src/newgrf_text.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /**
  11  * @file newgrf_text.cpp
  12  * Implementation of  Action 04 "universal holder" structure and functions.
  13  * This file implements a linked-lists of strings,
  14  * holding everything that the newgrf action 04 will send over to OpenTTD.
  15  * One of the biggest problems is that Dynamic lang Array uses ISO codes
  16  * as way to identifying current user lang, while newgrf uses bit shift codes
  17  * not related to ISO.  So equivalence functionnality had to be set.
  18  */
  19
  20 #include "stdafx.h"
  21 #include "newgrf.h"
  22 #include "strings_func.h"
  23 #include "newgrf_storage.h"
  24 #include "newgrf_text.h"
  25 #include "newgrf_cargo.h"
  26 #include "string.h"
  27 #include "date_type.h"
  28 #include "debug.h"
  29 #include "core/alloc_type.hpp"
  30 #include "core/smallmap_type.hpp"
  31 #include "language.h"
  32
  33 #include "table/strings.h"
  34 #include "table/control_codes.h"
  35
  36 #define GRFTAB  28
  37 #define TABSIZE 11
  38
  39 /**
  40  * Explains the newgrf shift bit positioning.
  41  * the grf base will not be used in order to find the string, but rather for
  42  * jumping from standard langID scheme to the new one.
  43  */
  44 enum GRFBaseLanguages {
  45         GRFLB_AMERICAN    = 0x01,
  46         GRFLB_ENGLISH     = 0x02,
  47         GRFLB_GERMAN      = 0x04,
  48         GRFLB_FRENCH      = 0x08,
  49         GRFLB_SPANISH     = 0x10,
  50         GRFLB_GENERIC     = 0x80,
  51 };
  52
  53 enum GRFExtendedLanguages {
  54         GRFLX_AMERICAN    = 0x00,
  55         GRFLX_ENGLISH     = 0x01,
  56         GRFLX_GERMAN      = 0x02,
  57         GRFLX_FRENCH      = 0x03,
  58         GRFLX_SPANISH     = 0x04,
  59         GRFLX_UNSPECIFIED = 0x7F,
  60 };
  61
  62
  63 /**
  64  * Holder of a GRFTextMap.
  65  * Putting both grfid and stringid together allows us to avoid duplicates,
  66  * since it is NOT SUPPOSED to happen.
  67  */
  68 struct GRFTextEntry {
  69         uint32 grfid;
  70         uint16 stringid;
  71         StringID def_string;
  72         GRFTextMap *map;
  73 };
  74
  75
  76 static uint _num_grf_texts = 0;
  77 static GRFTextEntry _grf_text[(1 << TABSIZE) * 3];
  78 static byte _currentLangID = GRFLX_ENGLISH;  ///< by default, english is used.
  79
  80 /**
  81  * Get the mapping from the NewGRF supplied ID to OpenTTD's internal ID.
  82  * @param newgrf_id The NewGRF ID to map.
  83  * @param gender    Whether to map genders or cases.
  84  * @return The, to OpenTTD's internal ID, mapped index, or -1 if there is no mapping.
  85  */
  86 int LanguageMap::GetMapping(int newgrf_id, bool gender) const
  87 {
  88         const SmallVector<Mapping, 1> &map = gender ? this->gender_map : this->case_map;
  89         for (const Mapping *m = map.Begin(); m != map.End(); m++) {
  90                 if (m->newgrf_id == newgrf_id) return m->openttd_id;
  91         }
  92         return -1;
  93 }
  94
  95 /**
  96  * Get the mapping from OpenTTD's internal ID to the NewGRF supplied ID.
  97  * @param openttd_id The OpenTTD ID to map.
  98  * @param gender     Whether to map genders or cases.
  99  * @return The, to the NewGRF supplied ID, mapped index, or -1 if there is no mapping.
 100  */
 101 int LanguageMap::GetReverseMapping(int openttd_id, bool gender) const
 102 {
 103         const SmallVector<Mapping, 1> &map = gender ? this->gender_map : this->case_map;
 104         for (const Mapping *m = map.Begin(); m != map.End(); m++) {
 105                 if (m->openttd_id == openttd_id) return m->newgrf_id;
 106         }
 107         return -1;
 108 }
 109
 110
 111 /** Construct a copy of this text map. */
 112 GRFTextMap::GRFTextMap (const GRFTextMap &other)
 113         : std::map <byte, GRFText *> (other)
 114 {
 115         for (iterator iter = this->begin(); iter != this->end(); iter++) {
 116                 iter->second = iter->second->clone();
 117         }
 118 }
 119
 120 /** Destroy the text map. */
 121 GRFTextMap::~GRFTextMap()
 122 {
 123         for (iterator iter = this->begin(); iter != this->end(); iter++) {
 124                 delete iter->second;
 125         }
 126 }
 127
 128 /** Get the GRFText for the current language, or a default. */
 129 const GRFText *GRFTextMap::get_current (void) const
 130 {
 131         byte langs[4] = { _currentLangID, GRFLX_UNSPECIFIED, GRFLX_ENGLISH, GRFLX_AMERICAN };
 132
 133         for (uint i = 0; i < lengthof(langs); i++) {
 134                 const_iterator iter = this->find (langs[i]);
 135                 if (iter != this->end()) return iter->second;
 136         }
 137
 138         return NULL;
 139 }
 140
 141 /** Add a GRFText to this map. */
 142 void GRFTextMap::add (byte langid, GRFText *text)
 143 {
 144         std::pair <iterator, bool> pair =
 145                         this->insert (std::make_pair (langid, text));
 146
 147         if (!pair.second) {
 148                 /* The langid already existed in the map. */
 149                 GRFText *old = pair.first->second;
 150                 pair.first->second = text;
 151                 delete old;
 152         }
 153 }
 154
 155 /**
 156  * Add a string to this map.
 157  * @param langid The language of the new text.
 158  * @param grfid The grfid where this string is defined.
 159  * @param allow_newlines Whether newlines are allowed in this string.
 160  * @param text The text to add to the list.
 161  * @note All text-codes will be translated.
 162  */
 163 void GRFTextMap::add (byte langid, uint32 grfid, bool allow_newlines, const char *text)
 164 {
 165         int len;
 166         char *translatedtext = TranslateTTDPatchCodes (grfid, langid, allow_newlines, text, &len);
 167         GRFText *newtext = GRFText::create (translatedtext, len);
 168         free (translatedtext);
 169
 170         this->add (langid, newtext);
 171 }
 172
 173
 174 /** Helper structure for mapping choice lists. */
 175 struct UnmappedChoiceList : ZeroedMemoryAllocator {
 176         /** Clean everything up. */
 177         ~UnmappedChoiceList()
 178         {
 179                 for (SmallPair<byte, char *> *p = this->strings.Begin(); p < this->strings.End(); p++) {
 180                         free(p->second);
 181                 }
 182         }
 183
 184         /**
 185          * Initialise the mapping.
 186          * @param type   The type of mapping.
 187          * @param old_d  The old begin of the string, i.e. from where to start writing again.
 188          * @param offset The offset to get the plural/gender from.
 189          */
 190         UnmappedChoiceList(StringControlCode type, char *old_d, int offset) :
 191                 type(type), old_d(old_d), offset(offset)
 192         {
 193         }
 194
 195         StringControlCode type; ///< The type of choice list.
 196         char *old_d;            ///< The old/original location of the "d" local variable.
 197         int offset;             ///< The offset for the plural/gender form.
 198
 199         /** Mapping of NewGRF supplied ID to the different strings in the choice list. */
 200         SmallMap<byte, char *> strings;
 201
 202         /**
 203          * Flush this choice list into the old d variable.
 204          * @param lm  The current language mapping.
 205          * @return The new location of the output string.
 206          */
 207         char *Flush(const LanguageMap *lm)
 208         {
 209                 if (!this->strings.Contains(0)) {
 210                         /* In case of a (broken) NewGRF without a default,
 211                          * assume an empty string. */
 212                         grfmsg(1, "choice list misses default value");
 213                         this->strings[0] = xstrdup("");
 214                 }
 215
 216                 char *d = old_d;
 217                 if (lm == NULL) {
 218                         /* In case there is no mapping, just ignore everything but the default.
 219                          * A probable cause for this happening is when the language file has
 220                          * been removed by the user and as such no mapping could be made. */
 221                         size_t len = strlen(this->strings[0]);
 222                         memcpy(d, this->strings[0], len);
 223                         return d + len;
 224                 }
 225
 226                 d += Utf8Encode(d, this->type);
 227
 228                 if (this->type == SCC_SWITCH_CASE) {
 229                         /*
 230                          * Format for case switch:
 231                          * <NUM CASES> <CASE1> <LEN1> <STRING1> <CASE2> <LEN2> <STRING2> <CASE3> <LEN3> <STRING3> <STRINGDEFAULT>
 232                          * Each LEN is printed using 2 bytes in big endian order.
 233                          */
 234
 235                         /* "<NUM CASES>" */
 236                         int count = 0;
 237                         for (uint8 i = 0; i < _current_language->num_cases; i++) {
 238                                 /* Count the ones we have a mapped string for. */
 239                                 if (this->strings.Contains(lm->GetReverseMapping(i, false))) count++;
 240                         }
 241                         *d++ = count;
 242
 243                         for (uint8 i = 0; i < _current_language->num_cases; i++) {
 244                                 /* Resolve the string we're looking for. */
 245                                 int idx = lm->GetReverseMapping(i, false);
 246                                 if (!this->strings.Contains(idx)) continue;
 247                                 char *str = this->strings[idx];
 248
 249                                 /* "<CASEn>" */
 250                                 *d++ = i + 1;
 251
 252                                 /* "<LENn>" */
 253                                 size_t len = strlen(str) + 1;
 254                                 *d++ = GB(len, 8, 8);
 255                                 *d++ = GB(len, 0, 8);
 256
 257                                 /* "<STRINGn>" */
 258                                 memcpy(d, str, len);
 259                                 d += len;
 260                         }
 261
 262                         /* "<STRINGDEFAULT>" */
 263                         size_t len = strlen(this->strings[0]) + 1;
 264                         memcpy(d, this->strings[0], len);
 265                         d += len;
 266                 } else {
 267                         if (this->type == SCC_PLURAL_LIST) {
 268                                 *d++ = lm->plural_form;
 269                         }
 270
 271                         /*
 272                          * Format for choice list:
 273                          * <OFFSET> <NUM CHOICES> <LENs> <STRINGs>
 274                          */
 275
 276                         /* "<OFFSET>" */
 277                         *d++ = this->offset - 0x80;
 278
 279                         /* "<NUM CHOICES>" */
 280                         int count = (this->type == SCC_GENDER_LIST ? _current_language->num_genders : LANGUAGE_MAX_PLURAL_FORMS);
 281                         *d++ = count;
 282
 283                         /* "<LENs>" */
 284                         for (int i = 0; i < count; i++) {
 285                                 int idx = (this->type == SCC_GENDER_LIST ? lm->GetReverseMapping(i, true) : i + 1);
 286                                 const char *str = this->strings[this->strings.Contains(idx) ? idx : 0];
 287                                 size_t len = strlen(str) + 1;
 288                                 if (len > 0xFF) grfmsg(1, "choice list string is too long");
 289                                 *d++ = GB(len, 0, 8);
 290                         }
 291
 292                         /* "<STRINGs>" */
 293                         for (int i = 0; i < count; i++) {
 294                                 int idx = (this->type == SCC_GENDER_LIST ? lm->GetReverseMapping(i, true) : i + 1);
 295                                 const char *str = this->strings[this->strings.Contains(idx) ? idx : 0];
 296                                 /* Limit the length of the string we copy to 0xFE. The length is written above
 297                                  * as a byte and we need room for the final '\0'. */
 298                                 size_t len = min<size_t>(0xFE, strlen(str));
 299                                 memcpy(d, str, len);
 300                                 d += len;
 301                                 *d++ = '\0';
 302                         }
 303                 }
 304                 return d;
 305         }
 306 };
 307
 308 /**
 309  * Translate TTDPatch string codes into something OpenTTD can handle (better).
 310  * @param grfid          The (NewGRF) ID associated with this string
 311  * @param language_id    The (NewGRF) language ID associated with this string.
 312  * @param allow_newlines Whether newlines are allowed in the string or not.
 313  * @param str            The string to translate.
 314  * @param [out] olen     The length of the final string.
 315  * @param byte80         The control code to use as replacement for the 0x80-value.
 316  * @return The translated string.
 317  */
 318 char *TranslateTTDPatchCodes(uint32 grfid, uint8 language_id, bool allow_newlines, const char *str, int *olen, StringControlCode byte80)
 319 {
 320         char *tmp = xmalloc (strlen(str) * 10 + 1); // Allocate space to allow for expansion
 321         char *d = tmp;
 322         bool unicode = false;
 323         WChar c;
 324         size_t len = Utf8Decode(&c, str);
 325
 326         /* Helper variable for a possible (string) mapping. */
 327         UnmappedChoiceList *mapping = NULL;
 328
 329         if (c == NFO_UTF8_IDENTIFIER) {
 330                 unicode = true;
 331                 str += len;
 332         }
 333
 334         for (;;) {
 335                 if (unicode && Utf8EncodedCharLen(*str) != 0) {
 336                         c = Utf8Consume(&str);
 337                         /* 'Magic' range of control codes. */
 338                         if (GB(c, 8, 8) == 0xE0) {
 339                                 c = GB(c, 0, 8);
 340                         } else if (c >= 0x20) {
 341                                 if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';
 342                                 d += Utf8Encode(d, c);
 343                                 continue;
 344                         }
 345                 } else {
 346                         c = (byte)*str++;
 347                 }
 348                 if (c == '\0') break;
 349
 350                 switch (c) {
 351                         case 0x01:
 352                                 if (str[0] == '\0') goto string_end;
 353                                 d += Utf8Encode(d, ' ');
 354                                 str++;
 355                                 break;
 356                         case 0x0A: break;
 357                         case 0x0D:
 358                                 if (allow_newlines) {
 359                                         *d++ = 0x0A;
 360                                 } else {
 361                                         grfmsg(1, "Detected newline in string that does not allow one");
 362                                 }
 363                                 break;
 364                         case 0x0E: d += Utf8Encode(d, SCC_TINYFONT); break;
 365                         case 0x0F: d += Utf8Encode(d, SCC_BIGFONT); break;
 366                         case 0x1F:
 367                                 if (str[0] == '\0' || str[1] == '\0') goto string_end;
 368                                 d += Utf8Encode(d, ' ');
 369                                 str += 2;
 370                                 break;
 371                         case 0x7B:
 372                         case 0x7C:
 373                         case 0x7D:
 374                         case 0x7E:
 375                         case 0x7F: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD_SIGNED + c - 0x7B); break;
 376                         case 0x80: d += Utf8Encode(d, byte80); break;
 377                         case 0x81: {
 378                                 if (str[0] == '\0' || str[1] == '\0') goto string_end;
 379                                 StringID string;
 380                                 string  = ((uint8)*str++);
 381                                 string |= ((uint8)*str++) << 8;
 382                                 d += Utf8Encode(d, SCC_NEWGRF_STRINL);
 383                                 d += Utf8Encode(d, MapGRFStringID(grfid, string));
 384                                 break;
 385                         }
 386                         case 0x82:
 387                         case 0x83:
 388                         case 0x84: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_DATE_LONG + c - 0x82); break;
 389                         case 0x85: d += Utf8Encode(d, SCC_NEWGRF_DISCARD_WORD);       break;
 390                         case 0x86: d += Utf8Encode(d, SCC_NEWGRF_ROTATE_TOP_4_WORDS); break;
 391                         case 0x87: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_VOLUME_LONG);  break;
 392                         case 0x88: d += Utf8Encode(d, SCC_BLUE);    break;
 393                         case 0x89: d += Utf8Encode(d, SCC_SILVER);  break;
 394                         case 0x8A: d += Utf8Encode(d, SCC_GOLD);    break;
 395                         case 0x8B: d += Utf8Encode(d, SCC_RED);     break;
 396                         case 0x8C: d += Utf8Encode(d, SCC_PURPLE);  break;
 397                         case 0x8D: d += Utf8Encode(d, SCC_LTBROWN); break;
 398                         case 0x8E: d += Utf8Encode(d, SCC_ORANGE);  break;
 399                         case 0x8F: d += Utf8Encode(d, SCC_GREEN);   break;
 400                         case 0x90: d += Utf8Encode(d, SCC_YELLOW);  break;
 401                         case 0x91: d += Utf8Encode(d, SCC_DKGREEN); break;
 402                         case 0x92: d += Utf8Encode(d, SCC_CREAM);   break;
 403                         case 0x93: d += Utf8Encode(d, SCC_BROWN);   break;
 404                         case 0x94: d += Utf8Encode(d, SCC_WHITE);   break;
 405                         case 0x95: d += Utf8Encode(d, SCC_LTBLUE);  break;
 406                         case 0x96: d += Utf8Encode(d, SCC_GRAY);    break;
 407                         case 0x97: d += Utf8Encode(d, SCC_DKBLUE);  break;
 408                         case 0x98: d += Utf8Encode(d, SCC_BLACK);   break;
 409                         case 0x9A: {
 410                                 int code = *str++;
 411                                 switch (code) {
 412                                         case 0x00: goto string_end;
 413                                         case 0x01: d += Utf8Encode(d, SCC_NEWGRF_PRINT_QWORD_CURRENCY); break;
 414                                         /* 0x02: ignore next colour byte is not supported. It works on the final
 415                                          * string and as such hooks into the string drawing routine. At that
 416                                          * point many things already happened, such as splitting up of strings
 417                                          * when drawn over multiple lines or right-to-left translations, which
 418                                          * make the behaviour peculiar, e.g. only happening at specific width
 419                                          * of windows. Or we need to add another pass over the string to just
 420                                          * support this. As such it is not implemented in OpenTTD. */
 421                                         case 0x03: {
 422                                                 if (str[0] == '\0' || str[1] == '\0') goto string_end;
 423                                                 uint16 tmp  = ((uint8)*str++);
 424                                                 tmp        |= ((uint8)*str++) << 8;
 425                                                 d += Utf8Encode(d, SCC_NEWGRF_PUSH_WORD);
 426                                                 d += Utf8Encode(d, tmp);
 427                                                 break;
 428                                         }
 429                                         case 0x04:
 430                                                 if (str[0] == '\0') goto string_end;
 431                                                 d += Utf8Encode(d, SCC_NEWGRF_UNPRINT);
 432                                                 d += Utf8Encode(d, *str++);
 433                                                 break;
 434                                         case 0x06: d += Utf8Encode(d, SCC_NEWGRF_PRINT_BYTE_HEX);          break;
 435                                         case 0x07: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_HEX);          break;
 436                                         case 0x08: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD_HEX);         break;
 437                                         /* 0x09, 0x0A are TTDPatch internal use only string codes. */
 438                                         case 0x0B: d += Utf8Encode(d, SCC_NEWGRF_PRINT_QWORD_HEX);         break;
 439                                         case 0x0C: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_STATION_NAME); break;
 440                                         case 0x0D: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_WEIGHT_LONG);  break;
 441                                         case 0x0E:
 442                                         case 0x0F: {
 443                                                 if (str[0] == '\0') goto string_end;
 444                                                 const LanguageMap *lm = LanguageMap::GetLanguageMap(grfid, language_id);
 445                                                 int index = *str++;
 446                                                 int mapped = lm != NULL ? lm->GetMapping(index, code == 0x0E) : -1;
 447                                                 if (mapped >= 0) {
 448                                                         d += Utf8Encode(d, code == 0x0E ? SCC_GENDER_INDEX : SCC_SET_CASE);
 449                                                         d += Utf8Encode(d, code == 0x0E ? mapped : mapped + 1);
 450                                                 }
 451                                                 break;
 452                                         }
 453
 454                                         case 0x10:
 455                                         case 0x11:
 456                                                 if (str[0] == '\0') goto string_end;
 457                                                 if (mapping == NULL) {
 458                                                         if (code == 0x10) str++; // Skip the index
 459                                                         grfmsg(1, "choice list %s marker found when not expected", code == 0x10 ? "next" : "default");
 460                                                         break;
 461                                                 } else {
 462                                                         /* Terminate the previous string. */
 463                                                         *d = '\0';
 464                                                         int index = (code == 0x10 ? *str++ : 0);
 465                                                         if (mapping->strings.Contains(index)) {
 466                                                                 grfmsg(1, "duplicate choice list string, ignoring");
 467                                                                 d++;
 468                                                         } else {
 469                                                                 d = mapping->strings[index] = xmalloc (strlen(str) * 10 + 1);
 470                                                         }
 471                                                 }
 472                                                 break;
 473
 474                                         case 0x12:
 475                                                 if (mapping == NULL) {
 476                                                         grfmsg(1, "choice list end marker found when not expected");
 477                                                 } else {
 478                                                         /* Terminate the previous string. */
 479                                                         *d = '\0';
 480
 481                                                         /* Now we can start flushing everything and clean everything up. */
 482                                                         d = mapping->Flush(LanguageMap::GetLanguageMap(grfid, language_id));
 483                                                         delete mapping;
 484                                                         mapping = NULL;
 485                                                 }
 486                                                 break;
 487
 488                                         case 0x13:
 489                                         case 0x14:
 490                                         case 0x15:
 491                                                 if (str[0] == '\0') goto string_end;
 492                                                 if (mapping != NULL) {
 493                                                         grfmsg(1, "choice lists can't be stacked, it's going to get messy now...");
 494                                                         if (code != 0x14) str++;
 495                                                 } else {
 496                                                         static const StringControlCode mp[] = { SCC_GENDER_LIST, SCC_SWITCH_CASE, SCC_PLURAL_LIST };
 497                                                         mapping = new UnmappedChoiceList(mp[code - 0x13], d, code == 0x14 ? 0 : *str++);
 498                                                 }
 499                                                 break;
 500
 501                                         case 0x16:
 502                                         case 0x17:
 503                                         case 0x18:
 504                                         case 0x19:
 505                                         case 0x1A:
 506                                         case 0x1B:
 507                                         case 0x1C:
 508                                         case 0x1D:
 509                                         case 0x1E:
 510                                                 d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD_DATE_LONG + code - 0x16);
 511                                                 break;
 512
 513                                         default:
 514                                                 grfmsg(1, "missing handler for extended format code");
 515                                                 break;
 516                                 }
 517                                 break;
 518                         }
 519
 520                         case 0x9E: d += Utf8Encode(d, 0x20AC);               break; // Euro
 521                         case 0x9F: d += Utf8Encode(d, 0x0178);               break; // Y with diaeresis
 522                         case 0xA0: d += Utf8Encode(d, SCC_UP_ARROW);         break;
 523                         case 0xAA: d += Utf8Encode(d, SCC_DOWN_ARROW);       break;
 524                         case 0xAC: d += Utf8Encode(d, SCC_CHECKMARK);        break;
 525                         case 0xAD: d += Utf8Encode(d, SCC_CROSS);            break;
 526                         case 0xAF: d += Utf8Encode(d, SCC_RIGHT_ARROW);      break;
 527                         case 0xB4: d += Utf8Encode(d, SCC_TRAIN);            break;
 528                         case 0xB5: d += Utf8Encode(d, SCC_LORRY);            break;
 529                         case 0xB6: d += Utf8Encode(d, SCC_BUS);              break;
 530                         case 0xB7: d += Utf8Encode(d, SCC_PLANE);            break;
 531                         case 0xB8: d += Utf8Encode(d, SCC_SHIP);             break;
 532                         case 0xB9: d += Utf8Encode(d, SCC_SUPERSCRIPT_M1);   break;
 533                         case 0xBC: d += Utf8Encode(d, SCC_SMALL_UP_ARROW);   break;
 534                         case 0xBD: d += Utf8Encode(d, SCC_SMALL_DOWN_ARROW); break;
 535                         default:
 536                                 /* Validate any unhandled character */
 537                                 if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';
 538                                 d += Utf8Encode(d, c);
 539                                 break;
 540                 }
 541         }
 542
 543 string_end:
 544         if (mapping != NULL) {
 545                 grfmsg(1, "choice list was incomplete, the whole list is ignored");
 546                 delete mapping;
 547         }
 548
 549         *d = '\0';
 550         if (olen != NULL) *olen = d - tmp + 1;
 551         tmp = xrealloc (tmp, d - tmp + 1);
 552         return tmp;
 553 }
 554
 555 /**
 556  * Add the new read string into our structure.
 557  */
 558 StringID AddGRFString(uint32 grfid, uint16 stringid, byte langid_to_add, bool new_scheme, bool allow_newlines, const char *text_to_add, StringID def_string)
 559 {
 560         char *translatedtext;
 561         uint id;
 562
 563         /* When working with the old language scheme (grf_version is less than 7) and
 564          * English or American is among the set bits, simply add it as English in
 565          * the new scheme, i.e. as langid = 1.
 566          * If English is set, it is pretty safe to assume the translations are not
 567          * actually translated.
 568          */
 569         if (!new_scheme) {
 570                 if (langid_to_add & (GRFLB_AMERICAN | GRFLB_ENGLISH)) {
 571                         langid_to_add = GRFLX_ENGLISH;
 572                 } else {
 573                         StringID ret = STR_EMPTY;
 574                         if (langid_to_add & GRFLB_GERMAN)  ret = AddGRFString(grfid, stringid, GRFLX_GERMAN,  true, allow_newlines, text_to_add, def_string);
 575                         if (langid_to_add & GRFLB_FRENCH)  ret = AddGRFString(grfid, stringid, GRFLX_FRENCH,  true, allow_newlines, text_to_add, def_string);
 576                         if (langid_to_add & GRFLB_SPANISH) ret = AddGRFString(grfid, stringid, GRFLX_SPANISH, true, allow_newlines, text_to_add, def_string);
 577                         return ret;
 578                 }
 579         }
 580
 581         for (id = 0; id < _num_grf_texts; id++) {
 582                 if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {
 583                         break;
 584                 }
 585         }
 586
 587         /* Too many strings allocated, return empty */
 588         if (id == lengthof(_grf_text)) return STR_EMPTY;
 589
 590         int len;
 591         translatedtext = TranslateTTDPatchCodes(grfid, langid_to_add, allow_newlines, text_to_add, &len);
 592
 593         GRFText *newtext = GRFText::create (translatedtext, len);
 594
 595         free(translatedtext);
 596
 597         /* If we didn't find our stringid and grfid in the list, allocate a new id */
 598         if (id == _num_grf_texts) _num_grf_texts++;
 599
 600         if (_grf_text[id].map == NULL) {
 601                 _grf_text[id].grfid      = grfid;
 602                 _grf_text[id].stringid   = stringid;
 603                 _grf_text[id].def_string = def_string;
 604                 _grf_text[id].map        = new GRFTextMap;
 605         }
 606         _grf_text[id].map->add (langid_to_add, newtext);
 607
 608         grfmsg (3, "Added 0x%X: grfid %08X string 0x%X lang 0x%X string '%s'", id, grfid, stringid, langid_to_add, newtext->text);
 609
 610         return (GRFTAB << TABSIZE) + id;
 611 }
 612
 613 /**
 614  * Returns the index for this stringid associated with its grfID
 615  */
 616 StringID GetGRFStringID(uint32 grfid, uint16 stringid)
 617 {
 618         for (uint id = 0; id < _num_grf_texts; id++) {
 619                 if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {
 620                         return (GRFTAB << TABSIZE) + id;
 621                 }
 622         }
 623
 624         return STR_UNDEFINED;
 625 }
 626
 627
 628 /**
 629  * Get a C-string from a stringid set by a newgrf.
 630  */
 631 const char *GetGRFStringPtr(uint16 stringid)
 632 {
 633         assert(_grf_text[stringid].grfid != 0);
 634
 635         const char *str = _grf_text[stringid].map->get_string();
 636         if (str != NULL) return str;
 637
 638         /* Use the default string ID if the fallback string isn't available */
 639         return GetStringPtr(_grf_text[stringid].def_string);
 640 }
 641
 642 /**
 643  * Equivalence Setter function between game and newgrf langID.
 644  * This function will adjust _currentLangID as to what is the LangID
 645  * of the current language set by the user.
 646  * This function is called after the user changed language,
 647  * from strings.cpp:ReadLanguagePack
 648  * @param language_id iso code of current selection
 649  */
 650 void SetCurrentGrfLangID(byte language_id)
 651 {
 652         _currentLangID = language_id;
 653 }
 654
 655 bool CheckGrfLangID(byte lang_id, byte grf_version)
 656 {
 657         if (grf_version < 7) {
 658                 switch (_currentLangID) {
 659                         case GRFLX_GERMAN:  return (lang_id & GRFLB_GERMAN)  != 0;
 660                         case GRFLX_FRENCH:  return (lang_id & GRFLB_FRENCH)  != 0;
 661                         case GRFLX_SPANISH: return (lang_id & GRFLB_SPANISH) != 0;
 662                         default:            return (lang_id & (GRFLB_ENGLISH | GRFLB_AMERICAN)) != 0;
 663                 }
 664         }
 665
 666         return (lang_id == _currentLangID || lang_id == GRFLX_UNSPECIFIED);
 667 }
 668
 669 /**
 670  * House cleaning.
 671  * Remove all strings and reset the text counter.
 672  */
 673 void CleanUpStrings()
 674 {
 675         uint id;
 676
 677         for (id = 0; id < _num_grf_texts; id++) {
 678                 delete _grf_text[id].map;
 679                 _grf_text[id].grfid    = 0;
 680                 _grf_text[id].stringid = 0;
 681                 _grf_text[id].map      = NULL;
 682         }
 683
 684         _num_grf_texts = 0;
 685 }
 686
 687 struct TextRefStack {
 688         byte stack[0x30];
 689         byte position;
 690         const GRFFile *grffile;
 691         bool used;
 692
 693         TextRefStack() : position(0), grffile(NULL), used(false) {}
 694
 695         TextRefStack(const TextRefStack &stack) :
 696                 position(stack.position),
 697                 grffile(stack.grffile),
 698                 used(stack.used)
 699         {
 700                 memcpy(this->stack, stack.stack, sizeof(this->stack));
 701         }
 702
 703         uint8  PopUnsignedByte()  { assert(this->position < lengthof(this->stack)); return this->stack[this->position++]; }
 704         int8   PopSignedByte()    { return (int8)this->PopUnsignedByte(); }
 705
 706         uint16 PopUnsignedWord()
 707         {
 708                 uint16 val = this->PopUnsignedByte();
 709                 return val | (this->PopUnsignedByte() << 8);
 710         }
 711         int16  PopSignedWord()    { return (int32)this->PopUnsignedWord(); }
 712
 713         uint32 PopUnsignedDWord()
 714         {
 715                 uint32 val = this->PopUnsignedWord();
 716                 return val | (this->PopUnsignedWord() << 16);
 717         }
 718         int32  PopSignedDWord()   { return (int32)this->PopUnsignedDWord(); }
 719
 720         uint64 PopUnsignedQWord()
 721         {
 722                 uint64 val = this->PopUnsignedDWord();
 723                 return val | (((uint64)this->PopUnsignedDWord()) << 32);
 724         }
 725         int64  PopSignedQWord()   { return (int64)this->PopUnsignedQWord(); }
 726
 727         /** Rotate the top four words down: W1, W2, W3, W4 -> W4, W1, W2, W3 */
 728         void RotateTop4Words()
 729         {
 730                 byte tmp[2];
 731                 for (int i = 0; i  < 2; i++) tmp[i] = this->stack[this->position + i + 6];
 732                 for (int i = 5; i >= 0; i--) this->stack[this->position + i + 2] = this->stack[this->position + i];
 733                 for (int i = 0; i  < 2; i++) this->stack[this->position + i] = tmp[i];
 734         }
 735
 736         void PushWord(uint16 word)
 737         {
 738                 if (this->position >= 2) {
 739                         this->position -= 2;
 740                 } else {
 741                         for (int i = lengthof(stack) - 1; i >= this->position + 2; i--) {
 742                                 this->stack[i] = this->stack[i - 2];
 743                         }
 744                 }
 745                 this->stack[this->position]     = GB(word, 0, 8);
 746                 this->stack[this->position + 1] = GB(word, 8, 8);
 747         }
 748
 749         void ResetStack(const GRFFile *grffile)
 750         {
 751                 assert(grffile != NULL);
 752                 this->position = 0;
 753                 this->grffile = grffile;
 754                 this->used = true;
 755         }
 756
 757         void RewindStack() { this->position = 0; }
 758 };
 759
 760 /** The stack that is used for TTDP compatible string code parsing */
 761 static TextRefStack _newgrf_textrefstack;
 762
 763 /**
 764  * Check whether the NewGRF text stack is in use.
 765  * @return True iff the NewGRF text stack is used.
 766  */
 767 bool UsingNewGRFTextStack()
 768 {
 769         return _newgrf_textrefstack.used;
 770 }
 771
 772 /**
 773  * Create a backup of the current NewGRF text stack.
 774  * @return A copy of the current text stack.
 775  */
 776 struct TextRefStack *CreateTextRefStackBackup()
 777 {
 778         return new TextRefStack(_newgrf_textrefstack);
 779 }
 780
 781 /**
 782  * Restore a copy of the text stack to the used stack.
 783  * @param backup The copy to restore.
 784  */
 785 void RestoreTextRefStackBackup(struct TextRefStack *backup)
 786 {
 787         _newgrf_textrefstack = *backup;
 788         delete backup;
 789 }
 790
 791 /**
 792  * Start using the TTDP compatible string code parsing.
 793  *
 794  * On start a number of values is copied on the #TextRefStack.
 795  * You can then use #GetString() and the normal string drawing functions,
 796  * and they will use the #TextRefStack for NewGRF string codes.
 797  *
 798  * However, when you want to draw a string multiple times using the same stack,
 799  * you have to call #RewindTextRefStack() between draws.
 800  *
 801  * After you are done with drawing, you must disable usage of the #TextRefStack
 802  * by calling #StopTextRefStackUsage(), so NewGRF string codes operate on the
 803  * normal string parameters again.
 804  *
 805  * @param grffile the NewGRF providing the stack data
 806  * @param numEntries number of entries to copy from the registers
 807  * @param values values to copy onto the stack; if NULL the temporary NewGRF registers will be used instead
 808  */
 809 void StartTextRefStackUsage(const GRFFile *grffile, byte numEntries, const uint32 *values)
 810 {
 811         extern TemporaryStorageArray<int32, 0x110> _temp_store;
 812
 813         _newgrf_textrefstack.ResetStack(grffile);
 814
 815         byte *p = _newgrf_textrefstack.stack;
 816         for (uint i = 0; i < numEntries; i++) {
 817                 uint32 value = values != NULL ? values[i] : _temp_store.GetValue(0x100 + i);
 818                 for (uint j = 0; j < 32; j += 8) {
 819                         *p = GB(value, j, 8);
 820                         p++;
 821                 }
 822         }
 823 }
 824
 825 /** Stop using the TTDP compatible string code parsing */
 826 void StopTextRefStackUsage()
 827 {
 828         _newgrf_textrefstack.used = false;
 829 }
 830
 831 void RewindTextRefStack()
 832 {
 833         _newgrf_textrefstack.RewindStack();
 834 }
 835
 836 /**
 837  * FormatString for NewGRF specific "magic" string control codes
 838  * @param scc   the string control code that has been read
 839  * @param buf   the buffer we're writing to
 840  * @param str   the string that we need to write
 841  * @param argv  the OpenTTD stack of values
 842  * @param argv_size space on the stack \a argv
 843  * @param modify_argv When true, modify the OpenTTD stack.
 844  * @return the string control code to "execute" now
 845  */
 846 uint RemapNewGRFStringControlCode (uint scc, stringb *buf, const char **str, int64 *argv, uint argv_size, bool modify_argv)
 847 {
 848         switch (scc) {
 849                 default: break;
 850
 851                 case SCC_NEWGRF_PRINT_DWORD_SIGNED:
 852                 case SCC_NEWGRF_PRINT_WORD_SIGNED:
 853                 case SCC_NEWGRF_PRINT_BYTE_SIGNED:
 854                 case SCC_NEWGRF_PRINT_WORD_UNSIGNED:
 855                 case SCC_NEWGRF_PRINT_BYTE_HEX:
 856                 case SCC_NEWGRF_PRINT_WORD_HEX:
 857                 case SCC_NEWGRF_PRINT_DWORD_HEX:
 858                 case SCC_NEWGRF_PRINT_QWORD_HEX:
 859                 case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
 860                 case SCC_NEWGRF_PRINT_QWORD_CURRENCY:
 861                 case SCC_NEWGRF_PRINT_WORD_STRING_ID:
 862                 case SCC_NEWGRF_PRINT_WORD_DATE_LONG:
 863                 case SCC_NEWGRF_PRINT_DWORD_DATE_LONG:
 864                 case SCC_NEWGRF_PRINT_WORD_DATE_SHORT:
 865                 case SCC_NEWGRF_PRINT_DWORD_DATE_SHORT:
 866                 case SCC_NEWGRF_PRINT_WORD_SPEED:
 867                 case SCC_NEWGRF_PRINT_WORD_VOLUME_LONG:
 868                 case SCC_NEWGRF_PRINT_WORD_VOLUME_SHORT:
 869                 case SCC_NEWGRF_PRINT_WORD_WEIGHT_LONG:
 870                 case SCC_NEWGRF_PRINT_WORD_WEIGHT_SHORT:
 871                 case SCC_NEWGRF_PRINT_WORD_POWER:
 872                 case SCC_NEWGRF_PRINT_WORD_STATION_NAME:
 873                 case SCC_NEWGRF_PRINT_WORD_CARGO_NAME:
 874                         if (argv_size < 1) {
 875                                 DEBUG(misc, 0, "Too many NewGRF string parameters.");
 876                                 return 0;
 877                         }
 878                         break;
 879
 880                 case SCC_NEWGRF_PRINT_WORD_CARGO_LONG:
 881                 case SCC_NEWGRF_PRINT_WORD_CARGO_SHORT:
 882                 case SCC_NEWGRF_PRINT_WORD_CARGO_TINY:
 883                         if (argv_size < 2) {
 884                                 DEBUG(misc, 0, "Too many NewGRF string parameters.");
 885                                 return 0;
 886                         }
 887                         break;
 888         }
 889
 890         if (_newgrf_textrefstack.used && modify_argv) {
 891                 switch (scc) {
 892                         default: NOT_REACHED();
 893                         case SCC_NEWGRF_PRINT_BYTE_SIGNED:      *argv = _newgrf_textrefstack.PopSignedByte();    break;
 894                         case SCC_NEWGRF_PRINT_QWORD_CURRENCY:   *argv = _newgrf_textrefstack.PopSignedQWord();   break;
 895
 896                         case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
 897                         case SCC_NEWGRF_PRINT_DWORD_SIGNED:     *argv = _newgrf_textrefstack.PopSignedDWord();   break;
 898
 899                         case SCC_NEWGRF_PRINT_BYTE_HEX:         *argv = _newgrf_textrefstack.PopUnsignedByte();  break;
 900                         case SCC_NEWGRF_PRINT_QWORD_HEX:        *argv = _newgrf_textrefstack.PopUnsignedQWord(); break;
 901
 902                         case SCC_NEWGRF_PRINT_WORD_SPEED:
 903                         case SCC_NEWGRF_PRINT_WORD_VOLUME_LONG:
 904                         case SCC_NEWGRF_PRINT_WORD_VOLUME_SHORT:
 905                         case SCC_NEWGRF_PRINT_WORD_SIGNED:      *argv = _newgrf_textrefstack.PopSignedWord();    break;
 906
 907                         case SCC_NEWGRF_PRINT_WORD_HEX:
 908                         case SCC_NEWGRF_PRINT_WORD_WEIGHT_LONG:
 909                         case SCC_NEWGRF_PRINT_WORD_WEIGHT_SHORT:
 910                         case SCC_NEWGRF_PRINT_WORD_POWER:
 911                         case SCC_NEWGRF_PRINT_WORD_STATION_NAME:
 912                         case SCC_NEWGRF_PRINT_WORD_UNSIGNED:    *argv = _newgrf_textrefstack.PopUnsignedWord();  break;
 913
 914                         case SCC_NEWGRF_PRINT_DWORD_DATE_LONG:
 915                         case SCC_NEWGRF_PRINT_DWORD_DATE_SHORT:
 916                         case SCC_NEWGRF_PRINT_DWORD_HEX:        *argv = _newgrf_textrefstack.PopUnsignedDWord(); break;
 917
 918                         case SCC_NEWGRF_PRINT_WORD_DATE_LONG:
 919                         case SCC_NEWGRF_PRINT_WORD_DATE_SHORT:  *argv = _newgrf_textrefstack.PopUnsignedWord() + DAYS_TILL_ORIGINAL_BASE_YEAR; break;
 920
 921                         case SCC_NEWGRF_DISCARD_WORD:           _newgrf_textrefstack.PopUnsignedWord(); break;
 922
 923                         case SCC_NEWGRF_ROTATE_TOP_4_WORDS:     _newgrf_textrefstack.RotateTop4Words(); break;
 924                         case SCC_NEWGRF_PUSH_WORD:              _newgrf_textrefstack.PushWord(Utf8Consume(str)); break;
 925
 926                         case SCC_NEWGRF_UNPRINT: {
 927                                 size_t unprint = Utf8Consume(str);
 928                                 if (unprint < buf->length()) {
 929                                         buf->truncate (buf->length() - unprint);
 930                                 } else {
 931                                         buf->clear();
 932                                 }
 933                                 break;
 934                         }
 935
 936                         case SCC_NEWGRF_PRINT_WORD_CARGO_LONG:
 937                         case SCC_NEWGRF_PRINT_WORD_CARGO_SHORT:
 938                         case SCC_NEWGRF_PRINT_WORD_CARGO_TINY:
 939                                 argv[0] = GetCargoTranslation(_newgrf_textrefstack.PopUnsignedWord(), _newgrf_textrefstack.grffile);
 940                                 argv[1] = _newgrf_textrefstack.PopUnsignedWord();
 941                                 break;
 942
 943                         case SCC_NEWGRF_PRINT_WORD_STRING_ID:
 944                                 *argv = MapGRFStringID(_newgrf_textrefstack.grffile->grfid, _newgrf_textrefstack.PopUnsignedWord());
 945                                 break;
 946
 947                         case SCC_NEWGRF_PRINT_WORD_CARGO_NAME: {
 948                                 CargoID cargo = GetCargoTranslation(_newgrf_textrefstack.PopUnsignedWord(), _newgrf_textrefstack.grffile);
 949                                 *argv = cargo < NUM_CARGO ? 1 << cargo : 0;
 950                                 break;
 951                         }
 952                 }
 953         } else {
 954                 /* Consume additional parameter characters */
 955                 switch (scc) {
 956                         default: break;
 957
 958                         case SCC_NEWGRF_PUSH_WORD:
 959                         case SCC_NEWGRF_UNPRINT:
 960                                 Utf8Consume(str);
 961                                 break;
 962                 }
 963         }
 964
 965         switch (scc) {
 966                 default: NOT_REACHED();
 967                 case SCC_NEWGRF_PRINT_DWORD_SIGNED:
 968                 case SCC_NEWGRF_PRINT_WORD_SIGNED:
 969                 case SCC_NEWGRF_PRINT_BYTE_SIGNED:
 970                 case SCC_NEWGRF_PRINT_WORD_UNSIGNED:
 971                         return SCC_COMMA;
 972
 973                 case SCC_NEWGRF_PRINT_BYTE_HEX:
 974                 case SCC_NEWGRF_PRINT_WORD_HEX:
 975                 case SCC_NEWGRF_PRINT_DWORD_HEX:
 976                 case SCC_NEWGRF_PRINT_QWORD_HEX:
 977                         return SCC_HEX;
 978
 979                 case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
 980                 case SCC_NEWGRF_PRINT_QWORD_CURRENCY:
 981                         return SCC_CURRENCY_LONG;
 982
 983                 case SCC_NEWGRF_PRINT_WORD_STRING_ID:
 984                         return SCC_NEWGRF_PRINT_WORD_STRING_ID;
 985
 986                 case SCC_NEWGRF_PRINT_WORD_DATE_LONG:
 987                 case SCC_NEWGRF_PRINT_DWORD_DATE_LONG:
 988                         return SCC_DATE_LONG;
 989
 990                 case SCC_NEWGRF_PRINT_WORD_DATE_SHORT:
 991                 case SCC_NEWGRF_PRINT_DWORD_DATE_SHORT:
 992                         return SCC_DATE_SHORT;
 993
 994                 case SCC_NEWGRF_PRINT_WORD_SPEED:
 995                         return SCC_VELOCITY;
 996
 997                 case SCC_NEWGRF_PRINT_WORD_VOLUME_LONG:
 998                         return SCC_VOLUME_LONG;
 999
1000                 case SCC_NEWGRF_PRINT_WORD_VOLUME_SHORT:
1001                         return SCC_VOLUME_SHORT;
1002
1003                 case SCC_NEWGRF_PRINT_WORD_WEIGHT_LONG:
1004                         return SCC_WEIGHT_LONG;
1005
1006                 case SCC_NEWGRF_PRINT_WORD_WEIGHT_SHORT:
1007                         return SCC_WEIGHT_SHORT;
1008
1009                 case SCC_NEWGRF_PRINT_WORD_POWER:
1010                         return SCC_POWER;
1011
1012                 case SCC_NEWGRF_PRINT_WORD_CARGO_LONG:
1013                         return SCC_CARGO_LONG;
1014
1015                 case SCC_NEWGRF_PRINT_WORD_CARGO_SHORT:
1016                         return SCC_CARGO_SHORT;
1017
1018                 case SCC_NEWGRF_PRINT_WORD_CARGO_TINY:
1019                         return SCC_CARGO_TINY;
1020
1021                 case SCC_NEWGRF_PRINT_WORD_CARGO_NAME:
1022                         return SCC_CARGO_LIST;
1023
1024                 case SCC_NEWGRF_PRINT_WORD_STATION_NAME:
1025                         return SCC_STATION_NAME;
1026
1027                 case SCC_NEWGRF_DISCARD_WORD:
1028                 case SCC_NEWGRF_ROTATE_TOP_4_WORDS:
1029                 case SCC_NEWGRF_PUSH_WORD:
1030                 case SCC_NEWGRF_UNPRINT:
1031                         return 0;
1032         }
1033 }