Implemented garglk_set_program_name(), garglk_set_program_info(), garglk_set_story_name()
[rodin/chimara.git] / interpreters / frotz / files.c
1 /* files.c - Transscription, recording and playback
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include "frotz.h"
22 #include "glk.h"
23 #include "glkio.h"
24
25 extern void set_more_prompts (bool);
26
27 extern bool is_terminator (zchar);
28
29 extern bool read_yes_or_no (const char *);
30
31 static int script_width = 0;
32
33 static FILE *sfp = NULL;
34 static FILE *rfp = NULL;
35 static FILE *pfp = NULL;
36
37 /*
38  * script_open
39  *
40  * Open the transscript file. 'AMFV' makes this more complicated as it
41  * turns transscription on/off several times to exclude some text from
42  * the transscription file. This wasn't a problem for the original V4
43  * interpreters which always sent transscription to the printer, but it
44  * means a problem to modern interpreters that offer to open a new file
45  * every time transscription is turned on. Our solution is to append to
46  * the old transscription file in V1 to V4, and to ask for a new file
47  * name in V5+.
48  *
49  * Alas, we cannot do this, since glk cannot give us the filename
50  * to reopen it again, and I dont want to mess with filerefs here.
51  *
52  */
53
54 void script_open (void)
55 {
56         static bool script_valid = FALSE;
57
58         h_flags &= ~SCRIPTING_FLAG;
59
60 #if 0
61         if (h_version >= V5 || !script_valid) {
62                 if (!os_read_file_name (new_name, script_name, FILE_SCRIPT))
63                         goto done;
64         }
65
66         /* Opening in "at" mode doesn't work for script_erase_input... */
67
68         if ((sfp = fopen (sfp = fopen (script_name, "r+t")) != NULL || (sfp = fopen (script_name, "w+t")) != NULL) {
69
70 #endif
71
72         if ((sfp = frotzopenprompt(FILE_SCRIPT)) != NULL)
73         {
74                 fseek (sfp, 0, SEEK_END);
75
76                 h_flags |= SCRIPTING_FLAG;
77
78                 script_valid = TRUE;
79                 ostream_script = TRUE;
80
81                 script_width = 0;
82
83         } else print_string ("Cannot open file\n");
84
85 /* done: */
86
87         SET_WORD (H_FLAGS, h_flags)
88
89 }/* script_open */
90
91 /*
92  * script_close
93  *
94  * Stop transscription.
95  *
96  */
97
98 void script_close (void)
99 {
100
101         h_flags &= ~SCRIPTING_FLAG;
102         SET_WORD (H_FLAGS, h_flags)
103
104                 fclose (sfp); ostream_script = FALSE;
105
106 }/* script_close */
107
108 /*
109  * script_new_line
110  *
111  * Write a newline to the transscript file.
112  *
113  */
114
115 void script_new_line (void)
116 {
117
118         if (fputc ('\n', sfp) == EOF)
119                 script_close ();
120
121         script_width = 0;
122
123 }/* script_new_line */
124
125 /*
126  * script_char
127  *
128  * Write a single character to the transscript file.
129  *
130  */
131
132 void script_char (zchar c)
133 {
134
135         if (c == ZC_INDENT && script_width != 0)
136                 c = ' ';
137
138         if (c == ZC_INDENT)
139         { script_char (' '); script_char (' '); script_char (' '); return; }
140         if (c == ZC_GAP)
141         { script_char (' '); script_char (' '); return; }
142
143         fputc (c, sfp); script_width++;
144
145 }/* script_char */
146
147 /*
148  * script_word
149  *
150  * Write a string to the transscript file.
151  *
152  */
153
154 void script_word (const zchar *s)
155 {
156         int width;
157         int i;
158
159         if (*s == ZC_INDENT && script_width != 0)
160                 script_char (*s++);
161
162         for (i = 0, width = 0; s[i] != 0; i++)
163
164                 if (s[i] == ZC_NEW_STYLE || s[i] == ZC_NEW_FONT)
165                         i++;
166                 else if (s[i] == ZC_GAP)
167                         width += 3;
168                 else if (s[i] == ZC_INDENT)
169                         width += 2;
170                 else
171                         width += 1;
172
173         if (f_setup.script_cols != 0 && script_width + width > f_setup.script_cols) {
174
175                 if (*s == ' ' || *s == ZC_INDENT || *s == ZC_GAP)
176                         s++;
177
178                 script_new_line ();
179
180         }
181
182         for (i = 0; s[i] != 0; i++)
183
184                 if (s[i] == ZC_NEW_FONT || s[i] == ZC_NEW_STYLE)
185                         i++;
186                 else
187                         script_char (s[i]);
188
189 }/* script_word */
190
191 /*
192  * script_write_input
193  *
194  * Send an input line to the transscript file.
195  *
196  */
197
198 void script_write_input (const zchar *buf, zchar key)
199 {
200         int width;
201         int i;
202
203         for (i = 0, width = 0; buf[i] != 0; i++)
204                 width++;
205
206         if (f_setup.script_cols != 0 && script_width + width > f_setup.script_cols)
207                 script_new_line ();
208
209         for (i = 0; buf[i] != 0; i++)
210                 script_char (buf[i]);
211
212         if (key == ZC_RETURN)
213                 script_new_line ();
214
215 }/* script_write_input */
216
217 /*
218  * script_erase_input
219  *
220  * Remove an input line from the transscript file.
221  *
222  */
223
224 void script_erase_input (const zchar *buf)
225 {
226         int width;
227         int i;
228
229         for (i = 0, width = 0; buf[i] != 0; i++)
230                 width++;
231
232         fseek (sfp, -width, SEEK_CUR); script_width -= width;
233
234 }/* script_erase_input */
235
236 /*
237  * script_mssg_on
238  *
239  * Start sending a "debugging" message to the transscript file.
240  *
241  */
242
243 void script_mssg_on (void)
244 {
245
246         if (script_width != 0)
247                 script_new_line ();
248
249         script_char (ZC_INDENT);
250
251 }/* script_mssg_on */
252
253 /*
254  * script_mssg_off
255  *
256  * Stop writing a "debugging" message.
257  *
258  */
259
260 void script_mssg_off (void)
261 {
262
263         script_new_line ();
264
265 }/* script_mssg_off */
266
267 /*
268  * record_open
269  *
270  * Open a file to record the player's input.
271  *
272  */
273
274 void record_open (void)
275 {
276         if ((rfp = frotzopenprompt(FILE_RECORD)) != NULL)
277                 ostream_record = TRUE;
278         else
279                 print_string ("Cannot open file\n");
280 }
281
282 /*
283  * record_close
284  *
285  * Stop recording the player's input.
286  *
287  */
288
289 void record_close (void)
290 {
291
292         fclose (rfp); ostream_record = FALSE;
293
294 }/* record_close */
295
296 /*
297  * record_code
298  *
299  * Helper function for record_char.
300  *
301  */
302
303 static void record_code (int c, bool force_encoding)
304 {
305
306         if (force_encoding || c == '[' || c < 0x20 || c > 0x7e) {
307
308                 int i;
309
310                 fputc ('[', rfp);
311
312                 for (i = 10000; i != 0; i /= 10)
313                         if (c >= i || i == 1)
314                                 fputc ('0' + (c / i) % 10, rfp);
315
316                 fputc (']', rfp);
317
318         } else fputc (c, rfp);
319
320 }/* record_code */
321
322 /*
323  * record_char
324  *
325  * Write a character to the command file.
326  *
327  */
328
329 static void record_char (zchar c)
330 {
331
332         if (c != ZC_RETURN) {
333                 if (c < ZC_HKEY_MIN || c > ZC_HKEY_MAX) {
334                         record_code (translate_to_zscii (c), FALSE);
335                         if (c == ZC_SINGLE_CLICK || c == ZC_DOUBLE_CLICK) {
336                                 record_code (mouse_x, TRUE);
337                                 record_code (mouse_y, TRUE);
338                         }
339                 } else record_code (1000 + c - ZC_HKEY_MIN, TRUE);
340         }
341
342 }/* record_char */
343
344 /*
345  * record_write_key
346  *
347  * Copy a keystroke to the command file.
348  *
349  */
350
351 void record_write_key (zchar key)
352 {
353
354         record_char (key);
355
356         if (fputc ('\n', rfp) == EOF)
357                 record_close ();
358
359 }/* record_write_key */
360
361 /*
362  * record_write_input
363  *
364  * Copy a line of input to a command file.
365  *
366  */
367
368 void record_write_input (const zchar *buf, zchar key)
369 {
370         zchar c;
371
372         while ((c = *buf++) != 0)
373                 record_char (c);
374
375         record_char (key);
376
377         if (fputc ('\n', rfp) == EOF)
378                 record_close ();
379
380 }/* record_write_input */
381
382 /*
383  * replay_open
384  *
385  * Open a file of commands for playback.
386  *
387  */
388
389 void replay_open (void)
390 {
391         if ((pfp = frotzopenprompt(FILE_PLAYBACK)) != NULL)
392                 istream_replay = TRUE;
393         else
394                 print_string ("Cannot open file\n");
395 }
396
397 /*
398  * replay_close
399  *
400  * Stop playback of commands.
401  *
402  */
403
404 void replay_close (void)
405 {
406         fclose (pfp); istream_replay = FALSE;
407 }
408
409 /*
410  * replay_code
411  *
412  * Helper function for replay_key and replay_line.
413  *
414  */
415
416 static int replay_code (void)
417 {
418         int c;
419
420         if ((c = fgetc (pfp)) == '[') {
421
422                 int c2;
423
424                 c = 0;
425
426                 while ((c2 = fgetc (pfp)) != EOF && c2 >= '0' && c2 <= '9')
427                         c = 10 * c + c2 - '0';
428
429                 return (c2 == ']') ? c : EOF;
430
431         } else return c;
432
433 }/* replay_code */
434
435 /*
436  * replay_char
437  *
438  * Read a character from the command file.
439  *
440  */
441
442 static zchar replay_char (void)
443 {
444         int c;
445
446         if ((c = replay_code ()) != EOF) {
447
448                 if (c != '\n') {
449
450                         if (c < 1000) {
451
452                                 c = translate_from_zscii (c);
453
454                                 if (c == ZC_SINGLE_CLICK || c == ZC_DOUBLE_CLICK) {
455                                         mouse_x = replay_code ();
456                                         mouse_y = replay_code ();
457                                 }
458
459                                 return c;
460
461                         } else return ZC_HKEY_MIN + c - 1000;
462                 }
463
464                 ungetc ('\n', pfp);
465
466                 return ZC_RETURN;
467
468         } else return ZC_BAD;
469
470 }/* replay_char */
471
472 /*
473  * replay_read_key
474  *
475  * Read a keystroke from a command file.
476  *
477  */
478
479 zchar replay_read_key (void)
480 {
481         zchar key;
482
483         key = replay_char ();
484
485         if (fgetc (pfp) != '\n') {
486
487                 replay_close ();
488                 return ZC_BAD;
489
490         } else return key;
491
492 }/* replay_read_key */
493
494 /*
495  * replay_read_input
496  *
497  * Read a line of input from a command file.
498  *
499  */
500
501 zchar replay_read_input (zchar *buf)
502 {
503         zchar c;
504
505         for (;;) {
506
507                 c = replay_char ();
508
509                 if (c == ZC_BAD || is_terminator (c))
510                         break;
511
512                 *buf++ = c;
513
514         }
515
516         *buf = 0;
517
518         if (fgetc (pfp) != '\n') {
519
520                 replay_close ();
521                 return ZC_BAD;
522
523         } else return c;
524
525 }/* replay_read_input */