00001
00002
00003
00004
00005
00006
00007
00008
00009
00019 #include "stdafx.h"
00020 #include "newgrf.h"
00021 #include "strings_func.h"
00022 #include "newgrf_storage.h"
00023 #include "string_func.h"
00024 #include "date_type.h"
00025 #include "debug.h"
00026
00027 #include "table/strings.h"
00028 #include "table/control_codes.h"
00029
00030 #define GRFTAB 28
00031 #define TABSIZE 11
00032
00040 StringID TTDPStringIDToOTTDStringIDMapping(StringID str)
00041 {
00042
00043 static const StringID units_volume[] = {
00044 STR_NOTHING, STR_PASSENGERS, STR_TONS, STR_BAGS,
00045 STR_LITERS, STR_ITEMS, STR_CRATES, STR_TONS,
00046 STR_TONS, STR_TONS, STR_TONS, STR_BAGS,
00047 STR_TONS, STR_TONS, STR_TONS, STR_BAGS,
00048 STR_TONS, STR_TONS, STR_BAGS, STR_LITERS,
00049 STR_TONS, STR_LITERS, STR_TONS, STR_NOTHING,
00050 STR_BAGS, STR_LITERS, STR_TONS, STR_NOTHING,
00051 STR_TONS, STR_NOTHING, STR_LITERS, STR_NOTHING
00052 };
00053
00054
00055 if (IsInsideMM(str, 0xD000, 0xD7FF) || IsInsideMM(str, 0xDC00, 0xDCFF)) return str;
00056
00057 #define TEXTID_TO_STRINGID(begin, end, stringid) if (str >= begin && str <= end) return str + (stringid - begin)
00058
00059 TEXTID_TO_STRINGID(0x000E, 0x002D, STR_CARGO_PLURAL_NOTHING);
00060 TEXTID_TO_STRINGID(0x002E, 0x004D, STR_CARGO_SINGULAR_NOTHING);
00061 if (str >= 0x004E && str <= 0x006D) return units_volume[str - 0x004E];
00062 TEXTID_TO_STRINGID(0x006E, 0x008D, STR_QUANTITY_NOTHING);
00063 TEXTID_TO_STRINGID(0x008E, 0x00AD, STR_ABBREV_NOTHING);
00064
00065
00066
00067
00068 TEXTID_TO_STRINGID(0x200F, 0x201F, STR_TOWN_BUILDING_NAME_TALL_OFFICE_BLOCK_1);
00069 TEXTID_TO_STRINGID(0x2036, 0x2041, STR_TOWN_BUILDING_NAME_COTTAGES_1);
00070 TEXTID_TO_STRINGID(0x2059, 0x205C, STR_TOWN_BUILDING_NAME_IGLOO_1);
00071
00072
00073 TEXTID_TO_STRINGID(0x4802, 0x4826, STR_INDUSTRY_NAME_COAL_MINE);
00074 TEXTID_TO_STRINGID(0x482D, 0x482E, STR_NEWS_INDUSTRY_CONSTRUCTION);
00075 TEXTID_TO_STRINGID(0x4832, 0x4834, STR_NEWS_INDUSTRY_CLOSURE_GENERAL);
00076 TEXTID_TO_STRINGID(0x4835, 0x4838, STR_NEWS_INDUSTRY_PRODUCTION_INCREASE_GENERAL);
00077 TEXTID_TO_STRINGID(0x4839, 0x483A, STR_NEWS_INDUSTRY_PRODUCTION_DECREASE_GENERAL);
00078
00079 switch (str) {
00080 case 0x4830: return STR_ERROR_CAN_T_CONSTRUCT_THIS_INDUSTRY;
00081 case 0x4831: return STR_ERROR_FOREST_CAN_ONLY_BE_PLANTED;
00082 case 0x483B: return STR_ERROR_CAN_ONLY_BE_POSITIONED;
00083 }
00084 #undef TEXTID_TO_STRINGID
00085
00086 if (str == STR_NULL) return STR_EMPTY;
00087
00088 DEBUG(grf, 0, "Unknown StringID 0x%04X remapped to STR_EMPTY. Please open a Feature Request if you need it", str);
00089
00090 return STR_EMPTY;
00091 }
00092
00098 enum GRFBaseLanguages {
00099 GRFLB_AMERICAN = 0x01,
00100 GRFLB_ENGLISH = 0x02,
00101 GRFLB_GERMAN = 0x04,
00102 GRFLB_FRENCH = 0x08,
00103 GRFLB_SPANISH = 0x10,
00104 GRFLB_GENERIC = 0x80,
00105 };
00106
00107 enum GRFExtendedLanguages {
00108 GRFLX_AMERICAN = 0x00,
00109 GRFLX_ENGLISH = 0x01,
00110 GRFLX_GERMAN = 0x02,
00111 GRFLX_FRENCH = 0x03,
00112 GRFLX_SPANISH = 0x04,
00113 GRFLX_UNSPECIFIED = 0x7F,
00114 };
00115
00121 struct GRFText {
00122 public:
00123 static GRFText *New(byte langid, const char *text)
00124 {
00125 return new (strlen(text) + 1) GRFText(langid, text);
00126 }
00127
00133 void *operator new(size_t size)
00134 {
00135 NOT_REACHED();
00136 }
00137
00142 void operator delete(void *p)
00143 {
00144 free(p);
00145 }
00146 private:
00147 GRFText(byte langid_, const char *text_) : next(NULL), langid(langid_)
00148 {
00149 strcpy(text, text_);
00150 }
00151
00158 void *operator new(size_t size, size_t extra)
00159 {
00160 return MallocT<byte>(size + extra);
00161 }
00162
00163 public:
00164 GRFText *next;
00165 byte langid;
00166 char text[];
00167 };
00168
00169
00175 struct GRFTextEntry {
00176 uint32 grfid;
00177 uint16 stringid;
00178 StringID def_string;
00179 GRFText *textholder;
00180 };
00181
00182
00183 static uint _num_grf_texts = 0;
00184 static GRFTextEntry _grf_text[(1 << TABSIZE) * 3];
00185 static byte _currentLangID = GRFLX_ENGLISH;
00186
00187
00188 char *TranslateTTDPatchCodes(uint32 grfid, const char *str)
00189 {
00190 char *tmp = MallocT<char>(strlen(str) * 10 + 1);
00191 char *d = tmp;
00192 bool unicode = false;
00193 WChar c;
00194 size_t len = Utf8Decode(&c, str);
00195
00196 if (c == 0x00DE) {
00197
00198 unicode = true;
00199 str += len;
00200 }
00201
00202 for (;;) {
00203 if (unicode && Utf8EncodedCharLen(*str) != 0) {
00204 c = Utf8Consume(&str);
00205
00206 if (GB(c, 8, 8) == 0xE0) {
00207 c = GB(c, 0, 8);
00208 } else if (c >= 0x20) {
00209 if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';
00210 d += Utf8Encode(d, c);
00211 continue;
00212 }
00213 } else {
00214 c = (byte)*str++;
00215 }
00216 if (c == 0) break;
00217
00218 switch (c) {
00219 case 0x01:
00220 d += Utf8Encode(d, SCC_SETX);
00221 *d++ = *str++;
00222 break;
00223 case 0x0A: break;
00224 case 0x0D: *d++ = 0x0A; break;
00225 case 0x0E: d += Utf8Encode(d, SCC_TINYFONT); break;
00226 case 0x0F: d += Utf8Encode(d, SCC_BIGFONT); break;
00227 case 0x1F:
00228 d += Utf8Encode(d, SCC_SETXY);
00229 *d++ = *str++;
00230 *d++ = *str++;
00231 break;
00232 case 0x7B:
00233 case 0x7C:
00234 case 0x7D:
00235 case 0x7E:
00236 case 0x7F:
00237 case 0x80: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DWORD + c - 0x7B); break;
00238 case 0x81: {
00239 StringID string;
00240 string = ((uint8)*str++);
00241 string |= ((uint8)*str++) << 8;
00242 d += Utf8Encode(d, SCC_STRING_ID);
00243 d += Utf8Encode(d, MapGRFStringID(grfid, string));
00244 break;
00245 }
00246 case 0x82:
00247 case 0x83:
00248 case 0x84: d += Utf8Encode(d, SCC_NEWGRF_PRINT_DATE + c - 0x82); break;
00249 case 0x85: d += Utf8Encode(d, SCC_NEWGRF_DISCARD_WORD); break;
00250 case 0x86: d += Utf8Encode(d, SCC_NEWGRF_ROTATE_TOP_4_WORDS); break;
00251 case 0x87: d += Utf8Encode(d, SCC_NEWGRF_PRINT_WORD_LITRES); break;
00252 case 0x88: d += Utf8Encode(d, SCC_BLUE); break;
00253 case 0x89: d += Utf8Encode(d, SCC_SILVER); break;
00254 case 0x8A: d += Utf8Encode(d, SCC_GOLD); break;
00255 case 0x8B: d += Utf8Encode(d, SCC_RED); break;
00256 case 0x8C: d += Utf8Encode(d, SCC_PURPLE); break;
00257 case 0x8D: d += Utf8Encode(d, SCC_LTBROWN); break;
00258 case 0x8E: d += Utf8Encode(d, SCC_ORANGE); break;
00259 case 0x8F: d += Utf8Encode(d, SCC_GREEN); break;
00260 case 0x90: d += Utf8Encode(d, SCC_YELLOW); break;
00261 case 0x91: d += Utf8Encode(d, SCC_DKGREEN); break;
00262 case 0x92: d += Utf8Encode(d, SCC_CREAM); break;
00263 case 0x93: d += Utf8Encode(d, SCC_BROWN); break;
00264 case 0x94: d += Utf8Encode(d, SCC_WHITE); break;
00265 case 0x95: d += Utf8Encode(d, SCC_LTBLUE); break;
00266 case 0x96: d += Utf8Encode(d, SCC_GRAY); break;
00267 case 0x97: d += Utf8Encode(d, SCC_DKBLUE); break;
00268 case 0x98: d += Utf8Encode(d, SCC_BLACK); break;
00269 case 0x9A:
00270 switch (*str++) {
00271 case 0:
00272 case 1:
00273 d += Utf8Encode(d, SCC_NEWGRF_PRINT_QWORD_CURRENCY);
00274 break;
00275 case 3: {
00276 uint16 tmp = ((uint8)*str++);
00277 tmp |= ((uint8)*str++) << 8;
00278 d += Utf8Encode(d, SCC_NEWGRF_PUSH_WORD);
00279 d += Utf8Encode(d, tmp);
00280 } break;
00281 case 4:
00282 d += Utf8Encode(d, SCC_NEWGRF_UNPRINT);
00283 d += Utf8Encode(d, *str++);
00284 break;
00285 case 6:
00286 d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_BYTE);
00287 break;
00288 case 7:
00289 d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_WORD);
00290 break;
00291 case 8:
00292 d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_DWORD);
00293 break;
00294 case 0x0B:
00295 d += Utf8Encode(d, SCC_NEWGRF_PRINT_HEX_QWORD);
00296 break;
00297
00298 default:
00299 grfmsg(1, "missing handler for extended format code");
00300 break;
00301 }
00302 break;
00303
00304 case 0x9E: d += Utf8Encode(d, 0x20AC); break;
00305 case 0x9F: d += Utf8Encode(d, 0x0178); break;
00306 case 0xA0: d += Utf8Encode(d, SCC_UPARROW); break;
00307 case 0xAA: d += Utf8Encode(d, SCC_DOWNARROW); break;
00308 case 0xAC: d += Utf8Encode(d, SCC_CHECKMARK); break;
00309 case 0xAD: d += Utf8Encode(d, SCC_CROSS); break;
00310 case 0xAF: d += Utf8Encode(d, SCC_RIGHTARROW); break;
00311 case 0xB4: d += Utf8Encode(d, SCC_TRAIN); break;
00312 case 0xB5: d += Utf8Encode(d, SCC_LORRY); break;
00313 case 0xB6: d += Utf8Encode(d, SCC_BUS); break;
00314 case 0xB7: d += Utf8Encode(d, SCC_PLANE); break;
00315 case 0xB8: d += Utf8Encode(d, SCC_SHIP); break;
00316 case 0xB9: d += Utf8Encode(d, SCC_SUPERSCRIPT_M1); break;
00317 case 0xBC: d += Utf8Encode(d, SCC_SMALLUPARROW); break;
00318 case 0xBD: d += Utf8Encode(d, SCC_SMALLDOWNARROW); break;
00319 default:
00320
00321 if (!IsValidChar(c, CS_ALPHANUMERAL)) c = '?';
00322 d += Utf8Encode(d, c);
00323 break;
00324 }
00325 }
00326
00327 *d = '\0';
00328 tmp = ReallocT(tmp, strlen(tmp) + 1);
00329 return tmp;
00330 }
00331
00332
00336 StringID AddGRFString(uint32 grfid, uint16 stringid, byte langid_to_add, bool new_scheme, const char *text_to_add, StringID def_string)
00337 {
00338 char *translatedtext;
00339 uint id;
00340
00341
00342
00343
00344
00345
00346
00347 if (!new_scheme) {
00348 if (langid_to_add & (GRFLB_AMERICAN | GRFLB_ENGLISH)) {
00349 langid_to_add = GRFLX_ENGLISH;
00350 } else {
00351 StringID ret = STR_EMPTY;
00352 if (langid_to_add & GRFLB_GERMAN) ret = AddGRFString(grfid, stringid, GRFLX_GERMAN, true, text_to_add, def_string);
00353 if (langid_to_add & GRFLB_FRENCH) ret = AddGRFString(grfid, stringid, GRFLX_FRENCH, true, text_to_add, def_string);
00354 if (langid_to_add & GRFLB_SPANISH) ret = AddGRFString(grfid, stringid, GRFLX_SPANISH, true, text_to_add, def_string);
00355 return ret;
00356 }
00357 }
00358
00359 for (id = 0; id < _num_grf_texts; id++) {
00360 if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {
00361 break;
00362 }
00363 }
00364
00365
00366 if (id == lengthof(_grf_text)) return STR_EMPTY;
00367
00368 translatedtext = TranslateTTDPatchCodes(grfid, text_to_add);
00369
00370 GRFText *newtext = GRFText::New(langid_to_add, translatedtext);
00371
00372 free(translatedtext);
00373
00374
00375 if (id == _num_grf_texts) _num_grf_texts++;
00376
00377 if (_grf_text[id].textholder == NULL) {
00378 _grf_text[id].grfid = grfid;
00379 _grf_text[id].stringid = stringid;
00380 _grf_text[id].def_string = def_string;
00381 _grf_text[id].textholder = newtext;
00382 } else {
00383 GRFText **ptext, *text;
00384 bool replaced = false;
00385
00386
00387 for (ptext = &_grf_text[id].textholder; (text = *ptext) != NULL; ptext = &text->next) {
00388 if (text->langid != langid_to_add) continue;
00389 newtext->next = text->next;
00390 *ptext = newtext;
00391 delete text;
00392 replaced = true;
00393 break;
00394 }
00395
00396
00397 if (!replaced) *ptext = newtext;
00398 }
00399
00400 grfmsg(3, "Added 0x%X: grfid %08X string 0x%X lang 0x%X string '%s'", id, grfid, stringid, newtext->langid, newtext->text);
00401
00402 return (GRFTAB << TABSIZE) + id;
00403 }
00404
00405
00406 static uint32 _last_grfid = 0;
00407
00411 StringID GetGRFStringID(uint32 grfid, uint16 stringid)
00412 {
00413 uint id;
00414
00415
00416 if (grfid == 0) grfid = _last_grfid;
00417
00418 for (id = 0; id < _num_grf_texts; id++) {
00419 if (_grf_text[id].grfid == grfid && _grf_text[id].stringid == stringid) {
00420 return (GRFTAB << TABSIZE) + id;
00421 }
00422 }
00423
00424 return STR_UNDEFINED;
00425 }
00426
00427
00428 const char *GetGRFStringPtr(uint16 stringid)
00429 {
00430 const GRFText *default_text = NULL;
00431 const GRFText *search_text;
00432
00433 assert(_grf_text[stringid].grfid != 0);
00434
00435
00436 _last_grfid = _grf_text[stringid].grfid;
00437
00438
00439 for (search_text = _grf_text[stringid].textholder; search_text != NULL; search_text = search_text->next) {
00440 if (search_text->langid == _currentLangID) {
00441 return search_text->text;
00442 }
00443
00444
00445
00446 if (search_text->langid == GRFLX_UNSPECIFIED || (default_text == NULL && (search_text->langid == GRFLX_ENGLISH || search_text->langid == GRFLX_AMERICAN))) {
00447 default_text = search_text;
00448 }
00449 }
00450
00451
00452 if (default_text != NULL) return default_text->text;
00453
00454
00455 return GetStringPtr(_grf_text[stringid].def_string);
00456 }
00457
00466 void SetCurrentGrfLangID(byte language_id)
00467 {
00468 _currentLangID = language_id;
00469 }
00470
00471 bool CheckGrfLangID(byte lang_id, byte grf_version)
00472 {
00473 if (grf_version < 7) {
00474 switch (_currentLangID) {
00475 case GRFLX_GERMAN: return (lang_id & GRFLB_GERMAN) != 0;
00476 case GRFLX_FRENCH: return (lang_id & GRFLB_FRENCH) != 0;
00477 case GRFLX_SPANISH: return (lang_id & GRFLB_SPANISH) != 0;
00478 default: return (lang_id & (GRFLB_ENGLISH | GRFLB_AMERICAN)) != 0;
00479 }
00480 }
00481
00482 return (lang_id == _currentLangID || lang_id == GRFLX_UNSPECIFIED);
00483 }
00484
00489 void CleanUpStrings()
00490 {
00491 uint id;
00492
00493 for (id = 0; id < _num_grf_texts; id++) {
00494 GRFText *grftext = _grf_text[id].textholder;
00495 while (grftext != NULL) {
00496 GRFText *grftext2 = grftext->next;
00497 delete grftext;
00498 grftext = grftext2;
00499 }
00500 _grf_text[id].grfid = 0;
00501 _grf_text[id].stringid = 0;
00502 _grf_text[id].textholder = NULL;
00503 }
00504
00505 _num_grf_texts = 0;
00506 }
00507
00508 struct TextRefStack {
00509 byte stack[0x30];
00510 byte position;
00511 bool used;
00512
00513 TextRefStack() : used(false) {}
00514
00515 uint8 PopUnsignedByte() { assert(this->position < lengthof(this->stack)); return this->stack[this->position++]; }
00516 int8 PopSignedByte() { return (int8)this->PopUnsignedByte(); }
00517
00518 uint16 PopUnsignedWord()
00519 {
00520 uint16 val = this->PopUnsignedByte();
00521 return val | (this->PopUnsignedByte() << 8);
00522 }
00523 int16 PopSignedWord() { return (int32)this->PopUnsignedWord(); }
00524
00525 uint32 PopUnsignedDWord()
00526 {
00527 uint32 val = this->PopUnsignedWord();
00528 return val | (this->PopUnsignedWord() << 16);
00529 }
00530 int32 PopSignedDWord() { return (int32)this->PopUnsignedDWord(); }
00531
00532 uint64 PopUnsignedQWord()
00533 {
00534 uint64 val = this->PopUnsignedDWord();
00535 return val | (((uint64)this->PopUnsignedDWord()) << 32);
00536 }
00537 int64 PopSignedQWord() { return (int64)this->PopUnsignedQWord(); }
00538
00540 void RotateTop4Words()
00541 {
00542 byte tmp[2];
00543 for (int i = 0; i < 2; i++) tmp[i] = this->stack[this->position + i + 6];
00544 for (int i = 5; i >= 0; i--) this->stack[this->position + i + 2] = this->stack[this->position + i];
00545 for (int i = 0; i < 2; i++) this->stack[this->position + i] = tmp[i];
00546 }
00547
00548 void PushWord(uint16 word)
00549 {
00550 if (this->position >= 2) {
00551 this->position -= 2;
00552 } else {
00553 for (int i = lengthof(stack) - 1; i >= this->position + 2; i--) {
00554 this->stack[i] = this->stack[i - 2];
00555 }
00556 }
00557 this->stack[this->position] = GB(word, 0, 8);
00558 this->stack[this->position + 1] = GB(word, 8, 8);
00559 }
00560
00561 void ResetStack() { this->position = 0; this->used = true; }
00562 void RewindStack() { this->position = 0; }
00563 };
00564
00565 static TextRefStack _newgrf_normal_textrefstack;
00566 static TextRefStack _newgrf_error_textrefstack;
00567
00569 static TextRefStack *_newgrf_textrefstack = &_newgrf_normal_textrefstack;
00570
00575 void PrepareTextRefStackUsage(byte numEntries)
00576 {
00577 extern TemporaryStorageArray<int32, 0x110> _temp_store;
00578
00579 _newgrf_textrefstack->ResetStack();
00580
00581 byte *p = _newgrf_textrefstack->stack;
00582 for (uint i = 0; i < numEntries; i++) {
00583 for (uint j = 0; j < 32; j += 8) {
00584 *p = GB(_temp_store.Get(0x100 + i), j, 8);
00585 p++;
00586 }
00587 }
00588 }
00589
00591 void StopTextRefStackUsage() { _newgrf_textrefstack->used = false; }
00592
00593 void SwitchToNormalRefStack()
00594 {
00595 _newgrf_textrefstack = &_newgrf_normal_textrefstack;
00596 }
00597
00598 void SwitchToErrorRefStack()
00599 {
00600 _newgrf_textrefstack = &_newgrf_error_textrefstack;
00601 }
00602
00603 void RewindTextRefStack()
00604 {
00605 _newgrf_textrefstack->RewindStack();
00606 }
00607
00616 uint RemapNewGRFStringControlCode(uint scc, char *buf_start, char **buff, const char **str, int64 *argv)
00617 {
00618 if (_newgrf_textrefstack->used) {
00619 switch (scc) {
00620 default: NOT_REACHED();
00621 case SCC_NEWGRF_PRINT_SIGNED_BYTE: *argv = _newgrf_textrefstack->PopSignedByte(); break;
00622 case SCC_NEWGRF_PRINT_SIGNED_WORD: *argv = _newgrf_textrefstack->PopSignedWord(); break;
00623 case SCC_NEWGRF_PRINT_QWORD_CURRENCY: *argv = _newgrf_textrefstack->PopUnsignedQWord(); break;
00624
00625 case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
00626 case SCC_NEWGRF_PRINT_DWORD: *argv = _newgrf_textrefstack->PopSignedDWord(); break;
00627
00628 case SCC_NEWGRF_PRINT_HEX_BYTE: *argv = _newgrf_textrefstack->PopUnsignedByte(); break;
00629 case SCC_NEWGRF_PRINT_HEX_DWORD: *argv = _newgrf_textrefstack->PopUnsignedDWord(); break;
00630 case SCC_NEWGRF_PRINT_HEX_QWORD: *argv = _newgrf_textrefstack->PopSignedQWord(); break;
00631
00632 case SCC_NEWGRF_PRINT_HEX_WORD:
00633 case SCC_NEWGRF_PRINT_WORD_SPEED:
00634 case SCC_NEWGRF_PRINT_WORD_LITRES:
00635 case SCC_NEWGRF_PRINT_UNSIGNED_WORD: *argv = _newgrf_textrefstack->PopUnsignedWord(); break;
00636
00637 case SCC_NEWGRF_PRINT_DATE:
00638 case SCC_NEWGRF_PRINT_MONTH_YEAR: *argv = _newgrf_textrefstack->PopSignedWord() + DAYS_TILL_ORIGINAL_BASE_YEAR; break;
00639
00640 case SCC_NEWGRF_DISCARD_WORD: _newgrf_textrefstack->PopUnsignedWord(); break;
00641
00642 case SCC_NEWGRF_ROTATE_TOP_4_WORDS: _newgrf_textrefstack->RotateTop4Words(); break;
00643 case SCC_NEWGRF_PUSH_WORD: _newgrf_textrefstack->PushWord(Utf8Consume(str)); break;
00644 case SCC_NEWGRF_UNPRINT: *buff = max(*buff - Utf8Consume(str), buf_start); break;
00645
00646 case SCC_NEWGRF_PRINT_STRING_ID:
00647 *argv = TTDPStringIDToOTTDStringIDMapping(_newgrf_textrefstack->PopUnsignedWord());
00648 break;
00649 }
00650 }
00651
00652 switch (scc) {
00653 default: NOT_REACHED();
00654 case SCC_NEWGRF_PRINT_DWORD:
00655 case SCC_NEWGRF_PRINT_SIGNED_WORD:
00656 case SCC_NEWGRF_PRINT_SIGNED_BYTE:
00657 case SCC_NEWGRF_PRINT_UNSIGNED_WORD:
00658 return SCC_COMMA;
00659
00660 case SCC_NEWGRF_PRINT_HEX_BYTE:
00661 case SCC_NEWGRF_PRINT_HEX_WORD:
00662 case SCC_NEWGRF_PRINT_HEX_DWORD:
00663 case SCC_NEWGRF_PRINT_HEX_QWORD:
00664 return SCC_HEX;
00665
00666 case SCC_NEWGRF_PRINT_DWORD_CURRENCY:
00667 case SCC_NEWGRF_PRINT_QWORD_CURRENCY:
00668 return SCC_CURRENCY;
00669
00670 case SCC_NEWGRF_PRINT_STRING_ID:
00671 return SCC_STRING1;
00672
00673 case SCC_NEWGRF_PRINT_DATE:
00674 return SCC_DATE_LONG;
00675
00676 case SCC_NEWGRF_PRINT_MONTH_YEAR:
00677 return SCC_DATE_TINY;
00678
00679 case SCC_NEWGRF_PRINT_WORD_SPEED:
00680 return SCC_VELOCITY;
00681
00682 case SCC_NEWGRF_PRINT_WORD_LITRES:
00683 return SCC_VOLUME;
00684
00685 case SCC_NEWGRF_DISCARD_WORD:
00686 case SCC_NEWGRF_ROTATE_TOP_4_WORDS:
00687 case SCC_NEWGRF_PUSH_WORD:
00688 case SCC_NEWGRF_UNPRINT:
00689 return 0;
00690 }
00691 }