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/ShaderLang.h"
47 #include "../MachineIndependent/Versions.h"
48 #include "InfoSink.h"
49 
50 class TCompiler;
51 class TLinker;
52 class TUniformMap;
53 
54 //
55 // The base class used to back handles returned to the driver.
56 //
57 class TShHandleBase {
58 public:
TShHandleBase()59     TShHandleBase() { pool = new glslang::TPoolAllocator; }
~TShHandleBase()60     virtual ~TShHandleBase() { delete pool; }
getAsCompiler()61     virtual TCompiler* getAsCompiler() { return 0; }
getAsLinker()62     virtual TLinker* getAsLinker() { return 0; }
getAsUniformMap()63     virtual TUniformMap* getAsUniformMap() { return 0; }
getPool()64     virtual glslang::TPoolAllocator* getPool() const { return pool; }
65 private:
66     glslang::TPoolAllocator* pool;
67 };
68 
69 //
70 // The base class for the machine dependent linker to derive from
71 // for managing where uniforms live.
72 //
73 class TUniformMap : public TShHandleBase {
74 public:
TUniformMap()75     TUniformMap() { }
~TUniformMap()76     virtual ~TUniformMap() { }
getAsUniformMap()77     virtual TUniformMap* getAsUniformMap() { return this; }
78     virtual int getLocation(const char* name) = 0;
getInfoSink()79     virtual TInfoSink& getInfoSink() { return infoSink; }
80     TInfoSink infoSink;
81 };
82 
83 class TIntermNode;
84 
85 //
86 // The base class for the machine dependent compiler to derive from
87 // for managing object code from the compile.
88 //
89 class TCompiler : public TShHandleBase {
90 public:
TCompiler(EShLanguage l,TInfoSink & sink)91     TCompiler(EShLanguage l, TInfoSink& sink) : infoSink(sink) , language(l), haveValidObjectCode(false) { }
~TCompiler()92     virtual ~TCompiler() { }
getLanguage()93     EShLanguage getLanguage() { return language; }
getInfoSink()94     virtual TInfoSink& getInfoSink() { return infoSink; }
95 
96     virtual bool compile(TIntermNode* root, int version = 0, EProfile profile = ENoProfile) = 0;
97 
getAsCompiler()98     virtual TCompiler* getAsCompiler() { return this; }
linkable()99     virtual bool linkable() { return haveValidObjectCode; }
100 
101     TInfoSink& infoSink;
102 protected:
103     TCompiler& operator=(TCompiler&);
104 
105     EShLanguage language;
106     bool haveValidObjectCode;
107 };
108 
109 //
110 // Link operations are based on a list of compile results...
111 //
112 typedef glslang::TVector<TCompiler*> TCompilerList;
113 typedef glslang::TVector<TShHandleBase*> THandleList;
114 
115 //
116 // The base class for the machine dependent linker to derive from
117 // to manage the resulting executable.
118 //
119 
120 class TLinker : public TShHandleBase {
121 public:
TLinker(EShExecutable e,TInfoSink & iSink)122     TLinker(EShExecutable e, TInfoSink& iSink) :
123         infoSink(iSink),
124         executable(e),
125         haveReturnableObjectCode(false),
126         appAttributeBindings(0),
127         fixedAttributeBindings(0),
128         excludedAttributes(0),
129         excludedCount(0),
130         uniformBindings(0) { }
getAsLinker()131     virtual TLinker* getAsLinker() { return this; }
~TLinker()132     virtual ~TLinker() { }
133     virtual bool link(TCompilerList&, TUniformMap*) = 0;
link(THandleList &)134     virtual bool link(THandleList&) { return false; }
setAppAttributeBindings(const ShBindingTable * t)135     virtual void setAppAttributeBindings(const ShBindingTable* t)   { appAttributeBindings = t; }
setFixedAttributeBindings(const ShBindingTable * t)136     virtual void setFixedAttributeBindings(const ShBindingTable* t) { fixedAttributeBindings = t; }
137     virtual void getAttributeBindings(ShBindingTable const **t) const = 0;
setExcludedAttributes(const int * attributes,int count)138     virtual void setExcludedAttributes(const int* attributes, int count) { excludedAttributes = attributes; excludedCount = count; }
getUniformBindings()139     virtual ShBindingTable* getUniformBindings() const  { return uniformBindings; }
getObjectCode()140     virtual const void* getObjectCode() const { return 0; } // a real compiler would be returning object code here
getInfoSink()141     virtual TInfoSink& getInfoSink() { return infoSink; }
142     TInfoSink& infoSink;
143 protected:
144     TLinker& operator=(TLinker&);
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 void DeleteLinker(TShHandleBase*);
169 void DeleteBindingList(TShHandleBase* bindingList);
170 
171 TUniformMap* ConstructUniformMap();
172 void DeleteCompiler(TCompiler*);
173 
174 void DeleteUniformMap(TUniformMap*);
175 
176 #endif // _SHHANDLE_INCLUDED_
177