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

	{"DATE_TINY", EmitSingleByte, 0x9E},

   270

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

   271

   272

	{"UPARROW", EmitSingleByte, 0xA0},

   273

	{"POUNDSIGN", EmitSingleByte, 0xA3},

   274

	{"YENSIGN", EmitSingleByte, 0xA5},

   275

	{"COPYRIGHT", EmitSingleByte, 0xA9},

   276

	{"DOWNARROW", EmitSingleByte, 0xAA},

   277

	{"CHECKMARK", EmitSingleByte, 0xAC},

   278

	{"CROSS", EmitSingleByte, 0xAD},

   279

	{"RIGHTARROW", EmitSingleByte, 0xAF},

   280

   281

	{"TRAIN", EmitSingleByte, 0xb4},

   282

	{"LORRY", EmitSingleByte, 0xb5},

   283

	{"BUS",   EmitSingleByte, 0xb6},

   284

	{"PLANE", EmitSingleByte, 0xb7},

   285

	{"SHIP",  EmitSingleByte, 0xb8},

   286

   287

	{"SMALLUPARROW", EmitSingleByte, 0xBC},

   288

	{"SMALLDOWNARROW", EmitSingleByte, 0xBD},

   289

	{"THREE_FOURTH", EmitSingleByte, 0xBE},

   290

};

   291

   292

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

   293

	int i;

   294

	const CmdStruct *cs = _cmd_structs;

   295

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

   296

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

   297

			return cs;

   298

	}

   299

	return NULL;

   300

}

   301

   302

   303

// returns 0 on EOL

   304

// returns 1-255 on literal byte

   305

// else returns command struct

   306

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

   307

{

   308

	char *s = *str, *start;

   309

	byte c = *s++;

   310

	const CmdStruct *cmd;

   311

   312

	if (c != '{') {

   313

		*str = s;

   314

		return (CmdStruct*) (int)c;

   315

	}

   316

   317

	// parse command name

   318

	start = s;

   319

	for(;;) {

   320

		c = *s++;

   321

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

   322

			break;

   323

		if (c == 0) {

   324

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

   325

			return NULL;

   326

		}

   327

	}

   328

   329

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

   330

	if (cmd == NULL) {

   331

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

   332

		return NULL;

   333

	}

   334

   335

	if (c == ' ') {

   336

		// copy params

   337

		start = s;

   338

		for(;;) {

   339

			c = *s++;

   340

			if (c == '}') break;

   341

			if (c == 0) {

   342

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

   343

				return NULL;

   344

			}

   345

			*param++ = c;

   346

		}

   347

   348

	}

   349

	*param = 0;

   350

   351

	*str = s;

   352

   353

	return cmd;

   354

}

   355

   356

   357

void handle_pragma(char *str)

   358

{

   359

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

   360

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

   361

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

   362

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

   363

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

   364

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

   365

	} else {

   366

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

   367

	}

   368

}

   369

   370

bool check_commands_match(char *a, char *b)

   371

{

   372

	const CmdStruct *ar, *br;

   373

	char param[100];

   374

   375

	do {

   376

		// read until next command from a.

   377

		do {

   378

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

   379

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

   380

   381

		// read until next command from b.

   382

		do {

   383

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

   384

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

   385

   386

		// make sure they are identical

   387

		if (ar != br) return false;

   388

	} while (ar);

   389

   390

	return true;

   391

}

   392

   393

void handle_string(char *str, bool master) {

   394

	char *s,*t,*r;

   395

	int ent;

   396

   397

	if (*str == '#') {

   398

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

   399

			handle_pragma(str + 2);

   400

		return;

   401

	}

   402

   403

	// Ignore comments & blank lines

   404

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

   405

		return;

   406

   407

	s = strchr(str, ':');

   408

	if (s == NULL) {

   409

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

   410

		return;

   411

	}

   412

   413

	// Trim spaces

   414

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

   415

	*t = 0;

   416

   417

	ent = hash_find(str);

   418

   419

	s++; // skip :

   420

   421

	// allocate string entry

   422

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

   423

	*r = master;

   424

	strcpy(r + 1, str);

   425

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

   426

   427

	if (master) {

   428

		if (ent != -1) {

   429

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

   430

			return;

   431

		}

   432

   433

		ent = _next_string_id++;

   434

		if (allstr[ent]) {

   435

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

   436

			return;

   437

		}

   438

		allstr[ent] = r;

   439

   440

		// add to hash table

   441

		hash_add(str, ent);

   442

	} else {

   443

		if (ent == -1) {

   444

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

   445

			_warnings = 0; // non-fatal

   446

			return;

   447

		}

   448

   449

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

   450

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

   451

			_warnings = 0; // non-fatal

   452

			return;

   453

		}

   454

   455

		// check that the commands match

   456

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

   457

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

   458

			_warnings = 0; // non-fatal

   459

			return;

   460

		}

   461

   462

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

   463

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

   464

			free(r);

   465

		} else {

   466

			free(allstr[ent]);

   467

			allstr[ent] = r;

   468

		}

   469

	}

   470

}

   471

   472

uint32 my_hash_str(uint32 hash, const char *s)

   473

{

   474

	for(;*s;s++) {

   475

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

   476

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

   477

	}

   478

	return hash;

   479

   480

}

   481

   482

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

   483

	char buf[2048];

   484

	int i;

   485

	FILE *in;

   486

   487

	in = fopen(file, "r");

   488

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

   489

   490

	_cur_line = 1;

   491

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

   492

		i = strlen(buf);

   493

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

   494

		buf[i] = 0;

   495

   496

		handle_string(buf, english);

   497

		_cur_line++;

   498

	}

   499

   500

	fclose(in);

   501

   502

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

   503

	if (english) {

   504

		uint32 hash = 0;

   505

		char *s;

   506

		const CmdStruct *cs;

   507

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

   508

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

   509

				hash ^= i * 0x717239;

   510

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

   511

				hash = my_hash_str(hash, s + 1);

   512

   513

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

   514

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

   515

					if ( (uint)cs >= 256) {

   516

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

   517

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

   518

					}

   519

				}

   520

			}

   521

		}

   522

		_hash = hash;

   523

	}

   524

}

   525

   526

int count_inuse(int grp) {