1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "sound.h"

     4

#include "network.h"

     5

#include "settings.h"

     6

     7

typedef struct IniFile IniFile;

     8

typedef struct IniItem IniItem;

     9

typedef struct IniGroup IniGroup;

    10

typedef struct MemoryPool MemoryPool;

    11

    12

static void pool_init(MemoryPool **pool);

    13

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

    14

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

    15

static void pool_free(MemoryPool **pool);

    16

    17

struct MemoryPool {

    18

	uint pos,size;

    19

	MemoryPool *next;

    20

	byte mem[1];

    21

};

    22

    23

static MemoryPool *pool_new(uint minsize)

    24

{

    25

	MemoryPool *p;

    26

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

    27

    28

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

    29

	p->pos = 0;

    30

	p->size = minsize;

    31

	p->next = NULL;

    32

	return p;

    33

}

    34

    35

static void pool_init(MemoryPool **pool)

    36

{

    37

	*pool = pool_new(0);

    38

}

    39

    40

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

    41

{

    42

	uint pos;

    43

	MemoryPool *p = *pool;

    44

    45

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

    46

    47

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

    48

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

    49

		p = p->next;

    50

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

    51

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

    52

		MemoryPool *n = pool_new(size);

    53

		*pool = n;

    54

		n->next = p;

    55

		p = n;

    56

	}

    57

    58

	pos = p->pos;

    59

	p->pos += size;

    60

	return p->mem + pos;

    61

}

    62

    63

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

    64

{

    65

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

    66

	p[size] = 0;

    67

	memcpy(p, mem, size);

    68

	return p;

    69

}

    70

    71

static void pool_free(MemoryPool **pool)

    72

{

    73

	MemoryPool *p = *pool, *n;

    74

	*pool = NULL;

    75

	while (p) {

    76

		n = p->next;

    77

		free(p);

    78

		p = n;

    79

	}

    80

}

    81

    82

// structs describing the ini format.

    83

struct IniItem {

    84

	char *name;

    85

	char *value;

    86

	char *comment;

    87

	IniItem *next;

    88

};

    89

    90

struct IniGroup {

    91

	char *name; // name of group

    92

	char *comment; //comment for group

    93

	IniItem *item, **last_item;

    94

	IniGroup *next;

    95

	IniFile *ini;

    96

	IniGroupType type; // type of group

    97

};

    98

    99

struct IniFile {

   100

	MemoryPool *pool;

   101

	IniGroup *group, **last_group;

   102

	char *comment; // last comment in file

   103

};

   104

   105

// allocate an inifile object

   106

static IniFile *ini_alloc()

   107

{

   108

	IniFile *ini;

   109

	MemoryPool *pool;

   110

	pool_init(&pool);

   111

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

   112

	ini->pool = pool;

   113

	ini->group = NULL;

   114

	ini->last_group = &ini->group;

   115

	ini->comment = NULL;

   116

	return ini;

   117

}

   118

   119

// allocate an ini group object

   120

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

   121

{

   122

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

   123

	grp->ini = ini;

   124

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

   125

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

   126

		grp->type = IGT_LIST;

   127

	else

   128

		grp->type = IGT_VARIABLES;

   129

	grp->next = NULL;

   130

	grp->item = NULL;

   131

	grp->comment = NULL;

   132

	grp->last_item = &grp->item;

   133

	*ini->last_group = grp;

   134

	ini->last_group = &grp->next;

   135

	return grp;

   136

}

   137

   138

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

   139

{

   140

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

   141

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

   142

	item->next = NULL;

   143

	item->comment = NULL;

   144

	item->value = NULL;

   145

	*group->last_item = item;

   146

	group->last_item = &item->next;

   147

	return item;

   148

}

   149

   150

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

   151

static IniFile *ini_load(const char *filename)

   152

{

   153

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

   154

	FILE *in;

   155

	IniFile *ini;

   156

	IniGroup *group = NULL;

   157

	IniItem *item;

   158

   159

	byte *comment = NULL;

   160

	uint comment_size = 0;

   161

	uint comment_alloc = 0;

   162

   163

	ini = ini_alloc();

   164

   165

	in = fopen(filename, "r");

   166

	if (in == NULL) return ini;

   167

   168

	// for each line in the file

   169

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

   170

   171

		// trim whitespace from the left side

   172

		for(s=buffer; *s == ' ' || *s == '\t'; s++);

   173

   174

		// trim whitespace from right side.

   175

		e = s + strlen(s);

   176

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

   177

		*e = 0;

   178

   179

		// skip comments and empty lines

   180

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

   181

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

   182

			uint a = comment_alloc;

   183

			uint pos;

   184

			// add to comment

   185

			if (ns > a) {

   186

				a = max(a, 128);

   187

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

   188

				comment = realloc(comment, comment_alloc = a);

   189

			}

   190

			pos = comment_size;

   191

			comment_size += (e - s + 1);

   192

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

   193

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

   194

			continue;

   195

		}

   196

   197

		// it's a group?

   198

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

   199

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

   200

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

   201

			else

   202

				e--;

   203

			s++; // skip [

   204

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

   205

			if (comment_size) {

   206

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

   207

				comment_size = 0;

   208

			}

   209

		} else if (group) {

   210

			// find end of keyname

   211

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

   212

   213

			// it's an item in an existing group

   214

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

   215

			if (comment_size) {

   216

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

   217

				comment_size = 0;

   218

			}

   219

   220

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

   221

			if( group->type == IGT_LIST ) {

   222

				item->value = item->name;

   223

				continue;

   224

			}

   225

   226

			// find start of parameter

   227

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

   228

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

   229

		} else {

   230

			// it's an orphan item

   231

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

   232

		}

   233

	}

   234

   235

	if (comment_size) {

   236

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

   237

		comment_size = 0;

   238

	}

   239

   240

	free(comment);

   241

	fclose(in);

   242

   243

	return ini;

   244

}

   245

   246

// lookup a group or make a new one

   247

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

   248

{

   249

	IniGroup *group;

   250

   251

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

   252

   253

	// does it exist already?

   254

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

   255

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

   256

			return group;

   257

   258

	// otherwise make a new one

   259

	group = ini_group_alloc(ini, name, len);

   260

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

   261

	return group;

   262

}

   263

   264

// lookup an item or make a new one

   265

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

   266

{

   267

	IniItem *item;

   268

	uint len = strlen(name);

   269

   270

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

   271

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

   272

			return item;

   273

   274

	if (!create) return NULL;

   275

   276

	// otherwise make a new one

   277

	item = ini_item_alloc(group, name, len);

   278

	return item;

   279

}

   280

   281

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

   282

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

   283

{

   284

	FILE *f;

   285

	IniGroup *group;

   286

	IniItem *item;

   287

   288

	f = fopen(filename, "w");

   289

	if (f == NULL) return false;

   290

   291

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

   292

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

   293

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

   294

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

   295

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

   296

			if(group->type==IGT_LIST)

   297

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

   298

			else

   299

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

   300

		}

   301

	}

   302

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

   303

   304

	fclose(f);

   305

	return true;

   306

}

   307

   308

static void ini_free(IniFile *ini)

   309

{

   310

	pool_free(&ini->pool);

   311

}

   312

   313

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

   314

{

   315

	const char *s;

   316

	int idx;

   317

   318

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

   319

   320

	// check if it's an integer

   321

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

   322

		return strtoul(one, NULL, 0);

   323

   324

	idx = 0;

   325

	for(;;) {

   326

		// find end of item

   327

		s = many;

   328

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

   329

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

   330

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

   331

		many = s + 1;

   332

		idx++;

   333

	}

   334

}

   335

   336

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

   337

{

   338

	const char *s;

   339

	int r;

   340

	uint32 res = 0;

   341

   342

	for(;;) {

   343

		// skip "whitespace"

   344

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

   345

		if (*str == 0) break;

   346

   347

		s = str;

   348

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

   349

   350

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

   351

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

   352

   353

		res |= (1 << r);

   354

		if (*s == 0) break;

   355

		str = s + 1;

   356

	}

   357

	return res;

   358

}

   359

   360

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

   361

{

   362

	int n = 0, v;

   363

	char *end;

   364

   365

	for(;;) {

   366

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

   367

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

   368

		p = end;

   369

		items[n++] = v;

   370

		if (*p == 0) break;

   371

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

   372

		p++;

   373

	}

   374

   375

	return n;

   376

}

   377

   378

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

   379

{

   380

	int items[64];

   381

	int i,nitems;

   382

   383

	if (str == NULL) {

   384

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

   385

		nitems = nelems;

   386

	} else {

   387

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

   388

		if (nitems != nelems)

   389

			return false;

   390

	}

   391

   392

	switch(type) {

   393

	case SDT_INT8 >> 4:

   394

	case SDT_UINT8 >> 4:

   395

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

   396

		break;

   397

	case SDT_INT16 >> 4:

   398

	case SDT_UINT16 >> 4:

   399

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

   400

		break;

   401

	case SDT_INT32 >> 4:

   402

	case SDT_UINT32 >> 4:

   403

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

   404

		break;

   405

	default:

   406

		NOT_REACHED();

   407

	}

   408

   409

	return true;

   410

}

   411

   412

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

   413

{

   414

	int i, v = 0;

   415

	byte *p = (byte*)array;

   416

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

   417

		switch(type) {

   418

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

   419

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

   420

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

   421

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

   422

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

   423

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

   424

		default: NOT_REACHED();

   425

		}

   426

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

   427

	}

   428

}

   429

   430

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

   431

{

   432

	int orig_i = i;

   433

	char c;

   434

   435

	while (--i >= 0) {

   436

		do {

   437

			many++;

   438

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

   439

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

   440

				return;

   441

			}

   442

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

   443

	}

   444

   445

	// copy until | or 0

   446

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

   447

		*buf++ = c;

   448

	*buf = 0;

   449

}

   450

   451

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

   452

{

   453

	const char *start;

   454

	int i = 0;

   455

	bool init = true;

   456

   457

	do {

   458

		start = many;

   459

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

   460

		if (x & 1) {

   461

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

   462

			init = false;

   463

			if (start == many) {

   464

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

   465

			} else {

   466

				memcpy(buf, start, many - start);

   467

				buf += many - start;

   468

			}

   469

		}

   470

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

   471

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

   472

	*buf = 0;

   473

}

   474

   475

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

   476

{

   477

	unsigned long val;

   478

	char *end;

   479

   480

	switch(desc->flags & 0xF) {

   481

	case SDT_INTX:

   482

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

   483

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

   484

		return (void*)val;

   485

	case SDT_ONEOFMANY: {

   486

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

   487

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

   488

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

   489

		return 0;

   490

	}

   491

	case SDT_MANYOFMANY: {

   492

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

   493

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

   494

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

   495

		return 0;

   496

	}

   497

	case SDT_BOOLX:

   498

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

   499

			return (void*)true;

   500

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

   501

			return (void*)false;

   502

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

   503

		break;

   504

   505

	case SDT_STRING:

   506

	case SDT_STRINGBUF:

   507

	case SDT_INTLIST:

   508

		return (void*)str;

   509

	}

   510

   511

	return NULL;

   512

}

   513

   514

static void load_setting_desc(IniFile *ini, const SettingDesc *desc, const void *grpname)

   515

{

   516

	IniGroup *group_def = ini_getgroup(ini, grpname, -1), *group;

   517

	IniItem *item;

   518

	const void *p;

   519

	void *ptr;

   520

   521

	for (;desc->name;desc++) {

   522

		// group override?

   523

		const char *s = strchr(desc->name, '.');

   524

		if (s) {

   525

			group = ini_getgroup(ini, desc->name, s - desc->name);