LCOV - code coverage report
Current view: directory - gfx/angle/src/compiler - ParseHelper.h (source / functions) Found Hit Coverage
Test: app.info Lines: 5 0 0.0 %
Date: 2012-06-02 Functions: 4 0 0.0 %

       1                 : //
       2                 : // Copyright (c) 2002-2010 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/ExtensionBehavior.h"
      10                 : #include "compiler/localintermediate.h"
      11                 : #include "compiler/ShHandle.h"
      12                 : #include "compiler/SymbolTable.h"
      13                 : 
      14                 : struct TMatrixFields {
      15                 :     bool wholeRow;
      16                 :     bool wholeCol;
      17                 :     int row;
      18                 :     int col;
      19                 : };
      20                 : 
      21               0 : struct TPragma {
      22               0 :     TPragma(bool o, bool d) : optimize(o), debug(d) { }
      23                 :     bool optimize;
      24                 :     bool debug;
      25                 :     TPragmaTable pragmaTable;
      26                 : };
      27                 : 
      28                 : //
      29                 : // The following are extra variables needed during parsing, grouped together so
      30                 : // they can be passed to the parser without needing a global.
      31                 : //
      32               0 : struct TParseContext {
      33               0 :     TParseContext(TSymbolTable& symt, TExtensionBehavior& ext, TIntermediate& interm, ShShaderType type, ShShaderSpec spec, int options, bool checksPrecErrors, const char* sourcePath, TInfoSink& is) :
      34                 :             intermediate(interm),
      35                 :             symbolTable(symt),
      36                 :             extensionBehavior(ext),
      37                 :             infoSink(is),
      38                 :             shaderType(type),
      39                 :             shaderSpec(spec),
      40                 :             compileOptions(options),
      41                 :             sourcePath(sourcePath),
      42                 :             treeRoot(0),
      43                 :             numErrors(0),
      44                 :             lexAfterType(false),
      45                 :             loopNestingLevel(0),
      46                 :             structNestingLevel(0),
      47                 :             inTypeParen(false),
      48                 :             currentFunctionType(NULL),
      49                 :             functionReturnsValue(false),
      50                 :             checksPrecisionErrors(checksPrecErrors),
      51                 :             contextPragma(true, false),
      52               0 :             scanner(NULL) {  }
      53                 :     TIntermediate& intermediate; // to hold and build a parse tree
      54                 :     TSymbolTable& symbolTable;   // symbol table that goes with the language currently being parsed
      55                 :     TExtensionBehavior& extensionBehavior;  // mapping between supported extensions and current behavior.
      56                 :     TInfoSink& infoSink;
      57                 :     ShShaderType shaderType;              // vertex or fragment language (future: pack or unpack)
      58                 :     ShShaderSpec shaderSpec;              // The language specification compiler conforms to - GLES2 or WebGL.
      59                 :     int compileOptions;
      60                 :     const char* sourcePath;      // Path of source file or NULL.
      61                 :     TIntermNode* treeRoot;       // root of parse tree being created
      62                 :     int numErrors;
      63                 :     bool lexAfterType;           // true if we've recognized a type, so can only be looking for an identifier
      64                 :     int loopNestingLevel;        // 0 if outside all loops
      65                 :     int structNestingLevel;      // incremented while parsing a struct declaration
      66                 :     bool inTypeParen;            // true if in parentheses, looking only for an identifier
      67                 :     const TType* currentFunctionType;  // the return type of the function that's currently being parsed
      68                 :     bool functionReturnsValue;   // true if a non-void function has a return
      69                 :     bool checksPrecisionErrors;  // true if an error will be generated when a variable is declared without precision, explicit or implicit.
      70                 :     struct TPragma contextPragma;
      71                 :     TString HashErrMsg;
      72                 :     bool AfterEOF;
      73                 :     void* scanner;
      74                 : 
      75                 :     void error(TSourceLoc loc, const char *reason, const char* token,
      76                 :                const char* extraInfoFormat, ...);
      77                 :     void warning(TSourceLoc loc, const char* reason, const char* token,
      78                 :                  const char* extraInfoFormat, ...);
      79                 :     void recover();
      80                 : 
      81                 :     bool parseVectorFields(const TString&, int vecSize, TVectorFields&, int line);
      82                 :     bool parseMatrixFields(const TString&, int matSize, TMatrixFields&, int line);
      83                 : 
      84                 :     bool reservedErrorCheck(int line, const TString& identifier);
      85                 :     void assignError(int line, const char* op, TString left, TString right);
      86                 :     void unaryOpError(int line, const char* op, TString operand);
      87                 :     void binaryOpError(int line, const char* op, TString left, TString right);
      88                 :     bool precisionErrorCheck(int line, TPrecision precision, TBasicType type);
      89                 :     bool lValueErrorCheck(int line, const char* op, TIntermTyped*);
      90                 :     bool constErrorCheck(TIntermTyped* node);
      91                 :     bool integerErrorCheck(TIntermTyped* node, const char* token);
      92                 :     bool globalErrorCheck(int line, bool global, const char* token);
      93                 :     bool constructorErrorCheck(int line, TIntermNode*, TFunction&, TOperator, TType*);
      94                 :     bool arraySizeErrorCheck(int line, TIntermTyped* expr, int& size);
      95                 :     bool arrayQualifierErrorCheck(int line, TPublicType type);
      96                 :     bool arrayTypeErrorCheck(int line, TPublicType type);
      97                 :     bool arrayErrorCheck(int line, TString& identifier, TPublicType type, TVariable*& variable);
      98                 :     bool voidErrorCheck(int, const TString&, const TPublicType&);
      99                 :     bool boolErrorCheck(int, const TIntermTyped*);
     100                 :     bool boolErrorCheck(int, const TPublicType&);
     101                 :     bool samplerErrorCheck(int line, const TPublicType& pType, const char* reason);
     102                 :     bool structQualifierErrorCheck(int line, const TPublicType& pType);
     103                 :     bool parameterSamplerErrorCheck(int line, TQualifier qualifier, const TType& type);
     104                 :     bool nonInitConstErrorCheck(int line, TString& identifier, TPublicType& type);
     105                 :     bool nonInitErrorCheck(int line, TString& identifier, TPublicType& type, TVariable*& variable);
     106                 :     bool paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type);
     107                 :     bool extensionErrorCheck(int line, const TString&);
     108                 :     bool supportsExtension(const char* extension);
     109                 : 
     110                 :     bool containsSampler(TType& type);
     111                 :     bool areAllChildConst(TIntermAggregate* aggrNode);
     112                 :     const TFunction* findFunction(int line, TFunction* pfnCall, bool *builtIn = 0);
     113                 :     bool executeInitializer(TSourceLoc line, TString& identifier, TPublicType& pType,
     114                 :                             TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable = 0);
     115                 :     bool arraySetMaxSize(TIntermSymbol*, TType*, int, bool, TSourceLoc);
     116                 : 
     117                 :     TIntermTyped* addConstructor(TIntermNode*, const TType*, TOperator, TFunction*, TSourceLoc);
     118                 :     TIntermTyped* foldConstConstructor(TIntermAggregate* aggrNode, const TType& type);
     119                 :     TIntermTyped* constructStruct(TIntermNode*, TType*, int, TSourceLoc, bool subset);
     120                 :     TIntermTyped* constructBuiltIn(const TType*, TOperator, TIntermNode*, TSourceLoc, bool subset);
     121                 :     TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, TSourceLoc);
     122                 :     TIntermTyped* addConstMatrixNode(int , TIntermTyped*, TSourceLoc);
     123                 :     TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, TSourceLoc line);
     124                 :     TIntermTyped* addConstStruct(TString& , TIntermTyped*, TSourceLoc);
     125                 : 
     126                 :     // Performs an error check for embedded struct declarations.
     127                 :     // Returns true if an error was raised due to the declaration of
     128                 :     // this struct.
     129                 :     bool enterStructDeclaration(TSourceLoc line, const TString& identifier);
     130                 :     void exitStructDeclaration();
     131                 : 
     132                 :     bool structNestingErrorCheck(TSourceLoc line, const TType& fieldType);
     133                 : };
     134                 : 
     135                 : int PaParseStrings(int count, const char* const string[], const int length[],
     136                 :                    TParseContext* context);
     137                 : 
     138                 : typedef TParseContext* TParseContextPointer;
     139                 : extern TParseContextPointer& GetGlobalParseContext();
     140                 : #define GlobalParseContext GetGlobalParseContext()
     141                 : 
     142                 : typedef struct TThreadParseContextRec
     143                 : {
     144                 :     TParseContext *lpGlobalParseContext;
     145                 : } TThreadParseContext;
     146                 : 
     147                 : #endif // _PARSER_HELPER_INCLUDED_

Generated by: LCOV version 1.7