source: MondoRescue/branches/2.2.5/mindi-busybox/util-linux/getopt.c @ 1765

Last change on this file since 1765 was 1765, checked in by Bruno Cornec, 13 years ago

Update to busybox 1.7.2

File size: 9.1 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * getopt.c - Enhanced implementation of BSD getopt(1)
4 *   Copyright (c) 1997, 1998, 1999, 2000  Frodo Looijaard <frodol@dds.nl>
5 *
6 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
7 */
8
9/*
10 * Version 1.0-b4: Tue Sep 23 1997. First public release.
11 * Version 1.0: Wed Nov 19 1997.
12 *   Bumped up the version number to 1.0
13 *   Fixed minor typo (CSH instead of TCSH)
14 * Version 1.0.1: Tue Jun 3 1998
15 *   Fixed sizeof instead of strlen bug
16 *   Bumped up the version number to 1.0.1
17 * Version 1.0.2: Thu Jun 11 1998 (not present)
18 *   Fixed gcc-2.8.1 warnings
19 *   Fixed --version/-V option (not present)
20 * Version 1.0.5: Tue Jun 22 1999
21 *   Make -u option work (not present)
22 * Version 1.0.6: Tue Jun 27 2000
23 *   No important changes
24 * Version 1.1.0: Tue Jun 30 2000
25 *   Added NLS support (partly written by Arkadiusz Mi<B6>kiewicz
26 *     <misiek@misiek.eu.org>)
27 * Ported to Busybox - Alfred M. Szmidt <ams@trillian.itslinux.org>
28 *  Removed --version/-V and --help/-h in
29 *  Removed parse_error(), using bb_error_msg() from Busybox instead
30 *  Replaced our_malloc with xmalloc and our_realloc with xrealloc
31 *
32 */
33
34#include <getopt.h>
35#include "libbb.h"
36
37/* NON_OPT is the code that is returned when a non-option is found in '+'
38   mode */
39enum {
40    NON_OPT = 1,
41#if ENABLE_GETOPT_LONG
42/* LONG_OPT is the code that is returned when a long option is found. */
43    LONG_OPT = 2
44#endif
45};
46
47/* For finding activated option flags. Must match getopt32 call! */
48enum {
49    OPT_o   = 0x1,  // -o
50    OPT_n   = 0x2,  // -n
51    OPT_q   = 0x4,  // -q
52    OPT_Q   = 0x8,  // -Q
53    OPT_s   = 0x10, // -s
54    OPT_T   = 0x20, // -T
55    OPT_u   = 0x40, // -u
56#if ENABLE_GETOPT_LONG
57    OPT_a   = 0x80, // -a
58    OPT_l   = 0x100, // -l
59#endif
60    SHELL_IS_TCSH = 0x8000, /* hijack this bit for other purposes */
61};
62
63/* 0 is getopt_long, 1 is getopt_long_only */
64#define alternative  (option_mask32 & OPT_a)
65
66#define quiet_errors (option_mask32 & OPT_q)
67#define quiet_output (option_mask32 & OPT_Q)
68#define quote        (!(option_mask32 & OPT_u))
69#define shell_TCSH   (option_mask32 & SHELL_IS_TCSH)
70
71/*
72 * This function 'normalizes' a single argument: it puts single quotes around
73 * it and escapes other special characters. If quote is false, it just
74 * returns its argument.
75 * Bash only needs special treatment for single quotes; tcsh also recognizes
76 * exclamation marks within single quotes, and nukes whitespace.
77 * This function returns a pointer to a buffer that is overwritten by
78 * each call.
79 */
80static const char *normalize(const char *arg)
81{
82    char *bufptr;
83#if ENABLE_FEATURE_CLEAN_UP
84    static char *BUFFER = NULL;
85    free(BUFFER);
86#else
87    char *BUFFER;
88#endif
89
90    if (!quote) { /* Just copy arg */
91        BUFFER = xstrdup(arg);
92        return BUFFER;
93    }
94
95    /* Each character in arg may take up to four characters in the result:
96       For a quote we need a closing quote, a backslash, a quote and an
97       opening quote! We need also the global opening and closing quote,
98       and one extra character for '\0'. */
99    BUFFER = xmalloc(strlen(arg)*4 + 3);
100
101    bufptr = BUFFER;
102    *bufptr ++= '\'';
103
104    while (*arg) {
105        if (*arg == '\'') {
106            /* Quote: replace it with: '\'' */
107            *bufptr ++= '\'';
108            *bufptr ++= '\\';
109            *bufptr ++= '\'';
110            *bufptr ++= '\'';
111        } else if (shell_TCSH && *arg == '!') {
112            /* Exclamation mark: replace it with: \! */
113            *bufptr ++= '\'';
114            *bufptr ++= '\\';
115            *bufptr ++= '!';
116            *bufptr ++= '\'';
117        } else if (shell_TCSH && *arg == '\n') {
118            /* Newline: replace it with: \n */
119            *bufptr ++= '\\';
120            *bufptr ++= 'n';
121        } else if (shell_TCSH && isspace(*arg)) {
122            /* Non-newline whitespace: replace it with \<ws> */
123            *bufptr ++= '\'';
124            *bufptr ++= '\\';
125            *bufptr ++= *arg;
126            *bufptr ++= '\'';
127        } else
128            /* Just copy */
129            *bufptr ++= *arg;
130        arg++;
131    }
132    *bufptr ++= '\'';
133    *bufptr ++= '\0';
134    return BUFFER;
135}
136
137/*
138 * Generate the output. argv[0] is the program name (used for reporting errors).
139 * argv[1..] contains the options to be parsed. argc must be the number of
140 * elements in argv (ie. 1 if there are no options, only the program name),
141 * optstr must contain the short options, and longopts the long options.
142 * Other settings are found in global variables.
143 */
144#if !ENABLE_GETOPT_LONG
145#define generate_output(argv,argc,optstr,longopts) generate_output(argv,argc,optstr)
146#endif
147static int generate_output(char **argv, int argc, const char *optstr, const struct option *longopts)
148{
149    int exit_code = 0; /* We assume everything will be OK */
150    unsigned opt;
151#if ENABLE_GETOPT_LONG
152    int longindex;
153#endif
154    const char *charptr;
155
156    if (quiet_errors) /* No error reporting from getopt(3) */
157        opterr = 0;
158    optind = 0; /* Reset getopt(3) */
159
160    while (1) {
161        opt =
162#if ENABLE_GETOPT_LONG
163            alternative ?
164            getopt_long_only(argc, argv, optstr, longopts, &longindex) :
165            getopt_long(argc, argv, optstr, longopts, &longindex);
166#else
167            getopt(argc, argv, optstr);
168#endif
169        if (opt == EOF)
170            break;
171        if (opt == '?' || opt == ':' )
172            exit_code = 1;
173        else if (!quiet_output) {
174#if ENABLE_GETOPT_LONG
175            if (opt == LONG_OPT) {
176                printf(" --%s", longopts[longindex].name);
177                if (longopts[longindex].has_arg)
178                    printf(" %s",
179                        normalize(optarg ? optarg : ""));
180            } else
181#endif
182            if (opt == NON_OPT)
183                printf(" %s", normalize(optarg));
184            else {
185                printf(" -%c", opt);
186                charptr = strchr(optstr,opt);
187                if (charptr != NULL && *++charptr == ':')
188                    printf(" %s",
189                        normalize(optarg ? optarg : ""));
190            }
191        }
192    }
193
194    if (!quiet_output) {
195        printf(" --");
196        while (optind < argc)
197            printf(" %s", normalize(argv[optind++]));
198        puts("");
199    }
200    return exit_code;
201}
202
203#if ENABLE_GETOPT_LONG
204/*
205 * Register several long options. options is a string of long options,
206 * separated by commas or whitespace.
207 * This nukes options!
208 */
209static struct option *add_long_options(struct option *long_options, char *options)
210{
211    int long_nr = 0;
212    int arg_opt, tlen;
213    char *tokptr = strtok(options, ", \t\n");
214
215    if (long_options)
216        while (long_options[long_nr].name)
217            long_nr++;
218
219    while (tokptr) {
220        arg_opt = no_argument;
221        tlen = strlen(tokptr);
222        if (tlen) {
223            tlen--;
224            if (tokptr[tlen] == ':') {
225                arg_opt = required_argument;
226                if (tlen && tokptr[tlen-1] == ':') {
227                    tlen--;
228                    arg_opt = optional_argument;
229                }
230                tokptr[tlen] = '\0';
231                if (tlen == 0)
232                    bb_error_msg_and_die("empty long option specified");
233            }
234            long_options = xrealloc(long_options,
235                    sizeof(long_options[0]) * (long_nr+2));
236            long_options[long_nr].has_arg = arg_opt;
237            long_options[long_nr].flag = NULL;
238            long_options[long_nr].val = LONG_OPT;
239            long_options[long_nr].name = xstrdup(tokptr);
240            long_nr++;
241            memset(&long_options[long_nr], 0, sizeof(long_options[0]));
242        }
243        tokptr = strtok(NULL, ", \t\n");
244    }
245    return long_options;
246}
247#endif
248
249static void set_shell(const char *new_shell)
250{
251    if (!strcmp(new_shell,"bash") || !strcmp(new_shell,"sh"))
252        return;
253    if (!strcmp(new_shell,"tcsh") || !strcmp(new_shell,"csh"))
254        option_mask32 |= SHELL_IS_TCSH;
255    else
256        bb_error_msg("unknown shell '%s', assuming bash", new_shell);
257}
258
259
260/* Exit codes:
261 *   0) No errors, successful operation.
262 *   1) getopt(3) returned an error.
263 *   2) A problem with parameter parsing for getopt(1).
264 *   3) Internal error, out of memory
265 *   4) Returned for -T
266 */
267
268#if ENABLE_GETOPT_LONG
269static const char getopt_longopts[] ALIGN1 =
270    "options\0"      Required_argument "o"
271    "longoptions\0"  Required_argument "l"
272    "quiet\0"        No_argument       "q"
273    "quiet-output\0" No_argument       "Q"
274    "shell\0"        Required_argument "s"
275    "test\0"         No_argument       "T"
276    "unquoted\0"     No_argument       "u"
277    "alternative\0"  No_argument       "a"
278    "name\0"         Required_argument "n"
279    ;
280#endif
281
282int getopt_main(int argc, char *argv[]);
283int getopt_main(int argc, char *argv[])
284{
285    char *optstr = NULL;
286    char *name = NULL;
287    unsigned opt;
288    const char *compatible;
289    char *s_arg;
290#if ENABLE_GETOPT_LONG
291    struct option *long_options = NULL;
292    llist_t *l_arg = NULL;
293#endif
294
295    compatible = getenv("GETOPT_COMPATIBLE"); /* used as yes/no flag */
296
297    if (argc == 1) {
298        if (compatible) {
299            /* For some reason, the original getopt gave no error
300               when there were no arguments. */
301            printf(" --\n");
302            return 0;
303        }
304        bb_error_msg_and_die("missing optstring argument");
305    }
306
307    if (argv[1][0] != '-' || compatible) {
308        char *s;
309
310        option_mask32 |= OPT_u; /* quoting off */
311        s = xstrdup(argv[1] + strspn(argv[1], "-+"));
312        argv[1] = argv[0];
313        return generate_output(argv+1, argc-1, s, long_options);
314    }
315
316#if !ENABLE_GETOPT_LONG
317    opt = getopt32(argv, "+o:n:qQs:Tu", &optstr, &name, &s_arg);
318#else
319    applet_long_options = getopt_longopts;
320    opt_complementary = "l::";
321    opt = getopt32(argv, "+o:n:qQs:Tual:",
322                    &optstr, &name, &s_arg, &l_arg);
323    /* Effectuate the read options for the applet itself */
324    while (l_arg) {
325        long_options = add_long_options(long_options, l_arg->data);
326        l_arg = l_arg->link;
327    }
328#endif
329
330    if (opt & OPT_s) {
331        set_shell(s_arg);
332    }
333
334    if (opt & OPT_T) {
335        return 4;
336    }
337
338    /* All options controlling the applet have now been parsed */
339    if (!optstr) {
340        if (optind >= argc)
341            bb_error_msg_and_die("missing optstring argument");
342        optstr = argv[optind++];
343    }
344
345    argv[optind-1] = name ? name : argv[0];
346    return generate_output(argv+optind-1, argc-optind+1, optstr, long_options);
347}
Note: See TracBrowser for help on using the repository browser.