Source:NetHack 3.6.5/src/save.c
Jump to navigation
Jump to search
Below is the full text to save.c from the source code of NetHack 3.6.5. To link to a particular line, write [[Source:NetHack 3.6.5/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) <mp, 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*/