to_string(): define long long overloads even in C++98 mode

Since `uint64_t` is an alias for `unsigned long long` on macOS, I think
this is the only way (except for templates that we used until
#76) to
ensure that `to_string()` supports an `uint64_t` argument.

`long long` is technically not in C++98, but if we detect that the
`LLONG_MAX` macro is defined, we should be able to use it. And as I
mentioned in `Common.cmake`, I don't think we currently support any
compiler without `long long` support, given that we already require
`int64_t`/`uint64_t`, which are also only part of C++11 and not C++98.

Author: generalmimon

Common.cmake

@@ -15,6 +15,13 @@ target_compile_options(${PROJECT_NAME} PRIVATE
     $<$<CXX_COMPILER_ID:MSVC>:/W4 /WX>
     $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:
         -Wall -Wextra -Wpedantic -Werror
+
+        # We're using the `long long` type intentionally. Although it's not part of C++98, in
+        # practice it is usually supported even by ancient compilers with very limited C++11
+        # support. And we already unconditionally require `uint64_t`, so it would be strange if
+        # the compiler supported `uint64_t` and not `long long`.
+        -Wno-error=long-long
+
         # See <https://gcc.gnu.org/onlinedocs/gcc-13.3.0/gcc/Warning-Options.html#index-Wstrict-aliasing_003dn>:
         #
         # > Level 1: (...) it has very few false negatives. However, it has many false positives.

gcc4.mk

@@ -13,6 +13,12 @@ OBJS := \
 
 CXXFLAGS := -std=c++98 -Wall -Wextra -pedantic
 
+# `-pedantic` enables `-Wlong-long`, which for some reason turns into
+# `error: ISO C++ does not support 'long long'`, even though we don't use `-Werror`. Since
+# we're using `long long` intentionally, we suppress this error using `-Wno-long-long`
+# (see https://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Warning-Options.html#index-Wlong_002dlong-305).
+CXXFLAGS += -Wno-long-long
+
 # NOTE: the meaning of `<n>` values in `-Wstrict-aliasing=<n>` is different in GCC 4.1.2
 # than in recent versions of GCC. According to
 # https://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Warning-Options.html#index-Wstrict_002daliasing-246,

kaitai/kaitaistream.h

@@ -13,6 +13,7 @@
 
 #include <ios> // std::streamsize, forward declaration of std::istream  // IWYU pragma: keep
 #include <cstddef> // std::size_t
+#include <climits> // LLONG_MAX, ULLONG_MAX
 #include <sstream> // std::istringstream  // IWYU pragma: keep
 #include <string> // std::string
 
@@ -252,8 +253,11 @@ class kstream {
         return to_string_signed(val);
     }
 
-// The `long long` type is only available since C++11, so we use it only in C++11 mode.
-#ifdef KAITAI_STREAM_H_CPP11_SUPPORT
+// The `long long` type is technically available only since C++11. It is usually
+// supported even by ancient compilers that have very limited C++11 support, but we can
+// still check if the `LLONG_MAX` macro is defined (it seems very unlikely that it is not,
+// though).
+#ifdef LLONG_MAX
     /**
      * Converts given integer `val` to a decimal string representation.
      * Should be used in place of `std::to_string(long long)` (which is available only
@@ -282,8 +286,11 @@ class kstream {
         return to_string_unsigned(val);
     }
 
-// The `unsigned long long` type is only available since C++11, so we use it only in C++11 mode.
-#ifdef KAITAI_STREAM_H_CPP11_SUPPORT
+// The `unsigned long long` type is technically available only since C++11. It is usually
+// supported even by ancient compilers that have very limited C++11 support, but we can
+// still check if the `LLONG_MAX` macro is defined (it seems very unlikely that it is not,
+// though).
+#ifdef ULLONG_MAX
     /**
      * Converts given integer `val` to a decimal string representation.
      * Should be used in place of `std::to_string(unsigned long long)` (which is available only

tests/unittest.cpp

@@ -154,8 +154,6 @@ TEST(KaitaiStreamTest, to_string_long)
 #pragma warning(pop)
 #endif
 
-// The `long long` type is only available since C++11, so we use it only in C++11 mode.
-#ifdef KAITAI_STREAM_H_CPP11_SUPPORT
 TEST(KaitaiStreamTest, to_string_unsigned_long_long)
 {
     EXPECT_EQ(kaitai::kstream::to_string(std::numeric_limits<unsigned long long>::min()), "0");
@@ -167,20 +165,6 @@ TEST(KaitaiStreamTest, to_string_long_long)
     EXPECT_EQ(kaitai::kstream::to_string(std::numeric_limits<long long>::min()), "-9223372036854775808");
     EXPECT_EQ(kaitai::kstream::to_string(std::numeric_limits<long long>::max()), "9223372036854775807");
 }
-#else
-// Make sure we still support 64-bit integers.
-TEST(KaitaiStreamTest, to_string_uint64)
-{
-    EXPECT_EQ(kaitai::kstream::to_string(std::numeric_limits<uint64_t>::min()), "0");
-    EXPECT_EQ(kaitai::kstream::to_string(std::numeric_limits<uint64_t>::max()), "18446744073709551615");
-}
-
-TEST(KaitaiStreamTest, to_string_int64)
-{
-    EXPECT_EQ(kaitai::kstream::to_string(std::numeric_limits<int64_t>::min()), "-9223372036854775808");
-    EXPECT_EQ(kaitai::kstream::to_string(std::numeric_limits<int64_t>::max()), "9223372036854775807");
-}
-#endif
 
 TEST(KaitaiStreamTest, string_to_int)
 {