Introduce flag_size with dd(1) style multiplicative suffixes

Author: rexim

example.c

@@ -15,7 +15,7 @@ int main(int argc, char **argv)
 {
     bool *help = flag_bool("help", false, "Print this help to stdout and exit with 0");
     char **line = flag_str("line", "Hi!", "Line to output to the file");
-    uint64_t *count = flag_uint64("count", 64, "Amount of lines to generate");
+    size_t *count = flag_size("count", 64, "Amount of lines to generate");
 
     if (!flag_parse(argc, argv)) {
         usage(stderr);
@@ -42,7 +42,7 @@ int main(int argc, char **argv)
         FILE *f = fopen(file_path, "w");
         assert(f);
 
-        for (uint64_t i = 0; i < *count; ++i) {
+        for (size_t i = 0; i < *count; ++i) {
             fprintf(f, "%s\n", *line);
         }
 

flag.h

@@ -26,6 +26,7 @@
 char *flag_name(void *val);
 bool *flag_bool(const char *name, bool def, const char *desc);
 uint64_t *flag_uint64(const char *name, uint64_t def, const char *desc);
+size_t *flag_size(const char *name, uint64_t def, const char *desc);
 char **flag_str(const char *name, const char *def, const char *desc);
 bool flag_parse(int argc, char **argv);
 int flag_rest_argc(void);
@@ -40,15 +41,19 @@ void flag_print_options(FILE *stream);
 #ifdef FLAG_IMPLEMENTATION
 
 typedef enum {
-    FLAG_BOOL,
+    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;
 } Flag_Value;
 
 typedef enum {
@@ -57,6 +62,8 @@ typedef enum {
     FLAG_ERROR_NO_VALUE,
     FLAG_ERROR_INVALID_NUMBER,
     FLAG_ERROR_INTEGER_OVERFLOW,
+    FLAG_ERROR_INVALID_SIZE_SUFFIX,
+    COUNT_FLAG_ERRORS,
 } Flag_Error;
 
 typedef struct {
@@ -120,6 +127,14 @@ uint64_t *flag_uint64(const char *name, uint64_t def, const char *desc)
     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;
+}
+
 char **flag_str(const char *name, const char *def, const char *desc)
 {
     Flag *flag = flag_new(FLAG_STR, name, desc);
@@ -176,6 +191,7 @@ bool flag_parse(int argc, char **argv)
         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;
@@ -207,11 +223,12 @@ bool flag_parse(int argc, char **argv)
                     // That way we can get rid of the dependency on errno and static_assert
                     unsigned long long int result = strtoull(arg, &endptr, 10);
 
-                    if (arg == endptr || *endptr != '\0') {
+                    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;
@@ -222,6 +239,50 @@ bool flag_parse(int argc, char **argv)
                 }
                 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);
@@ -252,6 +313,7 @@ void flag_print_options(FILE *stream)
 
         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) {
@@ -261,6 +323,9 @@ void flag_print_options(FILE *stream)
         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);
@@ -276,6 +341,7 @@ void flag_print_options(FILE *stream)
 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) {
     case FLAG_NO_ERROR:
         // NOTE: don't call flag_print_error() if flag_parse() didn't return false, okay? ._.
@@ -293,6 +359,10 @@ void flag_print_error(FILE *stream)
     case FLAG_ERROR_INTEGER_OVERFLOW:
         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;
+    case COUNT_FLAG_ERRORS:
     default:
         assert(0 && "unreachable");
         exit(69);