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

#include "helpers.hpp"

    26

    27

#ifdef WIN32

    28

/* for opendir/readdir/closedir */

    29

# include "fios.h"

    30

#else

    31

# include <sys/types.h>

    32

# include <dirent.h>

    33

#endif /* WIN32 */

    34

    35

char _userstring[128];

    36

    37

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

    38

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

    39

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

    40

    41

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

    42

    43

typedef struct LanguagePack {

    44

	uint32 ident;

    45

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

    46

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

    47

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

    48

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

    49

	uint16 offsets[32]; // the offsets

    50

	byte plural_form;   // how to compute plural forms

    51

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

    52

	char data[VARARRAY_SIZE];

    53

} LanguagePack;

    54

    55

static char **_langpack_offs;

    56

static LanguagePack *_langpack;

    57

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

    58

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

    59

    60

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

    61

	{ /* LT_NORMAL */

    62

		STR_PASSENGERS,

    63

		STR_TONS,

    64

		STR_BAGS,

    65

		STR_LITERS,

    66

		STR_ITEMS,

    67

		STR_CRATES,

    68

		STR_TONS,

    69

		STR_TONS,

    70

		STR_TONS,

    71

		STR_TONS,

    72

		STR_BAGS,

    73

		STR_RES_OTHER

    74

	},

    75

    76

	{ /* LT_HILLY */

    77

		STR_PASSENGERS,

    78

		STR_TONS,

    79

		STR_BAGS,

    80

		STR_LITERS,

    81

		STR_ITEMS,

    82

		STR_CRATES,

    83

		STR_TONS,

    84

		STR_TONS,

    85

		STR_RES_OTHER,

    86

		STR_TONS,

    87

		STR_BAGS,

    88

		STR_TONS

    89

	},

    90

    91

	{ /* LT_DESERT */

    92

		STR_PASSENGERS,

    93

		STR_LITERS,

    94

		STR_BAGS,

    95

		STR_LITERS,

    96

		STR_TONS,

    97

		STR_CRATES,

    98

		STR_TONS,

    99

		STR_TONS,

   100

		STR_TONS,

   101

		STR_LITERS,

   102

		STR_BAGS,

   103

		STR_TONS

   104

	},

   105

   106

	{ /* LT_CANDY */

   107

		STR_PASSENGERS,

   108

		STR_TONS,

   109

		STR_BAGS,

   110

		STR_NOTHING,

   111

		STR_NOTHING,

   112

		STR_TONS,

   113

		STR_TONS,

   114

		STR_LITERS,

   115

		STR_TONS,

   116

		STR_NOTHING,

   117

		STR_LITERS,

   118

		STR_NOTHING

   119

	}

   120

};

   121

   122

   123

// Read an int64 from the argv array.

   124

static inline int64 GetInt64(const int32 **argv)

   125

{

   126

	int64 result;

   127

   128

	assert(argv);

   129

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

   130

	(*argv)+=2;

   131

	return result;

   132

}

   133

   134

// Read an int32 from the argv array.

   135

static inline int32 GetInt32(const int32 **argv)

   136

{

   137

	assert(argv);

   138

	return *(*argv)++;

   139

}

   140

   141

// Read an array from the argv array.

   142

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

   143

{

   144

	const int32 *result;

   145

	assert(*argv);

   146

	result = *argv;

   147

	(*argv) += n;

   148

	return result;

   149

}

   150

   151

   152

#define NUM_BOUND_STRINGS 8

   153

   154

// Array to hold the bound strings.

   155

static const char *_bound_strings[NUM_BOUND_STRINGS];

   156

   157

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

   158

// slots for BindCString. NUM_BOUND_STRINGS slots are reserved.

   159

// Which means that after NUM_BOUND_STRINGS calls to BindCString,

   160

// the indices will be reused.

   161

static int _bind_index;

   162

   163

static const char *GetStringPtr(StringID string)

   164

{

   165

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

   166

}

   167

   168

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

   169

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

   170

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

   171

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

   172

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

   173

{

   174

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

   175

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

   176

	char buff[512];

   177

   178

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

   179

   180

	switch (tab) {

   181

		case 4:

   182

			if (index >= 0xC0)

   183

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

   184

			break;

   185

   186

		case 14:

   187

			if (index >= 0xE4)

   188

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

   189

			break;

   190

   191

		// User defined name

   192

		case 15:

   193

			return GetName(buffr, index, last);

   194

   195

		case 26:

   196

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

   197

			if (HASBIT(index, 10)) {

   198

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

   199

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

   200

			}

   201

			break;

   202

   203

		case 28:

   204

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

   205

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

   206

   207

		case 29:

   208

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

   209

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

   210

   211

		case 30:

   212

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

   213

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

   214

   215

		case 31:

   216

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

   217

			// but passed through verbatim.

   218

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

   219

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

   220

			}

   221

   222

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

   223

	}

   224

   225

	if (index >= _langtab_num[tab]) {

   226

		error(

   227

			"!String 0x%X is invalid. "

   228

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

   229

		);

   230

	}

   231

   232

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

   233

}

   234

   235

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

   236

{

   237

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

   238

}

   239

   240

   241

char *InlineString(char *buf, StringID string)

   242

{

   243

	buf += Utf8Encode(buf, SCC_STRING_ID);

   244

	buf += Utf8Encode(buf, string);

   245

	return buf;

   246

}

   247

   248

   249

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

   250

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

   251

// so be careful.

   252

StringID BindCString(const char *str)

   253

{

   254

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

   255

	_bound_strings[idx] = str;

   256

	return idx + STR_SPEC_DYNSTRING;

   257

}

   258

   259

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

   260

void SetDParamStr(uint n, const char *str)

   261

{

   262

	SetDParam(n, BindCString(str));

   263

}

   264

   265

void InjectDParam(int amount)

   266

{

   267

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

   268

}

   269

   270

static const uint32 _divisor_table[] = {

   271

	1000000000,

   272

	100000000,

   273

	10000000,

   274

	1000000,

   275

   276

	100000,

   277

	10000,

   278

	1000,

   279

	100,

   280

	10,

   281

	1

   282

};

   283

   284

// TODO

   285

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

   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

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

   310

		}

   311

	}

   312

   313

	*buff = '\0';

   314

   315

	return buff;

   316

}

   317

   318

// TODO

   319

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

   320

{

   321

	uint32 quot,divisor;

   322

	int i;

   323

	uint32 tot;

   324

	uint32 num;

   325

   326

	if (number < 0) {

   327

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

   328

		number = -number;

   329

	}

   330

   331

	num = number;

   332

   333

	tot = 0;

   334

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

   335

		divisor = _divisor_table[i];

   336

		quot = 0;

   337

		if (num >= divisor) {

   338

			quot = num / _divisor_table[i];

   339

			num = num % _divisor_table[i];

   340

		}

   341

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

   342

			*buff++ = '0' + quot;

   343

		}

   344

	}

   345

   346

	*buff = '\0';

   347

   348

	return buff;

   349

}

   350

   351

   352

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

   353

{

   354

	YearMonthDay ymd;

   355

   356

	ConvertDateToYMD(date, &ymd);

   357

   358

	buff = strecpy(buff, GetStringPtr(ymd.day + STR_01AC_1ST - 1), last);

   359

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

   360

	buff = strecpy(buff, GetStringPtr(STR_0162_JAN + ymd.month), last);

   361

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

   362

   363

	return FormatNoCommaNumber(buff, ymd.year, last);

   364

}

   365

   366

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

   367

{

   368

	YearMonthDay ymd;

   369

   370

	ConvertDateToYMD(date, &ymd);

   371

   372

	buff = strecpy(buff, GetStringPtr(STR_MONTH_JAN + ymd.month), last);

   373

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

   374

   375

	return FormatNoCommaNumber(buff, ymd.year, last);

   376

}

   377

   378

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

   379

{

   380

	YearMonthDay ymd;

   381

   382

	ConvertDateToYMD(date, &ymd);

   383

	buff += snprintf(

   384

		buff, last - buff + 1,

   385

		" %02i-%02i-%04i", ymd.day, ymd.month + 1, ymd.year

   386

	);

   387

   388

	return buff;

   389

}

   390

   391

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

   392

{

   393

	const char* multiplier = "";

   394

	char buf[40];

   395

	char* p;

   396

	int j;

   397

   398

	// multiply by exchange rate

   399

	number *= spec->rate;

   400

   401

	// convert from negative

   402

	if (number < 0) {

   403

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

   404

		number = -number;

   405

	}

   406

   407

	/* Add prefix part, folowing symbol_pos specification.

   408

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

   409

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

   410

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

   411

   412

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

   413

	if (compact) {

   414

		if (number >= 1000000000) {

   415

			number = (number + 500000) / 1000000;

   416

			multiplier = "M";

   417

		} else if (number >= 1000000) {

   418

			number = (number + 500) / 1000;

   419

			multiplier = "k";

   420

		}

   421

	}

   422

   423

	// convert to ascii number and add commas

   424

	p = endof(buf);

   425

	*--p = '\0';

   426

	j = 4;

   427

	do {

   428

		if (--j == 0) {

   429

			*--p = spec->separator;

   430

			j = 3;

   431

		}

   432

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

   433

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

   434

	buff = strecpy(buff, p, last);

   435

   436

	buff = strecpy(buff, multiplier, last);

   437

   438

	/* Add suffix part, folowing symbol_pos specification.

   439

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

   440

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

   441

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

   442

   443

	return buff;

   444

}

   445

   446

static int DeterminePluralForm(int32 n)

   447

{

   448

	// The absolute value determines plurality

   449

	if (n < 0) n = -n;

   450

   451

	switch (_langpack->plural_form) {

   452

	// Two forms, singular used for one only

   453

	// Used in:

   454

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

   455

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

   456

	case 0:

   457

	default:

   458

		return n != 1;

   459

   460

	// Only one form

   461

	// Used in:

   462

	//   Hungarian, Japanese, Korean, Turkish

   463

	case 1:

   464

		return 0;

   465

   466

	// Two forms, singular used for zero and one

   467

	// Used in:

   468

	//   French, Brazilian Portuguese

   469

	case 2:

   470

		return n > 1;

   471

   472

	// Three forms, special case for zero

   473

	// Used in:

   474

	//   Latvian

   475

	case 3:

   476

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

   477

   478

	// Three forms, special case for one and two

   479

	// Used in:

   480

	//   Gaelige (Irish)

   481

	case 4:

   482

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

   483

   484

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

   485

	// Used in:

   486

	//   Lithuanian

   487

	case 5:

   488

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

   489

   490

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

   491

	// Used in:

   492

	//   Croatian, Czech, Russian, Slovak, Ukrainian

   493

	case 6:

   494