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

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

{

	AddGRFTextToList(&_cur_grfconfig->name, langid, _cur_grfconfig->ident.grfid, str);

	return true;

}

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

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

{

	AddGRFTextToList(&_cur_grfconfig->info, langid, _cur_grfconfig->ident.grfid, str);

	return true;

}

typedef bool (*DataHandler)(size_t, ByteReader *);  ///< Type of callback function for binary nodes

typedef bool (*TextHandler)(byte, const char *str); ///< Type of callback function for text nodes

typedef bool (*BranchHandler)(ByteReader *);        ///< Type of callback function for branch nodes

/**

 * Data structure to store the allowed id/type combinations for action 14. The

 * data can be represented as a tree with 3 types of nodes:

 * 1. Branch nodes (identified by 'C' for choice).

 * 2. Binary leaf nodes (identified by 'B').

 * 3. Text leaf nodes (identified by 'T').

 */

struct AllowedSubtags {

	/** Create empty subtags object used to identify the end of a list. */

	AllowedSubtags() :

		id(0),

		type(0)

	{}

	/**

	 * Create a binary leaf node.

	 * @param id The id for this node.

	 * @param handler The callback function to call.

	 */

	AllowedSubtags(uint32 id, DataHandler handler) :

		id(id),

		type('B')

	{

		this->handler.data = handler;

	}

	/**

	 * Create a text leaf node.

	 * @param id The id for this node.

	 * @param handler The callback function to call.

	 */

	AllowedSubtags(uint32 id, TextHandler handler) :

		id(id),

		type('T')

	{

		this->handler.text = handler;

	}

	/**

	 * Create a branch node with a callback handler

	 * @param id The id for this node.

	 * @param handler The callback function to call.

	 */

	AllowedSubtags(uint32 id, BranchHandler handler) :

		id(id),

		type('C')

	{

		this->handler.call_handler = true;

		this->handler.u.branch = handler;

	}

	/**

	 * Create a branch node with a list of sub-nodes.

	 * @param id The id for this node.

	 * @param subtags Array with all valid subtags.

	 */

	AllowedSubtags(uint32 id, AllowedSubtags *subtags) :

		id(id),

		type('C')

	{

		this->handler.call_handler = false;

		this->handler.u.subtags = subtags;

	}

	uint32 id; ///< The identifier for this node

	byte type; ///< The type of the node, must be one of 'C', 'B' or 'T'.

	union {

		DataHandler data; ///< Callback function for a binary node, only valid if type == 'B'.

		TextHandler text; ///< Callback function for a text node, only valid if type == 'T'.

		struct {

			union {

				BranchHandler branch;    ///< Callback function for a branch node, only valid if type == 'C' && call_handler.

				AllowedSubtags *subtags; ///< Pointer to a list of subtags, only valid if type == 'C' && !call_handler.

			} u;

			bool call_handler; ///< True if there is a callback function for this node, false if there is a list of subnodes.

		};

	} handler;

};

AllowedSubtags _tags_info[] = {

	AllowedSubtags('NAME', ChangeGRFName),

	AllowedSubtags('DESC', ChangeGRFDescription),

	AllowedSubtags()

};

AllowedSubtags _tags_root[] = {

	AllowedSubtags('INFO', _tags_info),

	AllowedSubtags()

};

/**

 * Try to skip the current node and all subnodes (if it's a branch node).

 * @return True if we could skip the node, false if an error occured.

 */

static bool SkipUnknownInfo(ByteReader *buf, byte type)

{

	/* type and id are already read */

	switch (type) {

		case 'C': {

			byte new_type = buf->ReadByte();

			while (new_type != 0) {

				buf->ReadDWord(); // skip the id

				if (!SkipUnknownInfo(buf, new_type)) return false;

				new_type = buf->ReadByte();

			}

			break;

		}

		case 'T':

			buf->ReadByte(); // lang

			buf->ReadString(); // actual text

			break;

		case 'B': {

			uint16 size = buf->ReadWord();

			buf->Skip(size);

			break;

		}

		default:

			return false;

	}

	return true;

}

static bool HandleNode(byte type, uint32 id, ByteReader *buf, AllowedSubtags subtags[])

{

	uint i = 0;

	AllowedSubtags *tag;

	while ((tag = &subtags[i++])->type != 0) {

		if (tag->id != BSWAP32(id) || tag->type != type) continue;

		switch (type) {

			default: NOT_REACHED();

			case 'T': {

				byte langid = buf->ReadByte();

				return tag->handler.text(langid, buf->ReadString());

			}

			case 'B': {

				size_t len = buf->ReadWord();

				if (buf->Remaining() < len) return false;

				return tag->handler.data(len, buf);

			}

			case 'C': {

				if (tag->handler.call_handler) {

					return tag->handler.u.branch(buf);

				}

				byte new_type = buf->ReadByte();

				while (new_type != 0) {

					uint32 new_id = buf->ReadDWord();

					if (!HandleNode(new_type, new_id, buf, tag->handler.u.subtags)) return false;

					new_type = buf->ReadByte();

				}

				return true;

			}

		}

	}

	grfmsg(2, "StaticGRFInfo: unkown type/id combination found, type=%c, id=%x", type, id);

	return SkipUnknownInfo(buf, type);

}

/* Action 0x14 */

static void StaticGRFInfo(ByteReader *buf)

{

	/* <14> <type> <id> <text/data...> */

	byte type = buf->ReadByte();

	uint32 id = buf->ReadDWord();

	HandleNode(type, id, buf, _tags_root);

}

		/* 0x14 */ { StaticGRFInfo, NULL, NULL,            NULL,           NULL,              NULL, },