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

#include <setjmp.h>

    30

    31

enum {

    32

	SAVEGAME_VERSION = 21,

    33

    34

};

    35

    36

uint16 _sl_version;       /// the major savegame version identifier

    37

byte   _sl_minor_version; /// the minor savegame version, DO NOT USE!

    38

    39

typedef void WriterProc(uint len);

    40

typedef uint ReaderProc(void);

    41

    42

typedef uint ReferenceToIntProc(const void *obj, SLRefType rt);

    43

typedef void *IntToReferenceProc(uint index, SLRefType rt);

    44

    45

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

    46

static struct {

    47

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

    48

	byte need_length;                    /// ???

    49

	byte block_mode;                     /// ???

    50

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

    51

    52

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

    53

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

    54

    55

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

    56

    57

	WriterProc *write_bytes;             /// savegame writer function

    58

	ReaderProc *read_bytes;              /// savegame loader function

    59

    60

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

    61

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

    62

    63

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

    64

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

    65

    66

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

    67

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

    68

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

    69

    70

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

    71

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

    72

	byte *buf_ori;                       /// pointer to the original memory location of buf, used to free it afterwards

    73

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

    74

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

    75

    76

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

    77

	const char *excpt_msg;               /// the error message

    78

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

    79

} _sl;

    80

    81

    82

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

    83

    84

/**

    85

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

    86

 */

    87

static void SlReadFill(void)

    88

{

    89

	uint len = _sl.read_bytes();

    90

	assert(len != 0);

    91

    92

	_sl.bufp = _sl.buf;

    93

	_sl.bufe = _sl.buf + len;

    94

	_sl.offs_base += len;

    95

}

    96

    97

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

    98

    99

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

   100

 * as it appears in memory. @see VarTypes

   101

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

   102

 * @return Return the size of this type in bytes */

   103

static inline byte SlCalcConvMemLen(VarType conv)

   104

{

   105

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

   106

	byte length = (conv >> 4) & 0xF;

   107

	assert(length < lengthof(conv_mem_size));

   108

	return conv_mem_size[length];

   109

}

   110

   111

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

   112

 * as it appears in a saved game. @see VarTypes

   113

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

   114

 * @return Return the size of this type in bytes */

   115

static inline byte SlCalcConvFileLen(VarType conv)

   116

{

   117

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

   118

	byte length = conv & 0xF;

   119

	assert(length < lengthof(conv_file_size));

   120

	return conv_file_size[length];

   121

}

   122

   123

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

   124

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

   125

   126

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

   127

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

   128

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

   129

 */

   130

static void SlWriteFill(void)

   131

{

   132

	// flush the buffer to disk (the writer)

   133

	if (_sl.bufp != NULL) {

   134

		uint len = _sl.bufp - _sl.buf;

   135

		_sl.offs_base += len;

   136

		if (len) _sl.write_bytes(len);

   137

	}

   138

   139

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

   140

	* to start reading in more data */

   141

	_sl.bufp = _sl.buf;

   142

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

   143

}

   144

   145

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

   146

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

   147

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

   148

static void NORETURN SlError(const char *msg)

   149

{

   150

	_sl.excpt_msg = msg;

   151

	longjmp(_sl.excpt, 0);

   152

}

   153

   154

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

   155

 * flush it to its final destination

   156

 * @return return the read byte from file

   157

 */

   158

static inline byte SlReadByteInternal(void)

   159

{

   160

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

   161

	return *_sl.bufp++;

   162

}

   163

   164

/** Wrapper for SlReadByteInternal */

   165

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

   166

   167

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

   168

 * flush it to its destination (file)

   169

 * @param b the byte that is currently written

   170

 */

   171

static inline void SlWriteByteInternal(byte b)

   172

{

   173

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

   174

	*_sl.bufp++ = b;

   175

}

   176

   177

/** Wrapper for SlWriteByteInternal */

   178

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

   179

   180

static inline int SlReadUint16(void)

   181

{

   182

	int x = SlReadByte() << 8;

   183

	return x | SlReadByte();

   184

}

   185

   186

static inline uint32 SlReadUint32(void)

   187

{

   188

	uint32 x = SlReadUint16() << 16;

   189

	return x | SlReadUint16();

   190

}

   191

   192

static inline uint64 SlReadUint64(void)

   193

{

   194

	uint32 x = SlReadUint32();

   195

	uint32 y = SlReadUint32();

   196

	return (uint64)x << 32 | y;

   197

}

   198

   199

static inline void SlWriteUint16(uint16 v)

   200

{

   201

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

   202

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

   203

}

   204

   205

static inline void SlWriteUint32(uint32 v)

   206

{

   207

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

   208

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

   209

}

   210

   211

static inline void SlWriteUint64(uint64 x)

   212

{

   213

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

   214

	SlWriteUint32((uint32)x);

   215

}

   216

   217

/**

   218

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

   219

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

   220

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

   221

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

   222

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

   223

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

   224

 * @return Return the value of the index

   225

 */

   226

static uint SlReadSimpleGamma(void)

   227

{

   228

	uint i = SlReadByte();

   229

	if (HASBIT(i, 7)) {

   230

		i &= ~0x80;

   231

		if (HASBIT(i, 6)) {

   232

			i &= ~0x40;

   233

			if (HASBIT(i, 5)) {

   234

				i &= ~0x20;

   235

				if (HASBIT(i, 4))

   236

					SlError("Unsupported gamma");

   237

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

   238

			}

   239

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

   240

		}

   241

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

   242

	}

   243

	return i;

   244

}

   245

   246

/**

   247

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

   248

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

   249

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

   250

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

   251

 * 0xxxxxxx

   252

 * 10xxxxxx xxxxxxxx

   253

 * 110xxxxx xxxxxxxx xxxxxxxx

   254

 * 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx

   255

 * @param i Index being written

   256

 */

   257

   258

static void SlWriteSimpleGamma(uint i)

   259

{

   260

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

   261

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

   262

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

   263

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

   264

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

   265

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

   266

			} else {

   267

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

   268

			}

   269

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

   270

		} else {

   271

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

   272

		}

   273

	}

   274

	SlWriteByte(i);

   275

}

   276

   277

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

   278

static inline uint SlGetGammaLength(uint i) {

   279

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

   280

}

   281

   282

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

   283

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

   284

   285

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

   286

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

   287

   288

void SlSetArrayIndex(uint index)

   289

{

   290

	_sl.need_length = NL_WANTLENGTH;

   291

	_sl.array_index = index;

   292

}

   293

   294

/**

   295

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

   296

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

   297

 */

   298

int SlIterateArray(void)

   299

{

   300

	int index;

   301

	static uint32 next_offs;

   302

   303

	/* After reading in the whole array inside the loop

   304

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

   305

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

   306

   307

	while (true) {

   308

		uint length = SlReadArrayLength();

   309

		if (length == 0) {

   310

			next_offs = 0;

   311

			return -1;

   312

		}

   313

   314

		_sl.obj_len = --length;

   315

		next_offs = SlGetOffs() + length;

   316

   317

		switch (_sl.block_mode) {

   318

		case CH_SPARSE_ARRAY: index = (int)SlReadSparseIndex(); break;

   319

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

   320

		default:

   321

			DEBUG(misc, 0) ("[Sl] SlIterateArray: error");

   322

			return -1; // error

   323

		}

   324

   325

		if (length != 0) return index;

   326

	}

   327

}

   328

   329

/**

   330

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

   331

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

   332

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

   333

 */

   334

void SlSetLength(size_t length)

   335

{

   336

	assert(_sl.save);

   337

   338

	switch (_sl.need_length) {

   339

	case NL_WANTLENGTH:

   340

		_sl.need_length = NL_NONE;

   341

		switch (_sl.block_mode) {

   342

		case CH_RIFF:

   343

			// Ugly encoding of >16M RIFF chunks

   344

			// The lower 24 bits are normal

   345

			// The uppermost 4 bits are bits 24:27

   346

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

   347

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

   348

			break;

   349

		case CH_ARRAY:

   350

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

   351

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

   352

				SlWriteArrayLength(1);

   353

			SlWriteArrayLength(length + 1);

   354

			break;

   355

		case CH_SPARSE_ARRAY:

   356

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

   357

			SlWriteSparseIndex(_sl.array_index);

   358

			break;

   359

		default: NOT_REACHED();

   360

		} break;

   361

	case NL_CALCLENGTH:

   362

		_sl.obj_len += length;

   363

		break;

   364

	}

   365

}

   366

   367

/**

   368

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

   369

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

   370

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

   371

 * @param length number of bytes this fast CopyBytes lasts

   372

 */

   373

static void SlCopyBytes(void *ptr, size_t length)

   374

{

   375

	byte *p = (byte*)ptr;

   376

   377

	if (_sl.save) {

   378

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

   379

	} else {

   380

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

   381

	}

   382

}

   383

   384

#if 0

   385

/**

   386

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

   387

 * anything with them

   388

 * NOTICE: currently unused

   389

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

   390

 */

   391

static inline void SlSkipBytes(size_t length)

   392

{

   393

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

   394

		SlReadByte();

   395

}

   396

#endif

   397

   398

/* Get the length of the current object */

   399

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

   400

   401

/**

   402

 * Handle all conversion and typechecking of variables here.

   403

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

   404

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

   405

 * goes exactly the opposite way

   406

 * @param ptr The object being filled/read

   407

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

   408

 */

   409

static void SlSaveLoadConv(void *ptr, VarType conv)

   410

{

   411

	int64 x = 0;

   412

   413

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

   414

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

   415

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

   416

		case SLE_VAR_BL   >> 4:

   417

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

   418

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

   419

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

   420

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

   421

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

   422

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

   423

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

   424

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

   425

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

   426

		default: NOT_REACHED();

   427

		}

   428

   429

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

   430

		switch (conv & 0xF) {

   431

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

   432

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

   433

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

   434

		case SLE_FILE_STRINGID:

   435

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

   436

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

   437

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

   438

		default: NOT_REACHED();

   439

		}

   440

	} else { /* LOAD values */

   441

   442

		// Read a value from the file

   443

		switch (conv & 0xF) {

   444

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

   445

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

   446

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

   447

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

   448

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

   449

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

   450

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

   451

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

   452

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

   453

		default: NOT_REACHED();

   454

		}

   455

   456

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

   457

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

   458

		case SLE_VAR_BL   >> 4:

   459

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

   460

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

   461

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

   462

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

   463

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

   464

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

   465

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

   466

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

   467

		case SLE_VAR_NULL >> 4: break;

   468

		default: NOT_REACHED();

   469

		}

   470

	}

   471

}

   472

   473

static inline size_t SlCalcStringLen(const char *ptr, uint length)

   474

{

   475

	DEBUG(misc, 1) ("[Sl] TODO: save/load real length");

   476

	return length;//(_sl.save) ? min(strlen(ptr), length - 1) : SlReadArrayLength();

   477

}

   478

   479

/**

   480

 * Save/Load a string.

   481

 * @param ptr the string being manipulated

   482

 * @param the length of the string (full length)

   483

 * @param conv must be SLE_FILE_STRING

   484

 * @todo the full length of the string is saved, even when the buffer

   485

 * is 512 bytes and only 10 of those are used */

   486

static void SlString(void *ptr, uint length, VarType conv)

   487

{

   488

	uint len = SlCalcStringLen(ptr, length);

   489

	assert((conv & 0xF) == SLE_FILE_STRING);

   490

   491

	SlCopyBytes(ptr, len);

   492

}

   493

   494

/**

   495

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