Method ExpandArgs

source/script_expression.cpp:2036–2303

ResultType Line::ExpandArgs(ResultToken *aResultTokens)
// aResultTokens is non-null if the caller wants results that aren't strings.  Caller is
// responsible for freeing the tokens either after successful use or before aborting, on failure.
// Returns OK, FAIL, or EARLY_EXIT.  EARLY_EXIT occurs when a function-call inside an expression
// used the EXIT command to terminate the thread.
{
	// The counterpart of sArgDeref kept on our stack to protect it from recursion caused by
	// the calling of functions in the script:
	LPTSTR arg_deref[MAX_ARGS];
	int i;

	// Make two passes through this line's arg list.  This is done because the performance of
	// realloc() is worse than doing a free() and malloc() because the former often does a memcpy()
	// in addition to the latter's steps.  In addition, realloc() as much as doubles the memory
	// load on the system during the brief time that both the old and the new blocks of memory exist.
	// First pass: determine how much space will be needed to do all the args and allocate
	// more memory if needed.  Second pass: dereference the args into the buffer.

	// First pass. It takes into account the same things as 2nd pass.
	size_t space_needed = GetExpandedArgSize();
	if (space_needed == VARSIZE_ERROR)
		return FAIL;  // It will have already displayed the error.

	// Only allocate the buf at the last possible moment, when it's sure the buffer will be used
	// (improves performance when only a short script with no derefs is being run):
	if (space_needed > sDerefBufSize)
	{
		// KNOWN LIMITATION: The memory utilization of *recursive* user-defined functions is rather high because
		// of the size of DEREF_BUF_EXPAND_INCREMENT, which is used to create a new deref buffer for each layer
		// of recursion.  Due to limited stack space, the limit of recursion is about 300 to 800 layers depending
		// on the build.  For 800 layers on Unicode, about 25MB (32KB*800) of memory would be temporarily allocated,
		// which in a worst-case scenario would cause swapping and kill performance.  However, on most systems it
		// wouldn't be an issue, and the bigger problem is that recursion may be limited to ~300 layers.
		size_t increments_needed = space_needed / DEREF_BUF_EXPAND_INCREMENT;
		if (space_needed % DEREF_BUF_EXPAND_INCREMENT)  // Need one more if above division truncated it.
			++increments_needed;
		size_t new_buf_size = increments_needed * DEREF_BUF_EXPAND_INCREMENT;
		if (sDerefBuf)
		{
			// Do a free() and malloc(), which should be far more efficient than realloc(), especially if
			// there is a large amount of memory involved here (realloc's ability to do an in-place resize
			// might be unlikely for anything other than small blocks; see compiler's realloc.c):
			free(sDerefBuf);
			if (sDerefBufSize > LARGE_DEREF_BUF_SIZE)
				--sLargeDerefBufs;
		}
		if (   !(sDerefBuf = tmalloc(new_buf_size))   )
		{
			// Error msg was formerly: "Ran out of memory while attempting to dereference this line's parameters."
			sDerefBufSize = 0;  // Reset so that it can make another attempt, possibly smaller, next time.
			return MemoryError();
		}
		sDerefBufSize = new_buf_size;
		if (sDerefBufSize > LARGE_DEREF_BUF_SIZE)
			++sLargeDerefBufs;
	}

	// Always init our_buf_marker even if zero iterations, because we want to enforce