*/

void InitializeAnimatedTiles()

{

}

		byte side = draw_left ? 0 : 1;

		GUIEngineList *list = &this->engines[side];

		const Engine *e;

		FOR_ALL_ENGINES_OF_TYPE(e, type) {

			/* Either we got a request to rebuild the right engines list, or the left engines list selected a different engine */

			if (this->sel_engine[0] == INVALID_ENGINE) {

				/* Always empty the right engines list when nothing is selected in the left engines list */

				this->sel_engine[1] = INVALID_ENGINE;

			} else {

				if (this->reset_sel_engine && this->sel_engine[0] != INVALID_ENGINE) {

		this->filter.railtype = (this->listview_mode) ? RAILTYPE_END : GetRailType(this->window_number);

		/* Make list of all available train engines and wagons.

		 * Also check to see if the previously selected engine is still available,

	{

		EngineID sel_id = INVALID_ENGINE;

		const Engine *e;

		FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {

	void GenerateBuildShipList()

	{

		EngineID sel_id = INVALID_ENGINE;

		const Engine *e;

		FOR_ALL_ENGINES_OF_TYPE(e, VEH_SHIP) {

	{

		EngineID sel_id = INVALID_ENGINE;

		const Station *st = this->listview_mode ? NULL : Station::GetByTile(this->window_number);

	/* only execute the test call if it's toplevel, or we're not execing. */

	if (_docommand_recursive == 1 || !(flags & DC_EXEC) ) {

		SetTownRatingTestMode(true);

		res = proc(tile, flags & ~DC_EXEC, p1, p2, text);

		SetTownRatingTestMode(false);

	/* Execute the command here. All cost-relevant functions set the expenses type

	 * themselves to the cost object at some point */

	res = proc(tile, flags, p1, p2, text);

	if (res.Failed()) {

error:

	bool test_and_exec_can_differ = (cmd_flags & CMD_NO_TEST) != 0;

	/* Test the command. */

	SetTownRatingTestMode(true);

	BasePersistentStorageArray::SwitchMode(PSM_ENTER_TESTMODE);

	CommandCost res = proc(tile, flags, p1, p2, text);

	/* Actually try and execute the command. If no cost-type is given

	 * use the construction one */

	BasePersistentStorageArray::SwitchMode(PSM_ENTER_COMMAND);

	CommandCost res2 = proc(tile, flags | DC_EXEC, p1, p2, text);

	BasePersistentStorageArray::SwitchMode(PSM_LEAVE_COMMAND);

	{

		if (!this->groups.NeedRebuild()) return;

		if (this->livery_class >= LC_GROUP_RAIL) {

			GUIGroupList list;

	}

	/**

	 * Remove all items from the list and free allocated memory.

	 */

	inline void Reset()

	for (Industry **iid = _cargo_delivery_destinations.Begin(); iid != isend; iid++) {

		TriggerIndustryProduction(*iid);

	}

}

/**

 */

void EngineOverrideManager::ResetToDefaultMapping()

{

	for (VehicleType type = VEH_TRAIN; type <= VEH_AIRCRAFT; type++) {

		for (uint internal_id = 0; internal_id < _engine_counts[type]; internal_id++) {

			EngineIDMapping *eid = this->Append();

	/** Remove all items from the list. */

	inline void Clear()

	{

	}

	/** Compact the list down to the smallest block size boundary. */

	for (CompanyPropertiesMap::iterator it = this->companies.Begin(); it != end; it++) {

		delete it->second;

	}

	GamelogFree(this->gamelog_action, this->gamelog_actions);

	this->gamelog_action = NULL;

	Font *f = Layouter::GetFont(state.fontsize, state.cur_colour);

	line.buffer = buff_begin;

	/*

	 * Go through the whole string while adding Font instances to the font map

	for (FontColourMap::iterator it = fonts[size].Begin(); it != fonts[size].End(); ++it) {

		delete it->second;

	}

	/* We must reset the linecache since it references the just freed fonts */

	ResetLineCache();

	{

		if (!this->companies.NeedRebuild()) return;

		const Company *c;

		FOR_ALL_COMPANIES(c) {

	{

		if (!this->groups.NeedRebuild()) return;

		GUIGroupList list;

	for (Hotkey *hotkey = this->items; hotkey->name != NULL; ++hotkey) {

		IniItem *item = group->GetItem(hotkey->name, false);

		if (item != NULL) {

			if (item->value != NULL) ParseHotkeys(hotkey, item->value);

		}

	}

	void BuildSortIndustriesList()

	{

		if (this->industries.NeedRebuild()) {

			const Industry *i;

			FOR_ALL_INDUSTRIES(i) {

		_displayed_industries.reset();

		_displayed_industries.set(it);

		CargoesRow *row = this->fields.Append();

		row->columns[0].MakeHeader(STR_INDUSTRY_CARGOES_PRODUCERS);

		row->columns[1].MakeEmpty(CFT_SMALL_EMPTY);

		this->ind_cargo = cid + NUM_INDUSTRYTYPES;

		_displayed_industries.reset();

		CargoesRow *row = this->fields.Append();

		row->columns[0].MakeHeader(STR_INDUSTRY_CARGOES_PRODUCERS);

		row->columns[1].MakeEmpty(CFT_SMALL_EMPTY);

		for (SocketList::iterator s = sockets.Begin(); s != sockets.End(); s++) {

			closesocket(s->second);

		}

		DEBUG(net, 1, "[%s] closed listeners", Tsocket::GetName());

	}

};

	for (SocketList::iterator s = this->sockets.Begin(); s != this->sockets.End(); s++) {

		closesocket(s->second);

	}

}

NetworkRecvStatus NetworkUDPSocketHandler::CloseConnection(bool error)

		if (c->state != ContentInfo::AUTOSELECTED) continue;

		/* Only unselect when WE are the only parent. */

		this->ReverseLookupDependency(parents, c);

		/* First check whether anything depends on us */

		if (force_selection) continue;

		/* "Flood" search to find all items in the dependency graph*/

		this->ReverseLookupTreeDependency(parents, c);

		/* Is there anything that is "force" selected?, if so... we're done. */

{

	for (ContentIterator iter = this->infos.Begin(); iter != this->infos.End(); iter++) delete *iter;

}

/*** CALLBACK ***/

		if (!this->content.NeedRebuild()) return;

		/* Create temporary array of games to use for listing */

		bool all_available = true;

		if (!this->servers.NeedRebuild()) return;

		/* Create temporary array of games to use for listing */

		for (NetworkGameList *ngl = _network_game_list; ngl != NULL; ngl = ngl->next) {

			*this->servers.Append() = ngl;

	GetBindAddresses(&server, _settings_client.network.server_port);

	_udp_server_socket = new ServerNetworkUDPSocketHandler(&server);

	GetBindAddresses(&server, 0);

	_udp_master_socket = new MasterNetworkUDPSocketHandler(&server);

					if (_cur.skip_sprites < 0) return CIR_DISABLED;

					static SmallVector<DrawTileSeqStruct, 8> tmp_layout;

					for (;;) {

						/* no relative bounding box support */

						DrawTileSeqStruct *dtss = tmp_layout.Append();

		return CIR_INVALID_ID;

	}

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

		uint32 item = buf->ReadDWord();

		*translation_table.Append() = BSWAP32(item);

			}

			static SmallVector<DeterministicSpriteGroupAdjust, 16> adjusts;

			/* Loop through the var adjusts. Unfortunately we don't know how many we have

			 * from the outset, so we shall have to keep reallocing. */

		delete *file;

	}

	_cur.grffile   = NULL;

}

	for (StringIDMapping *it = _string_to_grf_mapping.Begin(); it != _string_to_grf_mapping.End(); it++) {

		*it->target = MapGRFStringID(it->grfid, it->source);

	}

	/* Free the action 6 override sprites. */

	for (GRFLineToSpriteOverride::iterator it = _grf_line_to_action6_sprite_override.begin(); it != _grf_line_to_action6_sprite_override.end(); it++) {

 */

uint32 NewGRFSpriteLayout::PrepareLayout(uint32 orig_offset, uint32 newgrf_ground_offset, uint32 newgrf_offset, uint constr_stage, bool separate_ground) const

{

	uint32 var10_values = 0;

	/* Create a copy of the spritelayout, so we can modify some values.

	{

		if (!this->avails.NeedRebuild()) return;

		for (const GRFConfig *c = _all_grfs; c != NULL; c = c->next) {

			bool found = false;

void InitializeSoundPool()

{

	/* Copy original sound data to the pool */

	SndCopyToPool();

			/* Set up new rail type */

			*rti = _original_railtypes[RAILTYPE_RAIL];

			rti->label = label;

			/* Make us compatible with ourself. */

			rti->powered_railtypes    = (RailTypes)(1LL << rt);

		SmallVector<uint, 16> skip_frames;

		FOR_ALL_ROADVEHICLES(v) {

			if (!v->IsFrontEngine()) continue;

			TileIndex prev_tile = v->tile;

			uint prev_tile_skip = 0;

			uint cur_skip = 0;

	}

	uint count = (uint)SlGetFieldLength() / sizeof(*_animated_tiles.Begin());

	_animated_tiles.Append(count);

	SlArray(_animated_tiles.Begin(), count, SLE_UINT32);

}

static void Load_EIDS()

{

	while (SlIterateArray() != -1) {

		EngineIDMapping *eid = _engine_mngr.Append();

		}

	}

}

/** Container for a label for SaveLoad system */

static void Load_RAIL()

{

	LabelObject lo;

static void Load_WAYP()

{

	/* Precaution for when loading failed and it didn't get cleared */

	int index;

				 * whether we're in the NULL or "normal" Ptrs proc. So just clear the list

				 * of old waypoints we constructed and then this waypoint (and the other

				 * possibly corrupt ones) will not be queried in the NULL Ptrs proc run. */

				SlErrorCorrupt("Referencing invalid Town");

			}

			wp->town = Town::Get(wp->town_index);

	/** Clear the temporary storage. */

	void Clear()

	{

	}

	/**

		DEBUG(misc, 3, "Building sign list");

		const Sign *si;

		FOR_ALL_SIGNS(si) *this->signs.Append() = si;

		DEBUG(misc, 3, "Building station list for company %d", owner);

		const Station *st;

		FOR_ALL_STATIONS(st) {

{

	TileArea ctx = ta;

	/* Check the inside, to return, if we sit on another station */

	TILE_AREA_LOOP(t, ta) {

	void BuildStoryPageList()

	{

		if (this->story_pages.NeedRebuild()) {

			const StoryPage *p;

			FOR_ALL_STORY_PAGES(p) {

	void BuildStoryPageElementList()

	{

		if (this->story_page_elements.NeedRebuild()) {

			const StoryPage *p = GetSelPage();

			if (p != NULL) {

			this->WriteLength(buffer.Length());

			this->Write(buffer.Begin(), buffer.Length());

		}

	}

}

		 * for word break iterators (especially for CJK languages) in combination

		 * with UTF-8 input. As a work around we have to convert the input to

		 * UTF-16 and create a mapping back to UTF-8 character indices. */

		while (*s != '\0') {

			size_t idx = s - string_base;

{

	if (textfile == NULL) return;

	/* Get text from file */

	size_t filesize;

	static int ref_count = 0; // Number of times test-mode is switched on.

	if (mode) {

		if (ref_count == 0) {

		}

		ref_count++;

	} else {

	void BuildSortTownList()

	{

		if (this->towns.NeedRebuild()) {

			const Town *t;

			FOR_ALL_TOWNS(t) {

 */

static void GetCargoSummaryOfArticulatedVehicle(const Train *v, CargoSummary *summary)

{

	do {

		if (!v->GetEngine()->CanCarryCargo()) continue;

void CallVehicleTicks()

{

	RunVehicleDayProc();

	}

	static SmallVector<RefitResult, 16> refit_result;

	v->InvalidateNewGRFCacheOfChain();

	byte actual_subtype = new_subtype;

		}

	}

	_returned_refit_capacity = total_capacity;

	_returned_mail_refit_capacity = total_mail_capacity;

	return cost;

	/* Create a list of subtypes used by the various parts of v_for */

	static SmallVector<StringID, 4> subtypes;

	for (; v_from != NULL; v_from = v_from->HasArticulatedPart() ? v_from->GetNextArticulatedPart() : NULL) {

		const Engine *e_from = v_from->GetEngine();

		if (!e_from->CanCarryCargo() || !HasBit(e_from->info.callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) continue;

	 */

	void BuildRefitList()

	{

		Vehicle *v = Vehicle::Get(this->window_number);

		/* Check only the selected vehicles. */

 */

void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engines, VehicleList *wagons, bool individual_wagons)

{

	const Vehicle *v;

	FOR_ALL_VEHICLES(v) {

 */

bool GenerateVehicleSortList(VehicleList *list, const VehicleListIdentifier &vli)

{

	const Vehicle *v;