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

#include "newgrf_text.h"

    20

#include "table/landscape_const.h"

    21

#include "music.h"

    22

    23

char _userstring[128];

    24

    25

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

    26

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

    27

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

    28

    29

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

    30

    31

extern const char _openttd_revision[];

    32

    33

typedef struct LanguagePack {

    34

	uint32 ident;

    35

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

    36

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

    37

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

    38

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

    39

	uint16 offsets[32];	// the offsets

    40

	byte plural_form;		// how to compute plural forms

    41

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

    42

	char data[VARARRAY_SIZE];

    43

} LanguagePack;

    44

    45

static char **_langpack_offs;

    46

static LanguagePack *_langpack;

    47

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

    48

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

    49

    50

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

    51

	{ /* LT_NORMAL */

    52

		STR_PASSENGERS,

    53

		STR_TONS,

    54

		STR_BAGS,

    55

		STR_LITERS,

    56

		STR_ITEMS,

    57

		STR_CRATES,

    58

		STR_TONS,

    59

		STR_TONS,

    60

		STR_TONS,

    61

		STR_TONS,

    62

		STR_BAGS,

    63

		STR_RES_OTHER

    64

	},

    65

    66

	{ /* LT_HILLY */

    67

		STR_PASSENGERS,

    68

		STR_TONS,

    69

		STR_BAGS,

    70

		STR_LITERS,

    71

		STR_ITEMS,

    72

		STR_CRATES,

    73

		STR_TONS,

    74

		STR_TONS,

    75

		STR_RES_OTHER,

    76

		STR_TONS,

    77

		STR_BAGS,

    78

		STR_TONS

    79

	},

    80

    81

	{ /* LT_DESERT */

    82

		STR_PASSENGERS,

    83

		STR_LITERS,

    84

		STR_BAGS,

    85

		STR_LITERS,

    86

		STR_TONS,

    87

		STR_CRATES,

    88

		STR_TONS,

    89

		STR_TONS,

    90

		STR_TONS,

    91

		STR_LITERS,

    92

		STR_BAGS,

    93

		STR_TONS

    94

	},

    95

    96

	{ /* LT_CANDY */

    97

		STR_PASSENGERS,

    98

		STR_TONS,

    99

		STR_BAGS,

   100

		STR_NOTHING,

   101

		STR_NOTHING,

   102

		STR_TONS,

   103

		STR_TONS,

   104

		STR_LITERS,

   105

		STR_TONS,

   106

		STR_NOTHING,

   107

		STR_LITERS,

   108

		STR_NOTHING

   109

	}

   110

};

   111

   112

   113

// Read an int64 from the argv array.

   114

static inline int64 GetInt64(const int32 **argv)

   115

{

   116

	int64 result;

   117

   118

	assert(argv);

   119

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

   120

	(*argv)+=2;

   121

	return result;

   122

}

   123

   124

// Read an int32 from the argv array.

   125

static inline int32 GetInt32(const int32 **argv)

   126

{

   127

	assert(argv);

   128

	return *(*argv)++;

   129

}

   130

   131

// Read an array from the argv array.

   132

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

   133

{

   134

	const int32 *result;

   135

	assert(*argv);

   136

	result = *argv;

   137

	(*argv) += n;

   138

	return result;

   139

}

   140

   141

   142

#define NUM_BOUND_STRINGS 8

   143

   144

// Array to hold the bound strings.

   145

static const char *_bound_strings[NUM_BOUND_STRINGS];

   146

   147

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

   148

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   149

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

   150

// the indices will be reused.

   151

static int _bind_index;

   152

   153

static const char *GetStringPtr(StringID string)

   154

{

   155

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

   156

}

   157

   158

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

   159

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

   160

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

   161

// should set those bits.

   162

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

   163

{

   164

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

   165

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

   166

   167

	if (GB(string, 0, 16) == 0) error("!invalid string id 0 in GetString");

   168

   169

	switch (tab) {

   170

		case 4:

   171

			if (index >= 0xC0)

   172

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

   173

			break;

   174

   175

		case 14:

   176

			if (index >= 0xE4)

   177

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

   178

			break;

   179

   180

		// User defined name

   181

		case 15:

   182

			return GetName(index, buffr);

   183

   184

		case 28:

   185

			return GetGRFString(buffr, index);

   186

   187

		case 29:

   188

			return GetGRFString(buffr, index + 0x800);

   189

   190

		case 30:

   191

			return GetGRFString(buffr, index + 0x1000);

   192

   193

		case 31:

   194

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

   195

			// but passed through verbatim.

   196

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

   197

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

   198

			}

   199

   200

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

   201

	}

   202

   203

	if (index >= _langtab_num[tab]) {

   204

		error(

   205

			"!String 0x%X is invalid. "

   206

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

   207

		);

   208

	}

   209

   210

	return FormatString(buffr, GetStringPtr(GB(string, 0, 16)), argv, GB(string, 24, 8));

   211

}

   212

   213

char *GetString(char *buffr, StringID string)

   214

{

   215

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

   216

}

   217

   218

   219

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

   220

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

   221

// so be careful.

   222

StringID BindCString(const char *str)

   223

{

   224

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

   225

	_bound_strings[idx] = str;

   226

	return idx + STR_SPEC_DYNSTRING;

   227

}

   228

   229

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

   230

void SetDParamStr(uint n, const char *str)

   231

{

   232

	SetDParam(n, BindCString(str));

   233

}

   234

   235

void InjectDParam(int amount)

   236

{

   237

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

   238

}

   239

   240

static const uint32 _divisor_table[] = {

   241

	1000000000,

   242

	100000000,

   243

	10000000,

   244

	1000000,

   245

   246

	100000,

   247

	10000,

   248

	1000,

   249

	100,

   250

	10,

   251

	1

   252

};

   253

   254

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

   255

{

   256

	uint32 quot,divisor;

   257

	int i;

   258

	uint32 tot;

   259

	uint32 num;

   260

   261

	if (number < 0) {

   262

		*buff++ = '-';

   263

		number = -number;

   264

	}

   265

   266

	num = number;

   267

   268

	tot = 0;

   269

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

   270

		divisor = _divisor_table[i];

   271

		quot = 0;

   272

		if (num >= divisor) {

   273

			quot = num / _divisor_table[i];

   274

			num = num % _divisor_table[i];

   275

		}

   276

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

   277

			*buff++ = '0' + quot;

   278

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

   279

		}

   280

	}

   281

   282

	*buff = '\0';

   283

   284

	return buff;

   285

}

   286

   287

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

   288

{

   289

	uint32 quot,divisor;

   290

	int i;

   291

	uint32 tot;

   292

	uint32 num;

   293

   294

	if (number < 0) {

   295

		*buff++ = '-';

   296

		number = -number;

   297

	}

   298

   299

	num = number;

   300

   301

	tot = 0;

   302

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

   303

		divisor = _divisor_table[i];

   304

		quot = 0;

   305

		if (num >= divisor) {

   306

			quot = num / _divisor_table[i];

   307

			num = num % _divisor_table[i];

   308

		}

   309

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

   310

			*buff++ = '0' + quot;

   311

		}

   312

	}

   313

   314

	*buff = '\0';

   315

   316

	return buff;

   317

}

   318

   319

   320

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

   321

{

   322

	const char *src;

   323

	YearMonthDay ymd;

   324

   325

	ConvertDayToYMD(&ymd, number);

   326

   327

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

   328

	buff[-1] = ' ';

   329

   330

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

   331

	buff[-1] = ' ';

   332

   333

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

   334

}

   335

   336

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

   337

{

   338

	const char *src;

   339

	YearMonthDay ymd;

   340

   341

	ConvertDayToYMD(&ymd, number);

   342

   343

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

   344

	buff[-1] = ' ';

   345

   346

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

   347

}

   348

   349

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

   350

{

   351

	YearMonthDay ymd;

   352

   353

	ConvertDayToYMD(&ymd, number);

   354

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

   355

   356

	return buff;

   357

}

   358

   359

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

   360

{

   361

	const char *s;

   362

	char c;

   363

	char buf[40], *p;

   364

	int j;

   365

   366

	// multiply by exchange rate

   367

	number *= spec->rate;

   368

   369

	// convert from negative

   370

	if (number < 0) {

   371

		*buff++ = '-';

   372

		number = -number;

   373

	}

   374

   375

	// add prefix part

   376

	s = spec->prefix;

   377

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

   378

   379

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

   380

	if (compact) {

   381

		compact = 0;

   382

		if (number >= 1000000000) {

   383

			number = (number + 500000) / 1000000;

   384

			compact = 'M';

   385

		} else if (number >= 1000000) {

   386

			number = (number + 500) / 1000;

   387

			compact = 'k';

   388

		}

   389

	}

   390

   391

	// convert to ascii number and add commas

   392

	p = buf;

   393

	j = 4;

   394

	do {

   395

		if (--j == 0) {

   396

			*p++ = spec->separator;

   397

			j = 3;

   398

		}

   399

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

   400

	} while (number /= 10);

   401

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

   402

   403

	if (compact) *buff++ = compact;

   404

   405

	// add suffix part

   406

	s = spec->suffix;

   407

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

   408

   409

	return buff;

   410

}

   411

   412

static int DeterminePluralForm(int32 n)

   413

{

   414

	// The absolute value determines plurality

   415

	if (n < 0) n = -n;

   416

   417

	switch (_langpack->plural_form) {

   418

	// Two forms, singular used for one only

   419

	// Used in:

   420

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

   421

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

   422

	case 0:

   423

	default:

   424

		return n != 1;

   425

   426

	// Only one form

   427

	// Used in:

   428

	//   Hungarian, Japanese, Korean, Turkish

   429

	case 1:

   430

		return 0;

   431

   432

	// Two forms, singular used for zero and one

   433

	// Used in:

   434

	//   French, Brazilian Portuguese

   435

	case 2:

   436

		return n > 1;

   437

   438

	// Three forms, special case for zero

   439

	// Used in:

   440

	//   Latvian

   441

	case 3:

   442

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

   443

   444

	// Three forms, special case for one and two

   445

	// Used in:

   446

	//   Gaelige (Irish)

   447

	case 4:

   448

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

   449

   450

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

   451

	// Used in:

   452

	//   Lithuanian

   453

	case 5:

   454

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

   455

   456

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

   457

	// Used in:

   458

	//   Croatian, Czech, Russian, Slovak, Ukrainian

   459

	case 6:

   460

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

   461

   462

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

   463

	// Used in:

   464

	//   Polish

   465

	case 7:

   466

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

   467

   468

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

   469

	// Used in:

   470

	//   Slovenian

   471

	case 8:

   472

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

   473

	}

   474

}

   475

   476

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

   477

{

   478

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

   479

	uint n = (byte)*b++;

   480

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

   481

   482

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

   483

		uint len = (byte)*b++;

   484

		if (i == form) {

   485

			mypos = pos;

   486

			mylen = len;

   487

		}

   488

		pos += len;

   489

	}

   490

	*dstlen = mylen;

   491

	memcpy(dst, b + mypos, mylen);

   492

	return b + pos;

   493

}

   494

   495

typedef struct Units {

   496

	int s_m;           ///< Multiplier for velocity

   497

	int s_s;           ///< Shift for velocity

   498