src/mesa/shader/slang/Include/ShHandle.h

   1 //
   2 //Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
   3 //All rights reserved.
   4 //
   5 //Redistribution and use in source and binary forms, with or without
   6 //modification, are permitted provided that the following conditions
   7 //are met:
   8 //
   9 //    Redistributions of source code must retain the above copyright
  10 //    notice, this list of conditions and the following disclaimer.
  11 //
  12 //    Redistributions in binary form must reproduce the above
  13 //    copyright notice, this list of conditions and the following
  14 //    disclaimer in the documentation and/or other materials provided
  15 //    with the distribution.
  16 //
  17 //    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
  18 //    contributors may be used to endorse or promote products derived
  19 //    from this software without specific prior written permission.
  20 //
  21 //THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 //"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 //LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24 //FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  25 //COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26 //INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27 //BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28 //LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  29 //CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30 //LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  31 //ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32 //POSSIBILITY OF SUCH DAMAGE.
  33 //
  34
  35 #ifndef _SHHANDLE_INCLUDED_
  36 #define _SHHANDLE_INCLUDED_
  37
  38 //
  39 // Machine independent part of the compiler private objects
  40 // sent as ShHandle to the driver.
  41 //
  42 // This should not be included by driver code.
  43 //
  44
  45 #define SH_EXPORTING
  46 #include "../Public/ShaderLangExt.h"
  47 #include "InfoSink.h"
  48
  49 class TCompiler;
  50 class TLinker;
  51 class TUniformMap;
  52 namespace Lf {
  53     class TBindingList;
  54     class TLinker;
  55     class TLibrary;
  56 }
  57
  58 //
  59 // The base class used to back handles returned to the driver.
  60 //
  61 class TShHandleBase {
  62 public:
  63     TShHandleBase() { }
  64     virtual ~TShHandleBase() { }
  65     virtual TCompiler* getAsCompiler() { return 0; }
  66     virtual TLinker* getAsLinker() { return 0; }
  67     virtual Lf::TLinker* getAsNewLinker() { return 0; }
  68     virtual TUniformMap* getAsUniformMap() { return 0; }
  69     virtual Lf::TBindingList* getAsBindingList() { return 0; }
  70     virtual Lf::TLibrary* getAsLibrary() { return 0; }
  71 };
  72 //
  73 // The base class for the machine dependent linker to derive from
  74 // for managing where uniforms live.
  75 //
  76 class TUniformMap : public TShHandleBase {
  77 public:
  78     TUniformMap() { }
  79     virtual ~TUniformMap() { }
  80     virtual TUniformMap* getAsUniformMap() { return this; }
  81     virtual int getLocation(const char* name) = 0;
  82     virtual TInfoSink& getInfoSink() { return infoSink; }
  83     TInfoSink infoSink;
  84 };
  85
  86 class TIntermNode;
  87
  88 //
  89 // The base class for the machine dependent compiler to derive from
  90 // for managing object code from the compile.
  91 //
  92 class TCompiler : public TShHandleBase {
  93 public:
  94     TCompiler(EShLanguage l, TInfoSink& sink) : infoSink(sink) , language(l), haveValidObjectCode(false) { }
  95     virtual ~TCompiler() { }
  96     EShLanguage getLanguage() { return language; }
  97     virtual TInfoSink& getInfoSink() { return infoSink; }
  98
  99     virtual bool compile(TIntermNode* root) = 0;
 100
 101     virtual TCompiler* getAsCompiler() { return this; }
 102     virtual bool linkable() { return haveValidObjectCode; }
 103
 104     TInfoSink& infoSink;
 105 protected:
 106     EShLanguage language;
 107     bool haveValidObjectCode;
 108 };
 109
 110 //
 111 // Link operations are base on a list of compile results...
 112 //
 113 typedef TVector<TCompiler*> TCompilerList;
 114 typedef TVector<TShHandleBase*> THandleList;
 115
 116 //
 117 // The base class for the machine dependent linker to derive from
 118 // to manage the resulting executable.
 119 //
 120
 121 class TLinker : public TShHandleBase {
 122 public:
 123     TLinker(EShExecutable e, TInfoSink& iSink) :
 124         infoSink(iSink),
 125         executable(e),
 126         haveReturnableObjectCode(false),
 127         appAttributeBindings(0),
 128         fixedAttributeBindings(0),
 129                 excludedAttributes(0),
 130                 excludedCount(0),
 131         uniformBindings(0) { }
 132     virtual TLinker* getAsLinker() { return this; }
 133     virtual ~TLinker() { }
 134     virtual bool link(TCompilerList&, TUniformMap*) = 0;
 135     virtual bool link(THandleList&) { return false; }
 136     virtual void setAppAttributeBindings(const ShBindingTable* t)   { appAttributeBindings = t; }
 137     virtual void setFixedAttributeBindings(const ShBindingTable* t) { fixedAttributeBindings = t; }
 138         virtual void getAttributeBindings(ShBindingTable const **t) const = 0;
 139         virtual void setExcludedAttributes(const int* attributes, int count) { excludedAttributes = attributes; excludedCount = count; }
 140     virtual ShBindingTable* getUniformBindings() const  { return uniformBindings; }
 141     virtual const void* getObjectCode() const { return 0; } // a real compiler would be returning object code here
 142     virtual TInfoSink& getInfoSink() { return infoSink; }
 143     TInfoSink& infoSink;
 144 protected:
 145     EShExecutable executable;
 146     bool haveReturnableObjectCode;  // true when objectCode is acceptable to send to driver
 147
 148     const ShBindingTable* appAttributeBindings;
 149     const ShBindingTable* fixedAttributeBindings;
 150         const int* excludedAttributes;
 151         int excludedCount;
 152     ShBindingTable* uniformBindings;                // created by the linker
 153 };
 154
 155 //
 156 // This is the interface between the machine independent code
 157 // and the machine dependent code.
 158 //
 159 // The machine dependent code should derive from the classes
 160 // above. Then Construct*() and Delete*() will create and
 161 // destroy the machine dependent objects, which contain the
 162 // above machine independent information.
 163 //
 164 TCompiler* ConstructCompiler(EShLanguage, int);
 165
 166 TShHandleBase* ConstructLinker(EShExecutable, int);
 167 TShHandleBase* ConstructBindings();
 168 TShHandleBase* ConstructLibrary();
 169 void DeleteLinker(TShHandleBase*);
 170
 171 TUniformMap* ConstructUniformMap();
 172 void DeleteCompiler(TCompiler*);
 173
 174 void DeleteUniformMap(TUniformMap*);
 175 void freeTargetDependentData(void*);
 176
 177 #endif // _SHHANDLE_INCLUDED_