From 72bf719772117eead2e9a354f6c92cd926d58c72 Mon Sep 17 00:00:00 2001
From: m-holger <m-holger@kubitscheck.org>
Date: Tue, 17 Jan 2023 12:00:33 +0000
Subject: Inline QIntC functions

---
 include/qpdf/QIntC.hh | 132 ++++++++++++++++++++++++++++++++------------------
 1 file changed, 84 insertions(+), 48 deletions(-)

(limited to 'include')

diff --git a/include/qpdf/QIntC.hh b/include/qpdf/QIntC.hh
index dadc7582..b896a026 100644
--- a/include/qpdf/QIntC.hh
+++ b/include/qpdf/QIntC.hh
@@ -63,48 +63,60 @@ namespace QIntC // QIntC = qpdf Integer Conversion
     class IntConverter<From, To, false, false>
     {
       public:
-        static To
+        inline static To
         convert(From const& i)
         {
             // From and To are both unsigned.
             if (i > std::numeric_limits<To>::max()) {
-                std::ostringstream msg;
-                msg.imbue(std::locale::classic());
-                msg << "integer out of range converting " << i << " from a "
-                    << sizeof(From) << "-byte unsigned type to a " << sizeof(To)
-                    << "-byte unsigned type";
-                throw std::range_error(msg.str());
+                error(i);
             }
             return static_cast<To>(i);
         }
+
+        static void
+        error(From i)
+        {
+            std::ostringstream msg;
+            msg.imbue(std::locale::classic());
+            msg << "integer out of range converting " << i << " from a "
+                << sizeof(From) << "-byte unsigned type to a " << sizeof(To)
+                << "-byte unsigned type";
+            throw std::range_error(msg.str());
+        }
     };
 
     template <typename From, typename To>
     class IntConverter<From, To, true, true>
     {
       public:
-        static To
+        inline static To
         convert(From const& i)
         {
             // From and To are both signed.
             if ((i < std::numeric_limits<To>::min()) ||
                 (i > std::numeric_limits<To>::max())) {
-                std::ostringstream msg;
-                msg.imbue(std::locale::classic());
-                msg << "integer out of range converting " << i << " from a "
-                    << sizeof(From) << "-byte signed type to a " << sizeof(To)
-                    << "-byte signed type";
-                throw std::range_error(msg.str());
+                error(i);
             }
             return static_cast<To>(i);
         }
+
+        static void
+        error(From i)
+        {
+            std::ostringstream msg;
+            msg.imbue(std::locale::classic());
+            msg << "integer out of range converting " << i << " from a "
+                << sizeof(From) << "-byte signed type to a " << sizeof(To)
+                << "-byte signed type";
+            throw std::range_error(msg.str());
+        }
     };
 
     template <typename From, typename To>
     class IntConverter<From, To, true, false>
     {
       public:
-        static To
+        inline static To
         convert(From const& i)
         {
             // From is signed, and To is unsigned. If i > 0, it's safe to
@@ -112,22 +124,28 @@ namespace QIntC // QIntC = qpdf Integer Conversion
             // compare with To's max.
             auto ii = static_cast<typename to_u<From>::type>(i);
             if ((i < 0) || (ii > std::numeric_limits<To>::max())) {
-                std::ostringstream msg;
-                msg.imbue(std::locale::classic());
-                msg << "integer out of range converting " << i << " from a "
-                    << sizeof(From) << "-byte signed type to a " << sizeof(To)
-                    << "-byte unsigned type";
-                throw std::range_error(msg.str());
+                error(i);
             }
             return static_cast<To>(i);
         }
+
+        static void
+        error(From i)
+        {
+            std::ostringstream msg;
+            msg.imbue(std::locale::classic());
+            msg << "integer out of range converting " << i << " from a "
+                << sizeof(From) << "-byte signed type to a " << sizeof(To)
+                << "-byte unsigned type";
+            throw std::range_error(msg.str());
+        }
     };
 
     template <typename From, typename To>
     class IntConverter<From, To, false, true>
     {
       public:
-        static To
+        inline static To
         convert(From const& i)
         {
             // From is unsigned, and to is signed. Convert To's max to the
@@ -135,98 +153,104 @@ namespace QIntC // QIntC = qpdf Integer Conversion
             auto maxval = static_cast<typename to_u<To>::type>(
                 std::numeric_limits<To>::max());
             if (i > maxval) {
-                std::ostringstream msg;
-                msg.imbue(std::locale::classic());
-                msg << "integer out of range converting " << i << " from a "
-                    << sizeof(From) << "-byte unsigned type to a " << sizeof(To)
-                    << "-byte signed type";
-                throw std::range_error(msg.str());
+                error(i);
             }
             return static_cast<To>(i);
         }
+
+        static void
+        error(From i)
+        {
+            std::ostringstream msg;
+            msg.imbue(std::locale::classic());
+            msg << "integer out of range converting " << i << " from a "
+                << sizeof(From) << "-byte unsigned type to a " << sizeof(To)
+                << "-byte signed type";
+            throw std::range_error(msg.str());
+        }
     };
 
     // Specific converters. The return type of each function must match
     // the second template parameter to IntConverter.
     template <typename T>
-    char
+    inline char
     to_char(T const& i)
     {
         return IntConverter<T, char>::convert(i);
     }
 
     template <typename T>
-    unsigned char
+    inline unsigned char
     to_uchar(T const& i)
     {
         return IntConverter<T, unsigned char>::convert(i);
     }
 
     template <typename T>
-    short
+    inline short
     to_short(T const& i)
     {
         return IntConverter<T, short>::convert(i);
     }
 
     template <typename T>
-    unsigned short
+    inline unsigned short
     to_ushort(T const& i)
     {
         return IntConverter<T, unsigned short>::convert(i);
     }
 
     template <typename T>
-    int
+    inline int
     to_int(T const& i)
     {
         return IntConverter<T, int>::convert(i);
     }
 
     template <typename T>
-    unsigned int
+    inline unsigned int
     to_uint(T const& i)
     {
         return IntConverter<T, unsigned int>::convert(i);
     }
 
     template <typename T>
-    size_t
+    inline size_t
     to_size(T const& i)
     {
         return IntConverter<T, size_t>::convert(i);
     }
 
     template <typename T>
-    qpdf_offset_t
+    inline qpdf_offset_t
     to_offset(T const& i)
     {
         return IntConverter<T, qpdf_offset_t>::convert(i);
     }
 
     template <typename T>
-    long
+    inline long
     to_long(T const& i)
     {
         return IntConverter<T, long>::convert(i);
     }
 
     template <typename T>
-    unsigned long
+    inline unsigned long
     to_ulong(T const& i)
     {
         return IntConverter<T, unsigned long>::convert(i);
     }
 
     template <typename T>
-    long long
+    inline long long
     to_longlong(T const& i)
     {
         return IntConverter<T, long long>::convert(i);
     }
 
     template <typename T>
-    unsigned long long
+    inline unsigned long long
     to_ulonglong(T const& i)
     {
         return IntConverter<T, unsigned long long>::convert(i);
@@ -234,12 +258,8 @@ namespace QIntC // QIntC = qpdf Integer Conversion
 
     template <typename T>
     void
-    range_check(T const& cur, T const& delta)
+    range_check_error(T const& cur, T const& delta)
     {
-        if ((delta > 0) != (cur > 0)) {
-            return;
-        }
-
         if ((delta > 0) && ((std::numeric_limits<T>::max() - cur) < delta)) {
             std::ostringstream msg;
             msg.imbue(std::locale::classic());
@@ -257,13 +277,19 @@ namespace QIntC // QIntC = qpdf Integer Conversion
     }
 
     template <typename T>
-    void
-    range_check_substract(T const& cur, T const& delta)
+    inline void
+    range_check(T const& cur, T const& delta)
     {
-        if ((delta >= 0) == (cur >= 0)) {
+        if ((delta > 0) != (cur > 0)) {
             return;
         }
+        QIntC::range_check_error<T>(cur, delta);
+    }
 
+    template <typename T>
+    void
+    range_check_substract_error(T const& cur, T const& delta)
+    {
         if ((delta > 0) && ((std::numeric_limits<T>::min() + delta) > cur)) {
             std::ostringstream msg;
             msg.imbue(std::locale::classic());
@@ -279,6 +305,16 @@ namespace QIntC // QIntC = qpdf Integer Conversion
             throw std::range_error(msg.str());
         }
     }
+
+    template <typename T>
+    inline void
+    range_check_substract(T const& cur, T const& delta)
+    {
+        if ((delta >= 0) == (cur >= 0)) {
+            return;
+        }
+        QIntC::range_check_substract_error<T>(cur, delta);
+    }
 }; // namespace QIntC
 
 #endif // QINTC_HH
-- 
cgit v1.2.3-54-g00ecf