PatchSet 5010 
Date: 2004/07/25 06:46:41
Author: guilhem
Branch: HEAD
Tag: (none) 
Log:
Merged GNU Getopt as it is needed by GNU Crypto.

        * libraries/javalib/gnu/getopt/MessagesBundle_de.properties,
        libraries/javalib/gnu/getopt/MessagesBundle_ja.properties,
        libraries/javalib/gnu/getopt/MessagesBundle_hu.properties,
        libraries/javalib/gnu/getopt/MessagesBundle_nl.properties,
        libraries/javalib/gnu/getopt/MessagesBundle_fr.properties,
        libraries/javalib/gnu/getopt/MessagesBundle_no.properties,
        libraries/javalib/gnu/getopt/MessagesBundle_cs.properties,
        libraries/javalib/gnu/getopt/MessagesBundle.properties,
        libraries/javalib/gnu/getopt/Getopt.java,
        libraries/javalib/gnu/getopt/LongOpt.java: Merged GNU Getopt
        as it is needed by GNU Crypto.

        * libraries/javalib/Makefile.am.in
        (gnu_getopt_message_bundles): New variable.
        (EXTRA_DIST): Added gnu_getopt_message_bundles.
        (JAR_CMD6): New variable.
        (rt.jar): Added JAR_CMD6.

        * libraries/javalib/all.files: Added GNU Getopt classes.

        * libraries/javalib/Makefile.am, libraries/javalib/Makefile.in:
        Regenerated.

Members: 
        ChangeLog:1.2569->1.2570 
        libraries/javalib/Makefile.am:1.205->1.206 
        libraries/javalib/Makefile.am.in:1.16->1.17 
        libraries/javalib/Makefile.in:1.281->1.282 
        libraries/javalib/all.files:1.5->1.6 
        libraries/javalib/gnu/getopt/Getopt.java:INITIAL->1.1 
        libraries/javalib/gnu/getopt/LongOpt.java:INITIAL->1.1 
        libraries/javalib/gnu/getopt/MessagesBundle.properties:INITIAL->1.1 
        libraries/javalib/gnu/getopt/MessagesBundle_cs.properties:INITIAL->1.1 
        libraries/javalib/gnu/getopt/MessagesBundle_de.properties:INITIAL->1.1 
        libraries/javalib/gnu/getopt/MessagesBundle_fr.properties:INITIAL->1.1 
        libraries/javalib/gnu/getopt/MessagesBundle_hu.properties:INITIAL->1.1 
        libraries/javalib/gnu/getopt/MessagesBundle_ja.properties:INITIAL->1.1 
        libraries/javalib/gnu/getopt/MessagesBundle_nl.properties:INITIAL->1.1 
        libraries/javalib/gnu/getopt/MessagesBundle_no.properties:INITIAL->1.1 

Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.2569 kaffe/ChangeLog:1.2570
--- kaffe/ChangeLog:1.2569      Sun Jul 25 06:37:12 2004
+++ kaffe/ChangeLog     Sun Jul 25 06:46:41 2004
@@ -1,3 +1,28 @@
+2004-07-24  Guilhem Lavaux <[EMAIL PROTECTED]>
+
+       * libraries/javalib/gnu/getopt/MessagesBundle_de.properties,
+       libraries/javalib/gnu/getopt/MessagesBundle_ja.properties,
+       libraries/javalib/gnu/getopt/MessagesBundle_hu.properties,
+       libraries/javalib/gnu/getopt/MessagesBundle_nl.properties,
+       libraries/javalib/gnu/getopt/MessagesBundle_fr.properties,
+       libraries/javalib/gnu/getopt/MessagesBundle_no.properties,
+       libraries/javalib/gnu/getopt/MessagesBundle_cs.properties,
+       libraries/javalib/gnu/getopt/MessagesBundle.properties,
+       libraries/javalib/gnu/getopt/Getopt.java,
+       libraries/javalib/gnu/getopt/LongOpt.java: Merged GNU Getopt
+       as it is needed by GNU Crypto.
+
+       * libraries/javalib/Makefile.am.in
+       (gnu_getopt_message_bundles): New variable.
+       (EXTRA_DIST): Added gnu_getopt_message_bundles.
+       (JAR_CMD6): New variable.
+       (rt.jar): Added JAR_CMD6.
+
+       * libraries/javalib/all.files: Added GNU Getopt classes.
+
+       * libraries/javalib/Makefile.am, libraries/javalib/Makefile.in:
+       Regenerated.
+
 2004-07-24  Mark Wielaard <[EMAIL PROTECTED]>
 
        2004-07-21  Michael Koch  <[EMAIL PROTECTED]>
Index: kaffe/libraries/javalib/Makefile.am
diff -u kaffe/libraries/javalib/Makefile.am:1.205 
kaffe/libraries/javalib/Makefile.am:1.206
--- kaffe/libraries/javalib/Makefile.am:1.205   Sun Jul 25 06:37:35 2004
+++ kaffe/libraries/javalib/Makefile.am Sun Jul 25 06:46:42 2004
@@ -88,6 +88,7 @@
        $(gnu_crypto_tool_SRCS) \
        $(gnu_crypto_tool_keytool_SRCS) \
        $(gnu_crypto_util_SRCS) \
+       $(gnu_getopt_SRCS) \
        $(gnu_inet_ftp_SRCS) \
        $(gnu_inet_util_SRCS) \
        $(gnu_java_awt_SRCS) \
@@ -755,6 +756,9 @@
        gnu/crypto/util/Sequence.java \
        gnu/crypto/util/SimpleList.java \
        gnu/crypto/util/Util.java
+gnu_getopt_SRCS = \
+       gnu/getopt/Getopt.java \
+       gnu/getopt/LongOpt.java
 gnu_inet_ftp_SRCS = \
        gnu/inet/ftp/ActiveModeDTP.java \
        gnu/inet/ftp/BlockInputStream.java \
@@ -4084,6 +4088,16 @@
        gnu/java/locale/iso639_ga.properties \
        gnu/java/locale/iso639.properties
 
+gnu_getopt_message_bundles = \
+       gnu/getopt/MessagesBundle_cs.properties \
+               gnu/getopt/MessagesBundle_ja.properties \
+       gnu/getopt/MessagesBundle_de.properties \
+               gnu/getopt/MessagesBundle_nl.properties \
+       gnu/getopt/MessagesBundle_fr.properties \
+               gnu/getopt/MessagesBundle_no.properties \
+       gnu/getopt/MessagesBundle_hu.properties \
+               gnu/getopt/MessagesBundle.properties
+
 EXTRA_DIST = \
        Makefile.am.in \
        Klasses.jar.bootstrap \
@@ -4101,7 +4115,8 @@
        $(OMITTED_PACKAGES_SRCS) \
        $(serialized_converters) \
        $(gnu_regexp_message_bundles) \
-       $(gnu_java_locale_bundles)
+       $(gnu_java_locale_bundles) \
+       $(gnu_getopt_message_bundles)
 
 dist-hook:
        rm -rf `find $(distdir) -name CVS`
@@ -4146,12 +4161,14 @@
 JAR_CMD3 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(gnu_regexp_message_bundles))
 JAR_CMD4 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(gnu_java_locale_bundles))
 JAR_CMD5 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(serialized_converters))
+JAR_CMD6 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(gnu_getopt_message_bundles))
 else
 JAR_CMD1 = $(JAR) -cvf rt.jar -C $(LIBDIR) $(SRCDIRS)
 JAR_CMD2 = $(JAR) -uvf rt.jar -C $(srcdir) META-INF/
 JAR_CMD3 = $(JAR) -uvf rt.jar -C $(srcdir) $(gnu_regexp_message_bundles)
 JAR_CMD4 = $(JAR) -uvf rt.jar -C $(srcdir) $(gnu_java_locale_bundles)
 JAR_CMD5 = $(JAR) -uvf rt.jar -C $(srcdir) $(serialized_converters)
+JAR_CMD6 = $(JAR) -uvf rt.jar -C $(srcdir) $(gnu_getopt_message_bundles)
 endif
 
 .PHONY: jar-classes
@@ -4166,6 +4183,7 @@
        $(JAR_CMD3)
        $(JAR_CMD4)
        $(JAR_CMD5)
+       $(JAR_CMD6)
 endif
 
 .PHONY: build-classes Klasses
Index: kaffe/libraries/javalib/Makefile.am.in
diff -u kaffe/libraries/javalib/Makefile.am.in:1.16 
kaffe/libraries/javalib/Makefile.am.in:1.17
--- kaffe/libraries/javalib/Makefile.am.in:1.16 Thu Jul 22 19:19:22 2004
+++ kaffe/libraries/javalib/Makefile.am.in      Sun Jul 25 06:46:44 2004
@@ -146,6 +146,16 @@
        gnu/java/locale/iso639_ga.properties \
        gnu/java/locale/iso639.properties
 
+gnu_getopt_message_bundles = \
+       gnu/getopt/MessagesBundle_cs.properties \
+               gnu/getopt/MessagesBundle_ja.properties \
+       gnu/getopt/MessagesBundle_de.properties \
+               gnu/getopt/MessagesBundle_nl.properties \
+       gnu/getopt/MessagesBundle_fr.properties \
+               gnu/getopt/MessagesBundle_no.properties \
+       gnu/getopt/MessagesBundle_hu.properties \
+               gnu/getopt/MessagesBundle.properties
+
 EXTRA_DIST = \
        Makefile.am.in \
        Klasses.jar.bootstrap \
@@ -163,7 +173,8 @@
        $(OMITTED_PACKAGES_SRCS) \
        $(serialized_converters) \
        $(gnu_regexp_message_bundles) \
-       $(gnu_java_locale_bundles)
+       $(gnu_java_locale_bundles) \
+       $(gnu_getopt_message_bundles)
 
 dist-hook:
        rm -rf `find $(distdir) -name CVS`
@@ -208,12 +219,14 @@
 JAR_CMD3 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(gnu_regexp_message_bundles))
 JAR_CMD4 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(gnu_java_locale_bundles))
 JAR_CMD5 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(serialized_converters))
+JAR_CMD6 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(gnu_getopt_message_bundles))
 else
 JAR_CMD1 = $(JAR) -cvf rt.jar -C $(LIBDIR) $(SRCDIRS)
 JAR_CMD2 = $(JAR) -uvf rt.jar -C $(srcdir) META-INF/
 JAR_CMD3 = $(JAR) -uvf rt.jar -C $(srcdir) $(gnu_regexp_message_bundles)
 JAR_CMD4 = $(JAR) -uvf rt.jar -C $(srcdir) $(gnu_java_locale_bundles)
 JAR_CMD5 = $(JAR) -uvf rt.jar -C $(srcdir) $(serialized_converters)
+JAR_CMD6 = $(JAR) -uvf rt.jar -C $(srcdir) $(gnu_getopt_message_bundles)
 endif
 
 .PHONY: jar-classes
@@ -228,6 +241,7 @@
        $(JAR_CMD3)
        $(JAR_CMD4)
        $(JAR_CMD5)
+       $(JAR_CMD6)
 endif
 
 .PHONY: build-classes Klasses
Index: kaffe/libraries/javalib/Makefile.in
diff -u kaffe/libraries/javalib/Makefile.in:1.281 
kaffe/libraries/javalib/Makefile.in:1.282
--- kaffe/libraries/javalib/Makefile.in:1.281   Sun Jul 25 06:37:36 2004
+++ kaffe/libraries/javalib/Makefile.in Sun Jul 25 06:46:44 2004
@@ -412,6 +412,7 @@
        $(gnu_crypto_tool_SRCS) \
        $(gnu_crypto_tool_keytool_SRCS) \
        $(gnu_crypto_util_SRCS) \
+       $(gnu_getopt_SRCS) \
        $(gnu_inet_ftp_SRCS) \
        $(gnu_inet_util_SRCS) \
        $(gnu_java_awt_SRCS) \
@@ -1126,6 +1127,10 @@
        gnu/crypto/util/SimpleList.java \
        gnu/crypto/util/Util.java
 
+gnu_getopt_SRCS = \
+       gnu/getopt/Getopt.java \
+       gnu/getopt/LongOpt.java
+
 gnu_inet_ftp_SRCS = \
        gnu/inet/ftp/ActiveModeDTP.java \
        gnu/inet/ftp/BlockInputStream.java \
@@ -4652,6 +4657,16 @@
        gnu/java/locale/iso639_ga.properties \
        gnu/java/locale/iso639.properties
 
+gnu_getopt_message_bundles = \
+       gnu/getopt/MessagesBundle_cs.properties \
+               gnu/getopt/MessagesBundle_ja.properties \
+       gnu/getopt/MessagesBundle_de.properties \
+               gnu/getopt/MessagesBundle_nl.properties \
+       gnu/getopt/MessagesBundle_fr.properties \
+               gnu/getopt/MessagesBundle_no.properties \
+       gnu/getopt/MessagesBundle_hu.properties \
+               gnu/getopt/MessagesBundle.properties
+
 EXTRA_DIST = \
        Makefile.am.in \
        Klasses.jar.bootstrap \
@@ -4669,7 +4684,8 @@
        $(OMITTED_PACKAGES_SRCS) \
        $(serialized_converters) \
        $(gnu_regexp_message_bundles) \
-       $(gnu_java_locale_bundles)
+       $(gnu_java_locale_bundles) \
+       $(gnu_getopt_message_bundles)
 
 LIBDIR = lib
 rebuildLib = ./rebuildLib
@@ -4683,6 +4699,8 @@
 @[EMAIL PROTECTED] = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(gnu_java_locale_bundles))
 @[EMAIL PROTECTED] = $(JAR) -uvf rt.jar -C $(srcdir) $(serialized_converters)
 @[EMAIL PROTECTED] = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r $$dstdir/rt.jar 
$(serialized_converters))
[EMAIL PROTECTED]@JAR_CMD6 = $(JAR) -uvf rt.jar -C $(srcdir) 
$(gnu_getopt_message_bundles)
[EMAIL PROTECTED]@JAR_CMD6 = (dstdir=`pwd`; cd $(srcdir) && $(ZIP) -DX -r 
$$dstdir/rt.jar $(gnu_getopt_message_bundles))
 all: all-recursive
 
 .SUFFIXES:
@@ -4883,7 +4901,7 @@
        -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
 
 distdir: $(DISTFILES)
-       $(mkdir_p) $(distdir)/gnu/java/locale $(distdir)/gnu/regexp $(distdir)/kaffe/io
+       $(mkdir_p) $(distdir)/gnu/getopt $(distdir)/gnu/java/locale 
$(distdir)/gnu/regexp $(distdir)/kaffe/io
        @srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
        topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
        list='$(DISTFILES)'; for file in $$list; do \
@@ -5066,6 +5084,7 @@
 @USE_PRECOMPILED_RT_JAR_FALSE@ $(JAR_CMD3)
 @USE_PRECOMPILED_RT_JAR_FALSE@ $(JAR_CMD4)
 @USE_PRECOMPILED_RT_JAR_FALSE@ $(JAR_CMD5)
[EMAIL PROTECTED]@      $(JAR_CMD6)
 
 .PHONY: build-classes Klasses
 build-classes Klasses: rt.jar
Index: kaffe/libraries/javalib/all.files
diff -u kaffe/libraries/javalib/all.files:1.5 kaffe/libraries/javalib/all.files:1.6
--- kaffe/libraries/javalib/all.files:1.5       Sun Jul 25 06:37:37 2004
+++ kaffe/libraries/javalib/all.files   Sun Jul 25 06:46:44 2004
@@ -417,6 +417,8 @@
 gnu/crypto/util/Sequence.java
 gnu/crypto/util/SimpleList.java
 gnu/crypto/util/Util.java
+gnu/getopt/Getopt.java
+gnu/getopt/LongOpt.java
 gnu/inet/ftp/ActiveModeDTP.java
 gnu/inet/ftp/BlockInputStream.java
 gnu/inet/ftp/BlockOutputStream.java
===================================================================
Checking out kaffe/libraries/javalib/gnu/getopt/Getopt.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/gnu/getopt/Getopt.java,v
VERS: 1.1
***************
--- /dev/null   Sun Aug  4 19:57:58 2002
+++ kaffe/libraries/javalib/gnu/getopt/Getopt.java      Sun Jul 25 07:03:25 2004
@@ -0,0 +1,1338 @@
+/**************************************************************************
+/* 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 ([EMAIL PROTECTED])
+/*
+/* 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.util.PropertyResourceBundle;
+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.
+  * <p>
+  * 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.
+  * <p>
+  * 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.
+  * <p>
+  * 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.
+  * <p>
+  * 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.
+  * <p>
+  * 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".
+  * <p>
+  * 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.
+  * <p>
+  * Here is a basic example of using Getopt:
+  * <p>
+  * <pre>
+  * 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");
+  *       }
+  *   }
+  * </pre>
+  * <p>
+  * 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.
+  * <p>
+  * 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.
+  * <p>
+  * 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.
+  * <p>
+  * 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". 
+  * <p> 
+  * 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().
+  * <p>
+  * 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.
+  * <p>
+  * 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.
+  * <p>
+  * 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".  
+  * <p>
+  * 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".
+  * <p>
+  * 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.
+  * <p>
+  * 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 '?'.  
+  * <p>
+  * 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.
+  * <p>
+  * 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).
+  * <p>
+  * 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.
+  * <p>
+  * 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.
+  * <p>
+  * 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. 
+  * <p>
+  * Here is an expanded Getopt example using long options and various
+  * techniques described above:
+  * <p>
+  * <pre>
+  * 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");
+  * </pre>
+  * <p>
+  * 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.
+  * <p> 
+  * 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.
+  * <p>
+  * 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.
+  * <p>
+  * Please send all bug reports, requests, and comments to
+  * <a href="mailto:[EMAIL PROTECTED]">[EMAIL PROTECTED]</a>.
+  *
+  * @version 1.0.7
+  *
+  * @author Roland McGrath ([EMAIL PROTECTED])
+  * @author Ulrich Drepper ([EMAIL PROTECTED])
+  * @author Aaron M. Renn ([EMAIL PROTECTED])
+  *
+  * @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 = PropertyResourceBundle.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 = PropertyResourceBundle.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 

*** Patch too long, truncated ***

_______________________________________________
kaffe mailing list
[EMAIL PROTECTED]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe

Reply via email to