Method ParseTerminalExpression

hlslparser/src/HLSLParser.cpp:2891–3284

}

bool HLSLParser::ParseTerminalExpression(HLSLExpression*& expression, bool& needsEndParen)
{
    const char* fileName = GetFileName();
    int line = GetLineNumber();

    needsEndParen = false;

    HLSLUnaryOp unaryOp;
    if (AcceptUnaryOperator(true, unaryOp)) {
        HLSLUnaryExpression* unaryExpression = m_tree->AddNode<HLSLUnaryExpression>(fileName, line);
        unaryExpression->unaryOp = unaryOp;
        if (!ParseTerminalExpression(unaryExpression->expression, needsEndParen)) {
            return false;
        }
        if (unaryOp == HLSLUnaryOp_BitNot) {
            if (!IsIntegerType(unaryExpression->expression->expressionType.baseType)) {
                const char* typeName = GetTypeNameHLSL(unaryExpression->expression->expressionType);
                m_tokenizer.Error("unary '~' : no global operator found which takes type '%s' (or there is no acceptable conversion)", typeName);
                return false;
            }
        }
        if (unaryOp == HLSLUnaryOp_Not) {
            unaryExpression->expressionType = HLSLType(HLSLBaseType_Bool);

            // Propagate constness.
            unaryExpression->expressionType.flags = unaryExpression->expression->expressionType.flags & HLSLTypeFlag_Const;
        }
        else {
            unaryExpression->expressionType = unaryExpression->expression->expressionType;
        }
        expression = unaryExpression;
        return true;
    }

    // Expressions inside parenthesis or casts.
    if (Accept('(')) {
        // Check for a casting operator.
        HLSLType type;
        if (AcceptType(false, type)) {
            // This is actually a type constructor like (float2(...
            if (Accept('(')) {
                needsEndParen = true;
                return ParsePartialConstructor(expression, type.baseType, type.typeName);
            }
            HLSLCastingExpression* castingExpression = m_tree->AddNode<HLSLCastingExpression>(fileName, line);
            castingExpression->type = type;
            expression = castingExpression;
            castingExpression->expressionType = type;
            return Expect(')') && ParseExpression(castingExpression->expression);
        }

        if (!ParseExpression(expression) || !Expect(')')) {
            return false;
        }
    }
    else {
        // Terminal values.
        float fValue = 0.0f;