Kernel: Breaking changes, see source code.

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

1 files changed, 80 insertions, 105 deletions

diff --git a/Private/Source/CodeManager.cxx b/Private/Source/CodeManager.cxx
index ced403cc..364a94f6 100644
--- a/Private/Source/CodeManager.cxx
+++ b/Private/Source/CodeManager.cxx
@@ -1,162 +1,137 @@
 /*
  *	========================================================
  *
- *	hCore
+ *	HCore
  * 	Copyright 2024 Mahrouss Logic, all rights reserved.
  *
  * 	========================================================
  */
 
-#include "NewKit/Defines.hpp"
-#include "NewKit/Panic.hpp"
 #include <KernelKit/CodeManager.hpp>
 #include <KernelKit/DebugOutput.hpp>
 #include <KernelKit/FileManager.hpp>
 #include <KernelKit/ProcessManager.hpp>
+#include <NewKit/Defines.hpp>
 #include <NewKit/ErrorID.hpp>
 #include <NewKit/KernelHeap.hpp>
 #include <NewKit/OwnPtr.hpp>
+#include <NewKit/RuntimeCheck.hpp>
 #include <NewKit/String.hpp>
 
-namespace hCore
-{
-namespace Detail
-{
-UInt32 rt_get_pef_platform(void) noexcept
-{
+namespace HCore {
+namespace Detail {
+UInt32 rt_get_pef_platform(void) noexcept {
 #ifdef __32x0__
-    return kPefArch32x0;
+  return kPefArch32x0;
 #elif defined(__64x0__)
-    return kPefArch64x0;
+  return kPefArch64x0;
 #elif defined(__x86_64__)
-    return kPefArchAMD64;
+  return kPefArchAMD64;
 #else
-    return kPefArchInvalid;
-#endif // __POWER || __x86_64__
+  return kPefArchInvalid;
+#endif  // __POWER || __x86_64__
 }
-} // namespace Detail
+}  // namespace Detail
 
-PEFLoader::PEFLoader(const VoidPtr blob) : fCachedBlob(nullptr)
-{
-    fCachedBlob = blob;
-    fBad = false;
+PEFLoader::PEFLoader(const VoidPtr blob) : fCachedBlob(nullptr) {
+  fCachedBlob = blob;
+  fBad = false;
 
-    MUST_PASS(fCachedBlob);
+  MUST_PASS(fCachedBlob);
 }
 
-PEFLoader::PEFLoader(const char *path) : fCachedBlob(nullptr), fBad(false)
-{
-    OwnPtr<FileStream<char>> file;
+PEFLoader::PEFLoader(const char *path) : fCachedBlob(nullptr), fBad(false) {
+  OwnPtr<FileStream<char>> file;
 
-    file.New(const_cast<Char *>(path));
+  file.New(const_cast<Char *>(path));
 
-    if (StringBuilder::Equals(file->MIME(), this->MIME()))
-    {
-        fPath = StringBuilder::Construct(path).Leak();
+  if (StringBuilder::Equals(file->MIME(), this->MIME())) {
+    fPath = StringBuilder::Construct(path).Leak();
 
-        fCachedBlob = file->ReadAll();
+    fCachedBlob = file->ReadAll();
 
-        PEFContainer *container = reinterpret_cast<PEFContainer *>(fCachedBlob);
-
-        auto fFree = [&]() -> void {
-            kcout << "CodeManager: Warning: Bad executable, program will not be started!\n";
-            fBad = true;
-
-            kernel_delete_ptr(fCachedBlob);
-
-            fCachedBlob = nullptr;
-        };
-
-        if (container->Cpu == Detail::rt_get_pef_platform() && container->Magic[0] == kPefMagic[0] &&
-            container->Magic[1] == kPefMagic[1] && container->Magic[2] == kPefMagic[2] && container->Abi == kPefAbi)
-        {
-            if (container->Kind != kPefKindObject && container->Kind != kPefKindDebug)
-            {
-                kcout << "CodeManager: Info: Good executable. can proceed.\n";
-                return;
-            }
-        }
+    PEFContainer *container = reinterpret_cast<PEFContainer *>(fCachedBlob);
 
-        fFree();
+    auto fFree = [&]() -> void {
+      kcout << "CodeManager: Warning: Bad executable, program will not be "
+               "started!\n";
+      fBad = true;
+
+      kernel_delete_ptr(fCachedBlob);
+
+      fCachedBlob = nullptr;
+    };
+
+    if (container->Cpu == Detail::rt_get_pef_platform() &&
+        container->Magic[0] == kPefMagic[0] &&
+        container->Magic[1] == kPefMagic[1] &&
+        container->Magic[2] == kPefMagic[2] && container->Abi == kPefAbi) {
+      if (container->Kind != kPefKindObject &&
+          container->Kind != kPefKindDebug) {
+        kcout << "CodeManager: Info: Good executable. can proceed.\n";
+        return;
+      }
     }
+
+    fFree();
+  }
 }
 
-PEFLoader::~PEFLoader()
-{
-    if (fCachedBlob)
-        kernel_delete_ptr(fCachedBlob);
+PEFLoader::~PEFLoader() {
+  if (fCachedBlob) kernel_delete_ptr(fCachedBlob);
 }
 
-VoidPtr PEFLoader::FindSymbol(const char *name, Int32 kind)
-{
-    if (!fCachedBlob || fBad)
-        return nullptr;
+VoidPtr PEFLoader::FindSymbol(const char *name, Int32 kind) {
+  if (!fCachedBlob || fBad) return nullptr;
 
-    PEFContainer *container = reinterpret_cast<PEFContainer *>(fCachedBlob);
+  PEFContainer *container = reinterpret_cast<PEFContainer *>(fCachedBlob);
 
-    PEFCommandHeader *container_header =
-        reinterpret_cast<PEFCommandHeader *>((UIntPtr)fCachedBlob + sizeof(PEFContainer));
+  PEFCommandHeader *container_header = reinterpret_cast<PEFCommandHeader *>(
+      (UIntPtr)fCachedBlob + sizeof(PEFContainer));
 
-    for (SizeT index = 0; index < container->Count; ++index)
-    {
-        kcout << "Iterating over container at index: " << StringBuilder::FromInt("%", index)
-              << ", name: " << container_header->Name << "\n";
+  for (SizeT index = 0; index < container->Count; ++index) {
+    kcout << "Iterating over container at index: "
+          << StringBuilder::FromInt("%", index)
+          << ", name: " << container_header->Name << "\n";
 
-        if (StringBuilder::Equals(container_header->Name, name))
-        {
-            kcout << "Found potential container, checking for validity.\n";
+    if (StringBuilder::Equals(container_header->Name, name)) {
+      kcout << "Found potential container, checking for validity.\n";
 
-            if (container_header->Kind == kind)
-                return static_cast<UIntPtr *>(fCachedBlob) + container_header->Offset;
+      if (container_header->Kind == kind)
+        return static_cast<UIntPtr *>(fCachedBlob) + container_header->Offset;
 
-            continue;
-        }
+      continue;
     }
+  }
 
-    return nullptr;
+  return nullptr;
 }
 
-ErrorOr<VoidPtr> PEFLoader::LoadStart()
-{
-    if (auto sym = this->FindSymbol("__start", kPefCode); sym)
-        return ErrorOr<VoidPtr>(sym);
+ErrorOr<VoidPtr> PEFLoader::LoadStart() {
+  if (auto sym = this->FindSymbol("__start", kPefCode); sym)
+    return ErrorOr<VoidPtr>(sym);
 
-    return ErrorOr<VoidPtr>(H_EXEC_ERROR);
+  return ErrorOr<VoidPtr>(H_EXEC_ERROR);
 }
 
-bool PEFLoader::IsLoaded() noexcept
-{
-    return !fBad && fCachedBlob;
-}
+bool PEFLoader::IsLoaded() noexcept { return !fBad && fCachedBlob; }
 
-namespace Utils
-{
-bool execute_from_image(PEFLoader &exec) noexcept
-{
-    auto errOrStart = exec.LoadStart();
+namespace Utils {
+bool execute_from_image(PEFLoader &exec) noexcept {
+  auto errOrStart = exec.LoadStart();
 
-    if (errOrStart.Error() != 0)
-        return false;
+  if (errOrStart.Error() != 0) return false;
 
-    Process proc(errOrStart.Leak().Leak());
-    Ref<Process> refProc = proc;
+  Process proc(errOrStart.Leak().Leak());
+  Ref<Process> refProc = proc;
 
-    return ProcessManager::Shared().Leak().Add(refProc);
+  return ProcessManager::Shared().Leak().Add(refProc);
 }
-} // namespace Utils
+}  // namespace Utils
 
-const char *PEFLoader::Path()
-{
-    return fPath.Leak().CData();
-}
+const char *PEFLoader::Path() { return fPath.Leak().CData(); }
 
-const char *PEFLoader::Format()
-{
-    return "PEF";
-}
+const char *PEFLoader::Format() { return "PEF"; }
 
-const char *PEFLoader::MIME()
-{
-    return "application/x-exec";
-}
-} // namespace hCore
+const char *PEFLoader::MIME() { return "application/x-exec"; }
+}  // namespace HCore