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/landscape_const.h"

    21

#include "table/control_codes.h"

    22

#include "music.h"

    23

#include "date.h"

    24

#include "industry.h"

    25

    26

/* for opendir/readdir/closedir */

    27

# include "fios.h"

    28

    29

char _userstring[128];

    30

    31

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

    32

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

    33

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

    34

    35

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

    36

    37

typedef struct LanguagePack {

    38

	uint32 ident;

    39

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

    40

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

    41

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

    42

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

    43

	uint16 offsets[32]; // the offsets

    44

	byte plural_form;   // how to compute plural forms

    45

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

    46

	char data[VARARRAY_SIZE];

    47

} LanguagePack;

    48

    49

static char **_langpack_offs;

    50

static LanguagePack *_langpack;

    51

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

    52

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

    53

    54

static const StringID _cargo_string_list[NUM_LANDSCAPE][NUM_CARGO] = {

    55

	{ /* LT_NORMAL */

    56

		STR_PASSENGERS,

    57

		STR_TONS,

    58

		STR_BAGS,

    59

		STR_LITERS,

    60

		STR_ITEMS,

    61

		STR_CRATES,

    62

		STR_TONS,

    63

		STR_TONS,

    64

		STR_TONS,

    65

		STR_TONS,

    66

		STR_BAGS,

    67

		STR_RES_OTHER

    68

	},

    69

    70

	{ /* LT_HILLY */

    71

		STR_PASSENGERS,

    72

		STR_TONS,

    73

		STR_BAGS,

    74

		STR_LITERS,

    75

		STR_ITEMS,

    76

		STR_CRATES,

    77

		STR_TONS,

    78

		STR_TONS,

    79

		STR_RES_OTHER,

    80

		STR_TONS,

    81

		STR_BAGS,

    82

		STR_TONS

    83

	},

    84

    85

	{ /* LT_DESERT */

    86

		STR_PASSENGERS,

    87

		STR_LITERS,

    88

		STR_BAGS,

    89

		STR_LITERS,

    90

		STR_TONS,

    91

		STR_CRATES,

    92

		STR_TONS,

    93

		STR_TONS,

    94

		STR_TONS,

    95

		STR_LITERS,

    96

		STR_BAGS,

    97

		STR_TONS

    98

	},

    99

   100

	{ /* LT_CANDY */

   101

		STR_PASSENGERS,

   102

		STR_TONS,

   103

		STR_BAGS,

   104

		STR_NOTHING,

   105

		STR_NOTHING,

   106

		STR_TONS,

   107

		STR_TONS,

   108

		STR_LITERS,

   109

		STR_TONS,

   110

		STR_NOTHING,

   111

		STR_LITERS,

   112

		STR_NOTHING

   113

	}

   114

};

   115

   116

   117

// Read an int64 from the argv array.

   118

static inline int64 GetInt64(const int32 **argv)

   119

{

   120

	int64 result;

   121

   122

	assert(argv);

   123

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

   124

	(*argv)+=2;

   125

	return result;

   126

}

   127

   128

// Read an int32 from the argv array.

   129

static inline int32 GetInt32(const int32 **argv)

   130

{

   131

	assert(argv);

   132

	return *(*argv)++;

   133

}

   134

   135

// Read an array from the argv array.

   136

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

   137

{

   138

	const int32 *result;

   139

	assert(*argv);

   140

	result = *argv;

   141

	(*argv) += n;

   142

	return result;

   143

}

   144

   145

   146

#define NUM_BOUND_STRINGS 8

   147

   148

// Array to hold the bound strings.

   149

static const char *_bound_strings[NUM_BOUND_STRINGS];

   150

   151

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

   152

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   153

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

   154

// the indices will be reused.

   155

static int _bind_index;

   156

   157

static const char *GetStringPtr(StringID string)

   158

{

   159

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

   160

}

   161

   162

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

   163

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

   164

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

   165

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

   166

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

   167

{

   168

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

   169

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

   170

	char buff[512];

   171

   172

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

   173

   174

	switch (tab) {

   175

		case 4:

   176

			if (index >= 0xC0)

   177

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

   178

			break;

   179

   180

		case 14:

   181

			if (index >= 0xE4)

   182

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

   183

			break;

   184

   185

		// User defined name

   186

		case 15:

   187

			return GetName(buffr, index, last);

   188

   189

		case 26:

   190

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

   191

			if (HASBIT(index, 10)) {

   192

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

   193

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

   194

			}

   195

			break;

   196

   197

		case 28:

   198

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

   199

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

   200

   201

		case 29:

   202

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

   203

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

   204

   205

		case 30:

   206

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

   207

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

   208

   209

		case 31:

   210

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

   211

			// but passed through verbatim.

   212

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

   213

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

   214

			}

   215

   216

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

   217

	}

   218

   219

	if (index >= _langtab_num[tab]) {

   220

		error(

   221

			"!String 0x%X is invalid. "

   222

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

   223

		);

   224

	}

   225

   226

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

   227

}

   228

   229

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

   230

{

   231

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

   232

}

   233

   234

   235

char *InlineString(char *buf, StringID string)

   236

{

   237

	buf += Utf8Encode(buf, SCC_STRING_ID);

   238

	buf += Utf8Encode(buf, string);

   239

	return buf;

   240

}

   241

   242

   243

/**

   244

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

   245

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

   246

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

   247

 *

   248

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

   249

 *       amount of 'user' bound strings by 2.

   250

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

   251

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

   252

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

   253

 */

   254

StringID BindCString(const char *str)

   255

{

   256

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

   257

	_bound_strings[idx] = str;

   258

	return idx + STR_SPEC_DYNSTRING;

   259

}

   260

   261

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

   262

void SetDParamStr(uint n, const char *str)

   263

{

   264

	SetDParam(n, BindCString(str));

   265

}

   266

   267

void InjectDParam(int amount)

   268

{

   269

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

   270

}

   271

   272

static const uint32 _divisor_table[] = {

   273

	1000000000,

   274

	100000000,

   275

	10000000,

   276

	1000000,

   277

   278

	100000,

   279

	10000,

   280

	1000,

   281

	100,

   282

	10,

   283

	1

   284

};

   285

   286

// TODO

   287

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

   288

{

   289

	uint32 quot,divisor;

   290

	int i;

   291

	uint32 tot;

   292

	uint32 num;

   293

   294

	if (number < 0) {

   295

		*buff++ = '-';

   296

		number = -number;

   297

	}

   298

   299

	num = number;

   300

   301

	tot = 0;

   302

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

   303

		divisor = _divisor_table[i];

   304

		quot = 0;

   305

		if (num >= divisor) {

   306

			quot = num / _divisor_table[i];

   307

			num = num % _divisor_table[i];

   308

		}

   309

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

   310

			*buff++ = '0' + quot;

   311

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

   312

		}

   313

	}

   314

   315

	*buff = '\0';

   316

   317

	return buff;

   318

}

   319

   320

// TODO

   321

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

   322

{

   323

	uint32 quot,divisor;

   324

	int i;

   325

	uint32 tot;

   326

	uint32 num;

   327

   328

	if (number < 0) {

   329

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

   330

		number = -number;

   331

	}

   332

   333

	num = number;

   334

   335

	tot = 0;

   336

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

   337

		divisor = _divisor_table[i];

   338

		quot = 0;

   339

		if (num >= divisor) {

   340

			quot = num / _divisor_table[i];

   341

			num = num % _divisor_table[i];

   342

		}

   343

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

   344

			*buff++ = '0' + quot;

   345

		}

   346

	}

   347

   348

	*buff = '\0';

   349

   350

	return buff;

   351

}

   352

   353

   354

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

   355

{

   356

	YearMonthDay ymd;

   357

	int32 args[3];

   358

	ConvertDateToYMD(date, &ymd);

   359

   360

	args[0] = ymd.day + STR_01AC_1ST - 1;

   361

	args[1] = STR_0162_JAN + ymd.month;

   362

	args[2] = ymd.year;

   363

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

   364

}

   365

   366

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

   367

{

   368

	YearMonthDay ymd;

   369

	int32 args[2];

   370

	ConvertDateToYMD(date, &ymd);

   371

   372

	args[0] = STR_MONTH_JAN + ymd.month;

   373

	args[1] = ymd.year;

   374

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

   375

}

   376

   377

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

   378

{

   379

	YearMonthDay ymd;

   380

	int32 args[3];

   381

	char day[3];

   382

	char month[3];

   383

	ConvertDateToYMD(date, &ymd);

   384

   385

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

   386

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

   387

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

   388

   389

	args[0] = BindCString(day);

   390

	args[1] = BindCString(month);

   391

	args[2] = ymd.year;

   392

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

   393

}

   394

   395

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

   396

{

   397

	const char* multiplier = "";

   398

	char buf[40];

   399

	char* p;

   400

	int j;

   401

   402

	// multiply by exchange rate

   403

	number *= spec->rate;

   404

   405

	// convert from negative

   406

	if (number < 0) {

   407

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

   408

		number = -number;

   409

	}

   410

   411

	/* Add prefix part, folowing symbol_pos specification.

   412

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

   413

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

   414

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

   415

   416

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

   417

	if (compact) {

   418

		if (number >= 1000000000) {

   419

			number = (number + 500000) / 1000000;

   420

			multiplier = "M";

   421

		} else if (number >= 1000000) {

   422

			number = (number + 500) / 1000;

   423

			multiplier = "k";

   424

		}

   425

	}

   426

   427

	// convert to ascii number and add commas

   428

	p = endof(buf);

   429

	*--p = '\0';

   430

	j = 4;

   431

	do {

   432

		if (--j == 0) {

   433

			*--p = spec->separator;

   434

			j = 3;

   435

		}

   436

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

   437

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

   438

	buff = strecpy(buff, p, last);

   439

   440

	buff = strecpy(buff, multiplier, last);

   441

   442

	/* Add suffix part, folowing symbol_pos specification.

   443

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

   444

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

   445

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

   446

   447

	return buff;

   448

}

   449

   450

static int DeterminePluralForm(int32 n)

   451

{

   452

	// The absolute value determines plurality

   453

	if (n < 0) n = -n;

   454

   455

	switch (_langpack->plural_form) {

   456

	// Two forms, singular used for one only

   457

	// Used in:

   458

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

   459

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

   460

	case 0:

   461

	default:

   462

		return n != 1;

   463

   464

	// Only one form

   465

	// Used in:

   466

	//   Hungarian, Japanese, Korean, Turkish

   467

	case 1:

   468

		return 0;

   469

   470

	// Two forms, singular used for zero and one

   471

	// Used in:

   472

	//   French, Brazilian Portuguese

   473

	case 2:

   474

		return n > 1;

   475

   476

	// Three forms, special case for zero

   477

	// Used in:

   478

	//   Latvian

   479

	case 3:

   480

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

   481

   482

	// Three forms, special case for one and two

   483

	// Used in:

   484

	//   Gaelige (Irish)

   485

	case 4:

   486

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

   487

   488

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

   489

	// Used in:

   490

	//   Lithuanian

   491

	case 5:

   492

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

   493

   494

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