kc3-lang/angle/src/compiler/ParseHelper.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : apatrick@chromium.org
  Date : 2011-01-26 19:30:57
  Hash : 0f4cefe9
  Message : Map D3D calls and HLSL shaders back to GLES2 calls and GLSL ES shaders in PIX. This makes debugging and profiling using PIX a lot more convenient. The top level of events are the GLES calls with their arguments. Those can be expanded to see the D3D calls that were issued for a particular GLES call. When PIX is attached, the shaders are saved out to temporary files and referenced from the translated HLSL shaders via #line directives. This enabled source level debugging of the original GLSL from PIX for pixel and vertex shaders. The HLSL is also saved to a temporary file so that intrinsic functions like texture2D can be stepped into. It also avoids creating a text file in the current working directory, which has continued to be an issue. I made the dependency on d3d9.dll static again so it can be accessed by GetModuleHandle witihin DllMain. I added an EVENT macro that issues D3DPERF_BeginEvent and D3DPERF_EndEvent around a C++ block. I replaced TRACE with EVENT for all the entry points. I removed the tracing of shader source since the source is visible in PIX. The means by which the filename of the temporary shader file is passed into the shader compiler is a little clunky. I did it that way to avoid changing the function signatures and breaking folks using the translator. I plan to make the compiler respect #pragma optimize so that optimization can be disabled for debugging purposes. For now it just disables shader optimization in debug builds of ANGLE. Review URL: http://codereview.appspot.com/3945043 git-svn-id: https://angleproject.googlecode.com/svn/trunk@541 736b8ea6-26fd-11df-bfd4-992fa37f6226

• src/compiler/ParseHelper.h

• //
  // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  #ifndef _PARSER_HELPER_INCLUDED_
  #define _PARSER_HELPER_INCLUDED_
  
  #include "compiler/ExtensionBehavior.h"
  #include "compiler/localintermediate.h"
  #include "compiler/ShHandle.h"
  #include "compiler/SymbolTable.h"
  
  struct TMatrixFields {
      bool wholeRow;
      bool wholeCol;
      int row;
      int col;
  };
  
  struct TPragma {
      TPragma(bool o, bool d) : optimize(o), debug(d) { }
      bool optimize;
      bool debug;
      TPragmaTable pragmaTable;
  };
  
  //
  // The following are extra variables needed during parsing, grouped together so
  // they can be passed to the parser without needing a global.
  //
  struct TParseContext {
      TParseContext(TSymbolTable& symt, const TExtensionBehavior& ext, TIntermediate& interm, ShShaderType type, ShShaderSpec spec, int options, const char* sourcePath, TInfoSink& is) :
              intermediate(interm), symbolTable(symt), extensionBehavior(ext), infoSink(is), shaderType(type), shaderSpec(spec), compileOptions(options), sourcePath(sourcePath), treeRoot(0),
              recoveredFromError(false), numErrors(0), lexAfterType(false), loopNestingLevel(0),
              inTypeParen(false), scanner(NULL), contextPragma(true, false) {  }
      TIntermediate& intermediate; // to hold and build a parse tree
      TSymbolTable& symbolTable;   // symbol table that goes with the language currently being parsed
      TExtensionBehavior extensionBehavior;  // mapping between supported extensions and current behavior.
      TInfoSink& infoSink;
      ShShaderType shaderType;              // vertex or fragment language (future: pack or unpack)
      ShShaderSpec shaderSpec;              // The language specification compiler conforms to - GLES2 or WebGL.
      int compileOptions;
      const char* sourcePath;      // Path of source file or NULL.
      TIntermNode* treeRoot;       // root of parse tree being created
      bool recoveredFromError;     // true if a parse error has occurred, but we continue to parse
      int numErrors;
      bool lexAfterType;           // true if we've recognized a type, so can only be looking for an identifier
      int loopNestingLevel;        // 0 if outside all loops
      bool inTypeParen;            // true if in parentheses, looking only for an identifier
      const TType* currentFunctionType;  // the return type of the function that's currently being parsed
      bool functionReturnsValue;   // true if a non-void function has a return
  
      void error(TSourceLoc loc, const char *reason, const char* token,
                 const char* extraInfoFormat, ...);
      void warning(TSourceLoc loc, const char* reason, const char* token,
                   const char* extraInfoFormat, ...);
      bool reservedErrorCheck(int line, const TString& identifier);
      void recover();
  
      bool parseVectorFields(const TString&, int vecSize, TVectorFields&, int line);
      bool parseMatrixFields(const TString&, int matSize, TMatrixFields&, int line);
      void assignError(int line, const char* op, TString left, TString right);
      void unaryOpError(int line, const char* op, TString operand);
      void binaryOpError(int line, const char* op, TString left, TString right);
      bool precisionErrorCheck(int line, TPrecision precision, TBasicType type);
      bool lValueErrorCheck(int line, const char* op, TIntermTyped*);
      bool constErrorCheck(TIntermTyped* node);
      bool integerErrorCheck(TIntermTyped* node, const char* token);
      bool globalErrorCheck(int line, bool global, const char* token);
      bool constructorErrorCheck(int line, TIntermNode*, TFunction&, TOperator, TType*);
      bool arraySizeErrorCheck(int line, TIntermTyped* expr, int& size);
      bool arrayQualifierErrorCheck(int line, TPublicType type);
      bool arrayTypeErrorCheck(int line, TPublicType type);
      bool arrayErrorCheck(int line, TString& identifier, TPublicType type, TVariable*& variable);
      bool voidErrorCheck(int, const TString&, const TPublicType&);
      bool boolErrorCheck(int, const TIntermTyped*);
      bool boolErrorCheck(int, const TPublicType&);
      bool samplerErrorCheck(int line, const TPublicType& pType, const char* reason);
      bool structQualifierErrorCheck(int line, const TPublicType& pType);
      bool parameterSamplerErrorCheck(int line, TQualifier qualifier, const TType& type);
      bool containsSampler(TType& type);
      bool nonInitConstErrorCheck(int line, TString& identifier, TPublicType& type);
      bool nonInitErrorCheck(int line, TString& identifier, TPublicType& type);
      bool paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type);
      bool extensionErrorCheck(int line, const TString&);
      const TFunction* findFunction(int line, TFunction* pfnCall, bool *builtIn = 0);
      bool executeInitializer(TSourceLoc line, TString& identifier, TPublicType& pType,
                              TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable = 0);
      bool areAllChildConst(TIntermAggregate* aggrNode);
      TIntermTyped* addConstructor(TIntermNode*, const TType*, TOperator, TFunction*, TSourceLoc);
      TIntermTyped* foldConstConstructor(TIntermAggregate* aggrNode, const TType& type);
      TIntermTyped* constructStruct(TIntermNode*, TType*, int, TSourceLoc, bool subset);
      TIntermTyped* constructBuiltIn(const TType*, TOperator, TIntermNode*, TSourceLoc, bool subset);
      TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, TSourceLoc);
      TIntermTyped* addConstMatrixNode(int , TIntermTyped*, TSourceLoc);
      TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, TSourceLoc line);
      TIntermTyped* addConstStruct(TString& , TIntermTyped*, TSourceLoc);
      bool arraySetMaxSize(TIntermSymbol*, TType*, int, bool, TSourceLoc);
      void* scanner;
      struct TPragma contextPragma;
      TString HashErrMsg;
      bool AfterEOF;
  };
  
  int PaParseStrings(int count, const char* const string[], const int length[],
                     TParseContext* context);
  
  typedef TParseContext* TParseContextPointer;
  extern TParseContextPointer& GetGlobalParseContext();
  #define GlobalParseContext GetGlobalParseContext()
  
  typedef struct TThreadParseContextRec
  {
      TParseContext *lpGlobalParseContext;
  } TThreadParseContext;
  
  #endif // _PARSER_HELPER_INCLUDED_