1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "sound.h"

     4

#include "table/currency.h"

     5

#include "network.h"

     6

#include "settings.h"

     7

     8

typedef struct IniFile IniFile;

     9

typedef struct IniItem IniItem;

    10

typedef struct IniGroup IniGroup;

    11

typedef struct SettingsMemoryPool SettingsMemoryPool;

    12

    13

static void pool_init(SettingsMemoryPool **pool);

    14

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

    15

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

    16

static void pool_free(SettingsMemoryPool **pool);

    17

    18

struct SettingsMemoryPool {

    19

	uint pos,size;

    20

	SettingsMemoryPool *next;

    21

	byte mem[1];

    22

};

    23

    24

static SettingsMemoryPool *pool_new(uint minsize)

    25

{

    26

	SettingsMemoryPool *p;

    27

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

    28

    29

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

    30

	p->pos = 0;

    31

	p->size = minsize;

    32

	p->next = NULL;

    33

	return p;

    34

}

    35

    36

static void pool_init(SettingsMemoryPool **pool)

    37

{

    38

	*pool = pool_new(0);

    39

}

    40

    41

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

    42

{

    43

	uint pos;

    44

	SettingsMemoryPool *p = *pool;

    45

    46

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

    47

    48

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

    49

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

    50

		p = p->next;

    51

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

    52

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

    53

		SettingsMemoryPool *n = pool_new(size);

    54

		*pool = n;

    55

		n->next = p;

    56

		p = n;

    57

	}

    58

    59

	pos = p->pos;

    60

	p->pos += size;

    61

	return p->mem + pos;

    62

}

    63

    64

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

    65

{

    66

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

    67

	p[size] = 0;

    68

	memcpy(p, mem, size);

    69

	return p;

    70

}

    71

    72

static void pool_free(SettingsMemoryPool **pool)

    73

{

    74

	SettingsMemoryPool *p = *pool, *n;

    75

	*pool = NULL;

    76

	while (p) {

    77

		n = p->next;

    78

		free(p);

    79

		p = n;

    80

	}

    81

}

    82

    83

// structs describing the ini format.

    84

struct IniItem {

    85

	char *name;

    86

	char *value;

    87

	char *comment;

    88

	IniItem *next;

    89

};

    90

    91

struct IniGroup {

    92

	char *name; // name of group

    93

	char *comment; //comment for group

    94

	IniItem *item, **last_item;

    95

	IniGroup *next;

    96

	IniFile *ini;

    97

	IniGroupType type; // type of group

    98

};

    99

   100

struct IniFile {

   101

	SettingsMemoryPool *pool;

   102

	IniGroup *group, **last_group;

   103

	char *comment; // last comment in file

   104

};

   105

   106

// allocate an inifile object

   107

static IniFile *ini_alloc(void)

   108

{

   109

	IniFile *ini;

   110

	SettingsMemoryPool *pool;

   111

	pool_init(&pool);

   112

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

   113

	ini->pool = pool;

   114

	ini->group = NULL;

   115

	ini->last_group = &ini->group;

   116

	ini->comment = NULL;

   117

	return ini;

   118

}

   119

   120

// allocate an ini group object

   121

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

   122

{

   123

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

   124

	grp->ini = ini;

   125

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

   126

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

   127

		grp->type = IGT_LIST;

   128

	else

   129

		grp->type = IGT_VARIABLES;

   130

	grp->next = NULL;

   131

	grp->item = NULL;

   132

	grp->comment = NULL;

   133

	grp->last_item = &grp->item;

   134

	*ini->last_group = grp;

   135

	ini->last_group = &grp->next;

   136

	return grp;

   137

}

   138

   139

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

   140

{

   141

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

   142

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

   143

	item->next = NULL;

   144

	item->comment = NULL;

   145

	item->value = NULL;

   146

	*group->last_item = item;

   147

	group->last_item = &item->next;

   148

	return item;

   149

}

   150

   151

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

   152

static IniFile *ini_load(const char *filename)

   153

{

   154

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

   155

	FILE *in;

   156

	IniFile *ini;

   157

	IniGroup *group = NULL;

   158

	IniItem *item;

   159

   160

	byte *comment = NULL;

   161

	uint comment_size = 0;

   162

	uint comment_alloc = 0;

   163

   164

	ini = ini_alloc();

   165

   166

	in = fopen(filename, "r");

   167

	if (in == NULL) return ini;

   168

   169

	// for each line in the file

   170

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

   171

   172

		// trim whitespace from the left side

   173

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

   174

   175

		// trim whitespace from right side.

   176

		e = s + strlen(s);

   177

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

   178

		*e = 0;

   179

   180

		// skip comments and empty lines

   181

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

   182

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

   183

			uint a = comment_alloc;

   184

			uint pos;

   185

			// add to comment

   186

			if (ns > a) {

   187

				a = max(a, 128);

   188

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

   189

				comment = realloc(comment, comment_alloc = a);

   190

			}

   191

			pos = comment_size;

   192

			comment_size += (e - s + 1);

   193

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

   194

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

   195

			continue;

   196

		}

   197

   198

		// it's a group?

   199

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

   200

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

   201

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

   202

			else

   203

				e--;

   204

			s++; // skip [

   205

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

   206

			if (comment_size) {

   207

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

   208

				comment_size = 0;

   209

			}

   210

		} else if (group) {

   211

			// find end of keyname

   212

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

   213

   214

			// it's an item in an existing group

   215

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

   216

			if (comment_size) {

   217

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

   218

				comment_size = 0;

   219

			}

   220

   221

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

   222

			if( group->type == IGT_LIST ) {

   223

				item->value = item->name;

   224

				continue;

   225

			}

   226

   227

			// find start of parameter

   228

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

   229

   230

   231

			// remove starting quotation marks

   232

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

   233

			// remove ending quotation marks

   234

			e = t + strlen(t);

   235

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

   236

			*e = 0;

   237

   238

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

   239

		} else {

   240

			// it's an orphan item

   241

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

   242

		}

   243

	}

   244

   245

	if (comment_size) {

   246

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

   247

		comment_size = 0;

   248

	}

   249

   250

	free(comment);

   251

	fclose(in);

   252

   253

	return ini;

   254

}

   255

   256

// lookup a group or make a new one

   257

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

   258

{

   259

	IniGroup *group;

   260

   261

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

   262

   263

	// does it exist already?

   264

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

   265

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

   266

			return group;

   267

   268

	// otherwise make a new one

   269

	group = ini_group_alloc(ini, name, len);

   270

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

   271

	return group;

   272

}

   273

   274

// lookup an item or make a new one

   275

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

   276

{

   277

	IniItem *item;

   278

	uint len = strlen(name);

   279

   280

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

   281

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

   282

			return item;

   283

   284

	if (!create) return NULL;

   285

   286

	// otherwise make a new one

   287

	item = ini_item_alloc(group, name, len);

   288

	return item;

   289

}

   290

   291

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

   292

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

   293

{

   294

	FILE *f;

   295

	IniGroup *group;

   296

	IniItem *item;

   297

   298

	f = fopen(filename, "w");

   299

	if (f == NULL) return false;

   300

   301

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

   302

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

   303

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

   304

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

   305

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

   306

			if(group->type==IGT_LIST)

   307

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

   308

			else

   309

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

   310

		}

   311

	}

   312

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

   313

   314

	fclose(f);

   315

	return true;

   316

}

   317

   318

static void ini_free(IniFile *ini)

   319

{

   320

	pool_free(&ini->pool);

   321

}

   322

   323

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

   324

{

   325

	const char *s;

   326

	int idx;

   327

   328

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

   329

   330

	// check if it's an integer

   331

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

   332

		return strtoul(one, NULL, 0);

   333

   334

	idx = 0;

   335

	for(;;) {

   336

		// find end of item

   337

		s = many;

   338

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

   339

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

   340

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

   341

		many = s + 1;

   342

		idx++;

   343

	}

   344

}

   345

   346

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

   347

{

   348

	const char *s;

   349

	int r;

   350

	uint32 res = 0;

   351

   352

	for(;;) {

   353

		// skip "whitespace"

   354

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

   355

		if (*str == 0) break;

   356

   357

		s = str;

   358

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

   359

   360

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

   361

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

   362

   363

		res |= (1 << r);

   364

		if (*s == 0) break;

   365

		str = s + 1;

   366

	}

   367

	return res;

   368

}

   369

   370

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

   371

{

   372

	int n = 0, v;

   373

	char *end;

   374

   375

	for(;;) {

   376

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

   377

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

   378

		p = end;

   379

		items[n++] = v;

   380

		if (*p == 0) break;

   381

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

   382

		p++;

   383

	}

   384

   385

	return n;

   386

}

   387

   388

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

   389

{

   390

	int items[64];

   391

	int i,nitems;

   392

   393

	if (str == NULL) {

   394

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

   395

		nitems = nelems;

   396

	} else {

   397

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

   398

		if (nitems != nelems)

   399

			return false;

   400

	}

   401

   402

	switch(type) {

   403

	case SDT_INT8 >> 4:

   404

	case SDT_UINT8 >> 4:

   405

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

   406

		break;

   407

	case SDT_INT16 >> 4:

   408

	case SDT_UINT16 >> 4:

   409

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

   410

		break;

   411

	case SDT_INT32 >> 4:

   412

	case SDT_UINT32 >> 4:

   413

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

   414

		break;

   415

	default:

   416

		NOT_REACHED();

   417

	}

   418

   419

	return true;

   420

}

   421

   422

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

   423

{

   424

	int i, v = 0;

   425

	byte *p = (byte*)array;

   426

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

   427

		switch(type) {

   428

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

   429

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

   430

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

   431

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

   432

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

   433

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

   434

		default: NOT_REACHED();

   435

		}

   436

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

   437

	}

   438

}

   439

   440

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

   441

{

   442

	int orig_i = i;

   443

	char c;

   444

   445

	while (--i >= 0) {

   446

		do {

   447

			many++;

   448

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

   449

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

   450

				return;

   451

			}

   452

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

   453

	}

   454

   455

	// copy until | or 0

   456

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

   457

		*buf++ = c;

   458

	*buf = 0;

   459

}

   460

   461

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

   462

{

   463

	const char *start;

   464

	int i = 0;

   465

	bool init = true;

   466

   467

	do {

   468

		start = many;

   469

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

   470

		if (x & 1) {

   471

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

   472

			init = false;

   473

			if (start == many) {

   474

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

   475

			} else {

   476

				memcpy(buf, start, many - start);

   477

				buf += many - start;

   478

			}

   479

		}

   480

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

   481

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

   482

	*buf = 0;

   483

}

   484

   485

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

   486

{

   487

	unsigned long val;

   488

	char *end;

   489

   490

	switch(desc->flags & 0xF) {

   491

	case SDT_INTX:

   492

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

   493

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

   494

		return (void*)val;

   495

	case SDT_ONEOFMANY: {

   496

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

   497

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

   498

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

   499

		return 0;

   500

	}

   501

	case SDT_MANYOFMANY: {

   502

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

   503

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

   504

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

   505

		return 0;

   506

	}

   507

	case SDT_BOOLX:

   508

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

   509

			return (void*)true;

   510

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

   511

			return (void*)false;

   512

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

   513

		break;

   514

   515

	case SDT_STRING:

   516

	case SDT_STRINGBUF:

   517

	case SDT_STRINGQUOT:

   518

	case SDT_INTLIST:

   519

		return str;

   520

	}