1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include "../macros.h"

     5

#include "../string.h"

     6

#include "../table/control_codes.h"

     7

#include "../helpers.hpp"

     8

#include <stdio.h>

     9

#include <string.h>

    10

#include <stdlib.h>

    11

#include <stdarg.h>

    12

    13

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

    14

#include <unistd.h>

    15

#include <sys/types.h>

    16

#include <sys/stat.h>

    17

#endif

    18

    19

#if defined WIN32 || defined __WATCOMC__

    20

#include <direct.h>

    21

#endif /* WIN32 || __WATCOMC__ */

    22

    23

#ifdef __MORPHOS__

    24

#ifdef stderr

    25

#undef stderr

    26

#endif

    27

#define stderr stdout

    28

#endif /* __MORPHOS__ */

    29

    30

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

    31

    32

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

    33

    34

struct LanguagePackHeader {

    35

	uint32 ident;

    36

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

    37

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

    38

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

    39

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

    40

	uint16 offsets[32]; // the offsets

    41

	byte plural_form;   // plural form index

    42

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

    43

};

    44

    45

struct CmdStruct {

    46

	const char *cmd;

    47

	ParseCmdProc proc;

    48

	long value;

    49

	int8 consumes;

    50

	byte flags;

    51

};

    52

    53

enum {

    54

	C_DONTCOUNT = 1,

    55

	C_CASE      = 2,

    56

};

    57

    58

    59

struct Case {

    60

	int caseidx;

    61

	char *string;

    62

	Case *next;

    63

};

    64

    65

static bool _masterlang;

    66

static bool _translated;

    67

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

    68

static int _cur_line;

    69

static int _errors, _warnings;

    70

    71

struct LangString {

    72

	char *name;            // Name of the string

    73

	char *english;         // English text

    74

	char *translated;      // Translated text

    75

	uint16 hash_next;      // next hash entry

    76

	uint16 index;

    77

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

    78

	Case *english_case;    // cases for english

    79

	Case *translated_case; // cases for foreign

    80

};

    81

    82

static LangString *_strings[65536];

    83

    84

    85

#define HASH_SIZE 32767

    86

static uint16 _hash_head[HASH_SIZE];

    87

    88

static byte _put_buf[4096];

    89

static int _put_pos;

    90

static int _next_string_id;

    91

    92

static uint32 _hash;

    93

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

    94

static byte _lang_pluralform;

    95

#define MAX_NUM_GENDER 8

    96

static char _genders[MAX_NUM_GENDER][8];

    97

static int _numgenders;

    98

    99

// contains the name of all cases.

   100

#define MAX_NUM_CASES 50

   101

static char _cases[MAX_NUM_CASES][16];

   102

static int _numcases;

   103

   104

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

   105

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

   106

   107

static const char *_cur_ident;

   108

   109

struct CmdPair {

   110

	const CmdStruct *a;

   111

	const char *v;

   112

};

   113

   114

struct ParsedCommandStruct {

   115

	int np;

   116

	CmdPair pairs[32];

   117

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

   118

};

   119

   120

// Used when generating some advanced commands.

   121

static ParsedCommandStruct _cur_pcs;

   122

static int _cur_argidx;

   123

   124

static uint HashStr(const char *s)

   125

{

   126

	uint hash = 0;

   127

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

   128

	return hash % HASH_SIZE;

   129

}

   130

   131

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

   132

{

   133

	uint hash = HashStr(s);

   134

	ls->hash_next = _hash_head[hash];

   135

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

   136

}

   137

   138

static LangString *HashFind(const char *s)

   139

{

   140

	int idx = _hash_head[HashStr(s)];

   141

   142

	while (--idx >= 0) {

   143

		LangString* ls = _strings[idx];

   144

   145

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

   146

		idx = ls->hash_next;

   147

	}

   148

	return NULL;

   149

}

   150

   151

#ifdef _MSC_VER

   152

# define LINE_NUM_FMT "(%d)"

   153

#else

   154

# define LINE_NUM_FMT ":%d"

   155

#endif

   156

   157

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

   158

{

   159

	char buf[1024];

   160

	va_list va;

   161

	va_start(va, s);

   162

	vsnprintf(buf, lengthof(buf), s, va);

   163

	va_end(va);

   164

	fprintf(stderr, "%s" LINE_NUM_FMT ": warning: %s\n", _file, _cur_line, buf);

   165

	_warnings++;

   166

}

   167

   168

void CDECL error(const char *s, ...)

   169

{

   170

	char buf[1024];

   171

	va_list va;

   172

	va_start(va, s);

   173

	vsnprintf(buf, lengthof(buf), s, va);

   174

	va_end(va);

   175

	fprintf(stderr, "%s" LINE_NUM_FMT ": error: %s\n", _file, _cur_line, buf);

   176

	_errors++;

   177

}

   178

   179

   180

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

   181

{

   182

	char buf[1024];

   183

	va_list va;

   184

	va_start(va, s);

   185

	vsnprintf(buf, lengthof(buf), s, va);

   186

	va_end(va);

   187

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

   188

	exit(1);

   189

}

   190

   191

static void PutByte(byte c)

   192

{

   193

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

   194

	_put_buf[_put_pos++] = c;

   195

}

   196

   197

   198

static void PutUtf8(uint32 value)

   199

{

   200

	if (value < 0x80) {

   201

		PutByte(value);

   202

	} else if (value < 0x800) {

   203

		PutByte(0xC0 + GB(value,  6, 5));

   204

		PutByte(0x80 + GB(value,  0, 6));

   205

	} else if (value < 0x10000) {

   206

		PutByte(0xE0 + GB(value, 12, 4));

   207

		PutByte(0x80 + GB(value,  6, 6));

   208

		PutByte(0x80 + GB(value,  0, 6));

   209

	} else if (value < 0x110000) {

   210

		PutByte(0xF0 + GB(value, 18, 3));

   211

		PutByte(0x80 + GB(value, 12, 6));

   212

		PutByte(0x80 + GB(value,  6, 6));

   213

		PutByte(0x80 + GB(value,  0, 6));

   214

	} else {

   215

		warning("Invalid unicode value U+0x%X", value);

   216

	}

   217

}

   218

   219

   220

size_t Utf8Validate(const char *s)

   221

{

   222

	uint32 c;

   223

   224

	if (!HASBIT(s[0], 7)) {

   225

		/* 1 byte */

   226

		return 1;

   227

	} else if (GB(s[0], 5, 3) == 6 && IsUtf8Part(s[1])) {

   228

		/* 2 bytes */

   229

		c = GB(s[0], 0, 5) << 6 | GB(s[1], 0, 6);

   230

		if (c >= 0x80) return 2;

   231

	} else if (GB(s[0], 4, 4) == 14 && IsUtf8Part(s[1]) && IsUtf8Part(s[2])) {

   232

		/* 3 bytes */

   233

		c = GB(s[0], 0, 4) << 12 | GB(s[1], 0, 6) << 6 | GB(s[2], 0, 6);

   234

		if (c >= 0x800) return 3;

   235

	} else if (GB(s[0], 3, 5) == 30 && IsUtf8Part(s[1]) && IsUtf8Part(s[2]) && IsUtf8Part(s[3])) {

   236

		/* 4 bytes */

   237

		c = GB(s[0], 0, 3) << 18 | GB(s[1], 0, 6) << 12 | GB(s[2], 0, 6) << 6 | GB(s[3], 0, 6);

   238

		if (c >= 0x10000 && c <= 0x10FFFF) return 4;

   239

	}

   240

   241

	return 0;

   242

}

   243

   244

   245

static void EmitSingleChar(char *buf, int value)

   246

{

   247

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

   248

	PutUtf8(value);

   249

}

   250

   251

   252

static void EmitSetX(char *buf, int value)

   253

{

   254

	char *err;

   255

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

   256

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

   257

	PutUtf8(SCC_SETX);

   258

	PutByte((byte)x);

   259

}

   260

   261

   262

static void EmitSetXY(char *buf, int value)

   263

{

   264

	char *err;

   265

	int x;

   266

	int y;

   267

   268

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

   269

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

   270

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

   271

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

   272

   273

	PutUtf8(SCC_SETXY);

   274

	PutByte((byte)x);

   275

	PutByte((byte)y);

   276

}

   277

   278

// The plural specifier looks like

   279

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

   280

   281

// This is encoded like

   282

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

   283

   284

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

   285

{

   286

	const char* s = *buf;

   287

	char* end;

   288

	bool rel = false;

   289

	int v;

   290

   291

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

   292

	if (*s == '+') {

   293

		rel = true;

   294

		s++;

   295

	}

   296

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

   297

	if (end == s) return false;

   298

	if (rel || v < 0) {

   299

		*value += v;

   300

	} else {

   301

		*value = v;

   302

	}

   303

	*buf = end;

   304

	return true;

   305

}

   306

   307

// Parse out the next word, or NULL

   308

char *ParseWord(char **buf)

   309

{

   310

	char *s = *buf, *r;

   311

   312

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

   313

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

   314

   315

	if (*s == '"') {

   316

		r = ++s;

   317

		// parse until next " or NUL

   318

		for (;;) {

   319

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

   320

			if (*s == '"') {

   321

				*s++ = '\0';

   322

				break;

   323

			}

   324

			s++;

   325

		}

   326

	} else {

   327

		// proceed until whitespace or NUL

   328

		r = s;

   329

		for (;;) {

   330

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

   331

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

   332

				*s++ = '\0';

   333

				break;

   334

			}

   335

			s++;

   336

		}

   337

	}

   338

	*buf = s;

   339

	return r;

   340

}

   341

   342

// Forward declaration

   343

static int TranslateArgumentIdx(int arg);

   344

   345

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

   346

{

   347

	uint i;

   348

	uint j;

   349

   350

	PutByte(nw);

   351

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

   352

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

   353

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

   354

	}

   355

}

   356

   357

static void EmitPlural(char *buf, int value)

   358

{

   359

	int argidx = _cur_argidx;

   360

	const char* words[5];

   361

	int nw = 0;

   362

   363

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

   364

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

   365

   366

	// Parse each string

   367

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

   368

		words[nw] = ParseWord(&buf);

   369

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

   370

	}

   371

   372

	if (nw == 0)

   373

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

   374

   375

	if (_plural_form_counts[_lang_pluralform] != nw) {

   376

		if (_translated) {

   377

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

   378

				_plural_form_counts[_lang_pluralform], nw);

   379

		} else {

   380

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

   381

			if (nw > _plural_form_counts[_lang_pluralform]) {

   382

				nw = _plural_form_counts[_lang_pluralform];

   383

			} else {

   384

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

   385

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

   386

				}

   387

			}

   388

		}

   389

	}

   390

   391

	PutUtf8(SCC_PLURAL_LIST);

   392

	PutByte(TranslateArgumentIdx(argidx));

   393

	EmitWordList(words, nw);

   394

}

   395

   396

   397

static void EmitGender(char *buf, int value)

   398

{

   399

	int argidx = _cur_argidx;

   400

	uint nw;

   401

   402

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

   403

		buf++;

   404

   405

		// This is a {G=DER} command

   406

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

   407

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

   408

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

   409

		}

   410

		// now nw contains the gender index

   411

		PutUtf8(SCC_GENDER_INDEX);

   412

		PutByte(nw);

   413

	} else {

   414

		const char* words[8];

   415

   416

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

   417

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

   418

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

   419

   420

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

   421

			words[nw] = ParseWord(&buf);

   422

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

   423

		}

   424

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

   425

		PutUtf8(SCC_GENDER_LIST);

   426

		PutByte(TranslateArgumentIdx(argidx));

   427

		EmitWordList(words, nw);

   428

	}

   429

}

   430

   431

   432

static const CmdStruct _cmd_structs[] = {

   433

	// Update position

   434

	{"SETX",  EmitSetX,  SCC_SETX,  0, 0},

   435

	{"SETXY", EmitSetXY, SCC_SETXY, 0, 0},

   436

   437

	// Font size

   438

	{"TINYFONT", EmitSingleChar, SCC_TINYFONT, 0, 0},

   439

	{"BIGFONT",  EmitSingleChar, SCC_BIGFONT,  0, 0},

   440

   441

	// Colors

   442

	{"BLUE",    EmitSingleChar, SCC_BLUE,    0, 0},

   443

	{"SILVER",  EmitSingleChar, SCC_SILVER,  0, 0},

   444

	{"GOLD",    EmitSingleChar, SCC_GOLD,    0, 0},

   445

	{"RED",     EmitSingleChar, SCC_RED,     0, 0},

   446

	{"PURPLE",  EmitSingleChar, SCC_PURPLE,  0, 0},

   447

	{"LTBROWN", EmitSingleChar, SCC_LTBROWN, 0, 0},

   448

	{"ORANGE",  EmitSingleChar, SCC_ORANGE,  0, 0},

   449

	{"GREEN",   EmitSingleChar, SCC_GREEN,   0, 0},

   450

	{"YELLOW",  EmitSingleChar, SCC_YELLOW,  0, 0},

   451

	{"DKGREEN", EmitSingleChar, SCC_DKGREEN, 0, 0},

   452

	{"CREAM",   EmitSingleChar, SCC_CREAM,   0, 0},

   453

	{"BROWN",   EmitSingleChar, SCC_BROWN,   0, 0},

   454

	{"WHITE",   EmitSingleChar, SCC_WHITE,   0, 0},

   455

	{"LTBLUE",  EmitSingleChar, SCC_LTBLUE,  0, 0},

   456

	{"GRAY",    EmitSingleChar, SCC_GRAY,    0, 0},

   457

	{"DKBLUE",  EmitSingleChar, SCC_DKBLUE,  0, 0},

   458

	{"BLACK",   EmitSingleChar, SCC_BLACK,   0, 0},

   459

   460

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

   461

	{"REV",           EmitSingleChar, SCC_REVISION,            0, 0}, // openttd revision string

   462

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

   463

	{"CURRCOMPACT64", EmitSingleChar, SCC_CURRENCY_COMPACT_64, 2, 0}, // compact currency 64 bits

   464

   465

	// These are special versions of {STRING1}

   466

	// The first string includes the second string.

   467

	{"COMPANY",    EmitSingleChar, SCC_STRING1, 1, 0},

   468

	{"PLAYERNAME", EmitSingleChar, SCC_STRING1, 1, 0},

   469

	{"VEHICLE",    EmitSingleChar, SCC_STRING1, 1, 0},

   470

   471

	{"STRING1", EmitSingleChar, SCC_STRING1, 1, C_CASE}, // included string that consumes ONE argument

   472

	{"STRING2", EmitSingleChar, SCC_STRING2, 2, C_CASE}, // included string that consumes TWO arguments

   473

	{"STRING3", EmitSingleChar, SCC_STRING3, 3, C_CASE}, // included string that consumes THREE arguments

   474

	{"STRING4", EmitSingleChar, SCC_STRING4, 4, C_CASE}, // included string that consumes FOUR arguments

   475

	{"STRING5", EmitSingleChar, SCC_STRING5, 5, C_CASE}, // included string that consumes FIVE arguments

   476

   477

	{"STATIONFEATURES", EmitSingleChar, SCC_STATION_FEATURES, 1, 0}, // station features string, icons of the features

   478

	{"INDUSTRY",        EmitSingleChar, SCC_INDUSTRY_NAME,    1, 0}, // industry, takes an industry #

   479

	{"CARGO",           EmitSingleChar, SCC_CARGO,            2, 0},

   480

	{"POWER",           EmitSingleChar, SCC_POWER,            1, 0},

   481

	{"VOLUME",          EmitSingleChar, SCC_VOLUME,           1, 0},

   482

	{"VOLUME_S",        EmitSingleChar, SCC_VOLUME_SHORT,     1, 0},

   483

	{"WEIGHT",          EmitSingleChar, SCC_WEIGHT,           1, 0},

   484

	{"WEIGHT_S",        EmitSingleChar, SCC_WEIGHT_SHORT,     1, 0},

   485

	{"FORCE",           EmitSingleChar, SCC_FORCE,            1, 0},