X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Fopt%2Fopt.c;h=094b15c7e1b48c25aed1256aa741921ad8091f52;hp=236d2af00d20027d8f1b505f2b7ad2ec429f4ac4;hb=c438ec17d7b2efe76e56e5fc5ab88bd4a02735e8;hpb=f8b1841d26dabd23c053f5fc61dbd1536cdad43c diff --git a/ccan/opt/opt.c b/ccan/opt/opt.c index 236d2af0..094b15c7 100644 --- a/ccan/opt/opt.c +++ b/ccan/opt/opt.c @@ -1,7 +1,7 @@ +/* Licensed under GPLv3+ - see LICENSE file for details */ #include #include #include -#include #include #include #include @@ -11,15 +11,136 @@ #include "private.h" struct opt_table *opt_table; -unsigned int opt_count; +unsigned int opt_count, opt_num_short, opt_num_short_arg, opt_num_long; const char *opt_argv0; +/* Returns string after first '-'. */ +static const char *first_name(const char *names, unsigned *len) +{ + *len = strcspn(names + 1, "|= "); + return names + 1; +} + +static const char *next_name(const char *names, unsigned *len) +{ + names += *len; + if (names[0] == ' ' || names[0] == '=' || names[0] == '\0') + return NULL; + return first_name(names + 1, len); +} + +static const char *first_opt(unsigned *i, unsigned *len) +{ + for (*i = 0; *i < opt_count; (*i)++) { + if (opt_table[*i].type == OPT_SUBTABLE) + continue; + return first_name(opt_table[*i].names, len); + } + return NULL; +} + +static const char *next_opt(const char *p, unsigned *i, unsigned *len) +{ + for (; *i < opt_count; (*i)++) { + if (opt_table[*i].type == OPT_SUBTABLE) + continue; + if (!p) + return first_name(opt_table[*i].names, len); + p = next_name(p, len); + if (p) + return p; + } + return NULL; +} + +const char *first_lopt(unsigned *i, unsigned *len) +{ + const char *p; + for (p = first_opt(i, len); p; p = next_opt(p, i, len)) { + if (p[0] == '-') { + /* Skip leading "-" */ + (*len)--; + p++; + break; + } + } + return p; +} + +const char *next_lopt(const char *p, unsigned *i, unsigned *len) +{ + for (p = next_opt(p, i, len); p; p = next_opt(p, i, len)) { + if (p[0] == '-') { + /* Skip leading "-" */ + (*len)--; + p++; + break; + } + } + return p; +} + +const char *first_sopt(unsigned *i) +{ + const char *p; + unsigned int len = 0 /* GCC bogus warning */; + + for (p = first_opt(i, &len); p; p = next_opt(p, i, &len)) { + if (p[0] != '-') + break; + } + return p; +} + +const char *next_sopt(const char *p, unsigned *i) +{ + unsigned int len = 1; + for (p = next_opt(p, i, &len); p; p = next_opt(p, i, &len)) { + if (p[0] != '-') + break; + } + return p; +} + static void check_opt(const struct opt_table *entry) { - assert(entry->flags == OPT_HASARG || entry->flags == OPT_NOARG); - assert(entry->shortopt || entry->longopt); - assert(entry->shortopt != ':'); - assert(entry->shortopt != '?' || entry->flags == OPT_NOARG); + const char *p; + unsigned len; + + if (entry->type != OPT_HASARG && entry->type != OPT_NOARG + && entry->type != (OPT_EARLY|OPT_HASARG) + && entry->type != (OPT_EARLY|OPT_NOARG)) + errx(1, "Option %s: unknown entry type %u", + entry->names, entry->type); + + if (!entry->desc) + errx(1, "Option %s: description cannot be NULL", entry->names); + + + if (entry->names[0] != '-') + errx(1, "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); + opt_num_long++; + } else { + if (len != 1) + errx(1, "Option %s: invalid short option" + " '%.*s'", entry->names, len+1, p-1); + opt_num_short++; + if (entry->type == OPT_HASARG) + opt_num_short_arg++; + } + /* 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); + } + } } static void add_opt(const struct opt_table *entry) @@ -28,20 +149,19 @@ static void add_opt(const struct opt_table *entry) opt_table[opt_count++] = *entry; } -void _opt_register(const char *longopt, char shortopt, enum opt_flags flags, +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.longopt = longopt; - opt.shortopt = shortopt; - opt.flags = flags; + opt.names = names; + 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); @@ -55,8 +175,8 @@ void opt_register_table(const struct opt_table entry[], const char *desc) struct opt_table heading = OPT_SUBTABLE(NULL, desc); add_opt(&heading); } - for (i = 0; entry[i].flags != OPT_END; i++) { - if (entry[i].flags == OPT_SUBTABLE) + for (i = 0; entry[i].type != OPT_END; i++) { + if (entry[i].type == OPT_SUBTABLE) opt_register_table(subtable_of(&entry[i]), entry[i].desc); else { @@ -66,170 +186,71 @@ 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); } -static char *make_optstring(void) +/* Parse your arguments. */ +bool opt_parse(int *argc, char *argv[], void (*errlog)(const char *fmt, ...)) { - /* Worst case, each one is ":x:", plus nul term. */ - char *str = malloc(1 + opt_count * 2 + 1); - unsigned int num, i; + int ret; + unsigned offset = 0; - /* This tells getopt_long we want a ':' returned for missing arg. */ - str[0] = ':'; - num = 1; - for (i = 0; i < opt_count; i++) { - if (!opt_table[i].shortopt) - continue; - str[num++] = opt_table[i].shortopt; - if (opt_table[i].flags == OPT_HASARG) - str[num++] = ':'; - } - str[num] = '\0'; - return str; -} + /* This helps opt_usage. */ + opt_argv0 = argv[0]; -static struct option *make_options(void) -{ - struct option *options = malloc(sizeof(*options) * (opt_count + 1)); - unsigned int i, num; + while ((ret = parse_one(argc, argv, 0, &offset, errlog)) == 1); - for (num = i = 0; i < opt_count; i++) { - if (!opt_table[i].longopt) - continue; - options[num].name = opt_table[i].longopt; - options[num].has_arg = (opt_table[i].flags == OPT_HASARG); - options[num].flag = NULL; - options[num].val = 0; - num++; - } - memset(&options[num], 0, sizeof(options[num])); - return options; + /* parse_one returns 0 on finish, -1 on error */ + return (ret == 0); } -static struct opt_table *find_short(char shortopt) +bool opt_early_parse(int argc, char *argv[], + void (*errlog)(const char *fmt, ...)) { - unsigned int i; - for (i = 0; i < opt_count; i++) { - if (opt_table[i].shortopt == shortopt) - return &opt_table[i]; - } - abort(); -} + int ret; + unsigned off = 0; + char **tmpargv = malloc(sizeof(argv[0]) * (argc + 1)); -/* We want the index'th long entry. */ -static struct opt_table *find_long(int index) -{ - unsigned int i; - for (i = 0; i < opt_count; i++) { - if (!opt_table[i].longopt) - continue; - if (index == 0) - return &opt_table[i]; - index--; - } - abort(); -} + /* We could avoid a copy and skip instead, but this is simple. */ + memcpy(tmpargv, argv, sizeof(argv[0]) * (argc + 1)); -/* glibc does this as: -/tmp/opt-example: invalid option -- 'x' -/tmp/opt-example: unrecognized option '--long' -/tmp/opt-example: option '--someflag' doesn't allow an argument -/tmp/opt-example: option '--s' is ambiguous -/tmp/opt-example: option requires an argument -- 's' -*/ -static void parse_fail(void (*errlog)(const char *fmt, ...), - char shortopt, const char *longopt, const char *problem) -{ - if (shortopt) - errlog("%s: -%c: %s", opt_argv0, shortopt, problem); - else - errlog("%s: --%s: %s", opt_argv0, longopt, problem); -} - -void dump_optstate(void); -void dump_optstate(void) -{ - printf("opterr = %i, optind = %i, optopt = %i, optarg = %s\n", - opterr, optind, optopt, optarg); -} - -/* Parse your arguments. */ -bool opt_parse(int *argc, char *argv[], void (*errlog)(const char *fmt, ...)) -{ - char *optstring = make_optstring(); - struct option *options = make_options(); - int ret, longidx = 0; - struct opt_table *e; - - /* We will do our own error reporting. */ - opterr = 0; + /* This helps opt_usage. */ opt_argv0 = argv[0]; - /* Reset in case we're called more than once. */ - optopt = 0; - optind = 1; - while ((ret = getopt_long(*argc, argv, optstring, options, &longidx)) - != -1) { - char *problem; - bool missing = false; - - /* optopt is 0 if it's an unknown long option, *or* if - * -? is a valid short option. */ - if (ret == '?') { - if (optopt || strncmp(argv[optind-1], "--", 2) == 0) { - parse_fail(errlog, optopt, argv[optind-1]+2, - "unrecognized option"); - break; - } - } else if (ret == ':') { - missing = true; - ret = optopt; - } + while ((ret = parse_one(&argc, tmpargv, OPT_EARLY, &off, errlog)) == 1); - if (ret != 0) - e = find_short(ret); - else - e = find_long(longidx); + free(tmpargv); - /* Missing argument */ - if (missing) { - parse_fail(errlog, e->shortopt, e->longopt, - "option requires an argument"); - break; - } - - if (e->flags == OPT_HASARG) - problem = e->cb_arg(optarg, e->arg); - else - problem = e->cb(e->arg); + /* parse_one returns 0 on finish, -1 on error */ + return (ret == 0); +} - if (problem) { - parse_fail(errlog, e->shortopt, e->longopt, - problem); - free(problem); - break; - } - } - free(optstring); - free(options); - if (ret != -1) - return false; +void opt_free_table(void) +{ + free(opt_table); + opt_table = NULL; + opt_count = opt_num_short = opt_num_short_arg = opt_num_long = 0; +} - /* We hide everything but remaining arguments. */ - memmove(&argv[1], &argv[optind], sizeof(argv[1]) * (*argc-optind+1)); - *argc -= optind - 1; +void opt_log_stderr(const char *fmt, ...) +{ + va_list ap; - return ret == -1 ? true : false; + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + fprintf(stderr, "\n"); + va_end(ap); } -void opt_log_stderr(const char *fmt, ...) +void opt_log_stderr_exit(const char *fmt, ...) { va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); + fprintf(stderr, "\n"); va_end(ap); + exit(1); } char *opt_invalid_argument(const char *arg)