Source:NetHack 3.6.4/src/save.c

From NetHackWiki
Jump to navigation Jump to search

Below is the full text to save.c from the source code of NetHack 3.6.4. To link to a particular line, write [[Source:NetHack 3.6.4/src/save.c#line12]], for example.

The NetHack General Public License applies to screenshots, source code and other content from NetHack.

This content was modified from the original NetHack source code distribution (by splitting up NetHack content between wiki pages, and possibly further editing). See the page history for a list of who changed it, and on what dates.

1. /* NetHack 3.6	save.c	$NHDT-Date: 1559994625 2019/06/08 11:50:25 $  $NHDT-Branch: NetHack-3.6 $:$NHDT-Revision: 1.121 $ */
2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
3. /*-Copyright (c) Michael Allison, 2009. */
4. /* NetHack may be freely redistributed.  See license for details. */
5. 
6. #include "hack.h"
7. #include "lev.h"
8. 
9. #ifndef NO_SIGNAL
10. #include <signal.h>
11. #endif
12. #if !defined(LSC) && !defined(O_WRONLY) && !defined(AZTEC_C)
13. #include <fcntl.h>
14. #endif
15. 
16. #ifdef MFLOPPY
17. long bytes_counted;
18. static int count_only;
19. #endif
20. 
21. #ifdef MICRO
22. int dotcnt, dotrow; /* also used in restore */
23. #endif
24. 
25. STATIC_DCL void FDECL(savelevchn, (int, int));
26. STATIC_DCL void FDECL(savedamage, (int, int));
27. STATIC_DCL void FDECL(saveobj, (int, struct obj *));
28. STATIC_DCL void FDECL(saveobjchn, (int, struct obj *, int));
29. STATIC_DCL void FDECL(savemon, (int, struct monst *));
30. STATIC_DCL void FDECL(savemonchn, (int, struct monst *, int));
31. STATIC_DCL void FDECL(savetrapchn, (int, struct trap *, int));
32. STATIC_DCL void FDECL(savegamestate, (int, int));
33. STATIC_OVL void FDECL(save_msghistory, (int, int));
34. #ifdef MFLOPPY
35. STATIC_DCL void FDECL(savelev0, (int, XCHAR_P, int));
36. STATIC_DCL boolean NDECL(swapout_oldest);
37. STATIC_DCL void FDECL(copyfile, (char *, char *));
38. #endif /* MFLOPPY */
39. STATIC_DCL void FDECL(savelevl, (int fd, BOOLEAN_P));
40. STATIC_DCL void FDECL(def_bufon, (int));
41. STATIC_DCL void FDECL(def_bufoff, (int));
42. STATIC_DCL void FDECL(def_bflush, (int));
43. STATIC_DCL void FDECL(def_bwrite, (int, genericptr_t, unsigned int));
44. #ifdef ZEROCOMP
45. STATIC_DCL void FDECL(zerocomp_bufon, (int));
46. STATIC_DCL void FDECL(zerocomp_bufoff, (int));
47. STATIC_DCL void FDECL(zerocomp_bflush, (int));
48. STATIC_DCL void FDECL(zerocomp_bwrite, (int, genericptr_t, unsigned int));
49. STATIC_DCL void FDECL(zerocomp_bputc, (int));
50. #endif
51. 
52. static struct save_procs {
53.     const char *name;
54.     void FDECL((*save_bufon), (int));
55.     void FDECL((*save_bufoff), (int));
56.     void FDECL((*save_bflush), (int));
57.     void FDECL((*save_bwrite), (int, genericptr_t, unsigned int));
58.     void FDECL((*save_bclose), (int));
59. } saveprocs = {
60. #if !defined(ZEROCOMP) || (defined(COMPRESS) || defined(ZLIB_COMP))
61.     "externalcomp", def_bufon, def_bufoff, def_bflush, def_bwrite, def_bclose,
62. #else
63.     "zerocomp",      zerocomp_bufon,  zerocomp_bufoff,
64.     zerocomp_bflush, zerocomp_bwrite, zerocomp_bclose,
65. #endif
66. };
67. 
68. #if defined(UNIX) || defined(VMS) || defined(__EMX__) || defined(WIN32)
69. #define HUP if (!program_state.done_hup)
70. #else
71. #define HUP
72. #endif
73. 
74. /* need to preserve these during save to avoid accessing freed memory */
75. static unsigned ustuck_id = 0, usteed_id = 0;
76. 
77. int
78. dosave()
79. {
80.     if (iflags.debug_fuzzer)
81.         return 0;
82.     clear_nhwindow(WIN_MESSAGE);
83.     if (yn("Really save?") == 'n') {
84.         clear_nhwindow(WIN_MESSAGE);
85.         if (multi > 0)
86.             nomul(0);
87.     } else {
88.         clear_nhwindow(WIN_MESSAGE);
89.         pline("Saving...");
90. #if defined(UNIX) || defined(VMS) || defined(__EMX__)
91.         program_state.done_hup = 0;
92. #endif
93.         if (dosave0()) {
94.             u.uhp = -1; /* universal game's over indicator */
95.             /* make sure they see the Saving message */
96.             display_nhwindow(WIN_MESSAGE, TRUE);
97.             exit_nhwindows("Be seeing you...");
98.             nh_terminate(EXIT_SUCCESS);
99.         } else
100.             (void) doredraw();
101.     }
102.     return 0;
103. }
104. 
105. /* returns 1 if save successful */
106. int
107. dosave0()
108. {
109.     const char *fq_save;
110.     register int fd, ofd;
111.     xchar ltmp;
112.     d_level uz_save;
113.     char whynot[BUFSZ];
114. 
115.     /* we may get here via hangup signal, in which case we want to fix up
116.        a few of things before saving so that they won't be restored in
117.        an improper state; these will be no-ops for normal save sequence */
118.     u.uinvulnerable = 0;
119.     if (iflags.save_uswallow)
120.         u.uswallow = 1, iflags.save_uswallow = 0;
121.     if (iflags.save_uinwater)
122.         u.uinwater = 1, iflags.save_uinwater = 0;
123.     if (iflags.save_uburied)
124.         u.uburied = 1, iflags.save_uburied = 0;
125. 
126.     if (!program_state.something_worth_saving || !SAVEF[0])
127.         return 0;
128.     fq_save = fqname(SAVEF, SAVEPREFIX, 1); /* level files take 0 */
129. 
130. #if defined(UNIX) || defined(VMS)
131.     sethanguphandler((void FDECL((*), (int) )) SIG_IGN);
132. #endif
133. #ifndef NO_SIGNAL
134.     (void) signal(SIGINT, SIG_IGN);
135. #endif
136. 
137. #if defined(MICRO) && defined(MFLOPPY)
138.     if (!saveDiskPrompt(0))
139.         return 0;
140. #endif
141. 
142.     HUP if (iflags.window_inited) {
143.         nh_uncompress(fq_save);
144.         fd = open_savefile();
145.         if (fd > 0) {
146.             (void) nhclose(fd);
147.             clear_nhwindow(WIN_MESSAGE);
148.             There("seems to be an old save file.");
149.             if (yn("Overwrite the old file?") == 'n') {
150.                 nh_compress(fq_save);
151.                 return 0;
152.             }
153.         }
154.     }
155. 
156.     HUP mark_synch(); /* flush any buffered screen output */
157. 
158.     fd = create_savefile();
159.     if (fd < 0) {
160.         HUP pline("Cannot open save file.");
161.         (void) delete_savefile(); /* ab@unido */
162.         return 0;
163.     }
164. 
165.     vision_recalc(2); /* shut down vision to prevent problems
166.                          in the event of an impossible() call */
167. 
168.     /* undo date-dependent luck adjustments made at startup time */
169.     if (flags.moonphase == FULL_MOON) /* ut-sally!fletcher */
170.         change_luck(-1);              /* and unido!ab */
171.     if (flags.friday13)
172.         change_luck(1);
173.     if (iflags.window_inited)
174.         HUP clear_nhwindow(WIN_MESSAGE);
175. 
176. #ifdef MICRO
177.     dotcnt = 0;
178.     dotrow = 2;
179.     curs(WIN_MAP, 1, 1);
180.     if (!WINDOWPORT("X11"))
181.         putstr(WIN_MAP, 0, "Saving:");
182. #endif
183. #ifdef MFLOPPY
184.     /* make sure there is enough disk space */
185.     if (iflags.checkspace) {
186.         long fds, needed;
187. 
188.         savelev(fd, ledger_no(&u.uz), COUNT_SAVE);
189.         savegamestate(fd, COUNT_SAVE);
190.         needed = bytes_counted;
191. 
192.         for (ltmp = 1; ltmp <= maxledgerno(); ltmp++)
193.             if (ltmp != ledger_no(&u.uz) && level_info[ltmp].where)
194.                 needed += level_info[ltmp].size + (sizeof ltmp);
195.         fds = freediskspace(fq_save);
196.         if (needed > fds) {
197.             HUP
198.             {
199.                 There("is insufficient space on SAVE disk.");
200.                 pline("Require %ld bytes but only have %ld.", needed, fds);
201.             }
202.             flushout();
203.             (void) nhclose(fd);
204.             (void) delete_savefile();
205.             return 0;
206.         }
207. 
208.         co_false();
209.     }
210. #endif /* MFLOPPY */
211. 
212.     store_version(fd);
213.     store_savefileinfo(fd);
214.     store_plname_in_file(fd);
215.     ustuck_id = (u.ustuck ? u.ustuck->m_id : 0);
216.     usteed_id = (u.usteed ? u.usteed->m_id : 0);
217.     savelev(fd, ledger_no(&u.uz), WRITE_SAVE | FREE_SAVE);
218.     savegamestate(fd, WRITE_SAVE | FREE_SAVE);
219. 
220.     /* While copying level files around, zero out u.uz to keep
221.      * parts of the restore code from completely initializing all
222.      * in-core data structures, since all we're doing is copying.
223.      * This also avoids at least one nasty core dump.
224.      */
225.     uz_save = u.uz;
226.     u.uz.dnum = u.uz.dlevel = 0;
227.     /* these pointers are no longer valid, and at least u.usteed
228.      * may mislead place_monster() on other levels
229.      */
230.     u.ustuck = (struct monst *) 0;
231.     u.usteed = (struct monst *) 0;
232. 
233.     for (ltmp = (xchar) 1; ltmp <= maxledgerno(); ltmp++) {
234.         if (ltmp == ledger_no(&uz_save))
235.             continue;
236.         if (!(level_info[ltmp].flags & LFILE_EXISTS))
237.             continue;
238. #ifdef MICRO
239.         curs(WIN_MAP, 1 + dotcnt++, dotrow);
240.         if (dotcnt >= (COLNO - 1)) {
241.             dotrow++;
242.             dotcnt = 0;
243.         }
244.         if (!WINDOWPORT("X11")) {
245.             putstr(WIN_MAP, 0, ".");
246.         }
247.         mark_synch();
248. #endif
249.         ofd = open_levelfile(ltmp, whynot);
250.         if (ofd < 0) {
251.             HUP pline1(whynot);
252.             (void) nhclose(fd);
253.             (void) delete_savefile();
254.             HUP Strcpy(killer.name, whynot);
255.             HUP done(TRICKED);
256.             return 0;
257.         }
258.         minit(); /* ZEROCOMP */
259.         getlev(ofd, hackpid, ltmp, FALSE);
260.         (void) nhclose(ofd);
261.         bwrite(fd, (genericptr_t) &ltmp, sizeof ltmp); /* level number*/
262.         savelev(fd, ltmp, WRITE_SAVE | FREE_SAVE);     /* actual level*/
263.         delete_levelfile(ltmp);
264.     }
265.     bclose(fd);
266. 
267.     u.uz = uz_save;
268. 
269.     /* get rid of current level --jgm */
270.     delete_levelfile(ledger_no(&u.uz));
271.     delete_levelfile(0);
272.     nh_compress(fq_save);
273.     /* this should probably come sooner... */
274.     program_state.something_worth_saving = 0;
275.     return 1;
276. }
277. 
278. STATIC_OVL void
279. savegamestate(fd, mode)
280. register int fd, mode;
281. {
282.     unsigned long uid;
283.     struct obj * bc_objs = (struct obj *)0;
284. 
285. #ifdef MFLOPPY
286.     count_only = (mode & COUNT_SAVE);
287. #endif
288.     uid = (unsigned long) getuid();
289.     bwrite(fd, (genericptr_t) &uid, sizeof uid);
290.     bwrite(fd, (genericptr_t) &context, sizeof context);
291.     bwrite(fd, (genericptr_t) &flags, sizeof flags);
292. #ifdef SYSFLAGS
293.     bwrite(fd, (genericptr_t) &sysflags, sysflags);
294. #endif
295.     urealtime.finish_time = getnow();
296.     urealtime.realtime += (long) (urealtime.finish_time
297.                                   - urealtime.start_timing);
298.     bwrite(fd, (genericptr_t) &u, sizeof u);
299.     bwrite(fd, yyyymmddhhmmss(ubirthday), 14);
300.     bwrite(fd, (genericptr_t) &urealtime.realtime, sizeof urealtime.realtime);
301.     bwrite(fd, yyyymmddhhmmss(urealtime.start_timing), 14);  /** Why? **/
302.     /* this is the value to use for the next update of urealtime.realtime */
303.     urealtime.start_timing = urealtime.finish_time;
304.     save_killers(fd, mode);
305. 
306.     /* must come before migrating_objs and migrating_mons are freed */
307.     save_timers(fd, mode, RANGE_GLOBAL);
308.     save_light_sources(fd, mode, RANGE_GLOBAL);
309. 
310.     saveobjchn(fd, invent, mode);
311. 
312.     /* save ball and chain if they are currently dangling free (i.e. not on
313.        floor or in inventory) */
314.     if (CHAIN_IN_MON) {
315.         uchain->nobj = bc_objs;
316.         bc_objs = uchain;
317.     }
318.     if (BALL_IN_MON) {
319.         uball->nobj = bc_objs;
320.         bc_objs = uball;
321.     }
322.     saveobjchn(fd, bc_objs, mode);
323. 
324.     saveobjchn(fd, migrating_objs, mode);
325.     savemonchn(fd, migrating_mons, mode);
326.     if (release_data(mode)) {
327.         invent = 0;
328.         migrating_objs = 0;
329.         migrating_mons = 0;
330.     }
331.     bwrite(fd, (genericptr_t) mvitals, sizeof mvitals);
332. 
333.     save_dungeon(fd, (boolean) !!perform_bwrite(mode),
334.                  (boolean) !!release_data(mode));
335.     savelevchn(fd, mode);
336.     bwrite(fd, (genericptr_t) &moves, sizeof moves);
337.     bwrite(fd, (genericptr_t) &monstermoves, sizeof monstermoves);
338.     bwrite(fd, (genericptr_t) &quest_status, sizeof quest_status);
339.     bwrite(fd, (genericptr_t) spl_book,
340.            sizeof(struct spell) * (MAXSPELL + 1));
341.     save_artifacts(fd);
342.     save_oracles(fd, mode);
343.     if (ustuck_id)
344.         bwrite(fd, (genericptr_t) &ustuck_id, sizeof ustuck_id);
345.     if (usteed_id)
346.         bwrite(fd, (genericptr_t) &usteed_id, sizeof usteed_id);
347.     bwrite(fd, (genericptr_t) pl_character, sizeof pl_character);
348.     bwrite(fd, (genericptr_t) pl_fruit, sizeof pl_fruit);
349.     savefruitchn(fd, mode);
350.     savenames(fd, mode);
351.     save_waterlevel(fd, mode);
352.     save_msghistory(fd, mode);
353.     bflush(fd);
354. }
355. 
356. boolean
357. tricked_fileremoved(fd, whynot)
358. int fd;
359. char *whynot;
360. {
361.     if (fd < 0) {
362.         pline1(whynot);
363.         pline("Probably someone removed it.");
364.         Strcpy(killer.name, whynot);
365.         done(TRICKED);
366.         return TRUE;
367.     }
368.     return FALSE;
369. }
370. 
371. #ifdef INSURANCE
372. void
373. savestateinlock()
374. {
375.     int fd, hpid;
376.     static boolean havestate = TRUE;
377.     char whynot[BUFSZ];
378. 
379.     /* When checkpointing is on, the full state needs to be written
380.      * on each checkpoint.  When checkpointing is off, only the pid
381.      * needs to be in the level.0 file, so it does not need to be
382.      * constantly rewritten.  When checkpointing is turned off during
383.      * a game, however, the file has to be rewritten once to truncate
384.      * it and avoid restoring from outdated information.
385.      *
386.      * Restricting havestate to this routine means that an additional
387.      * noop pid rewriting will take place on the first "checkpoint" after
388.      * the game is started or restored, if checkpointing is off.
389.      */
390.     if (flags.ins_chkpt || havestate) {
391.         /* save the rest of the current game state in the lock file,
392.          * following the original int pid, the current level number,
393.          * and the current savefile name, which should not be subject
394.          * to any internal compression schemes since they must be
395.          * readable by an external utility
396.          */
397.         fd = open_levelfile(0, whynot);
398.         if (tricked_fileremoved(fd, whynot))
399.             return;
400. 
401.         (void) read(fd, (genericptr_t) &hpid, sizeof hpid);
402.         if (hackpid != hpid) {
403.             Sprintf(whynot, "Level #0 pid (%d) doesn't match ours (%d)!",
404.                     hpid, hackpid);
405.             pline1(whynot);
406.             Strcpy(killer.name, whynot);
407.             done(TRICKED);
408.         }
409.         (void) nhclose(fd);
410. 
411.         fd = create_levelfile(0, whynot);
412.         if (fd < 0) {
413.             pline1(whynot);
414.             Strcpy(killer.name, whynot);
415.             done(TRICKED);
416.             return;
417.         }
418.         (void) write(fd, (genericptr_t) &hackpid, sizeof hackpid);
419.         if (flags.ins_chkpt) {
420.             int currlev = ledger_no(&u.uz);
421. 
422.             (void) write(fd, (genericptr_t) &currlev, sizeof currlev);
423.             save_savefile_name(fd);
424.             store_version(fd);
425.             store_savefileinfo(fd);
426.             store_plname_in_file(fd);
427. 
428.             ustuck_id = (u.ustuck ? u.ustuck->m_id : 0);
429.             usteed_id = (u.usteed ? u.usteed->m_id : 0);
430.             savegamestate(fd, WRITE_SAVE);
431.         }
432.         bclose(fd);
433.     }
434.     havestate = flags.ins_chkpt;
435. }
436. #endif
437. 
438. #ifdef MFLOPPY
439. boolean
440. savelev(fd, lev, mode)
441. int fd;
442. xchar lev;
443. int mode;
444. {
445.     if (mode & COUNT_SAVE) {
446.         bytes_counted = 0;
447.         savelev0(fd, lev, COUNT_SAVE);
448.         /* probably bytes_counted will be filled in again by an
449.          * immediately following WRITE_SAVE anyway, but we'll
450.          * leave it out of checkspace just in case */
451.         if (iflags.checkspace) {
452.             while (bytes_counted > freediskspace(levels))
453.                 if (!swapout_oldest())
454.                     return FALSE;
455.         }
456.     }
457.     if (mode & (WRITE_SAVE | FREE_SAVE)) {
458.         bytes_counted = 0;
459.         savelev0(fd, lev, mode);
460.     }
461.     if (mode != FREE_SAVE) {
462.         level_info[lev].where = ACTIVE;
463.         level_info[lev].time = moves;
464.         level_info[lev].size = bytes_counted;
465.     }
466.     return TRUE;
467. }
468. 
469. STATIC_OVL void
470. savelev0(fd, lev, mode)
471. #else
472. void
473. savelev(fd, lev, mode)
474. #endif
475. int fd;
476. xchar lev;
477. int mode;
478. {
479. #ifdef TOS
480.     short tlev;
481. #endif
482. 
483.     /*
484.      *  Level file contents:
485.      *    version info (handled by caller);
486.      *    save file info (compression type; also by caller);
487.      *    process ID;
488.      *    internal level number (ledger number);
489.      *    bones info;
490.      *    actual level data.
491.      *
492.      *  If we're tearing down the current level without saving anything
493.      *  (which happens at end of game or upon entrance to endgame or
494.      *  after an aborted restore attempt) then we don't want to do any
495.      *  actual I/O.  So when only freeing, we skip to the bones info
496.      *  portion (which has some freeing to do), then jump quite a bit
497.      *  further ahead to the middle of the 'actual level data' portion.
498.      */
499.     if (mode != FREE_SAVE) {
500.         /* WRITE_SAVE (probably ORed with FREE_SAVE), or COUNT_SAVE */
501. 
502.         /* purge any dead monsters (necessary if we're starting
503.            a panic save rather than a normal one, or sometimes
504.            when changing levels without taking time -- e.g.
505.            create statue trap then immediately level teleport) */
506.         if (iflags.purge_monsters)
507.             dmonsfree();
508. 
509.         if (fd < 0)
510.             panic("Save on bad file!"); /* impossible */
511. #ifdef MFLOPPY
512.         count_only = (mode & COUNT_SAVE);
513. #endif
514.         if (lev >= 0 && lev <= maxledgerno())
515.             level_info[lev].flags |= VISITED;
516.         bwrite(fd, (genericptr_t) &hackpid, sizeof hackpid);
517. #ifdef TOS
518.         tlev = lev;
519.         tlev &= 0x00ff;
520.         bwrite(fd, (genericptr_t) &tlev, sizeof tlev);
521. #else
522.         bwrite(fd, (genericptr_t) &lev, sizeof lev);
523. #endif
524.     }
525. 
526.     /* bones info comes before level data; the intent is for an external
527.        program ('hearse') to be able to match a bones file with the
528.        corresponding log file entry--or perhaps just skip that?--without
529.        the guessing that was needed in 3.4.3 and without having to
530.        interpret level data to find where to start; unfortunately it
531.        still needs to handle all the data compression schemes */
532.     savecemetery(fd, mode, &level.bonesinfo);
533.     if (mode == FREE_SAVE) /* see above */
534.         goto skip_lots;
535. 
536.     savelevl(fd, (boolean) ((sfsaveinfo.sfi1 & SFI1_RLECOMP) == SFI1_RLECOMP));
537.     bwrite(fd, (genericptr_t) lastseentyp, sizeof lastseentyp);
538.     bwrite(fd, (genericptr_t) &monstermoves, sizeof monstermoves);
539.     bwrite(fd, (genericptr_t) &upstair, sizeof (stairway));
540.     bwrite(fd, (genericptr_t) &dnstair, sizeof (stairway));
541.     bwrite(fd, (genericptr_t) &upladder, sizeof (stairway));
542.     bwrite(fd, (genericptr_t) &dnladder, sizeof (stairway));
543.     bwrite(fd, (genericptr_t) &sstairs, sizeof (stairway));
544.     bwrite(fd, (genericptr_t) &updest, sizeof (dest_area));
545.     bwrite(fd, (genericptr_t) &dndest, sizeof (dest_area));
546.     bwrite(fd, (genericptr_t) &level.flags, sizeof level.flags);
547.     bwrite(fd, (genericptr_t) doors, sizeof doors);
548.     save_rooms(fd); /* no dynamic memory to reclaim */
549. 
550.     /* from here on out, saving also involves allocated memory cleanup */
551.  skip_lots:
552.     /* timers and lights must be saved before monsters and objects */
553.     save_timers(fd, mode, RANGE_LEVEL);
554.     save_light_sources(fd, mode, RANGE_LEVEL);
555. 
556.     savemonchn(fd, fmon, mode);
557.     save_worm(fd, mode); /* save worm information */
558.     savetrapchn(fd, ftrap, mode);
559.     saveobjchn(fd, fobj, mode);
560.     saveobjchn(fd, level.buriedobjlist, mode);
561.     saveobjchn(fd, billobjs, mode);
562.     if (release_data(mode)) {
563.         int x,y;
564. 
565.         for (y = 0; y < ROWNO; y++)
566.             for (x = 0; x < COLNO; x++)
567.                 level.monsters[x][y] = 0;
568.         fmon = 0;
569.         ftrap = 0;
570.         fobj = level.buriedobjlist = billobjs = 0;
571.         /* level.bonesinfo = 0; -- handled by savecemetery() */
572.     }
573.     save_engravings(fd, mode);
574.     savedamage(fd, mode); /* pending shop wall and/or floor repair */
575.     save_regions(fd, mode);
576.     if (mode != FREE_SAVE)
577.         bflush(fd);
578. }
579. 
580. STATIC_OVL void
581. savelevl(fd, rlecomp)
582. int fd;
583. boolean rlecomp;
584. {
585. #ifdef RLECOMP
586.     struct rm *prm, *rgrm;
587.     int x, y;
588.     uchar match;
589. 
590.     if (rlecomp) {
591.         /* perform run-length encoding of rm structs */
592. 
593.         rgrm = &levl[0][0]; /* start matching at first rm */
594.         match = 0;
595. 
596.         for (y = 0; y < ROWNO; y++) {
597.             for (x = 0; x < COLNO; x++) {
598.                 prm = &levl[x][y];
599.                 if (prm->glyph == rgrm->glyph && prm->typ == rgrm->typ
600.                     && prm->seenv == rgrm->seenv
601.                     && prm->horizontal == rgrm->horizontal
602.                     && prm->flags == rgrm->flags && prm->lit == rgrm->lit
603.                     && prm->waslit == rgrm->waslit
604.                     && prm->roomno == rgrm->roomno && prm->edge == rgrm->edge
605.                     && prm->candig == rgrm->candig) {
606.                     match++;
607.                     if (match > 254) {
608.                         match = 254; /* undo this match */
609.                         goto writeout;
610.                     }
611.                 } else {
612.                     /* run has been broken, write out run-length encoding */
613.  writeout:
614.                     bwrite(fd, (genericptr_t) &match, sizeof (uchar));
615.                     bwrite(fd, (genericptr_t) rgrm, sizeof (struct rm));
616.                     /* start encoding again. we have at least 1 rm
617.                        in the next run, viz. this one. */
618.                     match = 1;
619.                     rgrm = prm;
620.                 }
621.             }
622.         }
623.         if (match > 0) {
624.             bwrite(fd, (genericptr_t) &match, sizeof (uchar));
625.             bwrite(fd, (genericptr_t) rgrm, sizeof (struct rm));
626.         }
627.         return;
628.     }
629. #else /* !RLECOMP */
630.     nhUse(rlecomp);
631. #endif /* ?RLECOMP */
632.     bwrite(fd, (genericptr_t) levl, sizeof levl);
633. }
634. 
635. /*ARGSUSED*/
636. void
637. bufon(fd)
638. int fd;
639. {
640.     (*saveprocs.save_bufon)(fd);
641.     return;
642. }
643. 
644. /*ARGSUSED*/
645. void
646. bufoff(fd)
647. int fd;
648. {
649.     (*saveprocs.save_bufoff)(fd);
650.     return;
651. }
652. 
653. /* flush run and buffer */
654. void
655. bflush(fd)
656. register int fd;
657. {
658.     (*saveprocs.save_bflush)(fd);
659.     return;
660. }
661. 
662. void
663. bwrite(fd, loc, num)
664. int fd;
665. genericptr_t loc;
666. register unsigned num;
667. {
668.     (*saveprocs.save_bwrite)(fd, loc, num);
669.     return;
670. }
671. 
672. void
673. bclose(fd)
674. int fd;
675. {
676.     (*saveprocs.save_bclose)(fd);
677.     return;
678. }
679. 
680. static int bw_fd = -1;
681. static FILE *bw_FILE = 0;
682. static boolean buffering = FALSE;
683. 
684. STATIC_OVL void
685. def_bufon(fd)
686. int fd;
687. {
688. #ifdef UNIX
689.     if (bw_fd != fd) {
690.         if (bw_fd >= 0)
691.             panic("double buffering unexpected");
692.         bw_fd = fd;
693.         if ((bw_FILE = fdopen(fd, "w")) == 0)
694.             panic("buffering of file %d failed", fd);
695.     }
696. #endif
697.     buffering = TRUE;
698. }
699. 
700. STATIC_OVL void
701. def_bufoff(fd)
702. int fd;
703. {
704.     def_bflush(fd);
705.     buffering = FALSE;
706. }
707. 
708. STATIC_OVL void
709. def_bflush(fd)
710. int fd;
711. {
712. #ifdef UNIX
713.     if (fd == bw_fd) {
714.         if (fflush(bw_FILE) == EOF)
715.             panic("flush of savefile failed!");
716.     }
717. #endif
718.     return;
719. }
720. 
721. STATIC_OVL void
722. def_bwrite(fd, loc, num)
723. register int fd;
724. register genericptr_t loc;
725. register unsigned num;
726. {
727.     boolean failed;
728. 
729. #ifdef MFLOPPY
730.     bytes_counted += num;
731.     if (count_only)
732.         return;
733. #endif
734. 
735. #ifdef UNIX
736.     if (buffering) {
737.         if (fd != bw_fd)
738.             panic("unbuffered write to fd %d (!= %d)", fd, bw_fd);
739. 
740.         failed = (fwrite(loc, (int) num, 1, bw_FILE) != 1);
741.     } else
742. #endif /* UNIX */
743.     {
744.         /* lint wants 3rd arg of write to be an int; lint -p an unsigned */
745. #if defined(BSD) || defined(ULTRIX) || defined(WIN32) || defined(_MSC_VER)
746.         failed = ((long) write(fd, loc, (int) num) != (long) num);
747. #else /* e.g. SYSV, __TURBOC__ */
748.         failed = ((long) write(fd, loc, num) != (long) num);
749. #endif
750.     }
751. 
752.     if (failed) {
753. #if defined(UNIX) || defined(VMS) || defined(__EMX__)
754.         if (program_state.done_hup)
755.             nh_terminate(EXIT_FAILURE);
756.         else
757. #endif
758.             panic("cannot write %u bytes to file #%d", num, fd);
759.     }
760. }
761. 
762. void
763. def_bclose(fd)
764. int fd;
765. {
766.     bufoff(fd);
767. #ifdef UNIX
768.     if (fd == bw_fd) {
769.         (void) fclose(bw_FILE);
770.         bw_fd = -1;
771.         bw_FILE = 0;
772.     } else
773. #endif
774.         (void) nhclose(fd);
775.     return;
776. }
777. 
778. #ifdef ZEROCOMP
779. /* The runs of zero-run compression are flushed after the game state or a
780.  * level is written out.  This adds a couple bytes to a save file, where
781.  * the runs could be mashed together, but it allows gluing together game
782.  * state and level files to form a save file, and it means the flushing
783.  * does not need to be specifically called for every other time a level
784.  * file is written out.
785.  */
786. 
787. #define RLESC '\0' /* Leading character for run of LRESC's */
788. #define flushoutrun(ln) (zerocomp_bputc(RLESC), zerocomp_bputc(ln), ln = -1)
789. 
790. #ifndef ZEROCOMP_BUFSIZ
791. #define ZEROCOMP_BUFSIZ BUFSZ
792. #endif
793. static NEARDATA unsigned char outbuf[ZEROCOMP_BUFSIZ];
794. static NEARDATA unsigned short outbufp = 0;
795. static NEARDATA short outrunlength = -1;
796. static NEARDATA int bwritefd;
797. static NEARDATA boolean compressing = FALSE;
798. 
799. /*dbg()
800. {
801.     HUP printf("outbufp %d outrunlength %d\n", outbufp,outrunlength);
802. }*/
803. 
804. STATIC_OVL void
805. zerocomp_bputc(c)
806. int c;
807. {
808. #ifdef MFLOPPY
809.     bytes_counted++;
810.     if (count_only)
811.         return;
812. #endif
813.     if (outbufp >= sizeof outbuf) {
814.         (void) write(bwritefd, outbuf, sizeof outbuf);
815.         outbufp = 0;
816.     }
817.     outbuf[outbufp++] = (unsigned char) c;
818. }
819. 
820. /*ARGSUSED*/
821. void STATIC_OVL
822. zerocomp_bufon(fd)
823. int fd;
824. {
825.     compressing = TRUE;
826.     return;
827. }
828. 
829. /*ARGSUSED*/
830. STATIC_OVL void
831. zerocomp_bufoff(fd)
832. int fd;
833. {
834.     if (outbufp) {
835.         outbufp = 0;
836.         panic("closing file with buffered data still unwritten");
837.     }
838.     outrunlength = -1;
839.     compressing = FALSE;
840.     return;
841. }
842. 
843. /* flush run and buffer */
844. STATIC_OVL void
845. zerocomp_bflush(fd)
846. register int fd;
847. {
848.     bwritefd = fd;
849.     if (outrunlength >= 0) { /* flush run */
850.         flushoutrun(outrunlength);
851.     }
852. #ifdef MFLOPPY
853.     if (count_only)
854.         outbufp = 0;
855. #endif
856. 
857.     if (outbufp) {
858.         if (write(fd, outbuf, outbufp) != outbufp) {
859. #if defined(UNIX) || defined(VMS) || defined(__EMX__)
860.             if (program_state.done_hup)
861.                 nh_terminate(EXIT_FAILURE);
862.             else
863. #endif
864.                 zerocomp_bclose(fd); /* panic (outbufp != 0) */
865.         }
866.         outbufp = 0;
867.     }
868. }
869. 
870. STATIC_OVL void
871. zerocomp_bwrite(fd, loc, num)
872. int fd;
873. genericptr_t loc;
874. register unsigned num;
875. {
876.     register unsigned char *bp = (unsigned char *) loc;
877. 
878.     if (!compressing) {
879. #ifdef MFLOPPY
880.         bytes_counted += num;
881.         if (count_only)
882.             return;
883. #endif
884.         if ((unsigned) write(fd, loc, num) != num) {
885. #if defined(UNIX) || defined(VMS) || defined(__EMX__)
886.             if (program_state.done_hup)
887.                 nh_terminate(EXIT_FAILURE);
888.             else
889. #endif
890.                 panic("cannot write %u bytes to file #%d", num, fd);
891.         }
892.     } else {
893.         bwritefd = fd;
894.         for (; num; num--, bp++) {
895.             if (*bp == RLESC) { /* One more char in run */
896.                 if (++outrunlength == 0xFF) {
897.                     flushoutrun(outrunlength);
898.                 }
899.             } else {                     /* end of run */
900.                 if (outrunlength >= 0) { /* flush run */
901.                     flushoutrun(outrunlength);
902.                 }
903.                 zerocomp_bputc(*bp);
904.             }
905.         }
906.     }
907. }
908. 
909. void
910. zerocomp_bclose(fd)
911. int fd;
912. {
913.     zerocomp_bufoff(fd);
914.     (void) nhclose(fd);
915.     return;
916. }
917. #endif /* ZEROCOMP */
918. 
919. STATIC_OVL void
920. savelevchn(fd, mode)
921. register int fd, mode;
922. {
923.     s_level *tmplev, *tmplev2;
924.     int cnt = 0;
925. 
926.     for (tmplev = sp_levchn; tmplev; tmplev = tmplev->next)
927.         cnt++;
928.     if (perform_bwrite(mode))
929.         bwrite(fd, (genericptr_t) &cnt, sizeof cnt);
930. 
931.     for (tmplev = sp_levchn; tmplev; tmplev = tmplev2) {
932.         tmplev2 = tmplev->next;
933.         if (perform_bwrite(mode))
934.             bwrite(fd, (genericptr_t) tmplev, sizeof *tmplev);
935.         if (release_data(mode))
936.             free((genericptr_t) tmplev);
937.     }
938.     if (release_data(mode))
939.         sp_levchn = 0;
940. }
941. 
942. /* used when saving a level and also when saving dungeon overview data */
943. void
944. savecemetery(fd, mode, cemeteryaddr)
945. int fd;
946. int mode;
947. struct cemetery **cemeteryaddr;
948. {
949.     struct cemetery *thisbones, *nextbones;
950.     int flag;
951. 
952.     flag = *cemeteryaddr ? 0 : -1;
953.     if (perform_bwrite(mode))
954.         bwrite(fd, (genericptr_t) &flag, sizeof flag);
955.     nextbones = *cemeteryaddr;
956.     while ((thisbones = nextbones) != 0) {
957.         nextbones = thisbones->next;
958.         if (perform_bwrite(mode))
959.             bwrite(fd, (genericptr_t) thisbones, sizeof *thisbones);
960.         if (release_data(mode))
961.             free((genericptr_t) thisbones);
962.     }
963.     if (release_data(mode))
964.         *cemeteryaddr = 0;
965. }
966. 
967. STATIC_OVL void
968. savedamage(fd, mode)
969. register int fd, mode;
970. {
971.     register struct damage *damageptr, *tmp_dam;
972.     unsigned int xl = 0;
973. 
974.     damageptr = level.damagelist;
975.     for (tmp_dam = damageptr; tmp_dam; tmp_dam = tmp_dam->next)
976.         xl++;
977.     if (perform_bwrite(mode))
978.         bwrite(fd, (genericptr_t) &xl, sizeof xl);
979. 
980.     while (xl--) {
981.         if (perform_bwrite(mode))
982.             bwrite(fd, (genericptr_t) damageptr, sizeof *damageptr);
983.         tmp_dam = damageptr;
984.         damageptr = damageptr->next;
985.         if (release_data(mode))
986.             free((genericptr_t) tmp_dam);
987.     }
988.     if (release_data(mode))
989.         level.damagelist = 0;
990. }
991. 
992. STATIC_OVL void
993. saveobj(fd, otmp)
994. int fd;
995. struct obj *otmp;
996. {
997.     int buflen, zerobuf = 0;
998. 
999.     buflen = (int) sizeof (struct obj);
1000.     bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1001.     bwrite(fd, (genericptr_t) otmp, buflen);
1002.     if (otmp->oextra) {
1003.         buflen = ONAME(otmp) ? (int) strlen(ONAME(otmp)) + 1 : 0;
1004.         bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1005.         if (buflen > 0)
1006.             bwrite(fd, (genericptr_t) ONAME(otmp), buflen);
1007. 
1008.         /* defer to savemon() for this one */
1009.         if (OMONST(otmp))
1010.             savemon(fd, OMONST(otmp));
1011.         else
1012.             bwrite(fd, (genericptr_t) &zerobuf, sizeof zerobuf);
1013. 
1014.         buflen = OMID(otmp) ? (int) sizeof (unsigned) : 0;
1015.         bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1016.         if (buflen > 0)
1017.             bwrite(fd, (genericptr_t) OMID(otmp), buflen);
1018. 
1019.         /* TODO: post 3.6.x, get rid of this */
1020.         buflen = OLONG(otmp) ? (int) sizeof (long) : 0;
1021.         bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1022.         if (buflen > 0)
1023.             bwrite(fd, (genericptr_t) OLONG(otmp), buflen);
1024. 
1025.         buflen = OMAILCMD(otmp) ? (int) strlen(OMAILCMD(otmp)) + 1 : 0;
1026.         bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1027.         if (buflen > 0)
1028.             bwrite(fd, (genericptr_t) OMAILCMD(otmp), buflen);
1029.     }
1030. }
1031. 
1032. STATIC_OVL void
1033. saveobjchn(fd, otmp, mode)
1034. register int fd, mode;
1035. register struct obj *otmp;
1036. {
1037.     register struct obj *otmp2;
1038.     int minusone = -1;
1039. 
1040.     while (otmp) {
1041.         otmp2 = otmp->nobj;
1042.         if (perform_bwrite(mode)) {
1043.             saveobj(fd, otmp);
1044.         }
1045.         if (Has_contents(otmp))
1046.             saveobjchn(fd, otmp->cobj, mode);
1047.         if (release_data(mode)) {
1048.             /*
1049.              * If these are on the floor, the discarding could be
1050.              * due to game save, or we could just be changing levels.
1051.              * Always invalidate the pointer, but ensure that we have
1052.              * the o_id in order to restore the pointer on reload.
1053.              */
1054.             if (otmp == context.victual.piece) {
1055.                 context.victual.o_id = otmp->o_id;
1056.                 context.victual.piece = (struct obj *) 0;
1057.             }
1058.             if (otmp == context.tin.tin) {
1059.                 context.tin.o_id = otmp->o_id;
1060.                 context.tin.tin = (struct obj *) 0;
1061.             }
1062.             if (otmp == context.spbook.book) {
1063.                 context.spbook.o_id = otmp->o_id;
1064.                 context.spbook.book = (struct obj *) 0;
1065.             }
1066.             otmp->where = OBJ_FREE; /* set to free so dealloc will work */
1067.             otmp->nobj = NULL;      /* nobj saved into otmp2 */
1068.             otmp->cobj = NULL;      /* contents handled above */
1069.             otmp->timed = 0;        /* not timed any more */
1070.             otmp->lamplit = 0;      /* caller handled lights */
1071.             dealloc_obj(otmp);
1072.         }
1073.         otmp = otmp2;
1074.     }
1075.     if (perform_bwrite(mode))
1076.         bwrite(fd, (genericptr_t) &minusone, sizeof (int));
1077. }
1078. 
1079. STATIC_OVL void
1080. savemon(fd, mtmp)
1081. int fd;
1082. struct monst *mtmp;
1083. {
1084.     int buflen;
1085. 
1086.     mtmp->mtemplit = 0; /* normally clear; if set here then a panic save
1087.                          * is being written while bhit() was executing */
1088.     buflen = (int) sizeof (struct monst);
1089.     bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1090.     bwrite(fd, (genericptr_t) mtmp, buflen);
1091.     if (mtmp->mextra) {
1092.         buflen = MNAME(mtmp) ? (int) strlen(MNAME(mtmp)) + 1 : 0;
1093.         bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1094.         if (buflen > 0)
1095.             bwrite(fd, (genericptr_t) MNAME(mtmp), buflen);
1096.         buflen = EGD(mtmp) ? (int) sizeof (struct egd) : 0;
1097.         bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1098.         if (buflen > 0)
1099.             bwrite(fd, (genericptr_t) EGD(mtmp), buflen);
1100.         buflen = EPRI(mtmp) ? (int) sizeof (struct epri) : 0;
1101.         bwrite(fd, (genericptr_t) &buflen, sizeof buflen);
1102.         if (buflen > 0)
1103.             bwrite(fd, (genericptr_t) EPRI(mtmp), buflen);
1104.         buflen = ESHK(mtmp) ? (int) sizeof (struct eshk) : 0;
1105.         bwrite(fd, (genericptr_t) &buflen, sizeof(int));
1106.         if (buflen > 0)
1107.             bwrite(fd, (genericptr_t) ESHK(mtmp), buflen);
1108.         buflen = EMIN(mtmp) ? (int) sizeof (struct emin) : 0;
1109.         bwrite(fd, (genericptr_t) &buflen, sizeof(int));
1110.         if (buflen > 0)
1111.             bwrite(fd, (genericptr_t) EMIN(mtmp), buflen);
1112.         buflen = EDOG(mtmp) ? (int) sizeof (struct edog) : 0;
1113.         bwrite(fd, (genericptr_t) &buflen, sizeof(int));
1114.         if (buflen > 0)
1115.             bwrite(fd, (genericptr_t) EDOG(mtmp), buflen);
1116.         /* mcorpsenm is inline int rather than pointer to something,
1117.            so doesn't need to be preceded by a length field */
1118.         bwrite(fd, (genericptr_t) &MCORPSENM(mtmp), sizeof MCORPSENM(mtmp));
1119.     }
1120. }
1121. 
1122. STATIC_OVL void
1123. savemonchn(fd, mtmp, mode)
1124. register int fd, mode;
1125. register struct monst *mtmp;
1126. {
1127.     register struct monst *mtmp2;
1128.     int minusone = -1;
1129. 
1130.     while (mtmp) {
1131.         mtmp2 = mtmp->nmon;
1132.         if (perform_bwrite(mode)) {
1133.             mtmp->mnum = monsndx(mtmp->data);
1134.             if (mtmp->ispriest)
1135.                 forget_temple_entry(mtmp); /* EPRI() */
1136.             savemon(fd, mtmp);
1137.         }
1138.         if (mtmp->minvent)
1139.             saveobjchn(fd, mtmp->minvent, mode);
1140.         if (release_data(mode)) {
1141.             if (mtmp == context.polearm.hitmon) {
1142.                 context.polearm.m_id = mtmp->m_id;
1143.                 context.polearm.hitmon = NULL;
1144.             }
1145.             mtmp->nmon = NULL;  /* nmon saved into mtmp2 */
1146.             dealloc_monst(mtmp);
1147.         }
1148.         mtmp = mtmp2;
1149.     }
1150.     if (perform_bwrite(mode))
1151.         bwrite(fd, (genericptr_t) &minusone, sizeof (int));
1152. }
1153. 
1154. /* save traps; ftrap is the only trap chain so the 2nd arg is superfluous */
1155. STATIC_OVL void
1156. savetrapchn(fd, trap, mode)
1157. int fd;
1158. register struct trap *trap;
1159. int mode;
1160. {
1161.     static struct trap zerotrap;
1162.     register struct trap *trap2;
1163. 
1164.     while (trap) {
1165.         trap2 = trap->ntrap;
1166.         if (perform_bwrite(mode))
1167.             bwrite(fd, (genericptr_t) trap, sizeof *trap);
1168.         if (release_data(mode))
1169.             dealloc_trap(trap);
1170.         trap = trap2;
1171.     }
1172.     if (perform_bwrite(mode))
1173.         bwrite(fd, (genericptr_t) &zerotrap, sizeof zerotrap);
1174. }
1175. 
1176. /* save all the fruit names and ID's; this is used only in saving whole games
1177.  * (not levels) and in saving bones levels.  When saving a bones level,
1178.  * we only want to save the fruits which exist on the bones level; the bones
1179.  * level routine marks nonexistent fruits by making the fid negative.
1180.  */
1181. void
1182. savefruitchn(fd, mode)
1183. int fd, mode;
1184. {
1185.     static struct fruit zerofruit;
1186.     register struct fruit *f2, *f1;
1187. 
1188.     f1 = ffruit;
1189.     while (f1) {
1190.         f2 = f1->nextf;
1191.         if (f1->fid >= 0 && perform_bwrite(mode))
1192.             bwrite(fd, (genericptr_t) f1, sizeof *f1);
1193.         if (release_data(mode))
1194.             dealloc_fruit(f1);
1195.         f1 = f2;
1196.     }
1197.     if (perform_bwrite(mode))
1198.         bwrite(fd, (genericptr_t) &zerofruit, sizeof zerofruit);
1199.     if (release_data(mode))
1200.         ffruit = 0;
1201. }
1202. 
1203. void
1204. store_plname_in_file(fd)
1205. int fd;
1206. {
1207.     int plsiztmp = PL_NSIZ;
1208. 
1209.     bufoff(fd);
1210.     /* bwrite() before bufon() uses plain write() */
1211.     bwrite(fd, (genericptr_t) &plsiztmp, sizeof plsiztmp);
1212.     bwrite(fd, (genericptr_t) plname, plsiztmp);
1213.     bufon(fd);
1214.     return;
1215. }
1216. 
1217. STATIC_OVL void
1218. save_msghistory(fd, mode)
1219. int fd, mode;
1220. {
1221.     char *msg;
1222.     int msgcount = 0, msglen;
1223.     int minusone = -1;
1224.     boolean init = TRUE;
1225. 
1226.     if (perform_bwrite(mode)) {
1227.         /* ask window port for each message in sequence */
1228.         while ((msg = getmsghistory(init)) != 0) {
1229.             init = FALSE;
1230.             msglen = strlen(msg);
1231.             if (msglen < 1)
1232.                 continue;
1233.             /* sanity: truncate if necessary (shouldn't happen);
1234.                no need to modify msg[] since terminator isn't written */
1235.             if (msglen > BUFSZ - 1)
1236.                 msglen = BUFSZ - 1;
1237.             bwrite(fd, (genericptr_t) &msglen, sizeof msglen);
1238.             bwrite(fd, (genericptr_t) msg, msglen);
1239.             ++msgcount;
1240.         }
1241.         bwrite(fd, (genericptr_t) &minusone, sizeof (int));
1242.     }
1243.     debugpline1("Stored %d messages into savefile.", msgcount);
1244.     /* note: we don't attempt to handle release_data() here */
1245. }
1246. 
1247. void
1248. store_savefileinfo(fd)
1249. int fd;
1250. {
1251.     /* sfcap (decl.c) describes the savefile feature capabilities
1252.      * that are supported by this port/platform build.
1253.      *
1254.      * sfsaveinfo (decl.c) describes the savefile info that actually
1255.      * gets written into the savefile, and is used to determine the
1256.      * save file being written.
1257.      *
1258.      * sfrestinfo (decl.c) describes the savefile info that is
1259.      * being used to read the information from an existing savefile.
1260.      */
1261. 
1262.     bufoff(fd);
1263.     /* bwrite() before bufon() uses plain write() */
1264.     bwrite(fd, (genericptr_t) &sfsaveinfo, (unsigned) sizeof sfsaveinfo);
1265.     bufon(fd);
1266.     return;
1267. }
1268. 
1269. void
1270. set_savepref(suitename)
1271. const char *suitename;
1272. {
1273.     if (!strcmpi(suitename, "externalcomp")) {
1274.         saveprocs.name = "externalcomp";
1275.         saveprocs.save_bufon = def_bufon;
1276.         saveprocs.save_bufoff = def_bufoff;
1277.         saveprocs.save_bflush = def_bflush;
1278.         saveprocs.save_bwrite = def_bwrite;
1279.         saveprocs.save_bclose = def_bclose;
1280.         sfsaveinfo.sfi1 |= SFI1_EXTERNALCOMP;
1281.         sfsaveinfo.sfi1 &= ~SFI1_ZEROCOMP;
1282.     }
1283.     if (!strcmpi(suitename, "!rlecomp")) {
1284.         sfsaveinfo.sfi1 &= ~SFI1_RLECOMP;
1285.     }
1286. #ifdef ZEROCOMP
1287.     if (!strcmpi(suitename, "zerocomp")) {
1288.         saveprocs.name = "zerocomp";
1289.         saveprocs.save_bufon = zerocomp_bufon;
1290.         saveprocs.save_bufoff = zerocomp_bufoff;
1291.         saveprocs.save_bflush = zerocomp_bflush;
1292.         saveprocs.save_bwrite = zerocomp_bwrite;
1293.         saveprocs.save_bclose = zerocomp_bclose;
1294.         sfsaveinfo.sfi1 |= SFI1_ZEROCOMP;
1295.         sfsaveinfo.sfi1 &= ~SFI1_EXTERNALCOMP;
1296.     }
1297. #endif
1298. #ifdef RLECOMP
1299.     if (!strcmpi(suitename, "rlecomp")) {
1300.         sfsaveinfo.sfi1 |= SFI1_RLECOMP;
1301.     }
1302. #endif
1303. }
1304. 
1305. /* also called by prscore(); this probably belongs in dungeon.c... */
1306. void
1307. free_dungeons()
1308. {
1309. #ifdef FREE_ALL_MEMORY
1310.     savelevchn(0, FREE_SAVE);
1311.     save_dungeon(0, FALSE, TRUE);
1312. #endif
1313.     return;
1314. }
1315. 
1316. void
1317. freedynamicdata()
1318. {
1319. #if defined(UNIX) && defined(MAIL)
1320.     free_maildata();
1321. #endif
1322.     unload_qtlist();
1323.     free_menu_coloring();
1324.     free_invbuf();           /* let_to_name (invent.c) */
1325.     free_youbuf();           /* You_buf,&c (pline.c) */
1326.     msgtype_free();
1327.     tmp_at(DISP_FREEMEM, 0); /* temporary display effects */
1328. #ifdef FREE_ALL_MEMORY
1329. #define free_current_level() savelev(-1, -1, FREE_SAVE)
1330. #define freeobjchn(X) (saveobjchn(0, X, FREE_SAVE), X = 0)
1331. #define freemonchn(X) (savemonchn(0, X, FREE_SAVE), X = 0)
1332. #define freefruitchn() savefruitchn(0, FREE_SAVE)
1333. #define freenames() savenames(0, FREE_SAVE)
1334. #define free_killers() save_killers(0, FREE_SAVE)
1335. #define free_oracles() save_oracles(0, FREE_SAVE)
1336. #define free_waterlevel() save_waterlevel(0, FREE_SAVE)
1337. #define free_timers(R) save_timers(0, FREE_SAVE, R)
1338. #define free_light_sources(R) save_light_sources(0, FREE_SAVE, R)
1339. #define free_animals() mon_animal_list(FALSE)
1340. 
1341.     /* move-specific data */
1342.     dmonsfree(); /* release dead monsters */
1343. 
1344.     /* level-specific data */
1345.     free_current_level();
1346. 
1347.     /* game-state data [ought to reorganize savegamestate() to handle this] */
1348.     free_killers();
1349.     free_timers(RANGE_GLOBAL);
1350.     free_light_sources(RANGE_GLOBAL);
1351.     freeobjchn(invent);
1352.     freeobjchn(migrating_objs);
1353.     freemonchn(migrating_mons);
1354.     freemonchn(mydogs); /* ascension or dungeon escape */
1355.     /* freelevchn();  --  [folded into free_dungeons()] */
1356.     free_animals();
1357.     free_oracles();
1358.     freefruitchn();
1359.     freenames();
1360.     free_waterlevel();
1361.     free_dungeons();
1362. 
1363.     /* some pointers in iflags */
1364.     if (iflags.wc_font_map)
1365.         free((genericptr_t) iflags.wc_font_map), iflags.wc_font_map = 0;
1366.     if (iflags.wc_font_message)
1367.         free((genericptr_t) iflags.wc_font_message),
1368.         iflags.wc_font_message = 0;
1369.     if (iflags.wc_font_text)
1370.         free((genericptr_t) iflags.wc_font_text), iflags.wc_font_text = 0;
1371.     if (iflags.wc_font_menu)
1372.         free((genericptr_t) iflags.wc_font_menu), iflags.wc_font_menu = 0;
1373.     if (iflags.wc_font_status)
1374.         free((genericptr_t) iflags.wc_font_status), iflags.wc_font_status = 0;
1375.     if (iflags.wc_tile_file)
1376.         free((genericptr_t) iflags.wc_tile_file), iflags.wc_tile_file = 0;
1377.     free_autopickup_exceptions();
1378. 
1379.     /* miscellaneous */
1380.     /* free_pickinv_cache();  --  now done from really_done()... */
1381.     free_symsets();
1382. #endif /* FREE_ALL_MEMORY */
1383.     if (VIA_WINDOWPORT())
1384.         status_finish();
1385. #ifdef DUMPLOG
1386.     dumplogfreemessages();
1387. #endif
1388. 
1389.     /* last, because it frees data that might be used by panic() to provide
1390.        feedback to the user; conceivably other freeing might trigger panic */
1391.     sysopt_release(); /* SYSCF strings */
1392.     return;
1393. }
1394. 
1395. #ifdef MFLOPPY
1396. boolean
1397. swapin_file(lev)
1398. int lev;
1399. {
1400.     char to[PATHLEN], from[PATHLEN];
1401. 
1402.     Sprintf(from, "%s%s", permbones, alllevels);
1403.     Sprintf(to, "%s%s", levels, alllevels);
1404.     set_levelfile_name(from, lev);
1405.     set_levelfile_name(to, lev);
1406.     if (iflags.checkspace) {
1407.         while (level_info[lev].size > freediskspace(to))
1408.             if (!swapout_oldest())
1409.                 return FALSE;
1410.     }
1411.     if (wizard) {
1412.         pline("Swapping in `%s'.", from);
1413.         wait_synch();
1414.     }
1415.     copyfile(from, to);
1416.     (void) unlink(from);
1417.     level_info[lev].where = ACTIVE;
1418.     return TRUE;
1419. }
1420. 
1421. STATIC_OVL boolean
1422. swapout_oldest()
1423. {
1424.     char to[PATHLEN], from[PATHLEN];
1425.     int i, oldest;
1426.     long oldtime;
1427. 
1428.     if (!ramdisk)
1429.         return FALSE;
1430.     for (i = 1, oldtime = 0, oldest = 0; i <= maxledgerno(); i++)
1431.         if (level_info[i].where == ACTIVE
1432.             && (!oldtime || level_info[i].time < oldtime)) {
1433.             oldest = i;
1434.             oldtime = level_info[i].time;
1435.         }
1436.     if (!oldest)
1437.         return FALSE;
1438.     Sprintf(from, "%s%s", levels, alllevels);
1439.     Sprintf(to, "%s%s", permbones, alllevels);
1440.     set_levelfile_name(from, oldest);
1441.     set_levelfile_name(to, oldest);
1442.     if (wizard) {
1443.         pline("Swapping out `%s'.", from);
1444.         wait_synch();
1445.     }
1446.     copyfile(from, to);
1447.     (void) unlink(from);
1448.     level_info[oldest].where = SWAPPED;
1449.     return TRUE;
1450. }
1451. 
1452. STATIC_OVL void
1453. copyfile(from, to)
1454. char *from, *to;
1455. {
1456. #ifdef TOS
1457.     if (_copyfile(from, to))
1458.         panic("Can't copy %s to %s", from, to);
1459. #else
1460.     char buf[BUFSIZ]; /* this is system interaction, therefore
1461.                        * BUFSIZ instead of NetHack's BUFSZ */
1462.     int nfrom, nto, fdfrom, fdto;
1463. 
1464.     if ((fdfrom = open(from, O_RDONLY | O_BINARY, FCMASK)) < 0)
1465.         panic("Can't copy from %s !?", from);
1466.     if ((fdto = open(to, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, FCMASK)) < 0)
1467.         panic("Can't copy to %s", to);
1468.     do {
1469.         nfrom = read(fdfrom, buf, BUFSIZ);
1470.         nto = write(fdto, buf, nfrom);
1471.         if (nto != nfrom)
1472.             panic("Copyfile failed!");
1473.     } while (nfrom == BUFSIZ);
1474.     (void) nhclose(fdfrom);
1475.     (void) nhclose(fdto);
1476. #endif /* TOS */
1477. }
1478. 
1479. /* see comment in bones.c */
1480. void
1481. co_false()
1482. {
1483.     count_only = FALSE;
1484.     return;
1485. }
1486. 
1487. #endif /* MFLOPPY */
1488. 
1489. /*save.c*/