Source:Save.c

Below is the full text to src/save.c from NetHack 3.4.3. To link to a particular line, write [[save.c#line123 ]], for example. 1.   /*	SCCS Id: @(#)save.c	3.4	2003/11/14	*/ 2.   /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */ 3.    /* NetHack may be freely redistributed. See license for details. */ 4.

5.   #include "hack.h"  6.    #include "lev.h"  7.    #include "quest.h"  8. 9.   #ifndef NO_SIGNAL 10.  #include   11. #endif 12.  #if !defined(LSC) && !defined(O_WRONLY) && !defined(AZTEC_C) 13.  #include   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.   #ifdef ZEROCOMP 26.  STATIC_DCL void FDECL(bputc, (int)); 27.  #endif 28.  STATIC_DCL void FDECL(savelevchn, (int,int)); 29.  STATIC_DCL void FDECL(savedamage, (int,int)); 30.  STATIC_DCL void FDECL(saveobjchn, (int,struct obj *,int)); 31.  STATIC_DCL void FDECL(savemonchn, (int,struct monst *,int)); 32.  STATIC_DCL void FDECL(savetrapchn, (int,struct trap *,int)); 33.  STATIC_DCL void FDECL(savegamestate, (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.  #ifdef GCC_WARN 40.  static long nulls[10]; 41.  #else 42.  #define nulls nul 43.  #endif 44.   45.   #if defined(UNIX) || defined(VMS) || defined(__EMX__) || defined(WIN32) 46.  #define HUP	if (!program_state.done_hup) 47.  #else 48.  #define HUP 49.  #endif 50.   51.   /* need to preserve these during save to avoid accessing freed memory */ 52.  static unsigned ustuck_id = 0, usteed_id = 0; 53.   54.   int 55.  dosave 56.  {  57.   	clear_nhwindow(WIN_MESSAGE); 58.  	if(yn("Really save?") == 'n') { 59.  		clear_nhwindow(WIN_MESSAGE); 60.  		if(multi > 0) nomul(0); 61.  	} else { 62.  		clear_nhwindow(WIN_MESSAGE); 63.  		pline("Saving..."); 64.  #if defined(UNIX) || defined(VMS) || defined(__EMX__) 65.  		program_state.done_hup = 0; 66.  #endif 67.  		if(dosave0) { 68.  			program_state.something_worth_saving = 0; 69.  			u.uhp = -1;		/* universal game's over indicator */ 70.  			/* make sure they see the Saving message */ 71.  			display_nhwindow(WIN_MESSAGE, TRUE); 72.  			exit_nhwindows("Be seeing you..."); 73.  			terminate(EXIT_SUCCESS); 74.  		} else (void)doredraw; 75.  	}  76.   	return 0; 77.  }  78.    79.    80.   #if defined(UNIX) || defined(VMS) || defined (__EMX__) || defined(WIN32) 81.  /*ARGSUSED*/ 82.  void 83.  hangup(sig_unused)  /* called as signal handler, so sent at least one arg */ 84.  int sig_unused; 85.  {  86.   # ifdef NOSAVEONHANGUP 87.  	(void) signal(SIGINT, SIG_IGN); 88.  	clearlocks; 89.  #  ifndef VMS 90.  	terminate(EXIT_FAILURE); 91.  #  endif 92.  # else	/* SAVEONHANGUP */ 93.  	if (!program_state.done_hup++) { 94.  	    if (program_state.something_worth_saving) 95.  		(void) dosave0; 96.  #  ifdef VMS 97.  	    /* don't call exit when already within an exit handler; 98.  	       that would cancel any other pending user-mode handlers */ 99.  	    if (!program_state.exiting) 100. #  endif 101. 	    {  102.  		clearlocks; 103. 		terminate(EXIT_FAILURE); 104. 	    }  105.  	}  106.  # endif 107. 	return; 108. }  109.  #endif 110.  111.  /* returns 1 if save successful */ 112. int 113. dosave0 114. {  115.  	const char *fq_save; 116. 	register int fd, ofd; 117. 	xchar ltmp; 118. 	d_level uz_save; 119. 	char whynot[BUFSZ]; 120.  121.  	if (!SAVEF[0]) 122. 		return 0; 123. 	fq_save = fqname(SAVEF, SAVEPREFIX, 1);	/* level files take 0 */ 124.  125.  #if defined(UNIX) || defined(VMS) 126. 	(void) signal(SIGHUP, SIG_IGN); 127. #endif 128. #ifndef NO_SIGNAL 129. 	(void) signal(SIGINT, SIG_IGN); 130. #endif 131.  132.  #if defined(MICRO) && defined(MFLOPPY) 133. 	if (!saveDiskPrompt(0)) return 0; 134. #endif 135.  136.  	HUP if (iflags.window_inited) { 137. 	    uncompress(fq_save); 138. 	    fd = open_savefile; 139. 	    if (fd > 0) { 140. 		(void) close(fd); 141. 		clear_nhwindow(WIN_MESSAGE); 142. 		There("seems to be an old save file."); 143. 		if (yn("Overwrite the old file?") == 'n') { 144. 		    compress(fq_save); 145. 		    return 0; 146. 		}  147.  	    }  148.  	}  149.   150.  	HUP mark_synch;	/* flush any buffered screen output */ 151.  152.  	fd = create_savefile; 153. 	if(fd < 0) { 154. 		HUP pline("Cannot open save file."); 155. 		(void) delete_savefile;	/* ab@unido */ 156. 		return(0); 157. 	}  158.   159.  	vision_recalc(2);	/* shut down vision to prevent problems 160. 				   in the event of an impossible call */ 161. 	  162.  	/* undo date-dependent luck adjustments made at startup time */ 163. 	if(flags.moonphase == FULL_MOON)	/* ut-sally!fletcher */ 164. 		change_luck(-1);		/* and unido!ab */ 165. 	if(flags.friday13) 166. 		change_luck(1); 167. 	if(iflags.window_inited) 168. 	    HUP clear_nhwindow(WIN_MESSAGE); 169.  170.  #ifdef MICRO 171. 	dotcnt = 0; 172. 	dotrow = 2; 173. 	curs(WIN_MAP, 1, 1); 174. 	if (strncmpi("X11", windowprocs.name, 3)) 175. 	  putstr(WIN_MAP, 0, "Saving:"); 176. #endif 177. #ifdef MFLOPPY 178. 	/* make sure there is enough disk space */ 179. 	if (iflags.checkspace) { 180. 	    long fds, needed; 181.  182.  	    savelev(fd, ledger_no(&u.uz), COUNT_SAVE); 183. 	    savegamestate(fd, COUNT_SAVE); 184. 	    needed = bytes_counted; 185.  186.  	    for (ltmp = 1; ltmp <= maxledgerno; ltmp++) 187. 		if (ltmp != ledger_no(&u.uz) && level_info[ltmp].where) 188. 		    needed += level_info[ltmp].size + (sizeof ltmp); 189. 	    fds = freediskspace(fq_save); 190. 	    if (needed > fds) { 191. 		HUP { 192. 		    There("is insufficient space on SAVE disk."); 193. 		    pline("Require %ld bytes but only have %ld.", needed, fds); 194. 		}  195.  		flushout; 196. 		(void) close(fd); 197. 		(void) delete_savefile; 198. 		return 0; 199. 	    }  200.   201.  	    co_false; 202. 	}  203.  #endif /* MFLOPPY */ 204.  205.  	store_version(fd); 206. #ifdef STORE_PLNAME_IN_FILE 207. 	bwrite(fd, (genericptr_t) plname, PL_NSIZ); 208. #endif 209. 	ustuck_id = (u.ustuck ? u.ustuck->m_id : 0); 210. #ifdef STEED 211. 	usteed_id = (u.usteed ? u.usteed->m_id : 0); 212. #endif 213. 	savelev(fd, ledger_no(&u.uz), WRITE_SAVE | FREE_SAVE); 214. 	savegamestate(fd, WRITE_SAVE | FREE_SAVE); 215.  216.  	/* While copying level files around, zero out u.uz to keep 217. 	 * parts of the restore code from completely initializing all 218. 	 * in-core data structures, since all we're doing is copying. 219. 	 * This also avoids at least one nasty core dump. 220. 	 */  221.  	uz_save = u.uz; 222. 	u.uz.dnum = u.uz.dlevel = 0; 223. 	/* these pointers are no longer valid, and at least u.usteed 224. 	 * may mislead place_monster on other levels 225. 	 */  226.  	u.ustuck = (struct monst *)0; 227. #ifdef STEED 228. 	u.usteed = (struct monst *)0; 229. #endif 230.  231.  	for(ltmp = (xchar)1; ltmp <= maxledgerno; ltmp++) { 232. 		if (ltmp == ledger_no(&uz_save)) continue; 233. 		if (!(level_info[ltmp].flags & LFILE_EXISTS)) continue; 234. #ifdef MICRO 235. 		curs(WIN_MAP, 1 + dotcnt++, dotrow); 236. 		if (dotcnt >= (COLNO - 1)) { 237. 			dotrow++; 238. 			dotcnt = 0; 239. 		}  240.  		if (strncmpi("X11", windowprocs.name, 3)){ 241. 		  putstr(WIN_MAP, 0, "."); 242. 		}  243.  		mark_synch; 244. #endif 245. 		ofd = open_levelfile(ltmp, whynot); 246. 		if (ofd < 0) { 247. 		    HUP pline("%s", whynot); 248. 		    (void) close(fd); 249. 		    (void) delete_savefile; 250. 		    HUP killer = whynot; 251. 		    HUP done(TRICKED); 252. 		    return(0); 253. 		}  254.  		minit;	/* ZEROCOMP */ 255. 		getlev(ofd, hackpid, ltmp, FALSE); 256. 		(void) close(ofd); 257. 		bwrite(fd, (genericptr_t) &ltmp, sizeof ltmp); /* level number*/ 258. 		savelev(fd, ltmp, WRITE_SAVE | FREE_SAVE);     /* actual level*/ 259. 		delete_levelfile(ltmp); 260. 	}  261.  	bclose(fd); 262.  263.  	u.uz = uz_save; 264.  265.  	/* get rid of current level --jgm */ 266. 	delete_levelfile(ledger_no(&u.uz)); 267. 	delete_levelfile(0); 268. 	compress(fq_save); 269. 	return(1); 270. }  271.   272.  STATIC_OVL void 273. savegamestate(fd, mode) 274. register int fd, mode; 275. {  276.  	int uid; 277.  278.  #ifdef MFLOPPY 279. 	count_only = (mode & COUNT_SAVE); 280. #endif 281. 	uid = getuid; 282. 	bwrite(fd, (genericptr_t) &uid, sizeof uid); 283. 	bwrite(fd, (genericptr_t) &flags, sizeof(struct flag)); 284. 	bwrite(fd, (genericptr_t) &u, sizeof(struct you)); 285.  286.  	/* must come before migrating_objs and migrating_mons are freed */ 287. 	save_timers(fd, mode, RANGE_GLOBAL); 288. 	save_light_sources(fd, mode, RANGE_GLOBAL); 289.  290.  	saveobjchn(fd, invent, mode); 291. 	saveobjchn(fd, migrating_objs, mode); 292. 	savemonchn(fd, migrating_mons, mode); 293. 	if (release_data(mode)) { 294. 	    invent = 0; 295. 	    migrating_objs = 0; 296. 	    migrating_mons = 0; 297. 	}  298.  	bwrite(fd, (genericptr_t) mvitals, sizeof(mvitals)); 299.  300.  	save_dungeon(fd, (boolean)!!perform_bwrite(mode),  301.  			 (boolean)!!release_data(mode)); 302. 	savelevchn(fd, mode); 303. 	bwrite(fd, (genericptr_t) &moves, sizeof moves); 304. 	bwrite(fd, (genericptr_t) &monstermoves, sizeof monstermoves); 305. 	bwrite(fd, (genericptr_t) &quest_status, sizeof(struct q_score)); 306. 	bwrite(fd, (genericptr_t) spl_book,  307.  				sizeof(struct spell) * (MAXSPELL + 1)); 308. 	save_artifacts(fd); 309. 	save_oracles(fd, mode); 310. 	if(ustuck_id) 311. 	    bwrite(fd, (genericptr_t) &ustuck_id, sizeof ustuck_id); 312. #ifdef STEED 313. 	if(usteed_id) 314. 	    bwrite(fd, (genericptr_t) &usteed_id, sizeof usteed_id); 315. #endif 316. 	bwrite(fd, (genericptr_t) pl_character, sizeof pl_character); 317. 	bwrite(fd, (genericptr_t) pl_fruit, sizeof pl_fruit); 318. 	bwrite(fd, (genericptr_t) &current_fruit, sizeof current_fruit); 319. 	savefruitchn(fd, mode); 320. 	savenames(fd, mode); 321. 	save_waterlevel(fd, mode); 322. 	bflush(fd); 323. }  324.   325.  #ifdef INSURANCE 326. void 327. savestateinlock 328. {  329.  	int fd, hpid; 330. 	static boolean havestate = TRUE; 331. 	char whynot[BUFSZ]; 332.  333.  	/* When checkpointing is on, the full state needs to be written 334. 	 * on each checkpoint. When checkpointing is off, only the pid 335. 	 * needs to be in the level.0 file, so it does not need to be  336. * constantly rewritten. When checkpointing is turned off during 337. 	 * a game, however, the file has to be rewritten once to truncate 338. 	 * it and avoid restoring from outdated information. 339. 	 *  340.  	 * Restricting havestate to this routine means that an additional 341. 	 * noop pid rewriting will take place on the first "checkpoint" after 342. 	 * the game is started or restored, if checkpointing is off. 343. 	 */  344.  	if (flags.ins_chkpt || havestate) { 345. 		/* save the rest of the current game state in the lock file, 346. 		 * following the original int pid, the current level number, 347. 		 * and the current savefile name, which should not be subject 348. 		 * to any internal compression schemes since they must be  349. * readable by an external utility 350. 		 */  351.  		fd = open_levelfile(0, whynot); 352. 		if (fd < 0) { 353. 		    pline("%s", whynot); 354. 		    pline("Probably someone removed it."); 355. 		    killer = whynot; 356. 		    done(TRICKED); 357. 		    return; 358. 		}  359.   360.  		(void) read(fd, (genericptr_t) &hpid, sizeof(hpid)); 361. 		if (hackpid != hpid) { 362. 		    Sprintf(whynot,  363.  			    "Level #0 pid (%d) doesn't match ours (%d)!",  364.  			    hpid, hackpid); 365. 		    pline("%s", whynot); 366. 		    killer = whynot; 367. 		    done(TRICKED); 368. 		}  369.  		(void) close(fd); 370.  371.  		fd = create_levelfile(0, whynot); 372. 		if (fd < 0) { 373. 		    pline("%s", whynot); 374. 		    killer = whynot; 375. 		    done(TRICKED); 376. 		    return; 377. 		}  378.  		(void) write(fd, (genericptr_t) &hackpid, sizeof(hackpid)); 379. 		if (flags.ins_chkpt) { 380. 		    int currlev = ledger_no(&u.uz); 381.  382.  		    (void) write(fd, (genericptr_t) &currlev, sizeof(currlev)); 383. 		    save_savefile_name(fd); 384. 		    store_version(fd); 385. #ifdef STORE_PLNAME_IN_FILE 386. 		    bwrite(fd, (genericptr_t) plname, PL_NSIZ); 387. #endif 388. 		    ustuck_id = (u.ustuck ? u.ustuck->m_id : 0); 389. #ifdef STEED 390. 		    usteed_id = (u.usteed ? u.usteed->m_id : 0); 391. #endif 392. 		    savegamestate(fd, WRITE_SAVE); 393. 		}  394.  		bclose(fd); 395. 	}  396.  	havestate = flags.ins_chkpt; 397. }  398.  #endif 399.  400.  #ifdef MFLOPPY 401. boolean 402. savelev(fd, lev, mode) 403. int fd; 404. xchar lev; 405. int mode; 406. {  407.  	if (mode & COUNT_SAVE) { 408. 		bytes_counted = 0; 409. 		savelev0(fd, lev, COUNT_SAVE); 410. 		/* probably bytes_counted will be filled in again by an  411. * immediately following WRITE_SAVE anyway, but we'll 412. * leave it out of checkspace just in case */ 413. 		if (iflags.checkspace) { 414. 			while (bytes_counted > freediskspace(levels)) 415. 				if (!swapout_oldest) 416. 					return FALSE; 417. 		}  418.  	}  419.  	if (mode & (WRITE_SAVE | FREE_SAVE)) { 420. 		bytes_counted = 0; 421. 		savelev0(fd, lev, mode); 422. 	}  423.  	if (mode != FREE_SAVE) { 424. 		level_info[lev].where = ACTIVE; 425. 		level_info[lev].time = moves; 426. 		level_info[lev].size = bytes_counted; 427. 	}  428.  	return TRUE; 429. }  430.   431.  STATIC_OVL void 432. savelev0(fd,lev,mode) 433. #else 434. void 435. savelev(fd,lev,mode) 436. #endif 437. int fd; 438. xchar lev; 439. int mode; 440. {  441.  #ifdef TOS 442. 	short tlev; 443. #endif 444.  445.  	/* if we're tearing down the current level without saving anything 446. 	   (which happens upon entrance to the endgame or after an aborted  447.  	   restore attempt) then we don't want to do any actual I/O */ 448. 	if (mode == FREE_SAVE) goto skip_lots; 449. 	if (iflags.purge_monsters) { 450. 		/* purge any dead monsters (necessary if we're starting  451.  		 * a panic save rather than a normal one, or sometimes  452.  		 * when changing levels without taking time -- e.g.  453.  		 * create statue trap then immediately level teleport) */ 454. 		dmonsfree; 455. 	}  456.   457.  	if(fd < 0) panic("Save on bad file!");	/* impossible */ 458. #ifdef MFLOPPY 459. 	count_only = (mode & COUNT_SAVE); 460. #endif 461. 	if (lev >= 0 && lev <= maxledgerno) 462. 	    level_info[lev].flags |= VISITED; 463. 	bwrite(fd,(genericptr_t) &hackpid,sizeof(hackpid)); 464. #ifdef TOS 465. 	tlev=lev; tlev &= 0x00ff; 466. 	bwrite(fd,(genericptr_t) &tlev,sizeof(tlev)); 467. #else 468. 	bwrite(fd,(genericptr_t) &lev,sizeof(lev)); 469. #endif 470. #ifdef RLECOMP 471. 	{  472.  	    /* perform run-length encoding of rm structs */ 473. 	    struct rm *prm, *rgrm; 474. 	    int x, y;  475. uchar match; 476.  477.  	    rgrm = &levl[0][0];		/* start matching at first rm */ 478. 	    match = 0; 479.  480.  	    for (y = 0; y < ROWNO; y++) { 481. 		for (x = 0; x < COLNO; x++) { 482. 		    prm = &levl[x][y]; 483. 		    if (prm->glyph == rgrm->glyph  484.  			&& prm->typ == rgrm->typ  485.  			&& prm->seenv == rgrm->seenv  486.  			&& prm->horizontal == rgrm->horizontal  487.  			&& prm->flags == rgrm->flags  488.  			&& prm->lit == rgrm->lit  489.  			&& prm->waslit == rgrm->waslit  490.  			&& prm->roomno == rgrm->roomno  491.  			&& prm->edge == rgrm->edge) { 492. 			match++; 493. 			if (match > 254) { 494. 			    match = 254;	/* undo this match */ 495. 			    goto writeout; 496. 			}  497.  		    } else { 498. 			/* the run has been broken, 499. 			 * write out run-length encoding */ 500. 		    writeout: 501. 			bwrite(fd, (genericptr_t)&match, sizeof(uchar)); 502. 			bwrite(fd, (genericptr_t)rgrm, sizeof(struct rm)); 503. 			/* start encoding again. we have at least 1 rm 504. * in the next run, viz. this one. */ 505.  			match = 1; 506. 			rgrm = prm; 507. 		    }  508.  		}  509.  	    }  510.  	    if (match > 0) { 511. 		bwrite(fd, (genericptr_t)&match, sizeof(uchar)); 512. 		bwrite(fd, (genericptr_t)rgrm, sizeof(struct rm)); 513. 	    }  514.  	}  515.  #else 516. 	bwrite(fd,(genericptr_t) levl,sizeof(levl)); 517. #endif /* RLECOMP */ 518.  519.  	bwrite(fd,(genericptr_t) &monstermoves,sizeof(monstermoves)); 520. 	bwrite(fd,(genericptr_t) &upstair,sizeof(stairway)); 521. 	bwrite(fd,(genericptr_t) &dnstair,sizeof(stairway)); 522. 	bwrite(fd,(genericptr_t) &upladder,sizeof(stairway)); 523. 	bwrite(fd,(genericptr_t) &dnladder,sizeof(stairway)); 524. 	bwrite(fd,(genericptr_t) &sstairs,sizeof(stairway)); 525. 	bwrite(fd,(genericptr_t) &updest,sizeof(dest_area)); 526. 	bwrite(fd,(genericptr_t) &dndest,sizeof(dest_area)); 527. 	bwrite(fd,(genericptr_t) &level.flags,sizeof(level.flags)); 528. 	bwrite(fd, (genericptr_t) doors, sizeof(doors)); 529. 	save_rooms(fd);	/* no dynamic memory to reclaim */ 530.  531.  	/* from here on out, saving also involves allocated memory cleanup */ 532.  skip_lots: 533. 	/* must be saved before mons, objs, and buried objs */ 534. 	save_timers(fd, mode, RANGE_LEVEL); 535. 	save_light_sources(fd, mode, RANGE_LEVEL); 536.  537.  	savemonchn(fd, fmon, mode); 538. 	save_worm(fd, mode);	/* save worm information */ 539. 	savetrapchn(fd, ftrap, mode); 540. 	saveobjchn(fd, fobj, mode); 541. 	saveobjchn(fd, level.buriedobjlist, mode); 542. 	saveobjchn(fd, billobjs, mode); 543. 	if (release_data(mode)) { 544. 	    fmon = 0; 545. 	    ftrap = 0; 546. 	    fobj = 0; 547. 	    level.buriedobjlist = 0; 548. 	    billobjs = 0; 549. 	}  550.  	save_engravings(fd, mode); 551. 	savedamage(fd, mode); 552. 	save_regions(fd, mode); 553. 	if (mode != FREE_SAVE) bflush(fd); 554. }  555.   556.  #ifdef ZEROCOMP 557. /* The runs of zero-run compression are flushed after the game state or a  558. * level is written out. This adds a couple bytes to a save file, where 559.  * the runs could be mashed together, but it allows gluing together game 560.  * state and level files to form a save file, and it means the flushing 561.  * does not need to be specifically called for every other time a level 562.  * file is written out. 563.  */  564.   565.  #define RLESC '\0'    /* Leading character for run of LRESC's */ 566. #define flushoutrun(ln) (bputc(RLESC), bputc(ln), ln = -1) 567.  568.  #ifndef ZEROCOMP_BUFSIZ 569. # define ZEROCOMP_BUFSIZ BUFSZ 570. #endif 571. static NEARDATA unsigned char outbuf[ZEROCOMP_BUFSIZ]; 572. static NEARDATA unsigned short outbufp = 0; 573. static NEARDATA short outrunlength = -1; 574. static NEARDATA int bwritefd; 575. static NEARDATA boolean compressing = FALSE; 576.  577.  /*dbg 578. {  579.      HUP printf("outbufp %d outrunlength %d\n", outbufp,outrunlength); 580. }*/  581.   582.  STATIC_OVL void 583. bputc(c) 584. int c;  585. { 586.  #ifdef MFLOPPY 587.     bytes_counted++; 588.     if (count_only) 589.       return; 590. #endif 591.     if (outbufp >= sizeof outbuf) { 592. 	(void) write(bwritefd, outbuf, sizeof outbuf); 593. 	outbufp = 0; 594.     }  595.      outbuf[outbufp++] = (unsigned char)c; 596. }  597.   598.  /*ARGSUSED*/ 599. void 600. bufon(fd) 601. int fd; 602. {  603.      compressing = TRUE; 604.     return; 605. }  606.   607.  /*ARGSUSED*/ 608. void 609. bufoff(fd) 610. int fd; 611. {  612.      if (outbufp) { 613. 	outbufp = 0; 614. 	panic("closing file with buffered data still unwritten"); 615.     }  616.      outrunlength = -1; 617.     compressing = FALSE; 618.     return; 619. }  620.   621.  void 622. bflush(fd)  /* flush run and buffer */ 623. register int fd; 624. {  625.      bwritefd = fd; 626.     if (outrunlength >= 0) {	/* flush run */ 627. 	flushoutrun(outrunlength); 628.     }  629.  #ifdef MFLOPPY 630.     if (count_only) outbufp = 0; 631. #endif 632.  633.      if (outbufp) { 634. 	if (write(fd, outbuf, outbufp) != outbufp) { 635. #if defined(UNIX) || defined(VMS) || defined(__EMX__) 636. 	    if (program_state.done_hup) 637. 		terminate(EXIT_FAILURE); 638. 	    else 639. #endif 640. 		bclose(fd);	/* panic (outbufp != 0) */ 641. 	}  642.  	outbufp = 0; 643.     }  644.  }  645.   646.  void 647. bwrite(fd, loc, num) 648. int fd; 649. genericptr_t loc; 650. register unsigned num; 651. {  652.      register unsigned char *bp = (unsigned char *)loc; 653.  654.      if (!compressing) { 655. #ifdef MFLOPPY 656. 	bytes_counted += num; 657. 	if (count_only) return; 658. #endif 659. 	if ((unsigned) write(fd, loc, num) != num) { 660. #if defined(UNIX) || defined(VMS) || defined(__EMX__) 661. 	    if (program_state.done_hup) 662. 		terminate(EXIT_FAILURE); 663. 	    else 664. #endif 665. 		panic("cannot write %u bytes to file #%d", num, fd); 666. 	}  667.      } else { 668. 	bwritefd = fd; 669. 	for (num; num--, bp++) { 670. 	    if (*bp == RLESC) {	/* One more char in run */ 671. 		if (++outrunlength == 0xFF) { 672. 		    flushoutrun(outrunlength); 673. 		}  674.  	    } else {		/* end of run */ 675. 		if (outrunlength >= 0) {	/* flush run */ 676. 		    flushoutrun(outrunlength); 677. 		}  678.  		bputc(*bp); 679. 	    }  680.  	}  681.      }  682.  }  683.   684.  void 685. bclose(fd) 686. int fd; 687. {  688.      bufoff(fd); 689.     (void) close(fd); 690.     return; 691. }  692.   693.  #else /* ZEROCOMP */ 694.  695.  static int bw_fd = -1; 696. static FILE *bw_FILE = 0; 697. static boolean buffering = FALSE; 698.  699.  void 700. bufon(fd) 701.     int fd; 702. {  703.  #ifdef UNIX 704.     if(bw_fd >= 0) 705. 	panic("double buffering unexpected"); 706.     bw_fd = fd; 707.     if((bw_FILE = fdopen(fd, "w")) == 0) 708. 	panic("buffering of file %d failed", fd); 709. #endif 710.     buffering = TRUE; 711. }  712.   713.  void 714. bufoff(fd) 715. int fd; 716. {  717.      bflush(fd); 718.     buffering = FALSE; 719. }  720.   721.  void 722. bflush(fd) 723.     int fd; 724. {  725.  #ifdef UNIX 726.     if(fd == bw_fd) { 727. 	if(fflush(bw_FILE) == EOF) 728. 	    panic("flush of savefile failed!"); 729.     }  730.  #endif 731.     return; 732. }  733.   734.  void 735. bwrite(fd,loc,num) 736. register int fd; 737. register genericptr_t loc; 738. register unsigned num; 739. {  740.  	boolean failed; 741.  742.  #ifdef MFLOPPY 743. 	bytes_counted += num; 744. 	if (count_only) return; 745. #endif 746.  747.  #ifdef UNIX 748. 	if (buffering) { 749. 	    if(fd != bw_fd) 750. 		panic("unbuffered write to fd %d (!= %d)", fd, bw_fd); 751.  752.  	    failed = (fwrite(loc, (int)num, 1, bw_FILE) != 1); 753. 	} else 754. #endif /* UNIX */ 755. 	{  756.  /* lint wants the 3rd arg of write to be an int; lint -p an unsigned */ 757. #if defined(BSD) || defined(ULTRIX) 758. 	    failed = (write(fd, loc, (int)num) != (int)num); 759. #else /* e.g. SYSV, __TURBOC__ */ 760. 	    failed = (write(fd, loc, num) != num); 761. #endif 762. 	}  763.   764.  	if (failed) { 765. #if defined(UNIX) || defined(VMS) || defined(__EMX__) 766. 	    if (program_state.done_hup) 767. 		terminate(EXIT_FAILURE); 768. 	    else 769. #endif 770. 		panic("cannot write %u bytes to file #%d", num, fd); 771. 	}  772.  }  773.   774.  void 775. bclose(fd) 776.     int fd; 777. {  778.      bufoff(fd); 779. #ifdef UNIX 780.     if (fd == bw_fd) { 781. 	(void) fclose(bw_FILE); 782. 	bw_fd = -1; 783. 	bw_FILE = 0; 784.     } else 785. #endif 786. 	(void) close(fd); 787.     return; 788. }  789.  #endif /* ZEROCOMP */ 790.  791.  STATIC_OVL void 792. savelevchn(fd, mode) 793. register int fd, mode; 794. {  795.  	s_level	*tmplev, *tmplev2; 796. 	int cnt = 0; 797.  798.  	for (tmplev = sp_levchn; tmplev; tmplev = tmplev->next) cnt++; 799. 	if (perform_bwrite(mode)) 800. 	    bwrite(fd, (genericptr_t) &cnt, sizeof(int)); 801.  802.  	for (tmplev = sp_levchn; tmplev; tmplev = tmplev2) { 803. 	    tmplev2 = tmplev->next; 804. 	    if (perform_bwrite(mode)) 805. 		bwrite(fd, (genericptr_t) tmplev, sizeof(s_level)); 806. 	    if (release_data(mode)) 807. 		free((genericptr_t) tmplev); 808. 	}  809.  	if (release_data(mode)) 810. 	    sp_levchn = 0; 811. }  812.   813.  STATIC_OVL void 814. savedamage(fd, mode) 815. register int fd, mode; 816. {  817.  	register struct damage *damageptr, *tmp_dam; 818. 	unsigned int xl = 0; 819.  820.  	damageptr = level.damagelist; 821. 	for (tmp_dam = damageptr; tmp_dam; tmp_dam = tmp_dam->next) 822. 	    xl++; 823. 	if (perform_bwrite(mode)) 824. 	    bwrite(fd, (genericptr_t) &xl, sizeof(xl)); 825.  826.  	while (xl--) { 827. 	    if (perform_bwrite(mode)) 828. 		bwrite(fd, (genericptr_t) damageptr, sizeof(*damageptr)); 829. 	    tmp_dam = damageptr; 830. 	    damageptr = damageptr->next; 831. 	    if (release_data(mode)) 832. 		free((genericptr_t)tmp_dam); 833. 	}  834.  	if (release_data(mode)) 835. 	    level.damagelist = 0; 836. }  837.   838.  STATIC_OVL void 839. saveobjchn(fd, otmp, mode) 840. register int fd, mode; 841. register struct obj *otmp; 842. {  843.  	register struct obj *otmp2; 844. 	unsigned int xl; 845. 	int minusone = -1; 846.  847.  	while(otmp) { 848. 	    otmp2 = otmp->nobj; 849. 	    if (perform_bwrite(mode)) { 850. 		xl = otmp->oxlth + otmp->onamelth; 851. 		bwrite(fd, (genericptr_t) &xl, sizeof(int)); 852. 		bwrite(fd, (genericptr_t) otmp, xl + sizeof(struct obj)); 853. 	    }  854.  	    if (Has_contents(otmp)) 855. 		saveobjchn(fd,otmp->cobj,mode); 856. 	    if (release_data(mode)) { 857. 		if (otmp->oclass == FOOD_CLASS) food_disappears(otmp); 858. 		if (otmp->oclass == SPBOOK_CLASS) book_disappears(otmp); 859. 		otmp->where = OBJ_FREE;	/* set to free so dealloc will work */ 860. 		otmp->timed = 0;	/* not timed any more */ 861. 		otmp->lamplit = 0;	/* caller handled lights */ 862. 		dealloc_obj(otmp); 863. 	    }  864.  	    otmp = otmp2; 865. 	}  866.  	if (perform_bwrite(mode)) 867. 	    bwrite(fd, (genericptr_t) &minusone, sizeof(int)); 868. }  869.   870.  STATIC_OVL void 871. savemonchn(fd, mtmp, mode) 872. register int fd, mode; 873. register struct monst *mtmp; 874. {  875.  	register struct monst *mtmp2; 876. 	unsigned int xl; 877. 	int minusone = -1; 878. 	struct permonst *monbegin = &mons[0]; 879.  880.  	if (perform_bwrite(mode)) 881. 	    bwrite(fd, (genericptr_t) &monbegin, sizeof(monbegin)); 882.  883.  	while (mtmp) { 884. 	    mtmp2 = mtmp->nmon; 885. 	    if (perform_bwrite(mode)) { 886. 		xl = mtmp->mxlth + mtmp->mnamelth; 887. 		bwrite(fd, (genericptr_t) &xl, sizeof(int)); 888. 		bwrite(fd, (genericptr_t) mtmp, xl + sizeof(struct monst)); 889. 	    }  890.  	    if (mtmp->minvent) 891. 		saveobjchn(fd,mtmp->minvent,mode); 892. 	    if (release_data(mode)) 893. 		dealloc_monst(mtmp); 894. 	    mtmp = mtmp2; 895. 	}  896.  	if (perform_bwrite(mode)) 897. 	    bwrite(fd, (genericptr_t) &minusone, sizeof(int)); 898. }  899.   900.  STATIC_OVL void 901. savetrapchn(fd, trap, mode) 902. register int fd, mode; 903. register struct trap *trap; 904. {  905.  	register struct trap *trap2; 906.  907.  	while (trap) { 908. 	    trap2 = trap->ntrap; 909. 	    if (perform_bwrite(mode)) 910. 		bwrite(fd, (genericptr_t) trap, sizeof(struct trap)); 911. 	    if (release_data(mode)) 912. 		dealloc_trap(trap); 913. 	    trap = trap2; 914. 	}  915.  	if (perform_bwrite(mode)) 916. 	    bwrite(fd, (genericptr_t)nulls, sizeof(struct trap)); 917. }  918.   919.  /* save all the fruit names and ID's; this is used only in saving whole games 920.  * (not levels) and in saving bones levels. When saving a bones level, 921.  * we only want to save the fruits which exist on the bones level; the bones 922.  * level routine marks nonexistent fruits by making the fid negative. 923.  */  924.  void 925. savefruitchn(fd, mode) 926. register int fd, mode; 927. {  928.  	register struct fruit *f2, *f1; 929.  930.  	f1 = ffruit; 931. 	while (f1) { 932. 	    f2 = f1->nextf; 933. 	    if (f1->fid >= 0 && perform_bwrite(mode)) 934. 		bwrite(fd, (genericptr_t) f1, sizeof(struct fruit)); 935. 	    if (release_data(mode)) 936. 		dealloc_fruit(f1); 937. 	    f1 = f2; 938. 	}  939.  	if (perform_bwrite(mode)) 940. 	    bwrite(fd, (genericptr_t)nulls, sizeof(struct fruit)); 941. 	if (release_data(mode)) 942. 	    ffruit = 0; 943. }  944.   945.  /* also called by prscore; this probably belongs in dungeon.c... */ 946.  void 947. free_dungeons 948. {  949.  #ifdef FREE_ALL_MEMORY 950. 	savelevchn(0, FREE_SAVE); 951. 	save_dungeon(0, FALSE, TRUE); 952. #endif 953. 	return; 954. }  955.   956.  void 957. freedynamicdata 958. {  959.  	unload_qtlist; 960. 	free_invbuf;	/* let_to_name (invent.c) */ 961. 	free_youbuf;	/* You_buf,&c (pline.c) */ 962. 	tmp_at(DISP_FREEMEM, 0);	/* temporary display effects */ 963. #ifdef FREE_ALL_MEMORY 964. # define freeobjchn(X)	(saveobjchn(0, X, FREE_SAVE),  X = 0) 965. # define freemonchn(X)	(savemonchn(0, X, FREE_SAVE),  X = 0) 966. # define freetrapchn(X)	(savetrapchn(0, X, FREE_SAVE), X = 0) 967. # define freefruitchn	 savefruitchn(0, FREE_SAVE) 968. # define freenames	 savenames(0, FREE_SAVE) 969. # define free_oracles	save_oracles(0, FREE_SAVE) 970. # define free_waterlevel save_waterlevel(0, FREE_SAVE) 971. # define free_worm	 save_worm(0, FREE_SAVE) 972. # define free_timers(R)	 save_timers(0, FREE_SAVE, R)  973. # define free_light_sources(R) save_light_sources(0, FREE_SAVE, R); 974. # define free_engravings save_engravings(0, FREE_SAVE) 975. # define freedamage	 savedamage(0, FREE_SAVE) 976. # define free_animals	 mon_animal_list(FALSE) 977.  978.  	/* move-specific data */ 979. 	dmonsfree;		/* release dead monsters */ 980.  981.  	/* level-specific data */ 982. 	free_timers(RANGE_LEVEL); 983. 	free_light_sources(RANGE_LEVEL); 984. 	freemonchn(fmon); 985. 	free_worm;		/* release worm segment information */ 986. 	freetrapchn(ftrap); 987. 	freeobjchn(fobj); 988. 	freeobjchn(level.buriedobjlist); 989. 	freeobjchn(billobjs); 990. 	free_engravings; 991. 	freedamage; 992.  993.  	/* game-state data */ 994. 	free_timers(RANGE_GLOBAL); 995. 	free_light_sources(RANGE_GLOBAL); 996. 	freeobjchn(invent); 997. 	freeobjchn(migrating_objs); 998. 	freemonchn(migrating_mons); 999. 	freemonchn(mydogs);		/* ascension or dungeon escape */ 1000.     /* freelevchn;	[folded into free_dungeons] */ 1001. 	free_animals; 1002. 	free_oracles; 1003. 	freefruitchn; 1004. 	freenames; 1005. 	free_waterlevel; 1006. 	free_dungeons; 1007. 1008. 	/* some pointers in iflags */ 1009. 	if (iflags.wc_font_map) free(iflags.wc_font_map); 1010. 	if (iflags.wc_font_message) free(iflags.wc_font_message); 1011. 	if (iflags.wc_font_text) free(iflags.wc_font_text); 1012. 	if (iflags.wc_font_menu) free(iflags.wc_font_menu); 1013. 	if (iflags.wc_font_status) free(iflags.wc_font_status); 1014. 	if (iflags.wc_tile_file) free(iflags.wc_tile_file); 1015. #ifdef AUTOPICKUP_EXCEPTIONS 1016. 	free_autopickup_exceptions; 1017. #endif 1018. 1019. #endif	/* FREE_ALL_MEMORY */ 1020. 	return; 1021. } 1022.  1023. #ifdef MFLOPPY 1024. boolean 1025. swapin_file(lev) 1026. int lev; 1027. { 1028. 	char to[PATHLEN], from[PATHLEN]; 1029. 1030. 	Sprintf(from, "%s%s", permbones, alllevels); 1031. 	Sprintf(to, "%s%s", levels, alllevels); 1032. 	set_levelfile_name(from, lev); 1033. 	set_levelfile_name(to, lev); 1034. 	if (iflags.checkspace) { 1035. 		while (level_info[lev].size > freediskspace(to)) 1036. 			if (!swapout_oldest) 1037. 				return FALSE; 1038. 	} 1039. # ifdef WIZARD 1040. 	if (wizard) { 1041. 		pline("Swapping in `%s'.", from); 1042. 		wait_synch; 1043. 	} 1044. # endif 1045. 	copyfile(from, to); 1046. 	(void) unlink(from); 1047. 	level_info[lev].where = ACTIVE; 1048. 	return TRUE; 1049. } 1050.  1051. STATIC_OVL boolean 1052. swapout_oldest { 1053. 	char to[PATHLEN], from[PATHLEN]; 1054. 	int i, oldest; 1055. 	long oldtime; 1056. 1057. 	if (!ramdisk) 1058. 		return FALSE; 1059. 	for (i = 1, oldtime = 0, oldest = 0; i <= maxledgerno; i++) 1060. 		if (level_info[i].where == ACTIVE 1061. 		&& (!oldtime || level_info[i].time < oldtime)) { 1062. 			oldest = i; 1063. oldtime = level_info[i].time; 1064. 		} 1065. 	if (!oldest) 1066. 		return FALSE; 1067. 	Sprintf(from, "%s%s", levels, alllevels); 1068. 	Sprintf(to, "%s%s", permbones, alllevels); 1069. 	set_levelfile_name(from, oldest); 1070. 	set_levelfile_name(to, oldest); 1071. # ifdef WIZARD 1072. 	if (wizard) { 1073. 		pline("Swapping out `%s'.", from); 1074. 		wait_synch; 1075. 	} 1076. # endif 1077. 	copyfile(from, to); 1078. 	(void) unlink(from); 1079. 	level_info[oldest].where = SWAPPED; 1080. 	return TRUE; 1081. } 1082.  1083. STATIC_OVL void 1084. copyfile(from, to) 1085. char *from, *to; 1086. { 1087. # ifdef TOS 1088. 1089. 	if (_copyfile(from, to)) 1090. 		panic("Can't copy %s to %s", from, to); 1091. # else 1092. 	char buf[BUFSIZ];	/* this is system interaction, therefore 1093. 				 * BUFSIZ instead of NetHack's BUFSZ */ 1094. 	int nfrom, nto, fdfrom, fdto; 1095. 1096. 	if ((fdfrom = open(from, O_RDONLY | O_BINARY, FCMASK)) < 0) 1097. 		panic("Can't copy from %s !?", from); 1098. 	if ((fdto = open(to, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, FCMASK)) < 0) 1099. 		panic("Can't copy to %s", to); 1100. 	do { 1101. 		nfrom = read(fdfrom, buf, BUFSIZ); 1102. 		nto = write(fdto, buf, nfrom); 1103. 		if (nto != nfrom) 1104. 			panic("Copyfile failed!"); 1105. 	} while (nfrom == BUFSIZ); 1106. 	(void) close(fdfrom); 1107. 	(void) close(fdto); 1108. # endif /* TOS */ 1109. } 1110.  1111. void 1112. co_false	   /* see comment in bones.c */ 1113. { 1114.     count_only = FALSE; 1115.    return; 1116. } 1117.  1118. #endif /* MFLOPPY */ 1119. 1120. /*save.c*/