/* Don't know the GRF, so mark game incompatible and the (possibly)

				 * already resolved name for this GRF (another server has sent the

				 * name of the GRF already. */

				c->name = FindUnknownGRFName(c->ident.grfid, c->ident.md5sum, true);

				c->status = GCS_NOT_FOUND;

				/* If we miss a file, we're obviously incompatible. */

				item->info.compatible = false;

			} else {

				c->filename = f->filename;

				c->name = f->name;

				c->info = f->info;

				c->status = GCS_UNKNOWN;

			}

		}

		/* Try to find the GRFTextWrapper for the name of this GRF ID and MD5sum tuple.

		 * If it exists and not resolved yet, then name of the fake GRF is

		 * overwritten with the name from the reply. */

		}

	}

}

		/* Don't know the GRF, so mark game incompatible and the (possibly)

		 * already resolved name for this GRF (another server has sent the

		 * name of the GRF already */

		config->name = FindUnknownGRFName(config->ident.grfid, config->ident.md5sum, true);

		config->status = GCS_NOT_FOUND;

	} else {

		config->filename = f->filename;

		config->name = f->name;

		config->info = f->info;

		config->url = f->url;

	}

	SetBit(config->flags, GCF_COPY);

}

	/* GRF IDs starting with 0xFF are reserved for internal TTDPatch use */

	if (GB(grfid, 0, 8) == 0xFF) SetBit(_cur.grfconfig->flags, GCF_SYSTEM);

	if (buf->HasData()) {

		const char *info = buf->ReadString();

	}

	/* GLS_INFOSCAN only looks for the action 8, so we can skip the rest of the file */

/** Callback function for 'INFO'->'NAME' to add a translation to the newgrf name. */

static bool ChangeGRFName(byte langid, const char *str)

{

	return true;

}

/** Callback function for 'INFO'->'DESC' to add a translation to the newgrf description. */

static bool ChangeGRFDescription(byte langid, const char *str)

{

	return true;

}

/** Callback function for 'INFO'->'URL_' to set the newgrf url. */

static bool ChangeGRFURL(byte langid, const char *str)

{

	return true;

}

/** Callback function for 'INFO'->'PARAM'->param_num->'NAME' to set the name of a parameter. */

static bool ChangeGRFParamName(byte langid, const char *str)

{

	return true;

}

/** Callback function for 'INFO'->'PARAM'->param_num->'DESC' to set the description of a parameter. */

static bool ChangeGRFParamDescription(byte langid, const char *str)

{

	return true;

}

		byte langid = buf->ReadByte();

		const char *name_string = buf->ReadString();

		if (val_name != _cur_parameter->value_names.End()) {

		} else {

			_cur_parameter->value_names.Insert(id, list);

		}

#include "textfile_gui.h"

#include "thread.h"

#include "newgrf_config.h"

#include "fileio_func.h"

#include "fios.h"

#include "safeguards.h"

/**

 * Create a new GRFConfig.

 *   is copied so the original string isn't needed after the constructor.

 */

GRFConfig::GRFConfig(const char *filename) :

	num_valid_params(lengthof(param))

{

	if (filename != nullptr) this->filename = stredup(filename);

}

/**

	MemCpyT<uint8>(this->original_md5sum, config.original_md5sum, lengthof(this->original_md5sum));

	MemCpyT<uint32>(this->param, config.param, lengthof(this->param));

	if (config.filename != nullptr) this->filename = stredup(config.filename);

	if (config.error != nullptr) this->error = new GRFError(*config.error);

	for (uint i = 0; i < config.param_info.size(); i++) {

		if (config.param_info[i] == nullptr) {

		free(this->filename);

		delete this->error;

	}

	for (uint i = 0; i < this->param_info.size(); i++) delete this->param_info[i];

}

 */

const char *GRFConfig::GetName() const

{

	return StrEmpty(name) ? this->filename : name;

}

 */

const char *GRFConfig::GetDescription() const

{

}

/**

 */

const char *GRFConfig::GetURL() const

{

}

/** Set the default value for all parameters as specified by action14. */

 * @param nr The newgrf parameter that is changed.

 */

GRFParameterInfo::GRFParameterInfo(uint nr) :

	type(PTYPE_UINT_ENUM),

	min_value(0),

	max_value(UINT32_MAX),

	param_nr(nr),

	first_bit(0),

	num_bit(32),

	complete_labels(false)

{}

 * @param info The GRFParameterInfo object to make a copy of.

 */

GRFParameterInfo::GRFParameterInfo(GRFParameterInfo &info) :

	type(info.type),

	min_value(info.min_value),

	max_value(info.max_value),

	param_nr(info.param_nr),

	first_bit(info.first_bit),

	num_bit(info.num_bit),

	complete_labels(info.complete_labels)

{

}

/**

				free(c->filename);

				c->filename = stredup(f->filename);

				memcpy(c->ident.md5sum, f->ident.md5sum, sizeof(c->ident.md5sum));

				c->name = f->name;

				c->info = f->name;

				c->error = nullptr;

				c->version = f->version;

				c->min_loadable_version = f->min_loadable_version;

		_modal_progress_paint_mutex.lock();

		const char *name = nullptr;

		if (name == nullptr) name = c->filename;

		UpdateNewGRFScanStatus(this->num_scanned, name);

/** Structure for UnknownGRFs; this is a lightweight variant of GRFConfig */

struct UnknownGRF : public GRFIdentifier {

};

/**

 *         and MD5 checksum or nullptr when it does not exist and create is false.

 *         This value must NEVER be freed by the caller.

 */

{

		}

	}

	if (!create) return nullptr;

}

/**

#include "misc/countedptr.hpp"

#include "fileio_type.h"

#include "textfile_type.h"

/** GRF config bit flags */

enum GCF_Flags {

	uint32 grfid;     ///< GRF ID (defined by Action 0x08)

	uint8 md5sum[16]; ///< MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF)

	/**

	 * Does the identification match the provided values?

	 * @param grfid  Expected grfid.

struct GRFParameterInfo {

	GRFParameterInfo(uint nr);

	GRFParameterInfo(GRFParameterInfo &info);

	GRFParameterType type; ///< The type of this parameter

	uint32 min_value;      ///< The minimal value this parameter can have

	uint32 max_value;      ///< The maximal value of this parameter

	byte param_nr;         ///< GRF parameter to store content in

	byte first_bit;        ///< First bit to use in the GRF parameter

	byte num_bit;          ///< Number of bits to use for this parameter

	bool complete_labels;  ///< True if all values have a label.

	uint32 GetValue(struct GRFConfig *config) const;

	void Finalize();

};

/** Information about GRF, used in the game and (part of it) in savegames */

struct GRFConfig : ZeroedMemoryAllocator {

	GRFConfig(const char *filename = nullptr);

	GRFIdentifier ident;                        ///< grfid and md5sum to uniquely identify newgrfs

	uint8 original_md5sum[16];                  ///< MD5 checksum of original file if only a 'compatible' file was loaded

	char *filename;                             ///< Filename - either with or without full path

	GRFError *error;                            ///< NOSAVE: Error/Warning during GRF loading (Action 0x0B)

	uint32 version;                             ///< NOSAVE: Version a NewGRF can set so only the newest NewGRF is shown

/** For communication about GRFs over the network */

#define UNKNOWN_GRF_NAME_PLACEHOLDER "<Unknown>"

void UpdateNewGRFScanStatus(uint num, const char *name);

bool UpdateNewGRFConfigPalette(int32 p1 = 0);

	GRFLX_UNSPECIFIED = 0x7F,

};

/**

 * Holder of the above structure.

	uint32 grfid;

	uint16 stringid;

	StringID def_string;

};

}

/**

 * @param list The list where the text should be added to.

 */

{

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

			return;

		}

	}

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

}

/**

 * @param text_to_add The text to add to the list.

 * @note All text-codes will be translated.

 */

{

	int len;

	char *translatedtext = TranslateTTDPatchCodes(grfid, langid, allow_newlines, text_to_add, &len);

	free(translatedtext);

}

/**

 * @param list The list where the text should be added to.

 * @param text_to_add The text to add to the list.

 */

{

}

/**

	int len;

	translatedtext = TranslateTTDPatchCodes(grfid, langid_to_add, allow_newlines, text_to_add, &len);

	free(translatedtext);

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

	if (id == _num_grf_texts) _num_grf_texts++;

		_grf_text[id].grfid      = grfid;

		_grf_text[id].stringid   = stringid;

		_grf_text[id].def_string = def_string;

	}

	return MakeStringID(TEXT_TAB_NEWGRF_START, id);

}

 * current language it is returned, otherwise the default translation

 * is returned. If there is neither a default nor a translation for the

 * current language nullptr is returned.

 */

{

	const char *default_text = nullptr;

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

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

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

		}

	}

}

/**

 * Get a C-string from a stringid set by a newgrf.

 */

const char *GetGRFStringPtr(uint16 stringid)

}

/**

 * House cleaning.

 * Remove all strings and reset the text counter.

 */

	uint id;

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

		_grf_text[id].grfid      = 0;

		_grf_text[id].stringid   = 0;

	}

	_num_grf_texts = 0;

#include "strings_type.h"

#include "core/smallvec_type.hpp"

#include "table/control_codes.h"

/** This character, the thorn ('þ'), indicates a unicode string to NFO. */

static const WChar NFO_UTF8_IDENTIFIER = 0x00DE;

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

StringID GetGRFStringID(uint32 grfid, StringID stringid);

const char *GetGRFStringPtr(uint16 stringid);

void CleanUpStrings();

void SetCurrentGrfLangID(byte language_id);

char *TranslateTTDPatchCodes(uint32 grfid, uint8 language_id, bool allow_newlines, const char *str, int *olen = nullptr, StringControlCode byte80 = SCC_NEWGRF_PRINT_WORD_STRING_ID);

bool CheckGrfLangID(byte lang_id, byte grf_version);

void StopTextRefStackUsage();

void RewindTextRefStack();

bool UsingNewGRFTextStack();