[=] correct codingstyle, [&] still some errors

Author: JulienMICHELgithub

.clang-format

@@ -0,0 +1,56 @@
+# Generated from CLion C/C++ Code Style settings
+---
+Language: Cpp
+BasedOnStyle: LLVM
+AccessModifierOffset: -4
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignOperands: false
+AlignTrailingComments: false
+AlwaysBreakTemplateDeclarations: Yes
+BraceWrapping: 
+  AfterCaseLabel: true
+  AfterClass: true
+  AfterControlStatement: true
+  AfterEnum: true
+  AfterFunction: true
+  AfterNamespace: true
+  AfterStruct: true
+  AfterUnion: true
+  AfterExternBlock: false
+  BeforeCatch: true
+  BeforeElse: true
+  BeforeLambdaBody: true
+  BeforeWhile: true
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBraces: Custom
+BreakConstructorInitializers: AfterColon
+BreakConstructorInitializersBeforeComma: false
+ColumnLimit: 120
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+IncludeCategories: 
+  - Regex: '^<.*'
+    Priority: 1
+  - Regex: '^".*'
+    Priority: 2
+  - Regex: '.*'
+    Priority: 3
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IndentCaseBlocks: true
+IndentWidth: 4
+InsertNewlineAtEOF: true
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: All
+PointerAlignment: Left
+SpaceInEmptyParentheses: false
+SpacesInAngles: false
+SpacesInConditionalStatement: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+TabWidth: 4
+UseTab: Always
+...

src/cvector_core.c

@@ -19,7 +19,6 @@ void *vector_init(size_t item_size, size_t capacity)
     header->size = 0;
     header->capacity = capacity;
     header->initial_capacity = capacity;
-
     return (header + 1);
 }
 
@@ -38,31 +37,30 @@ void *vector_ensure_capacity(void *v, size_t item_count, size_t item_size)
     new_capacity = header->capacity * 2;
     while (new_capacity < required_capacity)
         new_capacity *= 2;
-    header = realloc(header, sizeof(vector_header_t) + (new_capacity * item_size));
+    header = realloc(header,
+        sizeof(vector_header_t) + (new_capacity * item_size));
     if (!header)
         return NULL;
     header->capacity = new_capacity;
-
     return (header + 1);
 }
 
-int vector_push_back_impl(void **v, const void *val, size_t count, size_t item_size)
+int vector_push_back_impl(void **v, const void *val, size_t count,
+    size_t item_size)
 {
     vector_header_t *header;
     void *tmp;
 
     if (!v || !val || count == 0 || item_size == 0)
         return VECTOR_FAILURE;
-    if ((uintptr_t)val < 4096)
-        return VECTOR_FAILURE;
     tmp = vector_ensure_capacity(*v, count, item_size);
     if (!tmp)
         return VECTOR_FAILURE;
     *v = tmp;
     header = VECTOR_HEADER(*v);
-    memcpy((unsigned char*)(*v) + (header->size * item_size), val, count * item_size);
+    memcpy((unsigned char *)(*v) + (header->size * item_size), val,
+        count * item_size);
     header->size += count;
-
     return VECTOR_SUCCESS;
 }
 

src/cvector_insert_erase.c

@@ -2,13 +2,13 @@
 ** EPITECH PROJECT, 2024
 ** cvector
 ** File description:
-** Insert and erase functions for a C dynamic vector similar to std::vector in C++
+** add and del functions for a C dynamic vector similar to std::vector in C++
 */
 
 #include "cvector.h"
 
 int vector_insert_impl(void **v, const size_t index, const void *val,
-                  const size_t count, size_t item_size)
+    const size_t count, size_t item_size)
 {
     vector_header_t *header;
     void *tmp;
@@ -17,8 +17,6 @@ int vector_insert_impl(void **v, const size_t index, const void *val,
 
     if (!v || !val || count == 0 || item_size == 0)
         return VECTOR_FAILURE;
-    if ((uintptr_t)val < 4096)
-        return VECTOR_FAILURE;
     header = (*v) ? VECTOR_HEADER(*v) : NULL;
     old_size = header ? header->size : 0;
     required_size = ((index > old_size) ? index : old_size) + count;
@@ -33,34 +31,30 @@ int vector_insert_impl(void **v, const size_t index, const void *val,
     if (index < old_size)
         memmove((unsigned char *)(*v) + (index + count) * item_size,
             (unsigned char *)(*v) + index * item_size,
-            (old_size - index) * item_size);
+                (old_size - index) * item_size);
     memcpy((unsigned char *)(*v) + index * item_size, val, count * item_size);
     header->size = required_size;
     return VECTOR_SUCCESS;
 }
 
 void vector_erase_impl(void **v, const size_t index, size_t count,
-                  const size_t item_size)
+    const size_t item_size)
 {
     vector_header_t *header;
     //unsigned char *data;
     size_t old_size;
 
     if (!v || !*v || count == 0 || item_size == 0)
         return;
-
     header = VECTOR_HEADER(*v);
     if (index >= header->size)
         return;
     if (index + count > header->size)
         count = header->size - index;
-
     //data = (unsigned char *)*v;
     old_size = header->size;
-
     memmove((unsigned char *)*v + index * item_size,
-            (unsigned char *)*v + (index + count) * item_size,
+        (unsigned char *)*v + (index + count) * item_size,
             (old_size - index - count) * item_size);
-
     header->size = old_size - count;
 }

src/cvector_resize.c

@@ -7,96 +7,90 @@
 
 #include "cvector.h"
 
-int vector_reserve_impl(void **v, const size_t n,
-                               const size_t item_size)
+int vector_reserve_impl(void **v, const size_t n, const size_t item_size)
 {
-  vector_header_t *header;
-  vector_header_t *new_header;
+    vector_header_t *header;
+    vector_header_t *new_header;
 
-  if (!v || n == 0 || item_size == 0)
-    return VECTOR_FAILURE;
-  if (!*v) {
-    *v = vector_init(item_size, n);
-    return *v ? VECTOR_SUCCESS : VECTOR_FAILURE;
-  }
-  header = VECTOR_HEADER(*v);
-  if (n <= header->capacity)
+    if (!v || n == 0 || item_size == 0)
+        return VECTOR_FAILURE;
+    if (!*v) {
+        *v = vector_init(item_size, n);
+        return *v ? VECTOR_SUCCESS : VECTOR_FAILURE;
+    }
+    header = VECTOR_HEADER(*v);
+    if (n <= header->capacity)
+        return VECTOR_SUCCESS;
+    new_header = realloc(header, sizeof(vector_header_t) + (n * item_size));
+    #warning "TODO: memset new memory"
+    if (!new_header)
+        return VECTOR_FAILURE;
+    new_header->capacity = n;
+    *v = (new_header + 1);
     return VECTOR_SUCCESS;
-  new_header = realloc(header, sizeof(vector_header_t) + (n * item_size));
-  #warning "TODO: memset new memory"
-  if (!new_header)
-    return VECTOR_FAILURE;
-  new_header->capacity = n;
-  *v = (new_header + 1);
-
-  return VECTOR_SUCCESS;
 }
 
 static inline void *vector_init_zeroed(size_t item_size, size_t capacity)
 {
-  vector_header_t *header;
+    vector_header_t *header;
 
-  if (item_size == 0 || capacity == 0)
-    return NULL;
-  header = calloc(1, sizeof(vector_header_t) + item_size * capacity);
-  if (!header)
-    return NULL;
-  header->size = capacity;
-  header->capacity = capacity;
-  header->initial_capacity = capacity;
+    if (item_size == 0 || capacity == 0)
+        return NULL;
+    header = calloc(1, sizeof(vector_header_t) + item_size * capacity);
+    if (!header)
+        return NULL;
+    header->size = capacity;
+    header->capacity = capacity;
+    header->initial_capacity = capacity;
 
-  return (header + 1);
+    return (header + 1);
 }
 
 int vector_resize_impl(void **v, const size_t new_size,
-                              const size_t item_size)
+    const size_t item_size)
 {
-  vector_header_t *header;
-  void *tmp;
-  size_t old_size;
+    vector_header_t *header;
+    void *tmp;
+    size_t old_size;
 
-  if (!v || item_size == 0)
-    return VECTOR_FAILURE;
-  if (!*v) {
-    *v = vector_init_zeroed(item_size, new_size);
-    return (*v) ? VECTOR_SUCCESS : VECTOR_FAILURE;
-  }
-  header = VECTOR_HEADER(*v);
-  old_size = header->size;
-  if (new_size < old_size) {
+    if (!v || item_size == 0)
+        return VECTOR_FAILURE;
+    if (!*v) {
+        *v = vector_init_zeroed(item_size, new_size);
+        return (*v) ? VECTOR_SUCCESS : VECTOR_FAILURE;
+    }
+    header = VECTOR_HEADER(*v);
+    old_size = header->size;
+    if (new_size < old_size) {
+        header->size = new_size;
+        return VECTOR_SUCCESS;
+    }
+    if (new_size == old_size)
+        return VECTOR_SUCCESS;
+    tmp = vector_ensure_capacity(*v, new_size - old_size, item_size);
+    if (!tmp)
+        return VECTOR_FAILURE;
+    *v = tmp;
+    header = VECTOR_HEADER(*v);
+    memset((unsigned char *)(*v) + (old_size * item_size), 0, (new_size - old_size) * item_size);
     header->size = new_size;
     return VECTOR_SUCCESS;
-  }
-  if (new_size == old_size)
-    return VECTOR_SUCCESS;
-  tmp = vector_ensure_capacity(*v, new_size - old_size, item_size);
-  if (!tmp)
-    return VECTOR_FAILURE;
-  *v = tmp;
-  header = VECTOR_HEADER(*v);
-  memset((unsigned char *)(*v) + (old_size * item_size), 0, (new_size - old_size) * item_size);
-  header->size = new_size;
-
-  return VECTOR_SUCCESS;
 }
 
 int vector_shrink_to_fit_impl(void **v, const size_t item_size)
 {
-  vector_header_t *header;
-  vector_header_t *new_header;
+    vector_header_t *header;
+    vector_header_t *new_header;
 
-  if (!v || !*v || item_size == 0)
-    return VECTOR_FAILURE;
-
-  header = VECTOR_HEADER(*v);
-  if (header->capacity == header->size)
+    if (!v || !*v || item_size == 0)
+        return VECTOR_FAILURE;
+    header = VECTOR_HEADER(*v);
+    if (header->capacity == header->size)
+        return VECTOR_SUCCESS;
+    new_header = realloc(header, sizeof(vector_header_t) + (header->size * item_size));
+    if (!new_header)
+        return VECTOR_FAILURE;
+    new_header->capacity = new_header->size;
+    *v = (new_header + 1);
     return VECTOR_SUCCESS;
-
-  new_header = realloc(header, sizeof(vector_header_t) + (header->size * item_size));
-  if (!new_header)
-    return VECTOR_FAILURE;
-
-  new_header->capacity = new_header->size;
-  *v = (new_header + 1);
-  return VECTOR_SUCCESS;
 }