}

		}

		assert(slot != -1);

		DEBUG(misc, 6, "Closing filehandler '%s' in slot '%d' because of fd-limit", _fio.filenames[slot], slot);

		FioCloseFile(slot);

	}

}

#endif /* LIMITED_FDS */

void FioOpenFile(int slot, const char *filename)

{

	FILE *f;

#if defined(LIMITED_FDS)

	FioFreeHandle();

#endif /* LIMITED_FDS */

	f = FioFOpenFile(filename);

	if (f == NULL) usererror("Cannot open file '%s'", filename);

	uint32 pos = ftell(f);

	FioCloseFile(slot); // if file was opened before, close it

	_fio.handles[slot] = f;

	_fio.filenames[slot] = filename;

	/* Store the filename without path and extension */

	const char *t = strrchr(filename, PATHSEPCHAR);

	_fio.shortnames[slot] = strdup(t == NULL ? filename : t);

	char *t2 = strrchr(_fio.shortnames[slot], '.');

	if (t2 != NULL) *t2 = '\0';

	strtolower(_fio.shortnames[slot]);

#if defined(LIMITED_FDS)

	_fio.usage_count[slot] = 0;

	_fio.open_handles++;

#endif /* LIMITED_FDS */

	FioSeekToFile(slot, pos);

}

const char *_subdirs[NUM_SUBDIRS] = {

	"",

	"save" PATHSEP,

	"save" PATHSEP "autosave" PATHSEP,

	"scenario" PATHSEP,

	"scenario" PATHSEP "heightmap" PATHSEP,

	"gm" PATHSEP,

	"data" PATHSEP,

	"lang" PATHSEP,

	"ai" PATHSEP,

	"ai" PATHSEP "library" PATHSEP,

};

const char *_searchpaths[NUM_SEARCHPATHS];

TarList _tar_list;

TarFileList _tar_filelist;

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

static TarLinkList _tar_linklist; ///< List of directory links

/**

 * Check whether the given file exists

 * @param filename the file to try for existance

 * @param subdir the subdirectory to look in

 * @return true if and only if the file can be opened

 */

bool FioCheckFileExists(const char *filename, Subdirectory subdir)

{

	FILE *f = FioFOpenFile(filename, "rb", subdir);

	if (f == NULL) return false;

	FioFCloseFile(f);

	return true;

}

/**

 * Close a file in a safe way.

 */

void FioFCloseFile(FILE *f)

{

	fclose(f);

}

char *FioGetFullPath(char *buf, size_t buflen, Searchpath sp, Subdirectory subdir, const char *filename)

{

	assert(subdir < NUM_SUBDIRS);

	assert(sp < NUM_SEARCHPATHS);

	snprintf(buf, buflen, "%s%s%s", _searchpaths[sp], _subdirs[subdir], filename);

	return buf;

}

char *FioFindFullPath(char *buf, size_t buflen, Subdirectory subdir, const char *filename)

{

	Searchpath sp;

	assert(subdir < NUM_SUBDIRS);

	FOR_ALL_SEARCHPATHS(sp) {

		FioGetFullPath(buf, buflen, sp, subdir, filename);

		if (FileExists(buf)) break;

	}

	return buf;

}

char *FioAppendDirectory(char *buf, size_t buflen, Searchpath sp, Subdirectory subdir)

{

	assert(subdir < NUM_SUBDIRS);

	assert(sp < NUM_SEARCHPATHS);

	snprintf(buf, buflen, "%s%s", _searchpaths[sp], _subdirs[subdir]);

	return buf;

}

char *FioGetDirectory(char *buf, size_t buflen, Subdirectory subdir)

{

	Searchpath sp;

	/* Find and return the first valid directory */

	FOR_ALL_SEARCHPATHS(sp) {

		char *ret = FioAppendDirectory(buf, buflen, sp, subdir);

		if (FileExists(buf)) return ret;

	}

	/* Could not find the directory, fall back to a base path */

	ttd_strlcpy(buf, _personal_dir, buflen);

	return buf;

}

FILE *FioFOpenFileSp(const char *filename, const char *mode, Searchpath sp, Subdirectory subdir, size_t *filesize)

{

#if defined(WIN32) && defined(UNICODE)

	/* fopen is implemented as a define with ellipses for

	 * Unicode support (prepend an L). As we are not sending

	 * a string, but a variable, it 'renames' the variable,

	 * so make that variable to makes it compile happily */

	wchar_t Lmode[5];

	MultiByteToWideChar(CP_ACP, 0, mode, -1, Lmode, lengthof(Lmode));

#endif

	FILE *f = NULL;

	char buf[MAX_PATH];

	if (subdir == NO_DIRECTORY) {

		strecpy(buf, filename, lastof(buf));

	} else {

		snprintf(buf, lengthof(buf), "%s%s%s", _searchpaths[sp], _subdirs[subdir], filename);

	}

#if defined(WIN32)

	if (mode[0] == 'r' && GetFileAttributes(OTTD2FS(buf)) == INVALID_FILE_ATTRIBUTES) return NULL;

#endif

	f = fopen(buf, mode);

#if !defined(WIN32)

	if (f == NULL) {

		strtolower(buf + ((subdir == NO_DIRECTORY) ? 0 : strlen(_searchpaths[sp]) - 1));

		f = fopen(buf, mode);

	}

#endif

	if (f != NULL && filesize != NULL) {

		/* Find the size of the file */

		fseek(f, 0, SEEK_END);

		*filesize = ftell(f);

		fseek(f, 0, SEEK_SET);

	}

	return f;

}

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

{

	FILE *f = fopen(entry->tar_filename, "rb");

	assert(f != NULL);

	fseek(f, entry->position, SEEK_SET);

	if (filesize != NULL) *filesize = entry->size;

	return f;

}

/** Opens OpenTTD files somewhere in a personal or global directory */

FILE *FioFOpenFile(const char *filename, const char *mode, Subdirectory subdir, size_t *filesize)

{

	FILE *f = NULL;

	Searchpath sp;

	assert(subdir < NUM_SUBDIRS || subdir == NO_DIRECTORY);

	FOR_ALL_SEARCHPATHS(sp) {

		f = FioFOpenFileSp(filename, mode, sp, subdir, filesize);

		if (f != NULL || subdir == NO_DIRECTORY) break;

	}

	/* We can only use .tar in case of data-dir, and read-mode */

	if (f == NULL && mode[0] == 'r') {

		static const uint MAX_RESOLVED_LENGTH = 2 * (100 + 100 + 155) + 1; // Enough space to hold two filenames plus link. See 'TarHeader'.

		char resolved_name[MAX_RESOLVED_LENGTH];

		/* Filenames in tars are always forced to be lowercase */

		strcpy(resolved_name, filename);

		strtolower(resolved_name);

		size_t resolved_len = strlen(resolved_name);

		/* Resolve ONE directory link */

		for (TarLinkList::iterator link = _tar_linklist.begin(); link != _tar_linklist.end(); link++) {

			const std::string &src = link->first;

			size_t len = src.length();

			if (resolved_len >= len && resolved_name[len - 1] == PATHSEPCHAR && strncmp(src.c_str(), resolved_name, len) == 0) {

				/* Apply link */

				char resolved_name2[MAX_RESOLVED_LENGTH];

				const std::string &dest = link->second;

				strcpy(resolved_name2, &(resolved_name[len]));

				strcpy(resolved_name, dest.c_str());

				strcpy(&(resolved_name[dest.length()]), resolved_name2);

				break; // Only resolve one level

			}

		}

		TarFileList::iterator it = _tar_filelist.find(resolved_name);

		if (it != _tar_filelist.end()) {

			f = FioFOpenFileTar(&((*it).second), filesize);

		}

	}

	/* Sometimes a full path is given. To support

	 * the 'subdirectory' must be 'removed'. */

	if (f == NULL && subdir != NO_DIRECTORY) {

		f = FioFOpenFile(filename, mode, NO_DIRECTORY, filesize);

	}

	return f;

}

/**

 * Create a directory with the given name

 * @param name the new name of the directory

 */

void FioCreateDirectory(const char *name)

{

#if defined(WIN32) || defined(WINCE)

	CreateDirectory(OTTD2FS(name), NULL);

#elif defined(OS2) && !defined(__INNOTEK_LIBC__)

	mkdir(OTTD2FS(name));

#elif defined(__MORPHOS__) || defined(__AMIGAOS__)

	char buf[MAX_PATH];

	ttd_strlcpy(buf, name, MAX_PATH);

	size_t len = strlen(name) - 1;

	if (buf[len] == '/') {

		buf[len] = '\0'; // Kill pathsep, so mkdir() will not fail

	}

	mkdir(OTTD2FS(buf), 0755);

#else

	mkdir(OTTD2FS(name), 0755);

#endif

}

/**

 * Appends, if necessary, the path separator character to the end of the string.

 * It does not add the path separator to zero-sized strings.

 * @param buf    string to append the separator to

 * @param buflen the length of the buf

 */

void AppendPathSeparator(char *buf, size_t buflen)

{

	size_t s = strlen(buf);

	/* Length of string + path separator + '\0' */

	if (s != 0 && buf[s - 1] != PATHSEPCHAR && s + 2 < buflen) {

		buf[s]     = PATHSEPCHAR;

		buf[s + 1] = '\0';

	}

}

/**

 * Allocates and files a variable with the full path

 * based on the given directory.

 * @param dir the directory to base the path on

 * @return the malloced full path

 */

char *BuildWithFullPath(const char *dir)

{

	char *dest = MallocT<char>(MAX_PATH);

	ttd_strlcpy(dest, dir, MAX_PATH);

	/* Check if absolute or relative path */

	const char *s = strchr(dest, PATHSEPCHAR);

	/* Add absolute path */

	if (s == NULL || dest != s) {

		if (getcwd(dest, MAX_PATH) == NULL) *dest = '\0';

		AppendPathSeparator(dest, MAX_PATH);

		ttd_strlcat(dest, dir, MAX_PATH);

	}

	AppendPathSeparator(dest, MAX_PATH);

	return dest;

}

const char *FioTarFirstDir(const char *tarname)

{

	TarList::iterator it = _tar_list.find(tarname);

	if (it == _tar_list.end()) return NULL;

	return (*it).second.dirname;

}

static void TarAddLink(const std::string &srcParam, const std::string &destParam)

{

	std::string src = srcParam;

	std::string dest = destParam;

	/* Tar internals assume lowercase */

	std::transform(src.begin(), src.end(), src.begin(), tolower);

	std::transform(dest.begin(), dest.end(), dest.begin(), tolower);

	TarFileList::iterator dest_file = _tar_filelist.find(dest);

	if (dest_file != _tar_filelist.end()) {

		/* Link to file. Process the link like the destination file. */

		_tar_filelist.insert(TarFileList::value_type(src, dest_file->second));

	} else {

		/* Destination file not found. Assume 'link to directory' */

		/* Append PATHSEPCHAR to 'src' and 'dest' if needed */

		const std::string src_path = ((*src.rbegin() == PATHSEPCHAR) ? src : src + PATHSEPCHAR);

		const std::string dst_path = (dest.length() == 0 ? "" : ((*dest.rbegin() == PATHSEPCHAR) ? dest : dest + PATHSEPCHAR));

		_tar_linklist.insert(TarLinkList::value_type(src_path, dst_path));

	}

}

void FioTarAddLink(const char *src, const char *dest)

{

	TarAddLink(src, dest);

}

/**

 * Simplify filenames from tars.

 * Replace '/' by PATHSEPCHAR, and force 'name' to lowercase.

 * @param name Filename to process.

 */

static void SimplifyFileName(char *name)

{

	/* Force lowercase */

	strtolower(name);

	/* Tar-files always have '/' path-seperator, but we want our PATHSEPCHAR */

#if (PATHSEPCHAR != '/')

	for (char *n = name; *n != '\0'; n++) if (*n == '/') *n = PATHSEPCHAR;

#endif

}

bool TarListAddFile(const char *filename)

{

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

	typedef struct TarHeader {

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

		char mode[8];

		char uid[8];

		char gid[8];

		char size[12];       ///< Size of the file, in ASCII

		char mtime[12];

		char chksum[8];

		char typeflag;

		char linkname[100];

		char magic[6];

		char version[2];

		char uname[32];

		char gname[32];

		char devmajor[8];

		char devminor[8];

		char prefix[155];    ///< Path of the file

		char unused[12];

	} TarHeader;

	/* Check if we already seen this file */

	TarList::iterator it = _tar_list.find(filename);

	if (it != _tar_list.end()) return false;

	FILE *f = fopen(filename, "rb");

	assert(f != NULL);

	const char *dupped_filename = strdup(filename);

	_tar_list[filename].filename = dupped_filename;

	_tar_list[filename].dirname = NULL;

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

	char link[sizeof(th.linkname) + 1];

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

	size_t num = 0, pos = 0;

	/* Make a char of 512 empty bytes */

	char empty[512];

	memset(&empty[0], 0, sizeof(empty));

	for (;;) { // Note: feof() always returns 'false' after 'fseek()'. Cool, isn't it?

		size_t num_bytes_read = fread(&th, 1, 512, f);

		if (num_bytes_read != 512) break;

		pos += num_bytes_read;

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

			DEBUG(misc, 0, "The file '%s' isn't a valid tar-file", filename);

			return false;

		}

		name[0] = '\0';

		size_t len = 0;

		/* The prefix contains the directory-name */

		if (th.prefix[0] != '\0') {

			memcpy(name, th.prefix, sizeof(th.prefix));

			name[sizeof(th.prefix)] = '\0';

			len = strlen(name);

			name[len] = PATHSEPCHAR;

			len++;

		}

		/* Copy the name of the file in a safe way at the end of 'name' */

		memcpy(&name[len], th.name, sizeof(th.name));

		name[len + sizeof(th.name)] = '\0';

		/* Calculate the size of the file.. for some strange reason this is stored as a string */

		memcpy(buf, th.size, sizeof(th.size));

		buf[sizeof(th.size)] = '\0';

		int skip = strtol(buf, &end, 8);

		switch (th.typeflag) {

			case '\0':

			case '0': { // regular file

				/* Ignore empty files */

				if (skip == 0) break;

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

				/* Store this entry in the list */

				TarFileListEntry entry;

				entry.tar_filename = dupped_filename;

				entry.size         = skip;

				entry.position     = pos;

				/* Convert to lowercase and our PATHSEPCHAR */

				SimplifyFileName(name);

				DEBUG(misc, 6, "Found file in tar: %s (%d bytes, %d offset)", name, skip, pos);

				if (_tar_filelist.insert(TarFileList::value_type(name, entry)).second) num++;

				break;

			}

			case '1': // hard links

			case '2': { // symbolic links

				/* Copy the destination of the link in a safe way at the end of 'linkname' */

				memcpy(link, th.linkname, sizeof(th.linkname));

				link[sizeof(th.linkname)] = '\0';

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

				/* Convert to lowercase and our PATHSEPCHAR */

				SimplifyFileName(name);

				SimplifyFileName(link);

				/* Only allow relative links */

				if (link[0] == PATHSEPCHAR) {

					DEBUG(misc, 1, "Ignoring absolute link in tar: %s -> %s", name, link);

					break;

				}

				/* Process relative path.

				 * Note: The destination of links must not contain any directory-links. */

				strcpy(dest, name);

				char *destpos = strrchr(dest, PATHSEPCHAR);

				if (destpos == NULL) destpos = dest;

				*destpos = '\0';

				char *pos = link;

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

					char *next = strchr(link, PATHSEPCHAR);

					if (next == NULL) next = pos + strlen(pos);

					/* Skip '.' (current dir) */

					if (next != pos + 1 || pos[0] != '.') {

						if (next == pos + 2 && pos[0] == '.' && pos[1] == '.') {

							/* level up */

							if (dest[0] == '\0') {

								DEBUG(misc, 1, "Ignoring link pointing outside of data directory: %s -> %s", name, link);

								break;

							}

							/* Truncate 'dest' after last PATHSEPCHAR.

							 * This assumes, that the truncated part is a real directory and not a link */

							destpos = strrchr(dest, PATHSEPCHAR);

							if (destpos == NULL) destpos = dest;

						} else {

							/* Append at end of 'dest' */

							if (destpos != dest) *(destpos++) = PATHSEPCHAR;

							strncpy(destpos, pos, next - pos); // Safe as we do '\0'-termination ourselves

							destpos += next - pos;

						}

						*destpos = '\0';

					}

					pos = next;

				}

				/* Store links in temporary list */

				DEBUG(misc, 6, "Found link in tar: %s -> %s", name, dest);

				links.insert(TarLinkList::value_type(name, dest));

				break;

			}

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

				if (_tar_list[filename].dirname == NULL) _tar_list[filename].dirname = strdup(name);

				break;

			default:

				/* Ignore other types */

				break;

		}

		/* Skip to the next block.. */

		skip = Align(skip, 512);

		fseek(f, skip, SEEK_CUR);

		pos += skip;

	}

	DEBUG(misc, 1, "Found tar '%s' with %d new files", filename, num);

	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.

	 *      When resolving files at most one directory link is resolved.

	 *  2) Links to files:

	 *      The destination path must NOT contain any links.

	 *      The source path may contain one directory link.

	 */

	for (TarLinkList::iterator link = links.begin(); link != links.end(); link++) {

		const std::string &src = link->first;

		const std::string &dest = link->second;

		TarAddLink(src, dest);

	}

	return true;

}

static int ScanPathForTarFiles(const char *path, size_t basepath_length)

{

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

	uint num = 0;

	struct stat sb;

	struct dirent *dirent;

	DIR *dir;

	if (path == NULL || (dir = ttd_opendir(path)) == NULL) return 0;

	while ((dirent = readdir(dir)) != NULL) {

		const char *d_name = FS2OTTD(dirent->d_name);

		char filename[MAX_PATH];

		if (!FiosIsValidFile(path, dirent, &sb)) continue;

		snprintf(filename, lengthof(filename), "%s%s", path, d_name);

		if (S_ISDIR(sb.st_mode)) {

			/* Directory */

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

			AppendPathSeparator(filename, lengthof(filename));

			num += ScanPathForTarFiles(filename, basepath_length);

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

			/* File */

			char *ext = strrchr(filename, '.');

			/* If no extension or extension isn't .tar, skip the file */

			if (ext == NULL) continue;

			if (strcasecmp(ext, ".tar") != 0) continue;

			if (TarListAddFile(filename)) num++;

		}

	}

	closedir(dir);

	return num;

}

void ScanForTarFiles()

{

	Searchpath sp;

	char path[MAX_PATH];

	uint num = 0;

	DEBUG(misc, 1, "Scanning for tars");

	FOR_ALL_SEARCHPATHS(sp) {

		FioAppendDirectory(path, MAX_PATH, sp, DATA_DIR);

		num += ScanPathForTarFiles(path, strlen(path));

		FioAppendDirectory(path, MAX_PATH, sp, AI_DIR);

		num += ScanPathForTarFiles(path, strlen(path));

		FioAppendDirectory(path, MAX_PATH, sp, AI_LIBRARY_DIR);

		num += ScanPathForTarFiles(path, strlen(path));

		FioAppendDirectory(path, MAX_PATH, sp, SCENARIO_DIR);

		num += ScanPathForTarFiles(path, strlen(path));

	}

	DEBUG(misc, 1, "Scan complete, found %d files", num);

}

#if defined(WIN32) || defined(WINCE)

/**

 * Determine the base (personal dir and game data dir) paths

 * @param exe the path from the current path to the executable

 * @note defined in the OS related files (os2.cpp, win32.cpp, unix.cpp etc)

 */

extern void DetermineBasePaths(const char *exe);

#else /* defined(WIN32) || defined(WINCE) */

/**

 * Changes the working directory to the path of the give executable.

 * For OSX application bundles '.app' is the required extension of the bundle,

 * so when we crop the path to there, when can remove the name of the bundle

 * in the same way we remove the name from the executable name.

 * @param exe the path to the executable

 */

void ChangeWorkingDirectory(const char *exe)

{

#ifdef WITH_COCOA

	char *app_bundle = strchr(exe, '.');

	while (app_bundle != NULL && strncasecmp(app_bundle, ".app", 4) != 0) app_bundle = strchr(&app_bundle[1], '.');

	if (app_bundle != NULL) app_bundle[0] = '\0';

#endif /* WITH_COCOA */

	char *s = strrchr(exe, PATHSEPCHAR);

	if (s != NULL) {

		*s = '\0';

#if defined(__DJGPP__)

		/* If we want to go to the root, we can't use cd C:, but we must use '/' */

		if (s[-1] == ':') chdir("/");

#endif

		if (chdir(exe) != 0) DEBUG(misc, 0, "Directory with the binary does not exist?");

		*s = PATHSEPCHAR;

	}

#ifdef WITH_COCOA

	if (app_bundle != NULL) app_bundle[0] = '.';

#endif /* WITH_COCOA */

}

/**

 * Determine the base (personal dir and game data dir) paths

 * @param exe the path to the executable

 */

void DetermineBasePaths(const char *exe)

{

	char tmp[MAX_PATH];

#if defined(__MORPHOS__) || defined(__AMIGA__) || defined(DOS) || !defined(WITH_PERSONAL_DIR)

	_searchpaths[SP_PERSONAL_DIR] = NULL;

#else

	const char *homedir = getenv("HOME");

	if (homedir == NULL) {

		const struct passwd *pw = getpwuid(getuid());

		homedir = (pw == NULL) ? "" : pw->pw_dir;

	}

	snprintf(tmp, MAX_PATH, "%s" PATHSEP "%s", homedir, PERSONAL_DIR);

	AppendPathSeparator(tmp, MAX_PATH);

	_searchpaths[SP_PERSONAL_DIR] = strdup(tmp);

#endif

#if defined(WITH_SHARED_DIR)

	snprintf(tmp, MAX_PATH, "%s", SHARED_DIR);

	AppendPathSeparator(tmp, MAX_PATH);

	_searchpaths[SP_SHARED_DIR] = strdup(tmp);

#else

	_searchpaths[SP_SHARED_DIR] = NULL;

#endif

#if defined(__MORPHOS__) || defined(__AMIGA__)

	_searchpaths[SP_WORKING_DIR] = NULL;

#else

	if (getcwd(tmp, MAX_PATH) == NULL) *tmp = '\0';

	AppendPathSeparator(tmp, MAX_PATH);

	_searchpaths[SP_WORKING_DIR] = strdup(tmp);

#endif

	/* Change the working directory to that one of the executable */

	ChangeWorkingDirectory((char*)exe);

	if (getcwd(tmp, MAX_PATH) == NULL) *tmp = '\0';

	AppendPathSeparator(tmp, MAX_PATH);

	_searchpaths[SP_BINARY_DIR] = strdup(tmp);

#if defined(__MORPHOS__) || defined(__AMIGA__) || defined(DOS)

	_searchpaths[SP_INSTALLATION_DIR] = NULL;

#else

	snprintf(tmp, MAX_PATH, "%s", GLOBAL_DATA_DIR);

	AppendPathSeparator(tmp, MAX_PATH);

	_searchpaths[SP_INSTALLATION_DIR] = strdup(tmp);

#endif

#ifdef WITH_COCOA

extern void cocoaSetApplicationBundleDir();

	cocoaSetApplicationBundleDir();

#else

	_searchpaths[SP_APPLICATION_BUNDLE_DIR] = NULL;

#endif

}

#endif /* defined(WIN32) || defined(WINCE) */

char *_personal_dir;

/**

 * Acquire the base paths (personal dir and game data dir),

 * fill all other paths (save dir, autosave dir etc) and

 * make the save and scenario directories.

 * @param exe the path from the current path to the executable

 */

void DeterminePaths(const char *exe)

{

	DetermineBasePaths(exe);

	Searchpath sp;

	FOR_ALL_SEARCHPATHS(sp) DEBUG(misc, 4, "%s added as search path", _searchpaths[sp]);

	if (_config_file != NULL) {

		_personal_dir = strdup(_config_file);

		char *end = strrchr(_personal_dir , PATHSEPCHAR);

		if (end == NULL) {

			_personal_dir[0] = '\0';

		} else {

			end[1] = '\0';

		}

	} else {

		char personal_dir[MAX_PATH];

		FioFindFullPath(personal_dir, lengthof(personal_dir), BASE_DIR, "openttd.cfg");

		if (FileExists(personal_dir)) {

			char *end = strrchr(personal_dir, PATHSEPCHAR);

			if (end != NULL) end[1] = '\0';

			_personal_dir = strdup(personal_dir);

			_config_file = str_fmt("%sopenttd.cfg", _personal_dir);

		} else {

			static const Searchpath new_openttd_cfg_order[] = {

					SP_PERSONAL_DIR, SP_BINARY_DIR, SP_WORKING_DIR, SP_SHARED_DIR, SP_INSTALLATION_DIR

				};

			for (uint i = 0; i < lengthof(new_openttd_cfg_order); i++) {

				if (IsValidSearchPath(new_openttd_cfg_order[i])) {

					_personal_dir = strdup(_searchpaths[new_openttd_cfg_order[i]]);

					_config_file = str_fmt("%sopenttd.cfg", _personal_dir);

					break;

				}

			}

		}

	}

	DEBUG(misc, 3, "%s found as personal directory", _personal_dir);

	_highscore_file = str_fmt("%shs.dat", _personal_dir);

	_log_file = str_fmt("%sopenttd.log",  _personal_dir);