1//
2// Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
3// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6#ifndef _PARSER_HELPER_INCLUDED_
7#define _PARSER_HELPER_INCLUDED_
8
9#include "compiler/translator/Compiler.h"
10#include "compiler/translator/Diagnostics.h"
11#include "compiler/translator/DirectiveHandler.h"
12#include "compiler/translator/Intermediate.h"
13#include "compiler/translator/SymbolTable.h"
14#include "compiler/preprocessor/Preprocessor.h"
15
16struct TMatrixFields {
17    bool wholeRow;
18    bool wholeCol;
19    int row;
20    int col;
21};
22
23//
24// The following are extra variables needed during parsing, grouped together so
25// they can be passed to the parser without needing a global.
26//
27struct TParseContext {
28    TParseContext(TSymbolTable& symt, TExtensionBehavior& ext, TIntermediate& interm, sh::GLenum type, ShShaderSpec spec, int options, bool checksPrecErrors, const char* sourcePath, TInfoSink& is) :
29            intermediate(interm),
30            symbolTable(symt),
31            shaderType(type),
32            shaderSpec(spec),
33            compileOptions(options),
34            sourcePath(sourcePath),
35            treeRoot(0),
36            loopNestingLevel(0),
37            structNestingLevel(0),
38            currentFunctionType(NULL),
39            functionReturnsValue(false),
40            checksPrecisionErrors(checksPrecErrors),
41            defaultMatrixPacking(EmpColumnMajor),
42            defaultBlockStorage(EbsShared),
43            diagnostics(is),
44            shaderVersion(100),
45            directiveHandler(ext, diagnostics, shaderVersion),
46            preprocessor(&diagnostics, &directiveHandler),
47            scanner(NULL) {  }
48    TIntermediate& intermediate; // to hold and build a parse tree
49    TSymbolTable& symbolTable;   // symbol table that goes with the language currently being parsed
50    sh::GLenum shaderType;              // vertex or fragment language (future: pack or unpack)
51    ShShaderSpec shaderSpec;              // The language specification compiler conforms to - GLES2 or WebGL.
52    int shaderVersion;
53    int compileOptions;
54    const char* sourcePath;      // Path of source file or NULL.
55    TIntermNode* treeRoot;       // root of parse tree being created
56    int loopNestingLevel;        // 0 if outside all loops
57    int structNestingLevel;      // incremented while parsing a struct declaration
58    const TType* currentFunctionType;  // the return type of the function that's currently being parsed
59    bool functionReturnsValue;   // true if a non-void function has a return
60    bool checksPrecisionErrors;  // true if an error will be generated when a variable is declared without precision, explicit or implicit.
61    bool fragmentPrecisionHigh;  // true if highp precision is supported in the fragment language.
62    TLayoutMatrixPacking defaultMatrixPacking;
63    TLayoutBlockStorage defaultBlockStorage;
64    TString HashErrMsg;
65    TDiagnostics diagnostics;
66    TDirectiveHandler directiveHandler;
67    pp::Preprocessor preprocessor;
68    void* scanner;
69
70    int getShaderVersion() const { return shaderVersion; }
71    int numErrors() const { return diagnostics.numErrors(); }
72    TInfoSink& infoSink() { return diagnostics.infoSink(); }
73    void error(const TSourceLoc& loc, const char *reason, const char* token,
74               const char* extraInfo="");
75    void warning(const TSourceLoc& loc, const char* reason, const char* token,
76                 const char* extraInfo="");
77    void trace(const char* str);
78    void recover();
79
80    // This method is guaranteed to succeed, even if no variable with 'name' exists.
81    const TVariable *getNamedVariable(const TSourceLoc &location, const TString *name, const TSymbol *symbol);
82
83    bool parseVectorFields(const TString&, int vecSize, TVectorFields&, const TSourceLoc& line);
84    bool parseMatrixFields(const TString&, int matCols, int matRows, TMatrixFields&, const TSourceLoc& line);
85
86    bool reservedErrorCheck(const TSourceLoc& line, const TString& identifier);
87    void assignError(const TSourceLoc& line, const char* op, TString left, TString right);
88    void unaryOpError(const TSourceLoc& line, const char* op, TString operand);
89    void binaryOpError(const TSourceLoc& line, const char* op, TString left, TString right);
90    bool precisionErrorCheck(const TSourceLoc& line, TPrecision precision, TBasicType type);
91    bool lValueErrorCheck(const TSourceLoc& line, const char* op, TIntermTyped*);
92    bool constErrorCheck(TIntermTyped* node);
93    bool integerErrorCheck(TIntermTyped* node, const char* token);
94    bool globalErrorCheck(const TSourceLoc& line, bool global, const char* token);
95    bool constructorErrorCheck(const TSourceLoc& line, TIntermNode*, TFunction&, TOperator, TType*);
96    bool arraySizeErrorCheck(const TSourceLoc& line, TIntermTyped* expr, int& size);
97    bool arrayQualifierErrorCheck(const TSourceLoc& line, TPublicType type);
98    bool arrayTypeErrorCheck(const TSourceLoc& line, TPublicType type);
99    bool arrayErrorCheck(const TSourceLoc& line, const TString& identifier, const TPublicType &type, TVariable*& variable);
100    bool voidErrorCheck(const TSourceLoc&, const TString&, const TPublicType&);
101    bool boolErrorCheck(const TSourceLoc&, const TIntermTyped*);
102    bool boolErrorCheck(const TSourceLoc&, const TPublicType&);
103    bool samplerErrorCheck(const TSourceLoc& line, const TPublicType& pType, const char* reason);
104    bool structQualifierErrorCheck(const TSourceLoc& line, const TPublicType& pType);
105    bool locationDeclaratorListCheck(const TSourceLoc& line, const TPublicType &pType);
106    bool parameterSamplerErrorCheck(const TSourceLoc& line, TQualifier qualifier, const TType& type);
107    bool nonInitConstErrorCheck(const TSourceLoc& line, const TString& identifier, TPublicType& type, bool array);
108    bool nonInitErrorCheck(const TSourceLoc& line, const TString& identifier, const TPublicType& type, TVariable*& variable);
109    bool paramErrorCheck(const TSourceLoc& line, TQualifier qualifier, TQualifier paramQualifier, TType* type);
110    bool extensionErrorCheck(const TSourceLoc& line, const TString&);
111    bool singleDeclarationErrorCheck(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier);
112    bool layoutLocationErrorCheck(const TSourceLoc& location, const TLayoutQualifier &layoutQualifier);
113
114    const TPragma& pragma() const { return directiveHandler.pragma(); }
115    const TExtensionBehavior& extensionBehavior() const { return directiveHandler.extensionBehavior(); }
116    bool supportsExtension(const char* extension);
117    bool isExtensionEnabled(const char* extension) const;
118    void handleExtensionDirective(const TSourceLoc& loc, const char* extName, const char* behavior);
119    void handlePragmaDirective(const TSourceLoc& loc, const char* name, const char* value);
120
121    bool containsSampler(TType& type);
122    bool areAllChildConst(TIntermAggregate* aggrNode);
123    const TFunction* findFunction(const TSourceLoc& line, TFunction* pfnCall, int shaderVersion, bool *builtIn = 0);
124    bool executeInitializer(const TSourceLoc& line, const TString& identifier, TPublicType& pType,
125                            TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable = 0);
126
127    TPublicType addFullySpecifiedType(TQualifier qualifier, const TPublicType& typeSpecifier);
128    TPublicType addFullySpecifiedType(TQualifier qualifier, TLayoutQualifier layoutQualifier, const TPublicType& typeSpecifier);
129    TIntermAggregate* parseSingleDeclaration(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier);
130    TIntermAggregate* parseSingleArrayDeclaration(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier, const TSourceLoc& indexLocation, TIntermTyped *indexExpression);
131    TIntermAggregate* parseSingleInitDeclaration(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier, const TSourceLoc& initLocation, TIntermTyped *initializer);
132    TIntermAggregate* parseInvariantDeclaration(const TSourceLoc &invariantLoc, const TSourceLoc &identifierLoc, const TString *identifier, const TSymbol *symbol);
133
134    TIntermAggregate* parseDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, TSymbol *identifierSymbol, const TSourceLoc& identifierLocation, const TString &identifier);
135    TIntermAggregate* parseArrayDeclarator(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier, const TSourceLoc& arrayLocation, TIntermNode *declaratorList, TIntermTyped *indexExpression);
136    TIntermAggregate* parseInitDeclarator(TPublicType &publicType, TIntermAggregate *declaratorList, const TSourceLoc& identifierLocation, const TString &identifier, const TSourceLoc& initLocation, TIntermTyped *initializer);
137    void parseGlobalLayoutQualifier(const TPublicType &typeQualifier);
138    TFunction *addConstructorFunc(TPublicType publicType);
139    TIntermTyped* addConstructor(TIntermNode*, const TType*, TOperator, TFunction*, const TSourceLoc&);
140    TIntermTyped* foldConstConstructor(TIntermAggregate* aggrNode, const TType& type);
141    TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, const TSourceLoc&);
142    TIntermTyped* addConstMatrixNode(int , TIntermTyped*, const TSourceLoc&);
143    TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, const TSourceLoc& line);
144    TIntermTyped* addConstStruct(const TString &identifier, TIntermTyped *node, const TSourceLoc& line);
145    TIntermTyped* addIndexExpression(TIntermTyped *baseExpression, const TSourceLoc& location, TIntermTyped *indexExpression);
146    TIntermTyped* addFieldSelectionExpression(TIntermTyped *baseExpression, const TSourceLoc& dotLocation, const TString &fieldString, const TSourceLoc& fieldLocation);
147
148    TFieldList *addStructDeclaratorList(const TPublicType& typeSpecifier, TFieldList *fieldList);
149    TPublicType addStructure(const TSourceLoc& structLine, const TSourceLoc& nameLine, const TString *structName, TFieldList* fieldList);
150
151    TIntermAggregate* addInterfaceBlock(const TPublicType& typeQualifier, const TSourceLoc& nameLine, const TString& blockName, TFieldList* fieldList,
152                                        const TString* instanceName, const TSourceLoc& instanceLine, TIntermTyped* arrayIndex, const TSourceLoc& arrayIndexLine);
153
154    TLayoutQualifier parseLayoutQualifier(const TString &qualifierType, const TSourceLoc& qualifierTypeLine);
155    TLayoutQualifier parseLayoutQualifier(const TString &qualifierType, const TSourceLoc& qualifierTypeLine, const TString &intValueString, int intValue, const TSourceLoc& intValueLine);
156    TLayoutQualifier joinLayoutQualifiers(TLayoutQualifier leftQualifier, TLayoutQualifier rightQualifier);
157    TPublicType joinInterpolationQualifiers(const TSourceLoc &interpolationLoc, TQualifier interpolationQualifier,
158                                            const TSourceLoc &storageLoc, TQualifier storageQualifier);
159
160    // Performs an error check for embedded struct declarations.
161    // Returns true if an error was raised due to the declaration of
162    // this struct.
163    bool enterStructDeclaration(const TSourceLoc& line, const TString& identifier);
164    void exitStructDeclaration();
165
166    bool structNestingErrorCheck(const TSourceLoc& line, const TField& field);
167};
168
169int PaParseStrings(size_t count, const char* const string[], const int length[],
170                   TParseContext* context);
171
172#endif // _PARSER_HELPER_INCLUDED_
173