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

    31

char _userstring[128];

    32

    33

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

    34

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

    35

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

    36

    37

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

    38

    39

extern const char _openttd_revision[];

    40

    41

typedef struct LanguagePack {

    42

	uint32 ident;

    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];

    51

} LanguagePack;

    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

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

    59

	{ /* LT_NORMAL */

    60

		STR_PASSENGERS,

    61

		STR_TONS,

    62

		STR_BAGS,

    63

		STR_LITERS,

    64

		STR_ITEMS,

    65

		STR_CRATES,

    66

		STR_TONS,

    67

		STR_TONS,

    68

		STR_TONS,

    69

		STR_TONS,

    70

		STR_BAGS,

    71

		STR_RES_OTHER

    72

	},

    73

    74

	{ /* LT_HILLY */

    75

		STR_PASSENGERS,

    76

		STR_TONS,

    77

		STR_BAGS,

    78

		STR_LITERS,

    79

		STR_ITEMS,

    80

		STR_CRATES,

    81

		STR_TONS,

    82

		STR_TONS,

    83

		STR_RES_OTHER,

    84

		STR_TONS,

    85

		STR_BAGS,

    86

		STR_TONS

    87

	},

    88

    89

	{ /* LT_DESERT */

    90

		STR_PASSENGERS,

    91

		STR_LITERS,

    92

		STR_BAGS,

    93

		STR_LITERS,

    94

		STR_TONS,

    95

		STR_CRATES,

    96

		STR_TONS,

    97

		STR_TONS,

    98

		STR_TONS,

    99

		STR_LITERS,

   100

		STR_BAGS,

   101

		STR_TONS

   102

	},

   103

   104

	{ /* LT_CANDY */

   105

		STR_PASSENGERS,

   106

		STR_TONS,

   107

		STR_BAGS,

   108

		STR_NOTHING,

   109

		STR_NOTHING,

   110

		STR_TONS,

   111

		STR_TONS,

   112

		STR_LITERS,

   113

		STR_TONS,

   114

		STR_NOTHING,

   115

		STR_LITERS,

   116

		STR_NOTHING

   117

	}

   118

};

   119

   120

   121

// Read an int64 from the argv array.

   122

static inline int64 GetInt64(const int32 **argv)

   123

{

   124

	int64 result;

   125

   126

	assert(argv);

   127

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

   128

	(*argv)+=2;

   129

	return result;

   130

}

   131

   132

// Read an int32 from the argv array.

   133

static inline int32 GetInt32(const int32 **argv)

   134

{

   135

	assert(argv);

   136

	return *(*argv)++;

   137

}

   138

   139

// Read an array from the argv array.

   140

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

   141

{

   142

	const int32 *result;

   143

	assert(*argv);

   144

	result = *argv;

   145

	(*argv) += n;

   146

	return result;

   147

}

   148

   149

   150

#define NUM_BOUND_STRINGS 8

   151

   152

// Array to hold the bound strings.

   153

static const char *_bound_strings[NUM_BOUND_STRINGS];

   154

   155

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

   156

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   157

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

   158

// the indices will be reused.

   159

static int _bind_index;

   160

   161

static const char *GetStringPtr(StringID string)

   162

{

   163

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

   164

}

   165

   166

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

   167

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

   168

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

   169

// should set those bits.

   170

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

   171

{

   172

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

   173

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

   174

   175

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

   176

   177

	switch (tab) {

   178

		case 4:

   179

			if (index >= 0xC0)

   180

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

   181

			break;

   182

   183

		case 14:

   184

			if (index >= 0xE4)

   185

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

   186

			break;

   187

   188

		// User defined name

   189

		case 15:

   190

			return GetName(index, buffr);

   191

   192

		case 28:

   193

			return GetGRFString(buffr, index);

   194

   195

		case 29:

   196

			return GetGRFString(buffr, index + 0x800);

   197

   198

		case 30:

   199

			return GetGRFString(buffr, index + 0x1000);

   200

   201

		case 31:

   202

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

   203

			// but passed through verbatim.

   204

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

   205

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

   206

			}

   207

   208

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

   209

	}

   210

   211

	if (index >= _langtab_num[tab]) {

   212

		error(

   213

			"!String 0x%X is invalid. "

   214

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

   215

		);

   216

	}

   217

   218

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

   219

}

   220

   221

char *GetString(char *buffr, StringID string)

   222

{

   223

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

   224

}

   225

   226

   227

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

   228

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

   229

// so be careful.

   230

StringID BindCString(const char *str)

   231

{

   232

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

   233

	_bound_strings[idx] = str;

   234

	return idx + STR_SPEC_DYNSTRING;

   235

}

   236

   237

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

   238

void SetDParamStr(uint n, const char *str)

   239

{

   240

	SetDParam(n, BindCString(str));

   241

}

   242

   243

void InjectDParam(int amount)

   244

{

   245

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

   246

}

   247

   248

static const uint32 _divisor_table[] = {

   249

	1000000000,

   250

	100000000,

   251

	10000000,

   252

	1000000,

   253

   254

	100000,

   255

	10000,

   256

	1000,

   257

	100,

   258

	10,

   259

	1

   260

};

   261

   262

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

   263

{

   264

	uint32 quot,divisor;

   265

	int i;

   266

	uint32 tot;

   267

	uint32 num;

   268

   269

	if (number < 0) {

   270

		*buff++ = '-';

   271

		number = -number;

   272

	}

   273

   274

	num = number;

   275

   276

	tot = 0;

   277

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

   278

		divisor = _divisor_table[i];

   279

		quot = 0;

   280

		if (num >= divisor) {

   281

			quot = num / _divisor_table[i];

   282

			num = num % _divisor_table[i];

   283

		}

   284

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

   285

			*buff++ = '0' + quot;

   286

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

   287

		}

   288

	}

   289

   290

	*buff = '\0';

   291

   292

	return buff;

   293

}

   294

   295

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

   296

{

   297

	uint32 quot,divisor;

   298

	int i;

   299

	uint32 tot;

   300

	uint32 num;

   301

   302

	if (number < 0) {

   303

		*buff++ = '-';

   304

		number = -number;

   305

	}

   306

   307

	num = number;

   308

   309

	tot = 0;

   310

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

   311

		divisor = _divisor_table[i];

   312

		quot = 0;

   313

		if (num >= divisor) {

   314

			quot = num / _divisor_table[i];

   315

			num = num % _divisor_table[i];

   316

		}

   317

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

   318

			*buff++ = '0' + quot;

   319

		}

   320

	}

   321

   322

	*buff = '\0';

   323

   324

	return buff;

   325

}

   326

   327

   328

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

   329

{

   330

	const char *src;

   331

	YearMonthDay ymd;

   332

   333

	ConvertDayToYMD(&ymd, number);

   334

   335

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

   336

	buff[-1] = ' ';

   337

   338

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

   339

	buff[-1] = ' ';

   340

   341

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

   342

}

   343

   344

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

   345

{

   346

	const char *src;

   347

	YearMonthDay ymd;

   348

   349

	ConvertDayToYMD(&ymd, number);

   350

   351

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

   352

	buff[-1] = ' ';

   353

   354

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

   355

}

   356

   357

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

   358

{

   359

	YearMonthDay ymd;

   360

   361

	ConvertDayToYMD(&ymd, number);

   362

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

   363

   364

	return buff;

   365

}

   366

   367

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

   368

{

   369

	const char *s;

   370

	char c;

   371

	char buf[40], *p;

   372

	int j;

   373

   374

	// multiply by exchange rate

   375

	number *= spec->rate;

   376

   377

	// convert from negative

   378

	if (number < 0) {

   379

		*buff++ = '-';

   380

		number = -number;

   381

	}

   382

   383

	// add prefix part

   384

	s = spec->prefix;

   385

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

   386

   387

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

   388

	if (compact) {

   389

		compact = 0;

   390

		if (number >= 1000000000) {

   391

			number = (number + 500000) / 1000000;

   392

			compact = 'M';

   393

		} else if (number >= 1000000) {

   394

			number = (number + 500) / 1000;

   395

			compact = 'k';

   396

		}

   397

	}

   398

   399

	// convert to ascii number and add commas

   400

	p = buf;

   401

	j = 4;

   402

	do {

   403

		if (--j == 0) {

   404

			*p++ = spec->separator;

   405

			j = 3;

   406

		}

   407

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

   408

	} while (number /= 10);

   409

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

   410

   411

	if (compact) *buff++ = compact;

   412

   413

	// add suffix part

   414

	s = spec->suffix;

   415

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

   416

   417

	return buff;

   418

}

   419

   420

static int DeterminePluralForm(int32 n)

   421

{

   422

	// The absolute value determines plurality

   423

	if (n < 0) n = -n;

   424

   425

	switch (_langpack->plural_form) {

   426

	// Two forms, singular used for one only

   427

	// Used in:

   428

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

   429

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

   430

	case 0:

   431

	default:

   432

		return n != 1;

   433

   434

	// Only one form

   435

	// Used in:

   436

	//   Hungarian, Japanese, Korean, Turkish

   437

	case 1:

   438

		return 0;

   439

   440

	// Two forms, singular used for zero and one

   441

	// Used in:

   442

	//   French, Brazilian Portuguese

   443

	case 2:

   444

		return n > 1;

   445

   446

	// Three forms, special case for zero

   447

	// Used in:

   448

	//   Latvian

   449

	case 3:

   450

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

   451

   452

	// Three forms, special case for one and two

   453

	// Used in:

   454

	//   Gaelige (Irish)

   455

	case 4:

   456

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

   457

   458

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

   459

	// Used in:

   460

	//   Lithuanian

   461

	case 5:

   462

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

   463

   464

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

   465

	// Used in:

   466

	//   Croatian, Czech, Russian, Slovak, Ukrainian

   467

	case 6:

   468

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

   469

   470

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

   471

	// Used in:

   472

	//   Polish

   473

	case 7:

   474

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

   475

   476

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

   477

	// Used in:

   478

	//   Slovenian

   479

	case 8:

   480

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

   481

	}

   482

}

   483

   484

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

   485

{

   486

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

   487

	uint n = (byte)*b++;

   488

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

   489

   490

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

   491

		uint len = (byte)*b++;

   492

		if (i == form) {

   493

			mypos = pos;

   494

			mylen = len;

   495

		}

   496

		pos += len;

   497

	}

   498

	*dstlen = mylen;