1

#include "stdafx.h"

     2

#include "openttd.h"

     3

#include "string.h"

     4

#include "strings.h"

     5

#include "table/strings.h"

     6

#include "namegen.h"

     7

#include "station.h"

     8

#include "town.h"

     9

#include "vehicle.h"

    10

#include "news.h"

    11

#include "screenshot.h"

    12

#include "waypoint.h"

    13

#include "industry.h"

    14

    15

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

    16

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

    17

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

    18

    19

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

    20

    21

extern const char _openttd_revision[];

    22

    23

typedef struct LanguagePack {

    24

	uint32 ident;

    25

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

    26

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

    27

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

    28

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

    29

	uint16 offsets[32];	// the offsets

    30

	byte plural_form;		// how to compute plural forms

    31

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

    32

	char data[VARARRAY_SIZE];

    33

} LanguagePack;

    34

    35

static char **_langpack_offs;

    36

static LanguagePack *_langpack;

    37

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

    38

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

    39

    40

const StringID _currency_string_list[] = {

    41

	STR_CURR_GBP,

    42

	STR_CURR_USD,

    43

	STR_CURR_EUR,

    44

	STR_CURR_YEN,

    45

	STR_CURR_ATS,

    46

	STR_CURR_BEF,

    47

	STR_CURR_CHF,

    48

	STR_CURR_CZK,

    49

	STR_CURR_DEM,

    50

	STR_CURR_DKK,

    51

	STR_CURR_ESP,

    52

	STR_CURR_FIM,

    53

	STR_CURR_FRF,

    54

	STR_CURR_GRD,

    55

	STR_CURR_HUF,

    56

	STR_CURR_ISK,

    57

	STR_CURR_ITL,

    58

	STR_CURR_NLG,

    59

	STR_CURR_NOK,

    60

	STR_CURR_PLN,

    61

	STR_CURR_ROL,

    62

	STR_CURR_RUR,

    63

	STR_CURR_SEK,

    64

	STR_CURR_CUSTOM,

    65

	INVALID_STRING_ID

    66

};

    67

    68

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

    69

	{ /* LT_NORMAL */

    70

		STR_PASSENGERS,

    71

		STR_TONS,

    72

		STR_BAGS,

    73

		STR_LITERS,

    74

		STR_ITEMS,

    75

		STR_CRATES,

    76

		STR_TONS,

    77

		STR_TONS,

    78

		STR_TONS,

    79

		STR_TONS,

    80

		STR_BAGS,

    81

		STR_RES_OTHER

    82

	},

    83

    84

	{ /* LT_HILLY */

    85

		STR_PASSENGERS,

    86

		STR_TONS,

    87

		STR_BAGS,

    88

		STR_LITERS,

    89

		STR_ITEMS,

    90

		STR_CRATES,

    91

		STR_TONS,

    92

		STR_TONS,

    93

		STR_RES_OTHER,

    94

		STR_TONS,

    95

		STR_BAGS,

    96

		STR_TONS

    97

	},

    98

    99

	{ /* LT_DESERT */

   100

		STR_PASSENGERS,

   101

		STR_LITERS,

   102

		STR_BAGS,

   103

		STR_LITERS,

   104

		STR_TONS,

   105

		STR_CRATES,

   106

		STR_TONS,

   107

		STR_TONS,

   108

		STR_TONS,

   109

		STR_LITERS,

   110

		STR_BAGS,

   111

		STR_TONS

   112

	},

   113

   114

	{ /* LT_CANDY */

   115

		STR_PASSENGERS,

   116

		STR_TONS,

   117

		STR_BAGS,

   118

		STR_NOTHING,

   119

		STR_NOTHING,

   120

		STR_TONS,

   121

		STR_TONS,

   122

		STR_LITERS,

   123

		STR_TONS,

   124

		STR_NOTHING,

   125

		STR_LITERS,

   126

		STR_NOTHING

   127

	}

   128

};

   129

   130

   131

// Read an int64 from the argv array.

   132

static inline int64 GetInt64(const int32 **argv)

   133

{

   134

	int64 result;

   135

   136

	assert(argv);

   137

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

   138

	(*argv)+=2;

   139

	return result;

   140

}

   141

   142

// Read an int32 from the argv array.

   143

static inline int32 GetInt32(const int32 **argv)

   144

{

   145

	assert(argv);

   146

	return *(*argv)++;

   147

}

   148

   149

// Read an array from the argv array.

   150

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

   151

{

   152

	const int32 *result;

   153

	assert(*argv);

   154

	result = *argv;

   155

	(*argv) += n;

   156

	return result;

   157

}

   158

   159

   160

#define NUM_BOUND_STRINGS 8

   161

   162

// Array to hold the bound strings.

   163

static const char *_bound_strings[NUM_BOUND_STRINGS];

   164

   165

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

   166

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   167

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

   168

// the indices will be reused.

   169

static int _bind_index;

   170

   171

static const char *GetStringPtr(StringID string)

   172

{

   173

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

   174

}

   175

   176

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

   177

{

   178

	uint index = string & 0x7FF;

   179

	uint tab = string >> 11;

   180

   181

	if (!string) {

   182

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

   183

	}

   184

   185

	switch (tab) {

   186

		case 4:

   187

			if (index >= 0xC0)

   188

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

   189

			break;

   190

   191

		case 14:

   192

			if (index >= 0xE4)

   193

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

   194

			break;

   195

   196

		// User defined name

   197

		case 15:

   198

			return GetName(index, buffr);

   199

   200

		case 31:

   201

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

   202

			// but passed through verbatim.

   203

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

   204

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

   205

			}

   206

   207

			return FormatString(buffr, _userstring, NULL);

   208

	}

   209

   210

	if (index >= _langtab_num[tab])

   211

		error(

   212

			"!String 0x%X is invalid. "

   213

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

   214

		);

   215

   216

	return FormatString(buffr, GetStringPtr(string), argv);

   217

}

   218

   219

char *GetString(char *buffr, StringID string)

   220

{

   221

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

   222

}

   223

   224

   225

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

   226

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

   227

// so be careful.

   228

StringID BindCString(const char *str)

   229

{

   230

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

   231

	_bound_strings[idx] = str;

   232

	return idx + STR_SPEC_DYNSTRING;

   233

}

   234

   235

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

   236

void SetDParamStr(uint n, const char *str)

   237

{

   238

	SetDParam(n, BindCString(str));

   239

}

   240

   241

void InjectDParam(int amount)

   242

{

   243

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

   244

}

   245

   246

static const uint32 _divisor_table[] = {

   247

	1000000000,

   248

	100000000,

   249

	10000000,

   250

	1000000,

   251

   252

	100000,

   253

	10000,

   254

	1000,

   255

	100,

   256

	10,

   257

	1

   258

};

   259

   260

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

   261

{

   262

	uint32 quot,divisor;

   263

	int i;

   264

	uint32 tot;

   265

	uint32 num;

   266

   267

	if (number < 0) {

   268

		*buff++ = '-';

   269

		number = -number;

   270

	}

   271

   272

	num = number;

   273

   274

	tot = 0;

   275

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

   276

		divisor = _divisor_table[i];

   277

		quot = 0;

   278

		if (num >= divisor) {

   279

			quot = num / _divisor_table[i];

   280

			num = num % _divisor_table[i];

   281

		}

   282

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

   283

			*buff++ = '0' + quot;

   284

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

   285

		}

   286

	}

   287

   288

	*buff = '\0';

   289

   290

	return buff;

   291

}

   292

   293

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

   294

{

   295

	uint32 quot,divisor;

   296

	int i;

   297

	uint32 tot;

   298

	uint32 num;

   299

   300

	if (number < 0) {

   301

		*buff++ = '-';

   302

		number = -number;

   303

	}

   304

   305

	num = number;

   306

   307

	tot = 0;

   308

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

   309

		divisor = _divisor_table[i];

   310

		quot = 0;

   311

		if (num >= divisor) {

   312

			quot = num / _divisor_table[i];

   313

			num = num % _divisor_table[i];

   314

		}

   315

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

   316

			*buff++ = '0' + quot;

   317

		}

   318

	}

   319

   320

	*buff = '\0';

   321

   322

	return buff;

   323

}

   324

   325

   326

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

   327

{

   328

	const char *src;

   329

	YearMonthDay ymd;

   330

   331

	ConvertDayToYMD(&ymd, number);

   332

   333

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

   334

   335

	buff[-1] = ' ';

   336

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

   337

	buff[3] = ' ';

   338

   339

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

   340

}

   341

   342

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

   343

{

   344

	const char *src;

   345

	YearMonthDay ymd;

   346

   347

	ConvertDayToYMD(&ymd, number);

   348

   349

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

   350

	buff[-1] = ' ';

   351

   352

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

   353

}

   354

   355

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

   356

{

   357

	YearMonthDay ymd;

   358

   359

	ConvertDayToYMD(&ymd, number);

   360

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

   361

   362

	return buff;

   363

}

   364

   365

uint GetCurrentCurrencyRate(void)

   366

{

   367

	return _currency_specs[_opt_ptr->currency].rate;

   368

}

   369

   370

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

   371

{

   372

	const char *s;

   373

	char c;

   374

	char buf[40], *p;

   375

	int j;

   376

   377

	// multiply by exchange rate

   378

	number *= spec->rate;

   379

   380

	// convert from negative

   381

	if (number < 0) {

   382

		*buff++ = '-';

   383

		number = -number;

   384

	}

   385

   386

	// add prefix part

   387

	s = spec->prefix;

   388

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

   389

   390

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

   391

	if (compact) {

   392

		compact = 0;

   393

		if (number >= 1000000000) {

   394

			number = (number + 500000) / 1000000;

   395

			compact = 'M';

   396

		} else if (number >= 1000000) {

   397

			number = (number + 500) / 1000;

   398

			compact = 'k';

   399

		}

   400

	}

   401

   402

	// convert to ascii number and add commas

   403

	p = buf;

   404

	j = 4;

   405

	do {

   406

		if (--j == 0) {

   407

			*p++ = spec->separator;

   408

			j = 3;

   409

		}

   410

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

   411

	} while (number /= 10);

   412

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

   413

   414

	if (compact) *buff++ = compact;

   415

   416

	// add suffix part

   417

	s = spec->suffix;

   418

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

   419

   420

	return buff;

   421

}

   422

   423

static int DeterminePluralForm(int32 n)

   424

{

   425

	// The absolute value determines plurality

   426

	if (n < 0) n = -n;

   427

   428

	switch(_langpack->plural_form) {

   429

	// Two forms, singular used for one only

   430

	// Used in:

   431

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

   432

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

   433

	case 0:

   434

	default:

   435

		return n != 1;

   436

   437

	// Only one form

   438

	// Used in:

   439

	//   Hungarian, Japanese, Korean, Turkish

   440

	case 1:

   441

		return 0;

   442

   443

	// Two forms, singular used for zero and one

   444

	// Used in:

   445

	//   French, Brazilian Portuguese

   446

	case 2:

   447

		return n > 1;

   448

   449

	// Three forms, special case for zero

   450

	// Used in:

   451

	//   Latvian

   452

	case 3:

   453

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

   454

   455

	// Three forms, special case for one and two

   456

	// Used in:

   457

	//   Gaelige (Irish)

   458

	case 4:

   459

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

   460

   461

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

   462

	// Used in:

   463

	//   Lithuanian

   464

	case 5:

   465

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

   466

   467

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

   468

	// Used in:

   469

	//   Croatian, Czech, Russian, Slovak, Ukrainian

   470

	case 6:

   471

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

   472

   473

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

   474

	// Used in:

   475

	//   Polish

   476

	case 7:

   477

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

   478

   479

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

   480

	// Used in:

   481

	//   Slovenian

   482

	case 8:

   483

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

   484

	}

   485

}

   486

   487

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

   488

{

   489

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

   490

	uint n = (byte)*b++;

   491

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

   492

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

   493

		uint len = (byte)*b++;

   494

		if (i == form) {

   495

			mypos = pos;

   496

			mylen = len;

   497

		}

   498

		pos += len;