Method parse_expression_unary

source/effect_parser_exp.cpp:647–1486

}

bool reshadefx::parser::parse_expression_unary(expression &exp)
{
	location location = _token_next.location;

	const bool precise = exp.type.has(type::q_precise);

	// Check if a prefix operator exists
	if (accept_unary_op())
	{
		// Remember the operator token before parsing the expression that follows it
		const tokenid op = _token.id;

		// Parse the actual expression
		if (!parse_expression_unary(exp))
			return false;

		// Unary operators are only valid on basic types
		if (!exp.type.is_scalar() && !exp.type.is_vector() && !exp.type.is_matrix())
		{
			error(exp.location, 3022, "scalar, vector, or matrix expected");
			return false;
		}

		// Special handling for the "++" and "--" operators
		if (op == tokenid::plus_plus || op == tokenid::minus_minus)
		{
			if (exp.type.has(type::q_const) || !exp.is_lvalue)
			{
				error(location, 3025, "l-value specifies const object");
				return false;
			}

			// Create a constant one in the type of the expression
			const codegen::id constant_one = _codegen->emit_constant(exp.type, 1);

			const codegen::id value = _codegen->emit_load(exp);
			const codegen::id result = _codegen->emit_binary_op(location, op, exp.type, value, constant_one);

			// The "++" and "--" operands modify the source variable, so store result back into it
			_codegen->emit_store(exp, result);
		}
		else if (op != tokenid::plus) // Ignore "+" operator since it does not actually do anything
		{
			// The "~" bitwise operator is only valid on integral types
			if (op == tokenid::tilde && !exp.type.is_integral())
			{
				error(exp.location, 3082, "int or unsigned int type required");
				return false;
			}

			// The logical not operator expects a boolean type as input, so perform cast if necessary
			if (op == tokenid::exclaim && !exp.type.is_boolean())
				exp.add_cast_operation({ type::t_bool, exp.type.rows, exp.type.cols }); // The result will be boolean as well

			// Constant expressions can be evaluated at compile time
			if (!exp.evaluate_constant_expression(op))
			{
				const codegen::id value = _codegen->emit_load(exp);