scummvm/engines/glk/adrift/scparser.cpp

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#include "glk/adrift/scare.h"
#include "glk/adrift/scprotos.h"
#include "glk/adrift/scgamest.h"
#include "glk/jumps.h"

namespace Glk {
namespace Adrift {

/*
 * Module notes:
 *
 * o Some of the "finer" points of pattern matching in relation to "*"
 *   wildcards, and %text%, are unknown.
 *
 * o The inclusion of part or all of prefixes in %character% and %object%
 *   matching may be right; then again, it may not be.
 */

/* Assorted definitions and constants. */
static const sc_char NUL = '\0';
static const sc_char MINUS = '-';
static const sc_char PLUS = '+';
static const sc_char PERCENT = '%';
static const sc_char *const WHITESPACE = "\t\n\v\f\r ";

/* Pattern matching trace flag. */
static sc_bool uip_trace = FALSE;

/* Enumeration of tokens.  TOK_NONE represents a non-occurring token. */
enum sc_uip_tok_t {
	TOK_NONE = 0,
	TOK_CHOICE, TOK_CHOICE_END, TOK_OPTIONAL, TOK_OPTIONAL_END,
	TOK_ALTERNATES_SEPARATOR,
	TOK_WILDCARD, TOK_WHITESPACE, TOK_WORD, TOK_VARIABLE,
	TOK_CHARACTER_REFERENCE, TOK_OBJECT_REFERENCE, TOK_NUMBER_REFERENCE,
	TOK_TEXT_REFERENCE, TOK_EOS
};

/*
 * Small table tying token strings to tokens.  Anything not whitespace and
 * not caught by the table is a plain TOK_WORD.
 */
struct sc_uip_token_entry_t {
	const sc_char *const name;
	const sc_int length;
	const sc_uip_tok_t token;
};

static const sc_uip_token_entry_t UIP_TOKENS[] = {
	{"[", 1, TOK_CHOICE}, {"]", 1, TOK_CHOICE_END},
	{"{", 1, TOK_OPTIONAL}, {"}", 1, TOK_OPTIONAL_END},
	{"/", 1, TOK_ALTERNATES_SEPARATOR},
	{"*", 1, TOK_WILDCARD},
	{"%character%", 11, TOK_CHARACTER_REFERENCE},
	{"%object%", 8, TOK_OBJECT_REFERENCE},
	{"%number%", 8, TOK_NUMBER_REFERENCE},
	{"%text%", 6, TOK_TEXT_REFERENCE},
	{nullptr, 0, TOK_NONE}
};


/*
 * Tokenizer variables.  The temporary is used for keeping word token values.
 * For improved performance, we'll set it to indicate a static buffer if
 * short enough, otherwise it's allocated.
 */
static const sc_char *uip_pattern = nullptr;
static sc_int uip_index = 0;
static const sc_char *uip_token_value;
enum { UIP_ALLOCATION_AVOIDANCE_SIZE = 128 };
static sc_char uip_static_temporary[UIP_ALLOCATION_AVOIDANCE_SIZE];
static sc_char *uip_temporary = nullptr;


/*
 * uip_tokenize_start()
 * uip_tokenize_end()
 *
 * Start and wrap up pattern string tokenization.
 */
static void uip_tokenize_start(const sc_char *pattern) {
	static sc_bool initialized = FALSE;
	sc_int required;

	/* On first call only, verify the string lengths in the table. */
	if (!initialized) {
		const sc_uip_token_entry_t *entry;

		/* Compare table lengths with string lengths. */
		for (entry = UIP_TOKENS; entry->name; entry++) {
			if (entry->length != (sc_int) strlen(entry->name)) {
				sc_fatal("uip_tokenize_start:"
				         " table string length is wrong for \"%s\"\n",
				         entry->name);
			}
		}

		initialized = TRUE;
	}

	/* Save pattern, and restart index. */
	uip_pattern = pattern;
	uip_index = 0;

	/* Set up temporary; static if long enough, otherwise allocated. */
	required = strlen(pattern) + 1;
	uip_temporary = (required > UIP_ALLOCATION_AVOIDANCE_SIZE)
	                ? (sc_char *)sc_malloc(required) : uip_static_temporary;
}

static void uip_tokenize_end(void) {
	/* Deallocate temporary if required, and clear pattern and index. */
	if (uip_temporary != uip_static_temporary)
		sc_free(uip_temporary);
	uip_temporary = nullptr;
	uip_pattern = nullptr;
	uip_index = 0;
}


/*
 * uip_next_token()
 *
 * Return the next token from the current pattern.
 */
static sc_uip_tok_t uip_next_token(void) {
	const sc_uip_token_entry_t *entry;
	sc_char close;
	assert(uip_pattern);

	/* Get next character, return EOS if at pattern end. */
	if (uip_pattern[uip_index] == NUL) {
		uip_token_value = nullptr;
		return TOK_EOS;
	}

	/* If whitespace, skip it, then return a whitespace token. */
	if (sc_isspace(uip_pattern[uip_index])) {
		uip_index++;
		while (sc_isspace(uip_pattern[uip_index])
		        && uip_pattern[uip_index] != NUL)
			uip_index++;
		uip_token_value = nullptr;
		return TOK_WHITESPACE;
	}

	/* Search the table for matching strings. */
	for (entry = UIP_TOKENS; entry->name; entry++) {
		if (strncmp(uip_pattern + uip_index, entry->name, entry->length) == 0)
			break;
	}
	if (entry->name) {
		/* Advance over string, and return token. */
		uip_index += entry->length;
		uip_token_value = nullptr;
		return entry->token;
	}

	/*
	 * Search for a non-special variable reference.  This is apparently an
	 * Adrift extension to the standard pattern match, allowing %user_var% to
	 * be used in patterns.  If found, return a variable with the name as the
	 * token value.  We can't interpolate the value into the string either
	 * here or earlier, so we have to save the variable's name, and retrieve
	 * it when we come to try the match.
	 */
	if (sscanf(uip_pattern + uip_index, "%%%[^%]%c", uip_temporary, &close) == 2
	        && close == PERCENT) {
		uip_index += strlen(uip_temporary) + 2;
		uip_token_value = uip_temporary;
		return TOK_VARIABLE;
	}

	/*
	 * Return a word.  This is a contiguous run of non-pattern-special, non-
	 * whitespace, non-percent characters
	 */
	sscanf(uip_pattern + uip_index, "%[^][/{}*% \f\n\r\t\v]", uip_temporary);
	uip_token_value = uip_temporary;
	uip_index += strlen(uip_temporary);
	return TOK_WORD;
}


/*
 * uip_current_token_value()
 *
 * Return the token value of the current token.  It is an error to call
 * here if the current token is not a TOK_WORD or TOK_VARIABLE.
 */
static const sc_char *uip_current_token_value(void) {
	/* If the token value is NULL, the current token isn't a word. */
	if (!uip_token_value) {
		sc_fatal("uip_current_token_value:"
		         " attempt to take undefined token value\n");
	}

	/* Return value. */
	return uip_token_value;
}


/*
 * Parsed pattern tree node definition.   The tree is a left child, right
 * sibling representation, with token type, and word at nodes of type TOK_WORD.
 * NODE_UNUSED must be zero to ensure that the statically allocated array that
 * forms the node pool appears initially as containing only unused nodes.
 */
enum sc_pttype_t {
	NODE_UNUSED = 0,
	NODE_CHOICE, NODE_OPTIONAL, NODE_WILDCARD, NODE_WHITESPACE,
	NODE_CHARACTER_REFERENCE, NODE_OBJECT_REFERENCE, NODE_TEXT_REFERENCE,
	NODE_NUMBER_REFERENCE, NODE_WORD, NODE_VARIABLE, NODE_LIST, NODE_EOS
};
struct sc_ptnode_s {
	struct sc_ptnode_s *left_child;
	struct sc_ptnode_s *right_sibling;

	sc_pttype_t type;
	sc_char *word;
	sc_bool is_allocated;
};
typedef sc_ptnode_s sc_ptnode_t;
typedef sc_ptnode_t *sc_ptnoderef_t;

/* Predictive parser lookahead token. */
static sc_uip_tok_t uip_parse_lookahead = TOK_NONE;

/* Parse tree for cleanup, and forward declaration of pattern list parser. */
static sc_ptnoderef_t uip_parse_tree = nullptr;

/*
 * Pool of statically allocated nodes, for faster allocations.  Nodes are
 * first allocated from here, then by straight malloc() if this pool is empty.
 * An average game's peak node allocation seems to be around 40-50 nodes, so
 * allowing 128 here should be plenty.
 */
enum { UIP_NODE_POOL_SIZE = 128 };
static sc_ptnode_t uip_node_pool[UIP_NODE_POOL_SIZE];
static sc_int uip_node_pool_cursor = 0;
static sc_int uip_node_pool_available = UIP_NODE_POOL_SIZE;

/*
 * Words held at nodes are usually short (15 chars covers 95% of English), so
 * to avoid a lot of small allocations we use a pool of short strings, used
 * first, then by straight malloc() should the pool empty.
 */
enum { UIP_WORD_POOL_SIZE = 64, UIP_SHORT_WORD_SIZE = 16 };
struct sc_ptshortword_t {
	sc_bool is_in_use;
	sc_char word[UIP_SHORT_WORD_SIZE];
};
typedef sc_ptshortword_t *sc_ptshortwordref_t;
static sc_ptshortword_t uip_word_pool[UIP_WORD_POOL_SIZE];
static sc_int uip_word_pool_cursor = 0;
static sc_int uip_word_pool_available = UIP_WORD_POOL_SIZE;

// Forward declarations
static void uip_parse_list(CONTEXT, sc_ptnoderef_t list);


/*
 * uip_parse_matc
 *
 * Match a token to the lookahead, then advance lookahead.
 */
static void uip_parse_match(CONTEXT, sc_uip_tok_t token) {
	if (uip_parse_lookahead == token)
		uip_parse_lookahead = uip_next_token();
	else {
		/* Syntax error. */
		sc_error("uip_parse_match: syntax error, expected %ld, got %ld\n",
		         (sc_int) uip_parse_lookahead, (sc_int) token);
		LONG_JUMP;
	}
}


/*
 * uip_new_word()
 *
 * Return a string containing a copy of the word.  Uses a ring allocator to
 * allocate initially from static storage, for performance.  If this is
 * exhausted, backs off to standard allocation.
 */
static sc_char *uip_new_word(const sc_char *word) {
	sc_int required;

	/*
	 * Unless the pool is empty, search forwards from the next cursor position
	 * until an unused slot is found, or until the index wraps to the cursor.
	 */
	required = strlen(word) + 1;
	if (uip_word_pool_available > 0 && required <= UIP_SHORT_WORD_SIZE) {
		sc_int index_;
		sc_ptshortwordref_t shortword;

		index_ = (uip_word_pool_cursor + 1) % UIP_WORD_POOL_SIZE;
		while (index_ != uip_word_pool_cursor) {
			if (!uip_word_pool[index_].is_in_use)
				break;
			index_ = (index_ + 1) % UIP_WORD_POOL_SIZE;
		}

		if (uip_word_pool[index_].is_in_use)
			sc_fatal("uip_new_word: no free slot found in the words pool\n");

		/* Use the slot and update the pool cursor and free count. */
		shortword = uip_word_pool + index_;
		strcpy(shortword->word, word);
		shortword->is_in_use = TRUE;

		uip_word_pool_cursor = index_;
		uip_word_pool_available--;

		/* Return the address of the copied string. */
		return shortword->word;
	} else {
		sc_char *word_copy;

		/* Fall back to less efficient allocations. */
		word_copy = (sc_char *)sc_malloc(required);
		strcpy(word_copy, word);
		return word_copy;
	}
}


/*
 * uip_free_word()
 *
 * If the word was allocated, free its memory; if not, find its short word
 * pool entry and return it to the pool.
 */
static void uip_free_word(sc_char *word) {
	const sc_char *first_in_pool, *last_in_pool;

	/* Obtain the range of valid addresses for words from the word pool. */
	first_in_pool = uip_word_pool[0].word;
	last_in_pool = uip_word_pool[UIP_WORD_POOL_SIZE - 1].word;

	/* If from the pool, mark the entry as no longer in use, otherwise free. */
	if (word >= first_in_pool && word <= last_in_pool) {
		sc_int index_;
		sc_ptshortwordref_t shortword;

		/*
		 * Calculate the index to the word pool entry from which this short
		 * word was allocated.
		 */
		index_ = (word - first_in_pool) / sizeof(uip_word_pool[0]);
		shortword = uip_word_pool + index_;
		assert(shortword->word == word);

		shortword->is_in_use = FALSE;
		uip_word_pool_available++;
	} else
		sc_free(word);
}


/*
 * uip_new_node()
 *
 * Create a new node, populated with an initial type.  Uses a ring allocator
 * to allocate initially from static storage, for performance.  If this is
 * exhausted, backs off to standard allocation.
 */
static sc_ptnoderef_t uip_new_node(sc_pttype_t type) {
	sc_ptnoderef_t node;

	/*
	 * Unless the pool is empty, search forwards from the next cursor position
	 * until an unused slot is found, or until the index wraps to the cursor.
	 */
	if (uip_node_pool_available > 0) {
		sc_int index_;

		index_ = (uip_node_pool_cursor + 1) % UIP_NODE_POOL_SIZE;
		while (index_ != uip_node_pool_cursor) {
			if (uip_node_pool[index_].type == NODE_UNUSED)
				break;
			index_ = (index_ + 1) % UIP_NODE_POOL_SIZE;
		}

		if (uip_node_pool[index_].type != NODE_UNUSED)
			sc_fatal("uip_new_node: no free slot found in the nodes pool\n");

		/* Use the slot and update the pool cursor and free count. */
		node = uip_node_pool + index_;
		node->is_allocated = FALSE;

		uip_node_pool_cursor = index_;
		uip_node_pool_available--;
	} else {
		/* Fall back to less efficient allocations. */
		node = (sc_ptnoderef_t)sc_malloc(sizeof(*node));
		node->is_allocated = TRUE;
	}

	/* Fill in the remaining fields and return the new node. */
	node->left_child = nullptr;
	node->right_sibling = nullptr;
	node->type = type;
	node->word = nullptr;

	return node;
}


/*
 * uip_destroy_node()
 *
 * Destroy a node, and any allocated word memory.  If the node was allocated,
 * free its memory; if not, return it to the pool.
 */
static void uip_destroy_node(sc_ptnoderef_t node) {
	/* Free any word contained at this node. */
	if (node->word)
		uip_free_word(node->word);

	/*
	 * If the node was allocated, poison memory and free it.  If it came from
	 * the node pool, set it to unused and update the availability count for
	 * the pool.
	 */
	if (node->is_allocated) {
		memset(node, 0xaa, sizeof(*node));
		sc_free(node);
	} else {
		node->type = NODE_UNUSED;
		uip_node_pool_available++;
	}
}


/*
 * uip_parse_new_list()
 * uip_parse_alternatives()
 *
 * Parse a set of .../.../... alternatives for choices and optionals.  The
 * first function is a helper, returning a newly constructed parsed list.
 */
static sc_ptnoderef_t uip_parse_new_list(CONTEXT) {
	sc_ptnoderef_t list;

	/* Create a new list node, parse into it, and return it. */
	list = uip_new_node(NODE_LIST);
	R0CALL1(uip_parse_list, list);
	return list;
}

static void uip_parse_alternatives(CONTEXT, sc_ptnoderef_t node) {
	sc_ptnoderef_t child;

	/* Parse initial alternative, then add other listed alternatives. */
	FUNC0(uip_parse_new_list, node->left_child);
	child = node->left_child;
	while (uip_parse_lookahead == TOK_ALTERNATES_SEPARATOR) {
		CALL1(uip_parse_match, TOK_ALTERNATES_SEPARATOR);
		FUNC0(uip_parse_new_list, child->right_sibling);
		child = child->right_sibling;
	}
}


/*
 * uip_parse_element()
 *
 * Parse a single pattern element.
 */
static sc_ptnoderef_t uip_parse_element(CONTEXT) {
	sc_ptnoderef_t node = nullptr;
	sc_uip_tok_t token;

	/* Handle pattern element based on lookahead token. */
	switch (uip_parse_lookahead) {
	case TOK_WHITESPACE:
		R0CALL1(uip_parse_match, TOK_WHITESPACE);
		node = uip_new_node(NODE_WHITESPACE);
		break;

	case TOK_CHOICE:
		/* Parse a [...[/.../...]] choice. */
		R0CALL1(uip_parse_match, TOK_CHOICE);
		node = uip_new_node(NODE_CHOICE);
		R0CALL1(uip_parse_alternatives, node);
		R0CALL1(uip_parse_match, TOK_CHOICE_END);
		break;

	case TOK_OPTIONAL:
		/* Parse a {...[/.../...]} optional element. */
		R0CALL1(uip_parse_match, TOK_OPTIONAL);
		node = uip_new_node(NODE_OPTIONAL);
		R0CALL1(uip_parse_alternatives, node);
		R0CALL1(uip_parse_match, TOK_OPTIONAL_END);
		break;

	case TOK_WILDCARD:
	case TOK_CHARACTER_REFERENCE:
	case TOK_OBJECT_REFERENCE:
	case TOK_NUMBER_REFERENCE:
	case TOK_TEXT_REFERENCE:
		/* Parse %mumble% references and * wildcards. */
		token = uip_parse_lookahead;
		R0CALL1(uip_parse_match, token);
		switch (token) {
		case TOK_WILDCARD:
			node = uip_new_node(NODE_WILDCARD);
			break;
		case TOK_CHARACTER_REFERENCE:
			node = uip_new_node(NODE_CHARACTER_REFERENCE);
			break;
		case TOK_OBJECT_REFERENCE:
			node = uip_new_node(NODE_OBJECT_REFERENCE);
			break;
		case TOK_NUMBER_REFERENCE:
			node = uip_new_node(NODE_NUMBER_REFERENCE);
			break;
		case TOK_TEXT_REFERENCE:
			node = uip_new_node(NODE_TEXT_REFERENCE);
			break;
		default:
			sc_fatal("uip_parse_element: invalid token, %ld\n", (sc_int) token);
		}
		break;

	case TOK_WORD: {
		const sc_char *token_value;
		sc_char *word;

		/* Take a copy of the token's word value. */
		token_value = uip_current_token_value();
		word = uip_new_word(token_value);

		/* Store details in a word node. */
		R0CALL1(uip_parse_match, TOK_WORD);
		node = uip_new_node(NODE_WORD);
		node->word = word;
		break;
	}

	case TOK_VARIABLE: {
		const sc_char *token_value;
		sc_char *name;

		/* Take a copy of the token's variable name value. */
		token_value = uip_current_token_value();
		name = uip_new_word(token_value);

		/* Store details in a variable node, overloading word. */
		R0CALL1(uip_parse_match, TOK_VARIABLE);
		node = uip_new_node(NODE_VARIABLE);
		node->word = name;
		break;
	}

	default:
		/* Syntax error. */
		sc_error("uip_parse_element: syntax error,"
		         " unexpected token, %ld\n", (sc_int) uip_parse_lookahead);
		LONG_JUMP0;
	}

	/* Return the newly created node. */
	assert(node);
	return node;
}


/*
 * uip_parse_list()
 *
 * Parse a list of pattern elements.
 */
static void uip_parse_list(CONTEXT, sc_ptnoderef_t list) {
	sc_ptnoderef_t child, node;

	/* Add elements until a list terminator token is encountered. */
	child = list;
	while (TRUE) {
		switch (uip_parse_lookahead) {
		case TOK_CHOICE_END:
		case TOK_OPTIONAL_END:
		case TOK_ALTERNATES_SEPARATOR:
			/* Terminate list building and return. */
			return;

		case TOK_EOS:
			/* Place EOS at the appropriate link and return. */
			node = uip_new_node(NODE_EOS);
			if (child == list)
				child->left_child = node;
			else
				child->right_sibling = node;
			return;

		default:
			/* Add the next node at the appropriate link. */
			FUNC0(uip_parse_element, node);
			if (child == list) {
				child->left_child = node;
				child = child->left_child;
			} else {
				/*
				 * Make a special case of a choice or option next to another
				 * choice or option.  In this case, add an (invented) whitespace
				 * node, to ensure a match with suitable input.
				 */
				if ((child->type == NODE_OPTIONAL || child->type == NODE_CHOICE)
				        && (node->type == NODE_OPTIONAL || node->type == NODE_CHOICE)) {
					sc_ptnoderef_t whitespace;

					/* Interpose invented whitespace. */
					whitespace = uip_new_node(NODE_WHITESPACE);
					child->right_sibling = whitespace;
					child = child->right_sibling;
				}

				child->right_sibling = node;
				child = child->right_sibling;
			}
			continue;
		}
	}
}


/*
 * uip_destroy_tree()
 *
 * Free and destroy a parsed pattern tree.
 */
static void uip_destroy_tree(sc_ptnoderef_t node) {
	if (node) {
		/* Recursively destroy siblings, then left child. */
		uip_destroy_tree(node->right_sibling);
		uip_destroy_tree(node->left_child);

		/* Destroy the node itself. */
		uip_destroy_node(node);
	}
}


/*
 * uip_debug_dump_node()
 * uip_debug_dump()
 *
 * Print out a pattern match tree.
 */
static void uip_debug_dump_node(sc_ptnoderef_t node, sc_int depth) {
	/* End recursion on null node. */
	if (node) {
		sc_int index_;

		sc_trace(" ");
		for (index_ = 0; index_ < depth; index_++)
			sc_trace("  ");

		sc_trace("%p", (void *) node);
		switch (node->type) {
		case NODE_CHOICE:
			sc_trace(", choice");
			break;
		case NODE_OPTIONAL:
			sc_trace(", optional");
			break;
		case NODE_WILDCARD:
			sc_trace(", wildcard");
			break;
		case NODE_WHITESPACE:
			sc_trace(", whitespace");
			break;
		case NODE_CHARACTER_REFERENCE:
			sc_trace(", character");
			break;
		case NODE_OBJECT_REFERENCE:
			sc_trace(", object");
			break;
		case NODE_TEXT_REFERENCE:
			sc_trace(", text");
			break;
		case NODE_NUMBER_REFERENCE:
			sc_trace(", number");
			break;
		case NODE_WORD:
			sc_trace(", word \"%s\"", node->word);
			break;
		case NODE_VARIABLE:
			sc_trace(", variable \"%s\"", node->word);
			break;
		case NODE_LIST:
			sc_trace(", list");
			break;
		case NODE_EOS:
			sc_trace(", <eos>");
			break;
		default:
			sc_trace(", unknown type %ld", (sc_int) node->type);
			break;
		}
		if (node->left_child)
			sc_trace(", left child %p", (void *) node->left_child);
		if (node->right_sibling)
			sc_trace(", right sibling %p", (void *) node->right_sibling);
		sc_trace("\n");

		/* Recursively dump left child, then siblings. */
		uip_debug_dump_node(node->left_child, depth + 1);
		uip_debug_dump_node(node->right_sibling, depth);
	}
}

static void uip_debug_dump(void) {
	sc_trace("UIParser: debug dump follows...\n");
	if (uip_parse_tree) {
		sc_trace("uip_parse_tree = {\n");
		uip_debug_dump_node(uip_parse_tree, 0);
		sc_trace("}\n");
	} else
		sc_trace("uip_parse_tree = (nil)\n");
}


/* String matching variables. */
static const sc_char *uip_string = nullptr;
static sc_int uip_posn = 0;
static sc_gameref_t uip_game = nullptr;

/*
 * uip_match_start()
 * uip_match_end()
 *
 * Set up a string for matching to a pattern tree, and wrap up matching.
 */
static void uip_match_start(const sc_char *string, sc_gameref_t game) {
	/* Save string, and restart index. */
	uip_string = string;
	uip_posn = 0;

	/* Save the game we're working on. */
	uip_game = game;
}

static void uip_match_end(void) {
	/* Clear match target string, and variable set. */
	uip_string = nullptr;
	uip_posn = 0;
	uip_game = nullptr;
}


/*
 * uip_get_game()
 *
 * Safety wrapper to ensure module code sees a valid game when it requires
 * one.
 */
static sc_gameref_t uip_get_game(void) {
	assert(gs_is_game_valid(uip_game));
	return uip_game;
}


/* Forward declaration of low level node matcher. */
static sc_bool uip_match_node(sc_ptnoderef_t node);

/*
 * uip_match_eos()
 * uip_match_word()
 * uip_match_variable()
 * uip_match_whitespace()
 * uip_match_list()
 * uip_match_alternatives()
 * uip_match_choice()
 * uip_match_optional()
 * uip_match_wildcard()
 *
 * Text element and list/choice element match functions.  Return TRUE, and
 * advance position if necessary, on match, FALSE on no match, with position
 * unchanged.
 */
static sc_bool uip_match_eos(void) {
	/* Check that we hit the string's end. */
	return uip_string[uip_posn] == NUL;
}

static sc_bool uip_match_word(sc_ptnoderef_t node) {
	sc_int length;
	const sc_char *word;

	/* Get the word to match. */
	assert(node->word);
	word = node->word;

	/* Compare string text with this node's word, ignore case. */
	length = strlen(word);
	if (sc_strncasecmp(uip_string + uip_posn, word, length) == 0) {
		/* Word match, advance position and return. */
		uip_posn += length;
		return TRUE;
	}

	/* No match. */
	return FALSE;
}

static sc_bool uip_match_variable(sc_ptnoderef_t node) {
	const sc_gameref_t game = uip_get_game();
	const sc_var_setref_t vars = gs_get_vars(game);
	sc_int type;
	sc_vartype_t vt_rvalue;
	const sc_char *name;

	/* Get the variable name to match, from overloaded word. */
	assert(node->word);
	name = node->word;

	/* Get the variable's value. */
	if (var_get(vars, name, &type, &vt_rvalue)) {
		sc_int length;

		/* Compare the value against the current string position. */
		switch (type) {
		case VAR_INTEGER: {
			sc_char value[32];

			/* Compare numeric against the current string position. */
			sprintf(value, "%ld", vt_rvalue.integer);
			length = strlen(value);
			if (strncmp(uip_string + uip_posn, value, length) == 0) {
				/* Integer match, advance position and return. */
				uip_posn += length;
				return TRUE;
			}
			break;
		}

		case VAR_STRING:
			/* Compare string value against the current string position. */
			length = strlen(vt_rvalue.string);
			if (sc_strncasecmp(uip_string + uip_posn,
			                   vt_rvalue.string, length) == 0) {
				/* String match, advance position and return. */
				uip_posn += length;
				return TRUE;
			}
			break;

		default:
			sc_fatal("uip_match_variable: invalid variable type, %ld\n", type);
		}
	}

	/* No match, or no such variable. */
	return FALSE;
}

static sc_bool uip_match_whitespace(void) {
	/* If next character is space, read whitespace and return. */
	if (sc_isspace(uip_string[uip_posn])) {
		/* Space match, advance position and return. */
		while (uip_string[uip_posn] != NUL && sc_isspace(uip_string[uip_posn]))
			uip_posn++;
		return TRUE;
	}

	/*
	 * No match.  However, if we're trying to match space, this is a word
	 * boundary.  So... even though we're not sitting on a space, if the string
	 * prior character is whitespace, "double-match" the space.
	 *
	 * Also, match if we haven't yet matched any text.  In effect, this means
	 * leading spaces on patterns will be ignored.
	 *
	 * TODO Is this what we want to happen?  It seems harmless, even useful.
	 */
	if (uip_posn == 0 || sc_isspace(uip_string[uip_posn - 1]))
		return TRUE;

	/*
	 * And that's not all.  We also want to match whitespace if we're at the end
	 * of a string (another word boundary).  This will permit patterns that end
	 * in optional elements to succeed since options and wildcards always match,
	 * even if to no text.
	 */
	if (uip_string[uip_posn] == NUL)
		return TRUE;

	/* No match.  Really. */
	return FALSE;
}

static sc_bool uip_match_list(sc_ptnoderef_t node) {
	sc_ptnoderef_t child;

	/*
	 * If this list is empty, fail the match.  This special-case handling is
	 * what catches constructed temporary lists for wildcard-like items that
	 * don't actually encompass anything.
	 */
	if (!node->left_child)
		return FALSE;

	/* Match everything listed sequentially. */
	for (child = node->left_child; child; child = child->right_sibling) {
		if (!uip_match_node(child)) {
			/* No match. */
			return FALSE;
		}
	}

	/* Matched. */
	return TRUE;
}

static sc_bool uip_match_alternatives(sc_ptnoderef_t node) {
	sc_ptnoderef_t child;
	sc_int start_posn, extent;
	sc_bool matched;

	/* Note the start position for rewind between tries. */
	start_posn = uip_posn;

	/*
	 * Try a match on each of the children, looking to see which one moves the
	 * position on the furthest.  Match on this one.  This is a "maximal munch".
	 */
	extent = uip_posn;
	matched = FALSE;
	for (child = node->left_child; child; child = child->right_sibling) {
		uip_posn = start_posn;
		if (uip_match_node(child)) {
			/* Matched. */
			matched = TRUE;
			if (uip_posn > extent)
				extent = uip_posn;
		}
	}

	/* If matched, set position to extent; if not, back to start. */
	uip_posn = matched ? extent : start_posn;

	/* Return match status. */
	return matched;
}

static sc_bool uip_match_choice(sc_ptnoderef_t node) {
	/*
	 * Return the result of matching alternatives.  The choice will therefore
	 * fail if none of the alternatives match.
	 */
	return uip_match_alternatives(node);
}

static sc_bool uip_match_optional(sc_ptnoderef_t node) {
	sc_int start_posn;
	sc_ptnoderef_t list;
	sc_bool matched;

	/* Note the start position for rewind on empty match. */
	start_posn = uip_posn;

	/*
	 * Look ahead to see if we can match to nothing, and still have the main
	 * pattern match.  If we can, we'll go with this.  It's a "minimal munch"-ish
	 * strategy, but seems to be what Adrift does in this situation.
	 */
	list = uip_new_node(NODE_LIST);
	list->left_child = node->right_sibling;

	/* Match on the temporary list. */
	matched = uip_match_node(list);

	/* Free the temporary list node. */
	uip_destroy_node(list);

	/*
	 * If the temporary matched and consumed text, rewind position to match
	 * nothing.  If it didn't, match alternatives to consume anything that may
	 * match our options.
	 */
	if (matched && uip_posn > start_posn)
		uip_posn = start_posn;
	else
		uip_match_alternatives(node);

	/* Return TRUE no matter what. */
	return TRUE;
}

static sc_bool uip_match_wildcard(sc_ptnoderef_t node) {
	sc_int start_posn, limit, index_;
	sc_bool matched;
	sc_ptnoderef_t list;

	/*
	 * At least one game uses patterns like "thing******...".  Why?  Who knows.
	 * But if we're in a list of wildcards, and not the first, ignore the call;
	 * only the final one needs handling.
	 */
	if (node->right_sibling && node->right_sibling->type == NODE_WILDCARD)
		return TRUE;

	/* Note the start position for rewind on no match. */
	start_posn = uip_posn;

	/*
	 * To make life a little easier, we'll match on the tree to the right of
	 * this node by constructing a temporary list node, containing stuff to the
	 * right of the wildcard, and then matching on that.
	 */
	list = uip_new_node(NODE_LIST);
	list->left_child = node->right_sibling;

	/*
	 * Repeatedly try to match the rest of the tree at successive character
	 * positions, and stop if we succeed.  This is a "minimal munch", which may
	 * or may not be the right thing to be doing here.
	 *
	 * When scanning forward, take care to include the NUL, needed to match
	 * TOK_EOS.
	 */
	matched = FALSE;
	limit = strlen(uip_string) + 1;
	for (index_ = uip_posn + 1; index_ < limit; index_++) {
		uip_posn = index_;
		if (uip_match_node(list)) {
			/* Wildcard match at this point. */
			uip_posn = index_;
			matched = TRUE;
			break;
		}
	}

	/* Free the temporary list node. */
	uip_destroy_node(list);

	/* If we didn't match in the loop, restore position. */
	if (!matched)
		uip_posn = start_posn;

	/* Return TRUE whether we matched text or not. */
	return TRUE;
}


/*
 * uip_match_number()
 * uip_match_text()
 *
 * Attempt to match a number, or a word, from the string.
 */
static sc_bool uip_match_number(void) {
	const sc_gameref_t game = uip_get_game();
	const sc_var_setref_t vars = gs_get_vars(game);
	sc_int number;

	/* Attempt to read a number from input. */
	if (sscanf(uip_string + uip_posn, "%ld", &number) == 1) {
		/* Advance position over the number. */
		while (uip_string[uip_posn] == MINUS || uip_string[uip_posn] == PLUS)
			uip_posn++;
		while (sc_isdigit(uip_string[uip_posn]))
			uip_posn++;

		/* Set number reference in variables and return. */
		var_set_ref_number(vars, number);
		return TRUE;
	}

	/* No match. */
	return FALSE;
}

static sc_bool uip_match_text(sc_ptnoderef_t node) {
	const sc_gameref_t game = uip_get_game();
	const sc_var_setref_t vars = gs_get_vars(game);
	sc_int start_posn, limit, index_;
	sc_bool matched;
	sc_ptnoderef_t list;

	/* Note the start position for rewind on no match. */
	start_posn = uip_posn;

	/*
	 * As with wildcards, create a temporary list of the stuff to the right of
	 * the reference node, and match on that.
	 */
	list = uip_new_node(NODE_LIST);
	list->left_child = node->right_sibling;

	/*
	 * Again, as with wildcards, repeatedly try to match the rest of the tree at
	 * successive character positions, stopping if we succeed.
	 */
	matched = FALSE;
	limit = strlen(uip_string) + 1;
	for (index_ = uip_posn + 1; index_ < limit; index_++) {
		uip_posn = index_;
		if (uip_match_node(list)) {
			/* Text reference match at this point. */
			uip_posn = index_;
			matched = TRUE;
			break;
		}
	}

	/* Free the temporary list node. */
	uip_destroy_node(list);

	/* See if we found a match in the loop. */
	if (matched) {
		sc_char *string;

		/* Found a match; create a string and save the text. */
		string = (sc_char *)sc_malloc(uip_posn - start_posn + 1);
		memcpy(string, uip_string + start_posn, uip_posn - start_posn);
		string[uip_posn - start_posn] = NUL;

		/*
		 * Adrift seems to save referenced text as all-lowercase; we need to do
		 * the same.
		 */
		for (index_ = 0; string[index_] != NUL; index_++)
			string[index_] = sc_tolower(string[index_]);
		var_set_ref_text(vars, string);
		sc_free(string);

		/* Return TRUE since we matched text. */
		return TRUE;
	} else {
		/* We didn't match in the loop; restore position. */
		uip_posn = start_posn;

		/* Return FALSE on no match. */
		return FALSE;
	}
}


/*
 * uip_skip_article()
 *
 * Skip over any "a"/"an"/"the"/"some" at the head of a string.  Helper for
 * %character% and %object% matchers.  Returns the revised string position.
 */
static sc_int uip_skip_article(const sc_char *string, sc_int start) {
	sc_int posn;

	/* Skip over articles. */
	posn = start;
	if (sc_compare_word(string + posn, "a", 1))
		posn += 1;
	else if (sc_compare_word(string + posn, "an", 2))
		posn += 2;
	else if (sc_compare_word(string + posn, "the", 3))
		posn += 3;
	else if (sc_compare_word(string + posn, "some", 4))
		posn += 4;

	/* Skip any whitespace, and return. */
	while (sc_isspace(string[posn]) && string[posn] != NUL)
		posn++;
	return posn;
}


/*
 * uip_compare_reference()
 *
 * Helper for %character% and %object% matchers.  Matches multiple words
 * if necessary, at the current position.  Returns zero if the string
 * didn't match, otherwise the length of the current position that matched
 * the words passed in (the new value of uip_posn on match).
 */
static sc_int uip_compare_reference(const sc_char *words) {
	sc_int wpos, posn;

	/* Skip articles and lead in space on words and string. */
	wpos = uip_skip_article(words, 0);
	posn = uip_skip_article(uip_string, uip_posn);

	/* Match characters from words with the string at position. */
	while (TRUE) {
		/* Any character mismatch means no words match. */
		if (sc_tolower(words[wpos]) != sc_tolower(uip_string[posn]))
			return 0;

		/* Move to next character in each. */
		wpos++;
		posn++;

		/*
		 * If at space, advance over whitespace in words list.  Stop when we
		 * hit the end of the words list.
		 */
		while (sc_isspace(words[wpos]) && words[wpos] != NUL)
			wpos++;
		if (words[wpos] == NUL)
			break;

		/*
		 * About to match another word, so advance over whitespace in the
		 * current string too.
		 */
		while (sc_isspace(uip_string[posn]) && uip_string[posn] != NUL)
			posn++;
	}

	/*
	 * We reached the end of words.  If we're at the end of the match string, or
	 * at spaces, we've matched.
	 */
	if (sc_isspace(uip_string[posn]) || uip_string[posn] == NUL)
		return posn;

	/* More text after the match, so it's not quite a match. */
	return 0;
}


/*
 * uip_compare_prefixed_name()
 *
 * Helper for %character% and %object% matchers.  Attempts a reference
 * match against both the prefixed name, and if that fails, the plain name.
 * Returns the extent of the match, or zero if no match.
 */
static sc_int uip_compare_prefixed_name(const sc_char *prefix, const sc_char *name) {
	sc_char buffer[UIP_SHORT_WORD_SIZE + UIP_SHORT_WORD_SIZE + 1];
	sc_char *string;
	sc_int required, extent;

	/* Create a prefixed string, using the local buffer if possible. */
	required = strlen(prefix) + strlen(name) + 2;
	string = required > (sc_int) sizeof(buffer) ? (sc_char *)sc_malloc(required) : buffer;
	sprintf(string, "%s %s", prefix, name);

	/* Check against the prefixed name first, free string if required. */
	extent = uip_compare_reference(string);
	if (string != buffer)
		sc_free(string);

	/* If no match there, retry with just the plain name. */
	if (extent == 0)
		extent = uip_compare_reference(name);

	/* Return the count of characters consumed in matching. */
	return extent;
}


/*
 * uip_match_remainder()
 *
 * Helper for %character% and %object% matchers.  Matches the remainder
 * of a pattern, to resolve the difference between, say, "table leg" and
 * "table".
 */
static sc_bool uip_match_remainder(sc_ptnoderef_t node, sc_int extent) {
	sc_ptnoderef_t list;
	sc_int start_posn;
	sc_bool matched;

	/* Note the start position, then advance to the given extent. */
	start_posn = uip_posn;
	uip_posn = extent;

	/*
	 * Try to match everything after the node passed in, at this position in the
	 * string.
	 */
	list = uip_new_node(NODE_LIST);
	list->left_child = node->right_sibling;

	/* Match on the temporary list. */
	matched = uip_match_node(list);

	/* Free the temporary list node, and restore position. */
	uip_destroy_node(list);
	uip_posn = start_posn;

	/* Return TRUE if the pattern remainder matched. */
	return matched;
}


/*
 * uip_match_character()
 *
 * Match a %character% reference.  This function searches all NPC names and
 * aliases for possible matches, and sets the game npc_references flag
 * for any that match.  The final one to match is also stored in variables.
 */
static sc_bool uip_match_character(sc_ptnoderef_t node) {
	const sc_gameref_t game = uip_get_game();
	const sc_prop_setref_t bundle = gs_get_bundle(game);
	const sc_var_setref_t vars = gs_get_vars(game);
	sc_int npc_count, npc, max_extent;

	if (uip_trace)
		sc_trace("UIParser: attempting to match %%character%%\n");

	/* Clear all current character references. */
	gs_clear_npc_references(game);

	/* Iterate characters, looking for a name or alias match. */
	max_extent = 0;
	npc_count = gs_npc_count(game);
	for (npc = 0; npc < npc_count; npc++) {
		sc_vartype_t vt_key[4];
		const sc_char *prefix, *name;
		sc_int alias_count, alias, extent;

		/* Get the NPC's prefix and name. */
		vt_key[0].string = "NPCs";
		vt_key[1].integer = npc;
		vt_key[2].string = "Prefix";
		prefix = prop_get_string(bundle, "S<-sis", vt_key);
		vt_key[2].string = "Name";
		name = prop_get_string(bundle, "S<-sis", vt_key);

		if (uip_trace)
			sc_trace("UIParser: trying %s\n", name);

		/* Compare this name, both prefixed and not. */
		extent = uip_compare_prefixed_name(prefix, name);
		if (extent > 0 && uip_match_remainder(node, extent)) {
			if (uip_trace)
				sc_trace("UIParser: matched\n");

			/* Increase the maximum match extent if required. */
			max_extent = (extent > max_extent) ? extent : max_extent;

			/* Save match in variables and game. */
			var_set_ref_character(vars, npc);
			game->npc_references[npc] = TRUE;
		}

		/* Now compare against all NPC aliases. */
		vt_key[2].string = "Alias";
		alias_count = prop_get_child_count(bundle, "I<-sis", vt_key);

		for (alias = 0; alias < alias_count; alias++) {
			const sc_char *alias_name;

			/*
			 * Get the NPC alias.  Version 3.9 games introduce empty aliases,
			 * so check here.
			 */
			vt_key[3].integer = alias;
			alias_name = prop_get_string(bundle, "S<-sisi", vt_key);
			if (sc_strempty(alias_name))
				continue;

			if (uip_trace)
				sc_trace("UIParser: trying alias %s\n", alias_name);

			/* Compare this alias name, both prefixed and not. */
			extent = uip_compare_prefixed_name(prefix, alias_name);
			if (extent > 0 && uip_match_remainder(node, extent)) {
				if (uip_trace)
					sc_trace("UIParser: matched\n");

				/* Increase the maximum match extent if required. */
				max_extent = (extent > max_extent) ? extent : max_extent;

				/* Save match in variables and game. */
				var_set_ref_character(vars, npc);
				game->npc_references[npc] = TRUE;
			}
		}
	}

	/* On match, advance position and return successfully. */
	if (max_extent > 0) {
		uip_posn = max_extent;
		return TRUE;
	}

	/* No match. */
	return FALSE;
}


/*
 * uip_match_object()
 *
 * Match an %object% reference.  This function searches all object names and
 * aliases for possible matches, and sets the game object_references flag
 * for any that match.  The final one to match is also stored in variables.
 */
static sc_bool uip_match_object(sc_ptnoderef_t node) {
	const sc_gameref_t game = uip_get_game();
	const sc_prop_setref_t bundle = gs_get_bundle(game);
	const sc_var_setref_t vars = gs_get_vars(game);
	sc_int object_count, object, max_extent;

	if (uip_trace)
		sc_trace("UIParser: attempting to match %%object%%\n");

	/* Clear all current object references. */
	gs_clear_object_references(game);

	/* Iterate objects, looking for a name or alias match. */
	max_extent = 0;
	object_count = gs_object_count(game);
	for (object = 0; object < object_count; object++) {
		sc_vartype_t vt_key[4];
		const sc_char *prefix, *name;
		sc_int alias_count, alias, extent;

		/* Get the object's prefix and name. */
		vt_key[0].string = "Objects";
		vt_key[1].integer = object;
		vt_key[2].string = "Prefix";
		prefix = prop_get_string(bundle, "S<-sis", vt_key);
		vt_key[2].string = "Short";
		name = prop_get_string(bundle, "S<-sis", vt_key);

		if (uip_trace)
			sc_trace("UIParser: trying %s\n", name);

		/* Compare this name, both prefixed and not. */
		extent = uip_compare_prefixed_name(prefix, name);
		if (extent > 0 && uip_match_remainder(node, extent)) {
			if (uip_trace)
				sc_trace("UIParser: matched\n");

			/* Increase the maximum match extent if required. */
			max_extent = (extent > max_extent) ? extent : max_extent;

			/* Save match in variables and game. */
			var_set_ref_object(vars, object);
			game->object_references[object] = TRUE;
		}

		/* Now compare against all object aliases. */
		vt_key[2].string = "Alias";
		alias_count = prop_get_child_count(bundle, "I<-sis", vt_key);

		for (alias = 0; alias < alias_count; alias++) {
			const sc_char *alias_name;

			/*
			 * Get the object alias.  Version 3.9 games introduce empty aliases,
			 * so check here.
			 */
			vt_key[3].integer = alias;
			alias_name = prop_get_string(bundle, "S<-sisi", vt_key);
			if (sc_strempty(alias_name))
				continue;

			if (uip_trace)
				sc_trace("UIParser: trying alias %s\n", alias_name);

			/* Compare this alias name, both prefixed and not. */
			extent = uip_compare_prefixed_name(prefix, alias_name);
			if (extent > 0 && uip_match_remainder(node, extent)) {
				if (uip_trace)
					sc_trace("UIParser: matched\n");

				/* Increase the maximum match extent if required. */
				max_extent = (extent > max_extent) ? extent : max_extent;

				/* Save match in variables and game. */
				var_set_ref_object(vars, object);
				game->object_references[object] = TRUE;
			}
		}
	}

	/* On match, advance position and return successfully. */
	if (max_extent > 0) {
		uip_posn = max_extent;
		return TRUE;
	}

	/* No match. */
	return FALSE;
}


/*
 * uip_match_node()
 *
 * Attempt to match the given node to the current match string/position.
 * Return TRUE, with position advanced, on match, FALSE on fail with the
 * position unchanged.
 */
static sc_bool uip_match_node(sc_ptnoderef_t node) {
	sc_bool match = FALSE;

	/* Match depending on node type. */
	switch (node->type) {
	case NODE_EOS:
		match = uip_match_eos();
		break;
	case NODE_WORD:
		match = uip_match_word(node);
		break;
	case NODE_VARIABLE:
		match = uip_match_variable(node);
		break;
	case NODE_WHITESPACE:
		match = uip_match_whitespace();
		break;
	case NODE_LIST:
		match = uip_match_list(node);
		break;
	case NODE_CHOICE:
		match = uip_match_choice(node);
		break;
	case NODE_OPTIONAL:
		match = uip_match_optional(node);
		break;
	case NODE_WILDCARD:
		match = uip_match_wildcard(node);
		break;
	case NODE_CHARACTER_REFERENCE:
		match = uip_match_character(node);
		break;
	case NODE_OBJECT_REFERENCE:
		match = uip_match_object(node);
		break;
	case NODE_NUMBER_REFERENCE:
		match = uip_match_number();
		break;
	case NODE_TEXT_REFERENCE:
		match = uip_match_text(node);
		break;
	default:
		sc_fatal("uip_match_node: invalid type, %ld\n", (sc_int) node->type);
	}

	return match;
}


/*
 * uip_cleanse_string()
 * uip_free_cleansed_string()
 *
 * Given a string, copy it to the given buffer, and trim leading and trailing
 * spaces from it.  If the string does not fit the buffer, malloc enough for
 * a string copy and use that instead.  The caller needs to free this
 * allocation if it happens (detectable by comparing the return value to the
 * buffer passed in), or call uip_free_cleansed_string.
 */
static sc_char *uip_cleanse_string(const sc_char *original, sc_char *buffer, sc_int length) {
	sc_int required;
	sc_char *string;

	/*
	 * Use the supplied buffer if it is long enough, otherwise allocate, and
	 * copy the string.
	 */
	required = strlen(original) + 1;
	string = (required < length) ? buffer : (sc_char *)sc_malloc(required);
	strcpy(string, original);

	/* Trim, and return the string. */
	sc_trim_string(string);
	return string;
}

static sc_char *uip_free_cleansed_string(sc_char *string, const sc_char *buffer) {
	/* Free if the string was allocated by the function above. */
	if (string != buffer)
		sc_free(string);

	/* Always returns NULL, for the syntactic convenience of the caller. */
	return nullptr;
}


/*
 * uip_debug_trace()
 *
 * Set pattern match tracing on/off.
 */
void uip_debug_trace(sc_bool flag) {
	uip_trace = flag;
}


/*
 * uip_match()
 *
 * Match a string to a pattern, and return TRUE on match, FALSE otherwise.
 * For performance, this function uses a local buffer to try to avoid the
 * need to copy each of the pattern and match strings passed in.
 */
sc_bool uip_match(const sc_char *pattern, const sc_char *string, sc_gameref_t game) {
	static sc_char *cleansed = nullptr;
	sc_char buffer[UIP_ALLOCATION_AVOIDANCE_SIZE];
	sc_bool match;
	Context context;
	assert(pattern && string && game);

	/* Start tokenizer. */
	cleansed = uip_cleanse_string(pattern, buffer, sizeof(buffer));
	if (uip_trace)
		sc_trace("UIParser: pattern \"%s\"\n", cleansed);
	uip_tokenize_start(cleansed);

	// Try parsing the pattern into a match tree
	uip_parse_lookahead = uip_next_token();
	uip_parse_tree = uip_new_node(NODE_LIST);
	uip_parse_list(context, uip_parse_tree);

	if (context._break) {
		// Parse error -- clean up and fail
		uip_tokenize_end();
		uip_destroy_tree(uip_parse_tree);
		uip_parse_tree = nullptr;
		cleansed = uip_free_cleansed_string(cleansed, buffer);
		return FALSE;
	} else {
		uip_tokenize_end();
		cleansed = uip_free_cleansed_string(cleansed, buffer);
	}

	/* Dump out the pattern tree if requested. */
	if (if_get_trace_flag(SC_DUMP_PARSER_TREES))
		uip_debug_dump();

	/* Match the string to the pattern tree. */
	cleansed = uip_cleanse_string(string, buffer, sizeof(buffer));
	if (uip_trace)
		sc_trace("UIParser: string \"%s\"\n", cleansed);
	uip_match_start(cleansed, game);
	match = uip_match_node(uip_parse_tree);

	/* Clean up matching and free the parsed pattern tree. */
	uip_match_end();
	cleansed = uip_free_cleansed_string(cleansed, buffer);
	uip_destroy_tree(uip_parse_tree);
	uip_parse_tree = nullptr;

	/* Return result of matching. */
	if (uip_trace)
		sc_trace("UIParser: %s\n", match ? "MATCHED!" : "No match");
	return match;
}


/*
 * uip_replace_pronouns()
 *
 * Replaces pronouns by their respective object or NPC names, and returns the
 * resulting string to the caller, or NULL if no pronouns were replaced.  The
 * return string is malloc'ed, so the caller needs to remember to free it.
 */
sc_char *uip_replace_pronouns(sc_gameref_t game, const sc_char *string) {
	const sc_prop_setref_t bundle = gs_get_bundle(game);
	sc_int buffer_allocation;
	sc_char *buffer;
	const sc_char *current;
	assert(string);

	if (uip_trace)
		sc_trace("UIParser: pronoun search \"%s\"\n", string);

	/* Begin with a NULL buffer for lazy allocation. */
	buffer_allocation = 0;
	buffer = nullptr;

	/* Search for pronouns until no more string remains. */
	current = string + strspn(string, WHITESPACE);
	while (current[0] != NUL) {
		sc_vartype_t vt_key[3];
		sc_int object, npc, extent;
		const sc_char *prefix, *name;

		/* Initially, no object or NPC, no names, and a zero extent. */
		object = npc = -1;
		prefix = name = nullptr;
		extent = 0;

		/*
		 * Search for pronouns where we have an assigned object or NPC.  We
		 * can't be sure of getting plurality right, and it's not always
		 * intuitive even in English -- is "a pair of scissors" an "it", or
		 * a "them"?  Because of this, we just treat "it" and "them" equally
		 * for now.
		 */
		if (game->it_object != -1 && sc_compare_word(current, "it", 2)) {
			object = game->it_object;
			extent = 2;
		} else if (game->it_object != -1 && sc_compare_word(current, "them", 4)) {
			object = game->it_object;
			extent = 4;
		} else if (game->him_npc != -1 && sc_compare_word(current, "him", 3)) {
			npc = game->him_npc;
			extent = 3;
		} else if (game->her_npc != -1 && sc_compare_word(current, "her", 3)) {
			npc = game->her_npc;
			extent = 3;
		} else if (game->it_npc != -1 && sc_compare_word(current, "it", 2)) {
			npc = game->it_npc;
			extent = 2;
		}

		/* Assign prefix and name to the full object or NPC name, if any. */
		if (object > -1) {
			vt_key[0].string = "Objects";
			vt_key[1].integer = object;
			vt_key[2].string = "Prefix";
			prefix = prop_get_string(bundle, "S<-sis", vt_key);
			vt_key[2].string = "Short";
			name = prop_get_string(bundle, "S<-sis", vt_key);
		} else if (npc > -1) {
			vt_key[0].string = "NPCs";
			vt_key[1].integer = npc;
			vt_key[2].string = "Prefix";
			prefix = prop_get_string(bundle, "S<-sis", vt_key);
			vt_key[2].string = "Name";
			name = prop_get_string(bundle, "S<-sis", vt_key);
		}

		/*
		 * If a pronoun was found, prefix and name indicate what to insert, and
		 * extent shows how much of the buffer to replace with them.
		 */
		if (prefix && name && extent > 0) {
			sc_char *position;
			sc_int prefix_length, name_length, length, final_length;

			/*
			 * If not yet allocated, allocate a buffer now, and copy the input
			 * string into it.  Then switch current to the equivalent location
			 * in the allocated buffer; basic copy-on-write.
			 */
			if (!buffer) {
				buffer_allocation = strlen(string) + 1;
				buffer = (sc_char *)sc_malloc(buffer_allocation);
				strcpy(buffer, string);
				current = buffer + (current - string);
			}

			/*
			 * If necessary, grow the output buffer for the replacement,
			 * remembering to adjust current for the new buffer allocated.
			 * At the same time, note the last character index for the move.
			 */
			prefix_length = strlen(prefix);
			name_length = strlen(name);
			length = prefix_length + name_length + 1;
			if (length > extent) {
				sc_int offset;

				offset = current - buffer;
				buffer_allocation += length - extent;
				buffer = (sc_char *)sc_realloc(buffer, buffer_allocation);
				current = buffer + offset;
				final_length = length;
			} else
				final_length = extent;

			/* Insert the replacement strings into the buffer. */
			position = buffer + (current - buffer);
			memmove(position + length,
			        position + extent,
			        buffer_allocation - (current - buffer) - final_length);
			memcpy(position, prefix, prefix_length);
			position[prefix_length] = ' ';
			memcpy(position + prefix_length + 1, name, name_length);

			/* Adjust current to skip over the replacement. */
			current += length;

			if (uip_trace)
				sc_trace("Parser: pronoun \"%s\"\n", buffer);
		} else {
			/* If no match, advance current over the unmatched word. */
			current += strcspn(current, WHITESPACE);
		}

		/* Set current to the next word start. */
		current += strspn(current, WHITESPACE);
	}

	/* Return the final string, or NULL if no pronoun replacements. */
	return buffer;
}


/*
 * uip_assign_pronouns()
 *
 * Search a player command for object and NPC names, and assign any found to
 * game pronouns.  The string is searched from front to back, assigning
 * pronouns for objects or NPC names as found.  Later ones will overwrite
 * earlier ones if there is more than one in the string.
 */
void uip_assign_pronouns(sc_gameref_t game, const sc_char *string) {
	const sc_prop_setref_t bundle = gs_get_bundle(game);
	const sc_var_setref_t vars = gs_get_vars(game);
	const sc_char *current;
	sc_int saved_ref_object, saved_ref_character;
	assert(string);

	if (uip_trace)
		sc_trace("UIParser: pronoun assignment \"%s\"\n", string);

	/* Save var references so we can restore them later. */
	saved_ref_object = var_get_ref_object(vars);
	saved_ref_character = var_get_ref_character(vars);

	/* Search for object and NPC names until no more string remains. */
	current = string + strspn(string, WHITESPACE);
	while (current[0] != NUL) {
		if (uip_match("%object% *", current, game)) {
			sc_int count, index_, object;

			/*
			 * "Disambiguate" by rejecting objects that the player hasn't seen
			 * or can't see.  If the reference is unique, assign to the 'it'
			 * object pronoun.
			 */
			count = 0;
			object = -1;
			for (index_ = 0; index_ < gs_object_count(game); index_++) {
				if (game->object_references[index_]
				        && gs_object_seen(game, index_)
				        && obj_indirectly_in_room(game,
				                                  index_, gs_playerroom(game))) {
					count++;
					object = index_;
				}
			}

			if (count == 1) {
				game->it_object = object;
				game->it_npc = -1;

				if (uip_trace)
					sc_trace("UIParser: object 'it/them' assigned %ld\n", object);
			}
		}

		if (uip_match("%character% *", current, game)) {
			sc_int count, index_, npc;

			/* Do the same "disambiguation" as for objects above. */
			count = 0;
			npc = -1;
			for (index_ = 0; index_ < gs_npc_count(game); index_++) {
				if (game->npc_references[index_]
				        && gs_npc_seen(game, index_)
				        && npc_in_room(game, index_, gs_playerroom(game))) {
					count++;
					npc = index_;
				}
			}

			if (count == 1) {
				sc_vartype_t vt_key[3];
				sc_int version, gender;

				/*
				 * Version 3.8 games lack NPC gender information, so for this
				 * case set "him"/"her" on each match, and never set "it"; this
				 * matches the version 3.8 runner.
				 */
				vt_key[0].string = "Version";
				version = prop_get_integer(bundle, "I<-s", vt_key);
				if (version == TAF_VERSION_380) {
					game->him_npc = npc;
					game->her_npc = npc;
					game->it_npc = -1;

					if (uip_trace) {
						sc_trace("UIParser: 3.8 pronouns"
						         " 'him' and 'her' assigned %ld\n", npc);
					}
				} else {
					/* Find the NPC gender, so we know the pronoun to assign. */
					vt_key[0].string = "NPCs";
					vt_key[1].integer = npc;
					vt_key[2].string = "Gender";
					gender = prop_get_integer(bundle, "I<-sis", vt_key);

					switch (gender) {
					case NPC_MALE:
						game->him_npc = npc;
						break;
					case NPC_FEMALE:
						game->her_npc = npc;
						break;
					case NPC_NEUTER:
						game->it_npc = npc;
						game->it_object = -1;
						break;
					default:
						sc_error("uip_assign_pronouns:"
						         " unknown gender, %ld\n", gender);
					}

					if (uip_trace)
						sc_trace("UIParser: NPC 'him/her/it' assigned %ld\n", npc);
				}
			}
		}

		/*
		 * Advance the string position by a complete word.  This saves a lot
		 * of time -- there's no point looking for an object or NPC name in
		 * mid-word, and anyway it's not the right thing to do.
		 */
		current += strcspn(current, WHITESPACE);
		current += strspn(current, WHITESPACE);
	}

	/* Restore variables references. */
	var_set_ref_object(vars, saved_ref_object);
	var_set_ref_character(vars, saved_ref_character);
}

} // End of namespace Adrift
} // End of namespace Glk