Ubuntu Manpage: Getopt::Mixed - [OBSOLETE] getopt processing with both long and short options

NAME

       Getopt::Mixed - [OBSOLETE] getopt processing with both long and short options

VERSION

       This document describes version 1.12 of Getopt::Mixed, released February 8, 2014.

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, years 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 2.17; # Released with Perl 5.005
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 FUNCTIONS

       Getopt::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 ENVIRONMENT

       Getopt::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.40.0                                       2025-01-02                                    CIL::Mixed(3pm)