Skip to content

A
angle
Commit 0578f81c by daniel@transgaming.com
Options

Untabify compiler code

TRAC #12156 Signed-off-by: Shannon Woods Signed-off-by: Daniel Koch Author: Nicolas Capens git-svn-id: https://angleproject.googlecode.com/svn/trunk@292 736b8ea6-26fd-11df-bfd4-992fa37f6226
parent 0a311a46
Showing with 1093 additions and 1093 deletions
src/compiler/BaseTypes.h
...@@ -12,20 +12,20 @@ ...@@ -12,20 +12,20 @@
// //
enum TPrecision enum TPrecision
{ {
EbpHigh, EbpHigh,
EbpMedium, EbpMedium,
EbpLow, EbpLow,
}; };
__inline const char* getPrecisionString(TPrecision p) __inline const char* getPrecisionString(TPrecision p)
{ {
switch(p) switch(p)
{ {
case EbpHigh: return "highp"; break; case EbpHigh: return "highp"; break;
case EbpMedium: return "mediump"; break; case EbpMedium: return "mediump"; break;
case EbpLow: return "lowp"; break; case EbpLow: return "lowp"; break;
default: return "unknown precision"; default: return "unknown precision";
} }
} }
// //
...@@ -33,21 +33,21 @@ __inline const char* getPrecisionString(TPrecision p) ...@@ -33,21 +33,21 @@ __inline const char* getPrecisionString(TPrecision p)
// //
enum TBasicType enum TBasicType
{ {
EbtVoid, EbtVoid,
EbtFloat, EbtFloat,
EbtInt, EbtInt,
EbtBool, EbtBool,
EbtGuardSamplerBegin, // non type: see implementation of IsSampler() EbtGuardSamplerBegin, // non type: see implementation of IsSampler()
EbtSampler2D, EbtSampler2D,
EbtSamplerCube, EbtSamplerCube,
EbtGuardSamplerEnd, // non type: see implementation of IsSampler() EbtGuardSamplerEnd, // non type: see implementation of IsSampler()
EbtStruct, EbtStruct,
EbtAddress, // should be deprecated?? EbtAddress, // should be deprecated??
}; };
__inline bool IsSampler(TBasicType type) __inline bool IsSampler(TBasicType type)
{ {
return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd; return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd;
} }
// //
...@@ -58,41 +58,41 @@ __inline bool IsSampler(TBasicType type) ...@@ -58,41 +58,41 @@ __inline bool IsSampler(TBasicType type)
// //
enum TQualifier enum TQualifier
{ {
EvqTemporary, // For temporaries (within a function), read/write EvqTemporary, // For temporaries (within a function), read/write
EvqGlobal, // For globals read/write EvqGlobal, // For globals read/write
EvqConst, // User defined constants and non-output parameters in functions EvqConst, // User defined constants and non-output parameters in functions
EvqAttribute, // Readonly EvqAttribute, // Readonly
EvqVaryingIn, // readonly, fragment shaders only EvqVaryingIn, // readonly, fragment shaders only
EvqVaryingOut, // vertex shaders only read/write EvqVaryingOut, // vertex shaders only read/write
EvqInvariantVaryingIn, // readonly, fragment shaders only EvqInvariantVaryingIn, // readonly, fragment shaders only
EvqInvariantVaryingOut, // vertex shaders only read/write EvqInvariantVaryingOut, // vertex shaders only read/write
EvqUniform, // Readonly, vertex and fragment EvqUniform, // Readonly, vertex and fragment
// pack/unpack input and output // pack/unpack input and output
EvqInput, EvqInput,
EvqOutput, EvqOutput,
// parameters // parameters
EvqIn, EvqIn,
EvqOut, EvqOut,
EvqInOut, EvqInOut,
EvqConstReadOnly, EvqConstReadOnly,
// built-ins written by vertex shader // built-ins written by vertex shader
EvqPosition, EvqPosition,
EvqPointSize, EvqPointSize,
// built-ins read by fragment shader // built-ins read by fragment shader
EvqFragCoord, EvqFragCoord,
EvqFrontFacing, EvqFrontFacing,
EvqPointCoord, EvqPointCoord,
// built-ins written by fragment shader // built-ins written by fragment shader
EvqFragColor, EvqFragColor,
EvqFragData, EvqFragData,
// end of list // end of list
EvqLast, EvqLast,
}; };
// //
...@@ -100,31 +100,31 @@ enum TQualifier ...@@ -100,31 +100,31 @@ enum TQualifier
// //
__inline const char* getQualifierString(TQualifier q) __inline const char* getQualifierString(TQualifier q)
{ {
switch(q) switch(q)
{ {
case EvqTemporary: return "Temporary"; break; case EvqTemporary: return "Temporary"; break;
case EvqGlobal: return "Global"; break; case EvqGlobal: return "Global"; break;
case EvqConst: return "const"; break; case EvqConst: return "const"; break;
case EvqConstReadOnly: return "const"; break; case EvqConstReadOnly: return "const"; break;
case EvqAttribute: return "attribute"; break; case EvqAttribute: return "attribute"; break;
case EvqVaryingIn: return "varying"; break; case EvqVaryingIn: return "varying"; break;
case EvqVaryingOut: return "varying"; break; case EvqVaryingOut: return "varying"; break;
case EvqInvariantVaryingIn: return "invariant varying"; break; case EvqInvariantVaryingIn: return "invariant varying"; break;
case EvqInvariantVaryingOut:return "invariant varying"; break; case EvqInvariantVaryingOut:return "invariant varying"; break;
case EvqUniform: return "uniform"; break; case EvqUniform: return "uniform"; break;
case EvqIn: return "in"; break; case EvqIn: return "in"; break;
case EvqOut: return "out"; break; case EvqOut: return "out"; break;
case EvqInOut: return "inout"; break; case EvqInOut: return "inout"; break;
case EvqInput: return "input"; break; case EvqInput: return "input"; break;
case EvqOutput: return "output"; break; case EvqOutput: return "output"; break;
case EvqPosition: return "Position"; break; case EvqPosition: return "Position"; break;
case EvqPointSize: return "PointSize"; break; case EvqPointSize: return "PointSize"; break;
case EvqFragCoord: return "FragCoord"; break; case EvqFragCoord: return "FragCoord"; break;
case EvqFrontFacing: return "FrontFacing"; break; case EvqFrontFacing: return "FrontFacing"; break;
case EvqFragColor: return "FragColor"; break; case EvqFragColor: return "FragColor"; break;
case EvqFragData: return "FragData"; break; case EvqFragData: return "FragData"; break;
default: return "unknown qualifier"; default: return "unknown qualifier";
} }
} }
#endif // _BASICTYPES_INCLUDED_ #endif // _BASICTYPES_INCLUDED_
src/compiler/Initialize.cpp
...@@ -16,590 +16,590 @@ ...@@ -16,590 +16,590 @@
void TBuiltIns::initialize() void TBuiltIns::initialize()
{ {
// //
// Initialize all the built-in strings for parsing. // Initialize all the built-in strings for parsing.
// //
TString BuiltInFunctions; TString BuiltInFunctions;
TString BuiltInFunctionsVertex; TString BuiltInFunctionsVertex;
TString BuiltInFunctionsFragment; TString BuiltInFunctionsFragment;
TString StandardUniforms; TString StandardUniforms;
{ {
//============================================================================ //============================================================================
// //
// Prototypes for built-in functions seen by both vertex and fragment shaders. // Prototypes for built-in functions seen by both vertex and fragment shaders.
// //
//============================================================================ //============================================================================
TString& s = BuiltInFunctions; TString& s = BuiltInFunctions;
// //
// Angle and Trigonometric Functions. // Angle and Trigonometric Functions.
// //
s.append(TString("float radians(float degrees);")); s.append(TString("float radians(float degrees);"));
s.append(TString("vec2 radians(vec2 degrees);")); s.append(TString("vec2 radians(vec2 degrees);"));
s.append(TString("vec3 radians(vec3 degrees);")); s.append(TString("vec3 radians(vec3 degrees);"));
s.append(TString("vec4 radians(vec4 degrees);")); s.append(TString("vec4 radians(vec4 degrees);"));
s.append(TString("float degrees(float radians);")); s.append(TString("float degrees(float radians);"));
s.append(TString("vec2 degrees(vec2 radians);")); s.append(TString("vec2 degrees(vec2 radians);"));
s.append(TString("vec3 degrees(vec3 radians);")); s.append(TString("vec3 degrees(vec3 radians);"));
s.append(TString("vec4 degrees(vec4 radians);")); s.append(TString("vec4 degrees(vec4 radians);"));
s.append(TString("float sin(float angle);")); s.append(TString("float sin(float angle);"));
s.append(TString("vec2 sin(vec2 angle);")); s.append(TString("vec2 sin(vec2 angle);"));
s.append(TString("vec3 sin(vec3 angle);")); s.append(TString("vec3 sin(vec3 angle);"));
s.append(TString("vec4 sin(vec4 angle);")); s.append(TString("vec4 sin(vec4 angle);"));
s.append(TString("float cos(float angle);")); s.append(TString("float cos(float angle);"));
s.append(TString("vec2 cos(vec2 angle);")); s.append(TString("vec2 cos(vec2 angle);"));
s.append(TString("vec3 cos(vec3 angle);")); s.append(TString("vec3 cos(vec3 angle);"));
s.append(TString("vec4 cos(vec4 angle);")); s.append(TString("vec4 cos(vec4 angle);"));
s.append(TString("float tan(float angle);")); s.append(TString("float tan(float angle);"));
s.append(TString("vec2 tan(vec2 angle);")); s.append(TString("vec2 tan(vec2 angle);"));
s.append(TString("vec3 tan(vec3 angle);")); s.append(TString("vec3 tan(vec3 angle);"));
s.append(TString("vec4 tan(vec4 angle);")); s.append(TString("vec4 tan(vec4 angle);"));
s.append(TString("float asin(float x);")); s.append(TString("float asin(float x);"));
s.append(TString("vec2 asin(vec2 x);")); s.append(TString("vec2 asin(vec2 x);"));
s.append(TString("vec3 asin(vec3 x);")); s.append(TString("vec3 asin(vec3 x);"));
s.append(TString("vec4 asin(vec4 x);")); s.append(TString("vec4 asin(vec4 x);"));
s.append(TString("float acos(float x);")); s.append(TString("float acos(float x);"));
s.append(TString("vec2 acos(vec2 x);")); s.append(TString("vec2 acos(vec2 x);"));
s.append(TString("vec3 acos(vec3 x);")); s.append(TString("vec3 acos(vec3 x);"));
s.append(TString("vec4 acos(vec4 x);")); s.append(TString("vec4 acos(vec4 x);"));
s.append(TString("float atan(float y, float x);")); s.append(TString("float atan(float y, float x);"));
s.append(TString("vec2 atan(vec2 y, vec2 x);")); s.append(TString("vec2 atan(vec2 y, vec2 x);"));
s.append(TString("vec3 atan(vec3 y, vec3 x);")); s.append(TString("vec3 atan(vec3 y, vec3 x);"));
s.append(TString("vec4 atan(vec4 y, vec4 x);")); s.append(TString("vec4 atan(vec4 y, vec4 x);"));
s.append(TString("float atan(float y_over_x);")); s.append(TString("float atan(float y_over_x);"));
s.append(TString("vec2 atan(vec2 y_over_x);")); s.append(TString("vec2 atan(vec2 y_over_x);"));
s.append(TString("vec3 atan(vec3 y_over_x);")); s.append(TString("vec3 atan(vec3 y_over_x);"));
s.append(TString("vec4 atan(vec4 y_over_x);")); s.append(TString("vec4 atan(vec4 y_over_x);"));
// //
// Exponential Functions. // Exponential Functions.
// //
s.append(TString("float pow(float x, float y);")); s.append(TString("float pow(float x, float y);"));
s.append(TString("vec2 pow(vec2 x, vec2 y);")); s.append(TString("vec2 pow(vec2 x, vec2 y);"));
s.append(TString("vec3 pow(vec3 x, vec3 y);")); s.append(TString("vec3 pow(vec3 x, vec3 y);"));
s.append(TString("vec4 pow(vec4 x, vec4 y);")); s.append(TString("vec4 pow(vec4 x, vec4 y);"));
s.append(TString("float exp(float x);")); s.append(TString("float exp(float x);"));
s.append(TString("vec2 exp(vec2 x);")); s.append(TString("vec2 exp(vec2 x);"));
s.append(TString("vec3 exp(vec3 x);")); s.append(TString("vec3 exp(vec3 x);"));
s.append(TString("vec4 exp(vec4 x);")); s.append(TString("vec4 exp(vec4 x);"));
s.append(TString("float log(float x);")); s.append(TString("float log(float x);"));
s.append(TString("vec2 log(vec2 x);")); s.append(TString("vec2 log(vec2 x);"));
s.append(TString("vec3 log(vec3 x);")); s.append(TString("vec3 log(vec3 x);"));
s.append(TString("vec4 log(vec4 x);")); s.append(TString("vec4 log(vec4 x);"));
s.append(TString("float exp2(float x);")); s.append(TString("float exp2(float x);"));
s.append(TString("vec2 exp2(vec2 x);")); s.append(TString("vec2 exp2(vec2 x);"));
s.append(TString("vec3 exp2(vec3 x);")); s.append(TString("vec3 exp2(vec3 x);"));
s.append(TString("vec4 exp2(vec4 x);")); s.append(TString("vec4 exp2(vec4 x);"));
s.append(TString("float log2(float x);")); s.append(TString("float log2(float x);"));
s.append(TString("vec2 log2(vec2 x);")); s.append(TString("vec2 log2(vec2 x);"));
s.append(TString("vec3 log2(vec3 x);")); s.append(TString("vec3 log2(vec3 x);"));
s.append(TString("vec4 log2(vec4 x);")); s.append(TString("vec4 log2(vec4 x);"));
s.append(TString("float sqrt(float x);")); s.append(TString("float sqrt(float x);"));
s.append(TString("vec2 sqrt(vec2 x);")); s.append(TString("vec2 sqrt(vec2 x);"));
s.append(TString("vec3 sqrt(vec3 x);")); s.append(TString("vec3 sqrt(vec3 x);"));
s.append(TString("vec4 sqrt(vec4 x);")); s.append(TString("vec4 sqrt(vec4 x);"));
s.append(TString("float inversesqrt(float x);")); s.append(TString("float inversesqrt(float x);"));
s.append(TString("vec2 inversesqrt(vec2 x);")); s.append(TString("vec2 inversesqrt(vec2 x);"));
s.append(TString("vec3 inversesqrt(vec3 x);")); s.append(TString("vec3 inversesqrt(vec3 x);"));
s.append(TString("vec4 inversesqrt(vec4 x);")); s.append(TString("vec4 inversesqrt(vec4 x);"));
// //
// Common Functions. // Common Functions.
// //
s.append(TString("float abs(float x);")); s.append(TString("float abs(float x);"));
s.append(TString("vec2 abs(vec2 x);")); s.append(TString("vec2 abs(vec2 x);"));
s.append(TString("vec3 abs(vec3 x);")); s.append(TString("vec3 abs(vec3 x);"));
s.append(TString("vec4 abs(vec4 x);")); s.append(TString("vec4 abs(vec4 x);"));
s.append(TString("float sign(float x);")); s.append(TString("float sign(float x);"));
s.append(TString("vec2 sign(vec2 x);")); s.append(TString("vec2 sign(vec2 x);"));
s.append(TString("vec3 sign(vec3 x);")); s.append(TString("vec3 sign(vec3 x);"));
s.append(TString("vec4 sign(vec4 x);")); s.append(TString("vec4 sign(vec4 x);"));
s.append(TString("float floor(float x);")); s.append(TString("float floor(float x);"));
s.append(TString("vec2 floor(vec2 x);")); s.append(TString("vec2 floor(vec2 x);"));
s.append(TString("vec3 floor(vec3 x);")); s.append(TString("vec3 floor(vec3 x);"));
s.append(TString("vec4 floor(vec4 x);")); s.append(TString("vec4 floor(vec4 x);"));
s.append(TString("float ceil(float x);")); s.append(TString("float ceil(float x);"));
s.append(TString("vec2 ceil(vec2 x);")); s.append(TString("vec2 ceil(vec2 x);"));
s.append(TString("vec3 ceil(vec3 x);")); s.append(TString("vec3 ceil(vec3 x);"));
s.append(TString("vec4 ceil(vec4 x);")); s.append(TString("vec4 ceil(vec4 x);"));
s.append(TString("float fract(float x);")); s.append(TString("float fract(float x);"));
s.append(TString("vec2 fract(vec2 x);")); s.append(TString("vec2 fract(vec2 x);"));
s.append(TString("vec3 fract(vec3 x);")); s.append(TString("vec3 fract(vec3 x);"));
s.append(TString("vec4 fract(vec4 x);")); s.append(TString("vec4 fract(vec4 x);"));
s.append(TString("float mod(float x, float y);")); s.append(TString("float mod(float x, float y);"));
s.append(TString("vec2 mod(vec2 x, float y);")); s.append(TString("vec2 mod(vec2 x, float y);"));
s.append(TString("vec3 mod(vec3 x, float y);")); s.append(TString("vec3 mod(vec3 x, float y);"));
s.append(TString("vec4 mod(vec4 x, float y);")); s.append(TString("vec4 mod(vec4 x, float y);"));
s.append(TString("vec2 mod(vec2 x, vec2 y);")); s.append(TString("vec2 mod(vec2 x, vec2 y);"));
s.append(TString("vec3 mod(vec3 x, vec3 y);")); s.append(TString("vec3 mod(vec3 x, vec3 y);"));
s.append(TString("vec4 mod(vec4 x, vec4 y);")); s.append(TString("vec4 mod(vec4 x, vec4 y);"));
s.append(TString("float min(float x, float y);")); s.append(TString("float min(float x, float y);"));
s.append(TString("vec2 min(vec2 x, float y);")); s.append(TString("vec2 min(vec2 x, float y);"));
s.append(TString("vec3 min(vec3 x, float y);")); s.append(TString("vec3 min(vec3 x, float y);"));
s.append(TString("vec4 min(vec4 x, float y);")); s.append(TString("vec4 min(vec4 x, float y);"));
s.append(TString("vec2 min(vec2 x, vec2 y);")); s.append(TString("vec2 min(vec2 x, vec2 y);"));
s.append(TString("vec3 min(vec3 x, vec3 y);")); s.append(TString("vec3 min(vec3 x, vec3 y);"));
s.append(TString("vec4 min(vec4 x, vec4 y);")); s.append(TString("vec4 min(vec4 x, vec4 y);"));
s.append(TString("float max(float x, float y);")); s.append(TString("float max(float x, float y);"));
s.append(TString("vec2 max(vec2 x, float y);")); s.append(TString("vec2 max(vec2 x, float y);"));
s.append(TString("vec3 max(vec3 x, float y);")); s.append(TString("vec3 max(vec3 x, float y);"));
s.append(TString("vec4 max(vec4 x, float y);")); s.append(TString("vec4 max(vec4 x, float y);"));
s.append(TString("vec2 max(vec2 x, vec2 y);")); s.append(TString("vec2 max(vec2 x, vec2 y);"));
s.append(TString("vec3 max(vec3 x, vec3 y);")); s.append(TString("vec3 max(vec3 x, vec3 y);"));
s.append(TString("vec4 max(vec4 x, vec4 y);")); s.append(TString("vec4 max(vec4 x, vec4 y);"));
s.append(TString("float clamp(float x, float minVal, float maxVal);")); s.append(TString("float clamp(float x, float minVal, float maxVal);"));
s.append(TString("vec2 clamp(vec2 x, float minVal, float maxVal);")); s.append(TString("vec2 clamp(vec2 x, float minVal, float maxVal);"));
s.append(TString("vec3 clamp(vec3 x, float minVal, float maxVal);")); s.append(TString("vec3 clamp(vec3 x, float minVal, float maxVal);"));
s.append(TString("vec4 clamp(vec4 x, float minVal, float maxVal);")); s.append(TString("vec4 clamp(vec4 x, float minVal, float maxVal);"));
s.append(TString("vec2 clamp(vec2 x, vec2 minVal, vec2 maxVal);")); s.append(TString("vec2 clamp(vec2 x, vec2 minVal, vec2 maxVal);"));
s.append(TString("vec3 clamp(vec3 x, vec3 minVal, vec3 maxVal);")); s.append(TString("vec3 clamp(vec3 x, vec3 minVal, vec3 maxVal);"));
s.append(TString("vec4 clamp(vec4 x, vec4 minVal, vec4 maxVal);")); s.append(TString("vec4 clamp(vec4 x, vec4 minVal, vec4 maxVal);"));
s.append(TString("float mix(float x, float y, float a);")); s.append(TString("float mix(float x, float y, float a);"));
s.append(TString("vec2 mix(vec2 x, vec2 y, float a);")); s.append(TString("vec2 mix(vec2 x, vec2 y, float a);"));
s.append(TString("vec3 mix(vec3 x, vec3 y, float a);")); s.append(TString("vec3 mix(vec3 x, vec3 y, float a);"));
s.append(TString("vec4 mix(vec4 x, vec4 y, float a);")); s.append(TString("vec4 mix(vec4 x, vec4 y, float a);"));
s.append(TString("vec2 mix(vec2 x, vec2 y, vec2 a);")); s.append(TString("vec2 mix(vec2 x, vec2 y, vec2 a);"));
s.append(TString("vec3 mix(vec3 x, vec3 y, vec3 a);")); s.append(TString("vec3 mix(vec3 x, vec3 y, vec3 a);"));
s.append(TString("vec4 mix(vec4 x, vec4 y, vec4 a);")); s.append(TString("vec4 mix(vec4 x, vec4 y, vec4 a);"));
s.append(TString("float step(float edge, float x);")); s.append(TString("float step(float edge, float x);"));
s.append(TString("vec2 step(vec2 edge, vec2 x);")); s.append(TString("vec2 step(vec2 edge, vec2 x);"));
s.append(TString("vec3 step(vec3 edge, vec3 x);")); s.append(TString("vec3 step(vec3 edge, vec3 x);"));
s.append(TString("vec4 step(vec4 edge, vec4 x);")); s.append(TString("vec4 step(vec4 edge, vec4 x);"));
s.append(TString("vec2 step(float edge, vec2 x);")); s.append(TString("vec2 step(float edge, vec2 x);"));
s.append(TString("vec3 step(float edge, vec3 x);")); s.append(TString("vec3 step(float edge, vec3 x);"));
s.append(TString("vec4 step(float edge, vec4 x);")); s.append(TString("vec4 step(float edge, vec4 x);"));
s.append(TString("float smoothstep(float edge0, float edge1, float x);")); s.append(TString("float smoothstep(float edge0, float edge1, float x);"));
s.append(TString("vec2 smoothstep(vec2 edge0, vec2 edge1, vec2 x);")); s.append(TString("vec2 smoothstep(vec2 edge0, vec2 edge1, vec2 x);"));
s.append(TString("vec3 smoothstep(vec3 edge0, vec3 edge1, vec3 x);")); s.append(TString("vec3 smoothstep(vec3 edge0, vec3 edge1, vec3 x);"));
s.append(TString("vec4 smoothstep(vec4 edge0, vec4 edge1, vec4 x);")); s.append(TString("vec4 smoothstep(vec4 edge0, vec4 edge1, vec4 x);"));
s.append(TString("vec2 smoothstep(float edge0, float edge1, vec2 x);")); s.append(TString("vec2 smoothstep(float edge0, float edge1, vec2 x);"));
s.append(TString("vec3 smoothstep(float edge0, float edge1, vec3 x);")); s.append(TString("vec3 smoothstep(float edge0, float edge1, vec3 x);"));
s.append(TString("vec4 smoothstep(float edge0, float edge1, vec4 x);")); s.append(TString("vec4 smoothstep(float edge0, float edge1, vec4 x);"));
// //
// Geometric Functions. // Geometric Functions.
// //
s.append(TString("float length(float x);")); s.append(TString("float length(float x);"));
s.append(TString("float length(vec2 x);")); s.append(TString("float length(vec2 x);"));
s.append(TString("float length(vec3 x);")); s.append(TString("float length(vec3 x);"));
s.append(TString("float length(vec4 x);")); s.append(TString("float length(vec4 x);"));
s.append(TString("float distance(float p0, float p1);")); s.append(TString("float distance(float p0, float p1);"));
s.append(TString("float distance(vec2 p0, vec2 p1);")); s.append(TString("float distance(vec2 p0, vec2 p1);"));
s.append(TString("float distance(vec3 p0, vec3 p1);")); s.append(TString("float distance(vec3 p0, vec3 p1);"));
s.append(TString("float distance(vec4 p0, vec4 p1);")); s.append(TString("float distance(vec4 p0, vec4 p1);"));
s.append(TString("float dot(float x, float y);")); s.append(TString("float dot(float x, float y);"));
s.append(TString("float dot(vec2 x, vec2 y);")); s.append(TString("float dot(vec2 x, vec2 y);"));
s.append(TString("float dot(vec3 x, vec3 y);")); s.append(TString("float dot(vec3 x, vec3 y);"));
s.append(TString("float dot(vec4 x, vec4 y);")); s.append(TString("float dot(vec4 x, vec4 y);"));
s.append(TString("vec3 cross(vec3 x, vec3 y);")); s.append(TString("vec3 cross(vec3 x, vec3 y);"));
s.append(TString("float normalize(float x);")); s.append(TString("float normalize(float x);"));
s.append(TString("vec2 normalize(vec2 x);")); s.append(TString("vec2 normalize(vec2 x);"));
s.append(TString("vec3 normalize(vec3 x);")); s.append(TString("vec3 normalize(vec3 x);"));
s.append(TString("vec4 normalize(vec4 x);")); s.append(TString("vec4 normalize(vec4 x);"));
s.append(TString("float faceforward(float N, float I, float Nref);")); s.append(TString("float faceforward(float N, float I, float Nref);"));
s.append(TString("vec2 faceforward(vec2 N, vec2 I, vec2 Nref);")); s.append(TString("vec2 faceforward(vec2 N, vec2 I, vec2 Nref);"));
s.append(TString("vec3 faceforward(vec3 N, vec3 I, vec3 Nref);")); s.append(TString("vec3 faceforward(vec3 N, vec3 I, vec3 Nref);"));
s.append(TString("vec4 faceforward(vec4 N, vec4 I, vec4 Nref);")); s.append(TString("vec4 faceforward(vec4 N, vec4 I, vec4 Nref);"));
s.append(TString("float reflect(float I, float N);")); s.append(TString("float reflect(float I, float N);"));
s.append(TString("vec2 reflect(vec2 I, vec2 N);")); s.append(TString("vec2 reflect(vec2 I, vec2 N);"));
s.append(TString("vec3 reflect(vec3 I, vec3 N);")); s.append(TString("vec3 reflect(vec3 I, vec3 N);"));
s.append(TString("vec4 reflect(vec4 I, vec4 N);")); s.append(TString("vec4 reflect(vec4 I, vec4 N);"));
s.append(TString("float refract(float I, float N, float eta);")); s.append(TString("float refract(float I, float N, float eta);"));
s.append(TString("vec2 refract(vec2 I, vec2 N, float eta);")); s.append(TString("vec2 refract(vec2 I, vec2 N, float eta);"));
s.append(TString("vec3 refract(vec3 I, vec3 N, float eta);")); s.append(TString("vec3 refract(vec3 I, vec3 N, float eta);"));
s.append(TString("vec4 refract(vec4 I, vec4 N, float eta);")); s.append(TString("vec4 refract(vec4 I, vec4 N, float eta);"));
// //
// Matrix Functions. // Matrix Functions.
// //
s.append(TString("mat2 matrixCompMult(mat2 x, mat2 y);")); s.append(TString("mat2 matrixCompMult(mat2 x, mat2 y);"));
s.append(TString("mat3 matrixCompMult(mat3 x, mat3 y);")); s.append(TString("mat3 matrixCompMult(mat3 x, mat3 y);"));
s.append(TString("mat4 matrixCompMult(mat4 x, mat4 y);")); s.append(TString("mat4 matrixCompMult(mat4 x, mat4 y);"));
// //
// Vector relational functions. // Vector relational functions.
// //
s.append(TString("bvec2 lessThan(vec2 x, vec2 y);")); s.append(TString("bvec2 lessThan(vec2 x, vec2 y);"));
s.append(TString("bvec3 lessThan(vec3 x, vec3 y);")); s.append(TString("bvec3 lessThan(vec3 x, vec3 y);"));
s.append(TString("bvec4 lessThan(vec4 x, vec4 y);")); s.append(TString("bvec4 lessThan(vec4 x, vec4 y);"));
s.append(TString("bvec2 lessThan(ivec2 x, ivec2 y);")); s.append(TString("bvec2 lessThan(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 lessThan(ivec3 x, ivec3 y);")); s.append(TString("bvec3 lessThan(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 lessThan(ivec4 x, ivec4 y);")); s.append(TString("bvec4 lessThan(ivec4 x, ivec4 y);"));
s.append(TString("bvec2 lessThanEqual(vec2 x, vec2 y);")); s.append(TString("bvec2 lessThanEqual(vec2 x, vec2 y);"));
s.append(TString("bvec3 lessThanEqual(vec3 x, vec3 y);")); s.append(TString("bvec3 lessThanEqual(vec3 x, vec3 y);"));
s.append(TString("bvec4 lessThanEqual(vec4 x, vec4 y);")); s.append(TString("bvec4 lessThanEqual(vec4 x, vec4 y);"));
s.append(TString("bvec2 lessThanEqual(ivec2 x, ivec2 y);")); s.append(TString("bvec2 lessThanEqual(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 lessThanEqual(ivec3 x, ivec3 y);")); s.append(TString("bvec3 lessThanEqual(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 lessThanEqual(ivec4 x, ivec4 y);")); s.append(TString("bvec4 lessThanEqual(ivec4 x, ivec4 y);"));
s.append(TString("bvec2 greaterThan(vec2 x, vec2 y);")); s.append(TString("bvec2 greaterThan(vec2 x, vec2 y);"));
s.append(TString("bvec3 greaterThan(vec3 x, vec3 y);")); s.append(TString("bvec3 greaterThan(vec3 x, vec3 y);"));
s.append(TString("bvec4 greaterThan(vec4 x, vec4 y);")); s.append(TString("bvec4 greaterThan(vec4 x, vec4 y);"));
s.append(TString("bvec2 greaterThan(ivec2 x, ivec2 y);")); s.append(TString("bvec2 greaterThan(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 greaterThan(ivec3 x, ivec3 y);")); s.append(TString("bvec3 greaterThan(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 greaterThan(ivec4 x, ivec4 y);")); s.append(TString("bvec4 greaterThan(ivec4 x, ivec4 y);"));
s.append(TString("bvec2 greaterThanEqual(vec2 x, vec2 y);")); s.append(TString("bvec2 greaterThanEqual(vec2 x, vec2 y);"));
s.append(TString("bvec3 greaterThanEqual(vec3 x, vec3 y);")); s.append(TString("bvec3 greaterThanEqual(vec3 x, vec3 y);"));
s.append(TString("bvec4 greaterThanEqual(vec4 x, vec4 y);")); s.append(TString("bvec4 greaterThanEqual(vec4 x, vec4 y);"));
s.append(TString("bvec2 greaterThanEqual(ivec2 x, ivec2 y);")); s.append(TString("bvec2 greaterThanEqual(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 greaterThanEqual(ivec3 x, ivec3 y);")); s.append(TString("bvec3 greaterThanEqual(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 greaterThanEqual(ivec4 x, ivec4 y);")); s.append(TString("bvec4 greaterThanEqual(ivec4 x, ivec4 y);"));
s.append(TString("bvec2 equal(vec2 x, vec2 y);")); s.append(TString("bvec2 equal(vec2 x, vec2 y);"));
s.append(TString("bvec3 equal(vec3 x, vec3 y);")); s.append(TString("bvec3 equal(vec3 x, vec3 y);"));
s.append(TString("bvec4 equal(vec4 x, vec4 y);")); s.append(TString("bvec4 equal(vec4 x, vec4 y);"));
s.append(TString("bvec2 equal(ivec2 x, ivec2 y);")); s.append(TString("bvec2 equal(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 equal(ivec3 x, ivec3 y);")); s.append(TString("bvec3 equal(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 equal(ivec4 x, ivec4 y);")); s.append(TString("bvec4 equal(ivec4 x, ivec4 y);"));
s.append(TString("bvec2 equal(bvec2 x, bvec2 y);")); s.append(TString("bvec2 equal(bvec2 x, bvec2 y);"));
s.append(TString("bvec3 equal(bvec3 x, bvec3 y);")); s.append(TString("bvec3 equal(bvec3 x, bvec3 y);"));
s.append(TString("bvec4 equal(bvec4 x, bvec4 y);")); s.append(TString("bvec4 equal(bvec4 x, bvec4 y);"));
s.append(TString("bvec2 notEqual(vec2 x, vec2 y);")); s.append(TString("bvec2 notEqual(vec2 x, vec2 y);"));
s.append(TString("bvec3 notEqual(vec3 x, vec3 y);")); s.append(TString("bvec3 notEqual(vec3 x, vec3 y);"));
s.append(TString("bvec4 notEqual(vec4 x, vec4 y);")); s.append(TString("bvec4 notEqual(vec4 x, vec4 y);"));
s.append(TString("bvec2 notEqual(ivec2 x, ivec2 y);")); s.append(TString("bvec2 notEqual(ivec2 x, ivec2 y);"));
s.append(TString("bvec3 notEqual(ivec3 x, ivec3 y);")); s.append(TString("bvec3 notEqual(ivec3 x, ivec3 y);"));
s.append(TString("bvec4 notEqual(ivec4 x, ivec4 y);")); s.append(TString("bvec4 notEqual(ivec4 x, ivec4 y);"));
s.append(TString("bvec2 notEqual(bvec2 x, bvec2 y);")); s.append(TString("bvec2 notEqual(bvec2 x, bvec2 y);"));
s.append(TString("bvec3 notEqual(bvec3 x, bvec3 y);")); s.append(TString("bvec3 notEqual(bvec3 x, bvec3 y);"));
s.append(TString("bvec4 notEqual(bvec4 x, bvec4 y);")); s.append(TString("bvec4 notEqual(bvec4 x, bvec4 y);"));
s.append(TString("bool any(bvec2 x);")); s.append(TString("bool any(bvec2 x);"));
s.append(TString("bool any(bvec3 x);")); s.append(TString("bool any(bvec3 x);"));
s.append(TString("bool any(bvec4 x);")); s.append(TString("bool any(bvec4 x);"));
s.append(TString("bool all(bvec2 x);")); s.append(TString("bool all(bvec2 x);"));
s.append(TString("bool all(bvec3 x);")); s.append(TString("bool all(bvec3 x);"));
s.append(TString("bool all(bvec4 x);")); s.append(TString("bool all(bvec4 x);"));
s.append(TString("bvec2 not(bvec2 x);")); s.append(TString("bvec2 not(bvec2 x);"));
s.append(TString("bvec3 not(bvec3 x);")); s.append(TString("bvec3 not(bvec3 x);"));
s.append(TString("bvec4 not(bvec4 x);")); s.append(TString("bvec4 not(bvec4 x);"));
// //
// Texture Functions. // Texture Functions.
// //
s.append(TString("vec4 texture2D(sampler2D sampler, vec2 coord);")); s.append(TString("vec4 texture2D(sampler2D sampler, vec2 coord);"));
s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord);")); s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord);"));
s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord);")); s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord);"));
s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord);")); s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord);"));
// //
// Noise functions. // Noise functions.
// //
// s.append(TString("float noise1(float x);")); // s.append(TString("float noise1(float x);"));
// s.append(TString("float noise1(vec2 x);")); // s.append(TString("float noise1(vec2 x);"));
// s.append(TString("float noise1(vec3 x);")); // s.append(TString("float noise1(vec3 x);"));
// s.append(TString("float noise1(vec4 x);")); // s.append(TString("float noise1(vec4 x);"));
// s.append(TString("vec2 noise2(float x);")); // s.append(TString("vec2 noise2(float x);"));
// s.append(TString("vec2 noise2(vec2 x);")); // s.append(TString("vec2 noise2(vec2 x);"));
// s.append(TString("vec2 noise2(vec3 x);")); // s.append(TString("vec2 noise2(vec3 x);"));
// s.append(TString("vec2 noise2(vec4 x);")); // s.append(TString("vec2 noise2(vec4 x);"));
// s.append(TString("vec3 noise3(float x);")); // s.append(TString("vec3 noise3(float x);"));
// s.append(TString("vec3 noise3(vec2 x);")); // s.append(TString("vec3 noise3(vec2 x);"));
// s.append(TString("vec3 noise3(vec3 x);")); // s.append(TString("vec3 noise3(vec3 x);"));
// s.append(TString("vec3 noise3(vec4 x);")); // s.append(TString("vec3 noise3(vec4 x);"));
// s.append(TString("vec4 noise4(float x);")); // s.append(TString("vec4 noise4(float x);"));
// s.append(TString("vec4 noise4(vec2 x);")); // s.append(TString("vec4 noise4(vec2 x);"));
// s.append(TString("vec4 noise4(vec3 x);")); // s.append(TString("vec4 noise4(vec3 x);"));
// s.append(TString("vec4 noise4(vec4 x);")); // s.append(TString("vec4 noise4(vec4 x);"));
s.append(TString("\n")); s.append(TString("\n"));
} }
{ {
//============================================================================ //============================================================================
// //
// Prototypes for built-in functions seen by vertex shaders only. // Prototypes for built-in functions seen by vertex shaders only.
// //
//============================================================================ //============================================================================
TString& s = BuiltInFunctionsVertex; TString& s = BuiltInFunctionsVertex;
// //
// Geometric Functions. // Geometric Functions.
// //
s.append(TString("vec4 ftransform();")); s.append(TString("vec4 ftransform();"));
// //
// Texture Functions. // Texture Functions.
// //
s.append(TString("vec4 texture2DLod(sampler2D sampler, vec2 coord, float lod);")); s.append(TString("vec4 texture2DLod(sampler2D sampler, vec2 coord, float lod);"));
s.append(TString("vec4 texture2DProjLod(sampler2D sampler, vec3 coord, float lod);")); s.append(TString("vec4 texture2DProjLod(sampler2D sampler, vec3 coord, float lod);"));
s.append(TString("vec4 texture2DProjLod(sampler2D sampler, vec4 coord, float lod);")); s.append(TString("vec4 texture2DProjLod(sampler2D sampler, vec4 coord, float lod);"));
s.append(TString("vec4 textureCubeLod(samplerCube sampler, vec3 coord, float lod);")); s.append(TString("vec4 textureCubeLod(samplerCube sampler, vec3 coord, float lod);"));
s.append(TString("\n")); s.append(TString("\n"));
} }
{ {
//============================================================================ //============================================================================
// //
// Prototypes for built-in functions seen by fragment shaders only. // Prototypes for built-in functions seen by fragment shaders only.
// //
//============================================================================ //============================================================================
TString& s = BuiltInFunctionsFragment; TString& s = BuiltInFunctionsFragment;
// //
// Texture Functions. // Texture Functions.
// //
s.append(TString("vec4 texture2D(sampler2D sampler, vec2 coord, float bias);")); s.append(TString("vec4 texture2D(sampler2D sampler, vec2 coord, float bias);"));
s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord, float bias);")); s.append(TString("vec4 texture2DProj(sampler2D sampler, vec3 coord, float bias);"));
s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord, float bias);")); s.append(TString("vec4 texture2DProj(sampler2D sampler, vec4 coord, float bias);"));
s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord, float bias);")); s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord, float bias);"));
// s.append(TString("float dFdx(float p);")); // s.append(TString("float dFdx(float p);"));
// s.append(TString("vec2 dFdx(vec2 p);")); // s.append(TString("vec2 dFdx(vec2 p);"));
// s.append(TString("vec3 dFdx(vec3 p);")); // s.append(TString("vec3 dFdx(vec3 p);"));
// s.append(TString("vec4 dFdx(vec4 p);")); // s.append(TString("vec4 dFdx(vec4 p);"));
// s.append(TString("float dFdy(float p);")); // s.append(TString("float dFdy(float p);"));
// s.append(TString("vec2 dFdy(vec2 p);")); // s.append(TString("vec2 dFdy(vec2 p);"));
// s.append(TString("vec3 dFdy(vec3 p);")); // s.append(TString("vec3 dFdy(vec3 p);"));
// s.append(TString("vec4 dFdy(vec4 p);")); // s.append(TString("vec4 dFdy(vec4 p);"));
s.append(TString("float fwidth(float p);")); s.append(TString("float fwidth(float p);"));
s.append(TString("vec2 fwidth(vec2 p);")); s.append(TString("vec2 fwidth(vec2 p);"));
s.append(TString("vec3 fwidth(vec3 p);")); s.append(TString("vec3 fwidth(vec3 p);"));
s.append(TString("vec4 fwidth(vec4 p);")); s.append(TString("vec4 fwidth(vec4 p);"));
s.append(TString("\n")); s.append(TString("\n"));
} }
{ {
//============================================================================ //============================================================================
// //
// Standard Uniforms // Standard Uniforms
// //
//============================================================================ //============================================================================
TString& s = StandardUniforms; TString& s = StandardUniforms;
// //
// Depth range in window coordinates // Depth range in window coordinates
// //
s.append(TString("struct gl_DepthRangeParameters {")); s.append(TString("struct gl_DepthRangeParameters {"));
s.append(TString(" float near;")); // n // FIXME: highp s.append(TString(" float near;")); // n // FIXME: highp
s.append(TString(" float far;")); // f // FIXME: highp s.append(TString(" float far;")); // f // FIXME: highp
s.append(TString(" float diff;")); // f - n // FIXME: highp s.append(TString(" float diff;")); // f - n // FIXME: highp
s.append(TString("};")); s.append(TString("};"));
s.append(TString("uniform gl_DepthRangeParameters gl_DepthRange;")); s.append(TString("uniform gl_DepthRangeParameters gl_DepthRange;"));
s.append(TString("\n")); s.append(TString("\n"));
} }
builtInStrings[EShLangFragment].push_back(BuiltInFunctions.c_str()); builtInStrings[EShLangFragment].push_back(BuiltInFunctions.c_str());
builtInStrings[EShLangFragment].push_back(BuiltInFunctionsFragment); builtInStrings[EShLangFragment].push_back(BuiltInFunctionsFragment);
builtInStrings[EShLangFragment].push_back(StandardUniforms); builtInStrings[EShLangFragment].push_back(StandardUniforms);
builtInStrings[EShLangVertex].push_back(BuiltInFunctions); builtInStrings[EShLangVertex].push_back(BuiltInFunctions);
builtInStrings[EShLangVertex].push_back(BuiltInFunctionsVertex); builtInStrings[EShLangVertex].push_back(BuiltInFunctionsVertex);
builtInStrings[EShLangVertex].push_back(StandardUniforms); builtInStrings[EShLangVertex].push_back(StandardUniforms);
} }
void TBuiltIns::initialize(const TBuiltInResource &resources) void TBuiltIns::initialize(const TBuiltInResource &resources)
{ {
TString builtIns; TString builtIns;
// Implementation dependent constants // Implementation dependent constants
char builtInConstant[80]; char builtInConstant[80];
sprintf(builtInConstant, "const int gl_MaxVertexAttribs = %d;", resources.maxVertexAttribs); sprintf(builtInConstant, "const int gl_MaxVertexAttribs = %d;", resources.maxVertexAttribs);
builtIns.append(TString(builtInConstant)); builtIns.append(TString(builtInConstant));
sprintf(builtInConstant, "const int gl_MaxVertexUniformVectors = %d;", resources.maxVertexUniformVectors); sprintf(builtInConstant, "const int gl_MaxVertexUniformVectors = %d;", resources.maxVertexUniformVectors);
builtIns.append(TString(builtInConstant)); builtIns.append(TString(builtInConstant));
sprintf(builtInConstant, "const int gl_MaxVaryingVectors = %d;", resources.maxVaryingVectors); sprintf(builtInConstant, "const int gl_MaxVaryingVectors = %d;", resources.maxVaryingVectors);
builtIns.append(TString(builtInConstant)); builtIns.append(TString(builtInConstant));
sprintf(builtInConstant, "const int gl_MaxVertexTextureImageUnits = %d;", resources.maxVertexTextureImageUnits); sprintf(builtInConstant, "const int gl_MaxVertexTextureImageUnits = %d;", resources.maxVertexTextureImageUnits);
builtIns.append(TString(builtInConstant)); builtIns.append(TString(builtInConstant));
sprintf(builtInConstant, "const int gl_MaxCombinedTextureImageUnits = %d;", resources.maxCombinedTextureImageUnits); sprintf(builtInConstant, "const int gl_MaxCombinedTextureImageUnits = %d;", resources.maxCombinedTextureImageUnits);
builtIns.append(TString(builtInConstant)); builtIns.append(TString(builtInConstant));
sprintf(builtInConstant, "const int gl_MaxTextureImageUnits = %d;", resources.maxTextureImageUnits); sprintf(builtInConstant, "const int gl_MaxTextureImageUnits = %d;", resources.maxTextureImageUnits);
builtIns.append(TString(builtInConstant)); builtIns.append(TString(builtInConstant));
sprintf(builtInConstant, "const int gl_MaxFragmentUniformVectors = %d;", resources.maxFragmentUniformVectors); sprintf(builtInConstant, "const int gl_MaxFragmentUniformVectors = %d;", resources.maxFragmentUniformVectors);
builtIns.append(TString(builtInConstant)); builtIns.append(TString(builtInConstant));
sprintf(builtInConstant, "const int gl_MaxDrawBuffers = %d;", resources.maxDrawBuffers); sprintf(builtInConstant, "const int gl_MaxDrawBuffers = %d;", resources.maxDrawBuffers);
builtIns.append(TString(builtInConstant)); builtIns.append(TString(builtInConstant));
builtInStrings[EShLangFragment].push_back(builtIns); builtInStrings[EShLangFragment].push_back(builtIns);
builtInStrings[EShLangVertex].push_back(builtIns); builtInStrings[EShLangVertex].push_back(builtIns);
} }
void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable) void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable)
{ {
// //
// First, insert some special built-in variables that are not in // First, insert some special built-in variables that are not in
// the built-in header files. // the built-in header files.
// //
switch(language) { switch(language) {
case EShLangFragment: { case EShLangFragment: {
symbolTable.insert(*new TVariable(NewPoolTString("gl_FragCoord"), TType(EbtFloat, EvqFragCoord, 4))); // FIXME: mediump symbolTable.insert(*new TVariable(NewPoolTString("gl_FragCoord"), TType(EbtFloat, EvqFragCoord, 4))); // FIXME: mediump
symbolTable.insert(*new TVariable(NewPoolTString("gl_FrontFacing"), TType(EbtBool, EvqFrontFacing, 1))); symbolTable.insert(*new TVariable(NewPoolTString("gl_FrontFacing"), TType(EbtBool, EvqFrontFacing, 1)));
symbolTable.insert(*new TVariable(NewPoolTString("gl_FragColor"), TType(EbtFloat, EvqFragColor, 4))); // FIXME: mediump symbolTable.insert(*new TVariable(NewPoolTString("gl_FragColor"), TType(EbtFloat, EvqFragColor, 4))); // FIXME: mediump
symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData[gl_MaxDrawBuffers]"), TType(EbtFloat, EvqFragData, 4))); // FIXME: mediump symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData[gl_MaxDrawBuffers]"), TType(EbtFloat, EvqFragData, 4))); // FIXME: mediump
symbolTable.insert(*new TVariable(NewPoolTString("gl_PointCoord"), TType(EbtFloat, EvqPointCoord, 2))); // FIXME: mediump symbolTable.insert(*new TVariable(NewPoolTString("gl_PointCoord"), TType(EbtFloat, EvqPointCoord, 2))); // FIXME: mediump
} }
break; break;
case EShLangVertex: case EShLangVertex:
symbolTable.insert(*new TVariable(NewPoolTString("gl_Position"), TType(EbtFloat, EvqPosition, 4))); // FIXME: highp symbolTable.insert(*new TVariable(NewPoolTString("gl_Position"), TType(EbtFloat, EvqPosition, 4))); // FIXME: highp
symbolTable.insert(*new TVariable(NewPoolTString("gl_PointSize"), TType(EbtFloat, EvqPointSize, 1))); // FIXME: mediump symbolTable.insert(*new TVariable(NewPoolTString("gl_PointSize"), TType(EbtFloat, EvqPointSize, 1))); // FIXME: mediump
break; break;
default: break; default: break;
} }
// //
// Next, identify which built-ins from the already loaded headers have // Next, identify which built-ins from the already loaded headers have
// a mapping to an operator. Those that are not identified as such are // a mapping to an operator. Those that are not identified as such are
// expected to be resolved through a library of functions, versus as // expected to be resolved through a library of functions, versus as
// operations. // operations.
// //
symbolTable.relateToOperator("not", EOpVectorLogicalNot); symbolTable.relateToOperator("not", EOpVectorLogicalNot);
symbolTable.relateToOperator("matrixCompMult", EOpMul); symbolTable.relateToOperator("matrixCompMult", EOpMul);
symbolTable.relateToOperator("equal", EOpVectorEqual); symbolTable.relateToOperator("equal", EOpVectorEqual);
symbolTable.relateToOperator("notEqual", EOpVectorNotEqual); symbolTable.relateToOperator("notEqual", EOpVectorNotEqual);
symbolTable.relateToOperator("lessThan", EOpLessThan); symbolTable.relateToOperator("lessThan", EOpLessThan);
symbolTable.relateToOperator("greaterThan", EOpGreaterThan); symbolTable.relateToOperator("greaterThan", EOpGreaterThan);
symbolTable.relateToOperator("lessThanEqual", EOpLessThanEqual); symbolTable.relateToOperator("lessThanEqual", EOpLessThanEqual);
symbolTable.relateToOperator("greaterThanEqual", EOpGreaterThanEqual); symbolTable.relateToOperator("greaterThanEqual", EOpGreaterThanEqual);
symbolTable.relateToOperator("radians", EOpRadians); symbolTable.relateToOperator("radians", EOpRadians);
symbolTable.relateToOperator("degrees", EOpDegrees); symbolTable.relateToOperator("degrees", EOpDegrees);
symbolTable.relateToOperator("sin", EOpSin); symbolTable.relateToOperator("sin", EOpSin);
symbolTable.relateToOperator("cos", EOpCos); symbolTable.relateToOperator("cos", EOpCos);
symbolTable.relateToOperator("tan", EOpTan); symbolTable.relateToOperator("tan", EOpTan);
symbolTable.relateToOperator("asin", EOpAsin); symbolTable.relateToOperator("asin", EOpAsin);
symbolTable.relateToOperator("acos", EOpAcos); symbolTable.relateToOperator("acos", EOpAcos);
symbolTable.relateToOperator("atan", EOpAtan); symbolTable.relateToOperator("atan", EOpAtan);
symbolTable.relateToOperator("pow", EOpPow); symbolTable.relateToOperator("pow", EOpPow);
symbolTable.relateToOperator("exp2", EOpExp2); symbolTable.relateToOperator("exp2", EOpExp2);
symbolTable.relateToOperator("log", EOpLog); symbolTable.relateToOperator("log", EOpLog);
symbolTable.relateToOperator("exp", EOpExp); symbolTable.relateToOperator("exp", EOpExp);
symbolTable.relateToOperator("log2", EOpLog2); symbolTable.relateToOperator("log2", EOpLog2);
symbolTable.relateToOperator("sqrt", EOpSqrt); symbolTable.relateToOperator("sqrt", EOpSqrt);
symbolTable.relateToOperator("inversesqrt", EOpInverseSqrt); symbolTable.relateToOperator("inversesqrt", EOpInverseSqrt);
symbolTable.relateToOperator("abs", EOpAbs); symbolTable.relateToOperator("abs", EOpAbs);
symbolTable.relateToOperator("sign", EOpSign); symbolTable.relateToOperator("sign", EOpSign);
symbolTable.relateToOperator("floor", EOpFloor); symbolTable.relateToOperator("floor", EOpFloor);
symbolTable.relateToOperator("ceil", EOpCeil); symbolTable.relateToOperator("ceil", EOpCeil);
symbolTable.relateToOperator("fract", EOpFract); symbolTable.relateToOperator("fract", EOpFract);
symbolTable.relateToOperator("mod", EOpMod); symbolTable.relateToOperator("mod", EOpMod);
symbolTable.relateToOperator("min", EOpMin); symbolTable.relateToOperator("min", EOpMin);
symbolTable.relateToOperator("max", EOpMax); symbolTable.relateToOperator("max", EOpMax);
symbolTable.relateToOperator("clamp", EOpClamp); symbolTable.relateToOperator("clamp", EOpClamp);
symbolTable.relateToOperator("mix", EOpMix); symbolTable.relateToOperator("mix", EOpMix);
symbolTable.relateToOperator("step", EOpStep); symbolTable.relateToOperator("step", EOpStep);
symbolTable.relateToOperator("smoothstep", EOpSmoothStep); symbolTable.relateToOperator("smoothstep", EOpSmoothStep);
symbolTable.relateToOperator("length", EOpLength); symbolTable.relateToOperator("length", EOpLength);
symbolTable.relateToOperator("distance", EOpDistance); symbolTable.relateToOperator("distance", EOpDistance);
symbolTable.relateToOperator("dot", EOpDot); symbolTable.relateToOperator("dot", EOpDot);
symbolTable.relateToOperator("cross", EOpCross); symbolTable.relateToOperator("cross", EOpCross);
symbolTable.relateToOperator("normalize", EOpNormalize); symbolTable.relateToOperator("normalize", EOpNormalize);
symbolTable.relateToOperator("faceforward", EOpFaceForward); symbolTable.relateToOperator("faceforward", EOpFaceForward);
symbolTable.relateToOperator("reflect", EOpReflect); symbolTable.relateToOperator("reflect", EOpReflect);
symbolTable.relateToOperator("refract", EOpRefract); symbolTable.relateToOperator("refract", EOpRefract);
symbolTable.relateToOperator("any", EOpAny); symbolTable.relateToOperator("any", EOpAny);
symbolTable.relateToOperator("all", EOpAll); symbolTable.relateToOperator("all", EOpAll);
switch(language) switch(language)
{ {
case EShLangVertex: case EShLangVertex:
break; break;
case EShLangFragment: case EShLangFragment:
// symbolTable.relateToOperator("dFdx", EOpDPdx); // OES_standard_derivatives extension // symbolTable.relateToOperator("dFdx", EOpDPdx); // OES_standard_derivatives extension
// symbolTable.relateToOperator("dFdy", EOpDPdy); // OES_standard_derivatives extension // symbolTable.relateToOperator("dFdy", EOpDPdy); // OES_standard_derivatives extension
// symbolTable.relateToOperator("fwidth", EOpFwidth); // OES_standard_derivatives extension // symbolTable.relateToOperator("fwidth", EOpFwidth); // OES_standard_derivatives extension
break; break;
default: assert(false && "Language not supported"); default: assert(false && "Language not supported");
} }
} }
void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable, const TBuiltInResource &resources) void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable, const TBuiltInResource &resources)
{ {
// //
// First, insert some special built-in variables that are not in // First, insert some special built-in variables that are not in
// the built-in header files. // the built-in header files.
// //
switch(language) { switch(language) {
case EShLangFragment: { case EShLangFragment: {
// Set up gl_FragData. The array size. // Set up gl_FragData. The array size.
TType fragData(EbtFloat, EvqFragColor, 4, false, true); TType fragData(EbtFloat, EvqFragColor, 4, false, true);
fragData.setArraySize(resources.maxDrawBuffers); fragData.setArraySize(resources.maxDrawBuffers);
symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData"), fragData)); symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData"), fragData));
} }
break; break;
default: break; default: break;
} }
} }
const char* GetPreprocessorBuiltinString() const char* GetPreprocessorBuiltinString()
{ {
static const char *PreprocessorBuiltinString = ""; static const char *PreprocessorBuiltinString = "";
return PreprocessorBuiltinString; return PreprocessorBuiltinString;
} }
src/compiler/ParseHelper.h
...@@ -11,24 +11,24 @@ ...@@ -11,24 +11,24 @@
#include "compiler/localintermediate.h" #include "compiler/localintermediate.h"
struct TMatrixFields { struct TMatrixFields {
bool wholeRow; bool wholeRow;
bool wholeCol; bool wholeCol;
int row; int row;
int col; int col;
}; };
typedef enum { typedef enum {
EBhRequire, EBhRequire,
EBhEnable, EBhEnable,
EBhWarn, EBhWarn,
EBhDisable EBhDisable
} TBehavior; } TBehavior;
struct TPragma { struct TPragma {
TPragma(bool o, bool d) : optimize(o), debug(d) { } TPragma(bool o, bool d) : optimize(o), debug(d) { }
bool optimize; bool optimize;
bool debug; bool debug;
TPragmaTable pragmaTable; TPragmaTable pragmaTable;
}; };
// //
...@@ -36,71 +36,71 @@ struct TPragma { ...@@ -36,71 +36,71 @@ struct TPragma {
// they can be passed to the parser without needing a global. // they can be passed to the parser without needing a global.
// //
struct TParseContext { struct TParseContext {
TParseContext(TSymbolTable& symt, TIntermediate& interm, EShLanguage L, TInfoSink& is) : TParseContext(TSymbolTable& symt, TIntermediate& interm, EShLanguage L, TInfoSink& is) :
intermediate(interm), symbolTable(symt), infoSink(is), language(L), treeRoot(0), intermediate(interm), symbolTable(symt), infoSink(is), language(L), treeRoot(0),
recoveredFromError(false), numErrors(0), lexAfterType(false), loopNestingLevel(0), recoveredFromError(false), numErrors(0), lexAfterType(false), loopNestingLevel(0),
inTypeParen(false), contextPragma(true, false) { } inTypeParen(false), contextPragma(true, false) { }
TIntermediate& intermediate; // to hold and build a parse tree TIntermediate& intermediate; // to hold and build a parse tree
TSymbolTable& symbolTable; // symbol table that goes with the language currently being parsed TSymbolTable& symbolTable; // symbol table that goes with the language currently being parsed
TInfoSink& infoSink; TInfoSink& infoSink;
EShLanguage language; // vertex or fragment language (future: pack or unpack) EShLanguage language; // vertex or fragment language (future: pack or unpack)
TIntermNode* treeRoot; // root of parse tree being created TIntermNode* treeRoot; // root of parse tree being created
bool recoveredFromError; // true if a parse error has occurred, but we continue to parse bool recoveredFromError; // true if a parse error has occurred, but we continue to parse
int numErrors; int numErrors;
bool lexAfterType; // true if we've recognized a type, so can only be looking for an identifier bool lexAfterType; // true if we've recognized a type, so can only be looking for an identifier
int loopNestingLevel; // 0 if outside all loops int loopNestingLevel; // 0 if outside all loops
bool inTypeParen; // true if in parentheses, looking only for an identifier bool inTypeParen; // true if in parentheses, looking only for an identifier
const TType* currentFunctionType; // the return type of the function that's currently being parsed const TType* currentFunctionType; // the return type of the function that's currently being parsed
bool functionReturnsValue; // true if a non-void function has a return bool functionReturnsValue; // true if a non-void function has a return
TMap<TString, TBehavior> extensionBehavior; TMap<TString, TBehavior> extensionBehavior;
void initializeExtensionBehavior(); void initializeExtensionBehavior();
void C_DECL error(TSourceLoc, const char *szReason, const char *szToken, void C_DECL error(TSourceLoc, const char *szReason, const char *szToken,
const char *szExtraInfoFormat, ...); const char *szExtraInfoFormat, ...);
bool reservedErrorCheck(int line, const TString& identifier); bool reservedErrorCheck(int line, const TString& identifier);
void recover(); void recover();
bool parseVectorFields(const TString&, int vecSize, TVectorFields&, int line); bool parseVectorFields(const TString&, int vecSize, TVectorFields&, int line);
bool parseMatrixFields(const TString&, int matSize, TMatrixFields&, int line); bool parseMatrixFields(const TString&, int matSize, TMatrixFields&, int line);
void assignError(int line, const char* op, TString left, TString right); void assignError(int line, const char* op, TString left, TString right);
void unaryOpError(int line, const char* op, TString operand); void unaryOpError(int line, const char* op, TString operand);
void binaryOpError(int line, const char* op, TString left, TString right); void binaryOpError(int line, const char* op, TString left, TString right);
bool lValueErrorCheck(int line, const char* op, TIntermTyped*); bool lValueErrorCheck(int line, const char* op, TIntermTyped*);
bool constErrorCheck(TIntermTyped* node); bool constErrorCheck(TIntermTyped* node);
bool integerErrorCheck(TIntermTyped* node, const char* token); bool integerErrorCheck(TIntermTyped* node, const char* token);
bool globalErrorCheck(int line, bool global, const char* token); bool globalErrorCheck(int line, bool global, const char* token);
bool constructorErrorCheck(int line, TIntermNode*, TFunction&, TOperator, TType*); bool constructorErrorCheck(int line, TIntermNode*, TFunction&, TOperator, TType*);
bool arraySizeErrorCheck(int line, TIntermTyped* expr, int& size); bool arraySizeErrorCheck(int line, TIntermTyped* expr, int& size);
bool arrayQualifierErrorCheck(int line, TPublicType type); bool arrayQualifierErrorCheck(int line, TPublicType type);
bool arrayTypeErrorCheck(int line, TPublicType type); bool arrayTypeErrorCheck(int line, TPublicType type);
bool arrayErrorCheck(int line, TString& identifier, TPublicType type, TVariable*& variable); bool arrayErrorCheck(int line, TString& identifier, TPublicType type, TVariable*& variable);
bool voidErrorCheck(int, const TString&, const TPublicType&); bool voidErrorCheck(int, const TString&, const TPublicType&);
bool boolErrorCheck(int, const TIntermTyped*); bool boolErrorCheck(int, const TIntermTyped*);
bool boolErrorCheck(int, const TPublicType&); bool boolErrorCheck(int, const TPublicType&);
bool samplerErrorCheck(int line, const TPublicType& pType, const char* reason); bool samplerErrorCheck(int line, const TPublicType& pType, const char* reason);
bool structQualifierErrorCheck(int line, const TPublicType& pType); bool structQualifierErrorCheck(int line, const TPublicType& pType);
bool parameterSamplerErrorCheck(int line, TQualifier qualifier, const TType& type); bool parameterSamplerErrorCheck(int line, TQualifier qualifier, const TType& type);
bool containsSampler(TType& type); bool containsSampler(TType& type);
bool nonInitConstErrorCheck(int line, TString& identifier, TPublicType& type); bool nonInitConstErrorCheck(int line, TString& identifier, TPublicType& type);
bool nonInitErrorCheck(int line, TString& identifier, TPublicType& type); bool nonInitErrorCheck(int line, TString& identifier, TPublicType& type);
bool paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type); bool paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type);
bool extensionErrorCheck(int line, const char*); bool extensionErrorCheck(int line, const char*);
const TFunction* findFunction(int line, TFunction* pfnCall, bool *builtIn = 0); const TFunction* findFunction(int line, TFunction* pfnCall, bool *builtIn = 0);
bool executeInitializer(TSourceLoc line, TString& identifier, TPublicType& pType, bool executeInitializer(TSourceLoc line, TString& identifier, TPublicType& pType,
TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable = 0); TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable = 0);
bool areAllChildConst(TIntermAggregate* aggrNode); bool areAllChildConst(TIntermAggregate* aggrNode);
TIntermTyped* addConstructor(TIntermNode*, const TType*, TOperator, TFunction*, TSourceLoc); TIntermTyped* addConstructor(TIntermNode*, const TType*, TOperator, TFunction*, TSourceLoc);
TIntermTyped* foldConstConstructor(TIntermAggregate* aggrNode, const TType& type); TIntermTyped* foldConstConstructor(TIntermAggregate* aggrNode, const TType& type);
TIntermTyped* constructStruct(TIntermNode*, TType*, int, TSourceLoc, bool subset); TIntermTyped* constructStruct(TIntermNode*, TType*, int, TSourceLoc, bool subset);
TIntermTyped* constructBuiltIn(const TType*, TOperator, TIntermNode*, TSourceLoc, bool subset); TIntermTyped* constructBuiltIn(const TType*, TOperator, TIntermNode*, TSourceLoc, bool subset);
TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, TSourceLoc); TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, TSourceLoc);
TIntermTyped* addConstMatrixNode(int , TIntermTyped*, TSourceLoc); TIntermTyped* addConstMatrixNode(int , TIntermTyped*, TSourceLoc);
TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, TSourceLoc line); TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, TSourceLoc line);
TIntermTyped* addConstStruct(TString& , TIntermTyped*, TSourceLoc); TIntermTyped* addConstStruct(TString& , TIntermTyped*, TSourceLoc);
bool arraySetMaxSize(TIntermSymbol*, TType*, int, bool, TSourceLoc); bool arraySetMaxSize(TIntermSymbol*, TType*, int, bool, TSourceLoc);
struct TPragma contextPragma; struct TPragma contextPragma;
TString HashErrMsg; TString HashErrMsg;
bool AfterEOF; bool AfterEOF;
}; };
int PaParseStrings(char* argv[], int strLen[], int argc, TParseContext&); int PaParseStrings(char* argv[], int strLen[], int argc, TParseContext&);
...@@ -115,7 +115,7 @@ extern TParseContextPointer& GetGlobalParseContext(); ...@@ -115,7 +115,7 @@ extern TParseContextPointer& GetGlobalParseContext();
typedef struct TThreadParseContextRec typedef struct TThreadParseContextRec
{ {
TParseContext *lpGlobalParseContext; TParseContext *lpGlobalParseContext;
} TThreadParseContext; } TThreadParseContext;
#endif // _PARSER_HELPER_INCLUDED_ #endif // _PARSER_HELPER_INCLUDED_
src/compiler/SymbolTable.cpp
...@@ -20,53 +20,53 @@ ...@@ -20,53 +20,53 @@
// //
void TType::buildMangledName(TString& mangledName) void TType::buildMangledName(TString& mangledName)
{ {
if (isMatrix()) if (isMatrix())
mangledName += 'm'; mangledName += 'm';
else if (isVector()) else if (isVector())
mangledName += 'v'; mangledName += 'v';
switch (type) { switch (type) {
case EbtFloat: mangledName += 'f'; break; case EbtFloat: mangledName += 'f'; break;
case EbtInt: mangledName += 'i'; break; case EbtInt: mangledName += 'i'; break;
case EbtBool: mangledName += 'b'; break; case EbtBool: mangledName += 'b'; break;
case EbtSampler2D: mangledName += "s2"; break; case EbtSampler2D: mangledName += "s2"; break;
case EbtSamplerCube: mangledName += "sC"; break; case EbtSamplerCube: mangledName += "sC"; break;
case EbtStruct: case EbtStruct:
mangledName += "struct-"; mangledName += "struct-";
if (typeName) if (typeName)
mangledName += *typeName; mangledName += *typeName;
{// support MSVC++6.0 {// support MSVC++6.0
for (unsigned int i = 0; i < structure->size(); ++i) { for (unsigned int i = 0; i < structure->size(); ++i) {
mangledName += '-'; mangledName += '-';
(*structure)[i].type->buildMangledName(mangledName); (*structure)[i].type->buildMangledName(mangledName);
} }
} }
default: default:
break; break;
} }
mangledName += static_cast<char>('0' + getNominalSize()); mangledName += static_cast<char>('0' + getNominalSize());
if (isArray()) { if (isArray()) {
char buf[20]; char buf[20];
sprintf(buf, "%d", arraySize); sprintf(buf, "%d", arraySize);
mangledName += '['; mangledName += '[';
mangledName += buf; mangledName += buf;
mangledName += ']'; mangledName += ']';
} }
} }
int TType::getStructSize() const int TType::getStructSize() const
{ {
if (!getStruct()) { if (!getStruct()) {
assert(false && "Not a struct"); assert(false && "Not a struct");
return 0; return 0;
} }
if (structureSize == 0) if (structureSize == 0)
for (TTypeList::iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++) for (TTypeList::iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++)
structureSize += ((*tl).type)->getObjectSize(); structureSize += ((*tl).type)->getObjectSize();
return structureSize; return structureSize;
} }
// //
...@@ -75,31 +75,31 @@ int TType::getStructSize() const ...@@ -75,31 +75,31 @@ int TType::getStructSize() const
void TVariable::dump(TInfoSink& infoSink) const void TVariable::dump(TInfoSink& infoSink) const
{ {
infoSink.debug << getName().c_str() << ": " << type.getQualifierString() << " " << type.getBasicString(); infoSink.debug << getName().c_str() << ": " << type.getQualifierString() << " " << type.getBasicString();
if (type.isArray()) { if (type.isArray()) {
infoSink.debug << "[0]"; infoSink.debug << "[0]";
} }
infoSink.debug << "\n"; infoSink.debug << "\n";
} }
void TFunction::dump(TInfoSink &infoSink) const void TFunction::dump(TInfoSink &infoSink) const
{ {
infoSink.debug << getName().c_str() << ": " << returnType.getBasicString() << " " << getMangledName().c_str() << "\n"; infoSink.debug << getName().c_str() << ": " << returnType.getBasicString() << " " << getMangledName().c_str() << "\n";
} }
void TSymbolTableLevel::dump(TInfoSink &infoSink) const void TSymbolTableLevel::dump(TInfoSink &infoSink) const
{ {
tLevel::const_iterator it; tLevel::const_iterator it;
for (it = level.begin(); it != level.end(); ++it) for (it = level.begin(); it != level.end(); ++it)
(*it).second->dump(infoSink); (*it).second->dump(infoSink);
} }
void TSymbolTable::dump(TInfoSink &infoSink) const void TSymbolTable::dump(TInfoSink &infoSink) const
{ {
for (int level = currentLevel(); level >= 0; --level) { for (int level = currentLevel(); level >= 0; --level) {
infoSink.debug << "LEVEL " << level << "\n"; infoSink.debug << "LEVEL " << level << "\n";
table[level]->dump(infoSink); table[level]->dump(infoSink);
} }
} }
// //
...@@ -107,8 +107,8 @@ void TSymbolTable::dump(TInfoSink &infoSink) const ...@@ -107,8 +107,8 @@ void TSymbolTable::dump(TInfoSink &infoSink) const
// //
TFunction::~TFunction() TFunction::~TFunction()
{ {
for (TParamList::iterator i = parameters.begin(); i != parameters.end(); ++i) for (TParamList::iterator i = parameters.begin(); i != parameters.end(); ++i)
delete (*i).type; delete (*i).type;
} }
// //
...@@ -116,8 +116,8 @@ TFunction::~TFunction() ...@@ -116,8 +116,8 @@ TFunction::~TFunction()
// //
TSymbolTableLevel::~TSymbolTableLevel() TSymbolTableLevel::~TSymbolTableLevel()
{ {
for (tLevel::iterator it = level.begin(); it != level.end(); ++it) for (tLevel::iterator it = level.begin(); it != level.end(); ++it)
delete (*it).second; delete (*it).second;
} }
// //
...@@ -128,84 +128,84 @@ TSymbolTableLevel::~TSymbolTableLevel() ...@@ -128,84 +128,84 @@ TSymbolTableLevel::~TSymbolTableLevel()
// //
void TSymbolTableLevel::relateToOperator(const char* name, TOperator op) void TSymbolTableLevel::relateToOperator(const char* name, TOperator op)
{ {
tLevel::iterator it; tLevel::iterator it;
for (it = level.begin(); it != level.end(); ++it) { for (it = level.begin(); it != level.end(); ++it) {
if ((*it).second->isFunction()) { if ((*it).second->isFunction()) {
TFunction* function = static_cast<TFunction*>((*it).second); TFunction* function = static_cast<TFunction*>((*it).second);
if (function->getName() == name) if (function->getName() == name)
function->relateToOperator(op); function->relateToOperator(op);
} }
} }
} }
TSymbol::TSymbol(const TSymbol& copyOf) TSymbol::TSymbol(const TSymbol& copyOf)
{ {
name = NewPoolTString(copyOf.name->c_str()); name = NewPoolTString(copyOf.name->c_str());
uniqueId = copyOf.uniqueId; uniqueId = copyOf.uniqueId;
} }
TVariable::TVariable(const TVariable& copyOf, TStructureMap& remapper) : TSymbol(copyOf) TVariable::TVariable(const TVariable& copyOf, TStructureMap& remapper) : TSymbol(copyOf)
{ {
type.copyType(copyOf.type, remapper); type.copyType(copyOf.type, remapper);
userType = copyOf.userType; userType = copyOf.userType;
// for builtIn symbol table level, unionArray and arrayInformation pointers should be NULL // for builtIn symbol table level, unionArray and arrayInformation pointers should be NULL
assert(copyOf.arrayInformationType == 0); assert(copyOf.arrayInformationType == 0);
arrayInformationType = 0; arrayInformationType = 0;
if (copyOf.unionArray) { if (copyOf.unionArray) {
assert(!copyOf.type.getStruct()); assert(!copyOf.type.getStruct());
assert(copyOf.type.getObjectSize() == 1); assert(copyOf.type.getObjectSize() == 1);
unionArray = new ConstantUnion[1]; unionArray = new ConstantUnion[1];
unionArray[0] = copyOf.unionArray[0]; unionArray[0] = copyOf.unionArray[0];
} else } else
unionArray = 0; unionArray = 0;
} }
TVariable* TVariable::clone(TStructureMap& remapper) TVariable* TVariable::clone(TStructureMap& remapper)
{ {
TVariable *variable = new TVariable(*this, remapper); TVariable *variable = new TVariable(*this, remapper);
return variable; return variable;
} }
TFunction::TFunction(const TFunction& copyOf, TStructureMap& remapper) : TSymbol(copyOf) TFunction::TFunction(const TFunction& copyOf, TStructureMap& remapper) : TSymbol(copyOf)
{ {
for (unsigned int i = 0; i < copyOf.parameters.size(); ++i) { for (unsigned int i = 0; i < copyOf.parameters.size(); ++i) {
TParameter param; TParameter param;
parameters.push_back(param); parameters.push_back(param);
parameters.back().copyParam(copyOf.parameters[i], remapper); parameters.back().copyParam(copyOf.parameters[i], remapper);
} }
returnType.copyType(copyOf.returnType, remapper); returnType.copyType(copyOf.returnType, remapper);
mangledName = copyOf.mangledName; mangledName = copyOf.mangledName;
op = copyOf.op; op = copyOf.op;
defined = copyOf.defined; defined = copyOf.defined;
} }
TFunction* TFunction::clone(TStructureMap& remapper) TFunction* TFunction::clone(TStructureMap& remapper)
{ {
TFunction *function = new TFunction(*this, remapper); TFunction *function = new TFunction(*this, remapper);
return function; return function;
} }
TSymbolTableLevel* TSymbolTableLevel::clone(TStructureMap& remapper) TSymbolTableLevel* TSymbolTableLevel::clone(TStructureMap& remapper)
{ {
TSymbolTableLevel *symTableLevel = new TSymbolTableLevel(); TSymbolTableLevel *symTableLevel = new TSymbolTableLevel();
tLevel::iterator iter; tLevel::iterator iter;
for (iter = level.begin(); iter != level.end(); ++iter) { for (iter = level.begin(); iter != level.end(); ++iter) {
symTableLevel->insert(*iter->second->clone(remapper)); symTableLevel->insert(*iter->second->clone(remapper));
} }
return symTableLevel; return symTableLevel;
} }
void TSymbolTable::copyTable(const TSymbolTable& copyOf) void TSymbolTable::copyTable(const TSymbolTable& copyOf)
{ {
TStructureMap remapper; TStructureMap remapper;
uniqueId = copyOf.uniqueId; uniqueId = copyOf.uniqueId;
for (unsigned int i = 0; i < copyOf.table.size(); ++i) { for (unsigned int i = 0; i < copyOf.table.size(); ++i) {
table.push_back(copyOf.table[i]->clone(remapper)); table.push_back(copyOf.table[i]->clone(remapper));
} }
} }
src/compiler/Types.h
...@@ -15,15 +15,15 @@ ...@@ -15,15 +15,15 @@
// //
class TType; class TType;
struct TTypeLine { struct TTypeLine {
TType* type; TType* type;
int line; int line;
}; };
typedef TVector<TTypeLine> TTypeList; typedef TVector<TTypeLine> TTypeList;
inline TTypeList* NewPoolTTypeList() inline TTypeList* NewPoolTTypeList()
{ {
void* memory = GlobalPoolAllocator.allocate(sizeof(TTypeList)); void* memory = GlobalPoolAllocator.allocate(sizeof(TTypeList));
return new(memory) TTypeList; return new(memory) TTypeList;
} }
// //
...@@ -37,45 +37,45 @@ inline TTypeList* NewPoolTTypeList() ...@@ -37,45 +37,45 @@ inline TTypeList* NewPoolTTypeList()
// //
class TPublicType { class TPublicType {
public: public:
TBasicType type; TBasicType type;
TQualifier qualifier; TQualifier qualifier;
TPrecision precision; TPrecision precision;
int size; // size of vector or matrix, not size of array int size; // size of vector or matrix, not size of array
bool matrix; bool matrix;
bool array; bool array;
int arraySize; int arraySize;
TType* userDef; TType* userDef;
int line; int line;
void setBasic(TBasicType bt, TQualifier q, int ln = 0) void setBasic(TBasicType bt, TQualifier q, int ln = 0)
{ {
type = bt; type = bt;
qualifier = q; qualifier = q;
precision = EbpHigh; precision = EbpHigh;
size = 1; size = 1;
matrix = false; matrix = false;
array = false; array = false;
arraySize = 0; arraySize = 0;
userDef = 0; userDef = 0;
line = ln; line = ln;
} }
void setPrecision(TPrecision pcs) void setPrecision(TPrecision pcs)
{ {
precision = pcs; precision = pcs;
} }
void setAggregate(int s, bool m = false) void setAggregate(int s, bool m = false)
{ {
size = s; size = s;
matrix = m; matrix = m;
} }
void setArray(bool a, int s = 0) void setArray(bool a, int s = 0)
{ {
array = a; array = a;
arraySize = s; arraySize = s;
} }
}; };
typedef TMap<TTypeList*, TTypeList*> TStructureMap; typedef TMap<TTypeList*, TTypeList*> TStructureMap;
...@@ -85,197 +85,197 @@ typedef TMap<TTypeList*, TTypeList*>::iterator TStructureMapIterator; ...@@ -85,197 +85,197 @@ typedef TMap<TTypeList*, TTypeList*>::iterator TStructureMapIterator;
// //
class TType { class TType {
public: public:
POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator) POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
explicit TType(TBasicType t, TQualifier q = EvqTemporary, int s = 1, bool m = false, bool a = false, TPrecision p = EbpHigh) : explicit TType(TBasicType t, TQualifier q = EvqTemporary, int s = 1, bool m = false, bool a = false, TPrecision p = EbpHigh) :
type(t), precision(p), qualifier(q), size(s), matrix(m), array(a), arraySize(0), type(t), precision(p), qualifier(q), size(s), matrix(m), array(a), arraySize(0),
structure(0), structureSize(0), maxArraySize(0), arrayInformationType(0), fieldName(0), mangled(0), typeName(0) structure(0), structureSize(0), maxArraySize(0), arrayInformationType(0), fieldName(0), mangled(0), typeName(0)
{ } { }
explicit TType(const TPublicType &p) : explicit TType(const TPublicType &p) :
type(p.type), precision(p.precision), qualifier(p.qualifier), size(p.size), matrix(p.matrix), array(p.array), arraySize(p.arraySize), type(p.type), precision(p.precision), qualifier(p.qualifier), size(p.size), matrix(p.matrix), array(p.array), arraySize(p.arraySize),
structure(0), structureSize(0), maxArraySize(0), arrayInformationType(0), fieldName(0), mangled(0), typeName(0) structure(0), structureSize(0), maxArraySize(0), arrayInformationType(0), fieldName(0), mangled(0), typeName(0)
{ {
if (p.userDef) { if (p.userDef) {
structure = p.userDef->getStruct(); structure = p.userDef->getStruct();
typeName = NewPoolTString(p.userDef->getTypeName().c_str()); typeName = NewPoolTString(p.userDef->getTypeName().c_str());
} }
} }
explicit TType(TTypeList* userDef, const TString& n, TPrecision p = EbpHigh) : explicit TType(TTypeList* userDef, const TString& n, TPrecision p = EbpHigh) :
type(EbtStruct), precision(p), qualifier(EvqTemporary), size(1), matrix(false), array(false), arraySize(0), type(EbtStruct), precision(p), qualifier(EvqTemporary), size(1), matrix(false), array(false), arraySize(0),
structure(userDef), structureSize(0), maxArraySize(0), arrayInformationType(0), fieldName(0), mangled(0) { structure(userDef), structureSize(0), maxArraySize(0), arrayInformationType(0), fieldName(0), mangled(0) {
typeName = NewPoolTString(n.c_str()); typeName = NewPoolTString(n.c_str());
} }
explicit TType() {} explicit TType() {}
virtual ~TType() {} virtual ~TType() {}
TType(const TType& type) { *this = type; } TType(const TType& type) { *this = type; }
void copyType(const TType& copyOf, TStructureMap& remapper) void copyType(const TType& copyOf, TStructureMap& remapper)
{ {
type = copyOf.type; type = copyOf.type;
precision = copyOf.precision; precision = copyOf.precision;
qualifier = copyOf.qualifier; qualifier = copyOf.qualifier;
size = copyOf.size; size = copyOf.size;
matrix = copyOf.matrix; matrix = copyOf.matrix;
array = copyOf.array; array = copyOf.array;
arraySize = copyOf.arraySize; arraySize = copyOf.arraySize;
TStructureMapIterator iter; TStructureMapIterator iter;
if (copyOf.structure) { if (copyOf.structure) {
if ((iter = remapper.find(structure)) == remapper.end()) { if ((iter = remapper.find(structure)) == remapper.end()) {
// create the new structure here // create the new structure here
structure = NewPoolTTypeList(); structure = NewPoolTTypeList();
for (unsigned int i = 0; i < copyOf.structure->size(); ++i) { for (unsigned int i = 0; i < copyOf.structure->size(); ++i) {
TTypeLine typeLine; TTypeLine typeLine;
typeLine.line = (*copyOf.structure)[i].line; typeLine.line = (*copyOf.structure)[i].line;
typeLine.type = (*copyOf.structure)[i].type->clone(remapper); typeLine.type = (*copyOf.structure)[i].type->clone(remapper);
structure->push_back(typeLine); structure->push_back(typeLine);
} }
} else { } else {
structure = iter->second; structure = iter->second;
} }
} else } else
structure = 0; structure = 0;
fieldName = 0; fieldName = 0;
if (copyOf.fieldName) if (copyOf.fieldName)
fieldName = NewPoolTString(copyOf.fieldName->c_str()); fieldName = NewPoolTString(copyOf.fieldName->c_str());
typeName = 0; typeName = 0;
if (copyOf.typeName) if (copyOf.typeName)
typeName = NewPoolTString(copyOf.typeName->c_str()); typeName = NewPoolTString(copyOf.typeName->c_str());
mangled = 0; mangled = 0;
if (copyOf.mangled) if (copyOf.mangled)
mangled = NewPoolTString(copyOf.mangled->c_str()); mangled = NewPoolTString(copyOf.mangled->c_str());
structureSize = copyOf.structureSize; structureSize = copyOf.structureSize;
maxArraySize = copyOf.maxArraySize; maxArraySize = copyOf.maxArraySize;
assert(copyOf.arrayInformationType == 0); assert(copyOf.arrayInformationType == 0);
arrayInformationType = 0; // arrayInformationType should not be set for builtIn symbol table level arrayInformationType = 0; // arrayInformationType should not be set for builtIn symbol table level
} }
TType* clone(TStructureMap& remapper) TType* clone(TStructureMap& remapper)
{ {
TType *newType = new TType(); TType *newType = new TType();
newType->copyType(*this, remapper); newType->copyType(*this, remapper);
return newType; return newType;
} }
virtual void setType(TBasicType t, int s, bool m, bool a, int aS = 0) virtual void setType(TBasicType t, int s, bool m, bool a, int aS = 0)
{ type = t; size = s; matrix = m; array = a; arraySize = aS; } { type = t; size = s; matrix = m; array = a; arraySize = aS; }
virtual void setType(TBasicType t, int s, bool m, TType* userDef = 0) virtual void setType(TBasicType t, int s, bool m, TType* userDef = 0)
{ type = t; { type = t;
size = s; size = s;
matrix = m; matrix = m;
if (userDef) if (userDef)
structure = userDef->getStruct(); structure = userDef->getStruct();
// leave array information intact. // leave array information intact.
} }
virtual void setTypeName(const TString& n) { typeName = NewPoolTString(n.c_str()); } virtual void setTypeName(const TString& n) { typeName = NewPoolTString(n.c_str()); }
virtual void setFieldName(const TString& n) { fieldName = NewPoolTString(n.c_str()); } virtual void setFieldName(const TString& n) { fieldName = NewPoolTString(n.c_str()); }
virtual const TString& getTypeName() const virtual const TString& getTypeName() const
{ {
assert(typeName); assert(typeName);
return *typeName; return *typeName;
} }
virtual const TString& getFieldName() const virtual const TString& getFieldName() const
{ {
assert(fieldName); assert(fieldName);
return *fieldName; return *fieldName;
} }
virtual TBasicType getBasicType() const { return type; } virtual TBasicType getBasicType() const { return type; }
virtual TPrecision getPrecision() const { return precision; } virtual TPrecision getPrecision() const { return precision; }
virtual TQualifier getQualifier() const { return qualifier; } virtual TQualifier getQualifier() const { return qualifier; }
virtual void changePrecision(TPrecision p) { precision = p; } virtual void changePrecision(TPrecision p) { precision = p; }
virtual void changeQualifier(TQualifier q) { qualifier = q; } virtual void changeQualifier(TQualifier q) { qualifier = q; }
// One-dimensional size of single instance type // One-dimensional size of single instance type
virtual int getNominalSize() const { return size; } virtual int getNominalSize() const { return size; }
// Full-dimensional size of single instance of type // Full-dimensional size of single instance of type
virtual int getInstanceSize() const virtual int getInstanceSize() const
{ {
if (matrix) if (matrix)
return size * size; return size * size;
else else
return size; return size;
} }
virtual bool isMatrix() const { return matrix ? true : false; } virtual bool isMatrix() const { return matrix ? true : false; }
virtual bool isArray() const { return array ? true : false; } virtual bool isArray() const { return array ? true : false; }
bool isField() const { return fieldName != 0; } bool isField() const { return fieldName != 0; }
int getArraySize() const { return arraySize; } int getArraySize() const { return arraySize; }
void setArraySize(int s) { array = true; arraySize = s; } void setArraySize(int s) { array = true; arraySize = s; }
void setMaxArraySize (int s) { maxArraySize = s; } void setMaxArraySize (int s) { maxArraySize = s; }
int getMaxArraySize () const { return maxArraySize; } int getMaxArraySize () const { return maxArraySize; }
void clearArrayness() { array = false; arraySize = 0; maxArraySize = 0; } void clearArrayness() { array = false; arraySize = 0; maxArraySize = 0; }
void setArrayInformationType(TType* t) { arrayInformationType = t; } void setArrayInformationType(TType* t) { arrayInformationType = t; }
TType* getArrayInformationType() const { return arrayInformationType; } TType* getArrayInformationType() const { return arrayInformationType; }
virtual bool isVector() const { return size > 1 && !matrix; } virtual bool isVector() const { return size > 1 && !matrix; }
virtual bool isScalar() const { return size == 1 && !matrix && !structure; } virtual bool isScalar() const { return size == 1 && !matrix && !structure; }
static const char* getBasicString(TBasicType t) { static const char* getBasicString(TBasicType t) {
switch (t) { switch (t) {
case EbtVoid: return "void"; break; case EbtVoid: return "void"; break;
case EbtFloat: return "float"; break; case EbtFloat: return "float"; break;
case EbtInt: return "int"; break; case EbtInt: return "int"; break;
case EbtBool: return "bool"; break; case EbtBool: return "bool"; break;
case EbtSampler2D: return "sampler2D"; break; case EbtSampler2D: return "sampler2D"; break;
case EbtSamplerCube: return "samplerCube"; break; case EbtSamplerCube: return "samplerCube"; break;
case EbtStruct: return "structure"; break; case EbtStruct: return "structure"; break;
default: return "unknown type"; default: return "unknown type";
} }
} }
const char* getBasicString() const { return TType::getBasicString(type); } const char* getBasicString() const { return TType::getBasicString(type); }
const char* getPrecisionString() const { return ::getPrecisionString(precision); } const char* getPrecisionString() const { return ::getPrecisionString(precision); }
const char* getQualifierString() const { return ::getQualifierString(qualifier); } const char* getQualifierString() const { return ::getQualifierString(qualifier); }
TTypeList* getStruct() { return structure; } TTypeList* getStruct() { return structure; }
int getObjectSize() const int getObjectSize() const
{ {
int totalSize; int totalSize;
if (getBasicType() == EbtStruct) if (getBasicType() == EbtStruct)
totalSize = getStructSize(); totalSize = getStructSize();
else if (matrix) else if (matrix)
totalSize = size * size; totalSize = size * size;
else else
totalSize = size; totalSize = size;
if (isArray()) if (isArray())
totalSize *= std::max(getArraySize(), getMaxArraySize()); totalSize *= std::max(getArraySize(), getMaxArraySize());
return totalSize; return totalSize;
} }
TTypeList* getStruct() const { return structure; } TTypeList* getStruct() const { return structure; }
TString& getMangledName() { TString& getMangledName() {
if (!mangled) { if (!mangled) {
mangled = NewPoolTString(""); mangled = NewPoolTString("");
buildMangledName(*mangled); buildMangledName(*mangled);
*mangled += ';' ; *mangled += ';' ;
} }
return *mangled; return *mangled;
} }
bool sameElementType(const TType& right) const { bool sameElementType(const TType& right) const {
return type == right.type && return type == right.type &&
size == right.size && size == right.size &&
matrix == right.matrix && matrix == right.matrix &&
structure == right.structure; structure == right.structure;
} }
bool operator==(const TType& right) const { bool operator==(const TType& right) const {
return type == right.type && return type == right.type &&
size == right.size && size == right.size &&
matrix == right.matrix && matrix == right.matrix &&
array == right.array && (!array || arraySize == right.arraySize) && array == right.array && (!array || arraySize == right.arraySize) &&
structure == right.structure; structure == right.structure;
// don't check the qualifier, it's not ever what's being sought after // don't check the qualifier, it's not ever what's being sought after
} }
bool operator!=(const TType& right) const { bool operator!=(const TType& right) const {
return !operator==(right); return !operator==(right);
} }
bool operator<(const TType& right) const { bool operator<(const TType& right) const {
if (type != right.type) return type < right.type; if (type != right.type) return type < right.type;
if (size != right.size) return size < right.size; if (size != right.size) return size < right.size;
...@@ -285,28 +285,28 @@ public: ...@@ -285,28 +285,28 @@ public:
if (structure != right.structure) return structure < right.structure; if (structure != right.structure) return structure < right.structure;
return false; return false;
} }
TString getCompleteString() const; TString getCompleteString() const;
protected: protected:
void buildMangledName(TString&); void buildMangledName(TString&);
int getStructSize() const; int getStructSize() const;
TBasicType type : 6; TBasicType type : 6;
TPrecision precision; TPrecision precision;
TQualifier qualifier : 7; TQualifier qualifier : 7;
int size : 8; // size of vector or matrix, not size of array int size : 8; // size of vector or matrix, not size of array
unsigned int matrix : 1; unsigned int matrix : 1;
unsigned int array : 1; unsigned int array : 1;
int arraySize; int arraySize;
TTypeList* structure; // 0 unless this is a struct TTypeList* structure; // 0 unless this is a struct
mutable int structureSize; mutable int structureSize;
int maxArraySize; int maxArraySize;
TType* arrayInformationType; TType* arrayInformationType;
TString *fieldName; // for structure field names TString *fieldName; // for structure field names
TString *mangled; TString *mangled;
TString *typeName; // for structure field type name TString *typeName; // for structure field type name
}; };
#endif // _TYPES_INCLUDED_ #endif // _TYPES_INCLUDED_
src/compiler/glslang.y
...@@ -732,7 +732,7 @@ unary_expression ...@@ -732,7 +732,7 @@ unary_expression
switch($1.op) { switch($1.op) {
case EOpNegative: errorOp = "-"; break; case EOpNegative: errorOp = "-"; break;
case EOpLogicalNot: errorOp = "!"; break; case EOpLogicalNot: errorOp = "!"; break;
default: break; default: break;
} }
parseContext->unaryOpError($1.line, errorOp, $2->getCompleteString()); parseContext->unaryOpError($1.line, errorOp, $2->getCompleteString());
parseContext->recover(); parseContext->recover();
...@@ -1011,12 +1011,12 @@ declaration ...@@ -1011,12 +1011,12 @@ declaration
$$ = prototype; $$ = prototype;
} }
| init_declarator_list SEMICOLON { | init_declarator_list SEMICOLON {
if ($1.intermAggregate) if ($1.intermAggregate)
$1.intermAggregate->setOperator(EOpDeclaration); $1.intermAggregate->setOperator(EOpDeclaration);
$$ = $1.intermAggregate; $$ = $1.intermAggregate;
} }
| PRECISION precision_qualifier type_specifier_no_prec SEMICOLON { | PRECISION precision_qualifier type_specifier_no_prec SEMICOLON {
$$ = 0; $$ = 0;
} }
; ;
...@@ -1274,7 +1274,7 @@ init_declarator_list ...@@ -1274,7 +1274,7 @@ init_declarator_list
if (parseContext->arrayTypeErrorCheck($4.line, $1.type) || parseContext->arrayQualifierErrorCheck($4.line, $1.type)) if (parseContext->arrayTypeErrorCheck($4.line, $1.type) || parseContext->arrayQualifierErrorCheck($4.line, $1.type))
parseContext->recover(); parseContext->recover();
else { else {
$1.type.setArray(true, $7->getType().getArraySize()); $1.type.setArray(true, $7->getType().getArraySize());
if (parseContext->arrayErrorCheck($4.line, *$3.string, $1.type, variable)) if (parseContext->arrayErrorCheck($4.line, *$3.string, $1.type, variable))
parseContext->recover(); parseContext->recover();
} }
...@@ -1345,7 +1345,7 @@ init_declarator_list ...@@ -1345,7 +1345,7 @@ init_declarator_list
// build the intermediate representation // build the intermediate representation
// //
if (intermNode) if (intermNode)
$$.intermAggregate = parseContext->intermediate.growAggregate($1.intermNode, intermNode, $4.line); $$.intermAggregate = parseContext->intermediate.growAggregate($1.intermNode, intermNode, $4.line);
else else
$$.intermAggregate = $1.intermAggregate; $$.intermAggregate = $1.intermAggregate;
} else { } else {
...@@ -1361,7 +1361,7 @@ single_declaration ...@@ -1361,7 +1361,7 @@ single_declaration
$$.intermAggregate = parseContext->intermediate.makeAggregate(parseContext->intermediate.addSymbol(0, "", TType($1), $1.line), $1.line); $$.intermAggregate = parseContext->intermediate.makeAggregate(parseContext->intermediate.addSymbol(0, "", TType($1), $1.line), $1.line);
} }
| fully_specified_type IDENTIFIER { | fully_specified_type IDENTIFIER {
$$.intermAggregate = parseContext->intermediate.makeAggregate(parseContext->intermediate.addSymbol(0, *$2.string, TType($1), $2.line), $2.line); $$.intermAggregate = parseContext->intermediate.makeAggregate(parseContext->intermediate.addSymbol(0, *$2.string, TType($1), $2.line), $2.line);
if (parseContext->structQualifierErrorCheck($2.line, $$.type)) if (parseContext->structQualifierErrorCheck($2.line, $$.type))
parseContext->recover(); parseContext->recover();
...@@ -1395,11 +1395,11 @@ single_declaration ...@@ -1395,11 +1395,11 @@ single_declaration
} }
} }
| fully_specified_type IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET { | fully_specified_type IDENTIFIER LEFT_BRACKET constant_expression RIGHT_BRACKET {
TType type = TType($1); TType type = TType($1);
int size; int size;
if (parseContext->arraySizeErrorCheck($2.line, $4, size)) if (parseContext->arraySizeErrorCheck($2.line, $4, size))
parseContext->recover(); parseContext->recover();
type.setArraySize(size); type.setArraySize(size);
$$.intermAggregate = parseContext->intermediate.makeAggregate(parseContext->intermediate.addSymbol(0, *$2.string, type, $2.line), $2.line); $$.intermAggregate = parseContext->intermediate.makeAggregate(parseContext->intermediate.addSymbol(0, *$2.string, type, $2.line), $2.line);
if (parseContext->structQualifierErrorCheck($2.line, $1)) if (parseContext->structQualifierErrorCheck($2.line, $1))
...@@ -1429,24 +1429,24 @@ single_declaration ...@@ -1429,24 +1429,24 @@ single_declaration
$$.type = $1; $$.type = $1;
TIntermNode* intermNode; TIntermNode* intermNode;
if (!parseContext->executeInitializer($2.line, *$2.string, $1, $4, intermNode)) { if (!parseContext->executeInitializer($2.line, *$2.string, $1, $4, intermNode)) {
// //
// Build intermediate representation // Build intermediate representation
// //
if(intermNode) if(intermNode)
$$.intermAggregate = parseContext->intermediate.makeAggregate(intermNode, $3.line); $$.intermAggregate = parseContext->intermediate.makeAggregate(intermNode, $3.line);
else else
$$.intermAggregate = 0; $$.intermAggregate = 0;
} else { } else {
parseContext->recover(); parseContext->recover();
$$.intermAggregate = 0; $$.intermAggregate = 0;
} }
} }
| INVARIANT IDENTIFIER { | INVARIANT IDENTIFIER {
VERTEX_ONLY("invariant declaration", $1.line); VERTEX_ONLY("invariant declaration", $1.line);
$$.qualifier = EvqInvariantVaryingOut; $$.qualifier = EvqInvariantVaryingOut;
$$.intermAggregate = 0; $$.intermAggregate = 0;
} }
// //
...@@ -1589,23 +1589,23 @@ type_qualifier ...@@ -1589,23 +1589,23 @@ type_qualifier
type_specifier type_specifier
: type_specifier_no_prec { : type_specifier_no_prec {
$$ = $1; $$ = $1;
} }
| precision_qualifier type_specifier_no_prec { | precision_qualifier type_specifier_no_prec {
$$ = $2; $$ = $2;
$$.setPrecision($1); $$.setPrecision($1);
} }
; ;
precision_qualifier precision_qualifier
: HIGH_PRECISION { : HIGH_PRECISION {
$$ = EbpHigh; $$ = EbpHigh;
} }
| MEDIUM_PRECISION { | MEDIUM_PRECISION {
$$ = EbpMedium; $$ = EbpMedium;
} }
| LOW_PRECISION { | LOW_PRECISION {
$$ = EbpLow; $$ = EbpLow;
} }
; ;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment