vocabulary.h

/* 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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef SCI_PARSER_VOCABULARY_H
#define SCI_PARSER_VOCABULARY_H
 
#include "common/str.h"
#include "common/hashmap.h"
#include "common/hash-str.h"
#include "common/list.h"
 
#include "sci/sci.h"
#include "sci/engine/vm_types.h"
#include "sci/util.h"
 
namespace Common {
 
class Serializer;
 
}
 
namespace Sci {
 
class ResourceManager;
 
/*#define VOCABULARY_DEBUG */
 
enum {
    VOCAB_RESOURCE_SELECTORS = 997,
 
    VOCAB_RESOURCE_SCI0_MAIN_VOCAB = 0,
    VOCAB_RESOURCE_SCUMM_LOC_VOCAB = 1, // Special fanmade format for vocab translate
    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,
 
    VOCAB_RESOURCE_ALT_INPUTS = 913
};
 
 
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
};
 
enum {
    kParseEndOfInput = 0,
    kParseOpeningParenthesis = 1,
    kParseClosingParenthesis = 2,
    kParseNil = 3,
    kParseNumber = 4
};
 
#define VOCAB_MAX_WORDLENGTH 256
 
/* 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 ? */
#define VOCAB_MAGIC_NOTHING_GROUP 0xffe
 
/* Number of nodes for each ParseTreeNode 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; 
    int _group; 
};
 
typedef Common::List<ResultWord> ResultWordList;
typedef Common::List<ResultWordList> ResultWordListList;
 
typedef Common::HashMap<Common::String, ResultWordList, Common::CaseSensitiveString_Hash, Common::CaseSensitiveString_EqualTo> WordMap;
 
 
struct ParseRuleList;
 
struct suffix_t {
 
    int class_mask; 
    int result_class; 
    int alt_suffix_length; 
    int word_suffix_length; 
    const char *alt_suffix; 
    const char *word_suffix; 
};
 
typedef Common::List<suffix_t> SuffixList;
 
 
struct synonym_t {
    uint16 replaceant; 
    uint16 replacement; 
};
 
typedef Common::Array<synonym_t> SynonymList;
 
 
struct AltInput {
    const char *_input;
    const char *_replacement;
    uint32 _inputLength;
    uint32 _replacementLength;
    bool _prefix;
};
 
 
struct parse_tree_branch_t {
    int id;
    int data[10];
};
 
enum ParseTypes {
    kParseTreeWordNode = 4,
    kParseTreeLeafNode = 5,
    kParseTreeBranchNode = 6
};
 
struct ParseTreeNode {
    ParseTypes type;  
    int value; 
    ParseTreeNode* left; 
    ParseTreeNode* right; 
};
 
enum VocabularyVersions {
    kVocabularySCI0 = 0,
    kVocabularySCI1 = 1
};
 
class Vocabulary {
public:
    Vocabulary(ResourceManager *resMan, bool foreign);
    ~Vocabulary();
 
    // reset parser status
    void reset();
 
    const char *getAnyWordFromGroup(int group);
 
 
    void lookupWord(ResultWordList &retval, const char *word, int word_len);
 
    void lookupWordPrefix(ResultWordListList &parent_retval, ResultWordList &retval, const char *word, int word_len);
 
    bool lookupSpecificPrefixWithMeaning(ResultWordListList &parent_retval, ResultWordList &retval, const char *word, int word_len, unsigned char prefix, const char *meaning);
 
    bool lookupVerbPrefix(ResultWordListList &parent_retval, ResultWordList &retval, Common::String word, int word_len, Common::String prefix);
 
    bool tokenizeString(ResultWordListList &retval, const char *sentence, char **error);
 
    int parseGNF(const ResultWordListList &words, bool verbose = false);
 
    bool storePronounReference();
 
    void replacePronouns(ResultWordListList &words);
 
    ParseRuleList *buildGNF(bool verbose = false);
 
    void debugDecipherSaidBlock(const SciSpan<const byte> &data);
 
    void printSuffixes() const;
 
    void printParserWords() const;
 
    uint getParserBranchesSize() const { return _parserBranches.size(); }
    const parse_tree_branch_t &getParseTreeBranch(int number) const { return _parserBranches[number]; }
 
    void addSynonym(synonym_t syn) { _synonyms.push_back(syn); }
 
    void clearSynonyms() { _synonyms.clear(); }
 
    void synonymizeTokens(ResultWordListList &words);
 
    void printParserNodes(int num);
 
    void dumpParseTree();
 
    int parseNodes(int *i, int *pos, int type, int nr, int argc, const char **argv);
 
    bool checkAltInput(Common::String& text, uint16& cursorPos);
 
    void saveLoadWithSerializer(Common::Serializer &ser);
 
private:
    bool loadParserWords();
    
    void loadTranslatedWords();
 
    bool loadSuffixes();
 
    void freeSuffixes();
 
    bool loadBranches();
 
    void freeRuleList(ParseRuleList *rule_list);
 
 
    bool loadAltInputs();
 
    void freeAltInputs();
 
    ResourceManager *_resMan;
    VocabularyVersions _vocabVersion;
 
    bool _foreign;
    uint16 _resourceIdWords;
    uint16 _resourceIdSuffixes;
    uint16 _resourceIdBranches;
 
    // Parser-related lists
    SuffixList _parserSuffixes;
    ParseRuleList *_parserRules; 
    Common::Array<parse_tree_branch_t> _parserBranches;
    WordMap _parserWords;
    SynonymList _synonyms; 
    Common::Array<Common::List<AltInput> > _altInputs;
 
    struct PrefixMeaning {
        unsigned char prefix;
        const char *meaning;
    };
 
    int _pronounReference;
 
public:
    // Accessed by said()
    ParseTreeNode _parserNodes[VOCAB_TREE_NODES]; 
    // Parser data:
    reg_t parser_event; 
    bool parserIsValid; 
};
 
void vocab_dump_parse_tree(const char *tree_name, ParseTreeNode *nodes);
 
 
 
int said(const byte *spec, bool verbose);
 
} // End of namespace Sci
 
#endif // SCI_PARSER_VOCABULARY_H