1

/* $Id$ */

     2

     3

/** @file strings.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "currency.h"

     8

#include "functions.h"

     9

#include "string.h"

    10

#include "strings.h"

    11

#include "table/strings.h"

    12

#include "namegen.h"

    13

#include "station.h"

    14

#include "town.h"

    15

#include "vehicle.h"

    16

#include "news.h"

    17

#include "screenshot.h"

    18

#include "waypoint.h"

    19

#include "industry.h"

    20

#include "variables.h"

    21

#include "newgrf_text.h"

    22

#include "table/control_codes.h"

    23

#include "music.h"

    24

#include "date.h"

    25

#include "industry.h"

    26

#include "fileio.h"

    27

#include "helpers.hpp"

    28

#include "cargotype.h"

    29

#include "group.h"

    30

#include "debug.h"

    31

#include "newgrf_townname.h"

    32

#include "signs.h"

    33

#include "vehicle.h"

    34

#include "newgrf_engine.h"

    35

    36

/* for opendir/readdir/closedir */

    37

# include "fios.h"

    38

    39

DynamicLanguages _dynlang;

    40

char _userstring[128];

    41

uint64 _decode_parameters[20];

    42

    43

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

    44

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

    45

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

    46

    47

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

    48

    49

struct LanguagePack {

    50

	uint32 ident;       // 32-bits identifier

    51

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

    52

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

    53

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

    54

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

    55

	uint16 offsets[32]; // the offsets

    56

	byte plural_form;   // how to compute plural forms

    57

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

    58

	char data[VARARRAY_SIZE]; // list of strings

    59

};

    60

    61

static char **_langpack_offs;

    62

static LanguagePack *_langpack;

    63

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

    64

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

    65

    66

    67

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

    68

static inline int64 GetInt64(const int64 **argv)

    69

{

    70

	assert(argv);

    71

	return *(*argv)++;

    72

}

    73

    74

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

    75

static inline int32 GetInt32(const int64 **argv)

    76

{

    77

	return (int32)GetInt64(argv);

    78

}

    79

    80

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

    81

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

    82

{

    83

	const int64 *result;

    84

	assert(*argv);

    85

	result = *argv;

    86

	(*argv) += n;

    87

	return result;

    88

}

    89

    90

    91

#define NUM_BOUND_STRINGS 8

    92

    93

/* Array to hold the bound strings. */

    94

static const char *_bound_strings[NUM_BOUND_STRINGS];

    95

    96

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

    97

 * slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

    98

 * Which means that after NUM_BOUND_STRINGS calls to BindCString,

    99

 * the indices will be reused. */

   100

static int _bind_index;

   101

   102

static const char *GetStringPtr(StringID string)

   103

{

   104

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

   105

}

   106

   107

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

   108

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

   109

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

   110

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

   111

 * @param buffr

   112

 * @param string

   113

 * @param argv

   114

 * @param last

   115

 * @return a formatted string of char

   116

 */

   117

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

   118

{

   119

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

   120

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

   121

	char buff[512];

   122

   123

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

   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

			/* User defined name */

   138

			return GetName(buffr, index, last);

   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

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

   150

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

   151

   152

		case 29:

   153

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

   154

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

   155

   156

		case 30:

   157

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

   158

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

   159

   160

		case 31:

   161

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

   162

			 * but passed through verbatim. */

   163

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

   164

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

   165

			}

   166

   167

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

   168

	}

   169

   170

	if (index >= _langtab_num[tab]) {

   171

		error(

   172

			"!String 0x%X is invalid. "

   173

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

   174

		);

   175

	}

   176

   177

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

   178

}

   179

   180

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

   181

{

   182

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

   183

}

   184

   185

   186

char *InlineString(char *buf, StringID string)

   187

{

   188

	buf += Utf8Encode(buf, SCC_STRING_ID);

   189

	buf += Utf8Encode(buf, string);

   190

	return buf;

   191

}

   192

   193

   194

/**

   195

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

   196

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

   197

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

   198

 * @param str temp string to add

   199

 * @return the id of that temp string

   200

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

   201

 *       amount of 'user' bound strings by 2.

   202

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

   203

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

   204

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

   205

 */

   206

StringID BindCString(const char *str)

   207

{

   208

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

   209

	_bound_strings[idx] = str;

   210

	return idx + STR_SPEC_DYNSTRING;

   211

}

   212

   213

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

   214

 * @param n slot of the string

   215

 * @param str string to bind

   216

 */

   217

void SetDParamStr(uint n, const char *str)

   218

{

   219

	SetDParam(n, BindCString(str));

   220

}

   221

   222

void InjectDParam(int amount)

   223

{

   224

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

   225

}

   226

   227

static const uint32 _divisor_table[] = {

   228

	1000000000,

   229

	100000000,

   230

	10000000,

   231

	1000000,

   232

   233

	100000,

   234

	10000,

   235

	1000,

   236

	100,

   237

	10,

   238

	1

   239

};

   240

   241

// TODO

   242

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

   243

{

   244

	uint32 quot,divisor;

   245

	int i;

   246

	uint32 tot;

   247

	uint32 num;

   248

   249

	if (number < 0) {

   250

		*buff++ = '-';

   251

		number = -number;

   252

	}

   253

   254

	num = number;

   255

   256

	tot = 0;

   257

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

   258

		divisor = _divisor_table[i];

   259

		quot = 0;

   260

		if (num >= divisor) {

   261

			quot = num / _divisor_table[i];

   262

			num = num % _divisor_table[i];

   263

		}

   264

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

   265

			*buff++ = '0' + quot;

   266

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

   267

		}

   268

	}

   269

   270

	*buff = '\0';

   271

   272

	return buff;

   273

}

   274

   275

// TODO

   276

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

   277

{

   278

	uint32 quot,divisor;

   279

	int i;

   280

	uint32 tot;

   281

	uint32 num;

   282

   283

	if (number < 0) {

   284

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

   285

		number = -number;

   286

	}

   287

   288

	num = number;

   289

   290

	tot = 0;

   291

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

   292

		divisor = _divisor_table[i];

   293

		quot = 0;

   294

		if (num >= divisor) {

   295

			quot = num / _divisor_table[i];

   296

			num = num % _divisor_table[i];

   297

		}

   298

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

   299

			*buff++ = '0' + quot;

   300

		}

   301

	}

   302

   303

	*buff = '\0';

   304

   305

	return buff;

   306

}

   307

   308

   309

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

   310

{

   311

	YearMonthDay ymd;

   312

	ConvertDateToYMD(date, &ymd);

   313

   314

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

   315

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

   316

}

   317

   318

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

   319

{

   320

	YearMonthDay ymd;

   321

	ConvertDateToYMD(date, &ymd);

   322

   323

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

   324

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

   325

}

   326

   327

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

   328

{

   329

	YearMonthDay ymd;

   330

	ConvertDateToYMD(date, &ymd);

   331

   332

	char day[3];

   333

	char month[3];

   334

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

   335

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

   336

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

   337

   338

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

   339

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

   340

}

   341

   342

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

   343

{

   344

	const char* multiplier = "";

   345

	char buf[40];

   346

	char* p;

   347

	int j;

   348

   349

	/* Multiply by exchange rate, but do it safely. */

   350

	CommandCost cs(number);

   351

	cs.MultiplyCost(spec->rate);

   352

	number = cs.GetCost();

   353

   354

	/* convert from negative */

   355

	if (number < 0) {

   356

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

   357

		number = -number;

   358

	}

   359

   360

	/* Add prefix part, folowing symbol_pos specification.

   361

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

   362

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

   363

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

   364

   365

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

   366

	if (compact) {

   367

		if (number >= 1000000000) {

   368

			number = (number + 500000) / 1000000;

   369

			multiplier = "M";

   370

		} else if (number >= 1000000) {

   371

			number = (number + 500) / 1000;

   372

			multiplier = "k";

   373

		}

   374

	}

   375

   376

	/* convert to ascii number and add commas */

   377

	p = endof(buf);

   378

	*--p = '\0';

   379

	j = 4;

   380

	do {

   381

		if (--j == 0) {

   382

			*--p = spec->separator;

   383

			j = 3;

   384

		}

   385

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

   386

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

   387

	buff = strecpy(buff, p, last);

   388

   389

	buff = strecpy(buff, multiplier, last);

   390

   391

	/* Add suffix part, folowing symbol_pos specification.

   392

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

   393

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

   394

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

   395

   396

	return buff;

   397

}

   398

   399

static int DeterminePluralForm(int32 n)

   400

{

   401

	/* The absolute value determines plurality */

   402

	if (n < 0) n = -n;

   403

   404

	switch (_langpack->plural_form) {

   405

	/* Two forms, singular used for one only

   406

	 * Used in:

   407

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

   408

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

   409

	case 0:

   410

	default:

   411

		return n != 1;

   412

   413

	/* Only one form

   414

	 * Used in:

   415

	 *   Hungarian, Japanese, Korean, Turkish */

   416

	case 1:

   417

		return 0;

   418

   419

	/* Two forms, singular used for zero and one

   420

	 * Used in:

   421

	 *   French, Brazilian Portuguese */

   422

	case 2:

   423

		return n > 1;

   424

   425

	/* Three forms, special case for zero

   426

	 * Used in:

   427

	 *   Latvian */

   428

	case 3:

   429

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

   430

   431

	/* Three forms, special case for one and two

   432

	 * Used in:

   433

	 *   Gaelige (Irish) */

   434

	case 4:

   435

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

   436

   437

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

   438

	 * Used in:

   439

	 *   Lithuanian */

   440

	case 5:

   441

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

   442

   443

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

   444

	 * Used in:

   445

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

   446

	case 6:

   447

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

   448

   449

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

   450

	 * Used in:

   451

	 *   Polish */

   452

	case 7:

   453

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

   454

   455

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

   456

	 * Used in:

   457

	 *   Slovenian */

   458

	case 8:

   459

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

   460

	}

   461

}

   462

   463

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

   464

{

   465

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

   466

	uint n = (byte)*b++;

   467

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

   468

   469

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

   470

		uint len = (byte)*b++;

   471

		if (i == form) {

   472

			mypos = pos;

   473

			mylen = len;

   474

		}

   475

		pos += len;

   476

	}

   477

	*dstlen = mylen;

   478

	memcpy(dst, b + mypos, mylen);

   479

	return b + pos;

   480

}

   481

   482

struct Units {

   483

	int s_m;           ///< Multiplier for velocity

   484

	int s_s;           ///< Shift for velocity

   485

	StringID velocity; ///< String for velocity

   486

	int p_m;           ///< Multiplier for power

   487

	int p_s;           ///< Shift for power

   488

	StringID power;    ///< String for velocity

   489