:boom: Breaking changes, disk API improvemenets and bringing support for

more drivers...

Signed-off-by: Amlal El Mahrouss <amlal@el-mahrouss-logic.com>

13 files changed, 126 insertions, 126 deletions

diff --git a/Private/NewKit/Array.hpp b/Private/NewKit/Array.hpp
index a892f1a7..6724d8a9 100644
--- a/Private/NewKit/Array.hpp
+++ b/Private/NewKit/Array.hpp
@@ -27,12 +27,12 @@ public:
             return {};
 
         kcout << "Returning element\r\n";
-        return ErrorOr<T>(m_Array[At]);
+        return ErrorOr<T>(fArray[At]);
     }
 
     Boolean Empty() const
     {
-        for (auto Val : m_Array)
+        for (auto Val : fArray)
         {
             if (Val)
                 return false;
@@ -44,7 +44,7 @@ public:
     SizeT Count() const
     {
         SizeT cntElems = 0UL;
-        for (auto Val : m_Array)
+        for (auto Val : fArray)
         {
             if (Val)
                 ++cntElems;
@@ -55,7 +55,7 @@ public:
 
     const T *CData()
     {
-        return m_Array;
+        return fArray;
     }
 
     operator bool()
@@ -64,7 +64,7 @@ public:
     }
 
 private:
-    T m_Array[N];
+    T fArray[N];
     
 };
 } // namespace NewOS
diff --git a/Private/NewKit/ArrayList.hpp b/Private/NewKit/ArrayList.hpp
index ef6889ea..b7ab50cf 100644
--- a/Private/NewKit/ArrayList.hpp
+++ b/Private/NewKit/ArrayList.hpp
@@ -15,7 +15,7 @@ namespace NewOS
     {
     public:
         explicit ArrayList(T *list)
-            : m_List(reinterpret_cast<T>(list))
+            : fList(reinterpret_cast<T>(list))
         {}
 
         ~ArrayList() = default;
@@ -25,26 +25,26 @@ namespace NewOS
 
         T *Data()
         {
-            return m_List;
+            return fList;
         }
 
         const T *CData()
         {
-            return m_List;
+            return fList;
         }
 
         T &operator[](int index) const
         {
-            return m_List[index];
+            return fList[index];
         }
 
         operator bool()
         {
-            return m_List;
+            return fList;
         }
 
     private:
-        T *m_List;
+        T *fList;
 
         friend class InitHelpers;
 
diff --git a/Private/NewKit/Atom.hpp b/Private/NewKit/Atom.hpp
index 34cbea51..648302fc 100644
--- a/Private/NewKit/Atom.hpp
+++ b/Private/NewKit/Atom.hpp
@@ -22,11 +22,11 @@ template <typename T> class Atom final
   public:
     T operator[](Size sz)
     {
-        return (m_ArrayOfAtoms & sz);
+        return (fArrayOfAtoms & sz);
     }
     void operator|(Size sz)
     {
-        m_ArrayOfAtoms |= sz;
+        fArrayOfAtoms |= sz;
     }
 
     friend Boolean operator==(Atom<T> &atomic, const T &idx)
@@ -40,6 +40,6 @@ template <typename T> class Atom final
     }
 
   private:
-    T m_ArrayOfAtoms;
+    T fArrayOfAtoms;
 };
 } // namespace NewOS
diff --git a/Private/NewKit/Function.hpp b/Private/NewKit/Function.hpp
index 63bc31dc..79d33a3b 100644
--- a/Private/NewKit/Function.hpp
+++ b/Private/NewKit/Function.hpp
@@ -10,7 +10,7 @@ class Function final {
   Function() = default;
 
  public:
-  explicit Function(T (*Fn)(Args... args)) : m_Fn(Fn) {}
+  explicit Function(T (*Fn)(Args... args)) : fFn(Fn) {}
 
   ~Function() = default;
 
@@ -19,20 +19,20 @@ class Function final {
 
   template <typename... XArgs>
   T operator()(Args... args) {
-    return m_Fn(args...);
+    return fFn(args...);
   }
 
   template <typename... XArgs>
   T Call(Args... args) {
-    return m_Fn(args...);
+    return fFn(args...);
   }
 
-  operator bool() { return m_Fn; }
+  operator bool() { return fFn; }
 
-  bool operator!() { return !m_Fn; }
+  bool operator!() { return !fFn; }
 
  private:
-  T (*m_Fn)(Args... args);
+  T (*fFn)(Args... args);
 };
 }  // namespace NewOS
 
diff --git a/Private/NewKit/MutableArray.hpp b/Private/NewKit/MutableArray.hpp
index bdedb97f..b46f1bc7 100644
--- a/Private/NewKit/MutableArray.hpp
+++ b/Private/NewKit/MutableArray.hpp
@@ -13,9 +13,9 @@
     auto *NAME = NODE;                                                         \
     while (NAME)                                                               \
     {                                                                          \
-        if (NAME->m_Index == Index)                                            \
-            return NAME->m_Val;                                                \
-        NAME = NAME->m_Next;                                                   \
+        if (NAME->fIndex == Index)                                            \
+            return NAME->fVal;                                                \
+        NAME = NAME->fNext;                                                   \
     }
 
 
@@ -24,18 +24,18 @@
     auto *NAME = NODE;                                                         \
     while (NAME)                                                               \
     {                                                                          \
-        if (NAME->m_Index == Index)                                            \
-            return Ref<T>{NAME->m_Val};                                        \
-        NAME = NAME->m_Next;                                                   \
+        if (NAME->fIndex == Index)                                            \
+            return Ref<T>{NAME->fVal};                                        \
+        NAME = NAME->fNext;                                                   \
     }
 
 
 
 #define TRY_REMOVE_NODE(NODE)                                                  \
-    if (NODE && NODE->m_Index == Index)                                        \
+    if (NODE && NODE->fIndex == Index)                                        \
     {                                                                          \
-        NODE->m_Used = false;                                                  \
-        NODE->m_Index = 0;                                                     \
+        NODE->fUsed = false;                                                  \
+        NODE->fIndex = 0;                                                     \
                                                                                \
         return true;                                                           \
     }
@@ -53,19 +53,19 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray;
 template <typename T> class MutableLinkedList
 {
   public:
-    T m_Val;
-    SizeT m_Index{0};
-    Boolean m_Used{false};
+    T fVal;
+    SizeT fIndex{0};
+    Boolean fUsed{false};
 
-    MutableLinkedList *m_Prev{nullptr};
-    MutableLinkedList *m_Next{nullptr};
+    MutableLinkedList *fPrev{nullptr};
+    MutableLinkedList *fNext{nullptr};
 };
 
 template <typename T, T _PlaceHolderValue> class NullableMutableArray
 {
   public:
     // explicit this.
-    explicit NullableMutableArray() : m_FirstNode(new MutableLinkedList<T>()) {}
+    explicit NullableMutableArray() : fFirstNode(new MutableLinkedList<T>()) {}
 
     /*
      * We free all the nodes allocated by the array
@@ -74,12 +74,12 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray
 
     virtual ~NullableMutableArray()
     {
-        auto *It = m_FirstNode;
+        auto *It = fFirstNode;
         MutableLinkedList<T> *NextIt = nullptr;
 
         while (It)
         {
-            NextIt = It->m_Next;
+            NextIt = It->fNext;
             delete It;
 
             It = NextIt;
@@ -94,43 +94,43 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray
   public:
     T operator[](const SizeT &Index) const
     {
-        TRY_FIND_NODE(first, m_FirstNode);
-        TRY_FIND_NODE(last, m_LastNode);
+        TRY_FIND_NODE(first, fFirstNode);
+        TRY_FIND_NODE(last, fLastNode);
 
         return _PlaceHolderValue;
     }
 
-    SizeT Count() const { return m_NodeCount; }
+    SizeT Count() const { return fNodeCount; }
 
   public:
     Boolean Remove(const SizeT &Index)
     {
-        TRY_REMOVE_NODE(m_FirstNode);
-        TRY_REMOVE_NODE(m_LastNode);
+        TRY_REMOVE_NODE(fFirstNode);
+        TRY_REMOVE_NODE(fLastNode);
 
         return false;
     }
 
     Boolean Add(const T val)
     {
-        auto *iterationNode = m_FirstNode;
+        auto *iterationNode = fFirstNode;
         MUST_PASS(iterationNode);
 
         while (iterationNode)
         {
-            if (!iterationNode->m_Used)
+            if (!iterationNode->fUsed)
             {
-                iterationNode->m_Val = val;
-                iterationNode->m_Index = 0;
+                iterationNode->fVal = val;
+                iterationNode->fIndex = 0;
 
-                iterationNode->m_Used = true;
+                iterationNode->fUsed = true;
 
-                ++m_NodeCount;
+                ++fNodeCount;
 
                 return true;
             }
 
-            iterationNode = iterationNode->m_Next;
+            iterationNode = iterationNode->fNext;
         }
 
         return false;
@@ -138,11 +138,11 @@ template <typename T, T _PlaceHolderValue> class NullableMutableArray
 
   private:
     /* Avoid useless lookups */
-    MutableLinkedList<T> *m_LastNode{nullptr};
-    MutableLinkedList<T> *m_FirstNode{nullptr};
+    MutableLinkedList<T> *fLastNode{nullptr};
+    MutableLinkedList<T> *fFirstNode{nullptr};
 
     /* Number of nodes inside of this dynamic array. */
-    NewOS::SizeT m_NodeCount{0};
+    NewOS::SizeT fNodeCount{0};
 
   private:
     // don't remove that
@@ -162,24 +162,24 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr>
   public:
     Boolean Add(const T val)
     {
-        auto *iterationNode = m_FirstNode;
+        auto *iterationNode = fFirstNode;
         MUST_PASS(iterationNode);
 
         while (iterationNode)
         {
-            if (!iterationNode->m_Used)
+            if (!iterationNode->fUsed)
             {
-                iterationNode->m_Val = val;
-                iterationNode->m_Index = 0;
+                iterationNode->fVal = val;
+                iterationNode->fIndex = 0;
 
-                iterationNode->m_Used = true;
+                iterationNode->fUsed = true;
 
-                ++m_NodeCount;
+                ++fNodeCount;
 
                 return true;
             }
 
-            iterationNode = iterationNode->m_Next;
+            iterationNode = iterationNode->fNext;
         }
 
         return false;
@@ -188,24 +188,24 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr>
   public:
     Ref<T> operator[](const SizeT &Index) const
     {
-        TRY_FIND_NODE2(first, m_FirstNode);
-        TRY_FIND_NODE2(last, m_LastNode);
+        TRY_FIND_NODE2(first, fFirstNode);
+        TRY_FIND_NODE2(last, fLastNode);
 
         return {};
     }
 
-    SizeT Count() const { return m_NodeCount; }
+    SizeT Count() const { return fNodeCount; }
 
     bool Contains(T &value) noexcept
     {
-        MutableLinkedList<T> *first = m_FirstNode;
+        MutableLinkedList<T> *first = fFirstNode;
 
         while (first)
         {
-            if (first->m_Val == value && first->m_Used)
+            if (first->fVal == value && first->fUsed)
                 return true;
 
-            first = first->m_Next;
+            first = first->fNext;
         }
 
         return false;
@@ -213,10 +213,10 @@ class MutableArray : public NullableMutableArray<voidPtr, nullptr>
 
   private:
     /* Avoid useless lookups */
-    MutableLinkedList<T> *m_LastNode{nullptr};
-    MutableLinkedList<T> *m_FirstNode{nullptr};
+    MutableLinkedList<T> *fLastNode{nullptr};
+    MutableLinkedList<T> *fFirstNode{nullptr};
 
     /* Number of nodes inside of this dynamic array. */
-    NewOS::SizeT m_NodeCount{0};
+    NewOS::SizeT fNodeCount{0};
 };
 } // namespace NewOS
diff --git a/Private/NewKit/OwnPtr.hpp b/Private/NewKit/OwnPtr.hpp
index e6d006ed..ff2b59e1 100644
--- a/Private/NewKit/OwnPtr.hpp
+++ b/Private/NewKit/OwnPtr.hpp
@@ -30,30 +30,30 @@ class OwnPtr final {
  public:
   template <typename... Args>
   bool New(Args &&...arg) {
-    if (m_Cls) {
+    if (fCls) {
       return false;
     }
 
-    m_Cls = new T(arg...);
-    return m_Cls;
+    fCls = new T(arg...);
+    return fCls;
   }
 
   void Delete() {
-    if (m_Cls) delete m_Cls;
+    if (fCls) delete fCls;
 
-    m_Cls = nullptr;
+    fCls = nullptr;
   }
 
-  T *operator->() const { return m_Cls; };
-  T *Raw() { return m_Cls; }
+  T *operator->() const { return fCls; };
+  T *Raw() { return fCls; }
 
-  Ref<T> AsRef() { return Ref<T>(m_Cls); }
+  Ref<T> AsRef() { return Ref<T>(fCls); }
 
-  operator bool() { return m_Cls; }
-  bool operator!() { return !m_Cls; }
+  operator bool() { return fCls; }
+  bool operator!() { return !fCls; }
 
  private:
-  T *m_Cls;
+  T *fCls;
 };
 
 template <typename T, typename... Args>
diff --git a/Private/NewKit/PageManager.hpp b/Private/NewKit/PageManager.hpp
index 9aba5a6c..c8806c90 100644
--- a/Private/NewKit/PageManager.hpp
+++ b/Private/NewKit/PageManager.hpp
@@ -42,15 +42,15 @@ class PTEWrapper final {
   bool Access();
 
  private:
-  Boolean m_Rw;
-  Boolean m_User;
-  Boolean m_ExecDisable;
-  UIntPtr m_VirtAddr;
-  Boolean m_Cache;
-  Boolean m_Shareable;
-  Boolean m_Wt;
-  Boolean m_Present;
-  Boolean m_Accessed;
+  Boolean fRw;
+  Boolean fUser;
+  Boolean fExecDisable;
+  UIntPtr fVirtAddr;
+  Boolean fCache;
+  Boolean fShareable;
+  Boolean fWt;
+  Boolean fPresent;
+  Boolean fAccessed;
 
  private:
   friend class PageManager;
diff --git a/Private/NewKit/Pmm.hpp b/Private/NewKit/Pmm.hpp
index ed43a03c..2ed8b753 100644
--- a/Private/NewKit/Pmm.hpp
+++ b/Private/NewKit/Pmm.hpp
@@ -31,9 +31,9 @@ class Pmm final {
   Boolean ToggleShare(Ref<PTEWrapper> refPage, Boolean enable = true);
 
   /// @brief Get the page manager of this.
-  Ref<PageManager> &Leak() { return m_PageManager; }
+  Ref<PageManager> &Leak() { return fPageManager; }
 
  private:
-  Ref<PageManager> m_PageManager;
+  Ref<PageManager> fPageManager;
 };
 }  // namespace NewOS
diff --git a/Private/NewKit/Ref.hpp b/Private/NewKit/Ref.hpp
index 4327081b..30e65e2f 100644
--- a/Private/NewKit/Ref.hpp
+++ b/Private/NewKit/Ref.hpp
@@ -18,27 +18,27 @@ class Ref final {
   ~Ref() = default;
 
  public:
-  Ref(T cls, const bool &strong = false) : m_Class(cls), m_Strong(strong) {}
+  Ref(T cls, const bool &strong = false) : fClass(cls), fStrong(strong) {}
 
   Ref &operator=(T ref) {
-    m_Class = ref;
+    fClass = ref;
     return *this;
   }
 
  public:
-  T operator->() const { return m_Class; }
+  T operator->() const { return fClass; }
 
-  T &Leak() { return m_Class; }
+  T &Leak() { return fClass; }
 
-  T operator*() { return m_Class; }
+  T operator*() { return fClass; }
 
-  bool IsStrong() const { return m_Strong; }
+  bool IsStrong() const { return fStrong; }
 
-  operator bool() { return m_Strong; }
+  operator bool() { return fStrong; }
 
  private:
-  T m_Class;
-  bool m_Strong{false};
+  T fClass;
+  bool fStrong{false};
 };
 
 template <typename T>
@@ -47,17 +47,17 @@ class NonNullRef final {
   NonNullRef() = delete;
   NonNullRef(nullPtr) = delete;
 
-  NonNullRef(T *ref) : m_Ref(ref, true) {}
+  NonNullRef(T *ref) : fRef(ref, true) {}
 
   Ref<T> &operator->() {
-    MUST_PASS(m_Ref);
-    return m_Ref;
+    MUST_PASS(fRef);
+    return fRef;
   }
 
   NonNullRef &operator=(const NonNullRef<T> &ref) = delete;
   NonNullRef(const NonNullRef<T> &ref) = default;
 
  private:
-  Ref<T> m_Ref{nullptr};
+  Ref<T> fRef{nullptr};
 };
 }  // namespace NewOS
diff --git a/Private/NewKit/Stream.hpp b/Private/NewKit/Stream.hpp
index 30e60939..67288191 100644
--- a/Private/NewKit/Stream.hpp
+++ b/Private/NewKit/Stream.hpp
@@ -17,7 +17,7 @@ namespace NewOS
     {
     public:
         explicit Stream(Ref<Stream> ref)
-            : m_Stream(ref)
+            : fStream(ref)
         {}
 
         ~Stream() = default;
@@ -28,31 +28,31 @@ namespace NewOS
         template <typename Data>
         friend Stream<StreamTrait, Kind> &operator>>(Stream<StreamTrait, Kind> &Ks, Ref<Data>& Buf)
         {
-            Ks.m_Kind = Ks.m_Stream->In(Buf);
+            Ks.fKind = Ks.fStream->In(Buf);
             return *Ks;
         }
 
         template <typename Data>
         friend Stream<StreamTrait, Kind> &operator<<(Stream<StreamTrait, Kind> &Ks, Ref<Data>& Buf)
         {
-            Ks.m_Kind = Buf;
-            Ks.m_Stream->Out(Buf.Leak());
+            Ks.fKind = Buf;
+            Ks.fStream->Out(Buf.Leak());
             return *Ks;
         }
 
         Ref<StreamTrait> &AsStreamTrait()
         {
-            return m_Stream;
+            return fStream;
         }
         
         Ref<Kind>& AsType()
         {
-            return m_Kind;
+            return fKind;
         }
 
       private:
-        Ref<StreamTrait> m_Stream;
-        Ref<Kind> m_Kind;
+        Ref<StreamTrait> fStream;
+        Ref<Kind> fKind;
 
     };
 } // namespace NewOS
diff --git a/Private/NewKit/String.hpp b/Private/NewKit/String.hpp
index 1806c32a..93dfc584 100644
--- a/Private/NewKit/String.hpp
+++ b/Private/NewKit/String.hpp
@@ -15,14 +15,14 @@ class StringView final {
  public:
   explicit StringView() = default;
 
-  explicit StringView(Size Sz) : m_Sz(Sz) {
+  explicit StringView(Size Sz) : fSz(Sz) {
     MUST_PASS(Sz > 1);
-    m_Data = new Char[Sz];
-    MUST_PASS(m_Data);
+    fData = new Char[Sz];
+    MUST_PASS(fData);
   }
 
   ~StringView() {
-    if (m_Data) delete[] m_Data;
+    if (fData) delete[] fData;
   }
 
   StringView &operator=(const StringView &) = default;
@@ -41,14 +41,14 @@ class StringView final {
   StringView &operator+=(const Char *rhs);
   StringView &operator+=(const StringView &rhs);
 
-  operator bool() { return m_Data; }
+  operator bool() { return fData; }
 
-  bool operator!() { return m_Data; }
+  bool operator!() { return fData; }
 
  private:
-  Char *m_Data{nullptr};
-  Size m_Sz{0};
-  Size m_Cur{0};
+  Char *fData{nullptr};
+  Size fSz{0};
+  Size fCur{0};
 
   friend class StringBuilder;
 };
diff --git a/Private/NewKit/Utils.hpp b/Private/NewKit/Utils.hpp
index 67ecaf22..749e15ba 100644
--- a/Private/NewKit/Utils.hpp
+++ b/Private/NewKit/Utils.hpp
@@ -24,5 +24,5 @@ Boolean is_space(Char chr);
 Int rt_to_uppercase(Int c);
 Int rt_to_lower(Int c);
 voidPtr rt_string_in_string(const char *in, const char *needle);
-char *rt_string_from_char(char *str, const char chr);
+char *rt_string_frofchar(char *str, const char chr);
 }  // namespace NewOS
diff --git a/Private/NewKit/Variant.hpp b/Private/NewKit/Variant.hpp
index 109acbbe..c0738de2 100644
--- a/Private/NewKit/Variant.hpp
+++ b/Private/NewKit/Variant.hpp
@@ -25,15 +25,15 @@ class Variant final {
 
  public:
   explicit Variant(StringView *stringView)
-      : m_Ptr((voidPtr)stringView), m_Kind(VariantKind::kString) {}
-  explicit Variant(nullPtr) : m_Ptr(nullptr), m_Kind(VariantKind::kUndefined) {}
-  explicit Variant(voidPtr ptr) : m_Ptr(ptr), m_Kind(VariantKind::kPointer) {}
+      : fPtr((voidPtr)stringView), fKind(VariantKind::kString) {}
+  explicit Variant(nullPtr) : fPtr(nullptr), fKind(VariantKind::kUndefined) {}
+  explicit Variant(voidPtr ptr) : fPtr(ptr), fKind(VariantKind::kPointer) {}
 
  public:
   const Char *ToString();
 
  private:
-  voidPtr m_Ptr{nullptr};
-  VariantKind m_Kind{VariantKind::kUndefined};
+  voidPtr fPtr{nullptr};
+  VariantKind fKind{VariantKind::kUndefined};
 };
 }  // namespace NewOS