archive/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-07-04 22:11:18 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move to Endian agnostic read/write functions; add kernel

Browse source
This commit is contained in:
Chris Spegal 2023-10-10 10:59:26 -04:00
parent b8a83ab448
commit 1b7c4d8a2f
35 changed files with 468 additions and 222 deletions
Download patch file Download diff file Expand all files Collapse all files

175
src/util/helpers/Serializer.cpp
View file

@ -1,5 +1,91 @@
#include "Serializer.h"
// read return
template<typename T>
T MemStreamReader::read()
{
if (!reserveReadLength(sizeof(T)))
return 0;
const uint8* p = m_data + m_cursorPos;
T v;
std::memcpy(&v, p, sizeof(v));
m_cursorPos += sizeof(T);
return v;
}
template uint8 MemStreamReader::read<uint8>();
template uint16 MemStreamReader::read<uint16>();
template uint32 MemStreamReader::read<uint32>();
template uint32be MemStreamReader::read<uint32be>();
template uint64 MemStreamReader::read<uint64>();
template int MemStreamReader::read<int>();
template<>
std::string MemStreamReader::read()
{
std::string s;
uint32 stringSize = read<uint32>();
if (hasError())
return s;
if (stringSize >= (32 * 1024 * 1024))
{
// out of bounds read or suspiciously large string
m_hasError = true;
return std::string();
}
s.resize(stringSize);
readData(s.data(), stringSize);
return s;
}
// read void
template<typename T>
void MemStreamReader::read(T& v)
{
if (reserveReadLength(sizeof(T)))
{
const uint8* p = m_data + m_cursorPos;
std::memcpy(&v, p, sizeof(v));
m_cursorPos += sizeof(T);
}
}
template void MemStreamReader::read(uint8& v);
template void MemStreamReader::read(uint16& v);
template void MemStreamReader::read(uint32& v);
template void MemStreamReader::read(uint32be& v);
template void MemStreamReader::read(uint64& v);
template void MemStreamReader::read(int& v);
template<>
void MemStreamReader::read(std::string& v)
{
uint32 stringSize = read<uint32>();
if (!hasError())
{
if (stringSize >= (32 * 1024 * 1024))
{
// out of bounds read or suspiciously large string
m_hasError = true;
}
else
{
v.resize(stringSize);
readData(v.data(), stringSize);
}
}
}
// readSection
void MemStreamReader::readSection(const char* sec)
{
std::string sec_str = std::string(sec);
cemu_assert_debug(read<std::string>() == sec_str);
}
// readBE return
template<typename T>
@ -19,7 +105,6 @@ template uint8 MemStreamReader::readBE<uint8>();
template uint16 MemStreamReader::readBE<uint16>();
template uint32 MemStreamReader::readBE<uint32>();
template uint64 MemStreamReader::readBE<uint64>();
template int MemStreamReader::readBE<int>();
template<>
std::string MemStreamReader::readBE()
@ -39,45 +124,6 @@ std::string MemStreamReader::readBE()
return s;
}
// readBE void
template<typename T>
void MemStreamReader::readBE(T& v)
{
if (reserveReadLength(sizeof(T)))
{
const uint8* p = m_data + m_cursorPos;
std::memcpy(&v, p, sizeof(v));
v = _BE(v);
m_cursorPos += sizeof(T);
}
}
template void MemStreamReader::readBE(uint8& v);
template void MemStreamReader::readBE(uint16& v);
template void MemStreamReader::readBE(uint32& v);
template void MemStreamReader::readBE(uint64& v);
template void MemStreamReader::readBE(int& v);
template<>
void MemStreamReader::readBE(std::string& v)
{
uint32 stringSize = readBE<uint32>();
if (!hasError())
{
if (stringSize >= (32 * 1024 * 1024))
{
// out of bounds read or suspiciously large string
m_hasError = true;
}
else
{
v.resize(stringSize);
readData(v.data(), stringSize);
}
}
}
// readLE return
template<typename T>
@ -94,15 +140,39 @@ T MemStreamReader::readLE()
}
template uint8 MemStreamReader::readLE<uint8>();
template uint16 MemStreamReader::readLE<uint16>();
template uint32 MemStreamReader::readLE<uint32>();
template uint64 MemStreamReader::readLE<uint64>();
// readSection
// write void
void MemStreamReader::readSection(const char* sec)
template<typename T>
void MemStreamWriter::write(const T& v)
{
m_buffer.resize(m_buffer.size() + sizeof(T));
uint8* p = m_buffer.data() + m_buffer.size() - sizeof(T);
std::memcpy(p, &v, sizeof(v));
}
template void MemStreamWriter::write(const int& v);
template void MemStreamWriter::write(const uint64& v);
template void MemStreamWriter::write(const uint32be& v);
template void MemStreamWriter::write(const uint32& v);
template void MemStreamWriter::write(const uint16& v);
template void MemStreamWriter::write(const uint8& v);
template<>
void MemStreamWriter::write<std::string>(const std::string& v)
{
write<uint32>((uint32)v.size());
writeData(v.data(), v.size());
}
// writeSection
void MemStreamWriter::writeSection(const char* sec)
{
std::string sec_str = std::string(sec);
cemu_assert_debug(readBE<std::string>() == sec_str);
write(sec_str);
}
// writeBE void
@ -116,11 +186,10 @@ void MemStreamWriter::writeBE(const T& v)
std::memcpy(p, &tmp, sizeof(tmp));
}
template void MemStreamWriter::writeBE(const uint8& v);
template void MemStreamWriter::writeBE(const uint16& v);
template void MemStreamWriter::writeBE(const uint32& v);
template void MemStreamWriter::writeBE(const uint64& v);
template void MemStreamWriter::writeBE(const int& v);
template void MemStreamWriter::writeBE(const uint32& v);
template void MemStreamWriter::writeBE(const uint16& v);
template void MemStreamWriter::writeBE(const uint8& v);
template<>
void MemStreamWriter::writeBE<std::string>(const std::string& v)
@ -140,14 +209,6 @@ void MemStreamWriter::writeLE(const T& v)
std::memcpy(p, &tmp, sizeof(tmp));
}
template void MemStreamWriter::writeLE(const uint8& v);
template void MemStreamWriter::writeLE(const uint16& v);
template void MemStreamWriter::writeLE(const uint64& v);
template void MemStreamWriter::writeLE(const uint32& v);
// writeSection
void MemStreamWriter::writeSection(const char* sec)
{
std::string sec_str = std::string(sec);
writeBE(sec_str);
}