Use g_cond_wait_until() instead of g_cond_timed_wait()
[projects/chimara/chimara.git] / interpreters / frotz / process.c
1 /* process.c - Interpreter loop and program control
2  *      Copyright (c) 1995-1997 Stefan Jokisch
3  *
4  * This file is part of Frotz.
5  *
6  * Frotz is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * Frotz is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "frotz.h"
22
23 #ifdef DJGPP
24 #include "djfrotz.h"
25 #endif
26
27
28 zword zargs[8];
29 int zargc;
30
31 static int finished = 0;
32
33 static void __extended__ (void);
34 static void __illegal__ (void);
35
36 void (*op0_opcodes[0x10]) (void) = {
37     z_rtrue,
38     z_rfalse,
39     z_print,
40     z_print_ret,
41     z_nop,
42     z_save,
43     z_restore,
44     z_restart,
45     z_ret_popped,
46     z_catch,
47     z_quit,
48     z_new_line,
49     z_show_status,
50     z_verify,
51     __extended__,
52     z_piracy
53 };
54
55 void (*op1_opcodes[0x10]) (void) = {
56     z_jz,
57     z_get_sibling,
58     z_get_child,
59     z_get_parent,
60     z_get_prop_len,
61     z_inc,
62     z_dec,
63     z_print_addr,
64     z_call_s,
65     z_remove_obj,
66     z_print_obj,
67     z_ret,
68     z_jump,
69     z_print_paddr,
70     z_load,
71     z_call_n
72 };
73
74 void (*var_opcodes[0x40]) (void) = {
75     __illegal__,
76     z_je,
77     z_jl,
78     z_jg,
79     z_dec_chk,
80     z_inc_chk,
81     z_jin,
82     z_test,
83     z_or,
84     z_and,
85     z_test_attr,
86     z_set_attr,
87     z_clear_attr,
88     z_store,
89     z_insert_obj,
90     z_loadw,
91     z_loadb,
92     z_get_prop,
93     z_get_prop_addr,
94     z_get_next_prop,
95     z_add,
96     z_sub,
97     z_mul,
98     z_div,
99     z_mod,
100     z_call_s,
101     z_call_n,
102     z_set_colour,
103     z_throw,
104     __illegal__,
105     __illegal__,
106     __illegal__,
107     z_call_s,
108     z_storew,
109     z_storeb,
110     z_put_prop,
111     z_read,
112     z_print_char,
113     z_print_num,
114     z_random,
115     z_push,
116     z_pull,
117     z_split_window,
118     z_set_window,
119     z_call_s,
120     z_erase_window,
121     z_erase_line,
122     z_set_cursor,
123     z_get_cursor,
124     z_set_text_style,
125     z_buffer_mode,
126     z_output_stream,
127     z_input_stream,
128     z_sound_effect,
129     z_read_char,
130     z_scan_table,
131     z_not,
132     z_call_n,
133     z_call_n,
134     z_tokenise,
135     z_encode_text,
136     z_copy_table,
137     z_print_table,
138     z_check_arg_count
139 };
140
141 void (*ext_opcodes[0x1e]) (void) = {
142     z_save,
143     z_restore,
144     z_log_shift,
145     z_art_shift,
146     z_set_font,
147     __illegal__, // glkify - z_draw_picture,
148     __illegal__, // glkify - z_picture_data,
149     __illegal__, // glkify - z_erase_picture,
150     __illegal__, // glkify - z_set_margins,
151     z_save_undo,
152     z_restore_undo,
153     z_print_unicode,
154     z_check_unicode,
155     z_set_true_colour, /* spec 1.1 */
156     __illegal__,
157     __illegal__,
158     __illegal__, // glkify - z_move_window,
159     __illegal__, // glkify - z_window_size,
160     __illegal__, // glkify - z_window_style,
161     __illegal__, // glkify - z_get_wind_prop,
162     __illegal__, // glkify - z_scroll_window,
163     z_pop_stack,
164     __illegal__, // glkify - z_read_mouse,
165     __illegal__, // glkify - z_mouse_window,
166     z_push_stack,
167     __illegal__, // glkify - z_put_wind_prop,
168     z_print_form,
169     z_make_menu,
170     __illegal__, // glkify - z_picture_table
171     z_buffer_screen, /* spec 1.1 */
172 };
173
174
175 /*
176  * init_proc
177  *
178  * Initialize process variables.
179  *
180  */
181
182 void init_proc (void)
183 {
184     finished = 0;
185 } /* init_proc */
186
187
188 /*
189  * load_operand
190  *
191  * Load an operand, either a variable or a constant.
192  *
193  */
194
195 static void load_operand (zbyte type)
196 {
197     zword value;
198
199     if (type & 2) {                     /* variable */
200
201         zbyte variable;
202
203         CODE_BYTE (variable)
204
205         if (variable == 0)
206             value = *sp++;
207         else if (variable < 16)
208             value = *(fp - variable);
209         else {
210             zword addr = h_globals + 2 * (variable - 16);
211             LOW_WORD (addr, value)
212         }
213
214     } else if (type & 1) {              /* small constant */
215
216         zbyte bvalue;
217
218         CODE_BYTE (bvalue)
219         value = bvalue;
220
221     } else CODE_WORD (value)            /* large constant */
222
223     zargs[zargc++] = value;
224
225 }/* load_operand */
226
227 /*
228  * load_all_operands
229  *
230  * Given the operand specifier byte, load all (up to four) operands
231  * for a VAR or EXT opcode.
232  *
233  */
234
235 static void load_all_operands (zbyte specifier)
236 {
237     int i;
238
239     for (i = 6; i >= 0; i -= 2) {
240
241         zbyte type = (specifier >> i) & 0x03;
242
243         if (type == 3)
244             break;
245
246         load_operand (type);
247
248     }
249
250 }/* load_all_operands */
251
252 /*
253  * interpret
254  *
255  * Z-code interpreter main loop
256  *
257  */
258
259 void interpret (void)
260 {
261     do {
262
263         zbyte opcode;
264
265         CODE_BYTE (opcode)
266
267         zargc = 0;
268
269         if (opcode < 0x80) {                    /* 2OP opcodes */
270
271             load_operand ((zbyte) (opcode & 0x40) ? 2 : 1);
272             load_operand ((zbyte) (opcode & 0x20) ? 2 : 1);
273
274             var_opcodes[opcode & 0x1f] ();
275
276         } else if (opcode < 0xb0) {             /* 1OP opcodes */
277
278             load_operand ((zbyte) (opcode >> 4));
279
280             op1_opcodes[opcode & 0x0f] ();
281
282         } else if (opcode < 0xc0) {             /* 0OP opcodes */
283
284             op0_opcodes[opcode - 0xb0] ();
285
286         } else {                                /* VAR opcodes */
287
288             zbyte specifier1;
289             zbyte specifier2;
290
291             if (opcode == 0xec || opcode == 0xfa) {     /* opcodes 0xec */
292                 CODE_BYTE (specifier1)                  /* and 0xfa are */
293                 CODE_BYTE (specifier2)                  /* call opcodes */
294                 load_all_operands (specifier1);         /* with up to 8 */
295                 load_all_operands (specifier2);         /* arguments    */
296             } else {
297                 CODE_BYTE (specifier1)
298                 load_all_operands (specifier1);
299             }
300
301             var_opcodes[opcode - 0xc0] ();
302
303         }
304
305 #if defined(DJGPP) && defined(SOUND_SUPPORT)
306     if (end_of_sound_flag)
307         end_of_sound ();
308 #endif
309
310     } while (finished == 0);
311
312     finished--;
313
314 }/* interpret */
315
316 /*
317  * call
318  *
319  * Call a subroutine. Save PC and FP then load new PC and initialise
320  * new stack frame. Note that the caller may legally provide less or
321  * more arguments than the function actually has. The call type "ct"
322  * can be 0 (z_call_s), 1 (z_call_n) or 2 (direct call).
323  *
324  */
325
326 void call (zword routine, int argc, zword *args, int ct)
327 {
328     long pc;
329     zword value;
330     zbyte count;
331     int i;
332
333     if (sp - stack < 4)
334         runtime_error (ERR_STK_OVF);
335
336     GET_PC (pc)
337
338     *--sp = (zword) (pc >> 9);
339     *--sp = (zword) (pc & 0x1ff);
340     *--sp = (zword) (fp - stack - 1);
341     *--sp = (zword) (argc | (ct << (option_save_quetzal ? 12 : 8)));
342
343     fp = sp;
344     frame_count++;
345
346     /* Calculate byte address of routine */
347
348     if (h_version <= V3)
349         pc = (long) routine << 1;
350     else if (h_version <= V5)
351         pc = (long) routine << 2;
352     else if (h_version <= V7)
353         pc = ((long) routine << 2) + ((long) h_functions_offset << 3);
354     else if (h_version <= V8)
355         pc = (long) routine << 3;
356     else /* h_version == V9 */ {
357         long indirect = (long) routine << 2;
358         HIGH_LONG(indirect, pc);
359      }
360
361     if (pc >= story_size)
362         runtime_error (ERR_ILL_CALL_ADDR);
363
364     SET_PC (pc)
365
366     /* Initialise local variables */
367
368     CODE_BYTE (count)
369
370     if (count > 15)
371         runtime_error (ERR_CALL_NON_RTN);
372     if (sp - stack < count)
373         runtime_error (ERR_STK_OVF);
374
375     if (option_save_quetzal)
376         fp[0] |= (zword) count << 8;    /* Save local var count for Quetzal. */
377
378     value = 0;
379
380     for (i = 0; i < count; i++) {
381
382         if (h_version <= V4)            /* V1 to V4 games provide default */
383             CODE_WORD (value)           /* values for all local variables */
384
385         *--sp = (zword) ((argc-- > 0) ? args[i] : value);
386
387     }
388
389     /* Start main loop for direct calls */
390
391     if (ct == 2)
392         interpret ();
393
394 }/* call */
395
396 /*
397  * ret
398  *
399  * Return from the current subroutine and restore the previous stack
400  * frame. The result may be stored (0), thrown away (1) or pushed on
401  * the stack (2). In the latter case a direct call has been finished
402  * and we must exit the interpreter loop.
403  *
404  */
405
406 void ret (zword value)
407 {
408     long pc;
409     int ct;
410
411     if (sp > fp)
412         runtime_error (ERR_STK_UNDF);
413
414     sp = fp;
415
416     ct = *sp++ >> (option_save_quetzal ? 12 : 8);
417     frame_count--;
418     fp = stack + 1 + *sp++;
419     pc = *sp++;
420     pc = ((long) *sp++ << 9) | pc;
421
422     SET_PC (pc)
423
424     /* Handle resulting value */
425
426     if (ct == 0)
427         store (value);
428     if (ct == 2)
429         *--sp = value;
430
431     /* Stop main loop for direct calls */
432
433     if (ct == 2)
434         finished++;
435
436 }/* ret */
437
438 /*
439  * branch
440  *
441  * Take a jump after an instruction based on the flag, either true or
442  * false. The branch can be short or long; it is encoded in one or two
443  * bytes respectively. When bit 7 of the first byte is set, the jump
444  * takes place if the flag is true; otherwise it is taken if the flag
445  * is false. When bit 6 of the first byte is set, the branch is short;
446  * otherwise it is long. The offset occupies the bottom 6 bits of the
447  * first byte plus all the bits in the second byte for long branches.
448  * Uniquely, an offset of 0 means return false, and an offset of 1 is
449  * return true.
450  *
451  */
452
453 void branch (bool flag)
454 {
455     long pc;
456     zword offset;
457     zbyte specifier;
458     zbyte off1;
459     zbyte off2;
460
461     CODE_BYTE (specifier)
462
463     off1 = specifier & 0x3f;
464
465     if (!flag)
466         specifier ^= 0x80;
467
468     if (!(specifier & 0x40)) {          /* it's a long branch */
469
470         if (off1 & 0x20)                /* propagate sign bit */
471             off1 |= 0xc0;
472
473         CODE_BYTE (off2)
474
475         offset = (off1 << 8) | off2;
476
477     } else offset = off1;               /* it's a short branch */
478
479     if (specifier & 0x80) {
480
481         if (offset > 1) {               /* normal branch */
482
483             GET_PC (pc)
484             pc += (short) offset - 2;
485             SET_PC (pc)
486
487         } else ret (offset);            /* special case, return 0 or 1 */
488     }
489
490 }/* branch */
491
492 /*
493  * store
494  *
495  * Store an operand, either as a variable or pushed on the stack.
496  *
497  */
498
499 void store (zword value)
500 {
501     zbyte variable;
502
503     CODE_BYTE (variable)
504
505     if (variable == 0)
506         *--sp = value;
507     else if (variable < 16)
508         *(fp - variable) = value;
509     else {
510         zword addr = h_globals + 2 * (variable - 16);
511         SET_WORD (addr, value)
512     }
513
514 }/* store */
515
516 /*
517  * direct_call
518  *
519  * Call the interpreter loop directly. This is necessary when
520  *
521  * - a sound effect has been finished
522  * - a read instruction has timed out
523  * - a newline countdown has hit zero
524  *
525  * The interpreter returns the result value on the stack.
526  *
527  */
528
529 int direct_call (zword addr)
530 {
531     zword saved_zargs[8];
532     int saved_zargc;
533     int i;
534
535     /* Calls to address 0 return false */
536
537     if (addr == 0)
538         return 0;
539
540     /* Save operands and operand count */
541
542     for (i = 0; i < 8; i++)
543         saved_zargs[i] = zargs[i];
544
545     saved_zargc = zargc;
546
547     /* Call routine directly */
548
549     call (addr, 0, 0, 2);
550
551     /* Restore operands and operand count */
552
553     for (i = 0; i < 8; i++)
554         zargs[i] = saved_zargs[i];
555
556     zargc = saved_zargc;
557
558     /* Resulting value lies on top of the stack */
559
560     return (short) *sp++;
561
562 }/* direct_call */
563
564 /*
565  * __extended__
566  *
567  * Load and execute an extended opcode.
568  *
569  */
570
571 static void __extended__ (void)
572 {
573     zbyte opcode;
574     zbyte specifier;
575
576     CODE_BYTE (opcode)
577     CODE_BYTE (specifier)
578
579     load_all_operands (specifier);
580
581     if (opcode < 0x1e)                  /* extended opcodes from 0x1e on */
582         ext_opcodes[opcode] ();         /* are reserved for future spec' */
583
584 }/* __extended__ */
585
586 /*
587  * __illegal__
588  *
589  * Exit game because an unknown opcode has been hit.
590  *
591  */
592
593 static void __illegal__ (void)
594 {
595
596     runtime_error (ERR_ILL_OPCODE);
597
598 }/* __illegal__ */
599
600 /*
601  * z_catch, store the current stack frame for later use with z_throw.
602  *
603  *      no zargs used
604  *
605  */
606
607 void z_catch (void)
608 {
609
610     store (option_save_quetzal ? frame_count : (zword) (fp - stack));
611
612 }/* z_catch */
613
614 /*
615  * z_throw, go back to the given stack frame and return the given value.
616  *
617  *      zargs[0] = value to return
618  *      zargs[1] = stack frame
619  *
620  */
621
622 void z_throw (void)
623 {
624
625     if (option_save_quetzal) {
626         if (zargs[1] > frame_count)
627             runtime_error (ERR_BAD_FRAME);
628
629         /* Unwind the stack a frame at a time. */
630         for (; frame_count > zargs[1]; --frame_count)
631             fp = stack + 1 + fp[1];
632     } else {
633         if (zargs[1] > STACK_SIZE)
634             runtime_error (ERR_BAD_FRAME);
635
636         fp = stack + zargs[1];
637     }
638
639     ret (zargs[0]);
640
641 }/* z_throw */
642
643 /*
644  * z_call_n, call a subroutine and discard its result.
645  *
646  *      zargs[0] = packed address of subroutine
647  *      zargs[1] = first argument (optional)
648  *      ...
649  *      zargs[7] = seventh argument (optional)
650  *
651  */
652
653 void z_call_n (void)
654 {
655
656     if (zargs[0] != 0)
657         call (zargs[0], zargc - 1, zargs + 1, 1);
658
659 }/* z_call_n */
660
661 /*
662  * z_call_s, call a subroutine and store its result.
663  *
664  *      zargs[0] = packed address of subroutine
665  *      zargs[1] = first argument (optional)
666  *      ...
667  *      zargs[7] = seventh argument (optional)
668  *
669  */
670
671 void z_call_s (void)
672 {
673
674     if (zargs[0] != 0)
675         call (zargs[0], zargc - 1, zargs + 1, 0);
676     else
677         store (0);
678
679 }/* z_call_s */
680
681 /*
682  * z_check_arg_count, branch if subroutine was called with >= n arg's.
683  *
684  *      zargs[0] = number of arguments
685  *
686  */
687
688 void z_check_arg_count (void)
689 {
690
691     if (fp == stack + STACK_SIZE)
692         branch (zargs[0] == 0);
693     else
694         branch (zargs[0] <= (*fp & 0xff));
695
696 }/* z_check_arg_count */
697
698 /*
699  * z_jump, jump unconditionally to the given address.
700  *
701  *      zargs[0] = PC relative address
702  *
703  */
704
705 void z_jump (void)
706 {
707     long pc;
708
709     GET_PC (pc)
710
711     pc += (short) zargs[0] - 2;
712
713     if (pc >= story_size)
714         runtime_error (ERR_ILL_JUMP_ADDR);
715
716     SET_PC (pc)
717
718 }/* z_jump */
719
720 /*
721  * z_nop, no operation.
722  *
723  *      no zargs used
724  *
725  */
726
727 void z_nop (void)
728 {
729
730     /* Do nothing */
731
732 }/* z_nop */
733
734 /*
735  * z_quit, stop game and exit interpreter.
736  *
737  *      no zargs used
738  *
739  */
740
741 void z_quit (void)
742 {
743
744     finished = 9999;
745
746 }/* z_quit */
747
748 /*
749  * z_ret, return from a subroutine with the given value.
750  *
751  *      zargs[0] = value to return
752  *
753  */
754
755 void z_ret (void)
756 {
757
758     ret (zargs[0]);
759
760 }/* z_ret */
761
762 /*
763  * z_ret_popped, return from a subroutine with a value popped off the stack.
764  *
765  *      no zargs used
766  *
767  */
768
769 void z_ret_popped (void)
770 {
771
772     ret (*sp++);
773
774 }/* z_ret_popped */
775
776 /*
777  * z_rfalse, return from a subroutine with false (0).
778  *
779  *      no zargs used
780  *
781  */
782
783 void z_rfalse (void)
784 {
785
786     ret (0);
787
788 }/* z_rfalse */
789
790 /*
791  * z_rtrue, return from a subroutine with true (1).
792  *
793  *      no zargs used
794  *
795  */
796
797 void z_rtrue (void)
798 {
799
800     ret (1);
801
802 }/* z_rtrue */