}

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

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

static char *GetSpecialNameString(char *buff, int ind, StringParameters *args, const char *last);

struct LanguagePack : public LanguagePackHeader {

	char data[]; // list of strings

};

static char **_langpack_offs;

 * Get a parsed string with most special stringcodes replaced by the string parameters.

 * @param buffr  Pointer to a string buffer where the formatted string should be written to.

 * @param string

 * @param args   Arguments for the string.

 * @param last   Pointer just past the end of buffr.

 * @param case_index  The "case index". This will only be set when FormatString wants to print the string in a different case.

 * @return       Pointer to the final zero byte of the formatted string.

 */

{

	if (string == 0) return GetStringWithArgs(buffr, STR_UNDEFINED, args, last);

	uint index = GB(string, TAB_SIZE_OFFSET,  TAB_SIZE_BITS);

	uint tab   = GB(string, TAB_COUNT_OFFSET, TAB_COUNT_BITS);

	switch (tab) {

		case 4:

				return GetSpecialTownNameString(buffr, index - 0xC0, args->GetInt32(), last);

			}

			break;

		case 14:

				return GetSpecialNameString(buffr, index - 0xE4, args, last);

			}

			break;

		case 15:

			/* Old table for custom names. This is no longer used */

			error("Incorrect conversion of custom name string.");

		case GAME_TEXT_TAB:

		case 26:

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

			if (HasBit(index, 10)) {

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

				return GetStringWithArgs(buffr, string, args, last, case_index);

		case 31:

			NOT_REACHED();

	}

	if (index >= _langtab_num[tab]) {

		error("String 0x%X is invalid. You are probably using an old version of the .lng file.\n", string);

	}

	return FormatString(buffr, GetStringPtr(string), args, last, case_index);

}

 * @param str   The original string with format codes.

 * @param args  Pointer to extra arguments used by various string codes.

 * @param case_index

 * @param last  Pointer to just past the end of the buff array.

 * @param dry_run True when the argt array is not yet initialized.

 */

{

	uint orig_offset = args->offset;

	/* When there is no array with types there is no need to do a dry run. */

	if (args->HasTypeInformation() && !dry_run) {

		if (UsingNewGRFTextStack()) {

			 * argv array at the time they are encountered. That means that if

			 * another string command references a value later in the string it

			 * would fail. We solve that by running FormatString twice. The first

			 * pass makes sure the argv array is correctly filled and the second

			 * pass can reference later values without problems. */

			struct TextRefStack *backup = CreateTextRefStackBackup();

			RestoreTextRefStackBackup(backup);

		} else {

		}

		/* We have to restore the original offset here to to read the correct values. */

		args->offset = orig_offset;

	}

	WChar b;

	uint next_substr_case_index = 0;

					}

				}

				/* We error'd out in the while, to error out in themain too */

				if (*str == '\0') break;

				str = p;

				for (int i = 0; i < 20; i++) {

					if (sub_args_need_free[i]) free((void *)sub_args.GetParam(i));

				}

				break;

			}

			case SCC_REVISION: // {REV}

				buff = strecpy(buff, _openttd_revision, last);

				break;

			case SCC_STRING_ID: // {STRINL}

				buff = GetStringWithArgs(buff, Utf8Consume(&str), args, last);

				break;

			case SCC_RAW_STRING_POINTER: { // {RAW_STRING}

				const char *str = (const char *)(size_t)args->GetInt64(SCC_RAW_STRING_POINTER);

				buff = FormatString(buff, str, args, last);

				break;

			}

			case SCC_STRING: {// {STRING}

				StringID str = args->GetInt32(SCC_STRING);

				/* WARNING. It's prohibited for the included string to consume any arguments.

				 * For included strings that consume argument, you should use STRING1, STRING2 etc.

				 * To debug stuff you can set argv to NULL and it will tell you */

				StringParameters tmp_params(args->GetDataPointer(), args->num_param - args->offset, NULL);

				next_substr_case_index = 0;

				break;

			}

			case SCC_STRING1: { // {STRING1}

				/* String that consumes ONE argument */

				StringID str = args->GetInt32(SCC_STRING1);

				StringParameters sub_args(*args, 1);

				next_substr_case_index = 0;

				break;

			}

			case SCC_STRING2: { // {STRING2}

				/* String that consumes TWO arguments */

				StringID str = args->GetInt32(SCC_STRING2);

				StringParameters sub_args(*args, 2);

				next_substr_case_index = 0;

				break;

			}

			case SCC_STRING3: { // {STRING3}

				/* String that consumes THREE arguments */

				StringID str = args->GetInt32(SCC_STRING3);

				StringParameters sub_args(*args, 3);

				next_substr_case_index = 0;

				break;

			}

			case SCC_STRING4: { // {STRING4}

				/* String that consumes FOUR arguments */

				StringID str = args->GetInt32(SCC_STRING4);

				StringParameters sub_args(*args, 4);

				next_substr_case_index = 0;

				break;

			}

			case SCC_STRING5: { // {STRING5}

				/* String that consumes FIVE arguments */

				StringID str = args->GetInt32(SCC_STRING5);

				StringParameters sub_args(*args, 5);

				next_substr_case_index = 0;

				break;

			}

			case SCC_COMMA: // {COMMA}

				buff = FormatCommaNumber(buff, args->GetInt64(SCC_COMMA), last);

	}

};

extern StringParameters _global_string_params;

char *InlineString(char *buf, StringID string);

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

const char *GetStringPtr(StringID string);

void InjectDParam(uint amount);

/**

 * Set a string parameter \a v at index \a n in a given array \a s.