1 | | /* |
2 | | /* Copyright (c) 1987-1997 Free Software Foundation, Inc. |
3 | | /* Java Port Copyright (c) 1998 by Aaron M. Renn (arenn@urbanophile.com) |
4 | | /* |
5 | | /* This program is free software; you can redistribute it and/or modify |
6 | | /* it under the terms of the GNU Library General Public License as published |
7 | | /* by 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, but |
11 | | /* WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | | /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
13 | | /* GNU Library General Public License for more details. |
14 | | /* |
15 | | /* You should have received a copy of the GNU Library General Public License |
16 | | /* along with this program; see the file COPYING.LIB. If not, write to |
17 | | /* the Free Software Foundation Inc., 59 Temple Place - Suite 330, |
18 | | /* Boston, MA 02111-1307 USA |
19 | | /**************************************************************************/ |
20 | | |
21 | | package gnu.getopt; |
22 | | |
23 | | import java.text.MessageFormat; |
24 | | import java.util.HashMap; |
25 | | import java.util.Map; |
26 | | import java.util.function.Function; |
27 | | |
28 | | /**************************************************************************/ |
29 | | |
30 | | /** |
31 | | * This is a Java port of GNU getopt, a class for parsing command line |
32 | | * arguments passed to programs. It it based on the C getopt() functions |
33 | | * in glibc 2.0.6 and should parse options in a 100% compatible manner. |
34 | | * If it does not, that is a bug. The programmer's interface is also |
35 | | * very compatible. |
36 | | * <p> |
37 | | * To use Getopt, create a Getopt object with a argv array passed to the |
38 | | * main method, then call the getopt() method in a loop. It will return an |
39 | | * int that contains the value of the option character parsed from the |
40 | | * command line. When there are no more options to be parsed, it |
41 | | * returns -1. |
42 | | * <p> |
43 | | * A command line option can be defined to take an argument. If an |
44 | | * option has an argument, the value of that argument is stored in an |
45 | | * instance variable called optarg, which can be accessed using the |
46 | | * getOptarg() method. If an option that requires an argument is |
47 | | * found, but there is no argument present, then an error message is |
48 | | * printed. Normally getopt() returns a '?' in this situation, but |
49 | | * that can be changed as described below. |
50 | | * <p> |
51 | | * If an invalid option is encountered, an error message is printed |
52 | | * to the standard error and getopt() returns a '?'. The value of the |
53 | | * invalid option encountered is stored in the instance variable optopt |
54 | | * which can be retrieved using the getOptopt() method. To suppress |
55 | | * the printing of error messages for this or any other error, set |
56 | | * the value of the opterr instance variable to false using the |
57 | | * setOpterr() method. |
58 | | * <p> |
59 | | * Between calls to getopt(), the instance variable optind is used to |
60 | | * keep track of where the object is in the parsing process. After all |
61 | | * options have been returned, optind is the index in argv of the first |
62 | | * non-option argument. This variable can be accessed with the getOptind() |
63 | | * method. |
64 | | * <p> |
65 | | * Note that this object expects command line options to be passed in the |
66 | | * traditional Unix manner. That is, proceeded by a '-' character. |
67 | | * Multiple options can follow the '-'. For example "-abc" is equivalent |
68 | | * to "-a -b -c". If an option takes a required argument, the value |
69 | | * of the argument can immediately follow the option character or be |
70 | | * present in the next argv element. For example, "-cfoo" and "-c foo" |
71 | | * both represent an option character of 'c' with an argument of "foo" |
72 | | * assuming c takes a required argument. If an option takes an argument |
73 | | * that is not required, then any argument must immediately follow the |
74 | | * option character in the same argv element. For example, if c takes |
75 | | * a non-required argument, then "-cfoo" represents option character 'c' |
76 | | * with an argument of "foo" while "-c foo" represents the option |
77 | | * character 'c' with no argument, and a first non-option argv element |
78 | | * of "foo". |
79 | | * <p> |
80 | | * The user can stop getopt() from scanning any further into a command line |
81 | | * by using the special argument "--" by itself. For example: |
82 | | * "-a -- -d" would return an option character of 'a', then return -1 |
83 | | * The "--" is discarded and "-d" is pointed to by optind as the first |
84 | | * non-option argv element. |
85 | | * <p> |
86 | | * Here is a basic example of using Getopt: |
87 | | * <p> |
88 | | * <pre> |
89 | | * Getopt g = new Getopt("testprog", argv, "ab:c::d"); |
90 | | * // |
91 | | * int c; |
92 | | * String arg; |
93 | | * while ((c = g.getopt()) != -1) |
94 | | * { |
95 | | * switch(c) |
96 | | * { |
97 | | * case 'a': |
98 | | * case 'd': |
99 | | * System.out.print("You picked " + (char)c + "\n"); |
100 | | * break; |
101 | | * // |
102 | | * case 'b': |
103 | | * case 'c': |
104 | | * arg = g.getOptarg(); |
105 | | * System.out.print("You picked " + (char)c + |
106 | | * " with an argument of " + |
107 | | * ((arg != null) ? arg : "null") + "\n"); |
108 | | * break; |
109 | | * // |
110 | | * case '?': |
111 | | * break; // getopt() already printed an error |
112 | | * // |
113 | | * default: |
114 | | * System.out.print("getopt() returned " + c + "\n"); |
115 | | * } |
116 | | * } |
117 | | * </pre> |
118 | | * <p> |
119 | | * In this example, a new Getopt object is created with three params. |
120 | | * The first param is the program name. This is for printing error |
121 | | * messages in the form "program: error message". In the C version, this |
122 | | * value is taken from argv[0], but in Java the program name is not passed |
123 | | * in that element, thus the need for this parameter. The second param is |
124 | | * the argument list that was passed to the main() method. The third |
125 | | * param is the list of valid options. Each character represents a valid |
126 | | * option. If the character is followed by a single colon, then that |
127 | | * option has a required argument. If the character is followed by two |
128 | | * colons, then that option has an argument that is not required. |
129 | | * <p> |
130 | | * Note in this example that the value returned from getopt() is cast to |
131 | | * a char prior to printing. This is required in order to make the value |
132 | | * display correctly as a character instead of an integer. |
133 | | * <p> |
134 | | * If the first character in the option string is a colon, for example |
135 | | * ":abc::d", then getopt() will return a ':' instead of a '?' when it |
136 | | * encounters an option with a missing required argument. This allows the |
137 | | * caller to distinguish between invalid options and valid options that |
138 | | * are simply incomplete. |
139 | | * <p> |
140 | | * In the traditional Unix getopt(), -1 is returned when the first non-option |
141 | | * charcter is encountered. In GNU getopt(), the default behavior is to |
142 | | * allow options to appear anywhere on the command line. The getopt() |
143 | | * method permutes the argument to make it appear to the caller that all |
144 | | * options were at the beginning of the command line, and all non-options |
145 | | * were at the end. For example, calling getopt() with command line args |
146 | | * of "-a foo bar -d" returns options 'a' and 'd', then sets optind to |
147 | | * point to "foo". The program would read the last two argv elements as |
148 | | * "foo" and "bar", just as if the user had typed "-a -d foo bar". |
149 | | * <p> |
150 | | * The user can force getopt() to stop scanning the command line with |
151 | | * the special argument "--" by itself. Any elements occuring before the |
152 | | * "--" are scanned and permuted as normal. Any elements after the "--" |
153 | | * are returned as is as non-option argv elements. For example, |
154 | | * "foo -a -- bar -d" would return option 'a' then -1. optind would point |
155 | | * to "foo", "bar" and "-d" as the non-option argv elements. The "--" |
156 | | * is discarded by getopt(). |
157 | | * <p> |
158 | | * There are two ways this default behavior can be modified. The first is |
159 | | * to specify traditional Unix getopt() behavior (which is also POSIX |
160 | | * behavior) in which scanning stops when the first non-option argument |
161 | | * encountered. (Thus "-a foo bar -d" would return 'a' as an option and |
162 | | * have "foo", "bar", and "-d" as non-option elements). The second is to |
163 | | * allow options anywhere, but to return all elements in the order they |
164 | | * occur on the command line. When a non-option element is ecountered, |
165 | | * an integer 1 is returned and the value of the non-option element is |
166 | | * stored in optarg is if it were the argument to that option. For |
167 | | * example, "-a foo -d", returns first 'a', then 1 (with optarg set to |
168 | | * "foo") then 'd' then -1. When this "return in order" functionality |
169 | | * is enabled, the only way to stop getopt() from scanning all command |
170 | | * line elements is to use the special "--" string by itself as described |
171 | | * above. An example is "-a foo -b -- bar", which would return 'a', then |
172 | | * integer 1 with optarg set to "foo", then 'b', then -1. optind would |
173 | | * then point to "bar" as the first non-option argv element. The "--" |
174 | | * is discarded. |
175 | | * <p> |
176 | | * The POSIX/traditional behavior is enabled by either setting the |
177 | | * property "gnu.posixly_correct" or by putting a '+' sign as the first |
178 | | * character of the option string. The difference between the two |
179 | | * methods is that setting the gnu.posixly_correct property also forces |
180 | | * certain error messages to be displayed in POSIX format. To enable |
181 | | * the "return in order" functionality, put a '-' as the first character |
182 | | * of the option string. Note that after determining the proper |
183 | | * behavior, Getopt strips this leading '+' or '-', meaning that a ':' |
184 | | * placed as the second character after one of those two will still cause |
185 | | * getopt() to return a ':' instead of a '?' if a required option |
186 | | * argument is missing. |
187 | | * <p> |
188 | | * In addition to traditional single character options, GNU Getopt also |
189 | | * supports long options. These are preceeded by a "--" sequence and |
190 | | * can be as long as desired. Long options provide a more user-friendly |
191 | | * way of entering command line options. For example, in addition to a |
192 | | * "-h" for help, a program could support also "--help". |
193 | | * <p> |
194 | | * Like short options, long options can also take a required or non-required |
195 | | * argument. Required arguments can either be specified by placing an |
196 | | * equals sign after the option name, then the argument, or by putting the |
197 | | * argument in the next argv element. For example: "--outputdir=foo" and |
198 | | * "--outputdir foo" both represent an option of "outputdir" with an |
199 | | * argument of "foo", assuming that outputdir takes a required argument. |
200 | | * If a long option takes a non-required argument, then the equals sign |
201 | | * form must be used to specify the argument. In this case, |
202 | | * "--outputdir=foo" would represent option outputdir with an argument of |
203 | | * "foo" while "--outputdir foo" would represent the option outputdir |
204 | | * with no argument and a first non-option argv element of "foo". |
205 | | * <p> |
206 | | * Long options can also be specified using a special POSIX argument |
207 | | * format (one that I highly discourage). This form of entry is |
208 | | * enabled by placing a "W;" (yes, 'W' then a semi-colon) in the valid |
209 | | * option string. This causes getopt to treat the name following the |
210 | | * "-W" as the name of the long option. For example, "-W outputdir=foo" |
211 | | * would be equivalent to "--outputdir=foo". The name can immediately |
212 | | * follow the "-W" like so: "-Woutputdir=foo". Option arguments are |
213 | | * handled identically to normal long options. If a string follows the |
214 | | * "-W" that does not represent a valid long option, then getopt() returns |
215 | | * 'W' and the caller must decide what to do. Otherwise getopt() returns |
216 | | * a long option value as described below. |
217 | | * <p> |
218 | | * While long options offer convenience, they can also be tedious to type |
219 | | * in full. So it is permissible to abbreviate the option name to as |
220 | | * few characters as required to uniquely identify it. If the name can |
221 | | * represent multiple long options, then an error message is printed and |
222 | | * getopt() returns a '?'. |
223 | | * <p> |
224 | | * If an invalid option is specified or a required option argument is |
225 | | * missing, getopt() prints an error and returns a '?' or ':' exactly |
226 | | * as for short options. Note that when an invalid long option is |
227 | | * encountered, the optopt variable is set to integer 0 and so cannot |
228 | | * be used to identify the incorrect option the user entered. |
229 | | * <p> |
230 | | * Long options are defined by LongOpt objects. These objects are created |
231 | | * with a contructor that takes four params: a String representing the |
232 | | * object name, a integer specifying what arguments the option takes |
233 | | * (the value is one of LongOpt.NO_ARGUMENT, LongOpt.REQUIRED_ARGUMENT, |
234 | | * or LongOpt.OPTIONAL_ARGUMENT), a StringBuffer flag object (described |
235 | | * below), and an integer value (described below). |
236 | | * <p> |
237 | | * To enable long option parsing, create an array of LongOpt's representing |
238 | | * the legal options and pass it to the Getopt() constructor. WARNING: If |
239 | | * all elements of the array are not populated with LongOpt objects, the |
240 | | * getopt() method will throw a NullPointerException. |
241 | | * <p> |
242 | | * When getopt() is called and a long option is encountered, one of two |
243 | | * things can be returned. If the flag field in the LongOpt object |
244 | | * representing the long option is non-null, then the integer value field |
245 | | * is stored there and an integer 0 is returned to the caller. The val |
246 | | * field can then be retrieved from the flag field. Note that since the |
247 | | * flag field is a StringBuffer, the appropriate String to integer converions |
248 | | * must be performed in order to get the actual int value stored there. |
249 | | * If the flag field in the LongOpt object is null, then the value field |
250 | | * of the LongOpt is returned. This can be the character of a short option. |
251 | | * This allows an app to have both a long and short option sequence |
252 | | * (say, "-h" and "--help") that do the exact same thing. |
253 | | * <p> |
254 | | * With long options, there is an alternative method of determining |
255 | | * which option was selected. The method getLongind() will return the |
256 | | * the index in the long option array (NOT argv) of the long option found. |
257 | | * So if multiple long options are configured to return the same value, |
258 | | * the application can use getLongind() to distinguish between them. |
259 | | * <p> |
260 | | * Here is an expanded Getopt example using long options and various |
261 | | * techniques described above: |
262 | | * <p> |
263 | | * <pre> |
264 | | * int c; |
265 | | * String arg; |
266 | | * LongOpt[] longopts = new LongOpt[3]; |
267 | | * // |
268 | | * StringBuffer sb = new StringBuffer(); |
269 | | * longopts[0] = new LongOpt("help", LongOpt.NO_ARGUMENT, null, 'h'); |
270 | | * longopts[1] = new LongOpt("outputdir", LongOpt.REQUIRED_ARGUMENT, sb, 'o'); |
271 | | * longopts[2] = new LongOpt("maximum", LongOpt.OPTIONAL_ARGUMENT, null, 2); |
272 | | * // |
273 | | * Getopt g = new Getopt("testprog", argv, "-:bc::d:hW;", longopts); |
274 | | * g.setOpterr(false); // We'll do our own error handling |
275 | | * // |
276 | | * while ((c = g.getopt()) != -1) |
277 | | * switch (c) |
278 | | * { |
279 | | * case 0: |
280 | | * arg = g.getOptarg(); |
281 | | * System.out.println("Got long option with value '" + |
282 | | * (char)(new Integer(sb.toString())).intValue() |
283 | | * + "' with argument " + |
284 | | * ((arg != null) ? arg : "null")); |
285 | | * break; |
286 | | * // |
287 | | * case 1: |
288 | | * System.out.println("I see you have return in order set and that " + |
289 | | * "a non-option argv element was just found " + |
290 | | * "with the value '" + g.getOptarg() + "'"); |
291 | | * break; |
292 | | * // |
293 | | * case 2: |
294 | | * arg = g.getOptarg(); |
295 | | * System.out.println("I know this, but pretend I didn't"); |
296 | | * System.out.println("We picked option " + |
297 | | * longopts[g.getLongind()].getName() + |
298 | | * " with value " + |
299 | | * ((arg != null) ? arg : "null")); |
300 | | * break; |
301 | | * // |
302 | | * case 'b': |
303 | | * System.out.println("You picked plain old option " + (char)c); |
304 | | * break; |
305 | | * // |
306 | | * case 'c': |
307 | | * case 'd': |
308 | | * arg = g.getOptarg(); |
309 | | * System.out.println("You picked option '" + (char)c + |
310 | | * "' with argument " + |
311 | | * ((arg != null) ? arg : "null")); |
312 | | * break; |
313 | | * // |
314 | | * case 'h': |
315 | | * System.out.println("I see you asked for help"); |
316 | | * break; |
317 | | * // |
318 | | * case 'W': |
319 | | * System.out.println("Hmmm. You tried a -W with an incorrect long " + |
320 | | * "option name"); |
321 | | * break; |
322 | | * // |
323 | | * case ':': |
324 | | * System.out.println("Doh! You need an argument for option " + |
325 | | * (char)g.getOptopt()); |
326 | | * break; |
327 | | * // |
328 | | * case '?': |
329 | | * System.out.println("The option '" + (char)g.getOptopt() + |
330 | | * "' is not valid"); |
331 | | * break; |
332 | | * // |
333 | | * default: |
334 | | * System.out.println("getopt() returned " + c); |
335 | | * break; |
336 | | * } |
337 | | * // |
338 | | * for (int i = g.getOptind(); i < argv.length ; i++) |
339 | | * System.out.println("Non option argv element: " + argv[i] + "\n"); |
340 | | * </pre> |
341 | | * <p> |
342 | | * There is an alternative form of the constructor used for long options |
343 | | * above. This takes a trailing boolean flag. If set to false, Getopt |
344 | | * performs identically to the example, but if the boolean flag is true |
345 | | * then long options are allowed to start with a single '-' instead of |
346 | | * "--". If the first character of the option is a valid short option |
347 | | * character, then the option is treated as if it were the short option. |
348 | | * Otherwise it behaves as if the option is a long option. Note that |
349 | | * the name given to this option - long_only - is very counter-intuitive. |
350 | | * It does not cause only long options to be parsed but instead enables |
351 | | * the behavior described above. |
352 | | * <p> |
353 | | * Note that the functionality and variable names used are driven from |
354 | | * the C lib version as this object is a port of the C code, not a |
355 | | * new implementation. This should aid in porting existing C/C++ code, |
356 | | * as well as helping programmers familiar with the glibc version to |
357 | | * adapt to the Java version even if it seems very non-Java at times. |
358 | | * <p> |
359 | | * In this release I made all instance variables protected due to |
360 | | * overwhelming public demand. Any code which relied on optarg, |
361 | | * opterr, optind, or optopt being public will need to be modified to |
362 | | * use the appropriate access methods. |
363 | | * <p> |
364 | | * Please send all bug reports, requests, and comments to |
365 | | * <a href="mailto:arenn@urbanophile.com">arenn@urbanophile.com</a>. |
366 | | * |
367 | | * @version 1.0.7 |
368 | | * |
369 | | * @author Roland McGrath (roland@gnu.ai.mit.edu) |
370 | | * @author Ulrich Drepper (drepper@cygnus.com) |
371 | | * @author Aaron M. Renn (arenn@urbanophile.com) |
372 | | * |
373 | | * @see LongOpt |
374 | | */ |
375 | | public class Getopt extends Object |
376 | | { |
377 | | |
378 | | /**************************************************************************/ |
379 | | |
380 | | /* |
381 | | * Class Variables |
382 | | */ |
383 | | |
384 | | /** |
385 | | * Describe how to deal with options that follow non-option ARGV-elements. |
386 | | * |
387 | | * If the caller did not specify anything, |
388 | | * the default is REQUIRE_ORDER if the property |
389 | | * gnu.posixly_correct is defined, PERMUTE otherwise. |
390 | | * |
391 | | * The special argument `--' forces an end of option-scanning regardless |
392 | | * of the value of `ordering'. In the case of RETURN_IN_ORDER, only |
393 | | * `--' can cause `getopt' to return -1 with `optind' != ARGC. |
394 | | * |
395 | | * REQUIRE_ORDER means don't recognize them as options; |
396 | | * stop option processing when the first non-option is seen. |
397 | | * This is what Unix does. |
398 | | * This mode of operation is selected by either setting the property |
399 | | * gnu.posixly_correct, or using `+' as the first character |
400 | | * of the list of option characters. |
401 | | */ |
402 | | protected static final int REQUIRE_ORDER = 1; |
403 | | |
404 | | /** |
405 | | * PERMUTE is the default. We permute the contents of ARGV as we scan, |
406 | | * so that eventually all the non-options are at the end. This allows options |
407 | | * to be given in any order, even with programs that were not written to |
408 | | * expect this. |
409 | | */ |
410 | | protected static final int PERMUTE = 2; |
411 | | |
412 | | /** |
413 | | * RETURN_IN_ORDER is an option available to programs that were written |
414 | | * to expect options and other ARGV-elements in any order and that care about |
415 | | * the ordering of the two. We describe each non-option ARGV-element |
416 | | * as if it were the argument of an option with character code 1. |
417 | | * Using `-' as the first character of the list of option characters |
418 | | * selects this mode of operation. |
419 | | */ |
420 | | protected static final int RETURN_IN_ORDER = 3; |
421 | | |
422 | | /**************************************************************************/ |
423 | | |
424 | | /* |
425 | | * Instance Variables |
426 | | */ |
427 | | |
428 | | /** |
429 | | * For communication from `getopt' to the caller. |
430 | | * When `getopt' finds an option that takes an argument, |
431 | | * the argument value is returned here. |
432 | | * Also, when `ordering' is RETURN_IN_ORDER, |
433 | | * each non-option ARGV-element is returned here. |
434 | | */ |
435 | | protected String optarg; |
436 | | |
437 | | /** |
438 | | * Index in ARGV of the next element to be scanned. |
439 | | * This is used for communication to and from the caller |
440 | | * and for communication between successive calls to `getopt'. |
441 | | * |
442 | | * On entry to `getopt', zero means this is the first call; initialize. |
443 | | * |
444 | | * When `getopt' returns -1, this is the index of the first of the |
445 | | * non-option elements that the caller should itself scan. |
446 | | * |
447 | | * Otherwise, `optind' communicates from one call to the next |
448 | | * how much of ARGV has been scanned so far. |
449 | | */ |
450 | | protected int optind = 0; |
451 | | |
452 | | /** |
453 | | * Callers store false here to inhibit the error message |
454 | | * for unrecognized options. |
455 | | */ |
456 | | protected boolean opterr = true; |
457 | | |
458 | | /** |
459 | | * When an unrecognized option is encountered, getopt will return a '?' |
460 | | * and store the value of the invalid option here. |
461 | | */ |
462 | | protected int optopt = '?'; |
463 | | |
464 | | /** |
465 | | * The next char to be scanned in the option-element |
466 | | * in which the last option character we returned was found. |
467 | | * This allows us to pick up the scan where we left off. |
468 | | * |
469 | | * If this is zero, or a null string, it means resume the scan |
470 | | * by advancing to the next ARGV-element. |
471 | | */ |
472 | | protected String nextchar; |
473 | | |
474 | | /** |
475 | | * This is the string describing the valid short options. |
476 | | */ |
477 | | protected String optstring; |
478 | | |
479 | | /** |
480 | | * This is an array of LongOpt objects which describ the valid long |
481 | | * options. |
482 | | */ |
483 | | protected LongOpt[] long_options; |
484 | | |
485 | | /** |
486 | | * This flag determines whether or not we are parsing only long args |
487 | | */ |
488 | | protected boolean long_only; |
489 | | |
490 | | /** |
491 | | * Stores the index into the long_options array of the long option found |
492 | | */ |
493 | | protected int longind; |
494 | | |
495 | | /** |
496 | | * The flag determines whether or not we operate in strict POSIX compliance |
497 | | */ |
498 | | protected boolean posixly_correct; |
499 | | |
500 | | /** |
501 | | * A flag which communicates whether or not checkLongOption() did all |
502 | | * necessary processing for the current option |
503 | | */ |
504 | | protected boolean longopt_handled; |
505 | | |
506 | | /** |
507 | | * The index of the first non-option in argv[] |
508 | | */ |
509 | | protected int first_nonopt = 1; |
510 | | |
511 | | /** |
512 | | * The index of the last non-option in argv[] |
513 | | */ |
514 | | protected int last_nonopt = 1; |
515 | | |
516 | | /** |
517 | | * Flag to tell getopt to immediately return -1 the next time it is |
518 | | * called. |
519 | | */ |
520 | | private boolean endparse = false; |
521 | | |
522 | | /** |
523 | | * Saved argument list passed to the program |
524 | | */ |
525 | | protected String[] argv; |
526 | | |
527 | | /** |
528 | | * Determines whether we permute arguments or not |
529 | | */ |
530 | | protected int ordering; |
531 | | |
532 | | /** |
533 | | * Name to print as the program name in error messages. This is necessary |
534 | | * since Java does not place the program name in argv[0] |
535 | | */ |
536 | | protected String progname; |
537 | | |
538 | | /** |
539 | | * The localized strings are kept in a separate file |
540 | | */ |
541 | | private OptI18n _messages = new OptI18n(); // ResourceBundle.getBundle("gnu/getopt/MessagesBundle", Locale.getDefault()); |
542 | | |
543 | | /**************************************************************************/ |
544 | | |
545 | | /* |
546 | | * Constructors |
547 | | */ |
548 | | |
549 | | /** |
550 | | * Construct a basic Getopt instance with the given input data. Note that |
551 | | * this handles "short" options only. |
552 | | * |
553 | | * @param progname The name to display as the program name when printing errors |
554 | | * @param argv The String array passed as the command line to the program. |
555 | | * @param optstring A String containing a description of the valid args for this program |
556 | | */ |
557 | | public |
558 | | Getopt(String progname, String[] argv, String optstring) |
559 | | { |
560 | | this(progname, argv, optstring, null, false); |
561 | | } |
562 | | |
563 | | /**************************************************************************/ |
564 | | |
565 | | /** |
566 | | * Construct a Getopt instance with given input data that is capable of |
567 | | * parsing long options as well as short. |
568 | | * |
569 | | * @param progname The name to display as the program name when printing errors |
570 | | * @param argv The String array passed as the command ilne to the program |
571 | | * @param optstring A String containing a description of the valid short args for this program |
572 | | * @param long_options An array of LongOpt objects that describes the valid long args for this program |
573 | | */ |
574 | | public |
575 | | Getopt(String progname, String[] argv, String optstring, |
576 | | LongOpt[] long_options) |
577 | | { |
578 | | this(progname, argv, optstring, long_options, false); |
579 | | } |
580 | | |
581 | | /**************************************************************************/ |
582 | | |
583 | | private static Function<String, String> tr = Function.identity(); |
584 | | |
585 | | /** |
586 | | * Set the global translation handler for Getopt. |
587 | | * |
588 | | * This needs to be done before any call to {@link Getopt} or {@link LongOpt} |
589 | | * constructor. |
590 | | * @param tr function that takes messages in English and returns the localized message |
591 | | */ |
592 | | public static void setI18nHandler(Function<String, String> tr) { |
593 | | Getopt.tr = tr; |
594 | | } |
595 | | |
596 | | static class OptI18n { |
597 | | |
598 | | private final Map<String, String> trns = new HashMap<>(); |
599 | | |
600 | | public OptI18n() { |
601 | | add("getopt.ambigious", tr("{0}: option ''{1}'' is ambiguous")); |
602 | | add("getopt.arguments1", tr("{0}: option ''--{1}'' does not allow an argument")); |
603 | | add("getopt.arguments2", tr("{0}: option ''{1}{2}'' does not allow an argument")); |
604 | | add("getopt.requires", tr("{0}: option ''{1}'' requires an argument")); |
605 | | add("getopt.unrecognized", tr("{0}: unrecognized option ''--{1}''")); |
606 | | add("getopt.unrecognized2", tr("{0}: unrecognized option ''{1}{2}''")); |
607 | | add("getopt.illegal", tr("{0}: illegal option -- {1}")); |
608 | | add("getopt.invalid", tr("{0}: invalid option -- {1}")); |
609 | | add("getopt.requires2", tr("{0}: option requires an argument -- {1}")); |
610 | | add("getopt.invalidValue", tr("Invalid value {0} for parameter ''has_arg''")); |
611 | | } |
612 | | |
613 | | private String tr(String s) { |
614 | | return Getopt.tr.apply(s); |
615 | | } |
616 | | |
617 | | private void add(String key, String value) { |
618 | | trns.put(key, value); |
619 | | } |
620 | | |
621 | | public String getString(String s) { |
622 | | String val = trns.get(s); |
623 | | if (val == null) throw new IllegalArgumentException(); |
624 | | return val.replace("'", "''"); |
625 | | } |
626 | | } |
627 | | |
628 | | /** |
629 | | * Construct a Getopt instance with given input data that is capable of |
630 | | * parsing long options and short options. Contrary to what you might |
631 | | * think, the flag 'long_only' does not determine whether or not we |
632 | | * scan for only long arguments. Instead, a value of true here allows |
633 | | * long arguments to start with a '-' instead of '--' unless there is a |
634 | | * conflict with a short option name. |
635 | | * |
636 | | * @param progname The name to display as the program name when printing errors |
637 | | * @param argv The String array passed as the command ilne to the program |
638 | | * @param optstring A String containing a description of the valid short args for this program |
639 | | * @param long_options An array of LongOpt objects that describes the valid long args for this program |
640 | | * @param long_only true if long options that do not conflict with short options can start with a '-' as well as '--' |
641 | | */ |
642 | | public |
643 | | Getopt(String progname, String[] argv, String optstring, |
644 | | LongOpt[] long_options, boolean long_only) |
645 | | { |
646 | | if (optstring.length() == 0) |
647 | | optstring = " "; |
648 | | |
649 | | // This function is essentially _getopt_initialize from GNU getopt |
650 | | this.progname = progname; |
651 | | this.argv = argv; |
652 | | this.optstring = optstring; |
653 | | this.long_options = long_options; |
654 | | this.long_only = long_only; |
655 | | |
656 | | // Check for property "gnu.posixly_correct" to determine whether to |
657 | | // strictly follow the POSIX standard. This replaces the "POSIXLY_CORRECT" |
658 | | // environment variable in the C version |
659 | | try { |
660 | | if (System.getProperty("gnu.posixly_correct", null) == null) |
661 | | posixly_correct = false; |
662 | | else |
663 | | { |
664 | | posixly_correct = true; |
665 | | _messages = new OptI18n();//ResourceBundle.getBundle("gnu/getopt/MessagesBundle", |
666 | | // Locale.US); |
667 | | } |
668 | | } catch (SecurityException e) { |
669 | | System.err.println(e.getMessage()); |
670 | | } |
671 | | |
672 | | // Determine how to handle the ordering of options and non-options |
673 | | if (optstring.charAt(0) == '-') |
674 | | { |
675 | | ordering = RETURN_IN_ORDER; |
676 | | if (optstring.length() > 1) |
677 | | this.optstring = optstring.substring(1); |
678 | | } |
679 | | else if (optstring.charAt(0) == '+') |
680 | | { |
681 | | ordering = REQUIRE_ORDER; |
682 | | if (optstring.length() > 1) |
683 | | this.optstring = optstring.substring(1); |
684 | | } |
685 | | else if (posixly_correct) |
686 | | { |
687 | | ordering = REQUIRE_ORDER; |
688 | | } |
689 | | else |
690 | | { |
691 | | ordering = PERMUTE; // The normal default case |
692 | | } |
693 | | } |
694 | | |
695 | | /**************************************************************************/ |
696 | | |
697 | | /* |
698 | | * Instance Methods |
699 | | */ |
700 | | |
701 | | /** |
702 | | * In GNU getopt, it is possible to change the string containg valid options |
703 | | * on the fly because it is passed as an argument to getopt() each time. In |
704 | | * this version we do not pass the string on every call. In order to allow |
705 | | * dynamic option string changing, this method is provided. |
706 | | * |
707 | | * @param optstring The new option string to use |
708 | | */ |
709 | | public void |
710 | | setOptstring(String optstring) |
711 | | { |
712 | | if (optstring.length() == 0) |
713 | | optstring = " "; |
714 | | |
715 | | this.optstring = optstring; |
716 | | } |
717 | | |
718 | | /**************************************************************************/ |
719 | | |
720 | | /** |
721 | | * optind it the index in ARGV of the next element to be scanned. |
722 | | * This is used for communication to and from the caller |
723 | | * and for communication between successive calls to `getopt'. |
724 | | * |
725 | | * When `getopt' returns -1, this is the index of the first of the |
726 | | * non-option elements that the caller should itself scan. |
727 | | * |
728 | | * Otherwise, `optind' communicates from one call to the next |
729 | | * how much of ARGV has been scanned so far. |
730 | | */ |
731 | | public int |
732 | | getOptind() |
733 | | { |
734 | | return(optind); |
735 | | } |
736 | | |
737 | | /**************************************************************************/ |
738 | | |
739 | | /** |
740 | | * This method allows the optind index to be set manually. Normally this |
741 | | * is not necessary (and incorrect usage of this method can lead to serious |
742 | | * lossage), but optind is a public symbol in GNU getopt, so this method |
743 | | * was added to allow it to be modified by the caller if desired. |
744 | | * |
745 | | * @param optind The new value of optind |
746 | | */ |
747 | | public void |
748 | | setOptind(int optind) |
749 | | { |
750 | | this.optind = optind; |
751 | | } |
752 | | |
753 | | /**************************************************************************/ |
754 | | |
755 | | /** |
756 | | * Since in GNU getopt() the argument vector is passed back in to the |
757 | | * function every time, the caller can swap out argv on the fly. Since |
758 | | * passing argv is not required in the Java version, this method allows |
759 | | * the user to override argv. Note that incorrect use of this method can |
760 | | * lead to serious lossage. |
761 | | * |
762 | | * @param argv New argument list |
763 | | */ |
764 | | public void |
765 | | setArgv(String[] argv) |
766 | | { |
767 | | this.argv = argv; |
768 | | } |
769 | | |
770 | | /**************************************************************************/ |
771 | | |
772 | | /** |
773 | | * For communication from `getopt' to the caller. |
774 | | * When `getopt' finds an option that takes an argument, |
775 | | * the argument value is returned here. |
776 | | * Also, when `ordering' is RETURN_IN_ORDER, |
777 | | * each non-option ARGV-element is returned here. |
778 | | * No set method is provided because setting this variable has no effect. |
779 | | */ |
780 | | public String |
781 | | getOptarg() |
782 | | { |
783 | | return(optarg); |
784 | | } |
785 | | |
786 | | /**************************************************************************/ |
787 | | |
788 | | /** |
789 | | * Normally Getopt will print a message to the standard error when an |
790 | | * invalid option is encountered. This can be suppressed (or re-enabled) |
791 | | * by calling this method. There is no get method for this variable |
792 | | * because if you can't remember the state you set this to, why should I? |
793 | | */ |
794 | | public void |
795 | | setOpterr(boolean opterr) |
796 | | { |
797 | | this.opterr = opterr; |
798 | | } |
799 | | |
800 | | /**************************************************************************/ |
801 | | |
802 | | /** |
803 | | * When getopt() encounters an invalid option, it stores the value of that |
804 | | * option in optopt which can be retrieved with this method. There is |
805 | | * no corresponding set method because setting this variable has no effect. |
806 | | */ |
807 | | public int |
808 | | getOptopt() |
809 | | { |
810 | | return(optopt); |
811 | | } |
812 | | |
813 | | /**************************************************************************/ |
814 | | |
815 | | /** |
816 | | * Returns the index into the array of long options (NOT argv) representing |
817 | | * the long option that was found. |
818 | | */ |
819 | | public int |
820 | | getLongind() |
821 | | { |
822 | | return(longind); |
823 | | } |
824 | | |
825 | | /**************************************************************************/ |
826 | | |
827 | | /** |
828 | | * Exchange the shorter segment with the far end of the longer segment. |
829 | | * That puts the shorter segment into the right place. |
830 | | * It leaves the longer segment in the right place overall, |
831 | | * but it consists of two parts that need to be swapped next. |
832 | | * This method is used by getopt() for argument permutation. |
833 | | */ |
834 | | protected void |
835 | | exchange(String[] argv) |
836 | | { |
837 | | int bottom = first_nonopt; |
838 | | int middle = last_nonopt; |
839 | | int top = optind; |
840 | | String tem; |
841 | | |
842 | | while (top > middle && middle > bottom) |
843 | | { |
844 | | if (top - middle > middle - bottom) |
845 | | { |
846 | | // Bottom segment is the short one. |
847 | | int len = middle - bottom; |
848 | | int i; |
849 | | |
850 | | // Swap it with the top part of the top segment. |
851 | | for (i = 0; i < len; i++) |
852 | | { |
853 | | tem = argv[bottom + i]; |
854 | | argv[bottom + i] = argv[top - (middle - bottom) + i]; |
855 | | argv[top - (middle - bottom) + i] = tem; |
856 | | } |
857 | | // Exclude the moved bottom segment from further swapping. |
858 | | top -= len; |
859 | | } |
860 | | else |
861 | | { |
862 | | // Top segment is the short one. |
863 | | int len = top - middle; |
864 | | int i; |
865 | | |
866 | | // Swap it with the bottom part of the bottom segment. |
867 | | for (i = 0; i < len; i++) |
868 | | { |
869 | | tem = argv[bottom + i]; |
870 | | argv[bottom + i] = argv[middle + i]; |
871 | | argv[middle + i] = tem; |
872 | | } |
873 | | // Exclude the moved top segment from further swapping. |
874 | | bottom += len; |
875 | | } |
876 | | } |
877 | | |
878 | | // Update records for the slots the non-options now occupy. |
879 | | |
880 | | first_nonopt += (optind - last_nonopt); |
881 | | last_nonopt = optind; |
882 | | } |
883 | | |
884 | | /**************************************************************************/ |
885 | | |
886 | | /** |
887 | | * Check to see if an option is a valid long option. Called by getopt(). |
888 | | * Put in a separate method because this needs to be done twice. (The |
889 | | * C getopt authors just copy-pasted the code!). |
890 | | * |
891 | | * @param longind A buffer in which to store the 'val' field of found LongOpt |
892 | | * |
893 | | * @return Various things depending on circumstances |
894 | | */ |
895 | | protected int |
896 | | checkLongOption() |
897 | | { |
898 | | LongOpt pfound = null; |
899 | | int nameend; |
900 | | boolean ambig; |
901 | | boolean exact; |
902 | | |
903 | | longopt_handled = true; |
904 | | ambig = false; |
905 | | exact = false; |
906 | | longind = -1; |
907 | | |
908 | | nameend = nextchar.indexOf("="); |
909 | | if (nameend == -1) |
910 | | nameend = nextchar.length(); |
911 | | |
912 | | // Test all lnog options for either exact match or abbreviated matches |
913 | | for (int i = 0; i < long_options.length; i++) |
914 | | { |
915 | | if (long_options[i].getName().startsWith(nextchar.substring(0, nameend))) |
916 | | { |
917 | | if (long_options[i].getName().equals(nextchar.substring(0, nameend))) |
918 | | { |
919 | | // Exact match found |
920 | | pfound = long_options[i]; |
921 | | longind = i; |
922 | | exact = true; |
923 | | break; |
924 | | } |
925 | | else if (pfound == null) |
926 | | { |
927 | | // First nonexact match found |
928 | | pfound = long_options[i]; |
929 | | longind = i; |
930 | | } |
931 | | else |
932 | | { |
933 | | // Second or later nonexact match found |
934 | | ambig = true; |
935 | | } |
936 | | } |
937 | | } // for |
938 | | |
939 | | // Print out an error if the option specified was ambiguous |
940 | | if (ambig && !exact) |
941 | | { |
942 | | if (opterr) |
943 | | { |
944 | | Object[] msgArgs = { progname, argv[optind] }; |
945 | | System.err.println(MessageFormat.format( |
946 | | _messages.getString("getopt.ambigious"), |
947 | | msgArgs)); |
948 | | } |
949 | | |
950 | | nextchar = ""; |
951 | | optopt = 0; |
952 | | ++optind; |
953 | | |
954 | | return('?'); |
955 | | } |
956 | | |
957 | | if (pfound != null) |
958 | | { |
959 | | ++optind; |
960 | | |
961 | | if (nameend != nextchar.length()) |
962 | | { |
963 | | if (pfound.has_arg != LongOpt.NO_ARGUMENT) |
964 | | { |
965 | | if (nextchar.substring(nameend).length() > 1) |
966 | | optarg = nextchar.substring(nameend+1); |
967 | | else |
968 | | optarg = ""; |
969 | | } |
970 | | else |
971 | | { |
972 | | if (opterr) |
973 | | { |
974 | | // -- option |
975 | | if (argv[optind - 1].startsWith("--")) |
976 | | { |
977 | | Object[] msgArgs = { progname, pfound.name }; |
978 | | System.err.println(MessageFormat.format( |
979 | | _messages.getString("getopt.arguments1"), |
980 | | msgArgs)); |
981 | | } |
982 | | // +option or -option |
983 | | else |
984 | | { |
985 | | Object[] msgArgs = { progname, |
986 | | Character.toString(argv[optind-1].charAt(0)), |
987 | | pfound.name }; |
988 | | System.err.println(MessageFormat.format( |
989 | | _messages.getString("getopt.arguments2"), |
990 | | msgArgs)); |
991 | | } |
992 | | } |
993 | | |
994 | | nextchar = ""; |
995 | | optopt = pfound.val; |
996 | | |
997 | | return('?'); |
998 | | } |
999 | | } // if (nameend) |
1000 | | else if (pfound.has_arg == LongOpt.REQUIRED_ARGUMENT) |
1001 | | { |
1002 | | if (optind < argv.length) |
1003 | | { |
1004 | | optarg = argv[optind]; |
1005 | | ++optind; |
1006 | | } |
1007 | | else |
1008 | | { |
1009 | | if (opterr) |
1010 | | { |
1011 | | Object[] msgArgs = { progname, argv[optind-1] }; |
1012 | | System.err.println(MessageFormat.format( |
1013 | | _messages.getString("getopt.requires"), |
1014 | | msgArgs)); |
1015 | | } |
1016 | | |
1017 | | nextchar = ""; |
1018 | | optopt = pfound.val; |
1019 | | if (optstring.charAt(0) == ':') |
1020 | | return(':'); |
1021 | | else |
1022 | | return('?'); |
1023 | | } |
1024 | | } // else if (pfound) |
1025 | | |
1026 | | nextchar = ""; |
1027 | | |
1028 | | if (pfound.flag != null) |
1029 | | { |
1030 | | pfound.flag.setLength(0); |
1031 | | pfound.flag.append(pfound.val); |
1032 | | |
1033 | | return(0); |
1034 | | } |
1035 | | |
1036 | | return(pfound.val); |
1037 | | } // if (pfound != null) |
1038 | | |
1039 | | longopt_handled = false; |
1040 | | |
1041 | | return(0); |
1042 | | } |
1043 | | |
1044 | | /**************************************************************************/ |
1045 | | |
1046 | | /** |
1047 | | * This method returns a char that is the current option that has been |
1048 | | * parsed from the command line. If the option takes an argument, then |
1049 | | * the internal variable 'optarg' is set which is a String representing |
1050 | | * the the value of the argument. This value can be retrieved by the |
1051 | | * caller using the getOptarg() method. If an invalid option is found, |
1052 | | * an error message is printed and a '?' is returned. The name of the |
1053 | | * invalid option character can be retrieved by calling the getOptopt() |
1054 | | * method. When there are no more options to be scanned, this method |
1055 | | * returns -1. The index of first non-option element in argv can be |
1056 | | * retrieved with the getOptind() method. |
1057 | | * |
1058 | | * @return Various things as described above |
1059 | | */ |
1060 | | public int |
1061 | | getopt() |
1062 | | { |
1063 | | optarg = null; |
1064 | | |
1065 | | if (endparse == true) |
1066 | | return(-1); |
1067 | | |
1068 | | if ((nextchar == null) || (nextchar.equals(""))) |
1069 | | { |
1070 | | // If we have just processed some options following some non-options, |
1071 | | // exchange them so that the options come first. |
1072 | | if (last_nonopt > optind) |
1073 | | last_nonopt = optind; |
1074 | | if (first_nonopt > optind) |
1075 | | first_nonopt = optind; |
1076 | | |
1077 | | if (ordering == PERMUTE) |
1078 | | { |
1079 | | // If we have just processed some options following some non-options, |
1080 | | // exchange them so that the options come first. |
1081 | | if ((first_nonopt != last_nonopt) && (last_nonopt != optind)) |
1082 | | exchange(argv); |
1083 | | else if (last_nonopt != optind) |
1084 | | first_nonopt = optind; |
1085 | | |
1086 | | // Skip any additional non-options |
1087 | | // and extend the range of non-options previously skipped. |
1088 | | while ((optind < argv.length) && (argv[optind].equals("") || |
1089 | | (argv[optind].charAt(0) != '-') || argv[optind].equals("-"))) |
1090 | | { |
1091 | | optind++; |
1092 | | } |
1093 | | |
1094 | | last_nonopt = optind; |
1095 | | } |
1096 | | |
1097 | | // The special ARGV-element `--' means premature end of options. |
1098 | | // Skip it like a null option, |
1099 | | // then exchange with previous non-options as if it were an option, |
1100 | | // then skip everything else like a non-option. |
1101 | | if ((optind != argv.length) && argv[optind].equals("--")) |
1102 | | { |
1103 | | optind++; |
1104 | | |
1105 | | if ((first_nonopt != last_nonopt) && (last_nonopt != optind)) |
1106 | | exchange (argv); |
1107 | | else if (first_nonopt == last_nonopt) |
1108 | | first_nonopt = optind; |
1109 | | |
1110 | | last_nonopt = argv.length; |
1111 | | |
1112 | | optind = argv.length; |
1113 | | } |
1114 | | |
1115 | | // If we have done all the ARGV-elements, stop the scan |
1116 | | // and back over any non-options that we skipped and permuted. |
1117 | | if (optind == argv.length) |
1118 | | { |
1119 | | // Set the next-arg-index to point at the non-options |
1120 | | // that we previously skipped, so the caller will digest them. |
1121 | | if (first_nonopt != last_nonopt) |
1122 | | optind = first_nonopt; |
1123 | | |
1124 | | return(-1); |
1125 | | } |
1126 | | |
1127 | | // If we have come to a non-option and did not permute it, |
1128 | | // either stop the scan or describe it to the caller and pass it by. |
1129 | | if (argv[optind].equals("") || (argv[optind].charAt(0) != '-') || |
1130 | | argv[optind].equals("-")) |
1131 | | { |
1132 | | if (ordering == REQUIRE_ORDER) |
1133 | | return(-1); |
1134 | | |
1135 | | optarg = argv[optind++]; |
1136 | | return(1); |
1137 | | } |
1138 | | |
1139 | | // We have found another option-ARGV-element. |
1140 | | // Skip the initial punctuation. |
1141 | | if (argv[optind].startsWith("--")) |
1142 | | nextchar = argv[optind].substring(2); |
1143 | | else |
1144 | | nextchar = argv[optind].substring(1); |
1145 | | } |
1146 | | |
1147 | | // Decode the current option-ARGV-element. |
1148 | | |
1149 | | /* Check whether the ARGV-element is a long option. |
1150 | | |
1151 | | If long_only and the ARGV-element has the form "-f", where f is |
1152 | | a valid short option, don't consider it an abbreviated form of |
1153 | | a long option that starts with f. Otherwise there would be no |
1154 | | way to give the -f short option. |
1155 | | |
1156 | | On the other hand, if there's a long option "fubar" and |
1157 | | the ARGV-element is "-fu", do consider that an abbreviation of |
1158 | | the long option, just like "--fu", and not "-f" with arg "u". |
1159 | | |
1160 | | This distinction seems to be the most useful approach. */ |
1161 | | if ((long_options != null) && (argv[optind].startsWith("--") |
1162 | | || (long_only && ((argv[optind].length() > 2) || |
1163 | | (optstring.indexOf(argv[optind].charAt(1)) == -1))))) |
1164 | | { |
1165 | | int c = checkLongOption(); |
1166 | | |
1167 | | if (longopt_handled) |
1168 | | return(c); |
1169 | | |
1170 | | // Can't find it as a long option. If this is not getopt_long_only, |
1171 | | // or the option starts with '--' or is not a valid short |
1172 | | // option, then it's an error. |
1173 | | // Otherwise interpret it as a short option. |
1174 | | if (!long_only || argv[optind].startsWith("--") |
1175 | | || (optstring.indexOf(nextchar.charAt(0)) == -1)) |
1176 | | { |
1177 | | if (opterr) |
1178 | | { |
1179 | | if (argv[optind].startsWith("--")) |
1180 | | { |
1181 | | Object[] msgArgs = { progname, nextchar }; |
1182 | | System.err.println(MessageFormat.format( |
1183 | | _messages.getString("getopt.unrecognized"), |
1184 | | msgArgs)); |
1185 | | } |
1186 | | else |
1187 | | { |
1188 | | Object[] msgArgs = { progname, |
1189 | | Character.toString(argv[optind].charAt(0)), |
1190 | | nextchar }; |
1191 | | System.err.println(MessageFormat.format( |
1192 | | _messages.getString("getopt.unrecognized2"), |
1193 | | msgArgs)); |
1194 | | } |
1195 | | } |
1196 | | |
1197 | | nextchar = ""; |
1198 | | ++optind; |
1199 | | optopt = 0; |
1200 | | |
1201 | | return('?'); |
1202 | | } |
1203 | | } // if (longopts) |
1204 | | |
1205 | | // Look at and handle the next short option-character */ |
1206 | | int c = nextchar.charAt(0); //**** Do we need to check for empty str? |
1207 | | if (nextchar.length() > 1) |
1208 | | nextchar = nextchar.substring(1); |
1209 | | else |
1210 | | nextchar = ""; |
1211 | | |
1212 | | String temp = null; |
1213 | | if (optstring.indexOf(c) != -1) |
1214 | | temp = optstring.substring(optstring.indexOf(c)); |
1215 | | |
1216 | | if (nextchar.equals("")) |
1217 | | ++optind; |
1218 | | |
1219 | | if ((temp == null) || (c == ':')) |
1220 | | { |
1221 | | if (opterr) |
1222 | | { |
1223 | | if (posixly_correct) |
1224 | | { |
1225 | | // 1003.2 specifies the format of this message |
1226 | | Object[] msgArgs = { progname, |
1227 | | Character.toString((char)c) }; |
1228 | | System.err.println(MessageFormat.format( |
1229 | | _messages.getString("getopt.illegal"), msgArgs)); |
1230 | | } |
1231 | | else |
1232 | | { |
1233 | | Object[] msgArgs = { progname, |
1234 | | Character.toString((char)c) }; |
1235 | | System.err.println(MessageFormat.format( |
1236 | | _messages.getString("getopt.invalid"), msgArgs)); |
1237 | | } |
1238 | | } |
1239 | | |
1240 | | optopt = c; |
1241 | | |
1242 | | return('?'); |
1243 | | } |
1244 | | |
1245 | | // Convenience. Treat POSIX -W foo same as long option --foo |
1246 | | if ((temp.charAt(0) == 'W') && (temp.length() > 1) && (temp.charAt(1) == ';')) |
1247 | | { |
1248 | | if (!nextchar.equals("")) |
1249 | | { |
1250 | | optarg = nextchar; |
1251 | | } |
1252 | | // No further cars in this argv element and no more argv elements |
1253 | | else if (optind == argv.length) |
1254 | | { |
1255 | | if (opterr) |
1256 | | { |
1257 | | // 1003.2 specifies the format of this message. |
1258 | | Object[] msgArgs = { progname, |
1259 | | Character.toString((char)c) }; |
1260 | | System.err.println(MessageFormat.format( |
1261 | | _messages.getString("getopt.requires2"), msgArgs)); |
1262 | | } |
1263 | | |
1264 | | optopt = c; |
1265 | | if (optstring.charAt(0) == ':') |
1266 | | return(':'); |
1267 | | else |
1268 | | return('?'); |
1269 | | } |
1270 | | else |
1271 | | { |
1272 | | // We already incremented `optind' once; |
1273 | | // increment it again when taking next ARGV-elt as argument. |
1274 | | nextchar = argv[optind]; |
1275 | | optarg = argv[optind]; |
1276 | | } |
1277 | | |
1278 | | c = checkLongOption(); |
1279 | | |
1280 | | if (longopt_handled) |
1281 | | return(c); |
1282 | | else |
1283 | | // Let the application handle it |
1284 | | { |
1285 | | nextchar = null; |
1286 | | ++optind; |
1287 | | return('W'); |
1288 | | } |
1289 | | } |
1290 | | |
1291 | | if ((temp.length() > 1) && (temp.charAt(1) == ':')) |
1292 | | { |
1293 | | if ((temp.length() > 2) && (temp.charAt(2) == ':')) |
1294 | | // This is an option that accepts and argument optionally |
1295 | | { |
1296 | | if (!nextchar.equals("")) |
1297 | | { |
1298 | | optarg = nextchar; |
1299 | | ++optind; |
1300 | | } |
1301 | | else |
1302 | | { |
1303 | | optarg = null; |
1304 | | } |
1305 | | |
1306 | | nextchar = null; |
1307 | | } |
1308 | | else |
1309 | | { |
1310 | | if (!nextchar.equals("")) |
1311 | | { |
1312 | | optarg = nextchar; |
1313 | | ++optind; |
1314 | | } |
1315 | | else if (optind == argv.length) |
1316 | | { |
1317 | | if (opterr) |
1318 | | { |
1319 | | // 1003.2 specifies the format of this message |
1320 | | Object[] msgArgs = { progname, |
1321 | | Character.toString((char)c) }; |
1322 | | System.err.println(MessageFormat.format( |
1323 | | _messages.getString("getopt.requires2"), msgArgs)); |
1324 | | } |
1325 | | |
1326 | | optopt = c; |
1327 | | |
1328 | | if (optstring.charAt(0) == ':') |
1329 | | return(':'); |
1330 | | else |
1331 | | return('?'); |
1332 | | } |
1333 | | else |
1334 | | { |
1335 | | optarg = argv[optind]; |
1336 | | ++optind; |
1337 | | |
1338 | | // Ok, here's an obscure Posix case. If we have o:, and |
1339 | | // we get -o -- foo, then we're supposed to skip the --, |
1340 | | // end parsing of options, and make foo an operand to -o. |
1341 | | // Only do this in Posix mode. |
1342 | | if ((posixly_correct) && optarg.equals("--")) |
1343 | | { |
1344 | | // If end of argv, error out |
1345 | | if (optind == argv.length) |
1346 | | { |
1347 | | if (opterr) |
1348 | | { |
1349 | | // 1003.2 specifies the format of this message |
1350 | | Object[] msgArgs = { progname, |
1351 | | Character.toString((char)c) }; |
1352 | | System.err.println(MessageFormat.format( |
1353 | | _messages.getString("getopt.requires2"), msgArgs)); |
1354 | | } |
1355 | | |
1356 | | optopt = c; |
1357 | | |
1358 | | if (optstring.charAt(0) == ':') |
1359 | | return(':'); |
1360 | | else |
1361 | | return('?'); |
1362 | | } |
1363 | | |
1364 | | // Set new optarg and set to end |
1365 | | // Don't permute as we do on -- up above since we |
1366 | | // know we aren't in permute mode because of Posix. |
1367 | | optarg = argv[optind]; |
1368 | | ++optind; |
1369 | | first_nonopt = optind; |
1370 | | last_nonopt = argv.length; |
1371 | | endparse = true; |
1372 | | } |
1373 | | } |
1374 | | |
1375 | | nextchar = null; |
1376 | | } |
1377 | | } |
1378 | | |
1379 | | return(c); |
1380 | | } |
1381 | | |
1382 | | } // Class Getopt |
1383 | | |
1384 | | |