Function AR_EXP_ReduceToScalar

src/arithmetic/arithmetic_expression.c:292–360

compact tree by evaluating constant expressions e.g. MINUS(X) where X is a constant number will be reduced to a single node with the value -X PLUS(MINUS(A), B) will be reduced to a single constant: B-A

// a single node with the value -X
// PLUS(MINUS(A), B) will be reduced to a single constant: B-A
bool AR_EXP_ReduceToScalar
(
	AR_ExpNode *root,
	bool reduce_params,
	SIValue *val
) {
	if(val != NULL) {
		*val = SI_NullVal();
	}

	if(root->type == AR_EXP_OPERAND) {
		// in runtime, parameters are set so they can be evaluated
		if(reduce_params && AR_EXP_IsParameter(root)) {
			SIValue v = AR_EXP_Evaluate(root, NULL);
			if(val != NULL) {
				*val = v;
			}
			return true;
		}
		if(AR_EXP_IsConstant(root)) {
			// Root is already a constant
			if(val != NULL) *val = root->operand.constant;
			return true;
		}
		// Root is variadic, no way to reduce
		return false;
	} else {
		// root represents an operation
		ASSERT(AR_EXP_IsOperation(root));

		// see if we're able to reduce each child of root
		// if so we'll be able to reduce root
		bool reduce_children = true;
		for(int i = 0; i < root->op.child_count; i++) {
			if(!AR_EXP_ReduceToScalar(root->op.children[i], reduce_params, NULL)) {
				// root reduce is not possible, but continue to reduce every reducable child
				reduce_children = false;
			}
		}

		// can't reduce root as one of its children is not a constant
		if(!reduce_children) {
			return false;
		}

		// all child nodes are constants, make sure function is marked as reducible
		if(!root->op.f->reducible) {
			return false;
		}

		// evaluate function
		SIValue v = AR_EXP_Evaluate(root, NULL);
		if(val != NULL) *val = v;
		if(SIValue_IsNull(v)) {
			return false;
		}

		// reduce