1

/* $Id$ */

     2

     3

#define STRGEN

     4

     5

#include "../stdafx.h"

     6

#include <stdio.h>

     7

#include <string.h>

     8

#include <stdlib.h>

     9

#include <stdarg.h>

    10

    11

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

    12

#include <unistd.h>

    13

#endif

    14

    15

#ifdef __MORPHOS__

    16

#ifdef stderr

    17

#undef stderr

    18

#endif

    19

#define stderr stdout

    20

#endif // __MORPHOS__

    21

    22

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

    23

    24

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

    25

    26

typedef struct {

    27

	uint32 ident;

    28

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

    29

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

    30

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

    31

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

    32

	uint16 offsets[32];	// the offsets

    33

	byte plural_form;		// plural form index

    34

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

    35

} LanguagePackHeader;

    36

    37

typedef struct CmdStruct {

    38

	const char *cmd;

    39

	ParseCmdProc proc;

    40

	long value;

    41

	int8 consumes;

    42

	byte flags;

    43

} CmdStruct;

    44

    45

enum {

    46

	C_DONTCOUNT = 1,

    47

	C_CASE = 2,

    48

};

    49

    50

    51

typedef struct Case {

    52

	int caseidx;

    53

	char *string;

    54

	struct Case *next;

    55

} Case;

    56

    57

static int _cur_line;

    58

static int _errors, _warnings;

    59

    60

typedef struct LangString {

    61

	char *name;							// Name of the string

    62

	char *english;					// English text

    63

	char *translated;				// Translated text

    64

	uint16 hash_next;				// next hash entry

    65

	uint16 index;

    66

	Case *english_case;			// cases for english

    67

	Case *translated_case;	// cases for foreign

    68

} LangString;

    69

    70

static LangString *_strings[65536];

    71

    72

    73

#define HASH_SIZE 32767

    74

static uint16 _hash_head[HASH_SIZE];

    75

    76

static byte _put_buf[4096];

    77

static int _put_pos;

    78

static int _next_string_id;

    79

    80

static uint32 _hash;

    81

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

    82

static byte _lang_pluralform;

    83

#define MAX_NUM_GENDER 8

    84

static char _genders[MAX_NUM_GENDER][8];

    85

static int _numgenders;

    86

    87

// contains the name of all cases.

    88

#define MAX_NUM_CASES 50

    89

static char _cases[MAX_NUM_CASES][16];

    90

static int _numcases;

    91

    92

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

    93

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

    94

    95

static const char *_cur_ident;

    96

    97

typedef struct CmdPair {

    98

	const CmdStruct *a;

    99

	char *v;

   100

} CmdPair;

   101

   102

typedef struct ParsedCommandStruct {

   103

	int np;

   104

	CmdPair pairs[32];

   105

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

   106

} ParsedCommandStruct;

   107

   108

// Used when generating some advanced commands.

   109

static ParsedCommandStruct _cur_pcs;

   110

static int _cur_argidx;

   111

   112

static uint HashStr(const char *s)

   113

{

   114

	uint hash = 0;

   115

	for(; *s; s++)

   116

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

   117

	return hash % HASH_SIZE;

   118

}

   119

   120

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

   121

{

   122

	uint hash = HashStr(s);

   123

	ls->hash_next = _hash_head[hash];

   124

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

   125

}

   126

   127

static LangString *HashFind(const char *s)

   128

{

   129

	int idx = _hash_head[HashStr(s)];

   130

	while (--idx >= 0) {

   131

		LangString *ls = _strings[idx];

   132

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

   133

		idx = ls->hash_next;

   134

	}

   135

	return NULL;

   136

}

   137

   138

   139

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

   140

{

   141

	char buf[1024];

   142

	va_list va;

   143

	va_start(va, s);

   144

	vsprintf(buf, s, va);

   145

	va_end(va);

   146

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

   147

	_warnings++;

   148

}

   149

   150

   151

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

   152

{

   153

	char buf[1024];

   154

	va_list va;

   155

	va_start(va, s);

   156

	vsprintf(buf, s, va);

   157

	va_end(va);

   158

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

   159

	_errors++;

   160

}

   161

   162

   163

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

   164

{

   165

	char buf[1024];

   166

	va_list va;

   167

	va_start(va, s);

   168

	vsprintf(buf, s, va);

   169

	va_end(va);

   170

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

   171

	exit(1);

   172

}

   173

   174

   175

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

   176

{

   177

	assert(len > 0);

   178

	while (--len && *src)

   179

		*dst++=*src++;

   180

	*dst = 0;

   181

}

   182

   183

   184

static void PutByte(byte c)

   185

{

   186

	if (_put_pos == lengthof(_put_buf))

   187

		Fatal("Put buffer too small");

   188

	_put_buf[_put_pos++] = c;

   189

}

   190

   191

   192

static void EmitSingleByte(char *buf, int value)

   193

{

   194

	if (*buf != '\0')

   195

		Warning("Ignoring trailing letters in command");

   196

	PutByte((byte)value);

   197

}

   198

   199

   200

static void EmitEscapedByte(char *buf, int value)

   201

{

   202

	if (*buf != '\0')

   203

		Warning("Ignoring trailing letters in command");

   204

	PutByte((byte)0x85);

   205

	PutByte((byte)value);

   206

}

   207

   208

static void EmitSetX(char *buf, int value)

   209

{

   210

	char *err;

   211

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

   212

	if (*err != 0)

   213

		Fatal("SetX param invalid");

   214

	PutByte(1);

   215

	PutByte((byte)x);

   216

}

   217

   218

   219

static void EmitSetXY(char *buf, int value)

   220

{

   221

	char *err;

   222

	int x,y;

   223

   224

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

   225

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

   226

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

   227

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

   228

   229

	PutByte(2);

   230

	PutByte((byte)x);

   231

	PutByte((byte)y);

   232

}

   233

   234

// The plural specifier looks like

   235

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

   236

   237

// This is encoded like

   238

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

   239

   240

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

   241

{

   242

	char *s = *buf, *end;

   243

	bool rel = false;

   244

	int v;

   245

   246

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

   247

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

   248

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

   249

	if (end == s) return false;

   250

	if (rel || (v < 0))

   251

		*value += v;

   252

	else

   253

		*value = v;

   254

	*buf = end;

   255

	return true;

   256

}

   257

   258

// Parse out the next word, or NULL

   259

char *ParseWord(char **buf)

   260

{

   261

	char *s = *buf, *r;

   262

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

   263

	if (*s == 0)

   264

		return NULL;

   265

   266

	if (*s == '"') {

   267

		r = ++s;

   268

		// parse until next " or NUL

   269

		for(;;) {

   270

			if (*s == 0)

   271

				break;

   272

			if (*s == '"') {

   273

				*s++ = 0;

   274

				break;

   275

			}

   276

			s++;

   277

		}

   278

	} else {

   279

		// proceed until whitespace or NUL

   280

		r = s;

   281

		for(;;) {

   282

			if (*s == 0)

   283

				break;

   284

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

   285

				*s++ = 0;

   286

				break;

   287

			}

   288

			s++;

   289

		}

   290

	}

   291

	*buf = s;

   292

	return r;

   293

}

   294

   295

// Forward declaration

   296

static int TranslateArgumentIdx(int arg);

   297

   298

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

   299

{

   300

	int i,j;

   301

   302

	PutByte(nw);

   303

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

   304

		PutByte(strlen(words[i]));

   305

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

   306

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

   307

			PutByte(words[i][j]);

   308

	}

   309

}

   310

   311

static void EmitPlural(char *buf, int value)

   312

{

   313

	int argidx = _cur_argidx;

   314

	char *words[5];

   315

	int nw = 0;

   316

   317

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

   318

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

   319

		argidx--;

   320

   321

	// Parse each string

   322

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

   323

		words[nw] = ParseWord(&buf);

   324

		if (!words[nw])

   325

			break;

   326

	}

   327

   328

	if (nw == 0)

   329

		Fatal("No plural words");

   330

   331

	if (_plural_form_counts[_lang_pluralform] != nw)

   332

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

   333

			_plural_form_counts[_lang_pluralform], nw);

   334

   335

	PutByte(0x7D);

   336

	PutByte(TranslateArgumentIdx(argidx));

   337

	EmitWordList(words, nw);

   338

}

   339

   340

   341

static void EmitGender(char *buf, int value)

   342

{

   343

	int argidx = _cur_argidx;

   344

	char *words[8];

   345

	int nw;

   346

   347

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

   348

		buf++;

   349

   350

		// This is a {G=DER} command

   351

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

   352

			if (nw >= 8)

   353

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

   354

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

   355

				break;

   356

		}

   357

		// now nw contains the gender index

   358

		PutByte(0x87);

   359

		PutByte(nw);

   360

   361

	} else {

   362

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

   363

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

   364

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

   365

   366

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

   367

			words[nw] = ParseWord(&buf);

   368

			if (!words[nw])

   369

				break;

   370

		}

   371

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

   372

		PutByte(0x85);

   373

		PutByte(13);

   374

		PutByte(TranslateArgumentIdx(argidx));

   375

		EmitWordList(words, nw);

   376

	}

   377

}

   378

   379

   380

static const CmdStruct _cmd_structs[] = {

   381

	// Update position

   382

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

   383

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

   384

   385

	// Font size

   386

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

   387

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

   388

   389

	// New line

   390

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

   391

   392

	// Colors

   393

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

   394

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

   395

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

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

   411

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

   412

   413

	// Numbers

   414

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

   415

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

   416

   417

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

   418

   419

	// 0x85

   420

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

   421

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

   422

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

   423

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

   424

   425

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

   426

																						// The first string includes the second string.

   427

   428

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

   429

																						// The first string includes the second string.

   430

   431

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

   432

																						// The first string includes the second string.

   433

   434

   435

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

   436

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

   437

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

   438

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

   439

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

   440

   441

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

   442

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

   443

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

   444

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

   445

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

   446

   447

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

   448

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

   449

   450

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

   451

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

   452

   453

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

   454

   455

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

   456

   457

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

   458

   459

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

   460

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

   461

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

   462

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

   463

	// 0x9D is used for the pseudo command SETCASE

   464

	// 0x9E is used for case switching

   465

   466

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

   467

   468

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

   469

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

   470

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

   471

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

   472

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

   473

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

   474

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

   475

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

   476

   477

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

   478

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

   479

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

   480

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

   481

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

   482

   483

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

   484

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

   485

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

   486

};

   487

   488

   489

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

   490

{

   491

	int i;

   492

	const CmdStruct *cs = _cmd_structs;

   493