24dcbd1b1f
According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The packed qualifier overrides only std140, std430, and shared; other qualifiers are inherited. When packed is used, no shareable layout is guaranteed. The compiler and linker can optimize memory use based on what variables actively get used and on other criteria. Offsets must be queried, as there is no other way of guaranteeing where (and which) variables reside within the block" we should reserve std140 block and shared block in reflection. According to the spec glsl4.60.7: 4.4.5. Uniform and Shader Storage Block Layout Qualifiers: "The row_major and column_major qualifiers only affect the layout of matrices, including all matrices contained in structures and arrays they are applied to, to all depths of nesting. These qualifiers can be applied to other types, but will have no effect." We need ensure all matrix block member been effect. Support EShMsgKeepUncalled in reflection EShMsgKeepUncalled is a link message for link program. We need only one option to control uncalled function optimization. If we set EShMsgKeepUncalled as false in link time, linker won't be keep the uncall function sequence in AST, and if we set EShMsgKeepUncalled as true in link time, linker will keep all uncalled function sequence in AST. So, in reflecte time, we just only travers all function sequence. It make EShMsgKeepUncalled only work at linker, and can effect reflection. Recursively layout packing to "block member" layout packing isn't set recursively, it causes TReflection::getOffsets doesn't work correctly.
533 lines
28 KiB
C++
533 lines
28 KiB
C++
//
|
|
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
|
// Copyright (C) 2012-2013 LunarG, Inc.
|
|
// Copyright (C) 2015-2018 Google, 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.
|
|
//
|
|
|
|
//
|
|
// This header defines a two-level parse-helper hierarchy, derived from
|
|
// TParseVersions:
|
|
// - TParseContextBase: sharable across multiple parsers
|
|
// - TParseContext: GLSL specific helper
|
|
//
|
|
|
|
#ifndef _PARSER_HELPER_INCLUDED_
|
|
#define _PARSER_HELPER_INCLUDED_
|
|
|
|
#include <cstdarg>
|
|
#include <functional>
|
|
|
|
#include "parseVersions.h"
|
|
#include "../Include/ShHandle.h"
|
|
#include "SymbolTable.h"
|
|
#include "localintermediate.h"
|
|
#include "Scan.h"
|
|
#include "attribute.h"
|
|
|
|
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;
|
|
typedef std::map<const TTypeList*, std::map<size_t, const TTypeList*>> TStructRecord;
|
|
|
|
//
|
|
// Sharable code (as well as what's in TParseVersions) across
|
|
// parse helpers.
|
|
//
|
|
class TParseContextBase : public TParseVersions {
|
|
public:
|
|
TParseContextBase(TSymbolTable& symbolTable, TIntermediate& interm, bool parsingBuiltins, int version,
|
|
EProfile profile, const SpvVersion& spvVersion, EShLanguage language,
|
|
TInfoSink& infoSink, bool forwardCompatible, EShMessages messages,
|
|
const TString* entryPoint = nullptr)
|
|
: TParseVersions(interm, version, profile, spvVersion, language, infoSink, forwardCompatible, messages),
|
|
scopeMangler("::"),
|
|
symbolTable(symbolTable),
|
|
statementNestingLevel(0), loopNestingLevel(0), structNestingLevel(0), controlFlowNestingLevel(0),
|
|
postEntryPointReturn(false),
|
|
contextPragma(true, false),
|
|
beginInvocationInterlockCount(0), endInvocationInterlockCount(0),
|
|
parsingBuiltins(parsingBuiltins), scanContext(nullptr), ppContext(nullptr),
|
|
limits(resources.limits),
|
|
globalUniformBlock(nullptr),
|
|
globalUniformBinding(TQualifier::layoutBindingEnd),
|
|
globalUniformSet(TQualifier::layoutSetEnd)
|
|
{
|
|
if (entryPoint != nullptr)
|
|
sourceEntryPointName = *entryPoint;
|
|
}
|
|
virtual ~TParseContextBase() { }
|
|
|
|
#if !defined(GLSLANG_WEB) || defined(GLSLANG_WEB_DEVEL)
|
|
virtual void C_DECL error(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, ...);
|
|
virtual void C_DECL warn(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, ...);
|
|
virtual void C_DECL ppError(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, ...);
|
|
virtual void C_DECL ppWarn(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, ...);
|
|
#endif
|
|
|
|
virtual void setLimits(const TBuiltInResource&) = 0;
|
|
|
|
void checkIndex(const TSourceLoc&, const TType&, int& index);
|
|
|
|
EShLanguage getLanguage() const { return language; }
|
|
void setScanContext(TScanContext* c) { scanContext = c; }
|
|
TScanContext* getScanContext() const { return scanContext; }
|
|
void setPpContext(TPpContext* c) { ppContext = c; }
|
|
TPpContext* getPpContext() const { return ppContext; }
|
|
|
|
virtual void setLineCallback(const std::function<void(int, int, bool, int, const char*)>& func) { lineCallback = func; }
|
|
virtual void setExtensionCallback(const std::function<void(int, const char*, const char*)>& func) { extensionCallback = func; }
|
|
virtual void setVersionCallback(const std::function<void(int, int, const char*)>& func) { versionCallback = func; }
|
|
virtual void setPragmaCallback(const std::function<void(int, const TVector<TString>&)>& func) { pragmaCallback = func; }
|
|
virtual void setErrorCallback(const std::function<void(int, const char*)>& func) { errorCallback = func; }
|
|
|
|
virtual void reservedPpErrorCheck(const TSourceLoc&, const char* name, const char* op) = 0;
|
|
virtual bool lineContinuationCheck(const TSourceLoc&, bool endOfComment) = 0;
|
|
virtual bool lineDirectiveShouldSetNextLine() const = 0;
|
|
virtual void handlePragma(const TSourceLoc&, const TVector<TString>&) = 0;
|
|
|
|
virtual bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false) = 0;
|
|
|
|
virtual void notifyVersion(int line, int version, const char* type_string)
|
|
{
|
|
if (versionCallback)
|
|
versionCallback(line, version, type_string);
|
|
}
|
|
virtual void notifyErrorDirective(int line, const char* error_message)
|
|
{
|
|
if (errorCallback)
|
|
errorCallback(line, error_message);
|
|
}
|
|
virtual void notifyLineDirective(int curLineNo, int newLineNo, bool hasSource, int sourceNum, const char* sourceName)
|
|
{
|
|
if (lineCallback)
|
|
lineCallback(curLineNo, newLineNo, hasSource, sourceNum, sourceName);
|
|
}
|
|
virtual void notifyExtensionDirective(int line, const char* extension, const char* behavior)
|
|
{
|
|
if (extensionCallback)
|
|
extensionCallback(line, extension, behavior);
|
|
}
|
|
|
|
#ifdef ENABLE_HLSL
|
|
// Manage the global uniform block (default uniforms in GLSL, $Global in HLSL)
|
|
virtual void growGlobalUniformBlock(const TSourceLoc&, TType&, const TString& memberName, TTypeList* typeList = nullptr);
|
|
#endif
|
|
|
|
// Potentially rename shader entry point function
|
|
void renameShaderFunction(TString*& name) const
|
|
{
|
|
// Replace the entry point name given in the shader with the real entry point name,
|
|
// if there is a substitution.
|
|
if (name != nullptr && *name == sourceEntryPointName && intermediate.getEntryPointName().size() > 0)
|
|
name = NewPoolTString(intermediate.getEntryPointName().c_str());
|
|
}
|
|
|
|
virtual bool lValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*);
|
|
virtual void rValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*);
|
|
|
|
const char* const scopeMangler;
|
|
|
|
// Basic parsing state, easily accessible to the grammar
|
|
|
|
TSymbolTable& symbolTable; // symbol table that goes with the current language, version, and profile
|
|
int statementNestingLevel; // 0 if outside all flow control or compound statements
|
|
int loopNestingLevel; // 0 if outside all loops
|
|
int structNestingLevel; // 0 if outside blocks and structures
|
|
int controlFlowNestingLevel; // 0 if outside all flow control
|
|
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
|
|
// if inside a function, true if the function is the entry point and this is after a return statement
|
|
bool postEntryPointReturn;
|
|
// case, node, case, case, node, ...; ensure only one node between cases; stack of them for nesting
|
|
TList<TIntermSequence*> switchSequenceStack;
|
|
// the statementNestingLevel the current switch statement is at, which must match the level of its case statements
|
|
TList<int> switchLevel;
|
|
struct TPragma contextPragma;
|
|
int beginInvocationInterlockCount;
|
|
int endInvocationInterlockCount;
|
|
|
|
protected:
|
|
TParseContextBase(TParseContextBase&);
|
|
TParseContextBase& operator=(TParseContextBase&);
|
|
|
|
const bool parsingBuiltins; // true if parsing built-in symbols/functions
|
|
TVector<TSymbol*> linkageSymbols; // will be transferred to 'linkage', after all editing is done, order preserving
|
|
TScanContext* scanContext;
|
|
TPpContext* ppContext;
|
|
TBuiltInResource resources;
|
|
TLimits& limits;
|
|
TString sourceEntryPointName;
|
|
|
|
// 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;
|
|
|
|
// see implementation for detail
|
|
const TFunction* selectFunction(const TVector<const TFunction*>, const TFunction&,
|
|
std::function<bool(const TType&, const TType&, TOperator, int arg)>,
|
|
std::function<bool(const TType&, const TType&, const TType&)>,
|
|
/* output */ bool& tie);
|
|
|
|
virtual void parseSwizzleSelector(const TSourceLoc&, const TString&, int size,
|
|
TSwizzleSelectors<TVectorSelector>&);
|
|
|
|
// Manage the global uniform block (default uniforms in GLSL, $Global in HLSL)
|
|
TVariable* globalUniformBlock; // the actual block, inserted into the symbol table
|
|
unsigned int globalUniformBinding; // the block's binding number
|
|
unsigned int globalUniformSet; // the block's set number
|
|
int firstNewMember; // the index of the first member not yet inserted into the symbol table
|
|
// override this to set the language-specific name
|
|
virtual const char* getGlobalUniformBlockName() const { return ""; }
|
|
virtual void setUniformBlockDefaults(TType&) const { }
|
|
virtual void finalizeGlobalUniformBlockLayout(TVariable&) { }
|
|
virtual void outputMessage(const TSourceLoc&, const char* szReason, const char* szToken,
|
|
const char* szExtraInfoFormat, TPrefixType prefix,
|
|
va_list args);
|
|
virtual void trackLinkage(TSymbol& symbol);
|
|
virtual void makeEditable(TSymbol*&);
|
|
virtual TVariable* getEditableVariable(const char* name);
|
|
virtual void finish();
|
|
};
|
|
|
|
//
|
|
// Manage the state for when to respect precision qualifiers and when to warn about
|
|
// the defaults being different than might be expected.
|
|
//
|
|
class TPrecisionManager {
|
|
public:
|
|
TPrecisionManager() : obey(false), warn(false), explicitIntDefault(false), explicitFloatDefault(false){ }
|
|
virtual ~TPrecisionManager() {}
|
|
|
|
void respectPrecisionQualifiers() { obey = true; }
|
|
bool respectingPrecisionQualifiers() const { return obey; }
|
|
bool shouldWarnAboutDefaults() const { return warn; }
|
|
void defaultWarningGiven() { warn = false; }
|
|
void warnAboutDefaults() { warn = true; }
|
|
void explicitIntDefaultSeen()
|
|
{
|
|
explicitIntDefault = true;
|
|
if (explicitFloatDefault)
|
|
warn = false;
|
|
}
|
|
void explicitFloatDefaultSeen()
|
|
{
|
|
explicitFloatDefault = true;
|
|
if (explicitIntDefault)
|
|
warn = false;
|
|
}
|
|
|
|
protected:
|
|
bool obey; // respect precision qualifiers
|
|
bool warn; // need to give a warning about the defaults
|
|
bool explicitIntDefault; // user set the default for int/uint
|
|
bool explicitFloatDefault; // user set the default for float
|
|
};
|
|
|
|
//
|
|
// GLSL-specific parse helper. Should have GLSL in the name, but that's
|
|
// too big of a change for comparing branches at the moment, and perhaps
|
|
// impacts downstream consumers as well.
|
|
//
|
|
class TParseContext : public TParseContextBase {
|
|
public:
|
|
TParseContext(TSymbolTable&, TIntermediate&, bool parsingBuiltins, int version, EProfile, const SpvVersion& spvVersion, EShLanguage, TInfoSink&,
|
|
bool forwardCompatible = false, EShMessages messages = EShMsgDefault,
|
|
const TString* entryPoint = nullptr);
|
|
virtual ~TParseContext();
|
|
|
|
bool obeyPrecisionQualifiers() const { return precisionManager.respectingPrecisionQualifiers(); }
|
|
void setPrecisionDefaults();
|
|
|
|
void setLimits(const TBuiltInResource&) override;
|
|
bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false) override;
|
|
void parserError(const char* s); // for bison's yyerror
|
|
|
|
void reservedErrorCheck(const TSourceLoc&, const TString&);
|
|
void reservedPpErrorCheck(const TSourceLoc&, const char* name, const char* op) override;
|
|
bool lineContinuationCheck(const TSourceLoc&, bool endOfComment) override;
|
|
bool lineDirectiveShouldSetNextLine() const override;
|
|
bool builtInName(const TString&);
|
|
|
|
void handlePragma(const TSourceLoc&, const TVector<TString>&) override;
|
|
TIntermTyped* handleVariable(const TSourceLoc&, TSymbol* symbol, const TString* string);
|
|
TIntermTyped* handleBracketDereference(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
|
|
void handleIndexLimits(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
|
|
|
|
#ifndef GLSLANG_WEB
|
|
void makeEditable(TSymbol*&) override;
|
|
void ioArrayCheck(const TSourceLoc&, const TType&, const TString& identifier);
|
|
#endif
|
|
bool isIoResizeArray(const TType&) const;
|
|
void fixIoArraySize(const TSourceLoc&, TType&);
|
|
void handleIoResizeArrayAccess(const TSourceLoc&, TIntermTyped* base);
|
|
void checkIoArraysConsistency(const TSourceLoc&, bool tailOnly = false);
|
|
int getIoArrayImplicitSize(const TQualifier&, TString* featureString = nullptr) 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);
|
|
TIntermTyped* handleDotSwizzle(const TSourceLoc&, TIntermTyped* base, const TString& field);
|
|
void blockMemberExtensionCheck(const TSourceLoc&, const TIntermTyped* base, int member, const TString& memberName);
|
|
TFunction* handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype);
|
|
TIntermAggregate* handleFunctionDefinition(const TSourceLoc&, TFunction&);
|
|
TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermNode*);
|
|
TIntermTyped* handleBuiltInFunctionCall(TSourceLoc, TIntermNode* arguments, const TFunction& function);
|
|
void computeBuiltinPrecisions(TIntermTyped&, const TFunction&);
|
|
TIntermNode* handleReturnValue(const TSourceLoc&, TIntermTyped*);
|
|
void checkLocation(const TSourceLoc&, TOperator);
|
|
TIntermTyped* handleLengthMethod(const TSourceLoc&, TFunction*, TIntermNode*);
|
|
void addInputArgumentConversions(const TFunction&, TIntermNode*&) const;
|
|
TIntermTyped* addOutputArgumentConversions(const TFunction&, TIntermAggregate&) const;
|
|
void builtInOpCheck(const TSourceLoc&, const TFunction&, TIntermOperator&);
|
|
void nonOpBuiltInCheck(const TSourceLoc&, const TFunction&, TIntermAggregate&);
|
|
void userFunctionCallCheck(const TSourceLoc&, TIntermAggregate&);
|
|
void samplerConstructorLocationCheck(const TSourceLoc&, const char* token, TIntermNode*);
|
|
TFunction* handleConstructorCall(const TSourceLoc&, const TPublicType&);
|
|
void handlePrecisionQualifier(const TSourceLoc&, TQualifier&, TPrecisionQualifier);
|
|
void checkPrecisionQualifier(const TSourceLoc&, TPrecisionQualifier);
|
|
void memorySemanticsCheck(const TSourceLoc&, const TFunction&, const TIntermOperator& callNode);
|
|
|
|
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*) override;
|
|
void rValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*) override;
|
|
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&);
|
|
bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&);
|
|
void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&, const char *sizeType);
|
|
bool arrayQualifierError(const TSourceLoc&, const TQualifier&);
|
|
bool arrayError(const TSourceLoc&, const TType&);
|
|
void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&);
|
|
void structArrayCheck(const TSourceLoc&, const TType& structure);
|
|
void arraySizesCheck(const TSourceLoc&, const TQualifier&, TArraySizes*, const TIntermTyped* initializer, bool lastMember);
|
|
void arrayOfArrayVersionCheck(const TSourceLoc&, const 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, TIntermTyped* initializer);
|
|
void atomicUintCheck(const TSourceLoc&, const TType&, const TString& identifier);
|
|
void accStructCheck(const TSourceLoc & loc, const TType & type, const TString & identifier);
|
|
void transparentOpaqueCheck(const TSourceLoc&, const TType&, const TString& identifier);
|
|
void memberQualifierCheck(glslang::TPublicType&);
|
|
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&);
|
|
void redeclareBuiltinBlock(const TSourceLoc&, TTypeList& typeList, const TString& blockName, const TString* instanceName, TArraySizes* arraySizes);
|
|
void paramCheckFixStorage(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 referenceCheck(const TSourceLoc&, const TType&, const char* op);
|
|
void storage16BitAssignmentCheck(const TSourceLoc&, const TType&, const char* op);
|
|
void specializationCheck(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 layoutMemberLocationArrayCheck(const TSourceLoc&, bool memberWithLocation, TArraySizes* arraySizes);
|
|
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);
|
|
const TFunction* findFunctionExplicitTypes(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&);
|
|
TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&);
|
|
TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset);
|
|
void inheritMemoryQualifiers(const TQualifier& from, TQualifier& to);
|
|
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&, bool instanceName);
|
|
void fixBlockLocations(const TSourceLoc&, TQualifier&, TTypeList&, bool memberWithLocation, bool memberWithoutLocation);
|
|
void fixXfbOffsets(TQualifier&, TTypeList&);
|
|
void fixBlockUniformOffsets(TQualifier&, TTypeList&);
|
|
void fixBlockUniformLayoutMatrix(TQualifier&, TTypeList*, TTypeList*);
|
|
void fixBlockUniformLayoutPacking(TQualifier&, TTypeList*, 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);
|
|
const TTypeList* recordStructCopy(TStructRecord&, const TType*, const TType*);
|
|
|
|
#ifndef GLSLANG_WEB
|
|
TAttributeType attributeFromName(const TString& name) const;
|
|
TAttributes* makeAttributes(const TString& identifier) const;
|
|
TAttributes* makeAttributes(const TString& identifier, TIntermNode* node) const;
|
|
TAttributes* mergeAttributes(TAttributes*, TAttributes*) const;
|
|
|
|
// Determine selection control from attributes
|
|
void handleSelectionAttributes(const TAttributes& attributes, TIntermNode*);
|
|
void handleSwitchAttributes(const TAttributes& attributes, TIntermNode*);
|
|
// Determine loop control from attributes
|
|
void handleLoopAttributes(const TAttributes& attributes, TIntermNode*);
|
|
#endif
|
|
|
|
void checkAndResizeMeshViewDim(const TSourceLoc&, TType&, bool isBlockMember);
|
|
|
|
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&, const TString& identifier, const TType&);
|
|
void declareArray(const TSourceLoc&, const TString& identifier, const TType&, TSymbol*&);
|
|
void checkRuntimeSizable(const TSourceLoc&, const TIntermTyped&);
|
|
bool isRuntimeLength(const TIntermTyped&) const;
|
|
TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable);
|
|
TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer);
|
|
#ifndef GLSLANG_WEB
|
|
void finish() override;
|
|
#endif
|
|
|
|
public:
|
|
//
|
|
// Generally, bison productions, the scanner, and the PP need read/write access to these; just give them direct access
|
|
//
|
|
|
|
// Current state of parsing
|
|
bool inMain; // if inside a function, true if the function is main
|
|
const TString* blockName;
|
|
TQualifier currentBlockQualifier;
|
|
TPrecisionQualifier defaultPrecision[EbtNumTypes];
|
|
TBuiltInResource resources;
|
|
TLimits& limits;
|
|
|
|
protected:
|
|
TParseContext(TParseContext&);
|
|
TParseContext& operator=(TParseContext&);
|
|
|
|
static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2 * 2 * 2 * 2)); // see computeSamplerTypeIndex()
|
|
TPrecisionQualifier defaultSamplerPrecision[maxSamplerIndex];
|
|
TPrecisionManager precisionManager;
|
|
TQualifier globalBufferDefaults;
|
|
TQualifier globalUniformDefaults;
|
|
TQualifier globalInputDefaults;
|
|
TQualifier globalOutputDefaults;
|
|
TString currentCaller; // name of last function body entered (not valid when at global scope)
|
|
#ifndef GLSLANG_WEB
|
|
int* atomicUintOffsets; // to become an array of the right size to hold an offset per binding point
|
|
bool anyIndexLimits;
|
|
TIdSetType inductiveLoopIds;
|
|
TVector<TIntermTyped*> needsIndexLimitationChecking;
|
|
TStructRecord matrixFixRecord;
|
|
TStructRecord packingFixRecord;
|
|
|
|
//
|
|
// 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;
|
|
#endif
|
|
};
|
|
|
|
} // end namespace glslang
|
|
|
|
#endif // _PARSER_HELPER_INCLUDED_
|