41a36bbb2f
git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@22066 e7fa87d3-cd2b-0410-9028-fcbf551c1848
191 lines
9.5 KiB
C
191 lines
9.5 KiB
C
//
|
|
//Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
|
//Copyright (C) 2012-2013 LunarG, Inc.
|
|
//
|
|
//All rights reserved.
|
|
//
|
|
//Redistribution and use in source and binary forms, with or without
|
|
//modification, are permitted provided that the following conditions
|
|
//are met:
|
|
//
|
|
// Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
//
|
|
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
//"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
//POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
#ifndef _PARSER_HELPER_INCLUDED_
|
|
#define _PARSER_HELPER_INCLUDED_
|
|
|
|
#include "Versions.h"
|
|
#include "../Include/ShHandle.h"
|
|
#include "SymbolTable.h"
|
|
#include "localintermediate.h"
|
|
|
|
struct TMatrixFields {
|
|
bool wholeRow;
|
|
bool wholeCol;
|
|
int row;
|
|
int col;
|
|
};
|
|
|
|
typedef enum {
|
|
EBhRequire,
|
|
EBhEnable,
|
|
EBhWarn,
|
|
EBhDisable
|
|
} TBehavior;
|
|
|
|
struct TPragma {
|
|
TPragma(bool o, bool d) : optimize(o), debug(d) { }
|
|
bool optimize;
|
|
bool debug;
|
|
TPragmaTable pragmaTable;
|
|
};
|
|
|
|
//
|
|
// The following are extra variables needed during parsing, grouped together so
|
|
// they can be passed to the parser without needing a global.
|
|
//
|
|
struct TParseContext {
|
|
TParseContext(TSymbolTable&, TIntermediate&, int version, EProfile, EShLanguage, TInfoSink&,
|
|
bool forwardCompatible = false, EShMessages messages = EShMsgDefault);
|
|
TIntermediate& intermediate; // to hold and build a parse tree
|
|
TSymbolTable& symbolTable; // symbol table that goes with the current language, version, and profile
|
|
TInfoSink& infoSink;
|
|
EShLanguage language; // vertex or fragment language
|
|
TIntermNode* treeRoot; // root of parse tree being created
|
|
int numErrors; // number of compile-time errors encountered
|
|
bool lexAfterType; // true if we've recognized a type, so can only be looking for an identifier
|
|
int loopNestingLevel; // 0 if outside all loops
|
|
int structNestingLevel; // 0 if outside blocks and structures
|
|
TList<TIntermSequence*> switchSequenceStack; // case, node, case, case, node, ...; ensure only one node between cases; stack of them for nesting
|
|
bool inTypeParen; // true if in parentheses, looking only for an identifier
|
|
const TType* currentFunctionType; // the return type of the function that's currently being parsed
|
|
bool functionReturnsValue; // true if a non-void function has a return
|
|
|
|
int version; // version, updated by #version in the shader
|
|
EProfile profile; // the declared profile in the shader (core by default)
|
|
bool forwardCompatible; // true if errors are to be given for use of deprecated features
|
|
EShMessages messages; // errors/warnings
|
|
TMap<TString, TBehavior> extensionBehavior; // for each extension string, what it's current enablement is
|
|
|
|
struct TPragma contextPragma;
|
|
TPrecisionQualifier defaultPrecision[EbtNumTypes];
|
|
static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2)); // see computeSamplerTypeIndex()
|
|
TPrecisionQualifier defaultSamplerPrecision[maxSamplerIndex];
|
|
TQualifier defaultGlobalQualification;
|
|
TString HashErrMsg;
|
|
bool AfterEOF;
|
|
const TString* blockName;
|
|
TPublicType publicBlockType;
|
|
|
|
void initializeExtensionBehavior();
|
|
const char* getPreamble();
|
|
|
|
void C_DECL error(TSourceLoc, const char *szReason, const char *szToken,
|
|
const char *szExtraInfoFormat, ...);
|
|
void C_DECL warn(TSourceLoc, const char *szReason, const char *szToken,
|
|
const char *szExtraInfoFormat, ...);
|
|
bool reservedErrorCheck(int line, const TString& identifier);
|
|
|
|
TIntermTyped* handleVariable(int line, TSymbol* symbol, TString* string);
|
|
bool parseVectorFields(const TString&, int vecSize, TVectorFields&, int line);
|
|
void assignError(int line, const char* op, TString left, TString right);
|
|
void unaryOpError(int line, const char* op, TString operand);
|
|
void binaryOpError(int line, const char* op, TString left, TString right);
|
|
void variableCheck(TIntermTyped*& nodePtr);
|
|
bool lValueErrorCheck(int line, const char* op, TIntermTyped*);
|
|
void constCheck(TIntermTyped* node);
|
|
void integerCheck(TIntermTyped* node, const char* token);
|
|
void globalCheck(int line, bool global, const char* token);
|
|
bool constructorError(int line, TIntermNode*, TFunction&, TOperator, TType&);
|
|
void arraySizeCheck(int line, TIntermTyped* expr, int& size);
|
|
bool arrayQualifierError(int line, const TPublicType&);
|
|
void arraySizeRequiredCheck(int line, int& size);
|
|
void arrayCheck(int line, TString& identifier, const TPublicType&, TVariable*& variable);
|
|
bool insertBuiltInArrayAtGlobalLevel();
|
|
bool voidErrorCheck(int, const TString&, const TPublicType&);
|
|
void boolCheck(int, const TIntermTyped*);
|
|
void boolCheck(int, const TPublicType&);
|
|
bool samplerErrorCheck(int line, const TPublicType& pType, const char* reason);
|
|
void globalQualifierFix(int line, TQualifier&, const TPublicType&);
|
|
bool structQualifierErrorCheck(int line, const TPublicType& pType);
|
|
void mergeQualifiers(int line, TPublicType& dst, const TPublicType& src, bool force);
|
|
void setDefaultPrecision(int line, TPublicType&, TPrecisionQualifier);
|
|
int computeSamplerTypeIndex(TSampler&);
|
|
TPrecisionQualifier getDefaultPrecision(TPublicType&);
|
|
void precisionQualifierCheck(int line, TPublicType&);
|
|
void parameterSamplerCheck(int line, TStorageQualifier qualifier, const TType& type);
|
|
bool containsSampler(const TType& type);
|
|
void nonInitConstCheck(int line, TString& identifier, TPublicType& type);
|
|
void nonInitCheck(int line, TString& identifier, TPublicType& type);
|
|
void paramCheck(int line, TStorageQualifier qualifier, TType* type);
|
|
void nestedBlockCheck(int line);
|
|
void nestedStructCheck(int line);
|
|
|
|
void setLayoutQualifier(int line, TPublicType&, TString&);
|
|
void setLayoutQualifier(int line, TPublicType&, TString&, int);
|
|
void mergeLayoutQualifiers(int line, TQualifier& dest, const TQualifier& src);
|
|
|
|
const TFunction* findFunction(int line, TFunction* pfnCall, bool *builtIn = 0);
|
|
bool executeInitializerError(TSourceLoc line, TString& identifier, TPublicType& pType,
|
|
TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable = 0);
|
|
TIntermTyped* addConstructor(TIntermNode*, const TType&, TOperator, TFunction*, TSourceLoc);
|
|
TIntermTyped* constructStruct(TIntermNode*, const TType&, int, TSourceLoc);
|
|
TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermNode*, TSourceLoc, bool subset);
|
|
void addBlock(int line, TTypeList& typeList, const TString* instanceName = 0, TArraySizes arraySizes = 0);
|
|
void wrapupSwitchSubsequence(TIntermAggregate* statements, TIntermNode* branchNode);
|
|
TIntermNode* addSwitch(int line, TIntermTyped* expression, TIntermAggregate* body);
|
|
void updateDefaults(int line, const TPublicType&, const TString* id);
|
|
TIntermTyped* addConstVectorNode(TVectorFields&, TIntermTyped*, TSourceLoc);
|
|
TIntermTyped* addConstMatrixNode(int , TIntermTyped*, TSourceLoc);
|
|
TIntermTyped* addConstArrayNode(int index, TIntermTyped* node, TSourceLoc line);
|
|
TIntermTyped* addConstStruct(TString& , TIntermTyped*, TSourceLoc);
|
|
|
|
bool arraySetMaxSize(TIntermSymbol*, TType*, int, bool, TSourceLoc);
|
|
|
|
void requireProfile(int line, EProfileMask profileMask, const char *featureDesc);
|
|
void requireStage(int line, EShLanguageMask languageMask, const char *featureDesc);
|
|
void profileRequires(int line, EProfile callingProfile, int minVersion, int numExtensions, const char* extensions[], const char *featureDesc);
|
|
void profileRequires(int line, EProfile callingProfile, int minVersion, const char* extension, const char *featureDesc);
|
|
void checkDeprecated(int line, EProfile callingProfile, int depVersion, const char *featureDesc);
|
|
void requireNotRemoved(int line, EProfile callingProfile, int removedVersion, const char *featureDesc);
|
|
void fullIntegerCheck(int line, const char* op);
|
|
void doubleCheck(int line, const char* op);
|
|
};
|
|
|
|
int PaParseStrings(char* argv[], int strLen[], int argc, TParseContext&, const char* preamble);
|
|
int PaParseComment(int &lineno, TParseContext&);
|
|
void ResetFlex();
|
|
|
|
typedef TParseContext* TParseContextPointer;
|
|
extern TParseContextPointer& GetGlobalParseContext();
|
|
#define GlobalParseContext GetGlobalParseContext()
|
|
|
|
typedef struct TThreadParseContextRec
|
|
{
|
|
TParseContext *lpGlobalParseContext;
|
|
} TThreadParseContext;
|
|
|
|
#endif // _PARSER_HELPER_INCLUDED_
|