libAthena
/
athena
mirror of https://github.com/libAthena/athena.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Squash MSVC warnings 

Unify filename usage
This commit is contained in:
Phillip 2015-11-13 21:53:13 -08:00
parent b6b54d0921
commit 63a58265ef
9 changed files with 273 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/Athena/DNAYaml.hpp
View File

@ -903,7 +903,7 @@ public:
}
template <typename INTYPE>
void writeVal(const char* name, INTYPE val)
void writeVal(const char* name, const INTYPE& val)
{
YAMLNode* curSub = m_subStack.back();
if (curSub->m_type == YAML_MAPPING_NODE)
@ -913,7 +913,7 @@ public:
}
template <typename INTYPE>
void writeVal(const char* name, INTYPE val, size_t byteCount)
void writeVal(const char* name, const INTYPE& val, size_t byteCount)
{
YAMLNode* curSub = m_subStack.back();
if (curSub->m_type == YAML_MAPPING_NODE)

29
include/Athena/FileReader.hpp
View File

@ -14,12 +14,26 @@ class FileReader : public IStreamReader
{
public:
FileReader(const std::string& filename, atInt32 cacheSize = (32 * 1024));
#if _WIN32
FileReader(const std::wstring& filename, atInt32 cacheSize = (32 * 1024));
#endif
virtual ~FileReader();
inline const std::string& filename() const
{return m_filename;}
inline std::string filename() const
{
#if _WIN32
return utility::wideToUtf8(m_filename);
#else
return m_filename;
#endif
}
inline std::wstring wfilename() const
{
#if _WIN32
return m_filename;
#else
return utility::utf8ToWide(m_filename);
#endif
}
void open();
void close();
@ -34,13 +48,14 @@ public:
void setCacheSize(const atInt32 blockSize);
FILE* _fileHandle() {return m_fileHandle;}
protected:
std::string m_filename;
#if _WIN32
std::wstring m_wfilename;
std::wstring m_filename;
#else
std::string m_filename;
#endif
FILE* m_fileHandle;
std::unique_ptr<atUint8[]> m_cacheData;
atInt32 m_blockSize;
atInt32 m_blockSize;
atInt32 m_curBlock;
atUint64 m_offset;
};

24
include/Athena/FileWriter.hpp
View File

@ -12,11 +12,26 @@ class FileWriter : public IStreamWriter
{
public:
FileWriter(const std::string& filename, bool overwrite = true);
#if _WIN32
FileWriter(const std::wstring& filename, bool overwrite = true);
#endif
virtual ~FileWriter();
inline std::string filename() const
{
#if _WIN32
return utility::wideToUtf8(m_filename);
#else
return m_filename;
#endif
}
inline std::wstring wfilename() const
{
#if _WIN32
return m_filename;
#else
return utility::utf8ToWide(m_filename);
#endif
}
void open(bool overwrite = true);
void close();
inline bool isOpen() const
@ -28,9 +43,10 @@ public:
FILE* _fileHandle() {return m_fileHandle;}
private:
std::string m_filename;
#if _WIN32
std::wstring m_wfilename;
std::wstring m_filename;
#else
std::string m_filename;
#endif
FILE* m_fileHandle;
atUint8 m_currentByte;

270
include/Athena/IStreamWriter.hpp
View File

@ -383,306 +383,324 @@ public:
*
* @param vec The value to write to the buffer
*/
inline void writeVec2f(atVec2f vec)
inline void writeVec2f(const atVec2f& vec)
{
atVec2f tmp = vec;
if (m_endian == BigEndian)
{
utility::BigFloat(vec.vec[0]);
utility::BigFloat(vec.vec[1]);
utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]);
}
else
{
utility::LittleFloat(vec.vec[0]);
utility::LittleFloat(vec.vec[1]);
utility::LittleFloat(tmp.vec[0]);
utility::LittleFloat(tmp.vec[1]);
}
writeUBytes((atUint8*)&vec, 8);
writeUBytes((atUint8*)&tmp, 8);
}
inline void writeVal(atVec2f val) {writeVec2f(val);}
inline void writeVal(const atVec2f& val) {writeVec2f(val);}
/** @brief Writes an atVec2f (8 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec2fLittle(atVec2f vec)
inline void writeVec2fLittle(const atVec2f& vec)
{
utility::LittleFloat(vec.vec[0]);
utility::LittleFloat(vec.vec[1]);
writeUBytes((atUint8*)&vec, 8);
atVec2f tmp = vec;
utility::LittleFloat(tmp.vec[0]);
utility::LittleFloat(tmp.vec[1]);
writeUBytes((atUint8*)&tmp, 8);
}
inline void writeValLittle(atVec2f val) {writeVec2fLittle(val);}
inline void writeValLittle(const atVec2f& val) {writeVec2fLittle(val);}
/** @brief Writes an atVec2f (8 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec2fBig(atVec2f vec)
inline void writeVec2fBig(const atVec2f& vec)
{
utility::BigFloat(vec.vec[0]);
utility::BigFloat(vec.vec[1]);
writeUBytes((atUint8*)&vec, 8);
atVec2f tmp = vec;
utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]);
writeUBytes((atUint8*)&tmp, 8);
}
inline void writeValBig(atVec2f val) {writeVec2fBig(val);}
inline void writeValBig(const atVec2f& val) {writeVec2fBig(val);}
/** @brief Writes an atVec3f (12 bytes) to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings.
*
* @param vec The value to write to the buffer
*/
inline void writeVec3f(atVec3f vec)
inline void writeVec3f(const atVec3f& vec)
{
atVec3f tmp = vec;
if (m_endian == BigEndian)
{
utility::BigFloat(vec.vec[0]);
utility::BigFloat(vec.vec[1]);
utility::BigFloat(vec.vec[2]);
utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]);
utility::BigFloat(tmp.vec[2]);
}
else
{
utility::LittleFloat(vec.vec[0]);
utility::LittleFloat(vec.vec[1]);
utility::LittleFloat(vec.vec[2]);
utility::LittleFloat(tmp.vec[0]);
utility::LittleFloat(tmp.vec[1]);
utility::LittleFloat(tmp.vec[2]);
}
writeUBytes((atUint8*)&vec, 12);
writeUBytes((atUint8*)&tmp, 12);
}
inline void writeVal(atVec3f val) {writeVec3f(val);}
inline void writeVal(const atVec3f& val) {writeVec3f(val);}
/** @brief Writes an atVec3f (12 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec3fLittle(atVec3f vec)
inline void writeVec3fLittle(const atVec3f& vec)
{
utility::LittleFloat(vec.vec[0]);
utility::LittleFloat(vec.vec[1]);
utility::LittleFloat(vec.vec[2]);
writeUBytes((atUint8*)&vec, 12);
atVec3f tmp = vec;
utility::LittleFloat(tmp.vec[0]);
utility::LittleFloat(tmp.vec[1]);
utility::LittleFloat(tmp.vec[2]);
writeUBytes((atUint8*)&tmp, 12);
}
inline void writeValLittle(atVec3f val) {writeVec3fLittle(val);}
inline void writeValLittle(const atVec3f& val) {writeVec3fLittle(val);}
/** @brief Writes an atVec3f (12 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec3fBig(atVec3f vec)
inline void writeVec3fBig(const atVec3f& vec)
{
utility::BigFloat(vec.vec[0]);
utility::BigFloat(vec.vec[1]);
utility::BigFloat(vec.vec[2]);
writeUBytes((atUint8*)&vec, 12);
atVec3f tmp = vec;
utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]);
utility::BigFloat(tmp.vec[2]);
writeUBytes((atUint8*)&tmp, 12);
}
inline void writeValBig(atVec3f val) {writeVec3fBig(val);}
inline void writeValBig(const atVec3f& val) {writeVec3fBig(val);}
/** @brief Writes an atVec4f (16 bytes) to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings.
*
* @param vec The value to write to the buffer
*/
inline void writeVec4f(atVec4f vec)
inline void writeVec4f(const atVec4f& vec)
{
atVec4f tmp = vec;
if (m_endian == BigEndian)
{
utility::BigFloat(vec.vec[0]);
utility::BigFloat(vec.vec[1]);
utility::BigFloat(vec.vec[2]);
utility::BigFloat(vec.vec[3]);
utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]);
utility::BigFloat(tmp.vec[2]);
utility::BigFloat(tmp.vec[3]);
}
else
{
utility::LittleFloat(vec.vec[0]);
utility::LittleFloat(vec.vec[1]);
utility::LittleFloat(vec.vec[2]);
utility::LittleFloat(vec.vec[3]);
utility::LittleFloat(tmp.vec[0]);
utility::LittleFloat(tmp.vec[1]);
utility::LittleFloat(tmp.vec[2]);
utility::LittleFloat(tmp.vec[3]);
}
writeUBytes((atUint8*)&vec, 16);
writeUBytes((atUint8*)&tmp, 16);
}
inline void writeVal(atVec4f val) {writeVec4f(val);}
inline void writeVal(const atVec4f& val) {writeVec4f(val);}
/** @brief Writes an atVec4f (16 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec4fLittle(atVec4f vec)
inline void writeVec4fLittle(const atVec4f& vec)
{
utility::LittleFloat(vec.vec[0]);
utility::LittleFloat(vec.vec[1]);
utility::LittleFloat(vec.vec[2]);
utility::LittleFloat(vec.vec[3]);
writeUBytes((atUint8*)&vec, 16);
atVec4f tmp = vec;
utility::LittleFloat(tmp.vec[0]);
utility::LittleFloat(tmp.vec[1]);
utility::LittleFloat(tmp.vec[2]);
utility::LittleFloat(tmp.vec[3]);
writeUBytes((atUint8*)&tmp, 16);
}
inline void writeValLittle(atVec4f val) {writeVec4fLittle(val);}
inline void writeValLittle(const atVec4f& val) {writeVec4fLittle(val);}
/** @brief Writes an atVec4f (16 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec4fBig(atVec4f vec)
inline void writeVec4fBig(const atVec4f& vec)
{
utility::BigFloat(vec.vec[0]);
utility::BigFloat(vec.vec[1]);
utility::BigFloat(vec.vec[2]);
utility::BigFloat(vec.vec[3]);
writeUBytes((atUint8*)&vec, 16);
atVec4f tmp = vec;
utility::BigFloat(tmp.vec[0]);
utility::BigFloat(tmp.vec[1]);
utility::BigFloat(tmp.vec[2]);
utility::BigFloat(tmp.vec[3]);
writeUBytes((atUint8*)&tmp, 16);
}
inline void writeValBig(atVec4f val) {writeVec4fBig(val);}
inline void writeValBig(const atVec4f& val) {writeVec4fBig(val);}
/** @brief Writes an atVec2d (16 bytes) to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings.
*
* @param vec The value to write to the buffer
*/
inline void writeVec2d(atVec2d vec)
inline void writeVec2d(const atVec2d& vec)
{
atVec2d tmp = vec;
if (m_endian == BigEndian)
{
utility::BigDouble(vec.vec[0]);
utility::BigDouble(vec.vec[1]);
utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]);
}
else
{
utility::LittleDouble(vec.vec[0]);
utility::LittleDouble(vec.vec[1]);
utility::LittleDouble(tmp.vec[0]);
utility::LittleDouble(tmp.vec[1]);
}
writeUBytes((atUint8*)&vec, 16);
writeUBytes((atUint8*)&tmp, 16);
}
inline void writeVal(atVec2d val) {writeVec2d(val);}
inline void writeVal(const atVec2d& val) {writeVec2d(val);}
/** @brief Writes an atVec2d (16 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec2dLittle(atVec2d vec)
inline void writeVec2dLittle(const atVec2d& vec)
{
utility::LittleDouble(vec.vec[0]);
utility::LittleDouble(vec.vec[1]);
writeUBytes((atUint8*)&vec, 16);
atVec2d tmp = vec;
utility::LittleDouble(tmp.vec[0]);
utility::LittleDouble(tmp.vec[1]);
writeUBytes((atUint8*)&tmp, 16);
}
inline void writeValLittle(atVec2d val) {writeVec2dLittle(val);}
inline void writeValLittle(const atVec2d& val) {writeVec2dLittle(val);}
/** @brief Writes an atVec2d (16 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec2dBig(atVec2d vec)
inline void writeVec2dBig(const atVec2d& vec)
{
utility::BigDouble(vec.vec[0]);
utility::BigDouble(vec.vec[1]);
writeUBytes((atUint8*)&vec, 16);
atVec2d tmp = vec;
utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]);
writeUBytes((atUint8*)&tmp, 16);
}
inline void writeValBig(atVec2d val) {writeVec2dBig(val);}
inline void writeValBig(const atVec2d& val) {writeVec2dBig(val);}
/** @brief Writes an atVec3d (24 bytes) to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings.
*
* @param vec The value to write to the buffer
*/
inline void writeVec3d(atVec3d vec)
inline void writeVec3d(const atVec3d& vec)
{
atVec3d tmp = vec;
if (m_endian == BigEndian)
{
utility::BigDouble(vec.vec[0]);
utility::BigDouble(vec.vec[1]);
utility::BigDouble(vec.vec[2]);
utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]);
utility::BigDouble(tmp.vec[2]);
}
else
{
utility::LittleDouble(vec.vec[0]);
utility::LittleDouble(vec.vec[1]);
utility::LittleDouble(vec.vec[2]);
utility::LittleDouble(tmp.vec[0]);
utility::LittleDouble(tmp.vec[1]);
utility::LittleDouble(tmp.vec[2]);
}
writeUBytes((atUint8*)&vec, 24);
writeUBytes((atUint8*)&tmp, 24);
}
inline void writeVal(atVec3d val) {writeVec3d(val);}
inline void writeVal(const atVec3d& val) {writeVec3d(val);}
/** @brief Writes an atVec3d (24 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec3dLittle(atVec3d vec)
inline void writeVec3dLittle(const atVec3d& vec)
{
utility::LittleDouble(vec.vec[0]);
utility::LittleDouble(vec.vec[1]);
utility::LittleDouble(vec.vec[2]);
writeUBytes((atUint8*)&vec, 24);
atVec3d tmp = vec;
utility::LittleDouble(tmp.vec[0]);
utility::LittleDouble(tmp.vec[1]);
utility::LittleDouble(tmp.vec[2]);
writeUBytes((atUint8*)&tmp, 24);
}
inline void writeValLittle(atVec3d val) {writeVec3dLittle(val);}
inline void writeValLittle(const atVec3d& val) {writeVec3dLittle(val);}
/** @brief Writes an atVec3d (24 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec3dBig(atVec3d vec)
inline void writeVec3dBig(const atVec3d& vec)
{
utility::BigDouble(vec.vec[0]);
utility::BigDouble(vec.vec[1]);
utility::BigDouble(vec.vec[2]);
writeUBytes((atUint8*)&vec, 24);
atVec3d tmp = vec;
utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]);
utility::BigDouble(tmp.vec[2]);
writeUBytes((atUint8*)&tmp, 24);
}
inline void writeValBig(atVec3d val) {writeVec3dBig(val);}
inline void writeValBig(const atVec3d& val) {writeVec3dBig(val);}
/** @brief Writes an atVec4d (32 bytes) to the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings.
*
* @param vec The value to write to the buffer
*/
inline void writeVec4d(atVec4d vec)
inline void writeVec4d(const atVec4d& vec)
{
atVec4d tmp = vec;
if (m_endian == BigEndian)
{
utility::BigDouble(vec.vec[0]);
utility::BigDouble(vec.vec[1]);
utility::BigDouble(vec.vec[2]);
utility::BigDouble(vec.vec[3]);
utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]);
utility::BigDouble(tmp.vec[2]);
utility::BigDouble(tmp.vec[3]);
}
else
{
utility::LittleDouble(vec.vec[0]);
utility::LittleDouble(vec.vec[1]);
utility::LittleDouble(vec.vec[2]);
utility::LittleDouble(vec.vec[3]);
utility::LittleDouble(tmp.vec[0]);
utility::LittleDouble(tmp.vec[1]);
utility::LittleDouble(tmp.vec[2]);
utility::LittleDouble(tmp.vec[3]);
}
writeUBytes((atUint8*)&vec, 32);
writeUBytes((atUint8*)&tmp, 32);
}
inline void writeVal(atVec4d val) {writeVec4d(val);}
inline void writeVal(const atVec4d& val) {writeVec4d(val);}
/** @brief Writes an atVec4d (32 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against little depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec4dLittle(atVec4d vec)
inline void writeVec4dLittle(const atVec4d& vec)
{
utility::LittleDouble(vec.vec[0]);
utility::LittleDouble(vec.vec[1]);
utility::LittleDouble(vec.vec[2]);
utility::LittleDouble(vec.vec[3]);
writeUBytes((atUint8*)&vec, 32);
atVec4d tmp = vec;
utility::LittleDouble(tmp.vec[0]);
utility::LittleDouble(tmp.vec[1]);
utility::LittleDouble(tmp.vec[2]);
utility::LittleDouble(tmp.vec[3]);
writeUBytes((atUint8*)&tmp, 32);
}
inline void writeValLittle(atVec4d val) {writeVec4dLittle(val);}
inline void writeValLittle(const atVec4d& val) {writeVec4dLittle(val);}
/** @brief Writes an atVec4d (32 bytes) to the buffer and advances the buffer.
* It also swaps the bytes against big depending on the platform.
*
* @param vec The value to write to the buffer
*/
inline void writeVec4dBig(atVec4d vec)
inline void writeVec4dBig(const atVec4d& vec)
{
utility::BigDouble(vec.vec[0]);
utility::BigDouble(vec.vec[1]);
utility::BigDouble(vec.vec[2]);
utility::BigDouble(vec.vec[3]);
writeUBytes((atUint8*)&vec, 32);
atVec4d tmp = vec;
utility::BigDouble(tmp.vec[0]);
utility::BigDouble(tmp.vec[1]);
utility::BigDouble(tmp.vec[2]);
utility::BigDouble(tmp.vec[3]);
writeUBytes((atUint8*)&tmp, 32);
}
inline void writeValBig(atVec4d val) {writeVec4dBig(val);}
inline void writeValBig(const atVec4d& val) {writeVec4dBig(val);}
/** @brief Converts a UTF8 string to a wide-char string in the buffer and advances the buffer.
* It also swaps the bytes depending on the platform and Stream settings.

2
include/Athena/Types.hpp
View File

@ -58,7 +58,7 @@ void* operator new[](size_t bytes) noexcept \
void operator delete(void* buf) noexcept \
{_mm_free(buf);} \
void operator delete[](void* buf) noexcept \
{_mm_free(buf);} \
{_mm_free(buf);}
typedef union alignas(16)
{

5
include/Athena/Utility.hpp
View File

@ -208,6 +208,11 @@ std::string& rtrim(std::string& s);
// trim from both ends
std::string& trim(std::string& s);
atUint64 fileSize(const std::string& filename);
std::string wideToUtf8(const std::wstring& src);
std::wstring utf8ToWide(const std::string& src);
} // utility
} // Athena
#endif

29
src/Athena/FileReader.cpp
View File

@ -14,26 +14,32 @@ namespace Athena
namespace io
{
FileReader::FileReader(const std::string& filename, atInt32 cacheSize)
: m_filename(filename),
m_fileHandle(nullptr),
: m_fileHandle(nullptr),
m_cacheData(nullptr),
m_offset(0)
{
#if _WIN32
m_filename = utility::utf8ToWide(filename);
#else
m_filename = fiename;
#endif
open();
setCacheSize(cacheSize);
}
#if _WIN32
FileReader::FileReader(const std::wstring& filename, atInt32 cacheSize)
: m_wfilename(filename),
m_fileHandle(nullptr),
: m_fileHandle(nullptr),
m_cacheData(nullptr),
m_offset(0)
{
#if _WIN32
m_filename = filename;
#else
m_filename = utility::wideToUtf8(filename);
#endif
open();
setCacheSize(cacheSize);
}
#endif
FileReader::~FileReader()
{
@ -44,17 +50,14 @@ FileReader::~FileReader()
void FileReader::open()
{
#if _WIN32
if (m_wfilename.size())
m_fileHandle = _wfopen(m_wfilename.c_str(), L"rb");
else
m_fileHandle = fopen(m_filename.c_str(), "rb");
m_fileHandle = _wfopen(m_filename.c_str(), L"rb");
#else
m_fileHandle = fopen(m_filename.c_str(), "rb");
#endif
if (!m_fileHandle)
{
atError("File not found '%s'", m_filename.c_str());
atError("File not found '%s'", filename());
setError();
return;
}
@ -136,7 +139,11 @@ atUint64 FileReader::length() const
return 0;
}
#if _WIN32
return utility::fileSize(utility::wideToUtf8(m_filename));
#else
return utility::fileSize(m_filename);
#endif
}
atUint64 FileReader::readUBytesToBuf(void* buf, atUint64 len)

46
src/Athena/FileWriter.cpp
View File

@ -14,22 +14,28 @@ namespace Athena
namespace io
{
FileWriter::FileWriter(const std::string& filename, bool overwrite)
: m_filename(filename),
m_fileHandle(NULL),
: m_fileHandle(NULL),
m_bytePosition(0)
{
#if _WIN32
m_filename = utility::utf8ToWide(filename);
#else
m_filename = fiename;
#endif
open(overwrite);
}
#if _WIN32
FileWriter::FileWriter(const std::wstring& filename, bool overwrite)
: m_wfilename(filename),
m_fileHandle(NULL),
m_bytePosition(0)
: m_fileHandle(NULL),
m_bytePosition(0)
{
#if _WIN32
m_filename = filename;
#else
m_filename = utility::wideToUtf8(filename);
#endif
open(overwrite);
}
#endif
FileWriter::~FileWriter()
{
@ -40,32 +46,20 @@ FileWriter::~FileWriter()
void FileWriter::open(bool overwrite)
{
#if _WIN32
if (m_wfilename.size())
{
if (overwrite)
m_fileHandle = _wfopen(m_wfilename.c_str(), L"w+b");
else
m_fileHandle = _wfopen(m_wfilename.c_str(), L"r+b");
}
if (overwrite)
m_fileHandle = _wfopen(m_filename.c_str(), L"w+b");
else
{
if (overwrite)
m_fileHandle = fopen(m_filename.c_str(), "w+b");
else
m_fileHandle = fopen(m_filename.c_str(), "r+b");
}
m_fileHandle = _wfopen(m_filename.c_str(), L"r+b");
#else
if (overwrite)
m_fileHandle = fopen(m_filename.c_str(), "w+b");
else
m_fileHandle = fopen(m_filename.c_str(), "r+b");
m_fileHandle = fopen(m_filename.c_str(), "r+b");
#endif
if (!m_fileHandle)
{
atError("Unable to open file '%s'", m_filename.c_str());
atError("Unable to open file '%s'", filename());
setError();
return;
}
@ -104,7 +98,11 @@ atUint64 FileWriter::position() const
atUint64 FileWriter::length() const
{
#if _WIN32
return utility::fileSize(utility::wideToUtf8(m_filename));
#else
return utility::fileSize(m_filename);
#endif
}
void FileWriter::writeUBytes(const atUint8* data, atUint64 len)

39
src/Athena/Utility.cpp
View File

@ -10,6 +10,7 @@
#include <sys/types.h>
#include <sys/stat.h>
#include <random>
#include "utf8proc.h"
#ifdef _MSC_VER
#include <functional>
@ -207,5 +208,43 @@ atUint64 rand64()
return r0 | r1 | r2 | r3;
}
std::string wideToUtf8(const std::wstring& src)
{
std::string retval;
retval.reserve(src.length());
for (wchar_t ch : src)
{
utf8proc_uint8_t mb[4];
utf8proc_ssize_t c = utf8proc_encode_char(utf8proc_int32_t(ch), mb);
if (c < 0)
{
atWarning("invalid UTF-8 character while encoding");
return retval;
}
retval.append(reinterpret_cast<char*>(mb), c);
}
return retval;
}
std::wstring utf8ToWide(const std::string& src)
{
std::wstring retval;
retval.reserve(src.length());
const utf8proc_uint8_t* buf = reinterpret_cast<const utf8proc_uint8_t*>(src.c_str());
while (*buf)
{
utf8proc_int32_t wc;
utf8proc_ssize_t len = utf8proc_iterate(buf, -1, &wc);
if (len < 0)
{
atWarning("invalid UTF-8 character while decoding");
return retval;
}
buf += len;
retval += wchar_t(wc);
}
return retval;
}
} // utility
} // Athena