Config.h

Go to the documentation of this file.

/* ========================================
 
  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

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 };

template <typename Args>
inline Args&& forward(Args& arg) {
  return static_cast<Args&&>(arg);
}

template <typename Args>
inline Args&& move(Args&& arg) {
  return static_cast<Args&&>(arg);
}

class ICodec {
 public:
  explicit ICodec() = default;
  virtual ~ICodec() = default;
 
  ICodec& operator=(const ICodec&) = default;
  ICodec(const ICodec&)            = default;
 
 public:
  template <typename T>
  const Char* AsBytes(T type) {
    NE_UNUSED(type);
    return nullptr;
  }

  template <typename OutputClass, typename FactoryClass>
  OutputClass* Construct(Char* type) {
    FactoryClass class_fac;
    return class_fac.template From<OutputClass>(type);
  }

  template <typename T, typename Y>
  Y As(T type) {
    if (type.template IsSerializable()) {
      return type.template Error();
    }
 
    return type.template As<Y>();
  }
};

class ISchedulable {
 public:
  explicit ISchedulable() = default;
  virtual ~ISchedulable() = default;
 
  ISchedulable& operator=(const ISchedulable&) = default;
  ISchedulable(const ISchedulable&)            = default;

  virtual Bool IsUser() { return NO; }

  virtual Bool IsKernel() { return NO; }

  virtual Bool HasMP() { return NO; }
};
}  // namespace Kernel