Annotation of /trunk/mkinitrd-magellan/busybox/libbb/getopt32.c
Parent Directory | Revision Log
Revision 816 -
(hide annotations)
(download)
Fri Apr 24 18:33:46 2009 UTC (15 years, 1 month ago) by niro
File MIME type: text/plain
File size: 18967 byte(s)
Fri Apr 24 18:33:46 2009 UTC (15 years, 1 month ago) by niro
File MIME type: text/plain
File size: 18967 byte(s)
-updated to busybox-1.13.4
1 | niro | 532 | /* vi: set sw=4 ts=4: */ |
2 | /* | ||
3 | * universal getopt32 implementation for busybox | ||
4 | * | ||
5 | * Copyright (C) 2003-2005 Vladimir Oleynik <dzo@simtreas.ru> | ||
6 | * | ||
7 | * Licensed under GPLv2 or later, see file LICENSE in this tarball for details. | ||
8 | */ | ||
9 | |||
10 | niro | 816 | #include <getopt.h> |
11 | niro | 532 | #include "libbb.h" |
12 | |||
13 | /* Documentation | ||
14 | |||
15 | uint32_t | ||
16 | niro | 816 | getopt32(char **argv, const char *applet_opts, ...) |
17 | niro | 532 | |
18 | The command line options must be declared in const char | ||
19 | *applet_opts as a string of chars, for example: | ||
20 | |||
21 | niro | 816 | flags = getopt32(argv, "rnug"); |
22 | niro | 532 | |
23 | If one of the given options is found, a flag value is added to | ||
24 | the return value (an unsigned long). | ||
25 | |||
26 | The flag value is determined by the position of the char in | ||
27 | applet_opts string. For example, in the above case: | ||
28 | |||
29 | niro | 816 | flags = getopt32(argv, "rnug"); |
30 | niro | 532 | |
31 | "r" will add 1 (bit 0) | ||
32 | "n" will add 2 (bit 1) | ||
33 | niro | 816 | "u" will add 4 (bit 2) |
34 | niro | 532 | "g" will add 8 (bit 3) |
35 | |||
36 | and so on. You can also look at the return value as a bit | ||
37 | field and each option sets one bit. | ||
38 | |||
39 | On exit, global variable optind is set so that if you | ||
40 | will do argc -= optind; argv += optind; then | ||
41 | argc will be equal to number of remaining non-option | ||
42 | arguments, first one would be in argv[0], next in argv[1] and so on | ||
43 | (options and their parameters will be moved into argv[] | ||
44 | positions prior to argv[optind]). | ||
45 | |||
46 | ":" If one of the options requires an argument, then add a ":" | ||
47 | after the char in applet_opts and provide a pointer to store | ||
48 | the argument. For example: | ||
49 | |||
50 | char *pointer_to_arg_for_a; | ||
51 | char *pointer_to_arg_for_b; | ||
52 | char *pointer_to_arg_for_c; | ||
53 | char *pointer_to_arg_for_d; | ||
54 | |||
55 | niro | 816 | flags = getopt32(argv, "a:b:c:d:", |
56 | &pointer_to_arg_for_a, &pointer_to_arg_for_b, | ||
57 | &pointer_to_arg_for_c, &pointer_to_arg_for_d); | ||
58 | niro | 532 | |
59 | The type of the pointer (char* or llist_t*) may be controlled | ||
60 | by the "::" special separator that is set in the external string | ||
61 | opt_complementary (see below for more info). | ||
62 | |||
63 | "::" If option can have an *optional* argument, then add a "::" | ||
64 | after its char in applet_opts and provide a pointer to store | ||
65 | the argument. Note that optional arguments _must_ | ||
66 | immediately follow the option: -oparam, not -o param. | ||
67 | |||
68 | "+" If the first character in the applet_opts string is a plus, | ||
69 | then option processing will stop as soon as a non-option is | ||
70 | encountered in the argv array. Useful for applets like env | ||
71 | which should not process arguments to subprograms: | ||
72 | env -i ls -d / | ||
73 | Here we want env to process just the '-i', not the '-d'. | ||
74 | |||
75 | niro | 816 | const char *applet_long_options |
76 | niro | 532 | |
77 | niro | 816 | This struct allows you to define long options: |
78 | niro | 532 | |
79 | niro | 816 | static const char applet_longopts[] ALIGN1 = |
80 | //"name\0" has_arg val | ||
81 | "verbose\0" No_argument "v" | ||
82 | ; | ||
83 | applet_long_options = applet_longopts; | ||
84 | niro | 532 | |
85 | The last member of struct option (val) typically is set to | ||
86 | matching short option from applet_opts. If there is no matching | ||
87 | char in applet_opts, then: | ||
88 | - return bit have next position after short options | ||
89 | niro | 816 | - if has_arg is not "No_argument", use ptr for arg also |
90 | niro | 532 | - opt_complementary affects it too |
91 | |||
92 | Note: a good applet will make long options configurable via the | ||
93 | config process and not a required feature. The current standard | ||
94 | is to name the config option CONFIG_FEATURE_<applet>_LONG_OPTIONS. | ||
95 | |||
96 | const char *opt_complementary | ||
97 | |||
98 | ":" The colon (":") is used to separate groups of two or more chars | ||
99 | and/or groups of chars and special characters (stating some | ||
100 | conditions to be checked). | ||
101 | |||
102 | "abc" If groups of two or more chars are specified, the first char | ||
103 | is the main option and the other chars are secondary options. | ||
104 | Their flags will be turned on if the main option is found even | ||
105 | if they are not specifed on the command line. For example: | ||
106 | |||
107 | opt_complementary = "abc"; | ||
108 | niro | 816 | flags = getopt32(argv, "abcd") |
109 | niro | 532 | |
110 | If getopt() finds "-a" on the command line, then | ||
111 | getopt32's return value will be as if "-a -b -c" were | ||
112 | found. | ||
113 | |||
114 | "ww" Adjacent double options have a counter associated which indicates | ||
115 | the number of occurences of the option. | ||
116 | For example the ps applet needs: | ||
117 | if w is given once, GNU ps sets the width to 132, | ||
118 | if w is given more than once, it is "unlimited" | ||
119 | |||
120 | niro | 816 | int w_counter = 0; // must be initialized! |
121 | niro | 532 | opt_complementary = "ww"; |
122 | niro | 816 | getopt32(argv, "w", &w_counter); |
123 | niro | 532 | if (w_counter) |
124 | niro | 816 | width = (w_counter == 1) ? 132 : INT_MAX; |
125 | niro | 532 | else |
126 | niro | 816 | get_terminal_width(...&width...); |
127 | niro | 532 | |
128 | w_counter is a pointer to an integer. It has to be passed to | ||
129 | getopt32() after all other option argument sinks. | ||
130 | |||
131 | For example: accept multiple -v to indicate the level of verbosity | ||
132 | and for each -b optarg, add optarg to my_b. Finally, if b is given, | ||
133 | turn off c and vice versa: | ||
134 | |||
135 | llist_t *my_b = NULL; | ||
136 | int verbose_level = 0; | ||
137 | opt_complementary = "vv:b::b-c:c-b"; | ||
138 | niro | 816 | f = getopt32(argv, "vb:c", &my_b, &verbose_level); |
139 | niro | 532 | if (f & 2) // -c after -b unsets -b flag |
140 | niro | 816 | while (my_b) dosomething_with(llist_pop(&my_b)); |
141 | niro | 532 | if (my_b) // but llist is stored if -b is specified |
142 | niro | 816 | free_llist(my_b); |
143 | niro | 532 | if (verbose_level) printf("verbose level is %d\n", verbose_level); |
144 | |||
145 | Special characters: | ||
146 | |||
147 | "-" A dash as the first char in a opt_complementary group forces | ||
148 | all arguments to be treated as options, even if they have | ||
149 | no leading dashes. Next char in this case can't be a digit (0-9), | ||
150 | use ':' or end of line. For example: | ||
151 | |||
152 | opt_complementary = "-:w-x:x-w"; | ||
153 | niro | 816 | getopt32(argv, "wx"); |
154 | niro | 532 | |
155 | Allows any arguments to be given without a dash (./program w x) | ||
156 | as well as with a dash (./program -x). | ||
157 | |||
158 | niro | 816 | NB: getopt32() will leak a small amount of memory if you use |
159 | this option! Do not use it if there is a possibility of recursive | ||
160 | getopt32() calls. | ||
161 | |||
162 | niro | 532 | "--" A double dash at the beginning of opt_complementary means the |
163 | argv[1] string should always be treated as options, even if it isn't | ||
164 | prefixed with a "-". This is useful for special syntax in applets | ||
165 | such as "ar" and "tar": | ||
166 | tar xvf foo.tar | ||
167 | |||
168 | niro | 816 | NB: getopt32() will leak a small amount of memory if you use |
169 | this option! Do not use it if there is a possibility of recursive | ||
170 | getopt32() calls. | ||
171 | |||
172 | niro | 532 | "-N" A dash as the first char in a opt_complementary group followed |
173 | by a single digit (0-9) means that at least N non-option | ||
174 | arguments must be present on the command line | ||
175 | |||
176 | "=N" An equal sign as the first char in a opt_complementary group followed | ||
177 | by a single digit (0-9) means that exactly N non-option | ||
178 | arguments must be present on the command line | ||
179 | |||
180 | "?N" A "?" as the first char in a opt_complementary group followed | ||
181 | by a single digit (0-9) means that at most N arguments must be present | ||
182 | on the command line. | ||
183 | |||
184 | "V-" An option with dash before colon or end-of-line results in | ||
185 | niro | 816 | bb_show_usage() being called if this option is encountered. |
186 | niro | 532 | This is typically used to implement "print verbose usage message |
187 | and exit" option. | ||
188 | |||
189 | niro | 816 | "a-b" A dash between two options causes the second of the two |
190 | niro | 532 | to be unset (and ignored) if it is given on the command line. |
191 | |||
192 | [FIXME: what if they are the same? like "x-x"? Is it ever useful?] | ||
193 | |||
194 | For example: | ||
195 | The du applet has the options "-s" and "-d depth". If | ||
196 | getopt32 finds -s, then -d is unset or if it finds -d | ||
197 | then -s is unset. (Note: busybox implements the GNU | ||
198 | "--max-depth" option as "-d".) To obtain this behavior, you | ||
199 | set opt_complementary = "s-d:d-s". Only one flag value is | ||
200 | added to getopt32's return value depending on the | ||
201 | position of the options on the command line. If one of the | ||
202 | two options requires an argument pointer (":" in applet_opts | ||
203 | as in "d:") optarg is set accordingly. | ||
204 | |||
205 | char *smax_print_depth; | ||
206 | |||
207 | opt_complementary = "s-d:d-s:x-x"; | ||
208 | niro | 816 | opt = getopt32(argv, "sd:x", &smax_print_depth); |
209 | niro | 532 | |
210 | if (opt & 2) | ||
211 | niro | 816 | max_print_depth = atoi(smax_print_depth); |
212 | niro | 532 | if (opt & 4) |
213 | niro | 816 | printf("Detected odd -x usage\n"); |
214 | niro | 532 | |
215 | niro | 816 | "a--b" A double dash between two options, or between an option and a group |
216 | niro | 532 | of options, means that they are mutually exclusive. Unlike |
217 | the "-" case above, an error will be forced if the options | ||
218 | are used together. | ||
219 | |||
220 | For example: | ||
221 | The cut applet must have only one type of list specified, so | ||
222 | niro | 816 | -b, -c and -f are mutually exclusive and should raise an error |
223 | niro | 532 | if specified together. In this case you must set |
224 | opt_complementary = "b--cf:c--bf:f--bc". If two of the | ||
225 | niro | 816 | mutually exclusive options are found, getopt32 will call |
226 | bb_show_usage() and die. | ||
227 | niro | 532 | |
228 | "x--x" Variation of the above, it means that -x option should occur | ||
229 | at most once. | ||
230 | |||
231 | niro | 816 | "a+" A plus after a char in opt_complementary means that the parameter |
232 | for this option is a nonnegative integer. It will be processed | ||
233 | with xatoi_u() - allowed range is 0..INT_MAX. | ||
234 | niro | 532 | |
235 | niro | 816 | int param; // "unsigned param;" will also work |
236 | opt_complementary = "p+"; | ||
237 | getopt32(argv, "p:", ¶m); | ||
238 | |||
239 | "a::" A double colon after a char in opt_complementary means that the | ||
240 | niro | 532 | option can occur multiple times. Each occurrence will be saved as |
241 | a llist_t element instead of char*. | ||
242 | |||
243 | For example: | ||
244 | The grep applet can have one or more "-e pattern" arguments. | ||
245 | In this case you should use getopt32() as follows: | ||
246 | |||
247 | llist_t *patterns = NULL; | ||
248 | |||
249 | (this pointer must be initializated to NULL if the list is empty | ||
250 | niro | 816 | as required by llist_add_to_end(llist_t **old_head, char *new_item).) |
251 | niro | 532 | |
252 | opt_complementary = "e::"; | ||
253 | |||
254 | niro | 816 | getopt32(argv, "e:", &patterns); |
255 | niro | 532 | $ grep -e user -e root /etc/passwd |
256 | root:x:0:0:root:/root:/bin/bash | ||
257 | user:x:500:500::/home/user:/bin/bash | ||
258 | |||
259 | niro | 816 | "a?b" A "?" between an option and a group of options means that |
260 | niro | 532 | at least one of them is required to occur if the first option |
261 | occurs in preceding command line arguments. | ||
262 | |||
263 | For example from "id" applet: | ||
264 | |||
265 | // Don't allow -n -r -rn -ug -rug -nug -rnug | ||
266 | niro | 816 | opt_complementary = "r?ug:n?ug:u--g:g--u"; |
267 | flags = getopt32(argv, "rnug"); | ||
268 | niro | 532 | |
269 | This example allowed only: | ||
270 | $ id; id -u; id -g; id -ru; id -nu; id -rg; id -ng; id -rnu; id -rng | ||
271 | |||
272 | "X" A opt_complementary group with just a single letter means | ||
273 | that this option is required. If more than one such group exists, | ||
274 | at least one option is required to occur (not all of them). | ||
275 | For example from "start-stop-daemon" applet: | ||
276 | |||
277 | // Don't allow -KS -SK, but -S or -K is required | ||
278 | niro | 816 | opt_complementary = "K:S:K--S:S--K"; |
279 | flags = getopt32(argv, "KS...); | ||
280 | niro | 532 | |
281 | |||
282 | Don't forget to use ':'. For example, "?322-22-23X-x-a" | ||
283 | is interpreted as "?3:22:-2:2-2:2-3Xa:2--x" - | ||
284 | max 3 args; count uses of '-2'; min 2 args; if there is | ||
285 | a '-2' option then unset '-3', '-X' and '-a'; if there is | ||
286 | a '-2' and after it a '-x' then error out. | ||
287 | niro | 816 | But it's far too obfuscated. Use ':' to separate groups. |
288 | niro | 532 | */ |
289 | |||
290 | /* Code here assumes that 'unsigned' is at least 32 bits wide */ | ||
291 | |||
292 | niro | 816 | const char *const bb_argv_dash[] = { "-", NULL }; |
293 | |||
294 | niro | 532 | const char *opt_complementary; |
295 | |||
296 | niro | 816 | enum { |
297 | PARAM_STRING, | ||
298 | PARAM_LIST, | ||
299 | PARAM_INT, | ||
300 | }; | ||
301 | |||
302 | niro | 532 | typedef struct { |
303 | niro | 816 | unsigned char opt_char; |
304 | smallint param_type; | ||
305 | niro | 532 | unsigned switch_on; |
306 | unsigned switch_off; | ||
307 | unsigned incongruously; | ||
308 | unsigned requires; | ||
309 | niro | 816 | void **optarg; /* char**, llist_t** or int *. */ |
310 | niro | 532 | int *counter; |
311 | } t_complementary; | ||
312 | |||
313 | /* You can set applet_long_options for parse called long options */ | ||
314 | #if ENABLE_GETOPT_LONG | ||
315 | niro | 816 | static const struct option bb_null_long_options[1] = { |
316 | niro | 532 | { 0, 0, 0, 0 } |
317 | }; | ||
318 | niro | 816 | const char *applet_long_options; |
319 | niro | 532 | #endif |
320 | |||
321 | uint32_t option_mask32; | ||
322 | |||
323 | niro | 816 | uint32_t FAST_FUNC |
324 | getopt32(char **argv, const char *applet_opts, ...) | ||
325 | niro | 532 | { |
326 | niro | 816 | int argc; |
327 | niro | 532 | unsigned flags = 0; |
328 | unsigned requires = 0; | ||
329 | niro | 816 | t_complementary complementary[33]; /* last stays zero-filled */ |
330 | niro | 532 | int c; |
331 | const unsigned char *s; | ||
332 | t_complementary *on_off; | ||
333 | va_list p; | ||
334 | #if ENABLE_GETOPT_LONG | ||
335 | const struct option *l_o; | ||
336 | niro | 816 | struct option *long_options = (struct option *) &bb_null_long_options; |
337 | niro | 532 | #endif |
338 | unsigned trigger; | ||
339 | niro | 816 | char **pargv; |
340 | niro | 532 | int min_arg = 0; |
341 | int max_arg = -1; | ||
342 | |||
343 | #define SHOW_USAGE_IF_ERROR 1 | ||
344 | #define ALL_ARGV_IS_OPTS 2 | ||
345 | #define FIRST_ARGV_IS_OPT 4 | ||
346 | niro | 816 | |
347 | niro | 532 | int spec_flgs = 0; |
348 | |||
349 | niro | 816 | /* skip 0: some applets cheat: they do not actually HAVE argv[0] */ |
350 | argc = 1; | ||
351 | while (argv[argc]) | ||
352 | argc++; | ||
353 | |||
354 | niro | 532 | va_start(p, applet_opts); |
355 | |||
356 | c = 0; | ||
357 | on_off = complementary; | ||
358 | memset(on_off, 0, sizeof(complementary)); | ||
359 | |||
360 | /* skip GNU extension */ | ||
361 | s = (const unsigned char *)applet_opts; | ||
362 | if (*s == '+' || *s == '-') | ||
363 | s++; | ||
364 | while (*s) { | ||
365 | niro | 816 | if (c >= 32) |
366 | break; | ||
367 | on_off->opt_char = *s; | ||
368 | niro | 532 | on_off->switch_on = (1 << c); |
369 | if (*++s == ':') { | ||
370 | on_off->optarg = va_arg(p, void **); | ||
371 | niro | 816 | while (*++s == ':') |
372 | continue; | ||
373 | niro | 532 | } |
374 | on_off++; | ||
375 | c++; | ||
376 | } | ||
377 | |||
378 | #if ENABLE_GETOPT_LONG | ||
379 | niro | 816 | if (applet_long_options) { |
380 | const char *optstr; | ||
381 | unsigned i, count; | ||
382 | |||
383 | count = 1; | ||
384 | optstr = applet_long_options; | ||
385 | while (optstr[0]) { | ||
386 | optstr += strlen(optstr) + 3; /* skip NUL, has_arg, val */ | ||
387 | count++; | ||
388 | } | ||
389 | /* count == no. of longopts + 1 */ | ||
390 | long_options = alloca(count * sizeof(*long_options)); | ||
391 | memset(long_options, 0, count * sizeof(*long_options)); | ||
392 | i = 0; | ||
393 | optstr = applet_long_options; | ||
394 | while (--count) { | ||
395 | long_options[i].name = optstr; | ||
396 | optstr += strlen(optstr) + 1; | ||
397 | long_options[i].has_arg = (unsigned char)(*optstr++); | ||
398 | /* long_options[i].flag = NULL; */ | ||
399 | long_options[i].val = (unsigned char)(*optstr++); | ||
400 | i++; | ||
401 | } | ||
402 | for (l_o = long_options; l_o->name; l_o++) { | ||
403 | if (l_o->flag) | ||
404 | continue; | ||
405 | for (on_off = complementary; on_off->opt_char; on_off++) | ||
406 | if (on_off->opt_char == l_o->val) | ||
407 | goto next_long; | ||
408 | if (c >= 32) | ||
409 | break; | ||
410 | on_off->opt_char = l_o->val; | ||
411 | on_off->switch_on = (1 << c); | ||
412 | if (l_o->has_arg != no_argument) | ||
413 | on_off->optarg = va_arg(p, void **); | ||
414 | c++; | ||
415 | niro | 532 | next_long: ; |
416 | niro | 816 | } |
417 | niro | 532 | } |
418 | #endif /* ENABLE_GETOPT_LONG */ | ||
419 | for (s = (const unsigned char *)opt_complementary; s && *s; s++) { | ||
420 | t_complementary *pair; | ||
421 | unsigned *pair_switch; | ||
422 | |||
423 | if (*s == ':') | ||
424 | continue; | ||
425 | c = s[1]; | ||
426 | if (*s == '?') { | ||
427 | if (c < '0' || c > '9') { | ||
428 | spec_flgs |= SHOW_USAGE_IF_ERROR; | ||
429 | } else { | ||
430 | max_arg = c - '0'; | ||
431 | s++; | ||
432 | } | ||
433 | continue; | ||
434 | } | ||
435 | if (*s == '-') { | ||
436 | if (c < '0' || c > '9') { | ||
437 | if (c == '-') { | ||
438 | spec_flgs |= FIRST_ARGV_IS_OPT; | ||
439 | s++; | ||
440 | } else | ||
441 | spec_flgs |= ALL_ARGV_IS_OPTS; | ||
442 | } else { | ||
443 | min_arg = c - '0'; | ||
444 | s++; | ||
445 | } | ||
446 | continue; | ||
447 | } | ||
448 | if (*s == '=') { | ||
449 | min_arg = max_arg = c - '0'; | ||
450 | s++; | ||
451 | continue; | ||
452 | } | ||
453 | niro | 816 | for (on_off = complementary; on_off->opt_char; on_off++) |
454 | if (on_off->opt_char == *s) | ||
455 | niro | 532 | break; |
456 | if (c == ':' && s[2] == ':') { | ||
457 | niro | 816 | on_off->param_type = PARAM_LIST; |
458 | niro | 532 | continue; |
459 | } | ||
460 | niro | 816 | if (c == '+' && (s[2] == ':' || s[2] == '\0')) { |
461 | on_off->param_type = PARAM_INT; | ||
462 | continue; | ||
463 | } | ||
464 | niro | 532 | if (c == ':' || c == '\0') { |
465 | requires |= on_off->switch_on; | ||
466 | continue; | ||
467 | } | ||
468 | if (c == '-' && (s[2] == ':' || s[2] == '\0')) { | ||
469 | flags |= on_off->switch_on; | ||
470 | on_off->incongruously |= on_off->switch_on; | ||
471 | s++; | ||
472 | continue; | ||
473 | } | ||
474 | if (c == *s) { | ||
475 | on_off->counter = va_arg(p, int *); | ||
476 | s++; | ||
477 | } | ||
478 | pair = on_off; | ||
479 | pair_switch = &(pair->switch_on); | ||
480 | for (s++; *s && *s != ':'; s++) { | ||
481 | if (*s == '?') { | ||
482 | pair_switch = &(pair->requires); | ||
483 | } else if (*s == '-') { | ||
484 | if (pair_switch == &(pair->switch_off)) | ||
485 | pair_switch = &(pair->incongruously); | ||
486 | else | ||
487 | pair_switch = &(pair->switch_off); | ||
488 | } else { | ||
489 | niro | 816 | for (on_off = complementary; on_off->opt_char; on_off++) |
490 | if (on_off->opt_char == *s) { | ||
491 | niro | 532 | *pair_switch |= on_off->switch_on; |
492 | break; | ||
493 | } | ||
494 | } | ||
495 | } | ||
496 | s--; | ||
497 | } | ||
498 | niro | 816 | va_end(p); |
499 | niro | 532 | |
500 | niro | 816 | if (spec_flgs & (FIRST_ARGV_IS_OPT | ALL_ARGV_IS_OPTS)) { |
501 | pargv = argv + 1; | ||
502 | while (*pargv) { | ||
503 | if (pargv[0][0] != '-' && pargv[0][0] != '\0') { | ||
504 | /* Can't use alloca: opts with params will | ||
505 | * return pointers to stack! | ||
506 | * NB: we leak these allocations... */ | ||
507 | char *pp = xmalloc(strlen(*pargv) + 2); | ||
508 | *pp = '-'; | ||
509 | strcpy(pp + 1, *pargv); | ||
510 | *pargv = pp; | ||
511 | } | ||
512 | if (!(spec_flgs & ALL_ARGV_IS_OPTS)) | ||
513 | break; | ||
514 | pargv++; | ||
515 | niro | 532 | } |
516 | } | ||
517 | niro | 816 | |
518 | /* In case getopt32 was already called: | ||
519 | * reset the libc getopt() function, which keeps internal state. | ||
520 | * run_nofork_applet_prime() does this, but we might end up here | ||
521 | * also via gunzip_main() -> gzip_main(). Play safe. | ||
522 | */ | ||
523 | #ifdef __GLIBC__ | ||
524 | optind = 0; | ||
525 | #else /* BSD style */ | ||
526 | optind = 1; | ||
527 | /* optreset = 1; */ | ||
528 | #endif | ||
529 | /* optarg = NULL; opterr = 0; optopt = 0; - do we need this?? */ | ||
530 | |||
531 | pargv = NULL; | ||
532 | |||
533 | /* Note: just "getopt() <= 0" will not work well for | ||
534 | niro | 532 | * "fake" short options, like this one: |
535 | * wget $'-\203' "Test: test" http://kernel.org/ | ||
536 | * (supposed to act as --header, but doesn't) */ | ||
537 | #if ENABLE_GETOPT_LONG | ||
538 | while ((c = getopt_long(argc, argv, applet_opts, | ||
539 | niro | 816 | long_options, NULL)) != -1) { |
540 | niro | 532 | #else |
541 | while ((c = getopt(argc, argv, applet_opts)) != -1) { | ||
542 | niro | 816 | #endif |
543 | /* getopt prints "option requires an argument -- X" | ||
544 | * and returns '?' if an option has no arg, but one is reqd */ | ||
545 | c &= 0xff; /* fight libc's sign extension */ | ||
546 | for (on_off = complementary; on_off->opt_char != c; on_off++) { | ||
547 | /* c can be NUL if long opt has non-NULL ->flag, | ||
548 | * but we construct long opts so that flag | ||
549 | * is always NULL (see above) */ | ||
550 | if (on_off->opt_char == '\0' /* && c != '\0' */) { | ||
551 | /* c is probably '?' - "bad option" */ | ||
552 | niro | 532 | bb_show_usage(); |
553 | niro | 816 | } |
554 | niro | 532 | } |
555 | niro | 816 | if (flags & on_off->incongruously) |
556 | bb_show_usage(); | ||
557 | niro | 532 | trigger = on_off->switch_on & on_off->switch_off; |
558 | flags &= ~(on_off->switch_off ^ trigger); | ||
559 | flags |= on_off->switch_on ^ trigger; | ||
560 | flags ^= trigger; | ||
561 | if (on_off->counter) | ||
562 | (*(on_off->counter))++; | ||
563 | niro | 816 | if (on_off->param_type == PARAM_LIST) { |
564 | if (optarg) | ||
565 | llist_add_to_end((llist_t **)(on_off->optarg), optarg); | ||
566 | } else if (on_off->param_type == PARAM_INT) { | ||
567 | if (optarg) | ||
568 | //TODO: xatoi_u indirectly pulls in printf machinery | ||
569 | *(unsigned*)(on_off->optarg) = xatoi_u(optarg); | ||
570 | niro | 532 | } else if (on_off->optarg) { |
571 | niro | 816 | if (optarg) |
572 | *(char **)(on_off->optarg) = optarg; | ||
573 | niro | 532 | } |
574 | if (pargv != NULL) | ||
575 | break; | ||
576 | } | ||
577 | |||
578 | /* check depending requires for given options */ | ||
579 | niro | 816 | for (on_off = complementary; on_off->opt_char; on_off++) { |
580 | niro | 532 | if (on_off->requires && (flags & on_off->switch_on) && |
581 | (flags & on_off->requires) == 0) | ||
582 | bb_show_usage(); | ||
583 | } | ||
584 | if (requires && (flags & requires) == 0) | ||
585 | bb_show_usage(); | ||
586 | argc -= optind; | ||
587 | if (argc < min_arg || (max_arg >= 0 && argc > max_arg)) | ||
588 | bb_show_usage(); | ||
589 | |||
590 | option_mask32 = flags; | ||
591 | return flags; | ||
592 | } |