ScriptAllocatorScope alloc_scope(this->engine);

	/* Create the dummy AI */

	extern void Script_CreateDummyInfo(HSQUIRRELVM vm, const char *type, const char *dir);

	Script_CreateDummyInfo(this->engine->GetVM(), "AI", "ai");

}

	static Tbase_set *duplicate_sets; ///< All sets that aren't available, but needed for not downloading base sets when a newer version than the one on BaNaNaS is loaded.

	static const Tbase_set *used_set; ///< The currently used set

	/**

	 * Get the extension that is used to identify this set.

}

template <class Tbase_set>

{

	bool ret = false;

	Tbase_set *set = new Tbase_set();

	IniFile *ini = new IniFile();

	ini->LoadFromDisk(path, BASESET_DIR);

	auto psep = path.rfind(PATHSEPCHAR);

		path.clear();

	}

		Tbase_set *duplicate = nullptr;

		for (Tbase_set *c = BaseMedia<Tbase_set>::available_sets; c != nullptr; c = c->next) {

			if (c->name == set->name || c->shortname == set->shortname) {

#define INSTANTIATE_BASE_MEDIA_METHODS(repl_type, set_type) \

	template std::string repl_type::ini_set; \

	template const char *repl_type::GetExtension(); \

	template bool repl_type::HasSet(const struct ContentInfo *ci, bool md5sum); \

	template bool repl_type::SetSet(const std::string &name); \

	template char *repl_type::GetSetsList(char *p, const char *last); \

 * current operating system.

 */

std::array<std::string, NUM_SEARCHPATHS> _searchpaths;

TarFileList _tar_filelist[NUM_SUBDIRS];

typedef std::map<std::string, std::string> TarLinkList;

 */

FILE *FioFOpenFileTar(const TarFileListEntry &entry, size_t *filesize)

{

	if (f == nullptr) return f;

	if (fseek(f, entry.position, SEEK_SET) < 0) {

 * @param filename The name of the file to add.

 * @return True if the additions went correctly.

 */

{

	this->subdir = sd;

	return this->AddFile(filename, 0);

}

{

	/* No tar within tar. */

	/* The TAR-header, repeated for every file */

	struct TarHeader {

	TarList::iterator it = _tar_list[this->subdir].find(filename);

	if (it != _tar_list[this->subdir].end()) return false;

	/* Although the file has been found there can be

	 * a number of reasons we cannot open the file.

	 * Most common case is when we simply have not

	 * been given read access. */

	if (f == nullptr) return false;

	TarLinkList links; ///< Temporary list to collect links

			/* If we have only zeros in the block, it can be an end-of-file indicator */

			if (memcmp(&th, &empty[0], 512) == 0) continue;

			fclose(f);

			return false;

		}

				/* Store this entry in the list */

				TarFileListEntry entry;

				entry.size         = skip;

				entry.position     = pos;

					}

					if (destpos >= lastof(dest)) {

						fclose(f);

						return false;

					}

				/* Store the first directory name we detect */

				DEBUG(misc, 6, "Found dir in tar: %s", name);

				break;

			default:

		/* Skip to the next block.. */

		skip = Align(skip, 512);

		if (fseek(f, skip, SEEK_CUR) < 0) {

			fclose(f);

			return false;

		}

		pos += skip;

	}

	fclose(f);

	/* Resolve file links and store directory links.

	/* We don't know the file. */

	if (it == _tar_list[subdir].end()) return false;

	/* The file doesn't have a sub directory! */

		DEBUG(misc, 1, "Extracting %s failed; archive rejected, the contents must be in a sub directory", tar_filename.c_str());

		return false;

	}

			num += ScanPath(fs, extension, filename.c_str(), basepath_length, recursive);

		} else if (S_ISREG(sb.st_mode)) {

			/* File */

		}

	}

static uint ScanTar(FileScanner *fs, const char *extension, TarFileList::iterator tar)

{

	uint num = 0;

	return num;

}

	 * @param tar_filename    the name of the tar file the file is read from.

	 * @return true if the file is added.

	 */

};

/** Helper for scanning for files with tar as extension */

		ALL      = BASESET | NEWGRF | AI | SCENARIO | GAME, ///< Scan for everything.

	};

	/** Do the scan for Tars. */

	static uint DoScan(TarScanner::Mode mode);

extern bool FiosGetDiskFreeSpace(const char *path, uint64 *tot);

/* get the name of an oldstyle savegame */

/**

 * Compare two FiosItem's. Used with sort when sorting the file list.

	return unlink(filename.c_str()) == 0;

}

/**

 * Scanner to scan for a particular type of FIOS file.

			fop(fop), callback_proc(callback_proc), file_list(file_list)

	{}

};

/**

 * @param basepath_length amount of characters to chop of before to get a relative filename

 * @return true if the file is added.

 */

{

	char fios_title[64];

	fios_title[0] = '\0'; // reset the title;

	if (type == FIOS_TYPE_INVALID) return false;

	for (const FiosItem *fios = file_list.Begin(); fios != file_list.End(); fios++) {

	}

	FiosItem *fios = file_list.Append();

#ifdef _WIN32

	// Retrieve the file modified date using GetFileTime rather than stat to work around an obscure MSVC bug that affects Windows XP

	if (fh != INVALID_HANDLE_VALUE) {

		FILETIME ft;

		CloseHandle(fh);

#else

	struct stat sb;

		fios->mtime = sb.st_mtime;

#endif

	} else {

	}

	fios->type = type;

	/* If the file doesn't have a title, use its filename */

	const char *t = fios_title;

	if (StrEmpty(fios_title)) {

	}

	strecpy(fios->title, t, lastof(fios->title));

	str_validate(fios->title, lastof(fios->title));

 * @param last the last element in the title buffer

 * @param subdir the sub directory to search in

 */

{

	FILE *f = FioFOpenFile(buf, "r", subdir);

	if (f == nullptr) return;

 * @see FiosGetFileList

 * @see FiosGetSavegameList

 */

{

	/* Show savegame files

	 * .SAV OpenTTD saved game

 * @see FiosGetFileList

 * @see FiosGetScenarioList

 */

{

	/* Show scenario files

	 * .SCN OpenTTD style scenario file

	FiosGetFileList(fop, &FiosGetScenarioListCallback, subdir, file_list);

}

{

	/* Show heightmap files

	 * .PNG PNG Based heightmap files

		this->scanned = true;

	}

	{

		FILE *f = FioFOpenFile(filename, "r", SCENARIO_DIR);

		if (f == nullptr) return false;

		int fret = fscanf(f, "%u", &id.scenid);

		FioFCloseFile(f);

		if (fret != 1) return false;

		Md5 checksum;

		uint8 buffer[1024];

		size_t len, size;

		/* open the scenario file, but first get the name.

		 * This is safe as we check on extension which

		 * must always exist. */

		if (f == nullptr) return false;

		/* calculate md5sum */

std::string FiosMakeHeightmapName(const char *name);

std::string FiosMakeSavegameName(const char *name);

#endif /* FIOS_H */

		this->FileScanner::Scan(".txt", directory, false);

	}

	{

		if (exclude == filename) return true;

		LanguageScanner scanner(gs, filename);

		std::string ldir = basename + "lang" PATHSEP;

		TarList::iterator iter;

			/* The main script is in a tar file, so find all files that

			 * are in the same tar and add them to the langfile scanner. */

			TarFileList::iterator tar;

				if (tar->first.size() <= ldir.size() || tar->first.compare(0, ldir.size(), ldir) != 0) continue;

				if (tar->first.compare(tar->first.size() - 4, 4, ".txt") != 0) continue;

			}

		} else {

			/* Scan filesystem */

	{

	}

	/** Do the scan for GRFs. */

	static uint DoScan()

	}

};

{

	bool added = true;

	if (FillGRFDetails(c, false)) {

				/* if the file doesn't exist or it is not a valid savegame, let the saveload code show an error */

				auto t = _file_to_saveload.name.find_last_of('.');

				if (t != std::string::npos) {

					if (ft != FIOS_TYPE_INVALID) _file_to_saveload.SetMode(ft);

				}

	return true;

}

{

	FILE *f = FioFOpenFile(file, "rb", NO_DIRECTORY);

	free(this->date);

	free(this->instance_name);

	free(this->url);

	free(this->SQ_instance);

}

	}

	/* Get location information of the scanner */

	/* Cache the data the info file gives us. */

	if (!info->engine->CallStringMethodStrdup(*info->SQ_instance, "GetAuthor", &info->author, MAX_GET_OPS)) return SQ_ERROR;

	ScriptInfo() :

		engine(nullptr),

		SQ_instance(nullptr),

		author(nullptr),

		name(nullptr),

		short_name(nullptr),

	/**

	 * Get the filename of the main.nut script.

	 */

	/**

	 * Get the filename of the tar the script is in.

	 */

	/**

	 * Check if a given method exists.

	ScriptConfigItemList config_list; ///< List of settings from this Script.

private:

	const char *author;           ///< Author of the script.

	const char *name;             ///< Full name of the script.

	const char *short_name;       ///< Short name (4 chars) which uniquely identifies the script.

#include "../safeguards.h"

{

	if (!FioCheckFileExists(filename, this->subdir) || !FioCheckFileExists(this->main_script, this->subdir)) return false;

	this->ResetEngine();

	try {

	} catch (Script_FatalError &e) {

		return false;

	}

	return true;

}

ScriptScanner::ScriptScanner() :

{

}

{

	this->Reset();

	delete this->engine;

}

	}

	/* Add the file and calculate the md5 sum. */

	{

		Md5 checksum;

		uint8 buffer[1024];

		byte tmp_md5sum[16];

		/* Open the file ... */

		if (f == nullptr) return false;

		/* ... calculate md5sum... */

	if (!md5sum) return true;

	ScriptFileChecksumCreator checksum(dir);

	TarList::iterator iter;

		/* The main script is in a tar file, so find all files that

		 * are in the same tar and add them to the MD5 checksumming. */

		TarFileList::iterator tar;

			const char *ext = strrchr(tar->first.c_str(), '.');

			if (ext == nullptr || strcasecmp(ext, ".nut") != 0) continue;

		}

	} else {

		char path[MAX_PATH];

	/**

	 * Get the current main script the ScanDir is currently tracking.

	 */

	/**

	 * Get the current tar file the ScanDir is currently tracking.

	 */

	/**

	 * Get the list of all registered scripts.

	 */

	const char *FindMainScript(const ContentInfo *ci, bool md5sum);

	/**

	 * Rescan the script dir.

	void RescanDir();

protected:

	ScriptInfoList info_list;        ///< The list of all script.

	ScriptInfoList info_single_list; ///< The list of all unique script. The best script (highest version) is shown.

#include <map>

#include <string>

#include "fileio_type.h"

struct TarFileListEntry {

	size_t size;

	size_t position;

};

typedef std::map<std::string, TarFileListEntry> TarFileList;

extern TarFileList _tar_filelist[NUM_SUBDIRS];

#define FOR_ALL_TARS(tar, sd) for (tar = _tar_filelist[sd].begin(); tar != _tar_filelist[sd].end(); tar++)