Changeset 092a436 in mainline

Timestamp:

2018-07-05T21:41:19Z (6 years ago)

Author:

Dzejrou <dzejrou@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

fff05d3

Parents:

2987160

git-author:

Dzejrou <dzejrou@…> (2018-01-05 23:01:03)

git-committer:

Dzejrou <dzejrou@…> (2018-07-05 21:41:19)

Message:

cpp: changed limits to the primitive types so that we can be sure we cover them all

File:

• uspace/lib/cpp/include/impl/limits.hpp (modified) (2 diffs)

uspace/lib/cpp/include/impl/limits.hpp

@@ -31 +31 @@
 
 #include <cstdint>
+#include <climits>
 
 namespace std
@@ -345 +346 @@
 
     template<>
-    class numeric_limits<int8_t>: public aux::numeric_limits<int8_t>
-    {
-        public:
-            static constexpr bool is_specialized = true;
-
-            static constexpr int8_t max()
-            {
-                return INT8_MAX;
-            }
-
-            static constexpr int8_t min()
-            {
-                return INT8_MIN;
-            }
-
-            static constexpr int8_t lowest()
-            {
-                return min();
-            }
-    };
-
-    template<>
-    class numeric_limits<int16_t>: public aux::numeric_limits<int16_t>
-    {
-        public:
-            static constexpr bool is_specialized = true;
-
-            static constexpr int16_t max()
-            {
-                return INT16_MAX;
-            }
-
-            static constexpr int16_t min()
-            {
-                return INT16_MIN;
-            }
-
-            static constexpr int16_t lowest()
-            {
-                return min();
-            }
-    };
-
-    template<>
-    class numeric_limits<int32_t>: public aux::numeric_limits<int32_t>
-    {
-        public:
-            static constexpr bool is_specialized = true;
-
-            static constexpr int32_t max()
-            {
-                return INT32_MAX;
-            }
-
-            static constexpr int32_t min()
-            {
-                return INT32_MIN;
-            }
-
-            static constexpr int32_t lowest()
-            {
-                return min();
-            }
-    };
-
-    template<>
-    class numeric_limits<int64_t>: public aux::numeric_limits<int64_t>
-    {
-        public:
-            static constexpr bool is_specialized = true;
-
-            static constexpr int64_t max()
-            {
-                return INT64_MAX;
-            }
-
-            static constexpr int64_t min()
-            {
-                return INT64_MIN;
-            }
-
-            static constexpr int64_t lowest()
-            {
-                return min();
-            }
-    };
-
-    template<>
-    class numeric_limits<uint8_t>: public aux::numeric_limits<uint8_t>
-    {
-        public:
-            static constexpr bool is_specialized = true;
-
-            static constexpr uint8_t max()
-            {
-                return UINT8_MAX;
-            }
-
-            static constexpr uint8_t min()
-            {
-                return UINT8_MIN;
-            }
-
-            static constexpr uint8_t lowest()
-            {
-                return min();
-            }
-    };
-
-    template<>
-    class numeric_limits<uint16_t>: public aux::numeric_limits<uint16_t>
-    {
-        public:
-            static constexpr bool is_specialized = true;
-
-            static constexpr uint16_t max()
-            {
-                return UINT16_MAX;
-            }
-
-            static constexpr uint16_t min()
-            {
-                return UINT16_MIN;
-            }
-
-            static constexpr uint16_t lowest()
-            {
-                return min();
-            }
-    };
-
-    template<>
-    class numeric_limits<uint32_t>: public aux::numeric_limits<uint32_t>
-    {
-        public:
-            static constexpr bool is_specialized = true;
-
-            static constexpr uint32_t max()
-            {
-                return UINT32_MAX;
-            }
-
-            static constexpr uint32_t min()
-            {
-                return UINT32_MIN;
-            }
-
-            static constexpr uint32_t lowest()
-            {
-                return min();
-            }
-    };
-
-    template<>
-    class numeric_limits<uint64_t>: public aux::numeric_limits<uint64_t>
-    {
-        public:
-            static constexpr bool is_specialized = true;
-
-            static constexpr uint64_t max()
-            {
-                return UINT64_MAX;
-            }
-
-            static constexpr uint64_t min()
-            {
-                return UINT64_MIN;
-            }
-
-            static constexpr uint64_t lowest()
+    class numeric_limits<char>: public aux::numeric_limits<char>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr char max()
+            {
+                return CHAR_MAX;
+            }
+
+            static constexpr char min()
+            {
+                return CHAR_MIN;
+            }
+
+            static constexpr char lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<signed char>: public aux::numeric_limits<signed char>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr signed char max()
+            {
+                return SCHAR_MAX;
+            }
+
+            static constexpr signed char min()
+            {
+                return SCHAR_MIN;
+            }
+
+            static constexpr signed char lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<short>: public aux::numeric_limits<short>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr short max()
+            {
+                return SHRT_MAX;
+            }
+
+            static constexpr short min()
+            {
+                return SHRT_MIN;
+            }
+
+            static constexpr short lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<int>: public aux::numeric_limits<int>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr int max()
+            {
+                return INT_MAX;
+            }
+
+            static constexpr int min()
+            {
+                return INT_MIN;
+            }
+
+            static constexpr int lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<long>: public aux::numeric_limits<long>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr long max()
+            {
+                return LONG_MAX;
+            }
+
+            static constexpr long min()
+            {
+                return LONG_MIN;
+            }
+
+            static constexpr long lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<long long>: public aux::numeric_limits<long long>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr long long max()
+            {
+                return LLONG_MAX;
+            }
+
+            static constexpr long long min()
+            {
+                return LLONG_MIN;
+            }
+
+            static constexpr long long lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<unsigned char>: public aux::numeric_limits<unsigned char>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr unsigned char max()
+            {
+                return SCHAR_MAX;
+            }
+
+            static constexpr unsigned char min()
+            {
+                return SCHAR_MIN;
+            }
+
+            static constexpr unsigned char lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<unsigned short>: public aux::numeric_limits<unsigned short>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr unsigned short max()
+            {
+                return USHRT_MAX;
+            }
+
+            static constexpr unsigned short min()
+            {
+                return USHRT_MIN;
+            }
+
+            static constexpr unsigned short lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<unsigned int>: public aux::numeric_limits<unsigned int>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr unsigned int max()
+            {
+                return UINT_MAX;
+            }
+
+            static constexpr unsigned int min()
+            {
+                return UINT_MIN;
+            }
+
+            static constexpr unsigned int lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<unsigned long>: public aux::numeric_limits<unsigned long>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr unsigned long max()
+            {
+                return ULONG_MAX;
+            }
+
+            static constexpr unsigned long min()
+            {
+                return ULONG_MIN;
+            }
+
+            static constexpr unsigned long lowest()
+            {
+                return min();
+            }
+    };
+
+    template<>
+    class numeric_limits<unsigned long long>: public aux::numeric_limits<unsigned long long>
+    {
+        public:
+            static constexpr bool is_specialized = true;
+
+            static constexpr unsigned long long max()
+            {
+                return ULLONG_MAX;
+            }
+
+            static constexpr unsigned long long min()
+            {
+                return ULLONG_MIN;
+            }
+
+            static constexpr unsigned long long lowest()
             {
                 return min();