]>
Commit | Line | Data |
---|---|---|
2b6fc908 KZ |
1 | /* |
2 | getopt.c - Enhanced implementation of BSD getopt(1) | |
cf6d7fae | 3 | Copyright (c) 1997-2005 Frodo Looijaard <frodo@frodo.looijaard.name> |
2b6fc908 KZ |
4 | |
5 | This program is free software; you can redistribute it and/or modify | |
6 | it under the terms of the GNU General Public License as published by | |
7 | the Free Software Foundation; either version 2 of the License, or | |
8 | (at your option) any later version. | |
9 | ||
10 | This program is distributed in the hope that it will be useful, | |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 | GNU General Public License for more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License | |
16 | along with this program; if not, write to the Free Software | |
17 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
18 | */ | |
19 | ||
20 | /* | |
21 | * Version 1.0-b4: Tue Sep 23 1997. First public release. | |
22 | * Version 1.0: Wed Nov 19 1997. | |
23 | * Bumped up the version number to 1.0 | |
24 | * Fixed minor typo (CSH instead of TCSH) | |
25 | * Version 1.0.1: Tue Jun 3 1998 | |
26 | * Fixed sizeof instead of strlen bug | |
27 | * Bumped up the version number to 1.0.1 | |
28 | * Version 1.0.2: Thu Jun 11 1998 (not present) | |
29 | * Fixed gcc-2.8.1 warnings | |
30 | * Fixed --version/-V option (not present) | |
66ee8158 KZ |
31 | * Version 1.0.5: Tue Jun 22 1999 |
32 | * Make -u option work (not present) | |
33 | * Version 1.0.6: Tue Jun 27 2000 | |
34 | * No important changes | |
35 | * Version 1.1.0: Tue Jun 30 2000 | |
36 | * Added NLS support (partly written by Arkadiusz Mi<B6>kiewicz | |
df1dddf9 | 37 | * <misiek@pld.org.pl>) |
cf6d7fae KZ |
38 | * Version 1.1.4: Mon Nov 7 2005 |
39 | * Fixed a few type's in the manpage | |
2b6fc908 KZ |
40 | */ |
41 | ||
42 | #include <stdio.h> | |
43 | #include <stdlib.h> | |
44 | #include <string.h> | |
45 | #include <unistd.h> | |
46 | #include <ctype.h> | |
47 | ||
48 | #if LIBCGETOPT | |
49 | #include <getopt.h> | |
50 | #else | |
51 | #include "getopt.h" | |
52 | #endif | |
53 | ||
df1dddf9 | 54 | #include "nls.h" |
66ee8158 | 55 | |
2b6fc908 KZ |
56 | /* NON_OPT is the code that is returned when a non-option is found in '+' |
57 | mode */ | |
58 | #define NON_OPT 1 | |
59 | /* LONG_OPT is the code that is returned when a long option is found. */ | |
60 | #define LONG_OPT 2 | |
61 | ||
62 | /* The shells recognized. */ | |
63 | typedef enum {BASH,TCSH} shell_t; | |
64 | ||
65 | ||
66 | /* Some global variables that tells us how to parse. */ | |
67 | shell_t shell=BASH; /* The shell we generate output for. */ | |
68 | int quiet_errors=0; /* 0 is not quiet. */ | |
69 | int quiet_output=0; /* 0 is not quiet. */ | |
70 | int quote=1; /* 1 is do quote. */ | |
71 | int alternative=0; /* 0 is getopt_long, 1 is getopt_long_only */ | |
72 | ||
73 | /* Function prototypes */ | |
74 | void *our_malloc(size_t size); | |
75 | void *our_realloc(void *ptr, size_t size); | |
76 | const char *normalize(const char *arg); | |
77 | int generate_output(char * argv[],int argc,const char *optstr, | |
78 | const struct option *longopts); | |
79 | int main(int argc, char *argv[]); | |
80 | void parse_error(const char *message); | |
81 | void add_long_options(char *options); | |
82 | void add_longopt(const char *name,int has_arg); | |
83 | void print_help(void); | |
84 | void set_shell(const char *new_shell); | |
85 | void set_initial_shell(void); | |
86 | ||
87 | void *our_malloc(size_t size) | |
88 | { | |
89 | void *ret=malloc(size); | |
90 | if (! ret) { | |
7eda085c | 91 | fprintf(stderr,_("%s: Out of memory!\n"),"getopt"); |
2b6fc908 KZ |
92 | exit(3); |
93 | } | |
94 | return(ret); | |
95 | } | |
96 | ||
97 | void *our_realloc(void *ptr, size_t size) | |
98 | { | |
66ee8158 KZ |
99 | void *ret=realloc(ptr,size); |
100 | if (! ret && size) { | |
101 | fprintf(stderr,_("%s: Out of memory!\n"),"getopt"); | |
102 | exit(3); | |
103 | } | |
104 | return(ret); | |
2b6fc908 KZ |
105 | } |
106 | ||
107 | /* | |
108 | * This function 'normalizes' a single argument: it puts single quotes around | |
109 | * it and escapes other special characters. If quote is false, it just | |
110 | * returns its argument. | |
111 | * Bash only needs special treatment for single quotes; tcsh also recognizes | |
112 | * exclamation marks within single quotes, and nukes whitespace. | |
113 | * This function returns a pointer to a buffer that is overwritten by | |
114 | * each call. | |
115 | */ | |
116 | const char *normalize(const char *arg) | |
117 | { | |
118 | static char *BUFFER=NULL; | |
119 | const char *argptr=arg; | |
120 | char *bufptr; | |
121 | ||
66ee8158 KZ |
122 | if (BUFFER != NULL) |
123 | free(BUFFER); | |
2b6fc908 KZ |
124 | |
125 | if (!quote) { /* Just copy arg */ | |
126 | BUFFER=our_malloc(strlen(arg)+1); | |
127 | ||
128 | strcpy(BUFFER,arg); | |
129 | return BUFFER; | |
130 | } | |
131 | ||
132 | /* Each character in arg may take upto four characters in the result: | |
133 | For a quote we need a closing quote, a backslash, a quote and an | |
134 | opening quote! We need also the global opening and closing quote, | |
135 | and one extra character for '\0'. */ | |
136 | BUFFER=our_malloc(strlen(arg)*4+3); | |
137 | ||
138 | bufptr=BUFFER; | |
139 | *bufptr++='\''; | |
140 | ||
141 | while (*argptr) { | |
142 | if (*argptr == '\'') { | |
143 | /* Quote: replace it with: '\'' */ | |
144 | *bufptr++='\''; | |
145 | *bufptr++='\\'; | |
146 | *bufptr++='\''; | |
147 | *bufptr++='\''; | |
148 | } else if (shell==TCSH && *argptr=='!') { | |
149 | /* Exclamation mark: replace it with: \! */ | |
150 | *bufptr++='\''; | |
151 | *bufptr++='\\'; | |
152 | *bufptr++='!'; | |
153 | *bufptr++='\''; | |
154 | } else if (shell==TCSH && *argptr=='\n') { | |
155 | /* Newline: replace it with: \n */ | |
156 | *bufptr++='\\'; | |
157 | *bufptr++='n'; | |
158 | } else if (shell==TCSH && isspace(*argptr)) { | |
159 | /* Non-newline whitespace: replace it with \<ws> */ | |
160 | *bufptr++='\''; | |
161 | *bufptr++='\\'; | |
162 | *bufptr++=*argptr; | |
163 | *bufptr++='\''; | |
164 | } else | |
165 | /* Just copy */ | |
166 | *bufptr++=*argptr; | |
167 | argptr++; | |
168 | } | |
169 | *bufptr++='\''; | |
170 | *bufptr++='\0'; | |
171 | return BUFFER; | |
172 | } | |
173 | ||
174 | /* | |
175 | * Generate the output. argv[0] is the program name (used for reporting errors). | |
176 | * argv[1..] contains the options to be parsed. argc must be the number of | |
177 | * elements in argv (ie. 1 if there are no options, only the program name), | |
178 | * optstr must contain the short options, and longopts the long options. | |
179 | * Other settings are found in global variables. | |
180 | */ | |
181 | int generate_output(char * argv[],int argc,const char *optstr, | |
182 | const struct option *longopts) | |
183 | { | |
184 | int exit_code = 0; /* We assume everything will be OK */ | |
185 | int opt; | |
186 | int longindex; | |
187 | const char *charptr; | |
188 | ||
189 | if (quiet_errors) /* No error reporting from getopt(3) */ | |
190 | opterr=0; | |
191 | optind=0; /* Reset getopt(3) */ | |
192 | ||
193 | while ((opt = (alternative? | |
194 | getopt_long_only(argc,argv,optstr,longopts,&longindex): | |
195 | getopt_long(argc,argv,optstr,longopts,&longindex))) | |
196 | != EOF) | |
197 | if (opt == '?' || opt == ':' ) | |
198 | exit_code = 1; | |
199 | else if (!quiet_output) | |
200 | { | |
201 | if (opt == LONG_OPT) { | |
202 | printf(" --%s",longopts[longindex].name); | |
203 | if (longopts[longindex].has_arg) | |
204 | printf(" %s", | |
205 | normalize(optarg?optarg:"")); | |
206 | } else if (opt == NON_OPT) | |
207 | printf(" %s",normalize(optarg)); | |
208 | else { | |
209 | printf(" -%c",opt); | |
210 | charptr = strchr(optstr,opt); | |
211 | if (charptr != NULL && *++charptr == ':') | |
212 | printf(" %s", | |
213 | normalize(optarg?optarg:"")); | |
214 | } | |
215 | } | |
216 | ||
217 | if (! quiet_output) { | |
218 | printf(" --"); | |
219 | while (optind < argc) | |
220 | printf(" %s",normalize(argv[optind++])); | |
221 | printf("\n"); | |
222 | } | |
223 | return exit_code; | |
224 | } | |
225 | ||
226 | /* | |
227 | * Report an error when parsing getopt's own arguments. | |
228 | * If message is NULL, we already sent a message, we just exit with a helpful | |
229 | * hint. | |
230 | */ | |
231 | void parse_error(const char *message) | |
232 | { | |
233 | if (message) | |
234 | fprintf(stderr,"getopt: %s\n",message); | |
7eda085c | 235 | fputs(_("Try `getopt --help' for more information.\n"),stderr); |
2b6fc908 KZ |
236 | exit(2); |
237 | } | |
238 | ||
239 | static struct option *long_options=NULL; | |
240 | static int long_options_length=0; /* Length of array */ | |
241 | static int long_options_nr=0; /* Nr of used elements in array */ | |
242 | #define LONG_OPTIONS_INCR 10 | |
243 | #define init_longopt() add_longopt(NULL,0) | |
244 | ||
245 | /* Register a long option. The contents of name is copied. */ | |
246 | void add_longopt(const char *name,int has_arg) | |
247 | { | |
248 | char *tmp; | |
249 | if (!name) { /* init */ | |
250 | free(long_options); | |
251 | long_options=NULL; | |
252 | long_options_length=0; | |
253 | long_options_nr=0; | |
254 | } | |
255 | ||
256 | if (long_options_nr == long_options_length) { | |
257 | long_options_length += LONG_OPTIONS_INCR; | |
258 | long_options=our_realloc(long_options, | |
259 | sizeof(struct option) * | |
260 | long_options_length); | |
261 | } | |
262 | ||
263 | long_options[long_options_nr].name=NULL; | |
264 | long_options[long_options_nr].has_arg=0; | |
265 | long_options[long_options_nr].flag=NULL; | |
266 | long_options[long_options_nr].val=0; | |
267 | ||
268 | if (long_options_nr) { /* Not for init! */ | |
269 | long_options[long_options_nr-1].has_arg=has_arg; | |
270 | long_options[long_options_nr-1].flag=NULL; | |
271 | long_options[long_options_nr-1].val=LONG_OPT; | |
272 | tmp = our_malloc(strlen(name)+1); | |
273 | strcpy(tmp,name); | |
274 | long_options[long_options_nr-1].name=tmp; | |
275 | } | |
276 | long_options_nr++; | |
277 | } | |
278 | ||
279 | ||
280 | /* | |
281 | * Register several long options. options is a string of long options, | |
282 | * separated by commas or whitespace. | |
283 | * This nukes options! | |
284 | */ | |
285 | void add_long_options(char *options) | |
286 | { | |
287 | int arg_opt; | |
288 | char *tokptr=strtok(options,", \t\n"); | |
289 | while (tokptr) { | |
290 | arg_opt=no_argument; | |
291 | if (strlen(tokptr) > 0) { | |
292 | if (tokptr[strlen(tokptr)-1] == ':') { | |
293 | if (tokptr[strlen(tokptr)-2] == ':') { | |
294 | tokptr[strlen(tokptr)-2]='\0'; | |
295 | arg_opt=optional_argument; | |
296 | } else { | |
297 | tokptr[strlen(tokptr)-1]='\0'; | |
298 | arg_opt=required_argument; | |
299 | } | |
300 | if (strlen(tokptr) == 0) | |
7eda085c KZ |
301 | parse_error(_("empty long option after " |
302 | "-l or --long argument")); | |
2b6fc908 KZ |
303 | } |
304 | add_longopt(tokptr,arg_opt); | |
305 | } | |
306 | tokptr=strtok(NULL,", \t\n"); | |
307 | } | |
308 | } | |
309 | ||
310 | void set_shell(const char *new_shell) | |
311 | { | |
312 | if (!strcmp(new_shell,"bash")) | |
313 | shell=BASH; | |
314 | else if (!strcmp(new_shell,"tcsh")) | |
315 | shell=TCSH; | |
316 | else if (!strcmp(new_shell,"sh")) | |
317 | shell=BASH; | |
318 | else if (!strcmp(new_shell,"csh")) | |
319 | shell=TCSH; | |
320 | else | |
7eda085c | 321 | parse_error(_("unknown shell after -s or --shell argument")); |
2b6fc908 KZ |
322 | } |
323 | ||
324 | void print_help(void) | |
325 | { | |
7eda085c KZ |
326 | fputs(_("Usage: getopt optstring parameters\n"),stderr); |
327 | fputs(_(" getopt [options] [--] optstring parameters\n"),stderr); | |
328 | fputs(_(" getopt [options] -o|--options optstring [options] [--]\n"),stderr); | |
66ee8158 | 329 | fputs(_(" parameters\n"),stderr); |
7eda085c KZ |
330 | fputs(_(" -a, --alternative Allow long options starting with single -\n"),stderr); |
331 | fputs(_(" -h, --help This small usage guide\n"),stderr); | |
332 | fputs(_(" -l, --longoptions=longopts Long options to be recognized\n"),stderr); | |
333 | fputs(_(" -n, --name=progname The name under which errors are reported\n"),stderr); | |
334 | fputs(_(" -o, --options=optstring Short options to be recognized\n"),stderr); | |
66ee8158 | 335 | fputs(_(" -q, --quiet Disable error reporting by getopt(3)\n"),stderr); |
7eda085c KZ |
336 | fputs(_(" -Q, --quiet-output No normal output\n"),stderr); |
337 | fputs(_(" -s, --shell=shell Set shell quoting conventions\n"),stderr); | |
338 | fputs(_(" -T, --test Test for getopt(1) version\n"),stderr); | |
66ee8158 | 339 | fputs(_(" -u, --unqote Do not quote the output\n"),stderr); |
7eda085c | 340 | fputs(_(" -V, --version Output version information\n"),stderr); |
2b6fc908 KZ |
341 | exit(2); |
342 | } | |
343 | ||
344 | /* Exit codes: | |
345 | * 0) No errors, succesful operation. | |
346 | * 1) getopt(3) returned an error. | |
347 | * 2) A problem with parameter parsing for getopt(1). | |
348 | * 3) Internal error, out of memory | |
349 | * 4) Returned for -T | |
350 | */ | |
351 | ||
352 | static struct option longopts[]={ {"options",required_argument,NULL,'o'}, | |
353 | {"longoptions",required_argument,NULL,'l'}, | |
354 | {"quiet",no_argument,NULL,'q'}, | |
355 | {"quiet-output",no_argument,NULL,'Q'}, | |
356 | {"shell",required_argument,NULL,'s'}, | |
357 | {"test",no_argument,NULL,'T'}, | |
358 | {"unquoted",no_argument,NULL,'u'}, | |
359 | {"help",no_argument,NULL,'h'}, | |
360 | {"alternative",no_argument,NULL,'a'}, | |
361 | {"name",required_argument,NULL,'n'}, | |
362 | {"version",no_argument,NULL,'V'}, | |
363 | {NULL,0,NULL,0} | |
364 | }; | |
365 | ||
366 | /* Stop scanning as soon as a non-option argument is found! */ | |
367 | static const char *shortopts="+ao:l:n:qQs:TuhV"; | |
368 | ||
369 | int main(int argc, char *argv[]) | |
370 | { | |
371 | char *optstr=NULL; | |
372 | char *name=NULL; | |
5c36a0eb | 373 | int opt; |
2b6fc908 KZ |
374 | int compatible=0; |
375 | ||
cf6d7fae | 376 | #if WITHOUT_GETTEXT |
df1dddf9 | 377 | #else |
66ee8158 | 378 | setlocale(LC_ALL,""); |
7eda085c KZ |
379 | bindtextdomain(PACKAGE, LOCALEDIR); |
380 | textdomain(PACKAGE); | |
df1dddf9 | 381 | #endif |
7eda085c | 382 | |
2b6fc908 KZ |
383 | init_longopt(); |
384 | ||
385 | if (getenv("GETOPT_COMPATIBLE")) | |
386 | compatible=1; | |
387 | ||
388 | if (argc == 1) | |
389 | { | |
390 | if (compatible) { | |
391 | /* For some reason, the original getopt gave no error | |
392 | when there were no arguments. */ | |
393 | printf(" --\n"); | |
394 | exit(0); | |
395 | } | |
396 | else | |
7eda085c | 397 | parse_error(_("missing optstring argument")); |
2b6fc908 KZ |
398 | } |
399 | ||
400 | if (argv[1][0] != '-' || compatible) { | |
401 | quote=0; | |
402 | optstr=our_malloc(strlen(argv[1])+1); | |
403 | strcpy(optstr,argv[1]+strspn(argv[1],"-+")); | |
404 | argv[1]=argv[0]; | |
405 | exit(generate_output(argv+1,argc-1,optstr,long_options)); | |
406 | } | |
407 | ||
408 | while ((opt=getopt_long(argc,argv,shortopts,longopts,NULL)) != EOF) | |
409 | switch (opt) { | |
410 | case 'a': | |
411 | alternative=1; | |
412 | break; | |
413 | case 'h': | |
414 | print_help(); | |
415 | exit(0); | |
416 | case 'o': | |
417 | if (optstr) | |
418 | free(optstr); | |
419 | optstr=our_malloc(strlen(optarg)+1); | |
420 | strcpy(optstr,optarg); | |
421 | break; | |
422 | case 'l': | |
423 | add_long_options(optarg); | |
424 | break; | |
425 | case 'n': | |
426 | if (name) | |
427 | free(name); | |
428 | name=our_malloc(strlen(optarg)+1); | |
429 | strcpy(name,optarg); | |
430 | break; | |
431 | case 'q': | |
432 | quiet_errors=1; | |
433 | break; | |
434 | case 'Q': | |
435 | quiet_output=1; | |
436 | break; | |
437 | case 's': | |
438 | set_shell(optarg); | |
439 | break; | |
440 | case 'T': | |
441 | exit(4); | |
66ee8158 KZ |
442 | case 'u': |
443 | quote=0; | |
444 | break; | |
2b6fc908 | 445 | case 'V': |
cf6d7fae | 446 | printf(_("getopt (enhanced) 1.1.4\n")); |
2b6fc908 KZ |
447 | exit(0); |
448 | case '?': | |
449 | case ':': | |
450 | parse_error(NULL); | |
451 | default: | |
7eda085c | 452 | parse_error(_("internal error, contact the author.")); |
2b6fc908 KZ |
453 | } |
454 | ||
455 | if (!optstr) | |
456 | { | |
457 | if (optind >= argc) | |
7eda085c | 458 | parse_error(_("missing optstring argument")); |
2b6fc908 KZ |
459 | else { |
460 | optstr=our_malloc(strlen(argv[optind])+1); | |
461 | strcpy(optstr,argv[optind]); | |
462 | optind++; | |
463 | } | |
464 | } | |
465 | if (name) | |
466 | argv[optind-1]=name; | |
467 | else | |
468 | argv[optind-1]=argv[0]; | |
469 | exit(generate_output(argv+optind-1,argc-optind+1,optstr,long_options)); | |
470 | } |