aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--engines/glk/hugo/herun.cpp2810
-rw-r--r--engines/glk/hugo/hugo.cpp9
-rw-r--r--engines/glk/hugo/hugo.h193
-rw-r--r--engines/glk/hugo/hugo_defines.h18
-rw-r--r--engines/glk/hugo/hugo_types.h20
-rw-r--r--engines/glk/module.mk1
6 files changed, 3027 insertions, 24 deletions
diff --git a/engines/glk/hugo/herun.cpp b/engines/glk/hugo/herun.cpp
new file mode 100644
index 0000000000..43837977d5
--- /dev/null
+++ b/engines/glk/hugo/herun.cpp
@@ -0,0 +1,2810 @@
+/* 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/hugo/hugo.h"
+
+namespace Glk {
+namespace Hugo {
+
+void Hugo::RunDo() {
+ long skip, enterptr;
+
+ enterptr = ++codeptr;
+ skip = PeekWord(codeptr); /* remember the skip distance */
+ codeptr+=2;
+
+ SetStackFrame(stack_depth, DOWHILE_BLOCK, skip+enterptr, codeptr);
+
+#if defined (DEBUGGER)
+ dbnest++;
+#endif
+}
+
+void Hugo::RunEvents() {
+ int i, tempundo, flag, temp_ret;
+ int eventin, tempself;
+ int templocals[MAXLOCALS];
+ int temp_stack_depth;
+ int temp_parse_location;
+ long tempptr, eventaddr;
+#if defined (DEBUGGER)
+ int tempdbnest;
+#endif
+
+ tempundo = undorecord;
+ undorecord = true;
+
+ tempptr = codeptr;
+ tempself = var[self];
+ temp_ret = ret;
+ temp_parse_location = parse_location;
+
+ parse_location = var[location]; /* for Available() */
+
+ temp_stack_depth = stack_depth;
+
+ for (i=0; i<MAXLOCALS; i++)
+ templocals[i] = var[MAXGLOBALS+i];
+
+ for (i=0; i<events; i++)
+ {
+ defseg = eventtable;
+
+ eventin = PeekWord(2 + i * 4);
+ eventaddr = (long)PeekWord(2 + i * 4 + 2)*address_scale;
+ var[self] = eventin;
+
+ domain = 0, flag = 0;
+
+#if defined (DEBUGGER)
+ /* Prevent premature stopping */
+ if (debugger_step_over && !debugger_finish)
+ debugger_run = true;
+#endif
+ if (eventin==0 || GrandParent(eventin)==GrandParent(var[player]))
+ flag = 1;
+
+ /* true is to signal a non-grammar call */
+ else if (Available(eventin, true))
+ flag = 1;
+
+ if (flag)
+ {
+ PassLocals(0);
+
+ SetStackFrame(stack_depth, RUNROUTINE_BLOCK, 0, 0);
+#if defined (DEBUGGER)
+ tempdbnest = dbnest;
+ DebugRunRoutine(eventaddr);
+ dbnest = tempdbnest;
+#else
+ RunRoutine(eventaddr);
+#endif
+ stack_depth = temp_stack_depth;
+
+ retflag = 0;
+ if (var[endflag]) break;
+ }
+ }
+
+ for (i=0; i<MAXLOCALS; i++)
+ var[MAXGLOBALS+i] = templocals[i];
+
+ codeptr = tempptr;
+ parse_location = temp_parse_location;
+ var[self] = tempself;
+ undorecord = (char)tempundo;
+ ret = temp_ret;
+}
+
+void Hugo::playGame() {
+ char jw = 0; /* just wrote undo info */
+ char wasxverb = 0, newinput;
+ int i, flag, mc, lastspeaking = 0, startlocation;
+
+#ifdef USE_TEXTBUFFER
+ TB_Init();
+#endif
+
+#ifdef PALMOS
+ if (AutoResume())
+ {
+ goto FreshInput;
+ }
+#endif
+
+ /* Set up initial screen position */
+ hugo_settextpos(1, physical_windowheight/lineheight);
+ display_needs_repaint = false;
+ full = 0;
+
+ /* Load globals */
+ defseg = arraytable;
+ for (i=0; i<MAXGLOBALS; i++)
+ var[i] = PeekWord(i*2);
+
+ /* Reset the speaking-to variable */
+ speaking = 0;
+
+ if (game_version < 22)
+ {
+ passlocal[0] = objects;
+#if defined (ACTUAL_LINELENGTH)
+ passlocal[1] = ACTUAL_LINELENGTH();
+#else
+ passlocal[1] = physical_windowwidth/FIXEDCHARWIDTH;
+#endif
+ }
+
+#if defined (DEBUGGER)
+RestartDebugger:
+
+ dictcount = original_dictcount; /* see hd.c */
+
+ /* If no gamefile is loaded, jump immediately to the debugger
+ interrupt function.
+ */
+ if (game==NULL) Debugger();
+#endif
+
+ stack_depth = RESET_STACK_DEPTH;
+
+ InitGame();
+
+ undoptr = 0;
+ undoturn = 0;
+ undoinvalid = 1;
+ undorecord = 0;
+
+Start:
+ stack_depth = 0;
+
+ strcpy(errbuf, "");
+ strcpy(oops, "");
+
+ do
+ {
+ if (xverb==0)
+ {
+ undorecord = true;
+
+ SetStackFrame(RESET_STACK_DEPTH, RUNROUTINE_BLOCK, 0, 0);
+
+ PassLocals(0);
+
+#if defined (DEBUGGER)
+ currentroutine = mainaddr;
+ window[VIEW_CALLS].count = 0;
+
+ /* If there is no Main routine */
+ if (currentroutine==0) goto NormalTermination;
+
+ DebugRunRoutine((long)mainaddr*address_scale);
+#else
+ RunRoutine((long)mainaddr*address_scale);
+#endif
+ undorecord = false;
+ if (retflag)
+ break;
+ }
+
+ if (!undoinvalid && !wasxverb)
+ {
+ undorecord = true;
+ SaveUndo(0, undoturn, 0, 0, 0);
+ undorecord = false;
+ undoturn = 0;
+ }
+ else if (undoinvalid)
+ {
+ undoptr = 0;
+ undoinvalid = 0;
+ undoturn = 0;
+ undorecord = true;
+ SaveUndo(0, 0, 0, 0, 0);
+ SaveUndo(0, 0, 0, 0, 0);
+ undorecord = false;
+ }
+
+ xverb = true;
+
+ jw = 1;
+ if (var[endflag])
+ break;
+ jw = 0;
+
+ full_buffer = 0;
+
+ /* Endless game loop begins here */
+
+ do
+ {
+ PassLocals(0);
+
+ /* If there's nothing waiting to be finished in the
+ input buffer:
+ */
+ if (!remaining)
+ {
+ newinput = true;
+ speaking = 0;
+ do
+ {
+FreshInput:
+ if (full_buffer != true)
+ {
+ newinput = true;
+ speaking = 0;
+ var[actor] = var[player];
+#if defined (DEBUGGER)
+ AddStringtoCodeWindow("[Waiting for input]");
+ buffered_code_lines = FORCE_REDRAW;
+ debugger_has_stepped_back = false;
+ window[VIEW_LOCALS].changed = true;
+#endif
+ if (!playback)
+ {
+ GetCommand();
+ }
+ else
+ {
+ if (!hugo_fgets(buffer, MAXBUFFER, *playback))
+ {
+ if (hugo_fclose(playback))
+ FatalError(READ_E);
+ playback = NULL;
+ GetCommand();
+ }
+ else
+ {
+ /* Remove CR/LF */
+/*
+ buffer[strlen(buffer)-1] = '\0';
+ if (buffer[strlen(buffer)-1]==0x0d)
+ buffer[strlen(buffer)-1] = '\0';
+*/
+ while (buffer[strlen(buffer)-1]==0x0d || buffer[strlen(buffer)-1]==0x0a)
+ buffer[strlen(buffer)-1] = '\0';
+ sprintf(line, "\n%s%s", GetWord(var[prompt]), buffer);
+ if (script)
+ /* fprintf() this way for Glk */
+ script->putBuffer("\n", 1);
+#if defined (SCROLLBACK_DEFINED)
+ hugo_sendtoscrollback("\n");
+#endif
+ AP(line);
+ }
+ }
+#if defined (DEBUGGER)
+ if (debugger_collapsing)
+ goto NormalTermination;
+ runaway_counter = 0;
+#endif
+
+ SeparateWords();
+
+ if (record)
+ {
+ for (i=1; i<=words; i++)
+ {
+ if (!strcmp(word[i], "."))
+ {
+ /* fprintf() this way for Glk */
+ if (hugo_fprintf(record, "%s", "\n")<0)
+ FatalError(WRITE_E);
+ if (i==words) goto RecordedNewline;
+ }
+ else if (hugo_fputs(word[i], record)<0
+ || hugo_fprintf(record, "%s", " ")<0)
+ {
+ FatalError(WRITE_E);
+ }
+ }
+ if (hugo_fprintf(record, "%s", "\n")<0) FatalError(WRITE_E);
+RecordedNewline:;
+ }
+ }
+ else full_buffer = false;
+
+ if (!strcmp(buffer, "") || buffer[0]=='.')
+ {
+ strcpy(parseerr, "");
+
+ /* "What?" */
+ ParseError(0, 0);
+ goto FreshInput;
+ }
+ }
+
+ /* Loop until valid input */
+ while (Parse()==false && strcmp(buffer, ""));
+ }
+
+
+ /* Else if there's something left in the input buffer */
+ else
+ {
+ newinput = false;
+
+ /* Erase the just-parsed command, and check to
+ to see if what's left is just blanks
+ */
+ while (words > remaining)
+ KillWord(1);
+ flag = false;
+ for (i=1; i<=words; i++)
+ if (wd[i]!=0) flag = true;
+ if (!flag)
+ goto FreshInput;
+
+ if (words) AP("");
+
+ if (Parse()==false)
+ {
+ mc = false;
+ goto Skipmc;
+ }
+ }
+
+ /* Run the user Parse routine if one exists */
+ CallLibraryParse();
+
+ reparse_everything = false;
+ do
+ {
+ mc = MatchCommand();
+ if (mc==false)
+ {
+ remaining = 0;
+ }
+ } while (reparse_everything && !mc);
+Skipmc:;
+ }
+ while (!mc);
+
+ if (!xverb) undorecord = true;
+
+ wasxverb = xverb;
+
+ /* If there's an unknown string to be put in parse$ */
+ if (parsestr[0]!='\0')
+ {
+ if (parsestr[0]=='\"')
+ {
+ strcpy(parseerr, Right(parsestr, strlen(parsestr)-1));
+ if (parseerr[strlen(parseerr)-1]=='\"')
+ parseerr[strlen(parseerr)-1] = '\0';
+ }
+ }
+ else
+ strcpy(parseerr, "");
+
+ /* default actor */
+ var[actor] = var[player];
+
+ if (!newinput && lastspeaking) speaking = lastspeaking;
+
+ if (var[verbroutine]!=0 || (speaking))
+ {
+ /* If command addresses an object/char. */
+ if (speaking)
+ {
+ lastspeaking = speaking;
+ var[actor] = speaking;
+
+ /* If user Speakto routine exists */
+ if (speaktoaddr)
+ {
+ if (objcount) var[object] = objlist[0];
+ ret = 0;
+
+ SetStackFrame(RESET_STACK_DEPTH, RUNROUTINE_BLOCK, 0, 0);
+
+ passlocal[0] = speaking;
+ PassLocals(1);
+#if defined (DEBUGGER)
+ DebugRunRoutine((long)speaktoaddr*address_scale);
+#else
+ RunRoutine((long)speaktoaddr*address_scale);
+#endif
+ if (ret==0)
+ {
+ remaining = 0;
+ xverb = true;
+ }
+ retflag = 0;
+ }
+
+ else
+ {
+ /* "...start with a verb..." */
+ ParseError(2, 0);
+ xverb = true;
+ }
+
+ /* reset actor */
+ var[actor] = var[player];
+ }
+
+ /* Regular old vanilla command: */
+ else
+ {
+ speaking = 0;
+ lastspeaking = 0;
+
+ /* As of v2.5, the Perform junction routine takes care of calling the
+ before routines, verbroutine, etc.
+ */
+ if (game_version>=25 && performaddr!=0)
+ {
+ i = 0;
+NextPerform:
+ if (objcount) var[object] = objlist[i];
+
+ /* Have to do this before passing locals, in case
+ Name() ends up calling a routine (which would
+ trash passlocal[])
+ */
+ if (parseerr[0]=='\0' && parsestr[0]=='\0')
+ strcpy(parseerr, Name(objlist[i]));
+
+ /* Set up arguments for Perform */
+ passlocal[0] = var[verbroutine];
+ passlocal[1] = var[object];
+ passlocal[2] = var[xobject];
+
+ /* 'queue' argument, >1 if objcount > 1, or if
+ "all" has been used to refer to object(s) */
+ passlocal[3] = (objcount>1)?(i+1):(parse_allflag?1:0);
+ /* -1 if object is a digit */
+ if (object_is_number) passlocal[3] = (short)-1;
+
+ /* 'isxverb' argument */
+ if (game_version>=31 && xverb)
+ passlocal[4] = 1;
+
+ obj_match_state = -1;
+ startlocation = var[location];
+ ret = 0;
+
+ SetStackFrame(RESET_STACK_DEPTH, RUNROUTINE_BLOCK, 0, 0);
+
+ PassLocals(4);
+#if defined (DEBUGGER)
+ DebugRunRoutine((long)performaddr*address_scale);
+#else
+ RunRoutine((long)performaddr*address_scale);
+#endif
+ if (ret==0)
+ {
+ remaining = 0;
+ xverb = true;
+ }
+ retflag = 0;
+
+ /* Break if endflag is set or if the location has
+ changed from the first call to Perform
+ */
+ if (var[endflag] || startlocation!=var[location])
+ goto EndofCommand;
+
+ if (objcount>1 && ++i<objcount)
+ goto NextPerform;
+ }
+
+ /* v2.4 or earlier had to call the verb loop via the engine
+ (as does v2.5 with no Perform routine */
+
+ /* One or more objects specified */
+ else if (objcount > 0) /* "if (objcount > 0" for pre-v2.5 */
+ {
+ obj_match_state = 1;
+ startlocation = var[location];
+ for (i=0; i<objcount; i++)
+ {
+ if (parseerr[0]=='\0' && parsestr[0]=='\0')
+ strcpy(parseerr, Name(objlist[i]));
+
+ if (ValidObj(objlist[i]) &&
+ ((objcount>1 && objlist[i]!=var[xobject]) || objcount==1))
+ {
+ var[object] = objlist[i];
+ if (GetProp(var[player], before, 1, 0)==0)
+ if (GetProp(var[location], before, 1, 0)==0)
+ if (GetProp(var[xobject], before, 1, 0)==0)
+ {
+ /* If multiple objects are specified, print
+ "name: " for each:
+ */
+ if (objcount > 1)
+ {
+ sprintf(line, "%s: \\;", Name(var[object]));
+ AP(line);
+ }
+
+ obj_match_state = 0;
+
+ if ((object_is_number) || GetProp(var[object], before, 1, 0)==0)
+ {
+ obj_match_state = -1;
+ ret = 0;
+
+ SetStackFrame(RESET_STACK_DEPTH, RUNROUTINE_BLOCK, 0, 0);
+
+ PassLocals(0);
+#if defined (DEBUGGER)
+ DebugRunRoutine((long)var[verbroutine]*address_scale);
+#else
+ RunRoutine((long)var[verbroutine]*address_scale);
+#endif
+ if (ret==0)
+ {
+ remaining = 0;
+ xverb = true;
+ }
+ retflag = 0;
+
+ GetProp(var[player], after, 1, 0);
+ GetProp(var[location], after, 1, 0);
+ }
+ }
+ }
+ if (var[endflag] || var[location]!=startlocation)
+ break;
+ }
+ }
+
+ /* No object(s) specified */
+ else
+ {
+ if (GetProp(var[player], before, 1, 0)==0)
+ {
+ if (GetProp(var[location], before, 1, 0)==0)
+ {
+ ret = 0;
+
+ SetStackFrame(RESET_STACK_DEPTH, RUNROUTINE_BLOCK, 0, 0);
+
+ PassLocals(0);
+#if defined (DEBUGGER)
+ DebugRunRoutine((long)var[verbroutine]*address_scale);
+#else
+ RunRoutine((long)var[verbroutine]*address_scale);
+#endif
+ if (ret==0)
+ {
+ remaining = 0;
+ xverb = true;
+ }
+ retflag = 0;
+
+ GetProp(var[player], after, 1, 0);
+ GetProp(var[location], after, 1, 0);
+ }
+ }
+ }
+
+ /* (end of pre-v2.5 verbroutine-calling) */
+
+ }
+ }
+EndofCommand:
+ if (var[endflag])
+ break;
+
+ undorecord = false;
+ }
+ while (true); /* endless loop back to start */
+
+ undorecord = false;
+
+ if (var[endflag]==-1)
+#if defined (DEBUGGER)
+ goto NormalTermination;
+#else
+ return;
+#endif
+
+ if (!jw)
+ {
+ undorecord = true;
+ SaveUndo(0, undoturn, 0, 0, 0);
+ undorecord = false;
+ undoturn = 0;
+ }
+
+ if (playback)
+ {
+ if (hugo_fclose(playback)) FatalError(READ_E);
+ playback = NULL;
+ }
+
+ Flushpbuffer();
+
+
+ /* Run the user Endgame routine if one exists */
+
+#if defined (DEBUGGER)
+ if (endgameaddr && !debugger_collapsing)
+#else
+ if (endgameaddr)
+#endif
+ {
+ passlocal[0] = var[endflag];
+
+ SetStackFrame(RESET_STACK_DEPTH, RUNROUTINE_BLOCK, 0, 0);
+
+ ret = 0;
+ var[endflag] = 0;
+ PassLocals(0);
+#if defined (DEBUGGER)
+ DebugRunRoutine((long)endgameaddr*address_scale);
+#else
+ RunRoutine((long)endgameaddr*address_scale);
+#endif
+ retflag = false;
+ }
+ else
+ ret = 0;
+
+ xverb = true;
+ wasxverb = true;
+ if (ret) goto Start;
+
+ /* Stop all audio after running EndGame */
+ hugo_stopmusic();
+ hugo_stopsample();
+
+ /* The debugger will reset endflag anyway, but we need it to signal ports
+ (like Palm) that the game loop has exited.
+ */
+ var[endflag] = -1;
+
+#if defined (DEBUGGER)
+
+NormalTermination:
+
+ /* Normal program termination doesn't exit the debugger. */
+
+ debugger_interrupt = true;
+ debugger_run = false;
+ var[endflag] = false;
+
+ xverb = false;
+
+ SwitchtoDebugger();
+ UpdateDebugScreen();
+
+ if (debugger_collapsing!=2)
+ {
+ DebugMessageBox("Program Exiting", "Normal program termination");
+
+ }
+
+ debugger_collapsing = false;
+
+ if ((game!=NULL) && !RunRestart())
+ DebugMessageBox("Restart Error", "Unable to restart");
+
+ SwitchtoGame();
+
+ history_count = 0;
+ window[VIEW_CALLS].count = 0;
+
+ for (i=0; i<(int)window[CODE_WINDOW].count; i++)
+ free(codeline[i]);
+ window[CODE_WINDOW].count = 0;
+
+ /* Force Code window redraw */
+ buffered_code_lines = FORCE_REDRAW;
+
+ goto RestartDebugger;
+#endif
+}
+
+void Hugo::RunIf(char override) {
+ char t, tempinexpr;
+ long enterptr, skip;
+
+ switch (t = MEM(codeptr))
+ {
+ case CASE_T:
+ case IF_T:
+ case ELSEIF_T:
+ case WHILE_T:
+ case FOR_T:
+ {
+ codeptr++;
+ enterptr = codeptr;
+
+ /* Remember the skip distance */
+ skip = PeekWord(codeptr);
+ codeptr += 2;
+
+ /* Check if we've already done an elseif */
+ if (override && t==ELSEIF_T)
+ {
+ codeptr = skip+enterptr;
+ return;
+ }
+
+ /* Read the expression */
+ tempinexpr = inexpr;
+ inexpr = 1;
+ SetupExpr();
+ inexpr = tempinexpr;
+
+ /* If the expression is false, skip the
+ conditional block
+ */
+ if (EvalExpr(0)==0)
+ {
+ codeptr = skip+enterptr;
+ return;
+ }
+
+ /* Protect the stack if jumping backward */
+ if (MEM(codeptr)==JUMP_T)
+ {
+ if ((long)(PeekWord(codeptr+1)*address_scale) < codeptr)
+ if (--stack_depth < 0) stack_depth = 0;
+ }
+
+ /* Continue on into the conditional block if
+ the expression evaluated to non-zero
+ */
+PasstoBlock:
+ if (t==WHILE_T || t==FOR_T)
+ SetStackFrame(stack_depth, CONDITIONAL_BLOCK, skip+enterptr, 0);
+
+ else /* no 'break' parameter */
+ SetStackFrame(stack_depth, CONDITIONAL_BLOCK, 0, 0);
+#if defined (DEBUGGER)
+ dbnest++;
+#endif
+ return;
+ }
+ case ELSE_T:
+ {
+ skip = PeekWord(++codeptr);
+ enterptr = codeptr;
+ codeptr += 2;
+
+ if (override)
+ {
+ codeptr = skip+enterptr;
+ return;
+ }
+
+ if (MEM(codeptr)==JUMP_T)
+ {
+ if ((long)(PeekWord(codeptr+1)*address_scale) < codeptr)
+ if (--stack_depth < 0) stack_depth = 0;
+ }
+
+ goto PasstoBlock;
+ }
+ }
+}
+
+void Hugo::RunInput() {
+ int i;
+
+ strcpy(parseerr, "");
+
+ Flushpbuffer();
+
+ if (icolor==-1) icolor = fcolor; /* check unset input color */
+
+ hugo_getline("");
+
+#if defined (DEBUGGER)
+ if (debugger_collapsing) return;
+#endif
+
+ strcpy(buffer, Rtrim(strlwr(buffer)));
+
+ SeparateWords();
+
+ for (i=1; i<=words; i++)
+ {
+ wd[i] = FindWord(word[i]);
+
+ /* If a word isn't in the dictionary */
+ if (wd[i]==UNKNOWN_WORD)
+ {
+ wd[i] = 0;
+ strcpy(parseerr, word[i]);
+ if (parseerr[0]=='\"')
+ {
+ strcpy(parseerr, Right(parseerr, strlen(parseerr)-1));
+ if (parseerr[strlen(parseerr)-1]=='\"')
+ parseerr[strlen(parseerr)-1] = '\0';
+ }
+ }
+ }
+ currentpos = 0; /* left margin */
+ remaining = 0;
+}
+
+void Hugo::RunMove() {
+ int obj, p;
+#if defined (DEBUGGER)
+ char out_of_range = 0;
+#endif
+
+ switch (MEM(codeptr))
+ {
+ case MOVE_T:
+ {
+ codeptr++;
+ obj = GetValue();
+
+#if defined (DEBUGGER)
+ if (!CheckinRange(obj, objects, "object"))
+ out_of_range = true;
+ else
+#endif
+ SaveUndo(MOVE_T, obj, Parent(obj), 0, 0);
+
+ codeptr++; /* skip "to" */
+ p = GetValue();
+
+#if defined (DEBUGGER)
+ if (!CheckinRange(p, objects, "object"))
+ out_of_range = true;
+
+ if (!out_of_range)
+#endif
+ MoveObj(obj, p);
+ break;
+ }
+
+ case REMOVE_T:
+ {
+ codeptr++;
+ obj = GetValue();
+
+#if defined (DEBUGGER)
+ if (!CheckinRange(obj, objects, "object"))
+ out_of_range = true;
+
+ else
+#endif
+ SaveUndo(MOVE_T, obj, Parent(obj), 0, 0);
+
+#if defined (DEBUGGER)
+ if (!out_of_range)
+#endif
+ MoveObj(obj, 0); /* move to parent 0 */
+ break;
+ }
+ }
+
+ if (game_version>=23) codeptr++; /* eol */
+}
+
+void Hugo::RunPrint() {
+ char number = 0, hexnumber = 0;
+ int a;
+ int i, l;
+
+ codeptr++;
+
+ while (MEM(codeptr) != EOL_T)
+ {
+ strcpy(line, "");
+
+ switch (MEM(codeptr))
+ {
+ case NEWLINE_T:
+ {
+ codeptr++;
+ if (currentpos+hugo_textwidth(pbuffer)!=0)
+ AP("");
+ if (MEM(codeptr)==SEMICOLON_T) codeptr++;
+ continue;
+ }
+
+ case TO_T:
+ {
+ codeptr++;
+
+#if !defined (ACTUAL_LINELENGTH)
+ if ((a = GetValue()) > physical_windowwidth/FIXEDCHARWIDTH)
+ a = physical_windowwidth/FIXEDCHARWIDTH;
+#else
+ if ((a = GetValue()) > ACTUAL_LINELENGTH())
+ {
+ double ratio;
+
+ ratio = (physical_windowwidth/FIXEDCHARWIDTH) / a;
+ a = (int)(ACTUAL_LINELENGTH() / ratio);
+ }
+#endif
+ strcpy(line, "");
+ l = 0;
+ if (a*FIXEDCHARWIDTH >
+ hugo_textwidth(pbuffer)+currentpos-hugo_charwidth(' '))
+ {
+ for (i=hugo_textwidth(pbuffer)+currentpos;
+#ifdef NO_TERMINAL_LINEFEED
+ i<a*FIXEDCHARWIDTH;
+#else
+ i<a*FIXEDCHARWIDTH && i<physical_windowright;
+#endif
+ i+=hugo_charwidth(' '))
+ {
+ line[l++] = FORCED_SPACE;
+ line[l] = '\0';
+ }
+
+ }
+ break;
+ }
+
+ case CAPITAL_T:
+ {
+ codeptr++;
+ capital = 1;
+ continue;
+ }
+
+ case NUMBER_T:
+ {
+ codeptr++;
+ number = 1;
+ continue;
+ }
+
+ case HEX_T:
+ {
+ codeptr++;
+ number = 1;
+ hexnumber = 1;
+ continue;
+ }
+
+ case STRINGDATA_T:
+ {
+ codeptr++;
+ if (game_version >= 24)
+ l = PeekWord(codeptr++);
+ else
+ l = Peek(codeptr);
+ for (i=0; i<l; i++)
+ line[i] = (char)(MEM(++codeptr) - CHAR_TRANSLATION);
+ line[i] = '\0';
+ codeptr++;
+ break;
+ }
+
+ /* Anything else is treated as a value */
+ default:
+ {
+ a = GetValue();
+ if (!number)
+ {
+ strcpy(line, GetWord(a));
+ }
+ else
+ {
+ if (!hexnumber)
+ {
+ if (capital)
+ itoa((unsigned int)a, line, 10);
+ else
+ itoa(a, line, 10);
+ capital = 0;
+ }
+ else
+ sprintf(line, "%X", a);
+
+ number = 0;
+ hexnumber = 0;
+ }
+ break;
+ }
+ }
+
+ if (MEM(codeptr)==SEMICOLON_T)
+ {
+ codeptr++;
+ strcat(line, "\\;");
+ }
+ if (capital)
+ {
+ capital = 0;
+ if ((unsigned)line[0]<128)
+ line[0] = (char)toupper((int)line[0]);
+ else
+ {
+ /* Special conversion for non-Latin1
+ (>127) lowercase characters
+ */
+ char diff;
+ diff = 'a'-'A';
+ if ((unsigned)line[0]+diff<=255 && (unsigned)line[0]-diff>127)
+ line[0] -= diff;
+ }
+ }
+
+ AP(line);
+ }
+
+ codeptr++;
+}
+
+int Hugo::RunRestart() {
+ unsigned int a;
+ long i = 0;
+ Common::SeekableReadStream *file;
+
+#ifndef LOADGAMEDATA_REPLACED
+
+ remaining = 0;
+
+#if !defined (GLK) /* with Glk, game is never closed */
+ /* Use file instead of game, just in case the call fails */
+ if (!(file = HUGO_FOPEN(gamefile, "rb"))) goto RestartError;
+#else
+ file = game;
+#endif
+
+ if (hugo_fseek(file, (objtable-gameseg)*16, SEEK_SET)) goto RestartError;
+
+ i = (objtable-gameseg)*16L;
+ do
+ {
+ int val;
+
+ val = hugo_fgetc(file);
+ SETMEM(i++, (unsigned char)val);
+ if (val==EOF || hugo_ferror(file)) goto RestartError;
+ }
+ while (i < codeend);
+
+#if !defined (GLK)
+ if (fclose(file)) FatalError(READ_E);
+#endif
+
+#else
+ if (!(file = HUGO_FOPEN(gamefile, "rb"))) goto RestartError;
+ LoadGameData(true);
+ fclose(file);
+#endif /* LOADGAMEDATA_REPLACED */
+
+ defseg = arraytable;
+ for (a=0; a<MAXGLOBALS; a++)
+ var[a] = PeekWord(a*2);
+
+ i = codeptr;
+
+ if (game_version < 22)
+ {
+ passlocal[0] = objects;
+#if defined (ACTUAL_LINELENGTH)
+ passlocal[1] = ACTUAL_LINELENGTH();
+#else
+ passlocal[1] = physical_windowwidth/FIXEDCHARWIDTH;
+#endif
+ }
+
+#if defined (DEBUGGER)
+ /* A restart can happen mid-playback from the debugger */
+ if (playback)
+ {
+ if (hugo_fclose(playback))
+ FatalError(READ_E);
+ playback = NULL;
+ }
+
+ if (active_screen!=DEBUGGER)
+#endif
+ {
+ InitGame();
+
+ SetStackFrame(stack_depth, RUNROUTINE_BLOCK, 0, 0);
+
+ PassLocals(0);
+#if defined (DEBUGGER)
+ DebugRunRoutine((long)mainaddr*address_scale);
+#else
+ RunRoutine((long)mainaddr*address_scale);
+#endif
+ retflag = 0;
+
+ codeptr = i;
+
+ undoptr = 0;
+ undoturn = 0;
+ undoinvalid = 1;
+ }
+
+ return 1;
+
+RestartError:
+#if !defined (GLK)
+ if (fclose(file)) FatalError(READ_E);
+#endif
+
+ return 0;
+}
+
+#ifndef RESTOREGAMEDATA_REPLACED
+
+int Hugo::RestoreGameData() {
+ char testid[3], testserial[9];
+ int lbyte, hbyte;
+ int j;
+ unsigned int k, undosize;
+ long i;
+
+ /* Check ID */
+ testid[0] = (char)hugo_fgetc(save);
+ testid[1] = (char)hugo_fgetc(save);
+ testid[2] = '\0';
+ if (hugo_ferror(save)) goto RestoreError;
+
+ if (strcmp(testid, id))
+ {
+ AP("Incorrect save file.");
+ if (hugo_fclose(save)) FatalError(READ_E);
+ save = NULL;
+ return 0;
+ }
+
+ /* Check serial number */
+ if (!hugo_fgets(testserial, 9, save)) goto RestoreError;
+ if (strcmp(testserial, serial))
+ {
+ AP("Save file created by different version.");
+ if (hugo_fclose(save)) FatalError(READ_E);
+ save = NULL;
+ return 0;
+ }
+
+ /* Restore variables */
+ for (k=0; k<MAXGLOBALS+MAXLOCALS; k++)
+ {
+ if ((lbyte = hugo_fgetc(save))==EOF || (hbyte = hugo_fgetc(save))==EOF)
+ goto RestoreError;
+ var[k] = lbyte + hbyte * 256;
+ }
+
+ /* Restore objtable and above */
+
+ if (hugo_fseek(game, objtable*16L, SEEK_SET)) goto RestoreError;
+ i = 0;
+
+ while (i<codeend-(long)(objtable*16L))
+ {
+ if ((hbyte = hugo_fgetc(save))==EOF && hugo_ferror(save)) goto RestoreError;
+
+ if (hbyte==0)
+ {
+ if ((lbyte = hugo_fgetc(save))==EOF && hugo_ferror(save)) goto RestoreError;
+ SETMEM(objtable*16L+i, (unsigned char)lbyte);
+ i++;
+
+ /* Skip byte in game file */
+ if (hugo_fgetc(game)==EOF) goto RestoreError;
+ }
+ else
+ {
+ while (hbyte--)
+ {
+ /* Get unchanged game file byte */
+ if ((lbyte = hugo_fgetc(game))==EOF) goto RestoreError;
+ SETMEM(objtable*16L+i, (unsigned char)lbyte);
+ i++;
+ }
+ }
+ }
+
+ /* Restore undo data */
+ if ((lbyte = hugo_fgetc(save))==EOF || (hbyte = hugo_fgetc(save))==EOF)
+ goto RestoreError;
+ undosize = lbyte + hbyte*256;
+
+ /* We can only restore undo data if it was saved by a port with
+ the same MAXUNDO as us */
+ if (undosize==MAXUNDO)
+ {
+ for (k=0; k<MAXUNDO; k++)
+ {
+ for (j=0; j<5; j++)
+ {
+ if ((lbyte = hugo_fgetc(save))==EOF || (hbyte = hugo_fgetc(save))==EOF)
+ goto RestoreError;
+ undostack[k][j] = lbyte + hbyte*256;
+ }
+ }
+ if ((lbyte = hugo_fgetc(save))==EOF || (hbyte = hugo_fgetc(save))==EOF) goto RestoreError;
+ undoptr = lbyte + hbyte*256;
+ if ((lbyte = hugo_fgetc(save))==EOF || (hbyte = hugo_fgetc(save))==EOF) goto RestoreError;
+ undoturn = lbyte + hbyte*256;
+ if ((lbyte = hugo_fgetc(save))==EOF || (hbyte = hugo_fgetc(save))==EOF) goto RestoreError;
+ undoinvalid = (unsigned char)lbyte, undorecord = (unsigned char)hbyte;
+ }
+ else undoinvalid = true;
+
+ return true;
+
+RestoreError:
+ return false;
+}
+
+#endif // RESTOREGAMEDATA_REPLACED
+
+int Hugo::RunRestore() {
+#if !defined (GLK)
+ save = NULL;
+
+ /* stdio implementation */
+ hugo_getfilename("to restore", savefile);
+
+#if defined (DEBUGGER)
+ if (debugger_collapsing) return 1;
+#endif
+ if (!strcmp(line, "")) return 0;
+ if (!(save = HUGO_FOPEN(line, "r+b"))) return 0;
+
+#else
+ /* Glk implementation */
+ frefid_t savefile;
+
+ save = NULL;
+
+ savefile = glk_fileref_create_by_prompt(fileusage_SavedGame | fileusage_BinaryMode,
+ filemode_Read, 0);
+ if (!savefile) return 0;
+ if (glk_fileref_does_file_exist(savefile))
+ save = glk_stream_open_file(savefile, filemode_Read, 0);
+ else
+ save = NULL;
+ glk_fileref_destroy(savefile);
+ if (!save) return 0;
+
+#endif /* GLK */
+
+ if (!RestoreGameData()) goto RestoreError;
+
+ if (hugo_fclose(save)) FatalError(READ_E);
+ save = NULL;
+
+#if !defined (GLK)
+ strcpy(savefile, line);
+#endif
+
+ game_reset = true;
+
+ return (1);
+
+RestoreError:
+ if ((save) && hugo_fclose(save)) FatalError(READ_E);
+ save = NULL;
+ game_reset = false;
+ return 0;
+}
+
+void Hugo::RunRoutine(long addr) {
+ int null_count; /* for reading to next address boundary */
+ char tempinexpr;
+ int i, t, len, xpos, ypos;
+ int initial_stack_depth, tempret;
+ unsigned int routineptr = 0;
+ long textaddr;
+#if defined (DEBUGGER)
+ char wascalled = 0; /* distinguish routine calls from 'window'
+ blocks, etc. */
+ const char *called_from;
+ char trace_comp_prop = 0;
+ unsigned char param_type;
+ long param_start;
+ unsigned int old_currentroutine = 0;
+
+ /* Because <debugdata#> and <label#> in-code data is
+ not decompiled
+ */
+ int broke_on_nonstatement = 0;
+#endif
+
+ /* If routine doesn't exist */
+ if (addr==0L) return;
+
+ initial_stack_depth = stack_depth;
+ inexpr = 0;
+
+#if !defined (DEBUGGER)
+#if defined (DEBUG_CODE)
+/*
+ if (trce)
+ {
+ if (codeptr != addr)
+ {
+ sprintf(line, "[ROUTINE: $%6s]", PrintHex(addr));
+ AP(line);
+ wascalled = 1;
+ }
+ }
+*/
+#endif
+#endif
+
+#if defined (DEBUGGER)
+
+/*
+ * First see what debugger information has to be set up upon calling
+ * this block of code
+ */
+
+ /* If this is a routine call vs. other block, codeptr will be
+ different from addr.
+ */
+ if (codeptr != addr)
+ {
+ wascalled = 1;
+
+ /* Checking to see if currentroutine is 0 is a way of seeing
+ if the debugger has started properly. If, for example, a
+ property routine runs while LoadGame() is searching for
+ the display object, it may corrupt the uninitialized
+ debugger arrays.
+ */
+ if ((old_currentroutine = currentroutine)==0) return;
+
+ currentroutine = (unsigned int)(addr/address_scale);
+
+ if (debugger_step_over)
+ {
+ step_nest++;
+ debugger_interrupt = false;
+ }
+ else
+ {
+ /* Add a blank line if one hasn't been added
+ already:
+ */
+ if ((window[CODE_WINDOW].count) && (codeline[window[CODE_WINDOW].count-1][0]&0x0FF)!='\0')
+ AddStringtoCodeWindow("");
+
+ /* If this is a property routine, the debug_line array
+ already holds the calling information
+ */
+ if (!trace_complex_prop_routine)
+ sprintf(debug_line, "Calling: %s", RoutineName(currentroutine));
+ else
+ trace_comp_prop = true;
+ trace_complex_prop_routine = false;
+
+ call[window[VIEW_CALLS].count].addr = currentroutine;
+ call[window[VIEW_CALLS].count++].param = (char)arguments_passed;
+ window[VIEW_CALLS].changed = true;
+
+ /* Revise call history */
+ if (window[VIEW_CALLS].count==MAXCALLS)
+ {
+ for (i=0; i<MAXCALLS-1; i++)
+ {
+ call[i].addr = call[i+1].addr;
+ call[i].param = call[i+1].param;
+ }
+ call[0].addr = 0;
+ }
+
+ /* If not object.property or an event */
+ if (strchr(debug_line, '.')==NULL && strstr(debug_line, "vent ")==NULL)
+ {
+ strcat(debug_line, "(");
+ for (i=0; i<arguments_passed; i++)
+ {
+ sprintf(debug_line+strlen(debug_line), "%d", var[MAXGLOBALS+i]);
+ if (i<arguments_passed-1)
+ strcat(debug_line, ", ");
+ }
+ strcat(debug_line, ")");
+ }
+ AddStringtoCodeWindow(debug_line);
+ }
+ }
+
+#endif /* defined (DEBUGGER) */
+
+ defseg = gameseg;
+ codeptr = addr;
+
+/*
+ * Get the next token, so long as it isn't a CLOSE_BRACE_T ('}')
+ * marking the end of this block of code
+ */
+
+ContinueRunning:
+
+ while (MEM(codeptr) != CLOSE_BRACE_T) /* until "}" */
+ {
+
+#if defined (DEBUGGER)
+ /* Check if we're stepping over, and if we've returned to
+ the original level of nesting:
+ */
+ if (debugger_step_over && step_nest==0)
+ {
+ debugger_step_over = false;
+ debugger_interrupt = true;
+ }
+#endif
+ if (var[endflag]) return;
+
+ null_count = 0;
+
+ /* Read the next token */
+ while ((t = MEM(codeptr))==0)
+ {
+ codeptr++;
+
+ /* Allow for padding zeroes. If address_scale
+ zeroes are processed, we can't simply be
+ eating up the null space before an address
+ boundary.
+ */
+ if (++null_count > address_scale)
+ FatalError(UNKNOWN_OP_E);
+ }
+
+#if !defined (DEBUGGER)
+#if defined (DEBUG_CODE)
+ if (!inwindow)
+ {
+ sprintf(line, "[%6s: %s]", PrintHex(codeptr), token[t]);
+ AP(line);
+ }
+#endif
+#endif
+ if (game_version < 22) if (t==TEXT_T) t = TEXTDATA_T;
+
+#if defined (DEBUGGER)
+ if (++runaway_counter>=65535 && runtime_warnings)
+ {
+ sprintf(debug_line, "Possible runaway loop (65535 unchecked steps)");
+ RuntimeWarning(debug_line);
+ buffered_code_lines = FORCE_REDRAW;
+ runaway_counter = 0;
+ }
+
+ if (t!=DEBUGDATA_T && t!=LABEL_T && !debugger_step_over)
+ AddLinetoCodeWindow(codeptr);
+
+ if ((i = IsBreakpoint(codeptr)))
+ {
+ if (t==DEBUGDATA_T || t==LABEL_T)
+ broke_on_nonstatement = i;
+
+ debugger_interrupt = true;
+
+ /* '<' for "<Unknown>" */
+ if (breakpoint[--i].in[0]=='<')
+ {
+ breakpoint[i].in = RoutineName(currentroutine);
+ window[VIEW_BREAKPOINTS].changed = true;
+ }
+ }
+
+ /* Don't add in-code data to the code window */
+ if (t==DEBUGDATA_T || t==LABEL_T) goto ProcessToken;
+
+ /* Evaluate (only) any watch expressions set to break
+ when true:
+ */
+ for (i=0; i<(int)window[VIEW_WATCH].count; i++)
+ {
+ if (watch[i].isbreak)
+ {
+ SetupWatchEval(i);
+ if (EvalWatch())
+ {
+ debugger_interrupt = true;
+ break;
+ }
+ }
+ }
+
+ /* Always update the watch window */
+ window[VIEW_WATCH].changed = true;
+
+/*
+ * Immediately following is the main Debugger interrupt point.
+ * No matter where the engine is while running, if debugger_interrupt
+ * is ever set during the execution of a command, execution is
+ * paused and control passed to the Debugger.
+ */
+
+ if (debugger_interrupt)
+ {
+ if (broke_on_nonstatement)
+ {
+ broke_on_nonstatement--;
+ breakpoint[broke_on_nonstatement].addr = codeptr;
+ window[VIEW_BREAKPOINTS].changed = true;
+ broke_on_nonstatement = false;
+ }
+
+ if (debugger_step_over)
+ {
+ AddStringtoCodeWindow("...");
+ if (t!=DEBUGDATA_T && t!=LABEL_T)
+ AddLinetoCodeWindow(codeptr);
+ }
+ Debugger();
+ }
+
+
+ /* Now, additional processing for flags that may have been
+ set while execution was suspended:
+ */
+
+ /* Collapsing the RunRoutine() call stack */
+ if (debugger_collapsing) return;
+
+
+ /* May be necessary to reset this if, for some
+ reason, the line array was altered (see above)
+ */
+ if (!trace_complex_prop_routine)
+ sprintf(debug_line, "Calling: %s", RoutineName(currentroutine));
+ trace_complex_prop_routine = false;
+
+
+ /* Add this statement to the code history */
+ if (!debugger_step_back && !(debugger_step_over && step_nest>0))
+ {
+ if (++history_count>=MAX_CODE_HISTORY)
+ history_count = MAX_CODE_HISTORY;
+ code_history[history_last] = codeptr;
+ dbnest_history[history_last] = dbnest;
+ if (++history_last >= MAX_CODE_HISTORY)
+ history_last = 0;
+ }
+
+ /* If skipping next or stepping back */
+ if (debugger_skip || debugger_step_back)
+ {
+ /* Debugger() has reset codeptr to next_codeptr */
+ debugger_skip = false;
+ continue;
+ }
+
+#endif /* defined (DEBUGGER) */
+
+
+/*
+ * This is the heart of RunRoutine(): the switch statement
+ * that executes the next engine operation based on what token
+ * has been read
+ */
+#if defined (DEBUGGER)
+ProcessToken:
+#endif
+ switch (t)
+ {
+ /* First process any encoded, non-executable data: */
+
+ /* If this is v2.5 or later, the compiler will have
+ noted the nesting level of this label to
+ reconcile stack_depth
+ */
+ case LABEL_T:
+ stack_depth = initial_stack_depth + MEM(++codeptr);
+ codeptr++;
+ break;
+
+ case DEBUGDATA_T:
+ {
+ switch (MEM(++codeptr))
+ {
+ case VAR_T: /* local variable name */
+ {
+ len = MEM(++codeptr);
+#if defined (DEBUGGER)
+ if (!debugger_has_stepped_back)
+ {
+ /* Read the local variable name */
+ for (i=0; i<len; i++)
+ line[i] = MEM(codeptr+i+1);
+ line[len] = '\0';
+
+ /* Check to make sure it doesn't already exist,
+ for instance, if we've looped back to it
+ */
+ for (i=0; i<current_locals; i++)
+ if (!strcmp(line, localname[i])) break;
+
+ /* If it doesn't exist, add it */
+ if (i==current_locals)
+ {
+ strcpy(localname[current_locals], line);
+ if (++current_locals==MAXLOCALS)
+ current_locals--;
+ window[VIEW_LOCALS].count = current_locals;
+ }
+ }
+#endif
+ codeptr+=(len+1);
+ break;
+ }
+ }
+ break;
+ }
+
+
+ /* Then the executable statements: */
+
+ case TEXTDATA_T: /* printed text from file */
+ {
+ textaddr = Peek(codeptr+1)*65536L+(long)PeekWord(codeptr+2);
+ strcpy(line, GetText(textaddr));
+ codeptr += 4;
+ if (Peek(codeptr)==SEMICOLON_T)
+ {strcat(line, "\\;");
+ codeptr++;}
+ if (capital)
+ {line[0] = (char)toupper((int)line[0]);
+ capital = 0;}
+ AP(line);
+ break;
+ }
+
+ case TEXT_T:
+ {
+ if (MEM(++codeptr)==TO_T)
+ {
+ codeptr++;
+#if defined (DEBUGGER)
+ param_type = MEM(codeptr);
+ param_start = codeptr;
+#endif
+ textto = GetValue();
+ if (game_version>=23) codeptr++; /* eol */
+#if defined (DEBUGGER)
+ /* Check if textto is 0 but was not
+ really "text to 0", but rather
+ something that evaluated to 0
+ */
+ if (textto==0 && runtime_warnings)
+ {
+ if (param_type!=VALUE_T || param_start!=codeptr-4)
+ RuntimeWarning("Text array address evaluates to zero");
+ }
+#endif
+ }
+ else
+ {
+ SetupDisplay();
+ }
+ break;
+ }
+
+ case MINUS_T: /* "--" */
+ case PLUS_T: /* "++" */
+ GetValue();
+ codeptr++; /* eol */
+ break;
+
+ case PRINT_T:
+ RunPrint();
+ break;
+
+ case PRINTCHAR_T:
+ {
+Printcharloop:
+ codeptr++;
+ i = GetValue();
+ if (capital) sprintf(line, "%c\\;", toupper(i));
+ else sprintf(line, "%c\\;", i);
+ capital = 0;
+ AP(line);
+ if (Peek(codeptr)==COMMA_T)
+ goto Printcharloop;
+ if (game_version>=23) codeptr++; /* eol */
+ break;
+ }
+
+ case STRING_T:
+ RunString();
+ break;
+
+ case WINDOW_T:
+ RunWindow();
+ break;
+
+ case LOCATE_T:
+ {
+ char adhere_to_bottom = false;
+
+ codeptr++;
+
+ Flushpbuffer();
+
+ xpos = GetValue();
+ if (xpos > physical_windowwidth/FIXEDCHARWIDTH)
+ xpos = physical_windowwidth/FIXEDCHARWIDTH;
+
+ if (Peek(codeptr)==COMMA_T)
+ {
+ codeptr++;
+ ypos = GetValue();
+ }
+ else
+ ypos = currentline;
+
+ full = ypos - 1;
+
+
+ if (ypos >= physical_windowheight/lineheight)
+ full = 0;
+
+ if (ypos > physical_windowheight/lineheight)
+ {
+ ypos = physical_windowheight/lineheight;
+
+ if (!inwindow && current_text_y && (currentfont & PROP_FONT))
+ adhere_to_bottom = true;
+ }
+
+ hugo_settextpos(xpos, ypos);
+
+ /* An adjustment for non-fixed-width font lineheight */
+ if (adhere_to_bottom)
+ current_text_y = physical_windowbottom - lineheight;
+
+ currentpos = (xpos-1)*FIXEDCHARWIDTH;
+ currentline = ypos;
+
+ codeptr++; /* skip EOL */
+ break;
+ }
+
+ case SELECT_T:
+ codeptr++;
+ break;
+
+ case CASE_T:
+ case IF_T:
+ case ELSEIF_T:
+ case ELSE_T:
+ case WHILE_T:
+ case FOR_T:
+ RunIf(0);
+ break;
+
+ case DO_T:
+ RunDo();
+ break;
+
+ case RUN_T:
+ codeptr++;
+ tempret = ret;
+ GetValue(); /* object.property to run */
+ ret = tempret;
+ if (game_version>=23) codeptr++; /* eol */
+ break;
+
+ case BREAK_T:
+ {
+ for (; stack_depth>0; stack_depth--)
+ {
+ if (code_block[stack_depth].brk)
+ {
+ codeptr = code_block[stack_depth].brk;
+#if defined (DEBUGGER)
+ dbnest = code_block[stack_depth].dbnest;
+#endif
+ --stack_depth;
+ goto LeaveBreak;
+ }
+ }
+ codeptr++;
+LeaveBreak:
+ break;
+ }
+
+ case RETURN_T:
+ {
+ codeptr++;
+ i = inexpr; /* don't reuse tempinexpr */
+ inexpr = 1;
+
+ /* Let 'return Routine()' or 'return obj.prop'
+ set tail_recursion
+ */
+ tail_recursion = 0;
+ tail_recursion_addr = 0;
+
+ SetupExpr();
+ inexpr = (char)i;
+
+ /* If either a routine or property routine call has
+ determined it's valid, we can use tail-recursion
+ (with tail_recursion_addr having been set up)
+ */
+ if (tail_recursion)
+ {
+ HandleTailRecursion(tail_recursion_addr);
+ break;
+ }
+ else
+ {
+ /* Clear these to be safe */
+ tail_recursion = 0;
+ tail_recursion_addr = 0;
+
+ ret = EvalExpr(0);
+ retflag = true;
+ goto LeaveRunRoutine;
+ }
+ }
+
+ case JUMP_T:
+ {
+ codeptr = (long)PeekWord(codeptr + 1)*address_scale;
+#if defined (DEBUGGER)
+ if (MEM(codeptr)==LABEL_T)
+ dbnest = 0; /* prevent "false" nesting */
+#endif
+ break;
+ }
+
+ case PARENT_T:
+ case SIBLING_T:
+ case CHILD_T:
+ case YOUNGEST_T:
+ case ELDEST_T:
+ case YOUNGER_T:
+ case ELDER_T:
+ {
+ inobj = true;
+
+ /* Note: GetValue() would actually get
+ the property/attribute to be set
+ */
+ RunSet(GetVal());
+
+ inobj = false;
+ break;
+ }
+
+ case VAR_T:
+ case OBJECTNUM_T:
+ case VALUE_T:
+ case WORD_T:
+ case ARRAYDATA_T:
+ case ARRAY_T:
+ RunSet(-1);
+ break;
+
+ case ROUTINE_T:
+ case CALL_T:
+ {
+ switch (t)
+ {
+ case ROUTINE_T:
+ {
+ codeptr++;
+ routineptr = PeekWord(codeptr);
+ codeptr += 2;
+ break;
+ }
+ case CALL_T:
+ {
+ codeptr++;
+ routineptr = GetValue();
+ }
+ }
+
+ tempret = ret;
+ CallRoutine(routineptr);
+
+ if (MEM(codeptr)==DECIMAL_T || MEM(codeptr)==IS_T)
+ RunSet(ret);
+ else if ((t==CALL_T) && game_version>=23)
+ codeptr++; /* eol */
+
+ ret = tempret;
+
+ break;
+ }
+
+ case MOVE_T:
+ case REMOVE_T:
+ RunMove();
+ break;
+
+ case COLOR_T:
+ case COLOUR_T:
+ {
+ codeptr++;
+
+ /* Get foreground color */
+ fcolor = (char)GetValue();
+ /* If background color is given */
+ if (Peek(codeptr)==COMMA_T)
+ {
+ codeptr++;
+ bgcolor = (char)GetValue();
+
+ /* If input color is given */
+ if (Peek(codeptr)==COMMA_T)
+ {
+ codeptr++;
+ icolor = (char)GetValue();
+ }
+ else
+ icolor = fcolor;
+ }
+ else
+ icolor = fcolor;
+
+ /* Only set the actual pen color now if
+ there is no text buffered
+ */
+ if (pbuffer[0]=='\0')
+ {
+ hugo_settextcolor(fcolor);
+ hugo_setbackcolor(bgcolor);
+ }
+
+ if (inwindow)
+ default_bgcolor = bgcolor;
+
+ codeptr++; /* skip EOL */
+ break;
+ }
+
+ case PAUSE_T:
+ {
+ full = 0;
+ override_full = true;
+ codeptr++;
+ Flushpbuffer();
+ /* Flush the key buffer first */
+ while (hugo_iskeywaiting()) hugo_getkey();
+ wd[0] = (unsigned int)hugo_waitforkey();
+#if defined (DEBUGGER)
+ runaway_counter = 0;
+#endif
+ break;
+ }
+
+ case RUNEVENTS_T:
+ codeptr++;
+ RunEvents();
+ break;
+
+ case QUIT_T:
+ var[endflag] = -1;
+ break;
+
+ case INPUT_T:
+ RunInput();
+ full = 1;
+ override_full = true;
+ codeptr++;
+ break;
+
+ case SYSTEM_T:
+ RunSystem();
+ if (game_version>=23) codeptr++; /* eol */
+ break;
+
+ case CLS_T:
+ {
+ hugo_settextcolor(fcolor);
+ hugo_setbackcolor(bgcolor);
+ hugo_clearwindow();
+ hugo_settextpos(1, physical_windowheight/lineheight); /*+1);*/
+
+ if (!inwindow)
+ {
+ full = 0;
+ }
+ default_bgcolor = bgcolor;
+
+ codeptr++;
+ pbuffer[0] = '\0';
+ break;
+ }
+
+ case WRITEFILE_T:
+ case READFILE_T:
+ FileIO();
+ break;
+
+ case WRITEVAL_T:
+ {
+Writevalloop:
+ codeptr++;
+ i = GetValue();
+ if (ioblock)
+ {
+ if ((ioblock==2)
+ || hugo_fputc(i%256, io)==EOF
+ || hugo_fputc(i/256, io)==EOF)
+ {
+ ioerror = true;
+ retflag = true;
+ break;
+ }
+ }
+
+ if (Peek(codeptr)==COMMA_T)
+ goto Writevalloop;
+
+ if (game_version>=23) codeptr++; /* eol */
+ break;
+ }
+
+ case PICTURE_T:
+ DisplayPicture();
+ break;
+
+ case MUSIC_T:
+ PlayMusic();
+ break;
+
+ case SOUND_T:
+ PlaySample();
+ break;
+
+ case VIDEO_T:
+ PlayVideo();
+ break;
+
+ case ADDCONTEXT_T:
+ ContextCommand();
+ break;
+
+ /* Didn't match a command token, so throw up an
+ "Unknown operation" error.
+ */
+ default:
+ FatalError(UNKNOWN_OP_E);
+ }
+
+ defseg = gameseg;
+
+ if (retflag) goto LeaveRunRoutine;
+ }
+
+
+ /* Process the closing '}': */
+
+ codeptr++;
+
+#if defined (DEBUGGER)
+ if (--dbnest < 0) dbnest = 0;
+#endif
+ /* Continue executing this iteration of RunRoutine() if the
+ '}' marks the end of a conditional block, i.e., one that
+ didn't call RunRoutine() the way, e.g., 'window' does.
+ Otherwise, get out of RunRoutine().
+ */
+ if (code_block[stack_depth--].type > RUNROUTINE_BLOCK)
+ {
+ /* Skip a following 'elseif', 'else', or 'case' */
+ t = MEM(codeptr);
+ while (t==ELSEIF_T || t==ELSE_T || t==CASE_T)
+ {
+ RunIf(1);
+ t = MEM(codeptr);
+ }
+
+ if (t==WHILE_T && code_block[stack_depth+1].type==DOWHILE_BLOCK)
+ {
+ codeptr+=3;
+ tempinexpr = inexpr;
+ inexpr = 1;
+ SetupExpr();
+ inexpr = tempinexpr;
+
+ if (EvalExpr(0))
+ codeptr = code_block[++stack_depth].returnaddr;
+ else
+ codeptr = code_block[stack_depth+1].brk;
+ }
+
+ /* Since this isn't a RUNROUTINE_BLOCK, keep running this
+ iteration of RunRoutine()
+ */
+ goto ContinueRunning;
+
+ }
+
+ if (stack_depth<0) stack_depth = 0;
+
+ if (var[endflag]) return;
+
+
+LeaveRunRoutine:
+
+#if defined (DEBUGGER)
+
+/*
+ * Finally, do any debugger-required cleaning-up
+ */
+
+ /* As noted above, wascalled is true if this was a routine call
+ as opposed to, e.g., a conditional block. In the former case,
+ it is necessary to print the "Returning from..." message.
+ */
+ if (wascalled)
+ {
+ if (debugger_step_over)
+ {
+ if (--step_nest<=0)
+ {
+ debugger_step_over = false;
+ debugger_interrupt = true;
+
+ if (debugger_finish || step_nest < 0)
+ {
+ debugger_finish = false;
+ goto ReturnfromRoutine;
+ }
+ }
+ }
+
+ else if (!debugger_step_over)
+ {
+ReturnfromRoutine:
+ sprintf(debug_line, "(Returning %d", ret);
+
+ /* Since a complex property routine will give "<Routine>" as the
+ routine name, skip those
+ */
+ called_from = RoutineName(currentroutine);
+ if (!trace_comp_prop && called_from[0]!='<')
+ sprintf(debug_line+strlen(debug_line), " from %s", called_from);
+
+ if (old_currentroutine!=mainaddr && old_currentroutine!=initaddr
+ && currentroutine!=mainaddr && currentroutine!=initaddr)
+ {
+ sprintf(debug_line+strlen(debug_line), " to %s", RoutineName(old_currentroutine));
+ }
+ strcat(debug_line, ")");
+ AddStringtoCodeWindow(debug_line);
+ AddStringtoCodeWindow("");
+
+ if ((signed)--window[VIEW_CALLS].count < 0)
+ window[VIEW_CALLS].count = 0;
+ window[VIEW_CALLS].changed = true;
+ }
+
+ currentroutine = old_currentroutine;
+ }
+
+/*#elif defined (DEBUG_CODE)
+ if (wascalled)
+ {sprintf(line, "[RETURNING %d]", ret);
+ AP(line);}
+*/
+#endif
+
+ return;
+}
+
+#ifndef SAVEGAMEDATA_REPLACED
+
+int Hugo::SaveGameData() {
+ int c, j;
+ int lbyte, hbyte;
+ long i;
+ int samecount = 0;
+
+ /* Write ID */
+ if (hugo_fputc(id[0], save)==EOF || hugo_fputc(id[1], save)==EOF) goto SaveError;
+
+ /* Write serial number */
+ if (hugo_fputs(serial, save)==EOF) goto SaveError;
+
+ /* Save variables */
+ for (c=0; c<MAXGLOBALS+MAXLOCALS; c++)
+ {
+ hbyte = (unsigned int)var[c] / 256;
+ lbyte = (unsigned int)var[c] - hbyte * 256;
+ if (hugo_fputc(lbyte, save)==EOF || hugo_fputc(hbyte, save)==EOF) goto SaveError;
+ }
+
+ /* Save objtable to end of code space */
+
+ if (hugo_fseek(game, objtable*16L, SEEK_SET)) goto SaveError;
+
+ for (i=0; i<=codeend-(long)(objtable*16L); i++)
+ {
+ if ((lbyte = hugo_fgetc(game))==EOF) goto SaveError;
+ hbyte = MEM(objtable*16L+i);
+
+ /* If memory same as original game file */
+ if (lbyte==hbyte && samecount<255) samecount++;
+
+ /* If memory differs (or samecount exceeds 1 byte) */
+ else
+ {
+ if (samecount)
+ if (hugo_fputc(samecount, save)==EOF) goto SaveError;
+
+ if (lbyte!=hbyte)
+ {
+ if (hugo_fputc(0, save)==EOF) goto SaveError;
+ if (hugo_fputc(hbyte, save)==EOF) goto SaveError;
+ samecount = 0;
+ }
+ else samecount = 1;
+ }
+ }
+ if (samecount)
+ if (hugo_fputc(samecount, save)==EOF) goto SaveError;
+
+ /* Save undo data */
+
+ /* Save the number of turns in this port's undo stack */
+ hbyte = (unsigned int)MAXUNDO / 256;
+ lbyte = (unsigned int)MAXUNDO - hbyte*256;
+ if (hugo_fputc(lbyte, save)==EOF || hugo_fputc(hbyte, save)==EOF)
+ goto SaveError;
+ for (c=0; c<MAXUNDO; c++)
+ {
+ for (j=0; j<5; j++)
+ {
+ hbyte = (unsigned int)undostack[c][j] / 256;
+ lbyte = (unsigned int)undostack[c][j] - hbyte*256;
+ if (hugo_fputc(lbyte, save)==EOF || hugo_fputc(hbyte, save)==EOF)
+ goto SaveError;
+ }
+ }
+ if (hugo_fputc(undoptr-(undoptr/256)*256, save)==EOF || hugo_fputc(undoptr/256, save)==EOF)
+ goto SaveError;
+ if (hugo_fputc(undoturn-(undoturn/256)*256, save)==EOF || hugo_fputc(undoturn/256, save)==EOF)
+ goto SaveError;
+ if (hugo_fputc(undoinvalid, save)==EOF || hugo_fputc(undorecord, save)==EOF)
+ goto SaveError;
+
+ return true;
+
+SaveError:
+ return false;
+}
+
+#endif // SAVEGAMEDATA_REPLACED
+
+int Hugo::RunSave() {
+#ifdef PALMOS
+ /* Prevent simultaneous access to the same db record */
+ int dummy = MEM(objtable*16L);
+#endif
+
+#if !defined (GLK)
+ save = NULL;
+
+ /* stdio implementation */
+ hugo_getfilename("to save", savefile);
+
+#if defined (DEBUGGER)
+ if (debugger_collapsing) return 1;
+#endif
+ if (!strcmp(line, gamefile)) return 0;
+ if (!strcmp(line, "")) return 0;
+ if (!hugo_overwrite(line)) return 0;
+ if (!(save = HUGO_FOPEN(line, "w+b"))) return 0;
+
+#else
+ /* Glk implementation */
+ frefid_t savefile;
+
+ save = NULL;
+
+ savefile = glk_fileref_create_by_prompt(fileusage_SavedGame | fileusage_BinaryMode,
+ filemode_Write, 0);
+ if (!savefile) return 0;
+ save = glk_stream_open_file(savefile, filemode_Write, 0);
+ glk_fileref_destroy(savefile);
+ if (!save) return 0;
+
+#endif /* GLK */
+
+ if (!SaveGameData()) goto SaveError;
+
+ if (hugo_fclose(save)) FatalError(WRITE_E);
+ save = NULL;
+
+#if !defined (GLK)
+ strcpy(savefile, line);
+#endif
+
+ return(1);
+
+SaveError:
+ if ((save) && hugo_fclose(save)) FatalError(WRITE_E);
+ save = NULL;
+ return 0;
+}
+
+int Hugo::RunScriptSet() {
+ remaining = 0;
+
+ switch (Peek(codeptr))
+ {
+ case SCRIPTON_T:
+ {
+ if (!script)
+ {
+#if !defined (GLK)
+ /* stdio implementation */
+ hugo_getfilename("to begin transcription (or printer name)", scriptfile);
+#if defined (DEBUGGER)
+ if (debugger_collapsing) return 1;
+#endif
+ if (!strcmp(line, "")) return 0;
+ if (!hugo_overwrite(line)) return 0;
+ if (!(script = HUGO_FOPEN(line, "wt")))
+ return (0);
+ strcpy(scriptfile, line);
+
+#else
+ /* Glk implementation */
+ frefid_t fref;
+
+ fref = glk_fileref_create_by_prompt(fileusage_Transcript | fileusage_TextMode,
+ filemode_Write, 0);
+ script = glk_stream_open_file(fref, filemode_Write, 0);
+ glk_fileref_destroy(fref);
+ if (!script) return (0);
+#endif /* GLK */
+ return 1;
+ }
+ break;
+ }
+
+ case SCRIPTOFF_T:
+ {
+ if (script)
+ {
+ if (hugo_fclose(script)) return (0);
+ script = NULL;
+ return 1;
+ }
+ break;
+ }
+ }
+ return 0;
+}
+
+int Hugo::RunString() {
+ int i, pos;
+ unsigned int aaddr; /* array address */
+ unsigned int dword; /* dictionary word */
+ unsigned int maxlen = 32767;
+
+ codeptr += 2; /* skip "(" */
+
+ aaddr = GetValue();
+ if (game_version>=22)
+ {
+ /* Convert to 16-bit word value */
+ aaddr*=2;
+
+ if (game_version>=23)
+ {
+ defseg = arraytable;
+ maxlen = PeekWord(aaddr);
+ defseg = gameseg;
+
+ /* Space for array length */
+ aaddr+=2;
+ }
+ }
+
+ if (Peek(codeptr)==COMMA_T) codeptr++;
+
+ dword = GetValue();
+
+ if (Peek(codeptr)==COMMA_T) codeptr++;
+
+ if (Peek(codeptr)!=CLOSE_BRACKET_T)
+ maxlen = GetValue();
+ if (Peek(codeptr)==CLOSE_BRACKET_T) codeptr++;
+
+ strcpy(line, GetWord(dword));
+
+ defseg = arraytable;
+ pos = 0;
+ for (i=0; i<(int)strlen(line) && i<(int)maxlen; i++, pos++)
+ {
+ char a;
+
+ SaveUndo(ARRAYDATA_T, aaddr, i, PeekWord(aaddr+i*2), 0);
+
+ a = line[i];
+ if (a=='\\')
+ ++i, a = SpecialChar(line, &i);
+ PokeWord(aaddr+pos*2, a);
+ }
+ PokeWord(aaddr+pos*2, 0);
+
+ defseg = gameseg;
+
+ return (i);
+}
+
+int Hugo::RunSystem() {
+ codeptr++;
+
+ /* Since the obsolete form of the system command is unimplemented,
+ simply get the parameter (in order to skip it), and exit the
+ function.
+ */
+ if (game_version < 25)
+ {
+ GetValue();
+ return 0;
+ }
+
+ /* Otherwise, process the following system calls: */
+
+ codeptr++; /* skip opening bracket */
+
+ var[system_status] = 0;
+
+ Flushpbuffer();
+
+ switch (GetValue())
+ {
+ case 11: /* READ_KEY */
+ if (!hugo_iskeywaiting())
+ return 0;
+ else
+ {
+ full = 0;
+ return hugo_getkey();
+ }
+
+ case 21: /* NORMALIZE_RANDOM */
+#if !defined (RANDOM)
+ _random.setSeed(1);
+#else
+ SRANDOM(1);
+#endif
+ break;
+ case 22: /* INIT_RANDOM */
+ {
+#if !defined (RANDOM)
+ _random.setSeed(g_system->getMillis());
+#else
+ time_t seed;
+ SRANDOM((unsigned int)time((time_t *)&seed));
+#endif
+ break;
+ }
+ case 31: /* PAUSE_SECOND */
+ if (!hugo_timewait(1))
+ var[system_status] = STAT_UNAVAILABLE;
+ break;
+
+ case 32: /* PAUSE_100TH_SECOND */
+ if (!hugo_timewait(100))
+ var[system_status] = STAT_UNAVAILABLE;
+ break;
+
+ case 41: /* GAME_RESET */
+ {
+ if (game_reset)
+ {
+ game_reset = 0;
+ return true;
+ }
+ return false;
+ }
+
+ case 51: /* SYSTEM_TIME */
+ {
+#ifndef NO_STRFTIME
+ TimeDate td;
+ g_system->getTimeAndDate(td);
+ sprintf(parseerr, "%Y-%m-%d %H:%M:%S", td.tm_year, td.tm_mon, td.tm_mday,
+ td.tm_hour, td.tm_min, td.tm_sec);
+#else
+ hugo_gettimeformatted(parseerr);
+#endif
+ return true;
+ }
+
+ case 61: /* MINIMAL_INTERFACE */
+#ifdef MINIMAL_INTERFACE
+ return true;
+#else
+ return false;
+#endif
+
+ default:
+ var[system_status] = STAT_UNAVAILABLE;
+ }
+
+ return 0;
+}
+
+void Hugo::SaveWindowData(SAVED_WINDOW_DATA *spw) {
+ spw->left = physical_windowleft;
+ spw->top = physical_windowtop;
+ spw->right = physical_windowright;
+ spw->bottom = physical_windowbottom;
+ spw->width = physical_windowwidth;
+ spw->height = physical_windowheight;
+ spw->currentfont = currentfont;
+ spw->charwidth = charwidth;
+ spw->lineheight = lineheight;
+ spw->currentpos = currentpos;
+ spw->currentline = currentline;
+}
+
+void Hugo::RestoreWindowData(SAVED_WINDOW_DATA *spw) {
+ physical_windowleft = spw->left;
+ physical_windowtop = spw->top;
+ physical_windowright = spw->right;
+ physical_windowbottom = spw->bottom;
+ physical_windowwidth = spw->width;
+ physical_windowheight = spw->height;
+
+ charwidth = spw->charwidth;
+ lineheight = spw->lineheight;
+ currentpos = spw->currentpos;
+ currentline = spw->currentline;
+
+/* if (currentfont!=spw->currentfont) hugo_font((currentfont = spw->currentfont)); */
+}
+
+void Hugo::RunWindow() {
+ int top, bottom, left, right;
+ struct SAVED_WINDOW_DATA restorewindow;
+ int temp_current_text_y;
+ char restore_default_bgcolor;
+ int tempfull;
+ int temp_stack_depth = stack_depth;
+ HUGO_FILE tempscript;
+#ifdef MINIMAL_WINDOWING
+ int last_lowest_windowbottom = lowest_windowbottom;
+#endif
+
+#if defined (DEBUGGER)
+ unsigned char param_type;
+ int tempdbnest;
+ long param_start;
+#endif
+
+ Flushpbuffer();
+ tempfull = full;
+ full = 0;
+ override_full = false;
+
+ temp_current_text_y = current_text_y;
+
+ tempscript = script;
+ script = false;
+ restore_default_bgcolor = default_bgcolor;
+
+ /* v2.4 is the first version to support proper windowing */
+ if (game_version>=24)
+ {
+ /* Set up default top, left, etc. as character coordinates,
+ and save the current physical window data
+ */
+ left = physical_windowleft/FIXEDCHARWIDTH + 1;
+ top = physical_windowtop/FIXEDLINEHEIGHT + 1;
+ right = physical_windowright/FIXEDCHARWIDTH + 1;
+ bottom = physical_windowbottom/FIXEDLINEHEIGHT + 1;
+
+ SaveWindowData(&restorewindow);
+
+ /* if "window x1, y1, x2, y2" or "window n"... */
+ if (MEM(++codeptr)!=EOL_T)
+ {
+#if defined (DEBUGGER)
+ param_type = MEM(codeptr);
+ param_start = codeptr;
+#endif
+ left = GetValue();
+ if (MEM(codeptr++)==COMMA_T)
+ {
+ top = GetValue();
+ if (MEM(codeptr++)==COMMA_T)
+ {
+ right = GetValue();
+ if (MEM(codeptr++)==COMMA_T)
+ {
+ bottom = GetValue();
+ codeptr++;
+ }
+ }
+ }
+
+ /* if only one parameter, i.e., "window n" */
+ else
+ {
+ if (left!=0)
+ {
+ bottom = left;
+ top = 1;
+ left = 1;
+ right = SCREENWIDTH/FIXEDCHARWIDTH;
+ }
+
+ /* "window 0" restores full screen without
+ running a code block
+ */
+ else
+ {
+#if defined (DEBUGGER)
+ /* Here, check to see if left was 0 but the
+ statement wasn't really "window 0", but
+ rather something that evaluated to zero
+ */
+ if (runtime_warnings)
+ {
+ if (param_type!=VALUE_T || param_start!=codeptr-4)
+ RuntimeWarning("Window size evaluates to zero");
+ }
+#endif
+ left = 1, top = 1;
+ right = SCREENWIDTH/FIXEDCHARWIDTH;
+ bottom = SCREENHEIGHT/FIXEDLINEHEIGHT;
+ physical_lowest_windowbottom = lowest_windowbottom = 0;
+ hugo_settextwindow(left, top, right, bottom);
+ goto LeaveWindow;
+ }
+ }
+ }
+
+ /* ...or just "window", so use last window defaults */
+ else
+ {
+ codeptr++; /* skip EOL */
+
+ left = last_window_left;
+ top = last_window_top;
+ right = last_window_right;
+ bottom = last_window_bottom;
+ }
+
+ /* Remember, these are character/text coordinates */
+ if (top < 1) top = 1;
+ if (left < 1) left = 1;
+ if (bottom < 1) bottom = 1;
+ if (right < 1) right = 1;
+ if (top > SCREENHEIGHT/FIXEDLINEHEIGHT)
+ top = SCREENHEIGHT/FIXEDLINEHEIGHT;
+ if (left > SCREENWIDTH/FIXEDCHARWIDTH)
+ left = SCREENWIDTH/FIXEDCHARWIDTH;
+ if (bottom > SCREENHEIGHT/FIXEDLINEHEIGHT)
+ bottom = SCREENHEIGHT/FIXEDLINEHEIGHT;
+ if (right > SCREENWIDTH/FIXEDCHARWIDTH)
+ right = SCREENWIDTH/FIXEDCHARWIDTH;
+
+ /* Set the new text window */
+ inwindow = true;
+ hugo_settextwindow(left, top, right, bottom);
+ hugo_settextpos(1, 1);
+
+#if defined (DEBUGGER)
+ tempdbnest = dbnest++;
+#endif
+ SetStackFrame(stack_depth, RUNROUTINE_BLOCK, 0, 0);
+
+ RunRoutine(codeptr);
+
+#if defined (DEBUGGER)
+ dbnest = tempdbnest;
+#endif
+ stack_depth = temp_stack_depth;
+
+ Flushpbuffer();
+
+ /* Restore the old window parameters */
+ last_window_top = top;
+ last_window_bottom = bottom;
+ last_window_left = left;
+ last_window_right = right;
+
+ /* Figure out what the lowest window bottom is that we need
+ to protect from scrolling
+ */
+ if (bottom > lowest_windowbottom)
+ lowest_windowbottom = bottom;
+
+#ifdef MINIMAL_WINDOWING
+ if (minimal_windowing && illegal_window)
+ lowest_windowbottom = last_lowest_windowbottom;
+#endif
+ /* (error situation--shouldn't happen) */
+ if (lowest_windowbottom>=SCREENHEIGHT/FIXEDLINEHEIGHT)
+ lowest_windowbottom = 0;
+
+ /* Restore the old text window */
+ RestoreWindowData(&restorewindow);
+
+ inwindow = false;
+ hugo_settextwindow(physical_windowleft/FIXEDCHARWIDTH + 1,
+ lowest_windowbottom + 1,
+ physical_windowright/FIXEDCHARWIDTH + 1,
+ physical_windowbottom/FIXEDLINEHEIGHT + 1);
+
+ physical_lowest_windowbottom = lowest_windowbottom*FIXEDLINEHEIGHT;
+ }
+
+ /* v2.3 and earlier supported a very simple version of
+ windowing: mainly just moving the top/scroll-off line
+ of the printable area to the bottom of the text printed
+ in the "window" block
+ */
+ else
+ {
+ inwindow = true;
+ hugo_settextwindow(1, 1,
+ SCREENWIDTH/FIXEDCHARWIDTH,
+ SCREENHEIGHT/FIXEDLINEHEIGHT);
+ hugo_settextpos(1, 1);
+
+ SetStackFrame(stack_depth, RUNROUTINE_BLOCK, 0, 0);
+ RunRoutine(++codeptr);
+ Flushpbuffer();
+
+ inwindow = false;
+
+ stack_depth = temp_stack_depth;
+
+ hugo_settextwindow(1, full+1,
+ SCREENWIDTH/FIXEDCHARWIDTH,
+ SCREENHEIGHT/FIXEDLINEHEIGHT);
+
+ physical_lowest_windowbottom = full*lineheight;
+ }
+
+LeaveWindow:
+
+ current_text_y = temp_current_text_y;
+
+#ifndef PALMOS
+ if (!current_text_y)
+ hugo_settextpos(1, physical_windowheight/lineheight);
+#endif
+ current_text_x = 0;
+ currentpos = 0;
+
+ default_bgcolor = restore_default_bgcolor;
+ script = tempscript;
+
+ if (!override_full)
+ full = tempfull;
+ override_full = false;
+
+ just_left_window = true;
+}
+
+} // End of namespace Hugo
+} // End of namespace Glk
diff --git a/engines/glk/hugo/hugo.cpp b/engines/glk/hugo/hugo.cpp
index f7d39a7068..bd8575b080 100644
--- a/engines/glk/hugo/hugo.cpp
+++ b/engines/glk/hugo/hugo.cpp
@@ -68,7 +68,10 @@ Hugo::Hugo(OSystem *syst, const GlkGameDescription &gameDesc) : GlkAPI(syst, gam
debugger_finish(false), debugger_run(false), debugger_interrupt(false),
debugger_skip(false), runtime_error(false), currentroutine(false),
complex_prop_breakpoint(false), trace_complex_prop_routine(false), routines(0),
- properties(0), current_locals(0), this_codeptr(0), debug_workspace(0), attributes(0)
+ properties(0), current_locals(0), this_codeptr(0), debug_workspace(0), attributes(0),
+ original_dictcount(0), buffered_code_lines(0), debugger_has_stepped_back(false),
+ debugger_step_back(false), debugger_collapsing(0), runaway_counter(0), history_count(0),
+ active_screen(0), step_nest(0), history_last(0)
#endif
{
// heexpr
@@ -107,6 +110,8 @@ Hugo::Hugo(OSystem *syst, const GlkGameDescription &gameDesc) : GlkAPI(syst, gam
Common::fill(&propertyname[0], &propertyname[MAX_PROPERTY], (char *)nullptr);
Common::fill(&codeline[0][0], &codeline[9][100], 0);
Common::fill(&localname[0][0], &localname[9][100], 0);
+ Common::fill(&code_history[0], &code_history[MAX_CODE_HISTORY], 0);
+ Common::fill(&dbnest_history[0], &dbnest_history[MAX_CODE_HISTORY], 0);
#endif
}
@@ -122,7 +127,7 @@ void Hugo::runGame() {
LoadGame();
- PlayGame();
+ playGame();
hugo_cleanup_screen();
diff --git a/engines/glk/hugo/hugo.h b/engines/glk/hugo/hugo.h
index aa4deee21a..d022b1f2b0 100644
--- a/engines/glk/hugo/hugo.h
+++ b/engines/glk/hugo/hugo.h
@@ -24,6 +24,7 @@
#define GLK_HUGO_HUGO
#include "common/scummsys.h"
+#include "common/str.h"
#include "glk/glk_api.h"
#include "glk/hugo/htokens.h"
#include "glk/hugo/hugo_defines.h"
@@ -177,8 +178,8 @@ private:
char parse_called_twice;
char reparse_everything;
char punc_string[64]; ///< punctuation string
+ bool full_buffer;
- char full_buffer;
/**
* to MatchObject()
* Necessary for proper disambiguation when addressing a character;
@@ -223,13 +224,12 @@ private:
bool debugger_interrupt;
bool debugger_skip;
bool runtime_error;
- int currentroutine;
+ uint currentroutine;
bool complex_prop_breakpoint;
bool trace_complex_prop_routine;
char *objectname[MAX_OBJECT];
char *propertyname[MAX_PROPERTY];
-// CODE code[999];
- CALL call[999];
+ CALL call[MAXCALLS];
int routines;
int properties;
WINDOW window[99];
@@ -239,6 +239,20 @@ private:
long this_codeptr;
int debug_workspace;
int attributes;
+ int original_dictcount;
+ int buffered_code_lines;
+ bool debugger_has_stepped_back;
+ bool debugger_step_back;
+ int debugger_collapsing;
+ int runaway_counter;
+ int history_count;
+ int active_screen;
+ int step_nest;
+ BREAKPOINT breakpoint[MAXBREAKPOINTS];
+ BREAKPOINT watch[MAXBREAKPOINTS];
+ int code_history[MAX_CODE_HISTORY];
+ int dbnest_history[MAX_CODE_HISTORY];
+ int history_last;
#endif
private:
/**
@@ -822,6 +836,86 @@ private:
/**@}*/
/**
+ * \defgroup herun
+ * @{
+ */
+
+ void RunDo();
+
+ void RunEvents();
+
+ void playGame();
+
+ void RunIf(char override);
+
+ void RunInput();
+
+ /**
+ * (All the debugger range-checking is important because invalid memory writes due
+ * to invalid object location calculations are a good way to crash the system.)
+ */
+ void RunMove();
+
+ void RunPrint();
+
+ int RunRestart();
+
+ int RestoreGameData();
+
+ int RunRestore();
+
+ /**
+ * This is the main loop for running each line of code in sequence;
+ * the main switch statement is based on the first token in each line.
+ *
+ * This routine is relatively complex, especially given the addition of debugger control.
+ * Basically it is structured like this:
+ *
+ * 1. If this is the debugger build, see what debugger information has to be set up upon
+ * calling this block of code
+ *
+ * 2. Get the next token, and as long as it isn't CLOSE_BRACE_T ('}')...
+ *
+ * 3. ...If this is the debugger build, see if there is a standing debugger_interrupt
+ * to pass control back to the debugger, and perform all operations for stepping
+ * tracing, breakpoints, etc.
+ *
+ * 4. ...See what token we're dealing with and execute accordingly
+ *
+ * 5. ...Loop back to (2)
+ *
+ * 6. If this is the debugger build, do whatever is necessary to tidy up after finishing
+ * this block of code
+ *
+ * There's a bit of a trick involved since the original language design uses "{...}"
+ * structures for both conditionals and blocks that necessitate another (i.e., nested) call
+ * to RunRoutine(). The call_block structure array and stack_depth variable are the
+ * navigation guides.
+ */
+ void RunRoutine(long addr);
+
+ int SaveGameData();
+
+ int RunSave();
+
+ int RunScriptSet();
+
+ /**
+ * As in 'x = string(<array>, "<string>"[, maxlen]'.
+ */
+ int RunString();
+
+ int RunSystem();
+
+ void SaveWindowData(SAVED_WINDOW_DATA *spw);
+
+ void RestoreWindowData(SAVED_WINDOW_DATA *spw);
+
+ void RunWindow();
+
+ /**@}*/
+
+ /**
* \defgroup Miscellaneous
* @{
*/
@@ -833,10 +927,71 @@ private:
int hugo_fgetc(Common::SeekableReadStream *s) {
return s->readByte();
}
+ int hugo_fgetc(strid_t s) {
+ Common::SeekableReadStream *ws = *s;
+ return hugo_fgetc(ws);
+ }
+
+ int hugo_fputc(int c, Common::WriteStream *s) {
+ s->writeByte(c);
+ return s->err() ? EOF : 0;
+ }
+ int hugo_fputc(int c, strid_t s) {
+ Common::WriteStream *ws = *s;
+ return hugo_fputc(c, ws);
+ }
+
+ char *hugo_fgets(char *buf, int max, Common::SeekableReadStream *s) {
+ char *ptr = buf;
+ char c;
+ while (s->pos() < s->size() && (c = hugo_fgetc(s)) != '\n')
+ *ptr++ = c;
+ return buffer;
+ }
+ char *hugo_fgets(char *buf, int max, strid_t s) {
+ Common::SeekableReadStream *rs = *s;
+ return hugo_fgets(buf, max, rs);
+ }
+
+ size_t hugo_fread(void *ptr, size_t size, size_t count, Common::SeekableReadStream *s) {
+ return s->read(ptr, size * count);
+ }
+
+ int hugo_fprintf(Common::WriteStream *s, const char *fmt, ...) {
+ va_list va;
+ va_start(va, fmt);
+ Common::String text = Common::String::vformat(fmt, va);
+ va_end(va);
+
+ s->write(text.c_str(), text.size());
+ return s->err() ? -1 : 0;
+ }
+ int hugo_fprintf(strid_t s, const char *fmt, ...) {
+ va_list va;
+ va_start(va, fmt);
+ Common::String text = Common::String::vformat(fmt, va);
+ va_end(va);
+
+ Common::WriteStream *str = *s;
+ str->write(text.c_str(), text.size());
+ return str->err() ? -1 : 0;
+ }
+
+ int hugo_fputs(const char *str, Common::WriteStream *s) {
+ return s->write(str, strlen(str)) == strlen(str) ? 0 : -1;
+ }
+ int hugo_fputs(const char *str, strid_t s) {
+ Common::WriteStream *ws = *s;
+ return hugo_fputs(str, ws);
+ }
bool hugo_ferror(Common::SeekableReadStream *s) const {
return s->err();
}
+ bool hugo_ferror(strid_t s) const {
+ Common::SeekableReadStream *rs = *s;
+ return hugo_ferror(rs);
+ }
long hugo_ftell(Common::SeekableReadStream *s) {
return s->pos();
@@ -851,10 +1006,6 @@ private:
error("%s", line);
}
- size_t hugo_fread(void *ptr, size_t size, size_t count, Common::SeekableReadStream *s) {
- return s->read(ptr, size * count);
- }
-
uint hugo_rand() {
return _random.getRandomNumber(0xffffff);
}
@@ -894,9 +1045,23 @@ private:
void SwitchtoDebugger() {}
+ void Debugger() {}
+
+ void UpdateDebugScreen() {}
+
+ void SwitchtoGame() {}
+
void DebuggerFatal(DEBUGGER_ERROR err) { error("Debugger error"); }
+ void AddLinetoCodeWindow(int lineNum) {}
+
void RecoverLastGood() {}
+
+ void SetupWatchEval(int num) {}
+
+ bool EvalWatch() { return false; }
+
+ void RunSet(int v) {}
#endif
public:
/**
@@ -925,20 +1090,16 @@ public:
virtual Common::Error saveGameData(strid_t file, const Common::String &desc) override;
// TODO: Stubs to be Properly implemented
- void PlayGame() {}
void hugo_closefiles() {}
- void RunRoutine(long v) {}
unsigned int FindWord(const char *a) { return 0; }
void hugo_stopsample() {}
void hugo_stopmusic() {}
int hugo_hasgraphics() { return 0; }
int hugo_writetoscript(const char *s) { return 0; }
- short RunSave() { return 0; }
- short RunRestore() { return 0; }
- short RunScriptSet() { return 0; }
- short RunRestart() { return 0; }
- short RunString() { return 0; }
- short RunSystem() { return 0; }
+ void DisplayPicture() {}
+ void PlayMusic() {}
+ void PlaySample() {}
+ void PlayVideo() {}
};
} // End of namespace Hugo
diff --git a/engines/glk/hugo/hugo_defines.h b/engines/glk/hugo/hugo_defines.h
index 5d69c847c2..02cfab1882 100644
--- a/engines/glk/hugo/hugo_defines.h
+++ b/engines/glk/hugo/hugo_defines.h
@@ -32,7 +32,7 @@ namespace Hugo {
#define HEREVISION 3
#define HEINTERIM ".0"
#define GLK
-#define DEBUGGER
+#define DEBUGGER 1
#define MAXOBJLIST 32
#define MAX_CONTEXT_COMMANDS 32
@@ -44,9 +44,10 @@ namespace Hugo {
#define MAX_MOBJ 16 /* maximum number of matchable object words */
#define MAXBUFFER 255
#define MAXUNDO 1024
-
+#define MAXCALLS 99
+#define MAXBREAKPOINTS 99
+#define MAX_CODE_HISTORY 99
#define CHARWIDTH 1
-#define STAT_UNAVAILABLE (-1)
#define HUGO_FILE strid_t
#define MAXPATH 256
@@ -149,13 +150,20 @@ browsing.
#define TAIL_RECURSION_ROUTINE (-1)
#define TAIL_RECURSION_PROPERTY (-2)
+#define STAT_UNAVAILABLE ((short)-1)
+
+#define PRINTFATALERROR(a) error("%s", a)
+
#if defined (DEBUGGER)
#define VIEW_CALLS 0
#define VIEW_LOCALS 1
#define CODE_WINDOW 2
-#endif
+#define VIEW_BREAKPOINTS 3
+#define VIEW_WATCH 4
-#define PRINTFATALERROR(a) error("%s", a)
+#define FORCE_REDRAW 1
+
+#endif
} // End of namespace Hugo
} // End of namespace Glk
diff --git a/engines/glk/hugo/hugo_types.h b/engines/glk/hugo/hugo_types.h
index dacde03d54..fcdaa8ed27 100644
--- a/engines/glk/hugo/hugo_types.h
+++ b/engines/glk/hugo/hugo_types.h
@@ -100,6 +100,13 @@ struct pobject_structure {
pobject_structure() : obj(0), type(0) {}
};
+struct SAVED_WINDOW_DATA {
+ int left, top, right, bottom;
+ int width, height, charwidth, lineheight;
+ int currentpos, currentline;
+ int currentfont;
+};
+
/**
* Structure used for navigating {...} blocks:
*/
@@ -133,8 +140,19 @@ struct CALL {
struct WINDOW {
int count;
+ bool changed;
+
+ WINDOW() : count(99), changed(false) {}
+};
+
+struct BREAKPOINT {
+ bool isbreak;
+ long addr;
+ const char *in;
+ int count;
- WINDOW() : count(99) {}
+ BREAKPOINT() : isbreak(false), addr(0), in(nullptr), count(0) {
+ }
};
#endif
diff --git a/engines/glk/module.mk b/engines/glk/module.mk
index 00f5e35d56..00641dd854 100644
--- a/engines/glk/module.mk
+++ b/engines/glk/module.mk
@@ -77,6 +77,7 @@ MODULE_OBJS := \
hugo/hemisc.o \
hugo/heobject.o \
hugo/heparse.o \
+ hugo/herun.o \
hugo/htokens.o \
hugo/hugo.o \
hugo/stringfn.o \
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-21 21:23:56 +0000