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"

    20

    21

char _userstring[128];

    22

    23

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

    24

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

    25

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

    26

    27

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

    28

    29

extern const char _openttd_revision[];

    30

    31

typedef struct LanguagePack {

    32

	uint32 ident;

    33

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

    34

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

    35

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

    36

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

    37

	uint16 offsets[32];	// the offsets

    38

	byte plural_form;		// how to compute plural forms

    39

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

    40

	char data[VARARRAY_SIZE];

    41

} LanguagePack;

    42

    43

static char **_langpack_offs;

    44

static LanguagePack *_langpack;

    45

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

    46

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

    47

    48

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

    49

	{ /* LT_NORMAL */

    50

		STR_PASSENGERS,

    51

		STR_TONS,

    52

		STR_BAGS,

    53

		STR_LITERS,

    54

		STR_ITEMS,

    55

		STR_CRATES,

    56

		STR_TONS,

    57

		STR_TONS,

    58

		STR_TONS,

    59

		STR_TONS,

    60

		STR_BAGS,

    61

		STR_RES_OTHER

    62

	},

    63

    64

	{ /* LT_HILLY */

    65

		STR_PASSENGERS,

    66

		STR_TONS,

    67

		STR_BAGS,

    68

		STR_LITERS,

    69

		STR_ITEMS,

    70

		STR_CRATES,

    71

		STR_TONS,

    72

		STR_TONS,

    73

		STR_RES_OTHER,

    74

		STR_TONS,

    75

		STR_BAGS,

    76

		STR_TONS

    77

	},

    78

    79

	{ /* LT_DESERT */

    80

		STR_PASSENGERS,

    81

		STR_LITERS,

    82

		STR_BAGS,

    83

		STR_LITERS,

    84

		STR_TONS,

    85

		STR_CRATES,

    86

		STR_TONS,

    87

		STR_TONS,

    88

		STR_TONS,

    89

		STR_LITERS,

    90

		STR_BAGS,

    91

		STR_TONS

    92

	},

    93

    94

	{ /* LT_CANDY */

    95

		STR_PASSENGERS,

    96

		STR_TONS,

    97

		STR_BAGS,

    98

		STR_NOTHING,

    99

		STR_NOTHING,

   100

		STR_TONS,

   101

		STR_TONS,

   102

		STR_LITERS,

   103

		STR_TONS,

   104

		STR_NOTHING,

   105

		STR_LITERS,

   106

		STR_NOTHING

   107

	}

   108

};

   109

   110

   111

// Read an int64 from the argv array.

   112

static inline int64 GetInt64(const int32 **argv)

   113

{

   114

	int64 result;

   115

   116

	assert(argv);

   117

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

   118

	(*argv)+=2;

   119

	return result;

   120

}

   121

   122

// Read an int32 from the argv array.

   123

static inline int32 GetInt32(const int32 **argv)

   124

{

   125

	assert(argv);

   126

	return *(*argv)++;

   127

}

   128

   129

// Read an array from the argv array.

   130

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

   131

{

   132

	const int32 *result;

   133

	assert(*argv);

   134

	result = *argv;

   135

	(*argv) += n;

   136

	return result;

   137

}

   138

   139

   140

#define NUM_BOUND_STRINGS 8

   141

   142

// Array to hold the bound strings.

   143

static const char *_bound_strings[NUM_BOUND_STRINGS];

   144

   145

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

   146

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   147

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

   148

// the indices will be reused.

   149

static int _bind_index;

   150

   151

static const char *GetStringPtr(StringID string)

   152

{

   153

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

   154

}

   155

   156

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

   157

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

   158

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

   159

// should set those bits.

   160

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

   161

{

   162

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

   163

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

   164

   165

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

   166

   167

	switch (tab) {

   168

		case 4:

   169

			if (index >= 0xC0)

   170

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

   171

			break;

   172

   173

		case 14:

   174

			if (index >= 0xE4)

   175

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

   176

			break;

   177

   178

		// User defined name

   179

		case 15:

   180

			return GetName(index, buffr);

   181

   191

		case 31:

   192

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

   193

			// but passed through verbatim.

   194

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

   195

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

   196

			}

   197

   198

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

   199

	}

   200

   201

	if (index >= _langtab_num[tab]) {

   202

		error(

   203

			"!String 0x%X is invalid. "

   204

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

   205

		);

   206

	}

   207

   208

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

   209

}

   210

   211

char *GetString(char *buffr, StringID string)

   212

{

   213

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

   214

}

   215

   216

   217

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

   218

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

   219

// so be careful.

   220

StringID BindCString(const char *str)

   221

{

   222

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

   223

	_bound_strings[idx] = str;

   224

	return idx + STR_SPEC_DYNSTRING;

   225

}

   226

   227

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

   228

void SetDParamStr(uint n, const char *str)

   229

{

   230

	SetDParam(n, BindCString(str));

   231

}

   232

   233

void InjectDParam(int amount)

   234

{

   235

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

   236

}

   237

   238

static const uint32 _divisor_table[] = {

   239

	1000000000,

   240

	100000000,

   241

	10000000,

   242

	1000000,

   243

   244

	100000,

   245

	10000,

   246

	1000,

   247

	100,

   248

	10,

   249

	1

   250

};

   251

   252

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

   253

{

   254

	uint32 quot,divisor;

   255

	int i;

   256

	uint32 tot;

   257

	uint32 num;

   258

   259

	if (number < 0) {

   260

		*buff++ = '-';

   261

		number = -number;

   262

	}

   263

   264

	num = number;

   265

   266

	tot = 0;

   267

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

   268

		divisor = _divisor_table[i];

   269

		quot = 0;

   270

		if (num >= divisor) {

   271

			quot = num / _divisor_table[i];

   272

			num = num % _divisor_table[i];

   273

		}

   274

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

   275

			*buff++ = '0' + quot;

   276

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

   277

		}

   278

	}

   279

   280

	*buff = '\0';

   281

   282

	return buff;

   283

}

   284

   285

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

   286

{

   287

	uint32 quot,divisor;

   288

	int i;

   289

	uint32 tot;

   290

	uint32 num;

   291

   292

	if (number < 0) {

   293

		*buff++ = '-';

   294

		number = -number;

   295

	}

   296

   297

	num = number;

   298

   299

	tot = 0;

   300

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

   301

		divisor = _divisor_table[i];

   302

		quot = 0;

   303

		if (num >= divisor) {

   304

			quot = num / _divisor_table[i];

   305

			num = num % _divisor_table[i];

   306

		}

   307

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

   308

			*buff++ = '0' + quot;

   309

		}

   310

	}

   311

   312

	*buff = '\0';

   313

   314

	return buff;

   315

}

   316

   317

   318

static char *FormatYmdString(char *buff, uint16 number)

   319

{

   320

	const char *src;

   321

	YearMonthDay ymd;

   322

   323

	ConvertDayToYMD(&ymd, number);

   324

   325

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

   326

   327

	buff[-1] = ' ';

   328

	memcpy(buff, GetStringPtr(STR_0162_JAN + ymd.month), 4);

   329

	buff[3] = ' ';

   330

   331

	return FormatNoCommaNumber(buff + 4, ymd.year + MAX_YEAR_BEGIN_REAL);

   332

}

   333

   334

static char *FormatMonthAndYear(char *buff, uint16 number)

   335

{

   336

	const char *src;

   337

	YearMonthDay ymd;

   338

   339

	ConvertDayToYMD(&ymd, number);

   340

   341

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

   342

	buff[-1] = ' ';

   343

   344

	return FormatNoCommaNumber(buff, ymd.year + MAX_YEAR_BEGIN_REAL);

   345

}

   346

   347

static char *FormatTinyDate(char *buff, uint16 number)

   348

{

   349

	YearMonthDay ymd;

   350

   351

	ConvertDayToYMD(&ymd, number);

   352

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

   353

   354

	return buff;

   355

}

   356

   357

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

   358

{

   359

	const char *s;

   360

	char c;

   361

	char buf[40], *p;

   362

	int j;

   363

   364

	// multiply by exchange rate

   365

	number *= spec->rate;

   366

   367

	// convert from negative

   368

	if (number < 0) {

   369

		*buff++ = '-';

   370

		number = -number;

   371

	}

   372

   373

	// add prefix part

   374

	s = spec->prefix;

   375

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

   376

   377

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

   378

	if (compact) {

   379

		compact = 0;

   380

		if (number >= 1000000000) {

   381

			number = (number + 500000) / 1000000;

   382

			compact = 'M';

   383

		} else if (number >= 1000000) {

   384

			number = (number + 500) / 1000;

   385

			compact = 'k';

   386

		}

   387

	}

   388

   389

	// convert to ascii number and add commas

   390

	p = buf;

   391

	j = 4;

   392

	do {

   393

		if (--j == 0) {

   394

			*p++ = spec->separator;

   395

			j = 3;

   396

		}

   397

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

   398

	} while (number /= 10);

   399

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

   400

   401

	if (compact) *buff++ = compact;

   402

   403

	// add suffix part

   404

	s = spec->suffix;

   405

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

   406

   407

	return buff;

   408

}

   409

   410

static int DeterminePluralForm(int32 n)

   411

{

   412

	// The absolute value determines plurality

   413

	if (n < 0) n = -n;

   414

   415

	switch (_langpack->plural_form) {

   416

	// Two forms, singular used for one only

   417

	// Used in:

   418

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

   419

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

   420

	case 0:

   421

	default:

   422

		return n != 1;

   423

   424

	// Only one form

   425

	// Used in:

   426

	//   Hungarian, Japanese, Korean, Turkish

   427

	case 1:

   428

		return 0;

   429

   430

	// Two forms, singular used for zero and one

   431

	// Used in:

   432

	//   French, Brazilian Portuguese

   433

	case 2:

   434

		return n > 1;

   435

   436

	// Three forms, special case for zero

   437

	// Used in:

   438

	//   Latvian

   439

	case 3:

   440

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

   441

   442

	// Three forms, special case for one and two

   443

	// Used in:

   444

	//   Gaelige (Irish)

   445

	case 4:

   446

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

   447

   448

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

   449

	// Used in:

   450

	//   Lithuanian

   451

	case 5:

   452

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

   453

   454

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

   455

	// Used in:

   456

	//   Croatian, Czech, Russian, Slovak, Ukrainian

   457

	case 6:

   458

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

   459

   460

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

   461

	// Used in:

   462

	//   Polish

   463

	case 7:

   464

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

   465

   466

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

   467

	// Used in:

   468

	//   Slovenian

   469

	case 8:

   470

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

   471

	}

   472

}

   473

   474

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

   475

{

   476

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

   477

	uint n = (byte)*b++;

   478

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

   479

   480

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

   481

		uint len = (byte)*b++;

   482

		if (i == form) {

   483

			mypos = pos;

   484

			mylen = len;

   485

		}

   486

		pos += len;

   487

	}

   488

	*dstlen = mylen;

   489

	memcpy(dst, b + mypos, mylen);

   490

	return b + pos;

   491

}

   492

   493

typedef struct Units {

   494

	int s_m;           ///< Multiplier for velocity

   495

	int s_s;           ///< Shift for velocity

   496

	StringID velocity; ///< String for velocity

   497

	int p_m;           ///< Multiplier for power

   498

	int p_s;           ///< Shift for power