Use char instead of uint8_t and remove unnecessary includes

flamewing · flamewing · commit f7fbe731f0ad · 2025-07-27T18:17:28.000+02:00
Also going back to reinterpret_cast due to bugprone-bitwise-pointer-cast. I actually think they are right on this, using bit_cast makes it seems things are safer than they are.

Maybe add an "unsafe_pointer_cast" in the future?
diff --git a/include/mdcomp/basic_decoder.hh b/include/mdcomp/basic_decoder.hh
@@ -23,7 +23,6 @@
 #include "mdcomp/ignore_unused_variable_warning.hh"
 #include "mdcomp/stream_utils.hh"
 
-#include <bit>
 #include <cstddef>
 #include <cstdint>
 #include <iostream>
@@ -69,7 +68,8 @@ public:
         }
 
         auto const size_bytes = count * sizeof(T);
-        return std::bit_cast<T*>(::operator new[](size_bytes, std::align_val_t{Align}));
+        return reinterpret_cast<T*>(
+                ::operator new[](size_bytes, std::align_val_t{Align}));
     }
 
     void deallocate(T* pointer, [[maybe_unused]] std::size_t count_bytes) {
@@ -85,13 +85,13 @@ bool basic_decoder<Format, Pad, Args...>::encode(
     source.ignore(std::numeric_limits<std::streamsize>::max());
     auto full_size = static_cast<size_t>(source.gcount());
     source.seekg(start);
-    std::vector<uint8_t, aligned_allocator<uint8_t>> data;
+    std::vector<char, aligned_allocator<char>> data;
     if constexpr (Pad == pad_mode::pad_even) {
         data.resize(detail::round_up(full_size, 2U));
     } else {
         data.resize(full_size);
     }
-    source.read(std::bit_cast<char*>(data.data()), std::ssize(data));
+    source.read(data.data(), std::ssize(data));
     if constexpr (Pad == pad_mode::pad_even) {
         if (data.size() > full_size) {
             data.back() = 0;
diff --git a/include/mdcomp/bigendian_io.hh b/include/mdcomp/bigendian_io.hh
@@ -65,13 +65,14 @@ namespace detail {
     template <typename Iter>
     concept byte_input_iterator = requires() {
         requires std::input_iterator<Iter>;
-        requires(std::is_same_v<std::iter_value_t<Iter>, char>)
-                        || (std::is_same_v<std::iter_value_t<Iter>, uint8_t>);
+        requires(
+                std::is_same_v<std::iter_value_t<Iter>, char>
+                || std::is_same_v<std::iter_value_t<Iter>, uint8_t>);
     };
 
     template <typename Iter>
     concept byte_output_iterator
-            = (std::output_iterator<Iter, uint8_t>) || (std::output_iterator<Iter, char>);
+            = std::output_iterator<Iter, uint8_t> || std::output_iterator<Iter, char>;
 
     template <typename T>
     concept container = std::regular<T> && std::swappable<T>
diff --git a/include/mdcomp/comper.hh b/include/mdcomp/comper.hh
@@ -22,7 +22,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -33,7 +32,7 @@ using moduled_comper = moduled_adaptor<comper, 4096U, 1U>;
 class comper : public basic_comper, public moduled_comper {
     friend basic_comper;
     friend moduled_comper;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     using basic_comper::encode;
diff --git a/include/mdcomp/comperx.hh b/include/mdcomp/comperx.hh
@@ -22,7 +22,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -33,7 +32,7 @@ using moduled_comperx = moduled_adaptor<comperx, 4096U, 1U>;
 class comperx : public basic_comperx, public moduled_comperx {
     friend basic_comperx;
     friend moduled_comperx;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     using basic_comperx::encode;
diff --git a/include/mdcomp/enigma.hh b/include/mdcomp/enigma.hh
@@ -23,7 +23,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -34,7 +33,7 @@ using moduled_enigma = moduled_adaptor<enigma, 4096U, 1U>;
 class enigma : public basic_enigma, public moduled_enigma {
     friend basic_enigma;
     friend moduled_enigma;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     static bool encode(std::istream& source, std::ostream& dest);
diff --git a/include/mdcomp/kosinski.hh b/include/mdcomp/kosinski.hh
@@ -22,7 +22,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -33,7 +32,7 @@ using moduled_kosinski = moduled_adaptor<kosinski, 4096U, 16U>;
 class kosinski : public basic_kosinski, public moduled_kosinski {
     friend basic_kosinski;
     friend moduled_kosinski;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     using basic_kosinski::encode;
diff --git a/include/mdcomp/kosplus.hh b/include/mdcomp/kosplus.hh
@@ -22,7 +22,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -33,7 +32,7 @@ using moduled_kosplus = moduled_adaptor<kosplus, 4096U, 1U>;
 class kosplus : public basic_kosplus, public moduled_kosplus {
     friend basic_kosplus;
     friend moduled_kosplus;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     using basic_kosplus::encode;
diff --git a/include/mdcomp/lzkn1.hh b/include/mdcomp/lzkn1.hh
@@ -22,7 +22,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -33,7 +32,7 @@ using moduled_lzkn1 = moduled_adaptor<lzkn1, 4096U, 1U>;
 class lzkn1 : public basic_lzkn1, public moduled_lzkn1 {
     friend basic_lzkn1;
     friend moduled_lzkn1;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     using basic_lzkn1::encode;
diff --git a/include/mdcomp/lzss.hh b/include/mdcomp/lzss.hh
@@ -28,7 +28,6 @@
 #include <boost/container/static_vector.hpp>
 
 #include <algorithm>
-#include <bit>
 #include <cassert>
 #include <concepts>    // IWYU pragma: keep
 #include <cstddef>
@@ -237,7 +236,7 @@ namespace lzss {
         using symbolwise_data = typename Adaptor::adj_list_node::symbolwise_data;
         symbolwise_data data(length);
         source.read(
-                std::bit_cast<char*>(data.data()),
+                reinterpret_cast<char*>(data.data()),
                 static_cast<std::streamsize>(length * sizeof(stream_t)));
         nodes.emplace_back(position, std::move(data), type);
         output_size += Adaptor::edge_size(nodes.back());
@@ -667,7 +666,7 @@ namespace lzss {
     };
 
     template <adaptor_t Adaptor>
-    auto find_optimal_parse(std::span<uint8_t const> data_in, Adaptor adaptor) noexcept {
+    auto find_optimal_parse(std::span<char const> data_in, Adaptor adaptor) noexcept {
         ignore_unused_variable_warning(adaptor);
         using edge_type       = typename Adaptor::edge_type;
         using stream_t        = typename Adaptor::stream_t;
@@ -679,7 +678,7 @@ namespace lzss {
 
         auto read_stream = [](data_t data, size_t offset) {
             auto const* pointer
-                    = std::bit_cast<uint8_t const*>(std::addressof(data[offset]));
+                    = reinterpret_cast<char const*>(std::addressof(data[offset]));
             return stream_endian_t::template read<stream_t>(pointer);
         };
 
@@ -839,7 +838,7 @@ namespace lzss {
                     static_cast<size_t>(std::min(length, distance)),
                     boost::container::default_init_t{});
             dest.read(
-                    std::bit_cast<char*>(buffer.data()),
+                    reinterpret_cast<char*>(buffer.data()),
                     static_cast<std::streamsize>(buffer.size() * sizeof(stream_t)));
 
             if (length > distance) {
@@ -860,13 +859,13 @@ namespace lzss {
 
         dest.seekp(pointer);
         dest.write(
-                std::bit_cast<char const*>(buffer.data()),
+                reinterpret_cast<char const*>(buffer.data()),
                 static_cast<std::streamsize>(buffer.size() * sizeof(stream_t)));
     }
 
     template <adaptor_t Adaptor>
     auto encode(
-            std::ostream& dest, std::span<uint8_t const> data, Adaptor adaptor) noexcept {
+            std::ostream& dest, std::span<char const> data, Adaptor adaptor) noexcept {
         using ostream_t = Adaptor::ostream_t;
 
         // Compute optimal Comper parsing of input file.
diff --git a/include/mdcomp/moduled_adaptor.hh b/include/mdcomp/moduled_adaptor.hh
@@ -24,7 +24,6 @@
 #include "mdcomp/forge_span.hh"
 #include "mdcomp/stream_utils.hh"
 
-#include <bit>
 #include <cstddef>
 #include <cstdint>
 #include <ios>
@@ -34,7 +33,6 @@
 #include <sstream>
 #include <vector>
 
-
 template <typename Format, size_t DefaultModuleSize, size_t DefaultModulePadding>
 class moduled_adaptor {
 public:
@@ -84,10 +82,10 @@ bool moduled_adaptor<Format, DefaultModuleSize, DefaultModulePadding>::moduled_e
     source.ignore(std::numeric_limits<std::streamsize>::max());
     auto full_size = source.gcount();
     source.seekg(location);
-    std::vector<uint8_t> data;
+    std::vector<char> data;
     data.resize(static_cast<size_t>(full_size));
     auto pointer = std::ranges::cbegin(data);
-    source.read(std::bit_cast<char*>(data.data()), full_size);
+    source.read(data.data(), full_size);
 
     big_endian::write2(
             dest, static_cast<size_t>(full_size) & std::numeric_limits<uint16_t>::max());
diff --git a/include/mdcomp/nemesis.hh b/include/mdcomp/nemesis.hh
@@ -23,7 +23,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -34,7 +33,7 @@ using moduled_nemesis = moduled_adaptor<nemesis, 4096U, 1U>;
 class nemesis : public basic_nemesis, public moduled_nemesis {
     friend basic_nemesis;
     friend moduled_nemesis;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     static bool encode(std::istream& source, std::ostream& dest);
diff --git a/include/mdcomp/options_lib.hh b/include/mdcomp/options_lib.hh
@@ -603,7 +603,7 @@ inline int auto_compressor_decompressor(options_t options) {
 
         constexpr static auto as_u8string_view = [](std::string_view path) {
             return std::u8string_view{
-                    std::bit_cast<char8_t const*>(path.data()), path.size()};
+                    reinterpret_cast<char8_t const*>(path.data()), path.size()};
         };
         std::filesystem::path infile{as_u8string_view(options.positional.front())};
         std::filesystem::path outfile{as_u8string_view(options.positional.back())};
diff --git a/include/mdcomp/rocket.hh b/include/mdcomp/rocket.hh
@@ -22,7 +22,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -33,7 +32,7 @@ using moduled_rocket = moduled_adaptor<rocket, 4096U, 1U>;
 class rocket : public basic_rocket, public moduled_rocket {
     friend basic_rocket;
     friend moduled_rocket;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     static bool encode(std::istream& source, std::ostream& dest);
diff --git a/include/mdcomp/saxman.hh b/include/mdcomp/saxman.hh
@@ -23,7 +23,6 @@
 #include "mdcomp/moduled_adaptor.hh"
 
 #include <cstddef>
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -35,7 +34,7 @@ class saxman : public basic_saxman, public moduled_saxman {
     friend basic_saxman;
     friend moduled_saxman;
     static bool encode(
-            std::ostream& dest, std::span<uint8_t const> data, bool with_size = true);
+            std::ostream& dest, std::span<char const> data, bool with_size = true);
 
 public:
     using basic_saxman::encode;
diff --git a/include/mdcomp/snkrle.hh b/include/mdcomp/snkrle.hh
@@ -22,7 +22,6 @@
 #include "mdcomp/basic_decoder.hh"
 #include "mdcomp/moduled_adaptor.hh"
 
-#include <cstdint>
 #include <iosfwd>
 #include <span>
 
@@ -33,7 +32,7 @@ using moduled_snkrle = moduled_adaptor<snkrle, 4096U, 1U>;
 class snkrle : public basic_snkrle, public moduled_snkrle {
     friend basic_snkrle;
     friend moduled_snkrle;
-    static bool encode(std::ostream& dest, std::span<uint8_t const> data);
+    static bool encode(std::ostream& dest, std::span<char const> data);
 
 public:
     using basic_snkrle::encode;
diff --git a/src/lib/comper.cc b/src/lib/comper.cc
@@ -257,7 +257,7 @@ struct comper_internal {
         }
     }
 
-    static void encode(std::ostream& dest, std::span<uint8_t const> data) {
+    static void encode(std::ostream& dest, std::span<char const> data) {
         lzss::encode(dest, data, comper_adaptor{});
     }
 };
@@ -272,7 +272,7 @@ bool comper::decode(std::istream& source, std::iostream& dest) {
     return true;
 }
 
-bool comper::encode(std::ostream& dest, std::span<uint8_t const> data) {
+bool comper::encode(std::ostream& dest, std::span<char const> data) {
     comper_internal::encode(dest, data);
     return true;
 }
diff --git a/src/lib/comperx.cc b/src/lib/comperx.cc
@@ -258,7 +258,7 @@ struct comperx_internal {
         }
     }
 
-    static void encode(std::ostream& dest, std::span<uint8_t const> data) {
+    static void encode(std::ostream& dest, std::span<char const> data) {
         lzss::encode(dest, data, comperx_adaptor{});
     }
 };
@@ -273,7 +273,7 @@ bool comperx::decode(std::istream& source, std::iostream& dest) {
     return true;
 }
 
-bool comperx::encode(std::ostream& dest, std::span<uint8_t const> data) {
+bool comperx::encode(std::ostream& dest, std::span<char const> data) {
     comperx_internal::encode(dest, data);
     return true;
 }
diff --git a/src/lib/enigma.cc b/src/lib/enigma.cc
@@ -379,9 +379,9 @@ bool enigma::encode(std::istream& source, std::ostream& dest) {
     return true;
 }
 
-bool enigma::encode(std::ostream& dest, std::span<uint8_t const> data) {
+bool enigma::encode(std::ostream& dest, std::span<char const> data) {
     std::stringstream source(std::ios::in | std::ios::out | std::ios::binary);
-    source.write(std::bit_cast<char const*>(data.data()), std::ssize(data));
+    source.write(data.data(), std::ssize(data));
     source.seekg(0);
     return encode(source, dest);
 }
diff --git a/src/lib/kosinski.cc b/src/lib/kosinski.cc
@@ -337,7 +337,7 @@ struct kosinski_internal {
         }
     }
 
-    static void encode(std::ostream& dest, std::span<uint8_t const> data) {
+    static void encode(std::ostream& dest, std::span<char const> data) {
         lzss::encode(dest, data, kosinski_adaptor{});
     }
 };
@@ -352,7 +352,7 @@ bool kosinski::decode(std::istream& source, std::iostream& dest) {
     return true;
 }
 
-bool kosinski::encode(std::ostream& dest, std::span<uint8_t const> data) {
+bool kosinski::encode(std::ostream& dest, std::span<char const> data) {
     kosinski_internal::encode(dest, data);
     return true;
 }
diff --git a/src/lib/kosplus.cc b/src/lib/kosplus.cc
diff --git a/src/lib/lzkn1.cc b/src/lib/lzkn1.cc
diff --git a/src/lib/nemesis.cc b/src/lib/nemesis.cc
diff --git a/src/lib/rocket.cc b/src/lib/rocket.cc
diff --git a/src/lib/saxman.cc b/src/lib/saxman.cc
diff --git a/src/lib/snkrle.cc b/src/lib/snkrle.cc
