aiden
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Common: Eliminate more static functions in headers

Browse Source
pull/3518/head
Stenzek 2 months ago
parent d526818d33
commit bcb6f98cbd
No known key found for this signature in database
5 changed files with 89 additions and 92 deletions
Show Stats Download Patch File Download Diff File

22
src/common/align.h
Unescape Escape View File

@ -15,42 +15,42 @@
namespace Common { namespace Common {
template<typename T> template<typename T>
constexpr bool IsAligned(T value, unsigned int alignment) ALWAYS_INLINE constexpr bool IsAligned(T value, unsigned int alignment)
{ {
return (value % static_cast<T>(alignment)) == 0; return (value % static_cast<T>(alignment)) == 0;
} }
template<typename T> template<typename T>
constexpr T AlignUp(T value, unsigned int alignment) ALWAYS_INLINE constexpr T AlignUp(T value, unsigned int alignment)
{ {
return (value + static_cast<T>(alignment - 1)) / static_cast<T>(alignment) * static_cast<T>(alignment); return (value + static_cast<T>(alignment - 1)) / static_cast<T>(alignment) * static_cast<T>(alignment);
} }
template<typename T> template<typename T>
constexpr T AlignDown(T value, unsigned int alignment) ALWAYS_INLINE constexpr T AlignDown(T value, unsigned int alignment)
{ {
return value / static_cast<T>(alignment) * static_cast<T>(alignment); return value / static_cast<T>(alignment) * static_cast<T>(alignment);
} }
template<typename T> template<typename T>
constexpr bool IsAlignedPow2(T value, unsigned int alignment) ALWAYS_INLINE constexpr bool IsAlignedPow2(T value, unsigned int alignment)
{ {
return (value & static_cast<T>(alignment - 1)) == 0; return (value & static_cast<T>(alignment - 1)) == 0;
} }
template<typename T> template<typename T>
constexpr T AlignUpPow2(T value, unsigned int alignment) ALWAYS_INLINE constexpr T AlignUpPow2(T value, unsigned int alignment)
{ {
return (value + static_cast<T>(alignment - 1)) & static_cast<T>(~static_cast<T>(alignment - 1)); return (value + static_cast<T>(alignment - 1)) & static_cast<T>(~static_cast<T>(alignment - 1));
} }
template<typename T> template<typename T>
constexpr T AlignDownPow2(T value, unsigned int alignment) ALWAYS_INLINE constexpr T AlignDownPow2(T value, unsigned int alignment)
{ {
return value & static_cast<T>(~static_cast<T>(alignment - 1)); return value & static_cast<T>(~static_cast<T>(alignment - 1));
} }
template<typename T> template<typename T>
constexpr bool IsPow2(T value) ALWAYS_INLINE constexpr bool IsPow2(T value)
{ {
return (value & (value - 1)) == 0; return (value & (value - 1)) == 0;
} }
template<typename T> template<typename T>
constexpr T PreviousPow2(T value) ALWAYS_INLINE constexpr T PreviousPow2(T value)
{ {
if (value == static_cast<T>(0)) if (value == static_cast<T>(0))
return 0; return 0;
@ -70,7 +70,7 @@ constexpr T PreviousPow2(T value)
/// NOTE: Undefined for values greater than (1 << BITS-1), i.e. 0x80000000 for 32-bit. /// NOTE: Undefined for values greater than (1 << BITS-1), i.e. 0x80000000 for 32-bit.
template<typename T> template<typename T>
constexpr T NextPow2(T value) ALWAYS_INLINE constexpr T NextPow2(T value)
{ {
// https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
if (value == static_cast<T>(0)) if (value == static_cast<T>(0))
@ -90,7 +90,7 @@ constexpr T NextPow2(T value)
return value; return value;
} }
ALWAYS_INLINE static void* AlignedMalloc(size_t size, size_t alignment) ALWAYS_INLINE void* AlignedMalloc(size_t size, size_t alignment)
{ {
#ifdef _MSC_VER #ifdef _MSC_VER
return _aligned_malloc(size, alignment); return _aligned_malloc(size, alignment);
@ -105,7 +105,7 @@ ALWAYS_INLINE static void* AlignedMalloc(size_t size, size_t alignment)
#endif #endif
} }
ALWAYS_INLINE static void AlignedFree(void* ptr) ALWAYS_INLINE void AlignedFree(void* ptr)
{ {
#ifdef _MSC_VER #ifdef _MSC_VER
_aligned_free(ptr); _aligned_free(ptr);

52
src/common/bitutils.h
Unescape Escape View File

@ -14,14 +14,14 @@
// Zero-extending helper // Zero-extending helper
template<typename TReturn, typename TValue> template<typename TReturn, typename TValue>
ALWAYS_INLINE static constexpr TReturn ZeroExtend(TValue value) ALWAYS_INLINE constexpr TReturn ZeroExtend(TValue value)
{ {
return static_cast<TReturn>(static_cast<typename std::make_unsigned<TReturn>::type>( return static_cast<TReturn>(static_cast<typename std::make_unsigned<TReturn>::type>(
static_cast<typename std::make_unsigned<TValue>::type>(value))); static_cast<typename std::make_unsigned<TValue>::type>(value)));
} }
// Sign-extending helper // Sign-extending helper
template<typename TReturn, typename TValue> template<typename TReturn, typename TValue>
ALWAYS_INLINE static constexpr TReturn SignExtend(TValue value) ALWAYS_INLINE constexpr TReturn SignExtend(TValue value)
{ {
return static_cast<TReturn>( return static_cast<TReturn>(
static_cast<typename std::make_signed<TReturn>::type>(static_cast<typename std::make_signed<TValue>::type>(value))); static_cast<typename std::make_signed<TReturn>::type>(static_cast<typename std::make_signed<TValue>::type>(value)));
@ -29,101 +29,101 @@ ALWAYS_INLINE static constexpr TReturn SignExtend(TValue value)
// Type-specific helpers // Type-specific helpers
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u16 ZeroExtend16(TValue value) ALWAYS_INLINE constexpr u16 ZeroExtend16(TValue value)
{ {
return ZeroExtend<u16, TValue>(value); return ZeroExtend<u16, TValue>(value);
} }
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u32 ZeroExtend32(TValue value) ALWAYS_INLINE constexpr u32 ZeroExtend32(TValue value)
{ {
return ZeroExtend<u32, TValue>(value); return ZeroExtend<u32, TValue>(value);
} }
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u64 ZeroExtend64(TValue value) ALWAYS_INLINE constexpr u64 ZeroExtend64(TValue value)
{ {
return ZeroExtend<u64, TValue>(value); return ZeroExtend<u64, TValue>(value);
} }
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u16 SignExtend16(TValue value) ALWAYS_INLINE constexpr u16 SignExtend16(TValue value)
{ {
return SignExtend<u16, TValue>(value); return SignExtend<u16, TValue>(value);
} }
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u32 SignExtend32(TValue value) ALWAYS_INLINE constexpr u32 SignExtend32(TValue value)
{ {
return SignExtend<u32, TValue>(value); return SignExtend<u32, TValue>(value);
} }
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u64 SignExtend64(TValue value) ALWAYS_INLINE constexpr u64 SignExtend64(TValue value)
{ {
return SignExtend<u64, TValue>(value); return SignExtend<u64, TValue>(value);
} }
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u8 Truncate8(TValue value) ALWAYS_INLINE constexpr u8 Truncate8(TValue value)
{ {
return static_cast<u8>(static_cast<typename std::make_unsigned<decltype(value)>::type>(value)); return static_cast<u8>(static_cast<typename std::make_unsigned<decltype(value)>::type>(value));
} }
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u16 Truncate16(TValue value) ALWAYS_INLINE constexpr u16 Truncate16(TValue value)
{ {
return static_cast<u16>(static_cast<typename std::make_unsigned<decltype(value)>::type>(value)); return static_cast<u16>(static_cast<typename std::make_unsigned<decltype(value)>::type>(value));
} }
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr u32 Truncate32(TValue value) ALWAYS_INLINE constexpr u32 Truncate32(TValue value)
{ {
return static_cast<u32>(static_cast<typename std::make_unsigned<decltype(value)>::type>(value)); return static_cast<u32>(static_cast<typename std::make_unsigned<decltype(value)>::type>(value));
} }
// BCD helpers // BCD helpers
ALWAYS_INLINE static constexpr u8 BinaryToBCD(u8 value) ALWAYS_INLINE constexpr u8 BinaryToBCD(u8 value)
{ {
return ((value / 10) << 4) + (value % 10); return ((value / 10) << 4) + (value % 10);
} }
ALWAYS_INLINE static constexpr u8 PackedBCDToBinary(u8 value) ALWAYS_INLINE constexpr u8 PackedBCDToBinary(u8 value)
{ {
return ((value >> 4) * 10) + (value % 16); return ((value >> 4) * 10) + (value % 16);
} }
ALWAYS_INLINE static constexpr u8 IsValidBCDDigit(u8 digit) ALWAYS_INLINE constexpr u8 IsValidBCDDigit(u8 digit)
{ {
return (digit <= 9); return (digit <= 9);
} }
ALWAYS_INLINE static constexpr u8 IsValidPackedBCD(u8 value) ALWAYS_INLINE constexpr u8 IsValidPackedBCD(u8 value)
{ {
return IsValidBCDDigit(value & 0x0F) && IsValidBCDDigit(value >> 4); return IsValidBCDDigit(value & 0x0F) && IsValidBCDDigit(value >> 4);
} }
// Boolean to integer // Boolean to integer
ALWAYS_INLINE static constexpr u8 BoolToUInt8(bool value) ALWAYS_INLINE constexpr u8 BoolToUInt8(bool value)
{ {
return static_cast<u8>(value); return static_cast<u8>(value);
} }
ALWAYS_INLINE static constexpr u16 BoolToUInt16(bool value) ALWAYS_INLINE constexpr u16 BoolToUInt16(bool value)
{ {
return static_cast<u16>(value); return static_cast<u16>(value);
} }
ALWAYS_INLINE static constexpr u32 BoolToUInt32(bool value) ALWAYS_INLINE constexpr u32 BoolToUInt32(bool value)
{ {
return static_cast<u32>(value); return static_cast<u32>(value);
} }
ALWAYS_INLINE static constexpr u64 BoolToUInt64(bool value) ALWAYS_INLINE constexpr u64 BoolToUInt64(bool value)
{ {
return static_cast<u64>(value); return static_cast<u64>(value);
} }
ALWAYS_INLINE static constexpr float BoolToFloat(bool value) ALWAYS_INLINE constexpr float BoolToFloat(bool value)
{ {
return static_cast<float>(value); return static_cast<float>(value);
} }
// Integer to boolean // Integer to boolean
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static constexpr bool ConvertToBool(TValue value) ALWAYS_INLINE constexpr bool ConvertToBool(TValue value)
{ {
return static_cast<bool>(value); return static_cast<bool>(value);
} }
// Unsafe integer to boolean // Unsafe integer to boolean
template<typename TValue> template<typename TValue>
ALWAYS_INLINE static bool ConvertToBoolUnchecked(TValue value) ALWAYS_INLINE bool ConvertToBoolUnchecked(TValue value)
{ {
// static_assert(sizeof(uint8) == sizeof(bool)); // static_assert(sizeof(uint8) == sizeof(bool));
bool ret; bool ret;
@ -133,7 +133,7 @@ ALWAYS_INLINE static bool ConvertToBoolUnchecked(TValue value)
// Generic sign extension // Generic sign extension
template<int NBITS, typename T> template<int NBITS, typename T>
ALWAYS_INLINE static constexpr T SignExtendN(T value) ALWAYS_INLINE constexpr T SignExtendN(T value)
{ {
// http://graphics.stanford.edu/~seander/bithacks.html#VariableSignExtend // http://graphics.stanford.edu/~seander/bithacks.html#VariableSignExtend
constexpr int shift = 8 * sizeof(T) - NBITS; constexpr int shift = 8 * sizeof(T) - NBITS;
@ -142,7 +142,7 @@ ALWAYS_INLINE static constexpr T SignExtendN(T value)
/// Returns the number of zero bits before the first set bit, going MSB->LSB. /// Returns the number of zero bits before the first set bit, going MSB->LSB.
template<typename T> template<typename T>
ALWAYS_INLINE static unsigned CountLeadingZeros(T value) ALWAYS_INLINE unsigned CountLeadingZeros(T value)
{ {
#ifdef _MSC_VER #ifdef _MSC_VER
if constexpr (sizeof(value) >= sizeof(u64)) if constexpr (sizeof(value) >= sizeof(u64))
@ -169,7 +169,7 @@ ALWAYS_INLINE static unsigned CountLeadingZeros(T value)
/// Returns the number of zero bits before the first set bit, going LSB->MSB. /// Returns the number of zero bits before the first set bit, going LSB->MSB.
template<typename T> template<typename T>
ALWAYS_INLINE static unsigned CountTrailingZeros(T value) ALWAYS_INLINE unsigned CountTrailingZeros(T value)
{ {
#ifdef _MSC_VER #ifdef _MSC_VER
if constexpr (sizeof(value) >= sizeof(u64)) if constexpr (sizeof(value) >= sizeof(u64))
@ -194,7 +194,7 @@ ALWAYS_INLINE static unsigned CountTrailingZeros(T value)
// C++23-like std::byteswap() // C++23-like std::byteswap()
template<typename T> template<typename T>
ALWAYS_INLINE static T ByteSwap(T value) ALWAYS_INLINE T ByteSwap(T value)
{ {
if constexpr (std::is_signed_v<T>) if constexpr (std::is_signed_v<T>)
{ {

60
src/common/easing.h
Unescape Escape View File

@ -11,75 +11,75 @@ namespace Easing {
inline constexpr float pi = 3.1415926545f; inline constexpr float pi = 3.1415926545f;
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InSine(T t) ALWAYS_INLINE_RELEASE T InSine(T t)
{ {
return std::sin(1.5707963f * t); return std::sin(1.5707963f * t);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutSine(T t) ALWAYS_INLINE_RELEASE T OutSine(T t)
{ {
return 1 + std::sin(1.5707963f * (--t)); return 1 + std::sin(1.5707963f * (--t));
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutSine(T t) ALWAYS_INLINE_RELEASE T InOutSine(T t)
{ {
return 0.5f * (1 + std::sin(3.1415926f * (t - 0.5f))); return 0.5f * (1 + std::sin(3.1415926f * (t - 0.5f)));
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InQuad(T t) ALWAYS_INLINE_RELEASE T InQuad(T t)
{ {
return t * t; return t * t;
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutQuad(T t) ALWAYS_INLINE_RELEASE T OutQuad(T t)
{ {
return t * (2 - t); return t * (2 - t);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutQuad(T t) ALWAYS_INLINE_RELEASE T InOutQuad(T t)
{ {
return t < 0.5f ? 2 * t * t : t * (4 - 2 * t) - 1; return t < 0.5f ? 2 * t * t : t * (4 - 2 * t) - 1;
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InCubic(T t) ALWAYS_INLINE_RELEASE T InCubic(T t)
{ {
return t * t * t; return t * t * t;
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutCubic(T t) ALWAYS_INLINE_RELEASE T OutCubic(T t)
{ {
return 1 + (--t) * t * t; return 1 + (--t) * t * t;
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutCubic(T t) ALWAYS_INLINE_RELEASE T InOutCubic(T t)
{ {
return t < 0.5f ? 4 * t * t * t : 1 + (--t) * (2 * (--t)) * (2 * t); return t < 0.5f ? 4 * t * t * t : 1 + (--t) * (2 * (--t)) * (2 * t);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InQuart(T t) ALWAYS_INLINE_RELEASE T InQuart(T t)
{ {
t *= t; t *= t;
return t * t; return t * t;
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutQuart(T t) ALWAYS_INLINE_RELEASE T OutQuart(T t)
{ {
t = (--t) * t; t = (--t) * t;
return 1 - t * t; return 1 - t * t;
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutQuart(T t) ALWAYS_INLINE_RELEASE T InOutQuart(T t)
{ {
if (t < 0.5) if (t < 0.5)
{ {
@ -94,21 +94,21 @@ ALWAYS_INLINE_RELEASE static T InOutQuart(T t)
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InQuint(T t) ALWAYS_INLINE_RELEASE T InQuint(T t)
{ {
T t2 = t * t; T t2 = t * t;
return t * t2 * t2; return t * t2 * t2;
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutQuint(T t) ALWAYS_INLINE_RELEASE T OutQuint(T t)
{ {
T t2 = (--t) * t; T t2 = (--t) * t;
return 1 + t * t2 * t2; return 1 + t * t2 * t2;
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutQuint(T t) ALWAYS_INLINE_RELEASE T InOutQuint(T t)
{ {
T t2; T t2;
if (t < 0.5) if (t < 0.5)
@ -124,19 +124,19 @@ ALWAYS_INLINE_RELEASE static T InOutQuint(T t)
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InExpo(T t) ALWAYS_INLINE_RELEASE T InExpo(T t)
{ {
return (std::pow(static_cast<T>(2), static_cast<T>(8) * t) - static_cast<T>(1)) / static_cast<T>(255); return (std::pow(static_cast<T>(2), static_cast<T>(8) * t) - static_cast<T>(1)) / static_cast<T>(255);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutExpo(T t) ALWAYS_INLINE_RELEASE T OutExpo(T t)
{ {
return static_cast<T>(1) - std::pow(static_cast<T>(2), static_cast<T>(-8) * t); return static_cast<T>(1) - std::pow(static_cast<T>(2), static_cast<T>(-8) * t);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutExpo(T t) ALWAYS_INLINE_RELEASE T InOutExpo(T t)
{ {
if (t < 0.5f) if (t < 0.5f)
{ {
@ -149,19 +149,19 @@ ALWAYS_INLINE_RELEASE static T InOutExpo(T t)
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InCirc(T t) ALWAYS_INLINE_RELEASE T InCirc(T t)
{ {
return 1 - std::sqrt(1 - t); return 1 - std::sqrt(1 - t);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutCirc(T t) ALWAYS_INLINE_RELEASE T OutCirc(T t)
{ {
return std::sqrt(t); return std::sqrt(t);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutCirc(T t) ALWAYS_INLINE_RELEASE T InOutCirc(T t)
{ {
if (t < 0.5f) if (t < 0.5f)
{ {
@ -174,20 +174,20 @@ ALWAYS_INLINE_RELEASE static T InOutCirc(T t)
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InBack(T t) ALWAYS_INLINE_RELEASE T InBack(T t)
{ {
return t * t * (2.70158f * t - 1.70158f); return t * t * (2.70158f * t - 1.70158f);
} }
template<typename T> template<typename T>
static T OutBack(T t) ALWAYS_INLINE_RELEASE T OutBack(T t)
{ {
t -= 1; t -= 1;
return 1 + t * t * (2.70158f * t + 1.70158f); return 1 + t * t * (2.70158f * t + 1.70158f);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutBack(T t) ALWAYS_INLINE_RELEASE T InOutBack(T t)
{ {
if (t < 0.5f) if (t < 0.5f)
{ {
@ -200,21 +200,21 @@ ALWAYS_INLINE_RELEASE static T InOutBack(T t)
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InElastic(T t) ALWAYS_INLINE_RELEASE T InElastic(T t)
{ {
T t2 = t * t; T t2 = t * t;
return t2 * t2 * std::sin(t * pi * 4.5f); return t2 * t2 * std::sin(t * pi * 4.5f);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutElastic(T t) ALWAYS_INLINE_RELEASE T OutElastic(T t)
{ {
T t2 = (t - 1) * (t - 1); T t2 = (t - 1) * (t - 1);
return 1 - t2 * t2 * std::cos(t * pi * 4.5f); return 1 - t2 * t2 * std::cos(t * pi * 4.5f);
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutElastic(T t) ALWAYS_INLINE_RELEASE T InOutElastic(T t)
{ {
T t2; T t2;
if (t < 0.45f) if (t < 0.45f)
@ -234,19 +234,19 @@ ALWAYS_INLINE_RELEASE static T InOutElastic(T t)
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InBounce(T t) ALWAYS_INLINE_RELEASE T InBounce(T t)
{ {
return std::pow(2, 6 * (t - 1)) * std::abs(sin(t * pi * 3.5f)); return std::pow(2, 6 * (t - 1)) * std::abs(sin(t * pi * 3.5f));
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T OutBounce(T t) ALWAYS_INLINE_RELEASE T OutBounce(T t)
{ {
return 1 - std::pow(2, -6 * t) * std::abs(std::cos(t * pi * 3.5f)); return 1 - std::pow(2, -6 * t) * std::abs(std::cos(t * pi * 3.5f));
} }
template<typename T> template<typename T>
ALWAYS_INLINE_RELEASE static T InOutBounce(T t) ALWAYS_INLINE_RELEASE T InOutBounce(T t)
{ {
if (t < 0.5f) if (t < 0.5f)
{ {

8
src/common/minizip_helpers.h
Unescape Escape View File

@ -13,7 +13,7 @@
namespace MinizipHelpers { namespace MinizipHelpers {
[[maybe_unused]] static unzFile OpenUnzMemoryFile(const void* memory, size_t memory_size) inline unzFile OpenUnzMemoryFile(const void* memory, size_t memory_size)
{ {
struct MemoryFileInfo struct MemoryFileInfo
{ {
@ -70,7 +70,7 @@ namespace MinizipHelpers {
return unzOpen2_64("", &funcs); return unzOpen2_64("", &funcs);
} }
[[maybe_unused]] static unzFile OpenUnzFile(const char* filename) inline unzFile OpenUnzFile(const char* filename)
{ {
zlib_filefunc64_def funcs; zlib_filefunc64_def funcs;
fill_fopen64_filefunc(&funcs); fill_fopen64_filefunc(&funcs);
@ -90,8 +90,8 @@ namespace MinizipHelpers {
return unzOpen2_64(filename, &funcs); return unzOpen2_64(filename, &funcs);
} }
[[maybe_unused]] static std::optional<std::string> ReadZipFileToString(unzFile zf, const char* filename, inline std::optional<std::string> ReadZipFileToString(unzFile zf, const char* filename, bool case_sensitivity,
bool case_sensitivity, Error* error) Error* error)
{ {
std::optional<std::string> ret; std::optional<std::string> ret;

39
src/common/zip_helpers.h
Unescape Escape View File

@ -16,7 +16,7 @@
namespace ZipHelpers { namespace ZipHelpers {
[[maybe_unused]] static void SetErrorObject(Error* error, std::string_view msg, zip_error_t* ze) inline void SetErrorObject(Error* error, std::string_view msg, zip_error_t* ze)
{ {
Error::SetStringFmt(error, "{}{}", msg, ze ? zip_error_strerror(ze) : "UNKNOWN"); Error::SetStringFmt(error, "{}{}", msg, ze ? zip_error_strerror(ze) : "UNKNOWN");
if (ze) if (ze)
@ -53,7 +53,7 @@ struct ZipFileDeleter
using ManagedZipT = std::unique_ptr<zip_t, ZipDeleter>; using ManagedZipT = std::unique_ptr<zip_t, ZipDeleter>;
using ManagedZipFileT = std::unique_ptr<zip_file_t, ZipFileDeleter>; using ManagedZipFileT = std::unique_ptr<zip_file_t, ZipFileDeleter>;
[[maybe_unused]] static inline ManagedZipT OpenManagedZipFile(const char* filename, int flags, Error* error = nullptr) inline ManagedZipT OpenManagedZipFile(const char* filename, int flags, Error* error = nullptr)
{ {
zip_error_t ze; zip_error_t ze;
zip_source_t* zs = zip_source_file_create(filename, 0, 0, &ze); zip_source_t* zs = zip_source_file_create(filename, 0, 0, &ze);
@ -76,7 +76,7 @@ using ManagedZipFileT = std::unique_ptr<zip_file_t, ZipFileDeleter>;
return ManagedZipT(zip); return ManagedZipT(zip);
} }
[[maybe_unused]] static inline ManagedZipT OpenManagedZipCFile(std::FILE* fp, int flags, Error* error = nullptr) inline ManagedZipT OpenManagedZipCFile(std::FILE* fp, int flags, Error* error = nullptr)
{ {
zip_error_t ze; zip_error_t ze;
zip_source_t* zs = zip_source_filep_create(fp, 0, 0, &ze); zip_source_t* zs = zip_source_filep_create(fp, 0, 0, &ze);
@ -100,8 +100,8 @@ using ManagedZipFileT = std::unique_ptr<zip_file_t, ZipFileDeleter>;
return ManagedZipT(zip); return ManagedZipT(zip);
} }
[[maybe_unused]] static inline ManagedZipT OpenManagedZipBuffer(const void* buffer, size_t size, int flags, inline ManagedZipT OpenManagedZipBuffer(const void* buffer, size_t size, int flags, bool free_buffer,
bool free_buffer, Error* error = nullptr) Error* error = nullptr)
{ {
zip_error_t ze; zip_error_t ze;
zip_source_t* zs = zip_source_buffer_create(buffer, size, free_buffer, &ze); zip_source_t* zs = zip_source_buffer_create(buffer, size, free_buffer, &ze);
@ -126,8 +126,7 @@ using ManagedZipFileT = std::unique_ptr<zip_file_t, ZipFileDeleter>;
return ManagedZipT(zip); return ManagedZipT(zip);
} }
[[maybe_unused]] static inline ManagedZipFileT OpenManagedFileInZip(zip_t* zip, const char* filename, zip_flags_t flags, inline ManagedZipFileT OpenManagedFileInZip(zip_t* zip, const char* filename, zip_flags_t flags, Error* error = nullptr)
Error* error = nullptr)
{ {
zip_file_t* zf = zip_fopen(zip, filename, flags); zip_file_t* zf = zip_fopen(zip, filename, flags);
if (!zf) if (!zf)
@ -135,8 +134,8 @@ using ManagedZipFileT = std::unique_ptr<zip_file_t, ZipFileDeleter>;
return ManagedZipFileT(zf); return ManagedZipFileT(zf);
} }
[[maybe_unused]] static inline ManagedZipFileT OpenManagedFileIndexInZip(zip_t* zip, zip_uint64_t index, inline ManagedZipFileT OpenManagedFileIndexInZip(zip_t* zip, zip_uint64_t index, zip_flags_t flags,
zip_flags_t flags, Error* error = nullptr) Error* error = nullptr)
{ {
zip_file_t* zf = zip_fopen_index(zip, index, flags); zip_file_t* zf = zip_fopen_index(zip, index, flags);
if (!zf) if (!zf)
@ -145,8 +144,8 @@ using ManagedZipFileT = std::unique_ptr<zip_file_t, ZipFileDeleter>;
} }
template<typename T> template<typename T>
[[maybe_unused]] static inline std::optional<T> inline std::optional<T> ReadFileInZipToContainer(zip_t* zip, const char* name, bool case_sensitive = true,
ReadFileInZipToContainer(zip_t* zip, const char* name, bool case_sensitive = true, Error* error = nullptr) Error* error = nullptr)
{ {
const int flags = case_sensitive ? 0 : ZIP_FL_NOCASE; const int flags = case_sensitive ? 0 : ZIP_FL_NOCASE;
@ -185,8 +184,7 @@ ReadFileInZipToContainer(zip_t* zip, const char* name, bool case_sensitive = tru
} }
template<typename T> template<typename T>
[[maybe_unused]] static inline std::optional<T> ReadFileInZipToContainer(zip_file_t* file, u32 chunk_size = 4096, inline std::optional<T> ReadFileInZipToContainer(zip_file_t* file, u32 chunk_size = 4096, Error* error = nullptr)
Error* error = nullptr)
{ {
std::optional<T> ret = T(); std::optional<T> ret = T();
for (;;) for (;;)
@ -212,26 +210,25 @@ template<typename T>
return ret; return ret;
} }
[[maybe_unused]] static inline std::optional<std::string> inline std::optional<std::string> ReadFileInZipToString(zip_t* zip, const char* name, bool case_sensitive = true,
ReadFileInZipToString(zip_t* zip, const char* name, bool case_sensitive = true, Error* error = nullptr) Error* error = nullptr)
{ {
return ReadFileInZipToContainer<std::string>(zip, name, case_sensitive, error); return ReadFileInZipToContainer<std::string>(zip, name, case_sensitive, error);
} }
[[maybe_unused]] static inline std::optional<std::string> ReadFileInZipToString(zip_file_t* file, u32 chunk_size = 4096, inline std::optional<std::string> ReadFileInZipToString(zip_file_t* file, u32 chunk_size = 4096, Error* error = nullptr)
Error* error = nullptr)
{ {
return ReadFileInZipToContainer<std::string>(file, chunk_size, error); return ReadFileInZipToContainer<std::string>(file, chunk_size, error);
} }
[[maybe_unused]] static inline std::optional<std::vector<u8>> inline std::optional<std::vector<u8>> ReadBinaryFileInZip(zip_t* zip, const char* name, bool case_sensitive = true,
ReadBinaryFileInZip(zip_t* zip, const char* name, bool case_sensitive = true, Error* error = nullptr) Error* error = nullptr)
{ {
return ReadFileInZipToContainer<std::vector<u8>>(zip, name, case_sensitive, error); return ReadFileInZipToContainer<std::vector<u8>>(zip, name, case_sensitive, error);
} }
[[maybe_unused]] static inline std::optional<std::vector<u8>> inline std::optional<std::vector<u8>> ReadBinaryFileInZip(zip_file_t* file, u32 chunk_size = 4096,
ReadBinaryFileInZip(zip_file_t* file, u32 chunk_size = 4096, Error* error = nullptr) Error* error = nullptr)
{ {
return ReadFileInZipToContainer<std::vector<u8>>(file, chunk_size, error); return ReadFileInZipToContainer<std::vector<u8>>(file, chunk_size, error);
} }

Write Preview
Loading…
Cancel
Save