Build: Remove causes of pedantic warnings. Addresses issue #352 and PR #242.

SPIRV/SpvBuilder.cpp

@@ -2045,8 +2045,15 @@ Block& Builder::makeNewBlock()
 
 Builder::LoopBlocks& Builder::makeNewLoop()
 {
-    // Older MSVC versions don't allow inlining of blocks below.
+    // This verbosity is needed to simultaneously get the same behavior
-    LoopBlocks blocks = {makeNewBlock(), makeNewBlock(), makeNewBlock(), makeNewBlock()};
+    // everywhere (id's in the same order), have a syntax that works
+    // across lots of versions of C++, have no warnings from pedantic
+    // compilation modes, and leave the rest of the code alone.
+    Block& head            = makeNewBlock();
+    Block& body            = makeNewBlock();
+    Block& merge           = makeNewBlock();
+    Block& continue_target = makeNewBlock();
+    LoopBlocks blocks(head, body, merge, continue_target);
     loops.push(blocks);
     return loops.top();
 }

SPIRV/SpvBuilder.h

@@ -397,7 +397,12 @@ public:
     void endSwitch(std::vector<Block*>& segmentBB);
 
     struct LoopBlocks {
+        LoopBlocks(Block& head, Block& body, Block& merge, Block& continue_target) :
+            head(head), body(body), merge(merge), continue_target(continue_target) { }
         Block &head, &body, &merge, &continue_target;
+    private:
+        LoopBlocks();
+        LoopBlocks& operator=(const LoopBlocks&);
     };
 
     // Start a new loop and prepare the builder to generate code for it.  Until

StandAlone/ResourceLimits.cpp

@@ -238,7 +238,8 @@ std::string GetDefaultTBuiltInResourceString()
     return ostream.str();
 }
 
-void DecodeResourceLimits(TBuiltInResource* resources, char* config) {
+void DecodeResourceLimits(TBuiltInResource* resources, char* config)
+{
     const char* delims = " \t\n\r";
     const char* token = strtok(config, delims);
     while (token) {

glslang/Include/intermediate.h

@@ -579,7 +579,10 @@ public:
     virtual const glslang::TIntermSymbol*        getAsSymbolNode()    const { return 0; }
     virtual const glslang::TIntermBranch*        getAsBranchNode()    const { return 0; }
     virtual ~TIntermNode() { }
+
 protected:
+    TIntermNode(const TIntermNode&);
+    TIntermNode& operator=(const TIntermNode&);
     glslang::TSourceLoc loc;
 };
 
@@ -621,6 +624,7 @@ public:
     TString getCompleteString() const { return type.getCompleteString(); }
 
 protected:
+    TIntermTyped& operator=(const TIntermTyped&);
     TType type;
 };
 
@@ -702,6 +706,7 @@ public:
     const TConstUnionArray& getConstArray() const { return constArray; }
     void setConstSubtree(TIntermTyped* subtree) { constSubtree = subtree; }
     TIntermTyped* getConstSubtree() const { return constSubtree; }
+
 protected:
     int id;                      // the unique id of the symbol this node represents
     TString name;                // the name of the symbol this node represents
@@ -721,7 +726,10 @@ public:
     void setLiteral() { literal = true; }
     void setExpression() { literal = false; }
     bool isLiteral() const { return literal; }
+
 protected:
+    TIntermConstantUnion& operator=(const TIntermConstantUnion&);
+
     const TConstUnionArray constArray;
     bool literal;  // true if node represents a literal in the source code
 };

glslang/MachineIndependent/Scan.h

@@ -173,7 +173,7 @@ public:
         loc[getLastValidSourceIndex()].name = filename;
     }
 
-    void setFile(const char* filename, size_t i)
+    void setFile(const char* filename, int i)
     {
         if (i == getLastValidSourceIndex()) {
             logicalSourceLoc.name = filename;

glslang/MachineIndependent/ShaderLang.cpp

@@ -783,6 +783,8 @@ public:
     void setLineNum(int newLineNum) { lastLine = newLineNum; }
 
 private:
+    SourceLineSynchronizer& operator=(const SourceLineSynchronizer&);
+
     // A function for getting the index of the last valid source string we've
     // read tokens from.
     const std::function<int()> getLastSourceIndex;

glslang/MachineIndependent/preprocessor/PpContext.h

@@ -487,6 +487,8 @@ protected:
         }
 
     private:
+        TokenizableIncludeFile& operator=(const TokenizableIncludeFile&);
+
         // Stores the prologue for this string.
         const std::string prologue_;
 

glslang/MachineIndependent/propagateNoContraction.cpp

@@ -244,6 +244,8 @@ public:
     bool visitBranch(glslang::TVisit, glslang::TIntermBranch*) override;
 
 protected:
+    TSymbolDefinitionCollectingTraverser& operator=(const TSymbolDefinitionCollectingTraverser&);
+
     // The mapping from symbol node IDs to their defining nodes. This should be
     // populated along traversing the AST.
     NodeMapping& symbol_definition_mapping_;
@@ -548,6 +550,8 @@ public:
     }
 
 protected:
+    TNoContractionAssigneeCheckingTraverser& operator=(const TNoContractionAssigneeCheckingTraverser&);
+
     bool visitBinary(glslang::TVisit, glslang::TIntermBinary* node) override;
     void visitSymbol(glslang::TIntermSymbol* node) override;
 
@@ -648,6 +652,8 @@ public:
     }
 
 protected:
+    TNoContractionPropagator& operator=(const TNoContractionPropagator&);
+
     // Visits an aggregate node. The node can be a initializer list, in which
     // case we need to find the 'precise' or 'precise' containing object node
     // with the access chain record. In other cases, just need to traverse all

glslang/Public/ShaderLang.h

@@ -307,7 +307,7 @@ public:
     // 2. Call parse with an Includer.
     //
     // When the Glslang parser encounters an #include directive, it calls
-    // the Includer's include method with the the requested include name
+    // the Includer's include method with the requested include name
     // together with the current string name.  The returned IncludeResult
     // contains the fully resolved name of the included source, together
     // with the source text that should replace the #include directive
@@ -323,8 +323,10 @@ public:
         // An IncludeResult contains the resolved name and content of a source
         // inclusion.
         struct IncludeResult {
+            IncludeResult(const std::string& file_name, const char* const file_data, const size_t file_length, void* user_data) :
+                file_name(file_name), file_data(file_data), file_length(file_length), user_data(user_data) { }
             // For a successful inclusion, the fully resolved name of the requested
-            // include.  For example, in a filesystem-based includer, full resolution
+            // include.  For example, in a file system-based includer, full resolution
             // should convert a relative path name into an absolute path name.
             // For a failed inclusion, this is an empty string.
             const std::string file_name;
@@ -337,6 +339,9 @@ public:
             const size_t file_length;
             // Include resolver's context.
             void* user_data;
+        protected:
+            IncludeResult& operator=(const IncludeResult&);
+            IncludeResult();
         };
 
         // Resolves an inclusion request by name, type, current source name,
@@ -365,11 +370,8 @@ public:
     public:
         IncludeResult* include(const char*, IncludeType, const char*, size_t) override
         {
-            static const char unexpected_include[] =
+            const char* unexpected_include = "unexpected include directive";
-                "unexpected include directive";
+            return new IncludeResult(std::string(""), unexpected_include, strlen(unexpected_include), nullptr);
-            static const IncludeResult unexpectedIncludeResult =
-                {"", unexpected_include, sizeof(unexpected_include) - 1, nullptr};
-            return new IncludeResult(unexpectedIncludeResult);
         }
         virtual void releaseInclude(IncludeResult* result) override
         {

gtests/TestFixture.cpp

@@ -107,7 +107,7 @@ std::pair<bool, std::string> ReadFile(const std::string& path)
     if (fstream) {
         std::string contents;
         fstream.seekg(0, std::ios::end);
-        contents.reserve(fstream.tellg());
+        contents.reserve((std::string::size_type)fstream.tellg());
         fstream.seekg(0, std::ios::beg);
         contents.assign((std::istreambuf_iterator<char>(fstream)),
                         std::istreambuf_iterator<char>());

gtests/TestFixture.h

@@ -180,8 +180,7 @@ public:
         shader->setStringsWithLengths(&shaderStrings, &shaderLengths, 1);
         if (!entryPointName.empty()) shader->setEntryPoint(entryPointName.c_str());
         // Reinitialize glslang if the semantics change.
-        GlslangInitializer::InitializationToken token =
+        GlobalTestSettings.initializer->acquire(controls);
-            GlobalTestSettings.initializer->acquire(controls);
         return shader->parse(
                 (resources ? resources : &glslang::DefaultTBuiltInResource),
                 defaultVersion, isForwardCompatible, controls);

hlsl/hlslGrammar.h

@@ -55,6 +55,9 @@ namespace glslang {
         bool parse();
 
     protected:
+        HlslGrammar();
+        HlslGrammar& operator=(const HlslGrammar&);
+
         void expected(const char*);
         bool acceptIdentifier(HlslToken&);
         bool acceptCompilationUnit();

hlsl/hlslParseHelper.cpp

@@ -409,7 +409,7 @@ TIntermTyped* HlslParseContext::handleBracketDereference(const TSourceLoc& loc,
     return result;
 }
 
-void HlslParseContext::checkIndex(const TSourceLoc& loc, const TType& type, int& index)
+void HlslParseContext::checkIndex(const TSourceLoc& /*loc*/, const TType& /*type*/, int& /*index*/)
 {
     // HLSL todo: any rules for index fixups?
 }
@@ -527,7 +527,7 @@ int HlslParseContext::getIoArrayImplicitSize() const
         return 0;
 }
 
-void HlslParseContext::checkIoArrayConsistency(const TSourceLoc& loc, int requiredSize, const char* feature, TType& type, const TString& name)
+void HlslParseContext::checkIoArrayConsistency(const TSourceLoc& /*loc*/, int requiredSize, const char* /*feature*/, TType& type, const TString& /*name*/)
 {
     if (type.isImplicitlySizedArray())
         type.changeOuterArraySize(requiredSize);
@@ -1254,15 +1254,15 @@ TIntermTyped* HlslParseContext::handleFunctionCall(const TSourceLoc& loc, TFunct
 
             if (arguments) {
                 // Make sure qualifications work for these arguments.
-                TIntermAggregate* aggregate = arguments->getAsAggregate();
+                //TIntermAggregate* aggregate = arguments->getAsAggregate();
-                for (int i = 0; i < fnCandidate->getParamCount(); ++i) {
+                //for (int i = 0; i < fnCandidate->getParamCount(); ++i) {
-                    // At this early point there is a slight ambiguity between whether an aggregate 'arguments'
+                //    // At this early point there is a slight ambiguity between whether an aggregate 'arguments'
-                    // is the single argument itself or its children are the arguments.  Only one argument
+                //    // is the single argument itself or its children are the arguments.  Only one argument
-                    // means take 'arguments' itself as the one argument.
+                //    // means take 'arguments' itself as the one argument.
-                    TIntermNode* arg = fnCandidate->getParamCount() == 1 ? arguments : (aggregate ? aggregate->getSequence()[i] : arguments);
+                //    TIntermNode* arg = fnCandidate->getParamCount() == 1 ? arguments : (aggregate ? aggregate->getSequence()[i] : arguments);
-                    TQualifier& formalQualifier = (*fnCandidate)[i].type->getQualifier();
+                //    TQualifier& formalQualifier = (*fnCandidate)[i].type->getQualifier();
-                    TQualifier& argQualifier = arg->getAsTyped()->getQualifier();
+                //    TQualifier& argQualifier = arg->getAsTyped()->getQualifier();
-                }
+                //}
 
                 // Convert 'in' arguments
                 addInputArgumentConversions(*fnCandidate, arguments);  // arguments may be modified if it's just a single argument node
@@ -1895,7 +1895,7 @@ void HlslParseContext::globalCheck(const TSourceLoc& loc, const char* token)
 }
 
 
-bool HlslParseContext::builtInName(const TString& identifier)
+bool HlslParseContext::builtInName(const TString& /*identifier*/)
 {
     return false;
 }
@@ -1907,7 +1907,8 @@ bool HlslParseContext::builtInName(const TString& identifier)
 //
 // Returns true if there was an error in construction.
 //
-bool HlslParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, TFunction& function, TOperator op, TType& type)
+bool HlslParseContext::constructorError(const TSourceLoc& loc, TIntermNode* /*node*/, TFunction& function,
+                                        TOperator op, TType& type)
 {
     type.shallowCopy(function.getType());
 
@@ -2043,7 +2044,7 @@ bool HlslParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node
         return true;
     }
 
-    TIntermTyped* typed = node->getAsTyped();
+    // TIntermTyped* typed = node->getAsTyped();
 
     return false;
 }
@@ -2132,7 +2133,7 @@ void HlslParseContext::boolCheck(const TSourceLoc& loc, const TIntermTyped* type
 //
 // Fix just a full qualifier (no variables or types yet, but qualifier is complete) at global level.
 //
-void HlslParseContext::globalQualifierFix(const TSourceLoc& loc, TQualifier& qualifier)
+void HlslParseContext::globalQualifierFix(const TSourceLoc&, TQualifier& qualifier)
 {
     // move from parameter/unknown qualifiers to pipeline in/out qualifiers
     switch (qualifier.storage) {
@@ -2398,7 +2399,9 @@ void HlslParseContext::updateImplicitArraySize(const TSourceLoc& loc, TIntermNod
 //
 // Returns a redeclared and type-modified variable if a redeclared occurred.
 //
-TSymbol* HlslParseContext::redeclareBuiltinVariable(const TSourceLoc& loc, const TString& identifier, const TQualifier& qualifier, const TShaderQualifiers& publicType, bool& newDeclaration)
+TSymbol* HlslParseContext::redeclareBuiltinVariable(const TSourceLoc& /*loc*/, const TString& identifier,
+                                                    const TQualifier& /*qualifier*/,
+                                                    const TShaderQualifiers& /*publicType*/, bool& /*newDeclaration*/)
 {
     if (! builtInName(identifier) || symbolTable.atBuiltInLevel() || ! symbolTable.atGlobalLevel())
         return nullptr;
@@ -2698,7 +2701,7 @@ void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& pu
 void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publicType, TString& id, const TIntermTyped* node)
 {
     const char* feature = "layout-id value";
-    const char* nonLiteralFeature = "non-literal layout-id value";
+    //const char* nonLiteralFeature = "non-literal layout-id value";
 
     integerCheck(node, feature);
     const TIntermConstantUnion* constUnion = node->getAsConstantUnion();
@@ -2838,7 +2841,6 @@ void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& pu
 
     case EShLangFragment:
         if (id == "index") {
-            const char* exts[2] = { E_GL_ARB_separate_shader_objects, E_GL_ARB_explicit_attrib_location };
             publicType.qualifier.layoutIndex = value;
             return;
         }
@@ -2953,7 +2955,7 @@ void HlslParseContext::mergeObjectLayoutQualifiers(TQualifier& dst, const TQuali
 //
 const TFunction* HlslParseContext::findFunction(const TSourceLoc& loc, const TFunction& call, bool& builtIn)
 {
-    const TFunction* function = nullptr;
+    // const TFunction* function = nullptr;
 
     if (symbolTable.isFunctionNameVariable(call.getName())) {
         error(loc, "can't use function syntax on variable", call.getName().c_str(), "");
@@ -3866,7 +3868,7 @@ void HlslParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc,
 {
     if (publicType.shaderQualifiers.vertices != TQualifier::layoutNotSet) {
         assert(language == EShLangTessControl || language == EShLangGeometry);
-        const char* id = (language == EShLangTessControl) ? "vertices" : "max_vertices";
+        // const char* id = (language == EShLangTessControl) ? "vertices" : "max_vertices";
 
         if (language == EShLangTessControl)
             checkIoArraysConsistency(loc);

hlsl/hlslParseHelper.h

@@ -60,8 +60,8 @@ public:
     void C_DECL ppWarn(const TSourceLoc&, const char* szReason, const char* szToken,
         const char* szExtraInfoFormat, ...);
 
-    void reservedPpErrorCheck(const TSourceLoc&, const char* name, const char* op) { }
+    void reservedPpErrorCheck(const TSourceLoc&, const char* /*name*/, const char* /*op*/) { }
-    bool lineContinuationCheck(const TSourceLoc&, bool endOfComment) { return true; }
+    bool lineContinuationCheck(const TSourceLoc&, bool /*endOfComment*/) { return true; }
     bool lineDirectiveShouldSetNextLine() const { return true; }
     bool builtInName(const TString&);
 

hlsl/hlslParseables.cpp

@@ -136,12 +136,14 @@ glslang::TString& AppendTypeName(glslang::TString& s, const char* argOrder, cons
     switch (*argOrder) {
     case '-': break;  // no dimensions for voids
     case 'S': break;  // no dimensions on scalars
-    case 'V': s += ('0' + dim0); break;
+    case 'V': s += ('0' + (char)dim0); break;
     case 'M': 
         {
             if (!UseHlslTypes)  // GLSL has column first for mat types
                 std::swap(dim0, dim1);
-            s += ('0' + dim0); s += 'x'; s += ('0' + dim1);
+            s += ('0' + (char)dim0);
+            s += 'x';
+            s += ('0' + (char)dim1);
             break;
         }
     }
@@ -152,7 +154,7 @@ glslang::TString& AppendTypeName(glslang::TString& s, const char* argOrder, cons
 // TODO: the GLSL parser is currently used to parse HLSL prototypes.  However, many valid HLSL prototypes
 // are not valid GLSL prototypes.  This rejects the invalid ones.  Thus, there is a single switch below
 // to enable creation of the entire HLSL space.
-inline bool IsValidGlsl(const char* cname, char retOrder, char retType, char argOrder, char argType,
+inline bool IsValidGlsl(const char* cname, char retOrder, char retType, char /*argOrder*/, char argType,
                         int dim0, int dim1, int dim0Max, int dim1Max)
 {
     const bool isVec = dim0Max > 1 || argType == 'V';
@@ -208,7 +210,7 @@ inline const char* NthArg(const char* arg, int n)
     return arg;
 }
 
-inline void FindVectorMatrixBounds(const char* argOrder, int fixedVecSize, int& dim0Min, int& dim0Max, int& dim1Min, int& dim1Max)
+inline void FindVectorMatrixBounds(const char* argOrder, int fixedVecSize, int& dim0Min, int& dim0Max, int& /*dim1Min*/, int& dim1Max)
 {
     for (int arg = 0; ; ++arg) {
         const char* nthArgOrder(NthArg(argOrder, arg));
@@ -273,7 +275,7 @@ void TBuiltInParseablesHlsl::createMatTimesMat()
 // Most built-ins variables can be added as simple text strings.  Some need to
 // be added programmatically, which is done later in IdentifyBuiltIns() below.
 //
-void TBuiltInParseablesHlsl::initialize(int version, EProfile profile, const SpvVersion& spvVersion)
+void TBuiltInParseablesHlsl::initialize(int /*version*/, EProfile /*profile*/, const SpvVersion& /*spvVersion*/)
 {
     static const EShLanguageMask EShLangAll = EShLanguageMask(EShLangCount - 1);
 
@@ -556,8 +558,8 @@ void TBuiltInParseablesHlsl::initialize(int version, EProfile profile, const Spv
 // add stage-specific entries to the commonBuiltins, and only if that stage
 // was requested.
 //
-void TBuiltInParseablesHlsl::initialize(const TBuiltInResource &resources, int version, EProfile profile,
+void TBuiltInParseablesHlsl::initialize(const TBuiltInResource& /*resources*/, int /*version*/, EProfile /*profile*/,
-                                        const SpvVersion& spvVersion, EShLanguage language)
+                                        const SpvVersion& /*spvVersion*/, EShLanguage /*language*/)
 {
 }
 
@@ -570,7 +572,7 @@ void TBuiltInParseablesHlsl::initialize(const TBuiltInResource &resources, int v
 // 3) Tag extension-related symbols added to their base version with their extensions, so
 //    that if an early version has the extension turned off, there is an error reported on use.
 //
-void TBuiltInParseablesHlsl::identifyBuiltIns(int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language,
+void TBuiltInParseablesHlsl::identifyBuiltIns(int /*version*/, EProfile /*profile*/, const SpvVersion& /*spvVersion*/, EShLanguage /*language*/,
                                               TSymbolTable& symbolTable)
 {
     // symbolTable.relateToOperator("abort",                       EOpAbort);
@@ -719,8 +721,8 @@ void TBuiltInParseablesHlsl::identifyBuiltIns(int version, EProfile profile, con
 // 2) Tag extension-related symbols added to their base version with their extensions, so
 //    that if an early version has the extension turned off, there is an error reported on use.
 //
-void TBuiltInParseablesHlsl::identifyBuiltIns(int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language,
+void TBuiltInParseablesHlsl::identifyBuiltIns(int /*version*/, EProfile /*profile*/, const SpvVersion& /*spvVersion*/, EShLanguage /*language*/,
-                                              TSymbolTable& symbolTable, const TBuiltInResource &resources)
+                                              TSymbolTable& /*symbolTable*/, const TBuiltInResource& /*resources*/)
 {
 }
 

hlsl/hlslTokenStream.h

@@ -57,6 +57,9 @@ namespace glslang {
         HlslToken token;                  // the token we are currently looking at, but have not yet accepted
 
     private:
+        HlslTokenStream();
+        HlslTokenStream& operator=(const HlslTokenStream&);
+
         HlslScanContext& scanner;         // lexical scanner, to get next token
 
         // Previously scanned tokens, returned for future advances,