source: mainline/uspace/lib/c/generic/getopt.c@ 02fe42e

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 02fe42e was d1582b50, checked in by Jiri Svoboda <jiri@…>, 5 years ago

Fix spacing in single-line comments using latest ccheck

This found incorrectly formatted section comments (with blocks of
asterisks or dashes). I strongly believe against using section comments
but I am not simply removing them since that would probably be
controversial.
  • Property mode set to 100644
File size: 12.2 KB
Line 
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 <stdio.h>
37#include <stdlib.h>
38#include <stddef.h>
39#include <errno.h>
40#include <getopt.h>
41#include <str.h>
42
43/*
44 * HelenOS Port : We're incorporating only the modern getopt_long with wrappers
45 * to keep legacy getopt() usage from breaking. All references to REPLACE_GETOPT
46 * are dropped, we just include the code
47 */
48
49int opterr = 1; /* if error message should be printed */
50int optind = 1; /* index into parent argv vector */
51int optopt = '?'; /* character checked for validity */
52int optreset; /* reset getopt */
53char *optarg; /* argument associated with option */
54
55#define IGNORE_FIRST (*options == '-' || *options == '+')
56#define PRINT_ERROR ((opterr) && ((*options != ':') \
57 || (IGNORE_FIRST && options[1] != ':')))
58/* HelenOS Port - POSIXLY_CORRECT is always false */
59#define IS_POSIXLY_CORRECT 0
60#define PERMUTE (!IS_POSIXLY_CORRECT && !IGNORE_FIRST)
61/* XXX: GNU ignores PC if *options == '-' */
62#define IN_ORDER (!IS_POSIXLY_CORRECT && *options == '-')
63
64/* return values */
65#define BADCH (int)'?'
66#define BADARG ((IGNORE_FIRST && options[1] == ':') \
67 || (*options == ':') ? (int)':' : (int)'?')
68#define INORDER (int)1
69
70static char EMSG[] = "";
71
72static int getopt_internal(int, char **, const char *);
73static int gcd(int, int);
74static void permute_args(int, int, int, char **);
75
76static char *place = EMSG; /* option letter processing */
77
78/* XXX: set optreset to 1 rather than these two */
79static int nonopt_start = -1; /* first non option argument (for permute) */
80static int nonopt_end = -1; /* first option after non options (for permute) */
81
82/* Error messages */
83
84/*
85 * HelenOS Port: Calls to warnx() were eliminated (as we have no stderr that
86 * may be redirected) and replaced with printf. As such, error messages now
87 * end in a newline
88 */
89
90static const char recargchar[] = "option requires an argument -- %c\n";
91static const char recargstring[] = "option requires an argument -- %s\n";
92static const char ambig[] = "ambiguous option -- %.*s\n";
93static const char noarg[] = "option doesn't take an argument -- %.*s\n";
94static const char illoptchar[] = "unknown option -- %c\n";
95static const char illoptstring[] = "unknown option -- %s\n";
96
97/*
98 * Compute the greatest common divisor of a and b.
99 */
100static int gcd(int a, 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 */
119static void permute_args(int panonopt_start, int panonopt_end, int opt_end,
120 char **nargv)
121{
122 int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;
123 char *swap;
124
125 assert(nargv != NULL);
126
127 /*
128 * compute lengths of blocks and number and size of cycles
129 */
130 nnonopts = panonopt_end - panonopt_start;
131 nopts = opt_end - panonopt_end;
132 ncycle = gcd(nnonopts, nopts);
133 cyclelen = (opt_end - panonopt_start) / ncycle;
134
135 for (i = 0; i < ncycle; i++) {
136 cstart = panonopt_end + i;
137 pos = cstart;
138 for (j = 0; j < cyclelen; j++) {
139 if (pos >= panonopt_end)
140 pos -= nnonopts;
141 else
142 pos += nopts;
143 swap = nargv[pos];
144 nargv[pos] = nargv[cstart];
145 nargv[cstart] = swap;
146 }
147 }
148}
149
150/*
151 * getopt_internal --
152 * Parse argc/argv argument vector. Called by user level routines.
153 * Returns -2 if -- is found (can be long option or end of options marker).
154 */
155static int getopt_internal(int nargc, char **nargv, const char *options)
156{
157 const char *oli; /* option letter list index */
158 int optchar;
159
160 assert(nargv != NULL);
161 assert(options != NULL);
162
163 optarg = NULL;
164
165 /*
166 * XXX Some programs (like rsyncd) expect to be able to
167 * XXX re-initialize optind to 0 and have getopt_long(3)
168 * XXX properly function again. Work around this braindamage.
169 */
170 if (optind == 0)
171 optind = 1;
172
173 if (optreset)
174 nonopt_start = nonopt_end = -1;
175start:
176 if (optreset || !*place) { /* update scanning pointer */
177 optreset = 0;
178 if (optind >= nargc) { /* end of argument vector */
179 place = EMSG;
180 if (nonopt_end != -1) {
181 /* do permutation, if we have to */
182 permute_args(nonopt_start, nonopt_end,
183 optind, nargv);
184 optind -= nonopt_end - nonopt_start;
185 } else if (nonopt_start != -1) {
186 /*
187 * If we skipped non-options, set optind
188 * to the first of them.
189 */
190 optind = nonopt_start;
191 }
192 nonopt_start = nonopt_end = -1;
193 return -1;
194 }
195 if ((*(place = nargv[optind]) != '-') ||
196 (place[1] == '\0')) { /* found non-option */
197 place = EMSG;
198 if (IN_ORDER) {
199 /*
200 * GNU extension:
201 * return non-option as argument to option 1
202 */
203 optarg = nargv[optind++];
204 return INORDER;
205 }
206 if (!PERMUTE) {
207 /*
208 * if no permutation wanted, stop parsing
209 * at first non-option
210 */
211 return -1;
212 }
213 /* do permutation */
214 if (nonopt_start == -1)
215 nonopt_start = optind;
216 else if (nonopt_end != -1) {
217 permute_args(nonopt_start, nonopt_end,
218 optind, nargv);
219 nonopt_start = optind -
220 (nonopt_end - nonopt_start);
221 nonopt_end = -1;
222 }
223 optind++;
224 /* process next argument */
225 goto start;
226 }
227 if (nonopt_start != -1 && nonopt_end == -1)
228 nonopt_end = optind;
229 if (place[1] && *++place == '-') { /* found "--" */
230 place++;
231 return -2;
232 }
233 }
234 if ((optchar = (int)*place++) == (int)':' ||
235 (oli = str_chr(options + (IGNORE_FIRST ? 1 : 0), optchar)) == NULL) {
236 /* option letter unknown or ':' */
237 if (!*place)
238 ++optind;
239 if (PRINT_ERROR)
240 printf(illoptchar, optchar);
241 optopt = optchar;
242 return BADCH;
243 }
244 if (optchar == 'W' && oli[1] == ';') { /* -W long-option */
245 /* XXX: what if no long options provided (called by getopt)? */
246 if (*place)
247 return -2;
248
249 if (++optind >= nargc) { /* no arg */
250 place = EMSG;
251 if (PRINT_ERROR)
252 printf(recargchar, optchar);
253 optopt = optchar;
254 return BADARG;
255 } else /* white space */
256 place = nargv[optind];
257 /*
258 * Handle -W arg the same as --arg (which causes getopt to
259 * stop parsing).
260 */
261 return -2;
262 }
263 if (*++oli != ':') { /* doesn't take argument */
264 if (!*place)
265 ++optind;
266 } else { /* takes (optional) argument */
267 optarg = NULL;
268 if (*place) /* no white space */
269 optarg = place;
270 /* XXX: disable test for :: if PC? (GNU doesn't) */
271 else if (oli[1] != ':') { /* arg not optional */
272 if (++optind >= nargc) { /* no arg */
273 place = EMSG;
274 if (PRINT_ERROR)
275 printf(recargchar, optchar);
276 optopt = optchar;
277 return BADARG;
278 } else
279 optarg = nargv[optind];
280 }
281 place = EMSG;
282 ++optind;
283 }
284 /* dump back option letter */
285 return optchar;
286}
287
288/*
289 * getopt --
290 * Parse argc/argv argument vector.
291 */
292int getopt(int nargc, char *const *nargv, const char *options)
293{
294 int retval;
295
296 assert(nargv != NULL);
297 assert(options != NULL);
298
299 retval = getopt_internal(nargc, (char **)nargv, options);
300 if (retval == -2) {
301 ++optind;
302 /*
303 * We found an option (--), so if we skipped non-options,
304 * we have to permute.
305 */
306 if (nonopt_end != -1) {
307 permute_args(nonopt_start, nonopt_end, optind,
308 (char **)nargv);
309 optind -= nonopt_end - nonopt_start;
310 }
311 nonopt_start = nonopt_end = -1;
312 retval = -1;
313 }
314 return retval;
315}
316
317/*
318 * getopt_long --
319 * Parse argc/argv argument vector.
320 */
321int getopt_long(int nargc, char *const *nargv, const char *options,
322 const struct option *long_options, int *idx)
323{
324 int retval;
325
326#define IDENTICAL_INTERPRETATION(_x, _y) \
327 (long_options[(_x)].has_arg == long_options[(_y)].has_arg && \
328 long_options[(_x)].flag == long_options[(_y)].flag && \
329 long_options[(_x)].val == long_options[(_y)].val)
330
331 assert(nargv != NULL);
332 assert(options != NULL);
333 assert(long_options != NULL);
334 /* idx may be NULL */
335
336 retval = getopt_internal(nargc, (char **)nargv, options);
337 if (retval == -2) {
338 char *current_argv;
339 char *has_equal;
340 size_t current_argv_len;
341 int i, ambiguous, match;
342
343 current_argv = (char *)place;
344 match = -1;
345 ambiguous = 0;
346
347 optind++;
348 place = EMSG;
349
350 if (*current_argv == '\0') { /* found "--" */
351 /*
352 * We found an option (--), so if we skipped
353 * non-options, we have to permute.
354 */
355 if (nonopt_end != -1) {
356 permute_args(nonopt_start, nonopt_end,
357 optind, (char **)nargv);
358 optind -= nonopt_end - nonopt_start;
359 }
360 nonopt_start = nonopt_end = -1;
361 return -1;
362 }
363 if ((has_equal = str_chr(current_argv, '=')) != NULL) {
364 /* argument found (--option=arg) */
365 current_argv_len = has_equal - current_argv;
366 has_equal++;
367 } else
368 current_argv_len = str_size(current_argv);
369
370 for (i = 0; long_options[i].name; i++) {
371 /* find matching long option */
372 if (str_lcmp(current_argv, long_options[i].name,
373 str_nlength(current_argv, current_argv_len)))
374 continue;
375
376 if (str_size(long_options[i].name) ==
377 (unsigned)current_argv_len) {
378 /* exact match */
379 match = i;
380 ambiguous = 0;
381 break;
382 }
383 if (match == -1) /* partial match */
384 match = i;
385 else if (!IDENTICAL_INTERPRETATION(i, match))
386 ambiguous = 1;
387 }
388 if (ambiguous) {
389 /* ambiguous abbreviation */
390 if (PRINT_ERROR)
391 printf(ambig, (int)current_argv_len,
392 current_argv);
393 optopt = 0;
394 return BADCH;
395 }
396 if (match != -1) { /* option found */
397 if (long_options[match].has_arg == no_argument &&
398 has_equal) {
399 if (PRINT_ERROR)
400 printf(noarg, (int)current_argv_len,
401 current_argv);
402 /*
403 * XXX: GNU sets optopt to val regardless of
404 * flag
405 */
406 if (long_options[match].flag == NULL)
407 optopt = long_options[match].val;
408 else
409 optopt = 0;
410 return BADARG;
411 }
412 if (long_options[match].has_arg == required_argument ||
413 long_options[match].has_arg == optional_argument) {
414 if (has_equal)
415 optarg = has_equal;
416 else if (long_options[match].has_arg ==
417 required_argument) {
418 /*
419 * optional argument doesn't use
420 * next nargv
421 */
422 optarg = nargv[optind++];
423 }
424 }
425 if ((long_options[match].has_arg == required_argument) &&
426 (optarg == NULL)) {
427 /*
428 * Missing argument; leading ':'
429 * indicates no error should be generated
430 */
431 if (PRINT_ERROR)
432 printf(recargstring, current_argv);
433 /*
434 * XXX: GNU sets optopt to val regardless
435 * of flag
436 */
437 if (long_options[match].flag == NULL)
438 optopt = long_options[match].val;
439 else
440 optopt = 0;
441 --optind;
442 return BADARG;
443 }
444 } else { /* unknown option */
445 if (PRINT_ERROR)
446 printf(illoptstring, current_argv);
447 optopt = 0;
448 return BADCH;
449 }
450 if (long_options[match].flag) {
451 *long_options[match].flag = long_options[match].val;
452 retval = 0;
453 } else
454 retval = long_options[match].val;
455 if (idx)
456 *idx = match;
457 }
458 return retval;
459#undef IDENTICAL_INTERPRETATION
460}
Note: See TracBrowser for help on using the repository browser.