Kernel: Update TODO.

Src: Refactorings according to clang-format.
Meta: Update specification.
Public: Remove useless UIKit.

Signed-off-by: Amlal El Mahrouss <amlal.elmahrouss@icloud.com>

1 files changed, 122 insertions, 167 deletions

diff --git a/Private/Source/Utils.cxx b/Private/Source/Utils.cxx
index 9f767d72..6569258b 100644
--- a/Private/Source/Utils.cxx
+++ b/Private/Source/Utils.cxx
@@ -9,211 +9,166 @@
 
 #include <NewKit/Utils.hpp>
 
-namespace hCore
-{
-    Int string_compare(const Char *src, const Char *cmp, Size size)
-    {
-        Int32 counter = 0;
-
-        for (Size index = 0; index < size; ++index)
-        {
-            if (src[index] != cmp[index])
-                ++counter;
-        }
-
-        return counter;
-    }
+namespace hCore {
+Int string_compare(const Char *src, const Char *cmp, Size size) {
+  Int32 counter = 0;
 
-    void rt_zero_memory(voidPtr pointer, Size len)
-    {
-        rt_set_memory((voidPtr) pointer, 0, len);
-    }
+  for (Size index = 0; index < size; ++index) {
+    if (src[index] != cmp[index]) ++counter;
+  }
 
-    Size string_length(const Char *str, SizeT _len)
-    {
-        if (*str == '\0')
-            return 0;
+  return counter;
+}
 
-        Size len{0};
-        while (str[len] != '\0')
-        {
-            if (len > _len)
-            {
-                break;
-            }
+void rt_zero_memory(voidPtr pointer, Size len) {
+  rt_set_memory((voidPtr)pointer, 0, len);
+}
 
-            ++len;
-        }
+Size string_length(const Char *str, SizeT _len) {
+  if (*str == '\0') return 0;
 
-        return len;
+  Size len{0};
+  while (str[len] != '\0') {
+    if (len > _len) {
+      break;
     }
 
-    Size string_length(const Char *str)
-    {
-        if (*str == '\0')
-            return 0;
+    ++len;
+  }
 
-        Size len{0};
-        while (str[len] != '\0')
-            ++len;
+  return len;
+}
 
-        return len;
-    }
+Size string_length(const Char *str) {
+  if (*str == '\0') return 0;
 
-    voidPtr rt_set_memory(voidPtr src, char value, Size len)
-    {
-        if (!src || len < 1)
-            return nullptr;
-        char *start = reinterpret_cast<Char*>(src);
+  Size len{0};
+  while (str[len] != '\0') ++len;
 
-        while (len)
-        {
-            *start = value;
-            ++start;
-            --len;
-        }
+  return len;
+}
 
-        return (voidPtr) start;
-    }
+voidPtr rt_set_memory(voidPtr src, char value, Size len) {
+  if (!src || len < 1) return nullptr;
+  char *start = reinterpret_cast<Char *>(src);
 
-    Int rt_move_memory(const voidPtr src, voidPtr dst, Size len)
-    {
-        if (len < 1)
-            return -2;
-        if (!src || !dst)
-            return -1;
+  while (len) {
+    *start = value;
+    ++start;
+    --len;
+  }
 
-        char *srcChr = reinterpret_cast<Char*>(src);
-        char *dstChar = reinterpret_cast<Char*>(dst);
-        Size index = 0;
+  return (voidPtr)start;
+}
 
-        while (index < len)
-        {
-            dstChar[index] = srcChr[index];
-            srcChr[index] = 0;
+Int rt_move_memory(const voidPtr src, voidPtr dst, Size len) {
+  if (len < 1) return -2;
+  if (!src || !dst) return -1;
 
-            index++;
-        }
+  char *srcChr = reinterpret_cast<Char *>(src);
+  char *dstChar = reinterpret_cast<Char *>(dst);
+  Size index = 0;
 
-        return 0;
-    }
+  while (index < len) {
+    dstChar[index] = srcChr[index];
+    srcChr[index] = 0;
 
-    Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len)
-    {
-        if (len < 1)
-            return -2;
-        if (!src || !dst)
-            return -1;
+    index++;
+  }
 
-        char *srcChr = reinterpret_cast<char*>(src);
-        char *dstChar = reinterpret_cast<char*>(dst);
-        Size index = 0;
+  return 0;
+}
 
-        while (index < len)
-        {
-            dstChar[index] = srcChr[index];
-            index++;
-        }
+Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len) {
+  if (len < 1) return -2;
+  if (!src || !dst) return -1;
 
-        return 0;
-    }
+  char *srcChr = reinterpret_cast<char *>(src);
+  char *dstChar = reinterpret_cast<char *>(dst);
+  Size index = 0;
 
-    const Char *alloc_string(const Char *text)
-    {
-        if (!text)
-            return nullptr;
+  while (index < len) {
+    dstChar[index] = srcChr[index];
+    index++;
+  }
 
-        const Char *string = new Char[string_length(text)];
-        if (!string)
-            return nullptr;
+  return 0;
+}
 
-        voidPtr vText = reinterpret_cast<voidPtr>(const_cast<char*>(text));
-        voidPtr vStr = reinterpret_cast<voidPtr>(const_cast<char*>(string));
-        rt_copy_memory(vText, vStr, string_length(text));
-        return string;
-    }
+const Char *alloc_string(const Char *text) {
+  if (!text) return nullptr;
 
-    Int to_uppercase(Int character)
-    {
-        if (character >= 'a' && character <= 'z')
-            return character - 0x20;
+  const Char *string = new Char[string_length(text)];
+  if (!string) return nullptr;
 
-        return character;
-    }
+  voidPtr vText = reinterpret_cast<voidPtr>(const_cast<char *>(text));
+  voidPtr vStr = reinterpret_cast<voidPtr>(const_cast<char *>(string));
+  rt_copy_memory(vText, vStr, string_length(text));
+  return string;
+}
 
-    Int to_lower(Int character)
-    {
-        if (character >= 'A' && character <= 'Z')
-            return character + 0x20;
+Int to_uppercase(Int character) {
+  if (character >= 'a' && character <= 'z') return character - 0x20;
 
-        return character;
-    }
+  return character;
+}
 
-    bool to_str(Char *str, Int limit, Int base)
-    {
-        if (limit == 0)
-            return false;
+Int to_lower(Int character) {
+  if (character >= 'A' && character <= 'Z') return character + 0x20;
 
-        Int copy_limit = limit;
-        Int cnt = 0;
-        Int ret = base;
+  return character;
+}
 
-        while (limit != 1) {
-            ret = ret % 10;
-            str[cnt] = ret;
+bool to_str(Char *str, Int limit, Int base) {
+  if (limit == 0) return false;
 
-            ++cnt;
-            --limit;
-            --ret;
-        }
+  Int copy_limit = limit;
+  Int cnt = 0;
+  Int ret = base;
 
-        str[copy_limit] = '\0';
-        return true;
-    }
+  while (limit != 1) {
+    ret = ret % 10;
+    str[cnt] = ret;
 
-    Boolean is_space(Char chr)
-    {
-        return chr == ' ';
-    }
+    ++cnt;
+    --limit;
+    --ret;
+  }
 
-    Boolean is_newln(Char chr)
-    {
-        return chr == '\n';
-    }
+  str[copy_limit] = '\0';
+  return true;
+}
 
-    voidPtr string_in_string(const char *in, const char *needle)
-    {
-        for (size_t i = 0; i < string_length(in); ++i)
-        {
-            if (string_compare(in + i, needle, string_length(needle)) == 0)
-                return reinterpret_cast<voidPtr>(const_cast<char*>(in + i));
-        }
+Boolean is_space(Char chr) { return chr == ' '; }
 
-        return nullptr;
-    }
+Boolean is_newln(Char chr) { return chr == '\n'; }
 
-    // @brief Checks for a string start at the character.
-
-    char* string_from_char(char* str, const char chr)
-    {
-        while (*str != chr) 
-        { 
-        ++str; 
-        
-        if (*str == 0)
-            return nullptr;
-        }  
-    
-        return str;
-    }
-} // namespace hCore
+voidPtr string_in_string(const char *in, const char *needle) {
+  for (size_t i = 0; i < string_length(in); ++i) {
+    if (string_compare(in + i, needle, string_length(needle)) == 0)
+      return reinterpret_cast<voidPtr>(const_cast<char *>(in + i));
+  }
 
-extern "C" void memset(void* dst, char src, size_t len)
-{
-    hCore::rt_set_memory(dst, src, len);
+  return nullptr;
 }
 
-extern "C" void memcpy(void* dst, void* src, size_t len)
-{
-    hCore::rt_copy_memory(src, dst, len);
-}
\ No newline at end of file
+// @brief Checks for a string start at the character.
+
+char *string_from_char(char *str, const char chr) {
+  while (*str != chr) {
+    ++str;
+
+    if (*str == 0) return nullptr;
+  }
+
+  return str;
+}
+}  // namespace hCore
+
+extern "C" void memset(void *dst, char src, size_t len) {
+  hCore::rt_set_memory(dst, src, len);
+}
+
+extern "C" void memcpy(void *dst, void *src, size_t len) {
+  hCore::rt_copy_memory(src, dst, len);
+}