mirror of https://github.com/AxioDL/kabufuda.git
General: Use std::array where applicable
Same behavior, but with stronger typing. We can also eliminate usages of magic values in some places.
This commit is contained in:
Lioncash
parent
222fb5c179
commit
3e64021400
|
|
@ -1,5 +1,6 @@
|
|||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include "kabufuda/Constants.hpp"
|
||||
|
||||
|
|
@ -14,9 +15,9 @@ class BlockAllocationTable {
|
|||
uint16_t m_updateCounter;
|
||||
uint16_t m_freeBlocks;
|
||||
uint16_t m_lastAllocated;
|
||||
uint16_t m_map[0xFFB];
|
||||
std::array<uint16_t, 0xFFB> m_map;
|
||||
};
|
||||
uint8_t __raw[BlockSize];
|
||||
std::array<uint8_t, BlockSize> raw{};
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
|
|
@ -26,7 +27,6 @@ class BlockAllocationTable {
|
|||
|
||||
public:
|
||||
explicit BlockAllocationTable(uint32_t blockCount = (uint32_t(ECardSize::Card2043Mb) * MbitToBlocks));
|
||||
BlockAllocationTable(uint8_t data[BlockSize]);
|
||||
~BlockAllocationTable() = default;
|
||||
|
||||
uint16_t getNextBlock(uint16_t block) const;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
|
|
@ -37,8 +38,8 @@ struct CardStat {
|
|||
char x0_fileName[CARD_FILENAME_MAX];
|
||||
uint32_t x20_length;
|
||||
uint32_t x24_time; /* seconds since 01/01/2000 midnight */
|
||||
uint8_t x28_gameName[4];
|
||||
uint8_t x2c_company[2];
|
||||
std::array<uint8_t, 4> x28_gameName;
|
||||
std::array<uint8_t, 2> x2c_company;
|
||||
|
||||
/* read/write (Set by Card::getStatus/Card::setStatus) */
|
||||
uint8_t x2e_bannerFormat;
|
||||
|
|
@ -51,7 +52,7 @@ struct CardStat {
|
|||
/* read-only (Set by Card::getStatus) */
|
||||
uint32_t x3c_offsetBanner;
|
||||
uint32_t x40_offsetBannerTlut;
|
||||
uint32_t x44_offsetIcon[CARD_ICON_MAX];
|
||||
std::array<uint32_t, CARD_ICON_MAX> x44_offsetIcon;
|
||||
uint32_t x64_offsetIconTlut;
|
||||
uint32_t x68_offsetData;
|
||||
|
||||
|
|
@ -79,7 +80,7 @@ class Card {
|
|||
struct CardHeader {
|
||||
union {
|
||||
struct {
|
||||
uint8_t m_serial[12];
|
||||
std::array<uint8_t, 12> m_serial;
|
||||
uint64_t m_formatTime;
|
||||
int32_t m_sramBias;
|
||||
uint32_t m_sramLanguage;
|
||||
|
|
@ -87,12 +88,12 @@ class Card {
|
|||
uint16_t m_deviceId; /* 0 for Slot A, 1 for Slot B */
|
||||
uint16_t m_sizeMb;
|
||||
uint16_t m_encoding;
|
||||
uint8_t __padding[468];
|
||||
std::array<uint8_t, 468> padding;
|
||||
uint16_t m_updateCounter;
|
||||
uint16_t m_checksum;
|
||||
uint16_t m_checksumInv;
|
||||
};
|
||||
uint8_t __raw[BlockSize];
|
||||
std::array<uint8_t, BlockSize> raw;
|
||||
};
|
||||
void _swapEndian();
|
||||
};
|
||||
|
|
@ -102,10 +103,10 @@ class Card {
|
|||
|
||||
SystemString m_filename;
|
||||
AsyncIO m_fileHandle;
|
||||
Directory m_dirs[2];
|
||||
BlockAllocationTable m_bats[2];
|
||||
Directory m_tmpDirs[2];
|
||||
BlockAllocationTable m_tmpBats[2];
|
||||
std::array<Directory, 2> m_dirs;
|
||||
std::array<BlockAllocationTable, 2> m_bats;
|
||||
std::array<Directory, 2> m_tmpDirs;
|
||||
std::array<BlockAllocationTable, 2> m_tmpBats;
|
||||
uint8_t m_currentDir;
|
||||
uint8_t m_currentBat;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include "kabufuda/File.hpp"
|
||||
|
||||
|
|
@ -9,13 +10,13 @@ class Directory {
|
|||
#pragma pack(push, 4)
|
||||
union {
|
||||
struct {
|
||||
File m_files[MaxFiles];
|
||||
uint8_t __padding[0x3a];
|
||||
std::array<File, MaxFiles> m_files;
|
||||
std::array<uint8_t, 0x3a> padding;
|
||||
uint16_t m_updateCounter;
|
||||
uint16_t m_checksum;
|
||||
uint16_t m_checksumInv;
|
||||
};
|
||||
uint8_t __raw[BlockSize];
|
||||
std::array<uint8_t, BlockSize> raw;
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include "kabufuda/Constants.hpp"
|
||||
|
||||
|
|
@ -11,8 +12,8 @@ class File {
|
|||
#pragma pack(push, 4)
|
||||
union {
|
||||
struct {
|
||||
uint8_t m_game[4];
|
||||
uint8_t m_maker[2];
|
||||
std::array<uint8_t, 4> m_game;
|
||||
std::array<uint8_t, 2> m_maker;
|
||||
uint8_t m_reserved;
|
||||
uint8_t m_bannerFlags;
|
||||
char m_filename[0x20];
|
||||
|
|
@ -27,7 +28,7 @@ class File {
|
|||
uint16_t m_reserved2;
|
||||
uint32_t m_commentAddr;
|
||||
};
|
||||
uint8_t __raw[0x40];
|
||||
std::array<uint8_t, 0x40> raw;
|
||||
};
|
||||
|
||||
#pragma pack(pop)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
|
||||
// Modified code taken from libogc
|
||||
|
|
@ -41,7 +42,7 @@ union SRAMFlags {
|
|||
};
|
||||
|
||||
union SRAM {
|
||||
uint8_t p_SRAM[64];
|
||||
std::array<uint8_t, 64> p_SRAM;
|
||||
struct // Stored configuration value from the system SRAM area
|
||||
{
|
||||
uint16_t checksum; // Holds the block checksum.
|
||||
|
|
@ -55,13 +56,14 @@ union SRAM {
|
|||
SRAMFlags flags; // Device and operations flag
|
||||
|
||||
// Stored configuration value from the extended SRAM area
|
||||
uint8_t flash_id[2][12]; // flash_id[2][12] 96bit memorycard unlock flash ID
|
||||
uint32_t wirelessKbd_id; // Device ID of last connected wireless keyboard
|
||||
uint16_t wirelessPad_id[4]; // 16-bit device ID of last connected pad.
|
||||
uint8_t dvderr_code; // last non-recoverable error from DVD interface
|
||||
uint8_t __padding0; // reserved
|
||||
uint8_t flashID_chksum[2]; // 8-bit checksum of unlock flash ID
|
||||
uint32_t __padding1; // padding
|
||||
using FlashID = std::array<std::array<uint8_t, 12>, 2>;
|
||||
FlashID flash_id; // flash_id[2][12] 96bit memorycard unlock flash ID
|
||||
uint32_t wirelessKbd_id; // Device ID of last connected wireless keyboard
|
||||
std::array<uint16_t, 4> wirelessPad_id; // 16-bit device ID of last connected pad.
|
||||
uint8_t dvderr_code; // last non-recoverable error from DVD interface
|
||||
uint8_t __padding0; // reserved
|
||||
std::array<uint8_t, 2> flashID_chksum; // 8-bit checksum of unlock flash ID
|
||||
uint32_t __padding1; // padding
|
||||
};
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@
|
|||
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstring>
|
||||
#include <vector>
|
||||
|
||||
#include "kabufuda/Util.hpp"
|
||||
|
|
@ -19,23 +18,21 @@ void BlockAllocationTable::swapEndian() {
|
|||
|
||||
void BlockAllocationTable::updateChecksum() {
|
||||
swapEndian();
|
||||
calculateChecksumBE(reinterpret_cast<uint16_t*>(__raw + 4), 0xFFE, &m_checksum, &m_checksumInv);
|
||||
calculateChecksumBE(reinterpret_cast<uint16_t*>(raw.data() + 4), 0xFFE, &m_checksum, &m_checksumInv);
|
||||
swapEndian();
|
||||
}
|
||||
|
||||
bool BlockAllocationTable::valid() const {
|
||||
uint16_t ckSum, ckSumInv;
|
||||
const_cast<BlockAllocationTable&>(*this).swapEndian();
|
||||
calculateChecksumBE(reinterpret_cast<const uint16_t*>(__raw + 4), 0xFFE, &ckSum, &ckSumInv);
|
||||
calculateChecksumBE(reinterpret_cast<const uint16_t*>(raw.data() + 4), 0xFFE, &ckSum, &ckSumInv);
|
||||
bool res = (ckSum == m_checksum && ckSumInv == m_checksumInv);
|
||||
const_cast<BlockAllocationTable&>(*this).swapEndian();
|
||||
return res;
|
||||
}
|
||||
|
||||
BlockAllocationTable::BlockAllocationTable(uint32_t blockCount) {
|
||||
memset(__raw, 0, BlockSize);
|
||||
m_freeBlocks = uint16_t(blockCount - FSTBlocks);
|
||||
m_lastAllocated = 4;
|
||||
BlockAllocationTable::BlockAllocationTable(uint32_t blockCount)
|
||||
: m_freeBlocks{uint16_t(blockCount - FSTBlocks)}, m_lastAllocated{4} {
|
||||
updateChecksum();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,40 +26,36 @@ void Card::CardHeader::_swapEndian() {
|
|||
m_checksumInv = SBig(m_checksumInv);
|
||||
}
|
||||
|
||||
Card::Card() { memset(m_ch.__raw, 0xFF, BlockSize); }
|
||||
Card::Card() { m_ch.raw.fill(0xFF); }
|
||||
|
||||
Card::Card(Card&& other) {
|
||||
memmove(m_ch.__raw, other.m_ch.__raw, BlockSize);
|
||||
m_ch.raw = other.m_ch.raw;
|
||||
m_filename = std::move(other.m_filename);
|
||||
m_fileHandle = std::move(other.m_fileHandle);
|
||||
m_dirs[0] = std::move(other.m_dirs[0]);
|
||||
m_dirs[1] = std::move(other.m_dirs[1]);
|
||||
m_bats[0] = std::move(other.m_bats[0]);
|
||||
m_bats[1] = std::move(other.m_bats[1]);
|
||||
m_dirs = std::move(other.m_dirs);
|
||||
m_bats = std::move(other.m_bats);
|
||||
m_currentDir = other.m_currentDir;
|
||||
m_currentBat = other.m_currentBat;
|
||||
|
||||
m_maxBlock = other.m_maxBlock;
|
||||
memmove(m_game, other.m_game, 5);
|
||||
memmove(m_maker, other.m_maker, 3);
|
||||
std::copy(std::cbegin(other.m_game), std::cend(other.m_game), std::begin(m_game));
|
||||
std::copy(std::cbegin(other.m_maker), std::cend(other.m_maker), std::begin(m_maker));
|
||||
}
|
||||
|
||||
Card& Card::operator=(Card&& other) {
|
||||
close();
|
||||
|
||||
memmove(m_ch.__raw, other.m_ch.__raw, BlockSize);
|
||||
m_ch.raw = other.m_ch.raw;
|
||||
m_filename = std::move(other.m_filename);
|
||||
m_fileHandle = std::move(other.m_fileHandle);
|
||||
m_dirs[0] = std::move(other.m_dirs[0]);
|
||||
m_dirs[1] = std::move(other.m_dirs[1]);
|
||||
m_bats[0] = std::move(other.m_bats[0]);
|
||||
m_bats[1] = std::move(other.m_bats[1]);
|
||||
m_dirs = std::move(other.m_dirs);
|
||||
m_bats = std::move(other.m_bats);
|
||||
m_currentDir = other.m_currentDir;
|
||||
m_currentBat = other.m_currentBat;
|
||||
|
||||
m_maxBlock = other.m_maxBlock;
|
||||
memmove(m_game, other.m_game, 5);
|
||||
memmove(m_maker, other.m_maker, 3);
|
||||
std::copy(std::cbegin(other.m_game), std::cend(other.m_game), std::begin(m_game));
|
||||
std::copy(std::cbegin(other.m_maker), std::cend(other.m_maker), std::begin(m_maker));
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
|
@ -109,11 +105,14 @@ ECardResult Card::_pumpOpen() {
|
|||
}
|
||||
|
||||
Card::Card(const char* game, const char* maker) {
|
||||
memset(m_ch.__raw, 0xFF, BlockSize);
|
||||
if (game && strlen(game) == 4)
|
||||
memcpy(m_game, game, 4);
|
||||
if (maker && strlen(maker) == 2)
|
||||
memcpy(m_maker, maker, 2);
|
||||
m_ch.raw.fill(0xFF);
|
||||
|
||||
if (game != nullptr && std::strlen(game) == 4) {
|
||||
std::memcpy(m_game, game, 4);
|
||||
}
|
||||
if (maker != nullptr && std::strlen(maker) == 2) {
|
||||
std::memcpy(m_maker, maker, 2);
|
||||
}
|
||||
}
|
||||
|
||||
Card::~Card() { close(); }
|
||||
|
|
@ -166,7 +165,7 @@ void Card::_updateDirAndBat(const Directory& dir, const BlockAllocationTable& ba
|
|||
|
||||
void Card::_updateChecksum() {
|
||||
m_ch._swapEndian();
|
||||
calculateChecksumBE(reinterpret_cast<uint16_t*>(m_ch.__raw), 0xFE, &m_ch.m_checksum, &m_ch.m_checksumInv);
|
||||
calculateChecksumBE(reinterpret_cast<uint16_t*>(m_ch.raw.data()), 0xFE, &m_ch.m_checksum, &m_ch.m_checksumInv);
|
||||
m_ch._swapEndian();
|
||||
}
|
||||
|
||||
|
|
@ -300,25 +299,28 @@ ECardResult Card::deleteFile(uint32_t fileno) {
|
|||
}
|
||||
|
||||
ECardResult Card::renameFile(const char* oldName, const char* newName) {
|
||||
ECardResult openRes = _pumpOpen();
|
||||
if (openRes != ECardResult::READY)
|
||||
const ECardResult openRes = _pumpOpen();
|
||||
if (openRes != ECardResult::READY) {
|
||||
return openRes;
|
||||
}
|
||||
|
||||
if (strlen(newName) > 32)
|
||||
if (std::strlen(newName) > 32) {
|
||||
return ECardResult::NAMETOOLONG;
|
||||
}
|
||||
|
||||
Directory dir = m_dirs[m_currentDir];
|
||||
File* f = dir.getFile(m_game, m_maker, oldName);
|
||||
if (!f)
|
||||
if (f == nullptr) {
|
||||
return ECardResult::NOFILE;
|
||||
}
|
||||
|
||||
if (File* replF = dir.getFile(m_game, m_maker, newName)) {
|
||||
BlockAllocationTable bat = m_bats[m_currentBat];
|
||||
_deleteFile(*replF, bat);
|
||||
strncpy(f->m_filename, newName, 32);
|
||||
std::strncpy(f->m_filename, newName, 32);
|
||||
_updateDirAndBat(dir, bat);
|
||||
} else {
|
||||
strncpy(f->m_filename, newName, 32);
|
||||
std::strncpy(f->m_filename, newName, 32);
|
||||
_updateDirAndBat(dir, m_bats[m_currentBat]);
|
||||
}
|
||||
return ECardResult::READY;
|
||||
|
|
@ -554,11 +556,11 @@ ECardResult Card::getStatus(uint32_t fileNo, CardStat& statOut) const {
|
|||
if (!file || file->m_game[0] == 0xFF)
|
||||
return ECardResult::NOFILE;
|
||||
|
||||
strncpy(statOut.x0_fileName, file->m_filename, 32);
|
||||
std::strncpy(statOut.x0_fileName, file->m_filename, 32);
|
||||
statOut.x20_length = file->m_blockCount * BlockSize;
|
||||
statOut.x24_time = file->m_modifiedTime;
|
||||
memcpy(statOut.x28_gameName, file->m_game, 4);
|
||||
memcpy(statOut.x2c_company, file->m_maker, 2);
|
||||
statOut.x28_gameName = file->m_game;
|
||||
statOut.x2c_company = file->m_maker;
|
||||
|
||||
statOut.x2e_bannerFormat = file->m_bannerFlags;
|
||||
statOut.x30_iconAddr = file->m_iconAddress;
|
||||
|
|
@ -569,8 +571,7 @@ ECardResult Card::getStatus(uint32_t fileNo, CardStat& statOut) const {
|
|||
if (file->m_iconAddress == UINT32_MAX) {
|
||||
statOut.x3c_offsetBanner = UINT32_MAX;
|
||||
statOut.x40_offsetBannerTlut = UINT32_MAX;
|
||||
for (int i = 0; i < CARD_ICON_MAX; ++i)
|
||||
statOut.x44_offsetIcon[i] = UINT32_MAX;
|
||||
statOut.x44_offsetIcon.fill(UINT32_MAX);
|
||||
statOut.x64_offsetIconTlut = UINT32_MAX;
|
||||
statOut.x68_offsetData = file->m_commentAddr + 64;
|
||||
} else {
|
||||
|
|
@ -580,11 +581,12 @@ ECardResult Card::getStatus(uint32_t fileNo, CardStat& statOut) const {
|
|||
statOut.x40_offsetBannerTlut = cur;
|
||||
cur += TlutSize(statOut.GetBannerFormat());
|
||||
bool palette = false;
|
||||
for (int i = 0; i < CARD_ICON_MAX; ++i) {
|
||||
for (size_t i = 0; i < statOut.x44_offsetIcon.size(); ++i) {
|
||||
statOut.x44_offsetIcon[i] = cur;
|
||||
EImageFormat fmt = statOut.GetIconFormat(i);
|
||||
if (fmt == EImageFormat::C8)
|
||||
const EImageFormat fmt = statOut.GetIconFormat(int(i));
|
||||
if (fmt == EImageFormat::C8) {
|
||||
palette = true;
|
||||
}
|
||||
cur += IconSize(fmt);
|
||||
}
|
||||
if (palette) {
|
||||
|
|
@ -726,11 +728,14 @@ const uint8_t* Card::getCurrentMaker() const {
|
|||
|
||||
void Card::getSerial(uint64_t& serial) {
|
||||
m_ch._swapEndian();
|
||||
uint32_t serialBuf[8];
|
||||
for (uint32_t i = 0; i < 8; i++)
|
||||
serialBuf[i] = SBig(*reinterpret_cast<uint32_t*>(m_ch.__raw + (i * 4)));
|
||||
|
||||
std::array<uint32_t, 8> serialBuf{};
|
||||
for (size_t i = 0; i < serialBuf.size(); i++) {
|
||||
serialBuf[i] = SBig(*reinterpret_cast<uint32_t*>(m_ch.raw.data() + (i * 4)));
|
||||
}
|
||||
serial = uint64_t(serialBuf[0] ^ serialBuf[2] ^ serialBuf[4] ^ serialBuf[6]) << 32 |
|
||||
(serialBuf[1] ^ serialBuf[3] ^ serialBuf[5] ^ serialBuf[7]);
|
||||
|
||||
m_ch._swapEndian();
|
||||
}
|
||||
|
||||
|
|
@ -747,10 +752,11 @@ void Card::getFreeBlocks(int32_t& bytesNotUsed, int32_t& filesNotUsed) {
|
|||
static std::unique_ptr<uint8_t[]> DummyBlock;
|
||||
|
||||
void Card::format(ECardSlot id, ECardSize size, EEncoding encoding) {
|
||||
memset(m_ch.__raw, 0xFF, BlockSize);
|
||||
m_ch.raw.fill(0xFF);
|
||||
|
||||
uint64_t rand = uint64_t(getGCTime());
|
||||
m_ch.m_formatTime = rand;
|
||||
for (int i = 0; i < 12; i++) {
|
||||
for (size_t i = 0; i < m_ch.m_serial.size(); i++) {
|
||||
rand = (((rand * uint64_t(0x41c64e6d)) + uint64_t(0x3039)) >> 16);
|
||||
m_ch.m_serial[i] = uint8_t(g_SRAM.flash_id[uint32_t(id)][i] + uint32_t(rand));
|
||||
rand = (((rand * uint64_t(0x41c64e6d)) + uint64_t(0x3039)) >> 16);
|
||||
|
|
@ -776,30 +782,31 @@ void Card::format(ECardSlot id, ECardSize size, EEncoding encoding) {
|
|||
m_fileHandle = AsyncIO(m_filename.c_str(), true);
|
||||
|
||||
if (m_fileHandle) {
|
||||
uint32_t blockCount = (uint32_t(size) * MbitToBlocks) - 5;
|
||||
const uint32_t blockCount = (uint32_t(size) * MbitToBlocks) - 5;
|
||||
|
||||
m_tmpCh = m_ch;
|
||||
m_tmpCh._swapEndian();
|
||||
m_fileHandle.resizeQueue(5 + blockCount);
|
||||
m_fileHandle.asyncWrite(0, m_tmpCh.__raw, BlockSize, 0);
|
||||
m_fileHandle.asyncWrite(0, m_tmpCh.raw.data(), BlockSize, 0);
|
||||
m_tmpDirs[0] = m_dirs[0];
|
||||
m_tmpDirs[0].swapEndian();
|
||||
m_fileHandle.asyncWrite(1, m_tmpDirs[0].__raw, BlockSize, BlockSize * 1);
|
||||
m_fileHandle.asyncWrite(1, m_tmpDirs[0].raw.data(), BlockSize, BlockSize * 1);
|
||||
m_tmpDirs[1] = m_dirs[1];
|
||||
m_tmpDirs[1].swapEndian();
|
||||
m_fileHandle.asyncWrite(2, m_tmpDirs[1].__raw, BlockSize, BlockSize * 2);
|
||||
m_fileHandle.asyncWrite(2, m_tmpDirs[1].raw.data(), BlockSize, BlockSize * 2);
|
||||
m_tmpBats[0] = m_bats[0];
|
||||
m_tmpBats[0].swapEndian();
|
||||
m_fileHandle.asyncWrite(3, m_tmpBats[0].__raw, BlockSize, BlockSize * 3);
|
||||
m_fileHandle.asyncWrite(3, m_tmpBats[0].raw.data(), BlockSize, BlockSize * 3);
|
||||
m_tmpBats[1] = m_bats[1];
|
||||
m_tmpBats[1].swapEndian();
|
||||
m_fileHandle.asyncWrite(4, m_tmpBats[1].__raw, BlockSize, BlockSize * 4);
|
||||
m_fileHandle.asyncWrite(4, m_tmpBats[1].raw.data(), BlockSize, BlockSize * 4);
|
||||
if (!DummyBlock) {
|
||||
DummyBlock.reset(new uint8_t[BlockSize]);
|
||||
memset(DummyBlock.get(), 0xFF, BlockSize);
|
||||
}
|
||||
for (uint32_t i = 0; i < blockCount; ++i)
|
||||
for (uint32_t i = 0; i < blockCount; ++i) {
|
||||
m_fileHandle.asyncWrite(i + 5, DummyBlock.get(), BlockSize, BlockSize * (i + 5));
|
||||
}
|
||||
m_dirty = false;
|
||||
}
|
||||
}
|
||||
|
|
@ -821,19 +828,19 @@ void Card::commit() {
|
|||
m_tmpDirs[0] = m_dirs[0];
|
||||
m_tmpDirs[0].updateChecksum();
|
||||
m_tmpDirs[0].swapEndian();
|
||||
m_fileHandle.asyncWrite(1, m_tmpDirs[0].__raw, BlockSize, BlockSize * 1);
|
||||
m_fileHandle.asyncWrite(1, m_tmpDirs[0].raw.data(), BlockSize, BlockSize * 1);
|
||||
m_tmpDirs[1] = m_dirs[1];
|
||||
m_tmpDirs[1].updateChecksum();
|
||||
m_tmpDirs[1].swapEndian();
|
||||
m_fileHandle.asyncWrite(2, m_tmpDirs[1].__raw, BlockSize, BlockSize * 2);
|
||||
m_fileHandle.asyncWrite(2, m_tmpDirs[1].raw.data(), BlockSize, BlockSize * 2);
|
||||
m_tmpBats[0] = m_bats[0];
|
||||
m_tmpBats[0].updateChecksum();
|
||||
m_tmpBats[0].swapEndian();
|
||||
m_fileHandle.asyncWrite(3, m_tmpBats[0].__raw, BlockSize, BlockSize * 3);
|
||||
m_fileHandle.asyncWrite(3, m_tmpBats[0].raw.data(), BlockSize, BlockSize * 3);
|
||||
m_tmpBats[1] = m_bats[1];
|
||||
m_tmpBats[1].updateChecksum();
|
||||
m_tmpBats[1].swapEndian();
|
||||
m_fileHandle.asyncWrite(4, m_tmpBats[1].__raw, BlockSize, BlockSize * 4);
|
||||
m_fileHandle.asyncWrite(4, m_tmpBats[1].raw.data(), BlockSize, BlockSize * 4);
|
||||
m_dirty = false;
|
||||
}
|
||||
}
|
||||
|
|
@ -844,15 +851,15 @@ bool Card::open(SystemStringView filepath) {
|
|||
m_fileHandle = AsyncIO(m_filename);
|
||||
if (m_fileHandle) {
|
||||
m_fileHandle.resizeQueue(5);
|
||||
if (!m_fileHandle.asyncRead(0, m_ch.__raw, BlockSize, 0))
|
||||
if (!m_fileHandle.asyncRead(0, m_ch.raw.data(), BlockSize, 0))
|
||||
return false;
|
||||
if (!m_fileHandle.asyncRead(1, m_dirs[0].__raw, BlockSize, BlockSize * 1))
|
||||
if (!m_fileHandle.asyncRead(1, m_dirs[0].raw.data(), BlockSize, BlockSize * 1))
|
||||
return false;
|
||||
if (!m_fileHandle.asyncRead(2, m_dirs[1].__raw, BlockSize, BlockSize * 2))
|
||||
if (!m_fileHandle.asyncRead(2, m_dirs[1].raw.data(), BlockSize, BlockSize * 2))
|
||||
return false;
|
||||
if (!m_fileHandle.asyncRead(3, m_bats[0].__raw, BlockSize, BlockSize * 3))
|
||||
if (!m_fileHandle.asyncRead(3, m_bats[0].raw.data(), BlockSize, BlockSize * 3))
|
||||
return false;
|
||||
if (!m_fileHandle.asyncRead(4, m_bats[1].__raw, BlockSize, BlockSize * 4))
|
||||
if (!m_fileHandle.asyncRead(4, m_bats[1].raw.data(), BlockSize, BlockSize * 4))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
|
@ -882,7 +889,7 @@ ECardResult Card::getError() const {
|
|||
|
||||
uint16_t ckSum, ckSumInv;
|
||||
const_cast<Card&>(*this).m_ch._swapEndian();
|
||||
calculateChecksumBE(reinterpret_cast<const uint16_t*>(m_ch.__raw), 0xFE, &ckSum, &ckSumInv);
|
||||
calculateChecksumBE(reinterpret_cast<const uint16_t*>(m_ch.raw.data()), 0xFE, &ckSum, &ckSumInv);
|
||||
bool res = (ckSum == m_ch.m_checksum && ckSumInv == m_ch.m_checksumInv);
|
||||
const_cast<Card&>(*this).m_ch._swapEndian();
|
||||
|
||||
|
|
|
|||
|
|
@ -16,100 +16,124 @@ void Directory::swapEndian() {
|
|||
|
||||
void Directory::updateChecksum() {
|
||||
swapEndian();
|
||||
calculateChecksumBE(reinterpret_cast<uint16_t*>(__raw), 0xFFE, &m_checksum, &m_checksumInv);
|
||||
calculateChecksumBE(reinterpret_cast<uint16_t*>(raw.data()), 0xFFE, &m_checksum, &m_checksumInv);
|
||||
swapEndian();
|
||||
}
|
||||
|
||||
bool Directory::valid() const {
|
||||
uint16_t ckSum, ckSumInv;
|
||||
const_cast<Directory&>(*this).swapEndian();
|
||||
calculateChecksumBE(reinterpret_cast<const uint16_t*>(__raw), 0xFFE, &ckSum, &ckSumInv);
|
||||
calculateChecksumBE(reinterpret_cast<const uint16_t*>(raw.data()), 0xFFE, &ckSum, &ckSumInv);
|
||||
bool res = (ckSum == m_checksum && ckSumInv == m_checksumInv);
|
||||
const_cast<Directory&>(*this).swapEndian();
|
||||
return res;
|
||||
}
|
||||
|
||||
Directory::Directory() {
|
||||
memset(__raw, 0xFF, BlockSize);
|
||||
raw.fill(0xFF);
|
||||
m_updateCounter = 0;
|
||||
updateChecksum();
|
||||
}
|
||||
|
||||
Directory::Directory(uint8_t data[]) { memcpy(__raw, data, BlockSize); }
|
||||
Directory::Directory(uint8_t data[]) { std::memcpy(raw.data(), data, BlockSize); }
|
||||
|
||||
bool Directory::hasFreeFile() const {
|
||||
for (uint16_t i = 0; i < 127; i++)
|
||||
if (m_files[i].m_game[0] == 0xFF)
|
||||
return true;
|
||||
return false;
|
||||
return std::any_of(m_files.cbegin(), m_files.cend(), [](const auto& file) { return file.m_game[0] == 0xFF; });
|
||||
}
|
||||
|
||||
int32_t Directory::numFreeFiles() const {
|
||||
int32_t ret = 0;
|
||||
for (uint16_t i = 0; i < 127; i++)
|
||||
if (m_files[i].m_game[0] == 0xFF)
|
||||
++ret;
|
||||
return ret;
|
||||
return int32_t(
|
||||
std::count_if(m_files.cbegin(), m_files.cend(), [](const auto& file) { return file.m_game[0] == 0xFF; }));
|
||||
}
|
||||
|
||||
File* Directory::getFirstFreeFile(const char* game, const char* maker, const char* filename) {
|
||||
for (uint16_t i = 0; i < 127; i++) {
|
||||
if (m_files[i].m_game[0] == 0xFF) {
|
||||
File* ret = &m_files[i];
|
||||
*ret = File(filename);
|
||||
if (game && strlen(game) == 4)
|
||||
memcpy(ret->m_game, game, 4);
|
||||
if (maker && strlen(maker) == 2)
|
||||
memcpy(ret->m_maker, maker, 2);
|
||||
return ret;
|
||||
}
|
||||
const auto iter =
|
||||
std::find_if(m_files.begin(), m_files.end(), [](const auto& file) { return file.m_game[0] == 0xFF; });
|
||||
|
||||
if (iter == m_files.cend()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
*iter = File(filename);
|
||||
if (game != nullptr && std::strlen(game) == iter->m_game.size()) {
|
||||
std::memcpy(iter->m_game.data(), game, iter->m_game.size());
|
||||
}
|
||||
if (maker != nullptr && std::strlen(maker) == iter->m_maker.size()) {
|
||||
std::memcpy(iter->m_maker.data(), maker, iter->m_maker.size());
|
||||
}
|
||||
|
||||
return &*iter;
|
||||
}
|
||||
|
||||
File* Directory::getFirstNonFreeFile(uint32_t start, const char* game, const char* maker) {
|
||||
for (uint16_t i = start; i < 127; i++) {
|
||||
if (m_files[i].m_game[0] != 0xFF) {
|
||||
File* ret = &m_files[i];
|
||||
if (game && std::strlen(game) == 4 && std::strncmp(reinterpret_cast<const char*>(ret->m_game), game, 4) != 0)
|
||||
continue;
|
||||
if (maker && std::strlen(maker) == 2 && std::strncmp(reinterpret_cast<const char*>(ret->m_maker), maker, 2) != 0)
|
||||
continue;
|
||||
return ret;
|
||||
const auto iter = std::find_if(m_files.begin(), m_files.end(), [game, maker](const auto& file) {
|
||||
if (file.m_game[0] == 0xFF) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto* const game_ptr = reinterpret_cast<const char*>(file.m_game.data());
|
||||
const auto game_size = file.m_game.size();
|
||||
if (game != nullptr && std::strlen(game) == game_size && std::strncmp(game_ptr, game, game_size) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto* const maker_ptr = reinterpret_cast<const char*>(file.m_maker.data());
|
||||
const auto maker_size = file.m_maker.size();
|
||||
if (maker != nullptr && std::strlen(maker) == maker_size && std::strncmp(maker_ptr, maker, maker_size) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
});
|
||||
|
||||
if (iter == m_files.cend()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
return &*iter;
|
||||
}
|
||||
|
||||
File* Directory::getFile(const char* game, const char* maker, const char* filename) {
|
||||
for (uint16_t i = 0; i < 127; i++) {
|
||||
if (game && strlen(game) == 4 && memcmp(m_files[i].m_game, game, 4))
|
||||
continue;
|
||||
if (maker && strlen(maker) == 2 && memcmp(m_files[i].m_maker, maker, 2))
|
||||
continue;
|
||||
if (!strcmp(m_files[i].m_filename, filename))
|
||||
return &m_files[i];
|
||||
const auto iter = std::find_if(m_files.begin(), m_files.end(), [=](const auto& file) {
|
||||
const auto game_size = file.m_game.size();
|
||||
if (game != nullptr && std::strlen(game) == game_size && std::memcmp(file.m_game.data(), game, game_size) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto maker_size = file.m_maker.size();
|
||||
if (maker != nullptr && std::strlen(maker) == maker_size &&
|
||||
std::memcmp(file.m_maker.data(), maker, maker_size) != 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return std::strcmp(file.m_filename, filename) == 0;
|
||||
});
|
||||
|
||||
if (iter == m_files.cend()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
return &*iter;
|
||||
}
|
||||
|
||||
File* Directory::getFile(uint32_t idx) {
|
||||
if (idx >= 127)
|
||||
if (idx >= m_files.size()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return &m_files[idx];
|
||||
}
|
||||
|
||||
int32_t Directory::indexForFile(File* f) {
|
||||
if (!f)
|
||||
if (f == nullptr) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
auto it = std::find_if(std::begin(m_files), std::end(m_files), [&f](const File& file) -> bool { return f == &file; });
|
||||
if (it == std::end(m_files))
|
||||
const auto it = std::find_if(std::cbegin(m_files), std::cend(m_files), [&f](const File& file) { return f == &file; });
|
||||
if (it == std::cend(m_files)) {
|
||||
return -1;
|
||||
return it - std::begin(m_files);
|
||||
}
|
||||
|
||||
return it - std::cbegin(m_files);
|
||||
}
|
||||
} // namespace kabufuda
|
||||
|
|
|
|||
|
|
@ -1,18 +1,19 @@
|
|||
#include "kabufuda/File.hpp"
|
||||
|
||||
#include <cstring>
|
||||
#include <iterator>
|
||||
|
||||
#include "kabufuda/Util.hpp"
|
||||
|
||||
namespace kabufuda {
|
||||
File::File() { memset(__raw, 0xFF, 0x40); }
|
||||
File::File() { raw.fill(0xFF); }
|
||||
|
||||
File::File(char data[]) { memcpy(__raw, data, 0x40); }
|
||||
File::File(char data[]) { std::memcpy(raw.data(), data, raw.size()); }
|
||||
|
||||
File::File(const char* filename) {
|
||||
memset(__raw, 0, 0x40);
|
||||
memset(m_filename, 0, 32);
|
||||
strncpy(m_filename, filename, 32);
|
||||
raw.fill(0);
|
||||
std::memset(m_filename, 0, std::size(m_filename));
|
||||
std::strncpy(m_filename, filename, std::size(m_filename));
|
||||
}
|
||||
void File::swapEndian() {
|
||||
m_modifiedTime = SBig(m_modifiedTime);
|
||||
|
|
|
|||
Loading…
Reference in New Issue