Builder::LoopBlocks& Builder::makeNewLoop()
{
- // Older MSVC versions don't allow inlining of blocks below.
- LoopBlocks blocks = {makeNewBlock(), makeNewBlock(), makeNewBlock(), makeNewBlock()};
+ // This verbosity is needed to simultaneously get the same behavior
+ // 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();
}
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
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) {
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;
};
TString getCompleteString() const { return type.getCompleteString(); }
protected:
+ TIntermTyped& operator=(const TIntermTyped&);
TType type;
};
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
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
};
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;
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;
}
private:
+ TokenizableIncludeFile& operator=(const TokenizableIncludeFile&);
+
// Stores the prologue for this string.
const std::string prologue_;
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_;
}
protected:
+ TNoContractionAssigneeCheckingTraverser& operator=(const TNoContractionAssigneeCheckingTraverser&);
+
bool visitBinary(glslang::TVisit, glslang::TIntermBinary* node) override;
void visitSymbol(glslang::TIntermSymbol* node) override;
}
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
// 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
// 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;
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,
public:
IncludeResult* include(const char*, IncludeType, const char*, size_t) override
{
- static const char unexpected_include[] =
- "unexpected include directive";
- static const IncludeResult unexpectedIncludeResult =
- {"", unexpected_include, sizeof(unexpected_include) - 1, nullptr};
- return new IncludeResult(unexpectedIncludeResult);
+ const char* unexpected_include = "unexpected include directive";
+ return new IncludeResult(std::string(""), unexpected_include, strlen(unexpected_include), nullptr);
}
virtual void releaseInclude(IncludeResult* result) override
{
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>());
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);
bool parse();
protected:
+ HlslGrammar();
+ HlslGrammar& operator=(const HlslGrammar&);
+
void expected(const char*);
bool acceptIdentifier(HlslToken&);
bool acceptCompilationUnit();
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?
}
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);
if (arguments) {
// Make sure qualifications work for these arguments.
- TIntermAggregate* aggregate = arguments->getAsAggregate();
- for (int i = 0; i < fnCandidate->getParamCount(); ++i) {
- // 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
- // means take 'arguments' itself as the one argument.
- TIntermNode* arg = fnCandidate->getParamCount() == 1 ? arguments : (aggregate ? aggregate->getSequence()[i] : arguments);
- TQualifier& formalQualifier = (*fnCandidate)[i].type->getQualifier();
- TQualifier& argQualifier = arg->getAsTyped()->getQualifier();
- }
+ //TIntermAggregate* aggregate = arguments->getAsAggregate();
+ //for (int i = 0; i < fnCandidate->getParamCount(); ++i) {
+ // // 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
+ // // means take 'arguments' itself as the one argument.
+ // TIntermNode* arg = fnCandidate->getParamCount() == 1 ? arguments : (aggregate ? aggregate->getSequence()[i] : arguments);
+ // TQualifier& formalQualifier = (*fnCandidate)[i].type->getQualifier();
+ // TQualifier& argQualifier = arg->getAsTyped()->getQualifier();
+ //}
// Convert 'in' arguments
addInputArgumentConversions(*fnCandidate, arguments); // arguments may be modified if it's just a single argument node
}
-bool HlslParseContext::builtInName(const TString& identifier)
+bool HlslParseContext::builtInName(const TString& /*identifier*/)
{
return false;
}
//
// 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());
return true;
}
- TIntermTyped* typed = node->getAsTyped();
+ // TIntermTyped* typed = node->getAsTyped();
return false;
}
//
// 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) {
//
// 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;
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();
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;
}
//
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(), "");
{
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);
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) { }
- bool lineContinuationCheck(const TSourceLoc&, bool endOfComment) { return true; }
+ void reservedPpErrorCheck(const TSourceLoc&, const char* /*name*/, const char* /*op*/) { }
+ bool lineContinuationCheck(const TSourceLoc&, bool /*endOfComment*/) { return true; }
bool lineDirectiveShouldSetNextLine() const { return true; }
bool builtInName(const TString&);
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;
}
}
// 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';
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));
// 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);
// add stage-specific entries to the commonBuiltins, and only if that stage
// was requested.
//
-void TBuiltInParseablesHlsl::initialize(const TBuiltInResource &resources, int version, EProfile profile,
- const SpvVersion& spvVersion, EShLanguage language)
+void TBuiltInParseablesHlsl::initialize(const TBuiltInResource& /*resources*/, int /*version*/, EProfile /*profile*/,
+ const SpvVersion& /*spvVersion*/, EShLanguage /*language*/)
{
}
// 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);
// 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,
- TSymbolTable& symbolTable, const TBuiltInResource &resources)
+void TBuiltInParseablesHlsl::identifyBuiltIns(int /*version*/, EProfile /*profile*/, const SpvVersion& /*spvVersion*/, EShLanguage /*language*/,
+ TSymbolTable& /*symbolTable*/, const TBuiltInResource& /*resources*/)
{
}
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,
projects / platform / upstream / glslang.git / commitdiff