1

/** @file

     2

 * All actions handling saving and loading goes on in this file. The general actions

     3

 * are as follows for saving a game (loading is analogous):

     4

 * <ol>

     5

 * <li>initialize the writer by creating a temporary memory-buffer for it

     6

 * <li>go through all to-be saved elements, each 'chunk' (ChunkHandler) prefixed by a label

     7

 * <li>use their description array (SaveLoad) to know what elements to save and in what version

     8

 *    of the game it was active (used when loading)

     9

 * <li>write all data byte-by-byte to the temporary buffer so it is endian-safe

    10

 * <li>when the buffer is full; flush it to the output (eg save to file) (_sl.buf, _sl.bufp, _sl.bufe)

    11

 * <li>repeat this until everything is done, and flush any remaining output to file

    12

 * </ol>

    13

 * @see ChunkHandler

    14

 * @see SaveLoad

    15

 */

    32

enum NeedLengthValues {NL_NONE = 0, NL_WANTLENGTH = 1, NL_CALCLENGTH = 2};

    36

/**

    37

 * Fill the input buffer by reading from the file with the given reader

    38

 */

    49

static inline uint32 SlGetOffs(void) {return _sl.offs_base - (_sl.bufe - _sl.bufp);}

    51

/** Flush the output buffer by writing to disk with the given reader.

    52

 * If the buffer pointer has not yet been set up, set it up now. Usually

    53

 * only called when the buffer is full, or there is no more data to be processed

    54

 */

    57

	// flush the buffer to disk (the writer)

    64

	/* All the data from the buffer has been written away, rewind to the beginning

    65

	* to start reading in more data */

    70

/** Error handler, calls longjmp to simulate an exception.

    71

 * @todo this was used to have a central place to handle errors, but it is

    72

 * pretty ugly, and seriously interferes with any multithreaded approaches */

    79

/** Read in a single byte from file. If the temporary buffer is full,

    80

 * flush it to its final destination

    81

 * @return return the read byte from file

    82

 */

    89

/** Wrapper for SlReadByteInternal */

    90

int SlReadByte(void) {return SlReadByteInternal();}

    91

    92

/** Write away a single byte from memory. If the temporary buffer is full,

    93

 * flush it to its destination (file)

    94

 * @param b the byte that is currently written

    95

 */

    96

static inline void SlWriteByteInternal(byte b)

    98

	if (_sl.bufp == _sl.bufe) SlWriteFill();

    99

	*_sl.bufp++ = b;

   102

/** Wrapper for SlWriteByteInternal */

   103

void SlWriteByte(byte b) {SlWriteByteInternal(b);}

   105

static inline int SlReadUint16(void)

   111

static inline uint32 SlReadUint32(void)

   117

static inline uint64 SlReadUint64(void)

   124

static inline void SlWriteUint16(VarType v)

   130

static inline void SlWriteUint32(uint32 v)

   136

static inline void SlWriteUint64(uint64 x)

   142

/**

   143

 * Read in the header descriptor of an object or an array.

   144

 * If the highest bit is set (7), then the index is bigger than 127

   145

 * elements, so use the next byte to read in the real value.

   146

 * The actual value is then both bytes added with the first shifted

   147

 * 8 bytes to the right, and dropping the highest bit (which only indicated a big index).

   148

 * x = ((x & 0x7F) << 8) + SlReadByte();

   149

 * @return Return the value of the index

   150

 */

   151

static uint SlReadSimpleGamma(void)

   153

	uint i = SlReadByte();

   154

	if (HASBIT(i, 7)) {

   155

		i = (i << 8) + SlReadByte();

   156

		CLRBIT(i, 15);

   157

	}

   158

	return i;

   161

/**

   162

 * Write the header descriptor of an object or an array.

   163

 * If the element is bigger than 128, use 2 bytes for saving

   164

 * and use the highest byte of the first written one as a notice

   165

 * that the length consists of 2 bytes. The length is fixed to a

   166

 * maximum of 16384 since any higher value will have bit 15 set

   167

 * and the notice, would obfuscate the real value

   168

 * @param i Index being written

   169

 * @todo the maximum of 16384 can easily be reached with vehicles, so raise this artificial limit

   170

 */

   174

   175

	if (i >= (1 << 7)) {

   176

		SlWriteByte((byte)((1 << 7) | (i >> 8)));

   178

	} else

   182

/** Return if the length will use up 1 or two bytes in a savegame */

   183

static inline uint SlGetGammaLength(uint i) {return (i >= (1 << 7)) ? 2 : 1;}

   185

static inline int SlReadSparseIndex(void) {return SlReadSimpleGamma();}

   186

static inline void SlWriteSparseIndex(uint index) {SlWriteSimpleGamma(index);}

   188

static inline int SlReadArrayLength(void) {return SlReadSimpleGamma();}

   189

static inline void SlWriteArrayLength(uint length) {SlWriteSimpleGamma(length);}

   197

/**

   198

 * Iterate through the elements of an array and read the whole thing

   199

 * @return The index of the object, or -1 if we have reached the end of current block

   200

 */

   203

	int index;

   206

	/* After reading in the whole array inside the loop

   207

	 * we must have read in all the data, so we must be at end of current block. */

   210

	while (true) {

   211

		uint length = SlReadArrayLength();

   212

		if (length == 0) {

   217

		_sl.obj_len = --length;

   218

		next_offs = SlGetOffs() + length;

   220

		switch (_sl.block_mode) {

   221

		case CH_SPARSE_ARRAY:	index = SlReadSparseIndex(); break;

   222

		case CH_ARRAY:        index = _sl.array_index++; break;

   224

			DEBUG(misc, 0) ("SlIterateArray: error");

   228

		if (length != 0) return index;

   232

/**

   233

 * Sets the length of either a RIFF object or the number of items in an array.

   234

 * This lets us load an object or an array of arbitrary size

   235

 * @param length The length of the sought object/array

   236

 */

   237

void SlSetLength(size_t length)

   239

	switch (_sl.need_length) {

   242

		switch (_sl.block_mode) {

   246

			break;

   248

			assert(_sl.last_array_index <= _sl.array_index);

   258

		} break;

   265

/**

   266

 * Save/Load bytes. These do not need to be converted to Little/Big Endian

   267

 * so directly write them or read them to/from file

   268

 * @param ptr The source or destination of the object being manipulated

   269

 * @param length number of bytes this fast CopyBytes lasts

   270

 */

   276

		for (; length != 0; length--) {SlWriteByteInternal(*p++);}

   278

		for (; length != 0; length--) {*p++ = SlReadByteInternal();}

   283

/**

   284

 * Read in bytes from the file/data structure but don't do

   285

 * anything with them

   286

 * NOTICE: currently unused

   287

 * @param length The amount of bytes that is being treated this way

   288

 */

   289

static inline void SlSkipBytes(size_t length)

   291

	for (; length != 0; length--)

   296

/* Get the length of the current object */

   297

uint SlGetFieldLength(void) {return _sl.obj_len;}

   299

/**

   300

 * Handle all conversion and typechecking of variables here.

   301

 * In the case of saving, read in the actual value from the struct

   302

 * and then write them to file, endian safely. Loading a value

   303

 * goes exactly the opposite way

   304

 * @param ptr The object being filled/read

   305

 * @param conv @VarType type of the current element of the struct

   306

 */

   307

static void SlSaveLoadConv(void *ptr, VarType conv)

   311

	if (_sl.save) { /* SAVE values */

   312

		/* Read a value from the struct. These ARE endian safe. */

   313

		switch ((conv >> 4) & 0xF) {

   314

		case SLE_VAR_I8   >> 4: x = *(int8*)ptr; break;

   315

		case SLE_VAR_U8   >> 4: x = *(byte*)ptr; break;

   316

		case SLE_VAR_I16  >> 4: x = *(int16*)ptr; break;

   317

		case SLE_VAR_U16  >> 4: x = *(uint16*)ptr; break;

   318

		case SLE_VAR_I32  >> 4: x = *(int32*)ptr; break;

   319

		case SLE_VAR_U32  >> 4: x = *(uint32*)ptr; break;

   320

		case SLE_VAR_I64  >> 4: x = *(int64*)ptr; break;

   321

		case SLE_VAR_U64  >> 4: x = *(uint64*)ptr; break;

   322

		case SLE_VAR_NULL >> 4: x = 0; break;

   323

		default: NOT_REACHED();

   326

		// Write the value to the file and check if its value is in the desired range

   327

		switch (conv & 0xF) {

   328

		case SLE_FILE_I8: assert(x >= -128 && x <= 127);     SlWriteByte(x);break;

   329

		case SLE_FILE_U8:	assert(x >= 0 && x <= 255);        SlWriteByte(x);break;

   332

		case SLE_FILE_U16:assert(x >= 0 && x <= 65535);      SlWriteUint16(x);break;

   333

		case SLE_FILE_I32: case SLE_FILE_U32:                SlWriteUint32((uint32)x);break;

   334

		case SLE_FILE_I64: case SLE_FILE_U64:                SlWriteUint64(x);break;

   335

		default: NOT_REACHED();

   337

	} else { /* LOAD values */

   340

		switch (conv & 0xF) {

   341

		case SLE_FILE_I8:  x = (int8)SlReadByte(); break;

   342

		case SLE_FILE_U8:  x = (byte)SlReadByte(); break;

   343

		case SLE_FILE_I16: x = (int16)SlReadUint16(); break;

   345

		case SLE_FILE_I32: x = (int32)SlReadUint32(); break;

   347

		case SLE_FILE_I64: x = (int64)SlReadUint64(); break;

   350

		default: NOT_REACHED();

   353

		/* Write The value to the struct. These ARE endian safe. */

   354

		switch ((conv >> 4) & 0xF) {

   355

		case SLE_VAR_I8   >> 4:  *(int8*)ptr = x; break;

   356

		case SLE_VAR_U8   >> 4:  *(byte*)ptr = x; break;

   357

		case SLE_VAR_I16  >> 4: *(int16*)ptr = x; break;

   358

		case SLE_VAR_U16  >> 4: *(uint16*)ptr = x; break;

   359

		case SLE_VAR_I32  >> 4: *(int32*)ptr = x; break;

   360

		case SLE_VAR_U32  >> 4: *(uint32*)ptr = x; break;

   361

		case SLE_VAR_I64  >> 4: *(int64*)ptr = x; break;

   362

		case SLE_VAR_U64  >> 4: *(uint64*)ptr = x; break;

   363

		case SLE_VAR_NULL >> 4: break;

   364

		default: NOT_REACHED();

   369

/* Length in bytes of the various datatypes in a savefile. These

   370

 * sizes are guaranteed by assert_compiles in stdafx.h */

   371

static const byte _conv_lengths[] = {1, 1, 2, 2, 4, 4, 8, 8, 2};

   373

/**

   374

 * Return the size in bytes of a certain type of normal/atomic variable

   375

 * @param var The variable the size is being asked of (NOTICE: unused)

   376

 * @param conv @VarType type of variable that is used for calculating the size

   377

 * @return Return the size of this type in byes

   378

 */

   379

static inline size_t SlCalcConvLen(const void *var, VarType conv) {return _conv_lengths[conv & 0xF];}

   380

   381

/**

   382

 * Return the size in bytes of a reference (pointer)

   383

 */

   384

static inline size_t SlCalcRefLen(void) {return 2;}

   385

   386

/**

   387

 * Return the size in bytes of a certain type of atomic array

   388

 * @param array The variable the size is being asked of (NOTICE: unused)

   389

 * @param length The length of the array counted in elements

   390

 * @param conv @VarType type of the variable that is used in calculating the size

   391

 */

   392

static inline size_t SlCalcArrayLen(const void *array, uint length, VarType conv) {return _conv_lengths[conv & 0xF] * length;}

   393

   394

/**

   395

 * Save/Load an array.

   396

 * @param array The array being manipulated

   397

 * @param length The length of the array in elements

   398

 * @param conv @VarType type of the atomic array (int, byte, uint64, etc.)

   399

 */

   400

void SlArray(void *array, uint length, VarType conv)

   402

	static const byte conv_mem_size[] = {1, 1, 2, 2, 4, 4, 8, 8, 0};

   412

	/* NOTICE - handle some buggy stuff, in really old versions everything was saved

   413

	 * as a byte-type. So detect this, and adjust array size accordingly */

   416

			length *= 2; // int16, uint16 and StringID are 2 bytes in size

   419

			length *= 4; // int32 and uint32 are 4 bytes in size

   424

	/* If the size of elements is 1 byte, no special conversion is needed,

   425

	 * use specialized copy-to-copy function to speed up things */

   426

	if (conv == SLE_INT8 || conv == SLE_UINT8) {

   427

		SlCopyBytes(array, length);

   428

	} else {

   430

		for (; length != 0; length --) {

   432

			a += conv_mem_size[(conv >> 4) & 0xF]; // get size

   437

/**

   438

 * Calculate the size of an object.

   439

 * @param object Object that needs its length calculated

   440

 * @param sld The @SaveLoad description of the object so we know how to manipulate it

   441

 */

   442

static size_t SlCalcObjLength(void *object, const SaveLoad *sld)

   447

	for (; sld->cmd != SL_END; sld++) {

   448

		if (sld->cmd < SL_WRITEBYTE) {

   449

			if (HASBIT(sld->cmd, 2)) {

   450

				// check if the field is used in the current savegame version

   451

				if (_sl.version < sld->version_from || _sl.version > sld->version_to)

   455

			switch (sld->cmd) {

   456

			case SL_VAR: case SL_CONDVAR: /* Normal Variable */

   457

				length += SlCalcConvLen(NULL, sld->type); break;

   458

			case SL_REF: case SL_CONDREF:  /* Reference variable */

   459

				length += SlCalcRefLen(); break;

   460

			case SL_ARR: case SL_CONDARR: /* Array */

   461

				length += SlCalcArrayLen(NULL, sld->length, sld->type); break;

   462

			default: NOT_REACHED();

   464

		} else if (sld->cmd == SL_WRITEBYTE) {

   465

			length++; // a byte is logically of size 1

   466

		} else if (sld->cmd == SL_INCLUDE) {

   467

			length += SlCalcObjLength(NULL, _sl.includes[sld->version_from]);

   468

		}	else

   469

			assert(sld->cmd == SL_END);

   474

/**

   475

 * Main SaveLoad function.

   476

 * @param object The object that is being saved or loaded

   477

 * @param sld The @SaveLoad description of the object so we know how to manipulate it

   478

 */

   479

void SlObject(void *object, const SaveLoad *sld)

   483

		SlSetLength(SlCalcObjLength(object, sld));

   488

	for (; sld->cmd != SL_END; sld++) {

   489

		void *ptr = (byte*)object + sld->offset;

   491

		if (sld->cmd < SL_WRITEBYTE) {

   492

			/* CONDITIONAL saveload types depend on the savegame version */

   493

			if (HASBIT(sld->cmd, 2)) {

   494

				// check if the field is of the right version, if not, proceed to next one

   495

				if (_sl.version < sld->version_from || _sl.version > sld->version_to)

   499

			switch (sld->cmd) {