2b4ebbb1e1
After parsing a #include directive, we push a TokenizableString
which contains the content of the included file into the input
stack. Henceforth, tokens will be read from the newly pushed
TokenizableString. However, the scanner in TParseContext still
points to the previous input stream. We need to update the scanner
to point to the new input stream inside TokenizableString. Thus,
the setCurrent{String|Line|..} method in TParseContext updates
the status of the correct input stream. After finishing the newly
pushed TokenizableString, we need to restore the scanner to the
previous input stream.
372 lines
21 KiB
C++
372 lines
21 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"
|
|
#include "Scan.h"
|
|
#include <functional>
|
|
|
|
#include <functional>
|
|
|
|
namespace glslang {
|
|
|
|
struct TPragma {
|
|
TPragma(bool o, bool d) : optimize(o), debug(d) { }
|
|
bool optimize;
|
|
bool debug;
|
|
TPragmaTable pragmaTable;
|
|
};
|
|
|
|
class TScanContext;
|
|
class TPpContext;
|
|
|
|
typedef std::set<int> TIdSetType;
|
|
|
|
//
|
|
// The following are extra variables needed during parsing, grouped together so
|
|
// they can be passed to the parser without needing a global.
|
|
//
|
|
class TParseContext {
|
|
public:
|
|
TParseContext(TSymbolTable&, TIntermediate&, bool parsingBuiltins, int version, EProfile, EShLanguage, TInfoSink&,
|
|
bool forwardCompatible = false, EShMessages messages = EShMsgDefault);
|
|
virtual ~TParseContext();
|
|
|
|
void setLimits(const TBuiltInResource&);
|
|
bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false);
|
|
void parserError(const char* s); // for bison's yyerror
|
|
const char* getPreamble();
|
|
|
|
void C_DECL error(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, ...);
|
|
void C_DECL warn(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, ...);
|
|
void C_DECL ppError(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, ...);
|
|
void C_DECL ppWarn(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, ...);
|
|
|
|
bool relaxedErrors() const { return (messages & EShMsgRelaxedErrors) != 0; }
|
|
bool suppressWarnings() const { return (messages & EShMsgSuppressWarnings) != 0; }
|
|
bool vulkanRules() const { return (messages & EShMsgVulkanRules) != 0; }
|
|
bool spirvRules() const { return (messages & EShMsgSpvRules) != 0; }
|
|
|
|
void reservedErrorCheck(const TSourceLoc&, const TString&);
|
|
void reservedPpErrorCheck(const TSourceLoc&, const char* name, const char* op);
|
|
bool lineContinuationCheck(const TSourceLoc&, bool endOfComment);
|
|
bool builtInName(const TString&);
|
|
|
|
void handlePragma(const TSourceLoc&, const TVector<TString>&);
|
|
TIntermTyped* handleVariable(const TSourceLoc&, TSymbol* symbol, const TString* string);
|
|
TIntermTyped* handleBracketDereference(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
|
|
void checkIndex(const TSourceLoc&, const TType&, int& index);
|
|
void handleIndexLimits(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
|
|
|
|
void makeEditable(TSymbol*&);
|
|
bool isIoResizeArray(const TType&) const;
|
|
void fixIoArraySize(const TSourceLoc&, TType&);
|
|
void ioArrayCheck(const TSourceLoc&, const TType&, const TString& identifier);
|
|
void handleIoResizeArrayAccess(const TSourceLoc&, TIntermTyped* base);
|
|
void checkIoArraysConsistency(const TSourceLoc&, bool tailOnly = false);
|
|
int getIoArrayImplicitSize() const;
|
|
void checkIoArrayConsistency(const TSourceLoc&, int requiredSize, const char* feature, TType&, const TString&);
|
|
|
|
TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right);
|
|
TIntermTyped* handleUnaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* childNode);
|
|
TIntermTyped* handleDotDereference(const TSourceLoc&, TIntermTyped* base, const TString& field);
|
|
void blockMemberExtensionCheck(const TSourceLoc&, const TIntermTyped* base, const TString& field);
|
|
TFunction* handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype);
|
|
TIntermAggregate* handleFunctionDefinition(const TSourceLoc&, TFunction&);
|
|
TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermNode*);
|
|
void checkLocation(const TSourceLoc&, TOperator);
|
|
TIntermTyped* handleLengthMethod(const TSourceLoc&, TFunction*, TIntermNode*);
|
|
void addInputArgumentConversions(const TFunction&, TIntermNode*&) const;
|
|
TIntermTyped* addOutputArgumentConversions(const TFunction&, TIntermAggregate&) const;
|
|
void nonOpBuiltInCheck(const TSourceLoc&, const TFunction&, TIntermAggregate&);
|
|
TFunction* handleConstructorCall(const TSourceLoc&, const TPublicType&);
|
|
|
|
bool parseVectorFields(const TSourceLoc&, const TString&, int vecSize, TVectorFields&);
|
|
void assignError(const TSourceLoc&, const char* op, TString left, TString right);
|
|
void unaryOpError(const TSourceLoc&, const char* op, TString operand);
|
|
void binaryOpError(const TSourceLoc&, const char* op, TString left, TString right);
|
|
void variableCheck(TIntermTyped*& nodePtr);
|
|
bool lValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*);
|
|
void rValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*);
|
|
void constantValueCheck(TIntermTyped* node, const char* token);
|
|
void integerCheck(const TIntermTyped* node, const char* token);
|
|
void globalCheck(const TSourceLoc&, const char* token);
|
|
bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&);
|
|
void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, int& size);
|
|
bool arrayQualifierError(const TSourceLoc&, const TQualifier&);
|
|
bool arrayError(const TSourceLoc&, const TType&);
|
|
void arraySizeRequiredCheck(const TSourceLoc&, int size);
|
|
void structArrayCheck(const TSourceLoc&, const TType& structure);
|
|
void arrayUnsizedCheck(const TSourceLoc&, const TQualifier&, int size, bool initializer);
|
|
void arrayOfArrayVersionCheck(const TSourceLoc&);
|
|
void arrayDimCheck(const TSourceLoc&, TArraySizes* sizes1, TArraySizes* sizes2);
|
|
void arrayDimCheck(const TSourceLoc&, const TType*, TArraySizes*);
|
|
bool voidErrorCheck(const TSourceLoc&, const TString&, TBasicType);
|
|
void boolCheck(const TSourceLoc&, const TIntermTyped*);
|
|
void boolCheck(const TSourceLoc&, const TPublicType&);
|
|
void samplerCheck(const TSourceLoc&, const TType&, const TString& identifier);
|
|
void atomicUintCheck(const TSourceLoc&, const TType&, const TString& identifier);
|
|
void globalQualifierFixCheck(const TSourceLoc&, TQualifier&);
|
|
void globalQualifierTypeCheck(const TSourceLoc&, const TQualifier&, const TPublicType&);
|
|
bool structQualifierErrorCheck(const TSourceLoc&, const TPublicType& pType);
|
|
void mergeQualifiers(const TSourceLoc&, TQualifier& dst, const TQualifier& src, bool force);
|
|
void setDefaultPrecision(const TSourceLoc&, TPublicType&, TPrecisionQualifier);
|
|
int computeSamplerTypeIndex(TSampler&);
|
|
TPrecisionQualifier getDefaultPrecision(TPublicType&);
|
|
void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&);
|
|
void parameterTypeCheck(const TSourceLoc&, TStorageQualifier qualifier, const TType& type);
|
|
bool containsFieldWithBasicType(const TType& type ,TBasicType basicType);
|
|
TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&, bool& newDeclaration);
|
|
void redeclareBuiltinBlock(const TSourceLoc&, TTypeList& typeList, const TString& blockName, const TString* instanceName, TArraySizes* arraySizes);
|
|
void paramCheckFix(const TSourceLoc&, const TStorageQualifier&, TType& type);
|
|
void paramCheckFix(const TSourceLoc&, const TQualifier&, TType& type);
|
|
void nestedBlockCheck(const TSourceLoc&);
|
|
void nestedStructCheck(const TSourceLoc&);
|
|
void arrayObjectCheck(const TSourceLoc&, const TType&, const char* op);
|
|
void opaqueCheck(const TSourceLoc&, const TType&, const char* op);
|
|
void structTypeCheck(const TSourceLoc&, TPublicType&);
|
|
void inductiveLoopCheck(const TSourceLoc&, TIntermNode* init, TIntermLoop* loop);
|
|
void arrayLimitCheck(const TSourceLoc&, const TString&, int size);
|
|
void limitCheck(const TSourceLoc&, int value, const char* limit, const char* feature);
|
|
|
|
void inductiveLoopBodyCheck(TIntermNode*, int loopIndexId, TSymbolTable&);
|
|
void constantIndexExpressionCheck(TIntermNode*);
|
|
|
|
void setLayoutQualifier(const TSourceLoc&, TPublicType&, TString&);
|
|
void setLayoutQualifier(const TSourceLoc&, TPublicType&, TString&, const TIntermTyped*);
|
|
void mergeObjectLayoutQualifiers(TQualifier& dest, const TQualifier& src, bool inheritOnly);
|
|
void layoutObjectCheck(const TSourceLoc&, const TSymbol&);
|
|
void layoutTypeCheck(const TSourceLoc&, const TType&);
|
|
void layoutQualifierCheck(const TSourceLoc&, const TQualifier&);
|
|
void checkNoShaderLayouts(const TSourceLoc&, const TShaderQualifiers&);
|
|
void fixOffset(const TSourceLoc&, TSymbol&);
|
|
|
|
const TFunction* findFunction(const TSourceLoc& loc, const TFunction& call, bool& builtIn);
|
|
const TFunction* findFunctionExact(const TSourceLoc& loc, const TFunction& call, bool& builtIn);
|
|
const TFunction* findFunction120(const TSourceLoc& loc, const TFunction& call, bool& builtIn);
|
|
const TFunction* findFunction400(const TSourceLoc& loc, const TFunction& call, bool& builtIn);
|
|
void declareTypeDefaults(const TSourceLoc&, const TPublicType&);
|
|
TIntermNode* declareVariable(const TSourceLoc&, TString& identifier, const TPublicType&, TArraySizes* typeArray = 0, TIntermTyped* initializer = 0);
|
|
TIntermTyped* addConstructor(const TSourceLoc&, TIntermNode*, const TType&, TOperator);
|
|
TIntermTyped* constructStruct(TIntermNode*, const TType&, int, const TSourceLoc&);
|
|
TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset);
|
|
void declareBlock(const TSourceLoc&, TTypeList& typeList, const TString* instanceName = 0, TArraySizes* arraySizes = 0);
|
|
void blockStageIoCheck(const TSourceLoc&, const TQualifier&);
|
|
void blockQualifierCheck(const TSourceLoc&, const TQualifier&);
|
|
void fixBlockLocations(const TSourceLoc&, TQualifier&, TTypeList&, bool memberWithLocation, bool memberWithoutLocation);
|
|
void fixBlockXfbOffsets(TQualifier&, TTypeList&);
|
|
void fixBlockUniformOffsets(TQualifier&, TTypeList&);
|
|
void addQualifierToExisting(const TSourceLoc&, TQualifier, const TString& identifier);
|
|
void addQualifierToExisting(const TSourceLoc&, TQualifier, TIdentifierList&);
|
|
void invariantCheck(const TSourceLoc&, const TQualifier&);
|
|
void updateStandaloneQualifierDefaults(const TSourceLoc&, const TPublicType&);
|
|
void wrapupSwitchSubsequence(TIntermAggregate* statements, TIntermNode* branchNode);
|
|
TIntermNode* addSwitch(const TSourceLoc&, TIntermTyped* expression, TIntermAggregate* body);
|
|
|
|
void updateImplicitArraySize(const TSourceLoc&, TIntermNode*, int index);
|
|
|
|
void setScanContext(TScanContext* c) { scanContext = c; }
|
|
TScanContext* getScanContext() const { return scanContext; }
|
|
void setPpContext(TPpContext* c) { ppContext = c; }
|
|
TPpContext* getPpContext() const { return ppContext; }
|
|
void addError() { ++numErrors; }
|
|
int getNumErrors() const { return numErrors; }
|
|
const TSourceLoc& getCurrentLoc() const { return currentScanner->getSourceLoc(); }
|
|
void setCurrentLine(int line) { currentScanner->setLine(line); }
|
|
void setCurrentColumn(int col) { currentScanner->setColumn(col); }
|
|
void setCurrentSourceName(const char* name) { currentScanner->setFile(name); }
|
|
void setCurrentString(int string) { currentScanner->setString(string); }
|
|
void setScanner(TInputScanner* scanner) { currentScanner = scanner; }
|
|
TInputScanner* getScanner() const { return currentScanner; }
|
|
|
|
bool lineDirectiveShouldSetNextLine() const;
|
|
|
|
void notifyVersion(int line, int version, const char* type_string);
|
|
void notifyErrorDirective(int line, const char* error_message);
|
|
void notifyLineDirective(int curLineNo, int newLineNo, bool hasSource, int sourceNum, const char* sourceName);
|
|
void notifyExtensionDirective(int line, const char* extension, const char* behavior);
|
|
|
|
// The following are implemented in Versions.cpp to localize version/profile/stage/extensions control
|
|
void initializeExtensionBehavior();
|
|
void requireProfile(const TSourceLoc&, int queryProfiles, const char* featureDesc);
|
|
void profileRequires(const TSourceLoc&, int queryProfiles, int minVersion, int numExtensions, const char* const extensions[], const char* featureDesc);
|
|
void profileRequires(const TSourceLoc&, int queryProfiles, int minVersion, const char* const extension, const char* featureDesc);
|
|
void requireStage(const TSourceLoc&, EShLanguageMask, const char* featureDesc);
|
|
void requireStage(const TSourceLoc&, EShLanguage, const char* featureDesc);
|
|
void checkDeprecated(const TSourceLoc&, int queryProfiles, int depVersion, const char* featureDesc);
|
|
void requireNotRemoved(const TSourceLoc&, int queryProfiles, int removedVersion, const char* featureDesc);
|
|
void requireExtensions(const TSourceLoc&, int numExtensions, const char* const extensions[], const char* featureDesc, bool requiredByPreprocessor = false);
|
|
TExtensionBehavior getExtensionBehavior(const char*);
|
|
bool extensionTurnedOn(const char* const extension);
|
|
bool extensionsTurnedOn(int numExtensions, const char* const extensions[]);
|
|
void updateExtensionBehavior(int line, const char* const extension, const char* behavior);
|
|
void fullIntegerCheck(const TSourceLoc&, const char* op);
|
|
void doubleCheck(const TSourceLoc&, const char* op);
|
|
|
|
void setVersionCallback(const std::function<void(int, int, const char*)>& func) { versionCallback = func; }
|
|
void setPragmaCallback(const std::function<void(int, const TVector<TString>&)>& func) { pragmaCallback = func; }
|
|
void setLineCallback(const std::function<void(int, int, bool, int, const char*)>& func) { lineCallback = func; }
|
|
void setExtensionCallback(const std::function<void(int, const char*, const char*)>& func) { extensionCallback = func; }
|
|
void setErrorCallback(const std::function<void(int, const char*)>& func) { errorCallback = func; }
|
|
|
|
protected:
|
|
void nonInitConstCheck(const TSourceLoc&, TString& identifier, TType& type);
|
|
void inheritGlobalDefaults(TQualifier& dst) const;
|
|
TVariable* makeInternalVariable(const char* name, const TType&) const;
|
|
TVariable* declareNonArray(const TSourceLoc&, TString& identifier, TType&, bool& newDeclaration);
|
|
void declareArray(const TSourceLoc&, TString& identifier, const TType&, TSymbol*&, bool& newDeclaration);
|
|
TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable);
|
|
TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer);
|
|
TOperator mapTypeToConstructorOp(const TType&) const;
|
|
void updateExtensionBehavior(const char* const extension, TExtensionBehavior);
|
|
void finalErrorCheck();
|
|
void outputMessage(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, TPrefixType prefix,
|
|
va_list args);
|
|
|
|
public:
|
|
//
|
|
// Generally, bison productions, the scanner, and the PP need read/write access to these; just give them direct access
|
|
//
|
|
|
|
TIntermediate& intermediate; // helper for making and hooking up pieces of the parse tree
|
|
TSymbolTable& symbolTable; // symbol table that goes with the current language, version, and profile
|
|
TInfoSink& infoSink;
|
|
|
|
// compilation mode
|
|
EShLanguage language; // vertex or fragment language
|
|
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
|
|
|
|
// Current state of parsing
|
|
struct TPragma contextPragma;
|
|
int loopNestingLevel; // 0 if outside all loops
|
|
int structNestingLevel; // 0 if outside blocks and structures
|
|
int controlFlowNestingLevel; // 0 if outside all flow control
|
|
int statementNestingLevel; // 0 if outside all flow control or compound statements
|
|
TList<TIntermSequence*> switchSequenceStack; // case, node, case, case, node, ...; ensure only one node between cases; stack of them for nesting
|
|
TList<int> switchLevel; // the statementNestingLevel the current switch statement is at, which must match the level of its case statements
|
|
bool inMain; // if inside a function, true if the function is main
|
|
bool postMainReturn; // if inside a function, true if the function is main and this is after a return statement
|
|
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
|
|
const TString* blockName;
|
|
TQualifier currentBlockQualifier;
|
|
TIntermAggregate *linkage; // aggregate node of objects the linker may need, if not referenced by the rest of the AST
|
|
TPrecisionQualifier defaultPrecision[EbtNumTypes];
|
|
bool tokensBeforeEOF;
|
|
TBuiltInResource resources;
|
|
TLimits& limits;
|
|
|
|
protected:
|
|
TParseContext(TParseContext&);
|
|
TParseContext& operator=(TParseContext&);
|
|
|
|
EShMessages messages; // errors/warnings/rule-sets
|
|
TScanContext* scanContext;
|
|
TPpContext* ppContext;
|
|
TInputScanner* currentScanner;
|
|
int numErrors; // number of compile-time errors encountered
|
|
bool parsingBuiltins; // true if parsing built-in symbols/functions
|
|
TMap<TString, TExtensionBehavior> extensionBehavior; // for each extension string, what its current behavior is set to
|
|
static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2 * 2)); // see computeSamplerTypeIndex()
|
|
TPrecisionQualifier defaultSamplerPrecision[maxSamplerIndex];
|
|
bool afterEOF;
|
|
TQualifier globalBufferDefaults;
|
|
TQualifier globalUniformDefaults;
|
|
TQualifier globalInputDefaults;
|
|
TQualifier globalOutputDefaults;
|
|
int* atomicUintOffsets; // to become an array of the right size to hold an offset per binding point
|
|
TString currentCaller;
|
|
TIdSetType inductiveLoopIds;
|
|
bool anyIndexLimits;
|
|
TVector<TIntermTyped*> needsIndexLimitationChecking;
|
|
|
|
//
|
|
// Geometry shader input arrays:
|
|
// - array sizing is based on input primitive and/or explicit size
|
|
//
|
|
// Tessellation control output arrays:
|
|
// - array sizing is based on output layout(vertices=...) and/or explicit size
|
|
//
|
|
// Both:
|
|
// - array sizing is retroactive
|
|
// - built-in block redeclarations interact with this
|
|
//
|
|
// Design:
|
|
// - use a per-context "resize-list", a list of symbols whose array sizes
|
|
// can be fixed
|
|
//
|
|
// - the resize-list starts empty at beginning of user-shader compilation, it does
|
|
// not have built-ins in it
|
|
//
|
|
// - on built-in array use: copyUp() symbol and add it to the resize-list
|
|
//
|
|
// - on user array declaration: add it to the resize-list
|
|
//
|
|
// - on block redeclaration: copyUp() symbol and add it to the resize-list
|
|
// * note, that appropriately gives an error if redeclaring a block that
|
|
// was already used and hence already copied-up
|
|
//
|
|
// - on seeing a layout declaration that sizes the array, fix everything in the
|
|
// resize-list, giving errors for mismatch
|
|
//
|
|
// - on seeing an array size declaration, give errors on mismatch between it and previous
|
|
// array-sizing declarations
|
|
//
|
|
TVector<TSymbol*> ioArraySymbolResizeList;
|
|
|
|
// These, if set, will be called when a line, pragma ... is preprocessed.
|
|
// They will be called with any parameters to the original directive.
|
|
std::function<void(int, int, bool, int, const char*)> lineCallback;
|
|
std::function<void(int, const TVector<TString>&)> pragmaCallback;
|
|
std::function<void(int, int, const char*)> versionCallback;
|
|
std::function<void(int, const char*, const char*)> extensionCallback;
|
|
std::function<void(int, const char*)> errorCallback;
|
|
};
|
|
|
|
} // end namespace glslang
|
|
|
|
#endif // _PARSER_HELPER_INCLUDED_
|