From f24f4ff9788ea795a66903bfeb0517bc3e99aace Mon Sep 17 00:00:00 2001 From: ShizZy Date: Wed, 18 Sep 2013 23:26:13 -0400 Subject: [PATCH] added swap types to common --- src/common/common.vcxproj | 11 + src/common/common.vcxproj.filters | 1 + src/common/src/common_types.h | 2 + src/common/src/swap.h | 535 ++++++++++++++++++++++++++++++ 4 files changed, 549 insertions(+) create mode 100644 src/common/src/swap.h diff --git a/src/common/common.vcxproj b/src/common/common.vcxproj index 48a7d5afa..467195e0f 100644 --- a/src/common/common.vcxproj +++ b/src/common/common.vcxproj @@ -95,6 +95,9 @@ true + + ProgramDatabase + @@ -172,6 +175,7 @@ + @@ -197,6 +201,13 @@ + + + + + + + diff --git a/src/common/common.vcxproj.filters b/src/common/common.vcxproj.filters index 5bc11e5c5..0553ce433 100644 --- a/src/common/common.vcxproj.filters +++ b/src/common/common.vcxproj.filters @@ -54,6 +54,7 @@ + diff --git a/src/common/src/common_types.h b/src/common/src/common_types.h index 5cb402131..cbe556c7e 100644 --- a/src/common/src/common_types.h +++ b/src/common/src/common_types.h @@ -45,4 +45,6 @@ typedef signed long long s64; #endif // _WIN32 +#include "swap.h" + #endif // _COMMONTYPES_H_ diff --git a/src/common/src/swap.h b/src/common/src/swap.h new file mode 100644 index 000000000..b937f9ed1 --- /dev/null +++ b/src/common/src/swap.h @@ -0,0 +1,535 @@ +// Copyright (c) 2012- PPSSPP Project / Dolphin Project. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, version 2.0 or later versions. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License 2.0 for more details. + +// A copy of the GPL 2.0 should have been included with the program. +// If not, see http://www.gnu.org/licenses/ + +// Official git repository and contact information can be found at +// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/. + +#pragma once + +// Android +#if defined(ANDROID) +#include + +#if _BYTE_ORDER == _LITTLE_ENDIAN && !defined(COMMON_LITTLE_ENDIAN) +#define COMMON_LITTLE_ENDIAN 1 +#elif _BYTE_ORDER == _BIG_ENDIAN && !defined(COMMON_BIG_ENDIAN) +#define COMMON_BIG_ENDIAN 1 +#endif + +// GCC 4.6+ +#elif __GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6) + +#if __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) && !defined(COMMON_LITTLE_ENDIAN) +#define COMMON_LITTLE_ENDIAN 1 +#elif __BYTE_ORDER__ && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) && !defined(COMMON_BIG_ENDIAN) +#define COMMON_BIG_ENDIAN 1 +#endif + +// LLVM/clang +#elif __clang__ + +#if __LITTLE_ENDIAN__ && !defined(COMMON_LITTLE_ENDIAN) +#define COMMON_LITTLE_ENDIAN 1 +#elif __BIG_ENDIAN__ && !defined(COMMON_BIG_ENDIAN) +#define COMMON_BIG_ENDIAN 1 +#endif + +// MSVC +#elif defined(_MSC_VER) && !defined(COMMON_BIG_ENDIAN) && !defined(COMMON_LITTLE_ENDIAN) + +#ifdef _XBOX +#define COMMON_BIG_ENDIAN 1 +#else +#define COMMON_LITTLE_ENDIAN 1 +#endif + +#endif + +// Worst case, default to little endian. +#if !COMMON_BIG_ENDIAN && !COMMON_LITTLE_ENDIAN +#define COMMON_LITTLE_ENDIAN 1 +#endif + +template +struct swap_struct_t { + typedef swap_struct_t swapped_t; + +protected: + T value; + + static T swap(T v) { + return F::swap(v); + } +public: + T const swap() const { + return swap(value); + + } + swap_struct_t() : value((T)0) {} + swap_struct_t(const T &v): value(swap(v)) {} + + template + swapped_t& operator=(const S &source) { + value = swap((T)source); + return *this; + } + + operator long() const { return (long)swap(); } + operator s8() const { return (s8)swap(); } + operator u8() const { return (u8)swap(); } + operator s16() const { return (s16)swap(); } + operator u16() const { return (u16)swap(); } + operator s32() const { return (s32)swap(); } + operator u32() const { return (u32)swap(); } + operator s64() const { return (s64)swap(); } + operator u64() const { return (u64)swap(); } + operator float() const { return (float)swap(); } + operator double() const { return (double)swap(); } + + // +v + swapped_t operator +() const { + return +swap(); + } + // -v + swapped_t operator -() const { + return -swap(); + } + + // v / 5 + swapped_t operator/(const swapped_t &i) const { + return swap() / i.swap(); + } + template + swapped_t operator/(const S &i) const { + return swap() / i; + } + + // v * 5 + swapped_t operator*(const swapped_t &i) const { + return swap() * i.swap(); + } + template + swapped_t operator*(const S &i) const { + return swap() * i; + } + + // v + 5 + swapped_t operator+(const swapped_t &i) const { + return swap() + i.swap(); + } + template + swapped_t operator+(const S &i) const { + return swap() + (T)i; + } + // v - 5 + swapped_t operator-(const swapped_t &i) const { + return swap() - i.swap(); + } + template + swapped_t operator-(const S &i) const { + return swap() - (T)i; + } + + // v += 5 + swapped_t& operator+=(const swapped_t &i) { + value = swap(swap() + i.swap()); + return *this; + } + template + swapped_t& operator+=(const S &i) { + value = swap(swap() + (T)i); + return *this; + } + // v -= 5 + swapped_t& operator-=(const swapped_t &i) { + value = swap(swap() - i.swap()); + return *this; + } + template + swapped_t& operator-=(const S &i) { + value = swap(swap() - (T)i); + return *this; + } + + // ++v + swapped_t& operator++() { + value = swap(swap()+1); + return *this; + } + // --v + swapped_t& operator--() { + value = swap(swap()-1); + return *this; + } + + // v++ + swapped_t operator++(int) { + swapped_t old = *this; + value = swap(swap()+1); + return old; + } + // v-- + swapped_t operator--(int) { + swapped_t old = *this; + value = swap(swap()-1); + return old; + } + // Comparaison + // v == i + bool operator==(const swapped_t &i) const { + return swap() == i.swap(); + } + template + bool operator==(const S &i) const { + return swap() == i; + } + + // v != i + bool operator!=(const swapped_t &i) const { + return swap() != i.swap(); + } + template + bool operator!=(const S &i) const { + return swap() != i; + } + + // v > i + bool operator>(const swapped_t &i) const { + return swap() > i.swap(); + } + template + bool operator>(const S &i) const { + return swap() > i; + } + + // v < i + bool operator<(const swapped_t &i) const { + return swap() < i.swap(); + } + template + bool operator<(const S &i) const { + return swap() < i; + } + + // v >= i + bool operator>=(const swapped_t &i) const { + return swap() >= i.swap(); + } + template + bool operator>=(const S &i) const { + return swap() >= i; + } + + // v <= i + bool operator<=(const swapped_t &i) const { + return swap() <= i.swap(); + } + template + bool operator<=(const S &i) const { + return swap() <= i; + } + + // logical + swapped_t operator !() const { + return !swap(); + } + + // bitmath + swapped_t operator ~() const { + return ~swap(); + } + + swapped_t operator &(const swapped_t &b) const { + return swap() & b.swap(); + } + template + swapped_t operator &(const S &b) const { + return swap() & b; + } + swapped_t& operator &=(const swapped_t &b) { + value = swap(swap() & b.swap()); + return *this; + } + template + swapped_t& operator &=(const S b) { + value = swap(swap() & b); + return *this; + } + + swapped_t operator |(const swapped_t &b) const { + return swap() | b.swap(); + } + template + swapped_t operator |(const S &b) const { + return swap() | b; + } + swapped_t& operator |=(const swapped_t &b) { + value = swap(swap() | b.swap()); + return *this; + } + template + swapped_t& operator |=(const S &b) { + value = swap(swap() | b); + return *this; + } + + swapped_t operator ^(const swapped_t &b) const { + return swap() ^ b.swap(); + } + template + swapped_t operator ^(const S &b) const { + return swap() ^ b; + } + swapped_t& operator ^=(const swapped_t &b) { + value = swap(swap() ^ b.swap()); + return *this; + } + template + swapped_t& operator ^=(const S &b) { + value = swap(swap() ^ b); + return *this; + } + + template + swapped_t operator <<(const S &b) const { + return swap() << b; + } + template + swapped_t& operator <<=(const S &b) const { + value = swap(swap() << b); + return *this; + } + + template + swapped_t operator >>(const S &b) const { + return swap() >> b; + } + template + swapped_t& operator >>=(const S &b) const { + value = swap(swap() >> b); + return *this; + } + + // Member + /** todo **/ + + + // Arithmetics + template + friend S operator+(const S &p, const swapped_t v); + + template + friend S operator-(const S &p, const swapped_t v); + + template + friend S operator/(const S &p, const swapped_t v); + + template + friend S operator*(const S &p, const swapped_t v); + + template + friend S operator%(const S &p, const swapped_t v); + + // Arithmetics + assignements + template + friend S operator+=(const S &p, const swapped_t v); + + template + friend S operator-=(const S &p, const swapped_t v); + + // Bitmath + template + friend S operator&(const S &p, const swapped_t v); + + // Comparison + template + friend bool operator<(const S &p, const swapped_t v); + + template + friend bool operator>(const S &p, const swapped_t v); + + template + friend bool operator<=(const S &p, const swapped_t v); + + template + friend bool operator>=(const S &p, const swapped_t v); + + template + friend bool operator!=(const S &p, const swapped_t v); + + template + friend bool operator==(const S &p, const swapped_t v); +}; + + +// Arithmetics +template +S operator+(const S &i, const swap_struct_t v) { + return i + v.swap(); +} + +template +S operator-(const S &i, const swap_struct_t v) { + return i - v.swap(); +} + +template +S operator/(const S &i, const swap_struct_t v) { + return i / v.swap(); +} + +template +S operator*(const S &i, const swap_struct_t v) { + return i * v.swap(); +} + +template +S operator%(const S &i, const swap_struct_t v) { + return i % v.swap(); +} + +// Arithmetics + assignements +template +S &operator+=(S &i, const swap_struct_t v) { + i += v.swap(); + return i; +} + +template +S &operator-=(S &i, const swap_struct_t v) { + i -= v.swap(); + return i; +} + +// Logical +template +S operator&(const S &i, const swap_struct_t v) { + return i & v.swap(); +} + +template +S operator&(const swap_struct_t v, const S &i) { + return (S)(v.swap() & i); +} + + +// Comparaison +template +bool operator<(const S &p, const swap_struct_t v) { + return p < v.swap(); +} +template +bool operator>(const S &p, const swap_struct_t v) { + return p > v.swap(); +} +template +bool operator<=(const S &p, const swap_struct_t v) { + return p <= v.swap(); +} +template +bool operator>=(const S &p, const swap_struct_t v) { + return p >= v.swap(); +} +template +bool operator!=(const S &p, const swap_struct_t v) { + return p != v.swap(); +} +template +bool operator==(const S &p, const swap_struct_t v) { + return p == v.swap(); +} + +template +struct swap_64_t { + static T swap(T x) { + return (T)bswap64(*(u64 *)&x); + } +}; + +template +struct swap_32_t { + static T swap(T x) { + return (T)bswap32(*(u32 *)&x); + } +}; + +template +struct swap_16_t { + static T swap(T x) { + return (T)bswap16(*(u16 *)&x); + } +}; + +template +struct swap_float_t { + static T swap(T x) { + return (T)bswapf(*(float *)&x); + } +}; + +template +struct swap_double_t { + static T swap(T x) { + return (T)bswapd(*(double *)&x); + } +}; + +#if COMMON_LITTLE_ENDIAN +typedef u32 u32_le; +typedef u16 u16_le; +typedef u64 u64_le; + +typedef s32 s32_le; +typedef s16 s16_le; +typedef s64 s64_le; + +typedef float float_le; +typedef double double_le; + +typedef swap_struct_t> u64_be; +typedef swap_struct_t> s64_be; + +typedef swap_struct_t> u32_be; +typedef swap_struct_t> s32_be; + +typedef swap_struct_t> u16_be; +typedef swap_struct_t> s16_be; + +typedef swap_struct_t > float_be; +typedef swap_struct_t > double_be; +#else + +typedef swap_struct_t> u64_le; +typedef swap_struct_t> s64_le; + +typedef swap_struct_t> u32_le; +typedef swap_struct_t> s32_le; + +typedef swap_struct_t> u16_le; +typedef swap_struct_t> s16_le; + +typedef swap_struct_t > float_le; +typedef swap_struct_t > double_le; + +typedef u32 u32_be; +typedef u16 u16_be; +typedef u64 u64_be; + +typedef s32 s32_be; +typedef s16 s16_be; +typedef s64 s64_be; + +typedef float float_be; +typedef double double_be; +#endif \ No newline at end of file