text: //
  // 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),
              currentFunctionType(nullptr),
              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;
      TIntermTyped* addAssign(const TSourceLoc&, TOperator op, TIntermTyped* left, TIntermTyped* right);
      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_
  