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

    18

typedef struct IniFile IniFile;

    19

typedef struct IniItem IniItem;

    20

typedef struct IniGroup IniGroup;

    21

typedef struct SettingsMemoryPool SettingsMemoryPool;

    22

    23

static void pool_init(SettingsMemoryPool **pool);

    24

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

    25

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

    26

static void pool_free(SettingsMemoryPool **pool);

    27

    28

struct SettingsMemoryPool {

    29

	uint pos,size;

    30

	SettingsMemoryPool *next;

    31

	byte mem[1];

    32

};

    33

    34

static SettingsMemoryPool *pool_new(uint minsize)

    35

{

    36

	SettingsMemoryPool *p;

    37

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

    38

    39

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

    40

	p->pos = 0;

    41

	p->size = minsize;

    42

	p->next = NULL;

    43

	return p;

    44

}

    45

    46

static void pool_init(SettingsMemoryPool **pool)

    47

{

    48

	*pool = pool_new(0);

    49

}

    50

    51

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

    52

{

    53

	uint pos;

    54

	SettingsMemoryPool *p = *pool;

    55

    56

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

    57

    58

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

    59

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

    60

		p = p->next;

    61

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

    62

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

    63

		SettingsMemoryPool *n = pool_new(size);

    64

		*pool = n;

    65

		n->next = p;

    66

		p = n;

    67

	}

    68

    69

	pos = p->pos;

    70

	p->pos += size;

    71

	return p->mem + pos;

    72

}

    73

    74

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

    75

{

    76

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

    77

	p[size] = 0;

    78

	memcpy(p, mem, size);

    79

	return p;

    80

}

    81

    82

static void pool_free(SettingsMemoryPool **pool)

    83

{

    84

	SettingsMemoryPool *p = *pool, *n;

    85

	*pool = NULL;

    86

	while (p) {

    87

		n = p->next;

    88

		free(p);

    89

		p = n;

    90

	}

    91

}

    92

    93

// structs describing the ini format.

    94

struct IniItem {

    95

	char *name;

    96

	char *value;

    97

	char *comment;

    98

	IniItem *next;

    99

};

   100

   101

struct IniGroup {

   102

	char *name; // name of group

   103

	char *comment; //comment for group

   104

	IniItem *item, **last_item;

   105

	IniGroup *next;

   106

	IniFile *ini;

   107

	IniGroupType type; // type of group

   108

};

   109

   110

struct IniFile {

   111

	SettingsMemoryPool *pool;

   112

	IniGroup *group, **last_group;

   113

	char *comment; // last comment in file

   114

};

   115

   116

// allocate an inifile object

   117

static IniFile *ini_alloc(void)

   118

{

   119

	IniFile *ini;

   120

	SettingsMemoryPool *pool;

   121

	pool_init(&pool);

   122

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

   123

	ini->pool = pool;

   124

	ini->group = NULL;

   125

	ini->last_group = &ini->group;

   126

	ini->comment = NULL;

   127

	return ini;

   128

}

   129

   130

// allocate an ini group object

   131

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

   132

{

   133

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

   134

	grp->ini = ini;

   135

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

   136

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

   137

		grp->type = IGT_LIST;

   138

	} else {

   139

		grp->type = IGT_VARIABLES;

   140

	}

   141

	grp->next = NULL;

   142

	grp->item = NULL;

   143

	grp->comment = NULL;

   144

	grp->last_item = &grp->item;

   145

	*ini->last_group = grp;

   146

	ini->last_group = &grp->next;

   147

	return grp;

   148

}

   149

   150

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

   151

{

   152

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

   153

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

   154

	item->next = NULL;

   155

	item->comment = NULL;

   156

	item->value = NULL;

   157

	*group->last_item = item;

   158

	group->last_item = &item->next;

   159

	return item;

   160

}

   161

   162

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

   163

static IniFile *ini_load(const char *filename)

   164

{

   165

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

   166

	FILE *in;

   167

	IniFile *ini;

   168

	IniGroup *group = NULL;

   169

	IniItem *item;

   170

   171

	char *comment = NULL;

   172

	uint comment_size = 0;

   173

	uint comment_alloc = 0;

   174

   175

	ini = ini_alloc();

   176

   177

	in = fopen(filename, "r");

   178

	if (in == NULL) return ini;

   179

   180

	// for each line in the file

   181

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

   182

   183

		// trim whitespace from the left side

   184

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

   185

   186

		// trim whitespace from right side.

   187

		e = s + strlen(s);

   188

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

   189

		*e = 0;

   190

   191

		// skip comments and empty lines

   192

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

   193

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

   194

			uint a = comment_alloc;

   195

			uint pos;

   196

			// add to comment

   197

			if (ns > a) {

   198

				a = max(a, 128);

   199

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

   200

				comment = realloc(comment, comment_alloc = a);

   201

			}

   202

			pos = comment_size;

   203

			comment_size += (e - s + 1);

   204

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

   205

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

   206

			continue;

   207

		}

   208

   209

		// it's a group?

   210

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

   211

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

   212

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

   213

			else

   214

				e--;

   215

			s++; // skip [

   216

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

   217

			if (comment_size) {

   218

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

   219

				comment_size = 0;

   220

			}

   221

		} else if (group) {

   222

			// find end of keyname

   223

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

   224

   225

			// it's an item in an existing group

   226

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

   227

			if (comment_size) {

   228

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

   229

				comment_size = 0;

   230

			}

   231

   232

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

   233

			if (group->type == IGT_LIST) {

   234

				item->value = item->name;

   235

				continue;

   236

			}

   237

   238

			// find start of parameter

   239

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

   240

   241

   242

			// remove starting quotation marks

   243

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

   244

			// remove ending quotation marks

   245

			e = t + strlen(t);

   246

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

   247

			*e = 0;

   248

   249

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

   250

		} else {

   251

			// it's an orphan item

   252

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

   253

		}

   254

	}

   255

   256

	if (comment_size) {

   257

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

   258

		comment_size = 0;

   259

	}

   260

   261

	free(comment);

   262

	fclose(in);

   263

   264

	return ini;

   265

}

   266

   267

// lookup a group or make a new one

   268

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

   269

{

   270

	IniGroup *group;

   271

   272

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

   273

   274

	// does it exist already?

   275

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

   276

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

   277

			return group;

   278

   279

	// otherwise make a new one

   280

	group = ini_group_alloc(ini, name, len);

   281

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

   282

	return group;

   283

}

   284

   285

// lookup an item or make a new one

   286

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

   287

{

   288

	IniItem *item;

   289

	uint len = strlen(name);

   290

   291

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

   292

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

   293

   294

	if (!create) return NULL;

   295

   296

	// otherwise make a new one

   297

	return ini_item_alloc(group, name, len);

   298

}

   299

   300

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

   301

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

   302

{

   303

	FILE *f;

   304

	IniGroup *group;

   305

	IniItem *item;

   306

   307

	f = fopen(filename, "w");

   308

	if (f == NULL) return false;

   309

   310

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

   311

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

   312

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

   313

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

   314

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

   315

			if (group->type == IGT_LIST)

   316

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

   317

			else

   318

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

   319

		}

   320

	}

   321

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

   322

   323

	fclose(f);

   324

	return true;

   325

}

   326

   327

static void ini_free(IniFile *ini)

   328

{

   329

	pool_free(&ini->pool);

   330

}

   331

   332

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

   333

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

   334

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

   335

 * @param onelen force calculation of the *one parameter

   336

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

   337

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

   338

{

   339

	const char *s;

   340

	int idx;

   341

   342

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

   343

   344

	// check if it's an integer

   345

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

   346

		return strtoul(one, NULL, 0);

   347

   348

	idx = 0;

   349

	for (;;) {

   350

		// find end of item

   351

		s = many;

   352

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

   353

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

   354

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

   355

		many = s + 1;

   356

		idx++;

   357

	}

   358

}

   359

   360

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

   361

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

   362

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

   363

 * of seperated by a whitespace\tab or | character

   364

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

   365

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

   366

{

   367

	const char *s;

   368

	int r;

   369

	uint32 res = 0;

   370

   371

	for (;;) {

   372

		// skip "whitespace"

   373

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

   374

		if (*str == 0) break;

   375

   376

		s = str;

   377

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

   378

   379

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

   380

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

   381

   382

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

   383

		if (*s == 0) break;

   384

		str = s + 1;

   385

	}

   386

	return res;

   387

}

   388

   389

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

   390

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

   391

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

   392

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

   393

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

   394

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

   395

{

   396

	int n = 0, v;

   397

	char *end;

   398

   399

	for (;;) {

   400

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

   401

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

   402

		p = end;

   403

		items[n++] = v;

   404

		if (*p == 0) break;

   405

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

   406

		p++;

   407

	}

   408

   409

	return n;

   410

}

   411

   412

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

   413

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

   414

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

   415

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

   416

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

   417

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

   418

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

   419

{

   420

	int items[64];

   421

	int i, nitems;

   422

   423

	if (str == NULL) {

   424

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

   425

		nitems = nelems;

   426

	} else {

   427

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

   428

		if (nitems != nelems) return false;

   429

	}

   430

   431

	switch (type) {

   432

	case SLE_VAR_BL:

   433

	case SLE_VAR_I8:

   434

	case SLE_VAR_U8:

   435

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

   436

		break;

   437

	case SLE_VAR_I16:

   438

	case SLE_VAR_U16:

   439

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

   440

		break;

   441

	case SLE_VAR_I32:

   442

	case SLE_VAR_U32:

   443

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

   444

		break;

   445

	default: NOT_REACHED();

   446

	}

   447

   448

	return true;

   449

}

   450

   451

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

   452

 * is seperated by a comma

   453

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

   454

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

   455

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

   456

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

   457

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

   458

{

   459

	int i, v = 0;

   460

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

   461

   462

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

   463

		switch (type) {

   464

		case SLE_VAR_BL:

   465

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

   466

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

   467

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

   468

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

   469

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

   470

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

   471

		default: NOT_REACHED();

   472

		}

   473

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

   474

	}

   475

}

   476

   477

/* Convert a ONEofMANY structure to a string representation.

   478

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

   479

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

   480

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

   481

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

   482

{

   483

	int orig_id = id;

   484

   485

	// Look for the id'th element

   486

	while (--id >= 0) {

   487

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

   488

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

   489

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

   490

				return;

   491

			}

   492

		}

   493

		many++; // pass the |-character

   494

	}

   495

   496

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

   497

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

   498

	*buf = '\0';

   499

}

   500

   501

/* Convert a MANYofMANY structure to a string representation.

   502

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

   503

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

   504

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

   505

 *        be found in the bitmasked many string */

   506

static void make_manyofmany(char *buf, const char *many, uint32 x)

   507

{

   508

	const char *start;

   509

	int i = 0;