aboutsummaryrefslogtreecommitdiff
path: root/engines/sci/parser
diff options
context:
space:
mode:
Diffstat (limited to 'engines/sci/parser')
-rw-r--r--engines/sci/parser/grammar.cpp583
-rw-r--r--engines/sci/parser/said.cpp2483
-rw-r--r--engines/sci/parser/said.y838
-rw-r--r--engines/sci/parser/vocabulary.cpp633
-rw-r--r--engines/sci/parser/vocabulary.h338
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
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-16 04:45:14 +0000