Free r options software for linux

Options.pm is a command-line option-parsing Perl module meant to imitate the syntax of the t.p.usage.Options module from the Twisted Python library.

This module will allow you to specify which options to look for on the command line, and supports both long and short versions of simple flags and parameters. If a required parameter is unspecified, Options.pm will print nicely formatted usage information with the error.

App::Options is Perl module to combine command line options, environment vars, and option file values (for program configuration).

SYNOPSIS

#!/usr/local/bin/perl

use App::Options; # reads option values into %App::options by default

# do something with the options (in %App::options)
use DBI;
$dsn = "dbi:mysql:database=$App::options{dbname}";
$dbh = DBI->connect($dsn, $App::options{dbuser}, $App::options{dbpass});
...

Get help from the command line (assuming program is named "prog") ...

prog -?

Option values may be provided on the command line, in environment variables, and option files. (i.e. $ENV{APP_DBNAME} would set the value of %App::options{dbname} by default.)

The "dbname" and other options could also be set in one of the following configuration files

$HOME/.app/prog.conf
$HOME/.app/app.conf
$PROGDIR/prog.conf
$PROGDIR/app.conf
$PREFIX/etc/app/prog.conf
$PREFIX/etc/app/app.conf
/etc/app/app.conf

with a file format like

[prog]
dbname = prod
dbuser = scott
dbpass = tiger

See below for a more detailed explanation of these and other advanced features.

App::Options combines command-line arguments, environment variables, option files, and program defaults to produce a hash of option values.

Getopt::GUI::Long is a wrapper around Getopt::Long that extends the value of the original Getopt::Long module.

SYNOPSIS

use Getopt::GUI::Long;

# pass useful config options to Configure
Getopt::GUI::Long::Configure(qw(display_help no_ignore_case capture_output));
GetOptions(%opts,
["GUI:separator", "Important Flags:"],
["f|some-flag=s", "A flag based on a string"],
["o|other-flag", "A boloean"],
);

# or use references instead of a hash (less tested, however):

GetOptions(["some-flag=s", "perform some flag based on a value"] => $flag,
["other-flag=s", "perform some flag based on a value"] => $other);

# displays auto-help given the input above:

% opttest -h
Usage: opttest [OPTIONS] Other Arguments

OPTIONS:

Important Flags:
-f STRING A flag based on a string
-o A boloean

Help Options:
-h Display help options -- short flags preferred
--help Display help options -- long flags preferred
--help-full Display all help options -- short and long



# or long help:

% opttest --help
Usage: opttest [OPTIONS] Other Arguments

OPTIONS:

Important Flags:
--some-flag=STRING A flag based on a string
--other-flag A boloean

Help Options:
-h Display help options -- short flags preferred
--help Display help options -- long flags preferred
--help-full Display all help options -- short and long

# or a GUI screen:

(see http://net-policy.sourceforge.net/images/getopt_example.png )

It can:

1) add a simple graphical user interface option screen if no arguments are passed to the program. Thus, the arguments to actually use are built based on the results of the user interface. If arguments were passed to the program, the user interface is not shown and the program executes as it normally would and acts just as if Getopt::Long::GetOptions had been called instead.

2) provide an auto-help mechanism such that -h and --help are handled automatically. In fact, calling your program with -h will default to showing the user a list of short-style arguments when one exists for the option. Similarly --help will show the user a list of long-style when possible. --help-full will list all potential arguments for an option (short and long both).

Its designed to make the creation of graphical shells trivial without the programmer having to think about it much as well as providing automatic good-looking usage output without the programmer needing to write usage() functions.

Tk::Optionmenu will let the user select one of some predefined options values.

SYNOPSIS

use Optionmenu;

$opt = $w->Optionmenu(
-options => REFERENCE_to_OPTIONLIST,
-command => CALLBACK,
-variable => SCALAR_REF,
);

$opt->addOptions( OPTIONLIST );

# OPTION LIST is
# a) $val1, $val2, $val3,...
# b) [ $lab1=>$val1], [$lab2=>val2], ... ]
# c) combination of a) and b), e.g.,
# val1, [$lab2=>val2], val3, val4, [...], ...

The Optionmenu widget allows the user chose between a given set of options.

If the user should be able to change the available option have a look at Tk::BrowseEntry.

OPTIONS

-options

(Re)sets the list of options presented.

-command

Defines the callback that is invokes when a new option is selected.

-variable

Reference to a scalar that contains the current value of the selected option.

-textvariable

Reference to a scalar that contains the text label of the current value of the selected option.

METHODS

addOptions

Adds OPTION_LIST to the already available options.

EXAMPLE

use Tk;
my $mw = MainWindow->new();

my ($var, $tvar);
my $opt = $mw->Optionmenu(
-options => [[jan=>1], [feb=>2], [mar=>3], [apr=>4]],
-command => sub { print "got: ", shift, "n" },
-variable => $var,
-textvariable => $tvar
)->pack;

$opt->addOptions([may=>5],[jun=>6],[jul=>7],[aug=>8]);

my $f = $mw->Frame(-relief=>groove, -borderwidth => 2)->pack;
$f->Label(-textvariable=>$tvar)->pack(-side => left);
$f->Label(-text => " -> ")->pack(-side => left);
$f->Label(-textvariable=>$var)->pack(-side => left);

$mw->Button(-text=>Exit, -command=>sub{$mw->destroy})->pack;

MainLoop;

aB Backup Tools is a toolset for creating and maintaining backups and recoveries of important data on your system.
Enhancements:
- memory leaks fixed,
- options optimized,
- some look changes.

Getopt::OO is an object oriented command line parser. It handles short, long and multi (--x ... -) value options. Getopt::OO module also incorporates help for options to simplify generation of usage statements.

SYNOPSIS

use Getopt::OO qw(Debug Verbose);

my ($handle) = Getopt::OO->new(@ARGV,
-d => {
help => turn on debug output,
callback => sub {Debug(1); 0},
},
-o => {
help => another option.,
},
-f => {
help => option that expects one more value.,
n_values => 1,
},
--long {
help => long option
},
--multiple_ => {
help => [
"Everything between --multiple_values and - is",
"an value for this options",
],
multi_value => 1,
multiple= => 1, # Can happen more than once on command line.
},
other_values => {
help => file_1 ... file_n,
multi_value => 1,
},
);
if ($handle->Values()) {
Debug("You will get output if -d was on command line");
if (my $f = handle->Values(-f)) {
print "Got $f with the -f value.n";
}
}
else {
print "No options found on command line.n";
}

Getopt::OO is an object oriented tool for parsing command line arguments. It expects a reference to the input arguments and uses a perl hash to describe how the command line arguments should be parsed. Note that by parsed, we mean what options expect values, etc. We check to make sure values exist on the command line as necessary -- nothing else. The caller is responsible for making sure that a value that he knows should be a file exists, is writable, or whatever.

Command line arguments can be broken into two distinct types: options and values that are associated with these options. In windows, options often start with a / but sometimes with a -, but in unix they almost universally start with a -. For this module options start with a -. We support two types of options: the short single dashed options and the long double dashed options.

The difference between these two is that with this module the short options can be combined into a single option, but the long options can not. For example, most of us will be familiar with the tar -xvf file command which can also be expressed as -x -v -f file. Long options can not be combined this way, so --help for example must always stand by itself.

The input template expects the option names as its keys. For instance if you were expecting -xv --hello as possible command line options, the keys for your template hash would be -x, -v, and --hello.

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();

Java GetOpt library implements option parsing and a common online help behaviour, including an XML format for topics, command, and options (which can be queried with --help --xml) and support for online browsing with --help --browse.

Whats New in This Release:

ï¿1⁄2 The getopt library can now choose the pluggable look and feel of an application with a standard option "--plaf".
ï¿1⁄2 A new file of default options (.prefs/default.options) can specify a set of common default options for all programs using the getopt library, such as the PLAF.