1

/* $Id$ */

     2

     3

/** @file newgrf_text.cpp

     4

 * Implementation of  Action 04 "universal holder" structure and functions.

     5

 * This file implements a linked-lists of strings,

     6

 * holding everything that the newgrf action 04 will send over to OpenTTD.

     7

 * One of the biggest problems is that Dynamic lang Array uses ISO codes

     8

 * as way to identifying current user lang, while newgrf uses bit shift codes

     9

 * not related to ISO.  So equivalence functionnality had to be set.

    10

 */

    11

    12

#include "stdafx.h"

    13

#include "debug.h"

    14

#include "openttd.h"

    15

#include "variables.h"

    16

#include "newgrf.h"

    17

#include "newgrf_text.h"

    18

#include "strings_func.h"

    19

#include "core/alloc_func.hpp"

    20

#include "newgrf_storage.h"

    21

#include "string_func.h"

    22

#include "date_type.h"

    23

    24

#include "table/strings.h"

    25

#include "table/control_codes.h"

    26

    27

#define GRFTAB  28

    28

#define TABSIZE 11

    29

    30

/**

    31

 * Explains the newgrf shift bit positionning.

    32

 * the grf base will not be used in order to find the string, but rather for

    33

 * jumping from standard langID scheme to the new one.

    34

 */

    35

enum grf_base_languages {

    36

	GRFLB_AMERICAN    = 0x01,

    37

	GRFLB_ENGLISH     = 0x02,

    38

	GRFLB_GERMAN      = 0x04,

    39

	GRFLB_FRENCH      = 0x08,

    40

	GRFLB_SPANISH     = 0x10,

    41

	GRFLB_GENERIC     = 0x80,

    42

};

    43

    44

enum grf_extended_languages {

    45

	GRFLX_AMERICAN    = 0x00,

    46

	GRFLX_ENGLISH     = 0x01,

    47

	GRFLX_GERMAN      = 0x02,

    48

	GRFLX_FRENCH      = 0x03,

    49

	GRFLX_SPANISH     = 0x04,

    50

	GRFLX_ESPERANTO   = 0x05,

    51

	GRFLX_RUSSIAN     = 0x07,

    52

	GRFLX_CZECH       = 0x15,

    53

	GRFLX_SLOVAK      = 0x16,

    54

	GRFLX_BULGARIAN   = 0x18,

    55

	GRFLX_AFRIKAANS   = 0x1B,

    56

	GRFLX_GREEK       = 0x1E,

    57

	GRFLX_DUTCH       = 0x1F,

    58

	GRFLX_CATALAN     = 0x22,

    59

	GRFLX_HUNGARIAN   = 0x24,

    60

	GRFLX_ITALIAN     = 0x27,

    61

	GRFLX_ROMANIAN    = 0x28,

    62

	GRFLX_ICELANDIC   = 0x29,

    63

	GRFLX_LATVIAN     = 0x2A,

    64

	GRFLX_LITHUANIAN  = 0x2B,

    65

	GRFLX_SLOVENIAN   = 0x2C,

    66

	GRFLX_DANISH      = 0x2D,

    67

	GRFLX_SWEDISH     = 0x2E,

    68

	GRFLX_NORWEGIAN   = 0x2F,

    69

	GRFLX_POLISH      = 0x30,

    70

	GRFLX_GALICIAN    = 0x31,

    71

	GRFLX_FRISIAN     = 0x32,

    72

	GRFLX_UKRAINIAN   = 0x33,

    73

	GRFLX_ESTONIAN    = 0x34,

    74

	GRFLX_FINNISH     = 0x35,

    75

	GRFLX_PORTUGUESE  = 0x36,

    76

	GRFLX_BRAZILIAN   = 0x37,

    77

	GRFLX_CROATIAN    = 0x38,

    78

	GRFLX_JAPANESE    = 0x39,

    79

	GRFLX_KOREAN      = 0x3A,

    80

	GRFLX_TURKISH     = 0x3E,

    81

	GRFLX_UNSPECIFIED = 0x7F,

    82

};

    83

    84

    85

struct iso_grf {

    86

	char code[6];

    87

	byte grfLangID;

    88

};

    89

    90

/**

    91

 * ISO code VS NewGrf langID conversion array.

    92

 * This array is used in two ways:

    93

 * 1-its ISO part is matching OpenTTD dynamic language id

    94

 *   with newgrf bit positionning language id

    95

 * 2-its shift part is used to know what is the shift to

    96

 *   watch for when inserting new strings, hence analysing newgrf langid

    97

 */

    98

const iso_grf iso_codes[] = {

    99

	{"en_US", GRFLX_AMERICAN},

   100

	{"en_GB", GRFLX_ENGLISH},

   101

	{"de_DE", GRFLX_GERMAN},

   102

	{"fr_FR", GRFLX_FRENCH},

   103

	{"es_ES", GRFLX_SPANISH},

   104

	{"af_ZA", GRFLX_AFRIKAANS},

   105

	{"hr_HR", GRFLX_CROATIAN},

   106

	{"cs_CZ", GRFLX_CZECH},

   107

	{"ca_ES", GRFLX_CATALAN},

   108

	{"da_DA", GRFLX_DANISH},

   109

	{"nl_NL", GRFLX_DUTCH},

   110

	{"et_ET", GRFLX_ESTONIAN},

   111

	{"fi_FI", GRFLX_FINNISH},

   112

	{"fy_NL", GRFLX_FRISIAN},

   113

	{"gl_ES", GRFLX_GALICIAN},

   114

	{"el_GR", GRFLX_GREEK},

   115

	{"hu_HU", GRFLX_HUNGARIAN},

   116

	{"is_IS", GRFLX_ICELANDIC},

   117

	{"it_IT", GRFLX_ITALIAN},

   118

	{"lv_LV", GRFLX_LATVIAN},

   119

	{"lt_LT", GRFLX_LITHUANIAN},

   120

	{"nb_NO", GRFLX_NORWEGIAN},

   121

	{"pl_PL", GRFLX_POLISH},

   122

	{"pt_PT", GRFLX_PORTUGUESE},

   123

	{"pt_BR", GRFLX_BRAZILIAN},

   124

	{"ro_RO", GRFLX_ROMANIAN},

   125

	{"ru_RU", GRFLX_RUSSIAN},

   126

	{"sk_SK", GRFLX_SLOVAK},

   127

	{"sl_SL", GRFLX_SLOVENIAN},

   128

	{"sv_SE", GRFLX_SWEDISH},

   129

	{"tr_TR", GRFLX_TURKISH},

   130

	{"uk_UA", GRFLX_UKRAINIAN},

   131

	{"eo_EO", GRFLX_ESPERANTO},

   132

	{"bg_BG", GRFLX_BULGARIAN},

   133

	{"ja_JP", GRFLX_JAPANESE},

   134

	{"ko_KR", GRFLX_KOREAN},

   135

	{"gen",   GRFLB_GENERIC}   ///< this is not iso code, but there has to be something...

   136

};

   137

   138

   139

/**

   140

 * Element of the linked list.

   141

 * Each of those elements represent the string,

   142

 * but according to a different lang.

   143

 */

   144

struct GRFText {

   145

	public:

   146

		static GRFText* New(byte langid, const char* text)

   147

		{

   148

			return new(strlen(text) + 1) GRFText(langid, text);

   149

		}

   150

   151

	private:

   152

		GRFText(byte langid_, const char* text_) : next(NULL), langid(langid_)

   153

		{

   154

			strcpy(text, text_);

   155

		}

   156

   157

		void* operator new(size_t size, size_t extra)

   158

		{

   159

			return ::operator new(size + extra);

   160

		}

   161

   162

public:

   163

		/* dummy operator delete to silence VC8:

   164

		 * 'void *GRFText::operator new(size_t,size_t)' : no matching operator delete found;

   165

		 *     memory will not be freed if initialization throws an exception */

   166

		void operator delete(void *p, size_t extra)

   167

		{

   168

			return ::operator delete(p);

   169

		}

   170

   171

	public:

   172

		GRFText *next;

   173

		byte langid;

   174

		char text[VARARRAY_SIZE];

   175

};

   176

   177

   178

/**

   179

 * Holder of the above structure.

   180

 * Putting both grfid and stringid together allows us to avoid duplicates,

   181

 * since it is NOT SUPPOSED to happen.

   182

 */

   183

struct GRFTextEntry {

   184

	uint32 grfid;

   185

	uint16 stringid;

   186

	StringID def_string;

   187

	GRFText *textholder;

   188

};

   189

   190

   191

static uint _num_grf_texts = 0;

   192

static GRFTextEntry _grf_text[(1 << TABSIZE) * 3];

   193

static byte _currentLangID = GRFLX_ENGLISH;  ///< by default, english is used.

   194

   195

   196

char *TranslateTTDPatchCodes(uint32 grfid, const char *str)

   197

{

   198

	char *tmp = MallocT<char>(strlen(str) * 10 + 1); // Allocate space to allow for expansion

   199

	char *d = tmp;

   200

	bool unicode = false;

   201

	WChar c;

   202

	size_t len = Utf8Decode(&c, str);

   203

   204

	if (c == 0x00DE) {

   205

		/* The thorn ('þ') indicates a unicode string to TTDPatch */

   206

		unicode = true;

   207

		str += len;

   208

	}

   209

   210

	for (;;) {

   211

		if (unicode && Utf8EncodedCharLen(*str) != 0) {

   212

			c = Utf8Consume(&str);

   213

			/* 'Magic' range of control codes. */

   214

			if (GB(c, 8, 8) == 0xE0) c = GB(c, 0, 8);

   215

		} else {

   216

			c = (byte)*str++;

   217

		}

   218

		if (c == 0) break;

   219

   220

		switch (c) {

   221

			case 0x01:

   222

				d += Utf8Encode(d, SCC_SETX);

   223

				*d++ = *str++;

   224

				break;

   225

			case 0x0A: break;

   226

			case 0x0D: *d++ = 0x0A; break;

   227

			case 0x0E: d += Utf8Encode(d, SCC_TINYFONT); break;

   228

			case 0x0F: d += Utf8Encode(d, SCC_BIGFONT); break;

   229

			case 0x1F:

   230

				d += Utf8Encode(d, SCC_SETXY);

   231

				*d++ = *str++;

   232

				*d++ = *str++;

   233

				break;

   234

			case 0x7B:

   235

			case 0x7C:

   236

			case 0x7D:

   237

			case 0x7E:

   238

			case 0x7F:

   239

			case 0x80: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD + c - 0x7B); break;

   240

			case 0x81: {

   241

				StringID string;

   242

				string  = ((uint8)*str++);

   243

				string |= ((uint8)*str++) << 8;

   244

				d += Utf8Encode(d, SCC_STRING_ID);

   245

				d += Utf8Encode(d, MapGRFStringID(grfid, string));

   246

				break;

   247

			}

   248

			case 0x82:

   249

			case 0x83:

   250

			case 0x84: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_SPEED + c - 0x82); break;

   251

			case 0x85: d += Utf8Encode(d, SCC_NEWGRF_DISCARD_WORD);       break;

   252

			case 0x86: d += Utf8Encode(d, SCC_NEWGRF_ROTATE_TOP_4_WORDS); break;

   253

			case 0x87: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_LITRES);  break;

   254

			case 0x88: d += Utf8Encode(d, SCC_BLUE);    break;

   255

			case 0x89: d += Utf8Encode(d, SCC_SILVER);  break;

   256

			case 0x8A: d += Utf8Encode(d, SCC_GOLD);    break;

   257

			case 0x8B: d += Utf8Encode(d, SCC_RED);     break;

   258

			case 0x8C: d += Utf8Encode(d, SCC_PURPLE);  break;

   259

			case 0x8D: d += Utf8Encode(d, SCC_LTBROWN); break;

   260

			case 0x8E: d += Utf8Encode(d, SCC_ORANGE);  break;

   261

			case 0x8F: d += Utf8Encode(d, SCC_GREEN);   break;

   262

			case 0x90: d += Utf8Encode(d, SCC_YELLOW);  break;

   263

			case 0x91: d += Utf8Encode(d, SCC_DKGREEN); break;

   264

			case 0x92: d += Utf8Encode(d, SCC_CREAM);   break;

   265

			case 0x93: d += Utf8Encode(d, SCC_BROWN);   break;

   266

			case 0x94: d += Utf8Encode(d, SCC_WHITE);   break;

   267

			case 0x95: d += Utf8Encode(d, SCC_LTBLUE);  break;

   268

			case 0x96: d += Utf8Encode(d, SCC_GRAY);    break;

   269

			case 0x97: d += Utf8Encode(d, SCC_DKBLUE);  break;

   270

			case 0x98: d += Utf8Encode(d, SCC_BLACK);   break;

   271

			case 0x9A:

   272

				switch (*str++) {

   273

					case 0: /* FALL THROUGH */

   274

					case 1:

   275

						d += Utf8Encode(d, SCC_NEWGRF_PRINT_QWORD_CURRENCY);

   276

						break;

   277

					case 3: {

   278

						uint16 tmp  = ((uint8)*str++);

   279

						tmp        |= ((uint8)*str++) << 8;

   280

						d += Utf8Encode(d, SCC_NEWGRF_PUSH_WORD);

   281

						d += Utf8Encode(d, tmp);

   282

					} break;

   283

					case 4:

   284

						d += Utf8Encode(d, SCC_NEWGRF_UNPRINT);

   285

						d += Utf8Encode(d, *str++);

   286

						break;

   287

					case 6:

   288

						d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_BYTE);

   289

						break;

   290

					case 7:

   291

						d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_WORD);

   292

						break;

   293

					case 8:

   294

						d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_DWORD);

   295

						break;

   296

   297

					default:

   298

						grfmsg(1, "missing handler for extended format code");

   299

						break;

   300

				}

   301

				break;

   302

   303

			case 0x9E: d += Utf8Encode(d, 0x20AC); break; // Euro

   304

			case 0x9F: d += Utf8Encode(d, 0x0178); break; // Y with diaeresis

   305

			case 0xA0: d += Utf8Encode(d, SCC_UPARROW); break;

   306

			case 0xAA: d += Utf8Encode(d, SCC_DOWNARROW); break;

   307

			case 0xAC: d += Utf8Encode(d, SCC_CHECKMARK); break;

   308

			case 0xAD: d += Utf8Encode(d, SCC_CROSS); break;

   309

			case 0xAF: d += Utf8Encode(d, SCC_RIGHTARROW); break;

   310

			case 0xB4: d += Utf8Encode(d, SCC_TRAIN); break;

   311

			case 0xB5: d += Utf8Encode(d, SCC_LORRY); break;

   312

			case 0xB6: d += Utf8Encode(d, SCC_BUS); break;

   313

			case 0xB7: d += Utf8Encode(d, SCC_PLANE); break;

   314

			case 0xB8: d += Utf8Encode(d, SCC_SHIP); break;

   315

			case 0xB9: d += Utf8Encode(d, SCC_SUPERSCRIPT_M1); break;

   316

			case 0xBC: d += Utf8Encode(d, SCC_SMALLUPARROW); break;

   317

			case 0xBD: d += Utf8Encode(d, SCC_SMALLDOWNARROW); break;

   318

			default:

   319

				/* Validate any unhandled character */

   320

				if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';

   321

				d += Utf8Encode(d, c);

   322

				break;

   323

		}

   324

	}

   325

   326

	*d = '\0';

   327

	tmp = ReallocT(tmp, strlen(tmp) + 1);

   328

	return tmp;

   329

}

   330

   331

   332

/**

   333

 * Add the new read string into our structure.

   334

 */

   335

StringID AddGRFString(uint32 grfid, uint16 stringid, byte langid_to_add, bool new_scheme, const char *text_to_add, StringID def_string)

   336

{

   337

	char *translatedtext;

   338

	uint id;

   339

   340

	/* When working with the old language scheme (grf_version is less than 7) and

   341

	 * English or American is among the set bits, simply add it as English in

   342

	 * the new scheme, i.e. as langid = 1.

   343

	 * If English is set, it is pretty safe to assume the translations are not

   344

	 * actually translated.

   345

	 */

   346

	if (!new_scheme) {

   347

		if (HASBITS(langid_to_add, GRFLB_AMERICAN | GRFLB_ENGLISH)) {

   348

			langid_to_add = GRFLX_ENGLISH;

   349

		} else {

   350

			StringID ret = STR_EMPTY;

   351

			if (langid_to_add & GRFLB_GERMAN)  ret = AddGRFString(grfid, stringid, GRFLX_GERMAN,  true, text_to_add, def_string);

   352

			if (langid_to_add & GRFLB_FRENCH)  ret = AddGRFString(grfid, stringid, GRFLX_FRENCH,  true, text_to_add, def_string);

   353

			if (langid_to_add & GRFLB_SPANISH) ret = AddGRFString(grfid, stringid, GRFLX_SPANISH, true, text_to_add, def_string);

   354

			return ret;

   355

		}

   356

	}

   357

   358

	for (id = 0; id < _num_grf_texts; id++) {

   359

		if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {

   360

			break;

   361

		}

   362

	}

   363

   364

	/* Too many strings allocated, return empty */

   365

	if (id == lengthof(_grf_text)) return STR_EMPTY;

   366

   367

	translatedtext = TranslateTTDPatchCodes(grfid, text_to_add);

   368

   369

	GRFText *newtext = GRFText::New(langid_to_add, translatedtext);

   370

   371

	free(translatedtext);

   372

   373

	/* If we didn't find our stringid and grfid in the list, allocate a new id */

   374

	if (id == _num_grf_texts) _num_grf_texts++;

   375

   376

	if (_grf_text[id].textholder == NULL) {

   377

		_grf_text[id].grfid      = grfid;

   378

		_grf_text[id].stringid   = stringid;

   379

		_grf_text[id].def_string = def_string;

   380

		_grf_text[id].textholder = newtext;

   381

	} else {

   382

		GRFText **ptext, *text;

   383

		bool replaced = false;

   384

   385

		/* Loop through all languages and see if we can replace a string */

   386

		for (ptext = &_grf_text[id].textholder; (text = *ptext) != NULL; ptext = &text->next) {

   387

			if (text->langid != langid_to_add) continue;

   388

			newtext->next = text->next;

   389

			*ptext = newtext;

   390

			delete text;

   391

			replaced = true;

   392

			break;

   393

		}

   394

   395

		/* If a string wasn't replaced, then we must append the new string */

   396

		if (!replaced) *ptext = newtext;

   397

	}

   398

   399

	grfmsg(3, "Added 0x%X: grfid %08X string 0x%X lang 0x%X string '%s'", id, grfid, stringid, newtext->langid, newtext->text);

   400

   401

	return (GRFTAB << TABSIZE) + id;

   402

}

   403

   404

/* Used to remember the grfid that the last retrieved string came from */

   405

static uint32 _last_grfid = 0;

   406

   407

/**

   408

 * Returns the index for this stringid associated with its grfID

   409

 */

   410

StringID GetGRFStringID(uint32 grfid, uint16 stringid)

   411

{

   412

	uint id;

   413

   414

	/* grfid is zero when we're being called via an include */

   415

	if (grfid == 0) grfid = _last_grfid;

   416

   417

	for (id = 0; id < _num_grf_texts; id++) {

   418

		if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {

   419

			return (GRFTAB << TABSIZE) + id;

   420

		}

   421

	}

   422

   423

	return STR_UNDEFINED;

   424

}

   425

   426

   427

const char *GetGRFStringPtr(uint16 stringid)

   428

{

   429

	const GRFText *default_text = NULL;

   430

	const GRFText *search_text;

   431

   432

	assert(_grf_text[stringid].grfid != 0);

   433

   434

	/* Remember this grfid in case the string has included text */

   435

	_last_grfid = _grf_text[stringid].grfid;

   436

   437

	/*Search the list of lang-strings of this stringid for current lang */

   438

	for (search_text = _grf_text[stringid].textholder; search_text != NULL; search_text = search_text->next) {

   439

		if (search_text->langid == _currentLangID) {

   440

			return search_text->text;

   441

		}

   442

   443

		/* If the current string is English or American, set it as the

   444

		 * fallback language if the specific language isn't available. */

   445

		if (search_text->langid == GRFLX_UNSPECIFIED || (default_text == NULL && (search_text->langid == GRFLX_ENGLISH || search_text->langid == GRFLX_AMERICAN))) {

   446

			default_text = search_text;

   447

		}

   448

	}

   449

   450

	/* If there is a fallback string, return that */

   451

	if (default_text != NULL) return default_text->text;

   452

   453

	/* Use the default string ID if the fallback string isn't available */

   454

	return GetStringPtr(_grf_text[stringid].def_string);

   455

}

   456

   457

/**

   458

 * Equivalence Setter function between game and newgrf langID.

   459

 * This function will adjust _currentLangID as to what is the LangID

   460

 * of the current language set by the user.

   461

 * The array iso_codes will be used to find that match.

   462

 * If not found, it will have to be standard english

   463

 * This function is called after the user changed language,

   464

 * from strings.cpp:ReadLanguagePack

   465

 * @param iso_name iso code of current selection

   466

 */

   467

void SetCurrentGrfLangID(const char *iso_name)

   468

{

   469

	/* Use English by default, if we can't match up the iso_code. */

   470

	byte ret = GRFLX_ENGLISH;

   471

	byte i;

   472

   473

	for (i=0; i < lengthof(iso_codes); i++) {

   474

		if (strncmp(iso_codes[i].code, iso_name, strlen(iso_codes[i].code)) == 0) {

   475

			/* We found a match, so let's use it. */

   476

			ret = iso_codes[i].grfLangID;

   477

			break;

   478

		}

   479

	}

   480

	_currentLangID = ret;

   481

}

   482

   483

bool CheckGrfLangID(byte lang_id, byte grf_version)

   484

{

   485

	if (grf_version < 7) {

   486

		switch (_currentLangID) {

   487

			case GRFLX_GERMAN:  return (lang_id & GRFLB_GERMAN)  != 0;

   488

			case GRFLX_FRENCH:  return (lang_id & GRFLB_FRENCH)  != 0;

   489

			case GRFLX_SPANISH: return (lang_id & GRFLB_SPANISH) != 0;

   490

			default:            return (lang_id & (GRFLB_ENGLISH | GRFLB_AMERICAN)) != 0;

   491

		}

   492

	}

   493

   494

	return (lang_id == _currentLangID || lang_id == GRFLX_UNSPECIFIED);

   495

}

   496