Source/ThirdParty/ANGLE: Update ANGLE from r1987 to r2426 while keeping these changes:
authorachristensen@apple.com <achristensen@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 17 Jul 2013 05:34:17 +0000 (05:34 +0000)
committerachristensen@apple.com <achristensen@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 17 Jul 2013 05:34:17 +0000 (05:34 +0000)
Keeping #if defined(_MSC_VER) around #pragma warning(disable: 4718) in DependencyGraph.cpp.
Keeping include khrplatform.h instead of KHR/khrplatform.h in ShaderLang.h.
Added static_casts in Intermediate.cpp to fix compiling on Mac.
Changed enum bit fields to just enums for GCC in Types.h to fix compiling for GTK.
Ran Bison on Mac after removing the unsupported %code tag (See diff uploaded to bug for details).
Added YYLTYPE definition to glslang_tab.h which would have been put there by the unsupported %code tag.

https://bugs.webkit.org/show_bug.cgi?id=118550

Reviewed by Dean Jackson.

* ANGLE.plist: Updated revision of ANGLE to 2426.
* ANGLE.xcodeproj/project.pbxproj:
* GNUmakefile.am:
* Target.pri:
    Renamed DetectRecursion to DetectCallDepth and added builtin_symbol_table.
* include/GLSLANG/ShaderLang.h:
* src/common/version.h:
* src/compiler/BaseTypes.h:
(getQualifierString):
* src/compiler/Common.h:
* src/compiler/Compiler.cpp:
(TCompiler::TCompiler):
(TCompiler::Init):
(TCompiler::compile):
(TCompiler::detectCallDepth):
(TCompiler::enforceTimingRestrictions):
(TCompiler::limitExpressionComplexity):
* src/compiler/ConstantUnion.h:
(ConstantUnion::ConstantUnion):
* src/compiler/DetectCallDepth.cpp: Added.
(DetectCallDepth::FunctionNode::FunctionNode):
(DetectCallDepth::FunctionNode::getName):
(DetectCallDepth::FunctionNode::addCallee):
(DetectCallDepth::FunctionNode::detectCallDepth):
(DetectCallDepth::FunctionNode::reset):
(DetectCallDepth::DetectCallDepth):
(DetectCallDepth::~DetectCallDepth):
(DetectCallDepth::visitAggregate):
(DetectCallDepth::checkExceedsMaxDepth):
(DetectCallDepth::resetFunctionNodes):
(DetectCallDepth::detectCallDepthForFunction):
(DetectCallDepth::detectCallDepth):
(DetectCallDepth::findFunctionByName):
* src/compiler/DetectCallDepth.h: Added.
(DetectCallDepth::getInfoSink):
* src/compiler/DetectRecursion.cpp: Removed.
* src/compiler/DetectRecursion.h: Removed.
* src/compiler/Diagnostics.cpp:
(TDiagnostics::writeInfo):
* src/compiler/ForLoopUnroll.cpp:
(ForLoopUnroll::evaluateIntConstant):
* src/compiler/InfoSink.cpp:
(TInfoSinkBase::prefix):
(TInfoSinkBase::location):
(TInfoSinkBase::message):
* src/compiler/InfoSink.h:
* src/compiler/Initialize.cpp:
(TBuiltIns::initialize):
(IdentifyBuiltIns):
(InitExtensionBehavior):
* src/compiler/Intermediate.cpp: Updated and added static_casts to fix build errors on Mac.
(TIntermediate::addSymbol):
(TIntermediate::addBinaryMath):
(TIntermediate::addAssign):
(TIntermediate::addIndex):
(TIntermediate::addUnaryMath):
(TIntermediate::setAggregateOperator):
(TIntermediate::addConversion):
(TIntermediate::growAggregate):
(TIntermediate::makeAggregate):
(TIntermediate::addSelection):
(TIntermediate::addComma):
(TIntermediate::addConstantUnion):
(TIntermediate::addSwizzle):
(TIntermediate::addLoop):
(TIntermediate::addBranch):
(TIntermUnary::promote):
(TIntermBinary::promote):
(CompareStruct):
(CompareStructure):
(TIntermConstantUnion::fold):
(TIntermediate::promoteConstantUnion):
* src/compiler/OutputGLSL.cpp:
(TOutputGLSL::visitSymbol):
* src/compiler/OutputGLSL.h:
* src/compiler/OutputGLSLBase.cpp:
(TOutputGLSLBase::writeVariableType):
(TOutputGLSLBase::writeConstantUnion):
(TOutputGLSLBase::visitBinary):
(TOutputGLSLBase::visitAggregate):
(TOutputGLSLBase::getTypeName):
(TOutputGLSLBase::hashFunctionName):
(TOutputGLSLBase::structDeclared):
(TOutputGLSLBase::declareStruct):
* src/compiler/OutputGLSLBase.h:
* src/compiler/OutputHLSL.cpp:
(sh::OutputHLSL::OutputHLSL):
(sh::OutputHLSL::header):
(sh::OutputHLSL::visitSymbol):
(sh::OutputHLSL::visitBinary):
(sh::OutputHLSL::visitAggregate):
(sh::OutputHLSL::visitSelection):
(sh::OutputHLSL::visitLoop):
(sh::OutputHLSL::handleExcessiveLoop):
(sh::OutputHLSL::typeString):
(sh::OutputHLSL::initializer):
(sh::OutputHLSL::addConstructor):
(sh::OutputHLSL::writeConstantUnion):
(sh::OutputHLSL::decorateField):
* src/compiler/OutputHLSL.h:
* src/compiler/ParseHelper.cpp:
(TParseContext::parseVectorFields):
(TParseContext::parseMatrixFields):
(TParseContext::error):
(TParseContext::warning):
(TParseContext::assignError):
(TParseContext::unaryOpError):
(TParseContext::binaryOpError):
(TParseContext::precisionErrorCheck):
(TParseContext::lValueErrorCheck):
(TParseContext::globalErrorCheck):
(TParseContext::reservedErrorCheck):
(TParseContext::constructorErrorCheck):
(TParseContext::voidErrorCheck):
(TParseContext::boolErrorCheck):
(TParseContext::samplerErrorCheck):
(TParseContext::structQualifierErrorCheck):
(TParseContext::parameterSamplerErrorCheck):
(TParseContext::containsSampler):
(TParseContext::arraySizeErrorCheck):
(TParseContext::arrayQualifierErrorCheck):
(TParseContext::arrayTypeErrorCheck):
(TParseContext::arrayErrorCheck):
(TParseContext::nonInitConstErrorCheck):
(TParseContext::nonInitErrorCheck):
(TParseContext::paramErrorCheck):
(TParseContext::extensionErrorCheck):
(TParseContext::findFunction):
(TParseContext::isVariableBuiltIn):
(TParseContext::executeInitializer):
(TParseContext::addConstructor):
(TParseContext::constructBuiltIn):
(TParseContext::constructStruct):
(TParseContext::addConstVectorNode):
(TParseContext::addConstMatrixNode):
(TParseContext::addConstArrayNode):
(TParseContext::addConstStruct):
(TParseContext::enterStructDeclaration):
(TParseContext::structNestingErrorCheck):
* src/compiler/ParseHelper.h:
(TParseContext::TParseContext):
(TParseContext::pragma):
* src/compiler/PoolAlloc.cpp:
(TPoolAllocator::allocate):
* src/compiler/ShHandle.h:
* src/compiler/ShaderLang.cpp:
(ShInitBuiltInResources):
* src/compiler/SymbolTable.cpp:
(TType::TType):
(TType::buildMangledName):
(TType::getObjectSize):
(TStructure::containsArrays):
(TStructure::buildMangledName):
(TStructure::calculateObjectSize):
(TStructure::calculateDeepestNesting):
(TSymbolTableLevel::relateToExtension):
* src/compiler/SymbolTable.h:
(TSymbol::relateToExtension):
(TSymbol::getExtension):
(TVariable::TVariable):
(TVariable::setQualifier):
(TVariable::shareConstPointer):
* src/compiler/Types.h: Updated and changed enum bit fields to enums to fix compiling with GCC.
(TField::TField):
(TField::type):
(TField::name):
(NewPoolTFieldList):
(TStructure::TStructure):
(TStructure::name):
(TStructure::fields):
(TStructure::mangledName):
(TStructure::objectSize):
(TStructure::deepestNesting):
(TType::TType):
(TType::clearArrayness):
(TType::getStruct):
(TType::setStruct):
(TType::getMangledName):
(TType::getDeepestStructNesting):
(TType::isStructureContainingArrays):
(TPublicType::setBasic):
* src/compiler/VariableInfo.cpp:
(getUserDefinedVariableInfo):
* src/compiler/builtin_symbol_table.cpp: Added.
(builtin1):
(builtin2):
(builtin3):
(InsertBuiltInFunctionsCommon):
(InsertBuiltInFunctionsVertex):
* src/compiler/builtin_symbol_table.h: Added.
* src/compiler/glslang.l:
* src/compiler/glslang.y:
* src/compiler/glslang_lex.cpp:
(yy_get_previous_state):
(yy_try_NUL_trans):
(yyget_lloc):
(yyset_lloc):
(string_input):
(check_type):
(reserved_word):
(glslang_scan):
* src/compiler/glslang_tab.cpp:
(yysyntax_error):
(yyerror):
(glslang_parse):
* src/compiler/glslang_tab.h: Readded YYLTYPE definition after Bison removed it.
* src/compiler/intermOut.cpp:
(TOutputTraverser::visitUnary):
(TOutputTraverser::visitAggregate):
(TOutputTraverser::visitConstantUnion):
* src/compiler/intermediate.h:
(TIntermNode::TIntermNode):
(TIntermNode::~TIntermNode):
(TIntermNode::getLine):
(TIntermNode::setLine):
(TIntermNode::getAsLoopNode):
(TIntermConstantUnion::getIConst):
(TIntermConstantUnion::getFConst):
(TIntermConstantUnion::getBConst):
(TIntermAggregate::TIntermAggregate):
(TIntermTraverser::TIntermTraverser):
(TIntermTraverser::getMaxDepth):
(TIntermTraverser::incrementDepth):
* src/compiler/localintermediate.h:
* src/compiler/parseConst.cpp:
(TConstTraverser::visitSymbol):
(TConstTraverser::visitBinary):
(TConstTraverser::visitUnary):
(TConstTraverser::visitAggregate):
(TConstTraverser::visitSelection):
(TConstTraverser::visitConstantUnion):
(TConstTraverser::visitLoop):
(TConstTraverser::visitBranch):
(TIntermediate::parseConstTree):
* src/compiler/preprocessor/ExpressionParser.cpp:
* src/compiler/timing/RestrictVertexShaderTiming.cpp:
(RestrictVertexShaderTiming::visitSymbol):
    Updated ANGLE to r2426 and ran Bison.

Source/WebCore: Update ANGLE to r2426.
https://bugs.webkit.org/show_bug.cgi?id=118550

Reviewed by Dean Jackson.

* CMakeLists.txt: Renamed DetectRecursion to DetectCallDepth and added builtin_symbol_table.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@152755 268f45cc-cd09-0410-ab3c-d52691b4dbfc

48 files changed:
Source/ThirdParty/ANGLE/ANGLE.plist
Source/ThirdParty/ANGLE/ANGLE.xcodeproj/project.pbxproj
Source/ThirdParty/ANGLE/ChangeLog
Source/ThirdParty/ANGLE/GNUmakefile.am
Source/ThirdParty/ANGLE/Target.pri
Source/ThirdParty/ANGLE/include/GLSLANG/ShaderLang.h
Source/ThirdParty/ANGLE/src/compiler/BaseTypes.h
Source/ThirdParty/ANGLE/src/compiler/Common.h
Source/ThirdParty/ANGLE/src/compiler/Compiler.cpp
Source/ThirdParty/ANGLE/src/compiler/ConstantUnion.h
Source/ThirdParty/ANGLE/src/compiler/DetectCallDepth.cpp [new file with mode: 0644]
Source/ThirdParty/ANGLE/src/compiler/DetectCallDepth.h [moved from Source/ThirdParty/ANGLE/src/compiler/DetectRecursion.h with 59% similarity]
Source/ThirdParty/ANGLE/src/compiler/DetectRecursion.cpp [deleted file]
Source/ThirdParty/ANGLE/src/compiler/Diagnostics.cpp
Source/ThirdParty/ANGLE/src/compiler/ForLoopUnroll.cpp
Source/ThirdParty/ANGLE/src/compiler/InfoSink.cpp
Source/ThirdParty/ANGLE/src/compiler/InfoSink.h
Source/ThirdParty/ANGLE/src/compiler/Initialize.cpp
Source/ThirdParty/ANGLE/src/compiler/Intermediate.cpp
Source/ThirdParty/ANGLE/src/compiler/OutputGLSL.cpp
Source/ThirdParty/ANGLE/src/compiler/OutputGLSL.h
Source/ThirdParty/ANGLE/src/compiler/OutputGLSLBase.cpp
Source/ThirdParty/ANGLE/src/compiler/OutputGLSLBase.h
Source/ThirdParty/ANGLE/src/compiler/OutputHLSL.cpp
Source/ThirdParty/ANGLE/src/compiler/OutputHLSL.h
Source/ThirdParty/ANGLE/src/compiler/ParseHelper.cpp
Source/ThirdParty/ANGLE/src/compiler/ParseHelper.h
Source/ThirdParty/ANGLE/src/compiler/PoolAlloc.cpp
Source/ThirdParty/ANGLE/src/compiler/ShHandle.h
Source/ThirdParty/ANGLE/src/compiler/ShaderLang.cpp
Source/ThirdParty/ANGLE/src/compiler/SymbolTable.cpp
Source/ThirdParty/ANGLE/src/compiler/SymbolTable.h
Source/ThirdParty/ANGLE/src/compiler/Types.h
Source/ThirdParty/ANGLE/src/compiler/VariableInfo.cpp
Source/ThirdParty/ANGLE/src/compiler/builtin_symbol_table.cpp [new file with mode: 0644]
Source/ThirdParty/ANGLE/src/compiler/builtin_symbol_table.h [new file with mode: 0644]
Source/ThirdParty/ANGLE/src/compiler/glslang.l
Source/ThirdParty/ANGLE/src/compiler/glslang.y
Source/ThirdParty/ANGLE/src/compiler/glslang_lex.cpp
Source/ThirdParty/ANGLE/src/compiler/glslang_tab.cpp
Source/ThirdParty/ANGLE/src/compiler/glslang_tab.h
Source/ThirdParty/ANGLE/src/compiler/intermOut.cpp
Source/ThirdParty/ANGLE/src/compiler/intermediate.h
Source/ThirdParty/ANGLE/src/compiler/localintermediate.h
Source/ThirdParty/ANGLE/src/compiler/parseConst.cpp
Source/ThirdParty/ANGLE/src/compiler/timing/RestrictVertexShaderTiming.cpp
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog

index 809891c..dbc0127 100644 (file)
@@ -6,13 +6,13 @@
                <key>OpenSourceProject</key>
                <string>ANGLE</string>
                <key>OpenSourceVersion</key>
-               <string>r1641</string>
+               <string>r2426</string>
                <key>OpenSourceWebsiteURL</key>
                <string>http://code.google.com/p/angleproject/</string>
                <key>OpenSourceSCM</key>
-               <string>svn co -r1641 http://angleproject.googlecode.com/svn/trunk/</string>
+               <string>svn co -r2426 http://angleproject.googlecode.com/svn/trunk/</string>
                <key>OpenSourceImportDate</key>
-               <string>2013-01-04</string>
+               <string>2013-06-13</string>
                <key>OpenSourceLicense</key>
                <string>BSD</string>
                <key>OpenSourceLicenseFile</key>
index ef0e76f..fce5917 100644 (file)
@@ -12,8 +12,9 @@
                49951C0314B7AAB30060E96E /* length_limits.h in Headers */ = {isa = PBXBuildFile; fileRef = 49951C0214B7AAB30060E96E /* length_limits.h */; };
                49951C0914B7AAD80060E96E /* BuiltInFunctionEmulator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49951C0514B7AAD70060E96E /* BuiltInFunctionEmulator.cpp */; };
                49951C0A14B7AAD80060E96E /* BuiltInFunctionEmulator.h in Headers */ = {isa = PBXBuildFile; fileRef = 49951C0614B7AAD80060E96E /* BuiltInFunctionEmulator.h */; };
-               49951C0B14B7AAD80060E96E /* DetectRecursion.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49951C0714B7AAD80060E96E /* DetectRecursion.cpp */; };
-               49951C0C14B7AAD80060E96E /* DetectRecursion.h in Headers */ = {isa = PBXBuildFile; fileRef = 49951C0814B7AAD80060E96E /* DetectRecursion.h */; };
+               49951C0B14B7AAD80060E96E /* DetectCallDepth.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49951C0714B7AAD80060E96E /* DetectCallDepth.cpp */; };
+               49951C0C14B7AAD80060E96E /* DetectCallDepth.h in Headers */ = {isa = PBXBuildFile; fileRef = 49951C0814B7AAD80060E96E /* DetectCallDepth.h */; };
+               5CCEB8B617908EEC00FD9496 /* builtin_symbol_table.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5CCEB8B417908E3A00FD9496 /* builtin_symbol_table.cpp */; };
                90D9B10212E11DCB002D4255 /* Compiler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 90D9B0F912E11DCB002D4255 /* Compiler.cpp */; };
                90D9B10312E11DCB002D4255 /* ExtensionBehavior.h in Headers */ = {isa = PBXBuildFile; fileRef = 90D9B0FA12E11DCB002D4255 /* ExtensionBehavior.h */; };
                90D9B10412E11DCB002D4255 /* glslang_lex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 90D9B0FB12E11DCB002D4255 /* glslang_lex.cpp */; };
                49951C0214B7AAB30060E96E /* length_limits.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = length_limits.h; sourceTree = "<group>"; };
                49951C0514B7AAD70060E96E /* BuiltInFunctionEmulator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BuiltInFunctionEmulator.cpp; sourceTree = "<group>"; };
                49951C0614B7AAD80060E96E /* BuiltInFunctionEmulator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BuiltInFunctionEmulator.h; sourceTree = "<group>"; };
-               49951C0714B7AAD80060E96E /* DetectRecursion.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DetectRecursion.cpp; sourceTree = "<group>"; };
-               49951C0814B7AAD80060E96E /* DetectRecursion.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetectRecursion.h; sourceTree = "<group>"; };
+               49951C0714B7AAD80060E96E /* DetectCallDepth.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DetectCallDepth.cpp; sourceTree = "<group>"; };
+               49951C0814B7AAD80060E96E /* DetectCallDepth.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DetectCallDepth.h; sourceTree = "<group>"; };
+               5CCEB8B417908E3A00FD9496 /* builtin_symbol_table.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = builtin_symbol_table.cpp; sourceTree = "<group>"; };
+               5CCEB8B517908E3A00FD9496 /* builtin_symbol_table.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = builtin_symbol_table.h; sourceTree = "<group>"; };
                5D7C59C51208C68B001C873E /* ANGLE.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = ANGLE.xcconfig; sourceTree = "<group>"; };
                5D7C59C61208C68B001C873E /* Base.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Base.xcconfig; sourceTree = "<group>"; };
                5D7C59C71208C68B001C873E /* DebugRelease.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = DebugRelease.xcconfig; sourceTree = "<group>"; };
                                A265682C159C23E100398539 /* depgraph */,
                                FB39D2441200F35A00088E69 /* preprocessor */,
                                A2656834159C23E100398539 /* timing */,
+                               5CCEB8B417908E3A00FD9496 /* builtin_symbol_table.cpp */,
+                               5CCEB8B517908E3A00FD9496 /* builtin_symbol_table.h */,
                                FB39D2211200F35A00088E69 /* BaseTypes.h */,
                                49951C0514B7AAD70060E96E /* BuiltInFunctionEmulator.cpp */,
                                49951C0614B7AAD80060E96E /* BuiltInFunctionEmulator.h */,
                                FB39D2251200F35A00088E69 /* ConstantUnion.h */,
                                FB39D2261200F35A00088E69 /* debug.cpp */,
                                FB39D2271200F35A00088E69 /* debug.h */,
-                               49951C0714B7AAD80060E96E /* DetectRecursion.cpp */,
-                               49951C0814B7AAD80060E96E /* DetectRecursion.h */,
+                               49951C0714B7AAD80060E96E /* DetectCallDepth.cpp */,
+                               49951C0814B7AAD80060E96E /* DetectCallDepth.h */,
                                A26567B0159C21B100398539 /* Diagnostics.cpp */,
                                A26567B1159C21B100398539 /* Diagnostics.h */,
                                A26567B2159C21B100398539 /* DirectiveHandler.cpp */,
                                A265683A159C23E100398539 /* DependencyGraph.h in Headers */,
                                A265683C159C23E100398539 /* DependencyGraphBuilder.h in Headers */,
                                A265683E159C23E100398539 /* DependencyGraphOutput.h in Headers */,
-                               49951C0C14B7AAD80060E96E /* DetectRecursion.h in Headers */,
+                               49951C0C14B7AAD80060E96E /* DetectCallDepth.h in Headers */,
                                A26567BC159C21B100398539 /* Diagnostics.h in Headers */,
                                A264F8AD16974DED006FAA5A /* DiagnosticsBase.h in Headers */,
                                A26567BE159C21B100398539 /* DirectiveHandler.h in Headers */,
                                A265683B159C23E100398539 /* DependencyGraphBuilder.cpp in Sources */,
                                A265683D159C23E100398539 /* DependencyGraphOutput.cpp in Sources */,
                                A265683F159C23E100398539 /* DependencyGraphTraverse.cpp in Sources */,
-                               49951C0B14B7AAD80060E96E /* DetectRecursion.cpp in Sources */,
+                               49951C0B14B7AAD80060E96E /* DetectCallDepth.cpp in Sources */,
                                A26567BB159C21B100398539 /* Diagnostics.cpp in Sources */,
                                A264F8AC16974DED006FAA5A /* DiagnosticsBase.cpp in Sources */,
                                A26567BD159C21B100398539 /* DirectiveHandler.cpp in Sources */,
                                A2656840159C23E100398539 /* RestrictFragmentShaderTiming.cpp in Sources */,
                                A2656842159C23E100398539 /* RestrictVertexShaderTiming.cpp in Sources */,
                                90D9B10912E11DCB002D4255 /* SearchSymbol.cpp in Sources */,
+                               5CCEB8B617908EEC00FD9496 /* builtin_symbol_table.cpp in Sources */,
                                FB39D2A81200F35A00088E69 /* ShaderLang.cpp in Sources */,
                                FB39D2AA1200F35A00088E69 /* SymbolTable.cpp in Sources */,
                                A264F8C116974DED006FAA5A /* Token.cpp in Sources */,
index 539ab66..7cfc17b 100644 (file)
@@ -1,3 +1,256 @@
+2013-07-16  Alex Christensen  <achristensen@apple.com>
+
+        Update ANGLE from r1987 to r2426 while keeping these changes:
+        Keeping #if defined(_MSC_VER) around #pragma warning(disable: 4718) in DependencyGraph.cpp.
+        Keeping include khrplatform.h instead of KHR/khrplatform.h in ShaderLang.h.
+        Added static_casts in Intermediate.cpp to fix compiling on Mac.
+        Changed enum bit fields to just enums for GCC in Types.h to fix compiling for GTK.
+        Ran Bison on Mac after removing the unsupported %code tag (See diff uploaded to bug for details).
+        Added YYLTYPE definition to glslang_tab.h which would have been put there by the unsupported %code tag.
+
+        https://bugs.webkit.org/show_bug.cgi?id=118550
+
+        Reviewed by Dean Jackson.
+
+        * ANGLE.plist: Updated revision of ANGLE to 2426.
+        * ANGLE.xcodeproj/project.pbxproj:
+        * GNUmakefile.am:
+        * Target.pri:
+            Renamed DetectRecursion to DetectCallDepth and added builtin_symbol_table.
+        * include/GLSLANG/ShaderLang.h:
+        * src/common/version.h:
+        * src/compiler/BaseTypes.h:
+        (getQualifierString):
+        * src/compiler/Common.h:
+        * src/compiler/Compiler.cpp:
+        (TCompiler::TCompiler):
+        (TCompiler::Init):
+        (TCompiler::compile):
+        (TCompiler::detectCallDepth):
+        (TCompiler::enforceTimingRestrictions):
+        (TCompiler::limitExpressionComplexity):
+        * src/compiler/ConstantUnion.h:
+        (ConstantUnion::ConstantUnion):
+        * src/compiler/DetectCallDepth.cpp: Added.
+        (DetectCallDepth::FunctionNode::FunctionNode):
+        (DetectCallDepth::FunctionNode::getName):
+        (DetectCallDepth::FunctionNode::addCallee):
+        (DetectCallDepth::FunctionNode::detectCallDepth):
+        (DetectCallDepth::FunctionNode::reset):
+        (DetectCallDepth::DetectCallDepth):
+        (DetectCallDepth::~DetectCallDepth):
+        (DetectCallDepth::visitAggregate):
+        (DetectCallDepth::checkExceedsMaxDepth):
+        (DetectCallDepth::resetFunctionNodes):
+        (DetectCallDepth::detectCallDepthForFunction):
+        (DetectCallDepth::detectCallDepth):
+        (DetectCallDepth::findFunctionByName):
+        * src/compiler/DetectCallDepth.h: Added.
+        (DetectCallDepth::getInfoSink):
+        * src/compiler/DetectRecursion.cpp: Removed.
+        * src/compiler/DetectRecursion.h: Removed.
+        * src/compiler/Diagnostics.cpp:
+        (TDiagnostics::writeInfo):
+        * src/compiler/ForLoopUnroll.cpp:
+        (ForLoopUnroll::evaluateIntConstant):
+        * src/compiler/InfoSink.cpp:
+        (TInfoSinkBase::prefix):
+        (TInfoSinkBase::location):
+        (TInfoSinkBase::message):
+        * src/compiler/InfoSink.h:
+        * src/compiler/Initialize.cpp:
+        (TBuiltIns::initialize):
+        (IdentifyBuiltIns):
+        (InitExtensionBehavior):
+        * src/compiler/Intermediate.cpp: Updated and added static_casts to fix build errors on Mac.
+        (TIntermediate::addSymbol):
+        (TIntermediate::addBinaryMath):
+        (TIntermediate::addAssign):
+        (TIntermediate::addIndex):
+        (TIntermediate::addUnaryMath):
+        (TIntermediate::setAggregateOperator):
+        (TIntermediate::addConversion):
+        (TIntermediate::growAggregate):
+        (TIntermediate::makeAggregate):
+        (TIntermediate::addSelection):
+        (TIntermediate::addComma):
+        (TIntermediate::addConstantUnion):
+        (TIntermediate::addSwizzle):
+        (TIntermediate::addLoop):
+        (TIntermediate::addBranch):
+        (TIntermUnary::promote):
+        (TIntermBinary::promote):
+        (CompareStruct):
+        (CompareStructure):
+        (TIntermConstantUnion::fold):
+        (TIntermediate::promoteConstantUnion):
+        * src/compiler/OutputGLSL.cpp:
+        (TOutputGLSL::visitSymbol):
+        * src/compiler/OutputGLSL.h:
+        * src/compiler/OutputGLSLBase.cpp:
+        (TOutputGLSLBase::writeVariableType):
+        (TOutputGLSLBase::writeConstantUnion):
+        (TOutputGLSLBase::visitBinary):
+        (TOutputGLSLBase::visitAggregate):
+        (TOutputGLSLBase::getTypeName):
+        (TOutputGLSLBase::hashFunctionName):
+        (TOutputGLSLBase::structDeclared):
+        (TOutputGLSLBase::declareStruct):
+        * src/compiler/OutputGLSLBase.h:
+        * src/compiler/OutputHLSL.cpp:
+        (sh::OutputHLSL::OutputHLSL):
+        (sh::OutputHLSL::header):
+        (sh::OutputHLSL::visitSymbol):
+        (sh::OutputHLSL::visitBinary):
+        (sh::OutputHLSL::visitAggregate):
+        (sh::OutputHLSL::visitSelection):
+        (sh::OutputHLSL::visitLoop):
+        (sh::OutputHLSL::handleExcessiveLoop):
+        (sh::OutputHLSL::typeString):
+        (sh::OutputHLSL::initializer):
+        (sh::OutputHLSL::addConstructor):
+        (sh::OutputHLSL::writeConstantUnion):
+        (sh::OutputHLSL::decorateField):
+        * src/compiler/OutputHLSL.h:
+        * src/compiler/ParseHelper.cpp:
+        (TParseContext::parseVectorFields):
+        (TParseContext::parseMatrixFields):
+        (TParseContext::error):
+        (TParseContext::warning):
+        (TParseContext::assignError):
+        (TParseContext::unaryOpError):
+        (TParseContext::binaryOpError):
+        (TParseContext::precisionErrorCheck):
+        (TParseContext::lValueErrorCheck):
+        (TParseContext::globalErrorCheck):
+        (TParseContext::reservedErrorCheck):
+        (TParseContext::constructorErrorCheck):
+        (TParseContext::voidErrorCheck):
+        (TParseContext::boolErrorCheck):
+        (TParseContext::samplerErrorCheck):
+        (TParseContext::structQualifierErrorCheck):
+        (TParseContext::parameterSamplerErrorCheck):
+        (TParseContext::containsSampler):
+        (TParseContext::arraySizeErrorCheck):
+        (TParseContext::arrayQualifierErrorCheck):
+        (TParseContext::arrayTypeErrorCheck):
+        (TParseContext::arrayErrorCheck):
+        (TParseContext::nonInitConstErrorCheck):
+        (TParseContext::nonInitErrorCheck):
+        (TParseContext::paramErrorCheck):
+        (TParseContext::extensionErrorCheck):
+        (TParseContext::findFunction):
+        (TParseContext::isVariableBuiltIn):
+        (TParseContext::executeInitializer):
+        (TParseContext::addConstructor):
+        (TParseContext::constructBuiltIn):
+        (TParseContext::constructStruct):
+        (TParseContext::addConstVectorNode):
+        (TParseContext::addConstMatrixNode):
+        (TParseContext::addConstArrayNode):
+        (TParseContext::addConstStruct):
+        (TParseContext::enterStructDeclaration):
+        (TParseContext::structNestingErrorCheck):
+        * src/compiler/ParseHelper.h:
+        (TParseContext::TParseContext):
+        (TParseContext::pragma):
+        * src/compiler/PoolAlloc.cpp:
+        (TPoolAllocator::allocate):
+        * src/compiler/ShHandle.h:
+        * src/compiler/ShaderLang.cpp:
+        (ShInitBuiltInResources):
+        * src/compiler/SymbolTable.cpp:
+        (TType::TType):
+        (TType::buildMangledName):
+        (TType::getObjectSize):
+        (TStructure::containsArrays):
+        (TStructure::buildMangledName):
+        (TStructure::calculateObjectSize):
+        (TStructure::calculateDeepestNesting):
+        (TSymbolTableLevel::relateToExtension):
+        * src/compiler/SymbolTable.h:
+        (TSymbol::relateToExtension):
+        (TSymbol::getExtension):
+        (TVariable::TVariable):
+        (TVariable::setQualifier):
+        (TVariable::shareConstPointer):
+        * src/compiler/Types.h: Updated and changed enum bit fields to enums to fix compiling with GCC.
+        (TField::TField):
+        (TField::type):
+        (TField::name):
+        (NewPoolTFieldList):
+        (TStructure::TStructure):
+        (TStructure::name):
+        (TStructure::fields):
+        (TStructure::mangledName):
+        (TStructure::objectSize):
+        (TStructure::deepestNesting):
+        (TType::TType):
+        (TType::clearArrayness):
+        (TType::getStruct):
+        (TType::setStruct):
+        (TType::getMangledName):
+        (TType::getDeepestStructNesting):
+        (TType::isStructureContainingArrays):
+        (TPublicType::setBasic):
+        * src/compiler/VariableInfo.cpp:
+        (getUserDefinedVariableInfo):
+        * src/compiler/builtin_symbol_table.cpp: Added.
+        (builtin1):
+        (builtin2):
+        (builtin3):
+        (InsertBuiltInFunctionsCommon):
+        (InsertBuiltInFunctionsVertex):
+        * src/compiler/builtin_symbol_table.h: Added.
+        * src/compiler/glslang.l:
+        * src/compiler/glslang.y:
+        * src/compiler/glslang_lex.cpp:
+        (yy_get_previous_state):
+        (yy_try_NUL_trans):
+        (yyget_lloc):
+        (yyset_lloc):
+        (string_input):
+        (check_type):
+        (reserved_word):
+        (glslang_scan):
+        * src/compiler/glslang_tab.cpp:
+        (yysyntax_error):
+        (yyerror):
+        (glslang_parse):
+        * src/compiler/glslang_tab.h: Readded YYLTYPE definition after Bison removed it.
+        * src/compiler/intermOut.cpp:
+        (TOutputTraverser::visitUnary):
+        (TOutputTraverser::visitAggregate):
+        (TOutputTraverser::visitConstantUnion):
+        * src/compiler/intermediate.h:
+        (TIntermNode::TIntermNode):
+        (TIntermNode::~TIntermNode):
+        (TIntermNode::getLine):
+        (TIntermNode::setLine):
+        (TIntermNode::getAsLoopNode):
+        (TIntermConstantUnion::getIConst):
+        (TIntermConstantUnion::getFConst):
+        (TIntermConstantUnion::getBConst):
+        (TIntermAggregate::TIntermAggregate):
+        (TIntermTraverser::TIntermTraverser):
+        (TIntermTraverser::getMaxDepth):
+        (TIntermTraverser::incrementDepth):
+        * src/compiler/localintermediate.h:
+        * src/compiler/parseConst.cpp:
+        (TConstTraverser::visitSymbol):
+        (TConstTraverser::visitBinary):
+        (TConstTraverser::visitUnary):
+        (TConstTraverser::visitAggregate):
+        (TConstTraverser::visitSelection):
+        (TConstTraverser::visitConstantUnion):
+        (TConstTraverser::visitLoop):
+        (TConstTraverser::visitBranch):
+        (TIntermediate::parseConstTree):
+        * src/compiler/preprocessor/ExpressionParser.cpp:
+        * src/compiler/timing/RestrictVertexShaderTiming.cpp:
+        (RestrictVertexShaderTiming::visitSymbol):
+            Updated ANGLE to r2426 and ran Bison.
+
 2013-06-17  Darin Adler  <darin@apple.com>
 
         Sort all the Xcode project files
index 978f331..58befb7 100644 (file)
@@ -24,6 +24,8 @@ libANGLE_la_SOURCES = \
        Source/ThirdParty/ANGLE/include/KHR/khrplatform.h \
        Source/ThirdParty/ANGLE/src/common/angleutils.h \
        Source/ThirdParty/ANGLE/src/compiler/BaseTypes.h \
+       Source/ThirdParty/ANGLE/src/compiler/builtin_symbol_table.cpp \
+       Source/ThirdParty/ANGLE/src/compiler/builtin_symbol_table.h \
        Source/ThirdParty/ANGLE/src/compiler/BuiltInFunctionEmulator.cpp \
        Source/ThirdParty/ANGLE/src/compiler/BuiltInFunctionEmulator.h \
        Source/ThirdParty/ANGLE/src/compiler/CodeGenGLSL.cpp \
@@ -39,10 +41,10 @@ libANGLE_la_SOURCES = \
        Source/ThirdParty/ANGLE/src/compiler/depgraph/DependencyGraphOutput.h \
        Source/ThirdParty/ANGLE/src/compiler/depgraph/DependencyGraphOutput.cpp \
        Source/ThirdParty/ANGLE/src/compiler/depgraph/DependencyGraphTraverse.cpp \
+       Source/ThirdParty/ANGLE/src/compiler/DetectCallDepth.cpp \
+       Source/ThirdParty/ANGLE/src/compiler/DetectCallDepth.h \
        Source/ThirdParty/ANGLE/src/compiler/DetectDiscontinuity.cpp \
        Source/ThirdParty/ANGLE/src/compiler/DetectDiscontinuity.h \
-       Source/ThirdParty/ANGLE/src/compiler/DetectRecursion.cpp \
-       Source/ThirdParty/ANGLE/src/compiler/DetectRecursion.h \
        Source/ThirdParty/ANGLE/src/compiler/Diagnostics.cpp \
        Source/ThirdParty/ANGLE/src/compiler/Diagnostics.h \
        Source/ThirdParty/ANGLE/src/compiler/DirectiveHandler.cpp \
index 0057087..b878af6 100644 (file)
@@ -18,6 +18,7 @@ INCLUDEPATH += \
 
 HEADERS += \
     src/compiler/BaseTypes.h \
+    src/compiler/builtin_symbol_table.h \
     src/compiler/BuiltInFunctionEmulator.h \
     src/compiler/Common.h \
     src/compiler/ConstantUnion.h \
@@ -25,8 +26,8 @@ HEADERS += \
     src/compiler/depgraph/DependencyGraph.h \
     src/compiler/depgraph/DependencyGraphBuilder.h \
     src/compiler/depgraph/DependencyGraphOutput.h \
+    src/compiler/DetectCallDepth.h \
     src/compiler/DetectDiscontinuity.h \
-    src/compiler/DetectRecursion.h \
     src/compiler/Diagnostics.h \
     src/compiler/DirectiveHandler.h \
     src/compiler/ExtensionBehavior.h \
@@ -84,6 +85,7 @@ HEADERS += \
     src/third_party/compiler/ArrayBoundsClamper.h
 
 SOURCES += \
+    src/compiler/builtin_symbol_table.cpp \
     src/compiler/BuiltInFunctionEmulator.cpp \
     src/compiler/CodeGenGLSL.cpp \
     src/compiler/Compiler.cpp \
@@ -92,8 +94,8 @@ SOURCES += \
     src/compiler/depgraph/DependencyGraphBuilder.cpp \
     src/compiler/depgraph/DependencyGraphOutput.cpp \
     src/compiler/depgraph/DependencyGraphTraverse.cpp \
+    src/compiler/DetectCallDepth.cpp \
     src/compiler/DetectDiscontinuity.cpp \
-    src/compiler/DetectRecursion.cpp \
     src/compiler/Diagnostics.cpp \
     src/compiler/DirectiveHandler.cpp \
     src/compiler/ForLoopUnroll.cpp \
index 103db29..3212959 100644 (file)
@@ -159,7 +159,13 @@ typedef enum {
   // vec234, or mat234 type. The ShArrayIndexClampingStrategy enum,
   // specified in the ShBuiltInResources when constructing the
   // compiler, selects the strategy for the clamping implementation.
-  SH_CLAMP_INDIRECT_ARRAY_BOUNDS = 0x1000
+  SH_CLAMP_INDIRECT_ARRAY_BOUNDS = 0x1000,
+
+  // This flag limits the complexity of an expression.
+  SH_LIMIT_EXPRESSION_COMPLEXITY = 0x2000,
+
+  // This flag limits the depth of the call stack.
+  SH_LIMIT_CALL_STACK_DEPTH = 0x4000,
 } ShCompileOptions;
 
 // Defines alternate strategies for implementing array index clamping.
@@ -209,6 +215,7 @@ typedef struct
     int OES_EGL_image_external;
     int ARB_texture_rectangle;
     int EXT_draw_buffers;
+    int EXT_frag_depth;
 
     // Set to 1 if highp precision is supported in the fragment language.
     // Default is 0.
@@ -222,6 +229,12 @@ typedef struct
     // Selects a strategy to use when implementing array index clamping.
     // Default is SH_CLAMP_WITH_CLAMP_INTRINSIC.
     ShArrayIndexClampingStrategy ArrayIndexClampingStrategy;
+
+    // The maximum complexity an expression can be.
+    int MaxExpressionComplexity;
+
+    // The maximum depth a call stack can be.
+    int MaxCallStackDepth;
 } ShBuiltInResources;
 
 //
index af4c7e3..1631f4f 100644 (file)
@@ -90,10 +90,6 @@ enum TQualifier
     EvqInvariantVaryingOut,    // vertex shaders only  read/write
     EvqUniform,       // Readonly, vertex and fragment
 
-    // pack/unpack input and output
-    EvqInput,
-    EvqOutput,
-
     // parameters
     EvqIn,
     EvqOut,
@@ -112,6 +108,7 @@ enum TQualifier
     // built-ins written by fragment shader
     EvqFragColor,
     EvqFragData,
+    EvqFragDepth,
 
     // end of list
     EvqLast
@@ -137,14 +134,13 @@ inline const char* getQualifierString(TQualifier q)
     case EvqIn:             return "in";             break;
     case EvqOut:            return "out";            break;
     case EvqInOut:          return "inout";          break;
-    case EvqInput:          return "input";          break;
-    case EvqOutput:         return "output";         break;
     case EvqPosition:       return "Position";       break;
     case EvqPointSize:      return "PointSize";      break;
     case EvqFragCoord:      return "FragCoord";      break;
     case EvqFrontFacing:    return "FrontFacing";    break;
     case EvqFragColor:      return "FragColor";      break;
     case EvqFragData:       return "FragData";      break;
+    case EvqFragDepth:      return "FragDepth";     break;
     default:                return "unknown qualifier";
     }
 }
index 27a5598..532486a 100644 (file)
 
 #include "compiler/PoolAlloc.h"
 
-// We need two pieces of information to report errors/warnings - string and
-// line number. We encode these into a single int so that it can be easily
-// incremented/decremented by lexer. The right SOURCE_LOC_LINE_SIZE bits store
-// line number while the rest store the string number. Since the shaders are
-// usually small, we should not run out of memory. SOURCE_LOC_LINE_SIZE
-// can be increased to alleviate this issue.
-typedef int TSourceLoc;
-const unsigned int SOURCE_LOC_LINE_SIZE = 16;  // in bits.
-const unsigned int SOURCE_LOC_LINE_MASK = (1 << SOURCE_LOC_LINE_SIZE) - 1;
-
-inline TSourceLoc EncodeSourceLoc(int string, int line) {
-    return (string << SOURCE_LOC_LINE_SIZE) | (line & SOURCE_LOC_LINE_MASK);
-}
-
-inline void DecodeSourceLoc(TSourceLoc loc, int* string, int* line) {
-    if (string) *string = loc >> SOURCE_LOC_LINE_SIZE;
-    if (line) *line = loc & SOURCE_LOC_LINE_MASK;
-}
+struct TSourceLoc {
+    int first_file;
+    int first_line;
+    int last_file;
+    int last_line;
+};
 
 //
 // Put POOL_ALLOCATOR_NEW_DELETE in base classes to make them use this scheme.
index 9c9f9e7..2ac367c 100644 (file)
@@ -4,8 +4,9 @@
 // found in the LICENSE file.
 //
 
+#include "compiler/builtin_symbol_table.h"
 #include "compiler/BuiltInFunctionEmulator.h"
-#include "compiler/DetectRecursion.h"
+#include "compiler/DetectCallDepth.h"
 #include "compiler/ForLoopUnroll.h"
 #include "compiler/Initialize.h"
 #include "compiler/InitializeParseContext.h"
@@ -62,11 +63,26 @@ bool InitializeSymbolTable(
 
         if (PaParseStrings(1, &builtInShaders, &builtInLengths, &parseContext) != 0)
         {
-            infoSink.info.message(EPrefixInternalError, "Unable to parse built-ins");
+            infoSink.info.prefix(EPrefixInternalError);
+            infoSink.info << "Unable to parse built-ins";
             return false;
         }
     }
 
+
+    switch (type) {
+    case SH_FRAGMENT_SHADER:
+        InsertBuiltInFunctionsCommon(resources, &symbolTable);
+        break;
+
+    case SH_VERTEX_SHADER:
+        InsertBuiltInFunctionsCommon(resources, &symbolTable);
+        InsertBuiltInFunctionsVertex(resources, &symbolTable);
+        break;
+
+    default: assert(false && "Language not supported");
+    }
+
     IdentifyBuiltIns(type, spec, resources, symbolTable);
 
     return true;
@@ -103,6 +119,9 @@ TShHandleBase::~TShHandleBase() {
 TCompiler::TCompiler(ShShaderType type, ShShaderSpec spec)
     : shaderType(type),
       shaderSpec(spec),
+      maxUniformVectors(0),
+      maxExpressionComplexity(0),
+      maxCallStackDepth(0),
       fragmentPrecisionHigh(false),
       clampingStrategy(SH_CLAMP_WITH_CLAMP_INTRINSIC),
       builtInFunctionEmulator(type)
@@ -121,11 +140,14 @@ bool TCompiler::Init(const ShBuiltInResources& resources)
     maxUniformVectors = (shaderType == SH_VERTEX_SHADER) ?
         resources.MaxVertexUniformVectors :
         resources.MaxFragmentUniformVectors;
+    maxExpressionComplexity = resources.MaxExpressionComplexity;
+    maxCallStackDepth = resources.MaxCallStackDepth;
     TScopedPoolAllocator scopedAlloc(&allocator, false);
 
     // Generate built-in symbol table.
     if (!InitBuiltInSymbolTable(resources))
         return false;
+
     InitExtensionBehavior(resources, extensionBehavior);
     fragmentPrecisionHigh = resources.FragmentPrecisionHigh == 1;
 
@@ -170,8 +192,10 @@ bool TCompiler::compile(const char* const shaderStrings[],
     // We preserve symbols at the built-in level from compile-to-compile.
     // Start pushing the user-defined symbols at global level.
     symbolTable.push();
-    if (!symbolTable.atGlobalLevel())
-        infoSink.info.message(EPrefixInternalError, "Wrong symbol table level");
+    if (!symbolTable.atGlobalLevel()) {
+        infoSink.info.prefix(EPrefixInternalError);
+        infoSink.info << "Wrong symbol table level";
+    }
 
     // Parse shader.
     bool success =
@@ -182,7 +206,7 @@ bool TCompiler::compile(const char* const shaderStrings[],
         success = intermediate.postProcess(root);
 
         if (success)
-            success = detectRecursion(root);
+            success = detectCallDepth(root, infoSink, (compileOptions & SH_LIMIT_CALL_STACK_DEPTH) != 0);
 
         if (success && (compileOptions & SH_VALIDATE_LOOP_INDEXING))
             success = validateLimitations(root);
@@ -205,6 +229,10 @@ bool TCompiler::compile(const char* const shaderStrings[],
         if (success && (compileOptions & SH_CLAMP_INDIRECT_ARRAY_BOUNDS))
             arrayBoundsClamper.MarkIndirectArrayBoundsForClamping(root);
 
+        // Disallow expressions deemed too complex.
+        if (success && (compileOptions & SH_LIMIT_EXPRESSION_COMPLEXITY))
+            success = limitExpressionComplexity(root);
+
         // Call mapLongVariableNames() before collectAttribsUniforms() so in
         // collectAttribsUniforms() we already have the mapped symbol names and
         // we could composite mapped and original variable names.
@@ -217,7 +245,8 @@ bool TCompiler::compile(const char* const shaderStrings[],
             if (compileOptions & SH_ENFORCE_PACKING_RESTRICTIONS) {
                 success = enforcePackingRestrictions();
                 if (!success) {
-                    infoSink.info.message(EPrefixError, "too many uniforms");
+                    infoSink.info.prefix(EPrefixError);
+                    infoSink.info << "too many uniforms";
                 }
             }
         }
@@ -263,18 +292,24 @@ void TCompiler::clearResults()
     nameMap.clear();
 }
 
-bool TCompiler::detectRecursion(TIntermNode* root)
+bool TCompiler::detectCallDepth(TIntermNode* root, TInfoSink& infoSink, bool limitCallStackDepth)
 {
-    DetectRecursion detect;
+    DetectCallDepth detect(infoSink, limitCallStackDepth, maxCallStackDepth);
     root->traverse(&detect);
-    switch (detect.detectRecursion()) {
-        case DetectRecursion::kErrorNone:
+    switch (detect.detectCallDepth()) {
+        case DetectCallDepth::kErrorNone:
             return true;
-        case DetectRecursion::kErrorMissingMain:
-            infoSink.info.message(EPrefixError, "Missing main()");
+        case DetectCallDepth::kErrorMissingMain:
+            infoSink.info.prefix(EPrefixError);
+            infoSink.info << "Missing main()";
             return false;
-        case DetectRecursion::kErrorRecursion:
-            infoSink.info.message(EPrefixError, "Function recursion detected");
+        case DetectCallDepth::kErrorRecursion:
+            infoSink.info.prefix(EPrefixError);
+            infoSink.info << "Function recursion detected";
+            return false;
+        case DetectCallDepth::kErrorMaxDepthExceeded:
+            infoSink.info.prefix(EPrefixError);
+            infoSink.info << "Function call stack too deep";
             return false;
         default:
             UNREACHABLE();
@@ -320,6 +355,28 @@ bool TCompiler::enforceTimingRestrictions(TIntermNode* root, bool outputGraph)
     }
 }
 
+bool TCompiler::limitExpressionComplexity(TIntermNode* root)
+{
+    TIntermTraverser traverser;
+    root->traverse(&traverser);
+    TDependencyGraph graph(root);
+
+    for (TFunctionCallVector::const_iterator iter = graph.beginUserDefinedFunctionCalls();
+         iter != graph.endUserDefinedFunctionCalls();
+         ++iter)
+    {
+        TGraphFunctionCall* samplerSymbol = *iter;
+        TDependencyGraphTraverser graphTraverser;
+        samplerSymbol->traverse(&graphTraverser);
+    }
+
+    if (traverser.getMaxDepth() > maxExpressionComplexity) {
+        infoSink.info << "Expression too complex.";
+        return false;
+    }
+    return true;
+}
+
 bool TCompiler::enforceFragmentShaderTimingRestrictions(const TDependencyGraph& graph)
 {
     RestrictFragmentShaderTiming restrictor(infoSink.info);
index fd9d94d..32af4d3 100644 (file)
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -14,6 +14,7 @@ public:
     ConstantUnion()
     {
         iConst = 0;
+        type = EbtVoid;
     }
 
     POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)        
diff --git a/Source/ThirdParty/ANGLE/src/compiler/DetectCallDepth.cpp b/Source/ThirdParty/ANGLE/src/compiler/DetectCallDepth.cpp
new file mode 100644 (file)
index 0000000..60df52c
--- /dev/null
@@ -0,0 +1,185 @@
+//
+// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+#include "compiler/DetectCallDepth.h"
+#include "compiler/InfoSink.h"
+
+DetectCallDepth::FunctionNode::FunctionNode(const TString& fname)
+    : name(fname),
+      visit(PreVisit)
+{
+}
+
+const TString& DetectCallDepth::FunctionNode::getName() const
+{
+    return name;
+}
+
+void DetectCallDepth::FunctionNode::addCallee(
+    DetectCallDepth::FunctionNode* callee)
+{
+    for (size_t i = 0; i < callees.size(); ++i) {
+        if (callees[i] == callee)
+            return;
+    }
+    callees.push_back(callee);
+}
+
+int DetectCallDepth::FunctionNode::detectCallDepth(DetectCallDepth* detectCallDepth, int depth)
+{
+    ASSERT(visit == PreVisit);
+    ASSERT(detectCallDepth);
+
+    int maxDepth = depth;
+    visit = InVisit;
+    for (size_t i = 0; i < callees.size(); ++i) {
+        switch (callees[i]->visit) {
+            case InVisit:
+                // cycle detected, i.e., recursion detected.
+                return kInfiniteCallDepth;
+            case PostVisit:
+                break;
+            case PreVisit: {
+                // Check before we recurse so we don't go too depth
+                if (detectCallDepth->checkExceedsMaxDepth(depth))
+                    return depth;
+                int callDepth = callees[i]->detectCallDepth(detectCallDepth, depth + 1);
+                // Check after we recurse so we can exit immediately and provide info.
+                if (detectCallDepth->checkExceedsMaxDepth(callDepth)) {
+                    detectCallDepth->getInfoSink().info << "<-" << callees[i]->getName();
+                    return callDepth;
+                }
+                maxDepth = std::max(callDepth, maxDepth);
+                break;
+            }
+            default:
+                UNREACHABLE();
+                break;
+        }
+    }
+    visit = PostVisit;
+    return maxDepth;
+}
+
+void DetectCallDepth::FunctionNode::reset()
+{
+    visit = PreVisit;
+}
+
+DetectCallDepth::DetectCallDepth(TInfoSink& infoSink, bool limitCallStackDepth, int maxCallStackDepth)
+    : TIntermTraverser(true, false, true, false),
+      currentFunction(NULL),
+      infoSink(infoSink),
+      maxDepth(limitCallStackDepth ? maxCallStackDepth : FunctionNode::kInfiniteCallDepth)
+{
+}
+
+DetectCallDepth::~DetectCallDepth()
+{
+    for (size_t i = 0; i < functions.size(); ++i)
+        delete functions[i];
+}
+
+bool DetectCallDepth::visitAggregate(Visit visit, TIntermAggregate* node)
+{
+    switch (node->getOp())
+    {
+        case EOpPrototype:
+            // Function declaration.
+            // Don't add FunctionNode here because node->getName() is the
+            // unmangled function name.
+            break;
+        case EOpFunction: {
+            // Function definition.
+            if (visit == PreVisit) {
+                currentFunction = findFunctionByName(node->getName());
+                if (currentFunction == NULL) {
+                    currentFunction = new FunctionNode(node->getName());
+                    functions.push_back(currentFunction);
+                }
+            } else if (visit == PostVisit) {
+                currentFunction = NULL;
+            }
+            break;
+        }
+        case EOpFunctionCall: {
+            // Function call.
+            if (visit == PreVisit) {
+                FunctionNode* func = findFunctionByName(node->getName());
+                if (func == NULL) {
+                    func = new FunctionNode(node->getName());
+                    functions.push_back(func);
+                }
+                if (currentFunction)
+                    currentFunction->addCallee(func);
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return true;
+}
+
+bool DetectCallDepth::checkExceedsMaxDepth(int depth)
+{
+    return depth >= maxDepth;
+}
+
+void DetectCallDepth::resetFunctionNodes()
+{
+    for (size_t i = 0; i < functions.size(); ++i) {
+        functions[i]->reset();
+    }
+}
+
+DetectCallDepth::ErrorCode DetectCallDepth::detectCallDepthForFunction(FunctionNode* func)
+{
+    currentFunction = NULL;
+    resetFunctionNodes();
+
+    int maxCallDepth = func->detectCallDepth(this, 1);
+
+    if (maxCallDepth == FunctionNode::kInfiniteCallDepth)
+        return kErrorRecursion;
+
+    if (maxCallDepth >= maxDepth)
+        return kErrorMaxDepthExceeded;
+
+    return kErrorNone;
+}
+
+DetectCallDepth::ErrorCode DetectCallDepth::detectCallDepth()
+{
+    if (maxDepth != FunctionNode::kInfiniteCallDepth) {
+        // Check all functions because the driver may fail on them
+        // TODO: Before detectingRecursion, strip unused functions.
+        for (size_t i = 0; i < functions.size(); ++i) {
+            ErrorCode error = detectCallDepthForFunction(functions[i]);
+            if (error != kErrorNone)
+                return error;
+        }
+    } else {
+        FunctionNode* main = findFunctionByName("main(");
+        if (main == NULL)
+            return kErrorMissingMain;
+
+        return detectCallDepthForFunction(main);
+    }
+
+    return kErrorNone;
+}
+
+DetectCallDepth::FunctionNode* DetectCallDepth::findFunctionByName(
+    const TString& name)
+{
+    for (size_t i = 0; i < functions.size(); ++i) {
+        if (functions[i]->getName() == name)
+            return functions[i];
+    }
+    return NULL;
+}
+
@@ -9,28 +9,36 @@
 
 #include "GLSLANG/ShaderLang.h"
 
+#include <limits.h>
 #include "compiler/intermediate.h"
 #include "compiler/VariableInfo.h"
 
+class TInfoSink;
+
 // Traverses intermediate tree to detect function recursion.
-class DetectRecursion : public TIntermTraverser {
+class DetectCallDepth : public TIntermTraverser {
 public:
     enum ErrorCode {
         kErrorMissingMain,
         kErrorRecursion,
+        kErrorMaxDepthExceeded,
         kErrorNone
     };
 
-    DetectRecursion();
-    ~DetectRecursion();
+    DetectCallDepth(TInfoSink& infoSync, bool limitCallStackDepth, int maxCallStackDepth);
+    ~DetectCallDepth();
 
     virtual bool visitAggregate(Visit, TIntermAggregate*);
 
-    ErrorCode detectRecursion();
+    bool checkExceedsMaxDepth(int depth);
+
+    ErrorCode detectCallDepth();
 
 private:
     class FunctionNode {
     public:
+        static const int kInfiniteCallDepth = INT_MAX;
+
         FunctionNode(const TString& fname);
 
         const TString& getName() const;
@@ -38,8 +46,11 @@ private:
         // If a function is already in the callee list, this becomes a no-op.
         void addCallee(FunctionNode* callee);
 
-        // Return true if recursive function calls are detected.
-        bool detectRecursion();
+        // Returns kInifinityCallDepth if recursive function calls are detected.
+        int detectCallDepth(DetectCallDepth* detectCallDepth, int depth);
+
+        // Reset state.
+        void reset();
 
     private:
         // mangled function name is unique.
@@ -51,10 +62,19 @@ private:
         Visit visit;
     };
 
+    ErrorCode detectCallDepthForFunction(FunctionNode* func);
     FunctionNode* findFunctionByName(const TString& name);
+    void resetFunctionNodes();
+
+    TInfoSink& getInfoSink() { return infoSink; }
 
     TVector<FunctionNode*> functions;
     FunctionNode* currentFunction;
+    TInfoSink& infoSink;
+    int maxDepth;
+
+    DetectCallDepth(const DetectCallDepth&);
+    void operator=(const DetectCallDepth&);
 };
 
 #endif  // COMPILER_DETECT_RECURSION_H_
diff --git a/Source/ThirdParty/ANGLE/src/compiler/DetectRecursion.cpp b/Source/ThirdParty/ANGLE/src/compiler/DetectRecursion.cpp
deleted file mode 100644 (file)
index c09780d..0000000
+++ /dev/null
@@ -1,125 +0,0 @@
-//
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-#include "compiler/DetectRecursion.h"
-
-DetectRecursion::FunctionNode::FunctionNode(const TString& fname)
-    : name(fname),
-      visit(PreVisit)
-{
-}
-
-const TString& DetectRecursion::FunctionNode::getName() const
-{
-    return name;
-}
-
-void DetectRecursion::FunctionNode::addCallee(
-    DetectRecursion::FunctionNode* callee)
-{
-    for (size_t i = 0; i < callees.size(); ++i) {
-        if (callees[i] == callee)
-            return;
-    }
-    callees.push_back(callee);
-}
-
-bool DetectRecursion::FunctionNode::detectRecursion()
-{
-    ASSERT(visit == PreVisit);
-    visit = InVisit;
-    for (size_t i = 0; i < callees.size(); ++i) {
-        switch (callees[i]->visit) {
-            case InVisit:
-                // cycle detected, i.e., recursion detected.
-                return true;
-            case PostVisit:
-                break;
-            case PreVisit: {
-                bool recursion = callees[i]->detectRecursion();
-                if (recursion)
-                    return true;
-                break;
-            }
-            default:
-                UNREACHABLE();
-                break;
-        }
-    }
-    visit = PostVisit;
-    return false;
-}
-
-DetectRecursion::DetectRecursion()
-    : currentFunction(NULL)
-{
-}
-
-DetectRecursion::~DetectRecursion()
-{
-    for (size_t i = 0; i < functions.size(); ++i)
-        delete functions[i];
-}
-
-bool DetectRecursion::visitAggregate(Visit visit, TIntermAggregate* node)
-{
-    switch (node->getOp())
-    {
-        case EOpPrototype:
-            // Function declaration.
-            // Don't add FunctionNode here because node->getName() is the
-            // unmangled function name.
-            break;
-        case EOpFunction: {
-            // Function definition.
-            if (visit == PreVisit) {
-                currentFunction = findFunctionByName(node->getName());
-                if (currentFunction == NULL) {
-                    currentFunction = new FunctionNode(node->getName());
-                    functions.push_back(currentFunction);
-                }
-            }
-            break;
-        }
-        case EOpFunctionCall: {
-            // Function call.
-            if (visit == PreVisit) {
-                ASSERT(currentFunction != NULL);
-                FunctionNode* func = findFunctionByName(node->getName());
-                if (func == NULL) {
-                    func = new FunctionNode(node->getName());
-                    functions.push_back(func);
-                }
-                currentFunction->addCallee(func);
-            }
-            break;
-        }
-        default:
-            break;
-    }
-    return true;
-}
-
-DetectRecursion::ErrorCode DetectRecursion::detectRecursion()
-{
-    FunctionNode* main = findFunctionByName("main(");
-    if (main == NULL)
-        return kErrorMissingMain;
-    if (main->detectRecursion())
-        return kErrorRecursion;
-    return kErrorNone;
-}
-
-DetectRecursion::FunctionNode* DetectRecursion::findFunctionByName(
-    const TString& name)
-{
-    for (size_t i = 0; i < functions.size(); ++i) {
-        if (functions[i]->getName() == name)
-            return functions[i];
-    }
-    return NULL;
-}
-
index 06f370d..8a38c41 100644 (file)
@@ -46,7 +46,7 @@ void TDiagnostics::writeInfo(Severity severity,
     TInfoSinkBase& sink = mInfoSink.info;
     /* VC++ format: file(linenum) : error #: 'token' : extrainfo */
     sink.prefix(prefix);
-    sink.location(EncodeSourceLoc(loc.file, loc.line));
+    sink.location(loc.file, loc.line);
     sink << "'" << token <<  "' : " << reason << " " << extra << "\n";
 }
 
index fdc3f44..27a13ea 100644 (file)
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -210,6 +210,6 @@ int ForLoopUnroll::getLoopIncrement(TIntermLoop* node)
 int ForLoopUnroll::evaluateIntConstant(TIntermConstantUnion* node)
 {
     ASSERT((node != NULL) && (node->getUnionArrayPointer() != NULL));
-    return node->getUnionArrayPointer()->getIConst();
+    return node->getIConst(0);
 }
 
index ba32f78..d20a6c0 100644 (file)
@@ -6,8 +6,8 @@
 
 #include "compiler/InfoSink.h"
 
-void TInfoSinkBase::prefix(TPrefixType message) {
-    switch(message) {
+void TInfoSinkBase::prefix(TPrefixType p) {
+    switch(p) {
         case EPrefixNone:
             break;
         case EPrefixWarning:
@@ -31,29 +31,24 @@ void TInfoSinkBase::prefix(TPrefixType message) {
     }
 }
 
-void TInfoSinkBase::location(TSourceLoc loc) {
-    int string = 0, line = 0;
-    DecodeSourceLoc(loc, &string, &line);
-
+void TInfoSinkBase::location(int file, int line) {
     TPersistStringStream stream;
     if (line)
-        stream << string << ":" << line;
+        stream << file << ":" << line;
     else
-        stream << string << ":? ";
+        stream << file << ":? ";
     stream << ": ";
 
     sink.append(stream.str());
 }
 
-void TInfoSinkBase::message(TPrefixType message, const char* s) {
-    prefix(message);
-    sink.append(s);
-    sink.append("\n");
+void TInfoSinkBase::location(const TSourceLoc& loc) {
+    location(loc.first_file, loc.first_line);
 }
 
-void TInfoSinkBase::message(TPrefixType message, const char* s, TSourceLoc loc) {
-    prefix(message);
+void TInfoSinkBase::message(TPrefixType p, const TSourceLoc& loc, const char* m) {
+    prefix(p);
     location(loc);
-    sink.append(s);
+    sink.append(m);
     sink.append("\n");
 }
index e2224e9..6888838 100644 (file)
@@ -96,10 +96,10 @@ public:
     const TPersistString& str() const { return sink; }
     const char* c_str() const { return sink.c_str(); }
 
-    void prefix(TPrefixType message);
-    void location(TSourceLoc loc);
-    void message(TPrefixType message, const char* s);
-    void message(TPrefixType message, const char* s, TSourceLoc loc);
+    void prefix(TPrefixType p);
+    void location(int file, int line);
+    void location(const TSourceLoc& loc);
+    void message(TPrefixType p, const TSourceLoc& loc, const char* m);
 
 private:
     TPersistString sink;
index 97b46f8..33229a2 100644 (file)
 
 //============================================================================
 //
-// Prototypes for built-in functions seen by both vertex and fragment shaders.
-//
-//============================================================================
-static TString BuiltInFunctionsCommon(const ShBuiltInResources& resources)
-{
-    TString s;
-
-    //
-    // Angle and Trigonometric Functions.
-    //
-    s.append(TString("float radians(float degrees);"));
-    s.append(TString("vec2  radians(vec2  degrees);"));
-    s.append(TString("vec3  radians(vec3  degrees);"));
-    s.append(TString("vec4  radians(vec4  degrees);"));
-
-    s.append(TString("float degrees(float radians);"));
-    s.append(TString("vec2  degrees(vec2  radians);"));
-    s.append(TString("vec3  degrees(vec3  radians);"));
-    s.append(TString("vec4  degrees(vec4  radians);"));
-
-    s.append(TString("float sin(float angle);"));
-    s.append(TString("vec2  sin(vec2  angle);"));
-    s.append(TString("vec3  sin(vec3  angle);"));
-    s.append(TString("vec4  sin(vec4  angle);"));
-
-    s.append(TString("float cos(float angle);"));
-    s.append(TString("vec2  cos(vec2  angle);"));
-    s.append(TString("vec3  cos(vec3  angle);"));
-    s.append(TString("vec4  cos(vec4  angle);"));
-
-    s.append(TString("float tan(float angle);"));
-    s.append(TString("vec2  tan(vec2  angle);"));
-    s.append(TString("vec3  tan(vec3  angle);"));
-    s.append(TString("vec4  tan(vec4  angle);"));
-
-    s.append(TString("float asin(float x);"));
-    s.append(TString("vec2  asin(vec2  x);"));
-    s.append(TString("vec3  asin(vec3  x);"));
-    s.append(TString("vec4  asin(vec4  x);"));
-
-    s.append(TString("float acos(float x);"));
-    s.append(TString("vec2  acos(vec2  x);"));
-    s.append(TString("vec3  acos(vec3  x);"));
-    s.append(TString("vec4  acos(vec4  x);"));
-
-    s.append(TString("float atan(float y, float x);"));
-    s.append(TString("vec2  atan(vec2  y, vec2  x);"));
-    s.append(TString("vec3  atan(vec3  y, vec3  x);"));
-    s.append(TString("vec4  atan(vec4  y, vec4  x);"));
-
-    s.append(TString("float atan(float y_over_x);"));
-    s.append(TString("vec2  atan(vec2  y_over_x);"));
-    s.append(TString("vec3  atan(vec3  y_over_x);"));
-    s.append(TString("vec4  atan(vec4  y_over_x);"));
-
-    //
-    // Exponential Functions.
-    //
-    s.append(TString("float pow(float x, float y);"));
-    s.append(TString("vec2  pow(vec2  x, vec2  y);"));
-    s.append(TString("vec3  pow(vec3  x, vec3  y);"));
-    s.append(TString("vec4  pow(vec4  x, vec4  y);"));
-
-    s.append(TString("float exp(float x);"));
-    s.append(TString("vec2  exp(vec2  x);"));
-    s.append(TString("vec3  exp(vec3  x);"));
-    s.append(TString("vec4  exp(vec4  x);"));
-
-    s.append(TString("float log(float x);"));
-    s.append(TString("vec2  log(vec2  x);"));
-    s.append(TString("vec3  log(vec3  x);"));
-    s.append(TString("vec4  log(vec4  x);"));
-
-    s.append(TString("float exp2(float x);"));
-    s.append(TString("vec2  exp2(vec2  x);"));
-    s.append(TString("vec3  exp2(vec3  x);"));
-    s.append(TString("vec4  exp2(vec4  x);"));
-
-    s.append(TString("float log2(float x);"));
-    s.append(TString("vec2  log2(vec2  x);"));
-    s.append(TString("vec3  log2(vec3  x);"));
-    s.append(TString("vec4  log2(vec4  x);"));
-
-    s.append(TString("float sqrt(float x);"));
-    s.append(TString("vec2  sqrt(vec2  x);"));
-    s.append(TString("vec3  sqrt(vec3  x);"));
-    s.append(TString("vec4  sqrt(vec4  x);"));
-
-    s.append(TString("float inversesqrt(float x);"));
-    s.append(TString("vec2  inversesqrt(vec2  x);"));
-    s.append(TString("vec3  inversesqrt(vec3  x);"));
-    s.append(TString("vec4  inversesqrt(vec4  x);"));
-
-    //
-    // Common Functions.
-    //
-    s.append(TString("float abs(float x);"));
-    s.append(TString("vec2  abs(vec2  x);"));
-    s.append(TString("vec3  abs(vec3  x);"));
-    s.append(TString("vec4  abs(vec4  x);"));
-
-    s.append(TString("float sign(float x);"));
-    s.append(TString("vec2  sign(vec2  x);"));
-    s.append(TString("vec3  sign(vec3  x);"));
-    s.append(TString("vec4  sign(vec4  x);"));
-
-    s.append(TString("float floor(float x);"));
-    s.append(TString("vec2  floor(vec2  x);"));
-    s.append(TString("vec3  floor(vec3  x);"));
-    s.append(TString("vec4  floor(vec4  x);"));
-
-    s.append(TString("float ceil(float x);"));
-    s.append(TString("vec2  ceil(vec2  x);"));
-    s.append(TString("vec3  ceil(vec3  x);"));
-    s.append(TString("vec4  ceil(vec4  x);"));
-
-    s.append(TString("float fract(float x);"));
-    s.append(TString("vec2  fract(vec2  x);"));
-    s.append(TString("vec3  fract(vec3  x);"));
-    s.append(TString("vec4  fract(vec4  x);"));
-
-    s.append(TString("float mod(float x, float y);"));
-    s.append(TString("vec2  mod(vec2  x, float y);"));
-    s.append(TString("vec3  mod(vec3  x, float y);"));
-    s.append(TString("vec4  mod(vec4  x, float y);"));
-    s.append(TString("vec2  mod(vec2  x, vec2  y);"));
-    s.append(TString("vec3  mod(vec3  x, vec3  y);"));
-    s.append(TString("vec4  mod(vec4  x, vec4  y);"));
-
-    s.append(TString("float min(float x, float y);"));
-    s.append(TString("vec2  min(vec2  x, float y);"));
-    s.append(TString("vec3  min(vec3  x, float y);"));
-    s.append(TString("vec4  min(vec4  x, float y);"));
-    s.append(TString("vec2  min(vec2  x, vec2  y);"));
-    s.append(TString("vec3  min(vec3  x, vec3  y);"));
-    s.append(TString("vec4  min(vec4  x, vec4  y);"));
-
-    s.append(TString("float max(float x, float y);"));
-    s.append(TString("vec2  max(vec2  x, float y);"));
-    s.append(TString("vec3  max(vec3  x, float y);"));
-    s.append(TString("vec4  max(vec4  x, float y);"));
-    s.append(TString("vec2  max(vec2  x, vec2  y);"));
-    s.append(TString("vec3  max(vec3  x, vec3  y);"));
-    s.append(TString("vec4  max(vec4  x, vec4  y);"));
-
-    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("vec3  clamp(vec3  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("vec3  clamp(vec3  x, vec3  minVal, vec3  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("vec2  mix(vec2  x, vec2  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("vec2  mix(vec2  x, vec2  y, vec2  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("float step(float edge, float x);"));
-    s.append(TString("vec2  step(vec2  edge, vec2  x);"));
-    s.append(TString("vec3  step(vec3  edge, vec3  x);"));
-    s.append(TString("vec4  step(vec4  edge, vec4  x);"));
-    s.append(TString("vec2  step(float edge, vec2  x);"));
-    s.append(TString("vec3  step(float edge, vec3  x);"));
-    s.append(TString("vec4  step(float edge, vec4  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("vec3  smoothstep(vec3  edge0, vec3  edge1, vec3  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("vec3  smoothstep(float edge0, float edge1, vec3  x);"));
-    s.append(TString("vec4  smoothstep(float edge0, float edge1, vec4  x);"));
-
-    //
-    // Geometric Functions.
-    //
-    s.append(TString("float length(float x);"));
-    s.append(TString("float length(vec2  x);"));
-    s.append(TString("float length(vec3  x);"));
-    s.append(TString("float length(vec4  x);"));
-
-    s.append(TString("float distance(float p0, float p1);"));
-    s.append(TString("float distance(vec2  p0, vec2  p1);"));
-    s.append(TString("float distance(vec3  p0, vec3  p1);"));
-    s.append(TString("float distance(vec4  p0, vec4  p1);"));
-
-    s.append(TString("float dot(float x, float y);"));
-    s.append(TString("float dot(vec2  x, vec2  y);"));
-    s.append(TString("float dot(vec3  x, vec3  y);"));
-    s.append(TString("float dot(vec4  x, vec4  y);"));
-
-    s.append(TString("vec3 cross(vec3 x, vec3 y);"));
-    s.append(TString("float normalize(float x);"));
-    s.append(TString("vec2  normalize(vec2  x);"));
-    s.append(TString("vec3  normalize(vec3  x);"));
-    s.append(TString("vec4  normalize(vec4  x);"));
-
-    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("vec3  faceforward(vec3  N, vec3  I, vec3  Nref);"));
-    s.append(TString("vec4  faceforward(vec4  N, vec4  I, vec4  Nref);"));
-
-    s.append(TString("float reflect(float I, float N);"));
-    s.append(TString("vec2  reflect(vec2  I, vec2  N);"));
-    s.append(TString("vec3  reflect(vec3  I, vec3  N);"));
-    s.append(TString("vec4  reflect(vec4  I, vec4  N);"));
-
-    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("vec3  refract(vec3  I, vec3  N, float eta);"));
-    s.append(TString("vec4  refract(vec4  I, vec4  N, float eta);"));
-
-    //
-    // Matrix Functions.
-    //
-    s.append(TString("mat2 matrixCompMult(mat2 x, mat2 y);"));
-    s.append(TString("mat3 matrixCompMult(mat3 x, mat3 y);"));
-    s.append(TString("mat4 matrixCompMult(mat4 x, mat4 y);"));
-
-    //
-    // Vector relational functions.
-    //
-    s.append(TString("bvec2 lessThan(vec2 x, vec2 y);"));
-    s.append(TString("bvec3 lessThan(vec3 x, vec3 y);"));
-    s.append(TString("bvec4 lessThan(vec4 x, vec4 y);"));
-
-    s.append(TString("bvec2 lessThan(ivec2 x, ivec2 y);"));
-    s.append(TString("bvec3 lessThan(ivec3 x, ivec3 y);"));
-    s.append(TString("bvec4 lessThan(ivec4 x, ivec4 y);"));
-
-    s.append(TString("bvec2 lessThanEqual(vec2 x, vec2 y);"));
-    s.append(TString("bvec3 lessThanEqual(vec3 x, vec3 y);"));
-    s.append(TString("bvec4 lessThanEqual(vec4 x, vec4 y);"));
-
-    s.append(TString("bvec2 lessThanEqual(ivec2 x, ivec2 y);"));
-    s.append(TString("bvec3 lessThanEqual(ivec3 x, ivec3 y);"));
-    s.append(TString("bvec4 lessThanEqual(ivec4 x, ivec4 y);"));
-
-    s.append(TString("bvec2 greaterThan(vec2 x, vec2 y);"));
-    s.append(TString("bvec3 greaterThan(vec3 x, vec3 y);"));
-    s.append(TString("bvec4 greaterThan(vec4 x, vec4 y);"));
-
-    s.append(TString("bvec2 greaterThan(ivec2 x, ivec2 y);"));
-    s.append(TString("bvec3 greaterThan(ivec3 x, ivec3 y);"));
-    s.append(TString("bvec4 greaterThan(ivec4 x, ivec4 y);"));
-
-    s.append(TString("bvec2 greaterThanEqual(vec2 x, vec2 y);"));
-    s.append(TString("bvec3 greaterThanEqual(vec3 x, vec3 y);"));
-    s.append(TString("bvec4 greaterThanEqual(vec4 x, vec4 y);"));
-
-    s.append(TString("bvec2 greaterThanEqual(ivec2 x, ivec2 y);"));
-    s.append(TString("bvec3 greaterThanEqual(ivec3 x, ivec3 y);"));
-    s.append(TString("bvec4 greaterThanEqual(ivec4 x, ivec4 y);"));
-
-    s.append(TString("bvec2 equal(vec2 x, vec2 y);"));
-    s.append(TString("bvec3 equal(vec3 x, vec3 y);"));
-    s.append(TString("bvec4 equal(vec4 x, vec4 y);"));
-
-    s.append(TString("bvec2 equal(ivec2 x, ivec2 y);"));
-    s.append(TString("bvec3 equal(ivec3 x, ivec3 y);"));
-    s.append(TString("bvec4 equal(ivec4 x, ivec4 y);"));
-
-    s.append(TString("bvec2 equal(bvec2 x, bvec2 y);"));
-    s.append(TString("bvec3 equal(bvec3 x, bvec3 y);"));
-    s.append(TString("bvec4 equal(bvec4 x, bvec4 y);"));
-
-    s.append(TString("bvec2 notEqual(vec2 x, vec2 y);"));
-    s.append(TString("bvec3 notEqual(vec3 x, vec3 y);"));
-    s.append(TString("bvec4 notEqual(vec4 x, vec4 y);"));
-
-    s.append(TString("bvec2 notEqual(ivec2 x, ivec2 y);"));
-    s.append(TString("bvec3 notEqual(ivec3 x, ivec3 y);"));
-    s.append(TString("bvec4 notEqual(ivec4 x, ivec4 y);"));
-
-    s.append(TString("bvec2 notEqual(bvec2 x, bvec2 y);"));
-    s.append(TString("bvec3 notEqual(bvec3 x, bvec3 y);"));
-    s.append(TString("bvec4 notEqual(bvec4 x, bvec4 y);"));
-
-    s.append(TString("bool any(bvec2 x);"));
-    s.append(TString("bool any(bvec3 x);"));
-    s.append(TString("bool any(bvec4 x);"));
-
-    s.append(TString("bool all(bvec2 x);"));
-    s.append(TString("bool all(bvec3 x);"));
-    s.append(TString("bool all(bvec4 x);"));
-
-    s.append(TString("bvec2 not(bvec2 x);"));
-    s.append(TString("bvec3 not(bvec3 x);"));
-    s.append(TString("bvec4 not(bvec4 x);"));
-
-    //
-    // Texture Functions.
-    //
-    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, vec4 coord);"));
-    s.append(TString("vec4 textureCube(samplerCube sampler, vec3 coord);"));
-
-    if (resources.OES_EGL_image_external) {
-        s.append(TString("vec4 texture2D(samplerExternalOES sampler, vec2 coord);"));
-        s.append(TString("vec4 texture2DProj(samplerExternalOES sampler, vec3 coord);"));
-        s.append(TString("vec4 texture2DProj(samplerExternalOES sampler, vec4 coord);"));
-    }
-
-    if (resources.ARB_texture_rectangle) {
-        s.append(TString("vec4 texture2DRect(sampler2DRect sampler, vec2 coord);"));
-        s.append(TString("vec4 texture2DRectProj(sampler2DRect sampler, vec3 coord);"));
-        s.append(TString("vec4 texture2DRectProj(sampler2DRect sampler, vec4 coord);"));
-    }
-
-    //
-    // Noise functions.
-    //
-    //s.append(TString("float noise1(float x);"));
-    //s.append(TString("float noise1(vec2  x);"));
-    //s.append(TString("float noise1(vec3  x);"));
-    //s.append(TString("float noise1(vec4  x);"));
-
-    //s.append(TString("vec2 noise2(float x);"));
-    //s.append(TString("vec2 noise2(vec2  x);"));
-    //s.append(TString("vec2 noise2(vec3  x);"));
-    //s.append(TString("vec2 noise2(vec4  x);"));
-
-    //s.append(TString("vec3 noise3(float x);"));
-    //s.append(TString("vec3 noise3(vec2  x);"));
-    //s.append(TString("vec3 noise3(vec3  x);"));
-    //s.append(TString("vec3 noise3(vec4  x);"));
-
-    //s.append(TString("vec4 noise4(float x);"));
-    //s.append(TString("vec4 noise4(vec2  x);"));
-    //s.append(TString("vec4 noise4(vec3  x);"));
-    //s.append(TString("vec4 noise4(vec4  x);"));
-
-    return s;
-}
-
-//============================================================================
-//
-// Prototypes for built-in functions seen by vertex shaders only.
-//
-//============================================================================
-static TString BuiltInFunctionsVertex(const ShBuiltInResources& resources)
-{
-    TString s;
-
-    //
-    // Geometric Functions.
-    //
-    //s.append(TString("vec4 ftransform();"));
-
-    //
-    // Texture Functions.
-    //
-    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, vec4 coord, float lod);"));
-    s.append(TString("vec4 textureCubeLod(samplerCube sampler, vec3 coord, float lod);"));
-
-    return s;
-}
-
-//============================================================================
-//
 // Prototypes for built-in functions seen by fragment shaders only.
 //
 //============================================================================
@@ -500,15 +133,12 @@ void TBuiltIns::initialize(ShShaderType type, ShShaderSpec spec,
     switch (type) {
     case SH_FRAGMENT_SHADER:
         builtInStrings.push_back(DefaultPrecisionFragment());
-        builtInStrings.push_back(BuiltInFunctionsCommon(resources));
         builtInStrings.push_back(BuiltInFunctionsFragment(resources));
         builtInStrings.push_back(StandardUniforms());
         break;
 
     case SH_VERTEX_SHADER:
         builtInStrings.push_back(DefaultPrecisionVertex());
-        builtInStrings.push_back(BuiltInFunctionsCommon(resources));
-        builtInStrings.push_back(BuiltInFunctionsVertex(resources));
         builtInStrings.push_back(StandardUniforms());
         break;
 
@@ -539,6 +169,10 @@ void IdentifyBuiltIns(ShShaderType type, ShShaderSpec spec,
         if (spec != SH_CSS_SHADERS_SPEC) {
             symbolTable.insert(*new TVariable(NewPoolTString("gl_FragColor"),                   TType(EbtFloat, EbpMedium, EvqFragColor,   4)));
             symbolTable.insert(*new TVariable(NewPoolTString("gl_FragData[gl_MaxDrawBuffers]"), TType(EbtFloat, EbpMedium, EvqFragData,    4)));
+            if (resources.EXT_frag_depth) {
+                symbolTable.insert(*new TVariable(NewPoolTString("gl_FragDepthEXT"),            TType(EbtFloat, resources.FragmentPrecisionHigh ? EbpHigh : EbpMedium, EvqFragDepth, 1)));
+                symbolTable.relateToExtension("gl_FragDepthEXT", "GL_EXT_frag_depth");
+            }
         } else {
             symbolTable.insert(*new TVariable(NewPoolTString("css_MixColor"),                   TType(EbtFloat, EbpMedium, EvqGlobal,      4)));
             symbolTable.insert(*new TVariable(NewPoolTString("css_ColorMatrix"),                TType(EbtFloat, EbpMedium, EvqGlobal,      4, true)));
@@ -656,4 +290,6 @@ void InitExtensionBehavior(const ShBuiltInResources& resources,
         extBehavior["GL_ARB_texture_rectangle"] = EBhUndefined;
     if (resources.EXT_draw_buffers)
         extBehavior["GL_EXT_draw_buffers"] = EBhUndefined;
+    if (resources.EXT_frag_depth)
+        extBehavior["GL_EXT_frag_depth"] = EBhUndefined;
 }
index c0b08c1..334f0d7 100644 (file)
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -131,7 +131,7 @@ const char* getOperatorString(TOperator op) {
 //
 // Returns the added node.
 //
-TIntermSymbol* TIntermediate::addSymbol(int id, const TString& name, const TType& type, TSourceLoc line)
+TIntermSymbol* TIntermediate::addSymbol(int id, const TString& name, const TType& type, const TSourceLoc& line)
 {
     TIntermSymbol* node = new TIntermSymbol(id, name, type);
     node->setLine(line);
@@ -144,7 +144,7 @@ TIntermSymbol* TIntermediate::addSymbol(int id, const TString& name, const TType
 //
 // Returns the added node.
 //
-TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc line, TSymbolTable& symbolTable)
+TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIntermTyped* right, const TSourceLoc& line, TSymbolTable& symbolTable)
 {
     switch (op) {
         case EOpEqual:
@@ -200,8 +200,6 @@ TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIn
     // one and promote it to the right type.
     //
     TIntermBinary* node = new TIntermBinary(op);
-    if (line == 0)
-        line = right->getLine();
     node->setLine(line);
 
     node->setLeft(left);
@@ -230,15 +228,13 @@ TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIn
 //
 // Returns the added node.
 //
-TIntermTyped* TIntermediate::addAssign(TOperator op, TIntermTyped* left, TIntermTyped* right, TSourceLoc line)
+TIntermTyped* TIntermediate::addAssign(TOperator op, TIntermTyped* left, TIntermTyped* right, const TSourceLoc& line)
 {
     //
     // Like adding binary math, except the conversion can only go
     // from right to left.
     //
     TIntermBinary* node = new TIntermBinary(op);
-    if (line == 0)
-        line = left->getLine();
     node->setLine(line);
 
     TIntermTyped* child = addConversion(op, left->getType(), right);
@@ -260,11 +256,9 @@ TIntermTyped* TIntermediate::addAssign(TOperator op, TIntermTyped* left, TInterm
 // Returns the added node.
 // The caller should set the type of the returned node.
 //
-TIntermTyped* TIntermediate::addIndex(TOperator op, TIntermTyped* base, TIntermTyped* index, TSourceLoc line)
+TIntermTyped* TIntermediate::addIndex(TOperator op, TIntermTyped* base, TIntermTyped* index, const TSourceLoc& line)
 {
     TIntermBinary* node = new TIntermBinary(op);
-    if (line == 0)
-        line = index->getLine();
     node->setLine(line);
     node->setLeft(base);
     node->setRight(index);
@@ -279,13 +273,13 @@ TIntermTyped* TIntermediate::addIndex(TOperator op, TIntermTyped* base, TIntermT
 //
 // Returns the added node.
 //
-TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode, TSourceLoc line, TSymbolTable& symbolTable)
+TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode, const TSourceLoc& line, TSymbolTable& symbolTable)
 {
     TIntermUnary* node;
     TIntermTyped* child = childNode->getAsTyped();
 
     if (child == 0) {
-        infoSink.info.message(EPrefixInternalError, "Bad type in AddUnaryMath", line);
+        infoSink.info.message(EPrefixInternalError, line, "Bad type in AddUnaryMath");
         return 0;
     }
 
@@ -348,8 +342,6 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode,
     // Make a new node for the operator.
     //
     node = new TIntermUnary(op);
-    if (line == 0)
-        line = child->getLine();
     node->setLine(line);
     node->setOperand(child);
 
@@ -376,7 +368,7 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermNode* childNode,
 // Returns an aggregate node, which could be the one passed in if
 // it was already an aggregate but no operator was set.
 //
-TIntermAggregate* TIntermediate::setAggregateOperator(TIntermNode* node, TOperator op, TSourceLoc line)
+TIntermAggregate* TIntermediate::setAggregateOperator(TIntermNode* node, TOperator op, const TSourceLoc& line)
 {
     TIntermAggregate* aggNode;
 
@@ -391,8 +383,6 @@ TIntermAggregate* TIntermediate::setAggregateOperator(TIntermNode* node, TOperat
             //
             aggNode = new TIntermAggregate();
             aggNode->getSequence().push_back(node);
-            if (line == 0)
-                line = node->getLine();
         }
     } else
         aggNode = new TIntermAggregate();
@@ -401,8 +391,7 @@ TIntermAggregate* TIntermediate::setAggregateOperator(TIntermNode* node, TOperat
     // Set the operator.
     //
     aggNode->setOp(op);
-    if (line != 0)
-        aggNode->setLine(line);
+    aggNode->setLine(line);
 
     return aggNode;
 }
@@ -491,7 +480,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
                     case EbtInt:   newOp = EOpConvIntToFloat;  break;
                     case EbtBool:  newOp = EOpConvBoolToFloat; break;
                     default:
-                        infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
+                        infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion node");
                         return 0;
                 }
                 break;
@@ -500,7 +489,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
                     case EbtInt:   newOp = EOpConvIntToBool;   break;
                     case EbtFloat: newOp = EOpConvFloatToBool; break;
                     default:
-                        infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
+                        infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion node");
                         return 0;
                 }
                 break;
@@ -509,12 +498,12 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
                     case EbtBool:   newOp = EOpConvBoolToInt;  break;
                     case EbtFloat:  newOp = EOpConvFloatToInt; break;
                     default:
-                        infoSink.info.message(EPrefixInternalError, "Bad promotion node", node->getLine());
+                        infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion node");
                         return 0;
                 }
                 break;
             default:
-                infoSink.info.message(EPrefixInternalError, "Bad promotion type", node->getLine());
+                infoSink.info.message(EPrefixInternalError, node->getLine(), "Bad promotion type");
                 return 0;
         }
 
@@ -534,7 +523,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
 // Returns the resulting aggregate, unless 0 was passed in for
 // both existing nodes.
 //
-TIntermAggregate* TIntermediate::growAggregate(TIntermNode* left, TIntermNode* right, TSourceLoc line)
+TIntermAggregate* TIntermediate::growAggregate(TIntermNode* left, TIntermNode* right, const TSourceLoc& line)
 {
     if (left == 0 && right == 0)
         return 0;
@@ -551,8 +540,7 @@ TIntermAggregate* TIntermediate::growAggregate(TIntermNode* left, TIntermNode* r
     if (right)
         aggNode->getSequence().push_back(right);
 
-    if (line != 0)
-        aggNode->setLine(line);
+    aggNode->setLine(line);
 
     return aggNode;
 }
@@ -562,18 +550,14 @@ TIntermAggregate* TIntermediate::growAggregate(TIntermNode* left, TIntermNode* r
 //
 // Returns an aggregate, unless 0 was passed in for the existing node.
 //
-TIntermAggregate* TIntermediate::makeAggregate(TIntermNode* node, TSourceLoc line)
+TIntermAggregate* TIntermediate::makeAggregate(TIntermNode* node, const TSourceLoc& line)
 {
     if (node == 0)
         return 0;
 
     TIntermAggregate* aggNode = new TIntermAggregate;
     aggNode->getSequence().push_back(node);
-
-    if (line != 0)
-        aggNode->setLine(line);
-    else
-        aggNode->setLine(node->getLine());
+    aggNode->setLine(line);
 
     return aggNode;
 }
@@ -585,7 +569,7 @@ TIntermAggregate* TIntermediate::makeAggregate(TIntermNode* node, TSourceLoc lin
 //
 // Returns the selection node created.
 //
-TIntermNode* TIntermediate::addSelection(TIntermTyped* cond, TIntermNodePair nodePair, TSourceLoc line)
+TIntermNode* TIntermediate::addSelection(TIntermTyped* cond, TIntermNodePair nodePair, const TSourceLoc& line)
 {
     //
     // For compile time constant selections, prune the code and
@@ -593,7 +577,7 @@ TIntermNode* TIntermediate::addSelection(TIntermTyped* cond, TIntermNodePair nod
     //
 
     if (cond->getAsTyped() && cond->getAsTyped()->getAsConstantUnion()) {
-        if (cond->getAsTyped()->getAsConstantUnion()->getUnionArrayPointer()->getBConst() == true)
+        if (cond->getAsConstantUnion()->getBConst(0) == true)
             return nodePair.node1 ? setAggregateOperator(nodePair.node1, EOpSequence, nodePair.node1->getLine()) : NULL;
         else
             return nodePair.node2 ? setAggregateOperator(nodePair.node2, EOpSequence, nodePair.node2->getLine()) : NULL;
@@ -606,7 +590,7 @@ TIntermNode* TIntermediate::addSelection(TIntermTyped* cond, TIntermNodePair nod
 }
 
 
-TIntermTyped* TIntermediate::addComma(TIntermTyped* left, TIntermTyped* right, TSourceLoc line)
+TIntermTyped* TIntermediate::addComma(TIntermTyped* left, TIntermTyped* right, const TSourceLoc& line)
 {
     if (left->getType().getQualifier() == EvqConst && right->getType().getQualifier() == EvqConst) {
         return right;
@@ -626,7 +610,7 @@ TIntermTyped* TIntermediate::addComma(TIntermTyped* left, TIntermTyped* right, T
 //
 // Returns the selection node created, or 0 if one could not be.
 //
-TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, TSourceLoc line)
+TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, const TSourceLoc& line)
 {
     //
     // Get compatible types.
@@ -647,7 +631,7 @@ TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* true
     //
 
     if (cond->getAsConstantUnion() && trueBlock->getAsConstantUnion() && falseBlock->getAsConstantUnion()) {
-        if (cond->getAsConstantUnion()->getUnionArrayPointer()->getBConst())
+        if (cond->getAsConstantUnion()->getBConst(0))
             return trueBlock;
         else
             return falseBlock;
@@ -669,7 +653,7 @@ TIntermTyped* TIntermediate::addSelection(TIntermTyped* cond, TIntermTyped* true
 // Returns the constant union node created.
 //
 
-TIntermConstantUnion* TIntermediate::addConstantUnion(ConstantUnion* unionArrayPointer, const TType& t, TSourceLoc line)
+TIntermConstantUnion* TIntermediate::addConstantUnion(ConstantUnion* unionArrayPointer, const TType& t, const TSourceLoc& line)
 {
     TIntermConstantUnion* node = new TIntermConstantUnion(unionArrayPointer, t);
     node->setLine(line);
@@ -677,7 +661,7 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(ConstantUnion* unionArrayP
     return node;
 }
 
-TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, TSourceLoc line)
+TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, const TSourceLoc& line)
 {
 
     TIntermAggregate* node = new TIntermAggregate(EOpSequence);
@@ -700,7 +684,7 @@ TIntermTyped* TIntermediate::addSwizzle(TVectorFields& fields, TSourceLoc line)
 //
 // Create loop nodes.
 //
-TIntermNode* TIntermediate::addLoop(TLoopType type, TIntermNode* init, TIntermTyped* cond, TIntermTyped* expr, TIntermNode* body, TSourceLoc line)
+TIntermNode* TIntermediate::addLoop(TLoopType type, TIntermNode* init, TIntermTyped* cond, TIntermTyped* expr, TIntermNode* body, const TSourceLoc& line)
 {
     TIntermNode* node = new TIntermLoop(type, init, cond, expr, body);
     node->setLine(line);
@@ -711,12 +695,12 @@ TIntermNode* TIntermediate::addLoop(TLoopType type, TIntermNode* init, TIntermTy
 //
 // Add branches.
 //
-TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TSourceLoc line)
+TIntermBranch* TIntermediate::addBranch(TOperator branchOp, const TSourceLoc& line)
 {
     return addBranch(branchOp, 0, line);
 }
 
-TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TIntermTyped* expression, TSourceLoc line)
+TIntermBranch* TIntermediate::addBranch(TOperator branchOp, TIntermTyped* expression, const TSourceLoc& line)
 {
     TIntermBranch* node = new TIntermBranch(branchOp, expression);
     node->setLine(line);
@@ -846,6 +830,7 @@ bool TIntermUnary::promote(TInfoSink&)
     }
 
     setType(operand->getType());
+    type.setQualifier(EvqTemporary);
 
     return true;
 }
@@ -860,7 +845,7 @@ bool TIntermBinary::promote(TInfoSink& infoSink)
 {
     // This function only handles scalars, vectors, and matrices.
     if (left->isArray() || right->isArray()) {
-        infoSink.info.message(EPrefixInternalError, "Invalid operation for arrays", getLine());
+        infoSink.info.message(EPrefixInternalError, getLine(), "Invalid operation for arrays");
         return false;
     }
 
@@ -965,7 +950,7 @@ bool TIntermBinary::promote(TInfoSink& infoSink)
                     setType(TType(basicType, higherPrecision, EvqTemporary, size, false));
                 }
             } else {
-                infoSink.info.message(EPrefixInternalError, "Missing elses", getLine());
+                infoSink.info.message(EPrefixInternalError, getLine(), "Missing elses");
                 return false;
             }
             break;
@@ -994,7 +979,7 @@ bool TIntermBinary::promote(TInfoSink& infoSink)
                     setType(TType(basicType, higherPrecision, EvqTemporary, size, false));
                 }
             } else {
-                infoSink.info.message(EPrefixInternalError, "Missing elses", getLine());
+                infoSink.info.message(EPrefixInternalError, getLine(), "Missing elses");
                 return false;
             }
             break;
@@ -1034,23 +1019,22 @@ bool TIntermBinary::promote(TInfoSink& infoSink)
 
 bool CompareStruct(const TType& leftNodeType, ConstantUnion* rightUnionArray, ConstantUnion* leftUnionArray)
 {
-    const TTypeList* fields = leftNodeType.getStruct();
+    const TFieldList& fields = leftNodeType.getStruct()->fields();
 
-    size_t structSize = fields->size();
-    int index = 0;
+    size_t structSize = fields.size();
+    size_t index = 0;
 
     for (size_t j = 0; j < structSize; j++) {
-        int size = (*fields)[j].type->getObjectSize();
-        for (int i = 0; i < size; i++) {
-            if ((*fields)[j].type->getBasicType() == EbtStruct) {
-                if (!CompareStructure(*(*fields)[j].type, &rightUnionArray[index], &leftUnionArray[index]))
+        size_t size = fields[j]->type()->getObjectSize();
+        for (size_t i = 0; i < size; i++) {
+            if (fields[j]->type()->getBasicType() == EbtStruct) {
+                if (!CompareStructure(*(fields[j]->type()), &rightUnionArray[index], &leftUnionArray[index]))
                     return false;
             } else {
                 if (leftUnionArray[index] != rightUnionArray[index])
                     return false;
                 index++;
             }
-
         }
     }
     return true;
@@ -1062,10 +1046,10 @@ bool CompareStructure(const TType& leftNodeType, ConstantUnion* rightUnionArray,
         TType typeWithoutArrayness = leftNodeType;
         typeWithoutArrayness.clearArrayness();
 
-        int arraySize = leftNodeType.getArraySize();
+        size_t arraySize = leftNodeType.getArraySize();
 
-        for (int i = 0; i < arraySize; ++i) {
-            int offset = typeWithoutArrayness.getObjectSize() * i;
+        for (size_t i = 0; i < arraySize; ++i) {
+            size_t offset = typeWithoutArrayness.getObjectSize() * i;
             if (!CompareStruct(typeWithoutArrayness, &rightUnionArray[offset], &leftUnionArray[offset]))
                 return false;
         }
@@ -1085,7 +1069,7 @@ bool CompareStructure(const TType& leftNodeType, ConstantUnion* rightUnionArray,
 TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNode, TInfoSink& infoSink)
 {
     ConstantUnion *unionArray = getUnionArrayPointer();
-    int objectSize = getType().getObjectSize();
+    size_t objectSize = getType().getObjectSize();
 
     if (constantNode) {  // binary operations
         TIntermConstantUnion *node = constantNode->getAsConstantUnion();
@@ -1095,13 +1079,13 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
         // for a case like float f = 1.2 + vec4(2,3,4,5);
         if (constantNode->getType().getObjectSize() == 1 && objectSize > 1) {
             rightUnionArray = new ConstantUnion[objectSize];
-            for (int i = 0; i < objectSize; ++i)
+            for (size_t i = 0; i < objectSize; ++i)
                 rightUnionArray[i] = *node->getUnionArrayPointer();
             returnType = getType();
         } else if (constantNode->getType().getObjectSize() > 1 && objectSize == 1) {
             // for a case like float f = vec4(2,3,4,5) + 1.2;
             unionArray = new ConstantUnion[constantNode->getType().getObjectSize()];
-            for (int i = 0; i < constantNode->getType().getObjectSize(); ++i)
+            for (size_t i = 0; i < constantNode->getType().getObjectSize(); ++i)
                 unionArray[i] = *getUnionArrayPointer();
             returnType = node->getType();
             objectSize = constantNode->getType().getObjectSize();
@@ -1115,14 +1099,14 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
             case EOpAdd:
                 tempConstArray = new ConstantUnion[objectSize];
                 {// support MSVC++6.0
-                    for (int i = 0; i < objectSize; i++)
+                    for (size_t i = 0; i < objectSize; i++)
                         tempConstArray[i] = unionArray[i] + rightUnionArray[i];
                 }
                 break;
             case EOpSub:
                 tempConstArray = new ConstantUnion[objectSize];
                 {// support MSVC++6.0
-                    for (int i = 0; i < objectSize; i++)
+                    for (size_t i = 0; i < objectSize; i++)
                         tempConstArray[i] = unionArray[i] - rightUnionArray[i];
                 }
                 break;
@@ -1132,13 +1116,13 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
             case EOpMatrixTimesScalar:
                 tempConstArray = new ConstantUnion[objectSize];
                 {// support MSVC++6.0
-                    for (int i = 0; i < objectSize; i++)
+                    for (size_t i = 0; i < objectSize; i++)
                         tempConstArray[i] = unionArray[i] * rightUnionArray[i];
                 }
                 break;
             case EOpMatrixTimesMatrix:
                 if (getType().getBasicType() != EbtFloat || node->getBasicType() != EbtFloat) {
-                    infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for matrix multiply", getLine());
+                    infoSink.info.message(EPrefixInternalError, getLine(), "Constant Folding cannot be done for matrix multiply");
                     return 0;
                 }
                 {// support MSVC++6.0
@@ -1157,11 +1141,11 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
             case EOpDiv:
                 tempConstArray = new ConstantUnion[objectSize];
                 {// support MSVC++6.0
-                    for (int i = 0; i < objectSize; i++) {
+                    for (size_t i = 0; i < objectSize; i++) {
                         switch (getType().getBasicType()) {
             case EbtFloat:
                 if (rightUnionArray[i] == 0.0f) {
-                    infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine());
+                    infoSink.info.message(EPrefixWarning, getLine(), "Divide by zero error during constant folding");
                     tempConstArray[i].setFConst(unionArray[i].getFConst() < 0 ? -FLT_MAX : FLT_MAX);
                 } else
                     tempConstArray[i].setFConst(unionArray[i].getFConst() / rightUnionArray[i].getFConst());
@@ -1169,13 +1153,13 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
 
             case EbtInt:
                 if (rightUnionArray[i] == 0) {
-                    infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine());
+                    infoSink.info.message(EPrefixWarning, getLine(), "Divide by zero error during constant folding");
                     tempConstArray[i].setIConst(INT_MAX);
                 } else
                     tempConstArray[i].setIConst(unionArray[i].getIConst() / rightUnionArray[i].getIConst());
                 break;
             default:
-                infoSink.info.message(EPrefixInternalError, "Constant folding cannot be done for \"/\"", getLine());
+                infoSink.info.message(EPrefixInternalError, getLine(), "Constant folding cannot be done for \"/\"");
                 return 0;
                         }
                     }
@@ -1184,7 +1168,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
 
             case EOpMatrixTimesVector:
                 if (node->getBasicType() != EbtFloat) {
-                    infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for matrix times vector", getLine());
+                    infoSink.info.message(EPrefixInternalError, getLine(), "Constant Folding cannot be done for matrix times vector");
                     return 0;
                 }
                 tempConstArray = new ConstantUnion[getNominalSize()];
@@ -1205,7 +1189,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
 
             case EOpVectorTimesMatrix:
                 if (getType().getBasicType() != EbtFloat) {
-                    infoSink.info.message(EPrefixInternalError, "Constant Folding cannot be done for vector times matrix", getLine());
+                    infoSink.info.message(EPrefixInternalError, getLine(), "Constant Folding cannot be done for vector times matrix");
                     return 0;
                 }
 
@@ -1223,7 +1207,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
             case EOpLogicalAnd: // this code is written for possible future use, will not get executed currently
                 tempConstArray = new ConstantUnion[objectSize];
                 {// support MSVC++6.0
-                    for (int i = 0; i < objectSize; i++)
+                    for (size_t i = 0; i < objectSize; i++)
                         tempConstArray[i] = unionArray[i] && rightUnionArray[i];
                 }
                 break;
@@ -1231,7 +1215,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
             case EOpLogicalOr: // this code is written for possible future use, will not get executed currently
                 tempConstArray = new ConstantUnion[objectSize];
                 {// support MSVC++6.0
-                    for (int i = 0; i < objectSize; i++)
+                    for (size_t i = 0; i < objectSize; i++)
                         tempConstArray[i] = unionArray[i] || rightUnionArray[i];
                 }
                 break;
@@ -1239,7 +1223,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
             case EOpLogicalXor:
                 tempConstArray = new ConstantUnion[objectSize];
                 {// support MSVC++6.0
-                    for (int i = 0; i < objectSize; i++)
+                    for (size_t i = 0; i < objectSize; i++)
                         switch (getType().getBasicType()) {
             case EbtBool: tempConstArray[i].setBConst((unionArray[i] == rightUnionArray[i]) ? false : true); break;
             default: assert(false && "Default missing");
@@ -1285,7 +1269,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
                     if (!CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
                         boolNodeFlag = true;
                 } else {
-                    for (int i = 0; i < objectSize; i++) {
+                    for (size_t i = 0; i < objectSize; i++) {
                         if (unionArray[i] != rightUnionArray[i]) {
                             boolNodeFlag = true;
                             break;  // break out of for loop
@@ -1311,7 +1295,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
                     if (CompareStructure(node->getType(), node->getUnionArrayPointer(), unionArray))
                         boolNodeFlag = true;
                 } else {
-                    for (int i = 0; i < objectSize; i++) {
+                    for (size_t i = 0; i < objectSize; i++) {
                         if (unionArray[i] == rightUnionArray[i]) {
                             boolNodeFlag = true;
                             break;  // break out of for loop
@@ -1333,7 +1317,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
                 return tempNode;
 
             default:
-                infoSink.info.message(EPrefixInternalError, "Invalid operator for constant folding", getLine());
+                infoSink.info.message(EPrefixInternalError, getLine(), "Invalid operator for constant folding");
                 return 0;
         }
         tempNode = new TIntermConstantUnion(tempConstArray, returnType);
@@ -1346,14 +1330,14 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
         //
         TIntermConstantUnion *newNode = 0;
         ConstantUnion* tempConstArray = new ConstantUnion[objectSize];
-        for (int i = 0; i < objectSize; i++) {
+        for (size_t i = 0; i < objectSize; i++) {
             switch(op) {
                 case EOpNegative:
                     switch (getType().getBasicType()) {
                         case EbtFloat: tempConstArray[i].setFConst(-unionArray[i].getFConst()); break;
                         case EbtInt:   tempConstArray[i].setIConst(-unionArray[i].getIConst()); break;
                         default:
-                            infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
+                            infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
                             return 0;
                     }
                     break;
@@ -1361,7 +1345,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
                     switch (getType().getBasicType()) {
                         case EbtBool:  tempConstArray[i].setBConst(!unionArray[i].getBConst()); break;
                         default:
-                            infoSink.info.message(EPrefixInternalError, "Unary operation not folded into constant", getLine());
+                            infoSink.info.message(EPrefixInternalError, getLine(), "Unary operation not folded into constant");
                             return 0;
                     }
                     break;
@@ -1377,65 +1361,64 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod
 
 TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermConstantUnion* node)
 {
-    ConstantUnion *rightUnionArray = node->getUnionArrayPointer();
-    int size = node->getType().getObjectSize();
+    size_t size = node->getType().getObjectSize();
 
     ConstantUnion *leftUnionArray = new ConstantUnion[size];
 
-    for (int i=0; i < size; i++) {
+    for (size_t i = 0; i < size; i++) {
 
         switch (promoteTo) {
             case EbtFloat:
                 switch (node->getType().getBasicType()) {
                     case EbtInt:
-                        leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getIConst()));
+                        leftUnionArray[i].setFConst(static_cast<float>(node->getIConst(static_cast<int>(i))));
                         break;
                     case EbtBool:
-                        leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getBConst()));
+                        leftUnionArray[i].setFConst(static_cast<float>(node->getBConst(static_cast<bool>(i))));
                         break;
                     case EbtFloat:
-                        leftUnionArray[i] = rightUnionArray[i];
+                        leftUnionArray[i].setFConst(static_cast<float>(node->getFConst(static_cast<float>(i))));
                         break;
                     default:
-                        infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
+                        infoSink.info.message(EPrefixInternalError, node->getLine(), "Cannot promote");
                         return 0;
                 }
                 break;
             case EbtInt:
                 switch (node->getType().getBasicType()) {
                     case EbtInt:
-                        leftUnionArray[i] = rightUnionArray[i];
+                        leftUnionArray[i].setIConst(static_cast<int>(node->getIConst(static_cast<int>(i))));
                         break;
                     case EbtBool:
-                        leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getBConst()));
+                        leftUnionArray[i].setIConst(static_cast<int>(node->getBConst(static_cast<bool>(i))));
                         break;
                     case EbtFloat:
-                        leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getFConst()));
+                        leftUnionArray[i].setIConst(static_cast<int>(node->getFConst(static_cast<float>(i))));
                         break;
                     default:
-                        infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
+                        infoSink.info.message(EPrefixInternalError, node->getLine(), "Cannot promote");
                         return 0;
                 }
                 break;
             case EbtBool:
                 switch (node->getType().getBasicType()) {
                     case EbtInt:
-                        leftUnionArray[i].setBConst(rightUnionArray[i].getIConst() != 0);
+                        leftUnionArray[i].setBConst(node->getIConst(static_cast<int>(i)) != 0);
                         break;
                     case EbtBool:
-                        leftUnionArray[i] = rightUnionArray[i];
+                        leftUnionArray[i].setBConst(node->getBConst(static_cast<bool>(i)));
                         break;
                     case EbtFloat:
-                        leftUnionArray[i].setBConst(rightUnionArray[i].getFConst() != 0.0f);
+                        leftUnionArray[i].setBConst(node->getFConst(static_cast<float>(i)) != 0.0f);
                         break;
                     default:
-                        infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine());
+                        infoSink.info.message(EPrefixInternalError, node->getLine(), "Cannot promote");
                         return 0;
                 }
 
                 break;
             default:
-                infoSink.info.message(EPrefixInternalError, "Incorrect data type found", node->getLine());
+                infoSink.info.message(EPrefixInternalError, node->getLine(), "Incorrect data type found");
                 return 0;
         }
 
index 206f403..10a451c 100644 (file)
@@ -19,3 +19,17 @@ bool TOutputGLSL::writeVariablePrecision(TPrecision)
 {
     return false;
 }
+
+void TOutputGLSL::visitSymbol(TIntermSymbol* node)
+{
+    TInfoSinkBase& out = objSink();
+
+    if (node->getSymbol() == "gl_FragDepthEXT")
+    {
+        out << "gl_FragDepth";
+    }
+    else
+    {
+        TOutputGLSLBase::visitSymbol(node);
+    }
+}
index 199b6f3..fa68ac8 100644 (file)
@@ -20,6 +20,7 @@ public:
 
 protected:
     virtual bool writeVariablePrecision(TPrecision);
+    virtual void visitSymbol(TIntermSymbol* node);
 };
 
 #endif  // CROSSCOMPILERGLSL_OUTPUTGLSL_H_
index 1b9a10d..d677c75 100644 (file)
@@ -79,25 +79,9 @@ void TOutputGLSLBase::writeVariableType(const TType& type)
     if ((qualifier != EvqTemporary) && (qualifier != EvqGlobal))
         out << type.getQualifierString() << " ";
     // Declare the struct if we have not done so already.
-    if ((type.getBasicType() == EbtStruct) &&
-        (mDeclaredStructs.find(type.getTypeName()) == mDeclaredStructs.end()))
+    if ((type.getBasicType() == EbtStruct) && !structDeclared(type.getStruct()))
     {
-        out << "struct " << hashName(type.getTypeName()) << "{\n";
-        const TTypeList* structure = type.getStruct();
-        ASSERT(structure != NULL);
-        for (size_t i = 0; i < structure->size(); ++i)
-        {
-            const TType* fieldType = (*structure)[i].type;
-            ASSERT(fieldType != NULL);
-            if (writeVariablePrecision(fieldType->getPrecision()))
-                out << " ";
-            out << getTypeName(*fieldType) << " " << hashName(fieldType->getFieldName());
-            if (fieldType->isArray())
-                out << arrayBrackets(*fieldType);
-            out << ";\n";
-        }
-        out << "}";
-        mDeclaredStructs.insert(type.getTypeName());
+        declareStruct(type.getStruct());
     }
     else
     {
@@ -138,24 +122,25 @@ const ConstantUnion* TOutputGLSLBase::writeConstantUnion(const TType& type,
 
     if (type.getBasicType() == EbtStruct)
     {
-        out << hashName(type.getTypeName()) << "(";
-        const TTypeList* structure = type.getStruct();
-        ASSERT(structure != NULL);
-        for (size_t i = 0; i < structure->size(); ++i)
+        const TStructure* structure = type.getStruct();
+        out << hashName(structure->name()) << "(";
+
+        const TFieldList& fields = structure->fields();
+        for (size_t i = 0; i < fields.size(); ++i)
         {
-            const TType* fieldType = (*structure)[i].type;
+            const TType* fieldType = fields[i]->type();
             ASSERT(fieldType != NULL);
             pConstUnion = writeConstantUnion(*fieldType, pConstUnion);
-            if (i != structure->size() - 1) out << ", ";
+            if (i != fields.size() - 1) out << ", ";
         }
         out << ")";
     }
     else
     {
-        int size = type.getObjectSize();
+        size_t size = type.getObjectSize();
         bool writeType = size > 1;
         if (writeType) out << getTypeName(type) << "(";
-        for (int i = 0; i < size; ++i, ++pConstUnion)
+        for (size_t i = 0; i < size; ++i, ++pConstUnion)
         {
             switch (pConstUnion->getType())
             {
@@ -260,12 +245,18 @@ bool TOutputGLSLBase::visitBinary(Visit visit, TIntermBinary* node)
         case EOpIndexDirectStruct:
             if (visit == InVisit)
             {
+                // Here we are writing out "foo.bar", where "foo" is struct
+                // and "bar" is field. In AST, it is represented as a binary
+                // node, where left child represents "foo" and right child "bar".
+                // The node itself represents ".". The struct field "bar" is
+                // actually stored as an index into TStructure::fields.
                 out << ".";
-                // TODO(alokp): ASSERT
-                TString fieldName = node->getType().getFieldName();
+                const TStructure* structure = node->getLeft()->getType().getStruct();
+                const TIntermConstantUnion* index = node->getRight()->getAsConstantUnion();
+                const TField* field = structure->fields()[index->getIConst(0)];
 
-                const TType& structType = node->getLeft()->getType();
-                if (!mSymbolTable.findBuiltIn(structType.getTypeName()))
+                TString fieldName = field->name();
+                if (!mSymbolTable.findBuiltIn(structure->name()))
                     fieldName = hashName(fieldName);
 
                 out << fieldName;
@@ -596,7 +587,7 @@ bool TOutputGLSLBase::visitAggregate(Visit visit, TIntermAggregate* node)
             {
                 const TType& type = node->getType();
                 ASSERT(type.getBasicType() == EbtStruct);
-                out << hashName(type.getTypeName()) << "(";
+                out << hashName(type.getStruct()->name()) << "(";
             }
             else if (visit == InVisit)
             {
@@ -765,7 +756,7 @@ TString TOutputGLSLBase::getTypeName(const TType& type)
     else
     {
         if (type.getBasicType() == EbtStruct)
-            out << hashName(type.getTypeName());
+            out << hashName(type.getStruct()->name());
         else
             out << type.getBasicString();
     }
@@ -798,3 +789,29 @@ TString TOutputGLSLBase::hashFunctionName(const TString& mangled_name)
         return name;
     return hashName(name);
 }
+
+bool TOutputGLSLBase::structDeclared(const TStructure* structure) const
+{
+    return mDeclaredStructs.find(structure->name()) != mDeclaredStructs.end();
+}
+
+void TOutputGLSLBase::declareStruct(const TStructure* structure)
+{
+    TInfoSinkBase& out = objSink();
+
+    out << "struct " << hashName(structure->name()) << "{\n";
+    const TFieldList& fields = structure->fields();
+    for (size_t i = 0; i < fields.size(); ++i)
+    {
+        const TField* field = fields[i];
+        if (writeVariablePrecision(field->type()->getPrecision()))
+            out << " ";
+        out << getTypeName(*field->type()) << " " << hashName(field->name());
+        if (field->type()->isArray())
+            out << arrayBrackets(*field->type());
+        out << ";\n";
+    }
+    out << "}";
+
+    mDeclaredStructs.insert(structure->name());
+}
index c9f72d5..df4ad68 100644 (file)
@@ -52,6 +52,9 @@ protected:
     TString hashFunctionName(const TString& mangled_name);
 
 private:
+    bool structDeclared(const TStructure* structure) const;
+    void declareStruct(const TStructure* structure);
+
     TInfoSinkBase& mObjSink;
     bool mDeclaringVariables;
 
index 60678c2..cbc7834 100644 (file)
@@ -52,6 +52,7 @@ OutputHLSL::OutputHLSL(TParseContext &context) : TIntermTraverser(true, true, tr
     mUsesPointCoord = false;
     mUsesFrontFacing = false;
     mUsesPointSize = false;
+    mUsesFragDepth = false;
     mUsesXor = false;
     mUsesMod1 = false;
     mUsesMod2v = false;
@@ -189,6 +190,11 @@ void OutputHLSL::header()
         out << "\n"
                "static float4 gl_Color[1] = {float4(0, 0, 0, 0)};\n";
 
+        if (mUsesFragDepth)
+        {
+            out << "static float gl_Depth = 0.0;\n";
+        }
+
         if (mUsesFragCoord)
         {
             out << "static float4 gl_FragCoord = float4(0, 0, 0, 0);\n";
@@ -509,6 +515,11 @@ void OutputHLSL::header()
         out << "#define GL_USES_POINT_SIZE\n";
     }
 
+    if (mUsesFragDepth)
+    {
+        out << "#define GL_USES_FRAG_DEPTH\n";
+    }
+
     if (mUsesDepthRange)
     {
         out << "struct gl_DepthRangeParameters\n"
@@ -843,6 +854,11 @@ void OutputHLSL::visitSymbol(TIntermSymbol *node)
         mUsesPointSize = true;
         out << name;
     }
+    else if (name == "gl_FragDepthEXT")
+    {
+        mUsesFragDepth = true;
+        out << "gl_Depth";
+    }
     else
     {
         TQualifier qualifier = node->getQualifier();
@@ -952,7 +968,10 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
       case EOpIndexDirectStruct:
         if (visit == InVisit)
         {
-            out << "." + decorateField(node->getType().getFieldName(), node->getLeft()->getType());
+            const TStructure* structure = node->getLeft()->getType().getStruct();
+            const TIntermConstantUnion* index = node->getRight()->getAsConstantUnion();
+            const TField* field = structure->fields()[index->getIConst(0)];
+            out << "." + decorateField(field->name(), node->getLeft()->getType());
 
             return false;
         }
@@ -974,7 +993,7 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
 
                     if (element)
                     {
-                        int i = element->getUnionArrayPointer()[0].getIConst();
+                        int i = element->getIConst(0);
 
                         switch (i)
                         {
@@ -1021,18 +1040,18 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
                 out << "!(";
             }
 
-            const TTypeList *fields = node->getLeft()->getType().getStruct();
+            const TFieldList &fields = node->getLeft()->getType().getStruct()->fields();
 
-            for (size_t i = 0; i < fields->size(); i++)
+            for (size_t i = 0; i < fields.size(); i++)
             {
-                const TType *fieldType = (*fields)[i].type;
+                const TField *field = fields[i];
 
                 node->getLeft()->traverse(this);
-                out << "." + decorateField(fieldType->getFieldName(), node->getLeft()->getType()) + " == ";
+                out << "." + decorateField(field->name(), node->getLeft()->getType()) + " == ";
                 node->getRight()->traverse(this);
-                out << "." + decorateField(fieldType->getFieldName(), node->getLeft()->getType());
+                out << "." + decorateField(field->name(), node->getLeft()->getType());
 
-                if (i < fields->size() - 1)
+                if (i < fields.size() - 1)
                 {
                     out << " && ";
                 }
@@ -1238,7 +1257,7 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
         {
             if (mInsideFunction)
             {
-                outputLineDirective(node->getLine());
+                outputLineDirective(node->getLine().first_line);
                 out << "{\n";
 
                 mScopeDepth++;
@@ -1255,7 +1274,7 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
 
             for (TIntermSequence::iterator sit = node->getSequence().begin(); sit != node->getSequence().end(); sit++)
             {
-                outputLineDirective((*sit)->getLine());
+                outputLineDirective((*sit)->getLine().first_line);
 
                 traverseStatements(*sit);
 
@@ -1264,7 +1283,7 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
 
             if (mInsideFunction)
             {
-                outputLineDirective(node->getEndLine());
+                outputLineDirective(node->getLine().last_line);
                 out << "}\n";
 
                 mScopeDepth--;
@@ -1283,7 +1302,7 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
             {
                 if (variable->getType().getStruct())
                 {
-                    addConstructor(variable->getType(), scopedStruct(variable->getType().getTypeName()), NULL);
+                    addConstructor(variable->getType(), scopedStruct(variable->getType().getStruct()->name()), NULL);
                 }
 
                 if (!variable->getAsSymbolNode() || variable->getAsSymbolNode()->getSymbol() != "")   // Variable declaration
@@ -1401,7 +1420,7 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
                 {
                     if (symbol->getType().getStruct())
                     {
-                        addConstructor(symbol->getType(), scopedStruct(symbol->getType().getTypeName()), NULL);
+                        addConstructor(symbol->getType(), scopedStruct(symbol->getType().getStruct()->name()), NULL);
                     }
 
                     out << argumentString(symbol);
@@ -1650,8 +1669,8 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node)
         outputTriplet(visit, "mat4(", ", ", ")");
         break;
       case EOpConstructStruct:
-        addConstructor(node->getType(), scopedStruct(node->getType().getTypeName()), &node->getSequence());
-        outputTriplet(visit, structLookup(node->getType().getTypeName()) + "_ctor(", ", ", ")");
+        addConstructor(node->getType(), scopedStruct(node->getType().getStruct()->name()), &node->getSequence());
+        outputTriplet(visit, structLookup(node->getType().getStruct()->name()) + "_ctor(", ", ", ")");
         break;
       case EOpLessThan:         outputTriplet(visit, "(", " < ", ")");                 break;
       case EOpGreaterThan:      outputTriplet(visit, "(", " > ", ")");                 break;
@@ -1741,7 +1760,7 @@ bool OutputHLSL::visitSelection(Visit visit, TIntermSelection *node)
 
         out << ")\n";
         
-        outputLineDirective(node->getLine());
+        outputLineDirective(node->getLine().first_line);
         out << "{\n";
 
         if (node->getTrueBlock())
@@ -1749,20 +1768,20 @@ bool OutputHLSL::visitSelection(Visit visit, TIntermSelection *node)
             traverseStatements(node->getTrueBlock());
         }
 
-        outputLineDirective(node->getLine());
+        outputLineDirective(node->getLine().first_line);
         out << ";\n}\n";
 
         if (node->getFalseBlock())
         {
             out << "else\n";
 
-            outputLineDirective(node->getFalseBlock()->getLine());
+            outputLineDirective(node->getFalseBlock()->getLine().first_line);
             out << "{\n";
 
-            outputLineDirective(node->getFalseBlock()->getLine());
+            outputLineDirective(node->getFalseBlock()->getLine().first_line);
             traverseStatements(node->getFalseBlock());
 
-            outputLineDirective(node->getFalseBlock()->getLine());
+            outputLineDirective(node->getFalseBlock()->getLine().first_line);
             out << ";\n}\n";
         }
     }
@@ -1795,7 +1814,7 @@ bool OutputHLSL::visitLoop(Visit visit, TIntermLoop *node)
     {
         out << "{do\n";
 
-        outputLineDirective(node->getLine());
+        outputLineDirective(node->getLine().first_line);
         out << "{\n";
     }
     else
@@ -1823,7 +1842,7 @@ bool OutputHLSL::visitLoop(Visit visit, TIntermLoop *node)
 
         out << ")\n";
         
-        outputLineDirective(node->getLine());
+        outputLineDirective(node->getLine().first_line);
         out << "{\n";
     }
 
@@ -1832,12 +1851,12 @@ bool OutputHLSL::visitLoop(Visit visit, TIntermLoop *node)
         traverseStatements(node->getBody());
     }
 
-    outputLineDirective(node->getLine());
+    outputLineDirective(node->getLine().first_line);
     out << ";}\n";
 
     if (node->getType() == ELoopDoWhile)
     {
-        outputLineDirective(node->getCondition()->getLine());
+        outputLineDirective(node->getCondition()->getLine().first_line);
         out << "while(\n";
 
         node->getCondition()->traverse(this);
@@ -1977,7 +1996,7 @@ bool OutputHLSL::handleExcessiveLoop(TIntermLoop *node)
                         if (constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
                         {
                             index = symbol;
-                            initial = constant->getUnionArrayPointer()[0].getIConst();
+                            initial = constant->getIConst(0);
                         }
                     }
                 }
@@ -1999,7 +2018,7 @@ bool OutputHLSL::handleExcessiveLoop(TIntermLoop *node)
                 if (constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
                 {
                     comparator = test->getOp();
-                    limit = constant->getUnionArrayPointer()[0].getIConst();
+                    limit = constant->getIConst(0);
                 }
             }
         }
@@ -2020,7 +2039,7 @@ bool OutputHLSL::handleExcessiveLoop(TIntermLoop *node)
             {
                 if (constant->getBasicType() == EbtInt && constant->getNominalSize() == 1)
                 {
-                    int value = constant->getUnionArrayPointer()[0].getIConst();
+                    int value = constant->getIConst(0);
 
                     switch (op)
                     {
@@ -2109,7 +2128,7 @@ bool OutputHLSL::handleExcessiveLoop(TIntermLoop *node)
                 out << increment;
                 out << ")\n";
                 
-                outputLineDirective(node->getLine());
+                outputLineDirective(node->getLine().first_line);
                 out << "{\n";
 
                 if (node->getBody())
@@ -2117,7 +2136,7 @@ bool OutputHLSL::handleExcessiveLoop(TIntermLoop *node)
                     node->getBody()->traverse(this);
                 }
 
-                outputLineDirective(node->getLine());
+                outputLineDirective(node->getLine().first_line);
                 out << ";}\n";
 
                 if (!firstLoopFragment)
@@ -2213,22 +2232,23 @@ TString OutputHLSL::typeString(const TType &type)
 {
     if (type.getBasicType() == EbtStruct)
     {
-        if (type.getTypeName() != "")
+        const TString& typeName = type.getStruct()->name();
+        if (typeName != "")
         {
-            return structLookup(type.getTypeName());
+            return structLookup(typeName);
         }
         else   // Nameless structure, define in place
         {
-            const TTypeList &fields = *type.getStruct();
+            const TFieldList &fields = type.getStruct()->fields();
 
             TString string = "struct\n"
                              "{\n";
 
             for (unsigned int i = 0; i < fields.size(); i++)
             {
-                const TType &field = *fields[i].type;
+                const TField *field = fields[i];
 
-                string += "    " + typeString(field) + " " + decorate(field.getFieldName()) + arrayString(field) + ";\n";
+                string += "    " + typeString(*field->type()) + " " + decorate(field->name()) + arrayString(*field->type()) + ";\n";
             }
 
             string += "} ";
@@ -2304,11 +2324,12 @@ TString OutputHLSL::initializer(const TType &type)
 {
     TString string;
 
-    for (int component = 0; component < type.getObjectSize(); component++)
+    size_t size = type.getObjectSize();
+    for (size_t component = 0; component < size; component++)
     {
         string += "0";
 
-        if (component < type.getObjectSize() - 1)
+        if (component + 1 < size)
         {
             string += ", ";
         }
@@ -2347,13 +2368,13 @@ void OutputHLSL::addConstructor(const TType &type, const TString &name, const TI
         structure += "struct " + decorate(name) + "\n"
                      "{\n";
 
-        const TTypeList &fields = *type.getStruct();
+        const TFieldList &fields = type.getStruct()->fields();
 
         for (unsigned int i = 0; i < fields.size(); i++)
         {
-            const TType &field = *fields[i].type;
+            const TField *field = fields[i];
 
-            structure += "    " + typeString(field) + " " + decorateField(field.getFieldName(), type) + arrayString(field) + ";\n";
+            structure += "    " + typeString(*field->type()) + " " + decorateField(field->name(), type) + arrayString(*field->type()) + ";\n";
         }
 
         structure += "};\n";
@@ -2365,7 +2386,7 @@ void OutputHLSL::addConstructor(const TType &type, const TString &name, const TI
 
         for (unsigned int i = 0; i < fields.size(); i++)
         {
-            ctorParameters.push_back(*fields[i].type);
+            ctorParameters.push_back(*fields[i]->type());
         }
     }
     else if (parameters)
@@ -2458,27 +2479,30 @@ void OutputHLSL::addConstructor(const TType &type, const TString &name, const TI
     }
     else
     {
-        int remainingComponents = ctorType.getObjectSize();
-        int parameterIndex = 0;
+        size_t remainingComponents = ctorType.getObjectSize();
+        size_t parameterIndex = 0;
 
         while (remainingComponents > 0)
         {
             const TType &parameter = ctorParameters[parameterIndex];
-            bool moreParameters = parameterIndex < (int)ctorParameters.size() - 1;
+            const size_t parameterSize = parameter.getObjectSize();
+            bool moreParameters = parameterIndex + 1 < ctorParameters.size();
 
             constructor += "x" + str(parameterIndex);
 
             if (parameter.isScalar())
             {
-                remainingComponents -= parameter.getObjectSize();
+                ASSERT(parameterSize <= remainingComponents);
+                remainingComponents -= parameterSize;
             }
             else if (parameter.isVector())
             {
-                if (remainingComponents == parameter.getObjectSize() || moreParameters)
+                if (remainingComponents == parameterSize || moreParameters)
                 {
-                    remainingComponents -= parameter.getObjectSize();
+                    ASSERT(parameterSize <= remainingComponents);
+                    remainingComponents -= parameterSize;
                 }
-                else if (remainingComponents < parameter.getNominalSize())
+                else if (remainingComponents < static_cast<size_t>(parameter.getNominalSize()))
                 {
                     switch (remainingComponents)
                     {
@@ -2495,9 +2519,10 @@ void OutputHLSL::addConstructor(const TType &type, const TString &name, const TI
             }
             else if (parameter.isMatrix() || parameter.getStruct())
             {
-                ASSERT(remainingComponents == parameter.getObjectSize() || moreParameters);
+                ASSERT(remainingComponents == parameterSize || moreParameters);
+                ASSERT(parameterSize <= remainingComponents);
                 
-                remainingComponents -= parameter.getObjectSize();
+                remainingComponents -= parameterSize;
             }
             else UNREACHABLE();
 
@@ -2534,17 +2559,17 @@ const ConstantUnion *OutputHLSL::writeConstantUnion(const TType &type, const Con
 
     if (type.getBasicType() == EbtStruct)
     {
-        out << structLookup(type.getTypeName()) + "_ctor(";
+        out << structLookup(type.getStruct()->name()) + "_ctor(";
         
-        const TTypeList *structure = type.getStruct();
+        const TFieldList &fields = type.getStruct()->fields();
 
-        for (size_t i = 0; i < structure->size(); i++)
+        for (size_t i = 0; i < fields.size(); i++)
         {
-            const TType *fieldType = (*structure)[i].type;
+            const TType *fieldType = fields[i]->type();
 
             constUnion = writeConstantUnion(*fieldType, constUnion);
 
-            if (i != structure->size() - 1)
+            if (i != fields.size() - 1)
             {
                 out << ", ";
             }
@@ -2554,7 +2579,7 @@ const ConstantUnion *OutputHLSL::writeConstantUnion(const TType &type, const Con
     }
     else
     {
-        int size = type.getObjectSize();
+        size_t size = type.getObjectSize();
         bool writeType = size > 1;
         
         if (writeType)
@@ -2562,7 +2587,7 @@ const ConstantUnion *OutputHLSL::writeConstantUnion(const TType &type, const Con
             out << typeString(type) << "(";
         }
 
-        for (int i = 0; i < size; i++, constUnion++)
+        for (size_t i = 0; i < size; i++, constUnion++)
         {
             switch (constUnion->getType())
             {
@@ -2655,7 +2680,7 @@ TString OutputHLSL::decorateUniform(const TString &string, const TType &type)
 
 TString OutputHLSL::decorateField(const TString &string, const TType &structure)
 {
-    if (structure.getTypeName().compare(0, 3, "gl_") != 0)
+    if (structure.getStruct()->name().compare(0, 3, "gl_") != 0)
     {
         return decorate(string);
     }
index dc843fb..3a4c1da 100644 (file)
@@ -97,6 +97,7 @@ class OutputHLSL : public TIntermTraverser
     bool mUsesPointCoord;
     bool mUsesFrontFacing;
     bool mUsesPointSize;
+    bool mUsesFragDepth;
     bool mUsesXor;
     bool mUsesMod1;
     bool mUsesMod2v;
index 1768c7c..fd2e953 100644 (file)
@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -22,7 +22,7 @@
 // Look at a '.' field selector string and change it into offsets
 // for a vector.
 //
-bool TParseContext::parseVectorFields(const TString& compString, int vecSize, TVectorFields& fields, int line)
+bool TParseContext::parseVectorFields(const TString& compString, int vecSize, TVectorFields& fields, const TSourceLoc& line)
 {
     fields.num = (int) compString.size();
     if (fields.num > 4) {
@@ -115,7 +115,7 @@ bool TParseContext::parseVectorFields(const TString& compString, int vecSize, TV
 // Look at a '.' field selector string and change it into offsets
 // for a matrix.
 //
-bool TParseContext::parseMatrixFields(const TString& compString, int matSize, TMatrixFields& fields, int line)
+bool TParseContext::parseMatrixFields(const TString& compString, int matSize, TMatrixFields& fields, const TSourceLoc& line)
 {
     fields.wholeRow = false;
     fields.wholeCol = false;
@@ -175,22 +175,24 @@ void TParseContext::recover()
 //
 // Used by flex/bison to output all syntax and parsing errors.
 //
-void TParseContext::error(TSourceLoc loc,
+void TParseContext::error(const TSourceLoc& loc,
                           const char* reason, const char* token, 
                           const char* extraInfo)
 {
     pp::SourceLocation srcLoc;
-    DecodeSourceLoc(loc, &srcLoc.file, &srcLoc.line);
+    srcLoc.file = loc.first_file;
+    srcLoc.line = loc.first_line;
     diagnostics.writeInfo(pp::Diagnostics::ERROR,
                           srcLoc, reason, token, extraInfo);
 
 }
 
-void TParseContext::warning(TSourceLoc loc,
+void TParseContext::warning(const TSourceLoc& loc,
                             const char* reason, const char* token,
                             const char* extraInfo) {
     pp::SourceLocation srcLoc;
-    DecodeSourceLoc(loc, &srcLoc.file, &srcLoc.line);
+    srcLoc.file = loc.first_file;
+    srcLoc.line = loc.first_line;
     diagnostics.writeInfo(pp::Diagnostics::WARNING,
                           srcLoc, reason, token, extraInfo);
 }
@@ -203,7 +205,7 @@ void TParseContext::trace(const char* str)
 //
 // Same error message for all places assignments don't work.
 //
-void TParseContext::assignError(int line, const char* op, TString left, TString right)
+void TParseContext::assignError(const TSourceLoc& line, const char* op, TString left, TString right)
 {
     std::stringstream extraInfoStream;
     extraInfoStream << "cannot convert from '" << right << "' to '" << left << "'";
@@ -214,7 +216,7 @@ void TParseContext::assignError(int line, const char* op, TString left, TString
 //
 // Same error message for all places unary operations don't work.
 //
-void TParseContext::unaryOpError(int line, const char* op, TString operand)
+void TParseContext::unaryOpError(const TSourceLoc& line, const char* op, TString operand)
 {
     std::stringstream extraInfoStream;
     extraInfoStream << "no operation '" << op << "' exists that takes an operand of type " << operand 
@@ -226,7 +228,7 @@ void TParseContext::unaryOpError(int line, const char* op, TString operand)
 //
 // Same error message for all binary operations don't work.
 //
-void TParseContext::binaryOpError(int line, const char* op, TString left, TString right)
+void TParseContext::binaryOpError(const TSourceLoc& line, const char* op, TString left, TString right)
 {
     std::stringstream extraInfoStream;
     extraInfoStream << "no operation '" << op << "' exists that takes a left-hand operand of type '" << left 
@@ -235,7 +237,7 @@ void TParseContext::binaryOpError(int line, const char* op, TString left, TStrin
     error(line, " wrong operand types ", op, extraInfo.c_str()); 
 }
 
-bool TParseContext::precisionErrorCheck(int line, TPrecision precision, TBasicType type){
+bool TParseContext::precisionErrorCheck(const TSourceLoc& line, TPrecision precision, TBasicType type){
     if (!checksPrecisionErrors)
         return false;
     switch( type ){
@@ -263,7 +265,7 @@ bool TParseContext::precisionErrorCheck(int line, TPrecision precision, TBasicTy
 //
 // Returns true if the was an error.
 //
-bool TParseContext::lValueErrorCheck(int line, const char* op, TIntermTyped* node)
+bool TParseContext::lValueErrorCheck(const TSourceLoc& line, const char* op, TIntermTyped* node)
 {
     TIntermSymbol* symNode = node->getAsSymbolNode();
     TIntermBinary* binaryNode = node->getAsBinaryNode();
@@ -286,7 +288,7 @@ bool TParseContext::lValueErrorCheck(int line, const char* op, TIntermTyped* nod
                 
                 for (TIntermSequence::iterator p = aggrNode->getSequence().begin(); 
                                                p != aggrNode->getSequence().end(); p++) {
-                    int value = (*p)->getAsTyped()->getAsConstantUnion()->getUnionArrayPointer()->getIConst();
+                    int value = (*p)->getAsTyped()->getAsConstantUnion()->getIConst(0);
                     offset[value]++;     
                     if (offset[value] > 1) {
                         error(line, " l-value of swizzle cannot have duplicate components", op);
@@ -317,7 +319,6 @@ bool TParseContext::lValueErrorCheck(int line, const char* op, TIntermTyped* nod
     case EvqAttribute:      message = "can't modify an attribute";   break;
     case EvqUniform:        message = "can't modify a uniform";      break;
     case EvqVaryingIn:      message = "can't modify a varying";      break;
-    case EvqInput:          message = "can't modify an input";       break;
     case EvqFragCoord:      message = "can't modify gl_FragCoord";   break;
     case EvqFrontFacing:    message = "can't modify gl_FrontFacing"; break;
     case EvqPointCoord:     message = "can't modify gl_PointCoord";  break;
@@ -409,7 +410,7 @@ bool TParseContext::integerErrorCheck(TIntermTyped* node, const char* token)
 //
 // Returns true if the was an error.
 //
-bool TParseContext::globalErrorCheck(int line, bool global, const char* token)
+bool TParseContext::globalErrorCheck(const TSourceLoc& line, bool global, const char* token)
 {
     if (global)
         return false;
@@ -428,7 +429,7 @@ bool TParseContext::globalErrorCheck(int line, bool global, const char* token)
 //
 // Returns true if there was an error.
 //
-bool TParseContext::reservedErrorCheck(int line, const TString& identifier)
+bool TParseContext::reservedErrorCheck(const TSourceLoc& line, const TString& identifier)
 {
     static const char* reservedErrMsg = "reserved built-in name";
     if (!symbolTable.atBuiltInLevel()) {
@@ -466,7 +467,7 @@ bool TParseContext::reservedErrorCheck(int line, const TString& identifier)
 //
 // Returns true if there was an error in construction.
 //
-bool TParseContext::constructorErrorCheck(int line, TIntermNode* node, TFunction& function, TOperator op, TType* type)
+bool TParseContext::constructorErrorCheck(const TSourceLoc& line, TIntermNode* node, TFunction& function, TOperator op, TType* type)
 {
     *type = function.getReturnType();
 
@@ -487,7 +488,7 @@ bool TParseContext::constructorErrorCheck(int line, TIntermNode* node, TFunction
     // again, there is an extra argument, so 'overfull' will become true.
     //
 
-    int size = 0;
+    size_t size = 0;
     bool constType = true;
     bool full = false;
     bool overFull = false;
@@ -534,7 +535,7 @@ bool TParseContext::constructorErrorCheck(int line, TIntermNode* node, TFunction
         return true;
     }
     
-    if (op == EOpConstructStruct && !type->isArray() && int(type->getStruct()->size()) != function.getParamCount()) {
+    if (op == EOpConstructStruct && !type->isArray() && int(type->getStruct()->fields().size()) != function.getParamCount()) {
         error(line, "Number of constructor parameters does not match the number of structure fields", "constructor");
         return true;
     }
@@ -568,7 +569,7 @@ bool TParseContext::constructorErrorCheck(int line, TIntermNode* node, TFunction
 //
 // returns true in case of an error
 //
-bool TParseContext::voidErrorCheck(int line, const TString& identifier, const TPublicType& pubType)
+bool TParseContext::voidErrorCheck(const TSourceLoc& line, const TString& identifier, const TPublicType& pubType)
 {
     if (pubType.type == EbtVoid) {
         error(line, "illegal use of type 'void'", identifier.c_str());
@@ -582,7 +583,7 @@ bool TParseContext::voidErrorCheck(int line, const TString& identifier, const TP
 //
 // returns true in case of an error
 //
-bool TParseContext::boolErrorCheck(int line, const TIntermTyped* type)
+bool TParseContext::boolErrorCheck(const TSourceLoc& line, const TIntermTyped* type)
 {
     if (type->getBasicType() != EbtBool || type->isArray() || type->isMatrix() || type->isVector()) {
         error(line, "boolean expression expected", "");
@@ -596,7 +597,7 @@ bool TParseContext::boolErrorCheck(int line, const TIntermTyped* type)
 //
 // returns true in case of an error
 //
-bool TParseContext::boolErrorCheck(int line, const TPublicType& pType)
+bool TParseContext::boolErrorCheck(const TSourceLoc& line, const TPublicType& pType)
 {
     if (pType.type != EbtBool || pType.array || pType.matrix || (pType.size > 1)) {
         error(line, "boolean expression expected", "");
@@ -606,7 +607,7 @@ bool TParseContext::boolErrorCheck(int line, const TPublicType& pType)
     return false;
 }
 
-bool TParseContext::samplerErrorCheck(int line, const TPublicType& pType, const char* reason)
+bool TParseContext::samplerErrorCheck(const TSourceLoc& line, const TPublicType& pType, const char* reason)
 {
     if (pType.type == EbtStruct) {
         if (containsSampler(*pType.userDef)) {
@@ -625,7 +626,7 @@ bool TParseContext::samplerErrorCheck(int line, const TPublicType& pType, const
     return false;
 }
 
-bool TParseContext::structQualifierErrorCheck(int line, const TPublicType& pType)
+bool TParseContext::structQualifierErrorCheck(const TSourceLoc& line, const TPublicType& pType)
 {
     if ((pType.qualifier == EvqVaryingIn || pType.qualifier == EvqVaryingOut || pType.qualifier == EvqAttribute) &&
         pType.type == EbtStruct) {
@@ -640,7 +641,7 @@ bool TParseContext::structQualifierErrorCheck(int line, const TPublicType& pType
     return false;
 }
 
-bool TParseContext::parameterSamplerErrorCheck(int line, TQualifier qualifier, const TType& type)
+bool TParseContext::parameterSamplerErrorCheck(const TSourceLoc& line, TQualifier qualifier, const TType& type)
 {
     if ((qualifier == EvqOut || qualifier == EvqInOut) && 
              type.getBasicType() != EbtStruct && IsSampler(type.getBasicType())) {
@@ -657,9 +658,9 @@ bool TParseContext::containsSampler(TType& type)
         return true;
 
     if (type.getBasicType() == EbtStruct) {
-        TTypeList& structure = *type.getStruct();
-        for (unsigned int i = 0; i < structure.size(); ++i) {
-            if (containsSampler(*structure[i].type))
+        const TFieldList& fields = type.getStruct()->fields();
+        for (unsigned int i = 0; i < fields.size(); ++i) {
+            if (containsSampler(*fields[i]->type()))
                 return true;
         }
     }
@@ -672,7 +673,7 @@ bool TParseContext::containsSampler(TType& type)
 //
 // Returns true if there was an error.
 //
-bool TParseContext::arraySizeErrorCheck(int line, TIntermTyped* expr, int& size)
+bool TParseContext::arraySizeErrorCheck(const TSourceLoc& line, TIntermTyped* expr, int& size)
 {
     TIntermConstantUnion* constant = expr->getAsConstantUnion();
     if (constant == 0 || constant->getBasicType() != EbtInt) {
@@ -680,7 +681,7 @@ bool TParseContext::arraySizeErrorCheck(int line, TIntermTyped* expr, int& size)
         return true;
     }
 
-    size = constant->getUnionArrayPointer()->getIConst();
+    size = constant->getIConst(0);
 
     if (size <= 0) {
         error(line, "array size must be a positive integer", "");
@@ -696,7 +697,7 @@ bool TParseContext::arraySizeErrorCheck(int line, TIntermTyped* expr, int& size)
 //
 // Returns true if there is an error.
 //
-bool TParseContext::arrayQualifierErrorCheck(int line, TPublicType type)
+bool TParseContext::arrayQualifierErrorCheck(const TSourceLoc& line, TPublicType type)
 {
     if ((type.qualifier == EvqAttribute) || (type.qualifier == EvqConst)) {
         error(line, "cannot declare arrays of this qualifier", TType(type).getCompleteString().c_str());
@@ -711,7 +712,7 @@ bool TParseContext::arrayQualifierErrorCheck(int line, TPublicType type)
 //
 // Returns true if there is an error.
 //
-bool TParseContext::arrayTypeErrorCheck(int line, TPublicType type)
+bool TParseContext::arrayTypeErrorCheck(const TSourceLoc& line, TPublicType type)
 {
     //
     // Can the type be an array?
@@ -732,7 +733,7 @@ bool TParseContext::arrayTypeErrorCheck(int line, TPublicType type)
 //
 // Returns true if there was an error.
 //
-bool TParseContext::arrayErrorCheck(int line, TString& identifier, TPublicType type, TVariable*& variable)
+bool TParseContext::arrayErrorCheck(const TSourceLoc& line, TString& identifier, TPublicType type, TVariable*& variable)
 {
     //
     // Don't check for reserved word use until after we know it's not in the symbol table,
@@ -777,16 +778,6 @@ bool TParseContext::arrayErrorCheck(int line, TString& identifier, TPublicType t
             return true;
         }
 
-        TType* t = variable->getArrayInformationType();
-        while (t != 0) {
-            if (t->getMaxArraySize() > type.arraySize) {
-                error(line, "higher index value already used for the array", identifier.c_str());
-                return true;
-            }
-            t->setArraySize(type.arraySize);
-            t = t->getArrayInformationType();
-        }
-
         if (type.arraySize)
             variable->getType().setArraySize(type.arraySize);
     } 
@@ -797,56 +788,12 @@ bool TParseContext::arrayErrorCheck(int line, TString& identifier, TPublicType t
     return false;
 }
 
-bool TParseContext::arraySetMaxSize(TIntermSymbol *node, TType* type, int size, bool updateFlag, TSourceLoc line)
-{
-    bool builtIn = false;
-    TSymbol* symbol = symbolTable.find(node->getSymbol(), &builtIn);
-    if (symbol == 0) {
-        error(line, " undeclared identifier", node->getSymbol().c_str());
-        return true;
-    }
-    TVariable* variable = static_cast<TVariable*>(symbol);
-
-    type->setArrayInformationType(variable->getArrayInformationType());
-    variable->updateArrayInformationType(type);
-
-    // special casing to test index value of gl_FragData. If the accessed index is >= gl_MaxDrawBuffers
-    // its an error
-    if (node->getSymbol() == "gl_FragData") {
-        TSymbol* fragData = symbolTable.find("gl_MaxDrawBuffers", &builtIn);
-        ASSERT(fragData);
-
-        int fragDataValue = static_cast<TVariable*>(fragData)->getConstPointer()[0].getIConst();
-        if (fragDataValue <= size) {
-            error(line, "", "[", "gl_FragData can only have a max array size of up to gl_MaxDrawBuffers");
-            return true;
-        }
-    }
-
-    // we dont want to update the maxArraySize when this flag is not set, we just want to include this 
-    // node type in the chain of node types so that its updated when a higher maxArraySize comes in.
-    if (!updateFlag)
-        return false;
-
-    size++;
-    variable->getType().setMaxArraySize(size);
-    type->setMaxArraySize(size);
-    TType* tt = type;
-
-    while(tt->getArrayInformationType() != 0) {
-        tt = tt->getArrayInformationType();
-        tt->setMaxArraySize(size);
-    }
-
-    return false;
-}
-
 //
 // Enforce non-initializer type/qualifier rules.
 //
 // Returns true if there was an error.
 //
-bool TParseContext::nonInitConstErrorCheck(int line, TString& identifier, TPublicType& type, bool array)
+bool TParseContext::nonInitConstErrorCheck(const TSourceLoc& line, TString& identifier, TPublicType& type, bool array)
 {
     if (type.qualifier == EvqConst)
     {
@@ -878,7 +825,7 @@ bool TParseContext::nonInitConstErrorCheck(int line, TString& identifier, TPubli
 //
 // Returns true if there was an error.
 //
-bool TParseContext::nonInitErrorCheck(int line, TString& identifier, TPublicType& type, TVariable*& variable)
+bool TParseContext::nonInitErrorCheck(const TSourceLoc& line, TString& identifier, TPublicType& type, TVariable*& variable)
 {
     if (reservedErrorCheck(line, identifier))
         recover();
@@ -898,7 +845,7 @@ bool TParseContext::nonInitErrorCheck(int line, TString& identifier, TPublicType
     return false;
 }
 
-bool TParseContext::paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type)
+bool TParseContext::paramErrorCheck(const TSourceLoc& line, TQualifier qualifier, TQualifier paramQualifier, TType* type)
 {    
     if (qualifier != EvqConst && qualifier != EvqTemporary) {
         error(line, "qualifier not allowed on function parameter", getQualifierString(qualifier));
@@ -917,7 +864,7 @@ bool TParseContext::paramErrorCheck(int line, TQualifier qualifier, TQualifier p
     return false;
 }
 
-bool TParseContext::extensionErrorCheck(int line, const TString& extension)
+bool TParseContext::extensionErrorCheck(const TSourceLoc& line, const TString& extension)
 {
     const TExtensionBehavior& extBehavior = extensionBehavior();
     TExtensionBehavior::const_iterator iter = extBehavior.find(extension.c_str());
@@ -945,20 +892,6 @@ bool TParseContext::supportsExtension(const char* extension)
     return (iter != extbehavior.end());
 }
 
-void TParseContext::handleExtensionDirective(int line, const char* extName, const char* behavior)
-{
-    pp::SourceLocation loc;
-    DecodeSourceLoc(line, &loc.file, &loc.line);
-    directiveHandler.handleExtension(loc, extName, behavior);
-}
-
-void TParseContext::handlePragmaDirective(int line, const char* name, const char* value)
-{
-    pp::SourceLocation loc;
-    DecodeSourceLoc(line, &loc.file, &loc.line);
-    directiveHandler.handlePragma(loc, name, value);
-}
-
 /////////////////////////////////////////////////////////////////////////////////
 //
 // Non-Errors.
@@ -970,7 +903,7 @@ void TParseContext::handlePragmaDirective(int line, const char* name, const char
 //
 // Return the function symbol if found, otherwise 0.
 //
-const TFunction* TParseContext::findFunction(int line, TFunction* call, bool *builtIn)
+const TFunction* TParseContext::findFunction(const TSourceLoc& line, TFunction* call, bool *builtIn)
 {
     // First find by unmangled name to check whether the function name has been
     // hidden by a variable name or struct typename.
@@ -992,11 +925,32 @@ const TFunction* TParseContext::findFunction(int line, TFunction* call, bool *bu
     return static_cast<const TFunction*>(symbol);
 }
 
+bool TParseContext::isVariableBuiltIn(const TVariable* var)
+{
+    bool builtIn = false;
+    // First find by unmangled name to check whether the function name has been
+    // hidden by a variable name or struct typename.
+    const TSymbol* symbol = symbolTable.find(var->getName(), &builtIn);
+    if (symbol == 0) {
+        symbol = symbolTable.find(var->getMangledName(), &builtIn);
+    }
+
+    if (symbol == 0) {
+        return false;
+    }
+
+    if (!symbol->isVariable()) {
+        return false;
+    }
+
+    return builtIn;
+}
+
 //
 // Initializers show up in several places in the grammar.  Have one set of
 // code to handle them here.
 //
-bool TParseContext::executeInitializer(TSourceLoc line, TString& identifier, TPublicType& pType, 
+bool TParseContext::executeInitializer(const TSourceLoc& line, TString& identifier, TPublicType& pType, 
                                        TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable)
 {
     TType type = TType(pType);
@@ -1048,13 +1002,7 @@ bool TParseContext::executeInitializer(TSourceLoc line, TString& identifier, TPu
             return true;
         }
         if (initializer->getAsConstantUnion()) { 
-            ConstantUnion* unionArray = variable->getConstPointer();
-
-            if (type.getObjectSize() == 1 && type.getBasicType() != EbtStruct) {
-                *unionArray = (initializer->getAsConstantUnion()->getUnionArrayPointer())[0];
-            } else {
-                variable->shareConstPointer(initializer->getAsConstantUnion()->getUnionArrayPointer());
-            }
+            variable->shareConstPointer(initializer->getAsConstantUnion()->getUnionArrayPointer());
         } else if (initializer->getAsSymbolNode()) {
             const TSymbol* symbol = symbolTable.find(initializer->getAsSymbolNode()->getSymbol());
             const TVariable* tVar = static_cast<const TVariable*>(symbol);
@@ -1108,16 +1056,16 @@ bool TParseContext::areAllChildConst(TIntermAggregate* aggrNode)
 //
 // Returns 0 for an error or the constructed node (aggregate or typed) for no error.
 //
-TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType* type, TOperator op, TFunction* fnCall, TSourceLoc line)
+TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType* type, TOperator op, TFunction* fnCall, const TSourceLoc& line)
 {
     if (node == 0)
         return 0;
 
     TIntermAggregate* aggrNode = node->getAsAggregate();
     
-    TTypeList::const_iterator memberTypes;
+    TFieldList::const_iterator memberFields;
     if (op == EOpConstructStruct)
-        memberTypes = type->getStruct()->begin();
+        memberFields = type->getStruct()->fields().begin();
     
     TType elementType = *type;
     if (type->isArray())
@@ -1139,7 +1087,7 @@ TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType* type
         if (type->isArray())
             newNode = constructStruct(node, &elementType, 1, node->getLine(), false);
         else if (op == EOpConstructStruct)
-            newNode = constructStruct(node, (*memberTypes).type, 1, node->getLine(), false);
+            newNode = constructStruct(node, (*memberFields)->type(), 1, node->getLine(), false);
         else
             newNode = constructBuiltIn(type, op, node, node->getLine(), false);
 
@@ -1170,7 +1118,7 @@ TIntermTyped* TParseContext::addConstructor(TIntermNode* node, const TType* type
         if (type->isArray())
             newNode = constructStruct(*p, &elementType, paramCount+1, node->getLine(), true);
         else if (op == EOpConstructStruct)
-            newNode = constructStruct(*p, (memberTypes[paramCount]).type, paramCount+1, node->getLine(), true);
+            newNode = constructStruct(*p, memberFields[paramCount]->type(), paramCount+1, node->getLine(), true);
         else
             newNode = constructBuiltIn(type, op, *p, node->getLine(), true);
         
@@ -1216,7 +1164,7 @@ TIntermTyped* TParseContext::foldConstConstructor(TIntermAggregate* aggrNode, co
 //
 // Returns 0 for an error or the constructed node.
 //
-TIntermTyped* TParseContext::constructBuiltIn(const TType* type, TOperator op, TIntermNode* node, TSourceLoc line, bool subset)
+TIntermTyped* TParseContext::constructBuiltIn(const TType* type, TOperator op, TIntermNode* node, const TSourceLoc& line, bool subset)
 {
     TIntermTyped* newNode;
     TOperator basicOp;
@@ -1278,7 +1226,7 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType* type, TOperator op, T
 //
 // Returns 0 for an error or the input node itself if the expected and the given parameter types match.
 //
-TIntermTyped* TParseContext::constructStruct(TIntermNode* node, TType* type, int paramCount, TSourceLoc line, bool subset)
+TIntermTyped* TParseContext::constructStruct(TIntermNode* node, TType* type, int paramCount, const TSourceLoc& line, bool subset)
 {
     if (*type == node->getAsTyped()->getType()) {
         if (subset)
@@ -1305,7 +1253,7 @@ TIntermTyped* TParseContext::constructStruct(TIntermNode* node, TType* type, int
 // node or it could be the intermediate tree representation of accessing fields in a constant structure or column of 
 // a constant matrix.
 //
-TIntermTyped* TParseContext::addConstVectorNode(TVectorFields& fields, TIntermTyped* node, TSourceLoc line)
+TIntermTyped* TParseContext::addConstVectorNode(TVectorFields& fields, TIntermTyped* node, const TSourceLoc& line)
 {
     TIntermTyped* typedNode;
     TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion();
@@ -1313,7 +1261,6 @@ TIntermTyped* TParseContext::addConstVectorNode(TVectorFields& fields, TIntermTy
     ConstantUnion *unionArray;
     if (tempConstantNode) {
         unionArray = tempConstantNode->getUnionArrayPointer();
-        ASSERT(unionArray);
 
         if (!unionArray) {
             return node;
@@ -1328,7 +1275,7 @@ TIntermTyped* TParseContext::addConstVectorNode(TVectorFields& fields, TIntermTy
     ConstantUnion* constArray = new ConstantUnion[fields.num];
 
     for (int i = 0; i < fields.num; i++) {
-        if (fields.offsets[i] >= node->getType().getObjectSize()) {
+        if (fields.offsets[i] >= node->getType().getNominalSize()) {
             std::stringstream extraInfoStream;
             extraInfoStream << "vector field selection out of range '" << fields.offsets[i] << "'";
             std::string extraInfo = extraInfoStream.str();
@@ -1350,7 +1297,7 @@ TIntermTyped* TParseContext::addConstVectorNode(TVectorFields& fields, TIntermTy
 // to the function could either be a symbol node (m[0] where m is a constant matrix)that represents a 
 // constant matrix or it could be the tree representation of the constant matrix (s.m1[0] where s is a constant structure)
 //
-TIntermTyped* TParseContext::addConstMatrixNode(int index, TIntermTyped* node, TSourceLoc line)
+TIntermTyped* TParseContext::addConstMatrixNode(int index, TIntermTyped* node, const TSourceLoc& line)
 {
     TIntermTyped* typedNode;
     TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion();
@@ -1385,7 +1332,7 @@ TIntermTyped* TParseContext::addConstMatrixNode(int index, TIntermTyped* node, T
 // to the function could either be a symbol node (a[0] where a is a constant array)that represents a 
 // constant array or it could be the tree representation of the constant array (s.a1[0] where s is a constant structure)
 //
-TIntermTyped* TParseContext::addConstArrayNode(int index, TIntermTyped* node, TSourceLoc line)
+TIntermTyped* TParseContext::addConstArrayNode(int index, TIntermTyped* node, const TSourceLoc& line)
 {
     TIntermTyped* typedNode;
     TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion();
@@ -1401,9 +1348,8 @@ TIntermTyped* TParseContext::addConstArrayNode(int index, TIntermTyped* node, TS
         index = 0;
     }
 
-    int arrayElementSize = arrayElementType.getObjectSize();
-
     if (tempConstantNode) {
+         size_t arrayElementSize = arrayElementType.getObjectSize();
          ConstantUnion* unionArray = tempConstantNode->getUnionArrayPointer();
          typedNode = intermediate.addConstantUnion(&unionArray[arrayElementSize * index], tempConstantNode->getType(), line);
     } else {
@@ -1422,22 +1368,21 @@ TIntermTyped* TParseContext::addConstArrayNode(int index, TIntermTyped* node, TS
 // If there is an embedded/nested struct, it appropriately calls addConstStructNested or addConstStructFromAggr
 // function and returns the parse-tree with the values of the embedded/nested struct.
 //
-TIntermTyped* TParseContext::addConstStruct(TString& identifier, TIntermTyped* node, TSourceLoc line)
+TIntermTyped* TParseContext::addConstStruct(TString& identifier, TIntermTyped* node, const TSourceLoc& line)
 {
-    const TTypeList* fields = node->getType().getStruct();
-    TIntermTyped *typedNode;
-    int instanceSize = 0;
-    unsigned int index = 0;
-    TIntermConstantUnion *tempConstantNode = node->getAsConstantUnion();
-
-    for ( index = 0; index < fields->size(); ++index) {
-        if ((*fields)[index].type->getFieldName() == identifier) {
+    const TFieldList& fields = node->getType().getStruct()->fields();
+
+    size_t instanceSize = 0;
+    for (size_t index = 0; index < fields.size(); ++index) {
+        if (fields[index]->name() == identifier) {
             break;
         } else {
-            instanceSize += (*fields)[index].type->getObjectSize();
+            instanceSize += fields[index]->type()->getObjectSize();
         }
     }
 
+    TIntermTyped* typedNode = 0;
+    TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion();
     if (tempConstantNode) {
          ConstantUnion* constArray = tempConstantNode->getUnionArrayPointer();
 
@@ -1452,7 +1397,7 @@ TIntermTyped* TParseContext::addConstStruct(TString& identifier, TIntermTyped* n
     return typedNode;
 }
 
-bool TParseContext::enterStructDeclaration(int line, const TString& identifier)
+bool TParseContext::enterStructDeclaration(const TSourceLoc& line, const TString& identifier)
 {
     ++structNestingLevel;
 
@@ -1478,21 +1423,21 @@ const int kWebGLMaxStructNesting = 4;
 
 }  // namespace
 
-bool TParseContext::structNestingErrorCheck(TSourceLoc line, const TType& fieldType)
+bool TParseContext::structNestingErrorCheck(const TSourceLoc& line, const TField& field)
 {
     if (!isWebGLBasedSpec(shaderSpec)) {
         return false;
     }
 
-    if (fieldType.getBasicType() != EbtStruct) {
+    if (field.type()->getBasicType() != EbtStruct) {
         return false;
     }
 
     // We're already inside a structure definition at this point, so add
     // one to the field's struct nesting.
-    if (1 + fieldType.getDeepestStructNesting() > kWebGLMaxStructNesting) {
+    if (1 + field.type()->getDeepestStructNesting() > kWebGLMaxStructNesting) {
         std::stringstream extraInfoStream;
-        extraInfoStream << "Reference of struct type " << fieldType.getTypeName() 
+        extraInfoStream << "Reference of struct type " << field.name()
                         << " exceeds maximum struct nesting of " << kWebGLMaxStructNesting;
         std::string extraInfo = extraInfoStream.str();
         error(line, "", "", extraInfo.c_str());
index 26a3ea1..b2025b8 100644 (file)
@@ -33,10 +33,8 @@ struct TParseContext {
             compileOptions(options),
             sourcePath(sourcePath),
             treeRoot(0),
-            lexAfterType(false),
             loopNestingLevel(0),
             structNestingLevel(0),
-            inTypeParen(false),
             currentFunctionType(NULL),
             functionReturnsValue(false),
             checksPrecisionErrors(checksPrecErrors),
@@ -51,16 +49,13 @@ struct TParseContext {
     int compileOptions;
     const char* sourcePath;      // Path of source file or NULL.
     TIntermNode* treeRoot;       // root of parse tree being created
-    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 structNestingLevel;      // incremented while parsing a struct declaration
-    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
     bool functionReturnsValue;   // true if a non-void function has a return
     bool checksPrecisionErrors;  // true if an error will be generated when a variable is declared without precision, explicit or implicit.
     bool fragmentPrecisionHigh;  // true if highp precision is supported in the fragment language.
     TString HashErrMsg;
-    bool AfterEOF;
     TDiagnostics diagnostics;
     TDirectiveHandler directiveHandler;
     pp::Preprocessor preprocessor;
@@ -68,71 +63,68 @@ struct TParseContext {
 
     int numErrors() const { return diagnostics.numErrors(); }
     TInfoSink& infoSink() { return diagnostics.infoSink(); }
-    void error(TSourceLoc loc, const char *reason, const char* token,
+    void error(const TSourceLoc& loc, const char *reason, const char* token,
                const char* extraInfo="");
-    void warning(TSourceLoc loc, const char* reason, const char* token,
+    void warning(const TSourceLoc& loc, const char* reason, const char* token,
                  const char* extraInfo="");
     void trace(const char* str);
     void recover();
 
-    bool parseVectorFields(const TString&, int vecSize, TVectorFields&, int line);
-    bool parseMatrixFields(const TString&, int matSize, TMatrixFields&, int line);
+    bool parseVectorFields(const TString&, int vecSize, TVectorFields&, const TSourceLoc& line);
+    bool parseMatrixFields(const TString&, int matSize, TMatrixFields&, const TSourceLoc& line);
 
-    bool reservedErrorCheck(int line, const TString& identifier);
-    void assignError(int line, const char* op, TString left, TString right);
-    void unaryOpError(int line, const char* op, TString operand);
-    void binaryOpError(int line, const char* op, TString left, TString right);
-    bool precisionErrorCheck(int line, TPrecision precision, TBasicType type);
-    bool lValueErrorCheck(int line, const char* op, TIntermTyped*);
+    bool reservedErrorCheck(const TSourceLoc& line, const TString& identifier);
+    void assignError(const TSourceLoc& line, const char* op, TString left, TString right);
+    void unaryOpError(const TSourceLoc& line, const char* op, TString operand);
+    void binaryOpError(const TSourceLoc& line, const char* op, TString left, TString right);
+    bool precisionErrorCheck(const TSourceLoc& line, TPrecision precision, TBasicType type);
+    bool lValueErrorCheck(const TSourceLoc& line, const char* op, TIntermTyped*);
     bool constErrorCheck(TIntermTyped* node);
     bool integerErrorCheck(TIntermTyped* node, const char* token);
-    bool globalErrorCheck(int line, bool global, const char* token);
-    bool constructorErrorCheck(int line, TIntermNode*, TFunction&, TOperator, TType*);
-    bool arraySizeErrorCheck(int line, TIntermTyped* expr, int& size);
-    bool arrayQualifierErrorCheck(int line, TPublicType type);
-    bool arrayTypeErrorCheck(int line, TPublicType type);
-    bool arrayErrorCheck(int line, TString& identifier, TPublicType type, TVariable*& variable);
-    bool voidErrorCheck(int, const TString&, const TPublicType&);
-    bool boolErrorCheck(int, const TIntermTyped*);
-    bool boolErrorCheck(int, const TPublicType&);
-    bool samplerErrorCheck(int line, const TPublicType& pType, const char* reason);
-    bool structQualifierErrorCheck(int line, const TPublicType& pType);
-    bool parameterSamplerErrorCheck(int line, TQualifier qualifier, const TType& type);
-    bool nonInitConstErrorCheck(int line, TString& identifier, TPublicType& type, bool array);
-    bool nonInitErrorCheck(int line, TString& identifier, TPublicType& type, TVariable*& variable);
-    bool paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type);
-    bool extensionErrorCheck(int line, const TString&);
+    bool globalErrorCheck(const TSourceLoc& line, bool global, const char* token);
+    bool constructorErrorCheck(const TSourceLoc& line, TIntermNode*, TFunction&, TOperator, TType*);
+    bool arraySizeErrorCheck(const TSourceLoc& line, TIntermTyped* expr, int& size);
+    bool arrayQualifierErrorCheck(const TSourceLoc& line, TPublicType type);
+    bool arrayTypeErrorCheck(const TSourceLoc& line, TPublicType type);
+    bool arrayErrorCheck(const TSourceLoc& line, TString& identifier, TPublicType type, TVariable*& variable);
+    bool voidErrorCheck(const TSourceLoc&, const TString&, const TPublicType&);
+    bool boolErrorCheck(const TSourceLoc&, const TIntermTyped*);
+    bool boolErrorCheck(const TSourceLoc&, const TPublicType&);
+    bool samplerErrorCheck(const TSourceLoc& line, const TPublicType& pType, const char* reason);
+    bool structQualifierErrorCheck(const TSourceLoc& line, const TPublicType& pType);
+    bool parameterSamplerErrorCheck(const TSourceLoc& line, TQualifier qualifier, const TType& type);
+    bool nonInitConstErrorCheck(const TSourceLoc& line, TString& identifier, TPublicType& type, bool array);
+    bool nonInitErrorCheck(const TSourceLoc& line, TString& identifier, TPublicType& type, TVariable*& variable);
+    bool paramErrorCheck(const TSourceLoc& line, TQualifier qualifier, TQualifier paramQualifier, TType* type);
+    bool extensionErrorCheck(const TSourceLoc& line, const TString&);
 
+    const TPragma& pragma() const { return directiveHandler.pragma(); }
     const TExtensionBehavior& extensionBehavior() const { return directiveHandler.extensionBehavior(); }
     bool supportsExtension(const char* extension);
-    void handleExtensionDirective(int line, const char* extName, const char* behavior);
-
-    const TPragma& pragma() const { return directiveHandler.pragma(); }
-    void handlePragmaDirective(int line, const char* name, const char* value);
 
     bool containsSampler(TType& type);
     bool areAllChildConst(TIntermAggregate* aggrNode);
-    const TFunction* findFunction(int line, TFunction* pfnCall, bool *builtIn = 0);
-    bool executeInitializer(TSourceLoc line, TString& identifier, TPublicType& pType,
+    const TFunction* findFunction(const TSourceLoc& line, TFunction* pfnCall, bool *builtIn = 0);
+    bool isVariableBuiltIn(const TVariable* pVar);
+    bool executeInitializer(const TSourceLoc& line, TString& identifier, TPublicType& pType,
                             TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable = 0);
-    bool arraySetMaxSize(TIntermSymbol*, TType*, int, bool, TSourceLoc);
 
-    TIntermTyped* addConstructor(TIntermNode*, const TType*, TOperator, TFunction*, TSourceLoc);
+    TIntermTyped* addConstructor(TIntermNode*, const TType*, TOperator, TFunction*, const TSourceLoc&);
     TIntermTyped* foldConstConstructor(TIntermAggregate* aggrNode, const TType& type);
-    TIntermTyped* constructStruct(TIntermNode*, TType*, int, TSourceLoc, bool subset);
-    TIntermTyped* constructBuiltIn(const TType*, TOperator, TIntermNode*, TSourceLoc, bool subset);
-    TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, TSourceLoc);
-    TIntermTyped* addConstMatrixNode(int , TIntermTyped*, TSourceLoc);
-    TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, TSourceLoc line);
-    TIntermTyped* addConstStruct(TString& , TIntermTyped*, TSourceLoc);
+    TIntermTyped* constructStruct(TIntermNode*, TType*, int, const TSourceLoc&, bool subset);
+    TIntermTyped* constructBuiltIn(const TType*, TOperator, TIntermNode*, const TSourceLoc&, bool subset);
+    TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, const TSourceLoc&);
+    TIntermTyped* addConstMatrixNode(int , TIntermTyped*, const TSourceLoc&);
+    TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, const TSourceLoc& line);
+    TIntermTyped* addConstStruct(TString& , TIntermTyped*, const TSourceLoc&);
 
     // Performs an error check for embedded struct declarations.
     // Returns true if an error was raised due to the declaration of
     // this struct.
-    bool enterStructDeclaration(TSourceLoc line, const TString& identifier);
+    bool enterStructDeclaration(const TSourceLoc& line, const TString& identifier);
     void exitStructDeclaration();
 
-    bool structNestingErrorCheck(TSourceLoc line, const TType& fieldType);
+    bool structNestingErrorCheck(const TSourceLoc& line, const TField& field);
 };
 
 int PaParseStrings(size_t count, const char* const string[], const int length[],
index 9ef4f59..3f0f5a6 100644 (file)
@@ -228,24 +228,27 @@ void TPoolAllocator::popAll()
 
 void* TPoolAllocator::allocate(size_t numBytes)
 {
+    //
+    // Just keep some interesting statistics.
+    //
+    ++numCalls;
+    totalBytes += numBytes;
+
     // If we are using guard blocks, all allocations are bracketed by
     // them: [guardblock][allocation][guardblock].  numBytes is how
     // much memory the caller asked for.  allocationSize is the total
     // size including guard blocks.  In release build,
     // guardBlockSize=0 and this all gets optimized away.
     size_t allocationSize = TAllocation::allocationSize(numBytes);
-    
-    //
-    // Just keep some interesting statistics.
-    //
-    ++numCalls;
-    totalBytes += numBytes;
+    // Detect integer overflow.
+    if (allocationSize < numBytes)
+        return 0;
 
     //
     // Do the allocation, most likely case first, for efficiency.
     // This step could be moved to be inline sometime.
     //
-    if (currentPageOffset + allocationSize <= pageSize) {
+    if (allocationSize <= pageSize - currentPageOffset) {
         //
         // Safe to allocate from currentPageOffset.
         //
@@ -256,12 +259,16 @@ void* TPoolAllocator::allocate(size_t numBytes)
         return initializeAllocation(inUseList, memory, numBytes);
     }
 
-    if (allocationSize + headerSkip > pageSize) {
+    if (allocationSize > pageSize - headerSkip) {
         //
         // Do a multi-page allocation.  Don't mix these with the others.
         // The OS is efficient and allocating and free-ing multiple pages.
         //
         size_t numBytesToAlloc = allocationSize + headerSkip;
+        // Detect integer overflow.
+        if (numBytesToAlloc < allocationSize)
+            return 0;
+
         tHeader* memory = reinterpret_cast<tHeader*>(::new char[numBytesToAlloc]);
         if (memory == 0)
             return 0;
index daecd86..f863e54 100644 (file)
@@ -81,8 +81,8 @@ protected:
     bool InitBuiltInSymbolTable(const ShBuiltInResources& resources);
     // Clears the results from the previous compilation.
     void clearResults();
-    // Return true if function recursion is detected.
-    bool detectRecursion(TIntermNode* root);
+    // Return true if function recursion is detected or call depth exceeded.
+    bool detectCallDepth(TIntermNode* root, TInfoSink& infoSink, bool limitCallStackDepth);
     // Rewrites a shader's intermediate tree according to the CSS Shaders spec.
     void rewriteCSSShader(TIntermNode* root);
     // Returns true if the given shader does not exceed the minimum
@@ -104,6 +104,8 @@ protected:
     // Returns true if the shader does not use sampler dependent values to affect control 
     // flow or in operations whose time can depend on the input values.
     bool enforceFragmentShaderTimingRestrictions(const TDependencyGraph& graph);
+    // Return true if the maximum expression complexity below the limit.
+    bool limitExpressionComplexity(TIntermNode* root);
     // Get built-in extensions with default behavior.
     const TExtensionBehavior& getExtensionBehavior() const;
 
@@ -116,6 +118,8 @@ private:
     ShShaderSpec shaderSpec;
 
     int maxUniformVectors;
+    int maxExpressionComplexity;
+    int maxCallStackDepth;
 
     // Built-in symbol table for the given language, spec, and resources.
     // It is preserved from compile-to-compile.
index dcf8b96..a67a627 100644 (file)
@@ -126,6 +126,7 @@ void ShInitBuiltInResources(ShBuiltInResources* resources)
     resources->OES_EGL_image_external = 0;
     resources->ARB_texture_rectangle = 0;
     resources->EXT_draw_buffers = 0;
+    resources->EXT_frag_depth = 0;
 
     // Disable highp precision in fragment shader by default.
     resources->FragmentPrecisionHigh = 0;
index 847c1e4..51180af 100644 (file)
 
 #include <stdio.h>
 #include <algorithm>
-
-#include "common/angleutils.h"
+#include <climits>
 
 TType::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),
-            maxArraySize(0), arrayInformationType(0), structure(0), structureSize(0), deepestStructNesting(0), fieldName(0), mangled(0), typeName(0)
+            type(p.type), precision(p.precision), qualifier(p.qualifier), size(p.size), matrix(p.matrix), array(p.array), arraySize(p.arraySize), structure(0)
 {
-    if (p.userDef) {
+    if (p.userDef)
         structure = p.userDef->getStruct();
-        typeName = NewPoolTString(p.userDef->getTypeName().c_str());
-        computeDeepestStructNesting();
-    }
 }
 
 //
 // Recursively generate mangled names.
 //
-void TType::buildMangledName(TString& mangledName)
+TString TType::buildMangledName() const
 {
+    TString mangledName;
     if (isMatrix())
         mangledName += 'm';
     else if (isVector())
         mangledName += 'v';
 
     switch (type) {
-    case EbtFloat:              mangledName += 'f';      break;
-    case EbtInt:                mangledName += 'i';      break;
-    case EbtBool:               mangledName += 'b';      break;
-    case EbtSampler2D:          mangledName += "s2";     break;
-    case EbtSamplerCube:        mangledName += "sC";     break;
-    case EbtStruct:
-        mangledName += "struct-";
-        if (typeName)
-            mangledName += *typeName;
-        {// support MSVC++6.0
-            for (unsigned int i = 0; i < structure->size(); ++i) {
-                mangledName += '-';
-                (*structure)[i].type->buildMangledName(mangledName);
-            }
-        }
-    default:
-        break;
+    case EbtFloat:       mangledName += 'f';      break;
+    case EbtInt:         mangledName += 'i';      break;
+    case EbtBool:        mangledName += 'b';      break;
+    case EbtSampler2D:   mangledName += "s2";     break;
+    case EbtSamplerCube: mangledName += "sC";     break;
+    case EbtStruct:      mangledName += structure->mangledName(); break;
+    default:             break;
     }
 
     mangledName += static_cast<char>('0' + getNominalSize());
@@ -69,53 +55,72 @@ void TType::buildMangledName(TString& mangledName)
         mangledName += buf;
         mangledName += ']';
     }
+    return mangledName;
 }
 
-int TType::getStructSize() const
+size_t TType::getObjectSize() const
 {
-    if (!getStruct()) {
-        assert(false && "Not a struct");
-        return 0;
-    }
+    size_t totalSize = 0;
 
-    if (structureSize == 0)
-        for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++)
-            structureSize += ((*tl).type)->getObjectSize();
+    if (getBasicType() == EbtStruct)
+        totalSize = structure->objectSize();
+    else if (matrix)
+        totalSize = size * size;
+    else
+        totalSize = size;
+
+    if (isArray()) {
+        size_t arraySize = getArraySize();
+        if (arraySize > INT_MAX / totalSize)
+            totalSize = INT_MAX;
+        else
+            totalSize *= arraySize;
+    }
 
-    return structureSize;
+    return totalSize;
 }
 
-void TType::computeDeepestStructNesting()
+bool TStructure::containsArrays() const
 {
-    if (!getStruct()) {
-        return;
+    for (size_t i = 0; i < mFields->size(); ++i) {
+        const TType* fieldType = (*mFields)[i]->type();
+        if (fieldType->isArray() || fieldType->isStructureContainingArrays())
+            return true;
     }
+    return false;
+}
 
-    int maxNesting = 0;
-    for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); ++tl) {
-        maxNesting = std::max(maxNesting, ((*tl).type)->getDeepestStructNesting());
+TString TStructure::buildMangledName() const
+{
+    TString mangledName("struct-");
+    mangledName += *mName;
+    for (size_t i = 0; i < mFields->size(); ++i) {
+        mangledName += '-';
+        mangledName += (*mFields)[i]->type()->getMangledName();
     }
-
-    deepestStructNesting = 1 + maxNesting;
+    return mangledName;
 }
 
-bool TType::isStructureContainingArrays() const
+size_t TStructure::calculateObjectSize() const
 {
-    if (!structure)
-    {
-        return false;
+    size_t size = 0;
+    for (size_t i = 0; i < mFields->size(); ++i) {
+        size_t fieldSize = (*mFields)[i]->type()->getObjectSize();
+        if (fieldSize > INT_MAX - size)
+            size = INT_MAX;
+        else
+            size += fieldSize;
     }
+    return size;
+}
 
-    for (TTypeList::const_iterator member = structure->begin(); member != structure->end(); member++)
-    {
-        if (member->type->isArray() ||
-            member->type->isStructureContainingArrays())
-        {
-            return true;
-        }
+int TStructure::calculateDeepestNesting() const
+{
+    int maxNesting = 0;
+    for (size_t i = 0; i < mFields->size(); ++i) {
+        maxNesting = std::max(maxNesting, (*mFields)[i]->type()->getDeepestStructNesting());
     }
-
-    return false;
+    return 1 + maxNesting;
 }
 
 //
@@ -196,84 +201,8 @@ void TSymbolTableLevel::relateToOperator(const char* name, TOperator op)
 void TSymbolTableLevel::relateToExtension(const char* name, const TString& ext)
 {
     for (tLevel::iterator it = level.begin(); it != level.end(); ++it) {
-        if (it->second->isFunction()) {
-            TFunction* function = static_cast<TFunction*>(it->second);
-            if (function->getName() == name)
-                function->relateToExtension(ext);
-        }
-    }
-}
-
-TSymbol::TSymbol(const TSymbol& copyOf)
-{
-    name = NewPoolTString(copyOf.name->c_str());
-    uniqueId = copyOf.uniqueId;
-}
-
-TVariable::TVariable(const TVariable& copyOf, TStructureMap& remapper) : TSymbol(copyOf)
-{
-    type.copyType(copyOf.type, remapper);
-    userType = copyOf.userType;
-    // for builtIn symbol table level, unionArray and arrayInformation pointers should be NULL
-    assert(copyOf.arrayInformationType == 0);
-    arrayInformationType = 0;
-
-    if (copyOf.unionArray) {
-        assert(!copyOf.type.getStruct());
-        assert(copyOf.type.getObjectSize() == 1);
-        unionArray = new ConstantUnion[1];
-        unionArray[0] = copyOf.unionArray[0];
-    } else
-        unionArray = 0;
-}
-
-TVariable* TVariable::clone(TStructureMap& remapper)
-{
-    TVariable *variable = new TVariable(*this, remapper);
-
-    return variable;
-}
-
-TFunction::TFunction(const TFunction& copyOf, TStructureMap& remapper) : TSymbol(copyOf)
-{
-    for (unsigned int i = 0; i < copyOf.parameters.size(); ++i) {
-        TParameter param;
-        parameters.push_back(param);
-        parameters.back().copyParam(copyOf.parameters[i], remapper);
-    }
-
-    returnType.copyType(copyOf.returnType, remapper);
-    mangledName = copyOf.mangledName;
-    op = copyOf.op;
-    defined = copyOf.defined;
-}
-
-TFunction* TFunction::clone(TStructureMap& remapper)
-{
-    TFunction *function = new TFunction(*this, remapper);
-
-    return function;
-}
-
-TSymbolTableLevel* TSymbolTableLevel::clone(TStructureMap& remapper)
-{
-    TSymbolTableLevel *symTableLevel = new TSymbolTableLevel();
-    tLevel::iterator iter;
-    for (iter = level.begin(); iter != level.end(); ++iter) {
-        symTableLevel->insert(*iter->second->clone(remapper));
-    }
-
-    return symTableLevel;
-}
-
-void TSymbolTable::copyTable(const TSymbolTable& copyOf)
-{
-    TStructureMap remapper;
-    uniqueId = copyOf.uniqueId;
-    for (unsigned int i = 0; i < copyOf.table.size(); ++i) {
-        table.push_back(copyOf.table[i]->clone(remapper));
-    }
-    for( unsigned int i = 0; i < copyOf.precisionStack.size(); i++) {
-        precisionStack.push_back( copyOf.precisionStack[i] );
+        TSymbol* symbol = it->second;
+        if (symbol->getName() == name)
+            symbol->relateToExtension(ext);
     }
 }
index d27aa33..f6e1959 100644 (file)
@@ -32,6 +32,7 @@
 
 #include <assert.h>
 
+#include "common/angleutils.h"
 #include "compiler/InfoSink.h"
 #include "compiler/intermediate.h"
 
@@ -49,13 +50,16 @@ public:
     virtual bool isVariable() const { return false; }
     void setUniqueId(int id) { uniqueId = id; }
     int getUniqueId() const { return uniqueId; }
-    virtual void dump(TInfoSink &infoSink) const = 0;  
-    TSymbol(const TSymbol&);
-    virtual TSymbol* clone(TStructureMap& remapper) = 0;
+    virtual void dump(TInfoSink &infoSink) const = 0;
+    void relateToExtension(const TString& ext) { extension = ext; }
+    const TString& getExtension() const { return extension; }
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(TSymbol);
 
-protected:
     const TString *name;
     unsigned int uniqueId;      // For real comparing during code generation
+    TString extension;
 };
 
 //
@@ -70,15 +74,13 @@ protected:
 //
 class TVariable : public TSymbol {
 public:
-    TVariable(const TString *name, const TType& t, bool uT = false ) : TSymbol(name), type(t), userType(uT), unionArray(0), arrayInformationType(0) { }
+    TVariable(const TString *name, const TType& t, bool uT = false ) : TSymbol(name), type(t), userType(uT), unionArray(0) { }
     virtual ~TVariable() { }
     virtual bool isVariable() const { return true; }    
     TType& getType() { return type; }    
     const TType& getType() const { return type; }
     bool isUserType() const { return userType; }
     void setQualifier(TQualifier qualifier) { type.setQualifier(qualifier); }
-    void updateArrayInformationType(TType *t) { arrayInformationType = t; }
-    TType* getArrayInformationType() { return arrayInformationType; }
 
     virtual void dump(TInfoSink &infoSink) const;
 
@@ -100,16 +102,15 @@ public:
         delete[] unionArray;
         unionArray = constArray;  
     }
-    TVariable(const TVariable&, TStructureMap& remapper); // copy constructor
-    virtual TVariable* clone(TStructureMap& remapper);
 
-protected:
+private:
+    DISALLOW_COPY_AND_ASSIGN(TVariable);
+
     TType type;
     bool userType;
     // we are assuming that Pool Allocator will free the memory allocated to unionArray
     // when this object is destroyed
     ConstantUnion *unionArray;
-    TType *arrayInformationType;  // this is used for updating maxArraySize in all the references to a given symbol
 };
 
 //
@@ -119,11 +120,6 @@ protected:
 struct TParameter {
     TString *name;
     TType* type;
-    void copyParam(const TParameter& param, TStructureMap& remapper)
-    {
-        name = NewPoolTString(param.name->c_str());
-        type = param.type->clone(remapper);
-    }
 };
 
 //
@@ -163,9 +159,6 @@ public:
     void relateToOperator(TOperator o) { op = o; }
     TOperator getBuiltInOp() const { return op; }
 
-    void relateToExtension(const TString& ext) { extension = ext; }
-    const TString& getExtension() const { return extension; }
-
     void setDefined() { defined = true; }
     bool isDefined() { return defined; }
 
@@ -173,16 +166,15 @@ public:
     const TParameter& getParam(size_t i) const { return parameters[i]; }
 
     virtual void dump(TInfoSink &infoSink) const;
-    TFunction(const TFunction&, TStructureMap& remapper);
-    virtual TFunction* clone(TStructureMap& remapper);
 
-protected:
+private:
+    DISALLOW_COPY_AND_ASSIGN(TFunction);
+
     typedef TVector<TParameter> TParamList;
     TParamList parameters;
     TType returnType;
     TString mangledName;
     TOperator op;
-    TString extension;
     bool defined;
 };
 
@@ -231,7 +223,6 @@ public:
     void relateToOperator(const char* name, TOperator op);
     void relateToExtension(const char* name, const TString& ext);
     void dump(TInfoSink &infoSink) const;
-    TSymbolTableLevel* clone(TStructureMap& remapper);
 
 protected:
     tLevel level;
@@ -321,7 +312,6 @@ public:
     }
     int getMaxSymbolId() { return uniqueId; }
     void dump(TInfoSink &infoSink) const;
-    void copyTable(const TSymbolTable& copyOf);
 
     bool setDefaultPrecision( const TPublicType& type, TPrecision prec ){
         if (IsSampler(type.type))
index d457667..3846e6c 100644 (file)
@@ -7,30 +7,85 @@
 #ifndef _TYPES_INCLUDED
 #define _TYPES_INCLUDED
 
+#include "common/angleutils.h"
+
 #include "compiler/BaseTypes.h"
 #include "compiler/Common.h"
 #include "compiler/debug.h"
 
-class TType;
 struct TPublicType;
+class TType;
 
-//
-// Need to have association of line numbers to types in a list for building structs.
-//
-struct TTypeLine {
-    TType* type;
-    int line;
+class TField
+{
+public:
+    POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator);
+    TField(TType* type, TString* name) : mType(type), mName(name) {}
+
+    // TODO(alokp): We should only return const type.
+    // Fix it by tweaking grammar.
+    TType* type() { return mType; }
+    const TType* type() const { return mType; }
+
+    const TString& name() const { return *mName; }
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(TField);
+    TType* mType;
+    TString* mName;
 };
-typedef TVector<TTypeLine> TTypeList;
 
-inline TTypeList* NewPoolTTypeList()
+typedef TVector<TField*> TFieldList;
+inline TFieldList* NewPoolTFieldList()
 {
-    void* memory = GlobalPoolAllocator.allocate(sizeof(TTypeList));
-    return new(memory) TTypeList;
+    void* memory = GlobalPoolAllocator.allocate(sizeof(TFieldList));
+    return new(memory) TFieldList;
 }
 
-typedef TMap<TTypeList*, TTypeList*> TStructureMap;
-typedef TMap<TTypeList*, TTypeList*>::iterator TStructureMapIterator;
+class TStructure
+{
+public:
+    POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator);
+    TStructure(TString* name, TFieldList* fields)
+        : mName(name),
+          mFields(fields),
+          mObjectSize(0),
+          mDeepestNesting(0) {
+    }
+
+    const TString& name() const { return *mName; }
+    const TFieldList& fields() const { return *mFields; }
+
+    const TString& mangledName() const {
+        if (mMangledName.empty())
+            mMangledName = buildMangledName();
+        return mMangledName;
+    }
+    size_t objectSize() const {
+        if (mObjectSize == 0)
+            mObjectSize = calculateObjectSize();
+        return mObjectSize;
+    };
+    int deepestNesting() const {
+        if (mDeepestNesting == 0)
+            mDeepestNesting = calculateDeepestNesting();
+        return mDeepestNesting;
+    }
+    bool containsArrays() const;
+
+private:
+    DISALLOW_COPY_AND_ASSIGN(TStructure);
+    TString buildMangledName() const;
+    size_t calculateObjectSize() const;
+    int calculateDeepestNesting() const;
+
+    TString* mName;
+    TFieldList* mFields;
+
+    mutable TString mMangledName;
+    mutable size_t mObjectSize;
+    mutable int mDeepestNesting;
+};
 
 //
 // Base class for things that have a type.
@@ -41,69 +96,13 @@ public:
     POOL_ALLOCATOR_NEW_DELETE(GlobalPoolAllocator)
     TType() {}
     TType(TBasicType t, TPrecision p, TQualifier q = EvqTemporary, int s = 1, bool m = false, bool a = false) :
-            type(t), precision(p), qualifier(q), size(s), matrix(m), array(a), arraySize(0),
-            maxArraySize(0), arrayInformationType(0), structure(0), structureSize(0), deepestStructNesting(0), fieldName(0), mangled(0), typeName(0)
+            type(t), precision(p), qualifier(q), size(s), matrix(m), array(a), arraySize(0), structure(0)
     {
     }
     explicit TType(const TPublicType &p);
-    TType(TTypeList* userDef, const TString& n, TPrecision p = EbpUndefined) :
-            type(EbtStruct), precision(p), qualifier(EvqTemporary), size(1), matrix(false), array(false), arraySize(0),
-            maxArraySize(0), arrayInformationType(0), structure(userDef), structureSize(0), deepestStructNesting(0), fieldName(0), mangled(0)
-    {
-        typeName = NewPoolTString(n.c_str());
-    }
-
-    void copyType(const TType& copyOf, TStructureMap& remapper)
+    TType(TStructure* userDef, TPrecision p = EbpUndefined) :
+            type(EbtStruct), precision(p), qualifier(EvqTemporary), size(1), matrix(false), array(false), arraySize(0), structure(userDef)
     {
-        type = copyOf.type;
-        precision = copyOf.precision;
-        qualifier = copyOf.qualifier;
-        size = copyOf.size;
-        matrix = copyOf.matrix;
-        array = copyOf.array;
-        arraySize = copyOf.arraySize;
-
-        TStructureMapIterator iter;
-        if (copyOf.structure) {
-            if ((iter = remapper.find(structure)) == remapper.end()) {
-                // create the new structure here
-                structure = NewPoolTTypeList();
-                for (unsigned int i = 0; i < copyOf.structure->size(); ++i) {
-                    TTypeLine typeLine;
-                    typeLine.line = (*copyOf.structure)[i].line;
-                    typeLine.type = (*copyOf.structure)[i].type->clone(remapper);
-                    structure->push_back(typeLine);
-                }
-            } else {
-                structure = iter->second;
-            }
-        } else
-            structure = 0;
-
-        fieldName = 0;
-        if (copyOf.fieldName)
-            fieldName = NewPoolTString(copyOf.fieldName->c_str());
-        typeName = 0;
-        if (copyOf.typeName)
-            typeName = NewPoolTString(copyOf.typeName->c_str());
-
-        mangled = 0;
-        if (copyOf.mangled)
-            mangled = NewPoolTString(copyOf.mangled->c_str());
-
-        structureSize = copyOf.structureSize;
-        maxArraySize = copyOf.maxArraySize;
-        deepestStructNesting = copyOf.deepestStructNesting;
-        assert(copyOf.arrayInformationType == 0);
-        arrayInformationType = 0; // arrayInformationType should not be set for builtIn symbol table level
-    }
-
-    TType* clone(TStructureMap& remapper)
-    {
-        TType *newType = new TType();
-        newType->copyType(*this, remapper);
-
-        return newType;
     }
 
     TBasicType getBasicType() const { return type; }
@@ -119,22 +118,7 @@ public:
     int getNominalSize() const { return size; }
     void setNominalSize(int s) { size = s; }
     // Full size of single instance of type
-    int getObjectSize() const
-    {
-        int totalSize;
-
-        if (getBasicType() == EbtStruct)
-            totalSize = getStructSize();
-        else if (matrix)
-            totalSize = size * size;
-        else
-            totalSize = size;
-
-        if (isArray())
-            totalSize *= std::max(getArraySize(), getMaxArraySize());
-
-        return totalSize;
-    }
+    size_t getObjectSize() const;
 
     bool isMatrix() const { return matrix ? true : false; }
     void setMatrix(bool m) { matrix = m; }
@@ -142,47 +126,20 @@ public:
     bool isArray() const  { return array ? true : false; }
     int getArraySize() const { return arraySize; }
     void setArraySize(int s) { array = true; arraySize = s; }
-    int getMaxArraySize () const { return maxArraySize; }
-    void setMaxArraySize (int s) { maxArraySize = s; }
-    void clearArrayness() { array = false; arraySize = 0; maxArraySize = 0; }
-    void setArrayInformationType(TType* t) { arrayInformationType = t; }
-    TType* getArrayInformationType() const { return arrayInformationType; }
+    void clearArrayness() { array = false; arraySize = 0; }
 
     bool isVector() const { return size > 1 && !matrix; }
     bool isScalar() const { return size == 1 && !matrix && !structure; }
 
-    TTypeList* getStruct() const { return structure; }
-    void setStruct(TTypeList* s) { structure = s; computeDeepestStructNesting(); }
-
-    const TString& getTypeName() const
-    {
-        assert(typeName);
-        return *typeName;
-    }
-    void setTypeName(const TString& n)
-    {
-        typeName = NewPoolTString(n.c_str());
-    }
-
-    bool isField() const { return fieldName != 0; }
-    const TString& getFieldName() const
-    {
-        assert(fieldName);
-        return *fieldName;
-    }
-    void setFieldName(const TString& n)
-    {
-        fieldName = NewPoolTString(n.c_str());
-    }
+    TStructure* getStruct() const { return structure; }
+    void setStruct(TStructure* s) { structure = s; }
 
-    TString& getMangledName() {
-        if (!mangled) {
-            mangled = NewPoolTString("");
-            buildMangledName(*mangled);
-            *mangled += ';' ;
+    const TString& getMangledName() const {
+        if (mangled.empty()) {
+            mangled = buildMangledName();
+            mangled += ';';
         }
-
-        return *mangled;
+        return mangled;
     }
 
     bool sameElementType(const TType& right) const {
@@ -230,32 +187,34 @@ public:
     // For type "nesting2", this method would return 2 -- the number
     // of structures through which indirection must occur to reach the
     // deepest field (nesting2.field1.position).
-    int getDeepestStructNesting() const { return deepestStructNesting; }
+    int getDeepestStructNesting() const {
+        return structure ? structure->deepestNesting() : 0;
+    }
 
-    bool isStructureContainingArrays() const;
+    bool isStructureContainingArrays() const {
+        return structure ? structure->containsArrays() : false;
+    }
 
-protected:
-    void buildMangledName(TString&);
-    int getStructSize() const;
-    void computeDeepestStructNesting();
+private:
+    TString buildMangledName() const;
 
+#ifdef __GNUC__
+    TBasicType type;
+    TPrecision precision;
+    TQualifier qualifier;
+#else
     TBasicType type      : 6;
     TPrecision precision;
     TQualifier qualifier : 7;
+#endif
     int size             : 8; // size of vector or matrix, not size of array
     unsigned int matrix  : 1;
     unsigned int array   : 1;
     int arraySize;
-    int maxArraySize;
-    TType* arrayInformationType;
 
-    TTypeList* structure;      // 0 unless this is a struct
-    mutable int structureSize;
-    int deepestStructNesting;
+    TStructure* structure;      // 0 unless this is a struct
 
-    TString *fieldName;         // for structure field names
-    TString *mangled;
-    TString *typeName;          // for structure field type name
+    mutable TString mangled;
 };
 
 //
@@ -277,9 +236,9 @@ struct TPublicType
     bool array;
     int arraySize;
     TType* userDef;
-    int line;
+    TSourceLoc line;
 
-    void setBasic(TBasicType bt, TQualifier q, int ln = 0)
+    void setBasic(TBasicType bt, TQualifier q, const TSourceLoc& ln)
     {
         type = bt;
         qualifier = q;
index eb6bea9..84db807 100644 (file)
@@ -131,12 +131,13 @@ void getUserDefinedVariableInfo(const TType& type,
 {
     ASSERT(type.getBasicType() == EbtStruct);
 
-    const TTypeList* structure = type.getStruct();
-    for (size_t i = 0; i < structure->size(); ++i) {
-        const TType* fieldType = (*structure)[i].type;
-        getVariableInfo(*fieldType,
-                        name + "." + fieldType->getFieldName(),
-                        mappedName + "." + TIntermTraverser::hash(fieldType->getFieldName(), hashFunction),
+    const TFieldList& fields = type.getStruct()->fields();
+    for (size_t i = 0; i < fields.size(); ++i) {
+        const TType& fieldType = *(fields[i]->type());
+        const TString& fieldName = fields[i]->name();
+        getVariableInfo(fieldType,
+                        name + "." + fieldName,
+                        mappedName + "." + TIntermTraverser::hash(fieldName, hashFunction),
                         infoList,
                         hashFunction);
     }
diff --git a/Source/ThirdParty/ANGLE/src/compiler/builtin_symbol_table.cpp b/Source/ThirdParty/ANGLE/src/compiler/builtin_symbol_table.cpp
new file mode 100644 (file)
index 0000000..920c824
--- /dev/null
@@ -0,0 +1,289 @@
+// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// *************************************************************
+// This file is generated by generate_builtin_symbol_table.py.
+//                 * DO NOT HAND MODIFY *
+// *************************************************************
+#include "compiler/builtin_symbol_table.h"
+#include "compiler/SymbolTable.h"
+
+static void builtin1(TSymbolTable* t, TType* rvalue, const char* name, TType* ptype1, const char* pname1)
+{
+  TFunction* f = new TFunction(new TString(name), *rvalue);
+  TParameter param = {new TString(pname1), ptype1};
+  f->addParameter(param);
+  t->insert(*f);
+}
+
+static void builtin2(TSymbolTable* t, TType* rvalue, const char* name, TType* ptype1, const char* pname1, TType* ptype2, const char* pname2)
+{
+  TFunction* f = new TFunction(new TString(name), *rvalue);
+  TParameter param1 = {new TString(pname1), ptype1};
+  f->addParameter(param1);
+  TParameter param2 = {new TString(pname2), ptype2};
+  f->addParameter(param2);
+  t->insert(*f);
+}
+
+static void builtin3(TSymbolTable* t, TType* rvalue, const char* name, TType* ptype1, const char* pname1, TType* ptype2, const char* pname2, TType* ptype3, const char* pname3)
+{
+  TFunction* f = new TFunction(new TString(name), *rvalue);
+  TParameter param1 = {new TString(pname1), ptype1};
+  f->addParameter(param1);
+  TParameter param2 = {new TString(pname2), ptype2};
+  f->addParameter(param2);
+  TParameter param3 = {new TString(pname3), ptype3};
+  f->addParameter(param3);
+  t->insert(*f);
+}
+
+void InsertBuiltInFunctionsCommon(const ShBuiltInResources& resources, TSymbolTable* t) {
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "radians", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "degrees");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "radians", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "degrees");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "radians", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "degrees");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "radians", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "degrees");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "degrees", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "radians");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "degrees", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "radians");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "degrees", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "radians");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "degrees", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "radians");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "sin", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "sin", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "sin", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "sin", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "cos", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "cos", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "cos", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "cos", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "tan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "tan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "tan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "tan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "angle");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "asin", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "asin", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "asin", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "asin", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "acos", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "acos", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "acos", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "acos", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "atan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "atan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "atan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "atan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "atan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y_over_x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "atan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y_over_x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "atan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y_over_x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "atan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y_over_x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "pow", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "pow", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "pow", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "pow", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "exp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "exp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "exp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "exp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "log", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "log", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "log", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "log", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "exp2", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "exp2", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "exp2", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "exp2", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "log2", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "log2", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "log2", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "log2", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "sqrt", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "sqrt", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "sqrt", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "sqrt", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "inversesqrt", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "inversesqrt", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "inversesqrt", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "inversesqrt", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "abs", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "abs", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "abs", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "abs", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "sign", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "sign", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "sign", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "sign", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "floor", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "floor", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "floor", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "floor", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "ceil", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "ceil", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "ceil", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "ceil", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "fract", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "fract", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "fract", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "fract", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "mod", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "mod", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "mod", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "mod", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "mod", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "mod", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "mod", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "min", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "min", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "min", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "min", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "min", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "min", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "min", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "max", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "max", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "max", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "max", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "max", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "max", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "max", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "clamp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "minVal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "maxVal");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "clamp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "minVal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "maxVal");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "clamp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "minVal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "maxVal");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "clamp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "minVal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "maxVal");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "clamp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "minVal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "maxVal");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "clamp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "minVal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "maxVal");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "clamp", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "minVal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "maxVal");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "mix", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "a");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "mix", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "a");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "mix", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "a");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "mix", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "a");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "mix", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "a");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "mix", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "a");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "mix", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "a");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "step", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "step", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "edge", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "step", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "edge", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "step", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "edge", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "step", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "step", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "step", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "smoothstep", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge1", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "smoothstep", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "edge0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "edge1", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "smoothstep", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "edge0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "edge1", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "smoothstep", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "edge0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "edge1", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "smoothstep", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge1", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "smoothstep", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge1", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "smoothstep", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "edge1", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "length", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "length", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "length", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "length", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "distance", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "p0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "p1");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "distance", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "p0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "p1");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "distance", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "p0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "p1");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "distance", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "p0", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "p1");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "dot", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "dot", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "dot", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "dot", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "cross", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "normalize", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "normalize", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "normalize", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "normalize", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "faceforward", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "N", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "Nref");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "faceforward", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "N", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "Nref");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "faceforward", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "N", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "Nref");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "faceforward", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "N", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "Nref");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "reflect", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "N");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "reflect", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "N");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "reflect", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "N");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "reflect", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "N");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "refract", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "N", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "eta");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "refract", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "N", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "eta");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "refract", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "N", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "eta");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "refract", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "I", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "N", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "eta");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, true, false), "matrixCompMult", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, true, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, true, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, true, false), "matrixCompMult", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, true, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, true, false), "y");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, true, false), "matrixCompMult", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, true, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, true, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "lessThan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "lessThan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "lessThan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "lessThan", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "lessThan", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "lessThan", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "lessThanEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "lessThanEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "lessThanEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "lessThanEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "lessThanEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "lessThanEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "greaterThan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "greaterThan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "greaterThan", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "greaterThan", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "greaterThan", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "greaterThan", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "greaterThanEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "greaterThanEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "greaterThanEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "greaterThanEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "greaterThanEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "greaterThanEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "equal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "equal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "equal", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "equal", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "equal", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "equal", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "equal", new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "equal", new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "equal", new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "notEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "notEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "notEqual", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "notEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "notEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "notEqual", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtInt, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "notEqual", new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "x", new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "notEqual", new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "x", new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "y");
+    builtin2(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "notEqual", new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "x", new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "y");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 1, false, false), "any", new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 1, false, false), "any", new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 1, false, false), "any", new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 1, false, false), "all", new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 1, false, false), "all", new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 1, false, false), "all", new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "not", new TType(EbtBool, EbpUndefined, EvqGlobal, 2, false, false), "x");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "not", new TType(EbtBool, EbpUndefined, EvqGlobal, 3, false, false), "x");
+    builtin1(t, new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "not", new TType(EbtBool, EbpUndefined, EvqGlobal, 4, false, false), "x");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2D", new TType(EbtSampler2D, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "coord");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DProj", new TType(EbtSampler2D, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "coord");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DProj", new TType(EbtSampler2D, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "coord");
+    builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "textureCube", new TType(EbtSamplerCube, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "coord");
+    if (resources.OES_EGL_image_external) {
+        builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2D", new TType(EbtSamplerExternalOES, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "coord");
+    }
+    if (resources.OES_EGL_image_external) {
+        builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DProj", new TType(EbtSamplerExternalOES, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "coord");
+    }
+    if (resources.OES_EGL_image_external) {
+        builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DProj", new TType(EbtSamplerExternalOES, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "coord");
+    }
+    if (resources.ARB_texture_rectangle) {
+        builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DRect", new TType(EbtSampler2DRect, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "coord");
+    }
+    if (resources.ARB_texture_rectangle) {
+        builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DRectProj", new TType(EbtSampler2DRect, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "coord");
+    }
+    if (resources.ARB_texture_rectangle) {
+        builtin2(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DRectProj", new TType(EbtSampler2DRect, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "coord");
+    }
+}
+
+void InsertBuiltInFunctionsVertex(const ShBuiltInResources& resources, TSymbolTable* t) {
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DLod", new TType(EbtSampler2D, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 2, false, false), "coord", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "lod");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DProjLod", new TType(EbtSampler2D, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "coord", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "lod");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "texture2DProjLod", new TType(EbtSampler2D, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "coord", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "lod");
+    builtin3(t, new TType(EbtFloat, EbpUndefined, EvqGlobal, 4, false, false), "textureCubeLod", new TType(EbtSamplerCube, EbpUndefined, EvqGlobal, 1, false, false), "sampler", new TType(EbtFloat, EbpUndefined, EvqGlobal, 3, false, false), "coord", new TType(EbtFloat, EbpUndefined, EvqGlobal, 1, false, false), "lod");
+}
+
diff --git a/Source/ThirdParty/ANGLE/src/compiler/builtin_symbol_table.h b/Source/ThirdParty/ANGLE/src/compiler/builtin_symbol_table.h
new file mode 100644 (file)
index 0000000..8e04b61
--- /dev/null
@@ -0,0 +1,16 @@
+//
+// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+#ifndef _BUILTIN_SYMBOL_TABLE_INCLUDED_
+#define _BUILTIN_SYMBOL_TABLE_INCLUDED_
+
+#include "GLSLANG/ShaderLang.h"
+
+class TSymbolTable;
+
+extern void InsertBuiltInFunctionsCommon(const ShBuiltInResources& resources, TSymbolTable* t);
+extern void InsertBuiltInFunctionsVertex(const ShBuiltInResources& resources, TSymbolTable* t);
+
+#endif // _BUILTIN_SYMBOL_TABLE_INCLUDED_
index 140a9ae..4049875 100644 (file)
@@ -47,7 +47,10 @@ WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp).
 #pragma warning(disable : 4102)
 #endif
 
-#define YY_USER_ACTION yylval->lex.line = yylineno;
+#define YY_USER_ACTION                                 \
+    yylloc->first_file = yylloc->last_file = yycolumn; \
+    yylloc->first_line = yylloc->last_line = yylineno;
+
 #define YY_INPUT(buf, result, max_size) \
     result = string_input(buf, max_size, yyscanner);
 
@@ -57,10 +60,8 @@ static int reserved_word(yyscan_t yyscanner);
 %}
 
 %option noyywrap nounput never-interactive
-%option yylineno reentrant bison-bridge
-%option stack
+%option yylineno reentrant bison-bridge bison-locations
 %option extra-type="TParseContext*"
-%x COMMENT FIELDS
 
 D           [0-9]
 L           [a-zA-Z_]
@@ -70,73 +71,60 @@ O           [0-7]
 
 %%
 
-%{
-    TParseContext* context = yyextra;
-%}
-
-    /* Single-line comments */
-"//"[^\n]* ;
-
-    /* Multi-line comments */
-"/*"           { yy_push_state(COMMENT, yyscanner); }
-<COMMENT>. |
-<COMMENT>\n ;
-<COMMENT>"*/"  { yy_pop_state(yyscanner); }
-
-"invariant"    { return(INVARIANT); }
-"highp"        { return(HIGH_PRECISION); }
-"mediump"      { return(MEDIUM_PRECISION); }
-"lowp"         { return(LOW_PRECISION); }
-"precision"    { return(PRECISION); }
-
-"attribute"    { return(ATTRIBUTE); }
-"const"        { return(CONST_QUAL); }
-"uniform"      { return(UNIFORM); }
-"varying"      { return(VARYING); }
-
-"break"        { return(BREAK); }
-"continue"     { return(CONTINUE); }
-"do"           { return(DO); }
-"for"          { return(FOR); }
-"while"        { return(WHILE); }
-
-"if"           { return(IF); }
-"else"         { return(ELSE); }
-
-"in"           { return(IN_QUAL); }
-"out"          { return(OUT_QUAL); }
-"inout"        { return(INOUT_QUAL); }
-
-"float"        { context->lexAfterType = true; return(FLOAT_TYPE); }
-"int"          { context->lexAfterType = true; return(INT_TYPE); }
-"void"         { context->lexAfterType = true; return(VOID_TYPE); }
-"bool"         { context->lexAfterType = true; return(BOOL_TYPE); }
-"true"         { yylval->lex.b = true;  return(BOOLCONSTANT); }
-"false"        { yylval->lex.b = false; return(BOOLCONSTANT); }
-
-"discard"      { return(DISCARD); }
-"return"       { return(RETURN); }
-
-"mat2"         { context->lexAfterType = true; return(MATRIX2); }
-"mat3"         { context->lexAfterType = true; return(MATRIX3); }
-"mat4"         { context->lexAfterType = true; return(MATRIX4); }
-
-"vec2"         { context->lexAfterType = true; return (VEC2); }
-"vec3"         { context->lexAfterType = true; return (VEC3); }
-"vec4"         { context->lexAfterType = true; return (VEC4); }
-"ivec2"        { context->lexAfterType = true; return (IVEC2); }
-"ivec3"        { context->lexAfterType = true; return (IVEC3); }
-"ivec4"        { context->lexAfterType = true; return (IVEC4); }
-"bvec2"        { context->lexAfterType = true; return (BVEC2); }
-"bvec3"        { context->lexAfterType = true; return (BVEC3); }
-"bvec4"        { context->lexAfterType = true; return (BVEC4); }
-
-"sampler2D"       { context->lexAfterType = true; return SAMPLER2D; }
-"samplerCube"     { context->lexAfterType = true; return SAMPLERCUBE; }
-"samplerExternalOES" { context->lexAfterType = true; return SAMPLER_EXTERNAL_OES; }
-"sampler2DRect" { context->lexAfterType = true; return SAMPLER2DRECT; }
-
-"struct"       { context->lexAfterType = true; return(STRUCT); }
+"invariant"    { return INVARIANT; }
+"highp"        { return HIGH_PRECISION; }
+"mediump"      { return MEDIUM_PRECISION; }
+"lowp"         { return LOW_PRECISION; }
+"precision"    { return PRECISION; }
+
+"attribute"    { return ATTRIBUTE; }
+"const"        { return CONST_QUAL; }
+"uniform"      { return UNIFORM; }
+"varying"      { return VARYING; }
+
+"break"        { return BREAK; }
+"continue"     { return CONTINUE; }
+"do"           { return DO; }
+"for"          { return FOR; }
+"while"        { return WHILE; }
+
+"if"           { return IF; }
+"else"         { return ELSE; }
+
+"in"           { return IN_QUAL; }
+"out"          { return OUT_QUAL; }
+"inout"        { return INOUT_QUAL; }
+
+"float"        { return FLOAT_TYPE; }
+"int"          { return INT_TYPE; }
+"void"         { return VOID_TYPE; }
+"bool"         { return BOOL_TYPE; }
+"true"         { yylval->lex.b = true;  return BOOLCONSTANT; }
+"false"        { yylval->lex.b = false; return BOOLCONSTANT; }
+
+"discard"      { return DISCARD; }
+"return"       { return RETURN; }
+
+"mat2"         { return MATRIX2; }
+"mat3"         { return MATRIX3; }
+"mat4"         { return MATRIX4; }
+
+"vec2"         { return VEC2; }
+"vec3"         { return VEC3; }
+"vec4"         { return VEC4; }
+"ivec2"        { return IVEC2; }
+"ivec3"        { return IVEC3; }
+"ivec4"        { return IVEC4; }
+"bvec2"        { return BVEC2; }
+"bvec3"        { return BVEC3; }
+"bvec4"        { return BVEC4; }
+
+"sampler2D"          { return SAMPLER2D; }
+"samplerCube"        { return SAMPLERCUBE; }
+"samplerExternalOES" { return SAMPLER_EXTERNAL_OES; }
+"sampler2DRect"      { return SAMPLER2DRECT; }
+
+"struct"       { return STRUCT; }
 
 "asm"          { return reserved_word(yyscanner); }
 
@@ -183,13 +171,11 @@ O           [0-7]
 "fvec3"        { return reserved_word(yyscanner); }
 "fvec4"        { return reserved_word(yyscanner); }
 
-"sampler1D"    { return reserved_word(yyscanner); }
-"sampler3D"    { return reserved_word(yyscanner); }
-
-"sampler1DShadow" { return reserved_word(yyscanner); }
-"sampler2DShadow" { return reserved_word(yyscanner); }
-
-"sampler3DRect" { return reserved_word(yyscanner); }
+"sampler1D"           { return reserved_word(yyscanner); }
+"sampler3D"           { return reserved_word(yyscanner); }
+"sampler1DShadow"     { return reserved_word(yyscanner); }
+"sampler2DShadow"     { return reserved_word(yyscanner); }
+"sampler3DRect"       { return reserved_word(yyscanner); }
 "sampler2DRectShadow" { return reserved_word(yyscanner); }
 
 "sizeof"       { return reserved_word(yyscanner); }
@@ -203,72 +189,64 @@ O           [0-7]
    return check_type(yyscanner);
 }
 
-0[xX]{H}+         { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return(INTCONSTANT); }
-0{O}+             { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return(INTCONSTANT); }
-0{D}+             { context->error(yylineno, "Invalid Octal number.", yytext); context->recover(); return 0;}
-{D}+              { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return(INTCONSTANT); }
-
-{D}+{E}           { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
-{D}+"."{D}*({E})? { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
-"."{D}+({E})?     { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
-
-"+="            {  return(ADD_ASSIGN); }
-"-="            {  return(SUB_ASSIGN); }
-"*="            {  return(MUL_ASSIGN); }
-"/="            {  return(DIV_ASSIGN); }
-"%="            {  return(MOD_ASSIGN); }
-"<<="           {  return(LEFT_ASSIGN); }
-">>="           {  return(RIGHT_ASSIGN); }
-"&="            {  return(AND_ASSIGN); }
-"^="            {  return(XOR_ASSIGN); }
-"|="            {  return(OR_ASSIGN); }
-
-"++"            {  return(INC_OP); }
-"--"            {  return(DEC_OP); }
-"&&"            {  return(AND_OP); }
-"||"            {  return(OR_OP); }
-"^^"            {  return(XOR_OP); }
-"<="            {  return(LE_OP); }
-">="            {  return(GE_OP); }
-"=="            {  return(EQ_OP); }
-"!="            {  return(NE_OP); }
-"<<"            {  return(LEFT_OP); }
-">>"            {  return(RIGHT_OP); }
-";"             { context->lexAfterType = false; return(SEMICOLON); }
-("{"|"<%")      { context->lexAfterType = false; return(LEFT_BRACE); }
-("}"|"%>")      { return(RIGHT_BRACE); }
-","         { if (context->inTypeParen) context->lexAfterType = false; return(COMMA); }
-":"         { return(COLON); }
-"="         { context->lexAfterType = false; return(EQUAL); }
-"("         { context->lexAfterType = false; context->inTypeParen = true; return(LEFT_PAREN); }
-")"         { context->inTypeParen = false; return(RIGHT_PAREN); }
-("["|"<:")      { return(LEFT_BRACKET); }
-("]"|":>")      { return(RIGHT_BRACKET); }
-"."         { BEGIN(FIELDS);  return(DOT); }
-"!"         { return(BANG); }
-"-"         { return(DASH); }
-"~"         { return(TILDE); }
-"+"         { return(PLUS); }
-"*"         { return(STAR); }
-"/"         { return(SLASH); }
-"%"         { return(PERCENT); }
-"<"         { return(LEFT_ANGLE); }
-">"         { return(RIGHT_ANGLE); }
-"|"         { return(VERTICAL_BAR); }
-"^"         { return(CARET); }
-"&"         { return(AMPERSAND); }
-"?"         { return(QUESTION); }
-
-<FIELDS>{L}({L}|{D})* { 
-    BEGIN(INITIAL);
-    yylval->lex.string = NewPoolTString(yytext); 
-    return FIELD_SELECTION;
-}
-<FIELDS>[ \t\v\f\r] {}
-
-[ \t\v\n\f\r]   {  }
-<*><<EOF>>      { context->AfterEOF = true; yyterminate(); }
-<*>.            { context->warning(yylineno, "Unknown char", yytext, ""); return 0; }
+0[xX]{H}+         { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return INTCONSTANT; }
+0{O}+             { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return INTCONSTANT; }
+{D}+              { yylval->lex.i = static_cast<int>(strtol(yytext, 0, 0)); return INTCONSTANT; }
+
+{D}+{E}           { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return FLOATCONSTANT; }
+{D}+"."{D}*({E})? { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return FLOATCONSTANT; }
+"."{D}+({E})?     { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return FLOATCONSTANT; }
+
+"+="            { return ADD_ASSIGN; }
+"-="            { return SUB_ASSIGN; }
+"*="            { return MUL_ASSIGN; }
+"/="            { return DIV_ASSIGN; }
+"%="            { return MOD_ASSIGN; }
+"<<="           { return LEFT_ASSIGN; }
+">>="           { return RIGHT_ASSIGN; }
+"&="            { return AND_ASSIGN; }
+"^="            { return XOR_ASSIGN; }
+"|="            { return OR_ASSIGN; }
+
+"++"            { return INC_OP; }
+"--"            { return DEC_OP; }
+"&&"            { return AND_OP; }
+"||"            { return OR_OP; }
+"^^"            { return XOR_OP; }
+"<="            { return LE_OP; }
+">="            { return GE_OP; }
+"=="            { return EQ_OP; }
+"!="            { return NE_OP; }
+"<<"            { return LEFT_OP; }
+">>"            { return RIGHT_OP; }
+";"             { return SEMICOLON; }
+("{"|"<%")      { return LEFT_BRACE; }
+("}"|"%>")      { return RIGHT_BRACE; }
+","         { return COMMA; }
+":"         { return COLON; }
+"="         { return EQUAL; }
+"("         { return LEFT_PAREN; }
+")"         { return RIGHT_PAREN; }
+("["|"<:")  { return LEFT_BRACKET; }
+("]"|":>")  { return RIGHT_BRACKET; }
+"."         { return DOT; }
+"!"         { return BANG; }
+"-"         { return DASH; }
+"~"         { return TILDE; }
+"+"         { return PLUS; }
+"*"         { return STAR; }
+"/"         { return SLASH; }
+"%"         { return PERCENT; }
+"<"         { return LEFT_ANGLE; }
+">"         { return RIGHT_ANGLE; }
+"|"         { return VERTICAL_BAR; }
+"^"         { return CARET; }
+"&"         { return AMPERSAND; }
+"?"         { return QUESTION; }
+
+[ \t\v\n\f\r] { }
+<<EOF>>    { yyterminate(); }
+.          { assert(false); return 0; }
 
 %%
 
@@ -278,7 +256,8 @@ yy_size_t string_input(char* buf, yy_size_t max_size, yyscan_t yyscanner) {
     yy_size_t len = token.type == pp::Token::LAST ? 0 : token.text.size();
     if (len < max_size)
         memcpy(buf, token.text.c_str(), len);
-    yyset_lineno(EncodeSourceLoc(token.location.file, token.location.line), yyscanner);
+    yyset_column(token.location.file, yyscanner);
+    yyset_lineno(token.location.line, yyscanner);
 
     if (len >= max_size)
         YY_FATAL_ERROR("Input buffer overflow");
@@ -292,12 +271,10 @@ int check_type(yyscan_t yyscanner) {
     
     int token = IDENTIFIER;
     TSymbol* symbol = yyextra->symbolTable.find(yytext);
-    if (yyextra->lexAfterType == false && symbol && symbol->isVariable()) {
+    if (symbol && symbol->isVariable()) {
         TVariable* variable = static_cast<TVariable*>(symbol);
-        if (variable->isUserType()) {
-            yyextra->lexAfterType = true;
+        if (variable->isUserType())
             token = TYPE_NAME;
-        }
     }
     yylval->lex.symbol = symbol;
     return token;
@@ -306,22 +283,11 @@ int check_type(yyscan_t yyscanner) {
 int reserved_word(yyscan_t yyscanner) {
     struct yyguts_t* yyg = (struct yyguts_t*) yyscanner;
 
-    yyextra->error(yylineno, "Illegal use of reserved word", yytext, "");
+    yyextra->error(*yylloc, "Illegal use of reserved word", yytext, "");
     yyextra->recover();
     return 0;
 }
 
-void yyerror(TParseContext* context, const char* reason) {
-    struct yyguts_t* yyg = (struct yyguts_t*) context->scanner;
-
-    if (context->AfterEOF) {
-        context->error(yylineno, reason, "unexpected EOF");
-    } else {
-        context->error(yylineno, reason, yytext);
-    }
-    context->recover();
-}
-
 int glslang_initialize(TParseContext* context) {
     yyscan_t scanner = NULL;
     if (yylex_init_extra(context, &scanner))
@@ -344,8 +310,8 @@ int glslang_finalize(TParseContext* context) {
 int glslang_scan(size_t count, const char* const string[], const int length[],
                  TParseContext* context) {
     yyrestart(NULL, context->scanner);
-    yyset_lineno(EncodeSourceLoc(0, 1), context->scanner);
-    context->AfterEOF = false;
+    yyset_column(0, context->scanner);
+    yyset_lineno(1, context->scanner);
 
     // Initialize preprocessor.
     if (!context->preprocessor.init(count, string, length))
index fc75049..e3d9900 100644 (file)
@@ -1,6 +1,6 @@
 /*
 //
-// Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
+// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
@@ -39,7 +39,6 @@ WHICH GENERATES THE GLSL ES PARSER (glslang_tab.cpp AND glslang_tab.h).
 #include "GLSLANG/ShaderLang.h"
 
 #define YYENABLE_NLS 0
-#define YYLTYPE_IS_TRIVIAL 1
 
 #define YYLEX_PARAM context->scanner
 %}
@@ -47,10 +46,15 @@ WHICH GENERATES THE GLSL ES PARSER (glslang_tab.cpp AND glslang_tab.h).
 %expect 1 /* One shift reduce conflict because of if | else */
 %pure-parser
 %parse-param {TParseContext* context}
+%locations
+
+%code requires {
+#define YYLTYPE TSourceLoc
+#define YYLTYPE_IS_DECLARED 1
+}
 
 %union {
     struct {
-        TSourceLoc line;
         union {
             TString *string;
             float f;
@@ -60,7 +64,6 @@ WHICH GENERATES THE GLSL ES PARSER (glslang_tab.cpp AND glslang_tab.h).
         TSymbol* symbol;
     } lex;
     struct {
-        TSourceLoc line;
         TOperator op;
         union {
             TIntermNode* intermNode;
@@ -74,23 +77,31 @@ WHICH GENERATES THE GLSL ES PARSER (glslang_tab.cpp AND glslang_tab.h).
             TQualifier qualifier;
             TFunction* function;
             TParameter param;
-            TTypeLine typeLine;
-            TTypeList* typeList;
+            TField* field;
+            TFieldList* fieldList;
         };
     } interm;
 }
 
 %{
-extern int yylex(YYSTYPE* yylval_param, void* yyscanner);
-extern void yyerror(TParseContext* context, const char* reason);
-
-#define FRAG_VERT_ONLY(S, L) {  \
-    if (context->shaderType != SH_FRAGMENT_SHADER &&  \
-        context->shaderType != SH_VERTEX_SHADER) {  \
-        context->error(L, " supported in vertex/fragment shaders only ", S);  \
-        context->recover();  \
-    }  \
-}
+extern int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, void* yyscanner);
+static void yyerror(YYLTYPE* yylloc, TParseContext* context, const char* reason);
+
+#define YYLLOC_DEFAULT(Current, Rhs, N)                      \
+  do {                                                       \
+      if (YYID(N)) {                                         \
+        (Current).first_file = YYRHSLOC(Rhs, 1).first_file;  \
+        (Current).first_line = YYRHSLOC(Rhs, 1).first_line;  \
+        (Current).last_file = YYRHSLOC(Rhs, N).last_file;    \
+        (Current).last_line = YYRHSLOC(Rhs, N).last_line;    \
+      }                                                      \
+      else {                                                 \
+        (Current).first_file = YYRHSLOC(Rhs, 0).last_file;   \
+        (Current).first_line = YYRHSLOC(Rhs, 0).last_line;   \
+        (Current).last_file = YYRHSLOC(Rhs, 0).last_file;    \
+        (Current).last_line = YYRHSLOC(Rhs, 0).last_line;    \
+      }                                                      \
+  } while (0)
 
 #define VERTEX_ONLY(S, L) {  \
     if (context->shaderType != SH_VERTEX_SHADER) {  \
@@ -116,7 +127,6 @@ extern void yyerror(TParseContext* context, const char* reason);
 %token <lex> SAMPLER2D SAMPLERCUBE SAMPLER_EXTERNAL_OES SAMPLER2DRECT
 
 %token <lex> IDENTIFIER TYPE_NAME FLOATCONSTANT INTCONSTANT BOOLCONSTANT
-%token <lex> FIELD_SELECTION
 %token <lex> LEFT_OP RIGHT_OP
 %token <lex> INC_OP DEC_OP LE_OP GE_OP EQ_OP NE_OP
 %token <lex> AND_OP OR_OP XOR_OP MUL_ASSIGN DIV_ASSIGN ADD_ASSIGN
@@ -127,6 +137,7 @@ extern void yyerror(TParseContext* context, const char* reason);
 %token <lex> COMMA COLON EQUAL SEMICOLON BANG DASH TILDE PLUS STAR SLASH PERCENT
 %token <lex> LEFT_ANGLE RIGHT_ANGLE VERTICAL_BAR CARET AMPERSAND QUESTION
 
+%type <lex> identifier
 %type <interm> assignment_operator unary_operator
 %type <interm.intermTypedNode> variable_identifier primary_expression postfix_expression
 %type <interm.intermTypedNode> expression integer_expression assignment_expression
@@ -154,8 +165,8 @@ extern void yyerror(TParseContext* context, const char* reason);
 %type <interm.type> type_qualifier fully_specified_type type_specifier
 %type <interm.type> type_specifier_no_prec type_specifier_nonarray
 %type <interm.type> struct_specifier
-%type <interm.typeLine> struct_declarator
-%type <interm.typeList> struct_declarator_list struct_declaration struct_declaration_list
+%type <interm.field> struct_declarator
+%type <interm.fieldList> struct_declarator_list struct_declaration struct_declaration_list
 %type <interm.function> function_header function_declarator function_identifier
 %type <interm.function> function_header_with_parameters function_call_header
 %type <interm> function_call_header_with_parameters function_call_header_no_parameters function_call_generic function_prototype
@@ -164,13 +175,17 @@ extern void yyerror(TParseContext* context, const char* reason);
 %start translation_unit
 %%
 
+identifier
+    : IDENTIFIER
+    | TYPE_NAME
+
 variable_identifier
     : IDENTIFIER {
         // The symbol table search was done in the lexical phase
         const TSymbol* symbol = $1.symbol;
         const TVariable* variable;
         if (symbol == 0) {
-            context->error($1.line, "undeclared identifier", $1.string->c_str());
+            context->error(@1, "undeclared identifier", $1.string->c_str());
             context->recover();
             TType type(EbtFloat, EbpUndefined);
             TVariable* fakeVariable = new TVariable($1.string, type);
@@ -179,10 +194,17 @@ variable_identifier
         } else {
             // This identifier can only be a variable type symbol
             if (! symbol->isVariable()) {
-                context->error($1.line, "variable expected", $1.string->c_str());
+                context->error(@1, "variable expected", $1.string->c_str());
                 context->recover();
             }
+
             variable = static_cast<const TVariable*>(symbol);
+
+            if (context->isVariableBuiltIn(variable) && 
+                !variable->getExtension().empty() &&
+                context->extensionErrorCheck(@1, variable->getExtension())) {
+                context->recover();
+            }
         }
 
         // don't delete $1.string, it's used by error recovery, and the pool
@@ -191,11 +213,12 @@ variable_identifier
         if (variable->getType().getQualifier() == EvqConst ) {
             ConstantUnion* constArray = variable->getConstPointer();
             TType t(variable->getType());
-            $$ = context->intermediate.addConstantUnion(constArray, t, $1.line);
+            $$ = context->intermediate.addConstantUnion(constArray, t, @1);
         } else
             $$ = context->intermediate.addSymbol(variable->getUniqueId(),
-                                                     variable->getName(),
-                                                     variable->getType(), $1.line);
+                                                 variable->getName(),
+                                                 variable->getType(),
+                                                 @1);
     }
     ;
 
@@ -209,22 +232,22 @@ primary_expression
         // check for overflow for constants
         //
         if (abs($1.i) >= (1 << 16)) {
-            context->error($1.line, " integer constant overflow", "");
+            context->error(@1, " integer constant overflow", "");
             context->recover();
         }
         ConstantUnion *unionArray = new ConstantUnion[1];
         unionArray->setIConst($1.i);
-        $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), $1.line);
+        $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), @1);
     }
     | FLOATCONSTANT {
         ConstantUnion *unionArray = new ConstantUnion[1];
         unionArray->setFConst($1.f);
-        $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpUndefined, EvqConst), $1.line);
+        $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpUndefined, EvqConst), @1);
     }
     | BOOLCONSTANT {
         ConstantUnion *unionArray = new ConstantUnion[1];
         unionArray->setBConst($1.b);
-        $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $1.line);
+        $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @1);
     }
     | LEFT_PAREN expression RIGHT_PAREN {
         $$ = $2;
@@ -238,101 +261,97 @@ postfix_expression
     | postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET {
         if (!$1->isArray() && !$1->isMatrix() && !$1->isVector()) {
             if ($1->getAsSymbolNode())
-                context->error($2.line, " left of '[' is not of type array, matrix, or vector ", $1->getAsSymbolNode()->getSymbol().c_str());
+                context->error(@2, " left of '[' is not of type array, matrix, or vector ", $1->getAsSymbolNode()->getSymbol().c_str());
             else
-                context->error($2.line, " left of '[' is not of type array, matrix, or vector ", "expression");
+                context->error(@2, " left of '[' is not of type array, matrix, or vector ", "expression");
             context->recover();
         }
-        if ($1->getType().getQualifier() == EvqConst && $3->getQualifier() == EvqConst) {
-            if ($1->isArray()) { // constant folding for arrays
-                $$ = context->addConstArrayNode($3->getAsConstantUnion()->getUnionArrayPointer()->getIConst(), $1, $2.line);
-            } else if ($1->isVector()) {  // constant folding for vectors
-                TVectorFields fields;
-                fields.num = 1;
-                fields.offsets[0] = $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst(); // need to do it this way because v.xy sends fields integer array
-                $$ = context->addConstVectorNode(fields, $1, $2.line);
-            } else if ($1->isMatrix()) { // constant folding for matrices
-                $$ = context->addConstMatrixNode($3->getAsConstantUnion()->getUnionArrayPointer()->getIConst(), $1, $2.line);
+        if ($3->getQualifier() == EvqConst) {
+            int index = $3->getAsConstantUnion()->getIConst(0);
+            if (index < 0) {
+                std::stringstream infoStream;
+                infoStream << index;
+                std::string info = infoStream.str();
+                context->error(@3, "negative index", info.c_str());
+                context->recover();
+                index = 0;
             }
-        } else {
-            if ($3->getQualifier() == EvqConst) {
-                if (($1->isVector() || $1->isMatrix()) && $1->getType().getNominalSize() <= $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst() && !$1->isArray() ) {
-                    std::stringstream extraInfoStream;
-                    extraInfoStream << "field selection out of range '" << $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst() << "'";
-                    std::string extraInfo = extraInfoStream.str();
-                    context->error($2.line, "", "[", extraInfo.c_str());
-                    context->recover();
-                } else {
-                    if ($1->isArray()) {
-                        if ($1->getType().getArraySize() == 0) {
-                            if ($1->getType().getMaxArraySize() <= $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst()) {
-                                if (context->arraySetMaxSize($1->getAsSymbolNode(), $1->getTypePointer(), $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst(), true, $2.line))
-                                    context->recover();
-                            } else {
-                                if (context->arraySetMaxSize($1->getAsSymbolNode(), $1->getTypePointer(), 0, false, $2.line))
-                                    context->recover();
-                            }
-                        } else if ( $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst() >= $1->getType().getArraySize()) {
-                            std::stringstream extraInfoStream;
-                            extraInfoStream << "array index out of range '" << $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst() << "'";
-                            std::string extraInfo = extraInfoStream.str();
-                            context->error($2.line, "", "[", extraInfo.c_str());
-                            context->recover();
-                        }
-                    }
-                    $$ = context->intermediate.addIndex(EOpIndexDirect, $1, $3, $2.line);
+            if ($1->getType().getQualifier() == EvqConst) {
+                if ($1->isArray()) { // constant folding for arrays
+                    $$ = context->addConstArrayNode(index, $1, @2);
+                } else if ($1->isVector()) {  // constant folding for vectors
+                    TVectorFields fields;
+                    fields.num = 1;
+                    fields.offsets[0] = index; // need to do it this way because v.xy sends fields integer array
+                    $$ = context->addConstVectorNode(fields, $1, @2);
+                } else if ($1->isMatrix()) { // constant folding for matrices
+                    $$ = context->addConstMatrixNode(index, $1, @2);
                 }
             } else {
-                if ($1->isArray() && $1->getType().getArraySize() == 0) {
-                    context->error($2.line, "", "[", "array must be redeclared with a size before being indexed with a variable");
+                if ($1->isArray()) {
+                    if (index >= $1->getType().getArraySize()) {
+                        std::stringstream extraInfoStream;
+                        extraInfoStream << "array index out of range '" << index << "'";
+                        std::string extraInfo = extraInfoStream.str();
+                        context->error(@2, "", "[", extraInfo.c_str());
+                        context->recover();
+                        index = $1->getType().getArraySize() - 1;
+                    }
+                } else if (($1->isVector() || $1->isMatrix()) && $1->getType().getNominalSize() <= index) {
+                    std::stringstream extraInfoStream;
+                    extraInfoStream << "field selection out of range '" << index << "'";
+                    std::string extraInfo = extraInfoStream.str();
+                    context->error(@2, "", "[", extraInfo.c_str());
                     context->recover();
+                    index =  $1->getType().getNominalSize() - 1;
                 }
-
-                $$ = context->intermediate.addIndex(EOpIndexIndirect, $1, $3, $2.line);
+                $3->getAsConstantUnion()->getUnionArrayPointer()->setIConst(index);
+                $$ = context->intermediate.addIndex(EOpIndexDirect, $1, $3, @2);
             }
+        } else {
+            $$ = context->intermediate.addIndex(EOpIndexIndirect, $1, $3, @2);
         }
         if ($$ == 0) {
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setFConst(0.0f);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpHigh, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpHigh, EvqConst), @2);
         } else if ($1->isArray()) {
             if ($1->getType().getStruct())
-                $$->setType(TType($1->getType().getStruct(), $1->getType().getTypeName()));
+                $$->setType(TType($1->getType().getStruct()));
             else
                 $$->setType(TType($1->getBasicType(), $1->getPrecision(), EvqTemporary, $1->getNominalSize(), $1->isMatrix()));
 
             if ($1->getType().getQualifier() == EvqConst)
                 $$->getTypePointer()->setQualifier(EvqConst);
-        } else if ($1->isMatrix() && $1->getType().getQualifier() == EvqConst)
-            $$->setType(TType($1->getBasicType(), $1->getPrecision(), EvqConst, $1->getNominalSize()));
-        else if ($1->isMatrix())
-            $$->setType(TType($1->getBasicType(), $1->getPrecision(), EvqTemporary, $1->getNominalSize()));
-        else if ($1->isVector() && $1->getType().getQualifier() == EvqConst)
-            $$->setType(TType($1->getBasicType(), $1->getPrecision(), EvqConst));
-        else if ($1->isVector())
-            $$->setType(TType($1->getBasicType(), $1->getPrecision(), EvqTemporary));
-        else
+        } else if ($1->isMatrix()) {
+            TQualifier qualifier = $1->getType().getQualifier() == EvqConst ? EvqConst : EvqTemporary;
+            $$->setType(TType($1->getBasicType(), $1->getPrecision(), qualifier, $1->getNominalSize()));
+        } else if ($1->isVector()) {
+            TQualifier qualifier = $1->getType().getQualifier() == EvqConst ? EvqConst : EvqTemporary;
+            $$->setType(TType($1->getBasicType(), $1->getPrecision(), qualifier));
+        } else {
             $$->setType($1->getType());
+        }
     }
     | function_call {
         $$ = $1;
     }
-    | postfix_expression DOT FIELD_SELECTION {
+    | postfix_expression DOT identifier {
         if ($1->isArray()) {
-            context->error($3.line, "cannot apply dot operator to an array", ".");
+            context->error(@3, "cannot apply dot operator to an array", ".");
             context->recover();
         }
 
         if ($1->isVector()) {
             TVectorFields fields;
-            if (! context->parseVectorFields(*$3.string, $1->getNominalSize(), fields, $3.line)) {
+            if (! context->parseVectorFields(*$3.string, $1->getNominalSize(), fields, @3)) {
                 fields.num = 1;
                 fields.offsets[0] = 0;
                 context->recover();
             }
 
             if ($1->getType().getQualifier() == EvqConst) { // constant folding for vector fields
-                $$ = context->addConstVectorNode(fields, $1, $3.line);
+                $$ = context->addConstVectorNode(fields, $1, @3);
                 if ($$ == 0) {
                     context->recover();
                     $$ = $1;
@@ -341,13 +360,13 @@ postfix_expression
                     $$->setType(TType($1->getBasicType(), $1->getPrecision(), EvqConst, (int) (*$3.string).size()));
             } else {
                 TString vectorString = *$3.string;
-                TIntermTyped* index = context->intermediate.addSwizzle(fields, $3.line);
-                $$ = context->intermediate.addIndex(EOpVectorSwizzle, $1, index, $2.line);
+                TIntermTyped* index = context->intermediate.addSwizzle(fields, @3);
+                $$ = context->intermediate.addIndex(EOpVectorSwizzle, $1, index, @2);
                 $$->setType(TType($1->getBasicType(), $1->getPrecision(), EvqTemporary, (int) vectorString.size()));
             }
         } else if ($1->isMatrix()) {
             TMatrixFields fields;
-            if (! context->parseMatrixFields(*$3.string, $1->getNominalSize(), fields, $3.line)) {
+            if (! context->parseMatrixFields(*$3.string, $1->getNominalSize(), fields, @3)) {
                 fields.wholeRow = false;
                 fields.wholeCol = false;
                 fields.row = 0;
@@ -356,84 +375,78 @@ postfix_expression
             }
 
             if (fields.wholeRow || fields.wholeCol) {
-                context->error($2.line, " non-scalar fields not implemented yet", ".");
+                context->error(@2, " non-scalar fields not implemented yet", ".");
                 context->recover();
                 ConstantUnion *unionArray = new ConstantUnion[1];
                 unionArray->setIConst(0);
-                TIntermTyped* index = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), $3.line);
-                $$ = context->intermediate.addIndex(EOpIndexDirect, $1, index, $2.line);
+                TIntermTyped* index = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), @3);
+                $$ = context->intermediate.addIndex(EOpIndexDirect, $1, index, @2);
                 $$->setType(TType($1->getBasicType(), $1->getPrecision(),EvqTemporary, $1->getNominalSize()));
             } else {
                 ConstantUnion *unionArray = new ConstantUnion[1];
                 unionArray->setIConst(fields.col * $1->getNominalSize() + fields.row);
-                TIntermTyped* index = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), $3.line);
-                $$ = context->intermediate.addIndex(EOpIndexDirect, $1, index, $2.line);
+                TIntermTyped* index = context->intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), @3);
+                $$ = context->intermediate.addIndex(EOpIndexDirect, $1, index, @2);
                 $$->setType(TType($1->getBasicType(), $1->getPrecision()));
             }
         } else if ($1->getBasicType() == EbtStruct) {
             bool fieldFound = false;
-            const TTypeList* fields = $1->getType().getStruct();
-            if (fields == 0) {
-                context->error($2.line, "structure has no fields", "Internal Error");
-                context->recover();
-                $$ = $1;
-            } else {
-                unsigned int i;
-                for (i = 0; i < fields->size(); ++i) {
-                    if ((*fields)[i].type->getFieldName() == *$3.string) {
-                        fieldFound = true;
-                        break;
-                    }
+            const TFieldList& fields = $1->getType().getStruct()->fields();
+            unsigned int i;
+            for (i = 0; i < fields.size(); ++i) {
+                if (fields[i]->name() == *$3.string) {
+                    fieldFound = true;
+                    break;
                 }
-                if (fieldFound) {
-                    if ($1->getType().getQualifier() == EvqConst) {
-                        $$ = context->addConstStruct(*$3.string, $1, $2.line);
-                        if ($$ == 0) {
-                            context->recover();
-                            $$ = $1;
-                        }
-                        else {
-                            $$->setType(*(*fields)[i].type);
-                            // change the qualifier of the return type, not of the structure field
-                            // as the structure definition is shared between various structures.
-                            $$->getTypePointer()->setQualifier(EvqConst);
-                        }
-                    } else {
-                        ConstantUnion *unionArray = new ConstantUnion[1];
-                        unionArray->setIConst(i);
-                        TIntermTyped* index = context->intermediate.addConstantUnion(unionArray, *(*fields)[i].type, $3.line);
-                        $$ = context->intermediate.addIndex(EOpIndexDirectStruct, $1, index, $2.line);
-                        $$->setType(*(*fields)[i].type);
+            }
+            if (fieldFound) {
+                if ($1->getType().getQualifier() == EvqConst) {
+                    $$ = context->addConstStruct(*$3.string, $1, @2);
+                    if ($$ == 0) {
+                        context->recover();
+                        $$ = $1;
+                    }
+                    else {
+                        $$->setType(*fields[i]->type());
+                        // change the qualifier of the return type, not of the structure field
+                        // as the structure definition is shared between various structures.
+                        $$->getTypePointer()->setQualifier(EvqConst);
                     }
                 } else {
-                    context->error($2.line, " no such field in structure", $3.string->c_str());
-                    context->recover();
-                    $$ = $1;
+                    ConstantUnion *unionArray = new ConstantUnion[1];
+                    unionArray->setIConst(i);
+                    TIntermTyped* index = context->intermediate.addConstantUnion(unionArray, *fields[i]->type(), @3);
+                    $$ = context->intermediate.addIndex(EOpIndexDirectStruct, $1, index, @2);
+                    $$->setType(*fields[i]->type());
                 }
+            } else {
+                context->error(@2, " no such field in structure", $3.string->c_str());
+                context->recover();
+                $$ = $1;
             }
         } else {
-            context->error($2.line, " field selection requires structure, vector, or matrix on left hand side", $3.string->c_str());
+            context->error(@2, " field selection requires structure, vector, or matrix on left hand side", $3.string->c_str());
             context->recover();
             $$ = $1;
         }
         // don't delete $3.string, it's from the pool
     }
     | postfix_expression INC_OP {
-        if (context->lValueErrorCheck($2.line, "++", $1))
+        if (context->lValueErrorCheck(@2, "++", $1))
             context->recover();
-        $$ = context->intermediate.addUnaryMath(EOpPostIncrement, $1, $2.line, context->symbolTable);
+        $$ = context->intermediate.addUnaryMath(EOpPostIncrement, $1, @2, context->symbolTable);
         if ($$ == 0) {
-            context->unaryOpError($2.line, "++", $1->getCompleteString());
+            context->unaryOpError(@2, "++", $1->getCompleteString());
             context->recover();
             $$ = $1;
         }
     }
     | postfix_expression DEC_OP {
-        if (context->lValueErrorCheck($2.line, "--", $1))
+        if (context->lValueErrorCheck(@2, "--", $1))
             context->recover();
-        $$ = context->intermediate.addUnaryMath(EOpPostDecrement, $1, $2.line, context->symbolTable);
+        $$ = context->intermediate.addUnaryMath(EOpPostDecrement, $1, @2, context->symbolTable);
         if ($$ == 0) {
-            context->unaryOpError($2.line, "--", $1->getCompleteString());
+            context->unaryOpError(@2, "--", $1->getCompleteString());
             context->recover();
             $$ = $1;
         }
@@ -461,18 +474,18 @@ function_call
             // Their parameters will be verified algorithmically.
             //
             TType type(EbtVoid, EbpUndefined);  // use this to get the type back
-            if (context->constructorErrorCheck($1.line, $1.intermNode, *fnCall, op, &type)) {
+            if (context->constructorErrorCheck(@1, $1.intermNode, *fnCall, op, &type)) {
                 $$ = 0;
             } else {
                 //
                 // It's a constructor, of type 'type'.
                 //
-                $$ = context->addConstructor($1.intermNode, &type, op, fnCall, $1.line);
+                $$ = context->addConstructor($1.intermNode, &type, op, fnCall, @1);
             }
 
             if ($$ == 0) {
                 context->recover();
-                $$ = context->intermediate.setAggregateOperator(0, op, $1.line);
+                $$ = context->intermediate.setAggregateOperator(0, op, @1);
             }
             $$->setType(type);
         } else {
@@ -481,13 +494,13 @@ function_call
             //
             const TFunction* fnCandidate;
             bool builtIn;
-            fnCandidate = context->findFunction($1.line, fnCall, &builtIn);
+            fnCandidate = context->findFunction(@1, fnCall, &builtIn);
             if (fnCandidate) {
                 //
                 // A declared function.
                 //
                 if (builtIn && !fnCandidate->getExtension().empty() &&
-                    context->extensionErrorCheck($1.line, fnCandidate->getExtension())) {
+                    context->extensionErrorCheck(@1, fnCandidate->getExtension())) {
                     context->recover();
                 }
                 op = fnCandidate->getBuiltInOp();
@@ -499,7 +512,7 @@ function_call
                         //
                         // Treat it like a built-in unary operator.
                         //
-                        $$ = context->intermediate.addUnaryMath(op, $1.intermNode, 0, context->symbolTable);
+                        $$ = context->intermediate.addUnaryMath(op, $1.intermNode, @1, context->symbolTable);
                         if ($$ == 0)  {
                             std::stringstream extraInfoStream;
                             extraInfoStream << "built in unary operator function.  Type: " << static_cast<TIntermTyped*>($1.intermNode)->getCompleteString();
@@ -508,12 +521,12 @@ function_call
                             YYERROR;
                         }
                     } else {
-                        $$ = context->intermediate.setAggregateOperator($1.intermAggregate, op, $1.line);
+                        $$ = context->intermediate.setAggregateOperator($1.intermAggregate, op, @1);
                     }
                 } else {
                     // This is a real function call
 
-                    $$ = context->intermediate.setAggregateOperator($1.intermAggregate, EOpFunctionCall, $1.line);
+                    $$ = context->intermediate.setAggregateOperator($1.intermAggregate, EOpFunctionCall, @1);
                     $$->setType(fnCandidate->getReturnType());
 
                     // this is how we know whether the given function is a builtIn function or a user defined function
@@ -540,7 +553,7 @@ function_call
                 // Put on a dummy node for error recovery
                 ConstantUnion *unionArray = new ConstantUnion[1];
                 unionArray->setFConst(0.0f);
-                $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpUndefined, EvqConst), $1.line);
+                $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpUndefined, EvqConst), @1);
                 context->recover();
             }
         }
@@ -553,7 +566,7 @@ function_call_or_method
         $$ = $1;
     }
     | postfix_expression DOT function_call_generic {
-        context->error($3.line, "methods are not supported", "");
+        context->error(@3, "methods are not supported", "");
         context->recover();
         $$ = $3;
     }
@@ -562,11 +575,9 @@ function_call_or_method
 function_call_generic
     : function_call_header_with_parameters RIGHT_PAREN {
         $$ = $1;
-        $$.line = $2.line;
     }
     | function_call_header_no_parameters RIGHT_PAREN {
         $$ = $1;
-        $$.line = $2.line;
     }
     ;
 
@@ -592,7 +603,7 @@ function_call_header_with_parameters
         TParameter param = { 0, new TType($3->getType()) };
         $1.function->addParameter(param);
         $$.function = $1.function;
-        $$.intermNode = context->intermediate.growAggregate($1.intermNode, $3, $2.line);
+        $$.intermNode = context->intermediate.growAggregate($1.intermNode, $3, @2);
     }
     ;
 
@@ -617,39 +628,39 @@ function_identifier
             case EbtFloat:
                 if ($1.matrix) {
                     switch($1.size) {
-                    case 2:                                     op = EOpConstructMat2;  break;
-                    case 3:                                     op = EOpConstructMat3;  break;
-                    case 4:                                     op = EOpConstructMat4;  break;
+                    case 2: op = EOpConstructMat2;  break;
+                    case 3: op = EOpConstructMat3;  break;
+                    case 4: op = EOpConstructMat4;  break;
                     }
                 } else {
                     switch($1.size) {
-                    case 1:                                     op = EOpConstructFloat; break;
-                    case 2:                                     op = EOpConstructVec2;  break;
-                    case 3:                                     op = EOpConstructVec3;  break;
-                    case 4:                                     op = EOpConstructVec4;  break;
+                    case 1: op = EOpConstructFloat; break;
+                    case 2: op = EOpConstructVec2;  break;
+                    case 3: op = EOpConstructVec3;  break;
+                    case 4: op = EOpConstructVec4;  break;
                     }
                 }
                 break;
             case EbtInt:
                 switch($1.size) {
-                case 1:                                         op = EOpConstructInt;   break;
-                case 2:       FRAG_VERT_ONLY("ivec2", $1.line); op = EOpConstructIVec2; break;
-                case 3:       FRAG_VERT_ONLY("ivec3", $1.line); op = EOpConstructIVec3; break;
-                case 4:       FRAG_VERT_ONLY("ivec4", $1.line); op = EOpConstructIVec4; break;
+                case 1: op = EOpConstructInt;   break;
+                case 2: op = EOpConstructIVec2; break;
+                case 3: op = EOpConstructIVec3; break;
+                case 4: op = EOpConstructIVec4; break;
                 }
                 break;
             case EbtBool:
                 switch($1.size) {
-                case 1:                                         op = EOpConstructBool;  break;
-                case 2:       FRAG_VERT_ONLY("bvec2", $1.line); op = EOpConstructBVec2; break;
-                case 3:       FRAG_VERT_ONLY("bvec3", $1.line); op = EOpConstructBVec3; break;
-                case 4:       FRAG_VERT_ONLY("bvec4", $1.line); op = EOpConstructBVec4; break;
+                case 1: op = EOpConstructBool;  break;
+                case 2: op = EOpConstructBVec2; break;
+                case 3: op = EOpConstructBVec3; break;
+                case 4: op = EOpConstructBVec4; break;
                 }
                 break;
             default: break;
             }
             if (op == EOpNull) {
-                context->error($1.line, "cannot construct this type", getBasicString($1.type));
+                context->error(@1, "cannot construct this type", getBasicString($1.type));
                 context->recover();
                 $1.type = EbtFloat;
                 op = EOpConstructFloat;
@@ -661,14 +672,7 @@ function_identifier
         $$ = function;
     }
     | IDENTIFIER {
-        if (context->reservedErrorCheck($1.line, *$1.string))
-            context->recover();
-        TType type(EbtVoid, EbpUndefined);
-        TFunction *function = new TFunction($1.string, type);
-        $$ = function;
-    }
-    | FIELD_SELECTION {
-        if (context->reservedErrorCheck($1.line, *$1.string))
+        if (context->reservedErrorCheck(@1, *$1.string))
             context->recover();
         TType type(EbtVoid, EbpUndefined);
         TFunction *function = new TFunction($1.string, type);
@@ -681,28 +685,28 @@ unary_expression
         $$ = $1;
     }
     | INC_OP unary_expression {
-        if (context->lValueErrorCheck($1.line, "++", $2))
+        if (context->lValueErrorCheck(@1, "++", $2))
             context->recover();
-        $$ = context->intermediate.addUnaryMath(EOpPreIncrement, $2, $1.line, context->symbolTable);
+        $$ = context->intermediate.addUnaryMath(EOpPreIncrement, $2, @1, context->symbolTable);
         if ($$ == 0) {
-            context->unaryOpError($1.line, "++", $2->getCompleteString());
+            context->unaryOpError(@1, "++", $2->getCompleteString());
             context->recover();
             $$ = $2;
         }
     }
     | DEC_OP unary_expression {
-        if (context->lValueErrorCheck($1.line, "--", $2))
+        if (context->lValueErrorCheck(@1, "--", $2))
             context->recover();
-        $$ = context->intermediate.addUnaryMath(EOpPreDecrement, $2, $1.line, context->symbolTable);
+        $$ = context->intermediate.addUnaryMath(EOpPreDecrement, $2, @1, context->symbolTable);
         if ($$ == 0) {
-            context->unaryOpError($1.line, "--", $2->getCompleteString());
+            context->unaryOpError(@1, "--", $2->getCompleteString());
             context->recover();
             $$ = $2;
         }
     }
     | unary_operator unary_expression {
         if ($1.op != EOpNull) {
-            $$ = context->intermediate.addUnaryMath($1.op, $2, $1.line, context->symbolTable);
+            $$ = context->intermediate.addUnaryMath($1.op, $2, @1, context->symbolTable);
             if ($$ == 0) {
                 const char* errorOp = "";
                 switch($1.op) {
@@ -710,7 +714,7 @@ unary_expression
                 case EOpLogicalNot: errorOp = "!"; break;
                 default: break;
                 }
-                context->unaryOpError($1.line, errorOp, $2->getCompleteString());
+                context->unaryOpError(@1, errorOp, $2->getCompleteString());
                 context->recover();
                 $$ = $2;
             }
@@ -721,28 +725,26 @@ unary_expression
 // Grammar Note:  No traditional style type casts.
 
 unary_operator
-    : PLUS  { $$.line = $1.line; $$.op = EOpNull; }
-    | DASH  { $$.line = $1.line; $$.op = EOpNegative; }
-    | BANG  { $$.line = $1.line; $$.op = EOpLogicalNot; }
+    : PLUS  { $$.op = EOpNull; }
+    | DASH  { $$.op = EOpNegative; }
+    | BANG  { $$.op = EOpLogicalNot; }
     ;
 // Grammar Note:  No '*' or '&' unary ops.  Pointers are not supported.
 
 multiplicative_expression
     : unary_expression { $$ = $1; }
     | multiplicative_expression STAR unary_expression {
-        FRAG_VERT_ONLY("*", $2.line);
-        $$ = context->intermediate.addBinaryMath(EOpMul, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpMul, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "*", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "*", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             $$ = $1;
         }
     }
     | multiplicative_expression SLASH unary_expression {
-        FRAG_VERT_ONLY("/", $2.line);
-        $$ = context->intermediate.addBinaryMath(EOpDiv, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpDiv, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "/", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "/", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             $$ = $1;
         }
@@ -752,17 +754,17 @@ multiplicative_expression
 additive_expression
     : multiplicative_expression { $$ = $1; }
     | additive_expression PLUS multiplicative_expression {
-        $$ = context->intermediate.addBinaryMath(EOpAdd, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpAdd, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "+", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "+", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             $$ = $1;
         }
     }
     | additive_expression DASH multiplicative_expression {
-        $$ = context->intermediate.addBinaryMath(EOpSub, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpSub, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "-", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "-", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             $$ = $1;
         }
@@ -776,43 +778,43 @@ shift_expression
 relational_expression
     : shift_expression { $$ = $1; }
     | relational_expression LEFT_ANGLE shift_expression {
-        $$ = context->intermediate.addBinaryMath(EOpLessThan, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpLessThan, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "<", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "<", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setBConst(false);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @2);
         }
     }
     | relational_expression RIGHT_ANGLE shift_expression  {
-        $$ = context->intermediate.addBinaryMath(EOpGreaterThan, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpGreaterThan, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, ">", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, ">", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setBConst(false);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @2);
         }
     }
     | relational_expression LE_OP shift_expression  {
-        $$ = context->intermediate.addBinaryMath(EOpLessThanEqual, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpLessThanEqual, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "<=", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "<=", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setBConst(false);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @2);
         }
     }
     | relational_expression GE_OP shift_expression  {
-        $$ = context->intermediate.addBinaryMath(EOpGreaterThanEqual, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpGreaterThanEqual, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, ">=", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, ">=", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setBConst(false);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @2);
         }
     }
     ;
@@ -820,23 +822,23 @@ relational_expression
 equality_expression
     : relational_expression { $$ = $1; }
     | equality_expression EQ_OP relational_expression  {
-        $$ = context->intermediate.addBinaryMath(EOpEqual, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpEqual, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "==", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "==", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setBConst(false);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @2);
         }
     }
     | equality_expression NE_OP relational_expression {
-        $$ = context->intermediate.addBinaryMath(EOpNotEqual, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpNotEqual, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "!=", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "!=", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setBConst(false);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @2);
         }
     }
     ;
@@ -856,13 +858,13 @@ inclusive_or_expression
 logical_and_expression
     : inclusive_or_expression { $$ = $1; }
     | logical_and_expression AND_OP inclusive_or_expression {
-        $$ = context->intermediate.addBinaryMath(EOpLogicalAnd, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpLogicalAnd, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "&&", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "&&", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setBConst(false);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @2);
         }
     }
     ;
@@ -870,13 +872,13 @@ logical_and_expression
 logical_xor_expression
     : logical_and_expression { $$ = $1; }
     | logical_xor_expression XOR_OP logical_and_expression  {
-        $$ = context->intermediate.addBinaryMath(EOpLogicalXor, $1, $3, $2.line, context->symbolTable);
+        $$ = context->intermediate.addBinaryMath(EOpLogicalXor, $1, $3, @2, context->symbolTable);
         if ($$ == 0) {
-            context->binaryOpError($2.line, "^^", $1->getCompleteString(), $3->getCompleteString());
+            context->binaryOpError(@2, "^^", $1->getCompleteString(), $3->getCompleteString());
             context->recover();
             ConstantUnion *unionArray = new ConstantUnion[1];
             unionArray->setBConst(false);
-            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), $2.line);
+            $$ = context->intermediate.addConstantUnion(unionArray, TType(EbtBool, EbpUndefined, EvqConst), @2);
         }
     }
     ;
@@ -884,13 +886,13 @@ logical_xor_expression
 logical_or_expression
     : logical_xor_expression { $$ = $1; }
     | logical_or_expression OR_OP logical_xor_expression  {
-        $$ = context->intermediate.addBinaryMath(EOpLogicalOr, $1, $3, $2.line, context->