code format

4 files changed, 20 insertions, 14 deletions

diff --git a/examples/custom_mutators/custom_mutator_helpers.h b/examples/custom_mutators/custom_mutator_helpers.h
index e5ce3569..0848321f 100644
--- a/examples/custom_mutators/custom_mutator_helpers.h
+++ b/examples/custom_mutators/custom_mutator_helpers.h
@@ -277,12 +277,13 @@ static void surgical_havoc_mutate(u8 *out_buf, s32 begin, s32 end) {
 
 }
 
-
 /* This function calculates the next power of 2 greater or equal its argument.
  @return The rounded up power of 2 (if no overflow) or 0 on overflow.
 */
 static inline size_t next_pow2(size_t in) {
-  if (in == 0 || in > (size_t)-1) return 0; /* avoid undefined behaviour under-/overflow */
+
+  if (in == 0 || in > (size_t)-1)
+    return 0;                  /* avoid undefined behaviour under-/overflow */
   size_t out = in - 1;
   out |= out >> 1;
   out |= out >> 2;
@@ -290,6 +291,7 @@ static inline size_t next_pow2(size_t in) {
   out |= out >> 8;
   out |= out >> 16;
   return out + 1;
+
 }
 
 /* This function makes sure *size is > size_needed after call.
@@ -299,8 +301,7 @@ static inline size_t next_pow2(size_t in) {
  Will return NULL and free *buf if size_needed is <1 or realloc failed.
  @return For convenience, this function returns *buf.
  */
-static inline void *maybe_grow(void **buf, size_t *size,
-                                  size_t size_needed) {
+static inline void *maybe_grow(void **buf, size_t *size, size_t size_needed) {
 
   /* No need to realloc */
   if (likely(size_needed && *size >= size_needed)) return *buf;
@@ -312,9 +313,7 @@ static inline void *maybe_grow(void **buf, size_t *size,
   size_t next_size = next_pow2(size_needed);
 
   /* handle overflow */
-  if (!next_size) {
-    next_size = size_needed;
-  }
+  if (!next_size) { next_size = size_needed; }
 
   /* alloc */
   *buf = realloc(*buf, next_size);
diff --git a/examples/custom_mutators/example.c b/examples/custom_mutators/example.c
index 488ece81..a9764f5b 100644
--- a/examples/custom_mutators/example.c
+++ b/examples/custom_mutators/example.c
@@ -193,7 +193,8 @@ size_t afl_custom_pre_save(my_mutator_t *data, uint8_t *buf, size_t buf_size,
  * @return The amount of possible iteration steps to trim the input.
  *        negative on error.
  */
-int32_t afl_custom_init_trim(my_mutator_t *data, uint8_t *buf, size_t buf_size) {
+int32_t afl_custom_init_trim(my_mutator_t *data, uint8_t *buf,
+                             size_t buf_size) {
 
   // We simply trim once
   data->trimmming_steps = 1;
@@ -201,9 +202,12 @@ int32_t afl_custom_init_trim(my_mutator_t *data, uint8_t *buf, size_t buf_size)
   data->cur_step = 0;
 
   if (!maybe_grow(BUF_PARAMS(data, trim), buf_size)) {
+
     perror("init_trim grow");
     return -1;
+
   }
+
   memcpy(data->trim_buf, buf, buf_size);
 
   data->trim_size_current = buf_size;
diff --git a/include/alloc-inl.h b/include/alloc-inl.h
index 91564932..4211e398 100644
--- a/include/alloc-inl.h
+++ b/include/alloc-inl.h
@@ -771,7 +771,9 @@ static inline void TRK_ck_free(void *ptr, const char *file, const char *func,
  @return The rounded up power of 2 (if no overflow) or 0 on overflow.
 */
 static inline size_t next_pow2(size_t in) {
-  if (in == 0 || in > (size_t)-1) return 0; /* avoid undefined behaviour under-/overflow */
+
+  if (in == 0 || in > (size_t)-1)
+    return 0;                  /* avoid undefined behaviour under-/overflow */
   size_t out = in - 1;
   out |= out >> 1;
   out |= out >> 2;
@@ -779,6 +781,7 @@ static inline size_t next_pow2(size_t in) {
   out |= out >> 8;
   out |= out >> 16;
   return out + 1;
+
 }
 
 /* This function makes sure *size is > size_needed after call.
@@ -804,9 +807,7 @@ static inline void *ck_maybe_grow(void **buf, size_t *size,
   size_t next_size = next_pow2(size_needed);
 
   /* handle overflow */
-  if (!next_size) {
-    next_size = size_needed;
-  }
+  if (!next_size) { next_size = size_needed; }
 
   /* alloc */
   *buf = ck_realloc(*buf, next_size);
diff --git a/src/afl-fuzz-mutators.c b/src/afl-fuzz-mutators.c
index 90d7de40..754b2190 100644
--- a/src/afl-fuzz-mutators.c
+++ b/src/afl-fuzz-mutators.c
@@ -213,7 +213,8 @@ u8 trim_case_custom(afl_state_t *afl, struct queue_entry *q, u8 *in_buf) {
   afl->stage_cur = 0;
   afl->stage_max =
       afl->mutator->afl_custom_init_trim(afl->mutator->data, in_buf, q->len);
-  if (unlikely(afl->stage_max) < 0) FATAL("custom_init_trim error ret: %d", afl->stage_max);
+  if (unlikely(afl->stage_max) < 0)
+    FATAL("custom_init_trim error ret: %d", afl->stage_max);
   if (afl->not_on_tty && afl->debug)
     SAYF("[Custom Trimming] START: Max %d iterations, %u bytes", afl->stage_max,
          q->len);
@@ -273,7 +274,8 @@ u8 trim_case_custom(afl_state_t *afl, struct queue_entry *q, u8 *in_buf) {
       /* Tell the custom mutator that the trimming was unsuccessful */
       afl->stage_cur =
           afl->mutator->afl_custom_post_trim(afl->mutator->data, 0);
-      if (unlikely(afl->stage_cur < 0)) FATAL("Error ret in custom_post_trim: %d", afl->stage_cur);
+      if (unlikely(afl->stage_cur < 0))
+        FATAL("Error ret in custom_post_trim: %d", afl->stage_cur);
       if (afl->not_on_tty && afl->debug)
         SAYF("[Custom Trimming] FAILURE: %d/%d iterations", afl->stage_cur,
              afl->stage_max);