Formatting fixes (#781)

* Formatting

* More formatting

* More formatting

* More formatting

include/PICA/float_types.hpp

@@ -6,6 +6,7 @@
 
 #include <cmath>
 #include <cstring>
+
 #include "helpers.hpp"
 
 namespace Floats {
@@ -44,8 +45,7 @@ namespace Floats {
 				else
 					exponent += bias;
 				hex = sign | (mantissa << (23 - M)) | (exponent << 23);
-            }
+			} else {
-            else {
 				hex = sign;
 			}
 
@@ -54,47 +54,30 @@ namespace Floats {
 			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
-        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 result = value * flt.toFloat32();
 			// PICA gives 0 instead of NaN when multiplying by inf
 			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);
 		}
 
-        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) {
 			value = operator*(flt).value;
@@ -116,33 +99,19 @@ namespace Floats {
 			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:
 		static constexpr unsigned MASK = (1 << (M + E + 1)) - 1;

include/panda_qt/config_window.hpp

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

include/panda_qt/thread_debugger.hpp

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

include/sdl_sensors.hpp

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

include/swap.hpp

@@ -23,6 +23,7 @@
 #include <cstdlib>
 #endif
 #include <cstring>
+
 #include "helpers.hpp"
 
 // GCC
@@ -57,15 +58,9 @@
 namespace Common {
 
 #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__)
 #if defined(__Bitrig__) || defined(__OpenBSD__)
 // redefine swap16, swap32, swap64 as inline functions
@@ -73,33 +68,23 @@ namespace Common {
 #undef swap32
 #undef swap64
 #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
-// 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 {
-    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
 
-[[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.");
 
 		u32 value;
@@ -109,9 +94,9 @@ namespace Common {
 		std::memcpy(&f, &value, sizeof(u32));
 
 		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.");
 
 		u64 value;
@@ -121,7 +106,7 @@ namespace Common {
 		std::memcpy(&f, &value, sizeof(u64));
 
 		return f;
-}
+	}
 
 }  // Namespace Common
 
@@ -129,17 +114,13 @@ template <typename T, typename F>
 struct swap_struct_t {
 	using swapped_t = swap_struct_t;
 
-protected:
+  protected:
 	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)) {}
 
@@ -149,76 +130,44 @@ public:
 		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
-    swapped_t operator+() const {
+	swapped_t operator+() const { return +swap(); }
-        return +swap();
-    }
 	// -v
-    swapped_t operator-() const {
+	swapped_t operator-() const { return -swap(); }
-        return -swap();
-    }
 
 	// 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 {
 		return swap() / i;
 	}
 
 	// 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 {
 		return swap() * i;
 	}
 
 	// 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 {
 		return swap() + static_cast<T>(i);
 	}
 	// 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 {
 		return swap() - static_cast<T>(i);
@@ -270,72 +219,54 @@ public:
 	}
 	// Comparaison
 	// 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 {
 		return swap() == 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 {
 		return swap() != 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 {
 		return swap() > 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 {
 		return swap() < 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 {
 		return swap() >= 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 {
 		return swap() <= i;
 	}
 
 	// logical
-    swapped_t operator!() const {
+	swapped_t operator!() const { return !swap(); }
-        return !swap();
-    }
 
 	// 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 {
 		return swap() & b;
@@ -350,9 +281,7 @@ public:
 		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 {
 		return swap() | b;
@@ -367,9 +296,7 @@ public:
 		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 {
 		return swap() ^ b;
@@ -532,37 +459,27 @@ bool operator==(const S& p, const swap_struct_t<T, F> v) {
 
 template <typename 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>
 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>
 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>
 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>
 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>
@@ -570,7 +487,7 @@ struct swap_enum_t {
 	static_assert(std::is_enum_v<T>);
 	using base = std::underlying_type_t<T>;
 
-public:
+  public:
 	swap_enum_t() = default;
 	swap_enum_t(const T& v) : value(swap(v)) {}
 
@@ -579,15 +496,11 @@ public:
 		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{};
 	// clang-format off
     using swap_t = std::conditional_t<
@@ -598,9 +511,7 @@ protected:
         std::is_same_v<base, u64>, swap_64_t<u64>, std::conditional_t<
         std::is_same_v<base, s64>, swap_64_t<s64>, void>>>>>>;
 	// 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