Free getopt plus software for linux

Getopt::Plus is a Perl module with options wrapper with standard options, help system and more.

FILE_SIZE_HUMAN

Map from file size in bytes to human name, as hashref, keys being name (full name, lowercase, no trailing s) and abbrev (one/two-letter abbreviation).
Option Types

Permissable values to the type field of an option specifier.

OPT_FLOAT

OPT_INT

OPT_STRING

OPT_FDLEVEL

OPT_BOOLEAN

Error Codes

ERR_OK

Not an error at all. Hence the name.

ERR_ABNORMAL

Not so much an error as a non-erroneous circumstance worthy of signalling, e.g., grep finding no matches.

ERR_UTILITY

Again, not really an error, rather a utility function being called --- e.g., the --help or --version. This gets an error code because it is almost certainly an error to call from batch scripts.

ERR_USAGE

The program was called wrong.

ERR_IO_READ

Some problem reading from disk or network (system read).

ERR_IO_WRITE

Some problem writing to disk or network (system write).

ERR_DB_READ

Some problem reading from db or similar (application read).

ERR_DB_WRITE

Some problem writing to db or similar (application write).

ERR_EXTERNAL

Some problem with an external application.

ERR_INTERNAL

An internal logic error (the sort of thing that should never happen, but has been caught by an internal assertion or sanity check).

ERR_INPUT

Some problem with the input file (which was read fine, but contains bad data).

Tk::Getopt is a user configuration window for Tk with interface to Getopt::Long.

SYNOPSIS

use Tk::Getopt;
@opttable = ([opt1, =s, default], [opt2, !, 1], ...);
$opt = new Tk::Getopt(-opttable => @opttable,
-options => %options,
-filename => "$ENV{HOME}/.options");
$opt->set_defaults; # set default values
$opt->load_options; # configuration file
$opt->get_options; # command line
$opt->process_options; # process callbacks, check restrictions ...
print $options->{opt1}, $options->{opt2} ...;
...
$top = new MainWindow;
$opt->option_editor($top);
or using a Getopt::Long-like interface
$opt = new Tk::Getopt(-getopt => [help => $HELP,
file:s => $FILE,
foo! => $FOO,
num:i => $NO,
]);
or an alternative Getopt::Long interface
%optctl = (foo => $foo,
bar => $bar);
$opt = new Tk::Getopt(-getopt => [%optctl, "foo!", "bar=s"]);

Tk::Getopt provides an interface to access command line options via Getopt::Long and editing with a graphical user interface via a Tk window.

Unlike Getopt::Long, this package uses a object oriented interface, so you have to create a new Tk::Getopt object with new. Unlike other packages in the Tk hierarchy, this package does not define a Tk widget. The graphical interface is calles by the method option_editor.

After creating an object with new, you can parse command line options by calling get_options. This method calls itself Getopt::Long::GetOptions.

Getopt::Simple is a Perl module that provides a simple wrapper around Getopt::Long.

SYNOPSIS

use Getopt::Simple;

# Or ...
# use Getopt::Simple qw($switch);

my($options) =
{
help =>
{
type => ,
env => -,
default => ,
# verbose => , # Not needed on every key.
order => 1,
},
username =>
{
type => =s, # As per Getopt::Long.
env => $USER, # Help text.
default => $ENV{USER} || RonSavage, # In case $USER is undef.
verbose => Specify the username on the remote machine,
order => 3, # Help text sort order.
},
password =>
{
type => =s,
env => -,
default => password,
verbose => Specify the password on the remote machine,
order => 4,
},
};

my($option) = Getopt::Simple -> new();

if (! $option -> getOptions($options, "Usage: testSimple.pl [options]") )
{
exit(-1); # Failure.
}

print "username: $$option{switch}{username}. n";
print "password: $$option{switch}{password}. n";

# Or, after use Getopt::Simple qw($switch); ...
# print "username: $$switch{username}. n";
# print "password: $$switch{password}. n";

Getopt::Simple is a pure Perl module.

The Getopt::Simple module provides a simple way of specifying:

Command line switches

Type information for switch values

Default values for the switches

Help text per switch

Getopt::Long is an extended processing of command line options.

SYNOPSIS

use Getopt::Long;
my $data = "file.dat";
my $length = 24;
my $verbose;
$result = GetOptions ("length=i" => $length, # numeric
"file=s" => $data, # string
"verbose" => $verbose); # flag

The Getopt::Long module implements an extended getopt function called GetOptions(). This function adheres to the POSIX syntax for command line options, with GNU extensions.

In general, this means that options have long names instead of single letters, and are introduced with a double dash "--". Support for bundling of command line options, as was the case with the more traditional single-letter approach, is provided but not enabled by default.

Getopt::Popt is a Perl interface to the popt(3) library.

SYNOPSIS

use Getopt::Popt qw(:all);

# setup the options array
push @options,new Getopt::Popt::Option(
longName => "long",
shortName => "l",
argInfo => POPT_ARG_STRING,
arg => $qux,
val => $val);

# or, if youre lazy, have Getopt::Popt automagically do the new()
push @options, { shortName => s,
argInfo => POPT_ARG_NONE,
arg => $quux,
val => s
};

# "val"s can be a single character or an integer:
push @options, { longName => xor,
argInfo => POPT_ARG_VAL | POPT_ARGFLAG_XOR,
arg => $quuux,
val => 0xbadf00d # integer
},
Enable automatic help/usage messages (--help or --usage):
push @options, POPT_AUTOHELP;
Create a new popt context:
$popt = new Getopt::Popt(name => $alias_name,
argv => @ARGV,
options => @options,
flags => $flags);
Setup option aliases:
# load some aliases
$popt->readDefaultConfig();
$popt->readConfigFile("/path/to/aliases");

# add your own alias
$alias = new Getopt::Popt::Alias(longName => "taco",
argv => [qw(--flavored --kisses)]);
$popt->addAlias($alias, $alias_flags);
Load options as you would in C:
# loop through the options, using the popt C way:
while(($rc = $popt->getNextOpt()) > 0) {
...
# one way to get the arg val
$bork = $popt->getOptArg();
...
# stuff some args
$popt->stuffArgs(qw(-q -u -x));
...
# start over
$popt->resetContext();
...
}
And handle errors as you would in C:
$errstr = $popt->strerror($rc);
$badopt = $popt->badOption($rc,$badopt_flags);
Or try the new perly way:
eval {
while(defined($val = $popt->getNextOptChar())) {
^^^^-- note!
# $val is a Scalar::Util::dualvar:
if($val eq "c") { # getArgs();

Getopt::EvaP is a Perl module to evaluate Perl command line parameters.

SYNOPSIS

use vars qw/@PDT @MM %OPT/;
use Getopt::EvaP;

EvaP @PDT, @MM, %OPT;

EXPORT

use Getopt::EvaP exports the subs EvaP and EvaP_PAC into your name space.

@PDT is the Parameter Description Table, which is a reference to a list of strings describing the command line parameters, aliases, types and default values. @MM is the Message Module, which is also a reference to a list of strings describing the command and its parameters. %OPT is an optional hash reference where Evaluate Parameters should place its results. If specified, the historical behaviour of modifying the calling routines namespace by storing option values in %Options, %options and $opt* is disabled.

Getopt::ExPar contains extended parameters command line parser.

SYNOPSIS

use Getopt::ExPar;

my(@PDT, @MM, %OPT);
ExPar @PDT, @MM, $OPT;

EXPORT

use Getopt::ExPar exports the sub ExPar into your name space.

ExPar is a perl5 module used to parse command line parameters. This package uses the @PDT, Parameter Description Table, and the @MM, Message Module, to return %OPT which is a hash reference containing the command line option data. The function of Getopt::ExPar is based on Getopt::EvaP, created by Stephen O. Lidie.

Introduction

The ExPar function parses a perl command line. Using the option definitions in the @PDT, argument types are checked and the arguments themselves may be checked against a specified range or pattern. By using both @PDT and @MM, several types of help may be retured to the user. ExPar handles command lines with this format:

command [-parameters] [file_list]

where any parameters and file_list are optional.

Parameter Description Table (PDT) Syntax

Here is the PDT syntax. Optional constructs are enclosed in [], and the | character separates possible values in a list.

PDT [program_name, alias]
[parameter_name[, alias]: type [pattern | range] [ = [default_variable,] default_value]]
PDTEND [flag_list]

flag_list is one or more of the following flags: optional_file_list | required_file_list | no_file_list: specifies condition of list of files at end of command line. (only one of these may be specified) abbreviations: allows for abbreviations of commands or aliases as long as enough of the command is given to make it distinguishable from all others. If not, a message is printed so the user may be more specific. switchglomming: allows for multiple single-letter switch options to be specified as single option (must be first option). pdt_warnings: for debugging a @PDT, it prints out messages that are not necessarily errors, like inconsistent number of default values in a list, etc.
The default_variable is an environment variable - see the section Usage Notes for complete details.

So, the simplest possible PDT would be:

PDT
PDTEND

This PDT would simply define a -help switch for the command, but is rather useless.

A typical PDT would look more like this:

PDT frog
number, n: integer = 1
chars, c: string = "default_string"
PDTEND no_file_list

This PDT, for command frog, defines two parameters, number (or n), of type integer with a default value of 1, and chars (or c), of type string with a default value of "default_string". The PDTEND no_file_list indicator indicates that no trailing file_list can appear on the command line. Of course, the -help switch is defined automatically.

Each of these options may be further refined by using a range and a pattern, respectively:

PDT frog
number, n: integer (((#100, the # is implied. Other simple conditions are < and == (a single = is accepted as ==, not an assignment). Ex: This condition: (#>10, #<<less