Skip to content

A
angle
Commit 06145236 by Jamie Madill
Options

Refactor style in ParseContext.h.

BUG=angleproject:995 Change-Id: I893785a068d0d5cf4afc18123896bf540e53a3e0 Reviewed-on: https://chromium-review.googlesource.com/270627Reviewed-by: 's avatarZhenyao Mo <zmo@chromium.org> Tested-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 95d34aaf
Showing with 198 additions and 130 deletions
src/compiler/translator/ParseContext.cpp
...@@ -653,7 +653,7 @@ bool TParseContext::parameterSamplerErrorCheck(const TSourceLoc& line, TQualifie ...@@ -653,7 +653,7 @@ bool TParseContext::parameterSamplerErrorCheck(const TSourceLoc& line, TQualifie
return false; return false;
} }
bool TParseContext::containsSampler(TType& type) bool TParseContext::containsSampler(const TType& type)
{ {
if (IsSampler(type.getBasicType())) if (IsSampler(type.getBasicType()))
return true; return true;
...@@ -750,12 +750,13 @@ bool TParseContext::arrayQualifierErrorCheck(const TSourceLoc &line, const TPubl ...@@ -750,12 +750,13 @@ bool TParseContext::arrayQualifierErrorCheck(const TSourceLoc &line, const TPubl
// //
// Returns true if there is an error. // Returns true if there is an error.
// //
bool TParseContext::arrayTypeErrorCheck(const TSourceLoc& line, TPublicType type) bool TParseContext::arrayTypeErrorCheck(const TSourceLoc& line, const TPublicType &type)
{ {
// //
// Can the type be an array? // Can the type be an array?
// //
if (type.array) { if (type.array)
{
error(line, "cannot declare arrays of arrays", TType(type).getCompleteString().c_str()); error(line, "cannot declare arrays of arrays", TType(type).getCompleteString().c_str());
return true; return true;
} }
...@@ -889,7 +890,7 @@ bool TParseContext::extensionErrorCheck(const TSourceLoc& line, const TString& e ...@@ -889,7 +890,7 @@ bool TParseContext::extensionErrorCheck(const TSourceLoc& line, const TString& e
// These checks are common for all declarations starting a declarator list, and declarators that follow an empty // These checks are common for all declarations starting a declarator list, and declarators that follow an empty
// declaration. // declaration.
// //
bool TParseContext::singleDeclarationErrorCheck(TPublicType &publicType, const TSourceLoc &identifierLocation) bool TParseContext::singleDeclarationErrorCheck(const TPublicType &publicType, const TSourceLoc &identifierLocation)
{ {
switch (publicType.qualifier) switch (publicType.qualifier)
{ {
...@@ -1095,7 +1096,7 @@ const TFunction* TParseContext::findFunction(const TSourceLoc& line, TFunction* ...@@ -1095,7 +1096,7 @@ const TFunction* TParseContext::findFunction(const TSourceLoc& line, TFunction*
// //
// Returns true on error, false if no error // Returns true on error, false if no error
// //
bool TParseContext::executeInitializer(const TSourceLoc &line, const TString &identifier, TPublicType &pType, bool TParseContext::executeInitializer(const TSourceLoc &line, const TString &identifier, const TPublicType &pType,
TIntermTyped *initializer, TIntermNode **intermNode) TIntermTyped *initializer, TIntermNode **intermNode)
{ {
ASSERT(intermNode != nullptr); ASSERT(intermNode != nullptr);
...@@ -1357,7 +1358,7 @@ TIntermAggregate *TParseContext::parseSingleArrayDeclaration(TPublicType &public ...@@ -1357,7 +1358,7 @@ TIntermAggregate *TParseContext::parseSingleArrayDeclaration(TPublicType &public
return intermediate.makeAggregate(symbol, identifierLocation); return intermediate.makeAggregate(symbol, identifierLocation);
} }
TIntermAggregate *TParseContext::parseSingleInitDeclaration(TPublicType &publicType, TIntermAggregate *TParseContext::parseSingleInitDeclaration(const TPublicType &publicType,
const TSourceLoc &identifierLocation, const TSourceLoc &identifierLocation,
const TString &identifier, const TString &identifier,
const TSourceLoc &initLocation, const TSourceLoc &initLocation,
...@@ -1539,7 +1540,7 @@ TIntermAggregate *TParseContext::parseArrayDeclarator(TPublicType &publicType, T ...@@ -1539,7 +1540,7 @@ TIntermAggregate *TParseContext::parseArrayDeclarator(TPublicType &publicType, T
return nullptr; return nullptr;
} }
TIntermAggregate *TParseContext::parseInitDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, TIntermAggregate *TParseContext::parseInitDeclarator(const TPublicType &publicType, TIntermAggregate *aggregateDeclaration,
const TSourceLoc &identifierLocation, const TString &identifier, const TSourceLoc &identifierLocation, const TString &identifier,
const TSourceLoc &initLocation, TIntermTyped *initializer) const TSourceLoc &initLocation, TIntermTyped *initializer)
{ {
...@@ -1576,7 +1577,7 @@ TIntermAggregate *TParseContext::parseInitDeclarator(TPublicType &publicType, TI ...@@ -1576,7 +1577,7 @@ TIntermAggregate *TParseContext::parseInitDeclarator(TPublicType &publicType, TI
} }
} }
TIntermAggregate *TParseContext::parseArrayInitDeclarator(TPublicType &publicType, TIntermAggregate *TParseContext::parseArrayInitDeclarator(const TPublicType &publicType,
TIntermAggregate *aggregateDeclaration, TIntermAggregate *aggregateDeclaration,
const TSourceLoc& identifierLocation, const TSourceLoc& identifierLocation,
const TString &identifier, const TString &identifier,
...@@ -1668,8 +1669,9 @@ void TParseContext::parseGlobalLayoutQualifier(const TPublicType &typeQualifier) ...@@ -1668,8 +1669,9 @@ void TParseContext::parseGlobalLayoutQualifier(const TPublicType &typeQualifier)
} }
} }
TFunction *TParseContext::addConstructorFunc(TPublicType publicType) TFunction *TParseContext::addConstructorFunc(const TPublicType &publicTypeIn)
{ {
TPublicType publicType = publicTypeIn;
TOperator op = EOpNull; TOperator op = EOpNull;
if (publicType.userDef) if (publicType.userDef)
{ {
......
src/compiler/translator/ParseContext.h
...@@ -13,7 +13,8 @@ ...@@ -13,7 +13,8 @@
#include "compiler/translator/SymbolTable.h" #include "compiler/translator/SymbolTable.h"
#include "compiler/preprocessor/Preprocessor.h" #include "compiler/preprocessor/Preprocessor.h"
struct TMatrixFields { struct TMatrixFields
{
bool wholeRow; bool wholeRow;
bool wholeCol; bool wholeCol;
int row; int row;
...@@ -24,18 +25,27 @@ struct TMatrixFields { ...@@ -24,18 +25,27 @@ struct TMatrixFields {
// The following are extra variables needed during parsing, grouped together so // The following are extra variables needed during parsing, grouped together so
// they can be passed to the parser without needing a global. // they can be passed to the parser without needing a global.
// //
struct TParseContext { struct TParseContext : angle::NonCopyable
TParseContext(TSymbolTable& symt, TExtensionBehavior& ext, TIntermediate& interm, sh::GLenum type, ShShaderSpec spec, int options, bool checksPrecErrors, TInfoSink& is, bool debugShaderPrecisionSupported) : {
intermediate(interm), TParseContext(TSymbolTable &symt,
TExtensionBehavior &ext,
TIntermediate &interm,
sh::GLenum type,
ShShaderSpec spec,
int options,
bool checksPrecErrors,
TInfoSink &is,
bool debugShaderPrecisionSupported)
: intermediate(interm),
symbolTable(symt), symbolTable(symt),
shaderType(type), shaderType(type),
shaderSpec(spec), shaderSpec(spec),
compileOptions(options), compileOptions(options),
treeRoot(0), treeRoot(nullptr),
mLoopNestingLevel(0), mLoopNestingLevel(0),
structNestingLevel(0), structNestingLevel(0),
mSwitchNestingLevel(0), mSwitchNestingLevel(0),
currentFunctionType(NULL), currentFunctionType(nullptr),
mFunctionReturnsValue(false), mFunctionReturnsValue(false),
checksPrecisionErrors(checksPrecErrors), checksPrecisionErrors(checksPrecErrors),
fragmentPrecisionHigh(false), fragmentPrecisionHigh(false),
...@@ -45,21 +55,22 @@ struct TParseContext { ...@@ -45,21 +55,22 @@ struct TParseContext {
shaderVersion(100), shaderVersion(100),
directiveHandler(ext, diagnostics, shaderVersion, debugShaderPrecisionSupported), directiveHandler(ext, diagnostics, shaderVersion, debugShaderPrecisionSupported),
preprocessor(&diagnostics, &directiveHandler), preprocessor(&diagnostics, &directiveHandler),
scanner(NULL), scanner(nullptr),
mDeferredSingleDeclarationErrorCheck(false) mDeferredSingleDeclarationErrorCheck(false)
{ {
} }
TIntermediate& intermediate; // to hold and build a parse tree
TSymbolTable& symbolTable; // symbol table that goes with the language currently being parsed TIntermediate &intermediate; // to hold and build a parse tree
TSymbolTable &symbolTable; // symbol table that goes with the language currently being parsed
sh::GLenum shaderType; // vertex or fragment language (future: pack or unpack) sh::GLenum shaderType; // vertex or fragment language (future: pack or unpack)
ShShaderSpec shaderSpec; // The language specification compiler conforms to - GLES2 or WebGL. ShShaderSpec shaderSpec; // The language specification compiler conforms to - GLES2 or WebGL.
int shaderVersion; int shaderVersion;
int compileOptions; int compileOptions;
TIntermNode* treeRoot; // root of parse tree being created TIntermNode *treeRoot; // root of parse tree being created
int mLoopNestingLevel; // 0 if outside all loops int mLoopNestingLevel; // 0 if outside all loops
int structNestingLevel; // incremented while parsing a struct declaration int structNestingLevel; // incremented while parsing a struct declaration
int mSwitchNestingLevel; // 0 if outside all switch statements int mSwitchNestingLevel; // 0 if outside all switch statements
const TType* currentFunctionType; // the return type of the function that's currently being parsed const TType *currentFunctionType; // the return type of the function that's currently being parsed
bool mFunctionReturnsValue; // true if a non-void function has a return bool mFunctionReturnsValue; // true if a non-void function has a return
bool checksPrecisionErrors; // true if an error will be generated when a variable is declared without precision, explicit or implicit. bool checksPrecisionErrors; // true if an error will be generated when a variable is declared without precision, explicit or implicit.
bool fragmentPrecisionHigh; // true if highp precision is supported in the fragment language. bool fragmentPrecisionHigh; // true if highp precision is supported in the fragment language.
...@@ -69,118 +80,170 @@ struct TParseContext { ...@@ -69,118 +80,170 @@ struct TParseContext {
TDiagnostics diagnostics; TDiagnostics diagnostics;
TDirectiveHandler directiveHandler; TDirectiveHandler directiveHandler;
pp::Preprocessor preprocessor; pp::Preprocessor preprocessor;
void* scanner; void *scanner;
int getShaderVersion() const { return shaderVersion; } int getShaderVersion() const { return shaderVersion; }
int numErrors() const { return diagnostics.numErrors(); } int numErrors() const { return diagnostics.numErrors(); }
TInfoSink& infoSink() { return diagnostics.infoSink(); } TInfoSink &infoSink() { return diagnostics.infoSink(); }
void error(const TSourceLoc& loc, const char *reason, const char* token, void error(const TSourceLoc &loc, const char *reason, const char *token,
const char* extraInfo=""); const char *extraInfo="");
void warning(const TSourceLoc& loc, const char* reason, const char* token, void warning(const TSourceLoc &loc, const char *reason, const char *token,
const char* extraInfo=""); const char *extraInfo="");
void recover(); void recover();
// This method is guaranteed to succeed, even if no variable with 'name' exists. // This method is guaranteed to succeed, even if no variable with 'name' exists.
const TVariable *getNamedVariable(const TSourceLoc &location, const TString *name, const TSymbol *symbol); const TVariable *getNamedVariable(const TSourceLoc &location, const TString *name, const TSymbol *symbol);
bool parseVectorFields(const TString&, int vecSize, TVectorFields&, const TSourceLoc& line); bool parseVectorFields(const TString&, int vecSize, TVectorFields&, const TSourceLoc &line);
bool parseMatrixFields(const TString&, int matCols, int matRows, TMatrixFields&, const TSourceLoc& line); bool parseMatrixFields(const TString&, int matCols, int matRows, TMatrixFields&, const TSourceLoc &line);
bool reservedErrorCheck(const TSourceLoc& line, const TString& identifier); bool reservedErrorCheck(const TSourceLoc &line, const TString &identifier);
void assignError(const TSourceLoc& line, const char* op, TString left, TString right); void assignError(const TSourceLoc &line, const char *op, TString left, TString right);
void unaryOpError(const TSourceLoc& line, const char* op, TString operand); void unaryOpError(const TSourceLoc &line, const char *op, TString operand);
void binaryOpError(const TSourceLoc& line, const char* op, TString left, TString right); void binaryOpError(const TSourceLoc &line, const char *op, TString left, TString right);
bool precisionErrorCheck(const TSourceLoc& line, TPrecision precision, TBasicType type); bool precisionErrorCheck(const TSourceLoc &line, TPrecision precision, TBasicType type);
bool lValueErrorCheck(const TSourceLoc& line, const char* op, TIntermTyped*); bool lValueErrorCheck(const TSourceLoc &line, const char *op, TIntermTyped*);
bool constErrorCheck(TIntermTyped* node); bool constErrorCheck(TIntermTyped *node);
bool integerErrorCheck(TIntermTyped* node, const char* token); bool integerErrorCheck(TIntermTyped *node, const char *token);
bool globalErrorCheck(const TSourceLoc& line, bool global, const char* token); bool globalErrorCheck(const TSourceLoc &line, bool global, const char *token);
bool constructorErrorCheck(const TSourceLoc& line, TIntermNode*, TFunction&, TOperator, TType*); bool constructorErrorCheck(const TSourceLoc &line, TIntermNode*, TFunction&, TOperator, TType*);
bool arraySizeErrorCheck(const TSourceLoc& line, TIntermTyped* expr, int& size); bool arraySizeErrorCheck(const TSourceLoc &line, TIntermTyped *expr, int &size);
bool arrayQualifierErrorCheck(const TSourceLoc &line, const TPublicType &type); bool arrayQualifierErrorCheck(const TSourceLoc &line, const TPublicType &type);
bool arrayTypeErrorCheck(const TSourceLoc& line, TPublicType type); bool arrayTypeErrorCheck(const TSourceLoc &line, const TPublicType &type);
bool voidErrorCheck(const TSourceLoc &line, const TString &identifier, const TBasicType &type); bool voidErrorCheck(const TSourceLoc &line, const TString &identifier, const TBasicType &type);
bool boolErrorCheck(const TSourceLoc&, const TIntermTyped*); bool boolErrorCheck(const TSourceLoc&, const TIntermTyped*);
bool boolErrorCheck(const TSourceLoc&, const TPublicType&); bool boolErrorCheck(const TSourceLoc&, const TPublicType&);
bool samplerErrorCheck(const TSourceLoc& line, const TPublicType& pType, const char* reason); bool samplerErrorCheck(const TSourceLoc &line, const TPublicType &pType, const char *reason);
bool locationDeclaratorListCheck(const TSourceLoc& line, const TPublicType &pType); bool locationDeclaratorListCheck(const TSourceLoc &line, const TPublicType &pType);
bool parameterSamplerErrorCheck(const TSourceLoc& line, TQualifier qualifier, const TType& type); bool parameterSamplerErrorCheck(const TSourceLoc &line, TQualifier qualifier, const TType &type);
bool paramErrorCheck(const TSourceLoc& line, TQualifier qualifier, TQualifier paramQualifier, TType* type); bool paramErrorCheck(const TSourceLoc &line, TQualifier qualifier, TQualifier paramQualifier, TType *type);
bool extensionErrorCheck(const TSourceLoc& line, const TString&); bool extensionErrorCheck(const TSourceLoc &line, const TString&);
bool singleDeclarationErrorCheck(TPublicType &publicType, const TSourceLoc &identifierLocation); bool singleDeclarationErrorCheck(const TPublicType &publicType, const TSourceLoc &identifierLocation);
bool layoutLocationErrorCheck(const TSourceLoc& location, const TLayoutQualifier &layoutQualifier); bool layoutLocationErrorCheck(const TSourceLoc &location, const TLayoutQualifier &layoutQualifier);
bool functionCallLValueErrorCheck(const TFunction *fnCandidate, TIntermAggregate *); bool functionCallLValueErrorCheck(const TFunction *fnCandidate, TIntermAggregate *);
void es3InvariantErrorCheck(const TQualifier qualifier, const TSourceLoc &invariantLocation); void es3InvariantErrorCheck(const TQualifier qualifier, const TSourceLoc &invariantLocation);
const TPragma& pragma() const { return directiveHandler.pragma(); } const TPragma &pragma() const { return directiveHandler.pragma(); }
const TExtensionBehavior& extensionBehavior() const { return directiveHandler.extensionBehavior(); } const TExtensionBehavior &extensionBehavior() const { return directiveHandler.extensionBehavior(); }
bool supportsExtension(const char* extension); bool supportsExtension(const char *extension);
bool isExtensionEnabled(const char* extension) const; bool isExtensionEnabled(const char *extension) const;
void handleExtensionDirective(const TSourceLoc& loc, const char* extName, const char* behavior); void handleExtensionDirective(const TSourceLoc &loc, const char *extName, const char *behavior);
void handlePragmaDirective(const TSourceLoc& loc, const char* name, const char* value, bool stdgl); void handlePragmaDirective(const TSourceLoc &loc, const char *name, const char *value, bool stdgl);
bool containsSampler(TType& type); bool containsSampler(const TType &type);
bool areAllChildConst(TIntermAggregate* aggrNode); bool areAllChildConst(TIntermAggregate *aggrNode);
const TFunction* findFunction(const TSourceLoc& line, TFunction* pfnCall, int inputShaderVersion, bool *builtIn = 0); const TFunction* findFunction(
bool executeInitializer(const TSourceLoc &line, const TString &identifier, TPublicType &pType, const TSourceLoc &line, TFunction *pfnCall, int inputShaderVersion, bool *builtIn = 0);
TIntermTyped *initializer, TIntermNode **intermNode); bool executeInitializer(const TSourceLoc &line,
const TString &identifier,
TPublicType addFullySpecifiedType(TQualifier qualifier, bool invariant, TLayoutQualifier layoutQualifier, const TPublicType &pType,
const TPublicType& typeSpecifier); TIntermTyped *initializer,
TIntermNode **intermNode);
TPublicType addFullySpecifiedType(TQualifier qualifier,
bool invariant,
TLayoutQualifier layoutQualifier,
const TPublicType &typeSpecifier);
TIntermAggregate *parseSingleDeclaration(TPublicType &publicType, TIntermAggregate *parseSingleDeclaration(TPublicType &publicType,
const TSourceLoc &identifierOrTypeLocation, const TString &identifier); const TSourceLoc &identifierOrTypeLocation,
const TString &identifier);
TIntermAggregate *parseSingleArrayDeclaration(TPublicType &publicType, TIntermAggregate *parseSingleArrayDeclaration(TPublicType &publicType,
const TSourceLoc &identifierLocation, const TString &identifier, const TSourceLoc &identifierLocation,
const TSourceLoc &indexLocation, TIntermTyped *indexExpression); const TString &identifier,
TIntermAggregate *parseSingleInitDeclaration(TPublicType &publicType, const TSourceLoc &indexLocation,
const TSourceLoc &identifierLocation, const TString &identifier, TIntermTyped *indexExpression);
const TSourceLoc &initLocation, TIntermTyped *initializer); TIntermAggregate *parseSingleInitDeclaration(const TPublicType &publicType,
const TSourceLoc &identifierLocation,
const TString &identifier,
const TSourceLoc &initLocation,
TIntermTyped *initializer);
// Parse a declaration like "type a[n] = initializer" // Parse a declaration like "type a[n] = initializer"
// Note that this does not apply to declarations like "type[n] a = initializer" // Note that this does not apply to declarations like "type[n] a = initializer"
TIntermAggregate *parseSingleArrayInitDeclaration(TPublicType &publicType, TIntermAggregate *parseSingleArrayInitDeclaration(TPublicType &publicType,
const TSourceLoc &identifierLocation, const TString &identifier, const TSourceLoc &identifierLocation,
const TSourceLoc &indexLocation, TIntermTyped *indexExpression, const TString &identifier,
const TSourceLoc &initLocation, TIntermTyped *initializer); const TSourceLoc &indexLocation,
TIntermTyped *indexExpression,
TIntermAggregate *parseInvariantDeclaration(const TSourceLoc &invariantLoc, const TSourceLoc &identifierLoc, const TSourceLoc &initLocation,
const TString *identifier, const TSymbol *symbol); TIntermTyped *initializer);
TIntermAggregate *parseDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, TIntermAggregate *parseInvariantDeclaration(const TSourceLoc &invariantLoc,
const TSourceLoc &identifierLocation, const TString &identifier); const TSourceLoc &identifierLoc,
TIntermAggregate *parseArrayDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, const TString *identifier,
const TSourceLoc &identifierLocation, const TString &identifier, const TSymbol *symbol);
const TSourceLoc &arrayLocation, TIntermTyped *indexExpression);
TIntermAggregate *parseInitDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, TIntermAggregate *parseDeclarator(TPublicType &publicType,
const TSourceLoc &identifierLocation, const TString &identifier, TIntermAggregate *aggregateDeclaration,
const TSourceLoc &initLocation, TIntermTyped *initializer); const TSourceLoc &identifierLocation,
const TString &identifier);
TIntermAggregate *parseArrayDeclarator(TPublicType &publicType,
TIntermAggregate *aggregateDeclaration,
const TSourceLoc &identifierLocation,
const TString &identifier,
const TSourceLoc &arrayLocation,
TIntermTyped *indexExpression);
TIntermAggregate *parseInitDeclarator(const TPublicType &publicType,
TIntermAggregate *aggregateDeclaration,
const TSourceLoc &identifierLocation,
const TString &identifier,
const TSourceLoc &initLocation,
TIntermTyped *initializer);
// Parse a declarator like "a[n] = initializer" // Parse a declarator like "a[n] = initializer"
TIntermAggregate *parseArrayInitDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, TIntermAggregate *parseArrayInitDeclarator(const TPublicType &publicType,
const TSourceLoc& identifierLocation, const TString &identifier, TIntermAggregate *aggregateDeclaration,
const TSourceLoc& indexLocation, TIntermTyped *indexExpression, const TSourceLoc &identifierLocation,
const TSourceLoc &initLocation, TIntermTyped *initializer); const TString &identifier,
const TSourceLoc &indexLocation,
TIntermTyped *indexExpression,
const TSourceLoc &initLocation,
TIntermTyped *initializer);
void parseGlobalLayoutQualifier(const TPublicType &typeQualifier); void parseGlobalLayoutQualifier(const TPublicType &typeQualifier);
TFunction *addConstructorFunc(TPublicType publicType); TFunction *addConstructorFunc(const TPublicType &publicType);
TIntermTyped* addConstructor(TIntermNode*, TType*, TOperator, TFunction*, const TSourceLoc&); TIntermTyped *addConstructor(TIntermNode *arguments,
TIntermTyped* foldConstConstructor(TIntermAggregate* aggrNode, const TType& type); TType *type,
TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, const TSourceLoc&); TOperator op,
TIntermTyped* addConstMatrixNode(int , TIntermTyped*, const TSourceLoc&); TFunction *fnCall,
TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, const TSourceLoc& line); const TSourceLoc &line);
TIntermTyped* addConstStruct(const TString &identifier, TIntermTyped *node, const TSourceLoc& line); TIntermTyped *foldConstConstructor(TIntermAggregate *aggrNode, const TType &type);
TIntermTyped* addIndexExpression(TIntermTyped *baseExpression, const TSourceLoc& location, TIntermTyped *indexExpression); TIntermTyped *addConstVectorNode(TVectorFields&, TIntermTyped*, const TSourceLoc&);
TIntermTyped* addFieldSelectionExpression(TIntermTyped *baseExpression, const TSourceLoc& dotLocation, const TString &fieldString, const TSourceLoc& fieldLocation); TIntermTyped *addConstMatrixNode(int, TIntermTyped*, const TSourceLoc&);
TIntermTyped *addConstArrayNode(int index, TIntermTyped *node, const TSourceLoc &line);
TFieldList *addStructDeclaratorList(const TPublicType& typeSpecifier, TFieldList *fieldList); TIntermTyped *addConstStruct(
TPublicType addStructure(const TSourceLoc& structLine, const TSourceLoc& nameLine, const TString *structName, TFieldList* fieldList); const TString &identifier, TIntermTyped *node, const TSourceLoc& line);
TIntermTyped *addIndexExpression(TIntermTyped *baseExpression,
TIntermAggregate* addInterfaceBlock(const TPublicType& typeQualifier, const TSourceLoc& nameLine, const TString& blockName, TFieldList* fieldList, const TSourceLoc& location,
const TString* instanceName, const TSourceLoc& instanceLine, TIntermTyped* arrayIndex, const TSourceLoc& arrayIndexLine); TIntermTyped *indexExpression);
TIntermTyped* addFieldSelectionExpression(TIntermTyped *baseExpression,
TLayoutQualifier parseLayoutQualifier(const TString &qualifierType, const TSourceLoc& qualifierTypeLine); const TSourceLoc &dotLocation,
TLayoutQualifier parseLayoutQualifier(const TString &qualifierType, const TSourceLoc& qualifierTypeLine, const TString &intValueString, int intValue, const TSourceLoc& intValueLine); const TString &fieldString,
const TSourceLoc &fieldLocation);
TFieldList *addStructDeclaratorList(const TPublicType &typeSpecifier, TFieldList *fieldList);
TPublicType addStructure(const TSourceLoc &structLine,
const TSourceLoc &nameLine,
const TString *structName,
TFieldList *fieldList);
TIntermAggregate* addInterfaceBlock(const TPublicType &typeQualifier,
const TSourceLoc &nameLine,
const TString &blockName,
TFieldList *fieldList,
const TString *instanceName,
const TSourceLoc &instanceLine,
TIntermTyped *arrayIndex,
const TSourceLoc& arrayIndexLine);
TLayoutQualifier parseLayoutQualifier(
const TString &qualifierType, const TSourceLoc &qualifierTypeLine);
TLayoutQualifier parseLayoutQualifier(const TString &qualifierType,
const TSourceLoc &qualifierTypeLine,
const TString &intValueString,
int intValue,
const TSourceLoc &intValueLine);
TLayoutQualifier joinLayoutQualifiers(TLayoutQualifier leftQualifier, TLayoutQualifier rightQualifier); TLayoutQualifier joinLayoutQualifiers(TLayoutQualifier leftQualifier, TLayoutQualifier rightQualifier);
TPublicType joinInterpolationQualifiers(const TSourceLoc &interpolationLoc, TQualifier interpolationQualifier, TPublicType joinInterpolationQualifiers(const TSourceLoc &interpolationLoc, TQualifier interpolationQualifier,
const TSourceLoc &storageLoc, TQualifier storageQualifier); const TSourceLoc &storageLoc, TQualifier storageQualifier);
...@@ -188,56 +251,59 @@ struct TParseContext { ...@@ -188,56 +251,59 @@ struct TParseContext {
// Performs an error check for embedded struct declarations. // Performs an error check for embedded struct declarations.
// Returns true if an error was raised due to the declaration of // Returns true if an error was raised due to the declaration of
// this struct. // this struct.
bool enterStructDeclaration(const TSourceLoc& line, const TString& identifier); bool enterStructDeclaration(const TSourceLoc &line, const TString &identifier);
void exitStructDeclaration(); void exitStructDeclaration();
bool structNestingErrorCheck(const TSourceLoc& line, const TField& field); bool structNestingErrorCheck(const TSourceLoc &line, const TField &field);
TIntermSwitch *addSwitch(TIntermTyped *init, TIntermAggregate *statementList, const TSourceLoc &loc); TIntermSwitch *addSwitch(TIntermTyped *init, TIntermAggregate *statementList, const TSourceLoc &loc);
TIntermCase *addCase(TIntermTyped *condition, const TSourceLoc &loc); TIntermCase *addCase(TIntermTyped *condition, const TSourceLoc &loc);
TIntermCase *addDefault(const TSourceLoc &loc); TIntermCase *addDefault(const TSourceLoc &loc);
TIntermTyped *addUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &); TIntermTyped *addUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &loc);
TIntermTyped *addUnaryMathLValue(TOperator op, TIntermTyped *child, const TSourceLoc &); TIntermTyped *addUnaryMathLValue(TOperator op, TIntermTyped *child, const TSourceLoc &loc);
TIntermTyped *addBinaryMath(TOperator op, TIntermTyped *left, TIntermTyped *right, TIntermTyped *addBinaryMath(
const TSourceLoc &); TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
TIntermTyped *addBinaryMathBooleanResult(TOperator op, TIntermTyped *left, TIntermTyped *right, TIntermTyped *addBinaryMathBooleanResult(
const TSourceLoc &); TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
TIntermTyped *addAssign(TOperator op, TIntermTyped *left, TIntermTyped *right, TIntermTyped *addAssign(
const TSourceLoc &loc); TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
TIntermBranch *addBranch(TOperator op, const TSourceLoc &loc); TIntermBranch *addBranch(TOperator op, const TSourceLoc &loc);
TIntermBranch *addBranch(TOperator op, TIntermTyped *returnValue, const TSourceLoc &loc); TIntermBranch *addBranch(TOperator op, TIntermTyped *returnValue, const TSourceLoc &loc);
TIntermTyped *addFunctionCallOrMethod(TFunction *fnCall, TIntermNode *paramNode, TIntermNode *thisNode, TIntermTyped *addFunctionCallOrMethod(TFunction *fnCall,
const TSourceLoc &loc, bool *fatalError); TIntermNode *paramNode,
TIntermNode *thisNode,
const TSourceLoc &loc,
bool *fatalError);
TIntermTyped *addTernarySelection(TIntermTyped *cond, TIntermTyped *trueBlock, TIntermTyped *falseBlock, TIntermTyped *addTernarySelection(
const TSourceLoc &line); TIntermTyped *cond, TIntermTyped *trueBlock, TIntermTyped *falseBlock, const TSourceLoc &line);
private: private:
bool declareVariable(const TSourceLoc &line, const TString &identifier, const TType &type, TVariable **variable); bool declareVariable(const TSourceLoc &line, const TString &identifier, const TType &type, TVariable **variable);
bool nonInitErrorCheck(const TSourceLoc &line, const TString &identifier, TPublicType *type); bool nonInitErrorCheck(const TSourceLoc &line, const TString &identifier, TPublicType *type);
TIntermTyped *addBinaryMathInternal(TOperator op, TIntermTyped *left, TIntermTyped *right, TIntermTyped *addBinaryMathInternal(
const TSourceLoc &loc); TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
TIntermTyped *createAssign(TOperator op, TIntermTyped *left, TIntermTyped *right, TIntermTyped *createAssign(
const TSourceLoc &loc); TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
// The funcReturnType parameter is expected to be non-null when the operation is a built-in function. // The funcReturnType parameter is expected to be non-null when the operation is a built-in function.
// It is expected to be null for other unary operators. // It is expected to be null for other unary operators.
TIntermTyped *createUnaryMath(TOperator op, TIntermTyped *child, const TSourceLoc &loc, TIntermTyped *createUnaryMath(
const TType *funcReturnType); TOperator op, TIntermTyped *child, const TSourceLoc &loc, const TType *funcReturnType);
// Return true if the checks pass // Return true if the checks pass
bool binaryOpCommonCheck(TOperator op, TIntermTyped *left, TIntermTyped *right, bool binaryOpCommonCheck(
const TSourceLoc &loc); TOperator op, TIntermTyped *left, TIntermTyped *right, const TSourceLoc &loc);
// Set to true when the last/current declarator list was started with an empty declaration. // Set to true when the last/current declarator list was started with an empty declaration.
bool mDeferredSingleDeclarationErrorCheck; bool mDeferredSingleDeclarationErrorCheck;
}; };
int PaParseStrings(size_t count, const char* const string[], const int length[], int PaParseStrings(
TParseContext* context); size_t count, const char *const string[], const int length[], TParseContext *context);
#endif // COMPILER_TRANSLATOR_PARSECONTEXT_H_ #endif // COMPILER_TRANSLATOR_PARSECONTEXT_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment