HLSL: Abstract accepting an identifier.

hlsl/hlslGrammar.cpp

@@ -93,6 +93,19 @@ bool HlslGrammar::peekTokenClass(EHlslTokenClass tokenClass)
     return token.tokenClass == tokenClass;
 }
 
+// Only process the next token if it is an identifier.
+// Return true if it was an identifier.
+bool HlslGrammar::acceptIdentifier(HlslToken& idToken)
+{
+    if (peekTokenClass(EHTokIdentifier)) {
+        idToken = token;
+        advanceToken();
+        return true;
+    }
+
+    return false;
+}
+
 // compilationUnit
 //      : list of externalDeclaration
 //
@@ -137,11 +150,8 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& node)
         return false;
 
     // identifier
-    if (peekTokenClass(EHTokIdentifier)) {
+    HlslToken idToken;
-        TSourceLoc declLoc = token.loc;
+    if (acceptIdentifier(idToken)) {
-        TString* declName = token.string;
-        advanceToken();
-
         // = expression
         TIntermTyped* expressionNode = nullptr;
         if (acceptTokenClass(EHTokEqual)) {
@@ -153,12 +163,12 @@ bool HlslGrammar::acceptDeclaration(TIntermNode*& node)
 
         // SEMICOLON
         if (acceptTokenClass(EHTokSemicolon)) {
-            node = parseContext.declareVariable(declLoc, *declName, type, 0, expressionNode);
+            node = parseContext.declareVariable(idToken.loc, *idToken.string, type, 0, expressionNode);
             return true;
         }
 
         // function_parameters
-        TFunction* function = new TFunction(declName, type);
+        TFunction* function = new TFunction(idToken.string, type);
         if (acceptFunctionParameters(*function)) {
             // COLON semantic
             acceptSemantic();
@@ -345,13 +355,10 @@ bool HlslGrammar::acceptParameterDeclaration(TFunction& function)
         return false;
 
     // identifier
-    TString name;
+    HlslToken idToken;
-    if (peekTokenClass(EHTokIdentifier)) {
+    acceptIdentifier(idToken);
-        name = *token.string;
-        advanceToken();
-    }
 
-    TParameter param = { token.string, type };
+    TParameter param = { idToken.string, type };
     function.addParameter(param);
 
     return true;
@@ -390,9 +397,9 @@ bool HlslGrammar::acceptFunctionDefinition(TFunction& function, TIntermNode*& no
 bool HlslGrammar::acceptExpression(TIntermTyped*& node)
 {
     // identifier
-    if (peekTokenClass(EHTokIdentifier)) {
+    HlslToken idToken;
-        TIntermTyped* left = parseContext.handleVariable(token.loc, token.symbol, token.string);
+    if (acceptIdentifier(idToken)) {
-        advanceToken();
+        TIntermTyped* left = parseContext.handleVariable(idToken.loc, idToken.symbol, token.string);
 
         // operator?
         TOperator op;
@@ -401,9 +408,8 @@ bool HlslGrammar::acceptExpression(TIntermTyped*& node)
         TSourceLoc loc = token.loc;
 
         // identifier
-        if (peekTokenClass(EHTokIdentifier)) {
+        if (acceptIdentifier(idToken)) {
-            TIntermTyped* right = parseContext.handleVariable(token.loc, token.symbol, token.string);
+            TIntermTyped* right = parseContext.handleVariable(idToken.loc, idToken.symbol, token.string);
-            advanceToken();
             node = intermediate.addBinaryMath(op, left, right, loc);
             return true;
         }
@@ -624,10 +630,8 @@ bool HlslGrammar::acceptSemantic()
     // COLON
     if (acceptTokenClass(EHTokColon)) {
         // semantic
-        if (peekTokenClass(EHTokIdentifier)) {
+        HlslToken idToken;
-            TString* semantic = token.string;
+        if (! acceptIdentifier(idToken)) {
-            advanceToken();
-        } else {
             expected("semantic");
             return false;
         }

hlsl/hlslGrammar.h

@@ -57,7 +57,7 @@ namespace glslang {
         void advanceToken();
         bool acceptTokenClass(EHlslTokenClass);
         bool peekTokenClass(EHlslTokenClass);
-        bool lookAheadTokenClass(EHlslTokenClass);
+        bool acceptIdentifier(HlslToken&);
 
         bool acceptCompilationUnit();
         bool acceptDeclaration(TIntermNode*& node);

hlsl/hlslScanContext.h

@@ -34,8 +34,8 @@
 //
 
 //
-// This holds context specific to the GLSL scanner, which
+// This holds context specific to the HLSL scanner, which
-// sits between the preprocessor scanner and parser.
+// sits between the preprocessor scanner and HLSL parser.
 //
 
 #ifndef HLSLSCANCONTEXT_H_
@@ -49,20 +49,30 @@ namespace glslang {
 class TPpContext;
 class TPpToken;
 
+
+//
+// Everything needed to fully describe a token.
+//
 struct HlslToken {
-    TSourceLoc loc;
+    HlslToken() : isType(false), string(nullptr), symbol(nullptr) { loc.init(); }
-    EHlslTokenClass tokenClass;
+    TSourceLoc loc;                // location of token in the source
-    bool isType;
+    EHlslTokenClass tokenClass;    // what kind of token it is
-    union {
+    bool isType;                   // true if the token represents a user type
-        glslang::TString *string;
+    union {                        // what data the token holds
-        int i;
+        glslang::TString *string;  // for identifiers
+        int i;                     // for literals
         unsigned int u;
         bool b;
         double d;
     };
-    glslang::TSymbol* symbol;
+    glslang::TSymbol* symbol;      // if a symbol table lookup was done already, this is the result
 };
 
+//
+// The state of scanning and translating raw tokens to slightly richer
+// semantics, like knowing if an identifier is an existing symbol, or
+// user-defined type.
+//
 class HlslScanContext {
 public:
     HlslScanContext(TParseContextBase& parseContext, TPpContext& ppContext)