{

	ScriptScanner::Initialize("AIScanner");

	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");

}

void AIScannerInfo::SetDummyAI(class AIInfo *info)

{

class BaseMedia : FileScanner {

protected:

	static Tbase_set *available_sets; ///< All available sets

	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.

	 * @return the extension

	 */

	static const char *GetExtension();

	}

	return true;

}

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);

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

		path.erase(psep + 1);

	} else {

		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) {

				duplicate = c;

				break;

			}

 * @param repl_type the type of the BaseMedia to instantiate

 * @param set_type  the type of the BaseSet to instantiate

 */

#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); \

	template int repl_type::GetNumSets(); \

	template int repl_type::GetIndexOfUsedSet(); \

	template const set_type *repl_type::GetSet(int index); \

 * The search paths OpenTTD could search through.

 * At least one of the slots has to be filled with a path.

 * An empty string tells that there is no such path for the

 * current operating system.

 */

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

TarFileList _tar_filelist[NUM_SUBDIRS];

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

static TarLinkList _tar_linklist[NUM_SUBDIRS]; ///< List of directory links

/**

 * @param[out] filesize If not \c nullptr, size of the opened file.

 * @return File handle of the opened file, or \c nullptr if the file is not available.

 * @note The file is read from within the tar file, and may not return \c EOF after reading the whole file.

 */

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

{

	if (f == nullptr) return f;

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

		fclose(f);

		return nullptr;

	}

/**

 * Add a single file to the scanned files of a tar, circumventing the scanning code.

 * @param sd       The sub directory the file is in.

 * @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 {

		char name[100];      ///< Name of the file

		char mode[8];

		char uid[8];

	};

	/* Check if we already seen this file */

	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

	TarHeader th;

	char buf[sizeof(th.name) + 1], *end;

	char name[sizeof(th.prefix) + 1 + sizeof(th.name) + 1];

		/* Check if we have the new tar-format (ustar) or the old one (a lot of zeros after 'link' field) */

		if (strncmp(th.magic, "ustar", 5) != 0 && memcmp(&th.magic, &empty[0], 512 - offsetof(TarHeader, magic)) != 0) {

			/* 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;

		}

		name[0] = '\0';

				if (skip == 0) break;

				if (strlen(name) == 0) break;

				/* Store this entry in the list */

				TarFileListEntry entry;

				entry.size         = skip;

				entry.position     = pos;

				/* Convert to lowercase and our PATHSEPCHAR */

				SimplifyFileName(name);

						/* Append at end of 'dest' */

						if (destpos != dest) destpos = strecpy(destpos, PATHSEP, lastof(dest));

						destpos = strecpy(destpos, pos, lastof(dest));

					}

					if (destpos >= lastof(dest)) {

						fclose(f);

						return false;

					}

					pos = next;

				}

			case '5': // directory

				/* Convert to lowercase and our PATHSEPCHAR */

				SimplifyFileName(name);

				/* Store the first directory name we detect */

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

				break;

			default:

				/* Ignore other types */

				break;

		}

		/* 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 restrict usage of links to two cases:

	 *  1) Links to directories:

	 *      Both the source path and the destination path must NOT contain any further links.

bool ExtractTar(const std::string &tar_filename, Subdirectory subdir)

{

	TarList::iterator it = _tar_list[subdir].find(tar_filename);

	/* 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;

	}

	std::string filename = tar_filename;

	auto p = filename.find_last_of(PATHSEPCHAR);

			if (!recursive) continue;

			if (strcmp(d_name, ".") == 0 || strcmp(d_name, "..") == 0) continue;

			AppendPathSeparator(filename);

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

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

			/* File */

		}

	}

	closedir(dir);

	return num;

 * @param extension the extension of files to search for.

 * @param tar       the tar to search in.

 */

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

{

	uint num = 0;

	return num;

}

/**

 * Scan for files with the given extension in the given search path.

	 * @param filename        the full path to the file to read

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

	 *                        filename relative to the search path.

	 * @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 */

class TarScanner : FileScanner {

	uint DoScan(Subdirectory sd);

public:

		AI       = 1 << 2, ///< Scan for AIs and its libraries.

		SCENARIO = 1 << 3, ///< Scan for scenarios and heightmaps.

		GAME     = 1 << 4, ///< Scan for game scripts.

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

	};

	/** Do the scan for Tars. */

	static uint DoScan(TarScanner::Mode mode);

};

DECLARE_ENUM_AS_BIT_SET(TarScanner::Mode)

extern bool FiosIsValidFile(const char *path, const struct dirent *ent, struct stat *sb);

extern bool FiosIsHiddenFile(const struct dirent *ent);

extern void FiosGetDrives(FileList &file_list);

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.

 * @param other The FiosItem to compare to.

 * @return for ascending order: returns true if da < db. Vice versa for descending order.

 */

bool FiosDelete(const char *name)

{

	std::string filename = FiosMakeSavegameName(name);

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

}

/**

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

 */

class FiosFileScanner : public FileScanner {

	SaveLoadOperation fop;   ///< The kind of file we are looking for.

	 * @param file_list Destination of the found files.

	 */

	FiosFileScanner(SaveLoadOperation fop, fios_getlist_callback_proc *callback_proc, FileList &file_list) :

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

	{}

};

/**

 * Try to add a fios item set with the given filename.

 * @param filename        the full path to the file to read

 * @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;

		ULARGE_INTEGER ft_int64;

		if (GetFileTime(fh, nullptr, nullptr, &ft) != 0) {

			fios->mtime = 0;

		}

		CloseHandle(fh);

#else

	struct stat sb;

		fios->mtime = sb.st_mtime;

#endif

	} else {

		fios->mtime = 0;

	}

	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));

	return true;

}

 * the same as the data file but with '.title' added to it.

 * @param file filename to get the title for

 * @param title the title buffer to fill

 * @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;

	size_t read = fread(title, 1, last - title, f);

	assert(title + read <= last);

 * @param title Buffer if a callback wants to lookup the title of the file; nullptr to skip the lookup

 * @param last Last available byte in buffer (to prevent buffer overflows); not used when title == nullptr

 * @return a FIOS_TYPE_* type of the found file, FIOS_TYPE_INVALID if not a savegame

 * @see FiosGetFileList

 * @see FiosGetSavegameList

 */

{

	/* Show savegame files

	 * .SAV OpenTTD saved game

	 * .SS1 Transport Tycoon Deluxe preset game

	 * .SV1 Transport Tycoon Deluxe (Patch) saved game

	 * .SV2 Transport Tycoon Deluxe (Patch) saved 2-player game */

 * @param title Buffer if a callback wants to lookup the title of the file

 * @param last Last available byte in buffer (to prevent buffer overflows)

 * @return a FIOS_TYPE_* type of the found file, FIOS_TYPE_INVALID if not a scenario

 * @see FiosGetFileList

 * @see FiosGetScenarioList

 */

{

	/* Show scenario files

	 * .SCN OpenTTD style scenario file

	 * .SV0 Transport Tycoon Deluxe (Patch) scenario

	 * .SS0 Transport Tycoon Deluxe preset scenario */

	if (strcasecmp(ext, ".scn") == 0) {

	std::string base_path = FioFindDirectory(SCENARIO_DIR);

	Subdirectory subdir = (fop == SLO_LOAD && base_path == *_fios_path) ? SCENARIO_DIR : NO_DIRECTORY;

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

}

{

	/* Show heightmap files

	 * .PNG PNG Based heightmap files

	 * .BMP BMP Based heightmap files

	 */

		if (this->scanned && !rescan) return;

		this->FileScanner::Scan(".id", SCENARIO_DIR, true, true);

		this->scanned = true;

	}

	{

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

		if (f == nullptr) return false;

		ScenarioIdentifier id;

		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 */

		while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {

			size -= len;

			checksum.Append(buffer, len);

StringID FiosGetDescText(const char **path, uint64 *total_free);

bool FiosDelete(const char *name);

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

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

#endif /* FIOS_H */

	 */

	void Scan(const char *directory)

	{

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

	}

	{

		if (exclude == filename) return true;

		auto ls = ReadRawLanguageStrings(filename);

		if (!ls.IsValid()) return false;

		gs->raw_strings.push_back(std::move(ls));

		/* Scan for other language files */

		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;

			FOR_ALL_TARS(tar, GAME_DIR) {

				/* Not in the same tar. */

				if (tar->second.tar_filename != iter->first) continue;

				/* Check the path and extension. */

				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 */

			scanner.Scan(ldir.c_str());

		}

public:

	GRFFileScanner() : next_update(_realtime_tick), num_scanned(0)

	{

	}

	/** Do the scan for GRFs. */

	static uint DoScan()

	{

		GRFFileScanner fs;

		int ret = fs.Scan(".grf", NEWGRF_DIR);

		 * duplicate NewGRFs and base sets are ignored in the return value. */

		_settings_client.gui.last_newgrf_count = fs.num_scanned;

		return ret;

	}

};

{

	bool added = true;

	if (FillGRFDetails(c, false)) {

		if (_all_grfs == nullptr) {

			_all_grfs = c;

		} else {

				_switch_mode = is_scenario ? SM_LOAD_SCENARIO : SM_LOAD_GAME;

				_file_to_saveload.SetMode(SLO_LOAD, is_scenario ? FT_SCENARIO : FT_SAVEGAME, DFT_GAME_FILE);

				/* 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);

				}

				break;

			}

	_pause_mode = PM_PAUSED_SAVELOAD;

	return true;

}

{

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

	if (f == nullptr) {

		*title = '\0';

		return;

	free(this->name);

	free(this->short_name);

	free(this->description);

	free(this->date);

	free(this->instance_name);

	free(this->url);

	free(this->SQ_instance);

}

bool ScriptInfo::CheckMethod(const char *name) const

{

	if (!this->engine->MethodExists(*this->SQ_instance, name)) {

	};

	for (size_t i = 0; i < lengthof(required_functions); i++) {

		if (!info->CheckMethod(required_functions[i])) return SQ_ERROR;

	}

	/* 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;

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

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

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

/** All static information from an Script like name, version, etc. */

class ScriptInfo : public SimpleCountedObject {

public:

	ScriptInfo() :

		engine(nullptr),

		SQ_instance(nullptr),

		author(nullptr),

		name(nullptr),

		short_name(nullptr),

		description(nullptr),

		date(nullptr),

		instance_name(nullptr),

	 */

	const char *GetURL() const { return this->url; }

	/**

	 * Get the filename of the main.nut script.

	 */

	/**

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

	 */

	/**

	 * Check if a given method exists.

	 */

	bool CheckMethod(const char *name) const;