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 "ai/ai.h"

    15

    16

typedef struct IniFile IniFile;

    17

typedef struct IniItem IniItem;

    18

typedef struct IniGroup IniGroup;

    19

typedef struct SettingsMemoryPool SettingsMemoryPool;

    20

    21

static void pool_init(SettingsMemoryPool **pool);

    22

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

    23

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

    24

static void pool_free(SettingsMemoryPool **pool);

    25

    26

struct SettingsMemoryPool {

    27

	uint pos,size;

    28

	SettingsMemoryPool *next;

    29

	byte mem[1];

    30

};

    31

    32

static SettingsMemoryPool *pool_new(uint minsize)

    33

{

    34

	SettingsMemoryPool *p;

    35

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

    36

    37

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

    38

	p->pos = 0;

    39

	p->size = minsize;

    40

	p->next = NULL;

    41

	return p;

    42

}

    43

    44

static void pool_init(SettingsMemoryPool **pool)

    45

{

    46

	*pool = pool_new(0);

    47

}

    48

    49

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

    50

{

    51

	uint pos;

    52

	SettingsMemoryPool *p = *pool;

    53

    54

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

    55

    56

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

    57

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

    58

		p = p->next;

    59

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

    60

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

    61

		SettingsMemoryPool *n = pool_new(size);

    62

		*pool = n;

    63

		n->next = p;

    64

		p = n;

    65

	}

    66

    67

	pos = p->pos;

    68

	p->pos += size;

    69

	return p->mem + pos;

    70

}

    71

    72

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

    73

{

    74

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

    75

	p[size] = 0;

    76

	memcpy(p, mem, size);

    77

	return p;

    78

}

    79

    80

static void pool_free(SettingsMemoryPool **pool)

    81

{

    82

	SettingsMemoryPool *p = *pool, *n;

    83

	*pool = NULL;

    84

	while (p) {

    85

		n = p->next;

    86

		free(p);

    87

		p = n;

    88

	}

    89

}

    90

    91

// structs describing the ini format.

    92

struct IniItem {

    93

	char *name;

    94

	char *value;

    95

	char *comment;

    96

	IniItem *next;

    97

};

    98

    99

struct IniGroup {

   100

	char *name; // name of group

   101

	char *comment; //comment for group

   102

	IniItem *item, **last_item;

   103

	IniGroup *next;

   104

	IniFile *ini;

   105

	IniGroupType type; // type of group

   106

};

   107

   108

struct IniFile {

   109

	SettingsMemoryPool *pool;

   110

	IniGroup *group, **last_group;

   111

	char *comment; // last comment in file

   112

};

   113

   114

// allocate an inifile object

   115

static IniFile *ini_alloc(void)

   116

{

   117

	IniFile *ini;

   118

	SettingsMemoryPool *pool;

   119

	pool_init(&pool);

   120

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

   121

	ini->pool = pool;

   122

	ini->group = NULL;

   123

	ini->last_group = &ini->group;

   124

	ini->comment = NULL;

   125

	return ini;

   126

}

   127

   128

// allocate an ini group object

   129

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

   130

{

   131

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

   132

	grp->ini = ini;

   133

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

   134

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

   135

		grp->type = IGT_LIST;

   136

	else

   137

		grp->type = IGT_VARIABLES;

   138

	grp->next = NULL;

   139

	grp->item = NULL;

   140

	grp->comment = NULL;

   141

	grp->last_item = &grp->item;

   142

	*ini->last_group = grp;

   143

	ini->last_group = &grp->next;

   144

	return grp;

   145

}

   146

   147

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

   148

{

   149

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

   150

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

   151

	item->next = NULL;

   152

	item->comment = NULL;

   153

	item->value = NULL;

   154

	*group->last_item = item;

   155

	group->last_item = &item->next;

   156

	return item;

   157

}

   158

   159

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

   160

static IniFile *ini_load(const char *filename)

   161

{

   162

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

   163

	FILE *in;

   164

	IniFile *ini;

   165

	IniGroup *group = NULL;

   166

	IniItem *item;

   167

   168

	char *comment = NULL;

   169

	uint comment_size = 0;

   170

	uint comment_alloc = 0;

   171

   172

	ini = ini_alloc();

   173

   174

	in = fopen(filename, "r");

   175

	if (in == NULL) return ini;

   176

   177

	// for each line in the file

   178

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

   179

   180

		// trim whitespace from the left side

   181

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

   182

   183

		// trim whitespace from right side.

   184

		e = s + strlen(s);

   185

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

   186

		*e = 0;

   187

   188

		// skip comments and empty lines

   189

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

   190

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

   191

			uint a = comment_alloc;

   192

			uint pos;

   193

			// add to comment

   194

			if (ns > a) {

   195

				a = max(a, 128);

   196

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

   197

				comment = realloc(comment, comment_alloc = a);

   198

			}

   199

			pos = comment_size;

   200

			comment_size += (e - s + 1);

   201

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

   202

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

   203

			continue;

   204

		}

   205

   206

		// it's a group?

   207

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

   208

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

   209

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

   210

			else

   211

				e--;

   212

			s++; // skip [

   213

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

   214

			if (comment_size) {

   215

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

   216

				comment_size = 0;

   217

			}

   218

		} else if (group) {

   219

			// find end of keyname

   220

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

   221

   222

			// it's an item in an existing group

   223

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

   224

			if (comment_size) {

   225

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

   226

				comment_size = 0;

   227

			}

   228

   229

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

   230

			if( group->type == IGT_LIST ) {

   231

				item->value = item->name;

   232

				continue;

   233

			}

   234

   235

			// find start of parameter

   236

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

   237

   238

   239

			// remove starting quotation marks

   240

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

   241

			// remove ending quotation marks

   242

			e = t + strlen(t);

   243

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

   244

			*e = 0;

   245

   246

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

   247

		} else {

   248

			// it's an orphan item

   249

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

   250

		}

   251

	}

   252

   253

	if (comment_size) {

   254

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

   255

		comment_size = 0;

   256

	}

   257

   258

	free(comment);

   259

	fclose(in);

   260

   261

	return ini;

   262

}

   263

   264

// lookup a group or make a new one

   265

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

   266

{

   267

	IniGroup *group;

   268

   269

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

   270

   271

	// does it exist already?

   272

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

   273

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

   274

			return group;

   275

   276

	// otherwise make a new one

   277

	group = ini_group_alloc(ini, name, len);

   278

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

   279

	return group;

   280

}

   281

   282

// lookup an item or make a new one

   283

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

   284

{

   285

	IniItem *item;

   286

	uint len = strlen(name);

   287

   288

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

   289

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

   290

			return item;

   291

   292

	if (!create) return NULL;

   293

   294

	// otherwise make a new one

   295

	item = ini_item_alloc(group, name, len);

   296

	return item;

   297

}

   298

   299

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

   300

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

   301

{

   302

	FILE *f;

   303

	IniGroup *group;

   304

	IniItem *item;

   305

   306

	f = fopen(filename, "w");

   307

	if (f == NULL) return false;

   308

   309

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

   310

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

   311

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

   312

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

   313

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

   314

			if(group->type==IGT_LIST)

   315

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

   316

			else

   317

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

   318

		}

   319

	}

   320

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

   321

   322

	fclose(f);

   323

	return true;

   324

}

   325

   326

static void ini_free(IniFile *ini)

   327

{

   328

	pool_free(&ini->pool);

   329

}

   330

   331

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

   332

{

   333

	const char *s;

   334

	int idx;

   335

   336

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

   337

   338

	// check if it's an integer

   339

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

   340

		return strtoul(one, NULL, 0);

   341

   342

	idx = 0;

   343

	for(;;) {

   344

		// find end of item

   345

		s = many;

   346

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

   347

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

   348

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

   349

		many = s + 1;

   350

		idx++;

   351

	}

   352

}

   353

   354

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

   355

{

   356

	const char *s;

   357

	int r;

   358

	uint32 res = 0;

   359

   360

	for(;;) {

   361

		// skip "whitespace"

   362

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

   363

		if (*str == 0) break;

   364

   365

		s = str;

   366

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

   367

   368

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

   369

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

   370

   371

		res |= (1 << r);

   372

		if (*s == 0) break;

   373

		str = s + 1;

   374

	}

   375

	return res;

   376

}

   377

   378

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

   379

{

   380

	int n = 0, v;

   381

	char *end;

   382

   383

	for(;;) {

   384

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

   385

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

   386

		p = end;

   387

		items[n++] = v;

   388

		if (*p == 0) break;

   389

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

   390

		p++;

   391

	}

   392

   393

	return n;

   394

}

   395

   396

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

   397

{

   398

	int items[64];

   399

	int i,nitems;

   400

   401

	if (str == NULL) {

   402

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

   403

		nitems = nelems;

   404

	} else {

   405

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

   406

		if (nitems != nelems)

   407

			return false;

   408

	}

   409

   410

	switch(type) {

   411

	case SDT_INT8 >> 4:

   412

	case SDT_UINT8 >> 4:

   413

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

   414

		break;

   415

	case SDT_INT16 >> 4:

   416

	case SDT_UINT16 >> 4:

   417

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

   418

		break;

   419

	case SDT_INT32 >> 4:

   420

	case SDT_UINT32 >> 4:

   421

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

   422

		break;

   423

	default:

   424

		NOT_REACHED();

   425

	}

   426

   427

	return true;

   428

}

   429

   430

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

   431

{

   432

	int i, v = 0;

   433

	byte *p = (byte*)array;

   434

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

   435

		switch(type) {

   436

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

   437

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

   438

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

   439

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

   440

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

   441

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

   442

		default: NOT_REACHED();

   443

		}

   444

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

   445

	}

   446

}

   447

   448

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

   449

{

   450

	int orig_i = i;

   451

	char c;

   452

   453

	while (--i >= 0) {

   454

		do {

   455

			many++;

   456

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

   457

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

   458

				return;

   459

			}

   460

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

   461

	}

   462

   463

	// copy until | or 0

   464

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

   465

		*buf++ = c;

   466

	*buf = 0;

   467

}

   468

   469

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

   470

{

   471

	const char *start;

   472

	int i = 0;

   473

	bool init = true;

   474

   475

	do {

   476

		start = many;

   477

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

   478

		if (x & 1) {

   479

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

   480

			init = false;

   481

			if (start == many) {

   482

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

   483

			} else {

   484

				memcpy(buf, start, many - start);

   485

				buf += many - start;

   486

			}

   487

		}

   488

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

   489

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

   490

	*buf = 0;

   491

}

   492

   493

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

   494

{

   495

	uint32 val;

   496

	char *end;

   497

   498

	switch(desc->flags & 0xF) {

   499

	case SDT_INTX:

   500

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

   501

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

   502

		return (void*)val;

   503

	case SDT_ONEOFMANY: {

   504

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

   505

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

   506

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

   507

		return 0;

   508

	}

   509

	case SDT_MANYOFMANY: {

   510

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

   511

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

   512

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

   513

		return 0;

   514

	}

   515

	case SDT_BOOLX:

   516

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

   517

			return (void*)true;

   518

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

   519

			return (void*)false;