[kaffe] CVS kaffe (robilad): removed gnu.getopt code

Kaffe CVS cvs-commits at kaffe.org
Thu Aug 10 19:46:51 PDT 2006


PatchSet 7380 
Date: 2006/08/11 02:38:03
Author: robilad
Branch: HEAD
Tag: (none) 
Log:
removed gnu.getopt code

2006-08-10  Dalibor Topic  <robilad at kaffe.org>

        * THIRDPARTY: Removed gnu.getopt, since it's no longer used.

        * libraries/javalib/vmspecific/gnu/getopt/Getopt.java,
        libraries/javalib/vmspecific/gnu/getopt/LongOpt.java,
        libraries/javalib/vmspecific/gnu/getopt/MessagesBundle.properties,
        libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_cs.properties,
        libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_de.properties,
        libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_fr.properties,
        libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_hu.properties,
        libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_ja.properties,
        libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_nl.properties,
        libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_no.properties:
        Removed.

Members: 
	ChangeLog:1.4882->1.4883 
	THIRDPARTY:1.47->1.48 
	libraries/javalib/Makefile.am:1.453->1.454 
	libraries/javalib/Makefile.in:1.567->1.568 
	libraries/javalib/vmspecific/gnu/getopt/Getopt.java:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/LongOpt.java:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle.properties:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_cs.properties:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_de.properties:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_fr.properties:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_hu.properties:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_ja.properties:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_nl.properties:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_no.properties:1.1->1.2(DEAD) 

Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4882 kaffe/ChangeLog:1.4883
--- kaffe/ChangeLog:1.4882	Fri Aug 11 01:49:53 2006
+++ kaffe/ChangeLog	Fri Aug 11 02:38:03 2006
@@ -1,5 +1,21 @@
 2006-08-10  Dalibor Topic  <robilad at kaffe.org>
 
+	* THIRDPARTY: Removed gnu.getopt, since it's no longer used.
+
+	* libraries/javalib/vmspecific/gnu/getopt/Getopt.java,
+	libraries/javalib/vmspecific/gnu/getopt/LongOpt.java,
+	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle.properties,
+	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_cs.properties,
+	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_de.properties,
+	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_fr.properties,
+	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_hu.properties,
+	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_ja.properties,
+	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_nl.properties,
+	libraries/javalib/vmspecific/gnu/getopt/MessagesBundle_no.properties:
+	Removed.
+
+2006-08-10  Dalibor Topic  <robilad at kaffe.org>
+
 	* libraries/javalib/vmspecific/gnu/classpath/Configuration.java.in:
 	Removed unused file.
 
Index: kaffe/THIRDPARTY
diff -u kaffe/THIRDPARTY:1.47 kaffe/THIRDPARTY:1.48
--- kaffe/THIRDPARTY:1.47	Sat Apr 22 14:50:25 2006
+++ kaffe/THIRDPARTY	Fri Aug 11 02:38:06 2006
@@ -634,15 +634,6 @@
 
 This is version 6.7 of a conservative garbage collector for C and C++.
 
-* gnu.getopt
-
-This code has been merged from GNU Getopt 1.0.9
-
-Licensed under the GNU General Public License. See licence.terms for more 
-details. 
-
-Homepage: http://www.urbanophile.com/arenn/hacking/
-
 * ANTLR
 
 Gjdoc is using ANTLR. Files from ANTRL 2.7.5, necessary to run
Index: kaffe/libraries/javalib/Makefile.am
diff -u kaffe/libraries/javalib/Makefile.am:1.453 kaffe/libraries/javalib/Makefile.am:1.454
--- kaffe/libraries/javalib/Makefile.am:1.453	Fri Aug 11 01:49:59 2006
+++ kaffe/libraries/javalib/Makefile.am	Fri Aug 11 02:38:10 2006
@@ -80,16 +80,6 @@
 	vmspecific/gnu/classpath/jdwp/VMIdManager.java \
 	vmspecific/gnu/classpath/jdwp/VMMethod.java \
 	vmspecific/gnu/classpath/jdwp/VMVirtualMachine.java \
-	vmspecific/gnu/getopt/Getopt.java \
-	vmspecific/gnu/getopt/LongOpt.java \
-	vmspecific/gnu/getopt/MessagesBundle.properties \
-	vmspecific/gnu/getopt/MessagesBundle_cs.properties \
-	vmspecific/gnu/getopt/MessagesBundle_de.properties \
-	vmspecific/gnu/getopt/MessagesBundle_fr.properties \
-	vmspecific/gnu/getopt/MessagesBundle_hu.properties \
-	vmspecific/gnu/getopt/MessagesBundle_ja.properties \
-	vmspecific/gnu/getopt/MessagesBundle_nl.properties \
-	vmspecific/gnu/getopt/MessagesBundle_no.properties \
 	vmspecific/gnu/inet/comsat/ComsatClient.java \
 	vmspecific/gnu/inet/comsat/ComsatInfo.java \
 	vmspecific/gnu/inet/finger/FingerConnection.java \
Index: kaffe/libraries/javalib/Makefile.in
diff -u kaffe/libraries/javalib/Makefile.in:1.567 kaffe/libraries/javalib/Makefile.in:1.568
--- kaffe/libraries/javalib/Makefile.in:1.567	Fri Aug 11 01:50:00 2006
+++ kaffe/libraries/javalib/Makefile.in	Fri Aug 11 02:38:11 2006
@@ -392,16 +392,6 @@
 	vmspecific/gnu/classpath/jdwp/VMIdManager.java \
 	vmspecific/gnu/classpath/jdwp/VMMethod.java \
 	vmspecific/gnu/classpath/jdwp/VMVirtualMachine.java \
-	vmspecific/gnu/getopt/Getopt.java \
-	vmspecific/gnu/getopt/LongOpt.java \
-	vmspecific/gnu/getopt/MessagesBundle.properties \
-	vmspecific/gnu/getopt/MessagesBundle_cs.properties \
-	vmspecific/gnu/getopt/MessagesBundle_de.properties \
-	vmspecific/gnu/getopt/MessagesBundle_fr.properties \
-	vmspecific/gnu/getopt/MessagesBundle_hu.properties \
-	vmspecific/gnu/getopt/MessagesBundle_ja.properties \
-	vmspecific/gnu/getopt/MessagesBundle_nl.properties \
-	vmspecific/gnu/getopt/MessagesBundle_no.properties \
 	vmspecific/gnu/inet/comsat/ComsatClient.java \
 	vmspecific/gnu/inet/comsat/ComsatInfo.java \
 	vmspecific/gnu/inet/finger/FingerConnection.java \
@@ -749,7 +739,7 @@
 	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
 
 distdir: $(DISTFILES)
-	$(mkdir_p) $(distdir)/vmspecific/META-INF $(distdir)/vmspecific/gnu/classpath $(distdir)/vmspecific/gnu/classpath/jdwp $(distdir)/vmspecific/gnu/getopt $(distdir)/vmspecific/gnu/inet/comsat $(distdir)/vmspecific/gnu/inet/finger $(distdir)/vmspecific/gnu/inet/gopher $(distdir)/vmspecific/gnu/inet/imap $(distdir)/vmspecific/gnu/inet/ldap $(distdir)/vmspecific/gnu/inet/nntp $(distdir)/vmspecific/gnu/inet/pop3 $(distdir)/vmspecific/gnu/inet/smtp $(distdir)/vmspecific/gnu/inet/util $(distdir)/vmspecific/gnu/java/lang $(distdir)/vmspecific/gnu/java/lang/management $(distdir)/vmspecific/gnu/java/net $(distdir)/vmspecific/gnu/java/nio $(distdir)/vmspecific/java/io $(distdir)/vmspecific/java/lang $(distdir)/vmspecific/java/lang/management $(distdir)/vmspecific/java/lang/ref $(distdir)/vmspecific/java/lang/reflect $(distdir)/vmspecific/java/net $(distdir)/vmspecific/java/nio $(distdir)/vmspecific/java/nio/channels $(distdir)/vmspecific/java/security $(distdir)/vmspecific/java/util $(distdir)/vmspecific/org/kaffe/jar $(distdir)/vmspecific/org/kaffe/management $(distdir)/vmspecific/org/kaffe/security $(distdir)/vmspecific/org/kaffe/security/provider $(distdir)/vmspecific/org/kaffe/util
+	$(mkdir_p) $(distdir)/vmspecific/META-INF $(distdir)/vmspecific/gnu/classpath $(distdir)/vmspecific/gnu/classpath/jdwp $(distdir)/vmspecific/gnu/inet/comsat $(distdir)/vmspecific/gnu/inet/finger $(distdir)/vmspecific/gnu/inet/gopher $(distdir)/vmspecific/gnu/inet/imap $(distdir)/vmspecific/gnu/inet/ldap $(distdir)/vmspecific/gnu/inet/nntp $(distdir)/vmspecific/gnu/inet/pop3 $(distdir)/vmspecific/gnu/inet/smtp $(distdir)/vmspecific/gnu/inet/util $(distdir)/vmspecific/gnu/java/lang $(distdir)/vmspecific/gnu/java/lang/management $(distdir)/vmspecific/gnu/java/net $(distdir)/vmspecific/gnu/java/nio $(distdir)/vmspecific/java/io $(distdir)/vmspecific/java/lang $(distdir)/vmspecific/java/lang/management $(distdir)/vmspecific/java/lang/ref $(distdir)/vmspecific/java/lang/reflect $(distdir)/vmspecific/java/net $(distdir)/vmspecific/java/nio $(distdir)/vmspecific/java/nio/channels $(distdir)/vmspecific/java/security $(distdir)/vmspecific/java/util $(distdir)/vmspecific/org/kaffe/jar $(distdir)/vmspecific/org/kaffe/management $(distdir)/vmspecific/org/kaffe/security $(distdir)/vmspecific/org/kaffe/security/provider $(distdir)/vmspecific/org/kaffe/util
 	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
 	list='$(DISTFILES)'; for file in $$list; do \
===================================================================
Checking out kaffe/libraries/javalib/vmspecific/gnu/getopt/Getopt.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/vmspecific/gnu/getopt/Attic/Getopt.java,v
VERS: 1.1
***************
--- kaffe/libraries/javalib/vmspecific/gnu/getopt/Getopt.java	Fri Aug 11 02:46:51 2006
+++ /dev/null	Sun Aug  4 19:57:58 2002
@@ -1,1338 +0,0 @@
-/**************************************************************************
-/* 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 at 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., 51 Franklin Street, Fifth Floor, 
-/* Boston, MA  02110-1301 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:arenn at urbanophile.com">arenn at urbanophile.com</a>.
-  *
-  * @version 1.0.7
-  *
-  * @author Roland McGrath (roland at gnu.ai.mit.edu)
-  * @author Ulrich Drepper (drepper at cygnus.com)
-  * @author Aaron M. Renn (arenn at 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 = 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 
-  * 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;

*** Patch too long, truncated ***




More information about the kaffe mailing list