AxioDL/kabufuda
2
0
Fork 0
mirror of https://github.com/AxioDL/kabufuda.git synced 2025-06-16 19:43:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Formatting pass

Browse Source
This commit is contained in:
Phillip Stephens 2016-09-05 13:56:09 -07:00
parent d0791ebd21
commit b082a92fb2
13 changed files with 268 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
.clang-format Normal file
View File

@ -0,0 +1,29 @@
---
IndentWidth: 4
ColumnLimit: 120
UseTab: Never
---
Language: Cpp
DerivePointerAlignment: false
PointerAlignment: Left
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
BreakBeforeBraces: Allman
IndentCaseLabels: false
AllowShortBlocksOnASingleLine: true
AlignOperands: true
AlignTrailingComments: true
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: true
BreakConstructorInitializersBeforeComma: true
AlwaysBreakAfterReturnType: None
AlwaysBreakAfterDefinitionReturnType: None
AllowShortFunctionsOnASingleLine: All
Cpp11BracedListStyle: true
NamespaceIndentation: None
BinPackArguments: true
BinPackParameters: true
SortIncludes: false
AccessModifierOffset: -4
ConstructorInitializerIndentWidth: 0
ConstructorInitializerAllOnOneLineOrOnePerLine: true

3
include/kabufuda/BlockAllocationTable.hpp
View File

@ -9,8 +9,7 @@ class BlockAllocationTable
{ {
friend class Card; friend class Card;
#pragma pack(push, 4) #pragma pack(push, 4)
union union {
{
struct struct
{ {
uint16_t m_checksum; uint16_t m_checksum;

14
include/kabufuda/Card.hpp
View File

@ -22,8 +22,7 @@ public:
class Card class Card
{ {
#pragma pack(push, 4) #pragma pack(push, 4)
union union {
{
struct struct
{ {
uint8_t m_serial[12]; uint8_t m_serial[12];
@ -63,6 +62,7 @@ class Card
void _updateDirAndBat(); void _updateDirAndBat();
void _updateChecksum(); void _updateChecksum();
File* _fileFromHandle(const std::unique_ptr<IFileHandle>& fh) const; File* _fileFromHandle(const std::unique_ptr<IFileHandle>& fh) const;
public: public:
Card(); Card();
/** /**
@ -76,7 +76,7 @@ public:
* @param game * @param game
* @param maker * @param maker
*/ */
Card(const SystemString& filepath, const char* game = nullptr, const char* maker=nullptr); Card(const SystemString& filepath, const char* game = nullptr, const char* maker = nullptr);
~Card(); ~Card();
/** /**
@ -297,7 +297,7 @@ public:
* @param dest The destination Card instance * @param dest The destination Card instance
* @return True if successful, false otherwise * @return True if successful, false otherwise
*/ */
bool copyFileTo(const std::unique_ptr<IFileHandle>&fh, Card& dest); bool copyFileTo(const std::unique_ptr<IFileHandle>& fh, Card& dest);
/** /**
* @brief moveFileTo * @brief moveFileTo
@ -305,7 +305,7 @@ public:
* @param dest * @param dest
* @return * @return
*/ */
bool moveFileTo(const std::unique_ptr<IFileHandle>&fh, Card& dest); bool moveFileTo(const std::unique_ptr<IFileHandle>& fh, Card& dest);
/** /**
* @brief Sets the current game, if not null any openFile requests will only return files that match this game * @brief Sets the current game, if not null any openFile requests will only return files that match this game
@ -355,7 +355,8 @@ public:
void format(EDeviceId deviceId, ECardSize size = ECardSize::Card2043Mb, EEncoding encoding = EEncoding::ASCII); void format(EDeviceId deviceId, ECardSize size = ECardSize::Card2043Mb, EEncoding encoding = EEncoding::ASCII);
/** /**
* @brief Returns the size of the file in Megabits from a file on disk, useful for determining filesize ahead of time. * @brief Returns the size of the file in Megabits from a file on disk, useful for determining filesize ahead of
* time.
* @return Size of file in Megabits * @return Size of file in Megabits
*/ */
static uint32_t getSizeMbitFromFile(const SystemString& filename); static uint32_t getSizeMbitFromFile(const SystemString& filename);
@ -371,4 +372,3 @@ public:
} }
#endif // __CARD_HPP__ #endif // __CARD_HPP__

1
include/kabufuda/Constants.hpp
View File

@ -25,7 +25,6 @@ enum class EPermissions : uint8_t
}; };
ENABLE_BITWISE_ENUM(EPermissions) ENABLE_BITWISE_ENUM(EPermissions)
enum class EImageFormat : uint8_t enum class EImageFormat : uint8_t
{ {
None, None,

3
include/kabufuda/Directory.hpp
View File

@ -9,8 +9,7 @@ class Directory
{ {
friend class Card; friend class Card;
#pragma pack(push, 4) #pragma pack(push, 4)
union union {
{
struct struct
{ {
File m_files[MaxFiles]; File m_files[MaxFiles];

4
include/kabufuda/File.hpp
View File

@ -11,8 +11,7 @@ class File
friend class Directory; friend class Directory;
friend class Card; friend class Card;
#pragma pack(push, 4) #pragma pack(push, 4)
union union {
{
struct struct
{ {
uint8_t m_game[4]; uint8_t m_game[4];
@ -43,7 +42,6 @@ public:
File(const char* filename); File(const char* filename);
~File() {} ~File() {}
}; };
} }
#endif // __KABU_FILE_HPP__ #endif // __KABU_FILE_HPP__

231
include/kabufuda/Util.hpp
View File

@ -35,37 +35,36 @@
#undef bswap64 #undef bswap64
#ifndef ENABLE_BITWISE_ENUM #ifndef ENABLE_BITWISE_ENUM
#define ENABLE_BITWISE_ENUM(type)\ #define ENABLE_BITWISE_ENUM(type) \
constexpr type operator|(type a, type b)\ constexpr type operator|(type a, type b) \
{\ { \
using T = std::underlying_type_t<type>;\ using T = std::underlying_type_t<type>; \
return type(static_cast<T>(a) | static_cast<T>(b));\ return type(static_cast<T>(a) | static_cast<T>(b)); \
}\ } \
constexpr type operator&(type a, type b)\ constexpr type operator&(type a, type b) \
{\ { \
using T = std::underlying_type_t<type>;\ using T = std::underlying_type_t<type>; \
return type(static_cast<T>(a) & static_cast<T>(b));\ return type(static_cast<T>(a) & static_cast<T>(b)); \
}\ } \
inline type& operator|=(type& a, const type& b)\ inline type& operator|=(type& a, const type& b) \
{\ { \
using T = std::underlying_type_t<type>;\ using T = std::underlying_type_t<type>; \
a = type(static_cast<T>(a) | static_cast<T>(b));\ a = type(static_cast<T>(a) | static_cast<T>(b)); \
return a;\ return a; \
}\ } \
inline type& operator&=(type& a, const type& b)\ inline type& operator&=(type& a, const type& b) \
{\ { \
using T = std::underlying_type_t<type>;\ using T = std::underlying_type_t<type>; \
a = type(static_cast<T>(a) & static_cast<T>(b));\ a = type(static_cast<T>(a) & static_cast<T>(b)); \
return a;\ return a; \
}\ } \
inline type operator~(const type& key)\ inline type operator~(const type& key) \
{\ { \
using T = std::underlying_type_t<type>;\ using T = std::underlying_type_t<type>; \
return type(~static_cast<T>(key));\ return type(~static_cast<T>(key)); \
} }
#endif #endif
namespace kabufuda namespace kabufuda
{ {
@ -104,25 +103,20 @@ static inline T bswap64(T val)
#elif _WIN32 #elif _WIN32
return _byteswap_uint64(val); return _byteswap_uint64(val);
#else #else
return ((val & 0xFF00000000000000ULL) >> 56) | return ((val & 0xFF00000000000000ULL) >> 56) | ((val & 0x00FF000000000000ULL) >> 40) |
((val & 0x00FF000000000000ULL) >> 40) | ((val & 0x0000FF0000000000ULL) >> 24) | ((val & 0x000000FF00000000ULL) >> 8) |
((val & 0x0000FF0000000000ULL) >> 24) | ((val & 0x00000000FF000000ULL) << 8) | ((val & 0x0000000000FF0000ULL) << 24) |
((val & 0x000000FF00000000ULL) >> 8) | ((val & 0x000000000000FF00ULL) << 40) | ((val & 0x00000000000000FFULL) << 56);
((val & 0x00000000FF000000ULL) << 8) |
((val & 0x0000000000FF0000ULL) << 24) |
((val & 0x000000000000FF00ULL) << 40) |
((val & 0x00000000000000FFULL) << 56);
#endif #endif
} }
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
static inline int16_t SBig(int16_t val) {return bswap16(val);} static inline int16_t SBig(int16_t val) { return bswap16(val); }
static inline uint16_t SBig(uint16_t val) {return bswap16(val);} static inline uint16_t SBig(uint16_t val) { return bswap16(val); }
static inline int32_t SBig(int32_t val) {return bswap32(val);} static inline int32_t SBig(int32_t val) { return bswap32(val); }
static inline uint32_t SBig(uint32_t val) {return bswap32(val);} static inline uint32_t SBig(uint32_t val) { return bswap32(val); }
static inline int64_t SBig(int64_t val) {return bswap64(val);} static inline int64_t SBig(int64_t val) { return bswap64(val); }
static inline uint64_t SBig(uint64_t val) {return bswap64(val);} static inline uint64_t SBig(uint64_t val) { return bswap64(val); }
static inline float SBig(float val) static inline float SBig(float val)
{ {
int32_t ival = bswap32(*((int32_t*)(&val))); int32_t ival = bswap32(*((int32_t*)(&val)));
@ -133,25 +127,24 @@ static inline double SBig(double val)
int64_t ival = bswap64(*((int64_t*)(&val))); int64_t ival = bswap64(*((int64_t*)(&val)));
return *((double*)(&ival)); return *((double*)(&ival));
} }
#define SBIG(q) ( ( (q) & 0x000000FF ) << 24 | ( (q) & 0x0000FF00 ) << 8 \ #define SBIG(q) (((q)&0x000000FF) << 24 | ((q)&0x0000FF00) << 8 | ((q)&0x00FF0000) >> 8 | ((q)&0xFF000000) >> 24)
| ( (q) & 0x00FF0000 ) >> 8 | ( (q) & 0xFF000000 ) >> 24 )
static inline int16_t SLittle(int16_t val) {return val;} static inline int16_t SLittle(int16_t val) { return val; }
static inline uint16_t SLittle(uint16_t val) {return val;} static inline uint16_t SLittle(uint16_t val) { return val; }
static inline int32_t SLittle(int32_t val) {return val;} static inline int32_t SLittle(int32_t val) { return val; }
static inline uint32_t SLittle(uint32_t val) {return val;} static inline uint32_t SLittle(uint32_t val) { return val; }
static inline int64_t SLittle(int64_t val) {return val;} static inline int64_t SLittle(int64_t val) { return val; }
static inline uint64_t SLittle(uint64_t val) {return val;} static inline uint64_t SLittle(uint64_t val) { return val; }
static inline float SLittle(float val) {return val;} static inline float SLittle(float val) { return val; }
static inline double SLittle(double val) {return val;} static inline double SLittle(double val) { return val; }
#define SLITTLE(q) (q) #define SLITTLE(q) (q)
#else #else
static inline int16_t SLittle(int16_t val) {return bswap16(val);} static inline int16_t SLittle(int16_t val) { return bswap16(val); }
static inline uint16_t SLittle(uint16_t val) {return bswap16(val);} static inline uint16_t SLittle(uint16_t val) { return bswap16(val); }
static inline int32_t SLittle(int32_t val) {return bswap32(val);} static inline int32_t SLittle(int32_t val) { return bswap32(val); }
static inline uint32_t SLittle(uint32_t val) {return bswap32(val);} static inline uint32_t SLittle(uint32_t val) { return bswap32(val); }
static inline int64_t SLittle(int64_t val) {return bswap64(val);} static inline int64_t SLittle(int64_t val) { return bswap64(val); }
static inline uint64_t SLittle(uint64_t val) {return bswap64(val);} static inline uint64_t SLittle(uint64_t val) { return bswap64(val); }
static inline float SLittle(float val) static inline float SLittle(float val)
{ {
int32_t ival = bswap32(*((int32_t*)(&val))); int32_t ival = bswap32(*((int32_t*)(&val)));
@ -162,96 +155,91 @@ static inline double SLittle(double val)
int64_t ival = bswap64(*((int64_t*)(&val))); int64_t ival = bswap64(*((int64_t*)(&val)));
return *((double*)(&ival)); return *((double*)(&ival));
} }
#define SLITTLE(q) ( ( (q) & 0x000000FF ) << 24 | ( (q) & 0x0000FF00 ) << 8 \ #define SLITTLE(q) (((q)&0x000000FF) << 24 | ((q)&0x0000FF00) << 8 | ((q)&0x00FF0000) >> 8 | ((q)&0xFF000000) >> 24)
| ( (q) & 0x00FF0000 ) >> 8 | ( (q) & 0xFF000000 ) >> 24 )
static inline int16_t SBig(int16_t val) {return val;} static inline int16_t SBig(int16_t val) { return val; }
static inline uint16_t SBig(uint16_t val) {return val;} static inline uint16_t SBig(uint16_t val) { return val; }
static inline int32_t SBig(int32_t val) {return val;} static inline int32_t SBig(int32_t val) { return val; }
static inline uint32_t SBig(uint32_t val) {return val;} static inline uint32_t SBig(uint32_t val) { return val; }
static inline int64_t SBig(int64_t val) {return val;} static inline int64_t SBig(int64_t val) { return val; }
static inline uint64_t SBig(uint64_t val) {return val;} static inline uint64_t SBig(uint64_t val) { return val; }
static inline float SBig(float val) {return val;} static inline float SBig(float val) { return val; }
static inline double SBig(double val) {return val;} static inline double SBig(double val) { return val; }
#define SBIG(q) (q) #define SBIG(q) (q)
#endif #endif
#if CARD_UCS2 #if CARD_UCS2
typedef wchar_t SystemChar; typedef wchar_t SystemChar;
static inline size_t StrLen(const SystemChar* str) {return wcslen(str);} static inline size_t StrLen(const SystemChar* str) { return wcslen(str); }
typedef std::wstring SystemString; typedef std::wstring SystemString;
static inline void ToLower(SystemString& str) static inline void ToLower(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), towlower); }
{std::transform(str.begin(), str.end(), str.begin(), towlower);} static inline void ToUpper(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), towupper); }
static inline void ToUpper(SystemString& str)
{std::transform(str.begin(), str.end(), str.begin(), towupper);}
class SystemUTF8View class SystemUTF8View
{ {
std::string m_utf8; std::string m_utf8;
public: public:
explicit SystemUTF8View(const SystemString& str) explicit SystemUTF8View(const SystemString& str) : m_utf8(WideToUTF8(str)) {}
: m_utf8(WideToUTF8(str)) {} operator const std::string&() const { return m_utf8; }
operator const std::string&() const {return m_utf8;} const std::string& str() const { return m_utf8; }
const std::string& str() const {return m_utf8;} const char* c_str() const { return m_utf8.c_str(); }
const char* c_str() const {return m_utf8.c_str();} std::string operator+(const std::string& other) const { return m_utf8 + other; }
std::string operator+(const std::string& other) const {return m_utf8 + other;} std::string operator+(const char* other) const { return m_utf8 + other; }
std::string operator+(const char* other) const {return m_utf8 + other;}
}; };
inline std::string operator+(const std::string& lhs, const SystemUTF8View& rhs) {return lhs + std::string(rhs);} inline std::string operator+(const std::string& lhs, const SystemUTF8View& rhs) { return lhs + std::string(rhs); }
inline std::string operator+(const char* lhs, const SystemUTF8View& rhs) {return lhs + std::string(rhs);} inline std::string operator+(const char* lhs, const SystemUTF8View& rhs) { return lhs + std::string(rhs); }
class SystemStringView class SystemStringView
{ {
std::wstring m_sys; std::wstring m_sys;
public: public:
explicit SystemStringView(const std::string& str) explicit SystemStringView(const std::string& str) : m_sys(UTF8ToWide(str)) {}
: m_sys(UTF8ToWide(str)) {} operator const std::wstring&() const { return m_sys; }
operator const std::wstring&() const {return m_sys;} const std::wstring& sys_str() const { return m_sys; }
const std::wstring& sys_str() const {return m_sys;} const SystemChar* c_str() const { return m_sys.c_str(); }
const SystemChar* c_str() const {return m_sys.c_str();} std::wstring operator+(const std::wstring& other) const { return m_sys + other; }
std::wstring operator+(const std::wstring& other) const {return m_sys + other;} std::wstring operator+(const wchar_t* other) const { return m_sys + other; }
std::wstring operator+(const wchar_t* other) const {return m_sys + other;}
}; };
inline std::wstring operator+(const std::wstring& lhs, const SystemStringView& rhs) {return lhs + std::wstring(rhs);} inline std::wstring operator+(const std::wstring& lhs, const SystemStringView& rhs) { return lhs + std::wstring(rhs); }
inline std::wstring operator+(const wchar_t* lhs, const SystemStringView& rhs) {return lhs + std::wstring(rhs);} inline std::wstring operator+(const wchar_t* lhs, const SystemStringView& rhs) { return lhs + std::wstring(rhs); }
#ifndef _S #ifndef _S
#define _S(val) L ## val #define _S(val) L##val
#endif #endif
typedef struct _stat Sstat; typedef struct _stat Sstat;
#else #else
typedef char SystemChar; typedef char SystemChar;
static inline size_t StrLen(const SystemChar* str) {return strlen(str);} static inline size_t StrLen(const SystemChar* str) { return strlen(str); }
typedef std::string SystemString; typedef std::string SystemString;
static inline void ToLower(SystemString& str) static inline void ToLower(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), tolower); }
{std::transform(str.begin(), str.end(), str.begin(), tolower);} static inline void ToUpper(SystemString& str) { std::transform(str.begin(), str.end(), str.begin(), toupper); }
static inline void ToUpper(SystemString& str)
{std::transform(str.begin(), str.end(), str.begin(), toupper);}
class SystemUTF8View class SystemUTF8View
{ {
const std::string& m_utf8; const std::string& m_utf8;
public: public:
explicit SystemUTF8View(const SystemString& str) explicit SystemUTF8View(const SystemString& str) : m_utf8(str) {}
: m_utf8(str) {} operator const std::string&() const { return m_utf8; }
operator const std::string&() const {return m_utf8;} const std::string& str() const { return m_utf8; }
const std::string& str() const {return m_utf8;} const char* c_str() const { return m_utf8.c_str(); }
const char* c_str() const {return m_utf8.c_str();} std::string operator+(const std::string& other) const { return std::string(m_utf8) + other; }
std::string operator+(const std::string& other) const {return std::string(m_utf8) + other;} std::string operator+(const char* other) const { return std::string(m_utf8) + other; }
std::string operator+(const char* other) const {return std::string(m_utf8) + other;}
}; };
inline std::string operator+(const std::string& lhs, const SystemUTF8View& rhs) {return lhs + std::string(rhs);} inline std::string operator+(const std::string& lhs, const SystemUTF8View& rhs) { return lhs + std::string(rhs); }
inline std::string operator+(const char* lhs, const SystemUTF8View& rhs) {return lhs + std::string(rhs);} inline std::string operator+(const char* lhs, const SystemUTF8View& rhs) { return lhs + std::string(rhs); }
class SystemStringView class SystemStringView
{ {
const std::string& m_sys; const std::string& m_sys;
public: public:
explicit SystemStringView(const std::string& str) explicit SystemStringView(const std::string& str) : m_sys(str) {}
: m_sys(str) {} operator const std::string&() const { return m_sys; }
operator const std::string&() const {return m_sys;} const std::string& sys_str() const { return m_sys; }
const std::string& sys_str() const {return m_sys;} const SystemChar* c_str() const { return m_sys.c_str(); }
const SystemChar* c_str() const {return m_sys.c_str();} std::string operator+(const std::string& other) const { return m_sys + other; }
std::string operator+(const std::string& other) const {return m_sys + other;} std::string operator+(const char* other) const { return m_sys + other; }
std::string operator+(const char* other) const {return m_sys + other;}
}; };
inline std::string operator+(const std::string& lhs, const SystemStringView& rhs) {return lhs + std::string(rhs);} inline std::string operator+(const std::string& lhs, const SystemStringView& rhs) { return lhs + std::string(rhs); }
inline std::string operator+(const char* lhs, const SystemStringView& rhs) {return lhs + std::string(rhs);} inline std::string operator+(const char* lhs, const SystemStringView& rhs) { return lhs + std::string(rhs); }
#ifndef _S #ifndef _S
#define _S(val) val #define _S(val) val
#endif #endif
@ -266,7 +254,7 @@ enum class FileLockType
Read, Read,
Write Write
}; };
static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLockType lock=FileLockType::None) static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLockType lock = FileLockType::None)
{ {
#if CARD_UCS2 #if CARD_UCS2
FILE* fp = _wfopen(path, mode); FILE* fp = _wfopen(path, mode);
@ -282,7 +270,8 @@ static inline FILE* Fopen(const SystemChar* path, const SystemChar* mode, FileLo
{ {
#if _WIN32 #if _WIN32
OVERLAPPED ov = {}; OVERLAPPED ov = {};
LockFileEx((HANDLE)(uintptr_t)_fileno(fp), (lock == FileLockType::Write) ? LOCKFILE_EXCLUSIVE_LOCK : 0, 0, 0, 1, &ov); LockFileEx((HANDLE)(uintptr_t)_fileno(fp), (lock == FileLockType::Write) ? LOCKFILE_EXCLUSIVE_LOCK : 0, 0, 0, 1,
&ov);
#else #else
if (flock(fileno(fp), ((lock == FileLockType::Write) ? LOCK_EX : LOCK_SH) | LOCK_NB)) if (flock(fileno(fp), ((lock == FileLockType::Write) ? LOCK_EX : LOCK_SH) | LOCK_NB))
fprintf(stderr, "flock %s: %s", path, strerror(errno)); fprintf(stderr, "flock %s: %s", path, strerror(errno));
@ -327,7 +316,9 @@ static inline int Stat(const SystemChar* path, Sstat* statOut)
{ {
#if CARD_UCS2 #if CARD_UCS2
size_t pos; size_t pos;
for (pos=0 ; pos<3 && path[pos] != L'\0' ; ++pos) {} for (pos = 0; pos < 3 && path[pos] != L'\0'; ++pos)
{
}
if (pos == 2 && path[1] == L':') if (pos == 2 && path[1] == L':')
{ {
SystemChar fixPath[4] = {path[0], L':', L'/', L'\0'}; SystemChar fixPath[4] = {path[0], L':', L'/', L'\0'};

10
lib/kabufuda/BlockAllocationTable.cpp
View File

@ -2,7 +2,6 @@
#include "kabufuda/Util.hpp" #include "kabufuda/Util.hpp"
#include <vector> #include <vector>
namespace kabufuda namespace kabufuda
{ {
void BlockAllocationTable::swapEndian() void BlockAllocationTable::swapEndian()
@ -12,9 +11,7 @@ void BlockAllocationTable::swapEndian()
m_updateCounter = SBig(m_updateCounter); m_updateCounter = SBig(m_updateCounter);
m_freeBlocks = SBig(m_freeBlocks); m_freeBlocks = SBig(m_freeBlocks);
m_lastAllocated = SBig(m_lastAllocated); m_lastAllocated = SBig(m_lastAllocated);
std::for_each(std::begin(m_map), std::end(m_map), [](uint16_t& val){ std::for_each(std::begin(m_map), std::end(m_map), [](uint16_t& val) { val = SBig(val); });
val = SBig(val);
});
} }
void BlockAllocationTable::updateChecksum() void BlockAllocationTable::updateChecksum()
@ -41,8 +38,7 @@ BlockAllocationTable::BlockAllocationTable(uint32_t blockCount)
updateChecksum(); updateChecksum();
} }
BlockAllocationTable::~BlockAllocationTable() BlockAllocationTable::~BlockAllocationTable() {}
{}
uint16_t BlockAllocationTable::getNextBlock(uint16_t block) const uint16_t BlockAllocationTable::getNextBlock(uint16_t block) const
{ {
@ -83,7 +79,7 @@ bool BlockAllocationTable::clear(uint16_t first, uint16_t count)
if (length != count) if (length != count)
return false; return false;
for (size_t i= 0 ; i < length ; ++i) for (size_t i = 0; i < length; ++i)
m_map[blocks.at(i) - FSTBlocks] = 0; m_map[blocks.at(i) - FSTBlocks] = 0;
m_freeBlocks += count; m_freeBlocks += count;
return true; return true;

79
lib/kabufuda/Card.cpp
View File

@ -8,26 +8,21 @@
namespace kabufuda namespace kabufuda
{ {
IFileHandle::~IFileHandle() IFileHandle::~IFileHandle() {}
{
}
class FileHandle : public IFileHandle class FileHandle : public IFileHandle
{ {
friend class Card; friend class Card;
uint32_t idx; uint32_t idx;
int32_t offset =0; int32_t offset = 0;
public: public:
FileHandle() = default; FileHandle() = default;
FileHandle(uint32_t idx) FileHandle(uint32_t idx) : idx(idx) {}
: idx(idx)
{}
virtual ~FileHandle(); virtual ~FileHandle();
}; };
FileHandle::~FileHandle() FileHandle::~FileHandle() {}
{}
void Card::_swapEndian() void Card::_swapEndian()
{ {
@ -43,10 +38,7 @@ void Card::_swapEndian()
m_checksumInv = SBig(m_checksumInv); m_checksumInv = SBig(m_checksumInv);
} }
Card::Card() Card::Card() { memset(__raw, 0xFF, BlockSize); }
{
memset(__raw, 0xFF, BlockSize);
}
Card::Card(const Card& other) Card::Card(const Card& other)
{ {
@ -59,8 +51,7 @@ Card::Card(const Card& other)
memcpy(m_maker, other.m_maker, 2); memcpy(m_maker, other.m_maker, 2);
} }
Card::Card(const SystemString& filename, const char* game, const char* maker) Card::Card(const SystemString& filename, const char* game, const char* maker) : m_filename(filename)
: m_filename(filename)
{ {
memset(__raw, 0xFF, BlockSize); memset(__raw, 0xFF, BlockSize);
if (game && strlen(game) == 4) if (game && strlen(game) == 4)
@ -164,7 +155,7 @@ void Card::_updateChecksum()
_swapEndian(); _swapEndian();
} }
File* Card::_fileFromHandle(const std::unique_ptr<IFileHandle> &fh) const File* Card::_fileFromHandle(const std::unique_ptr<IFileHandle>& fh) const
{ {
if (!fh) if (!fh)
return nullptr; return nullptr;
@ -188,7 +179,6 @@ std::unique_ptr<IFileHandle> Card::createFile(const char* filename, size_t size)
f->m_firstBlock = block; f->m_firstBlock = block;
f->m_blockCount = uint16_t(size / BlockSize); f->m_blockCount = uint16_t(size / BlockSize);
return std::unique_ptr<IFileHandle>(new FileHandle(m_currentDir->indexForFile(f))); return std::unique_ptr<IFileHandle>(new FileHandle(m_currentDir->indexForFile(f)));
} }
return nullptr; return nullptr;
@ -231,7 +221,7 @@ void Card::deleteFile(const std::unique_ptr<IFileHandle>& fh)
FileHandle* f = dynamic_cast<FileHandle*>(fh.get()); FileHandle* f = dynamic_cast<FileHandle*>(fh.get());
uint16_t block = m_currentDir->getFile(f->idx)->m_firstBlock; uint16_t block = m_currentDir->getFile(f->idx)->m_firstBlock;
while(block != 0xFFFF) while (block != 0xFFFF)
{ {
/* TODO: add a fragmentation check */ /* TODO: add a fragmentation check */
uint16_t nextBlock = m_currentBat->getNextBlock(block); uint16_t nextBlock = m_currentBat->getNextBlock(block);
@ -239,7 +229,6 @@ void Card::deleteFile(const std::unique_ptr<IFileHandle>& fh)
block = nextBlock; block = nextBlock;
} }
*m_currentDir->getFile(f->idx) = File(); *m_currentDir->getFile(f->idx) = File();
} }
void Card::write(const std::unique_ptr<IFileHandle>& fh, const void* buf, size_t size) void Card::write(const std::unique_ptr<IFileHandle>& fh, const void* buf, size_t size)
@ -291,7 +280,7 @@ void Card::write(const std::unique_ptr<IFileHandle>& fh, const void* buf, size_t
} }
} }
void Card::read(const std::unique_ptr<IFileHandle> &fh, void *dst, size_t size) void Card::read(const std::unique_ptr<IFileHandle>& fh, void* dst, size_t size)
{ {
if (!fh) if (!fh)
return; return;
@ -339,7 +328,7 @@ void Card::read(const std::unique_ptr<IFileHandle> &fh, void *dst, size_t size)
} }
} }
void Card::seek(const std::unique_ptr<IFileHandle> &fh, int32_t pos, SeekOrigin whence) void Card::seek(const std::unique_ptr<IFileHandle>& fh, int32_t pos, SeekOrigin whence)
{ {
if (!fh) if (!fh)
return; return;
@ -349,7 +338,7 @@ void Card::seek(const std::unique_ptr<IFileHandle> &fh, int32_t pos, SeekOrigin
if (!file) if (!file)
return; return;
switch(whence) switch (whence)
{ {
case SeekOrigin::Begin: case SeekOrigin::Begin:
f->offset = pos; f->offset = pos;
@ -363,7 +352,7 @@ void Card::seek(const std::unique_ptr<IFileHandle> &fh, int32_t pos, SeekOrigin
} }
} }
int32_t Card::tell(const std::unique_ptr<IFileHandle> &fh) int32_t Card::tell(const std::unique_ptr<IFileHandle>& fh)
{ {
if (!fh) if (!fh)
return -1; return -1;
@ -385,7 +374,7 @@ void Card::setPublic(const std::unique_ptr<IFileHandle>& fh, bool pub)
file->m_permissions &= ~EPermissions::Public; file->m_permissions &= ~EPermissions::Public;
} }
bool Card::isPublic(const std::unique_ptr<IFileHandle> &fh) const bool Card::isPublic(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -394,7 +383,7 @@ bool Card::isPublic(const std::unique_ptr<IFileHandle> &fh) const
return bool(file->m_permissions & EPermissions::Public); return bool(file->m_permissions & EPermissions::Public);
} }
void Card::setCanCopy(const std::unique_ptr<IFileHandle> &fh, bool copy) const void Card::setCanCopy(const std::unique_ptr<IFileHandle>& fh, bool copy) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -406,7 +395,7 @@ void Card::setCanCopy(const std::unique_ptr<IFileHandle> &fh, bool copy) const
file->m_permissions |= EPermissions::NoCopy; file->m_permissions |= EPermissions::NoCopy;
} }
bool Card::canCopy(const std::unique_ptr<IFileHandle> &fh) const bool Card::canCopy(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -415,7 +404,7 @@ bool Card::canCopy(const std::unique_ptr<IFileHandle> &fh) const
return !bool(file->m_permissions & EPermissions::NoCopy); return !bool(file->m_permissions & EPermissions::NoCopy);
} }
void Card::setCanMove(const std::unique_ptr<IFileHandle> &fh, bool move) void Card::setCanMove(const std::unique_ptr<IFileHandle>& fh, bool move)
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -427,7 +416,7 @@ void Card::setCanMove(const std::unique_ptr<IFileHandle> &fh, bool move)
file->m_permissions |= EPermissions::NoMove; file->m_permissions |= EPermissions::NoMove;
} }
bool Card::canMove(const std::unique_ptr<IFileHandle> &fh) const bool Card::canMove(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -436,7 +425,7 @@ bool Card::canMove(const std::unique_ptr<IFileHandle> &fh) const
return !bool(file->m_permissions & EPermissions::NoMove); return !bool(file->m_permissions & EPermissions::NoMove);
} }
const char* Card::gameId(const std::unique_ptr<IFileHandle> &fh) const const char* Card::gameId(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -444,7 +433,7 @@ const char* Card::gameId(const std::unique_ptr<IFileHandle> &fh) const
return reinterpret_cast<const char*>(file->m_game); return reinterpret_cast<const char*>(file->m_game);
} }
const char *Card::maker(const std::unique_ptr<IFileHandle> &fh) const const char* Card::maker(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -460,7 +449,7 @@ void Card::setBannerFormat(const std::unique_ptr<IFileHandle>& fh, EImageFormat
file->m_bannerFlags = (file->m_bannerFlags & ~3) | (uint8_t(fmt)); file->m_bannerFlags = (file->m_bannerFlags & ~3) | (uint8_t(fmt));
} }
EImageFormat Card::bannerFormat(const std::unique_ptr<IFileHandle> &fh) const EImageFormat Card::bannerFormat(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -468,7 +457,7 @@ EImageFormat Card::bannerFormat(const std::unique_ptr<IFileHandle> &fh) const
return EImageFormat(file->m_bannerFlags & 3); return EImageFormat(file->m_bannerFlags & 3);
} }
void Card::setIconAnimationType(const std::unique_ptr<IFileHandle> &fh, EAnimationType type) void Card::setIconAnimationType(const std::unique_ptr<IFileHandle>& fh, EAnimationType type)
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -476,7 +465,7 @@ void Card::setIconAnimationType(const std::unique_ptr<IFileHandle> &fh, EAnimati
file->m_bannerFlags = (file->m_bannerFlags & ~4) | uint8_t(type); file->m_bannerFlags = (file->m_bannerFlags & ~4) | uint8_t(type);
} }
EAnimationType Card::iconAnimationType(const std::unique_ptr<IFileHandle> &fh) const EAnimationType Card::iconAnimationType(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -485,7 +474,7 @@ EAnimationType Card::iconAnimationType(const std::unique_ptr<IFileHandle> &fh) c
return EAnimationType(file->m_bannerFlags & 4); return EAnimationType(file->m_bannerFlags & 4);
} }
void Card::setIconFormat(const std::unique_ptr<IFileHandle> &fh, uint32_t idx, EImageFormat fmt) void Card::setIconFormat(const std::unique_ptr<IFileHandle>& fh, uint32_t idx, EImageFormat fmt)
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -494,7 +483,7 @@ void Card::setIconFormat(const std::unique_ptr<IFileHandle> &fh, uint32_t idx, E
file->m_iconFmt = (file->m_iconFmt & ~(3 << (2 * idx))) | (uint16_t(fmt) << (2 * idx)); file->m_iconFmt = (file->m_iconFmt & ~(3 << (2 * idx))) | (uint16_t(fmt) << (2 * idx));
} }
EImageFormat Card::iconFormat(const std::unique_ptr<IFileHandle> &fh, uint32_t idx) const EImageFormat Card::iconFormat(const std::unique_ptr<IFileHandle>& fh, uint32_t idx) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -503,7 +492,7 @@ EImageFormat Card::iconFormat(const std::unique_ptr<IFileHandle> &fh, uint32_t i
return EImageFormat(file->m_iconFmt >> (2 * (idx)) & 3); return EImageFormat(file->m_iconFmt >> (2 * (idx)) & 3);
} }
void Card::setIconSpeed(const std::unique_ptr<IFileHandle> &fh, uint32_t idx, EAnimationSpeed speed) void Card::setIconSpeed(const std::unique_ptr<IFileHandle>& fh, uint32_t idx, EAnimationSpeed speed)
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -512,7 +501,7 @@ void Card::setIconSpeed(const std::unique_ptr<IFileHandle> &fh, uint32_t idx, EA
file->m_animSpeed = (file->m_animSpeed & ~(3 << (2 * idx))) | (uint16_t(speed) << (2 * idx)); file->m_animSpeed = (file->m_animSpeed & ~(3 << (2 * idx))) | (uint16_t(speed) << (2 * idx));
} }
EAnimationSpeed Card::iconSpeed(const std::unique_ptr<IFileHandle> &fh, uint32_t idx) const EAnimationSpeed Card::iconSpeed(const std::unique_ptr<IFileHandle>& fh, uint32_t idx) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -521,7 +510,7 @@ EAnimationSpeed Card::iconSpeed(const std::unique_ptr<IFileHandle> &fh, uint32_t
return EAnimationSpeed((file->m_animSpeed >> (2 * (idx))) & 3); return EAnimationSpeed((file->m_animSpeed >> (2 * (idx))) & 3);
} }
void Card::setImageAddress(const std::unique_ptr<IFileHandle> &fh, uint32_t addr) void Card::setImageAddress(const std::unique_ptr<IFileHandle>& fh, uint32_t addr)
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -529,7 +518,7 @@ void Card::setImageAddress(const std::unique_ptr<IFileHandle> &fh, uint32_t addr
file->m_iconAddress = addr; file->m_iconAddress = addr;
} }
int32_t Card::imageAddress(const std::unique_ptr<IFileHandle> &fh) const int32_t Card::imageAddress(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -537,7 +526,7 @@ int32_t Card::imageAddress(const std::unique_ptr<IFileHandle> &fh) const
return file->m_iconAddress; return file->m_iconAddress;
} }
void Card::setCommentAddress(const std::unique_ptr<IFileHandle> &fh, uint32_t addr) void Card::setCommentAddress(const std::unique_ptr<IFileHandle>& fh, uint32_t addr)
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -545,7 +534,7 @@ void Card::setCommentAddress(const std::unique_ptr<IFileHandle> &fh, uint32_t ad
file->m_commentAddr = addr; file->m_commentAddr = addr;
} }
int32_t Card::commentAddress(const std::unique_ptr<IFileHandle> &fh) const int32_t Card::commentAddress(const std::unique_ptr<IFileHandle>& fh) const
{ {
File* file = _fileFromHandle(fh); File* file = _fileFromHandle(fh);
if (!file) if (!file)
@ -553,7 +542,7 @@ int32_t Card::commentAddress(const std::unique_ptr<IFileHandle> &fh) const
return file->m_commentAddr; return file->m_commentAddr;
} }
bool Card::copyFileTo(const std::unique_ptr<IFileHandle> &fh, Card &dest) bool Card::copyFileTo(const std::unique_ptr<IFileHandle>& fh, Card& dest)
{ {
if (!fh) if (!fh)
return false; return false;
@ -598,7 +587,7 @@ bool Card::copyFileTo(const std::unique_ptr<IFileHandle> &fh, Card &dest)
return true; return true;
} }
bool Card::moveFileTo(const std::unique_ptr<IFileHandle> &fh, Card &dest) bool Card::moveFileTo(const std::unique_ptr<IFileHandle>& fh, Card& dest)
{ {
if (copyFileTo(fh, dest)) if (copyFileTo(fh, dest))
{ {
@ -652,7 +641,7 @@ const uint8_t* Card::getCurrentMaker() const
return nullptr; return nullptr;
} }
void Card::getSerial(uint32_t *s0, uint32_t *s1) void Card::getSerial(uint32_t* s0, uint32_t* s1)
{ {
uint32_t serial[8]; uint32_t serial[8];
for (uint32_t i = 0; i < 8; i++) for (uint32_t i = 0; i < 8; i++)

45
lib/kabufuda/Directory.cpp
View File

@ -2,14 +2,11 @@
#include "kabufuda/Util.hpp" #include "kabufuda/Util.hpp"
#include <cstring> #include <cstring>
namespace kabufuda namespace kabufuda
{ {
void Directory::swapEndian() void Directory::swapEndian()
{ {
std::for_each(std::begin(m_files), std::end(m_files), [](File& f){ std::for_each(std::begin(m_files), std::end(m_files), [](File& f) { f.swapEndian(); });
f.swapEndian();
});
m_updateCounter = SBig(m_updateCounter); m_updateCounter = SBig(m_updateCounter);
m_checksum = SBig(m_checksum); m_checksum = SBig(m_checksum);
@ -39,28 +36,17 @@ Directory::Directory()
updateChecksum(); updateChecksum();
} }
Directory::Directory(uint8_t data[]) Directory::Directory(uint8_t data[]) { memcpy(__raw, data, BlockSize); }
{
memcpy(__raw, data, BlockSize);
}
Directory::Directory(const Directory& other) Directory::Directory(const Directory& other) { memcpy(__raw, other.__raw, BlockSize); }
{
memcpy(__raw, other.__raw, BlockSize);
}
void Directory::operator=(const Directory& other) void Directory::operator=(const Directory& other) { memcpy(__raw, other.__raw, BlockSize); }
{
memcpy(__raw, other.__raw, BlockSize);
}
Directory::~Directory() Directory::~Directory() {}
{
}
File* Directory::getFirstFreeFile(const char* game, const char* maker, const char* filename) File* Directory::getFirstFreeFile(const char* game, const char* maker, const char* filename)
{ {
for (uint16_t i = 0 ; i < 127 ; i++) for (uint16_t i = 0; i < 127; i++)
{ {
if (m_files[i].m_game[0] == 0xFF) if (m_files[i].m_game[0] == 0xFF)
{ {
@ -77,16 +63,18 @@ File* Directory::getFirstFreeFile(const char* game, const char* maker, const cha
return nullptr; return nullptr;
} }
File *Directory::getFirstNonFreeFile(uint32_t start, const char *game, const char *maker) File* Directory::getFirstNonFreeFile(uint32_t start, const char* game, const char* maker)
{ {
for (uint16_t i = start ; i < 127 ; i++) for (uint16_t i = start; i < 127; i++)
{ {
if (m_files[i].m_game[0] != 0xFF) if (m_files[i].m_game[0] != 0xFF)
{ {
File* ret = &m_files[i]; File* ret = &m_files[i];
if (game && std::strlen(game) == 4 && std::strncmp(reinterpret_cast<const char*>(ret->m_game), game, 4) != 0) if (game && std::strlen(game) == 4 &&
std::strncmp(reinterpret_cast<const char*>(ret->m_game), game, 4) != 0)
continue; continue;
if (maker && std::strlen(maker) == 2 && std::strncmp(reinterpret_cast<const char*>(ret->m_maker), maker, 2) != 0) if (maker && std::strlen(maker) == 2 &&
std::strncmp(reinterpret_cast<const char*>(ret->m_maker), maker, 2) != 0)
continue; continue;
return ret; return ret;
} }
@ -97,7 +85,7 @@ File *Directory::getFirstNonFreeFile(uint32_t start, const char *game, const cha
File* Directory::getFile(const char* game, const char* maker, const char* filename) File* Directory::getFile(const char* game, const char* maker, const char* filename)
{ {
for (uint16_t i = 0 ; i < 127 ; i++) for (uint16_t i = 0; i < 127; i++)
{ {
if (game && strlen(game) == 4 && memcmp(m_files[i].m_game, game, 4)) if (game && strlen(game) == 4 && memcmp(m_files[i].m_game, game, 4))
continue; continue;
@ -118,14 +106,13 @@ File* Directory::getFile(uint32_t idx)
return &m_files[idx]; return &m_files[idx];
} }
int32_t Directory::indexForFile(File *f) int32_t Directory::indexForFile(File* f)
{ {
if (!f) if (!f)
return -1; return -1;
auto it = std::find_if(std::begin(m_files), std::end(m_files), [&f](const File& file)->bool{ auto it =
return f == &file; 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)) if (it == std::end(m_files))
return -1; return -1;
return it - std::begin(m_files); return it - std::begin(m_files);

10
lib/kabufuda/File.cpp
View File

@ -3,15 +3,9 @@
namespace kabufuda namespace kabufuda
{ {
File::File() File::File() { memset(__raw, 0xFF, 0x40); }
{
memset(__raw, 0xFF, 0x40);
}
File::File(char data[]) File::File(char data[]) { memcpy(__raw, data, 0x40); }
{
memcpy(__raw, data, 0x40);
}
File::File(const char* filename) File::File(const char* filename)
{ {

6
lib/kabufuda/SRAM.cpp
View File

@ -1,7 +1,7 @@
#include "kabufuda/SRAM.hpp" #include "kabufuda/SRAM.hpp"
namespace kabufuda namespace kabufuda
{ {
// clang-format off
const SRAM g_SRAM = const SRAM g_SRAM =
{{ {{
0xFF, 0x6B, 0xFF, 0x6B,
@ -26,7 +26,5 @@ const SRAM g_SRAM =
0x00, 0x00, 0x00, 0x00,
0x00, 0x00 0x00, 0x00
}}; }};
// clang-format on
} }

2
lib/kabufuda/Util.cpp
View File

@ -6,7 +6,7 @@ namespace kabufuda
uint64_t getGCTime() uint64_t getGCTime()
{ {
time_t sysTime, tzDiff, tzDST; time_t sysTime, tzDiff, tzDST;
struct tm * gmTime; struct tm* gmTime;
time(&sysTime); time(&sysTime);