Handles program arguments like Unix getopt()
/* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* monoped@users.sourceforge.net
*/
import java.io.*;
import java.util.*;
/** Handles program arguments like Unix getopt(). Example: <pre>
* void main(String[] argv)
* {
* int opt;
* boolean x = false;
* Getopt getopt = new Getopt(argv, "a:hx");
* String argA = "";
*
* // get Options
*
* while ((opt = getopt.getOption()) != -1)
* {
* switch (opt)
* {
* case 'a': argA = getopt.getOptarg();
* break;
* case 'h': help();
* break;
* case 'x': x = true;
* break;
* default: System.out.println("wrong option: " + getOptopt());
* }
* }
*
* // handle non-option parameters
*
* String[] files = getopt.getParms();
*
* for (int i = 0; i < files.length; ++i)
* doSomethingWith(files[i]);
* }
*
* Legal calls:
* java Mainclass -hx file1 file2
* java Mainclass -xa blurp -h -- file3
*
* Illegal calls:
* java Mainclass -y f
* java Mainclass -a
*
* The special argument -- denotes the end of the options. All Arguments
* after this will be considered as non-options, even if starting with -.
*
* If any command line argument is of the form "@filename", this file
* is read and each line is considered a program parameter.
*
* </pre>
*
* @author Bernd Eggink (monoped@users.sourceforge.net)
*/
public class Getopt
{
private String[] argv;
private ArrayList arglist;
private String optarg, opts;
private int ichr = 0, optind = 0;
private char optopt;
private boolean opterr = true;
//----------------------------------------------------------------------
/** Default constructor
*
* @param opts The possible options.
*/
private Getopt(String opts)
{
this.opts = opts;
arglist = new ArrayList();
}
//----------------------------------------------------------------------
/** Constructs a Getopt object by reading all arguments from a file.
* @param filename Name of the file to read.
* @param opts The possible options.
* @param opterr If true, an error message will be printed if an illegal option character
* is found.
*/
public Getopt(String filename, String opts, boolean opterr)
throws IOException
{
this(filename, opts);
this.opterr = opterr;
}
//----------------------------------------------------------------------
/** Like Getopt(filename, opts, true) */
public Getopt(String filename, String opts)
throws IOException
{
this(opts);
addArgsFromFile(filename);
}
//----------------------------------------------------------------------
/** Constructs a Getopt object using the main() parameter list.
* @param argv The arguments of main()
* @param opts The possible options. Each option is a single character.
* If followed by a colon, the option given in the command line
* must be followed by an argument.
* @param opterr If true, an error message will be printed if an illegal option character
* is encountered.
*/
public Getopt(String[] argv, String opts, boolean opterr)
throws IOException
{
this(argv, opts);
this.opterr = opterr;
}
//----------------------------------------------------------------------
/** Like Getopt(argv, opts, true). */
public Getopt(String[] argv, String opts)
throws IOException
{
this(opts);
for (int i = 0; i < argv.length; ++i)
{
String arg = argv[i];
if (arg.startsWith("@"))
addArgsFromFile(arg.substring(1));
else
arglist.add(arg);
}
this.argv = (String[])arglist.toArray(new String[0]);
}
//----------------------------------------------------------------------
private void addArgsFromFile(String name)
throws IOException
{
BufferedReader reader = new BufferedReader(new FileReader(new File(name)));
String zeile;
while ((zeile = reader.readLine()) != null)
arglist.add(zeile);
reader.close();
}
//----------------------------------------------------------------------
/** Returns the current argument or null. */
public String getOptarg()
{
return optarg;
}
//----------------------------------------------------------------------
/** Returns the next option as int value,
* -1 if no more options are available, '?' if the option is illegal.
*/
public int getOption()
{
char c;
int iopt;
if (ichr == 0)
{
// beginning of word
if (optind >= argv.length || argv[optind].charAt(0) != '-')
return -1;
if (argv[optind].equals("-") || argv[optind].equals("--"))
{
++optind;
return -1;
}
}
// had -
c = argv[optind].charAt(++ichr);
if (c == ':' || (iopt = opts.indexOf(c)) < 0)
{
if (opterr)
System.err.println("+++ Illegal option: " + c);
if (++ichr >= argv[optind].length())
{
++optind;
ichr = 0;
}
optopt = c;
optarg = null;
return '?';
}
if (iopt + 1 < opts.length() && opts.charAt(iopt + 1) == ':')
{
// must have optarg
if (++ichr < argv[optind].length())
optarg = argv[optind++].substring(ichr);
else if (++optind >= argv.length)
{
if (opterr)
System.err.println("+++ Option " + c + " requires an argument");
ichr = 0;
optopt = c;
return '?';
}
else
optarg = argv[optind++];
ichr = 0;
}
else
{
// no optarg
if (ichr + 1 >= argv[optind].length())
{
++optind;
ichr = 0;
}
optarg = null;
}
return c;
}
//----------------------------------------------------------------------
/** Returns the unrecognized option character. */
public char getOptopt()
{
return optopt;
}
//----------------------------------------------------------------------
/** Returns parameters not handled by getOption() as array of Strings. */
public String[] getParms()
{
String[] parms = new String[argv.length - optind];
for (int i = 0; optind + i < argv.length; ++i)
parms[i] = argv[optind + i];
return parms;
}
//----------------------------------------------------------------------
/*
static public void main(String[] args)
{
try
{
Getopt g = new Getopt(args, "ab:c:d:e");
int opt;
while ((opt = g.getOption()) >= 0)
System.out.println("opt = " + (char)opt + ", optarg = " + g.getOptarg());
String[] words = g.getParms();
for (int i = 0; i < words.length; ++i)
System.out.println(words[i]);
}
catch (IOException ex)
{
System.err.println(ex);
}
}
*/
}
Related examples in the same category
