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

Merge branch 'master' of https://github.com/libAthena/Athena

This commit is contained in:
Jack Andersen 2015-11-17 10:37:55 -10:00
parent f381eb3059 df43b72f8a
commit 18e94dbc54
12 changed files with 309 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
atdna/CMakeLists.txt
View File

@ -167,7 +167,7 @@ macro(atdna out)
# OSX Extra
elseif(APPLE)
list(APPEND extraargs -isysroot ${CMAKE_OSX_SYSROOT} -isysroot
list(APPEND extraargs -isysroot ${CMAKE_OSX_SYSROOT} -I ${CMAKE_OSX_SYSROOT}/usr/include -isysroot
${CMAKE_OSX_SYSROOT}/../../../../../Toolchains/XcodeDefault.xctoolchain)
endif()

6
atdna/main.cpp
View File

@ -841,7 +841,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor>
}
}
if (sizeExprStr.size())
if (sizeExprStr.size() && sizeExprStr.compare("-1"))
fileOut << " __isz += (" << sizeExprStr << ");\n";
else
fileOut << " __isz += " << fieldName << ".size() + 1;\n";
@ -879,7 +879,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor>
++idx;
}
if (sizeExprStr.size())
if (sizeExprStr.size() && sizeExprStr.compare("-1"))
fileOut << " __isz += (" << sizeExprStr << ") * 2;\n";
else
fileOut << " __isz += (" << fieldName << ".size() + 1) * 2;\n";
@ -913,7 +913,7 @@ class ATDNAEmitVisitor : public clang::RecursiveASTVisitor<ATDNAEmitVisitor>
}
if (sizeExprStr.size())
if (sizeExprStr.size() && sizeExprStr.compare("-1"))
fileOut << " __isz += (" << sizeExprStr << ") * 2;\n";
else
fileOut << " __isz += (" << fieldName << ".size() + 1) * 2;\n";

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;

6
include/Athena/Global.hpp
View File

@ -22,6 +22,12 @@
#define S_ISLNK(m) 0
#endif
#define PRISize "Iu"
#else
#define PRISize "zu"
#endif
#ifndef AT_PRETTY_FUNCTION

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

59
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 = filename;
#endif
open();
setCacheSize(cacheSize);
}
#if _WIN32
FileReader::FileReader(const std::wstring& filename, atInt32 cacheSize)
: m_wfilename(filename),
m_fileHandle(nullptr),
m_cacheData(nullptr),
m_offset(0)
: 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,23 +50,21 @@ 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());
std::string _filename = filename();
atError("File not found '%s'", _filename.c_str());
setError();
return;
}
// ensure we're at the beginning of the file
rewind(m_fileHandle);
// reset error
m_hasError = false;
}
void FileReader::close()
@ -79,21 +83,24 @@ void FileReader::close()
void FileReader::seek(atInt64 pos, SeekOrigin origin)
{
if (!isOpen())
return;
// check block position
if (m_blockSize > 0)
{
atUint64 oldOff = m_offset;
switch(origin)
{
case SeekOrigin::Begin:
m_offset = pos;
break;
case SeekOrigin::Current:
m_offset += pos;
break;
case SeekOrigin::End:
m_offset = length() - pos;
break;
case SeekOrigin::Begin:
m_offset = pos;
break;
case SeekOrigin::Current:
m_offset += pos;
break;
case SeekOrigin::End:
m_offset = length() - pos;
break;
}
if (m_offset > length())
{
@ -136,7 +143,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)

57
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 = filename;
#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,38 +46,26 @@ 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().c_str());
setError();
return;
}
// ensure we're at the beginning of the file
rewind(m_fileHandle);
// reset error
m_hasError = false;
}
void FileWriter::close()
@ -90,6 +84,13 @@ void FileWriter::close()
void FileWriter::seek(atInt64 pos, SeekOrigin origin)
{
if (!isOpen())
{
atError("Unable to seek in file, not open");
setError();
return;
}
if (fseeko64(m_fileHandle, pos, (int)origin) != 0)
{
atError("Unable to seek in file");
@ -104,7 +105,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