Cleanup.

include/bx/error.h

@@ -8,8 +8,8 @@
 
 #include "string.h"
 
-#define BX_ERROR_SET(_ptr, _result, _msg) \
-			BX_MACRO_BLOCK_BEGIN \
+#define BX_ERROR_SET(_ptr, _result, _msg)            \
+			BX_MACRO_BLOCK_BEGIN                     \
 				(_ptr)->setError(_result,  "" _msg); \
 			BX_MACRO_BLOCK_END
 
@@ -17,13 +17,13 @@
 			const bx::Error tmpError; /* It should not be used directly! */ \
 			_ptr = NULL == _ptr ? const_cast<bx::Error*>(&tmpError) : _ptr
 
-#define BX_ERROR_SCOPE(_ptr) \
-			BX_ERROR_USE_TEMP_WHEN_NULL(_ptr); \
+#define BX_ERROR_SCOPE(_ptr)                                              \
+			BX_ERROR_USE_TEMP_WHEN_NULL(_ptr);                            \
 			bx::ErrorScope bxErrorScope(const_cast<bx::Error*>(&tmpError) )
 
-#define BX_ERROR_RESULT(_err, _code) \
+#define BX_ERROR_RESULT(_err, _code)                                  \
 			BX_STATIC_ASSERT(_code != 0, "ErrorCode 0 is reserved!"); \
-			static const bx::ErrorResult _err = { _code }
+			static constexpr bx::ErrorResult _err = { _code }
 
 namespace bx
 {

include/bx/filepath.h

@@ -9,11 +9,11 @@
 #include "error.h"
 #include "string.h"
 
-BX_ERROR_RESULT(BX_ERROR_ACCESS,        BX_MAKEFOURCC('b', 'x', 0, 0) );
-BX_ERROR_RESULT(BX_ERROR_NOT_DIRECTORY, BX_MAKEFOURCC('b', 'x', 0, 1) );
-
 namespace bx
 {
+	BX_ERROR_RESULT(kErrorAccess,       BX_MAKEFOURCC('b', 'x', 1, 1) );
+	BX_ERROR_RESULT(kErrorNotDirectory, BX_MAKEFOURCC('b', 'x', 1, 2) );
+
 	constexpr int32_t kMaxFilePath = 1024;
 
 	/// Special predefined OS directories.

include/bx/inline/readerwriter.inl

@@ -132,7 +132,7 @@ namespace bx
 		m_pos += size;
 		if (size != _size)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "SizerWriter: write truncated.");
+			BX_ERROR_SET(_err, kErrorReaderWriterWrite, "SizerWriter: write truncated.");
 		}
 		return size;
 	}
@@ -178,7 +178,7 @@ namespace bx
 		m_pos += size;
 		if (size != _size)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_READ, "MemoryReader: read truncated.");
+			BX_ERROR_SET(_err, kErrorReaderWriterRead, "MemoryReader: read truncated.");
 		}
 		return size;
 	}
@@ -251,7 +251,7 @@ namespace bx
 		m_top = max(m_top, m_pos);
 		if (size != _size)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "MemoryWriter: write truncated.");
+			BX_ERROR_SET(_err, kErrorReaderWriterWrite, "MemoryWriter: write truncated.");
 		}
 		return size;
 	}
@@ -422,7 +422,7 @@ namespace bx
 			const int64_t offset  = bx::seek(_reader, size);
 			if (offset != aligned)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "Align: read truncated.");
+				BX_ERROR_SET(_err, kErrorReaderWriterWrite, "Align: read truncated.");
 			}
 			return int32_t(offset - current);
 		}

include/bx/readerwriter.h

@@ -14,14 +14,14 @@
 #include "string.h"
 #include "uint32_t.h"
 
-BX_ERROR_RESULT(BX_ERROR_READERWRITER_OPEN,         BX_MAKEFOURCC('R', 'W', 0, 1) );
-BX_ERROR_RESULT(BX_ERROR_READERWRITER_READ,         BX_MAKEFOURCC('R', 'W', 0, 2) );
-BX_ERROR_RESULT(BX_ERROR_READERWRITER_WRITE,        BX_MAKEFOURCC('R', 'W', 0, 3) );
-BX_ERROR_RESULT(BX_ERROR_READERWRITER_EOF,          BX_MAKEFOURCC('R', 'W', 0, 4) );
-BX_ERROR_RESULT(BX_ERROR_READERWRITER_ALREADY_OPEN, BX_MAKEFOURCC('R', 'W', 0, 5) );
-
 namespace bx
 {
+	BX_ERROR_RESULT(kErrorReaderWriterOpen,        BX_MAKEFOURCC('b', 'x', 2, 1) );
+	BX_ERROR_RESULT(kErrorReaderWriterRead,        BX_MAKEFOURCC('b', 'x', 2, 2) );
+	BX_ERROR_RESULT(kErrorReaderWriterWrite,       BX_MAKEFOURCC('b', 'x', 2, 3) );
+	BX_ERROR_RESULT(kErrorReaderWriterEof,         BX_MAKEFOURCC('b', 'x', 2, 4) );
+	BX_ERROR_RESULT(kErrorReaderWriterAlreadyOpen, BX_MAKEFOURCC('b', 'x', 2, 5) );
+
 	/// The position from where offset is added.
 	struct Whence
 	{

src/file.cpp

@@ -104,14 +104,14 @@ namespace bx
 
 			if (NULL != m_file)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "FileReader: File is already open.");
+				BX_ERROR_SET(_err, kErrorReaderWriterAlreadyOpen, "FileReader: File is already open.");
 				return false;
 			}
 
 			m_file = fopen(_filePath.getCPtr(), "rb");
 			if (NULL == m_file)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "FileReader: Failed to open file.");
+				BX_ERROR_SET(_err, kErrorReaderWriterOpen, "FileReader: Failed to open file.");
 				return false;
 			}
 
@@ -146,11 +146,11 @@ namespace bx
 			{
 				if (0 != feof(m_file) )
 				{
-					BX_ERROR_SET(_err, BX_ERROR_READERWRITER_EOF, "FileReader: EOF.");
+					BX_ERROR_SET(_err, kErrorReaderWriterEof, "FileReader: EOF.");
 				}
 				else if (0 != ferror(m_file) )
 				{
-					BX_ERROR_SET(_err, BX_ERROR_READERWRITER_READ, "FileReader: read error.");
+					BX_ERROR_SET(_err, kErrorReaderWriterRead, "FileReader: read error.");
 				}
 
 				return size >= 0 ? size : 0;
@@ -184,7 +184,7 @@ namespace bx
 
 			if (NULL != m_file)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "FileReader: File is already open.");
+				BX_ERROR_SET(_err, kErrorReaderWriterAlreadyOpen, "FileReader: File is already open.");
 				return false;
 			}
 
@@ -192,7 +192,7 @@ namespace bx
 
 			if (NULL == m_file)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "FileWriter: Failed to open file.");
+				BX_ERROR_SET(_err, kErrorReaderWriterOpen, "FileWriter: Failed to open file.");
 				return false;
 			}
 
@@ -225,7 +225,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, "FileWriter: write failed.");
+				BX_ERROR_SET(_err, kErrorReaderWriterWrite, "FileWriter: write failed.");
 				return size >= 0 ? size : 0;
 			}
 
@@ -276,7 +276,7 @@ namespace bx
 
 			if (0 != m_fd)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "FileReader: File is already open.");
+				BX_ERROR_SET(_err, kErrorReaderWriterAlreadyOpen, "FileReader: File is already open.");
 				return false;
 			}
 
@@ -284,7 +284,7 @@ namespace bx
 
 			if (0 >= m_fd)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "FileReader: Failed to open file.");
+				BX_ERROR_SET(_err, kErrorReaderWriterOpen, "FileReader: Failed to open file.");
 				return false;
 			}
 
@@ -319,11 +319,11 @@ namespace bx
 				BX_UNUSED(_err);
 //				if (0 != feof(m_file) )
 //				{
-//					BX_ERROR_SET(_err, BX_ERROR_READERWRITER_EOF, "FileReader: EOF.");
+//					BX_ERROR_SET(_err, kErrorReaderWriterEof, "FileReader: EOF.");
 //				}
 //				else if (0 != ferror(m_file) )
 //				{
-//					BX_ERROR_SET(_err, BX_ERROR_READERWRITER_READ, "FileReader: read error.");
+//					BX_ERROR_SET(_err, kErrorReaderWriterRead, "FileReader: read error.");
 //				}
 
 				return size >= 0 ? size : 0;
@@ -357,7 +357,7 @@ namespace bx
 
 			if (0 != m_fd)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "FileReader: File is already open.");
+				BX_ERROR_SET(_err, kErrorReaderWriterAlreadyOpen, "FileReader: File is already open.");
 				return false;
 			}
 
@@ -365,7 +365,7 @@ namespace bx
 
 			if (0 >= m_fd)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "FileWriter: Failed to open file.");
+				BX_ERROR_SET(_err, kErrorReaderWriterOpen, "FileWriter: Failed to open file.");
 				return false;
 			}
 
@@ -397,7 +397,7 @@ namespace bx
 			int32_t size = crt0::write(m_fd, _data, _size);
 			if (size != _size)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "FileWriter: write failed.");
+				BX_ERROR_SET(_err, kErrorReaderWriterWrite, "FileWriter: write failed.");
 				return size >= 0 ? size : 0;
 			}
 
@@ -588,7 +588,7 @@ namespace bx
 
 			if (NULL == m_dir)
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "DirectoryReader: Failed to open directory.");
+				BX_ERROR_SET(_err, kErrorReaderWriterOpen, "DirectoryReader: Failed to open directory.");
 				return false;
 			}
 
@@ -620,7 +620,7 @@ namespace bx
 				{
 					if (!fetch(m_cache, m_dir) )
 					{
-						BX_ERROR_SET(_err, BX_ERROR_READERWRITER_EOF, "DirectoryReader: EOF.");
+						BX_ERROR_SET(_err, kErrorReaderWriterEof, "DirectoryReader: EOF.");
 						return total;
 					}
 				}
@@ -690,7 +690,7 @@ namespace bx
 		virtual bool open(const FilePath& _filePath, Error* _err) override
 		{
 			BX_UNUSED(_filePath);
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "DirectoryReader: Failed to open directory.");
+			BX_ERROR_SET(_err, kErrorReaderWriterOpen, "DirectoryReader: Failed to open directory.");
 			return false;
 		}
 
@@ -702,7 +702,7 @@ namespace bx
 		{
 			BX_UNUSED(_data, _size);
 			BX_ASSERT(NULL != _err, "Reader/Writer interface calling functions must handle errors.");
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_EOF, "DirectoryReader: EOF.");
+			BX_ERROR_SET(_err, kErrorReaderWriterEof, "DirectoryReader: EOF.");
 			return 0;
 		}
 	};
@@ -811,7 +811,7 @@ namespace bx
 
 		if (0 != result)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_ACCESS, "The parent directory does not allow write permission to the process.");
+			BX_ERROR_SET(_err, kErrorAccess, "The parent directory does not allow write permission to the process.");
 			return false;
 		}
 
@@ -836,7 +836,7 @@ namespace bx
 				return true;
 			}
 
-			BX_ERROR_SET(_err, BX_ERROR_NOT_DIRECTORY, "File already exist, and is not directory.");
+			BX_ERROR_SET(_err, kErrorNotDirectory, "File already exist, and is not directory.");
 			return false;
 		}
 
@@ -888,7 +888,7 @@ namespace bx
 
 		if (0 != result)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_ACCESS, "The parent directory does not allow write permission to the process.");
+			BX_ERROR_SET(_err, kErrorAccess, "The parent directory does not allow write permission to the process.");
 			return false;
 		}
 
@@ -910,13 +910,13 @@ namespace bx
 
 		if (!stat(fi, _filePath) )
 		{
-			BX_ERROR_SET(_err, BX_ERROR_ACCESS, "The parent directory does not allow write permission to the process.");
+			BX_ERROR_SET(_err, kErrorAccess, "The parent directory does not allow write permission to the process.");
 			return false;
 		}
 
 		if (FileType::Dir != fi.type)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_NOT_DIRECTORY, "File already exist, and is not directory.");
+			BX_ERROR_SET(_err, kErrorNotDirectory, "File already exist, and is not directory.");
 			return false;
 		}
 
@@ -925,7 +925,7 @@ namespace bx
 
 		if (!bx::open(&dr, _filePath) )
 		{
-			BX_ERROR_SET(_err, BX_ERROR_NOT_DIRECTORY, "File already exist, and is not directory.");
+			BX_ERROR_SET(_err, kErrorNotDirectory, "File already exist, and is not directory.");
 			return false;
 		}
 

src/process.cpp

@@ -43,7 +43,7 @@ namespace bx
 
 		if (NULL != m_file)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "ProcessReader: File is already open.");
+			BX_ERROR_SET(_err, kErrorReaderWriterAlreadyOpen, "ProcessReader: File is already open.");
 			return false;
 		}
 
@@ -55,7 +55,7 @@ namespace bx
 		m_file = popen(tmp, "r");
 		if (NULL == m_file)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "ProcessReader: Failed to open process.");
+			BX_ERROR_SET(_err, kErrorReaderWriterOpen, "ProcessReader: Failed to open process.");
 			return false;
 		}
 
@@ -80,11 +80,11 @@ namespace bx
 		{
 			if (0 != feof(file) )
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_EOF, "ProcessReader: EOF.");
+				BX_ERROR_SET(_err, kErrorReaderWriterEof, "ProcessReader: EOF.");
 			}
 			else if (0 != ferror(file) )
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_READ, "ProcessReader: read error.");
+				BX_ERROR_SET(_err, kErrorReaderWriterRead, "ProcessReader: read error.");
 			}
 
 			return size >= 0 ? size : 0;
@@ -114,7 +114,7 @@ namespace bx
 
 		if (NULL != m_file)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_ALREADY_OPEN, "ProcessWriter: File is already open.");
+			BX_ERROR_SET(_err, kErrorReaderWriterAlreadyOpen, "ProcessWriter: File is already open.");
 			return false;
 		}
 
@@ -126,7 +126,7 @@ namespace bx
 		m_file = popen(tmp, "w");
 		if (NULL == m_file)
 		{
-			BX_ERROR_SET(_err, BX_ERROR_READERWRITER_OPEN, "ProcessWriter: Failed to open process.");
+			BX_ERROR_SET(_err, kErrorReaderWriterOpen, "ProcessWriter: Failed to open process.");
 			return false;
 		}
 
@@ -151,7 +151,7 @@ namespace bx
 		{
 			if (0 != ferror(file) )
 			{
-				BX_ERROR_SET(_err, BX_ERROR_READERWRITER_WRITE, "ProcessWriter: write error.");
+				BX_ERROR_SET(_err, kErrorReaderWriterWrite, "ProcessWriter: write error.");
 			}
 
 			return size >= 0 ? size : 0;