From 08bc570308b0698090ce668dc7dca4c0c76dd3df Mon Sep 17 00:00:00 2001 From: Paul Gilbert Date: Mon, 17 Jun 2019 22:36:31 -0700 Subject: GLK: ALAN2: Initial import of full set of interpreter files --- engines/glk/alan2/acode.h | 306 ++++++ engines/glk/alan2/alan_version.cpp | 45 + engines/glk/alan2/alan_version.h | 36 + engines/glk/alan2/args.cpp | 308 ++++++ engines/glk/alan2/args.h | 50 + engines/glk/alan2/debug.cpp | 506 ++++++++++ engines/glk/alan2/debug.h | 47 + engines/glk/alan2/decode.cpp | 193 ++++ engines/glk/alan2/decode.h | 49 + engines/glk/alan2/exe.cpp | 1845 ++++++++++++++++++++++++++++++++++++ engines/glk/alan2/exe.h | 127 +++ engines/glk/alan2/glkio.cpp | 47 + engines/glk/alan2/glkio.h | 48 + engines/glk/alan2/glkstart.cpp | 65 ++ engines/glk/alan2/glkstart.h | 70 ++ engines/glk/alan2/inter.cpp | 893 +++++++++++++++++ engines/glk/alan2/inter.h | 38 + engines/glk/alan2/main.h | 155 +++ engines/glk/alan2/params.cpp | 159 ++++ engines/glk/alan2/params.h | 66 ++ engines/glk/alan2/parse.cpp | 846 +++++++++++++++++ engines/glk/alan2/parse.h | 54 ++ engines/glk/alan2/readline.cpp | 560 +++++++++++ engines/glk/alan2/readline.h | 46 + engines/glk/alan2/reverse.cpp | 552 +++++++++++ engines/glk/alan2/reverse.h | 46 + engines/glk/alan2/rules.cpp | 83 ++ engines/glk/alan2/rules.h | 44 + engines/glk/alan2/stack.cpp | 74 ++ engines/glk/alan2/stack.h | 48 + engines/glk/alan2/sysdep.cpp | 493 ++++++++++ engines/glk/alan2/sysdep.h | 409 ++++++++ engines/glk/alan2/term.cpp | 123 +++ engines/glk/alan2/term.h | 42 + engines/glk/alan2/types.h | 469 ++++----- engines/glk/alan2/util.h | 54 -- engines/glk/alan2/version.h | 59 ++ engines/glk/module.mk | 16 + 38 files changed, 8789 insertions(+), 282 deletions(-) create mode 100644 engines/glk/alan2/acode.h create mode 100644 engines/glk/alan2/alan_version.cpp create mode 100644 engines/glk/alan2/alan_version.h create mode 100644 engines/glk/alan2/args.cpp create mode 100644 engines/glk/alan2/args.h create mode 100644 engines/glk/alan2/debug.cpp create mode 100644 engines/glk/alan2/debug.h create mode 100644 engines/glk/alan2/decode.cpp create mode 100644 engines/glk/alan2/decode.h create mode 100644 engines/glk/alan2/exe.cpp create mode 100644 engines/glk/alan2/exe.h create mode 100644 engines/glk/alan2/glkio.cpp create mode 100644 engines/glk/alan2/glkio.h create mode 100644 engines/glk/alan2/glkstart.cpp create mode 100644 engines/glk/alan2/glkstart.h create mode 100644 engines/glk/alan2/inter.cpp create mode 100644 engines/glk/alan2/inter.h create mode 100644 engines/glk/alan2/main.h create mode 100644 engines/glk/alan2/params.cpp create mode 100644 engines/glk/alan2/params.h create mode 100644 engines/glk/alan2/parse.cpp create mode 100644 engines/glk/alan2/parse.h create mode 100644 engines/glk/alan2/readline.cpp create mode 100644 engines/glk/alan2/readline.h create mode 100644 engines/glk/alan2/reverse.cpp create mode 100644 engines/glk/alan2/reverse.h create mode 100644 engines/glk/alan2/rules.cpp create mode 100644 engines/glk/alan2/rules.h create mode 100644 engines/glk/alan2/stack.cpp create mode 100644 engines/glk/alan2/stack.h create mode 100644 engines/glk/alan2/sysdep.cpp create mode 100644 engines/glk/alan2/sysdep.h create mode 100644 engines/glk/alan2/term.cpp create mode 100644 engines/glk/alan2/term.h create mode 100644 engines/glk/alan2/version.h diff --git a/engines/glk/alan2/acode.h b/engines/glk/alan2/acode.h new file mode 100644 index 0000000000..5fee277c6c --- /dev/null +++ b/engines/glk/alan2/acode.h @@ -0,0 +1,306 @@ +/* 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 GLK_ALAN2_ACODE +#define GLK_ALAN2_ACODE + +namespace Glk { +namespace Alan2 { + +typedef size_t Aptr; /* Type for an ACODE memory address */ + +typedef unsigned int Aword; /* Type for an ACODE word */ +typedef unsigned int Aaddr; /* Type for an ACODE address */ +typedef unsigned int Abool; /* Type for an ACODE Boolean value */ +typedef signed int Aint; /* Type for an ACODE Integer value */ +typedef int CodeValue; /* Definition for the packing process */ + +#ifdef UNUSED +#if INT_MAX==0x7fffffff +typedef unsigned int Aword; /* Type for an ACODE word */ +typedef unsigned int Aaddr; /* Type for an ACODE address */ +typedef unsigned int Abool; /* Type for an ACODE Boolean value */ +typedef signed int Aint; /* Type for an ACODE Integer value */ +typedef int CodeValue; /* Definition for the packing process */ +#elif LONG_MAX==0x7fffffff +typedef unsigned long Aword; /* Type for an ACODE word */ +typedef unsigned long Aaddr; /* Type for an ACODE address */ +typedef unsigned long Abool; /* Type for an ACODE Boolean value */ +typedef signed long Aint; /* Type for an ACODE Integer value */ +typedef long CodeValue; /* Definition for the packing process */ +#else +#error "Can't find a 32-bit integer type" +#endif +#endif + +/* Constants for the Acode file, words/block & bytes/block */ +#define BLOCKLEN 256L +#define BLOCKSIZE (BLOCKLEN*sizeof(Aword)) + + +/* Definitions for the packing process */ +#define VALUEBITS 16 + +#define EOFChar 256 +#define TOPVALUE (((CodeValue)1<>28) +#define I_OP(x) ((x&0x8000000)?(x)|0x0f0000000:(x)&0x0fffffff) + + +typedef struct AcdHdr { +/* Important info */ + char vers[4]; /* 01 - Version of compiler */ + Aword size; /* 02 - Size of ACD-file in Awords */ +/* Options */ + Abool pack; /* 03 - Is the text packed ? */ + Aword paglen; /* 04 - Length of a page */ + Aword pagwidth; /* 05 - and width */ + Aword debug; /* 06 - Option debug */ +/* Data structures */ + Aaddr dict; /* 07 - Dictionary */ + Aaddr oatrs; /* 08 - Object default attributes */ + Aaddr latrs; /* 09 - Location default attributes */ + Aaddr aatrs; /* 0a - Actor default attributes */ + Aaddr acts; /* 0b - Actor table */ + Aaddr objs; /* 0c - Object table */ + Aaddr locs; /* 0d - Location table */ + Aaddr stxs; /* 0e - Syntax table */ + Aaddr vrbs; /* 0f - Verb table */ + Aaddr evts; /* 10 - Event table */ + Aaddr cnts; /* 11 - Container table */ + Aaddr ruls; /* 12 - Rule table */ + Aaddr init; /* 13 - String init table */ + Aaddr start; /* 14 - Start code */ + Aword msgs; /* 15 - Messages table */ +/* Miscellaneous */ + Aword objmin, objmax; /* 16 - Interval for object codes */ + Aword actmin, actmax; /* 18 - Interval for actor codes */ + Aword cntmin, cntmax; /* 1a - Interval for container codes */ + Aword locmin, locmax; /* 1c - Interval for location codes */ + Aword dirmin, dirmax; /* 1e - Interval for direction codes */ + Aword evtmin, evtmax; /* 20 - Interval for event codes */ + Aword rulmin, rulmax; /* 22 - Interval for rule codes */ + Aword maxscore; /* 24 - Maximum score */ + Aaddr scores; /* 25 - Score table */ + Aaddr freq; /* 26 - Address to Char freq's for coding */ + Aword acdcrc; /* 27 - Checksum for acd code (excl. hdr) */ + Aword txtcrc; /* 28 - Checksum for text data file */ +} AcdHdr; + +/* Error message numbers */ +typedef enum MsgKind { + M_HUH, /* Obsolete */ + M_WHAT, + M_WHAT_ALL, + M_WHAT_IT, + M_WHAT_THEM, + M_MULTIPLE, + M_WANT, + M_NOUN, + M_AFTER_BUT, + M_BUT_ALL, + M_NOT_MUCH, + M_WHICH_ONE, + M_NO_SUCH, + M_NO_WAY, + M_CANT0, + M_CANT, + M_NOTHING, /* Obsolete */ + M_SEEOBJ1, + M_SEEOBJ2, + M_SEEOBJ3, + M_SEEOBJ4, + M_SEEACT, + M_CONTAINS1, + M_CONTAINS2, + M_CONTAINS3, + M_CONTAINS4, + M_CONTAINS5, + M_EMPTY1, + M_EMPTY2, + M_SCORE1, + M_SCORE2, + M_UNKNOWN_WORD, + M_MORE, + M_AGAIN, + M_SAVEWHERE, + M_SAVEOVERWRITE, + M_SAVEFAILED, + M_SAVEMISSING, + M_SAVEVERS, + M_SAVENAME, + M_RESTOREFROM, + M_REALLY, /* CHANGED: v2.7 from M_RESTART */ + M_QUITACTION, /* INTRODUCED: v2.7, so M_ARTICLE moved */ + M_ARTICLE, /* INTRODUCED: v2.6 but replaced the M_NOMSG*/ + MSGMAX +} MsgKind; + +#define M_ARTICLE26 M_QUITACTION +#define M_MSGMAX26 M_ARTICLE + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/alan_version.cpp b/engines/glk/alan2/alan_version.cpp new file mode 100644 index 0000000000..d3e1b9dde7 --- /dev/null +++ b/engines/glk/alan2/alan_version.cpp @@ -0,0 +1,45 @@ +/* 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/alan2/alan_version.h" + +namespace Glk { +namespace Alan2 { + +Product alan = { + "Alan", + "Adventure Language System", + "Alan 2.8(6)", + "Alan 2.8(6) -- Adventure Language System (2001-07-13 14:35)", + "2001-07-13", + "14:35:07", + "Thomas Nilsson", + "", + "cygwin", + {"2.8(6)", 2, 8, 6, 995034907, ""} +}; + +static char *alanId = + "@(#)RELEASE "; + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/alan_version.h b/engines/glk/alan2/alan_version.h new file mode 100644 index 0000000000..1a75394bc5 --- /dev/null +++ b/engines/glk/alan2/alan_version.h @@ -0,0 +1,36 @@ +/* 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 GLK_ALAN2_ALAN_VERSION +#define GLK_ALAN2_ALAN_VERSION + +#include "glk/alan2/version.h" + +namespace Glk { +namespace Alan2 { + +extern Product alan; + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/args.cpp b/engines/glk/alan2/args.cpp new file mode 100644 index 0000000000..aceb00b67a --- /dev/null +++ b/engines/glk/alan2/args.cpp @@ -0,0 +1,308 @@ +/* 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 +#ifndef __PACIFIC__ +#include "glk/alan2/args.h" +#else +/* I have no idea at all why the include does not work in Pacific C ... */ +extern void args(int argc, char* argv[]); +#endif + +#include "glk/alan2/main.h" + +#ifdef __mac__ +#include "glk/alan2/macArgs.h" +#endif + +#ifdef __amiga__ +#include +#ifdef AZTEC_C +struct FileHandle *con = NULL; +#else +/* Geek Gadgets GCC */ +BPTR window; +BPTR cd; +#endif +#endif + +#ifdef GLK +#include "glk/alan2/alan2.h" +#include "glk/alan2/glkio.h" +#include "glk/alan2/sysdep.h" +#endif + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ +static void switches( + unsigned argc, + char *argv[] +) +#else +static void switches(argc, argv) + unsigned argc; + char *argv[]; +#endif +{ + uint i; + + advnam = ""; + for (i = 1; i < argc; i++) { + if (argv[i][0] == '-') { +#ifdef GLK + switch (g_vm->glk_char_to_lower(argv[i][1])) { +#else + switch (tolower(argv[i][1])) { +#endif + case 'i': + errflg = FALSE; + break; + case 't': + trcflg = TRUE; + break; + case 'd': + dbgflg = TRUE; + break; + case 's': + trcflg = TRUE; + stpflg = TRUE; + break; + case 'l': + logflg = TRUE; + break; + case 'v': + verbose = TRUE; + break; + case 'n': + statusflg = FALSE; + break; + default: + printf("Unrecognized switch, -%c\n", argv[i][1]); + usage(); + terminate(0); + } + } else { + advnam = argv[i]; + if (strcmp(&advnam[strlen(advnam)-4], ".acd") == 0 + || strcmp(&advnam[strlen(advnam)-4], ".ACD") == 0 + || strcmp(&advnam[strlen(advnam)-4], ".dat") == 0 + || strcmp(&advnam[strlen(advnam)-4], ".DAT") == 0) + advnam[strlen(advnam)-4] = '\0'; + } + } +} + + + +#ifdef __amiga__ + +#include +#include + +#include +#include +#include + +#include + +extern struct Library *IconBase; + +#ifndef AZTEC_C +/* Actually Geek Gadgets GCC with libnix */ + +/* Aztec C has its own pre-main wbparse which was used in Arun 2.7, with GCC we + need to do it ourselves. */ + +#include + +extern unsigned long *__stdfiledes; /* The libnix standard I/O file descriptors */ + +void +wb_parse(void) +{ + char *cp; + struct DiskObject *dop; + struct FileHandle *fhp; + + if (_WBenchMsg->sm_NumArgs == 1) /* If no argument use program icon/info */ + dop = GetDiskObject((UBYTE *)_WBenchMsg->sm_ArgList[0].wa_Name); + else { + BPTR olddir = CurrentDir(_WBenchMsg->sm_ArgList[1].wa_Lock); + dop = GetDiskObject((UBYTE *)_WBenchMsg->sm_ArgList[1].wa_Name); + CurrentDir(olddir); + } + if (dop != 0 && (cp = (char *)FindToolType((UBYTE **)dop->do_ToolTypes, + (UBYTE *)"WINDOW")) != NULL) + ; + else /* Could not find a WINDOW tool type */ + cp = "CON:10/10/480/160/Arun:Default Window/CLOSE"; + if ((window = Open((UBYTE *)cp, (long)MODE_OLDFILE))) { + fhp = (struct FileHandle *) ((long)window << 2); + SetConsoleTask(fhp->fh_Type); + SelectInput(window); + SelectOutput(window); + __stdfiledes[0] = Input(); + __stdfiledes[1] = Output(); + } else + exit(-1L); + FreeDiskObject(dop); +} +#endif +#endif + + +#ifdef _PROTOTYPES_ +void args( + int argc, + char * argv[] +) +#else +void args(argc, argv) + int argc; + char *argv[]; +#endif +{ + char *prgnam; + +#ifdef __mac__ +#include +#ifdef __MWERKS__ +#include +#endif + short msg, files; + static char advbuf[256], prgbuf[256]; + /*AppFile af;*/ + OSErr oe; + +#ifdef __MWERKS__ + /*SIOUXSettings.setupmenus = FALSE;*/ + SIOUXSettings.autocloseonquit = FALSE; + SIOUXSettings.asktosaveonclose = FALSE; + SIOUXSettings.showstatusline = FALSE; +#endif + + GetMacArgs(advbuf); + advnam = advbuf; + +#else +#ifdef __amiga__ + + if (argc == 0) { /* If started from Workbench get WbArgs : Aztec C & GG GCC */ + struct WBStartup *WBstart; + + if ((IconBase = OpenLibrary("icon.library", 0)) == NULL) + syserr("Could not open 'icon.library'"); + /* If started from WB normal main is called with argc == 0 and argv = WBstartup message */ + WBstart = (struct WBStartup *)argv; +#ifndef AZTEC_C + /* Geek Gadgets GCC */ + wb_parse(); +#endif + advnam = prgnam = WBstart->sm_ArgList[0].wa_Name; + if (WBstart->sm_NumArgs > 0) { + cd = CurrentDir(DupLock(WBstart->sm_ArgList[1].wa_Lock)); + advnam = WBstart->sm_ArgList[1].wa_Name; + } + /* Possibly other tooltypes ... */ + } else { + /* Started from a CLI */ + if ((prgnam = strrchr(argv[0], '/')) == NULL + && (prgnam = strrchr(argv[0], ':')) == NULL) + prgnam = argv[0]; + else + prgnam++; + /* Now look at the switches and arguments */ + switches(argc, argv); + if (advnam[0] == '\0') + /* No game given, try program name */ + if (stricmp(prgnam, PROGNAME) != 0 + && strstr(prgnam, PROGNAME) == 0) + advnam = strdup(argv[0]); + } +#else +#if defined(__dos__) || defined(__win__) + if ((prgnam = strrchr(argv[0], '\\')) == NULL + && (prgnam = strrchr(argv[0], '/')) == NULL + && (prgnam = strrchr(argv[0], ':')) == NULL) + prgnam = argv[0]; + else + prgnam++; + if (strlen(prgnam) > 4 + && (strcmp(&prgnam[strlen(prgnam)-4], ".EXE") == 0 + || strcmp(&prgnam[strlen(prgnam)-4], ".exe") == 0)) + prgnam[strlen(prgnam)-4] = '\0'; + /* Now look at the switches and arguments */ + switches(argc, argv); + if (advnam[0] == '\0') + /* No game given, try program name */ + if (stricmp(prgnam, PROGNAME) != 0 + && strstr(prgnam, PROGNAME) == 0) + advnam = strdup(argv[0]); +#else +#if defined __vms__ + if ((prgnam = strrchr(argv[0], ']')) == NULL + && (prgnam = strrchr(argv[0], '>')) == NULL + && (prgnam = strrchr(argv[0], ':')) == NULL) + prgnam = argv[0]; + else + prgnam++; + if (strrchr(prgnam, ';') != NULL) + *strrchr(prgnam, ';') = '\0'; + if (strlen(prgnam) > 4 + && (strcmp(&prgnam[strlen(prgnam)-4], ".EXE") == 0 + || strcmp(&prgnam[strlen(prgnam)-4], ".exe") == 0)) + prgnam[strlen(prgnam)-4] = '\0'; + /* Now look at the switches and arguments */ + switches(argc, argv); + if (advnam[0] == '\0') + /* No game given, try program name */ + if (strcmp(prgnam, PROGNAME) != 0 + && strstr(prgnam, PROGNAME) == 0) + advnam = strdup(argv[0]); +#else +#if defined(__unix__) || defined(__APPLE__) + if ((prgnam = strrchr(argv[0], '/')) == NULL) + prgnam = strdup(argv[0]); + else + prgnam = strdup(&prgnam[1]); + if (strrchr(prgnam, ';') != NULL) + *strrchr(prgnam, ';') = '\0'; + /* Now look at the switches and arguments */ + switches(argc, argv); + if (advnam[0] == '\0') + /* No game given, try program name */ + if (strcmp(prgnam, PROGNAME) != 0 + && strstr(prgnam, PROGNAME) == 0) + advnam = strdup(argv[0]); +#else + Unimplemented OS! +#endif +#endif +#endif +#endif +#endif +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/args.h b/engines/glk/alan2/args.h new file mode 100644 index 0000000000..a86d5197fe --- /dev/null +++ b/engines/glk/alan2/args.h @@ -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. + * + */ + +#ifndef GLK_ALAN2_ARGS +#define GLK_ALAN2_ARGS + +/* Handles the various startup methods on all machines. + * + * Main function args() will set up global variable advnam and the flags, + * the terminal will also be set up and connected. + */ + +#include "glk/alan2/types.h" + +namespace Glk { +namespace Alan2 { + +#ifndef PROGNAME +#define PROGNAME "alan2" +#endif + +#ifdef _PROTOTYPES_ +extern void args(int argc, char *argv[]); +#else +extern void args(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/debug.cpp b/engines/glk/alan2/debug.cpp new file mode 100644 index 0000000000..dc353c7729 --- /dev/null +++ b/engines/glk/alan2/debug.cpp @@ -0,0 +1,506 @@ +/* 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/alan2/types.h" +#ifdef HAVE_SHORT_FILENAMES +#include "glk/alan2/av.h" +#else +#include "glk/alan2/alan_version.h" +#endif + +#ifdef USE_READLINE +#include "glk/alan2/readline.h" +#endif + +#include "glk/alan2/inter.h" +#include "glk/alan2/main.h" +#include "glk/alan2/parse.h" +#include "glk/alan2/exe.h" + +#include "glk/alan2/debug.h" + +#ifdef GLK +#include "glk/alan2/glkio.h" +#endif + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ +static void showatrs( + Aword atradr +) +#else +static void showatrs(atradr) + Aword atradr; +#endif +{ + AtrElem *at; + int i; + char str[80]; + + if (atradr == 0) return; + + i = 1; + for (at = (AtrElem *) addrTo(atradr); !endOfTable(at); at++) { + sprintf(str, "$i%3ld: %ld (%s)", (long) i, (unsigned long) at->val, (char *) addrTo(at->stradr)); +#if ISO == 0 + fromIso(str, str); +#endif + output(str); + i++; + } +} + + +#ifdef _PROTOTYPES_ +static void showobjs(void) +#else +static void showobjs() +#endif +{ + char str[80]; + int obj; + + output("OBJECTS:"); + for (obj = OBJMIN; obj <= OBJMAX; obj++) { + sprintf(str, "$i%3ld: ", (long) obj); + output(str); + say(obj); + } +} + + +#ifdef _PROTOTYPES_ +static void showobj( + int obj +) +#else +static void showobj(obj) + int obj; +#endif +{ + char str[80]; +#define OBJ (obj-OBJMIN) + + + if (!isObj(obj)) { + sprintf(str, "Object number out of range. Between %ld and %ld, please.", (unsigned long) OBJMIN, (unsigned long) OBJMAX); + output(str); + return; + } + + sprintf(str, "OBJECT %d :", obj); + output(str); + say(obj); + + sprintf(str, "$iLocation = %ld", (unsigned long) where(obj)); + output(str); + if (isLoc(objs[OBJ].loc)) + say(objs[OBJ].loc); + else if (isCnt(objs[OBJ].loc)) { + if (isObj(objs[OBJ].loc)) { + output("in"); + say(objs[OBJ].loc); + } else if (isAct(objs[OBJ].loc)) { + output("carried by"); + say(objs[OBJ].loc); + } else + interpret(cnts[objs[OBJ].loc-CNTMIN].nam); + } else if (objs[OBJ].loc == 0) + output("nowhere"); + else + output("Illegal location!"); + + + output("$iAttributes ="); + showatrs(objs[OBJ].atrs); + +#undef OBJ +} + + +#ifdef _PROTOTYPES_ +static void showcnts(void) +#else +static void showcnts() +#endif +{ + char str[80]; + int cnt; +#define CNT (cnt-CNTMIN) + + output("CONTAINERS:"); + for (cnt = CNTMIN; cnt <= CNTMAX; cnt++) { + sprintf(str, "$i%3ld: ", (long) cnt); + output(str); + if (cnts[CNT].nam != 0) + interpret(cnts[CNT].nam); + if (cnts[CNT].parent != 0) + say(cnts[CNT].parent); + } + +#undef CNT +} + + +#ifdef _PROTOTYPES_ +static void showcnt( + int cnt +) +#else +static void showcnt(cnt) + int cnt; +#endif +{ + char str[80]; + int i; + Abool found = FALSE; +#define CNT (cnt-CNTMIN) + + if (cnt < CNTMIN || cnt > CNTMAX) { + sprintf(str, "Container number out of range. Between %ld and %ld, please.", (unsigned long) CNTMIN, (unsigned long) CNTMAX); + output(str); + return; + } + + sprintf(str, "CONTAINER %d :", cnt); + output(str); + if (cnts[CNT].nam != 0) + interpret(cnts[CNT].nam); + if (cnts[CNT].parent != 0) { + cnt = cnts[CNT].parent; + say(cnt); + sprintf(str, "$iLocation = %ld", (unsigned long) where(cnt)); + output(str); + } + output("$iContains "); + for (i = OBJMIN; i <= OBJMAX; i++) { + if (in(i, cnt)) { /* Yes, it's in this container */ + if (!found) { + output("$n"); + found = TRUE; + } + sprintf(str, "$t$t%d: ", i); + output(str); + say(i); + } + } + if (!found) + output("nothing"); + +#undef CNT +} + + +#ifdef _PROTOTYPES_ +static void showlocs(void) +#else +static void showlocs() +#endif +{ + char str[80]; + int loc; + + output("LOCATIONS:"); + for (loc = LOCMIN; loc <= LOCMAX; loc++) { + sprintf(str, "$i%3ld: ", (long) loc); + output(str); + say(loc); + } +} + + +#ifdef _PROTOTYPES_ +static void showloc( + int loc +) +#else +static void showloc(loc) + int loc; +#endif +{ + char str[80]; + + + if (!isLoc(loc)) { + sprintf(str, "Location number out of range. Between %ld and %ld, please.", (unsigned long) LOCMIN, (unsigned long) LOCMAX); + output(str); + return; + } + + sprintf(str, "LOCATION %d :", loc); + output(str); + say(loc); + + output("$iAttributes ="); + showatrs(locs[loc-LOCMIN].atrs); +} + + +#ifdef _PROTOTYPES_ +static void showacts(void) +#else +static void showacts() +#endif +{ + char str[80]; + int act; + + output("ACTORS:"); + for (act = ACTMIN; act <= ACTMAX; act++) { + sprintf(str, "$i%3ld:", (long) act); + output(str); + say(act); + } +} + + +#ifdef _PROTOTYPES_ +static void showact( + int act +) +#else +static void showact(act) + int act; +#endif +{ + char str[80]; + Boolean oldstp; + + if (!isAct(act)) { + sprintf(str, "Actor number out of range. Between %ld and %ld, please.", (unsigned long) ACTMIN, (unsigned long) ACTMAX); + output(str); + return; + } + + sprintf(str, "ACTOR %d :", act); + output(str); + oldstp = stpflg; stpflg = FALSE; /* Make sure not to trace this! */ + say(act); + stpflg = oldstp; + + sprintf(str, "$iLocation = %ld", (unsigned long) acts[act-ACTMIN].loc); + output(str); + if (isLoc(acts[act-ACTMIN].loc)) + say(acts[act-ACTMIN].loc); + else if (acts[act-ACTMIN].loc == 0) + output("nowhere"); + else + output("Illegal location!"); + + sprintf(str, "$iScript = %ld", (unsigned long) acts[act-ACTMIN].script); + output(str); + + sprintf(str, "$iStep = %ld", (unsigned long) acts[act-ACTMIN].step); + output(str); + + output("$iAttributes ="); + showatrs(acts[act-ACTMIN].atrs); +} + + +#ifdef _PROTOTYPES_ +static void showevts(void) +#else +static void showevts() +#endif +{ + int evt, i; + char str[80]; + Boolean scheduled; + + output("EVENTS:"); + for (evt = EVTMIN; evt <= EVTMAX; evt++) { + sprintf(str, "$i%d (%s):", evt, (char *)addrTo(evts[evt-EVTMIN].stradr)); +#if ISO == 0 + fromIso(str, str); +#endif + output(str); + scheduled = FALSE; + for (i = 0; i < etop; i++) + if ((scheduled = (eventq[i].event == evt))) + break; + if (scheduled) { + sprintf(str, "Scheduled for +%d, at ", eventq[i].time-cur.tick); + output(str); + say(eventq[i].where); + } else + output("Not scheduled."); + } +} + + +static Boolean trc, stp; +static int loc; + +#ifdef _PROTOTYPES_ +void saveInfo(void) +#else +void saveInfo() +#endif +{ + /* Save some important things */ + trc = trcflg; trcflg = FALSE; + stp = stpflg; stpflg = FALSE; + loc = cur.loc; cur.loc = where(HERO); +} + +#ifdef _PROTOTYPES_ +void restoreInfo(void) +#else +void restoreInfo() +#endif +{ + /* Restore! */ + trcflg = trc; + stpflg = stp; + cur.loc = loc; +} + + +#ifdef _PROTOTYPES_ +void debug(void) +#else +void debug() +#endif +{ + char buf[256]; + char c; + int i; + + saveInfo(); + while (TRUE) { + if (anyOutput) + para(); + do { + output("ABUG> "); +#ifdef USE_READLINE + (void) readline(buf); +#else + fgets(buf, 255, stdin); +#endif + lin = 1; + c = buf[0]; + i = 0; + sscanf(&buf[1], "%d", &i); + } while (buf && c == '\0'); + + switch (toUpper(c)) { + case 'H': + case '?': + output(alan.longHeader); + output("$nABUG Commands:\ + $iO [n] -- show object[s]\ + $iA [n] -- show actor[s]\ + $iL [n] -- show location[s]\ + $iC [n] -- show container[s]\ + $iE -- show events\ + $iG -- go on\ + $iT -- toggle trace mode\ + $iS -- toggle step mode\ + $iX -- exit debug mode\ + $iQ -- quit game"); + break; + case 'Q': + terminate(0); + case 'X': + dbgflg = FALSE; /* Fall through to 'G' */ + case 'G': + restoreInfo(); + return; + case 'O': + if (i == 0) + showobjs(); + else + showobj(i); + break; + case 'C': + if (i == 0) + showcnts(); + else + showcnt(i); + break; + case 'A': + if (i == 0) + showacts(); + else + showact(i); + break; + case 'L': + if (i == 0) + showlocs(); + else + showloc(i); + break; + case 'E': + showevts(); + break; + case 'S': + if ((stp = !stp)) + printf("Step on."); + else + printf("Step off."); + break; + case 'T': + if ((trc = !trc)) + printf("Trace on."); + else + printf("Trace off."); + break; + default: + output("Unknown ABUG command. ? for help."); + break; + } + } +} + + +/*====================================================================== + + debugsay() + + Say somethin, but make sure we don't disturb anything and that it is + shown to the player. + +*/ +#ifdef _PROTOTYPES_ +void debugsay(int item) +#else +void debugsay(item) + int item; +#endif +{ + saveInfo(); + needsp = FALSE; + col = 1; + if (item == 0) + printf("$null$"); + else + say(item); + needsp = FALSE; + col = 1; + restoreInfo(); +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/debug.h b/engines/glk/alan2/debug.h new file mode 100644 index 0000000000..aac870ec42 --- /dev/null +++ b/engines/glk/alan2/debug.h @@ -0,0 +1,47 @@ +/* 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. + * + */ + +/* TYPES */ + +#ifndef GLK_ALAN2_DEBUG +#define GLK_ALAN2_DEBUG + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ + +extern void saveInfo(void); +extern void restoreInfo(void); +extern void debug(void); +extern void debugsay(int item); +#else +extern void saveInfo(); +extern void restoreInfo(); +extern void debug(); +extern void debugsay(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/decode.cpp b/engines/glk/alan2/decode.cpp new file mode 100644 index 0000000000..4ffdc2f3b9 --- /dev/null +++ b/engines/glk/alan2/decode.cpp @@ -0,0 +1,193 @@ +/* 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 +#include "glk/alan2/main.h" +#include "glk/alan2/decode.h" + +namespace Glk { +namespace Alan2 { + +/* Bit output */ +static int decodeBuffer; /* Bits to be input */ +static int bitsToGo; /* Bits still in buffer */ +static int garbageBits; /* Bits past EOF */ + + +#ifdef _PROTOTYPES_ +static int inputBit(void) +#else +static int inputBit() +#endif +{ + int bit; + + if (!bitsToGo) { /* More bits available ? */ + decodeBuffer = txtfil->readByte(); /* No, so get more */ + if (decodeBuffer == EOF) { + garbageBits++; + if (garbageBits > VALUEBITS-2) + syserr("Error in encoded data file."); + } else + bitsToGo = 8; /* Another Char, 8 new bits */ + } + bit = decodeBuffer&1; /* Get next bit */ + decodeBuffer = decodeBuffer>>1; /* and remove it */ + bitsToGo--; + return bit; +} + + +/* Current state of decoding */ + +static CodeValue value; /* Currently seen code value */ +static CodeValue low, high; /* Current code region */ + + +#ifdef _PROTOTYPES_ +void startDecoding(void) +#else +void startDecoding() +#endif +{ + int i; + + bitsToGo = 0; + garbageBits = 0; + + value = 0; + for (i = 0; i < VALUEBITS; i++) + value = 2*value + inputBit(); + low = 0; + high = TOPVALUE; +} + + +#ifdef _PROTOTYPES_ +int decodeChar(void) +#else +int decodeChar() +#endif +{ + long range; + int f; + int symbol; + + range = (long)(high-low) + 1; + f = (((long)(value-low)+1)*freq[0]-1)/range; + + /* Find the symbol */ + for (symbol = 1; (int)freq[symbol] > f; symbol++); + + high = low + range*freq[symbol-1]/freq[0]-1; + low = low + range*freq[symbol]/freq[0]; + + for (;;) { + if (high < HALF) + ; + else if (low >= HALF) { + value = value - HALF; + low = low - HALF; + high = high - HALF; + } else if (low >= ONEQUARTER && high < THREEQUARTER) { + value = value - ONEQUARTER; + low = low - ONEQUARTER; + high = high - ONEQUARTER; + } else + break; + + /* Scale up the range */ + low = 2*low; + high = 2*high+1; + value = 2*value + inputBit(); + } + return symbol-1; +} + + + +/* Structure for saved decode info */ +typedef struct DecodeInfo { + long fpos; + int buffer; + int bits; + CodeValue value; + CodeValue high; + CodeValue low; +} DecodeInfo; + + +/*====================================================================== + + pushDecode() + + Save so much info about the decoding process so it is possible to + restore and continue later. + + */ +#ifdef _PROTOTYPES_ +void *pushDecode(void) +#else +void *pushDecode() +#endif +{ + DecodeInfo *info; + + info = (DecodeInfo *) allocate(sizeof(DecodeInfo)); + info->fpos = txtfil->pos(); + info->buffer = decodeBuffer; + info->bits = bitsToGo; + info->value = value; + info->high = high; + info->low = low; + return(info); +} + + +/*====================================================================== + + popDecode() + + Restore enough info about the decoding process so it is possible to + continue after having decoded something else. + + */ +#ifdef _PROTOTYPES_ +void popDecode(void *i) +#else +void popDecode(i) + void *i; +#endif +{ + DecodeInfo *info = (DecodeInfo *) i; + fseek(txtfil, info->fpos, 0); + decodeBuffer = info->buffer; + bitsToGo = info->bits; + value = info->value; + high = info->high; + low = info->low; + + free(info); +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/decode.h b/engines/glk/alan2/decode.h new file mode 100644 index 0000000000..7ce15b41de --- /dev/null +++ b/engines/glk/alan2/decode.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 GLK_ALAN2_DECODE +#define GLK_ALAN2_DECODE + +#include "glk/alan2/types.h" + +/* Arithmetic decoding module in Arun + */ + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ +extern void startDecoding(void); +extern int decodeChar(void); +extern void *pushDecode(void); +extern void popDecode(void *info); +#else +extern void startDecoding(); +extern int decodeChar(); +extern void *pushDecode(); +extern void popDecode(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/exe.cpp b/engines/glk/alan2/exe.cpp new file mode 100644 index 0000000000..1cccf3d32d --- /dev/null +++ b/engines/glk/alan2/exe.cpp @@ -0,0 +1,1845 @@ +/* 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/alan2/types.h" +#include "glk/alan2/alan2.h" + +#ifdef USE_READLINE +#include "glk/alan2/readline.h" +#endif + +#include "glk/alan2/main.h" +#include "glk/alan2/parse.h" +#include "glk/alan2/inter.h" +#include "glk/alan2/stack.h" +#include "glk/alan2/decode.h" + +#include "glk/alan2/exe.h" + +namespace Glk { +namespace Alan2 { + +#define WIDTH 80 + +#define N_EVTS 100 + + +/* PUBLIC DATA */ + +/* The event queue */ +EvtqElem eventq[N_EVTS]; /* Event queue */ +int etop = 0; /* Event queue top pointer */ + +Boolean looking = FALSE; /* LOOKING? flag */ + +int dscrstkp = 0; /* Describe-stack pointer */ + + +#ifdef _PROTOTYPES_ +void dscrobjs(void); +void dscracts(void); +#else +void dscrobjs(); +void dscracts(); +#endif + + + +#ifdef _PROTOTYPES_ +void print(Aword fpos, Aword len) +#else +void print(fpos, len) + Aword fpos, len; +#endif +{ + char str[2*WIDTH]; /* String buffer */ + int outlen = 0; /* Current output length */ + int ch; + int i; + long savfp; /* Temporary saved text file position */ + static Boolean printFlag = FALSE; /* Printing already? */ + Boolean savedPrintFlag = printFlag; + void *info; /* Saved decoding info */ + + + if (len == 0) return; + + if (isHere(HERO)) { /* Check if the player will see it */ + if (printFlag) { /* Already printing? */ + /* Save current text file position and/or decoding info */ + if (header->pack) + info = pushDecode(); + else + savfp = ftell(txtfil); + } + printFlag = TRUE; /* We're printing now! */ + fseek(txtfil, fpos, 0); /* Position to start of text */ + if (header->pack) + startDecoding(); + for (outlen = 0; outlen != (int)len; outlen = outlen + strlen(str)) { + /* Fill the buffer from the beginning */ + for (i = 0; i <= WIDTH || (i > WIDTH && ch != ' '); i++) { + if (outlen + i == (int)len) /* No more characters? */ + break; + if (header->pack) + ch = decodeChar(); + else + ch = getc(txtfil); + if (ch == EOFChar) /* Or end of text? */ + break; + str[i] = ch; + } + str[i] = '\0'; +#if ISO == 0 + fromIso(str, str); +#endif + output(str); + } + /* And restore */ + printFlag = savedPrintFlag; + if (printFlag) { + if (header->pack) + popDecode(info); + else + fseek(txtfil, savfp, 0); + } + } +} + + +#ifdef _PROTOTYPES_ +void sys(Aword fpos, Aword len) +#else +void sys(fpos, len) + Aword fpos, len; +#endif +{ +#ifdef GLK + ::error("system calls aren't supported"); +#else + char *command; + + getstr(fpos, len); /* Returns address to string on stack */ + command = (char *)pop(); + int tmp = system(command); + free(command); +#endif +} + + +#ifdef _PROTOTYPES_ +void getstr(Aword fpos, Aword len) +#else +void getstr(fpos, len) + Aword fpos, len; +#endif +{ + char *buf = (char *)allocate(len+1); + + push((Aptr) buf); /* Push the address to the string */ + fseek(txtfil, fpos, 0); /* Position to start of text */ + if (header->pack) + startDecoding(); + while (len--) + if (header->pack) + *(buf++) = decodeChar(); + else + *(buf++) = getc(txtfil); + *buf = '\0'; +} + + + +#ifdef _PROTOTYPES_ +void score(Aword sc) +#else +void score(sc) + Aword sc; +#endif +{ + char buf[80]; + + if (sc == 0) { + prmsg(M_SCORE1); + sprintf(buf, "%d", cur.score); + output(buf); + prmsg(M_SCORE2); + sprintf(buf, "%ld.", (unsigned long) header->maxscore); + output(buf); + } else { + cur.score += scores[sc-1]; + scores[sc-1] = 0; + } +} + +#ifdef _PROTOTYPES_ +void visits(Aword v) +#else +void visits(v) + Aword v; +#endif +{ + cur.visits = v; +} + + +#ifdef _PROTOTYPES_ +Boolean confirm(MsgKind msgno) +#else +Boolean confirm(msgno) + MsgKind msgno; +#endif +{ + char buf[80]; + + /* This is a bit of a hack since we really want to compare the input, + it could be affirmative, but for now any input is NOT! */ + prmsg(msgno); + +#ifdef USE_READLINE + if (!readline(buf)) return TRUE; +#else + if (gets(buf) == NULL) return TRUE; +#endif + col = 1; + + return (buf[0] == '\0'); +} + + +#ifdef _PROTOTYPES_ +void quit(void) +#else +void quit() +#endif +{ + char buf[80]; + char choices[10]; + + para(); + while (TRUE) { + col = 1; + statusline(); + prmsg(M_QUITACTION); +#ifdef USE_READLINE + if (!readline(buf)) terminate(0); +#else + if (gets(buf) == NULL) terminate(0); +#endif + if (strcmp(buf, "restart") == 0) + //longjmp(restart_label, TRUE); + ::error("TODO: restart"); + else if (strcmp(buf, "restore") == 0) { + restore(); + return; + } else if (strcmp(buf, "quit") == 0) + terminate(0); + } + syserr("Fallthrough in QUIT"); +} + + + +#ifdef _PROTOTYPES_ +void restart(void) +#else +void restart() +#endif +{ + para(); + if (confirm(M_REALLY)) { + //longjmp(restart_label, TRUE); + ::error("TODO: restart"); + } else + return; + syserr("Fallthrough in RESTART"); +} + + + +#ifdef _PROTOTYPES_ +void cancl(Aword evt) +#else +void cancl(evt) + Aword evt; +#endif +{ + int i; + + for(i = etop-1; i>=0; i--) + if (eventq[i].event == evt) { + while (i < etop-1) { + eventq[i].event = eventq[i+1].event; + eventq[i].time = eventq[i+1].time; + eventq[i].where = eventq[i+1].where; + i++; + } + etop--; + return; + } +} + + +#ifdef _PROTOTYPES_ +void schedule(Aword evt, Aword whr, Aword aft) +#else +void schedule(evt, whr, aft) + Aword evt, whr, aft; +#endif +{ int i; + int time; + + cancl(evt); + /* Check for overflow */ + if (etop == N_EVTS) syserr("Out of event space."); + + time = cur.tick+aft; + + /* Bubble this event down */ + for (i = etop; i >= 1 && eventq[i-1].time <= time; i--) { + eventq[i].event = eventq[i-1].event; + eventq[i].time = eventq[i-1].time; + eventq[i].where = eventq[i-1].where; + } + + eventq[i].time = time; + eventq[i].where = whr; + eventq[i].event = evt; + etop++; +} + + +/*---------------------------------------------------------------------- + + getatr() + + Get an attribute value from an attribute list + + */ +#ifdef _PROTOTYPES_ +static Aptr getatr( + Aaddr atradr, /* IN - ACODE address to attribute table */ + Aaddr atr /* IN - The attribute to read */ +) +#else +static Aptr getatr(atradr, atr) + Aaddr atradr; /* IN - ACODE address to attribute table */ + Aaddr atr; /* IN - The attribute to read */ +#endif +{ + AtrElem *at; + + at = (AtrElem *) addrTo(atradr); + return at[atr-1].val; +} + + +/*---------------------------------------------------------------------- + + setatr() + + Set a particular attribute to a value. + + */ +#ifdef _PROTOTYPES_ +static void setatr( + Aaddr atradr, /* IN - ACODE address to attribute table */ + Aword atr, /* IN - attribute code */ + Aword val /* IN - new value */ +) +#else +static void setatr(atradr, atr, val) + Aaddr atradr; /* IN - ACODE address to attribute table */ + Aword atr; /* IN - attribute code */ + Aword val; /* IN - new value */ +#endif +{ + AtrElem *at; + + at = (AtrElem *) addrTo(atradr); + at[atr-1].val = val; +} + + +/*---------------------------------------------------------------------- + + make() + + */ + +#ifdef _PROTOTYPES_ +static void makloc(Aword loc, Aword atr, Aword val) +#else +static void makloc(loc, atr, val) + Aword loc, atr, val; +#endif +{ + setatr(locs[loc-LOCMIN].atrs, atr, val); +} + +#ifdef _PROTOTYPES_ +static void makobj(Aword obj, Aword atr, Aword val) +#else +static void makobj(obj, atr, val) + Aword obj, atr, val; +#endif +{ + setatr(objs[obj-OBJMIN].atrs, atr, val); +} + +#ifdef _PROTOTYPES_ +static void makact(Aword act, Aword atr, Aword val) +#else +static void makact(act, atr, val) + Aword act, atr, val; +#endif +{ + setatr(acts[act-ACTMIN].atrs, atr, val); +} + + +#ifdef _PROTOTYPES_ +void make(Aword id, Aword atr, Aword val) +#else +void make(id, atr, val) + Aword id, atr, val; +#endif +{ + char str[80]; + + if (isObj(id)) + makobj(id, atr, val); + else if (isLoc(id)) + makloc(id, atr, val); + else if (isAct(id)) + makact(id, atr, val); + else { + sprintf(str, "Can't MAKE item (%ld).", (unsigned long) id); + syserr(str); + } +} + + +/*---------------------------------------------------------------------------- + + set() + + */ + +#ifdef _PROTOTYPES_ +static void setloc(Aword loc, Aword atr, Aword val) +#else +static void setloc(loc, atr, val) + Aword loc, atr, val; +#endif +{ + setatr(locs[loc-LOCMIN].atrs, atr, val); + locs[loc-LOCMIN].describe = 0; +} + + +#ifdef _PROTOTYPES_ +static void setobj(Aword obj, Aword atr, Aword val) +#else +static void setobj(obj, atr, val) + Aword obj, atr, val; +#endif +{ + setatr(objs[obj-OBJMIN].atrs, atr, val); +} + +#ifdef _PROTOTYPES_ +static void setact(Aword act, Aword atr, Aword val) +#else +static void setact(act, atr, val) + Aword act, atr, val; +#endif +{ + setatr(acts[act-ACTMIN].atrs, atr, val); +} + + +#ifdef _PROTOTYPES_ +void set(Aword id, Aword atr, Aword val) +#else +void set(id, atr, val) + Aword id, atr, val; +#endif +{ + char str[80]; + + if (isObj(id)) + setobj(id, atr, val); + else if (isLoc(id)) + setloc(id, atr, val); + else if (isAct(id)) + setact(id, atr, val); + else { + sprintf(str, "Can't SET item (%ld).", (unsigned long) id); + syserr(str); + } +} + + +#ifdef _PROTOTYPES_ +void setstr(Aword id, Aword atr, Aword str) +#else +void setstr(id, atr, str) + Aword id, atr, str; +#endif +{ + free((char *)attribute(id, atr)); + set(id, atr, str); +} + + + +/*----------------------------------------------------------------------------- + + incr/decr + + */ + +/*---------------------------------------------------------------------- + + incratr() + + Increment a particular attribute by a value. + + */ +#ifdef _PROTOTYPES_ +static void incratr( + Aaddr atradr, /* IN - ACODE address to attribute table */ + Aword atr, /* IN - attribute code */ + Aword step /* IN - step to increment by */ +) +#else +static void incratr(atradr, atr, step) + Aaddr atradr, atr, step; +#endif +{ + AtrElem *at; + + at = (AtrElem *) addrTo(atradr); + at[atr-1].val += step; +} + + +#ifdef _PROTOTYPES_ +static void incrloc(Aword loc, Aword atr, Aword step) +#else +static void incrloc(loc, atr, step) + Aword loc, atr, step; +#endif +{ + incratr(locs[loc-LOCMIN].atrs, atr, step); + locs[loc-LOCMIN].describe = 0; +} + + +#ifdef _PROTOTYPES_ +static void incrobj(Aword obj, Aword atr, Aword step) +#else +static void incrobj(obj, atr, step) + Aword obj, atr, step; +#endif +{ + incratr(objs[obj-OBJMIN].atrs, atr, step); +} + +#ifdef _PROTOTYPES_ +static void incract(Aword act, Aword atr, Aword step) +#else +static void incract(act, atr, step) + Aword act, atr, step; +#endif +{ + incratr(acts[act-ACTMIN].atrs, atr, step); +} + + +#ifdef _PROTOTYPES_ +void incr(Aword id, Aword atr, Aword step) +#else +void incr(id, atr, step) + Aword id, atr, step; +#endif +{ + char str[80]; + + if (isObj(id)) + incrobj(id, atr, step); + else if (isLoc(id)) + incrloc(id, atr, step); + else if (isAct(id)) + incract(id, atr, step); + else { + sprintf(str, "Can't INCR item (%ld).", (unsigned long) id); + syserr(str); + } +} + +#ifdef _PROTOTYPES_ +void decr(Aword id, Aword atr, Aword step) +#else +void decr(id, atr, step) + Aword id, atr, step; +#endif +{ + char str[80]; + + if (isObj(id)) + incrobj(id, atr, -step); + else if (isLoc(id)) + incrloc(id, atr, -step); + else if (isAct(id)) + incract(id, atr, -step); + else { + sprintf(str, "Can't DECR item (%ld).", (unsigned long) id); + syserr(str); + } +} + + + +/*---------------------------------------------------------------------- + + attribute() + + */ + +#ifdef _PROTOTYPES_ +static Aptr locatr(Aword loc, Aword atr) +#else +static Aptr locatr(loc, atr) + Aword loc, atr; +#endif +{ + return getatr(locs[loc-LOCMIN].atrs, atr); +} + + + +#ifdef _PROTOTYPES_ +static Aptr objatr(Aword obj, Aword atr) +#else +static Aptr objatr(obj, atr) + Aword obj, atr; +#endif +{ + return getatr(objs[obj-OBJMIN].atrs, atr); +} + +#ifdef _PROTOTYPES_ +static Aptr actatr(Aword act, Aword atr) +#else +static Aptr actatr(act, atr) + Aword act, atr; +#endif +{ + return getatr(acts[act-ACTMIN].atrs, atr); +} + +#ifdef _PROTOTYPES_ +static Aptr litatr(Aword lit, Aword atr) +#else +static Aptr litatr(lit, atr) + Aword lit, atr; +#endif +{ + char str[80]; + + if (atr == 1) + return litValues[lit-LITMIN].value; + else { + sprintf(str, "Unknown attribute for literal (%ld).", (unsigned long) atr); + syserr(str); + } + return (Aptr)EOF; +} + + +#ifdef _PROTOTYPES_ +Aptr attribute(Aword id, Aword atr) +#else +Aptr attribute(id, atr) + Aword id, atr; +#endif +{ + char str[80]; + + if (isObj(id)) + return objatr(id, atr); + else if (isLoc(id)) + return locatr(id, atr); + else if (isAct(id)) + return actatr(id, atr); + else if (isLit(id)) + return litatr(id, atr); + else { + sprintf(str, "Can't ATTRIBUTE item (%ld).", (unsigned long) id); + syserr(str); + } + return (Aptr)EOF; +} + + +#ifdef _PROTOTYPES_ +Aptr strattr(Aword id, Aword atr) +#else +Aptr strattr(id, atr) + Aword id, atr; +#endif +{ + return (Aptr) strdup((char *)attribute(id, atr)); +} + + +/*---------------------------------------------------------------------- + + where() + + */ + +#ifdef _PROTOTYPES_ +static Aword objloc(Aword obj) +#else +static Aword objloc(obj) + Aword obj; +#endif +{ + if (isCnt(objs[obj-OBJMIN].loc)) /* In something ? */ + if (isObj(objs[obj-OBJMIN].loc) || isAct(objs[obj-OBJMIN].loc)) + return(where(objs[obj-OBJMIN].loc)); + else /* Containers not anywhere is where the hero is! */ + return(where(HERO)); + else + return(objs[obj-OBJMIN].loc); +} + + +#ifdef _PROTOTYPES_ +static Aword actloc(Aword act) +#else +static Aword actloc(act) + Aword act; +#endif +{ + return(acts[act-ACTMIN].loc); +} + + +#ifdef _PROTOTYPES_ +Aword where(Aword id) +#else +Aword where(id) + Aword id; +#endif +{ + char str[80]; + + if (isObj(id)) + return objloc(id); + else if (isAct(id)) + return actloc(id); + else { + sprintf(str, "Can't WHERE item (%ld).", (unsigned long) id); + syserr(str); + } + return (Aptr)EOF; +} + + + +/*---------------------------------------------------------------------- + + aggregates + + */ + +#ifdef _PROTOTYPES_ +Aint agrmax(Aword atr, Aword whr) +#else +Aint agrmax(atr, whr) + Aword atr, whr; +#endif +{ + Aword i; + Aint max = 0; + + for (i = OBJMIN; i <= OBJMAX; i++) { + if (isLoc(whr)) { + if (where(i) == whr && attribute(i, atr) > max) + max = attribute(i, atr); + } else if (objs[i-OBJMIN].loc == whr && attribute(i, atr) > max) + max = attribute(i, atr); + } + return(max); +} + +#ifdef _PROTOTYPES_ +Aint agrsum(Aword atr, Aword whr) +#else +Aint agrsum(atr, whr) + Aword atr, whr; +#endif +{ + Aword i; + Aint sum = 0; + + for (i = OBJMIN; i <= OBJMAX; i++) { + if (isLoc(whr)) { + if (where(i) == whr) + sum += attribute(i, atr); + } else if (objs[i-OBJMIN].loc == whr) + sum += attribute(i, atr); + } + return(sum); +} + + +#ifdef _PROTOTYPES_ +Aint agrcount(Aword whr) +#else +Aint agrcount(whr) + Aword whr; +#endif +{ + Aword i; + Aword count = 0; + + for (i = OBJMIN; i <= OBJMAX; i++) { + if (isLoc(whr)) { + if (where(i) == whr) + count++; + } else if (objs[i-OBJMIN].loc == whr) + count++; + } + return(count); +} + + +/*---------------------------------------------------------------------- + + locate() + + */ + +#ifdef _PROTOTYPES_ +static void locobj(Aword obj, Aword whr) +#else +static void locobj(obj, whr) + Aword obj, whr; +#endif +{ + if (isCnt(whr)) { /* Into a container */ + if (whr == obj) + syserr("Locating something inside itself."); + if (checklim(whr, obj)) + return; + else + objs[obj-OBJMIN].loc = whr; + } else { + objs[obj-OBJMIN].loc = whr; + /* Make sure the location is described since it's changed */ + locs[whr-LOCMIN].describe = 0; + } +} + + +#ifdef _PROTOTYPES_ +static void locact(Aword act, Aword whr) +#else +static void locact(act, whr) + Aword act, whr; +#endif +{ + Aword prevact = cur.act; + Aword prevloc = cur.loc; + + cur.loc = whr; + acts[act-ACTMIN].loc = whr; + if (act == HERO) { + if (locs[acts[act-ACTMIN].loc-LOCMIN].describe % (cur.visits+1) == 0) + look(); + else { + if (anyOutput) + para(); + say(where(HERO)); + prmsg(M_AGAIN); + newline(); + dscrobjs(); + dscracts(); + } + locs[where(HERO)-LOCMIN].describe++; + locs[where(HERO)-LOCMIN].describe %= (cur.visits+1); + } else + locs[whr-LOCMIN].describe = 0; + if (locs[cur.loc-LOCMIN].does != 0) { + cur.act = act; + interpret(locs[cur.loc-LOCMIN].does); + cur.act = prevact; + } + + if (cur.act != act) + cur.loc = prevloc; +} + + +#ifdef _PROTOTYPES_ +void locate(Aword id, Aword whr) +#else +void locate(id, whr) + Aword id, whr; +#endif +{ + char str[80]; + + if (isObj(id)) + locobj(id, whr); + else if (isAct(id)) + locact(id, whr); + else { + sprintf(str, "Can't LOCATE item (%ld).", (unsigned long) id); + syserr(str); + } +} + + +/*---------------------------------------------------------------------- + + isHere() + + */ + +#ifdef _PROTOTYPES_ +static Abool objhere(Aword obj) +#else +static Abool objhere(obj) + Aword obj; +#endif +{ + if (isCnt(objs[obj-OBJMIN].loc)) { /* In something? */ + if (isObj(objs[obj-OBJMIN].loc) || isAct(objs[obj-OBJMIN].loc)) + return(isHere(objs[obj-OBJMIN].loc)); + else /* If the container wasn't anywhere, assume where HERO is! */ + return(where(HERO) == cur.loc); + } else + return(objs[obj-OBJMIN].loc == cur.loc); +} + + +#ifdef _PROTOTYPES_ +static Aword acthere(Aword act) +#else +static Aword acthere(act) + Aword act; +#endif +{ + return(acts[act-ACTMIN].loc == cur.loc); +} + + +#ifdef _PROTOTYPES_ +Abool isHere(Aword id) +#else +Abool isHere(id) + Aword id; +#endif +{ + char str[80]; + + if (isObj(id)) + return objhere(id); + else if (isAct(id)) + return acthere(id); + else { + sprintf(str, "Can't HERE item (%ld).", (unsigned long) id); + syserr(str); + } + return (Abool)EOF; +} + +/*---------------------------------------------------------------------- + + isNear() + + */ + +#ifdef _PROTOTYPES_ +static Aword objnear(Aword obj) +#else +static Aword objnear(obj) + Aword obj; +#endif +{ + if (isCnt(objs[obj-OBJMIN].loc)) { /* In something? */ + if (isObj(objs[obj-OBJMIN].loc) || isAct(objs[obj-OBJMIN].loc)) + return(isNear(objs[obj-OBJMIN].loc)); + else /* If the container wasn't anywhere, assume here, so not nearby! */ + return(FALSE); + } else + return(exitto(where(obj), cur.loc)); +} + + +#ifdef _PROTOTYPES_ +static Aword actnear(Aword act) +#else +static Aword actnear(act) + Aword act; +#endif +{ + return(exitto(where(act), cur.loc)); +} + + +#ifdef _PROTOTYPES_ +Abool isNear(Aword id) +#else +Abool isNear(id) + Aword id; +#endif +{ + char str[80]; + + if (isObj(id)) + return objnear(id); + else if (isAct(id)) + return actnear(id); + else { + sprintf(str, "Can't NEAR item (%ld).", (unsigned long) id); + syserr(str); + } + return (Abool)EOF; +} + + + +/*---------------------------------------------------------------------- + + in() + + */ + +#ifdef _PROTOTYPES_ +Abool in(Aword obj, Aword cnt) +#else +Abool in(obj, cnt) + Aword obj; + Aword cnt; +#endif +{ + if (!isObj(obj)) + return(FALSE); + if (!isCnt(cnt)) + syserr("IN in a non-container."); + + return(objs[obj-OBJMIN].loc == cnt); +} + + +/*---------------------------------------------------------------------- + + say() + + */ + +#ifdef _PROTOTYPES_ +static void sayloc(Aword loc) +#else +static void sayloc(loc) + Aword loc; +#endif +{ + interpret(locs[loc-LOCMIN].nams); +} + + +#ifdef _PROTOTYPES_ +static void sayobj(Aword obj) +#else +static void sayobj(obj) + Aword obj; +#endif +{ + interpret(objs[obj-OBJMIN].dscr2); +} + +#ifdef _PROTOTYPES_ +static void sayact(Aword act) +#else +static void sayact(act) + Aword act; +#endif +{ + interpret(acts[act-ACTMIN].nam); +} + + +#ifdef _PROTOTYPES_ +void sayint(Aword val) +#else +void sayint(val) + Aword val; +#endif +{ + char buf[25]; + + if (isHere(HERO)) { + sprintf(buf, "%ld", (unsigned long) val); + output(buf); + } +} + + +#ifdef _PROTOTYPES_ +void saystr(char *str) +#else +void saystr(str) + char *str; +#endif +{ + if (isHere(HERO)) + output(str); + free(str); +} + + +#ifdef _PROTOTYPES_ +static void saylit(Aword lit) +#else +static void saylit(lit) + Aword lit; +#endif +{ + char *str; + + if (isNum(lit)) + sayint(litValues[lit-LITMIN].value); + else { + str = (char *)strdup((char *)litValues[lit-LITMIN].value); + saystr(str); + } +} + + +#ifdef _PROTOTYPES_ +void sayarticle(Aword id) +#else +void sayarticle(id) + Aword id; +#endif +{ + if (!isObj(id)) + syserr("Trying to say article of something *not* an object."); + if (objs[id-OBJMIN].art != 0) + interpret(objs[id-OBJMIN].art); + else + prmsg(M_ARTICLE); +} + + +#ifdef _PROTOTYPES_ +void say(Aword id) +#else +void say(id) + Aword id; +#endif +{ + char str[80]; + + if (isHere(HERO)) { + if (isObj(id)) + sayobj(id); + else if (isLoc(id)) + sayloc(id); + else if (isAct(id)) + sayact(id); + else if (isLit(id)) + saylit(id); + else { + sprintf(str, "Can't SAY item (%ld).", (unsigned long) id); + syserr(str); + } + } +} + + +/*---------------------------------------------------------------------- + + describe() + + */ + +#ifdef _PROTOTYPES_ +static void dscrloc(Aword loc) +#else +static void dscrloc(loc) + Aword loc; +#endif +{ + if (locs[loc-LOCMIN].dscr != 0) + interpret(locs[loc-LOCMIN].dscr); +} + + +#ifdef _PROTOTYPES_ +static void dscrobj(Aword obj) +#else +static void dscrobj(obj) + Aword obj; +#endif +{ + objs[obj-OBJMIN].describe = FALSE; + if (objs[obj-OBJMIN].dscr1 != 0) + interpret(objs[obj-OBJMIN].dscr1); + else { + prmsg(M_SEEOBJ1); + sayarticle(obj); + say(obj); + prmsg(M_SEEOBJ4); + if (objs[obj-OBJMIN].cont != 0) + list(obj); + } +} + + +#ifdef _PROTOTYPES_ +static void dscract(Aword act) +#else +static void dscract(act) + Aword act; +#endif +{ + ScrElem *scr = NULL; + + if (acts[act-ACTMIN].script != 0) { + for (scr = (ScrElem *) addrTo(acts[act-ACTMIN].scradr); !endOfTable(scr); scr++) + if (scr->code == acts[act-ACTMIN].script) + break; + if (endOfTable(scr)) scr = NULL; + } + if (scr != NULL && scr->dscr != 0) + interpret(scr->dscr); + else if (acts[act-ACTMIN].dscr != 0) + interpret(acts[act-ACTMIN].dscr); + else { + interpret(acts[act-ACTMIN].nam); + prmsg(M_SEEACT); + } + acts[act-ACTMIN].describe = FALSE; +} + + +static Aword dscrstk[255]; + +#ifdef _PROTOTYPES_ +void describe(Aword id) +#else +void describe(id) + Aword id; +#endif +{ + int i; + char str[80]; + + for (i = 0; i < dscrstkp; i++) + if (dscrstk[i] == id) + syserr("Recursive DESCRIBE."); + dscrstk[dscrstkp++] = id; + + if (isObj(id)) + dscrobj(id); + else if (isLoc(id)) + dscrloc(id); + else if (isAct(id)) + dscract(id); + else { + sprintf(str, "Can't DESCRIBE item (%ld).", (unsigned long) id); + syserr(str); + } + + dscrstkp--; +} + + +/*---------------------------------------------------------------------- + + use() + + */ + +#ifdef _PROTOTYPES_ +void use(Aword act, Aword scr) +#else +void use(act, scr) + Aword act, scr; +#endif +{ + char str[80]; + + if (!isAct(act)) { + sprintf(str, "Item is not an Actor (%ld).", (unsigned long) act); + syserr(str); + } + + acts[act-ACTMIN].script = scr; + acts[act-ACTMIN].step = 0; +} + + + +/*---------------------------------------------------------------------- + + list() + + */ + +#ifdef _PROTOTYPES_ +void list(Aword cnt) +#else +void list(cnt) + Aword cnt; +#endif +{ + int i; + Aword props; + Aword prevobj; + Boolean found = FALSE; + Boolean multiple = FALSE; + + /* Find container properties */ + if (isObj(cnt)) + props = objs[cnt-OBJMIN].cont; + else if (isAct(cnt)) + props = acts[cnt-ACTMIN].cont; + else + props = cnt; + + for (i = OBJMIN; i <= OBJMAX; i++) { + if (in(i, cnt)) { /* Yes, it's in this container */ + if (!found) { + found = TRUE; + if (cnts[props-CNTMIN].header != 0) + interpret(cnts[props-CNTMIN].header); + else { + prmsg(M_CONTAINS1); + if (cnts[props-CNTMIN].nam != 0) /* It has it's own name */ + interpret(cnts[props-CNTMIN].nam); + else + say(cnts[props-CNTMIN].parent); /* It is actually an object or actor */ + prmsg(M_CONTAINS2); + } + } else { + if (multiple) { + needsp = FALSE; + prmsg(M_CONTAINS3); + } + multiple = TRUE; + sayarticle(prevobj); + say(prevobj); + } + prevobj = i; + } + } + + if (found) { + if (multiple) + prmsg(M_CONTAINS4); + sayarticle(prevobj); + say(prevobj); + prmsg(M_CONTAINS5); + } else { + if (cnts[props-CNTMIN].empty != 0) + interpret(cnts[props-CNTMIN].empty); + else { + prmsg(M_EMPTY1); + if (cnts[props-CNTMIN].nam != 0) /* It has it's own name */ + interpret(cnts[props-CNTMIN].nam); + else + say(cnts[props-CNTMIN].parent); /* It is actually an actor or object */ + prmsg(M_EMPTY2); + } + } + needsp = TRUE; +} + + +/*---------------------------------------------------------------------- + + empty() + + */ + +#ifdef _PROTOTYPES_ +void empty(Aword cnt, Aword whr) +#else +void empty(cnt, whr) + Aword cnt; + Aword whr; +#endif +{ + int i; + + for (i = OBJMIN; i <= OBJMAX; i++) + if (in(i, cnt)) + locate(i, whr); +} + + + +/*----------------------------------------------------------------------*\ + + Description of current location + + dscrobjs() + dscracts() + look() + +\*----------------------------------------------------------------------*/ + +#ifdef _PROTOTYPES_ +void dscrobjs(void) +#else +void dscrobjs() +#endif +{ + int i; + int prevobj; + Boolean found = FALSE; + Boolean multiple = FALSE; + + /* First describe everything here with its own description */ + for (i = OBJMIN; i <= OBJMAX; i++) + if (objs[i-OBJMIN].loc == cur.loc && + objs[i-OBJMIN].describe && + objs[i-OBJMIN].dscr1) + describe(i); + + /* Then list everything else here */ + for (i = OBJMIN; i <= OBJMAX; i++) + if (objs[i-OBJMIN].loc == cur.loc && + objs[i-OBJMIN].describe) { + if (!found) { + prmsg(M_SEEOBJ1); + sayarticle(i); + say(i); + found = TRUE; + } else { + if (multiple) { + needsp = FALSE; + prmsg(M_SEEOBJ2); + sayarticle(prevobj); + say(prevobj); + } + multiple = TRUE; + } + prevobj = i; + } + + if (found) { + if (multiple) { + prmsg(M_SEEOBJ3); + sayarticle(prevobj); + say(prevobj); + } + prmsg(M_SEEOBJ4); + } + + /* Set describe flag for all objects */ + for (i = OBJMIN; i <= OBJMAX; i++) + objs[i-OBJMIN].describe = TRUE; +} + + +#ifdef _PROTOTYPES_ +void dscracts(void) +#else +void dscracts() +#endif +{ + int i; + + for (i = HERO+1; i <= ACTMAX; i++) + if (acts[i-ACTMIN].loc == cur.loc && + acts[i-ACTMIN].describe) + describe(i); + + /* Set describe flag for all actors */ + for (i = HERO; i <= ACTMAX; i++) + acts[i-ACTMIN].describe = TRUE; +} + + +#ifdef _PROTOTYPES_ +void look(void) +#else +void look() +#endif +{ + int i; + + if (looking) + syserr("Recursive LOOK."); + + looking = TRUE; + /* Set describe flag for all objects and actors */ + for (i = OBJMIN; i <= OBJMAX; i++) + objs[i-OBJMIN].describe = TRUE; + for (i = ACTMIN; i <= ACTMAX; i++) + acts[i-ACTMIN].describe = TRUE; + + if (anyOutput) + para(); + +g_vm->glk_set_style(style_Subheader); +needsp = FALSE; + say(cur.loc); + needsp = FALSE; + output("."); +g_vm->glk_set_style(style_Normal); + newline(); +needsp = FALSE; + describe(cur.loc); + dscrobjs(); + dscracts(); + looking = FALSE; +} + + + +static char savfnm[256]; + + +/*---------------------------------------------------------------------- + + save() + + */ + +#ifdef GARGLK +void save() { + g_vm->saveGame(); +} + +#else + +#ifdef _PROTOTYPES_ +void save(void) +#else +void save() +#endif +{ + int i; + char str[256]; + AtrElem *atr; + FILE *savfil; + + /* First save ? */ + if (savfnm[0] == '\0') { + strcpy(savfnm, advnam); + strcat(savfnm, ".sav"); + } + prmsg(M_SAVEWHERE); + sprintf(str, "(%s) : ", savfnm); + output(str); + +#ifdef USE_READLINE + readline(str); +#else + gets(str); +#endif + +frefid_t fref; +fref = g_vm->glk_fileref_create_by_prompt(fileusage_SavedGame, filemode_Write, 0); +if (fref == NULL) + error(M_SAVEFAILED); +strcpy(str, g_vm->garglk_fileref_get_name(fref)); +g_vm->glk_fileref_destroy(fref); + + if (str[0] == '\0') + strcpy(str, savfnm); + col = 1; + if ((savfil = fopen(str, READ_MODE)) != NULL) + /* It already existed */ + if (!confirm(M_SAVEOVERWRITE)) + error(MSGMAX); /* Return to player without saying anything */ + if ((savfil = fopen(str, WRITE_MODE)) == NULL) + error(M_SAVEFAILED); + strcpy(savfnm, str); + + /* Save version of interpreter and name of game */ + fwrite((void *)&header->vers, sizeof(Aword), 1, savfil); + fwrite((void *)advnam, strlen(advnam)+1, 1, savfil); + /* Save current values */ + fwrite((void *)&cur, sizeof(cur), 1, savfil); + /* Save actors */ + for (i = ACTMIN; i <= ACTMAX; i++) { + fwrite((void *)&acts[i-ACTMIN].loc, sizeof(Aword), 1, savfil); + fwrite((void *)&acts[i-ACTMIN].script, sizeof(Aword), 1, savfil); + fwrite((void *)&acts[i-ACTMIN].step, sizeof(Aword), 1, savfil); + fwrite((void *)&acts[i-ACTMIN].count, sizeof(Aword), 1, savfil); + if (acts[i-ACTMIN].atrs) + for (atr = (AtrElem *) addrTo(acts[i-ACTMIN].atrs); !endOfTable(atr); atr++) + fwrite((void *)&atr->val, sizeof(Aword), 1, savfil); + } + + /* Save locations */ + for (i = LOCMIN; i <= LOCMAX; i++) { + fwrite((void *)&locs[i-LOCMIN].describe, sizeof(Aword), 1, savfil); + if (locs[i-LOCMIN].atrs) + for (atr = (AtrElem *) addrTo(locs[i-LOCMIN].atrs); !endOfTable(atr); atr++) + fwrite((void *)&atr->val, sizeof(Aword), 1, savfil); + } + + /* Save objects */ + for (i = OBJMIN; i <= OBJMAX; i++) { + fwrite((void *)&objs[i-OBJMIN].loc, sizeof(Aword), 1, savfil); + if (objs[i-OBJMIN].atrs) + for (atr = (AtrElem *) addrTo(objs[i-OBJMIN].atrs); !endOfTable(atr); atr++) + fwrite((void *)&atr->val, sizeof(atr->val), 1, savfil); + } + + /* Save the event queue */ + eventq[etop].time = 0; /* Mark the top */ + fwrite((void *)&eventq[0], sizeof(eventq[0]), etop+1, savfil); + + /* Save scores */ + for (i = 0; scores[i] != EOF; i++) + fwrite((void *)&scores[i], sizeof(Aword), 1, savfil); + + fclose(savfil); +} +#endif + +/*---------------------------------------------------------------------- + + restore() + + */ + +#ifdef GARGLK +void restore() { + g_vm->loadGame(); +} + +#else + +#ifdef _PROTOTYPES_ +void restore(void) +#else +void restore() +#endif +{ + int i,tmp; + FILE *savfil; + char str[256]; + AtrElem *atr; + char savedVersion[4]; + char savedName[256]; + + /* First save ? */ + if (savfnm[0] == '\0') { + strcpy(savfnm, advnam); + strcat(savfnm, ".sav"); + } + prmsg(M_RESTOREFROM); + sprintf(str, "(%s) : ", savfnm); + output(str); +#ifdef USE_READLINE + readline(str); +#else + gets(str); +#endif + + if (str[0] == '\0') + strcpy(str, savfnm); + col = 1; + if (str[0] == '\0') + strcpy(str, savfnm); /* Use the name temporarily */ + if ((savfil = fopen(str, READ_MODE)) == NULL) + error(M_SAVEMISSING); + strcpy(savfnm, str); /* Save it for future use */ + + tmp = fread((void *)&savedVersion, sizeof(Aword), 1, savfil); + /* 4f - save file version check doesn't seem to work on PC's! */ + if (strncmp(savedVersion, header->vers, 4)) { + fclose(savfil); + error(M_SAVEVERS); + return; + } + i = 0; + while ((savedName[i++] = fgetc(savfil)) != '\0'); + if (strcmp(savedName, advnam) != 0) { + fclose(savfil); + error(M_SAVENAME); + return; + } + + /* Restore current values */ + tmp = fread((void *)&cur, sizeof(cur), 1, savfil); + /* Restore actors */ + for (i = ACTMIN; i <= ACTMAX; i++) { + tmp = fread((void *)&acts[i-ACTMIN].loc, sizeof(Aword), 1, savfil); + tmp = fread((void *)&acts[i-ACTMIN].script, sizeof(Aword), 1, savfil); + tmp = fread((void *)&acts[i-ACTMIN].step, sizeof(Aword), 1, savfil); + tmp = fread((void *)&acts[i-ACTMIN].count, sizeof(Aword), 1, savfil); + if (acts[i-ACTMIN].atrs) + for (atr = (AtrElem *) addrTo(acts[i-ACTMIN].atrs); !endOfTable(atr); atr++) + tmp = fread((void *)&atr->val, sizeof(Aword), 1, savfil); + } + + /* Restore locations */ + for (i = LOCMIN; i <= LOCMAX; i++) { + tmp = fread((void *)&locs[i-LOCMIN].describe, sizeof(Aword), 1, savfil); + if (locs[i-LOCMIN].atrs) + for (atr = (AtrElem *) addrTo(locs[i-LOCMIN].atrs); !endOfTable(atr); atr++) + tmp = fread((void *)&atr->val, sizeof(Aword), 1, savfil); + } + + /* Restore objects */ + for (i = OBJMIN; i <= OBJMAX; i++) { + tmp = fread((void *)&objs[i-OBJMIN].loc, sizeof(Aword), 1, savfil); + if (objs[i-OBJMIN].atrs) + for (atr = (AtrElem *) addrTo(objs[i-OBJMIN].atrs); !endOfTable(atr); atr++) + tmp = fread((void *)&atr->val, sizeof(atr->val), 1, savfil); + } + + /* Restore the eventq */ + etop = 0; + do { + tmp = fread((void *)&eventq[etop], sizeof(eventq[0]), 1, savfil); + etop++; + } while (eventq[etop-1].time != 0); + etop--; + + /* Restore scores */ + for (i = 0; scores[i] != EOF; i++) + tmp = fread((void *)&scores[i], sizeof(Aword), 1, savfil); + + fclose(savfil); +} + +#endif + +/*---------------------------------------------------------------------- + + rnd() + + */ + +#ifdef _PROTOTYPES_ +Aword rnd(Aword from, Aword to) +#else +Aword rnd(from, to) + Aword from, to; +#endif +{ + if (to == from) + return to; + else if (to > from) + return (rand()/10)%(to-from+1)+from; + else + return (rand()/10)%(from-to+1)+to; +} + +/*---------------------------------------------------------------------- + + btw() + + BETWEEN + + */ + +#ifdef _PROTOTYPES_ +Abool btw(Aint val, Aint low, Aint high) +#else +Abool btw(val, low, high) + Aint val, low, high; +#endif +{ + if (high > low) + return low <= val && val <= high; + else + return high <= val && val <= low; +} + + + +/*---------------------------------------------------------------------- + + contains() + + */ + +#ifdef _PROTOTYPES_ +Aword contains(Aptr string, Aptr substring) +#else +Aword contains(string, substring) + Aptr string, substring;; +#endif +{ + Abool found; + + strlow((char *)string); + strlow((char *)substring); + + found = (strstr((char *)string, (char *)substring) != 0); + + free((char *)string); + free((char *)substring); + + return(found); +} + + + +/*---------------------------------------------------------------------- + + streq() + + Compare two strings approximately, ignore case + + */ +#ifdef _PROTOTYPES_ +Abool streq(char a[], char b[]) +#else +Abool streq(a, b) + char a[], b[]; /* IN - Strings to compare */ +#endif +{ + Boolean eq; + + strlow(a); + strlow(b); + + eq = (strcmp(a, b) == 0); + + free(a); + free(b); + + return(eq); +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/exe.h b/engines/glk/alan2/exe.h new file mode 100644 index 0000000000..0acfdda6eb --- /dev/null +++ b/engines/glk/alan2/exe.h @@ -0,0 +1,127 @@ +/* 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 GLK_ALAN2_EXE +#define GLK_ALAN2_EXE + +/* Header file for instruction execution unit in Alan interpreter + */ + +namespace Glk { +namespace Alan2 { + +/* The event queue */ +extern EvtqElem eventq[]; /* Event queue */ +extern int etop; /* Event queue top pointer */ +extern Boolean looking; /* LOOKING? flag */ +extern int dscrstkp; /* Point into describe stack */ + +#ifdef _PROTOTYPES_ +extern void sys(Aword fpos, Aword len); +extern Boolean confirm(MsgKind msgno); +extern Aptr attribute(Aword item, Aword atr); +extern void say(Aword item); +extern void saynum(Aword num); +extern void saystr(char *str); +extern Aptr strattr(Aword id, Aword atr); +extern void setstr(Aword id, Aword atr, Aword str); +extern void getstr(Aword fpos, Aword len); +extern void print(Aword fpos, Aword len); +extern void look(void); +extern void make(Aword id, Aword atr, Aword val); +extern void set(Aword id, Aword atr, Aword val); +extern void incr(Aword id, Aword atr, Aword step); +extern void decr(Aword id, Aword atr, Aword step); +extern void use(Aword act, Aword scr); +extern void describe(Aword id); +extern void list(Aword cnt); +extern void locate(Aword id, Aword whr); +extern void empty(Aword cnt, Aword whr); +extern void score(Aword sc); +extern void visits(Aword v); +extern void schedule(Aword evt, Aword whr, Aword aft); +extern void cancl(Aword evt); +extern void quit(void); +extern void restart(void); +extern void save(void); +extern void restore(void); +extern void say(Aword id); +extern void sayint(Aword val); +extern Aword rnd(Aword from, Aword to); +extern Abool btw(Aint val, Aint from, Aint to); +extern Aword contains(Aptr string, Aptr substring); +extern Abool streq(char a[], char b[]); +extern Abool in(Aword obj, Aword cnt); +extern Aword where(Aword item); +extern Aint agrmax(Aword atr, Aword whr); +extern Aint agrsum(Aword atr, Aword whr); +extern Aint agrcount(Aword whr); +extern Abool isHere(Aword item); +extern Abool isNear(Aword item); + +#else +extern void sys(); +extern Boolean confirm(); +extern Aptr attribute(); +extern void say(); +extern void saynum(); +extern void saystr(); +extern Aptr strattr(); +extern void setstr(); +extern void getstr(); +extern void print(); +extern void look(); +extern void make(); +extern void set(); +extern void incr(); +extern void decr(); +extern void use(); +extern void describe(); +extern void list(); +extern void locate(); +extern void empty(); +extern void score(); +extern void visits(); +extern void schedule(); +extern void cancl(); +extern void quit(); +extern void restart(); +extern void save(); +extern void restore(); +extern void say(); +extern void sayint(); +extern Aword rnd(); +extern Abool btw(); +extern Aword contains() +extern Abool streq(); +extern Abool in(); +extern Aword where(); +extern Aword agrmax(); +extern Aword agrsum(); +extern Abool isHere(); +extern Abool isNear(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/glkio.cpp b/engines/glk/alan2/glkio.cpp new file mode 100644 index 0000000000..346413170c --- /dev/null +++ b/engines/glk/alan2/glkio.cpp @@ -0,0 +1,47 @@ +/* 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/glk.h" +#include "glk/alan2/alan2.h" +#include "glk/alan2/glkio.h" + +namespace Glk { +namespace Alan2 { + +void glkio_printf(char *fmt, ...) { + va_list argp; + va_start(argp, fmt); + if (glkMainWin) { + char buf[1024]; /* FIXME: buf size should be foolproof */ + vsprintf(buf, fmt, argp); + g_vm->glk_put_string(buf); + } else { + // assume stdio is available in this case only + Common::String str = Common::String::vformat(fmt, argp); + warning(fmt, argp); + } + + va_end(argp); +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/glkio.h b/engines/glk/alan2/glkio.h new file mode 100644 index 0000000000..7dca2cab87 --- /dev/null +++ b/engines/glk/alan2/glkio.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 GLK_ALAN2_GLKIO +#define GLK_ALAN2_GLKIO + +/* Header file for Glk output for Alan interpreter + */ + +#include "glk/windows.h" + +namespace Glk { +namespace Alan2 { + +winid_t glkMainWin; +winid_t glkStatusWin; + +/* NB: this header must be included in any file which calls print() */ + +#define print glkio_printf +#undef printf +#define printf glkio_printf + +void glkio_printf(char *, ...); + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/glkstart.cpp b/engines/glk/alan2/glkstart.cpp new file mode 100644 index 0000000000..1119e18bf0 --- /dev/null +++ b/engines/glk/alan2/glkstart.cpp @@ -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. + * + */ + +#include "glk/alan2/alan2.h" +#include "glk/alan2/glkstart.h" +#include "glk/alan2/glkio.h" +#include "glk/alan2/args.h" + +#include "glk/alan2/alan_version.h" + +namespace Glk { +namespace Alan2 { + +glkunix_argumentlist_t glkunix_arguments[] = { + { "-v", glkunix_arg_NoValue, "-v: verbose mode" }, + { "-l", glkunix_arg_NoValue, "-l: log player command and game output" }, + { "-i", glkunix_arg_NoValue, "-i: ignore version and checksum errors" }, + { "-d", glkunix_arg_NoValue, "-d: enter debug mode" }, + { "-t", glkunix_arg_NoValue, "-t: trace game execution" }, + { "-s", glkunix_arg_NoValue, "-s: single instruction trace" }, + { "", glkunix_arg_ValueFollows, "filename: The game file to load." }, + { NULL, glkunix_arg_End, NULL } +}; + +bool glkunix_startup_code(glkunix_startup_t *data) { + // first, open a window for error output + glkMainWin = g_vm->glk_window_open(0, 0, 0, wintype_TextBuffer, 0); + if (glkMainWin == nullptr) + error("FATAL ERROR: Cannot open initial window"); + + g_vm->glk_stylehint_set(wintype_TextGrid, style_User1, stylehint_ReverseColor, 1); + glkStatusWin = g_vm->glk_window_open(glkMainWin, winmethod_Above | + winmethod_Fixed, 1, wintype_TextGrid, 0); + g_vm->glk_set_window(glkMainWin); + + /* now process the command line arguments */ + args(data->argc, data->argv); + + g_vm->garglk_set_program_name(alan.shortHeader); + g_vm->garglk_set_program_info("Alan Interpreter 2.8.6 by Thomas Nilsson\n"); + + return true; +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/glkstart.h b/engines/glk/alan2/glkstart.h new file mode 100644 index 0000000000..7e3a24b4dc --- /dev/null +++ b/engines/glk/alan2/glkstart.h @@ -0,0 +1,70 @@ +/* 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 GLK_ALAN2_GLK_START +#define GLK_ALAN2_GLK_START + +/* This header defines an interface that must be used by program linked + with the various Unix Glk libraries -- at least, the three I wrote. + (I encourage anyone writing a Unix Glk library to use this interface, + but it's not part of the Glk spec.) + + Because Glk is *almost* perfectly portable, this interface *almost* + doesn't have to exist. In practice, it's small. +*/ + +namespace Glk { +namespace Alan2 { + +#define glkunix_arg_End (0) +#define glkunix_arg_ValueFollows (1) +#define glkunix_arg_NoValue (2) +#define glkunix_arg_ValueCanFollow (3) +#define glkunix_arg_NumberValue (4) + +typedef struct glkunix_argumentlist_struct { + char *name; + int argtype; + char *desc; +} glkunix_argumentlist_t; + +typedef struct glkunix_startup_struct { + int argc; + char **argv; +} glkunix_startup_t; + +/* The list of command-line arguments; this should be defined in your code. */ +extern glkunix_argumentlist_t glkunix_arguments[]; + +/* The external function; this should be defined in your code. */ +extern bool glkunix_startup_code(glkunix_startup_t *data); + +/* Some helpful utility functions which the library makes available + to your code. Obviously, this is nonportable; so you should + only call it from glkunix_startup_code(). +*/ +extern strid_t glkunix_stream_open_pathname(char *pathname, uint textmode, uint rock); + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/inter.cpp b/engines/glk/alan2/inter.cpp new file mode 100644 index 0000000000..02b4f4819f --- /dev/null +++ b/engines/glk/alan2/inter.cpp @@ -0,0 +1,893 @@ +/* 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 +#include "glk/alan2/types.h" +#include "glk/alan2/main.h" +#include "glk/alan2/parse.h" +#include "glk/alan2/exe.h" +#include "glk/alan2/stack.h" +#include "glk/alan2/sysdep.h" + +#include "glk/alan2/inter.h" + +#ifdef GLK +#include "glk/alan2/glkio.h" +#endif + +namespace Glk { +namespace Alan2 { + +/* PRIVATE DATA */ + +static int pc; + + +#ifdef _PROTOTYPES_ +static void if_( + Aword v +) +#else +static void if_(v) + Aword v; +#endif +{ + int lev = 1; + Aword i; + + if (!v) { + /* Skip to next ELSE or ENDIF on same level */ + while (TRUE) { + i = memory[pc++]; + if (I_CLASS(i) == (Aword)C_STMOP) + switch (I_OP(i)) { + case I_ELSE: + if (lev == 1) return; + break; + case I_IF: + lev++; + break; + case I_ENDIF: + lev--; + if (lev == 0) return; + break; + } + } + } +} + + +#ifdef _PROTOTYPES_ +static void else_(void) +#else +static void else_() +#endif +{ + int lev = 1; + Aword i; + + while (TRUE) { + /* Skip to ENDIF on the same level */ + i = memory[pc++]; + if (I_CLASS(i) == (Aword)C_STMOP) + switch (I_OP(i)) { + case I_ENDIF: + lev--; + if (lev == 0) return; + break; + case I_IF: + lev++; + break; + } + } +} + + +#ifdef _PROTOTYPES_ +static void depstart(void) +#else +static void depstart(void) +#endif +{ + /* A DEPSTART was executed so skip across the redundant DEPCASE to + start at the first expression */ + pc++; +} + + +#ifdef _PROTOTYPES_ +static void swap(void) +#else +static void swap() +#endif +{ + Aptr v1 = pop(); + Aptr v2 = pop(); + + push(v1); + push(v2); +} + + + +#ifdef _PROTOTYPES_ +static void depexec( + Aword v +) +#else +static void depexec(v) + Aword v; +#endif +{ + int lev = 1; + Aword i; + + if (!v) + /* The expression was not true, skip to next CASE on the same + level which could be a DEPCASE or DEPELSE */ + while (TRUE) { + i = memory[pc++]; + if (I_CLASS(i) == (Aword)C_STMOP) + switch (I_OP(i)) { + case I_DEPSTART: + lev++; + break; + case I_DEPEND: + if (lev == 1) return; + lev--; + break; + case I_DEPCASE: + case I_DEPELSE: + if (lev == 1) return; + break; + } + } +} + + +#ifdef _PROTOTYPES_ +static void depcase(void) +#else +static void depcase() +#endif +{ + int lev = 1; + Aword i; + + /* Skip to end of DEPENDING block (next DEPEND on same level) because + we have just executed a DEPCASE/DEPELSE statement as a result of a DEPCASE + catching */ + + while (TRUE) { + i = memory[pc++]; + if (I_CLASS(i) == (Aword)C_STMOP) + switch (I_OP(i)) { + case I_DEPSTART: + lev++; + break; + case I_DEPEND: + lev--; + if (lev == 0) return; + break; + } + } +} + + +#ifdef _PROTOTYPES_ +void interpret(Aaddr adr) +#else +void interpret(adr) + Aaddr adr; +#endif +{ + Aaddr oldpc; + Aword i; + + if (stpflg) printf("\n++++++++++++++++++++++++++++++++++++++++++++++++++"); + + oldpc = pc; + pc = adr; + while(TRUE) { + if (stpflg) printf("\n%4x: ", pc); + if (pc > memTop) + syserr("Interpreting outside program."); + + i = memory[pc++]; + + switch (I_CLASS(i)) { + case C_CONST: + if (stpflg) printf("PUSH \t%5ld", I_OP(i)); + push(I_OP(i)); + break; + case C_CURVAR: + switch (I_OP(i)) { + case V_PARAM: + if (stpflg) printf("PARAM \t%5ld\t\t(%ld)", top(), params[top()-1].code); + push(params[pop()-1].code); + break; + case V_CURLOC: + if (stpflg) printf("CURLOC \t\t\t(%d)", cur.loc); + push(cur.loc); + break; + case V_CURACT: + if (stpflg) printf("CURACT \t\t\t(%d)", cur.act); + push(cur.act); + break; + case V_CURVRB: + if (stpflg) printf("CURVRB \t\t\t(%d)", cur.vrb); + push(cur.vrb); + break; + case V_SCORE: + if (stpflg) printf("CURSCORE \t\t\t(%d)", cur.score); + push(cur.score); + break; + default: + syserr("Unknown CURVAR instruction."); + break; + } + break; + + case C_STMOP: + switch (I_OP(i)) { + case I_PRINT: { + Aptr fpos, len; + fpos = pop(); + len = pop(); + if (stpflg) { + printf("PRINT \t%5ld, %5ld\t\"", fpos, len); + col = 34; /* To format it better! */ + } + print((char *)fpos, len); + if (stpflg) + printf("\""); + break; + } + case I_SYSTEM: { + Aptr fpos, len; + fpos = pop(); + len = pop(); + if (stpflg) { + printf("SYSTEM \t%5ld, %5ld\t\"", fpos, len); + col = 34; /* To format it better! */ + } + sys(fpos, len); + break; + } + case I_GETSTR: { + Aptr fpos, len; + fpos = pop(); + len = pop(); + if (stpflg) + printf("GETSTR\t%5ld, %5ld", fpos, len); + getstr(fpos, len); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_QUIT: { + if (stpflg) + printf("QUIT"); + quit(); + break; + } + case I_LOOK: { + if (stpflg) + printf("LOOK"); + look(); + break; + } + case I_SAVE: { + if (stpflg) + printf("SAVE"); + save(); + break; + } + case I_RESTORE: { + if (stpflg) + printf("RESTORE"); + restore(); + break; + } + case I_RESTART: { + if (stpflg) + printf("RESTART"); + restart(); + break; + } + case I_LIST: { + Aptr cnt; + cnt = pop(); + if (stpflg) + printf("LIST \t%5ld", cnt); + list(cnt); + break; + } + case I_EMPTY: { + Aptr cnt, whr; + cnt = pop(); + whr = pop(); + if (stpflg) + printf("EMPTY \t%5ld, %5ld", cnt, whr); + empty(cnt, whr); + break; + } + case I_SCORE: { + Aptr sc; + sc = pop(); + if (stpflg) + printf("SCORE \t%5ld\t\t(%ld)", sc, scores[sc-1]); + score(sc); + break; + } + case I_VISITS: { + Aptr v; + v = pop(); + if (stpflg) + printf("VISITS \t%5ld", v); + visits(v); + break; + } + case I_SCHEDULE: { + Aptr evt, whr, aft; + evt = pop(); + whr = pop(); + aft = pop(); + if (stpflg) + printf("SCHEDULE \t%5ld, %5ld, %5ld", evt, whr, aft); + schedule(evt, whr, aft); + break; + } + case I_CANCEL: { + Aptr evt; + evt = pop(); + if (stpflg) + printf("CANCEL \t%5ld", evt); + cancl(evt); + break; + } + case I_MAKE: { + Aptr id, atr, val; + id = pop(); + atr = pop(); + val = pop(); + if (stpflg) { + printf("MAKE \t%5ld, %5ld, ", id, atr); + if (val) printf("TRUE"); else printf("FALSE"); + } + make(id, atr, val); + break; + } + case I_SET: { + Aptr id, atr, val; + id = pop(); + atr = pop(); + val = pop(); + if (stpflg) { + printf("SET \t%5ld, %5ld, %5ld", id, atr, val); + } + set(id, atr, val); + break; + } + case I_STRSET: { + Aptr id, atr, str; + id = pop(); + atr = pop(); + str = pop(); + if (stpflg) { + printf("STRSET\t%5ld, %5ld, %5ld", id, atr, str); + } + setstr(id, atr, str); + break; + } + case I_INCR: { + Aptr id, atr, step; + id = pop(); + atr = pop(); + step = pop(); + if (stpflg) { + printf("INCR\t%5ld, %5ld, %5ld", id, atr, step); + } + incr(id, atr, step); + break; + } + case I_DECR: { + Aptr id, atr, step; + id = pop(); + atr = pop(); + step = pop(); + if (stpflg) { + printf("DECR\t%5ld, %5ld, %5ld", id, atr, step); + } + decr(id, atr, step); + break; + } + case I_ATTRIBUTE: { + Aptr id, atr; + id = pop(); + atr = pop(); + if (stpflg) + printf("ATTRIBUTE %5ld, %5ld", id, atr); + push(attribute(id, atr)); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_STRATTR: { + Aptr id, atr; + id = pop(); + atr = pop(); + if (stpflg) + printf("STRATTR \t%5ld, %5ld", id, atr); + push(strattr(id, atr)); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_LOCATE: { + Aptr id, whr; + id = pop(); + whr = pop(); + if (stpflg) + printf("LOCATE \t%5ld, %5ld", id, whr); + locate(id, whr); + break; + } + case I_WHERE: { + Aptr id; + id = pop(); + if (stpflg) + printf("WHERE \t%5ld", id); + push(where(id)); + if (stpflg) + printf("\t\t(%ld)", top()); + break; + } + case I_HERE: { + Aptr id; + id = pop(); + if (stpflg) + printf("HERE \t%5ld", id); + push(isHere(id)); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_NEAR: { + Aptr id; + id = pop(); + if (stpflg) + printf("NEAR \t%5ld", id); + push(isNear(id)); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_USE: { + Aptr act, scr; + act = pop(); + scr = pop(); + if (stpflg) + printf("USE \t%5ld, %5ld", act, scr); + use(act, scr); + break; + } + case I_IN: { + Aptr obj, cnt; + obj = pop(); + cnt = pop(); + if (stpflg) + printf("IN \t%5ld, %5ld ", obj, cnt); + push(in(obj, cnt)); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_DESCRIBE: { + Aptr id; + id = pop(); + if (stpflg) { + printf("DESCRIBE \t%5ld\t", id); + col = 34; /* To format it better! */ + } + describe(id); + break; + } + case I_SAY: { + Aptr id; + id = pop(); + if (stpflg) + printf("SAY \t%5ld\t\t\"", id); + say(id); + if (stpflg) + printf("\""); + break; + } + case I_SAYINT: { + Aptr val; + val = pop(); + if (stpflg) + printf("SAYINT\t%5ld\t\t\"", val); + sayint(val); + if (stpflg) + printf("\""); + break; + } + case I_SAYSTR: { + Aptr adr; + adr = pop(); + if (stpflg) + printf("SAYSTR\t%5ld\t\t\"", adr); + saystr((char *)adr); + if (stpflg) + printf("\""); + break; + } + case I_IF: { + Aptr v; + v = pop(); + if (stpflg) { + printf("IF \t"); + if (v) printf(" TRUE"); else printf("FALSE"); + } + if_(v); + break; + } + case I_ELSE: { + if (stpflg) + printf("ELSE"); + else_(); + break; + } + case I_ENDIF: { + if (stpflg) + printf("ENDIF"); + break; + } + case I_AND: { + Aptr lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) { + printf("AND \t"); + if (lh) printf("TRUE, "); else printf("FALSE, "); + if (rh) printf("TRUE"); else printf("FALSE"); + } + push(lh && rh); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_OR: { + Aptr lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) { + printf("OR \t"); + if (lh) printf("TRUE, "); else printf("FALSE, "); + if (rh) printf("TRUE"); else printf("FALSE"); + } + push(lh || rh); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_NE: { + Aptr lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("NE \t%5ld, %5ld", lh, rh); + push(lh != rh); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_EQ: { + Aptr lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("EQ \t%5ld, %5ld", lh, rh); + push(lh == rh); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_STREQ: { + Aptr lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("STREQ \t%5ld, %5ld", lh, rh); + push(streq((char *)lh, (char *)rh)); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_STREXACT: { + Aptr lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("STREXACT \t%5ld, %5ld", lh, rh); + push(strcmp((char *)lh, (char *)rh) == 0); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + free((void *)lh); + free((void *)rh); + break; + } + case I_LE: { + Aint lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("LE \t%5ld, %5ld", lh, rh); + push(lh <= rh); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_GE: { + Aint lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("GE \t%5ld, %5ld", lh, rh); + push(lh >= rh); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_LT: { + Aint lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("LT \t%5ld, %5ld", lh, rh); + push((signed int)lh < (signed int)rh); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_GT: { + Aint lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("GT \t%5ld, %5ld", lh, rh); + push(lh > rh); + if (stpflg) + if (top()) printf("\t(TRUE)"); else printf("\t(FALSE)"); + break; + } + case I_PLUS: { + Aint lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("PLUS \t%5ld, %5ld", lh, rh); + push(lh + rh); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_MINUS: { + Aint lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("MINUS \t%5ld, %5ld", lh, rh); + push(lh - rh); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_MULT: { + Aint lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("MULT \t%5ld, %5ld", lh, rh); + push(lh * rh); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_DIV: { + Aint lh, rh; + if (header->vers[0] == 2 && header->vers[1] == 7) /* Check for 2.7 version */ + swap(); + rh = pop(); + lh = pop(); + if (stpflg) + printf("DIV \t%5ld, %5ld", lh, rh); + push(lh / rh); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_NOT: { + Aptr val; + val = pop(); + if (stpflg) { + printf("NOT \t"); + if (val) printf("TRUE"); else printf("FALSE"); + } + push(!val); + if (stpflg) + if (top()) printf("\t\t(TRUE)"); else printf("\t\t(FALSE)"); + break; + } + case I_MAX: { + Aptr atr, whr; + atr = pop(); + whr = pop(); + if (stpflg) + printf("MAX \t%5ld, %5ld", atr, whr); + push(agrmax(atr, whr)); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_SUM: { + Aptr atr, whr; + atr = pop(); + whr = pop(); + if (stpflg) + printf("SUM \t%5ld, %5ld", atr, whr); + push(agrsum(atr, whr)); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_COUNT: { + Aptr whr; + whr = pop(); + if (stpflg) + printf("COUNT \t%5ld", whr); + push(agrcount(whr)); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_RND: { + Aptr from, to; + from = pop(); + to = pop(); + if (stpflg) + printf("RANDOM \t%5ld, %5ld", from, to); + push(rnd(from, to)); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_BTW: { + Aint low, high, val; + high = pop(); + low = pop(); + val = pop(); + if (stpflg) + printf("BETWEEN \t%5ld, %5ld, %5ld", val, low, high); + push(btw(val, low, high)); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + case I_CONTAINS: { + Aptr string, substring; + substring = pop(); + string = pop(); + if (stpflg) + printf("CONTAINS \t%5ld, %5ld", string, substring); + push(contains(string, substring)); + if (stpflg) + printf("\t(%ld)", top()); + break; + } + + case I_DEPSTART: + if (stpflg) + printf("DEPSTART"); + depstart(); + break; + + case I_DEPCASE: + if (stpflg) + printf("DEPCASE"); + depcase(); + break; + + case I_DEPEXEC: { + Aptr v; + v = pop(); + if (stpflg) { + printf("DEPEXEC \t"); + if (v) printf(" TRUE"); else printf("FALSE"); + } + depexec(v); + break; + } + + case I_DEPELSE: + if (stpflg) + printf("DEPELSE"); + depcase(); + break; + + case I_DEPEND: + if (stpflg) + printf("DEPEND"); + break; + + case I_RETURN: + if (stpflg) + printf("RETURN\n--------------------------------------------------\n"); + pc = oldpc; + return; + + default: + syserr("Unknown STMOP instruction."); + break; + } + if (fail) { + pc = oldpc; + return; + } + break; + + default: + syserr("Unknown instruction class."); + break; + } + } +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/inter.h b/engines/glk/alan2/inter.h new file mode 100644 index 0000000000..a7fafefc59 --- /dev/null +++ b/engines/glk/alan2/inter.h @@ -0,0 +1,38 @@ +/* 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 GLK_ALAN2_INTER +#define GLK_ALAN2_INTER + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ +extern void interpret(Aaddr adr); +#else +extern void interpret(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/main.h b/engines/glk/alan2/main.h new file mode 100644 index 0000000000..48c6d96382 --- /dev/null +++ b/engines/glk/alan2/main.h @@ -0,0 +1,155 @@ +/* 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 GLK_ALAN2_MAIN +#define GLK_ALAN2_MAIN + +/* Header file for main unit of ARUN Alan System interpreter */ + +#include "common/file.h" +#include "glk/alan2/types.h" + +namespace Glk { +namespace Alan2 { + +/* DATA */ + +#define MEMORYSIZE 1000L + +extern int memTop; /* Top of memory */ + +extern int conjWord; /* First conjunction in dictionary */ + +/* The Amachine memory */ +extern Aword *memory; +extern AcdHdr *header; + +/* Amachine variables */ +extern CurVars cur; + +/* Amachine data structures */ +extern WrdElem *dict; /* Dictionary pointer */ +extern ActElem *acts; /* Actor table pointer */ +extern LocElem *locs; /* Location table pointer */ +extern VrbElem *vrbs; /* Verb table pointer */ +extern StxElem *stxs; /* Syntax table pointer */ +extern ObjElem *objs; /* Object table pointer */ +extern CntElem *cnts; /* Container table pointer */ +extern RulElem *ruls; /* Rule table pointer */ +extern EvtElem *evts; /* Event table pointer */ +extern MsgElem *msgs; /* Message table pointer */ +extern Aword *scores; /* Score table pointer */ +extern Aword *freq; /* Cumulated frequencies */ + +extern int dictsize; /* Number of entries in dictionary */ + +/* The text and message file */ +extern Common::File *txtfil; +extern Common::WriteStream *logfil; + +#undef ftell +#undef fgetc +#undef getc +#undef fseek +#undef fclose +#define ftell(FP) FP->pos() +#define fgetc(FP) (FP->pos() >= FP->size()) ? EOF : FP->readByte() +#define getc(FP) (FP->pos() >= FP->size()) ? EOF : FP->readByte() +#define fseek(FP, OFS, WHENCE) FP->seek(OFS, WHENCE) +#define fclose(FP) delete FP + + +/* File names */ +extern char *advnam; + +/* Screen formatting info */ +extern int col, lin; +extern int paglen, pagwidth; + +/* Long jump buffer for restart */ +//extern jmp_buf restart_label; + +extern Boolean verbose, errflg, trcflg, dbgflg, stpflg, logflg, statusflg; +extern Boolean fail; +extern Boolean anyOutput; +extern Boolean needsp; + +#define endOfTable(x) eot((Aword *) x) + + +#ifdef _PROTOTYPES_ +extern void *allocate(unsigned long len); +extern void terminate(int code); +extern void usage(void); +extern void error(MsgKind msg); +extern void syserr(char *msg); +extern void statusline(void); +extern void output(char string[]); +extern void prmsg(MsgKind msg); +extern void para(void); +extern void newline(void); + +extern Boolean checklim(Aword cnt, Aword obj); +extern Boolean possible(void); +extern Boolean exitto(int to, int from); +extern void action(ParamElem *plst); +extern void go(int dir); + +extern Boolean eot(Aword *adr); +extern Boolean isObj(Aword x); +extern Boolean isCnt(Aword x); +extern Boolean isAct(Aword x); +extern Boolean isLoc(Aword x); +extern Boolean isLit(Aword x); +extern Boolean isNum(Aword x); +extern Boolean isStr(Aword x); + +/* Run the game! */ +extern void run(void); + +#else +extern void *allocate(); +extern void terminate(); +extern void syserr(); +extern void usage(); +extern void error(); +extern void output(); +extern void statusline(); +extern void prmsg(); +extern void print(); +extern void para(); +extern void newline(); +extern Boolean checklim(); +extern Boolean possible(); +extern Boolean eot(); +extern Boolean isObj(); +extern Boolean isCnt(); +extern Boolean isAct(); +extern Boolean isLoc(); +extern Boolean isLit(); +extern void run(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/params.cpp b/engines/glk/alan2/params.cpp new file mode 100644 index 0000000000..b8851035f2 --- /dev/null +++ b/engines/glk/alan2/params.cpp @@ -0,0 +1,159 @@ +/* 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 +#include "glk/alan2/types.h" +#include "glk/alan2/params.h" + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ +void compact(ParamElem a[]) +#else +void compact(a) + ParamElem a[]; +#endif +{ + int i, j; + + for (i = 0, j = 0; a[j].code != (Aword)EOF; j++) + if (a[j].code != 0) + a[i++] = a[j]; + a[i].code = (Aword)EOF; +} + + +#ifdef _PROTOTYPES_ +int lstlen(ParamElem a[]) +#else +int lstlen(a) + ParamElem a[]; +#endif +{ + int i = 0; + + while (a[i].code != (Aword)EOF) + i++; + return (i); +} + + +#ifdef _PROTOTYPES_ +Boolean inlst(ParamElem l[], Aword e) +#else +Boolean inlst(l, e) + ParamElem l[]; + Aword e; +#endif +{ + int i; + + for (i = 0; l[i].code != (Aword)EOF && l[i].code != e; i++); + return (l[i].code == e); +} + + +#ifdef _PROTOTYPES_ +void lstcpy(ParamElem a[], ParamElem b[]) +#else +void lstcpy(a, b) + ParamElem a[], b[]; +#endif +{ + int i; + + for (i = 0; b[i].code != (Aword)EOF; i++) + a[i] = b[i]; + a[i].code = (Aword)EOF; +} + + +#ifdef _PROTOTYPES_ +void sublst(ParamElem a[], ParamElem b[]) +#else +void sublst(a, b) + ParamElem a[], b[]; +#endif +{ + int i; + + for (i = 0; a[i].code != (Aword)EOF; i++) + if (inlst(b, a[i].code)) + a[i].code = 0; /* Mark empty */ + compact(a); +} + + +#ifdef _PROTOTYPES_ +void mrglst(ParamElem a[], ParamElem b[]) +#else +void mrglst(a, b) + ParamElem a[], b[]; +#endif +{ + int i,last; + + for (last = 0; a[last].code != (Aword)EOF; last++); /* Find end of list */ + for (i = 0; b[i].code != (Aword)EOF; i++) + if (!inlst(a, b[i].code)) { + a[last++] = b[i]; + a[last].code = (Aword)EOF; + } +} + + +#ifdef _PROTOTYPES_ +void isect(ParamElem a[], ParamElem b[]) +#else +void isect(a, b) + ParamElem a[], b[]; +#endif +{ + int i, last = 0; + + for (i = 0; a[i].code != (Aword)EOF; i++) + if (inlst(b, a[i].code)) + a[last++] = a[i]; + a[last].code = (Aword)EOF; +} + + +#ifdef _PROTOTYPES_ +void cpyrefs(ParamElem p[], Aword r[]) +#else +void cpyrefs(p, r) + ParamElem p[]; + Aword r[]; +#endif +{ + int i; + + for (i = 0; r[i] != (Aword)EOF; i++) { + p[i].code = r[i]; + p[i].firstWord = (Aword)EOF; + } + p[i].code = (Aword)EOF; +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/params.h b/engines/glk/alan2/params.h new file mode 100644 index 0000000000..82fa84be9c --- /dev/null +++ b/engines/glk/alan2/params.h @@ -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. + * + */ + +#ifndef GLK_ALAN2_PARAMS +#define GLK_ALAN2_PARAMS + +#include "glk/alan2/types.h" + +/* Various utility functions for handling parameters: + * + * compact() Compact a list, i.e remove any NULL elements + * lstlen() Count number of elements + * inlst() Check if an element is in the list + * sublst() Subract two lists + * lstcpy() Copy one list onto another + * mrglst() Merge the paramElems of one list into the first + * isect() Take the intersection of two lists + * cpyrefs() Copy the refs (in dictionary) to a paramList + */ + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ +extern void compact(ParamElem *a); +extern int lstlen(ParamElem *a); +extern Boolean inlst(ParamElem *l, Aword e); +extern void lstcpy(ParamElem *a, ParamElem *b); +extern void sublst(ParamElem *a, ParamElem *b); +extern void mrglst(ParamElem *a, ParamElem *b); +extern void isect(ParamElem *a, ParamElem *b); +extern void cpyrefs(ParamElem *p, Aword *r); +#else +extern void compact(); +extern int lstlen(); +extern Boolean inlst(); +extern void lstcpy(); +extern void sublst(); +extern void mrglst(); +extern void isect(); +extern void cpyrefs(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/parse.cpp b/engines/glk/alan2/parse.cpp new file mode 100644 index 0000000000..4e54c5cd6d --- /dev/null +++ b/engines/glk/alan2/parse.cpp @@ -0,0 +1,846 @@ +/* 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 +#include "glk/alan2/types.h" + +#ifdef USE_READLINE +#include "glk/alan2/readline.h" +#endif + +#include "glk/alan2/main.h" +#include "glk/alan2/inter.h" +#include "glk/alan2/exe.h" +#include "glk/alan2/term.h" +#include "glk/alan2/debug.h" +#include "glk/alan2/params.h" + +#include "glk/alan2/parse.h" + +#ifdef GLK +#include "glk/alan2/glkio.h" +#endif + +namespace Glk { +namespace Alan2 { + +#define LISTLEN 100 + + +/* PUBLIC DATA */ + +int wrds[LISTLEN/2] = {EOF}; /* List of parsed words */ +int wrdidx; /* and an index into it */ + +Boolean plural = FALSE; + + +/* Syntax Parameters */ +int paramidx; /* Index in params */ +ParamElem *params; /* List of params */ +static ParamElem *pparams; /* Previous parameter list */ +static ParamElem *mlst; /* Multiple objects list */ +static ParamElem *pmlst; /* Previous multiple list */ + +/* Literals */ +LitElem litValues[MAXPARAMS+1]; +int litCount; + +/* What did the user say? */ +int vrbwrd; /* The word he used */ +int vrbcode; /* The code for that verb */ + + +/*----------------------------------------------------------------------*\ + + SCAN DATA & PROCEDURES + + All procedures for getting a command and turning it into a list of + dictionary entries are placed here. + + buf + unknown() + lookup() + token + agetline() + scan() + +\*----------------------------------------------------------------------*/ + + +/* PRIVATE DATA */ + +static char buf[LISTLEN+1]; /* The input buffer */ +static char isobuf[LISTLEN+1]; /* The input buffer in ISO */ + + +static Boolean eol = TRUE; /* Looking at End of line? Yes, initially */ + + + +#ifdef _PROTOTYPES_ +static void unknown( + char token[] +) +#else +static void unknown(token) + char token[]; +#endif +{ + char *str = (char *)allocate((int)strlen(token)+4); + + str[0] = '\''; + strcpy(&str[1], token); + strcat(str, "'?"); +#if ISO == 0 + fromIso(str, str); +#endif + output(str); + free(str); + eol = TRUE; + error(M_UNKNOWN_WORD); +} + + + +static char *token; + + +#ifdef _PROTOTYPES_ +static int lookup( + char wrd[] +) +#else +static int lookup(wrd) + char wrd[]; +#endif +{ + int i; + + for (i = 0; !endOfTable(&dict[i]); i++) { + if (strcmp(wrd, (char *) addrTo(dict[i].wrd)) == 0) + return (i); + } + unknown(wrd); + return(EOF); +} + + +#ifdef _PROTOTYPES_ +static int number( + char token[] /* IN - The string to convert to a number */ +) +#else +static int number(token) + char token[]; /* IN - The string to convert to a number */ +#endif +{ + int i; + + sscanf(token, "%d", &i); + return i; +} + +#ifdef _PROTOTYPES_ +static char *gettoken( + char *buf +) +#else +static char *gettoken(buf) + char *buf; +#endif +{ + static char *marker; + static char oldch; + + if (buf == NULL) + *marker = oldch; + else + marker = buf; + while (*marker != '\0' && isSpace(*marker) && *marker != '\n') marker++; + buf = marker; + if (isISOLetter(*marker)) + while (*marker&&(isISOLetter(*marker)||isdigit(*marker)||*marker=='\'')) marker++; + else if (isdigit(*marker)) + while (isdigit(*marker)) marker++; + else if (*marker == '\"') { + marker++; + while (*marker != '\"') marker++; + marker++; + } else if (*marker == '\0' || *marker == '\n') + return NULL; + else + marker++; + oldch = *marker; + *marker = '\0'; + return buf; +} + + +#ifdef _PROTOTYPES_ +static void agetline(void) +#else +static void agetline() +#endif +{ + para(); + do { +#if defined(HAVE_ANSI) || defined(GLK) + statusline(); +#endif + printf("> "); + if (logflg) + fprintf(logfil, "> "); +#ifdef USE_READLINE + if (!readline(buf)) { + newline(); + quit(); + } +#else + if (fgets(buf, LISTLEN, stdin) == NULL) { + newline(); + quit(); + } +#endif + getPageSize(); + anyOutput = FALSE; + if (logflg) +#ifndef __amiga__ + fprintf(logfil, "%s\n", buf); +#else + fprintf(logfil, "%s", buf); +#endif +#if ISO == 0 + toIso(isobuf, buf, NATIVECHARSET); +#else + strcpy(isobuf, buf); +#endif + token = gettoken(isobuf); + if (token != NULL && strcmp("debug", token) == 0 && header->debug) { + dbgflg = TRUE; + debug(); + token = NULL; + } + } while (token == NULL); + eol = FALSE; + lin = 1; +} + + +#ifdef _PROTOTYPES_ +static void scan(void) +#else +static void scan() +#endif +{ + int i; + int w; + char *str; + + agetline(); + wrds[0] = 0; + for (i = 0; i < litCount; i++) + if (litValues[i].type == TYPSTR && litValues[i].value != 0) + free((char *) litValues[i].value); + i = 0; + litCount = 0; + do { + if (isISOLetter(token[0])) { + (void) stringLower(token); + w = lookup(token); + if (!isNoise(w)) + wrds[i++] = w; + } else if (isdigit(token[0])) { + if (litCount > MAXPARAMS) + syserr("Too many parameters."); + wrds[i++] = dictsize+litCount; /* Word outside dictionary = literal */ + litValues[litCount].type = TYPNUM; + litValues[litCount++].value = number(token); + } else if (token[0] == '\"') { + if (litCount > MAXPARAMS) + syserr("Too many parameters."); + wrds[i++] = dictsize+litCount; /* Word outside dictionary = literal */ + litValues[litCount].type = TYPSTR; + /* Remove the string quotes while copying */ + str = strdup(&token[1]); + str[strlen(token)-2] = '\0'; + litValues[litCount++].value = (Aptr) str; + } else if (token[0] == ',') { + wrds[i++] = conjWord; + } else + unknown(token); + wrds[i] = EOF; + eol = (token = gettoken(NULL)) == NULL; + } while (!eol); +} + + + +/*----------------------------------------------------------------------*\ + + PARSE DATA & PROCEDURES + + All procedures and data for getting a command and parsing it + + nonverb() - search for a non-verb command + buildall() - build a list of objects matching 'all' + unambig() - match an unambigous object reference + simple() - match a simple verb command + complex() - match a complex -"- + tryMatch()- to match a verb command + match() - find the verb class (not used currently) and 'tryMatch()' + +\*---------------------------------------------------------------------- */ + +static int allLength; /* No. of objects matching 'all' */ + + +#ifdef _PROTOTYPES_ +static void nonverb(void) +#else +static void nonverb() +#endif +{ + if (isDir(wrds[wrdidx])) { + wrdidx++; + if (wrds[wrdidx] != EOF && !isConj(wrds[wrdidx])) + error(M_WHAT); + else + go(dict[wrds[wrdidx-1]].code); + if (wrds[wrdidx] != EOF) + wrdidx++; + } else + error(M_WHAT); +} + + +#ifdef _PROTOTYPES_ +static void buildall( + ParamElem list[] +) +#else +static void buildall(list) + ParamElem list[]; +#endif +{ + int o, i = 0; + Boolean found = FALSE; + + for (o = OBJMIN; o <= OBJMAX; o++) + if (isHere(o)) { + found = TRUE; + list[i].code = o; + list[i++].firstWord = EOF; + } + if (!found) + error(M_WHAT_ALL); + else + list[i].code = EOF; +} + + +#ifdef _PROTOTYPES_ +static void unambig( + ParamElem plst[] +) +#else +static void unambig(plst) + ParamElem plst[]; +#endif +{ + int i; + Boolean found = FALSE; /* Adjective or noun found ? */ + static ParamElem *refs; /* Entities referenced by word */ + static ParamElem *savlst; /* Saved list for backup at EOF */ + int firstWord, lastWord; /* The words the player used */ + + if (refs == NULL) + refs = (ParamElem *)allocate((MAXENTITY+1)*sizeof(ParamElem)); + + if (savlst == NULL) + savlst = (ParamElem *)allocate((MAXENTITY+1)*sizeof(ParamElem)); + + if (isLiteral(wrds[wrdidx])) { + /* Transform the word into a reference to the literal value */ + plst[0].code = wrds[wrdidx++]-dictsize+LITMIN; + plst[0].firstWord = EOF; /* No words used! */ + plst[1].code = EOF; + return; + } + + plst[0].code = EOF; /* Make empty */ + if (isIt(wrds[wrdidx])) { + wrdidx++; + /* Use last object in previous command! */ + for (i = lstlen(pparams)-1; i >= 0 && (pparams[i].code == 0 || pparams[i].code >= LITMIN); i--); + if (i < 0) + error(M_WHAT_IT); + if (!isHere(pparams[i].code)) { + params[0].code = pparams[i].code; + params[0].firstWord = EOF; + params[1].code = EOF; + error(M_NO_SUCH); + } + plst[0] = pparams[i]; + plst[0].firstWord = EOF; /* No words used! */ + plst[1].code = EOF; + return; + } + + firstWord = wrdidx; + while (wrds[wrdidx] != EOF && isAdj(wrds[wrdidx])) { + /* If this word can be a noun and there is no noun following break loop */ + if (isNoun(wrds[wrdidx]) && (wrds[wrdidx+1] == EOF || !isNoun(wrds[wrdidx+1]))) + break; + cpyrefs(refs, (Aword *)addrTo(dict[wrds[wrdidx]].adjrefs)); + lstcpy(savlst, plst); /* To save it for backtracking */ + if (found) + isect(plst, refs); + else { + lstcpy(plst, refs); + found = TRUE; + } + wrdidx++; + } + if (wrds[wrdidx] != EOF) { + if (isNoun(wrds[wrdidx])) { + cpyrefs(refs, (Aword *)addrTo(dict[wrds[wrdidx]].nounrefs)); + if (found) + isect(plst, refs); + else { + lstcpy(plst, refs); + found = TRUE; + } + wrdidx++; + } else + error(M_NOUN); + } else if (found) { + if (isNoun(wrds[wrdidx-1])) { + /* Perhaps the last word was also a noun? */ + lstcpy(plst, savlst); /* Restore to before last adjective */ + cpyrefs(refs, (Aword *)addrTo(dict[wrds[wrdidx-1]].nounrefs)); + if (plst[0].code == EOF) + lstcpy(plst, refs); + else + isect(plst, refs); + } else + error(M_NOUN); + } + lastWord = wrdidx-1; + + /* Allow remote objects, but resolve ambiguities by presence */ + if (lstlen(plst) > 1) { + for (i=0; plst[i].code != EOF; i++) + if (!isHere(plst[i].code)) + plst[i].code = 0; + compact(plst); + } + + if (lstlen(plst) > 1 || (found && lstlen(plst) == 0)) { + params[0].code = 0; /* Just make it anything != EOF */ + params[0].firstWord = firstWord; /* Remember words for errors below */ + params[0].lastWord = lastWord; + params[1].code = EOF; /* But be sure to terminate */ + if (lstlen(plst) > 1) + error(M_WHICH_ONE); + else if (found && lstlen(plst) == 0) + error(M_NO_SUCH); + } else { + plst[0].firstWord = firstWord; + plst[0].lastWord = lastWord; + } +} + + +#ifdef _PROTOTYPES_ +static void simple( + ParamElem olst[] +) +#else +static void simple(olst) + ParamElem olst[]; +#endif +{ + static ParamElem *tlst = NULL; + int savidx = wrdidx; + Boolean savplur = FALSE; + int i; + + if (tlst == NULL) + tlst = (ParamElem *) allocate(sizeof(ParamElem)*(MAXENTITY+1)); + tlst[0].code = EOF; + + for (;;) { + if (isThem(wrds[wrdidx])) { + plural = TRUE; + for (i = 0; pmlst[i].code != EOF; i++) + if (!isHere(pmlst[i].code)) + pmlst[i].code = 0; + compact(pmlst); + if (lstlen(pmlst) == 0) + error(M_WHAT_THEM); + lstcpy(olst, pmlst); + olst[0].firstWord = EOF; /* No words used */ + wrdidx++; + } else { + unambig(olst); /* Look for unambigous noun phrase */ + if (lstlen(olst) == 0) { /* Failed! */ + lstcpy(olst, tlst); + wrdidx = savidx; + plural = savplur; + return; + } + } + mrglst(tlst, olst); + if (wrds[wrdidx] != EOF + && (isConj(wrds[wrdidx]) && + (isAdj(wrds[wrdidx+1]) || isNoun(wrds[wrdidx+1])))) { + /* More parameters in a conjunction separated list ? */ + savplur = plural; + savidx = wrdidx; + wrdidx++; + plural = TRUE; + } else { + lstcpy(olst, tlst); + return; + } + } +} + + +/*---------------------------------------------------------------------- + + complex() + + Above this procedure we can use the is* tests, but not below since + they work on words. Below all is converted to indices into the + entity tables. Particularly this goes for literals... + +*/ +#ifdef _PROTOTYPES_ +static void complex( + ParamElem olst[] +) +#else +static void complex(olst) + ParamElem olst[]; +#endif +{ + static ParamElem *alst = NULL; + + if (alst == NULL) + alst = (ParamElem *) allocate((MAXENTITY+1)*sizeof(ParamElem)); + + if (isAll(wrds[wrdidx])) { + plural = TRUE; + buildall(alst); /* Build list of all objects */ + wrdidx++; + if (wrds[wrdidx] != EOF && isBut(wrds[wrdidx])) { + wrdidx++; + simple(olst); + if (lstlen(olst) == 0) + error(M_AFTER_BUT); + sublst(alst, olst); + if (lstlen(alst) == 0) + error(M_NOT_MUCH); + } + lstcpy(olst, alst); + allLength = lstlen(olst); + } else + simple(olst); /* Look for simple noun group */ +} + + +#ifdef _PROTOTYPES_ +static Boolean claCheck( + ClaElem *cla /* IN - The cla elem to check */ +) +#else +static Boolean claCheck(cla) + ClaElem *cla; /* IN - The cla elem to check */ +#endif +{ + Boolean ok = FALSE; + + if ((cla->classes&(Aword)CLA_OBJ) != 0) + ok = ok || isObj(params[cla->code-1].code); + if ((cla->classes&(Aword)CLA_CNT) != 0) + ok = ok || isCnt(params[cla->code-1].code); + if ((cla->classes&(Aword)CLA_ACT) != 0) + ok = ok || isAct(params[cla->code-1].code); + if ((cla->classes&(Aword)CLA_NUM) != 0) + ok = ok || isNum(params[cla->code-1].code); + if ((cla->classes&(Aword)CLA_STR) != 0) + ok = ok || isStr(params[cla->code-1].code); + if ((cla->classes&(Aword)CLA_COBJ) != 0) + ok = ok || (isCnt(params[cla->code-1].code) && isObj(params[cla->code-1].code)); + if ((cla->classes&(Aword)CLA_CACT) != 0) + ok = ok || (isCnt(params[cla->code-1].code) && isAct(params[cla->code-1].code)); + return ok; +} + + +/*---------------------------------------------------------------------- + + resolve() + + In case the syntax did not indicate omnipotent powers (allowed + access to remote object), we need to remove non-present parameters + +*/ +static void resolve(ParamElem plst[]) +{ + int i; + + if (allLength > 0) return; /* ALL has already done this */ + + /* Resolve ambiguities by presence */ + for (i=0; plst[i].code != EOF; i++) + if (plst[i].code < LITMIN) /* Literals are always 'here' */ + if (!isHere(plst[i].code)) { + params[0] = plst[i]; /* Copy error param as first one for message */ + params[1].code = EOF; /* But be sure to terminate */ + error(M_NO_SUCH); + } +} + + +#ifdef _PROTOTYPES_ +static void tryMatch( + ParamElem mlst[] /* OUT - List of params allowed by multiple */ +) +#else +static void tryMatch(mlst) + ParamElem mlst[]; /* OUT - List of params allowed by multiple */ +#endif +{ + ElmElem *elms; /* Pointer to element list */ + StxElem *stx; /* Pointer to syntax list */ + ClaElem *cla; /* Pointer to class definitions */ + Boolean anyPlural = FALSE; /* Any parameter that was plural? */ + int i, p; + static ParamElem *tlst = NULL; /* List of params found by complex() */ + static Boolean *checked = NULL; /* Corresponding parameter checked? */ + + if (tlst == NULL) { + tlst = (ParamElem *) allocate((MAXENTITY+1)*sizeof(ParamElem)); + checked = (Boolean *) allocate((MAXENTITY+1)*sizeof(Boolean)); + } + + for (stx = stxs; !endOfTable(stx); stx++) + if (stx->code == vrbcode) + break; + if (endOfTable(stx)) + error(M_WHAT); + + elms = (ElmElem *) addrTo(stx->elms); + + while (TRUE) { + /* End of input? */ + if (wrds[wrdidx] == EOF || isConj(wrds[wrdidx])) { + while (!endOfTable(elms) && elms->code != EOS) + elms++; + if (endOfTable(elms)) + error(M_WHAT); + else + break; + } else { + /* A preposition? */ + if (isPrep(wrds[wrdidx])) { + while (!endOfTable(elms) && elms->code != dict[wrds[wrdidx]].code) + elms++; + if (endOfTable(elms)) + error(M_WHAT); + else + wrdidx++; + } else { + /* Must be a parameter! */ + while (!endOfTable(elms) && elms->code != 0) + elms++; + if (endOfTable(elms)) + error(M_WHAT); + /* Get it! */ + plural = FALSE; + complex(tlst); + if (lstlen(tlst) == 0) /* No object!? */ + error(M_WHAT); + if ((elms->flags & OMNIBIT) == 0) /* Omnipotent parameter? */ + /* If its not an omnipotent parameter, resolve by presence */ + resolve(tlst); + if (plural) { + if ((elms->flags & MULTIPLEBIT) == 0) /* Allowed multiple? */ + error(M_MULTIPLE); + else { + /* + Mark this as the multiple position in which to insert + actual parameter values later + */ + params[paramidx++].code = 0; + lstcpy(mlst, tlst); + anyPlural = TRUE; + } + } else + params[paramidx++] = tlst[0]; + params[paramidx].code = EOF; + } + elms = (ElmElem *) addrTo(elms->next); + } + } + + /* Now perform class checks */ + if (elms->next == 0) /* No verb code, verb not declared! */ + error(M_CANT0); + + for (p = 0; params[p].code != EOF; p++) /* Mark all parameters unchecked */ + checked[p] = FALSE; + for (cla = (ClaElem *) addrTo(elms->next); !endOfTable(cla); cla++) { + if (params[cla->code-1].code == 0) { + /* This was a multiple parameter, so check all and remove failing */ + for (i = 0; mlst[i].code != EOF; i++) { + params[cla->code-1] = mlst[i]; + if (!claCheck(cla)) { + /* Multiple could be both an explicit list of params and an ALL */ + if (allLength == 0) { + char marker[80]; + /* + It wasn't ALL, we need to say something about it, so + prepare a printout with $1/2/3 + */ + sprintf(marker, "($%ld)", (unsigned long) cla->code); + output(marker); + interpret(cla->stms); + para(); + } + mlst[i].code = 0; /* In any case remove it from the list */ + } + } + params[cla->code-1].code = 0; + } else { + if (!claCheck(cla)) { + interpret(cla->stms); + error(MSGMAX); /* Return to player without saying anything */ + } + } + checked[cla->code-1] = TRUE; /* Remember that it's already checked */ + } + /* Now check the rest of the parameters, must be objects */ + for (p = 0; params[p].code != EOF; p++) + if (!checked[p]) { + if (params[p].code == 0) { + /* This was a multiple parameter, check all and remove failing */ + for (i = 0; mlst[i].code != EOF; i++) + if (mlst[i].code != 0) /* Skip any empty slots */ + if (!isObj(mlst[i].code)) + mlst[i].code = 0; + } else if (!isObj(params[p].code)) + error(M_CANT0); + } + + /* Set verb code */ + cur.vrb = ((Aword *) cla)[1]; /* Take first word after end of table! */ + + /* Finally, if ALL was used, try to find out what was applicable */ + if (allLength > 0) { + for (p = 0; params[p].code != 0; p++); /* Find multiple marker */ + for (i = 0; i < allLength; i++) { + if (mlst[i].code != 0) { /* Already empty? */ + params[p] = mlst[i]; + if (!possible()) + mlst[i].code = 0; /* Remove this from list */ + } + } + params[p].code = 0; /* Restore multiple marker */ + compact(mlst); + if (lstlen(mlst) == 0) { + params[0].code = EOF; + error(M_WHAT_ALL); + } + } else if (anyPlural) { + compact(mlst); + if (lstlen(mlst) == 0) + /* If there where multiple parameters but non left, exit without a */ + /* word, assuming we have already said enough */ + error(MSGMAX); + } + plural = anyPlural; /* Remember that we found plural objects */ +} + + +#ifdef _PROTOTYPES_ +static void match( + ParamElem *mlst /* OUT - List of params allowed by multiple */ +) +#else +static void match(mlst) + ParamElem *mlst; /* OUT - List of params allowed by multiple */ +#endif +{ + tryMatch(mlst); /* ... to understand what he said */ + if (wrds[wrdidx] != EOF && !isConj(wrds[wrdidx])) + error(M_WHAT); + if (wrds[wrdidx] != EOF) /* More on this line? */ + wrdidx++; /* If so skip the AND */ +} + + +#ifdef _PROTOTYPES_ +void parse(void) +#else +void parse() +#endif +{ + if (mlst == NULL) { /* Allocate large enough paramlists */ + mlst = (ParamElem *) allocate(sizeof(ParamElem)*(MAXENTITY+1)); + mlst[0].code = EOF; + pmlst = (ParamElem *) allocate(sizeof(ParamElem)*(MAXENTITY+1)); + params = (ParamElem *) allocate(sizeof(ParamElem)*(MAXENTITY+1)); + params[0].code = EOF; + pparams = (ParamElem *) allocate(sizeof(ParamElem)*(MAXENTITY+1)); + } + + if (wrds[wrdidx] == EOF) { + wrdidx = 0; + scan(); + } else if (anyOutput) + para(); + + allLength = 0; + paramidx = 0; + lstcpy(pparams, params); + params[0].code = EOF; + lstcpy(pmlst, mlst); + mlst[0].code = EOF; + if (isVerb(wrds[wrdidx])) { + vrbwrd = wrds[wrdidx]; + vrbcode = dict[vrbwrd].code; + wrdidx++; + match(mlst); + action(mlst); /* mlst contains possible multiple params */ + } else { + params[0].code = EOF; + pmlst[0].code = EOF; + nonverb(); + } +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/parse.h b/engines/glk/alan2/parse.h new file mode 100644 index 0000000000..067c73fb3b --- /dev/null +++ b/engines/glk/alan2/parse.h @@ -0,0 +1,54 @@ +/* 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 GLK_ALAN2_PARSE +#define GLK_ALAN2_PARSE + +/* Parse data for ALAN interpreter module. */ + +namespace Glk { +namespace Alan2 { + +extern int wrds[]; /* List of Parsed Word */ +extern int wrdidx; /* and an index into it */ + +extern ParamElem *params; /* List of parameters */ +extern Boolean plural; + +extern LitElem litValues[]; +extern int litCount; + +extern int vrbwrd; + +#ifdef _PROTOTYPES_ + +/* Parse a new player command */ +extern void parse(void); + +#else +extern void parse(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/readline.cpp b/engines/glk/alan2/readline.cpp new file mode 100644 index 0000000000..c96b26c13d --- /dev/null +++ b/engines/glk/alan2/readline.cpp @@ -0,0 +1,560 @@ +/* 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/alan2/types.h" + +#ifdef GLK + +#include "glk/alan2/alan2.h" +#include "glk/alan2/readline.h" +#include "glk/alan2/main.h" +#include "glk/alan2/glkio.h" + +namespace Glk { +namespace Alan2 { + +/*====================================================================== + + readline() + + Read a line from the user, with history and editing + + */ + +/* 4f - length of user buffer should be used */ +Boolean readline(char usrbuf[]) +{ + event_t event; + g_vm->glk_request_line_event(glkMainWin, usrbuf, 255, 0); + /* FIXME: buffer size should be infallible: all existing calls use 256 or + 80 character buffers, except parse which uses LISTLEN (currently 100) + */ + do + { + g_vm->glk_select(&event); + if (evtype_Arrange == event.type) + statusline(); + } while (event.type != evtype_LineInput); + usrbuf[event.val1] = 0; + return TRUE; +} + +} // End of namespace Alan2 +} // End of namespace Glk + +#else + +#include "glk/alan2/sysdep.h" + +#ifdef HAVE_TERMIO +#include +#endif + +#ifdef __PACIFIC__ +#include +#else +//#include +#endif + +#include "glk/alan2/readline.h" + +#include "glk/alan2/main.h" + +namespace Glk { +namespace Alan2 { + +#ifdef HAVE_TERMIO +/*----------------------------------------------------------------------*\ + + termio handling + +\*----------------------------------------------------------------------*/ + +static struct termios term; + +static void newtermio() +{ + struct termios newterm; + tcgetattr(0, &term); + newterm=term; + newterm.c_lflag&=~(ECHO|ICANON); + newterm.c_cc[VMIN]=1; + newterm.c_cc[VTIME]=0; + tcsetattr(0, TCSANOW, &newterm); +} + +static void restoretermio() +{ + tcsetattr(0, TCSANOW, &term); +} + +#endif + + +/*----------------------------------------------------------------------*\ + + Global character buffers etc. + +\*----------------------------------------------------------------------*/ + +static unsigned char buffer[LINELENGTH+1]; +static int bufidx; + +static unsigned char *history[HISTORYLENGTH]; +static int histidx; /* Index where to store next history */ +static int histp; /* Points to the history recalled last */ + +static unsigned char ch; +static int endOfInput = 0; +static Boolean change; +static Boolean insert = TRUE; + + +/*----------------------------------------------------------------------*\ + + Character map types and maps + +\*----------------------------------------------------------------------*/ + +typedef struct {unsigned char min, max; void (*hook)(char ch);} KeyMap; + +/* Forward declaration of hooks */ +static void escHook(char ch); +static void insertCh(char ch); +static void arrowHook(char ch); +static void upArrow(char ch); +static void downArrow(char ch); +static void rightArrow(char ch); +static void leftArrow(char ch); +static void insertToggle(char ch); +static void newLine(char ch); +static void delFwd(char ch); +static void delBwd(char ch); + +#ifdef __XXunix__ +static KeyMap keymap[] = { + {0x00, 0x07, NULL}, + {0x08, 0x08, delBwd}, + {0x09, 0x09, NULL}, + {0x0a, 0x0a, newLine}, + {0x1b, 0x1b, escHook}, + {0x1c, 0x7e, insertCh}, + {0x7f, 0x7f, delFwd}, + {0x80, 0xff, insertCh}, + {0x00, 0x00, NULL} +}; + +/* I can't figure out what really coverns the esc-map characters... */ +#ifdef __solarisX__ +static KeyMap escmap[] = { + {0x00, 0x4e, NULL}, + {0x4f, 0x4f, arrowHook}, + {0x50, 0xff, NULL}, + {0x00, 0x00, NULL} +}; +#else +static KeyMap escmap[] = { + {0x00, 0x5a, NULL}, + {0x5b, 0x5b, arrowHook}, + {0x5c, 0xff, NULL}, + {0x00, 0x00, NULL} +}; +#endif + +static KeyMap arrowmap[] = { + {0x00, 0x31, NULL}, + {0x32, 0x32, insertToggle}, + {0x33, 0x40, NULL}, + {0x41, 0x41, upArrow}, + {0x42, 0x42, downArrow}, + {0x43, 0x43, rightArrow}, + {0x44, 0x44, leftArrow}, + {0x45, 0xff, NULL}, + {0x00, 0x00, NULL} +}; + +#endif + +#ifdef __win__ +static KeyMap keymap[] = { + {0x00, 0x01, NULL}, + {0x02, 0x02, leftArrow}, + {0x03, 0x05, NULL}, + {0x06, 0x06, rightArrow}, + {0x07, 0x07, NULL}, + {0x08, 0x08, delBwd}, + {0x09, 0x09, NULL}, + {0x0a, 0x0a, newLine}, + {0x1b, 0x1b, escHook}, + {0x1c, 0x7e, insertCh}, + {0x7f, 0x7f, delFwd}, + {0x80, 0xff, insertCh}, + {0x00, 0x00, NULL} +}; + +static KeyMap escmap[] = { + {0x00, 0x5a, NULL}, + {0x5b, 0x5b, arrowHook}, + {0x5c, 0xff, NULL}, + {0x00, 0x00, NULL} +}; + +static KeyMap arrowmap[] = { + {0x00, 0x31, NULL}, + {0x32, 0x32, insertToggle}, + {0x33, 0x40, NULL}, + {0x41, 0x41, upArrow}, + {0x42, 0x42, downArrow}, + {0x43, 0x43, rightArrow}, + {0x44, 0x44, leftArrow}, + {0x45, 0xff, NULL}, + {0x00, 0x00, NULL} +}; + +#endif + +#ifdef __dos__ +static KeyMap keymap[] = { + {0x00, 0x01, NULL}, + {0x02, 0x02, leftArrow}, + {0x03, 0x05, NULL}, + {0x06, 0x06, rightArrow}, + {0x07, 0x07, NULL}, + {0x08, 0x08, delBwd}, + {0x09, 0x09, NULL}, + {0x0a, 0x0a, newLine}, + {0x1b, 0x1b, escHook}, + {0x1c, 0x7e, insertCh}, + {0x7f, 0x7f, delFwd}, + {0x80, 0xff, insertCh}, + {0x00, 0x00, NULL} +}; + +static KeyMap escmap[] = { + {0x00, 0x5a, NULL}, + {0x5b, 0x5b, arrowHook}, + {0x5c, 0xff, NULL}, + {0x00, 0x00, NULL} +}; + +static KeyMap arrowmap[] = { + {0x00, 0x31, NULL}, + {0x32, 0x32, insertToggle}, + {0x33, 0x40, NULL}, + {0x41, 0x41, upArrow}, + {0x42, 0x42, downArrow}, + {0x43, 0x43, rightArrow}, + {0x44, 0x44, leftArrow}, + {0x45, 0xff, NULL}, + {0x00, 0x00, NULL} +}; + +#endif + + +static void doBeep(void) +{ + write(1, "\7", 1); +} + + +static void backspace(void) +{ + write(1, "\b", 1); +} + + +static void erase() +{ + int i; + + for (i = 0; i < bufidx; i++) backspace(); /* Backup to beginning of text */ + for (i = 0; i < strlen((char *)buffer); i++) write(1, " ", 1); /* Erase all text */ + for (i = 0; i < strlen((char *)buffer); i++) backspace(); /* Backup to beginning of text */ +} + +/*----------------------------------------------------------------------*\ + + Character handling hook functions + +\*----------------------------------------------------------------------*/ + +static void execute(KeyMap map[], unsigned char ch) +{ + int i = 0; + + for (i = 0; i <= 256; i++) { + if (i > 0 && map[i].min == 0x00) break; /* End marker is a 0,0,NULL */ + if (map[i].min <= ch && ch <= map[i].max) { + if (map[i].hook != NULL) { + map[i].hook(ch); + return; + } else + doBeep(); + } + } + doBeep(); +} + + +static void upArrow(char ch) +{ + /* Is there more history ? */ + if (history[(histp+HISTORYLENGTH-1)%HISTORYLENGTH] == NULL || + (histp+HISTORYLENGTH-1)%HISTORYLENGTH == histidx) { + write(1, "\7", 1); + return; + } + + erase(); + + /* Backup history pointer */ + histp = (histp+HISTORYLENGTH-1)%HISTORYLENGTH; + + /* Copy the history and write it */ + strcpy((char *)buffer, (char *)history[histp]); + bufidx = strlen((char *)buffer); + write(1, (void *)buffer, strlen((char *)buffer)); + +} + + +static void downArrow(char ch) +{ + /* Is there more history ? */ + if (histp == histidx) { + write(1, "\7", 1); + return; + } + + erase(); + + /* Advance history pointer */ + histp = (histp+1)%HISTORYLENGTH; + + /* If we are not at the most recent history entry, copy the history and write it */ + if (histp != histidx) { + strcpy((char *)buffer, (char *)history[histp]); + bufidx = strlen((char *)buffer); + write(1, (void *)buffer, strlen((char *)buffer)); + } else { + bufidx = 0; + buffer[0] = '\0'; + } +} + + +static void rightArrow(char ch) +{ + if (bufidx > LINELENGTH || buffer[bufidx] == '\0') + doBeep(); + else { + write(1, (void *)&buffer[bufidx], 1); + bufidx++; + } +} + + +static void leftArrow(char ch) +{ + if (bufidx == 0) + doBeep(); + else { + bufidx--; + backspace(); + } +} + + +static void insertToggle(char ch) +{ + read(0, &ch, 1); + if (ch != 'z') + doBeep(); + else + insert = !insert; +} + + +static void delBwd(char ch) +{ + if (bufidx == 0) + doBeep(); + else { + int i; + + change = TRUE; + backspace(); + bufidx--; + for (i = 0; i <= strlen((char *)&buffer[bufidx+1]); i++) + buffer[bufidx+i] = buffer[bufidx+1+i]; + write(1, (void *)&buffer[bufidx], strlen((char *)&buffer[bufidx])); + write(1, " ", 1); + for (i = 0; i <= strlen((char *)&buffer[bufidx]); i++) backspace(); + } +} + +static void delFwd(char ch) +{ + if (bufidx > LINELENGTH || buffer[bufidx] == '\0') + doBeep(); + else { + int i; + + change = TRUE; + strcpy((char *)&buffer[bufidx], (char *)&buffer[bufidx+1]); + write(1, (void *)&buffer[bufidx], strlen((char *)&buffer[bufidx])); + write(1, " ", 1); + for (i = 0; i <= strlen((char *)&buffer[bufidx]); i++) backspace(); + } +} + +static void escHook(char ch) { + read(0, &ch, 1); + execute(escmap, ch); +} + +static void arrowHook(char ch) { + read(0, &ch, 1); + execute(arrowmap, ch); +} + +static void newLine(char ch) +{ + endOfInput = 1; + write(1, "\n", 1); + + /* If the input is not the same as the previous, save it in the history */ + if (change && strlen((char *)buffer) > 0) { + if (history[histidx] == NULL) + history[histidx] = (unsigned char *)allocate(LINELENGTH+1); + strcpy((char *)history[histidx], (char *)buffer); + histidx = (histidx+1)%HISTORYLENGTH; + } +} + + +static void insertCh(char ch) { + if (bufidx > LINELENGTH) + doBeep(); + else { + /* If at end advance the NULL */ + if (buffer[bufidx] == '\0') + buffer[bufidx+1] = '\0'; + else if (insert) { + int i; + + /* If insert mode is on, move the characters ahead */ + for (i = strlen((char *)buffer); i >= bufidx; i--) + buffer[i+1] = buffer[i]; + write(1, (void *)&buffer[bufidx], strlen((char *)&buffer[bufidx])); + for (i = strlen((char *)&buffer[bufidx]); i > 0; i--) backspace(); + } + change = TRUE; + buffer[bufidx] = ch; + write(1, &ch, 1); + bufidx++; + } +} + + +/*---------------------------------------------------------------------- + + echoOff() + + */ +static void echoOff() +{ +#ifdef HAVE_TERMIO + newtermio(); +#else +#ifdef __win__ +#include +#include +#include + + DWORD handle = GetStdHandle(STD_INPUT_HANDLE); + + (void) SetConsoleMode(handle, 0); + +#endif +#endif +} + + +/*---------------------------------------------------------------------- + + echoOn() + + */ +static void echoOn() +{ +#ifdef HAVE_TERMIO + restoretermio(); +#else +#ifdef __win__ +#include +#include +#include + + DWORD handle = GetStdHandle(STD_INPUT_HANDLE); + (void) SetConsoleMode(handle, ENABLE_ECHO_INPUT); + +#endif +#endif +} + + +/*====================================================================== + + readline() + + Read a line from the user, with history and editing + + */ + +/* 4f - length of user buffer should be used */ +Boolean readline(char usrbuf[]) +{ + fflush(stdout); + bufidx = 0; + histp = histidx; + buffer[0] = '\0'; + change = TRUE; + echoOff(); + endOfInput = 0; + while (!endOfInput) { + if (read(0, (void *)&ch, 1) != 1) { + echoOn(); + return FALSE; + } + execute(keymap, ch); + } + echoOn(); + strcpy(usrbuf, (char *)buffer); + return TRUE; +} + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/readline.h b/engines/glk/alan2/readline.h new file mode 100644 index 0000000000..a50022415d --- /dev/null +++ b/engines/glk/alan2/readline.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 GLK_ALAN2_READLINE +#define GLK_ALAN2_READLINE + +/* Header file for user input, history andediting support */ + +#include "glk/alan2/types.h" + +namespace Glk { +namespace Alan2 { + +#define LINELENGTH 80 +#define HISTORYLENGTH 20 + +#ifdef _PROTOTYPES_ +extern Boolean readline(char usrbuf[]); + +#else +extern Boolean readline(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/reverse.cpp b/engines/glk/alan2/reverse.cpp new file mode 100644 index 0000000000..cf3e851226 --- /dev/null +++ b/engines/glk/alan2/reverse.cpp @@ -0,0 +1,552 @@ +/* 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/alan2/types.h" +#include "glk/alan2/main.h" +#include "glk/alan2/reverse.h" + +namespace Glk { +namespace Alan2 { + +/*---------------------------------------------------------------------- + + reversed() + + Return the reversed bytes in the Aword + +*/ +#ifdef _PROTOTYPES_ +Aword reversed(Aword w) /* IN - The ACODE word to swap bytes of */ +#else +Aword reversed(w) + Aword w; /* IN - The ACODE word to swap bytes of */ +#endif +{ + Aword s; /* The swapped ACODE word */ + char *wp, *sp; + int i; + + wp = (char *) &w; + sp = (char *) &s; + + for (i = 0; i < sizeof(Aword); i++) + sp[sizeof(Aword)-1 - i] = wp[i]; + + return s; +} + + +#ifdef _PROTOTYPES_ +void reverse(Aword *w) /* IN - The ACODE word to reverse bytes in */ +#else +void reverse(w) + Aword *w; /* IN - The ACODE word to reverse bytes in */ +#endif +{ + *w = reversed(*w); +} + + +#ifdef _PROTOTYPES_ +static void reverseTable(Aword adr, int len) +#else +static void reverseTable(adr, len) + Aword adr; + int len; +#endif +{ + Aword *e = &memory[adr]; + int i; + + if (adr != 0) + while (!endOfTable(e)) { + for (i = 0; i < len/(int)sizeof(Aword); i++) { + reverse(e); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseStms(Aword adr) +#else +static void reverseStms(adr) + Aword adr; +#endif +{ + Aword *e = &memory[adr]; + + if (adr != 0) + while (TRUE) { + reverse(e); + if (*e == ((Aword)C_STMOP<<28|(Aword)I_RETURN)) break; + e++; + } +} + + +#ifdef _PROTOTYPES_ +static void reverseMsgs(Aword adr) +#else +static void reverseMsgs(adr) + Aword adr; +#endif +{ + MsgElem *e = (MsgElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(MsgElem)); + while (!endOfTable(e)) { + reverseStms(e->stms); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseWrds(Aword adr) +#else +static void reverseWrds(adr) + Aword adr; +#endif +{ + WrdElem *e = (WrdElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(WrdElem)); + while (!endOfTable(e)) { + if ((e->_class & (1L<adjrefs, sizeof(Aword)); + reverseTable(e->nounrefs, sizeof(Aword)); + } + e++; + } + } +} + +#ifdef _PROTOTYPES_ +static void reverseChks(Aword adr) +#else +static void reverseChks(adr) + Aword adr; +#endif +{ + ChkElem *e = (ChkElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(ChkElem)); + while (!endOfTable(e)) { + reverseStms(e->exp); + reverseStms(e->stms); + e++; + } + } +} + +#ifdef _PROTOTYPES_ +static void reverseAlts(Aword adr) +#else +static void reverseAlts(adr) + Aword adr; +#endif +{ + AltElem *e = (AltElem *)&memory[adr]; + + if (adr != 0 && !endOfTable(e) && !e->done) { + reverseTable(adr, sizeof(AltElem)); + e->done = TRUE; + while (!endOfTable(e)) { + reverseChks(e->checks); + reverseStms(e->action); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseVrbs(Aword adr) +#else +static void reverseVrbs(adr) + Aword adr; +#endif +{ + VrbElem *e = (VrbElem *)&memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(VrbElem)); + while (!endOfTable(e)) { + reverseAlts(e->alts); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseSteps(Aword adr) +#else +static void reverseSteps(adr) + Aword adr; +#endif +{ + StepElem *e = (StepElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(StepElem)); + while (!endOfTable(e)) { + reverseStms(e->exp); + reverseStms(e->stm); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseScrs(Aword adr) +#else +static void reverseScrs(adr) + Aword adr; +#endif +{ + ScrElem *e = (ScrElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(ScrElem)); + while (!endOfTable(e)) { + reverseStms(e->dscr); + reverseSteps(e->steps); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseActs(Aword adr) +#else +static void reverseActs(adr) + Aword adr; +#endif +{ + ActElem *e = (ActElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(ActElem)); + while (!endOfTable(e)) { + reverseStms(e->nam); + reverseTable(e->atrs, sizeof(AtrElem)); + reverseScrs(e->scradr); + reverseVrbs(e->vrbs); + reverseStms(e->dscr); + e++; + } + } +} + +#ifdef _PROTOTYPES_ +static void reverseObjs(Aword adr, Boolean v2_5) +#else +static void reverseObjs(adr, v2_5) + Aword adr; + Boolean v2_5; /* TRUE if it's a v2.5 format game */ +#endif +{ + ObjElem *e = (ObjElem *) &memory[adr]; + ObjElem25 *e25 = (ObjElem25 *) &memory[adr]; + + if (v2_5) { + if (adr != 0 && !endOfTable(e25)) { + reverseTable(adr, sizeof(ObjElem25)); + while (!endOfTable(e25)) { + reverseTable(e25->atrs, sizeof(AtrElem)); + reverseVrbs(e25->vrbs); + reverseStms(e25->dscr1); + reverseStms(e25->dscr2); + e25++; + } + } + } else { + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(ObjElem)); + while (!endOfTable(e)) { + reverseTable(e->atrs, sizeof(AtrElem)); + reverseVrbs(e->vrbs); + reverseStms(e->art); + reverseStms(e->dscr1); + reverseStms(e->dscr2); + e++; + } + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseExts(Aword adr) +#else +static void reverseExts(adr) + Aword adr; +#endif +{ + ExtElem *e = (ExtElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(ExtElem)); + while (!endOfTable(e)) { + if (!e->done) { + reverseChks(e->checks); + reverseStms(e->action); + } + e++; + } + } +} + +#ifdef _PROTOTYPES_ +static void reverseLocs(Aword adr) +#else +static void reverseLocs(adr) + Aword adr; +#endif +{ + LocElem *e = (LocElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(LocElem)); + while (!endOfTable(e)) { + reverseStms(e->nams); + reverseStms(e->dscr); + reverseStms(e->does); + reverseTable(e->atrs, sizeof(AtrElem)); + reverseExts(e->exts); + reverseVrbs(e->vrbs); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseClas(Aword adr) +#else +static void reverseClas(adr) + Aword adr; +#endif +{ + ClaElem *e = (ClaElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(ClaElem)); + while (!endOfTable(e)) { + reverseStms(e->stms); + e++; + } + } + if (adr) + reverse(&((Aword *)e)[1]); /* The verb code is stored after the table */ +} + + +#ifdef _PROTOTYPES_ +static void reverseElms(Aword adr) +#else +static void reverseElms(adr) + Aword adr; +#endif +{ + ElmElem *e = (ElmElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(ElmElem)); + while (!endOfTable(e)) { + if (e->code == EOS) reverseClas(e->next); + else reverseElms(e->next); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseStxs(Aword adr) +#else +static void reverseStxs(adr) + Aword adr; +#endif +{ + StxElem *e = (StxElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(StxElem)); + while (!endOfTable(e)) { + reverseElms(e->elms); + e++; + } + } +} + +#ifdef _PROTOTYPES_ +static void reverseEvts(Aword adr) +#else +static void reverseEvts(adr) + Aword adr; +#endif +{ + EvtElem *e = (EvtElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(EvtElem)); + while (!endOfTable(e)) { + reverseStms(e->code); + e++; + } + } +} + + + +#ifdef _PROTOTYPES_ +static void reverseLims(Aword adr) +#else +static void reverseLims(adr) + Aword adr; +#endif +{ + LimElem *e = (LimElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(LimElem)); + while (!endOfTable(e)) { + reverseStms(e->stms); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseCnts(Aword adr) +#else +static void reverseCnts(adr) + Aword adr; +#endif +{ + CntElem *e = (CntElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(CntElem)); + while (!endOfTable(e)) { + reverseLims(e->lims); + reverseStms(e->header); + reverseStms(e->empty); + reverseStms(e->nam); + e++; + } + } +} + + +#ifdef _PROTOTYPES_ +static void reverseRuls(Aword adr) +#else +static void reverseRuls(adr) + Aword adr; +#endif +{ + RulElem *e = (RulElem *) &memory[adr]; + + if (adr != 0 && !endOfTable(e)) { + reverseTable(adr, sizeof(RulElem)); + while (!endOfTable(e)) { + reverseStms(e->exp); + reverseStms(e->stms); + e++; + } + } +} + + + +/*---------------------------------------------------------------------- + + reverseHdr() + + Reverse the header structure. + +*/ +#ifdef _PROTOTYPES_ +void reverseHdr(AcdHdr *hdr) +#else +void reverseHdr(hdr) + AcdHdr *hdr; +#endif +{ + int i; + + /* Reverse all words in the header except the first (version marking) */ + for (i = 1; i < sizeof(AcdHdr)/sizeof(Aword); i++) + reverse(&((Aword *)hdr)[i]); +} + +/*---------------------------------------------------------------------- + + reverseACD() + + Traverse all the data structures and reverse all integers. + Only performed in architectures with reversed byte ordering, which + makes the .ACD files fully compatible across architectures + + */ +#ifdef _PROTOTYPES_ +void reverseACD(Boolean v2_5) +#else +void reverseACD(v2_5) + Boolean v2_5; +#endif +{ + reverseHdr(header); + reverseWrds(header->dict); + reverseTable(header->oatrs, sizeof(AtrElem)); + reverseTable(header->latrs, sizeof(AtrElem)); + reverseTable(header->aatrs, sizeof(AtrElem)); + reverseActs(header->acts); + reverseObjs(header->objs, v2_5); + reverseLocs(header->locs); + reverseStxs(header->stxs); + reverseVrbs(header->vrbs); + reverseEvts(header->evts); + reverseCnts(header->cnts); + reverseRuls(header->ruls); + reverseTable(header->init, sizeof(IniElem)); + reverseStms(header->start); + reverseMsgs(header->msgs); + + reverseTable(header->scores, sizeof(Aword)); + reverseTable(header->freq, sizeof(Aword)); +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/reverse.h b/engines/glk/alan2/reverse.h new file mode 100644 index 0000000000..40807ce403 --- /dev/null +++ b/engines/glk/alan2/reverse.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 GLK_ALAN2_REVERSE +#define GLK_ALAN2_REVERSE + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ + +extern void reverseHdr(AcdHdr *hdr); +extern void reverseACD(Boolean v25); +extern void reverse(Aword *word); +extern Aword reversed(Aword word); + +#else +extern void reverseHdr(); +extern void reverseACD(); +extern void reverse(); +extern Aword reversed(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/rules.cpp b/engines/glk/alan2/rules.cpp new file mode 100644 index 0000000000..d00d1f3955 --- /dev/null +++ b/engines/glk/alan2/rules.cpp @@ -0,0 +1,83 @@ +/* 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/alan2/types.h" +#include "glk/alan2/main.h" +#include "glk/alan2/inter.h" +#include "glk/alan2/debug.h" +#include "glk/alan2/exe.h" +#include "glk/alan2/stack.h" + +#include "glk/alan2/rules.h" + +#ifdef GLK +#include "glk/alan2/glkio.h" +#endif + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ +void rules(void) +#else +void rules() +#endif +{ + Boolean change = TRUE; + int i; + + for (i = 1; !endOfTable(&ruls[i-1]); i++) + ruls[i-1].run = FALSE; + + while (change) { + change = FALSE; + for (i = 1; !endOfTable(&ruls[i-1]); i++) + if (!ruls[i-1].run) { + if (trcflg) { + printf("\n\n"); + } + interpret(ruls[i-1].exp); + if (pop()) { + change = TRUE; + ruls[i-1].run = TRUE; + if (trcflg) + if (!stpflg) + printf(", Executing:>\n"); + else { + printf("\nRULE %d (at ", i); + debugsay(cur.loc); + printf("), Executing:>\n"); + } + interpret(ruls[i-1].stms); + } else if (trcflg && !stpflg) + printf(":>\n"); + } + } +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/rules.h b/engines/glk/alan2/rules.h new file mode 100644 index 0000000000..1cc0b909e3 --- /dev/null +++ b/engines/glk/alan2/rules.h @@ -0,0 +1,44 @@ +/* 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 GLK_ALAN2_RULES +#define GLK_ALAN2_RULES + +/* Header file for rules handler in Alan interpreter */ + +namespace Glk { +namespace Alan2 { + +/* TYPES */ + +#ifdef _PROTOTYPES_ + +extern void rules(void); + +#else +extern void rules(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/stack.cpp b/engines/glk/alan2/stack.cpp new file mode 100644 index 0000000000..ccce1475d1 --- /dev/null +++ b/engines/glk/alan2/stack.cpp @@ -0,0 +1,74 @@ +/* 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/alan2/types.h" +#include "glk/alan2/main.h" +#include "glk/alan2/stack.h" + +namespace Glk { +namespace Alan2 { + +/* PRIVATE DATA */ + +#define STACKSIZE 100 + +/* The AMACHINE STACK */ +static Aptr stack[STACKSIZE]; +static int stackp = 0; + + +#ifdef _PROTOTYPES_ +void push(Aptr i) +#else +void push(i) + Aptr i; +#endif +{ + if (stackp == STACKSIZE) + syserr("Out of stack space."); + stack[stackp++] = i; +} + + +#ifdef _PROTOTYPES_ +Aptr pop(void) +#else +Aptr pop() +#endif +{ + if (stackp == 0) + syserr("Stack underflow."); + return(stack[--stackp]); +} + + +#ifdef _PROTOTYPES_ +Aptr top(void) +#else +Aptr top() +#endif +{ + return(stack[stackp-1]); +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/stack.h b/engines/glk/alan2/stack.h new file mode 100644 index 0000000000..7f10c080b6 --- /dev/null +++ b/engines/glk/alan2/stack.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 GLK_ALAN2_STACK +#define GLK_ALAN2_STACK + +/* Header file for stack handler in Alan interpreter */ + +namespace Glk { +namespace Alan2 { + +/* TYPES */ + +#ifdef _PROTOTYPES_ + +extern Aptr pop(void); +extern void push(Aptr item); +extern Aptr top(void); + +#else +extern Aptr pop(); +extern void push(); +extern Aptr top(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/sysdep.cpp b/engines/glk/alan2/sysdep.cpp new file mode 100644 index 0000000000..daa0417569 --- /dev/null +++ b/engines/glk/alan2/sysdep.cpp @@ -0,0 +1,493 @@ +/* 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 +#include "glk/alan2/sysdep.h" + +#ifdef GLK +#include "glk/alan2/alan2.h" +#endif + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ +extern void syserr(char str[]); +#endif + +#ifdef __vms__ + +char *strdup(char str[]) /* IN - String to duplicate */ +{ + char *new = (char *) malloc(strlen(str)+1); + + if (!new) + syserr("Out of memory"); + strcpy(new, str); + return new; +} + +#endif + + +#ifdef __mac__ + +char *strdup(char str[]) /* IN - String to duplicate */ +{ + char *new = (char *) malloc((size_t)((int)strlen(str)+1)); + + if (!new) + syserr("Out of memory"); + strcpy(new, str); + return new; +} + +#endif + + +#ifdef __vms__ + +/* Cheat implementation of strftime */ +size_t strftime ( + char *outbuf, + size_t len, + const char *format, + const struct tm *t) +{ + char buf[100]; + time_t ticks; + + time(&ticks); + strcpy(buf, ctime(&ticks)); + buf[strlen(buf)-1] = '\0'; + strcpy(outbuf, &buf[4]); +} + +#endif + +#ifdef __dos__ +#endif + +#ifdef GLK + +/* Note to Glk maintainers: 'native' characters are used for output, in this + case, Glk's Latin-1. ISO characters are Alan's internal representation, + stored in the .DAT file, and must be converted to native before printing. + Glk could just use the ISO routines directly, but its safer to maintain + its own tables to guard against future changes in either Alan or Glk (ie. a + move to Unicode). + */ + +static char spcChrs[] = +{ + '\x0A', /* linefeed */ + '\x20', /* space */ + '\xA0', /* non-breaking space */ + '\x00' +}; + +static char lowChrs[] = +{ + '\x61', /* a */ '\x62', /* b */ '\x63', /* c */ '\x64', /* d */ + '\x65', /* e */ '\x66', /* f */ '\x67', /* g */ '\x68', /* h */ + '\x69', /* i */ '\x6A', /* j */ '\x6B', /* k */ '\x6C', /* l */ + '\x6D', /* m */ '\x6E', /* n */ '\x6F', /* o */ '\x70', /* p */ + '\x71', /* q */ '\x72', /* r */ '\x73', /* s */ '\x74', /* t */ + '\x75', /* u */ '\x76', /* v */ '\x77', /* w */ '\x78', /* x */ + '\x79', /* y */ '\x7A', /* z */ '\xDF', /* ss */ + '\xE0', /* a grave */ '\xE1', /* a acute */ + '\xE2', /* a circumflex */ '\xE3', /* a tilde */ + '\xE4', /* a diaeresis */ '\xE5', /* a ring */ + '\xE6', /* ae */ '\xE7', /* c cedilla */ + '\xE8', /* e grave */ '\xE9', /* e acute */ + '\xEA', /* e circumflex */ '\xEB', /* e diaeresis */ + '\xEC', /* i grave */ '\xED', /* i acute */ + '\xEE', /* i circumflex */ '\xEF', /* i diaeresis */ + '\xF0', /* */ '\xF1', /* n tilde */ + '\xF2', /* o grave */ '\xF3', /* o acute */ + '\xF4', /* o circumflex */ '\xF5', /* o tilde */ + '\xF6', /* o diaeresis */ '\xF8', /* o slash */ + '\xF9', /* u grave */ '\xFA', /* u acute */ + '\xFB', /* u circumflex */ '\xFC', /* u diaeresis */ + '\xFD', /* y acute */ '\xFE', /* */ + '\xFF', /* y diaeresis */ '\x00' +}; + +/* FIXME: ss and y diaeresis have no UC analogues + Are they really considered LC? + */ + +static char uppChrs[] = +{ + '\x41', /* A */ '\x42', /* B */ '\x43', /* C */ '\x44', /* D */ + '\x45', /* E */ '\x46', /* F */ '\x47', /* G */ '\x48', /* H */ + '\x49', /* I */ '\x4A', /* J */ '\x4B', /* K */ '\x4C', /* L */ + '\x4D', /* M */ '\x4E', /* N */ '\x4F', /* O */ '\x50', /* P */ + '\x51', /* Q */ '\x52', /* R */ '\x53', /* S */ '\x54', /* T */ + '\x55', /* U */ '\x56', /* V */ '\x57', /* W */ '\x58', /* X */ + '\x59', /* Y */ '\x5A', /* Z */ + '\xC0', /* A grave */ '\xC1', /* A acute */ + '\xC2', /* A circumflex */ '\xC3', /* A tilde */ + '\xC4', /* A diaeresis */ '\xC5', /* A ring */ + '\xC6', /* AE */ '\xC7', /* C cedilla */ + '\xC8', /* E grave */ '\xC9', /* E acute */ + '\xCA', /* E circumflex */ '\xCB', /* E diaeresis */ + '\xCC', /* I grave */ '\xCD', /* I acute */ + '\xCE', /* I circumflex */ '\xCF', /* I diaeresis */ + '\xD0', /* */ '\xD1', /* N tilde */ + '\xD2', /* O grave */ '\xD3', /* O acute */ + '\xD4', /* O circumflex */ '\xD5', /* O tilde */ + '\xD6', /* O diaeresis */ '\xD8', /* O slash */ + '\xD9', /* U grave */ '\xDA', /* U acute */ + '\xDB', /* U circumflex */ '\xDC', /* U diaeresis */ + '\xDD', /* Y acute */ '\xDE', /* */ + '\x00' +}; + +#else + +/* Theses work on native character sets */ + +static char spcChrs[] = " \t\n"; + +#ifdef __amiga__ + +/* Which can't read 8-bit chars but is ISO */ +static char lowChrs[] = "abcdefghijklmnopqrstuvwxyz\340\341\342\343\344\345\346\347\351\352\353\354\355\356\357\360\361\362\363\364\365\366\370\371\372\373\374\375\376\377"; + +static char uppChrs[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"; + +#else + +/* Use native characters */ +static char lowChrs[] = "abcdefghijklmnopqrstuvwxyzàáâãäåæçéêëìíîïðñòóôõöøùúûüýþÿ"; + +static char uppChrs[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZÀÁÂÃÄÅÆÇÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÛÝÞß"; + +#endif +#endif + +int isSpace(int c) /* IN - Native character to test */ +{ + return (c != '\0' && strchr(spcChrs, c) != 0); +} + + +int isLower(int c) /* IN - Native character to test */ +{ + return (c != '\0' && strchr(lowChrs, c) != 0); +} + + +int isUpper(int c) /* IN - Native character to test */ +{ + return (c != '\0' && strchr(uppChrs, c) != 0); +} + +int isLetter(int c) /* IN - Native character to test */ +{ + return(c != '\0' && (isLower(c)? !0: isUpper(c))); +} + + +int toLower(int c) /* IN - Native character to convert */ +{ +#ifdef GLK + return g_vm->glk_char_to_lower(c); +#else +#ifdef __dos__ + char *cp; + + if ((cp = strchr(uppChrs, c)) != 0) + return(lowChrs[cp-uppChrs]); + else + return c; +#else +#ifdef __mac__ + char *cp; + + if ((cp = strchr(uppChrs, c)) != 0) + return(lowChrs[cp-uppChrs]); + else + return c; +#else + return (isUpper(c)? c + ('a' - 'A'): c); +#endif +#endif +#endif +} + +int toUpper(int c) /* IN - Native character to convert */ +{ +#ifdef GLK + return g_vm->glk_char_to_upper(c); +#else +#ifdef __dos__ + char *cp; + + if ((cp = strchr(lowChrs, c)) != 0) + return(uppChrs[cp-lowChrs]); + else + return c; +#else +#ifdef __mac__ + char *cp; + + if ((cp = strchr(lowChrs, c)) != 0) + return(uppChrs[cp-lowChrs]); + else + return c; +#else + return (isLower(c)? c - ('a' - 'A'): c); +#endif +#endif +#endif +} + +char *strlow(char str[]) /* INOUT - Native string to convert */ +{ + char *s; + + for (s = str; *s; s++) + *s = toLower(*s); + return(str); +} + + +char *strupp(char str[]) /* INOUT - Native string to convert */ +{ + char *s; + + for (s = str; *s; s++) + *s = toUpper(*s); + return(str); +} + + +/* The following work on ISO characters */ + +int isLowerCase(int c) /* IN - ISO character to test */ +{ + static char lowChrs[] = "abcdefghijklmnopqrstuvwxyz\340\341\342\343\344\345\346\347\351\352\353\354\355\356\357\360\361\362\363\364\365\366\370\371\372\373\374\375\376\377"; + return (c != '\0' && strchr(lowChrs, c) != 0); +} + + +int isUpperCase(int c) /* IN - ISO character to test */ +{ + static char uppChrs[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"; + return (c != '\0' && strchr(uppChrs, c) != 0); +} + + +int isISOLetter(int c) /* IN - ISO character to test */ +{ + return (isLowerCase(c) || isUpperCase(c)); +} + + +char toLowerCase(int c) /* IN - ISO character to convert */ +{ + return (isUpperCase(c)? c + ('a' - 'A'): c); +} + + +char toUpperCase(int c) /* IN - ISO character to convert */ +{ + return (isLowerCase(c)? c - ('a' - 'A'): c); +} + + +char *stringLower(char str[]) /* INOUT - ISO string to convert */ +{ + char *s; + + for (s = str; *s; s++) + *s = toLowerCase(*s); + return(str); +} + + +char *stringUpper(char str[]) /* INOUT - ISO string to convert */ +{ + char *s; + + for (s = str; *s; s++) + *s = toUpperCase(*s); + return(str); +} + + +/*---------------------------------------------------------------------- + toIso + + Converts the incoming string to ISO character set. The original is + in the current character set which in the case of the compiler might + be other than the native. + + */ +void toIso(char copy[], /* OUT - Mapped string */ + char original[], /* IN - string to convert */ + int charset) /* IN - the current character set */ +{ +static unsigned char macMap[256] += { +0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0A,0x0E,0x0F, +0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F, +0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F, +0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F, +0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F, +0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F, +0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F, +0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F, +0xC4,0xC5,0xC7,0xC9,0xD1,0xD6,0xDC,0xE1,0xE0,0xE2,0xE4,0xE3,0xE5,0xE7,0xE9,0xE8, +0xEA,0xEB,0xED,0xEC,0xEE,0xEF,0xF1,0xF3,0xF2,0xF4,0xF6,0xF5,0xFA,0xF9,0xFB,0xFC, +0xB9,0xB0,0xA2,0xA3,0xA7,0xB7,0xB6,0xDF,0xAE,0xA9,0xB2,0xB4,0xA8,0xD7,0xC6,0xD8, +0xA4,0xB1,0xCD,0xCC,0xA5,0xB5,0xF0,0xCA,0xDE,0xFE,0xA6,0xAA,0xBA,0xD4,0xE6,0xF8, +0xBF,0xA1,0xAC,0xCE,0xCF,0xC8,0xD0,0xAB,0xBB,0xCB,0xA0,0xC0,0xC3,0xD5,0xDD,0xFD, +0xAD,0xAF,0xDA,0xD9,0xB8,0xB3,0xF7,0xC2,0xFF,0xBC,0xBD,0xBE,0xC1,0xD2,0xD3,0xDB, +0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, +0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F}; + +static unsigned char dosMap[256] += { +0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0A,0x0E,0x0F, +0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F, +0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F, +0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F, +0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F, +0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F, +0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F, +0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F, +0xC7,0xFC,0xE9,0xE2,0xE4,0xE0,0xE5,0xE7,0xEA,0xEB,0xE8,0xEF,0xEE,0xEC,0xC4,0xC5, +0xC9,0xE6,0xC6,0xF4,0xF6,0xF2,0xFB,0xF9,0xFF,0xD6,0xDC,0xA2,0xA3,0xA5,0xDE,0xA6, +0xE1,0xED,0xF3,0xFA,0xF1,0xD1,0xAA,0xBA,0xBF,0xC0,0xC1,0xBD,0xBC,0xCF,0xAB,0xBB, +0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, +0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, +0xA1,0xA7,0xAD,0xB3,0xB8,0xB9,0xC3,0xCE,0xD2,0xD3,0xDB,0xDD,0xE3,0xF5,0xF8,0xFD, +0xA9,0xDF,0xC8,0xB6,0xCA,0xA4,0xB5,0xAE,0xD5,0xD0,0xD4,0xF0,0xD7,0xD8,0xCB,0xC2, +0xBE,0xB1,0xD9,0xDA,0xCD,0xCC,0xF7,0xA8,0xB0,0xB7,0xAF,0xAC,0xFE,0xB2,0xB4,0xA0}; + unsigned char *o, *c; + + switch (charset) { + case 0: /* ISO */ + if (copy != original) + (void)strcpy(copy, original); + break; + case 1: /* Mac */ + for (o = (unsigned char *)original, c = (unsigned char *)copy; *o; o++, c++) + *c = macMap[*o]; + *c = '\0'; + break; + + case 2: /* Dos */ + for (o = (unsigned char *)original, c = (unsigned char *)copy; *o; o++, c++) + *c = dosMap[*o]; + *c = '\0'; + break; + } +} + +/*---------------------------------------------------------------------- + + fromIso + + Converts a string from global Iso format to native. Only used in + interpreter so character set is known at compile time. + + */ +void fromIso(char copy[], /* OUT - Mapped string */ + char original[]) /* IN - string to convert */ +{ +#if ISO == 0 + static unsigned char map[256] +#if defined __mac__ + = { + 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0D,0x0B,0x0C,0x0D,0x0E,0x0F, + 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F, + 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F, + 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F, + 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F, + 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F, + 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F, + 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F, + 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, + 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF, + 0xCA,0xC1,0xA2,0xA3,0xB0,0xB4,0xBA,0xA4,0xAC,0xA9,0xBB,0xC7,0xC2,0xD0,0xA8,0xD1, + 0xA1,0xB1,0xAA,0xD5,0xAB,0xB5,0xA6,0xA5,0xD4,0xA0,0xBC,0xC8,0xD9,0xDA,0xDB,0xC0, + 0xCB,0xDC,0xD7,0xCC,0x80,0x81,0xAE,0x82,0xC5,0x83,0xB7,0xC9,0xB3,0xB2,0xC3,0xC4, + 0xC6,0x84,0xDD,0xDE,0xBD,0xCD,0x85,0xAD,0xAF,0xD3,0xD2,0xDF,0x86,0xCE,0xB8,0xA7, + 0x88,0x87,0x89,0x8B,0x8A,0x8C,0xBE,0x8D,0x8F,0x8E,0x90,0x91,0x93,0x92,0x94,0x95, + 0xB6,0x96,0x98,0x97,0x99,0x9B,0x9A,0xD6,0xBF,0x9D,0x9C,0x9E,0x9F,0xCF,0xB9,0xD8} +#else +#if defined __dos__ + = { + 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0D,0x0B,0x0C,0x0D,0x0E,0x0F, + 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F, + 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F, + 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F, + 0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F, + 0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F, + 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F, + 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F, + 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, + 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, + 0xFF,0xD0,0x9B,0x9C,0xE5,0x9D,0x9F,0xD1,0xF7,0xE0,0xA6,0xAE,0xFB,0xD2,0xE7,0xFA, + 0xF8,0xF1,0xFD,0xD3,0xFE,0xE6,0xE3,0xF9,0xD4,0xD5,0xA7,0xAF,0xAC,0xAB,0xF0,0xA8, + 0xA9,0xAA,0xEF,0xD6,0x8E,0x8F,0x92,0x80,0xE2,0x90,0xE4,0xEE,0xF5,0xF4,0xD7,0xAD, + 0xE9,0xA5,0xD8,0xD9,0xEA,0xE8,0x99,0xEC,0xED,0xF2,0xF3,0xDA,0x9A,0xDB,0x9E,0xE1, + 0x85,0xA0,0x83,0xDC,0x84,0x86,0x91,0x87,0x8A,0x82,0x88,0x89,0x8D,0xA1,0x8C,0x8B, + 0xEB,0xA4,0x95,0xA2,0x93,0xDD,0x94,0xF6,0xDE,0x97,0xA3,0x96,0x81,0xDF,0xFC,0x98} +#endif + ; +#endif + unsigned char *o, *c; + + for (o = (unsigned char *)original, c = (unsigned char *)copy; *o; o++, c++) + *c = map[*o]; + *c = '\0'; +#else + if (copy != original) + (void)strcpy(copy, original); +#endif +} + + +/*---------------------------------------------------------------------- + toNative + + Converts the incoming string to the native character set from any of + the others. The original is in the current character set which in + the case of the compiler might be other than the native. + + */ +void toNative(char copy[], /* OUT - Mapped string */ + char original[], /* IN - string to convert */ + int charset) /* IN - the current character set */ +{ + toIso(copy, original, charset); + if (NATIVECHARSET != 0) + fromIso(copy, copy); +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/sysdep.h b/engines/glk/alan2/sysdep.h new file mode 100644 index 0000000000..72769cb271 --- /dev/null +++ b/engines/glk/alan2/sysdep.h @@ -0,0 +1,409 @@ +/* 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 GLK_ALAN2_SYSDEP +#define GLK_ALAN2_SYSDEP + +/* System dependencies file for Alan Adventure Language system + * + * N.B.The test for symbols used here should really be of three types + * - processor name(like PC, x86, ...) + * - os name(DOS, WIN32, Solaris2, ...) + * - compiler name andversion(DJGPP, CYGWIN, GCC271, THINK-C, ...) + * + * The set symbols should indicate if a feature is on or off like the GNU + * AUTOCONFIG package does. + * + * This is not completely done yet! + */ + +#include "common/scummsys.h" + +namespace Glk { +namespace Alan2 { + +#define GLK +#define _PROTOTYPES_ +#define __win__ + +#ifdef GLK +#undef isdigit +#define isdigit Common::isDigit +#undef stricmp +#define stricmp scumm_stricmp +#undef strdup +#define strdup scumm_strdup +#undef rand +#define rand() g_vm->getRandomNumber(0x7fffffff) +#undef fprintf +#define fprintf(FP, STR) FP->write(STR, strlen(STR) + 1) +#endif + +/* Place definitions of OS and compiler here if necessary */ +#ifdef AZTEC_C +#define __amiga__ +#endif + +#ifndef __sun__ +#ifdef sun +#define __sun__ +#endif +#endif + +#ifdef _INCLUDE_HPUX_SOURCE +#define __hp__ +#endif + +#ifndef __unix__ +#ifdef unix +#define __unix__ +#endif +#endif + +#ifdef vax +#define __vms__ +#endif + +#ifdef THINK_C +#define __mac__ +#endif + +#ifdef __MWERKS__ +#ifdef macintosh +#define __mac__ +#else +#define __dos__ +#endif +#endif + +#ifdef DOS +#define __dos__ +#endif + +#ifdef __BORLANDC__ +#define __dos__ +#endif + +#ifdef __CYGWIN__ +#define __win__ +#endif + +#ifdef __MINGW32__ +#define __win__ +#endif + +#ifdef __PACIFIC__ +#define __dos__ +#define HAVE_SHORT_FILENAMES +#endif + + +/*---------------------------------------------------------------------- + + Below follows OS and compiler dependent settings. They should not be + changed except for introducing new sections when porting to new + environments. + + */ + +/************/ +/* Includes */ +/************/ + +#ifndef GLK +#include +#include +#endif + +#ifdef __STDC__ +#define _PROTOTYPES_ +#include +#include +#endif + +#ifdef __vms__ +/* Our VAXC doesn't define __STDC__ */ +#define _PROTOTYPES_ +#include +#include +#endif + + +#ifdef __mac__ +#define _PROTOTYPES_ +#include +#include +#include +#endif + +#ifdef __MWERKS__ +#define strdup _strdup +#endif + +/***********************/ +/* ISO character sets? */ +/***********************/ + +/* Common case first */ +#define ISO 1 +#define NATIVECHARSET 0 + +#ifdef GLK +#undef ISO +#define ISO 1 +#undef NATIVECHARSET +#define NATIVECHARSET 0 +#else /* Glk is ISO, no matter what the OS */ + +#ifdef __dos__ +#undef ISO +#define ISO 0 +#undef NATIVECHARSET +#define NATIVECHARSET 2 +#endif + +#ifdef __win__ +#undef ISO +#define ISO 1 +#undef NATIVECHARSET +#define NATIVECHARSET 2 +#endif + +#ifdef __mac__ +#undef ISO +#define ISO 0 +#undef NATIVECHARSET +#define NATIVECHARSET 1 +#endif + +#endif + +/**************************/ +/* Strings for file modes */ +/**************************/ +#define READ_MODE "r" +#define WRITE_MODE "w" + +#ifdef __mac__ +/* File open mode (binary) */ +#undef READ_MODE +#define READ_MODE "rb" +#undef WRITE_MODE +#define WRITE_MODE "wb" +#endif + +#ifdef __dos__ +/* File open mode (binary) */ +#undef READ_MODE +#define READ_MODE "rb" +#undef WRITE_MODE +#define WRITE_MODE "wb" +#endif + +#ifdef __win__ +/* File open mode (binary) */ +#undef READ_MODE +#define READ_MODE "rb" +#undef WRITE_MODE +#define WRITE_MODE "wb" +#endif + +/*****************/ +/* Byte ordering */ +/*****************/ + +#ifdef __dos__ +#define REVERSED +#endif + +#ifdef __vms__ +#define REVERSED +#endif + +#ifdef __win__ +#ifndef REVERSED +#define REVERSED +#endif +#endif + + +/****************************/ +/* Allocates cleared bytes? */ +/****************************/ + +#ifdef __CYGWIN__ +#define NOTCALLOC +#endif + +#ifdef __MINGW32__ +#define NOTCALLOC +#endif + +#ifdef __unix__ +#define NOTCALLOC +#endif + + +/****************/ +/* Have termio? */ +/****************/ + +#ifdef GLK +/* don't need TERMIO */ +#else + +#ifdef __CYGWIN__ +#define HAVE_TERMIO +#endif + +#ifdef __unix__ +#define HAVE_TERMIO +#endif + +#endif + +/*******************************/ +/* Is ANSI control available? */ +/*******************************/ + +#ifdef GLK +/* don't need ANSI */ +#else + +#ifdef __CYGWIN__ +#define HAVE_ANSI +#endif + +#endif + +/******************************/ +/* Use the READLINE function? */ +/******************************/ + +#ifdef GLK +/* Glk always uses readline(), no matter what the OS */ +#define USE_READLINE +#else + +#ifdef __unix__ +#define USE_READLINE +#endif + +#ifdef x__dos__ +#define USE_READLINE +#endif + +#ifdef __win__ +#define USE_READLINE +#endif + +#endif + +/* Special cases and definition overrides */ +#ifdef __unix__ +#define MULTI +#endif + + + + +#ifdef __vms__ + +#define MULTI + +extern char *strdup(char str[]); + +/* Cheat implementation of strftime */ +extern size_t strftime (char *, size_t, const char *, const struct tm *); + +#endif + +#ifdef __mac__ + +extern char *strdup(char *str); + +#endif + + +#ifdef __dos__ + +/* Return codes */ +#define EXIT_SUCCESS 0 +#define EXIT_FAILURE 1 + +#endif + + +#ifdef _PROTOTYPES_ + +/* Native character functions */ +extern int isSpace(int c); /* IN - Native character to test */ +extern int isLower(int c); /* IN - Native character to test */ +extern int isUpper(int c); /* IN - Native character to test */ +extern int isLetter(int c); /* IN - Native character to test */ +extern int toLower(int c); /* IN - Native character to convert */ +extern int toUpper(int c); /* IN - Native character to convert */ +extern char *strlow(char str[]); /* INOUT - Native string to convert */ +extern char *strupp(char str[]); /* INOUT - Native string to convert */ + +/* ISO character functions */ +extern int isISOLetter(int c); /* IN - ISO character to test */ +extern char toLowerCase(int c); /* IN - ISO character to convert */ +extern char toUpperCase(int c); /* IN - ISO character to convert */ +extern char *stringLower(char str[]); /* INOUT - ISO string to convert */ +extern char *stringUpper(char str[]); /* INOUT - ISO string to convert */ + +/* ISO string conversion functions */ +extern void toIso(char copy[], /* OUT - Mapped string */ + char original[], /* IN - string to convert */ + int charset); /* IN - The current character set */ + +extern void fromIso(char copy[], /* OUT - Mapped string */ + char original[]); /* IN - string to convert */ + +extern void toNative(char copy[], /* OUT - Mapped string */ + char original[], /* IN - string to convert */ + int charset); /* IN - current character set */ +#else +extern int isSpace(); +extern int isLower(); +extern int isUpper(); +extern int isLetter(); +extern int toLower(); +extern int toUpper(); +extern char *strlow(); +extern char *strupp(); + +extern int isISOLetter(); +extern char toLowerCase(); +extern char toUpperCase(); +extern char *stringLower(); +extern char *stringUpper(); + +extern void toIso(); +extern void fromIso(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/term.cpp b/engines/glk/alan2/term.cpp new file mode 100644 index 0000000000..cf60fc5bbe --- /dev/null +++ b/engines/glk/alan2/term.cpp @@ -0,0 +1,123 @@ +/* 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/alan2/main.h" +#include "glk/alan2/term.h" + +namespace Glk { +namespace Alan2 { + +/*====================================================================== + + getPageSize() + + Try to get the current page size from the system, else use the ones + from the header. + + */ +#ifdef _PROTOTYPES_ +void getPageSize(void) +#else +void getPageSize() +#endif +{ +#ifdef GLK + paglen = 0; + pagwidth = 0; + +#else +#ifdef HAVE_TERMIO + +#include + + extern int ioctl(); + + struct winsize win; + int ecode; + + ecode = ioctl(1, TIOCGWINSZ, &win); + + if (ecode != 0 || win.ws_row == 0) + paglen = header->paglen; + else + paglen = win.ws_row; + + if (ecode != 0 || win.ws_col == 0) + pagwidth = header->pagwidth; + else + pagwidth = win.ws_col; + +#else +#ifdef __amiga__ +#include +#include +#include +#include + + struct Process * proc; + struct InfoData *id; + struct Window *win; + struct TextFont *textFont; + struct StandardPacket *packet; + + proc = (struct Process *) FindTask(0L); + + id = (struct InfoData *) allocate(sizeof(struct InfoData)); + + if (proc->pr_ConsoleTask) { + packet = (struct StandardPacket *) allocate(sizeof(struct StandardPacket)); + packet->sp_Msg.mn_Node.ln_Name = (char *)&(packet->sp_Pkt); + packet->sp_Pkt.dp_Link = & packet->sp_Msg; + packet->sp_Pkt.dp_Port = & proc->pr_MsgPort; + packet->sp_Pkt.dp_Type = ACTION_DISK_INFO; + + packet->sp_Pkt.dp_Arg1 = ((LONG) id) >> 2; + + PutMsg ((struct MsgPort *) proc->pr_ConsoleTask, & packet->sp_Msg); + WaitPort(&proc->pr_MsgPort); + GetMsg(&proc->pr_MsgPort); + free((char *)packet); + + win = (struct Window *) id->id_VolumeNode; + free(id); + + /* Calculate number of characters and lines w.r.t font size and borders */ + textFont = win->IFont; + paglen = win->Height/textFont->tf_YSize-2; + pagwidth = win->Width/textFont->tf_XSize-3; + } else { + paglen = header->paglen; + pagwidth = header->pagwidth; + } + +#else + + paglen = header->paglen; + pagwidth = header->pagwidth; + +#endif +#endif +#endif +} + +} // End of namespace Alan2 +} // End of namespace Glk diff --git a/engines/glk/alan2/term.h b/engines/glk/alan2/term.h new file mode 100644 index 0000000000..339a3b5e82 --- /dev/null +++ b/engines/glk/alan2/term.h @@ -0,0 +1,42 @@ +/* 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 GLK_ALAN2_TERM +#define GLK_ALAN2_TERM + +/* Header file for terminal functions in ARUN, the Alan interpreter */ + +namespace Glk { +namespace Alan2 { + +#ifdef _PROTOTYPES_ + +extern void getPageSize(void); + +#else +extern void getPageSize(); +#endif + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/alan2/types.h b/engines/glk/alan2/types.h index 7da9e1dc58..2de31c06bf 100644 --- a/engines/glk/alan2/types.h +++ b/engines/glk/alan2/types.h @@ -23,248 +23,261 @@ #ifndef GLK_ALAN2_TYPES #define GLK_ALAN2_TYPES +#include "glk/alan2/sysdep.h" #include "glk/alan2/acode.h" namespace Glk { namespace Alan2 { -// CONSTANTS - -#define ACTMIN (_vm->header->actmin) -#define ACTMAX (_vm->header->actmax) -#define OBJMIN (_vm->header->objmin) -#define OBJMAX (_vm->header->objmax) -#define LOCMIN (_vm->header->locmin) -#define LOCMAX (_vm->header->locmax) -#define CNTMIN (_vm->header->cntmin) -#define CNTMAX (_vm->header->cntmax) -#define LITMIN (_vm->header->locmax + 1) -#define LITMAX (_vm->header->locmax + 1 + litCount) -#define EVTMIN (_vm->header->evtmin) -#define EVTMAX (_vm->header->evtmax) +/* CONSTANTS */ + +#ifndef __mac__ +#ifndef TRUE +#define TRUE (0==0) +#endif +#ifndef FALSE +#define FALSE (!TRUE) +#endif +#endif + +#define ACTMIN (header->actmin) +#define ACTMAX (header->actmax) +#define OBJMIN (header->objmin) +#define OBJMAX (header->objmax) +#define LOCMIN (header->locmin) +#define LOCMAX (header->locmax) +#define CNTMIN (header->cntmin) +#define CNTMAX (header->cntmax) +#define LITMIN (header->locmax+1) +#define LITMAX (header->locmax+1+litCount) +#define EVTMIN (header->evtmin) +#define EVTMAX (header->evtmax) #define HERO ACTMIN -#define addrTo(x) (&_vm->memory[x]) - -// The word classes are represented as numbers but in the dictonary they are generated as bits -#define isVerb(word) (word < dictsize && (dict[word].wordClass&((Aword)1L<= dictsize) -// TYPES - -// Amachine variables -struct CurVars { - int vrb; - int obj; - int loc; - int act; - int tick; - int score; - int visits; -}; - -// The various tables -struct WrdElem { // Dictionary - Aaddr wrd; // ACODE address to string - Aword wordClass; // Word class - Aword code; - Aaddr adjrefs; // Address to reference list - Aaddr nounrefs; // Address to reference list -}; - -struct ActElem { // ACTOR TABLE - Aword loc; // Location - Abool describe; // Description flag - Aaddr nam; // Address to name printing code - Aaddr atrs; // Address to attribute list - Aword cont; // Code for the container props if any - Aword script; // Which script is he using - Aaddr scradr; // Address to script table - Aword step; - Aword count; - Aaddr vrbs; - Aaddr dscr; // Address of description code -}; - -struct ScrElem { // SCRIPT TABLE - Aword code; // Script number - Aaddr dscr; // Optional description statements - Aaddr steps; // Address to steps -}; - -struct StepElem { // STEP TABLE - Aword after; // After how many ticks? - Aaddr exp; // Address to expression saying when - Aaddr stm; // Address to the actual code -}; - -struct LocElem { // LOCATION TABLE - Aaddr nams; // Address of name printing code - Aaddr dscr; // Address of description code - Aaddr does; // Address of does code - Aword describe; // Description flag & counter - Aaddr atrs; // Address of attribute list - Aaddr exts; // Address of exit list - Aaddr vrbs; // Address of local verb list -}; - -struct ExtElem { // EXIT TABLE structure - Abool done; // Flag for reverse/convert process - Aword code; // Direction code - Aaddr checks; // Address of check table - Aaddr action; // Address of action code - Aword next; // Number of next location -}; - -struct ChkElem { // CHECK TABLE - Aaddr exp; // ACODE address to expression code - Aaddr stms; // ACODE address to statement code -}; - -struct VrbElem { // VERB TABLE - Aword code; // Code for the verb - Aaddr alts; // Address to alternatives -}; - -struct StxElem { // SYNTAX TABLE - Aword code; // Code for verb word - Aaddr elms; // Address to element tables -}; - -struct ElmElem26 { // ELEMENT TABLES - Aword code; // Code for this element, 0 -> parameter - Abool multiple; // May be multiple (if parameter) - Aaddr next; // Address to next element table ... - // ... or class check if EOS -}; - -struct ElmElem { // ELEMENT TABLES - Aword code; // Code for this element, 0 -> parameter - Aword flags; // Flags for multiple/omni (if parameter) - // CHANGED: v2.7 from Abool for multiple - Aaddr next; // Address to next element table ... - // ... or class check if EOS -}; - -struct ClaElem { // CLASS DEFINITION TABLE - Aword code; // Parameter number - Aword classes; // Parameter classes - Aaddr stms; // Exception statements -}; - -struct AltElem { // VERB ALTERNATIVE TABLE - Abool done; // Flag for patching (reverse/convert) process - Aword param; // Parameter number - Aword qual; // Verb execution qualifier - Aaddr checks; // Address of the check table - Aaddr action; // Address of the action code -}; - -struct AtrElem { // ATTRIBUTE LIST - Aword val; // Its value - Aaddr stradr; // Address to the name -}; - -struct ObjElem25 { // OBJECT TABLE of 2.5 format - Aword loc; // Current location - Abool describe; // Describe flag - Aaddr atrs; // Address of attribute list - Aword cont; // Index to container properties if any - Aaddr vrbs; // Address to local verb table - Aaddr dscr1; // Address to Aword description code - Aaddr dscr2; // Address to short description code -}; - -struct ObjElem { // OBJECT TABLE - Aword loc; // Current location - Abool describe; // Describe flag - Aaddr atrs; // Address of attribute list - Aword cont; // Index to container properties if any - Aaddr vrbs; // Address to local verb table - Aaddr dscr1; // Address to Aword description code - Aaddr art; // Article printing code? Else use default - // INTRODUCED: v2.6 - Aaddr dscr2; // Address to short description code -}; - -struct CntElem { // CONTAINER TABLE - Aaddr lims; // Address to limit check code - Aaddr header; // Address to header code - Aaddr empty; // Address to empty code - Aword parent; // Object or actor index - Aaddr nam; // Address to statement printing name -}; - -struct LimElem { // LIMIT Type - Aword atr; // Attribute that limits - Aword val; // And the limiting value - Aaddr stms; // Statements if fail -}; - -struct RulElem { // RULE TABLE - Abool run; // Is rule already run? - Aaddr exp; // Address to expression code - Aaddr stms; // Address to run -}; - -struct EvtElem { // EVENT TABLE - Aaddr stradr; // Address to name string - Aaddr code; // Address of code to run -}; - -struct EvtqElem { // EVENT QUEUE ELEMENT - int time; - int event; - int where; -}; - -struct IniElem { // STRING INITIALISATION TABLE - Aword fpos; // File position - Aword len; // Length - Aword adr; // Where to store the string -}; - -struct MsgElem26 { // MESSAGE TABLE - Aword fpos; // File position - Aword len; // Length of message -}; - -struct MsgElem { // MESSAGE TABLE - Aaddr stms; // Address to statements - // Changed v2.7 from fpos+len in .dat -}; - -struct ParamElem { // PARAMETER - Aword code; // Code for this parameter (0=multiple) - Aword firstWord; // Index to first word used by player - Aword lastWord; // d:o to last -}; - -enum Type { - TYPNUM, - TYPSTR -}; - -struct LitElem { // LITERAL - Type type; - Aptr value; -}; +/* TYPES */ + +#ifndef __mac__ +typedef int Boolean; /* Boolean values within interpreter */ +#endif + +/* Amachine variables */ +typedef struct CurVars { + int + vrb, + obj, + loc, + act, + tick, + score, + visits; +} CurVars; + +/* The various tables */ +typedef struct WrdElem { /* Dictionary */ + Aaddr wrd; /* ACODE address to string */ + Aword _class; /* Word class */ + Aword code; + Aaddr adjrefs; /* Address to reference list */ + Aaddr nounrefs; /* Address to reference list */ +} WrdElem; + +typedef struct ActElem { /* ACTOR TABLE */ + Aword loc; /* Location */ + Abool describe; /* Description flag */ + Aaddr nam; /* Address to name printing code */ + Aaddr atrs; /* Address to attribute list */ + Aword cont; /* Code for the container props if any */ + Aword script; /* Which script is he using */ + Aaddr scradr; /* Address to script table */ + Aword step; + Aword count; + Aaddr vrbs; + Aaddr dscr; /* Address of description code */ +} ActElem; + +typedef struct ScrElem { /* SCRIPT TABLE */ + Aword code; /* Script number */ + Aaddr dscr; /* Optional description statements */ + Aaddr steps; /* Address to steps */ +} ScrElem; + +typedef struct StepElem { /* STEP TABLE */ + Aword after; /* After how many ticks? */ + Aaddr exp; /* Address to expression saying when */ + Aaddr stm; /* Address to the actual code */ +} StepElem; + +typedef struct LocElem { /* LOCATION TABLE */ + Aaddr nams; /* Address of name printing code */ + Aaddr dscr; /* Address of description code */ + Aaddr does; /* Address of does code */ + Aword describe; /* Description flag & counter */ + Aaddr atrs; /* Address of attribute list */ + Aaddr exts; /* Address of exit list */ + Aaddr vrbs; /* Address of local verb list */ +} LocElem; + +typedef struct ExtElem { /* EXIT TABLE structure */ + Abool done; /* Flag for reverse/convert process */ + Aword code; /* Direction code */ + Aaddr checks; /* Address of check table */ + Aaddr action; /* Address of action code */ + Aword next; /* Number of next location */ +} ExtElem; + +typedef struct ChkElem { /* CHECK TABLE */ + Aaddr exp; /* ACODE address to expression code */ + Aaddr stms; /* ACODE address to statement code */ +} ChkElem; + +typedef struct VrbElem { /* VERB TABLE */ + Aword code; /* Code for the verb */ + Aaddr alts; /* Address to alternatives */ +} VrbElem; + +typedef struct StxElem { /* SYNTAX TABLE */ + Aword code; /* Code for verb word */ + Aaddr elms; /* Address to element tables */ +} StxElem; + +typedef struct ElmElem26 { /* ELEMENT TABLES */ + Aword code; /* Code for this element, 0 -> parameter */ + Abool multiple; /* May be multiple (if parameter) */ + Aaddr next; /* Address to next element table ... */ + /* ... or class check if EOS */ +} ElmElem26; + +typedef struct ElmElem { /* ELEMENT TABLES */ + Aword code; /* Code for this element, 0 -> parameter */ + Aword flags; /* Flags for multiple/omni (if parameter) */ + /* CHANGED: v2.7 from Abool for multiple */ + Aaddr next; /* Address to next element table ... */ + /* ... or class check if EOS */ +} ElmElem; + +typedef struct ClaElem { /* CLASS DEFINITION TABLE */ + Aword code; /* Parameter number */ + Aword classes; /* Parameter classes */ + Aaddr stms; /* Exception statements */ +} ClaElem; + +typedef struct AltElem { /* VERB ALTERNATIVE TABLE */ + Abool done; /* Flag for patching (reverse/convert) process */ + Aword param; /* Parameter number */ + Aword qual; /* Verb execution qualifier */ + Aaddr checks; /* Address of the check table */ + Aaddr action; /* Address of the action code */ +} AltElem; + +typedef struct AtrElem { /* ATTRIBUTE LIST */ + Aword val; /* Its value */ + Aaddr stradr; /* Address to the name */ +} AtrElem; + +typedef struct ObjElem25 { /* OBJECT TABLE of 2.5 format*/ + Aword loc; /* Current location */ + Abool describe; /* Describe flag */ + Aaddr atrs; /* Address of attribute list */ + Aword cont; /* Index to container properties if any */ + Aaddr vrbs; /* Address to local verb table */ + Aaddr dscr1; /* Address to Aword description code */ + Aaddr dscr2; /* Address to short description code */ +} ObjElem25; + +typedef struct ObjElem { /* OBJECT TABLE */ + Aword loc; /* Current location */ + Abool describe; /* Describe flag */ + Aaddr atrs; /* Address of attribute list */ + Aword cont; /* Index to container properties if any */ + Aaddr vrbs; /* Address to local verb table */ + Aaddr dscr1; /* Address to Aword description code */ + Aaddr art; /* Article printing code? Else use default */ + /* INTRODUCED: v2.6 */ + Aaddr dscr2; /* Address to short description code */ +} ObjElem; + +typedef struct CntElem { /* CONTAINER TABLE */ + Aaddr lims; /* Address to limit check code */ + Aaddr header; /* Address to header code */ + Aaddr empty; /* Address to empty code */ + Aword parent; /* Object or actor index */ + Aaddr nam; /* Address to statement printing name */ +} CntElem; + +typedef struct LimElem { /* LIMIT Type */ + Aword atr; /* Attribute that limits */ + Aword val; /* And the limiting value */ + Aaddr stms; /* Statements if fail */ +} LimElem; + +typedef struct RulElem { /* RULE TABLE */ + Abool run; /* Is rule already run? */ + Aaddr exp; /* Address to expression code */ + Aaddr stms; /* Address to run */ +} RulElem; + +typedef struct EvtElem { /* EVENT TABLE */ + Aaddr stradr; /* Address to name string */ + Aaddr code; /* Address of code to run */ +} EvtElem; + +typedef struct EvtqElem { /* EVENT QUEUE ELEMENT */ + int time; + int event; + int where; +} EvtqElem; + +typedef struct IniElem { /* STRING INITIALISATION TABLE */ + Aword fpos; /* File position */ + Aword len; /* Length */ + Aword adr; /* Where to store the string */ +} IniElem; + +typedef struct MsgElem26 { /* MESSAGE TABLE */ + Aword fpos; /* File position */ + Aword len; /* Length of message */ +} MsgElem26; + +typedef struct MsgElem { /* MESSAGE TABLE */ + Aaddr stms; /* Address to statements*/ + /* Changed v2.7 from fpos+len in .dat */ +} MsgElem; + + +typedef struct ParamElem { /* PARAMETER */ + Aword code; /* Code for this parameter (0=multiple) */ + Aword firstWord; /* Index to first word used by player */ + Aword lastWord; /* d:o to last */ +} ParamElem; + +typedef enum Type {TYPNUM, TYPSTR} Type; + +typedef struct LitElem { /* LITERAL */ + Type type; + Aptr value; +} LitElem; #define MAXPARAMS 9 -#define MAXENTITY (_vm->header->actmax) +#define MAXENTITY (header->actmax) } // End of namespace Alan2 } // End of namespace Glk diff --git a/engines/glk/alan2/util.h b/engines/glk/alan2/util.h index 5ea14106bd..21993eb80d 100644 --- a/engines/glk/alan2/util.h +++ b/engines/glk/alan2/util.h @@ -23,65 +23,11 @@ #ifndef GLK_ALAN2_UTIL #define GLK_ALAN2_UTIL -#include "glk/alan2/acode.h" -#include "glk/alan2/alan2.h" #include "glk/alan2/types.h" namespace Glk { namespace Alan2 { -// TODO: Move these -extern LitElem *litValues; -extern uint32 litCount; // for LITMAX - defined in parse.cpp -extern ActElem *acts; // Actor table pointer -extern ObjElem *objs; // Object table pointer - -// Type checks -inline bool isObj(Aword x) { - return x >= OBJMIN && x <= OBJMAX; -} - -inline bool isAct(Aword x) { - return x >= ACTMIN && x <= ACTMAX; -} - -inline bool isCnt(Aword x) { - return (x >= CNTMIN && x <= CNTMAX) || - (isObj(x) && objs[x - OBJMIN].cont != 0) || - (isAct(x) && acts[x - ACTMIN].cont != 0); -} - -inline bool isLoc(Aword x) { - return x >= LOCMIN && x <= LOCMAX; -} - -inline bool isNum(Aword x) { - return x >= LITMIN && x <= LITMAX && litValues[x - LITMIN].type == TYPNUM; -} - -inline bool isStr(Aword x) { - return x >= LITMIN && x <= LITMAX && litValues[x - LITMIN].type == TYPSTR; -} - -inline bool isLit(Aword x) { - return x >= LITMIN && x <= LITMAX; -} - -inline bool endOfTable(LimElem *addr) { - Aword *x = (Aword *)addr; - return *x == (Aword)EOF; -} - -inline bool endOfTable(ScrElem *addr) { - Aword *x = (Aword *)addr; - return *x == (Aword)EOF; -} - -inline bool endOfTable(ExtElem *addr) { - Aword *x = (Aword *)addr; - return *x == (Aword)EOF; -} - } // End of namespace Alan2 } // End of namespace Glk diff --git a/engines/glk/alan2/version.h b/engines/glk/alan2/version.h new file mode 100644 index 0000000000..3bb90ad066 --- /dev/null +++ b/engines/glk/alan2/version.h @@ -0,0 +1,59 @@ +/* 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 GLK_ALAN2_VERSION +#define GLK_ALAN2_VERSION + +#include "common/system.h" + +namespace Glk { +namespace Alan2 { + +typedef int64 Time; + +struct Version { + char* string; + int version; + int revision; + int correction; + Time time; + char *state; +}; + +struct Product { + char* name; + char* slogan; + char* shortHeader; + char* longHeader; + char* date; + char* time; + char* user; + char* host; + char* ostype; + Version version; +}; + + +} // End of namespace Alan2 +} // End of namespace Glk + +#endif diff --git a/engines/glk/module.mk b/engines/glk/module.mk index bfda72d34a..b87fea9311 100644 --- a/engines/glk/module.mk +++ b/engines/glk/module.mk @@ -33,6 +33,22 @@ MODULE_OBJS := \ advsys/vm.o \ alan2/alan2.o \ alan2/detection.o \ + alan2/alan_version.o \ + alan2/args.o \ + alan2/debug.o \ + alan2/decode.o \ + alan2/exe.o \ + alan2/glkio.o \ + alan2/glkstart.o \ + alan2/inter.o \ + alan2/params.o \ + alan2/parse.o \ + alan2/readline.o \ + alan2/reverse.o \ + alan2/rules.o \ + alan2/stack.o \ + alan2/sysdep.o \ + alan2/term.o \ frotz/bitmap_font.o \ frotz/config.o \ frotz/detection.o \ -- cgit v1.2.3