Method parse_expression_multary

source/effect_parser_exp.cpp:1488–1757

}

bool reshadefx::parser::parse_expression_multary(expression &lhs_exp, unsigned int left_precedence)
{
	const bool precise = lhs_exp.type.has(type::q_precise);

	// Parse left hand side of the expression
	if (!parse_expression_unary(lhs_exp))
		return false;

	// Check if an operator exists so that this is a binary or ternary expression
	unsigned int right_precedence;

	while (peek_multary_op(right_precedence))
	{
		// Only process this operator if it has a lower precedence than the current operation, otherwise leave it for later and abort
		if (right_precedence <= left_precedence)
			break;

		// Finally consume the operator token
		consume();

		const tokenid op = _token.id;

		// Check if this is a binary or ternary operation
		if (op != tokenid::question)
		{
#if RESHADEFX_SHORT_CIRCUIT
			codegen::id lhs_block = 0;
			codegen::id rhs_block = 0;
			codegen::id merge_block = 0;

			// Switch block to a new one before parsing right-hand side value in case it needs to be skipped during short-circuiting
			if (op == tokenid::ampersand_ampersand || op == tokenid::pipe_pipe)
			{
				lhs_block = _codegen->set_block(0);
				rhs_block = _codegen->create_block();
				merge_block = _codegen->create_block();

				_codegen->enter_block(rhs_block);
			}
#endif
			expression rhs_exp;
			// Propagate precise qualifier to the right hand side
			if (precise)
				rhs_exp.type.qualifiers |= type::q_precise;

			// Parse the right hand side of the binary operation
			if (!parse_expression_multary(rhs_exp, right_precedence))
				return false;

			// Deduce the result base type based on implicit conversion rules
			type type = type::merge(lhs_exp.type, rhs_exp.type);
			bool is_bool_result = false;

			// Do some error checking depending on the operator
			if (op == tokenid::equal_equal || op == tokenid::exclaim_equal)
			{
				// Equality checks return a boolean value
				is_bool_result = true;