1

#define STRGEN

     2

     3

#include "../stdafx.h"

     4

#include <stdio.h>

     5

#include <string.h>

     6

#include <stdlib.h>

     7

#include <stdarg.h>

     8

     9

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

    10

#include <unistd.h>

    11

#endif

    12

    13

#ifdef __MORPHOS__

    14

#ifdef stderr

    15

#undef stderr

    16

#endif

    17

#define stderr stdout

    18

#endif // __MORPHOS__

    19

    20

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

    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

	byte plural_form;		// plural form index

    32

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

    33

} LanguagePackHeader;

    34

    35

typedef struct CmdStruct {

    36

	const char *cmd;

    37

	ParseCmdProc proc;

    38

	long value;

    39

	int8 consumes;

    40

	byte flags;

    41

} CmdStruct;

    42

    43

enum {

    44

	C_DONTCOUNT = 1,

    45

	C_CASE = 2,

    46

};

    47

    48

    49

typedef struct Case {

    50

	int caseidx;

    51

	char *string;

    52

	struct Case *next;

    53

} Case;

    54

    55

static int _cur_line;

    56

static int _errors, _warnings;

    57

    58

typedef struct LangString {

    59

	char *name;							// Name of the string

    60

	char *english;					// English text

    61

	char *translated;				// Translated text

    62

	uint16 hash_next;				// next hash entry

    63

	uint16 index;

    64

	Case *english_case;			// cases for english

    65

	Case *translated_case;	// cases for foreign

    66

} LangString;

    67

    68

static LangString *_strings[65536];

    69

    70

    71

#define HASH_SIZE 32767

    72

static uint16 _hash_head[HASH_SIZE];

    73

    74

static byte _put_buf[4096];

    75

static int _put_pos;

    76

static int _next_string_id;

    77

    78

static uint32 _hash;

    79

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

    80

static byte _lang_pluralform;

    81

#define MAX_NUM_GENDER 8

    82

static char _genders[MAX_NUM_GENDER][8];

    83

static int _numgenders;

    84

    85

// contains the name of all cases.

    86

#define MAX_NUM_CASES 50

    87

static char _cases[MAX_NUM_CASES][16];

    88

static int _numcases;

    89

    90

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

    91

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

    92

    93

static const char *_cur_ident;

    94

    95

typedef struct CmdPair {

    96

	const CmdStruct *a;

    97

	char *v;

    98

} CmdPair;

    99

   100

typedef struct ParsedCommandStruct {

   101

	int np;

   102

	CmdPair pairs[32];

   103

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

   104

} ParsedCommandStruct;

   105

   106

// Used when generating some advanced commands.

   107

static ParsedCommandStruct _cur_pcs;

   108

static int _cur_argidx;

   109

   110

static uint HashStr(const char *s)

   111

{

   112

	uint hash = 0;

   113

	for(; *s; s++)

   114

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

   115

	return hash % HASH_SIZE;

   116

}

   117

   118

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

   119

{

   120

	uint hash = HashStr(s);

   121

	ls->hash_next = _hash_head[hash];

   122

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

   123

}

   124

   125

static LangString *HashFind(const char *s)

   126

{

   127

	int idx = _hash_head[HashStr(s)];

   128

	while (--idx >= 0) {

   129

		LangString *ls = _strings[idx];

   130

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

   131

		idx = ls->hash_next;

   132

	}

   133

	return NULL;

   134

}

   135

   136

   137

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

   138

{

   139

	char buf[1024];

   140

	va_list va;

   141

	va_start(va, s);

   142

	vsprintf(buf, s, va);

   143

	va_end(va);

   144

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

   145

	_warnings++;

   146

}

   147

   148

   149

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

   150

{

   151

	char buf[1024];

   152

	va_list va;

   153

	va_start(va, s);

   154

	vsprintf(buf, s, va);

   155

	va_end(va);

   156

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

   157

	_errors++;

   158

}

   159

   160

   161

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

   162

{

   163

	char buf[1024];

   164

	va_list va;

   165

	va_start(va, s);

   166

	vsprintf(buf, s, va);

   167

	va_end(va);

   168

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

   169

	exit(1);

   170

}

   171

   172

   173

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

   174

{

   175

	assert(len > 0);

   176

	while (--len && *src)

   177

		*dst++=*src++;

   178

	*dst = 0;

   179

}

   180

   181

   182

static void PutByte(byte c)

   183

{

   184

	if (_put_pos == lengthof(_put_buf))

   185

		Fatal("Put buffer too small");

   186

	_put_buf[_put_pos++] = c;

   187

}

   188

   189

   190

static void EmitSingleByte(char *buf, int value)

   191

{

   192

	if (*buf != '\0')

   193

		Warning("Ignoring trailing letters in command");

   194

	PutByte((byte)value);

   195

}

   196

   197

   198

static void EmitEscapedByte(char *buf, int value)

   199

{

   200

	if (*buf != '\0')

   201

		Warning("Ignoring trailing letters in command");

   202

	PutByte((byte)0x85);

   203

	PutByte((byte)value);

   204

}

   205

   206

static void EmitSetX(char *buf, int value)

   207

{

   208

	char *err;

   209

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

   210

	if (*err != 0)

   211

		Fatal("SetX param invalid");

   212

	PutByte(1);

   213

	PutByte((byte)x);

   214

}

   215

   216

   217

static void EmitSetXY(char *buf, int value)

   218

{

   219

	char *err;

   220

	int x,y;

   221

   222

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

   223

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

   224

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

   225

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

   226

   227

	PutByte(2);

   228

	PutByte((byte)x);

   229

	PutByte((byte)y);

   230

}

   231

   232

// The plural specifier looks like

   233

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

   234

   235

// This is encoded like

   236

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

   237

   238

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

   239

{

   240

	char *s = *buf, *end;

   241

	bool rel = false;

   242

	int v;

   243

   244

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

   245

	if (*s == '+') { rel = true; s++; }

   246

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

   247

	if (end == s) return false;

   248

	if (rel || (v < 0))

   249

		*value += v;

   250

	else

   251

		*value = v;

   252

	*buf = end;

   253

	return true;

   254

}

   255

   256

// Parse out the next word, or NULL

   257

char *ParseWord(char **buf)

   258

{

   259

	char *s = *buf, *r;

   260

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

   261

	if (*s == 0)

   262

		return NULL;

   263

   264

	if (*s == '"') {

   265

		r = ++s;

   266

		// parse until next " or NUL

   267

		for(;;) {

   268

			if (*s == 0)

   269

				break;

   270

			if (*s == '"') {

   271

				*s++ = 0;

   272

				break;

   273

			}

   274

			s++;

   275

		}

   276

	} else {

   277

		// proceed until whitespace or NUL

   278

		r = s;

   279

		for(;;) {

   280

			if (*s == 0)

   281

				break;

   282

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

   283

				*s++ = 0;

   284

				break;

   285

			}

   286

			s++;

   287

		}

   288

	}

   289

	*buf = s;

   290

	return r;

   291

}

   292

   293

// Forward declaration

   294

static int TranslateArgumentIdx(int arg);

   295

   296

static void EmitWordList(char **words, int nw)

   297

{

   298

	int i,j;

   299

   300

	PutByte(nw);

   301

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

   302

		PutByte(strlen(words[i]));

   303

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

   304

		for(j=0; words[i][j]; j++)

   305

			PutByte(words[i][j]);

   306

	}

   307

}

   308

   309

static void EmitPlural(char *buf, int value)

   310

{

   311

	int argidx = _cur_argidx;

   312

	char *words[5];

   313

	int nw = 0;

   314

   315

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

   316

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

   317

		argidx--;

   318

   319

	// Parse each string

   320

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

   321

		words[nw] = ParseWord(&buf);

   322

		if (!words[nw])

   323

			break;

   324

	}

   325

   326

	if (nw == 0)

   327

		Fatal("No plural words");

   328

   329

	if (_plural_form_counts[_lang_pluralform] != nw)

   330

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

   331

			_plural_form_counts[_lang_pluralform], nw);

   332

   333

	PutByte(0x7D);

   334

	PutByte(TranslateArgumentIdx(argidx));

   335

	EmitWordList(words, nw);

   336

}

   337

   338

   339

static void EmitGender(char *buf, int value)

   340

{

   341

	int argidx = _cur_argidx;

   342

	char *words[8];

   343

	int nw;

   344

   345

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

   346

		buf++;

   347

   348

		// This is a {G=DER} command

   349

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

   350

			if (nw >= 8)

   351

				Fatal("G argument '%s' invalid", buf);

   352

			if (!strcmp(buf, _genders[nw]))

   353

				break;

   354

		}

   355

		// now nw contains the gender index

   356

		PutByte(0x87);

   357

		PutByte(nw);

   358

   359

	} else {

   360

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

   361

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

   362

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

   363

   364

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

   365

			words[nw] = ParseWord(&buf);

   366

			if (!words[nw])

   367

				break;

   368

		}

   369

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

   370

		PutByte(0x85);

   371

		PutByte(13);

   372

		PutByte(TranslateArgumentIdx(argidx));

   373

		EmitWordList(words, nw);

   374

	}

   375

}

   376

   377

   378

static const CmdStruct _cmd_structs[] = {

   379

	// Update position

   380

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

   381

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

   382

   383

	// Font size

   384

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

   385

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

   386

   387

	// New line

   388

	{"", EmitSingleByte, 10, 0, C_DONTCOUNT},

   389

   390

	// Colors

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

   409

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

   410

   411

	// Numbers

   412

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

   413

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

   414

   415

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

   416

   417

	// 0x85

   418

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

   419

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

   420

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

   421

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

   422

   423

	{"COMPANY", EmitEscapedByte, 5, 1},				// company string. This is actually a {STRING1}

   424

																						// The first string includes the second string.

   425

   426

	{"PLAYERNAME", EmitEscapedByte, 5, 1},		// playername string. This is actually a {STRING1}

   427

																						// The first string includes the second string.

   428

   429

	{"VEHICLE", EmitEscapedByte, 5, 1},		// playername string. This is actually a {STRING1}

   430

																						// The first string includes the second string.

   431

   432

   433

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

   434

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

   435

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

   436

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

   437

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

   438

   439

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

   440

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

   441

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

   442

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

   443

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

   444

   445

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

   446

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

   447

   448

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

   449

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

   450

   451

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

   452

   453

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

   454

   455

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

   456

   457

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

   458

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

   459

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

   460

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

   461

	// 0x9D is used for the pseudo command SETCASE

   462

	// 0x9E is used for case switching

   463

   464

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

   465

   466

	{"UPARROW", EmitSingleByte, 0xA0, 0},

   467

	{"POUNDSIGN", EmitSingleByte, 0xA3, 0},

   468

	{"YENSIGN", EmitSingleByte, 0xA5, 0},

   469

	{"COPYRIGHT", EmitSingleByte, 0xA9, 0},

   470

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

   471

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

   472

	{"CROSS", EmitSingleByte, 0xAD, 0},

   473

	{"RIGHTARROW", EmitSingleByte, 0xAF, 0},

   474

   475

	{"TRAIN", EmitSingleByte, 0xb4, 0},

   476

	{"LORRY", EmitSingleByte, 0xb5, 0},

   477

	{"BUS",   EmitSingleByte, 0xb6, 0},

   478

	{"PLANE", EmitSingleByte, 0xb7, 0},

   479

	{"SHIP",  EmitSingleByte, 0xb8, 0},

   480

   481

	{"SMALLUPARROW", EmitSingleByte, 0xBC, 0},

   482

	{"SMALLDOWNARROW", EmitSingleByte, 0xBD, 0},

   483

	{"THREE_FOURTH", EmitSingleByte, 0xBE, 0},

   484

};

   485

   486

   487

static const CmdStruct *FindCmd(const char *s, int len)

   488

{

   489

	int i;

   490

	const CmdStruct *cs = _cmd_structs;

   491

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

   492

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

   493

			return cs;