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