Cppcheck report - Fission: libs/fsAppCore/fsCRunningOrderGrammar.cpp

#include "fsCRunningOrderGrammar.h"

#include <fsCore/src/debug/fsAssert.h>

// Port of gui-grammar-tool/src/running_order.rs. Kept in lockstep with that
// module and the golden corpus (tests/gui_grammar_golden_corpus/running_order);
// its standalone C++ twin tooling/running_order_resolver.h verifies the same
// contract outside the engine. The fsStr primitives used here (chunk/chomp/
// leadingWhitespaceTrim) are the same ones the GUI grammar parses with.

namespace
{

// --- small fsStr helpers -------------------------------------------------

fsStr subStr(const fsStr& pStr, fsStr::sizeT pStart, fsStr::sizeT pLen)
{
	if (pStart >= pStr.dataSizeGet())
	{
		return fsStr();
	}
	const fsStr::sizeT avail = pStr.dataSizeGet() - pStart;
	return fsStr(pStr.utf8Get() + pStart, pLen < avail ? pLen : avail);
}

fsStr trimmed(const fsStr& pStr)
{
	fsStr out = pStr;
	out.leadingWhitespaceTrim();
	out.trailingWhitespaceTrim();
	return out;
}

fsBool isAsciiAlpha(fsChar pC)
{
	return (pC >= 'a' && pC <= 'z') || (pC >= 'A' && pC <= 'Z');
}

fsBool isAsciiDigit(fsChar pC)
{
	return pC >= '0' && pC <= '9';
}

// --- model ---------------------------------------------------------------

struct Tag
{
	enum Kind { eFlavour, eLanguage };
	Kind mKind;
<--- Member variable 'Tag::mKind' has no initializer. [+]
Member variable 'Tag::mKind' has no initializer. Member variables of native types, pointers, or references are left uninitialized when the class is instantiated. That may cause bugs or undefined behavior.
	fsStr mValue;
};

struct DefaultBlock
{
	fsStr mPrefix; // `*` matches every scene
	VarTableMap mConfig;
};

struct Entry
{
	fsStr mName;
	VarTableMap mConfig;
	std::vector<Tag> mExclude;
};

struct RunningOrder
{
	std::vector<DefaultBlock> mDefaults; // definition order
	std::vector<Entry> mEntries;
};

// The scene a `map->X` entry refers to. `.gui` never authors `map->` (it's
// derived on resolve), but parity with the tooling keeps grouping identical.
fsStr sceneNameStripped(const fsStr& pName)
{
	static const fsStr prefix("map->");
	if (pName.find(prefix) == 0)
	{
		return subStr(pName, prefix.dataSizeGet(), pName.dataSizeGet());
	}
	return pName;
}

// The `default <group>` a scene matches, keyed off its name:
//   jig_trees -> jig      (text before the first '_')
//   link1/link5 -> link   (a <word><number> series shares a group)
//   end -> end            (the terminator, its own group)
//   mainGatesRoadUp -> normal (hidden-object catch-all)
// link screens and `end` are deliberately NOT normal, so they neither inherit
// the hidden-object GUI nor get treated as map-first.
fsStr sceneGroup(const fsStr& pName)
{
	const fsStr stripped = sceneNameStripped(pName);

	const fsStr::sizeT underscore = stripped.find('_');
	if (underscore != fsStr::npos)
	{
		// Only an alphabetic prefix is a minigame type (`jig_`, `hog_`…); a
		// numeric/mixed prefix (`01_`) is a sequence number on a hidden-object
		// room, so fall through to the `normal` group.
		const fsStr prefix = subStr(stripped, 0, underscore);
		fsBool allAlpha = !prefix.emptyGet();
		for (fsStr::sizeT i = 0; i < prefix.dataSizeGet(); ++i)
		{
			allAlpha = allAlpha && isAsciiAlpha(prefix[i]);
		}
		if (allAlpha)
		{
			return prefix;
		}
	}
	if (stripped == "end")
	{
		return "end";
	}

	fsStr::sizeT digitPos = fsStr::npos;
	for (fsStr::sizeT i = 0; i < stripped.dataSizeGet(); ++i)
	{
		if (isAsciiDigit(stripped[i]))
		{
			digitPos = i;
			break;
		}
	}
	if (digitPos != fsStr::npos && digitPos > 0)
	{
		const fsStr stem = subStr(stripped, 0, digitPos);
		const fsStr digits = subStr(stripped, digitPos, stripped.dataSizeGet());
		fsBool ok = true;
		for (fsStr::sizeT i = 0; i < stem.dataSizeGet(); ++i)
		{
			ok = ok && isAsciiAlpha(stem[i]);
		}
		for (fsStr::sizeT i = 0; i < digits.dataSizeGet(); ++i)
		{
			ok = ok && isAsciiDigit(digits[i]);
		}
		if (ok)
		{
			return stem;
		}
	}
	return "normal";
}

// --- parsing -------------------------------------------------------------

void skipCommentsAndWhitespace(fsStr& pCursor)
{
	pCursor.leadingWhitespaceTrim();
	while (!pCursor.emptyGet() && '#' == pCursor[0])
	{
		pCursor.chomp("\n");
		pCursor.leadingWhitespaceTrim();
	}
}

// Consume a balanced `{ ... }` block and return its inner text. Precondition
// (after comment/ws skip): the cursor is on '{'. Brace-counts so nested braces
// are respected (mirrors fsIGuiComponent's include-contiguity scan).
fsStr readBlockContents(fsStr& pCursor)
{
	skipCommentsAndWhitespace(pCursor);
	if (pCursor.emptyGet() || '{' != pCursor[0])
	{
		return fsStr();
	}

	fsS32 depth = 1;
	fsStr::sizeT i = 1;
	while (depth > 0 && i < pCursor.dataSizeGet())
	{
		const fsChar c = pCursor[i];
		if ('{' == c)
		{
			++depth;
		}
		else if ('}' == c)
		{
			--depth;
		}
		++i;
	}
	// inner spans [1, i-1): between the opening '{' and the matching '}'.
	const fsStr body = subStr(pCursor, 1, i >= 2 ? i - 2 : 0);
	pCursor.erase(0, i);
	return body;
}

fsBool parseTag(const fsStr& pRaw, Tag& pOut)
{
	static const fsStr flavour("flavour:");
	static const fsStr lang("lang:");
	if (pRaw.find(flavour) == 0)
	{
		pOut.mKind = Tag::eFlavour;
		pOut.mValue = subStr(pRaw, flavour.dataSizeGet(), pRaw.dataSizeGet());
		return true;
	}
	if (pRaw.find(lang) == 0)
	{
		pOut.mKind = Tag::eLanguage;
		pOut.mValue = subStr(pRaw, lang.dataSizeGet(), pRaw.dataSizeGet());
		return true;
	}
	fsAssert(false, "running order exclude tag has unknown namespace (expected flavour:*/lang:*): %s",
	         pRaw.utf8Get());
	return false;
}

// Parse a `{ ... }` body into (config, exclude): `key: value` lines, `[...]`
// list literals (only `exclude` is lifted out as tags; any other list kept as
// a bracketed string), quoted or bare values, last-set-wins on dup keys.
void parseBlockBody(const fsStr& pBodyText, VarTableMap& pConfig, std::vector<Tag>& pExclude)
{
	fsStr cursor = pBodyText;
	for (;;)
	{
		skipCommentsAndWhitespace(cursor);
		if (cursor.emptyGet())
		{
			break;
		}

		const fsStr key = trimmed(cursor.chomp(":"));
		if (key.emptyGet())
		{
			break;
		}
		cursor.leadingWhitespaceTrim();

		if (!cursor.emptyGet() && '[' == cursor[0])
		{
			cursor.erase(0, 1);
			fsStr inner = cursor.chomp("]");
			if (key == "exclude")
			{
				while (!inner.emptyGet())
				{
					const fsStr part = trimmed(inner.chomp(","));
					Tag tag;
					if (!part.emptyGet() && parseTag(part, tag))
					{
						pExclude.push_back(tag);
					}
				}
			}
			else
			{
				pConfig[key] = fsStr("[") + trimmed(inner) + fsStr("]");
			}
		}
		else
		{
			// chunk() reads a quoted "..." verbatim (backslash paths survive)
			// or a bare leaf up to whitespace.
			pConfig[key] = cursor.chunk();
		}
	}
}

RunningOrder parseGui(const fsStr& pText)
{
	fsStr cursor = pText;
	RunningOrder order;

	for (;;)
	{
		skipCommentsAndWhitespace(cursor);
		if (cursor.emptyGet())
		{
			break;
		}

		const fsStr token = cursor.chunk();
		if (token.emptyGet())
		{
			break;
		}

		if (token == "default")
		{
			DefaultBlock block;
			block.mPrefix = cursor.chunk();
			const fsStr body = readBlockContents(cursor);
			std::vector<Tag> exclude;
			parseBlockBody(body, block.mConfig, exclude);
			fsAssert(exclude.empty(), "running order `default` block may not carry an exclude tag");
			order.mDefaults.push_back(block);
			continue;
		}

		// Entry. Names are plain - `map->` is derived at resolve time, never
		// authored - so a bare scene name is all we read. A block is optional.
		Entry entry;
		entry.mName = token;
		skipCommentsAndWhitespace(cursor);
		if (!cursor.emptyGet() && '{' == cursor[0])
		{
			const fsStr body = readBlockContents(cursor);
			parseBlockBody(body, entry.mConfig, entry.mExclude);
		}
		order.mEntries.push_back(entry);
	}

	return order;
}

// --- resolving -----------------------------------------------------------

fsBool isExcluded(const Entry& pEntry, const fsStr& pFlavour, const fsStr& pLanguage)
{
	for (const Tag& tag : pEntry.mExclude)<--- Consider using std::any_of algorithm instead of a raw loop.
	{
		if (Tag::eFlavour == tag.mKind && tag.mValue == pFlavour)
		{
			return true;
		}
		if (Tag::eLanguage == tag.mKind && tag.mValue == pLanguage)
		{
			return true;
		}
	}
	return false;
}

} // namespace

std::vector<fsCRunningOrderGrammar::ResolvedScene> fsCRunningOrderGrammar::resolve(const fsStr& pText,
                                                                                  const fsStr& pFlavour,
                                                                                  const fsStr& pLanguage)
{
	const RunningOrder order = parseGui(pText);

	std::vector<ResolvedScene> resolved;
	fsBool seenFirstHog = false;

	for (const Entry& entry : order.mEntries)
	{
		if (isExcluded(entry, pFlavour, pLanguage))
		{
			continue;
		}

		ResolvedScene scene;
		scene.mName = entry.mName;
		const fsStr group = sceneGroup(entry.mName);

		for (const DefaultBlock& def : order.mDefaults)
		{
			if (def.mPrefix == "*" || def.mPrefix == group)
			{
				for (const auto& kv : def.mConfig)
				{
					scene.mConfig[kv.first] = kv.second;
				}
			}
		}
		for (const auto& kv : entry.mConfig)
		{
			scene.mConfig[kv.first] = kv.second;
		}

		// A map-routed HOG room is a hidden-object scene (declares numHogItems)
		// in the `normal` group - prefix-less or sequence-numbered (`01_`). Map-
		// first for every such room except the first in the sequence. Excluded:
		// minigames/`barPuzzles`/link/end (no numHogItems) and alphabetically-
		// prefixed direct-access HOGs like `hog_rangerBedroom` (not in `normal`).
		const fsBool isHogRoom =
			group == "normal" && scene.mConfig.find("numHogItems") != scene.mConfig.end();
		scene.mGoesToMap = isHogRoom && seenFirstHog;
		if (isHogRoom)
		{
			seenFirstHog = true;
		}

		resolved.push_back(scene);
	}

	return resolved;
}