Renaming CrtFile* -> File*.

include/bx/crtimpl.h

@@ -25,7 +25,6 @@ namespace bx
 		virtual void* realloc(void* _ptr, size_t _size, size_t _align, const char* _file, uint32_t _line) BX_OVERRIDE;
 	};
 
-#if BX_CONFIG_CRT_FILE_READER_WRITER
 	///
 	ReaderI* getStdIn();
 
@@ -36,14 +35,14 @@ namespace bx
 	WriterI* getStdErr();
 
 	///
-	class CrtFileReader : public FileReaderI
+	class FileReader : public FileReaderI
 	{
 	public:
 		///
-		CrtFileReader();
+		FileReader();
 
 		///
-		virtual ~CrtFileReader();
+		virtual ~FileReader();
 
 		///
 		virtual bool open(const char* _filePath, Error* _err) BX_OVERRIDE;
@@ -62,14 +61,14 @@ namespace bx
 	};
 
 	///
-	class CrtFileWriter : public FileWriterI
+	class FileWriter : public FileWriterI
 	{
 	public:
 		///
-		CrtFileWriter();
+		FileWriter();
 
 		///
-		virtual ~CrtFileWriter();
+		virtual ~FileWriter();
 
 		///
 		virtual bool open(const char* _filePath, bool _append, Error* _err) BX_OVERRIDE;
@@ -86,9 +85,7 @@ namespace bx
 	private:
 		BX_ALIGN_DECL(16, uint8_t) m_internal[64];
 	};
-#endif // BX_CONFIG_CRT_FILE_READER_WRITER
 
-#if BX_CONFIG_CRT_PROCESS
 	///
 	class ProcessReader : public ReaderOpenI, public CloserI, public ReaderI
 	{
@@ -142,7 +139,6 @@ namespace bx
 		void* m_file;
 		int32_t m_exitCode;
 	};
-#endif // BX_CONFIG_CRT_PROCESS
 
 } // namespace bx
 

scripts/toolchain.lua

@@ -974,6 +974,9 @@ function toolchain(_buildDir, _libDir)
 			"-Wunused-value",
 			"-Wundef",
 		}
+		buildoptions_cpp {
+			"-std=c++11",
+		}
 
 	configuration { "freebsd" }
 		targetdir (path.join(_buildDir, "freebsd/bin"))
@@ -1173,13 +1176,9 @@ function toolchain(_buildDir, _libDir)
 			"$(SCE_ORBIS_SDK_DIR)/target/include",
 			"$(SCE_ORBIS_SDK_DIR)/target/include_common",
 		}
-		buildoptions {
-		}
 		buildoptions_cpp {
 			"-std=c++11",
 		}
-		linkoptions {
-		}
 
 	configuration { "qnx-arm" }
 		targetdir (path.join(_buildDir, "qnx-arm/bin"))

src/crtimpl.cpp

@@ -106,14 +106,14 @@ namespace bx
 
 			if (NULL != m_file)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "CrtFileReader: File is already open.");
+				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "FileReader: File is already open.");
 				return false;
 			}
 
 			m_file = fopen(_filePath, "rb");
 			if (NULL == m_file)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "CrtFileReader: Failed to open file.");
+				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "FileReader: Failed to open file.");
 				return false;
 			}
 
@@ -148,11 +148,11 @@ namespace bx
 			{
 				if (0 != feof(m_file) )
 				{
-					BX_ERROR_SET(_err, BX_ERROR_READERWRITER_EOF, "CrtFileReader: EOF.");
+					BX_ERROR_SET(_err, BX_ERROR_READERWRITER_EOF, "FileReader: EOF.");
 				}
 				else if (0 != ferror(m_file) )
 				{
-					BX_ERROR_SET(_err, BX_ERROR_READERWRITER_READ, "CrtFileReader: read error.");
+					BX_ERROR_SET(_err, BX_ERROR_READERWRITER_READ, "FileReader: read error.");
 				}
 
 				return size >= 0 ? size : 0;
@@ -166,48 +166,6 @@ namespace bx
 		bool  m_open;
 	};
 
-	ReaderI* getStdIn()
-	{
-		static FileReaderImpl s_stdIn(stdout);
-		return &s_stdIn;
-	}
-
-	CrtFileReader::CrtFileReader()
-	{
-		BX_STATIC_ASSERT(sizeof(FileReaderImpl) <= sizeof(m_internal) );
-		new(m_internal) FileReaderImpl(NULL);
-	}
-
-	CrtFileReader::~CrtFileReader()
-	{
-		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
-		impl->~FileReaderImpl();
-	}
-
-	bool CrtFileReader::open(const char* _filePath, Error* _err)
-	{
-		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
-		return impl->open(_filePath, _err);
-	}
-
-	void CrtFileReader::close()
-	{
-		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
-		impl->close();
-	}
-
-	int64_t CrtFileReader::seek(int64_t _offset, Whence::Enum _whence)
-	{
-		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
-		return impl->seek(_offset, _whence);
-	}
-
-	int32_t CrtFileReader::read(void* _data, int32_t _size, Error* _err)
-	{
-		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
-		return impl->read(_data, _size, _err);
-	}
-
 	class FileWriterImpl : public bx::FileWriterI
 	{
 	public:
@@ -228,7 +186,7 @@ namespace bx
 
 			if (NULL != m_file)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "CrtFileReader: File is already open.");
+				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "FileReader: File is already open.");
 				return false;
 			}
 
@@ -236,7 +194,7 @@ namespace bx
 
 			if (NULL == m_file)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "CrtFileWriter: Failed to open file.");
+				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "FileWriter: Failed to open file.");
 				return false;
 			}
 
@@ -268,7 +226,7 @@ namespace bx
 			int32_t size = (int32_t)fwrite(_data, 1, _size, m_file);
 			if (size != _size)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "CrtFileWriter: write failed.");
+				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "FileWriter: write failed.");
 				return size >= 0 ? size : 0;
 			}
 
@@ -280,54 +238,169 @@ namespace bx
 		bool  m_open;
 	};
 
-	WriterI* getStdOut()
+#else
+
+	class FileReaderImpl : public bx::FileReaderI
 	{
-		static FileWriterImpl s_stdOut(stdout);
-		return &s_stdOut;
+	public:
+		FileReaderImpl(void*)
+		{
+		}
+
+		virtual ~FileReaderImpl()
+		{
+			close();
+		}
+
+		virtual bool open(const char* _filePath, Error* _err) BX_OVERRIDE
+		{
+			BX_UNUSED(_filePath, _err);
+			return false;
+		}
+
+		virtual void close() BX_OVERRIDE
+		{
+		}
+
+		virtual int64_t seek(int64_t _offset, Whence::Enum _whence) BX_OVERRIDE
+		{
+			BX_UNUSED(_offset, _whence);
+			return 0;
+		}
+
+		virtual int32_t read(void* _data, int32_t _size, Error* _err) BX_OVERRIDE
+		{
+			BX_UNUSED(_data, _size, _err);
+			return 0;
+		}
+	};
+
+	class FileWriterImpl : public bx::FileWriterI
+	{
+	public:
+		FileWriterImpl(void*)
+		{
+		}
+
+		virtual ~FileWriterImpl()
+		{
+			close();
+		}
+
+		virtual bool open(const char* _filePath, bool _append, Error* _err) BX_OVERRIDE
+		{
+			BX_UNUSED(_filePath, _append);
+			return false;
+		}
+
+		virtual void close() BX_OVERRIDE
+		{
+		}
+
+		virtual int64_t seek(int64_t _offset, Whence::Enum _whence) BX_OVERRIDE
+		{
+			BX_UNUSED(_offset, _whence);
+			return 0;
+		}
+
+		virtual int32_t write(const void* _data, int32_t _size, Error* _err) BX_OVERRIDE
+		{
+			BX_UNUSED(_data, _size, _err);
+			return 0;
+		}
+	};
+
+#endif // BX_CONFIG_CRT_FILE_READER_WRITER
+
+	FileReader::FileReader()
+	{
+		BX_STATIC_ASSERT(sizeof(FileReaderImpl) <= sizeof(m_internal) );
+		new(m_internal) FileReaderImpl(NULL);
 	}
 
-	WriterI* getStdErr()
+	FileReader::~FileReader()
 	{
-		static FileWriterImpl s_stdOut(stderr);
-		return &s_stdOut;
+		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
+		impl->~FileReaderImpl();
 	}
 
-	CrtFileWriter::CrtFileWriter()
+	bool FileReader::open(const char* _filePath, Error* _err)
+	{
+		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
+		return impl->open(_filePath, _err);
+	}
+
+	void FileReader::close()
+	{
+		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
+		impl->close();
+	}
+
+	int64_t FileReader::seek(int64_t _offset, Whence::Enum _whence)
+	{
+		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
+		return impl->seek(_offset, _whence);
+	}
+
+	int32_t FileReader::read(void* _data, int32_t _size, Error* _err)
+	{
+		FileReaderImpl* impl = reinterpret_cast<FileReaderImpl*>(m_internal);
+		return impl->read(_data, _size, _err);
+	}
+
+	FileWriter::FileWriter()
 	{
 		BX_STATIC_ASSERT(sizeof(FileWriterImpl) <= sizeof(m_internal) );
 		new(m_internal) FileWriterImpl(NULL);
 	}
 
-	CrtFileWriter::~CrtFileWriter()
+	FileWriter::~FileWriter()
 	{
 		FileWriterImpl* impl = reinterpret_cast<FileWriterImpl*>(m_internal);
 		impl->~FileWriterImpl();
 	}
 
-	bool CrtFileWriter::open(const char* _filePath, bool _append, Error* _err)
+	bool FileWriter::open(const char* _filePath, bool _append, Error* _err)
 	{
 		FileWriterImpl* impl = reinterpret_cast<FileWriterImpl*>(m_internal);
 		return impl->open(_filePath, _append, _err);
 	}
 
-	void CrtFileWriter::close()
+	void FileWriter::close()
 	{
 		FileWriterImpl* impl = reinterpret_cast<FileWriterImpl*>(m_internal);
 		impl->close();
 	}
 
-	int64_t CrtFileWriter::seek(int64_t _offset, Whence::Enum _whence)
+	int64_t FileWriter::seek(int64_t _offset, Whence::Enum _whence)
 	{
 		FileWriterImpl* impl = reinterpret_cast<FileWriterImpl*>(m_internal);
 		return impl->seek(_offset, _whence);
 	}
 
-	int32_t CrtFileWriter::write(const void* _data, int32_t _size, Error* _err)
+	int32_t FileWriter::write(const void* _data, int32_t _size, Error* _err)
 	{
 		FileWriterImpl* impl = reinterpret_cast<FileWriterImpl*>(m_internal);
 		return impl->write(_data, _size, _err);
 	}
-#endif // BX_CONFIG_CRT_FILE_READER_WRITER
+
+	ReaderI* getStdIn()
+	{
+		static FileReaderImpl s_stdIn(stdout);
+		return &s_stdIn;
+	}
+
+	WriterI* getStdOut()
+	{
+		static FileWriterImpl s_stdOut(stdout);
+		return &s_stdOut;
+	}
+
+	WriterI* getStdErr()
+	{
+		static FileWriterImpl s_stdOut(stderr);
+		return &s_stdOut;
+	}
 
 #if BX_CONFIG_CRT_PROCESS
 

tools/bin2c/bin2c.cpp

@@ -149,7 +149,7 @@ int main(int _argc, const char* _argv[])
 	void* data = NULL;
 	uint32_t size = 0;
 
-	bx::CrtFileReader fr;
+	bx::FileReader fr;
 	if (bx::open(&fr, filePath) )
 	{
 		size = uint32_t(bx::getSize(&fr) );
@@ -158,7 +158,7 @@ int main(int _argc, const char* _argv[])
 		data = BX_ALLOC(&allocator, size);
 		bx::read(&fr, data, size);
 
-		bx::CrtFileWriter fw;
+		bx::FileWriter fw;
 		if (bx::open(&fw, outFilePath) )
 		{
 			Bin2cWriter writer(&fw, name);