1 /* Licensed under GPLv2+ - see LICENSE file for details */
2 #include <ccan/opt/opt.h>
3 #include <ccan/cast/cast.h>
14 /* Upper bound to sprintf this simple type? Each 3 bits < 1 digit. */
15 #define CHAR_SIZE(type) (((sizeof(type)*CHAR_BIT + 2) / 3) + 1)
17 static char *arg_bad(const char *fmt, const char *arg)
19 char *str = opt_alloc.alloc(strlen(fmt) + strlen(arg));
20 sprintf(str, fmt, arg);
24 char *opt_set_bool(bool *b)
30 char *opt_set_invbool(bool *b)
36 char *opt_set_bool_arg(const char *arg, bool *b)
38 if (!strcasecmp(arg, "yes") || !strcasecmp(arg, "true"))
39 return opt_set_bool(b);
40 if (!strcasecmp(arg, "no") || !strcasecmp(arg, "false"))
41 return opt_set_invbool(b);
43 return opt_invalid_argument(arg);
46 char *opt_set_invbool_arg(const char *arg, bool *b)
48 char *err = opt_set_bool_arg(arg, b);
56 char *opt_set_charp(const char *arg, char **p)
58 *p = cast_const(char *, arg);
62 /* Set an integer value, various forms.
63 FIXME: set to 1 on arg == NULL ? */
64 char *opt_set_intval(const char *arg, int *i)
67 char *err = opt_set_longval(arg, &l);
72 /* Beware truncation, but don't generate untestable code. */
73 if (sizeof(*i) != sizeof(l) && *i != l)
74 return arg_bad("value '%s' does not fit into an integer", arg);
78 char *opt_set_uintval(const char *arg, unsigned int *ui)
81 char *err = opt_set_intval(arg, &i);
86 return arg_bad("'%s' is negative but destination is unsigned", arg);
91 char *opt_set_longval(const char *arg, long *l)
95 /* This is how the manpage says to do it. Yech. */
97 *l = strtol(arg, &endp, 0);
99 return arg_bad("'%s' is not a number", arg);
101 return arg_bad("'%s' is out of range", arg);
105 char *opt_set_ulongval(const char *arg, unsigned long *ul)
110 err = opt_set_longval(arg, &l);
115 return arg_bad("'%s' is negative but destination is unsigned", arg);
119 char *opt_set_floatval(const char *arg, float *f)
124 err = opt_set_doubleval(arg, &d);
130 /*allow true infinity via --foo=INF, while avoiding isinf() from math.h
131 because it wasn't standard 25 years ago.*/
132 double inf = 1e300 * 1e300; /*direct 1e600 annoys -Woverflow*/
133 if ((d > FLT_MAX || d < -FLT_MAX) && d != inf && d != -inf)
134 return arg_bad("'%s' is out of range for a 32 bit float", arg);
135 if (d != 0 && *f == 0)
136 return arg_bad("'%s' is out of range (truncated to zero)", arg);
141 bool opt_show_floatval(char *buf, size_t len, const float *f)
144 opt_show_doubleval(buf, len, &d);
148 char *opt_set_doubleval(const char *arg, double *d)
152 /* This is how the manpage says to do it. Yech. */
154 /* Don't assume strtof */
155 *d = strtod(arg, &endp);
156 if (*endp || !arg[0])
157 return arg_bad("'%s' is not a number", arg);
159 return arg_bad("'%s' is out of range", arg);
164 bool opt_show_doubleval(char *buf, size_t len, const double *d)
166 snprintf(buf, len, "%f", *d);
170 char *opt_inc_intval(int *i)
176 char *opt_dec_intval(int *i)
182 /* Display version string. */
183 char *opt_version_and_exit(const char *version)
185 printf("%s\n", version);
186 /* Don't have valgrind complain! */
191 char *opt_usage_and_exit(const char *extra)
193 char *usage = opt_usage(opt_argv0, extra);
195 /* Don't have valgrind complain! */
196 opt_alloc.free(usage);
201 bool opt_show_bool(char *buf, size_t len, const bool *b)
203 strncpy(buf, *b ? "true" : "false", len);
207 bool opt_show_invbool(char *buf, size_t len, const bool *b)
209 strncpy(buf, *b ? "false" : "true", len);
213 bool opt_show_charp(char *buf, size_t len, char *const *p)
216 size_t plen = strlen(*p);
222 strncpy(buf+1, *p, plen);
232 /* Show an integer value, various forms. */
233 bool opt_show_intval(char *buf, size_t len, const int *i)
235 snprintf(buf, len, "%i", *i);
239 bool opt_show_uintval(char *buf, size_t len, const unsigned int *ui)
241 snprintf(buf, len, "%u", *ui);
245 bool opt_show_longval(char *buf, size_t len, const long *l)
247 snprintf(buf, len, "%li", *l);
251 bool opt_show_ulongval(char *buf, size_t len, const unsigned long *ul)
253 snprintf(buf, len, "%lu", *ul);
257 /* a helper function that multiplies out an argument's kMGTPE suffix in the
258 * long long int range, and perform checks common to all integer destinations.
260 * The base will be either 1000 or 1024, corresponding with the '_si' and
264 static char *set_llong_with_suffix(const char *arg, long long *ll,
265 const long long base)
270 return arg_bad("'%s' (an empty string) is not a number", arg);
273 *ll = strtoll(arg, &endp, 0);
275 return arg_bad("'%s' is out of range", arg);
277 /*The string continues with non-digits. If there is just one
278 letter and it is a known multiplier suffix, use it.*/
280 return arg_bad("'%s' is not a number (suffix too long)", arg);
293 mul = base * base * base;
297 mul = base * base * base * base;
300 mul = base * base * base * base * base;
303 mul = base * base * base * base * base * base;
305 /* This is as far as we can go in 64 bits ('E' is 2 ^ 60) */
307 return arg_bad("'%s' is not a number (unknown suffix)",
310 if (*ll > LLONG_MAX / mul || *ll < LLONG_MIN / mul)
311 return arg_bad("'%s' is out of range", arg);
317 /* Middle layer helpers that perform bounds checks for specific target sizes
320 static char * set_ulonglong_with_suffix(const char *arg, unsigned long long *ull,
324 char *err = set_llong_with_suffix(arg, &ll, base);
328 return arg_bad("'%s' is negative but destination is unsigned", arg);
333 static char * set_long_with_suffix(const char *arg, long *l, const long base)
336 char *err = set_llong_with_suffix(arg, &ll, base);
337 if (err != NULL) /*an error*/
341 /* Beware truncation, but don't generate untestable code. */
342 if (sizeof(*l) != sizeof(ll) && *l != ll)
343 return arg_bad("value '%s' does not fit into a long", arg);
347 static char * set_ulong_with_suffix(const char *arg, unsigned long *ul, const long base)
350 char *err = set_llong_with_suffix(arg, &ll, base);
354 return arg_bad("'%s' is negative but destination is unsigned", arg);
356 /* Beware truncation, but don't generate untestable code. */
357 if (sizeof(*ul) != sizeof(ll) && *ul != ll)
358 return arg_bad("value '%s' does not fit into an unsigned long", arg);
362 static char * set_int_with_suffix(const char *arg, int *i, const long base)
365 char *err = set_llong_with_suffix(arg, &ll, base);
366 if (err != NULL) /*an error*/
371 return arg_bad("value '%s' does not fit into an int", arg);
375 static char * set_uint_with_suffix(const char *arg, unsigned int *u, const long base)
378 char *err = set_llong_with_suffix(arg, &ll, base);
382 return arg_bad("'%s' is negative but destination is unsigned", arg);
385 return arg_bad("value '%s' does not fit into an unsigned int", arg);
389 /*Set an integer, with decimal or binary suffixes.
390 The accepted suffixes are k/K, M/m, G/g, T, P, E.
392 The *_bi functions multiply the numeric value by a power of 1024, while the
393 *_si functions multiply by a power of 1000.
396 char * opt_set_ulonglongval_bi(const char *arg, unsigned long long *ll)
398 return set_ulonglong_with_suffix(arg, ll, 1024);
401 char * opt_set_ulonglongval_si(const char *arg, unsigned long long *ll)
403 return set_ulonglong_with_suffix(arg, ll, 1000);
406 char * opt_set_longlongval_bi(const char *arg, long long *ll)
408 return set_llong_with_suffix(arg, ll, 1024);
411 char * opt_set_longlongval_si(const char *arg, long long *ll)
413 return set_llong_with_suffix(arg, ll, 1000);
416 char * opt_set_longval_bi(const char *arg, long *l)
418 return set_long_with_suffix(arg, l, 1024);
421 char * opt_set_longval_si(const char *arg, long *l)
423 return set_long_with_suffix(arg, l, 1000);
426 char * opt_set_ulongval_bi(const char *arg, unsigned long *ul)
428 return set_ulong_with_suffix(arg, ul, 1024);
431 char * opt_set_ulongval_si(const char *arg, unsigned long *ul)
433 return set_ulong_with_suffix(arg, ul, 1000);
436 char * opt_set_intval_bi(const char *arg, int *i)
438 return set_int_with_suffix(arg, i, 1024);
441 char * opt_set_intval_si(const char *arg, int *i)
443 return set_int_with_suffix(arg, i, 1000);
446 char * opt_set_uintval_bi(const char *arg, unsigned int *u)
448 return set_uint_with_suffix(arg, u, 1024);
451 char * opt_set_uintval_si(const char *arg, unsigned int *u)
453 return set_uint_with_suffix(arg, u, 1000);
456 /*static helpers for showing values with kMGTPE suffixes. In this case there
457 are separate but essentially identical functions for signed and unsigned
458 values, so that unsigned values greater than LLONG_MAX get suffixes.
460 static void show_llong_with_suffix(char *buf, size_t len, long long ll,
461 const long long base)
463 const char *suffixes = "kMGTPE";
466 /*zero is special because everything divides it (you'd get "0E")*/
467 snprintf(buf, len, "0");
470 for (i = 0; i < strlen(suffixes); i++){
471 long long tmp = ll / base;
472 if (tmp * base != ll)
477 snprintf(buf, len, "%"PRId64, (int64_t)ll);
479 snprintf(buf, len, "%"PRId64"%c", (int64_t)ll, suffixes[i - 1]);
482 static void show_ullong_with_suffix(char *buf, size_t len,
483 unsigned long long ull,
486 const char *suffixes = "kMGTPE";
489 /*zero is special because everything divides it (you'd get "0E")*/
490 snprintf(buf, len, "0");
493 for (i = 0; i < strlen(suffixes); i++){
494 unsigned long long tmp = ull / base;
495 if (tmp * base != ull)
500 snprintf(buf, len, "%"PRIu64, (uint64_t)ull);
502 snprintf(buf, len, "%"PRIu64"%c", (uint64_t)ull, suffixes[i - 1]);
506 bool opt_show_intval_bi(char *buf, size_t len, const int *x)
508 show_llong_with_suffix(buf, len, *x, 1024);
512 bool opt_show_longval_bi(char *buf, size_t len, const long *x)
514 show_llong_with_suffix(buf, len, *x, 1024);
518 bool opt_show_longlongval_bi(char *buf, size_t len, const long long *x)
520 show_llong_with_suffix(buf, len, *x, 1024);
525 bool opt_show_uintval_bi(char *buf, size_t len, const unsigned int *x)
527 show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1024);
531 bool opt_show_ulongval_bi(char *buf, size_t len, const unsigned long *x)
533 show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1024);
537 bool opt_show_ulonglongval_bi(char *buf, size_t len, const unsigned long long *x)
539 show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1024);
544 bool opt_show_intval_si(char *buf, size_t len, const int *x)
546 show_llong_with_suffix(buf, len, (long long) *x, 1000);
550 bool opt_show_longval_si(char *buf, size_t len, const long *x)
552 show_llong_with_suffix(buf, len, (long long) *x, 1000);
556 bool opt_show_longlongval_si(char *buf, size_t len, const long long *x)
558 show_llong_with_suffix(buf, len, *x, 1000);
563 bool opt_show_uintval_si(char *buf, size_t len, const unsigned int *x)
565 show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1000);
569 bool opt_show_ulongval_si(char *buf, size_t len, const unsigned long *x)
571 show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1000);
575 bool opt_show_ulonglongval_si(char *buf, size_t len, const unsigned long long *x)
577 show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1000);