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 "hal.h"

    23

#include "vehicle.h"

    24

#include "station.h"

    25

#include "thread.h"

    26

#include "town.h"

    27

#include "player.h"

    28

#include "saveload.h"

    29

#include "network.h"

    30

#include "variables.h"

    31

#include <setjmp.h>

    32

    34

uint16 _sl_version;       /// the major savegame version identifier

    35

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

    36

    37

typedef void WriterProc(uint len);

    38

typedef uint ReaderProc(void);

    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

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

    56

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

    57

    58

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

    59

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

    60

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

    61

    62

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

    63

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

    64

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

    65

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

    66

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

    67

    68

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

    69

	const char *excpt_msg;               /// the error message

    70

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

    71

} _sl;

    72

    73

    74

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

    75

    76

/**

    77

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

    78

 */

    79

static void SlReadFill(void)

    80

{

    81

	uint len = _sl.read_bytes();

    82

	assert(len != 0);

    83

    84

	_sl.bufp = _sl.buf;

    85

	_sl.bufe = _sl.buf + len;

    86

	_sl.offs_base += len;

    87

}

    88

    89

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

    90

    91

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

    92

 * as it appears in memory. @see VarTypes

    93

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

    94

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

    95

static inline byte SlCalcConvMemLen(VarType conv)

    96

{

    97

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

    98

	byte length = GB(conv, 4, 4);

    99

	assert(length < lengthof(conv_mem_size));

   100

	return conv_mem_size[length];

   101

}

   102

   103

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

   104

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

   105

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

   106

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

   107

static inline byte SlCalcConvFileLen(VarType conv)

   108

{

   109

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

   110

	byte length = GB(conv, 0, 4);

   111

	assert(length < lengthof(conv_file_size));

   112

	return conv_file_size[length];

   113

}

   114

   115

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

   116

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

   117

   118

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

   119

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

   120

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

   121

 */

   122

static void SlWriteFill(void)

   123

{

   124

	// flush the buffer to disk (the writer)

   125

	if (_sl.bufp != NULL) {

   126

		uint len = _sl.bufp - _sl.buf;

   127

		_sl.offs_base += len;

   128

		if (len) _sl.write_bytes(len);

   129

	}

   130

   131

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

   132

	* to start reading in more data */

   133

	_sl.bufp = _sl.buf;

   134

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

   135

}

   136

   137

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

   138

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

   139

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

   140

static void NORETURN SlError(const char *msg)

   141

{

   142

	_sl.excpt_msg = msg;

   143

	longjmp(_sl.excpt, 0);

   144

}

   145

   146

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

   147

 * flush it to its final destination

   148

 * @return return the read byte from file

   149

 */

   150

static inline byte SlReadByteInternal(void)

   151

{

   152

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

   153

	return *_sl.bufp++;

   154

}

   155

   156

/** Wrapper for SlReadByteInternal */

   157

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

   158

   159

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

   160

 * flush it to its destination (file)

   161

 * @param b the byte that is currently written

   162

 */

   163

static inline void SlWriteByteInternal(byte b)

   164

{

   165

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

   166

	*_sl.bufp++ = b;

   167

}

   168

   169

/** Wrapper for SlWriteByteInternal */

   170

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

   171

   172

static inline int SlReadUint16(void)

   173

{

   174

	int x = SlReadByte() << 8;

   175

	return x | SlReadByte();

   176

}

   177

   178

static inline uint32 SlReadUint32(void)

   179

{

   180

	uint32 x = SlReadUint16() << 16;

   181

	return x | SlReadUint16();

   182

}

   183

   184

static inline uint64 SlReadUint64(void)

   185

{

   186

	uint32 x = SlReadUint32();

   187

	uint32 y = SlReadUint32();

   188

	return (uint64)x << 32 | y;

   189

}

   190

   191

static inline void SlWriteUint16(uint16 v)

   192

{

   193

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

   194

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

   195

}

   196

   197

static inline void SlWriteUint32(uint32 v)

   198

{

   199

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

   200

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

   201

}

   202

   203

static inline void SlWriteUint64(uint64 x)

   204

{

   205

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

   206

	SlWriteUint32((uint32)x);

   207

}

   208

   209

/**

   210

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

   211

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

   212

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

   213

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

   214

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

   215

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

   216

 * @return Return the value of the index

   217

 */

   218

static uint SlReadSimpleGamma(void)

   219

{

   220

	uint i = SlReadByte();

   221

	if (HASBIT(i, 7)) {

   222

		i &= ~0x80;

   223

		if (HASBIT(i, 6)) {

   224

			i &= ~0x40;

   225

			if (HASBIT(i, 5)) {

   226

				i &= ~0x20;

   227

				if (HASBIT(i, 4))

   228

					SlError("Unsupported gamma");

   229

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

   230

			}

   231

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

   232

		}

   233

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

   234

	}

   235

	return i;

   236

}

   237

   238

/**

   239

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

   240

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

   241

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

   242

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

   243

 * 0xxxxxxx

   244

 * 10xxxxxx xxxxxxxx

   245

 * 110xxxxx xxxxxxxx xxxxxxxx

   246

 * 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx

   247

 * @param i Index being written

   248

 */

   249

   250

static void SlWriteSimpleGamma(uint i)

   251

{

   252

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

   253

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

   254

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

   255

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

   256

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

   257

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

   258

			} else {

   259

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

   260

			}

   261

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

   262

		} else {

   263

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

   264

		}

   265

	}

   266

	SlWriteByte(i);

   267

}

   268

   269

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

   270

static inline uint SlGetGammaLength(uint i) {

   271

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

   272

}

   273

   274

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

   275

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

   276

   277

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

   278

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

   279

static inline uint SlGetArrayLength(uint length) {return SlGetGammaLength(length);}

   280

   281

void SlSetArrayIndex(uint index)

   282

{

   283

	_sl.need_length = NL_WANTLENGTH;

   284

	_sl.array_index = index;

   285

}

   286

   287

/**

   288

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

   289

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

   290

 */

   291

int SlIterateArray(void)

   292

{

   293

	int index;

   294

	static uint32 next_offs;

   295

   296

	/* After reading in the whole array inside the loop

   297

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

   298

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

   299

   300

	while (true) {

   301

		uint length = SlReadArrayLength();

   302

		if (length == 0) {

   303

			next_offs = 0;

   304

			return -1;

   305

		}

   306

   307

		_sl.obj_len = --length;

   308

		next_offs = SlGetOffs() + length;

   309

   310

		switch (_sl.block_mode) {

   311

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

   312

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

   313

		default:

   314

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

   315

			return -1; // error

   316

		}

   317

   318

		if (length != 0) return index;

   319

	}

   320

}

   321

   322

/**

   323

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

   324

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

   325

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

   326

 */

   327

void SlSetLength(size_t length)

   328

{

   329

	assert(_sl.save);

   330

   331

	switch (_sl.need_length) {

   332

	case NL_WANTLENGTH:

   333

		_sl.need_length = NL_NONE;

   334

		switch (_sl.block_mode) {

   335

		case CH_RIFF:

   336

			// Ugly encoding of >16M RIFF chunks

   337

			// The lower 24 bits are normal

   338

			// The uppermost 4 bits are bits 24:27

   339

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

   340

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

   341

			break;

   342

		case CH_ARRAY:

   343

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

   344

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

   345

				SlWriteArrayLength(1);

   346

			SlWriteArrayLength(length + 1);

   347

			break;

   348

		case CH_SPARSE_ARRAY:

   349

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

   350

			SlWriteSparseIndex(_sl.array_index);

   351

			break;

   352

		default: NOT_REACHED();

   353

		} break;

   354

	case NL_CALCLENGTH:

   355

		_sl.obj_len += length;

   356

		break;

   357

	}

   358

}

   359

   360

/**

   361

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

   362

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

   363

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

   364

 * @param length number of bytes this fast CopyBytes lasts

   365

 */

   366

static void SlCopyBytes(void *ptr, size_t length)

   367

{

   368

	byte *p = (byte*)ptr;

   369

   370

	if (_sl.save) {

   371

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

   372

	} else {

   373

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

   374

	}

   375

}

   376

   377

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

   378

 * anything with them, discarding them in effect

   379

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

   380

 */

   381

static inline void SlSkipBytes(size_t length)

   382

{

   383

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

   384

}

   385

   386

/* Get the length of the current object */

   387

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

   388

   389

/** Return a signed-long version of the value of a setting

   390

 * @param ptr pointer to the variable

   391

 * @param conv type of variable, can be a non-clean

   392

 * type, eg one with other flags because it is parsed

   393

 * @return returns the value of the pointer-setting */

   394

int64 ReadValue(const void *ptr, VarType conv)

   395

{

   396

	switch (GetVarMemType(conv)) {

   397

	case SLE_VAR_BL:  return (*(bool*)ptr != 0);

   398

	case SLE_VAR_I8:  return *(int8*  )ptr;

   399

	case SLE_VAR_U8:  return *(byte*  )ptr;

   400

	case SLE_VAR_I16: return *(int16* )ptr;

   401

	case SLE_VAR_U16: return *(uint16*)ptr;

   402

	case SLE_VAR_I32: return *(int32* )ptr;

   403

	case SLE_VAR_U32: return *(uint32*)ptr;

   404

	case SLE_VAR_I64: return *(int64* )ptr;

   405

	case SLE_VAR_U64: return *(uint64*)ptr;

   406

	case SLE_VAR_NULL:return 0;

   407

	default: NOT_REACHED();

   408

	}

   409

   410

	/* useless, but avoids compiler warning this way */

   411

	return 0;

   412

}

   413

   414

/** Write the value of a setting

   415

 * @param ptr pointer to the variable

   416

 * @param conv type of variable, can be a non-clean type, eg

   417

 * with other flags. It is parsed upon read

   418

 * @param var the new value being given to the variable */

   419

void WriteValue(void *ptr, VarType conv, int64 val)

   420

{

   421

	switch (GetVarMemType(conv)) {

   422

	case SLE_VAR_BL:  *(bool  *)ptr = (val != 0);  break;

   423

	case SLE_VAR_I8:  *(int8  *)ptr = val; break;

   424

	case SLE_VAR_U8:  *(byte  *)ptr = val; break;

   425

	case SLE_VAR_I16: *(int16 *)ptr = val; break;

   426

	case SLE_VAR_U16: *(uint16*)ptr = val; break;

   427

	case SLE_VAR_I32: *(int32 *)ptr = val; break;

   428

	case SLE_VAR_U32: *(uint32*)ptr = val; break;

   429

	case SLE_VAR_I64: *(int64 *)ptr = val; break;

   430

	case SLE_VAR_U64: *(uint64*)ptr = val; break;

   431

	case SLE_VAR_NULL: break;

   432

	default: NOT_REACHED();

   433

	}

   434

}

   435

   436

/**

   437

 * Handle all conversion and typechecking of variables here.

   438

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

   439

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

   440

 * goes exactly the opposite way

   441

 * @param ptr The object being filled/read

   442

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

   443

 */

   444

static void SlSaveLoadConv(void *ptr, VarType conv)

   445

{

   446

	int64 x = 0;

   447

   448

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

   449

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

   450

		x = ReadValue(ptr, conv);

   451

   452

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

   453

		switch (GetVarFileType(conv)) {

   454

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

   455

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

   456

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

   457

		case SLE_FILE_STRINGID:

   458

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

   459

		case SLE_FILE_I32:

   460

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

   461

		case SLE_FILE_I64:

   462

		case SLE_FILE_U64:                                   SlWriteUint64(x);break;

   463

		default: NOT_REACHED();

   464

		}

   465

	} else { /* LOAD values */

   466

   467

		/* Read a value from the file */

   468

		switch (GetVarFileType(conv)) {

   469

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

   470

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

   471

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

   472

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

   473

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

   474

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

   475

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

   476

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

   477

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

   478

		default: NOT_REACHED();

   479

		}

   480

   481

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

   482

		WriteValue(ptr, conv, x);

   483

	}

   484

}

   485

   486

/** Calculate the net length of a string. This is in almost all cases

   487

 * just strlen(), but if the string is not properly terminated, we'll

   488

 * resort to the maximum length of the buffer.

   489

 * @param ptr pointer to the stringbuffer

   490

 * @param length maximum length of the string (buffer)

   491

 * @return return the net length of the string */

   492

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

   493

{