Root/
Source at commit ec7cab4cbb721bff91ec924ec691efd8daf36579 created 12 years 8 months ago. By Maarten ter Huurne, MIPS: JZ4740: A320: Updated quickstart documentation. | |
---|---|
1 | #include "util.h" |
2 | #include "parse-options.h" |
3 | #include "cache.h" |
4 | |
5 | #define OPT_SHORT 1 |
6 | #define OPT_UNSET 2 |
7 | |
8 | static int opterror(const struct option *opt, const char *reason, int flags) |
9 | { |
10 | if (flags & OPT_SHORT) |
11 | return error("switch `%c' %s", opt->short_name, reason); |
12 | if (flags & OPT_UNSET) |
13 | return error("option `no-%s' %s", opt->long_name, reason); |
14 | return error("option `%s' %s", opt->long_name, reason); |
15 | } |
16 | |
17 | static int get_arg(struct parse_opt_ctx_t *p, const struct option *opt, |
18 | int flags, const char **arg) |
19 | { |
20 | if (p->opt) { |
21 | *arg = p->opt; |
22 | p->opt = NULL; |
23 | } else if ((opt->flags & PARSE_OPT_LASTARG_DEFAULT) && (p->argc == 1 || |
24 | **(p->argv + 1) == '-')) { |
25 | *arg = (const char *)opt->defval; |
26 | } else if (p->argc > 1) { |
27 | p->argc--; |
28 | *arg = *++p->argv; |
29 | } else |
30 | return opterror(opt, "requires a value", flags); |
31 | return 0; |
32 | } |
33 | |
34 | static int get_value(struct parse_opt_ctx_t *p, |
35 | const struct option *opt, int flags) |
36 | { |
37 | const char *s, *arg = NULL; |
38 | const int unset = flags & OPT_UNSET; |
39 | |
40 | if (unset && p->opt) |
41 | return opterror(opt, "takes no value", flags); |
42 | if (unset && (opt->flags & PARSE_OPT_NONEG)) |
43 | return opterror(opt, "isn't available", flags); |
44 | |
45 | if (!(flags & OPT_SHORT) && p->opt) { |
46 | switch (opt->type) { |
47 | case OPTION_CALLBACK: |
48 | if (!(opt->flags & PARSE_OPT_NOARG)) |
49 | break; |
50 | /* FALLTHROUGH */ |
51 | case OPTION_BOOLEAN: |
52 | case OPTION_INCR: |
53 | case OPTION_BIT: |
54 | case OPTION_SET_UINT: |
55 | case OPTION_SET_PTR: |
56 | return opterror(opt, "takes no value", flags); |
57 | case OPTION_END: |
58 | case OPTION_ARGUMENT: |
59 | case OPTION_GROUP: |
60 | case OPTION_STRING: |
61 | case OPTION_INTEGER: |
62 | case OPTION_UINTEGER: |
63 | case OPTION_LONG: |
64 | case OPTION_U64: |
65 | default: |
66 | break; |
67 | } |
68 | } |
69 | |
70 | switch (opt->type) { |
71 | case OPTION_BIT: |
72 | if (unset) |
73 | *(int *)opt->value &= ~opt->defval; |
74 | else |
75 | *(int *)opt->value |= opt->defval; |
76 | return 0; |
77 | |
78 | case OPTION_BOOLEAN: |
79 | *(bool *)opt->value = unset ? false : true; |
80 | return 0; |
81 | |
82 | case OPTION_INCR: |
83 | *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1; |
84 | return 0; |
85 | |
86 | case OPTION_SET_UINT: |
87 | *(unsigned int *)opt->value = unset ? 0 : opt->defval; |
88 | return 0; |
89 | |
90 | case OPTION_SET_PTR: |
91 | *(void **)opt->value = unset ? NULL : (void *)opt->defval; |
92 | return 0; |
93 | |
94 | case OPTION_STRING: |
95 | if (unset) |
96 | *(const char **)opt->value = NULL; |
97 | else if (opt->flags & PARSE_OPT_OPTARG && !p->opt) |
98 | *(const char **)opt->value = (const char *)opt->defval; |
99 | else |
100 | return get_arg(p, opt, flags, (const char **)opt->value); |
101 | return 0; |
102 | |
103 | case OPTION_CALLBACK: |
104 | if (unset) |
105 | return (*opt->callback)(opt, NULL, 1) ? (-1) : 0; |
106 | if (opt->flags & PARSE_OPT_NOARG) |
107 | return (*opt->callback)(opt, NULL, 0) ? (-1) : 0; |
108 | if (opt->flags & PARSE_OPT_OPTARG && !p->opt) |
109 | return (*opt->callback)(opt, NULL, 0) ? (-1) : 0; |
110 | if (get_arg(p, opt, flags, &arg)) |
111 | return -1; |
112 | return (*opt->callback)(opt, arg, 0) ? (-1) : 0; |
113 | |
114 | case OPTION_INTEGER: |
115 | if (unset) { |
116 | *(int *)opt->value = 0; |
117 | return 0; |
118 | } |
119 | if (opt->flags & PARSE_OPT_OPTARG && !p->opt) { |
120 | *(int *)opt->value = opt->defval; |
121 | return 0; |
122 | } |
123 | if (get_arg(p, opt, flags, &arg)) |
124 | return -1; |
125 | *(int *)opt->value = strtol(arg, (char **)&s, 10); |
126 | if (*s) |
127 | return opterror(opt, "expects a numerical value", flags); |
128 | return 0; |
129 | |
130 | case OPTION_UINTEGER: |
131 | if (unset) { |
132 | *(unsigned int *)opt->value = 0; |
133 | return 0; |
134 | } |
135 | if (opt->flags & PARSE_OPT_OPTARG && !p->opt) { |
136 | *(unsigned int *)opt->value = opt->defval; |
137 | return 0; |
138 | } |
139 | if (get_arg(p, opt, flags, &arg)) |
140 | return -1; |
141 | *(unsigned int *)opt->value = strtol(arg, (char **)&s, 10); |
142 | if (*s) |
143 | return opterror(opt, "expects a numerical value", flags); |
144 | return 0; |
145 | |
146 | case OPTION_LONG: |
147 | if (unset) { |
148 | *(long *)opt->value = 0; |
149 | return 0; |
150 | } |
151 | if (opt->flags & PARSE_OPT_OPTARG && !p->opt) { |
152 | *(long *)opt->value = opt->defval; |
153 | return 0; |
154 | } |
155 | if (get_arg(p, opt, flags, &arg)) |
156 | return -1; |
157 | *(long *)opt->value = strtol(arg, (char **)&s, 10); |
158 | if (*s) |
159 | return opterror(opt, "expects a numerical value", flags); |
160 | return 0; |
161 | |
162 | case OPTION_U64: |
163 | if (unset) { |
164 | *(u64 *)opt->value = 0; |
165 | return 0; |
166 | } |
167 | if (opt->flags & PARSE_OPT_OPTARG && !p->opt) { |
168 | *(u64 *)opt->value = opt->defval; |
169 | return 0; |
170 | } |
171 | if (get_arg(p, opt, flags, &arg)) |
172 | return -1; |
173 | *(u64 *)opt->value = strtoull(arg, (char **)&s, 10); |
174 | if (*s) |
175 | return opterror(opt, "expects a numerical value", flags); |
176 | return 0; |
177 | |
178 | case OPTION_END: |
179 | case OPTION_ARGUMENT: |
180 | case OPTION_GROUP: |
181 | default: |
182 | die("should not happen, someone must be hit on the forehead"); |
183 | } |
184 | } |
185 | |
186 | static int parse_short_opt(struct parse_opt_ctx_t *p, const struct option *options) |
187 | { |
188 | for (; options->type != OPTION_END; options++) { |
189 | if (options->short_name == *p->opt) { |
190 | p->opt = p->opt[1] ? p->opt + 1 : NULL; |
191 | return get_value(p, options, OPT_SHORT); |
192 | } |
193 | } |
194 | return -2; |
195 | } |
196 | |
197 | static int parse_long_opt(struct parse_opt_ctx_t *p, const char *arg, |
198 | const struct option *options) |
199 | { |
200 | const char *arg_end = strchr(arg, '='); |
201 | const struct option *abbrev_option = NULL, *ambiguous_option = NULL; |
202 | int abbrev_flags = 0, ambiguous_flags = 0; |
203 | |
204 | if (!arg_end) |
205 | arg_end = arg + strlen(arg); |
206 | |
207 | for (; options->type != OPTION_END; options++) { |
208 | const char *rest; |
209 | int flags = 0; |
210 | |
211 | if (!options->long_name) |
212 | continue; |
213 | |
214 | rest = skip_prefix(arg, options->long_name); |
215 | if (options->type == OPTION_ARGUMENT) { |
216 | if (!rest) |
217 | continue; |
218 | if (*rest == '=') |
219 | return opterror(options, "takes no value", flags); |
220 | if (*rest) |
221 | continue; |
222 | p->out[p->cpidx++] = arg - 2; |
223 | return 0; |
224 | } |
225 | if (!rest) { |
226 | /* abbreviated? */ |
227 | if (!strncmp(options->long_name, arg, arg_end - arg)) { |
228 | is_abbreviated: |
229 | if (abbrev_option) { |
230 | /* |
231 | * If this is abbreviated, it is |
232 | * ambiguous. So when there is no |
233 | * exact match later, we need to |
234 | * error out. |
235 | */ |
236 | ambiguous_option = abbrev_option; |
237 | ambiguous_flags = abbrev_flags; |
238 | } |
239 | if (!(flags & OPT_UNSET) && *arg_end) |
240 | p->opt = arg_end + 1; |
241 | abbrev_option = options; |
242 | abbrev_flags = flags; |
243 | continue; |
244 | } |
245 | /* negated and abbreviated very much? */ |
246 | if (!prefixcmp("no-", arg)) { |
247 | flags |= OPT_UNSET; |
248 | goto is_abbreviated; |
249 | } |
250 | /* negated? */ |
251 | if (strncmp(arg, "no-", 3)) |
252 | continue; |
253 | flags |= OPT_UNSET; |
254 | rest = skip_prefix(arg + 3, options->long_name); |
255 | /* abbreviated and negated? */ |
256 | if (!rest && !prefixcmp(options->long_name, arg + 3)) |
257 | goto is_abbreviated; |
258 | if (!rest) |
259 | continue; |
260 | } |
261 | if (*rest) { |
262 | if (*rest != '=') |
263 | continue; |
264 | p->opt = rest + 1; |
265 | } |
266 | return get_value(p, options, flags); |
267 | } |
268 | |
269 | if (ambiguous_option) |
270 | return error("Ambiguous option: %s " |
271 | "(could be --%s%s or --%s%s)", |
272 | arg, |
273 | (ambiguous_flags & OPT_UNSET) ? "no-" : "", |
274 | ambiguous_option->long_name, |
275 | (abbrev_flags & OPT_UNSET) ? "no-" : "", |
276 | abbrev_option->long_name); |
277 | if (abbrev_option) |
278 | return get_value(p, abbrev_option, abbrev_flags); |
279 | return -2; |
280 | } |
281 | |
282 | static void check_typos(const char *arg, const struct option *options) |
283 | { |
284 | if (strlen(arg) < 3) |
285 | return; |
286 | |
287 | if (!prefixcmp(arg, "no-")) { |
288 | error ("did you mean `--%s` (with two dashes ?)", arg); |
289 | exit(129); |
290 | } |
291 | |
292 | for (; options->type != OPTION_END; options++) { |
293 | if (!options->long_name) |
294 | continue; |
295 | if (!prefixcmp(options->long_name, arg)) { |
296 | error ("did you mean `--%s` (with two dashes ?)", arg); |
297 | exit(129); |
298 | } |
299 | } |
300 | } |
301 | |
302 | void parse_options_start(struct parse_opt_ctx_t *ctx, |
303 | int argc, const char **argv, int flags) |
304 | { |
305 | memset(ctx, 0, sizeof(*ctx)); |
306 | ctx->argc = argc - 1; |
307 | ctx->argv = argv + 1; |
308 | ctx->out = argv; |
309 | ctx->cpidx = ((flags & PARSE_OPT_KEEP_ARGV0) != 0); |
310 | ctx->flags = flags; |
311 | if ((flags & PARSE_OPT_KEEP_UNKNOWN) && |
312 | (flags & PARSE_OPT_STOP_AT_NON_OPTION)) |
313 | die("STOP_AT_NON_OPTION and KEEP_UNKNOWN don't go together"); |
314 | } |
315 | |
316 | static int usage_with_options_internal(const char * const *, |
317 | const struct option *, int); |
318 | |
319 | int parse_options_step(struct parse_opt_ctx_t *ctx, |
320 | const struct option *options, |
321 | const char * const usagestr[]) |
322 | { |
323 | int internal_help = !(ctx->flags & PARSE_OPT_NO_INTERNAL_HELP); |
324 | |
325 | /* we must reset ->opt, unknown short option leave it dangling */ |
326 | ctx->opt = NULL; |
327 | |
328 | for (; ctx->argc; ctx->argc--, ctx->argv++) { |
329 | const char *arg = ctx->argv[0]; |
330 | |
331 | if (*arg != '-' || !arg[1]) { |
332 | if (ctx->flags & PARSE_OPT_STOP_AT_NON_OPTION) |
333 | break; |
334 | ctx->out[ctx->cpidx++] = ctx->argv[0]; |
335 | continue; |
336 | } |
337 | |
338 | if (arg[1] != '-') { |
339 | ctx->opt = arg + 1; |
340 | if (internal_help && *ctx->opt == 'h') |
341 | return parse_options_usage(usagestr, options); |
342 | switch (parse_short_opt(ctx, options)) { |
343 | case -1: |
344 | return parse_options_usage(usagestr, options); |
345 | case -2: |
346 | goto unknown; |
347 | default: |
348 | break; |
349 | } |
350 | if (ctx->opt) |
351 | check_typos(arg + 1, options); |
352 | while (ctx->opt) { |
353 | if (internal_help && *ctx->opt == 'h') |
354 | return parse_options_usage(usagestr, options); |
355 | switch (parse_short_opt(ctx, options)) { |
356 | case -1: |
357 | return parse_options_usage(usagestr, options); |
358 | case -2: |
359 | /* fake a short option thing to hide the fact that we may have |
360 | * started to parse aggregated stuff |
361 | * |
362 | * This is leaky, too bad. |
363 | */ |
364 | ctx->argv[0] = strdup(ctx->opt - 1); |
365 | *(char *)ctx->argv[0] = '-'; |
366 | goto unknown; |
367 | default: |
368 | break; |
369 | } |
370 | } |
371 | continue; |
372 | } |
373 | |
374 | if (!arg[2]) { /* "--" */ |
375 | if (!(ctx->flags & PARSE_OPT_KEEP_DASHDASH)) { |
376 | ctx->argc--; |
377 | ctx->argv++; |
378 | } |
379 | break; |
380 | } |
381 | |
382 | if (internal_help && !strcmp(arg + 2, "help-all")) |
383 | return usage_with_options_internal(usagestr, options, 1); |
384 | if (internal_help && !strcmp(arg + 2, "help")) |
385 | return parse_options_usage(usagestr, options); |
386 | switch (parse_long_opt(ctx, arg + 2, options)) { |
387 | case -1: |
388 | return parse_options_usage(usagestr, options); |
389 | case -2: |
390 | goto unknown; |
391 | default: |
392 | break; |
393 | } |
394 | continue; |
395 | unknown: |
396 | if (!(ctx->flags & PARSE_OPT_KEEP_UNKNOWN)) |
397 | return PARSE_OPT_UNKNOWN; |
398 | ctx->out[ctx->cpidx++] = ctx->argv[0]; |
399 | ctx->opt = NULL; |
400 | } |
401 | return PARSE_OPT_DONE; |
402 | } |
403 | |
404 | int parse_options_end(struct parse_opt_ctx_t *ctx) |
405 | { |
406 | memmove(ctx->out + ctx->cpidx, ctx->argv, ctx->argc * sizeof(*ctx->out)); |
407 | ctx->out[ctx->cpidx + ctx->argc] = NULL; |
408 | return ctx->cpidx + ctx->argc; |
409 | } |
410 | |
411 | int parse_options(int argc, const char **argv, const struct option *options, |
412 | const char * const usagestr[], int flags) |
413 | { |
414 | struct parse_opt_ctx_t ctx; |
415 | |
416 | parse_options_start(&ctx, argc, argv, flags); |
417 | switch (parse_options_step(&ctx, options, usagestr)) { |
418 | case PARSE_OPT_HELP: |
419 | exit(129); |
420 | case PARSE_OPT_DONE: |
421 | break; |
422 | default: /* PARSE_OPT_UNKNOWN */ |
423 | if (ctx.argv[0][1] == '-') { |
424 | error("unknown option `%s'", ctx.argv[0] + 2); |
425 | } else { |
426 | error("unknown switch `%c'", *ctx.opt); |
427 | } |
428 | usage_with_options(usagestr, options); |
429 | } |
430 | |
431 | return parse_options_end(&ctx); |
432 | } |
433 | |
434 | #define USAGE_OPTS_WIDTH 24 |
435 | #define USAGE_GAP 2 |
436 | |
437 | int usage_with_options_internal(const char * const *usagestr, |
438 | const struct option *opts, int full) |
439 | { |
440 | if (!usagestr) |
441 | return PARSE_OPT_HELP; |
442 | |
443 | fprintf(stderr, "\n usage: %s\n", *usagestr++); |
444 | while (*usagestr && **usagestr) |
445 | fprintf(stderr, " or: %s\n", *usagestr++); |
446 | while (*usagestr) { |
447 | fprintf(stderr, "%s%s\n", |
448 | **usagestr ? " " : "", |
449 | *usagestr); |
450 | usagestr++; |
451 | } |
452 | |
453 | if (opts->type != OPTION_GROUP) |
454 | fputc('\n', stderr); |
455 | |
456 | for (; opts->type != OPTION_END; opts++) { |
457 | size_t pos; |
458 | int pad; |
459 | |
460 | if (opts->type == OPTION_GROUP) { |
461 | fputc('\n', stderr); |
462 | if (*opts->help) |
463 | fprintf(stderr, "%s\n", opts->help); |
464 | continue; |
465 | } |
466 | if (!full && (opts->flags & PARSE_OPT_HIDDEN)) |
467 | continue; |
468 | |
469 | pos = fprintf(stderr, " "); |
470 | if (opts->short_name) |
471 | pos += fprintf(stderr, "-%c", opts->short_name); |
472 | else |
473 | pos += fprintf(stderr, " "); |
474 | |
475 | if (opts->long_name && opts->short_name) |
476 | pos += fprintf(stderr, ", "); |
477 | if (opts->long_name) |
478 | pos += fprintf(stderr, "--%s", opts->long_name); |
479 | |
480 | switch (opts->type) { |
481 | case OPTION_ARGUMENT: |
482 | break; |
483 | case OPTION_LONG: |
484 | case OPTION_U64: |
485 | case OPTION_INTEGER: |
486 | case OPTION_UINTEGER: |
487 | if (opts->flags & PARSE_OPT_OPTARG) |
488 | if (opts->long_name) |
489 | pos += fprintf(stderr, "[=<n>]"); |
490 | else |
491 | pos += fprintf(stderr, "[<n>]"); |
492 | else |
493 | pos += fprintf(stderr, " <n>"); |
494 | break; |
495 | case OPTION_CALLBACK: |
496 | if (opts->flags & PARSE_OPT_NOARG) |
497 | break; |
498 | /* FALLTHROUGH */ |
499 | case OPTION_STRING: |
500 | if (opts->argh) { |
501 | if (opts->flags & PARSE_OPT_OPTARG) |
502 | if (opts->long_name) |
503 | pos += fprintf(stderr, "[=<%s>]", opts->argh); |
504 | else |
505 | pos += fprintf(stderr, "[<%s>]", opts->argh); |
506 | else |
507 | pos += fprintf(stderr, " <%s>", opts->argh); |
508 | } else { |
509 | if (opts->flags & PARSE_OPT_OPTARG) |
510 | if (opts->long_name) |
511 | pos += fprintf(stderr, "[=...]"); |
512 | else |
513 | pos += fprintf(stderr, "[...]"); |
514 | else |
515 | pos += fprintf(stderr, " ..."); |
516 | } |
517 | break; |
518 | default: /* OPTION_{BIT,BOOLEAN,SET_UINT,SET_PTR} */ |
519 | case OPTION_END: |
520 | case OPTION_GROUP: |
521 | case OPTION_BIT: |
522 | case OPTION_BOOLEAN: |
523 | case OPTION_INCR: |
524 | case OPTION_SET_UINT: |
525 | case OPTION_SET_PTR: |
526 | break; |
527 | } |
528 | |
529 | if (pos <= USAGE_OPTS_WIDTH) |
530 | pad = USAGE_OPTS_WIDTH - pos; |
531 | else { |
532 | fputc('\n', stderr); |
533 | pad = USAGE_OPTS_WIDTH; |
534 | } |
535 | fprintf(stderr, "%*s%s\n", pad + USAGE_GAP, "", opts->help); |
536 | } |
537 | fputc('\n', stderr); |
538 | |
539 | return PARSE_OPT_HELP; |
540 | } |
541 | |
542 | void usage_with_options(const char * const *usagestr, |
543 | const struct option *opts) |
544 | { |
545 | exit_browser(false); |
546 | usage_with_options_internal(usagestr, opts, 0); |
547 | exit(129); |
548 | } |
549 | |
550 | int parse_options_usage(const char * const *usagestr, |
551 | const struct option *opts) |
552 | { |
553 | return usage_with_options_internal(usagestr, opts, 0); |
554 | } |
555 | |
556 | |
557 | int parse_opt_verbosity_cb(const struct option *opt, const char *arg __used, |
558 | int unset) |
559 | { |
560 | int *target = opt->value; |
561 | |
562 | if (unset) |
563 | /* --no-quiet, --no-verbose */ |
564 | *target = 0; |
565 | else if (opt->short_name == 'v') { |
566 | if (*target >= 0) |
567 | (*target)++; |
568 | else |
569 | *target = 1; |
570 | } else { |
571 | if (*target <= 0) |
572 | (*target)--; |
573 | else |
574 | *target = -1; |
575 | } |
576 | return 0; |
577 | } |
578 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9