1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "screenshot.h"

     4

#include "sound.h"

     5

#include "spritecache.h"

     6

#include "string.h"

     7

#include "variables.h"

     8

#include "table/currency.h"

     9

#include "network.h"

    10

#include "settings.h"

    11

    12

typedef struct IniFile IniFile;

    13

typedef struct IniItem IniItem;

    14

typedef struct IniGroup IniGroup;

    15

typedef struct SettingsMemoryPool SettingsMemoryPool;

    16

    17

static void pool_init(SettingsMemoryPool **pool);

    18

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

    19

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

    20

static void pool_free(SettingsMemoryPool **pool);

    21

    22

struct SettingsMemoryPool {

    23

	uint pos,size;

    24

	SettingsMemoryPool *next;

    25

	byte mem[1];

    26

};

    27

    28

static SettingsMemoryPool *pool_new(uint minsize)

    29

{

    30

	SettingsMemoryPool *p;

    31

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

    32

    33

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

    34

	p->pos = 0;

    35

	p->size = minsize;

    36

	p->next = NULL;

    37

	return p;

    38

}

    39

    40

static void pool_init(SettingsMemoryPool **pool)

    41

{

    42

	*pool = pool_new(0);

    43

}

    44

    45

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

    46

{

    47

	uint pos;

    48

	SettingsMemoryPool *p = *pool;

    49

    50

	size = (size + 3) & ~3; // align everything to a 32 bit boundary

    51

    52

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

    53

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

    54

		p = p->next;

    55

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

    56

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

    57

		SettingsMemoryPool *n = pool_new(size);

    58

		*pool = n;

    59

		n->next = p;

    60

		p = n;

    61

	}

    62

    63

	pos = p->pos;

    64

	p->pos += size;

    65

	return p->mem + pos;

    66

}

    67

    68

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

    69

{

    70

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

    71

	p[size] = 0;

    72

	memcpy(p, mem, size);

    73

	return p;

    74

}

    75

    76

static void pool_free(SettingsMemoryPool **pool)

    77

{

    78

	SettingsMemoryPool *p = *pool, *n;

    79

	*pool = NULL;

    80

	while (p) {

    81

		n = p->next;

    82

		free(p);

    83

		p = n;

    84

	}

    85

}

    86

    87

// structs describing the ini format.

    88

struct IniItem {

    89

	char *name;

    90

	char *value;

    91

	char *comment;

    92

	IniItem *next;

    93

};

    94

    95

struct IniGroup {

    96

	char *name; // name of group

    97

	char *comment; //comment for group

    98

	IniItem *item, **last_item;

    99

	IniGroup *next;

   100

	IniFile *ini;

   101

	IniGroupType type; // type of group

   102

};

   103

   104

struct IniFile {

   105

	SettingsMemoryPool *pool;

   106

	IniGroup *group, **last_group;

   107

	char *comment; // last comment in file

   108

};

   109

   110

// allocate an inifile object

   111

static IniFile *ini_alloc(void)

   112

{

   113

	IniFile *ini;

   114

	SettingsMemoryPool *pool;

   115

	pool_init(&pool);

   116

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

   117

	ini->pool = pool;

   118

	ini->group = NULL;

   119

	ini->last_group = &ini->group;

   120

	ini->comment = NULL;

   121

	return ini;

   122

}

   123

   124

// allocate an ini group object

   125

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

   126

{

   127

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

   128

	grp->ini = ini;

   129

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

   130

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

   131

		grp->type = IGT_LIST;

   132

	else

   133

		grp->type = IGT_VARIABLES;

   134

	grp->next = NULL;

   135

	grp->item = NULL;

   136

	grp->comment = NULL;

   137

	grp->last_item = &grp->item;

   138

	*ini->last_group = grp;

   139

	ini->last_group = &grp->next;

   140

	return grp;

   141

}

   142

   143

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

   144

{

   145

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

   146

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

   147

	item->next = NULL;

   148

	item->comment = NULL;

   149

	item->value = NULL;

   150

	*group->last_item = item;

   151

	group->last_item = &item->next;

   152

	return item;

   153

}

   154

   155

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

   156

static IniFile *ini_load(const char *filename)

   157

{

   158

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

   159

	FILE *in;

   160

	IniFile *ini;

   161

	IniGroup *group = NULL;

   162

	IniItem *item;

   163

   164

	char *comment = NULL;

   165

	uint comment_size = 0;

   166

	uint comment_alloc = 0;

   167

   168

	ini = ini_alloc();

   169

   170

	in = fopen(filename, "r");

   171

	if (in == NULL) return ini;

   172

   173

	// for each line in the file

   174

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

   175

   176

		// trim whitespace from the left side

   177

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

   178

   179

		// trim whitespace from right side.

   180

		e = s + strlen(s);

   181

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

   182

		*e = 0;

   183

   184

		// skip comments and empty lines

   185

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

   186

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

   187

			uint a = comment_alloc;

   188

			uint pos;

   189

			// add to comment

   190

			if (ns > a) {

   191

				a = max(a, 128);

   192

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

   193

				comment = realloc(comment, comment_alloc = a);

   194

			}

   195

			pos = comment_size;

   196

			comment_size += (e - s + 1);

   197

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

   198

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

   199

			continue;

   200

		}

   201

   202

		// it's a group?

   203

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

   204

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

   205

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

   206

			else

   207

				e--;

   208

			s++; // skip [

   209

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

   210

			if (comment_size) {

   211

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

   212

				comment_size = 0;

   213

			}

   214

		} else if (group) {

   215

			// find end of keyname

   216

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

   217

   218

			// it's an item in an existing group

   219

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

   220

			if (comment_size) {

   221

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

   222

				comment_size = 0;

   223

			}

   224

   225

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

   226

			if( group->type == IGT_LIST ) {

   227

				item->value = item->name;

   228

				continue;

   229

			}

   230

   231

			// find start of parameter

   232

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

   233

   234

   235

			// remove starting quotation marks

   236

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

   237

			// remove ending quotation marks

   238

			e = t + strlen(t);

   239

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

   240

			*e = 0;

   241

   242

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

   243

		} else {

   244

			// it's an orphan item

   245

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

   246

		}

   247

	}

   248

   249

	if (comment_size) {

   250

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

   251

		comment_size = 0;

   252

	}

   253

   254

	free(comment);

   255

	fclose(in);

   256

   257

	return ini;

   258

}

   259

   260

// lookup a group or make a new one

   261

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

   262

{

   263

	IniGroup *group;

   264

   265

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

   266

   267

	// does it exist already?

   268

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

   269

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

   270

			return group;

   271

   272

	// otherwise make a new one

   273

	group = ini_group_alloc(ini, name, len);

   274

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

   275

	return group;

   276

}

   277

   278

// lookup an item or make a new one

   279

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

   280

{

   281

	IniItem *item;

   282

	uint len = strlen(name);

   283

   284

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

   285

		if (!strcmp(item->name, name))

   286

			return item;

   287

   288

	if (!create) return NULL;

   289

   290

	// otherwise make a new one

   291

	item = ini_item_alloc(group, name, len);

   292

	return item;

   293

}

   294

   295

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

   296

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

   297

{

   298

	FILE *f;

   299

	IniGroup *group;

   300

	IniItem *item;

   301

   302

	f = fopen(filename, "w");

   303

	if (f == NULL) return false;

   304

   305

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

   306

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

   307

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

   308

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

   309

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

   310

			if(group->type==IGT_LIST)

   311

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

   312

			else

   313

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

   314

		}

   315

	}

   316

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

   317

   318

	fclose(f);

   319

	return true;

   320

}

   321

   322

static void ini_free(IniFile *ini)

   323

{

   324

	pool_free(&ini->pool);

   325

}

   326

   327

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

   328

{

   329

	const char *s;

   330

	int idx;

   331

   332

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

   333

   334

	// check if it's an integer

   335

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

   336

		return strtoul(one, NULL, 0);

   337

   338

	idx = 0;

   339

	for(;;) {

   340

		// find end of item

   341

		s = many;

   342

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

   343

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

   344

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

   345

		many = s + 1;

   346

		idx++;

   347

	}

   348

}

   349

   350

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

   351

{

   352

	const char *s;

   353

	int r;

   354

	uint32 res = 0;

   355

   356

	for(;;) {

   357

		// skip "whitespace"

   358

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

   359

		if (*str == 0) break;

   360

   361

		s = str;

   362

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

   363

   364

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

   365

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

   366

   367

		res |= (1 << r);

   368

		if (*s == 0) break;

   369

		str = s + 1;

   370

	}

   371

	return res;

   372

}

   373

   374

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

   375

{

   376

	int n = 0, v;

   377

	char *end;

   378

   379

	for(;;) {

   380

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

   381

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

   382

		p = end;

   383

		items[n++] = v;

   384

		if (*p == 0) break;

   385

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

   386

		p++;

   387

	}

   388

   389

	return n;

   390

}

   391

   392

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

   393

{

   394

	int items[64];

   395

	int i,nitems;

   396

   397

	if (str == NULL) {

   398

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

   399

		nitems = nelems;

   400

	} else {

   401

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

   402

		if (nitems != nelems)

   403

			return false;

   404

	}

   405

   406

	switch(type) {

   407

	case SDT_INT8 >> 4:

   408

	case SDT_UINT8 >> 4:

   409

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

   410

		break;

   411

	case SDT_INT16 >> 4:

   412

	case SDT_UINT16 >> 4:

   413

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

   414

		break;

   415

	case SDT_INT32 >> 4:

   416

	case SDT_UINT32 >> 4:

   417

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

   418

		break;

   419

	default:

   420

		NOT_REACHED();

   421

	}

   422

   423

	return true;

   424

}

   425

   426

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

   427

{

   428

	int i, v = 0;

   429

	byte *p = (byte*)array;

   430

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

   431

		switch(type) {

   432

		case SDT_INT8 >> 4: v = *(int8*)p; p += 1; break;

   433

		case SDT_UINT8 >> 4:v = *(byte*)p; p += 1; break;

   434

		case SDT_INT16 >> 4:v = *(int16*)p; p += 2; break;

   435

		case SDT_UINT16 >> 4:v = *(uint16*)p; p += 2; break;

   436

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

   437

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

   438

		default: NOT_REACHED();

   439

		}

   440

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

   441

	}

   442

}

   443

   444

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

   445

{

   446

	int orig_i = i;

   447

	char c;

   448

   449

	while (--i >= 0) {

   450

		do {

   451

			many++;

   452

			if (many[-1] == 0) {

   453

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

   454

				return;

   455

			}

   456

		} while (many[-1] != '|');

   457

	}

   458

   459

	// copy until | or 0

   460

	while ((c=*many++) != 0 && c != '|')

   461

		*buf++ = c;

   462

	*buf = 0;

   463

}

   464

   465

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

   466

{

   467

	const char *start;

   468

	int i = 0;

   469

	bool init = true;

   470

   471

	do {

   472

		start = many;

   473

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

   474

		if (x & 1) {

   475

			if (!init) *buf++ = '|';

   476

			init = false;

   477

			if (start == many) {

   478

				buf += sprintf(buf, "%d", i);

   479

			} else {

   480

				memcpy(buf, start, many - start);

   481

				buf += many - start;

   482

			}

   483

		}

   484

		if (*many == '|') many++;

   485

	} while (++i, x>>=1);

   486

	*buf = 0;

   487

}

   488

   489

static const void *string_to_val(const SettingDesc *desc, const char *str)

   490

{

   491

	uint32 val;

   492

	char *end;

   493

   494

	switch(desc->flags & 0xF) {

   495

	case SDT_INTX:

   496

		val = strtoul(str, &end, 0);

   497

		if (*end != 0) ShowInfoF("ini: trailing characters at end of setting '%s'", desc->name);

   498

		return (void*)val;

   499

	case SDT_ONEOFMANY: {

   500

		int r = lookup_oneofmany((const char*)desc->b, str, -1);

   501

		if (r != -1) return (void*)r;

   502

		ShowInfoF("ini: invalid value '%s' for '%s'", str, desc->name);

   503

		return 0;

   504

	}

   505

	case SDT_MANYOFMANY: {

   506

		uint32 r = lookup_manyofmany(desc->b, str);

   507

		if (r != (uint32)-1) return (void*)r;

   508

		ShowInfoF("ini: invalid value '%s' for '%s'", str, desc->name);

   509

		return 0;

   510

	}

   511

	case SDT_BOOLX:

   512

		if (!strcmp(str, "true") || !strcmp(str, "on") || !strcmp(str, "1"))

   513

			return (void*)true;

   514

		if (!strcmp(str, "false") || !strcmp(str, "off") || !strcmp(str, "0"))

   515

			return (void*)false;

   516

		ShowInfoF("ini: invalid setting value '%s' for '%s'", str, desc->name);

   517

		break;

   518

   519

	case SDT_STRING:

   520