diff options
Diffstat (limited to 'debian/patches/0700-getopt_mixed.patch')
| -rw-r--r-- | debian/patches/0700-getopt_mixed.patch | 894 |
1 files changed, 894 insertions, 0 deletions
diff --git a/debian/patches/0700-getopt_mixed.patch b/debian/patches/0700-getopt_mixed.patch new file mode 100644 index 0000000..ccdae8b --- /dev/null +++ b/debian/patches/0700-getopt_mixed.patch @@ -0,0 +1,894 @@ +Description: replace deprecated dependency libgetopt-mixed-perl +Author: Jörg Frings-Fürst <debian@jff-webhosting.net> +Bug: https://github.com/chilts/cil/issues/16 +Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=829577 +Last-Update: 2016-11-20 +--- +This patch header follows DEP-3: http://dep.debian.net/deps/dep3/ +Index: trunk/lib/CIL/Mixed.pm +=================================================================== +--- /dev/null ++++ trunk/lib/CIL/Mixed.pm +@@ -0,0 +1,804 @@ ++#--------------------------------------------------------------------- ++package CIL::Mixed; ++# ++# Copyright 1995 Christopher J. Madsen ++# ++# Author: Christopher J. Madsen <perl@cjmweb.net> ++# Created: 1 Jan 1995 ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the same terms as Perl itself. ++# ++# 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 either the ++# GNU General Public License or the Artistic License for more details. ++# ++# ABSTRACT: [OBSOLETE] getopt processing with both long and short options ++#--------------------------------------------------------------------- ++ ++require 5.000; ++use strict; ++use Carp; ++ ++use vars qw( ++ @EXPORT @EXPORT_OK @ISA %options ++ $PERMUTE $REQUIRE_ORDER $RETURN_IN_ORDER $VERSION ++ $badOption $checkArg $checkType $floatRegexp $group $ignoreCase ++ $intRegexp $option $optionEnd $optionStart $order $typeChars ++); ++ ++require Exporter; ++@ISA = qw(Exporter); ++@EXPORT = (); ++@EXPORT_OK = qw(abortMsg getOptions nextOption); ++ ++#===================================================================== ++# Package Global Variables: ++ ++BEGIN ++{ ++ $VERSION = '1.12'; ++ ++ # The permissible settings for $order: ++ $REQUIRE_ORDER = 0; ++ $PERMUTE = 1; ++ $RETURN_IN_ORDER = 2; ++ ++ # Regular expressions: ++ $intRegexp = '^[-+]?\d+$'; # Match an integer ++ $floatRegexp = '^[-+]?(\d*\.?\d+|\d+\.)$'; # Match a real number ++ $typeChars = 'sif'; # Match type characters ++} # end BEGIN ++ ++#===================================================================== ++# Subroutines: ++#--------------------------------------------------------------------- ++# Initialize the option processor: ++# ++# You should set any customization variables *after* calling init. ++# ++# For a description of option declarations, see the documentation at ++# the end of this file. ++# ++# Input: ++# List of option declarations (separated by whitespace) ++# If the first argument is entirely non-alphanumeric characters ++# with no whitespace, it is the characters that start options. ++ ++sub init ++{ ++ undef %options; ++ my($opt,$type); ++ ++ $ignoreCase = 1; # Ignore case by default ++ $optionStart = "-"; # Dash is the default option starter ++ ++ # If the first argument is entirely non-alphanumeric characters ++ # with no whitespace, it is the desired value for $optionStart: ++ $optionStart = shift @_ if $_[0] =~ /^[^a-z0-9\s]+$/i; ++ ++ foreach $group (@_) { ++ # Ignore case unless there are upper-case options: ++ $ignoreCase = 0 if $group =~ /[A-Z]/; ++ foreach $option (split(/\s+/,$group)) { ++ croak "Invalid option declaration `$option'" ++ unless $option =~ /^([^=:>]+)([=:][$typeChars]|>[^=:>]+)?$/o; ++ $opt = $1; ++ $type = $2 || ""; ++ if ($type =~ /^>(.*)$/) { ++ $type = $1; ++ croak "Invalid synonym `$option'" ++ if (not defined $options{$type} ++ or $options{$type} =~ /^[^:=]/); ++ } # end if synonym ++ $options{$opt} = $type; ++ } # end foreach option ++ } # end foreach group ++ ++ # Handle POSIX compliancy: ++ if (defined $ENV{"POSIXLY_CORRECT"}) { ++ $order = $REQUIRE_ORDER; ++ } else { ++ $order = $PERMUTE; ++ } ++ ++ $optionEnd = 0; ++ $badOption = \&badOption; ++ $checkArg = \&checkArg; ++} # end init ++ ++#--------------------------------------------------------------------- ++# Clean up when we're done: ++# ++# This just releases the memory used by the %options hash. ++# ++# If 'help' was defined as an option, a new hash with just 'help' is ++# created, in case the program calls abortMsg. ++ ++sub cleanup ++{ ++ my $help = defined($options{'help'}); ++ undef %options; ++ $options{'help'} = "" if $help; ++} # end cleanup ++ ++#--------------------------------------------------------------------- ++# Abort program with message: ++# ++# Prints program name and arguments to STDERR ++# If --help is an option, prints message saying 'Try --help' ++# Exits with code 1 ++ ++sub abortMsg ++{ ++ my $name = $0; ++ $name =~ s|^.+[\\/]||; # Remove any directories from name ++ print STDERR $name,": ",@_,"\n"; ++ print STDERR "Try `$name --help' for more information.\n" ++ if defined $options{"help"}; ++ exit 1; ++} # end abortMsg ++ ++#--------------------------------------------------------------------- ++# Standard function for handling bad options: ++# ++# Prints an error message and exits. ++# ++# You can override this by setting $Getopt::Mixed::badOption to a ++# function reference. ++# ++# Input: ++# Index into @ARGV ++# The option that caused the error ++# An optional string describing the problem ++# Currently, this can be ++# undef The option was not recognized ++# 'ambiguous' The option could match several long options ++# ++# Note: ++# The option has already been removed from @ARGV. To put it back, ++# you can say: ++# splice(@ARGV,$_[0],0,$_[1]); ++# ++# If your function returns, it should return whatever you want ++# nextOption to return. ++ ++sub badOption ++{ ++ my ($index, $option, $problem) = @_; ++ ++ $problem = 'unrecognized' unless $problem; ++ ++ abortMsg("$problem option `$option'"); ++} # end badOption ++ ++#--------------------------------------------------------------------- ++# Make sure we have the proper argument for this option: ++# ++# You can override this by setting $Getopt::Mixed::checkArg to a ++# function reference. ++# ++# Input: ++# $i: Position of argument in @ARGV ++# $value: The text appended to the option (undef if no text) ++# $option: The pretty name of the option (as the user typed it) ++# $type: The type of the option ++# ++# Returns: ++# The value of the option's argument ++ ++sub checkArg ++{ ++ my ($i,$value,$option,$type) = @_; ++ ++ abortMsg("option `$option' does not take an argument") ++ if (not $type and defined $value); ++ ++ if ($type =~ /^=/) { ++ # An argument is required for this option: ++ $value = splice(@ARGV,$i,1) unless defined $value; ++ abortMsg("option `$option' requires an argument") ++ unless defined $value; ++ } ++ ++ if ($type =~ /i$/) { ++ abortMsg("option `$option' requires integer argument") ++ if (defined $value and $value !~ /$intRegexp/o); ++ } ++ elsif ($type =~ /f$/) { ++ abortMsg("option `$option' requires numeric argument") ++ if (defined $value and $value !~ /$floatRegexp/o); ++ } ++ elsif ($type =~ /^[=:]/ and ref($checkType)) { ++ $value = &$checkType($i,$value,$option,$type); ++ } ++ ++ $value = "" if not defined $value and $type =~ /^:/; ++ ++ $value; ++} # end checkArg ++ ++#--------------------------------------------------------------------- ++# Find a match for an incomplete long option: ++# ++# Input: ++# The option text to match ++# ++# Returns: ++# The option that matched, or ++# undef, if no option matched, or ++# (undef, 'ambiguous'), if multiple options matched ++ ++sub findMatch ++{ ++ my $opt = shift; ++ ++ $opt =~ s/-/[^-]*-/g; ++ $opt .= ".*"; ++ ++ my @matches = grep(/^$opt$/, keys %options); ++ ++ return undef if $#matches < 0; ++ return $matches[0] if $#matches == 0; ++ ++ $opt = $matches[0]; ++ $opt = $options{$opt} if $options{$opt} =~ /^[^=:]/; ++ ++ foreach (@matches) { ++ return (undef, 'ambiguous') ++ unless $_ eq $opt or $options{$_} eq $opt; ++ } ++ ++ $opt; ++} # end findMatch ++ ++#--------------------------------------------------------------------- ++# Return the next option: ++# ++# Returns a list of 3 elements: (OPTION, VALUE, PRETTYNAME), where ++# OPTION is the name of the option, ++# VALUE is its argument, and ++# PRETTYNAME is the option as the user entered it. ++# Returns the null list if there are no more options to process ++# ++# If $order is $RETURN_IN_ORDER, and this is a normal argument (not an ++# option), OPTION will be the null string, VALUE will be the argument, ++# and PRETTYNAME will be undefined. ++ ++sub nextOption ++{ ++ return () if $#ARGV < 0; # No more arguments ++ ++ if ($optionEnd) { ++ # We aren't processing any more options: ++ return ("", shift @ARGV) if $order == $RETURN_IN_ORDER; ++ return (); ++ } ++ ++ # Find the next option: ++ my $i = 0; ++ while (length($ARGV[$i]) < 2 or ++ index($optionStart,substr($ARGV[$i],0,1)) < 0) { ++ return () if $order == $REQUIRE_ORDER; ++ return ("", shift @ARGV) if $order == $RETURN_IN_ORDER; ++ ++$i; ++ return () if $i > $#ARGV; ++ } # end while ++ ++ # Process the option: ++ my($option,$opt,$value,$optType,$prettyOpt); ++ $option = $ARGV[$i]; ++ if (substr($option,0,1) eq substr($option,1,1)) { ++ # If the option start character is repeated, it's a long option: ++ splice @ARGV,$i,1; ++ if (length($option) == 2) { ++ # A double dash by itself marks the end of the options: ++ $optionEnd = 1; # Don't process any more options ++ return nextOption(); ++ } # end if bare double dash ++ $opt = substr($option,2); ++ if ($opt =~ /^([^=]+)=(.*)$/) { ++ $opt = $1; ++ $value = $2; ++ } # end if option is followed by value ++ $opt =~ tr/A-Z/a-z/ if $ignoreCase; ++ $prettyOpt = substr($option,0,2) . $opt; ++ my $problem; ++ ($opt, $problem) = findMatch($opt) ++ unless defined $options{$opt} and length($opt) > 1; ++ return &$badOption($i,$option,$problem) unless $opt; ++ $optType = $options{$opt}; ++ if ($optType =~ /^[^:=]/) { ++ $opt = $optType; ++ $optType = $options{$opt}; ++ } ++ $value = &$checkArg($i,$value,$prettyOpt,$optType); ++ } # end if long option ++ else { ++ # It's a short option: ++ $opt = substr($option,1,1); ++ $opt =~ tr/A-Z/a-z/ if $ignoreCase; ++ return &$badOption($i,$option) unless defined $options{$opt}; ++ $optType = $options{$opt}; ++ if ($optType =~ /^[^:=]/) { ++ $opt = $optType; ++ $optType = $options{$opt}; ++ } ++ if (length($option) == 2 or $optType) { ++ # This is the last option in the group, so remove the group: ++ splice(@ARGV,$i,1); ++ } else { ++ # Just remove this option from the group: ++ substr($ARGV[$i],1,1) = ""; ++ } ++ if ($optType) { ++ $value = (length($option) > 2) ? substr($option,2) : undef; ++ $value =~ s/^=// if $value; # Allow either -d3 or -d=3 ++ } # end if option takes an argument ++ $prettyOpt = substr($option,0,2); ++ $value = &$checkArg($i,$value,$prettyOpt,$optType); ++ } # end else short option ++ ($opt,$value,$prettyOpt); ++} # end nextOption ++ ++#--------------------------------------------------------------------- ++# Get options: ++# ++# Input: ++# The same as for init() ++# If no parameters are supplied, init() is NOT called. This allows ++# you to call init() yourself and then change the configuration ++# variables. ++# ++# Output Variables: ++# Sets $opt_X for each `-X' option encountered. ++# ++# Note that if --apple is a synonym for -a, then --apple will cause ++# $opt_a to be set, not $opt_apple. ++ ++sub getOptions ++{ ++ &init if $#_ >= 0; # Pass arguments (if any) on to init ++ ++ # If you want to use $RETURN_IN_ORDER, you have to call ++ # nextOption yourself; getOptions doesn't support it: ++ $order = $PERMUTE if $order == $RETURN_IN_ORDER; ++ ++ my ($option,$value,$package); ++ ++ $package = (caller)[0]; ++ ++ while (($option, $value) = nextOption()) { ++ $option =~ s/\W/_/g; # Make a legal Perl identifier ++ $value = 1 unless defined $value; ++ my $code = "\$" . $package . "::opt_$option = \$value;"; ++ $code =~ /(.+)/; # Untaint it ++ eval $1; ++ } # end while ++ ++ cleanup(); ++} # end getOptions ++ ++#===================================================================== ++# Package return value: ++ ++$VERSION; ++ ++__END__ ++ ++=head1 NAME ++ ++Getopt::Mixed - [OBSOLETE] getopt processing with both long and short options ++ ++=head1 VERSION ++ ++This document describes version 1.12 of ++Getopt::Mixed, released February 8, 2014. ++ ++=head1 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(); ++ ++=head1 DESCRIPTION ++ ++B<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 C<->) and long options (introduced by C<-->). ++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. ++ ++=head2 Option Descriptions ++ ++The option-description arguments required by C<init> and C<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, C<=>, C<:>, and C<E<gt>>. ++ ++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 C<E<gt>> 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 B<-a> as an option that requires an ++integer argument and B<--apples> as a synonym for B<-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 C<init> or C<getOptions> is entirely ++non-alphanumeric characters with no whitespace, it represents the ++characters which can begin options. ++ ++=head2 User Interface ++ ++From the user's perspective, short options are introduced by a dash ++(C<->) and long options are introduced by a double dash (C<-->). ++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, I<not> an option. ++ ++Long options may be abbreviated. An option B<--all-the-time> could be ++abbreviated B<--all>, B<--a--tim>, or even B<--a>. Note that B<--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, B<-i> and B<--int> take integer arguments, ++B<-f> and B<--float> take floating point arguments, and B<-s> and ++B<--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 C<=>, whatever follows the C<=> ++I<is> the argument, even if it's the null string. In the example ++ ++ -i= 24 -f= 24.5 -s= Hello ++ ++B<-i> and B<-f> will cause an error, because the null string is not a ++number, but B<-s> is perfectly legal; its argument is the null string, ++not "Hello". ++ ++Remember that optional arguments I<cannot> be separated from the ++option by whitespace. ++ ++=head2 The Simple Method ++ ++The simple method is ++ ++ use Getopt::Mixed; ++ Getopt::Mixed::getOptions(...option-descriptions...); ++ ++You then examine the C<$opt_*> variables to find out what options were ++specified and the C<@ARGV> array to see what arguments are left. ++ ++If B<-a> is an option that doesn't take an argument, then C<$opt_a> ++will be set to 1 if the option is present, or left undefined if the ++option is not present. ++ ++If B<-b> is an option that takes an argument, then C<$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, C<$opt_b> will be set to the null string. ++ ++Note that even if you specify that an option I<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 (C<_>). ++ ++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. ++ ++=head2 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 C<@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. ++ ++=head1 OTHER FUNCTIONS ++ ++Getopt::Mixed provides one other function you can use. C<abortMsg> ++prints its arguments on STDERR, plus your program's name and a ++newline. It then exits with status 1. For example, if F<foo.pl> ++calls C<abortMsg> like this: ++ ++ Getopt::Mixed::abortMsg("Error"); ++ ++The output will be: ++ ++ foo.pl: Error ++ ++=head1 CUSTOMIZATION ++ ++There are several customization variables you can set. All of these ++variables should be set I<after> calling Getopt::Mixed::init and ++I<before> calling nextOption. ++ ++If you set any of these variables, you I<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 ++ ++=over 4 ++ ++=item $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. ++ ++=item $ignoreCase ++ ++Ignore case when matching options. Default is 1 unless the option ++descriptions contain an upper-case letter. ++ ++=item $optionStart ++ ++A string of characters that can start options. Default is "-". ++ ++=item $badOption ++ ++A reference to a function that is called when an unrecognized option ++is encountered. The function receives three arguments. C<$_[0]> is the ++position in C<@ARGV> where the option came from. C<$_[1]> is the option as ++the user typed it (including the option start character). C<$_[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 C<@ARGV>. To put it back, you can say: ++ ++ splice(@ARGV,$_[0],0,$_[1]); ++ ++The function can do anything you want to C<@ARGV>. It should return ++whatever you want nextOption to return. ++ ++The default is a function that prints an error message and exits the ++program. ++ ++=item $checkArg ++ ++A reference to a function that is called to make sure the argument ++type is correct. The function receives four arguments. C<$_[0]> is the ++position in C<@ARGV> where the option came from. C<$_[1]> is the text ++following the option, or undefined if there was no text following the ++option. C<$_[2]> is the name of the option as the user typed it ++(including the option start character), suitable for error messages. ++C<$_[3]> is the argument type specifier. ++ ++The function can do anything you want to C<@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 ++C<$intRegexp> or C<$floatRegexp>. ++ ++=item $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. ++ ++=item $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. ++ ++=item $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 I<before> calling init(), and cannot be ++changed afterwards. ++ ++=item $checkType ++ ++If you add new types to C<$typeChars>, you should set this to a function ++which will check arguments of the new types. ++ ++=back ++ ++=head1 SEE ALSO ++ ++L<Getopt::Long> ++ ++=head1 CONFIGURATION AND ENVIRONMENT ++ ++Getopt::Mixed requires no configuration files or environment variables. ++ ++=head1 INCOMPATIBILITIES ++ ++None reported. ++ ++=head1 BUGS AND LIMITATIONS ++ ++=over 4 ++ ++=item * ++ ++This document should be expanded. ++ ++=item * ++ ++A long option must be at least two characters long. Sorry. ++ ++=item * ++ ++The C<!> argument specifier of Getopt::Long is not supported, but you ++could have options B<--foo> and B<--nofoo> and then do something like: ++ ++ $opt_foo = 0 if $opt_nofoo; ++ ++=item * ++ ++The C<@> 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. ++ ++=back ++ ++=head1 AUTHOR ++ ++Christopher J. Madsen S<C<< <perl AT cjmweb.net> >>> ++ ++Please report any bugs or feature requests ++to S<C<< <bug-Getopt-Mixed AT rt.cpan.org> >>> ++or through the web interface at ++L<< http://rt.cpan.org/Public/Bug/Report.html?Queue=Getopt-Mixed >>. ++ ++You can follow or contribute to Getopt::Mixed's development at ++L<< 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. ++ ++=head1 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. ++ ++=head1 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. ++ ++=cut +Index: trunk/Build.PL +=================================================================== +--- trunk.orig/Build.PL ++++ trunk/Build.PL +@@ -21,7 +21,6 @@ my $builder = Module::Build->new( + 'File::Spec' => 0, + 'File::Temp' => 0, + 'File::Touch' => 0, +- 'Getopt::Mixed' => 0, + 'MIME::Base64' => 0, + 'Test::More' => 0, + }, +Index: trunk/MANIFEST +=================================================================== +--- trunk.orig/MANIFEST ++++ trunk/MANIFEST +@@ -10,6 +10,7 @@ lib/CIL/Base.pm + lib/CIL/Comment.pm + lib/CIL/Issue.pm + lib/CIL/Utils.pm ++lib/CIL/Mixed.pm + MANIFEST This list of files + README + t/00_files.t +Index: trunk/bin/cil +=================================================================== +--- trunk.orig/bin/cil ++++ trunk/bin/cil +@@ -20,7 +20,7 @@ + use strict; + use warnings; + +-use Getopt::Mixed "nextOption"; ++#use Getopt::Mixed "nextOption"; + use File::Touch; + use File::Glob ':glob'; + use File::Basename; +@@ -33,6 +33,7 @@ use CIL::Issue; + use CIL::Comment; + use CIL::Attachment; + use CIL::Utils; ++use CIL::Mixed "nextOption"; + + ## ---------------------------------------------------------------------------- + # constants +@@ -100,12 +101,12 @@ my %BOOLEAN_ARGS = ( + } + + # make sure that the command given is valid +- Getopt::Mixed::abortMsg('specify a command') ++ CIL::Mixed::abortMsg('specify a command') + if @ARGV == 0; + + my $command_name = shift @ARGV; + my( $command ) = grep { $command_name eq $_->name } CIL->commands +- or Getopt::Mixed::abortMsg("'$command_name' is not a valid cil command."); ++ or CIL::Mixed::abortMsg("'$command_name' is not a valid cil command."); + + # make a new $cil object + my $cil = CIL->new(); +@@ -136,7 +137,7 @@ sub get_options { + my ($in_opts, $booleans) = @_; + + my $args = {}; +- Getopt::Mixed::init( @$in_opts ); ++ CIL::Mixed::init( @$in_opts ); + while( my($opt, $val) = nextOption() ) { + # if boolean, keep a count of how many there is only + if ( exists $booleans->{$opt} ) { +@@ -154,7 +155,7 @@ sub get_options { + $args->{$opt} = $val; + } + } +- Getopt::Mixed::cleanup(); ++ CIL::Mixed::cleanup(); + return $args; + } + |