mirrors/Panda3DS
0
0
Fork 0
mirror of https://github.com/wheremyfoodat/Panda3DS.git synced 2025-09-26 03:08:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Formatting fixes (#781)

Browse source 
* Formatting

* More formatting

* More formatting

* More formatting
This commit is contained in:
wheremyfoodat 2025-07-21 00:33:24 +03:00 • committed by GitHub
commit 146dc92a0f
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 408 additions and 532 deletions
Download patch file Download diff file Expand all files Collapse all files

211
include/PICA/float_types.hpp
View file

@ -6,156 +6,125 @@
#include <cmath> #include <cmath>
#include <cstring> #include <cstring>
#include "helpers.hpp" #include "helpers.hpp"
namespace Floats { namespace Floats {
/** /**
* Template class for converting arbitrary Pica float types to IEEE 754 32-bit single-precision * Template class for converting arbitrary Pica float types to IEEE 754 32-bit single-precision
* floating point. * floating point.
* *
* When decoding, format is as follows: * When decoding, format is as follows:
* - The first `M` bits are the mantissa * - The first `M` bits are the mantissa
* - The next `E` bits are the exponent * - The next `E` bits are the exponent
* - The last bit is the sign bit * - The last bit is the sign bit
* *
* @todo Verify on HW if this conversion is sufficiently accurate. * @todo Verify on HW if this conversion is sufficiently accurate.
*/ */
template <unsigned M, unsigned E> template <unsigned M, unsigned E>
struct Float { struct Float {
public: public:
static Float<M, E> fromFloat32(float val) { static Float<M, E> fromFloat32(float val) {
Float<M, E> ret; Float<M, E> ret;
ret.value = val; ret.value = val;
return ret; return ret;
} }
static Float<M, E> fromRaw(u32 hex) { static Float<M, E> fromRaw(u32 hex) {
Float<M, E> res; Float<M, E> res;
const int width = M + E + 1; const int width = M + E + 1;
const int bias = 128 - (1 << (E - 1)); const int bias = 128 - (1 << (E - 1));
int exponent = (hex >> M) & ((1 << E) - 1); int exponent = (hex >> M) & ((1 << E) - 1);
const unsigned mantissa = hex & ((1 << M) - 1); const unsigned mantissa = hex & ((1 << M) - 1);
const unsigned sign = (hex >> (E + M)) << 31; const unsigned sign = (hex >> (E + M)) << 31;
if (hex & ((1 << (width - 1)) - 1)) { if (hex & ((1 << (width - 1)) - 1)) {
if (exponent == (1 << E) - 1) if (exponent == (1 << E) - 1)
exponent = 255; exponent = 255;
else else
exponent += bias; exponent += bias;
hex = sign | (mantissa << (23 - M)) | (exponent << 23); hex = sign | (mantissa << (23 - M)) | (exponent << 23);
} } else {
else { hex = sign;
hex = sign; }
}
std::memcpy(&res.value, &hex, sizeof(float)); std::memcpy(&res.value, &hex, sizeof(float));
return res; return res;
} }
static Float<M, E> zero() { static Float<M, E> zero() { return fromFloat32(0.f); }
return fromFloat32(0.f);
}
// Not recommended for anything but logging // Not recommended for anything but logging
float toFloat32() const { float toFloat32() const { return value; }
return value;
}
double toFloat64() const { double toFloat64() const { return static_cast<double>(value); }
return static_cast<double>(value);
}
operator float() { operator float() { return toFloat32(); }
return toFloat32();
}
operator double() { operator double() { return toFloat64(); }
return toFloat64();
}
Float<M, E> operator*(const Float<M, E>& flt) const { Float<M, E> operator*(const Float<M, E>& flt) const {
float result = value * flt.toFloat32(); float result = value * flt.toFloat32();
// PICA gives 0 instead of NaN when multiplying by inf // PICA gives 0 instead of NaN when multiplying by inf
if (std::isnan(result)) if (std::isnan(result))
if (!std::isnan(value) && !std::isnan(flt.toFloat32())) if (!std::isnan(value) && !std::isnan(flt.toFloat32())) result = 0.f;
result = 0.f; return Float<M, E>::fromFloat32(result);
return Float<M, E>::fromFloat32(result); }
}
Float<M, E> operator/(const Float<M, E>& flt) const { Float<M, E> operator/(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() / flt.toFloat32()); }
return Float<M, E>::fromFloat32(toFloat32() / flt.toFloat32());
}
Float<M, E> operator+(const Float<M, E>& flt) const { Float<M, E> operator+(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() + flt.toFloat32()); }
return Float<M, E>::fromFloat32(toFloat32() + flt.toFloat32());
}
Float<M, E> operator-(const Float<M, E>& flt) const { Float<M, E> operator-(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() - flt.toFloat32()); }
return Float<M, E>::fromFloat32(toFloat32() - flt.toFloat32());
}
Float<M, E>& operator*=(const Float<M, E>& flt) { Float<M, E>& operator*=(const Float<M, E>& flt) {
value = operator*(flt).value; value = operator*(flt).value;
return *this; return *this;
} }
Float<M, E>& operator/=(const Float<M, E>& flt) { Float<M, E>& operator/=(const Float<M, E>& flt) {
value /= flt.toFloat32(); value /= flt.toFloat32();
return *this; return *this;
} }
Float<M, E>& operator+=(const Float<M, E>& flt) { Float<M, E>& operator+=(const Float<M, E>& flt) {
value += flt.toFloat32(); value += flt.toFloat32();
return *this; return *this;
} }
Float<M, E>& operator-=(const Float<M, E>& flt) { Float<M, E>& operator-=(const Float<M, E>& flt) {
value -= flt.toFloat32(); value -= flt.toFloat32();
return *this; return *this;
} }
Float<M, E> operator-() const { Float<M, E> operator-() const { return Float<M, E>::fromFloat32(-toFloat32()); }
return Float<M, E>::fromFloat32(-toFloat32());
}
bool operator<(const Float<M, E>& flt) const { bool operator<(const Float<M, E>& flt) const { return toFloat32() < flt.toFloat32(); }
return toFloat32() < flt.toFloat32();
}
bool operator>(const Float<M, E>& flt) const { bool operator>(const Float<M, E>& flt) const { return toFloat32() > flt.toFloat32(); }
return toFloat32() > flt.toFloat32();
}
bool operator>=(const Float<M, E>& flt) const { bool operator>=(const Float<M, E>& flt) const { return toFloat32() >= flt.toFloat32(); }
return toFloat32() >= flt.toFloat32();
}
bool operator<=(const Float<M, E>& flt) const { bool operator<=(const Float<M, E>& flt) const { return toFloat32() <= flt.toFloat32(); }
return toFloat32() <= flt.toFloat32();
}
bool operator==(const Float<M, E>& flt) const { bool operator==(const Float<M, E>& flt) const { return toFloat32() == flt.toFloat32(); }
return toFloat32() == flt.toFloat32();
}
bool operator!=(const Float<M, E>& flt) const { bool operator!=(const Float<M, E>& flt) const { return toFloat32() != flt.toFloat32(); }
return toFloat32() != flt.toFloat32();
}
private: private:
static constexpr unsigned MASK = (1 << (M + E + 1)) - 1; static constexpr unsigned MASK = (1 << (M + E + 1)) - 1;
static constexpr unsigned MANTISSA_MASK = (1 << M) - 1; static constexpr unsigned MANTISSA_MASK = (1 << M) - 1;
static constexpr unsigned EXPONENT_MASK = (1 << E) - 1; static constexpr unsigned EXPONENT_MASK = (1 << E) - 1;
// Stored as a regular float, merely for convenience // Stored as a regular float, merely for convenience
// TODO: Perform proper arithmetic on this! // TODO: Perform proper arithmetic on this!
float value; float value;
}; };
using f24 = Float<16, 7>; using f24 = Float<16, 7>;
using f20 = Float<12, 7>; using f20 = Float<12, 7>;
using f16 = Float<10, 5>; using f16 = Float<10, 5>;
} // namespace Floats } // namespace Floats

2
include/PICA/shader.hpp
View file

@ -234,7 +234,7 @@ class PICAShader {
public: public:
static constexpr size_t maxInstructionCount = 4096; static constexpr size_t maxInstructionCount = 4096;
std::array<u32, maxInstructionCount> loadedShader; // Currently loaded & active shader std::array<u32, maxInstructionCount> loadedShader; // Currently loaded & active shader
PICAShader(ShaderType type) : type(type) {} PICAShader(ShaderType type) : type(type) {}

1
include/panda_qt/config_window.hpp
View file

@ -16,7 +16,6 @@
#include "emulator.hpp" #include "emulator.hpp"
#include "frontend_settings.hpp" #include "frontend_settings.hpp"
#include "input_mappings.hpp"
#include "panda_qt/input_window.hpp" #include "panda_qt/input_window.hpp"
class ConfigWindow : public QDialog { class ConfigWindow : public QDialog {

3
include/panda_qt/thread_debugger.hpp
View file

@ -5,9 +5,6 @@
#include <QTimer> #include <QTimer>
#include <QVBoxLayout> #include <QVBoxLayout>
#include <QtWidgets> #include <QtWidgets>
#include <atomic>
#include <chrono>
#include <thread>
#include "emulator.hpp" #include "emulator.hpp"

2
include/sdl_sensors.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include <cmath> #include <algorithm>
#include <glm/glm.hpp> #include <glm/glm.hpp>
#include "helpers.hpp" #include "helpers.hpp"

719
include/swap.hpp
View file

@ -23,6 +23,7 @@
#include <cstdlib> #include <cstdlib>
#endif #endif
#include <cstring> #include <cstring>
#include "helpers.hpp" #include "helpers.hpp"
// GCC // GCC
@ -57,15 +58,9 @@
namespace Common { namespace Common {
#ifdef _MSC_VER #ifdef _MSC_VER
[[nodiscard]] inline u16 swap16(u16 data) noexcept { [[nodiscard]] inline u16 swap16(u16 data) noexcept { return _byteswap_ushort(data); }
return _byteswap_ushort(data); [[nodiscard]] inline u32 swap32(u32 data) noexcept { return _byteswap_ulong(data); }
} [[nodiscard]] inline u64 swap64(u64 data) noexcept { return _byteswap_uint64(data); }
[[nodiscard]] inline u32 swap32(u32 data) noexcept {
return _byteswap_ulong(data);
}
[[nodiscard]] inline u64 swap64(u64 data) noexcept {
return _byteswap_uint64(data);
}
#elif defined(__clang__) || defined(__GNUC__) #elif defined(__clang__) || defined(__GNUC__)
#if defined(__Bitrig__) || defined(__OpenBSD__) #if defined(__Bitrig__) || defined(__OpenBSD__)
// redefine swap16, swap32, swap64 as inline functions // redefine swap16, swap32, swap64 as inline functions
@ -73,523 +68,441 @@ namespace Common {
#undef swap32 #undef swap32
#undef swap64 #undef swap64
#endif #endif
[[nodiscard]] inline u16 swap16(u16 data) noexcept { [[nodiscard]] inline u16 swap16(u16 data) noexcept { return __builtin_bswap16(data); }
return __builtin_bswap16(data); [[nodiscard]] inline u32 swap32(u32 data) noexcept { return __builtin_bswap32(data); }
} [[nodiscard]] inline u64 swap64(u64 data) noexcept { return __builtin_bswap64(data); }
[[nodiscard]] inline u32 swap32(u32 data) noexcept {
return __builtin_bswap32(data);
}
[[nodiscard]] inline u64 swap64(u64 data) noexcept {
return __builtin_bswap64(data);
}
#else #else
// Generic implementation. // Generic implementation.
[[nodiscard]] inline u16 swap16(u16 data) noexcept { [[nodiscard]] inline u16 swap16(u16 data) noexcept { return (data >> 8) | (data << 8); }
return (data >> 8) | (data << 8); [[nodiscard]] inline u32 swap32(u32 data) noexcept {
} return ((data & 0xFF000000U) >> 24) | ((data & 0x00FF0000U) >> 8) | ((data & 0x0000FF00U) << 8) | ((data & 0x000000FFU) << 24);
[[nodiscard]] inline u32 swap32(u32 data) noexcept { }
return ((data & 0xFF000000U) >> 24) | ((data & 0x00FF0000U) >> 8) | [[nodiscard]] inline u64 swap64(u64 data) noexcept {
((data & 0x0000FF00U) << 8) | ((data & 0x000000FFU) << 24); return ((data & 0xFF00000000000000ULL) >> 56) | ((data & 0x00FF000000000000ULL) >> 40) | ((data & 0x0000FF0000000000ULL) >> 24) |
} ((data & 0x000000FF00000000ULL) >> 8) | ((data & 0x00000000FF000000ULL) << 8) | ((data & 0x0000000000FF0000ULL) << 24) |
[[nodiscard]] inline u64 swap64(u64 data) noexcept { ((data & 0x000000000000FF00ULL) << 40) | ((data & 0x00000000000000FFULL) << 56);
return ((data & 0xFF00000000000000ULL) >> 56) | ((data & 0x00FF000000000000ULL) >> 40) | }
((data & 0x0000FF0000000000ULL) >> 24) | ((data & 0x000000FF00000000ULL) >> 8) |
((data & 0x00000000FF000000ULL) << 8) | ((data & 0x0000000000FF0000ULL) << 24) |
((data & 0x000000000000FF00ULL) << 40) | ((data & 0x00000000000000FFULL) << 56);
}
#endif #endif
[[nodiscard]] inline float swapf(float f) noexcept { [[nodiscard]] inline float swapf(float f) noexcept {
static_assert(sizeof(u32) == sizeof(float), "float must be the same size as uint32_t."); static_assert(sizeof(u32) == sizeof(float), "float must be the same size as uint32_t.");
u32 value; u32 value;
std::memcpy(&value, &f, sizeof(u32)); std::memcpy(&value, &f, sizeof(u32));
value = swap32(value); value = swap32(value);
std::memcpy(&f, &value, sizeof(u32)); std::memcpy(&f, &value, sizeof(u32));
return f; return f;
} }
[[nodiscard]] inline double swapd(double f) noexcept { [[nodiscard]] inline double swapd(double f) noexcept {
static_assert(sizeof(u64) == sizeof(double), "double must be the same size as uint64_t."); static_assert(sizeof(u64) == sizeof(double), "double must be the same size as uint64_t.");
u64 value; u64 value;
std::memcpy(&value, &f, sizeof(u64)); std::memcpy(&value, &f, sizeof(u64));
value = swap64(value); value = swap64(value);
std::memcpy(&f, &value, sizeof(u64)); std::memcpy(&f, &value, sizeof(u64));
return f; return f;
} }
} // Namespace Common } // Namespace Common
template <typename T, typename F> template <typename T, typename F>
struct swap_struct_t { struct swap_struct_t {
using swapped_t = swap_struct_t; using swapped_t = swap_struct_t;
protected: protected:
T value; T value;
static T swap(T v) { static T swap(T v) { return F::swap(v); }
return F::swap(v);
}
public: public:
T swap() const { T swap() const { return swap(value); }
return swap(value); swap_struct_t() = default;
} swap_struct_t(const T& v) : value(swap(v)) {}
swap_struct_t() = default;
swap_struct_t(const T& v) : value(swap(v)) {}
template <typename S> template <typename S>
swapped_t& operator=(const S& source) { swapped_t& operator=(const S& source) {
value = swap(static_cast<T>(source)); value = swap(static_cast<T>(source));
return *this; return *this;
} }
operator s8() const { operator s8() const { return static_cast<s8>(swap()); }
return static_cast<s8>(swap()); operator u8() const { return static_cast<u8>(swap()); }
} operator s16() const { return static_cast<s16>(swap()); }
operator u8() const { operator u16() const { return static_cast<u16>(swap()); }
return static_cast<u8>(swap()); operator s32() const { return static_cast<s32>(swap()); }
} operator u32() const { return static_cast<u32>(swap()); }
operator s16() const { operator s64() const { return static_cast<s64>(swap()); }
return static_cast<s16>(swap()); operator u64() const { return static_cast<u64>(swap()); }
} operator float() const { return static_cast<float>(swap()); }
operator u16() const { operator double() const { return static_cast<double>(swap()); }
return static_cast<u16>(swap());
}
operator s32() const {
return static_cast<s32>(swap());
}
operator u32() const {
return static_cast<u32>(swap());
}
operator s64() const {
return static_cast<s64>(swap());
}
operator u64() const {
return static_cast<u64>(swap());
}
operator float() const {
return static_cast<float>(swap());
}
operator double() const {
return static_cast<double>(swap());
}
// +v // +v
swapped_t operator+() const { swapped_t operator+() const { return +swap(); }
return +swap(); // -v
} swapped_t operator-() const { return -swap(); }
// -v
swapped_t operator-() const {
return -swap();
}
// v / 5 // v / 5
swapped_t operator/(const swapped_t& i) const { swapped_t operator/(const swapped_t& i) const { return swap() / i.swap(); }
return swap() / i.swap(); template <typename S>
} swapped_t operator/(const S& i) const {
template <typename S> return swap() / i;
swapped_t operator/(const S& i) const { }
return swap() / i;
}
// v * 5 // v * 5
swapped_t operator*(const swapped_t& i) const { swapped_t operator*(const swapped_t& i) const { return swap() * i.swap(); }
return swap() * i.swap(); template <typename S>
} swapped_t operator*(const S& i) const {
template <typename S> return swap() * i;
swapped_t operator*(const S& i) const { }
return swap() * i;
}
// v + 5 // v + 5
swapped_t operator+(const swapped_t& i) const { swapped_t operator+(const swapped_t& i) const { return swap() + i.swap(); }
return swap() + i.swap(); template <typename S>
} swapped_t operator+(const S& i) const {
template <typename S> return swap() + static_cast<T>(i);
swapped_t operator+(const S& i) const { }
return swap() + static_cast<T>(i); // v - 5
} swapped_t operator-(const swapped_t& i) const { return swap() - i.swap(); }
// v - 5 template <typename S>
swapped_t operator-(const swapped_t& i) const { swapped_t operator-(const S& i) const {
return swap() - i.swap(); return swap() - static_cast<T>(i);
} }
template <typename S>
swapped_t operator-(const S& i) const {
return swap() - static_cast<T>(i);
}
// v += 5 // v += 5
swapped_t& operator+=(const swapped_t& i) { swapped_t& operator+=(const swapped_t& i) {
value = swap(swap() + i.swap()); value = swap(swap() + i.swap());
return *this; return *this;
} }
template <typename S> template <typename S>
swapped_t& operator+=(const S& i) { swapped_t& operator+=(const S& i) {
value = swap(swap() + static_cast<T>(i)); value = swap(swap() + static_cast<T>(i));
return *this; return *this;
} }
// v -= 5 // v -= 5
swapped_t& operator-=(const swapped_t& i) { swapped_t& operator-=(const swapped_t& i) {
value = swap(swap() - i.swap()); value = swap(swap() - i.swap());
return *this; return *this;
} }
template <typename S> template <typename S>
swapped_t& operator-=(const S& i) { swapped_t& operator-=(const S& i) {
value = swap(swap() - static_cast<T>(i)); value = swap(swap() - static_cast<T>(i));
return *this; return *this;
} }
// ++v // ++v
swapped_t& operator++() { swapped_t& operator++() {
value = swap(swap() + 1); value = swap(swap() + 1);
return *this; return *this;
} }
// --v // --v
swapped_t& operator--() { swapped_t& operator--() {
value = swap(swap() - 1); value = swap(swap() - 1);
return *this; return *this;
} }
// v++ // v++
swapped_t operator++(int) { swapped_t operator++(int) {
swapped_t old = *this; swapped_t old = *this;
value = swap(swap() + 1); value = swap(swap() + 1);
return old; return old;
} }
// v-- // v--
swapped_t operator--(int) { swapped_t operator--(int) {
swapped_t old = *this; swapped_t old = *this;
value = swap(swap() - 1); value = swap(swap() - 1);
return old; return old;
} }
// Comparaison // Comparaison
// v == i // v == i
bool operator==(const swapped_t& i) const { bool operator==(const swapped_t& i) const { return swap() == i.swap(); }
return swap() == i.swap(); template <typename S>
} bool operator==(const S& i) const {
template <typename S> return swap() == i;
bool operator==(const S& i) const { }
return swap() == i;
}
// v != i // v != i
bool operator!=(const swapped_t& i) const { bool operator!=(const swapped_t& i) const { return swap() != i.swap(); }
return swap() != i.swap(); template <typename S>
} bool operator!=(const S& i) const {
template <typename S> return swap() != i;
bool operator!=(const S& i) const { }
return swap() != i;
}
// v > i // v > i
bool operator>(const swapped_t& i) const { bool operator>(const swapped_t& i) const { return swap() > i.swap(); }
return swap() > i.swap(); template <typename S>
} bool operator>(const S& i) const {
template <typename S> return swap() > i;
bool operator>(const S& i) const { }
return swap() > i;
}
// v < i // v < i
bool operator<(const swapped_t& i) const { bool operator<(const swapped_t& i) const { return swap() < i.swap(); }
return swap() < i.swap(); template <typename S>
} bool operator<(const S& i) const {
template <typename S> return swap() < i;
bool operator<(const S& i) const { }
return swap() < i;
}
// v >= i // v >= i
bool operator>=(const swapped_t& i) const { bool operator>=(const swapped_t& i) const { return swap() >= i.swap(); }
return swap() >= i.swap(); template <typename S>
} bool operator>=(const S& i) const {
template <typename S> return swap() >= i;
bool operator>=(const S& i) const { }
return swap() >= i;
}
// v <= i // v <= i
bool operator<=(const swapped_t& i) const { bool operator<=(const swapped_t& i) const { return swap() <= i.swap(); }
return swap() <= i.swap(); template <typename S>
} bool operator<=(const S& i) const {
template <typename S> return swap() <= i;
bool operator<=(const S& i) const { }
return swap() <= i;
}
// logical // logical
swapped_t operator!() const { swapped_t operator!() const { return !swap(); }
return !swap();
}
// bitmath // bitmath
swapped_t operator~() const { swapped_t operator~() const { return ~swap(); }
return ~swap();
}
swapped_t operator&(const swapped_t& b) const { swapped_t operator&(const swapped_t& b) const { return swap() & b.swap(); }
return swap() & b.swap(); template <typename S>
} swapped_t operator&(const S& b) const {
template <typename S> return swap() & b;
swapped_t operator&(const S& b) const { }
return swap() & b; swapped_t& operator&=(const swapped_t& b) {
} value = swap(swap() & b.swap());
swapped_t& operator&=(const swapped_t& b) { return *this;
value = swap(swap() & b.swap()); }
return *this; template <typename S>
} swapped_t& operator&=(const S b) {
template <typename S> value = swap(swap() & b);
swapped_t& operator&=(const S b) { return *this;
value = swap(swap() & b); }
return *this;
}
swapped_t operator|(const swapped_t& b) const { swapped_t operator|(const swapped_t& b) const { return swap() | b.swap(); }
return swap() | b.swap(); template <typename S>
} swapped_t operator|(const S& b) const {
template <typename S> return swap() | b;
swapped_t operator|(const S& b) const { }
return swap() | b; swapped_t& operator|=(const swapped_t& b) {
} value = swap(swap() | b.swap());
swapped_t& operator|=(const swapped_t& b) { return *this;
value = swap(swap() | b.swap()); }
return *this; template <typename S>
} swapped_t& operator|=(const S& b) {
template <typename S> value = swap(swap() | b);
swapped_t& operator|=(const S& b) { return *this;
value = swap(swap() | b); }
return *this;
}
swapped_t operator^(const swapped_t& b) const { swapped_t operator^(const swapped_t& b) const { return swap() ^ b.swap(); }
return swap() ^ b.swap(); template <typename S>
} swapped_t operator^(const S& b) const {
template <typename S> return swap() ^ b;
swapped_t operator^(const S& b) const { }
return swap() ^ b; swapped_t& operator^=(const swapped_t& b) {
} value = swap(swap() ^ b.swap());
swapped_t& operator^=(const swapped_t& b) { return *this;
value = swap(swap() ^ b.swap()); }
return *this; template <typename S>
} swapped_t& operator^=(const S& b) {
template <typename S> value = swap(swap() ^ b);
swapped_t& operator^=(const S& b) { return *this;
value = swap(swap() ^ b); }
return *this;
}
template <typename S> template <typename S>
swapped_t operator<<(const S& b) const { swapped_t operator<<(const S& b) const {
return swap() << b; return swap() << b;
} }
template <typename S> template <typename S>
swapped_t& operator<<=(const S& b) const { swapped_t& operator<<=(const S& b) const {
value = swap(swap() << b); value = swap(swap() << b);
return *this; return *this;
} }
template <typename S> template <typename S>
swapped_t operator>>(const S& b) const { swapped_t operator>>(const S& b) const {
return swap() >> b; return swap() >> b;
} }
template <typename S> template <typename S>
swapped_t& operator>>=(const S& b) const { swapped_t& operator>>=(const S& b) const {
value = swap(swap() >> b); value = swap(swap() >> b);
return *this; return *this;
} }
// Member // Member
/** todo **/ /** todo **/
// Arithmetics // Arithmetics
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend S operator+(const S& p, const swapped_t v); friend S operator+(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend S operator-(const S& p, const swapped_t v); friend S operator-(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend S operator/(const S& p, const swapped_t v); friend S operator/(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend S operator*(const S& p, const swapped_t v); friend S operator*(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend S operator%(const S& p, const swapped_t v); friend S operator%(const S& p, const swapped_t v);
// Arithmetics + assignments // Arithmetics + assignments
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend S operator+=(const S& p, const swapped_t v); friend S operator+=(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend S operator-=(const S& p, const swapped_t v); friend S operator-=(const S& p, const swapped_t v);
// Bitmath // Bitmath
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend S operator&(const S& p, const swapped_t v); friend S operator&(const S& p, const swapped_t v);
// Comparison // Comparison
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend bool operator<(const S& p, const swapped_t v); friend bool operator<(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend bool operator>(const S& p, const swapped_t v); friend bool operator>(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend bool operator<=(const S& p, const swapped_t v); friend bool operator<=(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend bool operator>=(const S& p, const swapped_t v); friend bool operator>=(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend bool operator!=(const S& p, const swapped_t v); friend bool operator!=(const S& p, const swapped_t v);
template <typename S, typename T2, typename F2> template <typename S, typename T2, typename F2>
friend bool operator==(const S& p, const swapped_t v); friend bool operator==(const S& p, const swapped_t v);
}; };
// Arithmetics // Arithmetics
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S operator+(const S& i, const swap_struct_t<T, F> v) { S operator+(const S& i, const swap_struct_t<T, F> v) {
return i + v.swap(); return i + v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S operator-(const S& i, const swap_struct_t<T, F> v) { S operator-(const S& i, const swap_struct_t<T, F> v) {
return i - v.swap(); return i - v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S operator/(const S& i, const swap_struct_t<T, F> v) { S operator/(const S& i, const swap_struct_t<T, F> v) {
return i / v.swap(); return i / v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S operator*(const S& i, const swap_struct_t<T, F> v) { S operator*(const S& i, const swap_struct_t<T, F> v) {
return i * v.swap(); return i * v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S operator%(const S& i, const swap_struct_t<T, F> v) { S operator%(const S& i, const swap_struct_t<T, F> v) {
return i % v.swap(); return i % v.swap();
} }
// Arithmetics + assignments // Arithmetics + assignments
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S& operator+=(S& i, const swap_struct_t<T, F> v) { S& operator+=(S& i, const swap_struct_t<T, F> v) {
i += v.swap(); i += v.swap();
return i; return i;
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S& operator-=(S& i, const swap_struct_t<T, F> v) { S& operator-=(S& i, const swap_struct_t<T, F> v) {
i -= v.swap(); i -= v.swap();
return i; return i;
} }
// Logical // Logical
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S operator&(const S& i, const swap_struct_t<T, F> v) { S operator&(const S& i, const swap_struct_t<T, F> v) {
return i & v.swap(); return i & v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
S operator&(const swap_struct_t<T, F> v, const S& i) { S operator&(const swap_struct_t<T, F> v, const S& i) {
return static_cast<S>(v.swap() & i); return static_cast<S>(v.swap() & i);
} }
// Comparaison // Comparaison
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
bool operator<(const S& p, const swap_struct_t<T, F> v) { bool operator<(const S& p, const swap_struct_t<T, F> v) {
return p < v.swap(); return p < v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
bool operator>(const S& p, const swap_struct_t<T, F> v) { bool operator>(const S& p, const swap_struct_t<T, F> v) {
return p > v.swap(); return p > v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
bool operator<=(const S& p, const swap_struct_t<T, F> v) { bool operator<=(const S& p, const swap_struct_t<T, F> v) {
return p <= v.swap(); return p <= v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
bool operator>=(const S& p, const swap_struct_t<T, F> v) { bool operator>=(const S& p, const swap_struct_t<T, F> v) {
return p >= v.swap(); return p >= v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
bool operator!=(const S& p, const swap_struct_t<T, F> v) { bool operator!=(const S& p, const swap_struct_t<T, F> v) {
return p != v.swap(); return p != v.swap();
} }
template <typename S, typename T, typename F> template <typename S, typename T, typename F>
bool operator==(const S& p, const swap_struct_t<T, F> v) { bool operator==(const S& p, const swap_struct_t<T, F> v) {
return p == v.swap(); return p == v.swap();
} }
template <typename T> template <typename T>
struct swap_64_t { struct swap_64_t {
static T swap(T x) { static T swap(T x) { return static_cast<T>(Common::swap64(x)); }
return static_cast<T>(Common::swap64(x));
}
}; };
template <typename T> template <typename T>
struct swap_32_t { struct swap_32_t {
static T swap(T x) { static T swap(T x) { return static_cast<T>(Common::swap32(x)); }
return static_cast<T>(Common::swap32(x));
}
}; };
template <typename T> template <typename T>
struct swap_16_t { struct swap_16_t {
static T swap(T x) { static T swap(T x) { return static_cast<T>(Common::swap16(x)); }
return static_cast<T>(Common::swap16(x));
}
}; };
template <typename T> template <typename T>
struct swap_float_t { struct swap_float_t {
static T swap(T x) { static T swap(T x) { return static_cast<T>(Common::swapf(x)); }
return static_cast<T>(Common::swapf(x));
}
}; };
template <typename T> template <typename T>
struct swap_double_t { struct swap_double_t {
static T swap(T x) { static T swap(T x) { return static_cast<T>(Common::swapd(x)); }
return static_cast<T>(Common::swapd(x));
}
}; };
template <typename T> template <typename T>
struct swap_enum_t { struct swap_enum_t {
static_assert(std::is_enum_v<T>); static_assert(std::is_enum_v<T>);
using base = std::underlying_type_t<T>; using base = std::underlying_type_t<T>;
public: public:
swap_enum_t() = default; swap_enum_t() = default;
swap_enum_t(const T& v) : value(swap(v)) {} swap_enum_t(const T& v) : value(swap(v)) {}
swap_enum_t& operator=(const T& v) { swap_enum_t& operator=(const T& v) {
value = swap(v); value = swap(v);
return *this; return *this;
} }
operator T() const { operator T() const { return swap(value); }
return swap(value);
}
explicit operator base() const { explicit operator base() const { return static_cast<base>(swap(value)); }
return static_cast<base>(swap(value));
}
protected: protected:
T value{}; T value{};
// clang-format off // clang-format off
using swap_t = std::conditional_t< using swap_t = std::conditional_t<
std::is_same_v<base, u16>, swap_16_t<u16>, std::conditional_t< std::is_same_v<base, u16>, swap_16_t<u16>, std::conditional_t<
std::is_same_v<base, s16>, swap_16_t<s16>, std::conditional_t< std::is_same_v<base, s16>, swap_16_t<s16>, std::conditional_t<
@ -597,14 +510,12 @@ protected:
std::is_same_v<base, s32>, swap_32_t<s32>, std::conditional_t< std::is_same_v<base, s32>, swap_32_t<s32>, std::conditional_t<
std::is_same_v<base, u64>, swap_64_t<u64>, std::conditional_t< std::is_same_v<base, u64>, swap_64_t<u64>, std::conditional_t<
std::is_same_v<base, s64>, swap_64_t<s64>, void>>>>>>; std::is_same_v<base, s64>, swap_64_t<s64>, void>>>>>>;
// clang-format on // clang-format on
static T swap(T x) { static T swap(T x) { return static_cast<T>(swap_t::swap(static_cast<base>(x))); }
return static_cast<T>(swap_t::swap(static_cast<base>(x)));
}
}; };
struct SwapTag {}; // Use the different endianness from the system struct SwapTag {}; // Use the different endianness from the system
struct KeepTag {}; // Use the same endianness as the system struct KeepTag {}; // Use the same endianness as the system
template <typename T, typename Tag> template <typename T, typename Tag>
struct AddEndian; struct AddEndian;
@ -613,65 +524,65 @@ struct AddEndian;
template <typename T> template <typename T>
struct AddEndian<T, KeepTag> { struct AddEndian<T, KeepTag> {
using type = T; using type = T;
}; };
// SwapTag specializations // SwapTag specializations
template <> template <>
struct AddEndian<u8, SwapTag> { struct AddEndian<u8, SwapTag> {
using type = u8; using type = u8;
}; };
template <> template <>
struct AddEndian<u16, SwapTag> { struct AddEndian<u16, SwapTag> {
using type = swap_struct_t<u16, swap_16_t<u16>>; using type = swap_struct_t<u16, swap_16_t<u16>>;
}; };
template <> template <>
struct AddEndian<u32, SwapTag> { struct AddEndian<u32, SwapTag> {
using type = swap_struct_t<u32, swap_32_t<u32>>; using type = swap_struct_t<u32, swap_32_t<u32>>;
}; };
template <> template <>
struct AddEndian<u64, SwapTag> { struct AddEndian<u64, SwapTag> {
using type = swap_struct_t<u64, swap_64_t<u64>>; using type = swap_struct_t<u64, swap_64_t<u64>>;
}; };
template <> template <>
struct AddEndian<s8, SwapTag> { struct AddEndian<s8, SwapTag> {
using type = s8; using type = s8;
}; };
template <> template <>
struct AddEndian<s16, SwapTag> { struct AddEndian<s16, SwapTag> {
using type = swap_struct_t<s16, swap_16_t<s16>>; using type = swap_struct_t<s16, swap_16_t<s16>>;
}; };
template <> template <>
struct AddEndian<s32, SwapTag> { struct AddEndian<s32, SwapTag> {
using type = swap_struct_t<s32, swap_32_t<s32>>; using type = swap_struct_t<s32, swap_32_t<s32>>;
}; };
template <> template <>
struct AddEndian<s64, SwapTag> { struct AddEndian<s64, SwapTag> {
using type = swap_struct_t<s64, swap_64_t<s64>>; using type = swap_struct_t<s64, swap_64_t<s64>>;
}; };
template <> template <>
struct AddEndian<float, SwapTag> { struct AddEndian<float, SwapTag> {
using type = swap_struct_t<float, swap_float_t<float>>; using type = swap_struct_t<float, swap_float_t<float>>;
}; };
template <> template <>
struct AddEndian<double, SwapTag> { struct AddEndian<double, SwapTag> {
using type = swap_struct_t<double, swap_double_t<double>>; using type = swap_struct_t<double, swap_double_t<double>>;
}; };
template <typename T> template <typename T>
struct AddEndian<T, SwapTag> { struct AddEndian<T, SwapTag> {
static_assert(std::is_enum_v<T>); static_assert(std::is_enum_v<T>);
using type = swap_enum_t<T>; using type = swap_enum_t<T>;
}; };
// Alias LETag/BETag as KeepTag/SwapTag depending on the system // Alias LETag/BETag as KeepTag/SwapTag depending on the system