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 __MORPHOS__

    12

#ifdef stderr

    13

#undef stderr

    14

#endif

    15

#define stderr stdout

    16

#endif // __MORPHOS__

    17

    18

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

    19

    20

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

    21

    22

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

    23

    24

typedef struct {

    25

	uint32 ident;

    26

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

    27

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

    28

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

    29

	char isocode[16];	// the ISO code for the language (not country code)

    30

	uint16 offsets[32];	// the offsets

    31

} LanguagePackHeader;

    32

    33

typedef struct CmdStruct {

    34

	const char *cmd;

    35

	ParseCmdProc proc;

    36

	long value;

    37

} CmdStruct;

    38

    39

typedef struct LineName {

    40

	struct LineName *hash_next;

    41

	int value;

    42

	char str[1];

    43

} LineName;

    44

    45

int _cur_line;

    46

bool _warnings;

    47

    48

uint32 _hash;

    49

char _lang_name[32], _lang_ownname[32], _lang_isocode[16];

    50

    51

#define HASH_SIZE 1023

    52

LineName *_hash_head[HASH_SIZE];

    53

unsigned int hash_str(const char *s) {

    54

	unsigned int hash = 0;

    55

	for(;*s;s++)

    56

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

    57

	return hash % HASH_SIZE;

    58

}

    59

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

    60

	unsigned int len = strlen(s);

    61

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

    62

	unsigned int hash = hash_str(s);

    63

	ln->hash_next = _hash_head[hash];

    64

	_hash_head[hash] = ln;

    65

	ln->value = value;

    66

	ln->str[len] = 0;

    67

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

    68

}

    69

    70

int hash_find(const char *s) {

    71

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

    72

	while (ln != NULL) {

    73

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

    74

			return ln->value;

    75

		}

    76

		ln = ln->hash_next;

    77

	}

    78

	return -1;

    79

}

    80

    81

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

    82

	char buf[1024];

    83

	va_list va;

    84

	va_start(va, s);

    85

	vsprintf(buf, s, va);

    86

	va_end(va);

    87

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

    88

	_warnings = true;

    89

}

    90

    91

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

    92

	char buf[1024];

    93

	va_list va;

    94

	va_start(va, s);

    95

	vsprintf(buf, s, va);

    96

	va_end(va);

    97

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

    98

	exit(1);

    99

}

   100

   101

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

   102

{

   103

	assert(len > 0);

   104

	while (--len && *src)

   105

		*dst++=*src++;

   106

	*dst = 0;

   107

}

   108

   109

   110

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

   111

// second part is the name of the string

   112

// third part is the actual string contents

   113

char *allstr[65536];

   114

   115

byte _put_buf[4096];

   116

int _put_pos;

   117

int _next_string_id;

   118

   119

void put_byte(byte c) {

   120

	if (_put_pos == lengthof(_put_buf))

   121

		error("Put buffer too small");

   122

	_put_buf[_put_pos++] = c;

   123

}

   124

   125

void emit_buf(int ent) {

   126

	char *s;

   127

   128

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

   129

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

   130

		return;

   131

	}

   132

   133

	if (allstr[ent] != 0) {

   134

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

   135

		return;

   136

	}

   137

   138

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

   139

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

   140

	*((uint16*)s) = _put_pos;

   141

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

   142

   143

	allstr[ent] = s;

   144

   145

	_put_pos = 0;

   146

}

   147

   148

void EmitSingleByte(char *buf, int value) {

   149

	if (*buf != 0)

   150

		warning("Ignoring trailing letters in command");

   151

	put_byte((byte)value);

   152

}

   153

   154

void EmitEscapedByte(char *buf, int value) {

   155

	if (*buf != 0)

   156

		warning("Ignoring trailing letters in command");

   157

	put_byte((byte)0x85);

   158

	put_byte((byte)value);

   159

}

   160

   161

   162

void EmitStringInl(char *buf, int value) {

   163

	int id;

   164

   165

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

   166

		id = strtol(buf, NULL, 0);

   167

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

   168

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

   169

			return;

   170

		}

   171

	} else {

   172

		id = hash_find(buf);

   173

		if (id == -1) {

   174

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

   175

			return;

   176

		}

   177

	}

   178

   179

	put_byte(0x81);

   180

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

   181

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

   182

}

   183

   184

void EmitSetX(char *buf, int value) {

   185

	char *err;

   186

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

   187

	if (*err != 0)

   188

		error("SetX param invalid");

   189

	put_byte(1);

   190

	put_byte((byte)x);

   191

}

   192

   193

void EmitSetXY(char *buf, int value) {

   194

	char *err;

   195

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

   196

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

   197

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

   198

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

   199

   200

	put_byte(0x1F);

   201

	put_byte((byte)x);

   202

	put_byte((byte)y);

   203

}

   204

   205

static const CmdStruct _cmd_structs[] = {

   206

	// Update position

   207

	{"SETX", EmitSetX, 1},

   208

	{"SETXY", EmitSetXY, 2},

   209

   210

	// Font size

   211

	{"TINYFONT", EmitSingleByte, 8},

   212

	{"BIGFONT", EmitSingleByte, 9},

   213

   214

	// New line

   215

	{"", EmitSingleByte, 10},

   216

   217

	// Colors

   218

	{"BLUE", EmitSingleByte, 15},

   219

	{"SILVER", EmitSingleByte, 16},

   220

	{"GOLD", EmitSingleByte, 17},

   221

	{"RED", EmitSingleByte, 18},

   222

	{"PURPLE", EmitSingleByte, 19},

   223

	{"LTBROWN", EmitSingleByte, 20},

   224

	{"ORANGE", EmitSingleByte, 21},

   225

	{"GREEN", EmitSingleByte, 22},

   226

	{"YELLOW", EmitSingleByte, 23},

   227

	{"DKGREEN", EmitSingleByte, 24},

   228

	{"CREAM", EmitSingleByte, 25},

   229

	{"BROWN", EmitSingleByte, 26},

   230

	{"WHITE", EmitSingleByte, 27},

   231

	{"LTBLUE", EmitSingleByte, 28},

   232

	{"GRAY", EmitSingleByte, 29},

   233

	{"DKBLUE", EmitSingleByte, 30},

   234

	{"BLACK", EmitSingleByte, 31},

   235

   236

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

   237

   238

	// Numbers

   239

	{"COMMA32", EmitSingleByte, 0x7B},

   240

	{"COMMA16", EmitSingleByte, 0x7C},

   241

	{"COMMA8", EmitSingleByte, 0x7D},

   242

	{"NUMU16", EmitSingleByte, 0x7E},

   243

   244

	{"CURRENCY", EmitSingleByte, 0x7F},

   245

   246

	// 0x85

   247

	{"CURRCOMPACT", EmitEscapedByte, 0},		// compact currency (32 bits)

   248

	{"INT32", EmitEscapedByte, 1},					// signed 32 bit integer

   249

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

   250

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

   251

	{"CURRCOMPACT64", EmitEscapedByte, 4},	// compact currency 64 bits

   252

   253

	{"STRINL", EmitStringInl, 0x81},

   254

   255

	{"DATE_LONG", EmitSingleByte, 0x82},

   256

	{"DATE_SHORT", EmitSingleByte, 0x83},

   257

   258

	{"VELOCITY", EmitSingleByte, 0x84},

   259

	{"SKIP16", EmitSingleByte, 0x85},

   260

	{"SKIP", EmitSingleByte, 0x86},

   261

	{"VOLUME", EmitSingleByte, 0x87},

   262

   263

	{"STRING", EmitSingleByte, 0x88},

   264

   265

	{"CARGO", EmitSingleByte, 0x99},

   266

	{"STATION", EmitSingleByte, 0x9A},

   267

	{"TOWN", EmitSingleByte, 0x9B},

   268

	{"CURRENCY64", EmitSingleByte, 0x9C},

   269

	{"WAYPOINT", EmitSingleByte, 0x9D}, // waypoint name

   270

	{"DATE_TINY", EmitSingleByte, 0x9E},

   271

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

   272

   273

	{"UPARROW", EmitSingleByte, 0xA0},

   274

	{"POUNDSIGN", EmitSingleByte, 0xA3},

   275

	{"YENSIGN", EmitSingleByte, 0xA5},

   276

	{"COPYRIGHT", EmitSingleByte, 0xA9},

   277

	{"DOWNARROW", EmitSingleByte, 0xAA},

   278

	{"CHECKMARK", EmitSingleByte, 0xAC},

   279

	{"CROSS", EmitSingleByte, 0xAD},

   280

	{"RIGHTARROW", EmitSingleByte, 0xAF},

   281

   282

	{"TRAIN", EmitSingleByte, 0xb4},

   283

	{"LORRY", EmitSingleByte, 0xb5},

   284

	{"BUS",   EmitSingleByte, 0xb6},

   285

	{"PLANE", EmitSingleByte, 0xb7},

   286

	{"SHIP",  EmitSingleByte, 0xb8},

   287

   288

	{"SMALLUPARROW", EmitSingleByte, 0xBC},

   289

	{"SMALLDOWNARROW", EmitSingleByte, 0xBD},

   290

	{"THREE_FOURTH", EmitSingleByte, 0xBE},

   291

};

   292

   293

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

   294

	int i;

   295

	const CmdStruct *cs = _cmd_structs;

   296

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

   297

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

   298

			return cs;

   299

	}

   300

	return NULL;

   301

}

   302

   303

   304

// returns 0 on EOL

   305

// returns 1-255 on literal byte

   306

// else returns command struct

   307

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

   308

{

   309

	char *s = *str, *start;

   310

	byte c = *s++;

   311

	const CmdStruct *cmd;

   312

   313

	if (c != '{') {

   314

		*str = s;

   315

		return (CmdStruct*) (int)c;

   316

	}

   317

   318

	// parse command name

   319

	start = s;

   320

	for(;;) {

   321

		c = *s++;

   322

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

   323

			break;

   324

		if (c == 0) {

   325

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

   326

			return NULL;

   327

		}

   328

	}

   329

   330

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

   331

	if (cmd == NULL) {

   332

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

   333

		return NULL;

   334

	}

   335

   336

	if (c == ' ') {

   337

		// copy params

   338

		start = s;

   339

		for(;;) {

   340

			c = *s++;

   341

			if (c == '}') break;

   342

			if (c == 0) {

   343

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

   344

				return NULL;

   345

			}

   346

			*param++ = c;

   347

		}

   348

   349

	}

   350

	*param = 0;

   351

   352

	*str = s;

   353

   354

	return cmd;

   355

}

   356

   357

   358

void handle_pragma(char *str)

   359

{

   360

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

   361

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

   362

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

   363

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

   364

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

   365

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

   366

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

   367

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

   368

	} else {

   369

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

   370

	}

   371

}

   372

   373

bool check_commands_match(char *a, char *b)

   374

{

   375

	const CmdStruct *ar, *br;

   376

	char param[100];

   377

   378

	do {

   379

		// read until next command from a.

   380

		do {

   381

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

   382

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

   383

   384

		// read until next command from b.

   385

		do {

   386

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

   387

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

   388

   389

		// make sure they are identical

   390

		if (ar != br) return false;

   391

	} while (ar);

   392

   393

	return true;

   394

}

   395

   396

void handle_string(char *str, bool master) {

   397

	char *s,*t,*r;

   398

	int ent;

   399

   400

	if (*str == '#') {

   401

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

   402

			handle_pragma(str + 2);

   403

		return;

   404

	}

   405

   406

	// Ignore comments & blank lines

   407

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

   408

		return;

   409

   410

	s = strchr(str, ':');

   411

	if (s == NULL) {

   412

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

   413

		return;

   414

	}

   415

   416

	// Trim spaces

   417

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

   418

	*t = 0;

   419

   420

	ent = hash_find(str);

   421

   422

	s++; // skip :

   423

   424

	// allocate string entry

   425

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

   426

	*r = master;

   427

	strcpy(r + 1, str);

   428

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

   429

   430

	if (master) {

   431

		if (ent != -1) {

   432

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

   433

			return;

   434

		}

   435

   436

		ent = _next_string_id++;

   437

		if (allstr[ent]) {

   438

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

   439

			return;

   440

		}

   441

		allstr[ent] = r;

   442

   443

		// add to hash table

   444

		hash_add(str, ent);

   445

	} else {

   446

		if (ent == -1) {

   447

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

   448

			_warnings = 0; // non-fatal

   449

			return;

   450

		}

   451

   452

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

   453

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

   454

			_warnings = 0; // non-fatal

   455

			return;

   456

		}

   457

   458

		// check that the commands match

   459

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

   460

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

   461

			_warnings = 0; // non-fatal

   462

			return;

   463

		}

   464

   465

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

   466

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

   467

			free(r);

   468

		} else {

   469

			free(allstr[ent]);

   470

			allstr[ent] = r;

   471

		}

   472

	}

   473

}

   474

   475

uint32 my_hash_str(uint32 hash, const char *s)

   476

{

   477

	for(;*s;s++) {

   478

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

   479

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

   480

	}

   481

	return hash;

   482

   483

}

   484

   485

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

   486

	char buf[2048];

   487

	int i;

   488

	FILE *in;

   489

   490

	in = fopen(file, "r");

   491

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

   492

   493

	_cur_line = 1;

   494

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

   495

		i = strlen(buf);

   496

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

   497

		buf[i] = 0;

   498

   499

		handle_string(buf, english);

   500

		_cur_line++;

   501

	}

   502

   503

	fclose(in);

   504

   505

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

   506

	if (english) {

   507

		uint32 hash = 0;

   508

		char *s;

   509

		const CmdStruct *cs;

   510

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

   511

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

   512

				hash ^= i * 0x717239;

   513

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

   514

				hash = my_hash_str(hash, s + 1);

   515

   516

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

   517

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

   518

					if ( (uint)cs >= 256) {

   519

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

   520

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

   521

					}

   522

				}

   523

			}

   524

		}

   525

		_hash = hash;