1

/* $Id$ */

     2

     3

/** @file

     4

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

     5

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

     6

 * <ol>

     7

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

     8

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

     9

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

    10

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

    11

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

    12

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

    13

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

    14

 * </ol>

    15

 * @see ChunkHandler

    16

 * @see SaveLoad

    17

 */

    18

#include "stdafx.h"

    19

#include "openttd.h"

    20

#include "debug.h"

    21

#include "functions.h"

    22

#include "vehicle.h"

    23

#include "station.h"

    24

#include "thread.h"

    25

#include "town.h"

    26

#include "player.h"

    27

#include "saveload.h"

    28

#include "variables.h"

    29

    30

enum {

    31

	SAVEGAME_MAJOR_VERSION = 16,

    32

	SAVEGAME_MINOR_VERSION = 0,

    33

    34

	SAVEGAME_LOADABLE_VERSION = (SAVEGAME_MAJOR_VERSION << 8) + SAVEGAME_MINOR_VERSION

    35

};

    36

    37

byte   _sl_version;      /// the major savegame version identifier

    38

uint16 _sl_full_version; /// the full version of the savegame

    39

    40

/** The saveload struct, containing reader-writer functions, bufffer, version, etc. */

    41

static struct {

    42

	bool save;                           /// are we doing a save or a load atm. True when saving

    43

	byte need_length;                    /// ???

    44

	byte block_mode;                     /// ???

    45

	bool error;                          /// did an error occur or not

    46

    47

	int obj_len;                         /// the length of the current object we are busy with

    48

	int array_index, last_array_index;   /// in the case of an array, the current and last positions

    49

    50

	uint32 offs_base;                    /// the offset in number of bytes since we started writing data (eg uncompressed savegame size)

    51

    52

	WriterProc *write_bytes;             /// savegame writer function

    53

	ReaderProc *read_bytes;              /// savegame loader function

    54

    55

	ReferenceToIntProc *ref_to_int_proc; /// function to convert pointers to numbers when saving a game

    56

	IntToReferenceProc *int_to_ref_proc; /// function to convert numbers to pointers when loading a game

    57

    58

	const ChunkHandler* const *chs;      /// the chunk of data that is being processed atm (vehicles, signs, etc.)

    59

	const SaveLoad* const *includes;     /// the internal layouf of the given chunk

    60

    61

	/** When saving/loading savegames, they are always saved to a temporary memory-place

    62

	 * to be flushed to file (save) or to final place (load) when full. */

    63

	byte *bufp, *bufe;                   /// bufp(ointer) gives the current position in the buffer bufe(nd) gives the end of the buffer

    64

    65

	// these 3 may be used by compressor/decompressors.

    66

	byte *buf;                           /// pointer to temporary memory to read/write, initialized by SaveLoadFormat->initread/write

    67

	uint bufsize;                        /// the size of the temporary memory *buf

    68

	FILE *fh;                            /// the file from which is read or written to

    69

    70

	void (*excpt_uninit)(void);          /// the function to execute on any encountered error

    71

	const char *excpt_msg;               /// the error message

    72

	jmp_buf excpt;                       /// @todo used to jump to "exception handler";  really ugly

    73

} _sl;

    74

    75

    76

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

    77

    78

/**

    79

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

    80

 */

    81

static void SlReadFill(void)

    82

{

    83

	uint len = _sl.read_bytes();

    84

	assert(len != 0);

    85

    86

	_sl.bufp = _sl.buf;

    87

	_sl.bufe = _sl.buf + len;

    88

	_sl.offs_base += len;

    89

}

    90

    91

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

    92

    93

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

    94

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

    95

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

    96

 */

    97

static void SlWriteFill(void)

    98

{

    99

	// flush the buffer to disk (the writer)

   100

	if (_sl.bufp != NULL) {

   101

		uint len = _sl.bufp - _sl.buf;

   102

		_sl.offs_base += len;

   103

		if (len) _sl.write_bytes(len);

   104

	}

   105

   106

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

   107

	* to start reading in more data */

   108

	_sl.bufp = _sl.buf;

   109

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

   110

}

   111

   112

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

   113

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

   114

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

   115

static void NORETURN SlError(const char *msg)

   116

{

   117

	_sl.excpt_msg = msg;

   118

	longjmp(_sl.excpt, 0);

   119

}

   120

   121

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

   122

 * flush it to its final destination

   123

 * @return return the read byte from file

   124

 */

   125

static inline int SlReadByteInternal(void)

   126

{

   127

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

   128

	return *_sl.bufp++;

   129

}

   130

   131

/** Wrapper for SlReadByteInternal */

   132

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

   133

   134

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

   135

 * flush it to its destination (file)

   136

 * @param b the byte that is currently written

   137

 */

   138

static inline void SlWriteByteInternal(byte b)

   139

{

   140

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

   141

	*_sl.bufp++ = b;

   142

}

   143

   144

/** Wrapper for SlWriteByteInternal */

   145

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

   146

   147

static inline int SlReadUint16(void)

   148

{

   149

	int x = SlReadByte() << 8;

   150

	return x | SlReadByte();

   151

}

   152

   153

static inline uint32 SlReadUint32(void)

   154

{

   155

	uint32 x = SlReadUint16() << 16;

   156

	return x | SlReadUint16();

   157

}

   158

   159

static inline uint64 SlReadUint64(void)

   160

{

   161

	uint32 x = SlReadUint32();

   162

	uint32 y = SlReadUint32();

   163

	return (uint64)x << 32 | y;

   164

}

   165

   166

static inline void SlWriteUint16(uint16 v)

   167

{

   168

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

   169

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

   170

}

   171

   172

static inline void SlWriteUint32(uint32 v)

   173

{

   174

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

   175

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

   176

}

   177

   178

static inline void SlWriteUint64(uint64 x)

   179

{

   180

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

   181

	SlWriteUint32((uint32)x);

   182

}

   183

   184

/**

   185

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

   186

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

   187

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

   188

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

   189

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

   190

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

   191

 * @return Return the value of the index

   192

 */

   193

static uint SlReadSimpleGamma(void)

   194

{

   195

	uint i = SlReadByte();

   196

	if (HASBIT(i, 7)) {

   197

		i &= ~0x80;

   198

		if (HASBIT(i, 6)) {

   199

			i &= ~0x40;

   200

			if (HASBIT(i, 5)) {

   201

				i &= ~0x20;

   202

				if (HASBIT(i, 4))

   203

					SlError("Unsupported gamma");

   204

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

   205

			}

   206

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

   207

		}

   208

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

   209

	}

   210

	return i;

   211

}

   212

   213

/**

   214

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

   215

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

   216

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

   217

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

   218

 * 0xxxxxxx

   219

 * 10xxxxxx xxxxxxxx

   220

 * 110xxxxx xxxxxxxx xxxxxxxx

   221

 * 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx

   222

 * @param i Index being written

   223

 */

   224

   225

static void SlWriteSimpleGamma(uint i)

   226

{

   227

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

   228

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

   229

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

   230

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

   231

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

   232

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

   233

			} else {

   234

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

   235

			}

   236

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

   237

		} else {

   238

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

   239

		}

   240

	}

   241

	SlWriteByte(i);

   242

}

   243

   244

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

   245

static inline uint SlGetGammaLength(uint i) {

   246

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

   247

}

   248

   249

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

   250

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

   251

   252

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

   253

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

   254

   255

void SlSetArrayIndex(uint index)

   256

{

   257

	_sl.need_length = NL_WANTLENGTH;

   258

	_sl.array_index = index;

   259

}

   260

   261

/**

   262

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

   263

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

   264

 */

   265

int SlIterateArray(void)

   266

{

   267

	int index;

   268

	static uint32 next_offs;

   269

   270

	/* After reading in the whole array inside the loop

   271

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

   272

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

   273

   274

	while (true) {

   275

		uint length = SlReadArrayLength();

   276

		if (length == 0) {

   277

			next_offs = 0;

   278

			return -1;

   279

		}

   280

   281

		_sl.obj_len = --length;

   282

		next_offs = SlGetOffs() + length;

   283

   284

		switch (_sl.block_mode) {

   285

		case CH_SPARSE_ARRAY: index = SlReadSparseIndex(); break;

   286

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

   287

		default:

   288

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

   289

			return -1; // error

   290

		}

   291

   292

		if (length != 0) return index;

   293

	}

   294

}

   295

   296

/**

   297

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

   298

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

   299

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

   300

 */

   301

void SlSetLength(size_t length)

   302

{

   303

	switch (_sl.need_length) {

   304

	case NL_WANTLENGTH:

   305

		_sl.need_length = NL_NONE;

   306

		switch (_sl.block_mode) {

   307

		case CH_RIFF:

   308

			// Ugly encoding of >16M RIFF chunks

   309

			// The lower 24 bits are normal

   310

			// The uppermost 4 bits are bits 24:27

   311

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

   312

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

   313

			break;

   314

		case CH_ARRAY:

   315

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

   316

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

   317

				SlWriteArrayLength(1);

   318

			SlWriteArrayLength(length + 1);

   319

			break;

   320

		case CH_SPARSE_ARRAY:

   321

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

   322

			SlWriteSparseIndex(_sl.array_index);

   323

			break;

   324

		default: NOT_REACHED();

   325

		} break;

   326

	case NL_CALCLENGTH:

   327

		_sl.obj_len += length;

   328

		break;

   329

	}

   330

}

   331

   332

/**

   333

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

   334

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

   335

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

   336

 * @param length number of bytes this fast CopyBytes lasts

   337

 */

   338

static void SlCopyBytes(void *ptr, size_t length)

   339

{

   340

	byte *p = (byte*)ptr;

   341

   342

	if (_sl.save) {

   343

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

   344

	} else {

   345

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

   346

	}

   347

}

   348

   349

#if 0

   350

/**

   351

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

   352

 * anything with them

   353

 * NOTICE: currently unused

   354

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

   355

 */

   356

static inline void SlSkipBytes(size_t length)

   357

{

   358

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

   359

		SlReadByte();

   360

}

   361

#endif

   362

   363

/* Get the length of the current object */

   364

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

   365

   366

/**

   367

 * Handle all conversion and typechecking of variables here.

   368

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

   369

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

   370

 * goes exactly the opposite way

   371

 * @param ptr The object being filled/read

   372

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

   373

 */

   374

static void SlSaveLoadConv(void *ptr, VarType conv)

   375

{

   376

	int64 x = 0;

   377

   378

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

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

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

   386

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

   387

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

   388

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

   389

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

   390

		default: NOT_REACHED();

   391

		}

   392

   393

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

   394

		switch (conv & 0xF) {

   395

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

   396

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

   397

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

   398

		case SLE_FILE_STRINGID:

   399

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

   400

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

   401

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

   402

		default: NOT_REACHED();

   403

		}

   404

	} else { /* LOAD values */

   405

   406

		// Read a value from the file

   407

		switch (conv & 0xF) {

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

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

   417

		default: NOT_REACHED();

   418

		}

   419

   420

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

   421

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

   422

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

   423

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

   424

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

   425

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

   426

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

   427

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

   428

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

   429

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

   430

		case SLE_VAR_NULL >> 4: break;

   431

		default: NOT_REACHED();

   432

		}

   433

	}

   434

}

   435

   436

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

   437

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

   438

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

   439

   440

/**

   441

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

   442

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

   443

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

   444

 * @return Return the size of this type in byes

   445

 */

   446

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

   447

   448

/**

   449

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

   450

 */

   451

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

   452

   453

/**

   454

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

   455

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

   456

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

   457

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

   458

 */

   459

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

   460

   461

/**

   462

 * Save/Load an array.

   463

 * @param array The array being manipulated

   464

 * @param length The length of the array in elements

   465

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

   466

 */

   467

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

   468

{

   469

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

   470

   471

	// Automatically calculate the length?

   472

	if (_sl.need_length != NL_NONE) {

   473

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

   474

		// Determine length only?

   475

		if (_sl.need_length == NL_CALCLENGTH)

   476

			return;

   477

	}

   478

   479

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

   480

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

   481

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

   482

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

   483

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

   484

			conv = SLE_INT8;

   485

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

   486

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

   487

			conv = SLE_INT8;

   488

		}

   489

	}

   490

   491

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

   492

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

   493

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

   494

		SlCopyBytes(array, length);

   495

	} else {

   496

		byte *a = (byte*)array;

   497