1

/* $Id$ */

     2

     3

#include "../stdafx.h"

     4

#include "../macros.h"

     5

#include "../string.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

#if defined WIN32 || defined __WATCOMC__

    16

#include <direct.h>

    17

#endif /* WIN32 || __WATCOMC__ */

    18

    19

#ifdef __MORPHOS__

    20

#ifdef stderr

    21

#undef stderr

    22

#endif

    23

#define stderr stdout

    24

#endif /* __MORPHOS__ */

    25

    26

#ifdef __WATCOMC__

    27

	uint _map_log_x;     // an unpleasant hack required because Watcom is insisting on

    28

	uint _map_size_x;    // these variables being valid references in map.h

    29

	uint _map_size_y;

    30

	uint _map_tile_mask;

    31

	uint _map_size;

    32

#endif /* __WATCOMC__ */

    33

    34

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

    35

    36

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

    37

    38

typedef struct LanguagePackHeader {

    39

	uint32 ident;

    40

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

    41

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

    42

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

    43

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

    44

	uint16 offsets[32]; // the offsets

    45

	byte plural_form;   // plural form index

    46

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

    47

} LanguagePackHeader;

    48

    49

typedef struct CmdStruct {

    50

	const char *cmd;

    51

	ParseCmdProc proc;

    52

	long value;

    53

	int8 consumes;

    54

	byte flags;

    55

} CmdStruct;

    56

    57

enum {

    58

	C_DONTCOUNT = 1,

    59

	C_CASE      = 2,

    60

};

    61

    62

    63

typedef struct Case {

    64

	int caseidx;

    65

	char *string;

    66

	struct Case *next;

    67

} Case;

    68

    69

static bool _masterlang;

    70

static bool _translated;

    71

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

    72

static int _cur_line;

    73

static int _errors, _warnings;

    74

    75

typedef struct LangString {

    76

	char *name;            // Name of the string

    77

	char *english;         // English text

    78

	char *translated;      // Translated text

    79

	uint16 hash_next;      // next hash entry

    80

	uint16 index;

    81

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

    82

	Case *english_case;    // cases for english

    83

	Case *translated_case; // cases for foreign

    84

} LangString;

    85

    86

static LangString *_strings[65536];

    87

    88

    89

#define HASH_SIZE 32767

    90

static uint16 _hash_head[HASH_SIZE];

    91

    92

static byte _put_buf[4096];

    93

static int _put_pos;

    94

static int _next_string_id;

    95

    96

static uint32 _hash;

    97

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

    98

static byte _lang_pluralform;

    99

#define MAX_NUM_GENDER 8

   100

static char _genders[MAX_NUM_GENDER][8];

   101

static int _numgenders;

   102

   103

// contains the name of all cases.

   104

#define MAX_NUM_CASES 50

   105

static char _cases[MAX_NUM_CASES][16];

   106

static int _numcases;

   107

   108

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

   109

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

   110

   111

static const char *_cur_ident;

   112

   113

typedef struct CmdPair {

   114

	const CmdStruct *a;

   115

	char *v;

   116

} CmdPair;

   117

   118

typedef struct ParsedCommandStruct {

   119

	int np;

   120

	CmdPair pairs[32];

   121

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

   122

} ParsedCommandStruct;

   123

   124

// Used when generating some advanced commands.

   125

static ParsedCommandStruct _cur_pcs;

   126

static int _cur_argidx;

   127

   128

static uint HashStr(const char *s)

   129

{

   130

	uint hash = 0;

   131

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

   132

	return hash % HASH_SIZE;

   133

}

   134

   135

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

   136

{

   137

	uint hash = HashStr(s);

   138

	ls->hash_next = _hash_head[hash];

   139

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

   140

}

   141

   142

static LangString *HashFind(const char *s)

   143

{

   144

	int idx = _hash_head[HashStr(s)];

   145

   146

	while (--idx >= 0) {

   147

		LangString* ls = _strings[idx];

   148

   149

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

   150

		idx = ls->hash_next;

   151

	}

   152

	return NULL;

   153

}

   154

   155

#ifdef _MSC_VER

   156

# define LINE_NUM_FMT "(%d)"

   157

#else

   158

# define LINE_NUM_FMT ":%d"

   159

#endif

   160

   161

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

   162

{

   163

	char buf[1024];

   164

	va_list va;

   165

	va_start(va, s);

   166

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

   167

	va_end(va);

   168

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

   169

	_warnings++;

   170

}

   171

   172

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

   173

{

   174

	char buf[1024];

   175

	va_list va;

   176

	va_start(va, s);

   177

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

   178

	va_end(va);

   179

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

   180

	_errors++;

   181

}

   182

   183

   184

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

   185

{

   186

	char buf[1024];

   187

	va_list va;

   188

	va_start(va, s);

   189

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

   190

	va_end(va);

   191

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

   192

	exit(1);

   193

}

   194

   195

static void PutByte(byte c)

   196

{

   197

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

   198

	_put_buf[_put_pos++] = c;

   199

}

   200

   201

   202

static void EmitSingleByte(char *buf, int value)

   203

{

   204

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

   205

	PutByte((byte)value);

   206

}

   207

   208

   209

static void EmitEscapedByte(char *buf, int value)

   210

{

   211

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

   212

	PutByte(0x85);

   213

	PutByte((byte)value);

   214

}

   215

   216

static void EmitSetX(char *buf, int value)

   217

{

   218

	char *err;

   219

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

   220

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

   221

	PutByte(1);

   222

	PutByte((byte)x);

   223

}

   224

   225

   226

static void EmitSetXY(char *buf, int value)

   227

{

   228

	char *err;

   229

	int x;

   230

	int y;

   231

   232

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

   233

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

   234

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

   235

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

   236

   237

	PutByte(2);

   238

	PutByte((byte)x);

   239

	PutByte((byte)y);

   240

}

   241

   242

// The plural specifier looks like

   243

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

   244

   245

// This is encoded like

   246

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

   247

   248

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

   249

{

   250

	const char* s = *buf;

   251

	char* end;

   252

	bool rel = false;

   253

	int v;

   254

   255

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

   256

	if (*s == '+') {

   257

		rel = true;

   258

		s++;

   259

	}

   260

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

   261

	if (end == s) return false;

   262

	if (rel || v < 0) {

   263

		*value += v;

   264

	} else {

   265

		*value = v;

   266

	}

   267

	*buf = end;

   268

	return true;

   269

}

   270

   271

// Parse out the next word, or NULL

   272

char *ParseWord(char **buf)

   273

{

   274

	char *s = *buf, *r;

   275

   276

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

   277

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

   278

   279

	if (*s == '"') {

   280

		r = ++s;

   281

		// parse until next " or NUL

   282

		for (;;) {

   283

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

   284

			if (*s == '"') {

   285

				*s++ = '\0';

   286

				break;

   287

			}

   288

			s++;

   289

		}

   290

	} else {

   291

		// proceed until whitespace or NUL

   292

		r = s;

   293

		for (;;) {

   294

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

   295

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

   296

				*s++ = '\0';

   297

				break;

   298

			}

   299

			s++;

   300

		}

   301

	}

   302

	*buf = s;

   303

	return r;

   304

}

   305

   306

// Forward declaration

   307

static int TranslateArgumentIdx(int arg);

   308

   309

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

   310

{

   311

	uint i;

   312

	uint j;

   313

   314

	PutByte(nw);

   315

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

   316

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

   317

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

   318

	}

   319

}

   320

   321

static void EmitPlural(char *buf, int value)

   322

{

   323

	int argidx = _cur_argidx;

   324

	const char* words[5];

   325

	int nw = 0;

   326

   327

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

   328

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

   329

   330

	// Parse each string

   331

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

   332

		words[nw] = ParseWord(&buf);

   333

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

   334

	}

   335

   336

	if (nw == 0)

   337

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

   338

   339

	if (_plural_form_counts[_lang_pluralform] != nw) {

   340

		if (_translated) {

   341

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

   342

				_plural_form_counts[_lang_pluralform], nw);

   343

		} else {

   344

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

   345

			if (nw > _plural_form_counts[_lang_pluralform]) {

   346

				nw = _plural_form_counts[_lang_pluralform];

   347

			} else {

   348

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

   349

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

   350

				}

   351

			}

   352

		}

   353

	}

   354

   355

	PutByte(0x8D);

   356

	PutByte(TranslateArgumentIdx(argidx));

   357

	EmitWordList(words, nw);

   358

}

   359

   360

   361

static void EmitGender(char *buf, int value)

   362

{

   363

	int argidx = _cur_argidx;

   364

	uint nw;

   365

   366

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

   367

		buf++;

   368

   369

		// This is a {G=DER} command

   370

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

   371

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

   372

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

   373

		}

   374

		// now nw contains the gender index

   375

		PutByte(0x87);

   376

		PutByte(nw);

   377

	} else {

   378

		const char* words[8];

   379

   380

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

   381

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

   382

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

   383

   384

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

   385

			words[nw] = ParseWord(&buf);

   386

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

   387

		}

   388

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

   389

		PutByte(0x85);

   390

		PutByte(13);

   391

		PutByte(TranslateArgumentIdx(argidx));

   392

		EmitWordList(words, nw);

   393

	}

   394

}

   395

   396

   397

static const CmdStruct _cmd_structs[] = {

   398

	// Update position

   399

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

   400

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

   401

   402

	// Font size

   403

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

   404

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

   405

   406

	// Colors

   407

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

   408

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

   409

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

   410

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

   411

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

   412

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

   413

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

   414

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

   415

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

   416

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

   417

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

   418

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

   419

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

   420

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

   421

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

   422

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

   423

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

   424

   425

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

   426

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

   427

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

   428

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

   429

   430

	// These are special versions of {STRING1}

   431

	// The first string includes the second string.

   432

	{"COMPANY",    EmitEscapedByte, 5, 1, 0},

   433

	{"PLAYERNAME", EmitEscapedByte, 5, 1, 0},

   434

	{"VEHICLE",    EmitEscapedByte, 5, 1, 0},

   435

   436

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

   437

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

   438

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

   439

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

   440

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

   441

   442

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

   443

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

   444

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

   445

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

   446

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

   447

	{"POWER",           EmitEscapedByte, 16, 1, 0},

   448

	{"VOLUME_S",        EmitEscapedByte, 17, 1, 0},

   449

	{"WEIGHT",          EmitEscapedByte, 18, 1, 0},

   450

	{"WEIGHT_S",        EmitEscapedByte, 19, 1, 0},

   451

	{"FORCE",           EmitEscapedByte, 20, 1, 0},

   452

   453

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

   454

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

   455

   456

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

   457

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

   458

   459

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

   460

   461

	// 0x85 is the marker for escaped commands

   462

   463

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

   464

   465

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

   466

   467

	// Numbers

   468

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

   469

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

   470

   471

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

   472

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

   473

   474

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

   475

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

   476

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

   477

   478

	// 0x9D is used for the pseudo command SETCASE

   479

	// 0x9E is used for case switching

   480

   481

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

   482

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

   483

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

   484

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

   485

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