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