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

	uint16 offsets[32];	// the offsets

    30

} LanguagePackHeader;

    31

    32

typedef struct CmdStruct {

    33

	const char *cmd;

    34

	ParseCmdProc proc;

    35

	long value;

    36

} CmdStruct;

    37

    38

typedef struct LineName {

    39

	struct LineName *hash_next;

    40

	int value;

    41

	char str[1];

    42

} LineName;

    43

    44

int _cur_line;

    45

bool _warnings;

    46

    47

uint32 _hash;

    48

char _lang_name[32], _lang_ownname[32];

    49

    50

#define HASH_SIZE 1023

    51

LineName *_hash_head[HASH_SIZE];

    52

unsigned int hash_str(const char *s) {

    53

	unsigned int hash = 0;

    54

	for(;*s;s++)

    55

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

    56

	return hash % HASH_SIZE;

    57

}

    58

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

    59

	unsigned int len = strlen(s);

    60

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

    61

	unsigned int hash = hash_str(s);

    62

	ln->hash_next = _hash_head[hash];

    63

	_hash_head[hash] = ln;

    64

	ln->value = value;

    65

	ln->str[len] = 0;

    66

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

    67

}

    68

    69

int hash_find(const char *s) {

    70

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

    71

	while (ln != NULL) {

    72

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

    73

			return ln->value;

    74

		}

    75

		ln = ln->hash_next;

    76

	}

    77

	return -1;

    78

}

    79

    80

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

    81

	char buf[1024];

    82

	va_list va;

    83

	va_start(va, s);

    84

	vsprintf(buf, s, va);

    85

	va_end(va);

    86

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

    87

	_warnings = true;

    88

}

    89

    90

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

    91

	char buf[1024];

    92

	va_list va;

    93

	va_start(va, s);

    94

	vsprintf(buf, s, va);

    95

	va_end(va);

    96

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

    97

	exit(1);

    98

}

    99

   100

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

   101

{

   102

	assert(len > 0);

   103

	while (--len && *src)

   104

		*dst++=*src++;

   105

	*dst = 0;

   106

}

   107

   108

   109

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

   110

// second part is the name of the string

   111

// third part is the actual string contents

   112

char *allstr[65536];

   113

   114

byte _put_buf[4096];

   115

int _put_pos;

   116

int _next_string_id;

   117

   118

void put_byte(byte c) {

   119

	if (_put_pos == lengthof(_put_buf))

   120

		error("Put buffer too small");

   121

	_put_buf[_put_pos++] = c;

   122

}

   123

   124

void emit_buf(int ent) {

   125

	char *s;

   126

   127

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

   128

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

   129

		return;

   130

	}

   131

   132

	if (allstr[ent] != 0) {

   133

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

   134

		return;

   135

	}

   136

   137

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

   138

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

   139

	*((uint16*)s) = _put_pos;

   140

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

   141

   142

	allstr[ent] = s;

   143

   144

	_put_pos = 0;

   145

}

   146

   147

void EmitSingleByte(char *buf, int value) {

   148

	if (*buf != 0)

   149

		warning("Ignoring trailing letters in command");

   150

	put_byte((byte)value);

   151

}

   152

   153

void EmitEscapedByte(char *buf, int value) {

   154

	if (*buf != 0)

   155

		warning("Ignoring trailing letters in command");

   156

	put_byte((byte)0x85);

   157

	put_byte((byte)value);

   158

}

   159

   160

   161

void EmitStringInl(char *buf, int value) {

   162

	int id;

   163

   164

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

   165

		id = strtol(buf, NULL, 0);

   166

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

   167

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

   168

			return;

   169

		}

   170

	} else {

   171

		id = hash_find(buf);

   172

		if (id == -1) {

   173

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

   174

			return;

   175

		}

   176

	}

   177

   178

	put_byte(0x81);

   179

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

   180

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

   181

}

   182

   183

void EmitSetX(char *buf, int value) {

   184

	char *err;

   185

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

   186

	if (*err != 0)

   187

		error("SetX param invalid");

   188

	put_byte(1);

   189

	put_byte((byte)x);

   190

}

   191

   192

void EmitSetXY(char *buf, int value) {

   193

	char *err;

   194

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

   195

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

   196

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

   197

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

   198

   199

	put_byte(0x1F);

   200

	put_byte((byte)x);

   201

	put_byte((byte)y);

   202

}

   203

   204

static const CmdStruct _cmd_structs[] = {

   205

	// Update position

   206

	{"SETX", EmitSetX, 1},

   207

	{"SETXY", EmitSetXY, 2},

   208

   209

	// Font size

   210

	{"TINYFONT", EmitSingleByte, 8},

   211

	{"BIGFONT", EmitSingleByte, 9},

   212

   213

	// New line

   214

	{"", EmitSingleByte, 10},

   215

   216

	// Colors

   217

	{"BLUE", EmitSingleByte, 15},

   218

	{"SILVER", EmitSingleByte, 16},

   219

	{"GOLD", EmitSingleByte, 17},

   220

	{"RED", EmitSingleByte, 18},

   221

	{"PURPLE", EmitSingleByte, 19},

   222

	{"LTBROWN", EmitSingleByte, 20},

   223

	{"ORANGE", EmitSingleByte, 21},

   224

	{"GREEN", EmitSingleByte, 22},

   225

	{"YELLOW", EmitSingleByte, 23},

   226

	{"DKGREEN", EmitSingleByte, 24},

   227

	{"CREAM", EmitSingleByte, 25},

   228

	{"BROWN", EmitSingleByte, 26},

   229

	{"WHITE", EmitSingleByte, 27},

   230

	{"LTBLUE", EmitSingleByte, 28},

   231

	{"GRAY", EmitSingleByte, 29},

   232

	{"DKBLUE", EmitSingleByte, 30},

   233

	{"BLACK", EmitSingleByte, 31},

   234

   235

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

   236

   237

	// Numbers

   238

	{"COMMA32", EmitSingleByte, 0x7B},

   239

	{"COMMA16", EmitSingleByte, 0x7C},

   240

	{"COMMA8", EmitSingleByte, 0x7D},

   241

	{"NUMU16", EmitSingleByte, 0x7E},

   242

   243

	{"CURRENCY", EmitSingleByte, 0x7F},

   244

   245

	// 0x85

   246

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

   247

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

   248

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

   249

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

   250

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

   251

   252

	{"STRINL", EmitStringInl, 0x81},

   253

   254

	{"DATE_LONG", EmitSingleByte, 0x82},

   255

	{"DATE_SHORT", EmitSingleByte, 0x83},

   256

   257

	{"VELOCITY", EmitSingleByte, 0x84},

   258

	{"SKIP16", EmitSingleByte, 0x85},

   259

	{"SKIP", EmitSingleByte, 0x86},

   260

	{"VOLUME", EmitSingleByte, 0x87},

   261

   262

	{"STRING", EmitSingleByte, 0x88},

   263

   264

	{"CARGO", EmitSingleByte, 0x99},

   265

	{"STATION", EmitSingleByte, 0x9A},

   266

	{"TOWN", EmitSingleByte, 0x9B},

   267

	{"CURRENCY64", EmitSingleByte, 0x9C},

   268

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

   269

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

   270

   271

	{"UPARROW", EmitSingleByte, 0xA0},

   272

	{"POUNDSIGN", EmitSingleByte, 0xA3},

   273

	{"YENSIGN", EmitSingleByte, 0xA5},

   274

	{"COPYRIGHT", EmitSingleByte, 0xA9},

   275

	{"DOWNARROW", EmitSingleByte, 0xAA},

   276

	{"CHECKMARK", EmitSingleByte, 0xAC},

   277

	{"CROSS", EmitSingleByte, 0xAD},

   278

	{"RIGHTARROW", EmitSingleByte, 0xAF},

   279

   280

	{"TRAIN", EmitSingleByte, 0xb4},

   281

	{"LORRY", EmitSingleByte, 0xb5},

   282

	{"BUS",   EmitSingleByte, 0xb6},

   283

	{"PLANE", EmitSingleByte, 0xb7},

   284

	{"SHIP",  EmitSingleByte, 0xb8},

   285

   286

	{"SMALLUPARROW", EmitSingleByte, 0xBC},

   287

	{"SMALLDOWNARROW", EmitSingleByte, 0xBD},

   288

	{"THREE_FOURTH", EmitSingleByte, 0xBE},

   289

};

   290

   291

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

   292

	int i;

   293

	const CmdStruct *cs = _cmd_structs;

   294

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

   295

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

   296

			return cs;

   297

	}

   298

	return NULL;

   299

}

   300

   301

   302

// returns 0 on EOL

   303

// returns 1-255 on literal byte

   304

// else returns command struct

   305

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

   306

{

   307

	char *s = *str, *start;

   308

	byte c = *s++;

   309

	const CmdStruct *cmd;

   310

   311

	if (c != '{') {

   312

		*str = s;

   313

		return (CmdStruct*) (int)c;

   314

	}

   315

   316

	// parse command name

   317

	start = s;

   318

	for(;;) {

   319

		c = *s++;

   320

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

   321

			break;

   322

		if (c == 0) {

   323

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

   324

			return NULL;

   325

		}

   326

	}

   327

   328

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

   329

	if (cmd == NULL) {

   330

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

   331

		return NULL;

   332

	}

   333

   334

	if (c == ' ') {

   335

		// copy params

   336

		start = s;

   337

		for(;;) {

   338

			c = *s++;

   339

			if (c == '}') break;

   340

			if (c == 0) {

   341

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

   342

				return NULL;

   343

			}

   344

			*param++ = c;

   345

		}

   346

   347

	}

   348

	*param = 0;

   349

   350

	*str = s;

   351

   352

	return cmd;

   353

}

   354

   355

   356

void handle_pragma(char *str)

   357

{

   358

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

   359

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

   360

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

   361

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

   362

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

   363

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

   364

	} else {

   365

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

   366

	}

   367

}

   368

   369

bool check_commands_match(char *a, char *b)

   370

{

   371

	const CmdStruct *ar, *br;

   372

	char param[100];

   373

   374

	do {

   375

		// read until next command from a.

   376

		do {

   377

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

   378

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

   379

   380

		// read until next command from b.

   381

		do {

   382

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

   383

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

   384

   385

		// make sure they are identical

   386

		if (ar != br) return false;

   387

	} while (ar);

   388

   389

	return true;

   390

}

   391

   392

void handle_string(char *str, bool master) {

   393

	char *s,*t,*r;

   394

	int ent;

   395

   396

	if (*str == '#') {

   397

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

   398

			handle_pragma(str + 2);

   399

		return;

   400

	}

   401

   402

	// Ignore comments & blank lines

   403

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

   404

		return;

   405

   406

	s = strchr(str, ':');

   407

	if (s == NULL) {

   408

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

   409

		return;

   410

	}

   411

   412

	// Trim spaces

   413

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

   414

	*t = 0;

   415

   416

	ent = hash_find(str);

   417

   418

	s++; // skip :

   419

   420

	// allocate string entry

   421

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

   422

	*r = master;

   423

	strcpy(r + 1, str);

   424

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

   425

   426

	if (master) {

   427

		if (ent != -1) {

   428

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

   429

			return;

   430

		}

   431

   432

		ent = _next_string_id++;

   433

		if (allstr[ent]) {

   434

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

   435

			return;

   436

		}

   437

		allstr[ent] = r;

   438

   439

		// add to hash table

   440

		hash_add(str, ent);

   441

	} else {

   442

		if (ent == -1) {

   443

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

   444

			_warnings = 0; // non-fatal

   445

			return;

   446

		}

   447

   448

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

   449

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

   450

			_warnings = 0; // non-fatal

   451

			return;

   452

		}

   453

   454

		// check that the commands match

   455

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

   456

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

   457

			_warnings = 0; // non-fatal

   458

			return;

   459

		}

   460

   461

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

   462

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

   463

			free(r);

   464

		} else {

   465

			free(allstr[ent]);

   466

			allstr[ent] = r;

   467

		}

   468

	}

   469

}

   470

   471

uint32 my_hash_str(uint32 hash, const char *s)

   472

{

   473

	for(;*s;s++) {

   474

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

   475

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

   476

	}

   477

	return hash;

   478

   479

}

   480

   481

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

   482

	char buf[2048];

   483

	int i;

   484

	FILE *in;

   485

   486

	in = fopen(file, "r");

   487

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

   488

   489

	_cur_line = 1;

   490

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

   491

		i = strlen(buf);

   492

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

   493

		buf[i] = 0;

   494

   495

		handle_string(buf, english);

   496

		_cur_line++;

   497

	}

   498

   499

	fclose(in);

   500

   501

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

   502

	if (english) {

   503

		uint32 hash = 0;

   504

		char *s;

   505

		const CmdStruct *cs;

   506

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

   507

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

   508

				hash ^= i * 0x717239;

   509

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

   510

				hash = my_hash_str(hash, s + 1);

   511

   512

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

   513

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

   514

					if ( (uint)cs >= 256) {

   515

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

   516

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

   517

					}

   518

				}

   519

			}

   520

		}

   521

		_hash = hash;

   522

	}

   523

}

   524

   525

int count_inuse(int grp) {

   526

	int i;