xref: /freebsd/lib/libc/stdlib/getopt_long.c (revision 8d20be1e22095c27faf8fe8b2f0d089739cc742e)
1 /*	$OpenBSD: getopt_long.c,v 1.22 2006/10/04 21:29:04 jmc 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 #if 0
53 #if defined(LIBC_SCCS) && !defined(lint)
54 static char *rcsid = "$OpenBSD: getopt_long.c,v 1.16 2004/02/04 18:17:25 millert Exp $";
55 #endif /* LIBC_SCCS and not lint */
56 #endif
57 #include <sys/cdefs.h>
58 __FBSDID("$FreeBSD$");
59 
60 #include <err.h>
61 #include <errno.h>
62 #include <getopt.h>
63 #include <stdlib.h>
64 #include <string.h>
65 
66 #define GNU_COMPATIBLE		/* Be more compatible, configure's use us! */
67 
68 #if 0				/* we prefer to keep our getopt(3) */
69 #define	REPLACE_GETOPT		/* use this getopt as the system getopt(3) */
70 #endif
71 
72 #ifdef REPLACE_GETOPT
73 int	opterr = 1;		/* if error message should be printed */
74 int	optind = 1;		/* index into parent argv vector */
75 int	optopt = '?';		/* character checked for validity */
76 int	optreset;		/* reset getopt */
77 char    *optarg;		/* argument associated with option */
78 #endif
79 
80 #define PRINT_ERROR	((opterr) && (*options != ':'))
81 
82 #define FLAG_PERMUTE	0x01	/* permute non-options to the end of argv */
83 #define FLAG_ALLARGS	0x02	/* treat non-options as args to option "-1" */
84 #define FLAG_LONGONLY	0x04	/* operate as getopt_long_only */
85 
86 /* return values */
87 #define	BADCH		(int)'?'
88 #define	BADARG		((*options == ':') ? (int)':' : (int)'?')
89 #define	INORDER 	(int)1
90 
91 #define	EMSG		""
92 
93 #ifdef GNU_COMPATIBLE
94 #define NO_PREFIX	(-1)
95 #define D_PREFIX	0
96 #define DD_PREFIX	1
97 #define W_PREFIX	2
98 #endif
99 
100 static int getopt_internal(int, char * const *, const char *,
101 			   const struct option *, int *, int);
102 static int parse_long_options(char * const *, const char *,
103 			      const struct option *, int *, int, int);
104 static int gcd(int, int);
105 static void permute_args(int, int, int, char * const *);
106 
107 static char *place = EMSG; /* option letter processing */
108 
109 /* XXX: set optreset to 1 rather than these two */
110 static int nonopt_start = -1; /* first non option argument (for permute) */
111 static int nonopt_end = -1;   /* first option after non options (for permute) */
112 
113 /* Error messages */
114 static const char recargchar[] = "option requires an argument -- %c";
115 static const char illoptchar[] = "illegal option -- %c"; /* From P1003.2 */
116 #ifdef GNU_COMPATIBLE
117 static int dash_prefix = NO_PREFIX;
118 static const char gnuoptchar[] = "invalid option -- %c";
119 
120 static const char recargstring[] = "option `%s%s' requires an argument";
121 static const char ambig[] = "option `%s%.*s' is ambiguous";
122 static const char noarg[] = "option `%s%.*s' doesn't allow an argument";
123 static const char illoptstring[] = "unrecognized option `%s%s'";
124 #else
125 static const char recargstring[] = "option requires an argument -- %s";
126 static const char ambig[] = "ambiguous option -- %.*s";
127 static const char noarg[] = "option doesn't take an argument -- %.*s";
128 static const char illoptstring[] = "unknown option -- %s";
129 #endif
130 
131 /*
132  * Compute the greatest common divisor of a and b.
133  */
134 static int
135 gcd(int a, int b)
136 {
137 	int c;
138 
139 	c = a % b;
140 	while (c != 0) {
141 		a = b;
142 		b = c;
143 		c = a % b;
144 	}
145 
146 	return (b);
147 }
148 
149 /*
150  * Exchange the block from nonopt_start to nonopt_end with the block
151  * from nonopt_end to opt_end (keeping the same order of arguments
152  * in each block).
153  */
154 static void
155 permute_args(int panonopt_start, int panonopt_end, int opt_end,
156 	char * const *nargv)
157 {
158 	int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
159 	char *swap;
160 
161 	/*
162 	 * compute lengths of blocks and number and size of cycles
163 	 */
164 	nnonopts = panonopt_end - panonopt_start;
165 	nopts = opt_end - panonopt_end;
166 	ncycle = gcd(nnonopts, nopts);
167 	cyclelen = (opt_end - panonopt_start) / ncycle;
168 
169 	for (i = 0; i < ncycle; i++) {
170 		cstart = panonopt_end+i;
171 		pos = cstart;
172 		for (j = 0; j < cyclelen; j++) {
173 			if (pos >= panonopt_end)
174 				pos -= nnonopts;
175 			else
176 				pos += nopts;
177 			swap = nargv[pos];
178 			/* LINTED const cast */
179 			((char **) nargv)[pos] = nargv[cstart];
180 			/* LINTED const cast */
181 			((char **)nargv)[cstart] = swap;
182 		}
183 	}
184 }
185 
186 /*
187  * parse_long_options --
188  *	Parse long options in argc/argv argument vector.
189  * Returns -1 if short_too is set and the option does not match long_options.
190  */
191 static int
192 parse_long_options(char * const *nargv, const char *options,
193 	const struct option *long_options, int *idx, int short_too, int flags)
194 {
195 	char *current_argv, *has_equal;
196 #ifdef GNU_COMPATIBLE
197 	char *current_dash;
198 #endif
199 	size_t current_argv_len;
200 	int i, match, exact_match, second_partial_match;
201 
202 	current_argv = place;
203 #ifdef GNU_COMPATIBLE
204 	switch (dash_prefix) {
205 		case D_PREFIX:
206 			current_dash = "-";
207 			break;
208 		case DD_PREFIX:
209 			current_dash = "--";
210 			break;
211 		case W_PREFIX:
212 			current_dash = "-W ";
213 			break;
214 		default:
215 			current_dash = "";
216 			break;
217 	}
218 #endif
219 	match = -1;
220 	exact_match = 0;
221 	second_partial_match = 0;
222 
223 	optind++;
224 
225 	if ((has_equal = strchr(current_argv, '=')) != NULL) {
226 		/* argument found (--option=arg) */
227 		current_argv_len = has_equal - current_argv;
228 		has_equal++;
229 	} else
230 		current_argv_len = strlen(current_argv);
231 
232 	for (i = 0; long_options[i].name; i++) {
233 		/* find matching long option */
234 		if (strncmp(current_argv, long_options[i].name,
235 		    current_argv_len))
236 			continue;
237 
238 		if (strlen(long_options[i].name) == current_argv_len) {
239 			/* exact match */
240 			match = i;
241 			exact_match = 1;
242 			break;
243 		}
244 		/*
245 		 * If this is a known short option, don't allow
246 		 * a partial match of a single character.
247 		 */
248 		if (short_too && current_argv_len == 1)
249 			continue;
250 
251 		if (match == -1)        /* first partial match */
252 			match = i;
253 		else if ((flags & FLAG_LONGONLY) ||
254 			 long_options[i].has_arg !=
255 			     long_options[match].has_arg ||
256 			 long_options[i].flag != long_options[match].flag ||
257 			 long_options[i].val != long_options[match].val)
258 			second_partial_match = 1;
259 	}
260 	if (!exact_match && second_partial_match) {
261 		/* ambiguous abbreviation */
262 		if (PRINT_ERROR)
263 			warnx(ambig,
264 #ifdef GNU_COMPATIBLE
265 			     current_dash,
266 #endif
267 			     (int)current_argv_len,
268 			     current_argv);
269 		optopt = 0;
270 		return (BADCH);
271 	}
272 	if (match != -1) {		/* option found */
273 		if (long_options[match].has_arg == no_argument
274 		    && has_equal) {
275 			if (PRINT_ERROR)
276 				warnx(noarg,
277 #ifdef GNU_COMPATIBLE
278 				     current_dash,
279 #endif
280 				     (int)current_argv_len,
281 				     current_argv);
282 			/*
283 			 * XXX: GNU sets optopt to val regardless of flag
284 			 */
285 			if (long_options[match].flag == NULL)
286 				optopt = long_options[match].val;
287 			else
288 				optopt = 0;
289 #ifdef GNU_COMPATIBLE
290 			return (BADCH);
291 #else
292 			return (BADARG);
293 #endif
294 		}
295 		if (long_options[match].has_arg == required_argument ||
296 		    long_options[match].has_arg == optional_argument) {
297 			if (has_equal)
298 				optarg = has_equal;
299 			else if (long_options[match].has_arg ==
300 			    required_argument) {
301 				/*
302 				 * optional argument doesn't use next nargv
303 				 */
304 				optarg = nargv[optind++];
305 			}
306 		}
307 		if ((long_options[match].has_arg == required_argument)
308 		    && (optarg == NULL)) {
309 			/*
310 			 * Missing argument; leading ':' indicates no error
311 			 * should be generated.
312 			 */
313 			if (PRINT_ERROR)
314 				warnx(recargstring,
315 #ifdef GNU_COMPATIBLE
316 				    current_dash,
317 #endif
318 				    current_argv);
319 			/*
320 			 * XXX: GNU sets optopt to val regardless of flag
321 			 */
322 			if (long_options[match].flag == NULL)
323 				optopt = long_options[match].val;
324 			else
325 				optopt = 0;
326 			--optind;
327 			return (BADARG);
328 		}
329 	} else {			/* unknown option */
330 		if (short_too) {
331 			--optind;
332 			return (-1);
333 		}
334 		if (PRINT_ERROR)
335 			warnx(illoptstring,
336 #ifdef GNU_COMPATIBLE
337 			      current_dash,
338 #endif
339 			      current_argv);
340 		optopt = 0;
341 		return (BADCH);
342 	}
343 	if (idx)
344 		*idx = match;
345 	if (long_options[match].flag) {
346 		*long_options[match].flag = long_options[match].val;
347 		return (0);
348 	} else
349 		return (long_options[match].val);
350 }
351 
352 /*
353  * getopt_internal --
354  *	Parse argc/argv argument vector.  Called by user level routines.
355  */
356 static int
357 getopt_internal(int nargc, char * const *nargv, const char *options,
358 	const struct option *long_options, int *idx, int flags)
359 {
360 	char *oli;				/* option letter list index */
361 	int optchar, short_too;
362 	int posixly_correct;	/* no static, can be changed on the fly */
363 
364 	if (options == NULL)
365 		return (-1);
366 
367 	/*
368 	 * Disable GNU extensions if POSIXLY_CORRECT is set or options
369 	 * string begins with a '+'.
370 	 */
371 	posixly_correct = (getenv("POSIXLY_CORRECT") != NULL);
372 #ifdef GNU_COMPATIBLE
373 	if (*options == '-')
374 		flags |= FLAG_ALLARGS;
375 	else if (posixly_correct || *options == '+')
376 		flags &= ~FLAG_PERMUTE;
377 #else
378 	if (posixly_correct || *options == '+')
379 		flags &= ~FLAG_PERMUTE;
380 	else if (*options == '-')
381 		flags |= FLAG_ALLARGS;
382 #endif
383 	if (*options == '+' || *options == '-')
384 		options++;
385 
386 	/*
387 	 * XXX Some GNU programs (like cvs) set optind to 0 instead of
388 	 * XXX using optreset.  Work around this braindamage.
389 	 */
390 	if (optind == 0)
391 		optind = optreset = 1;
392 
393 	optarg = NULL;
394 	if (optreset)
395 		nonopt_start = nonopt_end = -1;
396 start:
397 	if (optreset || !*place) {		/* update scanning pointer */
398 		optreset = 0;
399 		if (optind >= nargc) {          /* end of argument vector */
400 			place = EMSG;
401 			if (nonopt_end != -1) {
402 				/* do permutation, if we have to */
403 				permute_args(nonopt_start, nonopt_end,
404 				    optind, nargv);
405 				optind -= nonopt_end - nonopt_start;
406 			}
407 			else if (nonopt_start != -1) {
408 				/*
409 				 * If we skipped non-options, set optind
410 				 * to the first of them.
411 				 */
412 				optind = nonopt_start;
413 			}
414 			nonopt_start = nonopt_end = -1;
415 			return (-1);
416 		}
417 		if (*(place = nargv[optind]) != '-' ||
418 #ifdef GNU_COMPATIBLE
419 		    place[1] == '\0') {
420 #else
421 		    (place[1] == '\0' && strchr(options, '-') == NULL)) {
422 #endif
423 			place = EMSG;		/* found non-option */
424 			if (flags & FLAG_ALLARGS) {
425 				/*
426 				 * GNU extension:
427 				 * return non-option as argument to option 1
428 				 */
429 				optarg = nargv[optind++];
430 				return (INORDER);
431 			}
432 			if (!(flags & FLAG_PERMUTE)) {
433 				/*
434 				 * If no permutation wanted, stop parsing
435 				 * at first non-option.
436 				 */
437 				return (-1);
438 			}
439 			/* do permutation */
440 			if (nonopt_start == -1)
441 				nonopt_start = optind;
442 			else if (nonopt_end != -1) {
443 				permute_args(nonopt_start, nonopt_end,
444 				    optind, nargv);
445 				nonopt_start = optind -
446 				    (nonopt_end - nonopt_start);
447 				nonopt_end = -1;
448 			}
449 			optind++;
450 			/* process next argument */
451 			goto start;
452 		}
453 		if (nonopt_start != -1 && nonopt_end == -1)
454 			nonopt_end = optind;
455 
456 		/*
457 		 * If we have "-" do nothing, if "--" we are done.
458 		 */
459 		if (place[1] != '\0' && *++place == '-' && place[1] == '\0') {
460 			optind++;
461 			place = EMSG;
462 			/*
463 			 * We found an option (--), so if we skipped
464 			 * non-options, we have to permute.
465 			 */
466 			if (nonopt_end != -1) {
467 				permute_args(nonopt_start, nonopt_end,
468 				    optind, nargv);
469 				optind -= nonopt_end - nonopt_start;
470 			}
471 			nonopt_start = nonopt_end = -1;
472 			return (-1);
473 		}
474 	}
475 
476 	/*
477 	 * Check long options if:
478 	 *  1) we were passed some
479 	 *  2) the arg is not just "-"
480 	 *  3) either the arg starts with -- we are getopt_long_only()
481 	 */
482 	if (long_options != NULL && place != nargv[optind] &&
483 	    (*place == '-' || (flags & FLAG_LONGONLY))) {
484 		short_too = 0;
485 #ifdef GNU_COMPATIBLE
486 		dash_prefix = D_PREFIX;
487 #endif
488 		if (*place == '-') {
489 			place++;		/* --foo long option */
490 #ifdef GNU_COMPATIBLE
491 			dash_prefix = DD_PREFIX;
492 #endif
493 		} else if (*place != ':' && strchr(options, *place) != NULL)
494 			short_too = 1;		/* could be short option too */
495 
496 		optchar = parse_long_options(nargv, options, long_options,
497 		    idx, short_too, flags);
498 		if (optchar != -1) {
499 			place = EMSG;
500 			return (optchar);
501 		}
502 	}
503 
504 	if ((optchar = (int)*place++) == (int)':' ||
505 	    (optchar == (int)'-' && *place != '\0') ||
506 	    (oli = strchr(options, optchar)) == NULL) {
507 		/*
508 		 * If the user specified "-" and  '-' isn't listed in
509 		 * options, return -1 (non-option) as per POSIX.
510 		 * Otherwise, it is an unknown option character (or ':').
511 		 */
512 		if (optchar == (int)'-' && *place == '\0')
513 			return (-1);
514 		if (!*place)
515 			++optind;
516 #ifdef GNU_COMPATIBLE
517 		if (PRINT_ERROR)
518 			warnx(posixly_correct ? illoptchar : gnuoptchar,
519 			      optchar);
520 #else
521 		if (PRINT_ERROR)
522 			warnx(illoptchar, optchar);
523 #endif
524 		optopt = optchar;
525 		return (BADCH);
526 	}
527 	if (long_options != NULL && optchar == 'W' && oli[1] == ';') {
528 		/* -W long-option */
529 		if (*place)			/* no space */
530 			/* NOTHING */;
531 		else if (++optind >= nargc) {	/* no arg */
532 			place = EMSG;
533 			if (PRINT_ERROR)
534 				warnx(recargchar, optchar);
535 			optopt = optchar;
536 			return (BADARG);
537 		} else				/* white space */
538 			place = nargv[optind];
539 #ifdef GNU_COMPATIBLE
540 		dash_prefix = W_PREFIX;
541 #endif
542 		optchar = parse_long_options(nargv, options, long_options,
543 		    idx, 0, flags);
544 		place = EMSG;
545 		return (optchar);
546 	}
547 	if (*++oli != ':') {			/* doesn't take argument */
548 		if (!*place)
549 			++optind;
550 	} else {				/* takes (optional) argument */
551 		optarg = NULL;
552 		if (*place)			/* no white space */
553 			optarg = place;
554 		else if (oli[1] != ':') {	/* arg not optional */
555 			if (++optind >= nargc) {	/* no arg */
556 				place = EMSG;
557 				if (PRINT_ERROR)
558 					warnx(recargchar, optchar);
559 				optopt = optchar;
560 				return (BADARG);
561 			} else
562 				optarg = nargv[optind];
563 		}
564 		place = EMSG;
565 		++optind;
566 	}
567 	/* dump back option letter */
568 	return (optchar);
569 }
570 
571 #ifdef REPLACE_GETOPT
572 /*
573  * getopt --
574  *	Parse argc/argv argument vector.
575  *
576  * [eventually this will replace the BSD getopt]
577  */
578 int
579 getopt(int nargc, char * const *nargv, const char *options)
580 {
581 
582 	/*
583 	 * We don't pass FLAG_PERMUTE to getopt_internal() since
584 	 * the BSD getopt(3) (unlike GNU) has never done this.
585 	 *
586 	 * Furthermore, since many privileged programs call getopt()
587 	 * before dropping privileges it makes sense to keep things
588 	 * as simple (and bug-free) as possible.
589 	 */
590 	return (getopt_internal(nargc, nargv, options, NULL, NULL, 0));
591 }
592 #endif /* REPLACE_GETOPT */
593 
594 /*
595  * getopt_long --
596  *	Parse argc/argv argument vector.
597  */
598 int
599 getopt_long(int nargc, char * const *nargv, const char *options,
600 	const struct option *long_options, int *idx)
601 {
602 
603 	return (getopt_internal(nargc, nargv, options, long_options, idx,
604 	    FLAG_PERMUTE));
605 }
606 
607 /*
608  * getopt_long_only --
609  *	Parse argc/argv argument vector.
610  */
611 int
612 getopt_long_only(int nargc, char * const *nargv, const char *options,
613 	const struct option *long_options, int *idx)
614 {
615 
616 	return (getopt_internal(nargc, nargv, options, long_options, idx,
617 	    FLAG_PERMUTE|FLAG_LONGONLY));
618 }
619