diff options
Diffstat (limited to 'src/3rdparty/angle/src/compiler')
91 files changed, 1686 insertions, 5232 deletions
diff --git a/src/3rdparty/angle/src/compiler/BaseTypes.h b/src/3rdparty/angle/src/compiler/BaseTypes.h index 5f83185304..af4c7e3ed9 100644 --- a/src/3rdparty/angle/src/compiler/BaseTypes.h +++ b/src/3rdparty/angle/src/compiler/BaseTypes.h @@ -16,7 +16,7 @@ enum TPrecision EbpUndefined, EbpLow, EbpMedium, - EbpHigh, + EbpHigh }; inline const char* getPrecisionString(TPrecision p) @@ -47,7 +47,7 @@ enum TBasicType EbtGuardSamplerEnd, // non type: see implementation of IsSampler() EbtStruct, EbtAddress, // should be deprecated?? - EbtInvariant, // used as a type when qualifying a previously declared variable as being invariant + EbtInvariant // used as a type when qualifying a previously declared variable as being invariant }; inline const char* getBasicString(TBasicType t) @@ -114,7 +114,7 @@ enum TQualifier EvqFragData, // end of list - EvqLast, + EvqLast }; // diff --git a/src/3rdparty/angle/src/compiler/CodeGenHLSL.cpp b/src/3rdparty/angle/src/compiler/CodeGenHLSL.cpp index f46ff66d40..637ccc5e37 100644 --- a/src/3rdparty/angle/src/compiler/CodeGenHLSL.cpp +++ b/src/3rdparty/angle/src/compiler/CodeGenHLSL.cpp @@ -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,9 +14,11 @@ TCompiler* ConstructCompiler( ShShaderType type, ShShaderSpec spec, ShShaderOutput output) { - switch (output) { - case SH_HLSL_OUTPUT: - return new TranslatorHLSL(type, spec); + switch (output) + { + case SH_HLSL9_OUTPUT: + case SH_HLSL11_OUTPUT: + return new TranslatorHLSL(type, spec, output); default: return NULL; } diff --git a/src/3rdparty/angle/src/compiler/Compiler.cpp b/src/3rdparty/angle/src/compiler/Compiler.cpp index 9e7f75c33a..c8c79e7147 100644 --- a/src/3rdparty/angle/src/compiler/Compiler.cpp +++ b/src/3rdparty/angle/src/compiler/Compiler.cpp @@ -19,6 +19,7 @@ #include "compiler/depgraph/DependencyGraphOutput.h" #include "compiler/timing/RestrictFragmentShaderTiming.h" #include "compiler/timing/RestrictVertexShaderTiming.h" +#include "third_party/compiler/ArrayBoundsClamper.h" bool isWebGLBasedSpec(ShShaderSpec spec) { @@ -37,6 +38,7 @@ bool InitializeSymbolTable( // The builtins deliberately don't specify precisions for the function // arguments and return types. For that reason we don't try to check them. TParseContext parseContext(symbolTable, extBehavior, intermediate, type, spec, 0, false, NULL, infoSink); + parseContext.fragmentPrecisionHigh = resources.FragmentPrecisionHigh == 1; GlobalParseContext = &parseContext; @@ -101,6 +103,8 @@ TShHandleBase::~TShHandleBase() { TCompiler::TCompiler(ShShaderType type, ShShaderSpec spec) : shaderType(type), shaderSpec(spec), + fragmentPrecisionHigh(false), + clampingStrategy(SH_CLAMP_WITH_CLAMP_INTRINSIC), builtInFunctionEmulator(type) { longNameMap = LongNameMap::GetInstance(); @@ -123,12 +127,18 @@ bool TCompiler::Init(const ShBuiltInResources& resources) if (!InitBuiltInSymbolTable(resources)) return false; InitExtensionBehavior(resources, extensionBehavior); + fragmentPrecisionHigh = resources.FragmentPrecisionHigh == 1; + + arrayBoundsClamper.SetClampingStrategy(resources.ArrayIndexClampingStrategy); + clampingStrategy = resources.ArrayIndexClampingStrategy; + + hashFunction = resources.HashFunction; return true; } bool TCompiler::compile(const char* const shaderStrings[], - const int numStrings, + size_t numStrings, int compileOptions) { TScopedPoolAllocator scopedAlloc(&allocator, true); @@ -143,7 +153,7 @@ bool TCompiler::compile(const char* const shaderStrings[], // First string is path of source file if flag is set. The actual source follows. const char* sourcePath = NULL; - int firstSource = 0; + size_t firstSource = 0; if (compileOptions & SH_SOURCE_PATH) { sourcePath = shaderStrings[0]; @@ -154,6 +164,7 @@ bool TCompiler::compile(const char* const shaderStrings[], TParseContext parseContext(symbolTable, extensionBehavior, intermediate, shaderType, shaderSpec, compileOptions, true, sourcePath, infoSink); + parseContext.fragmentPrecisionHigh = fragmentPrecisionHigh; GlobalParseContext = &parseContext; // We preserve symbols at the built-in level from compile-to-compile. @@ -190,10 +201,15 @@ bool TCompiler::compile(const char* const shaderStrings[], if (success && (compileOptions & SH_EMULATE_BUILT_IN_FUNCTIONS)) builtInFunctionEmulator.MarkBuiltInFunctionsForEmulation(root); + // Clamping uniform array bounds needs to happen after validateLimitations pass. + if (success && (compileOptions & SH_CLAMP_INDIRECT_ARRAY_BOUNDS)) + arrayBoundsClamper.MarkIndirectArrayBoundsForClamping(root); + // Call mapLongVariableNames() before collectAttribsUniforms() so in // collectAttribsUniforms() we already have the mapped symbol names and // we could composite mapped and original variable names. - if (success && (compileOptions & SH_MAP_LONG_VARIABLE_NAMES)) + // Also, if we hash all the names, then no need to do this for long names. + if (success && (compileOptions & SH_MAP_LONG_VARIABLE_NAMES) && hashFunction == NULL) mapLongVariableNames(root); if (success && (compileOptions & SH_ATTRIBUTES_UNIFORMS)) { @@ -227,6 +243,7 @@ bool TCompiler::InitBuiltInSymbolTable(const ShBuiltInResources& resources) { TBuiltIns builtIns; + compileResources = resources; builtIns.initialize(shaderType, shaderSpec, resources); return InitializeSymbolTable(builtIns.getBuiltInStrings(), shaderType, shaderSpec, resources, infoSink, symbolTable); @@ -234,6 +251,7 @@ bool TCompiler::InitBuiltInSymbolTable(const ShBuiltInResources& resources) void TCompiler::clearResults() { + arrayBoundsClamper.Cleanup(); infoSink.info.erase(); infoSink.obj.erase(); infoSink.debug.erase(); @@ -242,6 +260,8 @@ void TCompiler::clearResults() uniforms.clear(); builtInFunctionEmulator.Cleanup(); + + nameMap.clear(); } bool TCompiler::detectRecursion(TIntermNode* root) @@ -317,7 +337,7 @@ bool TCompiler::enforceVertexShaderTimingRestrictions(TIntermNode* root) void TCompiler::collectAttribsUniforms(TIntermNode* root) { - CollectAttribsUniforms collect(attribs, uniforms); + CollectAttribsUniforms collect(attribs, uniforms, hashFunction); root->traverse(&collect); } @@ -344,6 +364,21 @@ const TExtensionBehavior& TCompiler::getExtensionBehavior() const return extensionBehavior; } +const ShBuiltInResources& TCompiler::getResources() const +{ + return compileResources; +} + +const ArrayBoundsClamper& TCompiler::getArrayBoundsClamper() const +{ + return arrayBoundsClamper; +} + +ShArrayIndexClampingStrategy TCompiler::getArrayIndexClampingStrategy() const +{ + return clampingStrategy; +} + const BuiltInFunctionEmulator& TCompiler::getBuiltInFunctionEmulator() const { return builtInFunctionEmulator; diff --git a/src/3rdparty/angle/src/compiler/ConstantUnion.h b/src/3rdparty/angle/src/compiler/ConstantUnion.h index fd9d94dc5a..32af4d38b0 100644 --- a/src/3rdparty/angle/src/compiler/ConstantUnion.h +++ b/src/3rdparty/angle/src/compiler/ConstantUnion.h @@ -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/src/3rdparty/angle/src/compiler/DetectDiscontinuity.cpp b/src/3rdparty/angle/src/compiler/DetectDiscontinuity.cpp index 472232a75d..7c3b68a0b3 100644 --- a/src/3rdparty/angle/src/compiler/DetectDiscontinuity.cpp +++ b/src/3rdparty/angle/src/compiler/DetectDiscontinuity.cpp @@ -16,11 +16,26 @@ namespace sh { bool DetectLoopDiscontinuity::traverse(TIntermNode *node) { + mLoopDepth = 0; mLoopDiscontinuity = false; node->traverse(this); return mLoopDiscontinuity; } +bool DetectLoopDiscontinuity::visitLoop(Visit visit, TIntermLoop *loop) +{ + if (visit == PreVisit) + { + ++mLoopDepth; + } + else if (visit == PostVisit) + { + --mLoopDepth; + } + + return true; +} + bool DetectLoopDiscontinuity::visitBranch(Visit visit, TIntermBranch *node) { if (mLoopDiscontinuity) @@ -28,14 +43,19 @@ bool DetectLoopDiscontinuity::visitBranch(Visit visit, TIntermBranch *node) return false; } + if (!mLoopDepth) + { + return true; + } + switch (node->getFlowOp()) { case EOpKill: break; case EOpBreak: case EOpContinue: - mLoopDiscontinuity = true; case EOpReturn: + mLoopDiscontinuity = true; break; default: UNREACHABLE(); } diff --git a/src/3rdparty/angle/src/compiler/DetectDiscontinuity.h b/src/3rdparty/angle/src/compiler/DetectDiscontinuity.h index 8bda4c3dea..e5520bd5b0 100644 --- a/src/3rdparty/angle/src/compiler/DetectDiscontinuity.h +++ b/src/3rdparty/angle/src/compiler/DetectDiscontinuity.h @@ -23,8 +23,10 @@ class DetectLoopDiscontinuity : public TIntermTraverser protected: bool visitBranch(Visit visit, TIntermBranch *node); + bool visitLoop(Visit visit, TIntermLoop *loop); bool visitAggregate(Visit visit, TIntermAggregate *node); + int mLoopDepth; bool mLoopDiscontinuity; }; diff --git a/src/3rdparty/angle/src/compiler/Diagnostics.cpp b/src/3rdparty/angle/src/compiler/Diagnostics.cpp index 8aa1cb6b24..06f370dbe5 100644 --- a/src/3rdparty/angle/src/compiler/Diagnostics.cpp +++ b/src/3rdparty/angle/src/compiler/Diagnostics.cpp @@ -8,7 +8,7 @@ #include "compiler/debug.h" #include "compiler/InfoSink.h" -#include "compiler/preprocessor/new/SourceLocation.h" +#include "compiler/preprocessor/SourceLocation.h" TDiagnostics::TDiagnostics(TInfoSink& infoSink) : mInfoSink(infoSink), diff --git a/src/3rdparty/angle/src/compiler/Diagnostics.h b/src/3rdparty/angle/src/compiler/Diagnostics.h index 3670414b03..cb71bb1204 100644 --- a/src/3rdparty/angle/src/compiler/Diagnostics.h +++ b/src/3rdparty/angle/src/compiler/Diagnostics.h @@ -7,7 +7,7 @@ #ifndef COMPILER_DIAGNOSTICS_H_ #define COMPILER_DIAGNOSTICS_H_ -#include "compiler/preprocessor/new/Diagnostics.h" +#include "compiler/preprocessor/DiagnosticsBase.h" class TInfoSink; diff --git a/src/3rdparty/angle/src/compiler/DirectiveHandler.h b/src/3rdparty/angle/src/compiler/DirectiveHandler.h index 21d3dfc315..95ca59d6fe 100644 --- a/src/3rdparty/angle/src/compiler/DirectiveHandler.h +++ b/src/3rdparty/angle/src/compiler/DirectiveHandler.h @@ -9,7 +9,7 @@ #include "compiler/ExtensionBehavior.h" #include "compiler/Pragma.h" -#include "compiler/preprocessor/new/DirectiveHandler.h" +#include "compiler/preprocessor/DirectiveHandlerBase.h" class TDiagnostics; diff --git a/src/3rdparty/angle/src/compiler/ExtensionBehavior.h b/src/3rdparty/angle/src/compiler/ExtensionBehavior.h index 6040980837..5c1595fb21 100644 --- a/src/3rdparty/angle/src/compiler/ExtensionBehavior.h +++ b/src/3rdparty/angle/src/compiler/ExtensionBehavior.h @@ -16,7 +16,7 @@ typedef enum EBhEnable, EBhWarn, EBhDisable, - EBhUndefined, + EBhUndefined } TBehavior; inline const char* getBehaviorString(TBehavior b) diff --git a/src/3rdparty/angle/src/compiler/ForLoopUnroll.cpp b/src/3rdparty/angle/src/compiler/ForLoopUnroll.cpp index fdc3f44431..27a13eabab 100644 --- a/src/3rdparty/angle/src/compiler/ForLoopUnroll.cpp +++ b/src/3rdparty/angle/src/compiler/ForLoopUnroll.cpp @@ -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); } diff --git a/src/3rdparty/angle/src/compiler/HashNames.h b/src/3rdparty/angle/src/compiler/HashNames.h new file mode 100644 index 0000000000..d2141e2d85 --- /dev/null +++ b/src/3rdparty/angle/src/compiler/HashNames.h @@ -0,0 +1,19 @@ +// +// Copyright (c) 2002-2012 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 COMPILER_HASH_NAMES_H_ +#define COMPILER_HASH_NAMES_H_ + +#include <map> + +#include "compiler/intermediate.h" +#include "GLSLANG/ShaderLang.h" + +#define HASHED_NAME_PREFIX "webgl_" + +typedef std::map<TPersistString, TPersistString> NameMap; + +#endif // COMPILER_HASH_NAMES_H_ diff --git a/src/3rdparty/angle/src/compiler/Initialize.cpp b/src/3rdparty/angle/src/compiler/Initialize.cpp index 3e94ce7ba8..97b46f898e 100644 --- a/src/3rdparty/angle/src/compiler/Initialize.cpp +++ b/src/3rdparty/angle/src/compiler/Initialize.cpp @@ -654,4 +654,6 @@ void InitExtensionBehavior(const ShBuiltInResources& resources, extBehavior["GL_OES_EGL_image_external"] = EBhUndefined; if (resources.ARB_texture_rectangle) extBehavior["GL_ARB_texture_rectangle"] = EBhUndefined; + if (resources.EXT_draw_buffers) + extBehavior["GL_EXT_draw_buffers"] = EBhUndefined; } diff --git a/src/3rdparty/angle/src/compiler/Intermediate.cpp b/src/3rdparty/angle/src/compiler/Intermediate.cpp index 92c450530e..edf279ef67 100644 --- a/src/3rdparty/angle/src/compiler/Intermediate.cpp +++ b/src/3rdparty/angle/src/compiler/Intermediate.cpp @@ -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. // @@ -12,6 +12,7 @@ #include <limits.h> #include <algorithm> +#include "compiler/HashNames.h" #include "compiler/localintermediate.h" #include "compiler/QualifierAlive.h" #include "compiler/RemoveTree.h" @@ -592,7 +593,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; @@ -646,7 +647,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; @@ -845,6 +846,7 @@ bool TIntermUnary::promote(TInfoSink&) } setType(operand->getType()); + type.setQualifier(EvqTemporary); return true; } @@ -1161,7 +1163,7 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod case EbtFloat: if (rightUnionArray[i] == 0.0f) { infoSink.info.message(EPrefixWarning, "Divide by zero error during constant folding", getLine()); - tempConstArray[i].setFConst(FLT_MAX); + tempConstArray[i].setFConst(unionArray[i].getFConst() < 0 ? -FLT_MAX : FLT_MAX); } else tempConstArray[i].setFConst(unionArray[i].getFConst() / rightUnionArray[i].getFConst()); break; @@ -1376,7 +1378,6 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, TIntermTyped* constantNod TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermConstantUnion* node) { - ConstantUnion *rightUnionArray = node->getUnionArrayPointer(); int size = node->getType().getObjectSize(); ConstantUnion *leftUnionArray = new ConstantUnion[size]; @@ -1387,13 +1388,13 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC 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(i))); break; case EbtBool: - leftUnionArray[i].setFConst(static_cast<float>(rightUnionArray[i].getBConst())); + leftUnionArray[i].setFConst(static_cast<float>(node->getBConst(i))); break; case EbtFloat: - leftUnionArray[i] = rightUnionArray[i]; + leftUnionArray[i].setFConst(static_cast<float>(node->getFConst(i))); break; default: infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine()); @@ -1403,13 +1404,13 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC case EbtInt: switch (node->getType().getBasicType()) { case EbtInt: - leftUnionArray[i] = rightUnionArray[i]; + leftUnionArray[i].setIConst(static_cast<int>(node->getIConst(i))); break; case EbtBool: - leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getBConst())); + leftUnionArray[i].setIConst(static_cast<int>(node->getBConst(i))); break; case EbtFloat: - leftUnionArray[i].setIConst(static_cast<int>(rightUnionArray[i].getFConst())); + leftUnionArray[i].setIConst(static_cast<int>(node->getFConst(i))); break; default: infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine()); @@ -1419,13 +1420,13 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC case EbtBool: switch (node->getType().getBasicType()) { case EbtInt: - leftUnionArray[i].setBConst(rightUnionArray[i].getIConst() != 0); + leftUnionArray[i].setBConst(node->getIConst(i) != 0); break; case EbtBool: - leftUnionArray[i] = rightUnionArray[i]; + leftUnionArray[i].setBConst(node->getBConst(i)); break; case EbtFloat: - leftUnionArray[i].setBConst(rightUnionArray[i].getFConst() != 0.0f); + leftUnionArray[i].setBConst(node->getFConst(i) != 0.0f); break; default: infoSink.info.message(EPrefixInternalError, "Cannot promote", node->getLine()); @@ -1445,3 +1446,14 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC return addConstantUnion(leftUnionArray, TType(promoteTo, t.getPrecision(), t.getQualifier(), t.getNominalSize(), t.isMatrix(), t.isArray()), node->getLine()); } +// static +TString TIntermTraverser::hash(const TString& name, ShHashFunction64 hashFunction) +{ + if (hashFunction == NULL || name.empty()) + return name; + khronos_uint64_t number = (*hashFunction)(name.c_str(), name.length()); + TStringStream stream; + stream << HASHED_NAME_PREFIX << std::hex << number; + TString hashedName = stream.str(); + return hashedName; +} diff --git a/src/3rdparty/angle/src/compiler/MapLongVariableNames.cpp b/src/3rdparty/angle/src/compiler/MapLongVariableNames.cpp index a50310154d..a41d20f4e8 100644 --- a/src/3rdparty/angle/src/compiler/MapLongVariableNames.cpp +++ b/src/3rdparty/angle/src/compiler/MapLongVariableNames.cpp @@ -8,7 +8,7 @@ namespace { -TString mapLongName(int id, const TString& name, bool isGlobal) +TString mapLongName(size_t id, const TString& name, bool isGlobal) { ASSERT(name.size() > MAX_SHORTENED_IDENTIFIER_SIZE); TStringStream stream; @@ -70,7 +70,7 @@ void LongNameMap::Insert(const char* originalName, const char* mappedName) originalName, mappedName)); } -int LongNameMap::Size() const +size_t LongNameMap::Size() const { return mLongNameMap.size(); } @@ -115,7 +115,7 @@ TString MapLongVariableNames::mapGlobalLongName(const TString& name) const char* mappedName = mGlobalMap->Find(name.c_str()); if (mappedName != NULL) return mappedName; - int id = mGlobalMap->Size(); + size_t id = mGlobalMap->Size(); TString rt = mapLongName(id, name, true); mGlobalMap->Insert(name.c_str(), rt.c_str()); return rt; diff --git a/src/3rdparty/angle/src/compiler/MapLongVariableNames.h b/src/3rdparty/angle/src/compiler/MapLongVariableNames.h index fb2c7e81cb..d6352acb4b 100644 --- a/src/3rdparty/angle/src/compiler/MapLongVariableNames.h +++ b/src/3rdparty/angle/src/compiler/MapLongVariableNames.h @@ -31,7 +31,7 @@ public: void Insert(const char* originalName, const char* mappedName); // Return the number of entries in the map. - int Size() const; + size_t Size() const; private: LongNameMap(); diff --git a/src/3rdparty/angle/src/compiler/OutputESSL.cpp b/src/3rdparty/angle/src/compiler/OutputESSL.cpp index 64ee92d44e..c2048f1cec 100644 --- a/src/3rdparty/angle/src/compiler/OutputESSL.cpp +++ b/src/3rdparty/angle/src/compiler/OutputESSL.cpp @@ -6,8 +6,12 @@ #include "compiler/OutputESSL.h" -TOutputESSL::TOutputESSL(TInfoSinkBase& objSink) - : TOutputGLSLBase(objSink) +TOutputESSL::TOutputESSL(TInfoSinkBase& objSink, + ShArrayIndexClampingStrategy clampingStrategy, + ShHashFunction64 hashFunction, + NameMap& nameMap, + TSymbolTable& symbolTable) + : TOutputGLSLBase(objSink, clampingStrategy, hashFunction, nameMap, symbolTable) { } diff --git a/src/3rdparty/angle/src/compiler/OutputESSL.h b/src/3rdparty/angle/src/compiler/OutputESSL.h index 4fa73c8047..05db96e497 100644 --- a/src/3rdparty/angle/src/compiler/OutputESSL.h +++ b/src/3rdparty/angle/src/compiler/OutputESSL.h @@ -12,7 +12,11 @@ class TOutputESSL : public TOutputGLSLBase { public: - TOutputESSL(TInfoSinkBase& objSink); + TOutputESSL(TInfoSinkBase& objSink, + ShArrayIndexClampingStrategy clampingStrategy, + ShHashFunction64 hashFunction, + NameMap& nameMap, + TSymbolTable& symbolTable); protected: virtual bool writeVariablePrecision(TPrecision precision); diff --git a/src/3rdparty/angle/src/compiler/OutputGLSL.cpp b/src/3rdparty/angle/src/compiler/OutputGLSL.cpp index dd31b4b58b..206f403408 100644 --- a/src/3rdparty/angle/src/compiler/OutputGLSL.cpp +++ b/src/3rdparty/angle/src/compiler/OutputGLSL.cpp @@ -6,8 +6,12 @@ #include "compiler/OutputGLSL.h" -TOutputGLSL::TOutputGLSL(TInfoSinkBase& objSink) - : TOutputGLSLBase(objSink) +TOutputGLSL::TOutputGLSL(TInfoSinkBase& objSink, + ShArrayIndexClampingStrategy clampingStrategy, + ShHashFunction64 hashFunction, + NameMap& nameMap, + TSymbolTable& symbolTable) + : TOutputGLSLBase(objSink, clampingStrategy, hashFunction, nameMap, symbolTable) { } diff --git a/src/3rdparty/angle/src/compiler/OutputGLSL.h b/src/3rdparty/angle/src/compiler/OutputGLSL.h index 0fe2356eb7..199b6f3e46 100644 --- a/src/3rdparty/angle/src/compiler/OutputGLSL.h +++ b/src/3rdparty/angle/src/compiler/OutputGLSL.h @@ -12,7 +12,11 @@ class TOutputGLSL : public TOutputGLSLBase { public: - TOutputGLSL(TInfoSinkBase& objSink); + TOutputGLSL(TInfoSinkBase& objSink, + ShArrayIndexClampingStrategy clampingStrategy, + ShHashFunction64 hashFunction, + NameMap& nameMap, + TSymbolTable& symbolTable); protected: virtual bool writeVariablePrecision(TPrecision); diff --git a/src/3rdparty/angle/src/compiler/OutputGLSLBase.cpp b/src/3rdparty/angle/src/compiler/OutputGLSLBase.cpp index 552fa5066d..1b9a10deaa 100644 --- a/src/3rdparty/angle/src/compiler/OutputGLSLBase.cpp +++ b/src/3rdparty/angle/src/compiler/OutputGLSLBase.cpp @@ -7,37 +7,10 @@ #include "compiler/OutputGLSLBase.h" #include "compiler/debug.h" +#include <cfloat> + namespace { -TString getTypeName(const TType& type) -{ - TInfoSinkBase out; - if (type.isMatrix()) - { - out << "mat"; - out << type.getNominalSize(); - } - else if (type.isVector()) - { - switch (type.getBasicType()) - { - case EbtFloat: out << "vec"; break; - case EbtInt: out << "ivec"; break; - case EbtBool: out << "bvec"; break; - default: UNREACHABLE(); break; - } - out << type.getNominalSize(); - } - else - { - if (type.getBasicType() == EbtStruct) - out << type.getTypeName(); - else - out << type.getBasicString(); - } - return TString(out.c_str()); -} - TString arrayBrackets(const TType& type) { ASSERT(type.isArray()); @@ -66,10 +39,18 @@ bool isSingleStatement(TIntermNode* node) { } } // namespace -TOutputGLSLBase::TOutputGLSLBase(TInfoSinkBase& objSink) +TOutputGLSLBase::TOutputGLSLBase(TInfoSinkBase& objSink, + ShArrayIndexClampingStrategy clampingStrategy, + ShHashFunction64 hashFunction, + NameMap& nameMap, + TSymbolTable& symbolTable) : TIntermTraverser(true, true, true), mObjSink(objSink), - mDeclaringVariables(false) + mDeclaringVariables(false), + mClampingStrategy(clampingStrategy), + mHashFunction(hashFunction), + mNameMap(nameMap), + mSymbolTable(symbolTable) { } @@ -101,7 +82,7 @@ void TOutputGLSLBase::writeVariableType(const TType& type) if ((type.getBasicType() == EbtStruct) && (mDeclaredStructs.find(type.getTypeName()) == mDeclaredStructs.end())) { - out << "struct " << type.getTypeName() << "{\n"; + out << "struct " << hashName(type.getTypeName()) << "{\n"; const TTypeList* structure = type.getStruct(); ASSERT(structure != NULL); for (size_t i = 0; i < structure->size(); ++i) @@ -110,7 +91,7 @@ void TOutputGLSLBase::writeVariableType(const TType& type) ASSERT(fieldType != NULL); if (writeVariablePrecision(fieldType->getPrecision())) out << " "; - out << getTypeName(*fieldType) << " " << fieldType->getFieldName(); + out << getTypeName(*fieldType) << " " << hashName(fieldType->getFieldName()); if (fieldType->isArray()) out << arrayBrackets(*fieldType); out << ";\n"; @@ -140,7 +121,7 @@ void TOutputGLSLBase::writeFunctionParameters(const TIntermSequence& args) const TString& name = arg->getSymbol(); if (!name.empty()) - out << " " << name; + out << " " << hashName(name); if (type.isArray()) out << arrayBrackets(type); @@ -157,7 +138,7 @@ const ConstantUnion* TOutputGLSLBase::writeConstantUnion(const TType& type, if (type.getBasicType() == EbtStruct) { - out << type.getTypeName() << "("; + out << hashName(type.getTypeName()) << "("; const TTypeList* structure = type.getStruct(); ASSERT(structure != NULL); for (size_t i = 0; i < structure->size(); ++i) @@ -178,7 +159,7 @@ const ConstantUnion* TOutputGLSLBase::writeConstantUnion(const TType& type, { switch (pConstUnion->getType()) { - case EbtFloat: out << pConstUnion->getFConst(); break; + case EbtFloat: out << std::min(FLT_MAX, std::max(-FLT_MAX, pConstUnion->getFConst())); break; case EbtInt: out << pConstUnion->getIConst(); break; case EbtBool: out << pConstUnion->getBConst(); break; default: UNREACHABLE(); @@ -196,7 +177,7 @@ void TOutputGLSLBase::visitSymbol(TIntermSymbol* node) if (mLoopUnroll.NeedsToReplaceSymbolWithValue(node)) out << mLoopUnroll.GetLoopIndexValue(node); else - out << node->getSymbol(); + out << hashVariableName(node->getSymbol()); if (mDeclaringVariables && node->getType().isArray()) out << arrayBrackets(node->getType()); @@ -235,15 +216,59 @@ bool TOutputGLSLBase::visitBinary(Visit visit, TIntermBinary* node) break; case EOpIndexDirect: - case EOpIndexIndirect: writeTriplet(visit, NULL, "[", "]"); break; + case EOpIndexIndirect: + if (node->getAddIndexClamp()) + { + if (visit == InVisit) + { + if (mClampingStrategy == SH_CLAMP_WITH_CLAMP_INTRINSIC) { + out << "[int(clamp(float("; + } else { + out << "[webgl_int_clamp("; + } + } + else if (visit == PostVisit) + { + int maxSize; + TIntermTyped *left = node->getLeft(); + TType leftType = left->getType(); + + if (left->isArray()) + { + // The shader will fail validation if the array length is not > 0. + maxSize = leftType.getArraySize() - 1; + } + else + { + maxSize = leftType.getNominalSize() - 1; + } + + if (mClampingStrategy == SH_CLAMP_WITH_CLAMP_INTRINSIC) { + out << "), 0.0, float(" << maxSize << ")))]"; + } else { + out << ", 0, " << maxSize << ")]"; + } + } + } + else + { + writeTriplet(visit, NULL, "[", "]"); + } + break; case EOpIndexDirectStruct: if (visit == InVisit) { out << "."; // TODO(alokp): ASSERT - out << node->getType().getFieldName(); + TString fieldName = node->getType().getFieldName(); + + const TType& structType = node->getLeft()->getType(); + if (!mSymbolTable.findBuiltIn(structType.getTypeName())) + fieldName = hashName(fieldName); + + out << fieldName; visitChildren = false; } break; @@ -467,7 +492,7 @@ bool TOutputGLSLBase::visitAggregate(Visit visit, TIntermAggregate* node) // Function declaration. ASSERT(visit == PreVisit); writeVariableType(node->getType()); - out << " " << node->getName(); + out << " " << hashName(node->getName()); out << "("; writeFunctionParameters(node->getSequence()); @@ -480,7 +505,7 @@ bool TOutputGLSLBase::visitAggregate(Visit visit, TIntermAggregate* node) // Function definition. ASSERT(visit == PreVisit); writeVariableType(node->getType()); - out << " " << TFunction::unmangleName(node->getName()); + out << " " << hashFunctionName(node->getName()); incrementDepth(); // Function definition node contains one or two children nodes @@ -510,8 +535,7 @@ bool TOutputGLSLBase::visitAggregate(Visit visit, TIntermAggregate* node) // Function call. if (visit == PreVisit) { - TString functionName = TFunction::unmangleName(node->getName()); - out << functionName << "("; + out << hashFunctionName(node->getName()) << "("; } else if (visit == InVisit) { @@ -572,7 +596,7 @@ bool TOutputGLSLBase::visitAggregate(Visit visit, TIntermAggregate* node) { const TType& type = node->getType(); ASSERT(type.getBasicType() == EbtStruct); - out << type.getTypeName() << "("; + out << hashName(type.getTypeName()) << "("; } else if (visit == InVisit) { @@ -718,3 +742,59 @@ void TOutputGLSLBase::visitCodeBlock(TIntermNode* node) { out << "{\n}\n"; // Empty code block. } } + +TString TOutputGLSLBase::getTypeName(const TType& type) +{ + TInfoSinkBase out; + if (type.isMatrix()) + { + out << "mat"; + out << type.getNominalSize(); + } + else if (type.isVector()) + { + switch (type.getBasicType()) + { + case EbtFloat: out << "vec"; break; + case EbtInt: out << "ivec"; break; + case EbtBool: out << "bvec"; break; + default: UNREACHABLE(); break; + } + out << type.getNominalSize(); + } + else + { + if (type.getBasicType() == EbtStruct) + out << hashName(type.getTypeName()); + else + out << type.getBasicString(); + } + return TString(out.c_str()); +} + +TString TOutputGLSLBase::hashName(const TString& name) +{ + if (mHashFunction == NULL || name.empty()) + return name; + NameMap::const_iterator it = mNameMap.find(name.c_str()); + if (it != mNameMap.end()) + return it->second.c_str(); + TString hashedName = TIntermTraverser::hash(name, mHashFunction); + mNameMap[name.c_str()] = hashedName.c_str(); + return hashedName; +} + +TString TOutputGLSLBase::hashVariableName(const TString& name) +{ + if (mSymbolTable.findBuiltIn(name) != NULL) + return name; + return hashName(name); +} + +TString TOutputGLSLBase::hashFunctionName(const TString& mangled_name) +{ + TString name = TFunction::unmangleName(mangled_name); + if (mSymbolTable.findBuiltIn(mangled_name) != NULL || name == "main") + return name; + return hashName(name); +} diff --git a/src/3rdparty/angle/src/compiler/OutputGLSLBase.h b/src/3rdparty/angle/src/compiler/OutputGLSLBase.h index efd0b5fc2d..c9f72d5631 100644 --- a/src/3rdparty/angle/src/compiler/OutputGLSLBase.h +++ b/src/3rdparty/angle/src/compiler/OutputGLSLBase.h @@ -16,7 +16,11 @@ class TOutputGLSLBase : public TIntermTraverser { public: - TOutputGLSLBase(TInfoSinkBase& objSink); + TOutputGLSLBase(TInfoSinkBase& objSink, + ShArrayIndexClampingStrategy clampingStrategy, + ShHashFunction64 hashFunction, + NameMap& nameMap, + TSymbolTable& symbolTable); protected: TInfoSinkBase& objSink() { return mObjSink; } @@ -25,6 +29,7 @@ protected: virtual bool writeVariablePrecision(TPrecision precision) = 0; void writeFunctionParameters(const TIntermSequence& args); const ConstantUnion* writeConstantUnion(const TType& type, const ConstantUnion* pConstUnion); + TString getTypeName(const TType& type); virtual void visitSymbol(TIntermSymbol* node); virtual void visitConstantUnion(TIntermConstantUnion* node); @@ -37,6 +42,15 @@ protected: void visitCodeBlock(TIntermNode* node); + + // Return the original name if hash function pointer is NULL; + // otherwise return the hashed name. + TString hashName(const TString& name); + // Same as hashName(), but without hashing built-in variables. + TString hashVariableName(const TString& name); + // Same as hashName(), but without hashing built-in functions. + TString hashFunctionName(const TString& mangled_name); + private: TInfoSinkBase& mObjSink; bool mDeclaringVariables; @@ -48,6 +62,15 @@ private: DeclaredStructs mDeclaredStructs; ForLoopUnroll mLoopUnroll; + + ShArrayIndexClampingStrategy mClampingStrategy; + + // name hashing. + ShHashFunction64 mHashFunction; + + NameMap& mNameMap; + + TSymbolTable& mSymbolTable; }; #endif // CROSSCOMPILERGLSL_OUTPUTGLSLBASE_H_ diff --git a/src/3rdparty/angle/src/compiler/OutputHLSL.cpp b/src/3rdparty/angle/src/compiler/OutputHLSL.cpp index a430695744..f6a984148b 100644 --- a/src/3rdparty/angle/src/compiler/OutputHLSL.cpp +++ b/src/3rdparty/angle/src/compiler/OutputHLSL.cpp @@ -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. // @@ -8,13 +8,14 @@ #include "common/angleutils.h" #include "compiler/debug.h" +#include "compiler/DetectDiscontinuity.h" #include "compiler/InfoSink.h" -#include "compiler/UnfoldShortCircuit.h" #include "compiler/SearchSymbol.h" -#include "compiler/DetectDiscontinuity.h" +#include "compiler/UnfoldShortCircuit.h" -#include <stdio.h> #include <algorithm> +#include <cfloat> +#include <stdio.h> namespace sh { @@ -26,7 +27,8 @@ TString str(int i) return buffer; } -OutputHLSL::OutputHLSL(TParseContext &context) : TIntermTraverser(true, true, true), mContext(context) +OutputHLSL::OutputHLSL(TParseContext &context, const ShBuiltInResources& resources, ShShaderOutput outputType) + : TIntermTraverser(true, true, true), mContext(context), mOutputType(outputType) { mUnfoldShortCircuit = new UnfoldShortCircuit(context, this); mInsideFunction = false; @@ -46,6 +48,8 @@ OutputHLSL::OutputHLSL(TParseContext &context) : TIntermTraverser(true, true, tr mUsesTexture2DProjLod0_bias = false; mUsesTextureCubeLod0 = false; mUsesTextureCubeLod0_bias = false; + mUsesFragColor = false; + mUsesFragData = false; mUsesDepthRange = false; mUsesFragCoord = false; mUsesPointCoord = false; @@ -80,6 +84,8 @@ OutputHLSL::OutputHLSL(TParseContext &context) : TIntermTraverser(true, true, tr mUsesAtan2_3 = false; mUsesAtan2_4 = false; + mNumRenderTargets = resources.EXT_draw_buffers ? resources.MaxDrawBuffers : 1; + mScopeDepth = 0; mUniqueIndex = 0; @@ -89,6 +95,24 @@ OutputHLSL::OutputHLSL(TParseContext &context) : TIntermTraverser(true, true, tr mInsideDiscontinuousLoop = false; mExcessiveLoopIndex = NULL; + + if (mOutputType == SH_HLSL9_OUTPUT) + { + if (mContext.shaderType == SH_FRAGMENT_SHADER) + { + mUniformRegister = 3; // Reserve registers for dx_DepthRange, dx_ViewCoords and dx_DepthFront + } + else + { + mUniformRegister = 2; // Reserve registers for dx_DepthRange and dx_ViewAdjust + } + } + else + { + mUniformRegister = 0; + } + + mSamplerRegister = 0; } OutputHLSL::~OutputHLSL() @@ -98,7 +122,7 @@ OutputHLSL::~OutputHLSL() void OutputHLSL::output() { - mContainsLoopDiscontinuity = containsLoopDiscontinuity(mContext.treeRoot); + mContainsLoopDiscontinuity = mContext.shaderType == SH_FRAGMENT_SHADER && containsLoopDiscontinuity(mContext.treeRoot); mContext.treeRoot->traverse(this); // Output the body first to determine what has to go in the header header(); @@ -112,6 +136,11 @@ TInfoSinkBase &OutputHLSL::getBodyStream() return mBody; } +const ActiveUniforms &OutputHLSL::getUniforms() +{ + return mActiveUniforms; +} + int OutputHLSL::vectorSize(const TType &type) const { int elementSize = type.isMatrix() ? type.getNominalSize() : 1; @@ -135,58 +164,71 @@ void OutputHLSL::header() out << *constructor; } - if (shaderType == SH_FRAGMENT_SHADER) + TString uniforms; + TString varyings; + TString attributes; + + for (ReferencedSymbols::const_iterator uniform = mReferencedUniforms.begin(); uniform != mReferencedUniforms.end(); uniform++) { - TString uniforms; - TString varyings; + const TType &type = uniform->second->getType(); + const TString &name = uniform->second->getSymbol(); - TSymbolTableLevel *symbols = mContext.symbolTable.getGlobalLevel(); - int semanticIndex = 0; + if (mOutputType == SH_HLSL11_OUTPUT && IsSampler(type.getBasicType())) // Also declare the texture + { + int index = samplerRegister(mReferencedUniforms[name]); + + uniforms += "uniform SamplerState sampler_" + decorateUniform(name, type) + arrayString(type) + + " : register(s" + str(index) + ");\n"; - for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++) + uniforms += "uniform " + textureString(type) + " texture_" + decorateUniform(name, type) + arrayString(type) + + " : register(t" + str(index) + ");\n"; + } + else { - const TSymbol *symbol = (*namedSymbol).second; - const TString &name = symbol->getName(); + uniforms += "uniform " + typeString(type) + " " + decorateUniform(name, type) + arrayString(type) + + " : register(" + registerString(mReferencedUniforms[name]) + ");\n"; + } + } - if (symbol->isVariable()) - { - const TVariable *variable = static_cast<const TVariable*>(symbol); - const TType &type = variable->getType(); - TQualifier qualifier = type.getQualifier(); + for (ReferencedSymbols::const_iterator varying = mReferencedVaryings.begin(); varying != mReferencedVaryings.end(); varying++) + { + const TType &type = varying->second->getType(); + const TString &name = varying->second->getSymbol(); - if (qualifier == EvqUniform) - { - if (mReferencedUniforms.find(name.c_str()) != mReferencedUniforms.end()) - { - uniforms += "uniform " + typeString(type) + " " + decorateUniform(name, type) + arrayString(type) + ";\n"; - } - } - else if (qualifier == EvqVaryingIn || qualifier == EvqInvariantVaryingIn) - { - if (mReferencedVaryings.find(name.c_str()) != mReferencedVaryings.end()) - { - // Program linking depends on this exact format - varyings += "static " + typeString(type) + " " + decorate(name) + arrayString(type) + " = " + initializer(type) + ";\n"; + // Program linking depends on this exact format + varyings += "static " + typeString(type) + " " + decorate(name) + arrayString(type) + " = " + initializer(type) + ";\n"; + } - semanticIndex += type.isArray() ? type.getArraySize() : 1; - } - } - else if (qualifier == EvqGlobal || qualifier == EvqTemporary) - { - // Globals are declared and intialized as an aggregate node - } - else if (qualifier == EvqConst) - { - // Constants are repeated as literals where used - } - else UNREACHABLE(); - } - } + for (ReferencedSymbols::const_iterator attribute = mReferencedAttributes.begin(); attribute != mReferencedAttributes.end(); attribute++) + { + const TType &type = attribute->second->getType(); + const TString &name = attribute->second->getSymbol(); + + attributes += "static " + typeString(type) + " " + decorate(name) + arrayString(type) + " = " + initializer(type) + ";\n"; + } + + if (shaderType == SH_FRAGMENT_SHADER) + { + TExtensionBehavior::const_iterator iter = mContext.extensionBehavior().find("GL_EXT_draw_buffers"); + bool usingMRTExtension = iter != mContext.extensionBehavior().end() && iter->second == EBhEnable; + + unsigned int numColorValues = usingMRTExtension ? mNumRenderTargets : 1; out << "// Varyings\n"; out << varyings; out << "\n" - "static float4 gl_Color[1] = {float4(0, 0, 0, 0)};\n"; + "static float4 gl_Color[" << numColorValues << "] =\n" + "{\n"; + for (unsigned int i = 0; i < numColorValues; i++) + { + out << " float4(0, 0, 0, 0)"; + if (i + 1 != numColorValues) + { + out << ","; + } + out << "\n"; + } + out << "};\n"; if (mUsesFragCoord) { @@ -205,205 +247,379 @@ void OutputHLSL::header() out << "\n"; - if (mUsesFragCoord) + if (mUsesDepthRange) + { + out << "struct gl_DepthRangeParameters\n" + "{\n" + " float near;\n" + " float far;\n" + " float diff;\n" + "};\n" + "\n"; + } + + if (mOutputType == SH_HLSL11_OUTPUT) { - out << "uniform float4 dx_Coord;\n" - "uniform float2 dx_Depth;\n"; + out << "cbuffer DriverConstants : register(b1)\n" + "{\n"; + + if (mUsesDepthRange) + { + out << " float3 dx_DepthRange : packoffset(c0);\n"; + } + + if (mUsesFragCoord) + { + out << " float4 dx_ViewCoords : packoffset(c1);\n"; + } + + if (mUsesFragCoord || mUsesFrontFacing) + { + out << " float3 dx_DepthFront : packoffset(c2);\n"; + } + + out << "};\n"; } + else + { + if (mUsesDepthRange) + { + out << "uniform float3 dx_DepthRange : register(c0);"; + } - if (mUsesFrontFacing) + if (mUsesFragCoord) + { + out << "uniform float4 dx_ViewCoords : register(c1);\n"; + } + + if (mUsesFragCoord || mUsesFrontFacing) + { + out << "uniform float3 dx_DepthFront : register(c2);\n"; + } + } + + out << "\n"; + + if (mUsesDepthRange) { - out << "uniform bool dx_PointsOrLines;\n" - "uniform bool dx_FrontCCW;\n"; + out << "static gl_DepthRangeParameters gl_DepthRange = {dx_DepthRange.x, dx_DepthRange.y, dx_DepthRange.z};\n" + "\n"; } - out << "\n"; out << uniforms; out << "\n"; if (mUsesTexture2D) { - out << "float4 gl_texture2D(sampler2D s, float2 t)\n" - "{\n" - " return tex2D(s, t);\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2D(sampler2D s, float2 t)\n" + "{\n" + " return tex2D(s, t);\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2D(Texture2D t, SamplerState s, float2 uv)\n" + "{\n" + " return t.Sample(s, uv);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTexture2D_bias) { - out << "float4 gl_texture2D(sampler2D s, float2 t, float bias)\n" - "{\n" - " return tex2Dbias(s, float4(t.x, t.y, 0, bias));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2D(sampler2D s, float2 t, float bias)\n" + "{\n" + " return tex2Dbias(s, float4(t.x, t.y, 0, bias));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2D(Texture2D t, SamplerState s, float2 uv, float bias)\n" + "{\n" + " return t.SampleBias(s, uv, bias);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTexture2DProj) { - out << "float4 gl_texture2DProj(sampler2D s, float3 t)\n" - "{\n" - " return tex2Dproj(s, float4(t.x, t.y, 0, t.z));\n" - "}\n" - "\n" - "float4 gl_texture2DProj(sampler2D s, float4 t)\n" - "{\n" - " return tex2Dproj(s, t);\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DProj(sampler2D s, float3 t)\n" + "{\n" + " return tex2Dproj(s, float4(t.x, t.y, 0, t.z));\n" + "}\n" + "\n" + "float4 gl_texture2DProj(sampler2D s, float4 t)\n" + "{\n" + " return tex2Dproj(s, t);\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DProj(Texture2D t, SamplerState s, float3 uvw)\n" + "{\n" + " return t.Sample(s, float2(uvw.x / uvw.z, uvw.y / uvw.z));\n" + "}\n" + "\n" + "float4 gl_texture2DProj(Texture2D t, SamplerState s, float4 uvw)\n" + "{\n" + " return t.Sample(s, float2(uvw.x / uvw.w, uvw.y / uvw.w));\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTexture2DProj_bias) { - out << "float4 gl_texture2DProj(sampler2D s, float3 t, float bias)\n" - "{\n" - " return tex2Dbias(s, float4(t.x / t.z, t.y / t.z, 0, bias));\n" - "}\n" - "\n" - "float4 gl_texture2DProj(sampler2D s, float4 t, float bias)\n" - "{\n" - " return tex2Dbias(s, float4(t.x / t.w, t.y / t.w, 0, bias));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DProj(sampler2D s, float3 t, float bias)\n" + "{\n" + " return tex2Dbias(s, float4(t.x / t.z, t.y / t.z, 0, bias));\n" + "}\n" + "\n" + "float4 gl_texture2DProj(sampler2D s, float4 t, float bias)\n" + "{\n" + " return tex2Dbias(s, float4(t.x / t.w, t.y / t.w, 0, bias));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DProj(Texture2D t, SamplerState s, float3 uvw, float bias)\n" + "{\n" + " return t.SampleBias(s, float2(uvw.x / uvw.z, uvw.y / uvw.z), bias);\n" + "}\n" + "\n" + "float4 gl_texture2DProj(Texture2D t, SamplerState s, float4 uvw, float bias)\n" + "{\n" + " return t.SampleBias(s, float2(uvw.x / uvw.w, uvw.y / uvw.w), bias);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTextureCube) { - out << "float4 gl_textureCube(samplerCUBE s, float3 t)\n" - "{\n" - " return texCUBE(s, t);\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_textureCube(samplerCUBE s, float3 t)\n" + "{\n" + " return texCUBE(s, t);\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_textureCube(TextureCube t, SamplerState s, float3 uvw)\n" + "{\n" + " return t.Sample(s, uvw);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTextureCube_bias) { - out << "float4 gl_textureCube(samplerCUBE s, float3 t, float bias)\n" - "{\n" - " return texCUBEbias(s, float4(t.x, t.y, t.z, bias));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_textureCube(samplerCUBE s, float3 t, float bias)\n" + "{\n" + " return texCUBEbias(s, float4(t.x, t.y, t.z, bias));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_textureCube(TextureCube t, SamplerState s, float3 uvw, float bias)\n" + "{\n" + " return t.SampleBias(s, uvw, bias);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } // These *Lod0 intrinsics are not available in GL fragment shaders. // They are used to sample using discontinuous texture coordinates. if (mUsesTexture2DLod0) { - out << "float4 gl_texture2DLod0(sampler2D s, float2 t)\n" - "{\n" - " return tex2Dlod(s, float4(t.x, t.y, 0, 0));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DLod0(sampler2D s, float2 t)\n" + "{\n" + " return tex2Dlod(s, float4(t.x, t.y, 0, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DLod0(Texture2D t, SamplerState s, float2 uv)\n" + "{\n" + " return t.SampleLevel(s, uv, 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTexture2DLod0_bias) { - out << "float4 gl_texture2DLod0(sampler2D s, float2 t, float bias)\n" - "{\n" - " return tex2Dlod(s, float4(t.x, t.y, 0, 0));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DLod0(sampler2D s, float2 t, float bias)\n" + "{\n" + " return tex2Dlod(s, float4(t.x, t.y, 0, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DLod0(Texture2D t, SamplerState s, float2 uv, float bias)\n" + "{\n" + " return t.SampleLevel(s, uv, 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTexture2DProjLod0) { - out << "float4 gl_texture2DProjLod0(sampler2D s, float3 t)\n" - "{\n" - " return tex2Dlod(s, float4(t.x / t.z, t.y / t.z, 0, 0));\n" - "}\n" - "\n" - "float4 gl_texture2DProjLod(sampler2D s, float4 t)\n" - "{\n" - " return tex2Dlod(s, float4(t.x / t.w, t.y / t.w, 0, 0));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DProjLod0(sampler2D s, float3 t)\n" + "{\n" + " return tex2Dlod(s, float4(t.x / t.z, t.y / t.z, 0, 0));\n" + "}\n" + "\n" + "float4 gl_texture2DProjLod(sampler2D s, float4 t)\n" + "{\n" + " return tex2Dlod(s, float4(t.x / t.w, t.y / t.w, 0, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DProjLod0(Texture2D t, SamplerState s, float3 uvw)\n" + "{\n" + " return t.SampleLevel(s, float2(uvw.x / uvw.z, uvw.y / uvw.z), 0);\n" + "}\n" + "\n" + "float4 gl_texture2DProjLod0(Texture2D t, SamplerState s, float4 uvw)\n" + "{\n" + " return t.SampleLevel(s, float2(uvw.x / uvw.w, uvw.y / uvw.w), 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTexture2DProjLod0_bias) { - out << "float4 gl_texture2DProjLod0_bias(sampler2D s, float3 t, float bias)\n" - "{\n" - " return tex2Dlod(s, float4(t.x / t.z, t.y / t.z, 0, 0));\n" - "}\n" - "\n" - "float4 gl_texture2DProjLod_bias(sampler2D s, float4 t, float bias)\n" - "{\n" - " return tex2Dlod(s, float4(t.x / t.w, t.y / t.w, 0, 0));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DProjLod0_bias(sampler2D s, float3 t, float bias)\n" + "{\n" + " return tex2Dlod(s, float4(t.x / t.z, t.y / t.z, 0, 0));\n" + "}\n" + "\n" + "float4 gl_texture2DProjLod_bias(sampler2D s, float4 t, float bias)\n" + "{\n" + " return tex2Dlod(s, float4(t.x / t.w, t.y / t.w, 0, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DProjLod_bias(Texture2D t, SamplerState s, float3 uvw, float bias)\n" + "{\n" + " return t.SampleLevel(s, float2(uvw.x / uvw.z, uvw.y / uvw.z), 0);\n" + "}\n" + "\n" + "float4 gl_texture2DProjLod_bias(Texture2D t, SamplerState s, float4 uvw, float bias)\n" + "{\n" + " return t.SampleLevel(s, float2(uvw.x / uvw.w, uvw.y / uvw.w), 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTextureCubeLod0) { - out << "float4 gl_textureCubeLod0(samplerCUBE s, float3 t)\n" - "{\n" - " return texCUBElod(s, float4(t.x, t.y, t.z, 0));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_textureCubeLod0(samplerCUBE s, float3 t)\n" + "{\n" + " return texCUBElod(s, float4(t.x, t.y, t.z, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_textureCubeLod0(TextureCube t, SamplerState s, float3 uvw)\n" + "{\n" + " return t.SampleLevel(s, uvw, 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTextureCubeLod0_bias) { - out << "float4 gl_textureCubeLod0(samplerCUBE s, float3 t, float bias)\n" - "{\n" - " return texCUBElod(s, float4(t.x, t.y, t.z, 0));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_textureCubeLod0(samplerCUBE s, float3 t, float bias)\n" + "{\n" + " return texCUBElod(s, float4(t.x, t.y, t.z, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_textureCubeLod0(TextureCube t, SamplerState s, float3 uvw, float bias)\n" + "{\n" + " return t.SampleLevel(s, uvw, 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } - } - else // Vertex shader - { - TString uniforms; - TString attributes; - TString varyings; - TSymbolTableLevel *symbols = mContext.symbolTable.getGlobalLevel(); - - for (TSymbolTableLevel::const_iterator namedSymbol = symbols->begin(); namedSymbol != symbols->end(); namedSymbol++) + if (usingMRTExtension && mNumRenderTargets > 1) { - const TSymbol *symbol = (*namedSymbol).second; - const TString &name = symbol->getName(); - - if (symbol->isVariable()) - { - const TVariable *variable = static_cast<const TVariable*>(symbol); - const TType &type = variable->getType(); - TQualifier qualifier = type.getQualifier(); + out << "#define GL_USES_MRT\n"; + } - if (qualifier == EvqUniform) - { - if (mReferencedUniforms.find(name.c_str()) != mReferencedUniforms.end()) - { - uniforms += "uniform " + typeString(type) + " " + decorateUniform(name, type) + arrayString(type) + ";\n"; - } - } - else if (qualifier == EvqAttribute) - { - if (mReferencedAttributes.find(name.c_str()) != mReferencedAttributes.end()) - { - attributes += "static " + typeString(type) + " " + decorate(name) + arrayString(type) + " = " + initializer(type) + ";\n"; - } - } - else if (qualifier == EvqVaryingOut || qualifier == EvqInvariantVaryingOut) - { - if (mReferencedVaryings.find(name.c_str()) != mReferencedVaryings.end()) - { - // Program linking depends on this exact format - varyings += "static " + typeString(type) + " " + decorate(name) + arrayString(type) + " = " + initializer(type) + ";\n"; - } - } - else if (qualifier == EvqGlobal || qualifier == EvqTemporary) - { - // Globals are declared and intialized as an aggregate node - } - else if (qualifier == EvqConst) - { - // Constants are repeated as literals where used - } - else UNREACHABLE(); - } + if (mUsesFragColor) + { + out << "#define GL_USES_FRAG_COLOR\n"; } + if (mUsesFragData) + { + out << "#define GL_USES_FRAG_DATA\n"; + } + } + else // Vertex shader + { out << "// Attributes\n"; out << attributes; out << "\n" @@ -417,74 +633,194 @@ void OutputHLSL::header() out << "\n" "// Varyings\n"; out << varyings; - out << "\n" - "uniform float2 dx_HalfPixelSize;\n" - "\n"; - out << uniforms; out << "\n"; - - if (mUsesTexture2D) + + if (mUsesDepthRange) { - out << "float4 gl_texture2D(sampler2D s, float2 t)\n" + out << "struct gl_DepthRangeParameters\n" "{\n" - " return tex2Dlod(s, float4(t.x, t.y, 0, 0));\n" - "}\n" + " float near;\n" + " float far;\n" + " float diff;\n" + "};\n" "\n"; } - if (mUsesTexture2DLod) + if (mOutputType == SH_HLSL11_OUTPUT) { - out << "float4 gl_texture2DLod(sampler2D s, float2 t, float lod)\n" - "{\n" - " return tex2Dlod(s, float4(t.x, t.y, 0, lod));\n" - "}\n" + if (mUsesDepthRange) + { + out << "cbuffer DriverConstants : register(b1)\n" + "{\n" + " float3 dx_DepthRange : packoffset(c0);\n" + "};\n" + "\n"; + } + } + else + { + if (mUsesDepthRange) + { + out << "uniform float3 dx_DepthRange : register(c0);\n"; + } + + out << "uniform float4 dx_ViewAdjust : register(c1);\n" "\n"; } - if (mUsesTexture2DProj) + if (mUsesDepthRange) { - out << "float4 gl_texture2DProj(sampler2D s, float3 t)\n" - "{\n" - " return tex2Dlod(s, float4(t.x / t.z, t.y / t.z, 0, 0));\n" - "}\n" - "\n" - "float4 gl_texture2DProj(sampler2D s, float4 t)\n" - "{\n" - " return tex2Dlod(s, float4(t.x / t.w, t.y / t.w, 0, 0));\n" - "}\n" + out << "static gl_DepthRangeParameters gl_DepthRange = {dx_DepthRange.x, dx_DepthRange.y, dx_DepthRange.z};\n" "\n"; } + out << uniforms; + out << "\n"; + + if (mUsesTexture2D) + { + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2D(sampler2D s, float2 t)\n" + "{\n" + " return tex2Dlod(s, float4(t.x, t.y, 0, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2D(Texture2D t, SamplerState s, float2 uv)\n" + "{\n" + " return t.SampleLevel(s, uv, 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); + } + + if (mUsesTexture2DLod) + { + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DLod(sampler2D s, float2 t, float lod)\n" + "{\n" + " return tex2Dlod(s, float4(t.x, t.y, 0, lod));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DLod(Texture2D t, SamplerState s, float2 uv, float lod)\n" + "{\n" + " return t.SampleLevel(s, uv, lod);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); + } + + if (mUsesTexture2DProj) + { + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DProj(sampler2D s, float3 t)\n" + "{\n" + " return tex2Dlod(s, float4(t.x / t.z, t.y / t.z, 0, 0));\n" + "}\n" + "\n" + "float4 gl_texture2DProj(sampler2D s, float4 t)\n" + "{\n" + " return tex2Dlod(s, float4(t.x / t.w, t.y / t.w, 0, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DProj(Texture2D t, SamplerState s, float3 uvw)\n" + "{\n" + " return t.SampleLevel(s, float2(uvw.x / uvw.z, uvw.y / uvw.z), 0);\n" + "}\n" + "\n" + "float4 gl_texture2DProj(Texture2D t, SamplerState s, float4 uvw)\n" + "{\n" + " return t.SampleLevel(s, float2(uvw.x / uvw.w, uvw.y / uvw.w), 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); + } + if (mUsesTexture2DProjLod) { - out << "float4 gl_texture2DProjLod(sampler2D s, float3 t, float lod)\n" - "{\n" - " return tex2Dlod(s, float4(t.x / t.z, t.y / t.z, 0, lod));\n" - "}\n" - "\n" - "float4 gl_texture2DProjLod(sampler2D s, float4 t, float lod)\n" - "{\n" - " return tex2Dlod(s, float4(t.x / t.w, t.y / t.w, 0, lod));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_texture2DProjLod(sampler2D s, float3 t, float lod)\n" + "{\n" + " return tex2Dlod(s, float4(t.x / t.z, t.y / t.z, 0, lod));\n" + "}\n" + "\n" + "float4 gl_texture2DProjLod(sampler2D s, float4 t, float lod)\n" + "{\n" + " return tex2Dlod(s, float4(t.x / t.w, t.y / t.w, 0, lod));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_texture2DProj(Texture2D t, SamplerState s, float3 uvw, float lod)\n" + "{\n" + " return t.SampleLevel(s, float2(uvw.x / uvw.z, uvw.y / uvw.z), lod);\n" + "}\n" + "\n" + "float4 gl_texture2DProj(Texture2D t, SamplerState s, float4 uvw)\n" + "{\n" + " return t.SampleLevel(s, float2(uvw.x / uvw.w, uvw.y / uvw.w), lod);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTextureCube) { - out << "float4 gl_textureCube(samplerCUBE s, float3 t)\n" - "{\n" - " return texCUBElod(s, float4(t.x, t.y, t.z, 0));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_textureCube(samplerCUBE s, float3 t)\n" + "{\n" + " return texCUBElod(s, float4(t.x, t.y, t.z, 0));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_textureCube(TextureCube t, SamplerState s, float3 uvw)\n" + "{\n" + " return t.SampleLevel(s, uvw, 0);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } if (mUsesTextureCubeLod) { - out << "float4 gl_textureCubeLod(samplerCUBE s, float3 t, float lod)\n" - "{\n" - " return texCUBElod(s, float4(t.x, t.y, t.z, lod));\n" - "}\n" - "\n"; + if (mOutputType == SH_HLSL9_OUTPUT) + { + out << "float4 gl_textureCubeLod(samplerCUBE s, float3 t, float lod)\n" + "{\n" + " return texCUBElod(s, float4(t.x, t.y, t.z, lod));\n" + "}\n" + "\n"; + } + else if (mOutputType == SH_HLSL11_OUTPUT) + { + out << "float4 gl_textureCubeLod(TextureCube t, SamplerState s, float3 uvw, float lod)\n" + "{\n" + " return t.SampleLevel(s, uvw, lod);\n" + "}\n" + "\n"; + } + else UNREACHABLE(); } } @@ -508,20 +844,6 @@ void OutputHLSL::header() out << "#define GL_USES_POINT_SIZE\n"; } - if (mUsesDepthRange) - { - out << "struct gl_DepthRangeParameters\n" - "{\n" - " float near;\n" - " float far;\n" - " float diff;\n" - "};\n" - "\n" - "uniform float3 dx_DepthRange;" - "static gl_DepthRangeParameters gl_DepthRange = {dx_DepthRange.x, dx_DepthRange.y, dx_DepthRange.z};\n" - "\n"; - } - if (mUsesXor) { out << "bool xor(bool p, bool q)\n" @@ -812,10 +1134,12 @@ void OutputHLSL::visitSymbol(TIntermSymbol *node) if (name == "gl_FragColor") { out << "gl_Color[0]"; + mUsesFragColor = true; } else if (name == "gl_FragData") { out << "gl_Color"; + mUsesFragData = true; } else if (name == "gl_DepthRange") { @@ -848,17 +1172,17 @@ void OutputHLSL::visitSymbol(TIntermSymbol *node) if (qualifier == EvqUniform) { - mReferencedUniforms.insert(name.c_str()); + mReferencedUniforms[name] = node; out << decorateUniform(name, node->getType()); } else if (qualifier == EvqAttribute) { - mReferencedAttributes.insert(name.c_str()); + mReferencedAttributes[name] = node; out << decorate(name); } else if (qualifier == EvqVaryingOut || qualifier == EvqInvariantVaryingOut || qualifier == EvqVaryingIn || qualifier == EvqInvariantVaryingIn) { - mReferencedVaryings.insert(name.c_str()); + mReferencedVaryings[name] = node; out << decorate(name); } else @@ -973,7 +1297,7 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node) if (element) { - int i = element->getUnionArrayPointer()[0].getIConst(); + int i = element->getIConst(0); switch (i) { @@ -1276,7 +1600,6 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node) { TIntermSequence &sequence = node->getSequence(); TIntermTyped *variable = sequence[0]->getAsTyped(); - bool visit = true; if (variable && (variable->getQualifier() == EvqTemporary || variable->getQualifier() == EvqGlobal)) { @@ -1309,19 +1632,11 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node) (*sit)->traverse(this); } - if (visit && this->inVisit) + if (*sit != sequence.back()) { - if (*sit != sequence.back()) - { - visit = this->visitAggregate(InVisit, node); - } + out << ", "; } } - - if (visit && this->postVisit) - { - this->visitAggregate(PostVisit, node); - } } else if (variable->getAsSymbolNode() && variable->getAsSymbolNode()->getSymbol() == "") // Type (struct) declaration { @@ -1329,7 +1644,24 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node) } else UNREACHABLE(); } - + else if (variable && (variable->getQualifier() == EvqVaryingOut || variable->getQualifier() == EvqInvariantVaryingOut)) + { + for (TIntermSequence::iterator sit = sequence.begin(); sit != sequence.end(); sit++) + { + TIntermSymbol *symbol = (*sit)->getAsSymbolNode(); + + if (symbol) + { + // Vertex (output) varyings which are declared but not written to should still be declared to allow successful linking + mReferencedVaryings[symbol->getSymbol()] = symbol; + } + else + { + (*sit)->traverse(this); + } + } + } + return false; } else if (visit == InVisit) @@ -1440,151 +1772,163 @@ bool OutputHLSL::visitAggregate(Visit visit, TIntermAggregate *node) break; case EOpFunctionCall: { - if (visit == PreVisit) - { - TString name = TFunction::unmangleName(node->getName()); - bool lod0 = mInsideDiscontinuousLoop || mOutputLod0Function; + TString name = TFunction::unmangleName(node->getName()); + bool lod0 = mInsideDiscontinuousLoop || mOutputLod0Function; - if (node->isUserDefined()) - { - out << decorate(name) << (lod0 ? "Lod0(" : "("); - } - else + if (node->isUserDefined()) + { + out << decorate(name) << (lod0 ? "Lod0(" : "("); + } + else + { + if (name == "texture2D") { - if (name == "texture2D") + if (!lod0) { - if (!lod0) + if (node->getSequence().size() == 2) { - if (node->getSequence().size() == 2) - { - mUsesTexture2D = true; - } - else if (node->getSequence().size() == 3) - { - mUsesTexture2D_bias = true; - } - else UNREACHABLE(); - - out << "gl_texture2D("; + mUsesTexture2D = true; } - else + else if (node->getSequence().size() == 3) { - if (node->getSequence().size() == 2) - { - mUsesTexture2DLod0 = true; - } - else if (node->getSequence().size() == 3) - { - mUsesTexture2DLod0_bias = true; - } - else UNREACHABLE(); - - out << "gl_texture2DLod0("; + mUsesTexture2D_bias = true; } + else UNREACHABLE(); + + out << "gl_texture2D("; } - else if (name == "texture2DProj") + else { - if (!lod0) + if (node->getSequence().size() == 2) { - if (node->getSequence().size() == 2) - { - mUsesTexture2DProj = true; - } - else if (node->getSequence().size() == 3) - { - mUsesTexture2DProj_bias = true; - } - else UNREACHABLE(); - - out << "gl_texture2DProj("; + mUsesTexture2DLod0 = true; } - else + else if (node->getSequence().size() == 3) { - if (node->getSequence().size() == 2) - { - mUsesTexture2DProjLod0 = true; - } - else if (node->getSequence().size() == 3) - { - mUsesTexture2DProjLod0_bias = true; - } - else UNREACHABLE(); - - out << "gl_texture2DProjLod0("; + mUsesTexture2DLod0_bias = true; } + else UNREACHABLE(); + + out << "gl_texture2DLod0("; } - else if (name == "textureCube") + } + else if (name == "texture2DProj") + { + if (!lod0) { - if (!lod0) + if (node->getSequence().size() == 2) { - if (node->getSequence().size() == 2) - { - mUsesTextureCube = true; - } - else if (node->getSequence().size() == 3) - { - mUsesTextureCube_bias = true; - } - else UNREACHABLE(); - - out << "gl_textureCube("; + mUsesTexture2DProj = true; } - else + else if (node->getSequence().size() == 3) { - if (node->getSequence().size() == 2) - { - mUsesTextureCubeLod0 = true; - } - else if (node->getSequence().size() == 3) - { - mUsesTextureCubeLod0_bias = true; - } - else UNREACHABLE(); - - out << "gl_textureCubeLod0("; + mUsesTexture2DProj_bias = true; } + else UNREACHABLE(); + + out << "gl_texture2DProj("; } - else if (name == "texture2DLod") + else { - if (node->getSequence().size() == 3) + if (node->getSequence().size() == 2) + { + mUsesTexture2DProjLod0 = true; + } + else if (node->getSequence().size() == 3) { - mUsesTexture2DLod = true; + mUsesTexture2DProjLod0_bias = true; } else UNREACHABLE(); - out << "gl_texture2DLod("; + out << "gl_texture2DProjLod0("; } - else if (name == "texture2DProjLod") + } + else if (name == "textureCube") + { + if (!lod0) { - if (node->getSequence().size() == 3) + if (node->getSequence().size() == 2) + { + mUsesTextureCube = true; + } + else if (node->getSequence().size() == 3) { - mUsesTexture2DProjLod = true; + mUsesTextureCube_bias = true; } else UNREACHABLE(); - out << "gl_texture2DProjLod("; + out << "gl_textureCube("; } - else if (name == "textureCubeLod") + else { - if (node->getSequence().size() == 3) + if (node->getSequence().size() == 2) { - mUsesTextureCubeLod = true; + mUsesTextureCubeLod0 = true; + } + else if (node->getSequence().size() == 3) + { + mUsesTextureCubeLod0_bias = true; } else UNREACHABLE(); - out << "gl_textureCubeLod("; + out << "gl_textureCubeLod0("; + } + } + else if (name == "texture2DLod") + { + if (node->getSequence().size() == 3) + { + mUsesTexture2DLod = true; + } + else UNREACHABLE(); + + out << "gl_texture2DLod("; + } + else if (name == "texture2DProjLod") + { + if (node->getSequence().size() == 3) + { + mUsesTexture2DProjLod = true; } else UNREACHABLE(); + + out << "gl_texture2DProjLod("; } + else if (name == "textureCubeLod") + { + if (node->getSequence().size() == 3) + { + mUsesTextureCubeLod = true; + } + else UNREACHABLE(); + + out << "gl_textureCubeLod("; + } + else UNREACHABLE(); } - else if (visit == InVisit) - { - out << ", "; - } - else + + TIntermSequence &arguments = node->getSequence(); + + for (TIntermSequence::iterator arg = arguments.begin(); arg != arguments.end(); arg++) { - out << ")"; + if (mOutputType == SH_HLSL11_OUTPUT && IsSampler((*arg)->getAsTyped()->getBasicType())) + { + out << "texture_"; + (*arg)->traverse(this); + out << ", sampler_"; + } + + (*arg)->traverse(this); + + if (arg < arguments.end() - 1) + { + out << ", "; + } } + + out << ")"; + + return false; } break; case EOpParameters: outputTriplet(visit, "(", ", ", ")\n{\n"); break; @@ -1778,14 +2122,17 @@ bool OutputHLSL::visitLoop(Visit visit, TIntermLoop *node) { bool wasDiscontinuous = mInsideDiscontinuousLoop; - if (!mInsideDiscontinuousLoop) + if (mContainsLoopDiscontinuity && !mInsideDiscontinuousLoop) { mInsideDiscontinuousLoop = containsLoopDiscontinuity(node); } - if (handleExcessiveLoop(node)) + if (mOutputType == SH_HLSL9_OUTPUT) { - return false; + if (handleExcessiveLoop(node)) + { + return false; + } } TInfoSinkBase &out = mBody; @@ -1976,7 +2323,7 @@ bool OutputHLSL::handleExcessiveLoop(TIntermLoop *node) if (constant->getBasicType() == EbtInt && constant->getNominalSize() == 1) { index = symbol; - initial = constant->getUnionArrayPointer()[0].getIConst(); + initial = constant->getIConst(0); } } } @@ -1998,7 +2345,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); } } } @@ -2019,7 +2366,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) { @@ -2191,6 +2538,12 @@ TString OutputHLSL::argumentString(const TIntermSymbol *symbol) name = decorate(name); } + if (mOutputType == SH_HLSL11_OUTPUT && IsSampler(type.getBasicType())) + { + return qualifierString(qualifier) + " " + textureString(type) + " texture_" + name + arrayString(type) + ", " + + qualifierString(qualifier) + " SamplerState sampler_" + name + arrayString(type); + } + return qualifierString(qualifier) + " " + typeString(type) + " " + name + arrayString(type); } @@ -2285,10 +2638,28 @@ TString OutputHLSL::typeString(const TType &type) } } - UNIMPLEMENTED(); // FIXME + UNREACHABLE(); return "<unknown type>"; } +TString OutputHLSL::textureString(const TType &type) +{ + switch (type.getBasicType()) + { + case EbtSampler2D: + return "Texture2D"; + case EbtSamplerCube: + return "TextureCube"; + case EbtSamplerExternalOES: + return "Texture2D"; + default: + break; + } + + UNREACHABLE(); + return "<unknown texture type>"; +} + TString OutputHLSL::arrayString(const TType &type) { if (!type.isArray()) @@ -2565,7 +2936,7 @@ const ConstantUnion *OutputHLSL::writeConstantUnion(const TType &type, const Con { switch (constUnion->getType()) { - case EbtFloat: out << constUnion->getFConst(); break; + case EbtFloat: out << std::min(FLT_MAX, std::max(-FLT_MAX, constUnion->getFConst())); break; case EbtInt: out << constUnion->getIConst(); break; case EbtBool: out << constUnion->getBConst(); break; default: UNREACHABLE(); @@ -2640,11 +3011,7 @@ TString OutputHLSL::decorate(const TString &string) TString OutputHLSL::decorateUniform(const TString &string, const TType &type) { - if (type.isArray()) - { - return "ar_" + string; // Allows identifying arrays of size 1 - } - else if (type.getBasicType() == EbtSamplerExternalOES) + if (type.getBasicType() == EbtSamplerExternalOES) { return "ex_" + string; } @@ -2661,4 +3028,197 @@ TString OutputHLSL::decorateField(const TString &string, const TType &structure) return string; } + +TString OutputHLSL::registerString(TIntermSymbol *operand) +{ + ASSERT(operand->getQualifier() == EvqUniform); + + if (IsSampler(operand->getBasicType())) + { + return "s" + str(samplerRegister(operand)); + } + + return "c" + str(uniformRegister(operand)); +} + +int OutputHLSL::samplerRegister(TIntermSymbol *sampler) +{ + const TType &type = sampler->getType(); + ASSERT(IsSampler(type.getBasicType())); + + int index = mSamplerRegister; + mSamplerRegister += sampler->totalRegisterCount(); + + declareUniform(type, sampler->getSymbol(), index); + + return index; +} + +int OutputHLSL::uniformRegister(TIntermSymbol *uniform) +{ + const TType &type = uniform->getType(); + ASSERT(!IsSampler(type.getBasicType())); + + int index = mUniformRegister; + mUniformRegister += uniform->totalRegisterCount(); + + declareUniform(type, uniform->getSymbol(), index); + + return index; +} + +void OutputHLSL::declareUniform(const TType &type, const TString &name, int index) +{ + const TTypeList *structure = type.getStruct(); + + if (!structure) + { + mActiveUniforms.push_back(Uniform(glVariableType(type), glVariablePrecision(type), name.c_str(), type.getArraySize(), index)); + } + else + { + if (type.isArray()) + { + int elementIndex = index; + + for (int i = 0; i < type.getArraySize(); i++) + { + for (size_t j = 0; j < structure->size(); j++) + { + const TType &fieldType = *(*structure)[j].type; + const TString &fieldName = fieldType.getFieldName(); + + const TString uniformName = name + "[" + str(i) + "]." + fieldName; + declareUniform(fieldType, uniformName, elementIndex); + elementIndex += fieldType.totalRegisterCount(); + } + } + } + else + { + int fieldIndex = index; + + for (size_t i = 0; i < structure->size(); i++) + { + const TType &fieldType = *(*structure)[i].type; + const TString &fieldName = fieldType.getFieldName(); + + const TString uniformName = name + "." + fieldName; + declareUniform(fieldType, uniformName, fieldIndex); + fieldIndex += fieldType.totalRegisterCount(); + } + } + } +} + +GLenum OutputHLSL::glVariableType(const TType &type) +{ + if (type.getBasicType() == EbtFloat) + { + if (type.isScalar()) + { + return GL_FLOAT; + } + else if (type.isVector()) + { + switch(type.getNominalSize()) + { + case 2: return GL_FLOAT_VEC2; + case 3: return GL_FLOAT_VEC3; + case 4: return GL_FLOAT_VEC4; + default: UNREACHABLE(); + } + } + else if (type.isMatrix()) + { + switch(type.getNominalSize()) + { + case 2: return GL_FLOAT_MAT2; + case 3: return GL_FLOAT_MAT3; + case 4: return GL_FLOAT_MAT4; + default: UNREACHABLE(); + } + } + else UNREACHABLE(); + } + else if (type.getBasicType() == EbtInt) + { + if (type.isScalar()) + { + return GL_INT; + } + else if (type.isVector()) + { + switch(type.getNominalSize()) + { + case 2: return GL_INT_VEC2; + case 3: return GL_INT_VEC3; + case 4: return GL_INT_VEC4; + default: UNREACHABLE(); + } + } + else UNREACHABLE(); + } + else if (type.getBasicType() == EbtBool) + { + if (type.isScalar()) + { + return GL_BOOL; + } + else if (type.isVector()) + { + switch(type.getNominalSize()) + { + case 2: return GL_BOOL_VEC2; + case 3: return GL_BOOL_VEC3; + case 4: return GL_BOOL_VEC4; + default: UNREACHABLE(); + } + } + else UNREACHABLE(); + } + else if (type.getBasicType() == EbtSampler2D) + { + return GL_SAMPLER_2D; + } + else if (type.getBasicType() == EbtSamplerCube) + { + return GL_SAMPLER_CUBE; + } + else UNREACHABLE(); + + return GL_NONE; +} + +GLenum OutputHLSL::glVariablePrecision(const TType &type) +{ + if (type.getBasicType() == EbtFloat) + { + switch (type.getPrecision()) + { + case EbpHigh: return GL_HIGH_FLOAT; + case EbpMedium: return GL_MEDIUM_FLOAT; + case EbpLow: return GL_LOW_FLOAT; + case EbpUndefined: + // Should be defined as the default precision by the parser + default: UNREACHABLE(); + } + } + else if (type.getBasicType() == EbtInt) + { + switch (type.getPrecision()) + { + case EbpHigh: return GL_HIGH_INT; + case EbpMedium: return GL_MEDIUM_INT; + case EbpLow: return GL_LOW_INT; + case EbpUndefined: + // Should be defined as the default precision by the parser + default: UNREACHABLE(); + } + } + + // Other types (boolean, sampler) don't have a precision + return GL_NONE; +} + } diff --git a/src/3rdparty/angle/src/compiler/OutputHLSL.h b/src/3rdparty/angle/src/compiler/OutputHLSL.h index dc843fb366..749a3461b3 100644 --- a/src/3rdparty/angle/src/compiler/OutputHLSL.h +++ b/src/3rdparty/angle/src/compiler/OutputHLSL.h @@ -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. // @@ -9,9 +9,14 @@ #include <list> #include <set> +#include <map> + +#define GL_APICALL +#include <GLES2/gl2.h> #include "compiler/intermediate.h" #include "compiler/ParseHelper.h" +#include "compiler/Uniform.h" namespace sh { @@ -20,14 +25,16 @@ class UnfoldShortCircuit; class OutputHLSL : public TIntermTraverser { public: - explicit OutputHLSL(TParseContext &context); + OutputHLSL(TParseContext &context, const ShBuiltInResources& resources, ShShaderOutput outputType); ~OutputHLSL(); void output(); TInfoSinkBase &getBodyStream(); + const ActiveUniforms &getUniforms(); TString typeString(const TType &type); + TString textureString(const TType &type); static TString qualifierString(TQualifier qualifier); static TString arrayString(const TType &type); static TString initializer(const TType &type); @@ -64,6 +71,7 @@ class OutputHLSL : public TIntermTraverser TString structLookup(const TString &typeName); TParseContext &mContext; + const ShShaderOutput mOutputType; UnfoldShortCircuit *mUnfoldShortCircuit; bool mInsideFunction; @@ -72,9 +80,10 @@ class OutputHLSL : public TIntermTraverser TInfoSinkBase mBody; TInfoSinkBase mFooter; - std::set<std::string> mReferencedUniforms; - std::set<std::string> mReferencedAttributes; - std::set<std::string> mReferencedVaryings; + typedef std::map<TString, TIntermSymbol*> ReferencedSymbols; + ReferencedSymbols mReferencedUniforms; + ReferencedSymbols mReferencedAttributes; + ReferencedSymbols mReferencedVaryings; // Parameters determining what goes in the header output bool mUsesTexture2D; @@ -92,6 +101,8 @@ class OutputHLSL : public TIntermTraverser bool mUsesTexture2DProjLod0_bias; bool mUsesTextureCubeLod0; bool mUsesTextureCubeLod0_bias; + bool mUsesFragColor; + bool mUsesFragData; bool mUsesDepthRange; bool mUsesFragCoord; bool mUsesPointCoord; @@ -126,6 +137,8 @@ class OutputHLSL : public TIntermTraverser bool mUsesAtan2_3; bool mUsesAtan2_4; + int mNumRenderTargets; + typedef std::set<TString> Constructors; Constructors mConstructors; @@ -146,6 +159,18 @@ class OutputHLSL : public TIntermTraverser bool mInsideDiscontinuousLoop; TIntermSymbol *mExcessiveLoopIndex; + + int mUniformRegister; + int mSamplerRegister; + + TString registerString(TIntermSymbol *operand); + int samplerRegister(TIntermSymbol *sampler); + int uniformRegister(TIntermSymbol *uniform); + void declareUniform(const TType &type, const TString &name, int index); + static GLenum glVariableType(const TType &type); + static GLenum glVariablePrecision(const TType &type); + + ActiveUniforms mActiveUniforms; }; } diff --git a/src/3rdparty/angle/src/compiler/ParseHelper.cpp b/src/3rdparty/angle/src/compiler/ParseHelper.cpp index 508f1726a7..441ff35e00 100644 --- a/src/3rdparty/angle/src/compiler/ParseHelper.cpp +++ b/src/3rdparty/angle/src/compiler/ParseHelper.cpp @@ -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. // @@ -10,7 +10,7 @@ #include <stdio.h> #include "compiler/glslang.h" -#include "compiler/preprocessor/new/SourceLocation.h" +#include "compiler/preprocessor/SourceLocation.h" /////////////////////////////////////////////////////////////////////// // @@ -33,7 +33,7 @@ bool TParseContext::parseVectorFields(const TString& compString, int vecSize, TV enum { exyzw, ergba, - estpq, + estpq } fieldSet[4]; for (int i = 0; i < fields.num; ++i) { @@ -286,7 +286,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); @@ -493,7 +493,7 @@ bool TParseContext::constructorErrorCheck(int line, TIntermNode* node, TFunction bool overFull = false; bool matrixInMatrix = false; bool arrayArg = false; - for (int i = 0; i < function.getParamCount(); ++i) { + for (size_t i = 0; i < function.getParamCount(); ++i) { const TParameter& param = function.getParam(i); size += param.type->getObjectSize(); @@ -512,7 +512,7 @@ bool TParseContext::constructorErrorCheck(int line, TIntermNode* node, TFunction if (constType) type->setQualifier(EvqConst); - if (type->isArray() && type->getArraySize() != function.getParamCount()) { + if (type->isArray() && static_cast<size_t>(type->getArraySize()) != function.getParamCount()) { error(line, "array constructor needs one argument per array element", "constructor"); return true; } @@ -680,7 +680,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", ""); @@ -1313,7 +1313,6 @@ TIntermTyped* TParseContext::addConstVectorNode(TVectorFields& fields, TIntermTy ConstantUnion *unionArray; if (tempConstantNode) { unionArray = tempConstantNode->getUnionArrayPointer(); - ASSERT(unionArray); if (!unionArray) { return node; @@ -1507,7 +1506,7 @@ bool TParseContext::structNestingErrorCheck(TSourceLoc line, const TType& fieldT // // Returns 0 for success. // -int PaParseStrings(int count, const char* const string[], const int length[], +int PaParseStrings(size_t count, const char* const string[], const int length[], TParseContext* context) { if ((count == 0) || (string == NULL)) return 1; diff --git a/src/3rdparty/angle/src/compiler/ParseHelper.h b/src/3rdparty/angle/src/compiler/ParseHelper.h index 824ee00f39..26a3ea1308 100644 --- a/src/3rdparty/angle/src/compiler/ParseHelper.h +++ b/src/3rdparty/angle/src/compiler/ParseHelper.h @@ -9,7 +9,7 @@ #include "compiler/Diagnostics.h" #include "compiler/DirectiveHandler.h" #include "compiler/localintermediate.h" -#include "compiler/preprocessor/new/Preprocessor.h" +#include "compiler/preprocessor/Preprocessor.h" #include "compiler/ShHandle.h" #include "compiler/SymbolTable.h" @@ -58,6 +58,7 @@ struct TParseContext { 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; @@ -134,7 +135,7 @@ struct TParseContext { bool structNestingErrorCheck(TSourceLoc line, const TType& fieldType); }; -int PaParseStrings(int count, const char* const string[], const int length[], +int PaParseStrings(size_t count, const char* const string[], const int length[], TParseContext* context); #endif // _PARSER_HELPER_INCLUDED_ diff --git a/src/3rdparty/angle/src/compiler/ShHandle.h b/src/3rdparty/angle/src/compiler/ShHandle.h index 6ba302ad04..28049305e0 100644 --- a/src/3rdparty/angle/src/compiler/ShHandle.h +++ b/src/3rdparty/angle/src/compiler/ShHandle.h @@ -18,13 +18,16 @@ #include "compiler/BuiltInFunctionEmulator.h" #include "compiler/ExtensionBehavior.h" +#include "compiler/HashNames.h" #include "compiler/InfoSink.h" #include "compiler/SymbolTable.h" #include "compiler/VariableInfo.h" +#include "third_party/compiler/ArrayBoundsClamper.h" class LongNameMap; class TCompiler; class TDependencyGraph; +class TranslatorHLSL; // // Helper function to identify specs that are based on the WebGL spec, @@ -40,6 +43,7 @@ public: TShHandleBase(); virtual ~TShHandleBase(); virtual TCompiler* getAsCompiler() { return 0; } + virtual TranslatorHLSL* getAsTranslatorHLSL() { return 0; } protected: // Memory allocator. Allocates and tracks memory required by the compiler. @@ -59,7 +63,7 @@ public: bool Init(const ShBuiltInResources& resources); bool compile(const char* const shaderStrings[], - const int numStrings, + size_t numStrings, int compileOptions); // Get results of the last compilation. @@ -68,6 +72,10 @@ public: const TVariableInfoList& getUniforms() const { return uniforms; } int getMappedNameMaxLength() const; + ShHashFunction64 getHashFunction() const { return hashFunction; } + NameMap& getNameMap() { return nameMap; } + TSymbolTable& getSymbolTable() { return symbolTable; } + protected: ShShaderType getShaderType() const { return shaderType; } ShShaderSpec getShaderSpec() const { return shaderSpec; } @@ -100,7 +108,11 @@ protected: bool enforceFragmentShaderTimingRestrictions(const TDependencyGraph& graph); // Get built-in extensions with default behavior. const TExtensionBehavior& getExtensionBehavior() const; + // Get the resources set by InitBuiltInSymbolTable + const ShBuiltInResources& getResources() const; + const ArrayBoundsClamper& getArrayBoundsClamper() const; + ShArrayIndexClampingStrategy getArrayIndexClampingStrategy() const; const BuiltInFunctionEmulator& getBuiltInFunctionEmulator() const; private: @@ -109,12 +121,17 @@ private: int maxUniformVectors; + ShBuiltInResources compileResources; + // Built-in symbol table for the given language, spec, and resources. // It is preserved from compile-to-compile. TSymbolTable symbolTable; // Built-in extensions with default behavior. TExtensionBehavior extensionBehavior; + bool fragmentPrecisionHigh; + ArrayBoundsClamper arrayBoundsClamper; + ShArrayIndexClampingStrategy clampingStrategy; BuiltInFunctionEmulator builtInFunctionEmulator; // Results of compilation. @@ -124,6 +141,10 @@ private: // Cached copy of the ref-counted singleton. LongNameMap* longNameMap; + + // name hashing. + ShHashFunction64 hashFunction; + NameMap nameMap; }; // diff --git a/src/3rdparty/angle/src/compiler/ShaderLang.cpp b/src/3rdparty/angle/src/compiler/ShaderLang.cpp index 56f5c7f2ec..92f39311c2 100644 --- a/src/3rdparty/angle/src/compiler/ShaderLang.cpp +++ b/src/3rdparty/angle/src/compiler/ShaderLang.cpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2002-2011 The ANGLE Project Authors. All rights reserved. +// Copyright (c) 2002-2012 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 @@ #include "compiler/InitializeDll.h" #include "compiler/preprocessor/length_limits.h" #include "compiler/ShHandle.h" +#include "compiler/TranslatorHLSL.h" // // This is the platform independent interface between an OGL driver @@ -21,18 +22,18 @@ // static bool checkActiveUniformAndAttribMaxLengths(const ShHandle handle, - int expectedValue) + size_t expectedValue) { - int activeUniformLimit = 0; + size_t activeUniformLimit = 0; ShGetInfo(handle, SH_ACTIVE_UNIFORM_MAX_LENGTH, &activeUniformLimit); - int activeAttribLimit = 0; + size_t activeAttribLimit = 0; ShGetInfo(handle, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &activeAttribLimit); return (expectedValue == activeUniformLimit && expectedValue == activeAttribLimit); } -static bool checkMappedNameMaxLength(const ShHandle handle, int expectedValue) +static bool checkMappedNameMaxLength(const ShHandle handle, size_t expectedValue) { - int mappedNameMaxLength = 0; + size_t mappedNameMaxLength = 0; ShGetInfo(handle, SH_MAPPED_NAME_MAX_LENGTH, &mappedNameMaxLength); return (expectedValue == mappedNameMaxLength); } @@ -40,7 +41,7 @@ static bool checkMappedNameMaxLength(const ShHandle handle, int expectedValue) static void getVariableInfo(ShShaderInfo varType, const ShHandle handle, int index, - int* length, + size_t* length, int* size, ShDataType* type, char* name, @@ -69,14 +70,14 @@ static void getVariableInfo(ShShaderInfo varType, // This size must match that queried by // SH_ACTIVE_UNIFORM_MAX_LENGTH and SH_ACTIVE_ATTRIBUTE_MAX_LENGTH // in ShGetInfo, below. - int activeUniformAndAttribLength = 1 + MAX_SYMBOL_NAME_LEN; + size_t activeUniformAndAttribLength = 1 + MAX_SYMBOL_NAME_LEN; ASSERT(checkActiveUniformAndAttribMaxLengths(handle, activeUniformAndAttribLength)); strncpy(name, varInfo.name.c_str(), activeUniformAndAttribLength); name[activeUniformAndAttribLength - 1] = 0; if (mappedName) { // This size must match that queried by // SH_MAPPED_NAME_MAX_LENGTH in ShGetInfo, below. - int maxMappedNameLength = 1 + MAX_SYMBOL_NAME_LEN; + size_t maxMappedNameLength = 1 + MAX_SYMBOL_NAME_LEN; ASSERT(checkMappedNameMaxLength(handle, maxMappedNameLength)); strncpy(mappedName, varInfo.mappedName.c_str(), maxMappedNameLength); mappedName[maxMappedNameLength - 1] = 0; @@ -125,6 +126,15 @@ void ShInitBuiltInResources(ShBuiltInResources* resources) resources->OES_standard_derivatives = 0; resources->OES_EGL_image_external = 0; resources->ARB_texture_rectangle = 0; + resources->EXT_draw_buffers = 0; + + // Disable highp precision in fragment shader by default. + resources->FragmentPrecisionHigh = 0; + + // Disable name hashing by default. + resources->HashFunction = NULL; + + resources->ArrayIndexClampingStrategy = SH_CLAMP_WITH_CLAMP_INTRINSIC; } // @@ -172,7 +182,7 @@ void ShDestruct(ShHandle handle) int ShCompile( const ShHandle handle, const char* const shaderStrings[], - const int numStrings, + size_t numStrings, int compileOptions) { if (!InitThread()) @@ -190,7 +200,7 @@ int ShCompile( return success ? 1 : 0; } -void ShGetInfo(const ShHandle handle, ShShaderInfo pname, int* params) +void ShGetInfo(const ShHandle handle, ShShaderInfo pname, size_t* params) { if (!handle || !params) return; @@ -224,6 +234,22 @@ void ShGetInfo(const ShHandle handle, ShShaderInfo pname, int* params) // handle array and struct dereferences. *params = 1 + MAX_SYMBOL_NAME_LEN; break; + case SH_NAME_MAX_LENGTH: + *params = 1 + MAX_SYMBOL_NAME_LEN; + break; + case SH_HASHED_NAME_MAX_LENGTH: + if (compiler->getHashFunction() == NULL) { + *params = 0; + } else { + // 64 bits hashing output requires 16 bytes for hex + // representation. + const char HashedNamePrefix[] = HASHED_NAME_PREFIX; + *params = 16 + sizeof(HashedNamePrefix); + } + break; + case SH_HASHED_NAMES_COUNT: + *params = compiler->getNameMap().size(); + break; default: UNREACHABLE(); } } @@ -262,7 +288,7 @@ void ShGetObjectCode(const ShHandle handle, char* objCode) void ShGetActiveAttrib(const ShHandle handle, int index, - int* length, + size_t* length, int* size, ShDataType* type, char* name, @@ -274,7 +300,7 @@ void ShGetActiveAttrib(const ShHandle handle, void ShGetActiveUniform(const ShHandle handle, int index, - int* length, + size_t* length, int* size, ShDataType* type, char* name, @@ -283,3 +309,64 @@ void ShGetActiveUniform(const ShHandle handle, getVariableInfo(SH_ACTIVE_UNIFORMS, handle, index, length, size, type, name, mappedName); } + +void ShGetNameHashingEntry(const ShHandle handle, + int index, + char* name, + char* hashedName) +{ + if (!handle || !name || !hashedName || index < 0) + return; + + TShHandleBase* base = static_cast<TShHandleBase*>(handle); + TCompiler* compiler = base->getAsCompiler(); + if (!compiler) return; + + const NameMap& nameMap = compiler->getNameMap(); + if (index >= static_cast<int>(nameMap.size())) + return; + + NameMap::const_iterator it = nameMap.begin(); + for (int i = 0; i < index; ++i) + ++it; + + size_t len = it->first.length() + 1; + size_t max_len = 0; + ShGetInfo(handle, SH_NAME_MAX_LENGTH, &max_len); + if (len > max_len) { + ASSERT(false); + len = max_len; + } + strncpy(name, it->first.c_str(), len); + // To be on the safe side in case the source is longer than expected. + name[len - 1] = '\0'; + + len = it->second.length() + 1; + max_len = 0; + ShGetInfo(handle, SH_HASHED_NAME_MAX_LENGTH, &max_len); + if (len > max_len) { + ASSERT(false); + len = max_len; + } + strncpy(hashedName, it->second.c_str(), len); + // To be on the safe side in case the source is longer than expected. + hashedName[len - 1] = '\0'; +} + +void ShGetInfoPointer(const ShHandle handle, ShShaderInfo pname, void** params) +{ + if (!handle || !params) + return; + + TShHandleBase* base = static_cast<TShHandleBase*>(handle); + TranslatorHLSL* translator = base->getAsTranslatorHLSL(); + if (!translator) return; + + switch(pname) + { + case SH_ACTIVE_UNIFORMS_ARRAY: + *params = (void*)&translator->getUniforms(); + break; + default: UNREACHABLE(); + } +} diff --git a/src/3rdparty/angle/src/compiler/SymbolTable.h b/src/3rdparty/angle/src/compiler/SymbolTable.h index a89499e4f4..d27aa332b7 100644 --- a/src/3rdparty/angle/src/compiler/SymbolTable.h +++ b/src/3rdparty/angle/src/compiler/SymbolTable.h @@ -169,8 +169,8 @@ public: void setDefined() { defined = true; } bool isDefined() { return defined; } - int getParamCount() const { return static_cast<int>(parameters.size()); } - const TParameter& getParam(int i) const { return parameters[i]; } + size_t getParamCount() const { return parameters.size(); } + const TParameter& getParam(size_t i) const { return parameters[i]; } virtual void dump(TInfoSink &infoSink) const; TFunction(const TFunction&, TStructureMap& remapper); @@ -323,10 +323,16 @@ public: void dump(TInfoSink &infoSink) const; void copyTable(const TSymbolTable& copyOf); - void setDefaultPrecision( TBasicType type, TPrecision prec ){ - if( type != EbtFloat && type != EbtInt ) return; // Only set default precision for int/float + bool setDefaultPrecision( const TPublicType& type, TPrecision prec ){ + if (IsSampler(type.type)) + return true; // Skip sampler types for the time being + if (type.type != EbtFloat && type.type != EbtInt) + return false; // Only set default precision for int/float + if (type.size != 1 || type.matrix || type.array) + return false; // Not allowed to set for aggregate types int indexOfLastElement = static_cast<int>(precisionStack.size()) - 1; - precisionStack[indexOfLastElement][type] = prec; // Uses map operator [], overwrites the current value + precisionStack[indexOfLastElement][type.type] = prec; // Uses map operator [], overwrites the current value + return true; } // Searches down the precisionStack for a precision qualifier for the specified TBasicType diff --git a/src/3rdparty/angle/src/compiler/TranslatorESSL.cpp b/src/3rdparty/angle/src/compiler/TranslatorESSL.cpp index e3a2c2a802..2900f8a8ed 100644 --- a/src/3rdparty/angle/src/compiler/TranslatorESSL.cpp +++ b/src/3rdparty/angle/src/compiler/TranslatorESSL.cpp @@ -22,8 +22,11 @@ void TranslatorESSL::translate(TIntermNode* root) { getBuiltInFunctionEmulator().OutputEmulatedFunctionDefinition( sink, getShaderType() == SH_FRAGMENT_SHADER); + // Write array bounds clamping emulation if needed. + getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); + // Write translated shader. - TOutputESSL outputESSL(sink); + TOutputESSL outputESSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable()); root->traverse(&outputESSL); } diff --git a/src/3rdparty/angle/src/compiler/TranslatorGLSL.cpp b/src/3rdparty/angle/src/compiler/TranslatorGLSL.cpp index bb07a1eb4e..7ca4341dcd 100644 --- a/src/3rdparty/angle/src/compiler/TranslatorGLSL.cpp +++ b/src/3rdparty/angle/src/compiler/TranslatorGLSL.cpp @@ -35,7 +35,10 @@ void TranslatorGLSL::translate(TIntermNode* root) { getBuiltInFunctionEmulator().OutputEmulatedFunctionDefinition( sink, false); + // Write array bounds clamping emulation if needed. + getArrayBoundsClamper().OutputClampingFunctionDefinition(sink); + // Write translated shader. - TOutputGLSL outputGLSL(sink); + TOutputGLSL outputGLSL(sink, getArrayIndexClampingStrategy(), getHashFunction(), getNameMap(), getSymbolTable()); root->traverse(&outputGLSL); } diff --git a/src/3rdparty/angle/src/compiler/TranslatorHLSL.cpp b/src/3rdparty/angle/src/compiler/TranslatorHLSL.cpp index f41decd48c..37408a07c4 100644 --- a/src/3rdparty/angle/src/compiler/TranslatorHLSL.cpp +++ b/src/3rdparty/angle/src/compiler/TranslatorHLSL.cpp @@ -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. // @@ -9,15 +9,16 @@ #include "compiler/InitializeParseContext.h" #include "compiler/OutputHLSL.h" -TranslatorHLSL::TranslatorHLSL(ShShaderType type, ShShaderSpec spec) - : TCompiler(type, spec) +TranslatorHLSL::TranslatorHLSL(ShShaderType type, ShShaderSpec spec, ShShaderOutput output) + : TCompiler(type, spec), mOutputType(output) { } void TranslatorHLSL::translate(TIntermNode *root) { TParseContext& parseContext = *GetGlobalParseContext(); - sh::OutputHLSL outputHLSL(parseContext); + sh::OutputHLSL outputHLSL(parseContext, getResources(), mOutputType); outputHLSL.output(); + mActiveUniforms = outputHLSL.getUniforms(); } diff --git a/src/3rdparty/angle/src/compiler/TranslatorHLSL.h b/src/3rdparty/angle/src/compiler/TranslatorHLSL.h index c3f672ba91..9550e15e8e 100644 --- a/src/3rdparty/angle/src/compiler/TranslatorHLSL.h +++ b/src/3rdparty/angle/src/compiler/TranslatorHLSL.h @@ -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. // @@ -8,13 +8,20 @@ #define COMPILER_TRANSLATORHLSL_H_ #include "compiler/ShHandle.h" +#include "compiler/Uniform.h" class TranslatorHLSL : public TCompiler { public: - TranslatorHLSL(ShShaderType type, ShShaderSpec spec); + TranslatorHLSL(ShShaderType type, ShShaderSpec spec, ShShaderOutput output); + + virtual TranslatorHLSL *getAsTranslatorHLSL() { return this; } + const sh::ActiveUniforms &getUniforms() { return mActiveUniforms; } protected: virtual void translate(TIntermNode* root); + + sh::ActiveUniforms mActiveUniforms; + ShShaderOutput mOutputType; }; #endif // COMPILER_TRANSLATORHLSL_H_ diff --git a/src/3rdparty/angle/src/compiler/Types.h b/src/3rdparty/angle/src/compiler/Types.h index d4576673b1..854bb44c07 100644 --- a/src/3rdparty/angle/src/compiler/Types.h +++ b/src/3rdparty/angle/src/compiler/Types.h @@ -136,6 +136,43 @@ public: return totalSize; } + int elementRegisterCount() const + { + TTypeList *structure = getStruct(); + + if (structure) + { + int registerCount = 0; + + for (size_t i = 0; i < structure->size(); i++) + { + registerCount += (*structure)[i].type->totalRegisterCount(); + } + + return registerCount; + } + else if (isMatrix()) + { + return getNominalSize(); + } + else + { + return 1; + } + } + + int totalRegisterCount() const + { + if (array) + { + return arraySize * elementRegisterCount(); + } + else + { + return elementRegisterCount(); + } + } + bool isMatrix() const { return matrix ? true : false; } void setMatrix(bool m) { matrix = m; } diff --git a/src/3rdparty/angle/src/compiler/UnfoldShortCircuit.cpp b/src/3rdparty/angle/src/compiler/UnfoldShortCircuit.cpp index 1782ebc90c..47f0afca6a 100644 --- a/src/3rdparty/angle/src/compiler/UnfoldShortCircuit.cpp +++ b/src/3rdparty/angle/src/compiler/UnfoldShortCircuit.cpp @@ -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. // @@ -95,9 +95,9 @@ bool UnfoldShortCircuit::visitBinary(Visit visit, TIntermBinary *node) mTemporaryIndex = i + 1; } return false; + default: + return true; } - - return true; } bool UnfoldShortCircuit::visitSelection(Visit visit, TIntermSelection *node) @@ -111,6 +111,8 @@ bool UnfoldShortCircuit::visitSelection(Visit visit, TIntermSelection *node) out << mOutputHLSL->typeString(node->getType()) << " s" << i << ";\n"; + out << "{\n"; + mTemporaryIndex = i + 1; node->getCondition()->traverse(this); out << "if("; @@ -135,6 +137,8 @@ bool UnfoldShortCircuit::visitSelection(Visit visit, TIntermSelection *node) out << ";\n" "}\n"; + out << "}\n"; + mTemporaryIndex = i + 1; } diff --git a/src/3rdparty/angle/src/compiler/Uniform.cpp b/src/3rdparty/angle/src/compiler/Uniform.cpp new file mode 100644 index 0000000000..f367db2be8 --- /dev/null +++ b/src/3rdparty/angle/src/compiler/Uniform.cpp @@ -0,0 +1,21 @@ +// +// Copyright (c) 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. +// + +#include "compiler/Uniform.h" + +namespace sh +{ + +Uniform::Uniform(GLenum type, GLenum precision, const char *name, int arraySize, int registerIndex) +{ + this->type = type; + this->precision = precision; + this->name = name; + this->arraySize = arraySize; + this->registerIndex = registerIndex; +} + +} diff --git a/src/3rdparty/angle/src/compiler/Uniform.h b/src/3rdparty/angle/src/compiler/Uniform.h new file mode 100644 index 0000000000..4c53ffa7d2 --- /dev/null +++ b/src/3rdparty/angle/src/compiler/Uniform.h @@ -0,0 +1,35 @@ +// +// Copyright (c) 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 COMPILER_UNIFORM_H_ +#define COMPILER_UNIFORM_H_ + +#include <string> +#include <vector> + +#define GL_APICALL +#include <GLES2/gl2.h> + +namespace sh +{ + +struct Uniform +{ + Uniform(GLenum type, GLenum precision, const char *name, int arraySize, int registerIndex); + + GLenum type; + GLenum precision; + std::string name; + unsigned int arraySize; + + int registerIndex; +}; + +typedef std::vector<Uniform> ActiveUniforms; + +} + +#endif // COMPILER_UNIFORM_H_ diff --git a/src/3rdparty/angle/src/compiler/ValidateLimitations.cpp b/src/3rdparty/angle/src/compiler/ValidateLimitations.cpp index d69ec6bbaa..a5562d09a4 100644 --- a/src/3rdparty/angle/src/compiler/ValidateLimitations.cpp +++ b/src/3rdparty/angle/src/compiler/ValidateLimitations.cpp @@ -421,7 +421,7 @@ bool ValidateLimitations::validateFunctionCall(TIntermAggregate* node) return true; // List of param indices for which loop indices are used as argument. - typedef std::vector<int> ParamIndex; + typedef std::vector<size_t> ParamIndex; ParamIndex pIndex; TIntermSequence& params = node->getSequence(); for (TIntermSequence::size_type i = 0; i < params.size(); ++i) { diff --git a/src/3rdparty/angle/src/compiler/VariableInfo.cpp b/src/3rdparty/angle/src/compiler/VariableInfo.cpp index 3ff283627b..eb6bea9b0f 100644 --- a/src/3rdparty/angle/src/compiler/VariableInfo.cpp +++ b/src/3rdparty/angle/src/compiler/VariableInfo.cpp @@ -77,23 +77,25 @@ static void getBuiltInVariableInfo(const TType& type, static void getUserDefinedVariableInfo(const TType& type, const TString& name, const TString& mappedName, - TVariableInfoList& infoList); + TVariableInfoList& infoList, + ShHashFunction64 hashFunction); // Returns info for an attribute or uniform. static void getVariableInfo(const TType& type, const TString& name, const TString& mappedName, - TVariableInfoList& infoList) + TVariableInfoList& infoList, + ShHashFunction64 hashFunction) { if (type.getBasicType() == EbtStruct) { if (type.isArray()) { for (int i = 0; i < type.getArraySize(); ++i) { TString lname = name + arrayBrackets(i); TString lmappedName = mappedName + arrayBrackets(i); - getUserDefinedVariableInfo(type, lname, lmappedName, infoList); + getUserDefinedVariableInfo(type, lname, lmappedName, infoList, hashFunction); } } else { - getUserDefinedVariableInfo(type, name, mappedName, infoList); + getUserDefinedVariableInfo(type, name, mappedName, infoList, hashFunction); } } else { getBuiltInVariableInfo(type, name, mappedName, infoList); @@ -124,7 +126,8 @@ void getBuiltInVariableInfo(const TType& type, void getUserDefinedVariableInfo(const TType& type, const TString& name, const TString& mappedName, - TVariableInfoList& infoList) + TVariableInfoList& infoList, + ShHashFunction64 hashFunction) { ASSERT(type.getBasicType() == EbtStruct); @@ -133,8 +136,9 @@ void getUserDefinedVariableInfo(const TType& type, const TType* fieldType = (*structure)[i].type; getVariableInfo(*fieldType, name + "." + fieldType->getFieldName(), - mappedName + "." + fieldType->getFieldName(), - infoList); + mappedName + "." + TIntermTraverser::hash(fieldType->getFieldName(), hashFunction), + infoList, + hashFunction); } } @@ -149,9 +153,11 @@ TVariableInfo::TVariableInfo(ShDataType type, int size) } CollectAttribsUniforms::CollectAttribsUniforms(TVariableInfoList& attribs, - TVariableInfoList& uniforms) + TVariableInfoList& uniforms, + ShHashFunction64 hashFunction) : mAttribs(attribs), - mUniforms(uniforms) + mUniforms(uniforms), + mHashFunction(hashFunction) { } @@ -206,10 +212,16 @@ bool CollectAttribsUniforms::visitAggregate(Visit, TIntermAggregate* node) // cannot be initialized in a shader, we must have only // TIntermSymbol nodes in the sequence. ASSERT(variable != NULL); + TString processedSymbol; + if (mHashFunction == NULL) + processedSymbol = variable->getSymbol(); + else + processedSymbol = TIntermTraverser::hash(variable->getOriginalSymbol(), mHashFunction); getVariableInfo(variable->getType(), variable->getOriginalSymbol(), - variable->getSymbol(), - infoList); + processedSymbol, + infoList, + mHashFunction); } } break; diff --git a/src/3rdparty/angle/src/compiler/VariableInfo.h b/src/3rdparty/angle/src/compiler/VariableInfo.h index fdcc08f5b5..4130a589f5 100644 --- a/src/3rdparty/angle/src/compiler/VariableInfo.h +++ b/src/3rdparty/angle/src/compiler/VariableInfo.h @@ -27,7 +27,8 @@ typedef std::vector<TVariableInfo> TVariableInfoList; class CollectAttribsUniforms : public TIntermTraverser { public: CollectAttribsUniforms(TVariableInfoList& attribs, - TVariableInfoList& uniforms); + TVariableInfoList& uniforms, + ShHashFunction64 hashFunction); virtual void visitSymbol(TIntermSymbol*); virtual void visitConstantUnion(TIntermConstantUnion*); @@ -41,6 +42,8 @@ public: private: TVariableInfoList& mAttribs; TVariableInfoList& mUniforms; + + ShHashFunction64 mHashFunction; }; #endif // COMPILER_VARIABLE_INFO_H_ diff --git a/src/3rdparty/angle/src/compiler/VariablePacker.cpp b/src/3rdparty/angle/src/compiler/VariablePacker.cpp index 2f0c4bc2a2..8957287763 100644 --- a/src/3rdparty/angle/src/compiler/VariablePacker.cpp +++ b/src/3rdparty/angle/src/compiler/VariablePacker.cpp @@ -85,7 +85,7 @@ int VariablePacker::GetNumRows(ShDataType type) case SH_FLOAT_MAT3: return 3; case SH_FLOAT_MAT2: - return 1; + return 2; case SH_FLOAT_VEC4: case SH_INT_VEC4: case SH_BOOL_VEC4: diff --git a/src/3rdparty/angle/src/compiler/glslang.h b/src/3rdparty/angle/src/compiler/glslang.h index 3a45daf3a4..f221199093 100644 --- a/src/3rdparty/angle/src/compiler/glslang.h +++ b/src/3rdparty/angle/src/compiler/glslang.h @@ -8,7 +8,7 @@ struct TParseContext; extern int glslang_initialize(TParseContext* context); extern int glslang_finalize(TParseContext* context); -extern int glslang_scan(int count, +extern int glslang_scan(size_t count, const char* const string[], const int length[], TParseContext* context); diff --git a/src/3rdparty/angle/src/compiler/glslang.l b/src/3rdparty/angle/src/compiler/glslang.l index e0483e2ea9..140a9aeb2d 100644 --- a/src/3rdparty/angle/src/compiler/glslang.l +++ b/src/3rdparty/angle/src/compiler/glslang.l @@ -38,7 +38,7 @@ WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp). %{ #include "compiler/glslang.h" #include "compiler/ParseHelper.h" -#include "compiler/preprocessor/new/Token.h" +#include "compiler/preprocessor/Token.h" #include "compiler/util.h" #include "glslang_tab.h" @@ -51,7 +51,7 @@ WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp). #define YY_INPUT(buf, result, max_size) \ result = string_input(buf, max_size, yyscanner); -static int string_input(char* buf, int max_size, yyscan_t yyscanner); +static yy_size_t string_input(char* buf, yy_size_t max_size, yyscan_t yyscanner); static int check_type(yyscan_t yyscanner); static int reserved_word(yyscan_t yyscanner); %} @@ -203,10 +203,10 @@ O [0-7] return check_type(yyscanner); } -0[xX]{H}+ { yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); } -0{O}+ { yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); } +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 = 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); } @@ -272,146 +272,13 @@ O [0-7] %% -// Old preprocessor interface. -extern "C" { -#include "compiler/preprocessor/preprocess.h" - -extern int InitPreprocessor(); -extern int FinalizePreprocessor(); -extern void PredefineIntMacro(const char *name, int value); - -#define SETUP_CONTEXT(pp) \ - TParseContext* context = (TParseContext*) pp->pC; \ - struct yyguts_t* yyg = (struct yyguts_t*) context->scanner; - -// Preprocessor callbacks. -void CPPDebugLogMsg(const char *msg) -{ - SETUP_CONTEXT(cpp); - context->trace(msg); -} - -void CPPWarningToInfoLog(const char *msg) -{ - SETUP_CONTEXT(cpp); - context->warning(yylineno, msg, ""); -} - -void CPPShInfoLogMsg(const char *msg) -{ - SETUP_CONTEXT(cpp); - context->error(yylineno, msg, ""); - context->recover(); -} - -void CPPErrorToInfoLog(const char *msg) -{ - SETUP_CONTEXT(cpp); - context->error(yylineno, msg, ""); - context->recover(); -} - -void SetLineNumber(int line) -{ - SETUP_CONTEXT(cpp); - int string = 0; - DecodeSourceLoc(yylineno, &string, NULL); - yylineno = EncodeSourceLoc(string, line); -} - -void SetStringNumber(int string) -{ - SETUP_CONTEXT(cpp); - int line = 0; - DecodeSourceLoc(yylineno, NULL, &line); - yylineno = EncodeSourceLoc(string, line); -} - -int GetStringNumber() -{ - SETUP_CONTEXT(cpp); - int string = 0; - DecodeSourceLoc(yylineno, &string, NULL); - return string; -} - -int GetLineNumber() -{ - SETUP_CONTEXT(cpp); - int line = 0; - DecodeSourceLoc(yylineno, NULL, &line); - return line; -} - -void IncLineNumber() -{ - SETUP_CONTEXT(cpp); - int string = 0, line = 0; - DecodeSourceLoc(yylineno, &string, &line); - yylineno = EncodeSourceLoc(string, ++line); -} - -void DecLineNumber() -{ - SETUP_CONTEXT(cpp); - int string = 0, line = 0; - DecodeSourceLoc(yylineno, &string, &line); - yylineno = EncodeSourceLoc(string, --line); -} - -void HandlePragma(const char **tokens, int numTokens) -{ - SETUP_CONTEXT(cpp); - - if (numTokens != 4) return; - if (strcmp(tokens[1], "(") != 0) return; - if (strcmp(tokens[3], ")") != 0) return; - - context->handlePragmaDirective(yylineno, tokens[0], tokens[2]); -} - -void StoreStr(const char *string) -{ - SETUP_CONTEXT(cpp); - TString strSrc; - strSrc = TString(string); - - context->HashErrMsg = context->HashErrMsg + " " + strSrc; -} - -const char* GetStrfromTStr(void) -{ - SETUP_CONTEXT(cpp); - cpp->ErrMsg = context->HashErrMsg.c_str(); - return cpp->ErrMsg; -} - -void ResetTString(void) -{ - SETUP_CONTEXT(cpp); - context->HashErrMsg = ""; -} - -void updateExtensionBehavior(const char* extName, const char* behavior) -{ - SETUP_CONTEXT(cpp); - context->handleExtensionDirective(yylineno, extName, behavior); -} -} // extern "C" - -int string_input(char* buf, int max_size, yyscan_t yyscanner) { - int len = 0; - -#if ANGLE_USE_NEW_PREPROCESSOR +yy_size_t string_input(char* buf, yy_size_t max_size, yyscan_t yyscanner) { pp::Token token; yyget_extra(yyscanner)->preprocessor.lex(&token); - len = token.type == pp::Token::LAST ? 0 : token.text.size(); - if ((len > 0) && (len < max_size)) + 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); -#else - len = yylex_CPP(buf, max_size); -#endif // ANGLE_USE_NEW_PREPROCESSOR if (len >= max_size) YY_FATAL_ERROR("Input buffer overflow"); @@ -471,41 +338,28 @@ int glslang_finalize(TParseContext* context) { context->scanner = NULL; yylex_destroy(scanner); -#if !ANGLE_USE_NEW_PREPROCESSOR - FinalizePreprocessor(); -#endif return 0; } -int glslang_scan(int count, const char* const string[], const int length[], +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; // Initialize preprocessor. -#if ANGLE_USE_NEW_PREPROCESSOR if (!context->preprocessor.init(count, string, length)) return 1; -#else - if (InitPreprocessor()) - return 1; - cpp->pC = context; - cpp->pastFirstStatement = 0; - if (InitScannerInput(cpp, count, string, length)) - return 1; -#endif // ANGLE_USE_NEW_PREPROCESSOR // Define extension macros. const TExtensionBehavior& extBehavior = context->extensionBehavior(); for (TExtensionBehavior::const_iterator iter = extBehavior.begin(); iter != extBehavior.end(); ++iter) { -#if ANGLE_USE_NEW_PREPROCESSOR context->preprocessor.predefineMacro(iter->first.c_str(), 1); -#else - PredefineIntMacro(iter->first.c_str(), 1); -#endif } + if (context->fragmentPrecisionHigh) + context->preprocessor.predefineMacro("GL_FRAGMENT_PRECISION_HIGH", 1); + return 0; } diff --git a/src/3rdparty/angle/src/compiler/glslang.y b/src/3rdparty/angle/src/compiler/glslang.y index 39c9cee26e..8dbcee32ef 100644 --- a/src/3rdparty/angle/src/compiler/glslang.y +++ b/src/3rdparty/angle/src/compiler/glslang.y @@ -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. // @@ -38,6 +38,9 @@ WHICH GENERATES THE GLSL ES PARSER (glslang_tab.cpp AND glslang_tab.h). #include "compiler/ParseHelper.h" #include "GLSLANG/ShaderLang.h" +#define YYENABLE_NLS 0 +#define YYLTYPE_IS_TRIVIAL 1 + #define YYLEX_PARAM context->scanner %} @@ -242,36 +245,36 @@ postfix_expression } if ($1->getType().getQualifier() == EvqConst && $3->getQualifier() == EvqConst) { if ($1->isArray()) { // constant folding for arrays - $$ = context->addConstArrayNode($3->getAsConstantUnion()->getUnionArrayPointer()->getIConst(), $1, $2.line); + $$ = context->addConstArrayNode($3->getAsConstantUnion()->getIConst(0), $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 + fields.offsets[0] = $3->getAsConstantUnion()->getIConst(0); // 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); + $$ = context->addConstMatrixNode($3->getAsConstantUnion()->getIConst(0), $1, $2.line); } } else { if ($3->getQualifier() == EvqConst) { - if (($1->isVector() || $1->isMatrix()) && $1->getType().getNominalSize() <= $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst() && !$1->isArray() ) { + if (($1->isVector() || $1->isMatrix()) && $1->getType().getNominalSize() <= $3->getAsConstantUnion()->getIConst(0) && !$1->isArray() ) { std::stringstream extraInfoStream; - extraInfoStream << "field selection out of range '" << $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst() << "'"; + extraInfoStream << "field selection out of range '" << $3->getAsConstantUnion()->getIConst(0) << "'"; 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)) + if ($1->getType().getMaxArraySize() <= $3->getAsConstantUnion()->getIConst(0)) { + if (context->arraySetMaxSize($1->getAsSymbolNode(), $1->getTypePointer(), $3->getAsConstantUnion()->getIConst(0), 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()) { + } else if ( $3->getAsConstantUnion()->getIConst(0) >= $1->getType().getArraySize()) { std::stringstream extraInfoStream; - extraInfoStream << "array index out of range '" << $3->getAsConstantUnion()->getUnionArrayPointer()->getIConst() << "'"; + extraInfoStream << "array index out of range '" << $3->getAsConstantUnion()->getIConst(0) << "'"; std::string extraInfo = extraInfoStream.str(); context->error($2.line, "", "[", extraInfo.c_str()); context->recover(); @@ -521,7 +524,7 @@ function_call $$->getAsAggregate()->setName(fnCandidate->getMangledName()); TQualifier qual; - for (int i = 0; i < fnCandidate->getParamCount(); ++i) { + for (size_t i = 0; i < fnCandidate->getParamCount(); ++i) { qual = fnCandidate->getParam(i).type->getQualifier(); if (qual == EvqOut || qual == EvqInOut) { if (context->lValueErrorCheck($$->getLine(), "assign", $$->getAsAggregate()->getSequence()[i]->getAsTyped())) { @@ -962,7 +965,7 @@ declaration prototype->setType(function.getReturnType()); prototype->setName(function.getName()); - for (int i = 0; i < function.getParamCount(); i++) + for (size_t i = 0; i < function.getParamCount(); i++) { const TParameter ¶m = function.getParam(i); if (param.name != 0) @@ -988,7 +991,14 @@ declaration $$ = $1.intermAggregate; } | PRECISION precision_qualifier type_specifier_no_prec SEMICOLON { - context->symbolTable.setDefaultPrecision( $3.type, $2 ); + if (($2 == EbpHigh) && (context->shaderType == SH_FRAGMENT_SHADER) && !context->fragmentPrecisionHigh) { + context->error($1.line, "precision is not supported in fragment shader", "highp"); + context->recover(); + } + if (!context->symbolTable.setDefaultPrecision( $3, $2 )) { + context->error($1.line, "illegal type argument for default precision qualifier", getBasicString($3.type)); + context->recover(); + } $$ = 0; } ; @@ -1009,7 +1019,7 @@ function_prototype context->error($2.line, "overloaded functions must have the same return type", $1->getReturnType().getBasicString()); context->recover(); } - for (int i = 0; i < prevDec->getParamCount(); ++i) { + for (size_t i = 0; i < prevDec->getParamCount(); ++i) { if (prevDec->getParam(i).type->getQualifier() != $1->getParam(i).type->getQualifier()) { context->error($2.line, "overloaded functions must have the same parameter qualifiers", $1->getParam(i).type->getQualifierString()); context->recover(); @@ -2079,7 +2089,7 @@ function_definition // knows where to find parameters. // TIntermAggregate* paramNodes = new TIntermAggregate; - for (int i = 0; i < function->getParamCount(); i++) { + for (size_t i = 0; i < function->getParamCount(); i++) { const TParameter& param = function->getParam(i); if (param.name != 0) { TVariable *variable = new TVariable(param.name, *param.type); @@ -2139,4 +2149,3 @@ function_definition int glslang_parse(TParseContext* context) { return yyparse(context); } - diff --git a/src/3rdparty/angle/src/compiler/intermOut.cpp b/src/3rdparty/angle/src/compiler/intermOut.cpp index e83c7b72f2..f48a049c63 100644 --- a/src/3rdparty/angle/src/compiler/intermOut.cpp +++ b/src/3rdparty/angle/src/compiler/intermOut.cpp @@ -42,7 +42,7 @@ TString TType::getCompleteString() const if (qualifier != EvqTemporary && qualifier != EvqGlobal) stream << getQualifierString() << " " << getPrecisionString() << " "; if (array) - stream << "array of "; + stream << "array[" << getArraySize() << "] of "; if (matrix) stream << size << "X" << size << " matrix of "; else if (size > 1) diff --git a/src/3rdparty/angle/src/compiler/intermediate.h b/src/3rdparty/angle/src/compiler/intermediate.h index af78fa00ef..8e76ef921f 100644 --- a/src/3rdparty/angle/src/compiler/intermediate.h +++ b/src/3rdparty/angle/src/compiler/intermediate.h @@ -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. // @@ -16,6 +16,8 @@ #ifndef __INTERMEDIATE_H #define __INTERMEDIATE_H +#include "GLSLANG/ShaderLang.h" + #include "compiler/Common.h" #include "compiler/Types.h" #include "compiler/ConstantUnion.h" @@ -181,7 +183,7 @@ enum TOperator { EOpVectorTimesScalarAssign, EOpMatrixTimesScalarAssign, EOpMatrixTimesMatrixAssign, - EOpDivAssign, + EOpDivAssign }; extern const char* getOperatorString(TOperator op); @@ -257,6 +259,10 @@ public: const char* getQualifierString() const { return type.getQualifierString(); } TString getCompleteString() const { return type.getCompleteString(); } + int totalRegisterCount() const { return type.totalRegisterCount(); } + int elementRegisterCount() const { return type.elementRegisterCount(); } + int getArraySize() const { return type.getArraySize(); } + protected: TType type; }; @@ -267,7 +273,7 @@ protected: enum TLoopType { ELoopFor, ELoopWhile, - ELoopDoWhile, + ELoopDoWhile }; class TIntermLoop : public TIntermNode { @@ -356,7 +362,10 @@ public: TIntermConstantUnion(ConstantUnion *unionPointer, const TType& t) : TIntermTyped(t), unionArrayPointer(unionPointer) { } ConstantUnion* getUnionArrayPointer() const { return unionArrayPointer; } - void setUnionArrayPointer(ConstantUnion *c) { unionArrayPointer = c; } + + int getIConst(int index) const { return unionArrayPointer ? unionArrayPointer[index].getIConst() : 0; } + float getFConst(int index) const { return unionArrayPointer ? unionArrayPointer[index].getFConst() : 0.0f; } + bool getBConst(int index) const { return unionArrayPointer ? unionArrayPointer[index].getBConst() : false; } virtual TIntermConstantUnion* getAsConstantUnion() { return this; } virtual void traverse(TIntermTraverser*); @@ -389,7 +398,7 @@ protected: // class TIntermBinary : public TIntermOperator { public: - TIntermBinary(TOperator o) : TIntermOperator(o) {} + TIntermBinary(TOperator o) : TIntermOperator(o), addIndexClamp(false) {} virtual TIntermBinary* getAsBinaryNode() { return this; } virtual void traverse(TIntermTraverser*); @@ -400,9 +409,15 @@ public: TIntermTyped* getRight() const { return right; } bool promote(TInfoSink&); + void setAddIndexClamp() { addIndexClamp = true; } + bool getAddIndexClamp() { return addIndexClamp; } + protected: TIntermTyped* left; TIntermTyped* right; + + // If set to true, wrap any EOpIndexIndirect with a clamp to bounds. + bool addIndexClamp; }; // @@ -545,6 +560,10 @@ public: void incrementDepth() {depth++;} void decrementDepth() {depth--;} + // Return the original name if hash function pointer is NULL; + // otherwise return the hashed name. + static TString hash(const TString& name, ShHashFunction64 hashFunction); + const bool preVisit; const bool inVisit; const bool postVisit; diff --git a/src/3rdparty/angle/src/compiler/osinclude.h b/src/3rdparty/angle/src/compiler/osinclude.h index 1d95907b79..d8bb1a797c 100644 --- a/src/3rdparty/angle/src/compiler/osinclude.h +++ b/src/3rdparty/angle/src/compiler/osinclude.h @@ -24,9 +24,7 @@ #error Unsupported platform. #endif -#if defined(ANGLE_USE_NSPR) -#include "prthread.h" -#elif defined(ANGLE_OS_WIN) +#if defined(ANGLE_OS_WIN) #define STRICT #define VC_EXTRALEAN 1 #include <windows.h> @@ -34,7 +32,7 @@ #include <pthread.h> #include <semaphore.h> #include <errno.h> -#endif // ANGLE_USE_NSPR +#endif // ANGLE_OS_WIN #include "compiler/debug.h" @@ -42,16 +40,13 @@ // // Thread Local Storage Operations // -#if defined(ANGLE_USE_NSPR) -typedef PRUintn OS_TLSIndex; -#define OS_INVALID_TLS_INDEX 0xFFFFFFFF -#elif defined(ANGLE_OS_WIN) +#if defined(ANGLE_OS_WIN) typedef DWORD OS_TLSIndex; #define OS_INVALID_TLS_INDEX (TLS_OUT_OF_INDEXES) #elif defined(ANGLE_OS_POSIX) -typedef unsigned int OS_TLSIndex; -#define OS_INVALID_TLS_INDEX 0xFFFFFFFF -#endif // ANGLE_USE_NSPR +typedef pthread_key_t OS_TLSIndex; +#define OS_INVALID_TLS_INDEX (static_cast<OS_TLSIndex>(-1)) +#endif // ANGLE_OS_WIN OS_TLSIndex OS_AllocTLSIndex(); bool OS_SetTLSValue(OS_TLSIndex nIndex, void *lpvValue); @@ -60,9 +55,7 @@ bool OS_FreeTLSIndex(OS_TLSIndex nIndex); inline void* OS_GetTLSValue(OS_TLSIndex nIndex) { ASSERT(nIndex != OS_INVALID_TLS_INDEX); -#if defined(ANGLE_USE_NSPR) - return PR_GetThreadPrivate(nIndex); -#elif defined(ANGLE_OS_WIN) +#if defined(ANGLE_OS_WIN) return TlsGetValue(nIndex); #elif defined(ANGLE_OS_POSIX) return pthread_getspecific(nIndex); diff --git a/src/3rdparty/angle/src/compiler/ossource_nspr.cpp b/src/3rdparty/angle/src/compiler/ossource_nspr.cpp deleted file mode 100644 index f63d81e5d5..0000000000 --- a/src/3rdparty/angle/src/compiler/ossource_nspr.cpp +++ /dev/null @@ -1,43 +0,0 @@ -// -// Copyright (c) 2002-2010 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 contains the nspr specific functions -// -#include "compiler/osinclude.h" - -// -// Thread Local Storage Operations -// -OS_TLSIndex OS_AllocTLSIndex() -{ - PRUintn index; - PRStatus status = PR_NewThreadPrivateIndex(&index, NULL); - - if (status) { - assert(0 && "OS_AllocTLSIndex(): Unable to allocate Thread Local Storage"); - return OS_INVALID_TLS_INDEX; - } - - return index; -} - -bool OS_SetTLSValue(OS_TLSIndex nIndex, void *lpvValue) -{ - if (nIndex == OS_INVALID_TLS_INDEX) { - assert(0 && "OS_SetTLSValue(): Invalid TLS Index"); - return false; - } - - return PR_SetThreadPrivate(nIndex, lpvValue) == 0; -} - -bool OS_FreeTLSIndex(OS_TLSIndex nIndex) -{ - // Can't delete TLS keys with nspr - return true; -} - diff --git a/src/3rdparty/angle/src/compiler/parseConst.cpp b/src/3rdparty/angle/src/compiler/parseConst.cpp index 9a8a50c31c..421d31f586 100644 --- a/src/3rdparty/angle/src/compiler/parseConst.cpp +++ b/src/3rdparty/angle/src/compiler/parseConst.cpp @@ -151,6 +151,13 @@ bool TConstTraverser::visitSelection(Visit visit, TIntermSelection* node) void TConstTraverser::visitConstantUnion(TIntermConstantUnion* node) { + if (!node->getUnionArrayPointer()) + { + // The constant was not initialized, this should already have been logged + assert(infoSink.info.size() != 0); + return; + } + ConstantUnion* leftUnionArray = unionArray; int instanceSize = type.getObjectSize(); diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Diagnostics.cpp b/src/3rdparty/angle/src/compiler/preprocessor/DiagnosticsBase.cpp index 3f50dfc98a..3e22e1f1c5 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Diagnostics.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/DiagnosticsBase.cpp @@ -4,7 +4,7 @@ // found in the LICENSE file. // -#include "Diagnostics.h" +#include "DiagnosticsBase.h" #include <cassert> diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Diagnostics.h b/src/3rdparty/angle/src/compiler/preprocessor/DiagnosticsBase.h index 07bc411846..07bc411846 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Diagnostics.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/DiagnosticsBase.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/DirectiveHandler.cpp b/src/3rdparty/angle/src/compiler/preprocessor/DirectiveHandlerBase.cpp index ca91e1c71b..ef35c6ed50 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/DirectiveHandler.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/DirectiveHandlerBase.cpp @@ -4,7 +4,7 @@ // found in the LICENSE file. // -#include "DirectiveHandler.h" +#include "DirectiveHandlerBase.h" namespace pp { diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/DirectiveHandler.h b/src/3rdparty/angle/src/compiler/preprocessor/DirectiveHandlerBase.h index 2aaeec2818..2aaeec2818 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/DirectiveHandler.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/DirectiveHandlerBase.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/DirectiveParser.cpp b/src/3rdparty/angle/src/compiler/preprocessor/DirectiveParser.cpp index f2e42d06bf..94dfdf513d 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/DirectiveParser.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/DirectiveParser.cpp @@ -10,8 +10,8 @@ #include <cstdlib> #include <sstream> -#include "Diagnostics.h" -#include "DirectiveHandler.h" +#include "DiagnosticsBase.h" +#include "DirectiveHandlerBase.h" #include "ExpressionParser.h" #include "MacroExpander.h" #include "Token.h" diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/DirectiveParser.h b/src/3rdparty/angle/src/compiler/preprocessor/DirectiveParser.h index 8a7f0072ba..8a7f0072ba 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/DirectiveParser.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/DirectiveParser.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/ExpressionParser.h b/src/3rdparty/angle/src/compiler/preprocessor/ExpressionParser.h index 092d059413..092d059413 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/ExpressionParser.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/ExpressionParser.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/ExpressionParser.y b/src/3rdparty/angle/src/compiler/preprocessor/ExpressionParser.y index 832ad4001e..b6d3143e60 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/ExpressionParser.y +++ b/src/3rdparty/angle/src/compiler/preprocessor/ExpressionParser.y @@ -22,7 +22,11 @@ WHICH GENERATES THE GLSL ES preprocessor expression parser. #if defined(__GNUC__) // Triggered by the auto-generated pplval variable. +#if !defined(__clang__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) +#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" +#else #pragma GCC diagnostic ignored "-Wuninitialized" +#endif #elif defined(_MSC_VER) #pragma warning(disable: 4065 4701) #endif @@ -32,7 +36,7 @@ WHICH GENERATES THE GLSL ES preprocessor expression parser. #include <cassert> #include <sstream> -#include "Diagnostics.h" +#include "DiagnosticsBase.h" #include "Lexer.h" #include "Token.h" @@ -42,6 +46,8 @@ typedef __int64 YYSTYPE; #include <stdint.h> typedef intmax_t YYSTYPE; #endif // _MSC_VER +#define YYENABLE_NLS 0 +#define YYLTYPE_IS_TRIVIAL 1 #define YYSTYPE_IS_TRIVIAL 1 #define YYSTYPE_IS_DECLARED 1 diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Input.cpp b/src/3rdparty/angle/src/compiler/preprocessor/Input.cpp index c3de95f313..b4d970a97d 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Input.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/Input.cpp @@ -17,27 +17,26 @@ Input::Input() : mCount(0), mString(0) { } -Input::Input(int count, const char* const string[], const int length[]) : +Input::Input(size_t count, const char* const string[], const int length[]) : mCount(count), mString(string) { - assert(mCount >= 0); mLength.reserve(mCount); - for (int i = 0; i < mCount; ++i) + for (size_t i = 0; i < mCount; ++i) { int len = length ? length[i] : -1; - mLength.push_back(len < 0 ? strlen(mString[i]) : len); + mLength.push_back(len < 0 ? std::strlen(mString[i]) : len); } } -int Input::read(char* buf, int maxSize) +size_t Input::read(char* buf, size_t maxSize) { - int nRead = 0; + size_t nRead = 0; while ((nRead < maxSize) && (mReadLoc.sIndex < mCount)) { - int size = mLength[mReadLoc.sIndex] - mReadLoc.cIndex; + size_t size = mLength[mReadLoc.sIndex] - mReadLoc.cIndex; size = std::min(size, maxSize); - memcpy(buf + nRead, mString[mReadLoc.sIndex] + mReadLoc.cIndex, size); + std::memcpy(buf + nRead, mString[mReadLoc.sIndex] + mReadLoc.cIndex, size); nRead += size; mReadLoc.cIndex += size; diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Input.h b/src/3rdparty/angle/src/compiler/preprocessor/Input.h index dac734b68d..14b7597cb4 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Input.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/Input.h @@ -7,6 +7,7 @@ #ifndef COMPILER_PREPROCESSOR_INPUT_H_ #define COMPILER_PREPROCESSOR_INPUT_H_ +#include <stddef.h> #include <vector> namespace pp @@ -17,18 +18,18 @@ class Input { public: Input(); - Input(int count, const char* const string[], const int length[]); + Input(size_t count, const char* const string[], const int length[]); - int count() const { return mCount; } - const char* string(int index) const { return mString[index]; } - int length(int index) const { return mLength[index]; } + size_t count() const { return mCount; } + const char* string(size_t index) const { return mString[index]; } + size_t length(size_t index) const { return mLength[index]; } - int read(char* buf, int maxSize); + size_t read(char* buf, size_t maxSize); struct Location { - int sIndex; // String index; - int cIndex; // Char index. + size_t sIndex; // String index; + size_t cIndex; // Char index. Location() : sIndex(0), cIndex(0) { } }; @@ -36,9 +37,9 @@ class Input private: // Input. - int mCount; + size_t mCount; const char* const* mString; - std::vector<int> mLength; + std::vector<size_t> mLength; Location mReadLoc; }; diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Lexer.cpp b/src/3rdparty/angle/src/compiler/preprocessor/Lexer.cpp index 7c663ee761..7c663ee761 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Lexer.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/Lexer.cpp diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Lexer.h b/src/3rdparty/angle/src/compiler/preprocessor/Lexer.h index eb85cea873..eb85cea873 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Lexer.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/Lexer.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Macro.cpp b/src/3rdparty/angle/src/compiler/preprocessor/Macro.cpp index b2e3088e32..b2e3088e32 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Macro.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/Macro.cpp diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Macro.h b/src/3rdparty/angle/src/compiler/preprocessor/Macro.h index 7ec0149116..7ec0149116 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Macro.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/Macro.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/MacroExpander.cpp b/src/3rdparty/angle/src/compiler/preprocessor/MacroExpander.cpp index 701cec9a4b..1116c516ff 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/MacroExpander.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/MacroExpander.cpp @@ -9,7 +9,7 @@ #include <algorithm> #include <sstream> -#include "Diagnostics.h" +#include "DiagnosticsBase.h" #include "Token.h" namespace pp @@ -57,7 +57,7 @@ MacroExpander::MacroExpander(Lexer* lexer, MacroExpander::~MacroExpander() { - for (size_t i = 0; i < mContextStack.size(); ++i) + for (std::size_t i = 0; i < mContextStack.size(); ++i) { delete mContextStack[i]; } @@ -224,7 +224,7 @@ bool MacroExpander::expandMacro(const Macro& macro, replaceMacroParams(macro, args, replacements); } - for (size_t i = 0; i < replacements->size(); ++i) + for (std::size_t i = 0; i < replacements->size(); ++i) { Token& repl = replacements->at(i); if (i == 0) @@ -311,7 +311,7 @@ bool MacroExpander::collectMacroArgs(const Macro& macro, // Pre-expand each argument before substitution. // This step expands each argument individually before they are // inserted into the macro body. - for (size_t i = 0; i < args->size(); ++i) + for (std::size_t i = 0; i < args->size(); ++i) { MacroArg& arg = args->at(i); TokenLexer lexer(&arg); @@ -332,7 +332,7 @@ void MacroExpander::replaceMacroParams(const Macro& macro, const std::vector<MacroArg>& args, std::vector<Token>* replacements) { - for (size_t i = 0; i < macro.replacements.size(); ++i) + for (std::size_t i = 0; i < macro.replacements.size(); ++i) { const Token& repl = macro.replacements[i]; if (repl.type != Token::IDENTIFIER) @@ -352,13 +352,13 @@ void MacroExpander::replaceMacroParams(const Macro& macro, continue; } - size_t iArg = std::distance(macro.parameters.begin(), iter); + std::size_t iArg = std::distance(macro.parameters.begin(), iter); const MacroArg& arg = args[iArg]; if (arg.empty()) { continue; } - size_t iRepl = replacements->size(); + std::size_t iRepl = replacements->size(); replacements->insert(replacements->end(), arg.begin(), arg.end()); // The replacement token inherits padding properties from // macro replacement token. diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/MacroExpander.h b/src/3rdparty/angle/src/compiler/preprocessor/MacroExpander.h index 7c5c543871..21b67571f1 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/MacroExpander.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/MacroExpander.h @@ -53,7 +53,7 @@ class MacroExpander : public Lexer struct MacroContext { const Macro* macro; - size_t index; + std::size_t index; std::vector<Token> replacements; MacroContext() : macro(0), index(0) { } diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Preprocessor.cpp b/src/3rdparty/angle/src/compiler/preprocessor/Preprocessor.cpp index ffa7225a8f..5ffc6420bc 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Preprocessor.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/Preprocessor.cpp @@ -9,7 +9,7 @@ #include <cassert> #include <sstream> -#include "Diagnostics.h" +#include "DiagnosticsBase.h" #include "DirectiveParser.h" #include "Macro.h" #include "MacroExpander.h" @@ -48,7 +48,7 @@ Preprocessor::~Preprocessor() delete mImpl; } -bool Preprocessor::init(int count, +bool Preprocessor::init(size_t count, const char* const string[], const int length[]) { diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Preprocessor.h b/src/3rdparty/angle/src/compiler/preprocessor/Preprocessor.h index 5fe35b27bd..7b70180fc8 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Preprocessor.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/Preprocessor.h @@ -7,6 +7,8 @@ #ifndef COMPILER_PREPROCESSOR_PREPROCESSOR_H_ #define COMPILER_PREPROCESSOR_PREPROCESSOR_H_ +#include <stddef.h> + #include "pp_utils.h" namespace pp @@ -32,7 +34,7 @@ class Preprocessor // Each element in the length array may contain the length of the // corresponding string or a value less than 0 to indicate that the string // is null terminated. - bool init(int count, const char* const string[], const int length[]); + bool init(size_t count, const char* const string[], const int length[]); // Adds a pre-defined macro. void predefineMacro(const char* name, int value); diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/SourceLocation.h b/src/3rdparty/angle/src/compiler/preprocessor/SourceLocation.h index 6982613ac7..6982613ac7 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/SourceLocation.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/SourceLocation.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Token.cpp b/src/3rdparty/angle/src/compiler/preprocessor/Token.cpp index 67f50aa32c..67f50aa32c 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Token.cpp +++ b/src/3rdparty/angle/src/compiler/preprocessor/Token.cpp diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Token.h b/src/3rdparty/angle/src/compiler/preprocessor/Token.h index 8b553aecb6..8b553aecb6 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Token.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/Token.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Tokenizer.h b/src/3rdparty/angle/src/compiler/preprocessor/Tokenizer.h index a594d2d865..7a6fa87b04 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Tokenizer.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/Tokenizer.h @@ -32,12 +32,12 @@ class Tokenizer : public Lexer bool leadingSpace; bool lineStart; }; - static const size_t kMaxTokenLength; + static const std::size_t kMaxTokenLength; Tokenizer(Diagnostics* diagnostics); ~Tokenizer(); - bool init(int count, const char* const string[], const int length[]); + bool init(size_t count, const char* const string[], const int length[]); void setFileNumber(int file); void setLineNumber(int line); diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/Tokenizer.l b/src/3rdparty/angle/src/compiler/preprocessor/Tokenizer.l index 9762988350..fc81d84f37 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/Tokenizer.l +++ b/src/3rdparty/angle/src/compiler/preprocessor/Tokenizer.l @@ -1,6 +1,6 @@ /* // -// 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. // @@ -14,7 +14,7 @@ IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh. %top{ // -// Copyright (c) 2011 The ANGLE Project Authors. All rights reserved. +// Copyright (c) 2011-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. // @@ -25,7 +25,7 @@ IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_parser.sh. %{ #include "Tokenizer.h" -#include "Diagnostics.h" +#include "DiagnosticsBase.h" #include "Token.h" #if defined(__GNUC__) @@ -229,6 +229,8 @@ FRACTIONAL_CONSTANT ({DIGIT}*"."{DIGIT}+)|({DIGIT}+".") return '\n'; } +\\{NEWLINE} { ++yylineno; } + . { yylval->assign(1, yytext[0]); return pp::Token::PP_OTHER; @@ -239,13 +241,14 @@ FRACTIONAL_CONSTANT ({DIGIT}*"."{DIGIT}+)|({DIGIT}+".") // Set the location for EOF token manually. pp::Input* input = &yyextra->input; pp::Input::Location* scanLoc = &yyextra->scanLoc; - int sIndexMax = std::max(0, input->count() - 1); + yy_size_t sIndexMax = input->count() ? input->count() - 1 : 0; if (scanLoc->sIndex != sIndexMax) { // We can only reach here if there are empty strings at the // end of the input. scanLoc->sIndex = sIndexMax; scanLoc->cIndex = 0; - yyfileno = sIndexMax; yylineno = 1; + // FIXME: this is not 64-bit clean. + yyfileno = static_cast<int>(sIndexMax); yylineno = 1; } yylloc->file = yyfileno; yylloc->line = yylineno; @@ -278,9 +281,8 @@ Tokenizer::~Tokenizer() destroyScanner(); } -bool Tokenizer::init(int count, const char* const string[], const int length[]) +bool Tokenizer::init(size_t count, const char* const string[], const int length[]) { - if (count < 0) return false; if ((count > 0) && (string == 0)) return false; mContext.input = Input(count, string, length); diff --git a/src/3rdparty/angle/src/compiler/preprocessor/atom.c b/src/3rdparty/angle/src/compiler/preprocessor/atom.c deleted file mode 100644 index 39158d2fa1..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/atom.c +++ /dev/null @@ -1,737 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ - -// -// atom.c -// - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> - -#include "common/angleutils.h" -#include "compiler/debug.h" -#include "compiler/preprocessor/slglobals.h" - -#undef malloc -#undef realloc -#undef free - -/////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////// String table: ////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -static const struct { - int val; - const char *str; -} tokens[] = { - { CPP_AND_OP, "&&" }, - { CPP_AND_ASSIGN, "&=" }, - { CPP_SUB_ASSIGN, "-=" }, - { CPP_MOD_ASSIGN, "%=" }, - { CPP_ADD_ASSIGN, "+=" }, - { CPP_DIV_ASSIGN, "/=" }, - { CPP_MUL_ASSIGN, "*=" }, - { CPP_RIGHT_BRACKET, ":>" }, - { CPP_EQ_OP, "==" }, - { CPP_XOR_OP, "^^" }, - { CPP_XOR_ASSIGN, "^=" }, - { CPP_FLOATCONSTANT, "<float-const>" }, - { CPP_GE_OP, ">=" }, - { CPP_RIGHT_OP, ">>" }, - { CPP_RIGHT_ASSIGN, ">>=" }, - { CPP_IDENTIFIER, "<ident>" }, - { CPP_INTCONSTANT, "<int-const>" }, - { CPP_LE_OP, "<=" }, - { CPP_LEFT_OP, "<<" }, - { CPP_LEFT_ASSIGN, "<<=" }, - { CPP_LEFT_BRACKET, "<:" }, - { CPP_LEFT_BRACE, "<%" }, - { CPP_DEC_OP, "--" }, - { CPP_RIGHT_BRACE, "%>" }, - { CPP_NE_OP, "!=" }, - { CPP_OR_OP, "||" }, - { CPP_OR_ASSIGN, "|=" }, - { CPP_INC_OP, "++" }, - { CPP_STRCONSTANT, "<string-const>" }, - { CPP_TYPEIDENTIFIER, "<type-ident>" }, -}; - -/////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////////// String table: ////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -#define INIT_STRING_TABLE_SIZE 16384 - -typedef struct StringTable_Rec { - char *strings; - int nextFree; - int size; -} StringTable; - -/* - * InitStringTable() - Initialize the string table. - * - */ - -static int InitStringTable(StringTable *stable) -{ - stable->strings = (char *) malloc(INIT_STRING_TABLE_SIZE); - if (!stable->strings) - return 0; - // Zero-th offset means "empty" so don't use it. - stable->nextFree = 1; - stable->size = INIT_STRING_TABLE_SIZE; - return 1; -} // InitStringTable - -/* - * FreeStringTable() - Free the string table. - * - */ - -static void FreeStringTable(StringTable *stable) -{ - if (stable->strings) - free(stable->strings); - stable->strings = NULL; - stable->nextFree = 0; - stable->size = 0; -} // FreeStringTable - -/* - * HashString() - Hash a string with the base hash function. - * - */ - -static int HashString(const char *s) -{ - int hval = 0; - - while (*s) { - hval = (hval*13507 + *s*197) ^ (hval >> 2); - s++; - } - return hval & 0x7fffffff; -} // HashString - -/* - * HashString2() - Hash a string with the incrimenting hash function. - * - */ - -static int HashString2(const char *s) -{ - int hval = 0; - - while (*s) { - hval = (hval*729 + *s*37) ^ (hval >> 1); - s++; - } - return hval; -} // HashString2 - -/* - * AddString() - Add a string to a string table. Return it's offset. - * - */ - -static int AddString(StringTable *stable, const char *s) -{ - int len, loc; - char *str; - - len = (int) strlen(s); - while (stable->nextFree + len + 1 >= stable->size) { - assert(stable->size < 1000000); - str = (char *) malloc(stable->size*2); - memcpy(str, stable->strings, stable->size); - free(stable->strings); - stable->strings = str; - stable->size = stable->size*2; - } - loc = stable->nextFree; - strcpy(&stable->strings[loc], s); - stable->nextFree += len + 1; - return loc; -} // AddString - -/////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////// Hash table: /////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -#define INIT_HASH_TABLE_SIZE 2047 -#define HASH_TABLE_MAX_COLLISIONS 3 - -typedef struct HashEntry_Rec { - int index; // String table offset of string representation - int value; // Atom (symbol) value -} HashEntry; - -typedef struct HashTable_Rec { - HashEntry *entry; - int size; - int entries; - int counts[HASH_TABLE_MAX_COLLISIONS + 1]; -} HashTable; - -/* - * InitHashTable() - Initialize the hash table. - * - */ - -static int InitHashTable(HashTable *htable, int fsize) -{ - int ii; - - htable->entry = (HashEntry *) malloc(sizeof(HashEntry)*fsize); - if (!htable->entry) - return 0; - htable->size = fsize; - for (ii = 0; ii < fsize; ii++) { - htable->entry[ii].index = 0; - htable->entry[ii].value = 0; - } - htable->entries = 0; - for (ii = 0; ii <= HASH_TABLE_MAX_COLLISIONS; ii++) - htable->counts[ii] = 0; - return 1; -} // InitHashTable - -/* - * FreeHashTable() - Free the hash table. - * - */ - -static void FreeHashTable(HashTable *htable) -{ - if (htable->entry) - free(htable->entry); - htable->entry = NULL; - htable->size = 0; - htable->entries = 0; -} // FreeHashTable - -/* - * Empty() - See if a hash table entry is empty. - * - */ - -static int Empty(HashTable *htable, int hashloc) -{ - assert(hashloc >= 0 && hashloc < htable->size); - if (htable->entry[hashloc].index == 0) { - return 1; - } else { - return 0; - } -} // Empty - -/* - * Match() - See if a hash table entry is matches a string. - * - */ - -static int Match(HashTable *htable, StringTable *stable, const char *s, int hashloc) -{ - int strloc; - - strloc = htable->entry[hashloc].index; - if (!strcmp(s, &stable->strings[strloc])) { - return 1; - } else { - return 0; - } -} // Match - -/////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////// Atom table: /////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -#define INIT_ATOM_TABLE_SIZE 1024 - - -struct AtomTable_Rec { - StringTable stable; // String table. - HashTable htable; // Hashes string to atom number and token value. Multiple strings can - // have the same token value but each unique string is a unique atom. - int *amap; // Maps atom value to offset in string table. Atoms all map to unique - // strings except for some undefined values in the lower, fixed part - // of the atom table that map to "<undefined>". The lowest 256 atoms - // correspond to single character ASCII values except for alphanumeric - // characters and '_', which can be other tokens. Next come the - // language tokens with their atom values equal to the token value. - // Then come predefined atoms, followed by user specified identifiers. - int *arev; // Reversed atom for symbol table use. - int nextFree; - int size; -}; - -static AtomTable latable = { { NULL, 0, 0 }, { NULL, 0, 0, {0} }, NULL, NULL, 0, 0 }; -AtomTable *atable = &latable; - -static int AddAtomFixed(AtomTable *atable, const char *s, int atom); - -/* - * GrowAtomTable() - Grow the atom table to at least "size" if it's smaller. - * - */ - -static int GrowAtomTable(AtomTable *atable, int size) -{ - int *newmap, *newrev; - - if (atable->size < size) { - if (atable->amap) { - newmap = realloc(atable->amap, sizeof(int)*size); - newrev = realloc(atable->arev, sizeof(int)*size); - } else { - newmap = malloc(sizeof(int)*size); - newrev = malloc(sizeof(int)*size); - atable->size = 0; - } - if (!newmap || !newrev) { - /* failed to grow -- error */ - if (newmap) - atable->amap = newmap; - if (newrev) - atable->arev = newrev; - return -1; - } - memset(&newmap[atable->size], 0, (size - atable->size) * sizeof(int)); - memset(&newrev[atable->size], 0, (size - atable->size) * sizeof(int)); - atable->amap = newmap; - atable->arev = newrev; - atable->size = size; - } - return 0; -} // GrowAtomTable - -/* - * lReverse() - Reverse the bottom 20 bits of a 32 bit int. - * - */ - -static int lReverse(int fval) -{ - unsigned int in = fval; - int result = 0, cnt = 0; - - while(in) { - result <<= 1; - result |= in&1; - in >>= 1; - cnt++; - } - - // Don't use all 31 bits. One million atoms is plenty and sometimes the - // upper bits are used for other things. - - if (cnt < 20) - result <<= 20 - cnt; - return result; -} // lReverse - -/* - * AllocateAtom() - Allocate a new atom. Associated with the "undefined" value of -1. - * - */ - -static int AllocateAtom(AtomTable *atable) -{ - if (atable->nextFree >= atable->size) - GrowAtomTable(atable, atable->nextFree*2); - atable->amap[atable->nextFree] = -1; - atable->arev[atable->nextFree] = lReverse(atable->nextFree); - atable->nextFree++; - return atable->nextFree - 1; -} // AllocateAtom - -/* - * SetAtomValue() - Allocate a new atom associated with "hashindex". - * - */ - -static void SetAtomValue(AtomTable *atable, int atomnumber, int hashindex) -{ - atable->amap[atomnumber] = atable->htable.entry[hashindex].index; - atable->htable.entry[hashindex].value = atomnumber; -} // SetAtomValue - -/* - * FindHashLoc() - Find the hash location for this string. Return -1 it hash table is full. - * - */ - -static int FindHashLoc(AtomTable *atable, const char *s) -{ - int hashloc, hashdelta, count; - int FoundEmptySlot = 0; - int collision[HASH_TABLE_MAX_COLLISIONS + 1]; - - hashloc = HashString(s) % atable->htable.size; - if (!Empty(&atable->htable, hashloc)) { - if (Match(&atable->htable, &atable->stable, s, hashloc)) - return hashloc; - collision[0] = hashloc; - hashdelta = HashString2(s); - count = 0; - while (count < HASH_TABLE_MAX_COLLISIONS) { - hashloc = ((hashloc + hashdelta) & 0x7fffffff) % atable->htable.size; - if (!Empty(&atable->htable, hashloc)) { - if (Match(&atable->htable, &atable->stable, s, hashloc)) { - return hashloc; - } - } else { - FoundEmptySlot = 1; - break; - } - count++; - collision[count] = hashloc; - } - - if (!FoundEmptySlot) { - if (cpp->options.DumpAtomTable) { - int ii; - char str[200]; - snprintf(str, sizeof(str), "*** Hash failed with more than %d collisions. Must increase hash table size. ***", - HASH_TABLE_MAX_COLLISIONS); - CPPShInfoLogMsg(str); - - snprintf(str, sizeof(str), "*** New string \"%s\", hash=%04x, delta=%04x", s, collision[0], hashdelta); - CPPShInfoLogMsg(str); - for (ii = 0; ii <= HASH_TABLE_MAX_COLLISIONS; ii++) { - snprintf(str, sizeof(str), "*** Collides on try %d at hash entry %04x with \"%s\"", - ii + 1, collision[ii], GetAtomString(atable, atable->htable.entry[collision[ii]].value)); - CPPShInfoLogMsg(str); - } - } - return -1; - } else { - atable->htable.counts[count]++; - } - } - return hashloc; -} // FindHashLoc - -/* - * IncreaseHashTableSize() - * - */ - -static int IncreaseHashTableSize(AtomTable *atable) -{ - int ii, strloc, oldhashloc, value, size; - AtomTable oldtable; - char *s; - - // Save the old atom table and create a new one: - - oldtable = *atable; - size = oldtable.htable.size*2 + 1; - if (!InitAtomTable(atable, size)) - return 0; - - // Add all the existing values to the new atom table preserving their atom values: - - for (ii = atable->nextFree; ii < oldtable.nextFree; ii++) { - strloc = oldtable.amap[ii]; - s = &oldtable.stable.strings[strloc]; - oldhashloc = FindHashLoc(&oldtable, s); - assert(oldhashloc >= 0); - value = oldtable.htable.entry[oldhashloc].value; - AddAtomFixed(atable, s, value); - } - FreeAtomTable(&oldtable); - return 1; -} // IncreaseHashTableSize - -/* - * LookUpAddStringHash() - Lookup a string in the hash table. If it's not there, add it and - * initialize the atom value in the hash table to 0. Return the hash table index. - */ - -static int LookUpAddStringHash(AtomTable *atable, const char *s) -{ - int hashloc, strloc; - - while(1) { - hashloc = FindHashLoc(atable, s); - if (hashloc >= 0) - break; - IncreaseHashTableSize(atable); - } - - if (Empty(&atable->htable, hashloc)) { - atable->htable.entries++; - strloc = AddString(&atable->stable, s); - atable->htable.entry[hashloc].index = strloc; - atable->htable.entry[hashloc].value = 0; - } - return hashloc; -} // LookUpAddStringHash - -/* - * LookUpAddString() - Lookup a string in the hash table. If it's not there, add it and - * initialize the atom value in the hash table to the next atom number. - * Return the atom value of string. - */ - -int LookUpAddString(AtomTable *atable, const char *s) -{ - int hashindex, atom; - - hashindex = LookUpAddStringHash(atable, s); - atom = atable->htable.entry[hashindex].value; - if (atom == 0) { - atom = AllocateAtom(atable); - SetAtomValue(atable, atom, hashindex); - } - return atom; -} // LookUpAddString - -/* - * GetAtomString() - * - */ - -const char *GetAtomString(AtomTable *atable, int atom) -{ - int soffset; - - if (atom > 0 && atom < atable->nextFree) { - soffset = atable->amap[atom]; - if (soffset > 0 && soffset < atable->stable.nextFree) { - return &atable->stable.strings[soffset]; - } else { - return "<internal error: bad soffset>"; - } - } else { - if (atom == 0) { - return "<null atom>"; - } else { - if (atom == EOF) { - return "<EOF>"; - } else { - return "<invalid atom>"; - } - } - } -} // GetAtomString - -/* - * GetReversedAtom() - * - */ - -int GetReversedAtom(AtomTable *atable, int atom) -{ - if (atom > 0 && atom < atable->nextFree) { - return atable->arev[atom]; - } else { - return 0; - } -} // GetReversedAtom - -/* - * AddAtom() - Add a string to the atom, hash and string tables if it isn't already there. - * Return it's atom index. - */ - -int AddAtom(AtomTable *atable, const char *s) -{ - int atom; - - atom = LookUpAddString(atable, s); - return atom; -} // AddAtom - -/* - * AddAtomFixed() - Add an atom to the hash and string tables if it isn't already there. - * Assign it the atom value of "atom". - */ - -static int AddAtomFixed(AtomTable *atable, const char *s, int atom) -{ - int hashindex, lsize; - - hashindex = LookUpAddStringHash(atable, s); - if (atable->nextFree >= atable->size || atom >= atable->size) { - lsize = atable->size*2; - if (lsize <= atom) - lsize = atom + 1; - GrowAtomTable(atable, lsize); - } - atable->amap[atom] = atable->htable.entry[hashindex].index; - atable->htable.entry[hashindex].value = atom; - //if (atom >= atable->nextFree) - // atable->nextFree = atom + 1; - while (atom >= atable->nextFree) { - atable->arev[atable->nextFree] = lReverse(atable->nextFree); - atable->nextFree++; - } - return atom; -} // AddAtomFixed - -/* - * InitAtomTable() - Initialize the atom table. - * - */ - -int InitAtomTable(AtomTable *atable, int htsize) -{ - unsigned int ii; - - htsize = htsize <= 0 ? INIT_HASH_TABLE_SIZE : htsize; - if (!InitStringTable(&atable->stable)) - return 0; - if (!InitHashTable(&atable->htable, htsize)) - return 0; - - atable->nextFree = 0; - atable->amap = NULL; - atable->size = 0; - GrowAtomTable(atable, INIT_ATOM_TABLE_SIZE); - if (!atable->amap) - return 0; - - // Initialize lower part of atom table to "<undefined>" atom: - - AddAtomFixed(atable, "<undefined>", 0); - for (ii = 0; ii < FIRST_USER_TOKEN_SY; ii++) - atable->amap[ii] = atable->amap[0]; - - // Add single character tokens to the atom table: - - { - const char *s = "~!%^&*()-+=|,.<>/?;:[]{}#"; - char t[2]; - - t[1] = '\0'; - while (*s) { - t[0] = *s; - AddAtomFixed(atable, t, s[0]); - s++; - } - } - - // Add multiple character scanner tokens : - - for (ii = 0; ii < sizeof(tokens)/sizeof(tokens[0]); ii++) - AddAtomFixed(atable, tokens[ii].str, tokens[ii].val); - - // Add error symbol if running in error mode: - - if (cpp->options.ErrorMode) - AddAtomFixed(atable, "error", ERROR_SY); - - AddAtom(atable, "<*** end fixed atoms ***>"); - - return 1; -} // InitAtomTable - -/////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////// Debug Printing Functions: ////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -/* - * PrintAtomTable() - * - */ - -void PrintAtomTable(AtomTable *atable) -{ - int ii; - char str[200]; - - for (ii = 0; ii < atable->nextFree; ii++) { - snprintf(str, sizeof(str), "%d: \"%s\"", ii, &atable->stable.strings[atable->amap[ii]]); - CPPDebugLogMsg(str); - } - snprintf(str, sizeof(str), "Hash table: size=%d, entries=%d, collisions=", - atable->htable.size, atable->htable.entries); - CPPDebugLogMsg(str); - for (ii = 0; ii < HASH_TABLE_MAX_COLLISIONS; ii++) { - snprintf(str, sizeof(str), " %d", atable->htable.counts[ii]); - CPPDebugLogMsg(str); - } - -} // PrintAtomTable - - -/* - * GetStringOfAtom() - * - */ - -char* GetStringOfAtom(AtomTable *atable, int atom) -{ - char* chr_str; - chr_str=&atable->stable.strings[atable->amap[atom]]; - return chr_str; -} // GetStringOfAtom - -/* - * FreeAtomTable() - Free the atom table and associated memory - * - */ - -void FreeAtomTable(AtomTable *atable) -{ - FreeStringTable(&atable->stable); - FreeHashTable(&atable->htable); - if (atable->amap) - free(atable->amap); - if (atable->arev) - free(atable->arev); - atable->amap = NULL; - atable->arev = NULL; - atable->nextFree = 0; - atable->size = 0; -} // FreeAtomTable - -/////////////////////////////////////////////////////////////////////////////////////////////// -///////////////////////////////////////// End of atom.c /////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - diff --git a/src/3rdparty/angle/src/compiler/preprocessor/atom.h b/src/3rdparty/angle/src/compiler/preprocessor/atom.h deleted file mode 100644 index 1d84c32515..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/atom.h +++ /dev/null @@ -1,63 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// atom.h -// - -#if !defined(__ATOM_H) -#define __ATOM_H 1 - -typedef struct AtomTable_Rec AtomTable; - -extern AtomTable *atable; - -int InitAtomTable(AtomTable *atable, int htsize); -void FreeAtomTable(AtomTable *atable); -int AddAtom(AtomTable *atable, const char *s); -void PrintAtomTable(AtomTable *atable); -int LookUpAddString(AtomTable *atable, const char *s); -const char *GetAtomString(AtomTable *atable, int atom); -int GetReversedAtom(AtomTable *atable, int atom); -char* GetStringOfAtom(AtomTable *atable, int atom); -#endif // !defined(__ATOM_H) diff --git a/src/3rdparty/angle/src/compiler/preprocessor/compile.h b/src/3rdparty/angle/src/compiler/preprocessor/compile.h deleted file mode 100644 index 11808531cc..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/compile.h +++ /dev/null @@ -1,100 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// compile.h -// - -#if !defined(__COMPILE_H) -#define __COMPILE_H 1 - -int InitCPPStruct(void); - -typedef struct Options_Rec{ - const char *profileString; - int ErrorMode; - int Quiet; - - // Debug The Compiler options: - int DumpAtomTable; -} Options; - -#define MAX_IF_NESTING 64 -struct CPPStruct_Rec { - // Public members - SourceLoc *pLastSourceLoc; // Set at the start of each statement by the tree walkers - Options options; // Compile options and parameters - - // Private members - SourceLoc lastSourceLoc; - - // Scanner data: - - SourceLoc *tokenLoc; // Source location of most recent token seen by the scanner - int mostRecentToken; // Most recent token seen by the scanner - InputSrc *currentInput; - int previous_token; - int pastFirstStatement; // used to make sure that #version is the first statement seen in the file, if present - - void *pC; // storing the parseContext of the compile object in cpp. - - // Private members: - SourceLoc ltokenLoc; - int ifdepth; //current #if-#else-#endif nesting in the cpp.c file (pre-processor) - int elsedepth[MAX_IF_NESTING];//Keep a track of #if depth..Max allowed is 64. - int elsetracker; //#if-#else and #endif constructs...Counter. - const char *ErrMsg; - int CompileError; //Indicate compile error when #error, #else,#elif mismatch. - - // - // Globals used to communicate between PaParseStrings() and yy_input()and - // also across the files.(gen_glslang.cpp and scanner.c) - // - int PaWhichStr; // which string we're parsing - const int* PaStrLen; // array of lengths of the PaArgv strings - int PaArgc; // count of strings in the array - const char* const* PaArgv; // our array of strings to parse - unsigned int tokensBeforeEOF : 1; -}; - -#endif // !defined(__COMPILE_H) diff --git a/src/3rdparty/angle/src/compiler/preprocessor/cpp.c b/src/3rdparty/angle/src/compiler/preprocessor/cpp.c deleted file mode 100644 index 8a1076b9df..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/cpp.c +++ /dev/null @@ -1,1118 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// cpp.c -// - -#include <stdarg.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#include <ctype.h> - -#include "common/angleutils.h" -#include "compiler/preprocessor/slglobals.h" - -#if defined(_MSC_VER) -#pragma warning(disable: 4054) -#pragma warning(disable: 4152) -#pragma warning(disable: 4706) -#endif - -static int CPPif(yystypepp * yylvalpp); - -/* Don't use memory.c's replacements, as we clean up properly here */ -#undef malloc -#undef free - -static int bindAtom = 0; -static int constAtom = 0; -static int defaultAtom = 0; -static int defineAtom = 0; -static int definedAtom = 0; -static int elseAtom = 0; -static int elifAtom = 0; -static int endifAtom = 0; -static int ifAtom = 0; -static int ifdefAtom = 0; -static int ifndefAtom = 0; -static int includeAtom = 0; -static int lineAtom = 0; -static int pragmaAtom = 0; -static int texunitAtom = 0; -static int undefAtom = 0; -static int errorAtom = 0; -static int __LINE__Atom = 0; -static int __FILE__Atom = 0; -static int __VERSION__Atom = 0; -static int versionAtom = 0; -static int extensionAtom = 0; - -static Scope *macros = 0; -#define MAX_MACRO_ARGS 64 - -static SourceLoc ifloc; /* outermost #if */ - -int InitCPP(void) -{ - char buffer[64], *t; - const char *f; - - // Add various atoms needed by the CPP line scanner: - bindAtom = LookUpAddString(atable, "bind"); - constAtom = LookUpAddString(atable, "const"); - defaultAtom = LookUpAddString(atable, "default"); - defineAtom = LookUpAddString(atable, "define"); - definedAtom = LookUpAddString(atable, "defined"); - elifAtom = LookUpAddString(atable, "elif"); - elseAtom = LookUpAddString(atable, "else"); - endifAtom = LookUpAddString(atable, "endif"); - ifAtom = LookUpAddString(atable, "if"); - ifdefAtom = LookUpAddString(atable, "ifdef"); - ifndefAtom = LookUpAddString(atable, "ifndef"); - includeAtom = LookUpAddString(atable, "include"); - lineAtom = LookUpAddString(atable, "line"); - pragmaAtom = LookUpAddString(atable, "pragma"); - texunitAtom = LookUpAddString(atable, "texunit"); - undefAtom = LookUpAddString(atable, "undef"); - errorAtom = LookUpAddString(atable, "error"); - __LINE__Atom = LookUpAddString(atable, "__LINE__"); - __FILE__Atom = LookUpAddString(atable, "__FILE__"); - __VERSION__Atom = LookUpAddString(atable, "__VERSION__"); - versionAtom = LookUpAddString(atable, "version"); - extensionAtom = LookUpAddString(atable, "extension"); - macros = NewScopeInPool(mem_CreatePool(0, 0)); - strcpy(buffer, "PROFILE_"); - t = buffer + strlen(buffer); - f = cpp->options.profileString; - while ((isalnum(*f) || *f == '_') && t < buffer + sizeof(buffer) - 1) - *t++ = toupper(*f++); - *t = 0; - - PredefineIntMacro("GL_ES", 1); - PredefineIntMacro("GL_FRAGMENT_PRECISION_HIGH", 1); - - return 1; -} // InitCPP - -int FreeCPP(void) -{ - if (macros) - { - mem_FreePool(macros->pool); - macros = 0; - } - - return 1; -} - -int FinalCPP(void) -{ - if (cpp->ifdepth) - CPPErrorToInfoLog("#if mismatch"); - return 1; -} - -static int CPPdefine(yystypepp * yylvalpp) -{ - int token, name, args[MAX_MACRO_ARGS], argc; - const char *message; - MacroSymbol mac; - Symbol *symb; - SourceLoc dummyLoc; - memset(&mac, 0, sizeof(mac)); - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token != CPP_IDENTIFIER) { - CPPErrorToInfoLog("#define"); - return token; - } - name = yylvalpp->sc_ident; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token == '(' && !yylvalpp->sc_int) { - // gather arguments - argc = 0; - do { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (argc == 0 && token == ')') break; - if (token != CPP_IDENTIFIER) { - CPPErrorToInfoLog("#define"); - return token; - } - if (argc < MAX_MACRO_ARGS) - args[argc++] = yylvalpp->sc_ident; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } while (token == ','); - if (token != ')') { - CPPErrorToInfoLog("#define"); - return token; - } - mac.argc = argc; - mac.args = mem_Alloc(macros->pool, argc * sizeof(int)); - memcpy(mac.args, args, argc * sizeof(int)); - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } - mac.body = NewTokenStream(GetAtomString(atable, name), macros->pool); - while (token != '\n') { - if (token == '\\') { - CPPErrorToInfoLog("The line continuation character (\\) is not part of the OpenGL ES Shading Language"); - return token; - } else if (token <= 0) { // EOF or error - CPPErrorToInfoLog("unexpected end of input in #define preprocessor directive - expected a newline"); - return 0; - } - RecordToken(mac.body, token, yylvalpp); - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - }; - - symb = LookUpSymbol(macros, name); - if (symb) { - if (!symb->details.mac.undef) { - // already defined -- need to make sure they are identical - if (symb->details.mac.argc != mac.argc) goto error; - for (argc=0; argc < mac.argc; argc++) - if (symb->details.mac.args[argc] != mac.args[argc]) - goto error; - RewindTokenStream(symb->details.mac.body); - RewindTokenStream(mac.body); - do { - int old_lval, old_token; - old_token = ReadToken(symb->details.mac.body, yylvalpp); - old_lval = yylvalpp->sc_int; - token = ReadToken(mac.body, yylvalpp); - if (token != old_token || yylvalpp->sc_int != old_lval) { - error: - StoreStr("Macro Redefined"); - StoreStr(GetStringOfAtom(atable,name)); - message=GetStrfromTStr(); - DecLineNumber(); - CPPShInfoLogMsg(message); - IncLineNumber(); - ResetTString(); - break; } - } while (token > 0); - } - //FreeMacro(&symb->details.mac); - } else { - dummyLoc.file = 0; - dummyLoc.line = 0; - symb = AddSymbol(&dummyLoc, macros, name, MACRO_S); - } - symb->details.mac = mac; - return '\n'; -} // CPPdefine - -static int CPPundef(yystypepp * yylvalpp) -{ - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - Symbol *symb; - if(token == '\n'){ - CPPErrorToInfoLog("#undef"); - return token; - } - if (token != CPP_IDENTIFIER) - goto error; - symb = LookUpSymbol(macros, yylvalpp->sc_ident); - if (symb) { - symb->details.mac.undef = 1; - } - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token != '\n') { - error: - CPPErrorToInfoLog("#undef"); - } - return token; -} // CPPundef - -/* CPPelse -- skip forward to appropriate spot. This is actually used -** to skip to and #endif after seeing an #else, AND to skip to a #else, -** #elif, or #endif after a #if/#ifdef/#ifndef/#elif test was false -*/ - -static int CPPelse(int matchelse, yystypepp * yylvalpp) -{ - int atom,depth=0; - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - - while (token > 0) { - if (token != '#') { - while (token != '\n') { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token <= 0) { // EOF or error - CPPErrorToInfoLog("unexpected end of input in #else preprocessor directive - expected a newline"); - return 0; - } - } - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - continue; - } - if ((token = cpp->currentInput->scan(cpp->currentInput, yylvalpp)) != CPP_IDENTIFIER) - continue; - atom = yylvalpp->sc_ident; - if (atom == ifAtom || atom == ifdefAtom || atom == ifndefAtom){ - depth++; cpp->ifdepth++; cpp->elsetracker++; - if (cpp->ifdepth > MAX_IF_NESTING) { - CPPErrorToInfoLog("max #if nesting depth exceeded"); - cpp->CompileError = 1; - return 0; - } - // sanity check elsetracker - if (cpp->elsetracker < 0 || cpp->elsetracker >= MAX_IF_NESTING) { - CPPErrorToInfoLog("mismatched #if/#endif statements"); - cpp->CompileError = 1; - return 0; - } - cpp->elsedepth[cpp->elsetracker] = 0; - } - else if (atom == endifAtom) { - if(--depth<0){ - if (cpp->elsetracker) - --cpp->elsetracker; - if (cpp->ifdepth) - --cpp->ifdepth; - break; - } - --cpp->elsetracker; - --cpp->ifdepth; - } - else if (((int)(matchelse) != 0)&& depth==0) { - if (atom == elseAtom ) { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token != '\n') { - CPPWarningToInfoLog("unexpected tokens following #else preprocessor directive - expected a newline"); - while (token != '\n') { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token <= 0) { // EOF or error - CPPErrorToInfoLog("unexpected end of input following #else preprocessor directive - expected a newline"); - return 0; - } - } - } - break; - } - else if (atom == elifAtom) { - /* we decrement cpp->ifdepth here, because CPPif will increment - * it and we really want to leave it alone */ - if (cpp->ifdepth){ - --cpp->ifdepth; - --cpp->elsetracker; - } - return CPPif(yylvalpp); - } - } - else if((atom==elseAtom) && (!ChkCorrectElseNesting())){ - CPPErrorToInfoLog("#else after a #else"); - cpp->CompileError=1; - return 0; - } - }; - return token; -} - -enum eval_prec { - MIN_PREC, - COND, LOGOR, LOGAND, OR, XOR, AND, EQUAL, RELATION, SHIFT, ADD, MUL, UNARY, - MAX_PREC -}; - -static int op_logor(int a, int b) { return a || b; } -static int op_logand(int a, int b) { return a && b; } -static int op_or(int a, int b) { return a | b; } -static int op_xor(int a, int b) { return a ^ b; } -static int op_and(int a, int b) { return a & b; } -static int op_eq(int a, int b) { return a == b; } -static int op_ne(int a, int b) { return a != b; } -static int op_ge(int a, int b) { return a >= b; } -static int op_le(int a, int b) { return a <= b; } -static int op_gt(int a, int b) { return a > b; } -static int op_lt(int a, int b) { return a < b; } -static int op_shl(int a, int b) { return a << b; } -static int op_shr(int a, int b) { return a >> b; } -static int op_add(int a, int b) { return a + b; } -static int op_sub(int a, int b) { return a - b; } -static int op_mul(int a, int b) { return a * b; } -static int op_div(int a, int b) { return a / b; } -static int op_mod(int a, int b) { return a % b; } -static int op_pos(int a) { return a; } -static int op_neg(int a) { return -a; } -static int op_cmpl(int a) { return ~a; } -static int op_not(int a) { return !a; } - -struct { - int token, prec, (*op)(int, int); -} binop[] = { - { CPP_OR_OP, LOGOR, op_logor }, - { CPP_AND_OP, LOGAND, op_logand }, - { '|', OR, op_or }, - { '^', XOR, op_xor }, - { '&', AND, op_and }, - { CPP_EQ_OP, EQUAL, op_eq }, - { CPP_NE_OP, EQUAL, op_ne }, - { '>', RELATION, op_gt }, - { CPP_GE_OP, RELATION, op_ge }, - { '<', RELATION, op_lt }, - { CPP_LE_OP, RELATION, op_le }, - { CPP_LEFT_OP, SHIFT, op_shl }, - { CPP_RIGHT_OP, SHIFT, op_shr }, - { '+', ADD, op_add }, - { '-', ADD, op_sub }, - { '*', MUL, op_mul }, - { '/', MUL, op_div }, - { '%', MUL, op_mod }, -}; - -struct { - int token, (*op)(int); -} unop[] = { - { '+', op_pos }, - { '-', op_neg }, - { '~', op_cmpl }, - { '!', op_not }, -}; - -#define ALEN(A) (sizeof(A)/sizeof(A[0])) - -static int eval(int token, int prec, int *res, int *err, yystypepp * yylvalpp) -{ - int i, val; - Symbol *s; - if (token == CPP_IDENTIFIER) { - if (yylvalpp->sc_ident == definedAtom) { - int needclose = 0; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token == '(') { - needclose = 1; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } - if (token != CPP_IDENTIFIER) - goto error; - *res = (s = LookUpSymbol(macros, yylvalpp->sc_ident)) - ? !s->details.mac.undef : 0; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (needclose) { - if (token != ')') - goto error; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } - } else if (MacroExpand(yylvalpp->sc_ident, yylvalpp)) { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - return eval(token, prec, res, err, yylvalpp); - } else { - goto error; - } - } else if (token == CPP_INTCONSTANT) { - *res = yylvalpp->sc_int; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } else if (token == '(') { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - token = eval(token, MIN_PREC, res, err, yylvalpp); - if (!*err) { - if (token != ')') - goto error; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } - } else { - for (i = ALEN(unop) - 1; i >= 0; i--) { - if (unop[i].token == token) - break; - } - if (i >= 0) { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - token = eval(token, UNARY, res, err, yylvalpp); - *res = unop[i].op(*res); - } else { - goto error; - } - } - while (!*err) { - if (token == ')' || token == '\n') break; - for (i = ALEN(binop) - 1; i >= 0; i--) { - if (binop[i].token == token) - break; - } - if (i < 0 || binop[i].prec <= prec) - break; - val = *res; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - token = eval(token, binop[i].prec, res, err, yylvalpp); - - if (binop[i].op == op_div || binop[i].op == op_mod) - { - if (*res == 0) - { - CPPErrorToInfoLog("preprocessor divide or modulo by zero"); - *err = 1; - return token; - } - } - - *res = binop[i].op(val, *res); - } - return token; -error: - CPPErrorToInfoLog("incorrect preprocessor directive"); - *err = 1; - *res = 0; - return token; -} // eval - -static int CPPif(yystypepp * yylvalpp) { - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - int res = 0, err = 0; - - if (!cpp->ifdepth++) - ifloc = *cpp->tokenLoc; - if(cpp->ifdepth > MAX_IF_NESTING){ - CPPErrorToInfoLog("max #if nesting depth exceeded"); - cpp->CompileError = 1; - return 0; - } - cpp->elsetracker++; - // sanity check elsetracker - if (cpp->elsetracker < 0 || cpp->elsetracker >= MAX_IF_NESTING) { - CPPErrorToInfoLog("mismatched #if/#endif statements"); - cpp->CompileError = 1; - return 0; - } - cpp->elsedepth[cpp->elsetracker] = 0; - - token = eval(token, MIN_PREC, &res, &err, yylvalpp); - if (token != '\n') { - CPPWarningToInfoLog("unexpected tokens following #if preprocessor directive - expected a newline"); - while (token != '\n') { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token <= 0) { // EOF or error - CPPErrorToInfoLog("unexpected end of input in #if preprocessor directive - expected a newline"); - return 0; - } - } - } - if (!res && !err) { - token = CPPelse(1, yylvalpp); - } - - return token; -} // CPPif - -static int CPPifdef(int defined, yystypepp * yylvalpp) -{ - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - int name = yylvalpp->sc_ident; - if(++cpp->ifdepth > MAX_IF_NESTING){ - CPPErrorToInfoLog("max #if nesting depth exceeded"); - cpp->CompileError = 1; - return 0; - } - cpp->elsetracker++; - // sanity check elsetracker - if (cpp->elsetracker < 0 || cpp->elsetracker >= MAX_IF_NESTING) { - CPPErrorToInfoLog("mismatched #if/#endif statements"); - cpp->CompileError = 1; - return 0; - } - cpp->elsedepth[cpp->elsetracker] = 0; - - if (token != CPP_IDENTIFIER) { - defined ? CPPErrorToInfoLog("ifdef"):CPPErrorToInfoLog("ifndef"); - } else { - Symbol *s = LookUpSymbol(macros, name); - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token != '\n') { - CPPWarningToInfoLog("unexpected tokens following #ifdef preprocessor directive - expected a newline"); - while (token != '\n') { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token <= 0) { // EOF or error - CPPErrorToInfoLog("unexpected end of input in #ifdef preprocessor directive - expected a newline"); - return 0; - } - } - } - if (((s && !s->details.mac.undef) ? 1 : 0) != defined) - token = CPPelse(1, yylvalpp); - } - return token; -} // CPPifdef - -static int CPPline(yystypepp * yylvalpp) -{ - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if(token=='\n'){ - DecLineNumber(); - CPPErrorToInfoLog("#line"); - IncLineNumber(); - return token; - } - else if (token == CPP_INTCONSTANT) { - yylvalpp->sc_int=atoi(yylvalpp->symbol_name); - SetLineNumber(yylvalpp->sc_int); - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - - if (token == CPP_INTCONSTANT) { - yylvalpp->sc_int=atoi(yylvalpp->symbol_name); - SetStringNumber(yylvalpp->sc_int); - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if(token!='\n') - CPPErrorToInfoLog("#line"); - } - else if (token == '\n'){ - return token; - } - else{ - CPPErrorToInfoLog("#line"); - } - } - else{ - CPPErrorToInfoLog("#line"); - } - return token; -} - -static int CPPerror(yystypepp * yylvalpp) { - - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - const char *message; - - while (token != '\n') { - if (token <= 0){ - CPPErrorToInfoLog("unexpected end of input in #error preprocessor directive - expected a newline"); - return 0; - }else if (token == CPP_FLOATCONSTANT || token == CPP_INTCONSTANT){ - StoreStr(yylvalpp->symbol_name); - }else if(token == CPP_IDENTIFIER || token == CPP_STRCONSTANT){ - StoreStr(GetStringOfAtom(atable,yylvalpp->sc_ident)); - }else { - StoreStr(GetStringOfAtom(atable,token)); - } - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } - DecLineNumber(); - //store this msg into the shader's information log..set the Compile Error flag!!!! - message=GetStrfromTStr(); - CPPShInfoLogMsg(message); - ResetTString(); - cpp->CompileError=1; - IncLineNumber(); - return '\n'; -}//CPPerror - -static int CPPpragma(yystypepp * yylvalpp) -{ - char SrcStrName[2]; - char** allTokens; - int tokenCount = 0; - int maxTokenCount = 10; - const char* SrcStr; - int i; - - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - - if (token=='\n') { - DecLineNumber(); - CPPErrorToInfoLog("#pragma"); - IncLineNumber(); - return token; - } - - allTokens = (char**)malloc(sizeof(char*) * maxTokenCount); - - while (token != '\n') { - if (tokenCount >= maxTokenCount) { - maxTokenCount *= 2; - allTokens = (char**)realloc((char**)allTokens, sizeof(char*) * maxTokenCount); - } - switch (token) { - case CPP_IDENTIFIER: - SrcStr = GetAtomString(atable, yylvalpp->sc_ident); - allTokens[tokenCount] = (char*)malloc(strlen(SrcStr) + 1); - strcpy(allTokens[tokenCount++], SrcStr); - break; - case CPP_INTCONSTANT: - SrcStr = yylvalpp->symbol_name; - allTokens[tokenCount] = (char*)malloc(strlen(SrcStr) + 1); - strcpy(allTokens[tokenCount++], SrcStr); - break; - case CPP_FLOATCONSTANT: - SrcStr = yylvalpp->symbol_name; - allTokens[tokenCount] = (char*)malloc(strlen(SrcStr) + 1); - strcpy(allTokens[tokenCount++], SrcStr); - break; - case -1: - // EOF - CPPShInfoLogMsg("#pragma directive must end with a newline"); - goto freeMemoryAndReturnToken; - default: - SrcStrName[0] = token; - SrcStrName[1] = '\0'; - allTokens[tokenCount] = (char*)malloc(2); - strcpy(allTokens[tokenCount++], SrcStrName); - } - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } - - HandlePragma((const char**)allTokens, tokenCount); - -freeMemoryAndReturnToken: - for (i = 0; i < tokenCount; ++i) { - free (allTokens[i]); - } - free (allTokens); - - return token; -} // CPPpragma - -#define ESSL_VERSION_NUMBER 100 -#define ESSL_VERSION_STRING "100" - -static int CPPversion(yystypepp * yylvalpp) -{ - - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - - if (cpp->pastFirstStatement == 1) - CPPShInfoLogMsg("#version must occur before any other statement in the program"); - - if(token=='\n'){ - DecLineNumber(); - CPPErrorToInfoLog("#version"); - IncLineNumber(); - return token; - } - if (token != CPP_INTCONSTANT) - CPPErrorToInfoLog("#version"); - - yylvalpp->sc_int=atoi(yylvalpp->symbol_name); - //SetVersionNumber(yylvalpp->sc_int); - - if (yylvalpp->sc_int != ESSL_VERSION_NUMBER) - CPPShInfoLogMsg("Version number not supported by ESSL"); - - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - - if (token == '\n'){ - return token; - } - else{ - CPPErrorToInfoLog("#version"); - } - return token; -} // CPPversion - -static int CPPextension(yystypepp * yylvalpp) -{ - - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - char extensionName[MAX_SYMBOL_NAME_LEN + 1]; - - if(token=='\n'){ - DecLineNumber(); - CPPShInfoLogMsg("extension name not specified"); - IncLineNumber(); - return token; - } - - if (token != CPP_IDENTIFIER) - CPPErrorToInfoLog("#extension"); - - strncpy(extensionName, GetAtomString(atable, yylvalpp->sc_ident), MAX_SYMBOL_NAME_LEN); - extensionName[MAX_SYMBOL_NAME_LEN] = '\0'; - - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token != ':') { - CPPShInfoLogMsg("':' missing after extension name"); - return token; - } - - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token != CPP_IDENTIFIER) { - CPPShInfoLogMsg("behavior for extension not specified"); - return token; - } - - updateExtensionBehavior(extensionName, GetAtomString(atable, yylvalpp->sc_ident)); - - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token == '\n'){ - return token; - } - else{ - CPPErrorToInfoLog("#extension"); - } - return token; -} // CPPextension - -int readCPPline(yystypepp * yylvalpp) -{ - int token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - const char *message; - - if (token == CPP_IDENTIFIER) { - if (yylvalpp->sc_ident == defineAtom) { - token = CPPdefine(yylvalpp); - } else if (yylvalpp->sc_ident == elseAtom) { - if(ChkCorrectElseNesting()){ - if (!cpp->ifdepth ){ - CPPErrorToInfoLog("#else mismatch"); - cpp->CompileError=1; - return 0; - } - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token != '\n') { - CPPWarningToInfoLog("unexpected tokens following #else preprocessor directive - expected a newline"); - while (token != '\n') { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token <= 0) { // EOF or error - CPPErrorToInfoLog("unexpected end of input in #ifdef preprocessor directive - expected a newline"); - return 0; - } - } - } - token = CPPelse(0, yylvalpp); - }else{ - CPPErrorToInfoLog("#else after a #else"); - cpp->ifdepth = 0; - cpp->elsetracker = 0; - cpp->pastFirstStatement = 1; - cpp->CompileError = 1; - return 0; - } - } else if (yylvalpp->sc_ident == elifAtom) { - if (!cpp->ifdepth){ - CPPErrorToInfoLog("#elif mismatch"); - cpp->CompileError=1; - return 0; - } - // this token is really a dont care, but we still need to eat the tokens - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - while (token != '\n') { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token <= 0) { // EOF or error - CPPErrorToInfoLog("unexpect tokens following #elif preprocessor directive - expected a newline"); - cpp->CompileError = 1; - return 0; - } - } - token = CPPelse(0, yylvalpp); - } else if (yylvalpp->sc_ident == endifAtom) { - if (!cpp->ifdepth){ - CPPErrorToInfoLog("#endif mismatch"); - cpp->CompileError=1; - return 0; - } - else - --cpp->ifdepth; - - if (cpp->elsetracker) - --cpp->elsetracker; - - } else if (yylvalpp->sc_ident == ifAtom) { - token = CPPif(yylvalpp); - } else if (yylvalpp->sc_ident == ifdefAtom) { - token = CPPifdef(1, yylvalpp); - } else if (yylvalpp->sc_ident == ifndefAtom) { - token = CPPifdef(0, yylvalpp); - } else if (yylvalpp->sc_ident == lineAtom) { - token = CPPline(yylvalpp); - } else if (yylvalpp->sc_ident == pragmaAtom) { - token = CPPpragma(yylvalpp); - } else if (yylvalpp->sc_ident == undefAtom) { - token = CPPundef(yylvalpp); - } else if (yylvalpp->sc_ident == errorAtom) { - token = CPPerror(yylvalpp); - } else if (yylvalpp->sc_ident == versionAtom) { - token = CPPversion(yylvalpp); - } else if (yylvalpp->sc_ident == extensionAtom) { - token = CPPextension(yylvalpp); - } else { - StoreStr("Invalid Directive"); - StoreStr(GetStringOfAtom(atable,yylvalpp->sc_ident)); - message=GetStrfromTStr(); - CPPShInfoLogMsg(message); - ResetTString(); - } - } - while (token != '\n' && token != 0 && token != EOF) { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } - - cpp->pastFirstStatement = 1; - - return token; -} // readCPPline - -void FreeMacro(MacroSymbol *s) { - DeleteTokenStream(s->body); -} - -void PredefineIntMacro(const char *name, int value) { - SourceLoc location = {0, 0}; - Symbol *symbol = NULL; - MacroSymbol macro = {0, NULL, NULL, 0, 0}; - yystypepp val = {0, 0.0, 0, {0}}; - int atom = 0; - - macro.body = NewTokenStream(name, macros->pool); - val.sc_int = value; - snprintf(val.symbol_name, MAX_SYMBOL_NAME_LEN+1, "%d", value); - RecordToken(macro.body, CPP_INTCONSTANT, &val); - atom = LookUpAddString(atable, name); - symbol = AddSymbol(&location, macros, atom, MACRO_S); - symbol->details.mac = macro; -} - -static int eof_scan(InputSrc *in, yystypepp * yylvalpp) { return -1; } -static void noop(InputSrc *in, int ch, yystypepp * yylvalpp) { } - -static void PushEofSrc() { - InputSrc *in = malloc(sizeof(InputSrc)); - memset(in, 0, sizeof(InputSrc)); - in->scan = eof_scan; - in->getch = eof_scan; - in->ungetch = noop; - in->prev = cpp->currentInput; - cpp->currentInput = in; -} - -static void PopEofSrc() { - if (cpp->currentInput->scan == eof_scan) { - InputSrc *in = cpp->currentInput; - cpp->currentInput = in->prev; - free(in); - } -} - -static TokenStream *PrescanMacroArg(TokenStream *a, yystypepp * yylvalpp) { - int token; - TokenStream *n; - RewindTokenStream(a); - do { - token = ReadToken(a, yylvalpp); - if (token == CPP_IDENTIFIER && LookUpSymbol(macros, yylvalpp->sc_ident)) - break; - } while (token > 0); - if (token <= 0) return a; - n = NewTokenStream("macro arg", 0); - PushEofSrc(); - ReadFromTokenStream(a, 0, 0); - while ((token = cpp->currentInput->scan(cpp->currentInput, yylvalpp)) > 0) { - if (token == CPP_IDENTIFIER && MacroExpand(yylvalpp->sc_ident, yylvalpp)) - continue; - RecordToken(n, token, yylvalpp); - } - PopEofSrc(); - DeleteTokenStream(a); - return n; -} // PrescanMacroArg - -typedef struct MacroInputSrc { - InputSrc base; - MacroSymbol *mac; - TokenStream **args; -} MacroInputSrc; - -/* macro_scan --- -** return the next token for a macro expanion, handling macro args -*/ -static int macro_scan(MacroInputSrc *in, yystypepp * yylvalpp) { - int i; - int token = ReadToken(in->mac->body, yylvalpp); - if (token == CPP_IDENTIFIER) { - for (i = in->mac->argc-1; i>=0; i--) - if (in->mac->args[i] == yylvalpp->sc_ident) break; - if (i >= 0) { - ReadFromTokenStream(in->args[i], yylvalpp->sc_ident, 0); - return cpp->currentInput->scan(cpp->currentInput, yylvalpp); - } - } - if (token > 0) return token; - in->mac->busy = 0; - cpp->currentInput = in->base.prev; - if (in->args) { - for (i=in->mac->argc-1; i>=0; i--) - DeleteTokenStream(in->args[i]); - free(in->args); - } - free(in); - return cpp->currentInput->scan(cpp->currentInput, yylvalpp); -} // macro_scan - -/* MacroExpand -** check an identifier (atom) to see if it a macro that should be expanded. -** If it is, push an InputSrc that will produce the appropriate expansion -** and return TRUE. If not, return FALSE. -*/ - -int MacroExpand(int atom, yystypepp * yylvalpp) -{ - Symbol *sym = LookUpSymbol(macros, atom); - MacroInputSrc *in; - int i,j, token, depth=0; - const char *message; - if (atom == __LINE__Atom) { - yylvalpp->sc_int = GetLineNumber(); - snprintf(yylvalpp->symbol_name, MAX_SYMBOL_NAME_LEN+1, "%d", yylvalpp->sc_int); - UngetToken(CPP_INTCONSTANT, yylvalpp); - return 1; - } - if (atom == __FILE__Atom) { - yylvalpp->sc_int = GetStringNumber(); - snprintf(yylvalpp->symbol_name, MAX_SYMBOL_NAME_LEN+1, "%d", yylvalpp->sc_int); - UngetToken(CPP_INTCONSTANT, yylvalpp); - return 1; - } - if (atom == __VERSION__Atom) { - strcpy(yylvalpp->symbol_name,ESSL_VERSION_STRING); - yylvalpp->sc_int = atoi(yylvalpp->symbol_name); - UngetToken(CPP_INTCONSTANT, yylvalpp); - return 1; - } - if (!sym || sym->details.mac.undef) return 0; - if (sym->details.mac.busy) return 0; // no recursive expansions - in = malloc(sizeof(*in)); - memset(in, 0, sizeof(*in)); - in->base.scan = (void *)macro_scan; - in->base.line = cpp->currentInput->line; - in->base.name = cpp->currentInput->name; - in->mac = &sym->details.mac; - if (sym->details.mac.args) { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token != '(') { - UngetToken(token, yylvalpp); - yylvalpp->sc_ident = atom; - return 0; - } - in->args = malloc(in->mac->argc * sizeof(TokenStream *)); - for (i=0; i<in->mac->argc; i++) - in->args[i] = NewTokenStream("macro arg", 0); - i=0;j=0; - do{ - depth = 0; - while(1) { - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token <= 0) { - StoreStr("EOF in Macro "); - StoreStr(GetStringOfAtom(atable,atom)); - message=GetStrfromTStr(); - CPPShInfoLogMsg(message); - ResetTString(); - return 1; - } - if((in->mac->argc==0) && (token!=')')) break; - if (depth == 0 && (token == ',' || token == ')')) break; - if (token == '(') depth++; - if (token == ')') depth--; - RecordToken(in->args[i], token, yylvalpp); - j=1; - } - if (token == ')') { - if((in->mac->argc==1) &&j==0) - break; - i++; - break; - } - i++; - }while(i < in->mac->argc); - - if (i < in->mac->argc) { - StoreStr("Too few args in Macro "); - StoreStr(GetStringOfAtom(atable,atom)); - message=GetStrfromTStr(); - CPPShInfoLogMsg(message); - ResetTString(); - } else if (token != ')') { - depth=0; - while (token >= 0 && (depth > 0 || token != ')')) { - if (token == ')') depth--; - token = cpp->currentInput->scan(cpp->currentInput, yylvalpp); - if (token == '(') depth++; - } - - if (token <= 0) { - StoreStr("EOF in Macro "); - StoreStr(GetStringOfAtom(atable,atom)); - message=GetStrfromTStr(); - CPPShInfoLogMsg(message); - ResetTString(); - return 1; - } - StoreStr("Too many args in Macro "); - StoreStr(GetStringOfAtom(atable,atom)); - message=GetStrfromTStr(); - CPPShInfoLogMsg(message); - ResetTString(); - } - for (i=0; i<in->mac->argc; i++) { - in->args[i] = PrescanMacroArg(in->args[i], yylvalpp); - } - } -#if 0 - printf(" <%s:%d>found macro %s\n", GetAtomString(atable, loc.file), - loc.line, GetAtomString(atable, atom)); - for (i=0; i<in->mac->argc; i++) { - printf("\targ %s = '", GetAtomString(atable, in->mac->args[i])); - DumpTokenStream(stdout, in->args[i]); - printf("'\n"); - } -#endif - /*retain the input source*/ - in->base.prev = cpp->currentInput; - sym->details.mac.busy = 1; - RewindTokenStream(sym->details.mac.body); - cpp->currentInput = &in->base; - return 1; -} // MacroExpand - -int ChkCorrectElseNesting(void) -{ - // sanity check to make sure elsetracker is in a valid range - if (cpp->elsetracker < 0 || cpp->elsetracker >= MAX_IF_NESTING) { - return 0; - } - - if (cpp->elsedepth[cpp->elsetracker] == 0) { - cpp->elsedepth[cpp->elsetracker] = 1; - return 1; - } - return 0; -} - - diff --git a/src/3rdparty/angle/src/compiler/preprocessor/cpp.h b/src/3rdparty/angle/src/compiler/preprocessor/cpp.h deleted file mode 100644 index 802e23ef07..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/cpp.h +++ /dev/null @@ -1,86 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// cpp.h -// - -#if !defined(__CPP_H) -#define __CPP_H 1 - -#include "compiler/preprocessor/parser.h" -#include "compiler/preprocessor/tokens.h" - -int InitCPP(void); -int FinalCPP(void); -int readCPPline(yystypepp * yylvalpp); -int MacroExpand(int atom, yystypepp * yylvalpp); -int ChkCorrectElseNesting(void); - -typedef struct MacroSymbol { - int argc; - int *args; - TokenStream *body; - unsigned busy:1; - unsigned undef:1; -} MacroSymbol; - -void FreeMacro(MacroSymbol *); -void PredefineIntMacro(const char *name, int value); - -void CPPDebugLogMsg(const char *msg); // Prints information into debug log -void CPPShInfoLogMsg(const char*); // Store cpp Err Msg into Sh.Info.Log -void CPPWarningToInfoLog(const char *msg); // Prints warning messages into info log -void HandlePragma(const char**, int numTokens); // #pragma directive container. -void ResetTString(void); // #error Message as TString. -void CPPErrorToInfoLog(const char*); // Stick all cpp errors into Sh.Info.log. -void StoreStr(const char*); // Store the TString in Parse Context. -void SetLineNumber(int); // Set line number. -void SetStringNumber(int); // Set string number. -int GetLineNumber(void); // Get the current String Number. -int GetStringNumber(void); // Get the current String Number. -const char* GetStrfromTStr(void); // Convert TString to String. -void updateExtensionBehavior(const char* extName, const char* behavior); -int FreeCPP(void); - -#endif // !(defined(__CPP_H) diff --git a/src/3rdparty/angle/src/compiler/preprocessor/cppstruct.c b/src/3rdparty/angle/src/compiler/preprocessor/cppstruct.c deleted file mode 100644 index 58cff31091..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/cppstruct.c +++ /dev/null @@ -1,152 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// cppstruct.c -// - -#include <stdio.h> -#include <stdlib.h> - -#include "compiler/preprocessor/slglobals.h" - -CPPStruct *cpp = NULL; -static int refCount = 0; - -int InitPreprocessor(void); -int ResetPreprocessor(void); -int FreeCPPStruct(void); -int FinalizePreprocessor(void); - -/* - * InitCPPStruct() - Initilaize the CPP structure. - * - */ - -int InitCPPStruct(void) -{ - int len; - char *p; - - cpp = (CPPStruct *) malloc(sizeof(CPPStruct)); - if (cpp == NULL) - return 0; - - refCount++; - - // Initialize public members: - cpp->pLastSourceLoc = &cpp->lastSourceLoc; - - p = (char *) &cpp->options; - len = sizeof(cpp->options); - while (--len >= 0) - p[len] = 0; - - ResetPreprocessor(); - return 1; -} // InitCPPStruct - -int ResetPreprocessor(void) -{ - // Initialize private members: - - cpp->lastSourceLoc.file = 0; - cpp->lastSourceLoc.line = 0; - cpp->pC = 0; - cpp->CompileError = 0; - cpp->ifdepth = 0; - for(cpp->elsetracker = 0; cpp->elsetracker < MAX_IF_NESTING; cpp->elsetracker++) - cpp->elsedepth[cpp->elsetracker] = 0; - cpp->elsetracker = 0; - cpp->tokensBeforeEOF = 0; - return 1; -} - -//Intializing the Preprocessor. - -int InitPreprocessor(void) -{ - # define CPP_STUFF true - # ifdef CPP_STUFF - FreeCPPStruct(); - InitCPPStruct(); - cpp->options.Quiet = 1; - cpp->options.profileString = "generic"; - if (!InitAtomTable(atable, 0)) - return 1; - if (!InitScanner(cpp)) - return 1; - # endif - return 0; -} - -//FreeCPPStruct() - Free the CPP structure. - -int FreeCPPStruct(void) -{ - if (refCount) - { - free(cpp); - refCount--; - } - - return 1; -} - -//Finalizing the Preprocessor. - -int FinalizePreprocessor(void) -{ - # define CPP_STUFF true - # ifdef CPP_STUFF - FreeAtomTable(atable); - FreeCPPStruct(); - FreeScanner(); - # endif - return 0; -} - - -/////////////////////////////////////////////////////////////////////////////////////////////// -////////////////////////////////////// End of cppstruct.c ////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/3rdparty/angle/src/compiler/preprocessor/memory.c b/src/3rdparty/angle/src/compiler/preprocessor/memory.c deleted file mode 100644 index 029521a559..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/memory.c +++ /dev/null @@ -1,158 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -#include <stddef.h> -#include <stdlib.h> -#include <string.h> - -#ifndef _MSC_VER -#include <stdint.h> -#endif - -#include "compiler/preprocessor/memory.h" - -#if defined(_MSC_VER) -#pragma warning(disable: 4706) -#endif - -// default alignment and chunksize, if called with 0 arguments -#define CHUNKSIZE (64*1024) -#define ALIGN 8 - -// we need to call the `real' malloc and free, not our replacements -#undef malloc -#undef free - -struct chunk { - struct chunk *next; -}; - -struct cleanup { - struct cleanup *next; - void (*fn)(void *); - void *arg; -}; - -struct MemoryPool_rec { - struct chunk *next; - uintptr_t free, end; - size_t chunksize; - uintptr_t alignmask; - struct cleanup *cleanup; -}; - -MemoryPool *mem_CreatePool(size_t chunksize, unsigned int align) -{ - MemoryPool *pool; - - if (align == 0) align = ALIGN; - if (chunksize == 0) chunksize = CHUNKSIZE; - if (align & (align-1)) return 0; - if (chunksize < sizeof(MemoryPool)) return 0; - if (chunksize & (align-1)) return 0; - if (!(pool = malloc(chunksize))) return 0; - pool->next = 0; - pool->chunksize = chunksize; - pool->alignmask = (uintptr_t)(align)-1; - pool->free = ((uintptr_t)(pool + 1) + pool->alignmask) & ~pool->alignmask; - pool->end = (uintptr_t)pool + chunksize; - pool->cleanup = 0; - return pool; -} - -void mem_FreePool(MemoryPool *pool) -{ - struct cleanup *cleanup; - struct chunk *p, *next; - - for (cleanup = pool->cleanup; cleanup; cleanup = cleanup->next) { - cleanup->fn(cleanup->arg); - } - for (p = (struct chunk *)pool; p; p = next) { - next = p->next; - free(p); - } -} - -void *mem_Alloc(MemoryPool *pool, size_t size) -{ - struct chunk *ch; - void *rv = (void *)pool->free; - size = (size + pool->alignmask) & ~pool->alignmask; - if (size <= 0) size = pool->alignmask; - pool->free += size; - if (pool->free > pool->end || pool->free < (uintptr_t)rv) { - size_t minreq = (size + sizeof(struct chunk) + pool->alignmask) - & ~pool->alignmask; - pool->free = (uintptr_t)rv; - if (minreq >= pool->chunksize) { - // request size is too big for the chunksize, so allocate it as - // a single chunk of the right size - ch = malloc(minreq); - if (!ch) return 0; - } else { - ch = malloc(pool->chunksize); - if (!ch) return 0; - pool->free = (uintptr_t)ch + minreq; - pool->end = (uintptr_t)ch + pool->chunksize; - } - ch->next = pool->next; - pool->next = ch; - rv = (void *)(((uintptr_t)(ch+1) + pool->alignmask) & ~pool->alignmask); - } - return rv; -} - -int mem_AddCleanup(MemoryPool *pool, void (*fn)(void *), void *arg) { - struct cleanup *cleanup; - - pool->free = (pool->free + sizeof(void *) - 1) & ~(sizeof(void *)-1); - cleanup = mem_Alloc(pool, sizeof(struct cleanup)); - if (!cleanup) return -1; - cleanup->next = pool->cleanup; - cleanup->fn = fn; - cleanup->arg = arg; - pool->cleanup = cleanup; - return 0; -} diff --git a/src/3rdparty/angle/src/compiler/preprocessor/memory.h b/src/3rdparty/angle/src/compiler/preprocessor/memory.h deleted file mode 100644 index 5fcadb32f6..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/memory.h +++ /dev/null @@ -1,58 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -#ifndef __MEMORY_H -#define __MEMORY_H - -#include <stddef.h> - -typedef struct MemoryPool_rec MemoryPool; - -extern MemoryPool *mem_CreatePool(size_t chunksize, unsigned int align); -extern void mem_FreePool(MemoryPool *); -extern void *mem_Alloc(MemoryPool *p, size_t size); -extern void *mem_Realloc(MemoryPool *p, void *old, size_t oldsize, size_t newsize); -extern int mem_AddCleanup(MemoryPool *p, void (*fn)(void *), void *arg); - -#endif /* __MEMORY_H */ diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/numeric_lex.h b/src/3rdparty/angle/src/compiler/preprocessor/numeric_lex.h index b04125d230..b04125d230 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/numeric_lex.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/numeric_lex.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/parser.h b/src/3rdparty/angle/src/compiler/preprocessor/parser.h deleted file mode 100644 index f67342b670..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/parser.h +++ /dev/null @@ -1,93 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ - -#ifndef BISON_PARSER_H -# define BISON_PARSER_H - -#ifndef yystypepp -typedef struct { - int sc_int; - float sc_fval; - int sc_ident; - char symbol_name[MAX_SYMBOL_NAME_LEN+1]; -} yystypepp; - -# define YYSTYPE_IS_TRIVIAL 1 -#endif -# define CPP_AND_OP 257 -# define CPP_SUB_ASSIGN 259 -# define CPP_MOD_ASSIGN 260 -# define CPP_ADD_ASSIGN 261 -# define CPP_DIV_ASSIGN 262 -# define CPP_MUL_ASSIGN 263 -# define CPP_EQ_OP 264 -# define CPP_XOR_OP 265 -# define ERROR_SY 266 -# define CPP_FLOATCONSTANT 267 -# define CPP_GE_OP 268 -# define CPP_RIGHT_OP 269 -# define CPP_IDENTIFIER 270 -# define CPP_INTCONSTANT 271 -# define CPP_LE_OP 272 -# define CPP_LEFT_OP 273 -# define CPP_DEC_OP 274 -# define CPP_NE_OP 275 -# define CPP_OR_OP 276 -# define CPP_INC_OP 277 -# define CPP_STRCONSTANT 278 -# define CPP_TYPEIDENTIFIER 279 - -# define FIRST_USER_TOKEN_SY 289 - -# define CPP_RIGHT_ASSIGN 280 -# define CPP_LEFT_ASSIGN 281 -# define CPP_AND_ASSIGN 282 -# define CPP_OR_ASSIGN 283 -# define CPP_XOR_ASSIGN 284 -# define CPP_LEFT_BRACKET 285 -# define CPP_RIGHT_BRACKET 286 -# define CPP_LEFT_BRACE 287 -# define CPP_RIGHT_BRACE 288 - -#endif /* not BISON_PARSER_H */ diff --git a/src/3rdparty/angle/src/compiler/preprocessor/new/pp_utils.h b/src/3rdparty/angle/src/compiler/preprocessor/pp_utils.h index 17164ea8b0..17164ea8b0 100644 --- a/src/3rdparty/angle/src/compiler/preprocessor/new/pp_utils.h +++ b/src/3rdparty/angle/src/compiler/preprocessor/pp_utils.h diff --git a/src/3rdparty/angle/src/compiler/preprocessor/preprocess.h b/src/3rdparty/angle/src/compiler/preprocessor/preprocess.h deleted file mode 100644 index 15056da2c9..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/preprocess.h +++ /dev/null @@ -1,50 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ - -#include "compiler/preprocessor/slglobals.h" -extern CPPStruct *cpp; -int InitCPPStruct(void); -int InitScanner(CPPStruct *cpp); -int InitAtomTable(AtomTable *atable, int htsize); -char* GetStringOfAtom(AtomTable *atable, int atom); diff --git a/src/3rdparty/angle/src/compiler/preprocessor/scanner.c b/src/3rdparty/angle/src/compiler/preprocessor/scanner.c deleted file mode 100644 index fde853c1e0..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/scanner.c +++ /dev/null @@ -1,698 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// scanner.c -// - -#include <assert.h> -#include <stdarg.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> - -#if 0 - #include <ieeefp.h> -#else - #define isinff(x) (((*(int *)&(x) & 0x7f800000L)==0x7f800000L) && \ - ((*(int *)&(x) & 0x007fffffL)==0000000000L)) -#endif - -#include "compiler/preprocessor/slglobals.h" -#include "compiler/util.h" - -typedef struct StringInputSrc { - InputSrc base; - char *p; -} StringInputSrc; - -static int ScanFromString(const char *s); - -static int eof_scan(InputSrc *is, yystypepp * yylvalpp) -{ - return EOF; -} // eof_scan - -static void noop(InputSrc *in, int ch, yystypepp * yylvalpp) {} - -static InputSrc eof_inputsrc = { 0, &eof_scan, &eof_scan, &noop, 0, 0 }; - -static int byte_scan(InputSrc *, yystypepp * yylvalpp); - -#define EOL_SY '\n' - -#if defined(_MSC_VER) - #define DBG_BREAKPOINT() __asm int 3 -#elif defined(_M_AMD64) - #define DBG_BREAKPOINT() assert(!"Dbg_Breakpoint"); -#else - #define DBG_BREAKPOINT() -#endif - -#if defined(_MSC_VER) && !defined(_M_AMD64) - __int64 RDTSC ( void ) { - - __int64 v; - - __asm __emit 0x0f - __asm __emit 0x31 - __asm mov dword ptr v, eax - __asm mov dword ptr v+4, edx - - return v; - } -#endif - - -int InitScanner(CPPStruct *cpp) -{ - // Add various atoms needed by the CPP line scanner: - if (!InitCPP()) - return 0; - - cpp->mostRecentToken = 0; - cpp->tokenLoc = &cpp->ltokenLoc; - - cpp->ltokenLoc.file = 0; - cpp->ltokenLoc.line = 0; - - cpp->currentInput = &eof_inputsrc; - cpp->previous_token = '\n'; - cpp->pastFirstStatement = 0; - - return 1; -} // InitScanner - -int FreeScanner(void) -{ - return (FreeCPP()); -} - -int InitScannerInput(CPPStruct *cpp, int count, const char* const string[], const int length[]) -{ - cpp->PaWhichStr = 0; - cpp->PaArgv = string; - cpp->PaArgc = count; - cpp->PaStrLen = length; - ScanFromString(string[0]); - return 0; -} - -/* - * str_getch() - * takes care of reading from multiple strings. - * returns the next-char from the input stream. - * returns EOF when the complete shader is parsed. - */ -static int str_getch(StringInputSrc *in) -{ - for(;;){ - if (*in->p){ - if (*in->p == '\n') { - in->base.line++; - IncLineNumber(); - } - return *in->p++; - } - if(++(cpp->PaWhichStr) < cpp->PaArgc){ - free(in); - SetStringNumber(cpp->PaWhichStr); - SetLineNumber(1); - ScanFromString(cpp->PaArgv[cpp->PaWhichStr]); - in=(StringInputSrc*)cpp->currentInput; - continue; - } - else{ - cpp->currentInput = in->base.prev; - cpp->PaWhichStr=0; - free(in); - return EOF; - } - } -} // str_getch - -static void str_ungetch(StringInputSrc *in, int ch, yystypepp *type) { - if (in->p[-1] == ch)in->p--; - else { - *(in->p)='\0'; //this would take care of shifting to the previous string. - cpp->PaWhichStr--; - } - if (ch == '\n') { - in->base.line--; - DecLineNumber(); - } -} // str_ungetch - -int ScanFromString(const char *s) -{ - - StringInputSrc *in = malloc(sizeof(StringInputSrc)); - memset(in, 0, sizeof(StringInputSrc)); - in->p = (char*) s; - in->base.line = 1; - in->base.scan = byte_scan; - in->base.getch = (int (*)(InputSrc *, yystypepp *))str_getch; - in->base.ungetch = (void (*)(InputSrc *, int, yystypepp *))str_ungetch; - in->base.prev = cpp->currentInput; - cpp->currentInput = &in->base; - - return 1; -} // ScanFromString; - - -/////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////// Floating point constants: ///////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -#define APPEND_CHAR_S(ch, str, len, max_len) \ - if (len < max_len) { \ - str[len++] = ch; \ - } else if (!alreadyComplained) { \ - CPPErrorToInfoLog("BUFFER OVERFLOW"); \ - alreadyComplained = 1; \ - } - -/* - * lFloatConst() - Scan a floating point constant. Assumes that the scanner - * has seen at least one digit, followed by either a decimal '.' or the - * letter 'e'. - * ch - '.' or 'e' - * len - length of string already copied into yylvalpp->symbol_name. - */ - -static int lFloatConst(int ch, int len, yystypepp * yylvalpp) -{ - int alreadyComplained = 0; - assert((ch == '.') || (ch == 'e') || (ch == 'E')); - - if (ch == '.') { - do { - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } while (ch >= '0' && ch <= '9'); - } - - // Exponent: - if (ch == 'e' || ch == 'E') { - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '+') { - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } else if (ch == '-') { - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } - if (ch >= '0' && ch <= '9') { - while (ch >= '0' && ch <= '9') { - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } - } else { - CPPErrorToInfoLog("EXPONENT INVALID"); - } - } - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - - assert(len <= MAX_SYMBOL_NAME_LEN); - yylvalpp->symbol_name[len] = '\0'; - yylvalpp->sc_fval = (float) atof_dot(yylvalpp->symbol_name); - if (isinff(yylvalpp->sc_fval)) { - CPPErrorToInfoLog("FLOAT CONSTANT OVERFLOW"); - } - return CPP_FLOATCONSTANT; -} // lFloatConst - -/////////////////////////////////////////////////////////////////////////////////////////////// -///////////////////////////////////////// Normal Scanner ////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -static int byte_scan(InputSrc *in, yystypepp * yylvalpp) -{ - char string_val[MAX_STRING_LEN + 1]; - int alreadyComplained = 0; - int len, ch, ii, ival = 0; - - for (;;) { - yylvalpp->sc_int = 0; - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - - while (ch == ' ' || ch == '\t' || ch == '\r') { - yylvalpp->sc_int = 1; - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } - - cpp->ltokenLoc.file = cpp->currentInput->name; - cpp->ltokenLoc.line = cpp->currentInput->line; - alreadyComplained = 0; - len = 0; - switch (ch) { - default: - return ch; // Single character token - case EOF: - return -1; - case 'A': case 'B': case 'C': case 'D': case 'E': - case 'F': case 'G': case 'H': case 'I': case 'J': - case 'K': case 'L': case 'M': case 'N': case 'O': - case 'P': case 'Q': case 'R': case 'S': case 'T': - case 'U': case 'V': case 'W': case 'X': case 'Y': - case 'Z': case '_': - case 'a': case 'b': case 'c': case 'd': case 'e': - case 'f': case 'g': case 'h': case 'i': case 'j': - case 'k': case 'l': case 'm': case 'n': case 'o': - case 'p': case 'q': case 'r': case 's': case 't': - case 'u': case 'v': case 'w': case 'x': case 'y': - case 'z': - do { - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } while ((ch >= 'a' && ch <= 'z') || - (ch >= 'A' && ch <= 'Z') || - (ch >= '0' && ch <= '9') || - ch == '_'); - assert(len <= MAX_SYMBOL_NAME_LEN); - yylvalpp->symbol_name[len] = '\0'; - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - yylvalpp->sc_ident = LookUpAddString(atable, yylvalpp->symbol_name); - return CPP_IDENTIFIER; - break; - case '0': - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == 'x' || ch == 'X') { // hexadecimal integer constants - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if ((ch >= '0' && ch <= '9') || - (ch >= 'A' && ch <= 'F') || - (ch >= 'a' && ch <= 'f')) - { - ival = 0; - do { - if ((ival <= 0x0fffffff) && (len < MAX_SYMBOL_NAME_LEN)) { - yylvalpp->symbol_name[len++] = ch; - if (ch >= '0' && ch <= '9') { - ii = ch - '0'; - } else if (ch >= 'A' && ch <= 'F') { - ii = ch - 'A' + 10; - } else { - ii = ch - 'a' + 10; - } - ival = (ival << 4) | ii; - } else if (!alreadyComplained) { - CPPErrorToInfoLog("HEX CONSTANT OVERFLOW"); - alreadyComplained = 1; - } - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } while ((ch >= '0' && ch <= '9') || - (ch >= 'A' && ch <= 'F') || - (ch >= 'a' && ch <= 'f')); - } else { - CPPErrorToInfoLog("HEX CONSTANT INVALID"); - } - assert(len <= MAX_SYMBOL_NAME_LEN); - yylvalpp->symbol_name[len] = '\0'; - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - yylvalpp->sc_int = ival; - return CPP_INTCONSTANT; - } else if (ch >= '0' && ch <= '7') { // octal integer constants - ival = 0; - do { - if ((ival <= 0x1fffffff) && (len < MAX_SYMBOL_NAME_LEN)) { - yylvalpp->symbol_name[len++] = ch; - ii = ch - '0'; - ival = (ival << 3) | ii; - } else if (!alreadyComplained) { - CPPErrorToInfoLog("OCT CONSTANT OVERFLOW"); - alreadyComplained = 1; - } - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } while (ch >= '0' && ch <= '7'); - if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'h' || ch == 'x'|| ch == 'E') - return lFloatConst(ch, len, yylvalpp); - assert(len <= MAX_SYMBOL_NAME_LEN); - yylvalpp->symbol_name[len] = '\0'; - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - yylvalpp->sc_int = ival; - return CPP_INTCONSTANT; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - ch = '0'; - } - // Fall through... - case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - do { - APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } while (ch >= '0' && ch <= '9'); - if (ch == '.' || ch == 'e' || ch == 'E') { - return lFloatConst(ch, len, yylvalpp); - } else { - assert(len <= MAX_SYMBOL_NAME_LEN); - yylvalpp->symbol_name[len] = '\0'; - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - ival = 0; - for (ii = 0; ii < len; ii++) { - ch = yylvalpp->symbol_name[ii] - '0'; - ival = ival*10 + ch; - if ((ival > 214748364) || (ival == 214748364 && ch >= 8)) { - CPPErrorToInfoLog("INTEGER CONSTANT OVERFLOW"); - break; - } - } - yylvalpp->sc_int = ival; - if(ival==0) - strcpy(yylvalpp->symbol_name,"0"); - return CPP_INTCONSTANT; - } - break; - case '-': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '-') { - return CPP_DEC_OP; - } else if (ch == '=') { - return CPP_SUB_ASSIGN; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '-'; - } - case '+': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '+') { - return CPP_INC_OP; - } else if (ch == '=') { - return CPP_ADD_ASSIGN; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '+'; - } - case '*': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '=') { - return CPP_MUL_ASSIGN; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '*'; - } - case '%': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '=') { - return CPP_MOD_ASSIGN; - } else if (ch == '>'){ - return CPP_RIGHT_BRACE; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '%'; - } - case ':': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '>') { - return CPP_RIGHT_BRACKET; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return ':'; - } - case '^': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '^') { - return CPP_XOR_OP; - } else { - if (ch == '=') - return CPP_XOR_ASSIGN; - else{ - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '^'; - } - } - - case '=': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '=') { - return CPP_EQ_OP; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '='; - } - case '!': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '=') { - return CPP_NE_OP; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '!'; - } - case '|': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '|') { - return CPP_OR_OP; - } else { - if (ch == '=') - return CPP_OR_ASSIGN; - else{ - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '|'; - } - } - case '&': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '&') { - return CPP_AND_OP; - } else { - if (ch == '=') - return CPP_AND_ASSIGN; - else{ - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '&'; - } - } - case '<': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '<') { - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if(ch == '=') - return CPP_LEFT_ASSIGN; - else{ - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return CPP_LEFT_OP; - } - } else { - if (ch == '=') { - return CPP_LE_OP; - } else { - if (ch == '%') - return CPP_LEFT_BRACE; - else if (ch == ':') - return CPP_LEFT_BRACKET; - else{ - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '<'; - } - } - } - case '>': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '>') { - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if(ch == '=') - return CPP_RIGHT_ASSIGN; - else{ - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return CPP_RIGHT_OP; - } - } else { - if (ch == '=') { - return CPP_GE_OP; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '>'; - } - } - case '.': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch >= '0' && ch <= '9') { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return lFloatConst('.', 0, yylvalpp); - } else { - if (ch == '.') { - return -1; // Special EOF hack - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '.'; - } - } - case '/': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == '/') { - do { - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } while (ch != '\n' && ch != EOF); - if (ch == EOF) - return -1; - return '\n'; - } else if (ch == '*') { - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - do { - while (ch != '*') { - if (ch == EOF) { - CPPErrorToInfoLog("EOF IN COMMENT"); - return -1; - } - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - } - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - if (ch == EOF) { - CPPErrorToInfoLog("EOF IN COMMENT"); - return -1; - } - } while (ch != '/'); - // Go try it again... - } else if (ch == '=') { - return CPP_DIV_ASSIGN; - } else { - cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp); - return '/'; - } - break; - case '"': - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - while (ch != '"' && ch != '\n' && ch != EOF) { - if (ch == '\\') { - CPPErrorToInfoLog("The line continuation character (\\) is not part of the OpenGL ES Shading Language"); - return -1; - } - APPEND_CHAR_S(ch, string_val, len, MAX_STRING_LEN); - ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp); - }; - assert(len <= MAX_STRING_LEN); - string_val[len] = '\0'; - if (ch == '"') { - yylvalpp->sc_ident = LookUpAddString(atable, string_val); - return CPP_STRCONSTANT; - } else { - CPPErrorToInfoLog("EOL IN STRING"); - return ERROR_SY; - } - break; - } - } -} // byte_scan - -int yylex_CPP(char* buf, int maxSize) -{ - yystypepp yylvalpp; - int token = '\n'; - - for(;;) { - - char* tokenString = 0; - token = cpp->currentInput->scan(cpp->currentInput, &yylvalpp); - if(check_EOF(token)) - return 0; - if (token < 0) { - // This check may need to be improved to support UTF-8 - // characters in comments. - CPPErrorToInfoLog("preprocessor encountered non-ASCII character in shader source"); - return 0; - } - if (token == '#') { - if (cpp->previous_token == '\n'|| cpp->previous_token == 0) { - token = readCPPline(&yylvalpp); - if(check_EOF(token)) - return 0; - continue; - } else { - CPPErrorToInfoLog("preprocessor command must not be preceded by any other statement in that line"); - return 0; - } - } - cpp->previous_token = token; - // expand macros - if (token == CPP_IDENTIFIER && MacroExpand(yylvalpp.sc_ident, &yylvalpp)) { - cpp->pastFirstStatement = 1; - continue; - } - - if (token == '\n') - continue; - cpp->pastFirstStatement = 1; - - if (token == CPP_IDENTIFIER) { - tokenString = GetStringOfAtom(atable,yylvalpp.sc_ident); - } else if (token == CPP_FLOATCONSTANT || token == CPP_INTCONSTANT){ - tokenString = yylvalpp.symbol_name; - } else { - tokenString = GetStringOfAtom(atable,token); - } - - if (tokenString) { - int len = strlen(tokenString); - cpp->tokensBeforeEOF = 1; - if (len >= maxSize) { - return maxSize; - } else if (len > 0) { - strcpy(buf, tokenString); - return len; - } - - return 0; - } - } -} // yylex - -//Checks if the token just read is EOF or not. -int check_EOF(int token) -{ - if(token==-1){ - if(cpp->ifdepth >0){ - CPPErrorToInfoLog("#endif missing!! Compilation stopped"); - cpp->CompileError=1; - } - return 1; - } - return 0; -} - -/////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////// End of scanner.c ////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - diff --git a/src/3rdparty/angle/src/compiler/preprocessor/scanner.h b/src/3rdparty/angle/src/compiler/preprocessor/scanner.h deleted file mode 100644 index b67c1d644e..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/scanner.h +++ /dev/null @@ -1,81 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// scanner.h -// - -#if !defined(__SCANNER_H) -#define __SCANNER_H 1 - -#include "compiler/preprocessor/length_limits.h" -#include "compiler/preprocessor/parser.h" - -// Not really atom table stuff but needed first... - -typedef struct SourceLoc_Rec { - unsigned short file, line; -} SourceLoc; - -int yylex_CPP(char* buf, int maxSize); - -typedef struct InputSrc { - struct InputSrc *prev; - int (*scan)(struct InputSrc *, yystypepp *); - int (*getch)(struct InputSrc *, yystypepp *); - void (*ungetch)(struct InputSrc *, int, yystypepp *); - int name; /* atom */ - int line; -} InputSrc; - -int InitScanner(CPPStruct *cpp); // Intialise the cpp scanner. -int InitScannerInput(CPPStruct *cpp, int count, const char* const string[], const int length[]); -int check_EOF(int); // check if we hit a EOF abruptly -void CPPErrorToInfoLog(const char *); // sticking the msg,line into the Shader's.Info.log -void SetLineNumber(int); -void SetStringNumber(int); -void IncLineNumber(void); -void DecLineNumber(void); -int FreeScanner(void); // Free the cpp scanner -#endif // !(defined(__SCANNER_H) - diff --git a/src/3rdparty/angle/src/compiler/preprocessor/slglobals.h b/src/3rdparty/angle/src/compiler/preprocessor/slglobals.h deleted file mode 100644 index 4634626643..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/slglobals.h +++ /dev/null @@ -1,82 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// slglobals.h -// - -#if !defined(__SLGLOBALS_H) -#define __SLGLOBALS_H 1 - -typedef struct CPPStruct_Rec CPPStruct; - -extern CPPStruct *cpp; - -#undef CPPC_DEBUG_THE_COMPILER -#if defined(_DEBUG) -#define CPPC_DEBUG_THE_COMPILER 1 -#endif - -#undef CPPC_ENABLE_TOOLS -#define CPPC_ENABLE_TOOLS 1 - -#include "compiler/preprocessor/memory.h" -#include "compiler/preprocessor/atom.h" -#include "compiler/preprocessor/scanner.h" -#include "compiler/preprocessor/cpp.h" -#include "compiler/preprocessor/tokens.h" -#include "compiler/preprocessor/symbols.h" -#include "compiler/preprocessor/compile.h" -#if !defined(NO_PARSER) -#include "compiler/preprocessor/parser.h" -#endif - -#if !defined(NULL) -#define NULL 0 -#endif - -#endif // !(defined(__SLGLOBALS_H) - - - - diff --git a/src/3rdparty/angle/src/compiler/preprocessor/symbols.c b/src/3rdparty/angle/src/compiler/preprocessor/symbols.c deleted file mode 100644 index f18b2569b3..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/symbols.c +++ /dev/null @@ -1,288 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// symbols.c -// - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> - -#include "compiler/preprocessor/slglobals.h" - -#if defined(_MSC_VER) -#pragma warning(disable: 4706) -#endif - -/////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////// Symbol Table Variables: /////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -Scope *ScopeList = NULL; -Scope *CurrentScope = NULL; -Scope *GlobalScope = NULL; - -static void unlinkScope(void *_scope) { - Scope *scope = _scope; - - if (scope->next) - scope->next->prev = scope->prev; - if (scope->prev) - scope->prev->next = scope->next; - else - ScopeList = scope->next; -} - -/* - * NewScope() - * - */ -Scope *NewScopeInPool(MemoryPool *pool) -{ - Scope *lScope; - - lScope = mem_Alloc(pool, sizeof(Scope)); - lScope->pool = pool; - lScope->parent = NULL; - lScope->funScope = NULL; - lScope->symbols = NULL; - - lScope->level = 0; - - lScope->programs = NULL; - if ((lScope->next = ScopeList)) - ScopeList->prev = lScope; - lScope->prev = 0; - ScopeList = lScope; - mem_AddCleanup(pool, unlinkScope, lScope); - return lScope; -} // NewScope - -/* - * PushScope() - * - */ - -void PushScope(Scope *fScope) -{ - Scope *lScope; - - if (CurrentScope) { - fScope->level = CurrentScope->level + 1; - if (fScope->level == 1) { - if (!GlobalScope) { - /* HACK - CTD -- if GlobalScope==NULL and level==1, we're - * defining a function in the superglobal scope. Things - * will break if we leave the level as 1, so we arbitrarily - * set it to 2 */ - fScope->level = 2; - } - } - if (fScope->level >= 2) { - lScope = fScope; - while (lScope->level > 2) - lScope = lScope->next; - fScope->funScope = lScope; - } - } else { - fScope->level = 0; - } - fScope->parent = CurrentScope; - CurrentScope = fScope; -} // PushScope - -/* - * PopScope() - * - */ - -Scope *PopScope(void) -{ - Scope *lScope; - - lScope = CurrentScope; - if (CurrentScope) - CurrentScope = CurrentScope->parent; - return lScope; -} // PopScope - -/* - * NewSymbol() - Allocate a new symbol node; - * - */ - -Symbol *NewSymbol(SourceLoc *loc, Scope *fScope, int name, symbolkind kind) -{ - Symbol *lSymb; - char *pch; - unsigned int ii; - - lSymb = (Symbol *) mem_Alloc(fScope->pool, sizeof(Symbol)); - lSymb->left = NULL; - lSymb->right = NULL; - lSymb->next = NULL; - lSymb->name = name; - lSymb->loc = *loc; - lSymb->kind = kind; - - // Clear union area: - - pch = (char *) &lSymb->details; - for (ii = 0; ii < sizeof(lSymb->details); ii++) - *pch++ = 0; - return lSymb; -} // NewSymbol - -/* - * lAddToTree() - Using a binary tree is not a good idea for basic atom values because they - * are generated in order. We'll fix this later (by reversing the bit pattern). - */ - -static void lAddToTree(Symbol **fSymbols, Symbol *fSymb) -{ - Symbol *lSymb; - int lrev, frev; - - lSymb = *fSymbols; - if (lSymb) { - frev = GetReversedAtom(atable, fSymb->name); - while (lSymb) { - lrev = GetReversedAtom(atable, lSymb->name); - if (lrev == frev) { - CPPErrorToInfoLog("GetAtomString(atable, fSymb->name)"); - break; - } else { - if (lrev > frev) { - if (lSymb->left) { - lSymb = lSymb->left; - } else { - lSymb->left = fSymb; - break; - } - } else { - if (lSymb->right) { - lSymb = lSymb->right; - } else { - lSymb->right = fSymb; - break; - } - } - } - } - } else { - *fSymbols = fSymb; - } -} // lAddToTree - - -/* - * AddSymbol() - Add a variable, type, or function name to a scope. - * - */ - -Symbol *AddSymbol(SourceLoc *loc, Scope *fScope, int atom, symbolkind kind) -{ - Symbol *lSymb; - - if (!fScope) - fScope = CurrentScope; - lSymb = NewSymbol(loc, fScope, atom, kind); - lAddToTree(&fScope->symbols, lSymb); - return lSymb; -} // AddSymbol - - -/*********************************************************************************************/ -/************************************ Symbol Semantic Functions ******************************/ -/*********************************************************************************************/ - -/* - * LookUpLocalSymbol() - * - */ - -Symbol *LookUpLocalSymbol(Scope *fScope, int atom) -{ - Symbol *lSymb; - int rname, ratom; - - ratom = GetReversedAtom(atable, atom); - if (!fScope) - fScope = CurrentScope; - lSymb = fScope->symbols; - while (lSymb) { - rname = GetReversedAtom(atable, lSymb->name); - if (rname == ratom) { - return lSymb; - } else { - if (rname > ratom) { - lSymb = lSymb->left; - } else { - lSymb = lSymb->right; - } - } - } - return NULL; -} // LookUpLocalSymbol - -/* - * LookUpSymbol() - * - */ - -Symbol *LookUpSymbol(Scope *fScope, int atom) -{ - Symbol *lSymb; - - if (!fScope) - fScope = CurrentScope; - while (fScope) { - lSymb = LookUpLocalSymbol(fScope, atom); - if (lSymb) - return lSymb; - fScope = fScope->parent; - } - return NULL; -} // LookUpSymbol - diff --git a/src/3rdparty/angle/src/compiler/preprocessor/symbols.h b/src/3rdparty/angle/src/compiler/preprocessor/symbols.h deleted file mode 100644 index e7d0b075fa..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/symbols.h +++ /dev/null @@ -1,111 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// symbols.h -// - -#if !defined(__SYMBOLS_H) -#define __SYMBOLS_H 1 - -#include "compiler/preprocessor/memory.h" - -typedef enum symbolkind { - MACRO_S -} symbolkind; - -// Typedefs for things defined here in "symbols.h": - -typedef struct Scope_Rec Scope; -typedef struct Symbol_Rec Symbol; - -typedef struct SymbolList_Rec { - struct SymbolList_Rec *next; - Symbol *symb; -} SymbolList; - -struct Scope_Rec { - Scope *next, *prev; // doubly-linked list of all scopes - Scope *parent; - Scope *funScope; // Points to base scope of enclosing function - MemoryPool *pool; // pool used for allocation in this scope - Symbol *symbols; - - int level; // 0 = super globals, 1 = globals, etc. - - // Only used at global scope (level 1): - SymbolList *programs; // List of programs for this compilation. -}; - - -// Symbol table is a simple binary tree. - -#include "compiler/preprocessor/cpp.h" // to get MacroSymbol def - -struct Symbol_Rec { - Symbol *left, *right; - Symbol *next; - int name; // Name atom - SourceLoc loc; - symbolkind kind; - union { - MacroSymbol mac; - } details; -}; - -extern Scope *CurrentScope; -extern Scope *GlobalScope; -extern Scope *ScopeList; - -Scope *NewScopeInPool(MemoryPool *); -#define NewScope() NewScopeInPool(CurrentScope->pool) -void PushScope(Scope *fScope); -Scope *PopScope(void); -Symbol *NewSymbol(SourceLoc *loc, Scope *fScope, int name, symbolkind kind); -Symbol *AddSymbol(SourceLoc *loc, Scope *fScope, int atom, symbolkind kind); -Symbol *LookUpLocalSymbol(Scope *fScope, int atom); -Symbol *LookUpSymbol(Scope *fScope, int atom); - - -#endif // !defined(__SYMBOLS_H) - diff --git a/src/3rdparty/angle/src/compiler/preprocessor/tokens.c b/src/3rdparty/angle/src/compiler/preprocessor/tokens.c deleted file mode 100644 index b94c05ebd4..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/tokens.c +++ /dev/null @@ -1,467 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// tokens.c -// - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#include <ctype.h> - -#include "common/angleutils.h" -#include "compiler/debug.h" -#include "compiler/preprocessor/slglobals.h" -#include "compiler/util.h" - -#if defined(_MSC_VER) -#pragma warning(disable: 4054) -#pragma warning(disable: 4152) -#endif - -/////////////////////////////////////////////////////////////////////////////////////////////// -//////////////////////// Preprocessor and Token Recorder and Playback: //////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// - -/* - * idstr() - * Copy a string to a malloc'ed block and convert it into something suitable - * for an ID - * - */ - -static char *idstr(const char *fstr, MemoryPool *pool) -{ - size_t len; - char *str, *t; - const char *f; - - len = strlen(fstr); - if (!pool) - str = (char *) malloc(len + 1); - else - str = (char *) mem_Alloc(pool, len + 1); - - for (f=fstr, t=str; *f; f++) { - if (isalnum(*f)) *t++ = *f; - else if (*f == '.' || *f == '/') *t++ = '_'; - } - *t = 0; - return str; -} // idstr - - -/* - * lNewBlock() - * - */ - -static TokenBlock *lNewBlock(TokenStream *fTok, MemoryPool *pool) -{ - TokenBlock *lBlock; - - if (!pool) - lBlock = (TokenBlock *) malloc(sizeof(TokenBlock) + 256); - else - lBlock = (TokenBlock *) mem_Alloc(pool, sizeof(TokenBlock) + 256); - lBlock->count = 0; - lBlock->current = 0; - lBlock->data = (unsigned char *) lBlock + sizeof(TokenBlock); - lBlock->max = 256; - lBlock->next = NULL; - if (fTok->head) { - fTok->current->next = lBlock; - } else { - fTok->head = lBlock; - } - fTok->current = lBlock; - return lBlock; -} // lNewBlock - -/* - * lAddByte() - * - */ - -static void lAddByte(TokenStream *fTok, unsigned char fVal) -{ - TokenBlock *lBlock; - lBlock = fTok->current; - if (lBlock->count >= lBlock->max) - lBlock = lNewBlock(fTok, 0); - lBlock->data[lBlock->count++] = fVal; -} // lAddByte - - - -/* - * lReadByte() - Get the next byte from a stream. - * - */ - -static int lReadByte(TokenStream *pTok) -{ - TokenBlock *lBlock; - int lval = -1; - - lBlock = pTok->current; - if (lBlock) { - if (lBlock->current >= lBlock->count) { - lBlock = lBlock->next; - if (lBlock) - lBlock->current = 0; - pTok->current = lBlock; - } - if (lBlock) - lval = lBlock->data[lBlock->current++]; - } - return lval; -} // lReadByte - -/////////////////////////////////////// Global Functions:////////////////////////////////////// - -/* - * NewTokenStream() - * - */ - -TokenStream *NewTokenStream(const char *name, MemoryPool *pool) -{ - TokenStream *pTok; - - if (!pool) - pTok = (TokenStream *) malloc(sizeof(TokenStream)); - else - pTok = (TokenStream*)mem_Alloc(pool, sizeof(TokenStream)); - pTok->next = NULL; - pTok->name = idstr(name, pool); - pTok->head = NULL; - pTok->current = NULL; - lNewBlock(pTok, pool); - return pTok; -} // NewTokenStream - -/* - * DeleteTokenStream() - * - */ - -void DeleteTokenStream(TokenStream *pTok) -{ - TokenBlock *pBlock, *nBlock; - - if (pTok) { - pBlock = pTok->head; - while (pBlock) { - nBlock = pBlock->next; - free(pBlock); - pBlock = nBlock; - } - if (pTok->name) - free(pTok->name); - free(pTok); - } -} // DeleteTokenStream - -/* - * RecordToken() - Add a token to the end of a list for later playback or printout. - * - */ - -void RecordToken(TokenStream *pTok, int token, yystypepp * yylvalpp) -{ - const char *s; - char *str=NULL; - - if (token > 256) - lAddByte(pTok, (unsigned char)((token & 0x7f) + 0x80)); - else - lAddByte(pTok, (unsigned char)(token & 0x7f)); - switch (token) { - case CPP_IDENTIFIER: - case CPP_TYPEIDENTIFIER: - case CPP_STRCONSTANT: - s = GetAtomString(atable, yylvalpp->sc_ident); - while (*s) - lAddByte(pTok, (unsigned char) *s++); - lAddByte(pTok, 0); - break; - case CPP_FLOATCONSTANT: - case CPP_INTCONSTANT: - str=yylvalpp->symbol_name; - while (*str){ - lAddByte(pTok, (unsigned char) *str++); - } - lAddByte(pTok, 0); - break; - case '(': - lAddByte(pTok, (unsigned char)(yylvalpp->sc_int ? 1 : 0)); - default: - break; - } -} // RecordToken - -/* - * RewindTokenStream() - Reset a token stream in preperation for reading. - * - */ - -void RewindTokenStream(TokenStream *pTok) -{ - if (pTok->head) { - pTok->current = pTok->head; - pTok->current->current = 0; - } -} // RewindTokenStream - -/* - * ReadToken() - Read the next token from a stream. - * - */ - -int ReadToken(TokenStream *pTok, yystypepp * yylvalpp) -{ - char symbol_name[MAX_SYMBOL_NAME_LEN + 1]; - char string_val[MAX_STRING_LEN + 1]; - int ltoken, len; - char ch; - int base, accum; - char ch_val; - - ltoken = lReadByte(pTok); - if (ltoken >= 0) { - if (ltoken > 127) - ltoken += 128; - switch (ltoken) { - case CPP_IDENTIFIER: - case CPP_TYPEIDENTIFIER: - len = 0; - ch = lReadByte(pTok); - while ((ch >= 'a' && ch <= 'z') || - (ch >= 'A' && ch <= 'Z') || - (ch >= '0' && ch <= '9') || - ch == '_') - { - if (len < MAX_SYMBOL_NAME_LEN) { - symbol_name[len++] = ch; - ch = lReadByte(pTok); - } - } - symbol_name[len] = '\0'; - assert(ch == '\0'); - yylvalpp->sc_ident = LookUpAddString(atable, symbol_name); - return CPP_IDENTIFIER; - break; - case CPP_STRCONSTANT: - len = 0; - while ((ch = lReadByte(pTok)) != 0) - if (len < MAX_STRING_LEN) - string_val[len++] = ch; - string_val[len] = '\0'; - yylvalpp->sc_ident = LookUpAddString(atable, string_val); - break; - case CPP_FLOATCONSTANT: - len = 0; - ch = lReadByte(pTok); - while ((ch >= '0' && ch <= '9')||(ch=='e'||ch=='E'||ch=='.')||(ch=='+'||ch=='-')) - { - if (len < MAX_SYMBOL_NAME_LEN) { - symbol_name[len++] = ch; - ch = lReadByte(pTok); - } - } - symbol_name[len] = '\0'; - assert(ch == '\0'); - strcpy(yylvalpp->symbol_name,symbol_name); - yylvalpp->sc_fval=(float)atof_dot(yylvalpp->symbol_name); - break; - case CPP_INTCONSTANT: - len = 0; - accum = 0; - ch = lReadByte(pTok); - if (ch == '0') { - symbol_name[len++] = ch; - ch = lReadByte(pTok); - if (ch == 'x' || ch == 'X') { - symbol_name[len++] = ch; - base = 16; - ch = lReadByte(pTok); - } else { - base = 8; - } - } else { - base = 10; - } - - while (len < MAX_SYMBOL_NAME_LEN) - { - ch_val = -1; - if (isdigit(ch)) - ch_val = ch - '0'; - else if (isxdigit(ch)) - ch_val = tolower(ch) - 'a' + 10; - - if (ch_val < 0 || ch_val >= base) - break; - - symbol_name[len++] = ch; - accum = accum * base + ch_val; - ch = lReadByte(pTok); - } - symbol_name[len] = '\0'; - assert(ch == '\0'); - strcpy(yylvalpp->symbol_name, symbol_name); - yylvalpp->sc_int = accum; - break; - case '(': - yylvalpp->sc_int = lReadByte(pTok); - break; - } - return ltoken; - } - return EOF_SY; -} // ReadToken - -typedef struct TokenInputSrc { - InputSrc base; - TokenStream *tokens; - int (*final)(CPPStruct *); -} TokenInputSrc; - -static int scan_token(TokenInputSrc *in, yystypepp * yylvalpp) -{ - int token = ReadToken(in->tokens, yylvalpp); - int (*final)(CPPStruct *); - cpp->tokenLoc->file = cpp->currentInput->name; - cpp->tokenLoc->line = cpp->currentInput->line; - if (token == '\n') { - in->base.line++; - return token; - } - if (token > 0) return token; - cpp->currentInput = in->base.prev; - final = in->final; - free(in); - if (final && !final(cpp)) return -1; - return cpp->currentInput->scan(cpp->currentInput, yylvalpp); -} - -int ReadFromTokenStream(TokenStream *ts, int name, int (*final)(CPPStruct *)) -{ - TokenInputSrc *in = malloc(sizeof(TokenInputSrc)); - memset(in, 0, sizeof(TokenInputSrc)); - in->base.name = name; - in->base.prev = cpp->currentInput; - in->base.scan = (int (*)(InputSrc *, yystypepp *))scan_token; - in->base.line = 1; - in->tokens = ts; - in->final = final; - RewindTokenStream(ts); - cpp->currentInput = &in->base; - return 1; -} - -typedef struct UngotToken { - InputSrc base; - int token; - yystypepp lval; -} UngotToken; - -static int reget_token(UngotToken *t, yystypepp * yylvalpp) -{ - int token = t->token; - *yylvalpp = t->lval; - cpp->currentInput = t->base.prev; - free(t); - return token; -} - -void UngetToken(int token, yystypepp * yylvalpp) { - UngotToken *t = malloc(sizeof(UngotToken)); - memset(t, 0, sizeof(UngotToken)); - t->token = token; - t->lval = *yylvalpp; - t->base.scan = (void *)reget_token; - t->base.prev = cpp->currentInput; - t->base.name = cpp->currentInput->name; - t->base.line = cpp->currentInput->line; - cpp->currentInput = &t->base; -} - - -void DumpTokenStream(FILE *fp, TokenStream *s, yystypepp * yylvalpp) { - int token; - char str[100]; - - if (fp == 0) fp = stdout; - RewindTokenStream(s); - while ((token = ReadToken(s, yylvalpp)) > 0) { - switch (token) { - case CPP_IDENTIFIER: - case CPP_TYPEIDENTIFIER: - snprintf(str, sizeof(str), "%s ", GetAtomString(atable, yylvalpp->sc_ident)); - break; - case CPP_STRCONSTANT: - snprintf(str, sizeof(str), "\"%s\"", GetAtomString(atable, yylvalpp->sc_ident)); - break; - case CPP_FLOATCONSTANT: - //printf("%g9.6 ", yylvalpp->sc_fval); - break; - case CPP_INTCONSTANT: - //printf("%d ", yylvalpp->sc_int); - break; - default: - if (token >= 127) - snprintf(str, sizeof(str), "%s ", GetAtomString(atable, token)); - else - snprintf(str, sizeof(str), "%c", token); - break; - } - CPPDebugLogMsg(str); - } -} - -/////////////////////////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////// End of tokens.c /////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/3rdparty/angle/src/compiler/preprocessor/tokens.h b/src/3rdparty/angle/src/compiler/preprocessor/tokens.h deleted file mode 100644 index dbf4a2ccfe..0000000000 --- a/src/3rdparty/angle/src/compiler/preprocessor/tokens.h +++ /dev/null @@ -1,90 +0,0 @@ -/****************************************************************************\ -Copyright (c) 2002, NVIDIA Corporation. - -NVIDIA Corporation("NVIDIA") supplies this software to you in -consideration of your agreement to the following terms, and your use, -installation, modification or redistribution of this NVIDIA software -constitutes acceptance of these terms. If you do not agree with these -terms, please do not use, install, modify or redistribute this NVIDIA -software. - -In consideration of your agreement to abide by the following terms, and -subject to these terms, NVIDIA grants you a personal, non-exclusive -license, under NVIDIA's copyrights in this original NVIDIA software (the -"NVIDIA Software"), to use, reproduce, modify and redistribute the -NVIDIA Software, with or without modifications, in source and/or binary -forms; provided that if you redistribute the NVIDIA Software, you must -retain the copyright notice of NVIDIA, this notice and the following -text and disclaimers in all such redistributions of the NVIDIA Software. -Neither the name, trademarks, service marks nor logos of NVIDIA -Corporation may be used to endorse or promote products derived from the -NVIDIA Software without specific prior written permission from NVIDIA. -Except as expressly stated in this notice, no other rights or licenses -express or implied, are granted by NVIDIA herein, including but not -limited to any patent rights that may be infringed by your derivative -works or by other works in which the NVIDIA Software may be -incorporated. No hardware is licensed hereunder. - -THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT -WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, -INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, -NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR -ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER -PRODUCTS. - -IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, -INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY -OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE -NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, -TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF -NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -\****************************************************************************/ -// -// tokens.h -// - -#if !defined(__TOKENS_H) -#define __TOKENS_H 1 - -#include <stdio.h> -#include "compiler/preprocessor/parser.h" - -#define EOF_SY (-1) - -typedef struct TokenBlock_Rec TokenBlock; - -typedef struct TokenStream_Rec { - struct TokenStream_Rec *next; - char *name; - TokenBlock *head; - TokenBlock *current; -} TokenStream; - -struct TokenBlock_Rec { - TokenBlock *next; - int current; - int count; - int max; - unsigned char *data; -}; - -extern TokenStream stdlib_cpp_stream; - - -TokenStream *NewTokenStream(const char *name, MemoryPool *pool); -void DeleteTokenStream(TokenStream *pTok); -void RecordToken(TokenStream *pTok, int token, yystypepp * yylvalpp); -void RewindTokenStream(TokenStream *pTok); -int ReadToken(TokenStream *pTok, yystypepp * yylvalpp); -int ReadFromTokenStream(TokenStream *pTok, int name, int (*final)(CPPStruct *)); -void UngetToken(int, yystypepp * yylvalpp); - -#if defined(CPPC_ENABLE_TOOLS) - -void DumpTokenStream(FILE *, TokenStream *, yystypepp * yylvalpp); - -#endif // defined(CPPC_ENABLE_TOOLS) - -#endif // !defined(__TOKENS_H) |