Method PreparseCommands

source/script.cpp:7478–7671

Line *Script::PreparseCommands(Line *aStartingLine)
// Preparse any commands which might rely on blocks having been fully preparsed,
// such as any command which has a jump target (label).
// Also perform some late-stage optimizations and validation.
{
	for (Line *line = aStartingLine; line; line = line->mNextLine)
	{
		LPTSTR line_raw_arg1 = LINE_RAW_ARG1; // Resolve only once to help reduce code size.
		LPTSTR line_raw_arg2 = LINE_RAW_ARG2; //
		
		switch (line->mActionType)
		{
		case ACT_BLOCK_BEGIN:
			if (line->mAttribute) // This is the opening brace of a function definition.
				g->CurrentFunc = (UserFunc *)line->mAttribute; // Must be set only for the above condition because functions can of course contain types of blocks other than the function's own block.
			break;
		case ACT_BLOCK_END:
			if (line->mAttribute) // This is the closing brace of a function definition.
			{
				auto &func = *(UserFunc *)line->mAttribute;

				g->CurrentFunc = func.mOuterFunc;

				Line *block_begin = line->mParentLine;
				Line *parent = block_begin->mParentLine;

				if (func.mIsFuncExpression // =>
					&& block_begin->mParentLine
					&& block_begin->mParentLine->mActionType != ACT_BLOCK_BEGIN)
				{
					if (line->mNextLine->mActionType == ACT_BLOCK_BEGIN) // It could only be a fat arrow block-begin under these conditions.
						// There's another =>function after this one (defined within the same
						// expression), so just continue until the last =>function is found.
						continue;
					// This fat arrow function's parent line is a statement with a single-line
					// action, but that action is currently separated from its parent by one or
					// more fat arrow functions.  It won't work that way because If/Else/Loop/etc.
					// all skip an initial ACT_BLOCK_BEGIN (to avoid an extra ExecUntil call),
					// which would result in executing the function's body instead of skipping it.
					Line *body = line->mNextLine;
				#ifdef KEEP_FAT_ARROW_FUNCTIONS_IN_LINE_LIST // Currently unused.
					block_begin = parent->mNextLine; // In case there are multiple fat arrow functions on one line.
					Line *after_body = parent->mRelatedLine;
					Line *body_end = after_body->mPrevLine; // In case body is multiple lines (such as a nested IF or LOOP).
					// Swap the statement body and fat arrow functions around to make it work:
					parent   ->mNextLine = body       , body       ->mPrevLine = parent;
					body_end ->mNextLine = block_begin, block_begin->mPrevLine = body_end;
					line     ->mNextLine = after_body , after_body ->mPrevLine = line;
				#else
					// Remove the fat arrow functions to allow the correct body to execute.
					// This relies on there being no need for the fat arrow functions to
					// remain in the Line list after this point (so for instance, there's
					// no possibility of setting a breakpoint in one of these functions).
					parent->mNextLine = body, body->mPrevLine = parent;
				#endif
				}
				else if (parent && parent->mActionType != ACT_BLOCK_BEGIN)
				{