+Unity Runtime codeHEADmaster

1 files changed, 831 insertions, 0 deletions

diff --git a/Runtime/Utilities/File.cpp b/Runtime/Utilities/File.cpp
new file mode 100644
index 0000000..f93e2df
--- /dev/null
+++ b/Runtime/Utilities/File.cpp
@@ -0,0 +1,831 @@
+#include "UnityPrefix.h"
+#include "File.h"
+#include "PathNameUtility.h"
+#include "PlatformDependent/Win/unistd.h"
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#if UNITY_EDITOR
+#include "FileUtilities.h"
+#include "Editor/Platform/Interface/EditorUtility.h"
+#endif
+#include "Runtime/Scripting/ScriptingUtility.h"
+#if UNITY_OSX || UNITY_IPHONE || UNITY_LINUX || UNITY_FLASH || UNITY_WEBGL || UNITY_TIZEN
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "dirent.h"
+#endif
+#if UNITY_BB10
+#include <unistd.h>
+#include <dirent.h>
+#endif
+#include "Runtime/Threads/Thread.h"
+
+// This is File implementation for OSX and possibly others. Windows implementation is in PlatformDependent
+#if UNITY_WIN
+#error "Windows implementation of File is not here!"
+#endif
+
+using namespace std;
+
+#if UNITY_EDITOR
+string GetFormattedFileError (int error, const std::string& operation);
+#endif
+
+static string gCurrentDirectory;
+
+static FILE* OpenFileWithPath( const string& path, File::Permission permission )
+{
+#if SUPPORT_DIRECT_FILE_ACCESS
+	const char* fileMode = NULL;
+	switch (permission) {
+		case File::kReadPermission:
+			fileMode="rb";
+			break;
+		case File::kWritePermission:
+			fileMode="wb";
+			break;
+		case File::kReadWritePermission:
+			fileMode="r+b";
+			break;
+		case File::kAppendPermission:
+			fileMode="ab";
+			break;
+	}
+
+	return fopen( PathToAbsolutePath(path).c_str(), fileMode );
+
+#else //SUPPORT_DIRECT_FILE_ACCESS
+
+	ErrorString("No file access allowed!");
+	return NULL;
+#endif
+}
+
+bool IsAbsoluteFilePath( const std::string& path )
+{
+	if( path.empty() )
+		return false;
+
+	if( path[0] == kPlatformPathNameSeparator )
+		return true; // paths starting with separator are absolute
+
+	return false;
+}
+
+
+string PathToAbsolutePath (const string& path)
+{
+	if( IsAbsoluteFilePath(path) )
+		return path;
+	else
+		return AppendPathName (File::GetCurrentDirectory (), path);
+}
+
+bool ReadFromFile (const string& pathName, void *data, int fileStart, int byteLength)
+{
+	FILE* file = OpenFileWithPath( pathName, File::kReadPermission );
+	if (file == NULL)
+		return false;
+
+	fseek(file, 0, SEEK_END);
+
+	int length = ftell(file);
+	fseek(file, 0, SEEK_SET);
+	if (length < byteLength)
+	{
+		fclose(file);
+		return false;
+	}
+
+	int readLength = fread(data, 1, byteLength, file);
+
+	fclose(file);
+
+	if (readLength != byteLength)
+		return false;
+
+	return true;
+}
+
+
+#if !UNITY_FLASH  //flash implementation in AS3Utility.cpp
+bool ReadStringFromFile (InputString* outData, const string& pathName)
+{
+	FILE* file = OpenFileWithPath( pathName, File::kReadPermission );
+	if (file == NULL)
+		return false;
+
+	fseek(file, 0, SEEK_END);
+
+	int length = ftell(file);
+	fseek(file, 0, SEEK_SET);
+	if (length < 0)
+	{
+		fclose( file );
+		return false;
+	}
+
+	outData->resize(length);
+	int readLength = fread(&*outData->begin(), 1, length, file);
+
+	fclose(file);
+
+	if (readLength != length)
+	{
+		outData->clear();
+		return false;
+	}
+
+	return true;
+}
+#endif
+
+
+bool WriteBytesToFile (const void *data, int byteLength, const string& pathName)
+{
+	File file;
+	if (!file.Open(pathName, File::kWritePermission))
+		return false;
+
+	bool success = file.Write(data, byteLength);
+
+	file.Close();
+
+	return success;
+}
+
+
+int GetFileLength (const string& pathName)
+{
+	#if UNITY_OSX || UNITY_BB10
+	struct stat statbuffer;
+	if( stat(pathName.c_str(), &statbuffer) != 0 )
+		return 0; /// return -1 for error???
+	Assert (S_ISREG(statbuffer.st_mode));
+	return statbuffer.st_size;
+	#elif UNITY_FLASH
+	return Ext_FileContainer_GetFileLength(pathName.c_str());
+	#else
+	FILE* file = OpenFileWithPath( pathName, File::kReadPermission );
+	if (file == NULL)
+		return 0; /// return -1???
+
+	fseek(file, 0, SEEK_END);
+	int length = ftell(file);
+	fclose(file);
+
+	return length;
+	#endif
+}
+
+File::File () { m_File = NULL;m_Position = 0; }
+
+File::~File () { AssertIf(m_File != NULL); }
+
+#if UNITY_EDITOR
+string GetFormattedFileError (int error, const std::string& operation)
+{
+	const char* opstr = operation.c_str();
+	switch (error)
+	{
+		case ENAMETOOLONG:
+			return Format("%s failed because file name is too long", opstr);
+		case ENOTDIR:
+			return Format("%s failed: from directory to non-directory", opstr);
+		case EISDIR:
+			return Format("%s failed: from non-directory to directory", opstr);
+		case EXDEV:
+			return Format("%s failed: to and from are on different file systems", opstr);
+		case EIO:
+			return Format("%s failed: I/O error updating directory", opstr);
+		case EROFS:
+			return Format("%s failed: read only file system", opstr);
+		case EFAULT:
+			return Format("%s failed: segmentation fault", opstr);
+		case EINVAL:
+			return Format("%s failed: from is a parent of to, or rename of . or ..", opstr);
+		case ENOTEMPTY:
+			return Format("%s failed: to is a directory and not empty", opstr);
+		case EPERM:
+			return Format("%s failed because the operation was not permitted", opstr);
+		case ENOENT:
+			return Format("%s failed because the file or directory does not exist", opstr);
+		case ENOMEM:
+			return Format("%s failed because there was not enough memory available", opstr);
+		case EACCES:
+			return Format("%s failed because permission for the file was denied", opstr);
+		case EEXIST:
+			return Format("%s failed because the file already exists", opstr);
+		case ENOSPC:
+			return Format("%s failed because there is no disk space left. Please free some disk space and continue.", opstr);
+		#if UNITY_OSX
+		case EAUTH:
+			return Format("%s failed because of an authentication failure", opstr);
+		case ENEEDAUTH:
+			return Format("%s failed because you need an authenticator", opstr);
+		case ELOOP:
+			return Format("%s failed: too many symbolic links", opstr);
+		case EDQUOT:
+			return Format("%s failed: quota limit reached", opstr);
+		#endif
+		default:
+			return Format("%s failed with error: %s", opstr, strerror(error));
+	}
+}
+
+#endif
+static bool HandleFileError (const char* title, const string& operation, FILE* file)
+{
+	#if UNITY_EDITOR
+	int err = ferror(file);
+	clearerr(file);
+
+	int result = DisplayDialogComplex (title, GetFormattedFileError(err, operation), "Try Again", "Cancel", "Force Quit");
+	if (result == 1)
+		return false;
+	else if (result == 2)
+		exit(1);
+	else
+		return true;
+	#else
+	return false;
+	#endif
+}
+
+bool File::Open (const std::string& path, File::Permission perm, AutoBehavior behavior)
+{
+	Close();
+	m_Path = path;
+
+	int retryCount = 5;
+
+	while (true)
+	{
+		m_File = OpenFileWithPath( path, perm );
+		m_Position = 0;
+		if (m_File != NULL)
+		{
+			if (perm == kAppendPermission)
+				m_Position = ftell(m_File);
+			return true;
+		}
+		else
+		{
+#if SUPPORT_THREADS
+			if ( (behavior & kRetryOnOpenFail) && (--retryCount > 0))
+			{
+				Thread::Sleep(0.2);
+				continue;
+			}
+#endif
+
+			if ( behavior & kSilentReturnOnOpenFail )
+				return false;
+
+			#if UNITY_EDITOR
+			int result = DisplayDialogComplex ("Opening file failed", GetFormattedFileError(errno, "Opening file "+path), "Try Again", "Cancel", "Force Quit");
+			if (result == 1)
+				return false;
+			else if (result == 2)
+				exit(1);
+			#else
+			ErrorString("Failed to open file at path: " + path);
+			return false;
+			#endif
+		}
+	}
+	return false;
+}
+
+bool File::Close ()
+{
+	if (m_File != NULL)
+	{
+		if (fclose(m_File) != 0)
+		{
+			#if UNITY_EDITOR
+			ErrorString(GetFormattedFileError(errno, "Closing file " + m_Path));
+			#elif UNITY_FLASH
+			//no problemo
+			#else
+			ErrorString("Closing file " + m_Path);
+			#endif
+		}
+		m_File = NULL;
+	}
+
+	m_Path.clear();
+	return true;
+}
+
+int File::Read (void* buffer, int size)
+{
+	if (m_File)
+	{
+		int s = fread(buffer, 1, size, m_File);
+
+		if (s == size || ferror(m_File) == 0)
+		{
+			m_Position += s;
+			return s;
+		}
+		else
+		{
+			//m_Position = -1;
+			if (!HandleFileError("Reading file failed", "Reading from file " + m_Path, m_File))
+				return false;
+
+			// We don't know how far the file was read.
+			// So we just play safe and go through the API that seeks from a specific offset
+			int oldPos = m_Position;
+			m_Position = -1;
+			return Read(oldPos, buffer, size);
+		}
+	}
+	else
+	{
+		ErrorString("Reading failed because the file was not opened");
+		return 0;
+	}
+}
+
+int File::Read (int position, void* buffer, int size)
+{
+	if (m_File)
+	{
+		while (true)
+		{
+			// Seek if necessary
+			if (position != m_Position)
+			{
+				if (fseek(m_File, position, SEEK_SET) != -1)
+					m_Position = position;
+				else
+				{
+					m_Position = -1;
+					if (!HandleFileError("Reading file failed", "Seeking in file " + m_Path, m_File ))
+						return 0;
+
+					continue;
+				}
+			}
+
+			int s = fread(buffer, 1, size, m_File);
+			if (s == size || ferror(m_File) == 0)
+			{
+				m_Position += s;
+				return s;
+			}
+			else
+			{
+				m_Position = -1;
+				if (!HandleFileError("Reading file failed", "Reading from file " + m_Path, m_File ))
+					return 0;
+			}
+		}
+	}
+	else
+	{
+		ErrorString("Reading failed because the file was not opened");
+		return 0;
+	}
+	return 0;
+}
+
+
+
+bool File::Write (const void* buffer, int size)
+{
+	if (m_File)
+	{
+		int s = fwrite(buffer, 1, size, m_File);
+		if (s == size)
+		{
+			m_Position += s;
+			return true;
+		}
+		else
+		{
+			if (!HandleFileError("Writing file failed", "Writing to file " + m_Path, m_File))
+				return false;
+
+			// We don't know how far the file was read.
+			// So we just play safe and go through the API that seeks from a specific offset
+			int oldPos = m_Position;
+			m_Position = -1;
+			return Write(oldPos, buffer, size);
+		}
+	}
+	else
+	{
+		ErrorString("Writing failed because the file was not opened");
+		return false;
+	}
+}
+
+bool File::Write (int position, const void* buffer, int size)
+{
+	if (m_File)
+	{
+		while (true)
+		{
+			// Seek if necessary
+			if (position != m_Position)
+			{
+				if (fseek(m_File, position, SEEK_SET) != -1)
+					m_Position = position;
+				else
+				{
+					m_Position = -1;
+					if (!HandleFileError("Writing file failed", "Seeking in file "+m_Path, m_File))
+						return false;
+
+					continue;
+				}
+			}
+
+			int s = fwrite(buffer, 1, size, m_File);
+			if (s == size)
+			{
+				m_Position += s;
+				return true;
+			}
+			else
+			{
+				m_Position = -1;
+				if (!HandleFileError("Writing file failed", "Writing to file "+m_Path, m_File))
+					return false;
+			}
+		}
+	}
+	else
+	{
+		ErrorString("Writing failed because the file was not opened");
+	}
+	return false;
+}
+
+bool File::SetFileLength (int size)
+{
+	return ::SetFileLength(m_Path, size);
+}
+
+int File::GetFileLength()
+{
+	return ::GetFileLength(m_Path);
+}
+
+void File::SetCurrentDirectory (const string& path)
+{
+	gCurrentDirectory = path;
+}
+
+const string& File::GetCurrentDirectory ()
+{
+	return gCurrentDirectory;
+}
+
+void File::CleanupClass()
+{
+	gCurrentDirectory = string();
+}
+
+bool SetFileLength (const std::string& path, int size)
+{
+	#if UNITY_PEPPER || UNITY_FLASH || UNITY_WEBGL
+	ErrorString("SetFileLength not supported on this platform!");
+	return false;
+	#else
+	while (true)
+	{
+		int error = truncate(path.c_str(), size);
+		if (error == 0)
+			return true;
+
+		#if UNITY_EDITOR
+		int result = DisplayDialogComplex ("Writing file error", GetFormattedFileError(errno, "Resizing file " + path), "Try Again", "Cancel", "Quit");
+		if (result == 1)
+			return false;
+		else if (result == 2)
+			exit(1);
+		#else
+		return false;
+		#endif
+	}
+	#endif
+
+	return true;
+}
+
+static bool IsFileCreatedAtAbsolutePath (const string & path)
+{
+	#if UNITY_OSX || UNITY_IPHONE || UNITY_LINUX || UNITY_FLASH || UNITY_WEBGL || UNITY_BB10 || UNITY_TIZEN
+	
+	struct stat status;
+
+	if (stat(path.c_str(), &status) != 0)
+		return false;
+
+#if TARGET_IPHONE_SIMULATOR
+	// some bad hack for simulator, if we can stat it then file exists...
+	return true;
+#endif
+
+	return S_ISREG (status.st_mode);
+
+	#elif !SUPPORT_DIRECT_FILE_ACCESS
+
+	ErrorString("No file access allowed!");
+	return false;
+
+	#else
+
+	#error "Unsupported platform!"
+
+	#endif
+}
+
+#if !UNITY_FLASH //Flash implementation in AS3Utility.cpp
+bool IsFileCreated (const string& path)
+{
+	return IsFileCreatedAtAbsolutePath (PathToAbsolutePath (path));
+}
+#endif
+
+
+#if UNITY_OSX || UNITY_IPHONE || UNITY_PEPPER || UNITY_LINUX || UNITY_BB10 || UNITY_TIZEN
+bool IsFileOrDirectoryInUse ( const string& path )
+{
+#if UNITY_LINUX || UNITY_BB10 || UNITY_TIZEN
+	return false;
+#elif !UNITY_PEPPER
+	bool isUsed = false;
+
+	if ( IsDirectoryCreated( path ) )
+	{
+		set<string> paths;
+		if ( GetFolderContentsAtPath( path, paths ) )
+		{
+			for (set<string>::iterator i = paths.begin(); i != paths.end(); i++)
+			{
+				if ( IsFileOrDirectoryInUse( *i ) )
+					return true;
+			}
+		}
+	}
+	else if ( IsFileCreated( path ) )
+	{
+		File openTest;
+		if ( openTest.Open( path, File::kReadPermission ) )
+		{
+			if ( !openTest.Lock( File::kExclusive, false ) )
+				isUsed = true;
+			openTest.Lock( File::kNone, false );
+			openTest.Close();
+		}
+		else
+			isUsed = true;
+	}
+
+	return isUsed;
+#else
+	ErrorString("No file access allowed!");
+	return false;
+#endif
+}
+#endif
+
+static bool IsDirectoryCreatedAtAbsolutePath (const string & path)
+{
+	#if UNITY_OSX || UNITY_LINUX || UNITY_IPHONE || UNITY_BB10 || UNITY_WEBGL || UNITY_TIZEN
+	struct stat status;
+	if (stat(path.c_str(), &status) != 0)
+		return false;
+	return S_ISDIR(status.st_mode);
+
+	#elif UNITY_FLASH
+	#warning "IsDirectoryCreatedAtAbsolutePath() NOT implemented for UNITY_FLASH"
+	return false;
+
+	#elif !SUPPORT_DIRECT_FILE_ACCESS
+
+	ErrorString("No file access allowed!");
+	return false;
+	#else
+	#error Unknown platform
+	#endif
+}
+
+bool IsDirectoryCreated (const string& path)
+{
+	return IsDirectoryCreatedAtAbsolutePath (PathToAbsolutePath (path));
+}
+
+bool CreateDirectory (const string& pathName)
+{
+#if SUPPORT_DIRECT_FILE_ACCESS && !UNITY_FLASH
+	if (IsFileCreated (pathName))
+		return false;
+	else if (IsDirectoryCreated (pathName))
+		return true;
+
+	string absolutePath = PathToAbsolutePath (pathName);
+
+#if UNITY_EDITOR
+	std::string fileNamePart = GetLastPathNameComponent (absolutePath);
+	if (CheckValidFileNameDetail (fileNamePart) == kFileNameInvalid)
+	{
+		ErrorStringMsg ("%s is not a valid directory name. Please make sure there are no unallowed characters in the name.", fileNamePart.c_str ());
+		return false;
+	}
+#endif
+
+	int res = mkdir(absolutePath.c_str(), 0755);
+	return res == 0;
+#else
+	ErrorString("No file access allowed!");
+	return false;
+#endif
+}
+
+bool DeleteFile (const string& path)
+{
+#if !UNITY_PEPPER && !UNITY_FLASH && !UNITY_WEBGL
+	string absolutePath = PathToAbsolutePath (path);
+	if (IsFileCreated (absolutePath))
+	{
+		return unlink(absolutePath.c_str()) == 0;
+	}
+	else
+	{
+		return false;
+	}
+#else
+	ErrorString("No file access allowed!");
+	return false;
+#endif
+}
+
+int DeleteFilesAndDirsRecursive(const string& path)
+{
+#if SUPPORT_DIRECT_FILE_ACCESS && !UNITY_FLASH && !UNITY_WEBGL
+	int res;
+
+	struct stat status;
+	res = lstat(path.c_str(), &status);
+	if (res != 0)
+		return res;
+
+	if (S_ISDIR(status.st_mode) && !S_ISLNK(status.st_mode))
+	{
+		DIR *dirp = opendir (path.c_str());
+		if (dirp == NULL)
+			return -1;
+
+		struct dirent *dp;
+		while ( (dp = readdir(dirp)) )
+		{
+			if (strcmp(dp->d_name, ".") != 0 && strcmp(dp->d_name, "..") != 0)
+			{
+				string name = dp->d_name;
+				res = DeleteFilesAndDirsRecursive(AppendPathName (path, name));
+				if (res != 0)
+				{
+					closedir(dirp);
+					return res;
+				}
+			}
+		}
+		closedir(dirp);
+
+		res = rmdir(path.c_str());
+	}
+	else
+	{
+		res = unlink(path.c_str());
+	}
+
+	return res;
+#else
+	ErrorString("No file access allowed!");
+	return false;
+#endif
+}
+
+bool DeleteFileOrDirectory (const string& path)
+{
+	int res = DeleteFilesAndDirsRecursive(PathToAbsolutePath(path));
+	return res == 0;
+}
+
+bool ShouldIgnoreFile (const char* name, size_t length)
+{
+	AssertIf(!name);
+	if (length < 1)
+		return true;
+
+	// ignore hidden files
+	if (name[0] == '.')
+		return true;
+	// ignore CVS files
+	if (StrICmp(name, "cvs") == 0)
+		return true;
+
+	// ignore temporary and backup files
+	if ((name[length-1] == '~') || (length >= 4 && StrICmp(name + length - 4, ".tmp" ) == 0))
+		return true;
+
+	return false;
+}
+
+bool GetFolderContentsAtPath (const string& pathName, set<string>& paths)
+{
+#if SUPPORT_DIRECT_FILE_ACCESS && !UNITY_FLASH
+	string absolutePath = PathToAbsolutePath(pathName);
+	DIR *dirp;
+    struct dirent *dp;
+
+    if ((dirp = opendir(absolutePath.c_str())) == NULL)
+        return false;
+
+	while ( (dp = readdir(dirp)) )
+	{
+		if (strcmp(dp->d_name, ".") != 0 && strcmp(dp->d_name, "..") != 0)
+		{
+			if (!ShouldIgnoreFile (dp->d_name, strlen (dp->d_name)))
+			{
+				string name = dp->d_name;
+				paths.insert (AppendPathName (pathName, name));
+			}
+		}
+	}
+	closedir(dirp);
+	return true;
+#else
+	ErrorString("No file access allowed!");
+	return false;
+#endif
+}
+
+#if UNITY_EDITOR
+
+bool MoveReplaceFile (const string& fromPath, const string& toPath)
+{
+	if( IsDirectoryCreated(fromPath) )
+	{
+		ErrorString( Format("Path %s is a directory", fromPath.c_str()) );
+		return false;
+	}
+	while (true)
+	{
+		int error = rename( PathToAbsolutePath(fromPath).c_str(), PathToAbsolutePath(toPath).c_str() );
+		if( error == 0 )
+			return true;
+
+		int errorCode = errno;
+		if( errorCode == EXDEV )
+		{
+			DeleteFileOrDirectory(toPath);
+			if (CopyFileOrDirectory(fromPath, toPath))
+			{
+				if (DeleteFileOrDirectory(fromPath))
+					return true;
+			}
+		}
+
+		#if UNITY_EDITOR
+		int result = DisplayDialogComplex ("Moving file failed", GetFormattedFileError(errno, "Moving "+fromPath+" to "+toPath), "Try Again", "Cancel", "Force Quit");
+		if (result == 1)
+			return false;
+		else if (result == 2)
+			exit(1);
+		#else
+		return false;
+		#endif
+	}
+	return false;
+}
+
+#endif
+
+#if UNITY_OSX || UNITY_IPHONE
+bool File::Lock(File::LockMode mode, bool block)
+{
+	int fd = fileno (m_File);
+	return flock (fd, mode + (block?0:LOCK_NB) ) == 0;
+}
+
+#include <sys/resource.h>
+//Local testing and various internet sources suggest that this is the absolute maximim of open files OSX can hande.
+#define kMaxOpenFile 10240
+
+void SetupFileLimits ()
+{
+	struct rlimit limit;
+    limit.rlim_cur = kMaxOpenFile;
+    limit.rlim_max = kMaxOpenFile;
+    if (setrlimit(RLIMIT_NOFILE, &limit) != 0)
+		printf_console("setrlimit() failed with errno=%d\n", errno);
+}
+#endif