- * To use Getopt, create a Getopt object with a argv array passed to the - * main method, then call the getopt() method in a loop. It will return an - * int that contains the value of the option character parsed from the - * command line. When there are no more options to be parsed, it - * returns -1. - *
- * A command line option can be defined to take an argument. If an - * option has an argument, the value of that argument is stored in an - * instance variable called optarg, which can be accessed using the - * getOptarg() method. If an option that requires an argument is - * found, but there is no argument present, then an error message is - * printed. Normally getopt() returns a '?' in this situation, but - * that can be changed as described below. - *
- * If an invalid option is encountered, an error message is printed - * to the standard error and getopt() returns a '?'. The value of the - * invalid option encountered is stored in the instance variable optopt - * which can be retrieved using the getOptopt() method. To suppress - * the printing of error messages for this or any other error, set - * the value of the opterr instance variable to false using the - * setOpterr() method. - *
- * Between calls to getopt(), the instance variable optind is used to - * keep track of where the object is in the parsing process. After all - * options have been returned, optind is the index in argv of the first - * non-option argument. This variable can be accessed with the getOptind() - * method. - *
- * Note that this object expects command line options to be passed in the - * traditional Unix manner. That is, proceeded by a '-' character. - * Multiple options can follow the '-'. For example "-abc" is equivalent - * to "-a -b -c". If an option takes a required argument, the value - * of the argument can immediately follow the option character or be - * present in the next argv element. For example, "-cfoo" and "-c foo" - * both represent an option character of 'c' with an argument of "foo" - * assuming c takes a required argument. If an option takes an argument - * that is not required, then any argument must immediately follow the - * option character in the same argv element. For example, if c takes - * a non-required argument, then "-cfoo" represents option character 'c' - * with an argument of "foo" while "-c foo" represents the option - * character 'c' with no argument, and a first non-option argv element - * of "foo". - *
- * The user can stop getopt() from scanning any further into a command line - * by using the special argument "--" by itself. For example: - * "-a -- -d" would return an option character of 'a', then return -1 - * The "--" is discarded and "-d" is pointed to by optind as the first - * non-option argv element. - *
- * Here is a basic example of using Getopt: - *
- *
- * Getopt g = new Getopt("testprog", argv, "ab:c::d");
- * //
- * int c;
- * String arg;
- * while ((c = g.getopt()) != -1)
- * {
- * switch(c)
- * {
- * case 'a':
- * case 'd':
- * System.out.print("You picked " + (char)c + "\n");
- * break;
- * //
- * case 'b':
- * case 'c':
- * arg = g.getOptarg();
- * System.out.print("You picked " + (char)c +
- * " with an argument of " +
- * ((arg != null) ? arg : "null") + "\n");
- * break;
- * //
- * case '?':
- * break; // getopt() already printed an error
- * //
- * default:
- * System.out.print("getopt() returned " + c + "\n");
- * }
- * }
- *
- * - * In this example, a new Getopt object is created with three params. - * The first param is the program name. This is for printing error - * messages in the form "program: error message". In the C version, this - * value is taken from argv[0], but in Java the program name is not passed - * in that element, thus the need for this parameter. The second param is - * the argument list that was passed to the main() method. The third - * param is the list of valid options. Each character represents a valid - * option. If the character is followed by a single colon, then that - * option has a required argument. If the character is followed by two - * colons, then that option has an argument that is not required. - *
- * Note in this example that the value returned from getopt() is cast to - * a char prior to printing. This is required in order to make the value - * display correctly as a character instead of an integer. - *
- * If the first character in the option string is a colon, for example - * ":abc::d", then getopt() will return a ':' instead of a '?' when it - * encounters an option with a missing required argument. This allows the - * caller to distinguish between invalid options and valid options that - * are simply incomplete. - *
- * In the traditional Unix getopt(), -1 is returned when the first non-option - * charcter is encountered. In GNU getopt(), the default behavior is to - * allow options to appear anywhere on the command line. The getopt() - * method permutes the argument to make it appear to the caller that all - * options were at the beginning of the command line, and all non-options - * were at the end. For example, calling getopt() with command line args - * of "-a foo bar -d" returns options 'a' and 'd', then sets optind to - * point to "foo". The program would read the last two argv elements as - * "foo" and "bar", just as if the user had typed "-a -d foo bar". - *
- * The user can force getopt() to stop scanning the command line with - * the special argument "--" by itself. Any elements occuring before the - * "--" are scanned and permuted as normal. Any elements after the "--" - * are returned as is as non-option argv elements. For example, - * "foo -a -- bar -d" would return option 'a' then -1. optind would point - * to "foo", "bar" and "-d" as the non-option argv elements. The "--" - * is discarded by getopt(). - *
- * There are two ways this default behavior can be modified. The first is - * to specify traditional Unix getopt() behavior (which is also POSIX - * behavior) in which scanning stops when the first non-option argument - * encountered. (Thus "-a foo bar -d" would return 'a' as an option and - * have "foo", "bar", and "-d" as non-option elements). The second is to - * allow options anywhere, but to return all elements in the order they - * occur on the command line. When a non-option element is ecountered, - * an integer 1 is returned and the value of the non-option element is - * stored in optarg is if it were the argument to that option. For - * example, "-a foo -d", returns first 'a', then 1 (with optarg set to - * "foo") then 'd' then -1. When this "return in order" functionality - * is enabled, the only way to stop getopt() from scanning all command - * line elements is to use the special "--" string by itself as described - * above. An example is "-a foo -b -- bar", which would return 'a', then - * integer 1 with optarg set to "foo", then 'b', then -1. optind would - * then point to "bar" as the first non-option argv element. The "--" - * is discarded. - *
- * The POSIX/traditional behavior is enabled by either setting the - * property "gnu.posixly_correct" or by putting a '+' sign as the first - * character of the option string. The difference between the two - * methods is that setting the gnu.posixly_correct property also forces - * certain error messages to be displayed in POSIX format. To enable - * the "return in order" functionality, put a '-' as the first character - * of the option string. Note that after determining the proper - * behavior, Getopt strips this leading '+' or '-', meaning that a ':' - * placed as the second character after one of those two will still cause - * getopt() to return a ':' instead of a '?' if a required option - * argument is missing. - *
- * In addition to traditional single character options, GNU Getopt also - * supports long options. These are preceeded by a "--" sequence and - * can be as long as desired. Long options provide a more user-friendly - * way of entering command line options. For example, in addition to a - * "-h" for help, a program could support also "--help". - *
- * Like short options, long options can also take a required or non-required - * argument. Required arguments can either be specified by placing an - * equals sign after the option name, then the argument, or by putting the - * argument in the next argv element. For example: "--outputdir=foo" and - * "--outputdir foo" both represent an option of "outputdir" with an - * argument of "foo", assuming that outputdir takes a required argument. - * If a long option takes a non-required argument, then the equals sign - * form must be used to specify the argument. In this case, - * "--outputdir=foo" would represent option outputdir with an argument of - * "foo" while "--outputdir foo" would represent the option outputdir - * with no argument and a first non-option argv element of "foo". - *
- * Long options can also be specified using a special POSIX argument - * format (one that I highly discourage). This form of entry is - * enabled by placing a "W;" (yes, 'W' then a semi-colon) in the valid - * option string. This causes getopt to treat the name following the - * "-W" as the name of the long option. For example, "-W outputdir=foo" - * would be equivalent to "--outputdir=foo". The name can immediately - * follow the "-W" like so: "-Woutputdir=foo". Option arguments are - * handled identically to normal long options. If a string follows the - * "-W" that does not represent a valid long option, then getopt() returns - * 'W' and the caller must decide what to do. Otherwise getopt() returns - * a long option value as described below. - *
- * While long options offer convenience, they can also be tedious to type - * in full. So it is permissible to abbreviate the option name to as - * few characters as required to uniquely identify it. If the name can - * represent multiple long options, then an error message is printed and - * getopt() returns a '?'. - *
- * If an invalid option is specified or a required option argument is - * missing, getopt() prints an error and returns a '?' or ':' exactly - * as for short options. Note that when an invalid long option is - * encountered, the optopt variable is set to integer 0 and so cannot - * be used to identify the incorrect option the user entered. - *
- * Long options are defined by LongOpt objects. These objects are created - * with a contructor that takes four params: a String representing the - * object name, a integer specifying what arguments the option takes - * (the value is one of LongOpt.NO_ARGUMENT, LongOpt.REQUIRED_ARGUMENT, - * or LongOpt.OPTIONAL_ARGUMENT), a StringBuffer flag object (described - * below), and an integer value (described below). - *
- * To enable long option parsing, create an array of LongOpt's representing - * the legal options and pass it to the Getopt() constructor. WARNING: If - * all elements of the array are not populated with LongOpt objects, the - * getopt() method will throw a NullPointerException. - *
- * When getopt() is called and a long option is encountered, one of two - * things can be returned. If the flag field in the LongOpt object - * representing the long option is non-null, then the integer value field - * is stored there and an integer 0 is returned to the caller. The val - * field can then be retrieved from the flag field. Note that since the - * flag field is a StringBuffer, the appropriate String to integer converions - * must be performed in order to get the actual int value stored there. - * If the flag field in the LongOpt object is null, then the value field - * of the LongOpt is returned. This can be the character of a short option. - * This allows an app to have both a long and short option sequence - * (say, "-h" and "--help") that do the exact same thing. - *
- * With long options, there is an alternative method of determining - * which option was selected. The method getLongind() will return the - * the index in the long option array (NOT argv) of the long option found. - * So if multiple long options are configured to return the same value, - * the application can use getLongind() to distinguish between them. - *
- * Here is an expanded Getopt example using long options and various - * techniques described above: - *
- *
- * int c;
- * String arg;
- * LongOpt[] longopts = new LongOpt[3];
- * //
- * StringBuffer sb = new StringBuffer();
- * longopts[0] = new LongOpt("help", LongOpt.NO_ARGUMENT, null, 'h');
- * longopts[1] = new LongOpt("outputdir", LongOpt.REQUIRED_ARGUMENT, sb, 'o');
- * longopts[2] = new LongOpt("maximum", LongOpt.OPTIONAL_ARGUMENT, null, 2);
- * //
- * Getopt g = new Getopt("testprog", argv, "-:bc::d:hW;", longopts);
- * g.setOpterr(false); // We'll do our own error handling
- * //
- * while ((c = g.getopt()) != -1)
- * switch (c)
- * {
- * case 0:
- * arg = g.getOptarg();
- * System.out.println("Got long option with value '" +
- * (char)(new Integer(sb.toString())).intValue()
- * + "' with argument " +
- * ((arg != null) ? arg : "null"));
- * break;
- * //
- * case 1:
- * System.out.println("I see you have return in order set and that " +
- * "a non-option argv element was just found " +
- * "with the value '" + g.getOptarg() + "'");
- * break;
- * //
- * case 2:
- * arg = g.getOptarg();
- * System.out.println("I know this, but pretend I didn't");
- * System.out.println("We picked option " +
- * longopts[g.getLongind()].getName() +
- * " with value " +
- * ((arg != null) ? arg : "null"));
- * break;
- * //
- * case 'b':
- * System.out.println("You picked plain old option " + (char)c);
- * break;
- * //
- * case 'c':
- * case 'd':
- * arg = g.getOptarg();
- * System.out.println("You picked option '" + (char)c +
- * "' with argument " +
- * ((arg != null) ? arg : "null"));
- * break;
- * //
- * case 'h':
- * System.out.println("I see you asked for help");
- * break;
- * //
- * case 'W':
- * System.out.println("Hmmm. You tried a -W with an incorrect long " +
- * "option name");
- * break;
- * //
- * case ':':
- * System.out.println("Doh! You need an argument for option " +
- * (char)g.getOptopt());
- * break;
- * //
- * case '?':
- * System.out.println("The option '" + (char)g.getOptopt() +
- * "' is not valid");
- * break;
- * //
- * default:
- * System.out.println("getopt() returned " + c);
- * break;
- * }
- * //
- * for (int i = g.getOptind(); i < argv.length ; i++)
- * System.out.println("Non option argv element: " + argv[i] + "\n");
- *
- * - * There is an alternative form of the constructor used for long options - * above. This takes a trailing boolean flag. If set to false, Getopt - * performs identically to the example, but if the boolean flag is true - * then long options are allowed to start with a single '-' instead of - * "--". If the first character of the option is a valid short option - * character, then the option is treated as if it were the short option. - * Otherwise it behaves as if the option is a long option. Note that - * the name given to this option - long_only - is very counter-intuitive. - * It does not cause only long options to be parsed but instead enables - * the behavior described above. - *
- * Note that the functionality and variable names used are driven from - * the C lib version as this object is a port of the C code, not a - * new implementation. This should aid in porting existing C/C++ code, - * as well as helping programmers familiar with the glibc version to - * adapt to the Java version even if it seems very non-Java at times. - *
- * In this release I made all instance variables protected due to - * overwhelming public demand. Any code which relied on optarg, - * opterr, optind, or optopt being public will need to be modified to - * use the appropriate access methods. - *
- * Please send all bug reports, requests, and comments to - * arenn@urbanophile.com. - * - * @version 1.0.7 - * - * @author Roland McGrath (roland@gnu.ai.mit.edu) - * @author Ulrich Drepper (drepper@cygnus.com) - * @author Aaron M. Renn (arenn@urbanophile.com) - * - * @see LongOpt - */ -public class Getopt extends Object -{ - -/**************************************************************************/ - -/* - * Class Variables + * This is a Java port of GNU getopt, a class for parsing command line + * arguments passed to programs. It it based on the C getopt() functions + * in glibc 2.0.6 and should parse options in a 100% compatible manner. + * If it does not, that is a bug. The programmer's interface is also + * very compatible. + *
+ * To use Getopt, create a Getopt object with a argv array passed to the + * main method, then call the getopt() method in a loop. It will return an + * int that contains the value of the option character parsed from the + * command line. When there are no more options to be parsed, it + * returns -1. + *
+ * A command line option can be defined to take an argument. If an + * option has an argument, the value of that argument is stored in an + * instance variable called optarg, which can be accessed using the + * getOptarg() method. If an option that requires an argument is + * found, but there is no argument present, then an error message is + * printed. Normally getopt() returns a '?' in this situation, but + * that can be changed as described below. + *
+ * If an invalid option is encountered, an error message is printed + * to the standard error and getopt() returns a '?'. The value of the + * invalid option encountered is stored in the instance variable optopt + * which can be retrieved using the getOptopt() method. To suppress + * the printing of error messages for this or any other error, set + * the value of the opterr instance variable to false using the + * setOpterr() method. + *
+ * Between calls to getopt(), the instance variable optind is used to + * keep track of where the object is in the parsing process. After all + * options have been returned, optind is the index in argv of the first + * non-option argument. This variable can be accessed with the getOptind() + * method. + *
+ * Note that this object expects command line options to be passed in the + * traditional Unix manner. That is, proceeded by a '-' character. + * Multiple options can follow the '-'. For example "-abc" is equivalent + * to "-a -b -c". If an option takes a required argument, the value + * of the argument can immediately follow the option character or be + * present in the next argv element. For example, "-cfoo" and "-c foo" + * both represent an option character of 'c' with an argument of "foo" + * assuming c takes a required argument. If an option takes an argument + * that is not required, then any argument must immediately follow the + * option character in the same argv element. For example, if c takes + * a non-required argument, then "-cfoo" represents option character 'c' + * with an argument of "foo" while "-c foo" represents the option + * character 'c' with no argument, and a first non-option argv element + * of "foo". + *
+ * The user can stop getopt() from scanning any further into a command line + * by using the special argument "--" by itself. For example: + * "-a -- -d" would return an option character of 'a', then return -1 + * The "--" is discarded and "-d" is pointed to by optind as the first + * non-option argv element. + *
+ * Here is a basic example of using Getopt: + *
+ *
+ * Getopt g = new Getopt("testprog", argv, "ab:c::d");
+ * //
+ * int c;
+ * String arg;
+ * while ((c = g.getopt()) != -1)
+ * {
+ * switch(c)
+ * {
+ * case 'a':
+ * case 'd':
+ * System.out.print("You picked " + (char)c + "\n");
+ * break;
+ * //
+ * case 'b':
+ * case 'c':
+ * arg = g.getOptarg();
+ * System.out.print("You picked " + (char)c +
+ * " with an argument of " +
+ * ((arg != null) ? arg : "null") + "\n");
+ * break;
+ * //
+ * case '?':
+ * break; // getopt() already printed an error
+ * //
+ * default:
+ * System.out.print("getopt() returned " + c + "\n");
+ * }
+ * }
+ *
+ * + * In this example, a new Getopt object is created with three params. + * The first param is the program name. This is for printing error + * messages in the form "program: error message". In the C version, this + * value is taken from argv[0], but in Java the program name is not passed + * in that element, thus the need for this parameter. The second param is + * the argument list that was passed to the main() method. The third + * param is the list of valid options. Each character represents a valid + * option. If the character is followed by a single colon, then that + * option has a required argument. If the character is followed by two + * colons, then that option has an argument that is not required. + *
+ * Note in this example that the value returned from getopt() is cast to + * a char prior to printing. This is required in order to make the value + * display correctly as a character instead of an integer. + *
+ * If the first character in the option string is a colon, for example + * ":abc::d", then getopt() will return a ':' instead of a '?' when it + * encounters an option with a missing required argument. This allows the + * caller to distinguish between invalid options and valid options that + * are simply incomplete. + *
+ * In the traditional Unix getopt(), -1 is returned when the first non-option + * charcter is encountered. In GNU getopt(), the default behavior is to + * allow options to appear anywhere on the command line. The getopt() + * method permutes the argument to make it appear to the caller that all + * options were at the beginning of the command line, and all non-options + * were at the end. For example, calling getopt() with command line args + * of "-a foo bar -d" returns options 'a' and 'd', then sets optind to + * point to "foo". The program would read the last two argv elements as + * "foo" and "bar", just as if the user had typed "-a -d foo bar". + *
+ * The user can force getopt() to stop scanning the command line with + * the special argument "--" by itself. Any elements occuring before the + * "--" are scanned and permuted as normal. Any elements after the "--" + * are returned as is as non-option argv elements. For example, + * "foo -a -- bar -d" would return option 'a' then -1. optind would point + * to "foo", "bar" and "-d" as the non-option argv elements. The "--" + * is discarded by getopt(). + *
+ * There are two ways this default behavior can be modified. The first is + * to specify traditional Unix getopt() behavior (which is also POSIX + * behavior) in which scanning stops when the first non-option argument + * encountered. (Thus "-a foo bar -d" would return 'a' as an option and + * have "foo", "bar", and "-d" as non-option elements). The second is to + * allow options anywhere, but to return all elements in the order they + * occur on the command line. When a non-option element is ecountered, + * an integer 1 is returned and the value of the non-option element is + * stored in optarg is if it were the argument to that option. For + * example, "-a foo -d", returns first 'a', then 1 (with optarg set to + * "foo") then 'd' then -1. When this "return in order" functionality + * is enabled, the only way to stop getopt() from scanning all command + * line elements is to use the special "--" string by itself as described + * above. An example is "-a foo -b -- bar", which would return 'a', then + * integer 1 with optarg set to "foo", then 'b', then -1. optind would + * then point to "bar" as the first non-option argv element. The "--" + * is discarded. + *
+ * The POSIX/traditional behavior is enabled by either setting the + * property "gnu.posixly_correct" or by putting a '+' sign as the first + * character of the option string. The difference between the two + * methods is that setting the gnu.posixly_correct property also forces + * certain error messages to be displayed in POSIX format. To enable + * the "return in order" functionality, put a '-' as the first character + * of the option string. Note that after determining the proper + * behavior, Getopt strips this leading '+' or '-', meaning that a ':' + * placed as the second character after one of those two will still cause + * getopt() to return a ':' instead of a '?' if a required option + * argument is missing. + *
+ * In addition to traditional single character options, GNU Getopt also + * supports long options. These are preceeded by a "--" sequence and + * can be as long as desired. Long options provide a more user-friendly + * way of entering command line options. For example, in addition to a + * "-h" for help, a program could support also "--help". + *
+ * Like short options, long options can also take a required or non-required + * argument. Required arguments can either be specified by placing an + * equals sign after the option name, then the argument, or by putting the + * argument in the next argv element. For example: "--outputdir=foo" and + * "--outputdir foo" both represent an option of "outputdir" with an + * argument of "foo", assuming that outputdir takes a required argument. + * If a long option takes a non-required argument, then the equals sign + * form must be used to specify the argument. In this case, + * "--outputdir=foo" would represent option outputdir with an argument of + * "foo" while "--outputdir foo" would represent the option outputdir + * with no argument and a first non-option argv element of "foo". + *
+ * Long options can also be specified using a special POSIX argument + * format (one that I highly discourage). This form of entry is + * enabled by placing a "W;" (yes, 'W' then a semi-colon) in the valid + * option string. This causes getopt to treat the name following the + * "-W" as the name of the long option. For example, "-W outputdir=foo" + * would be equivalent to "--outputdir=foo". The name can immediately + * follow the "-W" like so: "-Woutputdir=foo". Option arguments are + * handled identically to normal long options. If a string follows the + * "-W" that does not represent a valid long option, then getopt() returns + * 'W' and the caller must decide what to do. Otherwise getopt() returns + * a long option value as described below. + *
+ * While long options offer convenience, they can also be tedious to type + * in full. So it is permissible to abbreviate the option name to as + * few characters as required to uniquely identify it. If the name can + * represent multiple long options, then an error message is printed and + * getopt() returns a '?'. + *
+ * If an invalid option is specified or a required option argument is + * missing, getopt() prints an error and returns a '?' or ':' exactly + * as for short options. Note that when an invalid long option is + * encountered, the optopt variable is set to integer 0 and so cannot + * be used to identify the incorrect option the user entered. + *
+ * Long options are defined by LongOpt objects. These objects are created + * with a contructor that takes four params: a String representing the + * object name, a integer specifying what arguments the option takes + * (the value is one of LongOpt.NO_ARGUMENT, LongOpt.REQUIRED_ARGUMENT, + * or LongOpt.OPTIONAL_ARGUMENT), a StringBuffer flag object (described + * below), and an integer value (described below). + *
+ * To enable long option parsing, create an array of LongOpt's representing + * the legal options and pass it to the Getopt() constructor. WARNING: If + * all elements of the array are not populated with LongOpt objects, the + * getopt() method will throw a NullPointerException. + *
+ * When getopt() is called and a long option is encountered, one of two + * things can be returned. If the flag field in the LongOpt object + * representing the long option is non-null, then the integer value field + * is stored there and an integer 0 is returned to the caller. The val + * field can then be retrieved from the flag field. Note that since the + * flag field is a StringBuffer, the appropriate String to integer converions + * must be performed in order to get the actual int value stored there. + * If the flag field in the LongOpt object is null, then the value field + * of the LongOpt is returned. This can be the character of a short option. + * This allows an app to have both a long and short option sequence + * (say, "-h" and "--help") that do the exact same thing. + *
+ * With long options, there is an alternative method of determining + * which option was selected. The method getLongind() will return the + * the index in the long option array (NOT argv) of the long option found. + * So if multiple long options are configured to return the same value, + * the application can use getLongind() to distinguish between them. + *
+ * Here is an expanded Getopt example using long options and various + * techniques described above: + *
+ *
+ * int c;
+ * String arg;
+ * LongOpt[] longopts = new LongOpt[3];
+ * //
+ * StringBuffer sb = new StringBuffer();
+ * longopts[0] = new LongOpt("help", LongOpt.NO_ARGUMENT, null, 'h');
+ * longopts[1] = new LongOpt("outputdir", LongOpt.REQUIRED_ARGUMENT, sb, 'o');
+ * longopts[2] = new LongOpt("maximum", LongOpt.OPTIONAL_ARGUMENT, null, 2);
+ * //
+ * Getopt g = new Getopt("testprog", argv, "-:bc::d:hW;", longopts);
+ * g.setOpterr(false); // We'll do our own error handling
+ * //
+ * while ((c = g.getopt()) != -1)
+ * switch (c)
+ * {
+ * case 0:
+ * arg = g.getOptarg();
+ * System.out.println("Got long option with value '" +
+ * (char)(new Integer(sb.toString())).intValue()
+ * + "' with argument " +
+ * ((arg != null) ? arg : "null"));
+ * break;
+ * //
+ * case 1:
+ * System.out.println("I see you have return in order set and that " +
+ * "a non-option argv element was just found " +
+ * "with the value '" + g.getOptarg() + "'");
+ * break;
+ * //
+ * case 2:
+ * arg = g.getOptarg();
+ * System.out.println("I know this, but pretend I didn't");
+ * System.out.println("We picked option " +
+ * longopts[g.getLongind()].getName() +
+ * " with value " +
+ * ((arg != null) ? arg : "null"));
+ * break;
+ * //
+ * case 'b':
+ * System.out.println("You picked plain old option " + (char)c);
+ * break;
+ * //
+ * case 'c':
+ * case 'd':
+ * arg = g.getOptarg();
+ * System.out.println("You picked option '" + (char)c +
+ * "' with argument " +
+ * ((arg != null) ? arg : "null"));
+ * break;
+ * //
+ * case 'h':
+ * System.out.println("I see you asked for help");
+ * break;
+ * //
+ * case 'W':
+ * System.out.println("Hmmm. You tried a -W with an incorrect long " +
+ * "option name");
+ * break;
+ * //
+ * case ':':
+ * System.out.println("Doh! You need an argument for option " +
+ * (char)g.getOptopt());
+ * break;
+ * //
+ * case '?':
+ * System.out.println("The option '" + (char)g.getOptopt() +
+ * "' is not valid");
+ * break;
+ * //
+ * default:
+ * System.out.println("getopt() returned " + c);
+ * break;
+ * }
+ * //
+ * for (int i = g.getOptind(); i < argv.length ; i++)
+ * System.out.println("Non option argv element: " + argv[i] + "\n");
+ *
+ * + * There is an alternative form of the constructor used for long options + * above. This takes a trailing boolean flag. If set to false, Getopt + * performs identically to the example, but if the boolean flag is true + * then long options are allowed to start with a single '-' instead of + * "--". If the first character of the option is a valid short option + * character, then the option is treated as if it were the short option. + * Otherwise it behaves as if the option is a long option. Note that + * the name given to this option - long_only - is very counter-intuitive. + * It does not cause only long options to be parsed but instead enables + * the behavior described above. + *
+ * Note that the functionality and variable names used are driven from + * the C lib version as this object is a port of the C code, not a + * new implementation. This should aid in porting existing C/C++ code, + * as well as helping programmers familiar with the glibc version to + * adapt to the Java version even if it seems very non-Java at times. + *
+ * In this release I made all instance variables protected due to + * overwhelming public demand. Any code which relied on optarg, + * opterr, optind, or optopt being public will need to be modified to + * use the appropriate access methods. + *
+ * Please send all bug reports, requests, and comments to
+ * arenn@urbanophile.com.
+ *
+ * @version 1.0.7
+ *
+ * @author Roland McGrath (roland@gnu.ai.mit.edu)
+ * @author Ulrich Drepper (drepper@cygnus.com)
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ *
+ * @see LongOpt
*/
+public class Getopt extends Object {
+
+ /**************************************************************************/
+
+ /*
+ * Class Variables
+ */
+ /**
+ * Describe how to deal with options that follow non-option ARGV-elements.
+ *
+ * If the caller did not specify anything,
+ * the default is REQUIRE_ORDER if the property
+ * gnu.posixly_correct is defined, PERMUTE otherwise.
+ *
+ * The special argument `--' forces an end of option-scanning regardless
+ * of the value of `ordering'. In the case of RETURN_IN_ORDER, only
+ * `--' can cause `getopt' to return -1 with `optind' != ARGC.
+ *
+ * REQUIRE_ORDER means don't recognize them as options;
+ * stop option processing when the first non-option is seen.
+ * This is what Unix does.
+ * This mode of operation is selected by either setting the property
+ * gnu.posixly_correct, or using `+' as the first character
+ * of the list of option characters.
+ */
+ protected static final int REQUIRE_ORDER = 1;
+ /**
+ * PERMUTE is the default. We permute the contents of ARGV as we scan,
+ * so that eventually all the non-options are at the end. This allows options
+ * to be given in any order, even with programs that were not written to
+ * expect this.
+ */
+ protected static final int PERMUTE = 2;
+ /**
+ * RETURN_IN_ORDER is an option available to programs that were written
+ * to expect options and other ARGV-elements in any order and that care about
+ * the ordering of the two. We describe each non-option ARGV-element
+ * as if it were the argument of an option with character code 1.
+ * Using `-' as the first character of the list of option characters
+ * selects this mode of operation.
+ */
+ protected static final int RETURN_IN_ORDER = 3;
+ /**************************************************************************/
+
+ /*
+ * Instance Variables
+ */
+ /**
+ * For communication from `getopt' to the caller.
+ * When `getopt' finds an option that takes an argument,
+ * the argument value is returned here.
+ * Also, when `ordering' is RETURN_IN_ORDER,
+ * each non-option ARGV-element is returned here.
+ */
+ protected String optarg;
+ /**
+ * Index in ARGV of the next element to be scanned.
+ * This is used for communication to and from the caller
+ * and for communication between successive calls to `getopt'.
+ *
+ * On entry to `getopt', zero means this is the first call; initialize.
+ *
+ * When `getopt' returns -1, this is the index of the first of the
+ * non-option elements that the caller should itself scan.
+ *
+ * Otherwise, `optind' communicates from one call to the next
+ * how much of ARGV has been scanned so far.
+ */
+ protected int optind = 0;
+ /**
+ * Callers store false here to inhibit the error message
+ * for unrecognized options.
+ */
+ protected boolean opterr = true;
+ /**
+ * When an unrecognized option is encountered, getopt will return a '?'
+ * and store the value of the invalid option here.
+ */
+ protected int optopt = '?';
+ /**
+ * The next char to be scanned in the option-element
+ * in which the last option character we returned was found.
+ * This allows us to pick up the scan where we left off.
+ *
+ * If this is zero, or a null string, it means resume the scan
+ * by advancing to the next ARGV-element.
+ */
+ protected String nextchar;
+ /**
+ * This is the string describing the valid short options.
+ */
+ protected String optstring;
+ /**
+ * This is an array of LongOpt objects which describ the valid long
+ * options.
+ */
+ protected LongOpt[] long_options;
+ /**
+ * This flag determines whether or not we are parsing only long args
+ */
+ protected boolean long_only;
+ /**
+ * Stores the index into the long_options array of the long option found
+ */
+ protected int longind;
+ /**
+ * The flag determines whether or not we operate in strict POSIX compliance
+ */
+ protected boolean posixly_correct;
+ /**
+ * A flag which communicates whether or not checkLongOption() did all
+ * necessary processing for the current option
+ */
+ protected boolean longopt_handled;
+ /**
+ * The index of the first non-option in argv[]
+ */
+ protected int first_nonopt = 1;
+ /**
+ * The index of the last non-option in argv[]
+ */
+ protected int last_nonopt = 1;
+ /**
+ * Flag to tell getopt to immediately return -1 the next time it is
+ * called.
+ */
+ private boolean endparse = false;
+ /**
+ * Saved argument list passed to the program
+ */
+ protected String[] argv;
+ /**
+ * Determines whether we permute arguments or not
+ */
+ protected int ordering;
+ /**
+ * Name to print as the program name in error messages. This is necessary
+ * since Java does not place the program name in argv[0]
+ */
+ protected String progname;
+ /**
+ * The localized strings are kept in a separate file
+ */
+ private ResourceBundle _messages = ResourceBundle.getBundle(
+ "gnu/getopt/MessagesBundle", Locale.getDefault());
+
+ /**************************************************************************/
+
+ /*
+ * Constructors
+ */
+ /**
+ * Construct a basic Getopt instance with the given input data. Note that
+ * this handles "short" options only.
+ *
+ * @param progname The name to display as the program name when printing errors
+ * @param argv The String array passed as the command line to the program.
+ * @param optstring A String containing a description of the valid args for this program
+ */
+ public Getopt(String progname, String[] argv, String optstring) {
+ this(progname, argv, optstring, null, false);
+ }
-/**
- * Describe how to deal with options that follow non-option ARGV-elements.
- *
- * If the caller did not specify anything,
- * the default is REQUIRE_ORDER if the property
- * gnu.posixly_correct is defined, PERMUTE otherwise.
- *
- * The special argument `--' forces an end of option-scanning regardless
- * of the value of `ordering'. In the case of RETURN_IN_ORDER, only
- * `--' can cause `getopt' to return -1 with `optind' != ARGC.
- *
- * REQUIRE_ORDER means don't recognize them as options;
- * stop option processing when the first non-option is seen.
- * This is what Unix does.
- * This mode of operation is selected by either setting the property
- * gnu.posixly_correct, or using `+' as the first character
- * of the list of option characters.
- */
-protected static final int REQUIRE_ORDER = 1;
-
-/**
- * PERMUTE is the default. We permute the contents of ARGV as we scan,
- * so that eventually all the non-options are at the end. This allows options
- * to be given in any order, even with programs that were not written to
- * expect this.
- */
-protected static final int PERMUTE = 2;
-
-/**
- * RETURN_IN_ORDER is an option available to programs that were written
- * to expect options and other ARGV-elements in any order and that care about
- * the ordering of the two. We describe each non-option ARGV-element
- * as if it were the argument of an option with character code 1.
- * Using `-' as the first character of the list of option characters
- * selects this mode of operation.
- */
-protected static final int RETURN_IN_ORDER = 3;
+ /**************************************************************************/
+ /**
+ * Construct a Getopt instance with given input data that is capable of
+ * parsing long options as well as short.
+ *
+ * @param progname The name to display as the program name when printing errors
+ * @param argv The String array passed as the command ilne to the program
+ * @param optstring A String containing a description of the valid short args for this program
+ * @param long_options An array of LongOpt objects that describes the valid long args for this program
+ */
+ public Getopt(String progname, String[] argv, String optstring,
+ LongOpt[] long_options) {
+ this(progname, argv, optstring, long_options, false);
+ }
-/**************************************************************************/
+ /**************************************************************************/
+ /**
+ * Construct a Getopt instance with given input data that is capable of
+ * parsing long options and short options. Contrary to what you might
+ * think, the flag 'long_only' does not determine whether or not we
+ * scan for only long arguments. Instead, a value of true here allows
+ * long arguments to start with a '-' instead of '--' unless there is a
+ * conflict with a short option name.
+ *
+ * @param progname The name to display as the program name when printing errors
+ * @param argv The String array passed as the command ilne to the program
+ * @param optstring A String containing a description of the valid short args for this program
+ * @param long_options An array of LongOpt objects that describes the valid long args for this program
+ * @param long_only true if long options that do not conflict with short options can start with a '-' as well as '--'
+ */
+ public Getopt(String progname, String[] argv, String optstring,
+ LongOpt[] long_options, boolean long_only) {
+ if (optstring.isEmpty()) {
+ optstring = " ";
+ }
-/*
- * Instance Variables
- */
-
-/**
- * For communication from `getopt' to the caller.
- * When `getopt' finds an option that takes an argument,
- * the argument value is returned here.
- * Also, when `ordering' is RETURN_IN_ORDER,
- * each non-option ARGV-element is returned here.
- */
-protected String optarg;
+ // This function is essentially _getopt_initialize from GNU getopt
+ this.progname = progname;
+ this.argv = argv;
+ this.optstring = optstring;
+ this.long_options = long_options;
+ this.long_only = long_only;
+
+ // Check for property "gnu.posixly_correct" to determine whether to
+ // strictly follow the POSIX standard. This replaces the "POSIXLY_CORRECT"
+ // environment variable in the C version
+ if (System.getProperty("gnu.posixly_correct", null) == null) {
+ posixly_correct = false;
+ } else {
+ posixly_correct = true;
+ _messages = ResourceBundle.getBundle("gnu/getopt/MessagesBundle",
+ Locale.US);
+ }
-/**
- * Index in ARGV of the next element to be scanned.
- * This is used for communication to and from the caller
- * and for communication between successive calls to `getopt'.
- *
- * On entry to `getopt', zero means this is the first call; initialize.
- *
- * When `getopt' returns -1, this is the index of the first of the
- * non-option elements that the caller should itself scan.
- *
- * Otherwise, `optind' communicates from one call to the next
- * how much of ARGV has been scanned so far.
- */
-protected int optind = 0;
-
-/**
- * Callers store false here to inhibit the error message
- * for unrecognized options.
- */
-protected boolean opterr = true;
-
-/**
- * When an unrecognized option is encountered, getopt will return a '?'
- * and store the value of the invalid option here.
- */
-protected int optopt = '?';
-
-/**
- * The next char to be scanned in the option-element
- * in which the last option character we returned was found.
- * This allows us to pick up the scan where we left off.
- *
- * If this is zero, or a null string, it means resume the scan
- * by advancing to the next ARGV-element.
- */
-protected String nextchar;
+ // Determine how to handle the ordering of options and non-options
+ if (optstring.charAt(0) == '-') {
+ ordering = RETURN_IN_ORDER;
+ if (optstring.length() > 1) {
+ this.optstring = optstring.substring(1);
+ }
+ } else if (optstring.charAt(0) == '+') {
+ ordering = REQUIRE_ORDER;
+ if (optstring.length() > 1) {
+ this.optstring = optstring.substring(1);
+ }
+ } else if (posixly_correct) {
+ ordering = REQUIRE_ORDER;
+ } else {
+ ordering = PERMUTE; // The normal default case
+ }
+ }
-/**
- * This is the string describing the valid short options.
- */
-protected String optstring;
+ /**************************************************************************/
+ /*
+ * Instance Methods
+ */
+ /**
+ * In GNU getopt, it is possible to change the string containg valid options
+ * on the fly because it is passed as an argument to getopt() each time. In
+ * this version we do not pass the string on every call. In order to allow
+ * dynamic option string changing, this method is provided.
+ *
+ * @param optstring The new option string to use
+ */
+ public void setOptstring(String optstring) {
+ if (optstring.isEmpty()) {
+ optstring = " ";
+ }
-/**
- * This is an array of LongOpt objects which describ the valid long
- * options.
- */
-protected LongOpt[] long_options;
+ this.optstring = optstring;
+ }
-/**
- * This flag determines whether or not we are parsing only long args
- */
-protected boolean long_only;
+ /**************************************************************************/
+ /**
+ * optind it the index in ARGV of the next element to be scanned.
+ * This is used for communication to and from the caller
+ * and for communication between successive calls to `getopt'.
+ *
+ * When `getopt' returns -1, this is the index of the first of the
+ * non-option elements that the caller should itself scan.
+ *
+ * Otherwise, `optind' communicates from one call to the next
+ * how much of ARGV has been scanned so far.
+ */
+ public int getOptind() {
+ return (optind);
+ }
-/**
- * Stores the index into the long_options array of the long option found
- */
-protected int longind;
+ /**************************************************************************/
+ /**
+ * This method allows the optind index to be set manually. Normally this
+ * is not necessary (and incorrect usage of this method can lead to serious
+ * lossage), but optind is a public symbol in GNU getopt, so this method
+ * was added to allow it to be modified by the caller if desired.
+ *
+ * @param optind The new value of optind
+ */
+ public void setOptind(int optind) {
+ this.optind = optind;
+ }
-/**
- * The flag determines whether or not we operate in strict POSIX compliance
- */
-protected boolean posixly_correct;
+ /**************************************************************************/
+ /**
+ * Since in GNU getopt() the argument vector is passed back in to the
+ * function every time, the caller can swap out argv on the fly. Since
+ * passing argv is not required in the Java version, this method allows
+ * the user to override argv. Note that incorrect use of this method can
+ * lead to serious lossage.
+ *
+ * @param argv New argument list
+ */
+ public void setArgv(String[] argv) {
+ this.argv = argv;
+ }
-/**
- * A flag which communicates whether or not checkLongOption() did all
- * necessary processing for the current option
- */
-protected boolean longopt_handled;
+ /**************************************************************************/
+ /**
+ * For communication from `getopt' to the caller.
+ * When `getopt' finds an option that takes an argument,
+ * the argument value is returned here.
+ * Also, when `ordering' is RETURN_IN_ORDER,
+ * each non-option ARGV-element is returned here.
+ * No set method is provided because setting this variable has no effect.
+ */
+ public String getOptarg() {
+ return (optarg);
+ }
-/**
- * The index of the first non-option in argv[]
- */
-protected int first_nonopt = 1;
+ /**************************************************************************/
+ /**
+ * Normally Getopt will print a message to the standard error when an
+ * invalid option is encountered. This can be suppressed (or re-enabled)
+ * by calling this method. There is no get method for this variable
+ * because if you can't remember the state you set this to, why should I?
+ */
+ public void setOpterr(boolean opterr) {
+ this.opterr = opterr;
+ }
-/**
- * The index of the last non-option in argv[]
- */
-protected int last_nonopt = 1;
+ /**************************************************************************/
+ /**
+ * When getopt() encounters an invalid option, it stores the value of that
+ * option in optopt which can be retrieved with this method. There is
+ * no corresponding set method because setting this variable has no effect.
+ */
+ public int getOptopt() {
+ return (optopt);
+ }
-/**
- * Flag to tell getopt to immediately return -1 the next time it is
- * called.
- */
-private boolean endparse = false;
+ /**************************************************************************/
+ /**
+ * Returns the index into the array of long options (NOT argv) representing
+ * the long option that was found.
+ */
+ public int getLongind() {
+ return (longind);
+ }
-/**
- * Saved argument list passed to the program
- */
-protected String[] argv;
+ /**************************************************************************/
+ /**
+ * Exchange the shorter segment with the far end of the longer segment.
+ * That puts the shorter segment into the right place.
+ * It leaves the longer segment in the right place overall,
+ * but it consists of two parts that need to be swapped next.
+ * This method is used by getopt() for argument permutation.
+ */
+ protected void exchange(String[] argv) {
+ int bottom = first_nonopt;
+ int middle = last_nonopt;
+ int top = optind;
+ String tem;
+
+ while (top > middle && middle > bottom) {
+ if (top - middle > middle - bottom) {
+ // Bottom segment is the short one.
+ int len = middle - bottom;
+ int i;
+
+ // Swap it with the top part of the top segment.
+ for (i = 0; i < len; i++) {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[top - (middle - bottom) + i];
+ argv[top - (middle - bottom) + i] = tem;
+ }
+ // Exclude the moved bottom segment from further swapping.
+ top -= len;
+ } else {
+ // Top segment is the short one.
+ int len = top - middle;
+ int i;
+
+ // Swap it with the bottom part of the bottom segment.
+ for (i = 0; i < len; i++) {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[middle + i];
+ argv[middle + i] = tem;
+ }
+ // Exclude the moved top segment from further swapping.
+ bottom += len;
+ }
+ }
-/**
- * Determines whether we permute arguments or not
- */
-protected int ordering;
+ // Update records for the slots the non-options now occupy.
-/**
- * Name to print as the program name in error messages. This is necessary
- * since Java does not place the program name in argv[0]
- */
-protected String progname;
+ first_nonopt += (optind - last_nonopt);
+ last_nonopt = optind;
+ }
-/**
- * The localized strings are kept in a separate file
- */
-private ResourceBundle _messages = ResourceBundle.getBundle(
- "gnu/getopt/MessagesBundle", Locale.getDefault());
+ /**************************************************************************/
+ /**
+ * Check to see if an option is a valid long option. Called by getopt().
+ * Put in a separate method because this needs to be done twice. (The
+ * C getopt authors just copy-pasted the code!).
+ *
+ * @param longind A buffer in which to store the 'val' field of found LongOpt
+ *
+ * @return Various things depending on circumstances
+ */
+ protected int checkLongOption() {
+ LongOpt pfound = null;
+ int nameend;
+ boolean ambig;
+ boolean exact;
+
+ longopt_handled = true;
+ ambig = false;
+ exact = false;
+ longind = -1;
+
+ nameend = nextchar.indexOf("=");
+ if (nameend == -1) {
+ nameend = nextchar.length();
+ }
-/**************************************************************************/
+ // Test all lnog options for either exact match or abbreviated matches
+ for (int i = 0; i < long_options.length; i++) {
+ if (long_options[i].getName().startsWith(nextchar.substring(0, nameend))) {
+ if (long_options[i].getName().equals(nextchar.substring(0, nameend))) {
+ // Exact match found
+ pfound = long_options[i];
+ longind = i;
+ exact = true;
+ break;
+ } else if (pfound == null) {
+ // First nonexact match found
+ pfound = long_options[i];
+ longind = i;
+ } else {
+ // Second or later nonexact match found
+ ambig = true;
+ }
+ }
+ } // for
+
+ // Print out an error if the option specified was ambiguous
+ if (ambig && !exact) {
+ if (opterr) {
+ Object[] msgArgs = {progname, argv[optind]};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.ambigious"),
+ msgArgs));
+ }
-/*
- * Constructors
- */
+ nextchar = "";
+ optopt = 0;
+ ++optind;
-/**
- * Construct a basic Getopt instance with the given input data. Note that
- * this handles "short" options only.
- *
- * @param progname The name to display as the program name when printing errors
- * @param argv The String array passed as the command line to the program.
- * @param optstring A String containing a description of the valid args for this program
- */
-public
-Getopt(String progname, String[] argv, String optstring)
-{
- this(progname, argv, optstring, null, false);
-}
+ return ('?');
+ }
-/**************************************************************************/
+ if (pfound != null) {
+ ++optind;
-/**
- * Construct a Getopt instance with given input data that is capable of
- * parsing long options as well as short.
- *
- * @param progname The name to display as the program name when printing errors
- * @param argv The String array passed as the command ilne to the program
- * @param optstring A String containing a description of the valid short args for this program
- * @param long_options An array of LongOpt objects that describes the valid long args for this program
- */
-public
-Getopt(String progname, String[] argv, String optstring,
- LongOpt[] long_options)
-{
- this(progname, argv, optstring, long_options, false);
-}
+ if (nameend != nextchar.length()) {
+ if (pfound.has_arg != LongOpt.NO_ARGUMENT) {
+ if (nextchar.substring(nameend).length() > 1) {
+ optarg = nextchar.substring(nameend + 1);
+ } else {
+ optarg = "";
+ }
+ } else {
+ if (opterr) {
+ // -- option
+ if (argv[optind - 1].startsWith("--")) {
+ Object[] msgArgs = {progname, pfound.name};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.arguments1"),
+ msgArgs));
+ } // +option or -option
+ else {
+ Object[] msgArgs = {progname, new Character(argv[optind - 1].charAt(0)).toString(),
+ pfound.name};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.arguments2"),
+ msgArgs));
+ }
+ }
-/**************************************************************************/
+ nextchar = "";
+ optopt = pfound.val;
-/**
- * Construct a Getopt instance with given input data that is capable of
- * parsing long options and short options. Contrary to what you might
- * think, the flag 'long_only' does not determine whether or not we
- * scan for only long arguments. Instead, a value of true here allows
- * long arguments to start with a '-' instead of '--' unless there is a
- * conflict with a short option name.
- *
- * @param progname The name to display as the program name when printing errors
- * @param argv The String array passed as the command ilne to the program
- * @param optstring A String containing a description of the valid short args for this program
- * @param long_options An array of LongOpt objects that describes the valid long args for this program
- * @param long_only true if long options that do not conflict with short options can start with a '-' as well as '--'
- */
-public
-Getopt(String progname, String[] argv, String optstring,
- LongOpt[] long_options, boolean long_only)
-{
- if (optstring.length() == 0)
- optstring = " ";
-
- // This function is essentially _getopt_initialize from GNU getopt
- this.progname = progname;
- this.argv = argv;
- this.optstring = optstring;
- this.long_options = long_options;
- this.long_only = long_only;
-
- // Check for property "gnu.posixly_correct" to determine whether to
- // strictly follow the POSIX standard. This replaces the "POSIXLY_CORRECT"
- // environment variable in the C version
- if (System.getProperty("gnu.posixly_correct", null) == null)
- posixly_correct = false;
- else
- {
- posixly_correct = true;
- _messages = ResourceBundle.getBundle("gnu/getopt/MessagesBundle",
- Locale.US);
- }
+ return ('?');
+ }
+ } // if (nameend)
+ else if (pfound.has_arg == LongOpt.REQUIRED_ARGUMENT) {
+ if (optind < argv.length) {
+ optarg = argv[optind];
+ ++optind;
+ } else {
+ if (opterr) {
+ Object[] msgArgs = {progname, argv[optind - 1]};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.requires"),
+ msgArgs));
+ }
- // Determine how to handle the ordering of options and non-options
- if (optstring.charAt(0) == '-')
- {
- ordering = RETURN_IN_ORDER;
- if (optstring.length() > 1)
- this.optstring = optstring.substring(1);
- }
- else if (optstring.charAt(0) == '+')
- {
- ordering = REQUIRE_ORDER;
- if (optstring.length() > 1)
- this.optstring = optstring.substring(1);
- }
- else if (posixly_correct)
- {
- ordering = REQUIRE_ORDER;
- }
- else
- {
- ordering = PERMUTE; // The normal default case
- }
-}
+ nextchar = "";
+ optopt = pfound.val;
+ if (optstring.charAt(0) == ':') {
+ return (':');
+ } else {
+ return ('?');
+ }
+ }
+ } // else if (pfound)
-/**************************************************************************/
-
-/*
- * Instance Methods
- */
+ nextchar = "";
-/**
- * In GNU getopt, it is possible to change the string containg valid options
- * on the fly because it is passed as an argument to getopt() each time. In
- * this version we do not pass the string on every call. In order to allow
- * dynamic option string changing, this method is provided.
- *
- * @param optstring The new option string to use
- */
-public void
-setOptstring(String optstring)
-{
- if (optstring.length() == 0)
- optstring = " ";
-
- this.optstring = optstring;
-}
+ if (pfound.flag != null) {
+ pfound.flag.setLength(0);
+ pfound.flag.append(pfound.val);
-/**************************************************************************/
+ return (0);
+ }
-/**
- * optind it the index in ARGV of the next element to be scanned.
- * This is used for communication to and from the caller
- * and for communication between successive calls to `getopt'.
- *
- * When `getopt' returns -1, this is the index of the first of the
- * non-option elements that the caller should itself scan.
- *
- * Otherwise, `optind' communicates from one call to the next
- * how much of ARGV has been scanned so far.
- */
-public int
-getOptind()
-{
- return(optind);
-}
+ return (pfound.val);
+ } // if (pfound != null)
-/**************************************************************************/
+ longopt_handled = false;
-/**
- * This method allows the optind index to be set manually. Normally this
- * is not necessary (and incorrect usage of this method can lead to serious
- * lossage), but optind is a public symbol in GNU getopt, so this method
- * was added to allow it to be modified by the caller if desired.
- *
- * @param optind The new value of optind
- */
-public void
-setOptind(int optind)
-{
- this.optind = optind;
-}
+ return (0);
+ }
-/**************************************************************************/
+ /**************************************************************************/
+ /**
+ * This method returns a char that is the current option that has been
+ * parsed from the command line. If the option takes an argument, then
+ * the internal variable 'optarg' is set which is a String representing
+ * the the value of the argument. This value can be retrieved by the
+ * caller using the getOptarg() method. If an invalid option is found,
+ * an error message is printed and a '?' is returned. The name of the
+ * invalid option character can be retrieved by calling the getOptopt()
+ * method. When there are no more options to be scanned, this method
+ * returns -1. The index of first non-option element in argv can be
+ * retrieved with the getOptind() method.
+ *
+ * @return Various things as described above
+ */
+ public int getopt() {
+ optarg = null;
+
+ if (endparse == true) {
+ return (-1);
+ }
-/**
- * Since in GNU getopt() the argument vector is passed back in to the
- * function every time, the caller can swap out argv on the fly. Since
- * passing argv is not required in the Java version, this method allows
- * the user to override argv. Note that incorrect use of this method can
- * lead to serious lossage.
- *
- * @param argv New argument list
- */
-public void
-setArgv(String[] argv)
-{
- this.argv = argv;
-}
+ if ((nextchar == null) || (nextchar != null && nextchar.isEmpty())) {
+ // If we have just processed some options following some non-options,
+ // exchange them so that the options come first.
+ if (last_nonopt > optind) {
+ last_nonopt = optind;
+ }
+ if (first_nonopt > optind) {
+ first_nonopt = optind;
+ }
-/**************************************************************************/
+ if (ordering == PERMUTE) {
+ // If we have just processed some options following some non-options,
+ // exchange them so that the options come first.
+ if ((first_nonopt != last_nonopt) && (last_nonopt != optind)) {
+ exchange(argv);
+ } else if (last_nonopt != optind) {
+ first_nonopt = optind;
+ }
-/**
- * For communication from `getopt' to the caller.
- * When `getopt' finds an option that takes an argument,
- * the argument value is returned here.
- * Also, when `ordering' is RETURN_IN_ORDER,
- * each non-option ARGV-element is returned here.
- * No set method is provided because setting this variable has no effect.
- */
-public String
-getOptarg()
-{
- return(optarg);
-}
+ // Skip any additional non-options
+ // and extend the range of non-options previously skipped.
+ while ((optind < argv.length) && (argv[optind] != null && argv[optind].isEmpty() ||
+ (argv[optind].charAt(0) != '-') || "-".equals(argv[optind]))) {
+ optind++;
+ }
-/**************************************************************************/
+ last_nonopt = optind;
+ }
-/**
- * Normally Getopt will print a message to the standard error when an
- * invalid option is encountered. This can be suppressed (or re-enabled)
- * by calling this method. There is no get method for this variable
- * because if you can't remember the state you set this to, why should I?
- */
-public void
-setOpterr(boolean opterr)
-{
- this.opterr = opterr;
-}
+ // The special ARGV-element `--' means premature end of options.
+ // Skip it like a null option,
+ // then exchange with previous non-options as if it were an option,
+ // then skip everything else like a non-option.
+ if ((optind != argv.length) && "--".equals(argv[optind])) {
+ optind++;
+
+ if ((first_nonopt != last_nonopt) && (last_nonopt != optind)) {
+ exchange(argv);
+ } else if (first_nonopt == last_nonopt) {
+ first_nonopt = optind;
+ }
-/**************************************************************************/
+ last_nonopt = argv.length;
-/**
- * When getopt() encounters an invalid option, it stores the value of that
- * option in optopt which can be retrieved with this method. There is
- * no corresponding set method because setting this variable has no effect.
- */
-public int
-getOptopt()
-{
- return(optopt);
-}
+ optind = argv.length;
+ }
-/**************************************************************************/
+ // If we have done all the ARGV-elements, stop the scan
+ // and back over any non-options that we skipped and permuted.
+ if (optind == argv.length) {
+ // Set the next-arg-index to point at the non-options
+ // that we previously skipped, so the caller will digest them.
+ if (first_nonopt != last_nonopt) {
+ optind = first_nonopt;
+ }
-/**
- * Returns the index into the array of long options (NOT argv) representing
- * the long option that was found.
- */
-public int
-getLongind()
-{
- return(longind);
-}
+ return (-1);
+ }
-/**************************************************************************/
+ // If we have come to a non-option and did not permute it,
+ // either stop the scan or describe it to the caller and pass it by.
+ if (argv[optind] != null && argv[optind].isEmpty() || (argv[optind].charAt(0) != '-') ||
+ "-".equals(argv[optind])) {
+ if (ordering == REQUIRE_ORDER) {
+ return (-1);
+ }
-/**
- * Exchange the shorter segment with the far end of the longer segment.
- * That puts the shorter segment into the right place.
- * It leaves the longer segment in the right place overall,
- * but it consists of two parts that need to be swapped next.
- * This method is used by getopt() for argument permutation.
- */
-protected void
-exchange(String[] argv)
-{
- int bottom = first_nonopt;
- int middle = last_nonopt;
- int top = optind;
- String tem;
-
- while (top > middle && middle > bottom)
- {
- if (top - middle > middle - bottom)
- {
- // Bottom segment is the short one.
- int len = middle - bottom;
- int i;
-
- // Swap it with the top part of the top segment.
- for (i = 0; i < len; i++)
- {
- tem = argv[bottom + i];
- argv[bottom + i] = argv[top - (middle - bottom) + i];
- argv[top - (middle - bottom) + i] = tem;
+ optarg = argv[optind++];
+ return (1);
}
- // Exclude the moved bottom segment from further swapping.
- top -= len;
- }
- else
- {
- // Top segment is the short one.
- int len = top - middle;
- int i;
-
- // Swap it with the bottom part of the bottom segment.
- for (i = 0; i < len; i++)
- {
- tem = argv[bottom + i];
- argv[bottom + i] = argv[middle + i];
- argv[middle + i] = tem;
+
+ // We have found another option-ARGV-element.
+ // Skip the initial punctuation.
+ if (argv[optind].startsWith("--")) {
+ nextchar = argv[optind].substring(2);
+ } else {
+ nextchar = argv[optind].substring(1);
}
- // Exclude the moved top segment from further swapping.
- bottom += len;
}
- }
- // Update records for the slots the non-options now occupy.
+ // Decode the current option-ARGV-element.
- first_nonopt += (optind - last_nonopt);
- last_nonopt = optind;
-}
+ /* Check whether the ARGV-element is a long option.
-/**************************************************************************/
+ If long_only and the ARGV-element has the form "-f", where f is
+ a valid short option, don't consider it an abbreviated form of
+ a long option that starts with f. Otherwise there would be no
+ way to give the -f short option.
-/**
- * Check to see if an option is a valid long option. Called by getopt().
- * Put in a separate method because this needs to be done twice. (The
- * C getopt authors just copy-pasted the code!).
- *
- * @param longind A buffer in which to store the 'val' field of found LongOpt
- *
- * @return Various things depending on circumstances
- */
-protected int
-checkLongOption()
-{
- LongOpt pfound = null;
- int nameend;
- boolean ambig;
- boolean exact;
-
- longopt_handled = true;
- ambig = false;
- exact = false;
- longind = -1;
-
- nameend = nextchar.indexOf("=");
- if (nameend == -1)
- nameend = nextchar.length();
-
- // Test all lnog options for either exact match or abbreviated matches
- for (int i = 0; i < long_options.length; i++)
- {
- if (long_options[i].getName().startsWith(nextchar.substring(0, nameend)))
- {
- if (long_options[i].getName().equals(nextchar.substring(0, nameend)))
- {
- // Exact match found
- pfound = long_options[i];
- longind = i;
- exact = true;
- break;
- }
- else if (pfound == null)
- {
- // First nonexact match found
- pfound = long_options[i];
- longind = i;
- }
- else
- {
- // Second or later nonexact match found
- ambig = true;
- }
- }
- } // for
-
- // Print out an error if the option specified was ambiguous
- if (ambig && !exact)
- {
- if (opterr)
- {
- Object[] msgArgs = { progname, argv[optind] };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.ambigious"),
- msgArgs));
- }
+ On the other hand, if there's a long option "fubar" and
+ the ARGV-element is "-fu", do consider that an abbreviation of
+ the long option, just like "--fu", and not "-f" with arg "u".
- nextchar = "";
- optopt = 0;
- ++optind;
-
- return('?');
- }
-
- if (pfound != null)
- {
- ++optind;
-
- if (nameend != nextchar.length())
- {
- if (pfound.has_arg != LongOpt.NO_ARGUMENT)
- {
- if (nextchar.substring(nameend).length() > 1)
- optarg = nextchar.substring(nameend+1);
- else
- optarg = "";
+ This distinction seems to be the most useful approach. */
+ if ((long_options != null) && (argv[optind].startsWith("--") || (long_only && ((argv[optind].length() > 2) ||
+ (optstring.indexOf(argv[optind].charAt(1)) == -1))))) {
+ int c = checkLongOption();
+
+ if (longopt_handled) {
+ return (c);
}
- else
- {
- if (opterr)
- {
- // -- option
- if (argv[optind - 1].startsWith("--"))
- {
- Object[] msgArgs = { progname, pfound.name };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.arguments1"),
- msgArgs));
- }
- // +option or -option
- else
- {
- Object[] msgArgs = { progname, new
- Character(argv[optind-1].charAt(0)).toString(),
- pfound.name };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.arguments2"),
- msgArgs));
+
+ // Can't find it as a long option. If this is not getopt_long_only,
+ // or the option starts with '--' or is not a valid short
+ // option, then it's an error.
+ // Otherwise interpret it as a short option.
+ if (!long_only || argv[optind].startsWith("--") || (optstring.indexOf(nextchar.charAt(0)) == -1)) {
+ if (opterr) {
+ if (argv[optind].startsWith("--")) {
+ Object[] msgArgs = {progname, nextchar};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.unrecognized"),
+ msgArgs));
+ } else {
+ Object[] msgArgs = {progname, new Character(argv[optind].charAt(0)).toString(),
+ nextchar};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.unrecognized2"),
+ msgArgs));
}
- }
-
- nextchar = "";
- optopt = pfound.val;
-
- return('?');
- }
- } // if (nameend)
- else if (pfound.has_arg == LongOpt.REQUIRED_ARGUMENT)
- {
- if (optind < argv.length)
- {
- optarg = argv[optind];
- ++optind;
- }
- else
- {
- if (opterr)
- {
- Object[] msgArgs = { progname, argv[optind-1] };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.requires"),
- msgArgs));
}
-
- nextchar = "";
- optopt = pfound.val;
- if (optstring.charAt(0) == ':')
- return(':');
- else
- return('?');
- }
- } // else if (pfound)
-
- nextchar = "";
-
- if (pfound.flag != null)
- {
- pfound.flag.setLength(0);
- pfound.flag.append(pfound.val);
-
- return(0);
- }
-
- return(pfound.val);
- } // if (pfound != null)
-
- longopt_handled = false;
-
- return(0);
-}
-/**************************************************************************/
+ nextchar = "";
+ ++optind;
+ optopt = 0;
-/**
- * This method returns a char that is the current option that has been
- * parsed from the command line. If the option takes an argument, then
- * the internal variable 'optarg' is set which is a String representing
- * the the value of the argument. This value can be retrieved by the
- * caller using the getOptarg() method. If an invalid option is found,
- * an error message is printed and a '?' is returned. The name of the
- * invalid option character can be retrieved by calling the getOptopt()
- * method. When there are no more options to be scanned, this method
- * returns -1. The index of first non-option element in argv can be
- * retrieved with the getOptind() method.
- *
- * @return Various things as described above
- */
-public int
-getopt()
-{
- optarg = null;
-
- if (endparse == true)
- return(-1);
-
- if ((nextchar == null) || (nextchar.equals("")))
- {
- // If we have just processed some options following some non-options,
- // exchange them so that the options come first.
- if (last_nonopt > optind)
- last_nonopt = optind;
- if (first_nonopt > optind)
- first_nonopt = optind;
-
- if (ordering == PERMUTE)
- {
- // If we have just processed some options following some non-options,
- // exchange them so that the options come first.
- if ((first_nonopt != last_nonopt) && (last_nonopt != optind))
- exchange(argv);
- else if (last_nonopt != optind)
- first_nonopt = optind;
-
- // Skip any additional non-options
- // and extend the range of non-options previously skipped.
- while ((optind < argv.length) && (argv[optind].equals("") ||
- (argv[optind].charAt(0) != '-') || argv[optind].equals("-")))
- {
- optind++;
+ return ('?');
}
-
- last_nonopt = optind;
+ } // if (longopts)
+
+ // Look at and handle the next short option-character */
+ int c = nextchar.charAt(0); //**** Do we need to check for empty str?
+ if (nextchar.length() > 1) {
+ nextchar = nextchar.substring(1);
+ } else {
+ nextchar = "";
}
- // The special ARGV-element `--' means premature end of options.
- // Skip it like a null option,
- // then exchange with previous non-options as if it were an option,
- // then skip everything else like a non-option.
- if ((optind != argv.length) && argv[optind].equals("--"))
- {
- optind++;
-
- if ((first_nonopt != last_nonopt) && (last_nonopt != optind))
- exchange (argv);
- else if (first_nonopt == last_nonopt)
- first_nonopt = optind;
-
- last_nonopt = argv.length;
-
- optind = argv.length;
- }
-
- // If we have done all the ARGV-elements, stop the scan
- // and back over any non-options that we skipped and permuted.
- if (optind == argv.length)
- {
- // Set the next-arg-index to point at the non-options
- // that we previously skipped, so the caller will digest them.
- if (first_nonopt != last_nonopt)
- optind = first_nonopt;
-
- return(-1);
+ String temp = null;
+ if (optstring.indexOf(c) != -1) {
+ temp = optstring.substring(optstring.indexOf(c));
}
- // If we have come to a non-option and did not permute it,
- // either stop the scan or describe it to the caller and pass it by.
- if (argv[optind].equals("") || (argv[optind].charAt(0) != '-') ||
- argv[optind].equals("-"))
- {
- if (ordering == REQUIRE_ORDER)
- return(-1);
-
- optarg = argv[optind++];
- return(1);
+ if (nextchar != null && nextchar.isEmpty()) {
+ ++optind;
}
-
- // We have found another option-ARGV-element.
- // Skip the initial punctuation.
- if (argv[optind].startsWith("--"))
- nextchar = argv[optind].substring(2);
- else
- nextchar = argv[optind].substring(1);
- }
-
- // Decode the current option-ARGV-element.
-
- /* Check whether the ARGV-element is a long option.
-
- If long_only and the ARGV-element has the form "-f", where f is
- a valid short option, don't consider it an abbreviated form of
- a long option that starts with f. Otherwise there would be no
- way to give the -f short option.
-
- On the other hand, if there's a long option "fubar" and
- the ARGV-element is "-fu", do consider that an abbreviation of
- the long option, just like "--fu", and not "-f" with arg "u".
-
- This distinction seems to be the most useful approach. */
- if ((long_options != null) && (argv[optind].startsWith("--")
- || (long_only && ((argv[optind].length() > 2) ||
- (optstring.indexOf(argv[optind].charAt(1)) == -1)))))
- {
- int c = checkLongOption();
-
- if (longopt_handled)
- return(c);
-
- // Can't find it as a long option. If this is not getopt_long_only,
- // or the option starts with '--' or is not a valid short
- // option, then it's an error.
- // Otherwise interpret it as a short option.
- if (!long_only || argv[optind].startsWith("--")
- || (optstring.indexOf(nextchar.charAt(0)) == -1))
- {
- if (opterr)
- {
- if (argv[optind].startsWith("--"))
- {
- Object[] msgArgs = { progname, nextchar };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.unrecognized"),
- msgArgs));
- }
- else
- {
- Object[] msgArgs = { progname, new
- Character(argv[optind].charAt(0)).toString(),
- nextchar };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.unrecognized2"),
- msgArgs));
- }
- }
- nextchar = "";
- ++optind;
- optopt = 0;
-
- return('?');
- }
- } // if (longopts)
-
- // Look at and handle the next short option-character */
- int c = nextchar.charAt(0); //**** Do we need to check for empty str?
- if (nextchar.length() > 1)
- nextchar = nextchar.substring(1);
- else
- nextchar = "";
-
- String temp = null;
- if (optstring.indexOf(c) != -1)
- temp = optstring.substring(optstring.indexOf(c));
-
- if (nextchar.equals(""))
- ++optind;
-
- if ((temp == null) || (c == ':'))
- {
- if (opterr)
- {
- if (posixly_correct)
- {
- // 1003.2 specifies the format of this message
- Object[] msgArgs = { progname, new
- Character((char)c).toString() };
- System.err.println(MessageFormat.format(
+ if ((temp == null) || (c == ':')) {
+ if (opterr) {
+ if (posixly_correct) {
+ // 1003.2 specifies the format of this message
+ Object[] msgArgs = {progname, new Character((char) c).toString()};
+ throw new IllegalArgumentException(MessageFormat.format(
_messages.getString("getopt.illegal"), msgArgs));
- }
- else
- {
- Object[] msgArgs = { progname, new
- Character((char)c).toString() };
- System.err.println(MessageFormat.format(
+ } else {
+ Object[] msgArgs = {progname, new Character((char) c).toString()};
+ throw new IllegalArgumentException(MessageFormat.format(
_messages.getString("getopt.invalid"), msgArgs));
+ }
}
- }
- optopt = c;
+ optopt = c;
- return('?');
- }
-
- // Convenience. Treat POSIX -W foo same as long option --foo
- if ((temp.charAt(0) == 'W') && (temp.length() > 1) && (temp.charAt(1) == ';'))
- {
- if (!nextchar.equals(""))
- {
- optarg = nextchar;
+ return ('?');
}
- // No further cars in this argv element and no more argv elements
- else if (optind == argv.length)
- {
- if (opterr)
- {
- // 1003.2 specifies the format of this message.
- Object[] msgArgs = { progname, new
- Character((char)c).toString() };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.requires2"), msgArgs));
- }
- optopt = c;
- if (optstring.charAt(0) == ':')
- return(':');
- else
- return('?');
- }
- else
- {
- // We already incremented `optind' once;
- // increment it again when taking next ARGV-elt as argument.
- nextchar = argv[optind];
- optarg = argv[optind];
- }
+ // Convenience. Treat POSIX -W foo same as long option --foo
+ if ((temp.charAt(0) == 'W') && (temp.length() > 1) && (temp.charAt(1) == ';')) {
+ if (nextchar != null && !nextchar.isEmpty()) {
+ optarg = nextchar;
+ } // No further cars in this argv element and no more argv elements
+ else if (optind == argv.length) {
+ if (opterr) {
+ // 1003.2 specifies the format of this message.
+ Object[] msgArgs = {progname, new Character((char) c).toString()};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.requires2"), msgArgs));
+ }
- c = checkLongOption();
+ optopt = c;
+ if (optstring.charAt(0) == ':') {
+ return (':');
+ } else {
+ return ('?');
+ }
+ } else {
+ // We already incremented `optind' once;
+ // increment it again when taking next ARGV-elt as argument.
+ nextchar = argv[optind];
+ optarg = argv[optind];
+ }
- if (longopt_handled)
- return(c);
- else
- // Let the application handle it
- {
- nextchar = null;
- ++optind;
- return('W');
- }
- }
+ c = checkLongOption();
- if ((temp.length() > 1) && (temp.charAt(1) == ':'))
- {
- if ((temp.length() > 2) && (temp.charAt(2) == ':'))
- // This is an option that accepts and argument optionally
- {
- if (!nextchar.equals(""))
- {
- optarg = nextchar;
- ++optind;
- }
- else
+ if (longopt_handled) {
+ return (c);
+ } else // Let the application handle it
{
- optarg = null;
+ nextchar = null;
+ ++optind;
+ return ('W');
}
-
- nextchar = null;
}
- else
- {
- if (!nextchar.equals(""))
- {
- optarg = nextchar;
- ++optind;
- }
- else if (optind == argv.length)
+
+ if ((temp.length() > 1) && (temp.charAt(1) == ':')) {
+ if ((temp.length() > 2) && (temp.charAt(2) == ':')) // This is an option that accepts and argument optionally
{
- if (opterr)
- {
- // 1003.2 specifies the format of this message
- Object[] msgArgs = { progname, new
- Character((char)c).toString() };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.requires2"), msgArgs));
+ if (nextchar != null && !nextchar.isEmpty()) {
+ optarg = nextchar;
+ ++optind;
+ } else {
+ optarg = null;
}
- optopt = c;
-
- if (optstring.charAt(0) == ':')
- return(':');
- else
- return('?');
- }
- else
- {
- optarg = argv[optind];
- ++optind;
-
- // Ok, here's an obscure Posix case. If we have o:, and
- // we get -o -- foo, then we're supposed to skip the --,
- // end parsing of options, and make foo an operand to -o.
- // Only do this in Posix mode.
- if ((posixly_correct) && optarg.equals("--"))
- {
- // If end of argv, error out
- if (optind == argv.length)
- {
- if (opterr)
- {
- // 1003.2 specifies the format of this message
- Object[] msgArgs = { progname, new
- Character((char)c).toString() };
- System.err.println(MessageFormat.format(
- _messages.getString("getopt.requires2"), msgArgs));
- }
+ nextchar = null;
+ } else {
+ if (nextchar != null && !nextchar.isEmpty()) {
+ optarg = nextchar;
+ ++optind;
+ } else if (optind == argv.length) {
+ if (opterr) {
+ // 1003.2 specifies the format of this message
+ Object[] msgArgs = {progname, new Character((char) c).toString()};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.requires2"), msgArgs));
+ }
- optopt = c;
-
- if (optstring.charAt(0) == ':')
- return(':');
- else
- return('?');
+ optopt = c;
+
+ if (optstring.charAt(0) == ':') {
+ return (':');
+ } else {
+ return ('?');
}
+ } else {
+ optarg = argv[optind];
+ ++optind;
+
+ // Ok, here's an obscure Posix case. If we have o:, and
+ // we get -o -- foo, then we're supposed to skip the --,
+ // end parsing of options, and make foo an operand to -o.
+ // Only do this in Posix mode.
+ if ((posixly_correct) && "--".equals(optarg)) {
+ // If end of argv, error out
+ if (optind == argv.length) {
+ if (opterr) {
+ // 1003.2 specifies the format of this message
+ Object[] msgArgs = {progname, new Character((char) c).toString()};
+ throw new IllegalArgumentException(MessageFormat.format(
+ _messages.getString("getopt.requires2"), msgArgs));
+ }
+
+ optopt = c;
+
+ if (optstring.charAt(0) == ':') {
+ return (':');
+ } else {
+ return ('?');
+ }
+ }
- // Set new optarg and set to end
- // Don't permute as we do on -- up above since we
- // know we aren't in permute mode because of Posix.
- optarg = argv[optind];
- ++optind;
- first_nonopt = optind;
- last_nonopt = argv.length;
- endparse = true;
+ // Set new optarg and set to end
+ // Don't permute as we do on -- up above since we
+ // know we aren't in permute mode because of Posix.
+ optarg = argv[optind];
+ ++optind;
+ first_nonopt = optind;
+ last_nonopt = argv.length;
+ endparse = true;
+ }
}
- }
- nextchar = null;
+ nextchar = null;
+ }
}
- }
-
- return(c);
-}
+ return (c);
+ }
} // Class Getopt
diff --git a/gnu/getopt/GetoptDemo.class b/gnu/getopt/GetoptDemo.class
deleted file mode 100644
index 5182187..0000000
Binary files a/gnu/getopt/GetoptDemo.class and /dev/null differ
diff --git a/gnu/getopt/GetoptDemo.java b/gnu/getopt/GetoptDemo.java
index b57c5a8..59aef46 100644
--- a/gnu/getopt/GetoptDemo.java
+++ b/gnu/getopt/GetoptDemo.java
@@ -1,5 +1,4 @@
-import gnu.getopt.LongOpt;
-import gnu.getopt.Getopt;
+package gnu.getopt;
/*
* This sample code was written by Aaron M. Renn and is a demonstration
@@ -7,91 +6,84 @@
* sample code is hereby placed into the public domain by the author and
* may be used without restriction.
*/
+public class GetoptDemo {
-public class GetoptDemo
-{
-
-public static void
-main(String[] argv)
-{
- int c;
- String arg;
- LongOpt[] longopts = new LongOpt[3];
- //
- StringBuffer sb = new StringBuffer();
- longopts[0] = new LongOpt("help", LongOpt.NO_ARGUMENT, null, 'h');
- longopts[1] = new LongOpt("outputdir", LongOpt.REQUIRED_ARGUMENT, sb, 'o');
- longopts[2] = new LongOpt("maximum", LongOpt.OPTIONAL_ARGUMENT, null, 2);
- //
- Getopt g = new Getopt("testprog", argv, "-:bc::d:hW;", longopts);
- g.setOpterr(false); // We'll do our own error handling
- //
- while ((c = g.getopt()) != -1)
- switch (c)
- {
- case 0:
- arg = g.getOptarg();
- System.out.println("Got long option with value '" +
- (char)(new Integer(sb.toString())).intValue()
- + "' with argument " +
- ((arg != null) ? arg : "null"));
- break;
- //
- case 1:
- System.out.println("I see you have return in order set and that " +
- "a non-option argv element was just found " +
- "with the value '" + g.getOptarg() + "'");
- break;
- //
- case 2:
- arg = g.getOptarg();
- System.out.println("I know this, but pretend I didn't");
- System.out.println("We picked option " +
- longopts[g.getLongind()].getName() +
- " with value " +
- ((arg != null) ? arg : "null"));
- break;
- //
- case 'b':
- System.out.println("You picked plain old option " + (char)c);
- break;
- //
- case 'c':
- case 'd':
- arg = g.getOptarg();
- System.out.println("You picked option '" + (char)c +
- "' with argument " +
- ((arg != null) ? arg : "null"));
- break;
- //
- case 'h':
- System.out.println("I see you asked for help");
- break;
- //
- case 'W':
- System.out.println("Hmmm. You tried a -W with an incorrect long " +
- "option name");
- break;
- //
- case ':':
- System.out.println("Doh! You need an argument for option " +
- (char)g.getOptopt());
- break;
- //
- case '?':
- System.out.println("The option '" + (char)g.getOptopt() +
- "' is not valid");
- break;
- //
- default:
- System.out.println("getopt() returned " + c);
- break;
- }
- //
- for (int i = g.getOptind(); i < argv.length ; i++)
- System.out.println("Non option argv element: " + argv[i] + "\n");
-}
-
+ public static void main(String[] argv) {
+ int c;
+ String arg;
+ LongOpt[] longopts = new LongOpt[3];
+ //
+ StringBuffer sb = new StringBuffer();
+ longopts[0] = new LongOpt("help", LongOpt.NO_ARGUMENT, null, 'h');
+ longopts[1] = new LongOpt("outputdir", LongOpt.REQUIRED_ARGUMENT, sb, 'o');
+ longopts[2] = new LongOpt("maximum", LongOpt.OPTIONAL_ARGUMENT, null, 2);
+ //
+ Getopt g = new Getopt("testprog", argv, "-:bc::d:hW;", longopts);
+ g.setOpterr(false); // We'll do our own error handling
+ //
+ while ((c = g.getopt()) != -1) {
+ switch (c) {
+ case 0:
+ arg = g.getOptarg();
+ System.out.println("Got long option with value '" +
+ (char) (new Integer(sb.toString())).intValue() + "' with argument " +
+ ((arg != null) ? arg : "null"));
+ break;
+ //
+ case 1:
+ System.out.println("I see you have return in order set and that " +
+ "a non-option argv element was just found " +
+ "with the value '" + g.getOptarg() + "'");
+ break;
+ //
+ case 2:
+ arg = g.getOptarg();
+ System.out.println("I know this, but pretend I didn't");
+ System.out.println("We picked option " +
+ longopts[g.getLongind()].getName() +
+ " with value " +
+ ((arg != null) ? arg : "null"));
+ break;
+ //
+ case 'b':
+ System.out.println("You picked plain old option " + (char) c);
+ break;
+ //
+ case 'c':
+ case 'd':
+ arg = g.getOptarg();
+ System.out.println("You picked option '" + (char) c +
+ "' with argument " +
+ ((arg != null) ? arg : "null"));
+ break;
+ //
+ case 'h':
+ System.out.println("I see you asked for help");
+ break;
+ //
+ case 'W':
+ System.out.println("Hmmm. You tried a -W with an incorrect long " +
+ "option name");
+ break;
+ //
+ case ':':
+ System.out.println("Doh! You need an argument for option " +
+ (char) g.getOptopt());
+ break;
+ //
+ case '?':
+ System.out.println("The option '" + (char) g.getOptopt() +
+ "' is not valid");
+ break;
+ //
+ default:
+ System.out.println("getopt() returned " + c);
+ break;
+ }
+ }
+ //
+ for (int i = g.getOptind(); i < argv.length; i++) {
+ System.out.println("Non option argv element: " + argv[i] + "\n");
+ }
+ }
} // Class GetoptDemo
-
-
diff --git a/gnu/getopt/LongOpt.class b/gnu/getopt/LongOpt.class
deleted file mode 100644
index fb602e9..0000000
Binary files a/gnu/getopt/LongOpt.class and /dev/null differ
diff --git a/gnu/getopt/LongOpt.java b/gnu/getopt/LongOpt.java
index 6357085..65f7c08 100644
--- a/gnu/getopt/LongOpt.java
+++ b/gnu/getopt/LongOpt.java
@@ -18,7 +18,6 @@
/* the Free Software Foundation Inc., 59 Temple Place - Suite 330,
/* Boston, MA 02111-1307 USA
/**************************************************************************/
-
package gnu.getopt;
import java.util.Locale;
@@ -26,170 +25,141 @@
import java.text.MessageFormat;
/**************************************************************************/
-
-/**
- * This object represents the definition of a long option in the Java port
- * of GNU getopt. An array of LongOpt objects is passed to the Getopt
- * object to define the list of valid long options for a given parsing
- * session. Refer to the getopt documentation for details on the
- * format of long options.
- *
- * @version 1.0.5
- * @author Aaron M. Renn (arenn@urbanophile.com)
- *
- * @see Getopt
- */
-public class LongOpt extends Object
-{
-
-/**************************************************************************/
-
-/*
- * Class Variables
- */
-
-/**
- * Constant value used for the "has_arg" constructor argument. This
- * value indicates that the option takes no argument.
- */
-public static final int NO_ARGUMENT = 0;
-
-/**
- * Constant value used for the "has_arg" constructor argument. This
- * value indicates that the option takes an argument that is required.
- */
-public static final int REQUIRED_ARGUMENT = 1;
-
-/**
- * Constant value used for the "has_arg" constructor argument. This
- * value indicates that the option takes an argument that is optional.
- */
-public static final int OPTIONAL_ARGUMENT = 2;
-
-/**************************************************************************/
-
-/*
- * Instance Variables
- */
-
-/**
- * The name of the long option
- */
-protected String name;
-
-/**
- * Indicates whether the option has no argument, a required argument, or
- * an optional argument.
- */
-protected int has_arg;
-
-/**
- * If this variable is not null, then the value stored in "val" is stored
- * here when this long option is encountered. If this is null, the value
- * stored in "val" is treated as the name of an equivalent short option.
- */
-protected StringBuffer flag;
-
-/**
- * The value to store in "flag" if flag is not null, otherwise the
- * equivalent short option character for this long option.
- */
-protected int val;
-
/**
- * Localized strings for error messages
- */
-private ResourceBundle _messages = ResourceBundle.getBundle(
- "gnu/getopt/MessagesBundle", Locale.getDefault());
-
-/**************************************************************************/
-
-/*
- * Constructors
+ * This object represents the definition of a long option in the Java port
+ * of GNU getopt. An array of LongOpt objects is passed to the Getopt
+ * object to define the list of valid long options for a given parsing
+ * session. Refer to the getopt documentation for details on the
+ * format of long options.
+ *
+ * @version 1.0.5
+ * @author Aaron M. Renn (arenn@urbanophile.com)
+ *
+ * @see Getopt
*/
-
-/**
- * Create a new LongOpt object with the given parameter values. If the
- * value passed as has_arg is not valid, then an exception is thrown.
- *
- * @param name The long option String.
- * @param has_arg Indicates whether the option has no argument (NO_ARGUMENT), a required argument (REQUIRED_ARGUMENT) or an optional argument (OPTIONAL_ARGUMENT).
- * @param flag If non-null, this is a location to store the value of "val" when this option is encountered, otherwise "val" is treated as the equivalent short option character.
- * @param val The value to return for this long option, or the equivalent single letter option to emulate if flag is null.
- *
- * @exception IllegalArgumentException If the has_arg param is not one of NO_ARGUMENT, REQUIRED_ARGUMENT or OPTIONAL_ARGUMENT.
- */
-public
-LongOpt(String name, int has_arg,
- StringBuffer flag, int val) throws IllegalArgumentException
-{
- // Validate has_arg
- if ((has_arg != NO_ARGUMENT) && (has_arg != REQUIRED_ARGUMENT)
- && (has_arg != OPTIONAL_ARGUMENT))
- {
- Object[] msgArgs = { new Integer(has_arg).toString() };
- throw new IllegalArgumentException(MessageFormat.format(
+public class LongOpt extends Object {
+
+ /**************************************************************************/
+
+ /*
+ * Class Variables
+ */
+ /**
+ * Constant value used for the "has_arg" constructor argument. This
+ * value indicates that the option takes no argument.
+ */
+ public static final int NO_ARGUMENT = 0;
+ /**
+ * Constant value used for the "has_arg" constructor argument. This
+ * value indicates that the option takes an argument that is required.
+ */
+ public static final int REQUIRED_ARGUMENT = 1;
+ /**
+ * Constant value used for the "has_arg" constructor argument. This
+ * value indicates that the option takes an argument that is optional.
+ */
+ public static final int OPTIONAL_ARGUMENT = 2;
+ /**************************************************************************/
+
+ /*
+ * Instance Variables
+ */
+ /**
+ * The name of the long option
+ */
+ protected String name;
+ /**
+ * Indicates whether the option has no argument, a required argument, or
+ * an optional argument.
+ */
+ protected int has_arg;
+ /**
+ * If this variable is not null, then the value stored in "val" is stored
+ * here when this long option is encountered. If this is null, the value
+ * stored in "val" is treated as the name of an equivalent short option.
+ */
+ protected StringBuffer flag;
+ /**
+ * The value to store in "flag" if flag is not null, otherwise the
+ * equivalent short option character for this long option.
+ */
+ protected int val;
+ /**
+ * Localized strings for error messages
+ */
+ private ResourceBundle _messages = ResourceBundle.getBundle(
+ "gnu/getopt/MessagesBundle", Locale.getDefault());
+
+ /**************************************************************************/
+
+ /*
+ * Constructors
+ */
+ /**
+ * Create a new LongOpt object with the given parameter values. If the
+ * value passed as has_arg is not valid, then an exception is thrown.
+ *
+ * @param name The long option String.
+ * @param has_arg Indicates whether the option has no argument (NO_ARGUMENT), a required argument (REQUIRED_ARGUMENT) or an optional argument (OPTIONAL_ARGUMENT).
+ * @param flag If non-null, this is a location to store the value of "val" when this option is encountered, otherwise "val" is treated as the equivalent short option character.
+ * @param val The value to return for this long option, or the equivalent single letter option to emulate if flag is null.
+ *
+ * @exception IllegalArgumentException If the has_arg param is not one of NO_ARGUMENT, REQUIRED_ARGUMENT or OPTIONAL_ARGUMENT.
+ */
+ public LongOpt(String name, int has_arg,
+ StringBuffer flag, int val) throws IllegalArgumentException {
+ // Validate has_arg
+ if ((has_arg != NO_ARGUMENT) && (has_arg != REQUIRED_ARGUMENT) && (has_arg != OPTIONAL_ARGUMENT)) {
+ Object[] msgArgs = {new Integer(has_arg).toString()};
+ throw new IllegalArgumentException(MessageFormat.format(
_messages.getString("getopt.invalidValue"), msgArgs));
- }
-
- // Store off values
- this.name = name;
- this.has_arg = has_arg;
- this.flag = flag;
- this.val = val;
-}
-
-/**************************************************************************/
-
-/**
- * Returns the name of this LongOpt as a String
- *
- * @return Then name of the long option
- */
-public String
-getName()
-{
- return(name);
-}
+ }
-/**************************************************************************/
-
-/**
- * Returns the value set for the 'has_arg' field for this long option
- *
- * @return The value of 'has_arg'
- */
-public int
-getHasArg()
-{
- return(has_arg);
-}
-
-/**************************************************************************/
+ // Store off values
+ this.name = name;
+ this.has_arg = has_arg;
+ this.flag = flag;
+ this.val = val;
+ }
-/**
- * Returns the value of the 'flag' field for this long option
- *
- * @return The value of 'flag'
- */
-public StringBuffer
-getFlag()
-{
- return(flag);
-}
+ /**************************************************************************/
+ /**
+ * Returns the name of this LongOpt as a String
+ *
+ * @return Then name of the long option
+ */
+ public String getName() {
+ return (name);
+ }
-/**
- * Returns the value of the 'val' field for this long option
- *
- * @return The value of 'val'
- */
-public int
-getVal()
-{
- return(val);
-}
+ /**************************************************************************/
+ /**
+ * Returns the value set for the 'has_arg' field for this long option
+ *
+ * @return The value of 'has_arg'
+ */
+ public int getHasArg() {
+ return (has_arg);
+ }
-/**************************************************************************/
+ /**************************************************************************/
+ /**
+ * Returns the value of the 'flag' field for this long option
+ *
+ * @return The value of 'flag'
+ */
+ public StringBuffer getFlag() {
+ return (flag);
+ }
+ /**
+ * Returns the value of the 'val' field for this long option
+ *
+ * @return The value of 'val'
+ */
+ public int getVal() {
+ return (val);
+ }
+ /**************************************************************************/
} // Class LongOpt
diff --git a/gnu/getopt/README b/gnu/getopt/README
index 48451f7..04ae7d4 100644
--- a/gnu/getopt/README
+++ b/gnu/getopt/README
@@ -55,3 +55,28 @@ Aaron.
arenn@urbanophile.com
http://www.urbanophile.com/arenn/
+If you are using version 1.0.15 which includes the removal of System.err.println error
+messages which are now replaced by throw new IllegalArgumentException therefore allowing
+to use this library more easily in your code deciding on your own what you do with thrown
+exceptions you will also beneficiate from Maven build facility.
+
+To build the jar type:
+mvn clean ; mvn package
+
+You an then use the jar produced under target/java-getopt-1.0.15.jar
+
+The other changes I made are both cosmetic (code formating) and also try to comply
+with some Java coding best practices like using "constant".compare(object_string) instead
+of object_string.compare("constant") and isEmpty() rather than .length() == 0
+
+Of course you can ask me to integrate any thing you see fit/missing and depending on
+what my sparetime allows me I'll be more than happy to try to comply to your needs.
+Feel free also to use
+https://github.com/obourdon/java-getopt/issues
+to log any issue you would like to be addressed
+
+Thanks for everything
+
+Olivier
+olivier.bourdon@freesbee.fr
+https://github.com/obourdon/java-getopt
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..41c6a5e
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,41 @@
+
+