From 7ee61fa5d4a6dfd6880e48b83a8dae1d485d1e94 Mon Sep 17 00:00:00 2001 From: Paul Gilbert Date: Sun, 27 Oct 2019 21:17:49 -0700 Subject: GLK: ARCHETYPE: Added converted files --- engines/glk/archetype/archetype.cpp | 876 +++++++++++++++++++++++++++++++++- engines/glk/archetype/archetype.h | 95 ++++ engines/glk/archetype/array.cpp | 66 +++ engines/glk/archetype/array.h | 69 +++ engines/glk/archetype/crypt.cpp | 82 ++++ engines/glk/archetype/crypt.h | 64 +++ engines/glk/archetype/error.cpp | 80 ++++ engines/glk/archetype/error.h | 49 ++ engines/glk/archetype/expression.cpp | 129 +++++ engines/glk/archetype/expression.h | 90 ++++ engines/glk/archetype/game_stat.cpp | 121 +++++ engines/glk/archetype/game_stat.h | 46 ++ engines/glk/archetype/heap_sort.cpp | 148 ++++++ engines/glk/archetype/heap_sort.h | 48 ++ engines/glk/archetype/id_table.cpp | 73 +++ engines/glk/archetype/id_table.h | 77 +++ engines/glk/archetype/interpreter.cpp | 478 +++++++++++++++++++ engines/glk/archetype/interpreter.h | 130 +++++ engines/glk/archetype/keywords.cpp | 152 ++++++ engines/glk/archetype/keywords.h | 149 ++++++ engines/glk/archetype/linked_list.cpp | 90 ++++ engines/glk/archetype/linked_list.h | 80 ++++ engines/glk/archetype/misc.cpp | 197 ++++++++ engines/glk/archetype/misc.h | 184 +++++++ engines/glk/archetype/parser.cpp | 291 +++++++++++ engines/glk/archetype/parser.h | 89 ++++ engines/glk/archetype/saveload.cpp | 672 ++++++++++++++++++++++++++ engines/glk/archetype/saveload.h | 79 +++ engines/glk/archetype/semantic.cpp | 234 +++++++++ engines/glk/archetype/semantic.h | 112 +++++ engines/glk/archetype/statement.h | 98 ++++ engines/glk/archetype/string.cpp | 133 ++++++ engines/glk/archetype/string.h | 143 ++++++ engines/glk/archetype/sys_object.cpp | 305 ++++++++++++ engines/glk/archetype/sys_object.h | 46 ++ engines/glk/archetype/timestamp.cpp | 50 ++ engines/glk/archetype/timestamp.h | 62 +++ engines/glk/archetype/token.cpp | 441 +++++++++++++++++ engines/glk/archetype/token.h | 62 +++ engines/glk/archetype/wrap.cpp | 147 ++++++ engines/glk/archetype/wrap.h | 65 +++ engines/glk/module.mk | 21 +- 42 files changed, 6619 insertions(+), 4 deletions(-) create mode 100644 engines/glk/archetype/array.cpp create mode 100644 engines/glk/archetype/array.h create mode 100644 engines/glk/archetype/crypt.cpp create mode 100644 engines/glk/archetype/crypt.h create mode 100644 engines/glk/archetype/error.cpp create mode 100644 engines/glk/archetype/error.h create mode 100644 engines/glk/archetype/expression.cpp create mode 100644 engines/glk/archetype/expression.h create mode 100644 engines/glk/archetype/game_stat.cpp create mode 100644 engines/glk/archetype/game_stat.h create mode 100644 engines/glk/archetype/heap_sort.cpp create mode 100644 engines/glk/archetype/heap_sort.h create mode 100644 engines/glk/archetype/id_table.cpp create mode 100644 engines/glk/archetype/id_table.h create mode 100644 engines/glk/archetype/interpreter.cpp create mode 100644 engines/glk/archetype/interpreter.h create mode 100644 engines/glk/archetype/keywords.cpp create mode 100644 engines/glk/archetype/keywords.h create mode 100644 engines/glk/archetype/linked_list.cpp create mode 100644 engines/glk/archetype/linked_list.h create mode 100644 engines/glk/archetype/misc.cpp create mode 100644 engines/glk/archetype/misc.h create mode 100644 engines/glk/archetype/parser.cpp create mode 100644 engines/glk/archetype/parser.h create mode 100644 engines/glk/archetype/saveload.cpp create mode 100644 engines/glk/archetype/saveload.h create mode 100644 engines/glk/archetype/semantic.cpp create mode 100644 engines/glk/archetype/semantic.h create mode 100644 engines/glk/archetype/statement.h create mode 100644 engines/glk/archetype/string.cpp create mode 100644 engines/glk/archetype/string.h create mode 100644 engines/glk/archetype/sys_object.cpp create mode 100644 engines/glk/archetype/sys_object.h create mode 100644 engines/glk/archetype/timestamp.cpp create mode 100644 engines/glk/archetype/timestamp.h create mode 100644 engines/glk/archetype/token.cpp create mode 100644 engines/glk/archetype/token.h create mode 100644 engines/glk/archetype/wrap.cpp create mode 100644 engines/glk/archetype/wrap.h (limited to 'engines') diff --git a/engines/glk/archetype/archetype.cpp b/engines/glk/archetype/archetype.cpp index d2409bfce3..4b19c57854 100644 --- a/engines/glk/archetype/archetype.cpp +++ b/engines/glk/archetype/archetype.cpp @@ -20,8 +20,16 @@ * */ -#include "glk/archetype/archetype.h" #include "common/config-manager.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/crypt.h" +#include "glk/archetype/expression.h" +#include "glk/archetype/heap_sort.h" +#include "glk/archetype/misc.h" +#include "glk/archetype/saveload.h" +#include "glk/archetype/sys_object.h" +#include "glk/archetype/timestamp.h" +#include "glk/archetype/wrap.h" namespace Glk { namespace Archetype { @@ -29,15 +37,44 @@ namespace Archetype { Archetype *g_vm; Archetype::Archetype(OSystem *syst, const GlkGameDescription &gameDesc) : GlkAPI(syst, gameDesc), - _saveSlot(-1) { + _saveSlot(-1) { g_vm = this; } void Archetype::runGame() { - + initialize(); + interpret(); + deinitialize(); } bool Archetype::initialize() { + crypt_init(); + expression_init(); + heap_sort_init(); + misc_init(); + saveload_init(); + sys_object_init(); + timestamp_init(); + + // keywords + new_xarray(Literals); + new_xarray(Vocabulary); + + new_xarray(Type_ID_List); + new_xarray(Object_ID_List); + new_xarray(Attribute_ID_List); + + // parser + Abbreviate = 0x7fffffff; + new_list(Proximate); + new_list(object_names); + new_list(verb_names); + + // semantic + new_xarray(Type_List); + new_xarray(Object_List); + NullStr = NewConstStr("null"); + return true; } @@ -54,5 +91,838 @@ Common::Error Archetype::writeGameData(Common::WriteStream *ws) { return Common::kWritingFailed; } +void Archetype::interpret() { + Translating = false; + bool success = loadGame(); + _gameFile.close(); + + if (!success) + error("Could not load game"); + + ContextType context; + ResultType result; + undefine(result); + + if (!send_message(OP_SEND, find_message("START"), MainObject, result, context)) + error("Cannot execute; no ''START'' message for main object."); + + cleanup(result); +} + +bool Archetype::loadGame() { + return false; +} + +void Archetype::write(const String &fmt, ...) { + // TODO +} + +void Archetype::writeln(const String &fmt, ...) { + // TODO +} + +void Archetype::readln(String &s) { + // TODO +} + +char Archetype::ReadKey() { + // TODO + return '\0'; +} + +void Archetype::lookup(int the_obj, int the_attr, ResultType &result, ContextType &context, + DesiredType desired) { + NodePtr np; + bool done, first_pass; + ListType attrs; + int parent; + void *p, *original; + ExprTree e; + ContextType c; + + cleanup(result); + + if (desired == NAME) { + result._kind = IDENT; + result._ident.ident_kind = ATTRIBUTE_ID; + result._ident.ident_int = the_attr; + return; + } + + if (the_obj == 0) + // system object - all attributes UNDEFINED + return; + + if (!index_xarray(Object_List, the_obj, original)) { + g_vm->writeln("Internal error: cannot reference object %d", the_obj); + return; + } + + // Return UNDEFINED for attempting to reference any attribute of a destroyed object + if (original == nullptr) + return; + + // It is important to change the context before a lookup so that any non-scalar expressions + // that are referenced will be evaluated in the light of that object's context + c = context; + c.self = the_obj; // references to self must be right + c.each = 0; + + first_pass = true; + p = original; + done = false; + + // Inheritance loop + do { + ObjectType &obj = *((ObjectPtr)p); + attrs = obj.attributes; + parent = obj.inherited_from; + + np = find_item(attrs, the_attr); + if (np != nullptr || parent == 0) { + done = true; + } else { + // Track back + if (!index_xarray(Type_List, parent, p)) { + writeln("Internal error: lookup cannot find parent type %d", parent); + return; + } + + first_pass = false; + } + } while (!done); + + if (np == nullptr) + // not found anywhere + return; + + switch (desired) { + case RVALUE: + eval_expr((ExprPtr)np->data, result, c, RVALUE); + break; + + // Getting an inherited LVALUE is tricky. We must remember that since we have come + // this far, we definitely will return an ATTR_PTR result + case LVALUE: + if (first_pass) { + result._kind = ATTR_PTR; + result._attr.acl_attr = np; + } else { + // inherited - must create new node } + result._kind = ATTR_PTR; + result._attr.acl_attr = (NodePtr)malloc(sizeof(NodeType)); + + e = (ExprTree)malloc(sizeof(ExprNode)); + undefine(*e); + eval_expr((ExprPtr)np->data, *e, c, RVALUE); + + result._attr.acl_attr->data = e; + result._attr.acl_attr->key = the_attr; + insert_item(((ObjectPtr)original)->attributes, result._attr.acl_attr); + } + break; + + default: + break; + } +} + +bool Archetype::send_message(int transport, int message_sent, int recipient, + ResultType &result, ContextType &context) { + bool done, find_other; + ObjectPtr op, original; + ResultType r; + NodePtr np; + StatementPtr st; + void *p; + ContextType c; + + if (message_sent == 0) { + cleanup(result); + return false; + } + + if ((Debug & DEBUG_MSGS) > 0) { + r._kind = IDENT; + r._ident.ident_kind = OBJECT_ID; + r._ident.ident_int = context.self; + wrapout(" : ", false); + display_result(r); + + if (transport == OP_SEND) + wrapout(" sending ", false); + else + wrapout(" passing ", false); + + if (index_xarray(Vocabulary, message_sent, p)) { + String str = String::format("'%s'", ((StringPtr)p)->c_str()); + wrapout(str, false); + } + + if (transport == OP_SEND_TO_TYPE) + r._ident.ident_kind = TYPE_ID; + + wrapout(" to ", false); + r._ident.ident_int = recipient; + display_result(r); + wrapout("", true); + } + + // Trying to send a message to a destroyed object results in UNDEFINED + + if ((((transport == OP_SEND_TO_TYPE) && index_xarray(Type_List, recipient, p)) + || index_xarray(Object_List, recipient, p)) + && (p != nullptr)) { + c = context; + c.each = 0; + c.message = message_sent; + if (transport == OP_SEND) { + c.sender = context.self; + c.self = recipient; + } + + op = (ObjectPtr)p; + original = op; + done = false; + find_other = false; + while (!done) { + if (find_other) { + st = op->other; + } else { + np = find_item(op->methods, message_sent); + if (np != nullptr) + st = (StatementPtr)np->data; + else + st = nullptr; + } + + if (st != nullptr) { + // found it + exec_stmt(st, result, c); + return true; + } else { + // no message for recipient + if (op->inherited_from == 0) { + if (find_other) { + done = true; + } else { + op = original; + find_other = true; + } + } + else if (index_xarray(Type_List, op->inherited_from, p)) { + op = (ObjectPtr)p; + } else { + wraperr("Internal error: invalid inheritance"); + return false; + } + } + } + } + + // If we get here, it means that there was not even a "default" handler for + // the message in the given object or its lineage. Return ABSENT + result._kind = RESERVED; + result._reserved.keyword = RW_ABSENT; + + return false; +} + +void Archetype::eval_expr(ExprTree the_expr, ResultType &result, ContextType &context, DesiredType desired) { + ResultType r1, r2; + int i; + ExprTree e; + bool b; + + // It is very important to make sure that the "kind" fields of our temporary result variables + // are properly set to RESERVED/UNDEFINED before doing anything with them, so that if someone + // tries to clean them up later on, they won"t try to dispose of a string that isn't there + undefine(r1); + undefine(r2); + + cleanup(result); + + if (the_expr == nullptr) + return; + + // Check: if this is a lone attribute, look it up in this object"s table + if (the_expr->_kind == IDENT && the_expr->_ident.ident_kind == ATTRIBUTE_ID) + lookup(context.self, the_expr->_ident.ident_int, result, context, desired); + + else if (the_expr->_kind == RESERVED) { + // it is a special reserved word that requires an action + switch (the_expr->_reserved.keyword) { + case RW_READ: + case RW_KEY: + result._kind = STR_PTR; + if (the_expr->_reserved.keyword == RW_READ) + result._str.acl_str = ReadLine(true); // read full line + else + result._str.acl_str = ReadLine(false); // read single key + + Rows = 0; + cursor_reset(); // user will have had to hit + break; + + case RW_MESSAGE: + result._kind = MESSAGE; + result._msgTextQuote.index = context.message; + break; + + case RW_EACH: + case RW_SELF: + case RW_SENDER: + result._kind = IDENT; + result._ident.ident_kind = OBJECT_ID; + + switch (the_expr->_reserved.keyword) { + case RW_EACH: + result._ident.ident_int = context.each; + break; + case RW_SELF: + result._ident.ident_int = context.self; + break; + case RW_SENDER: + result._ident.ident_int = context.sender; + break; + default: + break; + } + break; + + default: + break; + } + } else if (the_expr->_kind == OPER) { + // It's an operator, need to evaulate it + switch (the_expr->_oper.op_name) { + case OP_SEND: + case OP_PASS: + eval_expr(the_expr->_oper.left, r1, context, RVALUE); + eval_expr(the_expr->_oper.right, r2, context, RVALUE); + + if (r2._kind == IDENT && (r2._ident.ident_kind == OBJECT_ID || r2._ident.ident_kind == TYPE_ID)) { + // Object 0 is the system object and always receives string messages + + if (r2._ident.ident_kind == OBJECT_ID && r2._ident.ident_int == 0) { + if (convert_to(STR_PTR, r1)) + send_to_system(the_expr->_oper.op_name, *r1._str.acl_str, result, context); + + } else if (convert_to(MESSAGE, r1)) { + if (r2._ident.ident_kind == TYPE_ID) + b = send_message(OP_SEND_TO_TYPE, r1._msgTextQuote.index, r2._ident.ident_int, + result, context); + else + b = send_message(the_expr->_oper.op_name, r1._msgTextQuote.index, + r2._ident.ident_int, result, context); + } + } + break; + + case OP_DOT: + eval_expr(the_expr->_oper.left, r1, context, RVALUE); + + if (r1._kind == IDENT && r1._ident.ident_kind == OBJECT_ID) { + eval_expr(the_expr->_oper.right, r2, context, NAME); + if (r2._kind == IDENT && r2._ident.ident_kind == ATTRIBUTE_ID) + lookup(r1._ident.ident_int, r2._ident.ident_int, result, context, desired); + } + break; + + case OP_ASSIGN: + if (desired == NAME) + return; + + eval_expr(the_expr->_oper.right, result, context, RVALUE); + eval_expr(the_expr->_oper.left, r1, context, LVALUE); + + if (!assignment(r1, result)) + cleanup(result); + else if (desired == LVALUE) { + cleanup(result); + result._kind = ATTR_PTR; + result._attr.acl_attr = r1._attr.acl_attr; + } + break; + + case OP_C_MULTIPLY: + case OP_C_DIVIDE: + case OP_C_PLUS: + case OP_C_MINUS: + case OP_C_CONCAT: + if (desired == NAME) + return; + + // Do the two operations using a dummy expression node + e = (ExprTree)malloc(sizeof(ExprNode)); + *e = *the_expr; + + switch (the_expr->_oper.op_name) { + case OP_C_MULTIPLY: + e->_oper.op_name = OP_MULTIPLY; + break; + case OP_C_DIVIDE: + e->_oper.op_name = OP_DIVIDE; + break; + case OP_C_PLUS: + e->_oper.op_name = OP_PLUS; + break; + case OP_C_MINUS: + e->_oper.op_name = OP_MINUS; + break; + case OP_C_CONCAT: + e->_oper.op_name = OP_CONCAT; + break; + default: + break; + } + + eval_expr(e, r1, context, RVALUE); + e->_oper.op_name = OP_ASSIGN; + e->_oper.right = &r1; + + eval_expr(e, result, context, desired); + free(e); + break; + + case OP_CHS: + case OP_NUMERIC: + eval_expr(the_expr->_oper.right, result, context, RVALUE); + if (!convert_to(NUMERIC, result)) + cleanup(result); + else if (the_expr->_oper.op_name == OP_CHS) + result._numeric.acl_int = -result._numeric.acl_int; + break; + + case OP_STRING: + eval_expr(the_expr->_oper.right, result, context, RVALUE); + if (!convert_to(STR_PTR, result)) + cleanup(result); + break; + + case OP_LENGTH: + eval_expr(the_expr->_oper.right, r1, context, RVALUE); + if (convert_to(STR_PTR, r1)) { + result._kind = NUMERIC; + result._numeric.acl_int = r1._str.acl_str->size(); + } + break; + + // For the random operator, we must be careful: ? "01234" should select a random digit + // out of that set, not attempt to convert it to 1234 and take a random number in the + // range 1 - 1234. However, we can neither immediately convert it to string, because + // ? 6 should produce a value in the range 1 - 6, not the character "6". } + case OP_RANDOM: + eval_expr(the_expr->_oper.right, result, context, RVALUE); + if (result._kind == NUMERIC) + // convert x < range to 1 <= x <= range + result._numeric.acl_int = g_vm->getRandomNumber(result._numeric.acl_int - 1) + 1; + else if (convert_to(STR_PTR, result)) { + // Replace the string with a single random character for it + String &s = *result._str.acl_str; + s = s[g_vm->getRandomNumber(s.size() - 1)]; + } + break; + + case OP_NOT: + result._kind = RESERVED; + if (eval_condition(the_expr->_oper.right, context)) + result._reserved.keyword = RW_FALSE; + else + result._reserved.keyword = RW_TRUE; + break; + + case OP_PLUS: + case OP_MINUS: + case OP_MULTIPLY: + case OP_DIVIDE: + eval_expr(the_expr->_oper.left, r1, context, RVALUE); + eval_expr(the_expr->_oper.right, r2, context, RVALUE); + if (convert_to(NUMERIC, r1) && convert_to(NUMERIC, r2)) { + result._kind = NUMERIC; + switch (the_expr->_oper.op_name) { + case OP_PLUS: + result._numeric.acl_int = r1._numeric.acl_int + r2._numeric.acl_int; + break; + case OP_MINUS: + result._numeric.acl_int = r1._numeric.acl_int - r2._numeric.acl_int; + break; + case OP_MULTIPLY: + result._numeric.acl_int = r1._numeric.acl_int * r2._numeric.acl_int; + break; + case OP_DIVIDE: + result._numeric.acl_int = r1._numeric.acl_int / r2._numeric.acl_int; + break; + default: + break; + } + } + break; + + case OP_AND: + result._kind = RESERVED; + if (eval_condition(the_expr->_oper.left, context) && eval_condition(the_expr->_oper.right, context)) + result._reserved.keyword = RW_TRUE; + else + result._reserved.keyword = RW_FALSE; + break; + + case OP_OR: + if (eval_condition(the_expr->_oper.left, context) || eval_condition(the_expr->_oper.right, context)) + result._reserved.keyword = RW_TRUE; + else + result._reserved.keyword = RW_FALSE; + break; + + case OP_POWER: + eval_expr(the_expr->_oper.right, r2, context, RVALUE); + eval_expr(the_expr->_oper.left, r1, context, RVALUE); + if (convert_to(NUMERIC, r2) && convert_to(NUMERIC, r1)) { + result._kind = NUMERIC; + result._numeric.acl_int = 1; + for (i = 1; i <= r2._numeric.acl_int; ++i) + result._numeric.acl_int *= r1._numeric.acl_int; + } + break; + + case OP_CONCAT: + eval_expr(the_expr->_oper.left, r1, context, RVALUE); + eval_expr(the_expr->_oper.right, r2, context, RVALUE); + if (convert_to(STR_PTR, r1) && convert_to(STR_PTR, r2)) { + result._kind = STR_PTR; + result._str.acl_str = MakeNewDynStr(*r1._str.acl_str + *r2._str.acl_str); + } + break; + + case OP_LEFTFROM: + case OP_RIGHTFROM: + eval_expr(the_expr->_oper.left, r1, context, RVALUE); + eval_expr(the_expr->_oper.right, r2, context, RVALUE); + if (convert_to(STR_PTR, r1) && convert_to(NUMERIC, r2)) { + result._kind = STR_PTR; + if (the_expr->_oper.op_name == OP_LEFTFROM) + result._str.acl_str = MakeNewDynStr(r1._str.acl_str->left(r2._numeric.acl_int)); + else + result._str.acl_str = MakeNewDynStr(r1._str.acl_str->right(r2._numeric.acl_int)); + } + break; + + case OP_WITHIN: + eval_expr(the_expr->_oper.left, r1, context, RVALUE); + eval_expr(the_expr->_oper.right, r2, context, RVALUE); + if (convert_to(STR_PTR, r1) && convert_to(STR_PTR, r2)) { + result._kind = NUMERIC; + result._numeric.acl_int = r2._str.acl_str->indexOf(*r1._str.acl_str); + if (result._numeric.acl_int == -1) + cleanup(result); + } + break; + + case OP_EQ: + case OP_NE: + case OP_LT: + case OP_GT: + case OP_LE: + case OP_GE: + eval_expr(the_expr->_oper.left, r1, context, RVALUE); + eval_expr(the_expr->_oper.right, r2, context, RVALUE); + + result._kind = RESERVED; + if (result_compare(the_expr->_oper.op_name, r1, r2)) + result._reserved.keyword = RW_TRUE; + else + result._reserved.keyword = RW_FALSE; + break; + + default: + g_vm->writeln("Internal error: \"%s\" not yet supported", Operators[the_expr->_oper.op_name]); + break; + } + + cleanup(r1); + cleanup(r2); + + if ((Debug & DEBUG_EXPR) > 0) { + wrapout(" -- ", false); + display_expr(the_expr); + wrapout(" ==> ", false); + display_result(result); + wrapout("", true); + } + } else { + switch (desired) { + case RVALUE: + copy_result(result, *the_expr); + break; + case LVALUE: + result = *the_expr; + break; + default: + break; + } + } +} + +bool Archetype::eval_condition(ExprTree the_expr, ContextType &context) { + ResultType result; + bool failure; + + undefine(result); + eval_expr(the_expr, result, context, RVALUE); + + failure = (result._kind == RESERVED) && (result._reserved.keyword = RW_UNDEFINED + || result._reserved.keyword == RW_FALSE || result._reserved.keyword == RW_ABSENT); + + cleanup(result); + return !failure; +} + +void Archetype::exec_stmt(StatementPtr the_stmt, ResultType &result, ContextType &context) { + NodePtr np; + void *p, *q; + ResultType r1, r2; + CasePairPtr this_case; + bool b; + ContextType c; + int i; + ObjectPtr the_object; + bool verbose; + + undefine(r1); + undefine(r2); + cleanup(result); + + verbose = (Debug & DEBUG_STMT) > 0; + + if (verbose) + wrapout(" == ", false); + + switch (the_stmt->_kind) { + case COMPOUND: + np = nullptr; + b = false; + while (!b && iterate_list(the_stmt->_compound.statements, np)) { + cleanup(result); + exec_stmt((StatementPtr)np->data, result, context); + + b = (result._kind == RESERVED) && (result._reserved.keyword == RW_BREAK); + } + break; + + case ST_EXPR: + if (verbose) + display_expr(the_stmt->_expr.expression); + + switch (the_stmt->_expr.expression->_kind) { + case QUOTE_LIT: + if (index_xarray(Literals, the_stmt->_expr.expression->_msgTextQuote.index, p)) { + result._kind = TEXT_LIT; + result._msgTextQuote.index = the_stmt->_expr.expression->_msgTextQuote.index; + wrapout(*((StringPtr)p), true); + } + break; + + case MESSAGE: + b = send_message(OP_PASS, the_stmt->_expr.expression->_msgTextQuote.index, + context.self, result, context); + default: + eval_expr(the_stmt->_expr.expression, result, context, RVALUE); + break; + } + break; + + case ST_WRITE: + case ST_WRITES: + case ST_STOP: + if (verbose) { + switch (the_stmt->_kind) { + case ST_WRITE: + wrapout("write ", false); + break; + case ST_WRITES: + wrapout("writes ", false); + break; + case ST_STOP: + wrapout("stop ", false); + break; + default: + break; + } + + wrapout(" ", false); + np = nullptr; + while (iterate_list(the_stmt->_write.print_list, np)) { + display_expr((ExprTree)np->data); + if (np->next != the_stmt->_write.print_list) + wrapout(", ", false); + } + + wrapout("", true); + } + + np = nullptr; + while (iterate_list(the_stmt->_write.print_list, np)) { + cleanup(result); + eval_expr((ExprTree)np->data, result, context, RVALUE); + write_result(result); + } + + if (the_stmt->_kind == ST_WRITE) { + wrapout("", true); + } + else if (the_stmt->_kind == ST_STOP) { + g_vm->writeln(); + g_vm->writeln(); + error("%s", VERSION); + } + break; + + case ST_IF: + if (verbose) { + wrapout("if: Testing ", false); + display_expr(the_stmt->_if.condition); + } + if (eval_condition(the_stmt->_if.condition, context)) { + if (verbose) + wrapout(" Evaluated true; executing then branch", true); + exec_stmt(the_stmt->_if.then_branch, result, context); + + } + else if (the_stmt->_if.else_branch != nullptr) { + if (verbose) + wrapout(" Evaluated false; executing else branch", true); + exec_stmt(the_stmt->_if.else_branch, result, context); + } + break; + + case ST_CASE: + if (verbose) { + wrapout("case ", false); + display_expr(the_stmt->_case.test_expr); + wrapout(" of", false); + wrapout("", true); + } + + eval_expr(the_stmt->_case.test_expr, r1, context, RVALUE); + np = nullptr; + + while (iterate_list(the_stmt->_case.cases, np)) { + this_case = (CasePairPtr)np->data; + + //with this_case^ do begin + eval_expr(this_case->value, r2, context, RVALUE); + if ((r2._kind == RESERVED && r2._reserved.keyword == RW_DEFAULT) + || result_compare(OP_EQ, r1, r2)) { + exec_stmt(this_case->action, result, context); + cleanup(r1); + cleanup(r2); + return; + } + + cleanup(r2); + } + + cleanup(result); + cleanup(r1); + break; + + case ST_BREAK: + result._kind = RESERVED; + result._reserved.keyword = RW_BREAK; + break; + + case ST_FOR: + b = false; + c = context; + c.each = 1; + + while (!b && c.each < (int)Object_List.size()) { + if (eval_condition(the_stmt->_loop.selection, c)) { + exec_stmt(the_stmt->_loop.action, result, c); + b = (result._kind == RESERVED) && (result._reserved.keyword == RW_BREAK); + cleanup(result); + } + + ++c.each; + } + break; + + case ST_WHILE: + b = false; + while (!b && eval_condition(the_stmt->_loop.selection, context)) { + exec_stmt(the_stmt->_loop.action, result, context); + b = (result._kind == RESERVED) && (result._reserved.keyword == RW_BREAK); + cleanup(result); + } + break; + + case ST_CREATE: + eval_expr(the_stmt->_create.new_name, r1, context, LVALUE); + + // Attempt a dummy assignment just to see if it works + result._kind = IDENT; + result._ident.ident_kind = OBJECT_ID; + result._ident.ident_int = 0; + + if (!assignment(r1, result)) { + cleanup(result); + } + else { + // do it for real + the_object = (ObjectPtr)malloc(sizeof(ObjectType)); + the_object->inherited_from = the_stmt->_create.archetype; + new_list(the_object->attributes); + new_list(the_object->methods); + the_object->other = nullptr; + p = the_object; + + // NOTE: Search the list for an empty slot; if none found, append + i = Dynamic; + b = true; + while (access_xarray(Object_List, i, q, PEEK_ACCESS) && q != nullptr) + ++i; + + if (i >= (int)Object_List.size()) + append_to_xarray(Object_List, p); + else + b = access_xarray(Object_List, i, p, POKE_ACCESS); + + // Now we know its number; go back and update the result"s object reference. + // "Return" this same value + ((ExprPtr)r1._attr.acl_attr->data)->_ident.ident_int = i; + copy_result(result, *(ExprPtr)r1._attr.acl_attr->data); + + cleanup(r1); + } + break; + + // Just dispose of the indicated object in the Object_List. Shrink the list only if + // the very last object was destroyed + case ST_DESTROY: + eval_expr(the_stmt->_destroy.victim, result, context, RVALUE); + if (result._kind == IDENT && result._ident.ident_kind == OBJECT_ID + && index_xarray(Object_List, result._ident.ident_int, p)) { + the_object = (ObjectPtr)p; + dispose_object(the_object); + p = nullptr; + b = access_xarray(Object_List, result._ident.ident_int, p, POKE_ACCESS); + if (result._ident.ident_int == ((int)Object_List.size() - 1)) + shrink_xarray(Object_List); + } else { + wraperr("Can only destroy previously created objects"); + } + + cleanup(result); + break; + + default: + wraperr("Internal error: statement not supported yet"); + break; + } + + if (verbose) + wrapout("", true); // finish off dangling lines +} + } // End of namespace Archetype } // End of namespace Glk diff --git a/engines/glk/archetype/archetype.h b/engines/glk/archetype/archetype.h index 709ebc643b..dec950ca74 100644 --- a/engines/glk/archetype/archetype.h +++ b/engines/glk/archetype/archetype.h @@ -24,6 +24,11 @@ #define ARCHETYPE_ARCHETYPE #include "glk/glk_api.h" +#include "glk/archetype/array.h" +#include "glk/archetype/interpreter.h" +#include "glk/archetype/semantic.h" +#include "glk/archetype/statement.h" +#include "glk/archetype/string.h" namespace Glk { namespace Archetype { @@ -34,6 +39,23 @@ namespace Archetype { class Archetype : public GlkAPI { private: int _saveSlot; + bool Translating; +public: + // keywords.cpp + XArrayType Literals, Vocabulary; + XArrayType Type_ID_List, Object_ID_List, Attribute_ID_List; + + // parser.cpp + String Command; + int Abbreviate; + ListType Proximate; + ListType verb_names; + ListType object_names; + + // semantic.cpp + XArrayType Type_List, Object_List; + ListType Overlooked; + StringPtr NullStr; private: /** * Engine initialization @@ -44,6 +66,64 @@ private: * Engine cleanup */ void deinitialize(); + + /** + * Main interpreter method + */ + void interpret(); + + /** + * Loads the text adventure game + */ + bool loadGame(); + + /** + * Given an object number, attribute number, anddesired_type, returns the value of the lookup + * in the given result.If the desired_type is LVALUE, then it creates a new attribute node + * in the object's own attribute list(if not already existing) and returns a pointer to it. + * If RVALUE, it evaluates any expression it may find, returning the result of the evaluation. + * + * Also performs inheritance, looking back through the object's family tree to find the attribute. + */ + void lookup(int the_obj, int the_attr, ResultType &result, ContextType &context, DesiredType desired); + + /** + * Sends the given message number to the object of the given number. This procedure performs + * inheritance; that is, it will search back through the object's ancestry in order to find + * someone to perform the message.Has to do something tricky with the default message: + * it must first search the entire ancestry for an explicit message, then search again for + * a default, if none found. + * @param transport how to send the message : sending to an object, + * passing to an object, or sending(passing) to a type. + * @param message message to send + * @param recipient number of object to receive message + * @param result Output result of the sending + * @param context Context + * @returns true if the recipient handles the message; false if it doesn't + */ + bool send_message(int transport, int message_sent, int recipient, ResultType &result, + ContextType &context); + + /** + * Evaluates the given expression + */ + void eval_expr(ExprTree the_expr, ResultType &result, ContextType &context, DesiredType desired); + + /** + * Evaluates the given expression as though it were a condition. Will succeed if the given + * expression is not UNDEFINED and not false. + * @param the_expr Expression to evaluate + * @returns true if the condition can be considered true; false otherwise + */ + bool eval_condition(ExprTree the_expr, ContextType &context); + + /** + * Given a pointer to a statement, executes that statement. Very heavily called + * @param the_stmt pointer to statement to be executed + * @param result the "value" of the execution(for example, the last expression + * of a compound statement + */ + void exec_stmt(StatementPtr the_stmt, ResultType &result, ContextType &context); public: /** * Constructor @@ -78,6 +158,21 @@ public: bool loadingSavegame() const { return _saveSlot != -1; } + + /** + * Write some text to the screen + */ + void write(const String &fmt, ...); + + /** + * Write a line to the screen + */ + void writeln(const String &fmt, ...); + void writeln() { writeln(""); } + + void readln(String &s); + + char ReadKey(); }; extern Archetype *g_vm; diff --git a/engines/glk/archetype/array.cpp b/engines/glk/archetype/array.cpp new file mode 100644 index 0000000000..b816306fc3 --- /dev/null +++ b/engines/glk/archetype/array.cpp @@ -0,0 +1,66 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/array.h" + +namespace Glk { +namespace Archetype { + +void new_xarray(XArrayType &the_xarray) { + the_xarray.clear(); +} + +void dispose_xarray(XArrayType &the_xarray) { + the_xarray.clear(); +} + +void append_to_xarray(XArrayType &the_xarray, void *element) { + the_xarray.push_back(element); +} + +bool access_xarray(XArrayType &the_xarray, int index, void *&result, AccessType direction) { + if (index < 0 || index >= (int)the_xarray.size()) + return false; + + switch (direction) { + case PEEK_ACCESS: + result = the_xarray[index]; + break; + case POKE_ACCESS: + the_xarray[index] = result; + break; + } + + return true; +} + +bool index_xarray(XArrayType &the_xarray, int index, void *&result) { + return access_xarray(the_xarray, index, result, PEEK_ACCESS); +} + +void shrink_xarray(XArrayType &the_xarray) { + if (!the_xarray.empty()) + the_xarray.resize(the_xarray.size() - 1); +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/array.h b/engines/glk/archetype/array.h new file mode 100644 index 0000000000..17379f1057 --- /dev/null +++ b/engines/glk/archetype/array.h @@ -0,0 +1,69 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_XARRAY +#define ARCHETYPE_XARRAY + +#include "common/array.h" + +namespace Glk { +namespace Archetype { + +typedef Common::Array XArrayType; + +enum AccessType { POKE_ACCESS, PEEK_ACCESS }; + +/** + * Initialize an extendible array + */ +extern void new_xarray(XArrayType &the_xarray); + +/** + * Disposes the array + */ +extern void dispose_xarray(XArrayType &the_xarray); + +/** + * Appends a new element to the end of the array + */ +extern void append_to_xarray(XArrayType &the_xarray, void *element); + +/** + * Access a given index in the array to either set or retrieve an entry + * @param the_xarray The array to access + */ +extern bool access_xarray(XArrayType &the_xarray, int index, void *&result, AccessType direction); + +/** + * Access a given index in the array + */ +extern bool index_xarray(XArrayType &the_xarray, int index, void *&result); + +/** + * Removes the last element of the array + */ +extern void shrink_xarray(XArrayType &the_xarray); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/crypt.cpp b/engines/glk/archetype/crypt.cpp new file mode 100644 index 0000000000..d99dab0907 --- /dev/null +++ b/engines/glk/archetype/crypt.cpp @@ -0,0 +1,82 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/crypt.h" +#include "glk/archetype/archetype.h" + +namespace Glk { +namespace Archetype { + +byte CryptMask; +EncryptionType Encryption; + +void crypt_init() { + Encryption = NONE; + CryptMask = 0x55; +} + +void cryptinit(EncryptionType crypt_kind, uint seed) { + CryptMask = seed & 0xff; + Encryption = crypt_kind; + + if (Encryption == COMPLEX) + g_vm->setRandomNumberSeed(seed); +} + +void cryptstr(Common::String &s) { + byte nextMask; + + switch (Encryption) { + case SIMPLE: + for (uint i = 0; i < s.size(); ++i) + s.setChar(s[i] ^ CryptMask, i); + break; + + case PURPLE: + for (uint i = 0; i < s.size(); ++i) { + s.setChar(s[i] ^ CryptMask, i); + CryptMask += s[i] & 7; + } + break; + + case UNPURPLE: + for (uint i = 0; i < s.size(); ++i) { + nextMask = CryptMask + (s[i] & 7); + s.setChar(s[i] ^ CryptMask, i); + CryptMask = nextMask; + } + break; + + case COMPLEX: + for (uint i = 0; i < s.size(); ++i) { + s.setChar(s[i] ^ CryptMask, i); + CryptMask = g_vm->getRandomNumber(0x100); + } + break; + + default: + break; + } +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/crypt.h b/engines/glk/archetype/crypt.h new file mode 100644 index 0000000000..d978210e9a --- /dev/null +++ b/engines/glk/archetype/crypt.h @@ -0,0 +1,64 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_CRYPT +#define ARCHETYPE_CRYPT + +#include "common/scummsys.h" +#include "common/str.h" + +namespace Glk { +namespace Archetype { + +enum EncryptionType { + NONE, SIMPLE, PURPLE, UNPURPLE, COMPLEX, DEBUGGING_ON +}; + +extern byte CryptMask; +extern EncryptionType Encryption; + +/** + * Initializes fields local to the file + */ +extern void crypt_init(); + +extern void cryptinit(EncryptionType crypt_kind, uint seed); + +/** + * Encrypts or decrypts a string.Since all encryption methods are based on XOR, + * the same method both encrypts anddecrypts. + * If is SIMPLE, the CryptMask is simply XORed with each byte in the string. + * If is PURPLE, the CryptMask is changed each time after using it, + * by adding to it the lowest three bits of the result of the last encrypted + * byte.This way the mask changes frequently anddynamically in a way that + * is difficult to predict. + * If is UNPURPLE, the same algorithm as PURPLE is used except that + * the next CryptMask must be determined before altering the byte under consideration. + * if is COMPLEX, a pseudorandom sequence is used to alter the + * CryptMask.This can make prediction well-nigh impossible. + */ +extern void cryptstr(Common::String &s); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/error.cpp b/engines/glk/archetype/error.cpp new file mode 100644 index 0000000000..18cb4d6acb --- /dev/null +++ b/engines/glk/archetype/error.cpp @@ -0,0 +1,80 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/error.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/token.h" + +namespace Glk { +namespace Archetype { + +void hit_eof(progfile &f, AclType expecting, int specific) { + if (KeepLooking) { + KeepLooking = false; + g_vm->write("Found end of file; expected "); + write_token(expecting, specific); + g_vm->writeln(); + } +} + +void expected(progfile &f, AclType expect_ttype, int expect_specific) { + if (KeepLooking) { + f.sourcePos(); + g_vm->write("Expected "); + write_token(expect_ttype, expect_specific); + g_vm->write("; found "); + write_token(f.ttype, f.tnum); + g_vm->writeln(); + } +} + +void expect_general(progfile &f, const String &general_desc) { + if (KeepLooking) { + f.sourcePos(); + g_vm->write("Expected %s; found ", general_desc.c_str()); + write_token(f.ttype, f.tnum); + g_vm->writeln(); + } +} + +void error_message(progfile &f, const String &message) { + if (KeepLooking) { + f.sourcePos(); + g_vm->writeln(message); + } +} + +bool insist_on(progfile &f, AclType some_type, int some_number) { + if (!get_token(f)) { + hit_eof(f, some_type, some_number); + return false; + } else if (f.ttype != some_type && f.tnum != some_number) { + expected(f, some_type, some_number); + KeepLooking = false; + return false; + } else { + return true; + } +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/error.h b/engines/glk/archetype/error.h new file mode 100644 index 0000000000..c6b70c0228 --- /dev/null +++ b/engines/glk/archetype/error.h @@ -0,0 +1,49 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_ERROR +#define ARCHETYPE_ERROR + +/* Writes out all kinds of compile-time errors.Does not perform a halt; + * expects the program itself to "unravel" the process + */ + +#include "glk/archetype/misc.h" + +namespace Glk { +namespace Archetype { + +extern void hit_eof(progfile &f, AclType expecting, int specific); +extern void expected(progfile &f, AclType expect_ttype, int expect_specific); +extern void expect_general(progfile &f, const String &general_desc); +extern void error_message(progfile &f, const String &message); + +/** + * Used when a particular token is insisted upon by the syntax, usually + * for readability.It will be an error for the token not to exist. + */ +extern bool insist_on(progfile &f, AclType some_type, int some_number); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/expression.cpp b/engines/glk/archetype/expression.cpp new file mode 100644 index 0000000000..6f71dd502d --- /dev/null +++ b/engines/glk/archetype/expression.cpp @@ -0,0 +1,129 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/expression.h" + +namespace Glk { +namespace Archetype { + +bool Right_Assoc[NUM_OPERS + 1]; +bool Binary[NUM_OPERS + 1]; +int8 Precedence[NUM_OPERS + 1]; + +void expression_init() { + Binary[OP_LPAREN] = false; + Binary[OP_DOT] = true; + Binary[OP_CHS] = false; + Binary[OP_NUMERIC] = false; + Binary[OP_STRING] = false; + Binary[OP_RANDOM] = false; + Binary[OP_LENGTH] = false; + Binary[OP_POWER] = true; + Binary[OP_MULTIPLY] = true; + Binary[OP_DIVIDE] = true; + Binary[OP_PLUS] = true; + Binary[OP_MINUS] = true; + Binary[OP_CONCAT] = true; + Binary[OP_WITHIN] = true; + Binary[OP_LEFTFROM] = true; + Binary[OP_RIGHTFROM] = true; + Binary[OP_EQ] = true; + Binary[OP_NE] = true; + Binary[OP_GT] = true; + Binary[OP_LT] = true; + Binary[OP_GE] = true; + Binary[OP_LE] = true; + Binary[OP_NOT] = false; + Binary[OP_AND] = true; + Binary[OP_OR] = true; + Binary[OP_C_MULTIPLY] = true; + Binary[OP_C_DIVIDE] = true; + Binary[OP_C_PLUS] = true; + Binary[OP_C_MINUS] = true; + Binary[OP_C_CONCAT] = true; + Binary[OP_ASSIGN] = true; + Binary[OP_SEND] = true; + Binary[OP_PASS] = true; + + // Initialize the Right_Assoc table as follows : anything unary must be right-associative; + // all others are assumed left-associative.After the loop, right-associative binary operators + // are explicity set + for (int i = 0; i <= NUM_OPERS; ++i) + Right_Assoc[i] = !Binary[i]; + + Right_Assoc[OP_POWER] = true; + Right_Assoc[OP_C_MULTIPLY] = true; + Right_Assoc[OP_C_DIVIDE] = true; + Right_Assoc[OP_C_PLUS] = true; + Right_Assoc[OP_C_MINUS] = true; + Right_Assoc[OP_C_CONCAT] = true; + Right_Assoc[OP_ASSIGN] = true; + + + Precedence[OP_LPAREN] = 14; // must always be the higest + Precedence[OP_DOT] = 13; + + Precedence[OP_CHS] = 12; + Precedence[OP_NUMERIC] = 12; + Precedence[OP_STRING] = 12; + Precedence[OP_RANDOM] = 12; + Precedence[OP_LENGTH] = 12; + + Precedence[OP_POWER] = 11; + + Precedence[OP_MULTIPLY] = 10; + Precedence[OP_DIVIDE] = 10; + + Precedence[OP_PLUS] = 9; + Precedence[OP_MINUS] = 9; + Precedence[OP_CONCAT] = 9; + + Precedence[OP_WITHIN] = 8; + + Precedence[OP_LEFTFROM] = 7; + Precedence[OP_RIGHTFROM] = 7; + + Precedence[OP_SEND] = 6; + Precedence[OP_PASS] = 6; + + Precedence[OP_EQ] = 5; + Precedence[OP_NE] = 5; + Precedence[OP_GT] = 5; + Precedence[OP_LT] = 5; + Precedence[OP_GE] = 5; + Precedence[OP_LE] = 5; + + Precedence[OP_NOT] = 4; + Precedence[OP_AND] = 3; + Precedence[OP_OR] = 2; + + Precedence[OP_C_MULTIPLY] = 1; + Precedence[OP_C_DIVIDE] = 1; + Precedence[OP_C_PLUS] = 1; + Precedence[OP_C_MINUS] = 1; + Precedence[OP_C_CONCAT] = 1; + Precedence[OP_ASSIGN] = 1; +} + + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/expression.h b/engines/glk/archetype/expression.h new file mode 100644 index 0000000000..3fc600787a --- /dev/null +++ b/engines/glk/archetype/expression.h @@ -0,0 +1,90 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_EXPRESSION +#define ARCHETYPE_EXPRESSION + +#include "glk/archetype/keywords.h" +#include "glk/archetype/linked_list.h" +#include "glk/archetype/misc.h" + +namespace Glk { +namespace Archetype { + +const int OP_LPAREN = NUM_OPERS + 1; // book-keeping operator +const int OP_SEND_TO_TYPE = NUM_OPERS + 2; // for use with interpreter + +struct OperNode { + int8 op_name; + union ExprNode *left, *right; +}; + +struct MessageTextQuoteNode { + int index; +}; + +struct NumericNode { + int acl_int; +}; + +struct StrNode { + StringPtr acl_str; +}; + +struct AttrNode { + NodePtr acl_attr; +}; + +struct ReservedNode { + int8 keyword; +}; + +struct IdentNode { + ClassifyType ident_kind; + int ident_int; +}; + +union ExprNode { + AclType _kind; + OperNode _oper; + NumericNode _numeric; + MessageTextQuoteNode _msgTextQuote; + StrNode _str; + AttrNode _attr; + ReservedNode _reserved; + IdentNode _ident; +}; + +typedef ExprNode *ExprPtr; +typedef ExprPtr ExprTree; + +// Global variables +extern bool Right_Assoc[NUM_OPERS + 1]; +extern bool Binary[NUM_OPERS + 1]; +extern int8 Precedence[NUM_OPERS + 1]; + +extern void expression_init(); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/game_stat.cpp b/engines/glk/archetype/game_stat.cpp new file mode 100644 index 0000000000..9f6a8b85d6 --- /dev/null +++ b/engines/glk/archetype/game_stat.cpp @@ -0,0 +1,121 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/game_stat.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/crypt.h" +#include "glk/archetype/saveload.h" +#include "glk/archetype/statement.h" +#include "glk/archetype/timestamp.h" + +namespace Glk { +namespace Archetype { + +void save_game_state(Common::WriteStream *bfile, XArrayType &objects) { + int i; + void *p; + + // Write out the timestamp associated with the original game + bfile->writeUint32LE(GTimeStamp); + + // Get the encryption straight - reset the seed + cryptinit(Encryption, GTimeStamp); + + for (i = 0; i < Dynamic - 1; ++i) { + if (index_xarray(objects, i, p)) { + ObjectPtr op = (ObjectPtr)p; + bfile->writeUint32LE(vContSeq); + + dump_item_list(bfile, op->attributes, EXPR_LIST); + } + } + + for (i = Dynamic; i < (int)objects.size(); ++i) { + if (index_xarray(objects, i, p)) { + bfile->writeUint32LE(vContSeq); + dump_object(bfile, (ObjectPtr)p); + } + } + + bfile->writeUint32LE(vEndSeq); +} + +bool load_game_state(Common::ReadStream *bfile, XArrayType &objects) { + int i; + void *p; + ObjectPtr op; + TimestampType tstamp; + StatementKind sentinel; + + // Check the time stamp + tstamp = bfile->readUint32LE(); + if (tstamp != GTimeStamp) { + g_vm->writeln("State file does not match original .ACX file"); + return false; + } + + // Get the encryption straight - reset the seed.Be careful upon loading since we have + // to do UNPURPLE instead of PURPLE + if (Encryption == PURPLE) + Encryption = UNPURPLE; + cryptinit(Encryption, GTimeStamp); + + // Need to flush out the previous attributes andload in the new ones. Dynamically allocated + // objects are a little different since they might vary between game states + for (i = 0; i < Dynamic - 1; ++i) { + if (index_xarray(objects, i, p)) { + sentinel = (StatementKind)bfile->readUint32LE(); + op = (ObjectPtr)p; + dispose_item_list(op->attributes, EXPR_LIST); + load_item_list(bfile, op->attributes, EXPR_LIST); + } + } + + // Flush dynamic objects.Dispose of each object andshrink back the xarray + + for (i = objects.size() - 1; i >= Dynamic; --i) { + if (index_xarray(objects, i, p)) { + op = (ObjectPtr)p; + dispose_object(op); + } + + shrink_xarray(objects); + } + + // sentinel has been set from before + sentinel = (StatementKind)bfile->readUint32LE(); + while (sentinel == CONT_SEQ) { + load_object(bfile, op); + p = op; + append_to_xarray(objects, p); + + sentinel = (StatementKind)bfile->readUint32LE(); + } + + if (Encryption == UNPURPLE) + Encryption = PURPLE; + + return true; +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/game_stat.h b/engines/glk/archetype/game_stat.h new file mode 100644 index 0000000000..ae4a1bb2ef --- /dev/null +++ b/engines/glk/archetype/game_stat.h @@ -0,0 +1,46 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_GAME_STAT +#define ARCHETYPE_GAME_STAT + +/* Functions and procedures that help with the saving and loading of + * game states. Only the attribute records of a given object list are ever + * saved or loaded; statements and other object information, such as + * the Dynamic pointer, are really constant across a game; as long as + * we know that the game states belong to a particular game, we don't + * need to save any more. + */ + +#include "glk/archetype/array.h" +#include "common/stream.h" + +namespace Glk { +namespace Archetype { + +extern void save_game_state(Common::WriteStream *bfile, XArrayType &objects); +extern bool load_game_state(Common::ReadStream *bfile, XArrayType &objects); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/heap_sort.cpp b/engines/glk/archetype/heap_sort.cpp new file mode 100644 index 0000000000..98753ccc70 --- /dev/null +++ b/engines/glk/archetype/heap_sort.cpp @@ -0,0 +1,148 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/heap_sort.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/misc.h" + +namespace Glk { +namespace Archetype { + +const char *const CANT_PEEK = "Internal error: cannot peek into heap"; +const char *const CANT_POKE = "Internal error: cannot poke into heap"; + +HeapType H; + +void heap_sort_init() { + new_xarray(H); +} + +static bool lighter(const Element one, const Element two) { + return *static_cast(one) < *static_cast(two); +} + +static void heapup() { + int L, parent; + Element Lp, parentp = nullptr; + Element temp; + + L = H.size(); + while (L > 0) { + if ((L % 2) == 0) + parent = L / 2; + else + parent = (L - 1) / 2; + + if (!(access_xarray(H, L, Lp, PEEK_ACCESS) && access_xarray(H, parent, parentp, PEEK_ACCESS))) + g_vm->writeln(CANT_PEEK); + + if (lighter(Lp, parentp)) { + temp = parentp; + if (!(access_xarray(H, parent, Lp, POKE_ACCESS) && access_xarray(H, L, temp, POKE_ACCESS))) + g_vm->writeln(CANT_POKE); + L = parent; + } else { + L = 0; + } + } +} + +static void heapdown() { + uint L, compare, lc, rc; + Element lp; + Element lcp, rcp; + Element comparep; + Element temp; + + L = 0; + while (L < H.size()) { + lc = L * 2; + if (lc >= H.size()) { + L = lc; + } else { + rc = lc + 1; + if (!access_xarray(H, lc, lcp, PEEK_ACCESS)) + g_vm->writeln(CANT_PEEK); + + if (rc >= H.size()) { + compare = lc; + comparep = lcp; + } else { + if (!access_xarray(H, rc, rcp, PEEK_ACCESS)) + g_vm->writeln(CANT_PEEK); + if (lighter(lcp, rcp)) { + compare = lc; + comparep = lcp; + } else { + compare = rc; + comparep = rcp; + } + } + + if (!access_xarray(H, L, lp, PEEK_ACCESS)) + g_vm->writeln(CANT_PEEK); + if (!lighter(comparep, lp)) { + temp = comparep; + if (!(access_xarray(H, compare, lp, POKE_ACCESS) && access_xarray(H, L, temp, POKE_ACCESS))) + g_vm->writeln(CANT_POKE); + L = compare; + } else { + L = H.size(); + } + } + } +} + +bool pop_heap(Element &e) { + Element temp; + + if (H.empty()) { + return false; + } else { + if (!(access_xarray(H, 0, e, PEEK_ACCESS) && access_xarray(H, H.size() - 1, temp, PEEK_ACCESS) + && access_xarray(H, 0, temp, POKE_ACCESS))) + g_vm->writeln(CANT_PEEK); + + shrink_xarray(H); + heapdown(); + return true; + } +} + +void drop_on_heap(Element e) { + append_to_xarray(H, e); + heapup(); +} + +void drop_str_on_heap(const String &s) { + StringPtr sp = NewDynStr(s); + void *p = (void *)sp; + drop_on_heap(p); +} + +void reinit_heap() { + dispose_xarray(H); + new_xarray(H); +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/heap_sort.h b/engines/glk/archetype/heap_sort.h new file mode 100644 index 0000000000..5e2512407f --- /dev/null +++ b/engines/glk/archetype/heap_sort.h @@ -0,0 +1,48 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_HEAP_SORT +#define ARCHETYPE_HEAP_SORT + +#include "glk/archetype/array.h" +#include "glk/archetype/string.h" + +namespace Glk { +namespace Archetype { + +typedef XArrayType HeapType; +typedef void *Element; + +extern HeapType H; + +// Public methods +extern void heap_sort_init(); +extern bool pop_heap(Element &e); +extern void drop_on_heap(Element e); +extern void drop_str_on_heap(const String &s); +extern void reinit_heap(); + + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/id_table.cpp b/engines/glk/archetype/id_table.cpp new file mode 100644 index 0000000000..a611503b71 --- /dev/null +++ b/engines/glk/archetype/id_table.cpp @@ -0,0 +1,73 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/id_table.h" +#include "glk/archetype/array.h" + +namespace Glk { +namespace Archetype { + +ClassifyType DefaultClassification; + +// Static variables +IdRecPtr hash[BUCKETS]; +XArrayType h_index; + +int add_ident(const String &id_str) { + int hasher; + IdRecPtr p, new_rec; + + hasher = (int)(toupper(id_str[1])) - 65; // A..Z => 65..90 => 0..25 + if (hasher < 0 || hasher > 25) + hasher = 26; + + p = hash[hasher]; + while (p->next && *p->next->id_name < id_str) + p = p->next; + + if (p->next == nullptr || *p->next->id_name > id_str) { + new_rec = new IdRecType(); + append_to_xarray(h_index, new_rec); + + new_rec->id_kind = DefaultClassification; + new_rec->id_index = h_index.size() - 1; + new_rec->id_integer = new_rec->id_index; + new_rec->id_name = NewConstStr(id_str); + new_rec->next = p->next; + + p->next = new_rec; + return h_index.size() - 1; + } else { + // found existing identifier + return p->next->id_index; + } +} + +bool index_ident(int index, IdRecPtr &id_ptr) { + void *p; + bool result = index_xarray(h_index, index, p); + id_ptr = (IdRecPtr)p; + return result; +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/id_table.h b/engines/glk/archetype/id_table.h new file mode 100644 index 0000000000..2aff6d6ce9 --- /dev/null +++ b/engines/glk/archetype/id_table.h @@ -0,0 +1,77 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_ID_TABLE +#define ARCHETYPE_ID_TABLE + +#include "glk/archetype/misc.h" +#include "glk/archetype/string.h" + +/** + * Contains the necessary data structures andfunctions for adding to andreferring + * to the ID table(a very busy little structure). + * + * The ID table is a 27-element hash table with one bucket for each letter; identifiers + * are hashed according to their first letter. The last bucket is for identifiers beginning with + * an underscore. The ID table is cross_indexed by an xarray containing pointers to id_records. + * The ID table is complex enough that it should probably not be accessed directly but rather + * only through its procedures.In this way the data type, its primary instantiation, andassociated + * code comprise one stand-alone module which must be "used" by any module wishing to modify or + * query the table. + */ +namespace Glk { +namespace Archetype { + +const int BUCKETS = 27; // 1 per letter of alphabet, plus the underscore + +struct IdRecType { + ClassifyType id_kind; + int id_integer; // What integer the ID gets written as + int id_index; // The ID's index in the ID table + StringPtr id_name; + IdRecType *next; +}; +typedef IdRecType *IdRecPtr; + +// Public methods +/** + * Adds the given identifier to the ID table, andreturns its index. There are no duplications; + * if the identifier already exists, its existing index is returned. + * @param id_str String containing identifier name + * @returns The index of the identifier + */ +extern int add_ident(const String &id_str); + +/** + * A quick little wrapper to the index_xarray function. + * @param index Number of the identifier + * @param id_ptr Out pointer to the id_record for that identifier + * @returns True if the requested identifier exists in the table + */ +extern bool index_ident(int index, IdRecPtr &id_ptr); + +extern ClassifyType DefaultClassification; + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/interpreter.cpp b/engines/glk/archetype/interpreter.cpp new file mode 100644 index 0000000000..108b948605 --- /dev/null +++ b/engines/glk/archetype/interpreter.cpp @@ -0,0 +1,478 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/interpreter.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/misc.h" +#include "glk/archetype/saveload.h" +#include "glk/archetype/timestamp.h" +#include "glk/archetype/wrap.h" + +namespace Glk { +namespace Archetype { + +int MainObject; + +void interpreter_init() { + MainObject = 0; +} + +StringPtr MakeNewDynStr(const String &s) { + return NewDynStr(s); +} + +int find_message(const String &message) { + void *p; + + for (uint i = 0; i < g_vm->Vocabulary.size(); ++i) { + if (!index_xarray(g_vm->Vocabulary, i, p)) + g_vm->writeln("Internal error - cannot index element %d of Vocabulary", i); + else if (message == *((StringPtr)p)) + return i; + } + + return -1; +} + +bool convert_to(AclType target_type, ResultType &the_scalar) { + int code; + char dir_from = '\0'; + int the_number = -1; + String s1; + void *p; + bool boolval = false; + + if (target_type == the_scalar._kind) + return true; + + switch (target_type) { + case QUOTE_LIT: + case TEXT_LIT: + case IDENT: + case RESERVED: + return false; + default: + break; + } + + switch (the_scalar._kind) { + case NUMERIC: + dir_from = 'N'; + the_number = the_scalar._numeric.acl_int; + break; + + case MESSAGE: + dir_from = 'S'; + if (index_xarray(g_vm->Vocabulary, the_scalar._msgTextQuote.index, p)) + s1 = *(StringPtr)p; + break; + + case TEXT_LIT: + case QUOTE_LIT: + dir_from = 'S'; + if (index_xarray(g_vm->Literals, the_scalar._msgTextQuote.index, p)) + s1 = *(StringPtr)p; + break; + + case STR_PTR: + // string memory will be disposed ONLY if successful convert + dir_from = 'S'; + s1 = *the_scalar._str.acl_str; + break; + + case IDENT: + //with the_scalar do begin + dir_from = 'S'; + + switch (the_scalar._ident.ident_kind) { + case ENUMERATE_ID: + dir_from = 'N'; + the_number = the_scalar._ident.ident_int; + break; + + case OBJECT_ID: + if (the_scalar._ident.ident_int == 0) + s1 = "system"; + else if (index_xarray(g_vm->Object_ID_List, the_scalar._ident.ident_int, p)) { + if (p == nullptr) + s1 = "null"; + else + s1 = *(StringPtr)p; + } else { + return false; + } + break; + + case TYPE_ID: + if (the_scalar._ident.ident_int == 0) + s1 = "null"; + else if (index_xarray(g_vm->Type_ID_List, the_scalar._ident.ident_int, p)) + s1 = *(StringPtr)p; + else + return false; + break; + + case ATTRIBUTE_ID: + if (index_xarray(g_vm->Attribute_ID_List, the_scalar._ident.ident_int, p)) + s1 = *((StringPtr)p); + else + return false; + break; + + default: + break; + } + break; + + case RESERVED: + if (the_scalar._reserved.keyword == RW_TRUE || the_scalar._reserved.keyword == RW_FALSE) { + dir_from = 'B'; + boolval = (the_scalar._reserved.keyword == RW_TRUE); + } else { + return false; + } + break; + + default: + break; + } + + if (target_type == STR_PTR || target_type == MESSAGE) { + if (the_scalar._kind == STR_PTR) + FreeDynStr(the_scalar._str.acl_str); // we know this will succeed + + the_scalar._kind = target_type; + + switch (dir_from) { + case 'N': + s1 = String::format("%d", the_number); + break; + case 'B': + s1 = boolval ? "TRUE" : "false"; + break; + default: + break; + } + + if (target_type == MESSAGE) + the_scalar._msgTextQuote.index = find_message(s1); + else + the_scalar._str.acl_str = NewDynStr(s1); + + return true; + } else { + // numeric conversions + switch (dir_from) { + case 'N': + the_scalar._kind = NUMERIC; + the_scalar._numeric.acl_int = the_number; + return true; + + case 'B': + the_scalar._kind = NUMERIC; + the_scalar._numeric.acl_int = boolval ? 1 : 0; + break; + + case 'S': + s1.trim(); + the_number = s1.val(&code); + + if (code != 0) { + return false; + } else { + // successful + if (the_scalar._kind == STR_PTR) + FreeDynStr(the_scalar._str.acl_str); // memory no longer needed + + the_scalar._kind = NUMERIC; + the_scalar._numeric.acl_int = the_number; + } + + return true; + + default: + break; + } + } + + return false; +} + +void undefine(ResultType &result) { + result._kind = RESERVED; + result._reserved.keyword = RW_UNDEFINED; +} + +void cleanup(ResultType &result) { + if (result._kind == STR_PTR) + FreeDynStr(result._str.acl_str); + result._kind = RESERVED; + result._reserved.keyword = RW_UNDEFINED; +} + +void copy_result(ResultType &r1, const ResultType &r2) { + cleanup(r1); + r1 = r2; + if (r1._kind == STR_PTR) + r1._str.acl_str = NewDynStr(*r2._str.acl_str); +} + +bool result_compare(short comparison, ResultType &r1, ResultType &r2) { + bool verdict = false; + + // Try numeric reckoning first, then string reckoning + if (convert_to(NUMERIC, r1) && convert_to(NUMERIC, r2)) { + switch (comparison) { + case OP_EQ: + case OP_NE: + verdict = r1._numeric.acl_int == r2._numeric.acl_int; + break; + case OP_LT: + verdict = r1._numeric.acl_int < r2._numeric.acl_int; + break; + case OP_LE: + verdict = r1._numeric.acl_int <= r2._numeric.acl_int; + break; + case OP_GT: + verdict = r1._numeric.acl_int > r2._numeric.acl_int; + break; + case OP_GE: + verdict = r1._numeric.acl_int >= r2._numeric.acl_int; + break; + default: + break; + } + + } else if (convert_to(STR_PTR, r1) && convert_to(STR_PTR, r2)) { + switch (comparison) { + case OP_EQ: + case OP_NE: + verdict = *r1._str.acl_str == *r2._str.acl_str; + break; + case OP_LT: + verdict = *r1._str.acl_str < *r2._str.acl_str; + break; + case OP_LE: + verdict = *r1._str.acl_str <= *r2._str.acl_str; + break; + case OP_GT: + verdict = *r1._str.acl_str > *r2._str.acl_str; + break; + case OP_GE: + verdict = *r1._str.acl_str >= *r2._str.acl_str; + break; + default: + break; + } + + } else if (r1._kind == r2._kind) { + switch (r1._kind) { + case RESERVED: + switch (comparison) { + case OP_EQ: + case OP_NE: + verdict = r1._reserved.keyword == r2._reserved.keyword; + break; + default: + break; + } + + case IDENT: + if (r1._ident.ident_kind == r2._ident.ident_kind) { + switch (comparison) { + case OP_EQ: + case OP_NE: + verdict = r1._ident.ident_int == r2._ident.ident_int; + break; + default: + break; + } + } + break; + + default: + break; + } + } + + if (comparison == OP_NE) + return !verdict; + else + return verdict; +} + +bool assignment(ResultType &target, ResultType &value) { + ExprPtr e; + + if (target._kind != ATTR_PTR) { + wraperr("Warning: attempted assignment to a non-attribute"); + return false; + } else { + e = (ExprPtr)target._attr.acl_attr->data; + + // If the current expression starts with an operator, we know it isn't a flat result + // and must therefore be disposed of before proceeding. Otherwise simply clean up + // the previous expression node + if (e->_kind != OPER) { + cleanup(*e); + } else { + dispose_expr(e); + e = (ExprPtr)malloc(sizeof(ExprNode)); + undefine(*e); + } + } + + copy_result(*e, value); + target._attr.acl_attr->data = e; + + return true; +} + +void write_result(ResultType &result) { + ResultType r1; + + undefine(r1); + if (result._kind == STR_PTR) + wrapout(*result._str.acl_str, false); + else if (result._kind == RESERVED) + wrapout(Reserved_Wds[result._reserved.keyword], false); + else { + if (result._kind == ATTR_PTR) + copy_result(r1, *(ResultType *)result._attr.acl_attr->data); + else + copy_result(r1, result); + if (convert_to(STR_PTR, r1)) + wrapout(*r1._str.acl_str, false); + cleanup(r1); + } +} + +void display_result(ResultType &result) { + String enclose; + + switch (result._kind) { + case STR_PTR: + case TEXT_LIT: + enclose = "\""; + break; + case QUOTE_LIT: + enclose = " "; + wrapout(">>", false); + break; + case MESSAGE: + enclose = "\'"; + default: + enclose = ' '; + } + + if (enclose != " ") + wrapout(enclose, false); + write_result(result); + if (enclose != " ") + wrapout(enclose, false); +} + +void display_expr(ExprTree the_tree) { + if (the_tree->_kind != OPER) { + display_result(*the_tree); + } else { + if (Binary[the_tree->_oper.op_name]) { + wrapout(" (", false); + display_expr(the_tree->_oper.left); + wrapout(") ", false); + } + + wrapout(Operators[the_tree->_oper.op_name], false); + wrapout(" (", false); + display_expr(the_tree->_oper.right); + wrapout(") ", false); + } +} + +bool load_game(Common::ReadStream *f_in) { + int length; + char ch = '\0'; + double fileVersion; + + // First, check the initial version string against that in the misc unit + length = strlen(VERSION_STUB); + for (int i = 0; i < length; ++i) { + ch = (char)f_in->readByte(); + if (ch != VERSION_STUB[i]) { + g_vm->writeln("This file is not an Archetype file."); + return false; + } + } + + // Bleed off string version information + while (!f_in->eos() && ch != 26) + ch = f_in->readByte(); + + // Check encoded version + // TODO: Figure out real format + fileVersion = 0; + (void)f_in->readUint32LE(); + + if (fileVersion > VERSION_NUM) { + g_vm->writeln("This version of PERFORM is %.1f; file version is %.1f", + VERSION_NUM, fileVersion); + g_vm->writeln("Cannot PERFORM this file."); + return false; + } + + // Get encryption information + Encryption = (EncryptionType)f_in->readUint16LE(); + + // Read the timestamp. It is used to verify saved game states, and also to prime the encryption + GTimeStamp = f_in->readUint32LE(); + + // Initialize the encrypter. This is done by using the global time stamp as a starting point + // and using the Encryption variable to decide the method. Be careful here; the PURPLE + // or Dynamic encryption works differently in that we have to set Encryption to UNPURPLE + // (since we're decoding) and then back to PURPLE again in case they save any game states. + // See load_game_state in the GAMESTAT unit for similar machinations + if (Encryption == PURPLE) + Encryption = UNPURPLE; + cryptinit(Encryption, GTimeStamp); + + // Where's the main object? + MainObject = f_in->readSint32LE(); + + load_obj_list(f_in, g_vm->Object_List); + load_obj_list(f_in, g_vm->Type_List); + + load_text_list(f_in, g_vm->Literals); + load_text_list(f_in, g_vm->Vocabulary); + + if (Encryption == DEBUGGING_ON) { + g_vm->writeln("Loading debugging information"); + load_id_info(f_in); + } + + if (Encryption == UNPURPLE) + Encryption = PURPLE; + + return true; +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/interpreter.h b/engines/glk/archetype/interpreter.h new file mode 100644 index 0000000000..2ee357aad5 --- /dev/null +++ b/engines/glk/archetype/interpreter.h @@ -0,0 +1,130 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_INTERPRETER +#define ARCHETYPE_INTERPRETER + +#include "glk/archetype/expression.h" +#include "common/stream.h" + +namespace Glk { +namespace Archetype { + +enum DesiredType { LVALUE, RVALUE, NAME }; + +typedef ExprNode ResultType; + +struct ContextType { + int sender, self, each, message; +}; + +extern int MainObject; + +extern void interpreter_init(); + +/** + * A short wrapper to NewDynStr which basically uses the stack as temporary string storage. + * If you want to use a string constructor expression as an argument, call this function, + * since it does not take strings by reference but by value. Expensive on the stack but + * only briefly; it saves cluttering eval_expr + */ +extern StringPtr MakeNewDynStr(const String &s); + +/** + * Given a string message, returns its number in the Vocabulary list, or -1 if it was not found. + * At present, it simply uses a very inefficient O(N) lookup. If speed begins to become a + * consideration, this can be changed. + * @param message message to find number of + * @returns the number of the message in the Vocabulary list. + */ +extern int find_message(const String &message); + +/** + * Converts a scalar expression node to a target type. Deals primarily with numeric -> string + * or string -> numeric conversions in their many incarnations. + * @param target_type type to convert to + * @param the_scalar scalar to convert + */ +extern bool convert_to(AclType target_type, ResultType &the_scalar); + +/** + * Used to initialize previously unused result records. Does not expect that there might be + * a string pointer lurking within. + */ +extern void undefine(ResultType &result); + +/** + * To be used on temporary result variables after their usefulness is finished. Like 'undefine' above, + * except that it is used only for results that have actually been used - in other words, results with + * their "kind" field set properly. + */ +extern void cleanup(ResultType &result); + +/** + * Does an rvalue-like copy from r2 to r1 + */ +extern void copy_result(ResultType &r1, const ResultType &r2); + +/** + * Compares two result nodes according to the given operator. + * @returns true if they can; false if they cannot + */ +extern bool result_compare(short comparison, ResultType &r1, ResultType &r2); + +/** + * Given the result of an LVALUE evaluation and a result to assign to the attribute, + * performs the assignment if possible. + * @param target hopefully points to attribute to receive assignment + * @param value Result to assign + * @returns Returns true if the assignment was successful; false otherwise + */ +extern bool assignment(ResultType &target, ResultType &value); + +/** + * Writes the given result to screen w/o terminating it with a newline + */ +extern void write_result(ResultType &result); + +/** + * For purposes of debugging. + * Strings are enclosed in double quotes. + * Messages are enclosed in single quotes. + * Quote literals are preceded by >> + */ +extern void display_result(ResultType &result); + +/** + * Given an expression tree, displays the thing on screen. + */ +extern void display_expr(ExprTree the_tree); + +/** + * Loads a game into memory from a binary input file. Checks for errors + * in the header or incompatible versions. + * @param f_in Input file + */ +extern bool load_game(Common::ReadStream *f_in); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/keywords.cpp b/engines/glk/archetype/keywords.cpp new file mode 100644 index 0000000000..c794750699 --- /dev/null +++ b/engines/glk/archetype/keywords.cpp @@ -0,0 +1,152 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/keywords.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/misc.h" + +namespace Glk { +namespace Archetype { + +LookupType Reserved_Wds = { + nullptr, + "ABSENT", + "FALSE", + "TRUE", + "UNDEFINED", + "based", + "break", + "case", + "create", + "default", + "destroy", + "do", + "each", + "else", + "end", + "for", + "if", + "include", + "key", + "keyword", + "message", + "methods", + "named", + "null", + "of", + "on", + "read", + "self", + "sender", + "stop", + "then", + "type", + "while", + "write", + "writes" +}; + +LookupType Operators = { + nullptr, + "&", + "&:=", + "*", + "*:=", + "+", + "+:=", + "-", + "-->", + "-:=", + "->", + ".", + "/", + "/:=", + ":=", + "<", + "<=", + "=", + ">", + ">=", + "?", + "^", + "and", + "chs", + "leftfrom", + "length", + "not", + "numeric", + "or", + "rightfrom", + "string", + "within", + "~=", + nullptr, + nullptr +}; + +void load_text_list(Common::ReadStream *fIn, XArrayType &the_list) { + int i, n; + String s; + + new_xarray(the_list); + n = fIn->readUint16LE(); + for (i = 0; i < n; ++i) { + load_string(fIn, s); + append_to_xarray(the_list, NewConstStr(s)); + } +} + +void dump_text_list(Common::WriteStream *fOut, XArrayType &the_list) { + void *p; + + fOut->writeUint16LE(the_list.size()); + for (uint i = 0; i < the_list.size(); ++i) { + if (index_xarray(the_list, i, p)) + dump_string(fOut, *(StringPtr)(p)); + } +} + +void dispose_text_list(XArrayType &the_list) { + void *p; + + for (uint i = 0; i < the_list.size(); ++i) { + if (index_xarray(the_list, i, p)) + free((StringPtr)p); + } + + dispose_xarray(the_list); +} + +void load_id_info(Common::ReadStream *bfile) { + load_text_list(bfile, g_vm->Type_ID_List); + load_text_list(bfile, g_vm->Object_ID_List); + load_text_list(bfile, g_vm->Attribute_ID_List); +} + +void dump_id_info(Common::WriteStream *bfile) { + dump_text_list(bfile, g_vm->Type_ID_List); + dump_text_list(bfile, g_vm->Object_ID_List); + dump_text_list(bfile, g_vm->Attribute_ID_List); +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/keywords.h b/engines/glk/archetype/keywords.h new file mode 100644 index 0000000000..f36c66e20b --- /dev/null +++ b/engines/glk/archetype/keywords.h @@ -0,0 +1,149 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_KEYWORDS +#define ARCHETYPE_KEYWORDS + +#include "common/stream.h" +#include "glk/archetype/array.h" +#include "glk/archetype/string.h" + +namespace Glk { +namespace Archetype { + +// max length of any reserved word or operator +const int SHORT_STR_LEN = 9; + +enum { + NUM_RWORDS = 34, + NUM_OPERS = 32, + MAX_ELEMENTS = 34 // max(NUM_RWORDS, NUM_OPERS) +}; + +enum ReservedWordId { + RW_ABSENT = 1, + RW_FALSE = 2, + RW_TRUE = 3, + RW_UNDEFINED = 4, + RW_BASED = 5, + RW_BREAK = 6, + RW_CASE = 7, + RW_CREATE = 8, + RW_DEFAULT = 9, + RW_DESTROY = 10, + RW_DO = 11, + RW_EACH = 12, + RW_ELSE = 13, + RW_END = 14, + RW_FOR = 15, + RW_IF = 16, + RW_INCLUDE = 17, + RW_KEY = 18, + RW_KEYWORD = 19, + RW_MESSAGE = 20, + RW_METHODS = 21, + RW_NAMED = 22, + RW_NULL = 23, + RW_OF = 24, + RW_ON = 25, + RW_READ = 26, + RW_SELF = 27, + RW_SENDER = 28, + RW_STOP = 29, + RW_THEN = 30, + RW_TYPE = 31, + RW_WHILE = 32, + RW_WRITE = 33, + RW_WRITES = 34 +}; + +enum OperatorId { + OP_CONCAT = 1, + OP_C_CONCAT = 2, + OP_MULTIPLY = 3, + OP_C_MULTIPLY = 4, + OP_PLUS = 5, + OP_C_PLUS = 6, + OP_MINUS = 7, + OP_PASS = 8, + OP_C_MINUS = 9, + OP_SEND = 10, + OP_DOT = 11, + OP_DIVIDE = 12, + OP_C_DIVIDE = 13, + OP_ASSIGN = 14, + OP_LT = 15, + OP_LE = 16, + OP_EQ = 17, + OP_GT = 18, + OP_GE = 19, + OP_RANDOM = 20, + OP_POWER = 21, + OP_AND = 22, + OP_CHS = 23, + OP_LEFTFROM = 24, + OP_LENGTH = 25, + OP_NOT = 26, + OP_NUMERIC = 27, + OP_OR = 28, + OP_RIGHTFROM = 29, + OP_STRING = 30, + OP_WITHIN = 31, + OP_NE = 32 +}; + +//typedef char ShortStrType[SHORT_STR_LEN]; +typedef const char *const LookupType[MAX_ELEMENTS + 1]; + +extern LookupType Reserved_Wds, Operators; + +// Methods + +/** + * Loads an xarray of test literals into memory from the given file + */ +extern void load_text_list(Common::ReadStream *fIn, XArrayType &the_list); + +/** + * Dumps the given xarray of text literals to the given file + */ +extern void dump_text_list(Common::WriteStream *fOut, XArrayType &the_list); + +/** + * Disposes with all memory associated with the given xarray of text literals + */ +extern void dispose_text_list(XArrayType &the_list); + +/** + * Loads all ID information from the given binary file + */ +extern void load_id_info(Common::ReadStream *bfile); + +/** + * Dumps all ID information to the given binary file + */ +extern void dump_id_info(Common::WriteStream *bfile); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/linked_list.cpp b/engines/glk/archetype/linked_list.cpp new file mode 100644 index 0000000000..90cca17981 --- /dev/null +++ b/engines/glk/archetype/linked_list.cpp @@ -0,0 +1,90 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/linked_list.h" +#include "glk/archetype/misc.h" + +namespace Glk { +namespace Archetype { + +void new_list(ListType &the_list) { + the_list = new NodeType(); +} + +void dispose_list(ListType &the_list) { + NodePtr theNode, axe; + for (theNode = the_list->next; theNode != the_list; ) { + axe = theNode; + theNode = theNode->next; + add_bytes(-(int)sizeof(*axe)); + free(axe); + } + +} + +bool iterate_list(ListType &the_list, NodePtr index) { + if (index == nullptr) + index = the_list->next; + else + index = index->next; + + return index != the_list; +} + +void append_to_list(ListType &the_list, NodePtr the_node) { + the_list->data = the_node->data; + the_list->key = the_node->key; + the_node->next = the_list->next; + the_list->next = the_node; + + the_list = the_node; +} + +NodePtr index_list(ListType &the_list, int number) { + int i = 0; + NodePtr p = the_list->next; + + while (i < number && p != the_list) { + p = p->next; + ++i; + } + + return (p == the_list) ? nullptr : p; +} + +void insert_item(ListType &the_list, NodePtr the_item) { + NodePtr p; + for (p = the_list; p->next != the_list && p->next->key > the_item->key; p = p->next) {} + + the_item->next = p->next; + p->next = the_item; +} + +NodePtr find_item(ListType &the_list, int the_key) { + NodePtr p; + for (p = the_list->next; p != the_list && the_key < p->key; p = p->next) {} + + return (p == the_list || the_key != p->key) ? nullptr : p; +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/linked_list.h b/engines/glk/archetype/linked_list.h new file mode 100644 index 0000000000..372de365b8 --- /dev/null +++ b/engines/glk/archetype/linked_list.h @@ -0,0 +1,80 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_LINKED_LIST +#define ARCHETYPE_LINKED_LIST + +#include "common/list.h" + +namespace Glk { +namespace Archetype { + +struct NodeType { + void *data; + int key; + NodeType *next; +}; +typedef NodeType *NodePtr; + +typedef NodePtr ListType; + +/** + * Allocates a header node and points it to itself + */ +extern void new_list(ListType &the_list); + +/** + * Throws away all the memory that makes up an entire list structure. Is a "shallow dispose"; + * i.e. only disposes of the structure, not the data. + */ +extern void dispose_list(ListType &the_list); + +/** + * Iterates through the given list + */ +extern bool iterate_list(ListType &the_list, NodePtr index); + +/** + * Appends a new item to the list + */ +extern void append_to_list(ListType &the_list, NodePtr the_node); + +/** + * Permits a linked list to be indexed like an array in O(N) time. + */ +extern NodePtr index_list(ListType &the_list, int number); + +/** + * Ordered insert; average time O(N/2). Inserts in descending order + */ +extern void insert_item(ListType &the_list, NodePtr the_item); + +/** + * Given a list and a key, finds the first item in the list corresponding to that key. + * Expects that the elements have been sorted in descending order + */ +extern NodePtr find_item(ListType &the_list, int the_key); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/misc.cpp b/engines/glk/archetype/misc.cpp new file mode 100644 index 0000000000..34c067c2b0 --- /dev/null +++ b/engines/glk/archetype/misc.cpp @@ -0,0 +1,197 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/misc.h" +#include "glk/archetype/archetype.h" +#include "glk/quetzal.h" + +namespace Glk { +namespace Archetype { + +const char *const VERSION_STUB = "Archetype version "; +const char *const VERSION = "Archetype version 1.02"; +const double VERSION_NUM = 1.01; + +size_t Bytes; +int Debug; +bool KeepLooking; +bool AllErrors; + +void *Prior, *NextExit; + +void misc_init() { + //NextExit = ExitProc; + //ExitProc = @exit_prog; + //HeapError = @HeapFunc; + //Mark(Prior) + Bytes = 0; + Debug = 0; + KeepLooking = true; + AllErrors = false; +} + +/*----------------------------------------------------------------------*/ + +bool progfile::open(const String &name) { + filename = name; + + if (!_file.open(name)) { + return false; + + } else { + file_line = 0; + line_buffer = ""; + line_pos = 0; + newlines = false; + consumed = true; + last_ch = NULL_CH; + + return true; + } +} + +void progfile::close() { + _file.close(); +} + +bool progfile::readChar(char &ch) { + if (last_ch != NULL_CH) { + ch = last_ch; + last_ch = NULL_CH; + } else { + ++line_pos; + while (line_pos >= (int)line_buffer.size()) { + if (_file.eos()) { + ch = NULL_CH; + return false; + } + + line_buffer = QuetzalReader::readString(&_file); + line_buffer += NEWLINE_CH; + ++file_line; + line_pos = 0; + } + + ch = line_buffer[line_pos]; + } + + return true; +} + +void progfile::unreadChar(char ch) { + last_ch = ch; +} + +void progfile::sourcePos() { + /* With the /A switch specified, multiple source_pos messages can be called, + * so long as there is no fatal syntax error.Otherwise, the first error + * of any kind, regardless of severity, is the only error printed.This is + * done as a courtesy to those of us without scrolling DOS windows + */ + if (KeepLooking) { + if (!AllErrors) + KeepLooking = false; + + g_vm->writeln("Error in %s at line %d", filename.c_str(), file_line); + g_vm->writeln(line_buffer); + + String s; + for (int i = 0; i < line_pos; ++i) + s += ' '; + s += '^'; + g_vm->writeln(s); + } +} + +/*----------------------------------------------------------------------*/ + +void add_bytes(int delta) { + Bytes += delta; + + if ((Debug & DEBUG_BYTES) != 0) { + if (delta >= 0) + g_vm->write("Allocated "); + else + g_vm->write("Deallocated "); + + g_vm->writeln("%.3d bytes. Current consumed memory: %.6d", ABS(delta), Bytes); + } +} + +String formatFilename(const String &name, const String &ext, bool replace) { + String s; + int period = 0; + bool noExt; + + // Check for a period for an extension + period = name.lastIndexOf('.'); + noExt = period == -1; + + if (replace || noExt) { + return name + "." + ext; + } else { + return String(name.c_str(), name.c_str() + period + 1) + ext; + } +} + +void load_string(Common::ReadStream *fIn, String &the_string) { + char buffer[257]; + size_t strSize = fIn->readByte(); + fIn->read(buffer, strSize); + buffer[strSize] = '\0'; + + the_string = String(buffer); + cryptstr(the_string); +} + +void dump_string(Common::WriteStream *fOut, const String &the_string) { + assert(the_string.size() < 256); + fOut->writeByte(the_string.size()); + + if (Encryption == NONE) { + fOut->write(the_string.c_str(), the_string.size()); + + } else { + String tmp = the_string; + cryptstr(tmp); + fOut->write(tmp.c_str(), tmp.size()); + } +} + +StringPtr NewConstStr(const String &s) { + return new String(s); +} + +void FreeConstStr(StringPtr &sp) { + delete sp; +} + +StringPtr NewDynStr(const String &s) { + return new String(s); +} + +void FreeDynStr(StringPtr &sp) { + delete sp; +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/misc.h b/engines/glk/archetype/misc.h new file mode 100644 index 0000000000..0799077a85 --- /dev/null +++ b/engines/glk/archetype/misc.h @@ -0,0 +1,184 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_MISC +#define ARCHETYPE_MISC + +#include "common/file.h" +#include "glk/archetype/crypt.h" +#include "glk/archetype/string.h" + +namespace Glk { +namespace Archetype { + +#define MAX_STRING 255 +#define NULL_CH '\0' +#define NEWLINE_CH '\r' + +enum { + DEBUG_BYTES = 0x01, + DEBUG_MSGS = 0x02, + DEBUG_EXPR = 0x04, + DEBUG_STMT = 0x08 +}; + +enum AclType { + RESERVED, IDENT, MESSAGE, OPER, TEXT_LIT, QUOTE_LIT, NUMERIC, PUNCTUATION, + STR_PTR, ATTR_PTR, BAD_TOKEN, NEWLINE +}; + +/** + * Source program file/accounting structure.With such a file, it is important to keep + * not only the file pointer, but also fields to keep track of position in the source file + * andthe compiler state, or the context of the tokenizer + */ +class progfile { +private: + Common::File _file; // The physical file +public: + String filename; // to do with error tracking + String line_buffer; + int file_line; + int line_pos; + + bool newlines; // having to do with the tokenizer context + char last_ch; + bool consumed; + AclType ttype; + int tnum; +public: + /** + * Constructor + */ + progfile() : file_line(0), line_pos(0), newlines(false), last_ch(NULL_CH), + consumed(false), ttype(RESERVED), tnum(0) {} + + /** + * Opens an Archetype program source file. + * @param name Filename + */ + bool open(const String &name); + + /** + * Closes an Archetype program source code file. + */ + void close(); + + /** + * Reads a single character from the given progfile, performing all appropriate housekeeping. + * + * It appends an internal newline to the end of every line taken from the file; it is up to + * the tokenizer as to whether to consider it white space or a token. + * @param c The output character + * @returns True if the character was safely read from the file + */ + bool readChar(char &ch); + + /** + * Has the effect of putting a character back on the data stream. + * Closely cooperates with read_char above. + * @param ch Character to un-read + */ + void unreadChar(char ch); + + /** + * Writes out the current position in the source file nicely for error messages + * and so forth.It will, however, only write this out once per execution of the program. + * This is to prevent messages scrolling uncontrollably off the screen. + */ + void sourcePos(); +}; + +enum ClassifyType { TYPE_ID, OBJECT_ID, ATTRIBUTE_ID, ENUMERATE_ID, UNDEFINED_ID }; + +extern const char *const VERSION; +extern const char *const VERSION_STUB; +extern const double VERSION_NUM; +extern size_t Bytes; // Bytes consumed by allocated memory +extern int Debug; +extern bool KeepLooking; +extern bool AllErrors; + +/** + * Performs initialization of fields local to the file + */ +extern void misc_init(); + +/** + * Provides a method of keeping track of the size, in allocation, of the used part of the heap. + * @param delta if positive, the number allocated; if negative, the number deallocated. + */ +extern void add_bytes(int delta); + +/** + * Given a name andextension, tacks on the given extension if none given. + * of are ".", or else tacks those four characters on. + * @param name Filename + * @param ext Extension + * @param replace Whether to replace existing extension + */ +extern String formatFilename(const String &name, const String &ext, bool replace); + +/** + * Given an input stream, reads in a Pascal style string with the first byte being the length. + * Secondarily, it also decrypts the string + * @param fIn Input file + * @param the_string Output string + */ +extern void load_string(Common::ReadStream *fIn, String &the_string); + +/** + * Given an untyped file variable anda string variable, writes to the file first the length + * of the string andthen the string itself. + * @param fOut Output file + * @param the_string The string to output + */ +extern void dump_string(Common::WriteStream *fOut, const String &the_string); + +/** + * Used for allocating string space that is not expected to be disposed of + * until the end of the program andis never expected to change. + * Only the very minimum space necessary to store the string is used; + * thereby using minimal space andincurring no fragmentation + */ +extern StringPtr NewConstStr(const String &s); + +/** + * Frees a const string + */ +extern void FreeConstStr(StringPtr &sp); + +/** + * Dynamic strings were originally strings where we need speed and yet we need to allocate + * only the string space necessary. These days, we can simply just allocate a new string + */ +extern StringPtr NewDynStr(const String &s); + +/** + * Frees a dynamic string + */ +extern void FreeDynStr(StringPtr &sp); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/parser.cpp b/engines/glk/archetype/parser.cpp new file mode 100644 index 0000000000..0063e2818c --- /dev/null +++ b/engines/glk/archetype/parser.cpp @@ -0,0 +1,291 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/parser.h" +#include "glk/archetype/archetype.h" +#include "common/algorithm.h" + +namespace Glk { +namespace Archetype { + +const int WORD_LEN = 32; + +struct ParseType { + StringPtr word; + int object; +}; +typedef ParseType *ParsePtr; + +/** + * Is a word character + */ +static bool isWordChar(char c) { + return Common::isAlnum(c) || c == '-' || c == '\"'; +} + +/** + * Puts into lowercase the given character. + */ +static char locase(char ch) { + return tolower(ch); +} + +void normalize_string(const String &first, String &second) { + int i, j, lfirst; + bool in_word, done; + + i = j = 0; + in_word = false; + done = false; + lfirst = first.size() - 1; + second = " "; + + do { + if (i > lfirst || !isWordChar(first[i])) { + if (in_word) { + j = 0; + in_word = false; + second = second + " "; + } + else { + ++i; + } + + if (i > lfirst) + done = true; + + } else if (in_word) { + if (j < g_vm->Abbreviate) { + second = second + locase(first[i]); + ++j; + } + + ++i; + } else { + in_word = true; + } + } while (!done); +} + +void add_parse_word(TargetListType which_list, String &the_word, int the_object) { + ListType the_list; + String tempstr; + NodePtr np; + ParsePtr pp; + int bar; + + if (which_list == PARSER_VERBLIST) + the_list = g_vm->verb_names; + else + the_list = g_vm->object_names; + + the_word += '|'; + + do { + bar = the_word.indexOf('|'); + if (bar != -1) { + pp = (ParsePtr)malloc(sizeof(ParseType)); + tempstr = the_word.left(bar - 1).left(g_vm->Abbreviate); + + pp->word = NewConstStr(tempstr); + pp->word->toLowercase(); + the_word = String(the_word.c_str() + bar + 1); + pp->object = the_object; + + np = (NodePtr)malloc(sizeof(NodeType)); + np->key = pp->word->size(); + np->data = pp; + + insert_item(the_list, np); + } + } while (bar != 0); +} + +static void parse_sentence_substitute(int start, ParsePtr pp, int &next_starting) { + int sublen = pp->word->size(); + + if (sublen > g_vm->Abbreviate) + sublen = g_vm->Abbreviate; + + g_vm->Command = g_vm->Command.left(start) + + String::format("%%%c%c^", pp->object >> 8, pp->object & 0xff) + + String(g_vm->Command.c_str() + start + sublen + 1); + + next_starting = next_starting - sublen + 4; +} + +static bool parse_sentence_next_chunk(int &start_at, String &the_chunk, int &next_starting) { + int i; + + if (next_starting == 0) { + return false; + } else { + do { + start_at = next_starting; + the_chunk = g_vm->Command.mid(start_at); + + i = the_chunk.indexOf('%'); + if (i == -1) { + next_starting = 0; + } else { + the_chunk = the_chunk.left(i - 1); + next_starting = next_starting + i + 3; + } + + the_chunk.trim(); + } while (!(next_starting == 0 || !the_chunk.empty())); + + return !the_chunk.empty(); + } +} + +void parse_sentence() { + const int nfillers = 3; + const char *const FILTERS[nfillers] = { " a ", " an ", " the " }; + int next_starting; + String s; + NodePtr np, near_match, far_match; + ParsePtr pp; + int i, lchunk; + + // Rip out those fillers + s = g_vm->Command; + for (i = 0; i < nfillers; ++i) { + int filterIndex; + while ((filterIndex = g_vm->Command.indexOf(FILTERS[i])) != -1) + g_vm->Command.del(filterIndex, strlen(FILTERS[i]) - 1); + } + + // Restore the original string if filler removal destroyed it completely + if (g_vm->Command == " ") + g_vm->Command = s; + + // Two passes: one matching all verbs and prepositions from the verb list, longest strings first + + np = nullptr; + while (iterate_list(g_vm->verb_names, np)) { + pp = (ParsePtr)np->data; + s = String::format(" %s ", pp->word->left(g_vm->Abbreviate).c_str()); + + i = g_vm->Command.indexOf(s); + if (i != -1) + parse_sentence_substitute(i, pp, next_starting); + } + + // Second pass: carefully search for the remaining string chunks; search only the part + // of the noun list of the same length; give preference to those in the Proximate list + next_starting = 1; + + while (parse_sentence_next_chunk(i, s, next_starting)) { + lchunk = s.size() - 1; + + np = find_item(g_vm->object_names, lchunk); + if (np != nullptr) { + near_match = nullptr; + far_match = nullptr; + + do { + pp = (ParsePtr)np->data; + if (pp->word->left(g_vm->Abbreviate) == s) { + if (find_item(g_vm->Proximate, pp->object) != nullptr) + near_match = np; + else + far_match = np; + } + } while (!(iterate_list(g_vm->object_names, np) && (lchunk == (int)((ParsePtr)np->data)->word->size()))); + + if (near_match != nullptr) + parse_sentence_substitute(i, (ParsePtr)near_match->data, next_starting); + else if (far_match != nullptr) + parse_sentence_substitute(i, (ParsePtr)far_match->data, next_starting); + } + } + + g_vm->Command.trim(); +} + +bool pop_object(int &intback, String &strback) { + int i; + + if (g_vm->Command.empty()) { + return false; + } else { + if (g_vm->Command.firstChar() == '%') { + // parsed object + intback = ((int)g_vm->Command[1] << 8) | ((int)g_vm->Command[2]); + g_vm->Command.del(0, 4); + } + else { + intback = -1; + i = g_vm->Command.indexOf('%'); + if (i < 0) + i = g_vm->Command.size(); + + strback = g_vm->Command.left(i); + g_vm->Command = g_vm->Command.mid(i); + strback.trim(); + } + + g_vm->Command.trim(); + return true; + } +} + +int find_object(const String &s) { + NodePtr np; + + np = nullptr; + while (iterate_list(g_vm->object_names, np)) { + if (*((ParsePtr)np->data)->word == s) + return ((ParsePtr)np->data)->object; + } + + np = nullptr; + while (iterate_list(g_vm->verb_names, np)) { + if (*((ParsePtr)np->data)->word == s) + return ((ParsePtr)np->data)->object; + } + + return 0; +} + +void clear_parse_list(ListType &the_list) { + ParsePtr pp; + NodePtr np = nullptr; + + while (iterate_list(the_list, np)) { + pp = (ParsePtr)np->data; + FreeConstStr(pp->word); + free(pp); + } + + dispose_list(the_list); + new_list(the_list); +} + +void new_parse_list() { + clear_parse_list(g_vm->verb_names); + clear_parse_list(g_vm->object_names); +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/parser.h b/engines/glk/archetype/parser.h new file mode 100644 index 0000000000..c5185b0f35 --- /dev/null +++ b/engines/glk/archetype/parser.h @@ -0,0 +1,89 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_PARSER +#define ARCHETYPE_PARSER + +#include "glk/archetype/string.h" + +namespace Glk { +namespace Archetype { + +enum TargetListType { PARSER_VERBLIST, PARSER_NOUNLIST }; + +/** + * Given a string, creates a string with one and only one space between each word + * @param first the string to be normalized + * @param second the normalized string + */ +extern void normalize_string(const String &first, String &second); + +/** + * Adds another word to one of the lists to match. If the given word has vertical bars in it, + * the bars are considered delimiters and each delimited word is added to the available list + */ +extern void add_parse_word(TargetListType which_list, String &the_word, int the_object); + +/** + * Parses the previously given sentence into a string of object references. + * The verbpreps list is searched first, followed by the nounphrases list. + * It does not identify any parts of speech; it is strictly substitutional. + * + * Also removes all instances of the words "a", "an", "the". + * + * NOTES: + * When an object is matched, its name is replaced by the sequence + * . The percent will + * indicate the beginning of the encoded number; the caret indicates + * the end and also serves the purpose of keeping the trim() procedure + * from trimming off objects 9 or 13 or the like. + * + * Objects are matched as words; they must be surrounded by spaces. + * When they are replaced in the Command string, they leave the spaces + * on both sides so as not to interfere with further matching + */ +extern void parse_sentence(); + +/** + * Pops the first object number off of the parsed Command string and sends the number back. + * If Command does not begin with an object marker, sends back the unparseable string. + * @param intback will be -1 if there was no object; otherwise, the number of the object. + * @param strback will contain the (trimmed) unparseable chunk if intback is -1; unchanged otherwise + * @returns true if there was anything to be popped; false otherwise + */ +extern bool pop_object(int &intback, String &strback); + +/** + * Performs a subset of the normal parse_sentence algorithm. Given a single string, + * find the number of the first object that matches. + */ +extern int find_object(const String &s); + +/** + * Called in order to force a full deletion of the parse lists, in order that new ones may be built up + */ +extern void new_parse_list(); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/saveload.cpp b/engines/glk/archetype/saveload.cpp new file mode 100644 index 0000000000..2a965e3039 --- /dev/null +++ b/engines/glk/archetype/saveload.cpp @@ -0,0 +1,672 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/saveload.h" +#include "glk/archetype/id_table.h" +#include "glk/archetype/semantic.h" + +namespace Glk { +namespace Archetype { + +StatementKind vEndSeq, vContSeq; // to make BlockWrite happy +int Dynamic; +bool Translating; + +void saveload_init() { + vEndSeq = END_SEQ; + vContSeq = CONT_SEQ; + + Dynamic = 0; + Translating = true; +} + +// ===================== Forward Declarations ======================= + +static void walk_item_list(MissionType mission, Common::Stream *bfile, + ListType elements, ContentType content); +static void walk_expr(MissionType mission, Common::Stream *bfile, ExprTree &the_expr); +static void walk_stmt(MissionType mission, Common::Stream *bfile, StatementPtr &the_stmt); + +// ========================== Item Lists ============================ + +// Wrappers + +void load_item_list(Common::ReadStream *f_in, ListType elements, ContentType content) { + walk_item_list(LOAD, f_in, elements, content); +} + +void dump_item_list(Common::WriteStream *f_out, ListType elements, ContentType content) { + walk_item_list(DUMP, f_out, elements, content); +} + +void dispose_item_list(ListType &elements, ContentType content) { + walk_item_list(FREE, nullptr, elements, content); +} + +/** + * Used for operating on general linked lists which are homogenous, all containing the same type + * of data, signified by the "content" variable. + * @param mission action to perform while walking through + * @param bfile binary file to read or write from + * @param elements list of items + * @param content contents of each of the items + */ +void walk_item_list(MissionType mission, Common::Stream *bfile, ListType elements, ContentType content) { + StatementKind sentinel; + StatementPtr this_stmt; + ExprTree this_expr; + CasePairPtr this_case; + NodePtr np = nullptr; + bool yet_more = false; + + Common::ReadStream *readStream = dynamic_cast(bfile); + Common::WriteStream *writeStream = dynamic_cast(bfile); + + // Prelude + switch (mission) { + case LOAD: + assert(readStream); + sentinel = (StatementKind)readStream->readUint32LE(); + new_list(elements); + yet_more = sentinel == CONT_SEQ; + break; + + case DUMP: + case FREE: + np = nullptr; + yet_more = iterate_list(elements, np); + break; + + default: + break; + } + + while (yet_more) { + // Main walk + switch (mission) { + case LOAD: + assert(readStream); + np = (NodePtr)malloc(sizeof(NodeType)); + add_bytes(sizeof(NodeType)); + np->key = readStream->readSint32LE(); + break; + + case DUMP: + assert(writeStream); + writeStream->writeUint32LE(vContSeq); + writeStream->writeSint32LE(np->key); + break; + + default: + break; + } + + switch (content) { + case EXPR_LIST: + switch (mission) { + case LOAD: + walk_expr(mission, bfile, this_expr); + np->data = this_expr; + break; + case DUMP: + case FREE: + this_expr = (ExprTree)np->data; + walk_expr(mission, bfile, this_expr); + break; + default: + break; + } + break; + + case STMT_LIST: + switch (mission) { + case LOAD: + walk_stmt(mission, bfile, this_stmt); + np->data = this_stmt; + break; + case DUMP: + case FREE: + this_stmt = (StatementPtr)np->data; + walk_stmt(mission, bfile, this_stmt); + break; + default: + break; + } + break; + + case CASE_LIST: + switch (mission) { + case LOAD: + this_case = (CasePairPtr)malloc(sizeof(CasePairType)); + add_bytes(sizeof(CasePairType)); + walk_expr(mission, bfile, this_case->value); + walk_stmt(mission, bfile, this_case->action); + + np->data = this_case; + break; + + case DUMP: + case FREE: + this_case = (CasePairPtr)np->data; + walk_expr(mission, bfile, this_case->value); + walk_stmt(mission, bfile, this_case->action); + + if (mission == FREE) { + add_bytes(sizeof(CasePairType)); + free(this_case); + } + break; + + default: + break; + } + break; + + default: + break; + } + + switch (mission) { + case LOAD: + assert(readStream); + append_to_list(elements, np); + sentinel = (StatementKind)readStream->readUint32LE(); + yet_more = sentinel == CONT_SEQ; + break; + + case DUMP: + case FREE: + yet_more = iterate_list(elements, np); + break; + + default: + break; + } + } + + // Postlude + switch (mission) { + case DUMP: + writeStream->writeUint32LE(vEndSeq); + break; + case FREE: + dispose_list(elements); + elements = nullptr; + break; + default: + break; + } +} + +// ============================ Expressions =========================== + +// Wrappers +void load_expr(Common::ReadStream *f_in, ExprTree &the_expr) { + walk_expr(LOAD, f_in, the_expr); +} + +void dump_expr(Common::WriteStream *f_out, ExprTree &the_expr) { + walk_expr(DUMP, f_out, the_expr); +} + +void dispose_expr(ExprTree &the_expr) { + walk_expr(FREE, nullptr, the_expr); +} + +/** + * Separated from walk_expr so as not to consume too much stack space with its large temporary string.. + */ +static StringPtr LoadDynStr(Common::ReadStream *f_in) { + String s; + load_string(f_in, s); + return NewDynStr(s); +} + +/** + * Walks through an expression tree. + * @param mission action to take on each visited element + * @param bfile binary file to read or write from as necessary + * @param the_expr expression tree to walk + */ +static void walk_expr(MissionType mission, Common::Stream *bfile, ExprTree &the_expr) { + int temp = 0; + ClassifyType ID_kind = UNDEFINED_ID; + + Common::ReadStream *readStream = dynamic_cast(bfile); + Common::WriteStream *writeStream = dynamic_cast(bfile); + + // Prelude + switch (mission) { + case LOAD: + assert(readStream); + the_expr = (ExprTree)malloc(sizeof(ExprNode)); + add_bytes(sizeof(ExprNode)); + the_expr->_kind = (AclType)readStream->readUint32LE(); + break; + + case DUMP: + if (the_expr == nullptr) + return; + + assert(writeStream); + while (the_expr->_kind == OPER && the_expr->_oper.op_name == OP_LPAREN) + the_expr = the_expr->_oper.right; + + writeStream->writeUint32LE(the_expr->_kind); + break; + + case FREE: + if (the_expr == nullptr) + return; + break; + + default: + break; + } + + // Main walk + switch (the_expr->_kind) { + case OPER: + switch (mission) { + case LOAD: + the_expr->_oper.op_name = readStream->readSByte(); + the_expr->_oper.left = nullptr; + break; + case DUMP: + writeStream->writeSByte(the_expr->_oper.op_name); + break; + default: + break; + } + + if (Binary[the_expr->_oper.op_name]) + walk_expr(mission, bfile, the_expr->_oper.left); + walk_expr(mission, bfile, the_expr->_oper.right); + break; + + case NUMERIC: + switch (mission) { + case LOAD: + the_expr->_numeric.acl_int = readStream->readSint32LE(); + break; + case DUMP: + writeStream->writeSint32LE(the_expr->_numeric.acl_int); + break; + default: + break; + } + break; + + case MESSAGE: + case TEXT_LIT: + case QUOTE_LIT: + switch (mission) { + case LOAD: + the_expr->_msgTextQuote.index = readStream->readSint32LE(); + break; + case DUMP: + writeStream->writeSint32LE(the_expr->_msgTextQuote.index); + break; + default: + break; + } + break; + + case IDENT: + switch (mission) { + case LOAD: + the_expr->_ident.ident_kind = (ClassifyType)readStream->readUint32LE(); + the_expr->_ident.ident_int = readStream->readSint32LE(); + break; + case DUMP: + if (Translating && the_expr->_ident.ident_kind == DefaultClassification) { + // may have changed meaning + get_meaning(the_expr->_ident.ident_int, ID_kind, temp); + if (ID_kind == UNDEFINED_ID) + add_undefined(the_expr->_ident.ident_int); + } else { + the_expr->_ident.ident_kind = ID_kind; + the_expr->_ident.ident_int = temp; + } + + writeStream->writeUint32LE(the_expr->_ident.ident_kind); + writeStream->writeSint32LE(the_expr->_ident.ident_int); + break; + default: + break; + } + break; + + case RESERVED: + switch (mission) { + case LOAD: + the_expr->_reserved.keyword = readStream->readSByte(); + break; + case DUMP: + writeStream->writeSByte(the_expr->_reserved.keyword); + break; + default: + break; + } + break; + + case STR_PTR: + switch (mission) { + case LOAD: + the_expr->_str.acl_str = LoadDynStr(readStream); + break; + case DUMP: + dump_string(writeStream, *the_expr->_str.acl_str); + break; + case FREE: + FreeDynStr(the_expr->_str.acl_str); + break; + default: + break; + } + break; + + default: + break; + } + + // Postlude + switch (mission) { + case FREE: + free(the_expr); + the_expr = nullptr; + break; + default: + break; + } +} + + +// =========================== Statements ========================= + +// Wrappers + +void load_stmt(Common::ReadStream *f_in, StatementPtr &the_stmt) { + walk_stmt(LOAD, f_in, the_stmt); +} + +void dump_stmt(Common::WriteStream *f_out, StatementPtr &the_stmt) { + walk_stmt(DUMP, f_out, the_stmt); +} + +void dispose_stmt(StatementPtr &the_stmt) { + walk_stmt(FREE, nullptr, the_stmt); +} + +/** + * Handles the control involved in walking through a statement. + * @param mission action to take for each statement + * @param bfile binary file to read or write as necessary + * @param the_stmt pointer to a statement record + */ +static void walk_stmt(MissionType mission, Common::Stream *bfile, StatementPtr &the_stmt) { + NodePtr np; // for appending to lists + StatementKind sentinel; + StatementPtr this_stmt = nullptr; + ExprTree this_expr; + + Common::ReadStream *readStream = dynamic_cast(bfile); + Common::WriteStream *writeStream = dynamic_cast(bfile); + + // Prelude + switch (mission) { + case LOAD: + the_stmt = nullptr; + if (readStream->eos()) + return; + + sentinel = (StatementKind)readStream->readUint32LE(); + if (sentinel == END_SEQ) + return; + + the_stmt = (StatementPtr)malloc(sizeof(StatementType)); + add_bytes(sizeof(StatementType)); + the_stmt->_kind = sentinel; + break; + + case DUMP: + if (the_stmt == nullptr) { + writeStream->writeUint32LE(vEndSeq); + return; + } else { + writeStream->writeUint32LE(this_stmt->_kind); + } + break; + + case FREE: + if (the_stmt == nullptr) + return; + break; + + default: + break; + } + + // Main walk + assert(this_stmt); + switch (this_stmt->_kind) { + case COMPOUND: + walk_item_list(mission, bfile, this_stmt->_compound.statements, STMT_LIST); + break; + + case ST_EXPR: + walk_expr(mission, bfile, this_stmt->_expr.expression); + break; + + case ST_IF: + walk_expr(mission, bfile, this_stmt->_if.condition); + walk_stmt(mission, bfile, this_stmt->_if.then_branch); + walk_stmt(mission, bfile, this_stmt->_if.else_branch); + break; + + case ST_CASE: + walk_expr(mission, bfile, this_stmt->_case.test_expr); + walk_item_list(mission, bfile, this_stmt->_case.cases, CASE_LIST); + break; + + case ST_CREATE: + switch (mission) { + case LOAD: + this_stmt->_create.archetype = readStream->readSint32LE(); + break; + case DUMP: + writeStream->writeSint32LE(this_stmt->_create.archetype); + break; + default: + break; + } + + walk_expr(mission, bfile, this_stmt->_create.new_name); + break; + + case ST_DESTROY: + walk_expr(mission, bfile, this_stmt->_destroy.victim); + break; + + case ST_FOR: + case ST_WHILE: + walk_expr(mission, bfile, this_stmt->_loop.selection); + walk_stmt(mission, bfile, this_stmt->_loop.action); + break; + + case ST_WRITE: + case ST_WRITES: + case ST_STOP: + switch (mission) { + case LOAD: + new_list(this_stmt->_write.print_list); + sentinel = (StatementKind)readStream->readUint32LE(); + + while (sentinel != END_SEQ) { + walk_expr(mission, bfile, this_expr); + np = (NodePtr)malloc(sizeof(NodeType)); + add_bytes(sizeof(NodeType)); + + np->data = this_expr; + append_to_list(this_stmt->_write.print_list, np); + + sentinel = (StatementKind)readStream->readUint32LE(); + } + break; + + case DUMP: + case FREE: + np = nullptr; + while (iterate_list(this_stmt->_write.print_list, np)) { + if (mission == DUMP) + writeStream->writeUint32LE(vContSeq); + this_expr = (ExprTree)np->data; + walk_expr(mission, bfile, this_expr); + + if (mission == FREE) + np->data = nullptr; + } + + if (mission == DUMP) + writeStream->writeUint32LE(vEndSeq); + else + dispose_list(this_stmt->_write.print_list); + break; + + default: + break; + } + break; + + default: + break; + } + + // Postlude + switch (mission) { + case FREE: + add_bytes(sizeof(StatementType)); + free(the_stmt); + break; + default: + break; + } +} + + +// ============================ Objects =========================== + +void load_object(Common::ReadStream *f_in, ObjectPtr &the_object) { + StatementKind sentinel; + + the_object = (ObjectPtr)malloc(sizeof(ObjectType)); + add_bytes(sizeof(ObjectType)); + + the_object->inherited_from = f_in->readSint32LE(); + load_item_list(f_in, the_object->attributes, EXPR_LIST); + load_item_list(f_in, the_object->methods, STMT_LIST); + + sentinel = (StatementKind)f_in->readUint32LE(); + if (sentinel == CONT_SEQ) + load_stmt(f_in, the_object->other); + else + the_object->other = nullptr; +} + +void dump_object(Common::WriteStream *f_out, const ObjectPtr the_object) { + f_out->writeUint32LE(the_object->inherited_from); + dump_item_list(f_out, the_object->attributes, EXPR_LIST); + dump_item_list(f_out, the_object->methods, STMT_LIST); + + if (the_object->other == nullptr) { + f_out->writeUint32LE(vEndSeq); + } else { + f_out->writeUint32LE(vContSeq); + dump_stmt(f_out, the_object->other); + } +} + +void dispose_object(ObjectPtr &the_object) { + dispose_item_list(the_object->attributes, EXPR_LIST); + dispose_item_list(the_object->methods, STMT_LIST); + if (the_object->other != nullptr) + dispose_stmt(the_object->other); + + add_bytes(sizeof(ObjectType)); + free(the_object); + the_object = nullptr; +} + + +// ============================= Object Lists ======================== + +void load_obj_list(Common::ReadStream *f_in, XArrayType &obj_list) { + ObjectPtr new_object; + void *p; + int i, list_size; + + new_xarray(obj_list); + list_size = f_in->readUint32LE(); + + for (i = 0; i < list_size; ++i) { + load_object(f_in, new_object); + p = new_object; + append_to_xarray(obj_list, p); + } + + // Objects may be dynamically allocated beneath this limit. It is okay to set that limit + // at this time since this routine is only invoked when initially loading a game + Dynamic = obj_list.size(); // TODO: Check if this should be size() + 1 +} + +void dump_obj_list(Common::WriteStream *f_out, XArrayType &obj_list) { + uint i; + void *p; + ObjectPtr this_obj; + + f_out->writeUint32LE(obj_list.size()); + + for (i = 0; i < obj_list.size(); ++i) { + if (index_xarray(obj_list, i, p)) { + this_obj = (ObjectPtr)p; + dump_object(f_out, this_obj); + } + } +} + +void dispose_obj_list(XArrayType &obj_list) { + uint i; + void *p; + ObjectPtr axe_obj; + + for (i = 0; i < obj_list.size(); ++i) { + if (index_xarray(obj_list, i, p)) { + axe_obj = (ObjectPtr)p; + dispose_object(axe_obj); + } + } + + dispose_xarray(obj_list); +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/saveload.h b/engines/glk/archetype/saveload.h new file mode 100644 index 0000000000..fe6251be9c --- /dev/null +++ b/engines/glk/archetype/saveload.h @@ -0,0 +1,79 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_ERROR +#define ARCHETYPE_ERROR + +/* Contains routines for both saving and loading binary ACX files. Also + * contains routines for disposing of the major ACL structures, in order to + * be able to throw away the old before loading in the new + */ + +#include "glk/archetype/linked_list.h" +#include "glk/archetype/statement.h" +#include "common/stream.h" + +namespace Glk { +namespace Archetype { + +enum ContentType { STMT_LIST, EXPR_LIST, CASE_LIST }; +enum MissionType { LOAD, DUMP, FREE, DISPLAY }; + +struct ObjectType { + int inherited_from; // index to Type_List + ListType attributes; + ListType methods; + StatementPtr other; +}; +typedef ObjectType *ObjectPtr; + +// Global variables +extern StatementKind vEndSeq, vContSeq; // to make BlockWrite happy +extern int Dynamic; +extern bool Translating; + +extern void saveload_init(); + +extern void load_item_list(Common::ReadStream *f_in, ListType elements, ContentType content); +extern void dump_item_list(Common::WriteStream *f_out, ListType elements, ContentType content); +extern void dispose_item_list(ListType &elements, ContentType content); + +extern void load_expr(Common::ReadStream *f_in, ExprTree &the_expr); +extern void dump_expr(Common::WriteStream *f_out, ExprTree &the_expr); +extern void dispose_expr(ExprTree &the_expr); + +extern void load_stmt(Common::ReadStream *f_in, StatementPtr &the_stmt); +extern void dump_stmt(Common::WriteStream *f_out, StatementPtr &the_stmt); +extern void dispose_stmt(StatementPtr &the_stmt); + +extern void load_object(Common::ReadStream *f_in, ObjectPtr &the_object); +extern void dump_object(Common::WriteStream *f_out, const ObjectPtr the_object); +extern void dispose_object(ObjectPtr &the_object); + +extern void load_obj_list(Common::ReadStream *f_in, XArrayType &obj_list); +extern void dump_obj_list(Common::WriteStream *f_out, XArrayType &obj_list); +extern void dispose_obj_list(XArrayType &obj_list); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/semantic.cpp b/engines/glk/archetype/semantic.cpp new file mode 100644 index 0000000000..4e2cd37205 --- /dev/null +++ b/engines/glk/archetype/semantic.cpp @@ -0,0 +1,234 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/semantic.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/error.h" +#include "glk/archetype/id_table.h" + +namespace Glk { +namespace Archetype { + +typedef int *IntegerPtr; + +int classify_as(progfile &f, int id_number, ClassifyType interpretation, void *ptr_to_data) { + IdRecPtr the_id_ptr; + String error_string; + int result = 0; + + if (!index_ident(id_number, the_id_ptr)) { + error_message(f, "Attempt to classify unencountered identifier"); + } else { + //with the_id_ptr^ do begin + if (the_id_ptr->id_kind == interpretation) + result = the_id_ptr->id_integer; + + // If the existing id_kind is the DefaultClassification, we're allowed to + // change it; otherwise there's a conflict + else if (the_id_ptr->id_kind == DefaultClassification) { + the_id_ptr->id_kind = interpretation; + the_id_ptr->id_integer = the_id_ptr->id_index; + + switch (the_id_ptr->id_kind) { + case TYPE_ID: + append_to_xarray(g_vm->Type_List, ptr_to_data); + append_to_xarray(g_vm->Type_ID_List, (void *)the_id_ptr->id_name); + the_id_ptr->id_integer = g_vm->Type_List.size() - 1; + break; + + case OBJECT_ID: + if (ptr_to_data == nullptr) { + the_id_ptr->id_integer = 0; + } else { + // Object_List may have grown by unnamed objects between calls to classify_as. + // Fill in the intervening spaces with "null" + while (g_vm->Object_ID_List.size() < g_vm->Object_List.size()) + append_to_xarray(g_vm->Object_ID_List, (void *)g_vm->NullStr); + + append_to_xarray(g_vm->Object_List, ptr_to_data); + append_to_xarray(g_vm->Object_ID_List, (void *)the_id_ptr->id_name); + the_id_ptr->id_integer = g_vm->Object_List.size() - 1; + } + break; + + case ATTRIBUTE_ID: + append_to_xarray(g_vm->Attribute_ID_List, (void *)the_id_ptr->id_name); + the_id_ptr->id_integer = g_vm->Attribute_ID_List.size() - 1; + break; + + default: + break; + } + } else { + error_string = String::format("Identifier type conflict: \"%s\" already declared as ", + the_id_ptr->id_name->c_str()); + + switch (the_id_ptr->id_kind) { + case TYPE_ID: + error_string = error_string + "a type"; + break; + case OBJECT_ID: + error_string = error_string + "an object"; + break; + case ATTRIBUTE_ID: + error_string = error_string + "an attribute"; + break; + case ENUMERATE_ID: + error_string = error_string + "a keyword"; + break; + default: + break; + } + + error_message(f, error_string); + the_id_ptr->id_integer = 0; + } + + result = the_id_ptr->id_integer; + } + + return result; +} + +void get_meaning(int id_number, ClassifyType &meaning, int &number) { + IdRecPtr the_id_ptr; + + if (!index_ident(id_number, the_id_ptr)) { + error("Internal error: attempt to find meaning of unencountered identifier"); + } else { + meaning = the_id_ptr->id_kind; + number = the_id_ptr->id_integer; + } +} + +void add_undefined(int the_ID) { + NodePtr np; + IntegerPtr ip; + + np = find_item(g_vm->Overlooked, the_ID); + if (np != nullptr) { + ++*((IntegerPtr)np->data); + } else { + np = (NodePtr)malloc(sizeof(NodeType)); + np->key = the_ID; + ip = (IntegerPtr)malloc(sizeof(int)); + *ip = 1; // TODO: Should this be 0-based? + np->data = ip; + insert_item(g_vm->Overlooked, np); + } +} + +bool display_undefined() { + NodePtr np = nullptr; + IntegerPtr ip; + IdRecPtr id_rec; + bool exists = false; + + while (iterate_list(g_vm->Overlooked, np)) { + if (!exists) { + g_vm->writeln("The following identifiers were not explicitly defined."); + exists = true; + } + + ip = (IntegerPtr)np->data; + g_vm->write("Used %d", *ip); + if (*ip == 1) + g_vm->write(" time: "); + else + g_vm->write(" times: "); + + if (index_ident(np->key, id_rec)) + g_vm->writeln("%s", id_rec->id_name->c_str()); + else + g_vm->writeln(""); + + free(ip); + } + + dispose_list(g_vm->Overlooked); + + return exists; +} + +bool verify_expr(progfile &f, ExprTree the_expr) { + bool success = true; + + switch (the_expr->_kind) { + case OPER: + switch (the_expr->_oper.op_name) { + case OP_DOT: + if (the_expr->_oper.right->_kind != IDENT) { + error_message(f, "Right side of dot must be an identifier"); + success = false; + } + else if (the_expr->_oper.right->_ident.ident_kind != ATTRIBUTE_ID) { + the_expr->_oper.right->_ident.ident_int = classify_as(f, + the_expr->_oper.right->_ident.ident_int, ATTRIBUTE_ID, nullptr); + } + + the_expr->_oper.right->_ident.ident_kind = ATTRIBUTE_ID; + if (the_expr->_oper.right->_ident.ident_int == 0) + success = false; + + case OP_ASSIGN: + case OP_C_CONCAT: + case OP_C_MULTIPLY: + case OP_C_DIVIDE: + case OP_C_PLUS: + case OP_C_MINUS: + if (the_expr->_oper.left->_kind == IDENT) { + get_meaning(the_expr->_oper.left->_ident.ident_int, + the_expr->_oper.left->_ident.ident_kind, the_expr->_oper.left->_ident.ident_int); + + if (the_expr->_oper.left->_ident.ident_kind != ATTRIBUTE_ID) { + error_message(f, "Left side of assignment is not an attribute"); + success = false; + } + } + else if (!(the_expr->_oper.left->_kind == OPER && + the_expr->_oper.left->_oper.op_name == OP_DOT)) { + error_message(f, "Left side of assignment must reference an attribute"); + success = false; + } + break; + + default: + break; + } + + if (success) { + if (Binary[the_expr->_oper.op_name]) + success = verify_expr(f, the_expr->_oper.left); + } + if (success) + success = verify_expr(f, the_expr->_oper.right); + break; + + default: + break; + } + + return success; +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/semantic.h b/engines/glk/archetype/semantic.h new file mode 100644 index 0000000000..2166e81220 --- /dev/null +++ b/engines/glk/archetype/semantic.h @@ -0,0 +1,112 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_SEMANTIC +#define ARCHETYPE_SEMANTIC + +/* Used by the SYNTAX unit, it provides the high-level semantic checking + * as well as .ACX file output. + */ + +#include "glk/archetype/array.h" +#include "glk/archetype/expression.h" +#include "glk/archetype/linked_list.h" + +namespace Glk { +namespace Archetype { + +/** + * Works closely with the ID_Table to create and verify the various semantic + * interpretations of identifiers, which are classified as either: + * TYPE_ID: names a type definition template in the type list. + * OBJECT_ID: names an object instantiation in the object list. + * ATTRIBUTE_ID: an attribute identifier. + * ENUMERATE_ID: an identifier like "open" or "closed" which is simply + * assigned so that it can be tested. + * UNDEFINED_ID: Not defined anywhere. If /K is asserted for CREATE, then + * this is the value returned by default; otherwise, + * ENUMERATE_ID is. + * + * @param f the progfile that is being read. Since this function is part + * of the first "pass", it needs access to the file being read. + * @param id_number the index in the ID table + * @param interpretation one of the constants above + * @param ptr_to_data (IN) if not nil, points to the data that the identifier represents + * (when first encountered) + * @returns depends on interpretation: + * TYPE_ID: the index in Type_List + * OBJECT_ID: the index in Object_List + * ATTRIBUTE_ID: the order the identifier was declared in, i.e. + * for the first attribute encountered, 1, for the + * second, 2, etc. + * ENUMERATE_ID: the unchanged id_number, for a simple unique number. + * UNDEFINED_ID: same as ENUMERATE_ID + * + * In any case, classify_as returns 0 if there was an error. + * Such an error will have been printed by this routine, so there + * will be no need for the caller to print out its own. + */ +extern int classify_as(progfile &f, int id_number, ClassifyType interpretation, void *ptr_to_data); + +/** + * Given an ID_Table index, finds what it represents and returns an appropriate enumerated + * type and index. + * + * If /K is asserted, default return is UNDEFINED_ID; else it is ENUMERATE_ID. + * @param id_number integer index to ID_Table + * @param meaning Output classification of ID + * @param number Output integer appropriate to classification + */ +extern void get_meaning(int id_number, ClassifyType &meaning, int &number); + +/** + * Used for adding the number of an undefined identifier to a list to be produced + * at the end of translation. + */ +extern void add_undefined(int the_ID); + +/** + * Displays the list of undefined identifiers collected with add_undefined + */ +extern bool display_undefined(); + +/** + * Assumes that expression tree contains no OP_LPAREN nodes. + * Ensures the following: + * 1. All OP_DOT operators have identifiers as their right-hand + * arguments, which are classified as ATTRIBUTE_ID's. + * 2. All assignment operators have OP_DOT operators or identifiers + * as their left-hand arguments, and any such identifiers are + * classified as ATTRIBUTE_ID's. + * This is necessary because the only way to use the OP_DOT operator is + * to discover the value of some attribute, and attributes are the only + * things which may be assigned to. + * + * @param f Program file (for logging errors) + * @param the_expr Expression to be verified + */ +extern bool verify_expr(progfile &f, ExprTree the_expr); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/statement.h b/engines/glk/archetype/statement.h new file mode 100644 index 0000000000..0be8c1b9a0 --- /dev/null +++ b/engines/glk/archetype/statement.h @@ -0,0 +1,98 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_STATEMENT +#define ARCHETYPE_STATEMENT + +#include "glk/archetype/expression.h" +#include "glk/archetype/linked_list.h" + +namespace Glk { +namespace Archetype { + +enum StatementKind { + COMPOUND, ST_EXPR, ST_IF, ST_CASE, ST_FOR, ST_WHILE, ST_BREAK, ST_CREATE, + ST_DESTROY, ST_WRITE, ST_WRITES, ST_STOP, CONT_SEQ, END_SEQ +}; + +union StatementType; +typedef StatementType *StatementPtr; + +struct StmtCompound { + ListType statements; +}; + +struct StmtExpr { + ExprTree expression; +}; + +struct StmtIf { + ExprTree condition; + StatementPtr then_branch; + StatementPtr else_branch; +}; + +struct StmtCase { + ExprTree test_expr; + ListType cases; +}; + +struct StmtCreate { + int archetype; + ExprTree new_name; +}; + +struct StmtDestroy { + ExprTree victim; +}; + +struct StmtLoop { + ExprTree selection; + StatementPtr action; +}; + +struct StmtWrite { + ListType print_list; +}; + +union StatementType { + StatementKind _kind; + StmtCompound _compound; + StmtExpr _expr; + StmtIf _if; + StmtCase _case; + StmtCreate _create; + StmtDestroy _destroy; + StmtLoop _loop; + StmtWrite _write; +}; + +struct CasePairType { + ExprTree value; + StatementPtr action; +}; +typedef CasePairType *CasePairPtr; + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/string.cpp b/engines/glk/archetype/string.cpp new file mode 100644 index 0000000000..4db4688a7d --- /dev/null +++ b/engines/glk/archetype/string.cpp @@ -0,0 +1,133 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/string.h" +#include "common/algorithm.h" + +namespace Glk { +namespace Archetype { + +int String::indexOf(char c) const { + const char *p = strchr(c_str(), c); + return p ? p - c_str() : -1; +} + +int String::indexOf(const String &substr) const { + const char *c = strstr(c_str(), substr.c_str()); + return c ? c - c_str() : -1; +} + +int String::lastIndexOf(char c) const { + for (int i = (int)size() - 1; i >= 0; --i) { + if (operator[](i) == c) + return i; + } + + return -1; +} + +void String::trim() { + while (!empty() && (lastChar() == ' ' || lastChar() == '\t' || lastChar() == '\n' + || lastChar() == '\r')) + deleteLastChar(); +} + +String operator+(const String &x, const String &y) { + Common::String tmp = Common::operator+(x, y); + return String(tmp.c_str()); +} + +String operator+(const char *x, const String &y) { + Common::String tmp = Common::operator+(x, y); + return String(tmp.c_str()); +} + +String operator+(const String &x, const char *y) { + Common::String tmp = Common::operator+(x, y); + return String(tmp.c_str()); +} + +String operator+(const String &x, char y) { + Common::String tmp = Common::operator+(x, y); + return String(tmp.c_str()); +} + +String operator+(char x, const String &y) { + Common::String tmp = Common::operator+(x, y); + return String(tmp.c_str()); +} + +bool operator==(const char *x, const String &y) { + return Common::operator==(x, y); +} + +bool operator!=(const char *x, const String &y) { + return Common::operator!=(x, y); +} + +String String::format(const char *fmt, ...) { + va_list va; + va_start(va, fmt); + Common::String tmp = Common::String::vformat(fmt, va); + va_end(va); + return String(tmp); +} + +String String::vformat(const char *fmt, va_list args) { + Common::String tmp = Common::String::vformat(fmt, args); + return String(tmp); +} + +int String::val(int *code) { + if (code) + *code = 0; + + return atoi(c_str()); +} + +String String::left(size_t count) const { + return String(c_str(), c_str() + MIN(count, (size_t)size())); +} + +String String::right(size_t count) const { + size_t len = size(); + return String(c_str() + len - MIN(count, len), c_str() + len); +} + +String String::mid(size_t start, size_t count) const { + int max = (int)size() - start; + return String(c_str() + start, c_str() + start + MIN((int)count, max)); +} + +String String::mid(size_t start) const { + return String(c_str() + start); +} + +void String::del(size_t start, size_t count) { + if (start) + (*this) = left(start) + mid(start + count - 1); + else + (*this) = mid(count); +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/string.h b/engines/glk/archetype/string.h new file mode 100644 index 0000000000..f85ed37d1a --- /dev/null +++ b/engines/glk/archetype/string.h @@ -0,0 +1,143 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_STRING +#define ARCHETYPE_STRING + +#include "common/str.h" + +namespace Glk { +namespace Archetype { + +class String : public Common::String { +public: + String() : Common::String() {} + String(const char *str) : Common::String(str) {} + String(const char *str, uint32 len) : Common::String(str, len) {} + String(const char *beginP, const char *endP) : Common::String(beginP, endP) {} + String(const Common::String &str) : Common::String(str) {} + explicit String(char c) : Common::String(c) {} + + String &operator=(const char *str) { + Common::String::operator=(str); + return *this; + } + String &operator=(const Common::String &str) { + Common::String::operator=(str); + return *this; + } + String &operator=(char c) { + Common::String::operator=(c); + return *this; + } + String &operator+=(const char *str) { + Common::String::operator+=(str); + return *this; + } + String &operator+=(const Common::String &str) { + Common::String::operator+=(str); + return *this; + } + String &operator+=(char c) { + Common::String::operator+=(c); + return *this; + } + + static String format(const char *fmt, ...) GCC_PRINTF(1, 2); + + static String vformat(const char *fmt, va_list args); + + /** + * Returns the index of a character within this string + */ + int indexOf(char c) const; + + /** + * Returns the index of a substring within this string + */ + int indexOf(const String &substr) const; + + /** + * Returns the last index of a character in a string, or -1 if it isn't present + */ + int lastIndexOf(char c) const; + + /** + * Trims spaces(and tabs and newlines) off the ends of a given string + */ + void trim(); + + /** + * Gets a substring of the string + */ + String substring(int index, int count) const { + return String(c_str() + index, c_str() + index + count); + } + + /** + * Converts a string to a value + * @param code Optional returns non-value of character index + */ + int val(int *code); + + /** + * Returns a given number of chracters from the start of a string + */ + String left(size_t count) const; + + /** + * Returns a given number of characters from the end of a string + */ + String right(size_t count) const; + + /** + * Returns a substring of another string + */ + String mid(size_t start) const; + String mid(size_t start, size_t count) const; + + /** + * Delete a range within a string + */ + void del(size_t start, size_t count); +}; + +// Append two strings to form a new (temp) string +String operator+(const String &x, const String &y); + +String operator+(const char *x, const String &y); +String operator+(const String &x, const char *y); + +String operator+(const String &x, char y); +String operator+(char x, const String &y); + +// Some useful additional comparison operators for Strings +bool operator==(const char *x, const String &y); +bool operator!=(const char *x, const String &y); + +typedef String *StringPtr; +typedef String ShortStringType; + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/sys_object.cpp b/engines/glk/archetype/sys_object.cpp new file mode 100644 index 0000000000..c30a1b87f6 --- /dev/null +++ b/engines/glk/archetype/sys_object.cpp @@ -0,0 +1,305 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/sys_object.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/game_stat.h" +#include "glk/archetype/heap_sort.h" +#include "glk/archetype/parser.h" +#include "glk/archetype/wrap.h" +#include "common/algorithm.h" +#include "common/savefile.h" + +namespace Glk { +namespace Archetype { + +enum SysStateType { + IDLING, INIT_SORTER, OPEN_SORTER, CLOSE_SORTER, NEXT_SORTED, PLAYER_CMD, + NORMALIZE, ABBR, OPEN_PARSER, VERB_LIST, NOUN_LIST, CLOSE_PARSER, INIT_PARSER, + WHICH_OBJECT, ROLL_CALL, PRESENT, PARSE, NEXT_OBJECT, DEBUG_MESSAGES, + DEBUG_EXPRESSIONS, DEBUG_STATEMENTS, DEBUG_MEMORY, FREE_MEMORY, SAVE_STATE, LOAD_STATE +}; + +const char *const StateLookup[LOAD_STATE + 1] = { + "IDLING", "INIT SORTER", "OPEN SORTER", "CLOSE SORTER", "NEXT SORTED", "PLAYER CMD", + "NORMALIZE", "ABBR", "OPEN PARSER", "VERB LIST", "NOUN LIST", "CLOSE PARSER", "INIT PARSER", + "WHICH OBJECT", "ROLL CALL", "PRESENT", "PARSE", "NEXT OBJECT", "DEBUG MESSAGES", + "DEBUG EXPRESSIONS", "DEBUG STATEMENTS", "DEBUG MEMORY", "FREE MEMORY", "SAVE STATE", "LOAD STATE" +}; + +// Global variables which retain the state of the system object between calls +SysStateType sys_state; +TargetListType target_list; + +void sys_object_init() { + sys_state = IDLING; + target_list = PARSER_VERBLIST; +} + +static bool figure_state(const String &s) { + for (int st = IDLING; st <= LOAD_STATE; ++st) { + if (StateLookup[st] == s) { + sys_state = (SysStateType)st; + return true; + } + } + + return false; +} + +void send_to_system(int transport, String &strmsg, ResultType &result, ContextType &context) { + int the_caller; + int obj_index; + String nomatch; + NodePtr np; + void *p; + + if (transport == OP_SEND) + the_caller = context.self; + else + the_caller = context.sender; + + do { + cleanup(result); + + switch (sys_state) { + case IDLING: + if (figure_state(strmsg)) { + switch (sys_state) { + case PLAYER_CMD: + case ABBR: + case SAVE_STATE: + case LOAD_STATE: + case OPEN_PARSER: + case OPEN_SORTER: + case WHICH_OBJECT: + return; // come back again! + + case INIT_SORTER: + reinit_heap(); + sys_state = OPEN_SORTER; + return; + + case INIT_PARSER: + new_parse_list(); + sys_state = OPEN_PARSER; + return; + + default: + break; + } + } + + case PLAYER_CMD: + normalize_string(strmsg, g_vm->Command); + sys_state = IDLING; + break; + + case NORMALIZE: + // last normalized command + result._kind = STR_PTR; + result._str.acl_str = NewDynStr(g_vm->Command); + sys_state = IDLING; + + case ABBR: + result._kind = STR_PTR; + result._str.acl_str = NewDynStr(strmsg); + + if (convert_to(NUMERIC, result)) { + g_vm->Abbreviate = result._numeric.acl_int; + } + else { + wraperr("Warning: non-numeric abbreviation message sent to system"); + cleanup(result); + } + sys_state = IDLING; + break; + + case OPEN_PARSER: + if (figure_state(strmsg)) { + switch (sys_state) { + case CLOSE_PARSER: + sys_state = IDLING; + break; + + case VERB_LIST: + target_list = PARSER_VERBLIST; + sys_state = OPEN_PARSER; + break; + + case NOUN_LIST: + target_list = PARSER_NOUNLIST; + sys_state = OPEN_PARSER; + break; + + default: + break; + } + } + else { + add_parse_word(target_list, strmsg, the_caller); + } + + return; + + case OPEN_SORTER: + if (figure_state(strmsg)) { + switch (sys_state) { + case CLOSE_SORTER: + sys_state = IDLING; + break; + default: + break; + } + } else { + drop_str_on_heap(strmsg); + } + return; + + case NEXT_SORTED: + if (!pop_heap(p)) { + cleanup(result); + } else { + result._kind = STR_PTR; + result._str.acl_str = (StringPtr)p; + sys_state = IDLING; + } + break; + + case WHICH_OBJECT: + obj_index = find_object(strmsg); + if (obj_index != 0) { + result._kind = IDENT; + result._ident.ident_kind = OBJECT_ID; + result._ident.ident_int = obj_index; + } + sys_state = IDLING; + break; + + case ROLL_CALL: + dispose_list(g_vm->Proximate); + new_list(g_vm->Proximate); + sys_state = IDLING; + break; + + case PRESENT: + np = (NodePtr)malloc(sizeof(NodeType)); + np->data = nullptr; + np->key = the_caller; + + insert_item(g_vm->Proximate, np); + sys_state = IDLING; + break; + + case PARSE: + parse_sentence(); + sys_state = IDLING; + break; + + case NEXT_OBJECT: + if (!pop_object(obj_index, nomatch)) { + cleanup(result); + } else if (obj_index < 0) { + result._kind = STR_PTR; + result._str.acl_str = NewDynStr(nomatch); + } else { + result._kind = IDENT; + result._ident.ident_kind = OBJECT_ID; + result._ident.ident_int = obj_index; + } + + sys_state = IDLING; + break; + + case DEBUG_MESSAGES: + Debug = Debug ^ DEBUG_MSGS; + sys_state = IDLING; + break; + + case DEBUG_EXPRESSIONS: + Debug = Debug ^ DEBUG_EXPR; + sys_state = IDLING; + break; + + case DEBUG_STATEMENTS: + Debug = Debug ^ DEBUG_STMT; + sys_state = IDLING; + break; + + case DEBUG_MEMORY: + wrapout("", true); // get to beginning of line + //g_vm->writeln("Maximum memory request: %d bytes", MaxAvail); + //g_vm->writeln("Actual free memory: %d bytes", MemAvail); + sys_state = IDLING; + break; + + case FREE_MEMORY: + result._kind = NUMERIC; + result._numeric.acl_int = 0xffff; // MemAvail; + sys_state = IDLING; + break; + + case SAVE_STATE: { + Common::OutSaveFile *stfile = g_system->getSavefileManager()->openForSaving(strmsg); + if (stfile == nullptr) { + g_vm->writeln("Error opening %s", strmsg.c_str()); + cleanup(result); + } + else { + save_game_state(stfile, g_vm->Object_List); + result._kind = RESERVED; + result._reserved.keyword = RW_TRUE; + + stfile->finalize(); + delete stfile; + } + + sys_state = IDLING; + break; + } + + case LOAD_STATE: { + Common::InSaveFile *stfile = g_system->getSavefileManager()->openForLoading(strmsg); + if (stfile == nullptr) { + g_vm->writeln("Error opening %s", strmsg.c_str()); + cleanup(result); + } else { + result._kind = RESERVED; + result._reserved.keyword = load_game_state(stfile, g_vm->Object_List) ? RW_TRUE : RW_FALSE; + delete stfile; + } + + sys_state = IDLING; + break; + } + + default: + break; + } + + if (g_vm->shouldQuit()) + sys_state = IDLING; + } while (sys_state != IDLING); +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/sys_object.h b/engines/glk/archetype/sys_object.h new file mode 100644 index 0000000000..5fa9982d45 --- /dev/null +++ b/engines/glk/archetype/sys_object.h @@ -0,0 +1,46 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_SYS_OBJECT +#define ARCHETYPE_SYS_OBJECT + +#include "glk/archetype/string.h" +#include "glk/archetype/interpreter.h" + +namespace Glk { +namespace Archetype { + +extern void sys_object_init(); + +/** + * Is the receiver of all "system calls" and the only object that receives + * messages in the form of strings rather than message constants. + * + * Notes: Uses a global variable called sys_state to keep track of its state + * between calls. + */ +extern void send_to_system(int transport, String &strmsg, ResultType &result, ContextType &context); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/timestamp.cpp b/engines/glk/archetype/timestamp.cpp new file mode 100644 index 0000000000..d146e4c168 --- /dev/null +++ b/engines/glk/archetype/timestamp.cpp @@ -0,0 +1,50 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/timestamp.h" +#include "common/system.h" + +namespace Glk { +namespace Archetype { + +TimestampType GTimeStamp; + +void timestamp_init() { + GTimeStamp = 0; +} + +void get_time_stamp(TimestampType &tstamp) { + // Get the time and date + TimeDate td; + g_system->getTimeAndDate(td); + + // Normalize the year + tstamp = ((td.tm_year - 1992) % 64) << 26; + tstamp |= td.tm_mon << 22; + tstamp |= td.tm_mday << 17; + tstamp |= td.tm_hour << 12; + tstamp |= td.tm_min << 6; + tstamp |= td.tm_sec; +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/timestamp.h b/engines/glk/archetype/timestamp.h new file mode 100644 index 0000000000..893ba438ce --- /dev/null +++ b/engines/glk/archetype/timestamp.h @@ -0,0 +1,62 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_TIMESTAMP +#define ARCHETYPE_TIMESTAMP + +#include "common/scummsys.h" + +namespace Glk { +namespace Archetype { + +typedef uint32 TimestampType; + +extern TimestampType GTimeStamp; + +extern void timestamp_init(); + +/** + * Creates a compressed long integer that contains all the necessary time information. + * There are enough bits in a 32-bit word to do this : + * + * Variable Range Bits + * -------- ----- ---- + * Year 0-63 6 + * Month 1-12 4 + * Day 0-31 5 + * Hour 0-23 5 + * Minute 0-59 6 + * Second 0-59 6 + * + * Note that Year does not quite fit comfortably into this scheme.The actual returned value + * is 1980-2099, a span of 119 years; but we are using only 63. Year 0 is considered 1992 + * and the upper limit is 2055 before it goes back to year 0 (1992) again. + * + * The DayOfWeek information is thrown away because it is redundant, and the Sec100 information + * is thrown away because it is unnecessarily precise + */ +extern void get_time_stamp(TimestampType &tstamp); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/token.cpp b/engines/glk/archetype/token.cpp new file mode 100644 index 0000000000..3be0e2365b --- /dev/null +++ b/engines/glk/archetype/token.cpp @@ -0,0 +1,441 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers || c == 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 || c == 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 || c == g_vm->write to the Free Software + * Foundation || c == Inc. || c == 51 Franklin Street || c == Fifth Floor || c == Boston || c == MA 02110-1301 || c == USA. + * + */ + +#include "glk/archetype/token.h" +#include "glk/archetype/archetype.h" +#include "glk/archetype/id_table.h" +#include "glk/archetype/misc.h" +#include "glk/archetype/keywords.h" + +namespace Glk { +namespace Archetype { + +enum StateType { START, STOP, DECIDE, WHITE, COMMENT, QUOTE, LITERAL, IDENTIFIER, NUMBER, OPERATOR }; + +bool isWhitespace(char c) { + return c == ' ' || c == '\t' || c == NEWLINE_CH; +} + +bool isLiteralType(char c) { + return c == '"' || c == '\''; +} + +bool isLetter(char c) { + return Common::isAlpha(c); +} + +bool isDigit(char c) { + return Common::isDigit(c); +} + +bool isStartChar(char c) { + return Common::isAlpha(c) || c == '_'; +} + +bool isIdChar(char c) { + return isStartChar(c) || isDigit(c); +} + +bool isLongOper(char c) { + return c == '<' || c == '>' || c == ':' || c == '+' || c == '-' || c == '*' + || c == '/' || c == '&' || c == '~'; +} + +bool isOperChar(char c) { + return isLongOper(c) || c == '=' || c == '.' || c == '^' || c == '?'; +} + +/** + * Performs a binary search on the given ordered array, passing back the + * index of the given string if it's in the array. + * Used for quickly finding an operator or reserved word. + * @param the_array ordered array of short strings + * @param elements number of elements in the array + * @param match_str string to match + * @param a_index Outputs the array index + * @returns true if match_str was an element in the_array; false otherwise + */ +static bool binary_search(const LookupType &the_array, int elements, + const ShortStringType &match_str, int &a_index) { + int left = 0, right = elements - 1, mid; + + do { + mid = (left + right) / 2; + if (match_str < the_array[mid]) + right = mid - 1; + else + left = mid + 1; + } while (match_str != the_array[mid] && left <= right); + + if (match_str != the_array[mid]) { + return false; + } else { + a_index = mid; + return true; + } +} + +/** + * Searches the given unordered xarray for a string matching the given + * string; if found, returns the index in the list of the string. If + * not found, adds it to the list. + * @param the_xarray xarray to be searched + * @param the_str string to be compared + * @returns The index of the_str in the_xarray. + */ +static int add_unique_str(XArrayType &the_xarray, const String &the_str) { + StringPtr new_str; + int i; + void *p; + + // Duplicate the given string + new_str = NewConstStr(the_str); + + if (the_xarray.empty()) { + append_to_xarray(the_xarray, (void *)new_str); + return the_xarray.size() - 1; + } else { + i = 1; + while (index_xarray(the_xarray, i, p) && *((StringPtr)p) != the_str) + ++i; + + if (*((StringPtr)p) == the_str) { + FreeConstStr(new_str); + return i; + } else { + append_to_xarray(the_xarray, (void *)new_str); + return the_xarray.size() - 1; + } + } +} + +/** + * Similar to the above, except that it is to be used when the strings are + * not expected to repeat much. + */ +static int add_non_unique_str(XArrayType &the_xarray, const String &the_str) { + append_to_xarray(the_xarray, (void *)NewConstStr(the_str)); + return the_xarray.size() - 1; +} + +bool get_token(progfile &f) { + StateType state; + bool more_chars; + char bracket, next_ch = '\0'; + String s; + + // Check for old token. f.newlines may have changed while an old token was unconsumed, + // so if the unconsumed token was a NEWLINE and f.newlines is false, we must continue + // and get another token; otherwise we jump out with what we have + if (!f.consumed) { + f.consumed = true; + + if (!((f.ttype == NEWLINE) && !f.newlines)) + return true; + } + + more_chars = true; + state = START; + + while (state != STOP) { + switch (state) { + case START: + if (f.readChar(next_ch)) { + state = DECIDE; + } else { + more_chars = false; + state = STOP; + } + break; + + case DECIDE: + if (!more_chars) + state = STOP; + else if (isWhitespace(next_ch)) + state = WHITE; + else if (isLiteralType(next_ch)) + state = LITERAL; + else if (isStartChar(next_ch)) + state = IDENTIFIER; + else if (isDigit(next_ch)) + state = NUMBER; + else if (isOperChar(next_ch)) + state = OPERATOR; + else { + // a single-character token + switch (next_ch) { + case '#': + state = COMMENT; + case ';': + if (!f.newlines) { + state = START; + } + else { + f.ttype = NEWLINE; + f.tnum = (int)NEWLINE_CH; + state = STOP; + } + default: + f.ttype = PUNCTUATION; + f.tnum = (int)next_ch; + state = STOP; + } + break; + } + break; + + case WHITE: + while (state == WHITE && isWhitespace(next_ch)) { + if (next_ch == NEWLINE_CH && f.newlines) { + f.ttype = NEWLINE; + state = STOP; + } else { + more_chars = f.readChar(next_ch); + } + } + if (state == WHITE) { + if (more_chars) + // decide on new non-white character + state = DECIDE; + else + state = STOP; + } + break; + + case COMMENT: + case QUOTE: + s = ""; + more_chars = f.readChar(next_ch); + while (more_chars && next_ch != NEWLINE_CH) { + s = s + next_ch; + more_chars = f.readChar(next_ch); + } + if (state == COMMENT) { + if (more_chars) + state = START; + else + state = STOP; + } else { + // quoted literal + f.unreadChar(next_ch); // leave \n for the next guy + f.ttype = QUOTE_LIT; + f.tnum = add_non_unique_str(g_vm->Literals, s); + state = STOP; + } + break; + + case LITERAL: + bracket = next_ch; + s = ""; + more_chars = f.readChar(next_ch); // start the loop + while (more_chars && next_ch != NEWLINE_CH && next_ch != bracket) { + if (next_ch == '\\') { + more_chars = f.readChar(next_ch); + switch (next_ch) { + case 't': + next_ch = '\t'; + break; + case 'b': + next_ch = '\x8'; + break; + case 'e': + next_ch = (char)27; + break; + case'n': + s = s + '\r'; + next_ch = '\n'; + break; + } + } + s = s + next_ch; + + more_chars = f.readChar(next_ch); + } + + if (next_ch != bracket) { + f.sourcePos(); + error("Unterminated literal"); + } else { + switch (bracket) { + case '"': + f.ttype = TEXT_LIT; + f.tnum = add_non_unique_str(g_vm->Literals, s); + break; + case '\'': + f.ttype = MESSAGE; + f.tnum = add_unique_str(g_vm->Vocabulary, s); + break; + default: + error("Programmer error: unknown literal type"); + break; + } + + state = STOP; + } + break; + + case IDENTIFIER: + s = ""; + while (isIdChar(next_ch)) { + s = s + next_ch; + more_chars = f.readChar(next_ch); + } + if (!isIdChar(next_ch)) + f.unreadChar(next_ch); + + // Check for reserved words or operators + if (binary_search(Reserved_Wds, NUM_RWORDS, s, f.tnum)) + f.ttype = RESERVED; + else if (binary_search(Operators, NUM_OPERS, s, f.tnum)) + f.ttype = OPER; + else { + f.ttype = IDENT; + f.tnum = add_ident(s); + } + + state = STOP; + break; + + case NUMBER: + s = ""; + while (more_chars && isDigit(next_ch)) { + s = s + next_ch; + more_chars = f.readChar(next_ch); + } + + if (!isDigit(next_ch)) + f.unreadChar(next_ch); + f.ttype = NUMERIC; + + f.tnum = atoi(s.c_str()); + state = STOP; + break; + + case OPERATOR: + s = ""; + + while (more_chars && isLongOper(next_ch) && s != ">>") { + // have to stop short with >> + s = s + next_ch; + more_chars = f.readChar(next_ch); + } + + if (s == ">>") { + f.unreadChar(next_ch); + state = QUOTE; + } else { + if (!isOperChar(next_ch)) + f.unreadChar(next_ch); + else + s = s + next_ch; + + state = STOP; + + if (s == ":") { + f.ttype = PUNCTUATION; + f.tnum = (int)':'; + } else if (!binary_search(Operators, NUM_OPERS, s, f.tnum)) { + f.sourcePos(); + error("Unknown operator %s", s.c_str()); + } else { + f.ttype = OPER; + } + } + break; + + default: + break; + } + } + + return more_chars; +} + +void write_token(AclType the_type, int the_number) { + StringPtr str_ptr; + IdRecPtr the_id_ptr; + void *p; + + switch (the_type) { + case IDENT: + if (the_number < 0) { + g_vm->write("an identifier"); + } + else { + g_vm->write(": ", the_number); + if (index_ident(the_number, the_id_ptr)) + g_vm->write("\"%s\"", the_id_ptr->id_name); + } + break; + + case RESERVED: + if (the_number < 0) + g_vm->write("a reserved word"); + else + g_vm->write("reserved word \"%s\"", Reserved_Wds[the_number]); + break; + + case OPER: + if (the_number < 0) + g_vm->write("an operator"); + else + g_vm->write("operator \"%s\"", Operators[the_number]); + break; + + case PUNCTUATION: + g_vm->write("%c", (char)the_number); + break; + + case TEXT_LIT: + if (the_number < 0) + g_vm->write("a text literal"); + else if (index_xarray(g_vm->Literals, the_number, p)) { + str_ptr = (StringPtr)p; + g_vm->write("\"%s\"", str_ptr->c_str()); + } + else { + g_vm->write(": ", the_number); + } + break; + + case MESSAGE: + if (the_number < 0) + g_vm->write("a message"); + else if (index_xarray(g_vm->Vocabulary, the_number, p)) { + str_ptr = (StringPtr)p; + g_vm->write("\'%s\'", str_ptr->c_str()); + } else { + g_vm->write(": ", the_number); + } + break; + + case NUMERIC: + g_vm->write("the number %d", the_number); + break; + + default: + g_vm->write(""); + } +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/token.h b/engines/glk/archetype/token.h new file mode 100644 index 0000000000..eda985eaf9 --- /dev/null +++ b/engines/glk/archetype/token.h @@ -0,0 +1,62 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_TOKEN +#define ARCHETYPE_TOKEN + +#include "glk/archetype/misc.h" +#include "common/str.h" + +namespace Glk { +namespace Archetype { + +/* +extern bool isLiteralType(char c); +extern bool isLetter(char c); +extern bool isDigit(char c); +extern bool isStartChar(char c); +extern bool isIdChar(char c); +extern bool isLongOper(char c); +extern bool isOperChar(char c); +*/ + +/** + * State machine which passes out the next token from the file f_in. + * + * A token is a constant (including parse words and literal text), + * a reserved word, or an operator (including the curly braces). + * @param f The input file + * @returns True if there is a token available, false if the file is empty + */ +extern bool get_token(progfile &f); + +/** + * Given a token type andtoken number, writes out the proper string (without terminating the line). + * @param the_type the token type + * @param the_number the token number + */ +extern void write_token(AclType the_type, int the_number); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/archetype/wrap.cpp b/engines/glk/archetype/wrap.cpp new file mode 100644 index 0000000000..6ef961f0d3 --- /dev/null +++ b/engines/glk/archetype/wrap.cpp @@ -0,0 +1,147 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "glk/archetype/wrap.h" +#include "glk/archetype/archetype.h" + +namespace Glk { +namespace Archetype { + +const int + MAXCOLS = 75, // leave room for punctuation + SAFETY_MARGIN = 3, + MAXROWS = 24, + + REVERSE_VID = 3, + BOLDFACE = 8; + +int Rows; +int cursor; + +void wrap_init() { + cursor_reset(); + Rows = 0; +} + +static void wrap_wait() { +#ifdef UNUSED + char ch; + + TextColor(BOLDFACE); TextBackground(REVERSE_VID); + write('Hit any key to continue...'); + ch := ReadKey; + write(chr(13)); + NormVideo; + ClrScr; //or ClrEol if you don't want the whole screen } + Rows : = 0 +#endif +} + +void wrapint(int i, bool terminate) { + String s = String::format("%d", i); + wrapout(s, terminate); +} + +void wrapout(const String &str, bool terminate) { + int thisline, maxchars, startnext; + String s = str; + + // 'thisline' starts out as the maximum number of characters that can be + // written before a newline; it gets trimmed back to being the number of + // characters from the string that are actually written on this line. } + maxchars = MAXCOLS - cursor; + + const char CHARS[7] = { '.', ',', ':', ';', ')', '-', '"' }; + for (int i = 0; i < 7; ++i) { + if (s[0] == CHARS[i]) { + maxchars += SAFETY_MARGIN; + break; + } + } + + thisline = maxchars; + while (thisline < (int)s.size()) { + while (thisline >= 0 && s[thisline] != ' ') + --thisline; + } + + // If we were unable to find a wrapping point then it means one of two + // things : a) the string is too long to fit on one line, andmust be + // split unnaturally; or b) we are near the end of a line andmust wrap + // the entire string; i.e.print nothing, finish the line andgo on + if (thisline == 0 && s.size() > MAXCOLS) + thisline = maxchars + 1; + + g_vm->writeln(s.substring(0, thisline - 1)); + ++Rows; + if (Rows >= MAXROWS) + wrap_wait(); + + startnext = thisline; + while (startnext < (int)s.size() && s[startnext] == ' ') { + ++startnext; + + s = s.substring(startnext, s.size()); + cursor = 1; + thisline = MAXCOLS - cursor; + } + + g_vm->write(s); + cursor += s.size(); + + if (terminate) { + g_vm->writeln(); + ++Rows; + if (Rows >= MAXROWS) + wrap_wait(); + cursor = 1; + } +} + +void wraperr(const String &s) { + if (cursor > 1) + g_vm->writeln(); + g_vm->writeln(s); + + String tmp; + for (int i = 1; i < cursor; ++i) + tmp += ' '; + g_vm->write(tmp); +} + +StringPtr ReadLine(bool full_line) { + String s; + + if (full_line) + g_vm->readln(s); + else + s = g_vm->ReadKey(); + + return NewDynStr(s); +} + +void cursor_reset() { + cursor = 1; +} + +} // End of namespace Archetype +} // End of namespace Glk diff --git a/engines/glk/archetype/wrap.h b/engines/glk/archetype/wrap.h new file mode 100644 index 0000000000..7195303b9f --- /dev/null +++ b/engines/glk/archetype/wrap.h @@ -0,0 +1,65 @@ +/* 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. + * + */ + +#ifndef ARCHETYPE_WRAP +#define ARCHETYPE_WRAP + +#include "glk/archetype/misc.h" + +namespace Glk { +namespace Archetype { + +extern int Rows; + +/** + * When we want to wrap a number + */ +extern void wrapint(int i, bool terminate); + +/** + * Given a string, writes it out to screen, making sure that if it exceeds the screen columns, + * it is broken at natural word boundaries (i.e. white space) + */ +extern void wrapout(const String &s, bool terminate); + +/** + * Used for printing run-time errors. It will print the error message on + * a line by itself and pick up the next line at the exact same cursor position. + */ +extern void wraperr(const String &s); + +/** + * Hides the extra stack space necessary for performing a readln() so that + * it won't affect eval_expr + */ +extern StringPtr ReadLine(bool full_line); + +/** + * Used for directly resetting the cursor position by means other than + * physically wrapping it around + */ +extern void cursor_reset(); + +} // End of namespace Archetype +} // End of namespace Glk + +#endif diff --git a/engines/glk/module.mk b/engines/glk/module.mk index 449607cdf0..8915c669f3 100644 --- a/engines/glk/module.mk +++ b/engines/glk/module.mk @@ -146,7 +146,26 @@ endif ifdef ENABLE_GLK_ARCHETYPE MODULE_OBJS += \ archetype/archetype.o \ - archetype/detection.o + archetype/array.o \ + archetype/crypt.o \ + archetype/detection.o \ + archetype/error.o \ + archetype/expression.o \ + archetype/game_stat.o \ + archetype/heap_sort.o \ + archetype/id_table.o \ + archetype/interpreter.o \ + archetype/keywords.o \ + archetype/linked_list.o \ + archetype/misc.o \ + archetype/parser.o \ + archetype/saveload.o \ + archetype/semantic.o \ + archetype/string.o \ + archetype/sys_object.o \ + archetype/timestamp.o \ + archetype/token.o \ + archetype/wrap.o endif ifdef ENABLE_GLK_FROTZ -- cgit v1.2.3