1

/* $Id$ */

     2

     3

/** @file strings.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "currency.h"

     8

#include "string.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/control_codes.h"

    21

#include "music.h"

    22

#include "date.h"

    23

#include "industry.h"

    24

#include "fileio.h"

    25

#include "cargotype.h"

    26

#include "group.h"

    27

#include "debug.h"

    28

#include "newgrf_townname.h"

    29

#include "signs.h"

    30

#include "vehicle.h"

    31

#include "newgrf_engine.h"

    32

#include "spritecache.h"

    33

#include "fontcache.h"

    34

#include "gui.h"

    35

#include "strings_func.h"

    36

#include "functions.h"

    37

#include "core/endian_func.hpp"

    38

    39

/* for opendir/readdir/closedir */

    40

# include "fios.h"

    41

    42

DynamicLanguages _dynlang;

    43

char _userstring[128];

    44

uint64 _decode_parameters[20];

    45

    46

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

    47

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

    48

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

    49

    50

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

    51

    52

struct LanguagePack {

    53

	uint32 ident;       // 32-bits identifier

    54

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

    55

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

    56

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

    57

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

    58

	uint16 offsets[32]; // the offsets

    59

	byte plural_form;   // how to compute plural forms

    60

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

    61

	char data[VARARRAY_SIZE]; // list of strings

    62

};

    63

    64

static char **_langpack_offs;

    65

static LanguagePack *_langpack;

    66

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

    67

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

    68

    69

    70

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

    71

static inline int64 GetInt64(const int64 **argv)

    72

{

    73

	assert(argv);

    74

	return *(*argv)++;

    75

}

    76

    77

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

    78

static inline int32 GetInt32(const int64 **argv)

    79

{

    80

	return (int32)GetInt64(argv);

    81

}

    82

    83

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

    84

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

    85

{

    86

	const int64 *result;

    87

	assert(*argv);

    88

	result = *argv;

    89

	(*argv) += n;

    90

	return result;

    91

}

    92

    93

    94

#define NUM_BOUND_STRINGS 8

    95

    96

/* Array to hold the bound strings. */

    97

static const char *_bound_strings[NUM_BOUND_STRINGS];

    98

    99

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

   100

 * slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   101

 * Which means that after NUM_BOUND_STRINGS calls to BindCString,

   102

 * the indices will be reused. */

   103

static int _bind_index;

   104

   105

static const char *GetStringPtr(StringID string)

   106

{

   107

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

   108

}

   109

   110

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

   111

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

   112

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

   113

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

   114

 * @param buffr

   115

 * @param string

   116

 * @param argv

   117

 * @param last

   118

 * @return a formatted string of char

   119

 */

   120

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

   121

{

   122

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

   123

   124

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

   125

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

   126

	char buff[512];

   127

   128

	switch (tab) {

   129

		case 4:

   130

			if (index >= 0xC0)

   131

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

   132

			break;

   133

   134

		case 14:

   135

			if (index >= 0xE4)

   136

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

   137

			break;

   138

   139

		case 15:

   140

			/* User defined name */

   141

			return GetName(buffr, index, last);

   142

   143

		case 26:

   144

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

   145

			if (HasBit(index, 10)) {

   146

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

   147

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

   148

			}

   149

			break;

   150

   151

		case 28:

   152

			GetGRFString(buff, index, lastof(buff));

   153

			return FormatString(buffr, buff, argv, 0, last);

   154

   155

		case 29:

   156

			GetGRFString(buff, index + 0x800, lastof(buff));

   157

			return FormatString(buffr, buff, argv, 0, last);

   158

   159

		case 30:

   160

			GetGRFString(buff, index + 0x1000, lastof(buff));

   161

			return FormatString(buffr, buff, argv, 0, last);

   162

   163

		case 31:

   164

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

   165

			 * but passed through verbatim. */

   166

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

   167

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

   168

			}

   169

   170

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

   171

	}

   172

   173

	if (index >= _langtab_num[tab]) {

   174

		error(

   175

			"!String 0x%X is invalid. "

   176

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

   177

		);

   178

	}

   179

   180

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

   181

}

   182

   183

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

   184

{

   185

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

   186

}

   187

   188

   189

char *InlineString(char *buf, StringID string)

   190

{

   191

	buf += Utf8Encode(buf, SCC_STRING_ID);

   192

	buf += Utf8Encode(buf, string);

   193

	return buf;

   194

}

   195

   196

   197

/**

   198

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

   199

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

   200

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

   201

 * @param str temp string to add

   202

 * @return the id of that temp string

   203

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

   204

 *       amount of 'user' bound strings by 2.

   205

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

   206

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

   207

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

   208

 */

   209

StringID BindCString(const char *str)

   210

{

   211

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

   212

	_bound_strings[idx] = str;

   213

	return idx + STR_SPEC_DYNSTRING;

   214

}

   215

   216

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

   217

 * @param n slot of the string

   218

 * @param str string to bind

   219

 */

   220

void SetDParamStr(uint n, const char *str)

   221

{

   222

	SetDParam(n, BindCString(str));

   223

}

   224

   225

void InjectDParam(int amount)

   226

{

   227

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

   228

}

   229

   230

// TODO

   231

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

   232

{

   233

	uint64 divisor = 10000000000000000000ULL;

   234

	uint64 quot;

   235

	int i;

   236

	uint64 tot;

   237

	uint64 num;

   238

   239

	if (number < 0) {

   240

		*buff++ = '-';

   241

		number = -number;

   242

	}

   243

   244

	num = number;

   245

   246

	tot = 0;

   247

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

   248

		quot = 0;

   249

		if (num >= divisor) {

   250

			quot = num / divisor;

   251

			num = num % divisor;

   252

		}

   253

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

   254

			*buff++ = '0' + quot;

   255

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

   256

		}

   257

   258

		divisor /= 10;

   259

	}

   260

   261

	*buff = '\0';

   262

   263

	return buff;

   264

}

   265

   266

// TODO

   267

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

   268

{

   269

	uint64 divisor = 10000000000000000000ULL;

   270

	uint64 quot;

   271

	int i;

   272

	uint64 tot;

   273

	uint64 num;

   274

   275

	if (number < 0) {

   276

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

   277

		number = -number;

   278

	}

   279

   280

	num = number;

   281

   282

	tot = 0;

   283

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

   284

		quot = 0;

   285

		if (num >= divisor) {

   286

			quot = num / divisor;

   287

			num = num % divisor;

   288

		}

   289

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

   290

			*buff++ = '0' + quot;

   291

		}

   292

   293

		divisor /= 10;

   294

	}

   295

   296

	*buff = '\0';

   297

   298

	return buff;

   299

}

   300

   301

   302

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

   303

{

   304

	YearMonthDay ymd;

   305

	ConvertDateToYMD(date, &ymd);

   306

   307

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

   308

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

   309

}

   310

   311

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

   312

{

   313

	YearMonthDay ymd;

   314

	ConvertDateToYMD(date, &ymd);

   315

   316

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

   317

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

   318

}

   319

   320

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

   321

{

   322

	YearMonthDay ymd;

   323

	ConvertDateToYMD(date, &ymd);

   324

   325

	char day[3];

   326

	char month[3];

   327

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

   328

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

   329

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

   330

   331

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

   332

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

   333

}

   334

   335

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

   336

{

   337

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

   338

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

   339

	bool negative = number < 0;

   340

	const char *multiplier = "";

   341

	char buf[40];

   342

	char *p;

   343

	int j;

   344

   345

	number *= spec->rate;

   346

   347

	/* convert from negative */

   348

	if (number < 0) {

   349

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

   350

		buff += Utf8Encode(buff, SCC_RED);

   351

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

   352

		number = -number;

   353

	}

   354

   355

	/* Add prefix part, folowing symbol_pos specification.

   356

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

   357

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

   358

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

   359

   360

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

   361

	if (compact) {

   362

		if (number >= 1000000000) {

   363

			number = (number + 500000) / 1000000;

   364

			multiplier = "M";

   365

		} else if (number >= 1000000) {

   366

			number = (number + 500) / 1000;

   367

			multiplier = "k";

   368

		}

   369

	}

   370

   371

	/* convert to ascii number and add commas */

   372

	p = endof(buf);

   373

	*--p = '\0';

   374

	j = 4;

   375

	do {

   376

		if (--j == 0) {

   377

			*--p = spec->separator;

   378

			j = 3;

   379

		}

   380

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

   381

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

   382

	buff = strecpy(buff, p, last);

   383

   384

	buff = strecpy(buff, multiplier, last);

   385

   386

	/* Add suffix part, folowing symbol_pos specification.

   387

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

   388

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

   389

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

   390

   391

	if (negative) {

   392

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

   393

		buff += Utf8Encode(buff, SCC_PREVIOUS_COLOUR);

   394

		*buff = '\0';

   395

	}

   396

   397

	return buff;

   398

}

   399

   400

static int DeterminePluralForm(int64 cnt)

   401

{

   402

	uint64 n = cnt;

   403

	/* The absolute value determines plurality */

   404

	if (cnt < 0) n = -cnt;

   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

   471

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

   472

		uint len = (byte)*b++;

   473

		if (i == form) {

   474

			mypos = pos;

   475

			mylen = len;

   476

		}

   477

		pos += len;

   478

	}

   479

	*dstlen = mylen;

   480

	memcpy(dst, b + mypos, mylen);

   481

	return b + pos;

   482

}

   483

   484

struct Units {

   485

	int s_m;           ///< Multiplier for velocity