Core: Removed unused directory_file_system and meta_file_system modules.

Core: Updated CMakeLists.txt to remove directory_file_system and meta_file_system modules.

src/core/CMakeLists.txt

@@ -29,8 +29,6 @@ set(SRCS    core.cpp
             arm/interpreter/mmu/tlb.cpp
             arm/interpreter/mmu/wb.cpp
             arm/interpreter/mmu/xscale_copro.cpp
-            file_sys/directory_file_system.cpp
-            file_sys/meta_file_system.cpp
             hle/hle.cpp
             hle/config_mem.cpp
             hle/coprocessor.cpp
@@ -75,9 +73,7 @@ set(HEADERS core.h
             arm/interpreter/vfp/asm_vfp.h
             arm/interpreter/vfp/vfp.h
             arm/interpreter/vfp/vfp_helper.h
-            file_sys/directory_file_system.h
             file_sys/file_sys.h
-            file_sys/meta_file_system.h
             hle/config_mem.h
             hle/coprocessor.h
             hle/hle.h

src/core/core.vcxproj

@@ -162,8 +162,6 @@
     <ClCompile Include="arm\interpreter\vfp\vfpsingle.cpp" />
     <ClCompile Include="core.cpp" />
     <ClCompile Include="core_timing.cpp" />
-    <ClCompile Include="file_sys\directory_file_system.cpp" />
-    <ClCompile Include="file_sys\meta_file_system.cpp" />
     <ClCompile Include="hle\config_mem.cpp" />
     <ClCompile Include="hle\coprocessor.cpp" />
     <ClCompile Include="hle\hle.cpp" />
@@ -211,9 +209,7 @@
     <ClInclude Include="arm\interpreter\vfp\vfp_helper.h" />
     <ClInclude Include="core.h" />
     <ClInclude Include="core_timing.h" />
-    <ClInclude Include="file_sys\directory_file_system.h" />
     <ClInclude Include="file_sys\file_sys.h" />
-    <ClInclude Include="file_sys\meta_file_system.h" />
     <ClInclude Include="hle\config_mem.h" />
     <ClInclude Include="hle\coprocessor.h" />
     <ClInclude Include="hle\function_wrappers.h" />

src/core/core.vcxproj.filters

@@ -63,12 +63,6 @@
     <ClCompile Include="arm\interpreter\thumbemu.cpp">
       <Filter>arm\interpreter</Filter>
     </ClCompile>
-    <ClCompile Include="file_sys\directory_file_system.cpp">
-      <Filter>file_sys</Filter>
-    </ClCompile>
-    <ClCompile Include="file_sys\meta_file_system.cpp">
-      <Filter>file_sys</Filter>
-    </ClCompile>
     <ClCompile Include="hw\hw.cpp">
       <Filter>hw</Filter>
     </ClCompile>
@@ -205,15 +199,9 @@
     <ClInclude Include="arm\interpreter\skyeye_defs.h">
       <Filter>arm\interpreter</Filter>
     </ClInclude>
-    <ClInclude Include="file_sys\directory_file_system.h">
-      <Filter>file_sys</Filter>
-    </ClInclude>
     <ClInclude Include="file_sys\file_sys.h">
       <Filter>file_sys</Filter>
     </ClInclude>
-    <ClInclude Include="file_sys\meta_file_system.h">
-      <Filter>file_sys</Filter>
-    </ClInclude>
     <ClInclude Include="hw\hw.h">
       <Filter>hw</Filter>
     </ClInclude>

src/core/file_sys/directory_file_system.cpp

@@ -1,669 +0,0 @@
-// Copyright (c) 2012- PPSSPP Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0 or later versions.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official git repository and contact information can be found at
-// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
-
-#include "common/chunk_file.h"
-#include "common/file_util.h"
-#include "common/utf8.h"
-
-#include "core/file_sys/directory_file_system.h"
-
-#if EMU_PLATFORM == PLATFORM_WINDOWS
-#include <windows.h>
-#include <sys/stat.h>
-#else
-#include <dirent.h>
-#include <unistd.h>
-#include <sys/stat.h>
-#include <ctype.h>
-#endif
-
-#if HOST_IS_CASE_SENSITIVE
-static bool FixFilenameCase(const std::string &path, std::string &filename)
-{
-	// Are we lucky?
-	if (File::Exists(path + filename))
-		return true;
-
-	size_t filenameSize = filename.size();  // size in bytes, not characters
-	for (size_t i = 0; i < filenameSize; i++)
-	{
-		filename[i] = tolower(filename[i]);
-	}
-
-	//TODO: lookup filename in cache for "path"
-
-	struct dirent_large { struct dirent entry; char padding[FILENAME_MAX+1]; } diren;
-	struct dirent_large;
-	struct dirent *result = NULL;
-
-	DIR *dirp = opendir(path.c_str());
-	if (!dirp)
-		return false;
-
-	bool retValue = false;
-
-	while (!readdir_r(dirp, (dirent*) &diren, &result) && result)
-	{
-		if (strlen(result->d_name) != filenameSize)
-			continue;
-
-		size_t i;
-		for (i = 0; i < filenameSize; i++)
-		{
-			if (filename[i] != tolower(result->d_name[i]))
-				break;
-		}
-
-		if (i < filenameSize)
-			continue;
-
-		filename = result->d_name;
-		retValue = true;
-	}
-
-	closedir(dirp);
-
-	return retValue;
-}
-
-bool FixPathCase(std::string& basePath, std::string &path, FixPathCaseBehavior behavior)
-{
-	size_t len = path.size();
-
-	if (len == 0)
-		return true;
-
-	if (path[len - 1] == '/')
-	{
-		len--;
-
-		if (len == 0)
-			return true;
-	}
-
-	std::string fullPath;
-	fullPath.reserve(basePath.size() + len + 1);
-	fullPath.append(basePath); 
-
-	size_t start = 0;
-	while (start < len)
-	{
-		size_t i = path.find('/', start);
-		if (i == std::string::npos)
-			i = len;
-
-		if (i > start)
-		{
-			std::string component = path.substr(start, i - start);
-
-			// Fix case and stop on nonexistant path component
-			if (FixFilenameCase(fullPath, component) == false) {
-				// Still counts as success if partial matches allowed or if this
-				// is the last component and only the ones before it are required
-				return (behavior == FPC_PARTIAL_ALLOWED || (behavior == FPC_PATH_MUST_EXIST && i >= len));
-			}
-
-			path.replace(start, i - start, component);
-
-			fullPath.append(component);
-			fullPath.append(1, '/');
-		}
-
-		start = i + 1;
-	}
-
-	return true;
-}
-
-#endif
-
-std::string DirectoryFileHandle::GetLocalPath(std::string& basePath, std::string localpath)
-{
-	if (localpath.empty())
-		return basePath;
-
-	if (localpath[0] == '/')
-		localpath.erase(0,1);
-	//Convert slashes
-#ifdef _WIN32
-	for (size_t i = 0; i < localpath.size(); i++) {
-		if (localpath[i] == '/')
-			localpath[i] = '\\';
-	}
-#endif
-	return basePath + localpath;
-}
-
-bool DirectoryFileHandle::Open(std::string& basePath, std::string& fileName, FileAccess access)
-{
-#if HOST_IS_CASE_SENSITIVE
-	if (access & (FILEACCESS_APPEND|FILEACCESS_CREATE|FILEACCESS_WRITE))
-	{
-		DEBUG_LOG(FILESYS, "Checking case for path %s", fileName.c_str());
-		if ( ! FixPathCase(basePath, fileName, FPC_PATH_MUST_EXIST) )
-			return false;  // or go on and attempt (for a better error code than just 0?)
-	}
-	// else we try fopen first (in case we're lucky) before simulating case insensitivity
-#endif
-
-	std::string fullName = GetLocalPath(basePath,fileName);
-	INFO_LOG(FILESYS,"Actually opening %s", fullName.c_str());
-
-	//TODO: tests, should append seek to end of file? seeking in a file opened for append?
-#ifdef _WIN32
-	// Convert parameters to Windows permissions and access
-	DWORD desired = 0;
-	DWORD sharemode = 0;
-	DWORD openmode = 0;
-	if (access & FILEACCESS_READ) {
-		desired   |= GENERIC_READ;
-		sharemode |= FILE_SHARE_READ;
-	}
-	if (access & FILEACCESS_WRITE) {
-		desired   |= GENERIC_WRITE;
-		sharemode |= FILE_SHARE_WRITE;
-	}
-	if (access & FILEACCESS_CREATE) {
-		openmode = OPEN_ALWAYS;
-	} else {
-		openmode = OPEN_EXISTING;
-	}
-	//Let's do it!
-	hFile = CreateFile(ConvertUTF8ToWString(fullName).c_str(), desired, sharemode, 0, openmode, 0, 0);
-	bool success = hFile != INVALID_HANDLE_VALUE;
-#else
-	// Convert flags in access parameter to fopen access mode
-	const char *mode = NULL;
-	if (access & FILEACCESS_APPEND) {
-		if (access & FILEACCESS_READ)
-			mode = "ab+";  // append+read, create if needed
-		else
-			mode = "ab";  // append only, create if needed
-	} else if (access & FILEACCESS_WRITE) {
-		if (access & FILEACCESS_READ) {
-			// FILEACCESS_CREATE is ignored for read only, write only, and append
-			// because C++ standard fopen's nonexistant file creation can only be
-			// customized for files opened read+write
-			if (access & FILEACCESS_CREATE)
-				mode = "wb+";  // read+write, create if needed
-			else
-				mode = "rb+";  // read+write, but don't create
-		} else {
-			mode = "wb";  // write only, create if needed
-		}
-	} else {  // neither write nor append, so default to read only
-		mode = "rb";  // read only, don't create
-	}
-
-	hFile = fopen(fullName.c_str(), mode);
-	bool success = hFile != 0;
-#endif
-
-#if HOST_IS_CASE_SENSITIVE
-	if (!success &&
-	    !(access & FILEACCESS_APPEND) &&
-	    !(access & FILEACCESS_CREATE) &&
-	    !(access & FILEACCESS_WRITE))
-	{
-		if ( ! FixPathCase(basePath,fileName, FPC_PATH_MUST_EXIST) )
-			return 0;  // or go on and attempt (for a better error code than just 0?)
-		fullName = GetLocalPath(basePath,fileName); 
-		const char* fullNameC = fullName.c_str();
-
-		DEBUG_LOG(FILESYS, "Case may have been incorrect, second try opening %s (%s)", fullNameC, fileName.c_str());
-
-		// And try again with the correct case this time
-#ifdef _WIN32
-		hFile = CreateFile(fullNameC, desired, sharemode, 0, openmode, 0, 0);
-		success = hFile != INVALID_HANDLE_VALUE;
-#else
-		hFile = fopen(fullNameC, mode);
-		success = hFile != 0;
-#endif
-	}
-#endif
-
-	return success;
-}
-
-size_t DirectoryFileHandle::Read(u8* pointer, s64 size)
-{
-	size_t bytesRead = 0;
-#ifdef _WIN32
-	::ReadFile(hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesRead, 0);
-#else
-	bytesRead = fread(pointer, 1, size, hFile);
-#endif
-	return bytesRead;
-}
-
-size_t DirectoryFileHandle::Write(const u8* pointer, s64 size)
-{
-	size_t bytesWritten = 0;
-#ifdef _WIN32
-	::WriteFile(hFile, (LPVOID)pointer, (DWORD)size, (LPDWORD)&bytesWritten, 0);
-#else
-	bytesWritten = fwrite(pointer, 1, size, hFile);
-#endif
-	return bytesWritten;
-}
-
-size_t DirectoryFileHandle::Seek(s32 position, FileMove type)
-{
-#ifdef _WIN32
-	DWORD moveMethod = 0;
-	switch (type) {
-	case FILEMOVE_BEGIN:    moveMethod = FILE_BEGIN;    break;
-	case FILEMOVE_CURRENT:  moveMethod = FILE_CURRENT;  break;
-	case FILEMOVE_END:      moveMethod = FILE_END;      break;
-	}
-	DWORD newPos = SetFilePointer(hFile, (LONG)position, 0, moveMethod);
-	return newPos;
-#else
-	int moveMethod = 0;
-	switch (type) {
-	case FILEMOVE_BEGIN:    moveMethod = SEEK_SET;  break;
-	case FILEMOVE_CURRENT:  moveMethod = SEEK_CUR;  break;
-	case FILEMOVE_END:      moveMethod = SEEK_END;  break;
-	}
-	fseek(hFile, position, moveMethod);
-	return ftell(hFile);
-#endif
-}
-
-void DirectoryFileHandle::Close()
-{
-#ifdef _WIN32
-	if (hFile != (HANDLE)-1)
-		CloseHandle(hFile);
-#else
-	if (hFile != 0)
-		fclose(hFile);
-#endif
-}
-
-DirectoryFileSystem::DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath) : basePath(_basePath) {
-	File::CreateFullPath(basePath);
-	hAlloc = _hAlloc;
-}
-
-DirectoryFileSystem::~DirectoryFileSystem() {
-	for (auto iter = entries.begin(); iter != entries.end(); ++iter) {
-		iter->second.hFile.Close();
-	}
-}
-
-std::string DirectoryFileSystem::GetLocalPath(std::string localpath) {
-	if (localpath.empty())
-		return basePath;
-
-	if (localpath[0] == '/')
-		localpath.erase(0,1);
-	//Convert slashes
-#ifdef _WIN32
-	for (size_t i = 0; i < localpath.size(); i++) {
-		if (localpath[i] == '/')
-			localpath[i] = '\\';
-	}
-#endif
-	return basePath + localpath;
-}
-
-bool DirectoryFileSystem::MkDir(const std::string &dirname) {
-#if HOST_IS_CASE_SENSITIVE
-	// Must fix case BEFORE attempting, because MkDir would create
-	// duplicate (different case) directories
-
-	std::string fixedCase = dirname;
-	if ( ! FixPathCase(basePath,fixedCase, FPC_PARTIAL_ALLOWED) )
-		return false;
-
-	return File::CreateFullPath(GetLocalPath(fixedCase));
-#else
-	return File::CreateFullPath(GetLocalPath(dirname));
-#endif
-}
-
-bool DirectoryFileSystem::RmDir(const std::string &dirname) {
-	std::string fullName = GetLocalPath(dirname);
-
-#if HOST_IS_CASE_SENSITIVE
-	// Maybe we're lucky?
-	if (File::DeleteDirRecursively(fullName))
-		return true;
-
-	// Nope, fix case and try again
-	fullName = dirname;
-	if ( ! FixPathCase(basePath,fullName, FPC_FILE_MUST_EXIST) )
-		return false;  // or go on and attempt (for a better error code than just false?)
-
-	fullName = GetLocalPath(fullName);
-#endif
-
-/*#ifdef _WIN32
-	return RemoveDirectory(fullName.c_str()) == TRUE;
-#else
-	return 0 == rmdir(fullName.c_str());
-#endif*/
-	return File::DeleteDirRecursively(fullName);
-}
-
-int DirectoryFileSystem::RenameFile(const std::string &from, const std::string &to) {
-	std::string fullTo = to;
-
-	// Rename ignores the path (even if specified) on to.
-	size_t chop_at = to.find_last_of('/');
-	if (chop_at != to.npos)
-		fullTo = to.substr(chop_at + 1);
-
-	// Now put it in the same directory as from.
-	size_t dirname_end = from.find_last_of('/');
-	if (dirname_end != from.npos)
-		fullTo = from.substr(0, dirname_end + 1) + fullTo;
-
-	// At this point, we should check if the paths match and give an already exists error.
-	if (from == fullTo)
-		return -1;//SCE_KERNEL_ERROR_ERRNO_FILE_ALREADY_EXISTS;
-
-	std::string fullFrom = GetLocalPath(from);
-
-#if HOST_IS_CASE_SENSITIVE
-	// In case TO should overwrite a file with different case
-	if ( ! FixPathCase(basePath,fullTo, FPC_PATH_MUST_EXIST) )
-		return -1;  // or go on and attempt (for a better error code than just false?)
-#endif
-
-	fullTo = GetLocalPath(fullTo);
-	const char * fullToC = fullTo.c_str();
-
-#ifdef _WIN32
-	bool retValue = (MoveFile(ConvertUTF8ToWString(fullFrom).c_str(), ConvertUTF8ToWString(fullToC).c_str()) == TRUE);
-#else
-	bool retValue = (0 == rename(fullFrom.c_str(), fullToC));
-#endif
-
-#if HOST_IS_CASE_SENSITIVE
-	if (! retValue)
-	{
-		// May have failed due to case sensitivity on FROM, so try again
-		fullFrom = from;
-		if ( ! FixPathCase(basePath,fullFrom, FPC_FILE_MUST_EXIST) )
-			return -1;  // or go on and attempt (for a better error code than just false?)
-		fullFrom = GetLocalPath(fullFrom);
-
-#ifdef _WIN32
-		retValue = (MoveFile(fullFrom.c_str(), fullToC) == TRUE);
-#else
-		retValue = (0 == rename(fullFrom.c_str(), fullToC));
-#endif
-	}
-#endif
-
-	// TODO: Better error codes.
-	return retValue ? 0 : -1;//SCE_KERNEL_ERROR_ERRNO_FILE_ALREADY_EXISTS;
-}
-
-bool DirectoryFileSystem::RemoveFile(const std::string &filename) {
-	std::string fullName = GetLocalPath(filename);
-#ifdef _WIN32
-	bool retValue = (::DeleteFileA(fullName.c_str()) == TRUE);
-#else
-	bool retValue = (0 == unlink(fullName.c_str()));
-#endif
-
-#if HOST_IS_CASE_SENSITIVE
-	if (! retValue)
-	{
-		// May have failed due to case sensitivity, so try again
-		fullName = filename;
-		if ( ! FixPathCase(basePath,fullName, FPC_FILE_MUST_EXIST) )
-			return false;  // or go on and attempt (for a better error code than just false?)
-		fullName = GetLocalPath(fullName);
-
-#ifdef _WIN32
-		retValue = (::DeleteFileA(fullName.c_str()) == TRUE);
-#else
-		retValue = (0 == unlink(fullName.c_str()));
-#endif
-	}
-#endif
-
-	return retValue;
-}
-
-u32 DirectoryFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename) {
-	OpenFileEntry entry;
-	bool success = entry.hFile.Open(basePath,filename,access);
-
-	if (!success) {
-#ifdef _WIN32
-		ERROR_LOG(FILESYS, "DirectoryFileSystem::OpenFile: FAILED, %i - access = %i", GetLastError(), (int)access);
-#else
-		ERROR_LOG(FILESYS, "DirectoryFileSystem::OpenFile: FAILED, access = %i", (int)access);
-#endif
-		//wwwwaaaaahh!!
-		return 0;
-	} else {
-#ifdef _WIN32
-		if (access & FILEACCESS_APPEND)
-			entry.hFile.Seek(0,FILEMOVE_END);
-#endif
-
-		u32 newHandle = hAlloc->GetNewHandle();
-		entries[newHandle] = entry;
-
-		return newHandle;
-	}
-}
-
-void DirectoryFileSystem::CloseFile(u32 handle) {
-	EntryMap::iterator iter = entries.find(handle);
-	if (iter != entries.end()) {
-		hAlloc->FreeHandle(handle);
-		iter->second.hFile.Close();
-		entries.erase(iter);
-	} else {
-		//This shouldn't happen...
-		ERROR_LOG(FILESYS,"Cannot close file that hasn't been opened: %08x", handle);
-	}
-}
-
-bool DirectoryFileSystem::OwnsHandle(u32 handle) {
-	EntryMap::iterator iter = entries.find(handle);
-	return (iter != entries.end());
-}
-
-size_t DirectoryFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size) {
-	EntryMap::iterator iter = entries.find(handle);
-	if (iter != entries.end())
-	{
-		size_t bytesRead = iter->second.hFile.Read(pointer,size);
-		return bytesRead;
-	} else {
-		//This shouldn't happen...
-		ERROR_LOG(FILESYS,"Cannot read file that hasn't been opened: %08x", handle);
-		return 0;
-	}
-}
-
-size_t DirectoryFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size) {
-	EntryMap::iterator iter = entries.find(handle);
-	if (iter != entries.end())
-	{
-		size_t bytesWritten = iter->second.hFile.Write(pointer,size);
-		return bytesWritten;
-	} else {
-		//This shouldn't happen...
-		ERROR_LOG(FILESYS,"Cannot write to file that hasn't been opened: %08x", handle);
-		return 0;
-	}
-}
-
-size_t DirectoryFileSystem::SeekFile(u32 handle, s32 position, FileMove type) {
-	EntryMap::iterator iter = entries.find(handle);
-	if (iter != entries.end()) {
-		return iter->second.hFile.Seek(position,type);
-	} else {
-		//This shouldn't happen...
-		ERROR_LOG(FILESYS,"Cannot seek in file that hasn't been opened: %08x", handle);
-		return 0;
-	}
-}
-
-FileInfo DirectoryFileSystem::GetFileInfo(std::string filename) {
-	FileInfo x;
-	x.name = filename;
-
-	std::string fullName = GetLocalPath(filename);
-	if (! File::Exists(fullName)) {
-#if HOST_IS_CASE_SENSITIVE
-		if (! FixPathCase(basePath,filename, FPC_FILE_MUST_EXIST))
-			return x;
-		fullName = GetLocalPath(filename);
-
-		if (! File::Exists(fullName))
-			return x;
-#else
-		return x;
-#endif
-	}
-	x.type = File::IsDirectory(fullName) ? FILETYPE_DIRECTORY : FILETYPE_NORMAL;
-	x.exists = true;
-
-	if (x.type != FILETYPE_DIRECTORY)
-	{
-#ifdef _WIN32
-		struct _stat64i32 s;
-		_wstat64i32(ConvertUTF8ToWString(fullName).c_str(), &s);
-#else
-		struct stat s;
-		stat(fullName.c_str(), &s);
-#endif
-
-		x.size = File::GetSize(fullName);
-		x.access = s.st_mode & 0x1FF;
-		localtime_r((time_t*)&s.st_atime,&x.atime);
-		localtime_r((time_t*)&s.st_ctime,&x.ctime);
-		localtime_r((time_t*)&s.st_mtime,&x.mtime);
-	}
-
-	return x;
-}
-
-bool DirectoryFileSystem::GetHostPath(const std::string &inpath, std::string &outpath) {
-	outpath = GetLocalPath(inpath);
-	return true;
-}
-
-#ifdef _WIN32
-#define FILETIME_FROM_UNIX_EPOCH_US 11644473600000000ULL
-
-static void tmFromFiletime(tm &dest, FILETIME &src)
-{
-	u64 from_1601_us = (((u64) src.dwHighDateTime << 32ULL) + (u64) src.dwLowDateTime) / 10ULL;
-	u64 from_1970_us = from_1601_us - FILETIME_FROM_UNIX_EPOCH_US;
-
-	time_t t = (time_t) (from_1970_us / 1000000UL);
-	localtime_r(&t, &dest);
-}
-#endif
-
-std::vector<FileInfo> DirectoryFileSystem::GetDirListing(std::string path) {
-	std::vector<FileInfo> myVector;
-#ifdef _WIN32
-	WIN32_FIND_DATA findData;
-	HANDLE hFind;
-
-	std::string w32path = GetLocalPath(path) + "\\*.*";
-
-	hFind = FindFirstFile(ConvertUTF8ToWString(w32path).c_str(), &findData);
-
-	if (hFind == INVALID_HANDLE_VALUE) {
-		return myVector; //the empty list
-	}
-
-	while (true) {
-		FileInfo entry;
-		if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-			entry.type = FILETYPE_DIRECTORY;
-		else
-			entry.type = FILETYPE_NORMAL;
-
-		// TODO: Make this more correct?
-		entry.access = entry.type == FILETYPE_NORMAL ? 0666 : 0777;
-		// TODO: is this just for .. or all subdirectories? Need to add a directory to the test
-		// to find out. Also why so different than the old test results?
-		if (!wcscmp(findData.cFileName, L"..") )
-			entry.size = 4096;
-		else
-			entry.size = findData.nFileSizeLow | ((u64)findData.nFileSizeHigh<<32);
-		entry.name = ConvertWStringToUTF8(findData.cFileName);
-		tmFromFiletime(entry.atime, findData.ftLastAccessTime);
-		tmFromFiletime(entry.ctime, findData.ftCreationTime);
-		tmFromFiletime(entry.mtime, findData.ftLastWriteTime);
-		myVector.push_back(entry);
-
-		int retval = FindNextFile(hFind, &findData);
-		if (!retval)
-			break;
-	}
-#else
-	dirent *dirp;
-	std::string localPath = GetLocalPath(path);
-	DIR *dp = opendir(localPath.c_str());
-
-#if HOST_IS_CASE_SENSITIVE
-	if(dp == NULL && FixPathCase(basePath,path, FPC_FILE_MUST_EXIST)) {
-		// May have failed due to case sensitivity, try again
-		localPath = GetLocalPath(path);
-		dp = opendir(localPath.c_str());
-	}
-#endif
-
-	if (dp == NULL) {
-		ERROR_LOG(FILESYS,"Error opening directory %s\n",path.c_str());
-		return myVector;
-	}
-
-	while ((dirp = readdir(dp)) != NULL) {
-		FileInfo entry;
-		struct stat s;
-		std::string fullName = GetLocalPath(path) + "/"+dirp->d_name;
-		stat(fullName.c_str(), &s);
-		if (S_ISDIR(s.st_mode))
-			entry.type = FILETYPE_DIRECTORY;
-		else
-			entry.type = FILETYPE_NORMAL;
-		entry.access = s.st_mode & 0x1FF;
-		entry.name = dirp->d_name;
-		entry.size = s.st_size;
-		localtime_r((time_t*)&s.st_atime,&entry.atime);
-		localtime_r((time_t*)&s.st_ctime,&entry.ctime);
-		localtime_r((time_t*)&s.st_mtime,&entry.mtime);
-		myVector.push_back(entry);
-	}
-	closedir(dp);
-#endif
-	return myVector;
-}
-
-void DirectoryFileSystem::DoState(PointerWrap &p) {
-	if (!entries.empty()) {
-		p.SetError(p.ERROR_WARNING);
-		ERROR_LOG(FILESYS, "FIXME: Open files during savestate, could go badly.");
-	}
-}

src/core/file_sys/directory_file_system.h

@@ -1,155 +0,0 @@
-// Copyright (c) 2012- PPSSPP Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0 or later versions.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official git repository and contact information can be found at
-// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
-
-#pragma once
-
-// TODO: Remove the Windows-specific code, FILE is fine there too.
-
-#include <map>
-
-#include "core/file_sys/file_sys.h"
-
-#ifdef _WIN32
-typedef void * HANDLE;
-#endif
-
-#if defined(__APPLE__)
-
-#if TARGET_OS_IPHONE
-#define HOST_IS_CASE_SENSITIVE 1
-#elif TARGET_IPHONE_SIMULATOR
-#define HOST_IS_CASE_SENSITIVE 0
-#else
-// Mac OSX case sensitivity defaults off, but is user configurable (when
-// creating a filesytem), so assume the worst:
-#define HOST_IS_CASE_SENSITIVE 1
-#endif
-
-#elif defined(_WIN32) || defined(__SYMBIAN32__)
-#define HOST_IS_CASE_SENSITIVE 0
-
-#else  // Android, Linux, BSD (and the rest?)
-#define HOST_IS_CASE_SENSITIVE 1
-
-#endif
-
-#if HOST_IS_CASE_SENSITIVE
-enum FixPathCaseBehavior {
-	FPC_FILE_MUST_EXIST,  // all path components must exist (rmdir, move from)
-	FPC_PATH_MUST_EXIST,  // all except the last one must exist - still tries to fix last one (fopen, move to)
-	FPC_PARTIAL_ALLOWED,  // don't care how many exist (mkdir recursive)
-};
-
-bool FixPathCase(std::string& basePath, std::string &path, FixPathCaseBehavior behavior);
-#endif
-
-struct DirectoryFileHandle
-{
-#ifdef _WIN32
-	HANDLE hFile;
-#else
-	FILE* hFile;
-#endif
-	DirectoryFileHandle()
-	{
-#ifdef _WIN32
-		hFile = (HANDLE)-1;
-#else
-		hFile = 0;
-#endif
-	}
-
-	std::string GetLocalPath(std::string& basePath, std::string localpath);
-	bool Open(std::string& basePath, std::string& fileName, FileAccess access);
-	size_t Read(u8* pointer, s64 size);
-	size_t Write(const u8* pointer, s64 size);
-	size_t Seek(s32 position, FileMove type);
-	void Close();
-};
-
-class DirectoryFileSystem : public IFileSystem {
-public:
-	DirectoryFileSystem(IHandleAllocator *_hAlloc, std::string _basePath);
-	~DirectoryFileSystem();
-
-	void DoState(PointerWrap &p);
-	std::vector<FileInfo> GetDirListing(std::string path);
-	u32      OpenFile(std::string filename, FileAccess access, const char *devicename=NULL);
-	void     CloseFile(u32 handle);
-	size_t   ReadFile(u32 handle, u8 *pointer, s64 size);
-	size_t   WriteFile(u32 handle, const u8 *pointer, s64 size);
-	size_t   SeekFile(u32 handle, s32 position, FileMove type);
-	FileInfo GetFileInfo(std::string filename);
-	bool     OwnsHandle(u32 handle);
-
-	bool MkDir(const std::string &dirname);
-	bool RmDir(const std::string &dirname);
-	int  RenameFile(const std::string &from, const std::string &to);
-	bool RemoveFile(const std::string &filename);
-	bool GetHostPath(const std::string &inpath, std::string &outpath);
-
-private:
-	struct OpenFileEntry {
-		DirectoryFileHandle hFile;
-	};
-
-	typedef std::map<u32, OpenFileEntry> EntryMap;
-	EntryMap entries;
-	std::string basePath;
-	IHandleAllocator *hAlloc;
-
-	// In case of Windows: Translate slashes, etc.
-	std::string GetLocalPath(std::string localpath);
-};
-
-// VFSFileSystem: Ability to map in Android APK paths as well! Does not support all features, only meant for fonts.
-// Very inefficient - always load the whole file on open.
-class VFSFileSystem : public IFileSystem {
-public:
-	VFSFileSystem(IHandleAllocator *_hAlloc, std::string _basePath);
-	~VFSFileSystem();
-
-	void DoState(PointerWrap &p);
-	std::vector<FileInfo> GetDirListing(std::string path);
-	u32      OpenFile(std::string filename, FileAccess access, const char *devicename=NULL);
-	void     CloseFile(u32 handle);
-	size_t   ReadFile(u32 handle, u8 *pointer, s64 size);
-	size_t   WriteFile(u32 handle, const u8 *pointer, s64 size);
-	size_t   SeekFile(u32 handle, s32 position, FileMove type);
-	FileInfo GetFileInfo(std::string filename);
-	bool     OwnsHandle(u32 handle);
-
-	bool MkDir(const std::string &dirname);
-	bool RmDir(const std::string &dirname);
-	int  RenameFile(const std::string &from, const std::string &to);
-	bool RemoveFile(const std::string &filename);
-	bool GetHostPath(const std::string &inpath, std::string &outpath);
-
-private:
-	struct OpenFileEntry {
-		u8 *fileData;
-		size_t size;
-		size_t seekPos;
-	};
-
-	typedef std::map<u32, OpenFileEntry> EntryMap;
-	EntryMap entries;
-	std::string basePath;
-	IHandleAllocator *hAlloc;
-
-	std::string GetLocalPath(std::string localpath);
-};

src/core/file_sys/meta_file_system.cpp

@@ -1,519 +0,0 @@
-// Copyright (c) 2012- PPSSPP Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0 or later versions.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official git repository and contact information can be found at
-// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
-
-#include <set>
-#include <algorithm>
-
-#include "common/string_util.h"
-#include "core/file_sys/meta_file_system.h"
-
-static bool ApplyPathStringToComponentsVector(std::vector<std::string> &vector, const std::string &pathString)
-{
-	size_t len = pathString.length();
-	size_t start = 0;
-
-	while (start < len)
-	{
-		size_t i = pathString.find('/', start);
-		if (i == std::string::npos)
-			i = len;
-
-		if (i > start)
-		{
-			std::string component = pathString.substr(start, i - start);
-			if (component != ".")
-			{
-				if (component == "..")
-				{
-					if (vector.size() != 0)
-					{
-						vector.pop_back();
-					}
-					else
-					{
-						// The PSP silently ignores attempts to .. to parent of root directory
-						WARN_LOG(FILESYS, "RealPath: ignoring .. beyond root - root directory is its own parent: \"%s\"", pathString.c_str());
-					}
-				}
-				else
-				{
-					vector.push_back(component);
-				}
-			}
-		}
-
-		start = i + 1;
-	}
-
-	return true;
-}
-
-/*
- * Changes relative paths to absolute, removes ".", "..", and trailing "/"
- * "drive:./blah" is absolute (ignore the dot) and "/blah" is relative (because it's missing "drive:")
- * babel (and possibly other games) use "/directoryThatDoesNotExist/../directoryThatExists/filename"
- */
-static bool RealPath(const std::string &currentDirectory, const std::string &inPath, std::string &outPath)
-{
-	size_t inLen = inPath.length();
-	if (inLen == 0)
-	{
-		WARN_LOG(FILESYS, "RealPath: inPath is empty");
-		outPath = currentDirectory;
-		return true;
-	}
-
-	size_t inColon = inPath.find(':');
-	if (inColon + 1 == inLen)
-	{
-		// There's nothing after the colon, e.g. umd0: - this is perfectly valid.
-		outPath = inPath;
-		return true;
-	}
-
-	bool relative = (inColon == std::string::npos);
-	
-	std::string prefix, inAfterColon;
-	std::vector<std::string> cmpnts;  // path components
-	size_t outPathCapacityGuess = inPath.length();
-
-	if (relative)
-	{
-		size_t curDirLen = currentDirectory.length();
-		if (curDirLen == 0)
-		{
-			ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory is empty", inPath.c_str());
-			return false;
-		}
-		
-		size_t curDirColon = currentDirectory.find(':');
-		if (curDirColon == std::string::npos)
-		{
-			ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory \"%s\" has no prefix", inPath.c_str(), currentDirectory.c_str());
-			return false;
-		}
-		if (curDirColon + 1 == curDirLen)
-		{
-			ERROR_LOG(FILESYS, "RealPath: inPath \"%s\" is relative, but current directory \"%s\" is all prefix and no path. Using \"/\" as path for current directory.", inPath.c_str(), currentDirectory.c_str());
-		}
-		else
-		{
-			const std::string curDirAfter = currentDirectory.substr(curDirColon + 1);
-			if (! ApplyPathStringToComponentsVector(cmpnts, curDirAfter) )
-			{
-				ERROR_LOG(FILESYS,"RealPath: currentDirectory is not a valid path: \"%s\"", currentDirectory.c_str());
-				return false;
-			}
-
-			outPathCapacityGuess += curDirLen;
-		}
-
-		prefix = currentDirectory.substr(0, curDirColon + 1);
-		inAfterColon = inPath;
-	}
-	else
-	{
-		prefix = inPath.substr(0, inColon + 1);
-		inAfterColon = inPath.substr(inColon + 1);
-	}
-
-	// Special case: "disc0:" is different from "disc0:/", so keep track of the single slash.
-	if (inAfterColon == "/")
-	{
-		outPath = prefix + inAfterColon;
-		return true;
-	}
-
-	if (! ApplyPathStringToComponentsVector(cmpnts, inAfterColon) )
-	{
-		WARN_LOG(FILESYS, "RealPath: inPath is not a valid path: \"%s\"", inPath.c_str());
-		return false;
-	}
-
-	outPath.clear();
-	outPath.reserve(outPathCapacityGuess);
-
-	outPath.append(prefix);
-
-	size_t numCmpnts = cmpnts.size();
-	for (size_t i = 0; i < numCmpnts; i++)
-	{
-		outPath.append(1, '/');
-		outPath.append(cmpnts[i]);
-	}
-
-	return true;
-}
-
-IFileSystem *MetaFileSystem::GetHandleOwner(u32 handle)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	for (size_t i = 0; i < fileSystems.size(); i++)
-	{
-		if (fileSystems[i].system->OwnsHandle(handle))
-			return fileSystems[i].system; //got it!
-	}
-	//none found?
-	return 0;
-}
-
-bool MetaFileSystem::MapFilePath(const std::string &_inpath, std::string &outpath, MountPoint **system)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	std::string realpath;
-
-	// Special handling: host0:command.txt (as seen in Super Monkey Ball Adventures, for example)
-	// appears to mean the current directory on the UMD. Let's just assume the current directory.
-	std::string inpath = _inpath;
-	if (strncasecmp(inpath.c_str(), "host0:", strlen("host0:")) == 0) {
-		INFO_LOG(FILESYS, "Host0 path detected, stripping: %s", inpath.c_str());
-		inpath = inpath.substr(strlen("host0:"));
-	}
-
-	const std::string *currentDirectory = &startingDirectory;
-
-	_assert_msg_(FILESYS, false, "must implement equiv of __KernelGetCurThread");
-
-	int currentThread = 0;//__KernelGetCurThread();
-	currentDir_t::iterator it = currentDir.find(currentThread);
-	if (it == currentDir.end()) 
-	{
-		//Attempt to emulate SCE_KERNEL_ERROR_NOCWD / 8002032C: may break things requiring fixes elsewhere
-		if (inpath.find(':') == std::string::npos /* means path is relative */) 
-		{
-			lastOpenError = -1;//SCE_KERNEL_ERROR_NOCWD;
-			WARN_LOG(FILESYS, "Path is relative, but current directory not set for thread %i. returning 8002032C(SCE_KERNEL_ERROR_NOCWD) instead.", currentThread);
-		}
-	}
-	else
-	{
-		currentDirectory = &(it->second);
-	}
-
-	if ( RealPath(*currentDirectory, inpath, realpath) )
-	{
-		for (size_t i = 0; i < fileSystems.size(); i++)
-		{
-			size_t prefLen = fileSystems[i].prefix.size();
-			if (strncasecmp(fileSystems[i].prefix.c_str(), realpath.c_str(), prefLen) == 0)
-			{
-				outpath = realpath.substr(prefLen);
-				*system = &(fileSystems[i]);
-
-				INFO_LOG(FILESYS, "MapFilePath: mapped \"%s\" to prefix: \"%s\", path: \"%s\"", inpath.c_str(), fileSystems[i].prefix.c_str(), outpath.c_str());
-
-				return true;
-			}
-		}
-	}
-
-	DEBUG_LOG(FILESYS, "MapFilePath: failed mapping \"%s\", returning false", inpath.c_str());
-	return false;
-}
-
-void MetaFileSystem::Mount(std::string prefix, IFileSystem *system)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	MountPoint x;
-	x.prefix = prefix;
-	x.system = system;
-	fileSystems.push_back(x);
-}
-
-void MetaFileSystem::Unmount(std::string prefix, IFileSystem *system)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	MountPoint x;
-	x.prefix = prefix;
-	x.system = system;
-	fileSystems.erase(std::remove(fileSystems.begin(), fileSystems.end(), x), fileSystems.end());
-}
-
-void MetaFileSystem::Shutdown()
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	current = 6;
-
-	// Ownership is a bit convoluted. Let's just delete everything once.
-
-	std::set<IFileSystem *> toDelete;
-	for (size_t i = 0; i < fileSystems.size(); i++) {
-		toDelete.insert(fileSystems[i].system);
-	}
-
-	for (auto iter = toDelete.begin(); iter != toDelete.end(); ++iter)
-	{
-		delete *iter;
-	}
-
-	fileSystems.clear();
-	currentDir.clear();
-	startingDirectory = "";
-}
-
-u32 MetaFileSystem::OpenWithError(int &error, std::string filename, FileAccess access, const char *devicename)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	u32 h = OpenFile(filename, access, devicename);
-	error = lastOpenError;
-	return h;
-}
-
-u32 MetaFileSystem::OpenFile(std::string filename, FileAccess access, const char *devicename)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	lastOpenError = 0;
-	std::string of;
-	MountPoint *mount;
-	if (MapFilePath(filename, of, &mount))
-	{
-		return mount->system->OpenFile(of, access, mount->prefix.c_str());
-	}
-	else
-	{
-		return 0;
-	}
-}
-
-FileInfo MetaFileSystem::GetFileInfo(std::string filename)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	std::string of;
-	IFileSystem *system;
-	if (MapFilePath(filename, of, &system))
-	{
-		return system->GetFileInfo(of);
-	}
-	else
-	{
-		FileInfo bogus; // TODO
-		return bogus; 
-	}
-}
-
-bool MetaFileSystem::GetHostPath(const std::string &inpath, std::string &outpath)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	std::string of;
-	IFileSystem *system;
-	if (MapFilePath(inpath, of, &system)) {
-		return system->GetHostPath(of, outpath);
-	} else {
-		return false;
-	}
-}
-
-std::vector<FileInfo> MetaFileSystem::GetDirListing(std::string path)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	std::string of;
-	IFileSystem *system;
-	if (MapFilePath(path, of, &system))
-	{
-		return system->GetDirListing(of);
-	}
-	else
-	{
-		std::vector<FileInfo> empty;
-		return empty;
-	}
-}
-
-void MetaFileSystem::ThreadEnded(int threadID)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	currentDir.erase(threadID);
-}
-
-int MetaFileSystem::ChDir(const std::string &dir)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	// Retain the old path and fail if the arg is 1023 bytes or longer.
-	if (dir.size() >= 1023)
-		return -1;//SCE_KERNEL_ERROR_NAMETOOLONG;
-
-	_assert_msg_(FILESYS, false, "must implement equiv of __KernelGetCurThread");
-
-	int curThread = 0; //__KernelGetCurThread();
-	
-	std::string of;
-	MountPoint *mountPoint;
-	if (MapFilePath(dir, of, &mountPoint))
-	{
-		currentDir[curThread] = mountPoint->prefix + of;
-		return 0;
-	}
-	else
-	{
-		for (size_t i = 0; i < fileSystems.size(); i++)
-		{
-			const std::string &prefix = fileSystems[i].prefix;
-			if (strncasecmp(prefix.c_str(), dir.c_str(), prefix.size()) == 0)
-			{
-				// The PSP is completely happy with invalid current dirs as long as they have a valid device.
-				WARN_LOG(FILESYS, "ChDir failed to map path \"%s\", saving as current directory anyway", dir.c_str());
-				currentDir[curThread] = dir;
-				return 0;
-			}
-		}
-
-		WARN_LOG(FILESYS, "ChDir failed to map device for \"%s\", failing", dir.c_str());
-		return -1;//SCE_KERNEL_ERROR_NODEV;
-	}
-}
-
-bool MetaFileSystem::MkDir(const std::string &dirname)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	std::string of;
-	IFileSystem *system;
-	if (MapFilePath(dirname, of, &system))
-	{
-		return system->MkDir(of);
-	}
-	else
-	{
-		return false;
-	}
-}
-
-bool MetaFileSystem::RmDir(const std::string &dirname)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	std::string of;
-	IFileSystem *system;
-	if (MapFilePath(dirname, of, &system))
-	{
-		return system->RmDir(of);
-	}
-	else
-	{
-		return false;
-	}
-}
-
-int MetaFileSystem::RenameFile(const std::string &from, const std::string &to)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	std::string of;
-	std::string rf;
-	IFileSystem *osystem;
-	IFileSystem *rsystem = NULL;
-	if (MapFilePath(from, of, &osystem))
-	{
-		// If it's a relative path, it seems to always use from's filesystem.
-		if (to.find(":/") != to.npos)
-		{
-			if (!MapFilePath(to, rf, &rsystem))
-				return -1;
-		}
-		else
-		{
-			rf = to;
-			rsystem = osystem;
-		}
-
-		if (osystem != rsystem)
-			return -1;//SCE_KERNEL_ERROR_XDEV;
-
-		return osystem->RenameFile(of, rf);
-	}
-	else
-	{
-		return -1;
-	}
-}
-
-bool MetaFileSystem::RemoveFile(const std::string &filename)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	std::string of;
-	IFileSystem *system;
-	if (MapFilePath(filename, of, &system))
-	{
-		return system->RemoveFile(of);
-	}
-	else
-	{
-		return false;
-	}
-}
-
-void MetaFileSystem::CloseFile(u32 handle)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	IFileSystem *sys = GetHandleOwner(handle);
-	if (sys)
-		sys->CloseFile(handle);
-}
-
-size_t MetaFileSystem::ReadFile(u32 handle, u8 *pointer, s64 size)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	IFileSystem *sys = GetHandleOwner(handle);
-	if (sys)
-		return sys->ReadFile(handle,pointer,size);
-	else
-		return 0;
-}
-
-size_t MetaFileSystem::WriteFile(u32 handle, const u8 *pointer, s64 size)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	IFileSystem *sys = GetHandleOwner(handle);
-	if (sys)
-		return sys->WriteFile(handle,pointer,size);
-	else
-		return 0;
-}
-
-size_t MetaFileSystem::SeekFile(u32 handle, s32 position, FileMove type)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	IFileSystem *sys = GetHandleOwner(handle);
-	if (sys)
-		return sys->SeekFile(handle,position,type);
-	else
-		return 0;
-}
-
-void MetaFileSystem::DoState(PointerWrap &p)
-{
-	std::lock_guard<std::recursive_mutex> guard(lock);
-	
-	auto s = p.Section("MetaFileSystem", 1);
-	if (!s)
-		return;
-
-	p.Do(current);
-
-	// Save/load per-thread current directory map
-	p.Do(currentDir);
-
-	u32 n = (u32) fileSystems.size();
-	p.Do(n);
-	if (n != (u32) fileSystems.size())
-	{
-		p.SetError(p.ERROR_FAILURE);
-		ERROR_LOG(FILESYS, "Savestate failure: number of filesystems doesn't match.");
-		return;
-	}
-
-	for (u32 i = 0; i < n; ++i)
-		fileSystems[i].system->DoState(p);
-}
-

src/core/file_sys/meta_file_system.h

@@ -1,110 +0,0 @@
-// Copyright (c) 2012- PPSSPP Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0 or later versions.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official git repository and contact information can be found at
-// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
-
-#pragma once
-
-#include "common/std_mutex.h"
-
-#include "core/file_sys/file_sys.h"
-
-class MetaFileSystem : public IHandleAllocator, public IFileSystem
-{
-private:
-	u32 current;
-	struct MountPoint
-	{
-		std::string prefix;
-		IFileSystem *system;
-
-		bool operator == (const MountPoint &other) const
-		{
-			return prefix == other.prefix && system == other.system;
-		}
-	};
-	std::vector<MountPoint> fileSystems;
-
-	typedef std::map<int, std::string> currentDir_t;
-	currentDir_t currentDir;
-
-	std::string startingDirectory;
-	int lastOpenError;
-	std::recursive_mutex lock;
-
-public:
-	MetaFileSystem()
-	{
-		current = 6;  // what?
-	}
-
-	void Mount(std::string prefix, IFileSystem *system);
-	void Unmount(std::string prefix, IFileSystem *system);
-
-	void ThreadEnded(int threadID);
-
-	void Shutdown();
-
-	u32 GetNewHandle() {return current++;}
-	void FreeHandle(u32 handle) {}
-
-	virtual void DoState(PointerWrap &p);
-
-	IFileSystem *GetHandleOwner(u32 handle);
-	bool MapFilePath(const std::string &inpath, std::string &outpath, MountPoint **system);
-
-	inline bool MapFilePath(const std::string &_inpath, std::string &outpath, IFileSystem **system)
-	{
-		MountPoint *mountPoint;
-		if (MapFilePath(_inpath, outpath, &mountPoint))
-		{
-			*system = mountPoint->system;
-			return true;
-		}
-
-		return false;
-	}
-
-	// Only possible if a file system is a DirectoryFileSystem or similar.
-	bool GetHostPath(const std::string &inpath, std::string &outpath);
-	
-	std::vector<FileInfo> GetDirListing(std::string path);
-	u32      OpenFile(std::string filename, FileAccess access, const char *devicename = NULL);
-	u32      OpenWithError(int &error, std::string filename, FileAccess access, const char *devicename = NULL);
-	void     CloseFile(u32 handle);
-	size_t   ReadFile(u32 handle, u8 *pointer, s64 size);
-	size_t   WriteFile(u32 handle, const u8 *pointer, s64 size);
-	size_t   SeekFile(u32 handle, s32 position, FileMove type);
-	FileInfo GetFileInfo(std::string filename);
-	bool     OwnsHandle(u32 handle) {return false;}
-	inline size_t GetSeekPos(u32 handle)
-	{
-		return SeekFile(handle, 0, FILEMOVE_CURRENT);
-	}
-
-	virtual int ChDir(const std::string &dir);
-
-	virtual bool MkDir(const std::string &dirname);
-	virtual bool RmDir(const std::string &dirname);
-	virtual int  RenameFile(const std::string &from, const std::string &to);
-	virtual bool RemoveFile(const std::string &filename);
-
-	// TODO: void IoCtl(...)
-
-	void SetStartingDirectory(const std::string &dir) {
-		std::lock_guard<std::recursive_mutex> guard(lock);
-		startingDirectory = dir;
-	}
-};

src/core/system.cpp

@@ -15,7 +15,6 @@
 namespace System {
 
 volatile State g_state;
-MetaFileSystem g_ctr_file_system;
 
 void UpdateState(State state) {
 }
@@ -45,7 +44,6 @@ void Shutdown() {
     CoreTiming::Shutdown();
     VideoCore::Shutdown();
     Kernel::Shutdown();
-    g_ctr_file_system.Shutdown();
 }
 
 } // namespace

src/core/system.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include "common/emu_window.h"
-#include "core/file_sys/meta_file_system.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -24,7 +23,6 @@ typedef enum {
 } State;
 
 extern volatile State g_state;
-extern MetaFileSystem g_ctr_file_system;
 
 void UpdateState(State state);
 void Init(EmuWindow* emu_window);