another style change.

1 files changed, 112 insertions, 112 deletions

diff --git a/jrk.h b/jrk.h
index 9d00201..ba46305 100644
--- a/jrk.h
+++ b/jrk.h
@@ -41,7 +41,7 @@ typedef double f64;
 #define JRK_MAX(a, b) ((a) > (b) ? (a) : (b))
 
 #define jrk_return_defer(value) \
-    do { result = value; goto defer; } while(0)
+	do { result = value; goto defer; } while(0)
 
 #define JRK_KILOBYTES(x) ((u64)x*1024)
 #define JRK_MEGABYTES(x) ((u64)JRK_KILOBYTES((u64)x*1024))
@@ -103,66 +103,66 @@ char *jrk_tmpstrings_push(const char*);
 char *jrk_tmpstrings_pushf(const char*, ...);
 
 #ifndef jrk_die
-    #define jrk_die(x)                                                   \
-        do {                                                             \
-            fprintf(stderr, "%s:%d: error: "x" \n", __FILE__, __LINE__); \
-            exit(69);                                                    \
-        } while (0)
+	#define jrk_die(x) \
+		do { \
+			fprintf(stderr, "%s:%d: error: "x" \n", __FILE__, __LINE__); \
+			exit(69); \
+		} while (0)
 #endif
 
 #ifndef jrk_diev
-    #define jrk_diev(x, ...)                                                         \
-        do {                                                                         \
-            fprintf(stderr, "%s:%d: error: "x"\n", __FILE__, __LINE__, __VA_ARGS__); \
-            exit(69);                                                                \
-        } while (0)
+	#define jrk_diev(x, ...) \
+		do { \
+			fprintf(stderr, "%s:%d: error: "x"\n", __FILE__, __LINE__, __VA_ARGS__); \
+			exit(69); \
+		} while (0)
 #endif
 
 #define jrk_edie(x) jrk_diev(x": %s", strerror(errno))
 #define jrk_ediev(x, ...) jrk_diev(x": %s", __VA_ARGS__, strerror(errno))
 
 #ifndef jrk_log
-    #define jrk_log(x)                    \
-      do {                                \
-          fprintf(stderr, "info: "x"\n"); \
-      } while (0)
+	#define jrk_log(x) \
+	do { \
+		fprintf(stderr, "info: "x"\n"); \
+	} while (0)
 #endif
 
 #ifndef jrk_logv
-    #define jrk_logv(x, ...)                            \
-      do {                                              \
-          fprintf(stderr, "info: "x"\n",  __VA_ARGS__); \
-      } while (0)
+	#define jrk_logv(x, ...) \
+	do { \
+		fprintf(stderr, "info: "x"\n",  __VA_ARGS__); \
+	} while (0)
 #endif
 
 #ifndef jrk_elog
-    #define jrk_elog(x) jrk_log(x": %s", strerror(errno))
+	#define jrk_elog(x) jrk_log(x": %s", strerror(errno))
 #endif
 
 #ifndef jrk_elogv
-    #define jrk_elogv(x, ...) jrk_logv(x": %s", __VA_ARGS__, strerror(errno))
+	#define jrk_elogv(x, ...) jrk_logv(x": %s", __VA_ARGS__, strerror(errno))
 #endif
 
 #ifndef jrk_error
-    #define jrk_error(x)                   \
-      do {                                 \
-          fprintf(stderr, "error: "x"\n"); \
-      } while (0)
+	#define jrk_error(x) \
+	do { \
+		fprintf(stderr, "error: "x"\n"); \
+	} while (0)
 #endif
 
 #ifndef jrk_errorv
-    #define jrk_errorv(x, ...)                           \
-      do {                                               \
-          fprintf(stderr, "error: "x"\n",  __VA_ARGS__); \
-      } while (0)
+	#define jrk_errorv(x, ...) \
+	do { \
+		fprintf(stderr, "error: "x"\n",  __VA_ARGS__); \
+	} while (0)
 #endif
 
 #ifndef jrk_eerror
-    #define jrk_eerror(x) jrk_errorv(x": %s", strerror(errno))
+	#define jrk_eerror(x) jrk_errorv(x": %s", strerror(errno))
 #endif
 
 #ifndef jrk_eerrorv
-    #define jrk_eerrorv(x, ...) jrk_errorv(x": %s", __VA_ARGS__, strerror(errno))
+	#define jrk_eerrorv(x, ...) jrk_errorv(x": %s", __VA_ARGS__, strerror(errno))
 #endif
 
 #define jrk_assert(c, msg) do { if (!(c)) jrk_die("jrk_assert: "msg); } while(0)
@@ -176,15 +176,15 @@ char *jrk_tmpstrings_pushf(const char*, ...);
 #define JRK_ARRAY_DEFAULT_INIT_CAPACITY 16
 
 #ifndef JRK_ARRAY_DEFAULT_ALLOC_FN
-    #define JRK_ARRAY_DEFAULT_ALLOC_FN jrk_ecalloc
+	#define JRK_ARRAY_DEFAULT_ALLOC_FN jrk_ecalloc
 #endif
 
 #ifndef JRK_ARRAY_DEFAULT_REALLOC_FN
-    #define JRK_ARRAY_DEFAULT_REALLOC_FN jrk_erealloc
+	#define JRK_ARRAY_DEFAULT_REALLOC_FN jrk_erealloc
 #endif
 
 #ifndef JRK_ARRAY_DEFAULT_FREE_FN
-    #define JRK_ARRAY_DEFAULT_FREE_FN free
+	#define JRK_ARRAY_DEFAULT_FREE_FN free
 #endif
 
 typedef void *(*jrk_array_alloc_function_t) (u64, u64, void*);
@@ -193,82 +193,82 @@ typedef void *(*jrk_array_realloc_function_t) (void*, u64, u64, void*);
 #define __jrk_array_alloc(arr, count, len) (arr)->allocfn ? (arr)->allocfn((count), (len), (arr)->allocfn_user) : JRK_ARRAY_DEFAULT_ALLOC_FN((count), (len))
 #define __jrk_array_realloc(arr, _len) (arr)->reallocfn ? (arr)->reallocfn((arr)->items, (arr)->len * sizeof((arr)->items[0]), (_len), (arr)->allocfn_user) : JRK_ARRAY_DEFAULT_REALLOC_FN((arr)->items, (_len))
 
-#define jrk_array_prototype(type)                                                                                             \
-    typedef struct {                                                                                                          \
-        type *items;                                                                                                          \
-        u64 len;                                                                                                              \
-        u64 capacity;                                                                                                         \
-        jrk_array_alloc_function_t allocfn;                                                                                   \
-        jrk_array_realloc_function_t reallocfn;                                                                               \
-        void *allocfn_user;                                                                                                   \
-    } jrk_Array_##type;                                                                                                       \
-                                                                                                                              \
-    bool jrk_array_##type##_init_ex(jrk_Array_##type*, u64, jrk_array_alloc_function_t, jrk_array_realloc_function_t, void*); \
-    bool jrk_array_##type##_init(jrk_Array_##type*, u64);                                                                     \
-    void jrk_array_##type##_deinit(jrk_Array_##type*);                                                                        \
-    bool jrk_array_##type##_setcap(jrk_Array_##type*, u64);                                                                   \
-    bool jrk_array_##type##_push(jrk_Array_##type*, type);                                                                    \
-    bool jrk_array_##type##_pushn(jrk_Array_##type*, const type*, u64)
-
-#define jrk_array_impl(type)                                                                                                                                             \
-    bool jrk_array_##type##_init_ex(jrk_Array_##type *arr, u64 capacity, jrk_array_alloc_function_t allocfn, jrk_array_realloc_function_t reallocfn, void *allocfn_user) \
-    {                                                                                                                                                                    \
-        (arr)->allocfn = (allocfn) ? (allocfn) : NULL;                                                                                                                   \
-        (arr)->reallocfn = (reallocfn) ? (reallocfn) : NULL;                                                                                                             \
-        (arr)->allocfn_user = (allocfn_user) ? (allocfn_user) : NULL;                                                                                                    \
-        (arr)->len = 0;                                                                                                                                                 \
-        (arr)->capacity = (capacity);                                                                                                                                    \
-        (arr)->items = __jrk_array_alloc((arr), (arr)->capacity, sizeof(type));                                                                                          \
-        if (!(arr)->items) return false;                                                                                                                                 \
-        memset((arr)->items, 0, (arr)->capacity * sizeof(type));                                                                                                         \
-        return true;                                                                                                                                                     \
-    }                                                                                                                                                                    \
-                                                                                                                                                                         \
-    bool jrk_array_##type##_init(jrk_Array_##type *arr, u64 capacity)                                                                                                    \
-    {                                                                                                                                                                    \
-        return jrk_array_##type##_init_ex(arr, capacity, NULL, NULL, NULL);                                                                                              \
-    }                                                                                                                                                                    \
-                                                                                                                                                                         \
-    void jrk_array_##type##_deinit(jrk_Array_##type *arr)                                                                                                                \
-    {                                                                                                                                                                    \
-        if ((arr)->items && !(arr)->allocfn)                                                                                                                             \
-            JRK_ARRAY_DEFAULT_FREE_FN((arr)->items);                                                                                                                     \
-    }                                                                                                                                                                    \
-                                                                                                                                                                         \
-    bool jrk_array_##type##_setcap(jrk_Array_##type *arr, u64 new_capacity)                                                                                              \
-    {                                                                                                                                                                    \
-        if (new_capacity < (arr)->capacity) return false;                                                                                                                \
-        (arr)->items = __jrk_array_realloc((arr), new_capacity * sizeof(type));                                                                                          \
-        if (!(arr)->items) return false;                                                                                                                                 \
-        memset((arr)->items + (arr)->len, 0, (new_capacity * sizeof(type)) - ((arr)->capacity * sizeof(type)));                                                          \
-        (arr)->capacity = new_capacity;                                                                                                                                  \
-        return true;                                                                                                                                                     \
-    }                                                                                                                                                                    \
-                                                                                                                                                                         \
-    bool jrk_array_##type##_push(jrk_Array_##type *arr, type val)                                                                                                        \
-    {                                                                                                                                                                    \
-        if ((arr)->len+ 1 > (arr)->capacity) {                                                                                                                           \
-            while ((arr)->len + 1 > ((arr)->capacity))                                                                                                                   \
-                (arr)->capacity = (arr->capacity) ? (arr)->capacity * 2 : JRK_ARRAY_DEFAULT_INIT_CAPACITY;                                                               \
-            (arr)->items = __jrk_array_realloc((arr), (arr)->capacity * sizeof(type));                                                                                   \
-            if (!(arr)->items) return false;                                                                                                                             \
-        }                                                                                                                                                                \
-        (arr)->items[(arr)->len++] = (val);                                                                                                                              \
-        return true;                                                                                                                                                     \
-    }                                                                                                                                                                    \
-                                                                                                                                                                         \
-    bool jrk_array_##type##_pushn(jrk_Array_##type *arr, const type *vals, u64 count)                                                                                    \
-    {                                                                                                                                                                    \
-        if ((arr)->len+ count > (arr)->capacity) {                                                                                                                       \
-            while ((arr)->len+ count > ((arr)->capacity))                                                                                                                \
-                (arr)->capacity = (arr->capacity) ? (arr)->capacity * 2 : JRK_ARRAY_DEFAULT_INIT_CAPACITY;                                                               \
-            (arr)->items = __jrk_array_realloc((arr), (arr)->capacity * sizeof(type));                                                                                   \
-            if (!(arr)->items) return false;                                                                                                                             \
-            memset((arr)->items + (arr)->len, 0, count * sizeof(type));                                                                                                  \
-        }                                                                                                                                                                \
-        memcpy(&(arr)->items[(arr)->len], (vals), sizeof(type) * (count));                                                                                               \
-        (arr)->len+= count;                                                                                                                                              \
-        return true;                                                                                                                                                     \
+#define jrk_array_prototype(type) \
+	typedef struct { \
+		type *items; \
+		u64 len; \
+		u64 capacity; \
+		jrk_array_alloc_function_t allocfn; \
+		jrk_array_realloc_function_t reallocfn; \
+		void *allocfn_user; \
+	} jrk_Array_##type; \
+	\
+	bool jrk_array_##type##_init_ex(jrk_Array_##type*, u64, jrk_array_alloc_function_t, jrk_array_realloc_function_t, void*); \
+	bool jrk_array_##type##_init(jrk_Array_##type*, u64); \
+	void jrk_array_##type##_deinit(jrk_Array_##type*); \
+	bool jrk_array_##type##_setcap(jrk_Array_##type*, u64); \
+	bool jrk_array_##type##_push(jrk_Array_##type*, type); \
+	bool jrk_array_##type##_pushn(jrk_Array_##type*, const type*, u64)
+
+#define jrk_array_impl(type) \
+	bool jrk_array_##type##_init_ex(jrk_Array_##type *arr, u64 capacity, jrk_array_alloc_function_t allocfn, jrk_array_realloc_function_t reallocfn, void *allocfn_user) \
+	{ \
+		(arr)->allocfn = (allocfn) ? (allocfn) : NULL; \
+		(arr)->reallocfn = (reallocfn) ? (reallocfn) : NULL; \
+		(arr)->allocfn_user = (allocfn_user) ? (allocfn_user) : NULL; \
+		(arr)->len = 0; \
+		(arr)->capacity = (capacity); \
+		(arr)->items = __jrk_array_alloc((arr), (arr)->capacity, sizeof(type)); \
+		if (!(arr)->items) return false; \
+		memset((arr)->items, 0, (arr)->capacity * sizeof(type)); \
+		return true; \
+	} \
+	\
+	bool jrk_array_##type##_init(jrk_Array_##type *arr, u64 capacity) \
+	{ \
+		return jrk_array_##type##_init_ex(arr, capacity, NULL, NULL, NULL); \
+	} \
+	\
+	void jrk_array_##type##_deinit(jrk_Array_##type *arr) \
+	{ \
+		if ((arr)->items && !(arr)->allocfn) \
+			JRK_ARRAY_DEFAULT_FREE_FN((arr)->items); \
+	} \
+	\
+	bool jrk_array_##type##_setcap(jrk_Array_##type *arr, u64 new_capacity) \
+	{ \
+		if (new_capacity < (arr)->capacity) return false; \
+		(arr)->items = __jrk_array_realloc((arr), new_capacity * sizeof(type)); \
+		if (!(arr)->items) return false; \
+		memset((arr)->items + (arr)->len, 0, (new_capacity * sizeof(type)) - ((arr)->capacity * sizeof(type))); \
+		(arr)->capacity = new_capacity; \
+		return true; \
+	} \
+	\
+	bool jrk_array_##type##_push(jrk_Array_##type *arr, type val) \
+	{ \
+		if ((arr)->len+ 1 > (arr)->capacity) { \
+			while ((arr)->len + 1 > ((arr)->capacity)) \
+				(arr)->capacity = (arr->capacity) ? (arr)->capacity * 2 : JRK_ARRAY_DEFAULT_INIT_CAPACITY; \
+			(arr)->items = __jrk_array_realloc((arr), (arr)->capacity * sizeof(type)); \
+			if (!(arr)->items) return false; \
+		} \
+		(arr)->items[(arr)->len++] = (val); \
+		return true; \
+	} \
+	\
+	bool jrk_array_##type##_pushn(jrk_Array_##type *arr, const type *vals, u64 count) \
+	{ \
+		if ((arr)->len+ count > (arr)->capacity) { \
+			while ((arr)->len+ count > ((arr)->capacity)) \
+				(arr)->capacity = (arr->capacity) ? (arr)->capacity * 2 : JRK_ARRAY_DEFAULT_INIT_CAPACITY; \
+			(arr)->items = __jrk_array_realloc((arr), (arr)->capacity * sizeof(type)); \
+			if (!(arr)->items) return false; \
+			memset((arr)->items + (arr)->len, 0, count * sizeof(type)); \
+		} \
+		memcpy(&(arr)->items[(arr)->len], (vals), sizeof(type) * (count)); \
+		(arr)->len+= count; \
+		return true; \
     }
 
 #define jrk_array_foreach(type, it, arr) for (type *it = (arr)->items; it < (arr)->items + (arr)->len; ++it)
@@ -302,11 +302,11 @@ bool jrk_sb_read_entire_file(jrk_String_Builder*, const char*);
 u64 jrk_fnv1a_64(const u8*, u64);
 
 #ifndef JRK_HM_DEFAULT_ALLOC_FN
-    #define JRK_HM_DEFAULT_ALLOC_FN jrk_ecalloc
+	#define JRK_HM_DEFAULT_ALLOC_FN jrk_ecalloc
 #endif
 
 #ifndef JRK_HM_DEFAULT_FREE_FN
-    #define JRK_HM_DEFAULT_FREE_FN free
+	#define JRK_HM_DEFAULT_FREE_FN free
 #endif
 
 typedef jrk_array_alloc_function_t jrk_hm_alloc_function_t;