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

char _userstring[128];

    49

uint64 _decode_parameters[20];

    50

    51

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

    52

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

    53

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

    54

    55

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

    56

    57

struct LanguagePack {

    58

	uint32 ident;       // 32-bits identifier

    59

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

    60

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

    61

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

    62

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

    63

	uint16 offsets[32]; // the offsets

    64

	byte plural_form;   // how to compute plural forms

    65

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

    66

	char data[VARARRAY_SIZE]; // list of strings

    67

};

    68

    69

static char **_langpack_offs;

    70

static LanguagePack *_langpack;

    71

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

    72

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

    73

    74

    75

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

    76

static inline int64 GetInt64(const int64 **argv)

    77

{

    78

	assert(argv);

    79

	return *(*argv)++;

    80

}

    81

    82

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

    83

static inline int32 GetInt32(const int64 **argv)

    84

{

    85

	return (int32)GetInt64(argv);

    86

}

    87

    88

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

    89

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

    90

{

    91

	const int64 *result;

    92

	assert(*argv);

    93

	result = *argv;

    94

	(*argv) += n;

    95

	return result;

    96

}

    97

    98

    99

#define NUM_BOUND_STRINGS 8

   100

   101

/* Array to hold the bound strings. */

   102

static const char *_bound_strings[NUM_BOUND_STRINGS];

   103

   104

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

   105

 * slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   106

 * Which means that after NUM_BOUND_STRINGS calls to BindCString,

   107

 * the indices will be reused. */

   108

static int _bind_index;

   109

   110

const char *GetStringPtr(StringID string)

   111

{

   112

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

   113

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

   114

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

   115

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

   116

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

   117

	}

   118

}

   119

   120

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

   121

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

   122

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

   123

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

   124

 * @param buffr

   125

 * @param string

   126

 * @param argv

   127

 * @param last

   128

 * @return a formatted string of char

   129

 */

   130

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

   131

{

   132

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

   133

   134

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

   135

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

   136

   137

	switch (tab) {

   138

		case 4:

   139

			if (index >= 0xC0)

   140

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

   141

			break;

   142

   143

		case 14:

   144

			if (index >= 0xE4)

   145

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

   146

			break;

   147

   148

		case 15:

   149

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

   150

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

   151

   152

		case 26:

   153

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

   154

			if (HasBit(index, 10)) {

   155

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

   156

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

   157

			}

   158

			break;

   159

   160

		case 28:

   161

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

   162

   163

		case 29:

   164

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

   165

   166

		case 30:

   167

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

   168

   169

		case 31:

   170

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

   171

			 * but passed through verbatim. */

   172

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

   173

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

   174

			}

   175

   176

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

   177

	}

   178

   179

	if (index >= _langtab_num[tab]) {

   180

		error(

   181

			"String 0x%X is invalid. "

   182

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

   183

		);

   184

	}

   185

   186

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

   187

}

   188

   189

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

   190

{

   191

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

   192

}

   193

   194

   195

char *InlineString(char *buf, StringID string)

   196

{

   197

	buf += Utf8Encode(buf, SCC_STRING_ID);

   198

	buf += Utf8Encode(buf, string);

   199

	return buf;

   200

}

   201

   202

   203

/**

   204

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

   205

 * The StringID of the bound string is valid until BindCString is called

   206

 * another NUM_BOUND_STRINGS times. So be careful when using it.

   207

 * @param str temp string to add

   208

 * @return the id of that temp string

   209

 * @note formatting a DATE_TINY calls BindCString twice, thus reduces the

   210

 *       amount of 'user' bound strings by 2.

   211

 * @todo rewrite the BindCString system to make the limit flexible and

   212

 *       non-round-robin. For example by using smart pointers that free

   213

 *       the allocated StringID when they go out-of-scope/are freed.

   214

 */

   215

StringID BindCString(const char *str)

   216

{

   217

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

   218

	_bound_strings[idx] = str;

   219

	return idx + STR_SPEC_DYNSTRING;

   220

}

   221

   222

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

   223

 * @param n slot of the string

   224

 * @param str string to bind

   225

 */

   226

void SetDParamStr(uint n, const char *str)

   227

{

   228

	SetDParam(n, BindCString(str));

   229

}

   230

   231

void InjectDParam(int amount)

   232

{

   233

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

   234

}

   235

   236

// TODO

   237

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

   238

{

   239

	uint64 divisor = 10000000000000000000ULL;

   240

	uint64 quot;

   241

	int i;

   242

	uint64 tot;

   243

	uint64 num;

   244

   245

	if (number < 0) {

   246

		*buff++ = '-';

   247

		number = -number;

   248

	}

   249

   250

	num = number;

   251

   252

	tot = 0;

   253

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

   254

		quot = 0;

   255

		if (num >= divisor) {

   256

			quot = num / divisor;

   257

			num = num % divisor;

   258

		}

   259

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

   260

			*buff++ = '0' + quot;

   261

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

   262

		}

   263

   264

		divisor /= 10;

   265

	}

   266

   267

	*buff = '\0';

   268

   269

	return buff;

   270

}

   271

   272

// TODO

   273

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

   274

{

   275

	uint64 divisor = 10000000000000000000ULL;

   276

	uint64 quot;

   277

	int i;

   278

	uint64 tot;

   279

	uint64 num;

   280

   281

	if (number < 0) {

   282

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

   283

		number = -number;

   284

	}

   285

   286

	num = number;

   287

   288

	tot = 0;

   289

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

   290

		quot = 0;

   291

		if (num >= divisor) {

   292

			quot = num / divisor;

   293

			num = num % divisor;

   294

		}

   295

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

   296

			*buff++ = '0' + quot;

   297

		}

   298

   299

		divisor /= 10;

   300

	}

   301

   302

	*buff = '\0';

   303

   304

	return buff;

   305

}

   306

   307

   308

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

   309

{

   310

	YearMonthDay ymd;

   311

	ConvertDateToYMD(date, &ymd);

   312

   313

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

   314

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

   315

}

   316

   317

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

   318

{

   319

	YearMonthDay ymd;

   320

	ConvertDateToYMD(date, &ymd);

   321

   322

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

   323

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

   324

}

   325

   326

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

   327

{

   328

	YearMonthDay ymd;

   329

	ConvertDateToYMD(date, &ymd);

   330

   331

	char day[3];

   332

	char month[3];

   333

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

   334

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

   335

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

   336

   337

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

   338

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

   339

}

   340

   341

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

   342

{

   343

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

   344

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

   345

	bool negative = number < 0;

   346

	const char *multiplier = "";

   347

	char buf[40];

   348

	char *p;

   349

	int j;

   350

   351

	number *= spec->rate;

   352

   353

	/* convert from negative */

   354

	if (number < 0) {

   355

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

   356

		buff += Utf8Encode(buff, SCC_RED);

   357

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

   358

		number = -number;

   359

	}

   360

   361

	/* Add prefix part, folowing symbol_pos specification.

   362

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

   363

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

   364

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

   365

   366

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

   367

	if (compact) {

   368

		if (number >= 1000000000) {

   369

			number = (number + 500000) / 1000000;

   370

			multiplier = "M";

   371

		} else if (number >= 1000000) {

   372

			number = (number + 500) / 1000;

   373

			multiplier = "k";

   374

		}

   375

	}

   376

   377

	/* convert to ascii number and add commas */

   378

	p = endof(buf);

   379

	*--p = '\0';

   380

	j = 4;

   381

	do {

   382

		if (--j == 0) {

   383

			*--p = spec->separator;

   384

			j = 3;

   385

		}

   386

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

   387

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

   388

	buff = strecpy(buff, p, last);

   389

   390

	buff = strecpy(buff, multiplier, last);

   391

   392

	/* Add suffix part, folowing symbol_pos specification.

   393

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

   394

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

   395

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

   396

   397

	if (negative) {

   398

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

   399

		buff += Utf8Encode(buff, SCC_PREVIOUS_COLOUR);

   400

		*buff = '\0';

   401

	}

   402

   403

	return buff;

   404

}

   405

   406

static int DeterminePluralForm(int64 count)

   407

{

   408

	/* The absolute value determines plurality */

   409

	uint64 n = abs(count);

   410

   411

	switch (_langpack->plural_form) {

   412

		default:

   413

			NOT_REACHED();

   414

   415

		/* Two forms, singular used for one only

   416

		 * Used in:

   417

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

   418

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

   419

		case 0:

   420

			return n != 1;

   421

   422

		/* Only one form

   423

		 * Used in:

   424

		 *   Hungarian, Japanese, Korean, Turkish */

   425

		case 1:

   426

			return 0;

   427

   428

		/* Two forms, singular used for zero and one

   429

		 * Used in:

   430

		 *   French, Brazilian Portuguese */

   431

		case 2:

   432

			return n > 1;

   433

   434

		/* Three forms, special case for zero

   435

		 * Used in:

   436

		 *   Latvian */

   437

		case 3:

   438

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

   439

   440

		/* Three forms, special case for one and two

   441

		 * Used in:

   442

		 *   Gaelige (Irish) */

   443

		case 4:

   444

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

   445

   446

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

   447

		 * Used in:

   448

		 *   Lithuanian */

   449

		case 5:

   450

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

   451

   452

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

   453

		 * Used in:

   454

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

   455

		case 6:

   456

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

   457

   458

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

   459

		 * Used in:

   460

		 *   Polish */

   461

		case 7:

   462

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

   463

   464

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

   465

		 * Used in:

   466

		 *   Slovenian */

   467

		case 8:

   468

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

   469

   470

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

   471

		 * Used in:

   472

		 *   Icelandic */

   473

		case 9:

   474

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

   475

	}

   476

}

   477

   478

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

   479

{

   480

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

   481

	uint n = (byte)*b++;

   482

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

   483

   484

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

   485

		uint len = (byte)*b++;

   486

		if (i == form) {

   487

			mypos = pos;