1

#include "../stdafx.h"

     2

#include <stdio.h>

     3

#include <string.h>

     4

#include <stdlib.h>

     5

#include <stdarg.h>

     6

     7

#if !defined(WIN32) || defined(__CYGWIN__)

     8

#include <unistd.h>

     9

#endif

    10

    11

#ifdef WITH_REV

    12

extern char _openttd_revision[];

    13

#endif

    14

    15

/* Compiles a list of strings into a compiled string list */

    16

    17

#define lengthof(x) (sizeof(x)/sizeof(x[0]))

    18

    19

typedef void (*ParseCmdProc)(char *buf, int value);

    20

    21

typedef struct {

    22

	uint32 ident;

    23

	uint32 version;			// 32-bits of auto generated version info which is basically a hash of strings.h

    24

	char name[32];			// the international name of this language

    25

	char own_name[32];	// the localized name of this language

    26

	uint16 offsets[32];	// the offsets

    27

} LanguagePackHeader;

    28

    29

typedef struct CmdStruct {

    30

	const char *cmd;

    31

	ParseCmdProc proc;

    32

	long value;

    33

} CmdStruct;

    34

    35

typedef struct LineName {

    36

	struct LineName *hash_next;

    37

	int value;

    38

	char str[1];

    39

} LineName; 

    40

    41

int _cur_line;

    42

bool _warnings;

    43

    44

uint32 _hash;

    45

char _lang_name[32], _lang_ownname[32];

    46

    47

#define HASH_SIZE 1023

    48

LineName *_hash_head[HASH_SIZE];

    49

unsigned int hash_str(const char *s) {

    50

	unsigned int hash = 0;

    51

	for(;*s;s++)

    52

		hash = ((hash << 3) | (hash >> 29)) ^ *s;

    53

	return hash % HASH_SIZE;

    54

}

    55

void hash_add(const char *s, int value) {

    56

	unsigned int len = strlen(s);

    57

	LineName *ln = (LineName*)malloc(sizeof(LineName) + len);

    58

	unsigned int hash = hash_str(s);

    59

	ln->hash_next = _hash_head[hash];

    60

	_hash_head[hash] = ln;

    61

	ln->value = value;

    62

	ln->str[len] = 0;

    63

	memcpy(ln->str, s, len);

    64

}

    65

    66

int hash_find(const char *s) {

    67

	LineName *ln = _hash_head[hash_str(s)];

    68

	while (ln != NULL) {

    69

		if (!strcmp(ln->str, s)) {

    70

			return ln->value;

    71

		}

    72

		ln = ln->hash_next;

    73

	}

    74

	return -1;

    75

}

    76

    77

void warning(const char *s, ...) {

    78

	char buf[1024];

    79

	va_list va;

    80

	va_start(va, s);

    81

	vsprintf(buf, s, va);

    82

	va_end(va);

    83

	fprintf(stderr, "%d: ERROR: %s\n", _cur_line, buf);

    84

	_warnings = true;

    85

}

    86

    87

void NORETURN error(const char *s, ...) {

    88

	char buf[1024];

    89

	va_list va;

    90

	va_start(va, s);

    91

	vsprintf(buf, s, va);

    92

	va_end(va);

    93

	fprintf(stderr, "%d: FATAL: %s\n", _cur_line, buf);

    94

	exit(1);

    95

}

    96

    97

void ttd_strlcpy(char *dst, const char *src, size_t len)

    98

{

    99

	assert(len > 0);

   100

	while (--len && *src)

   101

		*dst++=*src++;

   102

	*dst = 0;

   103

}

   104

   105

   106

// first byte tells if it's english.lng or a custom language file

   107

// second part is the name of the string

   108

// third part is the actual string contents

   109

char *allstr[65536];

   110

   111

byte _put_buf[4096];

   112

int _put_pos;

   113

int _next_string_id;

   114

   115

void put_byte(byte c) {

   116

	if (_put_pos == lengthof(_put_buf))

   117

		error("Put buffer too small");

   118

	_put_buf[_put_pos++] = c;

   119

}

   120

   121

void emit_buf(int ent) {

   122

	char *s;

   123

   124

	if (ent < 0 || ent >= 0x10000) {

   125

		warning("Invalid string ID %d\n", ent);

   126

		return;

   127

	}

   128

   129

	if (allstr[ent] != 0) {

   130

		warning("Duplicate string ID %d\n", ent);

   131

		return;

   132

	}

   133

   134

	// Allocate the string, and put the uint16 before with the length.

   135

	s = (char*)malloc(sizeof(uint16) + _put_pos);

   136

	*((uint16*)s) = _put_pos;

   137

	memcpy(s + sizeof(uint16), _put_buf, _put_pos);

   138

   139

	allstr[ent] = s;

   140

   141

	_put_pos = 0;

   142

}

   143

   144

void EmitSingleByte(char *buf, int value) {

   145

	if (*buf != 0)

   146

		warning("Ignoring trailing letters in command");

   147

	put_byte((byte)value);

   148

}

   149

   150

void EmitEscapedByte(char *buf, int value) {

   151

	if (*buf != 0)

   152

		warning("Ignoring trailing letters in command");

   153

	put_byte((byte)0x85);

   154

	put_byte((byte)value);

   155

}

   156

   157

   158

void EmitStringInl(char *buf, int value) {

   159

	int id;

   160

   161

	if (*buf>='0' && *buf <= '9') {

   162

		id = strtol(buf, NULL, 0);

   163

		if (id < 0 || id>=0x10000) {

   164

			warning("Invalid inline num %s\n", buf);

   165

			return;

   166

		}

   167

	} else {

   168

		id = hash_find(buf);

   169

		if (id == -1) {

   170

			warning("Invalid inline string '%s'", buf);

   171

			return;

   172

		}

   173

	}

   174

   175

	put_byte(0x81);

   176

	put_byte((byte)(id & 0xFF));

   177

	put_byte((byte)(id >> 8));

   178

}

   179

   180

void EmitSetX(char *buf, int value) {

   181

	char *err;

   182

	int x = strtol(buf, &err, 0);

   183

	if (*err != 0)

   184

		error("SetX param invalid");

   185

	put_byte(1);

   186

	put_byte((byte)x);

   187

}

   188

   189

void EmitSetXY(char *buf, int value) {

   190

	char *err;

   191

	int x = strtol(buf, &err, 0), y;

   192

	if (*err != 0) error("SetXY param invalid");

   193

	y = strtol(err+1, &err, 0);

   194

	if (*err != 0) error("SetXY param invalid");

   195

   196

	put_byte(0x1F);

   197

	put_byte((byte)x);

   198

	put_byte((byte)y);

   199

}

   200

   201

static const CmdStruct _cmd_structs[] = {

   202

	// Update position

   203

	{"SETX", EmitSetX, 1},

   204

	{"SETXY", EmitSetXY, 2},

   205

   206

	// Font size

   207

	{"TINYFONT", EmitSingleByte, 8},

   208

	{"BIGFONT", EmitSingleByte, 9},

   209

   210

	// New line

   211

	{"", EmitSingleByte, 10},

   212

   213

	// Colors

   214

	{"BLUE", EmitSingleByte, 15},		

   215

	{"SILVER", EmitSingleByte, 16},

   216

	{"GOLD", EmitSingleByte, 17},

   217

	{"RED", EmitSingleByte, 18},

   218

	{"PURPLE", EmitSingleByte, 19},

   219

	{"LTBROWN", EmitSingleByte, 20},

   220

	{"ORANGE", EmitSingleByte, 21},

   221

	{"GREEN", EmitSingleByte, 22},

   222

	{"YELLOW", EmitSingleByte, 23},

   223

	{"DKGREEN", EmitSingleByte, 24},

   224

	{"CREAM", EmitSingleByte, 25},

   225

	{"BROWN", EmitSingleByte, 26},

   226

	{"WHITE", EmitSingleByte, 27},

   227

	{"LTBLUE", EmitSingleByte, 28},

   228

	{"GRAY", EmitSingleByte, 29},

   229

	{"DKBLUE", EmitSingleByte, 30},

   230

	{"BLACK", EmitSingleByte, 31},

   231

   232

	// 0x7B=123 is the LAST special character we may use.

   233

   234

	// Numbers

   235

	{"COMMA32", EmitSingleByte, 0x7B},

   236

	{"COMMA16", EmitSingleByte, 0x7C},

   237

	{"COMMA8", EmitSingleByte, 0x7D},

   238

	{"NUMU16", EmitSingleByte, 0x7E},

   239

   240

	{"CURRENCY", EmitSingleByte, 0x7F},

   241

   242

	{"CURRCOMPACT", EmitEscapedByte, 0}, // compact currency

   243

	{"INT32", EmitEscapedByte, 1}, // compact currency

   244

	{"REV", EmitEscapedByte, 2}, // openttd revision string

   245

	{"SHORTCARGO", EmitEscapedByte, 3}, // short cargo description, only ### tons, or ### litres

   246

   247

	{"STRINL", EmitStringInl, 0x81},

   248

   249

	{"DATE_LONG", EmitSingleByte, 0x82},

   250

	{"DATE_SHORT", EmitSingleByte, 0x83},

   251

   252

	{"VELOCITY", EmitSingleByte, 0x84},

   253

	{"SKIP16", EmitSingleByte, 0x85},

   254

	{"SKIP", EmitSingleByte, 0x86},

   255

	{"VOLUME", EmitSingleByte, 0x87},

   256

   257

	{"STRING", EmitSingleByte, 0x88},

   258

   259

	{"CARGO", EmitSingleByte, 0x99},

   260

	{"STATION", EmitSingleByte, 0x9A},

   261

	{"TOWN", EmitSingleByte, 0x9B},

   262

	{"CURRENCY64", EmitSingleByte, 0x9C},

   263

	{"CHECKPOINT", EmitSingleByte, 0x9D}, // checkpoint name

   264

	// 0x9E=158 is the LAST special character we may use.

   265

   266

	{"UPARROW", EmitSingleByte, 0xA0},

   267

	{"POUNDSIGN", EmitSingleByte, 0xA3},

   268

	{"YENSIGN", EmitSingleByte, 0xA5},

   269

	{"COPYRIGHT", EmitSingleByte, 0xA9},

   270

	{"DOWNARROW", EmitSingleByte, 0xAA},

   271

	{"CHECKMARK", EmitSingleByte, 0xAC},

   272

	{"CROSS", EmitSingleByte, 0xAD},

   273

	{"RIGHTARROW", EmitSingleByte, 0xAF},

   274

   275

	{"SMALLUPARROW", EmitSingleByte, 0xBC},

   276

	{"SMALLDOWNARROW", EmitSingleByte, 0xBD},

   277

	{"THREE_FOURTH", EmitSingleByte, 0xBE},

   278

};

   279

   280

const CmdStruct *find_cmd(const char *s, int len) {

   281

	int i;

   282

	const CmdStruct *cs = _cmd_structs;

   283

	for(i=0; i!=lengthof(_cmd_structs); i++,cs++) {

   284

		if (!strncmp(cs->cmd, s, len) && cs->cmd[len] == 0)

   285

			return cs;

   286

	}

   287

	return NULL;

   288

}

   289

   290

   291

// returns 0 on EOL

   292

// returns 1-255 on literal byte

   293

// else returns command struct

   294

const CmdStruct *parse_command_string(char **str, char *param, const char *errortext)

   295

{

   296

	char *s = *str, *start;

   297

	byte c = *s++;

   298

	const CmdStruct *cmd;

   299

   300

	if (c != '{') {

   301

		*str = s;

   302

		return (CmdStruct*) (int)c;

   303

	}

   304

   305

	// parse command name

   306

	start = s;

   307

	for(;;) {

   308

		c = *s++;

   309

		if (c == '}' || c == ' ')

   310

			break;

   311

		if (c == 0) {

   312

			if (errortext) warning("Missing } from command '%s' in '%s'", start, errortext);

   313

			return NULL;

   314

		}

   315

	}

   316

   317

	cmd = find_cmd(start, s - start - 1);

   318

	if (cmd == NULL) {

   319

		if (errortext) warning("Undefined command '%.*s' in '%s'", s - start - 1, start, errortext);

   320

		return NULL;

   321

	}

   322

   323

	if (c == ' ') {

   324

		// copy params

   325

		start = s;

   326

		for(;;) {

   327

			c = *s++;

   328

			if (c == '}') break;

   329

			if (c == 0) {

   330

				if (errortext) warning("Missing } from command '%s' in '%s'", start, errortext);

   331

				return NULL;

   332

			}

   333

			*param++ = c;

   334

		}

   335

   336

	}

   337

	*param = 0;

   338

   339

	*str = s;

   340

   341

	return cmd;

   342

}

   343

   344

   345

void handle_pragma(char *str)

   346

{

   347

	if (!memcmp(str, "id ", 3)) {

   348

		_next_string_id = strtoul(str + 3, NULL, 0);

   349

	} else if (!memcmp(str, "name ", 5)) {

   350

		ttd_strlcpy(_lang_name, str + 5, sizeof(_lang_name));

   351

	} else if (!memcmp(str, "ownname ", 8)) {

   352

		ttd_strlcpy(_lang_ownname, str + 8, sizeof(_lang_ownname));

   353

	} else {

   354

		error("unknown pragma '%s'", str);

   355

	}

   356

}

   357

   358

bool check_commands_match(char *a, char *b)

   359

{

   360

	const CmdStruct *ar, *br;

   361

	char param[100];

   362

   363

	do {

   364

		// read until next command from a.

   365

		do {

   366

			ar = parse_command_string(&a, param, NULL);

   367

		} while (ar != NULL && (unsigned long)ar <= 255);

   368

   369

		// read until next command from b.

   370

		do {

   371

			br = parse_command_string(&b, param, NULL);

   372

		} while (br != NULL && (unsigned long)br <= 255);

   373

   374

		// make sure they are identical

   375

		if (ar != br) return false;

   376

	} while (ar);

   377

   378

	return true;

   379

}

   380

   381

void handle_string(char *str, bool master) {

   382

	char *s,*t,*r;

   383

	int ent;

   384

   385

	if (*str == '#') {

   386

		if (str[1] == '#' && str[2] != '#')

   387

			handle_pragma(str + 2);

   388

		return;

   389

	}

   390

   391

	// Ignore comments & blank lines

   392

	if (*str == ';' || *str == ' ' || *str == 0)

   393

		return;

   394

   395

	s = strchr(str, ':');

   396

	if (s == NULL) {

   397

		warning("Line has no ':' delimiter");

   398

		return;

   399

	}

   400

   401

	// Trim spaces

   402

	for(t=s;t > str && (t[-1]==' ' || t[-1]=='\t'); t--);

   403

	*t = 0;

   404

   405

	ent = hash_find(str);

   406

   407

	s++; // skip :

   408

   409

	// allocate string entry

   410

	r = malloc(strlen(str) + strlen(s) + 3);

   411

	*r = master;

   412

	strcpy(r + 1, str);

   413

	strcpy(r + 2 + strlen(str), s);

   414

   415

	if (master) {

   416

		if (ent != -1) {

   417

			warning("String name '%s' is used multiple times", str);

   418

			return;

   419

		}

   420

   421

		ent = _next_string_id++;

   422

		if (allstr[ent]) {

   423

			warning("String ID 0x%X for '%s' already in use by '%s'", ent, str, allstr[ent] + 1);

   424

			return;

   425

		}

   426

		allstr[ent] = r;

   427

   428

		// add to hash table

   429

		hash_add(str, ent);

   430

	} else {

   431

		if (ent == -1) {

   432

			warning("String name '%s' does not exist in master file", str);

   433

			_warnings = 0; // non-fatal

   434

			return;

   435

		}

   436

   437

		if (!allstr[ent][0]) {

   438

			warning("String name '%s' is used multiple times", str);

   439

			_warnings = 0; // non-fatal

   440

			return;

   441

		}

   442

   443

		// check that the commands match

   444

		if (!check_commands_match(s, allstr[ent] + 2 + strlen(allstr[ent] + 1))) {

   445

			fprintf(stderr, "Warning: String name '%s' does not match the layout of the master string\n", str);

   446

			_warnings = 0; // non-fatal

   447

			return;

   448

		}

   449

   450

		if (s[0] == ':' && s[1] == 0) {

   451

			allstr[ent][0] = 0; // use string from master file legitiately

   452

			free(r);

   453

		} else {

   454

			free(allstr[ent]);

   455

			allstr[ent] = r;

   456

		}

   457

	}

   458

}

   459

   460

uint32 my_hash_str(uint32 hash, const char *s)

   461

{

   462

	for(;*s;s++) {

   463

		hash = ((hash << 3) | (hash >> 29)) ^ *s;

   464

		if (hash & 1) hash = (hash>>1) ^ 0xDEADBEEF; else hash >>= 1;

   465

	}

   466

	return hash;

   467

   468

}

   469

   470

void parse_file(const char *file, bool english) {

   471

	char buf[2048];

   472

	int i;

   473

	FILE *in;

   474

   475

	in = fopen(file, "r");

   476

	if (in == NULL) { error("Cannot open file '%s'", file); }

   477

   478

	_cur_line = 1;

   479

	while (fgets(buf, sizeof(buf),in) != NULL) {

   480

		i = strlen(buf);

   481

		while (i>0 && (buf[i-1]=='\r' || buf[i-1]=='\n' || buf[i-1] == ' ')) i--;

   482

		buf[i] = 0;

   483

   484

		handle_string(buf, english);

   485

		_cur_line++;

   486

	}

   487

   488

	fclose(in);

   489

   490

	// make a hash of the file to get a unique "version number"

   491

	if (english) {

   492

		uint32 hash = 0;

   493

		char *s;

   494

		const CmdStruct *cs;

   495

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

   496

			if ((s=allstr[i]) != NULL) {

   497

				hash ^= i * 0x717239;

   498

				if (hash & 1) hash = (hash>>1) ^ 0xDEADBEEF; else hash >>= 1;

   499

				hash = my_hash_str(hash, s + 1);

   500

   501

				s = s + 2 + strlen(s + 1);

   502

				while ((cs = parse_command_string(&s, buf, NULL)) != 0) {

   503

					if ( (uint)cs >= 256) {

   504

						hash ^= (cs - _cmd_structs) * 0x1234567;

   505

						if (hash & 1) hash = (hash>>1) ^ 0xF00BAA4; else hash >>= 1;

   506

					}

   507

				}

   508

			}	

   509

		}

   510

		_hash = hash;

   511

	}

   512

}

   513

   514

int count_inuse(int grp) {

   515

	int i;

   516

   517

	for(i=0x800; --i >= 0;) {

   518

		if (allstr[(grp<<11)+i] != NULL)

   519

			break;

   520

	}

   521

	return i + 1;

   522

}

   523

   524

void check_all_used() {

   525

	int i;

   526

	LineName *ln;

   527

	int num_warn = 10;

   528

   529

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

   530