From: John Kessenich Date: Fri, 28 Jul 2017 22:20:13 +0000 (-0600) Subject: Nonfunctional: Shorten some lines to the coding standard, to retrigger failed test... X-Git-Tag: upstream/11.4.0~1060 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=2ceec68109d90dcb3e3e9360a43cb0376ca2116b;p=platform%2Fupstream%2Fglslang.git Nonfunctional: Shorten some lines to the coding standard, to retrigger failed test run. --- diff --git a/hlsl/hlslParseHelper.cpp b/hlsl/hlslParseHelper.cpp index 561a529..84d0fdc 100755 --- a/hlsl/hlslParseHelper.cpp +++ b/hlsl/hlslParseHelper.cpp @@ -53,10 +53,12 @@ namespace glslang { HlslParseContext::HlslParseContext(TSymbolTable& symbolTable, TIntermediate& interm, bool parsingBuiltins, - int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language, TInfoSink& infoSink, + int version, EProfile profile, const SpvVersion& spvVersion, EShLanguage language, + TInfoSink& infoSink, const TString sourceEntryPointName, bool forwardCompatible, EShMessages messages) : - TParseContextBase(symbolTable, interm, parsingBuiltins, version, profile, spvVersion, language, infoSink, forwardCompatible, messages), + TParseContextBase(symbolTable, interm, parsingBuiltins, version, profile, spvVersion, language, infoSink, + forwardCompatible, messages), annotationNestingLevel(0), inputPatch(nullptr), builtInIoIndex(nullptr), @@ -133,7 +135,8 @@ bool HlslParseContext::parseShaderStrings(TPpContext& ppContext, TInputScanner& // Print a message formated such that if you click on the message it will take you right to // the line through most UIs. const glslang::TSourceLoc& sourceLoc = input.getSourceLoc(); - infoSink.info << sourceLoc.name << "(" << sourceLoc.line << "): error at column " << sourceLoc.column << ", HLSL parsing failed.\n"; + infoSink.info << sourceLoc.name << "(" << sourceLoc.line << "): error at column " << sourceLoc.column + << ", HLSL parsing failed.\n"; ++numErrors; return false; } @@ -170,7 +173,8 @@ bool HlslParseContext::shouldConvertLValue(const TIntermNode* node) const return false; } -void HlslParseContext::growGlobalUniformBlock(const TSourceLoc& loc, TType& memberType, const TString& memberName, TTypeList* newTypeList) +void HlslParseContext::growGlobalUniformBlock(const TSourceLoc& loc, TType& memberType, const TString& memberName, + TTypeList* newTypeList) { newTypeList = nullptr; correctUniform(memberType.getQualifier()); @@ -395,12 +399,13 @@ TIntermTyped* HlslParseContext::handleLvalue(const TSourceLoc& loc, const char* // fall through... case EOpAssign: { - // Since this is an lvalue, we'll convert an image load to a sequence like this (to still provide the value): + // Since this is an lvalue, we'll convert an image load to a sequence like this + // (to still provide the value): // OpSequence // OpImageStore(object, lhs, rhs) // rhs - // But if it's not a simple symbol RHS (say, a fn call), we don't want to duplicate the RHS, so we'll convert - // instead to this: + // But if it's not a simple symbol RHS (say, a fn call), we don't want to duplicate the RHS, + // so we'll convert instead to this: // OpSequence // rhsTmp = rhs // OpImageStore(object, coord, rhsTmp) @@ -828,7 +833,8 @@ TIntermTyped* HlslParseContext::handleBracketDereference(const TSourceLoc& loc, variableCheck(base); if (! base->isArray() && ! base->isMatrix() && ! base->isVector()) { if (base->getAsSymbolNode()) - error(loc, " left of '[' is not of type array, matrix, or vector ", base->getAsSymbolNode()->getName().c_str(), ""); + error(loc, " left of '[' is not of type array, matrix, or vector ", + base->getAsSymbolNode()->getName().c_str(), ""); else error(loc, " left of '[' is not of type array, matrix, or vector ", "expression", ""); } else if (base->getType().getQualifier().storage == EvqConst && index->getQualifier().storage == EvqConst) @@ -882,7 +888,8 @@ void HlslParseContext::checkIndex(const TSourceLoc& /*loc*/, const TType& /*type } // Handle seeing a binary node with a math operation. -TIntermTyped* HlslParseContext::handleBinaryMath(const TSourceLoc& loc, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right) +TIntermTyped* HlslParseContext::handleBinaryMath(const TSourceLoc& loc, const char* str, TOperator op, + TIntermTyped* left, TIntermTyped* right) { TIntermTyped* result = intermediate.addBinaryMath(op, left, right, loc); if (result == nullptr) @@ -892,7 +899,8 @@ TIntermTyped* HlslParseContext::handleBinaryMath(const TSourceLoc& loc, const ch } // Handle seeing a unary node with a math operation. -TIntermTyped* HlslParseContext::handleUnaryMath(const TSourceLoc& loc, const char* str, TOperator op, TIntermTyped* childNode) +TIntermTyped* HlslParseContext::handleUnaryMath(const TSourceLoc& loc, const char* str, TOperator op, + TIntermTyped* childNode) { TIntermTyped* result = intermediate.addUnaryMath(op, childNode, loc); @@ -957,9 +965,11 @@ TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TInt // Keep 'result' pointing to 'base', since we expect an operator[] to go by next. } else { if (field == "mips") - error(loc, "unexpected texture type for .mips[][] operator:", base->getType().getCompleteString().c_str(), ""); + error(loc, "unexpected texture type for .mips[][] operator:", + base->getType().getCompleteString().c_str(), ""); else - error(loc, "unexpected operator on texture type:", field.c_str(), base->getType().getCompleteString().c_str()); + error(loc, "unexpected operator on texture type:", field.c_str(), + base->getType().getCompleteString().c_str()); } } else if (base->isVector() || base->isScalar()) { TSwizzleSelectors selectors; @@ -993,7 +1003,8 @@ TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TInt } else { TIntermTyped* index = intermediate.addSwizzle(selectors, loc); result = intermediate.addIndex(EOpVectorSwizzle, base, index, loc); - result->setType(TType(base->getBasicType(), EvqTemporary, base->getType().getQualifier().precision, selectors.size())); + result->setType(TType(base->getBasicType(), EvqTemporary, base->getType().getQualifier().precision, + selectors.size())); } } } else if (base->isMatrix()) { @@ -1007,10 +1018,14 @@ TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TInt result = intermediate.foldDereference(base, selectors[0].coord1, loc); result = intermediate.foldDereference(result, selectors[0].coord2, loc); } else { - result = intermediate.addIndex(EOpIndexDirect, base, intermediate.addConstantUnion(selectors[0].coord1, loc), loc); + result = intermediate.addIndex(EOpIndexDirect, base, + intermediate.addConstantUnion(selectors[0].coord1, loc), + loc); TType dereferencedCol(base->getType(), 0); result->setType(dereferencedCol); - result = intermediate.addIndex(EOpIndexDirect, result, intermediate.addConstantUnion(selectors[0].coord2, loc), loc); + result = intermediate.addIndex(EOpIndexDirect, result, + intermediate.addConstantUnion(selectors[0].coord2, loc), + loc); TType dereferenced(dereferencedCol, 0); result->setType(dereferenced); } @@ -1021,7 +1036,8 @@ TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TInt if (base->getType().getQualifier().isFrontEndConstant()) result = intermediate.foldDereference(base, column, loc); else { - result = intermediate.addIndex(EOpIndexDirect, base, intermediate.addConstantUnion(column, loc), loc); + result = intermediate.addIndex(EOpIndexDirect, base, intermediate.addConstantUnion(column, loc), + loc); TType dereferenced(base->getType(), 0); result->setType(dereferenced); } @@ -1029,7 +1045,8 @@ TIntermTyped* HlslParseContext::handleDotDereference(const TSourceLoc& loc, TInt // general case, not a column, not a single component TIntermTyped* index = intermediate.addSwizzle(selectors, loc); result = intermediate.addIndex(EOpMatrixSwizzle, base, index, loc); - result->setType(TType(base->getBasicType(), EvqTemporary, base->getType().getQualifier().precision, selectors.size())); + result->setType(TType(base->getBasicType(), EvqTemporary, base->getType().getQualifier().precision, + selectors.size())); } } } else if (base->getBasicType() == EbtStruct || base->getBasicType() == EbtBlock) { @@ -1145,13 +1162,16 @@ TType& HlslParseContext::split(TType& type, TString name, const TType* outerStru // Get iterator to (now at end) set of builtin interstage IO members const auto firstIo = std::stable_partition(userStructure->begin(), userStructure->end(), - [this](const TTypeLoc& t) {return !t.type->isBuiltInInterstageIO(language);}); + [this](const TTypeLoc& t) { + return !t.type->isBuiltInInterstageIO(language); + }); // Move those to the builtin IO. However, we also propagate arrayness (just one level is handled // now) to this variable. for (auto ioType = firstIo; ioType != userStructure->end(); ++ioType) { const TType& memberType = *ioType->type; - TVariable* ioVar = makeInternalVariable(name + (name.empty() ? "" : "_") + memberType.getFieldName(), memberType); + TVariable* ioVar = makeInternalVariable(name + (name.empty() ? "" : "_") + memberType.getFieldName(), + memberType); if (arraySizes) ioVar->getWritableType().newArraySizes(*arraySizes); @@ -1475,7 +1495,8 @@ TIntermTyped* HlslParseContext::splitAccessStruct(const TSourceLoc& loc, TInterm if (memberType.isBuiltInInterstageIO(language)) { // It's one of the interstage IO variables we split off. - TIntermTyped* builtIn = intermediate.addSymbol(*interstageBuiltInIo[tInterstageIoData(memberType, base->getType())], loc); + TIntermTyped* builtIn = intermediate.addSymbol(*interstageBuiltInIo[tInterstageIoData(memberType, + base->getType())], loc); // If there's an array reference to an outer split struct, we re-apply it here. if (builtInIoIndex != nullptr) { @@ -1681,7 +1702,8 @@ void HlslParseContext::addInterstageIoToLinkage() // For struct buffers with counters, we must pass the counter buffer as hidden parameter. // This adds the hidden parameter to the parameter list in 'paramNodes' if needed. // Otherwise, it's a no-op -void HlslParseContext::addStructBufferHiddenCounterParam(const TSourceLoc& loc, TParameter& param, TIntermAggregate*& paramNodes) +void HlslParseContext::addStructBufferHiddenCounterParam(const TSourceLoc& loc, TParameter& param, + TIntermAggregate*& paramNodes) { if (! hasStructBuffCounter(*param.type)) return; @@ -1707,7 +1729,8 @@ void HlslParseContext::addStructBufferHiddenCounterParam(const TSourceLoc& loc, // Returns an aggregate of parameter-symbol nodes. // TIntermAggregate* HlslParseContext::handleFunctionDefinition(const TSourceLoc& loc, TFunction& function, - const TAttributeMap& attributes, TIntermNode*& entryPointTree) + const TAttributeMap& attributes, + TIntermNode*& entryPointTree) { currentCaller = function.getMangledName(); TSymbol* symbol = symbolTable.find(function.getMangledName()); @@ -1774,7 +1797,8 @@ TIntermAggregate* HlslParseContext::handleFunctionDefinition(const TSourceLoc& l const TTypeList* structure = variable->getType().getStruct(); for (int mem = 0; mem < (int)structure->size(); ++mem) { paramNodes = intermediate.growAggregate(paramNodes, - flattenAccess(variable->getUniqueId(), mem, *(*structure)[mem].type), + flattenAccess(variable->getUniqueId(), mem, + *(*structure)[mem].type), loc); } } else { @@ -1816,7 +1840,8 @@ void HlslParseContext::handleEntryPointAttributes(const TSourceLoc& loc, const T // MaxVertexCount const TIntermAggregate* maxVertexCount = attributes[EatMaxVertexCount]; if (maxVertexCount != nullptr) { - if (! intermediate.setVertices(maxVertexCount->getSequence()[0]->getAsConstantUnion()->getConstArray()[0].getIConst())) { + if (! intermediate.setVertices(maxVertexCount->getSequence()[0]->getAsConstantUnion()-> + getConstArray()[0].getIConst())) { error(loc, "cannot change previously set maxvertexcount attribute", "", ""); } } @@ -1927,14 +1952,16 @@ void HlslParseContext::handleEntryPointAttributes(const TSourceLoc& loc, const T } if (! intermediate.setVertexSpacing(partitioning)) - error(loc, "cannot change previously set partitioning", TQualifier::getVertexSpacingString(partitioning), ""); + error(loc, "cannot change previously set partitioning", + TQualifier::getVertexSpacingString(partitioning), ""); } } // Handle [outputcontrolpoints("...")] const TIntermAggregate* outputControlPoints = attributes[EatOutputControlPoints]; if (outputControlPoints != nullptr) { - const TConstUnion& ctrlPointConst = outputControlPoints->getSequence()[0]->getAsConstantUnion()->getConstArray()[0]; + const TConstUnion& ctrlPointConst = + outputControlPoints->getSequence()[0]->getAsConstantUnion()->getConstArray()[0]; if (ctrlPointConst.getType() != EbtInt) { error(loc, "invalid outputcontrolpoints", "", ""); } else { @@ -1978,7 +2005,8 @@ void HlslParseContext::handleEntryPointAttributes(const TSourceLoc& loc, const T // Returns nullptr if no entry-point tree was built, otherwise, returns // a subtree that creates the entry point. // -TIntermNode* HlslParseContext::transformEntryPoint(const TSourceLoc& loc, TFunction& userFunction, const TAttributeMap& attributes) +TIntermNode* HlslParseContext::transformEntryPoint(const TSourceLoc& loc, TFunction& userFunction, + const TAttributeMap& attributes) { // Return true if this is a tessellation patch constant function input to a domain shader. const auto isDsPcfInput = [this](const TType& type) { @@ -2155,7 +2183,8 @@ TIntermNode* HlslParseContext::transformEntryPoint(const TSourceLoc& loc, TFunct return synthFunctionDef; } -void HlslParseContext::handleFunctionBody(const TSourceLoc& loc, TFunction& function, TIntermNode* functionBody, TIntermNode*& node) +void HlslParseContext::handleFunctionBody(const TSourceLoc& loc, TFunction& function, TIntermNode* functionBody, + TIntermNode*& node) { node = intermediate.growAggregate(node, functionBody); intermediate.setAggregateOperator(node, EOpFunction, function.getType(), loc); @@ -2405,7 +2434,7 @@ TIntermAggregate* HlslParseContext::assignClipCullDistance(const TSourceLoc& loc } - // If we haven't created the output arleady, create it now. + // If we haven't created the output already, create it now. if (*clipCullVar == nullptr) { // ClipDistance and CullDistance are handled specially in the entry point output // copy algorithm, because they may need to be unpacked from components of vectors @@ -2518,7 +2547,8 @@ TIntermAggregate* HlslParseContext::assignClipCullDistance(const TSourceLoc& loc // expected to then not exist for opaque types, because they will turn into aliases. // // Return a node that contains the non-aliased assignments that must continue to exist. -TIntermAggregate* HlslParseContext::flattenedInit(const TSourceLoc& loc, TIntermSymbol* symbol, const TIntermAggregate& initializer) +TIntermAggregate* HlslParseContext::flattenedInit(const TSourceLoc& loc, TIntermSymbol* symbol, + const TIntermAggregate& initializer) { TIntermAggregate* initList = nullptr; // synthesize an access to each member, and then an assignment to it @@ -2544,7 +2574,8 @@ TIntermAggregate* HlslParseContext::flattenedInit(const TSourceLoc& loc, TInterm // // Also, assignment to matrix swizzles requires multiple component assignments, // intercept those as well. -TIntermTyped* HlslParseContext::handleAssign(const TSourceLoc& loc, TOperator op, TIntermTyped* left, TIntermTyped* right) +TIntermTyped* HlslParseContext::handleAssign(const TSourceLoc& loc, TOperator op, TIntermTyped* left, + TIntermTyped* right) { if (left == nullptr || right == nullptr) return nullptr; @@ -2803,7 +2834,8 @@ TIntermTyped* HlslParseContext::handleAssign(const TSourceLoc& loc, TOperator op // An assignment to matrix swizzle must be decomposed into individual assignments. // These must be selected component-wise from the RHS and stored component-wise // into the LHS. -TIntermTyped* HlslParseContext::handleAssignToMatrixSwizzle(const TSourceLoc& loc, TOperator op, TIntermTyped* left, TIntermTyped* right) +TIntermTyped* HlslParseContext::handleAssignToMatrixSwizzle(const TSourceLoc& loc, TOperator op, TIntermTyped* left, + TIntermTyped* right) { assert(left->getAsOperator() && left->getAsOperator()->getOp() == EOpMatrixSwizzle); @@ -2885,7 +2917,8 @@ TOperator HlslParseContext::mapAtomicOp(const TSourceLoc& loc, TOperator op, boo // // Create a combined sampler/texture from separate sampler and texture. // -TIntermAggregate* HlslParseContext::handleSamplerTextureCombine(const TSourceLoc& loc, TIntermTyped* argTex, TIntermTyped* argSampler) +TIntermAggregate* HlslParseContext::handleSamplerTextureCombine(const TSourceLoc& loc, TIntermTyped* argTex, + TIntermTyped* argSampler) { TIntermAggregate* txcombine = new TIntermAggregate(EOpConstructTextureSampler); @@ -3045,7 +3078,8 @@ void HlslParseContext::decomposeStructBufferMethods(const TSourceLoc& loc, TInte if (isByteAddressBuffer) - argIndex = intermediate.addBinaryNode(EOpRightShift, argIndex, intermediate.addConstantUnion(2, loc, true), + argIndex = intermediate.addBinaryNode(EOpRightShift, argIndex, + intermediate.addConstantUnion(2, loc, true), loc, TType(EbtInt)); // Index into the array to find the item being loaded. @@ -3080,7 +3114,8 @@ void HlslParseContext::decomposeStructBufferMethods(const TSourceLoc& loc, TInte // First, we'll store the address in a variable to avoid multiple shifts // (we must convert the byte address to an item address) TIntermTyped* byteAddrIdx = intermediate.addBinaryNode(EOpRightShift, argIndex, - intermediate.addConstantUnion(2, loc, true), loc, TType(EbtInt)); + intermediate.addConstantUnion(2, loc, true), + loc, TType(EbtInt)); TVariable* byteAddrSym = makeInternalVariable("byteAddrTemp", TType(EbtInt, EvqTemporary)); TIntermTyped* byteAddrIdxVar = intermediate.addSymbol(*byteAddrSym, loc); @@ -3096,10 +3131,12 @@ void HlslParseContext::decomposeStructBufferMethods(const TSourceLoc& loc, TInte // add index offset if (idx != 0) - offsetIdx = intermediate.addBinaryNode(EOpAdd, offsetIdx, intermediate.addConstantUnion(idx, loc, true), + offsetIdx = intermediate.addBinaryNode(EOpAdd, offsetIdx, + intermediate.addConstantUnion(idx, loc, true), loc, TType(EbtInt)); - const TOperator idxOp = (offsetIdx->getQualifier().storage == EvqConst) ? EOpIndexDirect : EOpIndexIndirect; + const TOperator idxOp = (offsetIdx->getQualifier().storage == EvqConst) ? EOpIndexDirect + : EOpIndexIndirect; vec = intermediate.growAggregate(vec, intermediate.addIndex(idxOp, argArray, offsetIdx, loc)); } @@ -3158,7 +3195,8 @@ void HlslParseContext::decomposeStructBufferMethods(const TSourceLoc& loc, TInte if (idx != 0) offsetIdx = intermediate.addBinaryNode(EOpAdd, offsetIdx, idxConst, loc, TType(EbtInt)); - const TOperator idxOp = (offsetIdx->getQualifier().storage == EvqConst) ? EOpIndexDirect : EOpIndexIndirect; + const TOperator idxOp = (offsetIdx->getQualifier().storage == EvqConst) ? EOpIndexDirect + : EOpIndexIndirect; TIntermTyped* lValue = intermediate.addIndex(idxOp, argArray, offsetIdx, loc); TIntermTyped* rValue = (size == 1) ? argValue : @@ -3191,7 +3229,8 @@ void HlslParseContext::decomposeStructBufferMethods(const TSourceLoc& loc, TInte body = intermediate.growAggregate(body, assign, loc); } else { const int length = argArray->getType().getOuterArraySize(); - TIntermTyped* assign = intermediate.addAssign(EOpAssign, argNumItems, intermediate.addConstantUnion(length, loc, true), loc); + TIntermTyped* assign = intermediate.addAssign(EOpAssign, argNumItems, + intermediate.addConstantUnion(length, loc, true), loc); body = intermediate.growAggregate(body, assign, loc); } @@ -3202,7 +3241,8 @@ void HlslParseContext::decomposeStructBufferMethods(const TSourceLoc& loc, TInte intermediate.getBaseAlignment(argArray->getType(), size, stride, false, argArray->getType().getQualifier().layoutMatrix == ElmRowMajor); - TIntermTyped* assign = intermediate.addAssign(EOpAssign, argStride, intermediate.addConstantUnion(stride, loc, true), loc); + TIntermTyped* assign = intermediate.addAssign(EOpAssign, argStride, + intermediate.addConstantUnion(stride, loc, true), loc); body = intermediate.growAggregate(body, assign); } @@ -3277,8 +3317,9 @@ void HlslParseContext::decomposeStructBufferMethods(const TSourceLoc& loc, TInte { TIntermTyped* oldCounter = incDecCounter(-1); - TIntermTyped* newCounter = intermediate.addBinaryNode(EOpAdd, oldCounter, intermediate.addConstantUnion(-1, loc, true), loc, - oldCounter->getType()); + TIntermTyped* newCounter = intermediate.addBinaryNode(EOpAdd, oldCounter, + intermediate.addConstantUnion(-1, loc, true), loc, + oldCounter->getType()); node = intermediate.addIndex(EOpIndexIndirect, argArray, newCounter, loc); @@ -4716,7 +4757,8 @@ void HlslParseContext::decomposeIntrinsic(const TSourceLoc& loc, TIntermTyped*& TIntermAggregate* compoundStatement = intermediate.makeAggregate(tmpArgAssign, loc); - const TType boolType(EbtBool, EvqTemporary, arg0->getVectorSize(), arg0->getMatrixCols(), arg0->getMatrixRows()); + const TType boolType(EbtBool, EvqTemporary, arg0->getVectorSize(), arg0->getMatrixCols(), + arg0->getMatrixRows()); TIntermTyped* isnan = handleUnaryMath(loc, "isnan", EOpIsNan, intermediate.addSymbol(*tempArg, loc)); isnan->setType(boolType); @@ -4826,7 +4868,8 @@ TIntermTyped* HlslParseContext::handleFunctionCall(const TSourceLoc& loc, TFunct // Error check for a function requiring specific extensions present. if (builtIn && fnCandidate->getNumExtensions()) - requireExtensions(loc, fnCandidate->getNumExtensions(), fnCandidate->getExtensions(), fnCandidate->getName().c_str()); + requireExtensions(loc, fnCandidate->getNumExtensions(), fnCandidate->getExtensions(), + fnCandidate->getName().c_str()); // turn an implicit member-function resolution into an explicit call TString callerName; @@ -4856,7 +4899,8 @@ TIntermTyped* HlslParseContext::handleFunctionCall(const TSourceLoc& loc, TFunct op = fnCandidate->getBuiltInOp(); if (builtIn && op != EOpNull) { // A function call mapped to a built-in operation. - result = intermediate.addBuiltInFunctionCall(loc, op, fnCandidate->getParamCount() == 1, arguments, fnCandidate->getType()); + result = intermediate.addBuiltInFunctionCall(loc, op, fnCandidate->getParamCount() == 1, arguments, + fnCandidate->getType()); if (result == nullptr) { error(arguments->getLoc(), " wrong operand type", "Internal Error", "built in unary operator function. Type: %s", @@ -4922,7 +4966,8 @@ TIntermTyped* HlslParseContext::handleFunctionCall(const TSourceLoc& loc, TFunct } // generic error recovery - // TODO: simplification: localize all the error recoveries that look like this, and taking type into account to reduce cascades + // TODO: simplification: localize all the error recoveries that look like this, and taking type into account to + // reduce cascades if (result == nullptr) result = intermediate.addConstantUnion(0.0, EbtFloat, loc); @@ -5000,7 +5045,8 @@ void HlslParseContext::addInputArgumentConversions(const TFunction& function, TI internalAggregate->getType()); internalSymbolNode->setLoc(arg->getLoc()); // This makes the deepest level, the member-wise copy - TIntermAggregate* assignAgg = handleAssign(arg->getLoc(), EOpAssign, internalSymbolNode, arg)->getAsAggregate(); + TIntermAggregate* assignAgg = handleAssign(arg->getLoc(), EOpAssign, + internalSymbolNode, arg)->getAsAggregate(); // Now, pair that with the resulting aggregate. assignAgg = intermediate.growAggregate(assignAgg, internalSymbolNode, arg->getLoc()); @@ -5154,7 +5200,8 @@ TIntermTyped* HlslParseContext::addOutputArgumentConversions(const TFunction& fu TIntermSymbol* tempArgNode = intermediate.addSymbol(*tempArg, loc); // This makes the deepest level, the member-wise copy - TIntermTyped* tempAssign = handleAssign(arguments[i]->getLoc(), EOpAssign, arguments[i]->getAsTyped(), tempArgNode); + TIntermTyped* tempAssign = handleAssign(arguments[i]->getLoc(), EOpAssign, arguments[i]->getAsTyped(), + tempArgNode); tempAssign = handleLvalue(arguments[i]->getLoc(), "assign", tempAssign); conversionTree = intermediate.growAggregate(conversionTree, tempAssign, arguments[i]->getLoc()); @@ -5264,7 +5311,8 @@ void HlslParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fn case EOpTextureGather: // More than two arguments needs gpu_shader5, and rectangular or shadow needs gpu_shader5, // otherwise, need GL_ARB_texture_gather. - if (fnCandidate.getParamCount() > 2 || fnCandidate[0].type->getSampler().dim == EsdRect || fnCandidate[0].type->getSampler().shadow) { + if (fnCandidate.getParamCount() > 2 || fnCandidate[0].type->getSampler().dim == EsdRect || + fnCandidate[0].type->getSampler().shadow) { if (! fnCandidate[0].type->getSampler().shadow) compArg = 2; } @@ -5326,7 +5374,8 @@ void HlslParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fn for (int c = 0; c < type.getVectorSize(); ++c) { int offset = aggArgs[arg]->getAsConstantUnion()->getConstArray()[c].getIConst(); if (offset > resources.maxProgramTexelOffset || offset < resources.minProgramTexelOffset) - error(loc, "value is out of range:", "texel offset", "[gl_MinProgramTexelOffset, gl_MaxProgramTexelOffset]"); + error(loc, "value is out of range:", "texel offset", + "[gl_MinProgramTexelOffset, gl_MaxProgramTexelOffset]"); } } } @@ -5362,7 +5411,8 @@ void HlslParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fn // desktop 4.4 and later: swizzles may be used const TIntermTyped* base = TIntermediate::findLValueBase(arg0, true); if (base == nullptr || base->getType().getQualifier().storage != EvqVaryingIn) - error(loc, "first argument must be an interpolant, or interpolant-array element", fnCandidate.getName().c_str(), ""); + error(loc, "first argument must be an interpolant, or interpolant-array element", + fnCandidate.getName().c_str(), ""); } break; @@ -5573,14 +5623,16 @@ void HlslParseContext::handleRegister(const TSourceLoc& loc, TQualifier& qualifi // Convert to a scalar boolean, or if not allowed by HLSL semantics, // report an error and return nullptr. -TIntermTyped* HlslParseContext::convertConditionalExpression(const TSourceLoc& loc, TIntermTyped* condition, bool mustBeScalar) +TIntermTyped* HlslParseContext::convertConditionalExpression(const TSourceLoc& loc, TIntermTyped* condition, + bool mustBeScalar) { if (mustBeScalar && !condition->getType().isScalarOrVec1()) { error(loc, "requires a scalar", "conditional expression", ""); return nullptr; } - return intermediate.addConversion(EOpConstructBool, TType(EbtBool, EvqTemporary, condition->getVectorSize()), condition); + return intermediate.addConversion(EOpConstructBool, TType(EbtBool, EvqTemporary, condition->getVectorSize()), + condition); } // @@ -5805,7 +5857,8 @@ bool HlslParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node TArraySizes& arraySizes = type.getArraySizes(); // At least the dimensionalities have to match. - if (! function[0].type->isArray() || arraySizes.getNumDims() != function[0].type->getArraySizes().getNumDims() + 1) { + if (! function[0].type->isArray() || + arraySizes.getNumDims() != function[0].type->getArraySizes().getNumDims() + 1) { error(loc, "array constructor argument not correct type to construct array element", "constructor", ""); return true; } @@ -5929,7 +5982,8 @@ bool HlslParseContext::constructorTextureSamplerError(const TSourceLoc& loc, con return true; } if (function.getType().getSampler().shadow != function[1].type->getSampler().shadow) { - error(loc, "sampler-constructor second argument presence of shadow must match constructor presence of shadow", token, ""); + error(loc, "sampler-constructor second argument presence of shadow must match constructor presence of shadow", + token, ""); return true; } @@ -6019,7 +6073,8 @@ int HlslParseContext::computeSamplerTypeIndex(TSampler& sampler) int shadowIndex = sampler.shadow ? 1 : 0; int externalIndex = sampler.external ? 1 : 0; - return EsdNumDims * (EbtNumTypes * (2 * (2 * arrayIndex + shadowIndex) + externalIndex) + sampler.type) + sampler.dim; + return EsdNumDims * + (EbtNumTypes * (2 * (2 * arrayIndex + shadowIndex) + externalIndex) + sampler.type) + sampler.dim; } // @@ -6095,7 +6150,8 @@ void HlslParseContext::arrayDimMerge(TType& type, const TArraySizes* sizes) // Do all the semantic checking for declaring or redeclaring an array, with and // without a size, and make the right changes to the symbol table. // -void HlslParseContext::declareArray(const TSourceLoc& loc, const TString& identifier, const TType& type, TSymbol*& symbol, bool track) +void HlslParseContext::declareArray(const TSourceLoc& loc, const TString& identifier, const TType& type, + TSymbol*& symbol, bool track) { if (symbol == nullptr) { bool currentScope; @@ -6137,7 +6193,8 @@ void HlslParseContext::declareArray(const TSourceLoc& loc, const TString& identi TType& existingType = symbol->getWritableType(); if (existingType.isExplicitlySizedArray()) { - // be more lenient for input arrays to geometry shaders and tessellation control outputs, where the redeclaration is the same size + // be more lenient for input arrays to geometry shaders and tessellation control outputs, + // where the redeclaration is the same size return; } @@ -6193,7 +6250,8 @@ void HlslParseContext::updateImplicitArraySize(const TSourceLoc& loc, TIntermNod // // Enforce non-initializer type/qualifier rules. // -void HlslParseContext::fixConstInit(const TSourceLoc& loc, const TString& identifier, TType& type, TIntermTyped*& initializer) +void HlslParseContext::fixConstInit(const TSourceLoc& loc, const TString& identifier, TType& type, + TIntermTyped*& initializer) { // // Make the qualifier make sense, given that there is an initializer. @@ -6231,7 +6289,8 @@ TSymbol* HlslParseContext::redeclareBuiltinVariable(const TSourceLoc& /*loc*/, c // Either redeclare the requested block, or give an error message why it can't be done. // // TODO: functionality: explicitly sizing members of redeclared blocks is not giving them an explicit size -void HlslParseContext::redeclareBuiltinBlock(const TSourceLoc& loc, TTypeList& newTypeList, const TString& blockName, const TString* instanceName, TArraySizes* arraySizes) +void HlslParseContext::redeclareBuiltinBlock(const TSourceLoc& loc, TTypeList& newTypeList, const TString& blockName, + const TString* instanceName, TArraySizes* arraySizes) { // Redeclaring a built-in block... @@ -6294,17 +6353,23 @@ void HlslParseContext::redeclareBuiltinBlock(const TSourceLoc& loc, TTypeList& n TType& oldType = *member->type; const TType& newType = *newMember->type; if (! newType.sameElementType(oldType)) - error(memberLoc, "cannot redeclare block member with a different type", member->type->getFieldName().c_str(), ""); + error(memberLoc, "cannot redeclare block member with a different type", + member->type->getFieldName().c_str(), ""); if (oldType.isArray() != newType.isArray()) - error(memberLoc, "cannot change arrayness of redeclared block member", member->type->getFieldName().c_str(), ""); + error(memberLoc, "cannot change arrayness of redeclared block member", + member->type->getFieldName().c_str(), ""); else if (! oldType.sameArrayness(newType) && oldType.isExplicitlySizedArray()) - error(memberLoc, "cannot change array size of redeclared block member", member->type->getFieldName().c_str(), ""); + error(memberLoc, "cannot change array size of redeclared block member", + member->type->getFieldName().c_str(), ""); if (newType.getQualifier().isMemory()) - error(memberLoc, "cannot add memory qualifier to redeclared block member", member->type->getFieldName().c_str(), ""); + error(memberLoc, "cannot add memory qualifier to redeclared block member", + member->type->getFieldName().c_str(), ""); if (newType.getQualifier().hasLayout()) - error(memberLoc, "cannot add layout to redeclared block member", member->type->getFieldName().c_str(), ""); + error(memberLoc, "cannot add layout to redeclared block member", + member->type->getFieldName().c_str(), ""); if (newType.getQualifier().patch) - error(memberLoc, "cannot add patch to redeclared block member", member->type->getFieldName().c_str(), ""); + error(memberLoc, "cannot add patch to redeclared block member", + member->type->getFieldName().c_str(), ""); oldType.getQualifier().centroid = newType.getQualifier().centroid; oldType.getQualifier().sample = newType.getQualifier().sample; oldType.getQualifier().invariant = newType.getQualifier().invariant; @@ -6632,7 +6697,8 @@ void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TQualifier& qua // Put the id's layout qualifier value into the public type, for qualifiers having a number set. // This is before we know any type information for error checking. -void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TQualifier& qualifier, TString& id, const TIntermTyped* node) +void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TQualifier& qualifier, TString& id, + const TIntermTyped* node) { const char* feature = "layout-id value"; // const char* nonLiteralFeature = "non-literal layout-id value"; @@ -6690,7 +6756,8 @@ void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TQualifier& qua // "It is a compile-time error to specify an *xfb_buffer* that is greater than // the implementation-dependent constant gl_MaxTransformFeedbackBuffers." if (value >= resources.maxTransformFeedbackBuffers) - error(loc, "buffer is too large:", id.c_str(), "gl_MaxTransformFeedbackBuffers is %d", resources.maxTransformFeedbackBuffers); + error(loc, "buffer is too large:", id.c_str(), "gl_MaxTransformFeedbackBuffers is %d", + resources.maxTransformFeedbackBuffers); if (value >= (int)TQualifier::layoutXfbBufferEnd) error(loc, "buffer is too large:", id.c_str(), "internal max is %d", TQualifier::layoutXfbBufferEnd - 1); else @@ -6706,7 +6773,8 @@ void HlslParseContext::setLayoutQualifier(const TSourceLoc& loc, TQualifier& qua // "The resulting stride (implicit or explicit), when divided by 4, must be less than or equal to the // implementation-dependent constant gl_MaxTransformFeedbackInterleavedComponents." if (value > 4 * resources.maxTransformFeedbackInterleavedComponents) - error(loc, "1/4 stride is too large:", id.c_str(), "gl_MaxTransformFeedbackInterleavedComponents is %d", resources.maxTransformFeedbackInterleavedComponents); + error(loc, "1/4 stride is too large:", id.c_str(), "gl_MaxTransformFeedbackInterleavedComponents is %d", + resources.maxTransformFeedbackInterleavedComponents); else if (value >= (int)TQualifier::layoutXfbStrideEnd) error(loc, "stride is too large:", id.c_str(), "internal max is %d", TQualifier::layoutXfbStrideEnd - 1); if (value < (int)TQualifier::layoutXfbStrideEnd) @@ -7317,7 +7385,8 @@ TSymbol* HlslParseContext::lookupUserType(const TString& typeName, TType& type) // 'parseType' is the type part of the declaration (to the left) // 'arraySizes' is the arrayness tagged on the identifier (to the right) // -TIntermNode* HlslParseContext::declareVariable(const TSourceLoc& loc, const TString& identifier, TType& type, TIntermTyped* initializer) +TIntermNode* HlslParseContext::declareVariable(const TSourceLoc& loc, const TString& identifier, TType& type, + TIntermTyped* initializer) { if (voidErrorCheck(loc, identifier, type.getBasicType())) return nullptr; @@ -7424,7 +7493,8 @@ TVariable* HlslParseContext::makeInternalVariable(const char* name, const TType& } // Make a symbol node holding a new internal temporary variable. -TIntermSymbol* HlslParseContext::makeInternalVariableNode(const TSourceLoc& loc, const char* name, const TType& type) const +TIntermSymbol* HlslParseContext::makeInternalVariableNode(const TSourceLoc& loc, const char* name, + const TType& type) const { TVariable* tmpVar = makeInternalVariable(name, type); tmpVar->getWritableType().getQualifier().makeTemporary(); @@ -7438,7 +7508,8 @@ TIntermSymbol* HlslParseContext::makeInternalVariableNode(const TSourceLoc& loc, // // Return the successfully declared variable. // -TVariable* HlslParseContext::declareNonArray(const TSourceLoc& loc, const TString& identifier, const TType& type, bool track) +TVariable* HlslParseContext::declareNonArray(const TSourceLoc& loc, const TString& identifier, const TType& type, + bool track) { // make a new variable TVariable* variable = new TVariable(&identifier, type); @@ -7460,7 +7531,8 @@ TVariable* HlslParseContext::declareNonArray(const TSourceLoc& loc, const TStrin // Returning nullptr just means there is no code to execute to handle the // initializer, which will, for example, be the case for constant initializers. // -TIntermNode* HlslParseContext::executeInitializer(const TSourceLoc& loc, TIntermTyped* initializer, TVariable* variable, bool flattened) +TIntermNode* HlslParseContext::executeInitializer(const TSourceLoc& loc, TIntermTyped* initializer, TVariable* variable, + bool flattened) { // // Identifier must be of type constant, a global, or a temporary, and @@ -7624,7 +7696,8 @@ TIntermTyped* HlslParseContext::convertInitializerList(const TSourceLoc& loc, co // recursively process each element TType elementType(arrayType, 0); // dereferenced type for (int i = 0; i < arrayType.getOuterArraySize(); ++i) { - initList->getSequence()[i] = convertInitializerList(loc, elementType, initList->getSequence()[i]->getAsTyped(), scalarInit); + initList->getSequence()[i] = convertInitializerList(loc, elementType, + initList->getSequence()[i]->getAsTyped(), scalarInit); if (initList->getSequence()[i] == nullptr) return nullptr; } @@ -7639,7 +7712,8 @@ TIntermTyped* HlslParseContext::convertInitializerList(const TSourceLoc& loc, co return nullptr; } for (size_t i = 0; i < type.getStruct()->size(); ++i) { - initList->getSequence()[i] = convertInitializerList(loc, *(*type.getStruct())[i].type, initList->getSequence()[i]->getAsTyped(), scalarInit); + initList->getSequence()[i] = convertInitializerList(loc, *(*type.getStruct())[i].type, + initList->getSequence()[i]->getAsTyped(), scalarInit); if (initList->getSequence()[i] == nullptr) return nullptr; } @@ -7658,7 +7732,8 @@ TIntermTyped* HlslParseContext::convertInitializerList(const TSourceLoc& loc, co } TType vectorType(type, 0); // dereferenced type for (int i = 0; i < type.getMatrixCols(); ++i) { - initList->getSequence()[i] = convertInitializerList(loc, vectorType, initList->getSequence()[i]->getAsTyped(), scalarInit); + initList->getSequence()[i] = convertInitializerList(loc, vectorType, + initList->getSequence()[i]->getAsTyped(), scalarInit); if (initList->getSequence()[i] == nullptr) return nullptr; } @@ -7669,7 +7744,8 @@ TIntermTyped* HlslParseContext::convertInitializerList(const TSourceLoc& loc, co // error check; we're at bottom, so work is finished below if (type.getVectorSize() != (int)initList->getSequence().size()) { - error(loc, "wrong vector size (or rows in a matrix column):", "initializer list", type.getCompleteString().c_str()); + error(loc, "wrong vector size (or rows in a matrix column):", "initializer list", + type.getCompleteString().c_str()); return nullptr; } } else if (type.isScalar()) { @@ -7856,7 +7932,8 @@ TIntermTyped* HlslParseContext::addConstructor(const TSourceLoc& loc, TIntermTyp // // Returns nullptr for an error or the constructed node. // -TIntermTyped* HlslParseContext::constructBuiltIn(const TType& type, TOperator op, TIntermTyped* node, const TSourceLoc& loc, bool subset) +TIntermTyped* HlslParseContext::constructBuiltIn(const TType& type, TOperator op, TIntermTyped* node, + const TSourceLoc& loc, bool subset) { TIntermTyped* newNode; TOperator basicOp; @@ -8208,7 +8285,8 @@ void HlslParseContext::declareBlock(const TSourceLoc& loc, TType& type, const TS TVariable& variable = *new TVariable(instanceName, blockType); if (! symbolTable.insert(variable)) { if (*instanceName == "") - error(loc, "nameless block contains a member that already has a name at global scope", "" /* blockName->c_str() */, ""); + error(loc, "nameless block contains a member that already has a name at global scope", + "" /* blockName->c_str() */, ""); else error(loc, "block instance name redefinition", variable.getName().c_str(), ""); @@ -8256,7 +8334,8 @@ void HlslParseContext::fixBlockLocations(const TSourceLoc& loc, TQualifier& qual memberQualifier.layoutLocation = nextLocation; memberQualifier.layoutComponent = 0; } - nextLocation = memberQualifier.layoutLocation + intermediate.computeTypeLocationSize(*typeList[member].type); + nextLocation = memberQualifier.layoutLocation + + intermediate.computeTypeLocationSize(*typeList[member].type); } } } @@ -8319,8 +8398,9 @@ void HlslParseContext::fixBlockUniformOffsets(const TQualifier& qualifier, TType int dummyStride; int memberAlignment = intermediate.getBaseAlignment(*typeList[member].type, memberSize, dummyStride, qualifier.layoutPacking == ElpStd140, - subMatrixLayout != ElmNone ? subMatrixLayout == ElmRowMajor - : qualifier.layoutMatrix == ElmRowMajor); + subMatrixLayout != ElmNone + ? subMatrixLayout == ElmRowMajor + : qualifier.layoutMatrix == ElmRowMajor); if (memberQualifier.hasOffset()) { // "The specified offset must be a multiple // of the base alignment of the type of the block member it qualifies, or a compile-time error results." @@ -8497,12 +8577,14 @@ void HlslParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, case ElgIsolines: break; default: - error(loc, "cannot apply to input", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry), ""); + error(loc, "cannot apply to input", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry), + ""); } } else if (publicType.qualifier.storage == EvqVaryingOut) { handleOutputGeometry(loc, publicType.shaderQualifiers.geometry); } else - error(loc, "cannot apply to:", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry), GetStorageQualifierString(publicType.qualifier.storage)); + error(loc, "cannot apply to:", TQualifier::getGeometryString(publicType.shaderQualifiers.geometry), + GetStorageQualifierString(publicType.qualifier.storage)); } if (publicType.shaderQualifiers.spacing != EvsNone) intermediate.setVertexSpacing(publicType.shaderQualifiers.spacing); @@ -8560,7 +8642,8 @@ void HlslParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, globalOutputDefaults.layoutXfbBuffer = qualifier.layoutXfbBuffer; if (globalOutputDefaults.hasXfbBuffer() && qualifier.hasXfbStride()) { if (! intermediate.setXfbBufferStride(globalOutputDefaults.layoutXfbBuffer, qualifier.layoutXfbStride)) - error(loc, "all stride settings must match for xfb buffer", "xfb_stride", "%d", qualifier.layoutXfbBuffer); + error(loc, "all stride settings must match for xfb buffer", "xfb_stride", "%d", + qualifier.layoutXfbBuffer); } break; default: @@ -8609,7 +8692,8 @@ void HlslParseContext::wrapupSwitchSubsequence(TIntermAggregate* statements, TIn // Turn the top-level node sequence built up of wrapupSwitchSubsequence // into a switch node. // -TIntermNode* HlslParseContext::addSwitch(const TSourceLoc& loc, TIntermTyped* expression, TIntermAggregate* lastStatements, TSelectionControl control) +TIntermNode* HlslParseContext::addSwitch(const TSourceLoc& loc, TIntermTyped* expression, + TIntermAggregate* lastStatements, TSelectionControl control) { wrapupSwitchSubsequence(lastStatements, nullptr); @@ -9268,7 +9352,8 @@ void HlslParseContext::addPatchConstantInvocation() TIntermSymbol* pcfResultVar = intermediate.addSymbol(*pcfCallResult, loc); TIntermNode* pcfResultAssign = handleAssign(loc, EOpAssign, pcfResultVar, pcfCall); - TIntermNode* pcfResultToOut = handleAssign(loc, EOpAssign, pcfOutputSym, intermediate.addSymbol(*pcfCallResult, loc)); + TIntermNode* pcfResultToOut = handleAssign(loc, EOpAssign, pcfOutputSym, + intermediate.addSymbol(*pcfCallResult, loc)); pcfCallSequence = intermediate.growAggregate(pcfCallSequence, pcfResultAssign); pcfCallSequence = intermediate.growAggregate(pcfCallSequence, pcfResultToOut);