cleanup modules, initial ABR file support
This commit is contained in:
229
src/abr.h
Normal file
229
src/abr.h
Normal file
@@ -0,0 +1,229 @@
|
||||
#pragma once
|
||||
#include "asset.h"
|
||||
#include <codecvt>
|
||||
|
||||
class BinaryStream
|
||||
{
|
||||
public:
|
||||
enum class ByteOrder : uint8_t { BigEndian, LittleEndian, Host };
|
||||
static ByteOrder sys_order()
|
||||
{
|
||||
union {
|
||||
uint32_t i;
|
||||
char c[4];
|
||||
} bint { 0x01020304 };
|
||||
|
||||
return bint.c[0] == 1 ? ByteOrder::BigEndian : ByteOrder::LittleEndian;
|
||||
}
|
||||
BinaryStream(const BinaryParam&) = delete;
|
||||
BinaryStream() = default;
|
||||
~BinaryStream()
|
||||
{
|
||||
if (m_ptr)
|
||||
delete m_ptr;
|
||||
m_ptr = m_cur = nullptr;
|
||||
m_size = 0;
|
||||
}
|
||||
void init(uint8_t* owned_data_ptr, size_t size, ByteOrder byte_order = ByteOrder::Host)
|
||||
{
|
||||
m_ptr = m_cur = owned_data_ptr;
|
||||
m_size = size;
|
||||
m_byte_order = byte_order;
|
||||
m_swap = byte_order == ByteOrder::Host ? false : byte_order != sys_order();
|
||||
}
|
||||
inline void skip(size_t bytes) { m_cur += bytes; }
|
||||
inline bool eof() { return std::distance(m_ptr, m_cur) >= m_size; }
|
||||
inline bool has_data(size_t sz) { return std::distance(m_ptr, m_cur + sz) < m_size; }
|
||||
uint8_t ru8() { return read<uint8_t>(); }
|
||||
uint16_t ru16() { return m_swap ? swap(read<uint16_t>()) : read<uint16_t>(); }
|
||||
uint32_t ru32() { return m_swap ? swap(read<uint32_t>()) : read<uint32_t>(); }
|
||||
uint64_t ru64() { return m_swap ? swap(read<uint64_t>()) : read<uint64_t>(); }
|
||||
int8_t ri8() { return read<int8_t>(); }
|
||||
int16_t ri16() { return m_swap ? swap(read<int16_t>()) : read<int16_t>(); }
|
||||
int32_t ri32() { return m_swap ? swap(read<int32_t>()) : read<int32_t>(); }
|
||||
int64_t ri64() { return m_swap ? swap(read<int64_t>()) : read<int64_t>(); }
|
||||
float rflt() { return read<float>(); }
|
||||
double rdbl() { return read<double>(); }
|
||||
std::string pick(size_t chars) { return { (char*)m_cur, chars }; }
|
||||
std::string rstring() { auto len = ru32(); return { advance<char>(len), len }; }
|
||||
std::string rstring(size_t len) { return { advance<char>(len), len }; }
|
||||
std::wstring rwstring() { auto len = ru32(); return rwstring(len); }
|
||||
std::wstring rwstring(size_t len) {
|
||||
//std::wstring_convert<std::codecvt_utf16<char>> conv;
|
||||
char* ptr = advance<char>(len * 2);
|
||||
for (int i = 0; i < len; i++)
|
||||
std::swap(ptr[i * 2], ptr[i * 2 + 1]);
|
||||
//auto s = conv.from_bytes(ptr, ptr + len);
|
||||
wchar_t* wptr = (wchar_t*)ptr;
|
||||
//std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert;
|
||||
//std::string utf8 = convert.to_bytes(wptr, wptr + len);
|
||||
//std::wstring ws(len, 0);
|
||||
//mbsrtowcs((wchar_t*)ws.data(), (const char**)&ptr, len, nullptr);
|
||||
return std::wstring(wptr, len);
|
||||
}
|
||||
protected:
|
||||
template<typename T> inline T align4(T x) { return ((x - T{1}) & (~(T{3}))) + T{4}; }
|
||||
template<typename T> T read()
|
||||
{
|
||||
T ret{};
|
||||
if (m_ptr)
|
||||
{
|
||||
if (has_data(sizeof(T)))
|
||||
ret = *reinterpret_cast<T*>(m_cur);
|
||||
m_cur += sizeof(T);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
template<typename T> T* advance(size_t bytes)
|
||||
{
|
||||
T* ret = nullptr;
|
||||
if (m_ptr)
|
||||
{
|
||||
if (has_data(bytes))
|
||||
ret = reinterpret_cast<T*>(m_cur);
|
||||
m_cur += bytes;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
template<typename T> T swap(T x)
|
||||
{
|
||||
#if _MSC_VER >= 1400
|
||||
if (sizeof(T) == 2)
|
||||
return _byteswap_ushort(x);
|
||||
else if (sizeof(T) == 4)
|
||||
return _byteswap_ulong(x);
|
||||
else if (sizeof(T) == 8)
|
||||
return _byteswap_uint64(x);
|
||||
#else
|
||||
auto p = reinterpret_cast<uint16_t*>(&x);
|
||||
if (sizeof(T) == 2)
|
||||
{
|
||||
std::swap(p[0], p[1]);
|
||||
}
|
||||
else if (sizeof(T) == 4)
|
||||
{
|
||||
std::swap(p[0], p[3]);
|
||||
std::swap(p[1], p[2]);
|
||||
}
|
||||
else if (sizeof(T) == 8)
|
||||
{
|
||||
std::swap(p[0], p[7]);
|
||||
std::swap(p[1], p[6]);
|
||||
std::swap(p[2], p[5]);
|
||||
std::swap(p[3], p[4]);
|
||||
}
|
||||
else
|
||||
{
|
||||
static_assert(true, "Should not reach here");
|
||||
}
|
||||
return x;
|
||||
#endif
|
||||
}
|
||||
private:
|
||||
uint8_t *m_ptr = nullptr;
|
||||
uint8_t *m_cur = nullptr;
|
||||
size_t m_size = 0;
|
||||
bool m_swap = false;
|
||||
ByteOrder m_byte_order = ByteOrder::Host;
|
||||
};
|
||||
|
||||
static constexpr const uint32_t abr_s2sig(const char s[4])
|
||||
{
|
||||
return (uint32_t)(s[0]) << 0
|
||||
| (uint32_t)(s[1]) << 8
|
||||
| (uint32_t)(s[2]) << 16
|
||||
| (uint32_t)(s[3]) << 24;
|
||||
}
|
||||
|
||||
static constexpr const std::array<char, 5> abr_sig2sz(uint32_t x)
|
||||
{
|
||||
return {
|
||||
(char)(x >> 0 ),
|
||||
(char)(x >> 8 ),
|
||||
(char)(x >> 16),
|
||||
(char)(x >> 24),
|
||||
0
|
||||
};
|
||||
}
|
||||
|
||||
class ABR : public BinaryStream
|
||||
{
|
||||
struct Type {
|
||||
using Vec = std::vector<std::shared_ptr<Type>>;
|
||||
using Map = std::map<std::string, std::shared_ptr<Type>>;
|
||||
using Ref = std::shared_ptr<Type>;
|
||||
virtual std::string str() const { return "type"; }
|
||||
};
|
||||
struct Class : public Type { };
|
||||
struct Property : public Type { };
|
||||
struct Reference : public Type { };
|
||||
struct List : public Type{
|
||||
Type::Vec children;
|
||||
};
|
||||
struct Double : public Type { double value; };
|
||||
struct UnitFloat : public Type { std::string unit; double value; };
|
||||
struct String : public Type { std::wstring value; };
|
||||
struct Enum : public Type { };
|
||||
struct EnumRef : public Type { };
|
||||
struct Offset : public Type { };
|
||||
struct Identifier : public Type { };
|
||||
struct Index : public Type { };
|
||||
struct Name : public Type { };
|
||||
struct Integer : public Type
|
||||
{
|
||||
int32_t value;
|
||||
};
|
||||
struct LargeInteger : public Type { };
|
||||
struct Boolean : public Type
|
||||
{
|
||||
bool value;
|
||||
virtual std::string str() const override { return "Boolean: " + ; }
|
||||
};
|
||||
struct Alias : public Type { };
|
||||
struct Descriptor : public Type
|
||||
{
|
||||
std::wstring name;
|
||||
std::string class_id;
|
||||
Type::Map props;
|
||||
};
|
||||
|
||||
public:
|
||||
ABR();
|
||||
bool open(const std::string& path);
|
||||
private:
|
||||
inline std::string rkey_or_string()
|
||||
{
|
||||
auto len = ru32();
|
||||
if (len == 0)
|
||||
len = 4;
|
||||
return rstring(len);
|
||||
}
|
||||
bool section_desc();
|
||||
bool section_samp();
|
||||
bool section_patt();
|
||||
std::shared_ptr<List> parse_vlls();
|
||||
std::shared_ptr<String> parse_text();
|
||||
std::shared_ptr<Descriptor> parse_objc();
|
||||
std::shared_ptr<UnitFloat> parse_untf();
|
||||
std::shared_ptr<Boolean> parse_bool();
|
||||
std::shared_ptr<Integer> parse_long();
|
||||
std::shared_ptr<Double> parse_doub();
|
||||
std::shared_ptr<Enum> parse_enum();
|
||||
//Type::Ref parse_prop();
|
||||
Type::Ref call(std::string t)
|
||||
{
|
||||
if (m_parser_table.find(t) != m_parser_table.end())
|
||||
{
|
||||
auto& method = m_parser_table[t];
|
||||
return method();
|
||||
}
|
||||
else if (m_parser_table.find(pick(4)) != m_parser_table.end())
|
||||
{
|
||||
auto& method = m_parser_table[rstring(4)];
|
||||
return method();
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
std::map<std::string, std::function<Type::Ref()>> m_parser_table;
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user