Index: uspace/lib/cpp/include/impl/limits.hpp
===================================================================
--- uspace/lib/cpp/include/impl/limits.hpp	(revision 2987160e9aba409b3bda76ca9f0b640d345bd1d3)
+++ uspace/lib/cpp/include/impl/limits.hpp	(revision 092a4364f1c9c83ed02ea8d2c2040bcde41bd802)
@@ -31,4 +31,5 @@
 
 #include <cstdint>
+#include <climits>
 
 namespace std
@@ -345,174 +346,240 @@
 
     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();