1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "currency.h"

     6

#include "functions.h"

     7

#include "string.h"

     8

#include "strings.h"

     9

#include "table/strings.h"

    10

#include "namegen.h"

    11

#include "station.h"

    12

#include "town.h"

    13

#include "vehicle.h"

    14

#include "news.h"

    15

#include "screenshot.h"

    16

#include "waypoint.h"

    17

#include "industry.h"

    18

#include "variables.h"

    19

    20

char _userstring[128];

    21

    22

static char *StationGetSpecialString(char *buff, int x);

    23

static char *GetSpecialTownNameString(char *buff, int ind, uint32 seed);

    24

static char *GetSpecialPlayerNameString(char *buff, int ind, const int32 *argv);

    25

    26

static char *FormatString(char *buff, const char *str, const int32 *argv, uint casei);

    27

    28

extern const char _openttd_revision[];

    29

    30

typedef struct LanguagePack {

    31

	uint32 ident;

    32

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

    33

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

    34

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

    35

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

    36

	uint16 offsets[32];	// the offsets

    37

	byte plural_form;		// how to compute plural forms

    38

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

    39

	char data[VARARRAY_SIZE];

    40

} LanguagePack;

    41

    42

static char **_langpack_offs;

    43

static LanguagePack *_langpack;

    44

static uint _langtab_num[32]; // Offset into langpack offs

    45

static uint _langtab_start[32]; // Offset into langpack offs

    46

    47

static const StringID _cargo_string_list[NUM_LANDSCAPE][NUM_CARGO] = {

    48

	{ /* LT_NORMAL */

    49

		STR_PASSENGERS,

    50

		STR_TONS,

    51

		STR_BAGS,

    52

		STR_LITERS,

    53

		STR_ITEMS,

    54

		STR_CRATES,

    55

		STR_TONS,

    56

		STR_TONS,

    57

		STR_TONS,

    58

		STR_TONS,

    59

		STR_BAGS,

    60

		STR_RES_OTHER

    61

	},

    62

    63

	{ /* LT_HILLY */

    64

		STR_PASSENGERS,

    65

		STR_TONS,

    66

		STR_BAGS,

    67

		STR_LITERS,

    68

		STR_ITEMS,

    69

		STR_CRATES,

    70

		STR_TONS,

    71

		STR_TONS,

    72

		STR_RES_OTHER,

    73

		STR_TONS,

    74

		STR_BAGS,

    75

		STR_TONS

    76

	},

    77

    78

	{ /* LT_DESERT */

    79

		STR_PASSENGERS,

    80

		STR_LITERS,

    81

		STR_BAGS,

    82

		STR_LITERS,

    83

		STR_TONS,

    84

		STR_CRATES,

    85

		STR_TONS,

    86

		STR_TONS,

    87

		STR_TONS,

    88

		STR_LITERS,

    89

		STR_BAGS,

    90

		STR_TONS

    91

	},

    92

    93

	{ /* LT_CANDY */

    94

		STR_PASSENGERS,

    95

		STR_TONS,

    96

		STR_BAGS,

    97

		STR_NOTHING,

    98

		STR_NOTHING,

    99

		STR_TONS,

   100

		STR_TONS,

   101

		STR_LITERS,

   102

		STR_TONS,

   103

		STR_NOTHING,

   104

		STR_LITERS,

   105

		STR_NOTHING

   106

	}

   107

};

   108

   109

   110

// Read an int64 from the argv array.

   111

static inline int64 GetInt64(const int32 **argv)

   112

{

   113

	int64 result;

   114

   115

	assert(argv);

   116

	result = (uint32)(*argv)[0] + ((uint64)(uint32)(*argv)[1] << 32);

   117

	(*argv)+=2;

   118

	return result;

   119

}

   120

   121

// Read an int32 from the argv array.

   122

static inline int32 GetInt32(const int32 **argv)

   123

{

   124

	assert(argv);

   125

	return *(*argv)++;

   126

}

   127

   128

// Read an array from the argv array.

   129

static inline const int32 *GetArgvPtr(const int32 **argv, int n)

   130

{

   131

	const int32 *result;

   132

	assert(*argv);

   133

	result = *argv;

   134

	(*argv) += n;

   135

	return result;

   136

}

   137

   138

   139

#define NUM_BOUND_STRINGS 8

   140

   141

// Array to hold the bound strings.

   142

static const char *_bound_strings[NUM_BOUND_STRINGS];

   143

   144

// This index is used to implement a "round-robin" allocating of

   145

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   146

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

   147

// the indices will be reused.

   148

static int _bind_index;

   149

   150

static const char *GetStringPtr(StringID string)

   151

{

   152

	return _langpack_offs[_langtab_start[string >> 11] + (string & 0x7FF)];

   153

}

   154

   155

// The highest 8 bits of string contain the "case index".

   156

// These 8 bits will only be set when FormatString wants to print

   157

// the string in a different case. No one else except FormatString

   158

// should set those bits.

   159

char *GetStringWithArgs(char *buffr, uint string, const int32 *argv)

   160

{

   161

	uint index = GB(string,  0, 11);

   162

	uint tab   = GB(string, 11,  5);

   163

   164

	if (!(string & 0xFFFF)) {

   165

		error("!invalid string id 0 in GetString");

   166

	}

   167

   168

	switch (tab) {

   169

		case 4:

   170

			if (index >= 0xC0)

   171

				return GetSpecialTownNameString(buffr, index - 0xC0, GetInt32(&argv));

   172

			break;

   173

   174

		case 14:

   175

			if (index >= 0xE4)

   176

				return GetSpecialPlayerNameString(buffr, index - 0xE4, argv);

   177

			break;

   178

   179

		// User defined name

   180

		case 15:

   181

			return GetName(index, buffr);

   182

   183

		case 31:

   184

			// dynamic strings. These are NOT to be passed through the formatter,

   185

			// but passed through verbatim.

   186

			if (index < (STR_SPEC_USERSTRING & 0x7FF)) {

   187

				return strecpy(buffr, _bound_strings[index], NULL);

   188

			}

   189

   190

			return FormatString(buffr, _userstring, NULL, 0);

   191

	}

   192

   193

	if (index >= _langtab_num[tab])

   194

		error(

   195

			"!String 0x%X is invalid. "

   196

			"Probably because an old version of the .lng file.\n", string

   197

		);

   198

   199

	return FormatString(buffr, GetStringPtr(string&0xFFFF), argv, string >> 24);

   200

}

   201

   202

char *GetString(char *buffr, StringID string)

   203

{

   204

	return GetStringWithArgs(buffr, string, (int32*)_decode_parameters);

   205

}

   206

   207

   208

// This function takes a C-string and allocates a temporary string ID.

   209

// The duration of the bound string is valid only until the next GetString,

   210

// so be careful.

   211

StringID BindCString(const char *str)

   212

{

   213

	int idx = (++_bind_index) & (NUM_BOUND_STRINGS - 1);

   214

	_bound_strings[idx] = str;

   215

	return idx + STR_SPEC_DYNSTRING;

   216

}

   217

   218

// This function is used to "bind" a C string to a OpenTTD dparam slot.

   219

void SetDParamStr(uint n, const char *str)

   220

{

   221

	SetDParam(n, BindCString(str));

   222

}

   223

   224

void InjectDParam(int amount)

   225

{

   226

	memmove(_decode_parameters + amount, _decode_parameters, sizeof(_decode_parameters) - amount * sizeof(uint32));

   227

}

   228

   229

static const uint32 _divisor_table[] = {

   230

	1000000000,

   231

	100000000,

   232

	10000000,

   233

	1000000,

   234

   235

	100000,

   236

	10000,

   237

	1000,

   238

	100,

   239

	10,

   240

	1

   241

};

   242

   243

static char *FormatCommaNumber(char *buff, int32 number)

   244

{

   245

	uint32 quot,divisor;

   246

	int i;

   247

	uint32 tot;

   248

	uint32 num;

   249

   250

	if (number < 0) {

   251

		*buff++ = '-';

   252

		number = -number;

   253

	}

   254

   255

	num = number;

   256

   257

	tot = 0;

   258

	for (i = 0; i != 10; i++) {

   259

		divisor = _divisor_table[i];

   260

		quot = 0;

   261

		if (num >= divisor) {

   262

			quot = num / _divisor_table[i];

   263

			num = num % _divisor_table[i];

   264

		}

   265

		if (tot |= quot || i == 9) {

   266

			*buff++ = '0' + quot;

   267

			if (i == 0 || i == 3 || i == 6) *buff++ = ',';

   268

		}

   269

	}

   270

   271

	*buff = '\0';

   272

   273

	return buff;

   274

}

   275

   276

static char *FormatNoCommaNumber(char *buff, int32 number)

   277

{

   278

	uint32 quot,divisor;

   279

	int i;

   280

	uint32 tot;

   281

	uint32 num;

   282

   283

	if (number < 0) {

   284

		*buff++ = '-';

   285

		number = -number;

   286

	}

   287

   288

	num = number;

   289

   290

	tot = 0;

   291

	for (i = 0; i != 10; i++) {

   292

		divisor = _divisor_table[i];

   293

		quot = 0;

   294

		if (num >= divisor) {

   295

			quot = num / _divisor_table[i];

   296

			num = num % _divisor_table[i];

   297

		}

   298

		if (tot |= quot || i == 9) {

   299

			*buff++ = '0' + quot;

   300

		}

   301

	}

   302

   303

	*buff = '\0';

   304

   305

	return buff;

   306

}

   307

   308

   309

static char *FormatYmdString(char *buff, uint16 number)

   310

{

   311

	const char *src;

   312

	YearMonthDay ymd;

   313

   314

	ConvertDayToYMD(&ymd, number);

   315

   316

	for (src = GetStringPtr(ymd.day + STR_01AC_1ST - 1); (*buff++ = *src++) != '\0';) {}

   317

   318

	buff[-1] = ' ';

   319

	memcpy(buff, GetStringPtr(STR_0162_JAN + ymd.month), 4);

   320

	buff[3] = ' ';

   321

   322

	return FormatNoCommaNumber(buff+4, ymd.year + MAX_YEAR_BEGIN_REAL);

   323

}

   324

   325

static char *FormatMonthAndYear(char *buff, uint16 number)

   326

{

   327

	const char *src;

   328

	YearMonthDay ymd;

   329

   330

	ConvertDayToYMD(&ymd, number);

   331

   332

	for (src = GetStringPtr(STR_MONTH_JAN + ymd.month); (*buff++ = *src++) != '\0';) {}

   333

	buff[-1] = ' ';

   334

   335

	return FormatNoCommaNumber(buff, ymd.year + MAX_YEAR_BEGIN_REAL);

   336

}

   337

   338

static char *FormatTinyDate(char *buff, uint16 number)

   339

{

   340

	YearMonthDay ymd;

   341

   342

	ConvertDayToYMD(&ymd, number);

   343

	buff += sprintf(buff, " %02i-%02i-%04i", ymd.day, ymd.month + 1, ymd.year + MAX_YEAR_BEGIN_REAL);

   344

   345

	return buff;

   346

}

   347

   348

static char *FormatGenericCurrency(char *buff, const CurrencySpec *spec, int64 number, bool compact)

   349

{

   350

	const char *s;

   351

	char c;

   352

	char buf[40], *p;

   353

	int j;

   354

   355

	// multiply by exchange rate

   356

	number *= spec->rate;

   357

   358

	// convert from negative

   359

	if (number < 0) {

   360

		*buff++ = '-';

   361

		number = -number;

   362

	}

   363

   364

	// add prefix part

   365

	s = spec->prefix;

   366

	while (s != spec->prefix + lengthof(spec->prefix) && (c = *s++) != '\0') *buff++ = c;

   367

   368

	// for huge numbers, compact the number into k or M

   369

	if (compact) {

   370

		compact = 0;

   371

		if (number >= 1000000000) {

   372

			number = (number + 500000) / 1000000;

   373

			compact = 'M';

   374

		} else if (number >= 1000000) {

   375

			number = (number + 500) / 1000;

   376

			compact = 'k';

   377

		}

   378

	}

   379

   380

	// convert to ascii number and add commas

   381

	p = buf;

   382

	j = 4;

   383

	do {

   384

		if (--j == 0) {

   385

			*p++ = spec->separator;

   386

			j = 3;

   387

		}

   388

		*p++ = '0' + number % 10;

   389

	} while (number /= 10);

   390

	do *buff++ = *--p; while (p != buf);

   391

   392

	if (compact) *buff++ = compact;

   393

   394

	// add suffix part

   395

	s = spec->suffix;

   396

	while (s != spec->suffix + lengthof(spec->suffix) && (c = *s++) != '\0') *buff++ = c;

   397

   398

	return buff;

   399

}

   400

   401

static int DeterminePluralForm(int32 n)

   402

{

   403

	// The absolute value determines plurality

   404

	if (n < 0) n = -n;

   405

   406

	switch(_langpack->plural_form) {

   407

	// Two forms, singular used for one only

   408

	// Used in:

   409

	//   Danish, Dutch, English, German, Norwegian, Swedish, Estonian, Finnish,

   410

	//   Greek, Hebrew, Italian, Portuguese, Spanish, Esperanto

   411

	case 0:

   412

	default:

   413

		return n != 1;

   414

   415

	// Only one form

   416

	// Used in:

   417

	//   Hungarian, Japanese, Korean, Turkish

   418

	case 1:

   419

		return 0;

   420

   421

	// Two forms, singular used for zero and one

   422

	// Used in:

   423

	//   French, Brazilian Portuguese

   424

	case 2:

   425

		return n > 1;

   426

   427

	// Three forms, special case for zero

   428

	// Used in:

   429

	//   Latvian

   430

	case 3:

   431

		return n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2;

   432

   433

	// Three forms, special case for one and two

   434

	// Used in:

   435

	//   Gaelige (Irish)

   436

	case 4:

   437

		return n==1 ? 0 : n==2 ? 1 : 2;

   438

   439

	// Three forms, special case for numbers ending in 1[2-9]

   440

	// Used in:

   441

	//   Lithuanian

   442

	case 5:

   443

		return n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2;

   444

   445

	// Three forms, special cases for numbers ending in 1 and 2, 3, 4, except those ending in 1[1-4]

   446

	// Used in:

   447

	//   Croatian, Czech, Russian, Slovak, Ukrainian

   448

	case 6:

   449

		return n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;

   450

   451

	// Three forms, special case for one and some numbers ending in 2, 3, or 4

   452

	// Used in:

   453

	//   Polish

   454

	case 7:

   455

		return n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;

   456

   457

	// Four forms, special case for one and all numbers ending in 02, 03, or 04

   458

	// Used in:

   459

	//   Slovenian

   460

	case 8:

   461

		return n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3;

   462

	}

   463

}

   464

   465

static const char *ParseStringChoice(const char *b, uint form, char *dst, int *dstlen)

   466

{

   467

	//<NUM> {Length of each string} {each string}

   468

	uint n = (byte)*b++;

   469

	uint pos,i, mylen=0,mypos=0;

   470

	for(i=pos=0; i!=n; i++) {

   471

		uint len = (byte)*b++;

   472

		if (i == form) {

   473

			mypos = pos;

   474

			mylen = len;

   475

		}

   476

		pos += len;

   477

	}

   478

	*dstlen = mylen;

   479

	memcpy(dst, b + mypos, mylen);

   480

	return b + pos;

   481

}

   482

   483

   484

static char *FormatString(char *buff, const char *str, const int32 *argv, uint casei)

   485

{

   486

	byte b;

   487

	const int32 *argv_orig = argv;

   488

	uint modifier = 0;

   489

   490

	while ((b = *str++) != '\0') {

   491

		switch (b) {

   492

		case 0x1: // {SETX}

   493

			*buff++ = b;

   494

			*buff++ = *str++;

   495

			break;

   496

		case 0x2: // {SETXY}

   497

			*buff++ = b;

   498

			*buff++ = *str++;

   499