8e4dd21e63
- this takes care to add support to match the [behaviour of
DXC](34b6d0f91e/tools/clang/lib/Parse/HLSLRootSignature.cpp (L74))
acceptable floating point integers
Namely:
- Allow for specifying the decimal '.'
- Allow for specifying exponents with 'e' or 'E' and allow for 'f' to
denote an otherwise interpreted integer as a float
This pr is simply responsible of creating a token that could be
interpeted as a floating point integer by `NumericLiteralParser`. As
such, we are not required to validate that the special characters only
occur once and that 'f' is only at the end of the string. These will be
validated when invoking `NumericLiteralParser` during parsing.
Resolves #126565
138 lines
4.2 KiB
C++
138 lines
4.2 KiB
C++
//=== LexHLSLRootSignature.cpp - Lex Root Signature -----------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Lex/LexHLSLRootSignature.h"
|
|
|
|
namespace clang {
|
|
namespace hlsl {
|
|
|
|
using TokenKind = RootSignatureToken::Kind;
|
|
|
|
// Lexer Definitions
|
|
|
|
static bool isNumberChar(char C) {
|
|
return isdigit(C) // integer support
|
|
|| C == '.' // float support
|
|
|| C == 'e' || C == 'E' || C == '-' || C == '+' // exponent support
|
|
|| C == 'f' || C == 'F'; // explicit float support
|
|
}
|
|
|
|
RootSignatureToken RootSignatureLexer::lexToken() {
|
|
// Discard any leading whitespace
|
|
advanceBuffer(Buffer.take_while(isspace).size());
|
|
|
|
if (isEndOfBuffer())
|
|
return RootSignatureToken(TokenKind::end_of_stream, SourceLoc);
|
|
|
|
// Record where this token is in the text for usage in parser diagnostics
|
|
RootSignatureToken Result(SourceLoc);
|
|
|
|
char C = Buffer.front();
|
|
|
|
// Punctuators
|
|
switch (C) {
|
|
#define PUNCTUATOR(X, Y) \
|
|
case Y: { \
|
|
Result.TokKind = TokenKind::pu_##X; \
|
|
advanceBuffer(); \
|
|
return Result; \
|
|
}
|
|
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Number literal
|
|
if (isdigit(C) || C == '.') {
|
|
Result.NumSpelling = Buffer.take_while(isNumberChar);
|
|
|
|
// If all values are digits then we have an int literal
|
|
bool IsInteger = Result.NumSpelling.find_if_not(isdigit) == StringRef::npos;
|
|
|
|
Result.TokKind =
|
|
IsInteger ? TokenKind::int_literal : TokenKind::float_literal;
|
|
advanceBuffer(Result.NumSpelling.size());
|
|
return Result;
|
|
}
|
|
|
|
// All following tokens require at least one additional character
|
|
if (Buffer.size() <= 1) {
|
|
Result = RootSignatureToken(TokenKind::invalid, SourceLoc);
|
|
return Result;
|
|
}
|
|
|
|
// Peek at the next character to deteremine token type
|
|
char NextC = Buffer[1];
|
|
|
|
// Registers: [tsub][0-9+]
|
|
if ((C == 't' || C == 's' || C == 'u' || C == 'b') && isdigit(NextC)) {
|
|
// Convert character to the register type.
|
|
switch (C) {
|
|
case 'b':
|
|
Result.TokKind = TokenKind::bReg;
|
|
break;
|
|
case 't':
|
|
Result.TokKind = TokenKind::tReg;
|
|
break;
|
|
case 'u':
|
|
Result.TokKind = TokenKind::uReg;
|
|
break;
|
|
case 's':
|
|
Result.TokKind = TokenKind::sReg;
|
|
break;
|
|
default:
|
|
llvm_unreachable("Switch for an expected token was not provided");
|
|
}
|
|
|
|
advanceBuffer();
|
|
|
|
// Lex the integer literal
|
|
Result.NumSpelling = Buffer.take_while(isNumberChar);
|
|
advanceBuffer(Result.NumSpelling.size());
|
|
|
|
return Result;
|
|
}
|
|
|
|
// Keywords and Enums:
|
|
StringRef TokSpelling =
|
|
Buffer.take_while([](char C) { return isalnum(C) || C == '_'; });
|
|
|
|
// Define a large string switch statement for all the keywords and enums
|
|
auto Switch = llvm::StringSwitch<TokenKind>(TokSpelling);
|
|
#define KEYWORD(NAME) Switch.CaseLower(#NAME, TokenKind::kw_##NAME);
|
|
#define ENUM(NAME, LIT) Switch.CaseLower(LIT, TokenKind::en_##NAME);
|
|
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
|
|
|
|
// Then attempt to retreive a string from it
|
|
Result.TokKind = Switch.Default(TokenKind::invalid);
|
|
advanceBuffer(TokSpelling.size());
|
|
return Result;
|
|
}
|
|
|
|
RootSignatureToken RootSignatureLexer::consumeToken() {
|
|
// If we previously peeked then just return the previous value over
|
|
if (NextToken && NextToken->TokKind != TokenKind::end_of_stream) {
|
|
RootSignatureToken Result = *NextToken;
|
|
NextToken = std::nullopt;
|
|
return Result;
|
|
}
|
|
return lexToken();
|
|
}
|
|
|
|
RootSignatureToken RootSignatureLexer::peekNextToken() {
|
|
// Already peeked from the current token
|
|
if (NextToken)
|
|
return *NextToken;
|
|
|
|
NextToken = lexToken();
|
|
return *NextToken;
|
|
}
|
|
|
|
} // namespace hlsl
|
|
} // namespace clang
|