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 "music.h"

    22

#include "date.h"

    23

    24

#ifdef WIN32

    25

/* for opendir/readdir/closedir */

    26

# include "fios.h"

    27

#else

    28

# include <sys/types.h>

    29

# include <dirent.h>

    30

#endif /* WIN32 */

    31

    32

char _userstring[128];

    33

    34

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

    35

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

    36

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

    37

    38

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

    39

    40

extern const char _openttd_revision[];

    41

    42

typedef struct LanguagePack {

    43

	uint32 ident;

    44

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

    45

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

    46

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

    47

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

    48

	uint16 offsets[32]; // the offsets

    49

	byte plural_form;   // how to compute plural forms

    50

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

    51

	char data[VARARRAY_SIZE];

    52

} LanguagePack;

    53

    54

static char **_langpack_offs;

    55

static LanguagePack *_langpack;

    56

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

    57

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

    58

    59

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

    60

	{ /* LT_NORMAL */

    61

		STR_PASSENGERS,

    62

		STR_TONS,

    63

		STR_BAGS,

    64

		STR_LITERS,

    65

		STR_ITEMS,

    66

		STR_CRATES,

    67

		STR_TONS,

    68

		STR_TONS,

    69

		STR_TONS,

    70

		STR_TONS,

    71

		STR_BAGS,

    72

		STR_RES_OTHER

    73

	},

    74

    75

	{ /* LT_HILLY */

    76

		STR_PASSENGERS,

    77

		STR_TONS,

    78

		STR_BAGS,

    79

		STR_LITERS,

    80

		STR_ITEMS,

    81

		STR_CRATES,

    82

		STR_TONS,

    83

		STR_TONS,

    84

		STR_RES_OTHER,

    85

		STR_TONS,

    86

		STR_BAGS,

    87

		STR_TONS

    88

	},

    89

    90

	{ /* LT_DESERT */

    91

		STR_PASSENGERS,

    92

		STR_LITERS,

    93

		STR_BAGS,

    94

		STR_LITERS,

    95

		STR_TONS,

    96

		STR_CRATES,

    97

		STR_TONS,

    98

		STR_TONS,

    99

		STR_TONS,

   100

		STR_LITERS,

   101

		STR_BAGS,

   102

		STR_TONS

   103

	},

   104

   105

	{ /* LT_CANDY */

   106

		STR_PASSENGERS,

   107

		STR_TONS,

   108

		STR_BAGS,

   109

		STR_NOTHING,

   110

		STR_NOTHING,

   111

		STR_TONS,

   112

		STR_TONS,

   113

		STR_LITERS,

   114

		STR_TONS,

   115

		STR_NOTHING,

   116

		STR_LITERS,

   117

		STR_NOTHING

   118

	}

   119

};

   120

   121

   122

// Read an int64 from the argv array.

   123

static inline int64 GetInt64(const int32 **argv)

   124

{

   125

	int64 result;

   126

   127

	assert(argv);

   128

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

   129

	(*argv)+=2;

   130

	return result;

   131

}

   132

   133

// Read an int32 from the argv array.

   134

static inline int32 GetInt32(const int32 **argv)

   135

{

   136

	assert(argv);

   137

	return *(*argv)++;

   138

}

   139

   140

// Read an array from the argv array.

   141

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

   142

{

   143

	const int32 *result;

   144

	assert(*argv);

   145

	result = *argv;

   146

	(*argv) += n;

   147

	return result;

   148

}

   149

   150

   151

#define NUM_BOUND_STRINGS 8

   152

   153

// Array to hold the bound strings.

   154

static const char *_bound_strings[NUM_BOUND_STRINGS];

   155

   156

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

   157

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   158

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

   159

// the indices will be reused.

   160

static int _bind_index;

   161

   162

static const char *GetStringPtr(StringID string)

   163

{

   164

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

   165

}

   166

   167

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

   168

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

   169

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

   170

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

   171

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

   172

{

   173

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

   174

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

   175

   176

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

   177

   178

	switch (tab) {

   179

		case 4:

   180

			if (index >= 0xC0)

   181

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

   182

			break;

   183

   184

		case 14:

   185

			if (index >= 0xE4)

   186

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

   187

			break;

   188

   189

		// User defined name

   190

		case 15:

   191

			return GetName(index, buffr);

   192

   193

		case 28:

   194

			return GetGRFString(buffr, index);

   195

   196

		case 29:

   197

			return GetGRFString(buffr, index + 0x800);

   198

   199

		case 30:

   200

			return GetGRFString(buffr, index + 0x1000);

   201

   202

		case 31:

   203

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

   204

			// but passed through verbatim.

   205

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

   206

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

   207

			}

   208

   209

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

   210

	}

   211

   212

	if (index >= _langtab_num[tab]) {

   213

		error(

   214

			"!String 0x%X is invalid. "

   215

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

   216

		);

   217

	}

   218

   219

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

   220

}

   221

   222

char *GetString(char *buffr, StringID string)

   223

{

   224

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

   225

}

   226

   227

   228

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

   229

// The duration of the bound string is valid only until the next GetString,

   230

// so be careful.

   231

StringID BindCString(const char *str)

   232

{

   233

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

   234

	_bound_strings[idx] = str;

   235

	return idx + STR_SPEC_DYNSTRING;

   236

}

   237

   238

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

   239

void SetDParamStr(uint n, const char *str)

   240

{

   241

	SetDParam(n, BindCString(str));

   242

}

   243

   244

void InjectDParam(int amount)

   245

{

   246

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

   247

}

   248

   249

static const uint32 _divisor_table[] = {

   250

	1000000000,

   251

	100000000,

   252

	10000000,

   253

	1000000,

   254

   255

	100000,

   256

	10000,

   257

	1000,

   258

	100,

   259

	10,

   260

	1

   261

};

   262

   263

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

   264

{

   265

	uint32 quot,divisor;

   266

	int i;

   267

	uint32 tot;

   268

	uint32 num;

   269

   270

	if (number < 0) {

   271

		*buff++ = '-';

   272

		number = -number;

   273

	}

   274

   275

	num = number;

   276

   277

	tot = 0;

   278

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

   279

		divisor = _divisor_table[i];

   280

		quot = 0;

   281

		if (num >= divisor) {

   282

			quot = num / _divisor_table[i];

   283

			num = num % _divisor_table[i];

   284

		}

   285

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

   286

			*buff++ = '0' + quot;

   287

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

   288

		}

   289

	}

   290

   291

	*buff = '\0';

   292

   293

	return buff;

   294

}

   295

   296

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

   297

{

   298

	uint32 quot,divisor;

   299

	int i;

   300

	uint32 tot;

   301

	uint32 num;

   302

   303

	if (number < 0) {

   304

		*buff++ = '-';

   305

		number = -number;

   306

	}

   307

   308

	num = number;

   309

   310

	tot = 0;

   311

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

   312

		divisor = _divisor_table[i];

   313

		quot = 0;

   314

		if (num >= divisor) {

   315

			quot = num / _divisor_table[i];

   316

			num = num % _divisor_table[i];

   317

		}

   318

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

   319

			*buff++ = '0' + quot;

   320

		}

   321

	}

   322

   323

	*buff = '\0';

   324

   325

	return buff;

   326

}

   327

   328

   329

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

   330

{

   331

	const char *src;

   332

	YearMonthDay ymd;

   333

   334

	ConvertDateToYMD(date, &ymd);

   335

   336

	for (src = GetStringPtr(ymd.day + STR_01AC_1ST - 1); (*buff++ = *src++) != '\0';) {}

   337

	buff[-1] = ' ';

   338

   339

	for (src = GetStringPtr(STR_0162_JAN + ymd.month); (*buff++ = *src++) != '\0';) {}

   340

	buff[-1] = ' ';

   341

   342

	return FormatNoCommaNumber(buff, ymd.year);

   343

}

   344

   345

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

   346

{

   347

	const char *src;

   348

	YearMonthDay ymd;

   349

   350

	ConvertDateToYMD(date, &ymd);

   351

   352

	for (src = GetStringPtr(STR_MONTH_JAN + ymd.month); (*buff++ = *src++) != '\0';) {}

   353

	buff[-1] = ' ';

   354

   355

	return FormatNoCommaNumber(buff, ymd.year);

   356

}

   357

   358

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

   359

{

   360

	YearMonthDay ymd;

   361

   362

	ConvertDateToYMD(date, &ymd);

   363

	buff += sprintf(buff, " %02i-%02i-%04i", ymd.day, ymd.month + 1, ymd.year);

   364

   365

	return buff;

   366

}

   367

   368

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

   369

{

   370

	const char *s;

   371

	char c;

   372

	char buf[40], *p;

   373

	int j;

   374

   375

	// multiply by exchange rate

   376

	number *= spec->rate;

   377

   378

	// convert from negative

   379

	if (number < 0) {

   380

		*buff++ = '-';

   381

		number = -number;

   382

	}

   383

   384

	/* Add prefix part, folowing symbol_pos specification.

   385

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

   386

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

   387

	if (spec->symbol_pos != 1){

   388

		s = spec->prefix;

   389

		while (s != spec->prefix + lengthof(spec->prefix) && (c = *(s++)) != '\0') *(buff)++ = c;

   390

	}

   391

   392

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

   393

	if (compact) {

   394

		compact = 0;

   395

		if (number >= 1000000000) {

   396

			number = (number + 500000) / 1000000;

   397

			compact = 'M';

   398

		} else if (number >= 1000000) {

   399

			number = (number + 500) / 1000;

   400

			compact = 'k';

   401

		}

   402

	}

   403

   404

	// convert to ascii number and add commas

   405

	p = buf;

   406

	j = 4;

   407

	do {

   408

		if (--j == 0) {

   409

			*p++ = spec->separator;

   410

			j = 3;

   411

		}

   412

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

   413

	} while (number /= 10);

   414

	do *buff++ = *--p; while (p != buf);

   415

   416

	if (compact) *buff++ = compact;

   417

   418

	/* Add suffix part, folowing symbol_pos specification.

   419

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

   420

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

   421

	if (spec->symbol_pos != 0) {

   422

		s = spec->suffix;

   423

		while (s != spec->suffix + lengthof(spec->suffix) && (c = *(s++)) != '\0') *(buff++) = c;

   424

	}

   425

   426

	return buff;

   427

}

   428

   429

static int DeterminePluralForm(int32 n)

   430

{

   431

	// The absolute value determines plurality

   432

	if (n < 0) n = -n;

   433

   434

	switch (_langpack->plural_form) {

   435

	// Two forms, singular used for one only

   436

	// Used in:

   437

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

   438

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

   439

	case 0:

   440

	default:

   441

		return n != 1;

   442

   443

	// Only one form

   444

	// Used in:

   445

	//   Hungarian, Japanese, Korean, Turkish

   446

	case 1:

   447

		return 0;

   448

   449

	// Two forms, singular used for zero and one

   450

	// Used in:

   451

	//   French, Brazilian Portuguese

   452

	case 2:

   453

		return n > 1;

   454

   455

	// Three forms, special case for zero

   456

	// Used in:

   457

	//   Latvian

   458

	case 3:

   459

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

   460

   461

	// Three forms, special case for one and two

   462

	// Used in:

   463

	//   Gaelige (Irish)

   464

	case 4:

   465

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

   466

   467

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

   468

	// Used in:

   469

	//   Lithuanian

   470

	case 5:

   471

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

   472

   473

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

   474

	// Used in:

   475

	//   Croatian, Czech, Russian, Slovak, Ukrainian

   476

	case 6:

   477

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

   478

   479

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

   480

	// Used in:

   481

	//   Polish

   482

	case 7:

   483

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

   484

   485

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

   486

	// Used in:

   487

	//   Slovenian

   488

	case 8:

   489

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

   490

	}

   491

}

   492

   493

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

   494

{

   495

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

   496

	uint n = (byte)*b++;

   497

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