liboptparse: add get_size and get_size_int accessors

Problem: It would be convenient to support options with size arguments
specified using the k, K, M, G, etc suffixes, but liboptparse offers
no such interface.

Add optparse_get_size() and optparse_get_size_int() which parse
option arguments using libutil's parse_size() and return a uint64_t or
int respectively. The optparse_get_size_int() variant raises a fatal
error if the argument overflows MAX_INT.

Author: grondo

src/common/Makefile.am

@@ -111,6 +111,7 @@ libflux_optparse_la_LIBADD = \
 	$(builddir)/libczmqcontainers/libczmqcontainers.la \
 	$(builddir)/liblsd/liblsd.la \
 	$(builddir)/libutil/fsd.lo \
+	$(builddir)/libutil/parse_size.lo \
 	$(LIBPTHREAD)
 libflux_optparse_la_LDFLAGS = \
 	-Wl,--version-script=$(srcdir)/libflux-optparse.map \

src/common/liboptparse/optparse.c

@@ -19,9 +19,11 @@
 #include <ctype.h>
 #include <stdarg.h>
 #include <argz.h>
+#include <math.h>
 
 #include "src/common/libczmqcontainers/czmq_containers.h"
 #include "src/common/libutil/fsd.h"
+#include "src/common/libutil/parse_size.h"
 #include "ccan/str/str.h"
 
 #include "optparse.h"
@@ -950,6 +952,59 @@ double optparse_get_duration (optparse_t *p, const char *name,
     return d;
 }
 
+uint64_t optparse_get_size (optparse_t *p,
+                            const char *name,
+                            const char *default_value)
+{
+    int n;
+    uint64_t result;
+    const char *s = NULL;
+
+    if (default_value == NULL)
+        default_value = "0";
+
+    if ((n = optparse_getopt (p, name, &s)) < 0) {
+        optparse_fatalmsg (p, 1,
+                           "%s: optparse error: no such argument '%s'\n",
+                           p->program_name, name);
+        return (uint64_t) -1;
+    }
+    if (n == 0)
+        s = default_value;
+    if (parse_size (s, &result) < 0) {
+        optparse_fatalmsg (p, 1,
+                          "%s: invalid argument for option '%s': %s: %s\n",
+                          p->program_name,
+                          name,
+                          s,
+                          strerror (errno));
+        return (uint64_t) -1;
+    }
+    return result;
+}
+
+int optparse_get_size_int (optparse_t *p,
+                           const char *name,
+                           const char *default_value)
+{
+    uint64_t val = optparse_get_size (p, name, default_value);
+    if (val == (uint64_t)-1)
+        return -1;
+    if (val > INT_MAX) {
+        const char *s;
+        optparse_getopt (p, name, &s);
+        optparse_fatalmsg (p,
+                           1,
+                           "%s: %s: value %s too large (must be < %s)\n",
+                           p->program_name,
+                           name,
+                           s,
+                           encode_size (INT_MAX+1UL));
+        return -1;
+    }
+    return (int)val;
+}
+
 const char *optparse_get_str (optparse_t *p, const char *name,
                               const char *default_value)
 {

src/common/liboptparse/optparse.h

@@ -12,6 +12,7 @@
 #define _UTIL_OPTPARSE_H
 
 #include <stdbool.h>
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -381,6 +382,27 @@ int optparse_get_int (optparse_t *p, const char *name, int default_value);
 double optparse_get_duration (optparse_t *p, const char *name,
                               double default_value);
 
+/*
+ *   Return the option argument parsed as a size in bytes (or other unit)
+ *    with optional multiplicative suffix: k or K=1024, M=1024*1024,
+ *    G=1024*1024*1024, and so on for T, P, and E. The end result is
+ *    truncated and returned as uint64_t. If there was an error parsing
+ *    the size string, then the fatal error function is called.
+ *
+ *   Return default value if option was unused. default_value=NULL
+ *    is equivalent to default_value="0".
+ */
+uint64_t optparse_get_size (optparse_t *p, const char *name,
+                            const char *default_value);
+
+/*
+ *  Like optparse_get_size(), but return an int and ensure the provided
+ *   argument does not overflow INT_MAX (calls fatal error function if so).
+ */
+int optparse_get_size_int (optparse_t *p,
+                           const char *name,
+                           const char *default_value);
+
 /*
  *   Return the option argument as a double if 'name' was used,
  *    'default_value' if not.  If the option is unknown, or the argument