Subversion Repositories HelenOS

Rev

Rev 3346 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3317 post 1
/*  $NetBSD: getopt_long.c,v 1.21.4.1 2008/01/09 01:34:14 matt Exp $    */
2
 
3
/*-
4
 * Copyright (c) 2000 The NetBSD Foundation, Inc.
5
 * All rights reserved.
6
 *
7
 * This code is derived from software contributed to The NetBSD Foundation
8
 * by Dieter Baron and Thomas Klausner.
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions
12
 * are met:
13
 * 1. Redistributions of source code must retain the above copyright
14
 *    notice, this list of conditions and the following disclaimer.
15
 * 2. Redistributions in binary form must reproduce the above copyright
16
 *    notice, this list of conditions and the following disclaimer in the
17
 *    documentation and/or other materials provided with the distribution.
18
 *
19
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29
 * POSSIBILITY OF SUCH DAMAGE.
30
 */
31
 
32
/* Ported to HelenOS August 2008 by Tim Post <echo@echoreply.us> */
33
 
34
#include <assert.h>
35
#include <stdarg.h>
36
#include <err.h>
37
#include <errno.h>
38
#include <getopt.h>
39
#include <stdlib.h>
40
#include <string.h>
41
 
42
/* HelenOS Port : We're incorporating only the modern getopt_long with wrappers
43
 * to keep legacy getopt() usage from breaking. All references to REPLACE_GETOPT
44
 * are dropped, we just include the code */
45
 
46
int opterr = 1;     /* if error message should be printed */
47
int optind = 1;     /* index into parent argv vector */
48
int optopt = '?';       /* character checked for validity */
49
int optreset;       /* reset getopt */
50
char *optarg;       /* argument associated with option */
51
 
52
 
53
#define IGNORE_FIRST    (*options == '-' || *options == '+')
54
#define PRINT_ERROR ((opterr) && ((*options != ':') \
55
                      || (IGNORE_FIRST && options[1] != ':')))
56
/*HelenOS Port - POSIXLY_CORRECT is always false */
57
#define IS_POSIXLY_CORRECT 0
58
#define PERMUTE         (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
59
/* XXX: GNU ignores PC if *options == '-' */
60
#define IN_ORDER        (!IS_POSIXLY_CORRECT && *options == '-')
61
 
62
/* return values */
63
#define BADCH   (int)'?'
64
#define BADARG      ((IGNORE_FIRST && options[1] == ':') \
65
             || (*options == ':') ? (int)':' : (int)'?')
66
#define INORDER (int)1
67
 
68
#define EMSG    ""
69
 
70
static int getopt_internal(int, char **, const char *);
71
static int gcd(int, int);
72
static void permute_args(int, int, int, char **);
73
 
74
static const char *place = EMSG; /* option letter processing */
75
 
76
/* XXX: set optreset to 1 rather than these two */
77
static int nonopt_start = -1; /* first non option argument (for permute) */
78
static int nonopt_end = -1;   /* first option after non options (for permute) */
79
 
80
/* Error messages */
81
 
3336 post 82
/* HelenOS Port: Calls to warnx() were eliminated (as we have no stderr that
83
 * may be redirected) and replaced with printf. As such, error messages now
84
 * end in a newline */
3317 post 85
 
3336 post 86
static const char recargchar[] = "option requires an argument -- %c\n";
87
static const char recargstring[] = "option requires an argument -- %s\n";
88
static const char ambig[] = "ambiguous option -- %.*s\n";
89
static const char noarg[] = "option doesn't take an argument -- %.*s\n";
90
static const char illoptchar[] = "unknown option -- %c\n";
91
static const char illoptstring[] = "unknown option -- %s\n";
92
 
93
 
3317 post 94
/*
95
 * Compute the greatest common divisor of a and b.
96
 */
97
static int
98
gcd(a, b)
99
    int a;
100
    int b;
101
{
102
    int c;
103
 
104
    c = a % b;
105
    while (c != 0) {
106
        a = b;
107
        b = c;
108
        c = a % b;
109
    }
110
 
111
    return b;
112
}
113
 
114
/*
115
 * Exchange the block from nonopt_start to nonopt_end with the block
116
 * from nonopt_end to opt_end (keeping the same order of arguments
117
 * in each block).
118
 */
119
static void
120
permute_args(panonopt_start, panonopt_end, opt_end, nargv)
121
    int panonopt_start;
122
    int panonopt_end;
123
    int opt_end;
124
    char **nargv;
125
{
126
    int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
127
    char *swap;
128
 
129
    assert(nargv != NULL);
130
 
131
    /*
132
     * compute lengths of blocks and number and size of cycles
133
     */
134
    nnonopts = panonopt_end - panonopt_start;
135
    nopts = opt_end - panonopt_end;
136
    ncycle = gcd(nnonopts, nopts);
137
    cyclelen = (opt_end - panonopt_start) / ncycle;
138
 
139
    for (i = 0; i < ncycle; i++) {
140
        cstart = panonopt_end+i;
141
        pos = cstart;
142
        for (j = 0; j < cyclelen; j++) {
143
            if (pos >= panonopt_end)
144
                pos -= nnonopts;
145
            else
146
                pos += nopts;
147
            swap = nargv[pos];
148
            nargv[pos] = nargv[cstart];
149
            nargv[cstart] = swap;
150
        }
151
    }
152
}
153
 
154
/*
155
 * getopt_internal --
156
 *  Parse argc/argv argument vector.  Called by user level routines.
157
 *  Returns -2 if -- is found (can be long option or end of options marker).
158
 */
159
static int
160
getopt_internal(nargc, nargv, options)
161
    int nargc;
162
    char **nargv;
163
    const char *options;
164
{
165
    char *oli;              /* option letter list index */
166
    int optchar;
167
 
168
    assert(nargv != NULL);
169
    assert(options != NULL);
170
 
171
    optarg = NULL;
172
 
173
    /*
174
     * XXX Some programs (like rsyncd) expect to be able to
175
     * XXX re-initialize optind to 0 and have getopt_long(3)
176
     * XXX properly function again.  Work around this braindamage.
177
     */
178
    if (optind == 0)
179
        optind = 1;
180
 
181
    if (optreset)
182
        nonopt_start = nonopt_end = -1;
183
start:
184
    if (optreset || !*place) {      /* update scanning pointer */
185
        optreset = 0;
186
        if (optind >= nargc) {          /* end of argument vector */
187
            place = EMSG;
188
            if (nonopt_end != -1) {
189
                /* do permutation, if we have to */
190
                permute_args(nonopt_start, nonopt_end,
191
                    optind, nargv);
192
                optind -= nonopt_end - nonopt_start;
193
            }
194
            else if (nonopt_start != -1) {
195
                /*
196
                 * If we skipped non-options, set optind
197
                 * to the first of them.
198
                 */
199
                optind = nonopt_start;
200
            }
201
            nonopt_start = nonopt_end = -1;
202
            return -1;
203
        }
204
        if ((*(place = nargv[optind]) != '-')
205
            || (place[1] == '\0')) {    /* found non-option */
206
            place = EMSG;
207
            if (IN_ORDER) {
208
                /*
209
                 * GNU extension:
210
                 * return non-option as argument to option 1
211
                 */
212
                optarg = nargv[optind++];
213
                return INORDER;
214
            }
215
            if (!PERMUTE) {
216
                /*
217
                 * if no permutation wanted, stop parsing
218
                 * at first non-option
219
                 */
220
                return -1;
221
            }
222
            /* do permutation */
223
            if (nonopt_start == -1)
224
                nonopt_start = optind;
225
            else if (nonopt_end != -1) {
226
                permute_args(nonopt_start, nonopt_end,
227
                    optind, nargv);
228
                nonopt_start = optind -
229
                    (nonopt_end - nonopt_start);
230
                nonopt_end = -1;
231
            }
232
            optind++;
233
            /* process next argument */
234
            goto start;
235
        }
236
        if (nonopt_start != -1 && nonopt_end == -1)
237
            nonopt_end = optind;
238
        if (place[1] && *++place == '-') {  /* found "--" */
239
            place++;
240
            return -2;
241
        }
242
    }
243
    if ((optchar = (int)*place++) == (int)':' ||
244
        (oli = strchr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
245
        /* option letter unknown or ':' */
246
        if (!*place)
247
            ++optind;
248
        if (PRINT_ERROR)
3336 post 249
            printf(illoptchar, optchar);
3317 post 250
        optopt = optchar;
251
        return BADCH;
252
    }
253
    if (optchar == 'W' && oli[1] == ';') {      /* -W long-option */
254
        /* XXX: what if no long options provided (called by getopt)? */
255
        if (*place)
256
            return -2;
257
 
258
        if (++optind >= nargc) {    /* no arg */
259
            place = EMSG;
260
            if (PRINT_ERROR)
3336 post 261
                printf(recargchar, optchar);
3317 post 262
            optopt = optchar;
263
            return BADARG;
264
        } else              /* white space */
265
            place = nargv[optind];
266
        /*
267
         * Handle -W arg the same as --arg (which causes getopt to
268
         * stop parsing).
269
         */
270
        return -2;
271
    }
272
    if (*++oli != ':') {            /* doesn't take argument */
273
        if (!*place)
274
            ++optind;
275
    } else {                /* takes (optional) argument */
276
        optarg = NULL;
277
        if (*place)         /* no white space */
278
            optarg = *place;
279
        /* XXX: disable test for :: if PC? (GNU doesn't) */
280
        else if (oli[1] != ':') {   /* arg not optional */
281
            if (++optind >= nargc) {    /* no arg */
282
                place = EMSG;
283
                if (PRINT_ERROR)
3336 post 284
                    printf(recargchar, optchar);
3317 post 285
                optopt = optchar;
286
                return BADARG;
287
            } else
288
                optarg = nargv[optind];
289
        }
290
        place = EMSG;
291
        ++optind;
292
    }
293
    /* dump back option letter */
294
    return optchar;
295
}
296
 
297
/*
298
 * getopt --
299
 *  Parse argc/argv argument vector.
300
 */
301
int
302
getopt(nargc, nargv, options)
303
    int nargc;
304
    char * const *nargv;
305
    const char *options;
306
{
307
    int retval;
308
 
309
    assert(nargv != NULL);
310
    assert(options != NULL);
311
 
312
    retval = getopt_internal(nargc, (char **)nargv, options);
313
    if (retval == -2) {
314
        ++optind;
315
        /*
316
         * We found an option (--), so if we skipped non-options,
317
         * we have to permute.
318
         */
319
        if (nonopt_end != -1) {
320
            permute_args(nonopt_start, nonopt_end, optind,
321
                       (char **)nargv);
322
            optind -= nonopt_end - nonopt_start;
323
        }
324
        nonopt_start = nonopt_end = -1;
325
        retval = -1;
326
    }
327
    return retval;
328
}
329
 
330
/*
331
 * getopt_long --
332
 *  Parse argc/argv argument vector.
333
 */
334
int
335
getopt_long(nargc, nargv, options, long_options, idx)
336
    int nargc;
337
    char * const *nargv;
338
    const char *options;
339
    const struct option *long_options;
340
    int *idx;
341
{
342
    int retval;
343
 
344
#define IDENTICAL_INTERPRETATION(_x, _y)                \
345
    (long_options[(_x)].has_arg == long_options[(_y)].has_arg &&    \
346
     long_options[(_x)].flag == long_options[(_y)].flag &&      \
347
     long_options[(_x)].val == long_options[(_y)].val)
348
 
349
    assert(nargv != NULL);
350
    assert(options != NULL);
351
    assert(long_options != NULL);
352
    /* idx may be NULL */
353
 
354
    retval = getopt_internal(nargc, (char **)nargv, options);
355
    if (retval == -2) {
356
        char *current_argv, *has_equal;
357
        size_t current_argv_len;
358
        int i, ambiguous, match;
359
 
360
        current_argv = (char *)place;
361
        match = -1;
362
        ambiguous = 0;
363
 
364
        optind++;
365
        place = EMSG;
366
 
367
        if (*current_argv == '\0') {        /* found "--" */
368
            /*
369
             * We found an option (--), so if we skipped
370
             * non-options, we have to permute.
371
             */
372
            if (nonopt_end != -1) {
373
                permute_args(nonopt_start, nonopt_end,
374
                    optind, (char **)nargv);
375
                optind -= nonopt_end - nonopt_start;
376
            }
377
            nonopt_start = nonopt_end = -1;
378
            return -1;
379
        }
380
        if ((has_equal = strchr(current_argv, '=')) != NULL) {
381
            /* argument found (--option=arg) */
382
            current_argv_len = has_equal - current_argv;
383
            has_equal++;
384
        } else
385
            current_argv_len = strlen(current_argv);
386
 
387
        for (i = 0; long_options[i].name; i++) {
388
            /* find matching long option */
389
            if (strncmp(current_argv, long_options[i].name,
390
                current_argv_len))
391
                continue;
392
 
393
            if (strlen(long_options[i].name) ==
394
                (unsigned)current_argv_len) {
395
                /* exact match */
396
                match = i;
397
                ambiguous = 0;
398
                break;
399
            }
400
            if (match == -1)        /* partial match */
401
                match = i;
402
            else if (!IDENTICAL_INTERPRETATION(i, match))
403
                ambiguous = 1;
404
        }
405
        if (ambiguous) {
406
            /* ambiguous abbreviation */
407
            if (PRINT_ERROR)
3336 post 408
                printf(ambig, (int)current_argv_len,
3317 post 409
                     current_argv);
410
            optopt = 0;
411
            return BADCH;
412
        }
413
        if (match != -1) {          /* option found */
414
                if (long_options[match].has_arg == no_argument
415
                && has_equal) {
416
                if (PRINT_ERROR)
3336 post 417
                    printf(noarg, (int)current_argv_len,
3317 post 418
                         current_argv);
419
                /*
420
                 * XXX: GNU sets optopt to val regardless of
421
                 * flag
422
                 */
423
                if (long_options[match].flag == NULL)
424
                    optopt = long_options[match].val;
425
                else
426
                    optopt = 0;
427
                return BADARG;
428
            }
429
            if (long_options[match].has_arg == required_argument ||
430
                long_options[match].has_arg == optional_argument) {
431
                if (has_equal)
432
                    optarg = has_equal;
433
                else if (long_options[match].has_arg ==
434
                    required_argument) {
435
                    /*
436
                     * optional argument doesn't use
437
                     * next nargv
438
                     */
439
                    optarg = nargv[optind++];
440
                }
441
            }
442
            if ((long_options[match].has_arg == required_argument)
443
                && (optarg == NULL)) {
444
                /*
445
                 * Missing argument; leading ':'
446
                 * indicates no error should be generated
447
                 */
448
                if (PRINT_ERROR)
3336 post 449
                    printf(recargstring, current_argv);
3317 post 450
                /*
451
                 * XXX: GNU sets optopt to val regardless
452
                 * of flag
453
                 */
454
                if (long_options[match].flag == NULL)
455
                    optopt = long_options[match].val;
456
                else
457
                    optopt = 0;
458
                --optind;
459
                return BADARG;
460
            }
461
        } else {            /* unknown option */
462
            if (PRINT_ERROR)
3336 post 463
                printf(illoptstring, current_argv);
3317 post 464
            optopt = 0;
465
            return BADCH;
466
        }
467
        if (long_options[match].flag) {
468
            *long_options[match].flag = long_options[match].val;
469
            retval = 0;
470
        } else
471
            retval = long_options[match].val;
472
        if (idx)
473
            *idx = match;
474
    }
475
    return retval;
476
#undef IDENTICAL_INTERPRETATION
477
}
478