Use g_cond_wait_until() instead of g_cond_timed_wait()
[projects/chimara/chimara.git] / interpreters / frotz / quetzal.c
1 /* quetzal.c  - Saving and restoring of Quetzal files.
2  *      Written by Martin Frost <mdf@doc.ic.ac.uk>
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 #include "glk.h"
23 #include "glkio.h"
24
25 #define get_c fgetc
26 #define put_c fputc
27
28 typedef unsigned long zlong;
29
30 /*
31  * This is used only by save_quetzal. It probably should be allocated
32  * dynamically rather than statically.
33  */
34
35 static zword frames[STACK_SIZE/4+1];
36
37 /*
38  * ID types.
39  */
40
41 #define makeid(a,b,c,d) ((zlong) (((a)<<24) | ((b)<<16) | ((c)<<8) | (d)))
42
43 #define ID_FORM makeid ('F','O','R','M')
44 #define ID_IFZS makeid ('I','F','Z','S')
45 #define ID_IFhd makeid ('I','F','h','d')
46 #define ID_UMem makeid ('U','M','e','m')
47 #define ID_CMem makeid ('C','M','e','m')
48 #define ID_Stks makeid ('S','t','k','s')
49 #define ID_ANNO makeid ('A','N','N','O')
50
51 /*
52  * Various parsing states within restoration.
53  */
54
55 #define GOT_HEADER      0x01
56 #define GOT_STACK       0x02
57 #define GOT_MEMORY      0x04
58 #define GOT_NONE        0x00
59 #define GOT_ALL         0x07
60 #define GOT_ERROR       0x80
61
62 /*
63  * Macros used to write the files.
64  */
65
66 #define write_byte(fp,b) (put_c (b, fp) != EOF)
67 #define write_bytx(fp,b) write_byte (fp, (b) & 0xFF)
68 #define write_word(fp,w) \
69     (write_bytx (fp, (w) >>  8) && write_bytx (fp, (w)))
70 #define write_long(fp,l) \
71     (write_bytx (fp, (l) >> 24) && write_bytx (fp, (l) >> 16) && \
72      write_bytx (fp, (l) >>  8) && write_bytx (fp, (l)))
73 #define write_chnk(fp,id,len) \
74     (write_long (fp, (id))      && write_long (fp, (len)))
75 #define write_run(fp,run) \
76     (write_byte (fp, 0)         && write_byte (fp, (run)))
77
78 /* Read one word from file; return TRUE if OK. */
79 static bool read_word (FILE *f, zword *result)
80 {
81     int a, b;
82
83     if ((a = get_c (f)) == EOF) return FALSE;
84     if ((b = get_c (f)) == EOF) return FALSE;
85
86     *result = ((zword) a << 8) | (zword) b;
87     return TRUE;
88 }
89
90 /* Read one long from file; return TRUE if OK. */
91 static bool read_long (FILE *f, zlong *result)
92 {
93     int a, b, c, d;
94
95     if ((a = get_c (f)) == EOF) return FALSE;
96     if ((b = get_c (f)) == EOF) return FALSE;
97     if ((c = get_c (f)) == EOF) return FALSE;
98     if ((d = get_c (f)) == EOF) return FALSE;
99
100     *result = ((zlong) a << 24) | ((zlong) b << 16) |
101               ((zlong) c <<  8) |  (zlong) d;
102     return TRUE;
103 }
104
105 /*
106  * Restore a saved game using Quetzal format. Return 2 if OK, 0 if an error
107  * occurred before any damage was done, -1 on a fatal error.
108  */
109
110 zword restore_quetzal (FILE *svf, FILE *stf, int blorb_ofs)
111 {
112     zlong ifzslen, currlen, tmpl;
113     zlong pc;
114     zword i, tmpw;
115     zword fatal = 0;    /* Set to -1 when errors must be fatal. */
116     zbyte skip, progress = GOT_NONE;
117     int x, y;
118
119     /* Check it's really an `IFZS' file. */
120     if (!read_long (svf, &tmpl)
121         || !read_long (svf, &ifzslen)
122         || !read_long (svf, &currlen))                          return 0;
123     if (tmpl != ID_FORM || currlen != ID_IFZS)
124     {
125         print_string ("This is not a saved game file!\n");
126         return 0;
127     }
128     if ((ifzslen & 1) || ifzslen<4) /* Sanity checks. */        return 0;
129     ifzslen -= 4;
130
131     /* Read each chunk and process it. */
132     while (ifzslen > 0)
133     {
134         /* Read chunk header. */
135         if (ifzslen < 8) /* Couldn't contain a chunk. */        return 0;
136         if (!read_long (svf, &tmpl)
137             || !read_long (svf, &currlen))                      return 0;
138         ifzslen -= 8;   /* Reduce remaining by size of header. */
139
140         /* Handle chunk body. */
141         if (ifzslen < currlen) /* Chunk goes past EOF?! */      return 0;
142         skip = currlen & 1;
143         ifzslen -= currlen + (zlong) skip;
144
145         switch (tmpl)
146         {
147             /* `IFhd' header chunk; must be first in file. */
148             case ID_IFhd:
149                 if (progress & GOT_HEADER)
150                 {
151                     print_string ("Save file has two IFZS chunks!\n");
152                     return fatal;
153                 }
154                 progress |= GOT_HEADER;
155                 if (currlen < 13
156                     || !read_word (svf, &tmpw))                 return fatal;
157                 if (tmpw != h_release)
158                     progress = GOT_ERROR;
159
160                 for (i=H_SERIAL; i<H_SERIAL+6; ++i)
161                 {
162                     if ((x = get_c (svf)) == EOF)               return fatal;
163                     if (x != zmp[i])
164                         progress = GOT_ERROR;
165                 }
166
167                 if (!read_word (svf, &tmpw))                    return fatal;
168                 if (tmpw != h_checksum)
169                     progress = GOT_ERROR;
170
171                 if (progress & GOT_ERROR)
172                 {
173                     print_string ("File was not saved from this story!\n");
174                     return fatal;
175                 }
176                 if ((x = get_c (svf)) == EOF)                   return fatal;
177                 pc = (zlong) x << 16;
178                 if ((x = get_c (svf)) == EOF)                   return fatal;
179                 pc |= (zlong) x << 8;
180                 if ((x = get_c (svf)) == EOF)                   return fatal;
181                 pc |= (zlong) x;
182                 fatal = -1;     /* Setting PC means errors must be fatal. */
183                 SET_PC (pc);
184
185                 for (i=13; i<currlen; ++i)
186                     (void) get_c (svf); /* Skip rest of chunk. */
187                 break;
188             /* `Stks' stacks chunk; restoring this is quite complex. ;) */
189             case ID_Stks:
190                 if (progress & GOT_STACK)
191                 {
192                     print_string ("File contains two stack chunks!\n");
193                     break;
194                 }
195                 progress |= GOT_STACK;
196
197                 fatal = -1;     /* Setting SP means errors must be fatal. */
198                 sp = stack + STACK_SIZE;
199
200                 /*
201                  * All versions other than V6 may use evaluation stack outside
202                  * any function context. As a result a faked function context
203                  * will be present in the file here. We skip this context, but
204                  * load the associated stack onto the stack proper...
205                  */
206                 if (h_version != V6)
207                 {
208                     if (currlen < 8)                            return fatal;
209                     for (i=0; i<6; ++i)
210                         if (get_c (svf) != 0)                   return fatal;
211                     if (!read_word (svf, &tmpw))                return fatal;
212                     if (tmpw > STACK_SIZE)
213                     {
214                         print_string ("Save-file has too much stack (and I can't cope).\n");
215                         return fatal;
216                     }
217                     currlen -= 8;
218                     if (currlen < tmpw*2)                       return fatal;
219                     for (i=0; i<tmpw; ++i)
220                         if (!read_word (svf, --sp))             return fatal;
221                     currlen -= tmpw*2;
222                 }
223
224                 /* We now proceed to load the main block of stack frames. */
225                 for (fp = stack+STACK_SIZE, frame_count = 0;
226                      currlen > 0;
227                      currlen -= 8, ++frame_count)
228                 {
229                     if (currlen < 8)                            return fatal;
230                     if (sp - stack < 4) /* No space for frame. */
231                     {
232                         print_string ("Save-file has too much stack (and I can't cope).\n");
233                         return fatal;
234                     }
235
236                     /* Read PC, procedure flag and formal param count. */
237                     if (!read_long (svf, &tmpl))                return fatal;
238                     y = (int) (tmpl & 0x0F);    /* Number of formals. */
239                     tmpw = y << 8;
240
241                     /* Read result variable. */
242                     if ((x = get_c (svf)) == EOF)               return fatal;
243
244                     /* Check the procedure flag... */
245                     if (tmpl & 0x10)
246                     {
247                         tmpw |= 0x1000; /* It's a procedure. */
248                         tmpl >>= 8;     /* Shift to get PC value. */
249                     }
250                     else
251                     {
252                         /* Functions have type 0, so no need to or anything. */
253                         tmpl >>= 8;     /* Shift to get PC value. */
254                         --tmpl;         /* Point at result byte. */
255                         /* Sanity check on result variable... */
256                         if (zmp[tmpl] != (zbyte) x)
257                         {
258                             print_string ("Save-file has wrong variable number on stack (possibly wrong game version?)\n");
259                             return fatal;
260                         }
261                     }
262                     *--sp = (zword) (tmpl >> 9);        /* High part of PC */
263                     *--sp = (zword) (tmpl & 0x1FF);     /* Low part of PC */
264                     *--sp = (zword) (fp - stack - 1);   /* FP */
265
266                     /* Read and process argument mask. */
267                     if ((x = get_c (svf)) == EOF)               return fatal;
268                     ++x;        /* Should now be a power of 2 */
269                     for (i=0; i<8; ++i)
270                         if (x & (1<<i))
271                             break;
272                     if (x ^ (1<<i))     /* Not a power of 2 */
273                     {
274                         print_string ("Save-file uses incomplete argument lists (which I can't handle)\n");
275                         return fatal;
276                     }
277                     *--sp = tmpw | i;
278                     fp = sp;    /* FP for next frame. */
279
280                     /* Read amount of eval stack used. */
281                     if (!read_word (svf, &tmpw))                return fatal;
282
283                     tmpw += y;  /* Amount of stack + number of locals. */
284                     if (sp - stack <= tmpw)
285                     {
286                         print_string ("Save-file has too much stack (and I can't cope).\n");
287                         return fatal;
288                     }
289                     if (currlen < tmpw*2)                       return fatal;
290                     for (i=0; i<tmpw; ++i)
291                         if (!read_word (svf, --sp))             return fatal;
292                     currlen -= tmpw*2;
293                 }
294                 /* End of `Stks' processing... */
295                 break;
296             /* Any more special chunk types must go in HERE or ABOVE. */
297             /* `CMem' compressed memory chunk; uncompress it. */
298             case ID_CMem:
299                 if (!(progress & GOT_MEMORY))   /* Don't complain if two. */
300                 {
301                     (void) fseek (stf, blorb_ofs, SEEK_SET);
302                     i=0;        /* Bytes written to data area. */
303                     for (; currlen > 0; --currlen)
304                     {
305                         if ((x = get_c (svf)) == EOF)           return fatal;
306                         if (x == 0)     /* Start run. */
307                         {
308                             /* Check for bogus run. */
309                             if (currlen < 2)
310                             {
311                                 print_string ("File contains bogus `CMem' chunk.\n");
312                                 for (; currlen > 0; --currlen)
313                                     (void) get_c (svf); /* Skip rest. */
314                                 currlen = 1;
315                                 i = 0xFFFF;
316                                 break; /* Keep going; may be a `UMem' too. */
317                             }
318                             /* Copy story file to memory during the run. */
319                             --currlen;
320                             if ((x = get_c (svf)) == EOF)       return fatal;
321                             for (; x >= 0 && i<h_dynamic_size; --x, ++i)
322                                 if ((y = get_c (stf)) == EOF)   return fatal;
323                                 else
324                                     zmp[i] = (zbyte) y;
325                         }
326                         else    /* Not a run. */
327                         {
328                             if ((y = get_c (stf)) == EOF)       return fatal;
329                             zmp[i] = (zbyte) (x ^ y);
330                             ++i;
331                         }
332                         /* Make sure we don't load too much. */
333                         if (i > h_dynamic_size)
334                         {
335                             print_string ("warning: `CMem' chunk too long!\n");
336                             for (; currlen > 1; --currlen)
337                                 (void) get_c (svf);     /* Skip rest. */
338                             break;      /* Keep going; there may be a `UMem' too. */
339                         }
340                     }
341                     /* If chunk is short, assume a run. */
342                     for (; i<h_dynamic_size; ++i)
343                         if ((y = get_c (stf)) == EOF)           return fatal;
344                         else
345                             zmp[i] = (zbyte) y;
346                     if (currlen == 0)
347                         progress |= GOT_MEMORY; /* Only if succeeded. */
348                     break;
349             }
350                 /* Fall right thru (to default) if already GOT_MEMORY */
351             /* `UMem' uncompressed memory chunk; load it. */
352             case ID_UMem:
353                 if (!(progress & GOT_MEMORY))   /* Don't complain if two. */
354                 {
355                     /* Must be exactly the right size. */
356                     if (currlen == h_dynamic_size)
357                     {
358                         if (fread (zmp, currlen, 1, svf) == 1)
359                         {
360                             progress |= GOT_MEMORY;     /* Only on success. */
361                             break;
362                         }
363                     }
364                     else
365                         print_string ("`UMem' chunk wrong size!\n");
366                     /* Fall into default action (skip chunk) on errors. */
367                 }
368                 /* Fall thru (to default) if already GOT_MEMORY */
369             /* Unrecognised chunk type; skip it. */
370             default:
371                 (void) fseek (svf, currlen, SEEK_CUR);  /* Skip chunk. */
372                 break;
373         }
374         if (skip)
375             (void) get_c (svf); /* Skip pad byte. */
376     }
377
378     /*
379      * We've reached the end of the file. For the restoration to have been a
380      * success, we must have had one of each of the required chunks.
381      */
382     if (!(progress & GOT_HEADER))
383         print_string ("error: no valid header (`IFhd') chunk in file.\n");
384     if (!(progress & GOT_STACK))
385         print_string ("error: no valid stack (`Stks') chunk in file.\n");
386     if (!(progress & GOT_MEMORY))
387         print_string ("error: no valid memory (`CMem' or `UMem') chunk in file.\n");
388
389     return (progress == GOT_ALL ? 2 : fatal);
390 }
391
392 /*
393  * Save a game using Quetzal format. Return 1 if OK, 0 if failed.
394  */
395
396 zword save_quetzal (FILE *svf, FILE *stf, int blorb_ofs)
397 {
398     zlong ifzslen = 0, cmemlen = 0, stkslen = 0;
399     zlong pc;
400     zword i, j, n;
401     zword nvars, nargs, nstk, *p;
402     zbyte var;
403     long cmempos, stkspos;
404     int c;
405
406     /* Write `IFZS' header. */
407     if (!write_chnk (svf, ID_FORM, 0))                  return 0;
408     if (!write_long (svf, ID_IFZS))                     return 0;
409
410     /* Write `IFhd' chunk. */
411     GET_PC (pc);
412     if (!write_chnk (svf, ID_IFhd, 13))                 return 0;
413     if (!write_word (svf, h_release))                   return 0;
414     for (i=H_SERIAL; i<H_SERIAL+6; ++i)
415         if (!write_byte (svf, zmp[i]))                  return 0;
416     if (!write_word (svf, h_checksum))                  return 0;
417     if (!write_long (svf, pc << 8)) /* Includes pad. */ return 0;
418
419     /* Write `CMem' chunk. */
420     if ((cmempos = ftell (svf)) < 0)                    return 0;
421     if (!write_chnk (svf, ID_CMem, 0))                  return 0;
422     (void) fseek (stf, blorb_ofs, SEEK_SET);
423     /* j holds current run length. */
424     for (i=0, j=0, cmemlen=0; i < h_dynamic_size; ++i)
425     {
426         if ((c = get_c (stf)) == EOF)                   return 0;
427         c ^= (int) zmp[i];
428         if (c == 0)
429             ++j;        /* It's a run of equal bytes. */
430         else
431         {
432             /* Write out any run there may be. */
433             if (j > 0)
434             {
435                 for (; j > 0x100; j -= 0x100)
436                 {
437                     if (!write_run (svf, 0xFF))         return 0;
438                     cmemlen += 2;
439                 }
440                 if (!write_run (svf, j-1))              return 0;
441                 cmemlen += 2;
442                 j = 0;
443             }
444             /* Any runs are now written. Write this (nonzero) byte. */
445             if (!write_byte (svf, (zbyte) c))           return 0;
446             ++cmemlen;
447         }
448     }
449     /*
450      * Reached end of dynamic memory. We ignore any unwritten run there may be
451      * at this point.
452      */
453     if (cmemlen & 1)    /* Chunk length must be even. */
454         if (!write_byte (svf, 0))                       return 0;
455
456     /* Write `Stks' chunk. You are not expected to understand this. ;) */
457     if ((stkspos = ftell (svf)) < 0)                    return 0;
458     if (!write_chnk (svf, ID_Stks, 0))                  return 0;
459
460     /*
461      * We construct a list of frame indices, most recent first, in `frames'.
462      * These indices are the offsets into the `stack' array of the word before
463      * the first word pushed in each frame.
464      */
465     frames[0] = sp - stack;     /* The frame we'd get by doing a call now. */
466     for (i = fp - stack + 4, n=0; i < STACK_SIZE+4; i = stack[i-3] + 5)
467         frames[++n] = i;
468
469     /*
470      * All versions other than V6 can use evaluation stack outside a function
471      * context. We write a faked stack frame (most fields zero) to cater for
472      * this.
473      */
474     if (h_version != V6)
475     {
476         for (i=0; i<6; ++i)
477             if (!write_byte (svf, 0))                   return 0;
478         nstk = STACK_SIZE - frames[n];
479         if (!write_word (svf, nstk))                    return 0;
480         for (j=STACK_SIZE-1; j >= frames[n]; --j)
481             if (!write_word (svf, stack[j]))            return 0;
482         stkslen = 8 + 2*nstk;
483     }
484
485     /* Write out the rest of the stack frames. */
486     for (i=n; i>0; --i)
487     {
488         p = stack + frames[i] - 4;      /* Points to call frame. */
489         nvars = (p[0] & 0x0F00) >> 8;
490         nargs =  p[0] & 0x00FF;
491         nstk  =  frames[i] - frames[i-1] - nvars - 4;
492         pc    =  ((zlong) p[3] << 9) | p[2];
493
494         switch (p[0] & 0xF000)  /* Check type of call. */
495         {
496             case 0x0000:        /* Function. */
497                 var = zmp[pc];
498                 pc = ((pc + 1) << 8) | nvars;
499                 break;
500             case 0x1000:        /* Procedure. */
501                 var = 0;
502                 pc = (pc << 8) | 0x10 | nvars;  /* Set procedure flag. */
503                 break;
504             /* case 0x2000: */
505             default:
506                 runtime_error (ERR_SAVE_IN_INTER);
507                 return 0;
508         }
509         if (nargs != 0)
510             nargs = (1 << nargs) - 1;   /* Make args into bitmap. */
511
512         /* Write the main part of the frame... */
513         if (!write_long (svf, pc)
514             || !write_byte (svf, var)
515             || !write_byte (svf, nargs)
516             || !write_word (svf, nstk))                 return 0;
517
518         /* Write the variables and eval stack. */
519         for (j=0, --p; j<nvars+nstk; ++j, --p)
520             if (!write_word (svf, *p))                  return 0;
521
522         /* Calculate length written thus far. */
523         stkslen += 8 + 2 * (nvars + nstk);
524     }
525
526     /* Fill in variable chunk lengths. */
527     ifzslen = 3*8 + 4 + 14 + cmemlen + stkslen;
528     if (cmemlen & 1)
529         ++ifzslen;
530     (void) fseek (svf,         4, SEEK_SET);
531     if (!write_long (svf, ifzslen))                     return 0;
532     (void) fseek (svf, cmempos+4, SEEK_SET);
533     if (!write_long (svf, cmemlen))                     return 0;
534     (void) fseek (svf, stkspos+4, SEEK_SET);
535     if (!write_long (svf, stkslen))                     return 0;
536
537     /* After all that, still nothing went wrong! */
538     return 1;
539 }