Method ExpandExpression

source/script_expression.cpp:53–1527

__forceinline: Decided against it for this function because although it's only called by one caller, testing shows that it wastes stack space (room for its automatic variables would be unconditionally reserved in the stack of its caller). Also, the performance benefit of inlining this is too slight. Here's a simple way to verify wasted stack space in a caller that calls an inlined function: DWORD

//    _asm mov stack, esp
//    MsgBox(stack);
LPTSTR Line::ExpandExpression(int aArgIndex, ResultType &aResult, ResultToken *aResultToken
		, LPTSTR &aTarget, LPTSTR &aDerefBuf, size_t &aDerefBufSize, LPTSTR aArgDeref[], size_t aExtraSize)
// Caller should ignore aResult unless this function returns NULL.
// Returns a pointer to this expression's result, which can be one of the following:
// 1) NULL, in which case aResult will be either FAIL or EARLY_EXIT to indicate the means by which the current
//    quasi-thread was terminated as a result of a function call.
// 2) The constant empty string (""), in which case we do not alter aTarget for our caller.
// 3) Some persistent location not in aDerefBuf, namely the mContents of a variable or a literal string/number,
//    such as a function-call that returns "abc", 123, or a variable.
// 4) At position aTarget inside aDerefBuf (note that aDerefBuf might have been reallocated by us).
// aTarget is left unchanged except in case #4, in which case aTarget has been adjusted to the position after our
// result-string's terminator.  In addition, in case #4, aDerefBuf, aDerefBufSize, and aArgDeref[] have been adjusted
// for our caller if aDerefBuf was too small and needed to be enlarged.
//
// Thanks to Joost Mulders for providing the expression evaluation code upon which this function is based.
{
	LPTSTR target = aTarget; // "target" is used to track our usage (current position) within the aTarget buffer.

	// The following must be defined early so that to_free_count is initialized and the array is guaranteed to be
	// "in scope" in case of early "goto" (goto substantially boosts performance and reduces code size here).
	ExprTokenType **to_free = (ExprTokenType **)_alloca(mArg[aArgIndex].max_alloc * sizeof(ExprTokenType *));
	int to_free_count = 0; // The actual number of items in use in the above array.
	LPTSTR result_to_return = _T(""); // By contrast, NULL is used to tell the caller to abort the current thread.
	LPCTSTR error_msg = ERR_EXPR_EVAL, error_info = _T("");
	ExprTokenType *error_value;
	Var *output_var = (mActionType == ACT_ASSIGNEXPR) ? VAR(mArg[0]) : NULL; // Resolve early because it's similar in usage/scope to the above.

	ExprTokenType **stack = (ExprTokenType **)_alloca(mArg[aArgIndex].max_stack * sizeof(ExprTokenType *));
	int stack_count = 0;
	ExprTokenType *&postfix = mArg[aArgIndex].postfix;

	///////////////////////////////
	// EVALUATE POSTFIX EXPRESSION
	///////////////////////////////
	int i, delta;
	SymbolType right_is_number, left_is_number, right_is_pure_number, left_is_pure_number, result_symbol;
	double right_double, left_double;
	__int64 right_int64, left_int64;
	LPTSTR right_string, left_string;
	size_t right_length, left_length;
	TCHAR left_buf[max(MAX_NUMBER_SIZE, _f_retval_buf_size)];
	TCHAR right_buf[MAX_NUMBER_SIZE];
	LPTSTR result; // "result" is used for return values and also the final result.
	VarSizeType result_length;
	size_t result_size, alloca_usage = 0; // v1.0.45: Track amount of alloca mem to avoid stress on stack from extreme expressions (mostly theoretical).
	BOOL done, done_and_have_an_output_var, left_branch_is_true
		, left_was_negative, is_pre_op; // BOOL vs. bool benchmarks slightly faster, and is slightly smaller in code size (or maybe it's cp1's int vs. char that shrunk it).
	ExprTokenType *this_postfix, *p_postfix;
	Var *sym_assign_var, *temp_var;

	// v1.0.44.06: EXPR_SMALL_MEM_LIMIT is the means by which _alloca() is used to boost performance a
	// little by avoiding the overhead of malloc+free for small strings.  The limit should be something
	// small enough that the chance that even 10 of them would cause stack overflow is vanishingly small.
	#define EXPR_SMALL_MEM_LIMIT 4097 // The maximum size allowed for an item to qualify for alloca.
	#define EXPR_ALLOCA_LIMIT 40000  // The maximum amount of alloca memory for all items.  v1.0.45: An extra precaution against stack stress in extreme/theoretical cases.
	#define EXPR_IS_DONE (!stack_count && this_postfix[1].symbol == SYM_INVALID) // True if we've used up the last of the operators & operands.  Non-zero stack_count combined with SYM_INVALID would indicate an error (an exception will be thrown later, so don't take any shortcuts).

	// For each item in the postfix array: if it's an operand, push it onto stack; if it's an operator or