libk: add int_t min max size constants

2 files changed, 62 insertions, 31 deletions

diff --git a/libk/types.h b/libk/types.h
index 4c50a35..7f16206 100644
--- a/libk/types.h
+++ b/libk/types.h
@@ -4,27 +4,36 @@ typedef unsigned short size_t;
 typedef int ssize_t;
 
 typedef unsigned char uint8_t;
+constexpr uint8_t uint8_t_min = 0;
+constexpr uint8_t uint8_t_max = 0xff;
 
 typedef unsigned short uint16_t;
 constexpr uint16_t uint16_t_min = 0;
 constexpr uint16_t uint16_t_max = 0xffff;
 
 typedef unsigned int uint32_t;
-typedef unsigned long long int uint64_t;
+constexpr uint32_t uint32_t_min = 0;
+constexpr uint32_t uint32_t_max = 0xffffffff;
+
+typedef unsigned long long uint64_t;
+constexpr uint64_t uint64_t_min = 0;
+constexpr uint64_t uint64_t_max = 0xffffffffffffffff;
 
 typedef char int8_t;
+constexpr int8_t int8_t_max = uint8_t_max / 2;
+constexpr int8_t int8_t_min = -int8_t_max - 1;
+
 typedef short int16_t;
+constexpr int16_t int16_t_max = uint16_t_max / 2;
+constexpr int16_t int16_t_min = -int16_t_max - 1;
+
 typedef int int32_t;
-typedef long long int int64_t;
+constexpr int32_t int32_t_max = uint32_t_max / 2;
+constexpr int32_t int32_t_min = -int32_t_max - 1;
 
-/* in x86:
- * byte:  1 byte,   8 bits
- * word:  2 bytes, 16 bits
- * dword: 4 bytes, 32 bits
- * qword: 8 bytes, 64 bits
- * */
-typedef uint16_t uword_t;
-typedef int16_t word_t;
+typedef long long int int64_t;
+constexpr int64_t int64_t_max = uint64_t_max / 2;
+constexpr int64_t int64_t_min = -int64_t_max - 1;
 
 // Type Traits
 
diff --git a/libk/types/test.cc b/libk/types/test.cc
index f93d883..b3f29d9 100644
--- a/libk/types/test.cc
+++ b/libk/types/test.cc
@@ -1,29 +1,51 @@
-#include <types.h>
+#include <stdint.h>
+
+namespace libk {
+#include "types.h"
+}
 
 // types
-static_assert(sizeof(size_t) >= 2);
+static_assert(sizeof(libk::size_t) >= 2);
+
+static_assert(sizeof(libk::uint8_t) == 1);
+static_assert(libk::uint8_t_max == UINT8_MAX);
+
+static_assert(sizeof(libk::uint16_t) == 2);
+static_assert(libk::uint16_t_max == UINT16_MAX);
+
+static_assert(sizeof(libk::uint32_t) == 4);
+static_assert(libk::uint32_t_max == UINT32_MAX);
 
-static_assert(sizeof(uint8_t) == 1);
-static_assert(sizeof(uint16_t) == 2);
-static_assert(sizeof(uint32_t) == 4);
-static_assert(sizeof(uint64_t) == 8);
+static_assert(sizeof(libk::uint64_t) == 8);
+static_assert(libk::uint64_t_max == UINT64_MAX);
 
-static_assert(sizeof(int8_t) == 1);
-static_assert(sizeof(int16_t) == 2);
-static_assert(sizeof(int32_t) == 4);
-static_assert(sizeof(int64_t) == 8);
+static_assert(sizeof(libk::int8_t) == 1);
+static_assert(libk::int8_t_min == INT8_MIN);
+static_assert(libk::int8_t_max == INT8_MAX);
+
+static_assert(sizeof(libk::int16_t) == 2);
+static_assert(libk::int16_t_min == INT16_MIN);
+static_assert(libk::int16_t_max == INT16_MAX);
+
+static_assert(sizeof(libk::int32_t) == 4);
+static_assert(libk::int32_t_min == INT32_MIN);
+static_assert(libk::int32_t_max == INT32_MAX);
+
+static_assert(sizeof(libk::int64_t) == 8);
+static_assert(libk::int64_t_min == INT64_MIN);
+static_assert(libk::int64_t_max == INT64_MAX);
 
 // is_same
-static_assert(is_same<int, int>() == true);
-static_assert(is_same<int, unsigned int>() == false);
+static_assert(libk::is_same<int, int>() == true);
+static_assert(libk::is_same<int, unsigned int>() == false);
 
 // is_unsigned
-static_assert(is_unsigned<uint8_t>() == true);
-static_assert(is_unsigned<uint16_t>() == true);
-static_assert(is_unsigned<uint32_t>() == true);
-static_assert(is_unsigned<uint64_t>() == true);
-
-static_assert(is_unsigned<int8_t>() == false);
-static_assert(is_unsigned<int16_t>() == false);
-static_assert(is_unsigned<int32_t>() == false);
-static_assert(is_unsigned<int64_t>() == false);
+static_assert(libk::is_unsigned<uint8_t>() == true);
+static_assert(libk::is_unsigned<uint16_t>() == true);
+static_assert(libk::is_unsigned<uint32_t>() == true);
+static_assert(libk::is_unsigned<uint64_t>() == true);
+
+static_assert(libk::is_unsigned<int8_t>() == false);
+static_assert(libk::is_unsigned<int16_t>() == false);
+static_assert(libk::is_unsigned<int32_t>() == false);
+static_assert(libk::is_unsigned<int64_t>() == false);