1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "sound.h"

     4

#include "string.h"

     5

#include "table/currency.h"

     6

#include "network.h"

     7

#include "settings.h"

     8

     9

typedef struct IniFile IniFile;

    10

typedef struct IniItem IniItem;

    11

typedef struct IniGroup IniGroup;

    12

typedef struct SettingsMemoryPool SettingsMemoryPool;

    13

    14

static void pool_init(SettingsMemoryPool **pool);

    15

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

    16

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

    17

static void pool_free(SettingsMemoryPool **pool);

    18

    19

struct SettingsMemoryPool {

    20

	uint pos,size;

    21

	SettingsMemoryPool *next;

    22

	byte mem[1];

    23

};

    24

    25

static SettingsMemoryPool *pool_new(uint minsize)

    26

{

    27

	SettingsMemoryPool *p;

    28

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

    29

    30

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

    31

	p->pos = 0;

    32

	p->size = minsize;

    33

	p->next = NULL;

    34

	return p;

    35

}

    36

    37

static void pool_init(SettingsMemoryPool **pool)

    38

{

    39

	*pool = pool_new(0);

    40

}

    41

    42

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

    43

{

    44

	uint pos;

    45

	SettingsMemoryPool *p = *pool;

    46

    47

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

    48

    49

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

    50

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

    51

		p = p->next;

    52

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

    53

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

    54

		SettingsMemoryPool *n = pool_new(size);

    55

		*pool = n;

    56

		n->next = p;

    57

		p = n;

    58

	}

    59

    60

	pos = p->pos;

    61

	p->pos += size;

    62

	return p->mem + pos;

    63

}

    64

    65

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

    66

{

    67

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

    68

	p[size] = 0;

    69

	memcpy(p, mem, size);

    70

	return p;

    71

}

    72

    73

static void pool_free(SettingsMemoryPool **pool)

    74

{

    75

	SettingsMemoryPool *p = *pool, *n;

    76

	*pool = NULL;

    77

	while (p) {

    78

		n = p->next;

    79

		free(p);

    80

		p = n;

    81

	}

    82

}

    83

    84

// structs describing the ini format.

    85

struct IniItem {

    86

	char *name;

    87

	char *value;

    88

	char *comment;

    89

	IniItem *next;

    90

};

    91

    92

struct IniGroup {

    93

	char *name; // name of group

    94

	char *comment; //comment for group

    95

	IniItem *item, **last_item;

    96

	IniGroup *next;

    97

	IniFile *ini;

    98

	IniGroupType type; // type of group

    99

};

   100

   101

struct IniFile {

   102

	SettingsMemoryPool *pool;

   103

	IniGroup *group, **last_group;

   104

	char *comment; // last comment in file

   105

};

   106

   107

// allocate an inifile object

   108

static IniFile *ini_alloc(void)

   109

{

   110

	IniFile *ini;

   111

	SettingsMemoryPool *pool;

   112

	pool_init(&pool);

   113

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

   114

	ini->pool = pool;

   115

	ini->group = NULL;

   116

	ini->last_group = &ini->group;

   117

	ini->comment = NULL;

   118

	return ini;

   119

}

   120

   121

// allocate an ini group object

   122

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

   123

{

   124

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

   125

	grp->ini = ini;

   126

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

   127

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

   128

		grp->type = IGT_LIST;

   129

	else

   130

		grp->type = IGT_VARIABLES;

   131

	grp->next = NULL;

   132

	grp->item = NULL;

   133

	grp->comment = NULL;

   134

	grp->last_item = &grp->item;

   135

	*ini->last_group = grp;

   136

	ini->last_group = &grp->next;

   137

	return grp;

   138

}

   139

   140

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

   141

{

   142

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

   143

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

   144

	item->next = NULL;

   145

	item->comment = NULL;

   146

	item->value = NULL;

   147

	*group->last_item = item;

   148

	group->last_item = &item->next;

   149

	return item;

   150

}

   151

   152

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

   153

static IniFile *ini_load(const char *filename)

   154

{

   155

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

   156

	FILE *in;

   157

	IniFile *ini;

   158

	IniGroup *group = NULL;

   159

	IniItem *item;

   160

   161

	char *comment = NULL;

   162

	uint comment_size = 0;

   163

	uint comment_alloc = 0;

   164

   165

	ini = ini_alloc();

   166

   167

	in = fopen(filename, "r");

   168

	if (in == NULL) return ini;

   169

   170

	// for each line in the file

   171

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

   172

   173

		// trim whitespace from the left side

   174

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

   175

   176

		// trim whitespace from right side.

   177

		e = s + strlen(s);

   178

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

   179

		*e = 0;

   180

   181

		// skip comments and empty lines

   182

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

   183

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

   184

			uint a = comment_alloc;

   185

			uint pos;

   186

			// add to comment

   187

			if (ns > a) {

   188

				a = max(a, 128);

   189

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

   190

				comment = realloc(comment, comment_alloc = a);

   191

			}

   192

			pos = comment_size;

   193

			comment_size += (e - s + 1);

   194

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

   195

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

   196

			continue;

   197

		}

   198

   199

		// it's a group?

   200

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

   201

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

   202

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

   203

			else

   204

				e--;

   205

			s++; // skip [

   206

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

   207

			if (comment_size) {

   208

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

   209

				comment_size = 0;

   210

			}

   211

		} else if (group) {

   212

			// find end of keyname

   213

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

   214

   215

			// it's an item in an existing group

   216

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

   217

			if (comment_size) {

   218

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

   219

				comment_size = 0;

   220

			}

   221

   222

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

   223

			if( group->type == IGT_LIST ) {

   224

				item->value = item->name;

   225

				continue;

   226

			}

   227

   228

			// find start of parameter

   229

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

   230

   231

   232

			// remove starting quotation marks

   233

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

   234

			// remove ending quotation marks

   235

			e = t + strlen(t);

   236

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

   237

			*e = 0;

   238

   239

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

   240

		} else {

   241

			// it's an orphan item

   242

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

   243

		}

   244

	}

   245

   246

	if (comment_size) {

   247

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

   248

		comment_size = 0;

   249

	}

   250

   251

	free(comment);

   252

	fclose(in);

   253

   254

	return ini;

   255

}

   256

   257

// lookup a group or make a new one

   258

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

   259

{

   260

	IniGroup *group;

   261

   262

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

   263

   264

	// does it exist already?

   265

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

   266

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

   267

			return group;

   268

   269

	// otherwise make a new one

   270

	group = ini_group_alloc(ini, name, len);

   271

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

   272

	return group;

   273

}

   274

   275

// lookup an item or make a new one

   276

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

   277

{

   278

	IniItem *item;

   279

	uint len = strlen(name);

   280

   281

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

   282

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

   283

			return item;

   284

   285

	if (!create) return NULL;

   286

   287

	// otherwise make a new one

   288

	item = ini_item_alloc(group, name, len);

   289

	return item;

   290

}

   291

   292

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

   293

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

   294

{

   295

	FILE *f;

   296

	IniGroup *group;

   297

	IniItem *item;

   298

   299

	f = fopen(filename, "w");

   300

	if (f == NULL) return false;

   301

   302

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

   303

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

   304

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

   305

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

   306

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

   307

			if(group->type==IGT_LIST)

   308

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

   309

			else

   310

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

   311

		}

   312

	}

   313

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

   314

   315

	fclose(f);

   316

	return true;

   317

}

   318

   319

static void ini_free(IniFile *ini)

   320

{

   321

	pool_free(&ini->pool);

   322

}

   323

   324

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

   325

{

   326

	const char *s;

   327

	int idx;

   328

   329

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

   330

   331

	// check if it's an integer

   332

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

   333

		return strtoul(one, NULL, 0);

   334

   335

	idx = 0;

   336

	for(;;) {

   337

		// find end of item

   338

		s = many;

   339

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

   340

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

   341

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

   342

		many = s + 1;

   343

		idx++;

   344

	}

   345

}

   346

   347

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

   348

{

   349

	const char *s;

   350

	int r;

   351

	uint32 res = 0;

   352

   353

	for(;;) {

   354

		// skip "whitespace"

   355

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

   356

		if (*str == 0) break;

   357

   358

		s = str;

   359

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

   360

   361

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

   362

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

   363

   364

		res |= (1 << r);

   365

		if (*s == 0) break;

   366

		str = s + 1;

   367

	}

   368

	return res;

   369

}

   370

   371

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

   372

{

   373

	int n = 0, v;

   374

	char *end;

   375

   376

	for(;;) {

   377

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

   378

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

   379

		p = end;

   380

		items[n++] = v;

   381

		if (*p == 0) break;

   382

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

   383

		p++;

   384

	}

   385

   386

	return n;

   387

}

   388

   389

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

   390

{

   391

	int items[64];

   392

	int i,nitems;

   393

   394

	if (str == NULL) {

   395

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

   396

		nitems = nelems;

   397

	} else {

   398

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

   399

		if (nitems != nelems)

   400

			return false;

   401

	}

   402

   403

	switch(type) {

   404

	case SDT_INT8 >> 4:

   405

	case SDT_UINT8 >> 4:

   406

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

   407

		break;

   408

	case SDT_INT16 >> 4:

   409

	case SDT_UINT16 >> 4:

   410

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

   411

		break;

   412

	case SDT_INT32 >> 4:

   413

	case SDT_UINT32 >> 4:

   414

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

   415

		break;

   416

	default:

   417

		NOT_REACHED();

   418

	}

   419

   420

	return true;

   421

}

   422

   423

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

   424

{

   425

	int i, v = 0;

   426

	byte *p = (byte*)array;

   427

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

   428

		switch(type) {

   429

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

   430

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

   431

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

   432

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

   433

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

   434

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

   435

		default: NOT_REACHED();

   436

		}

   437

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

   438

	}

   439

}

   440

   441

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

   442

{

   443

	int orig_i = i;

   444

	char c;

   445

   446

	while (--i >= 0) {

   447

		do {

   448

			many++;

   449

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

   450

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

   451

				return;

   452

			}

   453

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

   454

	}

   455

   456

	// copy until | or 0

   457

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

   458

		*buf++ = c;

   459

	*buf = 0;

   460

}

   461

   462

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

   463

{

   464

	const char *start;

   465

	int i = 0;

   466

	bool init = true;

   467

   468

	do {

   469

		start = many;

   470

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

   471

		if (x & 1) {

   472

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

   473

			init = false;

   474

			if (start == many) {

   475

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

   476

			} else {

   477

				memcpy(buf, start, many - start);

   478

				buf += many - start;

   479

			}

   480

		}

   481

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

   482

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

   483

	*buf = 0;

   484

}

   485

   486

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

   487

{

   488

	uint32 val;

   489

	char *end;

   490

   491

	switch(desc->flags & 0xF) {

   492

	case SDT_INTX:

   493

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

   494

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

   495

		return (void*)val;

   496

	case SDT_ONEOFMANY: {

   497

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

   498

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

   499

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

   500

		return 0;

   501

	}

   502

	case SDT_MANYOFMANY: {

   503

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

   504

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

   505

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

   506

		return 0;

   507

	}

   508

	case SDT_BOOLX:

   509

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

   510

			return (void*)true;

   511

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

   512

			return (void*)false;

   513

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

   514

		break;

   515

   516

	case SDT_STRING:

   517

	case SDT_STRINGBUF:

   518

	case SDT_STRINGQUOT:

   519

	case SDT_INTLIST:

   520

		return str;