1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "vehicle.h"

     4

#include "station.h"

     5

#include "town.h"

     6

#include "player.h"

     7

#include "saveload.h"

     8

#include <setjmp.h>

     9

    10

enum {

    11

	SAVEGAME_MAJOR_VERSION = 4,

    12

	SAVEGAME_MINOR_VERSION = 1,

    13

    14

	SAVEGAME_LOADABLE_VERSION = (SAVEGAME_MAJOR_VERSION << 8) + SAVEGAME_MINOR_VERSION

    15

};

    16

    17

/******************************************************/

    18

/******************************************************/

    19

/******************************************************/

    20

    21

typedef void WriterProc(uint len);

    22

typedef uint ReaderProc();

    23

    24

typedef uint ReferenceToIntProc(void *v, uint t);

    25

typedef void *IntToReferenceProc(uint r, uint t);

    26

    27

typedef struct {

    28

	bool save;

    29

	byte need_length;

    30

	byte block_mode;

    31

	bool error;

    32

	byte version;

    33

    34

	int obj_len;

    35

	int array_index, last_array_index;

    36

    37

	uint32 offs_base;

    38

    39

	WriterProc *write_bytes;

    40

	ReaderProc *read_bytes;

    41

    42

	ReferenceToIntProc *ref_to_int_proc;

    43

	IntToReferenceProc *int_to_ref_proc;

    44

    45

	const ChunkHandler * const * chs;

    46

	const byte * const *includes;

    47

    48

	byte *bufp, *bufe;

    49

    50

	int tmp;

    51

    52

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

    53

	byte *buf; // pointer and size to read/write, initialized by init

    54

	uint bufsize;

    55

	FILE *fh;

    56

    57

	void (*excpt_uninit)();

    58

	const char *excpt_msg;

    59

	jmp_buf excpt; // used to jump to "exception handler"

    60

} SaverLoader;

    61

    62

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

    63

    64

SaverLoader _sl;

    65

    66

// fill the input buffer

    67

static void SlReadFill()

    68

{

    69

	uint len = _sl.read_bytes();

    70

	assert(len != 0);

    71

    72

	_sl.bufp = _sl.buf;

    73

	_sl.bufe = _sl.buf + len;

    74

	_sl.offs_base += len;

    75

}

    76

    77

static uint32 SlGetOffs()

    78

{

    79

	return _sl.offs_base - (_sl.bufe - _sl.bufp);

    80

}

    81

    82

// flush the output buffer

    83

static void SlWriteFill()

    84

{

    85

	// flush current buffer?

    86

	if (_sl.bufp != NULL) {

    87

		uint len = _sl.bufp - _sl.buf;

    88

		_sl.offs_base += len;

    89

		if (len) _sl.write_bytes(len);

    90

	}

    91

    92

	// setup next buffer

    93

	_sl.bufp = _sl.buf;

    94

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

    95

}

    96

    97

// error handler, calls longjmp to simulate an exception.

    98

static void NORETURN SlError(const char *msg)

    99

{

   100

	_sl.excpt_msg = msg;

   101

	longjmp(_sl.excpt, 0);

   102

}

   103

   104

int SlReadByte()

   105

{

   106

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

   107

	return *_sl.bufp++;

   108

}

   109

   110

void SlWriteByte(byte v)

   111

{

   112

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

   113

	*_sl.bufp++ = v;

   114

}

   115

   116

static int SlReadUint16()

   117

{

   118

	int x = SlReadByte() << 8;

   119

	return x | SlReadByte();

   120

}

   121

   122

static uint32 SlReadUint32()

   123

{

   124

	uint32 x = SlReadUint16() << 16;

   125

	return x | SlReadUint16();

   126

}

   127

   128

static uint64 SlReadUint64()

   129

{

   130

	uint32 x = SlReadUint32();

   131

	uint32 y = SlReadUint32();

   132

	return (uint64)x << 32 | y;

   133

}

   134

   135

static void SlWriteUint16(uint16 v)

   136

{

   137

	SlWriteByte((byte)(v >> 8));

   138

	SlWriteByte((byte)v);

   139

}

   140

   141

static void SlWriteUint32(uint32 v)

   142

{

   143

	SlWriteUint16((uint16)(v >> 16));

   144

	SlWriteUint16((uint16)v);

   145

}

   146

   147

static void SlWriteUint64(uint64 x)

   148

{

   149

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

   150

	SlWriteUint32((uint32)x);

   151

}

   152

   153

static int SlReadSimpleGamma()

   154

{

   155

	int x = SlReadByte();

   156

	if (x & 0x80)

   157

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

   158

	return x;

   159

}

   160

   161

static void SlWriteSimpleGamma(uint i)

   162

{

   163

	assert(i < (1 << 14));

   164

	if (i >= 0x80) {

   165

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

   166

		SlWriteByte((byte)i);

   167

	} else {

   168

		SlWriteByte(i);

   169

	}

   170

}

   171

   172

static uint SlGetGammaLength(uint i) {

   173

	return (i>=0x80) ? 2 : 1;

   174

}

   175

   176

int inline SlReadSparseIndex()

   177

{

   178

	return SlReadSimpleGamma();

   179

}

   180

   181

void inline SlWriteSparseIndex(uint index)

   182

{

   183

	SlWriteSimpleGamma(index);

   184

}

   185

   186

int inline SlReadArrayLength()

   187

{

   188

	return SlReadSimpleGamma();

   189

}

   190

   191

void inline SlWriteArrayLength(uint length)

   192

{

   193

	SlWriteSimpleGamma(length);

   194

}

   195

   196

void SlSetArrayIndex(uint index)

   197

{

   198

	_sl.need_length = NL_WANTLENGTH;

   199

	_sl.array_index = index;

   200

}

   201

   202

int SlIterateArray()

   203

{

   204

	int ind;

   205

	static uint32 next_offs;

   206

   207

	// Must be at end of current block.

   208

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

   209

   210

	while(true) {

   211

		uint len = SlReadArrayLength();

   212

		if (len == 0) {

   213

			next_offs = 0;

   214

			return -1;

   215

		}

   216

   217

		_sl.obj_len = --len;

   218

		next_offs = SlGetOffs() + len;

   219

   220

		switch(_sl.block_mode) {

   221

		case CH_SPARSE_ARRAY:	ind = SlReadSparseIndex(); break;

   222

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

   223

		default:

   224

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

   225

			return -1; // error

   226

		}

   227

   228

		if (len != 0)

   229

			return ind;

   230

	}

   231

}

   232

   233

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

   234

void SlSetLength(uint length)

   235

{

   236

	switch(_sl.need_length) {

   237

	case NL_WANTLENGTH:

   238

		_sl.need_length = NL_NONE;

   239

		switch(_sl.block_mode) {

   240

		case CH_RIFF:

   241

			// Really simple to write a RIFF length :)

   242

			SlWriteUint32(length);

   243

		break;

   244

		case CH_ARRAY:

   245

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

   246

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

   247

				SlWriteArrayLength(1);

   248

			SlWriteArrayLength(length + 1);

   249

			break;

   250

		case CH_SPARSE_ARRAY:

   251

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

   252

			SlWriteSparseIndex(_sl.array_index);

   253

			break;

   254

		default: NOT_REACHED();

   255

		}

   256

		break;

   257

	case NL_CALCLENGTH:

   258

		_sl.obj_len += length;

   259

		break;

   260

	}

   261

}

   262

   263

static void SlCopyBytes(void *ptr, size_t length)

   264

{

   265

	byte *p = (byte*)ptr;

   266

   267

	if (_sl.save) {

   268

		while(length) {

   269

			SlWriteByte(*p++);

   270

			length--;

   271

		}

   272

	} else {

   273

		while(length) {

   274

			// INLINED SlReadByte

   275

#if !defined(_DEBUG)

   276

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

   277

			*p++ = *_sl.bufp++;

   278

#else

   279

			*p++ = SlReadByte();

   280

#endif

   281

			length--;

   282

		}

   283

	}

   284

}

   285

   286

void SlSkipBytes(size_t length)

   287

{

   288

	while (length) {

   289

		SlReadByte();

   290

		length--;

   291

	}

   292

}

   293

   294

uint SlGetFieldLength()

   295

{

   296

	return _sl.obj_len;

   297

}

   298

   299

   300

static void SlSaveLoadConv(void *ptr, uint conv)

   301

{

   302

	int64 x = 0;

   303

   304

	if (_sl.save) {

   305

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

   306

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

   307

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

   308

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

   309

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

   310

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

   311

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

   312

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

   313

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

   314

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

   315

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

   316

		default:

   317

			NOT_REACHED();

   318

		}

   319

   320

		// Write it to the file

   321

		switch(conv & 0xF) {

   322

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

   323

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

   324

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

   325

		case SLE_FILE_STRINGID:

   326

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

   327

		case SLE_FILE_I32:

   328

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

   329

		case SLE_FILE_I64:

   330

		case SLE_FILE_U64:SlWriteUint64(x);break;

   331

		default:

   332

			assert(0);

   333

			NOT_REACHED();

   334

		}

   335

	} else {

   336

   337

		// Read a value from the file

   338

		switch(conv & 0xF) {

   339

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

   340

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

   341

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

   342

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

   343

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

   344

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

   345

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

   346

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

   347

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

   348

		default:

   349

			assert(0);

   350

			NOT_REACHED();

   351

		}

   352

   353

		// Write it to the struct, these ARE endian safe.

   354

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

   355

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

   356

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

   357

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

   358

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

   359

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

   360

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

   361

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

   362

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

   363

		case SLE_VAR_NULL: break;

   364

		default:

   365

			NOT_REACHED();

   366

		}

   367

	}

   368

}

   369

   370

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

   371

   372

static uint SlCalcConvLen(uint conv, void *p)

   373

{

   374

	return _conv_lengths[conv & 0xF];

   375

}

   376

   377

static uint SlCalcArrayLen(void *array, uint length, uint conv)

   378

{

   379

	return _conv_lengths[conv & 0xF] * length;

   380

}

   381

   382

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

   383

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

   384

{

   385

	// Automatically calculate the length?

   386

	if (_sl.need_length != NL_NONE) {

   387

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

   388

		// Determine length only?

   389

		if (_sl.need_length == NL_CALCLENGTH)

   390

			return;

   391

	}

   392

   393

	// handle buggy stuff

   394

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

   395

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

   396

			length *= 2;

   397

			conv = SLE_INT8;

   398

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

   399

			length *= 4;

   400

			conv = SLE_INT8;

   401

		}

   402

	}

   403

   404

	// Optimized cases when input equals output.

   405

	switch(conv) {

   406

	case SLE_INT8:

   407

	case SLE_UINT8:SlCopyBytes(array, length);break;

   408

	default: {

   409

		// Default "slow" case.

   410

		byte *a = (byte*)array;

   411

		while (length) {

   412

			SlSaveLoadConv(a, conv);

   413

			a += _conv_mem_size[(conv >> 4)&0xf];

   414

			length--;

   415

		}

   416

		}

   417

	}

   418

}

   419

   420

// Calculate the size of an object.

   421

static size_t SlCalcObjLength(void *object, const void *desc)

   422

{

   423

	size_t length = 0;

   424

	uint cmd,conv;

   425

	const byte *d = (const byte*)desc;

   426

   427

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

   428

	while (true) {

   429

		cmd = (d[0] >> 4);

   430

		if (cmd < 8) {

   431

			conv = d[2];

   432

			d += 3;

   433

			if (cmd&4) {

   434

				d += 2;

   435

				// check if the field is of the right version

   436

				if (_sl.version < d[-2] || _sl.version > d[-1]) {

   437

					if ((cmd & 3) == 2) d++;

   438

					continue;

   439

				}

   440

			}

   441

   442

			switch(cmd&3) {

   443

			// Normal variable

   444

			case 0: length += SlCalcConvLen(conv, NULL);break;

   445

			// Reference

   446

			case 1: length += 2; break;

   447

			// Array

   448

			case 2:	length += SlCalcArrayLen(NULL, *d++, conv); break;

   449

			default:NOT_REACHED();

   450

			}

   451

		} else if (cmd == 8) {

   452

			length++;

   453

			d += 4;

   454

		} else if (cmd == 9) {

   455

			length += SlCalcObjLength(NULL, _sl.includes[d[2]]);

   456

			d += 3;

   457

		} else if (cmd == 15)

   458

			break;

   459

		else

   460

			assert(0);

   461

	}

   462

	return length;

   463

}

   464

   465

void SlObject(void *object, const void *desc)

   466

{

   467

	const byte *d = (const byte*)desc;

   468

	void *ptr;

   469

	uint cmd,conv;

   470

   471

	// Automatically calculate the length?

   472

	if (_sl.need_length != NL_NONE) {

   473

		SlSetLength(SlCalcObjLength(object, d));

   474

		if (_sl.need_length == NL_CALCLENGTH)

   475

			return;

   476

	}

   477

   478

	while (true) {

   479

		// Currently it only supports up to 4096 byte big objects

   480

		ptr = (byte*)object + (d[0] & 0xF) + (d[1] << 4);

   481

   482

		cmd = d[0] >> 4;

   483

   484

		if (cmd < 8) {

   485

			conv = d[2];

   486

			d += 3;

   487

   488

			if (cmd&4) {

   489

				d += 2;

   490

				// check if the field is of the right version

   491

				if (_sl.version < d[-2] || _sl.version > d[-1]) {

   492

					if ((cmd & 3) == 2) d++;

   493

					continue;

   494

				}

   495

			}

   496

   497

			switch(cmd&3) {

   498

			// Normal variable

   499

			case 0:	SlSaveLoadConv(ptr, conv); break;

   500

			// Reference

   501

			case 1:

   502

				if (_sl.save) {

   503

					SlWriteUint16(_sl.ref_to_int_proc(*(void**)ptr, conv));

   504

				} else {

   505

					*(void**)ptr = _sl.int_to_ref_proc(SlReadUint16(), conv);

   506

				}

   507

				break;

   508

			// Array

   509

			case 2:	SlArray(ptr, *d++, conv); break;

   510

			default:NOT_REACHED();

   511

			}

   512

   513

		// Write byte.

   514

		} else if (cmd == 8) {

   515

			if (_sl.save) {

   516

				SlWriteByte(d[3]);

   517

			} else {

   518

				*(byte*)ptr = d[2];

   519

			}

   520

			d += 4;

   521

   522

		// Include

   523

		} else if (cmd == 9) {

   524

			SlObject(ptr, _sl.includes[d[2]]);

   525

			d += 3;