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

 */

    16

#include "stdafx.h"

    17

#include "openttd.h"

    18

#include "debug.h"

    19

#include "vehicle.h"

    20

#include "station.h"

    21

#include "town.h"

    22

#include "player.h"

    23

#include "saveload.h"

    24

#include "variables.h"

    25

    26

enum {

    27

	SAVEGAME_MAJOR_VERSION = 15,

    28

	SAVEGAME_MINOR_VERSION = 0,

    29

    30

	SAVEGAME_LOADABLE_VERSION = (SAVEGAME_MAJOR_VERSION << 8) + SAVEGAME_MINOR_VERSION

    31

};

    32

    33

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

    34

    35

SaverLoader _sl;

    36

    37

/**

    38

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

    39

 */

    40

static void SlReadFill(void)

    41

{

    42

	uint len = _sl.read_bytes();

    43

	assert(len != 0);

    44

    45

	_sl.bufp = _sl.buf;

    46

	_sl.bufe = _sl.buf + len;

    47

	_sl.offs_base += len;

    48

}

    49

    50

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

    51

    52

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

    53

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

    54

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

    55

 */

    56

static void SlWriteFill(void)

    57

{

    58

	// flush the buffer to disk (the writer)

    59

	if (_sl.bufp != NULL) {

    60

		uint len = _sl.bufp - _sl.buf;

    61

		_sl.offs_base += len;

    62

		if (len) _sl.write_bytes(len);

    63

	}

    64

    65

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

    66

	* to start reading in more data */

    67

	_sl.bufp = _sl.buf;

    68

	_sl.bufe = _sl.buf + _sl.bufsize;

    69

}

    70

    71

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

    72

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

    73

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

    74

static void NORETURN SlError(const char *msg)

    75

{

    76

	_sl.excpt_msg = msg;

    77

	longjmp(_sl.excpt, 0);

    78

}

    79

    80

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

    81

 * flush it to its final destination

    82

 * @return return the read byte from file

    83

 */

    84

static inline int SlReadByteInternal(void)

    85

{

    86

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

    87

	return *_sl.bufp++;

    88

}

    89

    90

/** Wrapper for SlReadByteInternal */

    91

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

    92

    93

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

    94

 * flush it to its destination (file)

    95

 * @param b the byte that is currently written

    96

 */

    97

static inline void SlWriteByteInternal(byte b)

    98

{

    99

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

   100

	*_sl.bufp++ = b;

   101

}

   102

   103

/** Wrapper for SlWriteByteInternal */

   104

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

   105

   106

static inline int SlReadUint16(void)

   107

{

   108

	int x = SlReadByte() << 8;

   109

	return x | SlReadByte();

   110

}

   111

   112

static inline uint32 SlReadUint32(void)

   113

{

   114

	uint32 x = SlReadUint16() << 16;

   115

	return x | SlReadUint16();

   116

}

   117

   118

static inline uint64 SlReadUint64(void)

   119

{

   120

	uint32 x = SlReadUint32();

   121

	uint32 y = SlReadUint32();

   122

	return (uint64)x << 32 | y;

   123

}

   124

   125

static inline void SlWriteUint16(uint16 v)

   126

{

   127

	SlWriteByte(GB(v, 8, 8));

   128

	SlWriteByte(GB(v, 0, 8));

   129

}

   130

   131

static inline void SlWriteUint32(uint32 v)

   132

{

   133

	SlWriteUint16(GB(v, 16, 16));

   134

	SlWriteUint16(GB(v,  0, 16));

   135

}

   136

   137

static inline void SlWriteUint64(uint64 x)

   138

{

   139

	SlWriteUint32((uint32)(x >> 32));

   140

	SlWriteUint32((uint32)x);

   141

}

   142

   143

/**

   144

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

   145

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

   146

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

   147

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

   148

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

   149

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

   150

 * @return Return the value of the index

   151

 */

   152

static uint SlReadSimpleGamma(void)

   153

{

   154

	uint i = SlReadByte();

   155

	if (HASBIT(i, 7)) {

   156

		i &= ~0x80;

   157

		if (HASBIT(i, 6)) {

   158

			i &= ~0x40;

   159

			if (HASBIT(i, 5)) {

   160

				i &= ~0x20;

   161

				if (HASBIT(i, 4))

   162

					SlError("Unsupported gamma");

   163

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

   164

			}

   165

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

   166

		}

   167

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

   168

	}

   169

	return i;

   170

}

   171

   172

/**

   173

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

   174

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

   175

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

   176

 * that the length consists of 2 bytes, etc.. like this:

   177

 * 0xxxxxxx

   178

 * 10xxxxxx xxxxxxxx

   179

 * 110xxxxx xxxxxxxx xxxxxxxx

   180

 * 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx

   181

 * @param i Index being written

   182

 */

   183

   184

static void SlWriteSimpleGamma(uint i)

   185

{

   186

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

   187

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

   188

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

   189

				assert(i < (1 << 28));

   190

				SlWriteByte((byte)0xE0 | (i>>24));

   191

				SlWriteByte((byte)(i>>16));

   192

			} else {

   193

				SlWriteByte((byte)0xC0 | (i>>16));

   194

			}

   195

			SlWriteByte((byte)(i>>8));

   196

		} else {

   197

			SlWriteByte((byte)(0x80 | (i>>8)));

   198

		}

   199

	}

   200

	SlWriteByte(i);

   201

}

   202

   203

/** Return how many bytes used to encode a gamma value */

   204

static inline uint SlGetGammaLength(uint i) {

   205

	return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21));

   206

}

   207

   208

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

   209

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

   210

   211

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

   212

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

   213

   214

void SlSetArrayIndex(uint index)

   215

{

   216

	_sl.need_length = NL_WANTLENGTH;

   217

	_sl.array_index = index;

   218

}

   219

   220

/**

   221

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

   222

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

   223

 */

   224

int SlIterateArray(void)

   225

{

   226

	int index;

   227

	static uint32 next_offs;

   228

   229

	/* After reading in the whole array inside the loop

   230

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

   231

	assert(next_offs == 0 || SlGetOffs() == next_offs);

   232

   233

	while (true) {

   234

		uint length = SlReadArrayLength();

   235

		if (length == 0) {

   236

			next_offs = 0;

   237

			return -1;

   238

		}

   239

   240

		_sl.obj_len = --length;

   241

		next_offs = SlGetOffs() + length;

   242

   243

		switch (_sl.block_mode) {

   244

		case CH_SPARSE_ARRAY: index = SlReadSparseIndex(); break;

   245

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

   246

		default:

   247

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

   248

			return -1; // error

   249

		}

   250

   251

		if (length != 0) return index;

   252

	}

   253

}

   254

   255

/**

   256

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

   257

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

   258

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

   259

 */

   260

void SlSetLength(size_t length)

   261

{

   262

	switch (_sl.need_length) {

   263

	case NL_WANTLENGTH:

   264

		_sl.need_length = NL_NONE;

   265

		switch (_sl.block_mode) {

   266

		case CH_RIFF:

   267

			// Ugly encoding of >16M RIFF chunks

   268

			// The lower 24 bits are normal

   269

			// The uppermost 4 bits are bits 24:27

   270

			assert(length < (1<<28));

   271

			SlWriteUint32((length & 0xFFFFFF) | ((length >> 24) << 28));

   272

			break;

   273

		case CH_ARRAY:

   274

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

   275

			while (++_sl.last_array_index <= _sl.array_index)

   276

				SlWriteArrayLength(1);

   277

			SlWriteArrayLength(length + 1);

   278

			break;

   279

		case CH_SPARSE_ARRAY:

   280

			SlWriteArrayLength(length + 1 + SlGetGammaLength(_sl.array_index)); // Also include length of sparse index.

   281

			SlWriteSparseIndex(_sl.array_index);

   282

			break;

   283

		default: NOT_REACHED();

   284

		} break;

   285

	case NL_CALCLENGTH:

   286

		_sl.obj_len += length;

   287

		break;

   288

	}

   289

}

   290

   291

/**

   292

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

   293

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

   294

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

   295

 * @param length number of bytes this fast CopyBytes lasts

   296

 */

   297

static void SlCopyBytes(void *ptr, size_t length)

   298

{

   299

	byte *p = (byte*)ptr;

   300

   301

	if (_sl.save) {

   302

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

   303

	} else {

   304

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

   305

	}

   306

}

   307

   308

#if 0

   309

/**

   310

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

   311

 * anything with them

   312

 * NOTICE: currently unused

   313

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

   314

 */

   315

static inline void SlSkipBytes(size_t length)

   316

{

   317

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

   318

		SlReadByte();

   319

}

   320

#endif

   321

   322

/* Get the length of the current object */

   323

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

   324

   325

/**

   326

 * Handle all conversion and typechecking of variables here.

   327

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

   328

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

   329

 * goes exactly the opposite way

   330

 * @param ptr The object being filled/read

   331

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

   332

 */

   333

static void SlSaveLoadConv(void *ptr, VarType conv)

   334

{

   335

	int64 x = 0;

   336

   337

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

   338

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

   339

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

   340

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

   341

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

   342

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

   343

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

   344

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

   345

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

   346

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

   347

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

   348

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

   349

		default: NOT_REACHED();

   350

		}

   351

   352

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

   353

		switch (conv & 0xF) {

   354

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

   355

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

   356

		case SLE_FILE_I16:assert(x >= -32768 && x <= 32767); SlWriteUint16(x);break;

   357

		case SLE_FILE_STRINGID:

   358

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

   359

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

   360

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

   361

		default: NOT_REACHED();

   362

		}

   363

	} else { /* LOAD values */

   364

   365

		// Read a value from the file

   366

		switch (conv & 0xF) {

   367

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

   368

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

   369

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

   370

		case SLE_FILE_U16: x = (uint16)SlReadUint16(); break;

   371

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

   372

		case SLE_FILE_U32: x = (uint32)SlReadUint32(); break;

   373

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

   374

		case SLE_FILE_U64: x = (uint64)SlReadUint64(); break;

   375

		case SLE_FILE_STRINGID: x = RemapOldStringID((uint16)SlReadUint16()); break;

   376

		default: NOT_REACHED();

   377

		}

   378

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

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

   386

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

   387

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

   388

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

   389

		case SLE_VAR_NULL >> 4: break;

   390

		default: NOT_REACHED();

   391

		}

   392

	}

   393

}

   394

   395

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

   396

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

   397

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

   398

   399

/**

   400

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

   401

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

   402

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

   403

 * @return Return the size of this type in byes

   404

 */

   405

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

   406

   407

/**

   408

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

   409

 */

   410

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

   411

   412

/**

   413

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

   414

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

   415

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

   416

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

   417

 */

   418

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

   419

   420

/**

   421

 * Save/Load an array.

   422

 * @param array The array being manipulated

   423

 * @param length The length of the array in elements

   424

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

   425

 */

   426

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

   427

{

   428

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

   429

   430

	// Automatically calculate the length?

   431

	if (_sl.need_length != NL_NONE) {

   432

		SlSetLength(SlCalcArrayLen(array, length, conv));

   433

		// Determine length only?

   434

		if (_sl.need_length == NL_CALCLENGTH)

   435

			return;

   436

	}

   437

   438

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

   439

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

   440

	if (!_sl.save && _sl.version == 0) {

   441

		if (conv == SLE_INT16 || conv == SLE_UINT16 || conv == SLE_STRINGID) {

   442

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

   443

			conv = SLE_INT8;

   444

		} else if (conv == SLE_INT32 || conv == SLE_UINT32) {

   445

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

   446

			conv = SLE_INT8;

   447

		}

   448

	}

   449

   450

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

   451

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

   452

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

   453

		SlCopyBytes(array, length);

   454

	} else {

   455

		byte *a = (byte*)array;

   456

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

   457

			SlSaveLoadConv(a, conv);

   458

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

   459

		}

   460

	}

   461

}

   462

   463

/**

   464

 * Calculate the size of an object.

   465

 * @param object Object that needs its length calculated

   466

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

   467

 */

   468

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

   469

{

   470

	size_t length = 0;

   471

   472

	// Need to determine the length and write a length tag.

   473

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

   474

		if (sld->cmd < SL_WRITEBYTE) {

   475

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

   476

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

   477

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

   478

					continue;

   479

			}

   480

   481

			switch (sld->cmd) {

   482

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

   483

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

   484

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

   485

				length += SlCalcRefLen(); break;

   486

			case SL_ARR: case SL_CONDARR: /* Array */

   487

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

   488

			default: NOT_REACHED();

   489

			}

   490

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

   491

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

   492

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

   493

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

   494

		} else

   495

			assert(sld->cmd == SL_END);

   496

	}

   497

	return length;