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

• Show log

  Commit

• Hash : e4249f02
  Author :
  Date : 2010-07-26T18:13:52
  

  Refactored the way symbol tables are initialized and stored. This was done in response to the addition of EShSpec.
  Symbol table entries depend on three things - language, spec (not now but may eventually), and built-in resources.
  We used to build two global symbol-tables - one for each language. During each compile, one of the symbol table was
  copied and resource-specific stuff was added. I have moved the symbol table to TCompiler that gets initilized when
  compiler is created and reused for each compile. This makes it much cleaner and extensible in case a spec requires
  special entries to be added to the symbol table.
  
  PS: Sorry for the long CL, but all of it needed to be done in one CL. I have verified that everything still compiles
  and passes all conformance tests.
  Review URL: http://codereview.appspot.com/1864044
  
  git-svn-id: https://angleproject.googlecode.com/svn/trunk@351 736b8ea6-26fd-11df-bfd4-992fa37f6226
  

Download

• src/compiler/ShHandle.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 _SHHANDLE_INCLUDED_
  #define _SHHANDLE_INCLUDED_
  
  //
  // Machine independent part of the compiler private objects
  // sent as ShHandle to the driver.
  //
  // This should not be included by driver code.
  //
  
  #include "GLSLANG/ShaderLang.h"
  
  #include "compiler/InfoSink.h"
  #include "compiler/SymbolTable.h"
  
  class TCompiler;
  class TIntermNode;
  
  //
  // The base class used to back handles returned to the driver.
  //
  class TShHandleBase {
  public:
      TShHandleBase() { }
      virtual ~TShHandleBase() { }
      virtual TCompiler* getAsCompiler() { return 0; }
  };
  
  //
  // The base class for the machine dependent compiler to derive from
  // for managing object code from the compile.
  //
  class TCompiler : public TShHandleBase {
  public:
      TCompiler(EShLanguage l, EShSpec s) : language(l), spec(s) { }
      virtual ~TCompiler() { }
  
      EShLanguage getLanguage() const { return language; }
      EShSpec getSpec() const { return spec; }
      TSymbolTable& getSymbolTable() { return symbolTable; }
      TInfoSink& getInfoSink() { return infoSink; }
  
      virtual bool compile(TIntermNode* root) = 0;
  
      virtual TCompiler* getAsCompiler() { return this; }
  
  protected:
      EShLanguage language;
      EShSpec spec;
  
      // Built-in symbol table for the given language, spec, and resources.
      // It is preserved from compile-to-compile.
      TSymbolTable symbolTable;
      // Output sink.
      TInfoSink infoSink;
  };
  
  //
  // This is the interface between the machine independent code
  // and the machine dependent code.
  //
  // The machine dependent code should derive from the classes
  // above. Then Construct*() and Delete*() will create and 
  // destroy the machine dependent objects, which contain the
  // above machine independent information.
  //
  TCompiler* ConstructCompiler(EShLanguage, EShSpec);
  void DeleteCompiler(TCompiler*);
  
  #endif // _SHHANDLE_INCLUDED_
  

Download