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(WIN64)) || 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 bool _masterlang;

    58

static bool _translated;

    59

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

    60

static int _cur_line;

    61

static int _errors, _warnings;

    62

    63

typedef struct LangString {

    64

	char *name;							// Name of the string

    65

	char *english;					// English text

    66

	char *translated;				// Translated text

    67

	uint16 hash_next;				// next hash entry

    68

	uint16 index;

    69

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

    70

	Case *english_case;			// cases for english

    71

	Case *translated_case;	// cases for foreign

    72

} LangString;

    73

    74

static LangString *_strings[65536];

    75

    76

    77

#define HASH_SIZE 32767

    78

static uint16 _hash_head[HASH_SIZE];

    79

    80

static byte _put_buf[4096];

    81

static int _put_pos;

    82

static int _next_string_id;

    83

    84

static uint32 _hash;

    85

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

    86

static byte _lang_pluralform;

    87

#define MAX_NUM_GENDER 8

    88

static char _genders[MAX_NUM_GENDER][8];

    89

static int _numgenders;

    90

    91

// contains the name of all cases.

    92

#define MAX_NUM_CASES 50

    93

static char _cases[MAX_NUM_CASES][16];

    94

static int _numcases;

    95

    96

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

    97

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

    98

    99

static const char *_cur_ident;

   100

   101

typedef struct CmdPair {

   102

	const CmdStruct *a;

   103

	char *v;

   104

} CmdPair;

   105

   106

typedef struct ParsedCommandStruct {

   107

	int np;

   108

	CmdPair pairs[32];

   109

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

   110

} ParsedCommandStruct;

   111

   112

// Used when generating some advanced commands.

   113

static ParsedCommandStruct _cur_pcs;

   114

static int _cur_argidx;

   115

   116

static uint HashStr(const char *s)

   117

{

   118

	uint hash = 0;

   119

	for(; *s; s++)

   120

		hash = ((hash << 3) | (hash >> 29)) ^ *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

	while (--idx >= 0) {

   135

		LangString *ls = _strings[idx];

   136

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

   137

		idx = ls->hash_next;

   138

	}

   139

	return NULL;

   140

}

   141

   142

   143

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

   144

{

   145

	char buf[1024];

   146

	va_list va;

   147

	va_start(va, s);

   148

	vsprintf(buf, s, va);

   149

	va_end(va);

   150

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

   151

	_warnings++;

   152

}

   153

   154

   155

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

   156

{

   157

	char buf[1024];

   158

	va_list va;

   159

	va_start(va, s);

   160

	vsprintf(buf, s, va);

   161

	va_end(va);

   162

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

   163

	_errors++;

   164

}

   165

   166

   167

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

   168

{

   169

	char buf[1024];

   170

	va_list va;

   171

	va_start(va, s);

   172

	vsprintf(buf, s, va);

   173

	va_end(va);

   174

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

   175

	exit(1);

   176

}

   177

   178

   179

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

   180

{

   181

	assert(len > 0);

   182

	while (--len && *src)

   183

		*dst++=*src++;

   184

	*dst = 0;

   185

}

   186

   187

   188

static void PutByte(byte c)

   189

{

   190

	if (_put_pos == lengthof(_put_buf))

   191

		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')

   199

		Warning("Ignoring trailing letters in command");

   200

	PutByte((byte)value);

   201

}

   202

   203

   204

static void EmitEscapedByte(char *buf, int value)

   205

{

   206

	if (*buf != '\0')

   207

		Warning("Ignoring trailing letters in command");

   208

	PutByte((byte)0x85);

   209

	PutByte((byte)value);

   210

}

   211

   212

static void EmitSetX(char *buf, int value)

   213

{

   214

	char *err;

   215

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

   216

	if (*err != 0)

   217

		Fatal("SetX param invalid");

   218

	PutByte(1);

   219

	PutByte((byte)x);

   220

}

   221

   222

   223

static void EmitSetXY(char *buf, int value)

   224

{

   225

	char *err;

   226

	int x,y;

   227

   228

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

   229

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

   230

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

   231

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

   232

   233

	PutByte(2);

   234

	PutByte((byte)x);

   235

	PutByte((byte)y);

   236

}

   237

   238

// The plural specifier looks like

   239

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

   240

   241

// This is encoded like

   242

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

   243

   244

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

   245

{

   246

	char *s = *buf, *end;

   247

	bool rel = false;

   248

	int v;

   249

   250

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

   251

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

   252

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

   253

	if (end == s) return false;

   254

	if (rel || (v < 0))

   255

		*value += v;

   256

	else

   257

		*value = v;

   258

	*buf = end;

   259

	return true;

   260

}

   261

   262

// Parse out the next word, or NULL

   263

char *ParseWord(char **buf)

   264

{

   265

	char *s = *buf, *r;

   266

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

   267

	if (*s == 0)

   268

		return NULL;

   269

   270

	if (*s == '"') {

   271

		r = ++s;

   272

		// parse until next " or NUL

   273

		for(;;) {

   274

			if (*s == 0)

   275

				break;

   276

			if (*s == '"') {

   277

				*s++ = 0;

   278

				break;

   279

			}

   280

			s++;

   281

		}

   282

	} else {

   283

		// proceed until whitespace or NUL

   284

		r = s;

   285

		for(;;) {

   286

			if (*s == 0)

   287

				break;

   288

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

   289

				*s++ = 0;

   290

				break;

   291

			}

   292

			s++;

   293

		}

   294

	}

   295

	*buf = s;

   296

	return r;

   297

}

   298

   299

// Forward declaration

   300

static int TranslateArgumentIdx(int arg);

   301

   302

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

   303

{

   304

	int i,j;

   305

   306

	PutByte(nw);

   307

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

   308

		PutByte(strlen(words[i]));

   309

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

   310

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

   311

			PutByte(words[i][j]);

   312

	}

   313

}

   314

   315

static void EmitPlural(char *buf, int value)

   316

{

   317

	int argidx = _cur_argidx;

   318

	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))

   323

		argidx--;

   324

   325

	// Parse each string

   326

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

   327

		words[nw] = ParseWord(&buf);

   328

		if (!words[nw])

   329

			break;

   330

	}

   331

   332

	if (nw == 0)

   333

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

   334

   335

	if (_plural_form_counts[_lang_pluralform] != nw) {

   336

		if (_translated) {

   337

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

   338

				_plural_form_counts[_lang_pluralform], nw);

   339

		} else {

   340

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

   341

			if (nw > _plural_form_counts[_lang_pluralform]) {

   342

				nw = _plural_form_counts[_lang_pluralform];

   343

			} else {

   344

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

   345

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

   346

				}

   347

			}

   348

		}

   349

	}

   350

   351

	PutByte(0x8D);

   352

	PutByte(TranslateArgumentIdx(argidx));

   353

	EmitWordList(words, nw);

   354

}

   355

   356

   357

static void EmitGender(char *buf, int value)

   358

{

   359

	int argidx = _cur_argidx;

   360

	char *words[8];

   361

	int nw;

   362

   363

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

   364

		buf++;

   365

   366

		// This is a {G=DER} command

   367

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

   368

			if (nw >= 8)

   369

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

   370

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

   371

				break;

   372

		}

   373

		// now nw contains the gender index

   374

		PutByte(0x87);

   375

		PutByte(nw);

   376

   377

	} else {

   378

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

   379

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

   380

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

   381

   382

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

   383

			words[nw] = ParseWord(&buf);

   384

			if (!words[nw])

   385

				break;

   386

		}

   387

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

   388

		PutByte(0x85);

   389

		PutByte(13);

   390

		PutByte(TranslateArgumentIdx(argidx));

   391

		EmitWordList(words, nw);

   392

	}

   393

}

   394

   395

   396

static const CmdStruct _cmd_structs[] = {

   397

	// Update position

   398

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

   399

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

   400

   401

	// Font size

   402

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

   403

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

   404

   405

	// New line

   406

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

   407

   408

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

   409

   410

	// Colors

   411

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

   412

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

   413

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

   414

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

   415

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

   416

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

   417

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

   418

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

   419

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

   420

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

   421

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

   422

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

   423

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

   424

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

   425

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

   426

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

   427

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

   428

   429

	// 0x85

   430

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

   431

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

   432

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

   433

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

   434

   435

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

   436

																						// The first string includes the second string.

   437

   438

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

   439

																						// The first string includes the second string.

   440

   441

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

   442

																						// The first string includes the second string.

   443

   444

   445

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

   446

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

   447

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

   448

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

   449

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

   450

   451

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

   452

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

   453

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

   454

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

   455

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

   456

   457

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

   458

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

   459

   460

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

   461

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

   462

   463

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

   464

   465

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

   466

   467

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

   468

   469

	// Numbers

   470

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

   471

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

   472

   473

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

   474

   475

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

   476

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

   477

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

   478

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

   479

	// 0x9D is used for the pseudo command SETCASE

   480

	// 0x9E is used for case switching

   481

   482

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

   483

   484

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

   485

   486

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

   487

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

   488

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

   489

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

   490

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

   491

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