Getopt::Mixed(3) User Contributed Perl Documentation Getopt::Mixed(3)NAMEGetopt::Mixed - getopt processing with both long and short options
VERSION
This document describes version 1.11 of Getopt::Mixed, released August
25, 2012.
SYNOPSIS
use Getopt::Mixed;
Getopt::Mixed::getOptions(...option-descriptions...);
...examine $opt_* variables...
or
use Getopt::Mixed "nextOption";
Getopt::Mixed::init(...option-descriptions...);
while (($option, $value) = nextOption()) {
...process option...
}
Getopt::Mixed::cleanup();
DESCRIPTION
This module is obsolete.
This package was my response to the standard modules Getopt::Std and
Getopt::Long. "Std" doesn't support long options, and "Long" didn't
support short options. I wanted both, since long options are easier to
remember and short options are faster to type.
However, some time ago Getopt::Long was changed to support short
options as well, and it has the huge advantage of being part of the
standard Perl distribution. So, Getopt::Mixed is now effectively
obsolete. I don't intend to make any more changes, but I'm leaving it
available for people who have code that already uses it. For new
modules, I recommend using Getopt::Long like this:
use Getopt::Long;
Getopt::Long::Configure(qw(bundling no_getopt_compat));
GetOptions(...option-descriptions...);
This package was intended to be the "Getopt-to-end-all-Getop's". It
combines (I hope) flexibility and simplicity. It supports both short
options (introduced by "-") and long options (introduced by "--").
Short options which do not take an argument can be grouped together.
Short options which do take an argument must be the last option in
their group, because everything following the option will be considered
to be its argument.
There are two methods for using Getopt::Mixed: the simple method and
the flexible method. Both methods use the same format for option
descriptions.
Option Descriptions
The option-description arguments required by "init" and "getOptions"
are strings composed of individual option descriptions. Several option
descriptions can appear in the same string if they are separated by
whitespace.
Each description consists of the option name and an optional trailing
argument specifier. Option names may consist of any characters but
whitespace, "=", ":", and ">".
Values for argument specifiers are:
<none> option does not take an argument
=s :s option takes a mandatory (=) or optional (:) string argument
=i :i option takes a mandatory (=) or optional (:) integer argument
=f :f option takes a mandatory (=) or optional (:) real number argument
>new option is a synonym for option `new'
The ">" specifier is not really an argument specifier. It defines an
option as being a synonym for another option. For example, "a=i
apples>a" would define -a as an option that requires an integer
argument and --apples as a synonym for -a. Only one level of synonyms
is supported, and the root option must be listed first. For example,
"apples>a a=i" and "a=i apples>a oranges>apples" are illegal; use "a=i
apples>a oranges>a" if that's what you want.
For example, in the option description:
"a b=i c:s apple baker>b charlie:s"
-a and --apple do not take arguments
-b takes a mandatory integer argument
--baker is a synonym for -b
-c and --charlie take an optional string argument
If the first argument to "init" or "getOptions" is entirely non-
alphanumeric characters with no whitespace, it represents the
characters which can begin options.
User Interface
From the user's perspective, short options are introduced by a dash
("-") and long options are introduced by a double dash ("--"). Short
options may be combined ("-a -b" can be written "-ab"), but an option
that takes an argument must be the last one in its group, because
anything following it is considered part of the argument. A double
dash by itself marks the end of the options; all arguments following it
are treated as normal arguments, not options. A single dash by itself
is treated as a normal argument, not an option.
Long options may be abbreviated. An option --all-the-time could be
abbreviated --all, --a--tim, or even --a. Note that --time would not
work; the abbreviation must start at the beginning of the option name.
If an abbreviation is ambiguous, an error message will be printed.
In the following examples, -i and --int take integer arguments, -f and
--float take floating point arguments, and -s and --string take string
arguments. All other options do not take an argument.
-i24-f24.5-sHello
-i=24 --int=-27 -f=24.5 --float=0.27 -s=Hello --string=Hello
If the argument is required, it can also be separated by whitespace:
-i 24 --int -27 -f 24.5 --float 0.27 -s Hello --string Hello
Note that if the option is followed by "=", whatever follows the "=" is
the argument, even if it's the null string. In the example
-i= 24 -f= 24.5 -s= Hello
-i and -f will cause an error, because the null string is not a number,
but -s is perfectly legal; its argument is the null string, not
"Hello".
Remember that optional arguments cannot be separated from the option by
whitespace.
The Simple Method
The simple method is
use Getopt::Mixed;
Getopt::Mixed::getOptions(...option-descriptions...);
You then examine the "$opt_*" variables to find out what options were
specified and the @ARGV array to see what arguments are left.
If -a is an option that doesn't take an argument, then $opt_a will be
set to 1 if the option is present, or left undefined if the option is
not present.
If -b is an option that takes an argument, then $opt_b will be set to
the value of the argument if the option is present, or left undefined
if the option is not present. If the argument is optional but not
supplied, $opt_b will be set to the null string.
Note that even if you specify that an option requires a string
argument, you can still get the null string (if the user specifically
enters it). If the option requires a numeric argument, you will never
get the null string (because it isn't a number).
When converting the option name to a Perl identifier, any non-word
characters in the name will be converted to underscores ("_").
If the same option occurs more than once, only the last occurrence will
be recorded. If that's not acceptable, you'll have to use the flexible
method instead.
The Flexible Method
The flexible method is
use Getopt::Mixed "nextOption";
Getopt::Mixed::init(...option-descriptions...);
while (($option, $value, $pretty) = nextOption()) {
...process option...
}
Getopt::Mixed::cleanup();
This lets you process arguments one at a time. You can then handle
repeated options any way you want to. It also lets you see option
names with non-alphanumeric characters without any translation. This
is also the only method that lets you find out what order the options
and other arguments were in.
First, you call Getopt::Mixed::init with the option descriptions.
Then, you keep calling nextOption until it returns an empty list.
Finally, you call Getopt::Mixed::cleanup when you're done. The
remaining (non-option) arguments will be found in @ARGV.
Each call to nextOption returns a list of the next option, its value,
and the option as the user typed it. The value will be undefined if
the option does not take an argument. The option is stripped of its
starter (e.g., you get "a" and "foo", not "-a" or "--foo"). If you
want to print an error message, use the third element, which does
include the option starter.
OTHER FUNCTIONSGetopt::Mixed provides one other function you can use. "abortMsg"
prints its arguments on STDERR, plus your program's name and a newline.
It then exits with status 1. For example, if foo.pl calls "abortMsg"
like this:
Getopt::Mixed::abortMsg("Error");
The output will be:
foo.pl: Error
CUSTOMIZATION
There are several customization variables you can set. All of these
variables should be set after calling Getopt::Mixed::init and before
calling nextOption.
If you set any of these variables, you must check the version number
first. The easiest way to do this is like this:
use Getopt::Mixed 1.006;
If you are using the simple method, and you want to set these
variables, you'll need to call init before calling getOptions, like
this:
use Getopt::Mixed 1.006;
Getopt::Mixed::init(...option-descriptions...);
...set configuration variables...
Getopt::Mixed::getOptions(); # IMPORTANT: no parameters
$order
$order can be set to $REQUIRE_ORDER, $PERMUTE, or $RETURN_IN_ORDER.
The default is $REQUIRE_ORDER if the environment variable
POSIXLY_CORRECT has been set, $PERMUTE otherwise.
$REQUIRE_ORDER means that no options can follow the first argument
which isn't an option.
$PERMUTE means that all options are treated as if they preceded all
other arguments.
$RETURN_IN_ORDER means that all arguments maintain their ordering.
When nextOption is called, and the next argument is not an option,
it returns the null string as the option and the argument as the
value. nextOption never returns the null list until all the
arguments have been processed.
$ignoreCase
Ignore case when matching options. Default is 1 unless the option
descriptions contain an upper-case letter.
$optionStart
A string of characters that can start options. Default is "-".
$badOption
A reference to a function that is called when an unrecognized
option is encountered. The function receives three arguments.
$_[0] is the position in @ARGV where the option came from. $_[1]
is the option as the user typed it (including the option start
character). $_[2] is either undef or a string describing the
reason the option was not recognized (Currently, the only possible
value is 'ambiguous', for a long option with several possible
matches). The option has already been removed from @ARGV. To put
it back, you can say:
splice(@ARGV,$_[0],0,$_[1]);
The function can do anything you want to @ARGV. It should return
whatever you want nextOption to return.
The default is a function that prints an error message and exits
the program.
$checkArg
A reference to a function that is called to make sure the argument
type is correct. The function receives four arguments. $_[0] is
the position in @ARGV where the option came from. $_[1] is the
text following the option, or undefined if there was no text
following the option. $_[2] is the name of the option as the user
typed it (including the option start character), suitable for error
messages. $_[3] is the argument type specifier.
The function can do anything you want to @ARGV. It should return
the value for this option.
The default is a function that prints an error message and exits
the program if the argument is not the right type for the option.
You can also adjust the behavior of the default function by
changing $intRegexp or $floatRegexp.
$intRegexp
A regular expression that matches an integer. Default is
'^[-+]?\d+$', which matches a string of digits preceded by an
optional sign. Unlike the other configuration variables, this
cannot be changed after nextOption is called, because the pattern
is compiled only once.
$floatRegexp
A regular expression that matches a floating point number. Default
is '^[-+]?(\d*\.?\d+|\d+\.)$', which matches the following formats:
"123", "123.", "123.45", and ".123" (plus an optional sign). It
does not match exponential notation. Unlike the other
configuration variables, this cannot be changed after nextOption is
called, because the pattern is compiled only once.
$typeChars
A string of the characters which are legal argument types. The
default is 'sif', for String, Integer, and Floating point
arguments. The string should consist only of letters. Upper case
letters are discouraged, since this will hamper the case-folding of
options. If you change this, you should set $checkType to a
function that will check arguments of your new type. Unlike the
other configuration variables, this must be set before calling
init(), and cannot be changed afterwards.
$checkType
If you add new types to $typeChars, you should set this to a
function which will check arguments of the new types.
CONFIGURATION AND ENVIRONMENTGetopt::Mixed requires no configuration files or environment variables.
INCOMPATIBILITIES
None reported.
BUGS AND LIMITATIONS
· This document should be expanded.
· A long option must be at least two characters long. Sorry.
· The "!" argument specifier of Getopt::Long is not supported, but
you could have options --foo and --nofoo and then do something
like:
$opt_foo = 0 if $opt_nofoo;
· The "@" argument specifier of Getopt::Long is not supported. If
you want your values pushed into an array, you'll have to use
nextOption and do it yourself.
AUTHOR
Christopher J. Madsen "<perl AT cjmweb.net>"
Please report any bugs or feature requests to
"<bug-Getopt-Mixed AT rt.cpan.org>" or through the web interface at
<http://rt.cpan.org/Public/Bug/Report.html?Queue=Getopt-Mixed>.
You can follow or contribute to Getopt::Mixed's development at
<http://github.com/madsen/getopt-mixed>.
Thanks are also due to Andreas Koenig for helping Getopt::Mixed conform
to the standards for Perl modules and for answering a bunch of
questions. Any remaining deficiencies are my fault.
COPYRIGHT AND LICENSE
This software is copyright (c) 1995 by Christopher J. Madsen.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
DISCLAIMER OF WARRANTY
BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT
WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER
PARTIES PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND,
EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
NECESSARY SERVICING, REPAIR, OR CORRECTION.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENSE, BE LIABLE
TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL, OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
perl v5.18.1 2012-08-25 Getopt::Mixed(3)
