Use g_cond_wait_until() instead of g_cond_timed_wait()
[projects/chimara/chimara.git] / interpreters / bocfel / zterp.c
1 /*-
2  * Copyright 2009-2012 Chris Spiegel.
3  *
4  * This file is part of Bocfel.
5  *
6  * Bocfel is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License, version
8  * 2 or 3, as published by the Free Software Foundation.
9  *
10  * Bocfel is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with Bocfel.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <stdint.h>
23 #include <ctype.h>
24 #include <signal.h>
25 #include <limits.h>
26
27 #include "zterp.h"
28 #include "blorb.h"
29 #include "branch.h"
30 #include "io.h"
31 #include "memory.h"
32 #include "osdep.h"
33 #include "process.h"
34 #include "random.h"
35 #include "screen.h"
36 #include "stack.h"
37 #include "unicode.h"
38 #include "util.h"
39
40 #ifdef ZTERP_GLK
41 #include <glk.h>
42 #include <libchimara/garglk.h>
43 #ifdef GARGLK
44 #include <glkstart.h>
45 #include <gi_blorb.h>
46
47 static schanid_t sound_channel = NULL;
48 #endif
49 #endif
50
51 #define MAX_LINE        2048
52 #define MAX_PATH        4096
53
54 #define ZTERP_VERSION   "0.6.1"
55
56 const char *game_file;
57 struct options options = {
58   .eval_stack_size = DEFAULT_STACK_SIZE,
59   .call_stack_size = DEFAULT_CALL_DEPTH,
60   .disable_color = 0,
61   .disable_config = 0,
62   .disable_sound = 0,
63   .disable_timed = 0,
64   .enable_escape = 0,
65   .escape_string = NULL,
66   .disable_fixed = 0,
67   .assume_fixed = 0,
68   .disable_graphics_font = 0,
69   .enable_alt_graphics = 0,
70   .show_id = 0,
71   .disable_term_keys = 0,
72   .disable_utf8 = 0,
73   .force_utf8 = 0,
74   .disable_meta_commands = 0,
75   .int_number = 1, /* DEC */
76   .int_version = 'C',
77   .replay_on = 0,
78   .replay_name = NULL,
79   .record_on = 0,
80   .record_name = NULL,
81   .transcript_on = 0,
82   .transcript_name = NULL,
83   .max_saves = 10,
84   .disable_undo_compression = 0,
85   .show_version = 0,
86   .disable_abbreviations = 0,
87   .enable_censorship = 0,
88   .overwrite_transcript = 0,
89   .random_seed = -1,
90   .random_device = NULL,
91 };
92
93 static char story_id[64];
94
95 uint32_t pc;
96
97 /* zversion stores the Z-machine version of the story: 1–6.
98  *
99  * Z-machine versions 7 and 8 are identical to version 5 but for a
100  * couple of tiny details.  They are thus classified as version 5.
101  *
102  * zwhich stores the actual version (1–8) for the few rare times where
103  * this knowledge is necessary.
104  */
105 int zversion;
106 static int zwhich;
107
108 struct header header;
109
110 static struct
111 {
112   zterp_io *io;
113   long offset;
114 } story;
115
116 /* The null character in the alphabet table does not actually signify a
117  * null character: character 6 from A2 is special in that it specifies
118  * that the next two characters form a 10-bit ZSCII character (§3.4).
119  * The code that uses the alphabet table will step around this character
120  * when necessary, so it’s safe to use a null character here to mean
121  * “nothing”.
122  */
123 uint8_t atable[26 * 3] =
124 {
125   /* A0 */
126   'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
127   'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
128
129   /* A1 */
130   'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
131   'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
132
133   /* A2 */
134   0x0, 0xd, '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.',
135   ',', '!', '?', '_', '#', '\'','"', '/', '\\','-', ':', '(', ')',
136 };
137
138 void znop(void)
139 {
140 }
141
142 void zquit(void)
143 {
144   break_from(0);
145 }
146
147 void zverify(void)
148 {
149   uint16_t checksum = 0;
150   uint32_t remaining = header.file_length - 0x40;
151
152   if(zterp_io_seek(story.io, story.offset + 0x40, SEEK_SET) == -1)
153   {
154     branch_if(0);
155     return;
156   }
157
158   while(remaining != 0)
159   {
160     uint8_t buf[8192];
161     uint32_t to_read = remaining < sizeof buf ? remaining : sizeof buf;
162
163     if(zterp_io_read(story.io, buf, to_read) != to_read)
164     {
165       branch_if(0);
166       return;
167     }
168
169     for(uint32_t i = 0; i < to_read; i++) checksum += buf[i];
170
171     remaining -= to_read;
172   }
173
174   branch_if(checksum == header.checksum);
175 }
176
177 uint32_t unpack(uint16_t addr, int string)
178 {
179   switch(zwhich)
180   {
181     case 1: case 2: case 3:
182       return addr * 2UL;
183     case 4: case 5:
184       return addr * 4UL;
185     case 6: case 7:
186       return (addr * 4UL) + (string ? header.S_O : header.R_O);
187     case 8:
188       return addr * 8UL;
189     default:
190       die("unhandled z-machine version: %d", zwhich);
191   }
192 }
193
194 void store(uint16_t v)
195 {
196   store_variable(BYTE(pc++), v);
197 }
198
199 void zsave5(void)
200 {
201   zterp_io *savefile;
202   size_t n;
203
204   if(znargs == 0)
205   {
206     zsave();
207     return;
208   }
209
210   /* This should be able to suggest a filename, but Glk doesn’t support that. */
211   savefile = zterp_io_open(NULL, ZTERP_IO_WRONLY | ZTERP_IO_SAVE);
212   if(savefile == NULL)
213   {
214     store(0);
215     return;
216   }
217
218   ZASSERT(zargs[0] + zargs[1] < memory_size, "attempt to save beyond the end of memory");
219   n = zterp_io_write(savefile, &memory[zargs[0]], zargs[1]);
220
221   zterp_io_close(savefile);
222
223   store(n == zargs[1]);
224 }
225
226 void zrestore5(void)
227 {
228   zterp_io *savefile;
229   uint8_t *buf;
230   size_t n;
231
232   if(znargs == 0)
233   {
234     zrestore();
235     return;
236   }
237
238   savefile = zterp_io_open(NULL, ZTERP_IO_RDONLY | ZTERP_IO_SAVE);
239   if(savefile == NULL)
240   {
241     store(0);
242     return;
243   }
244
245   buf = malloc(zargs[1]);
246   if(buf == NULL)
247   {
248     store(0);
249     return;
250   }
251
252   n = zterp_io_read(savefile, buf, zargs[1]);
253   for(size_t i = 0; i < n; i++) user_store_byte(zargs[0] + i, buf[i]);
254
255   free(buf);
256
257   zterp_io_close(savefile);
258
259   store(n);
260 }
261
262 void zpiracy(void)
263 {
264   branch_if(1);
265 }
266
267 void zsound_effect(void)
268 {
269 #ifdef GARGLK
270   uint8_t repeats, volume;
271   static uint32_t vols[8] = {
272     0x02000, 0x04000, 0x06000, 0x08000,
273     0x0a000, 0x0c000, 0x0e000, 0x10000
274   };
275
276   if(sound_channel == NULL || zargs[0] < 3) return;
277
278   repeats = zargs[2] >> 8;
279   volume = zargs[2] & 0xff;
280
281   if(volume == 0) volume = 1;
282   if(volume  > 8) volume = 8;
283
284   glk_schannel_set_volume(sound_channel, vols[volume - 1]);
285
286   switch(zargs[1])
287   {
288     case 1: /* prepare */
289       glk_sound_load_hint(zargs[0], 1);
290       break;
291     case 2: /* start */
292       glk_schannel_play_ext(sound_channel, zargs[0], repeats == 255 ? -1 : repeats, 0);
293       break;
294     case 3: /* stop */
295       glk_schannel_stop(sound_channel);
296       break;
297     case 4: /* finish with */
298       glk_sound_load_hint(zargs[0], 0);
299       break;
300   }
301 #endif
302 }
303
304 /* Find a story ID roughly in the form of an IFID according to §2.2.2.1
305  * of draft 7 of the Treaty of Babel.
306  *
307  * This does not add a ZCODE- prefix, and will not search for a manually
308  * created IFID.
309  */
310 static void find_id(void)
311 {
312   char serial[] = "------";
313
314   for(int i = 0; i < 6; i++)
315   {
316     /* isalnum() cannot be used because it is locale-aware, and this
317      * must only check for A–Z, a–z, and 0–9.  Because ASCII (or a
318      * compatible charset) is required, testing against 'a', 'z', etc.
319      * is OK.
320      */
321 #define ALNUM(c) ( ((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || ((c) >= '0' && (c) <= '9') )
322     if(ALNUM(header.serial[i])) serial[i] = header.serial[i];
323 #undef ALNUM
324   }
325
326   if(strchr("012345679", serial[0]) != NULL && strcmp(serial, "000000") != 0)
327   {
328     snprintf(story_id, sizeof story_id, "%d-%s-%04x", header.release, serial, (unsigned)header.checksum);
329   }
330   else
331   {
332     snprintf(story_id, sizeof story_id, "%d-%s", header.release, serial);
333   }
334 }
335
336 int is_story(const char *id)
337 {
338   return strcmp(story_id, id) == 0;
339 }
340
341 #ifndef ZTERP_NO_CHEAT
342 /* The index into these arrays is the address to freeze.
343  * The first array tracks whether the address is frozen, while the
344  * second holds the frozen value.
345  */
346 static char     freezew_cheat[UINT16_MAX + 1];
347 static uint16_t freezew_val  [UINT16_MAX + 1];
348
349 static void cheat(char *how)
350 {
351   char *p;
352
353   p = strtok(how, ":");
354   if(p == NULL) return;
355
356   if(strcmp(p, "freezew") == 0)
357   {
358     uint16_t addr;
359
360     p = strtok(NULL, ":");
361     if(p == NULL) return;
362
363     if(*p == 'G')
364     {
365       addr = strtoul(p + 1, NULL, 16);
366       if(addr > 239) return;
367
368       addr = header.globals + (addr * 2);
369     }
370     else
371     {
372       addr = strtoul(p, NULL, 16);
373     }
374
375     p = strtok(NULL, ":");
376     if(p == NULL) return;
377
378     freezew_cheat[addr] = 1;
379     freezew_val  [addr] = strtoul(p, NULL, 0);
380   }
381 }
382
383 int cheat_find_freezew(uint32_t addr, uint16_t *val)
384 {
385   if(addr > UINT16_MAX || !freezew_cheat[addr]) return 0;
386
387   *val = freezew_val[addr];
388
389   return 1;
390 }
391 #endif
392
393 static void read_config(void)
394 {
395   FILE *fp;
396   char file[MAX_PATH + 1];
397   char line[MAX_LINE];
398   char *key, *val, *p;
399   long n;
400   int story_matches = 1;
401
402   zterp_os_rcfile(file, sizeof file);
403
404   fp = fopen(file, "r");
405   if(fp == NULL) return;
406
407   while(fgets(line, sizeof line, fp) != NULL)
408   {
409     line[strcspn(line, "#\n")] = 0;
410     if(line[0] == 0) continue;
411
412     if(line[0] == '[')
413     {
414       p = strrchr(line, ']');
415       if(p != NULL && p[1] == 0)
416       {
417         *p = 0;
418
419         story_matches = 0;
420         for(p = strtok(line + 1, " ,"); p != NULL; p = strtok(NULL, " ,"))
421         {
422           if(is_story(p)) story_matches = 1;
423         }
424       }
425
426       continue;
427     }
428
429     if(!story_matches) continue;
430
431     key = strtok(line, " \t=");
432     if(key == NULL) continue;
433     val = strtok(NULL, "=");
434     if(val == NULL) continue;
435
436     /* Trim whitespace. */
437     while(isspace((unsigned char)*val)) val++;
438     if(*val == 0) continue;
439     p = val + strlen(val) - 1;
440     while(isspace((unsigned char)*p)) *p-- = 0;
441
442     n = strtol(val, NULL, 10);
443
444 #define BOOL(name)      else if(strcmp(key, #name) == 0) options.name = (n != 0)
445 #define NUMBER(name)    else if(strcmp(key, #name) == 0) options.name = n
446 #define STRING(name)    else if(strcmp(key, #name) == 0) do { free(options.name); options.name = xstrdup(val); } while(0)
447 #define CHAR(name)      else if(strcmp(key, #name) == 0) options.name = val[0]
448 #ifdef GARGLK
449 #define COLOR(name, num)else if(strcmp(key, "color_" #name) == 0) update_color(num, strtol(val, NULL, 16))
450 #else
451 #define COLOR(name, num)else if(0)
452 #endif
453
454     if(0);
455
456     NUMBER(eval_stack_size);
457     NUMBER(call_stack_size);
458     BOOL  (disable_color);
459     BOOL  (disable_timed);
460     BOOL  (disable_sound);
461     BOOL  (enable_escape);
462     STRING(escape_string);
463     BOOL  (disable_fixed);
464     BOOL  (assume_fixed);
465     BOOL  (disable_graphics_font);
466     BOOL  (enable_alt_graphics);
467     BOOL  (disable_term_keys);
468     BOOL  (disable_utf8);
469     BOOL  (force_utf8);
470     BOOL  (disable_meta_commands);
471     NUMBER(max_saves);
472     BOOL  (disable_undo_compression);
473     NUMBER(int_number);
474     CHAR  (int_version);
475     BOOL  (replay_on);
476     STRING(replay_name);
477     BOOL  (record_on);
478     STRING(record_name);
479     BOOL  (transcript_on);
480     STRING(transcript_name);
481     BOOL  (disable_abbreviations);
482     BOOL  (enable_censorship);
483     BOOL  (overwrite_transcript);
484     NUMBER(random_seed);
485     STRING(random_device);
486
487     COLOR(black,   2);
488     COLOR(red,     3);
489     COLOR(green,   4);
490     COLOR(yellow,  5);
491     COLOR(blue,    6);
492     COLOR(magenta, 7);
493     COLOR(cyan,    8);
494     COLOR(white,   9);
495
496 #ifndef ZTERP_NO_CHEAT
497     else if(strcmp(key, "cheat") == 0) cheat(val);
498 #endif
499
500 #undef BOOL
501 #undef NUMBER
502 #undef STRING
503 #undef CHAR
504 #undef COLOR
505   }
506
507   fclose(fp);
508 }
509
510 static int have_statuswin = 0;
511 static int have_upperwin  = 0;
512
513 /* Various parts of the header (those marked “Rst” in §11) should be
514  * updated by the interpreter.  This function does that.  This is also
515  * used when restoring, because the save file might have come from an
516  * interpreter with vastly different settings.
517  */
518 void write_header(void)
519 {
520   uint8_t flags1;
521
522   flags1 = BYTE(0x01);
523
524   if(zversion == 3)
525   {
526     flags1 |= FLAGS1_NOSTATUS;
527     flags1 &= ~(FLAGS1_SCREENSPLIT | FLAGS1_VARIABLE);
528
529 #ifdef GARGLK
530     /* Assume that if Gargoyle is being used, the default font is not fixed. */
531     flags1 |= FLAGS1_VARIABLE;
532 #endif
533
534     if(have_statuswin)            flags1 &= ~FLAGS1_NOSTATUS;
535     if(have_upperwin)             flags1 |= FLAGS1_SCREENSPLIT;
536     if(options.enable_censorship) flags1 |= FLAGS1_CENSOR;
537   }
538   else if(zversion >= 4)
539   {
540     flags1 |= (FLAGS1_BOLD | FLAGS1_ITALIC | FLAGS1_FIXED);
541     flags1 &= ~FLAGS1_TIMED;
542
543     if(zversion >= 5) flags1 &= ~FLAGS1_COLORS;
544
545     if(zversion == 6)
546     {
547       flags1 &= ~(FLAGS1_PICTURES | FLAGS1_SOUND);
548 #ifdef GARGLK
549       if(sound_channel != NULL) flags1 |= FLAGS1_SOUND;
550 #endif
551     }
552
553 #ifdef ZTERP_GLK
554     if(glk_gestalt(gestalt_Timer, 0)) flags1 |= FLAGS1_TIMED;
555 #ifdef GARGLK
556     if(zversion >= 5) flags1 |= FLAGS1_COLORS;
557 #endif
558 #else
559     if(!zterp_os_have_style(STYLE_BOLD)) flags1 &= ~FLAGS1_BOLD;
560     if(!zterp_os_have_style(STYLE_ITALIC)) flags1 &= ~FLAGS1_ITALIC;
561     if(zversion >= 5 && zterp_os_have_colors()) flags1 |= FLAGS1_COLORS;
562 #endif
563
564     if(zversion >= 5 && options.disable_color) flags1 &= ~FLAGS1_COLORS;
565     if(options.disable_timed) flags1 &= ~FLAGS1_TIMED;
566     if(options.disable_fixed) flags1 &= ~FLAGS1_FIXED;
567   }
568
569   STORE_BYTE(0x01, flags1);
570
571   if(zversion >= 5)
572   {
573     uint16_t flags2 = WORD(0x10);
574
575     flags2 &= ~FLAGS2_MOUSE;
576 #ifdef GARGLK
577     if(sound_channel == NULL) flags2 &= ~FLAGS2_SOUND;
578 #else
579     flags2 &= ~FLAGS2_SOUND;
580 #endif
581     if(zversion >= 6) flags2 &= ~FLAGS2_MENUS;
582
583     if(options.disable_graphics_font) flags2 &= ~FLAGS2_PICTURES;
584
585     if(options.max_saves == 0) flags2 &= ~FLAGS2_UNDO;
586
587     STORE_WORD(0x10, flags2);
588   }
589
590   if(zversion >= 4)
591   {
592     unsigned int width, height;
593
594     /* Interpreter number & version. */
595     if(options.int_number < 1 || options.int_number > 11) options.int_number = 1; /* DEC */
596     STORE_BYTE(0x1e, options.int_number);
597     STORE_BYTE(0x1f, options.int_version);
598
599     get_screen_size(&width, &height);
600
601     /* Screen height and width.
602      * A height of 255 means infinite, so cap at 254.
603      */
604     STORE_BYTE(0x20, height > 254 ? 254 : height);
605     STORE_BYTE(0x21, width > 255 ? 255 : width);
606
607     if(zversion >= 5)
608     {
609       /* Screen width and height in units. */
610       STORE_WORD(0x22, width > UINT16_MAX ? UINT16_MAX : width);
611       STORE_WORD(0x24, height > UINT16_MAX ? UINT16_MAX : height);
612
613       /* Font width and height in units. */
614       STORE_BYTE(0x26, 1);
615       STORE_BYTE(0x27, 1);
616
617       /* Default background and foreground colors. */
618       STORE_BYTE(0x2c, 1);
619       STORE_BYTE(0x2d, 1);
620     }
621   }
622
623   /* Standard revision # */
624   STORE_BYTE(0x32, 1);
625   STORE_BYTE(0x33, 1);
626 }
627
628 void process_story(void)
629 {
630   if(zterp_io_seek(story.io, story.offset, SEEK_SET) == -1) die("unable to rewind story");
631
632   if(zterp_io_read(story.io, memory, memory_size) != memory_size) die("unable to read from story file");
633
634   zversion =            BYTE(0x00);
635   if(zversion < 1 || zversion > 8) die("only z-code versions 1-8 are supported");
636
637   zwhich = zversion;
638   if(zversion == 7 || zversion == 8) zversion = 5;
639
640   pc =                  WORD(0x06);
641   if(pc >= memory_size) die("corrupted story: initial pc out of range");
642
643   header.release =      WORD(0x02);
644   header.dictionary =   WORD(0x08);
645   header.objects =      WORD(0x0a);
646   header.globals =      WORD(0x0c);
647   header.static_start = WORD(0x0e);
648   header.abbr =         WORD(0x18);
649
650   memcpy(header.serial, &memory[0x12], sizeof header.serial);
651
652   /* There is no explicit “end of static” tag; but it must end by 0xffff
653    * or the end of the story file, whichever is smaller.
654    */
655   header.static_end = memory_size < 0xffff ? memory_size : 0xffff;
656
657 #define PROPSIZE        (zversion <= 3 ? 62L : 126L)
658
659   /* There must be at least enough room in dynamic memory for the header
660    * (64 bytes), the global variables table (480 bytes), and the
661    * property defaults table (62 or 126 bytes).
662    */
663   if(header.static_start < 64 + 480 + PROPSIZE)   die("corrupted story: dynamic memory too small (%d bytes)", (int)header.static_start);
664   if(header.static_start >= memory_size)          die("corrupted story: static memory out of range");
665
666   if(header.dictionary != 0 &&
667      header.dictionary < header.static_start)     die("corrupted story: dictionary is not in static memory");
668
669   if(header.objects < 64 ||
670      header.objects + PROPSIZE > header.static_start)
671                                                   die("corrupted story: object table is not in dynamic memory");
672
673 #undef PROPSIZE
674
675   if(header.globals < 64 ||
676      header.globals + 480L > header.static_start) die("corrupted story: global variables are not in dynamic memory");
677
678   if(header.abbr >= memory_size)                  die("corrupted story: abbreviation table out of range");
679
680   header.file_length = WORD(0x1a) * (zwhich <= 3 ? 2UL : zwhich <= 5 ? 4UL : 8UL);
681   if(header.file_length > memory_size)            die("story's reported size (%lu) greater than file size (%lu)", (unsigned long)header.file_length, (unsigned long)memory_size);
682
683   header.checksum = WORD(0x1c);
684
685   if(zwhich == 6 || zwhich == 7)
686   {
687     header.R_O = WORD(0x28) * 8UL;
688     header.S_O = WORD(0x2a) * 8UL;
689   }
690
691   if(dynamic_memory == NULL)
692   {
693     dynamic_memory = malloc(header.static_start);
694     if(dynamic_memory == NULL) die("unable to allocate memory for dynamic memory");
695     memcpy(dynamic_memory, memory, header.static_start);
696   }
697
698 #ifdef GLK_MODULE_LINE_TERMINATORS
699   if(!options.disable_term_keys)
700   {
701     if(zversion >= 5 && WORD(0x2e) != 0)
702     {
703       term_keys_reset();
704
705       for(uint32_t i = WORD(0x2e); i < memory_size && memory[i] != 0; i++)
706       {
707         term_keys_add(memory[i]);
708       }
709     }
710   }
711 #endif
712
713   if(zversion == 1)
714   {
715     memcpy(&atable[26 * 2], " 0123456789.,!?_#'\"/\\<-:()", 26);
716   }
717   else if(zversion >= 5 && WORD(0x34) != 0)
718   {
719     if(WORD(0x34) + 26 * 3 >= memory_size) die("corrupted story: alphabet table out of range");
720
721     memcpy(atable, &memory[WORD(0x34)], 26 * 3);
722
723     /* Even with a new alphabet table, characters 6 and 7 from A2 must
724      * remain the same (§3.5.5.1).
725      */
726     atable[52] = 0x00;
727     atable[53] = 0x0d;
728   }
729
730   /* Check for a header extension table. */
731   if(zversion >= 5)
732   {
733     uint16_t etable = WORD(0x36);
734
735     if(etable != 0)
736     {
737       uint16_t nentries = user_word(etable);
738
739       if(etable + (2 * nentries) >= memory_size) die("corrupted story: header extension table out of range");
740
741       /* Unicode table. */
742       if(nentries >= 3 && WORD(etable + (2 * 3)) != 0)
743       {
744         uint16_t utable = WORD(etable + (2 * 3));
745
746         parse_unicode_table(utable);
747       }
748
749       /* Flags3. */
750       if(nentries >= 4) STORE_WORD(etable + (2 * 4), 0);
751       /* True default foreground color. */
752       if(nentries >= 5) STORE_WORD(etable + (2 * 5), 0x0000);
753       /* True default background color. */
754       if(nentries >= 6) STORE_WORD(etable + (2 * 6), 0x7fff);
755     }
756   }
757
758   /* The configuration file cannot be read until the ID of the current
759    * story is known, and the ID of the current story is not known until
760    * the file has been processed; so do both of those here.
761    */
762   find_id();
763   if(!options.disable_config) read_config();
764
765   /* Prevent the configuration file from unexpectedly being reread after
766    * @restart or @restore.
767    */
768   options.disable_config = 1;
769
770   /* Most options directly set their respective variables, but a few
771    * require intervention.  Delay that intervention until here so that
772    * the configuration file is taken into account.
773    */
774   if(options.disable_utf8)
775   {
776 #ifndef ZTERP_GLK
777     /* If Glk is not being used, the ZSCII to Unicode table needs to be
778      * aligned with the IO character set.
779      */
780     have_unicode = 0;
781 #endif
782     use_utf8_io = 0;
783   }
784   if(options.force_utf8)
785   {
786 #ifndef ZTERP_GLK
787     /* See above. */
788     have_unicode = 1;
789 #endif
790     use_utf8_io = 1;
791   }
792   if(options.escape_string == NULL) options.escape_string = xstrdup("1m");
793
794 #ifdef GARGLK
795   if(options.disable_sound && sound_channel != NULL)
796   {
797     glk_schannel_destroy(sound_channel);
798     sound_channel = NULL;
799   }
800 #endif
801
802   /* Now that we have a Unicode table and the user’s Unicode
803    * preferences, build the ZSCII to Unicode and Unicode to ZSCII
804    * tables.
805    */
806   setup_tables();
807
808   if(zversion <= 3) have_statuswin = create_statuswin();
809   if(zversion >= 3) have_upperwin  = create_upperwin();
810
811   write_header();
812   /* Put everything in a clean state. */
813   seed_random(0);
814   init_stack();
815   init_screen();
816
817   /* Unfortunately, Beyond Zork behaves badly when the interpreter
818    * number is set to DOS: it assumes that it can print out IBM PC
819    * character codes and get useful results (e.g. it writes out 0x18
820    * expecting an up arrow); however, if the pictures bit is set, it
821    * uses the character graphics font like a good citizen.  Thus turn
822    * that bit on when Beyond Zork is being used and the interpreter is
823    * set to DOS.  It might make sense to do this generally, not just for
824    * Beyond Zork; but this is such a minor corner of the Z-machine that
825    * it probably doesn’t matter.  For now, peg this to Beyond Zork.
826    */
827   if(options.int_number == 6 &&
828       (is_story("47-870915") || is_story("49-870917") ||
829        is_story("51-870923") || is_story("57-871221")))
830   {
831     STORE_WORD(0x10, WORD(0x10) | FLAGS2_PICTURES);
832   }
833
834   if(options.transcript_on)
835   {
836     STORE_WORD(0x10, WORD(0x10) | FLAGS2_TRANSCRIPT);
837     options.transcript_on = 0;
838   }
839
840   if(options.record_on)
841   {
842     output_stream(OSTREAM_RECORD, 0);
843     options.record_on = 0;
844   }
845
846   if(options.replay_on)
847   {
848     input_stream(ISTREAM_FILE);
849     options.replay_on = 0;
850   }
851
852   if(zversion == 6)
853   {
854     zargs[0] = pc;
855     call(0);
856   }
857 }
858
859 #ifdef ZTERP_GLK
860 zexternally_visible
861 void glk_main(void)
862 #else
863 int main(int argc, char **argv)
864 #endif
865 {
866   zterp_blorb *blorb;
867
868 #ifdef ZTERP_GLK
869   if(!create_mainwin()) return;
870 #ifdef GLK_MODULE_UNICODE
871   have_unicode = glk_gestalt(gestalt_Unicode, 0);
872 #endif
873 #else
874   have_unicode = zterp_os_have_unicode();
875 #endif
876
877   use_utf8_io = zterp_os_have_unicode();
878
879 #ifndef ZTERP_GLK
880   if(!process_arguments(argc, argv)) exit(EXIT_FAILURE);
881
882   zterp_os_init_term();
883 #endif
884
885 #ifdef ZTERP_GLK
886 #define PRINT(s)        do { glk_put_string(s); glk_put_char(UNICODE_LINEFEED); } while(0)
887 #else
888 #define PRINT(s)        puts(s)
889 #endif
890
891   if(options.show_version)
892   {
893     char config[MAX_PATH] = "Configuration file: ";
894
895     PRINT("Bocfel " ZTERP_VERSION);
896 #ifdef ZTERP_NO_SAFETY_CHECKS
897     PRINT("Runtime assertions disabled");
898 #else
899     PRINT("Runtime assertions enabled");
900 #endif
901 #ifdef ZTERP_NO_CHEAT
902     PRINT("Cheat support disabled");
903 #else
904     PRINT("Cheat support enabled");
905 #endif
906 #ifdef ZTERP_TANDY
907     PRINT("The Tandy bit can be set");
908 #else
909     PRINT("The Tandy bit cannot be set");
910 #endif
911
912     zterp_os_rcfile(config + strlen(config), sizeof config - strlen(config));
913     PRINT(config);
914
915 #ifdef ZTERP_GLK
916     glk_exit();
917 #else
918     exit(0);
919 #endif
920   }
921
922 #undef PRINT
923
924 #ifdef GARGLK
925   if(game_file == NULL)
926   {
927     frefid_t ref;
928
929     ref = glk_fileref_create_by_prompt(fileusage_Data | fileusage_BinaryMode, filemode_Read, 0);
930     if(ref != NULL)
931     {
932       game_file = xstrdup(garglk_fileref_get_name(ref));
933       glk_fileref_destroy(ref);
934     }
935   }
936 #endif
937
938   if(game_file == NULL) die("no story provided");
939
940   story.io = zterp_io_open(game_file, ZTERP_IO_RDONLY);
941   if(story.io == NULL) die("cannot open file %s", game_file);
942
943   blorb = zterp_blorb_parse(story.io);
944   if(blorb != NULL)
945   {
946     const zterp_blorb_chunk *chunk;
947
948     chunk = zterp_blorb_find(blorb, BLORB_EXEC, 0);
949     if(chunk == NULL) die("no EXEC resource found");
950     if(strcmp(chunk->name, "ZCOD") != 0)
951     {
952       if(strcmp(chunk->name, "GLUL") == 0) die("Glulx stories are not supported (try git or glulxe)");
953
954       die("unknown story type: %s", chunk->name);
955     }
956
957     if(chunk->offset > LONG_MAX) die("zcode offset too large");
958
959     memory_size = chunk->size;
960     story.offset = chunk->offset;
961
962     zterp_blorb_free(blorb);
963   }
964   else
965   {
966     long size = zterp_io_filesize(story.io);
967
968     if(size == -1) die("unable to determine file size");
969     if(size > UINT32_MAX) die("file too large");
970
971     memory_size = size;
972     story.offset = 0;
973   }
974
975 #ifdef GARGLK
976   if(glk_gestalt(gestalt_Sound, 0))
977   {
978     /* 5 for the worst case of needing to add .blb to the end plus the
979      * null character.
980      */
981     char *blorb_file = malloc(strlen(game_file) + 5);
982     if(blorb_file != NULL)
983     {
984       char *p;
985       strid_t file;
986
987       strcpy(blorb_file, game_file);
988       p = strrchr(blorb_file, '.');
989       if(p != NULL) *p = 0;
990       strcat(blorb_file, ".blb");
991
992       file = glkunix_stream_open_pathname(blorb_file, 0, 0);
993       if(file != NULL)
994       {
995         giblorb_set_resource_map(file);
996         sound_channel = glk_schannel_create(0);
997       }
998
999       free(blorb_file);
1000     }
1001   }
1002 #endif
1003
1004   if(memory_size < 64) die("story file too small");
1005   if(memory_size > SIZE_MAX - 22) die("story file too large");
1006
1007   /* It’s possible for a story to be cut short in the middle of an
1008    * instruction.  If so, the processing loop will run past the end of
1009    * memory.  Either pc needs to be checked each and every time it is
1010    * incremented, or a small guard needs to be placed at the end of
1011    * memory that will trigger an illegal instruction error.  The latter
1012    * is done by filling the end of memory with zeroes, which do not
1013    * represent a valid instruction.
1014    *
1015    * There need to be at least 22 bytes for the worst case: 0xec
1016    * (call_vs2) as the last byte in memory.  The next two bytes, which
1017    * will be zeroes, indicate that 8 large constants, or 16 bytes, will
1018    * be next.  This is a store instruction, so one more byte will be
1019    * read to determine where to store.  Another byte is read to
1020    * determine the next opcode; this will be zero, which is nominally a
1021    * 2OP, requiring two more bytes to be read.  At this point the opcode
1022    * will be looked up, resulting in an illegal instruction error.
1023    */
1024   memory = malloc(memory_size + 22);
1025   if(memory == NULL) die("unable to allocate memory for story file");
1026   memset(memory + memory_size, 0, 22);
1027
1028   process_story();
1029
1030   /* If header transcript/fixed bits have been set, either by the
1031    * story or by the user, this will activate them.
1032    */
1033   user_store_word(0x10, WORD(0x10));
1034
1035   if(options.show_id)
1036   {
1037 #ifdef ZTERP_GLK
1038     glk_put_string(story_id);
1039     glk_exit();
1040 #else
1041     puts(story_id);
1042     exit(0);
1043 #endif
1044   }
1045
1046   setup_opcodes();
1047
1048   process_instructions();
1049
1050 #ifndef ZTERP_GLK
1051   return 0;
1052 #endif
1053 }