1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "currency.h"

     6

#include "functions.h"

     7

#include "macros.h"

     8

#include "screenshot.h"

     9

#include "sound.h"

    10

#include "string.h"

    11

#include "variables.h"

    12

#include "network.h"

    13

#include "settings.h"

    14

#include "command.h"

    15

#include "console.h"

    16

#include "saveload.h"

    17

#include "npf.h"

    18

    19

/** The patch values that are used for new games and/or modified in config file */

    20

Patches _patches_newgame;

    21

    22

typedef struct IniFile IniFile;

    23

typedef struct IniItem IniItem;

    24

typedef struct IniGroup IniGroup;

    25

typedef struct SettingsMemoryPool SettingsMemoryPool;

    26

    27

static void pool_init(SettingsMemoryPool **pool);

    28

static void *pool_alloc(SettingsMemoryPool **pool, uint size);

    29

static void *pool_strdup(SettingsMemoryPool **pool, const char *mem, uint size);

    30

static void pool_free(SettingsMemoryPool **pool);

    31

    32

struct SettingsMemoryPool {

    33

	uint pos,size;

    34

	SettingsMemoryPool *next;

    35

	byte mem[1];

    36

};

    37

    38

static SettingsMemoryPool *pool_new(uint minsize)

    39

{

    40

	SettingsMemoryPool *p;

    41

	if (minsize < 4096 - 12) minsize = 4096 - 12;

    42

    43

	p = malloc(sizeof(SettingsMemoryPool) - 1 + minsize);

    44

	p->pos = 0;

    45

	p->size = minsize;

    46

	p->next = NULL;

    47

	return p;

    48

}

    49

    50

static void pool_init(SettingsMemoryPool **pool)

    51

{

    52

	*pool = pool_new(0);

    53

}

    54

    55

static void *pool_alloc(SettingsMemoryPool **pool, uint size)

    56

{

    57

	uint pos;

    58

	SettingsMemoryPool *p = *pool;

    59

    60

	size = ALIGN(size, sizeof(void*));

    61

    62

	// first check if there's memory in the next pool

    63

	if (p->next && p->next->pos + size <= p->next->size) {

    64

		p = p->next;

    65

	// then check if there's not memory in the cur pool

    66

	} else if (p->pos + size > p->size) {

    67

		SettingsMemoryPool *n = pool_new(size);

    68

		*pool = n;

    69

		n->next = p;

    70

		p = n;

    71

	}

    72

    73

	pos = p->pos;

    74

	p->pos += size;

    75

	return p->mem + pos;

    76

}

    77

    78

static void *pool_strdup(SettingsMemoryPool **pool, const char *mem, uint size)

    79

{

    80

	byte *p = pool_alloc(pool, size + 1);

    81

	p[size] = 0;

    82

	memcpy(p, mem, size);

    83

	return p;

    84

}

    85

    86

static void pool_free(SettingsMemoryPool **pool)

    87

{

    88

	SettingsMemoryPool *p = *pool, *n;

    89

	*pool = NULL;

    90

	while (p) {

    91

		n = p->next;

    92

		free(p);

    93

		p = n;

    94

	}

    95

}

    96

    97

// structs describing the ini format.

    98

struct IniItem {

    99

	char *name;

   100

	char *value;

   101

	char *comment;

   102

	IniItem *next;

   103

};

   104

   105

struct IniGroup {

   106

	char *name; // name of group

   107

	char *comment; //comment for group

   108

	IniItem *item, **last_item;

   109

	IniGroup *next;

   110

	IniFile *ini;

   111

	IniGroupType type; // type of group

   112

};

   113

   114

struct IniFile {

   115

	SettingsMemoryPool *pool;

   116

	IniGroup *group, **last_group;

   117

	char *comment; // last comment in file

   118

};

   119

   120

// allocate an inifile object

   121

static IniFile *ini_alloc(void)

   122

{

   123

	IniFile *ini;

   124

	SettingsMemoryPool *pool;

   125

	pool_init(&pool);

   126

	ini = (IniFile*)pool_alloc(&pool, sizeof(IniFile));

   127

	ini->pool = pool;

   128

	ini->group = NULL;

   129

	ini->last_group = &ini->group;

   130

	ini->comment = NULL;

   131

	return ini;

   132

}

   133

   134

// allocate an ini group object

   135

static IniGroup *ini_group_alloc(IniFile *ini, const char *grpt, int len)

   136

{

   137

	IniGroup *grp = pool_alloc(&ini->pool, sizeof(IniGroup));

   138

	grp->ini = ini;

   139

	grp->name = pool_strdup(&ini->pool, grpt, len);

   140

	if (!strcmp(grp->name, "newgrf") || !strcmp(grp->name, "servers") || !strcmp(grp->name, "bans")) {

   141

		grp->type = IGT_LIST;

   142

	} else {

   143

		grp->type = IGT_VARIABLES;

   144

	}

   145

	grp->next = NULL;

   146

	grp->item = NULL;

   147

	grp->comment = NULL;

   148

	grp->last_item = &grp->item;

   149

	*ini->last_group = grp;

   150

	ini->last_group = &grp->next;

   151

	return grp;

   152

}

   153

   154

static IniItem *ini_item_alloc(IniGroup *group, const char *name, int len)

   155

{

   156

	IniItem *item = pool_alloc(&group->ini->pool, sizeof(IniItem));

   157

	item->name = pool_strdup(&group->ini->pool, name, len);

   158

	item->next = NULL;

   159

	item->comment = NULL;

   160

	item->value = NULL;

   161

	*group->last_item = item;

   162

	group->last_item = &item->next;

   163

	return item;

   164

}

   165

   166

// load an ini file into the "abstract" format

   167

static IniFile *ini_load(const char *filename)

   168

{

   169

	char buffer[1024], c, *s, *t, *e;

   170

	FILE *in;

   171

	IniFile *ini;

   172

	IniGroup *group = NULL;

   173

	IniItem *item;

   174

   175

	char *comment = NULL;

   176

	uint comment_size = 0;

   177

	uint comment_alloc = 0;

   178

   179

	ini = ini_alloc();

   180

   181

	in = fopen(filename, "r");

   182

	if (in == NULL) return ini;

   183

   184

	// for each line in the file

   185

	while (fgets(buffer, sizeof(buffer), in)) {

   186

   187

		// trim whitespace from the left side

   188

		for (s = buffer; s[0] == ' ' || s[0] == '\t'; s++);

   189

   190

		// trim whitespace from right side.

   191

		e = s + strlen(s);

   192

		while (e > s && ((c=e[-1]) == '\n' || c == '\r' || c == ' ' || c == '\t')) e--;

   193

		*e = 0;

   194

   195

		// skip comments and empty lines

   196

		if (*s == '#' || *s == 0) {

   197

			uint ns = comment_size + (e - s + 1);

   198

			uint a = comment_alloc;

   199

			uint pos;

   200

			// add to comment

   201

			if (ns > a) {

   202

				a = max(a, 128);

   203

				do a*=2; while (a < ns);

   204

				comment = realloc(comment, comment_alloc = a);

   205

			}

   206

			pos = comment_size;

   207

			comment_size += (e - s + 1);

   208

			comment[pos + e - s] = '\n'; // comment newline

   209

			memcpy(comment + pos, s, e - s); // copy comment contents

   210

			continue;

   211

		}

   212

   213

		// it's a group?

   214

		if (s[0] == '[') {

   215

			if (e[-1] != ']')

   216

				ShowInfoF("ini: invalid group name '%s'\n", buffer);

   217

			else

   218

				e--;

   219

			s++; // skip [

   220

			group = ini_group_alloc(ini, s, e - s);

   221

			if (comment_size) {

   222

				group->comment = pool_strdup(&ini->pool, comment, comment_size);

   223

				comment_size = 0;

   224

			}

   225

		} else if (group) {

   226

			// find end of keyname

   227

			for (t=s; *t != 0 && *t != '=' && *t != '\t' && *t != ' '; t++) {}

   228

   229

			// it's an item in an existing group

   230

			item = ini_item_alloc(group, s, t-s);

   231

			if (comment_size) {

   232

				item->comment = pool_strdup(&ini->pool, comment, comment_size);

   233

				comment_size = 0;

   234

			}

   235

   236

			// for list items, the name and value are the same:

   237

			if (group->type == IGT_LIST) {

   238

				item->value = item->name;

   239

				continue;

   240

			}

   241

   242

			// find start of parameter

   243

			while (*t == '=' || *t == ' ' || *t == '\t') t++;

   244

   245

   246

			// remove starting quotation marks

   247

			if (*t == '\"') t++;

   248

			// remove ending quotation marks

   249

			e = t + strlen(t);

   250

			if (e > t && e[-1] =='\"') e--;

   251

			*e = 0;

   252

   253

			item->value = pool_strdup(&ini->pool, t, e - t);

   254

		} else {

   255

			// it's an orphan item

   256

			ShowInfoF("ini: '%s' outside of group\n", buffer);

   257

		}

   258

	}

   259

   260

	if (comment_size) {

   261

		ini->comment = pool_strdup(&ini->pool, comment, comment_size);

   262

		comment_size = 0;

   263

	}

   264

   265

	free(comment);

   266

	fclose(in);

   267

   268

	return ini;

   269

}

   270

   271

// lookup a group or make a new one

   272

static IniGroup *ini_getgroup(IniFile *ini, const char *name, int len)

   273

{

   274

	IniGroup *group;

   275

   276

	if (len == -1) len = strlen(name);

   277

   278

	// does it exist already?

   279

	for (group = ini->group; group; group = group->next)

   280

		if (!memcmp(group->name, name, len) && group->name[len] == 0)

   281

			return group;

   282

   283

	// otherwise make a new one

   284

	group = ini_group_alloc(ini, name, len);

   285

	group->comment = pool_strdup(&ini->pool, "\n", 1);

   286

	return group;

   287

}

   288

   289

// lookup an item or make a new one

   290

static IniItem *ini_getitem(IniGroup *group, const char *name, bool create)

   291

{

   292

	IniItem *item;

   293

	uint len = strlen(name);

   294

   295

	for (item = group->item; item; item = item->next)

   296

		if (strcmp(item->name, name) == 0) return item;

   297

   298

	if (!create) return NULL;

   299

   300

	// otherwise make a new one

   301

	return ini_item_alloc(group, name, len);

   302

}

   303

   304

// save ini file from the "abstract" format.

   305

static bool ini_save(const char *filename, IniFile *ini)

   306

{

   307

	FILE *f;

   308

	IniGroup *group;

   309

	IniItem *item;

   310

   311

	f = fopen(filename, "w");

   312

	if (f == NULL) return false;

   313

   314

	for (group = ini->group; group != NULL; group = group->next) {

   315

		if (group->comment) fputs(group->comment, f);

   316

		fprintf(f, "[%s]\n", group->name);

   317

		for (item = group->item; item != NULL; item = item->next) {

   318

			if (item->comment) fputs(item->comment, f);

   319

			if (group->type == IGT_LIST)

   320

				fprintf(f, "%s\n", item->value ? item->value : "");

   321

			else

   322

				fprintf(f, "%s = %s\n", item->name, item->value ? item->value : "");

   323

		}

   324

	}

   325

	if (ini->comment) fputs(ini->comment, f);

   326

   327

	fclose(f);

   328

	return true;

   329

}

   330

   331

static void ini_free(IniFile *ini)

   332

{

   333

	pool_free(&ini->pool);

   334

}

   335

   336

/* Find the index value of a ONEofMANY type in a string seperated by |

   337

 * @param many full domain of values the ONEofMANY setting can have

   338

 * @param one the current value of the setting for which a value needs found

   339

 * @param onelen force calculation of the *one parameter

   340

 * @return the integer index of the full-list, or -1 if not found */

   341

static int lookup_oneofmany(const char *many, const char *one, int onelen)

   342

{

   343

	const char *s;

   344

	int idx;

   345

   346

	if (onelen == -1) onelen = strlen(one);

   347

   348

	// check if it's an integer

   349

	if (*one >= '0' && *one <= '9')

   350

		return strtoul(one, NULL, 0);

   351

   352

	idx = 0;

   353

	for (;;) {

   354

		// find end of item

   355

		s = many;

   356

		while (*s != '|' && *s != 0) s++;

   357

		if (s - many == onelen && !memcmp(one, many, onelen)) return idx;

   358

		if (*s == 0) return -1;

   359

		many = s + 1;

   360

		idx++;

   361

	}

   362

}

   363

   364

/* Find the set-integer value MANYofMANY type in a string

   365

 * @param many full domain of values the MANYofMANY setting can have

   366

 * @param str the current string value of the setting, each individual

   367

 * of seperated by a whitespace\tab or | character

   368

 * @return the 'fully' set integer, or -1 if a set is not found */

   369

static uint32 lookup_manyofmany(const char *many, const char *str)

   370

{

   371

	const char *s;

   372

	int r;

   373

	uint32 res = 0;

   374

   375

	for (;;) {

   376

		// skip "whitespace"

   377

		while (*str == ' ' || *str == '\t' || *str == '|') str++;

   378

		if (*str == 0) break;

   379

   380

		s = str;

   381

		while (*s != 0 && *s != ' ' && *s != '\t' && *s != '|') s++;

   382

   383

		r = lookup_oneofmany(many, str, s - str);

   384

		if (r == -1) return (uint32)-1;

   385

   386

		SETBIT(res, r); // value found, set it

   387

		if (*s == 0) break;

   388

		str = s + 1;

   389

	}

   390

	return res;

   391

}

   392

   393

/** Parse an integerlist string and set each found value

   394

 * @param p the string to be parsed. Each element in the list is seperated by a comma

   395

 * @param items pointer to the integerlist-array that will be filled with values

   396

 * @param maxitems the maximum number of elements the integerlist-array has

   397

 * @return returns the number of items found, or -1 on an error */

   398

static int parse_intlist(const char *p, int *items, int maxitems)

   399

{

   400

	int n = 0, v;

   401

	char *end;

   402

   403

	for (;;) {

   404

		v = strtol(p, &end, 0);

   405

		if (p == end || n == maxitems) return -1;

   406

		p = end;

   407

		items[n++] = v;

   408

		if (*p == 0) break;

   409

		if (*p != ',') return -1;

   410

		p++;

   411

	}

   412

   413

	return n;

   414

}

   415

   416

/* Load parsed string-values into an integer-array (intlist)

   417

 * @param str the string that contains the values (and will be parsed)

   418

 * @param array pointer to the integer-arrays that will be filled

   419

 * @param nelems the number of elements the array holds. Maximum is 64 elements

   420

 * @param type the type of elements the array holds (eg INT8, UINT16, etc.)

   421

 * @return return true on success and false on error */

   422

static bool load_intlist(const char *str, void *array, int nelems, VarType type)

   423

{

   424

	int items[64];

   425

	int i, nitems;

   426

   427

	if (str == NULL) {

   428

		memset(items, 0, sizeof(items));

   429

		nitems = nelems;

   430

	} else {

   431

		nitems = parse_intlist(str, items, lengthof(items));

   432

		if (nitems != nelems) return false;

   433

	}

   434

   435

	switch (type) {

   436

	case SLE_VAR_BL:

   437

	case SLE_VAR_I8:

   438

	case SLE_VAR_U8:

   439

		for (i = 0; i != nitems; i++) ((byte*)array)[i] = items[i];

   440

		break;

   441

	case SLE_VAR_I16:

   442

	case SLE_VAR_U16:

   443

		for (i = 0; i != nitems; i++) ((uint16*)array)[i] = items[i];

   444

		break;

   445

	case SLE_VAR_I32:

   446

	case SLE_VAR_U32:

   447

		for (i = 0; i != nitems; i++) ((uint32*)array)[i] = items[i];

   448

		break;

   449

	default: NOT_REACHED();

   450

	}

   451

   452

	return true;

   453

}

   454

   455

/* Convert an integer-array (intlist) to a string representation. Each value

   456

 * is seperated by a comma

   457

 * @param buf output buffer where the string-representation will be stored

   458

 * @param array pointer to the integer-arrays that is read from

   459

 * @param nelems the number of elements the array holds.

   460

 * @param type the type of elements the array holds (eg INT8, UINT16, etc.) */

   461

static void make_intlist(char *buf, const void *array, int nelems, VarType type)

   462

{

   463

	int i, v = 0;

   464

	const byte *p = (const byte*)array;

   465

   466

	for (i = 0; i != nelems; i++) {

   467

		switch (type) {

   468

		case SLE_VAR_BL:

   469

		case SLE_VAR_I8:  v = *(int8*)p;   p += 1; break;

   470

		case SLE_VAR_U8:  v = *(byte*)p;   p += 1; break;

   471

		case SLE_VAR_I16: v = *(int16*)p;  p += 2; break;

   472

		case SLE_VAR_U16: v = *(uint16*)p; p += 2; break;

   473

		case SLE_VAR_I32: v = *(int32*)p;  p += 4; break;

   474

		case SLE_VAR_U32: v = *(uint32*)p; p += 4; break;

   475

		default: NOT_REACHED();

   476

		}

   477

		buf += sprintf(buf, (i == 0) ? "%d" : ",%d", v);

   478

	}

   479

}

   480

   481

/* Convert a ONEofMANY structure to a string representation.

   482

 * @param buf output buffer where the string-representation will be stored

   483

 * @param many the full-domain string of possible values

   484

 * @param id the value of the variable and whose string-representation must be found */

   485

static void make_oneofmany(char *buf, const char *many, int id)

   486

{

   487

	int orig_id = id;

   488

   489

	// Look for the id'th element

   490

	while (--id >= 0) {

   491

		for (; *many != '|'; many++) {

   492

			if (*many == '\0') { // not found

   493

				sprintf(buf, "%d", orig_id);

   494

				return;

   495

			}

   496

		}

   497

		many++; // pass the |-character

   498

	}

   499

   500

	// copy string until next item (|) or the end of the list if this is the last one

   501

	while (*many != '\0' && *many != '|') *buf++ = *many++;

   502

	*buf = '\0';

   503

}

   504

   505

/* Convert a MANYofMANY structure to a string representation.

   506

 * @param buf output buffer where the string-representation will be stored

   507

 * @param many the full-domain string of possible values

   508

 * @param x the value of the variable and whose string-representation must