openttd-mini: comparison saveload.c

equal deleted inserted replaced

-:614bba52258d
+:0a7025304867
 	if (_sl.bufp != NULL) {
 		uint len = _sl.bufp - _sl.buf;
 		_sl.offs_base += len;
 		if (len) _sl.write_bytes(len);
 	}
 	// setup next buffer
 	_sl.bufp = _sl.buf;
 	_sl.bufe = _sl.buf + _sl.bufsize;
 }
 int SlIterateArray()
 {
 	int ind;
 	static uint32 next_offs;
 	// Must be at end of current block.
 	assert(next_offs == 0 || SlGetOffs() == next_offs);
 	while(true) {
 		uint len = SlReadArrayLength();
 		case CH_ARRAY:        ind = _sl.array_index++; break;
 		default:
 			DEBUG(misc, 0) ("SlIterateArray: error\n");
 			return -1; // error
 		}
 		if (len != 0)
 			return ind;
 	}
 }
 static void SlSaveLoadConv(void *ptr, uint conv)
 {
 	int64 x = 0;
 	if (_sl.save) {
 		// Read a value from the struct. These ARE endian safe.
 		switch((conv >> 4)&0xf) {
 		case SLE_VAR_I8>>4: x = *(int8*)ptr; break;
 		case SLE_VAR_U8>>4: x = *(byte*)ptr; break;
 		case SLE_VAR_I16>>4: x = *(int16*)ptr; break;
 		case SLE_VAR_U16>>4: x = *(uint16*)ptr; break;
 		case SLE_VAR_I32>>4: x = *(int32*)ptr; break;
 		case SLE_VAR_U32>>4: x = *(uint32*)ptr; break;
 		case SLE_VAR_I64>>4: x = *(int64*)ptr; break;
 		case SLE_VAR_U64>>4: x = *(uint64*)ptr; break;
 		case SLE_VAR_NULL>>4: x = 0; break;
 		default:
 			NOT_REACHED();
 		}
 		default:
 			assert(0);
 			NOT_REACHED();
 		}
 	} else {
 		// Read a value from the file
 		switch(conv & 0xF) {
 		case SLE_FILE_I8: x = (int8)SlReadByte();	break;
 		case SLE_FILE_U8: x = (byte)SlReadByte(); break;
 		case SLE_FILE_I16: x = (int16)SlReadUint16();	break;
 				}
 			}
 			switch(cmd&3) {
 			// Normal variable
 			case 0: length += SlCalcConvLen(conv, NULL);break;
 			// Reference
 			case 1: length += 2; break;
 			// Array
 			case 2:	length += SlCalcArrayLen(NULL, *d++, conv); break;
 			default:NOT_REACHED();
 				break;
 			// Array
 			case 2:	SlArray(ptr, *d++, conv); break;
 			default:NOT_REACHED();
 			}
 		// Write byte.
 		} else if (cmd == 8) {
 			if (_sl.save) {
 				SlWriteByte(d[3]);
 			} else {
 	size_t len;
 	uint32 endoffs;
 	_sl.block_mode = m;
 	_sl.obj_len = 0;
 	switch(m) {
 	case CH_ARRAY:
 		_sl.array_index = 0;
 		ch->load_proc();
 		break;
 	if (ch->flags & CH_AUTO_LENGTH) {
 		// Need to calculate the length. Solve that by calling SlAutoLength in the save_proc.
 		_tmp_proc_1 = proc;
 		proc = SlStubSaveProc;
 	}
 	_sl.block_mode = ch->flags & CH_TYPE_MASK;
 	switch(ch->flags & CH_TYPE_MASK) {
 	case CH_RIFF:
 		_sl.need_length = NL_WANTLENGTH;
 		proc();
 	for(p=0; p!=CH_NUM_PRI_LEVELS; p++) {
 		for(chsc=_sl.chs;(ch=*chsc++) != NULL;) {
 			while(true) {
 				if (((ch->flags >> CH_PRI_SHL) & (CH_NUM_PRI_LEVELS - 1)) == p)
 					SlSaveChunk(ch);
 				if (ch->flags & CH_LAST)
 					break;
 				ch++;
 			}
 		}
 	// Read header
 	if (fread(tmp, sizeof(tmp), 1, _sl.fh) != 1) SlError("file read failed");
 	// Check if size is bad
 	((uint32*)out)[0] = size = tmp[1];
 	if (_sl.version != 0) {
 		tmp[0] = TO_BE32(tmp[0]);
 		size = TO_BE32(size);
 	}
 	// Read block
 	if (fread(out + sizeof(uint32), size, 1, _sl.fh) != 1) SlError("file read failed");
 	// Verify checksum
 	if (tmp[0] != lzo_adler32(0, out, size + sizeof(uint32))) SlError("bad checksum");
 	// Decompress
 	lzo1x_decompress(out + sizeof(uint32)*1, size, _sl.buf, &len, NULL);
 	return len;
 }
 static void WriteLZO(uint size)
 {
 	byte out[LZO_SIZE + LZO_SIZE / 64 + 16 + 3 + 8];
 	byte wrkmem[sizeof(byte*)*4096];
 	uint outlen;
 	lzo1x_1_compress(_sl.buf, size, out + sizeof(uint32)*2, &outlen, wrkmem);
 	((uint32*)out)[1] = TO_BE32(outlen);
 	((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out + sizeof(uint32), outlen + sizeof(uint32)));
 	if (fwrite(out, outlen + sizeof(uint32)*2, 1, _sl.fh) != 1) SlError("file write failed");
 }
 static bool InitReadZlib()
 {
 	memset(&_z, 0, sizeof(_z));
 	if (inflateInit(&_z) != Z_OK) return false;
 	_sl.bufsize = 4096;
 	_sl.buf = (byte*)malloc(4096 + 4096); // also contains fread buffer
 	return true;
 }
 		// inflate the data
 		r = inflate(&_z, 0);
 		if (r == Z_STREAM_END)
 			break;
 		if (r != Z_OK)
 			SlError("inflate() failed");
 	} while (_z.avail_out);
 	return 4096 - _z.avail_out;
 }
 int SaveOrLoad(const char *filename, int mode)
 {
 	uint32 hdr[2];
 	const SaveLoadFormat *fmt;
 uint version;
 	// old style load
 	if (mode == SL_OLD_LOAD) {
 		InitializeGame();
 		if (!LoadOldSaveGame(filename)) return SL_REINIT;
 		AfterLoadGame(0);
 		return SL_OK;
 	}
 	_sl.fh = fopen(filename, mode?"wb":"rb");
 	if (_sl.fh == NULL)
 		return SL_ERROR;
 	_sl.bufe = _sl.bufp = NULL;
 	_sl.offs_base = 0;
 	_sl.int_to_ref_proc = IntToReference;
 	_sl.ref_to_int_proc = ReferenceToInt;
 	_sl.save = mode;
 			ShowInfoF("Save game failed: %s.", _sl.excpt_msg);
 			return SL_ERROR;
 		}
 	}
 // we first initialize here to avoid: "warning: variable `version' might
 // be clobbered by `longjmp' or `vfork'"
 	version = 0;
 	if (mode != SL_LOAD) {
 		fmt = GetSavegameFormat(_savegame_format);
 		_sl.write_bytes = fmt->writer;
 		_sl.excpt_uninit = fmt->uninit_write;
 		if (!fmt->init_write()) goto init_err;
 		hdr[0] = fmt->tag;
 		hdr[1] = TO_BE32((SAVEGAME_MAJOR_VERSION<<16) + (SAVEGAME_MINOR_VERSION << 8));
 		if (fwrite(hdr, sizeof(hdr), 1, _sl.fh) != 1) SlError("file write failed");
 		_sl.version = SAVEGAME_MAJOR_VERSION;
 		BeforeSaveGame();
 		SlSaveChunks();
 		SlWriteFill(); // flush the save buffer
 		fmt->uninit_write();
 				break;
 			}
 			if (fmt->tag == hdr[0]) {
 				// check version number
 				version = TO_BE32(hdr[1]) >> 8;
 				// incompatible version?
 				if (version > SAVEGAME_LOADABLE_VERSION) goto read_err;
 				_sl.version = (version>>8);
 				break;
 			}

changeset 193	0a7025304867
parent 121	c2f18f4d8be1
child 222	b88456001397