More conversion from char * to std::string.

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@7266 8ced0084-cf51-0410-be5f-012b33b47a6e

1 files changed, 181 insertions, 283 deletions

diff --git a/Source/Core/Common/Src/FileUtil.cpp b/Source/Core/Common/Src/FileUtil.cpp
index 73735235f4..ed29eaa69e 100644
--- a/Source/Core/Common/Src/FileUtil.cpp
+++ b/Source/Core/Common/Src/FileUtil.cpp
@@ -49,8 +49,8 @@
 #endif
 
 #ifdef BSD4_4
-#define stat64 stat	// XXX
-#define fstat64 fstat	// XXX
+#define stat64 stat
+#define fstat64 fstat
 #endif
 
 // This namespace has various generic functions related to files and paths.
@@ -73,7 +73,7 @@ static void StripTailDirSlashes(std::string &fname)
 }
 
 // Returns true if file filename exists
-bool Exists(const char *filename)
+bool Exists(const std::string filename)
 {
 	struct stat64 file_info;
 
@@ -86,7 +86,7 @@ bool Exists(const char *filename)
 }
 
 // Returns true if filename is a directory
-bool IsDirectory(const char *filename)
+bool IsDirectory(const std::string filename)
 {
 	struct stat64 file_info;
 
@@ -97,7 +97,7 @@ bool IsDirectory(const char *filename)
 
 	if (result < 0) {
 		WARN_LOG(COMMON, "IsDirectory: stat failed on %s: %s", 
-				 filename, GetLastErrorMsg());
+				 filename.c_str(), GetLastErrorMsg());
 		return false;
 	}
 
@@ -106,33 +106,36 @@ bool IsDirectory(const char *filename)
 
 // Deletes a given filename, return true on success
 // Doesn't supports deleting a directory
-bool Delete(const char *filename)
+bool Delete(const std::string filename)
 {
-	INFO_LOG(COMMON, "Delete: file %s", filename);
+	INFO_LOG(COMMON, "Delete: file %s", filename.c_str());
 
 	// Return true because we care about the file no 
 	// being there, not the actual delete.
-	if (!Exists(filename)) {
-		WARN_LOG(COMMON, "Delete: %s does not exists", filename);
+	if (!Exists(filename))
+	{
+		WARN_LOG(COMMON, "Delete: %s does not exists", filename.c_str());
 		return true;
 	}
 
 	// We can't delete a directory
-	if (IsDirectory(filename)) {
-		WARN_LOG(COMMON, "Delete: %s is a directory", filename);
+	if (IsDirectory(filename))
+	{
+		WARN_LOG(COMMON, "Delete: %s is a directory", filename.c_str());
 		return false;
 	}
 
 #ifdef _WIN32
-	if (!DeleteFile(filename)) {
+	if (!DeleteFile(filename.c_str()))
+	{
 		WARN_LOG(COMMON, "Delete: DeleteFile failed on %s: %s", 
-				 filename, GetLastErrorMsg());
+				 filename.c_str(), GetLastErrorMsg());
 		return false;
 	}
 #else
-	if (unlink(filename) == -1) {
+	if (unlink(filename.c_str()) == -1) {
 		WARN_LOG(COMMON, "Delete: unlink failed on %s: %s", 
-				 filename, GetLastErrorMsg());
+				 filename.c_str(), GetLastErrorMsg());
 		return false;
 	}
 #endif
@@ -141,128 +144,122 @@ bool Delete(const char *filename)
 }
 
 // Returns true if successful, or path already exists.
-bool CreateDir(const char *path)
+bool CreateDir(const std::string path)
 {
-	INFO_LOG(COMMON, "CreateDir: directory %s", path);
+	INFO_LOG(COMMON, "CreateDir: directory %s", path.c_str());
 #ifdef _WIN32
-	if (::CreateDirectory(path, NULL))
+	if (::CreateDirectory(path.c_str(), NULL))
 		return true;
 	DWORD error = GetLastError();
-	if (error == ERROR_ALREADY_EXISTS) 	{
-		WARN_LOG(COMMON, "CreateDir: CreateDirectory failed on %s: already exists", path);
+	if (error == ERROR_ALREADY_EXISTS)
+	{
+		WARN_LOG(COMMON, "CreateDir: CreateDirectory failed on %s: already exists", path.c_str());
 		return true;
 	}
-	ERROR_LOG(COMMON, "CreateDir: CreateDirectory failed on %s: %i", path, error);
+	ERROR_LOG(COMMON, "CreateDir: CreateDirectory failed on %s: %i", path.c_str(), error);
 	return false;
 #else
-	if (mkdir(path, 0755) == 0)
+	if (mkdir(path.c_str(), 0755) == 0)
 		return true;
 
 	int err = errno;
 
-	if (err == EEXIST) {
-		WARN_LOG(COMMON, "CreateDir: mkdir failed on %s: already exists", path);
+	if (err == EEXIST)
+	{
+		WARN_LOG(COMMON, "CreateDir: mkdir failed on %s: already exists", path.c_str());
 		return true;
 	}
 
-	ERROR_LOG(COMMON, "CreateDir: mkdir failed on %s: %s", path, strerror(err));
+	ERROR_LOG(COMMON, "CreateDir: mkdir failed on %s: %s", path.c_str(), strerror(err));
 	return false;
 #endif
 }
 
 // Creates the full path of fullPath returns true on success
-bool CreateFullPath(const char *fullPath)
+bool CreateFullPath(const std::string fullPath)
 {
 	int panicCounter = 100;
-	INFO_LOG(COMMON, "CreateFullPath: path %s", fullPath);
+	INFO_LOG(COMMON, "CreateFullPath: path %s", fullPath.c_str());
 		
-	if (File::Exists(fullPath)) {
-		INFO_LOG(COMMON, "CreateFullPath: path exists %s", fullPath);
+	if (File::Exists(fullPath))
+	{
+		INFO_LOG(COMMON, "CreateFullPath: path exists %s", fullPath.c_str());
 		return true;
 	}
 
-	// safety check to ensure we have good dir seperators
-	std::string strFullPath(fullPath);
-
-	const char *position = strFullPath.c_str();
-	while (true) {
+	size_t position = 0;
+	while (true)
+	{
 		// Find next sub path
-		position = strchr(position, DIR_SEP_CHR);
+		position = fullPath.find(DIR_SEP_CHR, position);
 
 		// we're done, yay!
-		if (! position)
+		if (position == fullPath.npos)
 			return true;
 			
-		position++;
-
-		// Create next sub path
-		int sLen = (int)(position - strFullPath.c_str());
-		if (sLen > 0) {
-			char *subPath = strndup(strFullPath.c_str(), sLen);
-			if (!File::IsDirectory(subPath)) {
-				File::CreateDir(subPath);
-			}
-			free(subPath);
-		}
+		std::string subPath = fullPath.substr(0, position);
+		if (!File::IsDirectory(subPath))
+			File::CreateDir(subPath);
 
 		// A safety check
 		panicCounter--;
-		if (panicCounter <= 0) {
+		if (panicCounter <= 0)
+		{
 			ERROR_LOG(COMMON, "CreateFullPath: directory structure too deep");
 			return false;
 		}
+		position++;
 	}
 }
 
 
 // Deletes a directory filename, returns true on success
-bool DeleteDir(const char *filename)
+bool DeleteDir(const std::string filename)
 {
-	INFO_LOG(COMMON, "DeleteDir: directory %s", filename);
+	INFO_LOG(COMMON, "DeleteDir: directory %s", filename.c_str());
 
 	// check if a directory
-	if (!File::IsDirectory(filename)) {
-		ERROR_LOG(COMMON, "DeleteDir: Not a directory %s",
-				  filename);
+	if (!File::IsDirectory(filename))
+	{
+		ERROR_LOG(COMMON, "DeleteDir: Not a directory %s", filename.c_str());
 		return false;
 	}
 
 #ifdef _WIN32
-	if (::RemoveDirectory(filename))
+	if (::RemoveDirectory(filename.c_str()))
 		return true;
 #else
-	if (rmdir(filename) == 0)
+	if (rmdir(filename.c_str()) == 0)
 		return true;
 #endif
-	ERROR_LOG(COMMON, "DeleteDir: %s: %s",
-			  filename, GetLastErrorMsg());
+	ERROR_LOG(COMMON, "DeleteDir: %s: %s", filename.c_str(), GetLastErrorMsg());
 
 	return false;
 }
 
 // renames file srcFilename to destFilename, returns true on success 
-bool Rename(const char *srcFilename, const char *destFilename)
+bool Rename(const std::string srcFilename, const std::string destFilename)
 {
 	INFO_LOG(COMMON, "Rename: %s --> %s", 
-			 srcFilename, destFilename);
-	if (rename(srcFilename, destFilename) == 0)
+			srcFilename.c_str(), destFilename.c_str());
+	if (rename(srcFilename.c_str(), destFilename.c_str()) == 0)
 		return true;
 	ERROR_LOG(COMMON, "Rename: failed %s --> %s: %s", 
-			  srcFilename, destFilename, GetLastErrorMsg());
+			  srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
 	return false;
 }
 
 // copies file srcFilename to destFilename, returns true on success 
-bool Copy(const char *srcFilename, const char *destFilename)
+bool Copy(const std::string srcFilename, const std::string destFilename)
 {
 	INFO_LOG(COMMON, "Copy: %s --> %s", 
-			 srcFilename, destFilename);
+			srcFilename.c_str(), destFilename.c_str());
 #ifdef _WIN32
-	if (CopyFile(srcFilename, destFilename, FALSE))
+	if (CopyFile(srcFilename.c_str(), destFilename.c_str(), FALSE))
 		return true;
-		
+
 	ERROR_LOG(COMMON, "Copy: failed %s --> %s: %s", 
-			  srcFilename, destFilename, GetLastErrorMsg());
+			srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
 	return false;
 #else
 
@@ -272,21 +269,21 @@ bool Copy(const char *srcFilename, const char *destFilename)
 	char buffer[BSIZE];
 
 	// Open input file
-	FILE *input = fopen(srcFilename, "rb");
+	FILE *input = fopen(srcFilename.c_str(), "rb");
 	if (!input)
 	{
 		ERROR_LOG(COMMON, "Copy: input failed %s --> %s: %s", 
-				  srcFilename, destFilename, GetLastErrorMsg());
+				srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
 		return false;
 	}
 
 	// open output file
-	FILE *output = fopen(destFilename, "wb");
+	FILE *output = fopen(destFilename.c_str(), "wb");
 	if (!output)
 	{
 		fclose(input);
 		ERROR_LOG(COMMON, "Copy: output failed %s --> %s: %s", 
-				  srcFilename, destFilename, GetLastErrorMsg());
+				srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
 		return false;
 	}
 
@@ -297,10 +294,11 @@ bool Copy(const char *srcFilename, const char *destFilename)
 		int rnum = fread(buffer, sizeof(char), BSIZE, input);
 		if (rnum != BSIZE)
 		{
-			if (ferror(input) != 0) {
+			if (ferror(input) != 0)
+			{
 				ERROR_LOG(COMMON, 
-						  "Copy: failed reading from source, %s --> %s: %s", 
-						  srcFilename, destFilename, GetLastErrorMsg());
+						"Copy: failed reading from source, %s --> %s: %s", 
+						srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
 				return false;
 			}
 		}
@@ -310,8 +308,8 @@ bool Copy(const char *srcFilename, const char *destFilename)
 		if (wnum != rnum)
 		{
 			ERROR_LOG(COMMON, 
-					  "Copy: failed writing to output, %s --> %s: %s", 
-					  srcFilename, destFilename, GetLastErrorMsg());
+					"Copy: failed writing to output, %s --> %s: %s", 
+					srcFilename.c_str(), destFilename.c_str(), GetLastErrorMsg());
 			return false;
 		}
 	}
@@ -323,29 +321,29 @@ bool Copy(const char *srcFilename, const char *destFilename)
 }
 
 // Returns the size of filename (64bit)
-u64 GetSize(const char *filename)
+u64 GetSize(const std::string filename)
 {
-	if (!Exists(filename)) {
-		WARN_LOG(COMMON, "GetSize: failed %s: No such file"
-				 ,filename);
+	if (!Exists(filename))
+	{
+		WARN_LOG(COMMON, "GetSize: failed %s: No such file", filename.c_str());
 		return 0;
 	}
 
-	if (IsDirectory(filename)) {
-		WARN_LOG(COMMON, "GetSize: failed %s: is a directory"
-				 ,filename);
+	if (IsDirectory(filename))
+	{
+		WARN_LOG(COMMON, "GetSize: failed %s: is a directory", filename.c_str());
 		return 0;
 	}
-	// on windows it's actually _stat64 defined in commonFuncs
 	struct stat64 buf;
-	if (stat64(filename, &buf) == 0) {
+	if (stat64(filename.c_str(), &buf) == 0)
+	{
 		DEBUG_LOG(COMMON, "GetSize: %s: %lld",
-			filename, (long long)buf.st_size);
+				filename.c_str(), (long long)buf.st_size);
 		return buf.st_size;
 	}
 
 	ERROR_LOG(COMMON, "GetSize: Stat failed %s: %s",
-			  filename, GetLastErrorMsg());
+			filename.c_str(), GetLastErrorMsg());
 	return 0;
 }
 
@@ -381,14 +379,14 @@ u64 GetSize(FILE *f)
 }
 
 // creates an empty file filename, returns true on success 
-bool CreateEmptyFile(const char *filename)
+bool CreateEmptyFile(const std::string filename)
 {
-	INFO_LOG(COMMON, "CreateEmptyFile: %s", filename); 
+	INFO_LOG(COMMON, "CreateEmptyFile: %s", filename.c_str()); 
 
-	FILE *pFile = fopen(filename, "wb");
+	FILE *pFile = fopen(filename.c_str(), "wb");
 	if (!pFile) {
 		ERROR_LOG(COMMON, "CreateEmptyFile: failed %s: %s",
-				  filename, GetLastErrorMsg());
+				  filename.c_str(), GetLastErrorMsg());
 		return false;
 	}
 	fclose(pFile);
@@ -398,55 +396,57 @@ bool CreateEmptyFile(const char *filename)
 
 // Scans the directory tree gets, starting from _Directory and adds the
 // results into parentEntry. Returns the number of files+directories found
-u32 ScanDirectoryTree(const char *directory, FSTEntry& parentEntry)
+u32 ScanDirectoryTree(const std::string directory, FSTEntry& parentEntry)
 {
-	INFO_LOG(COMMON, "ScanDirectoryTree: directory %s", directory);
+	INFO_LOG(COMMON, "ScanDirectoryTree: directory %s", directory.c_str());
 	// How many files + directories we found
 	u32 foundEntries = 0;
-	char *virtualName;
 #ifdef _WIN32
 	// Find the first file in the directory.
 	WIN32_FIND_DATA ffd;
-	char searchName[MAX_PATH + 3];
-	strncpy(searchName, directory, MAX_PATH);
-	strcat(searchName, "\\*");
 
-	HANDLE hFind = FindFirstFile(searchName, &ffd);
-	if (hFind == INVALID_HANDLE_VALUE) {
+	HANDLE hFind = FindFirstFile((directory + "\\*").c_str(), &ffd);
+	if (hFind == INVALID_HANDLE_VALUE)
+	{
 		FindClose(hFind);
 		return foundEntries;
 	}
 	// windows loop
-	do {
+	do
+	{
 		FSTEntry entry;
-		virtualName = ffd.cFileName;
+		const std::string virtualName(ffd.cFileName);
 #else
 	struct dirent dirent, *result = NULL;
-	
-	DIR *dirp = opendir(directory);
+
+	DIR *dirp = opendir(directory.c_str());
 	if (!dirp)
 		return 0;
 
 	// non windows loop
-	while (!readdir_r(dirp, &dirent, &result) && result) {
+	while (!readdir_r(dirp, &dirent, &result) && result)
+	{
 		FSTEntry entry;
-		virtualName = result->d_name;
+		const std::string virtualName(result->d_name);
 #endif
 		// check for "." and ".."
 		if (((virtualName[0] == '.') && (virtualName[1] == '\0')) ||
-			((virtualName[0] == '.') && (virtualName[1] == '.') && 
-			 (virtualName[2] == '\0')))
+				((virtualName[0] == '.') && (virtualName[1] == '.') && 
+				 (virtualName[2] == '\0')))
 			continue;
 		entry.virtualName = virtualName;
 		entry.physicalName = directory;
 		entry.physicalName += DIR_SEP + entry.virtualName;
-		
-		if (IsDirectory(entry.physicalName.c_str())) {
+
+		if (IsDirectory(entry.physicalName.c_str()))
+		{
 			entry.isDirectory = true;
 			// is a directory, lets go inside
-			entry.size = ScanDirectoryTree(entry.physicalName.c_str(), entry);
+			entry.size = ScanDirectoryTree(entry.physicalName, entry);
 			foundEntries += (u32)entry.size;
-		} else { // is a file 
+		}
+		else
+		{ // is a file 
 			entry.isDirectory = false;
 			entry.size = GetSize(entry.physicalName.c_str());
 		}
@@ -465,38 +465,35 @@ u32 ScanDirectoryTree(const char *directory, FSTEntry& parentEntry)
 }
 
 	
-// deletes the given directory and anything under it. Returns true on
-// success.
-bool DeleteDirRecursively(const char *directory)
+// Deletes the given directory and anything under it. Returns true on success.
+bool DeleteDirRecursively(const std::string directory)
 {
-	INFO_LOG(COMMON, "DeleteDirRecursively: %s", directory);
+	INFO_LOG(COMMON, "DeleteDirRecursively: %s", directory.c_str());
 #ifdef _WIN32
 	// Find the first file in the directory.
 	WIN32_FIND_DATA ffd;
-	char searchName[MAX_PATH + 3] = {0};
-
-	strncpy(searchName, directory, MAX_PATH);
-	strcat(searchName, "\\*");
+	HANDLE hFind = FindFirstFile((directory + "\\*").c_str(), &ffd);
 
-	HANDLE hFind = FindFirstFile(searchName, &ffd);
-
-	if (hFind == INVALID_HANDLE_VALUE) {
+	if (hFind == INVALID_HANDLE_VALUE)
+	{
 		FindClose(hFind);
 		return false;
 	}
 		
 	// windows loop
-	do {
-		char *virtualName = ffd.cFileName;
+	do
+	{
+		const std::string virtualName = ffd.cFileName;
 #else
 	struct dirent dirent, *result = NULL;
-	DIR *dirp = opendir(directory);
+	DIR *dirp = opendir(directory.c_str());
 	if (!dirp)
 		return false;
 
 	// non windows loop
-	while (!readdir_r(dirp, &dirent, &result) && result) {
-		char *virtualName = result->d_name;
+	while (!readdir_r(dirp, &dirent, &result) && result)
+	{
+		const std::string virtualName = result->d_name;
 #endif
 
 		// check for "." and ".."
@@ -505,12 +502,14 @@ bool DeleteDirRecursively(const char *directory)
 			 (virtualName[2] == '\0')))
 			continue;
 
-		char newPath[MAX_PATH];
-		sprintf(newPath, "%s%c%s", directory, DIR_SEP_CHR, virtualName);
-		if (IsDirectory(newPath)) {
+		std::string newPath = directory + DIR_SEP_CHR + virtualName;
+		if (IsDirectory(newPath))
+		{
 			if (!DeleteDirRecursively(newPath))
 				return false;
-		} else {
+		}
+		else
+		{
 			if (!File::Delete(newPath))
 				return false;
 		}
@@ -527,37 +526,34 @@ bool DeleteDirRecursively(const char *directory)
 	return true;
 }
 
-//Create directory and copy contents (does not overwrite existing files)
-void CopyDir(const char *source_path, const char *dest_path)
+// Create directory and copy contents (does not overwrite existing files)
+void CopyDir(const std::string source_path, const std::string dest_path)
 {
 #ifndef _WIN32
-	if (!strcmp(source_path, dest_path)) return;
+	if (source_path == dest_path) return;
 	if (!File::Exists(source_path)) return;
 	if (!File::Exists(dest_path)) File::CreateFullPath(dest_path);
 
-	char *virtualName;
 	struct dirent dirent, *result = NULL;
-	DIR *dirp = opendir(source_path);
+	DIR *dirp = opendir(source_path.c_str());
 	if (!dirp) return;
 
 	while (!readdir_r(dirp, &dirent, &result) && result)
 	{
-		virtualName = result->d_name;
+		const std::string virtualName(result->d_name);
 		// check for "." and ".."
 		if (((virtualName[0] == '.') && (virtualName[1] == '\0')) ||
 			((virtualName[0] == '.') && (virtualName[1] == '.') &&
 			(virtualName[2] == '\0')))
 			continue;
 
-		char source[FILENAME_MAX], dest[FILENAME_MAX];
-		sprintf(source, "%s%s", source_path, virtualName);
-		sprintf(dest, "%s%s", dest_path, virtualName);
+		std::string source, dest;
+		source = source_path + virtualName;
+		dest = dest_path + virtualName;
 		if (IsDirectory(source))
 		{
-			const unsigned int srclen = strlen(source);
-			const unsigned int destlen = strlen(dest);
-			source[srclen] = '/'; source[srclen+1] = '\0';
-			dest[destlen]  = '/'; dest[destlen+1]  = '\0';
+			source += '/';
+			dest += '/';
 			if (!File::Exists(dest)) File::CreateFullPath(dest);
 			CopyDir(source, dest);
 		}
@@ -584,9 +580,9 @@ std::string GetCurrentDir()
 }
 
 // Sets the current directory to the given directory
-bool SetCurrentDir(const char *_rDirectory)
+bool SetCurrentDir(const std::string directory)
 {
-	return __chdir(_rDirectory) == 0;
+	return __chdir(directory.c_str()) == 0;
 }
 
 #if defined(__APPLE__)
@@ -622,155 +618,57 @@ std::string GetSysDirectory()
 	return sysDir;
 }
 
-// Returns a pointer to a string with a Dolphin data dir or file in the user's home
+// Returns a string with a Dolphin data dir or file in the user's home
 // directory. To be used in "multi-user" mode (that is, installed).
-std::string &GetUserPath(int DirIDX)
+std::string &GetUserPath(const unsigned int DirIDX)
 {
-	static std::string UserDir;
-	static std::string GCUserDir;
-	static std::string WiiUserDir;
-	static std::string WiiRootDir;
-	static std::string ConfigDir;
-	static std::string GameConfigDir;
-	static std::string MapsDir;
-	static std::string CacheDir;
-	static std::string ShaderCacheDir;
-	static std::string ShadersDir;
-	static std::string StateSavesDir;
-	static std::string ScreenShotsDir;
-	static std::string OpenCLDir;
-	static std::string HiresTexturesDir;
-	static std::string DumpDir;
-	static std::string DumpFramesDir;
-	static std::string DumpAudioDir;
-	static std::string DumpTexturesDir;
-	static std::string DumpDSPDir;
-	static std::string LogsDir;
-	static std::string MailLogsDir;
-	static std::string WiiSYSCONFDir;
-	static std::string DolphinConfig;
-	static std::string DSPConfig;
-	static std::string DebuggerConfig;
-	static std::string LoggerConfig;
-	static std::string MainLog;
-	static std::string WiiSYSCONF;
-	static std::string RamDump;
-	static std::string ARamDump;
-	static std::string GCSRam;
-	static std::string Default;
+	static std::string paths[NUM_PATH_INDICES];
 
 	// Set up all paths and files on the first run
-	if (UserDir.empty())
+	if (paths[D_USER_IDX].empty())
 	{
 #ifdef _WIN32
-		// Keep the directory setup the way it was on windows
-		UserDir = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
+		paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
 #else
 		if (File::Exists(ROOT_DIR DIR_SEP USERDATA_DIR))
-			UserDir = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
+			paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
 		else
-			UserDir = std::string(getenv("HOME")) + DIR_SEP DOLPHIN_DATA_DIR DIR_SEP;
+			paths[D_USER_IDX] = std::string(getenv("HOME")) + DIR_SEP DOLPHIN_DATA_DIR DIR_SEP;
 #endif
-		INFO_LOG(COMMON, "GetUserPath: Setting user directory to %s:", UserDir.c_str());
-
-		GCUserDir = UserDir + GC_USER_DIR DIR_SEP;
-		WiiUserDir = UserDir + WII_USER_DIR DIR_SEP;
-		WiiRootDir = UserDir + WII_USER_DIR;
-		ConfigDir = UserDir + CONFIG_DIR DIR_SEP;
-		GameConfigDir = UserDir + GAMECONFIG_DIR DIR_SEP;
-		MapsDir = UserDir + MAPS_DIR DIR_SEP;
-		CacheDir = UserDir + CACHE_DIR DIR_SEP;
-		ShaderCacheDir = UserDir + SHADERCACHE_DIR DIR_SEP;
-		ShadersDir = UserDir + SHADERS_DIR DIR_SEP;
-		StateSavesDir = UserDir + STATESAVES_DIR DIR_SEP;
-		ScreenShotsDir = UserDir + SCREENSHOTS_DIR DIR_SEP;
-		OpenCLDir = UserDir + OPENCL_DIR DIR_SEP;
-		HiresTexturesDir = UserDir + HIRES_TEXTURES_DIR DIR_SEP;
-		DumpDir = UserDir + DUMP_DIR DIR_SEP;
-		DumpFramesDir = UserDir + DUMP_FRAMES_DIR DIR_SEP;
-		DumpAudioDir = UserDir + DUMP_AUDIO_DIR DIR_SEP;
-		DumpTexturesDir = UserDir + DUMP_TEXTURES_DIR DIR_SEP;
-		DumpDSPDir = UserDir + DUMP_DSP_DIR DIR_SEP;
-		LogsDir = UserDir + LOGS_DIR DIR_SEP;
-		MailLogsDir = UserDir + MAIL_LOGS_DIR DIR_SEP;
-		WiiSYSCONFDir = UserDir + WII_SYSCONF_DIR DIR_SEP;
-		DolphinConfig = ConfigDir + DOLPHIN_CONFIG;
-		DSPConfig = ConfigDir + DSP_CONFIG;
-		DebuggerConfig = ConfigDir + DEBUGGER_CONFIG;
-		LoggerConfig = ConfigDir + LOGGER_CONFIG;
-		MainLog = LogsDir + MAIN_LOG;
-		WiiSYSCONF = WiiSYSCONFDir + WII_SYSCONF;
-		RamDump = DumpDir + RAM_DUMP;
-		ARamDump = DumpDir + ARAM_DUMP;
-		GCSRam = GCUserDir + GC_SRAM;
-	}
-	switch (DirIDX)
-	{
-		case D_USER_IDX:
-			return UserDir;
-		case D_GCUSER_IDX:
-			return GCUserDir;
-		case D_WIIUSER_IDX:
-			return WiiUserDir;
-		case D_WIIROOT_IDX:
-			return WiiRootDir;
-		case D_CONFIG_IDX:
-			return ConfigDir;
-		case D_GAMECONFIG_IDX:
-			return GameConfigDir;
-		case D_MAPS_IDX:
-			return MapsDir;
-		case D_CACHE_IDX:
-			return CacheDir;
-		case D_SHADERCACHE_IDX:
-			return ShaderCacheDir;
-		case D_SHADERS_IDX:
-			return ShadersDir;
-		case D_STATESAVES_IDX:
-			return StateSavesDir;
-		case D_SCREENSHOTS_IDX:
-			return ScreenShotsDir;
-		case D_OPENCL_IDX:
-			return OpenCLDir;
-		case D_HIRESTEXTURES_IDX:
-			return HiresTexturesDir;
-		case D_DUMP_IDX:
-			return DumpDir;
-		case D_DUMPFRAMES_IDX:
-			return DumpFramesDir;
-		case D_DUMPAUDIO_IDX:
-			return DumpAudioDir;
-		case D_DUMPTEXTURES_IDX:
-			return DumpTexturesDir;
-		case D_DUMPDSP_IDX:
-			return DumpDSPDir;
-		case D_LOGS_IDX:
-			return LogsDir;
-		case D_MAILLOGS_IDX:
-			return MailLogsDir;
-		case D_WIISYSCONF_IDX:
-			return WiiSYSCONFDir;
-		case F_DOLPHINCONFIG_IDX:
-			return DolphinConfig;
-		case F_DSPCONFIG_IDX:
-			return DSPConfig;
-		case F_DEBUGGERCONFIG_IDX:
-			return DebuggerConfig;
-		case F_LOGGERCONFIG_IDX:
-			return LoggerConfig;
-		case F_MAINLOG_IDX:
-			return MainLog;
-		case F_WIISYSCONF_IDX:
-			return WiiSYSCONF;
-		case F_RAMDUMP_IDX:
-			return RamDump;
-		case F_ARAMDUMP_IDX:
-			return ARamDump;
-		case F_GCSRAM_IDX:
-			return GCSRam;
-		default:
-			return Default;
+		INFO_LOG(COMMON, "GetUserPath: Setting user directory to %s:", paths[D_USER_IDX].c_str());
+
+		paths[D_GCUSER_IDX]			= paths[D_USER_IDX] + GC_USER_DIR DIR_SEP;
+		paths[D_WIIUSER_IDX]		= paths[D_USER_IDX] + WII_USER_DIR DIR_SEP;
+		paths[D_WIIROOT_IDX]		= paths[D_USER_IDX] + WII_USER_DIR;
+		paths[D_CONFIG_IDX]			= paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
+		paths[D_GAMECONFIG_IDX]		= paths[D_USER_IDX] + GAMECONFIG_DIR DIR_SEP;
+		paths[D_MAPS_IDX]			= paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
+		paths[D_CACHE_IDX]			= paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
+		paths[D_SHADERCACHE_IDX]	= paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;
+		paths[D_SHADERS_IDX]		= paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
+		paths[D_STATESAVES_IDX]		= paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
+		paths[D_SCREENSHOTS_IDX]	= paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
+		paths[D_OPENCL_IDX]			= paths[D_USER_IDX] + OPENCL_DIR DIR_SEP;
+		paths[D_HIRESTEXTURES_IDX]	= paths[D_USER_IDX] + HIRES_TEXTURES_DIR DIR_SEP;
+		paths[D_DUMP_IDX]			= paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
+		paths[D_DUMPFRAMES_IDX]		= paths[D_USER_IDX] + DUMP_FRAMES_DIR DIR_SEP;
+		paths[D_DUMPAUDIO_IDX]		= paths[D_USER_IDX] + DUMP_AUDIO_DIR DIR_SEP;
+		paths[D_DUMPTEXTURES_IDX]	= paths[D_USER_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
+		paths[D_DUMPDSP_IDX]		= paths[D_USER_IDX] + DUMP_DSP_DIR DIR_SEP;
+		paths[D_LOGS_IDX]			= paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
+		paths[D_MAILLOGS_IDX]		= paths[D_USER_IDX] + MAIL_LOGS_DIR DIR_SEP;
+		paths[D_WIISYSCONF_IDX]		= paths[D_USER_IDX] + WII_SYSCONF_DIR DIR_SEP;
+		paths[F_DOLPHINCONFIG_IDX]	= paths[D_CONFIG_IDX] + DOLPHIN_CONFIG;
+		paths[F_DSPCONFIG_IDX]		= paths[D_CONFIG_IDX] + DSP_CONFIG;
+		paths[F_DEBUGGERCONFIG_IDX]	= paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
+		paths[F_LOGGERCONFIG_IDX]	= paths[D_CONFIG_IDX] + LOGGER_CONFIG;
+		paths[F_MAINLOG_IDX]		= paths[D_LOGS_IDX] + MAIN_LOG;
+		paths[F_WIISYSCONF_IDX]		= paths[D_WIISYSCONF_IDX] + WII_SYSCONF;
+		paths[F_RAMDUMP_IDX]		= paths[D_DUMP_IDX] + RAM_DUMP;
+		paths[F_ARAMDUMP_IDX]		= paths[D_DUMP_IDX] + ARAM_DUMP;
+		paths[F_GCSRAM_IDX]			= paths[D_GCUSER_IDX] + GC_SRAM;
 	}
+	return paths[DirIDX];
 }
 
 bool WriteStringToFile(bool text_file, const std::string &str, const char *filename)