1

/* $Id$ */

     2

     3

/** @file saveload.cpp

     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

 */

    16

#include "stdafx.h"

    17

#include "openttd.h"

    18

#include "debug.h"

    19

#include "station.h"

    20

#include "thread.h"

    21

#include "town.h"

    22

#include "saveload.h"

    23

#include "network/network.h"

    24

#include "variables.h"

    25

#include "table/strings.h"

    26

#include "window_func.h"

    27

#include "strings_func.h"

    28

#include "gfx_func.h"

    29

#include "core/alloc_func.hpp"

    30

#include "functions.h"

    31

#include "core/endian_func.hpp"

    32

#include "vehicle_base.h"

    33

#include "autoreplace_base.h"

    34

#include <list>

    35

    36

extern const uint16 SAVEGAME_VERSION = 83;

    37

uint16 _sl_version;       ///< the major savegame version identifier

    38

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

    39

    40

typedef void WriterProc(uint len);

    41

typedef uint ReaderProc();

    42

    43

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

    44

static struct {

    45

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

    46

	byte need_length;                    ///< ???

    47

	byte block_mode;                     ///< ???

    48

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

    49

    50

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

    51

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

    52

    53

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

    54

    55

	WriterProc *write_bytes;             ///< savegame writer function

    56

	ReaderProc *read_bytes;              ///< savegame loader function

    57

    58

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

    59

    60

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

    61

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

    62

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

    63

    64

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

    65

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

    66

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

    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)();              ///< the function to execute on any encountered error

    71

	StringID error_str;                  ///< the translateable error message to show

    72

	char *extra_msg;                     ///< the error message

    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()

    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() {return _sl.offs_base - (_sl.bufe - _sl.bufp);}

    92

    93

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

    94

 * as it appears in memory. See VarTypes

    95

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

    96

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

    97

static inline byte SlCalcConvMemLen(VarType conv)

    98

{

    99

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

   100

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

   101

	assert(length < lengthof(conv_mem_size));

   102

	return conv_mem_size[length];

   103

}

   104

   105

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

   106

 * as it appears in a saved game. See VarTypes

   107

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

   108

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

   109

static inline byte SlCalcConvFileLen(VarType conv)

   110

{

   111

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

   112

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

   113

	assert(length < lengthof(conv_file_size));

   114

	return conv_file_size[length];

   115

}

   116

   117

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

   118

static inline size_t SlCalcRefLen() {return CheckSavegameVersion(69) ? 2 : 4;}

   119

   120

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

   121

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

   122

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

   123

 */

   124

static void SlWriteFill()

   125

{

   126

	/* flush the buffer to disk (the writer) */

   127

	if (_sl.bufp != NULL) {

   128

		uint len = _sl.bufp - _sl.buf;

   129

		_sl.offs_base += len;

   130

		if (len) _sl.write_bytes(len);

   131

	}

   132

   133

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

   134

	 * to start reading in more data */

   135

	_sl.bufp = _sl.buf;

   136

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

   137

}

   138

   139

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

   140

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

   141

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

   142

static void NORETURN SlError(StringID string, const char *extra_msg = NULL)

   143

{

   144

	_sl.error_str = string;

   145

	free(_sl.extra_msg);

   146

	_sl.extra_msg = (extra_msg == NULL) ? NULL : strdup(extra_msg);

   147

	throw std::exception();

   148

}

   149

   150

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

   151

 * flush it to its final destination

   152

 * @return return the read byte from file

   153

 */

   154

static inline byte SlReadByteInternal()

   155

{

   156

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

   157

	return *_sl.bufp++;

   158

}

   159

   160

/** Wrapper for SlReadByteInternal */

   161

byte SlReadByte() {return SlReadByteInternal();}

   162

   163

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

   164

 * flush it to its destination (file)

   165

 * @param b the byte that is currently written

   166

 */

   167

static inline void SlWriteByteInternal(byte b)

   168

{

   169

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

   170

	*_sl.bufp++ = b;

   171

}

   172

   173

/** Wrapper for SlWriteByteInternal */

   174

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

   175

   176

static inline int SlReadUint16()

   177

{

   178

	int x = SlReadByte() << 8;

   179

	return x | SlReadByte();

   180

}

   181

   182

static inline uint32 SlReadUint32()

   183

{

   184

	uint32 x = SlReadUint16() << 16;

   185

	return x | SlReadUint16();

   186

}

   187

   188

static inline uint64 SlReadUint64()

   189

{

   190

	uint32 x = SlReadUint32();

   191

	uint32 y = SlReadUint32();

   192

	return (uint64)x << 32 | y;

   193

}

   194

   195

static inline void SlWriteUint16(uint16 v)

   196

{

   197

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

   198

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

   199

}

   200

   201

static inline void SlWriteUint32(uint32 v)

   202

{

   203

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

   204

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

   205

}

   206

   207

static inline void SlWriteUint64(uint64 x)

   208

{

   209

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

   210

	SlWriteUint32((uint32)x);

   211

}

   212

   213

/**

   214

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

   215

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

   216

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

   217

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

   218

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

   219

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

   220

 * @return Return the value of the index

   221

 */

   222

static uint SlReadSimpleGamma()

   223

{

   224

	uint i = SlReadByte();

   225

	if (HasBit(i, 7)) {

   226

		i &= ~0x80;

   227

		if (HasBit(i, 6)) {

   228

			i &= ~0x40;

   229

			if (HasBit(i, 5)) {

   230

				i &= ~0x20;

   231

				if (HasBit(i, 4))

   232

					SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unsupported gamma");

   233

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

   234

			}

   235

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

   236

		}

   237

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

   238

	}

   239

	return i;

   240

}

   241

   242

/**

   243

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

   244

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

   245

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

   246

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

   247

 * 0xxxxxxx

   248

 * 10xxxxxx xxxxxxxx

   249

 * 110xxxxx xxxxxxxx xxxxxxxx

   250

 * 1110xxxx xxxxxxxx xxxxxxxx xxxxxxxx

   251

 * @param i Index being written

   252

 */

   253

   254

static void SlWriteSimpleGamma(uint i)

   255

{

   256

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

   257

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

   258

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

   259

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

   260

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

   261

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

   262

			} else {

   263

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

   264

			}

   265

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

   266

		} else {

   267

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

   268

		}

   269

	}

   270

	SlWriteByte(i);

   271

}

   272

   273

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

   274

static inline uint SlGetGammaLength(uint i)

   275

{

   276

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

   277

}

   278

   279

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

   280

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

   281

   282

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

   283

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

   284

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

   285

   286

void SlSetArrayIndex(uint index)

   287

{

   288

	_sl.need_length = NL_WANTLENGTH;

   289

	_sl.array_index = index;

   290

}

   291

   292

static uint32 _next_offs;

   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()

   299

{

   300

	int index;

   301

   302

	/* After reading in the whole array inside the loop

   303

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

   304

	if (_next_offs != 0 && SlGetOffs() != _next_offs) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Invalid chunk size");

   305

   306

	while (true) {

   307

		uint length = SlReadArrayLength();

   308

		if (length == 0) {

   309

			_next_offs = 0;

   310

			return -1;

   311

		}

   312

   313

		_sl.obj_len = --length;

   314

		_next_offs = SlGetOffs() + length;

   315

   316

		switch (_sl.block_mode) {

   317

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

   318

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

   319

		default:

   320

			DEBUG(sl, 0, "SlIterateArray error");

   321

			return -1; // error

   322

		}

   323

   324

		if (length != 0) return index;

   325

	}

   326

}

   327

   328

/**

   329

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

   330

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

   331

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

   332

 */

   333

void SlSetLength(size_t length)

   334

{

   335

	assert(_sl.save);

   336

   337

	switch (_sl.need_length) {

   338

	case NL_WANTLENGTH:

   339

		_sl.need_length = NL_NONE;

   340

		switch (_sl.block_mode) {

   341

		case CH_RIFF:

   342

			/* Ugly encoding of >16M RIFF chunks

   343

			 * The lower 24 bits are normal

   344

			 * The uppermost 4 bits are bits 24:27 */

   345

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

   346

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

   347

			break;

   348

		case CH_ARRAY:

   349

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

   350

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

   351

				SlWriteArrayLength(1);

   352

			SlWriteArrayLength(length + 1);

   353

			break;

   354

		case CH_SPARSE_ARRAY:

   355

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

   356

			SlWriteSparseIndex(_sl.array_index);

   357

			break;

   358

		default: NOT_REACHED();

   359

		} break;

   360

	case NL_CALCLENGTH:

   361

		_sl.obj_len += length;

   362

		break;

   363

	}

   364

}

   365

   366

/**

   367

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

   368

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

   369

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

   370

 * @param length number of bytes this fast CopyBytes lasts

   371

 */

   372

static void SlCopyBytes(void *ptr, size_t length)

   373

{

   374

	byte *p = (byte*)ptr;

   375

   376

	if (_sl.save) {

   377

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

   378

	} else {

   379

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

   380

	}

   381

}

   382

   383

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

   384

 * anything with them, discarding them in effect

   385

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

   386

 */

   387

static inline void SlSkipBytes(size_t length)

   388

{

   389

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

   390

}

   391

   392

/* Get the length of the current object */

   393

uint SlGetFieldLength() {return _sl.obj_len;}

   394

   395

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

   396

 * @param ptr pointer to the variable

   397

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

   398

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

   399

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

   400

int64 ReadValue(const void *ptr, VarType conv)

   401

{

   402

	switch (GetVarMemType(conv)) {

   403

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

   404

	case SLE_VAR_I8:  return *(int8*  )ptr;

   405

	case SLE_VAR_U8:  return *(byte*  )ptr;

   406

	case SLE_VAR_I16: return *(int16* )ptr;

   407

	case SLE_VAR_U16: return *(uint16*)ptr;

   408

	case SLE_VAR_I32: return *(int32* )ptr;

   409

	case SLE_VAR_U32: return *(uint32*)ptr;

   410

	case SLE_VAR_I64: return *(int64* )ptr;

   411

	case SLE_VAR_U64: return *(uint64*)ptr;

   412

	case SLE_VAR_NULL:return 0;

   413

	default: NOT_REACHED();

   414

	}

   415

   416

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

   417

	return 0;

   418

}

   419

   420

/** Write the value of a setting

   421

 * @param ptr pointer to the variable

   422

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

   423

 *             with other flags. It is parsed upon read

   424

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

   425

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

   426

{

   427

	switch (GetVarMemType(conv)) {

   428

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

   429

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

   430

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

   431

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

   432

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

   433

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

   434

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

   435

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

   436

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

   437

	case SLE_VAR_NULL: break;

   438

	default: NOT_REACHED();

   439

	}

   440

}

   441

   442

/**

   443

 * Handle all conversion and typechecking of variables here.

   444

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

   445

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

   446

 * goes exactly the opposite way

   447

 * @param ptr The object being filled/read

   448

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

   449

 */

   450

static void SlSaveLoadConv(void *ptr, VarType conv)

   451

{

   452

	int64 x = 0;

   453

   454

	if (_sl.save) { // SAVE values

   455

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

   456

		x = ReadValue(ptr, conv);

   457

   458

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

   459

		switch (GetVarFileType(conv)) {

   460

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

   461

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

   462

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

   463

		case SLE_FILE_STRINGID:

   464

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

   465

		case SLE_FILE_I32:

   466

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

   467

		case SLE_FILE_I64:

   468

		case SLE_FILE_U64:                                   SlWriteUint64(x);break;

   469

		default: NOT_REACHED();

   470

		}

   471

	} else { // LOAD values

   472

   473

		/* Read a value from the file */

   474

		switch (GetVarFileType(conv)) {

   475

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

   476

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

   477

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

   478

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

   479

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

   480

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

   481

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

   482

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

   483

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

   484

		default: NOT_REACHED();

   485

		}

   486

   487

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

   488

		WriteValue(ptr, conv, x);

   489

	}

   490

}