1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "currency.h"

     6

#include "functions.h"

     7

#include "string.h"

     8

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

    25

#include "cargotype.h"

    26

    27

/* for opendir/readdir/closedir */

    28

# include "fios.h"

    29

    30

char _userstring[128];

    31

    32

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

    33

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

    34

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

    35

    36

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

    37

    38

typedef struct LanguagePack {

    39

	uint32 ident;

    40

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

    41

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

    42

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

    43

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

    44

	uint16 offsets[32]; // the offsets

    45

	byte plural_form;   // how to compute plural forms

    46

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

    47

	char data[VARARRAY_SIZE];

    48

} LanguagePack;

    49

    50

static char **_langpack_offs;

    51

static LanguagePack *_langpack;

    52

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

    53

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

    54

    55

    56

// Read an int64 from the argv array.

    57

static inline int64 GetInt64(const int32 **argv)

    58

{

    59

	int64 result;

    60

    61

	assert(argv);

    62

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

    63

	(*argv)+=2;

    64

	return result;

    65

}

    66

    67

// Read an int32 from the argv array.

    68

static inline int32 GetInt32(const int32 **argv)

    69

{

    70

	assert(argv);

    71

	return *(*argv)++;

    72

}

    73

    74

// Read an array from the argv array.

    75

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

    76

{

    77

	const int32 *result;

    78

	assert(*argv);

    79

	result = *argv;

    80

	(*argv) += n;

    81

	return result;

    82

}

    83

    84

    85

#define NUM_BOUND_STRINGS 8

    86

    87

// Array to hold the bound strings.

    88

static const char *_bound_strings[NUM_BOUND_STRINGS];

    89

    90

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

    91

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

    92

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

    93

// the indices will be reused.

    94

static int _bind_index;

    95

    96

static const char *GetStringPtr(StringID string)

    97

{

    98

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

    99

}

   100

   101

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

   102

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

   103

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

   104

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

   105

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

   106

{

   107

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

   108

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

   109

	char buff[512];

   110

   111

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

   112

   113

	switch (tab) {

   114

		case 4:

   115

			if (index >= 0xC0)

   116

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

   117

			break;

   118

   119

		case 14:

   120

			if (index >= 0xE4)

   121

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

   122

			break;

   123

   124

		// User defined name

   125

		case 15:

   126

			return GetName(buffr, index, last);

   127

   128

		case 26:

   129

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

   130

			if (HASBIT(index, 10)) {

   131

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

   132

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

   133

			}

   134

			break;

   135

   136

		case 28:

   137

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

   138

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

   139

   140

		case 29:

   141

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

   142

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

   143

   144

		case 30:

   145

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

   146

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

   147

   148

		case 31:

   149

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

   150

			// but passed through verbatim.

   151

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

   152

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

   153

			}

   154

   155

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

   156

	}

   157

   158

	if (index >= _langtab_num[tab]) {

   159

		error(

   160

			"!String 0x%X is invalid. "

   161

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

   162

		);

   163

	}

   164

   165

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

   166

}

   167

   168

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

   169

{

   170

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

   171

}

   172

   173

   174

char *InlineString(char *buf, StringID string)

   175

{

   176

	buf += Utf8Encode(buf, SCC_STRING_ID);

   177

	buf += Utf8Encode(buf, string);

   178

	return buf;

   179

}

   180

   181

   182

/**

   183

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

   184

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

   185

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

   186

 *

   187

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

   188

 *       amount of 'user' bound strings by 2.

   189

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

   190

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

   191

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

   192

 */

   193

StringID BindCString(const char *str)

   194

{

   195

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

   196

	_bound_strings[idx] = str;

   197

	return idx + STR_SPEC_DYNSTRING;

   198

}

   199

   200

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

   201

void SetDParamStr(uint n, const char *str)

   202

{

   203

	SetDParam(n, BindCString(str));

   204

}

   205

   206

void InjectDParam(int amount)

   207

{

   208

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

   209

}

   210

   211

static const uint32 _divisor_table[] = {

   212

	1000000000,

   213

	100000000,

   214

	10000000,

   215

	1000000,

   216

   217

	100000,

   218

	10000,

   219

	1000,

   220

	100,

   221

	10,

   222

	1

   223

};

   224

   225

// TODO

   226

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

   227

{

   228

	uint32 quot,divisor;

   229

	int i;

   230

	uint32 tot;

   231

	uint32 num;

   232

   233

	if (number < 0) {

   234

		*buff++ = '-';

   235

		number = -number;

   236

	}

   237

   238

	num = number;

   239

   240

	tot = 0;

   241

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

   242

		divisor = _divisor_table[i];

   243

		quot = 0;

   244

		if (num >= divisor) {

   245

			quot = num / _divisor_table[i];

   246

			num = num % _divisor_table[i];

   247

		}

   248

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

   249

			*buff++ = '0' + quot;

   250

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

   251

		}

   252

	}

   253

   254

	*buff = '\0';

   255

   256

	return buff;

   257

}

   258

   259

// TODO

   260

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

   261

{

   262

	uint32 quot,divisor;

   263

	int i;

   264

	uint32 tot;

   265

	uint32 num;

   266

   267

	if (number < 0) {

   268

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

   269

		number = -number;

   270

	}

   271

   272

	num = number;

   273

   274

	tot = 0;

   275

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

   276

		divisor = _divisor_table[i];

   277

		quot = 0;

   278

		if (num >= divisor) {

   279

			quot = num / _divisor_table[i];

   280

			num = num % _divisor_table[i];

   281

		}

   282

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

   283

			*buff++ = '0' + quot;

   284

		}

   285

	}

   286

   287

	*buff = '\0';

   288

   289

	return buff;

   290

}

   291

   292

   293

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

   294

{

   295

	YearMonthDay ymd;

   296

	ConvertDateToYMD(date, &ymd);

   297

   298

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

   299

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

   300

}

   301

   302

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

   303

{

   304

	YearMonthDay ymd;

   305

	ConvertDateToYMD(date, &ymd);

   306

   307

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

   308

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

   309

}

   310

   311

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

   312

{

   313

	YearMonthDay ymd;

   314

	ConvertDateToYMD(date, &ymd);

   315

   316

	char day[3];

   317

	char month[3];

   318

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

   319

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

   320

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

   321

   322

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

   323

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

   324

}

   325

   326

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

   327

{

   328

	const char* multiplier = "";

   329

	char buf[40];

   330

	char* p;

   331

	int j;

   332

   333

	// multiply by exchange rate

   334

	number *= spec->rate;

   335

   336

	// convert from negative

   337

	if (number < 0) {

   338

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

   339

		number = -number;

   340

	}

   341

   342

	/* Add prefix part, folowing symbol_pos specification.

   343

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

   344

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

   345

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

   346

   347

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

   348

	if (compact) {

   349

		if (number >= 1000000000) {

   350

			number = (number + 500000) / 1000000;

   351

			multiplier = "M";

   352

		} else if (number >= 1000000) {

   353

			number = (number + 500) / 1000;

   354

			multiplier = "k";

   355

		}

   356

	}

   357

   358

	// convert to ascii number and add commas

   359

	p = endof(buf);

   360

	*--p = '\0';

   361

	j = 4;

   362

	do {

   363

		if (--j == 0) {

   364

			*--p = spec->separator;

   365

			j = 3;

   366

		}

   367

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

   368

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

   369

	buff = strecpy(buff, p, last);

   370

   371

	buff = strecpy(buff, multiplier, last);

   372

   373

	/* Add suffix part, folowing symbol_pos specification.

   374

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

   375

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

   376

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

   377

   378

	return buff;

   379

}

   380

   381

static int DeterminePluralForm(int32 n)

   382

{

   383

	// The absolute value determines plurality

   384

	if (n < 0) n = -n;

   385

   386

	switch (_langpack->plural_form) {

   387

	// Two forms, singular used for one only

   388

	// Used in:

   389

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

   390

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

   391

	case 0:

   392

	default:

   393

		return n != 1;

   394

   395

	// Only one form

   396

	// Used in:

   397

	//   Hungarian, Japanese, Korean, Turkish

   398

	case 1:

   399

		return 0;

   400

   401

	// Two forms, singular used for zero and one

   402

	// Used in:

   403

	//   French, Brazilian Portuguese

   404

	case 2:

   405

		return n > 1;

   406

   407

	// Three forms, special case for zero

   408

	// Used in:

   409

	//   Latvian

   410

	case 3:

   411

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

   412

   413

	// Three forms, special case for one and two

   414

	// Used in:

   415

	//   Gaelige (Irish)

   416

	case 4:

   417

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

   418

   419

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

   420

	// Used in:

   421

	//   Lithuanian

   422

	case 5:

   423

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

   424

   425

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

   426

	// Used in:

   427

	//   Croatian, Czech, Russian, Slovak, Ukrainian

   428

	case 6:

   429

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

   430

   431

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

   432

	// Used in:

   433

	//   Polish

   434

	case 7:

   435

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

   436

   437

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

   438

	// Used in:

   439

	//   Slovenian

   440

	case 8:

   441

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

   442

	}

   443

}

   444

   445

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

   446

{

   447

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

   448

	uint n = (byte)*b++;

   449

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

   450

   451

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

   452

		uint len = (byte)*b++;

   453

		if (i == form) {

   454

			mypos = pos;

   455

			mylen = len;

   456

		}

   457

		pos += len;

   458

	}

   459

	*dstlen = mylen;

   460

	memcpy(dst, b + mypos, mylen);

   461

	return b + pos;

   462

}

   463

   464

typedef struct Units {

   465

	int s_m;           ///< Multiplier for velocity

   466

	int s_s;           ///< Shift for velocity

   467

	StringID velocity; ///< String for velocity

   468

	int p_m;           ///< Multiplier for power

   469

	int p_s;           ///< Shift for power

   470

	StringID power;    ///< String for velocity

   471

	int w_m;           ///< Multiplier for weight

   472

	int w_s;           ///< Shift for weight

   473

	StringID s_weight; ///< Short string for weight

   474

	StringID l_weight; ///< Long string for weight

   475

	int v_m;           ///< Multiplier for volume

   476

	int v_s;           ///< Shift for volume

   477

	StringID s_volume; ///< Short string for volume

   478

	StringID l_volume; ///< Long string for volume

   479

	int f_m;           ///< Multiplier for force

   480

	int f_s;           ///< Shift for force

   481

	StringID force;    ///< String for force

   482

} Units;

   483

   484

/* Unit conversions */

   485

static const Units units[] = {

   486

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

   487

		   1,  0, STR_UNITS_VELOCITY_IMPERIAL,

   488

		   1,  0, STR_UNITS_POWER_IMPERIAL,

   489

		   1,  0, STR_UNITS_WEIGHT_SHORT_METRIC, STR_UNITS_WEIGHT_LONG_METRIC,

   490

		1000,  0, STR_UNITS_VOLUME_SHORT_METRIC, STR_UNITS_VOLUME_LONG_METRIC,

   491

		   1,  0, STR_UNITS_FORCE_SI,

   492

	},

   493

	{ // Metric (km/h, hp, metric ton, litre, kN)