1 files changed, 179 insertions, 0 deletions
diff --git a/src/kernel/NeKit/Defines.h b/src/kernel/NeKit/Defines.h
new file mode 100644
index 00000000..1a6a2cf6
--- /dev/null
+++ b/src/kernel/NeKit/Defines.h
@@ -0,0 +1,179 @@
+/* ========================================
+
+  Copyright (C) 2024-2025, Amlal El Mahrouss, licensed under the Apache 2.0 license.
+
+======================================== */
+
+#pragma once
+
+#include <NeKit/Macros.h>
+
+#define NEKIT_VERSION_STR "0.0.1"
+#define NEKIT_VERSION_BCD 0x0001
+
+#ifndef __cplusplus
+#error !!! Kernel compiles only with a C++ compiler. !!!
+#endif
+
+#if __cplusplus <= 201703L
+#define char8_t char
+#endif
+
+#ifdef __has_feature
+#if !__has_feature(cxx_nullptr)
+#if !__has_nullptr
+#error !!! You must at least have nullptr featured on your C++ compiler. !!!
+#endif
+#endif
+#endif
+
+/// @brief The **Kernel** namespace.
+namespace Kernel {
+using voidPtr = void*;
+using VoidPtr = void*;
+using nullPtr = decltype(nullptr);
+using NullPtr = decltype(nullptr);
+
+using Int     = int;
+using Int32   = __INT32_TYPE__;
+using UShort  = __UINT16_TYPE__;
+using UInt16  = __UINT16_TYPE__;
+using Short   = short;
+using Int16   = __INT16_TYPE__;
+using UInt    = __UINT32_TYPE__;
+using UInt32  = __UINT32_TYPE__;
+using Long    = __INT64_TYPE__;
+using Int64   = __INT64_TYPE__;
+using ULong   = __UINT64_TYPE__;
+using UInt64  = __UINT64_TYPE__;
+using Boolean = bool;
+using Bool    = bool;
+using Char    = char;
+using Int8    = __INT8_TYPE__;
+using Char8   = char8_t;
+using UChar   = __UINT8_TYPE__;
+using UInt8   = __UINT8_TYPE__;
+
+using SSize     = long;
+using SSizeT    = long;
+using Size      = __SIZE_TYPE__;
+using SizeT     = __SIZE_TYPE__;
+using IntPtr    = __INTPTR_TYPE__;
+using UIntPtr   = __UINTPTR_TYPE__;
+using IntFast   = __INT_FAST32_TYPE__;
+using IntFast64 = __INT_FAST64_TYPE__;
+using PtrDiff   = __PTRDIFF_TYPE__;
+
+using SInt16 = Int16;
+using SInt32 = Int32;
+using SInt64 = Int64;
+
+typedef UIntPtr* Ptr64;
+typedef UInt32*  Ptr32;
+typedef UInt8*   Ptr8;
+
+using Utf8Char  = char8_t;
+using Utf16Char = char16_t;
+using WideChar  = wchar_t;
+using Utf32Char = char32_t;
+
+using LongDouble = long double;
+using Double     = double;
+using Float      = float;
+
+typedef UInt32  PhysicalAddressKind;
+typedef UIntPtr VirtualAddressKind;
+
+using Void = void;
+using Any  = void*;
+
+using Lba = UInt64;
+
+using Char16 = char16_t;
+
+enum class Endian : UInt8 { kEndianInvalid, kEndianBig, kEndianLittle, kEndianMixed, kEndianCount };
+
+/// @brief Forward object.
+/// @tparam Args the object type.
+/// @param arg the object.
+/// @return object's rvalue
+template <typename Args>
+inline Args&& forward(Args& arg) {
+  return static_cast<Args&&>(arg);
+}
+
+/// @brief Move object.
+/// @tparam Args the object type.
+/// @param arg the object.
+/// @return object's rvalue
+template <typename Args>
+inline Args&& move(Args&& arg) {
+  return static_cast<Args&&>(arg);
+}
+
+/// @brief Encoding interface, used as a proxy to convert T to Char*
+/// Used to cast A to B or B to A.
+class ICodec {
+ public:
+  explicit ICodec() = default;
+  virtual ~ICodec() = default;
+
+  ICodec& operator=(const ICodec&) = default;
+  ICodec(const ICodec&)            = default;
+
+ public:
+  /// @brief Convert type to bytes.
+  /// @tparam T the type.
+  /// @param type (a1) the data.
+  /// @return a1 as Char*
+  template <typename T>
+  const Char* AsBytes(T type) noexcept {
+    NE_UNUSED(type);
+    return nullptr;
+  }
+
+  /// @brief Construct from type to class.
+  /// @tparam T the type to convert.
+  /// @param type (a1) the data.
+  /// @return a1 as Char*
+  template <typename OutputClass, typename FactoryClass>
+  OutputClass* Construct(Char* type) noexcept {
+    FactoryClass class_fac;
+    return class_fac.template From<OutputClass>(type);
+  }
+
+  /// @brief Convert T class to Y class.
+  /// @tparam T the class type of type.
+  /// @tparam Y the result class.
+  /// @param type the class to cast.
+  /// @return the class as Y.
+  template <typename T, typename Y>
+  Y As(T type) noexcept {
+    if (type.template IsSerializable()) {
+      return reinterpret_cast<Char*>(type);
+    }
+
+    return type.template As<Y>();
+  }
+};
+
+/// \brief Scheduler interface, represents a scheduler object.
+/// @note This is used to schedule tasks, such as threads, drivers, user threads, etc.
+class ISchedulable {
+ public:
+  explicit ISchedulable() = default;
+  virtual ~ISchedulable() = default;
+
+  ISchedulable& operator=(const ISchedulable&) = default;
+  ISchedulable(const ISchedulable&)            = default;
+
+  /// @brief Is this object only accepting user tasks?
+  virtual Bool IsUser() { return NO; }
+
+  /// @brief Is this object only accepting kernel tasks?
+  virtual Bool IsKernel() { return NO; }
+
+  /// @brief Is this object offloading to another CPU?
+  virtual Bool HasMP() { return NO; }
+};
+}  // namespace Kernel