#include "Public/ShaderLang.h"
+namespace glslang {
+
OS_TLSIndex ThreadInitializeIndex = OS_INVALID_TLS_INDEX;
bool InitProcess()
return success;
}
+
+} // end namespace glslang
#include "osinclude.h"
+namespace glslang {
bool InitProcess();
bool InitThread();
bool DetachThread();
bool DetachProcess();
+} // end namespace glslang
+
#endif // __INITIALIZEDLL_H
ShBindingTable FixedAttributeTable = { 3, FixedAttributeBindings };
-static EShLanguage FindLanguage(const std::string& name);
+EShLanguage FindLanguage(const std::string& name);
bool CompileFile(const char *fileName, ShHandle, int options, const TBuiltInResource*);
void usage();
void FreeFileData(char **data);
// .geom = geometry
// .frag = fragment
//
-static EShLanguage FindLanguage(const std::string& name)
+EShLanguage FindLanguage(const std::string& name)
{
size_t ext = name.rfind('.');
if (ext == std::string::npos) {
std::list<std::string> worklist;
};
-};
+} // end namespace glslang
#endif // WORKLIST_H_INCLUDED
Testing
- thread safety
-Interfacing
- - finish putting into a glslang namespace
-
-Shader Linking Validation
+Link Validation
- ensure no static references thrown away
- Cross-stage linking
- - type consistency check of uniform and ins <-> outs, both variables and blocks, stage-specific arrayness matching
- - location/binding/index check
- - matching initializers for uniforms
- - mixed es/non-es profiles
- - statically consumed input not produced by previous stage
- - matching between gl_PerVertex blocks and gl_PerFragment blocks
- - compute shader not with other stages
- Intra-stage linking
- - exactly one main
- - type consistency check of uniforms, globals, ins, and outs, both variables and blocks
- - location/component/binding/index/offset match check
- - location/component aliasing (except desktop vertex shader inputs)
- - geometry shader input array sizes and input layout qualifier declaration
- - compute shader layout(local_size_*) matching
- - mixed es/non-es profiles
- - matching initializers for globals
- - recursion for both functions and subroutines
- - matching redeclarations of interface blocks
- - read or write to both gl_ClipVertex and gl_ClipDistance
- - write to only one of gl_FragColor, gl_FragData, or user-declared
- - 4.4: overlapping transform/feedback offsets, offset/stride overflow checks, and stride matching
+ Cross-stage linking
+ - type consistency check of uniform and ins <-> outs, both variables and blocks, stage-specific arrayness matching
+ - location/binding/index check
+ - matching initializers for uniforms
+ - mixed es/non-es profiles
+ - statically consumed input not produced by previous stage
+ - matching between gl_PerVertex blocks and gl_PerFragment blocks
+ - compute shader not with other stages
+ - 1.3: deprecated mixing fixed vertex/fragment stage with programmable fragment/vertex stage.
+ - 4.3: remove cross-version linking restrictions.
+ - 4.3: Allow mismatches in interpolation and auxiliary qualification across stages.
+ Intra-stage linking
+ - exactly one main
+ - type consistency check of uniforms, globals, ins, and outs, both variables and blocks
+ - location/component/binding/index/offset match check
+ - location/component aliasing (except desktop vertex shader inputs)
+ - geometry shader input array sizes and input layout qualifier declaration
+ - compute shader layout(local_size_*) matching
+ - mixed es/non-es profiles
+ - matching initializers for globals
+ - recursion for both functions and subroutines
+ - Even the potential for recursion through subroutine uniforms is an error.
+ - matching redeclarations of interface blocks
+ - read or write to both gl_ClipVertex and gl_ClipDistance
+ - write to only one of gl_FragColor, gl_FragData, or user-declared
+ - 4.3: Be clear that early_fragment_tests is only needed in one fragment-stage compilation unit.
+ - 4.3: Be clear that implicit array sizing is only within a stage, not cross stage.
+ - 4.4: overlapping transform/feedback offsets, offset/stride overflow checks, and stride matching
-Functionality to Implement/Finish
+Shader Functionality to Implement/Finish
ESSL 3.0
- "const" compile-time constant propagation in the front-end has to be complete, for all built-in functions
GLSL 1.2
- Handle multiple compilation units per stage
- - Allow initializers on uniform declarations. The value is set at link time.
+ - Allow initializers on uniform declarations
- signature matching takes type conversions into account, ambiguity is an error
GLSL 1.3
. flat is for both user and predeclared built-in in/out variables
- non-perspective (linear) interpolation (noperspective)
- add gl_ClipDistance[] to both vertex and fragment shaders
- only statically used built-ins have to be redeclared as flat
- - Link: Deprecated mixing fixed vertex/fragment stage with programmable fragment/vertex stage.
- Deprecated gl_ClipVertex
- deprecate almost all built-in state
- ftransform() is deprecated
rather than relying on gl_MaxVaryingComponents. Also, corrected gl_MaxVaryingComponents to be 60 instead of 64.
- Added gl_PrimitiveID as an input to fragment shaders.
- Added gl_FragCoord qualifiers origin_upper_left, and pixel_center_integer to modify the values returned by gl_FragCoord (and have no affect on any other aspect of the pipeline or language).
- - including redeclaration of gl_FragCoord that adds nothing
+ - including redeclaration of gl_FragCoord that adds nothing
- Added support for multi-sample textures through sampler2DMS and sampler2DMSArray support in texelFetch() and textureSize().
- Broadened interface blocks from just uniforms to in and out interfaces as well.
- Broaden array usage to include vertex shader inputs (vertex in).
- Added geometry shaders. This includes targeting layers in FBO rendering.
- geometry shader layouts: they must be declared, telling the system the primitive input and output types and maximum number of vertices.
- Added geometry shader constants.
- - gl_FragCoord qualifiers use the layout(): origin_upper_left and pixel_center_integer.
- Broaden structure usage to include geometry inputs and geometry outputs.
GLSL 4.0
- tessellation control stage and tessellation evaluation stage. Includes barrier() built-in for synchronization.
- Sampler arrays can take a variable index now, as long as it's value is uniform for all uses.
- Per-sample shading. Including sample input mask gl_SampleMaskIn[] and per-sample interpolation, with explicit interpolation built-ins interpolateAtCentroid(), interpolateAtSample(), and interpolateAtOffset().
- New precise qualifier to disallow optimizations that re-order operations or treat different instances of the same operator with different precision.
- - Add a fused multiply andadd built-in, fma(), in relation to the new precise qualifier. (Because \93a * b + c\94 will require two operations under new rules for precise.)
+ - Add a fused multiply and add built-in, fma(), in relation to the new precise qualifier. (Because \93a * b + c\94 will require two operations under new rules for precise.)
- Added new built-in floating-point functions
- frexp() and ldexp()
- packUnorm2x16(), packUnorm4x8(),packSnorm4x8(), and packDouble2x32()
GLSL 4.1
- Support for partitioning shaders into multiple programs to provide light-weight mixing of different shader stages.
(GL_ARB_separate_shader_objects)
- - layout qualifiers
- - redeclaration of input/output blocks
- - ...
+ - layout qualifiers
+ - redeclaration of input/output blocks
+ - ...
- Add 64-bit floating-point attributes for vertex shader inputs.
- Support viewport arrays so where the geometry shader selects which viewport array will transform its output.
GLSL 4.2
- - Add 420-style function signature matching rules
+ - Add 420-style function signature matching rules (or did this start in 4.0?)
+ Move these previously deprecated features to be only in the compatibility profile:
+ The keyword attribute for vertex shader inputs. (Use in instead.)
+ The keyword varying for inputs and outputs. (Use in and out instead.)
+ The built-in variables gl_FragColor and gl_FragData. (Use out instead.)
+ Built-in constants related to these.
+ Change from ASCII to UTF-8 for the language character set and also allow any characters inside comments (except the byte value 0),
- including '\'.
+ including '\'.
+ Add line-continuation using '\', as in C++.
+ ES convergence
+ Clarify that .xyzwxy.xy is illegal, as it temporarily makes a \93vec6\94.
- can read/write/modify images from a shader, through new built-in functions
- qualifiers can act independently on the opaque shader variable and the backing image, so extra qualifiers can be used to separately qualify these
+ Variables declared in if and else statements are scoped only to the end of those statements, especially for non-compound statements
- Note, this is not backward compatible, it may depend on #version.
+ Note, this is not backward compatible, it may depend on #version.
- Allow implicit conversions of return values to the declared type of the function.
- The const keyword can be used to declare variables within a function body with initializer expressions that are not constant expressions.
+ Qualifiers on variable declarations no longer have to follow a strict order. The layout qualifier can be used multiple times, and multiple parameter qualifiers can be used.
- Allow .length() to be applied to vectors and matrices, returning the number of components or columns.
+ Clarify that .length() returns an int type and can be used as a constant integer expression.
- Allow swizzle operations on scalars.
- - Even the potential for recursion through subroutine uniforms is an error.
- Positive signed decimal literals, as well as octal and hexadecimal, can set all 32 bits. This includes setting the sign bit to create a negative value.
- Make GLSL consistent with the API regarding user clipping, by no longer referring to gl_Positionwhen gl_ClipVertex is not written. Rather, user clipping becomes undefined.
- Minor consistency fixes, corrections
GL_ARB_explicit_uniform_location extension.
- Accept ES GLSL shader #version statements, which will request ES functionality for ES GLSL
versions 100 and 300, as per the GL_ARB_ES3_compatibility extension.
- - Clarified about 90 errors as being either compile time, link time, or either.
- Clarify and correct scoping rules to what would normally be expected and what was intended.
(Function parameters and body nest inside global space. Loop variables and body nest inside
loop scope.)
- There are no digraphs (trigraphs were already disallowed).
- Remove the CPP difference that it is a compile-time error to use #if or #elif on expressions
containing undefined macro names. This reverts back to following expected CPP behavior.
- - Set both gl_MaxFragmentImageUniformsand gl_MaxCombinedImageUniformsto 8.
+ - Set both gl_MaxFragmentImageUniformsand gl_MaxCombinedImageUniforms to 8.
- Clarify textureSize() for cube map arrays.
- For layout qualifiers,
- make negative output locations a compile-time error, and
- make indexes outside the range [0,1] a compile-time error.
- - Allow mismatches in interpolation and auxiliary qualification across stages.
- - Remove cross-version linking restrictions.
- Add textureQueryLevels() built-ins to query the number of mipmap levels, as per the
GL_ARB_texture_query_levels extension.
- Make gl_Layer and gl_ViewportIndex also be inputs to the fragment shader, as per the
GL_ARB_fragment_layer_viewport extension.
- - Be explicit that compile-time constant expressions evaluating on the host may get a different
- value than the same expression on the target. Also reinforce that compile-time constant
- expressions are evaluated as if precise and invariantwere used.
- Add more examples and rules to be more specific about the required behavior of the precise
qualifier.
- Clarify fragment output variables cannot be double precision.
- - Clarify that \93floating-point\94 generally means both single- and double-precision and be more
- consistent with that.
- - Be clear that early_fragment_tests is only needed in one fragment-stage compilation unit.
- Allow the new shared keyword to be in layout-qualifier-id, allowing backward compatibility
with the shared identifier that was previously used.
+ Added overlooked texture function float textureOffset (sampler2DArrayShadow sampler, vec4 P, vec2 offset [, float bias] ).
+ Add missing type in grammar, ATOMIC_UINT, and missing qualifiers COHERENT, VOLATILE, RESTRICT, READONLY, and WRITEONLY.
- - do version checking for the above
+ - do version checking for the above
+ Add missing initializer lists to grammar.
GLSL 4.4
- Incorporate the ARB_enhanced_layouts extension, which adds
<ItemGroup>\r
<ClInclude Include="glslang\MachineIndependent\glslang_tab.cpp.h" />\r
<ClInclude Include="glslang\MachineIndependent\Initialize.h" />\r
- <ClInclude Include="glslang\MachineIndependent\MMap.h" />\r
<ClInclude Include="glslang\MachineIndependent\ParseHelper.h" />\r
<ClInclude Include="glslang\MachineIndependent\preprocessor\PpContext.h" />\r
<ClInclude Include="glslang\MachineIndependent\preprocessor\PpTokens.h" />\r
<ClInclude Include="glslang\MachineIndependent\Initialize.h">\r
<Filter>Machine Independent</Filter>\r
</ClInclude>\r
- <ClInclude Include="glslang\MachineIndependent\MMap.h">\r
- <Filter>Machine Independent</Filter>\r
- </ClInclude>\r
<ClInclude Include="glslang\MachineIndependent\ParseHelper.h">\r
<Filter>Machine Independent</Filter>\r
</ClInclude>\r
#ifndef _BASICTYPES_INCLUDED_
#define _BASICTYPES_INCLUDED_
+namespace glslang {
+
//
// Basic type. Arrays, vectors, sampler details, etc., are orthogonal to this.
//
};
// These will show up in error messages
-__inline const char* getStorageQualifierString(TStorageQualifier q)
+__inline const char* GetStorageQualifierString(TStorageQualifier q)
{
switch (q) {
case EvqTemporary: return "temporary"; break;
EpqHigh
};
-__inline const char* getPrecisionQualifierString(TPrecisionQualifier p)
+__inline const char* GetPrecisionQualifierString(TPrecisionQualifier p)
{
switch(p) {
case EpqNone: return ""; break;
}
}
+} // end namespace glslang
+
#endif // _BASICTYPES_INCLUDED_
#define TBaseList std::list
#define TBaseSet std::set
+namespace glslang {
+
//
// Pool version of string.
//
const int GlslangMaxTokenLength = 1024;
+} // end namespace glslang
+
#endif // _COMMON_INCLUDED_
#ifndef _CONSTANT_UNION_INCLUDED_
#define _CONSTANT_UNION_INCLUDED_
+namespace glslang {
-class constUnion {
+class TConstUnion {
public:
POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
return false;
}
- bool operator==(const constUnion& constant) const
+ bool operator==(const TConstUnion& constant) const
{
if (constant.type != type)
return false;
return !operator==(b);
}
- bool operator!=(const constUnion& constant) const
+ bool operator!=(const TConstUnion& constant) const
{
return !operator==(constant);
}
- bool operator>(const constUnion& constant) const
+ bool operator>(const TConstUnion& constant) const
{
assert(type == constant.type);
switch (type) {
return false;
}
- bool operator<(const constUnion& constant) const
+ bool operator<(const TConstUnion& constant) const
{
assert(type == constant.type);
switch (type) {
return false;
}
- constUnion operator+(const constUnion& constant) const
+ TConstUnion operator+(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtInt: returnValue.setIConst(iConst + constant.iConst); break;
return returnValue;
}
- constUnion operator-(const constUnion& constant) const
+ TConstUnion operator-(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtInt: returnValue.setIConst(iConst - constant.iConst); break;
return returnValue;
}
- constUnion operator*(const constUnion& constant) const
+ TConstUnion operator*(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtInt: returnValue.setIConst(iConst * constant.iConst); break;
return returnValue;
}
- constUnion operator%(const constUnion& constant) const
+ TConstUnion operator%(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtInt: returnValue.setIConst(iConst % constant.iConst); break;
return returnValue;
}
- constUnion operator>>(const constUnion& constant) const
+ TConstUnion operator>>(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
switch (type) {
case EbtInt:
switch (constant.type) {
return returnValue;
}
- constUnion operator<<(const constUnion& constant) const
+ TConstUnion operator<<(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
switch (type) {
case EbtInt:
switch (constant.type) {
return returnValue;
}
- constUnion operator&(const constUnion& constant) const
+ TConstUnion operator&(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtInt: returnValue.setIConst(iConst & constant.iConst); break;
return returnValue;
}
- constUnion operator|(const constUnion& constant) const
+ TConstUnion operator|(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtInt: returnValue.setIConst(iConst | constant.iConst); break;
return returnValue;
}
- constUnion operator^(const constUnion& constant) const
+ TConstUnion operator^(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtInt: returnValue.setIConst(iConst ^ constant.iConst); break;
return returnValue;
}
- constUnion operator~() const
+ TConstUnion operator~() const
{
- constUnion returnValue;
+ TConstUnion returnValue;
switch (type) {
case EbtInt: returnValue.setIConst(~iConst); break;
case EbtUint: returnValue.setUConst(~uConst); break;
return returnValue;
}
- constUnion operator&&(const constUnion& constant) const
+ TConstUnion operator&&(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtBool: returnValue.setBConst(bConst && constant.bConst); break;
return returnValue;
}
- constUnion operator||(const constUnion& constant) const
+ TConstUnion operator||(const TConstUnion& constant) const
{
- constUnion returnValue;
+ TConstUnion returnValue;
assert(type == constant.type);
switch (type) {
case EbtBool: returnValue.setBConst(bConst || constant.bConst); break;
TBasicType type;
};
+} // end namespace glslang
+
#endif // _CONSTANT_UNION_INCLUDED_
#include "../Include/Common.h"
#include <math.h>
+namespace glslang {
+
//
// TPrefixType is used to centralize how info log messages start.
// See below.
int outputStream;
};
+} // end namespace glslang
+
class TInfoSink {
public:
- TInfoSinkBase info;
- TInfoSinkBase debug;
+ glslang::TInfoSinkBase info;
+ glslang::TInfoSinkBase debug;
};
#endif // _INFOSINK_INCLUDED_
#ifndef __INITIALIZE_GLOBALS_INCLUDED_
#define __INITIALIZE_GLOBALS_INCLUDED_
+namespace glslang {
+
void InitializeGlobalPools();
void FreeGlobalPools();
bool InitializePoolIndex();
void FreePoolIndex();
+} // end namespace glslang
+
#endif // __INITIALIZE_GLOBALS_INCLUDED_
#include <string.h>
#include <vector>
+namespace glslang {
+
// If we are using guard blocks, we must track each indivual
// allocation. If we aren't using guard blocks, these
// never get instantiated, so won't have any impact.
TPoolAllocator& allocator;
};
+} // end namespace glslang
+
#endif // _POOLALLOC_INCLUDED_
int minProgramTexelOffset;
int maxProgramTexelOffset;
};
+
#endif // _RESOURCE_LIMITS_INCLUDED_
class TLinker;
class TUniformMap;
-
//
// The base class used to back handles returned to the driver.
//
virtual TInfoSink& getInfoSink() { return infoSink; }
TInfoSink infoSink;
};
+
class TIntermNode;
//
//
// Link operations are base on a list of compile results...
//
-typedef TVector<TCompiler*> TCompilerList;
-typedef TVector<TShHandleBase*> THandleList;
+typedef glslang::TVector<TCompiler*> TCompilerList;
+typedef glslang::TVector<TShHandleBase*> THandleList;
//
// The base class for the machine dependent linker to derive from
#include "../Include/Common.h"
#include "../Include/BaseTypes.h"
+namespace glslang {
+
const int GlslangMaxTypeLength = 200;
//
return getBasicString();
}
- const char* getStorageQualifierString() const { return ::getStorageQualifierString(qualifier.storage); }
- const char* getPrecisionQualifierString() const { return ::getPrecisionQualifierString(qualifier.precision); }
+ const char* getStorageQualifierString() const { return GetStorageQualifierString(qualifier.storage); }
+ const char* getPrecisionQualifierString() const { return GetPrecisionQualifierString(qualifier.precision); }
TTypeList* getStruct() { return structure; }
TTypeList* getStruct() const { return structure; }
TString *typeName; // for structure field type name
};
+} // end namespace glslang
+
#endif // _TYPES_INCLUDED_
#include "../Include/Types.h"
#include "../Include/ConstantUnion.h"
+namespace glslang {
+
//
// Operators used by the high-level (parse tree) representation.
//
class TIntermTyped;
class TIntermMethod;
class TIntermSymbol;
-class TInfoSink;
+
+} // end namespace glslang
//
// Base class for the tree nodes
//
+// (Put outside the glslang namespace, as it's used as part of the external interface.)
+//
class TIntermNode {
public:
- POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
+ POOL_ALLOCATOR_NEW_DELETE(glslang::GetThreadPoolAllocator())
TIntermNode() { loc.line = 0; loc.string = 0; }
- virtual TSourceLoc getLoc() const { return loc; }
- virtual void setLoc(TSourceLoc l) { loc = l; }
- virtual void traverse(TIntermTraverser*) = 0;
- virtual TIntermTyped* getAsTyped() { return 0; }
- virtual TIntermConstantUnion* getAsConstantUnion() { return 0; }
- virtual TIntermAggregate* getAsAggregate() { return 0; }
- virtual TIntermUnary* getAsUnaryNode() { return 0; }
- virtual TIntermBinary* getAsBinaryNode() { return 0; }
- virtual TIntermSelection* getAsSelectionNode() { return 0; }
- virtual TIntermSwitch* getAsSwitchNode() { return 0; }
- virtual TIntermMethod* getAsMethodNode() { return 0; }
- virtual TIntermSymbol* getAsSymbolNode() { return 0; }
- virtual TIntermBranch* getAsBranchNode() { return 0; }
+ virtual glslang::TSourceLoc getLoc() const { return loc; }
+ virtual void setLoc(glslang::TSourceLoc l) { loc = l; }
+ virtual void traverse(glslang::TIntermTraverser*) = 0;
+ virtual glslang::TIntermTyped* getAsTyped() { return 0; }
+ virtual glslang::TIntermConstantUnion* getAsConstantUnion() { return 0; }
+ virtual glslang::TIntermAggregate* getAsAggregate() { return 0; }
+ virtual glslang::TIntermUnary* getAsUnaryNode() { return 0; }
+ virtual glslang::TIntermBinary* getAsBinaryNode() { return 0; }
+ virtual glslang::TIntermSelection* getAsSelectionNode() { return 0; }
+ virtual glslang::TIntermSwitch* getAsSwitchNode() { return 0; }
+ virtual glslang::TIntermMethod* getAsMethodNode() { return 0; }
+ virtual glslang::TIntermSymbol* getAsSymbolNode() { return 0; }
+ virtual glslang::TIntermBranch* getAsBranchNode() { return 0; }
virtual ~TIntermNode() { }
protected:
- TSourceLoc loc;
+ glslang::TSourceLoc loc;
};
+class TInfoSink;
+
+namespace glslang {
+
//
// This is just to help yacc.
//
class TIntermConstantUnion : public TIntermTyped {
public:
- TIntermConstantUnion(constUnion *unionPointer, const TType& t) : TIntermTyped(t), unionArrayPointer(unionPointer) { }
- constUnion* getUnionArrayPointer() const { return unionArrayPointer; }
- void setUnionArrayPointer(constUnion *c) { unionArrayPointer = c; }
+ TIntermConstantUnion(TConstUnion *unionPointer, const TType& t) : TIntermTyped(t), unionArrayPointer(unionPointer) { }
+ TConstUnion* getUnionArrayPointer() const { return unionArrayPointer; }
+ void setUnionArrayPointer(TConstUnion *c) { unionArrayPointer = c; }
virtual TIntermConstantUnion* getAsConstantUnion() { return this; }
virtual void traverse(TIntermTraverser* );
virtual TIntermTyped* fold(TOperator, TIntermTyped*, TInfoSink&);
virtual TIntermTyped* fold(TOperator, const TType&, TInfoSink&);
protected:
- constUnion *unionArrayPointer;
+ TConstUnion *unionArrayPointer;
};
//
bool rightToLeft;
};
+} // end namespace glslang
+
#endif // __INTERMEDIATE_H
#include <cfloat>
#include <cstdlib>
-namespace glslang {
+namespace {
+
+using namespace glslang;
+
+// Some helper functions
bool isNan(double x)
{
(bitPatternH & 0xFFFFF) == 0 && bitPatternL == 0;
}
-};
-
-namespace {
-
-// Some helper functions
-
const double pi = 3.1415926535897932384626433832795;
-bool CompareStruct(const TType& leftNodeType, constUnion* rightUnionArray, constUnion* leftUnionArray);
+// forward reference for mutual recursion
+bool CompareStruct(const TType& leftNodeType, TConstUnion* rightUnionArray, TConstUnion* leftUnionArray);
-bool CompareStructure(const TType& leftNodeType, constUnion* rightUnionArray, constUnion* leftUnionArray)
+bool CompareStructure(const TType& leftNodeType, TConstUnion* rightUnionArray, TConstUnion* leftUnionArray)
{
if (leftNodeType.isArray()) {
TType typeWithoutArrayness(leftNodeType);
return true;
}
-bool CompareStruct(const TType& leftNodeType, constUnion* rightUnionArray, constUnion* leftUnionArray)
+bool CompareStruct(const TType& leftNodeType, TConstUnion* rightUnionArray, TConstUnion* leftUnionArray)
{
TTypeList* fields = leftNodeType.getStruct();
return true;
}
-}; // end anonymous namespace
+} // end anonymous namespace
+
+
+namespace glslang {
//
// The fold functions see if an operation on a constant can be done in place,
//
TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNode, TInfoSink& infoSink)
{
- constUnion *unionArray = getUnionArrayPointer();
+ TConstUnion *unionArray = getUnionArrayPointer();
int objectSize = getType().getObjectSize();
- constUnion* newConstArray = 0;
+ TConstUnion* newConstArray = 0;
// For most cases, the return type matches the argument type, so set that
// up and just code to exceptions below.
//
TIntermConstantUnion *node = constantNode->getAsConstantUnion();
- constUnion *rightUnionArray = node->getUnionArrayPointer();
+ TConstUnion *rightUnionArray = node->getUnionArrayPointer();
if (constantNode->getType().getObjectSize() == 1 && objectSize > 1) {
// for a case like float f = vec4(2,3,4,5) + 1.2;
- rightUnionArray = new constUnion[objectSize];
+ rightUnionArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; ++i)
rightUnionArray[i] = *node->getUnionArrayPointer();
} else if (constantNode->getType().getObjectSize() > 1 && objectSize == 1) {
// for a case like float f = 1.2 + vec4(2,3,4,5);
rightUnionArray = node->getUnionArrayPointer();
- unionArray = new constUnion[constantNode->getType().getObjectSize()];
+ unionArray = new TConstUnion[constantNode->getType().getObjectSize()];
for (int i = 0; i < constantNode->getType().getObjectSize(); ++i)
unionArray[i] = *getUnionArrayPointer();
returnType = node->getType();
bool boolNodeFlag = false;
switch(op) {
case EOpAdd:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] + rightUnionArray[i];
break;
case EOpSub:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] - rightUnionArray[i];
break;
case EOpMul:
case EOpVectorTimesScalar:
case EOpMatrixTimesScalar:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] * rightUnionArray[i];
break;
case EOpMatrixTimesMatrix:
- newConstArray = new constUnion[getMatrixRows() * node->getMatrixCols()];
+ newConstArray = new TConstUnion[getMatrixRows() * node->getMatrixCols()];
for (int row = 0; row < getMatrixRows(); row++) {
for (int column = 0; column < node->getMatrixCols(); column++) {
double sum = 0.0f;
returnType = TType(getType().getBasicType(), EvqConst, 0, getMatrixRows(), node->getMatrixCols());
break;
case EOpDiv:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++) {
switch (getType().getBasicType()) {
case EbtFloat:
break;
case EOpMatrixTimesVector:
- newConstArray = new constUnion[getMatrixRows()];
+ newConstArray = new TConstUnion[getMatrixRows()];
for (int i = 0; i < getMatrixRows(); i++) {
double sum = 0.0f;
for (int j = 0; j < node->getVectorSize(); j++) {
break;
case EOpVectorTimesMatrix:
- newConstArray = new constUnion[node->getMatrixCols()];
+ newConstArray = new TConstUnion[node->getMatrixCols()];
for (int i = 0; i < node->getMatrixCols(); i++) {
double sum = 0.0f;
for (int j = 0; j < getVectorSize(); j++)
break;
case EOpMod:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] % rightUnionArray[i];
break;
case EOpRightShift:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] >> rightUnionArray[i];
break;
case EOpLeftShift:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] << rightUnionArray[i];
break;
case EOpAnd:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] & rightUnionArray[i];
break;
case EOpInclusiveOr:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] | rightUnionArray[i];
break;
case EOpExclusiveOr:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] ^ rightUnionArray[i];
break;
case EOpLogicalAnd: // this code is written for possible future use, will not get executed currently
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] && rightUnionArray[i];
break;
case EOpLogicalOr: // this code is written for possible future use, will not get executed currently
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++)
newConstArray[i] = unionArray[i] || rightUnionArray[i];
break;
case EOpLogicalXor:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
for (int i = 0; i < objectSize; i++) {
switch (getType().getBasicType()) {
case EbtBool: newConstArray[i].setBConst((unionArray[i] == rightUnionArray[i]) ? false : true); break;
case EOpLessThan:
assert(objectSize == 1);
- newConstArray = new constUnion[1];
+ newConstArray = new TConstUnion[1];
newConstArray->setBConst(*unionArray < *rightUnionArray);
returnType = TType(EbtBool, EvqConst);
break;
case EOpGreaterThan:
assert(objectSize == 1);
- newConstArray = new constUnion[1];
+ newConstArray = new TConstUnion[1];
newConstArray->setBConst(*unionArray > *rightUnionArray);
returnType = TType(EbtBool, EvqConst);
break;
case EOpLessThanEqual:
{
assert(objectSize == 1);
- constUnion constant;
+ TConstUnion constant;
constant.setBConst(*unionArray > *rightUnionArray);
- newConstArray = new constUnion[1];
+ newConstArray = new TConstUnion[1];
newConstArray->setBConst(!constant.getBConst());
returnType = TType(EbtBool, EvqConst);
break;
case EOpGreaterThanEqual:
{
assert(objectSize == 1);
- constUnion constant;
+ TConstUnion constant;
constant.setBConst(*unionArray < *rightUnionArray);
- newConstArray = new constUnion[1];
+ newConstArray = new TConstUnion[1];
newConstArray->setBConst(!constant.getBConst());
returnType = TType(EbtBool, EvqConst);
break;
}
}
- newConstArray = new constUnion[1];
+ newConstArray = new TConstUnion[1];
newConstArray->setBConst(! boolNodeFlag);
returnType = TType(EbtBool, EvqConst);
break;
}
}
- newConstArray = new constUnion[1];
+ newConstArray = new TConstUnion[1];
newConstArray->setBConst(! boolNodeFlag);
returnType = TType(EbtBool, EvqConst);
break;
//
TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType, TInfoSink& infoSink)
{
- constUnion *unionArray = getUnionArrayPointer();
+ TConstUnion *unionArray = getUnionArrayPointer();
int objectSize = getType().getObjectSize();
// First, size the result, which is mostly the same as the argument's size,
// but not always.
- constUnion* newConstArray;
+ TConstUnion* newConstArray;
switch (op) {
// TODO: functionality: constant folding: finish listing exceptions to size here
case EOpDeterminant:
case EOpAny:
case EOpAll:
case EOpLength:
- newConstArray = new constUnion[1];
+ newConstArray = new TConstUnion[1];
break;
case EOpEmitStreamVertex:
return 0;
default:
- newConstArray = new constUnion[objectSize];
+ newConstArray = new TConstUnion[objectSize];
}
// Process non-component-wise operations
case EOpIsNan:
{
- newConstArray[i].setBConst(glslang::isNan(unionArray[i].getDConst()));
+ newConstArray[i].setBConst(isNan(unionArray[i].getDConst()));
break;
}
case EOpIsInf:
{
- newConstArray[i].setBConst(glslang::isInf(unionArray[i].getDConst()));
+ newConstArray[i].setBConst(isInf(unionArray[i].getDConst()));
break;
}
default:
return aggrNode;
}
- constUnion* newConstArray = new constUnion[objectSize];
+ TConstUnion* newConstArray = new TConstUnion[objectSize];
- TVector<constUnion*> childConstUnions;
+ TVector<TConstUnion*> childConstUnions;
for (unsigned int i = 0; i < children.size(); ++i)
childConstUnions.push_back(children[i]->getAsConstantUnion()->getUnionArrayPointer());
{
bool returnVal = false;
- constUnion* unionArray = new constUnion[aggrNode->getType().getObjectSize()];
+ TConstUnion* unionArray = new TConstUnion[aggrNode->getType().getObjectSize()];
if (aggrNode->getSequence().size() == 1)
returnVal = parseConstTree(aggrNode->getLoc(), aggrNode, unionArray, aggrNode->getOp(), aggrNode->getType(), true);
else
return addConstantUnion(unionArray, aggrNode->getType(), aggrNode->getLoc());
}
+
+} // end namespace glslang
#include <string.h>
+namespace glslang {
+
void TInfoSinkBase::append(const char *s)
{
if (outputStream & EString) {
if (outputStream & EStdOut)
fprintf(stdout, "%s", t.c_str());
}
+
+} // end namespace glslang
#include "../Include/intermediate.h"
#include "Initialize.h"
+namespace glslang {
+
const int FirstProfileVersion = 150;
const bool ForwardCompatibility = false;
break;
}
}
+
+} // end namespace glslang
#include "SymbolTable.h"
#include "Versions.h"
+namespace glslang {
+
class TBuiltIns {
public:
POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
void IdentifyBuiltIns(int version, EProfile profile, EShLanguage, TSymbolTable&);
void IdentifyBuiltIns(int version, EProfile profile, EShLanguage, TSymbolTable&, const TBuiltInResource &resources);
+} // end namespace glslang
+
#endif // _INITIALIZE_INCLUDED_
#include "../Include/intermediate.h"
+namespace glslang {
+
//
// Traverse the intermediate representation tree, and
// call a node type specific function for each node.
if (visit && it->postVisit && it->visitSwitch)
it->visitSwitch(false, this, it);
}
+
+} // end namespace glslang
#include "RemoveTree.h"
#include <float.h>
+namespace glslang {
+
////////////////////////////////////////////////////////////////////////////
//
// First set of functions are to help build the intermediate representation.
// Returns the constant union node created.
//
-TIntermConstantUnion* TIntermediate::addConstantUnion(constUnion* unionArrayPointer, const TType& t, TSourceLoc loc)
+TIntermConstantUnion* TIntermediate::addConstantUnion(TConstUnion* unionArrayPointer, const TType& t, TSourceLoc loc)
{
TIntermConstantUnion* node = new TIntermConstantUnion(unionArrayPointer, t);
node->setLoc(loc);
node->setLoc(loc);
TIntermConstantUnion* constIntNode;
TIntermSequence &sequenceVector = node->getSequence();
- constUnion* unionArray;
+ TConstUnion* unionArray;
for (int i = 0; i < fields.num; i++) {
- unionArray = new constUnion[1];
+ unionArray = new TConstUnion[1];
unionArray->setIConst(fields.offsets[i]);
constIntNode = addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc);
sequenceVector.push_back(constIntNode);
if (node->getType().isArray())
infoSink.info.message(EPrefixInternalError, "Cannot promote array", node->getLoc());
- constUnion *rightUnionArray = node->getUnionArrayPointer();
+ TConstUnion *rightUnionArray = node->getUnionArrayPointer();
int size = node->getType().getObjectSize();
- constUnion *leftUnionArray = new constUnion[size];
+ TConstUnion *leftUnionArray = new TConstUnion[size];
for (int i=0; i < size; i++) {
switch (promoteTo) {
*pragmaTable = pTable;
}
+} // end namespace glslang
+++ /dev/null
-//
-//Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
-//All rights reserved.
-//
-//Redistribution and use in source and binary forms, with or without
-//modification, are permitted provided that the following conditions
-//are met:
-//
-// Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following
-// disclaimer in the documentation and/or other materials provided
-// with the distribution.
-//
-// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-//POSSIBILITY OF SUCH DAMAGE.
-//
-
-#ifndef _MMAP_INCLUDED_
-#define _MMAP_INCLUDED_
-
-//
-// Encapsulate memory mapped files
-//
-
-class TMMap {
-public:
- TMMap(const char* fileName) :
- fSize(-1), // -1 is the error value returned by GetFileSize()
- fp(NULL),
- fBuff(0) // 0 is the error value returned by MapViewOfFile()
- {
- if ((fp = fopen(fileName, "r")) == NULL)
- return;
- char c = getc(fp);
- fSize = 0;
- while (c != EOF) {
- fSize++;
- c = getc(fp);
- }
- if (c == EOF)
- fSize++;
- rewind(fp);
- fBuff = (char*)malloc(sizeof(char) * fSize);
- int count = 0;
- c = getc(fp);
- while (c != EOF) {
- fBuff[count++] = c;
- c = getc(fp);
- }
- fBuff[count++] = c;
- }
-
- char* getData() { return fBuff; }
- int getSize() { return fSize; }
-
- ~TMMap() {
- if (fp != NULL)
- fclose(fp);
- }
-
-private:
- int fSize; // size of file to map in
- FILE *fp;
- char* fBuff; // the actual data;
-};
-
-#endif // _MMAP_INCLUDED_
#include "preprocessor/PpContext.h"
+extern int yyparse(void*);
+
+namespace glslang {
+
TParseContext::TParseContext(TSymbolTable& symt, TIntermediate& interm, bool pb, int v, EProfile p, EShLanguage L, TInfoSink& is,
bool fc, EShMessages m) :
intermediate(interm), symbolTable(symt), infoSink(is), language(L), treeRoot(0), linkage(0),
return 0;
}
-extern int yyparse(void*);
-
//
// Parse an array of strings using yyparse, going through the
// preprocessor to tokenize the shader strings, then through
// it was a member of an anonymous container, have to insert its dereference
TVariable* variable = anon->getAnonContainer().getAsVariable();
TIntermTyped* container = intermediate.addSymbol(variable->getUniqueId(), variable->getName(), variable->getType(), loc);
- constUnion* unionArray = new constUnion[1];
+ TConstUnion* unionArray = new TConstUnion[1];
unionArray->setUConst(anon->getMemberNumber());
TIntermTyped* constNode = intermediate.addConstantUnion(unionArray, TType(EbtUint, EvqConst), loc);
// pop will reclaim the memory
if (variable->getType().getQualifier().storage == EvqConst ) {
- constUnion* constArray = variable->getConstUnionPointer();
+ TConstUnion* constArray = variable->getConstUnionPointer();
TType t(variable->getType());
node = intermediate.addConstantUnion(constArray, t, loc);
} else
}
if (result == 0) {
- constUnion *unionArray = new constUnion[1];
+ TConstUnion *unionArray = new TConstUnion[1];
unionArray->setDConst(0.0);
result = intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), loc);
} else {
result->setType(TType(base->getBasicType(), EvqConst, (int) (field).size()));
} else {
if (fields.num == 1) {
- constUnion *unionArray = new constUnion[1];
+ TConstUnion *unionArray = new TConstUnion[1];
unionArray->setIConst(fields.offsets[0]);
TIntermTyped* index = intermediate.addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc);
result = intermediate.addIndex(EOpIndexDirect, base, index, loc);
result->getTypePointer()->getQualifier().storage = EvqConst;
}
} else {
- constUnion *unionArray = new constUnion[1];
+ TConstUnion *unionArray = new TConstUnion[1];
unionArray->setIConst(i);
TIntermTyped* index = intermediate.addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc);
result = intermediate.addIndex(EOpIndexDirectStruct, base, index, loc);
} else
length = intermNode->getAsTyped()->getType().getArraySize();
- constUnion *unionArray = new constUnion[1];
+ TConstUnion *unionArray = new TConstUnion[1];
unionArray->setIConst(length);
result = intermediate.addConstantUnion(unionArray, TType(EbtInt, EvqConst), loc);
} else if (op != EOpNull) {
} else {
// error message was put out by PaFindFunction()
// Put on a dummy node for error recovery
- constUnion *unionArray = new constUnion[1];
+ TConstUnion *unionArray = new TConstUnion[1];
unionArray->setDConst(0.0);
result = intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), loc);
}
// now, knowing it is a shader in/out, do all the in/out semantic checks
if (publicType.basicType == EbtBool) {
- error(loc, "cannot be bool", getStorageQualifierString(qualifier.storage), "");
+ error(loc, "cannot be bool", GetStorageQualifierString(qualifier.storage), "");
return;
}
if (language == EShLangVertex && qualifier.storage == EvqVaryingIn) {
if (publicType.basicType == EbtStruct) {
- error(loc, "cannot be a structure or array", getStorageQualifierString(qualifier.storage), "");
+ error(loc, "cannot be a structure or array", GetStorageQualifierString(qualifier.storage), "");
return;
}
if (language == EShLangFragment && qualifier.storage == EvqVaryingOut) {
profileRequires(loc, EEsProfile, 300, 0, "fragment shader output");
if (publicType.basicType == EbtStruct) {
- error(loc, "cannot be a structure", getStorageQualifierString(qualifier.storage), "");
+ error(loc, "cannot be a structure", GetStorageQualifierString(qualifier.storage), "");
return;
}
profileRequires(loc, EEsProfile, 300, 0, "shader input/output");
if (language != EShLangVertex && qualifier.storage == EvqVaryingIn && ! qualifier.flat ||
language != EShLangFragment && qualifier.storage == EvqVaryingOut && ! qualifier.flat) {
- error(loc, "must be qualified as 'flat'", getStorageQualifierString(qualifier.storage), TType::getBasicString(publicType.basicType));
+ error(loc, "must be qualified as 'flat'", GetStorageQualifierString(qualifier.storage), TType::getBasicString(publicType.basicType));
return;
}
dst.storage == EvqConst && src.storage == EvqIn)
dst.storage = EvqConstReadOnly;
else if (src.storage != EvqTemporary)
- error(loc, "too many storage qualifiers", getStorageQualifierString(src.storage), "");
+ error(loc, "too many storage qualifiers", GetStorageQualifierString(src.storage), "");
// Precision qualifiers
if (! force && src.precision != EpqNone && dst.precision != EpqNone)
- error(loc, "only one precision qualifier allowed", getPrecisionQualifierString(src.precision), "");
+ error(loc, "only one precision qualifier allowed", GetPrecisionQualifierString(src.precision), "");
if (dst.precision == EpqNone || force && src.precision != EpqNone)
dst.precision = src.precision;
break;
default:
type->getQualifier().storage = EvqIn;
- error(loc, "qualifier not allowed on function parameter", getStorageQualifierString(qualifier), "");
+ error(loc, "qualifier not allowed on function parameter", GetStorageQualifierString(qualifier), "");
break;
}
}
return true;
}
if (initializer->getAsConstantUnion()) {
- constUnion* unionArray = variable->getConstUnionPointer();
+ TConstUnion* unionArray = variable->getConstUnionPointer();
if (type.getObjectSize() == 1 && type.getBasicType() != EbtStruct) {
*unionArray = (initializer->getAsConstantUnion()->getUnionArrayPointer())[0];
} else if (initializer->getAsSymbolNode()) {
TSymbol* symbol = symbolTable.find(initializer->getAsSymbolNode()->getName());
if (TVariable* tVar = symbol->getAsVariable()) {
- constUnion* constArray = tVar->getConstUnionPointer();
+ TConstUnion* constArray = tVar->getConstUnionPointer();
variable->shareConstPointer(constArray);
} else {
error(loc, "expected variable", initializer->getAsSymbolNode()->getName().c_str(), "");
TIntermTyped* typedNode;
TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion();
- constUnion *unionArray;
+ TConstUnion *unionArray;
if (tempConstantNode) {
unionArray = tempConstantNode->getUnionArrayPointer();
if (!unionArray) { // this error message should never be raised
- infoSink.info.message(EPrefixInternalError, "constUnion not initialized in addConstVectorNode function", loc);
+ infoSink.info.message(EPrefixInternalError, "TConstUnion not initialized in addConstVectorNode function", loc);
return node;
}
return 0;
}
- constUnion* constArray = new constUnion[fields.num];
+ TConstUnion* constArray = new TConstUnion[fields.num];
for (int i = 0; i < fields.num; i++) {
if (fields.offsets[i] >= node->getType().getObjectSize()) {
}
if (tempConstantNode) {
- constUnion* unionArray = tempConstantNode->getUnionArrayPointer();
+ TConstUnion* unionArray = tempConstantNode->getUnionArrayPointer();
int size = tempConstantNode->getType().getMatrixRows();
// Note: the type is corrected (dereferenced) by the caller
typedNode = intermediate.addConstantUnion(&unionArray[size*index], tempConstantNode->getType(), loc);
int arrayElementSize = arrayElementType.getObjectSize();
if (tempConstantNode) {
- constUnion* unionArray = tempConstantNode->getUnionArrayPointer();
+ TConstUnion* unionArray = tempConstantNode->getUnionArrayPointer();
typedNode = intermediate.addConstantUnion(&unionArray[arrayElementSize * index], tempConstantNode->getType(), loc);
} else {
error(loc, "Cannot offset into the array", "Error", "");
}
if (tempConstantNode) {
- constUnion* constArray = tempConstantNode->getUnionArrayPointer();
+ TConstUnion* constArray = tempConstantNode->getUnionArrayPointer();
typedNode = intermediate.addConstantUnion(constArray+instanceSize, tempConstantNode->getType(), loc); // type will be changed in the calling function
} else {
extensionBehavior["GL_ARB_texture_rectangle"] = EBhDisable;
extensionBehavior["GL_3DL_array_objects"] = EBhDisable;
}
+
+} // end namespace glslang
#include "SymbolTable.h"
#include "localintermediate.h"
+namespace glslang {
+
typedef enum {
EBhRequire,
EBhEnable,
TPragmaTable pragmaTable;
};
+class TScanContext;
class TPpContext;
-namespace glslang {
- class TScanContext;
-};
-
//
// The following are extra variables needed during parsing, grouped together so
// they can be passed to the parser without needing a global.
TParseContext(TSymbolTable&, TIntermediate&, bool parsingBuiltins, int version, EProfile, EShLanguage, TInfoSink&,
bool forwardCompatible = false, EShMessages messages = EShMsgDefault);
- glslang::TScanContext* scanContext;
+ TScanContext* scanContext;
TPpContext* ppContext;
TIntermediate& intermediate; // to hold and build a parse tree
TSymbolTable& symbolTable; // symbol table that goes with the current language, version, and profile
void doubleCheck(TSourceLoc, const char* op);
};
+} // end namespace glslang
+
#endif // _PARSER_HELPER_INCLUDED_
#include "Include/InitializeGlobals.h"
#include "osinclude.h"
+namespace glslang {
+
OS_TLSIndex PoolIndex;
void InitializeGlobalPools()
for (const TAllocation* alloc = this; alloc != 0; alloc = alloc->prevAlloc)
alloc->check();
}
+
+} // end namespace glslang
#include "../Include/intermediate.h"
+namespace glslang {
+
class TAliveTraverser : public TIntermTraverser {
public:
TAliveTraverser(TStorageQualifier q) : TIntermTraverser(), found(false), qualifier(q)
return true;
}
+} // end namespace glslang
+
#endif
//POSSIBILITY OF SUCH DAMAGE.
//
+namespace glslang {
+
bool QualifierWritten(TIntermNode* root, TStorageQualifier);
+
+} // end namespace glslang
#include "../Include/intermediate.h"
#include "RemoveTree.h"
+
+namespace glslang {
+
//
// Code to recursively delete the intermediate tree.
//
root->traverse(&it);
}
+} // end namespace glslang
//POSSIBILITY OF SUCH DAMAGE.
//
+namespace glslang {
+
void RemoveAllTreeNodes(TIntermNode*);
+
+} // end namespace glslang
return foundNonSpaceTab;
}
-}; // end glslang namespace
-
-namespace glslang {
-
// Fill this in when doing glslang-level scanning, to hand back to the parser.
class TParserToken {
public:
YYSTYPE& sType;
};
-}; // end namespace glslang
+} // end namespace glslang
// This is the function the glslang parser (i.e., bison) calls to get its next token
-int yylex(YYSTYPE* glslangTokenDesc, TParseContext& parseContext)
+int yylex(YYSTYPE* glslangTokenDesc, glslang::TParseContext& parseContext)
{
glslang::TParserToken token(*glslangTokenDesc);
return identifierOrType();
}
-};
+} // end namespace glslang
void ConsumeWhitespaceComment(TInputScanner& input, bool& foundNonSpaceTab);
bool ScanVersion(TInputScanner& input, int& version, EProfile& profile);
-}; // end glslang namespace
+} // end namespace glslang
#include "ParseHelper.h"
-class TPpContext;
-class TPpToken;
-
namespace glslang {
+class TPpContext;
+class TPpToken;
class TParserToken;
class TScanContext {
int keyword;
};
-};
+} // end namespace glslang
namespace { // anonymous namespace for file-local functions and symbols
+using namespace glslang;
+
int MapVersionToIndex(int version)
{
switch(version) {
TParseContext parseContext(symbolTable, intermediate, true, version, profile, language, infoSink);
TPpContext ppContext(parseContext);
- glslang::TScanContext scanContext(parseContext);
+ TScanContext scanContext(parseContext);
parseContext.scanContext = &scanContext;
parseContext.ppContext = &ppContext;
return true;
}
-}; // end anonymous namespace for local functions
+} // end anonymous namespace for local functions
//
// ShInitialize() should be called exactly once per process, not per thread.
#include "SymbolTable.h"
+namespace glslang {
+
//
// TType helper function needs a place to live.
//
if (copyOf.unionArray) {
assert(!copyOf.type.getStruct());
assert(copyOf.type.getObjectSize() == 1);
- unionArray = new constUnion[1];
+ unionArray = new TConstUnion[1];
unionArray[0] = copyOf.unionArray[0];
} else
unionArray = 0;
for (unsigned int i = 0; i < copyOf.table.size(); ++i)
table.push_back(copyOf.table[i]->clone(remapper));
}
+
+} // end namespace glslang
#include "../Include/intermediate.h"
#include "../Include/InfoSink.h"
+namespace glslang {
+
//
// Symbol base class. (Can build functions or variables out of these...)
//
virtual void dump(TInfoSink &infoSink) const;
- constUnion* getConstUnionPointer() {
+ TConstUnion* getConstUnionPointer() {
if (!unionArray)
- unionArray = new constUnion[type.getObjectSize()];
+ unionArray = new TConstUnion[type.getObjectSize()];
return unionArray;
}
- constUnion* getConstUnionPointer() const { return unionArray; }
+ TConstUnion* getConstUnionPointer() const { return unionArray; }
- void shareConstPointer( constUnion *constArray)
+ void shareConstPointer( TConstUnion *constArray)
{
delete unionArray;
unionArray = constArray;
bool userType;
// we are assuming that Pool Allocator will free the memory allocated to unionArray
// when this object is destroyed
- constUnion *unionArray;
+ TConstUnion *unionArray;
TType *arrayInformationType; // this is used for updating maxArraySize in all the references to a given symbol
};
unsigned int adoptedLevels;
};
+} // end namespace glslang
+
#endif // _SYMBOL_TABLE_INCLUDED_
#include "ParseHelper.h"
+namespace glslang {
+
const char* StageName[EShLangCount] = {
"vertex",
"tessellation control",
profileRequires(loc, ECoreProfile, 400, 0, op);
profileRequires(loc, ECompatibilityProfile, 400, 0, op);
}
+
+} // end namespace glslang
//\r
\r
/**\r
- * This is bison grammar and production code for parsing the OpenGL 2.0 shading\r
- * languages.\r
+ * This is bison grammar and productions for parsing all versions of the \r
+ * GLSL shading languages.\r
*/\r
%{\r
\r
#include "ParseHelper.h"\r
#include "../Public/ShaderLang.h"\r
\r
+using namespace glslang;\r
+\r
%}\r
\r
%union {\r
struct {\r
- TSourceLoc loc;\r
+ glslang::TSourceLoc loc;\r
union {\r
- TString *string;\r
+ glslang::TString *string;\r
int i;\r
unsigned int u;\r
bool b;\r
double d;\r
};\r
- TSymbol* symbol;\r
+ glslang::TSymbol* symbol;\r
} lex;\r
struct {\r
- TSourceLoc loc;\r
- TOperator op;\r
+ glslang::TSourceLoc loc;\r
+ glslang::TOperator op;\r
union {\r
TIntermNode* intermNode;\r
- TIntermNodePair nodePair;\r
- TIntermTyped* intermTypedNode;\r
- TIntermAggregate* intermAggregate;\r
+ glslang::TIntermNodePair nodePair;\r
+ glslang::TIntermTyped* intermTypedNode;\r
+ glslang::TIntermAggregate* intermAggregate;\r
};\r
union {\r
- TPublicType type;\r
- TFunction* function;\r
- TParameter param;\r
- TTypeLoc typeLine;\r
- TTypeList* typeList;\r
- TArraySizes arraySizes;\r
- TIdentifierList* identifierList;\r
+ glslang::TPublicType type;\r
+ glslang::TFunction* function;\r
+ glslang::TParameter param;\r
+ glslang::TTypeLoc typeLine;\r
+ glslang::TTypeList* typeList;\r
+ glslang::TArraySizes arraySizes;\r
+ glslang::TIdentifierList* identifierList;\r
};\r
} interm;\r
}\r
$$ = $1;\r
}\r
| INTCONSTANT {\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setIConst($1.i);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtInt, EvqConst), $1.loc);\r
}\r
| UINTCONSTANT { \r
parseContext.fullIntegerCheck($1.loc, "unsigned literal");\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setUConst($1.u);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtUint, EvqConst), $1.loc);\r
}\r
| FLOATCONSTANT {\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setDConst($1.d);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtFloat, EvqConst), $1.loc);\r
}\r
| DOUBLECONSTANT {\r
parseContext.doubleCheck($1.loc, "double literal");\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setDConst($1.d);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtDouble, EvqConst), $1.loc);\r
}\r
| BOOLCONSTANT {\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst($1.b);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $1.loc);\r
}\r
$$ = parseContext.intermediate.addBinaryMath(EOpLessThan, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, "<", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
}\r
$$ = parseContext.intermediate.addBinaryMath(EOpGreaterThan, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, ">", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
}\r
$$ = parseContext.intermediate.addBinaryMath(EOpLessThanEqual, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, "<=", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
}\r
$$ = parseContext.intermediate.addBinaryMath(EOpGreaterThanEqual, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, ">=", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
}\r
$$ = parseContext.intermediate.addBinaryMath(EOpEqual, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, "==", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
} else if (($1->isArray() || $3->isArray()))\r
$$ = parseContext.intermediate.addBinaryMath(EOpNotEqual, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, "!=", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
} else if (($1->isArray() || $3->isArray()))\r
$$ = parseContext.intermediate.addBinaryMath(EOpLogicalAnd, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, "&&", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
}\r
$$ = parseContext.intermediate.addBinaryMath(EOpLogicalXor, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, "^^", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
}\r
$$ = parseContext.intermediate.addBinaryMath(EOpLogicalOr, $1, $3, $2.loc);\r
if ($$ == 0) {\r
parseContext.binaryOpError($2.loc, "||", $1->getCompleteString(), $3->getCompleteString());\r
- constUnion *unionArray = new constUnion[1];\r
+ TConstUnion *unionArray = new TConstUnion[1];\r
unionArray->setBConst(false);\r
$$ = parseContext.intermediate.addConstantUnion(unionArray, TType(EbtBool, EvqConst), $2.loc);\r
}\r
: fully_specified_type IDENTIFIER LEFT_PAREN {\r
if ($1.qualifier.storage != EvqGlobal && $1.qualifier.storage != EvqTemporary) {\r
parseContext.error($2.loc, "no qualifiers allowed for function return",\r
- getStorageQualifierString($1.qualifier.storage), "");\r
+ GetStorageQualifierString($1.qualifier.storage), "");\r
}\r
\r
// Add the function as a prototype after parsing it (we do not support recursion)\r
#include "localintermediate.h"
+namespace glslang {
+
//
// Two purposes:
// 1. Show an example of how to iterate tree. Functions can
root->traverse(&it);
}
+
+} // end namespace glslang
#include "SymbolTable.h"
#include "Versions.h"
+namespace glslang {
+
struct TVectorFields {
int offsets[4];
int num;
//
// Set of helper functions to help parse and build the tree.
//
-class TInfoSink;
class TIntermediate {
public:
POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
TIntermTyped* addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, TSourceLoc);
TIntermTyped* addComma(TIntermTyped* left, TIntermTyped* right, TSourceLoc);
TIntermTyped* addMethod(TIntermTyped*, const TType&, const TString*, TSourceLoc);
- TIntermConstantUnion* addConstantUnion(constUnion*, const TType&, TSourceLoc);
+ TIntermConstantUnion* addConstantUnion(TConstUnion*, const TType&, TSourceLoc);
TIntermTyped* promoteConstantUnion(TBasicType, TIntermConstantUnion*) ;
- bool parseConstTree(TSourceLoc, TIntermNode*, constUnion*, TOperator, const TType&, bool singleConstantParam = false);
+ bool parseConstTree(TSourceLoc, TIntermNode*, TConstUnion*, TOperator, const TType&, bool singleConstantParam = false);
TIntermNode* addLoop(TIntermNode*, TIntermTyped*, TIntermTyped*, bool testFirst, TSourceLoc);
TIntermBranch* addBranch(TOperator, TSourceLoc);
TIntermBranch* addBranch(TOperator, TIntermTyped*, TSourceLoc);
void operator=(TIntermediate&); // prevent assignments
};
+} // end namespace glslang
+
#endif // _LOCAL_INTERMEDIATE_INCLUDED_
#include "ParseHelper.h"
+namespace glslang {
+
//
// Use this class to carry along data from node to node in
// the traversal
//
class TConstTraverser : public TIntermTraverser {
public:
- TConstTraverser(constUnion* cUnion, bool singleConstParam, TOperator constructType, TInfoSink& sink, const TType& t) : unionArray(cUnion), type(t),
+ TConstTraverser(TConstUnion* cUnion, bool singleConstParam, TOperator constructType, TInfoSink& sink, const TType& t) : unionArray(cUnion), type(t),
constructorType(constructType), singleConstantParam(singleConstParam), infoSink(sink), error(false), isMatrix(false),
matrixCols(0), matrixRows(0) { index = 0; tOp = EOpNull;}
int index ;
- constUnion *unionArray;
+ TConstUnion *unionArray;
TOperator tOp;
const TType& type;
TOperator constructorType;
void ParseConstantUnion(TIntermConstantUnion* node, TIntermTraverser* it)
{
TConstTraverser* oit = static_cast<TConstTraverser*>(it);
- constUnion* leftUnionArray = oit->unionArray;
+ TConstUnion* leftUnionArray = oit->unionArray;
int instanceSize = oit->type.getObjectSize();
if (oit->index >= instanceSize)
if (!oit->singleConstantParam) {
int size = node->getType().getObjectSize();
- constUnion *rightUnionArray = node->getUnionArrayPointer();
+ TConstUnion *rightUnionArray = node->getUnionArrayPointer();
for (int i=0; i < size; i++) {
if (oit->index >= instanceSize)
return;
matrixRows = oit->matrixRows;
isMatrix = oit->isMatrix;
totalSize = oit->index + size;
- constUnion *rightUnionArray = node->getUnionArrayPointer();
+ TConstUnion *rightUnionArray = node->getUnionArrayPointer();
if (!isMatrix) {
int count = 0;
for (int i = oit->index; i < totalSize; i++) {
// Individual functions can be initialized to 0 to skip processing of that
// type of node. It's children will still be processed.
//
-bool TIntermediate::parseConstTree(TSourceLoc line, TIntermNode* root, constUnion* unionArray, TOperator constructorType, const TType& t, bool singleConstantParam)
+bool TIntermediate::parseConstTree(TSourceLoc line, TIntermNode* root, TConstUnion* unionArray, TOperator constructorType, const TType& t, bool singleConstantParam)
{
if (root == 0)
return false;
else
return false;
}
+
+} // end namespace glslang
#undef malloc
#undef free
+namespace glslang {
+
int TPpContext::InitCPP()
{
TPpContext::AtomTable* atable = &atomTable;
DeleteTokenStream(s->body);
}
-static int eof_scan(TPpContext*, TPpContext::InputSrc* in, TPpToken* yylvalpp) { return -1; }
-static void noop(TPpContext*, TPpContext::InputSrc* in, int ch, TPpToken* yylvalpp) { }
+int eof_scan(TPpContext*, TPpContext::InputSrc* in, TPpToken* yylvalpp) { return -1; }
+void noop(TPpContext*, TPpContext::InputSrc* in, int ch, TPpToken* yylvalpp) { }
void TPpContext::PushEofSrc()
{
return 0;
}
+
+} // end namespace glslang
\ No newline at end of file
#undef realloc
#undef free
+namespace {
+
+using namespace glslang;
+
///////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////// String table: //////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
-static const struct {
+const struct {
int val;
const char *str;
} tokens[] = {
* InitStringTable() - Initialize the string table.
*
*/
-
int InitStringTable(TPpContext::StringTable *stable)
{
stable->strings = (char *) malloc(INIT_STRING_TABLE_SIZE);
* FreeStringTable() - Free the string table.
*
*/
-
void FreeStringTable(TPpContext::StringTable *stable)
{
if (stable->strings)
* HashString() - Hash a string with the base hash function.
*
*/
-
-static int HashString(const char *s)
+int HashString(const char *s)
{
int hval = 0;
* HashString2() - Hash a string with the incrimenting hash function.
*
*/
-
-static int HashString2(const char *s)
+int HashString2(const char *s)
{
int hval = 0;
* AddString() - Add a string to a string table. Return it's offset.
*
*/
-
-static int AddString(TPpContext::StringTable *stable, const char *s)
+int AddString(TPpContext::StringTable *stable, const char *s)
{
int len, loc;
char *str;
* InitHashTable() - Initialize the hash table.
*
*/
-
-static int InitHashTable(TPpContext::HashTable *htable, int fsize)
+int InitHashTable(TPpContext::HashTable *htable, int fsize)
{
int ii;
* FreeHashTable() - Free the hash table.
*
*/
-
-static void FreeHashTable(TPpContext::HashTable *htable)
+void FreeHashTable(TPpContext::HashTable *htable)
{
if (htable->entry)
free(htable->entry);
* Empty() - See if a hash table entry is empty.
*
*/
-
-static int Empty(TPpContext::HashTable *htable, int hashloc)
+int Empty(TPpContext::HashTable *htable, int hashloc)
{
assert(hashloc >= 0 && hashloc < htable->size);
if (htable->entry[hashloc].index == 0) {
* Match() - See if a hash table entry is matches a string.
*
*/
-
-static int Match(TPpContext::HashTable *htable, TPpContext::StringTable *stable, const char *s, int hashloc)
+int Match(TPpContext::HashTable *htable, TPpContext::StringTable *stable, const char *s, int hashloc)
{
int strloc;
* GrowAtomTable() - Grow the atom table to at least "size" if it's smaller.
*
*/
-
int GrowAtomTable(TPpContext::AtomTable *atable, int size)
{
int *newmap, *newrev;
* lReverse() - Reverse the bottom 20 bits of a 32 bit int.
*
*/
-
-static int lReverse(int fval)
+int lReverse(int fval)
{
unsigned int in = fval;
int result = 0, cnt = 0;
* AllocateAtom() - Allocate a new atom. Associated with the "undefined" value of -1.
*
*/
-
int AllocateAtom(TPpContext::AtomTable *atable)
{
if (atable->nextFree >= atable->size)
* SetAtomValue() - Allocate a new atom associated with "hashindex".
*
*/
-
void SetAtomValue(TPpContext::AtomTable *atable, int atomnumber, int hashindex)
{
atable->amap[atomnumber] = atable->htable.entry[hashindex].index;
* FindHashLoc() - Find the hash location for this string. Return -1 it hash table is full.
*
*/
-
int FindHashLoc(TPpContext::AtomTable *atable, const char *s)
{
int hashloc, hashdelta, count;
return hashloc;
} // FindHashLoc
+} // end anonymous namespace
+
+namespace glslang {
+
/*
* IncreaseHashTableSize()
*
*/
-
int TPpContext::IncreaseHashTableSize(AtomTable *atable)
{
int ii, strloc, oldhashloc, value, size;
atable->size = 0;
} // FreeAtomTable
-///////////////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////// End of atom.c ///////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////
-
+} // end namespace glslang
#include "PpContext.h"
+namespace glslang {
+
TPpContext::TPpContext(TParseContext& pc) :
parseContext(pc), preamble(0), strings(0), notAVersionToken(false),
ScopeList(0), CurrentScope(0), GlobalScope(0)
currentString = 0;
}
}
+
+} // end namespace glslang
#include "../ParseHelper.h"
+namespace glslang {
+
class TPpToken {
public:
static const int maxTokenLength = 1024;
int mem_AddCleanup(MemoryPool *p, void (*fn)(void *, void*), void *arg1, void* arg2);
};
-#endif // PPCONTEXT_H
+} // end namespace glslang
+#endif // PPCONTEXT_H
#undef malloc
#undef free
+namespace glslang {
+
struct chunk {
struct chunk *next;
};
pool->cleanup = cleanup;
return 0;
}
+
+} // end namespace glslang
#include "PpContext.h"
#include "PpTokens.h"
-static int eof_scan(TPpContext*, TPpContext::InputSrc*, TPpToken*)
+namespace {
+
+using namespace glslang;
+
+int eof_scan(TPpContext*, TPpContext::InputSrc*, TPpToken*)
{
return EOF;
-} // eof_scan
+}
+
+void noop(TPpContext*, TPpContext::InputSrc *in, int ch, TPpToken * yylvalpp)
+{
+}
-static void noop(TPpContext*, TPpContext::InputSrc *in, int ch, TPpToken * yylvalpp) {}
-static TPpContext::InputSrc eof_inputsrc = { 0, &eof_scan, &eof_scan, &noop };
+TPpContext::InputSrc eof_inputsrc = { 0, &eof_scan, &eof_scan, &noop };
+
+} // end anonymous namespace
+
+namespace glslang {
int TPpContext::InitScanner(TPpContext *cpp)
{
return 0;
}
-///////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////// End of scanner.c //////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////
-
+} // end namespace glslang
/////////////////////////////////// Symbol Table Variables: ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
-static void unlinkScope(void *_scope, void* scopeList)
+namespace {
+
+using namespace glslang;
+
+void unlinkScope(void *_scope, void* scopeList)
{
TPpContext::Scope *scope = (TPpContext::Scope*)_scope;
*(TPpContext::Scope**)scopeList = scope->next;
}
+} // end anonymous namespace
+
+namespace glslang {
+
/*
* NewScope()
*
return NULL;
} // LookUpSymbol
+} // end namespace glslang
#include "PpContext.h"
#include "PpTokens.h"
+namespace glslang {
+
///////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////// Preprocessor and Token Recorder and Playback: ////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////
}
}
-///////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////// End of tokens.c ///////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////////////
+} // end namespace glslang
#define _vsnprintf vsnprintf
+namespace glslang {
void DetachThreadLinux(void *);
bool OS_FreeTLSIndex(OS_TLSIndex nIndex);
-inline void * OS_GetTLSValue(OS_TLSIndex nIndex)
+inline void* OS_GetTLSValue(OS_TLSIndex nIndex)
{
//
// This function should return 0 if nIndex is invalid.
return pthread_getspecific(nIndex);
}
-namespace glslang {
- void InitGlobalLock();
- void GetGlobalLock();
- void ReleaseGlobalLock();
+void InitGlobalLock();
+void GetGlobalLock();
+void ReleaseGlobalLock();
+
+typedef unsigned int (*TThreadEntrypoint)(void*);
+void* OS_CreateThread(TThreadEntrypoint);
+void OS_WaitForAllThreads(void* threads, int numThreads);
- typedef unsigned int (*TThreadEntrypoint)(void*);
- void* OS_CreateThread(TThreadEntrypoint);
- void OS_WaitForAllThreads(void* threads, int numThreads);
+void OS_Sleep(int milliseconds);
- void OS_Sleep(int milliseconds);
+void OS_DumpMemoryCounters();
- void OS_DumpMemoryCounters();
-};
+} // end namespace glslang
#endif // __OSINCLUDE_H
#include "osinclude.h"
#include "InitializeDll.h"
+namespace glslang {
+
//
// Thread cleanup
//
return false;
}
-namespace glslang {
- // TODO: if we need these on linux, flesh them out
- void InitGlobalLock() { }
- void GetGlobalLock() { }
- void ReleaseGlobalLock() { }
-
- void* OS_CreateThread(TThreadEntrypoint entry)
- {
- }
-
- void OS_WaitForAllThreads(void* threads, int numThreads)
- {
- }
-
- void OS_Sleep(int milliseconds)
- {
- }
-
- void OS_DumpMemoryCounters()
- {
- }
-};
+// TODO: if we need these on linux, flesh them out
+void InitGlobalLock() { }
+void GetGlobalLock() { }
+void ReleaseGlobalLock() { }
+
+void* OS_CreateThread(TThreadEntrypoint entry)
+{
+}
+
+void OS_WaitForAllThreads(void* threads, int numThreads)
+{
+}
+
+void OS_Sleep(int milliseconds)
+{
+}
+
+void OS_DumpMemoryCounters()
+{
+}
+
+} // end namespace glslang
{
case DLL_PROCESS_ATTACH:
- if (!InitProcess())
+ if (! glslang::InitProcess())
return FALSE;
break;
case DLL_THREAD_ATTACH:
- if (!InitThread())
+ if (! glslang::InitThread())
return FALSE;
break;
case DLL_THREAD_DETACH:
- if (!DetachThread())
+ if (! glslang::DetachThread())
return FALSE;
break;
case DLL_PROCESS_DETACH:
- DetachProcess();
+ glslang::DetachProcess();
break;
default:
#error Trying to include a windows specific file in a non windows build.
#endif
+namespace glslang {
+
//
// Thread Local Storage Operations
//
void* OS_GetTLSValue(OS_TLSIndex nIndex);
-namespace glslang {
- void InitGlobalLock();
- void GetGlobalLock();
- void ReleaseGlobalLock();
+void InitGlobalLock();
+void GetGlobalLock();
+void ReleaseGlobalLock();
+
+typedef unsigned int (__stdcall *TThreadEntrypoint)(void*);
+void* OS_CreateThread(TThreadEntrypoint);
+void OS_WaitForAllThreads(void* threads, int numThreads);
- typedef unsigned int (__stdcall *TThreadEntrypoint)(void*);
- void* OS_CreateThread(TThreadEntrypoint);
- void OS_WaitForAllThreads(void* threads, int numThreads);
+void OS_Sleep(int milliseconds);
- void OS_Sleep(int milliseconds);
+void OS_DumpMemoryCounters();
- void OS_DumpMemoryCounters();
-};
+} // end namespace glslang
#endif // __OSINCLUDE_H
#error Trying to build a windows specific file in a non windows build.
#endif
+namespace glslang {
+
//
// Thread Local Storage Operations
//
return false;
}
-namespace glslang {
- HANDLE GlobalLock;
-
- void InitGlobalLock()
- {
- GlobalLock = CreateMutex(0, false, 0);
- }
-
- void GetGlobalLock()
- {
- WaitForSingleObject(GlobalLock, INFINITE);
- }
-
- void ReleaseGlobalLock()
- {
- ReleaseMutex(GlobalLock);
- }
-
- void* OS_CreateThread(TThreadEntrypoint entry)
- {
- return (void*)_beginthreadex(0, 0, entry, 0, 0, 0);
- //return CreateThread(0, 0, entry, 0, 0, 0);
- }
-
- void OS_WaitForAllThreads(void* threads, int numThreads)
- {
- WaitForMultipleObjects(numThreads, (HANDLE*)threads, true, INFINITE);
- }
-
- void OS_Sleep(int milliseconds)
- {
- Sleep(milliseconds);
- }
-
- void OS_DumpMemoryCounters()
- {
- PROCESS_MEMORY_COUNTERS counters;
- GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters));
- printf("Working set size: %d\n", counters.WorkingSetSize);
- }
-};
+HANDLE GlobalLock;
+
+void InitGlobalLock()
+{
+ GlobalLock = CreateMutex(0, false, 0);
+}
+
+void GetGlobalLock()
+{
+ WaitForSingleObject(GlobalLock, INFINITE);
+}
+
+void ReleaseGlobalLock()
+{
+ ReleaseMutex(GlobalLock);
+}
+
+void* OS_CreateThread(TThreadEntrypoint entry)
+{
+ return (void*)_beginthreadex(0, 0, entry, 0, 0, 0);
+ //return CreateThread(0, 0, entry, 0, 0, 0);
+}
+
+void OS_WaitForAllThreads(void* threads, int numThreads)
+{
+ WaitForMultipleObjects(numThreads, (HANDLE*)threads, true, INFINITE);
+}
+
+void OS_Sleep(int milliseconds)
+{
+ Sleep(milliseconds);
+}
+
+void OS_DumpMemoryCounters()
+{
+ PROCESS_MEMORY_COUNTERS counters;
+ GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters));
+ printf("Working set size: %d\n", counters.WorkingSetSize);
+}
+
+} // namespace glslang
projects / platform / upstream / glslang.git / commitdiff