diff --git a/.tx/config b/.tx/config index abb8a7a04..5e5a922e6 100644 --- a/.tx/config +++ b/.tx/config @@ -238,6 +238,23 @@ trans.ru_RU = installer/resources/locale/po/messages_ru.po trans.tr_TR = installer/resources/locale/po/messages_tr.po trans.zh_CN = installer/resources/locale/po/messages_zh.po +[I2P.getopt] +source_file = core/java/src/gnu/getopt/MessagesBundle.properties +source_lang = en +type = UNICODEPROPERTIES +trans.cs = core/java/src/gnu/getopt/MessagesBundle_cs.properties +trans.de = core/java/src/gnu/getopt/MessagesBundle_de.properties +trans.es = core/java/src/gnu/getopt/MessagesBundle_es.properties +trans.fr = core/java/src/gnu/getopt/MessagesBundle_fr.properties +trans.hu = core/java/src/gnu/getopt/MessagesBundle_hu.properties +trans.it = core/java/src/gnu/getopt/MessagesBundle_it.properties +trans.ja = core/java/src/gnu/getopt/MessagesBundle_ha.properties +trans.nl = core/java/src/gnu/getopt/MessagesBundle_nl.properties +trans.nb = core/java/src/gnu/getopt/MessagesBundle_nb.properties +trans.pl = core/java/src/gnu/getopt/MessagesBundle_pl.properties +trans.ro = core/java/src/gnu/getopt/MessagesBundle_ro.properties +trans.zh_CN = core/java/src/gnu/getopt/MessagesBundle_zh.properties + [main] host = https://www.transifex.com diff --git a/LICENSE.txt b/LICENSE.txt index 00397d1f2..5882f38bd 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -76,6 +76,11 @@ Public domain except as listed below: Copyright 2012 Hiroshi Nakamura See licenses/LICENSE-Apache2.0.txt + Getopt: + Copyright (c) 1998 by Aaron M. Renn (arenn@urbanophile.com) + See licenses/LICENSE-LGPLv2.1.txt + + Router (router.jar): Public domain except as listed below: UPnP.java: diff --git a/build.xml b/build.xml index 81cfe97c8..82f7375ed 100644 --- a/build.xml +++ b/build.xml @@ -467,8 +467,8 @@ splitindex="true" doctitle="I2P Javadocs for Release ${release.number} Build ${i2p.build.number}${build.extra}" windowtitle="I2P Anonymous Network - Java Documentation - Version ${release.number}"> - - + + diff --git a/core/java/build.xml b/core/java/build.xml index 814064343..0d3f10dec 100644 --- a/core/java/build.xml +++ b/core/java/build.xml @@ -46,7 +46,10 @@ - + + + + diff --git a/core/java/src/gnu/getopt/Getopt.java b/core/java/src/gnu/getopt/Getopt.java new file mode 100644 index 000000000..429301be5 --- /dev/null +++ b/core/java/src/gnu/getopt/Getopt.java @@ -0,0 +1,1337 @@ +/************************************************************************** +/* Getopt.java -- Java port of GNU getopt from glibc 2.0.6 +/* +/* Copyright (c) 1987-1997 Free Software Foundation, Inc. +/* Java Port Copyright (c) 1998 by Aaron M. Renn (arenn@urbanophile.com) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +package gnu.getopt; + +import java.util.Locale; +import java.util.ResourceBundle; +import java.text.MessageFormat; + +/**************************************************************************/ + +/** + * 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); +} + +/**************************************************************************/ + +/** + * 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.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); + } + + // 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 + } +} + +/**************************************************************************/ + +/* + * 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.length() == 0) + optstring = " "; + + this.optstring = optstring; +} + +/**************************************************************************/ + +/** + * 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); +} + +/**************************************************************************/ + +/** + * 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; +} + +/**************************************************************************/ + +/** + * 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; +} + +/**************************************************************************/ + +/** + * 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); +} + +/**************************************************************************/ + +/** + * 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; +} + +/**************************************************************************/ + +/** + * 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); +} + +/**************************************************************************/ + +/** + * Returns the index into the array of long options (NOT argv) representing + * the long option that was found. + */ +public int +getLongind() +{ + return(longind); +} + +/**************************************************************************/ + +/** + * 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; + } + } + + // Update records for the slots the non-options now occupy. + + first_nonopt += (optind - last_nonopt); + last_nonopt = optind; +} + +/**************************************************************************/ + +/** + * 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)); + } + + 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 = ""; + } + 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)); + } + } + + 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); +} + +/**************************************************************************/ + +/** + * 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++; + } + + last_nonopt = optind; + } + + // 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); + } + + // 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); + } + + // 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( + _messages.getString("getopt.illegal"), msgArgs)); + } + else + { + Object[] msgArgs = { progname, new + Character((char)c).toString() }; + System.err.println(MessageFormat.format( + _messages.getString("getopt.invalid"), msgArgs)); + } + } + + 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; + } + // 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]; + } + + c = checkLongOption(); + + if (longopt_handled) + return(c); + else + // Let the application handle it + { + nextchar = null; + ++optind; + return('W'); + } + } + + 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 + { + optarg = null; + } + + nextchar = null; + } + else + { + if (!nextchar.equals("")) + { + 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() }; + System.err.println(MessageFormat.format( + _messages.getString("getopt.requires2"), msgArgs)); + } + + 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)); + } + + 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; + } + } + + nextchar = null; + } + } + + return(c); +} + +} // Class Getopt + + diff --git a/core/java/src/gnu/getopt/LongOpt.java b/core/java/src/gnu/getopt/LongOpt.java new file mode 100644 index 000000000..6357085fe --- /dev/null +++ b/core/java/src/gnu/getopt/LongOpt.java @@ -0,0 +1,195 @@ +/************************************************************************** +/* LongOpt.java -- Long option object for Getopt +/* +/* Copyright (c) 1998 by Aaron M. Renn (arenn@urbanophile.com) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +package gnu.getopt; + +import java.util.Locale; +import java.util.ResourceBundle; +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 + */ + +/** + * 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); +} + +/**************************************************************************/ + +/** + * 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/core/java/src/gnu/getopt/MessagesBundle.properties b/core/java/src/gnu/getopt/MessagesBundle.properties new file mode 100644 index 000000000..9356ee13e --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle.properties @@ -0,0 +1,33 @@ +/************************************************************************** +/* MessagesBundle.properties -- English language error messages +/* +/* Copyright (c) 1998 by William King (wrking@eng.sun.com) and +/* Aaron M. Renn (arenn@urbanophile.com) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: option ''{1}'' is ambiguous +getopt.arguments1={0}: option ''--{1}'' doesn't allow an argument +getopt.arguments2={0}: option ''{1}{2}'' doesn't allow an argument +getopt.requires={0}: option ''{1}'' requires an argument +getopt.unrecognized={0}: unrecognized option ''--{1}'' +getopt.unrecognized2={0}: unrecognized option ''{1}{2}'' +getopt.illegal={0}: illegal option -- {1} +getopt.invalid={0}: invalid option -- {1} +getopt.requires2={0}: option requires an argument -- {1} +getopt.invalidValue=Invalid value {0} for parameter 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_cs.properties b/core/java/src/gnu/getopt/MessagesBundle_cs.properties new file mode 100644 index 000000000..3c14a03ce --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_cs.properties @@ -0,0 +1,33 @@ +/************************************************************************** +/* MessagesBundle_cs.properties -- Czech language error messages +/* +/* Czech Messages Copyright (c) 1998 by Roman Szturc (Roman.Szturc@vsb.cz) +/* These messages are encoded in ISO-8859-2 +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: volba ''{1}'' je nejednoznaèná +getopt.arguments1={0}: volba ''--{1}'' nepøipou¹tí argument +getopt.arguments2={0}: volba ''{1}{2}'' nepøipou¹tí argument +getopt.requires={0}: volba ''{1}'' vy¾aduje argument +getopt.unrecognized={0}: nepøípustná volba ''--{1}'' +getopt.unrecognized2={0}: nepøípustná volba ''{1}{2}'' +getopt.illegal={0}: nepøípustná volba -- {1} +getopt.invalid={0}: neplatná volba -- {1} +getopt.requires2={0}: volba vy¾aduje argument -- {1} +getopt.invalidValue=Neplatná hodnota {0} parameteru 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_de.properties b/core/java/src/gnu/getopt/MessagesBundle_de.properties new file mode 100644 index 000000000..f74138684 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_de.properties @@ -0,0 +1,33 @@ +/************************************************************************** +/* MessagesBundle.properties -- German language error messages +/* +/* German Messages Copyright (c) 1999 by Bernhard Bablok (bablokb@gmx.net) +/* These messages are encoded in ISO-8859-1 +//* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: Option ''{1}'' ist zweideutig +getopt.arguments1={0}: Option ''--{1}'' erlaubt kein Argument +getopt.arguments2={0}: Option ''{1}{2}'' erlaubt kein Argument +getopt.requires={0}: Option ''{1}'' benötigt ein Argument +getopt.unrecognized={0}: Unbekannte Option ''--{1}'' +getopt.unrecognized2={0}: Unbekannte Option ''{1}{2}'' +getopt.illegal={0}: Verbotene Option -- {1} +getopt.invalid={0}: Ungültige Option -- {1} +getopt.requires2={0}: Option benötigt ein Argument -- {1} +getopt.invalidValue=Ungültiger Wert {0} für Parameter 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_es.properties b/core/java/src/gnu/getopt/MessagesBundle_es.properties new file mode 100644 index 000000000..ef358f474 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_es.properties @@ -0,0 +1,33 @@ +/************************************************************************** +/* MessagesBundle_es.properties -- Spanish language error messages +/* +/* Spanish Messages Copyright (c) 2004 by Daniel Pérez (dondani@gmail.com) +/* These messages are encoded in ISO-8859-1 +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: la opción ''{1}'' es ambigua +getopt.arguments1={0}: la opción ''--{1}'' no permite un argumento +getopt.arguments2={0}: la opción ''{1}{2}'' no permite un argumento +getopt.requires={0}: la opción ''{1}'' requiere un argumento +getopt.unrecognized={0}: opción no reconocida ''--{1}'' +getopt.unrecognized2={0}: opción no reconocida ''{1}{2}'' +getopt.illegal={0}: opción ilegal -- {1} +getopt.invalid={0}: opción no válida -- {1} +getopt.requires2={0}: la opción requiere un argumento -- {1} +getopt.invalidValue=Valor no válido {0} para el parámetro 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_fr.properties b/core/java/src/gnu/getopt/MessagesBundle_fr.properties new file mode 100644 index 000000000..400447c49 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_fr.properties @@ -0,0 +1,35 @@ +/************************************************************************** +/* MessagesBundle_fr.properties -- French language error messages +/* +/* Copyright (c) 1999 Free Software Foundation, Inc. +/* Michel Robitaille , 1996, +/* Edouard G. Parmelan , 1999. +/* These messages are encoded in ISO-8859-1 +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: l'option ''{1}'' est ambiguë +getopt.arguments1={0}: l'option ''--{1}'' ne permet pas de paramètre +getopt.arguments2={0}: l'option ''{1}{2}'' ne permet pas de paramètre +getopt.requires={0}: l'option ''{1}'' requiert un paramètre +getopt.unrecognized={0}: option non reconnue ''--{1}'' +getopt.unrecognized2={0}: option non reconnue ''{1}{2}'' +getopt.illegal={0}: option illégale -- {1} +getopt.invalid={0}: option invalide -- {1} +getopt.requires2={0}: cette option requiert un paramètre -- {1} +getopt.invalidValue=Valeur invalide {0} pour le paramètre 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_hu.properties b/core/java/src/gnu/getopt/MessagesBundle_hu.properties new file mode 100644 index 000000000..f7af03b6e --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_hu.properties @@ -0,0 +1,32 @@ +/************************************************************************** +/* MessagesBundle.properties -- Hungarian language error messages +/* +/* Copyright (c) 2001 by Gyula Csom (csom@informix.hu) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: opció ''{1}'' félreérthetõ +getopt.arguments1={0}: opció ''--{1}'' nem enged meg argumentumot +getopt.arguments2={0}: opció ''{1}{2}'' nem enged meg argumentumot +getopt.requires={0}: opció ''{1}'' argumentumot igényel +getopt.unrecognized={0}: ismeretlen opció ''--{1}'' +getopt.unrecognized2={0}: ismeretlen opció ''{1}{2}'' +getopt.illegal={0}: illegális opció -- {1} +getopt.invalid={0}: érvénytelen opció -- {1} +getopt.requires2={0}: az opció argumentumot igényel -- {1} +getopt.invalidValue=Érvénytelen érték {0} a következõ paraméterhez 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_it.properties b/core/java/src/gnu/getopt/MessagesBundle_it.properties new file mode 100644 index 000000000..c596c26a0 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_it.properties @@ -0,0 +1,32 @@ +/************************************************************************** +/* MessagesBundle.properties -- Italian language error messages +/* +/* Copyright (c) 2005 by Sandro Tosi (matrixhasu@gmail.com) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: l'opzione ''{1}'' è ambigua +getopt.arguments1={0}: l'opzione ''--{1}'' non ammette un argomento +getopt.arguments2={0}: l'opzione ''{1}{2}'' non ammette un argomento +getopt.requires={0}: l'opzione ''{1}'' richiede un argomento +getopt.unrecognized={0}: opzione non riconosciuta ''--{1}'' +getopt.unrecognized2={0}: opzione non riconosciuta ''{1}{2}'' +getopt.illegal={0}: opzione illegale -- {1} +getopt.invalid={0}: opzione invalida -- {1} +getopt.requires2={0}: l'opzione richiede un argomento -- {1} +getopt.invalidValue=Valore non valido {0} per il parametro 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_ja.properties b/core/java/src/gnu/getopt/MessagesBundle_ja.properties new file mode 100644 index 000000000..557897299 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_ja.properties @@ -0,0 +1,32 @@ +/************************************************************************** +/* MessagesBundle.properties -- Japanese language error messages +/* +/* Copyright (c) 2001 by Yasuoka Masahiko (yasuoka@yasuoka.net) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: ''{1}'' \u30aa\u30d7\u30b7\u30e7\u30f3\u306f\u66d6\u6627\u3067\u3059\u3002 +getopt.arguments1={0}: ''--{1}'' \u30aa\u30d7\u30b7\u30e7\u30f3\u306f\u30d1\u30e9\u30e1\u30fc\u30bf\u3092\u3082\u3061\u307e\u305b\u3093\u3002 +getopt.arguments2={0}: ''{1}{2}'' \u30aa\u30d7\u30b7\u30e7\u30f3\u306f\u30d1\u30e9\u30e1\u30fc\u30bf\u3092\u3082\u3061\u307e\u305b\u3093\u3002 +getopt.requires={0}: ''{1}'' \u30aa\u30d7\u30b7\u30e7\u30f3\u306b\u306f\u30d1\u30e9\u30e1\u30fc\u30bf\u304c\u5fc5\u8981\u3067\u3059\u3002 +getopt.unrecognized={0}: ''--{1}'' \u306f\u7121\u52b9\u306a\u30aa\u30d7\u30b7\u30e7\u30f3\u3067\u3059\u3002 +getopt.unrecognized2={0}: ''{1}{2}'' \u306f\u7121\u52b9\u306a\u30aa\u30d7\u30b7\u30e7\u30f3\u3067\u3059\u3002 +getopt.illegal={0}: -- {1} \u306f\u4e0d\u6b63\u306a\u30aa\u30d7\u30b7\u30e7\u30f3\u3067\u3059\u3002 +getopt.invalid={0}: -- {1} \u30aa\u30d7\u30b7\u30e7\u30f3\u306f\u6b63\u3057\u304f\u3042\u308a\u307e\u305b\u3093\u3002 +getopt.requires2={0}: -- {1} \u30aa\u30d7\u30b7\u30e7\u30f3\u306b\u306f\u30d1\u30e9\u30e1\u30fc\u30bf\u304c\u5fc5\u8981\u3067\u3059\u3002 +getopt.invalidValue={0} \u306f\u3001'has_arg' \u30d1\u30e9\u30e1\u30fc\u30bf\u3068\u3057\u3066\u4e0d\u6b63\u306a\u5024\u3067\u3059\u3002 + diff --git a/core/java/src/gnu/getopt/MessagesBundle_nb.properties b/core/java/src/gnu/getopt/MessagesBundle_nb.properties new file mode 100644 index 000000000..bcb8c5022 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_nb.properties @@ -0,0 +1,32 @@ +/************************************************************************** +/* MessagesBundle.properties -- Norwegian language error messages +/* +/* Copyright (c) 1999 by Bjørn-Ove Heimsund (s811@ii.uib.no) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: flagget ''{1}'' er flertydig +getopt.arguments1={0}: flagget ''--{1}'' tillater ikke et argument +getopt.arguments2={0}: flagget ''{1}{2}'' tillater ikke et argument +getopt.requires={0}: flagget ''{1}'' krever et argument +getopt.unrecognized={0}: ukjent flagg ''--{1}'' +getopt.unrecognized2={0}: ukjent flagg ''{1}{2}'' +getopt.illegal={0}: ugyldig flagg -- {1} +getopt.invalid={0}: ugyldig flagg -- {1} +getopt.requires2={0}: flagget krever et argument -- {1} +getopt.invalidValue=Ugyldig verdi {0} for parameter 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_nl.properties b/core/java/src/gnu/getopt/MessagesBundle_nl.properties new file mode 100644 index 000000000..c6149227d --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_nl.properties @@ -0,0 +1,32 @@ +/************************************************************************** +/* MessagesBundle_nl.properties -- Dutch language error messages +/* +/* Copyright (c) 1999 by Ernst de Haan (ernst@jollem.com) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: optie ''{1}'' is ambigue +getopt.arguments1={0}: optie ''--{1}'' staat geen argumenten toe +getopt.arguments2={0}: optie ''{1}{2}'' staat geen argumenten toe +getopt.requires={0}: optie ''{1}'' heeft een argument nodig +getopt.unrecognized={0}: onbekende optie ''--{1}'' +getopt.unrecognized2={0}: onbekende optie ''{1}{2}'' +getopt.illegal={0}: niet-toegestane optie -- {1} +getopt.invalid={0}: onjuiste optie -- {1} +getopt.requires2={0}: optie heeft een argument nodig -- {1} +getopt.invalidValue=Ongeldige waarde {0} voor parameter 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_pl.properties b/core/java/src/gnu/getopt/MessagesBundle_pl.properties new file mode 100644 index 000000000..95808535f --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_pl.properties @@ -0,0 +1,36 @@ +/************************************************************************** +/* MessagesBundle_pl.properties -- Polish language error messages +/* +/* Polish Messages Copyright (c) 2006 by Krzysztof Szyma?ski (sirch.s@gmail.com) +/* These messages are encoded in ISO-8859-2 +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + + +getopt.ambigious={0}: opcja ''{1}''jest wieloznaczna +getopt.arguments1={0}: opcja ''--{1}'' nie akceptuje argumentu +getopt.arguments2={0}: opcja ''{1}{2}'' nie akceptuje argumentu +getopt.requires={0}: opcja ''{1}'' wymaga argumentu +getopt.unrecognized={0}: nierozpoznana opcja ''--{1}'' +getopt.unrecognized2={0}: nierozpoznana opcja ''{1}{2}'' +getopt.illegal={0}: nie dopuszczalna opcja --{1} +getopt.invalid={0}: b??dna opcja --{1} +getopt.requires2={0}: opcja --{1} oczekuje argumentu +getopt.invalidValue=Nie poprawna warto?? {0} argument 'has_arg' + + + diff --git a/core/java/src/gnu/getopt/MessagesBundle_ro.properties b/core/java/src/gnu/getopt/MessagesBundle_ro.properties new file mode 100644 index 000000000..3c0b08b37 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_ro.properties @@ -0,0 +1,34 @@ +/************************************************************************** +/* MessagesBundle_fr.properties -- Romanian language error messages +/* +/* Copyright (c) 1999 Free Software Foundation, Inc. +/* Marian-Nicolae Ion , 2004, +/* These messages are encoded in ISO-8859-2 +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your optiunea) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: opÅ£iunea ''{1}'' este ambiguă +getopt.arguments1={0}: opÅ£iunea ''--{1}'' nu acceptă parametru +getopt.arguments2={0}: opÅ£iunea ''{1}{2}'' nu acceptă parametru +getopt.requires={0}: opÅ£iunea ''{1}'' cere un parametru +getopt.unrecognized={0}: opÅ£iune necunoscută ''--{1}'' +getopt.unrecognized2={0}: opÅ£iune necunoscută ''{1}{2}'' +getopt.illegal={0}: opÅ£iune ilegală -- {1} +getopt.invalid={0}: opÅ£iune invalidă -- {1} +getopt.requires2={0}: această opÅ£iune cere un parametru -- {1} +getopt.invalidValue=Valoare invalidă {0} pentru parametrul 'has_arg' + diff --git a/core/java/src/gnu/getopt/MessagesBundle_zh.properties b/core/java/src/gnu/getopt/MessagesBundle_zh.properties new file mode 100644 index 000000000..1090dc6d5 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_zh.properties @@ -0,0 +1,33 @@ +/************************************************************************** +/* MessagesBundle.properties ¨CSimple Chinese language error messages +/* +/* Copyright (c) 2012 by David Zhang (david290@qq.com) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: Ñ¡Ïî ''{1}'' ÓÐÆçÒå +getopt.arguments1={0}:Ñ¡Ïî''--{1}'' ²»ÄÜ´ø²ÎÊý +getopt.arguments2={0}:Ñ¡Ïî''{1}{2}''²»ÄÜ´ø²ÎÊý +getopt.requires={0}: Ñ¡Ïî ''{1}'' ÒªÇó´øÓвÎÊý +getopt.unrecognized={0}: ÎÞ·¨Ê¶±ðµÄÑ¡Ïî ''--{1}'' +getopt.unrecognized2={0}:ÎÞ·¨Ê¶±ðµÄÑ¡Ïî''{1}{2}'' +getopt.illegal={0}: ·Ç·¨Ñ¡Ïî -- {1} +getopt.invalid={0}: ÎÞЧѡÏî -- {1} +getopt.requires2={0}:Ñ¡ÏîÐèÒªÓвÎÊý -- {1} +getopt.invalidValue=Ñ¡Ïî 'has_arg'µÄÖµ {0} ·Ç·¨ + + diff --git a/core/java/src/gnu/getopt/MessagesBundle_zh_TW.properties b/core/java/src/gnu/getopt/MessagesBundle_zh_TW.properties new file mode 100644 index 000000000..270e4f1b8 --- /dev/null +++ b/core/java/src/gnu/getopt/MessagesBundle_zh_TW.properties @@ -0,0 +1,33 @@ +/************************************************************************** +/* MessagesBundle.properties - Triditional Chinese language error messages +/* +/* Copyright (c) 2012 by David Zhang (david290@qq.com) +/* +/* This program is free software; you can redistribute it and/or modify +/* it under the terms of the GNU Library General Public License as published +/* by the Free Software Foundation; either version 2 of the License or +/* (at your option) any later version. +/* +/* This program is distributed in the hope that it will be useful, but +/* WITHOUT ANY WARRANTY; without even the implied warranty of +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +/* GNU Library General Public License for more details. +/* +/* You should have received a copy of the GNU Library General Public License +/* along with this program; see the file COPYING.LIB. If not, write to +/* the Free Software Foundation Inc., 59 Temple Place - Suite 330, +/* Boston, MA 02111-1307 USA +/**************************************************************************/ + +getopt.ambigious={0}: é¸é … ''{1}'' 有歧義 +getopt.arguments1={0}:é¸é …''--{1}'' ä¸èƒ½å¸¶åƒæ•¸ +getopt.arguments2={0}:é¸é …''{1}{2}''ä¸èƒ½å¸¶åƒæ•¸ +getopt.requires={0}: é¸é … ''{1}'' è¦æ±‚帶有åƒæ•¸ +getopt.unrecognized={0}: 無法識別的é¸é … ''--{1}'' +getopt.unrecognized2={0}:無法識別的é¸é …''{1}{2}'' +getopt.illegal={0}: éžæ³•é¸é … -- {1} +getopt.invalid={0}: 無效é¸é … -- {1} +getopt.requires2={0}:é¸é …需è¦æœ‰åƒæ•¸ -- {1} +getopt.invalidValue=é¸é … 'has_arg'的值 {0} éžæ³• + + diff --git a/core/java/src/gnu/getopt/package.html b/core/java/src/gnu/getopt/package.html new file mode 100644 index 000000000..4f7b81adc --- /dev/null +++ b/core/java/src/gnu/getopt/package.html @@ -0,0 +1,25 @@ + +

+This is Java getopt 1.0.14 (released 2012/02/08) +

+Added in I2P 0.9.12. +Source was retrieved from here. +Previous version 1.0.13 (released 2006/08/29) +is available here. +

+Copyright (c) 1998 by Aaron M. Renn (arenn@urbanophile.com), +LGPL v2. +

+Changes: +

  • +Simplified Chinese +MessagesBundle_chs.properties renamed to MessagesBundle_zh.properties +
  • +Traditional Chinese +MessagesBundle_cht.properties renamed to MessagesBundle_zh_TW.properties +
  • +Norwegian Bokmaal +MessagesBundle_no.properties renamed to MessagesBundle_nb.properties +
+

+