//

// Copyright (C) 2016-2018 Google, Inc.

// Copyright (C) 2016 LunarG, Inc.

// Copyright (C) 2023 Mobica Limited.

//

// 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 Google, Inc., 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 is a set of mutually recursive methods implementing the HLSL grammar.

// Generally, each returns

//  - through an argument: a type specifically appropriate to which rule it

//    recognized

//  - through the return value: true/false to indicate whether or not it

//    recognized its rule

//

// As much as possible, only grammar recognition should happen in this file,

// with all other work being farmed out to hlslParseHelper.cpp, which in turn

// will build the AST.

//

// The next token, yet to be "accepted" is always sitting in 'token'.

// When a method says it accepts a rule, that means all tokens involved

// in the rule will have been consumed, and none left in 'token'.

//

#include "../Include/defer.h"

#include "hlslTokens.h"

#include "hlslGrammar.h"

#include "hlslAttributes.h"

namespace glslang {

// Root entry point to this recursive decent parser.

// Return true if compilation unit was successfully accepted.

bool HlslGrammar::parse()

{

    advanceToken();

    return acceptCompilationUnit();

}

void HlslGrammar::expected(const char* syntax)

{

    parseContext.error(token.loc, "Expected", syntax, "");

}

void HlslGrammar::unimplemented(const char* error)

{

    parseContext.error(token.loc, "Unimplemented", error, "");

}

// IDENTIFIER

// THIS

// type that can be used as IDENTIFIER

//

// Only process the next token if it is an identifier.

// Return true if it was an identifier.

bool HlslGrammar::acceptIdentifier(HlslToken& idToken)

{

    // IDENTIFIER

    if (peekTokenClass(EHTokIdentifier)) {

        idToken = token;

        advanceToken();

        return true;

    }

    // THIS

    // -> maps to the IDENTIFIER spelled with the internal special name for 'this'

    if (peekTokenClass(EHTokThis)) {

        idToken = token;

        advanceToken();

        idToken.tokenClass = EHTokIdentifier;

        idToken.string = NewPoolTString(intermediate.implicitThisName);

        return true;

    }

    // type that can be used as IDENTIFIER

    // Even though "sample", "bool", "float", etc keywords (for types, interpolation modifiers),

    // they ARE still accepted as identifiers.  This is not a dense space: e.g, "void" is not a

    // valid identifier, nor is "linear".  This code special cases the known instances of this, so

    // e.g, "int sample;" or "float float;" is accepted.  Other cases can be added here if needed.

    const char* idString = getTypeString(peek());

    if (idString == nullptr)

        return false;

    token.string     = NewPoolTString(idString);

    token.tokenClass = EHTokIdentifier;

    idToken = token;

    typeIdentifiers = true;

    advanceToken();

    return true;

}

// compilationUnit

//      : declaration_list EOF

//

bool HlslGrammar::acceptCompilationUnit()

{

    if (! acceptDeclarationList(unitNode))

        return false;

    if (! peekTokenClass(EHTokNone))

        return false;

    // set root of AST

    if (unitNode && !unitNode->getAsAggregate())

        unitNode = intermediate.growAggregate(nullptr, unitNode);

    intermediate.setTreeRoot(unitNode);

    return true;

}

// Recognize the following, but with the extra condition that it can be

// successfully terminated by EOF or '}'.

//

// declaration_list

//      : list of declaration_or_semicolon followed by EOF or RIGHT_BRACE

//

// declaration_or_semicolon

//      : declaration

//      : SEMICOLON

//

bool HlslGrammar::acceptDeclarationList(TIntermNode*& nodeList)

{

    do {

        // HLSL allows extra semicolons between global declarations

        do { } while (acceptTokenClass(EHTokSemicolon));

        // EOF or RIGHT_BRACE

        if (peekTokenClass(EHTokNone) || peekTokenClass(EHTokRightBrace))

            return true;

        // declaration

        if (! acceptDeclaration(nodeList)) {

            expected("declaration");

            return false;

        }

    } while (true);

    return true;

}

// sampler_state

//      : LEFT_BRACE [sampler_state_assignment ... ] RIGHT_BRACE

//

// sampler_state_assignment

//     : sampler_state_identifier EQUAL value SEMICOLON

//

// sampler_state_identifier

//     : ADDRESSU

//     | ADDRESSV

//     | ADDRESSW

//     | BORDERCOLOR

//     | FILTER

//     | MAXANISOTROPY

//     | MAXLOD

//     | MINLOD

//     | MIPLODBIAS

//

bool HlslGrammar::acceptSamplerState()

{

    // TODO: this should be genericized to accept a list of valid tokens and

    // return token/value pairs.  Presently it is specific to texture values.

    if (! acceptTokenClass(EHTokLeftBrace))

        return true;

    parseContext.warn(token.loc, "unimplemented", "immediate sampler state", "");

    do {

        // read state name

        HlslToken state;

        if (! acceptIdentifier(state))

            break;  // end of list

        // FXC accepts any case

        TString stateName = *state.string;

        std::transform(stateName.begin(), stateName.end(), stateName.begin(), ::tolower);

        if (! acceptTokenClass(EHTokAssign)) {

            expected("assign");

            return false;

        }

        if (stateName == "minlod" || stateName == "maxlod") {

            if (! peekTokenClass(EHTokIntConstant)) {

                expected("integer");

                return false;

            }

            TIntermTyped* lod = nullptr;

            if (! acceptLiteral(lod))  // should never fail, since we just looked for an integer

                return false;

        } else if (stateName == "maxanisotropy") {

            if (! peekTokenClass(EHTokIntConstant)) {

                expected("integer");

                return false;

            }

            TIntermTyped* maxAnisotropy = nullptr;

            if (! acceptLiteral(maxAnisotropy))  // should never fail, since we just looked for an integer

                return false;

        } else if (stateName == "filter") {

            HlslToken filterMode;

            if (! acceptIdentifier(filterMode)) {

                expected("filter mode");

                return false;

            }

        } else if (stateName == "addressu" || stateName == "addressv" || stateName == "addressw") {

            HlslToken addrMode;

            if (! acceptIdentifier(addrMode)) {

                expected("texture address mode");

                return false;

            }

        } else if (stateName == "miplodbias") {

            TIntermTyped* lodBias = nullptr;

            if (! acceptLiteral(lodBias)) {

                expected("lod bias");

                return false;

            }

        } else if (stateName == "bordercolor") {

            return false;

        } else {

            expected("texture state");

            return false;

        }

        // SEMICOLON

        if (! acceptTokenClass(EHTokSemicolon)) {

            expected("semicolon");

            return false;

        }

    } while (true);

    if (! acceptTokenClass(EHTokRightBrace))

        return false;

    return true;

}

// sampler_declaration_dx9

//    : SAMPLER identifier EQUAL sampler_type sampler_state

//

bool HlslGrammar::acceptSamplerDeclarationDX9(TType& /*type*/)

{

    if (! acceptTokenClass(EHTokSampler))

        return false;

    // TODO: remove this when DX9 style declarations are implemented.

    unimplemented("Direct3D 9 sampler declaration");

    // read sampler name

    HlslToken name;

    if (! acceptIdentifier(name)) {

        expected("sampler name");

        return false;

    }

    if (! acceptTokenClass(EHTokAssign)) {

        expected("=");

        return false;

    }

    return false;

}

// declaration

//      : attributes attributed_declaration

//      | NAMESPACE IDENTIFIER LEFT_BRACE declaration_list RIGHT_BRACE

//

// attributed_declaration

//      : sampler_declaration_dx9 post_decls SEMICOLON

//      | fully_specified_type                           // for cbuffer/tbuffer

//      | fully_specified_type declarator_list SEMICOLON // for non cbuffer/tbuffer

//      | fully_specified_type identifier function_parameters post_decls compound_statement  // function definition

//      | fully_specified_type identifier sampler_state post_decls compound_statement        // sampler definition

//      | typedef declaration

//

// declarator_list

//      : declarator COMMA declarator COMMA declarator...  // zero or more declarators

//

// declarator

//      : identifier array_specifier post_decls

//      | identifier array_specifier post_decls EQUAL assignment_expression

//      | identifier function_parameters post_decls                                          // function prototype

//

// Parsing has to go pretty far in to know whether it's a variable, prototype, or

// function definition, so the implementation below doesn't perfectly divide up the grammar

// as above.  (The 'identifier' in the first item in init_declarator list is the

// same as 'identifier' for function declarations.)

//

// This can generate more than one subtree, one per initializer or a function body.

// All initializer subtrees are put in their own aggregate node, making one top-level

// node for all the initializers. Each function created is a top-level node to grow

// into the passed-in nodeList.

//

// If 'nodeList' is passed in as non-null, it must be an aggregate to extend for

// each top-level node the declaration creates. Otherwise, if only one top-level

// node in generated here, that is want is returned in nodeList.

//

bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList)

{

    // NAMESPACE IDENTIFIER LEFT_BRACE declaration_list RIGHT_BRACE

    if (acceptTokenClass(EHTokNamespace)) {

        HlslToken namespaceToken;

        if (!acceptIdentifier(namespaceToken)) {

            expected("namespace name");

            return false;

        }

        parseContext.pushNamespace(*namespaceToken.string);

        if (!acceptTokenClass(EHTokLeftBrace)) {

            expected("{");

            return false;

        }

        if (!acceptDeclarationList(nodeList)) {

            expected("declaration list");

            return false;

        }

        if (!acceptTokenClass(EHTokRightBrace)) {

            expected("}");

            return false;

        }

        parseContext.popNamespace();

        return true;

    }

    bool declarator_list = false; // true when processing comma separation

    // attributes

    TFunctionDeclarator declarator;

    acceptAttributes(declarator.attributes);

    // typedef

    bool typedefDecl = acceptTokenClass(EHTokTypedef);

    TType declaredType;

    // DX9 sampler declaration use a different syntax

    // DX9 shaders need to run through HLSL compiler (fxc) via a back compat mode, it isn't going to

    // be possible to simultaneously compile D3D10+ style shaders and DX9 shaders. If we want to compile DX9

    // HLSL shaders, this will have to be a master level switch

    // As such, the sampler keyword in D3D10+ turns into an automatic sampler type, and is commonly used

    // For that reason, this line is commented out

    // if (acceptSamplerDeclarationDX9(declaredType))

    //     return true;

    bool forbidDeclarators = (peekTokenClass(EHTokCBuffer) || peekTokenClass(EHTokTBuffer));

    // fully_specified_type

    if (! acceptFullySpecifiedType(declaredType, nodeList, declarator.attributes, forbidDeclarators))

        return false;

    // cbuffer and tbuffer end with the closing '}'.

    // No semicolon is included.

    if (forbidDeclarators)

        return true;

    // Check if there are invalid in/out qualifiers

    switch (declaredType.getQualifier().storage) {

    case EvqIn:

    case EvqOut:

    case EvqInOut:

        parseContext.error(token.loc, "in/out qualifiers are only valid on parameters", token.getCStrOrEmpty(), "");

        break;

    default:

        break;

    }

    // declarator_list

    //    : declarator

    //         : identifier

    HlslToken idToken;

    TIntermAggregate* initializers = nullptr;

    while (acceptIdentifier(idToken)) {

        TString *fullName = idToken.string;

        if (parseContext.symbolTable.atGlobalLevel())

            parseContext.getFullNamespaceName(fullName);

        if (peekTokenClass(EHTokLeftParen)) {

            // looks like function parameters

            // merge in the attributes into the return type

            parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType, true);

            // Potentially rename shader entry point function.  No-op most of the time.

            parseContext.renameShaderFunction(fullName);

            // function_parameters

            declarator.function = new TFunction(fullName, declaredType);

            if (!acceptFunctionParameters(*declarator.function)) {

                expected("function parameter list");

                return false;

            }

            // post_decls

            acceptPostDecls(declarator.function->getWritableType().getQualifier());

            // compound_statement (function body definition) or just a prototype?

            declarator.loc = token.loc;

            if (peekTokenClass(EHTokLeftBrace)) {

                if (declarator_list)

                    parseContext.error(idToken.loc, "function body can't be in a declarator list", "{", "");

                if (typedefDecl)

                    parseContext.error(idToken.loc, "function body can't be in a typedef", "{", "");

                return acceptFunctionDefinition(declarator, nodeList, nullptr);

            } else {

                if (typedefDecl)

                    parseContext.error(idToken.loc, "function typedefs not implemented", "{", "");

                parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, true);

            }

        } else {

            // A variable declaration.

            // merge in the attributes, the first time around, into the shared type

            if (! declarator_list)

                parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType);

            // Fix the storage qualifier if it's a global.

            if (declaredType.getQualifier().storage == EvqTemporary && parseContext.symbolTable.atGlobalLevel())

                declaredType.getQualifier().storage = EvqUniform;

            // recognize array_specifier

            TArraySizes* arraySizes = nullptr;

            acceptArraySpecifier(arraySizes);

            // We can handle multiple variables per type declaration, so

            // the number of types can expand when arrayness is different.

            TType variableType;

            variableType.shallowCopy(declaredType);

            // In the most general case, arrayness is potentially coming both from the

            // declared type and from the variable: "int[] a[];" or just one or the other.

            // Merge it all to the variableType, so all arrayness is part of the variableType.

            variableType.transferArraySizes(arraySizes);

            variableType.copyArrayInnerSizes(declaredType.getArraySizes());

            // samplers accept immediate sampler state

            if (variableType.getBasicType() == EbtSampler) {

                if (! acceptSamplerState())

                    return false;

            }

            // post_decls

            acceptPostDecls(variableType.getQualifier());

            // EQUAL assignment_expression

            TIntermTyped* expressionNode = nullptr;

            if (acceptTokenClass(EHTokAssign)) {

                if (typedefDecl)

                    parseContext.error(idToken.loc, "can't have an initializer", "typedef", "");

                if (! acceptAssignmentExpression(expressionNode)) {

                    expected("initializer");

                    return false;

                }

            }

            // TODO: things scoped within an annotation need their own name space;

            // TODO: non-constant strings are not yet handled.

            if (!(variableType.getBasicType() == EbtString && !variableType.getQualifier().isConstant()) &&

                parseContext.getAnnotationNestingLevel() == 0) {

                if (typedefDecl)

                    parseContext.declareTypedef(idToken.loc, *fullName, variableType);

                else if (variableType.getBasicType() == EbtBlock) {

                    if (expressionNode)

                        parseContext.error(idToken.loc, "buffer aliasing not yet supported", "block initializer", "");

                    parseContext.declareBlock(idToken.loc, variableType, fullName);

                    parseContext.declareStructBufferCounter(idToken.loc, variableType, *fullName);

                } else {

                    if (variableType.getQualifier().storage == EvqUniform && ! variableType.containsOpaque()) {

                        // this isn't really an individual variable, but a member of the $Global buffer

                        parseContext.growGlobalUniformBlock(idToken.loc, variableType, *fullName);

                    } else {

                        // Declare the variable and add any initializer code to the AST.

                        // The top-level node is always made into an aggregate, as that's

                        // historically how the AST has been.

                        initializers = intermediate.growAggregate(initializers, 

                            parseContext.declareVariable(idToken.loc, *fullName, variableType, expressionNode),

                            idToken.loc);

                    }

                }

            }

        }

        // COMMA

        if (acceptTokenClass(EHTokComma))

            declarator_list = true;

    }

    // The top-level initializer node is a sequence.

    if (initializers != nullptr)

        initializers->setOperator(EOpSequence);

    // if we have a locally scoped static, it needs a globally scoped initializer

    if (declaredType.getQualifier().storage == EvqGlobal && !parseContext.symbolTable.atGlobalLevel()) {

        unitNode = intermediate.growAggregate(unitNode, initializers, idToken.loc);

    } else {

        // Add the initializers' aggregate to the nodeList we were handed.

        if (nodeList)

            nodeList = intermediate.growAggregate(nodeList, initializers);

        else

            nodeList = initializers;

    }

    // SEMICOLON

    if (! acceptTokenClass(EHTokSemicolon)) {

        // This may have been a false detection of what appeared to be a declaration, but

        // was actually an assignment such as "float = 4", where "float" is an identifier.

        // We put the token back to let further parsing happen for cases where that may

        // happen.  This errors on the side of caution, and mostly triggers the error.

        if (peek() == EHTokAssign || peek() == EHTokLeftBracket || peek() == EHTokDot || peek() == EHTokComma)

            recedeToken();

        else

            expected(";");

        return false;

    }

    return true;

}

// control_declaration

//      : fully_specified_type identifier EQUAL expression

//

bool HlslGrammar::acceptControlDeclaration(TIntermNode*& node)

{

    node = nullptr;

    TAttributes attributes;

    // fully_specified_type

    TType type;

    if (! acceptFullySpecifiedType(type, attributes))

        return false;

    if (attributes.size() > 0)

        parseContext.warn(token.loc, "attributes don't apply to control declaration", "", "");

    // filter out type casts

    if (peekTokenClass(EHTokLeftParen)) {

        recedeToken();

        return false;

    }

    // identifier

    HlslToken idToken;

    if (! acceptIdentifier(idToken)) {

        expected("identifier");

        return false;

    }

    // EQUAL

    TIntermTyped* expressionNode = nullptr;

    if (! acceptTokenClass(EHTokAssign)) {

        expected("=");

        return false;

    }

    // expression

    if (! acceptExpression(expressionNode)) {

        expected("initializer");

        return false;

    }

    node = parseContext.declareVariable(idToken.loc, *idToken.string, type, expressionNode);

    return true;

}

// fully_specified_type

//      : type_specifier

//      | type_qualifier type_specifier

//      | type_specifier type_qualifier

//

bool HlslGrammar::acceptFullySpecifiedType(TType& type, const TAttributes& attributes)

{

    TIntermNode* nodeList = nullptr;

    return acceptFullySpecifiedType(type, nodeList, attributes);

}

bool HlslGrammar::acceptFullySpecifiedType(TType& type, TIntermNode*& nodeList, const TAttributes& attributes, bool forbidDeclarators)

{

    // type_qualifier

    TQualifier qualifier;

    qualifier.clear();

    if (! acceptPreQualifier(qualifier))

        return false;

    TSourceLoc loc = token.loc;

    // type_specifier

    if (! acceptType(type, nodeList)) {

        // If this is not a type, we may have inadvertently gone down a wrong path

        // by parsing "sample", which can be treated like either an identifier or a

        // qualifier.  Back it out, if we did.

        if (qualifier.sample)

            recedeToken();

        return false;

    }

    // type_qualifier

    if (! acceptPostQualifier(qualifier))

       return false;

    if (type.getBasicType() == EbtBlock) {

        // the type was a block, which set some parts of the qualifier

        parseContext.mergeQualifiers(type.getQualifier(), qualifier);

        // merge in the attributes

        parseContext.transferTypeAttributes(token.loc, attributes, type);

        // further, it can create an anonymous instance of the block

        // (cbuffer and tbuffer don't consume the next identifier, and

        // should set forbidDeclarators)

        if (forbidDeclarators || peek() != EHTokIdentifier)

            parseContext.declareBlock(loc, type);

    } else {

        // Some qualifiers are set when parsing the type.  Merge those with

        // whatever comes from acceptPreQualifier and acceptPostQualifier.

        assert(qualifier.layoutFormat == ElfNone);

        qualifier.layoutFormat = type.getQualifier().layoutFormat;

        qualifier.precision    = type.getQualifier().precision;

        if (type.getQualifier().storage == EvqOut ||

            type.getQualifier().storage == EvqBuffer) {

            qualifier.storage      = type.getQualifier().storage;

            qualifier.readonly     = type.getQualifier().readonly;

        }

        if (type.isBuiltIn())

            qualifier.builtIn = type.getQualifier().builtIn;

        type.getQualifier() = qualifier;

    }

    return true;

}

// type_qualifier

//      : qualifier qualifier ...

//

// Zero or more of these, so this can't return false.

//

bool HlslGrammar::acceptPreQualifier(TQualifier& qualifier)

{

    do {

        switch (peek()) {

        case EHTokStatic:

            qualifier.storage = EvqGlobal;

            break;

        case EHTokExtern:

            // TODO: no meaning in glslang?

            break;

        case EHTokShared:

            // TODO: hint

            break;

        case EHTokGroupShared:

            qualifier.storage = EvqShared;

            break;

        case EHTokUniform:

            qualifier.storage = EvqUniform;

            break;

        case EHTokConst:

            qualifier.storage = EvqConst;

            break;

        case EHTokVolatile:

            qualifier.volatil = true;

            break;

        case EHTokLinear:

            qualifier.smooth = true;

            break;

        case EHTokCentroid:

            qualifier.centroid = true;

            break;

        case EHTokNointerpolation:

            qualifier.flat = true;

            break;

        case EHTokNoperspective:

            qualifier.nopersp = true;

            break;

        case EHTokSample:

            qualifier.sample = true;

            break;

        case EHTokRowMajor:

            qualifier.layoutMatrix = ElmColumnMajor;

            break;

        case EHTokColumnMajor:

            qualifier.layoutMatrix = ElmRowMajor;

            break;

        case EHTokPrecise:

            qualifier.noContraction = true;

            break;

        case EHTokIn:

            if (qualifier.storage != EvqUniform) {

                qualifier.storage = (qualifier.storage == EvqOut) ? EvqInOut : EvqIn;

            }

            break;

        case EHTokOut:

            qualifier.storage = (qualifier.storage == EvqIn) ? EvqInOut : EvqOut;

            break;

        case EHTokInOut:

            qualifier.storage = EvqInOut;

            break;

        case EHTokLayout:

            if (! acceptLayoutQualifierList(qualifier))

                return false;

            continue;

        case EHTokGloballyCoherent:

            qualifier.coherent = true;

            break;

        case EHTokInline:

            // TODO: map this to SPIR-V function control

            break;

        // GS geometries: these are specified on stage input variables, and are an error (not verified here)

        // for output variables.

        case EHTokPoint:

            qualifier.storage = EvqIn;

            if (!parseContext.handleInputGeometry(token.loc, ElgPoints))

                return false;

            break;

        case EHTokLine:

            qualifier.storage = EvqIn;

            if (!parseContext.handleInputGeometry(token.loc, ElgLines))

                return false;

            break;

        case EHTokTriangle:

            qualifier.storage = EvqIn;

            if (!parseContext.handleInputGeometry(token.loc, ElgTriangles))

                return false;

            break;

        case EHTokLineAdj:

            qualifier.storage = EvqIn;

            if (!parseContext.handleInputGeometry(token.loc, ElgLinesAdjacency))

                return false;

            break;

        case EHTokTriangleAdj:

            qualifier.storage = EvqIn;

            if (!parseContext.handleInputGeometry(token.loc, ElgTrianglesAdjacency))

                return false;

            break;

        default:

            return true;

        }

        advanceToken();

    } while (true);

}

// type_qualifier

//      : qualifier qualifier ...

//

// Zero or more of these, so this can't return false.

//

bool HlslGrammar::acceptPostQualifier(TQualifier& qualifier)

{

    do {

        switch (peek()) {

        case EHTokConst:

            qualifier.storage = EvqConst;

            break;

        default:

            return true;

        }

        advanceToken();

    } while (true);

}

// layout_qualifier_list

//      : LAYOUT LEFT_PAREN layout_qualifier COMMA layout_qualifier ... RIGHT_PAREN

//

// layout_qualifier

//      : identifier

//      | identifier EQUAL expression

//

// Zero or more of these, so this can't return false.

//

bool HlslGrammar::acceptLayoutQualifierList(TQualifier& qualifier)

{

    if (! acceptTokenClass(EHTokLayout))

        return false;

    // LEFT_PAREN

    if (! acceptTokenClass(EHTokLeftParen))

        return false;

    do {

        // identifier

        HlslToken idToken;

        if (! acceptIdentifier(idToken))

            break;

        // EQUAL expression

        if (acceptTokenClass(EHTokAssign)) {

            TIntermTyped* expr;

            if (! acceptConditionalExpression(expr)) {

                expected("expression");

                return false;

            }

            parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string, expr);

        } else

            parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string);

        // COMMA

        if (! acceptTokenClass(EHTokComma))

            break;

    } while (true);

    // RIGHT_PAREN

    if (! acceptTokenClass(EHTokRightParen)) {

        expected(")");

        return false;

    }

    return true;

}

// template_type

//      : FLOAT

//      | DOUBLE

//      | INT

//      | DWORD

//      | UINT

//      | BOOL

//

bool HlslGrammar::acceptTemplateVecMatBasicType(TBasicType& basicType,

                                                TPrecisionQualifier& precision)

{

    precision = EpqNone;

    switch (peek()) {

    case EHTokFloat:

        basicType = EbtFloat;

        break;

    case EHTokDouble:

        basicType = EbtDouble;

        break;

    case EHTokInt:

    case EHTokDword:

        basicType = EbtInt;

        break;

    case EHTokUint:

        basicType = EbtUint;

        break;

    case EHTokBool:

        basicType = EbtBool;

        break;

    case EHTokHalf:

        basicType = parseContext.hlslEnable16BitTypes() ? EbtFloat16 : EbtFloat;

        break;

    case EHTokMin16float:

    case EHTokMin10float:

        basicType = parseContext.hlslEnable16BitTypes() ? EbtFloat16 : EbtFloat;

        precision = EpqMedium;

        break;

    case EHTokMin16int:

    case EHTokMin12int:

        basicType = parseContext.hlslEnable16BitTypes() ? EbtInt16 : EbtInt;

        precision = EpqMedium;

        break;

    case EHTokMin16uint:

        basicType = parseContext.hlslEnable16BitTypes() ? EbtUint16 : EbtUint;

        precision = EpqMedium;

        break;

    default:

        return false;

    }

    advanceToken();

    return true;

}

// vector_template_type

//      : VECTOR

//      | VECTOR LEFT_ANGLE template_type COMMA integer_literal RIGHT_ANGLE

//

bool HlslGrammar::acceptVectorTemplateType(TType& type)

{

    if (! acceptTokenClass(EHTokVector))

        return false;

    if (! acceptTokenClass(EHTokLeftAngle)) {

        // in HLSL, 'vector' alone means float4.

        new(&type) TType(EbtFloat, EvqTemporary, 4);

        return true;

    }

    TBasicType basicType;

    TPrecisionQualifier precision;

    if (! acceptTemplateVecMatBasicType(basicType, precision)) {

        expected("scalar type");

        return false;

    }

    // COMMA

    if (! acceptTokenClass(EHTokComma)) {

        expected(",");

        return false;

    }

    // integer

    if (! peekTokenClass(EHTokIntConstant)) {

        expected("literal integer");

        return false;

    }

    TIntermTyped* vecSize;

    if (! acceptLiteral(vecSize))

        return false;

    const int vecSizeI = vecSize->getAsConstantUnion()->getConstArray()[0].getIConst();

    new(&type) TType(basicType, EvqTemporary, precision, vecSizeI);