Method ParseBinaryExpression

hlslparser/src/HLSLParser.cpp:2794–2871

}

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

    bool needsEndParen;

    if (!ParseTerminalExpression(expression, needsEndParen)) {
        return false;
    }

    // reset priority cause openned parenthesis
    if (needsEndParen)
        priority = 0;

    while (1) {
        HLSLBinaryOp binaryOp;
        if (AcceptBinaryOperator(priority, binaryOp)) {
            HLSLExpression* expression2 = NULL;
            ASSERT(binaryOp < sizeof(_binaryOpPriority) / sizeof(int));
            if (!ParseBinaryExpression(_binaryOpPriority[binaryOp], expression2)) {
                return false;
            }
            HLSLBinaryExpression* binaryExpression = m_tree->AddNode<HLSLBinaryExpression>(fileName, line);
            binaryExpression->binaryOp = binaryOp;
            binaryExpression->expression1 = expression;
            binaryExpression->expression2 = expression2;
            if (!GetBinaryOpResultType(binaryOp, expression->expressionType, expression2->expressionType, binaryExpression->expressionType)) {
                const char* typeName1 = GetTypeNameHLSL(binaryExpression->expression1->expressionType);
                const char* typeName2 = GetTypeNameHLSL(binaryExpression->expression2->expressionType);
                m_tokenizer.Error("binary '%s' : no global operator found which takes types '%s' and '%s' (or there is no acceptable conversion)",
                                  GetBinaryOpName(binaryOp), typeName1, typeName2);

                return false;
            }

            // Propagate constness.
            binaryExpression->expressionType.flags = (expression->expressionType.flags | expression2->expressionType.flags) & HLSLTypeFlag_Const;

            expression = binaryExpression;
        }
        else if (_conditionalOpPriority > priority && Accept('?')) {
            HLSLConditionalExpression* conditionalExpression = m_tree->AddNode<HLSLConditionalExpression>(fileName, line);
            conditionalExpression->condition = expression;

            HLSLExpression* expression1 = NULL;
            HLSLExpression* expression2 = NULL;
            if (!ParseBinaryExpression(_conditionalOpPriority, expression1) || !Expect(':') || !ParseBinaryExpression(_conditionalOpPriority, expression2)) {
                return false;
            }

            // Make sure both cases have compatible types.
            if (GetTypeCastRank(m_tree, expression1->expressionType, expression2->expressionType) == -1) {
                const char* srcTypeName = GetTypeNameHLSL(expression2->expressionType);
                const char* dstTypeName = GetTypeNameHLSL(expression1->expressionType);
                m_tokenizer.Error("':' no possible conversion from from '%s' to '%s'", srcTypeName, dstTypeName);
                return false;
            }