- added a necessary support library for jsDriver.pl
authorkdecker <kdecker@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 14 Jul 2004 00:57:30 +0000 (00:57 +0000)
committerkdecker <kdecker@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 14 Jul 2004 00:57:30 +0000 (00:57 +0000)
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@7020 268f45cc-cd09-0410-ab3c-d52691b4dbfc

JavaScriptCore/tests/mozilla/Getopt/Mixed.pm [new file with mode: 0644]

diff --git a/JavaScriptCore/tests/mozilla/Getopt/Mixed.pm b/JavaScriptCore/tests/mozilla/Getopt/Mixed.pm
new file mode 100644 (file)
index 0000000..06d4fdc
--- /dev/null
@@ -0,0 +1,754 @@
+#---------------------------------------------------------------------
+package Getopt::Mixed;
+#
+# Copyright 1995 Christopher J. Madsen
+#
+# Author: Christopher J. Madsen <ac608@yfn.ysu.edu>
+# Created: 1 Jan 1995
+# Version: $Revision$ ($Date$)
+#    Note that RCS revision 1.23 => $Getopt::Mixed::VERSION = "1.023"
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# 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 the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Perl; see the file COPYING.  If not, write to the
+# Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# Process both single-character and extended options
+#---------------------------------------------------------------------
+
+require 5.000;
+use Carp;
+
+require Exporter;
+@ISA = qw(Exporter);
+@EXPORT = ();
+@EXPORT_OK = qw(abortMsg getOptions nextOption);
+
+#=====================================================================
+# Package Global Variables:
+
+BEGIN
+{
+    # 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
+
+    # Convert RCS revision number (must be main branch) to d.ddd format:
+    ' $Revision$ ' =~ / (\d+)\.(\d{1,3}) /
+        or die "Invalid version number";
+    $VERSION = sprintf("%d.%03d",$1,$2);
+} # 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;
+        eval("\$" . $package . '::opt_' . $option . ' = $value;');
+    } # end while
+
+    cleanup();
+} # end getOptions
+
+#=====================================================================
+# Package return value:
+
+$VERSION;
+
+__END__
+
+=head1 NAME
+
+Getopt::Mixed - getopt processing with both long and short options
+
+=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
+
+This package is my response to the standard modules Getopt::Std and
+Getopt::Long.  C<Std> doesn't support long options, and C<Long>
+doesn't support short options.  I wanted both, since long options are
+easier to remember and short options are faster to type.
+
+This package is 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 @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.  $_[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.
+
+=item $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.
+
+=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 $typeChars, you should set this to a function
+which will check arguments of the new types.
+
+=back
+
+=head1 BUGS
+
+=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 LICENSE
+
+Getopt::Mixed is distributed under the terms of the GNU General Public
+License as published by the Free Software Foundation; either version
+2, or (at your option) any later version.
+
+This means it is distributed in the hope that it will be useful, but
+I<without any warranty>; without even the implied warranty of
+I<merchantability> or I<fitness for a particular purpose>.  See the
+GNU General Public License for more details.
+
+Since Perl scripts are only compiled at runtime, and simply calling
+Getopt::Mixed does I<not> bring your program under the GPL, the only
+real restriction is that you can't use Getopt::Mixed in an
+binary-only distribution produced with C<dump> (unless you also
+provide source code).
+
+=head1 AUTHOR
+
+Christopher J. Madsen E<lt>F<ac608@yfn.ysu.edu>E<gt>
+
+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.
+
+=cut