1

/* $Id$ */

     2

     3

#define STRGEN

     4

     5

#include "../stdafx.h"

     6

#include "../macros.h"

     7

#include <stdio.h>

     8

#include <string.h>

     9

#include <stdlib.h>

    10

#include <stdarg.h>

    11

    12

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

    13

#include <unistd.h>

    14

#endif

    15

    16

#ifdef __MORPHOS__

    17

#ifdef stderr

    18

#undef stderr

    19

#endif

    20

#define stderr stdout

    21

#endif // __MORPHOS__

    22

    23

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

    24

    25

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

    26

    27

typedef struct LanguagePackHeader {

    28

	uint32 ident;

    29

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

    30

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

    31

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

    32

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

    33

	uint16 offsets[32];	// the offsets

    34

	byte plural_form;		// plural form index

    35

	byte pad[3];				// pad header to be a multiple of 4

    36

} LanguagePackHeader;

    37

    38

typedef struct CmdStruct {

    39

	const char *cmd;

    40

	ParseCmdProc proc;

    41

	long value;

    42

	int8 consumes;

    43

	byte flags;

    44

} CmdStruct;

    45

    46

enum {

    47

	C_DONTCOUNT = 1,

    48

	C_CASE = 2,

    49

};

    50

    51

    52

typedef struct Case {

    53

	int caseidx;

    54

	char *string;

    55

	struct Case *next;

    56

} Case;

    57

    58

static bool _masterlang;

    59

static bool _translated;

    60

static const char* _file = "(unknown file)";

    61

static int _cur_line;

    62

static int _errors, _warnings;

    63

    64

typedef struct LangString {

    65

	char *name;							// Name of the string

    66

	char *english;					// English text

    67

	char *translated;				// Translated text

    68

	uint16 hash_next;				// next hash entry

    69

	uint16 index;

    70

	int line;               // line of string in source-file

    71

	Case *english_case;			// cases for english

    72

	Case *translated_case;	// cases for foreign

    73

} LangString;

    74

    75

static LangString *_strings[65536];

    76

    77

    78

#define HASH_SIZE 32767

    79

static uint16 _hash_head[HASH_SIZE];

    80

    81

static byte _put_buf[4096];

    82

static int _put_pos;

    83

static int _next_string_id;

    84

    85

static uint32 _hash;

    86

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

    87

static byte _lang_pluralform;

    88

#define MAX_NUM_GENDER 8

    89

static char _genders[MAX_NUM_GENDER][8];

    90

static int _numgenders;

    91

    92

// contains the name of all cases.

    93

#define MAX_NUM_CASES 50

    94

static char _cases[MAX_NUM_CASES][16];

    95

static int _numcases;

    96

    97

// for each plural value, this is the number of plural forms.

    98

static const byte _plural_form_counts[] = { 2,1,2,3,3,3,3,3,4 };

    99

   100

static const char *_cur_ident;

   101

   102

typedef struct CmdPair {

   103

	const CmdStruct *a;

   104

	char *v;

   105

} CmdPair;

   106

   107

typedef struct ParsedCommandStruct {

   108

	int np;

   109

	CmdPair pairs[32];

   110

	const CmdStruct *cmd[32]; // ordered by param #

   111

} ParsedCommandStruct;

   112

   113

// Used when generating some advanced commands.

   114

static ParsedCommandStruct _cur_pcs;

   115

static int _cur_argidx;

   116

   117

static uint HashStr(const char *s)

   118

{

   119

	uint hash = 0;

   120

	for (; *s != '\0'; s++) hash = ROL(hash, 3) ^ *s;

   121

	return hash % HASH_SIZE;

   122

}

   123

   124

static void HashAdd(const char *s, LangString *ls)

   125

{

   126

	uint hash = HashStr(s);

   127

	ls->hash_next = _hash_head[hash];

   128

	_hash_head[hash] = ls->index + 1;

   129

}

   130

   131

static LangString *HashFind(const char *s)

   132

{

   133

	int idx = _hash_head[HashStr(s)];

   134

   135

	while (--idx >= 0) {

   136

		LangString* ls = _strings[idx];

   137

   138

		if (strcmp(ls->name, s) == 0) return ls;

   139

		idx = ls->hash_next;

   140

	}

   141

	return NULL;

   142

}

   143

   144

   145

static void CDECL Warning(const char *s, ...)

   146

{

   147

	char buf[1024];

   148

	va_list va;

   149

	va_start(va, s);

   150

	vsprintf(buf, s, va);

   151

	va_end(va);

   152

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

   153

	_warnings++;

   154

}

   155

   156

   157

static void CDECL Error(const char *s, ...)

   158

{

   159

	char buf[1024];

   160

	va_list va;

   161

	va_start(va, s);

   162

	vsprintf(buf, s, va);

   163

	va_end(va);

   164

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

   165

	_errors++;

   166

}

   167

   168

   169

static void NORETURN CDECL Fatal(const char *s, ...)

   170

{

   171

	char buf[1024];

   172

	va_list va;

   173

	va_start(va, s);

   174

	vsprintf(buf, s, va);

   175

	va_end(va);

   176

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

   177

	exit(1);

   178

}

   179

   180

   181

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

   182

{

   183

	assert(len > 0);

   184

	while (--len > 0 && *src != '\0') *dst++ = *src++;

   185

	*dst = '\0';

   186

}

   187

   188

   189

static void PutByte(byte c)

   190

{

   191

	if (_put_pos == lengthof(_put_buf)) Fatal("Put buffer too small");

   192

	_put_buf[_put_pos++] = c;

   193

}

   194

   195

   196

static void EmitSingleByte(char *buf, int value)

   197

{

   198

	if (*buf != '\0') Warning("Ignoring trailing letters in command");

   199

	PutByte((byte)value);

   200

}

   201

   202

   203

static void EmitEscapedByte(char *buf, int value)

   204

{

   205

	if (*buf != '\0') Warning("Ignoring trailing letters in command");

   206

	PutByte(0x85);

   207

	PutByte((byte)value);

   208

}

   209

   210

static void EmitSetX(char *buf, int value)

   211

{

   212

	char *err;

   213

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

   214

	if (*err != 0) Fatal("SetX param invalid");

   215

	PutByte(1);

   216

	PutByte((byte)x);

   217

}

   218

   219

   220

static void EmitSetXY(char *buf, int value)

   221

{

   222

	char *err;

   223

	int x;

   224

	int y;

   225

   226

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

   227

	if (*err != ' ') Fatal("SetXY param invalid");

   228

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

   229

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

   230

   231

	PutByte(2);

   232

	PutByte((byte)x);

   233

	PutByte((byte)y);

   234

}

   235

   236

// The plural specifier looks like

   237

// {NUM} {PLURAL -1 passenger passengers} then it picks either passenger/passengers depending on the count in NUM

   238

   239

// This is encoded like

   240

//  CommandByte <ARG#> <NUM> {Length of each string} {each string}

   241

   242

bool ParseRelNum(char **buf, int *value)

   243

{

   244

	const char* s = *buf;

   245

	char* end;

   246

	bool rel = false;

   247

	int v;

   248

   249

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

   250

	if (*s == '+') {

   251

		rel = true;

   252

		s++;

   253

	}

   254

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

   255

	if (end == s) return false;

   256

	if (rel || v < 0) {

   257

		*value += v;

   258

	} else {

   259

		*value = v;

   260

	}

   261

	*buf = end;

   262

	return true;

   263

}

   264

   265

// Parse out the next word, or NULL

   266

char *ParseWord(char **buf)

   267

{

   268

	char *s = *buf, *r;

   269

   270

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

   271

	if (*s == '\0') return NULL;

   272

   273

	if (*s == '"') {

   274

		r = ++s;

   275

		// parse until next " or NUL

   276

		for (;;) {

   277

			if (*s == '\0') break;

   278

			if (*s == '"') {

   279

				*s++ = '\0';

   280

				break;

   281

			}

   282

			s++;

   283

		}

   284

	} else {

   285

		// proceed until whitespace or NUL

   286

		r = s;

   287

		for (;;) {

   288

			if (*s == '\0') break;

   289

			if (*s == ' ' || *s == '\t') {

   290

				*s++ = '\0';

   291

				break;

   292

			}

   293

			s++;

   294

		}

   295

	}

   296

	*buf = s;

   297

	return r;

   298

}

   299

   300

// Forward declaration

   301

static int TranslateArgumentIdx(int arg);

   302

   303

static void EmitWordList(const char* const* words, uint nw)

   304

{

   305

	uint i;

   306

	uint j;

   307

   308

	PutByte(nw);

   309

	for (i = 0; i < nw; i++) PutByte(strlen(words[i]));

   310

	for (i = 0; i < nw; i++) {

   311

		for (j = 0; words[i][j] != '\0'; j++) PutByte(words[i][j]);

   312

	}

   313

}

   314

   315

static void EmitPlural(char *buf, int value)

   316

{

   317

	int argidx = _cur_argidx;

   318

	const char* words[5];

   319

	int nw = 0;

   320

   321

	// Parse out the number, if one exists. Otherwise default to prev arg.

   322

	if (!ParseRelNum(&buf, &argidx)) argidx--;

   323

   324

	// Parse each string

   325

	for (nw = 0; nw < 5; nw++) {

   326

		words[nw] = ParseWord(&buf);

   327

		if (words[nw] == NULL) break;

   328

	}

   329

   330

	if (nw == 0)

   331

		Fatal("%s: No plural words", _cur_ident);

   332

   333

	if (_plural_form_counts[_lang_pluralform] != nw) {

   334

		if (_translated) {

   335

			Fatal("%s: Invalid number of plural forms. Expecting %d, found %d.", _cur_ident,

   336

				_plural_form_counts[_lang_pluralform], nw);

   337

		} else {

   338

			Warning("'%s' is untranslated. Tweaking english string to allow compilation for plural forms", _cur_ident);

   339

			if (nw > _plural_form_counts[_lang_pluralform]) {

   340

				nw = _plural_form_counts[_lang_pluralform];

   341

			} else {

   342

				for (; nw < _plural_form_counts[_lang_pluralform]; nw++) {

   343

					words[nw] = words[nw - 1];

   344

				}

   345

			}

   346

		}

   347

	}

   348

   349

	PutByte(0x8D);

   350

	PutByte(TranslateArgumentIdx(argidx));

   351

	EmitWordList(words, nw);

   352

}

   353

   354

   355

static void EmitGender(char *buf, int value)

   356

{

   357

	int argidx = _cur_argidx;

   358

	uint nw;

   359

   360

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

   361

		buf++;

   362

   363

		// This is a {G=DER} command

   364

		for (nw = 0; ; nw++) {

   365

			if (nw >= 8) Fatal("G argument '%s' invalid", buf);

   366

			if (strcmp(buf, _genders[nw]) == 0) break;

   367

		}

   368

		// now nw contains the gender index

   369

		PutByte(0x87);

   370

		PutByte(nw);

   371

	} else {

   372

		const char* words[8];

   373

   374

		// This is a {G 0 foo bar two} command.

   375

		// If no relative number exists, default to +0

   376

		if (!ParseRelNum(&buf, &argidx)) {}

   377

   378

		for (nw = 0; nw < 8; nw++) {

   379

			words[nw] = ParseWord(&buf);

   380

			if (words[nw] == NULL) break;

   381

		}

   382

		if (nw != _numgenders) Fatal("Bad # of arguments for gender command");

   383

		PutByte(0x85);

   384

		PutByte(13);

   385

		PutByte(TranslateArgumentIdx(argidx));

   386

		EmitWordList(words, nw);

   387

	}

   388

}

   389

   390

   391

static const CmdStruct _cmd_structs[] = {

   392

	// Update position

   393

	{"SETX",  EmitSetX,  1, 0, 0},

   394

	{"SETXY", EmitSetXY, 2, 0, 0},

   395

   396

	// Font size

   397

	{"TINYFONT", EmitSingleByte, 8, 0, 0},

   398

	{"BIGFONT",  EmitSingleByte, 9, 0, 0},

   399

   400

	// Colors

   401

	{"BLUE",    EmitSingleByte, 15, 0, 0},

   402

	{"SILVER",  EmitSingleByte, 16, 0, 0},

   403

	{"GOLD",    EmitSingleByte, 17, 0, 0},

   404

	{"RED",     EmitSingleByte, 18, 0, 0},

   405

	{"PURPLE",  EmitSingleByte, 19, 0, 0},

   406

	{"LTBROWN", EmitSingleByte, 20, 0, 0},

   407

	{"ORANGE",  EmitSingleByte, 21, 0, 0},

   408

	{"GREEN",   EmitSingleByte, 22, 0, 0},

   409

	{"YELLOW",  EmitSingleByte, 23, 0, 0},

   410

	{"DKGREEN", EmitSingleByte, 24, 0, 0},

   411

	{"CREAM",   EmitSingleByte, 25, 0, 0},

   412

	{"BROWN",   EmitSingleByte, 26, 0, 0},

   413

	{"WHITE",   EmitSingleByte, 27, 0, 0},

   414

	{"LTBLUE",  EmitSingleByte, 28, 0, 0},

   415

	{"GRAY",    EmitSingleByte, 29, 0, 0},

   416

	{"DKBLUE",  EmitSingleByte, 30, 0, 0},

   417

	{"BLACK",   EmitSingleByte, 31, 0, 0},

   418

   419

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

   420

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

   421

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

   422

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

   423

   424

	// These are special versions of {STRING1}

   425

	// The first string includes the second string.

   426

	{"COMPANY",    EmitEscapedByte, 5, 1, 0},

   427

	{"PLAYERNAME", EmitEscapedByte, 5, 1, 0},

   428

	{"VEHICLE",    EmitEscapedByte, 5, 1, 0},

   429

   430

	{"STRING1", EmitEscapedByte, 5, 1, C_CASE}, // included string that consumes ONE argument

   431

	{"STRING2", EmitEscapedByte, 6, 2, C_CASE}, // included string that consumes TWO arguments

   432

	{"STRING3", EmitEscapedByte, 7, 3, C_CASE}, // included string that consumes THREE arguments

   433

	{"STRING4", EmitEscapedByte, 8, 4, C_CASE}, // included string that consumes FOUR arguments

   434

	{"STRING5", EmitEscapedByte, 9, 5, C_CASE}, // included string that consumes FIVE arguments

   435

   436

	{"STATIONFEATURES", EmitEscapedByte, 10, 1, 0}, // station features string, icons of the features

   437

	{"INDUSTRY",        EmitEscapedByte, 11, 1, 0}, // industry, takes an industry #

   438

	{"VOLUME",          EmitEscapedByte, 12, 1, 0},

   439

	{"DATE_TINY",       EmitEscapedByte, 14, 1, 0},

   440

	{"CARGO",           EmitEscapedByte, 15, 2, 0},

   441

   442

	{"P", EmitPlural, 0, 0, C_DONTCOUNT},					// plural specifier

   443

	{"G", EmitGender, 0, 0, C_DONTCOUNT},					// gender specifier

   444

   445

	{"DATE_LONG",  EmitSingleByte, 0x82, 1, 0},

   446

	{"DATE_SHORT", EmitSingleByte, 0x83, 1, 0},

   447

   448

	{"VELOCITY", EmitSingleByte, 0x84, 1, 0},

   449

   450

	// 0x85 is the marker for escaped commands

   451

   452

	{"SKIP", EmitSingleByte, 0x86, 1, 0},

   453

   454

	{"STRING", EmitSingleByte, 0x88, 1, C_CASE},

   455

   456

	// Numbers

   457

	{"COMMA", EmitSingleByte, 0x8B, 1, 0}, // Number with comma

   458

	{"NUM",   EmitSingleByte, 0x8E, 1, 0}, // Signed number

   459

   460

	{"CURRENCY",   EmitSingleByte, 0x8F, 1, 0},

   461

	{"CURRENCY64", EmitSingleByte, 0x9C, 2, 0},

   462

   463

	{"WAYPOINT", EmitSingleByte, 0x99, 1, 0}, // waypoint name

   464

	{"STATION",  EmitSingleByte, 0x9A, 1, 0},

   465

	{"TOWN",     EmitSingleByte, 0x9B, 1, 0},

   466

   467

	// 0x9D is used for the pseudo command SETCASE

   468

	// 0x9E is used for case switching

   469

   470

	{"",               EmitSingleByte, '\n', 0, C_DONTCOUNT},

   471

	{"{",              EmitSingleByte, '{',  0, C_DONTCOUNT},

   472

	{"UPARROW",        EmitSingleByte, 0x80, 0, 0},

   473

	{"SMALLUPARROW",   EmitSingleByte, 0x90, 0, 0},

   474

	{"SMALLDOWNARROW", EmitSingleByte, 0x91, 0, 0},

   475

	{"TRAIN",          EmitSingleByte, 0x94, 0, 0},

   476

	{"LORRY",          EmitSingleByte, 0x95, 0, 0},

   477

	{"BUS",            EmitSingleByte, 0x96, 0, 0},

   478

	{"PLANE",          EmitSingleByte, 0x97, 0, 0},

   479

	{"SHIP",           EmitSingleByte, 0x98, 0, 0},

   480

	{"NBSP",           EmitSingleByte, 0xA0, 0, C_DONTCOUNT},

   481

	{"CENT",           EmitSingleByte, '¢',  0, C_DONTCOUNT},

   482

	{"POUNDSIGN",      EmitSingleByte, '£',  0, C_DONTCOUNT},

   483

	{"EURO",           EmitSingleByte, '¤',  0, C_DONTCOUNT},

   484

	{"YENSIGN",        EmitSingleByte, '¥',  0, C_DONTCOUNT},

   485

	{"COPYRIGHT",      EmitSingleByte, '©',  0, C_DONTCOUNT},

   486

	{"DOWNARROW",      EmitSingleByte, 0xAA, 0, C_DONTCOUNT},

   487

	{"CHECKMARK",      EmitSingleByte, 0xAC, 0, C_DONTCOUNT},

   488