1 #include "git-compat-util.h"
2 #include "parse-options.h"
7 static inline const char *get_arg(struct parse_opt_ctx_t
*p
)
10 const char *res
= p
->opt
;
18 static inline const char *skip_prefix(const char *str
, const char *prefix
)
20 size_t len
= strlen(prefix
);
21 return strncmp(str
, prefix
, len
) ? NULL
: str
+ len
;
24 static int opterror(const struct option
*opt
, const char *reason
, int flags
)
26 if (flags
& OPT_SHORT
)
27 return error("switch `%c' %s", opt
->short_name
, reason
);
28 if (flags
& OPT_UNSET
)
29 return error("option `no-%s' %s", opt
->long_name
, reason
);
30 return error("option `%s' %s", opt
->long_name
, reason
);
33 static int get_value(struct parse_opt_ctx_t
*p
,
34 const struct option
*opt
, int flags
)
37 const int unset
= flags
& OPT_UNSET
;
40 return opterror(opt
, "takes no value", flags
);
41 if (unset
&& (opt
->flags
& PARSE_OPT_NONEG
))
42 return opterror(opt
, "isn't available", flags
);
44 if (!(flags
& OPT_SHORT
) && p
->opt
) {
47 if (!(opt
->flags
& PARSE_OPT_NOARG
))
54 return opterror(opt
, "takes no value", flags
);
60 arg
= p
->opt
? p
->opt
: (p
->argc
> 1 ? p
->argv
[1] : NULL
);
64 *(int *)opt
->value
&= ~opt
->defval
;
66 *(int *)opt
->value
|= opt
->defval
;
70 *(int *)opt
->value
= unset
? 0 : *(int *)opt
->value
+ 1;
74 *(int *)opt
->value
= unset
? 0 : opt
->defval
;
78 *(void **)opt
->value
= unset
? NULL
: (void *)opt
->defval
;
83 *(const char **)opt
->value
= NULL
;
86 if (opt
->flags
& PARSE_OPT_OPTARG
&& !p
->opt
) {
87 *(const char **)opt
->value
= (const char *)opt
->defval
;
91 return opterror(opt
, "requires a value", flags
);
92 *(const char **)opt
->value
= get_arg(p
);
97 return (*opt
->callback
)(opt
, NULL
, 1);
98 if (opt
->flags
& PARSE_OPT_NOARG
)
99 return (*opt
->callback
)(opt
, NULL
, 0);
100 if (opt
->flags
& PARSE_OPT_OPTARG
&& !p
->opt
)
101 return (*opt
->callback
)(opt
, NULL
, 0);
103 return opterror(opt
, "requires a value", flags
);
104 return (*opt
->callback
)(opt
, get_arg(p
), 0);
108 *(int *)opt
->value
= 0;
111 if (opt
->flags
& PARSE_OPT_OPTARG
&& !p
->opt
) {
112 *(int *)opt
->value
= opt
->defval
;
116 return opterror(opt
, "requires a value", flags
);
117 *(int *)opt
->value
= strtol(get_arg(p
), (char **)&s
, 10);
119 return opterror(opt
, "expects a numerical value", flags
);
123 die("should not happen, someone must be hit on the forehead");
127 static int parse_short_opt(struct parse_opt_ctx_t
*p
, const struct option
*options
)
129 for (; options
->type
!= OPTION_END
; options
++) {
130 if (options
->short_name
== *p
->opt
) {
131 p
->opt
= p
->opt
[1] ? p
->opt
+ 1 : NULL
;
132 return get_value(p
, options
, OPT_SHORT
);
135 return error("unknown switch `%c'", *p
->opt
);
138 static int parse_long_opt(struct parse_opt_ctx_t
*p
, const char *arg
,
139 const struct option
*options
)
141 const char *arg_end
= strchr(arg
, '=');
142 const struct option
*abbrev_option
= NULL
, *ambiguous_option
= NULL
;
143 int abbrev_flags
= 0, ambiguous_flags
= 0;
146 arg_end
= arg
+ strlen(arg
);
148 for (; options
->type
!= OPTION_END
; options
++) {
152 if (!options
->long_name
)
155 rest
= skip_prefix(arg
, options
->long_name
);
156 if (options
->type
== OPTION_ARGUMENT
) {
160 return opterror(options
, "takes no value", flags
);
163 p
->out
[p
->cpidx
++] = arg
- 2;
168 if (!strncmp(options
->long_name
, arg
, arg_end
- arg
)) {
172 * If this is abbreviated, it is
173 * ambiguous. So when there is no
174 * exact match later, we need to
177 ambiguous_option
= abbrev_option
;
178 ambiguous_flags
= abbrev_flags
;
180 if (!(flags
& OPT_UNSET
) && *arg_end
)
181 p
->opt
= arg_end
+ 1;
182 abbrev_option
= options
;
183 abbrev_flags
= flags
;
186 /* negated and abbreviated very much? */
187 if (!prefixcmp("no-", arg
)) {
192 if (strncmp(arg
, "no-", 3))
195 rest
= skip_prefix(arg
+ 3, options
->long_name
);
196 /* abbreviated and negated? */
197 if (!rest
&& !prefixcmp(options
->long_name
, arg
+ 3))
207 return get_value(p
, options
, flags
);
210 if (ambiguous_option
)
211 return error("Ambiguous option: %s "
212 "(could be --%s%s or --%s%s)",
214 (ambiguous_flags
& OPT_UNSET
) ? "no-" : "",
215 ambiguous_option
->long_name
,
216 (abbrev_flags
& OPT_UNSET
) ? "no-" : "",
217 abbrev_option
->long_name
);
219 return get_value(p
, abbrev_option
, abbrev_flags
);
220 return error("unknown option `%s'", arg
);
223 void check_typos(const char *arg
, const struct option
*options
)
228 if (!prefixcmp(arg
, "no-")) {
229 error ("did you mean `--%s` (with two dashes ?)", arg
);
233 for (; options
->type
!= OPTION_END
; options
++) {
234 if (!options
->long_name
)
236 if (!prefixcmp(options
->long_name
, arg
)) {
237 error ("did you mean `--%s` (with two dashes ?)", arg
);
243 void parse_options_start(struct parse_opt_ctx_t
*ctx
,
244 int argc
, const char **argv
, int flags
)
246 memset(ctx
, 0, sizeof(*ctx
));
247 ctx
->argc
= argc
- 1;
248 ctx
->argv
= argv
+ 1;
253 int parse_options_end(struct parse_opt_ctx_t
*ctx
)
255 memmove(ctx
->out
+ ctx
->cpidx
, ctx
->argv
, ctx
->argc
* sizeof(*ctx
->out
));
256 ctx
->out
[ctx
->cpidx
+ ctx
->argc
] = NULL
;
257 return ctx
->cpidx
+ ctx
->argc
;
260 static int usage_with_options_internal(const char * const *,
261 const struct option
*, int, int);
263 int parse_options(int argc
, const char **argv
, const struct option
*options
,
264 const char * const usagestr
[], int flags
)
266 struct parse_opt_ctx_t ctx
;
268 parse_options_start(&ctx
, argc
, argv
, flags
);
269 for (; ctx
.argc
; ctx
.argc
--, ctx
.argv
++) {
270 const char *arg
= ctx
.argv
[0];
272 if (*arg
!= '-' || !arg
[1]) {
273 if (ctx
.flags
& PARSE_OPT_STOP_AT_NON_OPTION
)
275 ctx
.out
[ctx
.cpidx
++] = ctx
.argv
[0];
282 usage_with_options(usagestr
, options
);
283 if (parse_short_opt(&ctx
, options
) < 0)
284 usage_with_options(usagestr
, options
);
286 check_typos(arg
+ 1, options
);
289 usage_with_options(usagestr
, options
);
290 if (parse_short_opt(&ctx
, options
) < 0)
291 usage_with_options(usagestr
, options
);
296 if (!arg
[2]) { /* "--" */
297 if (!(ctx
.flags
& PARSE_OPT_KEEP_DASHDASH
)) {
304 if (!strcmp(arg
+ 2, "help-all"))
305 usage_with_options_internal(usagestr
, options
, 1, 1);
306 if (!strcmp(arg
+ 2, "help"))
307 usage_with_options(usagestr
, options
);
308 if (parse_long_opt(&ctx
, arg
+ 2, options
))
309 usage_with_options(usagestr
, options
);
312 return parse_options_end(&ctx
);
315 #define USAGE_OPTS_WIDTH 24
318 int usage_with_options_internal(const char * const *usagestr
,
319 const struct option
*opts
, int full
, int do_exit
)
321 fprintf(stderr
, "usage: %s\n", *usagestr
++);
322 while (*usagestr
&& **usagestr
)
323 fprintf(stderr
, " or: %s\n", *usagestr
++);
325 fprintf(stderr
, "%s%s\n",
326 **usagestr
? " " : "",
331 if (opts
->type
!= OPTION_GROUP
)
334 for (; opts
->type
!= OPTION_END
; opts
++) {
338 if (opts
->type
== OPTION_GROUP
) {
341 fprintf(stderr
, "%s\n", opts
->help
);
344 if (!full
&& (opts
->flags
& PARSE_OPT_HIDDEN
))
347 pos
= fprintf(stderr
, " ");
348 if (opts
->short_name
)
349 pos
+= fprintf(stderr
, "-%c", opts
->short_name
);
350 if (opts
->long_name
&& opts
->short_name
)
351 pos
+= fprintf(stderr
, ", ");
353 pos
+= fprintf(stderr
, "--%s", opts
->long_name
);
355 switch (opts
->type
) {
356 case OPTION_ARGUMENT
:
359 if (opts
->flags
& PARSE_OPT_OPTARG
)
361 pos
+= fprintf(stderr
, "[=<n>]");
363 pos
+= fprintf(stderr
, "[<n>]");
365 pos
+= fprintf(stderr
, " <n>");
367 case OPTION_CALLBACK
:
368 if (opts
->flags
& PARSE_OPT_NOARG
)
373 if (opts
->flags
& PARSE_OPT_OPTARG
)
375 pos
+= fprintf(stderr
, "[=<%s>]", opts
->argh
);
377 pos
+= fprintf(stderr
, "[<%s>]", opts
->argh
);
379 pos
+= fprintf(stderr
, " <%s>", opts
->argh
);
381 if (opts
->flags
& PARSE_OPT_OPTARG
)
383 pos
+= fprintf(stderr
, "[=...]");
385 pos
+= fprintf(stderr
, "[...]");
387 pos
+= fprintf(stderr
, " ...");
390 default: /* OPTION_{BIT,BOOLEAN,SET_INT,SET_PTR} */
394 if (pos
<= USAGE_OPTS_WIDTH
)
395 pad
= USAGE_OPTS_WIDTH
- pos
;
398 pad
= USAGE_OPTS_WIDTH
;
400 fprintf(stderr
, "%*s%s\n", pad
+ USAGE_GAP
, "", opts
->help
);
406 return PARSE_OPT_HELP
;
409 void usage_with_options(const char * const *usagestr
,
410 const struct option
*opts
)
412 usage_with_options_internal(usagestr
, opts
, 0, 1);
413 exit(129); /* make gcc happy */
416 int parse_options_usage(const char * const *usagestr
,
417 const struct option
*opts
)
419 return usage_with_options_internal(usagestr
, opts
, 0, 0);
423 /*----- some often used options -----*/
426 int parse_opt_abbrev_cb(const struct option
*opt
, const char *arg
, int unset
)
431 v
= unset
? 0 : DEFAULT_ABBREV
;
433 v
= strtol(arg
, (char **)&arg
, 10);
435 return opterror(opt
, "expects a numerical value", 0);
436 if (v
&& v
< MINIMUM_ABBREV
)
441 *(int *)(opt
->value
) = v
;
445 int parse_opt_approxidate_cb(const struct option
*opt
, const char *arg
,
448 *(unsigned long *)(opt
->value
) = approxidate(arg
);