summaryrefslogtreecommitdiffstats
path: root/src/common
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/common/common.vcxproj11
-rw-r--r--src/common/common.vcxproj.filters1
-rw-r--r--src/common/src/common_types.h2
-rw-r--r--src/common/src/swap.h535
4 files changed, 549 insertions, 0 deletions
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 @@
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
<Lib />
+ <ClCompile>
+ <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+ </ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile />
@@ -172,6 +175,7 @@
<ClInclude Include="src\std_mutex.h" />
<ClInclude Include="src\std_thread.h" />
<ClInclude Include="src\string_util.h" />
+ <ClInclude Include="src\swap.h" />
<ClInclude Include="src\thread.h" />
<ClInclude Include="src\thunk.h" />
<ClInclude Include="src\timer.h" />
@@ -197,6 +201,13 @@
<ItemGroup>
<None Include="CMakeLists.txt" />
</ItemGroup>
+ <ItemGroup>
+ <Reference Include="System" />
+ <Reference Include="System.Data" />
+ <Reference Include="System.Drawing" />
+ <Reference Include="System.Windows.Forms" />
+ <Reference Include="System.Xml" />
+ </ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
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 @@
<ClInclude Include="src\atomic_win32.h" />
<ClInclude Include="src\emu_window.h" />
<ClInclude Include="src\platform.h" />
+ <ClInclude Include="src\swap.h" />
</ItemGroup>
<ItemGroup>
<None Include="CMakeLists.txt" />
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 <sys/endian.h>
+
+#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 <typename T, typename F>
+struct swap_struct_t {
+ typedef swap_struct_t<T, F> 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ bool operator==(const S &i) const {
+ return swap() == i;
+ }
+
+ // v != i
+ bool operator!=(const swapped_t &i) const {
+ return swap() != i.swap();
+ }
+ template <typename S>
+ bool operator!=(const S &i) const {
+ return swap() != i;
+ }
+
+ // v > i
+ bool operator>(const swapped_t &i) const {
+ return swap() > i.swap();
+ }
+ template <typename S>
+ bool operator>(const S &i) const {
+ return swap() > i;
+ }
+
+ // v < i
+ bool operator<(const swapped_t &i) const {
+ return swap() < i.swap();
+ }
+ template <typename S>
+ bool operator<(const S &i) const {
+ return swap() < i;
+ }
+
+ // v >= i
+ bool operator>=(const swapped_t &i) const {
+ return swap() >= i.swap();
+ }
+ template <typename S>
+ bool operator>=(const S &i) const {
+ return swap() >= i;
+ }
+
+ // v <= i
+ bool operator<=(const swapped_t &i) const {
+ return swap() <= i.swap();
+ }
+ template <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ 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 <typename S>
+ swapped_t& operator ^=(const S &b) {
+ value = swap(swap() ^ b);
+ return *this;
+ }
+
+ template <typename S>
+ swapped_t operator <<(const S &b) const {
+ return swap() << b;
+ }
+ template <typename S>
+ swapped_t& operator <<=(const S &b) const {
+ value = swap(swap() << b);
+ return *this;
+ }
+
+ template <typename S>
+ swapped_t operator >>(const S &b) const {
+ return swap() >> b;
+ }
+ template <typename S>
+ swapped_t& operator >>=(const S &b) const {
+ value = swap(swap() >> b);
+ return *this;
+ }
+
+ // Member
+ /** todo **/
+
+
+ // Arithmetics
+ template <typename S, typename T2, typename F2>
+ friend S operator+(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend S operator-(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend S operator/(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend S operator*(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend S operator%(const S &p, const swapped_t v);
+
+ // Arithmetics + assignements
+ template <typename S, typename T2, typename F2>
+ friend S operator+=(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend S operator-=(const S &p, const swapped_t v);
+
+ // Bitmath
+ template <typename S, typename T2, typename F2>
+ friend S operator&(const S &p, const swapped_t v);
+
+ // Comparison
+ template <typename S, typename T2, typename F2>
+ friend bool operator<(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend bool operator>(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend bool operator<=(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend bool operator>=(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend bool operator!=(const S &p, const swapped_t v);
+
+ template <typename S, typename T2, typename F2>
+ friend bool operator==(const S &p, const swapped_t v);
+};
+
+
+// Arithmetics
+template <typename S, typename T, typename F>
+S operator+(const S &i, const swap_struct_t<T, F> v) {
+ return i + v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator-(const S &i, const swap_struct_t<T, F> v) {
+ return i - v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator/(const S &i, const swap_struct_t<T, F> v) {
+ return i / v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator*(const S &i, const swap_struct_t<T, F> v) {
+ return i * v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator%(const S &i, const swap_struct_t<T, F> v) {
+ return i % v.swap();
+}
+
+// Arithmetics + assignements
+template <typename S, typename T, typename F>
+S &operator+=(S &i, const swap_struct_t<T, F> v) {
+ i += v.swap();
+ return i;
+}
+
+template <typename S, typename T, typename F>
+S &operator-=(S &i, const swap_struct_t<T, F> v) {
+ i -= v.swap();
+ return i;
+}
+
+// Logical
+template <typename S, typename T, typename F>
+S operator&(const S &i, const swap_struct_t<T, F> v) {
+ return i & v.swap();
+}
+
+template <typename S, typename T, typename F>
+S operator&(const swap_struct_t<T, F> v, const S &i) {
+ return (S)(v.swap() & i);
+}
+
+
+// Comparaison
+template <typename S, typename T, typename F>
+bool operator<(const S &p, const swap_struct_t<T, F> v) {
+ return p < v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator>(const S &p, const swap_struct_t<T, F> v) {
+ return p > v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator<=(const S &p, const swap_struct_t<T, F> v) {
+ return p <= v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator>=(const S &p, const swap_struct_t<T, F> v) {
+ return p >= v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator!=(const S &p, const swap_struct_t<T, F> v) {
+ return p != v.swap();
+}
+template <typename S, typename T, typename F>
+bool operator==(const S &p, const swap_struct_t<T, F> v) {
+ return p == v.swap();
+}
+
+template <typename T>
+struct swap_64_t {
+ static T swap(T x) {
+ return (T)bswap64(*(u64 *)&x);
+ }
+};
+
+template <typename T>
+struct swap_32_t {
+ static T swap(T x) {
+ return (T)bswap32(*(u32 *)&x);
+ }
+};
+
+template <typename T>
+struct swap_16_t {
+ static T swap(T x) {
+ return (T)bswap16(*(u16 *)&x);
+ }
+};
+
+template <typename T>
+struct swap_float_t {
+ static T swap(T x) {
+ return (T)bswapf(*(float *)&x);
+ }
+};
+
+template <typename T>
+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, swap_64_t<u64>> u64_be;
+typedef swap_struct_t<s64, swap_64_t<s64>> s64_be;
+
+typedef swap_struct_t<u32, swap_32_t<u32>> u32_be;
+typedef swap_struct_t<s32, swap_32_t<s32>> s32_be;
+
+typedef swap_struct_t<u16, swap_16_t<u16>> u16_be;
+typedef swap_struct_t<s16, swap_16_t<s16>> s16_be;
+
+typedef swap_struct_t<float, swap_float_t<float> > float_be;
+typedef swap_struct_t<double, swap_double_t<double> > double_be;
+#else
+
+typedef swap_struct_t<u64, swap_64_t<u64>> u64_le;
+typedef swap_struct_t<s64, swap_64_t<s64>> s64_le;
+
+typedef swap_struct_t<u32, swap_32_t<u32>> u32_le;
+typedef swap_struct_t<s32, swap_32_t<s32>> s32_le;
+
+typedef swap_struct_t<u16, swap_16_t<u16>> u16_le;
+typedef swap_struct_t<s16, swap_16_t<s16>> s16_le;
+
+typedef swap_struct_t<float, swap_float_t<float> > float_le;
+typedef swap_struct_t<double, swap_double_t<double> > 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
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-30 18:42:17 +0100