X-Git-Url: https://git.ozlabs.org/?a=blobdiff_plain;ds=sidebyside;f=ccan%2Fopt%2Fopt.c;h=d4601dfbb230a3076edfa64d8b5232996f4d59d2;hb=e5fb923ba3735c758ef795eb69d5ee1c6f0a94e9;hp=8f67740036e7e5c5ac53bb3c2abe8d5a9ccc7fce;hpb=9056c31b46452c92c7dd9c276664f514720a84c6;p=ccan diff --git a/ccan/opt/opt.c b/ccan/opt/opt.c index 8f677400..d4601dfb 100644 --- a/ccan/opt/opt.c +++ b/ccan/opt/opt.c @@ -1,9 +1,9 @@ +/* Licensed under GPLv2+ - see LICENSE file for details */ #include #include #include #include #include -#include #include #include #include @@ -12,6 +12,9 @@ struct opt_table *opt_table; unsigned int opt_count, opt_num_short, opt_num_short_arg, opt_num_long; const char *opt_argv0; +struct opt_alloc opt_alloc = { + malloc, realloc, free +}; /* Returns string after first '-'. */ static const char *first_name(const char *names, unsigned *len) @@ -101,32 +104,40 @@ const char *next_sopt(const char *p, unsigned *i) return p; } +/* Avoids dependency on err.h or ccan/err */ +#ifndef failmsg +#define failmsg(fmt, ...) \ + do { fprintf(stderr, fmt, __VA_ARGS__); exit(1); } while(0) +#endif + static void check_opt(const struct opt_table *entry) { const char *p; unsigned len; - if (entry->type != OPT_HASARG && entry->type != OPT_NOARG) - errx(1, "Option %s: unknown entry type %u", - entry->names, entry->type); + if (entry->type != OPT_HASARG && entry->type != OPT_NOARG + && entry->type != (OPT_EARLY|OPT_HASARG) + && entry->type != (OPT_EARLY|OPT_NOARG)) + failmsg("Option %s: unknown entry type %u", + entry->names, entry->type); if (!entry->desc) - errx(1, "Option %s: description cannot be NULL", entry->names); + failmsg("Option %s: description cannot be NULL", entry->names); if (entry->names[0] != '-') - errx(1, "Option %s: does not begin with '-'", entry->names); + failmsg("Option %s: does not begin with '-'", entry->names); for (p = first_name(entry->names, &len); p; p = next_name(p, &len)) { if (*p == '-') { if (len == 1) - errx(1, "Option %s: invalid long option '--'", - entry->names); + failmsg("Option %s: invalid long option '--'", + entry->names); opt_num_long++; } else { if (len != 1) - errx(1, "Option %s: invalid short option" - " '%.*s'", entry->names, len+1, p-1); + failmsg("Option %s: invalid short option" + " '%.*s'", entry->names, len+1, p-1); opt_num_short++; if (entry->type == OPT_HASARG) opt_num_short_arg++; @@ -134,15 +145,16 @@ static void check_opt(const struct opt_table *entry) /* Don't document args unless there are some. */ if (entry->type == OPT_NOARG) { if (p[len] == ' ' || p[len] == '=') - errx(1, "Option %s: does not take arguments" - " '%s'", entry->names, p+len+1); + failmsg("Option %s: does not take arguments" + " '%s'", entry->names, p+len+1); } } } static void add_opt(const struct opt_table *entry) { - opt_table = realloc(opt_table, sizeof(opt_table[0]) * (opt_count+1)); + opt_table = opt_alloc.realloc(opt_table, + sizeof(opt_table[0]) * (opt_count+1)); opt_table[opt_count++] = *entry; } @@ -150,7 +162,7 @@ void _opt_register(const char *names, enum opt_type type, char *(*cb)(void *arg), char *(*cb_arg)(const char *optarg, void *arg), void (*show)(char buf[OPT_SHOW_LEN], const void *arg), - void *arg, const char *desc) + const void *arg, const char *desc) { struct opt_table opt; opt.names = names; @@ -158,12 +170,29 @@ void _opt_register(const char *names, enum opt_type type, opt.cb = cb; opt.cb_arg = cb_arg; opt.show = show; - opt.arg = arg; + opt.u.carg = arg; opt.desc = desc; check_opt(&opt); add_opt(&opt); } +bool opt_unregister(const char *names) +{ + int found = -1, i; + + for (i = 0; i < opt_count; i++) { + if (opt_table[i].type == OPT_SUBTABLE) + continue; + if (strcmp(opt_table[i].names, names) == 0) + found = i; + } + if (found == -1) + return false; + opt_count--; + memmove(&opt_table[found], &opt_table[found+1], opt_count - found); + return true; +} + void opt_register_table(const struct opt_table entry[], const char *desc) { unsigned int i, start = opt_count; @@ -183,7 +212,7 @@ void opt_register_table(const struct opt_table entry[], const char *desc) } /* We store the table length in arg ptr. */ if (desc) - opt_table[start].arg = (void *)(intptr_t)(opt_count - start); + opt_table[start].u.tlen = (opt_count - start); } /* Parse your arguments. */ @@ -195,12 +224,53 @@ bool opt_parse(int *argc, char *argv[], void (*errlog)(const char *fmt, ...)) /* This helps opt_usage. */ opt_argv0 = argv[0]; - while ((ret = parse_one(argc, argv, &offset, errlog)) == 1); + while ((ret = parse_one(argc, argv, 0, &offset, errlog, false)) == 1); + + /* parse_one returns 0 on finish, -1 on error */ + return (ret == 0); +} + +static bool early_parse(int argc, char *argv[], + void (*errlog)(const char *fmt, ...), + bool ignore_unknown) +{ + int ret; + unsigned off = 0; + char **tmpargv = opt_alloc.alloc(sizeof(argv[0]) * (argc + 1)); + + /* We could avoid a copy and skip instead, but this is simple. */ + memcpy(tmpargv, argv, sizeof(argv[0]) * (argc + 1)); + + /* This helps opt_usage. */ + opt_argv0 = argv[0]; + + while ((ret = parse_one(&argc, tmpargv, OPT_EARLY, &off, errlog, ignore_unknown)) == 1); + + opt_alloc.free(tmpargv); /* parse_one returns 0 on finish, -1 on error */ return (ret == 0); } +bool opt_early_parse(int argc, char *argv[], + void (*errlog)(const char *fmt, ...)) +{ + return early_parse(argc, argv, errlog, false); +} + +bool opt_early_parse_incomplete(int argc, char *argv[], + void (*errlog)(const char *fmt, ...)) +{ + return early_parse(argc, argv, errlog, true); +} + +void opt_free_table(void) +{ + opt_alloc.free(opt_table); + opt_table = NULL; + opt_count = opt_num_short = opt_num_short_arg = opt_num_long = 0; +} + void opt_log_stderr(const char *fmt, ...) { va_list ap; @@ -224,7 +294,16 @@ void opt_log_stderr_exit(const char *fmt, ...) char *opt_invalid_argument(const char *arg) { - char *str = malloc(sizeof("Invalid argument '%s'") + strlen(arg)); + char *str = opt_alloc.alloc(sizeof("Invalid argument '%s'") + strlen(arg)); sprintf(str, "Invalid argument '%s'", arg); return str; } + +void opt_set_alloc(void *(*allocfn)(size_t size), + void *(*reallocfn)(void *ptr, size_t size), + void (*freefn)(void *ptr)) +{ + opt_alloc.alloc = allocfn; + opt_alloc.realloc = reallocfn; + opt_alloc.free = freefn; +}