format

ficus-toolchain/newlib/newlib-4.4.0.20231231/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

src/kernel/templates/List.hpp

@@ -27,7 +27,7 @@ private:
     uint64_t size = 0;
 
 public:
-    List() = default;
+     List() = default;
     ~List() {
         while (!empty()) {
             pop_back();

src/kernel/templates/PointersCollection.hpp

@@ -19,15 +19,15 @@ public:
 
     explicit UniquePtr(T *data) : ptr(data) {}
 
-    ~UniquePtr() {
+    ~        UniquePtr() {
         if (ptr == nullptr) return;
         delete ptr;
     }
 
-    UniquePtr(UniquePtr const &other)            = delete;
+               UniquePtr(UniquePtr const &other) = delete;
     UniquePtr &operator=(UniquePtr const &other) = delete;
 
-    UniquePtr(UniquePtr &&other) {
+               UniquePtr(UniquePtr &&other) {
         delete ptr;
         ptr       = other.ptr;
         other.ptr = nullptr;
@@ -133,12 +133,12 @@ class SharedPtr {
     friend SharedPtrTester;
 
 public:
-    SharedPtr() = default;
+             SharedPtr() = default;
 
     explicit SharedPtr(T *data) : _ptr(data), _base(new SharedPtr_Base{SharedPtr_Base::UsesBlock{1, 1}}) {}
-    SharedPtr(std::nullptr_t a_nullptr) : _ptr(nullptr), _base(nullptr) {}
+             SharedPtr(std::nullptr_t a_nullptr) : _ptr(nullptr), _base(nullptr) {}
 
-    ~SharedPtr() {
+    ~        SharedPtr() {
         unref();
     }
 
@@ -188,7 +188,7 @@ private:
 
     explicit SharedPtr(T *ptr, SharedPtr_Base *base) : _ptr(ptr), _base(base) {}
 
-    void unref() {
+    void     unref() {
         if (!_base) return;
         if (_base->strong_release())
             delete _ptr;
@@ -204,10 +204,10 @@ private:
 template<typename T>
 class WeakPtr {
 public:
-    WeakPtr() = default;
+     WeakPtr() = default;
 
-    WeakPtr(const SharedPtr<T> &shared) : _base(shared._base), _ptr(shared._ptr) { _base->weak_lock(); }
-    WeakPtr(std::nullptr_t a_nullptr) : _ptr(nullptr), _base(nullptr) {}
+     WeakPtr(const SharedPtr<T> &shared) : _base(shared._base), _ptr(shared._ptr) { _base->weak_lock(); }
+     WeakPtr(std::nullptr_t a_nullptr) : _ptr(nullptr), _base(nullptr) {}
 
     ~WeakPtr() {
         unref();
@@ -290,22 +290,22 @@ private:
     }
 
 public:
-    COWPointer() = default;
+                COWPointer() = default;
 
-    explicit COWPointer(T *data) : ptr(data) {}
+    explicit    COWPointer(T *data) : ptr(data) {}
 
-    explicit COWPointer(SharedPtr<T> data) : ptr(std::move(data)) {}
+    explicit    COWPointer(SharedPtr<T> data) : ptr(std::move(data)) {}
 
-    COWPointer(COWPointer &&other)     = default;
+                COWPointer(COWPointer &&other)     = default;
 
-    COWPointer(COWPointer const &data) = default;
+                COWPointer(COWPointer const &data) = default;
 
     COWPointer &operator=(COWPointer other) {
         std::swap(ptr, other.ptr);
         return *this;
     }
 
-    ~COWPointer() = default;
+    ~  COWPointer() = default;
 
     T *get() const {
         return ptr.get();

src/kernel/templates/SkipList.hpp

@@ -8,7 +8,7 @@
 
 #include "assert.h"
 
-extern "C" int  rand(void);
+extern "C" int rand(void);
 
 template<typename K, typename V>
 class SkipList {
@@ -31,7 +31,7 @@ private:
         int                  top = -1;
 
     public:
-        NodeAllocator() noexcept = default;
+         NodeAllocator() noexcept = default;
 
         ~NodeAllocator() noexcept {
             for (int i = top; i >= 0; i--) {
@@ -360,7 +360,7 @@ public:
         using pointer         = value_type *;
         using reference       = value_type &;
 
-        explicit SkipListIterator(Node *n) : n(std::move(n)){};
+        explicit          SkipListIterator(Node *n) : n(std::move(n)){};
 
         reference         operator*() const { return *n; }
 

src/unit-tests/kapi/kmem.hpp

@@ -9,9 +9,9 @@
 #include <cstdint>
 #include <cstdlib>
 
-void                    *kmalloc(size_t n) {return malloc(n);}
-void                     kfree(void *addr){return free(addr);}
-void                    *krealloc(void *addr, size_t newsize) {return realloc(addr,newsize);}
+void *kmalloc(size_t n) { return malloc(n); }
+void  kfree(void *addr) { return free(addr); }
+void *krealloc(void *addr, size_t newsize) { return realloc(addr, newsize); }
 
 
 #endif //KMEM_HPP

src/unit-tests/kapi/stdlib.h

@@ -8,35 +8,35 @@
 #include_next <stdlib.h>
 
 static inline char *itoa(int value, char *str, int base) {
-  char *rc;
-  char *ptr;
-  char *low;
-  // Check for supported base.
-  if (base < 2 || base > 36) {
-    *str = '\0';
-    return str;
-  }
-  rc = ptr = str;
-  // Set '-' for negative decimals.
-  if (value < 0 && base == 10) {
-    *ptr++ = '-';
-  }
-  // Remember where the numbers start.
-  low = ptr;
-  // The actual conversion.
-  do {
-    // Modulo is negative for negative value. This trick makes abs() unnecessary.
-    *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz"[35 + value % base];
-    value /= base;
-  } while (value);
-  // Terminating the string.
-  *ptr-- = '\0';
-  // Invert the numbers.
-  while (low < ptr) {
-    char tmp = *low;
-    *low++   = *ptr;
-    *ptr--   = tmp;
-  }
-  return rc;
+    char *rc;
+    char *ptr;
+    char *low;
+    // Check for supported base.
+    if (base < 2 || base > 36) {
+        *str = '\0';
+        return str;
+    }
+    rc = ptr = str;
+    // Set '-' for negative decimals.
+    if (value < 0 && base == 10) {
+        *ptr++ = '-';
+    }
+    // Remember where the numbers start.
+    low = ptr;
+    // The actual conversion.
+    do {
+        // Modulo is negative for negative value. This trick makes abs() unnecessary.
+        *ptr++ = "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz"[35 + value % base];
+        value /= base;
+    } while (value);
+    // Terminating the string.
+    *ptr-- = '\0';
+    // Invert the numbers.
+    while (low < ptr) {
+        char tmp = *low;
+        *low++   = *ptr;
+        *ptr--   = tmp;
+    }
+    return rc;
 }
 #endif //STDLIB_H