Separated the parser code

svn-id: r47480

5 files changed, 4875 insertions, 0 deletions

diff --git a/engines/sci/parser/grammar.cpp b/engines/sci/parser/grammar.cpp
new file mode 100644
index 0000000000..9ee3b8aeaa
--- /dev/null
+++ b/engines/sci/parser/grammar.cpp
@@ -0,0 +1,583 @@
+/* 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+/* Functionality to transform the context-free SCI grammar rules into
+ * strict Greibach normal form (strict GNF), and to test SCI input against
+ * that grammar, writing an appropriate node tree if successful.
+ */
+
+#include "sci/parser/vocabulary.h"
+#include "sci/console.h"
+#include "common/array.h"
+
+namespace Sci {
+
+#define TOKEN_OPAREN 0xff000000
+#define TOKEN_CPAREN 0xfe000000
+#define TOKEN_TERMINAL_CLASS 0x10000
+#define TOKEN_TERMINAL_GROUP 0x20000
+#define TOKEN_STUFFING_WORD 0x40000
+#define TOKEN_NON_NT (TOKEN_OPAREN | TOKEN_TERMINAL_CLASS | TOKEN_TERMINAL_GROUP | TOKEN_STUFFING_WORD)
+#define TOKEN_TERMINAL (TOKEN_TERMINAL_CLASS | TOKEN_TERMINAL_GROUP)
+
+static int _allocd_rules = 0;	// FIXME: Avoid non-const global vars
+
+struct ParseRule {
+	int _id; /**< non-terminal ID */
+	uint _firstSpecial; /**< first terminal or non-terminal */
+	uint _numSpecials; /**< number of terminals and non-terminals */
+	Common::Array<int> _data;	/**< actual data */
+
+	~ParseRule() {
+		assert(_allocd_rules > 0);
+		--_allocd_rules;
+	}
+
+	// FIXME remove this one again?
+	bool operator==(const ParseRule &other) const {
+		return _id == other._id &&
+			_firstSpecial == other._firstSpecial &&
+			_numSpecials == other._numSpecials &&
+			_data == other._data;
+	}
+};
+
+
+struct ParseRuleList {
+	int terminal; /**< Terminal character this rule matches against or 0 for a non-terminal rule */
+	ParseRule *rule;
+	ParseRuleList *next;
+
+	void print() const;
+
+	ParseRuleList(ParseRule *r) : rule(r), next(0) {
+		int term = rule->_data[rule->_firstSpecial];
+		terminal = ((term & TOKEN_TERMINAL) ? term : 0);
+	}
+
+	~ParseRuleList() {
+		delete rule;
+		delete next;
+	}
+};
+
+
+static void vocab_print_rule(ParseRule *rule) {
+	int wspace = 0;
+
+	if (!rule) {
+		warning("NULL rule");
+		return;
+	}
+
+	printf("[%03x] -> ", rule->_id);
+
+	if (rule->_data.empty())
+		printf("e");
+
+	for (uint i = 0; i < rule->_data.size(); i++) {
+		uint token = rule->_data[i];
+
+		if (token == TOKEN_OPAREN) {
+			if (i == rule->_firstSpecial)
+				printf("_");
+
+			printf("(");
+			wspace = 0;
+		} else if (token == TOKEN_CPAREN) {
+			if (i == rule->_firstSpecial)
+				printf("_");
+
+			printf(")");
+			wspace = 0;
+		} else {
+			if (wspace)
+				printf(" ");
+
+			if (i == rule->_firstSpecial)
+				printf("_");
+			if (token & TOKEN_TERMINAL_CLASS)
+				printf("C(%04x)", token & 0xffff);
+			else if (token & TOKEN_TERMINAL_GROUP)
+				printf("G(%04x)", token & 0xffff);
+			else if (token & TOKEN_STUFFING_WORD)
+				printf("%03x", token & 0xffff);
+			else
+				printf("[%03x]", token); /* non-terminal */
+			wspace = 1;
+		}
+
+		if (i == rule->_firstSpecial)
+			printf("_");
+	}
+	printf(" [%d specials]", rule->_numSpecials);
+}
+
+static ParseRule *_vdup(ParseRule *a) {
+	++_allocd_rules;
+	return new ParseRule(*a);
+}
+
+static ParseRule *_vinsert(ParseRule *turkey, ParseRule *stuffing) {
+	uint firstnt = turkey->_firstSpecial;
+
+	// Search for first TOKEN_NON_NT in 'turkey'
+	while ((firstnt < turkey->_data.size()) && (turkey->_data[firstnt] & TOKEN_NON_NT))
+		firstnt++;
+
+	// If no TOKEN_NON_NT found, or if it doesn't match the id of 'stuffing', abort.
+	if ((firstnt == turkey->_data.size()) || (turkey->_data[firstnt] != stuffing->_id))
+		return NULL;
+
+	// Create a new rule as a copy of 'turkey', where the token firstnt has been substituted
+	// by the rule 'stuffing'.
+	++_allocd_rules;
+
+	ParseRule *rule = new ParseRule(*turkey);
+	rule->_numSpecials += stuffing->_numSpecials - 1;
+	rule->_firstSpecial = firstnt + stuffing->_firstSpecial;
+	rule->_data.resize(turkey->_data.size() - 1 + stuffing->_data.size());
+
+	// Replace rule->_data[firstnt] by all of stuffing->_data
+	Common::copy(stuffing->_data.begin(), stuffing->_data.end(), rule->_data.begin() + firstnt);
+
+	if (firstnt < turkey->_data.size() - 1)
+		Common::copy(turkey->_data.begin() + firstnt + 1, turkey->_data.end(),
+				rule->_data.begin() + firstnt + stuffing->_data.size());
+
+	return rule;
+}
+
+static ParseRule *_vbuild_rule(const parse_tree_branch_t *branch) {
+	int tokens = 0, tokenpos = 0, i;
+
+	while (tokenpos < 10 && branch->data[tokenpos]) {
+		int type = branch->data[tokenpos];
+		tokenpos += 2;
+
+		if ((type == VOCAB_TREE_NODE_COMPARE_TYPE) || (type == VOCAB_TREE_NODE_COMPARE_GROUP) || (type == VOCAB_TREE_NODE_FORCE_STORAGE))
+			++tokens;
+		else if (type > VOCAB_TREE_NODE_LAST_WORD_STORAGE)
+			tokens += 5;
+		else
+			return NULL; // invalid
+	}
+
+	ParseRule *rule = new ParseRule();
+
+	++_allocd_rules;
+	rule->_id = branch->id;
+	rule->_numSpecials = tokenpos >> 1;
+	rule->_data.resize(tokens);
+	rule->_firstSpecial = 0;
+
+	tokens = 0;
+	for (i = 0; i < tokenpos; i += 2) {
+		int type = branch->data[i];
+		int value = branch->data[i + 1];
+
+		if (type == VOCAB_TREE_NODE_COMPARE_TYPE)
+			rule->_data[tokens++] = value | TOKEN_TERMINAL_CLASS;
+		else if (type == VOCAB_TREE_NODE_COMPARE_GROUP)
+			rule->_data[tokens++] = value | TOKEN_TERMINAL_GROUP;
+		else if (type == VOCAB_TREE_NODE_FORCE_STORAGE)
+			rule->_data[tokens++] = value | TOKEN_STUFFING_WORD;
+		else { // normal inductive rule
+			rule->_data[tokens++] = TOKEN_OPAREN;
+			rule->_data[tokens++] = type | TOKEN_STUFFING_WORD;
+			rule->_data[tokens++] = value | TOKEN_STUFFING_WORD;
+
+			if (i == 0)
+				rule->_firstSpecial = tokens;
+
+			rule->_data[tokens++] = value; // The non-terminal
+			rule->_data[tokens++] = TOKEN_CPAREN;
+		}
+	}
+
+	return rule;
+}
+
+static ParseRule *_vsatisfy_rule(ParseRule *rule, const ResultWord &input) {
+	int dep;
+
+	if (!rule->_numSpecials)
+		return NULL;
+
+	dep = rule->_data[rule->_firstSpecial];
+
+	if (((dep & TOKEN_TERMINAL_CLASS) && ((dep & 0xffff) & input._class)) ||
+			((dep & TOKEN_TERMINAL_GROUP) && ((dep & 0xffff) & input._group))) {
+		ParseRule *retval = new ParseRule(*rule);
+		++_allocd_rules;
+		retval->_data[rule->_firstSpecial] = TOKEN_STUFFING_WORD | input._group;
+		retval->_numSpecials--;
+		retval->_firstSpecial = 0;
+
+		if (retval->_numSpecials) { // find first special, if it exists
+			for (uint i = rule->_firstSpecial; i < retval->_data.size(); ++i) {
+				int tmp = retval->_data[i];
+				if (!(tmp & TOKEN_NON_NT) || (tmp & TOKEN_TERMINAL)) {
+					retval->_firstSpecial = i;
+					break;
+				}
+			}
+		}
+
+		return retval;
+	} else
+		return NULL;
+}
+
+void Vocabulary::freeRuleList(ParseRuleList *list) {
+	delete list;
+}
+
+static ParseRuleList *_vocab_add_rule(ParseRuleList *list, ParseRule *rule) {
+	if (!rule)
+		return list;
+
+	ParseRuleList *new_elem = new ParseRuleList(rule);
+
+	if (list) {
+		const int term = new_elem->terminal;
+/*		if (term < list->terminal) {
+			new_elem->next = list;
+			return new_elem;
+		} else {*/
+		ParseRuleList *seeker = list;
+
+		while (seeker->next/* && seeker->next->terminal <= term*/) {
+			if (seeker->next->terminal == term) {
+				if (*(seeker->next->rule) == *rule) {
+					delete rule;
+					delete new_elem;
+					return list; // No duplicate rules
+				}
+			}
+			seeker = seeker->next;
+		}
+
+		new_elem->next = seeker->next;
+		seeker->next = new_elem;
+		return list;
+	} else {
+		return new_elem;
+	}
+}
+
+void ParseRuleList::print() const {
+	const ParseRuleList *list = this;
+	int pos = 0;
+	while (list) {
+		printf("R%03d: ", pos);
+		vocab_print_rule(list->rule);
+		printf("\n");
+		list = list->next;
+		pos++;
+	}
+	printf("%d rules total.\n", pos);
+}
+
+static ParseRuleList *_vocab_split_rule_list(ParseRuleList *list) {
+	assert(list);
+	if (!list->next || (list->next->terminal)) {
+		ParseRuleList *tmp = list->next;
+		list->next = NULL;
+		return tmp;
+	} else
+		return _vocab_split_rule_list(list->next);
+}
+
+static void _vocab_free_empty_rule_list(ParseRuleList *list) {
+	assert(list);
+	if (list->next)
+		_vocab_free_empty_rule_list(list->next);
+	list->next = 0;
+	list->rule = 0;
+	delete list;
+}
+
+static ParseRuleList *_vocab_merge_rule_lists(ParseRuleList *l1, ParseRuleList *l2) {
+	ParseRuleList *retval = l1, *seeker = l2;
+	while (seeker) {
+		retval = _vocab_add_rule(retval, seeker->rule);
+		seeker = seeker->next;
+	}
+	_vocab_free_empty_rule_list(l2);
+
+	return retval;
+}
+
+static int _vocab_rule_list_length(ParseRuleList *list) {
+	return ((list) ? _vocab_rule_list_length(list->next) + 1 : 0);
+}
+
+static ParseRuleList *_vocab_clone_rule_list_by_id(ParseRuleList *list, int id) {
+	ParseRuleList *result = NULL;
+	ParseRuleList *seeker = list;
+
+	while (seeker) {
+		if (seeker->rule->_id == id) {
+			result = _vocab_add_rule(result, _vdup(seeker->rule));
+		}
+		seeker = seeker->next;
+	}
+
+	return result;
+}
+
+ParseRuleList *Vocabulary::buildGNF(bool verbose) {
+	int iterations = 0;
+	int last_termrules, termrules = 0;
+	int ntrules_nr;
+	ParseRuleList *ntlist = NULL;
+	ParseRuleList *tlist, *new_tlist;
+	Console *con = ((SciEngine *)g_engine)->getSciDebugger();
+
+	for (uint i = 1; i < _parserBranches.size(); i++) { // branch rule 0 is treated specially
+		ParseRule *rule = _vbuild_rule(&_parserBranches[i]);
+		if (!rule)
+			return NULL;
+		ntlist = _vocab_add_rule(ntlist, rule);
+	}
+
+	tlist = _vocab_split_rule_list(ntlist);
+	ntrules_nr = _vocab_rule_list_length(ntlist);
+
+	if (verbose)
+		con->DebugPrintf("Starting with %d rules\n", ntrules_nr);
+
+	new_tlist = tlist;
+	tlist = NULL;
+
+	do {
+		ParseRuleList *new_new_tlist = NULL;
+		ParseRuleList *ntseeker, *tseeker;
+		last_termrules = termrules;
+
+		ntseeker = ntlist;
+		while (ntseeker) {
+			tseeker = new_tlist;
+
+			while (tseeker) {
+				ParseRule *newrule = _vinsert(ntseeker->rule, tseeker->rule);
+				if (newrule)
+					new_new_tlist = _vocab_add_rule(new_new_tlist, newrule);
+				tseeker = tseeker->next;
+			}
+
+			ntseeker = ntseeker->next;
+		}
+
+		tlist = _vocab_merge_rule_lists(tlist, new_tlist);
+		new_tlist = new_new_tlist;
+		termrules = _vocab_rule_list_length(new_new_tlist);
+
+		if (verbose)
+			con->DebugPrintf("After iteration #%d: %d new term rules\n", ++iterations, termrules);
+
+	} while (termrules && (iterations < 30));
+
+	freeRuleList(ntlist);
+
+	if (verbose) {
+		con->DebugPrintf("\nGNF rules:\n");
+		tlist->print();
+		con->DebugPrintf("%d allocd rules\n", _allocd_rules);
+		con->DebugPrintf("Freeing rule list...\n");
+		freeRuleList(tlist);
+		return NULL;
+	}
+
+	return tlist;
+}
+
+static int _vbpt_pareno(parse_tree_node_t *nodes, int *pos, int base) {
+	// Opens parentheses
+	nodes[base].content.branches[0] = (*pos) + 1;
+	nodes[++(*pos)].type = kParseTreeBranchNode;
+	nodes[*pos].content.branches[0] = 0;
+	nodes[*pos].content.branches[1] = 0;
+	return *pos;
+}
+
+static int _vbpt_parenc(parse_tree_node_t *nodes, int *pos, int paren) {
+	// Closes parentheses for appending
+	nodes[paren].content.branches[1] = ++(*pos);
+	nodes[*pos].type = kParseTreeBranchNode;
+	nodes[*pos].content.branches[0] = 0;
+	nodes[*pos].content.branches[1] = 0;
+	return *pos;
+}
+
+static int _vbpt_append(parse_tree_node_t *nodes, int *pos, int base, int value) {
+	// writes one value to an existing base node and creates a successor node for writing
+	nodes[base].content.branches[0] = ++(*pos);
+	nodes[*pos].type = kParseTreeLeafNode;
+	nodes[*pos].content.value = value;
+	nodes[base].content.branches[1] = ++(*pos);
+	nodes[*pos].type = kParseTreeBranchNode;
+	nodes[*pos].content.branches[0] = 0;
+	nodes[*pos].content.branches[1] = 0;
+	return *pos;
+}
+
+static int _vbpt_terminate(parse_tree_node_t *nodes, int *pos, int base, int value) {
+	// Terminates, overwriting a nextwrite forknode
+	nodes[base].type = kParseTreeLeafNode;
+	nodes[base].content.value = value;
+	return *pos;
+}
+
+static int _vbpt_write_subexpression(parse_tree_node_t *nodes, int *pos, ParseRule *rule, uint rulepos, int writepos) {
+	uint token;
+
+	while ((token = ((rulepos < rule->_data.size()) ? rule->_data[rulepos++] : TOKEN_CPAREN)) != TOKEN_CPAREN) {
+		uint nexttoken = (rulepos < rule->_data.size()) ? rule->_data[rulepos] : TOKEN_CPAREN;
+		if (token == TOKEN_OPAREN) {
+			int writepos2 = _vbpt_pareno(nodes, pos, writepos);
+			rulepos = _vbpt_write_subexpression(nodes, pos, rule, rulepos, writepos2);
+			nexttoken = (rulepos < rule->_data.size()) ? rule->_data[rulepos] : TOKEN_CPAREN;
+			if (nexttoken != TOKEN_CPAREN)
+				writepos = _vbpt_parenc(nodes, pos, writepos);
+		} else if (token & TOKEN_STUFFING_WORD) {
+			if (nexttoken == TOKEN_CPAREN)
+				writepos = _vbpt_terminate(nodes, pos, writepos, token & 0xffff);
+			else
+				writepos = _vbpt_append(nodes, pos, writepos, token & 0xffff);
+		} else {
+			printf("\nError in parser (grammar.cpp, _vbpt_write_subexpression()): Rule data broken in rule ");
+			vocab_print_rule(rule);
+			printf(", at token position %d\n", *pos);
+			return rulepos;
+		}
+	}
+
+	return rulepos;
+}
+
+int Vocabulary::parseGNF(const ResultWordList &words, bool verbose) {
+	Console *con = ((SciEngine *)g_engine)->getSciDebugger();
+	// Get the start rules:
+	ParseRuleList *work = _vocab_clone_rule_list_by_id(_parserRules, _parserBranches[0].data[1]);
+	ParseRuleList *results = NULL;
+	uint word = 0;
+	const uint words_nr = words.size();
+	ResultWordList::const_iterator word_iter = words.begin();
+
+	for (word_iter = words.begin(); word_iter != words.end(); ++word_iter, ++word) {
+		ParseRuleList *new_work = NULL;
+		ParseRuleList *reduced_rules = NULL;
+		ParseRuleList *seeker, *subseeker;
+
+		if (verbose)
+			con->DebugPrintf("Adding word %d...\n", word);
+
+		seeker = work;
+		while (seeker) {
+			if (seeker->rule->_numSpecials <= (words_nr - word))
+				reduced_rules = _vocab_add_rule(reduced_rules, _vsatisfy_rule(seeker->rule, *word_iter));
+
+			seeker = seeker->next;
+		}
+
+		if (reduced_rules == NULL) {
+			freeRuleList(work);
+			if (verbose)
+				con->DebugPrintf("No results.\n");
+			return 1;
+		}
+
+		freeRuleList(work);
+
+		if (word + 1 < words_nr) {
+			seeker = reduced_rules;
+
+			while (seeker) {
+				if (seeker->rule->_numSpecials) {
+					int my_id = seeker->rule->_data[seeker->rule->_firstSpecial];
+
+					subseeker = _parserRules;
+					while (subseeker) {
+						if (subseeker->rule->_id == my_id)
+							new_work = _vocab_add_rule(new_work, _vinsert(seeker->rule, subseeker->rule));
+
+						subseeker = subseeker->next;
+					}
+				}
+
+				seeker = seeker->next;
+			}
+			freeRuleList(reduced_rules);
+		} else // last word
+			new_work = reduced_rules;
+
+		work = new_work;
+		if (verbose)
+			con->DebugPrintf("Now at %d candidates\n", _vocab_rule_list_length(work));
+		if (work == NULL) {
+			if (verbose)
+				con->DebugPrintf("No results.\n");
+			return 1;
+		}
+	}
+
+	results = work;
+
+	if (verbose) {
+		con->DebugPrintf("All results (excluding the surrounding '(141 %03x' and ')'):\n", _parserBranches[0].id);
+		results->print();
+		con->DebugPrintf("\n");
+	}
+
+	// now use the first result
+	{
+		int temp, pos;
+
+		_parserNodes[0].type = kParseTreeBranchNode;
+		_parserNodes[0].content.branches[0] = 1;
+		_parserNodes[0].content.branches[1] = 2;
+
+		_parserNodes[1].type = kParseTreeLeafNode;
+		_parserNodes[1].content.value = 0x141;
+
+		_parserNodes[2].type = kParseTreeBranchNode;
+		_parserNodes[2].content.branches[0] = 0;
+		_parserNodes[2].content.branches[1] = 0;
+
+		pos = 2;
+
+		temp = _vbpt_append(_parserNodes, &pos, 2, _parserBranches[0].id);
+		//_vbpt_write_subexpression(nodes, &pos, results[_vocab_rule_list_length(results)].rule, 0, temp);
+		_vbpt_write_subexpression(_parserNodes, &pos, results->rule, 0, temp);
+	}
+
+	freeRuleList(results);
+
+	return 0;
+}
+
+} // End of namespace Sci
diff --git a/engines/sci/parser/said.cpp b/engines/sci/parser/said.cpp
new file mode 100644
index 0000000000..32bd1fcf8d
--- /dev/null
+++ b/engines/sci/parser/said.cpp
@@ -0,0 +1,2483 @@
+/* A Bison parser, made by GNU Bison 2.3.  */
+
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+
+   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, 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.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "2.3"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Using locations.  */
+#define YYLSP_NEEDED 0
+
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     WGROUP = 258,
+     YY_COMMA = 259,
+     YY_AMP = 260,
+     YY_SLASH = 261,
+     YY_PARENO = 262,
+     YY_PARENC = 263,
+     YY_BRACKETSO = 264,
+     YY_BRACKETSC = 265,
+     YY_HASH = 266,
+     YY_LT = 267,
+     YY_GT = 268,
+     YY_BRACKETSO_LT = 269,
+     YY_BRACKETSO_SLASH = 270,
+     YY_LT_BRACKETSO = 271,
+     YY_LT_PARENO = 272
+   };
+#endif
+/* Tokens.  */
+#define WGROUP 258
+#define YY_COMMA 259
+#define YY_AMP 260
+#define YY_SLASH 261
+#define YY_PARENO 262
+#define YY_PARENC 263
+#define YY_BRACKETSO 264
+#define YY_BRACKETSC 265
+#define YY_HASH 266
+#define YY_LT 267
+#define YY_GT 268
+#define YY_BRACKETSO_LT 269
+#define YY_BRACKETSO_SLASH 270
+#define YY_LT_BRACKETSO 271
+#define YY_LT_PARENO 272
+
+
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "said.y"
+
+/* 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "sci/engine/state.h"
+
+
+// Bison generates an empty switch statement that gives a warning in MSVC.
+// This disables that warning.
+#ifdef _MSC_VER
+#pragma warning(disable:4065)
+#endif
+
+
+namespace Sci {
+
+#define SAID_BRANCH_NULL 0
+
+#define MAX_SAID_TOKENS 128
+
+// Maximum number of words to be expected in a parsed sentence
+#define AUGMENT_MAX_WORDS 64
+
+
+#define ANYWORD 0xfff
+
+#define WORD_TYPE_BASE 0x141
+#define WORD_TYPE_REF 0x144
+#define WORD_TYPE_SYNTACTIC_SUGAR 0x145
+
+#define AUGMENT_SENTENCE_PART_BRACKETS 0x152
+
+// Minor numbers
+#define AUGMENT_SENTENCE_MINOR_MATCH_PHRASE 0x14c
+#define AUGMENT_SENTENCE_MINOR_MATCH_WORD 0x153
+#define AUGMENT_SENTENCE_MINOR_RECURSE 0x144
+#define AUGMENT_SENTENCE_MINOR_PARENTHESES 0x14f
+
+
+#undef YYDEBUG /*1*/
+//#define SAID_DEBUG*/
+//#define SCI_DEBUG_PARSE_TREE_AUGMENTATION // uncomment to debug parse tree augmentation
+
+
+#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION
+#define scidprintf printf
+#else
+void print_nothing(...) { }
+#define scidprintf print_nothing
+#endif
+
+
+static char *said_parse_error;
+
+static int said_token;
+static int said_tokens_nr;
+static int said_tokens[MAX_SAID_TOKENS];
+static int said_blessed;  // increminated by said_top_branch
+
+static int said_tree_pos; // Set to 0 if we're out of space
+#define SAID_TREE_START 4; // Reserve space for the 4 top nodes
+
+#define VALUE_IGNORE -424242
+
+static parse_tree_node_t said_tree[VOCAB_TREE_NODES];
+
+typedef int wgroup_t;
+typedef int tree_t;
+typedef int said_spec_t;
+
+static tree_t said_aug_branch(int, int, tree_t, tree_t);
+static tree_t said_attach_branch(tree_t, tree_t);
+/*
+static tree_t said_wgroup_branch(wgroup_t);
+*/
+static said_spec_t said_top_branch(tree_t);
+static tree_t said_paren(tree_t, tree_t);
+static tree_t said_value(int, tree_t);
+static tree_t said_terminal(int);
+
+static int yylex(void);
+
+static int yyerror(const char *s) {
+	said_parse_error = strdup(s);
+	return 1; /* Abort */
+}
+
+
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef int YYSTYPE;
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+/* Copy the second part of user declarations.  */
+
+
+/* Line 216 of yacc.c.  */
+#line 250 "said.tab.c"
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions.  */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int i)
+#else
+static int
+YYID (i)
+    int i;
+#endif
+{
+  return i;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     ifndef _STDLIB_H
+#      define _STDLIB_H 1
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined _STDLIB_H \
+       && ! ((defined YYMALLOC || defined malloc) \
+	     && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef _STDLIB_H
+#    define _STDLIB_H 1
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+	 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss;
+  YYSTYPE yyvs;
+  };
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+      + YYSTACK_GAP_MAXIMUM)
+
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  YYSIZE_T yyi;				\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
+      while (YYID (0))
+#  endif
+# endif
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack)					\
+    do									\
+      {									\
+	YYSIZE_T yynewbytes;						\
+	YYCOPY (&yyptr->Stack, Stack, yysize);				\
+	Stack = &yyptr->Stack;						\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+	yyptr += yynewbytes / sizeof (*yyptr);				\
+      }									\
+    while (YYID (0))
+
+#endif
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  23
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   80
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  18
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  13
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  35
+/* YYNRULES -- Number of states.  */
+#define YYNSTATES  69
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   272
+
+#define YYTRANSLATE(YYX)						\
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17
+};
+
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+   YYRHS.  */
+static const yytype_uint8 yyprhs[] =
+{
+       0,     0,     3,     6,    10,    15,    16,    18,    19,    21,
+      24,    29,    31,    34,    39,    41,    43,    45,    49,    51,
+      55,    59,    64,    70,    73,    75,    77,    79,    83,    88,
+      92,    97,   100,   105,   109,   112
+};
+
+/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+static const yytype_int8 yyrhs[] =
+{
+      19,     0,    -1,    21,    20,    -1,    21,    22,    20,    -1,
+      21,    22,    23,    20,    -1,    -1,    13,    -1,    -1,    27,
+      -1,     6,    27,    -1,    15,     6,    27,    10,    -1,     6,
+      -1,     6,    27,    -1,    15,     6,    27,    10,    -1,     6,
+      -1,     3,    -1,    26,    -1,     9,    26,    10,    -1,    24,
+      -1,     7,    27,     8,    -1,    26,     4,    26,    -1,    26,
+      14,    29,    10,    -1,    26,     4,     9,    26,    10,    -1,
+      25,    28,    -1,    25,    -1,    28,    -1,    29,    -1,    14,
+      29,    10,    -1,    29,    14,    29,    10,    -1,    12,    24,
+      30,    -1,    17,     7,    27,     8,    -1,    12,    26,    -1,
+      16,     9,    26,    10,    -1,    12,    26,    30,    -1,    12,
+      26,    -1,    17,     7,    27,     8,    -1
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const yytype_uint8 yyrline[] =
+{
+       0,   129,   129,   131,   133,   139,   140,   147,   148,   154,
+     156,   158,   164,   166,   168,   173,   178,   180,   185,   187,
+     189,   191,   193,   198,   200,   202,   207,   209,   211,   216,
+     218,   220,   222,   227,   229,   231
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "WGROUP", "YY_COMMA", "YY_AMP",
+  "YY_SLASH", "YY_PARENO", "YY_PARENC", "YY_BRACKETSO", "YY_BRACKETSC",
+  "YY_HASH", "YY_LT", "YY_GT", "YY_BRACKETSO_LT", "YY_BRACKETSO_SLASH",
+  "YY_LT_BRACKETSO", "YY_LT_PARENO", "$accept", "saidspec", "optcont",
+  "leftspec", "midspec", "rightspec", "word", "cwordset", "wordset",
+  "expr", "cwordrefset", "wordrefset", "recref", 0
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,   270,   271,   272
+};
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    18,    19,    19,    19,    20,    20,    21,    21,    22,
+      22,    22,    23,    23,    23,    24,    25,    25,    26,    26,
+      26,    26,    26,    27,    27,    27,    28,    28,    28,    29,
+      29,    29,    29,    30,    30,    30
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     2,     3,     4,     0,     1,     0,     1,     2,
+       4,     1,     2,     4,     1,     1,     1,     3,     1,     3,
+       3,     4,     5,     2,     1,     1,     1,     3,     4,     3,
+       4,     2,     4,     3,     2,     4
+};
+
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+   means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       7,    15,     0,     0,     0,     0,     0,     0,     0,     5,
+      18,    24,    16,     8,    25,    26,     0,     0,    18,    31,
+       0,     0,     0,     1,    11,     6,     0,     2,     5,    23,
+       0,     0,     0,    19,    17,     0,     0,    29,    27,     0,
+       0,     9,     0,    14,     0,     3,     5,     0,    20,     0,
+       0,    34,     0,    32,    30,     0,    12,     0,     4,     0,
+      21,    28,    33,     0,    10,     0,    22,    35,    13
+};
+
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int8 yydefgoto[] =
+{
+      -1,     8,    27,     9,    28,    46,    10,    11,    12,    13,
+      14,    15,    37
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+#define YYPACT_NINF -24
+static const yytype_int8 yypact[] =
+{
+      -1,   -24,    -1,    62,    62,    54,     1,     5,    18,    38,
+     -24,    47,     3,   -24,   -24,    12,    23,    15,    -3,     3,
+      28,    62,    -1,   -24,    -1,   -24,    42,   -24,    39,   -24,
+      53,    54,    54,   -24,   -24,    62,    50,   -24,   -24,    29,
+      41,   -24,    -1,    -1,    52,   -24,    55,    62,     3,    57,
+      63,    20,    -1,   -24,   -24,    64,   -24,    -1,   -24,    32,
+     -24,   -24,   -24,    67,   -24,    66,   -24,   -24,   -24
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const yytype_int8 yypgoto[] =
+{
+     -24,   -24,   -23,   -24,   -24,   -24,    68,   -24,     0,    -2,
+      69,    -4,    26
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -1
+static const yytype_uint8 yytable[] =
+{
+      16,    20,     1,    17,    19,    45,     2,    30,     3,    35,
+      21,     4,    22,     5,    36,     6,     7,    31,    23,    30,
+      40,    39,    41,    58,    30,    34,    32,    49,    50,    31,
+      48,    33,    35,    30,    31,    51,    30,    36,    38,    53,
+      55,    56,    66,    31,    24,    43,    31,    59,    42,    54,
+      63,    25,    25,    26,    44,    65,     1,    52,    57,     4,
+       2,     5,    47,     6,     7,     1,     4,    60,    25,     2,
+       6,     7,    18,    61,    64,    67,    68,    62,     0,     0,
+      29
+};
+
+static const yytype_int8 yycheck[] =
+{
+       2,     5,     3,     3,     4,    28,     7,     4,     9,    12,
+       9,    12,     7,    14,    17,    16,    17,    14,     0,     4,
+      22,    21,    24,    46,     4,    10,    14,    31,    32,    14,
+      30,     8,    12,     4,    14,    35,     4,    17,    10,    10,
+      42,    43,    10,    14,     6,     6,    14,    47,     6,     8,
+      52,    13,    13,    15,    15,    57,     3,     7,     6,    12,
+       7,    14,     9,    16,    17,     3,    12,    10,    13,     7,
+      16,    17,     4,    10,    10,     8,    10,    51,    -1,    -1,
+      11
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,     3,     7,     9,    12,    14,    16,    17,    19,    21,
+      24,    25,    26,    27,    28,    29,    27,    26,    24,    26,
+      29,     9,     7,     0,     6,    13,    15,    20,    22,    28,
+       4,    14,    14,     8,    10,    12,    17,    30,    10,    26,
+      27,    27,     6,     6,    15,    20,    23,     9,    26,    29,
+      29,    26,     7,    10,     8,    27,    27,     6,    20,    26,
+      10,    10,    30,    27,    10,    27,    10,     8,    10
+};
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		(-2)
+#define YYEOF		0
+
+#define YYACCEPT	goto yyacceptlab
+#define YYABORT		goto yyabortlab
+#define YYERROR		goto yyerrorlab
+
+
+/* Like YYERROR except do call yyerror.  This remains here temporarily
+   to ease the transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+
+#define YYFAIL		goto yyerrlab
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)					\
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      yytoken = YYTRANSLATE (yychar);				\
+      YYPOPSTACK (1);						\
+      goto yybackup;						\
+    }								\
+  else								\
+    {								\
+      yyerror (YY_("syntax error: cannot back up")); \
+      YYERROR;							\
+    }								\
+while (YYID (0))
+
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (YYID (N))                                                    \
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
+    while (YYID (0))
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)			\
+     fprintf (File, "%d.%d-%d.%d",			\
+	      (Loc).first_line, (Loc).first_column,	\
+	      (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (YYLEX_PARAM)
+#else
+# define YYLEX yylex ()
+#endif
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)			\
+do {						\
+  if (yydebug)					\
+    YYFPRINTF Args;				\
+} while (YYID (0))
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
+do {									  \
+  if (yydebug)								  \
+    {									  \
+      YYFPRINTF (stderr, "%s ", Title);					  \
+      yy_symbol_print (stderr,						  \
+		  Type, Value); \
+      YYFPRINTF (stderr, "\n");						  \
+    }									  \
+} while (YYID (0))
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+#endif
+{
+  if (!yyvaluep)
+    return;
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+  YYUSE (yyoutput);
+# endif
+  switch (yytype)
+    {
+      default:
+	break;
+    }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+#endif
+{
+  if (yytype < YYNTOKENS)
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+  else
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
+#else
+static void
+yy_stack_print (bottom, top)
+    yytype_int16 *bottom;
+    yytype_int16 *top;
+#endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
+} while (YYID (0))
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
+#else
+static void
+yy_reduce_print (yyvsp, yyrule)
+    YYSTYPE *yyvsp;
+    int yyrule;
+#endif
+{
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+	     yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      fprintf (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+		       &(yyvsp[(yyi + 1) - (yynrhs)])
+		       		       );
+      fprintf (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (yyvsp, Rule); \
+} while (YYID (0))
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef	YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static YYSIZE_T
+yystrlen (const char *yystr)
+#else
+static YYSIZE_T
+yystrlen (yystr)
+    const char *yystr;
+#endif
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+#else
+static char *
+yystpcpy (yydest, yysrc)
+    char *yydest;
+    const char *yysrc;
+#endif
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+	switch (*++yyp)
+	  {
+	  case '\'':
+	  case ',':
+	    goto do_not_strip_quotes;
+
+	  case '\\':
+	    if (*++yyp != '\\')
+	      goto do_not_strip_quotes;
+	    /* Fall through.  */
+	  default:
+	    if (yyres)
+	      yyres[yyn] = *yyp;
+	    yyn++;
+	    break;
+
+	  case '"':
+	    if (yyres)
+	      yyres[yyn] = '\0';
+	    return yyn;
+	  }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into YYRESULT an error message about the unexpected token
+   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
+   including the terminating null byte.  If YYRESULT is null, do not
+   copy anything; just return the number of bytes that would be
+   copied.  As a special case, return 0 if an ordinary "syntax error"
+   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
+   size calculation.  */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
+{
+  int yyn = yypact[yystate];
+
+  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+    return 0;
+  else
+    {
+      int yytype = YYTRANSLATE (yychar);
+      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+      YYSIZE_T yysize = yysize0;
+      YYSIZE_T yysize1;
+      int yysize_overflow = 0;
+      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+      int yyx;
+
+# if 0
+      /* This is so xgettext sees the translatable formats that are
+	 constructed on the fly.  */
+      YY_("syntax error, unexpected %s");
+      YY_("syntax error, unexpected %s, expecting %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+      char *yyfmt;
+      char const *yyf;
+      static char const yyunexpected[] = "syntax error, unexpected %s";
+      static char const yyexpecting[] = ", expecting %s";
+      static char const yyor[] = " or %s";
+      char yyformat[sizeof yyunexpected
+		    + sizeof yyexpecting - 1
+		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+		       * (sizeof yyor - 1))];
+      char const *yyprefix = yyexpecting;
+
+      /* Start YYX at -YYN if negative to avoid negative indexes in
+	 YYCHECK.  */
+      int yyxbegin = yyn < 0 ? -yyn : 0;
+
+      /* Stay within bounds of both yycheck and yytname.  */
+      int yychecklim = YYLAST - yyn + 1;
+      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+      int yycount = 1;
+
+      yyarg[0] = yytname[yytype];
+      yyfmt = yystpcpy (yyformat, yyunexpected);
+
+      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+	  {
+	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+	      {
+		yycount = 1;
+		yysize = yysize0;
+		yyformat[sizeof yyunexpected - 1] = '\0';
+		break;
+	      }
+	    yyarg[yycount++] = yytname[yyx];
+	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+	    yysize_overflow |= (yysize1 < yysize);
+	    yysize = yysize1;
+	    yyfmt = yystpcpy (yyfmt, yyprefix);
+	    yyprefix = yyor;
+	  }
+
+      yyf = YY_(yyformat);
+      yysize1 = yysize + yystrlen (yyf);
+      yysize_overflow |= (yysize1 < yysize);
+      yysize = yysize1;
+
+      if (yysize_overflow)
+	return YYSIZE_MAXIMUM;
+
+      if (yyresult)
+	{
+	  /* Avoid sprintf, as that infringes on the user's name space.
+	     Don't have undefined behavior even if the translation
+	     produced a string with the wrong number of "%s"s.  */
+	  char *yyp = yyresult;
+	  int yyi = 0;
+	  while ((*yyp = *yyf) != '\0')
+	    {
+	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+		{
+		  yyp += yytnamerr (yyp, yyarg[yyi++]);
+		  yyf += 2;
+		}
+	      else
+		{
+		  yyp++;
+		  yyf++;
+		}
+	    }
+	}
+      return yysize;
+    }
+}
+#endif /* YYERROR_VERBOSE */
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
+#else
+static void
+yydestruct (yymsg, yytype, yyvaluep)
+    const char *yymsg;
+    int yytype;
+    YYSTYPE *yyvaluep;
+#endif
+{
+  YYUSE (yyvaluep);
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  switch (yytype)
+    {
+
+      default:
+	break;
+    }
+}
+
+
+/* Prevent warnings from -Wmissing-prototypes.  */
+
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
+
+
+
+/* The look-ahead symbol.  */
+int yychar;
+
+/* The semantic value of the look-ahead symbol.  */
+YYSTYPE yylval;
+
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+    void *YYPARSE_PARAM;
+#endif
+#else /* ! YYPARSE_PARAM */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void)
+#else
+int
+yyparse ()
+
+#endif
+#endif
+{
+
+  int yystate;
+  int yyn;
+  int yyresult;
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Look-ahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack.  */
+  yytype_int16 yyssa[YYINITDEPTH];
+  yytype_int16 *yyss = yyssa;
+  yytype_int16 *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  YYSTYPE *yyvsp;
+
+
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss;
+  yyvsp = yyvs;
+
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+	/* Give user a chance to reallocate the stack.  Use copies of
+	   these so that the &'s don't force the real ones into
+	   memory.  */
+	YYSTYPE *yyvs1 = yyvs;
+	yytype_int16 *yyss1 = yyss;
+
+
+	/* Each stack pointer address is followed by the size of the
+	   data in use in that stack, in bytes.  This used to be a
+	   conditional around just the two extra args, but that might
+	   be undefined if yyoverflow is a macro.  */
+	yyoverflow (YY_("memory exhausted"),
+		    &yyss1, yysize * sizeof (*yyssp),
+		    &yyvs1, yysize * sizeof (*yyvsp),
+
+		    &yystacksize);
+
+	yyss = yyss1;
+	yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+	goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+	yystacksize = YYMAXDEPTH;
+
+      {
+	yytype_int16 *yyss1 = yyss;
+	union yyalloc *yyptr =
+	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+	if (! yyptr)
+	  goto yyexhaustedlab;
+	YYSTACK_RELOCATE (yyss);
+	YYSTACK_RELOCATE (yyvs);
+
+#  undef YYSTACK_RELOCATE
+	if (yyss1 != yyssa)
+	  YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+		  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+	YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     look-ahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to look-ahead token.  */
+  yyn = yypact[yystate];
+  if (yyn == YYPACT_NINF)
+    goto yydefault;
+
+  /* Not known => get a look-ahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = YYLEX;
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yyn == 0 || yyn == YYTABLE_NINF)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  yystate = yyn;
+  *++yyvsp = yylval;
+
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 2:
+#line 130 "said.y"
+    { (yyval) = said_top_branch(said_attach_branch((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]))); ;}
+    break;
+
+  case 3:
+#line 132 "said.y"
+    { (yyval) = said_top_branch(said_attach_branch((yyvsp[(1) - (3)]), said_attach_branch((yyvsp[(2) - (3)]), (yyvsp[(3) - (3)])))); ;}
+    break;
+
+  case 4:
+#line 134 "said.y"
+    { (yyval) = said_top_branch(said_attach_branch((yyvsp[(1) - (4)]), said_attach_branch((yyvsp[(2) - (4)]), said_attach_branch((yyvsp[(3) - (4)]), (yyvsp[(4) - (4)]))))); ;}
+    break;
+
+  case 5:
+#line 139 "said.y"
+    { (yyval) = SAID_BRANCH_NULL; ;}
+    break;
+
+  case 6:
+#line 141 "said.y"
+    { (yyval) = said_paren(said_value(0x14b, said_value(0xf900, said_terminal(0xf900))), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 7:
+#line 147 "said.y"
+    { (yyval) = SAID_BRANCH_NULL; ;}
+    break;
+
+  case 8:
+#line 149 "said.y"
+    { (yyval) = said_paren(said_value(0x141, said_value(0x149, (yyvsp[(1) - (1)]))), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 9:
+#line 155 "said.y"
+    { (yyval) = said_aug_branch(0x142, 0x14a, (yyvsp[(2) - (2)]), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 10:
+#line 157 "said.y"
+    { (yyval) = said_aug_branch(0x152, 0x142, said_aug_branch(0x142, 0x14a, (yyvsp[(3) - (4)]), SAID_BRANCH_NULL), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 11:
+#line 159 "said.y"
+    { (yyval) = SAID_BRANCH_NULL; ;}
+    break;
+
+  case 12:
+#line 165 "said.y"
+    { (yyval) = said_aug_branch(0x143, 0x14a, (yyvsp[(2) - (2)]), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 13:
+#line 167 "said.y"
+    { (yyval) = said_aug_branch(0x152, 0x143, said_aug_branch(0x143, 0x14a, (yyvsp[(3) - (4)]), SAID_BRANCH_NULL), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 14:
+#line 169 "said.y"
+    { (yyval) = SAID_BRANCH_NULL; ;}
+    break;
+
+  case 15:
+#line 174 "said.y"
+    { (yyval) = said_paren(said_value(0x141, said_value(0x153, said_terminal((yyvsp[(1) - (1)])))), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 16:
+#line 179 "said.y"
+    { (yyval) = said_aug_branch(0x141, 0x14f, (yyvsp[(1) - (1)]), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 17:
+#line 181 "said.y"
+    { (yyval) = said_aug_branch(0x141, 0x14f, said_aug_branch(0x152, 0x14c, said_aug_branch(0x141, 0x14f, (yyvsp[(2) - (3)]), SAID_BRANCH_NULL), SAID_BRANCH_NULL), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 18:
+#line 186 "said.y"
+    { (yyval) = (yyvsp[(1) - (1)]); ;}
+    break;
+
+  case 19:
+#line 188 "said.y"
+    { (yyval) = said_aug_branch(0x141, 0x14c, (yyvsp[(2) - (3)]), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 20:
+#line 190 "said.y"
+    { (yyval) = said_attach_branch((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); ;}
+    break;
+
+  case 21:
+#line 192 "said.y"
+    { (yyval) = said_attach_branch((yyvsp[(1) - (4)]), (yyvsp[(3) - (4)])); ;}
+    break;
+
+  case 22:
+#line 194 "said.y"
+    { (yyval) = said_attach_branch((yyvsp[(1) - (5)]), (yyvsp[(3) - (5)])); ;}
+    break;
+
+  case 23:
+#line 199 "said.y"
+    { (yyval) = said_attach_branch((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)])); ;}
+    break;
+
+  case 24:
+#line 201 "said.y"
+    { (yyval) = (yyvsp[(1) - (1)]); ;}
+    break;
+
+  case 25:
+#line 203 "said.y"
+    { (yyval) = (yyvsp[(1) - (1)]); ;}
+    break;
+
+  case 26:
+#line 208 "said.y"
+    { (yyval) = (yyvsp[(1) - (1)]); ;}
+    break;
+
+  case 27:
+#line 210 "said.y"
+    { (yyval) = said_aug_branch(0x152, 0x144, (yyvsp[(2) - (3)]), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 28:
+#line 212 "said.y"
+    { (yyval) = said_attach_branch((yyvsp[(1) - (4)]), said_aug_branch(0x152, 0x144, (yyvsp[(3) - (4)]), SAID_BRANCH_NULL)); ;}
+    break;
+
+  case 29:
+#line 217 "said.y"
+    { (yyval) = said_aug_branch(0x144, 0x14f, (yyvsp[(2) - (3)]), (yyvsp[(3) - (3)])); ;}
+    break;
+
+  case 30:
+#line 219 "said.y"
+    { (yyval) = said_aug_branch(0x144, 0x14f, said_aug_branch(0x141, 0x144, (yyvsp[(2) - (4)]), SAID_BRANCH_NULL), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 31:
+#line 221 "said.y"
+    { (yyval) = said_aug_branch(0x144, 0x14f, (yyvsp[(2) - (2)]), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 32:
+#line 223 "said.y"
+    { (yyval) = said_aug_branch(0x152, 0x144, said_aug_branch(0x144, 0x14f, (yyvsp[(3) - (4)]), SAID_BRANCH_NULL), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 33:
+#line 228 "said.y"
+    { (yyval) = said_aug_branch(0x141, 0x144, said_aug_branch(0x144, 0x14f, (yyvsp[(2) - (3)]), SAID_BRANCH_NULL), (yyvsp[(3) - (3)])); ;}
+    break;
+
+  case 34:
+#line 230 "said.y"
+    { (yyval) = said_aug_branch(0x141, 0x144, said_aug_branch(0x144, 0x14f, (yyvsp[(2) - (2)]), SAID_BRANCH_NULL), SAID_BRANCH_NULL); ;}
+    break;
+
+  case 35:
+#line 232 "said.y"
+    { (yyval) = said_aug_branch(0x141, 0x14c, (yyvsp[(2) - (4)]), SAID_BRANCH_NULL); ;}
+    break;
+
+
+/* Line 1267 of yacc.c.  */
+#line 1665 "said.tab.c"
+      default: break;
+    }
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+
+  /* Now `shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (YY_("syntax error"));
+#else
+      {
+	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+	  {
+	    YYSIZE_T yyalloc = 2 * yysize;
+	    if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
+	    if (yymsg != yymsgbuf)
+	      YYSTACK_FREE (yymsg);
+	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+	    if (yymsg)
+	      yymsg_alloc = yyalloc;
+	    else
+	      {
+		yymsg = yymsgbuf;
+		yymsg_alloc = sizeof yymsgbuf;
+	      }
+	  }
+
+	if (0 < yysize && yysize <= yymsg_alloc)
+	  {
+	    (void) yysyntax_error (yymsg, yystate, yychar);
+	    yyerror (yymsg);
+	  }
+	else
+	  {
+	    yyerror (YY_("syntax error"));
+	    if (yysize != 0)
+	      goto yyexhaustedlab;
+	  }
+      }
+#endif
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse look-ahead token after an
+	 error, discard it.  */
+
+      if (yychar <= YYEOF)
+	{
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
+	}
+      else
+	{
+	  yydestruct ("Error: discarding",
+		      yytoken, &yylval);
+	  yychar = YYEMPTY;
+	}
+    }
+
+  /* Else will try to reuse look-ahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (yyn != YYPACT_NINF)
+	{
+	  yyn += YYTERROR;
+	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+	    {
+	      yyn = yytable[yyn];
+	      if (0 < yyn)
+		break;
+	    }
+	}
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+	YYABORT;
+
+
+      yydestruct ("Error: popping",
+		  yystos[yystate], yyvsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  *++yyvsp = yylval;
+
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#ifndef yyoverflow
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+		 yytoken, &yylval);
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+		  yystos[*yyssp], yyvsp);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  /* Make sure YYID is used.  */
+  return YYID (yyresult);
+}
+
+
+#line 235 "said.y"
+
+
+int parse_yy_token_lookup[] = {YY_COMMA, YY_AMP, YY_SLASH, YY_PARENO, YY_PARENC, YY_BRACKETSO, YY_BRACKETSC, YY_HASH, YY_LT, YY_GT};
+
+static int yylex(void) {
+	int retval = said_tokens[said_token++];
+
+	if (retval < SAID_LONG(SAID_FIRST)) {
+		yylval = retval;
+		retval = WGROUP;
+	} else {
+		retval >>= 8;
+
+		if (retval == SAID_TERM)
+			retval = 0;
+		else {
+			assert(retval >= SAID_FIRST);
+			retval = parse_yy_token_lookup[retval - SAID_FIRST];
+			if (retval == YY_BRACKETSO) {
+				if ((said_tokens[said_token] >> 8) == SAID_LT)
+					retval = YY_BRACKETSO_LT;
+				else
+					if ((said_tokens[said_token] >> 8) == SAID_SLASH)
+						retval = YY_BRACKETSO_SLASH;
+			} else if (retval == YY_LT && (said_tokens[said_token] >> 8) == SAID_BRACKO) {
+				retval = YY_LT_BRACKETSO;
+			} else if (retval == YY_LT && (said_tokens[said_token] >> 8) == SAID_PARENO) {
+				retval = YY_LT_PARENO;
+			}
+		}
+	}
+
+	return retval;
+}
+
+static int said_next_node() {
+	return ((said_tree_pos == 0) || (said_tree_pos >= VOCAB_TREE_NODES)) ? said_tree_pos = 0 : said_tree_pos++;
+}
+
+#define SAID_NEXT_NODE said_next_node()
+
+static int said_leaf_node(tree_t pos, int value) {
+	said_tree[pos].type = kParseTreeLeafNode;
+
+	if (value != VALUE_IGNORE)
+		said_tree[pos].content.value = value;
+
+	return pos;
+}
+
+static int said_branch_node(tree_t pos, int left, int right) {
+	said_tree[pos].type = kParseTreeBranchNode;
+
+	if (left != VALUE_IGNORE)
+		said_tree[pos].content.branches[0] = left;
+
+	if (right != VALUE_IGNORE)
+		said_tree[pos].content.branches[1] = right;
+
+	return pos;
+}
+
+static tree_t said_paren(tree_t t1, tree_t t2) {
+	if (t1)
+		return said_branch_node(SAID_NEXT_NODE, t1, t2);
+	else
+		return t2;
+}
+
+static tree_t said_value(int val, tree_t t) {
+	return said_branch_node(SAID_NEXT_NODE, said_leaf_node(SAID_NEXT_NODE, val), t);
+
+}
+
+static tree_t said_terminal(int val) {
+	return said_leaf_node(SAID_NEXT_NODE, val);
+}
+
+static tree_t said_aug_branch(int n1, int n2, tree_t t1, tree_t t2) {
+	int retval;
+
+	retval = said_branch_node(SAID_NEXT_NODE,
+				said_branch_node(SAID_NEXT_NODE,
+					said_leaf_node(SAID_NEXT_NODE, n1),
+						said_branch_node(SAID_NEXT_NODE,
+							said_leaf_node(SAID_NEXT_NODE, n2),
+						t1)
+					),
+				t2);
+
+#ifdef SAID_DEBUG
+	fprintf(stderr, "AUG(0x%x, 0x%x, [%04x], [%04x]) = [%04x]\n", n1, n2, t1, t2, retval);
+#endif
+
+	return retval;
+}
+
+static tree_t said_attach_branch(tree_t base, tree_t attacheant) {
+#ifdef SAID_DEBUG
+	fprintf(stderr, "ATT2([%04x], [%04x]) = [%04x]\n", base, attacheant, base);
+#endif
+
+	if (!attacheant)
+		return base;
+	if (!base)
+		return attacheant;
+
+	if (!base)
+		return 0; // Happens if we're out of space
+
+	said_branch_node(base, VALUE_IGNORE, attacheant);
+
+	return base;
+}
+
+static said_spec_t said_top_branch(tree_t first) {
+#ifdef SAID_DEBUG
+	fprintf(stderr, "TOP([%04x])\n", first);
+#endif
+	said_branch_node(0, 1, 2);
+	said_leaf_node(1, 0x141); // Magic number #1
+	said_branch_node(2, 3, first);
+	said_leaf_node(3, 0x13f); // Magic number #2
+
+	++said_blessed;
+
+	return 0;
+}
+
+static int said_parse_spec(byte *spec) {
+	int nextitem;
+
+	said_parse_error = NULL;
+	said_token = 0;
+	said_tokens_nr = 0;
+	said_blessed = 0;
+
+	said_tree_pos = SAID_TREE_START;
+
+	do {
+		nextitem = *spec++;
+		if (nextitem < SAID_FIRST)
+			said_tokens[said_tokens_nr++] = nextitem << 8 | *spec++;
+		else
+			said_tokens[said_tokens_nr++] = SAID_LONG(nextitem);
+
+	} while ((nextitem != SAID_TERM) && (said_tokens_nr < MAX_SAID_TOKENS));
+
+	if (nextitem == SAID_TERM)
+		yyparse();
+	else {
+		warning("SAID spec is too long");
+		return 1;
+	}
+
+	if (said_parse_error) {
+		warning("Error while parsing SAID spec: %s", said_parse_error);
+		free(said_parse_error);
+		return 1;
+	}
+
+	if (said_tree_pos == 0) {
+		warning("Out of tree space while parsing SAID spec");
+		return 1;
+	}
+
+	if (said_blessed != 1) {
+		warning("Found multiple top branches");
+		return 1;
+	}
+
+	return 0;
+}
+
+/**********************/
+/**** Augmentation ****/
+/**********************/
+
+// primitive functions
+
+#define AUG_READ_BRANCH(a, br, p) \
+	if (tree[p].type != kParseTreeBranchNode) \
+		return 0; \
+	a = tree[p].content.branches[br];
+
+#define AUG_READ_VALUE(a, p) \
+	if (tree[p].type != kParseTreeLeafNode) \
+		return 0; \
+	a = tree[p].content.value;
+
+#define AUG_ASSERT(i) \
+	if (!i) return 0;
+
+static int aug_get_next_sibling(parse_tree_node_t *tree, int pos, int *first, int *second) {
+	// Returns the next sibling relative to the specified position in 'tree',
+	// sets *first and *second to its augment node values, returns the new position
+	// or 0 if there was no next sibling
+	int seek, valpos;
+
+	AUG_READ_BRANCH(pos, 1, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_BRANCH(seek, 0, pos);
+	AUG_ASSERT(seek);
+
+	// Now retrieve first value
+	AUG_READ_BRANCH(valpos, 0, seek);
+	AUG_ASSERT(valpos);
+	AUG_READ_VALUE(*first, valpos);
+
+	// Get second value
+	AUG_READ_BRANCH(seek, 1, seek);
+	AUG_ASSERT(seek);
+	AUG_READ_BRANCH(valpos, 0, seek);
+	AUG_ASSERT(valpos);
+	AUG_READ_VALUE(*second, valpos);
+
+	return pos;
+}
+
+static int aug_get_wgroup(parse_tree_node_t *tree, int pos) {
+	// Returns 0 if pos in tree is not the root of a 3-element list, otherwise
+	// it returns the last element (which, in practice, is the word group
+	int val;
+
+	AUG_READ_BRANCH(pos, 0, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_BRANCH(pos, 1, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_BRANCH(pos, 1, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_VALUE(val, pos);
+
+	return val;
+}
+
+static int aug_get_base_node(parse_tree_node_t *tree) {
+	int startpos = 0;
+	AUG_READ_BRANCH(startpos, 1, startpos);
+
+	return startpos;
+}
+
+// semi-primitive functions
+
+static int aug_get_first_child(parse_tree_node_t *tree, int pos, int *first, int *second) {
+	// like aug_get_next_sibling, except that it recurses into the tree and
+	// finds the first child (usually *not* Ayanami Rei) of the current branch
+	// rather than its next sibling.
+	AUG_READ_BRANCH(pos, 0, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_BRANCH(pos, 1, pos);
+	AUG_ASSERT(pos);
+
+	return aug_get_next_sibling(tree, pos, first, second);
+}
+
+static void aug_find_words_recursively(parse_tree_node_t *tree, int startpos, int *base_words, int *base_words_nr,
+			   int *ref_words, int *ref_words_nr, int maxwords, int refbranch) {
+	// Finds and lists all base (141) and reference (144) words */
+	int major, minor;
+	int word;
+	int pos = aug_get_first_child(tree, startpos, &major, &minor);
+
+	//if (major == WORD_TYPE_REF)
+	//	refbranch = 1;
+
+	while (pos) {
+		if ((word = aug_get_wgroup(tree, pos))) { // found a word
+			if (!refbranch && major == WORD_TYPE_BASE) {
+				if ((*base_words_nr) == maxwords) {
+					warning("Out of regular words");
+					return; // return gracefully
+				}
+
+				base_words[*base_words_nr] = word; // register word
+				++(*base_words_nr);
+
+			}
+			if (major == WORD_TYPE_REF || refbranch) {
+				if ((*ref_words_nr) == maxwords) {
+					warning("Out of reference words");
+					return; // return gracefully
+				}
+
+				ref_words[*ref_words_nr] = word; // register word
+				++(*ref_words_nr);
+
+			}
+			if (major != WORD_TYPE_SYNTACTIC_SUGAR && major != WORD_TYPE_BASE && major != WORD_TYPE_REF)
+				warning("aug_find_words_recursively(): Unknown word type %03x", major);
+
+		} else // Did NOT find a word group: Attempt to recurse
+			aug_find_words_recursively(tree, pos, base_words, base_words_nr,
+						   ref_words, ref_words_nr, maxwords, refbranch || major == WORD_TYPE_REF);
+
+		pos = aug_get_next_sibling(tree, pos, &major, &minor);
+	}
+}
+
+
+static void aug_find_words(parse_tree_node_t *tree, int startpos, int *base_words, int *base_words_nr,
+				int *ref_words, int *ref_words_nr, int maxwords) {
+	// initializing wrapper for aug_find_words_recursively()
+	*base_words_nr = 0;
+	*ref_words_nr = 0;
+
+	aug_find_words_recursively(tree, startpos, base_words, base_words_nr, ref_words, ref_words_nr, maxwords, 0);
+}
+
+
+static int aug_contains_word(int *list, int length, int word) {
+	int i;
+
+	if (word == ANYWORD)
+		return (length);
+
+	for (i = 0; i < length; i++)
+		if (list[i] == word)
+			return 1;
+
+	return 0;
+}
+
+
+static int augment_sentence_expression(parse_tree_node_t *saidt, int augment_pos, parse_tree_node_t *parset,
+					int parse_branch, int major, int minor, int *base_words, int base_words_nr,
+					int *ref_words, int ref_words_nr);
+
+static int augment_match_expression_p(parse_tree_node_t *saidt, int augment_pos, parse_tree_node_t *parset,
+					int parse_basepos, int major, int minor,
+			   int *base_words, int base_words_nr, int *ref_words, int ref_words_nr) {
+	int cmajor, cminor, cpos;
+	cpos = aug_get_first_child(saidt, augment_pos, &cmajor, &cminor);
+	if (!cpos) {
+		warning("augment_match_expression_p(): Empty condition");
+		return 1;
+	}
+
+	scidprintf("Attempting to match (%03x %03x (%03x %03x\n", major, minor, cmajor, cminor);
+
+	if ((major == WORD_TYPE_BASE) && (minor == AUGMENT_SENTENCE_MINOR_RECURSE))
+		return augment_match_expression_p(saidt, cpos, parset, parse_basepos, cmajor, cminor,
+						  base_words, base_words_nr, ref_words, ref_words_nr);
+
+	switch (major) {
+
+	case WORD_TYPE_BASE:
+		while (cpos) {
+			if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_WORD) {
+				int word = aug_get_wgroup(saidt, cpos);
+				scidprintf("Looking for word %03x\n", word);
+
+				if (aug_contains_word(base_words, base_words_nr, word))
+					return 1;
+			} else if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_PHRASE) {
+				if (augment_sentence_expression(saidt, cpos, parset, parse_basepos, cmajor, cminor,
+								base_words, base_words_nr, ref_words, ref_words_nr))
+					return 1;
+			} else if (cminor == AUGMENT_SENTENCE_MINOR_PARENTHESES) {
+				int gc_major, gc_minor;
+				int gchild = aug_get_first_child(saidt, cpos, &gc_major, &gc_minor);
+
+				while (gchild) {
+					if (augment_match_expression_p(saidt, cpos, parset, parse_basepos, major,
+									minor, base_words, base_words_nr,
+								       ref_words, ref_words_nr))
+						return 1;
+					gchild = aug_get_next_sibling(saidt, gchild, &gc_major, &gc_minor);
+				}
+			} else
+				warning("augment_match_expression_p(): Unknown type 141 minor number %3x", cminor);
+
+			cpos = aug_get_next_sibling(saidt, cpos, &cmajor, &cminor);
+
+		}
+		break;
+
+	case WORD_TYPE_REF:
+		while (cpos) {
+			if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_WORD) {
+				int word = aug_get_wgroup(saidt, cpos);
+				scidprintf("Looking for refword %03x\n", word);
+
+				if (aug_contains_word(ref_words, ref_words_nr, word))
+					return 1;
+			} else if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_PHRASE) {
+				if (augment_match_expression_p(saidt, cpos, parset, parse_basepos, cmajor, cminor,
+							       base_words, base_words_nr, ref_words, ref_words_nr))
+					return 1;
+			} else if (cminor == AUGMENT_SENTENCE_MINOR_PARENTHESES) {
+				int gc_major, gc_minor;
+				int gchild = aug_get_first_child(saidt, cpos, &gc_major, &gc_minor);
+
+				while (gchild) {
+					if (augment_match_expression_p(saidt, cpos, parset, parse_basepos, major,
+									minor, base_words, base_words_nr,
+									ref_words, ref_words_nr))
+						return 1;
+					gchild = aug_get_next_sibling(saidt, gchild, &gc_major, &gc_minor);
+				}
+			} else
+				warning("augment_match_expression_p(): Unknown type 144 minor number %3x", cminor);
+
+			cpos = aug_get_next_sibling(saidt, cpos, &cmajor, &cminor);
+
+		}
+		break;
+
+	case AUGMENT_SENTENCE_PART_BRACKETS:
+		if (augment_match_expression_p(saidt, cpos, parset, parse_basepos, cmajor, cminor,
+					       base_words, base_words_nr, ref_words, ref_words_nr))
+			return 1;
+
+		scidprintf("Didn't match subexpression; checking sub-bracked predicate %03x\n", cmajor);
+
+		switch (cmajor) {
+		case WORD_TYPE_BASE:
+			if (!base_words_nr)
+				return 1;
+			break;
+
+		case WORD_TYPE_REF:
+			if (!ref_words_nr)
+				return 1;
+			break;
+
+		default:
+			warning("augment_match_expression_p(): (subp1) Unkonwn sub-bracket predicate %03x", cmajor);
+		}
+
+		break;
+
+	default:
+		warning("augment_match_expression_p(): Unknown predicate %03x", major);
+
+	}
+
+	scidprintf("augment_match_expression_p(): Generic failure\n");
+
+	return 0;
+}
+
+static int augment_sentence_expression(parse_tree_node_t *saidt, int augment_pos, parse_tree_node_t *parset,
+					int parse_branch, int major, int minor, int *base_words, int base_words_nr,
+					int *ref_words, int ref_words_nr) {
+	int check_major, check_minor;
+	int check_pos = aug_get_first_child(saidt, augment_pos, &check_major, &check_minor);
+	do {
+		if (!(augment_match_expression_p(saidt, check_pos, parset, parse_branch, check_major, check_minor,
+						base_words, base_words_nr, ref_words, ref_words_nr)))
+			return 0;
+	} while ((check_pos = aug_get_next_sibling(saidt, check_pos, &check_major, &check_minor)));
+
+	return 1;
+}
+
+static int augment_sentence_part(parse_tree_node_t *saidt, int augment_pos, parse_tree_node_t *parset, int parse_basepos, int major, int minor) {
+	int pmajor, pminor;
+	int parse_branch = parse_basepos;
+	int optional = 0;
+	int foundwords = 0;
+
+	scidprintf("Augmenting (%03x %03x\n", major, minor);
+
+	if (major == AUGMENT_SENTENCE_PART_BRACKETS) { // '[/ foo]' is true if '/foo' or if there
+						       // exists no x for which '/x' is true
+		if ((augment_pos = aug_get_first_child(saidt, augment_pos, &major, &minor))) {
+			scidprintf("Optional part: Now augmenting (%03x %03x\n", major, minor);
+			optional = 1;
+		} else {
+			scidprintf("Matched empty optional expression\n");
+			return 1;
+		}
+	}
+
+	if ((major < 0x141) || (major > 0x143)) {
+		scidprintf("augment_sentence_part(): Unexpected sentence part major number %03x\n", major);
+		return 0;
+	}
+
+	while ((parse_branch = aug_get_next_sibling(parset, parse_branch, &pmajor, &pminor))) {
+		if (pmajor == major) { // found matching sentence part
+			int success;
+			int base_words_nr;
+			int ref_words_nr;
+			int base_words[AUGMENT_MAX_WORDS];
+			int ref_words[AUGMENT_MAX_WORDS];
+#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION
+			int i;
+#endif
+
+			scidprintf("Found match with pminor = %03x\n", pminor);
+			aug_find_words(parset, parse_branch, base_words, &base_words_nr, ref_words, &ref_words_nr, AUGMENT_MAX_WORDS);
+			foundwords |= (ref_words_nr | base_words_nr);
+#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION
+			printf("%d base words:", base_words_nr);
+			for (i = 0; i < base_words_nr; i++)
+				printf(" %03x", base_words[i]);
+			printf("\n%d reference words:", ref_words_nr);
+			for (i = 0; i < ref_words_nr; i++)
+				printf(" %03x", ref_words[i]);
+			printf("\n");
+#endif
+
+			success = augment_sentence_expression(saidt, augment_pos, parset, parse_basepos, major, minor,
+							      base_words, base_words_nr, ref_words, ref_words_nr);
+
+			if (success) {
+				scidprintf("SUCCESS on augmenting (%03x %03x\n", major, minor);
+				return 1;
+			}
+		}
+	}
+
+	if (optional && (foundwords == 0)) {
+		scidprintf("Found no words and optional branch => SUCCESS on augmenting (%03x %03x\n", major, minor);
+		return 1;
+	}
+	scidprintf("FAILURE on augmenting (%03x %03x\n", major, minor);
+
+	return 0;
+}
+
+static int augment_parse_nodes(parse_tree_node_t *parset, parse_tree_node_t *saidt) {
+	int augment_basepos = 0;
+	int parse_basepos;
+	int major, minor;
+	int dontclaim = 0;
+
+	parse_basepos = aug_get_base_node(parset);
+	if (!parse_basepos) {
+		warning("augment_parse_nodes(): Parse tree is corrupt");
+		return 0;
+	}
+
+	augment_basepos = aug_get_base_node(saidt);
+	if (!augment_basepos) {
+		warning("augment_parse_nodes(): Said tree is corrupt");
+		return 0;
+	}
+
+	while ((augment_basepos = aug_get_next_sibling(saidt, augment_basepos, &major, &minor))) {
+		if ((major == 0x14b) && (minor == SAID_LONG(SAID_GT)))
+			dontclaim = 1; // special case
+		else // normal sentence part
+			if (!(augment_sentence_part(saidt, augment_basepos, parset, parse_basepos, major, minor))) {
+				scidprintf("Returning failure\n");
+				return 0; // fail
+			}
+	}
+
+	scidprintf("Returning success with dontclaim=%d\n", dontclaim);
+
+	if (dontclaim)
+		return SAID_PARTIAL_MATCH;
+	else
+		return 1; // full match
+}
+
+
+/*******************/
+/**** Main code ****/
+/*******************/
+
+int said(EngineState *s, byte *spec, bool verbose) {
+	int retval;
+
+	parse_tree_node_t *parse_tree_ptr = s->_voc->_parserNodes;
+
+	if (s->parserIsValid) {
+		if (said_parse_spec(spec)) {
+			printf("Offending spec was: ");
+			s->_voc->decipherSaidBlock(spec);
+			return SAID_NO_MATCH;
+		}
+
+		if (verbose)
+			vocab_dump_parse_tree("Said-tree", said_tree); // Nothing better to do yet
+		retval = augment_parse_nodes(parse_tree_ptr, &(said_tree[0]));
+
+		if (!retval)
+			return SAID_NO_MATCH;
+		else if (retval != SAID_PARTIAL_MATCH)
+			return SAID_FULL_MATCH;
+		else
+			return SAID_PARTIAL_MATCH;
+	}
+
+	return SAID_NO_MATCH;
+}
+
+
+#ifdef SAID_DEBUG_PROGRAM
+int main (int argc, char *argv) {
+	byte block[] = {0x01, 0x00, 0xf8, 0xf5, 0x02, 0x01, 0xf6, 0xf2, 0x02, 0x01, 0xf2, 0x01, 0x03, 0xff};
+	EngineState s;
+
+	s.parser_valid = 1;
+	said(&s, block);
+}
+#endif
+
+} // End of namespace Sci
+
diff --git a/engines/sci/parser/said.y b/engines/sci/parser/said.y
new file mode 100644
index 0000000000..1a3b2f52c8
--- /dev/null
+++ b/engines/sci/parser/said.y
@@ -0,0 +1,838 @@
+%{
+/* 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "sci/engine/state.h"
+
+
+// Bison generates an empty switch statement that gives a warning in MSVC.
+// This disables that warning.
+#ifdef _MSC_VER
+#pragma warning(disable:4065)
+#endif
+
+
+namespace Sci {
+
+#define SAID_BRANCH_NULL 0
+
+#define MAX_SAID_TOKENS 128
+
+// Maximum number of words to be expected in a parsed sentence
+#define AUGMENT_MAX_WORDS 64
+
+
+#define ANYWORD 0xfff
+
+#define WORD_TYPE_BASE 0x141
+#define WORD_TYPE_REF 0x144
+#define WORD_TYPE_SYNTACTIC_SUGAR 0x145
+
+#define AUGMENT_SENTENCE_PART_BRACKETS 0x152
+
+// Minor numbers
+#define AUGMENT_SENTENCE_MINOR_MATCH_PHRASE 0x14c
+#define AUGMENT_SENTENCE_MINOR_MATCH_WORD 0x153
+#define AUGMENT_SENTENCE_MINOR_RECURSE 0x144
+#define AUGMENT_SENTENCE_MINOR_PARENTHESES 0x14f
+
+
+#undef YYDEBUG /*1*/
+//#define SAID_DEBUG*/
+//#define SCI_DEBUG_PARSE_TREE_AUGMENTATION // uncomment to debug parse tree augmentation
+
+
+#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION
+#define scidprintf printf
+#else
+void print_nothing(...) { }
+#define scidprintf print_nothing
+#endif
+
+
+static char *said_parse_error;
+
+static int said_token;
+static int said_tokens_nr;
+static int said_tokens[MAX_SAID_TOKENS];
+static int said_blessed;  // increminated by said_top_branch
+
+static int said_tree_pos; // Set to 0 if we're out of space
+#define SAID_TREE_START 4; // Reserve space for the 4 top nodes
+
+#define VALUE_IGNORE -424242
+
+static parse_tree_node_t said_tree[VOCAB_TREE_NODES];
+
+typedef int wgroup_t;
+typedef int tree_t;
+typedef int said_spec_t;
+
+static tree_t said_aug_branch(int, int, tree_t, tree_t);
+static tree_t said_attach_branch(tree_t, tree_t);
+/*
+static tree_t said_wgroup_branch(wgroup_t);
+*/
+static said_spec_t said_top_branch(tree_t);
+static tree_t said_paren(tree_t, tree_t);
+static tree_t said_value(int, tree_t);
+static tree_t said_terminal(int);
+
+static int yylex();
+
+static int yyerror(const char *s) {
+	said_parse_error = strdup(s);
+	return 1; /* Abort */
+}
+
+%}
+
+%token WGROUP /* Word group */
+%token YY_COMMA     /* 0xf0 */
+%token YY_AMP       /* 0xf1 */
+%token YY_SLASH     /* 0xf2 */
+%token YY_PARENO    /* 0xf3 */
+%token YY_PARENC    /* 0xf4 */
+%token YY_BRACKETSO /* 0xf5 */
+%token YY_BRACKETSC /* 0xf6 */
+%token YY_HASH      /* 0xf7 */
+%token YY_LT        /* 0xf8 */
+%token YY_GT        /* 0xf9 */
+%token YY_BRACKETSO_LT /* special token used to imitate LR(2) behaviour */
+%token YY_BRACKETSO_SLASH /* special token used to imitate LR(2) behaviour */
+%token YY_LT_BRACKETSO /* special token used to imitate LR(2) behaviour */
+%token YY_LT_PARENO /* special token used to imitate LR(2) behaviour */
+
+%%
+
+saidspec :	  leftspec optcont
+			{ $$ = said_top_branch(said_attach_branch($1, $2)); }
+		| leftspec midspec optcont
+			{ $$ = said_top_branch(said_attach_branch($1, said_attach_branch($2, $3))); }
+		| leftspec midspec rightspec optcont
+			{ $$ = said_top_branch(said_attach_branch($1, said_attach_branch($2, said_attach_branch($3, $4)))); }
+		;
+
+
+optcont :	 /* empty */
+			{ $$ = SAID_BRANCH_NULL; }
+		| YY_GT
+			{ $$ = said_paren(said_value(0x14b, said_value(0xf900, said_terminal(0xf900))), SAID_BRANCH_NULL); }
+		;
+
+
+
+leftspec :	/* empty */
+			{ $$ = SAID_BRANCH_NULL; }
+		| expr
+			{ $$ = said_paren(said_value(0x141, said_value(0x149, $1)), SAID_BRANCH_NULL); }
+		;
+
+
+
+midspec :	 YY_SLASH expr
+			{ $$ = said_aug_branch(0x142, 0x14a, $2, SAID_BRANCH_NULL); }
+		| YY_BRACKETSO_SLASH YY_SLASH expr YY_BRACKETSC
+			{ $$ = said_aug_branch(0x152, 0x142, said_aug_branch(0x142, 0x14a, $3, SAID_BRANCH_NULL), SAID_BRANCH_NULL); }
+		| YY_SLASH
+			{ $$ = SAID_BRANCH_NULL; }
+		;
+
+
+
+rightspec :	 YY_SLASH expr
+			{ $$ = said_aug_branch(0x143, 0x14a, $2, SAID_BRANCH_NULL); }
+		| YY_BRACKETSO_SLASH YY_SLASH expr YY_BRACKETSC
+			{ $$ = said_aug_branch(0x152, 0x143, said_aug_branch(0x143, 0x14a, $3, SAID_BRANCH_NULL), SAID_BRANCH_NULL); }
+		| YY_SLASH
+			{ $$ = SAID_BRANCH_NULL; }
+		;
+
+
+word :		 WGROUP
+			{ $$ = said_paren(said_value(0x141, said_value(0x153, said_terminal($1))), SAID_BRANCH_NULL); }
+		;
+
+
+cwordset :	wordset
+			{ $$ = said_aug_branch(0x141, 0x14f, $1, SAID_BRANCH_NULL); }
+		| YY_BRACKETSO wordset YY_BRACKETSC
+			{ $$ = said_aug_branch(0x141, 0x14f, said_aug_branch(0x152, 0x14c, said_aug_branch(0x141, 0x14f, $2, SAID_BRANCH_NULL), SAID_BRANCH_NULL), SAID_BRANCH_NULL); }
+		;
+
+
+wordset :	 word
+			{ $$ = $1; }
+		| YY_PARENO expr YY_PARENC
+			{ $$ = said_aug_branch(0x141, 0x14c, $2, SAID_BRANCH_NULL); }
+		| wordset YY_COMMA wordset
+			{ $$ = said_attach_branch($1, $3); }
+		| wordset YY_BRACKETSO_LT wordrefset YY_BRACKETSC
+			{ $$ = said_attach_branch($1, $3); }
+		| wordset YY_COMMA YY_BRACKETSO wordset YY_BRACKETSC
+			{ $$ = said_attach_branch($1, $3); }
+		;
+
+
+expr :		 cwordset cwordrefset
+			{ $$ = said_attach_branch($1, $2); }
+		| cwordset
+			{ $$ = $1; }
+		| cwordrefset
+			{ $$ = $1; }
+		;
+
+
+cwordrefset :	 wordrefset
+			{ $$ = $1; }
+		| YY_BRACKETSO_LT wordrefset YY_BRACKETSC
+			{ $$ = said_aug_branch(0x152, 0x144, $2, SAID_BRANCH_NULL); }
+		| wordrefset YY_BRACKETSO_LT wordrefset YY_BRACKETSC
+			{ $$ = said_attach_branch($1, said_aug_branch(0x152, 0x144, $3, SAID_BRANCH_NULL)); }
+		;
+
+
+wordrefset :	YY_LT word recref
+			{ $$ = said_aug_branch(0x144, 0x14f, $2, $3); }
+		| YY_LT_PARENO YY_PARENO expr YY_PARENC
+		{ $$ = said_aug_branch(0x144, 0x14f, said_aug_branch(0x141, 0x144, $2, SAID_BRANCH_NULL), SAID_BRANCH_NULL); }
+		| YY_LT wordset
+			{ $$ = said_aug_branch(0x144, 0x14f, $2, SAID_BRANCH_NULL); }
+		| YY_LT_BRACKETSO YY_BRACKETSO wordset YY_BRACKETSC
+			{ $$ = said_aug_branch(0x152, 0x144, said_aug_branch(0x144, 0x14f, $3, SAID_BRANCH_NULL), SAID_BRANCH_NULL); }
+		;
+
+
+recref :	YY_LT wordset recref
+			{ $$ = said_aug_branch(0x141, 0x144, said_aug_branch(0x144, 0x14f, $2, SAID_BRANCH_NULL), $3); }
+		| YY_LT wordset
+			{ $$ = said_aug_branch(0x141, 0x144, said_aug_branch(0x144, 0x14f, $2, SAID_BRANCH_NULL), SAID_BRANCH_NULL); }
+		| YY_LT_PARENO YY_PARENO expr YY_PARENC
+		{ $$ = said_aug_branch(0x141, 0x14c, $2, SAID_BRANCH_NULL); }
+		;
+
+%%
+
+int parse_yy_token_lookup[] = {YY_COMMA, YY_AMP, YY_SLASH, YY_PARENO, YY_PARENC, YY_BRACKETSO, YY_BRACKETSC, YY_HASH, YY_LT, YY_GT};
+
+static int yylex() {
+	int retval = said_tokens[said_token++];
+
+	if (retval < SAID_LONG(SAID_FIRST)) {
+		yylval = retval;
+		retval = WGROUP;
+	} else {
+		retval >>= 8;
+
+		if (retval == SAID_TERM)
+			retval = 0;
+		else {
+			assert(retval >= SAID_FIRST);
+			retval = parse_yy_token_lookup[retval - SAID_FIRST];
+			if (retval == YY_BRACKETSO) {
+				if ((said_tokens[said_token] >> 8) == SAID_LT)
+					retval = YY_BRACKETSO_LT;
+				else
+					if ((said_tokens[said_token] >> 8) == SAID_SLASH)
+						retval = YY_BRACKETSO_SLASH;
+			} else if (retval == YY_LT && (said_tokens[said_token] >> 8) == SAID_BRACKO) {
+				retval = YY_LT_BRACKETSO;
+			} else if (retval == YY_LT && (said_tokens[said_token] >> 8) == SAID_PARENO) {
+				retval = YY_LT_PARENO;
+			}
+		}
+	}
+
+	return retval;
+}
+
+static int said_next_node() {
+	return ((said_tree_pos == 0) || (said_tree_pos >= VOCAB_TREE_NODES)) ? said_tree_pos = 0 : said_tree_pos++;
+}
+
+#define SAID_NEXT_NODE said_next_node()
+
+static int said_leaf_node(tree_t pos, int value) {
+	said_tree[pos].type = PARSE_TREE_NODE_LEAF;
+
+	if (value != VALUE_IGNORE)
+		said_tree[pos].content.value = value;
+
+	return pos;
+}
+
+static int said_branch_node(tree_t pos, int left, int right) {
+	said_tree[pos].type = PARSE_TREE_NODE_BRANCH;
+
+	if (left != VALUE_IGNORE)
+		said_tree[pos].content.branches[0] = left;
+
+	if (right != VALUE_IGNORE)
+		said_tree[pos].content.branches[1] = right;
+
+	return pos;
+}
+
+static tree_t said_paren(tree_t t1, tree_t t2) {
+	if (t1)
+		return said_branch_node(SAID_NEXT_NODE, t1, t2);
+	else
+		return t2;
+}
+
+static tree_t said_value(int val, tree_t t) {
+	return said_branch_node(SAID_NEXT_NODE, said_leaf_node(SAID_NEXT_NODE, val), t);
+
+}
+
+static tree_t said_terminal(int val) {
+	return said_leaf_node(SAID_NEXT_NODE, val);
+}
+
+static tree_t said_aug_branch(int n1, int n2, tree_t t1, tree_t t2) {
+	int retval;
+
+	retval = said_branch_node(SAID_NEXT_NODE,
+				said_branch_node(SAID_NEXT_NODE,
+					said_leaf_node(SAID_NEXT_NODE, n1),
+						said_branch_node(SAID_NEXT_NODE,
+							said_leaf_node(SAID_NEXT_NODE, n2),
+						t1)
+					),
+				t2);
+
+#ifdef SAID_DEBUG
+	fprintf(stderr, "AUG(0x%x, 0x%x, [%04x], [%04x]) = [%04x]\n", n1, n2, t1, t2, retval);
+#endif
+
+	return retval;
+}
+
+static tree_t said_attach_branch(tree_t base, tree_t attacheant) {
+#ifdef SAID_DEBUG
+	fprintf(stderr, "ATT2([%04x], [%04x]) = [%04x]\n", base, attacheant, base);
+#endif
+
+	if (!attacheant)
+		return base;
+	if (!base)
+		return attacheant;
+
+	if (!base)
+		return 0; // Happens if we're out of space
+
+	said_branch_node(base, VALUE_IGNORE, attacheant);
+
+	return base;
+}
+
+static said_spec_t said_top_branch(tree_t first) {
+#ifdef SAID_DEBUG
+	fprintf(stderr, "TOP([%04x])\n", first);
+#endif
+	said_branch_node(0, 1, 2);
+	said_leaf_node(1, 0x141); // Magic number #1
+	said_branch_node(2, 3, first);
+	said_leaf_node(3, 0x13f); // Magic number #2
+
+	++said_blessed;
+
+	return 0;
+}
+
+static int said_parse_spec(byte *spec) {
+	int nextitem;
+
+	said_parse_error = NULL;
+	said_token = 0;
+	said_tokens_nr = 0;
+	said_blessed = 0;
+
+	said_tree_pos = SAID_TREE_START;
+
+	do {
+		nextitem = *spec++;
+		if (nextitem < SAID_FIRST)
+			said_tokens[said_tokens_nr++] = nextitem << 8 | *spec++;
+		else
+			said_tokens[said_tokens_nr++] = SAID_LONG(nextitem);
+
+	} while ((nextitem != SAID_TERM) && (said_tokens_nr < MAX_SAID_TOKENS));
+
+	if (nextitem == SAID_TERM)
+		yyparse();
+	else {
+		warning("SAID spec is too long");
+		return 1;
+	}
+
+	if (said_parse_error) {
+		warning("Error while parsing SAID spec: %s", said_parse_error);
+		free(said_parse_error);
+		return 1;
+	}
+
+	if (said_tree_pos == 0) {
+		warning("Out of tree space while parsing SAID spec");
+		return 1;
+	}
+
+	if (said_blessed != 1) {
+		warning("Found multiple top branches");
+		return 1;
+	}
+
+	return 0;
+}
+
+/**********************/
+/**** Augmentation ****/
+/**********************/
+
+// primitive functions
+
+#define AUG_READ_BRANCH(a, br, p) \
+	if (tree[p].type != PARSE_TREE_NODE_BRANCH) \
+		return 0; \
+	a = tree[p].content.branches[br];
+
+#define AUG_READ_VALUE(a, p) \
+	if (tree[p].type != PARSE_TREE_NODE_LEAF) \
+		return 0; \
+	a = tree[p].content.value;
+
+#define AUG_ASSERT(i) \
+	if (!i) return 0;
+
+static int aug_get_next_sibling(parse_tree_node_t *tree, int pos, int *first, int *second) {
+	// Returns the next sibling relative to the specified position in 'tree',
+	// sets *first and *second to its augment node values, returns the new position
+	// or 0 if there was no next sibling
+	int seek, valpos;
+
+	AUG_READ_BRANCH(pos, 1, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_BRANCH(seek, 0, pos);
+	AUG_ASSERT(seek);
+
+	// Now retrieve first value
+	AUG_READ_BRANCH(valpos, 0, seek);
+	AUG_ASSERT(valpos);
+	AUG_READ_VALUE(*first, valpos);
+
+	// Get second value
+	AUG_READ_BRANCH(seek, 1, seek);
+	AUG_ASSERT(seek);
+	AUG_READ_BRANCH(valpos, 0, seek);
+	AUG_ASSERT(valpos);
+	AUG_READ_VALUE(*second, valpos);
+
+	return pos;
+}
+
+static int aug_get_wgroup(parse_tree_node_t *tree, int pos) {
+	// Returns 0 if pos in tree is not the root of a 3-element list, otherwise
+	// it returns the last element (which, in practice, is the word group
+	int val;
+
+	AUG_READ_BRANCH(pos, 0, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_BRANCH(pos, 1, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_BRANCH(pos, 1, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_VALUE(val, pos);
+
+	return val;
+}
+
+static int aug_get_base_node(parse_tree_node_t *tree) {
+	int startpos = 0;
+	AUG_READ_BRANCH(startpos, 1, startpos);
+
+	return startpos;
+}
+
+// semi-primitive functions
+
+static int aug_get_first_child(parse_tree_node_t *tree, int pos, int *first, int *second) {
+	// like aug_get_next_sibling, except that it recurses into the tree and
+	// finds the first child (usually *not* Ayanami Rei) of the current branch
+	// rather than its next sibling.
+	AUG_READ_BRANCH(pos, 0, pos);
+	AUG_ASSERT(pos);
+	AUG_READ_BRANCH(pos, 1, pos);
+	AUG_ASSERT(pos);
+
+	return aug_get_next_sibling(tree, pos, first, second);
+}
+
+static void aug_find_words_recursively(parse_tree_node_t *tree, int startpos, int *base_words, int *base_words_nr,
+			   int *ref_words, int *ref_words_nr, int maxwords, int refbranch) {
+	// Finds and lists all base (141) and reference (144) words */
+	int major, minor;
+	int word;
+	int pos = aug_get_first_child(tree, startpos, &major, &minor);
+
+	//if (major == WORD_TYPE_REF)
+	//	refbranch = 1;
+
+	while (pos) {
+		if ((word = aug_get_wgroup(tree, pos))) { // found a word
+			if (!refbranch && major == WORD_TYPE_BASE) {
+				if ((*base_words_nr) == maxwords) {
+					warning("Out of regular words");
+					return; // return gracefully
+				}
+
+				base_words[*base_words_nr] = word; // register word
+				++(*base_words_nr);
+
+			}
+			if (major == WORD_TYPE_REF || refbranch) {
+				if ((*ref_words_nr) == maxwords) {
+					warning("Out of reference words");
+					return; // return gracefully
+				}
+
+				ref_words[*ref_words_nr] = word; // register word
+				++(*ref_words_nr);
+
+			}
+			if (major != WORD_TYPE_SYNTACTIC_SUGAR && major != WORD_TYPE_BASE && major != WORD_TYPE_REF)
+				warning("aug_find_words_recursively(): Unknown word type %03x", major);
+
+		} else // Did NOT find a word group: Attempt to recurse
+			aug_find_words_recursively(tree, pos, base_words, base_words_nr,
+						   ref_words, ref_words_nr, maxwords, refbranch || major == WORD_TYPE_REF);
+
+		pos = aug_get_next_sibling(tree, pos, &major, &minor);
+	}
+}
+
+
+static void aug_find_words(parse_tree_node_t *tree, int startpos, int *base_words, int *base_words_nr,
+				int *ref_words, int *ref_words_nr, int maxwords) {
+	// initializing wrapper for aug_find_words_recursively()
+	*base_words_nr = 0;
+	*ref_words_nr = 0;
+
+	aug_find_words_recursively(tree, startpos, base_words, base_words_nr, ref_words, ref_words_nr, maxwords, 0);
+}
+
+
+static int aug_contains_word(int *list, int length, int word) {
+	int i;
+
+	if (word == ANYWORD)
+		return (length);
+
+	for (i = 0; i < length; i++)
+		if (list[i] == word)
+			return 1;
+
+	return 0;
+}
+
+
+static int augment_sentence_expression(parse_tree_node_t *saidt, int augment_pos, parse_tree_node_t *parset,
+					int parse_branch, int major, int minor, int *base_words, int base_words_nr,
+					int *ref_words, int ref_words_nr);
+
+static int augment_match_expression_p(parse_tree_node_t *saidt, int augment_pos, parse_tree_node_t *parset,
+					int parse_basepos, int major, int minor,
+			   int *base_words, int base_words_nr, int *ref_words, int ref_words_nr) {
+	int cmajor, cminor, cpos;
+	cpos = aug_get_first_child(saidt, augment_pos, &cmajor, &cminor);
+	if (!cpos) {
+		warning("augment_match_expression_p(): Empty condition");
+		return 1;
+	}
+
+	scidprintf("Attempting to match (%03x %03x (%03x %03x\n", major, minor, cmajor, cminor);
+
+	if ((major == WORD_TYPE_BASE) && (minor == AUGMENT_SENTENCE_MINOR_RECURSE))
+		return augment_match_expression_p(saidt, cpos, parset, parse_basepos, cmajor, cminor,
+						  base_words, base_words_nr, ref_words, ref_words_nr);
+
+	switch (major) {
+
+	case WORD_TYPE_BASE:
+		while (cpos) {
+			if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_WORD) {
+				int word = aug_get_wgroup(saidt, cpos);
+				scidprintf("Looking for word %03x\n", word);
+
+				if (aug_contains_word(base_words, base_words_nr, word))
+					return 1;
+			} else if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_PHRASE) {
+				if (augment_sentence_expression(saidt, cpos, parset, parse_basepos, cmajor, cminor,
+								base_words, base_words_nr, ref_words, ref_words_nr))
+					return 1;
+			} else if (cminor == AUGMENT_SENTENCE_MINOR_PARENTHESES) {
+				int gc_major, gc_minor;
+				int gchild = aug_get_first_child(saidt, cpos, &gc_major, &gc_minor);
+
+				while (gchild) {
+					if (augment_match_expression_p(saidt, cpos, parset, parse_basepos, major,
+									minor, base_words, base_words_nr,
+								       ref_words, ref_words_nr))
+						return 1;
+					gchild = aug_get_next_sibling(saidt, gchild, &gc_major, &gc_minor);
+				}
+			} else
+				warning("augment_match_expression_p(): Unknown type 141 minor number %3x", cminor);
+
+			cpos = aug_get_next_sibling(saidt, cpos, &cmajor, &cminor);
+
+		}
+		break;
+
+	case WORD_TYPE_REF:
+		while (cpos) {
+			if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_WORD) {
+				int word = aug_get_wgroup(saidt, cpos);
+				scidprintf("Looking for refword %03x\n", word);
+
+				if (aug_contains_word(ref_words, ref_words_nr, word))
+					return 1;
+			} else if (cminor == AUGMENT_SENTENCE_MINOR_MATCH_PHRASE) {
+				if (augment_match_expression_p(saidt, cpos, parset, parse_basepos, cmajor, cminor,
+							       base_words, base_words_nr, ref_words, ref_words_nr))
+					return 1;
+			} else if (cminor == AUGMENT_SENTENCE_MINOR_PARENTHESES) {
+				int gc_major, gc_minor;
+				int gchild = aug_get_first_child(saidt, cpos, &gc_major, &gc_minor);
+
+				while (gchild) {
+					if (augment_match_expression_p(saidt, cpos, parset, parse_basepos, major,
+									minor, base_words, base_words_nr,
+									ref_words, ref_words_nr))
+						return 1;
+					gchild = aug_get_next_sibling(saidt, gchild, &gc_major, &gc_minor);
+				}
+			} else
+				warning("augment_match_expression_p(): Unknown type 144 minor number %3x", cminor);
+
+			cpos = aug_get_next_sibling(saidt, cpos, &cmajor, &cminor);
+
+		}
+		break;
+
+	case AUGMENT_SENTENCE_PART_BRACKETS:
+		if (augment_match_expression_p(saidt, cpos, parset, parse_basepos, cmajor, cminor,
+					       base_words, base_words_nr, ref_words, ref_words_nr))
+			return 1;
+
+		scidprintf("Didn't match subexpression; checking sub-bracked predicate %03x\n", cmajor);
+
+		switch (cmajor) {
+		case WORD_TYPE_BASE:
+			if (!base_words_nr)
+				return 1;
+			break;
+
+		case WORD_TYPE_REF:
+			if (!ref_words_nr)
+				return 1;
+			break;
+
+		default:
+			warning("augment_match_expression_p(): (subp1) Unkonwn sub-bracket predicate %03x", cmajor);
+		}
+
+		break;
+
+	default:
+		warning("augment_match_expression_p(): Unknown predicate %03x", major);
+
+	}
+
+	scidprintf("augment_match_expression_p(): Generic failure\n");
+
+	return 0;
+}
+
+static int augment_sentence_expression(parse_tree_node_t *saidt, int augment_pos, parse_tree_node_t *parset,
+					int parse_branch, int major, int minor, int *base_words, int base_words_nr,
+					int *ref_words, int ref_words_nr) {
+	int check_major, check_minor;
+	int check_pos = aug_get_first_child(saidt, augment_pos, &check_major, &check_minor);
+	do {
+		if (!(augment_match_expression_p(saidt, check_pos, parset, parse_branch, check_major, check_minor,
+						base_words, base_words_nr, ref_words, ref_words_nr)))
+			return 0;
+	} while ((check_pos = aug_get_next_sibling(saidt, check_pos, &check_major, &check_minor)));
+
+	return 1;
+}
+
+static int augment_sentence_part(parse_tree_node_t *saidt, int augment_pos, parse_tree_node_t *parset, int parse_basepos, int major, int minor) {
+	int pmajor, pminor;
+	int parse_branch = parse_basepos;
+	int optional = 0;
+	int foundwords = 0;
+
+	scidprintf("Augmenting (%03x %03x\n", major, minor);
+
+	if (major == AUGMENT_SENTENCE_PART_BRACKETS) { // '[/ foo]' is true if '/foo' or if there
+						       // exists no x for which '/x' is true
+		if ((augment_pos = aug_get_first_child(saidt, augment_pos, &major, &minor))) {
+			scidprintf("Optional part: Now augmenting (%03x %03x\n", major, minor);
+			optional = 1;
+		} else {
+			scidprintf("Matched empty optional expression\n");
+			return 1;
+		}
+	}
+
+	if ((major < 0x141) || (major > 0x143)) {
+		scidprintf("augment_sentence_part(): Unexpected sentence part major number %03x\n", major);
+		return 0;
+	}
+
+	while ((parse_branch = aug_get_next_sibling(parset, parse_branch, &pmajor, &pminor))) {
+		if (pmajor == major) { // found matching sentence part
+			int success;
+			int base_words_nr;
+			int ref_words_nr;
+			int base_words[AUGMENT_MAX_WORDS];
+			int ref_words[AUGMENT_MAX_WORDS];
+#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION
+			int i;
+#endif
+
+			scidprintf("Found match with pminor = %03x\n", pminor);
+			aug_find_words(parset, parse_branch, base_words, &base_words_nr, ref_words, &ref_words_nr, AUGMENT_MAX_WORDS);
+			foundwords |= (ref_words_nr | base_words_nr);
+#ifdef SCI_DEBUG_PARSE_TREE_AUGMENTATION
+			printf("%d base words:", base_words_nr);
+			for (i = 0; i < base_words_nr; i++)
+				printf(" %03x", base_words[i]);
+			printf("\n%d reference words:", ref_words_nr);
+			for (i = 0; i < ref_words_nr; i++)
+				printf(" %03x", ref_words[i]);
+			printf("\n");
+#endif
+
+			success = augment_sentence_expression(saidt, augment_pos, parset, parse_basepos, major, minor,
+							      base_words, base_words_nr, ref_words, ref_words_nr);
+
+			if (success) {
+				scidprintf("SUCCESS on augmenting (%03x %03x\n", major, minor);
+				return 1;
+			}
+		}
+	}
+
+	if (optional && (foundwords == 0)) {
+		scidprintf("Found no words and optional branch => SUCCESS on augmenting (%03x %03x\n", major, minor);
+		return 1;
+	}
+	scidprintf("FAILURE on augmenting (%03x %03x\n", major, minor);
+
+	return 0;
+}
+
+static int augment_parse_nodes(parse_tree_node_t *parset, parse_tree_node_t *saidt) {
+	int augment_basepos = 0;
+	int parse_basepos;
+	int major, minor;
+	int dontclaim = 0;
+
+	parse_basepos = aug_get_base_node(parset);
+	if (!parse_basepos) {
+		warning("augment_parse_nodes(): Parse tree is corrupt");
+		return 0;
+	}
+
+	augment_basepos = aug_get_base_node(saidt);
+	if (!augment_basepos) {
+		warning("augment_parse_nodes(): Said tree is corrupt");
+		return 0;
+	}
+
+	while ((augment_basepos = aug_get_next_sibling(saidt, augment_basepos, &major, &minor))) {
+		if ((major == 0x14b) && (minor == SAID_LONG(SAID_GT)))
+			dontclaim = 1; // special case
+		else // normal sentence part
+			if (!(augment_sentence_part(saidt, augment_basepos, parset, parse_basepos, major, minor))) {
+				scidprintf("Returning failure\n");
+				return 0; // fail
+			}
+	}
+
+	scidprintf("Returning success with dontclaim=%d\n", dontclaim);
+
+	if (dontclaim)
+		return SAID_PARTIAL_MATCH;
+	else
+		return 1; // full match
+}
+
+
+/*******************/
+/**** Main code ****/
+/*******************/
+
+int said(EngineState *s, byte *spec, bool verbose) {
+	int retval;
+
+	parse_tree_node_t *parse_tree_ptr = s->_voc->_parser_nodes;
+
+	if (s->parserIsValid) {
+		if (said_parse_spec(s, spec)) {
+			warning("Offending spec was: ");
+			s->_voc->decipherSaidBlock(spec);
+			return SAID_NO_MATCH;
+		}
+
+		if (verbose)
+			vocab_dump_parse_tree("Said-tree", said_tree); // Nothing better to do yet
+		retval = augment_parse_nodes(parse_tree_ptr, &(said_tree[0]));
+
+		if (!retval)
+			return SAID_NO_MATCH;
+		else if (retval != SAID_PARTIAL_MATCH)
+			return SAID_FULL_MATCH;
+		else
+			return SAID_PARTIAL_MATCH;
+	}
+
+	return SAID_NO_MATCH;
+}
+
+
+#ifdef SAID_DEBUG_PROGRAM
+int main (int argc, char *argv) {
+	byte block[] = {0x01, 0x00, 0xf8, 0xf5, 0x02, 0x01, 0xf6, 0xf2, 0x02, 0x01, 0xf2, 0x01, 0x03, 0xff};
+	EngineState s;
+
+	s.parser_valid = 1;
+	said(&s, block);
+}
+#endif
+
+} // End of namespace Sci
diff --git a/engines/sci/parser/vocabulary.cpp b/engines/sci/parser/vocabulary.cpp
new file mode 100644
index 0000000000..5ecea03899
--- /dev/null
+++ b/engines/sci/parser/vocabulary.cpp
@@ -0,0 +1,633 @@
+/* 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+// Main vocabulary support functions and word lookup
+
+#include "sci/parser/vocabulary.h"
+#include "sci/resource.h"
+#include "sci/engine/state.h"
+#include "sci/engine/kernel.h"
+#include "sci/console.h"
+
+namespace Sci {
+
+#if 0
+
+#define VOCAB_RESOURCE_CLASSES 996
+/**
+ * Vocabulary class names.
+ * These strange names were taken from an SCI01 interpreter.
+ */
+const char *class_names[] = {"",
+                             "",
+                             "conj",   // conjunction
+                             "ass",    // ?
+                             "pos",    // preposition ?
+                             "art",    // article
+                             "adj",    // adjective
+                             "pron",   // pronoun
+                             "noun",   // noun
+                             "auxv",   // auxillary verb
+                             "adv",    // adverb
+                             "verb",   // verb
+                             "",
+                             "",
+                             "",
+                             ""
+                            };
+
+int *vocab_get_classes(ResourceManager *resMan, int* count) {
+	Resource* r;
+	int *c;
+	unsigned int i;
+
+	if ((r = resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_CLASSES), 0)) == NULL)
+		return 0;
+
+	c = (int *)malloc(sizeof(int) * r->size / 2);
+	for (i = 2; i < r->size; i += 4) {
+		c[i/4] = READ_LE_UINT16(r->data + i);
+	}
+	*count = r->size / 4;
+
+	return c;
+}
+
+int vocab_get_class_count(ResourceManager *resMan) {
+	Resource* r;
+
+	if ((r = resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_CLASSES), 0)) == 0)
+		return 0;
+
+	return r->size / 4;
+}
+
+#endif
+
+Vocabulary::Vocabulary(ResourceManager *resMan) : _resMan(resMan) {
+	_parserRules = NULL;
+	_vocabVersion = kVocabularySCI0;
+
+	memset(_parserNodes, 0, sizeof(_parserNodes));
+	// Mark parse tree as unused
+	_parserNodes[0].type = kParseTreeLeafNode;
+	_parserNodes[0].content.value = 0;
+
+	_synonyms.clear(); // No synonyms
+
+	debug(2, "Initializing vocabulary");
+
+	if (getSciVersion() <= SCI_VERSION_1_EGA && loadParserWords()) {
+		loadSuffixes();
+		if (loadBranches())
+			// Now build a GNF grammar out of this
+			_parserRules = buildGNF();
+	} else {
+		debug(2, "Assuming that this game does not use a parser.");
+		_parserRules = NULL;
+	}
+}
+
+Vocabulary::~Vocabulary() {
+	freeRuleList(_parserRules);
+	freeSuffixes();
+}
+
+bool Vocabulary::loadParserWords() {
+
+	char currentword[256] = ""; // They're not going to use words longer than 255 ;-)
+	int currentwordpos = 0;
+
+	// First try to load the SCI0 vocab resource.
+	Resource *resource = _resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_SCI0_MAIN_VOCAB), 0);
+ 
+	if (!resource) {
+		warning("SCI0: Could not find a main vocabulary, trying SCI01");
+		resource = _resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_SCI1_MAIN_VOCAB), 0);
+		_vocabVersion = kVocabularySCI1;
+	}
+
+	if (!resource) {
+		warning("SCI1: Could not find a main vocabulary");
+		return false; // NOT critical: SCI1 games and some demos don't have one!
+	}
+
+	unsigned int seeker;
+	if (_vocabVersion == kVocabularySCI1)
+		seeker = 255 * 2; // vocab.900 starts with 255 16-bit pointers which we don't use
+	else
+		seeker = 26 * 2; // vocab.000 starts with 26 16-bit pointers which we don't use
+
+	if (resource->size < seeker) {
+		warning("Invalid main vocabulary encountered: Too small");
+		return false;
+		// Now this ought to be critical, but it'll just cause parse() and said() not to work
+	}
+
+	_parserWords.clear();
+
+	while (seeker < resource->size) {
+		byte c;
+
+		currentwordpos = resource->data[seeker++]; // Parts of previous words may be re-used
+
+		if (_vocabVersion == kVocabularySCI1) {
+			c = 1;
+			while (seeker < resource->size && currentwordpos < 255 && c) {
+				c = resource->data[seeker++];
+				currentword[currentwordpos++] = c;
+			}
+			if (seeker == resource->size) {
+				warning("SCI1: Vocabulary not usable, disabling");
+				_parserWords.clear();
+				return false;
+			}
+		} else {
+			do {
+				c = resource->data[seeker++];
+				currentword[currentwordpos++] = c & 0x7f; // 0x80 is used to terminate the string
+			} while (c < 0x80);
+		}
+
+		currentword[currentwordpos] = 0;
+
+		// Now decode class and group:
+		c = resource->data[seeker + 1];
+		ResultWord newWord;
+		newWord._class = ((resource->data[seeker]) << 4) | ((c & 0xf0) >> 4);
+		newWord._group = (resource->data[seeker + 2]) | ((c & 0x0f) << 8);
+
+		// Add the word to the list
+		_parserWords[currentword] = newWord;
+
+		seeker += 3;
+	}
+
+	return true;
+}
+
+const char *Vocabulary::getAnyWordFromGroup(int group) {
+	if (group == VOCAB_MAGIC_NUMBER_GROUP)
+		return "{number}";
+
+	for (WordMap::const_iterator i = _parserWords.begin(); i != _parserWords.end(); ++i)
+		if (i->_value._group == group)
+			return i->_key.c_str();
+
+	return "{invalid}";
+}
+
+bool Vocabulary::loadSuffixes() {
+	// Determine if we can find a SCI1 suffix vocabulary first
+	Resource* resource = NULL;
+	
+	if (_vocabVersion == kVocabularySCI0)
+		resource = _resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_SCI0_SUFFIX_VOCAB), 1);
+	else
+		resource = _resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_SCI1_SUFFIX_VOCAB), 1);
+
+	if (!resource)
+		return false; // No vocabulary found
+
+	unsigned int seeker = 1;
+
+	while ((seeker < resource->size - 1) && (resource->data[seeker + 1] != 0xff)) {
+		suffix_t suffix;
+
+		suffix.alt_suffix = (const char *)resource->data + seeker;
+		suffix.alt_suffix_length = strlen(suffix.alt_suffix);
+		seeker += suffix.alt_suffix_length + 1; // Hit end of string
+
+		suffix.class_mask = (int16)READ_BE_UINT16(resource->data + seeker);
+		seeker += 2;
+
+		// Beginning of next string - skip leading '*'
+		seeker++;
+
+		suffix.word_suffix = (const char *)resource->data + seeker;
+		suffix.word_suffix_length = strlen(suffix.word_suffix);
+		seeker += suffix.word_suffix_length + 1;
+
+		suffix.result_class = (int16)READ_BE_UINT16(resource->data + seeker);
+		seeker += 3; // Next entry
+
+		_parserSuffixes.push_back(suffix);
+	}
+
+	return true;
+}
+
+void Vocabulary::freeSuffixes() {
+	Resource* resource = NULL;
+	
+	if (_vocabVersion == kVocabularySCI0)
+		resource = _resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_SCI0_SUFFIX_VOCAB), 0);
+	else
+		resource = _resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_SCI1_SUFFIX_VOCAB), 0);
+	
+	if (resource)
+		_resMan->unlockResource(resource);
+
+	_parserSuffixes.clear();
+}
+
+bool Vocabulary::loadBranches() {
+	Resource *resource = NULL;
+
+	if (_vocabVersion == kVocabularySCI0)
+		resource = _resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_SCI0_PARSE_TREE_BRANCHES), 0);
+	else
+		resource = _resMan->findResource(ResourceId(kResourceTypeVocab, VOCAB_RESOURCE_SCI1_PARSE_TREE_BRANCHES), 0);
+
+	_parserBranches.clear();
+
+	if (!resource)
+		return false;		// No parser tree data found
+
+	int branches_nr = resource->size / 20;
+
+	if (branches_nr == 0) {
+		warning("Parser tree data is empty");
+		return false;
+	}
+
+	_parserBranches.resize(branches_nr);
+
+	for (int i = 0; i < branches_nr; i++) {
+		byte *base = resource->data + i * 20;
+
+		_parserBranches[i].id = (int16)READ_LE_UINT16(base);
+
+		for (int k = 0; k < 9; k++)
+			_parserBranches[i].data[k] = READ_LE_UINT16(base + 2 + 2 * k);
+
+		_parserBranches[i].data[9] = 0; // Always terminate
+	}
+
+	if (!_parserBranches[branches_nr - 1].id) // branch lists may be terminated by empty rules
+		_parserBranches.remove_at(branches_nr - 1);
+
+	return true;
+}
+
+
+ResultWord Vocabulary::lookupWord(const char *word, int word_len) {
+	Common::String tempword(word, word_len);
+
+	// Remove all dashes from tempword
+	for (uint i = 0; i < tempword.size(); ) {
+		if (tempword[i] == '-')
+			tempword.deleteChar(i);
+		else
+			++i;
+	}
+
+	// Look it up:
+	WordMap::iterator dict_word = _parserWords.find(tempword);
+
+	// Match found? Return it!
+	if (dict_word != _parserWords.end()) {
+		return dict_word->_value;
+	}
+
+	// Now try all suffixes
+	for (SuffixList::const_iterator suffix = _parserSuffixes.begin(); suffix != _parserSuffixes.end(); ++suffix)
+		if (suffix->alt_suffix_length <= word_len) {
+
+			int suff_index = word_len - suffix->alt_suffix_length;
+			// Offset of the start of the suffix
+
+			if (scumm_strnicmp(suffix->alt_suffix, word + suff_index, suffix->alt_suffix_length) == 0) { // Suffix matched!
+				// Terminate word at suffix start position...:
+				Common::String tempword2(word, MIN(word_len, suff_index));
+
+				// ...and append "correct" suffix
+				tempword2 += Common::String(suffix->word_suffix, suffix->word_suffix_length);
+
+				dict_word = _parserWords.find(tempword2);
+
+				if ((dict_word != _parserWords.end()) && (dict_word->_value._class & suffix->class_mask)) { // Found it?
+					// Use suffix class
+					ResultWord tmp = dict_word->_value;
+					tmp._class = suffix->result_class;
+					return tmp;
+				}
+			}
+		}
+
+	// No match so far? Check if it's a number.
+
+	ResultWord retval = { -1, -1 };
+	char *tester;
+	if ((strtol(tempword.c_str(), &tester, 10) >= 0) && (*tester == '\0')) { // Do we have a complete number here?
+		ResultWord tmp = { VOCAB_CLASS_NUMBER, VOCAB_MAGIC_NUMBER_GROUP };
+		retval = tmp;
+	}
+
+	return retval;
+}
+
+void Vocabulary::decipherSaidBlock(byte *addr) {
+	byte nextitem;
+
+	do {
+		nextitem = *addr++;
+
+		if (nextitem < 0xf0) {
+			nextitem = nextitem << 8 | *addr++;
+			printf(" %s[%03x]", getAnyWordFromGroup(nextitem), nextitem);
+
+			nextitem = 42; // Make sure that group 0xff doesn't abort
+		} else switch (nextitem) {
+			case 0xf0:
+				printf(" ,");
+				break;
+			case 0xf1:
+				printf(" &");
+				break;
+			case 0xf2:
+				printf(" /");
+				break;
+			case 0xf3:
+				printf(" (");
+				break;
+			case 0xf4:
+				printf(" )");
+				break;
+			case 0xf5:
+				printf(" [");
+				break;
+			case 0xf6:
+				printf(" ]");
+				break;
+			case 0xf7:
+				printf(" #");
+				break;
+			case 0xf8:
+				printf(" <");
+				break;
+			case 0xf9:
+				printf(" >");
+				break;
+			case 0xff:
+				break;
+			}
+	} while (nextitem != 0xff);
+
+	printf("\n");
+}
+
+bool Vocabulary::tokenizeString(ResultWordList &retval, const char *sentence, char **error) {
+	const char *lastword = sentence;
+	int pos_in_sentence = 0;
+	char c;
+	int wordlen = 0;
+
+	*error = NULL;
+
+	do {
+
+		c = sentence[pos_in_sentence++];
+
+		if (isalnum(c) || (c == '-' && wordlen))
+			++wordlen;
+		// Continue on this word */
+		// Words may contain a '-', but may not
+		// start with one.
+		else {
+			if (wordlen) { // Finished a word?
+
+				ResultWord lookup_result = lookupWord(lastword, wordlen);
+				// Look it up
+
+				if (lookup_result._class == -1) { // Not found?
+					*error = (char *)calloc(wordlen + 1, 1);
+					strncpy(*error, lastword, wordlen); // Set the offending word
+					retval.clear();
+					return false; // And return with error
+				}
+
+				// Copy into list
+				retval.push_back(lookup_result);
+			}
+
+			lastword = sentence + pos_in_sentence;
+			wordlen = 0;
+		}
+
+	} while (c); // Until terminator is hit
+
+	return true;
+}
+
+void Vocabulary::printSuffixes() const {
+	char word_buf[256], alt_buf[256];
+	Console *con = ((SciEngine *)g_engine)->getSciDebugger();
+
+	int i = 0;
+	for (SuffixList::const_iterator suf = _parserSuffixes.begin(); suf != _parserSuffixes.end(); ++suf) {
+		strncpy(word_buf, suf->word_suffix, suf->word_suffix_length);
+		word_buf[suf->word_suffix_length] = 0;
+		strncpy(alt_buf, suf->alt_suffix, suf->alt_suffix_length);
+		alt_buf[suf->alt_suffix_length] = 0;
+
+		con->DebugPrintf("%4d: (%03x) -%12s  =>  -%12s (%03x)\n", i, suf->class_mask, word_buf, alt_buf, suf->result_class);
+		++i;
+	}
+}
+
+void Vocabulary::printParserWords() const {
+	Console *con = ((SciEngine *)g_engine)->getSciDebugger();
+
+	int j = 0;
+	for (WordMap::iterator i = _parserWords.begin(); i != _parserWords.end(); ++i) {
+		con->DebugPrintf("%4d: %03x [%03x] %20s |", j, i->_value._class, i->_value._group, i->_key.c_str());
+		if (j % 3 == 0)
+			con->DebugPrintf("\n");
+		j++;
+	}
+
+	con->DebugPrintf("\n");
+}
+
+void _vocab_recursive_ptree_dump_treelike(parse_tree_node_t *nodes, int nr, int prevnr) {
+	if ((nr > VOCAB_TREE_NODES)/* || (nr < prevnr)*/) {
+		printf("Error(%04x)", nr);
+		return;
+	}
+
+	if (nodes[nr].type == kParseTreeLeafNode)
+		//printf("[%03x]%04x", nr, nodes[nr].content.value);
+		printf("%x", nodes[nr].content.value);
+	else {
+		int lbranch = nodes[nr].content.branches[0];
+		int rbranch = nodes[nr].content.branches[1];
+		//printf("<[%03x]", nr);
+		printf("<");
+
+		if (lbranch)
+			_vocab_recursive_ptree_dump_treelike(nodes, lbranch, nr);
+		else
+			printf("NULL");
+
+		printf(",");
+
+		if (rbranch)
+			_vocab_recursive_ptree_dump_treelike(nodes, rbranch, nr);
+		else
+			printf("NULL");
+
+		printf(">");
+	}
+}
+
+void _vocab_recursive_ptree_dump(parse_tree_node_t *nodes, int nr, int prevnr, int blanks) {
+	int lbranch = nodes[nr].content.branches[0];
+	int rbranch = nodes[nr].content.branches[1];
+	int i;
+
+	if (nodes[nr].type == kParseTreeLeafNode) {
+		printf("vocab_dump_parse_tree: Error: consp is nil for element %03x\n", nr);
+		return;
+	}
+
+	if ((nr > VOCAB_TREE_NODES)/* || (nr < prevnr)*/) {
+		printf("Error(%04x))", nr);
+		return;
+	}
+
+	if (lbranch) {
+		if (nodes[lbranch].type == kParseTreeBranchNode) {
+			printf("\n");
+			for (i = 0; i < blanks; i++)
+				printf("    ");
+			printf("(");
+			_vocab_recursive_ptree_dump(nodes, lbranch, nr, blanks + 1);
+			printf(")\n");
+			for (i = 0; i < blanks; i++)
+				printf("    ");
+		} else
+			printf("%x", nodes[lbranch].content.value);
+		printf(" ");
+	}/* else printf ("nil");*/
+
+	if (rbranch) {
+		if (nodes[rbranch].type == kParseTreeBranchNode)
+			_vocab_recursive_ptree_dump(nodes, rbranch, nr, blanks);
+		else
+			printf("%x", nodes[rbranch].content.value);
+	}/* else printf("nil");*/
+}
+
+void vocab_dump_parse_tree(const char *tree_name, parse_tree_node_t *nodes) {
+	//_vocab_recursive_ptree_dump_treelike(nodes, 0, 0);
+	printf("(setq %s \n'(", tree_name);
+	_vocab_recursive_ptree_dump(nodes, 0, 0, 1);
+	printf("))\n");
+}
+
+void Vocabulary::dumpParseTree() {
+	//_vocab_recursive_ptree_dump_treelike(nodes, 0, 0);
+	printf("(setq parse-tree \n'(");
+	_vocab_recursive_ptree_dump(_parserNodes, 0, 0, 1);
+	printf("))\n");
+}
+
+void Vocabulary::synonymizeTokens(ResultWordList &words) {
+	if (_synonyms.empty())
+		return; // No synonyms: Nothing to check
+
+	for (ResultWordList::iterator i = words.begin(); i != words.end(); ++i)
+		for (SynonymList::const_iterator sync = _synonyms.begin(); sync != _synonyms.end(); ++sync)
+			if (i->_group == sync->replaceant)
+				i->_group = sync->replacement;
+}
+
+void Vocabulary::printParserNodes(int num) {
+	Console *con = ((SciEngine *)g_engine)->getSciDebugger();
+
+	for (int i = 0; i < num; i++) {
+		con->DebugPrintf(" Node %03x: ", i);
+		if (_parserNodes[i].type == kParseTreeLeafNode)
+			con->DebugPrintf("Leaf: %04x\n", _parserNodes[i].content.value);
+		else
+			con->DebugPrintf("Branch: ->%04x, ->%04x\n", _parserNodes[i].content.branches[0],
+			          _parserNodes[i].content.branches[1]);
+	}
+}
+
+int Vocabulary::parseNodes(int *i, int *pos, int type, int nr, int argc, const char **argv) {
+	int nextToken = 0, nextValue = 0, newPos = 0, oldPos = 0;
+	Console *con = ((SciEngine *)g_engine)->getSciDebugger();
+
+	if (type == kParseNil)
+		return 0;
+
+	if (type == kParseNumber) {
+		_parserNodes[*pos += 1].type = kParseTreeLeafNode;
+		_parserNodes[*pos].content.value = nr;
+		return *pos;
+	}
+	if (type == kParseEndOfInput) {
+		con->DebugPrintf("Unbalanced parentheses\n");
+		return -1;
+	}
+	if (type == kParseClosingParenthesis) {
+		con->DebugPrintf("Syntax error at token %d\n", *i);
+		return -1;
+	}
+
+	_parserNodes[oldPos = ++(*pos)].type = kParseTreeBranchNode;
+
+	for (int j = 0; j <= 1; j++) {
+		if (*i == argc) {
+			nextToken = kParseEndOfInput;
+		} else {
+			const char *token = argv[(*i)++];
+
+			if (!strcmp(token, "(")) {
+				nextToken = kParseOpeningParenthesis;
+			} else if (!strcmp(token, ")")) {
+				nextToken = kParseClosingParenthesis;
+			} else if (!strcmp(token, "nil")) {
+				nextToken = kParseNil;
+			} else {
+				nextValue = strtol(token, NULL, 0);
+				nextToken = kParseNumber;
+			}
+		}
+
+		if ((newPos = _parserNodes[oldPos].content.branches[j] = parseNodes(i, pos, nextToken, nextValue, argc, argv)) == -1)
+			return -1;
+	}
+
+	const char *token = argv[(*i)++];
+	if (strcmp(token, ")"))
+		con->DebugPrintf("Expected ')' at token %d\n", *i);
+
+	return oldPos;
+}
+
+} // End of namespace Sci
diff --git a/engines/sci/parser/vocabulary.h b/engines/sci/parser/vocabulary.h
new file mode 100644
index 0000000000..00b8780d1c
--- /dev/null
+++ b/engines/sci/parser/vocabulary.h
@@ -0,0 +1,338 @@
+/* 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef SCI_SCICORE_VOCABULARY_H
+#define SCI_SCICORE_VOCABULARY_H
+
+#include "common/str.h"
+#include "common/hashmap.h"
+#include "common/hash-str.h"
+#include "common/list.h"
+
+#include "sci/sci.h"
+
+namespace Sci {
+
+class ResourceManager;
+
+/*#define VOCABULARY_DEBUG */
+
+/** Number of bytes allocated on the heap to store bad words if parsing fails */
+#define PARSE_HEAP_SIZE 64
+
+enum {
+	VOCAB_RESOURCE_SELECTORS = 997,
+
+	VOCAB_RESOURCE_SCI0_MAIN_VOCAB = 0,
+	VOCAB_RESOURCE_SCI0_PARSE_TREE_BRANCHES = 900,
+	VOCAB_RESOURCE_SCI0_SUFFIX_VOCAB = 901,
+
+	VOCAB_RESOURCE_SCI1_MAIN_VOCAB = 900,
+	VOCAB_RESOURCE_SCI1_PARSE_TREE_BRANCHES = 901,
+	VOCAB_RESOURCE_SCI1_SUFFIX_VOCAB = 902
+};
+
+
+enum {
+	VOCAB_CLASS_PREPOSITION = 0x01,
+	VOCAB_CLASS_ARTICLE = 0x02,
+	VOCAB_CLASS_ADJECTIVE = 0x04,
+	VOCAB_CLASS_PRONOUN = 0x08,
+	VOCAB_CLASS_NOUN = 0x10,
+	VOCAB_CLASS_INDICATIVE_VERB = 0x20,
+	VOCAB_CLASS_ADVERB = 0x40,
+	VOCAB_CLASS_IMPERATIVE_VERB = 0x80,
+	VOCAB_CLASS_NUMBER = 0x001
+};
+
+enum {
+	kParseEndOfInput = 0,
+	kParseOpeningParenthesis = 1,
+	kParseClosingParenthesis = 2,
+	kParseNil = 3,
+	kParseNumber = 4
+};
+
+/* Anywords are ignored by the parser */
+#define VOCAB_CLASS_ANYWORD 0xff
+
+/* This word class is used for numbers */
+#define VOCAB_MAGIC_NUMBER_GROUP 0xffd /* 0xffe ? */
+
+/* Number of nodes for each parse_tree_node structure */
+#define VOCAB_TREE_NODES 500
+
+#define VOCAB_TREE_NODE_LAST_WORD_STORAGE 0x140
+#define VOCAB_TREE_NODE_COMPARE_TYPE 0x146
+#define VOCAB_TREE_NODE_COMPARE_GROUP 0x14d
+#define VOCAB_TREE_NODE_FORCE_STORAGE 0x154
+
+#define SAID_COMMA   0xf0
+#define SAID_AMP     0xf1
+#define SAID_SLASH   0xf2
+#define SAID_PARENO  0xf3
+#define SAID_PARENC  0xf4
+#define SAID_BRACKO  0xf5
+#define SAID_BRACKC  0xf6
+#define SAID_HASH    0xf7
+#define SAID_LT      0xf8
+#define SAID_GT      0xf9
+#define SAID_TERM    0xff
+
+#define SAID_FIRST SAID_COMMA
+
+/* There was no 'last matching word': */
+#define SAID_FULL_MATCH 0xffff
+#define SAID_NO_MATCH 0xfffe
+#define SAID_PARTIAL_MATCH 0xfffd
+
+#define SAID_LONG(x) ((x) << 8)
+
+struct ResultWord {
+	int _class; /**< Word class */
+	int _group; /**< Word group */
+};
+
+typedef Common::List<ResultWord> ResultWordList;
+
+typedef Common::HashMap<Common::String, ResultWord, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> WordMap;
+
+
+struct ParseRuleList;
+
+struct suffix_t {
+
+	int class_mask; /**< the word class this suffix applies to */
+	int result_class; /**< the word class a word is morphed to if it doesn't fail this check */
+
+	int alt_suffix_length; /**< String length of the suffix */
+	int word_suffix_length; /**< String length of the other suffix */
+
+	const char *alt_suffix; /**< The alternative suffix */
+	const char *word_suffix; /**< The suffix as used in the word vocabulary */
+
+};
+
+typedef Common::List<suffix_t> SuffixList;
+
+
+struct synonym_t {
+	int replaceant; /**< The word group to replace */
+	int replacement; /**< The replacement word group for this one */
+};
+
+typedef Common::List<synonym_t> SynonymList;
+
+struct parse_tree_branch_t {
+	int id;
+	int data[10];
+};
+
+enum ParseTypes {
+	kParseTreeLeafNode = 0,
+	kParseTreeBranchNode = 1
+};
+
+struct parse_tree_node_t {
+	ParseTypes type;  /**< leaf or branch */
+	union {
+		int value;  /**< For leaves */
+		short branches[2]; /**< For branches */
+	} content;
+};
+
+enum VocabularyVersions {
+	kVocabularySCI0 = 0,
+	kVocabularySCI1 = 1
+};
+
+class Vocabulary {
+public:
+	Vocabulary(ResourceManager *resMan);
+	~Vocabulary();
+
+	/**
+	 * Gets any word from the specified group. For debugging only.
+	 * @param group		Group number
+	 */
+	const char *getAnyWordFromGroup(int group);
+
+
+	/**
+	 * Looks up a single word in the words and suffixes list.
+	 * @param word		pointer to the word to look up
+	 * @param word_len	length of the word to look up
+	 * @return the matching word (or (-1,-1) if there was no match)
+	 */
+	ResultWord lookupWord(const char *word, int word_len);
+
+
+	/**
+	 * Tokenizes a string and compiles it into word_ts.
+	 * @param[in] retval		A list of words which will be set to the result
+	 * @param[out] sentence		The sentence to examine
+	 * @param[out] error		Points to a malloc'd copy of the offending text or to NULL on error
+	 * @return true on success, false on failure
+	 *
+	 * On error, false is returned. If *error is NULL, the sentence did not
+	 * contain any useful words; if not, *error points to a malloc'd copy of
+	 * the offending word. The returned list may contain anywords.
+	 */
+	bool tokenizeString(ResultWordList &retval, const char *sentence, char **error);
+
+	/**
+	 * Builds a parse tree from a list of words, using a set of Greibach Normal
+	 * Form rules.
+	 * @param words		The words to build the tree from
+	 * @param verbose	Set to true for debugging
+	 * @return	0 on success, 1 if the tree couldn't be built in VOCAB_TREE_NODES
+	 *			nodes or if the sentence structure in 'words' is not part of the
+	 *			language described by the grammar passed in 'rules'.
+	 */
+	int parseGNF(const ResultWordList &words, bool verbose = false);
+
+	/**
+	 * Constructs the Greibach Normal Form of the grammar supplied in 'branches'.
+	 * @param verbose	Set to true for debugging. If true, the list is
+	 *					freed before the function ends
+	 * @return	Pointer to a list of singly linked GNF rules describing the same
+	 *			language that was described by 'branches'
+	 *
+	 * The original SCI rules are in almost-CNF (Chomsky Normal Form). Note that
+	 * branch[0] is used only for a few magical incantations, as it is treated
+	 * specially by the SCI parser.
+	 */
+	ParseRuleList *buildGNF(bool verbose = false);
+
+	/**
+	 * Deciphers a said block and dumps its content via printf.
+	 * For debugging only.
+	 * @param pos	pointer to the data to dump
+	 */
+	void decipherSaidBlock(byte *pos);
+
+	/**
+	 * Prints the parser suffixes to the debug console.
+	 */
+	void printSuffixes() const;
+
+	/**
+	 * Prints the parser words to the debug console.
+	 */
+	void printParserWords() const;
+
+	uint getParserBranchesSize() const { return _parserBranches.size(); }
+	const parse_tree_branch_t &getParseTreeBranch(int number) const { return _parserBranches[number]; }
+
+	/**
+	 * Adds a new synonym to the list
+	 */
+	void addSynonym(synonym_t syn) { _synonyms.push_back(syn); }
+	
+	/**
+	 * Clears the list of synonyms
+	 */
+	void clearSynonyms() { _synonyms.clear(); }
+	
+	/** 
+	 * Synonymizes a token list
+	 * Parameters: (ResultWordList &) words: The word list to synonymize
+	 */
+	void synonymizeTokens(ResultWordList &words);
+
+	void printParserNodes(int num);
+
+	void dumpParseTree();
+
+	int parseNodes(int *i, int *pos, int type, int nr, int argc, const char **argv);
+
+private:
+	/**
+	 * Loads all words from the main vocabulary.
+	 * @return true on success, false on failure
+	 */
+	bool loadParserWords();
+
+	/**
+	 * Loads all suffixes from the suffix vocabulary.
+	 * @return true on success, false on failure
+	 */
+	bool loadSuffixes();
+
+	/**
+	 * Frees all suffixes in the given list.
+	 * @param suffixes: The suffixes to free
+	 */
+	void freeSuffixes();
+
+	/**
+	 * Retrieves all grammar rules from the resource data.
+	 * @param branches		The rules are stored into this Array
+	 * @return true on success, false on error
+	 */
+	bool loadBranches();
+
+	/**
+	 * Frees a parser rule list as returned by vocab_build_gnf().
+	 * @param rule_list		the rule list to free
+	 */
+	void freeRuleList(ParseRuleList *rule_list);
+
+	ResourceManager *_resMan;
+	VocabularyVersions _vocabVersion;
+
+	// Parser-related lists
+	SuffixList _parserSuffixes;
+	ParseRuleList *_parserRules; /**< GNF rules used in the parser algorithm */
+	Common::Array<parse_tree_branch_t> _parserBranches;
+	WordMap _parserWords;
+	SynonymList _synonyms; /**< The list of synonyms */
+
+public:
+	// Accessed by said()
+	parse_tree_node_t _parserNodes[VOCAB_TREE_NODES]; /**< The parse tree */
+};
+
+/**
+ * Prints a parse tree.
+ * @param tree_name		Name of the tree to dump (free-form)
+ * @param nodes			The nodes containing the parse tree
+ */
+void vocab_dump_parse_tree(const char *tree_name, parse_tree_node_t *nodes);
+
+
+
+/**
+ * Builds a parse tree from a spec and compares it to a parse tree.
+ * @param s			The affected state
+ * @param spec		Pointer to the spec to build
+ * @param verbose	Whether to display the parse tree after building it
+ * @return 1 on a match, 0 otherwise
+ */
+int said(EngineState *s, byte *spec, bool verbose);
+
+} // End of namespace Sci
+
+#endif // SCI_SCICORE_VOCABULARY_H