… | |
… | |
49 | #define GETOPT_EXIT_CODE 1 |
49 | #define GETOPT_EXIT_CODE 1 |
50 | #define PARAMETER_EXIT_CODE 2 |
50 | #define PARAMETER_EXIT_CODE 2 |
51 | #define XALLOC_EXIT_CODE 3 |
51 | #define XALLOC_EXIT_CODE 3 |
52 | #define TEST_EXIT_CODE 4 |
52 | #define TEST_EXIT_CODE 4 |
53 | |
53 | |
54 | |
|
|
55 | #include <stdio.h> |
54 | #include <stdio.h> |
56 | #include <stdlib.h> |
55 | #include <stdlib.h> |
57 | #include <string.h> |
56 | #include <string.h> |
58 | #include <unistd.h> |
57 | #include <unistd.h> |
59 | #include <ctype.h> |
58 | #include <ctype.h> |
… | |
… | |
63 | #else |
62 | #else |
64 | #include "getopt.h" |
63 | #include "getopt.h" |
65 | #endif |
64 | #endif |
66 | |
65 | |
67 | #include "nls.h" |
66 | #include "nls.h" |
|
|
67 | #include "xalloc.h" |
68 | |
68 | |
69 | /* NON_OPT is the code that is returned when a non-option is found in '+' |
69 | /* NON_OPT is the code that is returned when a non-option is found in '+' |
70 | * mode */ |
70 | * mode */ |
71 | #define NON_OPT 1 |
71 | #define NON_OPT 1 |
72 | /* LONG_OPT is the code that is returned when a long option is found. */ |
72 | /* LONG_OPT is the code that is returned when a long option is found. */ |
73 | #define LONG_OPT 2 |
73 | #define LONG_OPT 2 |
74 | |
74 | |
75 | /* The shells recognized. */ |
75 | /* The shells recognized. */ |
76 | typedef enum {BASH,TCSH} shell_t; |
76 | typedef enum { BASH, TCSH } shell_t; |
77 | |
77 | |
78 | |
78 | |
79 | /* Some global variables that tells us how to parse. */ |
79 | /* Some global variables that tells us how to parse. */ |
80 | shell_t shell=BASH; /* The shell we generate output for. */ |
80 | static shell_t shell = BASH; /* The shell we generate output for. */ |
81 | int quiet_errors=0; /* 0 is not quiet. */ |
81 | static int quiet_errors = 0; /* 0 is not quiet. */ |
82 | int quiet_output=0; /* 0 is not quiet. */ |
82 | static int quiet_output = 0; /* 0 is not quiet. */ |
83 | int quote=1; /* 1 is do quote. */ |
83 | static int quote = 1; /* 1 is do quote. */ |
84 | int alternative=0; /* 0 is getopt_long, 1 is getopt_long_only */ |
84 | |
|
|
85 | /* Allow changing which getopt is in use with function pointer */ |
|
|
86 | int (*getopt_long_fp) (int argc, char *const *argv, const char *optstr, |
|
|
87 | const struct option * longopts, int *longindex); |
85 | |
88 | |
86 | /* Function prototypes */ |
89 | /* Function prototypes */ |
87 | void *our_malloc(size_t size); |
|
|
88 | void *our_realloc(void *ptr, size_t size); |
|
|
89 | const char *normalize(const char *arg); |
90 | static const char *normalize(const char *arg); |
90 | int generate_output(char * argv[],int argc,const char *optstr, |
91 | static int generate_output(char *argv[], int argc, const char *optstr, |
91 | const struct option *longopts); |
92 | const struct option *longopts); |
92 | int main(int argc, char *argv[]); |
93 | int main(int argc, char *argv[]); |
93 | void parse_error(const char *message); |
94 | static void parse_error(const char *message); |
94 | void add_long_options(char *options); |
95 | static void add_long_options(char *options); |
95 | void add_longopt(const char *name,int has_arg); |
96 | static void add_longopt(const char *name, int has_arg); |
96 | void print_help(void); |
97 | static void print_help(void); |
97 | void set_shell(const char *new_shell); |
98 | static void set_shell(const char *new_shell); |
98 | void set_initial_shell(void); |
|
|
99 | |
|
|
100 | void *our_malloc(size_t size) |
|
|
101 | { |
|
|
102 | void *ret=malloc(size); |
|
|
103 | if (! ret) { |
|
|
104 | fprintf(stderr,_("%s: Out of memory!\n"),"getopt"); |
|
|
105 | exit(XALLOC_EXIT_CODE); |
|
|
106 | } |
|
|
107 | return(ret); |
|
|
108 | } |
|
|
109 | |
|
|
110 | void *our_realloc(void *ptr, size_t size) |
|
|
111 | { |
|
|
112 | void *ret=realloc(ptr,size); |
|
|
113 | if (! ret && size) { |
|
|
114 | fprintf(stderr,_("%s: Out of memory!\n"),"getopt"); |
|
|
115 | exit(XALLOC_EXIT_CODE); |
|
|
116 | } |
|
|
117 | return(ret); |
|
|
118 | } |
|
|
119 | |
99 | |
120 | /* |
100 | /* |
121 | * This function 'normalizes' a single argument: it puts single quotes |
101 | * This function 'normalizes' a single argument: it puts single quotes |
122 | * around it and escapes other special characters. If quote is false, it |
102 | * around it and escapes other special characters. If quote is false, it |
123 | * just returns its argument. |
103 | * just returns its argument. |
124 | * |
104 | * |
125 | * Bash only needs special treatment for single quotes; tcsh also recognizes |
105 | * Bash only needs special treatment for single quotes; tcsh also recognizes |
126 | * exclamation marks within single quotes, and nukes whitespace. This |
106 | * exclamation marks within single quotes, and nukes whitespace. This |
127 | * function returns a pointer to a buffer that is overwritten by each call. |
107 | * function returns a pointer to a buffer that is overwritten by each call. |
128 | */ |
108 | */ |
129 | const char *normalize(const char *arg) |
109 | static const char *normalize(const char *arg) |
130 | { |
110 | { |
131 | static char *BUFFER=NULL; |
111 | static char *BUFFER = NULL; |
132 | const char *argptr=arg; |
112 | const char *argptr = arg; |
133 | char *bufptr; |
113 | char *bufptr; |
134 | |
114 | |
135 | if (BUFFER != NULL) |
|
|
136 | free(BUFFER); |
115 | free(BUFFER); |
137 | |
116 | |
138 | if (!quote) { |
117 | if (!quote) { |
139 | /* Just copy arg */ |
118 | /* Just copy arg */ |
140 | BUFFER=our_malloc(strlen(arg)+1); |
119 | BUFFER = xmalloc(strlen(arg) + 1); |
141 | |
120 | |
142 | strcpy(BUFFER,arg); |
121 | strcpy(BUFFER, arg); |
143 | return BUFFER; |
122 | return BUFFER; |
144 | } |
123 | } |
145 | |
124 | |
146 | /* |
125 | /* |
147 | * Each character in arg may take upto four characters in the |
126 | * Each character in arg may take upto four characters in the |
148 | * result: For a quote we need a closing quote, a backslash, a quote |
127 | * result: For a quote we need a closing quote, a backslash, a quote |
149 | * and an opening quote! We need also the global opening and closing |
128 | * and an opening quote! We need also the global opening and closing |
150 | * quote, and one extra character for '\0'. |
129 | * quote, and one extra character for '\0'. |
151 | */ |
130 | */ |
152 | BUFFER=our_malloc(strlen(arg)*4+3); |
131 | BUFFER = xmalloc(strlen(arg) * 4 + 3); |
153 | |
132 | |
154 | bufptr=BUFFER; |
133 | bufptr = BUFFER; |
155 | *bufptr++='\''; |
134 | *bufptr++ = '\''; |
156 | |
135 | |
157 | while (*argptr) { |
136 | while (*argptr) { |
158 | if (*argptr == '\'') { |
137 | if (*argptr == '\'') { |
159 | /* Quote: replace it with: '\'' */ |
138 | /* Quote: replace it with: '\'' */ |
160 | *bufptr++='\''; |
139 | *bufptr++ = '\''; |
161 | *bufptr++='\\'; |
140 | *bufptr++ = '\\'; |
162 | *bufptr++='\''; |
141 | *bufptr++ = '\''; |
163 | *bufptr++='\''; |
142 | *bufptr++ = '\''; |
164 | } else if (shell==TCSH && *argptr=='!') { |
143 | } else if (shell == TCSH && *argptr == '!') { |
165 | /* Exclamation mark: replace it with: \! */ |
144 | /* Exclamation mark: replace it with: \! */ |
166 | *bufptr++='\''; |
145 | *bufptr++ = '\''; |
167 | *bufptr++='\\'; |
146 | *bufptr++ = '\\'; |
168 | *bufptr++='!'; |
147 | *bufptr++ = '!'; |
169 | *bufptr++='\''; |
148 | *bufptr++ = '\''; |
170 | } else if (shell==TCSH && *argptr=='\n') { |
149 | } else if (shell == TCSH && *argptr == '\n') { |
171 | /* Newline: replace it with: \n */ |
150 | /* Newline: replace it with: \n */ |
172 | *bufptr++='\\'; |
151 | *bufptr++ = '\\'; |
173 | *bufptr++='n'; |
152 | *bufptr++ = 'n'; |
174 | } else if (shell==TCSH && isspace(*argptr)) { |
153 | } else if (shell == TCSH && isspace(*argptr)) { |
175 | /* Non-newline whitespace: replace it with \<ws> */ |
154 | /* Non-newline whitespace: replace it with \<ws> */ |
176 | *bufptr++='\''; |
155 | *bufptr++ = '\''; |
177 | *bufptr++='\\'; |
156 | *bufptr++ = '\\'; |
178 | *bufptr++=*argptr; |
157 | *bufptr++ = *argptr; |
179 | *bufptr++='\''; |
158 | *bufptr++ = '\''; |
180 | } else |
159 | } else |
181 | /* Just copy */ |
160 | /* Just copy */ |
182 | *bufptr++=*argptr; |
161 | *bufptr++ = *argptr; |
183 | argptr++; |
162 | argptr++; |
184 | } |
163 | } |
185 | *bufptr++='\''; |
164 | *bufptr++ = '\''; |
186 | *bufptr++='\0'; |
165 | *bufptr++ = '\0'; |
187 | return BUFFER; |
166 | return BUFFER; |
188 | } |
167 | } |
189 | |
168 | |
190 | /* |
169 | /* |
191 | * Generate the output. argv[0] is the program name (used for reporting errors). |
170 | * Generate the output. argv[0] is the program name (used for reporting errors). |
192 | * argv[1..] contains the options to be parsed. argc must be the number of |
171 | * argv[1..] contains the options to be parsed. argc must be the number of |
193 | * elements in argv (ie. 1 if there are no options, only the program name), |
172 | * elements in argv (ie. 1 if there are no options, only the program name), |
194 | * optstr must contain the short options, and longopts the long options. |
173 | * optstr must contain the short options, and longopts the long options. |
195 | * Other settings are found in global variables. |
174 | * Other settings are found in global variables. |
196 | */ |
175 | */ |
197 | int generate_output(char * argv[],int argc,const char *optstr, |
176 | static int generate_output(char *argv[], int argc, const char *optstr, |
198 | const struct option *longopts) |
177 | const struct option *longopts) |
199 | { |
178 | { |
200 | int exit_code = EXIT_SUCCESS; /* Assume everything will be OK */ |
179 | int exit_code = EXIT_SUCCESS; /* Assume everything will be OK */ |
201 | int opt; |
180 | int opt; |
202 | int longindex; |
181 | int longindex; |
203 | const char *charptr; |
182 | const char *charptr; |
204 | |
183 | |
205 | if (quiet_errors) |
184 | if (quiet_errors) |
206 | /* No error reporting from getopt(3) */ |
185 | /* No error reporting from getopt(3) */ |
207 | opterr=0; |
186 | opterr = 0; |
208 | /* Reset getopt(3) */ |
187 | /* Reset getopt(3) */ |
209 | optind=0; |
188 | optind = 0; |
210 | |
189 | |
211 | while ((opt = (alternative? |
190 | while ((opt = |
212 | getopt_long_only(argc,argv,optstr,longopts,&longindex): |
|
|
213 | getopt_long(argc,argv,optstr,longopts,&longindex))) |
191 | (getopt_long_fp(argc, argv, optstr, longopts, &longindex))) |
214 | != EOF) |
192 | != EOF) |
215 | if (opt == '?' || opt == ':' ) |
193 | if (opt == '?' || opt == ':') |
216 | exit_code = GETOPT_EXIT_CODE; |
194 | exit_code = GETOPT_EXIT_CODE; |
217 | else if (!quiet_output) |
195 | else if (!quiet_output) { |
218 | { |
|
|
219 | if (opt == LONG_OPT) { |
196 | if (opt == LONG_OPT) { |
220 | printf(" --%s",longopts[longindex].name); |
197 | printf(" --%s", longopts[longindex].name); |
221 | if (longopts[longindex].has_arg) |
198 | if (longopts[longindex].has_arg) |
222 | printf(" %s", |
|
|
223 | normalize(optarg?optarg:"")); |
199 | printf(" %s", normalize(optarg ? optarg : "")); |
224 | } else if (opt == NON_OPT) |
200 | } else if (opt == NON_OPT) |
225 | printf(" %s",normalize(optarg)); |
201 | printf(" %s", normalize(optarg)); |
226 | else { |
202 | else { |
227 | printf(" -%c",opt); |
203 | printf(" -%c", opt); |
228 | charptr = strchr(optstr,opt); |
204 | charptr = strchr(optstr, opt); |
229 | if (charptr != NULL && *++charptr == ':') |
205 | if (charptr != NULL && *++charptr == ':') |
230 | printf(" %s", |
|
|
231 | normalize(optarg?optarg:"")); |
206 | printf(" %s", normalize(optarg ? optarg : "")); |
232 | } |
207 | } |
233 | } |
208 | } |
234 | |
209 | |
235 | if (! quiet_output) { |
210 | if (!quiet_output) { |
236 | printf(" --"); |
211 | printf(" --"); |
237 | while (optind < argc) |
212 | while (optind < argc) |
238 | printf(" %s",normalize(argv[optind++])); |
213 | printf(" %s", normalize(argv[optind++])); |
239 | printf("\n"); |
214 | printf("\n"); |
240 | } |
215 | } |
241 | return exit_code; |
216 | return exit_code; |
242 | } |
217 | } |
243 | |
218 | |
244 | /* |
219 | /* |
245 | * Report an error when parsing getopt's own arguments. If message is NULL, |
220 | * Report an error when parsing getopt's own arguments. If message is NULL, |
246 | * we already sent a message, we just exit with a helpful hint. |
221 | * we already sent a message, we just exit with a helpful hint. |
247 | */ |
222 | */ |
248 | void parse_error(const char *message) |
223 | static void __attribute__ ((__noreturn__)) parse_error(const char *message) |
249 | { |
224 | { |
250 | if (message) |
225 | if (message) |
251 | fprintf(stderr,"getopt: %s\n",message); |
226 | fprintf(stderr, "getopt: %s\n", message); |
252 | fputs(_("Try `getopt --help' for more information.\n"),stderr); |
227 | fputs(_("Try `getopt --help' for more information.\n"), stderr); |
253 | exit(PARAMETER_EXIT_CODE); |
228 | exit(PARAMETER_EXIT_CODE); |
254 | } |
229 | } |
255 | |
230 | |
256 | static struct option *long_options=NULL; |
231 | static struct option *long_options = NULL; |
257 | static int long_options_length=0; /* Length of array */ |
232 | static int long_options_length = 0; /* Length of array */ |
258 | static int long_options_nr=0; /* Nr of used elements in array */ |
233 | static int long_options_nr = 0; /* Nr of used elements in array */ |
259 | #define LONG_OPTIONS_INCR 10 |
234 | #define LONG_OPTIONS_INCR 10 |
260 | #define init_longopt() add_longopt(NULL,0) |
235 | #define init_longopt() add_longopt(NULL,0) |
261 | |
236 | |
262 | /* Register a long option. The contents of name is copied. */ |
237 | /* Register a long option. The contents of name is copied. */ |
263 | void add_longopt(const char *name,int has_arg) |
238 | static void add_longopt(const char *name, int has_arg) |
264 | { |
239 | { |
265 | char *tmp; |
240 | char *tmp; |
266 | if (!name) { |
241 | if (!name) { |
267 | /* init */ |
242 | /* init */ |
268 | free(long_options); |
243 | free(long_options); |
269 | long_options=NULL; |
244 | long_options = NULL; |
270 | long_options_length=0; |
245 | long_options_length = 0; |
271 | long_options_nr=0; |
246 | long_options_nr = 0; |
272 | } |
247 | } |
273 | |
248 | |
274 | if (long_options_nr == long_options_length) { |
249 | if (long_options_nr == long_options_length) { |
275 | long_options_length += LONG_OPTIONS_INCR; |
250 | long_options_length += LONG_OPTIONS_INCR; |
276 | long_options=our_realloc(long_options, |
251 | long_options = xrealloc(long_options, |
277 | sizeof(struct option) * |
252 | sizeof(struct option) * |
278 | long_options_length); |
253 | long_options_length); |
279 | } |
254 | } |
280 | |
255 | |
281 | long_options[long_options_nr].name=NULL; |
256 | long_options[long_options_nr].name = NULL; |
282 | long_options[long_options_nr].has_arg=0; |
257 | long_options[long_options_nr].has_arg = 0; |
283 | long_options[long_options_nr].flag=NULL; |
258 | long_options[long_options_nr].flag = NULL; |
284 | long_options[long_options_nr].val=0; |
259 | long_options[long_options_nr].val = 0; |
285 | |
260 | |
286 | if (long_options_nr) { |
261 | if (long_options_nr) { |
287 | /* Not for init! */ |
262 | /* Not for init! */ |
288 | long_options[long_options_nr-1].has_arg=has_arg; |
263 | long_options[long_options_nr - 1].has_arg = has_arg; |
289 | long_options[long_options_nr-1].flag=NULL; |
264 | long_options[long_options_nr - 1].flag = NULL; |
290 | long_options[long_options_nr-1].val=LONG_OPT; |
265 | long_options[long_options_nr - 1].val = LONG_OPT; |
291 | tmp = our_malloc(strlen(name)+1); |
266 | tmp = xmalloc(strlen(name) + 1); |
292 | strcpy(tmp,name); |
267 | strcpy(tmp, name); |
293 | long_options[long_options_nr-1].name=tmp; |
268 | long_options[long_options_nr - 1].name = tmp; |
294 | } |
269 | } |
295 | long_options_nr++; |
270 | long_options_nr++; |
296 | } |
271 | } |
297 | |
272 | |
298 | |
273 | |
299 | /* |
274 | /* |
300 | * Register several long options. options is a string of long options, |
275 | * Register several long options. options is a string of long options, |
301 | * separated by commas or whitespace. This nukes options! |
276 | * separated by commas or whitespace. This nukes options! |
302 | */ |
277 | */ |
303 | void add_long_options(char *options) |
278 | static void add_long_options(char *options) |
304 | { |
279 | { |
305 | int arg_opt; |
280 | int arg_opt; |
306 | char *tokptr=strtok(options,", \t\n"); |
281 | char *tokptr = strtok(options, ", \t\n"); |
307 | while (tokptr) { |
282 | while (tokptr) { |
308 | arg_opt=no_argument; |
283 | arg_opt = no_argument; |
309 | if (strlen(tokptr) > 0) { |
284 | if (strlen(tokptr) > 0) { |
310 | if (tokptr[strlen(tokptr)-1] == ':') { |
285 | if (tokptr[strlen(tokptr) - 1] == ':') { |
311 | if (tokptr[strlen(tokptr)-2] == ':') { |
286 | if (tokptr[strlen(tokptr) - 2] == ':') { |
312 | tokptr[strlen(tokptr)-2]='\0'; |
287 | tokptr[strlen(tokptr) - 2] = '\0'; |
313 | arg_opt=optional_argument; |
288 | arg_opt = optional_argument; |
314 | } else { |
289 | } else { |
315 | tokptr[strlen(tokptr)-1]='\0'; |
290 | tokptr[strlen(tokptr) - 1] = '\0'; |
316 | arg_opt=required_argument; |
291 | arg_opt = required_argument; |
317 | } |
292 | } |
318 | if (strlen(tokptr) == 0) |
293 | if (strlen(tokptr) == 0) |
|
|
294 | parse_error(_ |
319 | parse_error(_("empty long option after " |
295 | ("empty long option after " |
320 | "-l or --long argument")); |
296 | "-l or --long argument")); |
321 | } |
297 | } |
322 | add_longopt(tokptr,arg_opt); |
298 | add_longopt(tokptr, arg_opt); |
323 | } |
299 | } |
324 | tokptr=strtok(NULL,", \t\n"); |
300 | tokptr = strtok(NULL, ", \t\n"); |
325 | } |
301 | } |
326 | } |
302 | } |
327 | |
303 | |
328 | void set_shell(const char *new_shell) |
304 | static void set_shell(const char *new_shell) |
329 | { |
305 | { |
330 | if (!strcmp(new_shell,"bash")) |
306 | if (!strcmp(new_shell, "bash")) |
331 | shell=BASH; |
307 | shell = BASH; |
332 | else if (!strcmp(new_shell,"tcsh")) |
308 | else if (!strcmp(new_shell, "tcsh")) |
333 | shell=TCSH; |
309 | shell = TCSH; |
334 | else if (!strcmp(new_shell,"sh")) |
310 | else if (!strcmp(new_shell, "sh")) |
335 | shell=BASH; |
311 | shell = BASH; |
336 | else if (!strcmp(new_shell,"csh")) |
312 | else if (!strcmp(new_shell, "csh")) |
337 | shell=TCSH; |
313 | shell = TCSH; |
338 | else |
314 | else |
|
|
315 | parse_error(_ |
339 | parse_error(_("unknown shell after -s or --shell argument")); |
316 | ("unknown shell after -s or --shell argument")); |
340 | } |
317 | } |
341 | |
318 | |
342 | void print_help(void) |
319 | static void __attribute__ ((__noreturn__)) print_help(void) |
343 | { |
320 | { |
344 | fputs(_("Usage: getopt optstring parameters\n"),stderr); |
321 | fputs(_("Usage: getopt optstring parameters\n"), stderr); |
345 | fputs(_(" getopt [options] [--] optstring parameters\n"),stderr); |
322 | fputs(_(" getopt [options] [--] optstring parameters\n"), stderr); |
346 | fputs(_(" getopt [options] -o|--options optstring [options] [--]\n"),stderr); |
323 | fputs(_(" getopt [options] -o|--options optstring [options] [--]\n"), stderr); |
347 | fputs(_(" parameters\n"),stderr); |
324 | fputs(_(" parameters\n"), stderr); |
348 | fputs(_(" -a, --alternative Allow long options starting with single -\n"),stderr); |
325 | fputs(_(" -a, --alternative Allow long options starting with single -\n"), stderr); |
349 | fputs(_(" -h, --help This small usage guide\n"),stderr); |
326 | fputs(_(" -h, --help This small usage guide\n"), stderr); |
350 | fputs(_(" -l, --longoptions=longopts Long options to be recognized\n"),stderr); |
327 | fputs(_(" -l, --longoptions=longopts Long options to be recognized\n"), stderr); |
351 | fputs(_(" -n, --name=progname The name under which errors are reported\n"),stderr); |
328 | fputs(_(" -n, --name=progname The name under which errors are reported\n"), stderr); |
352 | fputs(_(" -o, --options=optstring Short options to be recognized\n"),stderr); |
329 | fputs(_(" -o, --options=optstring Short options to be recognized\n"), stderr); |
353 | fputs(_(" -q, --quiet Disable error reporting by getopt(3)\n"),stderr); |
330 | fputs(_(" -q, --quiet Disable error reporting by getopt(3)\n"), stderr); |
354 | fputs(_(" -Q, --quiet-output No normal output\n"),stderr); |
331 | fputs(_(" -Q, --quiet-output No normal output\n"), stderr); |
355 | fputs(_(" -s, --shell=shell Set shell quoting conventions\n"),stderr); |
332 | fputs(_(" -s, --shell=shell Set shell quoting conventions\n"), stderr); |
356 | fputs(_(" -T, --test Test for getopt(1) version\n"),stderr); |
333 | fputs(_(" -T, --test Test for getopt(1) version\n"), stderr); |
357 | fputs(_(" -u, --unqote Do not quote the output\n"),stderr); |
334 | fputs(_(" -u, --unqote Do not quote the output\n"), stderr); |
358 | fputs(_(" -V, --version Output version information\n"),stderr); |
335 | fputs(_(" -V, --version Output version information\n"), stderr); |
359 | exit(PARAMETER_EXIT_CODE); |
336 | exit(PARAMETER_EXIT_CODE); |
360 | } |
337 | } |
361 | |
|
|
362 | static struct option longopts[]={ {"options",required_argument,NULL,'o'}, |
|
|
363 | {"longoptions",required_argument,NULL,'l'}, |
|
|
364 | {"quiet",no_argument,NULL,'q'}, |
|
|
365 | {"quiet-output",no_argument,NULL,'Q'}, |
|
|
366 | {"shell",required_argument,NULL,'s'}, |
|
|
367 | {"test",no_argument,NULL,'T'}, |
|
|
368 | {"unquoted",no_argument,NULL,'u'}, |
|
|
369 | {"help",no_argument,NULL,'h'}, |
|
|
370 | {"alternative",no_argument,NULL,'a'}, |
|
|
371 | {"name",required_argument,NULL,'n'}, |
|
|
372 | {"version",no_argument,NULL,'V'}, |
|
|
373 | {NULL,0,NULL,0} |
|
|
374 | }; |
|
|
375 | |
|
|
376 | /* Stop scanning as soon as a non-option argument is found! */ |
|
|
377 | static const char *shortopts="+ao:l:n:qQs:TuhV"; |
|
|
378 | |
338 | |
379 | int main(int argc, char *argv[]) |
339 | int main(int argc, char *argv[]) |
380 | { |
340 | { |
381 | char *optstr=NULL; |
341 | char *optstr = NULL; |
382 | char *name=NULL; |
342 | char *name = NULL; |
383 | int opt; |
343 | int opt; |
384 | int compatible=0; |
344 | int compatible = 0; |
385 | |
345 | |
|
|
346 | /* Stop scanning as soon as a non-option argument is found! */ |
|
|
347 | static const char *shortopts = "+ao:l:n:qQs:TuhV"; |
|
|
348 | static const struct option longopts[] = { |
|
|
349 | {"options", required_argument, NULL, 'o'}, |
|
|
350 | {"longoptions", required_argument, NULL, 'l'}, |
|
|
351 | {"quiet", no_argument, NULL, 'q'}, |
|
|
352 | {"quiet-output", no_argument, NULL, 'Q'}, |
|
|
353 | {"shell", required_argument, NULL, 's'}, |
|
|
354 | {"test", no_argument, NULL, 'T'}, |
|
|
355 | {"unquoted", no_argument, NULL, 'u'}, |
|
|
356 | {"help", no_argument, NULL, 'h'}, |
|
|
357 | {"alternative", no_argument, NULL, 'a'}, |
|
|
358 | {"name", required_argument, NULL, 'n'}, |
|
|
359 | {"version", no_argument, NULL, 'V'}, |
|
|
360 | {NULL, 0, NULL, 0} |
|
|
361 | }; |
386 | #if WITHOUT_GETTEXT |
362 | #if WITHOUT_GETTEXT |
387 | #else |
363 | #else |
388 | setlocale(LC_ALL,""); |
364 | setlocale(LC_ALL, ""); |
389 | bindtextdomain(PACKAGE, LOCALEDIR); |
365 | bindtextdomain(PACKAGE, LOCALEDIR); |
390 | textdomain(PACKAGE); |
366 | textdomain(PACKAGE); |
391 | #endif |
367 | #endif |
392 | |
368 | |
393 | init_longopt(); |
369 | init_longopt(); |
|
|
370 | getopt_long_fp = getopt_long; |
394 | |
371 | |
395 | if (getenv("GETOPT_COMPATIBLE")) |
372 | if (getenv("GETOPT_COMPATIBLE")) |
396 | compatible=1; |
373 | compatible = 1; |
397 | |
374 | |
398 | if (argc == 1) |
375 | if (argc == 1) { |
399 | { |
|
|
400 | if (compatible) { |
376 | if (compatible) { |
401 | /* |
377 | /* |
402 | * For some reason, the original getopt gave no error |
378 | * For some reason, the original getopt gave no |
403 | * when there were no arguments. |
379 | * error when there were no arguments. |
404 | */ |
380 | */ |
405 | printf(" --\n"); |
381 | printf(" --\n"); |
406 | return EXIT_SUCCESS; |
382 | return EXIT_SUCCESS; |
407 | } |
|
|
408 | else |
383 | } else |
409 | parse_error(_("missing optstring argument")); |
384 | parse_error(_("missing optstring argument")); |
410 | |
385 | } |
411 | |
386 | |
|
|
387 | |
412 | if (argv[1][0] != '-' || compatible) { |
388 | if (argv[1][0] != '-' || compatible) { |
413 | quote=0; |
389 | quote = 0; |
414 | optstr=our_malloc(strlen(argv[1])+1); |
390 | optstr = xmalloc(strlen(argv[1]) + 1); |
415 | strcpy(optstr,argv[1]+strspn(argv[1],"-+")); |
391 | strcpy(optstr, argv[1] + strspn(argv[1], "-+")); |
416 | argv[1]=argv[0]; |
392 | argv[1] = argv[0]; |
417 | return generate_output(argv+1,argc-1,optstr,long_options); |
393 | return generate_output(argv + 1, argc - 1, optstr, |
|
|
394 | long_options); |
418 | } |
395 | } |
419 | |
396 | |
|
|
397 | while ((opt = |
420 | while ((opt=getopt_long(argc,argv,shortopts,longopts,NULL)) != EOF) |
398 | getopt_long(argc, argv, shortopts, longopts, NULL)) != EOF) |
421 | switch (opt) { |
399 | switch (opt) { |
422 | case 'a': |
400 | case 'a': |
423 | alternative=1; |
401 | getopt_long_fp = getopt_long_only; |
424 | break; |
402 | break; |
425 | case 'h': |
403 | case 'h': |
426 | print_help(); |
404 | print_help(); |
427 | case 'o': |
405 | case 'o': |
428 | if (optstr) |
|
|
429 | free(optstr); |
406 | free(optstr); |
430 | optstr=our_malloc(strlen(optarg)+1); |
407 | optstr = xmalloc(strlen(optarg) + 1); |
431 | strcpy(optstr,optarg); |
408 | strcpy(optstr, optarg); |
432 | break; |
409 | break; |
433 | case 'l': |
410 | case 'l': |
434 | add_long_options(optarg); |
411 | add_long_options(optarg); |
435 | break; |
412 | break; |
436 | case 'n': |
413 | case 'n': |
437 | if (name) |
|
|
438 | free(name); |
414 | free(name); |
439 | name=our_malloc(strlen(optarg)+1); |
415 | name = xmalloc(strlen(optarg) + 1); |
440 | strcpy(name,optarg); |
416 | strcpy(name, optarg); |
441 | break; |
417 | break; |
442 | case 'q': |
418 | case 'q': |
443 | quiet_errors=1; |
419 | quiet_errors = 1; |
444 | break; |
420 | break; |
445 | case 'Q': |
421 | case 'Q': |
446 | quiet_output=1; |
422 | quiet_output = 1; |
447 | break; |
423 | break; |
448 | case 's': |
424 | case 's': |
449 | set_shell(optarg); |
425 | set_shell(optarg); |
450 | break; |
426 | break; |
451 | case 'T': |
427 | case 'T': |
452 | return TEST_EXIT_CODE; |
428 | return TEST_EXIT_CODE; |
453 | case 'u': |
429 | case 'u': |
454 | quote=0; |
430 | quote = 0; |
455 | break; |
431 | break; |
456 | case 'V': |
432 | case 'V': |
457 | printf(_("getopt (enhanced) 1.1.4\n")); |
433 | printf(_("getopt (enhanced) 1.1.4\n")); |
458 | return EXIT_SUCCESS; |
434 | return EXIT_SUCCESS; |
459 | case '?': |
435 | case '?': |
… | |
… | |
461 | parse_error(NULL); |
437 | parse_error(NULL); |
462 | default: |
438 | default: |
463 | parse_error(_("internal error, contact the author.")); |
439 | parse_error(_("internal error, contact the author.")); |
464 | } |
440 | } |
465 | |
441 | |
466 | if (!optstr) |
442 | if (!optstr) { |
467 | { |
|
|
468 | if (optind >= argc) |
443 | if (optind >= argc) |
469 | parse_error(_("missing optstring argument")); |
444 | parse_error(_("missing optstring argument")); |
470 | else { |
445 | else { |
471 | optstr=our_malloc(strlen(argv[optind])+1); |
446 | optstr = xmalloc(strlen(argv[optind]) + 1); |
472 | strcpy(optstr,argv[optind]); |
447 | strcpy(optstr, argv[optind]); |
473 | optind++; |
448 | optind++; |
474 | } |
449 | } |
475 | } |
450 | } |
476 | if (name) |
451 | if (name) |
477 | argv[optind-1]=name; |
452 | argv[optind - 1] = name; |
478 | else |
453 | else |
479 | argv[optind-1]=argv[0]; |
454 | argv[optind - 1] = argv[0]; |
480 | return generate_output(argv+optind-1,argc-optind+1,optstr,long_options); |
455 | return generate_output(argv + optind - 1, argc-optind + 1, |
|
|
456 | optstr, long_options); |
481 | } |
457 | } |