deps(flag.h): update

1 files changed, 235 insertions, 239 deletions

diff --git a/include/viv/flag.h b/include/viv/flag.h
index cdd7c16..d21ff96 100644
--- a/include/viv/flag.h
+++ b/include/viv/flag.h
@@ -43,37 +43,37 @@ void flag_print_options(FILE *stream);
 #ifdef FLAG_IMPLEMENTATION
 
 typedef enum {
-    FLAG_BOOL = 0,
-    FLAG_UINT64,
-    FLAG_SIZE,
-    FLAG_STR,
-    COUNT_FLAG_TYPES,
+  FLAG_BOOL = 0,
+  FLAG_UINT64,
+  FLAG_SIZE,
+  FLAG_STR,
+  COUNT_FLAG_TYPES,
 } Flag_Type;
 
 static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive Flag_Value definition");
 typedef union {
-    char *as_str;
-    uint64_t as_uint64;
-    bool as_bool;
-    size_t as_size;
+  char *as_str;
+  uint64_t as_uint64;
+  bool as_bool;
+  size_t as_size;
 } Flag_Value;
 
 typedef enum {
-    FLAG_NO_ERROR = 0,
-    FLAG_ERROR_UNKNOWN,
-    FLAG_ERROR_NO_VALUE,
-    FLAG_ERROR_INVALID_NUMBER,
-    FLAG_ERROR_INTEGER_OVERFLOW,
-    FLAG_ERROR_INVALID_SIZE_SUFFIX,
-    COUNT_FLAG_ERRORS,
+  FLAG_NO_ERROR = 0,
+  FLAG_ERROR_UNKNOWN,
+  FLAG_ERROR_NO_VALUE,
+  FLAG_ERROR_INVALID_NUMBER,
+  FLAG_ERROR_INTEGER_OVERFLOW,
+  FLAG_ERROR_INVALID_SIZE_SUFFIX,
+  COUNT_FLAG_ERRORS,
 } Flag_Error;
 
 typedef struct {
-    Flag_Type type;
-    char *name;
-    char *desc;
-    Flag_Value val;
-    Flag_Value def;
+  Flag_Type type;
+  char *name;
+  char *desc;
+  Flag_Value val;
+  Flag_Value def;
 } Flag;
 
 #ifndef FLAGS_CAP
@@ -81,298 +81,294 @@ typedef struct {
 #endif
 
 typedef struct {
-    Flag flags[FLAGS_CAP];
-    size_t flags_count;
+  Flag flags[FLAGS_CAP];
+  size_t flags_count;
 
-    Flag_Error flag_error;
-    char *flag_error_name;
+  Flag_Error flag_error;
+  char *flag_error_name;
 
-    int rest_argc;
-    char **rest_argv;
+  int rest_argc;
+  char **rest_argv;
 } Flag_Context;
 
 static Flag_Context flag_global_context;
 
 Flag *flag_new(Flag_Type type, const char *name, const char *desc)
 {
-    Flag_Context *c = &flag_global_context;
-
-    assert(c->flags_count < FLAGS_CAP);
-    Flag *flag = &c->flags[c->flags_count++];
-    memset(flag, 0, sizeof(*flag));
-    flag->type = type;
-    // NOTE: I won't touch them I promise Kappa
-    flag->name = (char*) name;
-    flag->desc = (char*) desc;
-    return flag;
+  Flag_Context *c = &flag_global_context;
+
+  assert(c->flags_count < FLAGS_CAP);
+  Flag *flag = &c->flags[c->flags_count++];
+  memset(flag, 0, sizeof(*flag));
+  flag->type = type;
+  // NOTE: I won't touch them I promise Kappa
+  flag->name = (char*) name;
+  flag->desc = (char*) desc;
+  return flag;
 }
 
 char *flag_name(void *val)
 {
-    Flag *flag = (Flag*) ((char*) val - offsetof(Flag, val));
-    return flag->name;
+  Flag *flag = (Flag*) ((char*) val - offsetof(Flag, val));
+  return flag->name;
 }
 
 bool *flag_bool(const char *name, bool def, const char *desc)
 {
-    Flag *flag = flag_new(FLAG_BOOL, name, desc);
-    flag->def.as_bool = def;
-    flag->val.as_bool = def;
-    return &flag->val.as_bool;
+  Flag *flag = flag_new(FLAG_BOOL, name, desc);
+  flag->def.as_bool = def;
+  flag->val.as_bool = def;
+  return &flag->val.as_bool;
 }
 
 uint64_t *flag_uint64(const char *name, uint64_t def, const char *desc)
 {
-    Flag *flag = flag_new(FLAG_UINT64, name, desc);
-    flag->val.as_uint64 = def;
-    flag->def.as_uint64 = def;
-    return &flag->val.as_uint64;
+  Flag *flag = flag_new(FLAG_UINT64, name, desc);
+  flag->val.as_uint64 = def;
+  flag->def.as_uint64 = def;
+  return &flag->val.as_uint64;
 }
 
 size_t *flag_size(const char *name, uint64_t def, const char *desc)
 {
-    Flag *flag = flag_new(FLAG_SIZE, name, desc);
-    flag->val.as_size = def;
-    flag->def.as_size = def;
-    return &flag->val.as_size;
+  Flag *flag = flag_new(FLAG_SIZE, name, desc);
+  flag->val.as_size = def;
+  flag->def.as_size = def;
+  return &flag->val.as_size;
 }
 
 char **flag_str(const char *name, const char *def, const char *desc)
 {
-    Flag *flag = flag_new(FLAG_STR, name, desc);
-    flag->val.as_str = (char*) def;
-    flag->def.as_str = (char*) def;
-    return &flag->val.as_str;
+  Flag *flag = flag_new(FLAG_STR, name, desc);
+  flag->val.as_str = (char*) def;
+  flag->def.as_str = (char*) def;
+  return &flag->val.as_str;
 }
 
 static char *flag_shift_args(int *argc, char ***argv)
 {
-    assert(*argc > 0);
-    char *result = **argv;
-    *argv += 1;
-    *argc -= 1;
-    return result;
+  assert(*argc > 0);
+  char *result = **argv;
+  *argv += 1;
+  *argc -= 1;
+  return result;
 }
 
 int flag_rest_argc(void)
 {
-    return flag_global_context.rest_argc;
+  return flag_global_context.rest_argc;
 }
 
 char **flag_rest_argv(void)
 {
-    return flag_global_context.rest_argv;
+  return flag_global_context.rest_argv;
 }
 
 bool flag_parse(int argc, char **argv)
 {
-    Flag_Context *c = &flag_global_context;
+  Flag_Context *c = &flag_global_context;
 
-    flag_shift_args(&argc, &argv);
+  flag_shift_args(&argc, &argv);
 
-    while (argc > 0) {
-        char *flag = flag_shift_args(&argc, &argv);
+  while (argc > 0) {
+    char *flag = flag_shift_args(&argc, &argv);
 
-        if (*flag != '-') {
-            // NOTE: pushing flag back into args
-            c->rest_argc = argc + 1;
-            c->rest_argv = argv - 1;
-            return true;
-        }
-
-        if (strcmp(flag, "--") == 0) {
-            // NOTE: but if it's the terminator we don't need to push it back
-            c->rest_argc = argc;
-            c->rest_argv = argv;
-            return true;
-        }
-
-        // NOTE: remove the dash
-        flag += 1;
-
-        bool found = false;
-        for (size_t i = 0; i < c->flags_count; ++i) {
-            if (strcmp(c->flags[i].name, flag) == 0) {
-                static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive flag type parsing");
-                switch (c->flags[i].type) {
-                case FLAG_BOOL: {
-                    c->flags[i].val.as_bool = true;
-                }
-                break;
-
-                case FLAG_STR: {
-                    if (argc == 0) {
-                        c->flag_error = FLAG_ERROR_NO_VALUE;
-                        c->flag_error_name = flag;
-                        return false;
-                    }
-                    char *arg = flag_shift_args(&argc, &argv);
-                    c->flags[i].val.as_str = arg;
-                }
-                break;
-
-                case FLAG_UINT64: {
-                    if (argc == 0) {
-                        c->flag_error = FLAG_ERROR_NO_VALUE;
-                        c->flag_error_name = flag;
-                        return false;
-                    }
-                    char *arg = flag_shift_args(&argc, &argv);
-
-                    static_assert(sizeof(unsigned long long int) == sizeof(uint64_t), "The original author designed this for x86_64 machine with the compiler that expects unsigned long long int and uint64_t to be the same thing, so they could use strtoull() function to parse it. Please adjust this code for your case and maybe even send the patch to upstream to make it work on a wider range of environments.");
-                    char *endptr;
-                    // TODO: replace strtoull with a custom solution
-                    // That way we can get rid of the dependency on errno and static_assert
-                    unsigned long long int result = strtoull(arg, &endptr, 10);
-
-                    if (*endptr != '\0') {
-                        c->flag_error = FLAG_ERROR_INVALID_NUMBER;
-                        c->flag_error_name = flag;
-                        return false;
-                    }
-
-                    if (result == ULLONG_MAX && errno == ERANGE) {
-                        c->flag_error = FLAG_ERROR_INTEGER_OVERFLOW;
-                        c->flag_error_name = flag;
-                        return false;
-                    }
-
-                    c->flags[i].val.as_uint64 = result;
-                }
-                break;
-
-                case FLAG_SIZE: {
-                    if (argc == 0) {
-                        c->flag_error = FLAG_ERROR_NO_VALUE;
-                        c->flag_error_name = flag;
-                        return false;
-                    }
-                    char *arg = flag_shift_args(&argc, &argv);
-
-                    static_assert(sizeof(unsigned long long int) == sizeof(size_t), "The original author designed this for x86_64 machine with the compiler that expects unsigned long long int and size_t to be the same thing, so they could use strtoull() function to parse it. Please adjust this code for your case and maybe even send the patch to upstream to make it work on a wider range of environments.");
-                    char *endptr;
-                    // TODO: replace strtoull with a custom solution
-                    // That way we can get rid of the dependency on errno and static_assert
-                    unsigned long long int result = strtoull(arg, &endptr, 10);
-
-                    // TODO: handle more multiplicative suffixes like in dd(1). From the dd(1) man page:
-                    // > N and BYTES may be followed by the following
-                    // > multiplicative suffixes: c =1, w =2, b =512, kB =1000, K
-                    // > =1024, MB =1000*1000, M =1024*1024, xM =M, GB
-                    // > =1000*1000*1000, G =1024*1024*1024, and so on for T, P,
-                    // > E, Z, Y.
-                    if (strcmp(endptr, "K") == 0) {
-                        result *= 1024;
-                    } else if (strcmp(endptr, "M") == 0) {
-                        result *= 1024*1024;
-                    } else if (strcmp(endptr, "G") == 0) {
-                        result *= 1024*1024*1024;
-                    } else if (strcmp(endptr, "") != 0) {
-                        c->flag_error = FLAG_ERROR_INVALID_SIZE_SUFFIX;
-                        c->flag_error_name = flag;
-                        // TODO: capability to report what exactly is the wrong suffix
-                        return false;
-                    }
-
-                    if (result == ULLONG_MAX && errno == ERANGE) {
-                        c->flag_error = FLAG_ERROR_INTEGER_OVERFLOW;
-                        c->flag_error_name = flag;
-                        return false;
-                    }
-
-                    c->flags[i].val.as_size = result;
-                }
-                break;
-
-                case COUNT_FLAG_TYPES:
-                default: {
-                    assert(0 && "unreachable");
-                    exit(69);
-                }
-                }
-
-                found = true;
-            }
-        }
+    if (*flag != '-') {
+      // NOTE: pushing flag back into args
+      c->rest_argc = argc + 1;
+      c->rest_argv = argv - 1;
+      return true;
+    }
 
-        if (!found) {
-            c->flag_error = FLAG_ERROR_UNKNOWN;
-            c->flag_error_name = flag;
-            return false;
-        }
+    if (strcmp(flag, "--") == 0) {
+      // NOTE: but if it's the terminator we don't need to push it back
+      c->rest_argc = argc;
+      c->rest_argv = argv;
+      return true;
     }
 
-    c->rest_argc = argc;
-    c->rest_argv = argv;
-    return true;
-}
+    // NOTE: remove the dash
+    flag += 1;
 
-void flag_print_options(FILE *stream)
-{
-    Flag_Context *c = &flag_global_context;
+    bool found = false;
     for (size_t i = 0; i < c->flags_count; ++i) {
-        Flag *flag = &c->flags[i];
-
-        fprintf(stream, "    -%s\n", flag->name);
-        fprintf(stream, "        %s\n", flag->desc);
-        static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive flag type defaults printing");
+      if (strcmp(c->flags[i].name, flag) == 0) {
+        static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive flag type parsing");
         switch (c->flags[i].type) {
-        case FLAG_BOOL:
-            if (flag->def.as_bool) {
-                fprintf(stream, "        default: %s\n", flag->def.as_bool ? "true" : "false");
-            }
+          case FLAG_BOOL: {
+            c->flags[i].val.as_bool = true;
+          }
             break;
-        case FLAG_UINT64:
-            fprintf(stream, "        default: %" PRIu64 "\n", flag->def.as_uint64);
+
+          case FLAG_STR: {
+            if (argc == 0) {
+              c->flag_error = FLAG_ERROR_NO_VALUE;
+              c->flag_error_name = flag;
+              return false;
+            }
+            char *arg = flag_shift_args(&argc, &argv);
+            c->flags[i].val.as_str = arg;
+          }
             break;
-        case FLAG_SIZE:
-            fprintf(stream, "        default: %zu\n", flag->def.as_size);
+
+          case FLAG_UINT64: {
+            if (argc == 0) {
+              c->flag_error = FLAG_ERROR_NO_VALUE;
+              c->flag_error_name = flag;
+              return false;
+            }
+            char *arg = flag_shift_args(&argc, &argv);
+
+            static_assert(sizeof(unsigned long long int) == sizeof(uint64_t), "The original author designed this for x86_64 machine with the compiler that expects unsigned long long int and uint64_t to be the same thing, so they could use strtoull() function to parse it. Please adjust this code for your case and maybe even send the patch to upstream to make it work on a wider range of environments.");
+            char *endptr;
+            // TODO: replace strtoull with a custom solution
+            // That way we can get rid of the dependency on errno and static_assert
+            unsigned long long int result = strtoull(arg, &endptr, 10);
+
+            if (*endptr != '\0') {
+              c->flag_error = FLAG_ERROR_INVALID_NUMBER;
+              c->flag_error_name = flag;
+              return false;
+            }
+
+            if (result == ULLONG_MAX && errno == ERANGE) {
+              c->flag_error = FLAG_ERROR_INTEGER_OVERFLOW;
+              c->flag_error_name = flag;
+              return false;
+            }
+
+            c->flags[i].val.as_uint64 = result;
+          }
             break;
-        case FLAG_STR:
-            if (flag->def.as_str) {
-                fprintf(stream, "        default: %s\n", flag->def.as_str);
+
+          case FLAG_SIZE: {
+            if (argc == 0) {
+              c->flag_error = FLAG_ERROR_NO_VALUE;
+              c->flag_error_name = flag;
+              return false;
+            }
+            char *arg = flag_shift_args(&argc, &argv);
+
+            static_assert(sizeof(unsigned long long int) == sizeof(size_t), "The original author designed this for x86_64 machine with the compiler that expects unsigned long long int and size_t to be the same thing, so they could use strtoull() function to parse it. Please adjust this code for your case and maybe even send the patch to upstream to make it work on a wider range of environments.");
+            char *endptr;
+            // TODO: replace strtoull with a custom solution
+            // That way we can get rid of the dependency on errno and static_assert
+            unsigned long long int result = strtoull(arg, &endptr, 10);
+
+            // TODO: handle more multiplicative suffixes like in dd(1). From the dd(1) man page:
+            // > N and BYTES may be followed by the following
+            // > multiplicative suffixes: c =1, w =2, b =512, kB =1000, K
+            // > =1024, MB =1000*1000, M =1024*1024, xM =M, GB
+            // > =1000*1000*1000, G =1024*1024*1024, and so on for T, P,
+            // > E, Z, Y.
+            if (strcmp(endptr, "K") == 0) {
+              result *= 1024;
+            } else if (strcmp(endptr, "M") == 0) {
+              result *= 1024*1024;
+            } else if (strcmp(endptr, "G") == 0) {
+              result *= 1024*1024*1024;
+            } else if (strcmp(endptr, "") != 0) {
+              c->flag_error = FLAG_ERROR_INVALID_SIZE_SUFFIX;
+              c->flag_error_name = flag;
+              // TODO: capability to report what exactly is the wrong suffix
+              return false;
+            }
+
+            if (result == ULLONG_MAX && errno == ERANGE) {
+              c->flag_error = FLAG_ERROR_INTEGER_OVERFLOW;
+              c->flag_error_name = flag;
+              return false;
             }
+
+            c->flags[i].val.as_size = result;
+          }
             break;
-        default:
+
+          case COUNT_FLAG_TYPES:
+          default: {
             assert(0 && "unreachable");
             exit(69);
+          }
         }
+
+        found = true;
+      }
+    }
+
+    if (!found) {
+      c->flag_error = FLAG_ERROR_UNKNOWN;
+      c->flag_error_name = flag;
+      return false;
+    }
+  }
+
+  c->rest_argc = argc;
+  c->rest_argv = argv;
+  return true;
+}
+
+void flag_print_options(FILE *stream)
+{
+  Flag_Context *c = &flag_global_context;
+  for (size_t i = 0; i < c->flags_count; ++i) {
+    Flag *flag = &c->flags[i];
+
+    fprintf(stream, "    -%s\n", flag->name);
+    fprintf(stream, "        %s\n", flag->desc);
+    static_assert(COUNT_FLAG_TYPES == 4, "Exhaustive flag type defaults printing");
+    switch (c->flags[i].type) {
+      case FLAG_BOOL:
+        if (flag->def.as_bool) {
+          fprintf(stream, "        Default: %s\n", flag->def.as_bool ? "true" : "false");
+        }
+        break;
+      case FLAG_UINT64:
+        fprintf(stream, "        Default: %" PRIu64 "\n", flag->def.as_uint64);
+        break;
+      case FLAG_SIZE:
+        fprintf(stream, "        Default: %zu\n", flag->def.as_size);
+        break;
+      case FLAG_STR:
+        if (flag->def.as_str) {
+          fprintf(stream, "        Default: %s\n", flag->def.as_str);
+        }
+        break;
+      default:
+        assert(0 && "unreachable");
+        exit(69);
     }
+  }
 }
 
 void flag_print_error(FILE *stream)
 {
-    Flag_Context *c = &flag_global_context;
-    static_assert(COUNT_FLAG_ERRORS == 6, "Exhaustive flag error printing");
-    switch (c->flag_error) {
+  Flag_Context *c = &flag_global_context;
+  static_assert(COUNT_FLAG_ERRORS == 6, "Exhaustive flag error printing");
+  switch (c->flag_error) {
     case FLAG_NO_ERROR:
-        // NOTE: don't call flag_print_error() if flag_parse() didn't return false, okay? ._.
-        fprintf(
-          stream,
-          "operation failed successfully! please tell the developer of this software that "
-          "they don't know what they are doing!"
-        );
-        break;
+      // NOTE: don't call flag_print_error() if flag_parse() didn't return false, okay? ._.
+      fprintf(stream, "Operation Failed Successfully! Please tell the developer of this software that they don't know what they are doing! :)");
+      break;
     case FLAG_ERROR_UNKNOWN:
-        fprintf(stream, "error: -%s: unknown flag\n", c->flag_error_name);
-        break;
+      fprintf(stream, "ERROR: -%s: unknown flag\n", c->flag_error_name);
+      break;
     case FLAG_ERROR_NO_VALUE:
-        fprintf(stream, "error: -%s: no value provided\n", c->flag_error_name);
-        break;
+      fprintf(stream, "ERROR: -%s: no value provided\n", c->flag_error_name);
+      break;
     case FLAG_ERROR_INVALID_NUMBER:
-        fprintf(stream, "error: -%s: invalid number\n", c->flag_error_name);
-        break;
+      fprintf(stream, "ERROR: -%s: invalid number\n", c->flag_error_name);
+      break;
     case FLAG_ERROR_INTEGER_OVERFLOW:
-        fprintf(stream, "error: -%s: integer overflow\n", c->flag_error_name);
-        break;
+      fprintf(stream, "ERROR: -%s: integer overflow\n", c->flag_error_name);
+      break;
     case FLAG_ERROR_INVALID_SIZE_SUFFIX:
-        fprintf(stream, "error: -%s: invalid size suffix\n", c->flag_error_name);
-        break;
+      fprintf(stream, "ERROR: -%s: invalid size suffix\n", c->flag_error_name);
+      break;
     case COUNT_FLAG_ERRORS:
     default:
-        assert(0 && "unreachable");
-        exit(69);
-    }
+      assert(0 && "unreachable");
+      exit(69);
+  }
 }
 
 #endif