1/* $OpenBSD: getopt_long.c,v 1.26 2013/06/08 22:47:56 millert Exp $ */
2/* $NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $       */
3
4/*
5 * Copyright (c) 2002 Todd C. Miller <Todd.Miller@courtesan.com>
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 *
19 * Sponsored in part by the Defense Advanced Research Projects
20 * Agency (DARPA) and Air Force Research Laboratory, Air Force
21 * Materiel Command, USAF, under agreement number F39502-99-1-0512.
22 */
23/*-
24 * Copyright (c) 2000 The NetBSD Foundation, Inc.
25 * All rights reserved.
26 *
27 * This code is derived from software contributed to The NetBSD Foundation
28 * by Dieter Baron and Thomas Klausner.
29 *
30 * Redistribution and use in source and binary forms, with or without
31 * modification, are permitted provided that the following conditions
32 * are met:
33 * 1. Redistributions of source code must retain the above copyright
34 *    notice, this list of conditions and the following disclaimer.
35 * 2. Redistributions in binary form must reproduce the above copyright
36 *    notice, this list of conditions and the following disclaimer in the
37 *    documentation and/or other materials provided with the distribution.
38 *
39 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
40 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
41 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
43 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
44 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
45 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
46 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
47 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
49 * POSSIBILITY OF SUCH DAMAGE.
50 */
51
52#include <stdbool.h>
53#include <stdio.h>
54#include <stdlib.h>
55#include <string.h>
56#include <sys/cdefs.h>
57
58#include <log/getopt.h>
59
60#define PRINT_ERROR ((context->opterr) && (*options != ':'))
61
62#define FLAG_PERMUTE 0x01  // permute non-options to the end of argv
63#define FLAG_ALLARGS 0x02  // treat non-options as args to option "-1"
64
65// return values
66#define BADCH (int)'?'
67#define BADARG ((*options == ':') ? (int)':' : (int)'?')
68#define INORDER (int)1
69
70#define D_PREFIX 0
71#define DD_PREFIX 1
72#define W_PREFIX 2
73
74// Compute the greatest common divisor of a and b.
75static int gcd(int a, int b) {
76    int c = a % b;
77    while (c) {
78        a = b;
79        b = c;
80        c = a % b;
81    }
82    return b;
83}
84
85// Exchange the block from nonopt_start to nonopt_end with the block from
86// nonopt_end to opt_end (keeping the same order of arguments in each block).
87// Returns optind - (nonopt_end - nonopt_start) for convenience.
88static int permute_args(getopt_context* context, char* const* nargv) {
89    // compute lengths of blocks and number and size of cycles
90    int nnonopts = context->nonopt_end - context->nonopt_start;
91    int nopts = context->optind - context->nonopt_end;
92    int ncycle = gcd(nnonopts, nopts);
93    int cyclelen = (context->optind - context->nonopt_start) / ncycle;
94
95    for (int i = 0; i < ncycle; i++) {
96        int cstart = context->nonopt_end + i;
97        int pos = cstart;
98        for (int j = 0; j < cyclelen; j++) {
99            if (pos >= context->nonopt_end) {
100                pos -= nnonopts;
101            } else {
102                pos += nopts;
103            }
104            char* swap = nargv[pos];
105            const_cast<char**>(nargv)[pos] = nargv[cstart];
106            const_cast<char**>(nargv)[cstart] = swap;
107        }
108    }
109    return context->optind - (context->nonopt_end - context->nonopt_start);
110}
111
112// parse_long_options_r --
113//    Parse long options in argc/argv argument vector.
114// Returns -1 if short_too is set and the option does not match long_options.
115static int parse_long_options_r(char* const* nargv, const char* options,
116                                const struct option* long_options, int* idx,
117                                bool short_too, struct getopt_context* context) {
118    const char* current_argv = context->place;
119    const char* current_dash;
120    switch (context->dash_prefix) {
121        case D_PREFIX:
122            current_dash = "-";
123            break;
124        case DD_PREFIX:
125            current_dash = "--";
126            break;
127        case W_PREFIX:
128            current_dash = "-W ";
129            break;
130        default:
131            current_dash = "";
132            break;
133    }
134    context->optind++;
135
136    const char* has_equal;
137    size_t current_argv_len;
138    if (!!(has_equal = strchr(current_argv, '='))) {
139        // argument found (--option=arg)
140        current_argv_len = has_equal - current_argv;
141        has_equal++;
142    } else {
143        current_argv_len = strlen(current_argv);
144    }
145
146    int match = -1;
147    bool exact_match = false;
148    bool second_partial_match = false;
149    for (int i = 0; long_options[i].name; i++) {
150        // find matching long option
151        if (strncmp(current_argv, long_options[i].name, current_argv_len)) {
152            continue;
153        }
154
155        if (strlen(long_options[i].name) == current_argv_len) {
156            // exact match
157            match = i;
158            exact_match = true;
159            break;
160        }
161        // If this is a known short option, don't allow
162        // a partial match of a single character.
163        if (short_too && current_argv_len == 1) continue;
164
165        if (match == -1) {  // first partial match
166            match = i;
167        } else if (long_options[i].has_arg != long_options[match].has_arg ||
168                   long_options[i].flag != long_options[match].flag ||
169                   long_options[i].val != long_options[match].val) {
170            second_partial_match = true;
171        }
172    }
173    if (!exact_match && second_partial_match) {
174        // ambiguous abbreviation
175        if (PRINT_ERROR) {
176            fprintf(context->optstderr ?: stderr,
177                    "option `%s%.*s' is ambiguous", current_dash,
178                    (int)current_argv_len, current_argv);
179        }
180        context->optopt = 0;
181        return BADCH;
182    }
183    if (match != -1) {  // option found
184        if (long_options[match].has_arg == no_argument && has_equal) {
185            if (PRINT_ERROR) {
186                fprintf(context->optstderr ?: stderr,
187                        "option `%s%.*s' doesn't allow an argument",
188                        current_dash, (int)current_argv_len, current_argv);
189            }
190            // XXX: GNU sets optopt to val regardless of flag
191            context->optopt =
192                long_options[match].flag ? 0 : long_options[match].val;
193            return BADCH;
194        }
195        if (long_options[match].has_arg == required_argument ||
196            long_options[match].has_arg == optional_argument) {
197            if (has_equal) {
198                context->optarg = has_equal;
199            } else if (long_options[match].has_arg == required_argument) {
200                // optional argument doesn't use next nargv
201                context->optarg = nargv[context->optind++];
202            }
203        }
204        if ((long_options[match].has_arg == required_argument) &&
205            !context->optarg) {
206            // Missing argument; leading ':' indicates no error
207            // should be generated.
208            if (PRINT_ERROR) {
209                fprintf(context->optstderr ?: stderr,
210                        "option `%s%s' requires an argument", current_dash,
211                        current_argv);
212            }
213            // XXX: GNU sets optopt to val regardless of flag
214            context->optopt =
215                long_options[match].flag ? 0 : long_options[match].val;
216            context->optind--;
217            return BADARG;
218        }
219    } else {  // unknown option
220        if (short_too) {
221            context->optind--;
222            return -1;
223        }
224        if (PRINT_ERROR) {
225            fprintf(context->optstderr ?: stderr, "unrecognized option `%s%s'",
226                    current_dash, current_argv);
227        }
228        context->optopt = 0;
229        return BADCH;
230    }
231    if (idx) *idx = match;
232    if (long_options[match].flag) {
233        *long_options[match].flag = long_options[match].val;
234        return 0;
235    }
236    return long_options[match].val;
237}
238
239// getopt_long_r --
240//    Parse argc/argv argument vector.
241int getopt_long_r(int nargc, char* const* nargv, const char* options,
242                  const struct option* long_options, int* idx,
243                  struct getopt_context* context) {
244    if (!options) return -1;
245
246    // XXX Some GNU programs (like cvs) set optind to 0 instead of
247    // XXX using optreset.  Work around this braindamage.
248    if (!context->optind) context->optind = context->optreset = 1;
249
250    // Disable GNU extensions if options string begins with a '+'.
251    int flags = FLAG_PERMUTE;
252    if (*options == '-') {
253        flags |= FLAG_ALLARGS;
254    } else if (*options == '+') {
255        flags &= ~FLAG_PERMUTE;
256    }
257    if (*options == '+' || *options == '-') options++;
258
259    context->optarg = nullptr;
260    if (context->optreset) context->nonopt_start = context->nonopt_end = -1;
261start:
262    if (context->optreset || !*context->place) {  // update scanning pointer
263        context->optreset = 0;
264        if (context->optind >= nargc) {  // end of argument vector
265            context->place = EMSG;
266            if (context->nonopt_end != -1) {
267                // do permutation, if we have to
268                context->optind = permute_args(context, nargv);
269            } else if (context->nonopt_start != -1) {
270                // If we skipped non-options, set optind to the first of them.
271                context->optind = context->nonopt_start;
272            }
273            context->nonopt_start = context->nonopt_end = -1;
274            return -1;
275        }
276        if (*(context->place = nargv[context->optind]) != '-' ||
277            context->place[1] == '\0') {
278            context->place = EMSG;  // found non-option
279            if (flags & FLAG_ALLARGS) {
280                // GNU extension: return non-option as argument to option 1
281                context->optarg = nargv[context->optind++];
282                return INORDER;
283            }
284            if (!(flags & FLAG_PERMUTE)) {
285                // If no permutation wanted, stop parsing at first non-option.
286                return -1;
287            }
288            // do permutation
289            if (context->nonopt_start == -1) {
290                context->nonopt_start = context->optind;
291            } else if (context->nonopt_end != -1) {
292                context->nonopt_start = permute_args(context, nargv);
293                context->nonopt_end = -1;
294            }
295            context->optind++;
296            // process next argument
297            goto start;
298        }
299        if (context->nonopt_start != -1 && context->nonopt_end == -1) {
300            context->nonopt_end = context->optind;
301        }
302
303        // If we have "-" do nothing, if "--" we are done.
304        if (context->place[1] != '\0' && *++(context->place) == '-' &&
305            context->place[1] == '\0') {
306            context->optind++;
307            context->place = EMSG;
308            // We found an option (--), so if we skipped
309            // non-options, we have to permute.
310            if (context->nonopt_end != -1) {
311                context->optind = permute_args(context, nargv);
312            }
313            context->nonopt_start = context->nonopt_end = -1;
314            return -1;
315        }
316    }
317
318    int optchar;
319    // Check long options if:
320    //  1) we were passed some
321    //  2) the arg is not just "-"
322    //  3) either the arg starts with -- we are getopt_long_only()
323    if (long_options && context->place != nargv[context->optind] &&
324        (*context->place == '-')) {
325        bool short_too = false;
326        context->dash_prefix = D_PREFIX;
327        if (*context->place == '-') {
328            context->place++;  // --foo long option
329            context->dash_prefix = DD_PREFIX;
330        } else if (*context->place != ':' && strchr(options, *context->place)) {
331            short_too = true;  // could be short option too
332        }
333
334        optchar = parse_long_options_r(nargv, options, long_options, idx,
335                                       short_too, context);
336        if (optchar != -1) {
337            context->place = EMSG;
338            return optchar;
339        }
340    }
341
342    const char* oli;  // option letter list index
343    if ((optchar = (int)*(context->place)++) == (int)':' ||
344        (optchar == (int)'-' && *context->place != '\0') ||
345        !(oli = strchr(options, optchar))) {
346        // If the user specified "-" and  '-' isn't listed in
347        // options, return -1 (non-option) as per POSIX.
348        // Otherwise, it is an unknown option character (or ':').
349        if (optchar == (int)'-' && *context->place == '\0') return -1;
350        if (!*context->place) context->optind++;
351        if (PRINT_ERROR) {
352            fprintf(context->optstderr ?: stderr, "invalid option -- %c",
353                    optchar);
354        }
355        context->optopt = optchar;
356        return BADCH;
357    }
358
359    static const char recargchar[] = "option requires an argument -- %c";
360    if (long_options && optchar == 'W' && oli[1] == ';') {
361        // -W long-option
362        if (*context->place) {                      // no space
363            ;                                       // NOTHING
364        } else if (++(context->optind) >= nargc) {  // no arg
365            context->place = EMSG;
366            if (PRINT_ERROR) {
367                fprintf(context->optstderr ?: stderr, recargchar, optchar);
368            }
369            context->optopt = optchar;
370            return BADARG;
371        } else {  // white space
372            context->place = nargv[context->optind];
373        }
374        context->dash_prefix = W_PREFIX;
375        optchar = parse_long_options_r(nargv, options, long_options, idx, false,
376                                       context);
377        context->place = EMSG;
378        return optchar;
379    }
380    if (*++oli != ':') {  // doesn't take argument
381        if (!*context->place) context->optind++;
382    } else {  // takes (optional) argument
383        context->optarg = nullptr;
384        if (*context->place) {  // no white space
385            context->optarg = context->place;
386        } else if (oli[1] != ':') {              // arg not optional
387            if (++(context->optind) >= nargc) {  // no arg
388                context->place = EMSG;
389                if (PRINT_ERROR) {
390                    fprintf(context->optstderr ?: stderr, recargchar, optchar);
391                }
392                context->optopt = optchar;
393                return BADARG;
394            }
395            context->optarg = nargv[context->optind];
396        }
397        context->place = EMSG;
398        context->optind++;
399    }
400    // dump back option letter
401    return optchar;
402}
403