fixed inline functions

rmutil/vector.c

@@ -2,80 +2,85 @@
 #include <stdio.h>
 
 inline int __vector_PushPtr(Vector *v, void *elem) {
-    if (v->top == v->cap) {
+  if (v->top == v->cap) {
-        Vector_Resize(v, v->cap ? v->cap * 2 : 1);
+    Vector_Resize(v, v->cap ? v->cap * 2 : 1);
-    }
+  }
 
-    __vector_PutPtr(v, v->top++, elem);
+  __vector_PutPtr(v, v->top++, elem);
-    return v->top;
+  return v->top;
 }
 
 inline int Vector_Get(Vector *v, size_t pos, void *ptr) {
-    // return 0 if pos is out of bounds
+  // return 0 if pos is out of bounds
-    if (pos >= v->top) {
+  if (pos >= v->top) {
-        return 0;
+    return 0;
-    }
+  }
 
-    memcpy(ptr, v->data + (pos * v->elemSize), v->elemSize);
+  memcpy(ptr, v->data + (pos * v->elemSize), v->elemSize);
-    return 1;
+  return 1;
 }
 
 /* Get the element at the end of the vector, decreasing the size by one */
 inline int Vector_Pop(Vector *v, void *ptr) {
-    if (v->top > 0) {
+  if (v->top > 0) {
-        if (ptr != NULL) {
+    if (ptr != NULL) {
-            Vector_Get(v, v->top - 1, ptr);
+      Vector_Get(v, v->top - 1, ptr);
-        }
-        v->top--;
-        return 1;
     }
-    return 0;
+    v->top--;
+    return 1;
+  }
+  return 0;
 }
 
 inline int __vector_PutPtr(Vector *v, size_t pos, void *elem) {
-    // resize if pos is out of bounds
+  // resize if pos is out of bounds
-    if (pos >= v->cap) {
+  if (pos >= v->cap) {
-        Vector_Resize(v, pos + 1);
+    Vector_Resize(v, pos + 1);
-    }
+  }
 
-    if (elem) {
+  if (elem) {
-        memcpy(v->data + pos * v->elemSize, elem, v->elemSize);
+    memcpy(v->data + pos * v->elemSize, elem, v->elemSize);
-    } else {
+  } else {
-        memset(v->data + pos * v->elemSize, 0, v->elemSize);
+    memset(v->data + pos * v->elemSize, 0, v->elemSize);
-    }
+  }
-    // move the end offset to pos if we grew
+  // move the end offset to pos if we grew
-    if (pos > v->top) {
+  if (pos > v->top) {
-        v->top = pos;
+    v->top = pos;
-    }
+  }
-    return 1;
+  return 1;
 }
 
 int Vector_Resize(Vector *v, size_t newcap) {
-    int oldcap = v->cap;
+  int oldcap = v->cap;
-    v->cap = newcap;
+  v->cap = newcap;
 
-    v->data = realloc(v->data, v->cap * v->elemSize);
+  v->data = realloc(v->data, v->cap * v->elemSize);
 
-    // If we grew:
+  // If we grew:
-    // put all zeros at the newly realloc'd part of the vector
+  // put all zeros at the newly realloc'd part of the vector
-    if (newcap > oldcap) {
+  if (newcap > oldcap) {
-        int offset = oldcap * v->elemSize;
+    int offset = oldcap * v->elemSize;
-        memset(v->data + offset, 0, v->cap * v->elemSize - offset);
+    memset(v->data + offset, 0, v->cap * v->elemSize - offset);
-    }
+  }
-    return v->cap;
+  return v->cap;
 }
 
 Vector *__newVectorSize(size_t elemSize, size_t cap) {
-    Vector *vec = malloc(sizeof(Vector));
+  Vector *vec = malloc(sizeof(Vector));
-    vec->data = calloc(cap, elemSize);
+  vec->data = calloc(cap, elemSize);
-    vec->top = 0;
+  vec->top = 0;
-    vec->elemSize = elemSize;
+  vec->elemSize = elemSize;
-    vec->cap = cap;
+  vec->cap = cap;
 
-    return vec;
+  return vec;
 }
 
 void Vector_Free(Vector *v) {
-    free(v->data);
+  free(v->data);
-    free(v);
+  free(v);
 }
+
+inline int Vector_Size(Vector *v) { return v->top; }
+
+/* return the actual capacity */
+inline int Vector_Cap(Vector *v) { return v->cap; }

rmutil/vector.h

@@ -10,10 +10,10 @@
 * Works like C++ std::vector with an underlying resizable buffer
 */
 typedef struct {
-    char *data;
+  char *data;
-    size_t elemSize;
+  size_t elemSize;
-    size_t cap;
+  size_t cap;
-    size_t top;
+  size_t top;
 
 } Vector;
 
@@ -47,11 +47,13 @@ int Vector_Pop(Vector *v, void *ptr);
 * Put an element at pos.
 * Note: If pos is outside the vector capacity, we resize it accordingly
 */
-#define Vector_Put(v, pos, elem) __vector_PutPtr(v, pos, elem ? &(typeof(elem)){elem} : NULL)
+#define Vector_Put(v, pos, elem)                                               \
+  __vector_PutPtr(v, pos, elem ? &(typeof(elem)){elem} : NULL)
 
 /* Push an element at the end of v, resizing it if needed. This macro wraps
  * __vector_PushPtr */
-#define Vector_Push(v, elem) __vector_PushPtr(v, elem ? &(typeof(elem)){elem} : NULL)
+#define Vector_Push(v, elem)                                                   \
+  __vector_PushPtr(v, elem ? &(typeof(elem)){elem} : NULL)
 
 int __vector_PushPtr(Vector *v, void *elem);
 
@@ -59,10 +61,10 @@ int __vector_PushPtr(Vector *v, void *elem);
 int Vector_Resize(Vector *v, size_t newcap);
 
 /* return the used size of the vector, regardless of capacity */
-inline int Vector_Size(Vector *v) { return v->top; }
+int Vector_Size(Vector *v);
 
 /* return the actual capacity */
-inline int Vector_Cap(Vector *v) { return v->cap; }
+int Vector_Cap(Vector *v);
 
 /* free the vector and the underlying data. Does not release its elements if
  * they are pointers*/