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 "helpers.hpp"

    27

#include "cargotype.h"

    28

    29

/* for opendir/readdir/closedir */

    30

# include "fios.h"

    31

    32

DynamicLanguages _dynlang;

    33

char _userstring[128];

    34

    35

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

    36

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

    37

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

    38

    39

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

    40

    41

struct LanguagePack {

    42

	uint32 ident;       // 32-bits identifier

    43

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

    44

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

    45

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

    46

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

    47

	uint16 offsets[32]; // the offsets

    48

	byte plural_form;   // how to compute plural forms

    49

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

    50

	char data[VARARRAY_SIZE]; // list of strings

    51

};

    52

    53

static char **_langpack_offs;

    54

static LanguagePack *_langpack;

    55

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

    56

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

    57

    58

    59

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

    60

static inline int64 GetInt64(const int32 **argv)

    61

{

    62

	int64 result;

    63

    64

	assert(argv);

    65

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

    67

	return result;

    68

}

    69

    70

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

    71

static inline int32 GetInt32(const int32 **argv)

    72

{

    73

	assert(argv);

    74

	return *(*argv)++;

    75

}

    76

    77

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

    78

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

    79

{

    80

	const int32 *result;

    81

	assert(*argv);

    82

	result = *argv;

    83

	(*argv) += n;

    84

	return result;

    85

}

    86

    87

    88

#define NUM_BOUND_STRINGS 8

    89

    90

/* Array to hold the bound strings. */

    91

static const char *_bound_strings[NUM_BOUND_STRINGS];

    92

    93

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

    94

 * slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

    95

 * Which means that after NUM_BOUND_STRINGS calls to BindCString,

    96

 * the indices will be reused. */

    97

static int _bind_index;

    98

    99

static const char *GetStringPtr(StringID string)

   100

{

   101

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

   102

}

   103

   104

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

   105

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

   106

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

   107

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

   108

 * @param buffr

   109

 * @param string

   110

 * @param argv

   111

 * @param last

   112

 * @return a formatted string of char

   113

 */

   114

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

   115

{

   116

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

   117

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

   118

	char buff[512];

   119

   120

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

   121

   122

	switch (tab) {

   123

		case 4:

   124

			if (index >= 0xC0)

   125

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

   126

			break;

   127

   128

		case 14:

   129

			if (index >= 0xE4)

   130

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

   131

			break;

   132

   133

		case 15:

   134

			/* User defined name */

   135

			return GetName(buffr, index, last);

   136

   137

		case 26:

   138

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

   139

			if (HASBIT(index, 10)) {

   140

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

   141

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

   142

			}

   143

			break;

   144

   145

		case 28:

   146

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

   147

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

   148

   149

		case 29:

   150

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

   151

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

   152

   153

		case 30:

   154

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

   155

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

   156

   157

		case 31:

   158

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

   159

			 * but passed through verbatim. */

   160

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

   161

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

   162

			}

   163

   164

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

   165

	}

   166

   167

	if (index >= _langtab_num[tab]) {

   168

		error(

   169

			"!String 0x%X is invalid. "

   170

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

   171

		);

   172

	}

   173

   174

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

   175

}

   176

   177

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

   178

{

   179

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

   180

}

   181

   182

   183

char *InlineString(char *buf, StringID string)

   184

{

   185

	buf += Utf8Encode(buf, SCC_STRING_ID);

   186

	buf += Utf8Encode(buf, string);

   187

	return buf;

   188

}

   189

   190

   191

/**

   192

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

   193

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

   194

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

   195

 * @param str temp string to add

   196

 * @return the id of that temp string

   197

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

   198

 *       amount of 'user' bound strings by 2.

   199

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

   200

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

   201

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

   202

 */

   203

StringID BindCString(const char *str)

   204

{

   205

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

   206

	_bound_strings[idx] = str;

   207

	return idx + STR_SPEC_DYNSTRING;

   208

}

   209

   210

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

   211

 * @param n slot of the string

   212

 * @param str string to bind

   213

 */

   214

void SetDParamStr(uint n, const char *str)

   215

{

   216

	SetDParam(n, BindCString(str));

   217

}

   218

   219

void InjectDParam(int amount)

   220

{

   221

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

   222

}

   223

   224

static const uint32 _divisor_table[] = {

   225

	1000000000,

   226

	100000000,

   227

	10000000,

   228

	1000000,

   229

   230

	100000,

   231

	10000,

   232

	1000,

   233

	100,

   234

	10,

   235

	1

   236

};

   237

   238

// TODO

   239

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

   240

{

   241

	uint32 quot,divisor;

   242

	int i;

   243

	uint32 tot;

   244

	uint32 num;

   245

   246

	if (number < 0) {

   247

		*buff++ = '-';

   248

		number = -number;

   249

	}

   250

   251

	num = number;

   252

   253

	tot = 0;

   254

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

   255

		divisor = _divisor_table[i];

   256

		quot = 0;

   257

		if (num >= divisor) {

   258

			quot = num / _divisor_table[i];

   259

			num = num % _divisor_table[i];

   260

		}

   261

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

   262

			*buff++ = '0' + quot;

   263

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

   264

		}

   265

	}

   266

   267

	*buff = '\0';

   268

   269

	return buff;

   270

}

   271

   272

// TODO

   273

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

   274

{

   275

	uint32 quot,divisor;

   276

	int i;

   277

	uint32 tot;

   278

	uint32 num;

   279

   280

	if (number < 0) {

   281

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

   282

		number = -number;

   283

	}

   284

   285

	num = number;

   286

   287

	tot = 0;

   288

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

   289

		divisor = _divisor_table[i];

   290

		quot = 0;

   291

		if (num >= divisor) {

   292

			quot = num / _divisor_table[i];

   293

			num = num % _divisor_table[i];

   294

		}

   295

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

   296

			*buff++ = '0' + quot;

   297

		}

   298

	}

   299

   300

	*buff = '\0';

   301

   302

	return buff;

   303

}

   304

   305

   306

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

   307

{

   308

	YearMonthDay ymd;

   309

	ConvertDateToYMD(date, &ymd);

   310

   311

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

   312

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

   313

}

   314

   315

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

   316

{

   317

	YearMonthDay ymd;

   318

	ConvertDateToYMD(date, &ymd);

   319

   320

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

   321

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

   322

}

   323

   324

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

   325

{

   326

	YearMonthDay ymd;

   327

	ConvertDateToYMD(date, &ymd);

   328

   329

	char day[3];

   330

	char month[3];

   331

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

   332

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

   333

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

   334

   335

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

   336

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

   337

}

   338

   339

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

   340

{

   341

	const char* multiplier = "";

   342

	char buf[40];

   343

	char* p;

   344

	int j;

   345

   346

	/* multiply by exchange rate */

   347

	number *= spec->rate;

   348

   349

	/* convert from negative */

   350

	if (number < 0) {

   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' + 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

	return buff;

   392

}

   393

   394

static int DeterminePluralForm(int32 n)

   395

{

   396

	/* The absolute value determines plurality */

   397

	if (n < 0) n = -n;

   398

   399

	switch (_langpack->plural_form) {

   400

	/* Two forms, singular used for one only

   401

	 * Used in:

   402

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

   403

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

   404

	case 0:

   405

	default:

   406

		return n != 1;

   407

   408

	/* Only one form

   409

	 * Used in:

   410

	 *   Hungarian, Japanese, Korean, Turkish */

   411

	case 1:

   412

		return 0;

   413

   414

	/* Two forms, singular used for zero and one

   415

	 * Used in:

   416

	 *   French, Brazilian Portuguese */

   417

	case 2:

   418

		return n > 1;

   419

   420

	/* Three forms, special case for zero

   421

	 * Used in:

   422

	 *   Latvian */

   423

	case 3:

   425

   426

	/* Three forms, special case for one and two

   427

	 * Used in:

   428

	 *   Gaelige (Irish) */

   429

	case 4:

   431

   432

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

   433

	 * Used in:

   434

	 *   Lithuanian */

   435

	case 5:

   437

   438

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

   439

	 * Used in:

   440

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

   441

	case 6:

   443

   444

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

   445

	 * Used in:

   446

	 *   Polish */

   447

	case 7:

   449

   450

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

   451

	 * Used in:

   452

	 *   Slovenian */

   453

	case 8:

   455

	}

   456

}

   457

   458

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

   459

{

   460

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

   461

	uint n = (byte)*b++;

   463

   464

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

   465

		uint len = (byte)*b++;

   466

		if (i == form) {

   467

			mypos = pos;

   468

			mylen = len;

   469

		}

   470

		pos += len;

   471

	}

   472

	*dstlen = mylen;

   473

	memcpy(dst, b + mypos, mylen);

   474

	return b + pos;

   475

}

   476

   477

struct Units {

   478

	int s_m;           ///< Multiplier for velocity

   479

	int s_s;           ///< Shift for velocity

   480

	StringID velocity; ///< String for velocity

   481

	int p_m;           ///< Multiplier for power

   482

	int p_s;           ///< Shift for power

   483

	StringID power;    ///< String for velocity

   484

	int w_m;           ///< Multiplier for weight

   485

	int w_s;           ///< Shift for weight

   486

	StringID s_weight; ///< Short string for weight

   487

	StringID l_weight; ///< Long string for weight

   488

	int v_m;           ///< Multiplier for volume

   489

	int v_s;           ///< Shift for volume

   490

	StringID s_volume; ///< Short string for volume