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