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 const char* _file = "(unknown file)";

    58

static int _cur_line;

    59

static int _errors, _warnings;

    60

    61

typedef struct LangString {

    62

	char *name;							// Name of the string

    63

	char *english;					// English text

    64

	char *translated;				// Translated text

    65

	uint16 hash_next;				// next hash entry

    66

	uint16 index;

    67

	Case *english_case;			// cases for english

    68

	Case *translated_case;	// cases for foreign

    69

} LangString;

    70

    71

static LangString *_strings[65536];

    72

    73

    74

#define HASH_SIZE 32767

    75

static uint16 _hash_head[HASH_SIZE];

    76

    77

static byte _put_buf[4096];

    78

static int _put_pos;

    79

static int _next_string_id;

    80

    81

static uint32 _hash;

    82

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

    83

static byte _lang_pluralform;

    84

#define MAX_NUM_GENDER 8

    85

static char _genders[MAX_NUM_GENDER][8];

    86

static int _numgenders;

    87

    88

// contains the name of all cases.

    89

#define MAX_NUM_CASES 50

    90

static char _cases[MAX_NUM_CASES][16];

    91

static int _numcases;

    92

    93

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

    94

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

    95

    96

static const char *_cur_ident;

    97

    98

typedef struct CmdPair {

    99

	const CmdStruct *a;

   100

	char *v;

   101

} CmdPair;

   102

   103

typedef struct ParsedCommandStruct {

   104

	int np;

   105

	CmdPair pairs[32];

   106

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

   107

} ParsedCommandStruct;

   108

   109

// Used when generating some advanced commands.

   110

static ParsedCommandStruct _cur_pcs;

   111

static int _cur_argidx;

   112

   113

static uint HashStr(const char *s)

   114

{

   115

	uint hash = 0;

   116

	for(; *s; s++)

   117

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

   118

	return hash % HASH_SIZE;

   119

}

   120

   121

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

   122

{

   123

	uint hash = HashStr(s);

   124

	ls->hash_next = _hash_head[hash];

   125

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

   126

}

   127

   128

static LangString *HashFind(const char *s)

   129

{

   130

	int idx = _hash_head[HashStr(s)];

   131

	while (--idx >= 0) {

   132

		LangString *ls = _strings[idx];

   133

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

   134

		idx = ls->hash_next;

   135

	}

   136

	return NULL;

   137

}

   138

   139

   140

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

   141

{

   142

	char buf[1024];

   143

	va_list va;

   144

	va_start(va, s);

   145

	vsprintf(buf, s, va);

   146

	va_end(va);

   147

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

   148

	_warnings++;

   149

}

   150

   151

   152

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

   153

{

   154

	char buf[1024];

   155

	va_list va;

   156

	va_start(va, s);

   157

	vsprintf(buf, s, va);

   158

	va_end(va);

   159

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

   160

	_errors++;

   161

}

   162

   163

   164

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

   165

{

   166

	char buf[1024];

   167

	va_list va;

   168

	va_start(va, s);

   169

	vsprintf(buf, s, va);

   170

	va_end(va);

   171

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

   172

	exit(1);

   173

}

   174

   175

   176

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

   177

{

   178

	assert(len > 0);

   179

	while (--len && *src)

   180

		*dst++=*src++;

   181

	*dst = 0;

   182

}

   183

   184

   185

static void PutByte(byte c)

   186

{

   187

	if (_put_pos == lengthof(_put_buf))

   188

		Fatal("Put buffer too small");

   189

	_put_buf[_put_pos++] = c;

   190

}

   191

   192

   193

static void EmitSingleByte(char *buf, int value)

   194

{

   195

	if (*buf != '\0')

   196

		Warning("Ignoring trailing letters in command");

   197

	PutByte((byte)value);

   198

}

   199

   200

   201

static void EmitEscapedByte(char *buf, int value)

   202

{

   203

	if (*buf != '\0')

   204

		Warning("Ignoring trailing letters in command");

   205

	PutByte((byte)0x85);

   206

	PutByte((byte)value);

   207

}

   208

   209

static void EmitSetX(char *buf, int value)

   210

{

   211

	char *err;

   212

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

   213

	if (*err != 0)

   214

		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,y;

   224

   225

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

   226

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

   227

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

   228

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

   229

   230

	PutByte(2);

   231

	PutByte((byte)x);

   232

	PutByte((byte)y);

   233

}

   234

   235

// The plural specifier looks like

   236

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

   237

   238

// This is encoded like

   239

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

   240

   241

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

   242

{

   243

	char *s = *buf, *end;

   244

	bool rel = false;

   245

	int v;

   246

   247

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

   248

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

   249

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

   250

	if (end == s) return false;

   251

	if (rel || (v < 0))

   252

		*value += v;

   253

	else

   254

		*value = v;

   255

	*buf = end;

   256

	return true;

   257

}

   258

   259

// Parse out the next word, or NULL

   260

char *ParseWord(char **buf)

   261

{

   262

	char *s = *buf, *r;

   263

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

   264

	if (*s == 0)

   265

		return NULL;

   266

   267

	if (*s == '"') {

   268

		r = ++s;

   269

		// parse until next " or NUL

   270

		for(;;) {

   271

			if (*s == 0)

   272

				break;

   273

			if (*s == '"') {

   274

				*s++ = 0;

   275

				break;

   276

			}

   277

			s++;

   278

		}

   279

	} else {

   280

		// proceed until whitespace or NUL

   281

		r = s;

   282

		for(;;) {

   283

			if (*s == 0)

   284

				break;

   285

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

   286

				*s++ = 0;

   287

				break;

   288

			}

   289

			s++;

   290

		}

   291

	}

   292

	*buf = s;

   293

	return r;

   294

}

   295

   296

// Forward declaration

   297

static int TranslateArgumentIdx(int arg);

   298

   299

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

   300

{

   301

	int i,j;

   302

   303

	PutByte(nw);

   304

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

   305

		PutByte(strlen(words[i]));

   306

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

   307

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

   308

			PutByte(words[i][j]);

   309

	}

   310

}

   311

   312

static void EmitPlural(char *buf, int value)

   313

{

   314

	int argidx = _cur_argidx;

   315

	char *words[5];

   316

	int nw = 0;

   317

   318

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

   319

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

   320

		argidx--;

   321

   322

	// Parse each string

   323

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

   324

		words[nw] = ParseWord(&buf);

   325

		if (!words[nw])

   326

			break;

   327

	}

   328

   329

	if (nw == 0)

   330

		Fatal("No plural words");

   331

   332

	if (_plural_form_counts[_lang_pluralform] != nw)

   333

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

   334

			_plural_form_counts[_lang_pluralform], nw);

   335

   336

	PutByte(0x8D);

   337

	PutByte(TranslateArgumentIdx(argidx));

   338

	EmitWordList(words, nw);

   339

}

   340

   341

   342

static void EmitGender(char *buf, int value)

   343

{

   344

	int argidx = _cur_argidx;

   345

	char *words[8];

   346

	int nw;

   347

   348

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

   349

		buf++;

   350

   351

		// This is a {G=DER} command

   352

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

   353

			if (nw >= 8)

   354

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

   355

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

   356

				break;

   357

		}

   358

		// now nw contains the gender index

   359

		PutByte(0x87);

   360

		PutByte(nw);

   361

   362

	} else {

   363

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

   364

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

   365

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

   366

   367

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

   368

			words[nw] = ParseWord(&buf);

   369

			if (!words[nw])

   370

				break;

   371

		}

   372

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

   373

		PutByte(0x85);

   374

		PutByte(13);

   375

		PutByte(TranslateArgumentIdx(argidx));

   376

		EmitWordList(words, nw);

   377

	}

   378

}

   379

   380

   381

static const CmdStruct _cmd_structs[] = {

   382

	// Update position

   383

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

   384

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

   385

   386

	// Font size

   387

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

   388

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

   389

   390

	// New line

   391

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

   392

   393

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

   394

   395

	// Colors

   396

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

   397

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

   398

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

   399

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

   400

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

   401

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

   402

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

   403

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

   404

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

   405

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

   406

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

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

   414

	// 0x85

   415

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

   416

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

   417

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

   418

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

   419

   420

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

   421

																						// The first string includes the second string.

   422

   423

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

   424

																						// The first string includes the second string.

   425

   426

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

   427

																						// The first string includes the second string.

   428

   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},				// station features string, icons of the features

   437

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

   438

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

   439

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

   440

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

   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},

   446

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

   447

   448

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

   449

   450

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

   451

   452

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

   453

   454

	// Numbers

   455

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

   456

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

   457

   458

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

   459

   460

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

   461

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

   462

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

   463

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

   464

	// 0x9D is used for the pseudo command SETCASE

   465

	// 0x9E is used for case switching

   466

   467

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

   468

   469

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

   470

   471

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

   472

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

   473

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

   474

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

   475

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

   476

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

   477

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

   478

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

   479

   480

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

   481

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

   482

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

   483

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

   484

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

   485

   486

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

   487

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

   488

};

   489

   490

   491

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

   492

{