1

/* $Id$ */

     2

     3

/** @file strings.cpp Handling of translated strings. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "currency.h"

     8

#include "namegen_func.h"

     9

#include "station_base.h"

    10

#include "town.h"

    11

#include "screenshot.h"

    12

#include "waypoint.h"

    13

#include "industry.h"

    14

#include "variables.h"

    15

#include "newgrf_text.h"

    16

#include "music.h"

    17

#include "industry.h"

    18

#include "fileio.h"

    19

#include "cargotype.h"

    20

#include "group.h"

    21

#include "debug.h"

    22

#include "newgrf_townname.h"

    23

#include "signs_base.h"

    24

#include "newgrf_engine.h"

    25

#include "spritecache.h"

    26

#include "fontcache.h"

    27

#include "gui.h"

    28

#include "strings_func.h"

    29

#include "functions.h"

    30

#include "rev.h"

    31

#include "core/endian_func.hpp"

    32

#include "date_func.h"

    33

#include "vehicle_base.h"

    34

#include "string_func.h"

    35

#include "player_func.h"

    36

#include "player_base.h"

    37

#include "fios.h"

    38

#include "settings_type.h"

    39

#include "video/video_driver.hpp"

    40

#include "engine_func.h"

    41

#include "engine_base.h"

    42

#include "saveload.h"

    43

    44

#include "table/strings.h"

    45

#include "table/control_codes.h"

    46

    47

DynamicLanguages _dynlang;

    48

uint64 _decode_parameters[20];

    49

    50

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

    51

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

    52

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

    53

    54

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

    55

    56

struct LanguagePack {

    57

	uint32 ident;       // 32-bits identifier

    58

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

    59

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

    60

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

    61

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

    62

	uint16 offsets[32]; // the offsets

    63

	byte plural_form;   // how to compute plural forms

    64

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

    65

	char data[VARARRAY_SIZE]; // list of strings

    66

};

    67

    68

static char **_langpack_offs;

    69

static LanguagePack *_langpack;

    70

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

    71

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

    72

    73

    74

/** Read an int64 from the argv array. */

    75

static inline int64 GetInt64(const int64 **argv)

    76

{

    77

	assert(argv);

    78

	return *(*argv)++;

    79

}

    80

    81

/** Read an int32 from the argv array. */

    82

static inline int32 GetInt32(const int64 **argv)

    83

{

    84

	return (int32)GetInt64(argv);

    85

}

    86

    87

/** Read an array from the argv array. */

    88

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

    89

{

    90

	const int64 *result;

    91

	assert(*argv);

    92

	result = *argv;

    93

	(*argv) += n;

    94

	return result;

    95

}

    96

    97

    98

const char *GetStringPtr(StringID string)

    99

{

   100

	switch (GB(string, 11, 5)) {

   101

		case 28: return GetGRFStringPtr(GB(string, 0, 11));

   102

		case 29: return GetGRFStringPtr(GB(string, 0, 11) + 0x0800);

   103

		case 30: return GetGRFStringPtr(GB(string, 0, 11) + 0x1000);

   104

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

   105

	}

   106

}

   107

   108

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

   109

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

   110

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

   111

 * should set those bits, therefore string CANNOT be StringID, but uint32.

   112

 * @param buffr

   113

 * @param string

   114

 * @param argv

   115

 * @param last

   116

 * @return a formatted string of char

   117

 */

   118

static char *GetStringWithArgs(char *buffr, uint string, const int64 *argv, const char* last)

   119

{

   120

	if (GB(string, 0, 16) == 0) return GetStringWithArgs(buffr, STR_UNDEFINED, argv, last);

   121

   122

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

   123

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

   124

   125

	switch (tab) {

   126

		case 4:

   127

			if (index >= 0xC0)

   128

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

   129

			break;

   130

   131

		case 14:

   132

			if (index >= 0xE4)

   133

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

   134

			break;

   135

   136

		case 15:

   137

			/* Old table for custom names. This is no longer used */

   138

			error("Incorrect conversion of custom name string.");

   139

   140

		case 26:

   141

			/* Include string within newgrf text (format code 81) */

   142

			if (HasBit(index, 10)) {

   143

				StringID string = GetGRFStringID(0, 0xD000 + GB(index, 0, 10));

   144

				return GetStringWithArgs(buffr, string, argv, last);

   145

			}

   146

			break;

   147

   148

		case 28:

   149

			return FormatString(buffr, GetGRFStringPtr(index), argv, 0, last);

   150

   151

		case 29:

   152

			return FormatString(buffr, GetGRFStringPtr(index + 0x0800), argv, 0, last);

   153

   154

		case 30:

   155

			return FormatString(buffr, GetGRFStringPtr(index + 0x1000), argv, 0, last);

   156

   157

		case 31:

   158

			NOT_REACHED();

   159

	}

   160

   161

	if (index >= _langtab_num[tab]) {

   162

		error(

   163

			"String 0x%X is invalid. "

   164

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

   165

		);

   166

	}

   167

   168

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

   169

}

   170

   171

char *GetString(char *buffr, StringID string, const char* last)

   172

{

   173

	return GetStringWithArgs(buffr, string, (int64*)_decode_parameters, last);

   174

}

   175

   176

   177

char *InlineString(char *buf, StringID string)

   178

{

   179

	buf += Utf8Encode(buf, SCC_STRING_ID);

   180

	buf += Utf8Encode(buf, string);

   181

	return buf;

   182

}

   183

   184

   185

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

   186

 * @param n slot of the string

   187

 * @param str string to bind

   188

 */

   189

void SetDParamStr(uint n, const char *str)

   190

{

   191

	SetDParam(n, (uint64)str);

   192

}

   193

   194

void InjectDParam(int amount)

   195

{

   196

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

   197

}

   198

   199

// TODO

   200

static char *FormatCommaNumber(char *buff, int64 number, const char *last)

   201

{

   202

	uint64 divisor = 10000000000000000000ULL;

   203

	uint64 quot;

   204

	int i;

   205

	uint64 tot;

   206

	uint64 num;

   207

   208

	if (number < 0) {

   209

		*buff++ = '-';

   210

		number = -number;

   211

	}

   212

   213

	num = number;

   214

   215

	tot = 0;

   216

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

   217

		quot = 0;

   218

		if (num >= divisor) {

   219

			quot = num / divisor;

   220

			num = num % divisor;

   221

		}

   222

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

   223

			*buff++ = '0' + quot;

   224

			if ((i % 3) == 1 && i != 19) *buff++ = ',';

   225

		}

   226

   227

		divisor /= 10;

   228

	}

   229

   230

	*buff = '\0';

   231

   232

	return buff;

   233

}

   234

   235

// TODO

   236

static char *FormatNoCommaNumber(char *buff, int64 number, const char *last)

   237

{

   238

	uint64 divisor = 10000000000000000000ULL;

   239

	uint64 quot;

   240

	int i;

   241

	uint64 tot;

   242

	uint64 num;

   243

   244

	if (number < 0) {

   245

		buff = strecpy(buff, "-", last);

   246

		number = -number;

   247

	}

   248

   249

	num = number;

   250

   251

	tot = 0;

   252

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

   253

		quot = 0;

   254

		if (num >= divisor) {

   255

			quot = num / divisor;

   256

			num = num % divisor;

   257

		}

   258

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

   259

			*buff++ = '0' + quot;

   260

		}

   261

   262

		divisor /= 10;

   263

	}

   264

   265

	*buff = '\0';

   266

   267

	return buff;

   268

}

   269

   270

   271

static char *FormatYmdString(char *buff, Date date, const char* last)

   272

{

   273

	YearMonthDay ymd;

   274

	ConvertDateToYMD(date, &ymd);

   275

   276

	int64 args[3] = { ymd.day + STR_01AC_1ST - 1, STR_0162_JAN + ymd.month, ymd.year };

   277

	return FormatString(buff, GetStringPtr(STR_DATE_LONG), args, 0, last);

   278

}

   279

   280

static char *FormatMonthAndYear(char *buff, Date date, const char* last)

   281

{

   282

	YearMonthDay ymd;

   283

	ConvertDateToYMD(date, &ymd);

   284

   285

	int64 args[2] = { STR_MONTH_JAN + ymd.month, ymd.year };

   286

	return FormatString(buff, GetStringPtr(STR_DATE_SHORT), args, 0, last);

   287

}

   288

   289

static char *FormatTinyDate(char *buff, Date date, const char* last)

   290

{

   291

	YearMonthDay ymd;

   292

	ConvertDateToYMD(date, &ymd);

   293

   294

	char day[3];

   295

	char month[3];

   296

	/* We want to zero-pad the days and months */

   297

	snprintf(day,   lengthof(day),   "%02i", ymd.day);

   298

	snprintf(month, lengthof(month), "%02i", ymd.month + 1);

   299

   300

	int64 args[3] = { (int64)day, (int64)month, ymd.year };

   301

	return FormatString(buff, GetStringPtr(STR_DATE_TINY), args, 0, last);

   302

}

   303

   304

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

   305

{

   306

	/* We are going to make number absolute for printing, so

   307

	 * keep this piece of data as we need it later on */

   308

	bool negative = number < 0;

   309

	const char *multiplier = "";

   310

	char buf[40];

   311

	char *p;

   312

	int j;

   313

   314

	number *= spec->rate;

   315

   316

	/* convert from negative */

   317

	if (number < 0) {

   318

		if (buff + Utf8CharLen(SCC_RED) > last) return buff;

   319

		buff += Utf8Encode(buff, SCC_RED);

   320

		buff = strecpy(buff, "-", last);

   321

		number = -number;

   322

	}

   323

   324

	/* Add prefix part, folowing symbol_pos specification.

   325

	 * Here, it can can be either 0 (prefix) or 2 (both prefix anf suffix).

   326

	 * The only remaining value is 1 (suffix), so everything that is not 1 */

   327

	if (spec->symbol_pos != 1) buff = strecpy(buff, spec->prefix, last);

   328

   329

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

   330

	if (compact) {

   331

		if (number >= 1000000000) {

   332

			number = (number + 500000) / 1000000;

   333

			multiplier = "M";

   334

		} else if (number >= 1000000) {

   335

			number = (number + 500) / 1000;

   336

			multiplier = "k";

   337

		}

   338

	}

   339

   340

	/* convert to ascii number and add commas */

   341

	p = endof(buf);

   342

	*--p = '\0';

   343

	j = 4;

   344

	do {

   345

		if (--j == 0) {

   346

			*--p = spec->separator;

   347

			j = 3;

   348

		}

   349

		*--p = '0' + (char)(number % 10);

   350

	} while ((number /= 10) != 0);

   351

	buff = strecpy(buff, p, last);

   352

   353

	buff = strecpy(buff, multiplier, last);

   354

   355

	/* Add suffix part, folowing symbol_pos specification.

   356

	 * Here, it can can be either 1 (suffix) or 2 (both prefix anf suffix).

   357

	 * The only remaining value is 1 (prefix), so everything that is not 0 */

   358

	if (spec->symbol_pos != 0) buff = strecpy(buff, spec->suffix, last);

   359

   360

	if (negative) {

   361

		if (buff + Utf8CharLen(SCC_PREVIOUS_COLOUR) > last) return buff;

   362

		buff += Utf8Encode(buff, SCC_PREVIOUS_COLOUR);

   363

		*buff = '\0';

   364

	}

   365

   366

	return buff;

   367

}

   368

   369

static int DeterminePluralForm(int64 count)

   370

{

   371

	/* The absolute value determines plurality */

   372

	uint64 n = abs(count);

   373

   374

	switch (_langpack->plural_form) {

   375

		default:

   376

			NOT_REACHED();

   377

   378

		/* Two forms, singular used for one only

   379

		 * Used in:

   380

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

   381

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

   382

		case 0:

   383

			return n != 1;

   384

   385

		/* Only one form

   386

		 * Used in:

   387

		 *   Hungarian, Japanese, Korean, Turkish */

   388

		case 1:

   389

			return 0;

   390

   391

		/* Two forms, singular used for zero and one

   392

		 * Used in:

   393

		 *   French, Brazilian Portuguese */

   394

		case 2:

   395

			return n > 1;

   396

   397

		/* Three forms, special case for zero

   398

		 * Used in:

   399

		 *   Latvian */

   400

		case 3:

   401

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

   402

   403

		/* Three forms, special case for one and two

   404

		 * Used in:

   405

		 *   Gaelige (Irish) */

   406

		case 4:

   407

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

   408

   409

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

   410

		 * Used in:

   411

		 *   Lithuanian */

   412

		case 5:

   413

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

   414

   415

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

   416

		 * Used in:

   417

		 *   Croatian, Czech, Russian, Slovak, Ukrainian */

   418

		case 6:

   419

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

   420

   421

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

   422

		 * Used in:

   423

		 *   Polish */

   424

		case 7:

   425

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

   426

   427

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

   428

		 * Used in:

   429

		 *   Slovenian */

   430

		case 8:

   431

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

   432

   433

		/* Two forms; singular used for everything ending in 1 but not in 11.

   434

		 * Used in:

   435

		 *   Icelandic */

   436

		case 9:

   437

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

   438

	}

   439

}

   440

   441

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

   442

{

   443

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

   444

	uint n = (byte)*b++;

   445

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

   446

   447

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

   448

		uint len = (byte)*b++;

   449

		if (i == form) {

   450

			mypos = pos;

   451

			mylen = len;

   452

		}

   453

		pos += len;

   454

	}

   455

	*dstlen = mylen;

   456

	memcpy(dst, b + mypos, mylen);

   457

	return b + pos;

   458

}

   459

   460

struct Units {

   461

	int s_m;           ///< Multiplier for velocity

   462

	int s_s;           ///< Shift for velocity

   463

	StringID velocity; ///< String for velocity

   464

	int p_m;           ///< Multiplier for power

   465

	int p_s;           ///< Shift for power

   466

	StringID power;    ///< String for velocity

   467

	int w_m;           ///< Multiplier for weight

   468

	int w_s;           ///< Shift for weight

   469

	StringID s_weight; ///< Short string for weight

   470

	StringID l_weight; ///< Long string for weight

   471

	int v_m;           ///< Multiplier for volume

   472

	int v_s;           ///< Shift for volume

   473

	StringID s_volume; ///< Short string for volume

   474

	StringID l_volume; ///< Long string for volume

   475

	int f_m;           ///< Multiplier for force

   476

	int f_s;           ///< Shift for force

   477

	StringID force;    ///< String for force

   478

};

   479

   480

/* Unit conversions */

   481

static const Units units[] = {

   482

	{ // Imperial (Original, mph, hp, metric ton, litre, kN)

   483

		   1,  0, STR_UNITS_VELOCITY_IMPERIAL,

   484

		   1,  0, STR_UNITS_POWER_IMPERIAL,

   485

		   1,  0, STR_UNITS_WEIGHT_SHORT_METRIC, STR_UNITS_WEIGHT_LONG_METRIC,

   486

		1000,  0, STR_UNITS_VOLUME_SHORT_METRIC, STR_UNITS_VOLUME_LONG_METRIC,