From 4ef66ec7f6fed48e8e3a496bcf746c0998e47a3b Mon Sep 17 00:00:00 2001 From: Ole Tange Date: Sat, 7 Mar 2015 17:49:16 +0100 Subject: [PATCH] testsuite for 2GB issues on some Perl versions. Memory heavy jobs (>2 GB) moved to parallel-local-mem.sh. Passes testsuite. --- src/parallel | 2 +- testsuite/Makefile | 8 + .../perl-v5.14.2/lib/AutoLoader.pm | 429 +++ .../input-files/perl-v5.14.2/lib/Carp.pm | 578 ++++ .../perl-v5.14.2/lib/Carp/Heavy.pm | 10 + .../input-files/perl-v5.14.2/lib/Config.pm | 110 + testsuite/input-files/perl-v5.14.2/lib/Cwd.pm | 831 ++++++ .../perl-v5.14.2/lib/DynaLoader.pm | 753 +++++ .../input-files/perl-v5.14.2/lib/Errno.pm | 283 ++ .../input-files/perl-v5.14.2/lib/Exporter.pm | 587 ++++ .../perl-v5.14.2/lib/Exporter/Heavy.pm | 248 ++ .../input-files/perl-v5.14.2/lib/Fcntl.pm | 186 ++ .../perl-v5.14.2/lib/File/Basename.pm | 402 +++ .../input-files/perl-v5.14.2/lib/File/Glob.pm | 437 +++ .../input-files/perl-v5.14.2/lib/File/Path.pm | 981 ++++++ .../input-files/perl-v5.14.2/lib/File/Spec.pm | 337 +++ .../perl-v5.14.2/lib/File/Spec/Unix.pm | 521 ++++ .../input-files/perl-v5.14.2/lib/File/Temp.pm | 2452 +++++++++++++++ .../perl-v5.14.2/lib/FileHandle.pm | 262 ++ .../perl-v5.14.2/lib/Getopt/Long.pm | 2649 +++++++++++++++++ testsuite/input-files/perl-v5.14.2/lib/IO.pm | 68 + .../input-files/perl-v5.14.2/lib/IO/File.pm | 204 ++ .../input-files/perl-v5.14.2/lib/IO/Handle.pm | 646 ++++ .../perl-v5.14.2/lib/IO/Seekable.pm | 128 + .../input-files/perl-v5.14.2/lib/IPC/Open3.pm | 421 +++ .../input-files/perl-v5.14.2/lib/POSIX.pm | 1037 +++++++ .../perl-v5.14.2/lib/SelectSaver.pm | 54 + .../input-files/perl-v5.14.2/lib/Symbol.pm | 170 ++ .../input-files/perl-v5.14.2/lib/Tie/Hash.pm | 268 ++ .../perl-v5.14.2/lib/Time/HiRes.pm | 591 ++++ .../input-files/perl-v5.14.2/lib/XSLoader.pm | 352 +++ .../perl-v5.14.2/lib/auto/Cwd/Cwd.bs | 0 .../perl-v5.14.2/lib/auto/Cwd/Cwd.so | Bin 0 -> 13723 bytes .../perl-v5.14.2/lib/auto/Fcntl/Fcntl.bs | 0 .../perl-v5.14.2/lib/auto/Fcntl/Fcntl.so | Bin 0 -> 22335 bytes .../perl-v5.14.2/lib/auto/File/Glob/Glob.bs | 0 .../perl-v5.14.2/lib/auto/File/Glob/Glob.so | Bin 0 -> 27987 bytes .../perl-v5.14.2/lib/auto/IO/IO.bs | 0 .../perl-v5.14.2/lib/auto/IO/IO.so | Bin 0 -> 23184 bytes .../perl-v5.14.2/lib/auto/POSIX/POSIX.bs | 0 .../perl-v5.14.2/lib/auto/POSIX/POSIX.so | Bin 0 -> 120535 bytes .../perl-v5.14.2/lib/auto/POSIX/autosplit.ix | 173 ++ .../lib/auto/POSIX/load_imports.al | 231 ++ .../perl-v5.14.2/lib/auto/Time/HiRes/.exists | 0 .../perl-v5.14.2/lib/auto/Time/HiRes/HiRes.bs | 0 .../perl-v5.14.2/lib/auto/Time/HiRes/HiRes.so | Bin 0 -> 31873 bytes .../input-files/perl-v5.14.2/lib/base.pm | 265 ++ .../input-files/perl-v5.14.2/lib/constant.pm | 397 +++ .../input-files/perl-v5.14.2/lib/feature.pm | 249 ++ .../input-files/perl-v5.14.2/lib/overload.pm | 1701 +++++++++++ .../input-files/perl-v5.14.2/lib/strict.pm | 147 + .../input-files/perl-v5.14.2/lib/vars.pm | 82 + .../input-files/perl-v5.14.2/lib/warnings.pm | 567 ++++ .../perl-v5.14.2/lib/warnings/register.pm | 48 + testsuite/input-files/perl-v5.14.2/perl | Bin 0 -> 1477231 bytes testsuite/tests-to-run/niceload01.sh | 3 +- testsuite/tests-to-run/parallel-local-mem.sh | 39 + testsuite/tests-to-run/parallel-local114.sh | 6 - testsuite/tests-to-run/parallel-local19.sh | 6 - testsuite/tests-to-run/parallel-local22.sh | 2 +- testsuite/tests-to-run/parallel-local5.sh | 6 - testsuite/wanted-results/parallel-local-mem | 46 + testsuite/wanted-results/parallel-local114 | 9 - testsuite/wanted-results/parallel-local19 | 5 - testsuite/wanted-results/parallel-local22 | 4 +- testsuite/wanted-results/parallel-local4 | 2 +- testsuite/wanted-results/parallel-local5 | 5 - 67 files changed, 19955 insertions(+), 43 deletions(-) create mode 100644 testsuite/input-files/perl-v5.14.2/lib/AutoLoader.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Carp.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Carp/Heavy.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Config.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Cwd.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/DynaLoader.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Errno.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Exporter.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Exporter/Heavy.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Fcntl.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/File/Basename.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/File/Glob.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/File/Path.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/File/Spec.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/File/Spec/Unix.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/File/Temp.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/FileHandle.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Getopt/Long.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/IO.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/IO/File.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/IO/Handle.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/IO/Seekable.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/IPC/Open3.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/POSIX.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/SelectSaver.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Symbol.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Tie/Hash.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/Time/HiRes.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/XSLoader.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/Cwd/Cwd.bs create mode 100755 testsuite/input-files/perl-v5.14.2/lib/auto/Cwd/Cwd.so create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/Fcntl/Fcntl.bs create mode 100755 testsuite/input-files/perl-v5.14.2/lib/auto/Fcntl/Fcntl.so create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/File/Glob/Glob.bs create mode 100755 testsuite/input-files/perl-v5.14.2/lib/auto/File/Glob/Glob.so create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/IO/IO.bs create mode 100755 testsuite/input-files/perl-v5.14.2/lib/auto/IO/IO.so create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/POSIX.bs create mode 100755 testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/POSIX.so create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/autosplit.ix create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/load_imports.al create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/.exists create mode 100644 testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/HiRes.bs create mode 100755 testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/HiRes.so create mode 100644 testsuite/input-files/perl-v5.14.2/lib/base.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/constant.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/feature.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/overload.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/strict.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/vars.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/warnings.pm create mode 100644 testsuite/input-files/perl-v5.14.2/lib/warnings/register.pm create mode 100755 testsuite/input-files/perl-v5.14.2/perl create mode 100644 testsuite/tests-to-run/parallel-local-mem.sh create mode 100644 testsuite/wanted-results/parallel-local-mem diff --git a/src/parallel b/src/parallel index 000c956e..84d0e030 100755 --- a/src/parallel +++ b/src/parallel @@ -1052,7 +1052,7 @@ sub parse_options { sub init_globals { # Defaults: - $Global::version = 20150305; + $Global::version = 20150306; $Global::progname = 'parallel'; $Global::infinity = 2**31; $Global::debug = 0; diff --git a/testsuite/Makefile b/testsuite/Makefile index 5add6ec6..f3b7eed9 100644 --- a/testsuite/Makefile +++ b/testsuite/Makefile @@ -82,3 +82,11 @@ timings: tests-to-run/* ../src/parallel stdout bash -x /tmp/timing.script | tee /tmp/timing.out echo + .usr.bin.time_END >>/tmp/timing.out perl -ne '/\+ .usr.bin.time/ and do { print $$last.$$h; $$h=$$_ }; chomp; s/.*\0//;$$last = $$_' /tmp/timing.out |sort -n >timings + +timingbar: + vmstat 1 | timestamp --iso > vmstat.timestamp.1 & + stdout make 1 | timestamp --iso | tee make.timestamp.1 + killall vmstat + mv vmstat.timestamp.1 vmstat.timestamp + mv make.timestamp.1 make.timestamp + sort vmstat.timestamp make.timestamp | perl -pe '/tests-to-run(\S+)/ and $$p=$$1; print "$$p "' | field 6,1,2 | perl -ne '/^\d+ / and print' | histogram -i vh diff --git a/testsuite/input-files/perl-v5.14.2/lib/AutoLoader.pm b/testsuite/input-files/perl-v5.14.2/lib/AutoLoader.pm new file mode 100644 index 00000000..d7c99514 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/AutoLoader.pm @@ -0,0 +1,429 @@ +package AutoLoader; + +use strict; +use 5.006_001; + +our($VERSION, $AUTOLOAD); + +my $is_dosish; +my $is_epoc; +my $is_vms; +my $is_macos; + +BEGIN { + $is_dosish = $^O eq 'dos' || $^O eq 'os2' || $^O eq 'MSWin32' || $^O eq 'NetWare'; + $is_epoc = $^O eq 'epoc'; + $is_vms = $^O eq 'VMS'; + $is_macos = $^O eq 'MacOS'; + $VERSION = '5.71'; +} + +AUTOLOAD { + my $sub = $AUTOLOAD; + my $filename = AutoLoader::find_filename( $sub ); + + my $save = $@; + local $!; # Do not munge the value. + eval { local $SIG{__DIE__}; require $filename }; + if ($@) { + if (substr($sub,-9) eq '::DESTROY') { + no strict 'refs'; + *$sub = sub {}; + $@ = undef; + } elsif ($@ =~ /^Can't locate/) { + # The load might just have failed because the filename was too + # long for some old SVR3 systems which treat long names as errors. + # If we can successfully truncate a long name then it's worth a go. + # There is a slight risk that we could pick up the wrong file here + # but autosplit should have warned about that when splitting. + if ($filename =~ s/(\w{12,})\.al$/substr($1,0,11).".al"/e){ + eval { local $SIG{__DIE__}; require $filename }; + } + } + if ($@){ + $@ =~ s/ at .*\n//; + my $error = $@; + require Carp; + Carp::croak($error); + } + } + $@ = $save; + goto &$sub; +} + +sub find_filename { + my $sub = shift; + my $filename; + # Braces used to preserve $1 et al. + { + # Try to find the autoloaded file from the package-qualified + # name of the sub. e.g., if the sub needed is + # Getopt::Long::GetOptions(), then $INC{Getopt/Long.pm} is + # something like '/usr/lib/perl5/Getopt/Long.pm', and the + # autoload file is '/usr/lib/perl5/auto/Getopt/Long/GetOptions.al'. + # + # However, if @INC is a relative path, this might not work. If, + # for example, @INC = ('lib'), then $INC{Getopt/Long.pm} is + # 'lib/Getopt/Long.pm', and we want to require + # 'auto/Getopt/Long/GetOptions.al' (without the leading 'lib'). + # In this case, we simple prepend the 'auto/' and let the + # C take care of the searching for us. + + my ($pkg,$func) = ($sub =~ /(.*)::([^:]+)$/); + $pkg =~ s#::#/#g; + if (defined($filename = $INC{"$pkg.pm"})) { + if ($is_macos) { + $pkg =~ tr#/#:#; + $filename = undef + unless $filename =~ s#^(.*)$pkg\.pm\z#$1auto:$pkg:$func.al#s; + } else { + $filename = undef + unless $filename =~ s#^(.*)$pkg\.pm\z#$1auto/$pkg/$func.al#s; + } + + # if the file exists, then make sure that it is a + # a fully anchored path (i.e either '/usr/lib/auto/foo/bar.al', + # or './lib/auto/foo/bar.al'. This avoids C searching + # (and failing) to find the 'lib/auto/foo/bar.al' because it + # looked for 'lib/lib/auto/foo/bar.al', given @INC = ('lib'). + + if (defined $filename and -r $filename) { + unless ($filename =~ m|^/|s) { + if ($is_dosish) { + unless ($filename =~ m{^([a-z]:)?[\\/]}is) { + if ($^O ne 'NetWare') { + $filename = "./$filename"; + } else { + $filename = "$filename"; + } + } + } + elsif ($is_epoc) { + unless ($filename =~ m{^([a-z?]:)?[\\/]}is) { + $filename = "./$filename"; + } + } + elsif ($is_vms) { + # XXX todo by VMSmiths + $filename = "./$filename"; + } + elsif (!$is_macos) { + $filename = "./$filename"; + } + } + } + else { + $filename = undef; + } + } + unless (defined $filename) { + # let C do the searching + $filename = "auto/$sub.al"; + $filename =~ s#::#/#g; + } + } + return $filename; +} + +sub import { + my $pkg = shift; + my $callpkg = caller; + + # + # Export symbols, but not by accident of inheritance. + # + + if ($pkg eq 'AutoLoader') { + if ( @_ and $_[0] =~ /^&?AUTOLOAD$/ ) { + no strict 'refs'; + *{ $callpkg . '::AUTOLOAD' } = \&AUTOLOAD; + } + } + + # + # Try to find the autosplit index file. Eg., if the call package + # is POSIX, then $INC{POSIX.pm} is something like + # '/usr/local/lib/perl5/POSIX.pm', and the autosplit index file is in + # '/usr/local/lib/perl5/auto/POSIX/autosplit.ix', so we require that. + # + # However, if @INC is a relative path, this might not work. If, + # for example, @INC = ('lib'), then + # $INC{POSIX.pm} is 'lib/POSIX.pm', and we want to require + # 'auto/POSIX/autosplit.ix' (without the leading 'lib'). + # + + (my $calldir = $callpkg) =~ s#::#/#g; + my $path = $INC{$calldir . '.pm'}; + if (defined($path)) { + # Try absolute path name, but only eval it if the + # transformation from module path to autosplit.ix path + # succeeded! + my $replaced_okay; + if ($is_macos) { + (my $malldir = $calldir) =~ tr#/#:#; + $replaced_okay = ($path =~ s#^(.*)$malldir\.pm\z#$1auto:$malldir:autosplit.ix#s); + } else { + $replaced_okay = ($path =~ s#^(.*)$calldir\.pm\z#$1auto/$calldir/autosplit.ix#); + } + + eval { require $path; } if $replaced_okay; + # If that failed, try relative path with normal @INC searching. + if (!$replaced_okay or $@) { + $path ="auto/$calldir/autosplit.ix"; + eval { require $path; }; + } + if ($@) { + my $error = $@; + require Carp; + Carp::carp($error); + } + } +} + +sub unimport { + my $callpkg = caller; + + no strict 'refs'; + + for my $exported (qw( AUTOLOAD )) { + my $symname = $callpkg . '::' . $exported; + undef *{ $symname } if \&{ $symname } == \&{ $exported }; + *{ $symname } = \&{ $symname }; + } +} + +1; + +__END__ + +=head1 NAME + +AutoLoader - load subroutines only on demand + +=head1 SYNOPSIS + + package Foo; + use AutoLoader 'AUTOLOAD'; # import the default AUTOLOAD subroutine + + package Bar; + use AutoLoader; # don't import AUTOLOAD, define our own + sub AUTOLOAD { + ... + $AutoLoader::AUTOLOAD = "..."; + goto &AutoLoader::AUTOLOAD; + } + +=head1 DESCRIPTION + +The B module works with the B module and the +C<__END__> token to defer the loading of some subroutines until they are +used rather than loading them all at once. + +To use B, the author of a module has to place the +definitions of subroutines to be autoloaded after an C<__END__> token. +(See L.) The B module can then be run manually to +extract the definitions into individual files F. + +B implements an AUTOLOAD subroutine. When an undefined +subroutine in is called in a client module of B, +B's AUTOLOAD subroutine attempts to locate the subroutine in a +file with a name related to the location of the file from which the +client module was read. As an example, if F is located in +F, B will look for perl +subroutines B in F, where +the C<.al> file has the same name as the subroutine, sans package. If +such a file exists, AUTOLOAD will read and evaluate it, +thus (presumably) defining the needed subroutine. AUTOLOAD will then +C the newly defined subroutine. + +Once this process completes for a given function, it is defined, so +future calls to the subroutine will bypass the AUTOLOAD mechanism. + +=head2 Subroutine Stubs + +In order for object method lookup and/or prototype checking to operate +correctly even when methods have not yet been defined it is necessary to +"forward declare" each subroutine (as in C). See +L. Such forward declaration creates "subroutine +stubs", which are place holders with no code. + +The AutoSplit and B modules automate the creation of forward +declarations. The AutoSplit module creates an 'index' file containing +forward declarations of all the AutoSplit subroutines. When the +AutoLoader module is 'use'd it loads these declarations into its callers +package. + +Because of this mechanism it is important that B is always +Cd and not Cd. + +=head2 Using B's AUTOLOAD Subroutine + +In order to use B's AUTOLOAD subroutine you I +explicitly import it: + + use AutoLoader 'AUTOLOAD'; + +=head2 Overriding B's AUTOLOAD Subroutine + +Some modules, mainly extensions, provide their own AUTOLOAD subroutines. +They typically need to check for some special cases (such as constants) +and then fallback to B's AUTOLOAD for the rest. + +Such modules should I import B's AUTOLOAD subroutine. +Instead, they should define their own AUTOLOAD subroutines along these +lines: + + use AutoLoader; + use Carp; + + sub AUTOLOAD { + my $sub = $AUTOLOAD; + (my $constname = $sub) =~ s/.*:://; + my $val = constant($constname, @_ ? $_[0] : 0); + if ($! != 0) { + if ($! =~ /Invalid/ || $!{EINVAL}) { + $AutoLoader::AUTOLOAD = $sub; + goto &AutoLoader::AUTOLOAD; + } + else { + croak "Your vendor has not defined constant $constname"; + } + } + *$sub = sub { $val }; # same as: eval "sub $sub { $val }"; + goto &$sub; + } + +If any module's own AUTOLOAD subroutine has no need to fallback to the +AutoLoader's AUTOLOAD subroutine (because it doesn't have any AutoSplit +subroutines), then that module should not use B at all. + +=head2 Package Lexicals + +Package lexicals declared with C in the main block of a package +using B will not be visible to auto-loaded subroutines, due to +the fact that the given scope ends at the C<__END__> marker. A module +using such variables as package globals will not work properly under the +B. + +The C pragma (see L) may be used in such +situations as an alternative to explicitly qualifying all globals with +the package namespace. Variables pre-declared with this pragma will be +visible to any autoloaded routines (but will not be invisible outside +the package, unfortunately). + +=head2 Not Using AutoLoader + +You can stop using AutoLoader by simply + + no AutoLoader; + +=head2 B vs. B + +The B is similar in purpose to B: both delay the +loading of subroutines. + +B uses the C<__DATA__> marker rather than C<__END__>. +While this avoids the use of a hierarchy of disk files and the +associated open/close for each routine loaded, B suffers a +startup speed disadvantage in the one-time parsing of the lines after +C<__DATA__>, after which routines are cached. B can also +handle multiple packages in a file. + +B only reads code as it is requested, and in many cases +should be faster, but requires a mechanism like B be used to +create the individual files. L will invoke +B automatically if B is used in a module source +file. + +=head1 CAVEATS + +AutoLoaders prior to Perl 5.002 had a slightly different interface. Any +old modules which use B should be changed to the new calling +style. Typically this just means changing a require to a use, adding +the explicit C<'AUTOLOAD'> import if needed, and removing B +from C<@ISA>. + +On systems with restrictions on file name length, the file corresponding +to a subroutine may have a shorter name that the routine itself. This +can lead to conflicting file names. The I package warns of +these potential conflicts when used to split a module. + +AutoLoader may fail to find the autosplit files (or even find the wrong +ones) in cases where C<@INC> contains relative paths, B the program +does C. + +=head1 SEE ALSO + +L - an autoloader that doesn't use external files. + +=head1 AUTHOR + +C is maintained by the perl5-porters. Please direct +any questions to the canonical mailing list. Anything that +is applicable to the CPAN release can be sent to its maintainer, +though. + +Author and Maintainer: The Perl5-Porters + +Maintainer of the CPAN release: Steffen Mueller + +=head1 COPYRIGHT AND LICENSE + +This package has been part of the perl core since the first release +of perl5. It has been released separately to CPAN so older installations +can benefit from bug fixes. + +This package has the same copyright and license as the perl core: + + Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + by Larry Wall and others + + All rights reserved. + + This program is free software; you can redistribute it and/or modify + it under the terms of either: + + a) the GNU General Public License as published by the Free + Software Foundation; either version 1, or (at your option) any + later version, or + + b) the "Artistic License" which comes with this Kit. + + 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. + + You should have received a copy of the Artistic License with this + Kit, in the file named "Artistic". If not, I'll be glad to provide one. + + You should also have received a copy of the GNU General Public License + along with this program in the file named "Copying". If not, write to the + Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307, USA or visit their web page on the internet at + http://www.gnu.org/copyleft/gpl.html. + + For those of you that choose to use the GNU General Public License, + my interpretation of the GNU General Public License is that no Perl + script falls under the terms of the GPL unless you explicitly put + said script under the terms of the GPL yourself. Furthermore, any + object code linked with perl does not automatically fall under the + terms of the GPL, provided such object code only adds definitions + of subroutines and variables, and does not otherwise impair the + resulting interpreter from executing any standard Perl script. I + consider linking in C subroutines in this manner to be the moral + equivalent of defining subroutines in the Perl language itself. You + may sell such an object file as proprietary provided that you provide + or offer to provide the Perl source, as specified by the GNU General + Public License. (This is merely an alternate way of specifying input + to the program.) You may also sell a binary produced by the dumping of + a running Perl script that belongs to you, provided that you provide or + offer to provide the Perl source as specified by the GPL. (The + fact that a Perl interpreter and your code are in the same binary file + is, in this case, a form of mere aggregation.) This is my interpretation + of the GPL. If you still have concerns or difficulties understanding + my intent, feel free to contact me. Of course, the Artistic License + spells all this out for your protection, so you may prefer to use that. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/Carp.pm b/testsuite/input-files/perl-v5.14.2/lib/Carp.pm new file mode 100644 index 00000000..77fc2a1e --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Carp.pm @@ -0,0 +1,578 @@ +package Carp; + +use strict; +use warnings; + +our $VERSION = '1.20'; + +our $MaxEvalLen = 0; +our $Verbose = 0; +our $CarpLevel = 0; +our $MaxArgLen = 64; # How much of each argument to print. 0 = all. +our $MaxArgNums = 8; # How many arguments to print. 0 = all. + +require Exporter; +our @ISA = ('Exporter'); +our @EXPORT = qw(confess croak carp); +our @EXPORT_OK = qw(cluck verbose longmess shortmess); +our @EXPORT_FAIL = qw(verbose); # hook to enable verbose mode + +# The members of %Internal are packages that are internal to perl. +# Carp will not report errors from within these packages if it +# can. The members of %CarpInternal are internal to Perl's warning +# system. Carp will not report errors from within these packages +# either, and will not report calls *to* these packages for carp and +# croak. They replace $CarpLevel, which is deprecated. The +# $Max(EvalLen|(Arg(Len|Nums)) variables are used to specify how the eval +# text and function arguments should be formatted when printed. + +our %CarpInternal; +our %Internal; + +# disable these by default, so they can live w/o require Carp +$CarpInternal{Carp}++; +$CarpInternal{warnings}++; +$Internal{Exporter}++; +$Internal{'Exporter::Heavy'}++; + +# if the caller specifies verbose usage ("perl -MCarp=verbose script.pl") +# then the following method will be called by the Exporter which knows +# to do this thanks to @EXPORT_FAIL, above. $_[1] will contain the word +# 'verbose'. + +sub export_fail { shift; $Verbose = shift if $_[0] eq 'verbose'; @_ } + +sub _cgc { + no strict 'refs'; + return \&{"CORE::GLOBAL::caller"} if defined &{"CORE::GLOBAL::caller"}; + return; +} + +sub longmess { + # Icky backwards compatibility wrapper. :-( + # + # The story is that the original implementation hard-coded the + # number of call levels to go back, so calls to longmess were off + # by one. Other code began calling longmess and expecting this + # behaviour, so the replacement has to emulate that behaviour. + my $cgc = _cgc(); + my $call_pack = $cgc ? $cgc->() : caller(); + if ( $Internal{$call_pack} or $CarpInternal{$call_pack} ) { + return longmess_heavy(@_); + } + else { + local $CarpLevel = $CarpLevel + 1; + return longmess_heavy(@_); + } +} + +our @CARP_NOT; + +sub shortmess { + my $cgc = _cgc(); + + # Icky backwards compatibility wrapper. :-( + local @CARP_NOT = $cgc ? $cgc->() : caller(); + shortmess_heavy(@_); +} + +sub croak { die shortmess @_ } +sub confess { die longmess @_ } +sub carp { warn shortmess @_ } +sub cluck { warn longmess @_ } + +sub caller_info { + my $i = shift(@_) + 1; + my %call_info; + my $cgc = _cgc(); + { + package DB; + @DB::args = \$i; # A sentinel, which no-one else has the address of + @call_info{ + qw(pack file line sub has_args wantarray evaltext is_require) } + = $cgc ? $cgc->($i) : caller($i); + } + + unless ( defined $call_info{pack} ) { + return (); + } + + my $sub_name = Carp::get_subname( \%call_info ); + if ( $call_info{has_args} ) { + my @args; + if ( @DB::args == 1 + && ref $DB::args[0] eq ref \$i + && $DB::args[0] == \$i ) { + @DB::args = (); # Don't let anyone see the address of $i + local $@; + my $where = eval { + my $func = $cgc or return ''; + my $gv = B::svref_2object($func)->GV; + my $package = $gv->STASH->NAME; + my $subname = $gv->NAME; + return unless defined $package && defined $subname; + + # returning CORE::GLOBAL::caller isn't useful for tracing the cause: + return if $package eq 'CORE::GLOBAL' && $subname eq 'caller'; + " in &${package}::$subname"; + } // ''; + @args + = "** Incomplete caller override detected$where; \@DB::args were not set **"; + } + else { + @args = map { Carp::format_arg($_) } @DB::args; + } + if ( $MaxArgNums and @args > $MaxArgNums ) + { # More than we want to show? + $#args = $MaxArgNums; + push @args, '...'; + } + + # Push the args onto the subroutine + $sub_name .= '(' . join( ', ', @args ) . ')'; + } + $call_info{sub_name} = $sub_name; + return wantarray() ? %call_info : \%call_info; +} + +# Transform an argument to a function into a string. +sub format_arg { + my $arg = shift; + if ( ref($arg) ) { + $arg = defined($overload::VERSION) ? overload::StrVal($arg) : "$arg"; + } + if ( defined($arg) ) { + $arg =~ s/'/\\'/g; + $arg = str_len_trim( $arg, $MaxArgLen ); + + # Quote it? + $arg = "'$arg'" unless $arg =~ /^-?[0-9.]+\z/; + } # 0-9, not \d, as \d will try to + else { # load Unicode tables + $arg = 'undef'; + } + + # The following handling of "control chars" is direct from + # the original code - it is broken on Unicode though. + # Suggestions? + utf8::is_utf8($arg) + or $arg =~ s/([[:cntrl:]]|[[:^ascii:]])/sprintf("\\x{%x}",ord($1))/eg; + return $arg; +} + +# Takes an inheritance cache and a package and returns +# an anon hash of known inheritances and anon array of +# inheritances which consequences have not been figured +# for. +sub get_status { + my $cache = shift; + my $pkg = shift; + $cache->{$pkg} ||= [ { $pkg => $pkg }, [ trusts_directly($pkg) ] ]; + return @{ $cache->{$pkg} }; +} + +# Takes the info from caller() and figures out the name of +# the sub/require/eval +sub get_subname { + my $info = shift; + if ( defined( $info->{evaltext} ) ) { + my $eval = $info->{evaltext}; + if ( $info->{is_require} ) { + return "require $eval"; + } + else { + $eval =~ s/([\\\'])/\\$1/g; + return "eval '" . str_len_trim( $eval, $MaxEvalLen ) . "'"; + } + } + + return ( $info->{sub} eq '(eval)' ) ? 'eval {...}' : $info->{sub}; +} + +# Figures out what call (from the point of view of the caller) +# the long error backtrace should start at. +sub long_error_loc { + my $i; + my $lvl = $CarpLevel; + { + ++$i; + my $cgc = _cgc(); + my $pkg = $cgc ? $cgc->($i) : caller($i); + unless ( defined($pkg) ) { + + # This *shouldn't* happen. + if (%Internal) { + local %Internal; + $i = long_error_loc(); + last; + } + else { + + # OK, now I am irritated. + return 2; + } + } + redo if $CarpInternal{$pkg}; + redo unless 0 > --$lvl; + redo if $Internal{$pkg}; + } + return $i - 1; +} + +sub longmess_heavy { + return @_ if ref( $_[0] ); # don't break references as exceptions + my $i = long_error_loc(); + return ret_backtrace( $i, @_ ); +} + +# Returns a full stack backtrace starting from where it is +# told. +sub ret_backtrace { + my ( $i, @error ) = @_; + my $mess; + my $err = join '', @error; + $i++; + + my $tid_msg = ''; + if ( defined &threads::tid ) { + my $tid = threads->tid; + $tid_msg = " thread $tid" if $tid; + } + + my %i = caller_info($i); + $mess = "$err at $i{file} line $i{line}$tid_msg\n"; + + while ( my %i = caller_info( ++$i ) ) { + $mess .= "\t$i{sub_name} called at $i{file} line $i{line}$tid_msg\n"; + } + + return $mess; +} + +sub ret_summary { + my ( $i, @error ) = @_; + my $err = join '', @error; + $i++; + + my $tid_msg = ''; + if ( defined &threads::tid ) { + my $tid = threads->tid; + $tid_msg = " thread $tid" if $tid; + } + + my %i = caller_info($i); + return "$err at $i{file} line $i{line}$tid_msg\n"; +} + +sub short_error_loc { + # You have to create your (hash)ref out here, rather than defaulting it + # inside trusts *on a lexical*, as you want it to persist across calls. + # (You can default it on $_[2], but that gets messy) + my $cache = {}; + my $i = 1; + my $lvl = $CarpLevel; + { + my $cgc = _cgc(); + my $called = $cgc ? $cgc->($i) : caller($i); + $i++; + my $caller = $cgc ? $cgc->($i) : caller($i); + + return 0 unless defined($caller); # What happened? + redo if $Internal{$caller}; + redo if $CarpInternal{$caller}; + redo if $CarpInternal{$called}; + redo if trusts( $called, $caller, $cache ); + redo if trusts( $caller, $called, $cache ); + redo unless 0 > --$lvl; + } + return $i - 1; +} + +sub shortmess_heavy { + return longmess_heavy(@_) if $Verbose; + return @_ if ref( $_[0] ); # don't break references as exceptions + my $i = short_error_loc(); + if ($i) { + ret_summary( $i, @_ ); + } + else { + longmess_heavy(@_); + } +} + +# If a string is too long, trims it with ... +sub str_len_trim { + my $str = shift; + my $max = shift || 0; + if ( 2 < $max and $max < length($str) ) { + substr( $str, $max - 3 ) = '...'; + } + return $str; +} + +# Takes two packages and an optional cache. Says whether the +# first inherits from the second. +# +# Recursive versions of this have to work to avoid certain +# possible endless loops, and when following long chains of +# inheritance are less efficient. +sub trusts { + my $child = shift; + my $parent = shift; + my $cache = shift; + my ( $known, $partial ) = get_status( $cache, $child ); + + # Figure out consequences until we have an answer + while ( @$partial and not exists $known->{$parent} ) { + my $anc = shift @$partial; + next if exists $known->{$anc}; + $known->{$anc}++; + my ( $anc_knows, $anc_partial ) = get_status( $cache, $anc ); + my @found = keys %$anc_knows; + @$known{@found} = (); + push @$partial, @$anc_partial; + } + return exists $known->{$parent}; +} + +# Takes a package and gives a list of those trusted directly +sub trusts_directly { + my $class = shift; + no strict 'refs'; + no warnings 'once'; + return @{"$class\::CARP_NOT"} + ? @{"$class\::CARP_NOT"} + : @{"$class\::ISA"}; +} + +1; + +__END__ + +=head1 NAME + +Carp - alternative warn and die for modules + +=head1 SYNOPSIS + + use Carp; + + # warn user (from perspective of caller) + carp "string trimmed to 80 chars"; + + # die of errors (from perspective of caller) + croak "We're outta here!"; + + # die of errors with stack backtrace + confess "not implemented"; + + # cluck not exported by default + use Carp qw(cluck); + cluck "This is how we got here!"; + +=head1 DESCRIPTION + +The Carp routines are useful in your own modules because +they act like die() or warn(), but with a message which is more +likely to be useful to a user of your module. In the case of +cluck, confess, and longmess that context is a summary of every +call in the call-stack. For a shorter message you can use C +or C which report the error as being from where your module +was called. There is no guarantee that that is where the error +was, but it is a good educated guess. + +You can also alter the way the output and logic of C works, by +changing some global variables in the C namespace. See the +section on C below. + +Here is a more complete description of how C and C work. +What they do is search the call-stack for a function call stack where +they have not been told that there shouldn't be an error. If every +call is marked safe, they give up and give a full stack backtrace +instead. In other words they presume that the first likely looking +potential suspect is guilty. Their rules for telling whether +a call shouldn't generate errors work as follows: + +=over 4 + +=item 1. + +Any call from a package to itself is safe. + +=item 2. + +Packages claim that there won't be errors on calls to or from +packages explicitly marked as safe by inclusion in C<@CARP_NOT>, or +(if that array is empty) C<@ISA>. The ability to override what +@ISA says is new in 5.8. + +=item 3. + +The trust in item 2 is transitive. If A trusts B, and B +trusts C, then A trusts C. So if you do not override C<@ISA> +with C<@CARP_NOT>, then this trust relationship is identical to, +"inherits from". + +=item 4. + +Any call from an internal Perl module is safe. (Nothing keeps +user modules from marking themselves as internal to Perl, but +this practice is discouraged.) + +=item 5. + +Any call to Perl's warning system (eg Carp itself) is safe. +(This rule is what keeps it from reporting the error at the +point where you call C or C.) + +=item 6. + +C<$Carp::CarpLevel> can be set to skip a fixed number of additional +call levels. Using this is not recommended because it is very +difficult to get it to behave correctly. + +=back + +=head2 Forcing a Stack Trace + +As a debugging aid, you can force Carp to treat a croak as a confess +and a carp as a cluck across I modules. In other words, force a +detailed stack trace to be given. This can be very helpful when trying +to understand why, or from where, a warning or error is being generated. + +This feature is enabled by 'importing' the non-existent symbol +'verbose'. You would typically enable it by saying + + perl -MCarp=verbose script.pl + +or by including the string C<-MCarp=verbose> in the PERL5OPT +environment variable. + +Alternately, you can set the global variable C<$Carp::Verbose> to true. +See the C section below. + +=head1 GLOBAL VARIABLES + +=head2 $Carp::MaxEvalLen + +This variable determines how many characters of a string-eval are to +be shown in the output. Use a value of C<0> to show all text. + +Defaults to C<0>. + +=head2 $Carp::MaxArgLen + +This variable determines how many characters of each argument to a +function to print. Use a value of C<0> to show the full length of the +argument. + +Defaults to C<64>. + +=head2 $Carp::MaxArgNums + +This variable determines how many arguments to each function to show. +Use a value of C<0> to show all arguments to a function call. + +Defaults to C<8>. + +=head2 $Carp::Verbose + +This variable makes C and C generate stack backtraces +just like C and C. This is how C +is implemented internally. + +Defaults to C<0>. + +=head2 @CARP_NOT + +This variable, I, says which packages are I to be +considered as the location of an error. The C and C +functions will skip over callers when reporting where an error occurred. + +NB: This variable must be in the package's symbol table, thus: + + # These work + our @CARP_NOT; # file scope + use vars qw(@CARP_NOT); # package scope + @My::Package::CARP_NOT = ... ; # explicit package variable + + # These don't work + sub xyz { ... @CARP_NOT = ... } # w/o declarations above + my @CARP_NOT; # even at top-level + +Example of use: + + package My::Carping::Package; + use Carp; + our @CARP_NOT; + sub bar { .... or _error('Wrong input') } + sub _error { + # temporary control of where'ness, __PACKAGE__ is implicit + local @CARP_NOT = qw(My::Friendly::Caller); + carp(@_) + } + +This would make C report the error as coming from a caller not +in C, nor from C. + +Also read the L section above, about how C decides +where the error is reported from. + +Use C<@CARP_NOT>, instead of C<$Carp::CarpLevel>. + +Overrides C's use of C<@ISA>. + +=head2 %Carp::Internal + +This says what packages are internal to Perl. C will never +report an error as being from a line in a package that is internal to +Perl. For example: + + $Carp::Internal{ (__PACKAGE__) }++; + # time passes... + sub foo { ... or confess("whatever") }; + +would give a full stack backtrace starting from the first caller +outside of __PACKAGE__. (Unless that package was also internal to +Perl.) + +=head2 %Carp::CarpInternal + +This says which packages are internal to Perl's warning system. For +generating a full stack backtrace this is the same as being internal +to Perl, the stack backtrace will not start inside packages that are +listed in C<%Carp::CarpInternal>. But it is slightly different for +the summary message generated by C or C. There errors +will not be reported on any lines that are calling packages in +C<%Carp::CarpInternal>. + +For example C itself is listed in C<%Carp::CarpInternal>. +Therefore the full stack backtrace from C will not start +inside of C, and the short message from calling C is +not placed on the line where C was called. + +=head2 $Carp::CarpLevel + +This variable determines how many additional call frames are to be +skipped that would not otherwise be when reporting where an error +occurred on a call to one of C's functions. It is fairly easy +to count these call frames on calls that generate a full stack +backtrace. However it is much harder to do this accounting for calls +that generate a short message. Usually people skip too many call +frames. If they are lucky they skip enough that C goes all of +the way through the call stack, realizes that something is wrong, and +then generates a full stack backtrace. If they are unlucky then the +error is reported from somewhere misleading very high in the call +stack. + +Therefore it is best to avoid C<$Carp::CarpLevel>. Instead use +C<@CARP_NOT>, C<%Carp::Internal> and C<%Carp::CarpInternal>. + +Defaults to C<0>. + +=head1 BUGS + +The Carp routines don't handle exception objects currently. +If called with a first argument that is a reference, they simply +call die() or warn(), as appropriate. + diff --git a/testsuite/input-files/perl-v5.14.2/lib/Carp/Heavy.pm b/testsuite/input-files/perl-v5.14.2/lib/Carp/Heavy.pm new file mode 100644 index 00000000..38f95d8a --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Carp/Heavy.pm @@ -0,0 +1,10 @@ +package Carp; + +# On one line so MakeMaker will see it. +use Carp; our $VERSION = $Carp::VERSION; + +1; + +# Most of the machinery of Carp used to be there. +# It has been moved in Carp.pm now, but this placeholder remains for +# the benefit of modules that like to preload Carp::Heavy directly. diff --git a/testsuite/input-files/perl-v5.14.2/lib/Config.pm b/testsuite/input-files/perl-v5.14.2/lib/Config.pm new file mode 100644 index 00000000..a95e2fc0 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Config.pm @@ -0,0 +1,110 @@ +# This file was created by configpm when Perl was built. Any changes +# made to this file will be lost the next time perl is built. + +# for a description of the variables, please have a look at the +# Glossary file, as written in the Porting folder, or use the url: +# http://perl5.git.perl.org/perl.git/blob/HEAD:/Porting/Glossary + +package Config; +use strict; +use warnings; +use vars '%Config'; + +# Skip @Config::EXPORT because it only contains %Config, which we special +# case below as it's not a function. @Config::EXPORT won't change in the +# lifetime of Perl 5. +my %Export_Cache = (myconfig => 1, config_sh => 1, config_vars => 1, + config_re => 1, compile_date => 1, local_patches => 1, + bincompat_options => 1, non_bincompat_options => 1, + header_files => 1); + +@Config::EXPORT = qw(%Config); +@Config::EXPORT_OK = keys %Export_Cache; + +# Need to stub all the functions to make code such as print Config::config_sh +# keep working + +sub bincompat_options; +sub compile_date; +sub config_re; +sub config_sh; +sub config_vars; +sub header_files; +sub local_patches; +sub myconfig; +sub non_bincompat_options; + +# Define our own import method to avoid pulling in the full Exporter: +sub import { + shift; + @_ = @Config::EXPORT unless @_; + + my @funcs = grep $_ ne '%Config', @_; + my $export_Config = @funcs < @_ ? 1 : 0; + + no strict 'refs'; + my $callpkg = caller(0); + foreach my $func (@funcs) { + die qq{"$func" is not exported by the Config module\n} + unless $Export_Cache{$func}; + *{$callpkg.'::'.$func} = \&{$func}; + } + + *{"$callpkg\::Config"} = \%Config if $export_Config; + return; +} + +die "Perl lib version (5.14.2) doesn't match executable '$0' version ($])" + unless $^V; + +$^V eq 5.14.2 + or die "Perl lib version (5.14.2) doesn't match executable '$0' version (" . + sprintf("v%vd",$^V) . ")"; + + +sub FETCH { + my($self, $key) = @_; + + # check for cached value (which may be undef so we use exists not defined) + return exists $self->{$key} ? $self->{$key} : $self->fetch_string($key); +} + +sub TIEHASH { + bless $_[1], $_[0]; +} + +sub DESTROY { } + +sub AUTOLOAD { + require 'Config_heavy.pl'; + goto \&launcher unless $Config::AUTOLOAD =~ /launcher$/; + die "&Config::AUTOLOAD failed on $Config::AUTOLOAD"; +} + +# tie returns the object, so the value returned to require will be true. +tie %Config, 'Config', { + archlibexp => '/usr/local/lib/perl5/5.14.2/x86_64-linux', + archname => 'x86_64-linux', + cc => 'cc', + d_readlink => 'define', + d_symlink => 'define', + dlext => 'so', + dlsrc => 'dl_dlopen.xs', + dont_use_nlink => undef, + exe_ext => '', + inc_version_list => ' ', + intsize => '4', + ldlibpthname => 'LD_LIBRARY_PATH', + libpth => '/usr/local/lib /lib/x86_64-linux-gnu /lib/../lib /usr/lib/x86_64-linux-gnu /usr/lib/../lib /lib /usr/lib', + osname => 'linux', + osvers => '3.13.0-43-lowlatency', + path_sep => ':', + privlibexp => '/usr/local/lib/perl5/5.14.2', + scriptdir => '/usr/local/bin', + sitearchexp => '/usr/local/lib/perl5/site_perl/5.14.2/x86_64-linux', + sitelibexp => '/usr/local/lib/perl5/site_perl/5.14.2', + so => 'so', + useithreads => undef, + usevendorprefix => undef, + version => '5.14.2', +}; diff --git a/testsuite/input-files/perl-v5.14.2/lib/Cwd.pm b/testsuite/input-files/perl-v5.14.2/lib/Cwd.pm new file mode 100644 index 00000000..4683e103 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Cwd.pm @@ -0,0 +1,831 @@ +package Cwd; + +=head1 NAME + +Cwd - get pathname of current working directory + +=head1 SYNOPSIS + + use Cwd; + my $dir = getcwd; + + use Cwd 'abs_path'; + my $abs_path = abs_path($file); + +=head1 DESCRIPTION + +This module provides functions for determining the pathname of the +current working directory. It is recommended that getcwd (or another +*cwd() function) be used in I code to ensure portability. + +By default, it exports the functions cwd(), getcwd(), fastcwd(), and +fastgetcwd() (and, on Win32, getdcwd()) into the caller's namespace. + + +=head2 getcwd and friends + +Each of these functions are called without arguments and return the +absolute path of the current working directory. + +=over 4 + +=item getcwd + + my $cwd = getcwd(); + +Returns the current working directory. + +Exposes the POSIX function getcwd(3) or re-implements it if it's not +available. + +=item cwd + + my $cwd = cwd(); + +The cwd() is the most natural form for the current architecture. For +most systems it is identical to `pwd` (but without the trailing line +terminator). + +=item fastcwd + + my $cwd = fastcwd(); + +A more dangerous version of getcwd(), but potentially faster. + +It might conceivably chdir() you out of a directory that it can't +chdir() you back into. If fastcwd encounters a problem it will return +undef but will probably leave you in a different directory. For a +measure of extra security, if everything appears to have worked, the +fastcwd() function will check that it leaves you in the same directory +that it started in. If it has changed it will C with the message +"Unstable directory path, current directory changed +unexpectedly". That should never happen. + +=item fastgetcwd + + my $cwd = fastgetcwd(); + +The fastgetcwd() function is provided as a synonym for cwd(). + +=item getdcwd + + my $cwd = getdcwd(); + my $cwd = getdcwd('C:'); + +The getdcwd() function is also provided on Win32 to get the current working +directory on the specified drive, since Windows maintains a separate current +working directory for each drive. If no drive is specified then the current +drive is assumed. + +This function simply calls the Microsoft C library _getdcwd() function. + +=back + + +=head2 abs_path and friends + +These functions are exported only on request. They each take a single +argument and return the absolute pathname for it. If no argument is +given they'll use the current working directory. + +=over 4 + +=item abs_path + + my $abs_path = abs_path($file); + +Uses the same algorithm as getcwd(). Symbolic links and relative-path +components ("." and "..") are resolved to return the canonical +pathname, just like realpath(3). + +=item realpath + + my $abs_path = realpath($file); + +A synonym for abs_path(). + +=item fast_abs_path + + my $abs_path = fast_abs_path($file); + +A more dangerous, but potentially faster version of abs_path. + +=back + +=head2 $ENV{PWD} + +If you ask to override your chdir() built-in function, + + use Cwd qw(chdir); + +then your PWD environment variable will be kept up to date. Note that +it will only be kept up to date if all packages which use chdir import +it from Cwd. + + +=head1 NOTES + +=over 4 + +=item * + +Since the path separators are different on some operating systems ('/' +on Unix, ':' on MacPerl, etc...) we recommend you use the File::Spec +modules wherever portability is a concern. + +=item * + +Actually, on Mac OS, the C, C and C +functions are all aliases for the C function, which, on Mac OS, +calls `pwd`. Likewise, the C function is an alias for +C. + +=back + +=head1 AUTHOR + +Originally by the perl5-porters. + +Maintained by Ken Williams + +=head1 COPYRIGHT + +Copyright (c) 2004 by the Perl 5 Porters. All rights reserved. + +This program is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +Portions of the C code in this library are copyright (c) 1994 by the +Regents of the University of California. All rights reserved. The +license on this code is compatible with the licensing of the rest of +the distribution - please see the source code in F for the +details. + +=head1 SEE ALSO + +L + +=cut + +use strict; +use Exporter; +use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION); + +$VERSION = '3.36'; +my $xs_version = $VERSION; +$VERSION = eval $VERSION; + +@ISA = qw/ Exporter /; +@EXPORT = qw(cwd getcwd fastcwd fastgetcwd); +push @EXPORT, qw(getdcwd) if $^O eq 'MSWin32'; +@EXPORT_OK = qw(chdir abs_path fast_abs_path realpath fast_realpath); + +# sys_cwd may keep the builtin command + +# All the functionality of this module may provided by builtins, +# there is no sense to process the rest of the file. +# The best choice may be to have this in BEGIN, but how to return from BEGIN? + +if ($^O eq 'os2') { + local $^W = 0; + + *cwd = defined &sys_cwd ? \&sys_cwd : \&_os2_cwd; + *getcwd = \&cwd; + *fastgetcwd = \&cwd; + *fastcwd = \&cwd; + + *fast_abs_path = \&sys_abspath if defined &sys_abspath; + *abs_path = \&fast_abs_path; + *realpath = \&fast_abs_path; + *fast_realpath = \&fast_abs_path; + + return 1; +} + +# Need to look up the feature settings on VMS. The preferred way is to use the +# VMS::Feature module, but that may not be available to dual life modules. + +my $use_vms_feature; +BEGIN { + if ($^O eq 'VMS') { + if (eval { local $SIG{__DIE__}; require VMS::Feature; }) { + $use_vms_feature = 1; + } + } +} + +# Need to look up the UNIX report mode. This may become a dynamic mode +# in the future. +sub _vms_unix_rpt { + my $unix_rpt; + if ($use_vms_feature) { + $unix_rpt = VMS::Feature::current("filename_unix_report"); + } else { + my $env_unix_rpt = $ENV{'DECC$FILENAME_UNIX_REPORT'} || ''; + $unix_rpt = $env_unix_rpt =~ /^[ET1]/i; + } + return $unix_rpt; +} + +# Need to look up the EFS character set mode. This may become a dynamic +# mode in the future. +sub _vms_efs { + my $efs; + if ($use_vms_feature) { + $efs = VMS::Feature::current("efs_charset"); + } else { + my $env_efs = $ENV{'DECC$EFS_CHARSET'} || ''; + $efs = $env_efs =~ /^[ET1]/i; + } + return $efs; +} + + +# If loading the XS stuff doesn't work, we can fall back to pure perl +eval { + if ( $] >= 5.006 ) { + require XSLoader; + XSLoader::load( __PACKAGE__, $xs_version); + } else { + require DynaLoader; + push @ISA, 'DynaLoader'; + __PACKAGE__->bootstrap( $xs_version ); + } +}; + +# Must be after the DynaLoader stuff: +$VERSION = eval $VERSION; + +# Big nasty table of function aliases +my %METHOD_MAP = + ( + VMS => + { + cwd => '_vms_cwd', + getcwd => '_vms_cwd', + fastcwd => '_vms_cwd', + fastgetcwd => '_vms_cwd', + abs_path => '_vms_abs_path', + fast_abs_path => '_vms_abs_path', + }, + + MSWin32 => + { + # We assume that &_NT_cwd is defined as an XSUB or in the core. + cwd => '_NT_cwd', + getcwd => '_NT_cwd', + fastcwd => '_NT_cwd', + fastgetcwd => '_NT_cwd', + abs_path => 'fast_abs_path', + realpath => 'fast_abs_path', + }, + + dos => + { + cwd => '_dos_cwd', + getcwd => '_dos_cwd', + fastgetcwd => '_dos_cwd', + fastcwd => '_dos_cwd', + abs_path => 'fast_abs_path', + }, + + # QNX4. QNX6 has a $os of 'nto'. + qnx => + { + cwd => '_qnx_cwd', + getcwd => '_qnx_cwd', + fastgetcwd => '_qnx_cwd', + fastcwd => '_qnx_cwd', + abs_path => '_qnx_abs_path', + fast_abs_path => '_qnx_abs_path', + }, + + cygwin => + { + getcwd => 'cwd', + fastgetcwd => 'cwd', + fastcwd => 'cwd', + abs_path => 'fast_abs_path', + realpath => 'fast_abs_path', + }, + + epoc => + { + cwd => '_epoc_cwd', + getcwd => '_epoc_cwd', + fastgetcwd => '_epoc_cwd', + fastcwd => '_epoc_cwd', + abs_path => 'fast_abs_path', + }, + + MacOS => + { + getcwd => 'cwd', + fastgetcwd => 'cwd', + fastcwd => 'cwd', + abs_path => 'fast_abs_path', + }, + ); + +$METHOD_MAP{NT} = $METHOD_MAP{MSWin32}; + + +# Find the pwd command in the expected locations. We assume these +# are safe. This prevents _backtick_pwd() consulting $ENV{PATH} +# so everything works under taint mode. +my $pwd_cmd; +foreach my $try ('/bin/pwd', + '/usr/bin/pwd', + '/QOpenSys/bin/pwd', # OS/400 PASE. + ) { + + if( -x $try ) { + $pwd_cmd = $try; + last; + } +} +my $found_pwd_cmd = defined($pwd_cmd); +unless ($pwd_cmd) { + # Isn't this wrong? _backtick_pwd() will fail if somenone has + # pwd in their path but it is not /bin/pwd or /usr/bin/pwd? + # See [perl #16774]. --jhi + $pwd_cmd = 'pwd'; +} + +# Lazy-load Carp +sub _carp { require Carp; Carp::carp(@_) } +sub _croak { require Carp; Carp::croak(@_) } + +# The 'natural and safe form' for UNIX (pwd may be setuid root) +sub _backtick_pwd { + # Localize %ENV entries in a way that won't create new hash keys + my @localize = grep exists $ENV{$_}, qw(PATH IFS CDPATH ENV BASH_ENV); + local @ENV{@localize}; + + my $cwd = `$pwd_cmd`; + # Belt-and-suspenders in case someone said "undef $/". + local $/ = "\n"; + # `pwd` may fail e.g. if the disk is full + chomp($cwd) if defined $cwd; + $cwd; +} + +# Since some ports may predefine cwd internally (e.g., NT) +# we take care not to override an existing definition for cwd(). + +unless ($METHOD_MAP{$^O}{cwd} or defined &cwd) { + # The pwd command is not available in some chroot(2)'ed environments + my $sep = $Config::Config{path_sep} || ':'; + my $os = $^O; # Protect $^O from tainting + + + # Try again to find a pwd, this time searching the whole PATH. + if (defined $ENV{PATH} and $os ne 'MSWin32') { # no pwd on Windows + my @candidates = split($sep, $ENV{PATH}); + while (!$found_pwd_cmd and @candidates) { + my $candidate = shift @candidates; + $found_pwd_cmd = 1 if -x "$candidate/pwd"; + } + } + + # MacOS has some special magic to make `pwd` work. + if( $os eq 'MacOS' || $found_pwd_cmd ) + { + *cwd = \&_backtick_pwd; + } + else { + *cwd = \&getcwd; + } +} + +if ($^O eq 'cygwin') { + # We need to make sure cwd() is called with no args, because it's + # got an arg-less prototype and will die if args are present. + local $^W = 0; + my $orig_cwd = \&cwd; + *cwd = sub { &$orig_cwd() } +} + + +# set a reasonable (and very safe) default for fastgetcwd, in case it +# isn't redefined later (20001212 rspier) +*fastgetcwd = \&cwd; + +# A non-XS version of getcwd() - also used to bootstrap the perl build +# process, when miniperl is running and no XS loading happens. +sub _perl_getcwd +{ + abs_path('.'); +} + +# By John Bazik +# +# Usage: $cwd = &fastcwd; +# +# This is a faster version of getcwd. It's also more dangerous because +# you might chdir out of a directory that you can't chdir back into. + +sub fastcwd_ { + my($odev, $oino, $cdev, $cino, $tdev, $tino); + my(@path, $path); + local(*DIR); + + my($orig_cdev, $orig_cino) = stat('.'); + ($cdev, $cino) = ($orig_cdev, $orig_cino); + for (;;) { + my $direntry; + ($odev, $oino) = ($cdev, $cino); + CORE::chdir('..') || return undef; + ($cdev, $cino) = stat('.'); + last if $odev == $cdev && $oino == $cino; + opendir(DIR, '.') || return undef; + for (;;) { + $direntry = readdir(DIR); + last unless defined $direntry; + next if $direntry eq '.'; + next if $direntry eq '..'; + + ($tdev, $tino) = lstat($direntry); + last unless $tdev != $odev || $tino != $oino; + } + closedir(DIR); + return undef unless defined $direntry; # should never happen + unshift(@path, $direntry); + } + $path = '/' . join('/', @path); + if ($^O eq 'apollo') { $path = "/".$path; } + # At this point $path may be tainted (if tainting) and chdir would fail. + # Untaint it then check that we landed where we started. + $path =~ /^(.*)\z/s # untaint + && CORE::chdir($1) or return undef; + ($cdev, $cino) = stat('.'); + die "Unstable directory path, current directory changed unexpectedly" + if $cdev != $orig_cdev || $cino != $orig_cino; + $path; +} +if (not defined &fastcwd) { *fastcwd = \&fastcwd_ } + + +# Keeps track of current working directory in PWD environment var +# Usage: +# use Cwd 'chdir'; +# chdir $newdir; + +my $chdir_init = 0; + +sub chdir_init { + if ($ENV{'PWD'} and $^O ne 'os2' and $^O ne 'dos' and $^O ne 'MSWin32') { + my($dd,$di) = stat('.'); + my($pd,$pi) = stat($ENV{'PWD'}); + if (!defined $dd or !defined $pd or $di != $pi or $dd != $pd) { + $ENV{'PWD'} = cwd(); + } + } + else { + my $wd = cwd(); + $wd = Win32::GetFullPathName($wd) if $^O eq 'MSWin32'; + $ENV{'PWD'} = $wd; + } + # Strip an automounter prefix (where /tmp_mnt/foo/bar == /foo/bar) + if ($^O ne 'MSWin32' and $ENV{'PWD'} =~ m|(/[^/]+(/[^/]+/[^/]+))(.*)|s) { + my($pd,$pi) = stat($2); + my($dd,$di) = stat($1); + if (defined $pd and defined $dd and $di == $pi and $dd == $pd) { + $ENV{'PWD'}="$2$3"; + } + } + $chdir_init = 1; +} + +sub chdir { + my $newdir = @_ ? shift : ''; # allow for no arg (chdir to HOME dir) + $newdir =~ s|///*|/|g unless $^O eq 'MSWin32'; + chdir_init() unless $chdir_init; + my $newpwd; + if ($^O eq 'MSWin32') { + # get the full path name *before* the chdir() + $newpwd = Win32::GetFullPathName($newdir); + } + + return 0 unless CORE::chdir $newdir; + + if ($^O eq 'VMS') { + return $ENV{'PWD'} = $ENV{'DEFAULT'} + } + elsif ($^O eq 'MacOS') { + return $ENV{'PWD'} = cwd(); + } + elsif ($^O eq 'MSWin32') { + $ENV{'PWD'} = $newpwd; + return 1; + } + + if (ref $newdir eq 'GLOB') { # in case a file/dir handle is passed in + $ENV{'PWD'} = cwd(); + } elsif ($newdir =~ m#^/#s) { + $ENV{'PWD'} = $newdir; + } else { + my @curdir = split(m#/#,$ENV{'PWD'}); + @curdir = ('') unless @curdir; + my $component; + foreach $component (split(m#/#, $newdir)) { + next if $component eq '.'; + pop(@curdir),next if $component eq '..'; + push(@curdir,$component); + } + $ENV{'PWD'} = join('/',@curdir) || '/'; + } + 1; +} + + +sub _perl_abs_path +{ + my $start = @_ ? shift : '.'; + my($dotdots, $cwd, @pst, @cst, $dir, @tst); + + unless (@cst = stat( $start )) + { + _carp("stat($start): $!"); + return ''; + } + + unless (-d _) { + # Make sure we can be invoked on plain files, not just directories. + # NOTE that this routine assumes that '/' is the only directory separator. + + my ($dir, $file) = $start =~ m{^(.*)/(.+)$} + or return cwd() . '/' . $start; + + # Can't use "-l _" here, because the previous stat was a stat(), not an lstat(). + if (-l $start) { + my $link_target = readlink($start); + die "Can't resolve link $start: $!" unless defined $link_target; + + require File::Spec; + $link_target = $dir . '/' . $link_target + unless File::Spec->file_name_is_absolute($link_target); + + return abs_path($link_target); + } + + return $dir ? abs_path($dir) . "/$file" : "/$file"; + } + + $cwd = ''; + $dotdots = $start; + do + { + $dotdots .= '/..'; + @pst = @cst; + local *PARENT; + unless (opendir(PARENT, $dotdots)) + { + # probably a permissions issue. Try the native command. + return File::Spec->rel2abs( $start, _backtick_pwd() ); + } + unless (@cst = stat($dotdots)) + { + _carp("stat($dotdots): $!"); + closedir(PARENT); + return ''; + } + if ($pst[0] == $cst[0] && $pst[1] == $cst[1]) + { + $dir = undef; + } + else + { + do + { + unless (defined ($dir = readdir(PARENT))) + { + _carp("readdir($dotdots): $!"); + closedir(PARENT); + return ''; + } + $tst[0] = $pst[0]+1 unless (@tst = lstat("$dotdots/$dir")) + } + while ($dir eq '.' || $dir eq '..' || $tst[0] != $pst[0] || + $tst[1] != $pst[1]); + } + $cwd = (defined $dir ? "$dir" : "" ) . "/$cwd" ; + closedir(PARENT); + } while (defined $dir); + chop($cwd) unless $cwd eq '/'; # drop the trailing / + $cwd; +} + + +my $Curdir; +sub fast_abs_path { + local $ENV{PWD} = $ENV{PWD} || ''; # Guard against clobberage + my $cwd = getcwd(); + require File::Spec; + my $path = @_ ? shift : ($Curdir ||= File::Spec->curdir); + + # Detaint else we'll explode in taint mode. This is safe because + # we're not doing anything dangerous with it. + ($path) = $path =~ /(.*)/; + ($cwd) = $cwd =~ /(.*)/; + + unless (-e $path) { + _croak("$path: No such file or directory"); + } + + unless (-d _) { + # Make sure we can be invoked on plain files, not just directories. + + my ($vol, $dir, $file) = File::Spec->splitpath($path); + return File::Spec->catfile($cwd, $path) unless length $dir; + + if (-l $path) { + my $link_target = readlink($path); + die "Can't resolve link $path: $!" unless defined $link_target; + + $link_target = File::Spec->catpath($vol, $dir, $link_target) + unless File::Spec->file_name_is_absolute($link_target); + + return fast_abs_path($link_target); + } + + return $dir eq File::Spec->rootdir + ? File::Spec->catpath($vol, $dir, $file) + : fast_abs_path(File::Spec->catpath($vol, $dir, '')) . '/' . $file; + } + + if (!CORE::chdir($path)) { + _croak("Cannot chdir to $path: $!"); + } + my $realpath = getcwd(); + if (! ((-d $cwd) && (CORE::chdir($cwd)))) { + _croak("Cannot chdir back to $cwd: $!"); + } + $realpath; +} + +# added function alias to follow principle of least surprise +# based on previous aliasing. --tchrist 27-Jan-00 +*fast_realpath = \&fast_abs_path; + + +# --- PORTING SECTION --- + +# VMS: $ENV{'DEFAULT'} points to default directory at all times +# 06-Mar-1996 Charles Bailey bailey@newman.upenn.edu +# Note: Use of Cwd::chdir() causes the logical name PWD to be defined +# in the process logical name table as the default device and directory +# seen by Perl. This may not be the same as the default device +# and directory seen by DCL after Perl exits, since the effects +# the CRTL chdir() function persist only until Perl exits. + +sub _vms_cwd { + return $ENV{'DEFAULT'}; +} + +sub _vms_abs_path { + return $ENV{'DEFAULT'} unless @_; + my $path = shift; + + my $efs = _vms_efs; + my $unix_rpt = _vms_unix_rpt; + + if (defined &VMS::Filespec::vmsrealpath) { + my $path_unix = 0; + my $path_vms = 0; + + $path_unix = 1 if ($path =~ m#(?<=\^)/#); + $path_unix = 1 if ($path =~ /^\.\.?$/); + $path_vms = 1 if ($path =~ m#[\[<\]]#); + $path_vms = 1 if ($path =~ /^--?$/); + + my $unix_mode = $path_unix; + if ($efs) { + # In case of a tie, the Unix report mode decides. + if ($path_vms == $path_unix) { + $unix_mode = $unix_rpt; + } else { + $unix_mode = 0 if $path_vms; + } + } + + if ($unix_mode) { + # Unix format + return VMS::Filespec::unixrealpath($path); + } + + # VMS format + + my $new_path = VMS::Filespec::vmsrealpath($path); + + # Perl expects directories to be in directory format + $new_path = VMS::Filespec::pathify($new_path) if -d $path; + return $new_path; + } + + # Fallback to older algorithm if correct ones are not + # available. + + if (-l $path) { + my $link_target = readlink($path); + die "Can't resolve link $path: $!" unless defined $link_target; + + return _vms_abs_path($link_target); + } + + # may need to turn foo.dir into [.foo] + my $pathified = VMS::Filespec::pathify($path); + $path = $pathified if defined $pathified; + + return VMS::Filespec::rmsexpand($path); +} + +sub _os2_cwd { + $ENV{'PWD'} = `cmd /c cd`; + chomp $ENV{'PWD'}; + $ENV{'PWD'} =~ s:\\:/:g ; + return $ENV{'PWD'}; +} + +sub _win32_cwd_simple { + $ENV{'PWD'} = `cd`; + chomp $ENV{'PWD'}; + $ENV{'PWD'} =~ s:\\:/:g ; + return $ENV{'PWD'}; +} + +sub _win32_cwd { + if (eval 'defined &DynaLoader::boot_DynaLoader') { + $ENV{'PWD'} = Win32::GetCwd(); + } + else { # miniperl + chomp($ENV{'PWD'} = `cd`); + } + $ENV{'PWD'} =~ s:\\:/:g ; + return $ENV{'PWD'}; +} + +*_NT_cwd = defined &Win32::GetCwd ? \&_win32_cwd : \&_win32_cwd_simple; + +sub _dos_cwd { + if (!defined &Dos::GetCwd) { + $ENV{'PWD'} = `command /c cd`; + chomp $ENV{'PWD'}; + $ENV{'PWD'} =~ s:\\:/:g ; + } else { + $ENV{'PWD'} = Dos::GetCwd(); + } + return $ENV{'PWD'}; +} + +sub _qnx_cwd { + local $ENV{PATH} = ''; + local $ENV{CDPATH} = ''; + local $ENV{ENV} = ''; + $ENV{'PWD'} = `/usr/bin/fullpath -t`; + chomp $ENV{'PWD'}; + return $ENV{'PWD'}; +} + +sub _qnx_abs_path { + local $ENV{PATH} = ''; + local $ENV{CDPATH} = ''; + local $ENV{ENV} = ''; + my $path = @_ ? shift : '.'; + local *REALPATH; + + defined( open(REALPATH, '-|') || exec '/usr/bin/fullpath', '-t', $path ) or + die "Can't open /usr/bin/fullpath: $!"; + my $realpath = ; + close REALPATH; + chomp $realpath; + return $realpath; +} + +sub _epoc_cwd { + $ENV{'PWD'} = EPOC::getcwd(); + return $ENV{'PWD'}; +} + + +# Now that all the base-level functions are set up, alias the +# user-level functions to the right places + +if (exists $METHOD_MAP{$^O}) { + my $map = $METHOD_MAP{$^O}; + foreach my $name (keys %$map) { + local $^W = 0; # assignments trigger 'subroutine redefined' warning + no strict 'refs'; + *{$name} = \&{$map->{$name}}; + } +} + +# In case the XS version doesn't load. +*abs_path = \&_perl_abs_path unless defined &abs_path; +*getcwd = \&_perl_getcwd unless defined &getcwd; + +# added function alias for those of us more +# used to the libc function. --tchrist 27-Jan-00 +*realpath = \&abs_path; + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/DynaLoader.pm b/testsuite/input-files/perl-v5.14.2/lib/DynaLoader.pm new file mode 100644 index 00000000..29c05d00 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/DynaLoader.pm @@ -0,0 +1,753 @@ + +# Generated from DynaLoader_pm.PL + +package DynaLoader; + +# And Gandalf said: 'Many folk like to know beforehand what is to +# be set on the table; but those who have laboured to prepare the +# feast like to keep their secret; for wonder makes the words of +# praise louder.' + +# (Quote from Tolkien suggested by Anno Siegel.) +# +# See pod text at end of file for documentation. +# See also ext/DynaLoader/README in source tree for other information. +# +# Tim.Bunce@ig.co.uk, August 1994 + +BEGIN { + $VERSION = '1.13'; +} + +use Config; + +# enable debug/trace messages from DynaLoader perl code +$dl_debug = $ENV{PERL_DL_DEBUG} || 0 unless defined $dl_debug; + +# +# Flags to alter dl_load_file behaviour. Assigned bits: +# 0x01 make symbols available for linking later dl_load_file's. +# (only known to work on Solaris 2 using dlopen(RTLD_GLOBAL)) +# (ignored under VMS; effect is built-in to image linking) +# +# This is called as a class method $module->dl_load_flags. The +# definition here will be inherited and result on "default" loading +# behaviour unless a sub-class of DynaLoader defines its own version. +# + +sub dl_load_flags { 0x00 } + +($dl_dlext, $dl_so, $dlsrc) = @Config::Config{qw(dlext so dlsrc)}; + + +$do_expand = 0; + +@dl_require_symbols = (); # names of symbols we need +@dl_resolve_using = (); # names of files to link with +@dl_library_path = (); # path to look for files + +#XSLoader.pm may have added elements before we were required +#@dl_shared_objects = (); # shared objects for symbols we have +#@dl_librefs = (); # things we have loaded +#@dl_modules = (); # Modules we have loaded + +# This is a fix to support DLD's unfortunate desire to relink -lc +@dl_resolve_using = dl_findfile('-lc') if $dlsrc eq "dl_dld.xs"; + +# Initialise @dl_library_path with the 'standard' library path +# for this platform as determined by Configure. + +push(@dl_library_path, split(' ', $Config::Config{libpth})); + + +my $ldlibpthname = $Config::Config{ldlibpthname}; +my $ldlibpthname_defined = defined $Config::Config{ldlibpthname}; +my $pthsep = $Config::Config{path_sep}; + +# Add to @dl_library_path any extra directories we can gather from environment +# during runtime. + +if ($ldlibpthname_defined && + exists $ENV{$ldlibpthname}) { + push(@dl_library_path, split(/$pthsep/, $ENV{$ldlibpthname})); +} + +# E.g. HP-UX supports both its native SHLIB_PATH *and* LD_LIBRARY_PATH. + +if ($ldlibpthname_defined && + $ldlibpthname ne 'LD_LIBRARY_PATH' && + exists $ENV{LD_LIBRARY_PATH}) { + push(@dl_library_path, split(/$pthsep/, $ENV{LD_LIBRARY_PATH})); +} + + +# No prizes for guessing why we don't say 'bootstrap DynaLoader;' here. +# NOTE: All dl_*.xs (including dl_none.xs) define a dl_error() XSUB +boot_DynaLoader('DynaLoader') if defined(&boot_DynaLoader) && + !defined(&dl_error); + +if ($dl_debug) { + print STDERR "DynaLoader.pm loaded (@INC, @dl_library_path)\n"; + print STDERR "DynaLoader not linked into this perl\n" + unless defined(&boot_DynaLoader); +} + +1; # End of main code + + +sub croak { require Carp; Carp::croak(@_) } + +sub bootstrap_inherit { + my $module = $_[0]; + local *isa = *{"$module\::ISA"}; + local @isa = (@isa, 'DynaLoader'); + # Cannot goto due to delocalization. Will report errors on a wrong line? + bootstrap(@_); +} + +sub bootstrap { + # use local vars to enable $module.bs script to edit values + local(@args) = @_; + local($module) = $args[0]; + local(@dirs, $file); + + unless ($module) { + require Carp; + Carp::confess("Usage: DynaLoader::bootstrap(module)"); + } + + # A common error on platforms which don't support dynamic loading. + # Since it's fatal and potentially confusing we give a detailed message. + croak("Can't load module $module, dynamic loading not available in this perl.\n". + " (You may need to build a new perl executable which either supports\n". + " dynamic loading or has the $module module statically linked into it.)\n") + unless defined(&dl_load_file); + + + + my @modparts = split(/::/,$module); + my $modfname = $modparts[-1]; + + # Some systems have restrictions on files names for DLL's etc. + # mod2fname returns appropriate file base name (typically truncated) + # It may also edit @modparts if required. + $modfname = &mod2fname(\@modparts) if defined &mod2fname; + + + + my $modpname = join('/',@modparts); + + print STDERR "DynaLoader::bootstrap for $module ", + "(auto/$modpname/$modfname.$dl_dlext)\n" + if $dl_debug; + + foreach (@INC) { + + my $dir = "$_/auto/$modpname"; + + next unless -d $dir; # skip over uninteresting directories + + # check for common cases to avoid autoload of dl_findfile + my $try = "$dir/$modfname.$dl_dlext"; + last if $file = ($do_expand) ? dl_expandspec($try) : ((-f $try) && $try); + + # no luck here, save dir for possible later dl_findfile search + push @dirs, $dir; + } + # last resort, let dl_findfile have a go in all known locations + $file = dl_findfile(map("-L$_",@dirs,@INC), $modfname) unless $file; + + croak("Can't locate loadable object for module $module in \@INC (\@INC contains: @INC)") + unless $file; # wording similar to error from 'require' + + + my $bootname = "boot_$module"; + $bootname =~ s/\W/_/g; + @dl_require_symbols = ($bootname); + + # Execute optional '.bootstrap' perl script for this module. + # The .bs file can be used to configure @dl_resolve_using etc to + # match the needs of the individual module on this architecture. + my $bs = $file; + $bs =~ s/(\.\w+)?(;\d*)?$/\.bs/; # look for .bs 'beside' the library + if (-s $bs) { # only read file if it's not empty + print STDERR "BS: $bs ($^O, $dlsrc)\n" if $dl_debug; + eval { do $bs; }; + warn "$bs: $@\n" if $@; + } + + my $boot_symbol_ref; + + + + # Many dynamic extension loading problems will appear to come from + # this section of code: XYZ failed at line 123 of DynaLoader.pm. + # Often these errors are actually occurring in the initialisation + # C code of the extension XS file. Perl reports the error as being + # in this perl code simply because this was the last perl code + # it executed. + + my $libref = dl_load_file($file, $module->dl_load_flags) or + croak("Can't load '$file' for module $module: ".dl_error()); + + push(@dl_librefs,$libref); # record loaded object + + my @unresolved = dl_undef_symbols(); + if (@unresolved) { + require Carp; + Carp::carp("Undefined symbols present after loading $file: @unresolved\n"); + } + + $boot_symbol_ref = dl_find_symbol($libref, $bootname) or + croak("Can't find '$bootname' symbol in $file\n"); + + push(@dl_modules, $module); # record loaded module + + boot: + my $xs = dl_install_xsub("${module}::bootstrap", $boot_symbol_ref, $file); + + # See comment block above + + push(@dl_shared_objects, $file); # record files loaded + + &$xs(@args); +} + +sub dl_findfile { + # Read ext/DynaLoader/DynaLoader.doc for detailed information. + # This function does not automatically consider the architecture + # or the perl library auto directories. + my (@args) = @_; + my (@dirs, $dir); # which directories to search + my (@found); # full paths to real files we have found + #my $dl_ext= 'so'; # $Config::Config{'dlext'} suffix for perl extensions + #my $dl_so = 'so'; # $Config::Config{'so'} suffix for shared libraries + + print STDERR "dl_findfile(@args)\n" if $dl_debug; + + # accumulate directories but process files as they appear + arg: foreach(@args) { + # Special fast case: full filepath requires no search + + + if (m:/: && -f $_) { + push(@found,$_); + last arg unless wantarray; + next; + } + + + # Deal with directories first: + # Using a -L prefix is the preferred option (faster and more robust) + if (m:^-L:) { s/^-L//; push(@dirs, $_); next; } + + # Otherwise we try to try to spot directories by a heuristic + # (this is a more complicated issue than it first appears) + if (m:/: && -d $_) { push(@dirs, $_); next; } + + + + # Only files should get this far... + my(@names, $name); # what filenames to look for + if (m:-l: ) { # convert -lname to appropriate library name + s/-l//; + push(@names,"lib$_.$dl_so"); + push(@names,"lib$_.a"); + } else { # Umm, a bare name. Try various alternatives: + # these should be ordered with the most likely first + push(@names,"$_.$dl_dlext") unless m/\.$dl_dlext$/o; + push(@names,"$_.$dl_so") unless m/\.$dl_so$/o; + + push(@names,"lib$_.$dl_so") unless m:/:; + push(@names,"$_.a") if !m/\.a$/ and $dlsrc eq "dl_dld.xs"; + push(@names, $_); + } + my $dirsep = '/'; + + foreach $dir (@dirs, @dl_library_path) { + next unless -d $dir; + + foreach $name (@names) { + my($file) = "$dir$dirsep$name"; + print STDERR " checking in $dir for $name\n" if $dl_debug; + $file = ($do_expand) ? dl_expandspec($file) : (-f $file && $file); + #$file = _check_file($file); + if ($file) { + push(@found, $file); + next arg; # no need to look any further + } + } + } + } + if ($dl_debug) { + foreach(@dirs) { + print STDERR " dl_findfile ignored non-existent directory: $_\n" unless -d $_; + } + print STDERR "dl_findfile found: @found\n"; + } + return $found[0] unless wantarray; + @found; +} + + + +sub dl_expandspec { + my($spec) = @_; + # Optional function invoked if DynaLoader.pm sets $do_expand. + # Most systems do not require or use this function. + # Some systems may implement it in the dl_*.xs file in which case + # this Perl version should be excluded at build time. + + # This function is designed to deal with systems which treat some + # 'filenames' in a special way. For example VMS 'Logical Names' + # (something like unix environment variables - but different). + # This function should recognise such names and expand them into + # full file paths. + # Must return undef if $spec is invalid or file does not exist. + + my $file = $spec; # default output to input + + return undef unless -f $file; + print STDERR "dl_expandspec($spec) => $file\n" if $dl_debug; + $file; +} + +sub dl_find_symbol_anywhere +{ + my $sym = shift; + my $libref; + foreach $libref (@dl_librefs) { + my $symref = dl_find_symbol($libref,$sym); + return $symref if $symref; + } + return undef; +} + +__END__ + +=head1 NAME + +DynaLoader - Dynamically load C libraries into Perl code + +=head1 SYNOPSIS + + package YourPackage; + require DynaLoader; + @ISA = qw(... DynaLoader ...); + bootstrap YourPackage; + + # optional method for 'global' loading + sub dl_load_flags { 0x01 } + + +=head1 DESCRIPTION + +This document defines a standard generic interface to the dynamic +linking mechanisms available on many platforms. Its primary purpose is +to implement automatic dynamic loading of Perl modules. + +This document serves as both a specification for anyone wishing to +implement the DynaLoader for a new platform and as a guide for +anyone wishing to use the DynaLoader directly in an application. + +The DynaLoader is designed to be a very simple high-level +interface that is sufficiently general to cover the requirements +of SunOS, HP-UX, NeXT, Linux, VMS and other platforms. + +It is also hoped that the interface will cover the needs of OS/2, NT +etc and also allow pseudo-dynamic linking (using C at runtime). + +It must be stressed that the DynaLoader, by itself, is practically +useless for accessing non-Perl libraries because it provides almost no +Perl-to-C 'glue'. There is, for example, no mechanism for calling a C +library function or supplying arguments. A C::DynaLib module +is available from CPAN sites which performs that function for some +common system types. And since the year 2000, there's also Inline::C, +a module that allows you to write Perl subroutines in C. Also available +from your local CPAN site. + +DynaLoader Interface Summary + + @dl_library_path + @dl_resolve_using + @dl_require_symbols + $dl_debug + @dl_librefs + @dl_modules + @dl_shared_objects + Implemented in: + bootstrap($modulename) Perl + @filepaths = dl_findfile(@names) Perl + $flags = $modulename->dl_load_flags Perl + $symref = dl_find_symbol_anywhere($symbol) Perl + + $libref = dl_load_file($filename, $flags) C + $status = dl_unload_file($libref) C + $symref = dl_find_symbol($libref, $symbol) C + @symbols = dl_undef_symbols() C + dl_install_xsub($name, $symref [, $filename]) C + $message = dl_error C + +=over 4 + +=item @dl_library_path + +The standard/default list of directories in which dl_findfile() will +search for libraries etc. Directories are searched in order: +$dl_library_path[0], [1], ... etc + +@dl_library_path is initialised to hold the list of 'normal' directories +(F, etc) determined by B (C<$Config{'libpth'}>). This should +ensure portability across a wide range of platforms. + +@dl_library_path should also be initialised with any other directories +that can be determined from the environment at runtime (such as +LD_LIBRARY_PATH for SunOS). + +After initialisation @dl_library_path can be manipulated by an +application using push and unshift before calling dl_findfile(). +Unshift can be used to add directories to the front of the search order +either to save search time or to override libraries with the same name +in the 'normal' directories. + +The load function that dl_load_file() calls may require an absolute +pathname. The dl_findfile() function and @dl_library_path can be +used to search for and return the absolute pathname for the +library/object that you wish to load. + +=item @dl_resolve_using + +A list of additional libraries or other shared objects which can be +used to resolve any undefined symbols that might be generated by a +later call to load_file(). + +This is only required on some platforms which do not handle dependent +libraries automatically. For example the Socket Perl extension +library (F) contains references to many socket +functions which need to be resolved when it's loaded. Most platforms +will automatically know where to find the 'dependent' library (e.g., +F). A few platforms need to be told the +location of the dependent library explicitly. Use @dl_resolve_using +for this. + +Example usage: + + @dl_resolve_using = dl_findfile('-lsocket'); + +=item @dl_require_symbols + +A list of one or more symbol names that are in the library/object file +to be dynamically loaded. This is only required on some platforms. + +=item @dl_librefs + +An array of the handles returned by successful calls to dl_load_file(), +made by bootstrap, in the order in which they were loaded. +Can be used with dl_find_symbol() to look for a symbol in any of +the loaded files. + +=item @dl_modules + +An array of module (package) names that have been bootstrap'ed. + +=item @dl_shared_objects + +An array of file names for the shared objects that were loaded. + +=item dl_error() + +Syntax: + + $message = dl_error(); + +Error message text from the last failed DynaLoader function. Note +that, similar to errno in unix, a successful function call does not +reset this message. + +Implementations should detect the error as soon as it occurs in any of +the other functions and save the corresponding message for later +retrieval. This will avoid problems on some platforms (such as SunOS) +where the error message is very temporary (e.g., dlerror()). + +=item $dl_debug + +Internal debugging messages are enabled when $dl_debug is set true. +Currently setting $dl_debug only affects the Perl side of the +DynaLoader. These messages should help an application developer to +resolve any DynaLoader usage problems. + +$dl_debug is set to C<$ENV{'PERL_DL_DEBUG'}> if defined. + +For the DynaLoader developer/porter there is a similar debugging +variable added to the C code (see dlutils.c) and enabled if Perl was +built with the B<-DDEBUGGING> flag. This can also be set via the +PERL_DL_DEBUG environment variable. Set to 1 for minimal information or +higher for more. + +=item dl_findfile() + +Syntax: + + @filepaths = dl_findfile(@names) + +Determine the full paths (including file suffix) of one or more +loadable files given their generic names and optionally one or more +directories. Searches directories in @dl_library_path by default and +returns an empty list if no files were found. + +Names can be specified in a variety of platform independent forms. Any +names in the form B<-lname> are converted into F, where F<.*> is +an appropriate suffix for the platform. + +If a name does not already have a suitable prefix and/or suffix then +the corresponding file will be searched for by trying combinations of +prefix and suffix appropriate to the platform: "$name.o", "lib$name.*" +and "$name". + +If any directories are included in @names they are searched before +@dl_library_path. Directories may be specified as B<-Ldir>. Any other +names are treated as filenames to be searched for. + +Using arguments of the form C<-Ldir> and C<-lname> is recommended. + +Example: + + @dl_resolve_using = dl_findfile(qw(-L/usr/5lib -lposix)); + + +=item dl_expandspec() + +Syntax: + + $filepath = dl_expandspec($spec) + +Some unusual systems, such as VMS, require special filename handling in +order to deal with symbolic names for files (i.e., VMS's Logical Names). + +To support these systems a dl_expandspec() function can be implemented +either in the F file or code can be added to the dl_expandspec() +function in F. See F for more information. + +=item dl_load_file() + +Syntax: + + $libref = dl_load_file($filename, $flags) + +Dynamically load $filename, which must be the path to a shared object +or library. An opaque 'library reference' is returned as a handle for +the loaded object. Returns undef on error. + +The $flags argument to alters dl_load_file behaviour. +Assigned bits: + + 0x01 make symbols available for linking later dl_load_file's. + (only known to work on Solaris 2 using dlopen(RTLD_GLOBAL)) + (ignored under VMS; this is a normal part of image linking) + +(On systems that provide a handle for the loaded object such as SunOS +and HPUX, $libref will be that handle. On other systems $libref will +typically be $filename or a pointer to a buffer containing $filename. +The application should not examine or alter $libref in any way.) + +This is the function that does the real work. It should use the +current values of @dl_require_symbols and @dl_resolve_using if required. + + SunOS: dlopen($filename) + HP-UX: shl_load($filename) + Linux: dld_create_reference(@dl_require_symbols); dld_link($filename) + NeXT: rld_load($filename, @dl_resolve_using) + VMS: lib$find_image_symbol($filename,$dl_require_symbols[0]) + +(The dlopen() function is also used by Solaris and some versions of +Linux, and is a common choice when providing a "wrapper" on other +mechanisms as is done in the OS/2 port.) + +=item dl_unload_file() + +Syntax: + + $status = dl_unload_file($libref) + +Dynamically unload $libref, which must be an opaque 'library reference' as +returned from dl_load_file. Returns one on success and zero on failure. + +This function is optional and may not necessarily be provided on all platforms. +If it is defined, it is called automatically when the interpreter exits for +every shared object or library loaded by DynaLoader::bootstrap. All such +library references are stored in @dl_librefs by DynaLoader::Bootstrap as it +loads the libraries. The files are unloaded in last-in, first-out order. + +This unloading is usually necessary when embedding a shared-object perl (e.g. +one configured with -Duseshrplib) within a larger application, and the perl +interpreter is created and destroyed several times within the lifetime of the +application. In this case it is possible that the system dynamic linker will +unload and then subsequently reload the shared libperl without relocating any +references to it from any files DynaLoaded by the previous incarnation of the +interpreter. As a result, any shared objects opened by DynaLoader may point to +a now invalid 'ghost' of the libperl shared object, causing apparently random +memory corruption and crashes. This behaviour is most commonly seen when using +Apache and mod_perl built with the APXS mechanism. + + SunOS: dlclose($libref) + HP-UX: ??? + Linux: ??? + NeXT: ??? + VMS: ??? + +(The dlclose() function is also used by Solaris and some versions of +Linux, and is a common choice when providing a "wrapper" on other +mechanisms as is done in the OS/2 port.) + +=item dl_load_flags() + +Syntax: + + $flags = dl_load_flags $modulename; + +Designed to be a method call, and to be overridden by a derived class +(i.e. a class which has DynaLoader in its @ISA). The definition in +DynaLoader itself returns 0, which produces standard behavior from +dl_load_file(). + +=item dl_find_symbol() + +Syntax: + + $symref = dl_find_symbol($libref, $symbol) + +Return the address of the symbol $symbol or C if not found. If the +target system has separate functions to search for symbols of different +types then dl_find_symbol() should search for function symbols first and +then other types. + +The exact manner in which the address is returned in $symref is not +currently defined. The only initial requirement is that $symref can +be passed to, and understood by, dl_install_xsub(). + + SunOS: dlsym($libref, $symbol) + HP-UX: shl_findsym($libref, $symbol) + Linux: dld_get_func($symbol) and/or dld_get_symbol($symbol) + NeXT: rld_lookup("_$symbol") + VMS: lib$find_image_symbol($libref,$symbol) + + +=item dl_find_symbol_anywhere() + +Syntax: + + $symref = dl_find_symbol_anywhere($symbol) + +Applies dl_find_symbol() to the members of @dl_librefs and returns +the first match found. + +=item dl_undef_symbols() + +Example + + @symbols = dl_undef_symbols() + +Return a list of symbol names which remain undefined after load_file(). +Returns C<()> if not known. Don't worry if your platform does not provide +a mechanism for this. Most do not need it and hence do not provide it, +they just return an empty list. + + +=item dl_install_xsub() + +Syntax: + + dl_install_xsub($perl_name, $symref [, $filename]) + +Create a new Perl external subroutine named $perl_name using $symref as +a pointer to the function which implements the routine. This is simply +a direct call to newXSUB(). Returns a reference to the installed +function. + +The $filename parameter is used by Perl to identify the source file for +the function if required by die(), caller() or the debugger. If +$filename is not defined then "DynaLoader" will be used. + + +=item bootstrap() + +Syntax: + +bootstrap($module [...]) + +This is the normal entry point for automatic dynamic loading in Perl. + +It performs the following actions: + +=over 8 + +=item * + +locates an auto/$module directory by searching @INC + +=item * + +uses dl_findfile() to determine the filename to load + +=item * + +sets @dl_require_symbols to C<("boot_$module")> + +=item * + +executes an F file if it exists +(typically used to add to @dl_resolve_using any files which +are required to load the module on the current platform) + +=item * + +calls dl_load_flags() to determine how to load the file. + +=item * + +calls dl_load_file() to load the file + +=item * + +calls dl_undef_symbols() and warns if any symbols are undefined + +=item * + +calls dl_find_symbol() for "boot_$module" + +=item * + +calls dl_install_xsub() to install it as "${module}::bootstrap" + +=item * + +calls &{"${module}::bootstrap"} to bootstrap the module (actually +it uses the function reference returned by dl_install_xsub for speed) + +=back + +All arguments to bootstrap() are passed to the module's bootstrap function. +The default code generated by F expects $module [, $version] +If the optional $version argument is not given, it defaults to +C<$XS_VERSION // $VERSION> in the module's symbol table. The default code +compares the Perl-space version with the version of the compiled XS code, +and croaks with an error if they do not match. + +=back + + +=head1 AUTHOR + +Tim Bunce, 11 August 1994. + +This interface is based on the work and comments of (in no particular +order): Larry Wall, Robert Sanders, Dean Roehrich, Jeff Okamoto, Anno +Siegel, Thomas Neumann, Paul Marquess, Charles Bailey, myself and others. + +Larry Wall designed the elegant inherited bootstrap mechanism and +implemented the first Perl 5 dynamic loader using it. + +Solaris global loading added by Nick Ing-Simmons with design/coding +assistance from Tim Bunce, January 1996. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/Errno.pm b/testsuite/input-files/perl-v5.14.2/lib/Errno.pm new file mode 100644 index 00000000..aeea180e --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Errno.pm @@ -0,0 +1,283 @@ +# -*- buffer-read-only: t -*- +# +# This file is auto-generated. ***ANY*** changes here will be lost +# + +package Errno; +require Exporter; +use Config; +use strict; + +"$Config{'archname'}-$Config{'osvers'}" eq +"x86_64-linux-3.13.0-43-lowlatency" or + die "Errno architecture (x86_64-linux-3.13.0-43-lowlatency) does not match executable architecture ($Config{'archname'}-$Config{'osvers'})"; + +our $VERSION = "1.13"; +$VERSION = eval $VERSION; +our @ISA = 'Exporter'; + +my %err; + +BEGIN { + %err = ( + EPERM => 1, + ENOENT => 2, + ESRCH => 3, + EINTR => 4, + EIO => 5, + ENXIO => 6, + E2BIG => 7, + ENOEXEC => 8, + EBADF => 9, + ECHILD => 10, + EWOULDBLOCK => 11, + EAGAIN => 11, + ENOMEM => 12, + EACCES => 13, + EFAULT => 14, + ENOTBLK => 15, + EBUSY => 16, + EEXIST => 17, + EXDEV => 18, + ENODEV => 19, + ENOTDIR => 20, + EISDIR => 21, + EINVAL => 22, + ENFILE => 23, + EMFILE => 24, + ENOTTY => 25, + ETXTBSY => 26, + EFBIG => 27, + ENOSPC => 28, + ESPIPE => 29, + EROFS => 30, + EMLINK => 31, + EPIPE => 32, + EDOM => 33, + ERANGE => 34, + EDEADLOCK => 35, + EDEADLK => 35, + ENAMETOOLONG => 36, + ENOLCK => 37, + ENOSYS => 38, + ENOTEMPTY => 39, + ELOOP => 40, + ENOMSG => 42, + EIDRM => 43, + ECHRNG => 44, + EL2NSYNC => 45, + EL3HLT => 46, + EL3RST => 47, + ELNRNG => 48, + EUNATCH => 49, + ENOCSI => 50, + EL2HLT => 51, + EBADE => 52, + EBADR => 53, + EXFULL => 54, + ENOANO => 55, + EBADRQC => 56, + EBADSLT => 57, + EBFONT => 59, + ENOSTR => 60, + ENODATA => 61, + ETIME => 62, + ENOSR => 63, + ENONET => 64, + ENOPKG => 65, + EREMOTE => 66, + ENOLINK => 67, + EADV => 68, + ESRMNT => 69, + ECOMM => 70, + EPROTO => 71, + EMULTIHOP => 72, + EDOTDOT => 73, + EBADMSG => 74, + EOVERFLOW => 75, + ENOTUNIQ => 76, + EBADFD => 77, + EREMCHG => 78, + ELIBACC => 79, + ELIBBAD => 80, + ELIBSCN => 81, + ELIBMAX => 82, + ELIBEXEC => 83, + EILSEQ => 84, + ERESTART => 85, + ESTRPIPE => 86, + EUSERS => 87, + ENOTSOCK => 88, + EDESTADDRREQ => 89, + EMSGSIZE => 90, + EPROTOTYPE => 91, + ENOPROTOOPT => 92, + EPROTONOSUPPORT => 93, + ESOCKTNOSUPPORT => 94, + ENOTSUP => 95, + EOPNOTSUPP => 95, + EPFNOSUPPORT => 96, + EAFNOSUPPORT => 97, + EADDRINUSE => 98, + EADDRNOTAVAIL => 99, + ENETDOWN => 100, + ENETUNREACH => 101, + ENETRESET => 102, + ECONNABORTED => 103, + ECONNRESET => 104, + ENOBUFS => 105, + EISCONN => 106, + ENOTCONN => 107, + ESHUTDOWN => 108, + ETOOMANYREFS => 109, + ETIMEDOUT => 110, + ECONNREFUSED => 111, + EHOSTDOWN => 112, + EHOSTUNREACH => 113, + EALREADY => 114, + EINPROGRESS => 115, + ESTALE => 116, + EUCLEAN => 117, + ENOTNAM => 118, + ENAVAIL => 119, + EISNAM => 120, + EREMOTEIO => 121, + EDQUOT => 122, + ENOMEDIUM => 123, + EMEDIUMTYPE => 124, + ECANCELED => 125, + ENOKEY => 126, + EKEYEXPIRED => 127, + EKEYREVOKED => 128, + EKEYREJECTED => 129, + EOWNERDEAD => 130, + ENOTRECOVERABLE => 131, + ERFKILL => 132, + EHWPOISON => 133, + ); + # Generate proxy constant subroutines for all the values. + # Well, almost all the values. Unfortunately we can't assume that at this + # point that our symbol table is empty, as code such as if the parser has + # seen code such as C, it will have created the + # typeglob. + # Doing this before defining @EXPORT_OK etc means that even if a platform is + # crazy enough to define EXPORT_OK as an error constant, everything will + # still work, because the parser will upgrade the PCS to a real typeglob. + # We rely on the subroutine definitions below to update the internal caches. + # Don't use %each, as we don't want a copy of the value. + foreach my $name (keys %err) { + if ($Errno::{$name}) { + # We expect this to be reached fairly rarely, so take an approach + # which uses the least compile time effort in the common case: + eval "sub $name() { $err{$name} }; 1" or die $@; + } else { + $Errno::{$name} = \$err{$name}; + } + } +} + +our @EXPORT_OK = keys %err; + +our %EXPORT_TAGS = ( + POSIX => [qw( + E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT EAGAIN EALREADY + EBADF EBUSY ECHILD ECONNABORTED ECONNREFUSED ECONNRESET EDEADLK + EDESTADDRREQ EDOM EDQUOT EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH + EINPROGRESS EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK + EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH ENFILE ENOBUFS + ENODEV ENOENT ENOEXEC ENOLCK ENOMEM ENOPROTOOPT ENOSPC ENOSYS ENOTBLK + ENOTCONN ENOTDIR ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM + EPFNOSUPPORT EPIPE EPROTONOSUPPORT EPROTOTYPE ERANGE EREMOTE ERESTART + EROFS ESHUTDOWN ESOCKTNOSUPPORT ESPIPE ESRCH ESTALE ETIMEDOUT + ETOOMANYREFS ETXTBSY EUSERS EWOULDBLOCK EXDEV + )] +); + +sub TIEHASH { bless \%err } + +sub FETCH { + my (undef, $errname) = @_; + return "" unless exists $err{$errname}; + my $errno = $err{$errname}; + return $errno == $! ? $errno : 0; +} + +sub STORE { + require Carp; + Carp::confess("ERRNO hash is read only!"); +} + +*CLEAR = *DELETE = \*STORE; # Typeglob aliasing uses less space + +sub NEXTKEY { + each %err; +} + +sub FIRSTKEY { + my $s = scalar keys %err; # initialize iterator + each %err; +} + +sub EXISTS { + my (undef, $errname) = @_; + exists $err{$errname}; +} + +tie %!, __PACKAGE__; # Returns an object, objects are true. + +__END__ + +=head1 NAME + +Errno - System errno constants + +=head1 SYNOPSIS + + use Errno qw(EINTR EIO :POSIX); + +=head1 DESCRIPTION + +C defines and conditionally exports all the error constants +defined in your system C include file. It has a single export +tag, C<:POSIX>, which will export all POSIX defined error numbers. + +C also makes C<%!> magic such that each element of C<%!> has a +non-zero value only if C<$!> is set to that value. For example: + + use Errno; + + unless (open(FH, "/fangorn/spouse")) { + if ($!{ENOENT}) { + warn "Get a wife!\n"; + } else { + warn "This path is barred: $!"; + } + } + +If a specified constant C does not exist on the system, C<$!{EFOO}> +returns C<"">. You may use C to check whether the +constant is available on the system. + +=head1 CAVEATS + +Importing a particular constant may not be very portable, because the +import will fail on platforms that do not have that constant. A more +portable way to set C<$!> to a valid value is to use: + + if (exists &Errno::EFOO) { + $! = &Errno::EFOO; + } + +=head1 AUTHOR + +Graham Barr + +=head1 COPYRIGHT + +Copyright (c) 1997-8 Graham Barr. All rights reserved. +This program is free software; you can redistribute it and/or modify it +under the same terms as Perl itself. + +=cut + +# ex: set ro: diff --git a/testsuite/input-files/perl-v5.14.2/lib/Exporter.pm b/testsuite/input-files/perl-v5.14.2/lib/Exporter.pm new file mode 100644 index 00000000..a371714e --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Exporter.pm @@ -0,0 +1,587 @@ +package Exporter; + +require 5.006; + +# Be lean. +#use strict; +#no strict 'refs'; + +our $Debug = 0; +our $ExportLevel = 0; +our $Verbose ||= 0; +our $VERSION = '5.64_03'; +our (%Cache); + +sub as_heavy { + require Exporter::Heavy; + # Unfortunately, this does not work if the caller is aliased as *name = \&foo + # Thus the need to create a lot of identical subroutines + my $c = (caller(1))[3]; + $c =~ s/.*:://; + \&{"Exporter::Heavy::heavy_$c"}; +} + +sub export { + goto &{as_heavy()}; +} + +sub import { + my $pkg = shift; + my $callpkg = caller($ExportLevel); + + if ($pkg eq "Exporter" and @_ and $_[0] eq "import") { + *{$callpkg."::import"} = \&import; + return; + } + + # We *need* to treat @{"$pkg\::EXPORT_FAIL"} since Carp uses it :-( + my $exports = \@{"$pkg\::EXPORT"}; + # But, avoid creating things if they don't exist, which saves a couple of + # hundred bytes per package processed. + my $fail = ${$pkg . '::'}{EXPORT_FAIL} && \@{"$pkg\::EXPORT_FAIL"}; + return export $pkg, $callpkg, @_ + if $Verbose or $Debug or $fail && @$fail > 1; + my $export_cache = ($Cache{$pkg} ||= {}); + my $args = @_ or @_ = @$exports; + + local $_; + if ($args and not %$export_cache) { + s/^&//, $export_cache->{$_} = 1 + foreach (@$exports, @{"$pkg\::EXPORT_OK"}); + } + my $heavy; + # Try very hard not to use {} and hence have to enter scope on the foreach + # We bomb out of the loop with last as soon as heavy is set. + if ($args or $fail) { + ($heavy = (/\W/ or $args and not exists $export_cache->{$_} + or $fail and @$fail and $_ eq $fail->[0])) and last + foreach (@_); + } else { + ($heavy = /\W/) and last + foreach (@_); + } + return export $pkg, $callpkg, ($args ? @_ : ()) if $heavy; + local $SIG{__WARN__} = + sub {require Carp; &Carp::carp} if not $SIG{__WARN__}; + # shortcut for the common case of no type character + *{"$callpkg\::$_"} = \&{"$pkg\::$_"} foreach @_; +} + +# Default methods + +sub export_fail { + my $self = shift; + @_; +} + +# Unfortunately, caller(1)[3] "does not work" if the caller is aliased as +# *name = \&foo. Thus the need to create a lot of identical subroutines +# Otherwise we could have aliased them to export(). + +sub export_to_level { + goto &{as_heavy()}; +} + +sub export_tags { + goto &{as_heavy()}; +} + +sub export_ok_tags { + goto &{as_heavy()}; +} + +sub require_version { + goto &{as_heavy()}; +} + +1; +__END__ + +=head1 NAME + +Exporter - Implements default import method for modules + +=head1 SYNOPSIS + +In module F: + + package YourModule; + require Exporter; + @ISA = qw(Exporter); + @EXPORT_OK = qw(munge frobnicate); # symbols to export on request + +or + + package YourModule; + use Exporter 'import'; # gives you Exporter's import() method directly + @EXPORT_OK = qw(munge frobnicate); # symbols to export on request + +In other files which wish to use C: + + use YourModule qw(frobnicate); # import listed symbols + frobnicate ($left, $right) # calls YourModule::frobnicate + +Take a look at L for some variants +you will like to use in modern Perl code. + +=head1 DESCRIPTION + +The Exporter module implements an C method which allows a module +to export functions and variables to its users' namespaces. Many modules +use Exporter rather than implementing their own C method because +Exporter provides a highly flexible interface, with an implementation optimised +for the common case. + +Perl automatically calls the C method when processing a +C statement for a module. Modules and C are documented +in L and L. Understanding the concept of +modules and how the C statement operates is important to +understanding the Exporter. + +=head2 How to Export + +The arrays C<@EXPORT> and C<@EXPORT_OK> in a module hold lists of +symbols that are going to be exported into the users name space by +default, or which they can request to be exported, respectively. The +symbols can represent functions, scalars, arrays, hashes, or typeglobs. +The symbols must be given by full name with the exception that the +ampersand in front of a function is optional, e.g. + + @EXPORT = qw(afunc $scalar @array); # afunc is a function + @EXPORT_OK = qw(&bfunc %hash *typeglob); # explicit prefix on &bfunc + +If you are only exporting function names it is recommended to omit the +ampersand, as the implementation is faster this way. + +=head2 Selecting What To Export + +Do B export method names! + +Do B export anything else by default without a good reason! + +Exports pollute the namespace of the module user. If you must export +try to use C<@EXPORT_OK> in preference to C<@EXPORT> and avoid short or +common symbol names to reduce the risk of name clashes. + +Generally anything not exported is still accessible from outside the +module using the C (or C<< $blessed_ref->method >>) +syntax. By convention you can use a leading underscore on names to +informally indicate that they are 'internal' and not for public use. + +(It is actually possible to get private functions by saying: + + my $subref = sub { ... }; + $subref->(@args); # Call it as a function + $obj->$subref(@args); # Use it as a method + +However if you use them for methods it is up to you to figure out +how to make inheritance work.) + +As a general rule, if the module is trying to be object oriented +then export nothing. If it's just a collection of functions then +C<@EXPORT_OK> anything but use C<@EXPORT> with caution. For function and +method names use barewords in preference to names prefixed with +ampersands for the export lists. + +Other module design guidelines can be found in L. + +=head2 How to Import + +In other files which wish to use your module there are three basic ways for +them to load your module and import its symbols: + +=over 4 + +=item C + +This imports all the symbols from YourModule's C<@EXPORT> into the namespace +of the C statement. + +=item C + +This causes perl to load your module but does not import any symbols. + +=item C + +This imports only the symbols listed by the caller into their namespace. +All listed symbols must be in your C<@EXPORT> or C<@EXPORT_OK>, else an error +occurs. The advanced export features of Exporter are accessed like this, +but with list entries that are syntactically distinct from symbol names. + +=back + +Unless you want to use its advanced features, this is probably all you +need to know to use Exporter. + +=head1 Advanced features + +=head2 Specialised Import Lists + +If any of the entries in an import list begins with !, : or / then +the list is treated as a series of specifications which either add to +or delete from the list of names to import. They are processed left to +right. Specifications are in the form: + + [!]name This name only + [!]:DEFAULT All names in @EXPORT + [!]:tag All names in $EXPORT_TAGS{tag} anonymous list + [!]/pattern/ All names in @EXPORT and @EXPORT_OK which match + +A leading ! indicates that matching names should be deleted from the +list of names to import. If the first specification is a deletion it +is treated as though preceded by :DEFAULT. If you just want to import +extra names in addition to the default set you will still need to +include :DEFAULT explicitly. + +e.g., F defines: + + @EXPORT = qw(A1 A2 A3 A4 A5); + @EXPORT_OK = qw(B1 B2 B3 B4 B5); + %EXPORT_TAGS = (T1 => [qw(A1 A2 B1 B2)], T2 => [qw(A1 A2 B3 B4)]); + + Note that you cannot use tags in @EXPORT or @EXPORT_OK. + Names in EXPORT_TAGS must also appear in @EXPORT or @EXPORT_OK. + +An application using Module can say something like: + + use Module qw(:DEFAULT :T2 !B3 A3); + +Other examples include: + + use Socket qw(!/^[AP]F_/ !SOMAXCONN !SOL_SOCKET); + use POSIX qw(:errno_h :termios_h !TCSADRAIN !/^EXIT/); + +Remember that most patterns (using //) will need to be anchored +with a leading ^, e.g., C rather than C. + +You can say C to see how the +specifications are being processed and what is actually being imported +into modules. + +=head2 Exporting without using Exporter's import method + +Exporter has a special method, 'export_to_level' which is used in situations +where you can't directly call Exporter's import method. The export_to_level +method looks like: + + MyPackage->export_to_level($where_to_export, $package, @what_to_export); + +where C<$where_to_export> is an integer telling how far up the calling stack +to export your symbols, and C<@what_to_export> is an array telling what +symbols *to* export (usually this is C<@_>). The C<$package> argument is +currently unused. + +For example, suppose that you have a module, A, which already has an +import function: + + package A; + + @ISA = qw(Exporter); + @EXPORT_OK = qw ($b); + + sub import + { + $A::b = 1; # not a very useful import method + } + +and you want to Export symbol C<$A::b> back to the module that called +package A. Since Exporter relies on the import method to work, via +inheritance, as it stands Exporter::import() will never get called. +Instead, say the following: + + package A; + @ISA = qw(Exporter); + @EXPORT_OK = qw ($b); + + sub import + { + $A::b = 1; + A->export_to_level(1, @_); + } + +This will export the symbols one level 'above' the current package - ie: to +the program or module that used package A. + +Note: Be careful not to modify C<@_> at all before you call export_to_level +- or people using your package will get very unexplained results! + +=head2 Exporting without inheriting from Exporter + +By including Exporter in your C<@ISA> you inherit an Exporter's import() method +but you also inherit several other helper methods which you probably don't +want. To avoid this you can do + + package YourModule; + use Exporter qw( import ); + +which will export Exporter's own import() method into YourModule. +Everything will work as before but you won't need to include Exporter in +C<@YourModule::ISA>. + +Note: This feature was introduced in version 5.57 +of Exporter, released with perl 5.8.3. + +=head2 Module Version Checking + +The Exporter module will convert an attempt to import a number from a +module into a call to C<< $module_name->require_version($value) >>. This can +be used to validate that the version of the module being used is +greater than or equal to the required version. + +The Exporter module supplies a default C method which +checks the value of C<$VERSION> in the exporting module. + +Since the default C method treats the C<$VERSION> number as +a simple numeric value it will regard version 1.10 as lower than +1.9. For this reason it is strongly recommended that you use numbers +with at least two decimal places, e.g., 1.09. + +=head2 Managing Unknown Symbols + +In some situations you may want to prevent certain symbols from being +exported. Typically this applies to extensions which have functions +or constants that may not exist on some systems. + +The names of any symbols that cannot be exported should be listed +in the C<@EXPORT_FAIL> array. + +If a module attempts to import any of these symbols the Exporter +will give the module an opportunity to handle the situation before +generating an error. The Exporter will call an export_fail method +with a list of the failed symbols: + + @failed_symbols = $module_name->export_fail(@failed_symbols); + +If the C method returns an empty list then no error is +recorded and all the requested symbols are exported. If the returned +list is not empty then an error is generated for each symbol and the +export fails. The Exporter provides a default C method which +simply returns the list unchanged. + +Uses for the C method include giving better error messages +for some symbols and performing lazy architectural checks (put more +symbols into C<@EXPORT_FAIL> by default and then take them out if someone +actually tries to use them and an expensive check shows that they are +usable on that platform). + +=head2 Tag Handling Utility Functions + +Since the symbols listed within C<%EXPORT_TAGS> must also appear in either +C<@EXPORT> or C<@EXPORT_OK>, two utility functions are provided which allow +you to easily add tagged sets of symbols to C<@EXPORT> or C<@EXPORT_OK>: + + %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]); + + Exporter::export_tags('foo'); # add aa, bb and cc to @EXPORT + Exporter::export_ok_tags('bar'); # add aa, cc and dd to @EXPORT_OK + +Any names which are not tags are added to C<@EXPORT> or C<@EXPORT_OK> +unchanged but will trigger a warning (with C<-w>) to avoid misspelt tags +names being silently added to C<@EXPORT> or C<@EXPORT_OK>. Future versions +may make this a fatal error. + +=head2 Generating combined tags + +If several symbol categories exist in C<%EXPORT_TAGS>, it's usually +useful to create the utility ":all" to simplify "use" statements. + +The simplest way to do this is: + + %EXPORT_TAGS = (foo => [qw(aa bb cc)], bar => [qw(aa cc dd)]); + + # add all the other ":class" tags to the ":all" class, + # deleting duplicates + { + my %seen; + + push @{$EXPORT_TAGS{all}}, + grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}} foreach keys %EXPORT_TAGS; + } + +F creates an ":all" tag which contains some (but not really +all) of its categories. That could be done with one small +change: + + # add some of the other ":class" tags to the ":all" class, + # deleting duplicates + { + my %seen; + + push @{$EXPORT_TAGS{all}}, + grep {!$seen{$_}++} @{$EXPORT_TAGS{$_}} + foreach qw/html2 html3 netscape form cgi internal/; + } + +Note that the tag names in C<%EXPORT_TAGS> don't have the leading ':'. + +=head2 Ced Constants + +Many modules make use of Cing for constant subroutines to +avoid having to compile and waste memory on rarely used values (see +L for details on constant subroutines). Calls to such +constant subroutines are not optimized away at compile time because +they can't be checked at compile time for constancy. + +Even if a prototype is available at compile time, the body of the +subroutine is not (it hasn't been Ced yet). perl needs to +examine both the C<()> prototype and the body of a subroutine at +compile time to detect that it can safely replace calls to that +subroutine with the constant value. + +A workaround for this is to call the constants once in a C block: + + package My ; + + use Socket ; + + foo( SO_LINGER ); ## SO_LINGER NOT optimized away; called at runtime + BEGIN { SO_LINGER } + foo( SO_LINGER ); ## SO_LINGER optimized away at compile time. + +This forces the C for C to take place before +SO_LINGER is encountered later in C package. + +If you are writing a package that Cs, consider forcing +an C for any constants explicitly imported by other packages +or which are usually used when your package is Cd. + +=head1 Good Practices + +=head2 Declaring C<@EXPORT_OK> and Friends + +When using C with the standard C and C +pragmas, the C keyword is needed to declare the package +variables C<@EXPORT_OK>, C<@EXPORT>, C<@ISA>, etc. + + our @ISA = qw(Exporter); + our @EXPORT_OK = qw(munge frobnicate); + +If backward compatibility for Perls under 5.6 is important, +one must write instead a C statement. + + use vars qw(@ISA @EXPORT_OK); + @ISA = qw(Exporter); + @EXPORT_OK = qw(munge frobnicate); + +=head2 Playing Safe + +There are some caveats with the use of runtime statements +like C and the assignment to package +variables, which can very subtle for the unaware programmer. +This may happen for instance with mutually recursive +modules, which are affected by the time the relevant +constructions are executed. + +The ideal (but a bit ugly) way to never have to think +about that is to use C blocks. So the first part +of the L code could be rewritten as: + + package YourModule; + + use strict; + use warnings; + + our (@ISA, @EXPORT_OK); + BEGIN { + require Exporter; + @ISA = qw(Exporter); + @EXPORT_OK = qw(munge frobnicate); # symbols to export on request + } + +The C will assure that the loading of F +and the assignments to C<@ISA> and C<@EXPORT_OK> happen +immediately, leaving no room for something to get awry +or just plain wrong. + +With respect to loading C and inheriting, there +are alternatives with the use of modules like C and C. + + use base qw( Exporter ); + # or + use parent qw( Exporter ); + +Any of these statements are nice replacements for +C +with the same compile-time effect. The basic difference +is that C code interacts with declared C +while C is a streamlined version of the older +C code to just establish the IS-A relationship. + +For more details, see the documentation and code of +L and L. + +Another thorough remedy to that runtime vs. +compile-time trap is to use L, +which is a wrapper of Exporter that allows all +boilerplate code at a single gulp in the +use statement. + + use Exporter::Easy ( + OK => [ qw(munge frobnicate) ], + ); + # @ISA setup is automatic + # all assignments happen at compile time + +=head2 What not to Export + +You have been warned already in L +to not export: + +=over 4 + +=item * + +method names (because you don't need to +and that's likely to not do what you want), + +=item * + +anything by default (because you don't want to surprise your users... +badly) + +=item * + +anything you don't need to (because less is more) + +=back + +There's one more item to add to this list. Do B +export variable names. Just because C lets you +do that, it does not mean you should. + + @EXPORT_OK = qw( $svar @avar %hvar ); # DON'T! + +Exporting variables is not a good idea. They can +change under the hood, provoking horrible +effects at-a-distance, that are too hard to track +and to fix. Trust me: they are not worth it. + +To provide the capability to set/get class-wide +settings, it is best instead to provide accessors +as subroutines or class methods instead. + +=head1 SEE ALSO + +C is definitely not the only module with +symbol exporter capabilities. At CPAN, you may find +a bunch of them. Some are lighter. Some +provide improved APIs and features. Peek the one +that fits your needs. The following is +a sample list of such modules. + + Exporter::Easy + Exporter::Lite + Exporter::Renaming + Exporter::Tidy + Sub::Exporter / Sub::Installer + Perl6::Export / Perl6::Export::Attrs + +=head1 LICENSE + +This library is free software. You can redistribute it +and/or modify it under the same terms as Perl itself. + +=cut + + + diff --git a/testsuite/input-files/perl-v5.14.2/lib/Exporter/Heavy.pm b/testsuite/input-files/perl-v5.14.2/lib/Exporter/Heavy.pm new file mode 100644 index 00000000..724028a2 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Exporter/Heavy.pm @@ -0,0 +1,248 @@ +package Exporter::Heavy; + +use strict; +no strict 'refs'; + +# On one line so MakeMaker will see it. +require Exporter; our $VERSION = $Exporter::VERSION; + +=head1 NAME + +Exporter::Heavy - Exporter guts + +=head1 SYNOPSIS + +(internal use only) + +=head1 DESCRIPTION + +No user-serviceable parts inside. + +=cut + +# +# We go to a lot of trouble not to 'require Carp' at file scope, +# because Carp requires Exporter, and something has to give. +# + +sub _rebuild_cache { + my ($pkg, $exports, $cache) = @_; + s/^&// foreach @$exports; + @{$cache}{@$exports} = (1) x @$exports; + my $ok = \@{"${pkg}::EXPORT_OK"}; + if (@$ok) { + s/^&// foreach @$ok; + @{$cache}{@$ok} = (1) x @$ok; + } +} + +sub heavy_export { + + # First make import warnings look like they're coming from the "use". + local $SIG{__WARN__} = sub { + my $text = shift; + if ($text =~ s/ at \S*Exporter\S*.pm line \d+.*\n//) { + require Carp; + local $Carp::CarpLevel = 1; # ignore package calling us too. + Carp::carp($text); + } + else { + warn $text; + } + }; + local $SIG{__DIE__} = sub { + require Carp; + local $Carp::CarpLevel = 1; # ignore package calling us too. + Carp::croak("$_[0]Illegal null symbol in \@${1}::EXPORT") + if $_[0] =~ /^Unable to create sub named "(.*?)::"/; + }; + + my($pkg, $callpkg, @imports) = @_; + my($type, $sym, $cache_is_current, $oops); + my($exports, $export_cache) = (\@{"${pkg}::EXPORT"}, + $Exporter::Cache{$pkg} ||= {}); + + if (@imports) { + if (!%$export_cache) { + _rebuild_cache ($pkg, $exports, $export_cache); + $cache_is_current = 1; + } + + if (grep m{^[/!:]}, @imports) { + my $tagsref = \%{"${pkg}::EXPORT_TAGS"}; + my $tagdata; + my %imports; + my($remove, $spec, @names, @allexports); + # negated first item implies starting with default set: + unshift @imports, ':DEFAULT' if $imports[0] =~ m/^!/; + foreach $spec (@imports){ + $remove = $spec =~ s/^!//; + + if ($spec =~ s/^://){ + if ($spec eq 'DEFAULT'){ + @names = @$exports; + } + elsif ($tagdata = $tagsref->{$spec}) { + @names = @$tagdata; + } + else { + warn qq["$spec" is not defined in %${pkg}::EXPORT_TAGS]; + ++$oops; + next; + } + } + elsif ($spec =~ m:^/(.*)/$:){ + my $patn = $1; + @allexports = keys %$export_cache unless @allexports; # only do keys once + @names = grep(/$patn/, @allexports); # not anchored by default + } + else { + @names = ($spec); # is a normal symbol name + } + + warn "Import ".($remove ? "del":"add").": @names " + if $Exporter::Verbose; + + if ($remove) { + foreach $sym (@names) { delete $imports{$sym} } + } + else { + @imports{@names} = (1) x @names; + } + } + @imports = keys %imports; + } + + my @carp; + foreach $sym (@imports) { + if (!$export_cache->{$sym}) { + if ($sym =~ m/^\d/) { + $pkg->VERSION($sym); # inherit from UNIVERSAL + # If the version number was the only thing specified + # then we should act as if nothing was specified: + if (@imports == 1) { + @imports = @$exports; + last; + } + # We need a way to emulate 'use Foo ()' but still + # allow an easy version check: "use Foo 1.23, ''"; + if (@imports == 2 and !$imports[1]) { + @imports = (); + last; + } + } elsif ($sym !~ s/^&// || !$export_cache->{$sym}) { + # Last chance - see if they've updated EXPORT_OK since we + # cached it. + + unless ($cache_is_current) { + %$export_cache = (); + _rebuild_cache ($pkg, $exports, $export_cache); + $cache_is_current = 1; + } + + if (!$export_cache->{$sym}) { + # accumulate the non-exports + push @carp, + qq["$sym" is not exported by the $pkg module\n]; + $oops++; + } + } + } + } + if ($oops) { + require Carp; + Carp::croak("@{carp}Can't continue after import errors"); + } + } + else { + @imports = @$exports; + } + + my($fail, $fail_cache) = (\@{"${pkg}::EXPORT_FAIL"}, + $Exporter::FailCache{$pkg} ||= {}); + + if (@$fail) { + if (!%$fail_cache) { + # Build cache of symbols. Optimise the lookup by adding + # barewords twice... both with and without a leading &. + # (Technique could be applied to $export_cache at cost of memory) + my @expanded = map { /^\w/ ? ($_, '&'.$_) : $_ } @$fail; + warn "${pkg}::EXPORT_FAIL cached: @expanded" if $Exporter::Verbose; + @{$fail_cache}{@expanded} = (1) x @expanded; + } + my @failed; + foreach $sym (@imports) { push(@failed, $sym) if $fail_cache->{$sym} } + if (@failed) { + @failed = $pkg->export_fail(@failed); + foreach $sym (@failed) { + require Carp; + Carp::carp(qq["$sym" is not implemented by the $pkg module ], + "on this architecture"); + } + if (@failed) { + require Carp; + Carp::croak("Can't continue after import errors"); + } + } + } + + warn "Importing into $callpkg from $pkg: ", + join(", ",sort @imports) if $Exporter::Verbose; + + foreach $sym (@imports) { + # shortcut for the common case of no type character + (*{"${callpkg}::$sym"} = \&{"${pkg}::$sym"}, next) + unless $sym =~ s/^(\W)//; + $type = $1; + no warnings 'once'; + *{"${callpkg}::$sym"} = + $type eq '&' ? \&{"${pkg}::$sym"} : + $type eq '$' ? \${"${pkg}::$sym"} : + $type eq '@' ? \@{"${pkg}::$sym"} : + $type eq '%' ? \%{"${pkg}::$sym"} : + $type eq '*' ? *{"${pkg}::$sym"} : + do { require Carp; Carp::croak("Can't export symbol: $type$sym") }; + } +} + +sub heavy_export_to_level +{ + my $pkg = shift; + my $level = shift; + (undef) = shift; # XXX redundant arg + my $callpkg = caller($level); + $pkg->export($callpkg, @_); +} + +# Utility functions + +sub _push_tags { + my($pkg, $var, $syms) = @_; + my @nontag = (); + my $export_tags = \%{"${pkg}::EXPORT_TAGS"}; + push(@{"${pkg}::$var"}, + map { $export_tags->{$_} ? @{$export_tags->{$_}} + : scalar(push(@nontag,$_),$_) } + (@$syms) ? @$syms : keys %$export_tags); + if (@nontag and $^W) { + # This may change to a die one day + require Carp; + Carp::carp(join(", ", @nontag)." are not tags of $pkg"); + } +} + +sub heavy_require_version { + my($self, $wanted) = @_; + my $pkg = ref $self || $self; + return ${pkg}->VERSION($wanted); +} + +sub heavy_export_tags { + _push_tags((caller)[0], "EXPORT", \@_); +} + +sub heavy_export_ok_tags { + _push_tags((caller)[0], "EXPORT_OK", \@_); +} + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/Fcntl.pm b/testsuite/input-files/perl-v5.14.2/lib/Fcntl.pm new file mode 100644 index 00000000..cc35ff02 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Fcntl.pm @@ -0,0 +1,186 @@ +package Fcntl; + +=head1 NAME + +Fcntl - load the C Fcntl.h defines + +=head1 SYNOPSIS + + use Fcntl; + use Fcntl qw(:DEFAULT :flock); + +=head1 DESCRIPTION + +This module is just a translation of the C F file. +Unlike the old mechanism of requiring a translated F +file, this uses the B program (see the Perl source distribution) +and your native C compiler. This means that it has a +far more likely chance of getting the numbers right. + +=head1 NOTE + +Only C<#define> symbols get translated; you must still correctly +pack up your own arguments to pass as args for locking functions, etc. + +=head1 EXPORTED SYMBOLS + +By default your system's F_* and O_* constants (eg, F_DUPFD and +O_CREAT) and the FD_CLOEXEC constant are exported into your namespace. + +You can request that the flock() constants (LOCK_SH, LOCK_EX, LOCK_NB +and LOCK_UN) be provided by using the tag C<:flock>. See L. + +You can request that the old constants (FAPPEND, FASYNC, FCREAT, +FDEFER, FEXCL, FNDELAY, FNONBLOCK, FSYNC, FTRUNC) be provided for +compatibility reasons by using the tag C<:Fcompat>. For new +applications the newer versions of these constants are suggested +(O_APPEND, O_ASYNC, O_CREAT, O_DEFER, O_EXCL, O_NDELAY, O_NONBLOCK, +O_SYNC, O_TRUNC). + +For ease of use also the SEEK_* constants (for seek() and sysseek(), +e.g. SEEK_END) and the S_I* constants (for chmod() and stat()) are +available for import. They can be imported either separately or using +the tags C<:seek> and C<:mode>. + +Please refer to your native fcntl(2), open(2), fseek(3), lseek(2) +(equal to Perl's seek() and sysseek(), respectively), and chmod(2) +documentation to see what constants are implemented in your system. + +See L to learn about the uses of the O_* constants +with sysopen(). + +See L and L about the SEEK_* constants. + +See L about the S_I* constants. + +=cut + +use strict; +our($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS); + +require Exporter; +require XSLoader; +@ISA = qw(Exporter); +$VERSION = '1.11'; + +XSLoader::load(); + +# Named groups of exports +%EXPORT_TAGS = ( + 'flock' => [qw(LOCK_SH LOCK_EX LOCK_NB LOCK_UN)], + 'Fcompat' => [qw(FAPPEND FASYNC FCREAT FDEFER FDSYNC FEXCL FLARGEFILE + FNDELAY FNONBLOCK FRSYNC FSYNC FTRUNC)], + 'seek' => [qw(SEEK_SET SEEK_CUR SEEK_END)], + 'mode' => [qw(S_ISUID S_ISGID S_ISVTX S_ISTXT + _S_IFMT S_IFREG S_IFDIR S_IFLNK + S_IFSOCK S_IFBLK S_IFCHR S_IFIFO S_IFWHT S_ENFMT + S_IRUSR S_IWUSR S_IXUSR S_IRWXU + S_IRGRP S_IWGRP S_IXGRP S_IRWXG + S_IROTH S_IWOTH S_IXOTH S_IRWXO + S_IREAD S_IWRITE S_IEXEC + S_ISREG S_ISDIR S_ISLNK S_ISSOCK + S_ISBLK S_ISCHR S_ISFIFO + S_ISWHT S_ISENFMT + S_IFMT S_IMODE + )], +); + +# Items to export into callers namespace by default +# (move infrequently used names to @EXPORT_OK below) +@EXPORT = + qw( + FD_CLOEXEC + F_ALLOCSP + F_ALLOCSP64 + F_COMPAT + F_DUP2FD + F_DUPFD + F_EXLCK + F_FREESP + F_FREESP64 + F_FSYNC + F_FSYNC64 + F_GETFD + F_GETFL + F_GETLK + F_GETLK64 + F_GETOWN + F_NODNY + F_POSIX + F_RDACC + F_RDDNY + F_RDLCK + F_RWACC + F_RWDNY + F_SETFD + F_SETFL + F_SETLK + F_SETLK64 + F_SETLKW + F_SETLKW64 + F_SETOWN + F_SHARE + F_SHLCK + F_UNLCK + F_UNSHARE + F_WRACC + F_WRDNY + F_WRLCK + O_ACCMODE + O_ALIAS + O_APPEND + O_ASYNC + O_BINARY + O_CREAT + O_DEFER + O_DIRECT + O_DIRECTORY + O_DSYNC + O_EXCL + O_EXLOCK + O_LARGEFILE + O_NDELAY + O_NOCTTY + O_NOFOLLOW + O_NOINHERIT + O_NONBLOCK + O_RANDOM + O_RAW + O_RDONLY + O_RDWR + O_RSRC + O_RSYNC + O_SEQUENTIAL + O_SHLOCK + O_SYNC + O_TEMPORARY + O_TEXT + O_TRUNC + O_WRONLY + ); + +# Other items we are prepared to export if requested +@EXPORT_OK = (qw( + DN_ACCESS + DN_ATTRIB + DN_CREATE + DN_DELETE + DN_MODIFY + DN_MULTISHOT + DN_RENAME + F_GETLEASE + F_GETSIG + F_NOTIFY + F_SETLEASE + F_SETSIG + LOCK_MAND + LOCK_READ + LOCK_RW + LOCK_WRITE + O_IGNORE_CTTY + O_NOATIME + O_NOLINK + O_NOTRANS +), map {@{$_}} values %EXPORT_TAGS); + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/File/Basename.pm b/testsuite/input-files/perl-v5.14.2/lib/File/Basename.pm new file mode 100644 index 00000000..486eba1b --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/File/Basename.pm @@ -0,0 +1,402 @@ +=head1 NAME + +File::Basename - Parse file paths into directory, filename and suffix. + +=head1 SYNOPSIS + + use File::Basename; + + ($name,$path,$suffix) = fileparse($fullname,@suffixlist); + $name = fileparse($fullname,@suffixlist); + + $basename = basename($fullname,@suffixlist); + $dirname = dirname($fullname); + + +=head1 DESCRIPTION + +These routines allow you to parse file paths into their directory, filename +and suffix. + +B: C and C emulate the behaviours, and +quirks, of the shell and C functions of the same name. See each +function's documentation for details. If your concern is just parsing +paths it is safer to use L's C and +C methods. + +It is guaranteed that + + # Where $path_separator is / for Unix, \ for Windows, etc... + dirname($path) . $path_separator . basename($path); + +is equivalent to the original path for all systems but VMS. + + +=cut + + +package File::Basename; + +# File::Basename is used during the Perl build, when the re extension may +# not be available, but we only actually need it if running under tainting. +BEGIN { + if (${^TAINT}) { + require re; + re->import('taint'); + } +} + + +use strict; +use 5.006; +use warnings; +our(@ISA, @EXPORT, $VERSION, $Fileparse_fstype, $Fileparse_igncase); +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(fileparse fileparse_set_fstype basename dirname); +$VERSION = "2.82"; + +fileparse_set_fstype($^O); + + +=over 4 + +=item C +X + + my($filename, $directories, $suffix) = fileparse($path); + my($filename, $directories, $suffix) = fileparse($path, @suffixes); + my $filename = fileparse($path, @suffixes); + +The C routine divides a file path into its $directories, $filename +and (optionally) the filename $suffix. + +$directories contains everything up to and including the last +directory separator in the $path including the volume (if applicable). +The remainder of the $path is the $filename. + + # On Unix returns ("baz", "/foo/bar/", "") + fileparse("/foo/bar/baz"); + + # On Windows returns ("baz", 'C:\foo\bar\', "") + fileparse('C:\foo\bar\baz'); + + # On Unix returns ("", "/foo/bar/baz/", "") + fileparse("/foo/bar/baz/"); + +If @suffixes are given each element is a pattern (either a string or a +C) matched against the end of the $filename. The matching +portion is removed and becomes the $suffix. + + # On Unix returns ("baz", "/foo/bar/", ".txt") + fileparse("/foo/bar/baz.txt", qr/\.[^.]*/); + +If type is non-Unix (see C) then the pattern +matching for suffix removal is performed case-insensitively, since +those systems are not case-sensitive when opening existing files. + +You are guaranteed that C<$directories . $filename . $suffix> will +denote the same location as the original $path. + +=cut + + +sub fileparse { + my($fullname,@suffices) = @_; + + unless (defined $fullname) { + require Carp; + Carp::croak("fileparse(): need a valid pathname"); + } + + my $orig_type = ''; + my($type,$igncase) = ($Fileparse_fstype, $Fileparse_igncase); + + my($taint) = substr($fullname,0,0); # Is $fullname tainted? + + if ($type eq "VMS" and $fullname =~ m{/} ) { + # We're doing Unix emulation + $orig_type = $type; + $type = 'Unix'; + } + + my($dirpath, $basename); + + if (grep { $type eq $_ } qw(MSDOS DOS MSWin32 Epoc)) { + ($dirpath,$basename) = ($fullname =~ /^((?:.*[:\\\/])?)(.*)/s); + $dirpath .= '.\\' unless $dirpath =~ /[\\\/]\z/; + } + elsif ($type eq "OS2") { + ($dirpath,$basename) = ($fullname =~ m#^((?:.*[:\\/])?)(.*)#s); + $dirpath = './' unless $dirpath; # Can't be 0 + $dirpath .= '/' unless $dirpath =~ m#[\\/]\z#; + } + elsif ($type eq "MacOS") { + ($dirpath,$basename) = ($fullname =~ /^(.*:)?(.*)/s); + $dirpath = ':' unless $dirpath; + } + elsif ($type eq "AmigaOS") { + ($dirpath,$basename) = ($fullname =~ /(.*[:\/])?(.*)/s); + $dirpath = './' unless $dirpath; + } + elsif ($type eq 'VMS' ) { + ($dirpath,$basename) = ($fullname =~ /^(.*[:>\]])?(.*)/s); + $dirpath ||= ''; # should always be defined + } + else { # Default to Unix semantics. + ($dirpath,$basename) = ($fullname =~ m{^(.*/)?(.*)}s); + if ($orig_type eq 'VMS' and $fullname =~ m{^(/[^/]+/000000(/|$))(.*)}) { + # dev:[000000] is top of VMS tree, similar to Unix '/' + # so strip it off and treat the rest as "normal" + my $devspec = $1; + my $remainder = $3; + ($dirpath,$basename) = ($remainder =~ m{^(.*/)?(.*)}s); + $dirpath ||= ''; # should always be defined + $dirpath = $devspec.$dirpath; + } + $dirpath = './' unless $dirpath; + } + + + my $tail = ''; + my $suffix = ''; + if (@suffices) { + foreach $suffix (@suffices) { + my $pat = ($igncase ? '(?i)' : '') . "($suffix)\$"; + if ($basename =~ s/$pat//s) { + $taint .= substr($suffix,0,0); + $tail = $1 . $tail; + } + } + } + + # Ensure taint is propagated from the path to its pieces. + $tail .= $taint; + wantarray ? ($basename .= $taint, $dirpath .= $taint, $tail) + : ($basename .= $taint); +} + + + +=item C +X X + + my $filename = basename($path); + my $filename = basename($path, @suffixes); + +This function is provided for compatibility with the Unix shell command +C. It does B always return the file name portion of a +path as you might expect. To be safe, if you want the file name portion of +a path use C. + +C returns the last level of a filepath even if the last +level is clearly directory. In effect, it is acting like C for +paths. This differs from C's behaviour. + + # Both return "bar" + basename("/foo/bar"); + basename("/foo/bar/"); + +@suffixes work as in C except all regex metacharacters are +quoted. + + # These two function calls are equivalent. + my $filename = basename("/foo/bar/baz.txt", ".txt"); + my $filename = fileparse("/foo/bar/baz.txt", qr/\Q.txt\E/); + +Also note that in order to be compatible with the shell command, +C does not strip off a suffix if it is identical to the +remaining characters in the filename. + +=cut + + +sub basename { + my($path) = shift; + + # From BSD basename(1) + # The basename utility deletes any prefix ending with the last slash `/' + # character present in string (after first stripping trailing slashes) + _strip_trailing_sep($path); + + my($basename, $dirname, $suffix) = fileparse( $path, map("\Q$_\E",@_) ); + + # From BSD basename(1) + # The suffix is not stripped if it is identical to the remaining + # characters in string. + if( length $suffix and !length $basename ) { + $basename = $suffix; + } + + # Ensure that basename '/' == '/' + if( !length $basename ) { + $basename = $dirname; + } + + return $basename; +} + + + +=item C +X + +This function is provided for compatibility with the Unix shell +command C and has inherited some of its quirks. In spite of +its name it does B always return the directory name as you might +expect. To be safe, if you want the directory name of a path use +C. + +Only on VMS (where there is no ambiguity between the file and directory +portions of a path) and AmigaOS (possibly due to an implementation quirk in +this module) does C work like C, returning just the +$directories. + + # On VMS and AmigaOS + my $directories = dirname($path); + +When using Unix or MSDOS syntax this emulates the C shell function +which is subtly different from how C works. It returns all but +the last level of a file path even if the last level is clearly a directory. +In effect, it is not returning the directory portion but simply the path one +level up acting like C for file paths. + +Also unlike C, C does not include a trailing slash on +its returned path. + + # returns /foo/bar. fileparse() would return /foo/bar/ + dirname("/foo/bar/baz"); + + # also returns /foo/bar despite the fact that baz is clearly a + # directory. fileparse() would return /foo/bar/baz/ + dirname("/foo/bar/baz/"); + + # returns '.'. fileparse() would return 'foo/' + dirname("foo/"); + +Under VMS, if there is no directory information in the $path, then the +current default device and directory is used. + +=cut + + +sub dirname { + my $path = shift; + + my($type) = $Fileparse_fstype; + + if( $type eq 'VMS' and $path =~ m{/} ) { + # Parse as Unix + local($File::Basename::Fileparse_fstype) = ''; + return dirname($path); + } + + my($basename, $dirname) = fileparse($path); + + if ($type eq 'VMS') { + $dirname ||= $ENV{DEFAULT}; + } + elsif ($type eq 'MacOS') { + if( !length($basename) && $dirname !~ /^[^:]+:\z/) { + _strip_trailing_sep($dirname); + ($basename,$dirname) = fileparse $dirname; + } + $dirname .= ":" unless $dirname =~ /:\z/; + } + elsif (grep { $type eq $_ } qw(MSDOS DOS MSWin32 OS2)) { + _strip_trailing_sep($dirname); + unless( length($basename) ) { + ($basename,$dirname) = fileparse $dirname; + _strip_trailing_sep($dirname); + } + } + elsif ($type eq 'AmigaOS') { + if ( $dirname =~ /:\z/) { return $dirname } + chop $dirname; + $dirname =~ s{[^:/]+\z}{} unless length($basename); + } + else { + _strip_trailing_sep($dirname); + unless( length($basename) ) { + ($basename,$dirname) = fileparse $dirname; + _strip_trailing_sep($dirname); + } + } + + $dirname; +} + + +# Strip the trailing path separator. +sub _strip_trailing_sep { + my $type = $Fileparse_fstype; + + if ($type eq 'MacOS') { + $_[0] =~ s/([^:]):\z/$1/s; + } + elsif (grep { $type eq $_ } qw(MSDOS DOS MSWin32 OS2)) { + $_[0] =~ s/([^:])[\\\/]*\z/$1/; + } + else { + $_[0] =~ s{(.)/*\z}{$1}s; + } +} + + +=item C +X + + my $type = fileparse_set_fstype(); + my $previous_type = fileparse_set_fstype($type); + +Normally File::Basename will assume a file path type native to your current +operating system (ie. /foo/bar style on Unix, \foo\bar on Windows, etc...). +With this function you can override that assumption. + +Valid $types are "MacOS", "VMS", "AmigaOS", "OS2", "RISCOS", +"MSWin32", "DOS" (also "MSDOS" for backwards bug compatibility), +"Epoc" and "Unix" (all case-insensitive). If an unrecognized $type is +given "Unix" will be assumed. + +If you've selected VMS syntax, and the file specification you pass to +one of these routines contains a "/", they assume you are using Unix +emulation and apply the Unix syntax rules instead, for that function +call only. + +=back + +=cut + + +BEGIN { + +my @Ignore_Case = qw(MacOS VMS AmigaOS OS2 RISCOS MSWin32 MSDOS DOS Epoc); +my @Types = (@Ignore_Case, qw(Unix)); + +sub fileparse_set_fstype { + my $old = $Fileparse_fstype; + + if (@_) { + my $new_type = shift; + + $Fileparse_fstype = 'Unix'; # default + foreach my $type (@Types) { + $Fileparse_fstype = $type if $new_type =~ /^$type/i; + } + + $Fileparse_igncase = + (grep $Fileparse_fstype eq $_, @Ignore_Case) ? 1 : 0; + } + + return $old; +} + +} + + +1; + + +=head1 SEE ALSO + +L, L, L diff --git a/testsuite/input-files/perl-v5.14.2/lib/File/Glob.pm b/testsuite/input-files/perl-v5.14.2/lib/File/Glob.pm new file mode 100644 index 00000000..af17cffa --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/File/Glob.pm @@ -0,0 +1,437 @@ +package File::Glob; + +use strict; +our($VERSION, @ISA, @EXPORT_OK, @EXPORT_FAIL, %EXPORT_TAGS, $DEFAULT_FLAGS); + +require XSLoader; +use feature 'switch'; + +@ISA = qw(Exporter); + +# NOTE: The glob() export is only here for compatibility with 5.6.0. +# csh_glob() should not be used directly, unless you know what you're doing. + +%EXPORT_TAGS = ( + 'glob' => [ qw( + GLOB_ABEND + GLOB_ALPHASORT + GLOB_ALTDIRFUNC + GLOB_BRACE + GLOB_CSH + GLOB_ERR + GLOB_ERROR + GLOB_LIMIT + GLOB_MARK + GLOB_NOCASE + GLOB_NOCHECK + GLOB_NOMAGIC + GLOB_NOSORT + GLOB_NOSPACE + GLOB_QUOTE + GLOB_TILDE + glob + bsd_glob + ) ], +); + +@EXPORT_OK = (@{$EXPORT_TAGS{'glob'}}, 'csh_glob'); + +$VERSION = '1.13'; + +sub import { + require Exporter; + local $Exporter::ExportLevel = $Exporter::ExportLevel + 1; + Exporter::import(grep { + my $passthrough; + given ($_) { + $DEFAULT_FLAGS &= ~GLOB_NOCASE() when ':case'; + $DEFAULT_FLAGS |= GLOB_NOCASE() when ':nocase'; + when (':globally') { + no warnings 'redefine'; + *CORE::GLOBAL::glob = \&File::Glob::csh_glob; + } + $passthrough = 1; + } + $passthrough; + } @_); +} + +XSLoader::load(); + +$DEFAULT_FLAGS = GLOB_CSH(); +if ($^O =~ /^(?:MSWin32|VMS|os2|dos|riscos)$/) { + $DEFAULT_FLAGS |= GLOB_NOCASE(); +} + +# File::Glob::glob() is deprecated because its prototype is different from +# CORE::glob() (use bsd_glob() instead) +sub glob { + splice @_, 1; # don't pass PL_glob_index as flags! + goto &bsd_glob; +} + +## borrowed heavily from gsar's File::DosGlob +my %iter; +my %entries; + +sub csh_glob { + my $pat = shift; + my $cxix = shift; + my @pat; + + # glob without args defaults to $_ + $pat = $_ unless defined $pat; + + # extract patterns + $pat =~ s/^\s+//; # Protect against empty elements in + $pat =~ s/\s+$//; # things like < *.c> and <*.c >. + # These alone shouldn't trigger ParseWords. + if ($pat =~ /\s/) { + # XXX this is needed for compatibility with the csh + # implementation in Perl. Need to support a flag + # to disable this behavior. + require Text::ParseWords; + @pat = Text::ParseWords::parse_line('\s+',0,$pat); + } + + # assume global context if not provided one + $cxix = '_G_' unless defined $cxix; + $iter{$cxix} = 0 unless exists $iter{$cxix}; + + # if we're just beginning, do it all first + if ($iter{$cxix} == 0) { + if (@pat) { + $entries{$cxix} = [ map { doglob($_, $DEFAULT_FLAGS) } @pat ]; + } + else { + $entries{$cxix} = [ doglob($pat, $DEFAULT_FLAGS) ]; + } + } + + # chuck it all out, quick or slow + if (wantarray) { + delete $iter{$cxix}; + return @{delete $entries{$cxix}}; + } + else { + if ($iter{$cxix} = scalar @{$entries{$cxix}}) { + return shift @{$entries{$cxix}}; + } + else { + # return undef for EOL + delete $iter{$cxix}; + delete $entries{$cxix}; + return undef; + } + } +} + +1; +__END__ + +=head1 NAME + +File::Glob - Perl extension for BSD glob routine + +=head1 SYNOPSIS + + use File::Glob ':glob'; + + @list = bsd_glob('*.[ch]'); + $homedir = bsd_glob('~gnat', GLOB_TILDE | GLOB_ERR); + + if (GLOB_ERROR) { + # an error occurred reading $homedir + } + + ## override the core glob (CORE::glob() does this automatically + ## by default anyway, since v5.6.0) + use File::Glob ':globally'; + my @sources = <*.{c,h,y}>; + + ## override the core glob, forcing case sensitivity + use File::Glob qw(:globally :case); + my @sources = <*.{c,h,y}>; + + ## override the core glob forcing case insensitivity + use File::Glob qw(:globally :nocase); + my @sources = <*.{c,h,y}>; + + ## glob on all files in home directory + use File::Glob ':globally'; + my @sources = <~gnat/*>; + +=head1 DESCRIPTION + +The glob angle-bracket operator C<< <> >> is a pathname generator that +implements the rules for file name pattern matching used by Unix-like shells +such as the Bourne shell or C shell. + +File::Glob::bsd_glob() implements the FreeBSD glob(3) routine, which is +a superset of the POSIX glob() (described in IEEE Std 1003.2 "POSIX.2"). +bsd_glob() takes a mandatory C argument, and an optional +C argument, and returns a list of filenames matching the +pattern, with interpretation of the pattern modified by the C +variable. + +Since v5.6.0, Perl's CORE::glob() is implemented in terms of bsd_glob(). +Note that they don't share the same prototype--CORE::glob() only accepts +a single argument. Due to historical reasons, CORE::glob() will also +split its argument on whitespace, treating it as multiple patterns, +whereas bsd_glob() considers them as one pattern. + +=head2 META CHARACTERS + + \ Quote the next metacharacter + [] Character class + {} Multiple pattern + * Match any string of characters + ? Match any single character + ~ User name home directory + +The metanotation C is a shorthand for C. Left to +right order is preserved, with results of matches being sorted separately +at a low level to preserve this order. As a special case C<{>, C<}>, and +C<{}> are passed undisturbed. + +=head2 POSIX FLAGS + +The POSIX defined flags for bsd_glob() are: + +=over 4 + +=item C + +Force bsd_glob() to return an error when it encounters a directory it +cannot open or read. Ordinarily bsd_glob() continues to find matches. + +=item C + +Make bsd_glob() return an error (GLOB_NOSPACE) when the pattern expands +to a size bigger than the system constant C (usually found in +limits.h). If your system does not define this constant, bsd_glob() uses +C or C<_POSIX_ARG_MAX> where available (in that +order). You can inspect these values using the standard C +extension. + +=item C + +Each pathname that is a directory that matches the pattern has a slash +appended. + +=item C + +By default, file names are assumed to be case sensitive; this flag +makes bsd_glob() treat case differences as not significant. + +=item C + +If the pattern does not match any pathname, then bsd_glob() returns a list +consisting of only the pattern. If C is set, its effect +is present in the pattern returned. + +=item C + +By default, the pathnames are sorted in ascending ASCII order; this +flag prevents that sorting (speeding up bsd_glob()). + +=back + +The FreeBSD extensions to the POSIX standard are the following flags: + +=over 4 + +=item C + +Pre-process the string to expand C<{pat,pat,...}> strings like csh(1). +The pattern '{}' is left unexpanded for historical reasons (and csh(1) +does the same thing to ease typing of find(1) patterns). + +=item C + +Same as C but it only returns the pattern if it does not +contain any of the special characters "*", "?" or "[". C is +provided to simplify implementing the historic csh(1) globbing +behaviour and should probably not be used anywhere else. + +=item C + +Use the backslash ('\') character for quoting: every occurrence of a +backslash followed by a character in the pattern is replaced by that +character, avoiding any special interpretation of the character. +(But see below for exceptions on DOSISH systems). + +=item C + +Expand patterns that start with '~' to user name home directories. + +=item C + +For convenience, C is a synonym for +C. + +=back + +The POSIX provided C, C, and the FreeBSD +extensions C, and C flags have not been +implemented in the Perl version because they involve more complex +interaction with the underlying C structures. + +The following flag has been added in the Perl implementation for +csh compatibility: + +=over 4 + +=item C + +If C is not in effect, sort filenames is alphabetical +order (case does not matter) rather than in ASCII order. + +=back + +=head1 DIAGNOSTICS + +bsd_glob() returns a list of matching paths, possibly zero length. If an +error occurred, &File::Glob::GLOB_ERROR will be non-zero and C<$!> will be +set. &File::Glob::GLOB_ERROR is guaranteed to be zero if no error occurred, +or one of the following values otherwise: + +=over 4 + +=item C + +An attempt to allocate memory failed. + +=item C + +The glob was stopped because an error was encountered. + +=back + +In the case where bsd_glob() has found some matching paths, but is +interrupted by an error, it will return a list of filenames B +set &File::Glob::ERROR. + +Note that bsd_glob() deviates from POSIX and FreeBSD glob(3) behaviour +by not considering C and C as errors - bsd_glob() will +continue processing despite those errors, unless the C flag is +set. + +Be aware that all filenames returned from File::Glob are tainted. + +=head1 NOTES + +=over 4 + +=item * + +If you want to use multiple patterns, e.g. C, you should +probably throw them in a set as in C. This is because +the argument to bsd_glob() isn't subjected to parsing by the C shell. +Remember that you can use a backslash to escape things. + +=item * + +On DOSISH systems, backslash is a valid directory separator character. +In this case, use of backslash as a quoting character (via GLOB_QUOTE) +interferes with the use of backslash as a directory separator. The +best (simplest, most portable) solution is to use forward slashes for +directory separators, and backslashes for quoting. However, this does +not match "normal practice" on these systems. As a concession to user +expectation, therefore, backslashes (under GLOB_QUOTE) only quote the +glob metacharacters '[', ']', '{', '}', '-', '~', and backslash itself. +All other backslashes are passed through unchanged. + +=item * + +Win32 users should use the real slash. If you really want to use +backslashes, consider using Sarathy's File::DosGlob, which comes with +the standard Perl distribution. + +=item * + +Mac OS (Classic) users should note a few differences. Since +Mac OS is not Unix, when the glob code encounters a tilde glob (e.g. +~user) and the C flag is used, it simply returns that +pattern without doing any expansion. + +Glob on Mac OS is case-insensitive by default (if you don't use any +flags). If you specify any flags at all and still want glob +to be case-insensitive, you must include C in the flags. + +The path separator is ':' (aka colon), not '/' (aka slash). Mac OS users +should be careful about specifying relative pathnames. While a full path +always begins with a volume name, a relative pathname should always +begin with a ':'. If specifying a volume name only, a trailing ':' is +required. + +The specification of pathnames in glob patterns adheres to the usual Mac +OS conventions: The path separator is a colon ':', not a slash '/'. A +full path always begins with a volume name. A relative pathname on Mac +OS must always begin with a ':', except when specifying a file or +directory name in the current working directory, where the leading colon +is optional. If specifying a volume name only, a trailing ':' is +required. Due to these rules, a glob like E*:E will find all +mounted volumes, while a glob like E*E or E:*E will find +all files and directories in the current directory. + +Note that updirs in the glob pattern are resolved before the matching begins, +i.e. a pattern like "*HD:t?p::a*" will be matched as "*HD:a*". Note also, +that a single trailing ':' in the pattern is ignored (unless it's a volume +name pattern like "*HD:"), i.e. a glob like E:*:E will find both +directories I files (and not, as one might expect, only directories). +You can, however, use the C flag to distinguish (without a file +test) directory names from file names. + +If the C flag is set, all directory paths will have a ':' appended. +Since a directory like 'lib:' is I a valid I path on Mac OS, +both a leading and a trailing colon will be added, when the directory name in +question doesn't contain any colons (e.g. 'lib' becomes ':lib:'). + +=back + +=head1 SEE ALSO + +L, glob(3) + +=head1 AUTHOR + +The Perl interface was written by Nathan Torkington Egnat@frii.comE, +and is released under the artistic license. Further modifications were +made by Greg Bacon Egbacon@cs.uah.eduE, Gurusamy Sarathy +Egsar@activestate.comE, and Thomas Wegner +Ewegner_thomas@yahoo.comE. The C glob code has the +following copyright: + + Copyright (c) 1989, 1993 The Regents of the University of California. + All rights reserved. + + This code is derived from software contributed to Berkeley by + Guido van Rossum. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + 3. Neither the name of the University nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/File/Path.pm b/testsuite/input-files/perl-v5.14.2/lib/File/Path.pm new file mode 100644 index 00000000..5a9a88e4 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/File/Path.pm @@ -0,0 +1,981 @@ +package File::Path; + +use 5.005_04; +use strict; + +use Cwd 'getcwd'; +use File::Basename (); +use File::Spec (); + +BEGIN { + if ($] < 5.006) { + # can't say 'opendir my $dh, $dirname' + # need to initialise $dh + eval "use Symbol"; + } +} + +use Exporter (); +use vars qw($VERSION @ISA @EXPORT @EXPORT_OK); +$VERSION = '2.08_01'; +@ISA = qw(Exporter); +@EXPORT = qw(mkpath rmtree); +@EXPORT_OK = qw(make_path remove_tree); + +my $Is_VMS = $^O eq 'VMS'; +my $Is_MacOS = $^O eq 'MacOS'; + +# These OSes complain if you want to remove a file that you have no +# write permission to: +my $Force_Writeable = grep {$^O eq $_} qw(amigaos dos epoc MSWin32 MacOS os2); + +# Unix-like systems need to stat each directory in order to detect +# race condition. MS-Windows is immune to this particular attack. +my $Need_Stat_Check = !($^O eq 'MSWin32'); + +sub _carp { + require Carp; + goto &Carp::carp; +} + +sub _croak { + require Carp; + goto &Carp::croak; +} + +sub _error { + my $arg = shift; + my $message = shift; + my $object = shift; + + if ($arg->{error}) { + $object = '' unless defined $object; + $message .= ": $!" if $!; + push @{${$arg->{error}}}, {$object => $message}; + } + else { + _carp(defined($object) ? "$message for $object: $!" : "$message: $!"); + } +} + +sub make_path { + push @_, {} unless @_ and UNIVERSAL::isa($_[-1],'HASH'); + goto &mkpath; +} + +sub mkpath { + my $old_style = !(@_ and UNIVERSAL::isa($_[-1],'HASH')); + + my $arg; + my $paths; + + if ($old_style) { + my ($verbose, $mode); + ($paths, $verbose, $mode) = @_; + $paths = [$paths] unless UNIVERSAL::isa($paths,'ARRAY'); + $arg->{verbose} = $verbose; + $arg->{mode} = defined $mode ? $mode : 0777; + } + else { + $arg = pop @_; + $arg->{mode} = delete $arg->{mask} if exists $arg->{mask}; + $arg->{mode} = 0777 unless exists $arg->{mode}; + ${$arg->{error}} = [] if exists $arg->{error}; + $arg->{owner} = delete $arg->{user} if exists $arg->{user}; + $arg->{owner} = delete $arg->{uid} if exists $arg->{uid}; + if (exists $arg->{owner} and $arg->{owner} =~ /\D/) { + my $uid = (getpwnam $arg->{owner})[2]; + if (defined $uid) { + $arg->{owner} = $uid; + } + else { + _error($arg, "unable to map $arg->{owner} to a uid, ownership not changed"); + delete $arg->{owner}; + } + } + if (exists $arg->{group} and $arg->{group} =~ /\D/) { + my $gid = (getgrnam $arg->{group})[2]; + if (defined $gid) { + $arg->{group} = $gid; + } + else { + _error($arg, "unable to map $arg->{group} to a gid, group ownership not changed"); + delete $arg->{group}; + } + } + if (exists $arg->{owner} and not exists $arg->{group}) { + $arg->{group} = -1; # chown will leave group unchanged + } + if (exists $arg->{group} and not exists $arg->{owner}) { + $arg->{owner} = -1; # chown will leave owner unchanged + } + $paths = [@_]; + } + return _mkpath($arg, $paths); +} + +sub _mkpath { + my $arg = shift; + my $paths = shift; + + my(@created,$path); + foreach $path (@$paths) { + next unless defined($path) and length($path); + $path .= '/' if $^O eq 'os2' and $path =~ /^\w:\z/s; # feature of CRT + # Logic wants Unix paths, so go with the flow. + if ($Is_VMS) { + next if $path eq '/'; + $path = VMS::Filespec::unixify($path); + } + next if -d $path; + my $parent = File::Basename::dirname($path); + unless (-d $parent or $path eq $parent) { + push(@created,_mkpath($arg, [$parent])); + } + print "mkdir $path\n" if $arg->{verbose}; + if (mkdir($path,$arg->{mode})) { + push(@created, $path); + if (exists $arg->{owner}) { + # NB: $arg->{group} guaranteed to be set during initialisation + if (!chown $arg->{owner}, $arg->{group}, $path) { + _error($arg, "Cannot change ownership of $path to $arg->{owner}:$arg->{group}"); + } + } + } + else { + my $save_bang = $!; + my ($e, $e1) = ($save_bang, $^E); + $e .= "; $e1" if $e ne $e1; + # allow for another process to have created it meanwhile + if (!-d $path) { + $! = $save_bang; + if ($arg->{error}) { + push @{${$arg->{error}}}, {$path => $e}; + } + else { + _croak("mkdir $path: $e"); + } + } + } + } + return @created; +} + +sub remove_tree { + push @_, {} unless @_ and UNIVERSAL::isa($_[-1],'HASH'); + goto &rmtree; +} + +sub _is_subdir { + my($dir, $test) = @_; + + my($dv, $dd) = File::Spec->splitpath($dir, 1); + my($tv, $td) = File::Spec->splitpath($test, 1); + + # not on same volume + return 0 if $dv ne $tv; + + my @d = File::Spec->splitdir($dd); + my @t = File::Spec->splitdir($td); + + # @t can't be a subdir if it's shorter than @d + return 0 if @t < @d; + + return join('/', @d) eq join('/', splice @t, 0, +@d); +} + +sub rmtree { + my $old_style = !(@_ and UNIVERSAL::isa($_[-1],'HASH')); + + my $arg; + my $paths; + + if ($old_style) { + my ($verbose, $safe); + ($paths, $verbose, $safe) = @_; + $arg->{verbose} = $verbose; + $arg->{safe} = defined $safe ? $safe : 0; + + if (defined($paths) and length($paths)) { + $paths = [$paths] unless UNIVERSAL::isa($paths,'ARRAY'); + } + else { + _carp ("No root path(s) specified\n"); + return 0; + } + } + else { + $arg = pop @_; + ${$arg->{error}} = [] if exists $arg->{error}; + ${$arg->{result}} = [] if exists $arg->{result}; + $paths = [@_]; + } + + $arg->{prefix} = ''; + $arg->{depth} = 0; + + my @clean_path; + $arg->{cwd} = getcwd() or do { + _error($arg, "cannot fetch initial working directory"); + return 0; + }; + for ($arg->{cwd}) { /\A(.*)\Z/; $_ = $1 } # untaint + + for my $p (@$paths) { + # need to fixup case and map \ to / on Windows + my $ortho_root = $^O eq 'MSWin32' ? _slash_lc($p) : $p; + my $ortho_cwd = $^O eq 'MSWin32' ? _slash_lc($arg->{cwd}) : $arg->{cwd}; + my $ortho_root_length = length($ortho_root); + $ortho_root_length-- if $^O eq 'VMS'; # don't compare '.' with ']' + if ($ortho_root_length && _is_subdir($ortho_root, $ortho_cwd)) { + local $! = 0; + _error($arg, "cannot remove path when cwd is $arg->{cwd}", $p); + next; + } + + if ($Is_MacOS) { + $p = ":$p" unless $p =~ /:/; + $p .= ":" unless $p =~ /:\z/; + } + elsif ($^O eq 'MSWin32') { + $p =~ s{[/\\]\z}{}; + } + else { + $p =~ s{/\z}{}; + } + push @clean_path, $p; + } + + @{$arg}{qw(device inode perm)} = (lstat $arg->{cwd})[0,1] or do { + _error($arg, "cannot stat initial working directory", $arg->{cwd}); + return 0; + }; + + return _rmtree($arg, \@clean_path); +} + +sub _rmtree { + my $arg = shift; + my $paths = shift; + + my $count = 0; + my $curdir = File::Spec->curdir(); + my $updir = File::Spec->updir(); + + my (@files, $root); + ROOT_DIR: + foreach $root (@$paths) { + # since we chdir into each directory, it may not be obvious + # to figure out where we are if we generate a message about + # a file name. We therefore construct a semi-canonical + # filename, anchored from the directory being unlinked (as + # opposed to being truly canonical, anchored from the root (/). + + my $canon = $arg->{prefix} + ? File::Spec->catfile($arg->{prefix}, $root) + : $root + ; + + my ($ldev, $lino, $perm) = (lstat $root)[0,1,2] or next ROOT_DIR; + + if ( -d _ ) { + $root = VMS::Filespec::vmspath(VMS::Filespec::pathify($root)) if $Is_VMS; + + if (!chdir($root)) { + # see if we can escalate privileges to get in + # (e.g. funny protection mask such as -w- instead of rwx) + $perm &= 07777; + my $nperm = $perm | 0700; + if (!($arg->{safe} or $nperm == $perm or chmod($nperm, $root))) { + _error($arg, "cannot make child directory read-write-exec", $canon); + next ROOT_DIR; + } + elsif (!chdir($root)) { + _error($arg, "cannot chdir to child", $canon); + next ROOT_DIR; + } + } + + my ($cur_dev, $cur_inode, $perm) = (stat $curdir)[0,1,2] or do { + _error($arg, "cannot stat current working directory", $canon); + next ROOT_DIR; + }; + + if ($Need_Stat_Check) { + ($ldev eq $cur_dev and $lino eq $cur_inode) + or _croak("directory $canon changed before chdir, expected dev=$ldev ino=$lino, actual dev=$cur_dev ino=$cur_inode, aborting."); + } + + $perm &= 07777; # don't forget setuid, setgid, sticky bits + my $nperm = $perm | 0700; + + # notabene: 0700 is for making readable in the first place, + # it's also intended to change it to writable in case we have + # to recurse in which case we are better than rm -rf for + # subtrees with strange permissions + + if (!($arg->{safe} or $nperm == $perm or chmod($nperm, $curdir))) { + _error($arg, "cannot make directory read+writeable", $canon); + $nperm = $perm; + } + + my $d; + $d = gensym() if $] < 5.006; + if (!opendir $d, $curdir) { + _error($arg, "cannot opendir", $canon); + @files = (); + } + else { + no strict 'refs'; + if (!defined ${"\cTAINT"} or ${"\cTAINT"}) { + # Blindly untaint dir names if taint mode is + # active, or any perl < 5.006 + @files = map { /\A(.*)\z/s; $1 } readdir $d; + } + else { + @files = readdir $d; + } + closedir $d; + } + + if ($Is_VMS) { + # Deleting large numbers of files from VMS Files-11 + # filesystems is faster if done in reverse ASCIIbetical order. + # include '.' to '.;' from blead patch #31775 + @files = map {$_ eq '.' ? '.;' : $_} reverse @files; + } + + @files = grep {$_ ne $updir and $_ ne $curdir} @files; + + if (@files) { + # remove the contained files before the directory itself + my $narg = {%$arg}; + @{$narg}{qw(device inode cwd prefix depth)} + = ($cur_dev, $cur_inode, $updir, $canon, $arg->{depth}+1); + $count += _rmtree($narg, \@files); + } + + # restore directory permissions of required now (in case the rmdir + # below fails), while we are still in the directory and may do so + # without a race via '.' + if ($nperm != $perm and not chmod($perm, $curdir)) { + _error($arg, "cannot reset chmod", $canon); + } + + # don't leave the client code in an unexpected directory + chdir($arg->{cwd}) + or _croak("cannot chdir to $arg->{cwd} from $canon: $!, aborting."); + + # ensure that a chdir upwards didn't take us somewhere other + # than we expected (see CVE-2002-0435) + ($cur_dev, $cur_inode) = (stat $curdir)[0,1] + or _croak("cannot stat prior working directory $arg->{cwd}: $!, aborting."); + + if ($Need_Stat_Check) { + ($arg->{device} eq $cur_dev and $arg->{inode} eq $cur_inode) + or _croak("previous directory $arg->{cwd} changed before entering $canon, expected dev=$ldev ino=$lino, actual dev=$cur_dev ino=$cur_inode, aborting."); + } + + if ($arg->{depth} or !$arg->{keep_root}) { + if ($arg->{safe} && + ($Is_VMS ? !&VMS::Filespec::candelete($root) : !-w $root)) { + print "skipped $root\n" if $arg->{verbose}; + next ROOT_DIR; + } + if ($Force_Writeable and !chmod $perm | 0700, $root) { + _error($arg, "cannot make directory writeable", $canon); + } + print "rmdir $root\n" if $arg->{verbose}; + if (rmdir $root) { + push @{${$arg->{result}}}, $root if $arg->{result}; + ++$count; + } + else { + _error($arg, "cannot remove directory", $canon); + if ($Force_Writeable && !chmod($perm, ($Is_VMS ? VMS::Filespec::fileify($root) : $root)) + ) { + _error($arg, sprintf("cannot restore permissions to 0%o",$perm), $canon); + } + } + } + } + else { + # not a directory + $root = VMS::Filespec::vmsify("./$root") + if $Is_VMS + && !File::Spec->file_name_is_absolute($root) + && ($root !~ m/(?]+/); # not already in VMS syntax + + if ($arg->{safe} && + ($Is_VMS ? !&VMS::Filespec::candelete($root) + : !(-l $root || -w $root))) + { + print "skipped $root\n" if $arg->{verbose}; + next ROOT_DIR; + } + + my $nperm = $perm & 07777 | 0600; + if ($Force_Writeable and $nperm != $perm and not chmod $nperm, $root) { + _error($arg, "cannot make file writeable", $canon); + } + print "unlink $canon\n" if $arg->{verbose}; + # delete all versions under VMS + for (;;) { + if (unlink $root) { + push @{${$arg->{result}}}, $root if $arg->{result}; + } + else { + _error($arg, "cannot unlink file", $canon); + $Force_Writeable and chmod($perm, $root) or + _error($arg, sprintf("cannot restore permissions to 0%o",$perm), $canon); + last; + } + ++$count; + last unless $Is_VMS && lstat $root; + } + } + } + return $count; +} + +sub _slash_lc { + # fix up slashes and case on MSWin32 so that we can determine that + # c:\path\to\dir is underneath C:/Path/To + my $path = shift; + $path =~ tr{\\}{/}; + return lc($path); +} + +1; +__END__ + +=head1 NAME + +File::Path - Create or remove directory trees + +=head1 VERSION + +This document describes version 2.08 of File::Path, released +2009-10-04. + +=head1 SYNOPSIS + + use File::Path qw(make_path remove_tree); + + make_path('foo/bar/baz', '/zug/zwang'); + make_path('foo/bar/baz', '/zug/zwang', { + verbose => 1, + mode => 0711, + }); + + remove_tree('foo/bar/baz', '/zug/zwang'); + remove_tree('foo/bar/baz', '/zug/zwang', { + verbose => 1, + error => \my $err_list, + }); + + # legacy (interface promoted before v2.00) + mkpath('/foo/bar/baz'); + mkpath('/foo/bar/baz', 1, 0711); + mkpath(['/foo/bar/baz', 'blurfl/quux'], 1, 0711); + rmtree('foo/bar/baz', 1, 1); + rmtree(['foo/bar/baz', 'blurfl/quux'], 1, 1); + + # legacy (interface promoted before v2.06) + mkpath('foo/bar/baz', '/zug/zwang', { verbose => 1, mode => 0711 }); + rmtree('foo/bar/baz', '/zug/zwang', { verbose => 1, mode => 0711 }); + +=head1 DESCRIPTION + +This module provide a convenient way to create directories of +arbitrary depth and to delete an entire directory subtree from the +filesystem. + +The following functions are provided: + +=over + +=item make_path( $dir1, $dir2, .... ) + +=item make_path( $dir1, $dir2, ...., \%opts ) + +The C function creates the given directories if they don't +exists before, much like the Unix command C. + +The function accepts a list of directories to be created. Its +behaviour may be tuned by an optional hashref appearing as the last +parameter on the call. + +The function returns the list of directories actually created during +the call; in scalar context the number of directories created. + +The following keys are recognised in the option hash: + +=over + +=item mode => $num + +The numeric permissions mode to apply to each created directory +(defaults to 0777), to be modified by the current C. If the +directory already exists (and thus does not need to be created), +the permissions will not be modified. + +C is recognised as an alias for this parameter. + +=item verbose => $bool + +If present, will cause C to print the name of each directory +as it is created. By default nothing is printed. + +=item error => \$err + +If present, it should be a reference to a scalar. +This scalar will be made to reference an array, which will +be used to store any errors that are encountered. See the L section for more information. + +If this parameter is not used, certain error conditions may raise +a fatal error that will cause the program will halt, unless trapped +in an C block. + +=item owner => $owner + +=item user => $owner + +=item uid => $owner + +If present, will cause any created directory to be owned by C<$owner>. +If the value is numeric, it will be interpreted as a uid, otherwise +as username is assumed. An error will be issued if the username cannot be +mapped to a uid, or the uid does not exist, or the process lacks the +privileges to change ownership. + +Ownwership of directories that already exist will not be changed. + +C and C are aliases of C. + +=item group => $group + +If present, will cause any created directory to be owned by the group C<$group>. +If the value is numeric, it will be interpreted as a gid, otherwise +as group name is assumed. An error will be issued if the group name cannot be +mapped to a gid, or the gid does not exist, or the process lacks the +privileges to change group ownership. + +Group ownwership of directories that already exist will not be changed. + + make_path '/var/tmp/webcache', {owner=>'nobody', group=>'nogroup'}; + +=back + +=item mkpath( $dir ) + +=item mkpath( $dir, $verbose, $mode ) + +=item mkpath( [$dir1, $dir2,...], $verbose, $mode ) + +=item mkpath( $dir1, $dir2,..., \%opt ) + +The mkpath() function provide the legacy interface of make_path() with +a different interpretation of the arguments passed. The behaviour and +return value of the function is otherwise identical to make_path(). + +=item remove_tree( $dir1, $dir2, .... ) + +=item remove_tree( $dir1, $dir2, ...., \%opts ) + +The C function deletes the given directories and any +files and subdirectories they might contain, much like the Unix +command C or C on Windows. + +The function accepts a list of directories to be +removed. Its behaviour may be tuned by an optional hashref +appearing as the last parameter on the call. + +The functions returns the number of files successfully deleted. + +The following keys are recognised in the option hash: + +=over + +=item verbose => $bool + +If present, will cause C to print the name of each file as +it is unlinked. By default nothing is printed. + +=item safe => $bool + +When set to a true value, will cause C to skip the files +for which the process lacks the required privileges needed to delete +files, such as delete privileges on VMS. In other words, the code +will make no attempt to alter file permissions. Thus, if the process +is interrupted, no filesystem object will be left in a more +permissive mode. + +=item keep_root => $bool + +When set to a true value, will cause all files and subdirectories +to be removed, except the initially specified directories. This comes +in handy when cleaning out an application's scratch directory. + + remove_tree( '/tmp', {keep_root => 1} ); + +=item result => \$res + +If present, it should be a reference to a scalar. +This scalar will be made to reference an array, which will +be used to store all files and directories unlinked +during the call. If nothing is unlinked, the array will be empty. + + remove_tree( '/tmp', {result => \my $list} ); + print "unlinked $_\n" for @$list; + +This is a useful alternative to the C key. + +=item error => \$err + +If present, it should be a reference to a scalar. +This scalar will be made to reference an array, which will +be used to store any errors that are encountered. See the L section for more information. + +Removing things is a much more dangerous proposition than +creating things. As such, there are certain conditions that +C may encounter that are so dangerous that the only +sane action left is to kill the program. + +Use C to trap all that is reasonable (problems with +permissions and the like), and let it die if things get out +of hand. This is the safest course of action. + +=back + +=item rmtree( $dir ) + +=item rmtree( $dir, $verbose, $safe ) + +=item rmtree( [$dir1, $dir2,...], $verbose, $safe ) + +=item rmtree( $dir1, $dir2,..., \%opt ) + +The rmtree() function provide the legacy interface of remove_tree() +with a different interpretation of the arguments passed. The behaviour +and return value of the function is otherwise identical to +remove_tree(). + +=back + +=head2 ERROR HANDLING + +=over 4 + +=item B + +The following error handling mechanism is considered +experimental and is subject to change pending feedback from +users. + +=back + +If C or C encounter an error, a diagnostic +message will be printed to C via C (for non-fatal +errors), or via C (for fatal errors). + +If this behaviour is not desirable, the C attribute may be +used to hold a reference to a variable, which will be used to store +the diagnostics. The variable is made a reference to an array of hash +references. Each hash contain a single key/value pair where the key +is the name of the file, and the value is the error message (including +the contents of C<$!> when appropriate). If a general error is +encountered the diagnostic key will be empty. + +An example usage looks like: + + remove_tree( 'foo/bar', 'bar/rat', {error => \my $err} ); + if (@$err) { + for my $diag (@$err) { + my ($file, $message) = %$diag; + if ($file eq '') { + print "general error: $message\n"; + } + else { + print "problem unlinking $file: $message\n"; + } + } + } + else { + print "No error encountered\n"; + } + +Note that if no errors are encountered, C<$err> will reference an +empty array. This means that C<$err> will always end up TRUE; so you +need to test C<@$err> to determine if errors occured. + +=head2 NOTES + +C blindly exports C and C into the +current namespace. These days, this is considered bad style, but +to change it now would break too much code. Nonetheless, you are +invited to specify what it is you are expecting to use: + + use File::Path 'rmtree'; + +The routines C and C are B exported +by default. You must specify which ones you want to use. + + use File::Path 'remove_tree'; + +Note that a side-effect of the above is that C and C +are no longer exported at all. This is due to the way the C +module works. If you are migrating a codebase to use the new +interface, you will have to list everything explicitly. But that's +just good practice anyway. + + use File::Path qw(remove_tree rmtree); + +=head3 API CHANGES + +The API was changed in the 2.0 branch. For a time, C and +C tried, unsuccessfully, to deal with the two different +calling mechanisms. This approach was considered a failure. + +The new semantics are now only available with C and +C. The old semantics are only available through +C and C. Users are strongly encouraged to upgrade +to at least 2.08 in order to avoid surprises. + +=head3 SECURITY CONSIDERATIONS + +There were race conditions 1.x implementations of File::Path's +C function (although sometimes patched depending on the OS +distribution or platform). The 2.0 version contains code to avoid the +problem mentioned in CVE-2002-0435. + +See the following pages for more information: + + http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=286905 + http://www.nntp.perl.org/group/perl.perl5.porters/2005/01/msg97623.html + http://www.debian.org/security/2005/dsa-696 + +Additionally, unless the C parameter is set (or the +third parameter in the traditional interface is TRUE), should a +C be interrupted, files that were originally in read-only +mode may now have their permissions set to a read-write (or "delete +OK") mode. + +=head1 DIAGNOSTICS + +FATAL errors will cause the program to halt (C), since the +problem is so severe that it would be dangerous to continue. (This +can always be trapped with C, but it's not a good idea. Under +the circumstances, dying is the best thing to do). + +SEVERE errors may be trapped using the modern interface. If the +they are not trapped, or the old interface is used, such an error +will cause the program will halt. + +All other errors may be trapped using the modern interface, otherwise +they will be Ced about. Program execution will not be halted. + +=over 4 + +=item mkdir [path]: [errmsg] (SEVERE) + +C was unable to create the path. Probably some sort of +permissions error at the point of departure, or insufficient resources +(such as free inodes on Unix). + +=item No root path(s) specified + +C was not given any paths to create. This message is only +emitted if the routine is called with the traditional interface. +The modern interface will remain silent if given nothing to do. + +=item No such file or directory + +On Windows, if C gives you this warning, it may mean that +you have exceeded your filesystem's maximum path length. + +=item cannot fetch initial working directory: [errmsg] + +C attempted to determine the initial directory by calling +C, but the call failed for some reason. No attempt +will be made to delete anything. + +=item cannot stat initial working directory: [errmsg] + +C attempted to stat the initial directory (after having +successfully obtained its name via C), however, the call +failed for some reason. No attempt will be made to delete anything. + +=item cannot chdir to [dir]: [errmsg] + +C attempted to set the working directory in order to +begin deleting the objects therein, but was unsuccessful. This is +usually a permissions issue. The routine will continue to delete +other things, but this directory will be left intact. + +=item directory [dir] changed before chdir, expected dev=[n] ino=[n], actual dev=[n] ino=[n], aborting. (FATAL) + +C recorded the device and inode of a directory, and then +moved into it. It then performed a C on the current directory +and detected that the device and inode were no longer the same. As +this is at the heart of the race condition problem, the program +will die at this point. + +=item cannot make directory [dir] read+writeable: [errmsg] + +C attempted to change the permissions on the current directory +to ensure that subsequent unlinkings would not run into problems, +but was unable to do so. The permissions remain as they were, and +the program will carry on, doing the best it can. + +=item cannot read [dir]: [errmsg] + +C tried to read the contents of the directory in order +to acquire the names of the directory entries to be unlinked, but +was unsuccessful. This is usually a permissions issue. The +program will continue, but the files in this directory will remain +after the call. + +=item cannot reset chmod [dir]: [errmsg] + +C, after having deleted everything in a directory, attempted +to restore its permissions to the original state but failed. The +directory may wind up being left behind. + +=item cannot remove [dir] when cwd is [dir] + +The current working directory of the program is F +and you are attempting to remove an ancestor, such as F. +The directory tree is left untouched. + +The solution is to C out of the child directory to a place +outside the directory tree to be removed. + +=item cannot chdir to [parent-dir] from [child-dir]: [errmsg], aborting. (FATAL) + +C, after having deleted everything and restored the permissions +of a directory, was unable to chdir back to the parent. The program +halts to avoid a race condition from occurring. + +=item cannot stat prior working directory [dir]: [errmsg], aborting. (FATAL) + +C was unable to stat the parent directory after have returned +from the child. Since there is no way of knowing if we returned to +where we think we should be (by comparing device and inode) the only +way out is to C. + +=item previous directory [parent-dir] changed before entering [child-dir], expected dev=[n] ino=[n], actual dev=[n] ino=[n], aborting. (FATAL) + +When C returned from deleting files in a child directory, a +check revealed that the parent directory it returned to wasn't the one +it started out from. This is considered a sign of malicious activity. + +=item cannot make directory [dir] writeable: [errmsg] + +Just before removing a directory (after having successfully removed +everything it contained), C attempted to set the permissions +on the directory to ensure it could be removed and failed. Program +execution continues, but the directory may possibly not be deleted. + +=item cannot remove directory [dir]: [errmsg] + +C attempted to remove a directory, but failed. This may because +some objects that were unable to be removed remain in the directory, or +a permissions issue. The directory will be left behind. + +=item cannot restore permissions of [dir] to [0nnn]: [errmsg] + +After having failed to remove a directory, C was unable to +restore its permissions from a permissive state back to a possibly +more restrictive setting. (Permissions given in octal). + +=item cannot make file [file] writeable: [errmsg] + +C attempted to force the permissions of a file to ensure it +could be deleted, but failed to do so. It will, however, still attempt +to unlink the file. + +=item cannot unlink file [file]: [errmsg] + +C failed to remove a file. Probably a permissions issue. + +=item cannot restore permissions of [file] to [0nnn]: [errmsg] + +After having failed to remove a file, C was also unable +to restore the permissions on the file to a possibly less permissive +setting. (Permissions given in octal). + +=item unable to map [owner] to a uid, ownership not changed"); + +C was instructed to give the ownership of created +directories to the symbolic name [owner], but C did +not return the corresponding numeric uid. The directory will +be created, but ownership will not be changed. + +=item unable to map [group] to a gid, group ownership not changed + +C was instructed to give the group ownership of created +directories to the symbolic name [group], but C did +not return the corresponding numeric gid. The directory will +be created, but group ownership will not be changed. + +=back + +=head1 SEE ALSO + +=over 4 + +=item * + +L + +Allows files and directories to be moved to the Trashcan/Recycle +Bin (where they may later be restored if necessary) if the operating +system supports such functionality. This feature may one day be +made available directly in C. + +=item * + +L + +When removing directory trees, if you want to examine each file to +decide whether to delete it (and possibly leaving large swathes +alone), F offers a convenient and flexible approach +to examining directory trees. + +=back + +=head1 BUGS + +Please report all bugs on the RT queue: + +L + +=head1 ACKNOWLEDGEMENTS + +Paul Szabo identified the race condition originally, and Brendan +O'Dea wrote an implementation for Debian that addressed the problem. +That code was used as a basis for the current code. Their efforts +are greatly appreciated. + +Gisle Aas made a number of improvements to the documentation for +2.07 and his advice and assistance is also greatly appreciated. + +=head1 AUTHORS + +Tim Bunce and Charles Bailey. Currently maintained by David Landgren +>. + +=head1 COPYRIGHT + +This module is copyright (C) Charles Bailey, Tim Bunce and +David Landgren 1995-2009. All rights reserved. + +=head1 LICENSE + +This library is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/File/Spec.pm b/testsuite/input-files/perl-v5.14.2/lib/File/Spec.pm new file mode 100644 index 00000000..34c527ee --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/File/Spec.pm @@ -0,0 +1,337 @@ +package File::Spec; + +use strict; +use vars qw(@ISA $VERSION); + +$VERSION = '3.33'; +$VERSION = eval $VERSION; + +my %module = (MacOS => 'Mac', + MSWin32 => 'Win32', + os2 => 'OS2', + VMS => 'VMS', + epoc => 'Epoc', + NetWare => 'Win32', # Yes, File::Spec::Win32 works on NetWare. + symbian => 'Win32', # Yes, File::Spec::Win32 works on symbian. + dos => 'OS2', # Yes, File::Spec::OS2 works on DJGPP. + cygwin => 'Cygwin'); + + +my $module = $module{$^O} || 'Unix'; + +require "File/Spec/$module.pm"; +@ISA = ("File::Spec::$module"); + +1; + +__END__ + +=head1 NAME + +File::Spec - portably perform operations on file names + +=head1 SYNOPSIS + + use File::Spec; + + $x=File::Spec->catfile('a', 'b', 'c'); + +which returns 'a/b/c' under Unix. Or: + + use File::Spec::Functions; + + $x = catfile('a', 'b', 'c'); + +=head1 DESCRIPTION + +This module is designed to support operations commonly performed on file +specifications (usually called "file names", but not to be confused with the +contents of a file, or Perl's file handles), such as concatenating several +directory and file names into a single path, or determining whether a path +is rooted. It is based on code directly taken from MakeMaker 5.17, code +written by Andreas KEnig, Andy Dougherty, Charles Bailey, Ilya +Zakharevich, Paul Schinder, and others. + +Since these functions are different for most operating systems, each set of +OS specific routines is available in a separate module, including: + + File::Spec::Unix + File::Spec::Mac + File::Spec::OS2 + File::Spec::Win32 + File::Spec::VMS + +The module appropriate for the current OS is automatically loaded by +File::Spec. Since some modules (like VMS) make use of facilities available +only under that OS, it may not be possible to load all modules under all +operating systems. + +Since File::Spec is object oriented, subroutines should not be called directly, +as in: + + File::Spec::catfile('a','b'); + +but rather as class methods: + + File::Spec->catfile('a','b'); + +For simple uses, L provides convenient functional +forms of these methods. + +=head1 METHODS + +=over 2 + +=item canonpath +X + +No physical check on the filesystem, but a logical cleanup of a +path. + + $cpath = File::Spec->canonpath( $path ) ; + +Note that this does *not* collapse F sections into F. This +is by design. If F on your system is a symlink to F, +then F is actually F, not F as a naive +F<../>-removal would give you. If you want to do this kind of +processing, you probably want C's C function to +actually traverse the filesystem cleaning up paths like this. + +=item catdir +X + +Concatenate two or more directory names to form a complete path ending +with a directory. But remove the trailing slash from the resulting +string, because it doesn't look good, isn't necessary and confuses +OS/2. Of course, if this is the root directory, don't cut off the +trailing slash :-) + + $path = File::Spec->catdir( @directories ); + +=item catfile +X + +Concatenate one or more directory names and a filename to form a +complete path ending with a filename + + $path = File::Spec->catfile( @directories, $filename ); + +=item curdir +X + +Returns a string representation of the current directory. + + $curdir = File::Spec->curdir(); + +=item devnull +X + +Returns a string representation of the null device. + + $devnull = File::Spec->devnull(); + +=item rootdir +X + +Returns a string representation of the root directory. + + $rootdir = File::Spec->rootdir(); + +=item tmpdir +X + +Returns a string representation of the first writable directory from a +list of possible temporary directories. Returns the current directory +if no writable temporary directories are found. The list of directories +checked depends on the platform; e.g. File::Spec::Unix checks C<$ENV{TMPDIR}> +(unless taint is on) and F. + + $tmpdir = File::Spec->tmpdir(); + +=item updir +X + +Returns a string representation of the parent directory. + + $updir = File::Spec->updir(); + +=item no_upwards + +Given a list of file names, strip out those that refer to a parent +directory. (Does not strip symlinks, only '.', '..', and equivalents.) + + @paths = File::Spec->no_upwards( @paths ); + +=item case_tolerant + +Returns a true or false value indicating, respectively, that alphabetic +case is not or is significant when comparing file specifications. +Cygwin and Win32 accept an optional drive argument. + + $is_case_tolerant = File::Spec->case_tolerant(); + +=item file_name_is_absolute + +Takes as its argument a path, and returns true if it is an absolute path. + + $is_absolute = File::Spec->file_name_is_absolute( $path ); + +This does not consult the local filesystem on Unix, Win32, OS/2, or +Mac OS (Classic). It does consult the working environment for VMS +(see L). + +=item path +X + +Takes no argument. Returns the environment variable C (or the local +platform's equivalent) as a list. + + @PATH = File::Spec->path(); + +=item join +X + +join is the same as catfile. + +=item splitpath +X X + +Splits a path in to volume, directory, and filename portions. On systems +with no concept of volume, returns '' for volume. + + ($volume,$directories,$file) = File::Spec->splitpath( $path ); + ($volume,$directories,$file) = File::Spec->splitpath( $path, $no_file ); + +For systems with no syntax differentiating filenames from directories, +assumes that the last file is a path unless C<$no_file> is true or a +trailing separator or F or F is present. On Unix, this means that C<$no_file> +true makes this return ( '', $path, '' ). + +The directory portion may or may not be returned with a trailing '/'. + +The results can be passed to L to get back a path equivalent to +(usually identical to) the original path. + +=item splitdir +X X + +The opposite of L. + + @dirs = File::Spec->splitdir( $directories ); + +C<$directories> must be only the directory portion of the path on systems +that have the concept of a volume or that have path syntax that differentiates +files from directories. + +Unlike just splitting the directories on the separator, empty +directory names (C<''>) can be returned, because these are significant +on some OSes. + +=item catpath() + +Takes volume, directory and file portions and returns an entire path. Under +Unix, C<$volume> is ignored, and directory and file are concatenated. A '/' is +inserted if need be. On other OSes, C<$volume> is significant. + + $full_path = File::Spec->catpath( $volume, $directory, $file ); + +=item abs2rel +X X X + +Takes a destination path and an optional base path returns a relative path +from the base path to the destination path: + + $rel_path = File::Spec->abs2rel( $path ) ; + $rel_path = File::Spec->abs2rel( $path, $base ) ; + +If C<$base> is not present or '', then L is used. If C<$base> is +relative, then it is converted to absolute form using +L. This means that it is taken to be relative to +L. + +On systems with the concept of volume, if C<$path> and C<$base> appear to be +on two different volumes, we will not attempt to resolve the two +paths, and we will instead simply return C<$path>. Note that previous +versions of this module ignored the volume of C<$base>, which resulted in +garbage results part of the time. + +On systems that have a grammar that indicates filenames, this ignores the +C<$base> filename as well. Otherwise all path components are assumed to be +directories. + +If C<$path> is relative, it is converted to absolute form using L. +This means that it is taken to be relative to L. + +No checks against the filesystem are made. On VMS, there is +interaction with the working environment, as logicals and +macros are expanded. + +Based on code written by Shigio Yamaguchi. + +=item rel2abs() +X X X + +Converts a relative path to an absolute path. + + $abs_path = File::Spec->rel2abs( $path ) ; + $abs_path = File::Spec->rel2abs( $path, $base ) ; + +If C<$base> is not present or '', then L is used. If C<$base> is relative, +then it is converted to absolute form using L. This means that it +is taken to be relative to L. + +On systems with the concept of volume, if C<$path> and C<$base> appear to be +on two different volumes, we will not attempt to resolve the two +paths, and we will instead simply return C<$path>. Note that previous +versions of this module ignored the volume of C<$base>, which resulted in +garbage results part of the time. + +On systems that have a grammar that indicates filenames, this ignores the +C<$base> filename as well. Otherwise all path components are assumed to be +directories. + +If C<$path> is absolute, it is cleaned up and returned using L. + +No checks against the filesystem are made. On VMS, there is +interaction with the working environment, as logicals and +macros are expanded. + +Based on code written by Shigio Yamaguchi. + +=back + +For further information, please see L, +L, L, L, or +L. + +=head1 SEE ALSO + +L, L, L, +L, L, L, +L + +=head1 AUTHOR + +Currently maintained by Ken Williams C<< >>. + +The vast majority of the code was written by +Kenneth Albanowski C<< >>, +Andy Dougherty C<< >>, +Andreas KEnig C<< >>, +Tim Bunce C<< >>. +VMS support by Charles Bailey C<< >>. +OS/2 support by Ilya Zakharevich C<< >>. +Mac support by Paul Schinder C<< >>, and +Thomas Wegner C<< >>. +abs2rel() and rel2abs() written by Shigio Yamaguchi C<< >>, +modified by Barrie Slaymaker C<< >>. +splitpath(), splitdir(), catpath() and catdir() by Barrie Slaymaker. + +=head1 COPYRIGHT + +Copyright (c) 2004-2010 by the Perl 5 Porters. All rights reserved. + +This program is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/File/Spec/Unix.pm b/testsuite/input-files/perl-v5.14.2/lib/File/Spec/Unix.pm new file mode 100644 index 00000000..b276b213 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/File/Spec/Unix.pm @@ -0,0 +1,521 @@ +package File::Spec::Unix; + +use strict; +use vars qw($VERSION); + +$VERSION = '3.33'; +$VERSION = eval $VERSION; + +=head1 NAME + +File::Spec::Unix - File::Spec for Unix, base for other File::Spec modules + +=head1 SYNOPSIS + + require File::Spec::Unix; # Done automatically by File::Spec + +=head1 DESCRIPTION + +Methods for manipulating file specifications. Other File::Spec +modules, such as File::Spec::Mac, inherit from File::Spec::Unix and +override specific methods. + +=head1 METHODS + +=over 2 + +=item canonpath() + +No physical check on the filesystem, but a logical cleanup of a +path. On UNIX eliminates successive slashes and successive "/.". + + $cpath = File::Spec->canonpath( $path ) ; + +Note that this does *not* collapse F sections into F. This +is by design. If F on your system is a symlink to F, +then F is actually F, not F as a naive +F<../>-removal would give you. If you want to do this kind of +processing, you probably want C's C function to +actually traverse the filesystem cleaning up paths like this. + +=cut + +sub canonpath { + my ($self,$path) = @_; + return unless defined $path; + + # Handle POSIX-style node names beginning with double slash (qnx, nto) + # (POSIX says: "a pathname that begins with two successive slashes + # may be interpreted in an implementation-defined manner, although + # more than two leading slashes shall be treated as a single slash.") + my $node = ''; + my $double_slashes_special = $^O eq 'qnx' || $^O eq 'nto'; + + + if ( $double_slashes_special + && ( $path =~ s{^(//[^/]+)/?\z}{}s || $path =~ s{^(//[^/]+)/}{/}s ) ) { + $node = $1; + } + # This used to be + # $path =~ s|/+|/|g unless ($^O eq 'cygwin'); + # but that made tests 29, 30, 35, 46, and 213 (as of #13272) to fail + # (Mainly because trailing "" directories didn't get stripped). + # Why would cygwin avoid collapsing multiple slashes into one? --jhi + $path =~ s|/{2,}|/|g; # xx////xx -> xx/xx + $path =~ s{(?:/\.)+(?:/|\z)}{/}g; # xx/././xx -> xx/xx + $path =~ s|^(?:\./)+||s unless $path eq "./"; # ./xx -> xx + $path =~ s|^/(?:\.\./)+|/|; # /../../xx -> xx + $path =~ s|^/\.\.$|/|; # /.. -> / + $path =~ s|/\z|| unless $path eq "/"; # xx/ -> xx + return "$node$path"; +} + +=item catdir() + +Concatenate two or more directory names to form a complete path ending +with a directory. But remove the trailing slash from the resulting +string, because it doesn't look good, isn't necessary and confuses +OS2. Of course, if this is the root directory, don't cut off the +trailing slash :-) + +=cut + +sub catdir { + my $self = shift; + + $self->canonpath(join('/', @_, '')); # '' because need a trailing '/' +} + +=item catfile + +Concatenate one or more directory names and a filename to form a +complete path ending with a filename + +=cut + +sub catfile { + my $self = shift; + my $file = $self->canonpath(pop @_); + return $file unless @_; + my $dir = $self->catdir(@_); + $dir .= "/" unless substr($dir,-1) eq "/"; + return $dir.$file; +} + +=item curdir + +Returns a string representation of the current directory. "." on UNIX. + +=cut + +sub curdir { '.' } + +=item devnull + +Returns a string representation of the null device. "/dev/null" on UNIX. + +=cut + +sub devnull { '/dev/null' } + +=item rootdir + +Returns a string representation of the root directory. "/" on UNIX. + +=cut + +sub rootdir { '/' } + +=item tmpdir + +Returns a string representation of the first writable directory from +the following list or the current directory if none from the list are +writable: + + $ENV{TMPDIR} + /tmp + +Since perl 5.8.0, if running under taint mode, and if $ENV{TMPDIR} +is tainted, it is not used. + +=cut + +my $tmpdir; +sub _tmpdir { + return $tmpdir if defined $tmpdir; + my $self = shift; + my @dirlist = @_; + { + no strict 'refs'; + if (${"\cTAINT"}) { # Check for taint mode on perl >= 5.8.0 + require Scalar::Util; + @dirlist = grep { ! Scalar::Util::tainted($_) } @dirlist; + } + } + foreach (@dirlist) { + next unless defined && -d && -w _; + $tmpdir = $_; + last; + } + $tmpdir = $self->curdir unless defined $tmpdir; + $tmpdir = defined $tmpdir && $self->canonpath($tmpdir); + return $tmpdir; +} + +sub tmpdir { + return $tmpdir if defined $tmpdir; + $tmpdir = $_[0]->_tmpdir( $ENV{TMPDIR}, "/tmp" ); +} + +=item updir + +Returns a string representation of the parent directory. ".." on UNIX. + +=cut + +sub updir { '..' } + +=item no_upwards + +Given a list of file names, strip out those that refer to a parent +directory. (Does not strip symlinks, only '.', '..', and equivalents.) + +=cut + +sub no_upwards { + my $self = shift; + return grep(!/^\.{1,2}\z/s, @_); +} + +=item case_tolerant + +Returns a true or false value indicating, respectively, that alphabetic +is not or is significant when comparing file specifications. + +=cut + +sub case_tolerant { 0 } + +=item file_name_is_absolute + +Takes as argument a path and returns true if it is an absolute path. + +This does not consult the local filesystem on Unix, Win32, OS/2 or Mac +OS (Classic). It does consult the working environment for VMS (see +L). + +=cut + +sub file_name_is_absolute { + my ($self,$file) = @_; + return scalar($file =~ m:^/:s); +} + +=item path + +Takes no argument, returns the environment variable PATH as an array. + +=cut + +sub path { + return () unless exists $ENV{PATH}; + my @path = split(':', $ENV{PATH}); + foreach (@path) { $_ = '.' if $_ eq '' } + return @path; +} + +=item join + +join is the same as catfile. + +=cut + +sub join { + my $self = shift; + return $self->catfile(@_); +} + +=item splitpath + + ($volume,$directories,$file) = File::Spec->splitpath( $path ); + ($volume,$directories,$file) = File::Spec->splitpath( $path, $no_file ); + +Splits a path into volume, directory, and filename portions. On systems +with no concept of volume, returns '' for volume. + +For systems with no syntax differentiating filenames from directories, +assumes that the last file is a path unless $no_file is true or a +trailing separator or /. or /.. is present. On Unix this means that $no_file +true makes this return ( '', $path, '' ). + +The directory portion may or may not be returned with a trailing '/'. + +The results can be passed to L to get back a path equivalent to +(usually identical to) the original path. + +=cut + +sub splitpath { + my ($self,$path, $nofile) = @_; + + my ($volume,$directory,$file) = ('','',''); + + if ( $nofile ) { + $directory = $path; + } + else { + $path =~ m|^ ( (?: .* / (?: \.\.?\z )? )? ) ([^/]*) |xs; + $directory = $1; + $file = $2; + } + + return ($volume,$directory,$file); +} + + +=item splitdir + +The opposite of L. + + @dirs = File::Spec->splitdir( $directories ); + +$directories must be only the directory portion of the path on systems +that have the concept of a volume or that have path syntax that differentiates +files from directories. + +Unlike just splitting the directories on the separator, empty +directory names (C<''>) can be returned, because these are significant +on some OSs. + +On Unix, + + File::Spec->splitdir( "/a/b//c/" ); + +Yields: + + ( '', 'a', 'b', '', 'c', '' ) + +=cut + +sub splitdir { + return split m|/|, $_[1], -1; # Preserve trailing fields +} + + +=item catpath() + +Takes volume, directory and file portions and returns an entire path. Under +Unix, $volume is ignored, and directory and file are concatenated. A '/' is +inserted if needed (though if the directory portion doesn't start with +'/' it is not added). On other OSs, $volume is significant. + +=cut + +sub catpath { + my ($self,$volume,$directory,$file) = @_; + + if ( $directory ne '' && + $file ne '' && + substr( $directory, -1 ) ne '/' && + substr( $file, 0, 1 ) ne '/' + ) { + $directory .= "/$file" ; + } + else { + $directory .= $file ; + } + + return $directory ; +} + +=item abs2rel + +Takes a destination path and an optional base path returns a relative path +from the base path to the destination path: + + $rel_path = File::Spec->abs2rel( $path ) ; + $rel_path = File::Spec->abs2rel( $path, $base ) ; + +If $base is not present or '', then L is used. If $base is +relative, then it is converted to absolute form using +L. This means that it is taken to be relative to +L. + +On systems that have a grammar that indicates filenames, this ignores the +$base filename. Otherwise all path components are assumed to be +directories. + +If $path is relative, it is converted to absolute form using L. +This means that it is taken to be relative to L. + +No checks against the filesystem are made. On VMS, there is +interaction with the working environment, as logicals and +macros are expanded. + +Based on code written by Shigio Yamaguchi. + +=cut + +sub abs2rel { + my($self,$path,$base) = @_; + $base = $self->_cwd() unless defined $base and length $base; + + ($path, $base) = map $self->canonpath($_), $path, $base; + + if (grep $self->file_name_is_absolute($_), $path, $base) { + ($path, $base) = map $self->rel2abs($_), $path, $base; + } + else { + # save a couple of cwd()s if both paths are relative + ($path, $base) = map $self->catdir('/', $_), $path, $base; + } + + my ($path_volume) = $self->splitpath($path, 1); + my ($base_volume) = $self->splitpath($base, 1); + + # Can't relativize across volumes + return $path unless $path_volume eq $base_volume; + + my $path_directories = ($self->splitpath($path, 1))[1]; + my $base_directories = ($self->splitpath($base, 1))[1]; + + # For UNC paths, the user might give a volume like //foo/bar that + # strictly speaking has no directory portion. Treat it as if it + # had the root directory for that volume. + if (!length($base_directories) and $self->file_name_is_absolute($base)) { + $base_directories = $self->rootdir; + } + + # Now, remove all leading components that are the same + my @pathchunks = $self->splitdir( $path_directories ); + my @basechunks = $self->splitdir( $base_directories ); + + if ($base_directories eq $self->rootdir) { + shift @pathchunks; + return $self->canonpath( $self->catpath('', $self->catdir( @pathchunks ), '') ); + } + + while (@pathchunks && @basechunks && $self->_same($pathchunks[0], $basechunks[0])) { + shift @pathchunks ; + shift @basechunks ; + } + return $self->curdir unless @pathchunks || @basechunks; + + # $base now contains the directories the resulting relative path + # must ascend out of before it can descend to $path_directory. + my $result_dirs = $self->catdir( ($self->updir) x @basechunks, @pathchunks ); + return $self->canonpath( $self->catpath('', $result_dirs, '') ); +} + +sub _same { + $_[1] eq $_[2]; +} + +=item rel2abs() + +Converts a relative path to an absolute path. + + $abs_path = File::Spec->rel2abs( $path ) ; + $abs_path = File::Spec->rel2abs( $path, $base ) ; + +If $base is not present or '', then L is used. If $base is +relative, then it is converted to absolute form using +L. This means that it is taken to be relative to +L. + +On systems that have a grammar that indicates filenames, this ignores +the $base filename. Otherwise all path components are assumed to be +directories. + +If $path is absolute, it is cleaned up and returned using L. + +No checks against the filesystem are made. On VMS, there is +interaction with the working environment, as logicals and +macros are expanded. + +Based on code written by Shigio Yamaguchi. + +=cut + +sub rel2abs { + my ($self,$path,$base ) = @_; + + # Clean up $path + if ( ! $self->file_name_is_absolute( $path ) ) { + # Figure out the effective $base and clean it up. + if ( !defined( $base ) || $base eq '' ) { + $base = $self->_cwd(); + } + elsif ( ! $self->file_name_is_absolute( $base ) ) { + $base = $self->rel2abs( $base ) ; + } + else { + $base = $self->canonpath( $base ) ; + } + + # Glom them together + $path = $self->catdir( $base, $path ) ; + } + + return $self->canonpath( $path ) ; +} + +=back + +=head1 COPYRIGHT + +Copyright (c) 2004 by the Perl 5 Porters. All rights reserved. + +This program is free software; you can redistribute it and/or modify +it under the same terms as Perl itself. + +=head1 SEE ALSO + +L + +=cut + +# Internal routine to File::Spec, no point in making this public since +# it is the standard Cwd interface. Most of the platform-specific +# File::Spec subclasses use this. +sub _cwd { + require Cwd; + Cwd::getcwd(); +} + + +# Internal method to reduce xx\..\yy -> yy +sub _collapse { + my($fs, $path) = @_; + + my $updir = $fs->updir; + my $curdir = $fs->curdir; + + my($vol, $dirs, $file) = $fs->splitpath($path); + my @dirs = $fs->splitdir($dirs); + pop @dirs if @dirs && $dirs[-1] eq ''; + + my @collapsed; + foreach my $dir (@dirs) { + if( $dir eq $updir and # if we have an updir + @collapsed and # and something to collapse + length $collapsed[-1] and # and its not the rootdir + $collapsed[-1] ne $updir and # nor another updir + $collapsed[-1] ne $curdir # nor the curdir + ) + { # then + pop @collapsed; # collapse + } + else { # else + push @collapsed, $dir; # just hang onto it + } + } + + return $fs->catpath($vol, + $fs->catdir(@collapsed), + $file + ); +} + + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/File/Temp.pm b/testsuite/input-files/perl-v5.14.2/lib/File/Temp.pm new file mode 100644 index 00000000..a2d4ae07 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/File/Temp.pm @@ -0,0 +1,2452 @@ +package File::Temp; + +=head1 NAME + +File::Temp - return name and handle of a temporary file safely + +=begin __INTERNALS + +=head1 PORTABILITY + +This section is at the top in order to provide easier access to +porters. It is not expected to be rendered by a standard pod +formatting tool. Please skip straight to the SYNOPSIS section if you +are not trying to port this module to a new platform. + +This module is designed to be portable across operating systems and it +currently supports Unix, VMS, DOS, OS/2, Windows and Mac OS +(Classic). When porting to a new OS there are generally three main +issues that have to be solved: + +=over 4 + +=item * + +Can the OS unlink an open file? If it can not then the +C<_can_unlink_opened_file> method should be modified. + +=item * + +Are the return values from C reliable? By default all the +return values from C are compared when unlinking a temporary +file using the filename and the handle. Operating systems other than +unix do not always have valid entries in all fields. If C fails +then the C comparison should be modified accordingly. + +=item * + +Security. Systems that can not support a test for the sticky bit +on a directory can not use the MEDIUM and HIGH security tests. +The C<_can_do_level> method should be modified accordingly. + +=back + +=end __INTERNALS + +=head1 SYNOPSIS + + use File::Temp qw/ tempfile tempdir /; + + $fh = tempfile(); + ($fh, $filename) = tempfile(); + + ($fh, $filename) = tempfile( $template, DIR => $dir); + ($fh, $filename) = tempfile( $template, SUFFIX => '.dat'); + ($fh, $filename) = tempfile( $template, TMPDIR => 1 ); + + binmode( $fh, ":utf8" ); + + $dir = tempdir( CLEANUP => 1 ); + ($fh, $filename) = tempfile( DIR => $dir ); + +Object interface: + + require File::Temp; + use File::Temp (); + use File::Temp qw/ :seekable /; + + $fh = File::Temp->new(); + $fname = $fh->filename; + + $fh = File::Temp->new(TEMPLATE => $template); + $fname = $fh->filename; + + $tmp = File::Temp->new( UNLINK => 0, SUFFIX => '.dat' ); + print $tmp "Some data\n"; + print "Filename is $tmp\n"; + $tmp->seek( 0, SEEK_END ); + +The following interfaces are provided for compatibility with +existing APIs. They should not be used in new code. + +MkTemp family: + + use File::Temp qw/ :mktemp /; + + ($fh, $file) = mkstemp( "tmpfileXXXXX" ); + ($fh, $file) = mkstemps( "tmpfileXXXXXX", $suffix); + + $tmpdir = mkdtemp( $template ); + + $unopened_file = mktemp( $template ); + +POSIX functions: + + use File::Temp qw/ :POSIX /; + + $file = tmpnam(); + $fh = tmpfile(); + + ($fh, $file) = tmpnam(); + +Compatibility functions: + + $unopened_file = File::Temp::tempnam( $dir, $pfx ); + +=head1 DESCRIPTION + +C can be used to create and open temporary files in a safe +way. There is both a function interface and an object-oriented +interface. The File::Temp constructor or the tempfile() function can +be used to return the name and the open filehandle of a temporary +file. The tempdir() function can be used to create a temporary +directory. + +The security aspect of temporary file creation is emphasized such that +a filehandle and filename are returned together. This helps guarantee +that a race condition can not occur where the temporary file is +created by another process between checking for the existence of the +file and its opening. Additional security levels are provided to +check, for example, that the sticky bit is set on world writable +directories. See L<"safe_level"> for more information. + +For compatibility with popular C library functions, Perl implementations of +the mkstemp() family of functions are provided. These are, mkstemp(), +mkstemps(), mkdtemp() and mktemp(). + +Additionally, implementations of the standard L +tmpnam() and tmpfile() functions are provided if required. + +Implementations of mktemp(), tmpnam(), and tempnam() are provided, +but should be used with caution since they return only a filename +that was valid when function was called, so cannot guarantee +that the file will not exist by the time the caller opens the filename. + +Filehandles returned by these functions support the seekable methods. + +=cut + +# 5.6.0 gives us S_IWOTH, S_IWGRP, our and auto-vivifying filehandls +# People would like a version on 5.004 so give them what they want :-) +use 5.004; +use strict; +use Carp; +use File::Spec 0.8; +use File::Path qw/ rmtree /; +use Fcntl 1.03; +use IO::Seekable; # For SEEK_* +use Errno; +require VMS::Stdio if $^O eq 'VMS'; + +# pre-emptively load Carp::Heavy. If we don't when we run out of file +# handles and attempt to call croak() we get an error message telling +# us that Carp::Heavy won't load rather than an error telling us we +# have run out of file handles. We either preload croak() or we +# switch the calls to croak from _gettemp() to use die. +eval { require Carp::Heavy; }; + +# Need the Symbol package if we are running older perl +require Symbol if $] < 5.006; + +### For the OO interface +use base qw/ IO::Handle IO::Seekable /; +use overload '""' => "STRINGIFY", fallback => 1; + +# use 'our' on v5.6.0 +use vars qw($VERSION @EXPORT_OK %EXPORT_TAGS $DEBUG $KEEP_ALL); + +$DEBUG = 0; +$KEEP_ALL = 0; + +# We are exporting functions + +use base qw/Exporter/; + +# Export list - to allow fine tuning of export table + +@EXPORT_OK = qw{ + tempfile + tempdir + tmpnam + tmpfile + mktemp + mkstemp + mkstemps + mkdtemp + unlink0 + cleanup + SEEK_SET + SEEK_CUR + SEEK_END + }; + +# Groups of functions for export + +%EXPORT_TAGS = ( + 'POSIX' => [qw/ tmpnam tmpfile /], + 'mktemp' => [qw/ mktemp mkstemp mkstemps mkdtemp/], + 'seekable' => [qw/ SEEK_SET SEEK_CUR SEEK_END /], + ); + +# add contents of these tags to @EXPORT +Exporter::export_tags('POSIX','mktemp','seekable'); + +# Version number + +$VERSION = '0.22'; + +# This is a list of characters that can be used in random filenames + +my @CHARS = (qw/ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z + a b c d e f g h i j k l m n o p q r s t u v w x y z + 0 1 2 3 4 5 6 7 8 9 _ + /); + +# Maximum number of tries to make a temp file before failing + +use constant MAX_TRIES => 1000; + +# Minimum number of X characters that should be in a template +use constant MINX => 4; + +# Default template when no template supplied + +use constant TEMPXXX => 'X' x 10; + +# Constants for the security level + +use constant STANDARD => 0; +use constant MEDIUM => 1; +use constant HIGH => 2; + +# OPENFLAGS. If we defined the flag to use with Sysopen here this gives +# us an optimisation when many temporary files are requested + +my $OPENFLAGS = O_CREAT | O_EXCL | O_RDWR; +my $LOCKFLAG; + +unless ($^O eq 'MacOS') { + for my $oflag (qw/ NOFOLLOW BINARY LARGEFILE NOINHERIT /) { + my ($bit, $func) = (0, "Fcntl::O_" . $oflag); + no strict 'refs'; + $OPENFLAGS |= $bit if eval { + # Make sure that redefined die handlers do not cause problems + # e.g. CGI::Carp + local $SIG{__DIE__} = sub {}; + local $SIG{__WARN__} = sub {}; + $bit = &$func(); + 1; + }; + } + # Special case O_EXLOCK + $LOCKFLAG = eval { + local $SIG{__DIE__} = sub {}; + local $SIG{__WARN__} = sub {}; + &Fcntl::O_EXLOCK(); + }; +} + +# On some systems the O_TEMPORARY flag can be used to tell the OS +# to automatically remove the file when it is closed. This is fine +# in most cases but not if tempfile is called with UNLINK=>0 and +# the filename is requested -- in the case where the filename is to +# be passed to another routine. This happens on windows. We overcome +# this by using a second open flags variable + +my $OPENTEMPFLAGS = $OPENFLAGS; +unless ($^O eq 'MacOS') { + for my $oflag (qw/ TEMPORARY /) { + my ($bit, $func) = (0, "Fcntl::O_" . $oflag); + local($@); + no strict 'refs'; + $OPENTEMPFLAGS |= $bit if eval { + # Make sure that redefined die handlers do not cause problems + # e.g. CGI::Carp + local $SIG{__DIE__} = sub {}; + local $SIG{__WARN__} = sub {}; + $bit = &$func(); + 1; + }; + } +} + +# Private hash tracking which files have been created by each process id via the OO interface +my %FILES_CREATED_BY_OBJECT; + +# INTERNAL ROUTINES - not to be used outside of package + +# Generic routine for getting a temporary filename +# modelled on OpenBSD _gettemp() in mktemp.c + +# The template must contain X's that are to be replaced +# with the random values + +# Arguments: + +# TEMPLATE - string containing the XXXXX's that is converted +# to a random filename and opened if required + +# Optionally, a hash can also be supplied containing specific options +# "open" => if true open the temp file, else just return the name +# default is 0 +# "mkdir"=> if true, we are creating a temp directory rather than tempfile +# default is 0 +# "suffixlen" => number of characters at end of PATH to be ignored. +# default is 0. +# "unlink_on_close" => indicates that, if possible, the OS should remove +# the file as soon as it is closed. Usually indicates +# use of the O_TEMPORARY flag to sysopen. +# Usually irrelevant on unix +# "use_exlock" => Indicates that O_EXLOCK should be used. Default is true. + +# Optionally a reference to a scalar can be passed into the function +# On error this will be used to store the reason for the error +# "ErrStr" => \$errstr + +# "open" and "mkdir" can not both be true +# "unlink_on_close" is not used when "mkdir" is true. + +# The default options are equivalent to mktemp(). + +# Returns: +# filehandle - open file handle (if called with doopen=1, else undef) +# temp name - name of the temp file or directory + +# For example: +# ($fh, $name) = _gettemp($template, "open" => 1); + +# for the current version, failures are associated with +# stored in an error string and returned to give the reason whilst debugging +# This routine is not called by any external function +sub _gettemp { + + croak 'Usage: ($fh, $name) = _gettemp($template, OPTIONS);' + unless scalar(@_) >= 1; + + # the internal error string - expect it to be overridden + # Need this in case the caller decides not to supply us a value + # need an anonymous scalar + my $tempErrStr; + + # Default options + my %options = ( + "open" => 0, + "mkdir" => 0, + "suffixlen" => 0, + "unlink_on_close" => 0, + "use_exlock" => 1, + "ErrStr" => \$tempErrStr, + ); + + # Read the template + my $template = shift; + if (ref($template)) { + # Use a warning here since we have not yet merged ErrStr + carp "File::Temp::_gettemp: template must not be a reference"; + return (); + } + + # Check that the number of entries on stack are even + if (scalar(@_) % 2 != 0) { + # Use a warning here since we have not yet merged ErrStr + carp "File::Temp::_gettemp: Must have even number of options"; + return (); + } + + # Read the options and merge with defaults + %options = (%options, @_) if @_; + + # Make sure the error string is set to undef + ${$options{ErrStr}} = undef; + + # Can not open the file and make a directory in a single call + if ($options{"open"} && $options{"mkdir"}) { + ${$options{ErrStr}} = "doopen and domkdir can not both be true\n"; + return (); + } + + # Find the start of the end of the Xs (position of last X) + # Substr starts from 0 + my $start = length($template) - 1 - $options{"suffixlen"}; + + # Check that we have at least MINX x X (e.g. 'XXXX") at the end of the string + # (taking suffixlen into account). Any fewer is insecure. + + # Do it using substr - no reason to use a pattern match since + # we know where we are looking and what we are looking for + + if (substr($template, $start - MINX + 1, MINX) ne 'X' x MINX) { + ${$options{ErrStr}} = "The template must end with at least ". + MINX . " 'X' characters\n"; + return (); + } + + # Replace all the X at the end of the substring with a + # random character or just all the XX at the end of a full string. + # Do it as an if, since the suffix adjusts which section to replace + # and suffixlen=0 returns nothing if used in the substr directly + # and generate a full path from the template + + my $path = _replace_XX($template, $options{"suffixlen"}); + + + # Split the path into constituent parts - eventually we need to check + # whether the directory exists + # We need to know whether we are making a temp directory + # or a tempfile + + my ($volume, $directories, $file); + my $parent; # parent directory + if ($options{"mkdir"}) { + # There is no filename at the end + ($volume, $directories, $file) = File::Spec->splitpath( $path, 1); + + # The parent is then $directories without the last directory + # Split the directory and put it back together again + my @dirs = File::Spec->splitdir($directories); + + # If @dirs only has one entry (i.e. the directory template) that means + # we are in the current directory + if ($#dirs == 0) { + $parent = File::Spec->curdir; + } else { + + if ($^O eq 'VMS') { # need volume to avoid relative dir spec + $parent = File::Spec->catdir($volume, @dirs[0..$#dirs-1]); + $parent = 'sys$disk:[]' if $parent eq ''; + } else { + + # Put it back together without the last one + $parent = File::Spec->catdir(@dirs[0..$#dirs-1]); + + # ...and attach the volume (no filename) + $parent = File::Spec->catpath($volume, $parent, ''); + } + + } + + } else { + + # Get rid of the last filename (use File::Basename for this?) + ($volume, $directories, $file) = File::Spec->splitpath( $path ); + + # Join up without the file part + $parent = File::Spec->catpath($volume,$directories,''); + + # If $parent is empty replace with curdir + $parent = File::Spec->curdir + unless $directories ne ''; + + } + + # Check that the parent directories exist + # Do this even for the case where we are simply returning a name + # not a file -- no point returning a name that includes a directory + # that does not exist or is not writable + + unless (-e $parent) { + ${$options{ErrStr}} = "Parent directory ($parent) does not exist"; + return (); + } + unless (-d $parent) { + ${$options{ErrStr}} = "Parent directory ($parent) is not a directory"; + return (); + } + + # Check the stickiness of the directory and chown giveaway if required + # If the directory is world writable the sticky bit + # must be set + + if (File::Temp->safe_level == MEDIUM) { + my $safeerr; + unless (_is_safe($parent,\$safeerr)) { + ${$options{ErrStr}} = "Parent directory ($parent) is not safe ($safeerr)"; + return (); + } + } elsif (File::Temp->safe_level == HIGH) { + my $safeerr; + unless (_is_verysafe($parent, \$safeerr)) { + ${$options{ErrStr}} = "Parent directory ($parent) is not safe ($safeerr)"; + return (); + } + } + + + # Now try MAX_TRIES time to open the file + for (my $i = 0; $i < MAX_TRIES; $i++) { + + # Try to open the file if requested + if ($options{"open"}) { + my $fh; + + # If we are running before perl5.6.0 we can not auto-vivify + if ($] < 5.006) { + $fh = &Symbol::gensym; + } + + # Try to make sure this will be marked close-on-exec + # XXX: Win32 doesn't respect this, nor the proper fcntl, + # but may have O_NOINHERIT. This may or may not be in Fcntl. + local $^F = 2; + + # Attempt to open the file + my $open_success = undef; + if ( $^O eq 'VMS' and $options{"unlink_on_close"} && !$KEEP_ALL) { + # make it auto delete on close by setting FAB$V_DLT bit + $fh = VMS::Stdio::vmssysopen($path, $OPENFLAGS, 0600, 'fop=dlt'); + $open_success = $fh; + } else { + my $flags = ( ($options{"unlink_on_close"} && !$KEEP_ALL) ? + $OPENTEMPFLAGS : + $OPENFLAGS ); + $flags |= $LOCKFLAG if (defined $LOCKFLAG && $options{use_exlock}); + $open_success = sysopen($fh, $path, $flags, 0600); + } + if ( $open_success ) { + + # in case of odd umask force rw + chmod(0600, $path); + + # Opened successfully - return file handle and name + return ($fh, $path); + + } else { + + # Error opening file - abort with error + # if the reason was anything but EEXIST + unless ($!{EEXIST}) { + ${$options{ErrStr}} = "Could not create temp file $path: $!"; + return (); + } + + # Loop round for another try + + } + } elsif ($options{"mkdir"}) { + + # Open the temp directory + if (mkdir( $path, 0700)) { + # in case of odd umask + chmod(0700, $path); + + return undef, $path; + } else { + + # Abort with error if the reason for failure was anything + # except EEXIST + unless ($!{EEXIST}) { + ${$options{ErrStr}} = "Could not create directory $path: $!"; + return (); + } + + # Loop round for another try + + } + + } else { + + # Return true if the file can not be found + # Directory has been checked previously + + return (undef, $path) unless -e $path; + + # Try again until MAX_TRIES + + } + + # Did not successfully open the tempfile/dir + # so try again with a different set of random letters + # No point in trying to increment unless we have only + # 1 X say and the randomness could come up with the same + # file MAX_TRIES in a row. + + # Store current attempt - in principal this implies that the + # 3rd time around the open attempt that the first temp file + # name could be generated again. Probably should store each + # attempt and make sure that none are repeated + + my $original = $path; + my $counter = 0; # Stop infinite loop + my $MAX_GUESS = 50; + + do { + + # Generate new name from original template + $path = _replace_XX($template, $options{"suffixlen"}); + + $counter++; + + } until ($path ne $original || $counter > $MAX_GUESS); + + # Check for out of control looping + if ($counter > $MAX_GUESS) { + ${$options{ErrStr}} = "Tried to get a new temp name different to the previous value $MAX_GUESS times.\nSomething wrong with template?? ($template)"; + return (); + } + + } + + # If we get here, we have run out of tries + ${ $options{ErrStr} } = "Have exceeded the maximum number of attempts (" + . MAX_TRIES . ") to open temp file/dir"; + + return (); + +} + +# Internal routine to replace the XXXX... with random characters +# This has to be done by _gettemp() every time it fails to +# open a temp file/dir + +# Arguments: $template (the template with XXX), +# $ignore (number of characters at end to ignore) + +# Returns: modified template + +sub _replace_XX { + + croak 'Usage: _replace_XX($template, $ignore)' + unless scalar(@_) == 2; + + my ($path, $ignore) = @_; + + # Do it as an if, since the suffix adjusts which section to replace + # and suffixlen=0 returns nothing if used in the substr directly + # Alternatively, could simply set $ignore to length($path)-1 + # Don't want to always use substr when not required though. + my $end = ( $] >= 5.006 ? "\\z" : "\\Z" ); + + if ($ignore) { + substr($path, 0, - $ignore) =~ s/X(?=X*$end)/$CHARS[ int( rand( @CHARS ) ) ]/ge; + } else { + $path =~ s/X(?=X*$end)/$CHARS[ int( rand( @CHARS ) ) ]/ge; + } + return $path; +} + +# Internal routine to force a temp file to be writable after +# it is created so that we can unlink it. Windows seems to occassionally +# force a file to be readonly when written to certain temp locations +sub _force_writable { + my $file = shift; + chmod 0600, $file; +} + + +# internal routine to check to see if the directory is safe +# First checks to see if the directory is not owned by the +# current user or root. Then checks to see if anyone else +# can write to the directory and if so, checks to see if +# it has the sticky bit set + +# Will not work on systems that do not support sticky bit + +#Args: directory path to check +# Optionally: reference to scalar to contain error message +# Returns true if the path is safe and false otherwise. +# Returns undef if can not even run stat() on the path + +# This routine based on version written by Tom Christiansen + +# Presumably, by the time we actually attempt to create the +# file or directory in this directory, it may not be safe +# anymore... Have to run _is_safe directly after the open. + +sub _is_safe { + + my $path = shift; + my $err_ref = shift; + + # Stat path + my @info = stat($path); + unless (scalar(@info)) { + $$err_ref = "stat(path) returned no values"; + return 0; + } + ; + return 1 if $^O eq 'VMS'; # owner delete control at file level + + # Check to see whether owner is neither superuser (or a system uid) nor me + # Use the effective uid from the $> variable + # UID is in [4] + if ($info[4] > File::Temp->top_system_uid() && $info[4] != $>) { + + Carp::cluck(sprintf "uid=$info[4] topuid=%s euid=$> path='$path'", + File::Temp->top_system_uid()); + + $$err_ref = "Directory owned neither by root nor the current user" + if ref($err_ref); + return 0; + } + + # check whether group or other can write file + # use 066 to detect either reading or writing + # use 022 to check writability + # Do it with S_IWOTH and S_IWGRP for portability (maybe) + # mode is in info[2] + if (($info[2] & &Fcntl::S_IWGRP) || # Is group writable? + ($info[2] & &Fcntl::S_IWOTH) ) { # Is world writable? + # Must be a directory + unless (-d $path) { + $$err_ref = "Path ($path) is not a directory" + if ref($err_ref); + return 0; + } + # Must have sticky bit set + unless (-k $path) { + $$err_ref = "Sticky bit not set on $path when dir is group|world writable" + if ref($err_ref); + return 0; + } + } + + return 1; +} + +# Internal routine to check whether a directory is safe +# for temp files. Safer than _is_safe since it checks for +# the possibility of chown giveaway and if that is a possibility +# checks each directory in the path to see if it is safe (with _is_safe) + +# If _PC_CHOWN_RESTRICTED is not set, does the full test of each +# directory anyway. + +# Takes optional second arg as scalar ref to error reason + +sub _is_verysafe { + + # Need POSIX - but only want to bother if really necessary due to overhead + require POSIX; + + my $path = shift; + print "_is_verysafe testing $path\n" if $DEBUG; + return 1 if $^O eq 'VMS'; # owner delete control at file level + + my $err_ref = shift; + + # Should Get the value of _PC_CHOWN_RESTRICTED if it is defined + # and If it is not there do the extensive test + local($@); + my $chown_restricted; + $chown_restricted = &POSIX::_PC_CHOWN_RESTRICTED() + if eval { &POSIX::_PC_CHOWN_RESTRICTED(); 1}; + + # If chown_resticted is set to some value we should test it + if (defined $chown_restricted) { + + # Return if the current directory is safe + return _is_safe($path,$err_ref) if POSIX::sysconf( $chown_restricted ); + + } + + # To reach this point either, the _PC_CHOWN_RESTRICTED symbol + # was not avialable or the symbol was there but chown giveaway + # is allowed. Either way, we now have to test the entire tree for + # safety. + + # Convert path to an absolute directory if required + unless (File::Spec->file_name_is_absolute($path)) { + $path = File::Spec->rel2abs($path); + } + + # Split directory into components - assume no file + my ($volume, $directories, undef) = File::Spec->splitpath( $path, 1); + + # Slightly less efficient than having a function in File::Spec + # to chop off the end of a directory or even a function that + # can handle ../ in a directory tree + # Sometimes splitdir() returns a blank at the end + # so we will probably check the bottom directory twice in some cases + my @dirs = File::Spec->splitdir($directories); + + # Concatenate one less directory each time around + foreach my $pos (0.. $#dirs) { + # Get a directory name + my $dir = File::Spec->catpath($volume, + File::Spec->catdir(@dirs[0.. $#dirs - $pos]), + '' + ); + + print "TESTING DIR $dir\n" if $DEBUG; + + # Check the directory + return 0 unless _is_safe($dir,$err_ref); + + } + + return 1; +} + + + +# internal routine to determine whether unlink works on this +# platform for files that are currently open. +# Returns true if we can, false otherwise. + +# Currently WinNT, OS/2 and VMS can not unlink an opened file +# On VMS this is because the O_EXCL flag is used to open the +# temporary file. Currently I do not know enough about the issues +# on VMS to decide whether O_EXCL is a requirement. + +sub _can_unlink_opened_file { + + if ($^O eq 'MSWin32' || $^O eq 'os2' || $^O eq 'VMS' || $^O eq 'dos' || $^O eq 'MacOS') { + return 0; + } else { + return 1; + } + +} + +# internal routine to decide which security levels are allowed +# see safe_level() for more information on this + +# Controls whether the supplied security level is allowed + +# $cando = _can_do_level( $level ) + +sub _can_do_level { + + # Get security level + my $level = shift; + + # Always have to be able to do STANDARD + return 1 if $level == STANDARD; + + # Currently, the systems that can do HIGH or MEDIUM are identical + if ( $^O eq 'MSWin32' || $^O eq 'os2' || $^O eq 'cygwin' || $^O eq 'dos' || $^O eq 'MacOS' || $^O eq 'mpeix') { + return 0; + } else { + return 1; + } + +} + +# This routine sets up a deferred unlinking of a specified +# filename and filehandle. It is used in the following cases: +# - Called by unlink0 if an opened file can not be unlinked +# - Called by tempfile() if files are to be removed on shutdown +# - Called by tempdir() if directories are to be removed on shutdown + +# Arguments: +# _deferred_unlink( $fh, $fname, $isdir ); +# +# - filehandle (so that it can be expclicitly closed if open +# - filename (the thing we want to remove) +# - isdir (flag to indicate that we are being given a directory) +# [and hence no filehandle] + +# Status is not referred to since all the magic is done with an END block + +{ + # Will set up two lexical variables to contain all the files to be + # removed. One array for files, another for directories They will + # only exist in this block. + + # This means we only have to set up a single END block to remove + # all files. + + # in order to prevent child processes inadvertently deleting the parent + # temp files we use a hash to store the temp files and directories + # created by a particular process id. + + # %files_to_unlink contains values that are references to an array of + # array references containing the filehandle and filename associated with + # the temp file. + my (%files_to_unlink, %dirs_to_unlink); + + # Set up an end block to use these arrays + END { + local($., $@, $!, $^E, $?); + cleanup(); + } + + # Cleanup function. Always triggered on END but can be invoked + # manually. + sub cleanup { + if (!$KEEP_ALL) { + # Files + my @files = (exists $files_to_unlink{$$} ? + @{ $files_to_unlink{$$} } : () ); + foreach my $file (@files) { + # close the filehandle without checking its state + # in order to make real sure that this is closed + # if its already closed then I dont care about the answer + # probably a better way to do this + close($file->[0]); # file handle is [0] + + if (-f $file->[1]) { # file name is [1] + _force_writable( $file->[1] ); # for windows + unlink $file->[1] or warn "Error removing ".$file->[1]; + } + } + # Dirs + my @dirs = (exists $dirs_to_unlink{$$} ? + @{ $dirs_to_unlink{$$} } : () ); + foreach my $dir (@dirs) { + if (-d $dir) { + # Some versions of rmtree will abort if you attempt to remove + # the directory you are sitting in. We protect that and turn it + # into a warning. We do this because this occurs during + # cleanup and so can not be caught by the user. + eval { rmtree($dir, $DEBUG, 0); }; + warn $@ if ($@ && $^W); + } + } + + # clear the arrays + @{ $files_to_unlink{$$} } = () + if exists $files_to_unlink{$$}; + @{ $dirs_to_unlink{$$} } = () + if exists $dirs_to_unlink{$$}; + } + } + + + # This is the sub called to register a file for deferred unlinking + # This could simply store the input parameters and defer everything + # until the END block. For now we do a bit of checking at this + # point in order to make sure that (1) we have a file/dir to delete + # and (2) we have been called with the correct arguments. + sub _deferred_unlink { + + croak 'Usage: _deferred_unlink($fh, $fname, $isdir)' + unless scalar(@_) == 3; + + my ($fh, $fname, $isdir) = @_; + + warn "Setting up deferred removal of $fname\n" + if $DEBUG; + + # If we have a directory, check that it is a directory + if ($isdir) { + + if (-d $fname) { + + # Directory exists so store it + # first on VMS turn []foo into [.foo] for rmtree + $fname = VMS::Filespec::vmspath($fname) if $^O eq 'VMS'; + $dirs_to_unlink{$$} = [] + unless exists $dirs_to_unlink{$$}; + push (@{ $dirs_to_unlink{$$} }, $fname); + + } else { + carp "Request to remove directory $fname could not be completed since it does not exist!\n" if $^W; + } + + } else { + + if (-f $fname) { + + # file exists so store handle and name for later removal + $files_to_unlink{$$} = [] + unless exists $files_to_unlink{$$}; + push(@{ $files_to_unlink{$$} }, [$fh, $fname]); + + } else { + carp "Request to remove file $fname could not be completed since it is not there!\n" if $^W; + } + + } + + } + + +} + +=head1 OBJECT-ORIENTED INTERFACE + +This is the primary interface for interacting with +C. Using the OO interface a temporary file can be created +when the object is constructed and the file can be removed when the +object is no longer required. + +Note that there is no method to obtain the filehandle from the +C object. The object itself acts as a filehandle. Also, +the object is configured such that it stringifies to the name of the +temporary file, and can be compared to a filename directly. The object +isa C and isa C so all those methods are +available. + +=over 4 + +=item B + +Create a temporary file object. + + my $tmp = File::Temp->new(); + +by default the object is constructed as if C +was called without options, but with the additional behaviour +that the temporary file is removed by the object destructor +if UNLINK is set to true (the default). + +Supported arguments are the same as for C: UNLINK +(defaulting to true), DIR, EXLOCK and SUFFIX. Additionally, the filename +template is specified using the TEMPLATE option. The OPEN option +is not supported (the file is always opened). + + $tmp = File::Temp->new( TEMPLATE => 'tempXXXXX', + DIR => 'mydir', + SUFFIX => '.dat'); + +Arguments are case insensitive. + +Can call croak() if an error occurs. + +=cut + +sub new { + my $proto = shift; + my $class = ref($proto) || $proto; + + # read arguments and convert keys to upper case + my %args = @_; + %args = map { uc($_), $args{$_} } keys %args; + + # see if they are unlinking (defaulting to yes) + my $unlink = (exists $args{UNLINK} ? $args{UNLINK} : 1 ); + delete $args{UNLINK}; + + # template (store it in an array so that it will + # disappear from the arg list of tempfile) + my @template = ( exists $args{TEMPLATE} ? $args{TEMPLATE} : () ); + delete $args{TEMPLATE}; + + # Protect OPEN + delete $args{OPEN}; + + # Open the file and retain file handle and file name + my ($fh, $path) = tempfile( @template, %args ); + + print "Tmp: $fh - $path\n" if $DEBUG; + + # Store the filename in the scalar slot + ${*$fh} = $path; + + # Cache the filename by pid so that the destructor can decide whether to remove it + $FILES_CREATED_BY_OBJECT{$$}{$path} = 1; + + # Store unlink information in hash slot (plus other constructor info) + %{*$fh} = %args; + + # create the object + bless $fh, $class; + + # final method-based configuration + $fh->unlink_on_destroy( $unlink ); + + return $fh; +} + +=item B + +Create a temporary directory using an object oriented interface. + + $dir = File::Temp->newdir(); + +By default the directory is deleted when the object goes out of scope. + +Supports the same options as the C function. Note that directories +created with this method default to CLEANUP => 1. + + $dir = File::Temp->newdir( $template, %options ); + +=cut + +sub newdir { + my $self = shift; + + # need to handle args as in tempdir because we have to force CLEANUP + # default without passing CLEANUP to tempdir + my $template = (scalar(@_) % 2 == 1 ? shift(@_) : undef ); + my %options = @_; + my $cleanup = (exists $options{CLEANUP} ? $options{CLEANUP} : 1 ); + + delete $options{CLEANUP}; + + my $tempdir; + if (defined $template) { + $tempdir = tempdir( $template, %options ); + } else { + $tempdir = tempdir( %options ); + } + return bless { DIRNAME => $tempdir, + CLEANUP => $cleanup, + LAUNCHPID => $$, + }, "File::Temp::Dir"; +} + +=item B + +Return the name of the temporary file associated with this object +(if the object was created using the "new" constructor). + + $filename = $tmp->filename; + +This method is called automatically when the object is used as +a string. + +=cut + +sub filename { + my $self = shift; + return ${*$self}; +} + +sub STRINGIFY { + my $self = shift; + return $self->filename; +} + +=item B + +Return the name of the temporary directory associated with this +object (if the object was created using the "newdir" constructor). + + $dirname = $tmpdir->dirname; + +This method is called automatically when the object is used in string context. + +=item B + +Control whether the file is unlinked when the object goes out of scope. +The file is removed if this value is true and $KEEP_ALL is not. + + $fh->unlink_on_destroy( 1 ); + +Default is for the file to be removed. + +=cut + +sub unlink_on_destroy { + my $self = shift; + if (@_) { + ${*$self}{UNLINK} = shift; + } + return ${*$self}{UNLINK}; +} + +=item B + +When the object goes out of scope, the destructor is called. This +destructor will attempt to unlink the file (using C) +if the constructor was called with UNLINK set to 1 (the default state +if UNLINK is not specified). + +No error is given if the unlink fails. + +If the object has been passed to a child process during a fork, the +file will be deleted when the object goes out of scope in the parent. + +For a temporary directory object the directory will be removed +unless the CLEANUP argument was used in the constructor (and set to +false) or C was modified after creation. + +If the global variable $KEEP_ALL is true, the file or directory +will not be removed. + +=cut + +sub DESTROY { + local($., $@, $!, $^E, $?); + my $self = shift; + + # Make sure we always remove the file from the global hash + # on destruction. This prevents the hash from growing uncontrollably + # and post-destruction there is no reason to know about the file. + my $file = $self->filename; + my $was_created_by_proc; + if (exists $FILES_CREATED_BY_OBJECT{$$}{$file}) { + $was_created_by_proc = 1; + delete $FILES_CREATED_BY_OBJECT{$$}{$file}; + } + + if (${*$self}{UNLINK} && !$KEEP_ALL) { + print "# ---------> Unlinking $self\n" if $DEBUG; + + # only delete if this process created it + return unless $was_created_by_proc; + + # The unlink1 may fail if the file has been closed + # by the caller. This leaves us with the decision + # of whether to refuse to remove the file or simply + # do an unlink without test. Seems to be silly + # to do this when we are trying to be careful + # about security + _force_writable( $file ); # for windows + unlink1( $self, $file ) + or unlink($file); + } +} + +=back + +=head1 FUNCTIONS + +This section describes the recommended interface for generating +temporary files and directories. + +=over 4 + +=item B + +This is the basic function to generate temporary files. +The behaviour of the file can be changed using various options: + + $fh = tempfile(); + ($fh, $filename) = tempfile(); + +Create a temporary file in the directory specified for temporary +files, as specified by the tmpdir() function in L. + + ($fh, $filename) = tempfile($template); + +Create a temporary file in the current directory using the supplied +template. Trailing `X' characters are replaced with random letters to +generate the filename. At least four `X' characters must be present +at the end of the template. + + ($fh, $filename) = tempfile($template, SUFFIX => $suffix) + +Same as previously, except that a suffix is added to the template +after the `X' translation. Useful for ensuring that a temporary +filename has a particular extension when needed by other applications. +But see the WARNING at the end. + + ($fh, $filename) = tempfile($template, DIR => $dir); + +Translates the template as before except that a directory name +is specified. + + ($fh, $filename) = tempfile($template, TMPDIR => 1); + +Equivalent to specifying a DIR of "File::Spec->tmpdir", writing the file +into the same temporary directory as would be used if no template was +specified at all. + + ($fh, $filename) = tempfile($template, UNLINK => 1); + +Return the filename and filehandle as before except that the file is +automatically removed when the program exits (dependent on +$KEEP_ALL). Default is for the file to be removed if a file handle is +requested and to be kept if the filename is requested. In a scalar +context (where no filename is returned) the file is always deleted +either (depending on the operating system) on exit or when it is +closed (unless $KEEP_ALL is true when the temp file is created). + +Use the object-oriented interface if fine-grained control of when +a file is removed is required. + +If the template is not specified, a template is always +automatically generated. This temporary file is placed in tmpdir() +(L) unless a directory is specified explicitly with the +DIR option. + + $fh = tempfile( DIR => $dir ); + +If called in scalar context, only the filehandle is returned and the +file will automatically be deleted when closed on operating systems +that support this (see the description of tmpfile() elsewhere in this +document). This is the preferred mode of operation, as if you only +have a filehandle, you can never create a race condition by fumbling +with the filename. On systems that can not unlink an open file or can +not mark a file as temporary when it is opened (for example, Windows +NT uses the C flag) the file is marked for deletion when +the program ends (equivalent to setting UNLINK to 1). The C +flag is ignored if present. + + (undef, $filename) = tempfile($template, OPEN => 0); + +This will return the filename based on the template but +will not open this file. Cannot be used in conjunction with +UNLINK set to true. Default is to always open the file +to protect from possible race conditions. A warning is issued +if warnings are turned on. Consider using the tmpnam() +and mktemp() functions described elsewhere in this document +if opening the file is not required. + +If the operating system supports it (for example BSD derived systems), the +filehandle will be opened with O_EXLOCK (open with exclusive file lock). +This can sometimes cause problems if the intention is to pass the filename +to another system that expects to take an exclusive lock itself (such as +DBD::SQLite) whilst ensuring that the tempfile is not reused. In this +situation the "EXLOCK" option can be passed to tempfile. By default EXLOCK +will be true (this retains compatibility with earlier releases). + + ($fh, $filename) = tempfile($template, EXLOCK => 0); + +Options can be combined as required. + +Will croak() if there is an error. + +=cut + +sub tempfile { + + # Can not check for argument count since we can have any + # number of args + + # Default options + my %options = ( + "DIR" => undef, # Directory prefix + "SUFFIX" => '', # Template suffix + "UNLINK" => 0, # Do not unlink file on exit + "OPEN" => 1, # Open file + "TMPDIR" => 0, # Place tempfile in tempdir if template specified + "EXLOCK" => 1, # Open file with O_EXLOCK + ); + + # Check to see whether we have an odd or even number of arguments + my $template = (scalar(@_) % 2 == 1 ? shift(@_) : undef); + + # Read the options and merge with defaults + %options = (%options, @_) if @_; + + # First decision is whether or not to open the file + if (! $options{"OPEN"}) { + + warn "tempfile(): temporary filename requested but not opened.\nPossibly unsafe, consider using tempfile() with OPEN set to true\n" + if $^W; + + } + + if ($options{"DIR"} and $^O eq 'VMS') { + + # on VMS turn []foo into [.foo] for concatenation + $options{"DIR"} = VMS::Filespec::vmspath($options{"DIR"}); + } + + # Construct the template + + # Have a choice of trying to work around the mkstemp/mktemp/tmpnam etc + # functions or simply constructing a template and using _gettemp() + # explicitly. Go for the latter + + # First generate a template if not defined and prefix the directory + # If no template must prefix the temp directory + if (defined $template) { + # End up with current directory if neither DIR not TMPDIR are set + if ($options{"DIR"}) { + + $template = File::Spec->catfile($options{"DIR"}, $template); + + } elsif ($options{TMPDIR}) { + + $template = File::Spec->catfile(File::Spec->tmpdir, $template ); + + } + + } else { + + if ($options{"DIR"}) { + + $template = File::Spec->catfile($options{"DIR"}, TEMPXXX); + + } else { + + $template = File::Spec->catfile(File::Spec->tmpdir, TEMPXXX); + + } + + } + + # Now add a suffix + $template .= $options{"SUFFIX"}; + + # Determine whether we should tell _gettemp to unlink the file + # On unix this is irrelevant and can be worked out after the file is + # opened (simply by unlinking the open filehandle). On Windows or VMS + # we have to indicate temporary-ness when we open the file. In general + # we only want a true temporary file if we are returning just the + # filehandle - if the user wants the filename they probably do not + # want the file to disappear as soon as they close it (which may be + # important if they want a child process to use the file) + # For this reason, tie unlink_on_close to the return context regardless + # of OS. + my $unlink_on_close = ( wantarray ? 0 : 1); + + # Create the file + my ($fh, $path, $errstr); + croak "Error in tempfile() using $template: $errstr" + unless (($fh, $path) = _gettemp($template, + "open" => $options{'OPEN'}, + "mkdir"=> 0 , + "unlink_on_close" => $unlink_on_close, + "suffixlen" => length($options{'SUFFIX'}), + "ErrStr" => \$errstr, + "use_exlock" => $options{EXLOCK}, + ) ); + + # Set up an exit handler that can do whatever is right for the + # system. This removes files at exit when requested explicitly or when + # system is asked to unlink_on_close but is unable to do so because + # of OS limitations. + # The latter should be achieved by using a tied filehandle. + # Do not check return status since this is all done with END blocks. + _deferred_unlink($fh, $path, 0) if $options{"UNLINK"}; + + # Return + if (wantarray()) { + + if ($options{'OPEN'}) { + return ($fh, $path); + } else { + return (undef, $path); + } + + } else { + + # Unlink the file. It is up to unlink0 to decide what to do with + # this (whether to unlink now or to defer until later) + unlink0($fh, $path) or croak "Error unlinking file $path using unlink0"; + + # Return just the filehandle. + return $fh; + } + + +} + +=item B + +This is the recommended interface for creation of temporary +directories. By default the directory will not be removed on exit +(that is, it won't be temporary; this behaviour can not be changed +because of issues with backwards compatibility). To enable removal +either use the CLEANUP option which will trigger removal on program +exit, or consider using the "newdir" method in the object interface which +will allow the directory to be cleaned up when the object goes out of +scope. + +The behaviour of the function depends on the arguments: + + $tempdir = tempdir(); + +Create a directory in tmpdir() (see L). + + $tempdir = tempdir( $template ); + +Create a directory from the supplied template. This template is +similar to that described for tempfile(). `X' characters at the end +of the template are replaced with random letters to construct the +directory name. At least four `X' characters must be in the template. + + $tempdir = tempdir ( DIR => $dir ); + +Specifies the directory to use for the temporary directory. +The temporary directory name is derived from an internal template. + + $tempdir = tempdir ( $template, DIR => $dir ); + +Prepend the supplied directory name to the template. The template +should not include parent directory specifications itself. Any parent +directory specifications are removed from the template before +prepending the supplied directory. + + $tempdir = tempdir ( $template, TMPDIR => 1 ); + +Using the supplied template, create the temporary directory in +a standard location for temporary files. Equivalent to doing + + $tempdir = tempdir ( $template, DIR => File::Spec->tmpdir); + +but shorter. Parent directory specifications are stripped from the +template itself. The C option is ignored if C is set +explicitly. Additionally, C is implied if neither a template +nor a directory are supplied. + + $tempdir = tempdir( $template, CLEANUP => 1); + +Create a temporary directory using the supplied template, but +attempt to remove it (and all files inside it) when the program +exits. Note that an attempt will be made to remove all files from +the directory even if they were not created by this module (otherwise +why ask to clean it up?). The directory removal is made with +the rmtree() function from the L module. +Of course, if the template is not specified, the temporary directory +will be created in tmpdir() and will also be removed at program exit. + +Will croak() if there is an error. + +=cut + +# ' + +sub tempdir { + + # Can not check for argument count since we can have any + # number of args + + # Default options + my %options = ( + "CLEANUP" => 0, # Remove directory on exit + "DIR" => '', # Root directory + "TMPDIR" => 0, # Use tempdir with template + ); + + # Check to see whether we have an odd or even number of arguments + my $template = (scalar(@_) % 2 == 1 ? shift(@_) : undef ); + + # Read the options and merge with defaults + %options = (%options, @_) if @_; + + # Modify or generate the template + + # Deal with the DIR and TMPDIR options + if (defined $template) { + + # Need to strip directory path if using DIR or TMPDIR + if ($options{'TMPDIR'} || $options{'DIR'}) { + + # Strip parent directory from the filename + # + # There is no filename at the end + $template = VMS::Filespec::vmspath($template) if $^O eq 'VMS'; + my ($volume, $directories, undef) = File::Spec->splitpath( $template, 1); + + # Last directory is then our template + $template = (File::Spec->splitdir($directories))[-1]; + + # Prepend the supplied directory or temp dir + if ($options{"DIR"}) { + + $template = File::Spec->catdir($options{"DIR"}, $template); + + } elsif ($options{TMPDIR}) { + + # Prepend tmpdir + $template = File::Spec->catdir(File::Spec->tmpdir, $template); + + } + + } + + } else { + + if ($options{"DIR"}) { + + $template = File::Spec->catdir($options{"DIR"}, TEMPXXX); + + } else { + + $template = File::Spec->catdir(File::Spec->tmpdir, TEMPXXX); + + } + + } + + # Create the directory + my $tempdir; + my $suffixlen = 0; + if ($^O eq 'VMS') { # dir names can end in delimiters + $template =~ m/([\.\]:>]+)$/; + $suffixlen = length($1); + } + if ( ($^O eq 'MacOS') && (substr($template, -1) eq ':') ) { + # dir name has a trailing ':' + ++$suffixlen; + } + + my $errstr; + croak "Error in tempdir() using $template: $errstr" + unless ((undef, $tempdir) = _gettemp($template, + "open" => 0, + "mkdir"=> 1 , + "suffixlen" => $suffixlen, + "ErrStr" => \$errstr, + ) ); + + # Install exit handler; must be dynamic to get lexical + if ( $options{'CLEANUP'} && -d $tempdir) { + _deferred_unlink(undef, $tempdir, 1); + } + + # Return the dir name + return $tempdir; + +} + +=back + +=head1 MKTEMP FUNCTIONS + +The following functions are Perl implementations of the +mktemp() family of temp file generation system calls. + +=over 4 + +=item B + +Given a template, returns a filehandle to the temporary file and the name +of the file. + + ($fh, $name) = mkstemp( $template ); + +In scalar context, just the filehandle is returned. + +The template may be any filename with some number of X's appended +to it, for example F. The trailing X's are replaced +with unique alphanumeric combinations. + +Will croak() if there is an error. + +=cut + + + +sub mkstemp { + + croak "Usage: mkstemp(template)" + if scalar(@_) != 1; + + my $template = shift; + + my ($fh, $path, $errstr); + croak "Error in mkstemp using $template: $errstr" + unless (($fh, $path) = _gettemp($template, + "open" => 1, + "mkdir"=> 0 , + "suffixlen" => 0, + "ErrStr" => \$errstr, + ) ); + + if (wantarray()) { + return ($fh, $path); + } else { + return $fh; + } + +} + + +=item B + +Similar to mkstemp(), except that an extra argument can be supplied +with a suffix to be appended to the template. + + ($fh, $name) = mkstemps( $template, $suffix ); + +For example a template of C and suffix of C<.dat> +would generate a file similar to F. + +Returns just the filehandle alone when called in scalar context. + +Will croak() if there is an error. + +=cut + +sub mkstemps { + + croak "Usage: mkstemps(template, suffix)" + if scalar(@_) != 2; + + + my $template = shift; + my $suffix = shift; + + $template .= $suffix; + + my ($fh, $path, $errstr); + croak "Error in mkstemps using $template: $errstr" + unless (($fh, $path) = _gettemp($template, + "open" => 1, + "mkdir"=> 0 , + "suffixlen" => length($suffix), + "ErrStr" => \$errstr, + ) ); + + if (wantarray()) { + return ($fh, $path); + } else { + return $fh; + } + +} + +=item B + +Create a directory from a template. The template must end in +X's that are replaced by the routine. + + $tmpdir_name = mkdtemp($template); + +Returns the name of the temporary directory created. + +Directory must be removed by the caller. + +Will croak() if there is an error. + +=cut + +#' # for emacs + +sub mkdtemp { + + croak "Usage: mkdtemp(template)" + if scalar(@_) != 1; + + my $template = shift; + my $suffixlen = 0; + if ($^O eq 'VMS') { # dir names can end in delimiters + $template =~ m/([\.\]:>]+)$/; + $suffixlen = length($1); + } + if ( ($^O eq 'MacOS') && (substr($template, -1) eq ':') ) { + # dir name has a trailing ':' + ++$suffixlen; + } + my ($junk, $tmpdir, $errstr); + croak "Error creating temp directory from template $template\: $errstr" + unless (($junk, $tmpdir) = _gettemp($template, + "open" => 0, + "mkdir"=> 1 , + "suffixlen" => $suffixlen, + "ErrStr" => \$errstr, + ) ); + + return $tmpdir; + +} + +=item B + +Returns a valid temporary filename but does not guarantee +that the file will not be opened by someone else. + + $unopened_file = mktemp($template); + +Template is the same as that required by mkstemp(). + +Will croak() if there is an error. + +=cut + +sub mktemp { + + croak "Usage: mktemp(template)" + if scalar(@_) != 1; + + my $template = shift; + + my ($tmpname, $junk, $errstr); + croak "Error getting name to temp file from template $template: $errstr" + unless (($junk, $tmpname) = _gettemp($template, + "open" => 0, + "mkdir"=> 0 , + "suffixlen" => 0, + "ErrStr" => \$errstr, + ) ); + + return $tmpname; +} + +=back + +=head1 POSIX FUNCTIONS + +This section describes the re-implementation of the tmpnam() +and tmpfile() functions described in L +using the mkstemp() from this module. + +Unlike the L implementations, the directory used +for the temporary file is not specified in a system include +file (C) but simply depends on the choice of tmpdir() +returned by L. On some implementations this +location can be set using the C environment variable, which +may not be secure. +If this is a problem, simply use mkstemp() and specify a template. + +=over 4 + +=item B + +When called in scalar context, returns the full name (including path) +of a temporary file (uses mktemp()). The only check is that the file does +not already exist, but there is no guarantee that that condition will +continue to apply. + + $file = tmpnam(); + +When called in list context, a filehandle to the open file and +a filename are returned. This is achieved by calling mkstemp() +after constructing a suitable template. + + ($fh, $file) = tmpnam(); + +If possible, this form should be used to prevent possible +race conditions. + +See L for information on the choice of temporary +directory for a particular operating system. + +Will croak() if there is an error. + +=cut + +sub tmpnam { + + # Retrieve the temporary directory name + my $tmpdir = File::Spec->tmpdir; + + croak "Error temporary directory is not writable" + if $tmpdir eq ''; + + # Use a ten character template and append to tmpdir + my $template = File::Spec->catfile($tmpdir, TEMPXXX); + + if (wantarray() ) { + return mkstemp($template); + } else { + return mktemp($template); + } + +} + +=item B + +Returns the filehandle of a temporary file. + + $fh = tmpfile(); + +The file is removed when the filehandle is closed or when the program +exits. No access to the filename is provided. + +If the temporary file can not be created undef is returned. +Currently this command will probably not work when the temporary +directory is on an NFS file system. + +Will croak() if there is an error. + +=cut + +sub tmpfile { + + # Simply call tmpnam() in a list context + my ($fh, $file) = tmpnam(); + + # Make sure file is removed when filehandle is closed + # This will fail on NFS + unlink0($fh, $file) + or return undef; + + return $fh; + +} + +=back + +=head1 ADDITIONAL FUNCTIONS + +These functions are provided for backwards compatibility +with common tempfile generation C library functions. + +They are not exported and must be addressed using the full package +name. + +=over 4 + +=item B + +Return the name of a temporary file in the specified directory +using a prefix. The file is guaranteed not to exist at the time +the function was called, but such guarantees are good for one +clock tick only. Always use the proper form of C +with C if you must open such a filename. + + $filename = File::Temp::tempnam( $dir, $prefix ); + +Equivalent to running mktemp() with $dir/$prefixXXXXXXXX +(using unix file convention as an example) + +Because this function uses mktemp(), it can suffer from race conditions. + +Will croak() if there is an error. + +=cut + +sub tempnam { + + croak 'Usage tempnam($dir, $prefix)' unless scalar(@_) == 2; + + my ($dir, $prefix) = @_; + + # Add a string to the prefix + $prefix .= 'XXXXXXXX'; + + # Concatenate the directory to the file + my $template = File::Spec->catfile($dir, $prefix); + + return mktemp($template); + +} + +=back + +=head1 UTILITY FUNCTIONS + +Useful functions for dealing with the filehandle and filename. + +=over 4 + +=item B + +Given an open filehandle and the associated filename, make a safe +unlink. This is achieved by first checking that the filename and +filehandle initially point to the same file and that the number of +links to the file is 1 (all fields returned by stat() are compared). +Then the filename is unlinked and the filehandle checked once again to +verify that the number of links on that file is now 0. This is the +closest you can come to making sure that the filename unlinked was the +same as the file whose descriptor you hold. + + unlink0($fh, $path) + or die "Error unlinking file $path safely"; + +Returns false on error but croaks() if there is a security +anomaly. The filehandle is not closed since on some occasions this is +not required. + +On some platforms, for example Windows NT, it is not possible to +unlink an open file (the file must be closed first). On those +platforms, the actual unlinking is deferred until the program ends and +good status is returned. A check is still performed to make sure that +the filehandle and filename are pointing to the same thing (but not at +the time the end block is executed since the deferred removal may not +have access to the filehandle). + +Additionally, on Windows NT not all the fields returned by stat() can +be compared. For example, the C and C fields seem to be +different. Also, it seems that the size of the file returned by stat() +does not always agree, with C being more accurate than +C, presumably because of caching issues even when +using autoflush (this is usually overcome by waiting a while after +writing to the tempfile before attempting to C it). + +Finally, on NFS file systems the link count of the file handle does +not always go to zero immediately after unlinking. Currently, this +command is expected to fail on NFS disks. + +This function is disabled if the global variable $KEEP_ALL is true +and an unlink on open file is supported. If the unlink is to be deferred +to the END block, the file is still registered for removal. + +This function should not be called if you are using the object oriented +interface since the it will interfere with the object destructor deleting +the file. + +=cut + +sub unlink0 { + + croak 'Usage: unlink0(filehandle, filename)' + unless scalar(@_) == 2; + + # Read args + my ($fh, $path) = @_; + + cmpstat($fh, $path) or return 0; + + # attempt remove the file (does not work on some platforms) + if (_can_unlink_opened_file()) { + + # return early (Without unlink) if we have been instructed to retain files. + return 1 if $KEEP_ALL; + + # XXX: do *not* call this on a directory; possible race + # resulting in recursive removal + croak "unlink0: $path has become a directory!" if -d $path; + unlink($path) or return 0; + + # Stat the filehandle + my @fh = stat $fh; + + print "Link count = $fh[3] \n" if $DEBUG; + + # Make sure that the link count is zero + # - Cygwin provides deferred unlinking, however, + # on Win9x the link count remains 1 + # On NFS the link count may still be 1 but we cant know that + # we are on NFS + return ( $fh[3] == 0 or $^O eq 'cygwin' ? 1 : 0); + + } else { + _deferred_unlink($fh, $path, 0); + return 1; + } + +} + +=item B + +Compare C of filehandle with C of provided filename. This +can be used to check that the filename and filehandle initially point +to the same file and that the number of links to the file is 1 (all +fields returned by stat() are compared). + + cmpstat($fh, $path) + or die "Error comparing handle with file"; + +Returns false if the stat information differs or if the link count is +greater than 1. Calls croak if there is a security anomaly. + +On certain platforms, for example Windows, not all the fields returned by stat() +can be compared. For example, the C and C fields seem to be +different in Windows. Also, it seems that the size of the file +returned by stat() does not always agree, with C being more +accurate than C, presumably because of caching issues +even when using autoflush (this is usually overcome by waiting a while +after writing to the tempfile before attempting to C it). + +Not exported by default. + +=cut + +sub cmpstat { + + croak 'Usage: cmpstat(filehandle, filename)' + unless scalar(@_) == 2; + + # Read args + my ($fh, $path) = @_; + + warn "Comparing stat\n" + if $DEBUG; + + # Stat the filehandle - which may be closed if someone has manually + # closed the file. Can not turn off warnings without using $^W + # unless we upgrade to 5.006 minimum requirement + my @fh; + { + local ($^W) = 0; + @fh = stat $fh; + } + return unless @fh; + + if ($fh[3] > 1 && $^W) { + carp "unlink0: fstat found too many links; SB=@fh" if $^W; + } + + # Stat the path + my @path = stat $path; + + unless (@path) { + carp "unlink0: $path is gone already" if $^W; + return; + } + + # this is no longer a file, but may be a directory, or worse + unless (-f $path) { + confess "panic: $path is no longer a file: SB=@fh"; + } + + # Do comparison of each member of the array + # On WinNT dev and rdev seem to be different + # depending on whether it is a file or a handle. + # Cannot simply compare all members of the stat return + # Select the ones we can use + my @okstat = (0..$#fh); # Use all by default + if ($^O eq 'MSWin32') { + @okstat = (1,2,3,4,5,7,8,9,10); + } elsif ($^O eq 'os2') { + @okstat = (0, 2..$#fh); + } elsif ($^O eq 'VMS') { # device and file ID are sufficient + @okstat = (0, 1); + } elsif ($^O eq 'dos') { + @okstat = (0,2..7,11..$#fh); + } elsif ($^O eq 'mpeix') { + @okstat = (0..4,8..10); + } + + # Now compare each entry explicitly by number + for (@okstat) { + print "Comparing: $_ : $fh[$_] and $path[$_]\n" if $DEBUG; + # Use eq rather than == since rdev, blksize, and blocks (6, 11, + # and 12) will be '' on platforms that do not support them. This + # is fine since we are only comparing integers. + unless ($fh[$_] eq $path[$_]) { + warn "Did not match $_ element of stat\n" if $DEBUG; + return 0; + } + } + + return 1; +} + +=item B + +Similar to C except after file comparison using cmpstat, the +filehandle is closed prior to attempting to unlink the file. This +allows the file to be removed without using an END block, but does +mean that the post-unlink comparison of the filehandle state provided +by C is not available. + + unlink1($fh, $path) + or die "Error closing and unlinking file"; + +Usually called from the object destructor when using the OO interface. + +Not exported by default. + +This function is disabled if the global variable $KEEP_ALL is true. + +Can call croak() if there is a security anomaly during the stat() +comparison. + +=cut + +sub unlink1 { + croak 'Usage: unlink1(filehandle, filename)' + unless scalar(@_) == 2; + + # Read args + my ($fh, $path) = @_; + + cmpstat($fh, $path) or return 0; + + # Close the file + close( $fh ) or return 0; + + # Make sure the file is writable (for windows) + _force_writable( $path ); + + # return early (without unlink) if we have been instructed to retain files. + return 1 if $KEEP_ALL; + + # remove the file + return unlink($path); +} + +=item B + +Calling this function will cause any temp files or temp directories +that are registered for removal to be removed. This happens automatically +when the process exits but can be triggered manually if the caller is sure +that none of the temp files are required. This method can be registered as +an Apache callback. + +On OSes where temp files are automatically removed when the temp file +is closed, calling this function will have no effect other than to remove +temporary directories (which may include temporary files). + + File::Temp::cleanup(); + +Not exported by default. + +=back + +=head1 PACKAGE VARIABLES + +These functions control the global state of the package. + +=over 4 + +=item B + +Controls the lengths to which the module will go to check the safety of the +temporary file or directory before proceeding. +Options are: + +=over 8 + +=item STANDARD + +Do the basic security measures to ensure the directory exists and is +writable, that temporary files are opened only if they do not already +exist, and that possible race conditions are avoided. Finally the +L function is used to remove files safely. + +=item MEDIUM + +In addition to the STANDARD security, the output directory is checked +to make sure that it is owned either by root or the user running the +program. If the directory is writable by group or by other, it is then +checked to make sure that the sticky bit is set. + +Will not work on platforms that do not support the C<-k> test +for sticky bit. + +=item HIGH + +In addition to the MEDIUM security checks, also check for the +possibility of ``chown() giveaway'' using the L +sysconf() function. If this is a possibility, each directory in the +path is checked in turn for safeness, recursively walking back to the +root directory. + +For platforms that do not support the L +C<_PC_CHOWN_RESTRICTED> symbol (for example, Windows NT) it is +assumed that ``chown() giveaway'' is possible and the recursive test +is performed. + +=back + +The level can be changed as follows: + + File::Temp->safe_level( File::Temp::HIGH ); + +The level constants are not exported by the module. + +Currently, you must be running at least perl v5.6.0 in order to +run with MEDIUM or HIGH security. This is simply because the +safety tests use functions from L that are not +available in older versions of perl. The problem is that the version +number for Fcntl is the same in perl 5.6.0 and in 5.005_03 even though +they are different versions. + +On systems that do not support the HIGH or MEDIUM safety levels +(for example Win NT or OS/2) any attempt to change the level will +be ignored. The decision to ignore rather than raise an exception +allows portable programs to be written with high security in mind +for the systems that can support this without those programs failing +on systems where the extra tests are irrelevant. + +If you really need to see whether the change has been accepted +simply examine the return value of C. + + $newlevel = File::Temp->safe_level( File::Temp::HIGH ); + die "Could not change to high security" + if $newlevel != File::Temp::HIGH; + +=cut + +{ + # protect from using the variable itself + my $LEVEL = STANDARD; + sub safe_level { + my $self = shift; + if (@_) { + my $level = shift; + if (($level != STANDARD) && ($level != MEDIUM) && ($level != HIGH)) { + carp "safe_level: Specified level ($level) not STANDARD, MEDIUM or HIGH - ignoring\n" if $^W; + } else { + # Dont allow this on perl 5.005 or earlier + if ($] < 5.006 && $level != STANDARD) { + # Cant do MEDIUM or HIGH checks + croak "Currently requires perl 5.006 or newer to do the safe checks"; + } + # Check that we are allowed to change level + # Silently ignore if we can not. + $LEVEL = $level if _can_do_level($level); + } + } + return $LEVEL; + } +} + +=item TopSystemUID + +This is the highest UID on the current system that refers to a root +UID. This is used to make sure that the temporary directory is +owned by a system UID (C, C, C etc) rather than +simply by root. + +This is required since on many unix systems C is not owned +by root. + +Default is to assume that any UID less than or equal to 10 is a root +UID. + + File::Temp->top_system_uid(10); + my $topid = File::Temp->top_system_uid; + +This value can be adjusted to reduce security checking if required. +The value is only relevant when C is set to MEDIUM or higher. + +=cut + +{ + my $TopSystemUID = 10; + $TopSystemUID = 197108 if $^O eq 'interix'; # "Administrator" + sub top_system_uid { + my $self = shift; + if (@_) { + my $newuid = shift; + croak "top_system_uid: UIDs should be numeric" + unless $newuid =~ /^\d+$/s; + $TopSystemUID = $newuid; + } + return $TopSystemUID; + } +} + +=item B<$KEEP_ALL> + +Controls whether temporary files and directories should be retained +regardless of any instructions in the program to remove them +automatically. This is useful for debugging but should not be used in +production code. + + $File::Temp::KEEP_ALL = 1; + +Default is for files to be removed as requested by the caller. + +In some cases, files will only be retained if this variable is true +when the file is created. This means that you can not create a temporary +file, set this variable and expect the temp file to still be around +when the program exits. + +=item B<$DEBUG> + +Controls whether debugging messages should be enabled. + + $File::Temp::DEBUG = 1; + +Default is for debugging mode to be disabled. + +=back + +=head1 WARNING + +For maximum security, endeavour always to avoid ever looking at, +touching, or even imputing the existence of the filename. You do not +know that that filename is connected to the same file as the handle +you have, and attempts to check this can only trigger more race +conditions. It's far more secure to use the filehandle alone and +dispense with the filename altogether. + +If you need to pass the handle to something that expects a filename +then, on a unix system, use C<"/dev/fd/" . fileno($fh)> for arbitrary +programs, or more generally C<< "+<=&" . fileno($fh) >> for Perl +programs. You will have to clear the close-on-exec bit on that file +descriptor before passing it to another process. + + use Fcntl qw/F_SETFD F_GETFD/; + fcntl($tmpfh, F_SETFD, 0) + or die "Can't clear close-on-exec flag on temp fh: $!\n"; + +=head2 Temporary files and NFS + +Some problems are associated with using temporary files that reside +on NFS file systems and it is recommended that a local filesystem +is used whenever possible. Some of the security tests will most probably +fail when the temp file is not local. Additionally, be aware that +the performance of I/O operations over NFS will not be as good as for +a local disk. + +=head2 Forking + +In some cases files created by File::Temp are removed from within an +END block. Since END blocks are triggered when a child process exits +(unless C is used by the child) File::Temp takes care +to only remove those temp files created by a particular process ID. This +means that a child will not attempt to remove temp files created by the +parent process. + +If you are forking many processes in parallel that are all creating +temporary files, you may need to reset the random number seed using +srand(EXPR) in each child else all the children will attempt to walk +through the same set of random file names and may well cause +themselves to give up if they exceed the number of retry attempts. + +=head2 Directory removal + +Note that if you have chdir'ed into the temporary directory and it is +subsequently cleaned up (either in the END block or as part of object +destruction), then you will get a warning from File::Path::rmtree(). + +=head2 BINMODE + +The file returned by File::Temp will have been opened in binary mode +if such a mode is available. If that is not correct, use the C +function to change the mode of the filehandle. + +Note that you can modify the encoding of a file opened by File::Temp +also by using C. + +=head1 HISTORY + +Originally began life in May 1999 as an XS interface to the system +mkstemp() function. In March 2000, the OpenBSD mkstemp() code was +translated to Perl for total control of the code's +security checking, to ensure the presence of the function regardless of +operating system and to help with portability. The module was shipped +as a standard part of perl from v5.6.1. + +=head1 SEE ALSO + +L, L, L, L + +See L and L, L for +different implementations of temporary file handling. + +See L for an alternative object-oriented wrapper for +the C function. + +=head1 AUTHOR + +Tim Jenness Etjenness@cpan.orgE + +Copyright (C) 2007-2009 Tim Jenness. +Copyright (C) 1999-2007 Tim Jenness and the UK Particle Physics and +Astronomy Research Council. All Rights Reserved. This program is free +software; you can redistribute it and/or modify it under the same +terms as Perl itself. + +Original Perl implementation loosely based on the OpenBSD C code for +mkstemp(). Thanks to Tom Christiansen for suggesting that this module +should be written and providing ideas for code improvements and +security enhancements. + +=cut + +package File::Temp::Dir; + +use File::Path qw/ rmtree /; +use strict; +use overload '""' => "STRINGIFY", fallback => 1; + +# private class specifically to support tempdir objects +# created by File::Temp->newdir + +# ostensibly the same method interface as File::Temp but without +# inheriting all the IO::Seekable methods and other cruft + +# Read-only - returns the name of the temp directory + +sub dirname { + my $self = shift; + return $self->{DIRNAME}; +} + +sub STRINGIFY { + my $self = shift; + return $self->dirname; +} + +sub unlink_on_destroy { + my $self = shift; + if (@_) { + $self->{CLEANUP} = shift; + } + return $self->{CLEANUP}; +} + +sub DESTROY { + my $self = shift; + local($., $@, $!, $^E, $?); + if ($self->unlink_on_destroy && + $$ == $self->{LAUNCHPID} && !$File::Temp::KEEP_ALL) { + if (-d $self->{DIRNAME}) { + # Some versions of rmtree will abort if you attempt to remove + # the directory you are sitting in. We protect that and turn it + # into a warning. We do this because this occurs during object + # destruction and so can not be caught by the user. + eval { rmtree($self->{DIRNAME}, $File::Temp::DEBUG, 0); }; + warn $@ if ($@ && $^W); + } + } +} + + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/FileHandle.pm b/testsuite/input-files/perl-v5.14.2/lib/FileHandle.pm new file mode 100644 index 00000000..6b3636a0 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/FileHandle.pm @@ -0,0 +1,262 @@ +package FileHandle; + +use 5.006; +use strict; +our($VERSION, @ISA, @EXPORT, @EXPORT_OK); + +$VERSION = "2.02"; + +require IO::File; +@ISA = qw(IO::File); + +@EXPORT = qw(_IOFBF _IOLBF _IONBF); + +@EXPORT_OK = qw( + pipe + + autoflush + output_field_separator + output_record_separator + input_record_separator + input_line_number + format_page_number + format_lines_per_page + format_lines_left + format_name + format_top_name + format_line_break_characters + format_formfeed + + print + printf + getline + getlines +); + +# +# Everything we're willing to export, we must first import. +# +import IO::Handle grep { !defined(&$_) } @EXPORT, @EXPORT_OK; + +# +# Some people call "FileHandle::function", so all the functions +# that were in the old FileHandle class must be imported, too. +# +{ + no strict 'refs'; + + my %import = ( + 'IO::Handle' => + [qw(DESTROY new_from_fd fdopen close fileno getc ungetc gets + eof flush error clearerr setbuf setvbuf _open_mode_string)], + 'IO::Seekable' => + [qw(seek tell getpos setpos)], + 'IO::File' => + [qw(new new_tmpfile open)] + ); + for my $pkg (keys %import) { + for my $func (@{$import{$pkg}}) { + my $c = *{"${pkg}::$func"}{CODE} + or die "${pkg}::$func missing"; + *$func = $c; + } + } +} + +# +# Specialized importer for Fcntl magic. +# +sub import { + my $pkg = shift; + my $callpkg = caller; + require Exporter; + Exporter::export($pkg, $callpkg, @_); + + # + # If the Fcntl extension is available, + # export its constants. + # + eval { + require Fcntl; + Exporter::export('Fcntl', $callpkg); + }; +} + +################################################ +# This is the only exported function we define; +# the rest come from other classes. +# + +sub pipe { + my $r = new IO::Handle; + my $w = new IO::Handle; + CORE::pipe($r, $w) or return undef; + ($r, $w); +} + +# Rebless standard file handles +bless *STDIN{IO}, "FileHandle" if ref *STDIN{IO} eq "IO::Handle"; +bless *STDOUT{IO}, "FileHandle" if ref *STDOUT{IO} eq "IO::Handle"; +bless *STDERR{IO}, "FileHandle" if ref *STDERR{IO} eq "IO::Handle"; + +1; + +__END__ + +=head1 NAME + +FileHandle - supply object methods for filehandles + +=head1 SYNOPSIS + + use FileHandle; + + $fh = FileHandle->new; + if ($fh->open("< file")) { + print <$fh>; + $fh->close; + } + + $fh = FileHandle->new("> FOO"); + if (defined $fh) { + print $fh "bar\n"; + $fh->close; + } + + $fh = FileHandle->new("file", "r"); + if (defined $fh) { + print <$fh>; + undef $fh; # automatically closes the file + } + + $fh = FileHandle->new("file", O_WRONLY|O_APPEND); + if (defined $fh) { + print $fh "corge\n"; + undef $fh; # automatically closes the file + } + + $pos = $fh->getpos; + $fh->setpos($pos); + + $fh->setvbuf($buffer_var, _IOLBF, 1024); + + ($readfh, $writefh) = FileHandle::pipe; + + autoflush STDOUT 1; + +=head1 DESCRIPTION + +NOTE: This class is now a front-end to the IO::* classes. + +C creates a C, which is a reference to a +newly created symbol (see the C package). If it receives any +parameters, they are passed to C; if the open fails, +the C object is destroyed. Otherwise, it is returned to +the caller. + +C creates a C like C does. +It requires two parameters, which are passed to C; +if the fdopen fails, the C object is destroyed. +Otherwise, it is returned to the caller. + +C accepts one parameter or two. With one parameter, +it is just a front end for the built-in C function. With two +parameters, the first parameter is a filename that may include +whitespace or other special characters, and the second parameter is +the open mode, optionally followed by a file permission value. + +If C receives a Perl mode string (">", "+<", etc.) +or a POSIX fopen() mode string ("w", "r+", etc.), it uses the basic +Perl C operator. + +If C is given a numeric mode, it passes that mode +and the optional permissions value to the Perl C operator. +For convenience, C tries to import the O_XXX +constants from the Fcntl module. If dynamic loading is not available, +this may fail, but the rest of FileHandle will still work. + +C is like C except that its first parameter +is not a filename but rather a file handle name, a FileHandle object, +or a file descriptor number. + +If the C functions fgetpos() and fsetpos() are available, then +C returns an opaque value that represents the +current position of the FileHandle, and C uses +that value to return to a previously visited position. + +If the C function setvbuf() is available, then C +sets the buffering policy for the FileHandle. The calling sequence +for the Perl function is the same as its C counterpart, including the +macros C<_IOFBF>, C<_IOLBF>, and C<_IONBF>, except that the buffer +parameter specifies a scalar variable to use as a buffer. WARNING: A +variable used as a buffer by C must not be +modified in any way until the FileHandle is closed or until +C is called again, or memory corruption may +result! + +See L for complete descriptions of each of the following +supported C methods, which are just front ends for the +corresponding built-in functions: + + close + fileno + getc + gets + eof + clearerr + seek + tell + +See L for complete descriptions of each of the following +supported C methods: + + autoflush + output_field_separator + output_record_separator + input_record_separator + input_line_number + format_page_number + format_lines_per_page + format_lines_left + format_name + format_top_name + format_line_break_characters + format_formfeed + +Furthermore, for doing normal I/O you might need these: + +=over 4 + +=item $fh->print + +See L. + +=item $fh->printf + +See L. + +=item $fh->getline + +This works like <$fh> described in L +except that it's more readable and can be safely called in a +list context but still returns just one line. + +=item $fh->getlines + +This works like <$fh> when called in a list context to +read all the remaining lines in a file, except that it's more readable. +It will also croak() if accidentally called in a scalar context. + +=back + +There are many other functions available since FileHandle is descended +from IO::File, IO::Seekable, and IO::Handle. Please see those +respective pages for documentation on more functions. + +=head1 SEE ALSO + +The B extension, +L, +L. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/Getopt/Long.pm b/testsuite/input-files/perl-v5.14.2/lib/Getopt/Long.pm new file mode 100644 index 00000000..c827d3c3 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Getopt/Long.pm @@ -0,0 +1,2649 @@ +# Getopt::Long.pm -- Universal options parsing + +package Getopt::Long; + +# RCS Status : $Id: Long.pm,v 2.76 2009/03/30 20:54:30 jv Exp $ +# Author : Johan Vromans +# Created On : Tue Sep 11 15:00:12 1990 +# Last Modified By: Johan Vromans +# Last Modified On: Mon Mar 30 22:51:17 2009 +# Update Count : 1601 +# Status : Released + +################ Module Preamble ################ + +use 5.004; + +use strict; + +use vars qw($VERSION); +$VERSION = 2.38; +# For testing versions only. +#use vars qw($VERSION_STRING); +#$VERSION_STRING = "2.38"; + +use Exporter; +use vars qw(@ISA @EXPORT @EXPORT_OK); +@ISA = qw(Exporter); + +# Exported subroutines. +sub GetOptions(@); # always +sub GetOptionsFromArray(@); # on demand +sub GetOptionsFromString(@); # on demand +sub Configure(@); # on demand +sub HelpMessage(@); # on demand +sub VersionMessage(@); # in demand + +BEGIN { + # Init immediately so their contents can be used in the 'use vars' below. + @EXPORT = qw(&GetOptions $REQUIRE_ORDER $PERMUTE $RETURN_IN_ORDER); + @EXPORT_OK = qw(&HelpMessage &VersionMessage &Configure + &GetOptionsFromArray &GetOptionsFromString); +} + +# User visible variables. +use vars @EXPORT, @EXPORT_OK; +use vars qw($error $debug $major_version $minor_version); +# Deprecated visible variables. +use vars qw($autoabbrev $getopt_compat $ignorecase $bundling $order + $passthrough); +# Official invisible variables. +use vars qw($genprefix $caller $gnu_compat $auto_help $auto_version $longprefix); + +# Public subroutines. +sub config(@); # deprecated name + +# Private subroutines. +sub ConfigDefaults(); +sub ParseOptionSpec($$); +sub OptCtl($); +sub FindOption($$$$$); +sub ValidValue ($$$$$); + +################ Local Variables ################ + +# $requested_version holds the version that was mentioned in the 'use' +# or 'require', if any. It can be used to enable or disable specific +# features. +my $requested_version = 0; + +################ Resident subroutines ################ + +sub ConfigDefaults() { + # Handle POSIX compliancy. + if ( defined $ENV{"POSIXLY_CORRECT"} ) { + $genprefix = "(--|-)"; + $autoabbrev = 0; # no automatic abbrev of options + $bundling = 0; # no bundling of single letter switches + $getopt_compat = 0; # disallow '+' to start options + $order = $REQUIRE_ORDER; + } + else { + $genprefix = "(--|-|\\+)"; + $autoabbrev = 1; # automatic abbrev of options + $bundling = 0; # bundling off by default + $getopt_compat = 1; # allow '+' to start options + $order = $PERMUTE; + } + # Other configurable settings. + $debug = 0; # for debugging + $error = 0; # error tally + $ignorecase = 1; # ignore case when matching options + $passthrough = 0; # leave unrecognized options alone + $gnu_compat = 0; # require --opt=val if value is optional + $longprefix = "(--)"; # what does a long prefix look like +} + +# Override import. +sub import { + my $pkg = shift; # package + my @syms = (); # symbols to import + my @config = (); # configuration + my $dest = \@syms; # symbols first + for ( @_ ) { + if ( $_ eq ':config' ) { + $dest = \@config; # config next + next; + } + push(@$dest, $_); # push + } + # Hide one level and call super. + local $Exporter::ExportLevel = 1; + push(@syms, qw(&GetOptions)) if @syms; # always export GetOptions + $pkg->SUPER::import(@syms); + # And configure. + Configure(@config) if @config; +} + +################ Initialization ################ + +# Values for $order. See GNU getopt.c for details. +($REQUIRE_ORDER, $PERMUTE, $RETURN_IN_ORDER) = (0..2); +# Version major/minor numbers. +($major_version, $minor_version) = $VERSION =~ /^(\d+)\.(\d+)/; + +ConfigDefaults(); + +################ OO Interface ################ + +package Getopt::Long::Parser; + +# Store a copy of the default configuration. Since ConfigDefaults has +# just been called, what we get from Configure is the default. +my $default_config = do { + Getopt::Long::Configure () +}; + +sub new { + my $that = shift; + my $class = ref($that) || $that; + my %atts = @_; + + # Register the callers package. + my $self = { caller_pkg => (caller)[0] }; + + bless ($self, $class); + + # Process config attributes. + if ( defined $atts{config} ) { + my $save = Getopt::Long::Configure ($default_config, @{$atts{config}}); + $self->{settings} = Getopt::Long::Configure ($save); + delete ($atts{config}); + } + # Else use default config. + else { + $self->{settings} = $default_config; + } + + if ( %atts ) { # Oops + die(__PACKAGE__.": unhandled attributes: ". + join(" ", sort(keys(%atts)))."\n"); + } + + $self; +} + +sub configure { + my ($self) = shift; + + # Restore settings, merge new settings in. + my $save = Getopt::Long::Configure ($self->{settings}, @_); + + # Restore orig config and save the new config. + $self->{settings} = Getopt::Long::Configure ($save); +} + +sub getoptions { + my ($self) = shift; + + # Restore config settings. + my $save = Getopt::Long::Configure ($self->{settings}); + + # Call main routine. + my $ret = 0; + $Getopt::Long::caller = $self->{caller_pkg}; + + eval { + # Locally set exception handler to default, otherwise it will + # be called implicitly here, and again explicitly when we try + # to deliver the messages. + local ($SIG{__DIE__}) = 'DEFAULT'; + $ret = Getopt::Long::GetOptions (@_); + }; + + # Restore saved settings. + Getopt::Long::Configure ($save); + + # Handle errors and return value. + die ($@) if $@; + return $ret; +} + +package Getopt::Long; + +################ Back to Normal ################ + +# Indices in option control info. +# Note that ParseOptions uses the fields directly. Search for 'hard-wired'. +use constant CTL_TYPE => 0; +#use constant CTL_TYPE_FLAG => ''; +#use constant CTL_TYPE_NEG => '!'; +#use constant CTL_TYPE_INCR => '+'; +#use constant CTL_TYPE_INT => 'i'; +#use constant CTL_TYPE_INTINC => 'I'; +#use constant CTL_TYPE_XINT => 'o'; +#use constant CTL_TYPE_FLOAT => 'f'; +#use constant CTL_TYPE_STRING => 's'; + +use constant CTL_CNAME => 1; + +use constant CTL_DEFAULT => 2; + +use constant CTL_DEST => 3; + use constant CTL_DEST_SCALAR => 0; + use constant CTL_DEST_ARRAY => 1; + use constant CTL_DEST_HASH => 2; + use constant CTL_DEST_CODE => 3; + +use constant CTL_AMIN => 4; +use constant CTL_AMAX => 5; + +# FFU. +#use constant CTL_RANGE => ; +#use constant CTL_REPEAT => ; + +# Rather liberal patterns to match numbers. +use constant PAT_INT => "[-+]?_*[0-9][0-9_]*"; +use constant PAT_XINT => + "(?:". + "[-+]?_*[1-9][0-9_]*". + "|". + "0x_*[0-9a-f][0-9a-f_]*". + "|". + "0b_*[01][01_]*". + "|". + "0[0-7_]*". + ")"; +use constant PAT_FLOAT => "[-+]?[0-9._]+(\.[0-9_]+)?([eE][-+]?[0-9_]+)?"; + +sub GetOptions(@) { + # Shift in default array. + unshift(@_, \@ARGV); + # Try to keep caller() and Carp consitent. + goto &GetOptionsFromArray; +} + +sub GetOptionsFromString(@) { + my ($string) = shift; + require Text::ParseWords; + my $args = [ Text::ParseWords::shellwords($string) ]; + $caller ||= (caller)[0]; # current context + my $ret = GetOptionsFromArray($args, @_); + return ( $ret, $args ) if wantarray; + if ( @$args ) { + $ret = 0; + warn("GetOptionsFromString: Excess data \"@$args\" in string \"$string\"\n"); + } + $ret; +} + +sub GetOptionsFromArray(@) { + + my ($argv, @optionlist) = @_; # local copy of the option descriptions + my $argend = '--'; # option list terminator + my %opctl = (); # table of option specs + my $pkg = $caller || (caller)[0]; # current context + # Needed if linkage is omitted. + my @ret = (); # accum for non-options + my %linkage; # linkage + my $userlinkage; # user supplied HASH + my $opt; # current option + my $prefix = $genprefix; # current prefix + + $error = ''; + + if ( $debug ) { + # Avoid some warnings if debugging. + local ($^W) = 0; + print STDERR + ("Getopt::Long $Getopt::Long::VERSION (", + '$Revision: 2.76 $', ") ", + "called from package \"$pkg\".", + "\n ", + "argv: (@$argv)", + "\n ", + "autoabbrev=$autoabbrev,". + "bundling=$bundling,", + "getopt_compat=$getopt_compat,", + "gnu_compat=$gnu_compat,", + "order=$order,", + "\n ", + "ignorecase=$ignorecase,", + "requested_version=$requested_version,", + "passthrough=$passthrough,", + "genprefix=\"$genprefix\",", + "longprefix=\"$longprefix\".", + "\n"); + } + + # Check for ref HASH as first argument. + # First argument may be an object. It's OK to use this as long + # as it is really a hash underneath. + $userlinkage = undef; + if ( @optionlist && ref($optionlist[0]) and + UNIVERSAL::isa($optionlist[0],'HASH') ) { + $userlinkage = shift (@optionlist); + print STDERR ("=> user linkage: $userlinkage\n") if $debug; + } + + # See if the first element of the optionlist contains option + # starter characters. + # Be careful not to interpret '<>' as option starters. + if ( @optionlist && $optionlist[0] =~ /^\W+$/ + && !($optionlist[0] eq '<>' + && @optionlist > 0 + && ref($optionlist[1])) ) { + $prefix = shift (@optionlist); + # Turn into regexp. Needs to be parenthesized! + $prefix =~ s/(\W)/\\$1/g; + $prefix = "([" . $prefix . "])"; + print STDERR ("=> prefix=\"$prefix\"\n") if $debug; + } + + # Verify correctness of optionlist. + %opctl = (); + while ( @optionlist ) { + my $opt = shift (@optionlist); + + unless ( defined($opt) ) { + $error .= "Undefined argument in option spec\n"; + next; + } + + # Strip leading prefix so people can specify "--foo=i" if they like. + $opt = $+ if $opt =~ /^$prefix+(.*)$/s; + + if ( $opt eq '<>' ) { + if ( (defined $userlinkage) + && !(@optionlist > 0 && ref($optionlist[0])) + && (exists $userlinkage->{$opt}) + && ref($userlinkage->{$opt}) ) { + unshift (@optionlist, $userlinkage->{$opt}); + } + unless ( @optionlist > 0 + && ref($optionlist[0]) && ref($optionlist[0]) eq 'CODE' ) { + $error .= "Option spec <> requires a reference to a subroutine\n"; + # Kill the linkage (to avoid another error). + shift (@optionlist) + if @optionlist && ref($optionlist[0]); + next; + } + $linkage{'<>'} = shift (@optionlist); + next; + } + + # Parse option spec. + my ($name, $orig) = ParseOptionSpec ($opt, \%opctl); + unless ( defined $name ) { + # Failed. $orig contains the error message. Sorry for the abuse. + $error .= $orig; + # Kill the linkage (to avoid another error). + shift (@optionlist) + if @optionlist && ref($optionlist[0]); + next; + } + + # If no linkage is supplied in the @optionlist, copy it from + # the userlinkage if available. + if ( defined $userlinkage ) { + unless ( @optionlist > 0 && ref($optionlist[0]) ) { + if ( exists $userlinkage->{$orig} && + ref($userlinkage->{$orig}) ) { + print STDERR ("=> found userlinkage for \"$orig\": ", + "$userlinkage->{$orig}\n") + if $debug; + unshift (@optionlist, $userlinkage->{$orig}); + } + else { + # Do nothing. Being undefined will be handled later. + next; + } + } + } + + # Copy the linkage. If omitted, link to global variable. + if ( @optionlist > 0 && ref($optionlist[0]) ) { + print STDERR ("=> link \"$orig\" to $optionlist[0]\n") + if $debug; + my $rl = ref($linkage{$orig} = shift (@optionlist)); + + if ( $rl eq "ARRAY" ) { + $opctl{$name}[CTL_DEST] = CTL_DEST_ARRAY; + } + elsif ( $rl eq "HASH" ) { + $opctl{$name}[CTL_DEST] = CTL_DEST_HASH; + } + elsif ( $rl eq "SCALAR" || $rl eq "REF" ) { +# if ( $opctl{$name}[CTL_DEST] == CTL_DEST_ARRAY ) { +# my $t = $linkage{$orig}; +# $$t = $linkage{$orig} = []; +# } +# elsif ( $opctl{$name}[CTL_DEST] == CTL_DEST_HASH ) { +# } +# else { + # Ok. +# } + } + elsif ( $rl eq "CODE" ) { + # Ok. + } + else { + $error .= "Invalid option linkage for \"$opt\"\n"; + } + } + else { + # Link to global $opt_XXX variable. + # Make sure a valid perl identifier results. + my $ov = $orig; + $ov =~ s/\W/_/g; + if ( $opctl{$name}[CTL_DEST] == CTL_DEST_ARRAY ) { + print STDERR ("=> link \"$orig\" to \@$pkg","::opt_$ov\n") + if $debug; + eval ("\$linkage{\$orig} = \\\@".$pkg."::opt_$ov;"); + } + elsif ( $opctl{$name}[CTL_DEST] == CTL_DEST_HASH ) { + print STDERR ("=> link \"$orig\" to \%$pkg","::opt_$ov\n") + if $debug; + eval ("\$linkage{\$orig} = \\\%".$pkg."::opt_$ov;"); + } + else { + print STDERR ("=> link \"$orig\" to \$$pkg","::opt_$ov\n") + if $debug; + eval ("\$linkage{\$orig} = \\\$".$pkg."::opt_$ov;"); + } + } + + if ( $opctl{$name}[CTL_TYPE] eq 'I' + && ( $opctl{$name}[CTL_DEST] == CTL_DEST_ARRAY + || $opctl{$name}[CTL_DEST] == CTL_DEST_HASH ) + ) { + $error .= "Invalid option linkage for \"$opt\"\n"; + } + + } + + # Bail out if errors found. + die ($error) if $error; + $error = 0; + + # Supply --version and --help support, if needed and allowed. + if ( defined($auto_version) ? $auto_version : ($requested_version >= 2.3203) ) { + if ( !defined($opctl{version}) ) { + $opctl{version} = ['','version',0,CTL_DEST_CODE,undef]; + $linkage{version} = \&VersionMessage; + } + $auto_version = 1; + } + if ( defined($auto_help) ? $auto_help : ($requested_version >= 2.3203) ) { + if ( !defined($opctl{help}) && !defined($opctl{'?'}) ) { + $opctl{help} = $opctl{'?'} = ['','help',0,CTL_DEST_CODE,undef]; + $linkage{help} = \&HelpMessage; + } + $auto_help = 1; + } + + # Show the options tables if debugging. + if ( $debug ) { + my ($arrow, $k, $v); + $arrow = "=> "; + while ( ($k,$v) = each(%opctl) ) { + print STDERR ($arrow, "\$opctl{$k} = $v ", OptCtl($v), "\n"); + $arrow = " "; + } + } + + # Process argument list + my $goon = 1; + while ( $goon && @$argv > 0 ) { + + # Get next argument. + $opt = shift (@$argv); + print STDERR ("=> arg \"", $opt, "\"\n") if $debug; + + # Double dash is option list terminator. + if ( $opt eq $argend ) { + push (@ret, $argend) if $passthrough; + last; + } + + # Look it up. + my $tryopt = $opt; + my $found; # success status + my $key; # key (if hash type) + my $arg; # option argument + my $ctl; # the opctl entry + + ($found, $opt, $ctl, $arg, $key) = + FindOption ($argv, $prefix, $argend, $opt, \%opctl); + + if ( $found ) { + + # FindOption undefines $opt in case of errors. + next unless defined $opt; + + my $argcnt = 0; + while ( defined $arg ) { + + # Get the canonical name. + print STDERR ("=> cname for \"$opt\" is ") if $debug; + $opt = $ctl->[CTL_CNAME]; + print STDERR ("\"$ctl->[CTL_CNAME]\"\n") if $debug; + + if ( defined $linkage{$opt} ) { + print STDERR ("=> ref(\$L{$opt}) -> ", + ref($linkage{$opt}), "\n") if $debug; + + if ( ref($linkage{$opt}) eq 'SCALAR' + || ref($linkage{$opt}) eq 'REF' ) { + if ( $ctl->[CTL_TYPE] eq '+' ) { + print STDERR ("=> \$\$L{$opt} += \"$arg\"\n") + if $debug; + if ( defined ${$linkage{$opt}} ) { + ${$linkage{$opt}} += $arg; + } + else { + ${$linkage{$opt}} = $arg; + } + } + elsif ( $ctl->[CTL_DEST] == CTL_DEST_ARRAY ) { + print STDERR ("=> ref(\$L{$opt}) auto-vivified", + " to ARRAY\n") + if $debug; + my $t = $linkage{$opt}; + $$t = $linkage{$opt} = []; + print STDERR ("=> push(\@{\$L{$opt}, \"$arg\")\n") + if $debug; + push (@{$linkage{$opt}}, $arg); + } + elsif ( $ctl->[CTL_DEST] == CTL_DEST_HASH ) { + print STDERR ("=> ref(\$L{$opt}) auto-vivified", + " to HASH\n") + if $debug; + my $t = $linkage{$opt}; + $$t = $linkage{$opt} = {}; + print STDERR ("=> \$\$L{$opt}->{$key} = \"$arg\"\n") + if $debug; + $linkage{$opt}->{$key} = $arg; + } + else { + print STDERR ("=> \$\$L{$opt} = \"$arg\"\n") + if $debug; + ${$linkage{$opt}} = $arg; + } + } + elsif ( ref($linkage{$opt}) eq 'ARRAY' ) { + print STDERR ("=> push(\@{\$L{$opt}, \"$arg\")\n") + if $debug; + push (@{$linkage{$opt}}, $arg); + } + elsif ( ref($linkage{$opt}) eq 'HASH' ) { + print STDERR ("=> \$\$L{$opt}->{$key} = \"$arg\"\n") + if $debug; + $linkage{$opt}->{$key} = $arg; + } + elsif ( ref($linkage{$opt}) eq 'CODE' ) { + print STDERR ("=> &L{$opt}(\"$opt\"", + $ctl->[CTL_DEST] == CTL_DEST_HASH ? ", \"$key\"" : "", + ", \"$arg\")\n") + if $debug; + my $eval_error = do { + local $@; + local $SIG{__DIE__} = 'DEFAULT'; + eval { + &{$linkage{$opt}} + (Getopt::Long::CallBack->new + (name => $opt, + ctl => $ctl, + opctl => \%opctl, + linkage => \%linkage, + prefix => $prefix, + ), + $ctl->[CTL_DEST] == CTL_DEST_HASH ? ($key) : (), + $arg); + }; + $@; + }; + print STDERR ("=> die($eval_error)\n") + if $debug && $eval_error ne ''; + if ( $eval_error =~ /^!/ ) { + if ( $eval_error =~ /^!FINISH\b/ ) { + $goon = 0; + } + } + elsif ( $eval_error ne '' ) { + warn ($eval_error); + $error++; + } + } + else { + print STDERR ("Invalid REF type \"", ref($linkage{$opt}), + "\" in linkage\n"); + die("Getopt::Long -- internal error!\n"); + } + } + # No entry in linkage means entry in userlinkage. + elsif ( $ctl->[CTL_DEST] == CTL_DEST_ARRAY ) { + if ( defined $userlinkage->{$opt} ) { + print STDERR ("=> push(\@{\$L{$opt}}, \"$arg\")\n") + if $debug; + push (@{$userlinkage->{$opt}}, $arg); + } + else { + print STDERR ("=>\$L{$opt} = [\"$arg\"]\n") + if $debug; + $userlinkage->{$opt} = [$arg]; + } + } + elsif ( $ctl->[CTL_DEST] == CTL_DEST_HASH ) { + if ( defined $userlinkage->{$opt} ) { + print STDERR ("=> \$L{$opt}->{$key} = \"$arg\"\n") + if $debug; + $userlinkage->{$opt}->{$key} = $arg; + } + else { + print STDERR ("=>\$L{$opt} = {$key => \"$arg\"}\n") + if $debug; + $userlinkage->{$opt} = {$key => $arg}; + } + } + else { + if ( $ctl->[CTL_TYPE] eq '+' ) { + print STDERR ("=> \$L{$opt} += \"$arg\"\n") + if $debug; + if ( defined $userlinkage->{$opt} ) { + $userlinkage->{$opt} += $arg; + } + else { + $userlinkage->{$opt} = $arg; + } + } + else { + print STDERR ("=>\$L{$opt} = \"$arg\"\n") if $debug; + $userlinkage->{$opt} = $arg; + } + } + + $argcnt++; + last if $argcnt >= $ctl->[CTL_AMAX] && $ctl->[CTL_AMAX] != -1; + undef($arg); + + # Need more args? + if ( $argcnt < $ctl->[CTL_AMIN] ) { + if ( @$argv ) { + if ( ValidValue($ctl, $argv->[0], 1, $argend, $prefix) ) { + $arg = shift(@$argv); + $arg =~ tr/_//d if $ctl->[CTL_TYPE] =~ /^[iIo]$/; + ($key,$arg) = $arg =~ /^([^=]+)=(.*)/ + if $ctl->[CTL_DEST] == CTL_DEST_HASH; + next; + } + warn("Value \"$$argv[0]\" invalid for option $opt\n"); + $error++; + } + else { + warn("Insufficient arguments for option $opt\n"); + $error++; + } + } + + # Any more args? + if ( @$argv && ValidValue($ctl, $argv->[0], 0, $argend, $prefix) ) { + $arg = shift(@$argv); + $arg =~ tr/_//d if $ctl->[CTL_TYPE] =~ /^[iIo]$/; + ($key,$arg) = $arg =~ /^([^=]+)=(.*)/ + if $ctl->[CTL_DEST] == CTL_DEST_HASH; + next; + } + } + } + + # Not an option. Save it if we $PERMUTE and don't have a <>. + elsif ( $order == $PERMUTE ) { + # Try non-options call-back. + my $cb; + if ( (defined ($cb = $linkage{'<>'})) ) { + print STDERR ("=> &L{$tryopt}(\"$tryopt\")\n") + if $debug; + my $eval_error = do { + local $@; + local $SIG{__DIE__} = 'DEFAULT'; + eval { + &$cb + (Getopt::Long::CallBack->new + (name => $tryopt, + ctl => $ctl, + opctl => \%opctl, + linkage => \%linkage, + prefix => $prefix, + )); + }; + $@; + }; + print STDERR ("=> die($eval_error)\n") + if $debug && $eval_error ne ''; + if ( $eval_error =~ /^!/ ) { + if ( $eval_error =~ /^!FINISH\b/ ) { + $goon = 0; + } + } + elsif ( $eval_error ne '' ) { + warn ($eval_error); + $error++; + } + } + else { + print STDERR ("=> saving \"$tryopt\" ", + "(not an option, may permute)\n") if $debug; + push (@ret, $tryopt); + } + next; + } + + # ...otherwise, terminate. + else { + # Push this one back and exit. + unshift (@$argv, $tryopt); + return ($error == 0); + } + + } + + # Finish. + if ( @ret && $order == $PERMUTE ) { + # Push back accumulated arguments + print STDERR ("=> restoring \"", join('" "', @ret), "\"\n") + if $debug; + unshift (@$argv, @ret); + } + + return ($error == 0); +} + +# A readable representation of what's in an optbl. +sub OptCtl ($) { + my ($v) = @_; + my @v = map { defined($_) ? ($_) : ("") } @$v; + "[". + join(",", + "\"$v[CTL_TYPE]\"", + "\"$v[CTL_CNAME]\"", + "\"$v[CTL_DEFAULT]\"", + ("\$","\@","\%","\&")[$v[CTL_DEST] || 0], + $v[CTL_AMIN] || '', + $v[CTL_AMAX] || '', +# $v[CTL_RANGE] || '', +# $v[CTL_REPEAT] || '', + ). "]"; +} + +# Parse an option specification and fill the tables. +sub ParseOptionSpec ($$) { + my ($opt, $opctl) = @_; + + # Match option spec. + if ( $opt !~ m;^ + ( + # Option name + (?: \w+[-\w]* ) + # Alias names, or "?" + (?: \| (?: \? | \w[-\w]* ) )* + )? + ( + # Either modifiers ... + [!+] + | + # ... or a value/dest/repeat specification + [=:] [ionfs] [@%]? (?: \{\d*,?\d*\} )? + | + # ... or an optional-with-default spec + : (?: -?\d+ | \+ ) [@%]? + )? + $;x ) { + return (undef, "Error in option spec: \"$opt\"\n"); + } + + my ($names, $spec) = ($1, $2); + $spec = '' unless defined $spec; + + # $orig keeps track of the primary name the user specified. + # This name will be used for the internal or external linkage. + # In other words, if the user specifies "FoO|BaR", it will + # match any case combinations of 'foo' and 'bar', but if a global + # variable needs to be set, it will be $opt_FoO in the exact case + # as specified. + my $orig; + + my @names; + if ( defined $names ) { + @names = split (/\|/, $names); + $orig = $names[0]; + } + else { + @names = (''); + $orig = ''; + } + + # Construct the opctl entries. + my $entry; + if ( $spec eq '' || $spec eq '+' || $spec eq '!' ) { + # Fields are hard-wired here. + $entry = [$spec,$orig,undef,CTL_DEST_SCALAR,0,0]; + } + elsif ( $spec =~ /^:(-?\d+|\+)([@%])?$/ ) { + my $def = $1; + my $dest = $2; + my $type = $def eq '+' ? 'I' : 'i'; + $dest ||= '$'; + $dest = $dest eq '@' ? CTL_DEST_ARRAY + : $dest eq '%' ? CTL_DEST_HASH : CTL_DEST_SCALAR; + # Fields are hard-wired here. + $entry = [$type,$orig,$def eq '+' ? undef : $def, + $dest,0,1]; + } + else { + my ($mand, $type, $dest) = + $spec =~ /^([=:])([ionfs])([@%])?(\{(\d+)?(,)?(\d+)?\})?$/; + return (undef, "Cannot repeat while bundling: \"$opt\"\n") + if $bundling && defined($4); + my ($mi, $cm, $ma) = ($5, $6, $7); + return (undef, "{0} is useless in option spec: \"$opt\"\n") + if defined($mi) && !$mi && !defined($ma) && !defined($cm); + + $type = 'i' if $type eq 'n'; + $dest ||= '$'; + $dest = $dest eq '@' ? CTL_DEST_ARRAY + : $dest eq '%' ? CTL_DEST_HASH : CTL_DEST_SCALAR; + # Default minargs to 1/0 depending on mand status. + $mi = $mand eq '=' ? 1 : 0 unless defined $mi; + # Adjust mand status according to minargs. + $mand = $mi ? '=' : ':'; + # Adjust maxargs. + $ma = $mi ? $mi : 1 unless defined $ma || defined $cm; + return (undef, "Max must be greater than zero in option spec: \"$opt\"\n") + if defined($ma) && !$ma; + return (undef, "Max less than min in option spec: \"$opt\"\n") + if defined($ma) && $ma < $mi; + + # Fields are hard-wired here. + $entry = [$type,$orig,undef,$dest,$mi,$ma||-1]; + } + + # Process all names. First is canonical, the rest are aliases. + my $dups = ''; + foreach ( @names ) { + + $_ = lc ($_) + if $ignorecase > (($bundling && length($_) == 1) ? 1 : 0); + + if ( exists $opctl->{$_} ) { + $dups .= "Duplicate specification \"$opt\" for option \"$_\"\n"; + } + + if ( $spec eq '!' ) { + $opctl->{"no$_"} = $entry; + $opctl->{"no-$_"} = $entry; + $opctl->{$_} = [@$entry]; + $opctl->{$_}->[CTL_TYPE] = ''; + } + else { + $opctl->{$_} = $entry; + } + } + + if ( $dups && $^W ) { + foreach ( split(/\n+/, $dups) ) { + warn($_."\n"); + } + } + ($names[0], $orig); +} + +# Option lookup. +sub FindOption ($$$$$) { + + # returns (1, $opt, $ctl, $arg, $key) if okay, + # returns (1, undef) if option in error, + # returns (0) otherwise. + + my ($argv, $prefix, $argend, $opt, $opctl) = @_; + + print STDERR ("=> find \"$opt\"\n") if $debug; + + return (0) unless $opt =~ /^$prefix(.*)$/s; + return (0) if $opt eq "-" && !defined $opctl->{''}; + + $opt = $+; + my $starter = $1; + + print STDERR ("=> split \"$starter\"+\"$opt\"\n") if $debug; + + my $optarg; # value supplied with --opt=value + my $rest; # remainder from unbundling + + # If it is a long option, it may include the value. + # With getopt_compat, only if not bundling. + if ( ($starter=~/^$longprefix$/ + || ($getopt_compat && ($bundling == 0 || $bundling == 2))) + && $opt =~ /^([^=]+)=(.*)$/s ) { + $opt = $1; + $optarg = $2; + print STDERR ("=> option \"", $opt, + "\", optarg = \"$optarg\"\n") if $debug; + } + + #### Look it up ### + + my $tryopt = $opt; # option to try + + if ( $bundling && $starter eq '-' ) { + + # To try overrides, obey case ignore. + $tryopt = $ignorecase ? lc($opt) : $opt; + + # If bundling == 2, long options can override bundles. + if ( $bundling == 2 && length($tryopt) > 1 + && defined ($opctl->{$tryopt}) ) { + print STDERR ("=> $starter$tryopt overrides unbundling\n") + if $debug; + } + else { + $tryopt = $opt; + # Unbundle single letter option. + $rest = length ($tryopt) > 0 ? substr ($tryopt, 1) : ''; + $tryopt = substr ($tryopt, 0, 1); + $tryopt = lc ($tryopt) if $ignorecase > 1; + print STDERR ("=> $starter$tryopt unbundled from ", + "$starter$tryopt$rest\n") if $debug; + $rest = undef unless $rest ne ''; + } + } + + # Try auto-abbreviation. + elsif ( $autoabbrev && $opt ne "" ) { + # Sort the possible long option names. + my @names = sort(keys (%$opctl)); + # Downcase if allowed. + $opt = lc ($opt) if $ignorecase; + $tryopt = $opt; + # Turn option name into pattern. + my $pat = quotemeta ($opt); + # Look up in option names. + my @hits = grep (/^$pat/, @names); + print STDERR ("=> ", scalar(@hits), " hits (@hits) with \"$pat\" ", + "out of ", scalar(@names), "\n") if $debug; + + # Check for ambiguous results. + unless ( (@hits <= 1) || (grep ($_ eq $opt, @hits) == 1) ) { + # See if all matches are for the same option. + my %hit; + foreach ( @hits ) { + my $hit = $_; + $hit = $opctl->{$hit}->[CTL_CNAME] + if defined $opctl->{$hit}->[CTL_CNAME]; + $hit{$hit} = 1; + } + # Remove auto-supplied options (version, help). + if ( keys(%hit) == 2 ) { + if ( $auto_version && exists($hit{version}) ) { + delete $hit{version}; + } + elsif ( $auto_help && exists($hit{help}) ) { + delete $hit{help}; + } + } + # Now see if it really is ambiguous. + unless ( keys(%hit) == 1 ) { + return (0) if $passthrough; + warn ("Option ", $opt, " is ambiguous (", + join(", ", @hits), ")\n"); + $error++; + return (1, undef); + } + @hits = keys(%hit); + } + + # Complete the option name, if appropriate. + if ( @hits == 1 && $hits[0] ne $opt ) { + $tryopt = $hits[0]; + $tryopt = lc ($tryopt) if $ignorecase; + print STDERR ("=> option \"$opt\" -> \"$tryopt\"\n") + if $debug; + } + } + + # Map to all lowercase if ignoring case. + elsif ( $ignorecase ) { + $tryopt = lc ($opt); + } + + # Check validity by fetching the info. + my $ctl = $opctl->{$tryopt}; + unless ( defined $ctl ) { + return (0) if $passthrough; + # Pretend one char when bundling. + if ( $bundling == 1 && length($starter) == 1 ) { + $opt = substr($opt,0,1); + unshift (@$argv, $starter.$rest) if defined $rest; + } + if ( $opt eq "" ) { + warn ("Missing option after ", $starter, "\n"); + } + else { + warn ("Unknown option: ", $opt, "\n"); + } + $error++; + return (1, undef); + } + # Apparently valid. + $opt = $tryopt; + print STDERR ("=> found ", OptCtl($ctl), + " for \"", $opt, "\"\n") if $debug; + + #### Determine argument status #### + + # If it is an option w/o argument, we're almost finished with it. + my $type = $ctl->[CTL_TYPE]; + my $arg; + + if ( $type eq '' || $type eq '!' || $type eq '+' ) { + if ( defined $optarg ) { + return (0) if $passthrough; + warn ("Option ", $opt, " does not take an argument\n"); + $error++; + undef $opt; + } + elsif ( $type eq '' || $type eq '+' ) { + # Supply explicit value. + $arg = 1; + } + else { + $opt =~ s/^no-?//i; # strip NO prefix + $arg = 0; # supply explicit value + } + unshift (@$argv, $starter.$rest) if defined $rest; + return (1, $opt, $ctl, $arg); + } + + # Get mandatory status and type info. + my $mand = $ctl->[CTL_AMIN]; + + # Check if there is an option argument available. + if ( $gnu_compat && defined $optarg && $optarg eq '' ) { + return (1, $opt, $ctl, $type eq 's' ? '' : 0) ;#unless $mand; + $optarg = 0 unless $type eq 's'; + } + + # Check if there is an option argument available. + if ( defined $optarg + ? ($optarg eq '') + : !(defined $rest || @$argv > 0) ) { + # Complain if this option needs an argument. +# if ( $mand && !($type eq 's' ? defined($optarg) : 0) ) { + if ( $mand ) { + return (0) if $passthrough; + warn ("Option ", $opt, " requires an argument\n"); + $error++; + return (1, undef); + } + if ( $type eq 'I' ) { + # Fake incremental type. + my @c = @$ctl; + $c[CTL_TYPE] = '+'; + return (1, $opt, \@c, 1); + } + return (1, $opt, $ctl, + defined($ctl->[CTL_DEFAULT]) ? $ctl->[CTL_DEFAULT] : + $type eq 's' ? '' : 0); + } + + # Get (possibly optional) argument. + $arg = (defined $rest ? $rest + : (defined $optarg ? $optarg : shift (@$argv))); + + # Get key if this is a "name=value" pair for a hash option. + my $key; + if ($ctl->[CTL_DEST] == CTL_DEST_HASH && defined $arg) { + ($key, $arg) = ($arg =~ /^([^=]*)=(.*)$/s) ? ($1, $2) + : ($arg, defined($ctl->[CTL_DEFAULT]) ? $ctl->[CTL_DEFAULT] : + ($mand ? undef : ($type eq 's' ? "" : 1))); + if (! defined $arg) { + warn ("Option $opt, key \"$key\", requires a value\n"); + $error++; + # Push back. + unshift (@$argv, $starter.$rest) if defined $rest; + return (1, undef); + } + } + + #### Check if the argument is valid for this option #### + + my $key_valid = $ctl->[CTL_DEST] == CTL_DEST_HASH ? "[^=]+=" : ""; + + if ( $type eq 's' ) { # string + # A mandatory string takes anything. + return (1, $opt, $ctl, $arg, $key) if $mand; + + # Same for optional string as a hash value + return (1, $opt, $ctl, $arg, $key) + if $ctl->[CTL_DEST] == CTL_DEST_HASH; + + # An optional string takes almost anything. + return (1, $opt, $ctl, $arg, $key) + if defined $optarg || defined $rest; + return (1, $opt, $ctl, $arg, $key) if $arg eq "-"; # ?? + + # Check for option or option list terminator. + if ($arg eq $argend || + $arg =~ /^$prefix.+/) { + # Push back. + unshift (@$argv, $arg); + # Supply empty value. + $arg = ''; + } + } + + elsif ( $type eq 'i' # numeric/integer + || $type eq 'I' # numeric/integer w/ incr default + || $type eq 'o' ) { # dec/oct/hex/bin value + + my $o_valid = $type eq 'o' ? PAT_XINT : PAT_INT; + + if ( $bundling && defined $rest + && $rest =~ /^($key_valid)($o_valid)(.*)$/si ) { + ($key, $arg, $rest) = ($1, $2, $+); + chop($key) if $key; + $arg = ($type eq 'o' && $arg =~ /^0/) ? oct($arg) : 0+$arg; + unshift (@$argv, $starter.$rest) if defined $rest && $rest ne ''; + } + elsif ( $arg =~ /^$o_valid$/si ) { + $arg =~ tr/_//d; + $arg = ($type eq 'o' && $arg =~ /^0/) ? oct($arg) : 0+$arg; + } + else { + if ( defined $optarg || $mand ) { + if ( $passthrough ) { + unshift (@$argv, defined $rest ? $starter.$rest : $arg) + unless defined $optarg; + return (0); + } + warn ("Value \"", $arg, "\" invalid for option ", + $opt, " (", + $type eq 'o' ? "extended " : '', + "number expected)\n"); + $error++; + # Push back. + unshift (@$argv, $starter.$rest) if defined $rest; + return (1, undef); + } + else { + # Push back. + unshift (@$argv, defined $rest ? $starter.$rest : $arg); + if ( $type eq 'I' ) { + # Fake incremental type. + my @c = @$ctl; + $c[CTL_TYPE] = '+'; + return (1, $opt, \@c, 1); + } + # Supply default value. + $arg = defined($ctl->[CTL_DEFAULT]) ? $ctl->[CTL_DEFAULT] : 0; + } + } + } + + elsif ( $type eq 'f' ) { # real number, int is also ok + # We require at least one digit before a point or 'e', + # and at least one digit following the point and 'e'. + # [-]NN[.NN][eNN] + my $o_valid = PAT_FLOAT; + if ( $bundling && defined $rest && + $rest =~ /^($key_valid)($o_valid)(.*)$/s ) { + $arg =~ tr/_//d; + ($key, $arg, $rest) = ($1, $2, $+); + chop($key) if $key; + unshift (@$argv, $starter.$rest) if defined $rest && $rest ne ''; + } + elsif ( $arg =~ /^$o_valid$/ ) { + $arg =~ tr/_//d; + } + else { + if ( defined $optarg || $mand ) { + if ( $passthrough ) { + unshift (@$argv, defined $rest ? $starter.$rest : $arg) + unless defined $optarg; + return (0); + } + warn ("Value \"", $arg, "\" invalid for option ", + $opt, " (real number expected)\n"); + $error++; + # Push back. + unshift (@$argv, $starter.$rest) if defined $rest; + return (1, undef); + } + else { + # Push back. + unshift (@$argv, defined $rest ? $starter.$rest : $arg); + # Supply default value. + $arg = 0.0; + } + } + } + else { + die("Getopt::Long internal error (Can't happen)\n"); + } + return (1, $opt, $ctl, $arg, $key); +} + +sub ValidValue ($$$$$) { + my ($ctl, $arg, $mand, $argend, $prefix) = @_; + + if ( $ctl->[CTL_DEST] == CTL_DEST_HASH ) { + return 0 unless $arg =~ /[^=]+=(.*)/; + $arg = $1; + } + + my $type = $ctl->[CTL_TYPE]; + + if ( $type eq 's' ) { # string + # A mandatory string takes anything. + return (1) if $mand; + + return (1) if $arg eq "-"; + + # Check for option or option list terminator. + return 0 if $arg eq $argend || $arg =~ /^$prefix.+/; + return 1; + } + + elsif ( $type eq 'i' # numeric/integer + || $type eq 'I' # numeric/integer w/ incr default + || $type eq 'o' ) { # dec/oct/hex/bin value + + my $o_valid = $type eq 'o' ? PAT_XINT : PAT_INT; + return $arg =~ /^$o_valid$/si; + } + + elsif ( $type eq 'f' ) { # real number, int is also ok + # We require at least one digit before a point or 'e', + # and at least one digit following the point and 'e'. + # [-]NN[.NN][eNN] + my $o_valid = PAT_FLOAT; + return $arg =~ /^$o_valid$/; + } + die("ValidValue: Cannot happen\n"); +} + +# Getopt::Long Configuration. +sub Configure (@) { + my (@options) = @_; + + my $prevconfig = + [ $error, $debug, $major_version, $minor_version, + $autoabbrev, $getopt_compat, $ignorecase, $bundling, $order, + $gnu_compat, $passthrough, $genprefix, $auto_version, $auto_help, + $longprefix ]; + + if ( ref($options[0]) eq 'ARRAY' ) { + ( $error, $debug, $major_version, $minor_version, + $autoabbrev, $getopt_compat, $ignorecase, $bundling, $order, + $gnu_compat, $passthrough, $genprefix, $auto_version, $auto_help, + $longprefix ) = @{shift(@options)}; + } + + my $opt; + foreach $opt ( @options ) { + my $try = lc ($opt); + my $action = 1; + if ( $try =~ /^no_?(.*)$/s ) { + $action = 0; + $try = $+; + } + if ( ($try eq 'default' or $try eq 'defaults') && $action ) { + ConfigDefaults (); + } + elsif ( ($try eq 'posix_default' or $try eq 'posix_defaults') ) { + local $ENV{POSIXLY_CORRECT}; + $ENV{POSIXLY_CORRECT} = 1 if $action; + ConfigDefaults (); + } + elsif ( $try eq 'auto_abbrev' or $try eq 'autoabbrev' ) { + $autoabbrev = $action; + } + elsif ( $try eq 'getopt_compat' ) { + $getopt_compat = $action; + $genprefix = $action ? "(--|-|\\+)" : "(--|-)"; + } + elsif ( $try eq 'gnu_getopt' ) { + if ( $action ) { + $gnu_compat = 1; + $bundling = 1; + $getopt_compat = 0; + $genprefix = "(--|-)"; + $order = $PERMUTE; + } + } + elsif ( $try eq 'gnu_compat' ) { + $gnu_compat = $action; + } + elsif ( $try =~ /^(auto_?)?version$/ ) { + $auto_version = $action; + } + elsif ( $try =~ /^(auto_?)?help$/ ) { + $auto_help = $action; + } + elsif ( $try eq 'ignorecase' or $try eq 'ignore_case' ) { + $ignorecase = $action; + } + elsif ( $try eq 'ignorecase_always' or $try eq 'ignore_case_always' ) { + $ignorecase = $action ? 2 : 0; + } + elsif ( $try eq 'bundling' ) { + $bundling = $action; + } + elsif ( $try eq 'bundling_override' ) { + $bundling = $action ? 2 : 0; + } + elsif ( $try eq 'require_order' ) { + $order = $action ? $REQUIRE_ORDER : $PERMUTE; + } + elsif ( $try eq 'permute' ) { + $order = $action ? $PERMUTE : $REQUIRE_ORDER; + } + elsif ( $try eq 'pass_through' or $try eq 'passthrough' ) { + $passthrough = $action; + } + elsif ( $try =~ /^prefix=(.+)$/ && $action ) { + $genprefix = $1; + # Turn into regexp. Needs to be parenthesized! + $genprefix = "(" . quotemeta($genprefix) . ")"; + eval { '' =~ /$genprefix/; }; + die("Getopt::Long: invalid pattern \"$genprefix\"") if $@; + } + elsif ( $try =~ /^prefix_pattern=(.+)$/ && $action ) { + $genprefix = $1; + # Parenthesize if needed. + $genprefix = "(" . $genprefix . ")" + unless $genprefix =~ /^\(.*\)$/; + eval { '' =~ m"$genprefix"; }; + die("Getopt::Long: invalid pattern \"$genprefix\"") if $@; + } + elsif ( $try =~ /^long_prefix_pattern=(.+)$/ && $action ) { + $longprefix = $1; + # Parenthesize if needed. + $longprefix = "(" . $longprefix . ")" + unless $longprefix =~ /^\(.*\)$/; + eval { '' =~ m"$longprefix"; }; + die("Getopt::Long: invalid long prefix pattern \"$longprefix\"") if $@; + } + elsif ( $try eq 'debug' ) { + $debug = $action; + } + else { + die("Getopt::Long: unknown config parameter \"$opt\"") + } + } + $prevconfig; +} + +# Deprecated name. +sub config (@) { + Configure (@_); +} + +# Issue a standard message for --version. +# +# The arguments are mostly the same as for Pod::Usage::pod2usage: +# +# - a number (exit value) +# - a string (lead in message) +# - a hash with options. See Pod::Usage for details. +# +sub VersionMessage(@) { + # Massage args. + my $pa = setup_pa_args("version", @_); + + my $v = $main::VERSION; + my $fh = $pa->{-output} || + ($pa->{-exitval} eq "NOEXIT" || $pa->{-exitval} < 2) ? \*STDOUT : \*STDERR; + + print $fh (defined($pa->{-message}) ? $pa->{-message} : (), + $0, defined $v ? " version $v" : (), + "\n", + "(", __PACKAGE__, "::", "GetOptions", + " version ", + defined($Getopt::Long::VERSION_STRING) + ? $Getopt::Long::VERSION_STRING : $VERSION, ";", + " Perl version ", + $] >= 5.006 ? sprintf("%vd", $^V) : $], + ")\n"); + exit($pa->{-exitval}) unless $pa->{-exitval} eq "NOEXIT"; +} + +# Issue a standard message for --help. +# +# The arguments are the same as for Pod::Usage::pod2usage: +# +# - a number (exit value) +# - a string (lead in message) +# - a hash with options. See Pod::Usage for details. +# +sub HelpMessage(@) { + eval { + require Pod::Usage; + import Pod::Usage; + 1; + } || die("Cannot provide help: cannot load Pod::Usage\n"); + + # Note that pod2usage will issue a warning if -exitval => NOEXIT. + pod2usage(setup_pa_args("help", @_)); + +} + +# Helper routine to set up a normalized hash ref to be used as +# argument to pod2usage. +sub setup_pa_args($@) { + my $tag = shift; # who's calling + + # If called by direct binding to an option, it will get the option + # name and value as arguments. Remove these, if so. + @_ = () if @_ == 2 && $_[0] eq $tag; + + my $pa; + if ( @_ > 1 ) { + $pa = { @_ }; + } + else { + $pa = shift || {}; + } + + # At this point, $pa can be a number (exit value), string + # (message) or hash with options. + + if ( UNIVERSAL::isa($pa, 'HASH') ) { + # Get rid of -msg vs. -message ambiguity. + $pa->{-message} = $pa->{-msg}; + delete($pa->{-msg}); + } + elsif ( $pa =~ /^-?\d+$/ ) { + $pa = { -exitval => $pa }; + } + else { + $pa = { -message => $pa }; + } + + # These are _our_ defaults. + $pa->{-verbose} = 0 unless exists($pa->{-verbose}); + $pa->{-exitval} = 0 unless exists($pa->{-exitval}); + $pa; +} + +# Sneak way to know what version the user requested. +sub VERSION { + $requested_version = $_[1]; + shift->SUPER::VERSION(@_); +} + +package Getopt::Long::CallBack; + +sub new { + my ($pkg, %atts) = @_; + bless { %atts }, $pkg; +} + +sub name { + my $self = shift; + ''.$self->{name}; +} + +use overload + # Treat this object as an ordinary string for legacy API. + '""' => \&name, + fallback => 1; + +1; + +################ Documentation ################ + +=head1 NAME + +Getopt::Long - Extended processing of command line options + +=head1 SYNOPSIS + + use Getopt::Long; + my $data = "file.dat"; + my $length = 24; + my $verbose; + $result = GetOptions ("length=i" => \$length, # numeric + "file=s" => \$data, # string + "verbose" => \$verbose); # flag + +=head1 DESCRIPTION + +The Getopt::Long module implements an extended getopt function called +GetOptions(). This function adheres to the POSIX syntax for command +line options, with GNU extensions. In general, this means that options +have long names instead of single letters, and are introduced with a +double dash "--". Support for bundling of command line options, as was +the case with the more traditional single-letter approach, is provided +but not enabled by default. + +=head1 Command Line Options, an Introduction + +Command line operated programs traditionally take their arguments from +the command line, for example filenames or other information that the +program needs to know. Besides arguments, these programs often take +command line I as well. Options are not necessary for the +program to work, hence the name 'option', but are used to modify its +default behaviour. For example, a program could do its job quietly, +but with a suitable option it could provide verbose information about +what it did. + +Command line options come in several flavours. Historically, they are +preceded by a single dash C<->, and consist of a single letter. + + -l -a -c + +Usually, these single-character options can be bundled: + + -lac + +Options can have values, the value is placed after the option +character. Sometimes with whitespace in between, sometimes not: + + -s 24 -s24 + +Due to the very cryptic nature of these options, another style was +developed that used long names. So instead of a cryptic C<-l> one +could use the more descriptive C<--long>. To distinguish between a +bundle of single-character options and a long one, two dashes are used +to precede the option name. Early implementations of long options used +a plus C<+> instead. Also, option values could be specified either +like + + --size=24 + +or + + --size 24 + +The C<+> form is now obsolete and strongly deprecated. + +=head1 Getting Started with Getopt::Long + +Getopt::Long is the Perl5 successor of C. This was the +first Perl module that provided support for handling the new style of +command line options, hence the name Getopt::Long. This module also +supports single-character options and bundling. Single character +options may be any alphabetic character, a question mark, and a dash. +Long options may consist of a series of letters, digits, and dashes. +Although this is currently not enforced by Getopt::Long, multiple +consecutive dashes are not allowed, and the option name must not end +with a dash. + +To use Getopt::Long from a Perl program, you must include the +following line in your Perl program: + + use Getopt::Long; + +This will load the core of the Getopt::Long module and prepare your +program for using it. Most of the actual Getopt::Long code is not +loaded until you really call one of its functions. + +In the default configuration, options names may be abbreviated to +uniqueness, case does not matter, and a single dash is sufficient, +even for long option names. Also, options may be placed between +non-option arguments. See L for more +details on how to configure Getopt::Long. + +=head2 Simple options + +The most simple options are the ones that take no values. Their mere +presence on the command line enables the option. Popular examples are: + + --all --verbose --quiet --debug + +Handling simple options is straightforward: + + my $verbose = ''; # option variable with default value (false) + my $all = ''; # option variable with default value (false) + GetOptions ('verbose' => \$verbose, 'all' => \$all); + +The call to GetOptions() parses the command line arguments that are +present in C<@ARGV> and sets the option variable to the value C<1> if +the option did occur on the command line. Otherwise, the option +variable is not touched. Setting the option value to true is often +called I the option. + +The option name as specified to the GetOptions() function is called +the option I. Later we'll see that this specification +can contain more than just the option name. The reference to the +variable is called the option I. + +GetOptions() will return a true value if the command line could be +processed successfully. Otherwise, it will write error messages to +STDERR, and return a false result. + +=head2 A little bit less simple options + +Getopt::Long supports two useful variants of simple options: +I options and I options. + +A negatable option is specified with an exclamation mark C after the +option name: + + my $verbose = ''; # option variable with default value (false) + GetOptions ('verbose!' => \$verbose); + +Now, using C<--verbose> on the command line will enable C<$verbose>, +as expected. But it is also allowed to use C<--noverbose>, which will +disable C<$verbose> by setting its value to C<0>. Using a suitable +default value, the program can find out whether C<$verbose> is false +by default, or disabled by using C<--noverbose>. + +An incremental option is specified with a plus C<+> after the +option name: + + my $verbose = ''; # option variable with default value (false) + GetOptions ('verbose+' => \$verbose); + +Using C<--verbose> on the command line will increment the value of +C<$verbose>. This way the program can keep track of how many times the +option occurred on the command line. For example, each occurrence of +C<--verbose> could increase the verbosity level of the program. + +=head2 Mixing command line option with other arguments + +Usually programs take command line options as well as other arguments, +for example, file names. It is good practice to always specify the +options first, and the other arguments last. Getopt::Long will, +however, allow the options and arguments to be mixed and 'filter out' +all the options before passing the rest of the arguments to the +program. To stop Getopt::Long from processing further arguments, +insert a double dash C<--> on the command line: + + --size 24 -- --all + +In this example, C<--all> will I be treated as an option, but +passed to the program unharmed, in C<@ARGV>. + +=head2 Options with values + +For options that take values it must be specified whether the option +value is required or not, and what kind of value the option expects. + +Three kinds of values are supported: integer numbers, floating point +numbers, and strings. + +If the option value is required, Getopt::Long will take the +command line argument that follows the option and assign this to the +option variable. If, however, the option value is specified as +optional, this will only be done if that value does not look like a +valid command line option itself. + + my $tag = ''; # option variable with default value + GetOptions ('tag=s' => \$tag); + +In the option specification, the option name is followed by an equals +sign C<=> and the letter C. The equals sign indicates that this +option requires a value. The letter C indicates that this value is +an arbitrary string. Other possible value types are C for integer +values, and C for floating point values. Using a colon C<:> instead +of the equals sign indicates that the option value is optional. In +this case, if no suitable value is supplied, string valued options get +an empty string C<''> assigned, while numeric options are set to C<0>. + +=head2 Options with multiple values + +Options sometimes take several values. For example, a program could +use multiple directories to search for library files: + + --library lib/stdlib --library lib/extlib + +To accomplish this behaviour, simply specify an array reference as the +destination for the option: + + GetOptions ("library=s" => \@libfiles); + +Alternatively, you can specify that the option can have multiple +values by adding a "@", and pass a scalar reference as the +destination: + + GetOptions ("library=s@" => \$libfiles); + +Used with the example above, C<@libfiles> (or C<@$libfiles>) would +contain two strings upon completion: C<"lib/srdlib"> and +C<"lib/extlib">, in that order. It is also possible to specify that +only integer or floating point numbers are acceptable values. + +Often it is useful to allow comma-separated lists of values as well as +multiple occurrences of the options. This is easy using Perl's split() +and join() operators: + + GetOptions ("library=s" => \@libfiles); + @libfiles = split(/,/,join(',',@libfiles)); + +Of course, it is important to choose the right separator string for +each purpose. + +Warning: What follows is an experimental feature. + +Options can take multiple values at once, for example + + --coordinates 52.2 16.4 --rgbcolor 255 255 149 + +This can be accomplished by adding a repeat specifier to the option +specification. Repeat specifiers are very similar to the C<{...}> +repeat specifiers that can be used with regular expression patterns. +For example, the above command line would be handled as follows: + + GetOptions('coordinates=f{2}' => \@coor, 'rgbcolor=i{3}' => \@color); + +The destination for the option must be an array or array reference. + +It is also possible to specify the minimal and maximal number of +arguments an option takes. C indicates an option that +takes at least two and at most 4 arguments. C indicates one +or more values; C indicates zero or more option values. + +=head2 Options with hash values + +If the option destination is a reference to a hash, the option will +take, as value, strings of the form IC<=>I. The value will +be stored with the specified key in the hash. + + GetOptions ("define=s" => \%defines); + +Alternatively you can use: + + GetOptions ("define=s%" => \$defines); + +When used with command line options: + + --define os=linux --define vendor=redhat + +the hash C<%defines> (or C<%$defines>) will contain two keys, C<"os"> +with value C<"linux"> and C<"vendor"> with value C<"redhat">. It is +also possible to specify that only integer or floating point numbers +are acceptable values. The keys are always taken to be strings. + +=head2 User-defined subroutines to handle options + +Ultimate control over what should be done when (actually: each time) +an option is encountered on the command line can be achieved by +designating a reference to a subroutine (or an anonymous subroutine) +as the option destination. When GetOptions() encounters the option, it +will call the subroutine with two or three arguments. The first +argument is the name of the option. (Actually, it is an object that +stringifies to the name of the option.) For a scalar or array destination, +the second argument is the value to be stored. For a hash destination, +the second arguments is the key to the hash, and the third argument +the value to be stored. It is up to the subroutine to store the value, +or do whatever it thinks is appropriate. + +A trivial application of this mechanism is to implement options that +are related to each other. For example: + + my $verbose = ''; # option variable with default value (false) + GetOptions ('verbose' => \$verbose, + 'quiet' => sub { $verbose = 0 }); + +Here C<--verbose> and C<--quiet> control the same variable +C<$verbose>, but with opposite values. + +If the subroutine needs to signal an error, it should call die() with +the desired error message as its argument. GetOptions() will catch the +die(), issue the error message, and record that an error result must +be returned upon completion. + +If the text of the error message starts with an exclamation mark C +it is interpreted specially by GetOptions(). There is currently one +special command implemented: C will cause GetOptions() +to stop processing options, as if it encountered a double dash C<-->. + +In version 2.37 the first argument to the callback function was +changed from string to object. This was done to make room for +extensions and more detailed control. The object stringifies to the +option name so this change should not introduce compatibility +problems. + +=head2 Options with multiple names + +Often it is user friendly to supply alternate mnemonic names for +options. For example C<--height> could be an alternate name for +C<--length>. Alternate names can be included in the option +specification, separated by vertical bar C<|> characters. To implement +the above example: + + GetOptions ('length|height=f' => \$length); + +The first name is called the I name, the other names are +called I. When using a hash to store options, the key will +always be the primary name. + +Multiple alternate names are possible. + +=head2 Case and abbreviations + +Without additional configuration, GetOptions() will ignore the case of +option names, and allow the options to be abbreviated to uniqueness. + + GetOptions ('length|height=f' => \$length, "head" => \$head); + +This call will allow C<--l> and C<--L> for the length option, but +requires a least C<--hea> and C<--hei> for the head and height options. + +=head2 Summary of Option Specifications + +Each option specifier consists of two parts: the name specification +and the argument specification. + +The name specification contains the name of the option, optionally +followed by a list of alternative names separated by vertical bar +characters. + + length option name is "length" + length|size|l name is "length", aliases are "size" and "l" + +The argument specification is optional. If omitted, the option is +considered boolean, a value of 1 will be assigned when the option is +used on the command line. + +The argument specification can be + +=over 4 + +=item ! + +The option does not take an argument and may be negated by prefixing +it with "no" or "no-". E.g. C<"foo!"> will allow C<--foo> (a value of +1 will be assigned) as well as C<--nofoo> and C<--no-foo> (a value of +0 will be assigned). If the option has aliases, this applies to the +aliases as well. + +Using negation on a single letter option when bundling is in effect is +pointless and will result in a warning. + +=item + + +The option does not take an argument and will be incremented by 1 +every time it appears on the command line. E.g. C<"more+">, when used +with C<--more --more --more>, will increment the value three times, +resulting in a value of 3 (provided it was 0 or undefined at first). + +The C<+> specifier is ignored if the option destination is not a scalar. + +=item = I [ I ] [ I ] + +The option requires an argument of the given type. Supported types +are: + +=over 4 + +=item s + +String. An arbitrary sequence of characters. It is valid for the +argument to start with C<-> or C<-->. + +=item i + +Integer. An optional leading plus or minus sign, followed by a +sequence of digits. + +=item o + +Extended integer, Perl style. This can be either an optional leading +plus or minus sign, followed by a sequence of digits, or an octal +string (a zero, optionally followed by '0', '1', .. '7'), or a +hexadecimal string (C<0x> followed by '0' .. '9', 'a' .. 'f', case +insensitive), or a binary string (C<0b> followed by a series of '0' +and '1'). + +=item f + +Real number. For example C<3.14>, C<-6.23E24> and so on. + +=back + +The I can be C<@> or C<%> to specify that the option is +list or a hash valued. This is only needed when the destination for +the option value is not otherwise specified. It should be omitted when +not needed. + +The I specifies the number of values this option takes per +occurrence on the command line. It has the format C<{> [ I ] [ C<,> [ I ] ] C<}>. + +I denotes the minimal number of arguments. It defaults to 1 for +options with C<=> and to 0 for options with C<:>, see below. Note that +I overrules the C<=> / C<:> semantics. + +I denotes the maximum number of arguments. It must be at least +I. If I is omitted, I, there is no +upper bound to the number of argument values taken. + +=item : I [ I ] + +Like C<=>, but designates the argument as optional. +If omitted, an empty string will be assigned to string values options, +and the value zero to numeric options. + +Note that if a string argument starts with C<-> or C<-->, it will be +considered an option on itself. + +=item : I [ I ] + +Like C<:i>, but if the value is omitted, the I will be assigned. + +=item : + [ I ] + +Like C<:i>, but if the value is omitted, the current value for the +option will be incremented. + +=back + +=head1 Advanced Possibilities + +=head2 Object oriented interface + +Getopt::Long can be used in an object oriented way as well: + + use Getopt::Long; + $p = new Getopt::Long::Parser; + $p->configure(...configuration options...); + if ($p->getoptions(...options descriptions...)) ... + +Configuration options can be passed to the constructor: + + $p = new Getopt::Long::Parser + config => [...configuration options...]; + +=head2 Thread Safety + +Getopt::Long is thread safe when using ithreads as of Perl 5.8. It is +I thread safe when using the older (experimental and now +obsolete) threads implementation that was added to Perl 5.005. + +=head2 Documentation and help texts + +Getopt::Long encourages the use of Pod::Usage to produce help +messages. For example: + + use Getopt::Long; + use Pod::Usage; + + my $man = 0; + my $help = 0; + + GetOptions('help|?' => \$help, man => \$man) or pod2usage(2); + pod2usage(1) if $help; + pod2usage(-exitstatus => 0, -verbose => 2) if $man; + + __END__ + + =head1 NAME + + sample - Using Getopt::Long and Pod::Usage + + =head1 SYNOPSIS + + sample [options] [file ...] + + Options: + -help brief help message + -man full documentation + + =head1 OPTIONS + + =over 8 + + =item B<-help> + + Print a brief help message and exits. + + =item B<-man> + + Prints the manual page and exits. + + =back + + =head1 DESCRIPTION + + B will read the given input file(s) and do something + useful with the contents thereof. + + =cut + +See L for details. + +=head2 Parsing options from an arbitrary array + +By default, GetOptions parses the options that are present in the +global array C<@ARGV>. A special entry C can be +used to parse options from an arbitrary array. + + use Getopt::Long qw(GetOptionsFromArray); + $ret = GetOptionsFromArray(\@myopts, ...); + +When used like this, the global C<@ARGV> is not touched at all. + +The following two calls behave identically: + + $ret = GetOptions( ... ); + $ret = GetOptionsFromArray(\@ARGV, ... ); + +=head2 Parsing options from an arbitrary string + +A special entry C can be used to parse options +from an arbitrary string. + + use Getopt::Long qw(GetOptionsFromString); + $ret = GetOptionsFromString($string, ...); + +The contents of the string are split into arguments using a call to +C. As with C, the +global C<@ARGV> is not touched. + +It is possible that, upon completion, not all arguments in the string +have been processed. C will, when called in list +context, return both the return status and an array reference to any +remaining arguments: + + ($ret, $args) = GetOptionsFromString($string, ... ); + +If any arguments remain, and C was not called in +list context, a message will be given and C will +return failure. + +=head2 Storing options values in a hash + +Sometimes, for example when there are a lot of options, having a +separate variable for each of them can be cumbersome. GetOptions() +supports, as an alternative mechanism, storing options values in a +hash. + +To obtain this, a reference to a hash must be passed I to GetOptions(). For each option that is specified on the +command line, the option value will be stored in the hash with the +option name as key. Options that are not actually used on the command +line will not be put in the hash, on other words, +C (or defined()) can be used to test if an option +was used. The drawback is that warnings will be issued if the program +runs under C and uses C<$h{option}> without testing with +exists() or defined() first. + + my %h = (); + GetOptions (\%h, 'length=i'); # will store in $h{length} + +For options that take list or hash values, it is necessary to indicate +this by appending an C<@> or C<%> sign after the type: + + GetOptions (\%h, 'colours=s@'); # will push to @{$h{colours}} + +To make things more complicated, the hash may contain references to +the actual destinations, for example: + + my $len = 0; + my %h = ('length' => \$len); + GetOptions (\%h, 'length=i'); # will store in $len + +This example is fully equivalent with: + + my $len = 0; + GetOptions ('length=i' => \$len); # will store in $len + +Any mixture is possible. For example, the most frequently used options +could be stored in variables while all other options get stored in the +hash: + + my $verbose = 0; # frequently referred + my $debug = 0; # frequently referred + my %h = ('verbose' => \$verbose, 'debug' => \$debug); + GetOptions (\%h, 'verbose', 'debug', 'filter', 'size=i'); + if ( $verbose ) { ... } + if ( exists $h{filter} ) { ... option 'filter' was specified ... } + +=head2 Bundling + +With bundling it is possible to set several single-character options +at once. For example if C, C and C are all valid options, + + -vax + +would set all three. + +Getopt::Long supports two levels of bundling. To enable bundling, a +call to Getopt::Long::Configure is required. + +The first level of bundling can be enabled with: + + Getopt::Long::Configure ("bundling"); + +Configured this way, single-character options can be bundled but long +options B always start with a double dash C<--> to avoid +ambiguity. For example, when C, C, C and C are all valid +options, + + -vax + +would set C, C and C, but + + --vax + +would set C. + +The second level of bundling lifts this restriction. It can be enabled +with: + + Getopt::Long::Configure ("bundling_override"); + +Now, C<-vax> would set the option C. + +When any level of bundling is enabled, option values may be inserted +in the bundle. For example: + + -h24w80 + +is equivalent to + + -h 24 -w 80 + +When configured for bundling, single-character options are matched +case sensitive while long options are matched case insensitive. To +have the single-character options matched case insensitive as well, +use: + + Getopt::Long::Configure ("bundling", "ignorecase_always"); + +It goes without saying that bundling can be quite confusing. + +=head2 The lonesome dash + +Normally, a lone dash C<-> on the command line will not be considered +an option. Option processing will terminate (unless "permute" is +configured) and the dash will be left in C<@ARGV>. + +It is possible to get special treatment for a lone dash. This can be +achieved by adding an option specification with an empty name, for +example: + + GetOptions ('' => \$stdio); + +A lone dash on the command line will now be a legal option, and using +it will set variable C<$stdio>. + +=head2 Argument callback + +A special option 'name' C<< <> >> can be used to designate a subroutine +to handle non-option arguments. When GetOptions() encounters an +argument that does not look like an option, it will immediately call this +subroutine and passes it one parameter: the argument name. Well, actually +it is an object that stringifies to the argument name. + +For example: + + my $width = 80; + sub process { ... } + GetOptions ('width=i' => \$width, '<>' => \&process); + +When applied to the following command line: + + arg1 --width=72 arg2 --width=60 arg3 + +This will call +C while C<$width> is C<80>, +C while C<$width> is C<72>, and +C while C<$width> is C<60>. + +This feature requires configuration option B, see section +L. + +=head1 Configuring Getopt::Long + +Getopt::Long can be configured by calling subroutine +Getopt::Long::Configure(). This subroutine takes a list of quoted +strings, each specifying a configuration option to be enabled, e.g. +C, or disabled, e.g. C. Case does not +matter. Multiple calls to Configure() are possible. + +Alternatively, as of version 2.24, the configuration options may be +passed together with the C statement: + + use Getopt::Long qw(:config no_ignore_case bundling); + +The following options are available: + +=over 12 + +=item default + +This option causes all configuration options to be reset to their +default values. + +=item posix_default + +This option causes all configuration options to be reset to their +default values as if the environment variable POSIXLY_CORRECT had +been set. + +=item auto_abbrev + +Allow option names to be abbreviated to uniqueness. +Default is enabled unless environment variable +POSIXLY_CORRECT has been set, in which case C is disabled. + +=item getopt_compat + +Allow C<+> to start options. +Default is enabled unless environment variable +POSIXLY_CORRECT has been set, in which case C is disabled. + +=item gnu_compat + +C controls whether C<--opt=> is allowed, and what it should +do. Without C, C<--opt=> gives an error. With C, +C<--opt=> will give option C and empty value. +This is the way GNU getopt_long() does it. + +=item gnu_getopt + +This is a short way of setting C C C +C. With C, command line handling should be +fully compatible with GNU getopt_long(). + +=item require_order + +Whether command line arguments are allowed to be mixed with options. +Default is disabled unless environment variable +POSIXLY_CORRECT has been set, in which case C is enabled. + +See also C, which is the opposite of C. + +=item permute + +Whether command line arguments are allowed to be mixed with options. +Default is enabled unless environment variable +POSIXLY_CORRECT has been set, in which case C is disabled. +Note that C is the opposite of C. + +If C is enabled, this means that + + --foo arg1 --bar arg2 arg3 + +is equivalent to + + --foo --bar arg1 arg2 arg3 + +If an argument callback routine is specified, C<@ARGV> will always be +empty upon successful return of GetOptions() since all options have been +processed. The only exception is when C<--> is used: + + --foo arg1 --bar arg2 -- arg3 + +This will call the callback routine for arg1 and arg2, and then +terminate GetOptions() leaving C<"arg3"> in C<@ARGV>. + +If C is enabled, options processing +terminates when the first non-option is encountered. + + --foo arg1 --bar arg2 arg3 + +is equivalent to + + --foo -- arg1 --bar arg2 arg3 + +If C is also enabled, options processing will terminate +at the first unrecognized option, or non-option, whichever comes +first. + +=item bundling (default: disabled) + +Enabling this option will allow single-character options to be +bundled. To distinguish bundles from long option names, long options +I be introduced with C<--> and bundles with C<->. + +Note that, if you have options C, C and C, and +auto_abbrev enabled, possible arguments and option settings are: + + using argument sets option(s) + ------------------------------------------ + -a, --a a + -l, --l l + -al, -la, -ala, -all,... a, l + --al, --all all + +The surprising part is that C<--a> sets option C (due to auto +completion), not C. + +Note: disabling C also disables C. + +=item bundling_override (default: disabled) + +If C is enabled, bundling is enabled as with +C but now long option names override option bundles. + +Note: disabling C also disables C. + +B Using option bundling can easily lead to unexpected results, +especially when mixing long options and bundles. Caveat emptor. + +=item ignore_case (default: enabled) + +If enabled, case is ignored when matching long option names. If, +however, bundling is enabled as well, single character options will be +treated case-sensitive. + +With C, option specifications for options that only +differ in case, e.g., C<"foo"> and C<"Foo">, will be flagged as +duplicates. + +Note: disabling C also disables C. + +=item ignore_case_always (default: disabled) + +When bundling is in effect, case is ignored on single-character +options also. + +Note: disabling C also disables C. + +=item auto_version (default:disabled) + +Automatically provide support for the B<--version> option if +the application did not specify a handler for this option itself. + +Getopt::Long will provide a standard version message that includes the +program name, its version (if $main::VERSION is defined), and the +versions of Getopt::Long and Perl. The message will be written to +standard output and processing will terminate. + +C will be enabled if the calling program explicitly +specified a version number higher than 2.32 in the C or +C statement. + +=item auto_help (default:disabled) + +Automatically provide support for the B<--help> and B<-?> options if +the application did not specify a handler for this option itself. + +Getopt::Long will provide a help message using module L. The +message, derived from the SYNOPSIS POD section, will be written to +standard output and processing will terminate. + +C will be enabled if the calling program explicitly +specified a version number higher than 2.32 in the C or +C statement. + +=item pass_through (default: disabled) + +Options that are unknown, ambiguous or supplied with an invalid option +value are passed through in C<@ARGV> instead of being flagged as +errors. This makes it possible to write wrapper scripts that process +only part of the user supplied command line arguments, and pass the +remaining options to some other program. + +If C is enabled, options processing will terminate at +the first unrecognized option, or non-option, whichever comes first. +However, if C is enabled instead, results can become confusing. + +Note that the options terminator (default C<-->), if present, will +also be passed through in C<@ARGV>. + +=item prefix + +The string that starts options. If a constant string is not +sufficient, see C. + +=item prefix_pattern + +A Perl pattern that identifies the strings that introduce options. +Default is C<--|-|\+> unless environment variable +POSIXLY_CORRECT has been set, in which case it is C<--|->. + +=item long_prefix_pattern + +A Perl pattern that allows the disambiguation of long and short +prefixes. Default is C<-->. + +Typically you only need to set this if you are using nonstandard +prefixes and want some or all of them to have the same semantics as +'--' does under normal circumstances. + +For example, setting prefix_pattern to C<--|-|\+|\/> and +long_prefix_pattern to C<--|\/> would add Win32 style argument +handling. + +=item debug (default: disabled) + +Enable debugging output. + +=back + +=head1 Exportable Methods + +=over + +=item VersionMessage + +This subroutine provides a standard version message. Its argument can be: + +=over 4 + +=item * + +A string containing the text of a message to print I printing +the standard message. + +=item * + +A numeric value corresponding to the desired exit status. + +=item * + +A reference to a hash. + +=back + +If more than one argument is given then the entire argument list is +assumed to be a hash. If a hash is supplied (either as a reference or +as a list) it should contain one or more elements with the following +keys: + +=over 4 + +=item C<-message> + +=item C<-msg> + +The text of a message to print immediately prior to printing the +program's usage message. + +=item C<-exitval> + +The desired exit status to pass to the B function. +This should be an integer, or else the string "NOEXIT" to +indicate that control should simply be returned without +terminating the invoking process. + +=item C<-output> + +A reference to a filehandle, or the pathname of a file to which the +usage message should be written. The default is C<\*STDERR> unless the +exit value is less than 2 (in which case the default is C<\*STDOUT>). + +=back + +You cannot tie this routine directly to an option, e.g.: + + GetOptions("version" => \&VersionMessage); + +Use this instead: + + GetOptions("version" => sub { VersionMessage() }); + +=item HelpMessage + +This subroutine produces a standard help message, derived from the +program's POD section SYNOPSIS using L. It takes the same +arguments as VersionMessage(). In particular, you cannot tie it +directly to an option, e.g.: + + GetOptions("help" => \&HelpMessage); + +Use this instead: + + GetOptions("help" => sub { HelpMessage() }); + +=back + +=head1 Return values and Errors + +Configuration errors and errors in the option definitions are +signalled using die() and will terminate the calling program unless +the call to Getopt::Long::GetOptions() was embedded in C, or die() was trapped using C<$SIG{__DIE__}>. + +GetOptions returns true to indicate success. +It returns false when the function detected one or more errors during +option parsing. These errors are signalled using warn() and can be +trapped with C<$SIG{__WARN__}>. + +=head1 Legacy + +The earliest development of C started in 1990, with Perl +version 4. As a result, its development, and the development of +Getopt::Long, has gone through several stages. Since backward +compatibility has always been extremely important, the current version +of Getopt::Long still supports a lot of constructs that nowadays are +no longer necessary or otherwise unwanted. This section describes +briefly some of these 'features'. + +=head2 Default destinations + +When no destination is specified for an option, GetOptions will store +the resultant value in a global variable named CI, where +I is the primary name of this option. When a progam executes +under C (recommended), these variables must be +pre-declared with our() or C. + + our $opt_length = 0; + GetOptions ('length=i'); # will store in $opt_length + +To yield a usable Perl variable, characters that are not part of the +syntax for variables are translated to underscores. For example, +C<--fpp-struct-return> will set the variable +C<$opt_fpp_struct_return>. Note that this variable resides in the +namespace of the calling program, not necessarily C
. For +example: + + GetOptions ("size=i", "sizes=i@"); + +with command line "-size 10 -sizes 24 -sizes 48" will perform the +equivalent of the assignments + + $opt_size = 10; + @opt_sizes = (24, 48); + +=head2 Alternative option starters + +A string of alternative option starter characters may be passed as the +first argument (or the first argument after a leading hash reference +argument). + + my $len = 0; + GetOptions ('/', 'length=i' => $len); + +Now the command line may look like: + + /length 24 -- arg + +Note that to terminate options processing still requires a double dash +C<-->. + +GetOptions() will not interpret a leading C<< "<>" >> as option starters +if the next argument is a reference. To force C<< "<" >> and C<< ">" >> as +option starters, use C<< "><" >>. Confusing? Well, B anyway. + +=head2 Configuration variables + +Previous versions of Getopt::Long used variables for the purpose of +configuring. Although manipulating these variables still work, it is +strongly encouraged to use the C routine that was introduced +in version 2.17. Besides, it is much easier. + +=head1 Tips and Techniques + +=head2 Pushing multiple values in a hash option + +Sometimes you want to combine the best of hashes and arrays. For +example, the command line: + + --list add=first --list add=second --list add=third + +where each successive 'list add' option will push the value of add +into array ref $list->{'add'}. The result would be like + + $list->{add} = [qw(first second third)]; + +This can be accomplished with a destination routine: + + GetOptions('list=s%' => + sub { push(@{$list{$_[1]}}, $_[2]) }); + +=head1 Troubleshooting + +=head2 GetOptions does not return a false result when an option is not supplied + +That's why they're called 'options'. + +=head2 GetOptions does not split the command line correctly + +The command line is not split by GetOptions, but by the command line +interpreter (CLI). On Unix, this is the shell. On Windows, it is +COMMAND.COM or CMD.EXE. Other operating systems have other CLIs. + +It is important to know that these CLIs may behave different when the +command line contains special characters, in particular quotes or +backslashes. For example, with Unix shells you can use single quotes +(C<'>) and double quotes (C<">) to group words together. The following +alternatives are equivalent on Unix: + + "two words" + 'two words' + two\ words + +In case of doubt, insert the following statement in front of your Perl +program: + + print STDERR (join("|",@ARGV),"\n"); + +to verify how your CLI passes the arguments to the program. + +=head2 Undefined subroutine &main::GetOptions called + +Are you running Windows, and did you write + + use GetOpt::Long; + +(note the capital 'O')? + +=head2 How do I put a "-?" option into a Getopt::Long? + +You can only obtain this using an alias, and Getopt::Long of at least +version 2.13. + + use Getopt::Long; + GetOptions ("help|?"); # -help and -? will both set $opt_help + +=head1 AUTHOR + +Johan Vromans + +=head1 COPYRIGHT AND DISCLAIMER + +This program is Copyright 1990,2009 by Johan Vromans. +This program is free software; you can redistribute it and/or +modify it under the terms of the Perl Artistic License or the +GNU General Public License as published by the Free Software +Foundation; either version 2 of the License, 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. + +If you do not have a copy of the GNU General Public License write to +the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, +MA 02139, USA. + +=cut + diff --git a/testsuite/input-files/perl-v5.14.2/lib/IO.pm b/testsuite/input-files/perl-v5.14.2/lib/IO.pm new file mode 100644 index 00000000..d6ccbfb1 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/IO.pm @@ -0,0 +1,68 @@ +# + +package IO; + +use XSLoader (); +use Carp; +use strict; +use warnings; + +our $VERSION = "1.25_04"; +XSLoader::load 'IO', $VERSION; + +sub import { + shift; + + warnings::warnif('deprecated', qq{Parameterless "use IO" deprecated}) + if @_ == 0 ; + + my @l = @_ ? @_ : qw(Handle Seekable File Pipe Socket Dir); + + eval join("", map { "require IO::" . (/(\w+)/)[0] . ";\n" } @l) + or croak $@; +} + +1; + +__END__ + +=head1 NAME + +IO - load various IO modules + +=head1 SYNOPSIS + + use IO qw(Handle File); # loads IO modules, here IO::Handle, IO::File + use IO; # DEPRECATED + +=head1 DESCRIPTION + +C provides a simple mechanism to load several of the IO modules +in one go. The IO modules belonging to the core are: + + IO::Handle + IO::Seekable + IO::File + IO::Pipe + IO::Socket + IO::Dir + IO::Select + IO::Poll + +Some other IO modules don't belong to the perl core but can be loaded +as well if they have been installed from CPAN. You can discover which +ones exist by searching for "^IO::" on http://search.cpan.org. + +For more information on any of these modules, please see its respective +documentation. + +=head1 DEPRECATED + + use IO; # loads all the modules listed below + +The loaded modules are IO::Handle, IO::Seekable, IO::File, IO::Pipe, +IO::Socket, IO::Dir. You should instead explicitly import the IO +modules you want. + +=cut + diff --git a/testsuite/input-files/perl-v5.14.2/lib/IO/File.pm b/testsuite/input-files/perl-v5.14.2/lib/IO/File.pm new file mode 100644 index 00000000..1162c812 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/IO/File.pm @@ -0,0 +1,204 @@ +# + +package IO::File; + +=head1 NAME + +IO::File - supply object methods for filehandles + +=head1 SYNOPSIS + + use IO::File; + + $fh = IO::File->new(); + if ($fh->open("< file")) { + print <$fh>; + $fh->close; + } + + $fh = IO::File->new("> file"); + if (defined $fh) { + print $fh "bar\n"; + $fh->close; + } + + $fh = IO::File->new("file", "r"); + if (defined $fh) { + print <$fh>; + undef $fh; # automatically closes the file + } + + $fh = IO::File->new("file", O_WRONLY|O_APPEND); + if (defined $fh) { + print $fh "corge\n"; + + $pos = $fh->getpos; + $fh->setpos($pos); + + undef $fh; # automatically closes the file + } + + autoflush STDOUT 1; + +=head1 DESCRIPTION + +C inherits from C and C. It extends +these classes with methods that are specific to file handles. + +=head1 CONSTRUCTOR + +=over 4 + +=item new ( FILENAME [,MODE [,PERMS]] ) + +Creates an C. If it receives any parameters, they are passed to +the method C; if the open fails, the object is destroyed. Otherwise, +it is returned to the caller. + +=item new_tmpfile + +Creates an C opened for read/write on a newly created temporary +file. On systems where this is possible, the temporary file is anonymous +(i.e. it is unlinked after creation, but held open). If the temporary +file cannot be created or opened, the C object is destroyed. +Otherwise, it is returned to the caller. + +=back + +=head1 METHODS + +=over 4 + +=item open( FILENAME [,MODE [,PERMS]] ) + +=item open( FILENAME, IOLAYERS ) + +C accepts one, two or three parameters. With one parameter, +it is just a front end for the built-in C function. With two or three +parameters, the first parameter is a filename that may include +whitespace or other special characters, and the second parameter is +the open mode, optionally followed by a file permission value. + +If C receives a Perl mode string ("E", "+E", etc.) +or an ANSI C fopen() mode string ("w", "r+", etc.), it uses the basic +Perl C operator (but protects any special characters). + +If C is given a numeric mode, it passes that mode +and the optional permissions value to the Perl C operator. +The permissions default to 0666. + +If C is given a mode that includes the C<:> character, +it passes all the three arguments to the three-argument C operator. + +For convenience, C exports the O_XXX constants from the +Fcntl module, if this module is available. + +=item binmode( [LAYER] ) + +C sets C on the underlying C object, as documented +in C. + +C accepts one optional parameter, which is the layer to be +passed on to the C call. + +=back + +=head1 NOTE + +Some operating systems may perform C or C +on a directory without errors. This behavior is not portable and not +suggested for use. Using C and C or C are +suggested instead. + +=head1 SEE ALSO + +L, +L, +L, +L, +L + +=head1 HISTORY + +Derived from FileHandle.pm by Graham Barr EFE. + +=cut + +use 5.006_001; +use strict; +our($VERSION, @EXPORT, @EXPORT_OK, @ISA); +use Carp; +use Symbol; +use SelectSaver; +use IO::Seekable; +use File::Spec; + +require Exporter; + +@ISA = qw(IO::Handle IO::Seekable Exporter); + +$VERSION = "1.15"; + +@EXPORT = @IO::Seekable::EXPORT; + +eval { + # Make all Fcntl O_XXX constants available for importing + require Fcntl; + my @O = grep /^O_/, @Fcntl::EXPORT; + Fcntl->import(@O); # first we import what we want to export + push(@EXPORT, @O); +}; + +################################################ +## Constructor +## + +sub new { + my $type = shift; + my $class = ref($type) || $type || "IO::File"; + @_ >= 0 && @_ <= 3 + or croak "usage: $class->new([FILENAME [,MODE [,PERMS]]])"; + my $fh = $class->SUPER::new(); + if (@_) { + $fh->open(@_) + or return undef; + } + $fh; +} + +################################################ +## Open +## + +sub open { + @_ >= 2 && @_ <= 4 or croak 'usage: $fh->open(FILENAME [,MODE [,PERMS]])'; + my ($fh, $file) = @_; + if (@_ > 2) { + my ($mode, $perms) = @_[2, 3]; + if ($mode =~ /^\d+$/) { + defined $perms or $perms = 0666; + return sysopen($fh, $file, $mode, $perms); + } elsif ($mode =~ /:/) { + return open($fh, $mode, $file) if @_ == 3; + croak 'usage: $fh->open(FILENAME, IOLAYERS)'; + } else { + return open($fh, IO::Handle::_open_mode_string($mode), $file); + } + } + open($fh, $file); +} + +################################################ +## Binmode +## + +sub binmode { + ( @_ == 1 or @_ == 2 ) or croak 'usage $fh->binmode([LAYER])'; + + my($fh, $layer) = @_; + + return binmode $$fh unless $layer; + return binmode $$fh, $layer; +} + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/IO/Handle.pm b/testsuite/input-files/perl-v5.14.2/lib/IO/Handle.pm new file mode 100644 index 00000000..6ca3c8a3 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/IO/Handle.pm @@ -0,0 +1,646 @@ +package IO::Handle; + +=head1 NAME + +IO::Handle - supply object methods for I/O handles + +=head1 SYNOPSIS + + use IO::Handle; + + $io = IO::Handle->new(); + if ($io->fdopen(fileno(STDIN),"r")) { + print $io->getline; + $io->close; + } + + $io = IO::Handle->new(); + if ($io->fdopen(fileno(STDOUT),"w")) { + $io->print("Some text\n"); + } + + # setvbuf is not available by default on Perls 5.8.0 and later. + use IO::Handle '_IOLBF'; + $io->setvbuf($buffer_var, _IOLBF, 1024); + + undef $io; # automatically closes the file if it's open + + autoflush STDOUT 1; + +=head1 DESCRIPTION + +C is the base class for all other IO handle classes. It is +not intended that objects of C would be created directly, +but instead C is inherited from by several other classes +in the IO hierarchy. + +If you are reading this documentation, looking for a replacement for +the C package, then I suggest you read the documentation +for C too. + +=head1 CONSTRUCTOR + +=over 4 + +=item new () + +Creates a new C object. + +=item new_from_fd ( FD, MODE ) + +Creates an C like C does. +It requires two parameters, which are passed to the method C; +if the fdopen fails, the object is destroyed. Otherwise, it is returned +to the caller. + +=back + +=head1 METHODS + +See L for complete descriptions of each of the following +supported C methods, which are just front ends for the +corresponding built-in functions: + + $io->close + $io->eof + $io->fcntl( FUNCTION, SCALAR ) + $io->fileno + $io->format_write( [FORMAT_NAME] ) + $io->getc + $io->ioctl( FUNCTION, SCALAR ) + $io->read ( BUF, LEN, [OFFSET] ) + $io->print ( ARGS ) + $io->printf ( FMT, [ARGS] ) + $io->say ( ARGS ) + $io->stat + $io->sysread ( BUF, LEN, [OFFSET] ) + $io->syswrite ( BUF, [LEN, [OFFSET]] ) + $io->truncate ( LEN ) + +See L for complete descriptions of each of the following +supported C methods. All of them return the previous +value of the attribute and takes an optional single argument that when +given will set the value. If no argument is given the previous value +is unchanged (except for $io->autoflush will actually turn ON +autoflush by default). + + $io->autoflush ( [BOOL] ) $| + $io->format_page_number( [NUM] ) $% + $io->format_lines_per_page( [NUM] ) $= + $io->format_lines_left( [NUM] ) $- + $io->format_name( [STR] ) $~ + $io->format_top_name( [STR] ) $^ + $io->input_line_number( [NUM]) $. + +The following methods are not supported on a per-filehandle basis. + + IO::Handle->format_line_break_characters( [STR] ) $: + IO::Handle->format_formfeed( [STR]) $^L + IO::Handle->output_field_separator( [STR] ) $, + IO::Handle->output_record_separator( [STR] ) $\ + + IO::Handle->input_record_separator( [STR] ) $/ + +Furthermore, for doing normal I/O you might need these: + +=over 4 + +=item $io->fdopen ( FD, MODE ) + +C is like an ordinary C except that its first parameter +is not a filename but rather a file handle name, an IO::Handle object, +or a file descriptor number. (For the documentation of the C +method, see L.) + +=item $io->opened + +Returns true if the object is currently a valid file descriptor, false +otherwise. + +=item $io->getline + +This works like <$io> described in L +except that it's more readable and can be safely called in a +list context but still returns just one line. If used as the conditional ++within a C or C-style C loop, however, you will need to ++emulate the functionality of <$io> with C<< defined($_ = $io->getline) >>. + +=item $io->getlines + +This works like <$io> when called in a list context to read all +the remaining lines in a file, except that it's more readable. +It will also croak() if accidentally called in a scalar context. + +=item $io->ungetc ( ORD ) + +Pushes a character with the given ordinal value back onto the given +handle's input stream. Only one character of pushback per handle is +guaranteed. + +=item $io->write ( BUF, LEN [, OFFSET ] ) + +This C is like C found in C, that is it is the +opposite of read. The wrapper for the perl C function is +called C. + +=item $io->error + +Returns a true value if the given handle has experienced any errors +since it was opened or since the last call to C, or if the +handle is invalid. It only returns false for a valid handle with no +outstanding errors. + +=item $io->clearerr + +Clear the given handle's error indicator. Returns -1 if the handle is +invalid, 0 otherwise. + +=item $io->sync + +C synchronizes a file's in-memory state with that on the +physical medium. C does not operate at the perlio api level, but +operates on the file descriptor (similar to sysread, sysseek and +systell). This means that any data held at the perlio api level will not +be synchronized. To synchronize data that is buffered at the perlio api +level you must use the flush method. C is not implemented on all +platforms. Returns "0 but true" on success, C on error, C +for an invalid handle. See L. + +=item $io->flush + +C causes perl to flush any buffered data at the perlio api level. +Any unread data in the buffer will be discarded, and any unwritten data +will be written to the underlying file descriptor. Returns "0 but true" +on success, C on error. + +=item $io->printflush ( ARGS ) + +Turns on autoflush, print ARGS and then restores the autoflush status of the +C object. Returns the return value from print. + +=item $io->blocking ( [ BOOL ] ) + +If called with an argument C will turn on non-blocking IO if +C is false, and turn it off if C is true. + +C will return the value of the previous setting, or the +current setting if C is not given. + +If an error occurs C will return undef and C<$!> will be set. + +=back + + +If the C functions setbuf() and/or setvbuf() are available, then +C and C set the buffering +policy for an IO::Handle. The calling sequences for the Perl functions +are the same as their C counterparts--including the constants C<_IOFBF>, +C<_IOLBF>, and C<_IONBF> for setvbuf()--except that the buffer parameter +specifies a scalar variable to use as a buffer. You should only +change the buffer before any I/O, or immediately after calling flush. + +WARNING: The IO::Handle::setvbuf() is not available by default on +Perls 5.8.0 and later because setvbuf() is rather specific to using +the stdio library, while Perl prefers the new perlio subsystem instead. + +WARNING: A variable used as a buffer by C or C B in any way until the IO::Handle is closed or C or +C is called again, or memory corruption may result! Remember that +the order of global destruction is undefined, so even if your buffer +variable remains in scope until program termination, it may be undefined +before the file IO::Handle is closed. Note that you need to import the +constants C<_IOFBF>, C<_IOLBF>, and C<_IONBF> explicitly. Like C, setbuf +returns nothing. setvbuf returns "0 but true", on success, C on +failure. + +Lastly, there is a special method for working under B<-T> and setuid/gid +scripts: + +=over 4 + +=item $io->untaint + +Marks the object as taint-clean, and as such data read from it will also +be considered taint-clean. Note that this is a very trusting action to +take, and appropriate consideration for the data source and potential +vulnerability should be kept in mind. Returns 0 on success, -1 if setting +the taint-clean flag failed. (eg invalid handle) + +=back + +=head1 NOTE + +An C object is a reference to a symbol/GLOB reference (see +the C package). Some modules that +inherit from C may want to keep object related variables +in the hash table part of the GLOB. In an attempt to prevent modules +trampling on each other I propose the that any such module should prefix +its variables with its own name separated by _'s. For example the IO::Socket +module keeps a C variable in 'io_socket_timeout'. + +=head1 SEE ALSO + +L, +L, +L + +=head1 BUGS + +Due to backwards compatibility, all filehandles resemble objects +of class C, or actually classes derived from that class. +They actually aren't. Which means you can't derive your own +class from C and inherit those methods. + +=head1 HISTORY + +Derived from FileHandle.pm by Graham Barr EFE + +=cut + +use 5.006_001; +use strict; +our($VERSION, @EXPORT_OK, @ISA); +use Carp; +use Symbol; +use SelectSaver; +use IO (); # Load the XS module + +require Exporter; +@ISA = qw(Exporter); + +$VERSION = "1.31"; +$VERSION = eval $VERSION; + +@EXPORT_OK = qw( + autoflush + output_field_separator + output_record_separator + input_record_separator + input_line_number + format_page_number + format_lines_per_page + format_lines_left + format_name + format_top_name + format_line_break_characters + format_formfeed + format_write + + print + printf + say + getline + getlines + + printflush + flush + + SEEK_SET + SEEK_CUR + SEEK_END + _IOFBF + _IOLBF + _IONBF +); + +################################################ +## Constructors, destructors. +## + +sub new { + my $class = ref($_[0]) || $_[0] || "IO::Handle"; + if (@_ != 1) { + # Since perl will automatically require IO::File if needed, but + # also initialises IO::File's @ISA as part of the core we must + # ensure IO::File is loaded if IO::Handle is. This avoids effect- + # ively "half-loading" IO::File. + if ($] > 5.013 && $class eq 'IO::File' && !$INC{"IO/File.pm"}) { + require IO::File; + shift; + return IO::File::->new(@_); + } + croak "usage: $class->new()"; + } + my $io = gensym; + bless $io, $class; +} + +sub new_from_fd { + my $class = ref($_[0]) || $_[0] || "IO::Handle"; + @_ == 3 or croak "usage: $class->new_from_fd(FD, MODE)"; + my $io = gensym; + shift; + IO::Handle::fdopen($io, @_) + or return undef; + bless $io, $class; +} + +# +# There is no need for DESTROY to do anything, because when the +# last reference to an IO object is gone, Perl automatically +# closes its associated files (if any). However, to avoid any +# attempts to autoload DESTROY, we here define it to do nothing. +# +sub DESTROY {} + + +################################################ +## Open and close. +## + +sub _open_mode_string { + my ($mode) = @_; + $mode =~ /^\+?(<|>>?)$/ + or $mode =~ s/^r(\+?)$/$1/ + or $mode =~ s/^a(\+?)$/$1>>/ + or croak "IO::Handle: bad open mode: $mode"; + $mode; +} + +sub fdopen { + @_ == 3 or croak 'usage: $io->fdopen(FD, MODE)'; + my ($io, $fd, $mode) = @_; + local(*GLOB); + + if (ref($fd) && "".$fd =~ /GLOB\(/o) { + # It's a glob reference; Alias it as we cannot get name of anon GLOBs + my $n = qualify(*GLOB); + *GLOB = *{*$fd}; + $fd = $n; + } elsif ($fd =~ m#^\d+$#) { + # It's an FD number; prefix with "=". + $fd = "=$fd"; + } + + open($io, _open_mode_string($mode) . '&' . $fd) + ? $io : undef; +} + +sub close { + @_ == 1 or croak 'usage: $io->close()'; + my($io) = @_; + + close($io); +} + +################################################ +## Normal I/O functions. +## + +# flock +# select + +sub opened { + @_ == 1 or croak 'usage: $io->opened()'; + defined fileno($_[0]); +} + +sub fileno { + @_ == 1 or croak 'usage: $io->fileno()'; + fileno($_[0]); +} + +sub getc { + @_ == 1 or croak 'usage: $io->getc()'; + getc($_[0]); +} + +sub eof { + @_ == 1 or croak 'usage: $io->eof()'; + eof($_[0]); +} + +sub print { + @_ or croak 'usage: $io->print(ARGS)'; + my $this = shift; + print $this @_; +} + +sub printf { + @_ >= 2 or croak 'usage: $io->printf(FMT,[ARGS])'; + my $this = shift; + printf $this @_; +} + +sub say { + @_ or croak 'usage: $io->say(ARGS)'; + my $this = shift; + local $\ = "\n"; + print $this @_; +} + +sub getline { + @_ == 1 or croak 'usage: $io->getline()'; + my $this = shift; + return scalar <$this>; +} + +*gets = \&getline; # deprecated + +sub getlines { + @_ == 1 or croak 'usage: $io->getlines()'; + wantarray or + croak 'Can\'t call $io->getlines in a scalar context, use $io->getline'; + my $this = shift; + return <$this>; +} + +sub truncate { + @_ == 2 or croak 'usage: $io->truncate(LEN)'; + truncate($_[0], $_[1]); +} + +sub read { + @_ == 3 || @_ == 4 or croak 'usage: $io->read(BUF, LEN [, OFFSET])'; + read($_[0], $_[1], $_[2], $_[3] || 0); +} + +sub sysread { + @_ == 3 || @_ == 4 or croak 'usage: $io->sysread(BUF, LEN [, OFFSET])'; + sysread($_[0], $_[1], $_[2], $_[3] || 0); +} + +sub write { + @_ >= 2 && @_ <= 4 or croak 'usage: $io->write(BUF [, LEN [, OFFSET]])'; + local($\) = ""; + $_[2] = length($_[1]) unless defined $_[2]; + print { $_[0] } substr($_[1], $_[3] || 0, $_[2]); +} + +sub syswrite { + @_ >= 2 && @_ <= 4 or croak 'usage: $io->syswrite(BUF [, LEN [, OFFSET]])'; + if (defined($_[2])) { + syswrite($_[0], $_[1], $_[2], $_[3] || 0); + } else { + syswrite($_[0], $_[1]); + } +} + +sub stat { + @_ == 1 or croak 'usage: $io->stat()'; + stat($_[0]); +} + +################################################ +## State modification functions. +## + +sub autoflush { + my $old = new SelectSaver qualify($_[0], caller); + my $prev = $|; + $| = @_ > 1 ? $_[1] : 1; + $prev; +} + +sub output_field_separator { + carp "output_field_separator is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $,; + $, = $_[1] if @_ > 1; + $prev; +} + +sub output_record_separator { + carp "output_record_separator is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $\; + $\ = $_[1] if @_ > 1; + $prev; +} + +sub input_record_separator { + carp "input_record_separator is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $/; + $/ = $_[1] if @_ > 1; + $prev; +} + +sub input_line_number { + local $.; + () = tell qualify($_[0], caller) if ref($_[0]); + my $prev = $.; + $. = $_[1] if @_ > 1; + $prev; +} + +sub format_page_number { + my $old; + $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $%; + $% = $_[1] if @_ > 1; + $prev; +} + +sub format_lines_per_page { + my $old; + $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $=; + $= = $_[1] if @_ > 1; + $prev; +} + +sub format_lines_left { + my $old; + $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $-; + $- = $_[1] if @_ > 1; + $prev; +} + +sub format_name { + my $old; + $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $~; + $~ = qualify($_[1], caller) if @_ > 1; + $prev; +} + +sub format_top_name { + my $old; + $old = new SelectSaver qualify($_[0], caller) if ref($_[0]); + my $prev = $^; + $^ = qualify($_[1], caller) if @_ > 1; + $prev; +} + +sub format_line_break_characters { + carp "format_line_break_characters is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $:; + $: = $_[1] if @_ > 1; + $prev; +} + +sub format_formfeed { + carp "format_formfeed is not supported on a per-handle basis" + if ref($_[0]); + my $prev = $^L; + $^L = $_[1] if @_ > 1; + $prev; +} + +sub formline { + my $io = shift; + my $picture = shift; + local($^A) = $^A; + local($\) = ""; + formline($picture, @_); + print $io $^A; +} + +sub format_write { + @_ < 3 || croak 'usage: $io->write( [FORMAT_NAME] )'; + if (@_ == 2) { + my ($io, $fmt) = @_; + my $oldfmt = $io->format_name(qualify($fmt,caller)); + CORE::write($io); + $io->format_name($oldfmt); + } else { + CORE::write($_[0]); + } +} + +sub fcntl { + @_ == 3 || croak 'usage: $io->fcntl( OP, VALUE );'; + my ($io, $op) = @_; + return fcntl($io, $op, $_[2]); +} + +sub ioctl { + @_ == 3 || croak 'usage: $io->ioctl( OP, VALUE );'; + my ($io, $op) = @_; + return ioctl($io, $op, $_[2]); +} + +# this sub is for compatibility with older releases of IO that used +# a sub called constant to determine if a constant existed -- GMB +# +# The SEEK_* and _IO?BF constants were the only constants at that time +# any new code should just chech defined(&CONSTANT_NAME) + +sub constant { + no strict 'refs'; + my $name = shift; + (($name =~ /^(SEEK_(SET|CUR|END)|_IO[FLN]BF)$/) && defined &{$name}) + ? &{$name}() : undef; +} + + +# so that flush.pl can be deprecated + +sub printflush { + my $io = shift; + my $old; + $old = new SelectSaver qualify($io, caller) if ref($io); + local $| = 1; + if(ref($io)) { + print $io @_; + } + else { + print @_; + } +} + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/IO/Seekable.pm b/testsuite/input-files/perl-v5.14.2/lib/IO/Seekable.pm new file mode 100644 index 00000000..db1effda --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/IO/Seekable.pm @@ -0,0 +1,128 @@ +# + +package IO::Seekable; + +=head1 NAME + +IO::Seekable - supply seek based methods for I/O objects + +=head1 SYNOPSIS + + use IO::Seekable; + package IO::Something; + @ISA = qw(IO::Seekable); + +=head1 DESCRIPTION + +C does not have a constructor of its own as it is intended to +be inherited by other C based objects. It provides methods +which allow seeking of the file descriptors. + +=over 4 + +=item $io->getpos + +Returns an opaque value that represents the current position of the +IO::File, or C if this is not possible (eg an unseekable stream such +as a terminal, pipe or socket). If the fgetpos() function is available in +your C library it is used to implements getpos, else perl emulates getpos +using C's ftell() function. + +=item $io->setpos + +Uses the value of a previous getpos call to return to a previously visited +position. Returns "0 but true" on success, C on failure. + +=back + +See L for complete descriptions of each of the following +supported C methods, which are just front ends for the +corresponding built-in functions: + +=over 4 + +=item $io->seek ( POS, WHENCE ) + +Seek the IO::File to position POS, relative to WHENCE: + +=over 8 + +=item WHENCE=0 (SEEK_SET) + +POS is absolute position. (Seek relative to the start of the file) + +=item WHENCE=1 (SEEK_CUR) + +POS is an offset from the current position. (Seek relative to current) + +=item WHENCE=2 (SEEK_END) + +POS is an offset from the end of the file. (Seek relative to end) + +=back + +The SEEK_* constants can be imported from the C module if you +don't wish to use the numbers C<0> C<1> or C<2> in your code. + +Returns C<1> upon success, C<0> otherwise. + +=item $io->sysseek( POS, WHENCE ) + +Similar to $io->seek, but sets the IO::File's position using the system +call lseek(2) directly, so will confuse most perl IO operators except +sysread and syswrite (see L for full details) + +Returns the new position, or C on failure. A position +of zero is returned as the string C<"0 but true"> + +=item $io->tell + +Returns the IO::File's current position, or -1 on error. + +=back + +=head1 SEE ALSO + +L, +L, +L +L + +=head1 HISTORY + +Derived from FileHandle.pm by Graham Barr Egbarr@pobox.comE + +=cut + +use 5.006_001; +use Carp; +use strict; +our($VERSION, @EXPORT, @ISA); +use IO::Handle (); +# XXX we can't get these from IO::Handle or we'll get prototype +# mismatch warnings on C :-( +use Fcntl qw(SEEK_SET SEEK_CUR SEEK_END); +require Exporter; + +@EXPORT = qw(SEEK_SET SEEK_CUR SEEK_END); +@ISA = qw(Exporter); + +$VERSION = "1.10"; +$VERSION = eval $VERSION; + +sub seek { + @_ == 3 or croak 'usage: $io->seek(POS, WHENCE)'; + seek($_[0], $_[1], $_[2]); +} + +sub sysseek { + @_ == 3 or croak 'usage: $io->sysseek(POS, WHENCE)'; + sysseek($_[0], $_[1], $_[2]); +} + +sub tell { + @_ == 1 or croak 'usage: $io->tell()'; + tell($_[0]); +} + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/IPC/Open3.pm b/testsuite/input-files/perl-v5.14.2/lib/IPC/Open3.pm new file mode 100644 index 00000000..7015d27a --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/IPC/Open3.pm @@ -0,0 +1,421 @@ +package IPC::Open3; + +use strict; +no strict 'refs'; # because users pass me bareword filehandles +our ($VERSION, @ISA, @EXPORT); + +require Exporter; + +use Carp; +use Symbol qw(gensym qualify); + +$VERSION = 1.09; +@ISA = qw(Exporter); +@EXPORT = qw(open3); + +=head1 NAME + +IPC::Open3 - open a process for reading, writing, and error handling using open3() + +=head1 SYNOPSIS + + $pid = open3(\*CHLD_IN, \*CHLD_OUT, \*CHLD_ERR, + 'some cmd and args', 'optarg', ...); + + my($wtr, $rdr, $err); + use Symbol 'gensym'; $err = gensym; + $pid = open3($wtr, $rdr, $err, + 'some cmd and args', 'optarg', ...); + + waitpid( $pid, 0 ); + my $child_exit_status = $? >> 8; + +=head1 DESCRIPTION + +Extremely similar to open2(), open3() spawns the given $cmd and +connects CHLD_OUT for reading from the child, CHLD_IN for writing to +the child, and CHLD_ERR for errors. If CHLD_ERR is false, or the +same file descriptor as CHLD_OUT, then STDOUT and STDERR of the child +are on the same filehandle (this means that an autovivified lexical +cannot be used for the STDERR filehandle, see SYNOPSIS). The CHLD_IN +will have autoflush turned on. + +If CHLD_IN begins with C<< <& >>, then CHLD_IN will be closed in the +parent, and the child will read from it directly. If CHLD_OUT or +CHLD_ERR begins with C<< >& >>, then the child will send output +directly to that filehandle. In both cases, there will be a dup(2) +instead of a pipe(2) made. + +If either reader or writer is the null string, this will be replaced +by an autogenerated filehandle. If so, you must pass a valid lvalue +in the parameter slot so it can be overwritten in the caller, or +an exception will be raised. + +The filehandles may also be integers, in which case they are understood +as file descriptors. + +open3() returns the process ID of the child process. It doesn't return on +failure: it just raises an exception matching C. However, +C failures in the child (such as no such file or permission denied), +are just reported to CHLD_ERR, as it is not possible to trap them. + +If the child process dies for any reason, the next write to CHLD_IN is +likely to generate a SIGPIPE in the parent, which is fatal by default. +So you may wish to handle this signal. + +Note if you specify C<-> as the command, in an analogous fashion to +C the child process will just be the forked Perl +process rather than an external command. This feature isn't yet +supported on Win32 platforms. + +open3() does not wait for and reap the child process after it exits. +Except for short programs where it's acceptable to let the operating system +take care of this, you need to do this yourself. This is normally as +simple as calling C when you're done with the process. +Failing to do this can result in an accumulation of defunct or "zombie" +processes. See L for more information. + +If you try to read from the child's stdout writer and their stderr +writer, you'll have problems with blocking, which means you'll want +to use select() or the IO::Select, which means you'd best use +sysread() instead of readline() for normal stuff. + +This is very dangerous, as you may block forever. It assumes it's +going to talk to something like B, both writing to it and reading +from it. This is presumably safe because you "know" that commands +like B will read a line at a time and output a line at a time. +Programs like B that read their entire input stream first, +however, are quite apt to cause deadlock. + +The big problem with this approach is that if you don't have control +over source code being run in the child process, you can't control +what it does with pipe buffering. Thus you can't just open a pipe to +C and continually read and write a line from it. + +=head1 See Also + +=over 4 + +=item L + +Like Open3 but without STDERR catpure. + +=item L + +This is a CPAN module that has better error handling and more facilities +than Open3. + +=back + +=head1 WARNING + +The order of arguments differs from that of open2(). + +=cut + +# &open3: Marc Horowitz +# derived mostly from &open2 by tom christiansen, +# fixed for 5.001 by Ulrich Kunitz +# ported to Win32 by Ron Schmidt, Merrill Lynch almost ended my career +# fixed for autovivving FHs, tchrist again +# allow fd numbers to be used, by Frank Tobin +# allow '-' as command (c.f. open "-|"), by Adam Spiers +# +# usage: $pid = open3('wtr', 'rdr', 'err' 'some cmd and args', 'optarg', ...); +# +# spawn the given $cmd and connect rdr for +# reading, wtr for writing, and err for errors. +# if err is '', or the same as rdr, then stdout and +# stderr of the child are on the same fh. returns pid +# of child (or dies on failure). + + +# if wtr begins with '<&', then wtr will be closed in the parent, and +# the child will read from it directly. if rdr or err begins with +# '>&', then the child will send output directly to that fd. In both +# cases, there will be a dup() instead of a pipe() made. + + +# WARNING: this is dangerous, as you may block forever +# unless you are very careful. +# +# $wtr is left unbuffered. +# +# abort program if +# rdr or wtr are null +# a system call fails + +our $Me = 'open3 (bug)'; # you should never see this, it's always localized + +# Fatal.pm needs to be fixed WRT prototypes. + +sub xfork { + my $pid = fork; + defined $pid or croak "$Me: fork failed: $!"; + return $pid; +} + +sub xpipe { + pipe $_[0], $_[1] or croak "$Me: pipe($_[0], $_[1]) failed: $!"; +} + +sub xpipe_anon { + pipe $_[0], $_[1] or croak "$Me: pipe failed: $!"; +} + +sub xclose_on_exec { + require Fcntl; + my $flags = fcntl($_[0], &Fcntl::F_GETFD, 0) + or croak "$Me: fcntl failed: $!"; + fcntl($_[0], &Fcntl::F_SETFD, $flags|&Fcntl::FD_CLOEXEC) + or croak "$Me: fcntl failed: $!"; +} + +# I tried using a * prototype character for the filehandle but it still +# disallows a bareword while compiling under strict subs. + +sub xopen { + open $_[0], $_[1] or croak "$Me: open($_[0], $_[1]) failed: $!"; +} + +sub xclose { + $_[0] =~ /\A=?(\d+)\z/ ? eval { require POSIX; POSIX::close($1); } : close $_[0] +} + +sub fh_is_fd { + return $_[0] =~ /\A=?(\d+)\z/; +} + +sub xfileno { + return $1 if $_[0] =~ /\A=?(\d+)\z/; # deal with fh just being an fd + return fileno $_[0]; +} + +use constant DO_SPAWN => $^O eq 'os2' || $^O eq 'MSWin32'; + +sub _open3 { + local $Me = shift; + my($package, $dad_wtr, $dad_rdr, $dad_err, @cmd) = @_; + my($dup_wtr, $dup_rdr, $dup_err, $kidpid); + + if (@cmd > 1 and $cmd[0] eq '-') { + croak "Arguments don't make sense when the command is '-'" + } + + # simulate autovivification of filehandles because + # it's too ugly to use @_ throughout to make perl do it for us + # tchrist 5-Mar-00 + + unless (eval { + $dad_wtr = $_[1] = gensym unless defined $dad_wtr && length $dad_wtr; + $dad_rdr = $_[2] = gensym unless defined $dad_rdr && length $dad_rdr; + 1; }) + { + # must strip crud for croak to add back, or looks ugly + $@ =~ s/(?<=value attempted) at .*//s; + croak "$Me: $@"; + } + + $dad_err ||= $dad_rdr; + + $dup_wtr = ($dad_wtr =~ s/^[<>]&//); + $dup_rdr = ($dad_rdr =~ s/^[<>]&//); + $dup_err = ($dad_err =~ s/^[<>]&//); + + # force unqualified filehandles into caller's package + $dad_wtr = qualify $dad_wtr, $package unless fh_is_fd($dad_wtr); + $dad_rdr = qualify $dad_rdr, $package unless fh_is_fd($dad_rdr); + $dad_err = qualify $dad_err, $package unless fh_is_fd($dad_err); + + my $kid_rdr = gensym; + my $kid_wtr = gensym; + my $kid_err = gensym; + + xpipe $kid_rdr, $dad_wtr if !$dup_wtr; + xpipe $dad_rdr, $kid_wtr if !$dup_rdr; + xpipe $dad_err, $kid_err if !$dup_err && $dad_err ne $dad_rdr; + + if (!DO_SPAWN) { + # Used to communicate exec failures. + xpipe my $stat_r, my $stat_w; + + $kidpid = xfork; + if ($kidpid == 0) { # Kid + eval { + # A tie in the parent should not be allowed to cause problems. + untie *STDIN; + untie *STDOUT; + + close $stat_r; + xclose_on_exec $stat_w; + + # If she wants to dup the kid's stderr onto her stdout I need to + # save a copy of her stdout before I put something else there. + if ($dad_rdr ne $dad_err && $dup_err + && xfileno($dad_err) == fileno(STDOUT)) { + my $tmp = gensym; + xopen($tmp, ">&$dad_err"); + $dad_err = $tmp; + } + + if ($dup_wtr) { + xopen \*STDIN, "<&$dad_wtr" if fileno(STDIN) != xfileno($dad_wtr); + } else { + xclose $dad_wtr; + xopen \*STDIN, "<&=" . fileno $kid_rdr; + } + if ($dup_rdr) { + xopen \*STDOUT, ">&$dad_rdr" if fileno(STDOUT) != xfileno($dad_rdr); + } else { + xclose $dad_rdr; + xopen \*STDOUT, ">&=" . fileno $kid_wtr; + } + if ($dad_rdr ne $dad_err) { + if ($dup_err) { + # I have to use a fileno here because in this one case + # I'm doing a dup but the filehandle might be a reference + # (from the special case above). + xopen \*STDERR, ">&" . xfileno($dad_err) + if fileno(STDERR) != xfileno($dad_err); + } else { + xclose $dad_err; + xopen \*STDERR, ">&=" . fileno $kid_err; + } + } else { + xopen \*STDERR, ">&STDOUT" if fileno(STDERR) != fileno(STDOUT); + } + return 0 if ($cmd[0] eq '-'); + exec @cmd or do { + local($")=(" "); + croak "$Me: exec of @cmd failed"; + }; + }; + + my $bang = 0+$!; + my $err = $@; + utf8::encode $err if $] >= 5.008; + print $stat_w pack('IIa*', $bang, length($err), $err); + close $stat_w; + + eval { require POSIX; POSIX::_exit(255); }; + exit 255; + } + else { # Parent + close $stat_w; + my $to_read = length(pack('I', 0)) * 2; + my $bytes_read = read($stat_r, my $buf = '', $to_read); + if ($bytes_read) { + (my $bang, $to_read) = unpack('II', $buf); + read($stat_r, my $err = '', $to_read); + if ($err) { + utf8::decode $err if $] >= 5.008; + } else { + $err = "$Me: " . ($! = $bang); + } + $! = $bang; + die($err); + } + } + } + else { # DO_SPAWN + # All the bookkeeping of coincidence between handles is + # handled in spawn_with_handles. + + my @close; + if ($dup_wtr) { + $kid_rdr = \*{$dad_wtr}; + push @close, $kid_rdr; + } else { + push @close, \*{$dad_wtr}, $kid_rdr; + } + if ($dup_rdr) { + $kid_wtr = \*{$dad_rdr}; + push @close, $kid_wtr; + } else { + push @close, \*{$dad_rdr}, $kid_wtr; + } + if ($dad_rdr ne $dad_err) { + if ($dup_err) { + $kid_err = \*{$dad_err}; + push @close, $kid_err; + } else { + push @close, \*{$dad_err}, $kid_err; + } + } else { + $kid_err = $kid_wtr; + } + require IO::Pipe; + $kidpid = eval { + spawn_with_handles( [ { mode => 'r', + open_as => $kid_rdr, + handle => \*STDIN }, + { mode => 'w', + open_as => $kid_wtr, + handle => \*STDOUT }, + { mode => 'w', + open_as => $kid_err, + handle => \*STDERR }, + ], \@close, @cmd); + }; + die "$Me: $@" if $@; + } + + xclose $kid_rdr if !$dup_wtr; + xclose $kid_wtr if !$dup_rdr; + xclose $kid_err if !$dup_err && $dad_rdr ne $dad_err; + # If the write handle is a dup give it away entirely, close my copy + # of it. + xclose $dad_wtr if $dup_wtr; + + select((select($dad_wtr), $| = 1)[0]); # unbuffer pipe + $kidpid; +} + +sub open3 { + if (@_ < 4) { + local $" = ', '; + croak "open3(@_): not enough arguments"; + } + return _open3 'open3', scalar caller, @_ +} + +sub spawn_with_handles { + my $fds = shift; # Fields: handle, mode, open_as + my $close_in_child = shift; + my ($fd, $pid, @saved_fh, $saved, %saved, @errs); + require Fcntl; + + foreach $fd (@$fds) { + $fd->{tmp_copy} = IO::Handle->new_from_fd($fd->{handle}, $fd->{mode}); + $saved{fileno $fd->{handle}} = $fd->{tmp_copy}; + } + foreach $fd (@$fds) { + bless $fd->{handle}, 'IO::Handle' + unless eval { $fd->{handle}->isa('IO::Handle') } ; + # If some of handles to redirect-to coincide with handles to + # redirect, we need to use saved variants: + $fd->{handle}->fdopen($saved{fileno $fd->{open_as}} || $fd->{open_as}, + $fd->{mode}); + } + unless ($^O eq 'MSWin32') { + # Stderr may be redirected below, so we save the err text: + foreach $fd (@$close_in_child) { + fcntl($fd, Fcntl::F_SETFD(), 1) or push @errs, "fcntl $fd: $!" + unless $saved{fileno $fd}; # Do not close what we redirect! + } + } + + unless (@errs) { + $pid = eval { system 1, @_ }; # 1 == P_NOWAIT + push @errs, "IO::Pipe: Can't spawn-NOWAIT: $!" if !$pid || $pid < 0; + } + + foreach $fd (@$fds) { + $fd->{handle}->fdopen($fd->{tmp_copy}, $fd->{mode}); + $fd->{tmp_copy}->close or croak "Can't close: $!"; + } + croak join "\n", @errs if @errs; + return $pid; +} + +1; # so require is happy diff --git a/testsuite/input-files/perl-v5.14.2/lib/POSIX.pm b/testsuite/input-files/perl-v5.14.2/lib/POSIX.pm new file mode 100644 index 00000000..990b73ba --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/POSIX.pm @@ -0,0 +1,1037 @@ +package POSIX; +use strict; +use warnings; + +our(@ISA, %EXPORT_TAGS, @EXPORT_OK, @EXPORT, $AUTOLOAD, %SIGRT) = (); + +our $VERSION = "1.24"; + +use AutoLoader; + +require XSLoader; + +use Fcntl qw(FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_RDLCK F_SETFD + F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK O_ACCMODE O_APPEND + O_CREAT O_EXCL O_NOCTTY O_NONBLOCK O_RDONLY O_RDWR O_TRUNC + O_WRONLY SEEK_CUR SEEK_END SEEK_SET + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISREG + S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU S_ISGID S_ISUID + S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR); + +# Grandfather old foo_h form to new :foo_h form +my $loaded; + +sub import { + load_imports() unless $loaded++; + my $this = shift; + my @list = map { m/^\w+_h$/ ? ":$_" : $_ } @_; + local $Exporter::ExportLevel = 1; + Exporter::import($this,@list); +} + +sub croak { require Carp; goto &Carp::croak } +# declare usage to assist AutoLoad +sub usage; + +XSLoader::load(); + +sub AUTOLOAD { + no warnings 'uninitialized'; + if ($AUTOLOAD =~ /::(_?[a-z])/) { + # require AutoLoader; + $AutoLoader::AUTOLOAD = $AUTOLOAD; + goto &AutoLoader::AUTOLOAD + } + my $constname = $AUTOLOAD; + $constname =~ s/.*:://; + constant($constname); +} + +package POSIX::SigAction; + +use AutoLoader 'AUTOLOAD'; + +package POSIX::SigRt; + +use AutoLoader 'AUTOLOAD'; + +use Tie::Hash; + +use vars qw($SIGACTION_FLAGS $_SIGRTMIN $_SIGRTMAX $_sigrtn @ISA); +@POSIX::SigRt::ISA = qw(Tie::StdHash); + +$SIGACTION_FLAGS = 0; + +tie %POSIX::SIGRT, 'POSIX::SigRt'; + +sub DESTROY {}; + +package POSIX; + +1; +__END__ + +sub usage { + my ($mess) = @_; + croak "Usage: POSIX::$mess"; +} + +sub redef { + my ($mess) = @_; + croak "Use method $mess instead"; +} + +sub unimpl { + my ($mess) = @_; + $mess =~ s/xxx//; + croak "Unimplemented: POSIX::$mess"; +} + +sub assert { + usage "assert(expr)" if @_ != 1; + if (!$_[0]) { + croak "Assertion failed"; + } +} + +sub tolower { + usage "tolower(string)" if @_ != 1; + lc($_[0]); +} + +sub toupper { + usage "toupper(string)" if @_ != 1; + uc($_[0]); +} + +sub closedir { + usage "closedir(dirhandle)" if @_ != 1; + CORE::closedir($_[0]); +} + +sub opendir { + usage "opendir(directory)" if @_ != 1; + my $dirhandle; + CORE::opendir($dirhandle, $_[0]) + ? $dirhandle + : undef; +} + +sub readdir { + usage "readdir(dirhandle)" if @_ != 1; + CORE::readdir($_[0]); +} + +sub rewinddir { + usage "rewinddir(dirhandle)" if @_ != 1; + CORE::rewinddir($_[0]); +} + +sub errno { + usage "errno()" if @_ != 0; + $! + 0; +} + +sub creat { + usage "creat(filename, mode)" if @_ != 2; + &open($_[0], &O_WRONLY | &O_CREAT | &O_TRUNC, $_[1]); +} + +sub fcntl { + usage "fcntl(filehandle, cmd, arg)" if @_ != 3; + CORE::fcntl($_[0], $_[1], $_[2]); +} + +sub getgrgid { + usage "getgrgid(gid)" if @_ != 1; + CORE::getgrgid($_[0]); +} + +sub getgrnam { + usage "getgrnam(name)" if @_ != 1; + CORE::getgrnam($_[0]); +} + +sub atan2 { + usage "atan2(x,y)" if @_ != 2; + CORE::atan2($_[0], $_[1]); +} + +sub cos { + usage "cos(x)" if @_ != 1; + CORE::cos($_[0]); +} + +sub exp { + usage "exp(x)" if @_ != 1; + CORE::exp($_[0]); +} + +sub fabs { + usage "fabs(x)" if @_ != 1; + CORE::abs($_[0]); +} + +sub log { + usage "log(x)" if @_ != 1; + CORE::log($_[0]); +} + +sub pow { + usage "pow(x,exponent)" if @_ != 2; + $_[0] ** $_[1]; +} + +sub sin { + usage "sin(x)" if @_ != 1; + CORE::sin($_[0]); +} + +sub sqrt { + usage "sqrt(x)" if @_ != 1; + CORE::sqrt($_[0]); +} + +sub getpwnam { + usage "getpwnam(name)" if @_ != 1; + CORE::getpwnam($_[0]); +} + +sub getpwuid { + usage "getpwuid(uid)" if @_ != 1; + CORE::getpwuid($_[0]); +} + +sub longjmp { + unimpl "longjmp() is C-specific: use die instead"; +} + +sub setjmp { + unimpl "setjmp() is C-specific: use eval {} instead"; +} + +sub siglongjmp { + unimpl "siglongjmp() is C-specific: use die instead"; +} + +sub sigsetjmp { + unimpl "sigsetjmp() is C-specific: use eval {} instead"; +} + +sub kill { + usage "kill(pid, sig)" if @_ != 2; + CORE::kill $_[1], $_[0]; +} + +sub raise { + usage "raise(sig)" if @_ != 1; + CORE::kill $_[0], $$; # Is this good enough? +} + +sub offsetof { + unimpl "offsetof() is C-specific, stopped"; +} + +sub clearerr { + redef "IO::Handle::clearerr()"; +} + +sub fclose { + redef "IO::Handle::close()"; +} + +sub fdopen { + redef "IO::Handle::new_from_fd()"; +} + +sub feof { + redef "IO::Handle::eof()"; +} + +sub fgetc { + redef "IO::Handle::getc()"; +} + +sub fgets { + redef "IO::Handle::gets()"; +} + +sub fileno { + redef "IO::Handle::fileno()"; +} + +sub fopen { + redef "IO::File::open()"; +} + +sub fprintf { + unimpl "fprintf() is C-specific--use printf instead"; +} + +sub fputc { + unimpl "fputc() is C-specific--use print instead"; +} + +sub fputs { + unimpl "fputs() is C-specific--use print instead"; +} + +sub fread { + unimpl "fread() is C-specific--use read instead"; +} + +sub freopen { + unimpl "freopen() is C-specific--use open instead"; +} + +sub fscanf { + unimpl "fscanf() is C-specific--use <> and regular expressions instead"; +} + +sub fseek { + redef "IO::Seekable::seek()"; +} + +sub fsync { + redef "IO::Handle::sync()"; +} + +sub ferror { + redef "IO::Handle::error()"; +} + +sub fflush { + redef "IO::Handle::flush()"; +} + +sub fgetpos { + redef "IO::Seekable::getpos()"; +} + +sub fsetpos { + redef "IO::Seekable::setpos()"; +} + +sub ftell { + redef "IO::Seekable::tell()"; +} + +sub fwrite { + unimpl "fwrite() is C-specific--use print instead"; +} + +sub getc { + usage "getc(handle)" if @_ != 1; + CORE::getc($_[0]); +} + +sub getchar { + usage "getchar()" if @_ != 0; + CORE::getc(STDIN); +} + +sub gets { + usage "gets()" if @_ != 0; + scalar ; +} + +sub perror { + print STDERR "@_: " if @_; + print STDERR $!,"\n"; +} + +sub printf { + usage "printf(pattern, args...)" if @_ < 1; + CORE::printf STDOUT @_; +} + +sub putc { + unimpl "putc() is C-specific--use print instead"; +} + +sub putchar { + unimpl "putchar() is C-specific--use print instead"; +} + +sub puts { + unimpl "puts() is C-specific--use print instead"; +} + +sub remove { + usage "remove(filename)" if @_ != 1; + (-d $_[0]) ? CORE::rmdir($_[0]) : CORE::unlink($_[0]); +} + +sub rename { + usage "rename(oldfilename, newfilename)" if @_ != 2; + CORE::rename($_[0], $_[1]); +} + +sub rewind { + usage "rewind(filehandle)" if @_ != 1; + CORE::seek($_[0],0,0); +} + +sub scanf { + unimpl "scanf() is C-specific--use <> and regular expressions instead"; +} + +sub sprintf { + usage "sprintf(pattern,args)" if @_ == 0; + CORE::sprintf(shift,@_); +} + +sub sscanf { + unimpl "sscanf() is C-specific--use regular expressions instead"; +} + +sub tmpfile { + redef "IO::File::new_tmpfile()"; +} + +sub ungetc { + redef "IO::Handle::ungetc()"; +} + +sub vfprintf { + unimpl "vfprintf() is C-specific"; +} + +sub vprintf { + unimpl "vprintf() is C-specific"; +} + +sub vsprintf { + unimpl "vsprintf() is C-specific"; +} + +sub abs { + usage "abs(x)" if @_ != 1; + CORE::abs($_[0]); +} + +sub atexit { + unimpl "atexit() is C-specific: use END {} instead"; +} + +sub atof { + unimpl "atof() is C-specific, stopped"; +} + +sub atoi { + unimpl "atoi() is C-specific, stopped"; +} + +sub atol { + unimpl "atol() is C-specific, stopped"; +} + +sub bsearch { + unimpl "bsearch() not supplied"; +} + +sub calloc { + unimpl "calloc() is C-specific, stopped"; +} + +sub div { + unimpl "div() is C-specific, use /, % and int instead"; +} + +sub exit { + usage "exit(status)" if @_ != 1; + CORE::exit($_[0]); +} + +sub free { + unimpl "free() is C-specific, stopped"; +} + +sub getenv { + usage "getenv(name)" if @_ != 1; + $ENV{$_[0]}; +} + +sub labs { + unimpl "labs() is C-specific, use abs instead"; +} + +sub ldiv { + unimpl "ldiv() is C-specific, use /, % and int instead"; +} + +sub malloc { + unimpl "malloc() is C-specific, stopped"; +} + +sub qsort { + unimpl "qsort() is C-specific, use sort instead"; +} + +sub rand { + unimpl "rand() is non-portable, use Perl's rand instead"; +} + +sub realloc { + unimpl "realloc() is C-specific, stopped"; +} + +sub srand { + unimpl "srand()"; +} + +sub system { + usage "system(command)" if @_ != 1; + CORE::system($_[0]); +} + +sub memchr { + unimpl "memchr() is C-specific, use index() instead"; +} + +sub memcmp { + unimpl "memcmp() is C-specific, use eq instead"; +} + +sub memcpy { + unimpl "memcpy() is C-specific, use = instead"; +} + +sub memmove { + unimpl "memmove() is C-specific, use = instead"; +} + +sub memset { + unimpl "memset() is C-specific, use x instead"; +} + +sub strcat { + unimpl "strcat() is C-specific, use .= instead"; +} + +sub strchr { + unimpl "strchr() is C-specific, use index() instead"; +} + +sub strcmp { + unimpl "strcmp() is C-specific, use eq instead"; +} + +sub strcpy { + unimpl "strcpy() is C-specific, use = instead"; +} + +sub strcspn { + unimpl "strcspn() is C-specific, use regular expressions instead"; +} + +sub strerror { + usage "strerror(errno)" if @_ != 1; + local $! = $_[0]; + $! . ""; +} + +sub strlen { + unimpl "strlen() is C-specific, use length instead"; +} + +sub strncat { + unimpl "strncat() is C-specific, use .= instead"; +} + +sub strncmp { + unimpl "strncmp() is C-specific, use eq instead"; +} + +sub strncpy { + unimpl "strncpy() is C-specific, use = instead"; +} + +sub strpbrk { + unimpl "strpbrk() is C-specific, stopped"; +} + +sub strrchr { + unimpl "strrchr() is C-specific, use rindex() instead"; +} + +sub strspn { + unimpl "strspn() is C-specific, stopped"; +} + +sub strstr { + usage "strstr(big, little)" if @_ != 2; + CORE::index($_[0], $_[1]); +} + +sub strtok { + unimpl "strtok() is C-specific, stopped"; +} + +sub chmod { + usage "chmod(mode, filename)" if @_ != 2; + CORE::chmod($_[0], $_[1]); +} + +sub fstat { + usage "fstat(fd)" if @_ != 1; + local *TMP; + CORE::open(TMP, "<&$_[0]"); # Gross. + my @l = CORE::stat(TMP); + CORE::close(TMP); + @l; +} + +sub mkdir { + usage "mkdir(directoryname, mode)" if @_ != 2; + CORE::mkdir($_[0], $_[1]); +} + +sub stat { + usage "stat(filename)" if @_ != 1; + CORE::stat($_[0]); +} + +sub umask { + usage "umask(mask)" if @_ != 1; + CORE::umask($_[0]); +} + +sub wait { + usage "wait()" if @_ != 0; + CORE::wait(); +} + +sub waitpid { + usage "waitpid(pid, options)" if @_ != 2; + CORE::waitpid($_[0], $_[1]); +} + +sub gmtime { + usage "gmtime(time)" if @_ != 1; + CORE::gmtime($_[0]); +} + +sub localtime { + usage "localtime(time)" if @_ != 1; + CORE::localtime($_[0]); +} + +sub time { + usage "time()" if @_ != 0; + CORE::time; +} + +sub alarm { + usage "alarm(seconds)" if @_ != 1; + CORE::alarm($_[0]); +} + +sub chdir { + usage "chdir(directory)" if @_ != 1; + CORE::chdir($_[0]); +} + +sub chown { + usage "chown(uid, gid, filename)" if @_ != 3; + CORE::chown($_[0], $_[1], $_[2]); +} + +sub execl { + unimpl "execl() is C-specific, stopped"; +} + +sub execle { + unimpl "execle() is C-specific, stopped"; +} + +sub execlp { + unimpl "execlp() is C-specific, stopped"; +} + +sub execv { + unimpl "execv() is C-specific, stopped"; +} + +sub execve { + unimpl "execve() is C-specific, stopped"; +} + +sub execvp { + unimpl "execvp() is C-specific, stopped"; +} + +sub fork { + usage "fork()" if @_ != 0; + CORE::fork; +} + +sub getegid { + usage "getegid()" if @_ != 0; + $) + 0; +} + +sub geteuid { + usage "geteuid()" if @_ != 0; + $> + 0; +} + +sub getgid { + usage "getgid()" if @_ != 0; + $( + 0; +} + +sub getgroups { + usage "getgroups()" if @_ != 0; + my %seen; + grep(!$seen{$_}++, split(' ', $) )); +} + +sub getlogin { + usage "getlogin()" if @_ != 0; + CORE::getlogin(); +} + +sub getpgrp { + usage "getpgrp()" if @_ != 0; + CORE::getpgrp; +} + +sub getpid { + usage "getpid()" if @_ != 0; + $$; +} + +sub getppid { + usage "getppid()" if @_ != 0; + CORE::getppid; +} + +sub getuid { + usage "getuid()" if @_ != 0; + $<; +} + +sub isatty { + usage "isatty(filehandle)" if @_ != 1; + -t $_[0]; +} + +sub link { + usage "link(oldfilename, newfilename)" if @_ != 2; + CORE::link($_[0], $_[1]); +} + +sub rmdir { + usage "rmdir(directoryname)" if @_ != 1; + CORE::rmdir($_[0]); +} + +sub setbuf { + redef "IO::Handle::setbuf()"; +} + +sub setvbuf { + redef "IO::Handle::setvbuf()"; +} + +sub sleep { + usage "sleep(seconds)" if @_ != 1; + $_[0] - CORE::sleep($_[0]); +} + +sub unlink { + usage "unlink(filename)" if @_ != 1; + CORE::unlink($_[0]); +} + +sub utime { + usage "utime(filename, atime, mtime)" if @_ != 3; + CORE::utime($_[1], $_[2], $_[0]); +} + +sub load_imports { +%EXPORT_TAGS = ( + + assert_h => [qw(assert NDEBUG)], + + ctype_h => [qw(isalnum isalpha iscntrl isdigit isgraph islower + isprint ispunct isspace isupper isxdigit tolower toupper)], + + dirent_h => [], + + errno_h => [qw(E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT + EAGAIN EALREADY EBADF EBUSY ECHILD ECONNABORTED + ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ EDOM EDQUOT + EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS + EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK + EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH + ENFILE ENOBUFS ENODEV ENOENT ENOEXEC ENOLCK ENOMEM + ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR + ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM + EPFNOSUPPORT EPIPE EPROCLIM EPROTONOSUPPORT EPROTOTYPE + ERANGE EREMOTE ERESTART EROFS ESHUTDOWN ESOCKTNOSUPPORT + ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS ETXTBSY + EUSERS EWOULDBLOCK EXDEV errno)], + + fcntl_h => [qw(FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_RDLCK + F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK + O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK + O_RDONLY O_RDWR O_TRUNC O_WRONLY + creat + SEEK_CUR SEEK_END SEEK_SET + S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG S_ISUID + S_IWGRP S_IWOTH S_IWUSR)], + + float_h => [qw(DBL_DIG DBL_EPSILON DBL_MANT_DIG + DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP + DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP + FLT_DIG FLT_EPSILON FLT_MANT_DIG + FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP + FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP + FLT_RADIX FLT_ROUNDS + LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG + LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP + LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP)], + + grp_h => [], + + limits_h => [qw( ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX + INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON + MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX + PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN + SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX + ULONG_MAX USHRT_MAX _POSIX_ARG_MAX _POSIX_CHILD_MAX + _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT + _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_OPEN_MAX + _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SSIZE_MAX + _POSIX_STREAM_MAX _POSIX_TZNAME_MAX)], + + locale_h => [qw(LC_ALL LC_COLLATE LC_CTYPE LC_MESSAGES + LC_MONETARY LC_NUMERIC LC_TIME NULL + localeconv setlocale)], + + math_h => [qw(HUGE_VAL acos asin atan ceil cosh fabs floor fmod + frexp ldexp log10 modf pow sinh tan tanh)], + + pwd_h => [], + + setjmp_h => [qw(longjmp setjmp siglongjmp sigsetjmp)], + + signal_h => [qw(SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK + SA_RESETHAND SA_RESTART SA_SIGINFO SIGABRT SIGALRM + SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT SIGKILL + SIGPIPE %SIGRT SIGRTMIN SIGRTMAX SIGQUIT SIGSEGV SIGSTOP + SIGTERM SIGTSTP SIGTTIN SIGTTOU SIGUSR1 SIGUSR2 SIGBUS + SIGPOLL SIGPROF SIGSYS SIGTRAP SIGURG SIGVTALRM SIGXCPU SIGXFSZ + SIG_BLOCK SIG_DFL SIG_ERR SIG_IGN SIG_SETMASK SIG_UNBLOCK + raise sigaction signal sigpending sigprocmask sigsuspend)], + + stdarg_h => [], + + stddef_h => [qw(NULL offsetof)], + + stdio_h => [qw(BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid + L_tmpname NULL SEEK_CUR SEEK_END SEEK_SET + STREAM_MAX TMP_MAX stderr stdin stdout + clearerr fclose fdopen feof ferror fflush fgetc fgetpos + fgets fopen fprintf fputc fputs fread freopen + fscanf fseek fsetpos ftell fwrite getchar gets + perror putc putchar puts remove rewind + scanf setbuf setvbuf sscanf tmpfile tmpnam + ungetc vfprintf vprintf vsprintf)], + + stdlib_h => [qw(EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX NULL RAND_MAX + abort atexit atof atoi atol bsearch calloc div + free getenv labs ldiv malloc mblen mbstowcs mbtowc + qsort realloc strtod strtol strtoul wcstombs wctomb)], + + string_h => [qw(NULL memchr memcmp memcpy memmove memset strcat + strchr strcmp strcoll strcpy strcspn strerror strlen + strncat strncmp strncpy strpbrk strrchr strspn strstr + strtok strxfrm)], + + sys_stat_h => [qw(S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG + S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR + fstat mkfifo)], + + sys_times_h => [], + + sys_types_h => [], + + sys_utsname_h => [qw(uname)], + + sys_wait_h => [qw(WEXITSTATUS WIFEXITED WIFSIGNALED WIFSTOPPED + WNOHANG WSTOPSIG WTERMSIG WUNTRACED)], + + termios_h => [qw( B0 B110 B1200 B134 B150 B1800 B19200 B200 B2400 + B300 B38400 B4800 B50 B600 B75 B9600 BRKINT CLOCAL + CREAD CS5 CS6 CS7 CS8 CSIZE CSTOPB ECHO ECHOE ECHOK + ECHONL HUPCL ICANON ICRNL IEXTEN IGNBRK IGNCR IGNPAR + INLCR INPCK ISIG ISTRIP IXOFF IXON NCCS NOFLSH OPOST + PARENB PARMRK PARODD TCIFLUSH TCIOFF TCIOFLUSH TCION + TCOFLUSH TCOOFF TCOON TCSADRAIN TCSAFLUSH TCSANOW + TOSTOP VEOF VEOL VERASE VINTR VKILL VMIN VQUIT VSTART + VSTOP VSUSP VTIME + cfgetispeed cfgetospeed cfsetispeed cfsetospeed tcdrain + tcflow tcflush tcgetattr tcsendbreak tcsetattr )], + + time_h => [qw(CLK_TCK CLOCKS_PER_SEC NULL asctime clock ctime + difftime mktime strftime tzset tzname)], + + unistd_h => [qw(F_OK NULL R_OK SEEK_CUR SEEK_END SEEK_SET + STDERR_FILENO STDIN_FILENO STDOUT_FILENO W_OK X_OK + _PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON + _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX + _PC_PIPE_BUF _PC_VDISABLE _POSIX_CHOWN_RESTRICTED + _POSIX_JOB_CONTROL _POSIX_NO_TRUNC _POSIX_SAVED_IDS + _POSIX_VDISABLE _POSIX_VERSION _SC_ARG_MAX + _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL + _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS + _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION + _exit access ctermid cuserid + dup2 dup execl execle execlp execv execve execvp + fpathconf fsync getcwd getegid geteuid getgid getgroups + getpid getuid isatty lseek pathconf pause setgid setpgid + setsid setuid sysconf tcgetpgrp tcsetpgrp ttyname)], + + utime_h => [], + +); + +# Exporter::export_tags(); +{ + # De-duplicate the export list: + my %export; + @export{map {@$_} values %EXPORT_TAGS} = (); + # Doing the de-dup with a temporary hash has the advantage that the SVs in + # @EXPORT are actually shared hash key scalars, which will save some memory. + push @EXPORT, keys %export; +} + +@EXPORT_OK = qw( + abs + alarm + atan2 + chdir + chmod + chown + close + closedir + cos + exit + exp + fcntl + fileno + fork + getc + getgrgid + getgrnam + getlogin + getpgrp + getppid + getpwnam + getpwuid + gmtime + isatty + kill + lchown + link + localtime + log + mkdir + nice + open + opendir + pipe + printf + rand + read + readdir + rename + rewinddir + rmdir + sin + sleep + sprintf + sqrt + srand + stat + system + time + times + umask + unlink + utime + wait + waitpid + write +); + +require Exporter; +} + +package POSIX::SigAction; + +sub new { bless {HANDLER => $_[1], MASK => $_[2], FLAGS => $_[3] || 0, SAFE => 0}, $_[0] } +sub handler { $_[0]->{HANDLER} = $_[1] if @_ > 1; $_[0]->{HANDLER} }; +sub mask { $_[0]->{MASK} = $_[1] if @_ > 1; $_[0]->{MASK} }; +sub flags { $_[0]->{FLAGS} = $_[1] if @_ > 1; $_[0]->{FLAGS} }; +sub safe { $_[0]->{SAFE} = $_[1] if @_ > 1; $_[0]->{SAFE} }; + +package POSIX::SigRt; + + +sub _init { + $_SIGRTMIN = &POSIX::SIGRTMIN; + $_SIGRTMAX = &POSIX::SIGRTMAX; + $_sigrtn = $_SIGRTMAX - $_SIGRTMIN; +} + +sub _croak { + &_init unless defined $_sigrtn; + die "POSIX::SigRt not available" unless defined $_sigrtn && $_sigrtn > 0; +} + +sub _getsig { + &_croak; + my $rtsig = $_[0]; + # Allow (SIGRT)?MIN( + n)?, a common idiom when doing these things in C. + $rtsig = $_SIGRTMIN + ($1 || 0) + if $rtsig =~ /^(?:(?:SIG)?RT)?MIN(\s*\+\s*(\d+))?$/; + return $rtsig; +} + +sub _exist { + my $rtsig = _getsig($_[1]); + my $ok = $rtsig >= $_SIGRTMIN && $rtsig <= $_SIGRTMAX; + ($rtsig, $ok); +} + +sub _check { + my ($rtsig, $ok) = &_exist; + die "No POSIX::SigRt signal $_[1] (valid range SIGRTMIN..SIGRTMAX, or $_SIGRTMIN..$_SIGRTMAX)" + unless $ok; + return $rtsig; +} + +sub new { + my ($rtsig, $handler, $flags) = @_; + my $sigset = POSIX::SigSet->new($rtsig); + my $sigact = POSIX::SigAction->new($handler, + $sigset, + $flags); + POSIX::sigaction($rtsig, $sigact); +} + +sub EXISTS { &_exist } +sub FETCH { my $rtsig = &_check; + my $oa = POSIX::SigAction->new(); + POSIX::sigaction($rtsig, undef, $oa); + return $oa->{HANDLER} } +sub STORE { my $rtsig = &_check; new($rtsig, $_[2], $SIGACTION_FLAGS) } +sub DELETE { delete $SIG{ &_check } } +sub CLEAR { &_exist; delete @SIG{ &POSIX::SIGRTMIN .. &POSIX::SIGRTMAX } } +sub SCALAR { &_croak; $_sigrtn + 1 } diff --git a/testsuite/input-files/perl-v5.14.2/lib/SelectSaver.pm b/testsuite/input-files/perl-v5.14.2/lib/SelectSaver.pm new file mode 100644 index 00000000..b67adff4 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/SelectSaver.pm @@ -0,0 +1,54 @@ +package SelectSaver; + +our $VERSION = '1.02'; + +=head1 NAME + +SelectSaver - save and restore selected file handle + +=head1 SYNOPSIS + + use SelectSaver; + + { + my $saver = SelectSaver->new(FILEHANDLE); + # FILEHANDLE is selected + } + # previous handle is selected + + { + my $saver = SelectSaver->new; + # new handle may be selected, or not + } + # previous handle is selected + +=head1 DESCRIPTION + +A C object contains a reference to the file handle that +was selected when it was created. If its C method gets an extra +parameter, then that parameter is selected; otherwise, the selected +file handle remains unchanged. + +When a C is destroyed, it re-selects the file handle +that was selected when it was created. + +=cut + +require 5.000; +use Carp; +use Symbol; + +sub new { + @_ >= 1 && @_ <= 2 or croak 'usage: SelectSaver->new( [FILEHANDLE] )'; + my $fh = select; + my $self = bless \$fh, $_[0]; + select qualify($_[1], caller) if @_ > 1; + $self; +} + +sub DESTROY { + my $self = $_[0]; + select $$self; +} + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/Symbol.pm b/testsuite/input-files/perl-v5.14.2/lib/Symbol.pm new file mode 100644 index 00000000..1e408b59 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Symbol.pm @@ -0,0 +1,170 @@ +package Symbol; + +=head1 NAME + +Symbol - manipulate Perl symbols and their names + +=head1 SYNOPSIS + + use Symbol; + + $sym = gensym; + open($sym, "filename"); + $_ = <$sym>; + # etc. + + ungensym $sym; # no effect + + # replace *FOO{IO} handle but not $FOO, %FOO, etc. + *FOO = geniosym; + + print qualify("x"), "\n"; # "main::x" + print qualify("x", "FOO"), "\n"; # "FOO::x" + print qualify("BAR::x"), "\n"; # "BAR::x" + print qualify("BAR::x", "FOO"), "\n"; # "BAR::x" + print qualify("STDOUT", "FOO"), "\n"; # "main::STDOUT" (global) + print qualify(\*x), "\n"; # returns \*x + print qualify(\*x, "FOO"), "\n"; # returns \*x + + use strict refs; + print { qualify_to_ref $fh } "foo!\n"; + $ref = qualify_to_ref $name, $pkg; + + use Symbol qw(delete_package); + delete_package('Foo::Bar'); + print "deleted\n" unless exists $Foo::{'Bar::'}; + +=head1 DESCRIPTION + +C creates an anonymous glob and returns a reference +to it. Such a glob reference can be used as a file or directory +handle. + +For backward compatibility with older implementations that didn't +support anonymous globs, C is also provided. +But it doesn't do anything. + +C creates an anonymous IO handle. This can be +assigned into an existing glob without affecting the non-IO portions +of the glob. + +C turns unqualified symbol names into qualified +variable names (e.g. "myvar" -E "MyPackage::myvar"). If it is given a +second parameter, C uses it as the default package; +otherwise, it uses the package of its caller. Regardless, global +variable names (e.g. "STDOUT", "ENV", "SIG") are always qualified with +"main::". + +Qualification applies only to symbol names (strings). References are +left unchanged under the assumption that they are glob references, +which are qualified by their nature. + +C is just like C except that it +returns a glob ref rather than a symbol name, so you can use the result +even if C is in effect. + +C wipes out a whole package namespace. Note +this routine is not exported by default--you may want to import it +explicitly. + +=head1 BUGS + +C is a bit too powerful. It undefines every symbol that +lives in the specified package. Since perl, for performance reasons, does not +perform a symbol table lookup each time a function is called or a global +variable is accessed, some code that has already been loaded and that makes use +of symbols in package C may stop working after you delete C, even if +you reload the C module afterwards. + +=cut + +BEGIN { require 5.005; } + +require Exporter; +@ISA = qw(Exporter); +@EXPORT = qw(gensym ungensym qualify qualify_to_ref); +@EXPORT_OK = qw(delete_package geniosym); + +$VERSION = '1.07'; + +my $genpkg = "Symbol::"; +my $genseq = 0; + +my %global = map {$_ => 1} qw(ARGV ARGVOUT ENV INC SIG STDERR STDIN STDOUT); + +# +# Note that we never _copy_ the glob; we just make a ref to it. +# If we did copy it, then SVf_FAKE would be set on the copy, and +# glob-specific behaviors (e.g. C<*$ref = \&func>) wouldn't work. +# +sub gensym () { + my $name = "GEN" . $genseq++; + my $ref = \*{$genpkg . $name}; + delete $$genpkg{$name}; + $ref; +} + +sub geniosym () { + my $sym = gensym(); + # force the IO slot to be filled + select(select $sym); + *$sym{IO}; +} + +sub ungensym ($) {} + +sub qualify ($;$) { + my ($name) = @_; + if (!ref($name) && index($name, '::') == -1 && index($name, "'") == -1) { + my $pkg; + # Global names: special character, "^xyz", or other. + if ($name =~ /^(([^a-z])|(\^[a-z_]+))\z/i || $global{$name}) { + # RGS 2001-11-05 : translate leading ^X to control-char + $name =~ s/^\^([a-z_])/'qq(\c'.$1.')'/eei; + $pkg = "main"; + } + else { + $pkg = (@_ > 1) ? $_[1] : caller; + } + $name = $pkg . "::" . $name; + } + $name; +} + +sub qualify_to_ref ($;$) { + return \*{ qualify $_[0], @_ > 1 ? $_[1] : caller }; +} + +# +# of Safe.pm lineage +# +sub delete_package ($) { + my $pkg = shift; + + # expand to full symbol table name if needed + + unless ($pkg =~ /^main::.*::$/) { + $pkg = "main$pkg" if $pkg =~ /^::/; + $pkg = "main::$pkg" unless $pkg =~ /^main::/; + $pkg .= '::' unless $pkg =~ /::$/; + } + + my($stem, $leaf) = $pkg =~ m/(.*::)(\w+::)$/; + my $stem_symtab = *{$stem}{HASH}; + return unless defined $stem_symtab and exists $stem_symtab->{$leaf}; + + + # free all the symbols in the package + + my $leaf_symtab = *{$stem_symtab->{$leaf}}{HASH}; + foreach my $name (keys %$leaf_symtab) { + undef *{$pkg . $name}; + } + + # delete the symbol table + + %$leaf_symtab = (); + delete $stem_symtab->{$leaf}; +} + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/Tie/Hash.pm b/testsuite/input-files/perl-v5.14.2/lib/Tie/Hash.pm new file mode 100644 index 00000000..1acd829c --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Tie/Hash.pm @@ -0,0 +1,268 @@ +package Tie::Hash; + +our $VERSION = '1.04'; + +=head1 NAME + +Tie::Hash, Tie::StdHash, Tie::ExtraHash - base class definitions for tied hashes + +=head1 SYNOPSIS + + package NewHash; + require Tie::Hash; + + @ISA = qw(Tie::Hash); + + sub DELETE { ... } # Provides needed method + sub CLEAR { ... } # Overrides inherited method + + + package NewStdHash; + require Tie::Hash; + + @ISA = qw(Tie::StdHash); + + # All methods provided by default, define only those needing overrides + # Accessors access the storage in %{$_[0]}; + # TIEHASH should return a reference to the actual storage + sub DELETE { ... } + + package NewExtraHash; + require Tie::Hash; + + @ISA = qw(Tie::ExtraHash); + + # All methods provided by default, define only those needing overrides + # Accessors access the storage in %{$_[0][0]}; + # TIEHASH should return an array reference with the first element being + # the reference to the actual storage + sub DELETE { + $_[0][1]->('del', $_[0][0], $_[1]); # Call the report writer + delete $_[0][0]->{$_[1]}; # $_[0]->SUPER::DELETE($_[1]) + } + + + package main; + + tie %new_hash, 'NewHash'; + tie %new_std_hash, 'NewStdHash'; + tie %new_extra_hash, 'NewExtraHash', + sub {warn "Doing \U$_[1]\E of $_[2].\n"}; + +=head1 DESCRIPTION + +This module provides some skeletal methods for hash-tying classes. See +L for a list of the functions required in order to tie a hash +to a package. The basic B package provides a C method, as well +as methods C, C and C. The B and +B packages +provide most methods for hashes described in L (the exceptions +are C and C). They cause tied hashes to behave exactly like standard hashes, +and allow for selective overwriting of methods. B grandfathers the +C method: it is used if C is not defined +in the case a class forgets to include a C method. + +For developers wishing to write their own tied hashes, the required methods +are briefly defined below. See the L section for more detailed +descriptive, as well as example code: + +=over 4 + +=item TIEHASH classname, LIST + +The method invoked by the command C. Associates a new +hash instance with the specified class. C would represent additional +arguments (along the lines of L and compatriots) needed to +complete the association. + +=item STORE this, key, value + +Store datum I into I for the tied hash I. + +=item FETCH this, key + +Retrieve the datum in I for the tied hash I. + +=item FIRSTKEY this + +Return the first key in the hash. + +=item NEXTKEY this, lastkey + +Return the next key in the hash. + +=item EXISTS this, key + +Verify that I exists with the tied hash I. + +The B implementation is a stub that simply croaks. + +=item DELETE this, key + +Delete the key I from the tied hash I. + +=item CLEAR this + +Clear all values from the tied hash I. + +=item SCALAR this + +Returns what evaluating the hash in scalar context yields. + +B does not implement this method (but B +and B do). + +=back + +=head1 Inheriting from B + +The accessor methods assume that the actual storage for the data in the tied +hash is in the hash referenced by C. Thus overwritten +C method should return a hash reference, and the remaining methods +should operate on the hash referenced by the first argument: + + package ReportHash; + our @ISA = 'Tie::StdHash'; + + sub TIEHASH { + my $storage = bless {}, shift; + warn "New ReportHash created, stored in $storage.\n"; + $storage + } + sub STORE { + warn "Storing data with key $_[1] at $_[0].\n"; + $_[0]{$_[1]} = $_[2] + } + + +=head1 Inheriting from B + +The accessor methods assume that the actual storage for the data in the tied +hash is in the hash referenced by C<(tied(%tiedhash))-E[0]>. Thus overwritten +C method should return an array reference with the first +element being a hash reference, and the remaining methods should operate on the +hash C<< %{ $_[0]->[0] } >>: + + package ReportHash; + our @ISA = 'Tie::ExtraHash'; + + sub TIEHASH { + my $class = shift; + my $storage = bless [{}, @_], $class; + warn "New ReportHash created, stored in $storage.\n"; + $storage; + } + sub STORE { + warn "Storing data with key $_[1] at $_[0].\n"; + $_[0][0]{$_[1]} = $_[2] + } + +The default C method stores "extra" arguments to tie() starting +from offset 1 in the array referenced by C; this is the +same storage algorithm as in TIEHASH subroutine above. Hence, a typical +package inheriting from B does not need to overwrite this +method. + +=head1 C, C and C + +The methods C and C are not defined in B, +B, or B. Tied hashes do not require +presence of these methods, but if defined, the methods will be called in +proper time, see L. + +C is only defined in B and B. + +If needed, these methods should be defined by the package inheriting from +B, B, or B. See L +to find out what happens when C does not exist. + +=head1 MORE INFORMATION + +The packages relating to various DBM-related implementations (F, +F, etc.) show examples of general tied hashes, as does the +L module. While these do not utilize B, they serve as +good working examples. + +=cut + +use Carp; +use warnings::register; + +sub new { + my $pkg = shift; + $pkg->TIEHASH(@_); +} + +# Grandfather "new" + +sub TIEHASH { + my $pkg = shift; + my $pkg_new = $pkg -> can ('new'); + + if ($pkg_new and $pkg ne __PACKAGE__) { + my $my_new = __PACKAGE__ -> can ('new'); + if ($pkg_new == $my_new) { + # + # Prevent recursion + # + croak "$pkg must define either a TIEHASH() or a new() method"; + } + + warnings::warnif ("WARNING: calling ${pkg}->new since " . + "${pkg}->TIEHASH is missing"); + $pkg -> new (@_); + } + else { + croak "$pkg doesn't define a TIEHASH method"; + } +} + +sub EXISTS { + my $pkg = ref $_[0]; + croak "$pkg doesn't define an EXISTS method"; +} + +sub CLEAR { + my $self = shift; + my $key = $self->FIRSTKEY(@_); + my @keys; + + while (defined $key) { + push @keys, $key; + $key = $self->NEXTKEY(@_, $key); + } + foreach $key (@keys) { + $self->DELETE(@_, $key); + } +} + +# The Tie::StdHash package implements standard perl hash behaviour. +# It exists to act as a base class for classes which only wish to +# alter some parts of their behaviour. + +package Tie::StdHash; +# @ISA = qw(Tie::Hash); # would inherit new() only + +sub TIEHASH { bless {}, $_[0] } +sub STORE { $_[0]->{$_[1]} = $_[2] } +sub FETCH { $_[0]->{$_[1]} } +sub FIRSTKEY { my $a = scalar keys %{$_[0]}; each %{$_[0]} } +sub NEXTKEY { each %{$_[0]} } +sub EXISTS { exists $_[0]->{$_[1]} } +sub DELETE { delete $_[0]->{$_[1]} } +sub CLEAR { %{$_[0]} = () } +sub SCALAR { scalar %{$_[0]} } + +package Tie::ExtraHash; + +sub TIEHASH { my $p = shift; bless [{}, @_], $p } +sub STORE { $_[0][0]{$_[1]} = $_[2] } +sub FETCH { $_[0][0]{$_[1]} } +sub FIRSTKEY { my $a = scalar keys %{$_[0][0]}; each %{$_[0][0]} } +sub NEXTKEY { each %{$_[0][0]} } +sub EXISTS { exists $_[0][0]->{$_[1]} } +sub DELETE { delete $_[0][0]->{$_[1]} } +sub CLEAR { %{$_[0][0]} = () } +sub SCALAR { scalar %{$_[0][0]} } + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/Time/HiRes.pm b/testsuite/input-files/perl-v5.14.2/lib/Time/HiRes.pm new file mode 100644 index 00000000..8f2ec213 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/Time/HiRes.pm @@ -0,0 +1,591 @@ +package Time::HiRes; + +use strict; +use vars qw($VERSION $XS_VERSION @ISA @EXPORT @EXPORT_OK $AUTOLOAD); + +require Exporter; +require DynaLoader; + +@ISA = qw(Exporter DynaLoader); + +@EXPORT = qw( ); +@EXPORT_OK = qw (usleep sleep ualarm alarm gettimeofday time tv_interval + getitimer setitimer nanosleep clock_gettime clock_getres + clock clock_nanosleep + CLOCK_HIGHRES CLOCK_MONOTONIC CLOCK_PROCESS_CPUTIME_ID + CLOCK_REALTIME CLOCK_SOFTTIME CLOCK_THREAD_CPUTIME_ID + CLOCK_TIMEOFDAY CLOCKS_PER_SEC + ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ITIMER_REALPROF + TIMER_ABSTIME + d_usleep d_ualarm d_gettimeofday d_getitimer d_setitimer + d_nanosleep d_clock_gettime d_clock_getres + d_clock d_clock_nanosleep + stat + ); + +$VERSION = '1.9721_01'; +$XS_VERSION = $VERSION; +$VERSION = eval $VERSION; + +sub AUTOLOAD { + my $constname; + ($constname = $AUTOLOAD) =~ s/.*:://; + # print "AUTOLOAD: constname = $constname ($AUTOLOAD)\n"; + die "&Time::HiRes::constant not defined" if $constname eq 'constant'; + my ($error, $val) = constant($constname); + # print "AUTOLOAD: error = $error, val = $val\n"; + if ($error) { + my (undef,$file,$line) = caller; + die "$error at $file line $line.\n"; + } + { + no strict 'refs'; + *$AUTOLOAD = sub { $val }; + } + goto &$AUTOLOAD; +} + +sub import { + my $this = shift; + for my $i (@_) { + if (($i eq 'clock_getres' && !&d_clock_getres) || + ($i eq 'clock_gettime' && !&d_clock_gettime) || + ($i eq 'clock_nanosleep' && !&d_clock_nanosleep) || + ($i eq 'clock' && !&d_clock) || + ($i eq 'nanosleep' && !&d_nanosleep) || + ($i eq 'usleep' && !&d_usleep) || + ($i eq 'ualarm' && !&d_ualarm)) { + require Carp; + Carp::croak("Time::HiRes::$i(): unimplemented in this platform"); + } + } + Time::HiRes->export_to_level(1, $this, @_); +} + +bootstrap Time::HiRes; + +# Preloaded methods go here. + +sub tv_interval { + # probably could have been done in C + my ($a, $b) = @_; + $b = [gettimeofday()] unless defined($b); + (${$b}[0] - ${$a}[0]) + ((${$b}[1] - ${$a}[1]) / 1_000_000); +} + +# Autoload methods go after =cut, and are processed by the autosplit program. + +1; +__END__ + +=head1 NAME + +Time::HiRes - High resolution alarm, sleep, gettimeofday, interval timers + +=head1 SYNOPSIS + + use Time::HiRes qw( usleep ualarm gettimeofday tv_interval nanosleep + clock_gettime clock_getres clock_nanosleep clock + stat ); + + usleep ($microseconds); + nanosleep ($nanoseconds); + + ualarm ($microseconds); + ualarm ($microseconds, $interval_microseconds); + + $t0 = [gettimeofday]; + ($seconds, $microseconds) = gettimeofday; + + $elapsed = tv_interval ( $t0, [$seconds, $microseconds]); + $elapsed = tv_interval ( $t0, [gettimeofday]); + $elapsed = tv_interval ( $t0 ); + + use Time::HiRes qw ( time alarm sleep ); + + $now_fractions = time; + sleep ($floating_seconds); + alarm ($floating_seconds); + alarm ($floating_seconds, $floating_interval); + + use Time::HiRes qw( setitimer getitimer ); + + setitimer ($which, $floating_seconds, $floating_interval ); + getitimer ($which); + + use Time::HiRes qw( clock_gettime clock_getres clock_nanosleep + ITIMER_REAL ITIMER_VIRTUAL ITIMER_PROF ITIMER_REALPROF ); + + $realtime = clock_gettime(CLOCK_REALTIME); + $resolution = clock_getres(CLOCK_REALTIME); + + clock_nanosleep(CLOCK_REALTIME, 1.5e9); + clock_nanosleep(CLOCK_REALTIME, time()*1e9 + 10e9, TIMER_ABSTIME); + + my $ticktock = clock(); + + use Time::HiRes qw( stat ); + + my @stat = stat("file"); + my @stat = stat(FH); + +=head1 DESCRIPTION + +The C module implements a Perl interface to the +C, C, C, C, and +C/C system calls, in other words, high +resolution time and timers. See the L section below and the +test scripts for usage; see your system documentation for the +description of the underlying C or C, C, +C, and C/C calls. + +If your system lacks C or an emulation of it you don't +get C or the one-argument form of C. +If your system lacks all of C, C, +C, and C, you don't get C, +C, or C. +If your system lacks both C and C you don't get +C or C. + +If you try to import an unimplemented function in the C statement +it will fail at compile time. + +If your subsecond sleeping is implemented with C instead +of C, you can mix subsecond sleeping with signals since +C does not use signals. This, however, is not portable, +and you should first check for the truth value of +C<&Time::HiRes::d_nanosleep> to see whether you have nanosleep, and +then carefully read your C C API documentation for any +peculiarities. + +If you are using C for something else than mixing sleeping +with signals, give some thought to whether Perl is the tool you should +be using for work requiring nanosecond accuracies. + +Remember that unless you are working on a I system, +any clocks and timers will be imprecise, especially so if you are working +in a pre-emptive multiuser system. Understand the difference between +I and process time (in UNIX-like systems the sum of +I and I times). Any attempt to sleep for X seconds will +most probably end up sleeping B than that, but don't be surpised +if you end up sleeping slightly B. + +The following functions can be imported from this module. +No functions are exported by default. + +=over 4 + +=item gettimeofday () + +In array context returns a two-element array with the seconds and +microseconds since the epoch. In scalar context returns floating +seconds like C (see below). + +=item usleep ( $useconds ) + +Sleeps for the number of microseconds (millionths of a second) +specified. Returns the number of microseconds actually slept. +Can sleep for more than one second, unlike the C system call. +Can also sleep for zero seconds, which often works like a I. +See also C, C, and +C. + +Do not expect usleep() to be exact down to one microsecond. + +=item nanosleep ( $nanoseconds ) + +Sleeps for the number of nanoseconds (1e9ths of a second) specified. +Returns the number of nanoseconds actually slept (accurate only to +microseconds, the nearest thousand of them). Can sleep for more than +one second. Can also sleep for zero seconds, which often works like +a I. See also C, +C, and C. + +Do not expect nanosleep() to be exact down to one nanosecond. +Getting even accuracy of one thousand nanoseconds is good. + +=item ualarm ( $useconds [, $interval_useconds ] ) + +Issues a C call; the C<$interval_useconds> is optional and +will be zero if unspecified, resulting in C-like behaviour. + +Returns the remaining time in the alarm in microseconds, or C +if an error occurred. + +ualarm(0) will cancel an outstanding ualarm(). + +Note that the interaction between alarms and sleeps is unspecified. + +=item tv_interval + +tv_interval ( $ref_to_gettimeofday [, $ref_to_later_gettimeofday] ) + +Returns the floating seconds between the two times, which should have +been returned by C. If the second argument is omitted, +then the current time is used. + +=item time () + +Returns a floating seconds since the epoch. This function can be +imported, resulting in a nice drop-in replacement for the C

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 S5O!+191F;35}ghL?EeAbrhx+h literal 0 HcmV?d00001 diff --git a/testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/autosplit.ix b/testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/autosplit.ix new file mode 100644 index 00000000..a13c556c --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/autosplit.ix @@ -0,0 +1,173 @@ +# Index created by AutoSplit for ../../lib/POSIX.pm +# (file acts as timestamp) +package POSIX; +sub usage ; +sub redef ; +sub unimpl ; +sub assert ; +sub tolower ; +sub toupper ; +sub closedir ; +sub opendir ; +sub readdir ; +sub rewinddir ; +sub errno ; +sub creat ; +sub fcntl ; +sub getgrgid ; +sub getgrnam ; +sub atan2 ; +sub cos ; +sub exp ; +sub fabs ; +sub log ; +sub pow ; +sub sin ; +sub sqrt ; +sub getpwnam ; +sub getpwuid ; +sub longjmp ; +sub setjmp ; +sub siglongjmp ; +sub sigsetjmp ; +sub kill ; +sub raise ; +sub offsetof ; +sub clearerr ; +sub fclose ; +sub fdopen ; +sub feof ; +sub fgetc ; +sub fgets ; +sub fileno ; +sub fopen ; +sub fprintf ; +sub fputc ; +sub fputs ; +sub fread ; +sub freopen ; +sub fscanf ; +sub fseek ; +sub fsync ; +sub ferror ; +sub fflush ; +sub fgetpos ; +sub fsetpos ; +sub ftell ; +sub fwrite ; +sub getc ; +sub getchar ; +sub gets ; +sub perror ; +sub printf ; +sub putc ; +sub putchar ; +sub puts ; +sub remove ; +sub rename ; +sub rewind ; +sub scanf ; +sub sprintf ; +sub sscanf ; +sub tmpfile ; +sub ungetc ; +sub vfprintf ; +sub vprintf ; +sub vsprintf ; +sub abs ; +sub atexit ; +sub atof ; +sub atoi ; +sub atol ; +sub bsearch ; +sub calloc ; +sub div ; +sub exit ; +sub free ; +sub getenv ; +sub labs ; +sub ldiv ; +sub malloc ; +sub qsort ; +sub rand ; +sub realloc ; +sub srand ; +sub system ; +sub memchr ; +sub memcmp ; +sub memcpy ; +sub memmove ; +sub memset ; +sub strcat ; +sub strchr ; +sub strcmp ; +sub strcpy ; +sub strcspn ; +sub strerror ; +sub strlen ; +sub strncat ; +sub strncmp ; +sub strncpy ; +sub strpbrk ; +sub strrchr ; +sub strspn ; +sub strstr ; +sub strtok ; +sub chmod ; +sub fstat ; +sub mkdir ; +sub stat ; +sub umask ; +sub wait ; +sub waitpid ; +sub gmtime ; +sub localtime ; +sub time ; +sub alarm ; +sub chdir ; +sub chown ; +sub execl ; +sub execle ; +sub execlp ; +sub execv ; +sub execve ; +sub execvp ; +sub fork ; +sub getegid ; +sub geteuid ; +sub getgid ; +sub getgroups ; +sub getlogin ; +sub getpgrp ; +sub getpid ; +sub getppid ; +sub getuid ; +sub isatty ; +sub link ; +sub rmdir ; +sub setbuf ; +sub setvbuf ; +sub sleep ; +sub unlink ; +sub utime ; +sub load_imports ; +package POSIX::SigAction; +sub new ; +sub handler ; +sub mask ; +sub flags ; +sub safe ; +package POSIX::SigRt; +sub _init ; +sub _croak ; +sub _getsig ; +sub _exist ; +sub _check ; +sub new ; +sub EXISTS ; +sub FETCH ; +sub STORE ; +sub DELETE ; +sub CLEAR ; +sub SCALAR ; +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/load_imports.al b/testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/load_imports.al new file mode 100644 index 00000000..219830f8 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/auto/POSIX/load_imports.al @@ -0,0 +1,231 @@ +# NOTE: Derived from ../../lib/POSIX.pm. +# Changes made here will be lost when autosplit is run again. +# See AutoSplit.pm. +package POSIX; + +#line 753 "../../lib/POSIX.pm (autosplit into ../../lib/auto/POSIX/load_imports.al)" +sub load_imports { +%EXPORT_TAGS = ( + + assert_h => [qw(assert NDEBUG)], + + ctype_h => [qw(isalnum isalpha iscntrl isdigit isgraph islower + isprint ispunct isspace isupper isxdigit tolower toupper)], + + dirent_h => [], + + errno_h => [qw(E2BIG EACCES EADDRINUSE EADDRNOTAVAIL EAFNOSUPPORT + EAGAIN EALREADY EBADF EBUSY ECHILD ECONNABORTED + ECONNREFUSED ECONNRESET EDEADLK EDESTADDRREQ EDOM EDQUOT + EEXIST EFAULT EFBIG EHOSTDOWN EHOSTUNREACH EINPROGRESS + EINTR EINVAL EIO EISCONN EISDIR ELOOP EMFILE EMLINK + EMSGSIZE ENAMETOOLONG ENETDOWN ENETRESET ENETUNREACH + ENFILE ENOBUFS ENODEV ENOENT ENOEXEC ENOLCK ENOMEM + ENOPROTOOPT ENOSPC ENOSYS ENOTBLK ENOTCONN ENOTDIR + ENOTEMPTY ENOTSOCK ENOTTY ENXIO EOPNOTSUPP EPERM + EPFNOSUPPORT EPIPE EPROCLIM EPROTONOSUPPORT EPROTOTYPE + ERANGE EREMOTE ERESTART EROFS ESHUTDOWN ESOCKTNOSUPPORT + ESPIPE ESRCH ESTALE ETIMEDOUT ETOOMANYREFS ETXTBSY + EUSERS EWOULDBLOCK EXDEV errno)], + + fcntl_h => [qw(FD_CLOEXEC F_DUPFD F_GETFD F_GETFL F_GETLK F_RDLCK + F_SETFD F_SETFL F_SETLK F_SETLKW F_UNLCK F_WRLCK + O_ACCMODE O_APPEND O_CREAT O_EXCL O_NOCTTY O_NONBLOCK + O_RDONLY O_RDWR O_TRUNC O_WRONLY + creat + SEEK_CUR SEEK_END SEEK_SET + S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG S_ISUID + S_IWGRP S_IWOTH S_IWUSR)], + + float_h => [qw(DBL_DIG DBL_EPSILON DBL_MANT_DIG + DBL_MAX DBL_MAX_10_EXP DBL_MAX_EXP + DBL_MIN DBL_MIN_10_EXP DBL_MIN_EXP + FLT_DIG FLT_EPSILON FLT_MANT_DIG + FLT_MAX FLT_MAX_10_EXP FLT_MAX_EXP + FLT_MIN FLT_MIN_10_EXP FLT_MIN_EXP + FLT_RADIX FLT_ROUNDS + LDBL_DIG LDBL_EPSILON LDBL_MANT_DIG + LDBL_MAX LDBL_MAX_10_EXP LDBL_MAX_EXP + LDBL_MIN LDBL_MIN_10_EXP LDBL_MIN_EXP)], + + grp_h => [], + + limits_h => [qw( ARG_MAX CHAR_BIT CHAR_MAX CHAR_MIN CHILD_MAX + INT_MAX INT_MIN LINK_MAX LONG_MAX LONG_MIN MAX_CANON + MAX_INPUT MB_LEN_MAX NAME_MAX NGROUPS_MAX OPEN_MAX + PATH_MAX PIPE_BUF SCHAR_MAX SCHAR_MIN SHRT_MAX SHRT_MIN + SSIZE_MAX STREAM_MAX TZNAME_MAX UCHAR_MAX UINT_MAX + ULONG_MAX USHRT_MAX _POSIX_ARG_MAX _POSIX_CHILD_MAX + _POSIX_LINK_MAX _POSIX_MAX_CANON _POSIX_MAX_INPUT + _POSIX_NAME_MAX _POSIX_NGROUPS_MAX _POSIX_OPEN_MAX + _POSIX_PATH_MAX _POSIX_PIPE_BUF _POSIX_SSIZE_MAX + _POSIX_STREAM_MAX _POSIX_TZNAME_MAX)], + + locale_h => [qw(LC_ALL LC_COLLATE LC_CTYPE LC_MESSAGES + LC_MONETARY LC_NUMERIC LC_TIME NULL + localeconv setlocale)], + + math_h => [qw(HUGE_VAL acos asin atan ceil cosh fabs floor fmod + frexp ldexp log10 modf pow sinh tan tanh)], + + pwd_h => [], + + setjmp_h => [qw(longjmp setjmp siglongjmp sigsetjmp)], + + signal_h => [qw(SA_NOCLDSTOP SA_NOCLDWAIT SA_NODEFER SA_ONSTACK + SA_RESETHAND SA_RESTART SA_SIGINFO SIGABRT SIGALRM + SIGCHLD SIGCONT SIGFPE SIGHUP SIGILL SIGINT SIGKILL + SIGPIPE %SIGRT SIGRTMIN SIGRTMAX SIGQUIT SIGSEGV SIGSTOP + SIGTERM SIGTSTP SIGTTIN SIGTTOU SIGUSR1 SIGUSR2 SIGBUS + SIGPOLL SIGPROF SIGSYS SIGTRAP SIGURG SIGVTALRM SIGXCPU SIGXFSZ + SIG_BLOCK SIG_DFL SIG_ERR SIG_IGN SIG_SETMASK SIG_UNBLOCK + raise sigaction signal sigpending sigprocmask sigsuspend)], + + stdarg_h => [], + + stddef_h => [qw(NULL offsetof)], + + stdio_h => [qw(BUFSIZ EOF FILENAME_MAX L_ctermid L_cuserid + L_tmpname NULL SEEK_CUR SEEK_END SEEK_SET + STREAM_MAX TMP_MAX stderr stdin stdout + clearerr fclose fdopen feof ferror fflush fgetc fgetpos + fgets fopen fprintf fputc fputs fread freopen + fscanf fseek fsetpos ftell fwrite getchar gets + perror putc putchar puts remove rewind + scanf setbuf setvbuf sscanf tmpfile tmpnam + ungetc vfprintf vprintf vsprintf)], + + stdlib_h => [qw(EXIT_FAILURE EXIT_SUCCESS MB_CUR_MAX NULL RAND_MAX + abort atexit atof atoi atol bsearch calloc div + free getenv labs ldiv malloc mblen mbstowcs mbtowc + qsort realloc strtod strtol strtoul wcstombs wctomb)], + + string_h => [qw(NULL memchr memcmp memcpy memmove memset strcat + strchr strcmp strcoll strcpy strcspn strerror strlen + strncat strncmp strncpy strpbrk strrchr strspn strstr + strtok strxfrm)], + + sys_stat_h => [qw(S_IRGRP S_IROTH S_IRUSR S_IRWXG S_IRWXO S_IRWXU + S_ISBLK S_ISCHR S_ISDIR S_ISFIFO S_ISGID S_ISREG + S_ISUID S_IWGRP S_IWOTH S_IWUSR S_IXGRP S_IXOTH S_IXUSR + fstat mkfifo)], + + sys_times_h => [], + + sys_types_h => [], + + sys_utsname_h => [qw(uname)], + + sys_wait_h => [qw(WEXITSTATUS WIFEXITED WIFSIGNALED WIFSTOPPED + WNOHANG WSTOPSIG WTERMSIG WUNTRACED)], + + termios_h => [qw( B0 B110 B1200 B134 B150 B1800 B19200 B200 B2400 + B300 B38400 B4800 B50 B600 B75 B9600 BRKINT CLOCAL + CREAD CS5 CS6 CS7 CS8 CSIZE CSTOPB ECHO ECHOE ECHOK + ECHONL HUPCL ICANON ICRNL IEXTEN IGNBRK IGNCR IGNPAR + INLCR INPCK ISIG ISTRIP IXOFF IXON NCCS NOFLSH OPOST + PARENB PARMRK PARODD TCIFLUSH TCIOFF TCIOFLUSH TCION + TCOFLUSH TCOOFF TCOON TCSADRAIN TCSAFLUSH TCSANOW + TOSTOP VEOF VEOL VERASE VINTR VKILL VMIN VQUIT VSTART + VSTOP VSUSP VTIME + cfgetispeed cfgetospeed cfsetispeed cfsetospeed tcdrain + tcflow tcflush tcgetattr tcsendbreak tcsetattr )], + + time_h => [qw(CLK_TCK CLOCKS_PER_SEC NULL asctime clock ctime + difftime mktime strftime tzset tzname)], + + unistd_h => [qw(F_OK NULL R_OK SEEK_CUR SEEK_END SEEK_SET + STDERR_FILENO STDIN_FILENO STDOUT_FILENO W_OK X_OK + _PC_CHOWN_RESTRICTED _PC_LINK_MAX _PC_MAX_CANON + _PC_MAX_INPUT _PC_NAME_MAX _PC_NO_TRUNC _PC_PATH_MAX + _PC_PIPE_BUF _PC_VDISABLE _POSIX_CHOWN_RESTRICTED + _POSIX_JOB_CONTROL _POSIX_NO_TRUNC _POSIX_SAVED_IDS + _POSIX_VDISABLE _POSIX_VERSION _SC_ARG_MAX + _SC_CHILD_MAX _SC_CLK_TCK _SC_JOB_CONTROL + _SC_NGROUPS_MAX _SC_OPEN_MAX _SC_PAGESIZE _SC_SAVED_IDS + _SC_STREAM_MAX _SC_TZNAME_MAX _SC_VERSION + _exit access ctermid cuserid + dup2 dup execl execle execlp execv execve execvp + fpathconf fsync getcwd getegid geteuid getgid getgroups + getpid getuid isatty lseek pathconf pause setgid setpgid + setsid setuid sysconf tcgetpgrp tcsetpgrp ttyname)], + + utime_h => [], + +); + +# Exporter::export_tags(); +{ + # De-duplicate the export list: + my %export; + @export{map {@$_} values %EXPORT_TAGS} = (); + # Doing the de-dup with a temporary hash has the advantage that the SVs in + # @EXPORT are actually shared hash key scalars, which will save some memory. + push @EXPORT, keys %export; +} + +@EXPORT_OK = qw( + abs + alarm + atan2 + chdir + chmod + chown + close + closedir + cos + exit + exp + fcntl + fileno + fork + getc + getgrgid + getgrnam + getlogin + getpgrp + getppid + getpwnam + getpwuid + gmtime + isatty + kill + lchown + link + localtime + log + mkdir + nice + open + opendir + pipe + printf + rand + read + readdir + rename + rewinddir + rmdir + sin + sleep + sprintf + sqrt + srand + stat + system + time + times + umask + unlink + utime + wait + waitpid + write +); + +require Exporter; +} + +# end of POSIX::SigAction::load_imports +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/.exists b/testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/.exists new file mode 100644 index 00000000..e69de29b diff --git a/testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/HiRes.bs b/testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/HiRes.bs new file mode 100644 index 00000000..e69de29b diff --git a/testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/HiRes.so b/testsuite/input-files/perl-v5.14.2/lib/auto/Time/HiRes/HiRes.so new file mode 100755 index 0000000000000000000000000000000000000000..f02713d03d041fa600a7b5866f1edb96b5b68916 GIT binary patch literal 31873 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 +} + +sub get_attr { + $Fattr->{$_[0]} = [1] unless $Fattr->{$_[0]}; + return $Fattr->{$_[0]}; +} + +if ($] < 5.009) { + *get_fields = sub { + # Shut up a possible typo warning. + () = \%{$_[0].'::FIELDS'}; + my $f = \%{$_[0].'::FIELDS'}; + + # should be centralized in fields? perhaps + # fields::mk_FIELDS_be_OK. Peh. As long as %{ $package . '::FIELDS' } + # is used here anyway, it doesn't matter. + bless $f, 'pseudohash' if (ref($f) ne 'pseudohash'); + + return $f; + } +} +else { + *get_fields = sub { + # Shut up a possible typo warning. + () = \%{$_[0].'::FIELDS'}; + return \%{$_[0].'::FIELDS'}; + } +} + +sub import { + my $class = shift; + + return SUCCESS unless @_; + + # List of base classes from which we will inherit %FIELDS. + my $fields_base; + + my $inheritor = caller(0); + my @isa_classes; + + my @bases; + foreach my $base (@_) { + if ( $inheritor eq $base ) { + warn "Class '$inheritor' tried to inherit from itself\n"; + } + + next if grep $_->isa($base), ($inheritor, @bases); + + if (has_version($base)) { + ${$base.'::VERSION'} = '-1, set by base.pm' + unless defined ${$base.'::VERSION'}; + } + else { + my $sigdie; + { + local $SIG{__DIE__}; + eval "require $base"; + # Only ignore "Can't locate" errors from our eval require. + # Other fatal errors (syntax etc) must be reported. + die if $@ && $@ !~ /^Can't locate .*? at \(eval /; + unless (%{"$base\::"}) { + require Carp; + local $" = " "; + Carp::croak(<[0] = @$battr; + + if( keys %$dfields ) { + warn <<"END"; +$derived is inheriting from $base but already has its own fields! +This will cause problems. Be sure you use base BEFORE declaring fields. +END + + } + + # Iterate through the base's fields adding all the non-private + # ones to the derived class. Hang on to the original attribute + # (Public, Private, etc...) and add Inherited. + # This is all too complicated to do efficiently with add_fields(). + while (my($k,$v) = each %$bfields) { + my $fno; + if ($fno = $dfields->{$k} and $fno != $v) { + require Carp; + Carp::croak ("Inherited fields can't override existing fields"); + } + + if( $battr->[$v] & PRIVATE ) { + $dattr->[$v] = PRIVATE | INHERITED; + } + else { + $dattr->[$v] = INHERITED | $battr->[$v]; + $dfields->{$k} = $v; + } + } + + foreach my $idx (1..$#{$battr}) { + next if defined $dattr->[$idx]; + $dattr->[$idx] = $battr->[$idx] & INHERITED; + } +} + + +1; + +__END__ + +=head1 NAME + +base - Establish an ISA relationship with base classes at compile time + +=head1 SYNOPSIS + + package Baz; + use base qw(Foo Bar); + +=head1 DESCRIPTION + +Unless you are using the C pragma, consider this module discouraged +in favor of the lighter-weight C. + +Allows you to both load one or more modules, while setting up inheritance from +those modules at the same time. Roughly similar in effect to + + package Baz; + BEGIN { + require Foo; + require Bar; + push @ISA, qw(Foo Bar); + } + +C employs some heuristics to determine if a module has already been +loaded, if it has it doesn't try again. If C tries to C the +module it will not die if it cannot find the module's file, but will die on any +other error. After all this, should your base class be empty, containing no +symbols, it will die. This is useful for inheriting from classes in the same +file as yourself, like so: + + package Foo; + sub exclaim { "I can have such a thing?!" } + + package Bar; + use base "Foo"; + +If $VERSION is not detected even after loading it, will define $VERSION +in the base package, setting it to the string C<-1, set by base.pm>. + +C will also initialize the fields if one of the base classes has it. +Multiple inheritance of fields is B supported, if two or more base classes +each have inheritable fields the 'base' pragma will croak. See L, +L and L for a description of this feature. + +The base class' C method is B called. + + +=head1 DIAGNOSTICS + +=over 4 + +=item Base class package "%s" is empty. + +base.pm was unable to require the base package, because it was not +found in your path. + +=item Class 'Foo' tried to inherit from itself + +Attempting to inherit from yourself generates a warning. + + package Foo; + use base 'Foo'; + +=back + +=head1 HISTORY + +This module was introduced with Perl 5.004_04. + +=head1 CAVEATS + +Due to the limitations of the implementation, you must use +base I you declare any of your own fields. + + +=head1 SEE ALSO + +L + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/constant.pm b/testsuite/input-files/perl-v5.14.2/lib/constant.pm new file mode 100644 index 00000000..22566ce2 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/constant.pm @@ -0,0 +1,397 @@ +package constant; +use 5.005; +use strict; +use warnings::register; + +use vars qw($VERSION %declared); +$VERSION = '1.21'; + +#======================================================================= + +# Some names are evil choices. +my %keywords = map +($_, 1), qw{ BEGIN INIT CHECK END DESTROY AUTOLOAD }; +$keywords{UNITCHECK}++ if $] > 5.009; + +my %forced_into_main = map +($_, 1), + qw{ STDIN STDOUT STDERR ARGV ARGVOUT ENV INC SIG }; + +my %forbidden = (%keywords, %forced_into_main); + +my $str_end = $] >= 5.006 ? "\\z" : "\\Z"; +my $normal_constant_name = qr/^_?[^\W_0-9]\w*$str_end/; +my $tolerable = qr/^[A-Za-z_]\w*$str_end/; +my $boolean = qr/^[01]?$str_end/; + +BEGIN { + # We'd like to do use constant _CAN_PCS => $] > 5.009002 + # but that's a bit tricky before we load the constant module :-) + # By doing this, we save 1 run time check for *every* call to import. + no strict 'refs'; + my $const = $] > 5.009002; + *_CAN_PCS = sub () {$const}; +} + +#======================================================================= +# import() - import symbols into user's namespace +# +# What we actually do is define a function in the caller's namespace +# which returns the value. The function we create will normally +# be inlined as a constant, thereby avoiding further sub calling +# overhead. +#======================================================================= +sub import { + my $class = shift; + return unless @_; # Ignore 'use constant;' + my $constants; + my $multiple = ref $_[0]; + my $pkg = caller; + my $flush_mro; + my $symtab; + + if (_CAN_PCS) { + no strict 'refs'; + $symtab = \%{$pkg . '::'}; + }; + + if ( $multiple ) { + if (ref $_[0] ne 'HASH') { + require Carp; + Carp::croak("Invalid reference type '".ref(shift)."' not 'HASH'"); + } + $constants = shift; + } else { + unless (defined $_[0]) { + require Carp; + Carp::croak("Can't use undef as constant name"); + } + $constants->{+shift} = undef; + } + + foreach my $name ( keys %$constants ) { + # Normal constant name + if ($name =~ $normal_constant_name and !$forbidden{$name}) { + # Everything is okay + + # Name forced into main, but we're not in main. Fatal. + } elsif ($forced_into_main{$name} and $pkg ne 'main') { + require Carp; + Carp::croak("Constant name '$name' is forced into main::"); + + # Starts with double underscore. Fatal. + } elsif ($name =~ /^__/) { + require Carp; + Carp::croak("Constant name '$name' begins with '__'"); + + # Maybe the name is tolerable + } elsif ($name =~ $tolerable) { + # Then we'll warn only if you've asked for warnings + if (warnings::enabled()) { + if ($keywords{$name}) { + warnings::warn("Constant name '$name' is a Perl keyword"); + } elsif ($forced_into_main{$name}) { + warnings::warn("Constant name '$name' is " . + "forced into package main::"); + } + } + + # Looks like a boolean + # use constant FRED == fred; + } elsif ($name =~ $boolean) { + require Carp; + if (@_) { + Carp::croak("Constant name '$name' is invalid"); + } else { + Carp::croak("Constant name looks like boolean value"); + } + + } else { + # Must have bad characters + require Carp; + Carp::croak("Constant name '$name' has invalid characters"); + } + + { + no strict 'refs'; + my $full_name = "${pkg}::$name"; + $declared{$full_name}++; + if ($multiple || @_ == 1) { + my $scalar = $multiple ? $constants->{$name} : $_[0]; + + # Work around perl bug #xxxxx: Sub names (actually glob + # names in general) ignore the UTF8 flag. So we have to + # turn it off to get the "right" symbol table entry. + utf8::is_utf8 $name and utf8::encode $name; + + # The constant serves to optimise this entire block out on + # 5.8 and earlier. + if (_CAN_PCS && $symtab && !exists $symtab->{$name}) { + # No typeglob yet, so we can use a reference as space- + # efficient proxy for a constant subroutine + # The check in Perl_ck_rvconst knows that inlinable + # constants from cv_const_sv are read only. So we have to: + Internals::SvREADONLY($scalar, 1); + $symtab->{$name} = \$scalar; + ++$flush_mro; + } else { + *$full_name = sub () { $scalar }; + } + } elsif (@_) { + my @list = @_; + *$full_name = sub () { @list }; + } else { + *$full_name = sub () { }; + } + } + } + # Flush the cache exactly once if we make any direct symbol table changes. + mro::method_changed_in($pkg) if _CAN_PCS && $flush_mro; +} + +1; + +__END__ + +=head1 NAME + +constant - Perl pragma to declare constants + +=head1 SYNOPSIS + + use constant PI => 4 * atan2(1, 1); + use constant DEBUG => 0; + + print "Pi equals ", PI, "...\n" if DEBUG; + + use constant { + SEC => 0, + MIN => 1, + HOUR => 2, + MDAY => 3, + MON => 4, + YEAR => 5, + WDAY => 6, + YDAY => 7, + ISDST => 8, + }; + + use constant WEEKDAYS => qw( + Sunday Monday Tuesday Wednesday Thursday Friday Saturday + ); + + print "Today is ", (WEEKDAYS)[ (localtime)[WDAY] ], ".\n"; + +=head1 DESCRIPTION + +This pragma allows you to declare constants at compile-time. + +When you declare a constant such as C using the method shown +above, each machine your script runs upon can have as many digits +of accuracy as it can use. Also, your program will be easier to +read, more likely to be maintained (and maintained correctly), and +far less likely to send a space probe to the wrong planet because +nobody noticed the one equation in which you wrote C<3.14195>. + +When a constant is used in an expression, Perl replaces it with its +value at compile time, and may then optimize the expression further. +In particular, any code in an C block will be optimized +away if the constant is false. + +=head1 NOTES + +As with all C directives, defining a constant happens at +compile time. Thus, it's probably not correct to put a constant +declaration inside of a conditional statement (like C). + +Constants defined using this module cannot be interpolated into +strings like variables. However, concatenation works just fine: + + print "Pi equals PI...\n"; # WRONG: does not expand "PI" + print "Pi equals ".PI."...\n"; # right + +Even though a reference may be declared as a constant, the reference may +point to data which may be changed, as this code shows. + + use constant ARRAY => [ 1,2,3,4 ]; + print ARRAY->[1]; + ARRAY->[1] = " be changed"; + print ARRAY->[1]; + +Dereferencing constant references incorrectly (such as using an array +subscript on a constant hash reference, or vice versa) will be trapped at +compile time. + +Constants belong to the package they are defined in. To refer to a +constant defined in another package, specify the full package name, as +in C. Constants may be exported by modules, +and may also be called as either class or instance methods, that is, +as C<< Some::Package->CONSTANT >> or as C<< $obj->CONSTANT >> where +C<$obj> is an instance of C. Subclasses may define +their own constants to override those in their base class. + +The use of all caps for constant names is merely a convention, +although it is recommended in order to make constants stand out +and to help avoid collisions with other barewords, keywords, and +subroutine names. Constant names must begin with a letter or +underscore. Names beginning with a double underscore are reserved. Some +poor choices for names will generate warnings, if warnings are enabled at +compile time. + +=head2 List constants + +Constants may be lists of more (or less) than one value. A constant +with no values evaluates to C in scalar context. Note that +constants with more than one value do I return their last value in +scalar context as one might expect. They currently return the number +of values, but B. Do not use constants +with multiple values in scalar context. + +B This implies that the expression defining the value of a +constant is evaluated in list context. This may produce surprises: + + use constant TIMESTAMP => localtime; # WRONG! + use constant TIMESTAMP => scalar localtime; # right + +The first line above defines C as a 9-element list, as +returned by C in list context. To set it to the string +returned by C in scalar context, an explicit C +keyword is required. + +List constants are lists, not arrays. To index or slice them, they +must be placed in parentheses. + + my @workdays = WEEKDAYS[1 .. 5]; # WRONG! + my @workdays = (WEEKDAYS)[1 .. 5]; # right + +=head2 Defining multiple constants at once + +Instead of writing multiple C statements, you may define +multiple constants in a single statement by giving, instead of the +constant name, a reference to a hash where the keys are the names of +the constants to be defined. Obviously, all constants defined using +this method must have a single value. + + use constant { + FOO => "A single value", + BAR => "This", "won't", "work!", # Error! + }; + +This is a fundamental limitation of the way hashes are constructed in +Perl. The error messages produced when this happens will often be +quite cryptic -- in the worst case there may be none at all, and +you'll only later find that something is broken. + +When defining multiple constants, you cannot use the values of other +constants defined in the same declaration. This is because the +calling package doesn't know about any constant within that group +until I the C statement is finished. + + use constant { + BITMASK => 0xAFBAEBA8, + NEGMASK => ~BITMASK, # Error! + }; + +=head2 Magic constants + +Magical values and references can be made into constants at compile +time, allowing for way cool stuff like this. (These error numbers +aren't totally portable, alas.) + + use constant E2BIG => ($! = 7); + print E2BIG, "\n"; # something like "Arg list too long" + print 0+E2BIG, "\n"; # "7" + +You can't produce a tied constant by giving a tied scalar as the +value. References to tied variables, however, can be used as +constants without any problems. + +=head1 TECHNICAL NOTES + +In the current implementation, scalar constants are actually +inlinable subroutines. As of version 5.004 of Perl, the appropriate +scalar constant is inserted directly in place of some subroutine +calls, thereby saving the overhead of a subroutine call. See +L for details about how and when this +happens. + +In the rare case in which you need to discover at run time whether a +particular constant has been declared via this module, you may use +this function to examine the hash C<%constant::declared>. If the given +constant name does not include a package name, the current package is +used. + + sub declared ($) { + use constant 1.01; # don't omit this! + my $name = shift; + $name =~ s/^::/main::/; + my $pkg = caller; + my $full_name = $name =~ /::/ ? $name : "${pkg}::$name"; + $constant::declared{$full_name}; + } + +=head1 CAVEATS + +In the current version of Perl, list constants are not inlined +and some symbols may be redefined without generating a warning. + +It is not possible to have a subroutine or a keyword with the same +name as a constant in the same package. This is probably a Good Thing. + +A constant with a name in the list C is not allowed anywhere but in package C, for +technical reasons. + +Unlike constants in some languages, these cannot be overridden +on the command line or via environment variables. + +You can get into trouble if you use constants in a context which +automatically quotes barewords (as is true for any subroutine call). +For example, you can't say C<$hash{CONSTANT}> because C will +be interpreted as a string. Use C<$hash{CONSTANT()}> or +C<$hash{+CONSTANT}> to prevent the bareword quoting mechanism from +kicking in. Similarly, since the C<< => >> operator quotes a bareword +immediately to its left, you have to say C<< CONSTANT() => 'value' >> +(or simply use a comma in place of the big arrow) instead of +C<< CONSTANT => 'value' >>. + +=head1 SEE ALSO + +L - Facility for creating read-only scalars, arrays, hashes. + +L - Facility for creating read-only variables. Similar to C, +but uses C instead of C. + +L - Make read-only variables via attribute + +L - Perl extension to the C scalar flag + +L - A selection of general-utility hash subroutines (mostly +to lock/unlock keys and values) + +=head1 BUGS + +Please report any bugs or feature requests via the perlbug(1) utility. + +=head1 AUTHORS + +Tom Phoenix, EFE, with help from +many other folks. + +Multiple constant declarations at once added by Casey West, +EFE. + +Documentation mostly rewritten by Ilmari Karonen, +EFE. + +This program is maintained by the Perl 5 Porters. +The CPAN distribution is maintained by SEbastien Aperghis-Tramoni +EFE. + +=head1 COPYRIGHT & LICENSE + +Copyright (C) 1997, 1999 Tom Phoenix + +This module is free software; you can redistribute it or modify it +under the same terms as Perl itself. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/feature.pm b/testsuite/input-files/perl-v5.14.2/lib/feature.pm new file mode 100644 index 00000000..9d666adb --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/feature.pm @@ -0,0 +1,249 @@ +package feature; + +our $VERSION = '1.20'; + +# (feature name) => (internal name, used in %^H) +my %feature = ( + switch => 'feature_switch', + say => "feature_say", + state => "feature_state", + unicode_strings => "feature_unicode", +); + +# This gets set (for now) in $^H as well as in %^H, +# for runtime speed of the uc/lc/ucfirst/lcfirst functions. +# See HINT_UNI_8_BIT in perl.h. +our $hint_uni8bit = 0x00000800; + +# NB. the latest bundle must be loaded by the -E switch (see toke.c) + +my %feature_bundle = ( + "5.10" => [qw(switch say state)], + "5.11" => [qw(switch say state unicode_strings)], + "5.12" => [qw(switch say state unicode_strings)], + "5.13" => [qw(switch say state unicode_strings)], + "5.14" => [qw(switch say state unicode_strings)], +); + +# special case +$feature_bundle{"5.9.5"} = $feature_bundle{"5.10"}; + +# TODO: +# - think about versioned features (use feature switch => 2) + +=head1 NAME + +feature - Perl pragma to enable new features + +=head1 SYNOPSIS + + use feature qw(switch say); + given ($foo) { + when (1) { say "\$foo == 1" } + when ([2,3]) { say "\$foo == 2 || \$foo == 3" } + when (/^a[bc]d$/) { say "\$foo eq 'abd' || \$foo eq 'acd'" } + when ($_ > 100) { say "\$foo > 100" } + default { say "None of the above" } + } + + use feature ':5.10'; # loads all features available in perl 5.10 + +=head1 DESCRIPTION + +It is usually impossible to add new syntax to Perl without breaking +some existing programs. This pragma provides a way to minimize that +risk. New syntactic constructs, or new semantic meanings to older +constructs, can be enabled by C, and will be parsed +only when the appropriate feature pragma is in scope. + +=head2 Lexical effect + +Like other pragmas (C, for example), features have a lexical +effect. C will only make the feature "foo" available +from that point to the end of the enclosing block. + + { + use feature 'say'; + say "say is available here"; + } + print "But not here.\n"; + +=head2 C + +Features can also be turned off by using C. This too +has lexical effect. + + use feature 'say'; + say "say is available here"; + { + no feature 'say'; + print "But not here.\n"; + } + say "Yet it is here."; + +C with no features specified will turn off all features. + +=head2 The 'switch' feature + +C tells the compiler to enable the Perl 6 +given/when construct. + +See L for details. + +=head2 The 'say' feature + +C tells the compiler to enable the Perl 6 +C function. + +See L for details. + +=head2 the 'state' feature + +C tells the compiler to enable C +variables. + +See L for details. + +=head2 the 'unicode_strings' feature + +C tells the compiler to use Unicode semantics +in all string operations executed within its scope (unless they are also +within the scope of either C or C). The same applies +to all regular expressions compiled within the scope, even if executed outside +it. + +C tells the compiler to use the traditional +Perl semantics wherein the native character set semantics is used unless it is +clear to Perl that Unicode is desired. This can lead to some surprises +when the behavior suddenly changes. (See +L for details.) For this reason, if you are +potentially using Unicode in your program, the +C subpragma is B recommended. + +This subpragma is available starting with Perl 5.11.3, but was not fully +implemented until 5.13.8. + +=head1 FEATURE BUNDLES + +It's possible to load a whole slew of features in one go, using +a I. The name of a feature bundle is prefixed with +a colon, to distinguish it from an actual feature. At present, the +only feature bundle is C which is equivalent +to C. + +Specifying sub-versions such as the C<0> in C<5.10.0> in feature bundles has +no effect: feature bundles are guaranteed to be the same for all sub-versions. + +=head1 IMPLICIT LOADING + +There are two ways to load the C pragma implicitly : + +=over 4 + +=item * + +By using the C<-E> switch on the command-line instead of C<-e>. It enables +all available features in the main compilation unit (that is, the one-liner.) + +=item * + +By requiring explicitly a minimal Perl version number for your program, with +the C construct, and when the version is higher than or equal to +5.10.0. That is, + + use 5.10.0; + +will do an implicit + + use feature ':5.10'; + +and so on. Note how the trailing sub-version is automatically stripped from the +version. + +But to avoid portability warnings (see L), you may prefer: + + use 5.010; + +with the same effect. + +=back + +=cut + +sub import { + my $class = shift; + if (@_ == 0) { + croak("No features specified"); + } + while (@_) { + my $name = shift(@_); + if (substr($name, 0, 1) eq ":") { + my $v = substr($name, 1); + if (!exists $feature_bundle{$v}) { + $v =~ s/^([0-9]+)\.([0-9]+).[0-9]+$/$1.$2/; + if (!exists $feature_bundle{$v}) { + unknown_feature_bundle(substr($name, 1)); + } + } + unshift @_, @{$feature_bundle{$v}}; + next; + } + if (!exists $feature{$name}) { + unknown_feature($name); + } + $^H{$feature{$name}} = 1; + $^H |= $hint_uni8bit if $name eq 'unicode_strings'; + } +} + +sub unimport { + my $class = shift; + + # A bare C should disable *all* features + if (!@_) { + delete @^H{ values(%feature) }; + $^H &= ~ $hint_uni8bit; + return; + } + + while (@_) { + my $name = shift; + if (substr($name, 0, 1) eq ":") { + my $v = substr($name, 1); + if (!exists $feature_bundle{$v}) { + $v =~ s/^([0-9]+)\.([0-9]+).[0-9]+$/$1.$2/; + if (!exists $feature_bundle{$v}) { + unknown_feature_bundle(substr($name, 1)); + } + } + unshift @_, @{$feature_bundle{$v}}; + next; + } + if (!exists($feature{$name})) { + unknown_feature($name); + } + else { + delete $^H{$feature{$name}}; + $^H &= ~ $hint_uni8bit if $name eq 'unicode_strings'; + } + } +} + +sub unknown_feature { + my $feature = shift; + croak(sprintf('Feature "%s" is not supported by Perl %vd', + $feature, $^V)); +} + +sub unknown_feature_bundle { + my $feature = shift; + croak(sprintf('Feature bundle "%s" is not supported by Perl %vd', + $feature, $^V)); +} + +sub croak { + require Carp; + Carp::croak(@_); +} + +1; diff --git a/testsuite/input-files/perl-v5.14.2/lib/overload.pm b/testsuite/input-files/perl-v5.14.2/lib/overload.pm new file mode 100644 index 00000000..3abde68b --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/overload.pm @@ -0,0 +1,1701 @@ +package overload; + +our $VERSION = '1.13'; + +sub nil {} + +sub OVERLOAD { + $package = shift; + my %arg = @_; + my ($sub, $fb); + $ {$package . "::OVERLOAD"}{dummy}++; # Register with magic by touching. + $fb = ${$package . "::()"}; # preserve old fallback value RT#68196 + *{$package . "::()"} = \&nil; # Make it findable via fetchmethod. + for (keys %arg) { + if ($_ eq 'fallback') { + $fb = $arg{$_}; + } else { + $sub = $arg{$_}; + if (not ref $sub and $sub !~ /::/) { + $ {$package . "::(" . $_} = $sub; + $sub = \&nil; + } + #print STDERR "Setting `$ {'package'}::\cO$_' to \\&`$sub'.\n"; + *{$package . "::(" . $_} = \&{ $sub }; + } + } + ${$package . "::()"} = $fb; # Make it findable too (fallback only). +} + +sub import { + $package = (caller())[0]; + # *{$package . "::OVERLOAD"} = \&OVERLOAD; + shift; + $package->overload::OVERLOAD(@_); +} + +sub unimport { + $package = (caller())[0]; + ${$package . "::OVERLOAD"}{dummy}++; # Upgrade the table + shift; + for (@_) { + if ($_ eq 'fallback') { + undef $ {$package . "::()"}; + } else { + delete $ {$package . "::"}{"(" . $_}; + } + } +} + +sub Overloaded { + my $package = shift; + $package = ref $package if ref $package; + $package->can('()'); +} + +sub ov_method { + my $globref = shift; + return undef unless $globref; + my $sub = \&{*$globref}; + require Scalar::Util; + return $sub + if Scalar::Util::refaddr($sub) != Scalar::Util::refaddr(\&nil); + return shift->can($ {*$globref}); +} + +sub OverloadedStringify { + my $package = shift; + $package = ref $package if ref $package; + #$package->can('(""') + ov_method mycan($package, '(""'), $package + or ov_method mycan($package, '(0+'), $package + or ov_method mycan($package, '(bool'), $package + or ov_method mycan($package, '(nomethod'), $package; +} + +sub Method { + my $package = shift; + if(ref $package) { + local $@; + local $!; + require Scalar::Util; + $package = Scalar::Util::blessed($package); + return undef if !defined $package; + } + #my $meth = $package->can('(' . shift); + ov_method mycan($package, '(' . shift), $package; + #return $meth if $meth ne \&nil; + #return $ {*{$meth}}; +} + +sub AddrRef { + my $package = ref $_[0]; + return "$_[0]" unless $package; + + local $@; + local $!; + require Scalar::Util; + my $class = Scalar::Util::blessed($_[0]); + my $class_prefix = defined($class) ? "$class=" : ""; + my $type = Scalar::Util::reftype($_[0]); + my $addr = Scalar::Util::refaddr($_[0]); + return sprintf("%s%s(0x%x)", $class_prefix, $type, $addr); +} + +*StrVal = *AddrRef; + +sub mycan { # Real can would leave stubs. + my ($package, $meth) = @_; + + local $@; + local $!; + require mro; + + my $mro = mro::get_linear_isa($package); + foreach my $p (@$mro) { + my $fqmeth = $p . q{::} . $meth; + return \*{$fqmeth} if defined &{$fqmeth}; + } + + return undef; +} + +%constants = ( + 'integer' => 0x1000, # HINT_NEW_INTEGER + 'float' => 0x2000, # HINT_NEW_FLOAT + 'binary' => 0x4000, # HINT_NEW_BINARY + 'q' => 0x8000, # HINT_NEW_STRING + 'qr' => 0x10000, # HINT_NEW_RE + ); + +%ops = ( with_assign => "+ - * / % ** << >> x .", + assign => "+= -= *= /= %= **= <<= >>= x= .=", + num_comparison => "< <= > >= == !=", + '3way_comparison'=> "<=> cmp", + str_comparison => "lt le gt ge eq ne", + binary => '& &= | |= ^ ^=', + unary => "neg ! ~", + mutators => '++ --', + func => "atan2 cos sin exp abs log sqrt int", + conversion => 'bool "" 0+ qr', + iterators => '<>', + filetest => "-X", + dereferencing => '${} @{} %{} &{} *{}', + matching => '~~', + special => 'nomethod fallback ='); + +use warnings::register; +sub constant { + # Arguments: what, sub + while (@_) { + if (@_ == 1) { + warnings::warnif ("Odd number of arguments for overload::constant"); + last; + } + elsif (!exists $constants {$_ [0]}) { + warnings::warnif ("`$_[0]' is not an overloadable type"); + } + elsif (!ref $_ [1] || "$_[1]" !~ /(^|=)CODE\(0x[0-9a-f]+\)$/) { + # Can't use C above as code references can be + # blessed, and C would return the package the ref is blessed into. + if (warnings::enabled) { + $_ [1] = "undef" unless defined $_ [1]; + warnings::warn ("`$_[1]' is not a code reference"); + } + } + else { + $^H{$_[0]} = $_[1]; + $^H |= $constants{$_[0]}; + } + shift, shift; + } +} + +sub remove_constant { + # Arguments: what, sub + while (@_) { + delete $^H{$_[0]}; + $^H &= ~ $constants{$_[0]}; + shift, shift; + } +} + +1; + +__END__ + +=head1 NAME + +overload - Package for overloading Perl operations + +=head1 SYNOPSIS + + package SomeThing; + + use overload + '+' => \&myadd, + '-' => \&mysub; + # etc + ... + + package main; + $a = SomeThing->new( 57 ); + $b = 5 + $a; + ... + if (overload::Overloaded $b) {...} + ... + $strval = overload::StrVal $b; + +=head1 DESCRIPTION + +This pragma allows overloading of Perl's operators for a class. +To overload built-in functions, see L instead. + +=head2 Fundamentals + +=head3 Declaration + +Arguments of the C directive are (key, value) pairs. +For the full set of legal keys, see L below. + +Operator implementations (the values) can be subroutines, +references to subroutines, or anonymous subroutines +- in other words, anything legal inside a C<&{ ... }> call. +Values specified as strings are interpreted as method names. +Thus + + package Number; + use overload + "-" => "minus", + "*=" => \&muas, + '""' => sub { ...; }; + +declares that subtraction is to be implemented by method C +in the class C (or one of its base classes), +and that the function C is to be used for the +assignment form of multiplication, C<*=>. +It also defines an anonymous subroutine to implement stringification: +this is called whenever an object blessed into the package C +is used in a string context (this subroutine might, for example, +return the number as a Roman numeral). + +=head3 Calling Conventions and Magic Autogeneration + +The following sample implementation of C (which assumes +that C objects are simply blessed references to scalars) +illustrates the calling conventions: + + package Number; + sub minus { + my ($self, $other, $swap) = @_; + my $result = $$self - $other; # * + $result = -$result if $swap; + ref $result ? $result : bless \$result; + } + # * may recurse once - see table below + +Three arguments are passed to all subroutines specified in the +C directive (with one exception - see L). +The first of these is the operand providing the overloaded +operator implementation - +in this case, the object whose C method is being called. + +The second argument is the other operand, or C in the +case of a unary operator. + +The third argument is set to TRUE if (and only if) the two +operands have been swapped. Perl may do this to ensure that the +first argument (C<$self>) is an object implementing the overloaded +operation, in line with general object calling conventions. +For example, if C<$x> and C<$y> are Cs: + + operation | generates a call to + ============|====================== + $x - $y | minus($x, $y, '') + $x - 7 | minus($x, 7, '') + 7 - $x | minus($x, 7, 1) + +Perl may also use C to implement other operators which +have not been specified in the C directive, +according to the rules for L described later. +For example, the C above declared no subroutine +for any of the operators C<-->, C (the overload key for +unary minus), or C<-=>. Thus + + operation | generates a call to + ============|====================== + -$x | minus($x, 0, 1) + $x-- | minus($x, 1, undef) + $x -= 3 | minus($x, 3, undef) + +Note the Cs: +where autogeneration results in the method for a standard +operator which does not change either of its operands, such +as C<->, being used to implement an operator which changes +the operand ("mutators": here, C<--> and C<-=>), +Perl passes undef as the third argument. +This still evaluates as FALSE, consistent with the fact that +the operands have not been swapped, but gives the subroutine +a chance to alter its behaviour in these cases. + +In all the above examples, C is required +only to return the result of the subtraction: +Perl takes care of the assignment to $x. +In fact, such methods should I modify their operands, +even if C is passed as the third argument +(see L). + +The same is not true of implementations of C<++> and C<-->: +these are expected to modify their operand. +An appropriate implementation of C<--> might look like + + use overload '--' => "decr", + # ... + sub decr { --${$_[0]}; } + +=head3 Mathemagic, Mutators, and Copy Constructors + +The term 'mathemagic' describes the overloaded implementation +of mathematical operators. +Mathemagical operations raise an issue. +Consider the code: + + $a = $b; + --$a; + +If C<$a> and C<$b> are scalars then after these statements + + $a == $b - 1 + +An object, however, is a reference to blessed data, so if +C<$a> and C<$b> are objects then the assignment C<$a = $b> +copies only the reference, leaving C<$a> and C<$b> referring +to the same object data. +One might therefore expect the operation C<--$a> to decrement +C<$b> as well as C<$a>. +However, this would not be consistent with how we expect the +mathematical operators to work. + +Perl resolves this dilemma by transparently calling a copy +constructor before calling a method defined to implement +a mutator (C<-->, C<+=>, and so on.). +In the above example, when Perl reaches the decrement +statement, it makes a copy of the object data in C<$a> and +assigns to C<$a> a reference to the copied data. +Only then does it call C, which alters the copied +data, leaving C<$b> unchanged. +Thus the object metaphor is preserved as far as possible, +while mathemagical operations still work according to the +arithmetic metaphor. + +Note: the preceding paragraph describes what happens when +Perl autogenerates the copy constructor for an object based +on a scalar. +For other cases, see L. + +=head2 Overloadable Operations + +The complete list of keys that can be specified in the C +directive are given, separated by spaces, in the values of the +hash C<%overload::ops>: + + with_assign => '+ - * / % ** << >> x .', + assign => '+= -= *= /= %= **= <<= >>= x= .=', + num_comparison => '< <= > >= == !=', + '3way_comparison'=> '<=> cmp', + str_comparison => 'lt le gt ge eq ne', + binary => '& &= | |= ^ ^=', + unary => 'neg ! ~', + mutators => '++ --', + func => 'atan2 cos sin exp abs log sqrt int', + conversion => 'bool "" 0+ qr', + iterators => '<>', + filetest => '-X', + dereferencing => '${} @{} %{} &{} *{}', + matching => '~~', + special => 'nomethod fallback =' + +Most of the overloadable operators map one-to-one to these keys. +Exceptions, including additional overloadable operations not +apparent from this hash, are included in the notes which follow. + +=over 5 + +=item * C + +The operator C is not a valid key for C. +However, if the operator C is overloaded then the same +implementation will be used for C +(since the two operators differ only in precedence). + +=item * C + +The key C is used for unary minus to disambiguate it from +binary C<->. + +=item * C<++>, C<--> + +Assuming they are to behave analogously to Perl's C<++> and C<-->, +overloaded implementations of these operators are required to +mutate their operands. + +No distinction is made between prefix and postfix forms of the +increment and decrement operators: these differ only in the +point at which Perl calls the associated subroutine when +evaluating an expression. + +=item * I + + += -= *= /= %= **= <<= >>= x= .= + &= |= ^= + +Simple assignment is not overloadable (the C<'='> key is used +for the L). +Perl does have a way to make assignments to an object do whatever +you want, but this involves using tie(), not overload - +see L and the L examples below. + +The subroutine for the assignment variant of an operator is +required only to return the result of the operation. +It is permitted to change the value of its operand +(this is safe because Perl calls the copy constructor first), +but this is optional since Perl assigns the returned value to +the left-hand operand anyway. + +An object that overloads an assignment operator does so only in +respect of assignments to that object. +In other words, Perl never calls the corresponding methods with +the third argument (the "swap" argument) set to TRUE. +For example, the operation + + $a *= $b + +cannot lead to C<$b>'s implementation of C<*=> being called, +even if C<$a> is a scalar. +(It can, however, generate a call to C<$b>'s method for C<*>). + +=item * I + + + - * / % ** << >> x . + & | ^ + +As described L, +Perl may call methods for operators like C<+> and C<&> in the course +of implementing missing operations like C<++>, C<+=>, and C<&=>. +While these methods may detect this usage by testing the definedness +of the third argument, they should in all cases avoid changing their +operands. +This is because Perl does not call the copy constructor before +invoking these methods. + +=item * C + +Traditionally, the Perl function C rounds to 0 +(see L), and so for floating-point-like types one +should follow the same semantic. + +=item * I + + "" 0+ bool + +These conversions are invoked according to context as necessary. +For example, the subroutine for C<'""'> (stringify) may be used +where the overloaded object is passed as an argument to C, +and that for C<'bool'> where it is tested in the condition of a flow +control statement (like C) or the ternary C operation. + +Of course, in contexts like, for example, C<$obj + 1>, Perl will +invoke C<$obj>'s implementation of C<+> rather than (in this +example) converting C<$obj> to a number using the numify method +C<'0+'> (an exception to this is when no method has been provided +for C<'+'> and L is set to TRUE). + +The subroutines for C<'""'>, C<'0+'>, and C<'bool'> can return +any arbitrary Perl value. +If the corresponding operation for this value is overloaded too, +the operation will be called again with this value. + +As a special case if the overload returns the object itself then it will +be used directly. An overloaded conversion returning the object is +probably a bug, because you're likely to get something that looks like +C. + + qr + +The subroutine for C<'qr'> is used wherever the object is +interpolated into or used as a regexp, including when it +appears on the RHS of a C<=~> or C operator. + +C must return a compiled regexp, or a ref to a compiled regexp +(such as C returns), and any further overloading on the return +value will be ignored. + +=item * I + +If CE> is overloaded then the same implementation is used +for both the I syntax C$varE> and +I syntax C${var}E>. + +B Even in list context, the iterator is currently called only +once and with scalar context. + +=item * I + +The key C<'-X'> is used to specify a subroutine to handle all the +filetest operators (C<-f>, C<-x>, and so on: see L for +the full list); +it is not possible to overload any filetest operator individually. +To distinguish them, the letter following the '-' is passed as the +second argument (that is, in the slot that for binary operators +is used to pass the second operand). + +Calling an overloaded filetest operator does not affect the stat value +associated with the special filehandle C<_>. It still refers to the +result of the last C, C or unoverloaded filetest. + +This overload was introduced in Perl 5.12. + +=item * I + +The key C<"~~"> allows you to override the smart matching logic used by +the C<~~> operator and the switch construct (C/C). See +L and L. + +Unusually, the overloaded implementation of the smart match operator +does not get full control of the smart match behaviour. +In particular, in the following code: + + package Foo; + use overload '~~' => 'match'; + + my $obj = Foo->new(); + $obj ~~ [ 1,2,3 ]; + +the smart match does I invoke the method call like this: + + $obj->match([1,2,3],0); + +rather, the smart match distributive rule takes precedence, so $obj is +smart matched against each array element in turn until a match is found, +so you may see between one and three of these calls instead: + + $obj->match(1,0); + $obj->match(2,0); + $obj->match(3,0); + +Consult the match table in L for +details of when overloading is invoked. + +=item * I + + ${} @{} %{} &{} *{} + +If these operators are not explicitly overloaded then they +work in the normal way, yielding the underlying scalar, +array, or whatever stores the object data (or the appropriate +error message if the dereference operator doesn't match it). +Defining a catch-all C<'nomethod'> (see L) +makes no difference to this as the catch-all function will +not be called to implement a missing dereference operator. + +If a dereference operator is overloaded then it must return a +I of the appropriate type (for example, the +subroutine for key C<'${}'> should return a reference to a +scalar, not a scalar), or another object which overloads the +operator: that is, the subroutine only determines what is +dereferenced and the actual dereferencing is left to Perl. +As a special case, if the subroutine returns the object itself +then it will not be called again - avoiding infinite recursion. + +=item * I + + nomethod fallback = + +See L>. + +=back + +=head2 Magic Autogeneration + +If a method for an operation is not found then Perl tries to +autogenerate a substitute implementation from the operations +that have been defined. + +Note: the behaviour described in this section can be disabled +by setting C to FALSE (see L). + +In the following tables, numbers indicate priority. +For example, the table below states that, +if no implementation for C<'!'> has been defined then Perl will +implement it using C<'bool'> (that is, by inverting the value +returned by the method for C<'bool'>); +if boolean conversion is also unimplemented then Perl will +use C<'0+'> or, failing that, C<'""'>. + + operator | can be autogenerated from + | + | 0+ "" bool . x + =========|========================== + 0+ | 1 2 + "" | 1 2 + bool | 1 2 + int | 1 2 3 + ! | 2 3 1 + qr | 2 1 3 + . | 2 1 3 + x | 2 1 3 + .= | 3 2 4 1 + x= | 3 2 4 1 + <> | 2 1 3 + -X | 2 1 3 + +Note: The iterator (C<'EE'>) and file test (C<'-X'>) +operators work as normal: if the operand is not a blessed glob or +IO reference then it is converted to a string (using the method +for C<'""'>, C<'0+'>, or C<'bool'>) to be interpreted as a glob +or filename. + + operator | can be autogenerated from + | + | < <=> neg -= - + =========|========================== + neg | 1 + -= | 1 + -- | 1 2 + abs | a1 a2 b1 b2 [*] + < | 1 + <= | 1 + > | 1 + >= | 1 + == | 1 + != | 1 + + * one from [a1, a2] and one from [b1, b2] + +Just as numeric comparisons can be autogenerated from the method +for C<< '<=>' >>, string comparisons can be autogenerated from +that for C<'cmp'>: + + operators | can be autogenerated from + ====================|=========================== + lt gt le ge eq ne | cmp + +Similarly, autogeneration for keys C<'+='> and C<'++'> is analogous +to C<'-='> and C<'--'> above: + + operator | can be autogenerated from + | + | += + + =========|========================== + += | 1 + ++ | 1 2 + +And other assignment variations are analogous to +C<'+='> and C<'-='> (and similar to C<'.='> and C<'x='> above): + + operator || *= /= %= **= <<= >>= &= ^= |= + -------------------||-------------------------------- + autogenerated from || * / % ** << >> & ^ | + +Note also that the copy constructor (key C<'='>) may be +autogenerated, but only for objects based on scalars. +See L. + +=head3 Minimal Set of Overloaded Operations + +Since some operations can be automatically generated from others, there is +a minimal set of operations that need to be overloaded in order to have +the complete set of overloaded operations at one's disposal. +Of course, the autogenerated operations may not do exactly what the user +expects. The minimal set is: + + + - * / % ** << >> x + <=> cmp + & | ^ ~ + atan2 cos sin exp log sqrt int + "" 0+ bool + ~~ + +Of the conversions, only one of string, boolean or numeric is +needed because each can be generated from either of the other two. + +=head2 Special Keys for C + +=head3 C + +The C<'nomethod'> key is used to specify a catch-all function to +be called for any operator that is not individually overloaded. +The specified function will be passed four parameters. +The first three arguments coincide with those that would have been +passed to the corresponding method if it had been defined. +The fourth argument is the C key for that missing +method. + +For example, if C<$a> is an object blessed into a package declaring + + use overload 'nomethod' => 'catch_all', # ... + +then the operation + + 3 + $a + +could (unless a method is specifically declared for the key +C<'+'>) result in a call + + catch_all($a, 3, 1, '+') + +See L. + +=head3 C + +The value assigned to the key C<'fallback'> tells Perl how hard +it should try to find an alternative way to implement a missing +operator. + +=over + +=item * defined, but FALSE + + use overload "fallback" => 0, # ... ; + +This disables L. + +=item * C + +In the default case where no value is explicitly assigned to +C, magic autogeneration is enabled. + +=item * TRUE + +The same as for C, but if a missing operator cannot be +autogenerated then, instead of issuing an error message, Perl +is allowed to revert to what it would have done for that +operator if there had been no C directive. + +Note: in most cases, particularly the L, +this is unlikely to be appropriate behaviour. + +=back + +See L. + +=head3 Copy Constructor + +As mentioned L, +this operation is called when a mutator is applied to a reference +that shares its object with some other reference. +For example, if C<$b> is mathemagical, and C<'++'> is overloaded +with C<'incr'>, and C<'='> is overloaded with C<'clone'>, then the +code + + $a = $b; + # ... (other code which does not modify $a or $b) ... + ++$b; + +would be executed in a manner equivalent to + + $a = $b; + # ... + $b = $b->clone(undef, ""); + $b->incr(undef, ""); + +Note: + +=over + +=item * + +The subroutine for C<'='> does not overload the Perl assignment +operator: it is used only to allow mutators to work as described +here. (See L above.) + +=item * + +As for other operations, the subroutine implementing '=' is passed +three arguments, though the last two are always C and C<''>. + +=item * + +The copy constructor is called only before a call to a function +declared to implement a mutator, for example, if C<++$b;> in the +code above is effected via a method declared for key C<'++'> +(or 'nomethod', passed C<'++'> as the fourth argument) or, by +autogeneration, C<'+='>. +It is not called if the increment operation is effected by a call +to the method for C<'+'> since, in the equivalent code, + + $a = $b; + $b = $b + 1; + +the data referred to by C<$a> is unchanged by the assignment to +C<$b> of a reference to new object data. + +=item * + +The copy constructor is not called if Perl determines that it is +unnecessary because there is no other reference to the data being +modified. + +=item * + +If C<'fallback'> is undefined or TRUE then a copy constructor +can be autogenerated, but only for objects based on scalars. +In other cases it needs to be defined explicitly. +Where an object's data is stored as, for example, an array of +scalars, the following might be appropriate: + + use overload '=' => sub { bless [ @{$_[0]} ] }, # ... + +=item * + +If C<'fallback'> is TRUE and no copy constructor is defined then, +for objects not based on scalars, Perl may silently fall back on +simple assignment - that is, assignment of the object reference. +In effect, this disables the copy constructor mechanism since +no new copy of the object data is created. +This is almost certainly not what you want. +(It is, however, consistent: for example, Perl's fallback for the +C<++> operator is to increment the reference itself.) + +=back + +=head2 How Perl Chooses an Operator Implementation + +Which is checked first, C or C? +If the two operands of an operator are of different types and +both overload the operator, which implementation is used? +The following are the precedence rules: + +=over + +=item 1. + +If the first operand has declared a subroutine to overload the +operator then use that implementation. + +=item 2. + +Otherwise, if fallback is TRUE or undefined for the +first operand then see if the +L +allows another of its operators to be used instead. + +=item 3. + +Unless the operator is an assignment (C<+=>, C<-=>, etc.), +repeat step (1) in respect of the second operand. + +=item 4. + +Repeat Step (2) in respect of the second operand. + +=item 5. + +If the first operand has a "nomethod" method then use that. + +=item 6. + +If the second operand has a "nomethod" method then use that. + +=item 7. + +If C is TRUE for both operands +then perform the usual operation for the operator, +treating the operands as numbers, strings, or booleans +as appropriate for the operator (see note). + +=item 8. + +Nothing worked - die. + +=back + +Where there is only one operand (or only one operand with +overloading) the checks in respect of the other operand above are +skipped. + +There are exceptions to the above rules for dereference operations +(which, if Step 1 fails, always fall back to the normal, built-in +implementations - see Dereferencing), and for C<~~> (which has its +own set of rules - see L). + +Note on Step 7: some operators have a different semantic depending +on the type of their operands. +As there is no way to instruct Perl to treat the operands as, e.g., +numbers instead of strings, the result here may not be what you +expect. +See L. + +=head2 Losing Overloading + +The restriction for the comparison operation is that even if, for example, +`C' should return a blessed reference, the autogenerated `C' +function will produce only a standard logical value based on the +numerical value of the result of `C'. In particular, a working +numeric conversion is needed in this case (possibly expressed in terms of +other conversions). + +Similarly, C<.=> and C operators lose their mathemagical properties +if the string conversion substitution is applied. + +When you chop() a mathemagical object it is promoted to a string and its +mathemagical properties are lost. The same can happen with other +operations as well. + +=head2 Inheritance and Overloading + +Overloading respects inheritance via the @ISA hierarchy. +Inheritance interacts with overloading in two ways. + +=over + +=item Method names in the C directive + +If C in + + use overload key => value; + +is a string, it is interpreted as a method name - which may +(in the usual way) be inherited from another class. + +=item Overloading of an operation is inherited by derived classes + +Any class derived from an overloaded class is also overloaded +and inherits its operator implementations. +If the same operator is overloaded in more than one ancestor +then the implementation is determined by the usual inheritance +rules. + +For example, if C inherits from C and C (in that order), +C overloads C<+> with C<\&D::plus_sub>, and C overloads +C<+> by C<"plus_meth">, then the subroutine C will +be called to implement operation C<+> for an object in package C. + +=back + +Note that since the value of the C key is not a subroutine, +its inheritance is not governed by the above rules. In the current +implementation, the value of C in the first overloaded +ancestor is used, but this is accidental and subject to change. + +=head2 Run-time Overloading + +Since all C directives are executed at compile-time, the only way to +change overloading during run-time is to + + eval 'use overload "+" => \&addmethod'; + +You can also use + + eval 'no overload "+", "--", "<="'; + +though the use of these constructs during run-time is questionable. + +=head2 Public Functions + +Package C provides the following public functions: + +=over 5 + +=item overload::StrVal(arg) + +Gives string value of C as in absence of stringify overloading. If you +are using this to get the address of a reference (useful for checking if two +references point to the same thing) then you may be better off using +C, which is faster. + +=item overload::Overloaded(arg) + +Returns true if C is subject to overloading of some operations. + +=item overload::Method(obj,op) + +Returns C or a reference to the method that implements C. + +=back + +=head2 Overloading Constants + +For some applications, the Perl parser mangles constants too much. +It is possible to hook into this process via C +and C functions. + +These functions take a hash as an argument. The recognized keys of this hash +are: + +=over 8 + +=item integer + +to overload integer constants, + +=item float + +to overload floating point constants, + +=item binary + +to overload octal and hexadecimal constants, + +=item q + +to overload C-quoted strings, constant pieces of C- and C-quoted +strings and here-documents, + +=item qr + +to overload constant pieces of regular expressions. + +=back + +The corresponding values are references to functions which take three arguments: +the first one is the I string form of the constant, the second one +is how Perl interprets this constant, the third one is how the constant is used. +Note that the initial string form does not +contain string delimiters, and has backslashes in backslash-delimiter +combinations stripped (thus the value of delimiter is not relevant for +processing of this string). The return value of this function is how this +constant is going to be interpreted by Perl. The third argument is undefined +unless for overloaded C- and C- constants, it is C in single-quote +context (comes from strings, regular expressions, and single-quote HERE +documents), it is C for arguments of C/C operators, +it is C for right-hand side of C-operator, and it is C otherwise. + +Since an expression C<"ab$cd,,"> is just a shortcut for C<'ab' . $cd . ',,'>, +it is expected that overloaded constant strings are equipped with reasonable +overloaded catenation operator, otherwise absurd results will result. +Similarly, negative numbers are considered as negations of positive constants. + +Note that it is probably meaningless to call the functions overload::constant() +and overload::remove_constant() from anywhere but import() and unimport() methods. +From these methods they may be called as + + sub import { + shift; + return unless @_; + die "unknown import: @_" unless @_ == 1 and $_[0] eq ':constant'; + overload::constant integer => sub {Math::BigInt->new(shift)}; + } + +=head1 IMPLEMENTATION + +What follows is subject to change RSN. + +The table of methods for all operations is cached in magic for the +symbol table hash for the package. The cache is invalidated during +processing of C, C, new function +definitions, and changes in @ISA. However, this invalidation remains +unprocessed until the next Cing into the package. Hence if you +want to change overloading structure dynamically, you'll need an +additional (fake) Cing to update the table. + +(Every SVish thing has a magic queue, and magic is an entry in that +queue. This is how a single variable may participate in multiple +forms of magic simultaneously. For instance, environment variables +regularly have two forms at once: their %ENV magic and their taint +magic. However, the magic which implements overloading is applied to +the stashes, which are rarely used directly, thus should not slow down +Perl.) + +If an object belongs to a package using overload, it carries a special +flag. Thus the only speed penalty during arithmetic operations without +overloading is the checking of this flag. + +In fact, if C is not present, there is almost no overhead +for overloadable operations, so most programs should not suffer +measurable performance penalties. A considerable effort was made to +minimize the overhead when overload is used in some package, but the +arguments in question do not belong to packages using overload. When +in doubt, test your speed with C and without it. So far +there have been no reports of substantial speed degradation if Perl is +compiled with optimization turned on. + +There is no size penalty for data if overload is not used. The only +size penalty if overload is used in some package is that I the +packages acquire a magic during the next Cing into the +package. This magic is three-words-long for packages without +overloading, and carries the cache table if the package is overloaded. + +It is expected that arguments to methods that are not explicitly supposed +to be changed are constant (but this is not enforced). + +=head1 COOKBOOK + +Please add examples to what follows! + +=head2 Two-face Scalars + +Put this in F in your Perl library directory: + + package two_face; # Scalars with separate string and + # numeric values. + sub new { my $p = shift; bless [@_], $p } + use overload '""' => \&str, '0+' => \&num, fallback => 1; + sub num {shift->[1]} + sub str {shift->[0]} + +Use it as follows: + + require two_face; + my $seven = two_face->new("vii", 7); + printf "seven=$seven, seven=%d, eight=%d\n", $seven, $seven+1; + print "seven contains `i'\n" if $seven =~ /i/; + +(The second line creates a scalar which has both a string value, and a +numeric value.) This prints: + + seven=vii, seven=7, eight=8 + seven contains `i' + +=head2 Two-face References + +Suppose you want to create an object which is accessible as both an +array reference and a hash reference. + + package two_refs; + use overload '%{}' => \&gethash, '@{}' => sub { $ {shift()} }; + sub new { + my $p = shift; + bless \ [@_], $p; + } + sub gethash { + my %h; + my $self = shift; + tie %h, ref $self, $self; + \%h; + } + + sub TIEHASH { my $p = shift; bless \ shift, $p } + my %fields; + my $i = 0; + $fields{$_} = $i++ foreach qw{zero one two three}; + sub STORE { + my $self = ${shift()}; + my $key = $fields{shift()}; + defined $key or die "Out of band access"; + $$self->[$key] = shift; + } + sub FETCH { + my $self = ${shift()}; + my $key = $fields{shift()}; + defined $key or die "Out of band access"; + $$self->[$key]; + } + +Now one can access an object using both the array and hash syntax: + + my $bar = two_refs->new(3,4,5,6); + $bar->[2] = 11; + $bar->{two} == 11 or die 'bad hash fetch'; + +Note several important features of this example. First of all, the +I type of $bar is a scalar reference, and we do not overload +the scalar dereference. Thus we can get the I non-overloaded +contents of $bar by just using C<$$bar> (what we do in functions which +overload dereference). Similarly, the object returned by the +TIEHASH() method is a scalar reference. + +Second, we create a new tied hash each time the hash syntax is used. +This allows us not to worry about a possibility of a reference loop, +which would lead to a memory leak. + +Both these problems can be cured. Say, if we want to overload hash +dereference on a reference to an object which is I as a +hash itself, the only problem one has to circumvent is how to access +this I hash (as opposed to the I hash exhibited by the +overloaded dereference operator). Here is one possible fetching routine: + + sub access_hash { + my ($self, $key) = (shift, shift); + my $class = ref $self; + bless $self, 'overload::dummy'; # Disable overloading of %{} + my $out = $self->{$key}; + bless $self, $class; # Restore overloading + $out; + } + +To remove creation of the tied hash on each access, one may an extra +level of indirection which allows a non-circular structure of references: + + package two_refs1; + use overload '%{}' => sub { ${shift()}->[1] }, + '@{}' => sub { ${shift()}->[0] }; + sub new { + my $p = shift; + my $a = [@_]; + my %h; + tie %h, $p, $a; + bless \ [$a, \%h], $p; + } + sub gethash { + my %h; + my $self = shift; + tie %h, ref $self, $self; + \%h; + } + + sub TIEHASH { my $p = shift; bless \ shift, $p } + my %fields; + my $i = 0; + $fields{$_} = $i++ foreach qw{zero one two three}; + sub STORE { + my $a = ${shift()}; + my $key = $fields{shift()}; + defined $key or die "Out of band access"; + $a->[$key] = shift; + } + sub FETCH { + my $a = ${shift()}; + my $key = $fields{shift()}; + defined $key or die "Out of band access"; + $a->[$key]; + } + +Now if $baz is overloaded like this, then C<$baz> is a reference to a +reference to the intermediate array, which keeps a reference to an +actual array, and the access hash. The tie()ing object for the access +hash is a reference to a reference to the actual array, so + +=over + +=item * + +There are no loops of references. + +=item * + +Both "objects" which are blessed into the class C are +references to a reference to an array, thus references to a I. +Thus the accessor expression C<$$foo-E[$ind]> involves no +overloaded operations. + +=back + +=head2 Symbolic Calculator + +Put this in F in your Perl library directory: + + package symbolic; # Primitive symbolic calculator + use overload nomethod => \&wrap; + + sub new { shift; bless ['n', @_] } + sub wrap { + my ($obj, $other, $inv, $meth) = @_; + ($obj, $other) = ($other, $obj) if $inv; + bless [$meth, $obj, $other]; + } + +This module is very unusual as overloaded modules go: it does not +provide any usual overloaded operators, instead it provides an +implementation for L>. In this example the C +subroutine returns an object which encapsulates operations done over +the objects: C<< symbolic->new(3) >> contains C<['n', 3]>, C<< 2 + +symbolic->new(3) >> contains C<['+', 2, ['n', 3]]>. + +Here is an example of the script which "calculates" the side of +circumscribed octagon using the above package: + + require symbolic; + my $iter = 1; # 2**($iter+2) = 8 + my $side = symbolic->new(1); + my $cnt = $iter; + + while ($cnt--) { + $side = (sqrt(1 + $side**2) - 1)/$side; + } + print "OK\n"; + +The value of $side is + + ['/', ['-', ['sqrt', ['+', 1, ['**', ['n', 1], 2]], + undef], 1], ['n', 1]] + +Note that while we obtained this value using a nice little script, +there is no simple way to I this value. In fact this value may +be inspected in debugger (see L), but only if +C Bption is set, and not via C

command. + +If one attempts to print this value, then the overloaded operator +C<""> will be called, which will call C operator. The +result of this operator will be stringified again, but this result is +again of type C, which will lead to an infinite loop. + +Add a pretty-printer method to the module F: + + sub pretty { + my ($meth, $a, $b) = @{+shift}; + $a = 'u' unless defined $a; + $b = 'u' unless defined $b; + $a = $a->pretty if ref $a; + $b = $b->pretty if ref $b; + "[$meth $a $b]"; + } + +Now one can finish the script by + + print "side = ", $side->pretty, "\n"; + +The method C is doing object-to-string conversion, so it +is natural to overload the operator C<""> using this method. However, +inside such a method it is not necessary to pretty-print the +I $a and $b of an object. In the above subroutine +C<"[$meth $a $b]"> is a catenation of some strings and components $a +and $b. If these components use overloading, the catenation operator +will look for an overloaded operator C<.>; if not present, it will +look for an overloaded operator C<"">. Thus it is enough to use + + use overload nomethod => \&wrap, '""' => \&str; + sub str { + my ($meth, $a, $b) = @{+shift}; + $a = 'u' unless defined $a; + $b = 'u' unless defined $b; + "[$meth $a $b]"; + } + +Now one can change the last line of the script to + + print "side = $side\n"; + +which outputs + + side = [/ [- [sqrt [+ 1 [** [n 1 u] 2]] u] 1] [n 1 u]] + +and one can inspect the value in debugger using all the possible +methods. + +Something is still amiss: consider the loop variable $cnt of the +script. It was a number, not an object. We cannot make this value of +type C, since then the loop will not terminate. + +Indeed, to terminate the cycle, the $cnt should become false. +However, the operator C for checking falsity is overloaded (this +time via overloaded C<"">), and returns a long string, thus any object +of type C is true. To overcome this, we need a way to +compare an object to 0. In fact, it is easier to write a numeric +conversion routine. + +Here is the text of F with such a routine added (and +slightly modified str()): + + package symbolic; # Primitive symbolic calculator + use overload + nomethod => \&wrap, '""' => \&str, '0+' => \# + + sub new { shift; bless ['n', @_] } + sub wrap { + my ($obj, $other, $inv, $meth) = @_; + ($obj, $other) = ($other, $obj) if $inv; + bless [$meth, $obj, $other]; + } + sub str { + my ($meth, $a, $b) = @{+shift}; + $a = 'u' unless defined $a; + if (defined $b) { + "[$meth $a $b]"; + } else { + "[$meth $a]"; + } + } + my %subr = ( n => sub {$_[0]}, + sqrt => sub {sqrt $_[0]}, + '-' => sub {shift() - shift()}, + '+' => sub {shift() + shift()}, + '/' => sub {shift() / shift()}, + '*' => sub {shift() * shift()}, + '**' => sub {shift() ** shift()}, + ); + sub num { + my ($meth, $a, $b) = @{+shift}; + my $subr = $subr{$meth} + or die "Do not know how to ($meth) in symbolic"; + $a = $a->num if ref $a eq __PACKAGE__; + $b = $b->num if ref $b eq __PACKAGE__; + $subr->($a,$b); + } + +All the work of numeric conversion is done in %subr and num(). Of +course, %subr is not complete, it contains only operators used in the +example below. Here is the extra-credit question: why do we need an +explicit recursion in num()? (Answer is at the end of this section.) + +Use this module like this: + + require symbolic; + my $iter = symbolic->new(2); # 16-gon + my $side = symbolic->new(1); + my $cnt = $iter; + + while ($cnt) { + $cnt = $cnt - 1; # Mutator `--' not implemented + $side = (sqrt(1 + $side**2) - 1)/$side; + } + printf "%s=%f\n", $side, $side; + printf "pi=%f\n", $side*(2**($iter+2)); + +It prints (without so many line breaks) + + [/ [- [sqrt [+ 1 [** [/ [- [sqrt [+ 1 [** [n 1] 2]]] 1] + [n 1]] 2]]] 1] + [/ [- [sqrt [+ 1 [** [n 1] 2]]] 1] [n 1]]]=0.198912 + pi=3.182598 + +The above module is very primitive. It does not implement +mutator methods (C<++>, C<-=> and so on), does not do deep copying +(not required without mutators!), and implements only those arithmetic +operations which are used in the example. + +To implement most arithmetic operations is easy; one should just use +the tables of operations, and change the code which fills %subr to + + my %subr = ( 'n' => sub {$_[0]} ); + foreach my $op (split " ", $overload::ops{with_assign}) { + $subr{$op} = $subr{"$op="} = eval "sub {shift() $op shift()}"; + } + my @bins = qw(binary 3way_comparison num_comparison str_comparison); + foreach my $op (split " ", "@overload::ops{ @bins }") { + $subr{$op} = eval "sub {shift() $op shift()}"; + } + foreach my $op (split " ", "@overload::ops{qw(unary func)}") { + print "defining `$op'\n"; + $subr{$op} = eval "sub {$op shift()}"; + } + +Since subroutines implementing assignment operators are not required +to modify their operands (see L above), +we do not need anything special to make C<+=> and friends work, +besides adding these operators to %subr and defining a copy +constructor (needed since Perl has no way to know that the +implementation of C<'+='> does not mutate the argument - +see L). + +To implement a copy constructor, add C<< '=' => \&cpy >> to C +line, and code (this code assumes that mutators change things one level +deep only, so recursive copying is not needed): + + sub cpy { + my $self = shift; + bless [@$self], ref $self; + } + +To make C<++> and C<--> work, we need to implement actual mutators, +either directly, or in C. We continue to do things inside +C, thus add + + if ($meth eq '++' or $meth eq '--') { + @$obj = ($meth, (bless [@$obj]), 1); # Avoid circular reference + return $obj; + } + +after the first line of wrap(). This is not a most effective +implementation, one may consider + + sub inc { $_[0] = bless ['++', shift, 1]; } + +instead. + +As a final remark, note that one can fill %subr by + + my %subr = ( 'n' => sub {$_[0]} ); + foreach my $op (split " ", $overload::ops{with_assign}) { + $subr{$op} = $subr{"$op="} = eval "sub {shift() $op shift()}"; + } + my @bins = qw(binary 3way_comparison num_comparison str_comparison); + foreach my $op (split " ", "@overload::ops{ @bins }") { + $subr{$op} = eval "sub {shift() $op shift()}"; + } + foreach my $op (split " ", "@overload::ops{qw(unary func)}") { + $subr{$op} = eval "sub {$op shift()}"; + } + $subr{'++'} = $subr{'+'}; + $subr{'--'} = $subr{'-'}; + +This finishes implementation of a primitive symbolic calculator in +50 lines of Perl code. Since the numeric values of subexpressions +are not cached, the calculator is very slow. + +Here is the answer for the exercise: In the case of str(), we need no +explicit recursion since the overloaded C<.>-operator will fall back +to an existing overloaded operator C<"">. Overloaded arithmetic +operators I fall back to numeric conversion if C is +not explicitly requested. Thus without an explicit recursion num() +would convert C<['+', $a, $b]> to C<$a + $b>, which would just rebuild +the argument of num(). + +If you wonder why defaults for conversion are different for str() and +num(), note how easy it was to write the symbolic calculator. This +simplicity is due to an appropriate choice of defaults. One extra +note: due to the explicit recursion num() is more fragile than sym(): +we need to explicitly check for the type of $a and $b. If components +$a and $b happen to be of some related type, this may lead to problems. + +=head2 I Symbolic Calculator + +One may wonder why we call the above calculator symbolic. The reason +is that the actual calculation of the value of expression is postponed +until the value is I. + +To see it in action, add a method + + sub STORE { + my $obj = shift; + $#$obj = 1; + @$obj->[0,1] = ('=', shift); + } + +to the package C. After this change one can do + + my $a = symbolic->new(3); + my $b = symbolic->new(4); + my $c = sqrt($a**2 + $b**2); + +and the numeric value of $c becomes 5. However, after calling + + $a->STORE(12); $b->STORE(5); + +the numeric value of $c becomes 13. There is no doubt now that the module +symbolic provides a I calculator indeed. + +To hide the rough edges under the hood, provide a tie()d interface to the +package C. Add methods + + sub TIESCALAR { my $pack = shift; $pack->new(@_) } + sub FETCH { shift } + sub nop { } # Around a bug + +(the bug, fixed in Perl 5.14, is described in L<"BUGS">). One can use this +new interface as + + tie $a, 'symbolic', 3; + tie $b, 'symbolic', 4; + $a->nop; $b->nop; # Around a bug + + my $c = sqrt($a**2 + $b**2); + +Now numeric value of $c is 5. After C<$a = 12; $b = 5> the numeric value +of $c becomes 13. To insulate the user of the module add a method + + sub vars { my $p = shift; tie($_, $p), $_->nop foreach @_; } + +Now + + my ($a, $b); + symbolic->vars($a, $b); + my $c = sqrt($a**2 + $b**2); + + $a = 3; $b = 4; + printf "c5 %s=%f\n", $c, $c; + + $a = 12; $b = 5; + printf "c13 %s=%f\n", $c, $c; + +shows that the numeric value of $c follows changes to the values of $a +and $b. + +=head1 AUTHOR + +Ilya Zakharevich EFE. + +=head1 SEE ALSO + +The C pragma can be used to enable or disable overloaded +operations within a lexical scope - see L. + +=head1 DIAGNOSTICS + +When Perl is run with the B<-Do> switch or its equivalent, overloading +induces diagnostic messages. + +Using the C command of Perl debugger (see L) one can +deduce which operations are overloaded (and which ancestor triggers +this overloading). Say, if C is overloaded, then the method C<(eq> +is shown by debugger. The method C<()> corresponds to the C +key (in fact a presence of this method shows that this package has +overloading enabled, and it is what is used by the C +function of module C). + +The module might issue the following warnings: + +=over 4 + +=item Odd number of arguments for overload::constant + +(W) The call to overload::constant contained an odd number of arguments. +The arguments should come in pairs. + +=item `%s' is not an overloadable type + +(W) You tried to overload a constant type the overload package is unaware of. + +=item `%s' is not a code reference + +(W) The second (fourth, sixth, ...) argument of overload::constant needs +to be a code reference. Either an anonymous subroutine, or a reference +to a subroutine. + +=back + +=head1 BUGS AND PITFALLS + +=over + +=item * + +No warning is issued for invalid C keys. +Such errors are not always obvious: + + use overload "+0" => sub { ...; }, # should be "0+" + "not" => sub { ...; }; # should be "!" + +(Bug #74098) + +=item * + +A pitfall when fallback is TRUE and Perl resorts to a built-in +implementation of an operator is that some operators have more +than one semantic, for example C<|>: + + use overload '0+' => sub { $_[0]->{n}; }, + fallback => 1; + my $x = bless { n => 4 }, "main"; + my $y = bless { n => 8 }, "main"; + print $x | $y, "\n"; + +You might expect this to output "12". +In fact, it prints "<": the ASCII result of treating "|" +as a bitwise string operator - that is, the result of treating +the operands as the strings "4" and "8" rather than numbers. +The fact that numify (C<0+>) is implemented but stringify +(C<"">) isn't makes no difference since the latter is simply +autogenerated from the former. + +The only way to change this is to provide your own subroutine +for C<'|'>. + +=item * + +Magic autogeneration increases the potential for inadvertently +creating self-referential structures. +Currently Perl will not free self-referential +structures until cycles are explicitly broken. +For example, + + use overload '+' => 'add'; + sub add { bless [ \$_[0], \$_[1] ] }; + +is asking for trouble, since + + $obj += $y; + +will effectively become + + $obj = add($obj, $y, undef); + +with the same result as + + $obj = [\$obj, \$foo]; + +Even if no I assignment-variants of operators are present in +the script, they may be generated by the optimizer. +For example, + + "obj = $obj\n" + +may be optimized to + + my $tmp = 'obj = ' . $obj; $tmp .= "\n"; + +=item * + +Because it is used for overloading, the per-package hash +C<%OVERLOAD> now has a special meaning in Perl. +The symbol table is filled with names looking like line-noise. + +=item * + +For the purpose of inheritance every overloaded package behaves as if +C is present (possibly undefined). This may create +interesting effects if some package is not overloaded, but inherits +from two overloaded packages. + +=item * + +Before Perl 5.14, the relation between overloading and tie()ing was broken. +Overloading is triggered or not basing on the I class of the +tie()d variable. + +This happened because the presence of overloading was checked +too early, before any tie()d access was attempted. If the +class of the value FETCH()ed from the tied variable does not +change, a simple workaround for code that is to run on older Perl +versions is to access the value (via C<() = $foo> or some such) +immediately after tie()ing, so that after this call the I class +coincides with the current one. + +=item * + +Barewords are not covered by overloaded string constants. + +=back + +=cut + diff --git a/testsuite/input-files/perl-v5.14.2/lib/strict.pm b/testsuite/input-files/perl-v5.14.2/lib/strict.pm new file mode 100644 index 00000000..053aae75 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/strict.pm @@ -0,0 +1,147 @@ +package strict; + +$strict::VERSION = "1.04"; + +# Verify that we're called correctly so that strictures will work. +unless ( __FILE__ =~ /(^|[\/\\])\Q${\__PACKAGE__}\E\.pmc?$/ ) { + # Can't use Carp, since Carp uses us! + my (undef, $f, $l) = caller; + die("Incorrect use of pragma '${\__PACKAGE__}' at $f line $l.\n"); +} + +my %bitmask = ( +refs => 0x00000002, +subs => 0x00000200, +vars => 0x00000400 +); + +sub bits { + my $bits = 0; + my @wrong; + foreach my $s (@_) { + push @wrong, $s unless exists $bitmask{$s}; + $bits |= $bitmask{$s} || 0; + } + if (@wrong) { + require Carp; + Carp::croak("Unknown 'strict' tag(s) '@wrong'"); + } + $bits; +} + +my $default_bits = bits(qw(refs subs vars)); + +sub import { + shift; + $^H |= @_ ? bits(@_) : $default_bits; +} + +sub unimport { + shift; + $^H &= ~ (@_ ? bits(@_) : $default_bits); +} + +1; +__END__ + +=head1 NAME + +strict - Perl pragma to restrict unsafe constructs + +=head1 SYNOPSIS + + use strict; + + use strict "vars"; + use strict "refs"; + use strict "subs"; + + use strict; + no strict "vars"; + +=head1 DESCRIPTION + +If no import list is supplied, all possible restrictions are assumed. +(This is the safest mode to operate in, but is sometimes too strict for +casual programming.) Currently, there are three possible things to be +strict about: "subs", "vars", and "refs". + +=over 6 + +=item C + +This generates a runtime error if you +use symbolic references (see L). + + use strict 'refs'; + $ref = \$foo; + print $$ref; # ok + $ref = "foo"; + print $$ref; # runtime error; normally ok + $file = "STDOUT"; + print $file "Hi!"; # error; note: no comma after $file + +There is one exception to this rule: + + $bar = \&{'foo'}; + &$bar; + +is allowed so that C would not break under stricture. + + +=item C + +This generates a compile-time error if you access a variable that wasn't +declared via C or C, +localized via C, or wasn't fully qualified. Because this is to avoid +variable suicide problems and subtle dynamic scoping issues, a merely +local() variable isn't good enough. See L and +L. + + use strict 'vars'; + $X::foo = 1; # ok, fully qualified + my $foo = 10; # ok, my() var + local $foo = 9; # blows up + + package Cinna; + our $bar; # Declares $bar in current package + $bar = 'HgS'; # ok, global declared via pragma + +The local() generated a compile-time error because you just touched a global +name without fully qualifying it. + +Because of their special use by sort(), the variables $a and $b are +exempted from this check. + +=item C + +This disables the poetry optimization, generating a compile-time error if +you try to use a bareword identifier that's not a subroutine, unless it +is a simple identifier (no colons) and that it appears in curly braces or +on the left hand side of the C<< => >> symbol. + + use strict 'subs'; + $SIG{PIPE} = Plumber; # blows up + $SIG{PIPE} = "Plumber"; # just fine: quoted string is always ok + $SIG{PIPE} = \&Plumber; # preferred form + +=back + +See L. + +=head1 HISTORY + +C, with Perl 5.6.1, erroneously permitted to use an unquoted +compound identifier (e.g. C) as a hash key (before C<< => >> or +inside curlies), but without forcing it always to a literal string. + +Starting with Perl 5.8.1 strict is strict about its restrictions: +if unknown restrictions are used, the strict pragma will abort with + + Unknown 'strict' tag(s) '...' + +As of version 1.04 (Perl 5.10), strict verifies that it is used as +"strict" to avoid the dreaded Strict trap on case insensitive file +systems. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/vars.pm b/testsuite/input-files/perl-v5.14.2/lib/vars.pm new file mode 100644 index 00000000..8ec107c1 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/vars.pm @@ -0,0 +1,82 @@ +package vars; + +use 5.006; + +our $VERSION = '1.02'; + +use warnings::register; +use strict qw(vars subs); + +sub import { + my $callpack = caller; + my (undef, @imports) = @_; + my ($sym, $ch); + foreach (@imports) { + if (($ch, $sym) = /^([\$\@\%\*\&])(.+)/) { + if ($sym =~ /\W/) { + # time for a more-detailed check-up + if ($sym =~ /^\w+[[{].*[]}]$/) { + require Carp; + Carp::croak("Can't declare individual elements of hash or array"); + } elsif (warnings::enabled() and length($sym) == 1 and $sym !~ tr/a-zA-Z//) { + warnings::warn("No need to declare built-in vars"); + } elsif (($^H &= strict::bits('vars'))) { + require Carp; + Carp::croak("'$_' is not a valid variable name under strict vars"); + } + } + $sym = "${callpack}::$sym" unless $sym =~ /::/; + *$sym = + ( $ch eq "\$" ? \$$sym + : $ch eq "\@" ? \@$sym + : $ch eq "\%" ? \%$sym + : $ch eq "\*" ? \*$sym + : $ch eq "\&" ? \&$sym + : do { + require Carp; + Carp::croak("'$_' is not a valid variable name"); + }); + } else { + require Carp; + Carp::croak("'$_' is not a valid variable name"); + } + } +}; + +1; +__END__ + +=head1 NAME + +vars - Perl pragma to predeclare global variable names (obsolete) + +=head1 SYNOPSIS + + use vars qw($frob @mung %seen); + +=head1 DESCRIPTION + +NOTE: For variables in the current package, the functionality provided +by this pragma has been superseded by C declarations, available +in Perl v5.6.0 or later. See L. + +This will predeclare all the variables whose names are +in the list, allowing you to use them under "use strict", and +disabling any typo warnings. + +Unlike pragmas that affect the C<$^H> hints variable, the C and +C declarations are not BLOCK-scoped. They are thus effective +for the entire file in which they appear. You may not rescind such +declarations with C or C. + +Packages such as the B and B that delay +loading of subroutines within packages can create problems with +package lexicals defined using C. While the B pragma +cannot duplicate the effect of package lexicals (total transparency +outside of the package), it can act as an acceptable substitute by +pre-declaring global symbols, ensuring their availability to the +later-loaded routines. + +See L. + +=cut diff --git a/testsuite/input-files/perl-v5.14.2/lib/warnings.pm b/testsuite/input-files/perl-v5.14.2/lib/warnings.pm new file mode 100644 index 00000000..90a9d0a6 --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/warnings.pm @@ -0,0 +1,567 @@ +# -*- buffer-read-only: t -*- +# !!!!!!! DO NOT EDIT THIS FILE !!!!!!! +# This file is built by regen/warnings.pl. +# Any changes made here will be lost! + +package warnings; + +our $VERSION = '1.12'; + +# Verify that we're called correctly so that warnings will work. +# see also strict.pm. +unless ( __FILE__ =~ /(^|[\/\\])\Q${\__PACKAGE__}\E\.pmc?$/ ) { + my (undef, $f, $l) = caller; + die("Incorrect use of pragma '${\__PACKAGE__}' at $f line $l.\n"); +} + +=head1 NAME + +warnings - Perl pragma to control optional warnings + +=head1 SYNOPSIS + + use warnings; + no warnings; + + use warnings "all"; + no warnings "all"; + + use warnings::register; + if (warnings::enabled()) { + warnings::warn("some warning"); + } + + if (warnings::enabled("void")) { + warnings::warn("void", "some warning"); + } + + if (warnings::enabled($object)) { + warnings::warn($object, "some warning"); + } + + warnings::warnif("some warning"); + warnings::warnif("void", "some warning"); + warnings::warnif($object, "some warning"); + +=head1 DESCRIPTION + +The C pragma is a replacement for the command line flag C<-w>, +but the pragma is limited to the enclosing block, while the flag is global. +See L for more information. + +If no import list is supplied, all possible warnings are either enabled +or disabled. + +A number of functions are provided to assist module authors. + +=over 4 + +=item use warnings::register + +Creates a new warnings category with the same name as the package where +the call to the pragma is used. + +=item warnings::enabled() + +Use the warnings category with the same name as the current package. + +Return TRUE if that warnings category is enabled in the calling module. +Otherwise returns FALSE. + +=item warnings::enabled($category) + +Return TRUE if the warnings category, C<$category>, is enabled in the +calling module. +Otherwise returns FALSE. + +=item warnings::enabled($object) + +Use the name of the class for the object reference, C<$object>, as the +warnings category. + +Return TRUE if that warnings category is enabled in the first scope +where the object is used. +Otherwise returns FALSE. + +=item warnings::fatal_enabled() + +Return TRUE if the warnings category with the same name as the current +package has been set to FATAL in the calling module. +Otherwise returns FALSE. + +=item warnings::fatal_enabled($category) + +Return TRUE if the warnings category C<$category> has been set to FATAL in +the calling module. +Otherwise returns FALSE. + +=item warnings::fatal_enabled($object) + +Use the name of the class for the object reference, C<$object>, as the +warnings category. + +Return TRUE if that warnings category has been set to FATAL in the first +scope where the object is used. +Otherwise returns FALSE. + +=item warnings::warn($message) + +Print C<$message> to STDERR. + +Use the warnings category with the same name as the current package. + +If that warnings category has been set to "FATAL" in the calling module +then die. Otherwise return. + +=item warnings::warn($category, $message) + +Print C<$message> to STDERR. + +If the warnings category, C<$category>, has been set to "FATAL" in the +calling module then die. Otherwise return. + +=item warnings::warn($object, $message) + +Print C<$message> to STDERR. + +Use the name of the class for the object reference, C<$object>, as the +warnings category. + +If that warnings category has been set to "FATAL" in the scope where C<$object> +is first used then die. Otherwise return. + + +=item warnings::warnif($message) + +Equivalent to: + + if (warnings::enabled()) + { warnings::warn($message) } + +=item warnings::warnif($category, $message) + +Equivalent to: + + if (warnings::enabled($category)) + { warnings::warn($category, $message) } + +=item warnings::warnif($object, $message) + +Equivalent to: + + if (warnings::enabled($object)) + { warnings::warn($object, $message) } + +=item warnings::register_categories(@names) + +This registers warning categories for the given names and is primarily for +use by the warnings::register pragma, for which see L. + +=back + +See L and L. + +=cut + +our %Offsets = ( + + # Warnings Categories added in Perl 5.008 + + 'all' => 0, + 'closure' => 2, + 'deprecated' => 4, + 'exiting' => 6, + 'glob' => 8, + 'io' => 10, + 'closed' => 12, + 'exec' => 14, + 'layer' => 16, + 'newline' => 18, + 'pipe' => 20, + 'unopened' => 22, + 'misc' => 24, + 'numeric' => 26, + 'once' => 28, + 'overflow' => 30, + 'pack' => 32, + 'portable' => 34, + 'recursion' => 36, + 'redefine' => 38, + 'regexp' => 40, + 'severe' => 42, + 'debugging' => 44, + 'inplace' => 46, + 'internal' => 48, + 'malloc' => 50, + 'signal' => 52, + 'substr' => 54, + 'syntax' => 56, + 'ambiguous' => 58, + 'bareword' => 60, + 'digit' => 62, + 'parenthesis' => 64, + 'precedence' => 66, + 'printf' => 68, + 'prototype' => 70, + 'qw' => 72, + 'reserved' => 74, + 'semicolon' => 76, + 'taint' => 78, + 'threads' => 80, + 'uninitialized' => 82, + 'unpack' => 84, + 'untie' => 86, + 'utf8' => 88, + 'void' => 90, + + # Warnings Categories added in Perl 5.011 + + 'imprecision' => 92, + 'illegalproto' => 94, + + # Warnings Categories added in Perl 5.013 + + 'non_unicode' => 96, + 'nonchar' => 98, + 'surrogate' => 100, + ); + +our %Bits = ( + 'all' => "\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x55\x15", # [0..50] + 'ambiguous' => "\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00", # [29] + 'bareword' => "\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00", # [30] + 'closed' => "\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [6] + 'closure' => "\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [1] + 'debugging' => "\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00", # [22] + 'deprecated' => "\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [2] + 'digit' => "\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00", # [31] + 'exec' => "\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [7] + 'exiting' => "\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [3] + 'glob' => "\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [4] + 'illegalproto' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00", # [47] + 'imprecision' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00", # [46] + 'inplace' => "\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00", # [23] + 'internal' => "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00", # [24] + 'io' => "\x00\x54\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [5..11] + 'layer' => "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [8] + 'malloc' => "\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00", # [25] + 'misc' => "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [12] + 'newline' => "\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [9] + 'non_unicode' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", # [48] + 'nonchar' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04", # [49] + 'numeric' => "\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [13] + 'once' => "\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [14] + 'overflow' => "\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [15] + 'pack' => "\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00", # [16] + 'parenthesis' => "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00", # [32] + 'pipe' => "\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [10] + 'portable' => "\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00", # [17] + 'precedence' => "\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00", # [33] + 'printf' => "\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00", # [34] + 'prototype' => "\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00", # [35] + 'qw' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00", # [36] + 'recursion' => "\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00", # [18] + 'redefine' => "\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00", # [19] + 'regexp' => "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00", # [20] + 'reserved' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00", # [37] + 'semicolon' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00", # [38] + 'severe' => "\x00\x00\x00\x00\x00\x54\x05\x00\x00\x00\x00\x00\x00", # [21..25] + 'signal' => "\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00", # [26] + 'substr' => "\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00", # [27] + 'surrogate' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10", # [50] + 'syntax' => "\x00\x00\x00\x00\x00\x00\x00\x55\x55\x15\x00\x40\x00", # [28..38,47] + 'taint' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00", # [39] + 'threads' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00", # [40] + 'uninitialized' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00", # [41] + 'unopened' => "\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [11] + 'unpack' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00", # [42] + 'untie' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00", # [43] + 'utf8' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x15", # [44,48..50] + 'void' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00", # [45] + ); + +our %DeadBits = ( + 'all' => "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\x2a", # [0..50] + 'ambiguous' => "\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00", # [29] + 'bareword' => "\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00", # [30] + 'closed' => "\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [6] + 'closure' => "\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [1] + 'debugging' => "\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00", # [22] + 'deprecated' => "\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [2] + 'digit' => "\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00", # [31] + 'exec' => "\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [7] + 'exiting' => "\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [3] + 'glob' => "\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [4] + 'illegalproto' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00", # [47] + 'imprecision' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00", # [46] + 'inplace' => "\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00", # [23] + 'internal' => "\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00", # [24] + 'io' => "\x00\xa8\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [5..11] + 'layer' => "\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [8] + 'malloc' => "\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00", # [25] + 'misc' => "\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [12] + 'newline' => "\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [9] + 'non_unicode' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02", # [48] + 'nonchar' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08", # [49] + 'numeric' => "\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [13] + 'once' => "\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [14] + 'overflow' => "\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [15] + 'pack' => "\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00", # [16] + 'parenthesis' => "\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00", # [32] + 'pipe' => "\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [10] + 'portable' => "\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00", # [17] + 'precedence' => "\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00", # [33] + 'printf' => "\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00", # [34] + 'prototype' => "\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00", # [35] + 'qw' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00", # [36] + 'recursion' => "\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00", # [18] + 'redefine' => "\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00", # [19] + 'regexp' => "\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00", # [20] + 'reserved' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00", # [37] + 'semicolon' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00", # [38] + 'severe' => "\x00\x00\x00\x00\x00\xa8\x0a\x00\x00\x00\x00\x00\x00", # [21..25] + 'signal' => "\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00", # [26] + 'substr' => "\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00", # [27] + 'surrogate' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20", # [50] + 'syntax' => "\x00\x00\x00\x00\x00\x00\x00\xaa\xaa\x2a\x00\x80\x00", # [28..38,47] + 'taint' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00", # [39] + 'threads' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00", # [40] + 'uninitialized' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00", # [41] + 'unopened' => "\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", # [11] + 'unpack' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00", # [42] + 'untie' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00", # [43] + 'utf8' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x2a", # [44,48..50] + 'void' => "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00", # [45] + ); + +$NONE = "\0\0\0\0\0\0\0\0\0\0\0\0\0"; +$LAST_BIT = 102 ; +$BYTES = 13 ; + +$All = "" ; vec($All, $Offsets{'all'}, 2) = 3 ; + +sub Croaker +{ + require Carp; # this initializes %CarpInternal + local $Carp::CarpInternal{'warnings'}; + delete $Carp::CarpInternal{'warnings'}; + Carp::croak(@_); +} + +sub _bits { + my $mask = shift ; + my $catmask ; + my $fatal = 0 ; + my $no_fatal = 0 ; + + foreach my $word ( @_ ) { + if ($word eq 'FATAL') { + $fatal = 1; + $no_fatal = 0; + } + elsif ($word eq 'NONFATAL') { + $fatal = 0; + $no_fatal = 1; + } + elsif ($catmask = $Bits{$word}) { + $mask |= $catmask ; + $mask |= $DeadBits{$word} if $fatal ; + $mask &= ~($DeadBits{$word}|$All) if $no_fatal ; + } + else + { Croaker("Unknown warnings category '$word'")} + } + + return $mask ; +} + +sub bits +{ + # called from B::Deparse.pm + push @_, 'all' unless @_ ; + return _bits(undef, @_) ; +} + +sub import +{ + shift; + + my $mask = ${^WARNING_BITS} ; + + if (vec($mask, $Offsets{'all'}, 1)) { + $mask |= $Bits{'all'} ; + $mask |= $DeadBits{'all'} if vec($mask, $Offsets{'all'}+1, 1); + } + + # Empty @_ is equivalent to @_ = 'all' ; + ${^WARNING_BITS} = @_ ? _bits($mask, @_) : $mask | $Bits{all} ; +} + +sub unimport +{ + shift; + + my $catmask ; + my $mask = ${^WARNING_BITS} ; + + if (vec($mask, $Offsets{'all'}, 1)) { + $mask |= $Bits{'all'} ; + $mask |= $DeadBits{'all'} if vec($mask, $Offsets{'all'}+1, 1); + } + + push @_, 'all' unless @_; + + foreach my $word ( @_ ) { + if ($word eq 'FATAL') { + next; + } + elsif ($catmask = $Bits{$word}) { + $mask &= ~($catmask | $DeadBits{$word} | $All); + } + else + { Croaker("Unknown warnings category '$word'")} + } + + ${^WARNING_BITS} = $mask ; +} + +my %builtin_type; @builtin_type{qw(SCALAR ARRAY HASH CODE REF GLOB LVALUE Regexp)} = (); + +sub MESSAGE () { 4 }; +sub FATAL () { 2 }; +sub NORMAL () { 1 }; + +sub __chk +{ + my $category ; + my $offset ; + my $isobj = 0 ; + my $wanted = shift; + my $has_message = $wanted & MESSAGE; + + unless (@_ == 1 || @_ == ($has_message ? 2 : 0)) { + my $sub = (caller 1)[3]; + my $syntax = $has_message ? "[category,] 'message'" : '[category]'; + Croaker("Usage: $sub($syntax)"); + } + + my $message = pop if $has_message; + + if (@_) { + # check the category supplied. + $category = shift ; + if (my $type = ref $category) { + Croaker("not an object") + if exists $builtin_type{$type}; + $category = $type; + $isobj = 1 ; + } + $offset = $Offsets{$category}; + Croaker("Unknown warnings category '$category'") + unless defined $offset; + } + else { + $category = (caller(1))[0] ; + $offset = $Offsets{$category}; + Croaker("package '$category' not registered for warnings") + unless defined $offset ; + } + + my $i; + + if ($isobj) { + my $pkg; + $i = 2; + while (do { { package DB; $pkg = (caller($i++))[0] } } ) { + last unless @DB::args && $DB::args[0] =~ /^$category=/ ; + } + $i -= 2 ; + } + else { + $i = _error_loc(); # see where Carp will allocate the error + } + + # Defaulting this to 0 reduces complexity in code paths below. + my $callers_bitmask = (caller($i))[9] || 0 ; + + my @results; + foreach my $type (FATAL, NORMAL) { + next unless $wanted & $type; + + push @results, (vec($callers_bitmask, $offset + $type - 1, 1) || + vec($callers_bitmask, $Offsets{'all'} + $type - 1, 1)); + } + + # &enabled and &fatal_enabled + return $results[0] unless $has_message; + + # &warnif, and the category is neither enabled as warning nor as fatal + return if $wanted == (NORMAL | FATAL | MESSAGE) + && !($results[0] || $results[1]); + + require Carp; + Carp::croak($message) if $results[0]; + # will always get here for &warn. will only get here for &warnif if the + # category is enabled + Carp::carp($message); +} + +sub _mkMask +{ + my ($bit) = @_; + my $mask = ""; + + vec($mask, $bit, 1) = 1; + return $mask; +} + +sub register_categories +{ + my @names = @_; + + for my $name (@names) { + if (! defined $Bits{$name}) { + $Bits{$name} = _mkMask($LAST_BIT); + vec($Bits{'all'}, $LAST_BIT, 1) = 1; + $Offsets{$name} = $LAST_BIT ++; + foreach my $k (keys %Bits) { + vec($Bits{$k}, $LAST_BIT, 1) = 0; + } + $DeadBits{$name} = _mkMask($LAST_BIT); + vec($DeadBits{'all'}, $LAST_BIT++, 1) = 1; + } + } +} + +sub _error_loc { + require Carp; + goto &Carp::short_error_loc; # don't introduce another stack frame +} + +sub enabled +{ + return __chk(NORMAL, @_); +} + +sub fatal_enabled +{ + return __chk(FATAL, @_); +} + +sub warn +{ + return __chk(FATAL | MESSAGE, @_); +} + +sub warnif +{ + return __chk(NORMAL | FATAL | MESSAGE, @_); +} + +# These are not part of any public interface, so we can delete them to save +# space. +delete $warnings::{$_} foreach qw(NORMAL FATAL MESSAGE); + +1; + +# ex: set ro: diff --git a/testsuite/input-files/perl-v5.14.2/lib/warnings/register.pm b/testsuite/input-files/perl-v5.14.2/lib/warnings/register.pm new file mode 100644 index 00000000..45fd9a2f --- /dev/null +++ b/testsuite/input-files/perl-v5.14.2/lib/warnings/register.pm @@ -0,0 +1,48 @@ +package warnings::register; + +our $VERSION = '1.02'; + +=pod + +=head1 NAME + +warnings::register - warnings import function + +=head1 SYNOPSIS + + use warnings::register; + +=head1 DESCRIPTION + +Creates a warnings category with the same name as the current package. + +See L and L for more information on this module's +usage. + +=cut + +require warnings; + +# left here as cruft in case other users were using this undocumented routine +# -- rjbs, 2010-09-08 +sub mkMask +{ + my ($bit) = @_; + my $mask = ""; + + vec($mask, $bit, 1) = 1; + return $mask; +} + +sub import +{ + shift; + my @categories = @_; + + my $package = (caller(0))[0]; + warnings::register_categories($package); + + warnings::register_categories($package . "::$_") for @categories; +} + +1; diff --git a/testsuite/input-files/perl-v5.14.2/perl b/testsuite/input-files/perl-v5.14.2/perl new file mode 100755 index 0000000000000000000000000000000000000000..26bcdea3f5594f578c16d9f538ee10fdf4016feb GIT binary patch literal 1477231 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

YUiWp2LfafA>G}s*vvM``yAG8~ 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ȥ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%0Ax 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μ3#J@sCg zqoZTlV-kmGjaEqN+ZT0anfnfo<&(3QOJ7!&>B>g7T!HTEq?U6)TrY+;ouIEI6@-YR zmET=McVoC+2Fn$j`Zt8z8=ZEn_>CjmW3|sF-ocCyx(D`qXXT3bt?)|s$$!Z(PlPzr zQ4S4-fVNdLO0)>=3yQHHG&!9O=R}>?earE;vK)UY+aeZ4gI7d4A+z5@b_Oeb0CcHq zHH++WE)>2D4=_aCV@E+(6i_zwaa(%>aVqAa#_7~cSp(_klKk# z_%Cp-$q%=uc9llOO{gZh6O;j(L30lyIl!EfOo8MJNmGyee;a&aP;N>aZ-8O(0Ws%et@3i@R#YIRX74viMLu!sn9(LO zx%b7BfB#T?klzYXu;$*%+)h(KaxcTG{2B^@F>)&dVmyN=8?qM4@??mu@X^GU5*-%m z88Cx0AT$F=e)yz!vJfwi{|YWO-`qvV?5t&H<(7sb+;fC`i`>!eNZEq7_7w^5rMLk$ zBr)q-nT_hK4)os4=-jZ<0ywLTeMibPxUmfskf9VUY_~gdCfhf?Mi$Csc;RmQu&)ng zd~4j<=ac|?1GlLFl?~9lQk(Yv@GRBZ@2>V47{l<$jsj&m@thx1#2HsFXz#aC&W&{R zX)_Y6FM=a)v`OJPxlE#e!-WkOHC*f+fGFy(O9TG}c6pKxc~=6NU_IbB@_^vUx}o#i z-S`d0s)HXhvi~-(k15H#$hX5Eu`{*YNO1Xjv1qtI_$fPs5k&Iv#?8CiJvS~;9=hl% zHWwfQ!1;D7-In7c{_KB18CU+5d>*8XyN;YwJ@e(;=Z!Tk)-t1r)kMMu`hJ<6Ejel! z7s_J5N-%_JOcSe}Y51=2VZpaa9!DKEFQEK^wXmNiwB`CDoOtl!>nOgsV|=)de7N#o z98<=ZFt6w$m&u&o=)8}X&)x8E8PkU)Z!GH<9}fIK{*jdV?@43nkaX)acOaZ>EPFYM zK3sRY-QN!OcXFTZ;A>GItNjwCCDV1}H2^ewyXos?_V>zy&bwAd!%+qVe)22{+2DeC zd9{xWdcMxblIQ;6K6L_KR0aNh+Pd8z@sKfT@9((4JCDx` z<_n1XDK?Bt1v+8&R4FOXH|wcy)*gb3XmgCarjZ|x+!~B?VsH-mYZkx#UQ3s zNzO_jFysMjNZ!OO%(b(J$khV>zwxD6yQJlGk|3{3-cVjTD)GEw3Q$0=OwKRsmw3uo zR?j!P!{heoF~erC7qrD{yW`8(2iJYEgRbU1q?g z_kFtR%Zn08nfPPb;HU=_9%4_M|V!2S>m3Aq(~Th zHMQue&E~P9w4v)1wCclY+0M?ybpSuPmd0%WjODLbXgTXh;eC>BOYD|&N?Yq$ByG~} zuuP7CkMTYQ_C6m$&kL}pU_Kh0mkJEpuWCP%gXJ*NuJq>ZB6x$X1HfA8QCx_<9AGWH zm`T$1ls-u>v&EW*k#8GX#I7;~>?)-%t=m5H-IdA_aK(i=YdFo?%=Q#OHIcmncd&WY zEX)qgI=ev)NpW!0LuNV~N#Xoq@nc4|Pj=i!=RGpGw9eEhX%Qradvc#m;dU!Nih8>0 zr(xAS##CNkQ?OtQdLo;}R1re=@aLhic%A=fd0$04fj&q3zKkaFXu0~WRcj;TMseYR zQoV~ene7z2O&dk3nUU-e1C$$0i_lmT9lOyzs!Zj4uPl=;s8v2&?mj0eip9@cxN+Gn z48i^8L`oXM97up7$i4mtk5Z;c2dk4oN?u#zL4vd7wI%n9cvbd{p;|ky3mDmIsag(* z;`qh0%sQTN{7^}*pYRuZk%$tr;$2?29vN@UdC3RlCYE*{kdvJsL$oeI9j-m&Ke`5; z?}ev4U?z+-v9Ou9!DFA^>pS^P_`Zm}^s2$+kMQ23V8Gw9w*o1{5|bTn%O8yp({s)- z0*!a9Sz~F&BPVq+Z&Bz@r_|=WV{L+ZEHH|%nxU$v6uEh_k zJ0|h5|6D>5!B-zeop5N56Y!hld17sEEU-MnfYy1S{L_OD| zw+{$<(qU!JP(@Ymh%2q&wUEr4z%$9U*+}gVaXe*bF{!KNOe$(7WuD$`lxJtiiqwH(qwxMf+g<<8dlrC@pi?v*}7Fu;Rhzxgj z7cU#KlZPrU;tsCa$qkWgnFoizj3!g_N+4;EbLFqOsUjq=9p^7N!y9BHzqm-O;S_*k zb~7tY%qz3eKC+9c5e>%Ip`=p34TiKC@oo8~s_ECH#03b6BiqdFw-2$d3J`DF5Wdxd z`!g$6O8BFwq)6)f^<4bFj!Ie>ya$c9qmuR8*~wJH5P#1LZEj%IKsyhEC?&FImjK+h zrOK)>;rIoG=;$qn`;v5pOGpLG z1dG}G6OU8|Wlx3oE4|N-t1+OfWg}8L@>x=#NvUEJ?+N+y=7L)dEi-p27CBhE z>p1!r$e4v2Z}wNUd-Y(0kY0_cnPvl7$8d{_*hl!nEaK;Ag+=R~MM2@6)RdB<-9uhd zpTy12tMF=R7E%&FK|E>IE;&@yOm=oQIBR3hPJwHi53U)r#i@B7c>~`L0ILk0{_JU86^j~C@Wmm(B#9s6;l{jA##Ro@rBqZTz@U*MGrWC@{ z2j>ciU62<9pP&Ovw1*w_&@@7eGap*%W1%=rC=N-j0@raCW#u?lxvYX#nxK6V!-)G^ zyz^EdPEKBBu-P*HA8hT>1>I7JTIoT2-;n(&((sZssT~9cok?>n;Su#+9o1ImBPvaO zTpusnz6NVMqTH)ISn!d|-X=)~nc+e>DU3iA|BdMh*Rkn2xRDro1LtF~q9L`Z$UPKu zMrNzYm0&djXHm?me}g*=n4$XYDqakcp%+ToI!RoYn;l1g!IzFb@A za4-JM=ixcBa}@Ktf(HgdXu41&##-XVVL?CrORWsZ7+_qujHRu4Y^?f{_G0L@@eF(o zBI4c0pBak)DplQT=*EZa!@ho&bu|g+F7+_;E8g|$6BWMfLW}b9xIKM`>t4iAr*|4w zmcJ`Ws3vx$+U+KoOZ2X~q2)CEPM#g#(HIGhYUpSj7#iixR=tZ9mJL7mmJsC=yXp(~ zkUy3XY7Z&(=Qodw-a{0xYqM^Z|B*PH@skHgEuG#O+rsvl z@$eWTBsQG&7ZhH%tkGy{L$^24P}R+?%h(d~$4Wgm7ddDWz!ATmy`s!t)!y+uAurFF ziIE77;jA59IFgzt6l*Pg4>#Jnro?_cFF7N@y0|HF22v{BVfkJNH0?2)uU~c`yZ=>hyh8tR{BFeHLE1^mahI2$(H;cr7KiUyk;+hnQdHK zsgJei2mA0Y$qAou9v~X=CB@z%^+-Bs!xahM@6c@l_OfT`{!83|BMnxjA3znJoMC0; zyCPgU#mXoKjmzS5tc=zWmnElJnRorm$l1tX{$(FxemlAJhRPSm$UQ9PLSxtiME`FW#cv||Q@_-BiT^>EZ_oBG)lsbr z?*Z74MYMadl`%eCrXQZeQ-6#{1)nm;gL^-<{7a3oM75kpdD(T|_D_H|%DE*_`uCC-it3I|w1fC2Xqh!-g?mE+2cmns$^I`%csz_c)yOm zp}(JIlRJcGMRAL9a#NJrTr{K6Ib{zIOX34NwGoq%ov5tN66fWS?JK({yntZ8Dot1$)`%%Ktp&QDhD>9*k`Re>Cw--#`6JVeF&+C5t`tTV3`>!&35{D?MH~?W~VEpG%h5<6iJ8O4k__YI|49Kq)$MtK0f)2$qDYCElu0PC;^~oJQGX zWxnTM7DE|^`IjZ3_%FPnTpKxdyJ{1$4f;{c3%?%%zLkEPe)v?r)SJfk-1b?X3>pu| zUOQo~)tCbVnV2!fm-dD*{*>=z%PpE4^mmM4breaA{)&L&wmJYGr)k<2kX zZ$%XlYI~4DxHZII3G1%n2HUC;4Z7WN$B?*XxAB-_p4cHP;fju;C4}D}8_wvCFCh~- z13;g?-efI&K_4tx3zgZC^QjB~*HL+z1~6@EM4*XF%457)>qu#;&&Gk4VPSo!FOE%}(=Tn;Os;H45(CvyH`e4Me1OMdnLB)LYWe;aUT(x)*lw z!85ou`X5NyOOi~JLT6Ub2k4l_3rjfs!!iHpfJ@lYD;t!wB{4LAPqK5gw8p7$qlrWBcoQ?WPL zblDgC{(G$d>iulwI-eMc6s>&;`z)Lz@^QQ$tRlFp#2L^@QiW<^Z6sAfgK-JSudUXN z1LP^t?S4pHq4xmASpX$)KI>UGTt?t*UgXj{0>RjHM6@RZUuEWyn@o!s#o7F6TYvc( zB<^6xH96z!|8<*t*!1Ec<69G*ARuH-j1ZMlo^rkHRAEEp?>w?2M&;*3j^f6vVdwYf z=-*H0;S=&K;NyehxW32eOVQ)}?EkT+puv-ep&;G_`n30UXyUrr4v`GZpnux))fK}K zieaOMqf=SVGFLj8kIW9qrsvN6x6J3V78JHQvghlX!daL|VTeNILX+05J^;O)8GnF)0VAP88ucH@CZ9@#UM5&Pp3a*0CYX*0944oCVlXJ@tIM`LnFqo zZOV;F2w9*9{-}nylYhZ5XG0M3^jG%esPDn{8k#M9kys@Yj((SWez|*B!K{yQPU#Pux2j%vOwl-Z(^yX9l+W@50Iq~}Jtf9Csae5mf)a{k(RFCnPU5HyO z$Lf25!pHC_cB(d%cmaQ#XN|Lh2*Y(8mK(Q$P~=5059>5bzR|MW_>+jaR5X6M z1|8%xF}{L^u)E9)d?~tdUq~_1_HxPHbnQRYHaDdMZg%)PLO{%N ze%6Qhd}hild{Kg^CcxR?3;)-eBu$YcqL@WQ{)VZa-!*2DssgFCAS*+BU&LSAd4qDu zwxh%^xxbFc6hiL64tMQ3I>s>l>>txs1&02O?i)+sx4!pG^iDWd85cM-xOC&@a_21!(#9*M)Q|5Jr~^0`__uxMHmR2J z7oj{e{(I^+lkz|FD=3GC^Wyf`&Rnte@Vo(9$rc7xqD>xZr4K6cS3+W+wjo`{L@;Zb z{BQSK7d`1L;%{YbEGj+WU|9Z%1TvBJgcBJ4cPSH@9r$7e4jb9JN+wfBoC1hg<&ZEI z!PM^XLC-ciyWp@;B{HE+&K@ZgxBSI$SLD=0K`KdMURghBK1<^V`Urwz-Z$H6%=^5h ziNG|?2?`=!G>r)G2%pNB>pUYx=VnMp?OCYt(wn#n5-60@yL>3Sl|I3=1tgUc1OKIR z(2B+vt^Zeh(b5^sG7F*u&+1bx^bVOHd+t9rwxsrf_0 zi7Cc#mAbAv6mP<~rupkRP(o#U=jbi-B~zVhDh(U`l&0KK-6|$K-xc|b*O#Z}4GqUfNUN~dSH`|-#JG&Kecq}33FHsiG##5@^4#-o zJ1)20YR0VcdCKO!#DiY_uX0(J8@dQV>1MkW+HOArovn@`oUust)!OKo@8z?R?Tfr? z>7;2t53+|0AmtS6rmh=GIPyVe7$?}Nn`DfZBdDFdZZF6s`J@+e5`4@eQ3ygW>gMu}w~r9ouc%_OhnGmL(#3~TIqH*?E8 z7;BzLi+dO~3P%h&nJ2en05?yrq~Goy?!2SbcAP8CpU1uhiR_`La&>>vPXT0;3c@E{ zrS4H`5wb1+iBf;Q@z{bfG;Gw38gXiOY5davbdlK#$ENQt@=;UhNlAQT;xQsJTxu zM~Tm=fQ@V)12a}DJNI3Nz)_j0)?L`nB)~USAjFHE^F3((j`Glt^IxbBLEO@145FJX zSa_^rm7o#`7ses?VVGOfeu(ycP)c-**WtKi9F}~F%2}-R(KcnKlm|}KO0V!ZRmm7p zr+%qwiV#Z25=ZeVpAhz9p)C(n-Hm4XSWR!4+9cR2de)DkXh2a%m$uYU4lV5jUPh;L zXhe5oEL*ZwQM^|AV;ZrR+@sLm-a+AgJ-OwQu=@_!jE949DUdyh^Fv@>!3*_Vv1^8N zI0F+l1mpCI)cg{R3O@oW$@!(%SeXmWRlgrwnKR8*|EqlNEIEGw8kVs<<11vBttPyh z6fM+}kKjH_5!{B$JkV?*R*racSGtEI7H6YV}FkC3mwZX%tkbhGBIz z=)_iuz{ZbOQzoZCwjOu-J7$Uu{l?sAiU{57%e_aar5C=P9NH%688BKId9$+aSq(&9 z(ro5!VG~9Ou2atxGyN3?ik#Wpa3MJ(5 zPNxnw32_q>R5|QuvZh*ZPS!0)T-DnxcUMkj*mfs%@)?F1v+e1h=Bc$|${wOa za=5h8_i<%7UHRJ~a~2wHMY#=YnYad2tuU)lQdU3?H#TN38QPdVZq5N5_lDD^d$qE8 zL(kC$Q5t@;MkLQJCC}CFMu<025uNDtw!3!&1*BC!nSVLWn!IkMR?BHsjc-^@vd8{rcU#_E&@ta?uTb@nqme zYSo))k8m3&@)Qr4`s0}T<)S`D%?9rx;CR0@eNFN>c2yq|sKDW$gADb!uo9^};U20mZ#U-{$`@1b^1ZSIFd&fM1nC+YZ$K|}&h zE8#@D;ZT>$ESmTyu75ax{~tdD96rns3C$ib{(y;l?a}jV5pqk+(VMVISMk^q}`+ncZ}Y{MySv?(YL zqp1~>YhST4a>qnuAcf>N*y6Y$_vy4p*aG(D`Voj{KYnLCTEta16lBJu6(q#^nyW`3 zm~!|hcLIzXMnuK*mAEQ~`x)*8Qd}24sNLs+a6o~Rv>so}c}Ia{_D9t- z8kY4protu`vr*h}%n7V{=lD_vV~}>rAH`;j-^L@6;?D79MZB|}pTNr&dl#9n8!BSX z8{}cLr+?wRy#39t#_E2kbY_-Lz2HKt>E%F{F(h=|Z%d3kI=CO)iL=Ab-nN)ZleJ^w z158rYw3>zRt_UyaHnAg)DG)zyLATB~h!0-SU9aEcmX75o@891!u2j3n;<15z%{>#h z*ZrRh?@d0_HmHp8b3K!#Sgqxl2f-zzENc_(C1QdYB=`P@jIt4CIevDKn*yG))BT!s zWiWILCY6N<*7k!L5IigR((Ih*UC&n|gpXurR(c0u()0Pv{I;6!zwwYFPP3DE6aoPM zY}RvXPdI*nq?$cNnEqJ>z5dQt>&b14q44fMil7ZJIrmVE0(pLbqqvg0;_-^)u4@x( ztk${VwkK3N(^ES4xZ$%&v^@(yn%sl`Nq_S6Ux6ax8TL}@NmE9@vXL8EzNz}kaB}RC zI=&-asW)iWN=#UWl_^3gj%H02*zZk zg_5s&zUNe>FF94|v$`X2G2tBrC$obiJLIe-E9j1&(tkqFcvsTj{sph%C<0%}9UZ(E ze9{NdtoK{iS?~Vf=gsY(+*tvfcJ_;Z*3$4*U3iY0em34OxwF5O`6FAhOrcqAw(lUi@B9_)rDYOZbrc`(GJ)1=nMx&!K@Bp-1?YC3$Tv9II;8nq5oXa9-Ra zW1$Qv^eIH-o~m;W1PqRv3mmT#j>Rh$?LHHrA>4| z_QVrS(RQP>!lMsG3-Z2uZl_o>uEelG3^z55;=y%B%_dSlhD%(|N{mcM!o)#qeQ$P4C^3FVWgvPxFv=PGf?PEDHTF20$6k;v(A|U$bZ4z$aPUk ze_XLj(NKTp-i}|8zA2H67o~HM*T`wqM)M`k)JpFqB!4aAbblCLlaFa~%jMzLBd9`s zdS~};eQ&fA%fu3MC^b>-3LWtJ!ucv^eY3v2n?I~SQONZ zVr^b5y64mHA!Y&?!Tj=2oOpe5v6Uy|_iz?At`wXHBj&+9`kXx+f*~8k zZ<;v*$AyZ3T1uwfZG+J2_{_2?&C>$#$aHbu_4=fGUqPSe!h_VDELnO$q4 z&yh07iHZcwTp_TkH&*&W17QgEaerjRsbdJ}JTsZ7{r!vl-g#pXbT{$@lPibw#7J&t z@{yfQ=JADqJ*y(ouPfpmC!a?W1(qWK;P8#|fs+s;cS!JEa}yv3 z+RH_u<-TuwkX z50cjxRa)uSxKdfwrm}on)ZEnV-O2N=$S1=^1Mbnw+^;D{M#~Y{L76byArNx4wD$#k zUaVy{ss6XScN*9wII^_ZyNZhR?E1q6koXoHw!Mq#WLtIR>5^1eH53bf0(o@zneG=0 z`i9zS$iCq=x5&{i@^Ur9?~LrBFZyRri+lQZy*hM>UQHigo!W7kb*HbNIJ2h34m*>o zJ4%Y``S@;?Xjv*D!)-PnMHcvvPKR~qO#0FXFSA+G*k!zQK5K0LonE^S|3GKtp{>qF zCh;OTA1{6|P0yw~?l}+hkq?4E4r%)un!>P#PSBpy>Are!X(+c=_PFb7Qtkci>D%1* z(3;xLcvO>zcCifAe}ADC(m&tE&Vq1H=z^dsc%BR90Xi9w1yED+MZz}0p!<>EsTFZ>+F$RQDn(VTTvj(V8S$l%u~k#c?p2| z{XtIJ_R<-bUm8!$y8L3EmJ2MlQ&MRJGHV88Y7iXe0iikAd*Swa{0STvb69G1g&A_5 ze-LZIBKg7`%PIESn@cNwGJg?n(v>f9&A8Ii*5Y`e?q1X491+ewk`3o!~+oV%t34Q?*{Wi;m;yAm1f(e2sexcPLj_ zA@v=q;|oeEXp3{D$l6z1Ysrm-;{L`hi0z#{SlsTF;&Sak>3$D|2Z)nUL9`u~Dhn|!C-qkoQFO)8#6J$PwU#%-pj^Kgj`#^aq1 z+>QRTNAD&>aL11|7DOvZh4()7u&MYI4jv1R1m_?vm~H-ovFk*7{r8}i32%ovSg857 zvu%PKDqwJAA%0;!=H1`(xYtPePZi4kS(ENIKQn;qCv|PtuECzK3k<{LQjSpXA=pS!(ui_mH~>guEa3l!q3bXGla3 zTQtOMyEtbLo_BPR39D;dO=-L=8)>WLtS0wB6mU9IC&>`$_P~SqK9*e|C`7ZQFaU9C zZ(_$>Ynk=Za4z;6GUf+M8kzEM!m3!-5&p!o%Y=XAx?5^~9&P8x&OT~zGwW>9o%3b1 z>g8zF8_}xQ?W$LzRj=9nm+6W+FJJ&z57CKMy&7ZfXP(9D4o(Ckyn7k@21B@!W$uTx zhdZO;j%av|9bOX+udq|g)d?uVa?`wXo9T@6chd{!v3Aq$W9kK#_%H|+sW0-vQ) z0*5PnK93372H3^K`sYND7va07wp?~xC|3JX{3xvMBi|NZYPFJ)sy%G4@W$HV=VP^- z5?hQf)&&O1Ieh}Bx0V|sVRs^3pwj8Ijr^t2+u21L{lu2K;ZncIVX5jZcb4|!Y-F^` z2_HYDnCTkBA)&-l9{*(1bwnnNKZWX}Wu`R)@> zA#g~owaQw!A7lmLpGcwHwLSQYem2Zttn_HcVJ(@2%-xZCuRXalX{Cqo$o=y?*r@U^ zV53e?_hmk15+^94Y6JXxXT$+Fw-Es9p0&My$i4G^!^XgxMQh)QSE67GtKs{or*6gE zyD`o+KPGTtB!so3OyV5^TmZsJ5C$vb#R&|8q1ra_RW1#&m>dNwKp_R=x%5}XOBdYdUNuvcwBEkLHKZtXCHfOHS>m`>f1t|u3Q*+~HgN`A{vQLG#XuGt3}F&;2O0X) zJcTZ-VLa_d&PiWo5a8@kdfjy&qEQU5c)yR{r`{Xe?>Wlm*0q&~4F8-u30L5Q3aI)l z9*7b5cA|Rd!Iwh+woN&@#dyI8`M1fsbTuQ|Yke9n1NX^EC7f@T<=hRdEk68{`7pm4?JBG^j{lXJ z-BqpMFX+HTb)ctxzv+ROn;P!&o8C3|OndY)wK{jAUAv1sMmOOWXQO>f?3)|m?<ivG&!%kKWus8)6|4YI=8?q3K5>#HxeJ%j-loP`l{CYf=;aYzP8{-(VB>N|3+~%Zkw;V{yT}k| zG=%-^+Sjdx|L`Af(ofIBJN$2tQTNVh%yk&fxK7cyxE*ZOC6aqiWm z{&{04(;6#);?3+EW_u}^&urvA2rQd!Y8Rk;fba6E%xtp}l(O?m7wr0;U_1SD+j(l6 zgrsO54NKId9ud0`UOtTE4!L8&@9ey4^t3e#6zyCbyiI);cIH*v z(}}@pt*cq_NqN6r&fSY8cv(vpi8V$db4;V@b;w;)kh`W#>PYHMsCmjn{1&zQnH{nR zA9a!r`BM$IU(=ZV5ysioGR|7*xA@AeM9$8VkDf9%*x`2@7JSGH^x`==URbGzxckB? zA2|K1GFYT@+qpjUrE>;`a>EV2A(|VbD}33!OTMtJW7mFRUG%aYeuZf2FRb&P|H7KO za?TG4oQ;zMmZU2rC8-?7{^4x=!rB*&GJo+_;cp{Mh4p!Vkf~h^_b}Sw5r56=a*AH} zJKI?SZ)Csh+5J|it(U2NUG5Iwe!sfL=MtbES_jaN3O^6z&WpsVXmrl1rtIZqp3EY7 z{;lCGI7^)~bf%SVHxN1QQ7ukcWzFhMJuT)^OC&fy2sfuIlh>E+Ge-`g#w<=ApK7lC zptgEe;Ez;8cBv6cCdqp&8#zml2-_xKi~oH5{X7pue(=FW$^jL3bQ1pZk3IC3oJh|S zyGhq`w`rU{e?MWN9%a;kNhsEfuQ(?DrI0_O={FD8c-rH2>_z%Q*YuZJH)o#CgC65u zm>u-8QWe+EuZ|zmHr4D2-UDm_0Uw$_x6;rzWY9DrratZO^lFecdf`b**{1;T&5{JZ zw5M;6wUm4f04co%MfJc*^oH?f*0qcv+RA=)GH%2ZquB-dp8X(}9TIC9G;(t7ndLW- zmkH4tw4a#8cV0duh35FY`{%h_SZl}>fS`X#vdU6MEU^IeHF)}!tj>(u~5;O zLuMuH>0jH$v+?s)fLs7=V7}rct;Xg zYw!H!^_ynF4%@D%=9{g|Cl~~g1T4N$B&?mi&!@@b(bWBlDUD?x70r!h9~90;t8hfQ zOJoiqV5xps+iZx2>4*KJbh~-^w@v&+t4J{XdbDbVUDaV%tx zZq?1kZ#fvc(rt^aBN4VH4s!B}xJv?F@QXl&UW}rkoab10q{qgzBcHU5j3(1Ad7<38 z<4S!l$9~|HzR=tZJpRx?A~K2ylZ+}D&<|pcfe7Dk;+c^!Fen-b)N_`>*zCY%Lv#vG{KN(C z6+s~5WDz;E>tLp|_RxzDL~cD4#SMLdC^4d{l{N>7ezwuX|CEDwpj@HfanJeRY*YT3F7yx01;CWmE<14Fp)y6_Z;K) z?_n8$v_b!fzv%X!GUa@P(ZrGX^XjxxFw&owH(Es@2QKENKRJvi%h{2_ z99bzfa`%g+h}u|7S;RcUNNuJpay=hG(^S~V=zfin-$^cyT$HadIp%zDSG%za>R(6F zs5ue`B*#2Hm{(TjZ#+$od0#gP+dprUyk)|!)&tq3{fbAprmGPuHco-UX3)u73u=iz zDn-_5<~prb3QzUCl1h4p{NX2&P)8)8#u)h$=6SE`7MLo4qp$l3;B+Uao%_w5l7H`O zflg2-7eO?8>Q9^cUmHaIxnBxDvXRqi#0(+;m%A-xfK;pJW)O~CtC*2I&SZ%6I!fj0n`*^y2 z9(p-f#IrXcU0x5-6*-czBoqHOUv!x-kY=HZj*E)csHX(~N9yA?d3_ffLx!_8TJ9qGd%YC0M8&h!=63RCdYIs56n`5pM`5#jl&UG*++#4(gE3sndijcv$t z;Sxk?x=D1Hnap0}_PH`Ir2Zw*m!#$j{Z?5d)K9<^BccAC&)ltd^v%24`S?M5Pg6s; zn=*}(G>JI?M1O!7>++T`-SFS22%1Um`7q zsCsuI>VB7UI3>o9N$uz_dNcTVQ=Rc!vX+drmMjq%Z3v(5%LKfQD-U={;aVmnHLfz8 z>u9~HpsnS@3gwZ8bNoF-`XPfgR_1D-)~ogAfSQY&$=Vy=hgL(SNH}p zV;qiO;2U>Vg?U+5*FW(A^C=0DBsx&iwZe(C@;b>(^VQp|N7;h11J9!&R06rb7(R`> z^w&%JrzNV`mTL{*LQG3$6(7sB_ep-0Yo+<`Tma?M_GdC2(@)?pzajV49h#=WC-NqB zC4y3R@E7=m%BuV;e>jgB(toYa{yl`YZ0BWjXa;z-03D_h<^=Px+)yOWvvf8B4tKQa zIN2ZvK1hY$S4@%mt+DvN%cxL1Mc4cN_NxxOnmc(+LqS*bN~=|^cNR>~A;)M*_pE0| zS4%r*W~aoEqH0G^slMU+$Vuuv65p(SbBE>e21j?~L(5vy7gwQexC(7C@Fdq1YZNF2 z;;O&+ho4_QBenE4Y5{Od1ra6mOvdY7WOe~=H6#ERx<^zXdy4^C@p)`-w`m&f+UHTo z>EZ0(2dI~quaZk8ZiJUoTgYnKk$e0<?kCKTwC89uRJ_E=pN+RWpzn`weuc8-4gRDYx+q;N_T2AV zQmdt5mtxSj=XP!Q zZ+q_GXwbXF9J*Sv_ZZGMV>ruNawf@JFy<=20;dk;v4=%01>3de_A=%w$_LLEed)LleUa9)`B4m9;z$K82ny7(AAoLz(ei?pEf8a&vW(1$Xt zcj;pguZ^ow=5RiY)w+qzW(39~uRI4sO=I{RGLXLlA+w>Lz|D{M6ME(K{Z{%~%>}Ly zR{BR=<-ao1bSf2ROAPw2aLbTwMZi>R+8oT&as`Afa?oD&fv$4H0bL_CL90U7OqoGf z0f7{$z4Qf+b2idXq%0`Qc>$&qkyZQd-OG3R((mOfT!FqNmGTNW3-I>1`jD%ut`c;S z`(LmQO~D?=h1HX5Kbmv9N`}iJAFNfc4Aq}@ z673wn3Yis_S;;&z_1<{i@oQ#PNZgFBoe8eHNb^ggT2RzlGQ2*Gz zq5Pb&S{G)+#EElJ@BIC*<>Y@>s#LQVFff+hto3;}h^Hzfve%ObWp;mq5%<$gZy|rW zBA1#cnF^p}rp-UAnvG3SGdgq*y7J)wp9Cg;%*_MPzyd-!*$|mi>e^6!v|JzNylQ#! z5b$JX2rm*==@_oHN|iv(W=7kTm)S7M#4n|#@YbAupWm*?%l$-G78m&7#GmrM1wWz+ z>0TA~Dk(OZGKz!3?_9j z1@Y=+y(d1ZyC6P{E@qAa4ra9_Yi1*c%nK(H<;i(PKTPyb&I5>Pi}%K_%v}ikhR?~A zm=F(34eVtV!sB-Lrk%y|>o_?%`U0!jR{=kMzh8nC)Z9M86XR-%&8BKMd0IMlsNYul$9$txWe+!D zV#`?>eqW=`v-Qb6N7h@d9j!YUfYr1XBcrp{J&s;`=TRLl%<10&An&jIf&Vc6#_LTx z21cuz5AZ(VR#1B88-pilr37U0cnP8hMI09U&ofIIl=q-NvJnIGTLKffje;n6=xOF7 zMI5sKJ_UW&{cF0n=nGfelKZ~LQpfY%%5to1Z{M)GyrV@!+t#J)~SkT~O)P3;A3idXubpvhNpfD;jX(deoWvR#uF7I8b5hs z@r6s_!n+$W3d8jH{g2f?Z>7p;u%V4t-MJfreS$XYt@Lks!PPV?Bi7Vf@{=%hJAOo? z)w;E9m02`p9F+K}djLZKKCx^WB&CYMHKbNwhFJN}%6&8zXMIB(fHOQz!_#}HssS5b zwD!#j&G8W&6nwj>{E9G59p`vf`f=Ugc^zM9=)PYcS4W%q=}(OuBfmX5y`yKN+o#dl zk=nEyf|i-hYg*ntSz)Ce;RgJ1B2Be>Ca`Qql#|G&SgcjlQFS2uxhI z+YN5NNr^_Q={@)Df;WPn9yTPw^7NxjoIv-qoOT#eymCxKn{nU~tz8a4fd|jG24iDT zEhR~g=V4UY$n%ka#UTtjax0X(m&M_rF|jw9ZPeQp`KDO=PUZtM2jjz8e?N_}>8)@N zF)WUik^Ue#nwd}@ZS_fP?lZ?Bo!u8G97&ZY!&lks>){-_wN3QGW6GGF4S9@8d)SxK1ANrER zgj(*dltXx?9fq?sfad!i)>uI0CTgRFZ#j zk0X&bmp_^WUYu*p`4mOA)%ZoIJwGZtwV{~75DaA9p~zB5&-AV!B8IfH`4(^cqoGA= z&omsrMiY|Sa#=7bB7eR7h}AlqHH-Fl0-$dDo59O`O_y+tY_MugO{Ck`OtsD~YI~Z3 zZvB6~zmsnHt@RID`yQ={e-TB>lbl3H`$j0f(wFYN7q2UivCgXVu6yISH{Yl)TId0hNh=ijN1 zH?reiz(Ink`BOsi^5o9zWoPj5*iiE?S1ls$>IaGK$kIirO&jYj@KYJDDwrSQ zqfFVn*cE?H$t-*Ns~aPl_C_mhsT&dR2Zw8n6)@(fz@eT?A#tc?;PLl+>-Xb_iVEH) zw&Yg!zAxOr@><>R2I;IqPdW^_vpYsTV_7t)Q4z z_KZpsL$k`6GLLmo-@G_UQ@B`DTr8$#{Art03wY{2@DpRXld+0}y-u@k#W#|bKd*wQ zRw&BQqq;-g7bjn6%slIiFS9bg)Z5~#=vOvUNxLZf8=lfg@EBPAO*O;rQm~w_=qXfO z3_PChbv5{ki|h9Q3oA`#b-qJKXC&wY%{`n0352+i=ukBb%Ek-z-(zLP)#<*JPQC)f!Ekb?Zb5GCTMh^~Zgj zo4RRM`U$!}>J|Zm6hk~4bxYD*Kf!fVx-0%jgR!9I9?7q#SnZBE%p-t|wahQ-7*`Z( z9tTm~We?}PLCi{y(w0mrhYW-ps$P47C*HlQ8c4hL@NtAB zlX_ec|CKQ|)N05r+NVl)+(*We@T5MQPU3qU1gZLO=KJDvxFmdePI;_$GY~tudk%W@ zF`a-m(06F~(c0JIhbx~udQ9v}Mvs{ISZ`9NRO)Tw{Y7HGi`m}QchWY7=k!nB)D2)> z1u)i<1%gb?0v{%K0TYcaI{ghh{2WdewvJYLW9}$#A2yDFPSJ~g^mx>r`i7(DI_s?^ z#J7GceMNJBV8+~bShwmRKcL2GhRL1N63=C}CJyAwmsnZ~hVs9*(qrjFN6|E2*MWQ6 z%5d&qK|7rM5VlAE{TW)ZQlqGiDh}23hI^)vkMmRes45Cm(Fzj`i4)n^9xNRCB|Q2J zTnIzv9>h-VuEuk>(hr*S)*DLRC3(dqF&tR8+(MK2 z67pic<3@wcr|(Jb8fc~Oq{ZmG^$Od26RBvN*|H@`2# zgO$EPyK*-2J62UJ`-on7*9H3$CIfh)0hjR2qp08fI;nGh#Ca4=o5Q&*IS zy@P!C6o};q8nK)V2!oILw%X_~t@I!1VOL}(ivUt!bK|cwPvW^I$B5_13iscmML-Mk z0Ej#e84U=A_W`>X{2*kK6Oe>G;4kf)!di;;zI8k`rfPdN@&Kt#A~VhB|4p6--wE+D zdR2mf-q}f?;zQ7K4V3`29i-3GylTFOC~z!QYRoHLs;kAbby!LaZ)at1Pj5b7W)=8d(wx0d5 zNrY}YZ8nP1Meb+C_fk3^^=?%Ta3qE%m{jaG7xH&n{J_Q?lHRV5q94nBqX6xy1`a|?~0 z((Gee0O@Bnw+axlYZse!drOUBIOCPo?0P0EOr!Mf?v9S#u(UyDn4j~NIqcaJd%CEA zt3S{v8o{f`OU#*ZkWC*!nXbr?9R{yt5DW0?-(vJKzoV|?b=?E4%rCg=Xuy+=I967h zcPsbgWAkp}*IIHq%MnGz6{gT0rrQhK!zY1M(07A~N9&t2c#&n%bbRFY}4TG^!AHj3SRnUiKDWT!7fN>#9TGtlOLF$FtJR^Zktd?Atf z7e6!0z$8Zn`d&9P>|Xk@*2)_1((NK#unR_w6&NA^@GNfM%Fr&FXFE#e$STqfLROMf zcH=kVC}&}08cWj0&5X`I2RCPeo8HB`{?9t6sLszAtGe{TPt~Q!P`=Mjna9;cfbL8o zio`oYy?cmb9>K4@{Y5C26Qe)|DJ7iXtYIO2;Px~9C9T?6w(^;%WQ){w6;QWpr^d2B zu2Hav^cvc>b+lG}1ELoF{l%;ux!GBdg1`@{h6 zajt})@oP-bGP^c7I%fp#)KPX-8Oc^`8f&NC+hecT!Ebw!U9|$8^FFEeVRgmU!q;dH zs)!@6vvI-7-*M;u{%y9j=`Ph@_gFML2r27IVomq*y3l%4ye*@Xm;B3{V@izHQgQ~% zqAwfcwGfLeb%m7~JX(yR3iU%YdlO~g#^U4MQ{RF!x_pZ;!n}WtG+xPEB4`w@L zN*lCD(@mx{<%VV)ngw$-uie>DLj$G-GaZ~RV;490ZZnH$(T~7Z8ty$K-}X_oYL|7- zD%&Zkba#`i*v^&!ESl+Xe?X+OV78Zig_JkmW>6{^rMH?&o!8rvVdEG4lm55?ON{bw zr*VtPug89={A^zv({kG%w#9?=EG*GVur+(!1Qx1$-r0(X8}s|GxPJN!4E60C>){rk z!6PKu;coMH9FvDd>0h7=Bx;oT`x-T@NvEPrUvC?DNBb>HZ2&%z?SCy8CG$Ax}Sa4_lT^ZndR!~ z73FgHlXquo_h`;{;ld7rr*%5gMP?Z_ixa>$YNbx)p700`x*}UaCr_ z?S`ih*+I0L(LxXT9l%3nv39tA@%@S%2CTC-s{rpfkpchwNQIySFYb>vot=V0u(gS5 z6!Np`D0#9m*4y;Xd6N_ht>^mhh>827-ex0r0PxuK`gz$YH#F3)y>T#{$v?iNsc2=@ z%N*Bj-TF0)p(}C?bA;7JtTaJyB#->p5oh?xBi$SJHEQoBD)Qs=`dPRBhH}XkP_~D* z%LKo6H`})uLS;ZO^F0%~`6#SMzHbYat4EOz$!#>Le>0p#TlfL1Dtgaf?9HzNkRCLx z1(5#@04eO%?dE=FdE1Zt=F3d;^_1~lp7AcluQb54H|Nyvg=IJ664Dc^Ps(0xB0e4o z?F!x{T<;&eWL!8h@#A?~p*kOkyLB_fM}&%uUX-`zNk#c=}VePVWzV z?9(ewJA1>wN%Jv$dJq2XR>A8{E8wZs+Ppxuw=PQZ(;6xg@ep49u=y) z$kQp7d3lcs#bWYw8PHgI1b>Jyay^}t67WBS!LE| zAZyFnn;5C5gizXl^ZY@StYD=5kU|DlB@%%)a*FQjTg?Jujnr2_7-UGU`&4T;qnT=Z zm>!y=3<>-B^5Nw+liHf(S=(a%SUR=7y=F!JtfRH^$pXAqQ@nBt5I*9&OuVy7Op$vl zwiJ_d-}e)3AxOn>$pdmGc|d-pb-P!Lm+@yo_{$DFj0Fz8=77{K2_d#se3<{@l4$3pcp*%aT40B0(A$MJ?QHkHF$3Aad>fUv<_8=6! zkU^UxbJ>g^uXV+ z4xPc*=z%lvGb$moBO_#)*~15qRr4!$6+03p&*#%v)n@p%1Fbt?XeFBY=L90tkfY{8 zfPmfFO7xT)>)z9y9CIP>g>N%>Wn~r_8aU=b zGXzL{s)k5pKe9ZM(J86c&U$(Mjr?jjeP8bsnp;d{zKR7`?N zTV$4J>jtpY{pM-SYUKO>QS|#1Rnl!lWrG?wlYa+3Kibl?Ls`tc-OQqquN0bx_q6*8 zQAn~Dqb4bgM+8@s6a|_a-RjFI!dq~=K*$Wn!Skg;oPsx|{_MD(WRRI_S>+8&Z>8JI zALNg}pv;ORF{8h*+MeYFt84Xev%0+dAu9RxnWMgal%u%#Zz6B)OrI#e5}=dX3=$Bfi{ z^m2n*=QEd}$@~&_Xaqnr8wWhI4Ach_zyPT-88(CYbW`K|iZAd68bT@-7$JH&;|saN z#&9?_f?-auH$;ylvotLSkf~Y)Q%vPjOdy1EP%Ijp1 zR@7e0-(+D;U%)3`sbBoup5kMs?NvK8XurftQ}Zsr=!o8;Blju_$=%P&Z15XP>_eZ! zJw?ld{HkxbTZfwbs_Azr=iLV6lry8#eSNA1FJ5!-+n)#k{5LTeUM*>jK{yeljLb*= zJpQ5QiyH3^^R$yD?bIK1Npje^%=D38!zjK{PcZKrZStd9N zwxL47V%S!MV34MHLm=84xFoRCq&X@J^;@u0_Dn0?S11IVG{hv9c6U4xAD^;6+Yf5V08$c<4--8{TH`DzSYnkj=B$r6;ija?un#hee z5?v2G!m)JPeFEad;yR3Lsc4+0Qd5cDIc}!fjb}T?O)AZ0XiwYQojhV|8K%np-}6h| zaiTHKcpgUHFe~45%zR$hK~t|+V<65xr~qX&%s$+EB9#3Ja6h}azGelgzF` z9D95Y`G38Wd*>~P*hFv?DD|%poQpK%H^{fZ_`z+u95-1%FkbCeTdO#FO9q-@|5YaeKQ8ujHR@Ou(_5WYz}5V z7cbT`)JN@Yzhl#MYj#O}*_j;pFney1`|PJ!`iD{^dDJ~T*zHa&_T9=3=Ibbj=BB0W zV-uQbNa3<})h2dqlPZOE;GMio#hh<)=#=X5wVpds zzgUNTH^+VP7vxambE(MoEAox(obf1|ZeXy(GTKKu9TIIE0QVlNHQtJw;&O3i6JL`j z2Hku4<7!SlG}XobmgfiT+WR#6IaBlI==iC2)@e6gdaHFC;0O-AAk&=t-H?Q~>yTnZ)T+(-12X#f1uv!`v1kUoXrY27;L|5Rp@$*Z(z7QJy;f|Z<5v0| zumBjztK?NKUB?W76mi+eKB_RgRNZrDz3O|_%@-ZW4*U`tMTyGy^>d#}0CV|Ts*YZL zT@*CkmnW^y^bXBEx0?wk{);M1;B+DV#~+QvK>09Ya|QzMFp_3OWv=cozWYzD@t!ojHS+YGPd2iO4T1xFuF)g7VBOjVcj z37hSuiB1}GRxWsd69Z4}x+FfOZ85dD7wTJ&LYn`gJQ45@1#Z2Zvc`Yo(ZH}H-)2y( zp2g=oydH*}ih)FDsZ<_bmSiBF(y@?vk+imyyAAIWjkUXC z`B!=%;U9@hXHJl;3sE3Fi8*46`pm6Gf5q0tV!N5emRy>oTVt_vv|LqLpQ{M)R~Ci7 zCUh;xX!s8pH++Z@?jS&h3@#fh`6}1vlKDD#H^l+-q3!NrS zdQY4ktoO6;U;v14D4H1JbRd_{Kf^R4A2nA8X>XW7Dr56kV~kxCxVfqtm6p z`3?f-BhEh+(SLm8E`F_r@|m==H&)myJ}z!@wl?sCJzRL&RB@_P=`!4@G}!1Q21(yO z#Vez+8H-wLA^?97AAJ0V5Xv;Fg;Q0vT9=#1x_eugUkm0I$z2yG z_OpozQOHZIc3a|2?`XbA?m9j`nF_31rB5eKc#_eqPaKr1=%ufCT;Mk4$ID^oZ#SQl z#QAgVTeei>OP;%_U$SNl2i1a46!kq9GroQU9#QgR`AE56&oM!| z$adcK&q=|1(C3r4;%TyFZnf2l=gr0O&r)u+eQ(ryyz{h{y0*#T?pU}TZpFIA=+!w) zH|n%2-e9dc|3zm-U<(7+-QtHaed$aXqdT#yc9;wz^aT;pUGf*{HYpZO?YMbPnNYGk zIKn*EGMxi@KelddWsZ}hkGC>UaDj=HcsZzgFIatEAMfbge$XKb6z}~$(H}$l#eS}A zZSk?%FM+$TOyg|5LU?BRcy{v6A{cMiL$}n8-~JD*%s;sD#R!2<$x%r?61qj`M&<}Z zmq7)*0RqHe07DYQA+ELy^fA7BKN`RxoY}ej9D}nB3r;Ny!521Ep>^Bt4g`bEBQy6@ zoqO1BnaZqA340G3hI2hwf}FGLcs{o>B#b6WF@Jja4UR{Wr$_$YeH&eSA$>g! zE8qlV&K*)$Yu$M`C{s7mYSH#rcf4<}szXZuDd=b|IW6owmwJC=aun7 zMMmwGpB7NKnCxda)Jfy<1Io?>KG? z1kSfSI)y>RS{{|VSnlXWbS5K~lsr)Jfl-_jV;pUe?o+}_)#)8eOm-$BM4~Mh;fQGh z+KS@Of$0B^)o!&?k1-CD+I3Ah_p;ino5S(Cv|!xu+&kt-R_cIuy$U&kkwiPJ-H-roh>D7$4DP7ifTGyY z-9S$p!4=nmai2v8mw||y1ds&xh|8cjg3dTr5fOxuO(DTmupp1ep`-Mafd z=iIa1b8!;X3cb!c$WfCErEk(y;XPYb4WY9K5+oV|Z6z-vnUgG63SopxS{=**0q$K+ zN~c%Uhg+Wb)jAbj8oR*xikWSqH<~{kq^BQd9inZ$NsJ!K?B(RUhii-*XRHg;)~T|X z=6yc(3$|=`o=wgO&Q1O#>(op`bcvbeq4dX}^rvPCC$741mTotV{g#P@Ug~fa z#U4{JH@jW(c>91|bXzV4-a|j?ALwQx>%R_Lv*K8mnjkf%#5Hb1&1b0D^fYVw@~`Dy zQ{&8}hWW#Sf;|JVEF4kQ42c|yC9yfUp8Q|Yb{zoe5GKvz_t?&wqgnx|I^N(;8We(6jvb* z^Fh@E;+D6mf4Ok=oL|M&lQz4!`o>!ru|db(L2-2Xo4uM^2K2(IWUuz`TPmni<SphUZ#0Y9%{k6=@|W`3>&fLTr?bcsjo=29bh9h@B1gSQ zx}Ijb2?U%qyJ4~$vkj<*!a=l5a|_5$Ph1+-&3RBe4E)G=G3RMXWA?i-7fg5X0x^?g zGk2eT6%4nn6GGGP@zsvB;#VvW)G>^_MV8KP7C<12T_nqSeNW2_ z;)8mb7+I}wJOyAQ)@yiDT}j%!q^cvCJO7~&Y?1UB^i89AD#<*$s6W5ER#T`o z*MuhT@ZW;b{F2NFH|+Nnr%`Cqi2jkx`3n7Ak{;7P{prd*dGkADnUY!2gCK}^LixO7 znI<*Iq)t<+8{*AczSws?*@y&+~5wXx=1h$9`Ej`;_lg}Lo-h72Q8KJf59 zS8y{9P+O5M?L!c5ORVLK1Us5wq)dVI>-#O?I9%k$T=QXnc{*(@t8`9RM>cXo)O%zi^a(2V1nT#~qB%5gFL?&dv9 z`N*IV6Jy=cn1!M^>CF=-7b%=44V#s^_iSEjM@-}e{jEtX%RHkjL^zd14`cl9Df;Hd zB*vbB5rTOCWBO|o`6k>4T(vK}7O5fA<%xB2Jy=t!ONBFY)U>AAJLzU0jCw6M@7?}h zxZcT$Tc`BEwKR;bAjGP)B_NQbiSfLT4e$>Ow+rt=;Q}ByS;}nEOcBkP(pIvhJ+lPI zThz-+KE`uV4=dRh_vfOJm5TApx8Xq*4Ff~))rIfjmCK=zSobDpaMTp&qvQ}yeLU$1 zf2ZFn$bdN_*K`6;8YwEgBv^ILUVJ$!ci4}kH4#T@qOSl9k3*@MA3i2G^z(Yg!OgeZ zGJ)14H*pEG50V()Q8Ip_#p)qb+p(z-;X6IU{K_kr&~HQ%nR%{yd`fJsbSGs-v@J`(qHZtk74>|{f=ZX$nK;c^3tiCZ~W8Oe-b zXj(6d?ackxTlh$tPcY!s%*%xD?+gz*$*+1oDN&Jin7|P3s23mP& z>vuJ|hLL-uG?E#^Wq@^PEh1@`ih{qRf+e*{LqKK5@#rjT;?d%0CvaZ`VI=Ei(x`33 zwOqTCsxC>Nf320A0(O;T&L1dy@3lZuByooZcNvdmX)|9HCou_*!=7Rnbu-QdJ?S$h zl=(ut@)?o&#%Il5+{=7y!$(s4+YKk0_uU`@)Jg=${?<+U+D$r(*|qodHo4ZBq!|P4 zH{C3&-1lqkSKRj(-6G$qmKwLnVmHfJdw3sH#RB(zihZbCWI0PpNAm4y?)wdH6#@Y} z+buG|O%f5Zx4F3@Zjz*4`=4&oscurWlHPKYdbmlOl(gJU%5#&}E9pr$X&)qrq1P$t zZZ~POn5|G`cAhe?`IU|)hJ6V$GC-$V9j_kB6|9Qjd(%GgZj3{4+UI^Sg8>3d;k)B20DAW`OjeM-vW!6ydv%m;2|gfxMn7;mmvKhQ$04}M_7*Sx3D5{c4~itJc5B2| z@&on=Z_AWxhOU{>hK-df^DoHO=EnHX9rDXn?Fw|?zs77ivf6PdoKbW+R!iIH>X^OmxPWnZf zM=j7i7@uafzyxJRlxm>UP=}i-@yXjDDsofcrV(S zv7F3UB7+ubiQMocy6hT(|KE2FCuAi<5BqmF$m5BtL8|aw9fb$#hQx*xjjtYzB~soI&0uFlUGM zfmPGc2&{T`1tE&Tp*P=^ok>*jGk%oYqXZEif0bSWFzK9gDAbNP?OfT%J8V%Hf0tyw zAVhtIz%erv<8IM?cNo>lv=hR3nj@sYm^JMvJvQ)|J*|^@JT~xRjx}#5Ux_#7@>s?p zanOCH%4x^LQ*qzHm!-Y2lB~u7qJ1zN{3MdWaBI#f?*&x3BLX*k6V$OZ`(;zk9$VfH z;I4I^{cqFyi$8vrPI~QZ;jvQ6BI$^xE+KzmZKV8;Ai7#~(Ni0ycdS3k=vg>ui}Mg; z8bgqOD_lOZAzb)<%&7^m)MnO#hKqNKOj{u+->qX=O?1^41ASs#&$Lo!>(N>^E-Stl z`dR|C#`n(T8hQF3-^+JhhDFxwnJbt-rtuEmOM~0pBhbg2ekgWQfP$RIzponm388m) z(i;%(X260jTFbID#_M@2nh>jl7Ne&Atf79rt3Sm31*Q`ju?KbU92`OhKAb15uL)+; zffwnS;GCt+aFxYhL(Uq=sIj4sB`)J8hUWZ>Wh^2DN|1CjUT8RvjdfM?o#7%wOobju zhPdQTPlkAkPw^iS7p|v3WuUchpuKJrs+J4Yj;G&cD?-sN+ffr}ItzCwL!3lSvD3a; zeu!ZsN~Uz%0I{N+r}_2ri#-?j4@-bc*;2u4xNw^_=Vf8@LPS5@l6V9TnVM8TD)&J0OW{sUYdZd&X5R&?ufHej%mxlcW{lDZ&<7{N z*@N?HLi^j*gc=NifUb0aytoH}FIUFI%&|hm;kfwVXEf&Y za!)rnMR_ahDrc~6#ulKsRCe7LS@f(`zVnJcyYs&@w@;<eF8RcY^SIJTi`&I;NS9)Ps6CXvj=c?>la3}=teb9B{%)C}b=1sL$A z7fDob)8eujTpln~eNf-ph*)doCTFbV3zC>BEZ{vIU!iBFF z6)@igL~VPS;+3}pNVoz?r!~=DK^!NYa)3k^OeBQ?Y#y1?sv==SbAQpJwG|v zU(QvI^k!Aj`!lvYS(zu=0~FmsQYERHH zS9vq?s67pf6V3`ZGb3T3w;1R(Yry==UQOPw%fP4d;W=E;G_90x<8m+@>03zGj0#!o z=s?WWa;yby5W^1uzW-SkromXy`2?3U7q5)J$2iW# zo(af!+8lG-hn-aS>0;(pU@jS9S=5L%^mFGJmkJLLmQVc<)6Xc31i6ZpU<{ON4@CpH zMW-v1i=hq1ZA6|M4V*94m_e~WRg0}!NSES2hOlJvP!g{aC)qA~`!Ljn!wB6Hjg(iN zMFj)ay@INSW&X}Cxdh};(5m9!QA6}_3Q4~g(rQ}Cp)<)PSLRqDAI|1OAeP6(%~LH! zeWE>z`bLk9lrK_|%7RuN!DLcae9EL`iVvYquT3@f@{|_$_oX&9D)BZ~_4n?*=Gxtw z!96&wx=@wI_vT024|p@am&3j*6D!-ti)&Zu)JA!QdO)524Se>Di?OhXy>`ZZ%aAf1 z-+#5g8y;KgCM$W+7D&N9K2=?K03X;McEQ=f{6pMC*wB`f*DwJM*)Qf=bN9gnyRUb= z*vgvwonDPGN2VEICag|yL(Qtz&N_X|%-&vL0x@#6W`J9xY2RD;%Uz5s` z2{|OBdlmwjPzQF#oKUg;5s|cz{F$Rafrd?&$ z@mFB=zO8c=ugNt~yi9Q!m9vWKfl;*D-#({?afxBW^hHl?-}h_Y5;GK;5d>qjud}ms(6*whi<|}Yh=e1RP`?ENn#G+<*4&Sg zYYnZ7U=9*l6>eum+rU@M9}MwBEGS76&}?VOGX{sEZHAUl-J}%dxwyoTgHJLY494$V z8IPSWzU3c~$pPzTf60uriFK@T8O90TDY*}X>`U656-ay;OnjAXcAcT~U+$p!3zy$% zIJ%l-XT8Eo5N^;eS)UacHvhCp8h!W|&T2fv7z-XKwL#|?I67Who0m?!XeW8r)a3Gp zx?yB1EUVJ==d-VH0b+gZk8f%p@cBqg%;Ch3cUW`B;cn&b0jbATX7-P8u>ouD8Kh&W ziS#+oRVEUH#^36cr!}*I&e4QKo;E}&6kD1-t-w4U8(5k%t*?1($X=Q|t-Jep$I@2Q z4r>nj>%)gvCpH24)vcjx{>}=0V;{{6+MO4;`)C;=v)M;Wvu6-Y5VjV(nLT`t;e>(S zZ$VX8Tba5Wpll9Ov-N%eNL@#o;X9?UMMUXuR)3dE%5x<1r|OO|To|+F+~lr-aWQZ( zS-5+2r2Kjg4BiaW%AA|M7U0Xa&z|G&v)(#r?$KyZ(|WgDEf@yKxz@~u8SMe~y6bd) zVYM?6ME7c7rnNI?&8#{T!c*eHe=-717+oIi7_g6B1tvUf8`x-PVB-gN4Hn0EmN+&q zy6nr@z0DwF^$KBn?)S^kE>Uwlk};xpB)v#bXoR}!9+lS~ncg9jmHgL4(x>DHlN-S0 z*%bGLyXY{4b7@|%^hFCnr&jEqR?*gI`=Wi*ThrxWAlBWUdJI69DUMKXzy=yK0LvM^ zK_%=D4^Xvs4CXu#Z3kP7i`e_5`P^>QlI-}{EYtH=RN-evyk>-6JiW%stxV>i5&f+@ zm-FPc;gQ0i{hNO?`8{!XFz|#VeAz1~;pQZ%O032YaG_=8mjrR#ca>eGZiI1XJAMEn zKtXxBtU>qA6dg}d2vZPi(kP}qMJlX^@v6i9&^7H4tG6+&gPoHw6SD>4Xe4HjGFPD5 z3OEaBf??P3F;YGY4VA0FEHpPqS;;z-aKvcQR1mI{7ae)9FMnKxx;#RmaC(k`2s4ERfpOx_?!9XLwSYf6H2M zDH*(Fc1F=4-Mo`l;xeK=uzUSZU~R_Yq^qZZPFrOm|KbxYWX3uZEBttdiVt^S(8QwF?5 z`QK~i3P&?#qd7@qmdogkG<|9F(Mi)NBX|o;c1Q4A%qwQ}R%#C@)YR{K-WvP;g`t0L zzlS&WTjgdk>$e%Y&=(tufZKpx#Voo~=5hv3XG)OmJhGLQPY!}g{Y%qdbI^23A>mRgdeutw)+e>|+$PqNBT~Lx zOlWC&GXFuwj0E)WFxIs|V7cr?=~N%{p1U8?38UF`Z7`?Cf4df3zrEM#fs zPBU()01C>==lKjdaZwRlhNj<(q)qJ_UC3VaShi8cBEd2;hDW0Ma>uA_uE9DQ6+JBb z{K;Sm>M30C&<2#u-un~1v*ukl9&hM0diFI_Kw)H&k@O}$QxvrJP>7DPdkLMtz1yWB z2+!Pr9ZZ`K6=zaOY5EZZ>ubL-OVXAKJjg>(klAW_@l~oxIB_5qs#N5~TiG?X`c6);L(5~6SoE&N+d>PtEYAcEFgUdPcCSl4x zYK}}bPqVD#%yXDaLPH;-mURxq3l(}6Ip}&T+7>y5Q+8J&)t8AH+!P}C7+$^IPuhq` z;TusYbEII)=2N`*ZQ#0v!OX#m4~S^$G-vEtL8lIG2J-MAkzUlwO8(T{I5;J5W7lcg zs*~SNG@GGEHL3&-kR|Q26*^ntJomX-q|xv;U7Wx9-Hq?Ljl;N@9Yhj8qlNgMVyls& zTFc&SMpR!_$2_8XDYenbB~%34^ub?5krrvFg=3+PWAhF4LF$zhI~d!(?yhN9GU$AG zopIi#+5?RwJCL~*qo>E6A{=vX80?B`2JFTYi;{(pN=^}v-cp-mfw8U-uW4CTj|jS3 zPcxzfLciJ5n!~r5!~T`fJRJ0dk)P4**D=$s3xOy5IbX z#YZ&Ewo?ir!^qyOO>y+~B>(9OH zg>H7moA2k9INp@7<{!haiLfVwSPB`-rF=2epIvtTNlW`bHa`2=)i9i+@EkK_0Kk~{ z9QIw`(KPu226DcfKMH+d7NLaloW-Pg^jz4-nHX!?_nCozmws?pO#s}AeG}hvY4j@{ z6-XWfjwJqr+w&BPVR(t}$(q(SzL)E`6=omV5FJ}bO_NCbF8i~QnrZ<0H+*Gv_JW9{ zW6fz}SHc=ItZztyG3?6devvVhBTF;JaO$V(u8_$ELfHYIq>82?z9+l9kwsFgc{HpZ zD_g7r+Q_R;rbdtDvoE-T={m~P84|8vKvj|Q={WD~vX7>NBn?*wMS4B{pr)#W_=7Xw zFkgF_?svK1+5d;dagQ%Qzh2`$dMlWU)pit)hRG)&#IS3r%k#WJ6`f45J`%;IAJ1>& z&XelOTl`gzO>fUjY5FBm80UPd_12M2-)-oCOx(hC#K7diIMcE6P%!qv!NGNe1$n8$5F;yD{nz;fooG~sr_6c}XlVd#aEq&un zrJ0Ek6p})DW#uPv3D39FNAP_U-y@lU`6dcOB=H8?O}G5?Ii`Fy-+!frH5{DbE}xrU zLB;w#aA==mfDAix;Rp zqTgI5Qrz?GS*(MO!f>VgSG(eS@%KE0FGbzUQ2V3d`0-NHo0q7;oeZg>D`(&o;g6yM zr)}M7G$GcFZvVb9BRCJL;4JIT>fL1H`_+6WwP|9B4B%(E-qdt^1HGFSjY5%A4^zFOJY%BKDl( z+z-6SL3JY(16u2z_veDU?4lF!8{u}NC>gxd{*bcdm3qx|DFG}@MEAFS9U9z6EBU;} zUf7v?+aDnl(WUiIgVY;^f}ZKdN`Bdc=1_9p%`XheT6MUv=B7iPHW$)0kN!(PNUG7m zwTpePSJCaB*O-~UOBH(Bu$RPg8Ex2~c=G6%C*%h0{12clhke*cKh64T5IyjpVX*G8 z&twE& z)WtKYo#IkCGD5yseO29@vt8hZbm|@^Zq3mYRG2k0B&~c{6(^@zDR0{0=3LcfW zJpk@&bj_7Aidpw@%B*_8I&KyS2e;ZiXYFf9ZU9@Dq8lJQ(GvDK#YlHHr_W@{)w%`Hh~5aKpK$GV26J#dQh}YZxo1TOB-6Ns+S! z?nC&Er2l59#!PzQ%tis}1M!RJ(jPdO)*k#;{DuxXmy*NV_kZ3O!NOcnuti_YE!G}V z;cP#xpFq=GsduDv^a(ir`1oZlJI~B;YCA;D9H}Z?6Wi=bsR1X*N*Q`6HGLLh6UGJC zapfFXbKns(#LxUzE(6z$-%9V;CZ`YiN;1RRXv=*%$4E_bL>>k^xoe%kV5{BcP@QHj zUimoTF8)PY{6}0+)=)|O$39l-5Ml0eRjKn=UQN^dnp9CTm++WsC;@Tg7Fb*6pjUFHKW zeK56oOH-w>*cFpl;hB65bK_b#J+*5DqndrsAEjU$mgn>b`Uh-~*X8e+Q5>v#M>&H1 zmVCk@h3{F3H%To`W3k#R`e@{vsTkJeD7#hxr(*TUEcgjUf;CQ!5lH4N)bIq6-_R;I zF!YfBCjs?uofzcQNXWDC>HtYM4%Im;)pM7MROVB(YPBMu`t-#3sFM0?Zhvh-=q6`; zdoSV$VD%yNu!%B3mVQ=^T9U7<=QjJld}fF76JBR6ts(jf_3i&6xBJ4Q{A40a}`>UP* zpq$;ATl|nVpVTGn+(?k4A23_rqCbEy3LJdBk}0+96ocG%knUVanth7e>qUD$z`0_f z0k_CyeCxnB*S4IjWObcK1PGFIHaNjgOgCM7h+W^wRGqJ?hYNaW?jNK%atwo#N!-HP zijk9U&%bMo*-u1jp<%7jK$-{u7g@;*j2YByG`Y@DUVaw3j38ooF1dWFj-{CBW$&Q% z09u}UjOHiMqQMv3LEu<_&Etjg6 zY1C3O|5#&=-A}n@W{+dttTKBHRMy+qQf(tmxRoZIZz$cAbc>QcBFTQEmToL(*6q)p zAniGx486Ahq7Q%I6=oqAKAfLgMG&o+P9zb63s*aTVV&jsRv@QD_C~gUoDA7l>^iJ4 z&Rr~&ED2S+5i;y|pD@$$07Tn)L)t+1P@L<#vGiYHHNG3yuuqv&*DGdIo$=k5mtWS?A%wlGD)$jz{Muwd?C) z!xy%vkg;?abwu(;q!oC_|I0M$TxrIz?hyz;bE|_`5+}-(3ucGtW%HKilYN_#e#he4 z(;w$)BsqNvnGNIBMRflD)dL!wHCPqGnZHz%Jv`_yl8>!qJ2(w^!82o>D%ZDfa_|y= zRf)6@N4Lwqu|nm#oKC+$wQH!ag|bEp8qbpF8u09HFR-+$Szk}skz^qogYnY~qFg2+LpX<}xfqsr{P{w36=9iEVRDdL$P62OoG5g{s2Jscc{XwP z;u=kAmsDsO7}N>Dh&A-%2)@FZ+&K@^;rk3DiM}5>`Hv4O;*ER7qG=faQ+3hq`jZL9 z!>LZMeP@Jrq4!Z5+O(3p&tz=7J}XHGuZu&x%-*|Kok>3Q z4P;LKYYTbcJ65~7JjsW;a$yJ0Z_I5!6DrWSt)XjNyM)mZjO`{L*HvxoFR>`mbJHiM zlqy7zuwK;9Gr$K_dETOD0v1m1?-Y~ZOy4Gk9nlVIKYY$W*|pG5r^hbR z8u8dLoyYE`{$&YS8WQ$pgm0ZU8+IoCs&Rxv($h=vslYZP+!4`qCzuV`w8UEd6job_ zvC31>uH=>Xk!B1d6zk^OP z{*qRwDi2>fyp0lwvf?ihxqN?7d%>liEKNToie%q;A!|H_g)XTzYGU|v+<OD9h!6FATDVzU=t_fO^ zWS+F20}kJT*0LpCU<(1{4B}u_WGcp&z>PNhU+znj&7( z=}KDz-gIJUsWhi66JoU(Mwn`?R1XM>WAV>W8?;PWMMazhI2t%W1vZCYPhl(tlqmCI zN@A-TPTgiBtB_&Q^VV|yvJyb7!@n?sKir{@Qup07Usm`x(GQ}(d?k>*9Uw@JaUZo| z4CRq+qD=l~FFuZ^W~Sr67P7x0i9z9)+y{kUXqMzG>|SRP$!4jLB5l$tI@7u{kY+`H z3=R!$gHU5^o>hwO<=H&#@cHznJsF#HQTLmFKMkd=S-94?B z>+HiIE4r5%Q-FjKzpayeNjlO!YPjnaK6?HmP9@J;#?#BihoVGf&Etb``&@DuT~<7a z;v4QY@VsOJ9th@k%G4Q<3*+i(4|!hh)kL>6xpfQrHL|l5xkav{2s**xUbyX0lRmHq zk;1MFRPDnK2yy(c{o@55O)jP)=IFPSltw`M57qz9ew};aRQ&5`%`~@i?RPJVL``)` zIqZG(abko1L3r42wg-}b2L)p<)Ze?%9!32bm!L}%s%7l`FJ{I>b~*#~m@E?lL-+(% zc$eLd`Ea=l&H{BI4gYUyqiYY|)wq1km#xfI#(2wSk9-#B*ixxwGp72U0sKdc0~ZMn zY6bG10+V^@fvzEQM}N$O2Wus&XBx7%=k7)<1)Ls*lRFTc=9A`EV;~3msw5Yt@>?M7 zBzgio;Mh|2EhD58u`lVHuSHG$j<-m<$^f1`$2dfAI{U;x`Z8b(#KM_Jp{DaQhBQj) zl6|!t);VqGM&|nH1rgZqs_r2-dJwxa!9$t3zGf_IWIB~A<>Amb!P@m~U%(;f6i{>} zZ{&?Q4^!1Wg@dWMRg3`vNmpA*vtWh)A_N2U2^{Xsf>ZCuV3ILK_h4>ZsG!bP~AXJy7)D18nsJ%?CRGTe*W{7KOju){KlP}h!ykW55uVz#6xTjFGjMjz61J-dF zZNzo`wujF&_r?!MuUxt3*a2(Pt9rkc*gJ*wW<=J4XZWAk+liYQc(|=YVl!MGRQ=Cp zxNI^T?PUe7MWUB9?#XR@V5r{<6EahoIC$D5Xy9)Z2oX;Rj+@TVj$3MGpNTgMU_bC@ zy{|Esx$n#^{Jmu0~?#QQi)An1%`0iD&(WNP;0@JXbwbdOTp zS+EZwXdPNV5;96a=gZK)(_oW_Fxc69cbkD1UBh^uJ^~5P z+$l()P>F@2`i`_F13-4<- z)A!09Jd;~WH>5}KR>SpP+4_oTPMkrQjlH$=+>Z>hw#6W07ifU*266+H@A1JuGIY{2 z$n3kw?%S!!^emZZ>Pu!}@@#W*gh)B5jqF#IPc$p~{nHeEO)VAA#yld+qIaBmou-V6 zE_Ev!pJ|-Vpi#rfqJ1*--(yg;*LKruqec5*-aNL;IhesU(L>k0l}oSwfjr{-+iXP= z_QwxRC4Azo+eLF{W$}0ek8l^+F3WQQz~K9qR!~fQ$Io?6zAM6eqk+e}$=1}<RWSpqy)@s(F->_4NU(l)nSL8{B5$Mh z)|}%!k(|!c%NyHCo2%HIQ=}Ah<(t#U@iY16uVu{84HWa&ViL~?LqNKlIYJl0>ASVx z*>@=OU^2+KAraF%AH!8E3u=LNqYKuNHzPR5wmP?v>aKXUHFrOHWxthu%e3M{83R+# zR&T}&6NVZs(aw??1tk-FsfO5S^Y!Y+&s1`u9dMa==X^; zLHw=k*98$fxt%0-DJqwK^Nh-6z)l251Hpc%!ID?Hk?$3ytuR%0{@CbXaL}UhaE42p zaMtR>GgomB*rG_(fog4Ffw*Y;N4T?t&6-S1*H6kK%YK8Z&DHMN4}?+d>0Sc-T~E1X zzSMXV$b`U#L8mp@>?_z&33rP8_}S;$V!mQf{4S3_ZsU6|saw(J0~q@3lq0j21k{IRm4f>dA4+n7roVe@kTrQ}xtb zrg#L7KZbS;X;Y}V#Vgl1dU^i1_Eh!Yw=~w|N_APD1O!7Mtz{Y4b$wO&xo79#TRxjQe(&P74#g#Vw=O6(^|QQ zGskuqPz|PWG!slS2Q)i@R0A4d!n3$sMS*H`sm|FP-5*+q2%bkMgQzt$6F!PtbcP|w zVe~%T-d&vQdo$D;`J(c{e~txtR@(=iZFc@|K#&NLP8*DI1Evd2tTd1IcW3E)-&(%A zxGJrS9VS{q7;OqL`<%Wso|}z}0GL<}MfuTo1J>b?dH<@!Dvr+H32ei|Y}7qxyAw6- z?Een+&&+m5OC2tE6;P&k_Ka0I;vCO1t*&x9egYWo95HH_m0J5QkBzvPeD?UJ{rGZv z=5G1@=!C!JuUYEhmp<{`CDv zD$q;8x1qQ5_#VQM)tQW!<4hATJ_-DTsGi4*Z*#CxBY0ztO71|UOYhP-JiB~^;TU$# z0bP6Xd11Wxd-k;!p51Lom)8d~@gDggRcqDw4tNr3dsRt|RO(tIHFo@B*8ikZBN>-- zDg$uwucgR+fY*eTJfC`Na-?9&9Z7@iCSDLp`^RhO22$KIh5Sgq1p-PPdRmBIIPR16 zJJCv>px+yz_hf+_GP{H5A|v`~_W$LTbHi;?ceF$Ag=qU0N}Wcz_DDnysY^EJG0(|3#>`NNPC!blG&o$-IefbcQN#)ZzFG6MR60Cx6nE;)(722f51QOOUcU|0rl!u7XaQ zs$E^=@`t=o50xMh_Z00Flf6h(0f(_{Vi(^m|E1ADzI&5H>`(<~j`JPxKj3}`a>q6^ zi|G#%Uv7=>IXN1N@4XIB)B*|5H*PDJFrE-&%l5v%b>6e+o@hB%r@-r;wSg@0ooyhba! z+vuf|X@nm(Dfbw^4XH9UCFgy5sp`lSGAeq!KyEH9R0?MF+Lvd9(OwP zV)hV4@j2eB<&AcX?|_@1+(omvDKyPE2;i)MMz0zGi6-ypXnZ*%lG$!vT0 zGxVoW{aHqT>}L`NB&X7z^8-Xn+waWiu~mPUsZh6|&Lx8r{4@EtVWFV^UFbii#%yOI z^0e_d+_qjwi9;F?TNxr(RTdyX){zeY0spN80;&y!SB8Cqx_vUATwkZ>p4Be0%kH~1 z2XI*-)Vq!FGJnu(Z(f=2b*#Ndb$U9b;)@gi-pEF>eYzAwKV8h>-EXuORR+thz-gc< z$k_vw6*5*ntF{H2-W}DLl6${ZS{?}wEg#%qTlbq#B~!@l6jPa0>_@5#d0$hTtNU~X zziw1vjBR%N!%go7QpSYamH*S_GAh=&RI@&l6{vd9ecs5ka2v>A_DtjyZj4#)JozE{ zuXG{fRpk%6&wt}N;*xsj6!IvR>J$?l%Cnjpug-9J5odC5%b%eTt5apmo;R``f>lX+ zCAV;@NW36GEOS{bhY>>kHNrn>WlAb+*7ucT>5Qw2)RR5vjC~D>-N#t-boGN`?aU~h zM4azU;oi0k#c}cw;jC4bf+Cd?SgLR;A!OgDLK*ON9C3!2N422f;K7yQ^!xTVL-#d| zEYHDDhR{Ey*{_+f7Nv#s)|w}sODSsEn!xSOaj-PT$tZeJ7}ta)YOCE*|1e#GR5luG**z}zg-L47 z^!3i$BsXn%8?b2l8{UIY67!#J>8JRf>KGg*(DYTS#FuBbC5YU*`lods;-~oDYAZE^ z?$eKPIV(4{N_=%@TS#cNbDk0@J)sZlw;4)woQx%}TEL$fv&LS>(5 zUiIJos>?~O3P4ruA8#kqZqyWpLTY)JP}z#^{IlPG88MX|YKpUf3{~A+T74DQg=;l$ z?7(W;Xz9hY7%I$#iGT|9f1yu@d#ZK0ZWXnQ9#YiNO8pa$H_ZqKPuKCtp`toUG#*B+ z)Mx*^z2Tb*G2pUOcaD0Z^B@###&3uJp*Bw4wqMyI|5d=ao_<`rNjE%{VR#Kc>jZc* z8_aj_OP+VO@gs)zw^#Z`3BC2aqNP#dshDe&7(!{|I4~I>^Q+}&UeSm3(8_ZO=3-5| zGk``bq{6NLtU_#P{f8Bn-rlJ=L_cdPvh-6~v0vYoR~)3br4_Qc)&HsDVEsH^(Mdm# zROIRBK69&ReR)MtZ*xuDdFM8uv7#Lb&P{rf?Z}y;r+w~SJA5{-{)A;vm0~kA6#)>YBS%fB`HCWMCbqxL^C37gr zo;r&R=GwlBY&YRLCDeiO6}st?921mKMZ$pUow<{5=JJc!m1^Om&Mo41t+}r;e%Fa= zG}G~-sroSyyt=h;LIC>c)PtIOPhn;z<1b5q*zs6lU>TMtC21D7p*b@yS4pzv30Rd! zzv3vn#>!pH!KQR_e|D3Cmf17OVBjs(%{hmuA<&*vf;z{(oDY8RI{T?}z=eT)#t}Nw z$N1+sm%JzT!F_&!XM1X~+1f9l8&2|V7jr{&+t7^`y1e6A7{^&GCgBnsz&G0WU+x*^ zkD@T9sMYGoMtjy}UUIIIQ{R*9e8fK{dI#O7b#Zy&!u8WTJL7f;-rX}W7=}miis{Qg z9})Wxf^5-ARbYdGx7^dXu4mIh)-^!|-nxc<50YTnR1x#vmW zz1Q?==Z&iLloP1Cg%70%yaruRyZDh%?x0Sc04XUP(f_sqjg*>@rJS%5eWmLjb(c$J zS^61+=wXV<&z&>J>6M0uZX4ZNMEv5S9?`Z%?F_w%y`ZVfaSnOa0E5{lq3Ny;fWtli zyv9iLJ-%nQvA54Xf(NbalM{V%q_+nyZAp#}Wqh)c{si^oUNS|R7l+iBmA2--D~H}? z=b6(cdG$BDa=d#EDt3{#{@7xkCL1!gL!>vCMs}p>h0dW$&Ybe?wf@xA%$dXJdma!= zrYC95X0Z4%Q%Q7*6Q)bh*XRRoyG{Y`5jRQ(cVkxe>gai7f|l{$XAuhGOC^tQmV6b- z0Pt@>ct<{ti6L!JEy|K$KNHxSR0TEthA&sBSiS&IMJ@}WM zwUBJ%0uY@h5bAM-nVZi+33M;|pBi*1!pm1k=Wr|LxXuTo@T+ah7wXvU?qzxqZ65d~tMTg71+r&rp zh$D_x@H#miz8V2@6OTKGbh|ZoIpt z39fU{{ITJh(8!>75@%?}T!Ju+CCZCe$oh~yt#wV@Jb0v~Vj$HxvmO@E%gMPck5edl z(9&-^(#uT8f3sr$gDh!tcZ#TCXYN5$xFA~Vf1RjwgOPZ0ui{0#N<7>HAB&ClLzkPC zIGbeWf`14JYpNcX*gQ66D0iVgTwZCO``ml4h%1;_$yTo&CE~oCw3e5ihA@;a-a?=0!-?kys5=!E;B7oq(!FmZYHU5O0h(Ua><*} z-Muwa0#5s$!;ODQA5*By1PV3Nq2@`4%Iz~awpq!1aAarhy_1DoUQ#ELT27e3Z4Y97 z4?(k`%y|%WZ@ed9H3dx&BNTeed1gwpJij-5V#feNa^a=NnsFW7W4ccvUny6R7;|?o zjx{jj{O=as!vBeAGx^Swyn5Xy6xp45itnB9dUtAywWXEp*H18OkbBebJe@INz<;hY ze(p+*lGrUqh5aH%R

BTG1mD+k!@w&CQ0};C_6+kj^QiZ13V%-WLd{yISiJZ@DL- zmyWb(gN^8CZMeGf8O#O&G;co0bRm-9!a9y@3AUbREd+qZ#cWmmy+%VCJ(3$oCH!GM|Xc|N*=z#EWCTv z_8yi-bv2RJM@cbs^*fQ)FNlRN(pn2&!w0kjVJ`hDUIT(fJDdJZE`B5s9cXB7lpJ#W z6NGZFt3_!Ju189J)R3+cM4F|8)O)O=Jbsw?Cl)ZeRcxqj#F|FO?zI}p| zIf*m9)6U#Ylb{w+fHO)nJ)KJc4+2dk&R)g4Y4ksQ^&LpHFFGgbxtCmD{XY=Ni)Ch zeDSJLbSt~;nsLU`k-B2PD90JZRKJ-g*|(juct~v8H@WyRX7$g!IJYX3(QV>ZR8K;R zf2>(2`cPKBNH|$m_>q-(K$BjRlTVocq4~i;CFD-~*k(XpCWziYMaq-;FHo6xKEbZ; zXSPUJb1#EMebObx0?D|5Xem%DLh>lva3QL^3(~hFdDlo|0$x zdQW0J`!PeA(RIx9j+J9I7FPH9pK?6PbShPeT0z~yOlTl>2+k#X>8h-?p>7lOo9X)~ z7)kfvy&M{DeDUF#^GmGZBl0IFZl7|T>z~hR<=3QUQ=+IQ71vLC*bHk~N_Yf@hp^|N z=^2Vnt6-R%GdJ)Sp5(_mWg*04gRa-+kLP|0X&}ay4*I($$x3)SqGJjs>Fi^MPk)R&@_8n0V#(;FjrxobKdA`G%P!Dw@v1&@zI71<)qQW0hQrQaCS`kkb%$YS!E1-|I@oZ*6Q=Q3Ka^NGP+UMz>9tNA{l!9E{TxF}Vb$)3BE?7+y4)RY;U56Yy&`JNs< zJ(eeTSIe-?6Mgkp!>)$Yb)F>c1z^V1OY}eoS_j^q38PXVD zsR#*VCX&8%s?=%D2BVMr#@<0EoN27{FjyLw!mILC<1emZrC4hRq=8BE!kIKRFHgbe*}mUIh2{ z9JBi4AS=!T;*OzLkR#4!La(q)h-gi*e|Mr!w5F7jVQTCFQ#aB&m5YK+y!lbtKA?0m zZK`CbwD;c9H1~3>3ff&wBTDn=+)dEAb#{NKHcP!z_nZrM8Stq%Fr=Hh15-WrC-xYC^ zblG;aVZEa>B9lz05=^TS;Uek#Y9%|k`hqvlHPX!-;h-zF8j)IlUfTAi(0N)B-Cqm*e5vOFbe1I(#U0UpCAvb zB%7ux52xpwl`_tMXHt2S$!X-LO(v(FOwZnq$DG+BE8B$ z?5PObNql7tXe?+AyH>((t9^Ce(I07;L+~*U<73RNd>xb^KVz&X<{SIUl)UiDEv*w@ z2c7ReM5fr{e8UeXVa2hPoIPTkIB&@I$)vhCiOb1N6!v{64^2}il_%v$SM?xgdUZN+ z#w2iX2cHODnHxcnE^iqQf54l~BIZYWV?Fj*MQA$r*BsQ|dT{X?~d#SldSoQrAW~IMB-xE5!`>aay4ez9J+VD&a`>N>| zuonyuHVWUaOA@Ox&D8ftx4u78--?OIS(Vd>xnNqBuO9Ni)~FH6<7A*v35CRKI#;P2 z^lu4f_oj0)_e7fMfD!TQ@2`4i?^rW|r(MplUYxH|a|D&fqfjGso|!s*WwbYA06Z+G(?EaLrWns~DWO z7MYf>rR5e;0W#x%B`QGHYsMp;O~Q=|klIqksM=HuO4lVex7C@id3#9Hu9O+sRWQ0) zuSQ>&+-Sb!?HrsJC#VE3;E8kAI@D2Ysfwua706tc{?eJfO2((kDGCiBM0aB%{F|lV zB(&Fb73EEcfH$2XxVC7y+{m@(;cO)?&tufW>6PIO5rnYz>)iHM{G6CxYwmCOU$oy! z?g7k;U{~d(FAdrLg#;qu+1z939K9GoZ0`Ei!gxVh>d3^8D_JbB=Iwt<7NQFh_`DH0kNyGNHJ8$*9wWIKC^UC!&;=m^ z0ORN}ZM5$2z|Eh_?)>{cxa`iq@8iX$`#xT5y6@w~pWpZ4Uv-1WM57}GULwX@BEQc8 z-V*YXP%owr@q?+Xdq7lpR#qS;?92{C&ycTCDd#Tc-YH%h_e7>XV2?h`6t_~pbyKpS9`b82?V?%Y zv3`Mavi5nrG1*JOtXb?SUe;Hw)YI-`R+YT=i0!h?!HVimiIp1K;CC-s$fMhdA#_4>Z~`gPc%}Ni zX@E^c#3_GTJ5+Bg)tW@7sFoSAY2ChxwkxMJ^T?{0io)n}=!P`efBQ-M{q?lK`DbXQ z^C=iyB?m4DUO#o4bKImio|s9_qp{k-ZJy=_!WFELAnR`!U(cb|Oqb&+VDQ-7C2n!bV<=Kng@bn%_@M0<%}?p#&r zZ(7XiwM>XJ#bn-P&mSNLugf3FicGWaEIQx(dIg!mJi_Y*W|?;lrB9@^77wlX;*~u5 zr!F2{0zugwj9#DEofR7=uN!rb`fs6PowWZ2y|u5fmUn>j!ECv)RCW~slj|AtdORz@ zd^eoSd@rJYPwcM>k%!OAuhg_RHk9|P4Q2Zc$y33ZLPN66PdUR()gP%HHIj2K3+iz( z91$HtrU3}go(qWU0P-{klwC)>d_G4CKe;K-zgH4zl=rA~#!}L{fqEQP^z>Lqe8|9= z(}_Mstgv|TY2XGpR*q?f?*!0Jn5S96<8aa85w~XKUljG%C>^TV7#KZzNTd0qv5hU{ zV3SIt62*V@7|(yzXss0u71d-rKX25jEHkdnyX<$)W9lR*UnRo63>T!>k>wak$cKH zg0-Kk=ASPU_mPXKc={L&_6Kktv1oh{Dv8`(XT#5)gQ?|s>TEQ%$i@Qe${IFzmQW-R zXVx9+1@TJzR}A!aTARZq8*4946*KYWwB$$lu= zIlMhT+JENxl%ah`X)N*dlzaEP*3&f{p(joDmLaiqk@8^#YH$O*`eAPD^fOt3LAe=PjK0tW zV+1B*GJJ?)OVg=6#r_6X1Zi$q$|$k%HgOuRYKrmbt^rxwT@HEu;9a6~A-tBIw)TVe%=W#>(vQ-H5G+31$K`2F?l8*r6mWva^D{d z#VMa4^=5o6lMyalZ6!9lvvO{}PIDUcj2_YGHS#VWTX>CNM`V5#weCTo$^4ECdVAP9 zv3jy~{<`hf_*Ijwez|A%=)lbnU#f-jqBZ;k?Ej8sU`R69f$7L_I?~vO_0tY*-b7p9 zWnnXyXl8OJndX9CbFWgD-`txtx0dEQ)^+a?m_99B-q|!o^{s_X41b~dQ>U;Eg%L0wDK(FLc? zGSNR192_>I6(|r+Y$bX?l{(_Ao+%`nw~1#jT#A1N!3&paCEGx{YI5jGCikDCS**CE zc`thM5>?`!Ke&aOxH94?H(qM;yVp#`)o#U`_`w23+T@bicU+BeCiyNeR%M^6dUkxy zcihy4=@F%LXil1upz{}U5F^Xm`Vj3Ft2N!ZV|TuVEwVK&id^g(AxB3xuruf$p;=Th z-bfd5j2Lj@D!tTbk~9arp5sZfJ*`xMo2r;u5i50~`*sd*BdpX>?%TP%(eZChFlpmQvmDM8y*24IM*7hGej z-S!AW_N--Z`R6gvzq+KQSz3&{Ux{Y$0zL@T{WXNoX-n0>LD1O&F_C8J%%Uc8zttWv zs3o~~CIf`l+>Wq;RY@1ZufJF~;u>*3paCD~k30fd1#tLfAba_53Jh}#Iry#s* zGabt1v%71hnWqBdCUdN3hLB#k)z0DWiKzF7Yi4qas-_=4`%5OEO{_isHpf%r1l5SL zyZ*20_}tSy%}qyIjcrmh^`8`-R9b!=p=7($2j6Y~xl?#3fn$RLxDdzKjYI0tA1xD<L_pvS zE-(I>tzUxmjrP%paSqrEUdFyFWEil{KI{~Qi?NcusU)%cE-N{oKDhp7v#v_)UJ;#1 zceaCyv#=Sh#fOV_61z8Asol_Ar;FP!MO%80JT1DnXSwNK@_YSq4!KqZ{>@8b_ru1Y zkLyL1^Z`l5x6ynwFR?onZC~6W>m#-J{pC9F)UPWc(O5%o$6xj9+!~A(`A%qrvIA8;;?XLgt4Xl zpSI9UZddv&FeseW(D0|M96&zVk4L&W8afg#%w0ZMBR+yO1*x*fwr9>exH&!oOHDUj zpWk6kHW#7MF?G|6p6f3aNf9(6#x(CV* zJmDQXl58Uyvt8$Aa~+J^{O^O`A@|^SwR`Zpp+ScITKk(@bAI6fIGQxOBc1aPM`GE# zo@Iz&ILeC`e+C!@%~|foGuw3labpyRmzcunjm?g>Jx*M0H-bagM^Ig)zw*L2Aidag z_061hL)r=0-%JH+(oF#!M&SQd8RAQ0K!-KtP$UN@Accc_b+q$4=DgXlz5y*Oy@w*r zPWdHxt$&RQ>4rJ>cM}QDU)KtwjCZhmeL%7jy@hih{|?Zh?XXc)*FJ*NV%v868fxhr z-OJ>@#?q{ilD~2Wx(@%IiW+5pn9PQ^`o&96&=L2+JmlU!80{u^;;Ik!j0Hd|mU8uR z*c!UqUQlYt!+6?g5}>ng^34^lTqPsAv*kvnqQQRf$bAh}`Dl4d46HgbCsaMeyFHYu zoGOYUFZF`#exGFE&}ZjwJXBpm7VxqP;kBuuhp3a&gxPXvjx$2%X!b9UvE=UQ-H=5u zvvWOJAqwAw4s<&-7B8QV^X>sWQFRqj!n3PXD#5VXtljf2-&wt>OiJW3BL}3B(+G-KhNyncRH3#8h`M z_#Vw2mil*eK)m?%GpH=qHeMXnL$tl|gJ_4PBib2?X%C?fBbYjbf9GmiXPrMH&9}>X z_mzD4AEQ-W!I%F(w5kba!Ply0a<4tprB&tdy&kQa!z09?J43fm`N#eS=SC9fZXq3z zQ@7`sQCe7UB_3KWxE{u4QioJ#Ks(x}Xa=stH(DtPK@{LJ>wj8vZ*X%qJ45>@pJ4`k zQ8a1Tv|RUh)~JxQiJexmh~Ii`M1L`(WS29Me^p{^LQw+mUYg@Tha9&DJl5G zN}fS7LTzdJMAb0;pIkVf<=pwcfG|#bUV|PEMwR}H=j2zeGOIC*Wix($zj#jml_GIW zP3Pq2_cvQt@=&T}zS=_N>z8P&yTN=QX(w~480IIUs^awC7M%E7u!HmR{h74L!CcykVD5JN{o15rM`sl8)2u# z;fQ{)H%72#nmI6H&0VW(@%*@zn z+n-efZn#<_7x@wsIuj!-$&VrwDSx@OER*5htL%?DFyn+n_OzfzgIzR4 zUiGH}Ty+-E1STNo8h+6}o=~BfDl5*4qICW3zOm5rVRa0#oUEP;GxT;0N)1KV9YaL~ zR(+hJRmV`LJ&susvt^tMynfTr7*l%ceqT@7^t4B^zfY}egxk&Z8 z-i*7;VU+XNF?tjV@6p~;R`kt;`$bC>aBU3 zL(^lMHyX`IFLxdTju&t&e{jsQBRQ>8oI*eUz+;y}*Tud8UJv0p>z*TTYI>Q@i- z>xZiZ@7s-`s!Ed8?2gM$V@u6oxoN%h)^hGb&F9Wa zvWGV~ukx>PkVmRV_p9DLQagBH0;@qWP{_{}!U1Iv}C98vW zjgn7np8T+K|4qq)QJw#fu`>aT zsz@6DGU6i`tDL}o}L69^gv6a^IxA|Ct6%8an0lI$eP^BH8l_i|ZR z{dCn;SH%F530DGmAu1{!AR@kJ08um?0{Q={`@NYr!QJoAu9??Yb#-@jb#--hwL1rS zjZNTLvf*U@17O+jQp!un+qFiUo-L5#&*|bLD877dN^uFL6rYhgFb993_)Qc~5R^p; zs~BaZ{p@s!-e;{9&7|4$E2bSXX1DX{*8hHf*K~;hr8G@?o>EK@(SU$Q>eL#gv&`37 z&X&&^P`leNyyu@Vq-^L#W*mV)O%dvL% zP=JI|;kN0s#)H5;AGiQ`oB0xo??^#RLa6{!*lwV@MgaWGp9Est1+n+KgV?zsCecVE zzPQ|tw(2ChmlI8dFTPE3|6QW}-srC-`aX%?JhMAPsOm|aQ6)t_WflbuCosYFkQ|I2Cd3?q!gD>O7WSg)Q~O3D|PW>DIUKmrMQGrinkfF_xDpg zMDfI!MJQpNh~CnkSK*0XDAAb`J;NIZ+2uzPZkW z+4mBClSIEubi9nZ5xO>Cghtj~GIvXsQIh3(vVi5z!O(Y|T-ZtuwuHQ0B^Ta2Vnv|( z>3#H7PdW?$&kKMh(}0@F~)e#aXVEzgwJ-mj!21N^KJI)@HO}o`zI*fIl?o z0g8v-yga46guLaC;_6`mP^ST03;=rM23;n#N4~qpgZWMwid(ya`3K%;F{895N%WiE zXt^9>g(UiEZ?wF@V4W$^3%t>v3heF@J=+^C>HzCd7ow+nqra8h-$-;R(R9Ln=ghA`wZs?;#Z32!-NcXcCF6Z@n{fdX9 z)4Nx&cOJ2~)?CE+%(w~)Gz*^_C<-zC0KsYcy7-yu$_TbfTo+&e52ZGXNiOFRf_NA# zL2yJU9fEsGrB{&N{H1diR|jozunl~=v)^hO`qL+JE5zw2We;->1>nk$lM}*P%TH7A zPX0>dB7Qr%OpP`|7Nn&Pm_e>fA}#jfTL7{yNq z&;v{RfI^aBC6r3ADVshX==p&TNk?~>U?#JGZ+*^!X9uS^4^h?+Va%kuM={WBen72k z^(V+#0dc=4j@l^iJLcWv`MUIe-%KWS`!4joA1-NR3oT?NgS7)`Q0ZizhM` zGi61os=bNSOrf6Pw@16Bp3C*e28iBxg2{snBRx+x$IY4C1Zh+ka@ksoZcLHy^L>?W z>lR8V&1ToT~}8Q8y@W#?sVqiMDNo9C}&!Srqbha=FMJlxx9*gcmgdzLxD^$P6`!nTg zpH(_D)T!Bf549>9MsG%N+!se$o9~lKDB^4Wqobd)4xH#5B%eSJ-Kjv-2?%TJ38`nw z_64odBLF`?UT0r;{q@c^TgdHa!OkD0A?2`R;xVMVCx!#}f&%BU3=x zyE|r=*&`X_S0{N0PgI=N5XQv*3(=tWML)#$?!+c3M?xu-(?*tid>2r&cB|q~P`vF@ z^?vK2KICiQ2eYE93=#f9^tKxbia2e zNLGL;Z9H(M^qcal!8{WF=_%^&Y$Q6lvw2O5=TST{W#1#+I^qYd>p)99ByChAuOxR7 z@e4C$1e>feob$Nvt5Jp_ktvlpY&b^r&z{qV==ZLDmGUu;<0aQcz0!F>9hSifwpgN7 zKMyz#!9HE3cpdgPVx!$?9WVCSiMLy*&w6Y$(t=s&qv0%VLiXBgNU2f%o)9Z9tUMsH zpZa!Qn|7abZHWB(3oA^V(V1%Y)a6jrb?!CcGEXNxAf5Cn9bp#|O)JHPTwK}R$a*CX zj2rlsM&)r;PIpZ*&r?nwVUM66f@3(~Bn>WjtBi4k0)N2;@CXbCUF5`R*-|^c8 zeqyjCltRmG$mH$s80X>5QoQFznODCT7R(xRDs$^;Da?i}#Q=NSL?&p1dfP_pi_&lZ z(7uGo1f`rp?^qvZ&WT5j|CF*~p8t=|(38f5l zn>F}ri-8_*3&8KKNyjEFeZIFw177TY)O$PPL`vQ*QtI?msq4+t)sAGUhM(AxC_Vcm z5R|DuDI4YC5Z+p9jJ!h;gCfPIGAb;oX*hZ@_uyG~A;W8DOG8cnILd{Vh}t_zz!LK0 zM|;_Z8+Vk3-NBy({e1?i)`T=VuxIqu=f$v&RDLe|jdwsu~8!JaBSB?m1b3q~8M7Cj*i` z7^|SonF(${Z7(;8aPc3FSgUcH%C3Sbe)t+nF@(u|QWD1alm1TA&Lzk=VS#9M$WB_d>4Ma8lM-60k$%71fA4~Q-P2gcTH57b=C z2mT{3iJ`!`p&O`x|2T?|2@T* zoSeeVB$QIT4Kpj0;xFprMHCO!i6v8V03_rsf0Ux~&^7?vq5-4>AX)TSUDUl=?TUR8 zofP|)OYyTPuB3eB1~VbwU3HKp&g}UDlgE*=8G)4)uM@?P$O(3MtfxDB5o^8k3*9-0 zXx1^cyjf2kImB9l2f9^(nlXE+PHxm=XFDsBuk0zU$=_l5@>MmF%fxe#KX6a`{}HgS ziaNsnrcA!~h_mR}{>;1I*1P(4hs!|<`(^tOcH_~-^#1T(j-=5iY{q04B`hQH(!%T$ zM8s%Ud6z#v`#3m_pE;>*Q)+H!>e$y(KNkf2)>&P(RpeBO9V4-(|Em+FV|zb&GUTxs zN4)0DJQnfslT#d)_Q0dmH(Wx_jfWV6UUnbec%^xw@9&l!AK=1bzGx zbrNcj7hv=qq&ro3PBt5;^O`bIMG1FO-0G1Ls`~Sj)$f%#;eD(XLULCCZ}l-WOsxKx zD}1mzVPCP9PjGq(7;;O=wb6B6cvSmmSLHvq`G^Rn)l!}2FM~F+!j)Dv$sQ0V64s48 zJt;1?Ru*&5Zb;@SS>?alo1!neJVUp!gFXE4b0^Dk#B zgX=s&#qrV>IkB?vM5rCx&eiP@sw(4h1E84q_y~#Kpc35sG355p3f+zzHG*4v^8;Dj z^?%!0&d_$2yR@C=O{wYeQlP#T3Rs86X9MDFb&ZTXc8VztK!rE9r&kF4X$ z@Jna7)~=cZD{0~z+&!!k!3wug7asNY5qGtZ(c{&T z>1i@y56vS~N_Cms3Wqc5R3DxFv#?A5UE~Ah81=a?I$j_Rs_sR-b;k+@-T30x(Rgw? z1XWh?y4tgv6K7g)55u*+QT?-QRe^UFxg4h=O~IK!b#}Ina}n`$+{OncFT=2+ALU@g z77Mia003C)2B*{6!aTO%jH}$bq9+K6q{~wj^gm3PieF>;h!hnzC*ff|gY81~WQQ$y~0l5Y>nhAtWBUa8=`*pLuSedO0zH#eGYv zKU4jPpZbRQpN?>U=;6HkNh&t(&#P3w6Y}O1vABaZ5E*Ztc%0<`H=*ixOEtA!36sckMdk)@)d$B&6(0_~us8e$x56Dp0*$f1MU- zM>rTgJ`_8W7U@`8(O7wB#*rzJ4kdE2^Cg|>nn+J1OXYin3pr4=o9N7f1H5Pgc- z{MFcsmXhj*k&T(>`XVR8BbN7o9(V_|)cB-+k*Mxv1mJ2v;~@ak*T~u8fRK*v@-P|e zL=(O=<6t=x@RRzrZgxzEW!JcpA`Hxl!gVm=Mzb%Y16AU3sWIJI!N}g#1hjZC#iXdPPUfT^xAwQswK!)e@{KgEL%?J+UTX;{j#=adK z;`{X}$?-(HYgqkbPnWazx|d48YTq$nC4xX0{>XlYtIikjrF=Swvp{(lZo>On;n+~f zy*DZ5ZN0cobv$cT*zBg#%|!ZPnb-oXLCtWAYY^nf!&z(f+bSC1K{idrD-dA@iYa!y zT(86DGHS^eA7#Vz_f1D+iz>oNES#N=+PXNe^H{u7Wjj7)?kNOhJRsxq^j(<{bxD>= zrezc1+dS?|CG%x6iqk`E?d8+z_&d>0a5)|yoqt=YYy#-Jr#?G`1%GiK*~CAruX27B znF;wj0;R+YW_Ropie;Q2Y35j7$M+E`gh_Tgmj&fq|#ANF(>)8W5%LvK{JtfJ?0 zWkA3#{oNYIuf-ZTyQ38SBSitUp26XQie!*~O75`N$pJ;I@U$+nEPcf*LDhkQK5O>$ zcE0$tt0NeU-P(>jtQpM%e1`wPcLM~@9n{73z0B}1e?UnT{u#t@u$Fd1J4wHi5Za`0 zzn(7(k*+wHVMw#zlIXr$5sTXg78oEv+)JHBNLrnxjc-Olb)^O#&y3TKbOnna`YJQa zANh`7!Jw)Ew(w`=-$E39Tz-a3%$`eNMXV0yQfV5bWDU8!BS?=1-2#7@zjyns=#A}s z*30*)N8}9hQ~6R5vJnOm-gcmTP}9ijQqc|^pb`Ix9(*4thxd51?YK^5Q^x^%sLry> z0fk4FK=o42rAlLWWic;S@@fB*KcM*?NGsVf47kx?E+tM;pCKM_XvJMTK0%jf)>dpg9s1ZykbaMDIzM+@gF?iH|9D$9%P}5K^|^SGoM%$Q4>5(nWIDCm~ptyX!kzefHLebl|X$;9knYI{o&)+rI}~ zqCtBFm-d3o&EDua61`^^(Gzs#k1&fu%daOoS-FH#D{rGNxL7K$=TD1&2b7u~Jr}wd z10*GEI+d>xJ$^}=C)^{lRu!zZ}EqgUQ6*M;(#+*TtX?u+b9TnN%8xoc*3z$W}WJxw+j`_ zF2D@EDF+lupc3)|J<0;5aU)RA2dX9ld~{{B67xF^Qs!|eK0BqE5=sTx=3rr#fc%<2 z2}%-a+ggr4aJ!F&d!4{lp6!yTo_-YEHkMc?3S5&v^j{x^Sbhp(68f)*ZGImBqrHfo zAc*A&V)KW)2I;p~^5A)AVAZpT`mB3jRGji_Khg2Zj6Va7ZdwQ>Ja@<8`?)IB|3XJuwf14ZY>dpZPUqq+E9W)BvgILjHoB3sQe;Fiz_9lX^8w4XFW_K&El`mQ5F&3VXWX_`oHc3`&qIkrM!f^ z<&QdT`ilVQtN}bJ0G4V=%heA{C>1~(v!TfXK%QQeb|DS>;$p{QJ-vf=b)a3cbanVy z2C4}hM^HuOh`Eu;0+Z=CN{z0nENs-t^mo`sg8P|nv`uKKks8+DfMI*XX=997XvI?Em=9TiRfwJi7R zEbr(nGkz`0jVepeZGK_n{(q3uyfn|#5k`4do#+_spoUdN4w4gZW1J*uc{=TS(&}qc zx>Z6RXw%z@4!Lj9s|)#~BswF%%;XP)(~jcH z<=SzQY9*9Xyp1rrVjaZ?>EcZ=Uhl}s4GR0F^8n3`A8dikM?TtjSV#vanERaUp@`2> z@pZp$ppW^~_9I4db-Eop+p^i&Xbg&96|`bz4=DSCU0w zC@ZKpNnK+Vf;|_I#brBa5XeH#D+I%~tf!Z5(Nz?H=OJmZH(9uooK{E9)z!^R{~Ra- z$}1p`TIc)x+9LUaPc4!hS;S|bi_W24n^itK*`+*9tmiY9?zQ&E&e0rq)X(nfC;YeI zr_|+W2@_uYtG=2LkIxYC_(}>pe)U}CIi-_IbL+PoorXBa)`$&(8qLDbx*nME;7V6~ zsQs(9u|tXoR3B>zp=mQ+5iUgaI5bfG0iUiT5R9+7NRXwp`AJp_1fTQR+_GcE2_~;N zonhs%Tb1bEyknOcsFt?{m73^Mb$+jw4m7!rUlFmR+G16`u7tAnnL-&gdnmyHi~O+B zu45@4t6%LBe`ho4#6b;CH-_qdf_RsRm4G6idik=(bFZvWUOWoi`#~)Ya!Of$?nIxP zh100Tz7D9gu9d^4Q|MCnGO3ssZn3)Qh6SqIlO&C!)Y*cY$;*3_i6eZHgk$?VxrWjg;-^a4;aVb@|r-+1BBw1v`55$ zCD#RN(40Oxp=SK5Fl9y(-{;h614_2c(A*j7UPMjHrzScnyb$_Ivsy@p=KU z^k!;G0+3KDfHuO@NdjPj29O7UWrI`7OUPTkt;z3}RTRHO7yl+rIO&Zk4Umwx{860r z2?5X*00~C$5rkonJ6lo5gMdW30Eib#onU33O_l_8{74S#)z2BhSTb;+jRoLZ5)+n4C%ZvR55>|gvzRCb#{oi9*#_EUp;mQ3v5 zR}&3yzm`@__=Sk0?zD^Xg}p=-@gIb1ExCmfNo*wKZFXCuy4M>(j zdogacr;;&I{%0xw%_o#E)mYs}!BE{kqLa8u$b%cQPMa-Lk>K?ze;CqI0KiBt)9p#! zGJVt6Q?ohSH4;gKBsDYmQZ~8 zH7UgIS_)VRdBL_-)UI3x z)N_DJ@wEpA`0B4uDK4Ru;%)4!V^VxCe<*HHoW7Z^i=}j(o8`CEj!vuDXoPQx+-!!=lh+WQRq*Fbl^ww`fj7!$ z#I_xt9y{14Q2hicRvKrIpu2g$@Vogs^EkE#`bjghgFM9rLU3UfGic*fzGB==4&?YoKIkQdaBorC)_5{yYh>=Lj~+kN*VoGOuqyJ=a(Wf!%I;Y@}xbn8g8eIE8XVmD2g z-4uGGWLWluc8_FO7Fj#f3F9KWGh>noB6fD;k=FA1XE^qauWeQ8h5GjCKB+EQpOfD& z`M0u9DzE>yC;x(@@`o>lI_RPP|wTKB<`R(V@MRQ&OuxsZw8V`69Y%52KIeAP}n0gB(erQA39 zs?e0sRiUfx9ZzIB{yfoOlw#0SW}bBlfXA9o%ZRh>&&Xq=&^k{lWwtgFOd_&K+SJxQK_jWjB;3C)^93Ldi+&jTbsG&#=yV&^8ltY zK7AKz8q*Ud<9FGWLx)DDIqFzD4?xO}walzwCVy*vzU)wIQ<1#+(5eO!^}qG(6qzeL zs5KRGzKKra;R?AHd{d6hmSQHC)9zK%7wS(8tFB&Ec?V`{k1|yit#g-{N(zzyx;NUdqVQHp^x#=(t2|H;_dlsy-6AI`nbw^ zaPtwopxzbjf`&%Qs-BF#_QIF~cTbOK;tNwFOWrL_};dq{2S%hg!*!V?1 z6)?A}I$3sZo_x36Yia z+dlZ^@{7>KQvBIZm^eNh+lgJvHTf7J^oul zmuE%JmNdwyG`2IR;JdpoP;Nbi^EdNG8COU)S+7jb^et@uMALzFDxs7j^WG7DQ)=Fo z8?Mc~G`wPKM!4^)aKSIL$Jy&>lKZ|vAYPQkd$Yl_$N6HzYZmnz$CI_Av&aH zp!yyPxR?d17ZFl$W6e3?f-SS|GUs+4RydmZd)LcWr_0*;nx9L~S96#E!ig2!W0?Q& zo&ml{KTJ}7;zL_-gtejzs~^LEWVghk_cHvQzL(Eo))+Y=x`pZHv~$_@v{M?TE59uk z#vn$|Dto|Q-UmCm67+C*KtB7jM7dgJan1xKCZq@9B=%>D1pyekNz+K2R0+2 z^4hzyto)1BN4C{EMt$_KTJ%SbwM&2WvbO7wT&t7LoNuM`VO*6RZ|DY%mdKTUesW~7 zYAWd^A#1}AY21Hg?uCt#T>i_)5j`%@vf?lQQtY#~m1BJqh|hv*Xsz){xc>Qn>VHo8 zaNqsm6&zg#UTQ3>os(vkqq&3 z#o%l~9V=L&h?Jo>W$l{XG5k1wCKvgx8|N!Y`<7yJSpsMG99z*^6o@}O!Z&c7uee}a zpn9Pc2`s*+^6GH{r}|mK;fg(K4;fgzAUIXn2rm`(U0?V)aE-A%d%6*~|Cg4T=Y23c zYBaRwtyz>OUR*O!l;*dL63yt#r^@m*Dm#Ae-%X?m}z^Yu1$-Tjup?E|d8c zv(swU8J93$C5K$ZDUE%fQ(R!*eHNFx)Fj$rUXoR_F8Yz>tH9dWov*X5%Y;^a&Ae!! z`Oez#zE7B`RpHtxt8%2{%M3XWerp%=0OdetESSX#QIu`^xBduYdSm<^qo^~Me0kY{ z_RhIkMT-C}D_>FIjr&LVO2`;r!I(TCcQy(~FpUB=@9`Nzv9ItoOM1wV$t5z;gDc}9IF` z(x|jR^-}`5;Hq5AKlxG&X$g}!P&*6Ut=q@7^Vv7@h03El7w`hrw-a!9(v3UGSN*jB zF#J;p9L<-eD^otjmu9KYjLNBfei8Qcf*j|t>vj9jI`LZg4h9V_zcQy1Mw8%#18-F0 z6M^UI0`WcaHu8c|Bw>}@HBkLO=zhbs;~D#j`O}S}+^|^!Pb|X1&EJSYp%6g_Ap+?Z z7(!9L>E8qwHHt8c`@r7xi{PMN9c!ORu_DbK{;slM4*E&dV+qhI~l~nS%8J;GCG^#I2`#!N_ z;00;cStlGh*gelnif%mx^tT?yPw2ST6M`+M5N{rlk*Ow6QJ__)izXCYl1$?WE^K`((eOZD~ zqjiM?dmND|XfNWre=6E1{R;H;nGV{=Xy_ZPEHCt5?w z!hW63m+7+{ry=!~x+mERETD{Z8NFyfNEYdIa(%ln89i5(^uK0#iNfp@Hpi27)&?0t zt2UXvjO+mJ=>c4zATS(0Ph_6X_YNN9Tm+8M`7Gt&&W${Thc!XzCvL*k4^)UZSvOqj zx-OR(Ypn;!+fM$~lK*Tc{{@Ns5@S8?$^RFXf39UcBn4!%DxKXfQ9xp>8$1PWb_-l5 z1Jq3n37@b3YeZ%Zp$P3yP)uHv0br3*{XoEWP}Dwn00x)AGS|T1)#hTJ6{=JDgC>*kh$g$(Rhg ziz<6{vg~U|m0i#7%v*NzK2qm?ALXsH2VcURL7iah46AAgS~DnzX|jd z;q_^>V+xx8&<;^>jLA@F-b$Rb@CKD8bEP}9Zs4oICD*YjDYtr3&UMQ6Q#rbGH$<(A zy$IqXtJNy<#e`^$J2RQN z$Cf6Wc#}ZfsE;P@c#_4-Ky&yXU|&eyI3f!U1^zPv$7=*0{N}$P@JKj`fc>*O&X3XJ zq~=@uvVoctI4|1ll&CPLdt*PSK9ip%I@z1$^?bt zn<_2vlNqb9pQSVG{94Zk(6m(iWEC%DQfGaC(P4nC<9{0mVT013FvnI$=*~Ljdg;Wu z^XVIF2d67xbJn|PF&L2sh@pWp#RRQxqf~m85 zVHqGGB>%605o~6FO_^C_IV~HsuFUMjj1W491cpva4#I`xj15bRi+<$zmVKM5c2ttd zx*R?)?UH5pM6zg3&5f8Nos(tLy$RoV66_x-F^t^V9xxvgDP;5ZPwu)fRcdAjYBM~Z=_RdkTStD-+IK>lkSsa<9K1e+YxvbDr zUq}H4&lx~-ob!r<}vyOuGL#HH?KPxlpVb(5OXr~wG28vMo^AhFSNJOUo)s+P=Y) zkH(b|LB_+Rt7U&CMwpNL^8kPDra6Q#*SM2mhsYWGN zduZ};U`vx0syc@0DrB2x-Axs`A5`!fq-U3qE1W`;o!{}!?-=K|h+p=Hs(m756mk0J zmOaDCb27iu0_${7Vn-q!IXrNGvcA2$HImKzGSTaM2!2Y&+jLT~m4qsWN@@Y{| zC}olLO21_4(+;%1@+<8B5go?<#B^d}PL8?G?=0u{W`3>P=}l?W|H#tsRCp-~sxeo1 zA`6Lh8Z**NR)4yaS9sAK_a)=I5??QtdGSf??W_U!q&Q{p$xbmzImh77F+p1YmhSkT z7#E#Yy96DP(dO2v5w-r{;Z0Ag)bSRH%+Gtp%b?Q?lN4rctaWOj`frT7W{gk&tf^Ai z;f<>7Fzedy+fJns9ymo#u4Mz0um?DCXL#aHbmGqSEY9tTb2#-OPu4v7c18lsqiw)UPX+U_ zEsfG(K7;Q=V@WVePfvikqz#ypQ^71$VEpSoPEmD;ggw3vCJEuXf??Jt zhoqEwv=ZAM>L6!@K5#l!NxZKT0;qJSeVhhS-lk%a5vY7t9i1strt)I};P3lu*#uNF z=O#x6wU=AcGyaxMDNX85R!dqWBP{b~IvpdbZN%PeuDO>hNqK5#VJ_WTMqY)!H%|hB z>&-w^Tb&2@fQ>^pm#J!oSr>B=PUuFKUYjy&{Z-9_mo=y&wOcmIbTp|^FrYQhFI%%U2~k1)fT3sYI!^)X~Nw>ngS!-rgHaX(igMR4uj+i_qdMg5y+K&X7eJ zw!u23P0?c7kR<{A16HB3197mFLS~dJHHq4 z%Q&I+@>xT1YlADGS?@9j5}OjEfo+L0N<;;1U2qo1r&3>6$|lXh?RJ-oaUY+*++Kb*IOkd=hmoi$oxZ<^*W#+W+z(nl#!z^pjLu9|Z$@SKlq_lVZ#~sdbWpm=6Bkl( z*z@dP$(enLBJr#8Ic3kq8~N-$w%jaO=vpE~bb>N6`XmrLfi!Sd_8i}-H!`s27#I?J z4(qv~nE#dJHox!YI9}xlREv)c7a)Fa1cm?{c2%y}cg!AZ3w=8FAHQNR5xLL>c#M9Q zW1b5vGEbX7X+VKkJK!jrhc%4VU9VdA48#cQ1vz};+Kz^W&Y_i=cAdAr1|Yau_X%`hqS$4u%(GN-`@whxLgyq z=ADzNzr^11HaAdetg)^q5Q=Tbz-LXMM$S28J;rqdb{Q6i+rFxb&h&FUuGD^yzm>*F zb;oZ}nQ_)pjDxa6iif|W+8w8XK(AeVeJ)>NJaAeY)i+}PX<-1b8d9~Nx+O;1nb;caF(Y_@(C9BMw8IIn- zl&Ue1#w>piWNmbMGI=3#9HAife=L|U_Iwd?s(pRCXyF0g%F;KmMP^|FBh5^2I zf$E=#5;&#iW$duS{TP?UcBj>}7_+mmD;HBUT!N(q?is@;Zs#LUfL2+-)bi*fVY72ynEMdb=K#R` zttx&7pVMPgr+m+frW+70r+_hYQY@5}W?u~zX?`H>Ej8Qe7TtX#=7#XpaBVNS_QgZO zjp5qiz7##w!pebpM41fT$qb`8?DFFJ@oeuq!3jp~Jyb+$#vLe%1A1M$!N&(Tw zsr{~$!Y?_sOM%!|zf3p6Q*`u=ntB@R6`pH#ff9I5J7vPvV~;sqjxQ4I%Hd=)S+Z} zaY&kNPZK-0#C;E|pI~sK;O^LQek`R>*-oHnR}!TZdMtv?PgsYCko!*67>$poo@+@{ zRjA5rHYW6k^_G;lHv!)oM%WoZMFIAK6nyBkHBSH8kCS3`a`MZV*`t8N=%|smOQ|4i zc+uT*fo^HG!dWp{>n-A>K6|~?voJIP?sfSJ78}z)gC7>Uf>GIl8o3ElSvXi$laTRK zq~CG9OStNQa1i6i=;rAQ_0h?(B^dz7Hb-~fx5DRZ=ZoZ+Jxpv{6?6QseE3VdJCma{HkJEw>mreFbQ^6m?L)H6MdBjgMsSN;81z+v_SPSe6-;R(-+2NdfIb<=*%bH zJ5u9E);Za}!2H`uilhAHycMZT{1#6mrr6k{?Js&kWNRr<=B`|mvI~00VIz0;v_GK~ za&uZi?|%^ys9j6A)a?Hm0~BGMI;_{JmXbgkPdS(+zSx}n)=0b9oc^uRwa$}nyJ>kD zev7lM*!)b4*2{2DoE`Zm{(5`CH3Mb|Pi*)ygN5=ZGFyPKAoU8>-3!eu758EStuEt% zOECa0X{c$5o&>)6jP+9SQ#QS-ZYMa!e07&SdZ~Vb-mvQ@O~bFSw0Ka1s#=<0J-j)M zHd48>{vs^(k~Q&iMR1=*``Baon!Yf0NB`Ey&?LW-!hz~Rq`58M<+gk~*gr=#Y0=GL zbD}SHM}BLxK{aR4I@O>+^M;Y@nKnVYR9HhpaU2w=u3=?VntC7G7+g z_cgLv;MZ} zCW21E+Q2>ANgjqBh&sT#Eo&I(i^0G{jm93i{`M8PIdsAGp|nu!`?Tmi@)FB}FGv|% z@r_zxMw^*mhmCY4-|5Dh!Ty95LkLtW?XX_E@JQgHYa~gKP&W^xtcbXQ>Sw`+E2&eA z_qnLG2ueP%2!8Svv9WEzK+Pw7K%#kajdh4q8VOK35$mTC-*6a1zf3&%!WWuJx2F9d z{1=7;hO#~|@O1xHkMtnzdB9KJ5*GXi4oUrzPu6JFq?yP<2$mTnxJ~LyZnJ!nyt-0J z#q2cXU{)E_WGP2KVIwoovLPAzT()A>Yt*;`l8soRu{F0sM`g@;I5wN2ooT^f;Nix!7E9X$>+uX# zjg@(nhQg#&SW!2lyuW-j1=ZdmWKQhttt=99dk+D!GEh?`T_^onIj1uQ`?onkrX+fh zjoe5Xsg|nJB?EBm-eO%_AVa2v9bG-^8=Fp5vmz{`xAX_@ijSj2p!y2nX;03ypO~=~ zJM5k?CdCIzjKenO_v~nd$^)@e`L>T$lev;6DcYZP0tAxVcV*Qi@K0uEhY;G9WWq~%3+J`GvstuHx$wDs_ z4yRx)ZiUiYf?eUx*&rm7Q_s3ISxwRybM&(i<#+WB!aS*8cvu(kv0st|>G(2ZpfiG5 z%Kd)ejd2L(mC<7cHdO9Ni+1E?oq=h`H^jCw>Gcr7l8kh_g9E^wk@f;2G!49?lFFD< zwG;A&RQ|4WS3F;;X~`c|vzp)Cof(lM(~EbPOlF@m%f#p*OXhy5dGc7}K-gf4-Gga; zsd2J>I?(kJF|7|A8*$^%uH?M8+mkHhW6Yov^}L=Q3s1?lAEAfT4!#*Xw_`aJwmCSX z5BP-53(mZ0_cWRGO0?DOG3%-iM0Elv{JP}{9Wj3PFhz9L67-4o<|l+&1UM0ithZTt zv|xyzPot^+9Ii22kEsj4B?vWd98$8MGofU?ZwmGoIMxTs4z+Oj8#2GYV*(nhtr6!- z;|g;YJF?vl>ns(c_|9ZH4pU4T5uYwmMxUxTZzJDgt zp$>|D*NLfNeY;VqqjI_TRPznEg?R*F_Oaon2AL5s)?AmX0xw)!oY%wbS@W_muE7_B zeOWCm()A}OqgQGivDP3|%DTi&=heC4#}fb+BF-EyO;$>Su(KqVxw5{f5$?VxT=5A_ zDXXn$E$zFyxtm`1kxR-7z7AAh4^E}#Enl#>?uyv1Y_ipntU}C%%wQBv>s=_c&?i=@ zMRSEKu0`KKQ)P=p$~vEQz25(=_3Zz~b9NisnG2fVy~c~n?jz_`uiLgR7&8sM9EeTlIm zTyY@OcO6$ekCdgo$6>{htmc5T4~VTq>+)k{MA+;oyTb3CU14NLO9**=YuGG^%|l@Q zxJe%O7GA(RVycJ{%8#y3?2l^8(_#l(Bl$+pCtt*^hkwsYx-G?qf4Rcfe;@JU3`6sS z+Vb?~4?N=?nqc;9pbSm8mi&$Wk*r+4iDuzELNy!5mzh(uBUuFp0}uS3_R`Ph-~s^3 z!+!+_@4iCbE&VPnyyB~jz6VQdGdq{omUZS9?>6pczu(+h_MtI6_7|)bx=@QO?L4UD z#2vV%Q0?p{B7O8@$!OfxpS;lzDOY<@8uJl78nsTo%J8p#LG5f8n!W!7w<*{hcwnaV zO2w+u+WxDXa}w=i+J$4gvI=@P%NU?Sng~&Cj96~9TU525a;yJ&5$8Gb@mbHlo90WD zdzEr`ucbRK{WtTea1MWMKUF#M=j2#p`c=l@!5STr*ZqT_5(qc)JH?e){(82Tm|-JP zBRnddR>Ly)OQ2eP*Y-b5lrNlSIUUlz>N-^6hg;=(KhtE0XseDNJ$W`g;W5%DqBze-)ZgS$OmFLK4ipXh+jOo?2<_D7dMQzCk9943mY**wfra=^bF9 zckmv>>47&!qlK%Cbd0Uboo8jW-h!7v~!9xkvwa5vvuMa2mFE3K4%7k@t0DeX(K%oKkbL9{ZYhNd7AcOCm zR-4qYnPXi|OqrRrbckA+!{*Iwfj;G-kYZ!sSo20)v{+?E|2*s7E7buP69bLU0&zqc zQkQB&Xy%$HDf+y`EIzzn4Sg^hjh1;^zIkc?K(&ZBC1#jiqmohCyDyzVT_U#VYLJ=x zYUpLg{?b@en&LYTJVLqA0y0#4iSn~L%IU2UJj;_7{ex4TOf^xUndSY>V1DGbHdQTh zs%m~H!C#Rzd(rt1Dgcy>Tr6bqTgRY%!gEuUBP`|ABSQwa^2< z_HpEq@GIW+>2f(a)KZ^&CIwgL<=GiwM#B1>$;3z`hs9d2VmR6sk*#~!KplwSDZw)H z4#tOVuFOd`WMOn2ImRlbeKv!_nIwjH=U!qr>I&$x5o%eP%Udq8U91RBt(ScdOZpmq zghtsvY?9&0wSujFU%Ww1?RIqJ5G%0w&b-dn8HKN zp~Fa6V+p4{;VD68BZ`?4vRxVs8|8%M0A=P7E7}`hy%JD+kz8xyNlsYSH~0C)EI~UK z%t>=vG%#$89GC7p_JG0!)U|u@OD4!H+DbB;~M9nl>TV_U?Gqlob z;n)(zUk-D;-#^*e8yAJG>(G0ks<``{Fq(s`(u$_C+Vh$gma-JUPTak87v^CxQz*7O z%R1&v4nakAgSh73{+x8ioq4%37Ie-|71nzqqQWZL%pAhGBUsB`u%e-+;o{ois@vzC zZFgcNfNnUSzwx3>pYm$KJ#Vw;KL9k^$Q-H;??gAajRq7KG|ywbVdFO1?939oF4E-6 zTlMC+&ihu9CoNJEHq)2}^j@RhxXQVoC=}e?GkP&%!sfVa@1|9B(b?AcCLwy+SehYT zpz{qs9gp|q9?n1#i@E`XMICe|zhM1piLgvk%$c2yAFJ>hk?AwaJA+M1jWvCl6jiK) zexEV3vwfnPMyxMl2Vi$mp-O6Df7VCjVcsMTPRW!vAXX1S3UK!^%3FfU7uyyL)NrX- z3>y}HLJ^^O=7!yeIJJIrV21W?^|P3<$b{fI=}&==?*?%$u!2v$Z7a!&%+?gSSxlqn zQkTYiC4zF5i+r@Zvp zbWU1-Q7;ZI44aqG9Y_(Sa1F&C%NS3gMs|AF)y`>kPK)<_98PP*DNT6Aw;6*PnvZeU z6D{xVmvfNL?S#;FyM%_4vNXH0;PmL{rDkX5smR4}{0?DbTzT|;w>+X;%6=zwd0E8~ zVSh=tOU&N(xRL2qHf&Dzya3(qWvFH54cWTQoKZ5mYsQ$xhxY3^J`>)<6kx|uX5J=) zUTj|LG>u_i@Fv}-TUS~O?rD3lchclxbk1wOM2|=1!P6tZRp%Z;$LidpgC^*0_^akl zYMHT8JyorA%U18xWr3v9keZ?7fD<6SMlKB%d>**}38@kafItT71xo8__XW}Or72l1 zu((^~KE;etXAMm77FCC0D@#v9oN7*s{!2HzIUvpcJ|TwunPkKeIkrG=fpXDnf`LF{ z-9ZLX%9I%_5~-c3`AY{HCe?{0hxA95HHsphR;Byw(_DJi^g10R=nMOMsLi2cMTZwV z@gFDR5jnDqBkbVFaj1QJkg+qa5+mA6lqMisuWlLV(ThVJmt2 z7+GHfi}8N-LrdoC>Pbt{XEdaR3s%nlcCS8Xt2}UOG*2R%1CE}eA+2&wYsbiD$@N3k zB{L9{eXI8JKb2jo0VQ=Wy7GS->PCuw-GQMaV88W#*KZizQ&b;kNP*mNY$pO1#8fC&%>V5S4C z8rp#wjk+Z*72X{w@RaIHIvK!2Ku1s+5?I`^@<4v%l$MOF$V_i{!8gTi-FPQQ^hj3C_mBoQcX#?#1FF1(zI`BEu>Q7P zRby1&LSt;%R*^R=+!sN7?j-5Gu<aMD~ z)EBt;qxwDcU0LAbhPW@HbV4i)9F9Ixy+>{W>DjGum< z>{y`Kec-&x-ix!NpG9LR-G<|<(=mX`ikuj(y*r}Jkd^hZ*szKRZGAS4-$1pTlT$u3a(<}K>e$xRSSt++by!_I|5Q09c{Uj7L`>WX zqKTgWH3f7RiEqVK=EO|&8yG+k9h;lU*Ji$Wo4La_0k|!fkNMp_1)TkExOT1=+cm#Y z*j7(vo`RS1ouvA!xWm?G)1y1(4g2kxk#P$HizoQA_HE3akU`%wbz=K-qs_GMdTEy0 zrRe$0b4|*bB5h+qy#=tbty_%one#JLX8TIT5M(|AF9q7J=9lUB%2P3UbRE5U{B1sq zV*Dh^0!mJpX<&zy^Sc`xG}KH|+N=)={Vt;gGxvY}HxaCE9im>O=xRQ;i0%?asgjrI z@;1*;M9w#3Dhor|KvsN64UvYs^rG0F6ScS-k4$MdmDZpJ%=H4*l@y6BTf|?O(=0@e z?~mUY?z>w=7~fX>8dj~uX=<)@`zSF7Jd_q0&tFUk#ac@V1YgOAx$I>XW^n(=2U`I3 zdd#4WD78h{W}BOtr+zV}?eslj9@KrCk`Vd0k$ztqR;D&p(PZv4doJUMkw&*kFGvktT&UER;g(ktv(EGFsia z8tIyxsGZZDiE54?Qa@xmDy6CXK~3LxeOYbhG1kt1v+v9%%GxGhkE=v$6W^MSWY3u` zx}Ofg>ej&gMKlxU*kt??+Z%K|h6bZok~SwASiH&^yk{$;7w}T>xxvcTxski%j5{lG zkvbt6v~hl~9%19F#>`CM)PG#RC<~N&k%Num%h(!9XLex*Jr0MdZ~fO*T(e9g<_5=H138nLi`h9~_RN&jmb`NiG4B`is3aen2zw7HCK z53!EGe_~TQGK6o?u5eS@h=VApS%y=D*W~(8Ry&X5zn|;xB7cd|D25x)-JnEO{O=K0 zR$GL%-^#MS2g~|4z^K!qm9R09)woI4?wn}XQi!Q5mEfTAF*zSVQ!ZxYIk=fHnv~SC zT#&JDyR0Km9%IB=;tN#Y1lfqRo>N-z9`EJ~5!FxVl&*w;`l;>dB3y|{r~iWZbVFEn7LcM+Zy*1$04!-7p9yPwD%09>VSv5jg z9bhgxFBgA-IV?wdT+EY8YNz$~g*cAEYX7`7O7XhoZ)s@tN{vxD(MyoSbCJ%lHpsE= zC0_2N6=e-#uPE^dZfr7mHPy(K2>A?W%*nE9Z)EJ@qir0+2_GoQE#_fYa}LMY^Rlc6 zAdM|lmDT*Bv^!K=!WO8+*qK1)QgR3?_HEwrkzwH?va=lKgn4N-aw;rCv~RiA6NrXl z7#drRfn4L{tL&@tGW0sEgi)onv99n-rU-(!k)e!j>A-}%6PmzuZ=5(ju=w$Ycf|GM zs7Zmv&03-=uDzc9D?3AulDC(ckIm<+bj9}ci)%A;$JT5tGe%8{Oe{99nJEl&9S_OQ z%Wf`l=+4cawtlR6LTSMVx3wFa_Vrlfgi>RDS;k{BQ;07s*gV^b58(-xx5BfE3oe;C zZ)Lb(!|lg8a*UN}VhL+yA|Hl~tlM_~7&vnc{H^wm%;5an5XwfT{}`C$KXhv+INI6% z%)2`KW}k|BbBM!YZ&#EnGO_$0Ekc16xVMTr0x_}c(TPLC1^Xf=>j%4o+eNmP zB12k6b!FKWclfY!Hez$Jc`1;PIDXzrX*0tpD$gj&6rYC5{sdWPzHEezq6ucvG-G9K z8(t#6AY#R~%nmD!@zctTnaD(LKO8PYW391@ zX@~SwR90}6lE0;BT1F&pk04p~fBkGCt&6hsqSx3I>>;_Dm%IEUY~Gz^&AuE8GuDJS zptZzML9e@Pj$4asb~Tp^K|2CPUSnc^*y6# znw`t1Uazb_XM&3EM7tpgkB*D>lTI7x_D&>k#kO>}XNEKt1;I!^PbBk?`kOZ*2gSDT zrGngTe8U9&DKE7&_L#9ny|J9HbF zJrFxfXu{YM`?W$r`%QbY8{+oKni_We?9n zA#wAZ8MYjR4KlO%dZ+|_MA1w$m`RhPQ)He?x-6H7$sC4hcln`f>gD9ke)&tqk7pK} z`KniHxWd=k{EniBs_Qw_Y29KM@K@lhuzJXos|o#QvH5(ZG@@cdY1)VMr2U$v8@dzO zg*BjhHxWn;a)IQH>l{Je{#4~E=KTc!rw=J_e+s=MW~wVxv$^cIrMv8rr5?8($&7Zl z_cE}T7HKUvb`T9t02i=iWVaeU6CE(E3NqN3L`*aPARySo^=&|jII$%(G&_0=9fS47 z!eQge=k=59$`y3xhGLVA5`~U4%Vpym2{^^(t%2%wI&Z%MMrUweG4=JySA;ILgb;z@3l# ztn!VVcQrIWlOnIU^FtaAsh}O2G>Jh+(rbvG01QTZi>H@vc~le=@cVpjr;E#iza>Lpy$7HL$fN1J!<&$d1%WS^&qT!;jM{;15nWka^I`GF4#6Rf@(1VhZ+PG#oc z=NF2tq3}DdM*N9@{Nwnm;vK9npCODChdEr2wc*%JIcbsEECyx9;HWAU08XiS5sQoe zP9j2%QeW)IRr^B*TK&O-90MgCXYCC1Zu&&qmOhI(#})yi8R_8d7oNXXZ0DQJr|5!BoO?jM&w+|k+jV!QOj z^ZxMs3wyq8k3(zylCjQdwT96RS}X02HVk!lIH6DjCIyUTmyg; zF{{66J~n<3M+vul8{K~kzLs-UnHe8Nnhy1$zj-om#(VOJZsE!N8C%ukFwc{|8Qto! zFaODc8Efpvxlaz5u`IHLN$k_;SfqS+M7(zgFyjLqy5mTFk*4>zK@=cw#=>BTr--p2 z7~!|ZNCxZF?}Fe&exo6+I2oMGlUBSS*r0wF2IK1YpaYz;97%av{yd|;6~8W8n!r*I zr8wUN2WNhhnHIOxfH*fVX+WsYR1`(LJ?1v`AsO_DogS5wUlr{PpBXrgKj%sN;R5lM2dP(-ZUsxh+iioW+Uy%^=ei)m{T`h%CR8V@ z{E?;u-4uzv+F9UB!<2!$a`12dg{!$BO8)e01pc}TZlykX?yCTo1Ix9%(%H~luyaCFGvn@ORl-EQW-aaC}D6% z4p-N^2j17F^L&dKYx}>glH8@alB3+kKqzRNj}VR#IBBd&*Oj2diryg;4rPm7hIA1y zHk58mJnQYN3y}%v(UP;69K;Ta)Mo1X6y|}mYgGjY_9>*E66n%S18f5f`%KK5=oYE%=NZ_C~=h8}a9h12o zPmMc0_*dcbXXlHWwHyna* z8*3;Uw0$GT`b8)6ruo(ZP!*GoF5=sfDF<(|&MC&eDPJO=<$HSGvFBrn0DmsNAy@!) zTmR%TpcO^mQ-+S=^wiy-c03F@Q9rUPZO(N?EQk8DF<9xM83!$RP$; zVP`Ji6MGqRT=Y>{E%VnQcwKQ-=rq@#fCQ)78)CN?gMjBqyw=y~xN3)WUD@-r(D(QK zy&c|IRd2_aV&CrV;M_fiU1NQ0bkp_#^e9>*6f~3e#_yubN(KZ3 z;lof3=NK9g?~p*nWv78h4k{XZBON{Yk&X`u6|*&ZaZTphzUwk)J}*^Xml<+eZ91=3 z)WrYCyPnvN9QkLSBuSkQ#gFRyl9l5&3m{@3ub;{Xi>S{J+x-V1&>V2tS<_P_GhpFP{5Uhv^ zE01>Un|Ydm;vZQJaqaClqaqKe$Si6!5o1KqEKmnf)rdww{N?D7`6E@1bJcH}H%gpQ zITpS;dbScOqhnkzF}Z*5Lv#E-2hKPXLtD|GvuW9~dQh^G<0?xOjJe9?|bw+`J-b=`s!%bl*Cjyt(*XztQN{ zjSWl<;4n}hA9PwKU&~V4}1(&o5<(qZsSjfS&-NVn7zic*1EE0%5H6*paSf3_qIQMgQskrDjh8~ z*3*8d{e%3(d&BS?y%f)jwik4oymP3&R2l$vP;Aro@Sqp44qoaXiIa~Q<3o0QlH|rl zO-~OFHf`TVz66f<(-S-O`2IGnS*|v=wJGsA+~|{@?OFEQvyltrkFEFZL;w*(r_PM4 zZYSE~QKI~YgMM`~x^3|c@$SXm_zt%_Wi#yy%orH2^#o*nY`e0f;p;z-p!fQM+hW_3 z8-M&dL!PIGyfV5$I-#}hju?B)Yn--wmaCpM(%CloV-m1gb*kqP_2I&E_#l7GBDc4y z?iBU5O1+BP++z}LP8Cx=9;)PW`0Y0NW4LH$Fux;`nfV|c%aXG-DO3al`$RG1@ z_nT-Q)wc_zAM(d+aliGk6KZ9$sv)&y1fW~XCS8$-sfHu&#T~Vo!G3epL+B<5x#r5% zvi{3&@K^^JOpZP9NdLbh--XpU>ik@;f6os;k)7tT-u|chMR2z*vgonVk%%%XC$5Xl zmG+-0xRD{FCJ|RJEh&7d5ENtBEIPZt zp7Z;2KsM!?M&-bCcYh9PS9Of#I_(}L3(#k8=*qn45PH~X4sep1CYP~H2N`Gs013Zk zz2D^MtHv@Pxpu5k_WblT+xW!1#D2GKpaSO4{EGA4aK4}Hd>6H}z`K~hj1T+j0yHL_ z){@*j+GltC=h=>@{z{_IEpsd)gtaKU{^ls&Wkl8rNz3w2=7ny$gxcUd6LO&}pJ8{vXQHiOkk|9|o~CktncUUsSc3}3 z*JV}{IHo!=JAzvEDax;y%pcQ7SxPae@ew(qXF$uZp&pK6aQvBHSdMF$rU-1uH35Es zgKLKKJDgvpDN@2O(-bM=H^gs<-w40db`8@c;hb(@n&k98)0eJen{ABx6Y2=MN?=DF zp1|fgEFlEgx%Vg%ip2)~8spaCf{P)tu1u!PwXUZaaA6DISI+N z*_N*&Q>uJD?~6Wb)eRu}Wp~KTPOMk_^p;FNKb@;sj5xZd*a5rV@H5)j zZmo5c*KPI;6fBYAS0f$!(PoY%(1YxF*M5OwrsH6q@k11vD%s_aT>AxhQSt6$Q8n$O za}ndI;3D-qE?6(J^+ZuM%_k*{>Zyg_!?Z*u322FCzn$+0+5%Re-4^4hLm5aq%_pSk2U{QZ)_he*SMZ(AcuxvOx-9c`0ITLHL& zKPtJXS%e`@WLL-!Q5ncB9ZN4%W$i1YBnx_c0V_Z1uEhNmID>N3ZwBWJe5L!>+$tk;rX zJ6$jaj}e6Ci6|9u6%Gd{+ezg_y(}X`O?oN^fJiT^EJgQQYY+lQ&ac4JQVOItI-s?V z^~oZwrLXcYes{s896>yR+EeYFDE2(j^HgTlRY~w_t=IaE7ZeBgVg9D~LRxEI$UlO; zPdk#;&yBWz4#=KbU2glKX^BQupt2+-(u8%8KSC!E{NW*dk<3B`GU~DpY`TNVn^Bo<&}DR#i)KHKzv;7kqrRLa|tUO5nS>=!&sVr@l^}n*8Oe%QfY*f<@ZAB%o%4hG?EBocaW;1Yb8W z+hu1MHcUE0lK~KF4K=E7@6}N_a3{=ANzX1KZ8~O*_B|)%l|X zA-{Ax8jwH}?P?&cgMHatZ#lXAg?5(}9LiKZ$yB*Ta95tI&HJsSbeIDacyb)0BeAYs z+S&?;%@Sd?FeTxNbG zw<@yppkkEJnwP^4OB5Ms@AP1#*7&5>_^djyI!~KFbExf$vReE%Hdfn|`_&uezUG-{ za8NN*@!yOW9~n?UdZt&F@Fr*{`pYhK8T^xuHB@U)yeaS@*nmAiownl_;cmBRnU}r< zTV6lGv!+HZ>&J1{BRxLJ88lo%79ELNW-(1UsO5dxoy=gk@)(Ha7&ry*3mcti^Ij2g ziuI2ijzyLR=!Zfj<_nH4HYukHl^33@WG#pR6$JtP0@GAr1wK|9`?!g^x?`KK*666s zuVrzr7Y<2FmXKTNZF|lUe5ozIf+L0HduMUpd^f(Fd#06tiQAB=LS~%;i+9JimiCqJ zo&BcGztBOvNO$X*8#$m*fhE6^U^QVZjEhUsjlQt9c)ec!>7C#4%GEa^FiaW#j$KBh zPeAw7DjRf%@e8~cfjNz?+I-@QW=04CXXe1?%HPx%vt6`G#N|{PVd~4!K!n`JKt8)A zok&9wg5(9f&Ifw91k_)lW&I$jMZtHdw@>m=Sx8`bBKpoGz7EGZ~`G!*p;*43=zgj+cM@FMEP`Bh84 z$b*f+ZyfxuG5F@PFNVSI-N)IkF?4}RPEtFAbdYl-vpgs_8>xLbKdGM0H%}LBlaK>+ zuQy29gR1*s${}QDXF?E%wTHFq1v@5BE0Ai53o@Zy$hf%C>cd0YgPmHq(^|JL2fH7u z%^&8r`Nm$_{GAj@?8FV;nRtN3VK|?I1=l<%QGna z=InXoAR(M1WrwD22Gd83Ti z0eB?6Twyu!W*V(69#Llg_G9{yNGhz!DdyQFrM=wWu3p7y^Gcf`M{im^%^2}3$pG!Y zUnUK6hToVpka}mA7}0_LyRKpjAu$0$0*Ez)Sidj|FW7MiSz!bM7f70~617mUUtH>t z-P=GgLGn)%zuzRvaRkNMl4~=*8QS89R6pov6E*yd2`QOooOzF|ccb~PT)XJf!bYw6 zGzkbrOdnj(D~(&n;oIqpq#*(3tgB$eDH2fRNoW%!%A8UD8JDJi286syQW5)AeO9VL zZQc(75EtQZh4_Sxsi1M8C`_ilM2KFcu|90PUgKSfO(t_QXK{W4wnQf(SV>!axwiNg zKhcPFoGcG{=aeoHi0CPtR=!Ca`6`=ATiji~XYT3zXp4uuJS|+l|E{-5){U3dmpSiM zf-SYht17j{Z!$;zuoqvpEfE#TtXZ^Z?9N!3;%oGb?=rqo$AMUtbs^szxLSNU9VlNv zE2J%6CpL@B2(+7vXP0SDjX5%7lEjpiDT$9aXqK*MmQ8*Pgd&GXI;@fXKF;H}?i4%%u5nl&2jf`R zK?v-Vu#;XC%lR7Xzu4JAqu#Gz8XcTs{g6aifR}R<|FXBww)0x+`K-nwc8HL9&cpc# z5TeEp3C?;_3MX)$cF`Pj=dsj%3 zlkDbOCSR@HOrG%6swa;SUoBkz2~o<6?i^}~*+%gzST9M{5?e_yc1mQW>dcv^rjN&7 z_l~hUJ##Rd&1)K$*t=#E8)qmRXS{5jJioO~`o3XmFaRzplJN&*?L%QW%Caz%3i=$e zhMGO*J7t2Gh++X5!mI%f+OX4Aw&BuuQNe{*3(vDwgjPC%QIVr{<_BLFN4`pQj#8`0 z&td8)p>bei#{m$&vd5HeRb|gBnPrAJ z<&6`*ZrtQEU%Xr?MT)dmTO%`H2}Osg8zv$gi2#ARL4+U>V#hv+%cwk*i2;w^RjJf8 zQ6dh(6C(rGiwLEZeKpV?3QmL`N3_aUphLprLwfF!?(=1`uo?5^rN35EL_>rl8S4vW zlbAiE#dCAzq4upH7^AN`AMiyaj-8=8BWiLXco&K~B(d*&?Y{eQ$dRPFxS}-A0MQCec+F}C94++uxlA4UKWf~@EPi(BN95b|}PF-nVv(Vbhcoe*i zmH;pjc6#uM(9&n4XY>SY{@eZlojGwD+<9st-B)E}?@p^U{G4*2E&a;Mi8Iowb@Rd> zcwGgTtV2fT8dHutU=y@{2o{r0)R{wH1B+#=i7h3Te?^|St{p_l z)bl504}cA@t-r6ROBXRV3Z9Eot@T#{IhdWtc*!EPGR6POe)O9&O6}cO#?Biqs)Z6| zd$TGj2$j64Od)S=@d0FDKpHVQObO&P*{MqEH7_B7w?fFYR4_4|nG72s$}qy~Chibk zou&e4V{#cwVUU{=R2TAqh-$MgrCW&y zRB7xG{*P<9FMwnzy7qZ;saI<0S9#3>or_NYaUkp{h1W6VQsR4wnoFA}wpdxl&zDOt zU#nDG1gC`pWaZMAgcyrl8VdB=XQm01d&riF2<9u&7C#&IZfA3>O``#~;W=zvA)ms= zTZwSD&#Pyu`UoT?EYjZI(v7&jsZ)@9Inc=YN+#OyE#oUj6^CKgybg!16bmQKSn12lPfVvN@ z`8aJJCvAw%rFiPnUR>84MG@S#U(bx})1Fu>%aZw#mwPvH#!1)v937ST23{<3xp1|@ zdyC;sH!S6mW+ec^k?AwH;FNMp;vljvho|vCvAmU>I#(L0uy=>9q_g4|MjErq?A6C} zj{q|@nKR4MzCr=Lg$$k+ZYl%E(fyAVo1QOS5>6MIUgqN@Cm5FimC}NA2BgZV<#|7s zcjIFklVe`uCm@&)+hyKnv+J~`&{$qQsZ zqBoGeDaHVc|9}=%IqP2FRhZ*tr8yk)aC=DkdK+-i&*==1$yv-+kRI7=>t1_gKE3TQ2K6=Y zMrk{jTS+WpCZ|Ae1JU-^wA|)Y2k0s=h&yN2e@im>Az+iZUUivbE{Xe&R7ZwTmcBs^ zQF+<)?UxtW^sUjQZ^ZS2?%68@_r*OCtGyr)Sew}hwYU02U^eS6LMl$jd_vX~1Iwga z-|bcXK0#Nek!%NjP6r$8#a)Bm*m}njnPXdx@s`*<-@@+M-Ea5&5g%>($ljkUPZQ&f z-iwH<_^x~q?u<03=N9drwIu0EI#OoRem!r5sq499UI1}11sD*P%< zHO2-|$LxUl%dbHEyD9^!I~P%lVpgxwZ2cM8hGH-alx|gF5-N=kdrpJ@3A2hNqMg@~ zSoHEWT4DrkiD*e(C3xPIchB5fyi&gsD8CC=gD6_q^5|w?tP_Ib^TGxAyjt_K3;-oX z&)@pjBlTAVBWodl?8fb!sh^Wm;H|E7queR-(wk6lIo3_=y5uiGyb&Cw31sQQhjT<+ zNByBDSWA9H1)NsNvv<5ooPTl;et4)uTI-m=F0Vd+0?XlK$XtW^3`5WYr7exUEZ!62 z1SK%H;qu+M6as;@22sA4QcLa`a=K@{!3_A#OLBWCik+JD9iWs$kOJ{Dmtmm`Y?29( zz%NF(vBB7hc?iRevi!h?ZFr znYr7?ksv~aT|q$4`SB>wt#rDjYJ$ypgjC z%Em}oXChJ=A95JjHbCug`ivC{VKd~v0vSk4%DNLX?_Uk&U(SlPi*AeUDWImGWkA2r zona^($Jc4ed7_<@eZ?Ug78v(Xlh9N(2_K8C1U96y>f-UCN+VVgDegud1LZ_wUpO=$qL2vnut=zbj)&<*5wgP-rJylmIx%n<9pY>14lzB>lk8-Lr1CsoG&^)qY zolLa#`bQuF{7oRIg#a1CA;Wm(_ zl(}(v;Gf_iWwo;Y(sP7^M|e86F;}JAXsdKfNR#-ewGxp*IhNuoK|_)B*%C%GBqB|j z>@{2`o|Nj*C`^_eB5G_w{Mgxr?Z%k3n-u&fDx6a`%Y!EMl=kgSszW^#_EqNRIii!$c6zCk%)MMf|Q<;Qg z987`^X!-=R&V^bDHVxx*@adS?D9!*Q=2v)ME#Eo&GGmjtJQ_gdal67YrTZXe9?lK}iwE(3EZn)T9^50s7~Ju2?Z?m^k~!uHdNN8XB1LSj$B#it1@w_ zWc@4s`so+k=Q^a_f1U-EnX5!gop>S})IF>Blu~AK_}h3?=^CCEV5fZ59w>1-=3d{-T>6Ih!^;XS((9CmhTQ5+qByC@plfe;9%le#C=u0zHX|ALUR6s z&Q?MfjMW_PiV}~KFXW($^#bh1=z2m2)DovXC3a8-GRhgq-MqTvgIAeI7>{1i!Bmpv zANS=*L+R1=^iQh7#iT*{iZMbC5skxlhBqH?=87#uQ~??;5*(uL3#(47!BSyQ9=*eQ z)AX+NR7>(7AgqARF(gU|brmTqz2K$u*e;L62m{T|zb`o)`Os zK~vngV0?hZo=QK16*xD1_}8O~1%Jvcm#+Ot_p#qcvjLFVRweaA~Yw|IkTkKwC76zZB zoRC8)Z~k(XkZ*fK_D_8>MG59>B66(_AGO9_7a(hxhWYeWP+AMW-01AUXtF(eg3NO5 z5|TYy7{Ruk_;;|QhKaKLq2MBty{wE2#!QfwIsq}rO<<=+&l3dyw)nrK=Qd_L`ubmq z#%uRQFcSW^IQWRvFofcwT$Jgv-c(lKIFFJyP7r{rzoFDVsn3Bd>-Xy0;gD^WlW5~5kuB;rv(vd3ub=6`zo;e?PQW9- z`(;kB(mK07&R+reaL^0YB66OfnfU%oqk}l;b;lK>ys;l(_?sTgL;bQVdb76p+B~q- zC)(mqy@#3(9h&R$%&o4tEIO#Re6==D;JkDfrDOlA@JVe3OcVB6;FW2{wRyr7l$eWO zQXLZ+kVAm)#O~?Wuem!-AUTv(cO@T|p0Xt~bh4}sy_FZb>D5{U-8COSKpu|fK ziQ?mNFhmgA^F$hm?_U~wKHhj}eXLvZCms(jqDCnqAP6QJ=e<4!>rYbT2_@d$&!)b zeO~5J&m&}V24VS{%&g;mY7yt>(>@hsMk?NxNlyYrGS$xwlW;gw@n)6DR9R1IX!}Pv z+WrT=%95k)CpAaguTYxuhTZhupgr>o&4TN_VzyL{k@;{TZBR2<+7He5|55-%*=W-I zaHGI+B{DfoMXeD-+_W)(@+zGg9L`7O(kn>!afN$PG8S1Yl$tpj4Cx4qzUnEWNJ-BV zbd{-PxX&XiaR{nAlK$m<(jrsV$o*P+$3cV_VYON_oJp zQG*f4N{1Rc_T@uUBUAR7A5Zq$qfpL3kO}h~h9b~rO%{bg1|ik$zI8SotWM8t%wlVW zrFTCAID-}aC@>UOWO^T?17_DB55tNMPE5TI`4AQU1LT2D{y=%`*{rwi!)JSb*(t6s z-`;Mdvu_AT{TGV6=z!=a-pgu?T`~NbO=UNL7jD?l*N4vLvgjT;ds+T|jlq3OQ_vIu zv~^55@%>7lE!|it{+rWLR70Ea`Io(5yu_>swTsg;?tiK_#IK=VH(m@I|LFOV;_r7w zqk7ru=-m~Usvs&+qWiL9;dJXF%HSRnJx-5*c8Qi;3hTrZY}pgSM78cN-K8%liznWu zn13CYWzrX}s@B3EhPCiEtrb&9pZWK0hF5OF3Pi_H{!(^uRY9zo3Y>zmRMUY&Y?ql$ zs8u*!7ve%Z$*86NMnl95)lz@qfx2L7%qiLGVt+%JsWx^};fr7}9egIrnHu9j4I^l9 zuz@{xVtFY8C}0y#Kd^|7q6Ll?#P?qk9UR|JnI1SfayT=p;DK8$j3Hb<0Zx}wj}lz1 z#Ae+5=EKqpFhogh`HR}Zm5F^^B`}S>lVp?M%x~C{*($~M_Z+CQ$qwt_2}vH8fNIHy zMPkR^rX`TJ#}%HYYm4e%AzWAjIXx*)=KriY$z zGhLnwiJr$}|C3Zz&SuqKfO8L6JD0Kh^#-NvOf3`}b^iWL97LA&P` zuw4arlK0^^S^?+JT~d-0skH=NoTqQ#(S4?Rx?W3u1xdEzX4Lfo3>MKEtH$FdkG z8Bf%bXAR@?cr7&>8Ah1%yVo-z0<3CQbmkh*qEJ9tLep46St;S9&lPT+Y$eg5M~~=N za4{|dEfSGC%cZD&J`rVmBysm}_U!batl6~_OLvKBBCb?$bCq@BJA5hK#okie%KlJm zyeCXOIbo>Tj@-)ovW3%aPJC~5!{o{5fuxtKJzAX^@=LmDbFPuh0-NuLUlOV#+B^Am zS==l)o0)(bk2QtWmAS|=wy2cUnj3JqBR}L+1}^7$T5{wghawu*U?@DlPvtd+-)f{ zme}v`zpLYfggaXeZV}b7-Dc^TaaVcDH*42zW}nOg{AG3G?;TLFB>u!CG7*y0RI4Nv zMy%d;h!h~gBrbx{f%1_&G%FGYXQ>3vOT;RH-CHr3M=;ctkYpvS$bPtT)I_cM(Q}#4 z)Gin#8L0d_Oo%CyC8?~3yOb8Nv>ztJIDK^Fn9_DG?{vBsJwFROio-o~F|d<428WB? zKYi_R#26Rw0&JSfmB8;roB^&^&H!)1z6!>+BEl;vK85}_irwn~Dsqu1l6%A?o*q3l z{?4Jnaknnm0^t&1YxzouDF~NCn!fr7`}ze^D@wK01PGnYH8!tf_X{1dMv-O*y*;ry zmqIFSf}(Dp{&xXFKvkp5_fwgRwP;u3uox$+16&+pR;T%mv1sS(&@hYztT`ZPj16$D zh-i`pSd3A_rM8GcriH=zGTTJjljj!uS*1T@Rc8x*S?8gvvUZ-Jv)p^OY)59oj6B9HYtH;x}J}_?pI(nM$L4rp(J^^1wVD7huZF<{3X($1f;H<9lup)AQqdk5XMvx7yTX!+OyM1sO zk5Z>~9V*w-T}ty|-GrW3k5>deu|WzUp2P0bGviy8Y_mb;Cnbu@WA4l71Vvr!;!3x>$} zbBAwT0tT${o9}lqNSocVsVyj6rbK`WkXN{AfpWPKA$T7XfxfFKi^ydP;fz%}x@lQ( z^u;+C9Yp?PWvR0%LHr6&^z1Maok>l~V7&`;YcKeHKjm?Lp5Xh7KNmqO)z6q*Y^obo z_3<74XcmwF2`w2pOMu7WfX&f=XL6h+wlXZFJI^X_A81SXVXgJl-j#XLn`{7_DL0{X zC}!LNosS*RIaTfU-Hd?iCB7a#OKY7k=hp=`v&VhjOKck!@<;P<15gzw-uiGpL0eEo zxR~vR-vVPvns)obnn!QX0(?C1VQIVjN%ltSZ#3AFsq0Pb&z~{ysuXXr&j)T6#s=;6 zZXGhz)PpAq{q+5n`r zj`V7+Yhl-f7f4tq#XtR))?5k?rnNrX7ks`kdA-N20~RgpASlkvqu>$2rT|9&8z3Q9 zQJ4H0A7IR$>6=T81|Xk!sjJ1DyV0$N`H+ni=abUA3X8$DvE&j2 z7!py{rJkKLm{8@N2IU^pWi2b%qz&iJMMZ$oL1Nvp zjiy$XZbe1J-V>aTN)47(Zg0GIBoFa--ej#sEQ1pO6$oyF4YKhBQv!I&lzb$119ZMN z1BekewUtYjweU*N=oWH_W|O9&i-IWxs1%fi;hVboT!R4KqAEHZhg^yUpRQ37&pJDc zh$2!XiX!}$MrFSy2NSj?I;c|Qm2b1K?nKc$F7w3s)lE=4s!Zk@0e3gmFg;iCU7TPi zD#UcYEFXr5Vf>26PiiO+P}mY-D zRoE3({h11{c?l=2$tN=flabmO8^XNBd2`&)w4^v~Wkx9hPEXG)(w<N8cJBg9b0RoP$(JRqc z-_EaE;we1nd#k3(3TvtHyfq#C(*-==cP-Cqy4y?)wkyD4yh?zAx-xhi=K_+a5yz|) zWFp(SxsA4;S){89D5gwT6*H%Pi=5wp{DzG#nVwBMLVjjK9^+sBQ2iW7j4T`KxyR${ z;GDrSK}QiWebY83DePyCtheC+9jwCsQzFjW9s$tQJpQ`an+*ttBNh`QGk>-M5|WEJ zL1*fWiHkrL%9R|u>8+N$4z-j}8=DWwO8qD!O1GMi{!Zk6o~>V?R&oGI-~tmSu-ifn zY_t;NmEw=ICtlFK8WG%|Sm)i(CM;ej+tAxx-UE*FMbAH~4YP{MMOBzug^|Hk6_5}; z1LqsRh%Y~fVkoa<^nZT*1evhCAW#wNM15&9B=+u(4YU3i_R-PH<9(W^d`^Ey+BDr8 z4x&TfVaD1-lBx4L=HKWRYcAhw%I#CmI5qQT-S+__wI|!9V@+z(orS2loSBA1S~K1f z2PVc?J(aynJaW8 z+P1OEoWQenBZ@fD79K#!?l$im0Q*=d6GnAY@|P{(%Ppmp=>KC^Z*C$>sog^-wdi5o(~RyAv>W<-iM_*UpqmpN!N zZa7m&5w6tw5fJXsLk_pVKHlO_k8d?iSq zZroCswOgeQ0@pb55yG;tcom;3_&kK!!d%iG`-)v4JxtHP#g~3;5mP5fwNxn(hJBy}R^vP#t26k1nKkG&1yL9q#8p7~35cGO zAj0^SJ+l7Jp{|QcY7aCbUPfVy2bq@>DavwxLrc9ZDX=af*CGMW_Z1x&8H@unmWp-i z*)c~%G7Wx`BgTkz5&>U8=L-2d=u&+?@!YP1-XUMRm|!JXB6s5_N3ros+m+1TbLO;` zIma0*<8RGP><>gwc4Yt@@PXXKzCp3=Mu#n)E6E%&Yt!4vSjH=RHw0>i`g_(-YssxU z)y!(Rb#u^3{A`Y0zbu8S|8s?ZV$rJdhsju~*U=F@L;CHRZl9xdj^y=$BjId;k5Up& z&wHYW`p@OEeliLMwS?Q0dUD1qk`ML}zV>>&F<*T0a3n(2MdxC%yy#i~a{h7@9MAW( z*yBB_{#!UyMg8_2c(n1RYN52Bg_r+9YfrODS{yx(_dl2l>mCZa=P!@3{@*=(E&p|oT=fDq*xbW@^Du>OLU{II$HFNJ-a zxqd)!!sOw5`{(+c=vD4q|0gRuhKkgFap(I#DJ+hV?tCBC*RMdZvvBb~*qXi`?Cm!0@#z_06^QWfH0_Ec&k|7r2@D7Vg0RD{Y8gkY&L(fAj_P=l*twr zkF~?_Rk9ViIXk|=_V^C3snSwtq-c2YF)lXXpAk=xtx~u*WJ_w+4Ldgi8=)F=zV3_Xv}Jk ztV1u`+s08g+J+D_3`=fJrg*jSy7k2Cl0{VJ{l#uT*(3)2D<6gWH;B>rNYTM;_yxr< z{3&gf_ZH3}prqQGYc`BzoaSEot+bG%oqOu1w0|Xek7Rwn<#4OXH{o;XR71LO2^g&p zUn{_EZXV%Cg-n(+c`%p_0)y70yhvZQN9gNnDu_%$INpq1yI)AQHp^ghyHF}!7{h$2 zR5U8eKy!wq{ukp#qwWi4=T)58VBQZ?E)|N_(-FX|$3&YAcaf>>^L8O3S*>bq@MkQ4 z$XT0~&3%1WKBTnWXyU;mif38PM9Vl0bT&3`ZCy)7+vf5xS1Kvr3gwkxJK37^7uW_D zSJmmt0mm@B3`N*Qu|*6h?hfbIF}&PJTVi;*(KWot(2dc#hLJ zVsx-<^QBOxVyL+fk49C@;m=`NsZ8dpj&n6tN*k^8ENM@qxUNt+rvo#7QyU-==jZlc zVCOQxe}%%xW|dOf6LwQnF7g8!7a~hm`KRnA8g*s;6)X=fVg%)l;k%9lROQ)d47*S(;vOj?_9@?RE42xH9bX@E zGvrp)6@s^9=YEGgV(Cp?iimBE=8wbQC`AUyP{7dBL+}@e-hd7{5C-oV{RGyuBffoZ z;?qFX65=zr(ddNF4I8UOTLq{4p2O*0?zbg6Zcp0*#!+ zD^1;5`XmTFwFX|DId&&NOWwH=8a&rKSxeRP1md2BZe%S z2#_}5A;9VB@jiV%PHgr?mvX@UV$l$)3>>pgSNj}k!v*&AHMl;gyDXKw;alf|r1F?` zcU-?JBwJ%csd<#qt_r1Z=*gd)YQ{lfb-5gd> zlp}|C2J?s0nbYjfRJfh_g0@cU9_n=A)#Z=AXxY)KKX)|tRu1wJTE5cbkACZjYkf}J za{zfZI?5*Kh}Vt3>}MpDa!4%K)>ZuJN4MjCbtF4=3g5F;TuK$z0fmA-G$TYgwSEtJ z%0UJQxu9?B$BJC$uAM(SUFX`<)zANa!L=K^=V*S*`$gApD1{MwqP}=!IH43(7nt)7 z0)OXy(K+7;sb3v!X&C`4Fm9cDhz1f_esFo_)U z2QZ?|nH5?O@*GKz1)t)AW4vUnDee}A0~~%vrT1d-R8?N8u>!q(SCn9ywwr3$Ydhnj z8O?R*j#asf3&cdvMX{_U#d*T*OPps@qa!YJ!KRfdsCRi!&XZWDK9>Vx!t1G0)SIx;ZCg+g#EKsk|1r-OrEP;fUvPxcWmv4Q36aH2BTjT&M!g^ z)fNw`%~afLZGXjO59gel%O3W-3IO7s7Hmw~9f`_AYUlvE5W89euqPS&- zGZ;msVLBVwSJtyEAa1DuitwNyi#R`K$A1Gtc2c#`1(J|dD~jBQNLWL>`DfMBx3DMK zPn;sk|A&K_kXF7L45#NWqKx<-rtYU95|KX~1mNy>IFslP^u*jktdC=WQlJKthYpJ16%DFKx35Z4={U-V&TkI!9~$ zU$HY9dlT;s47GolpV%>sTxI0itKD-2xpEwt{+(@6A=UsUJ0#!0io+0{BZ#eB+fM`$ zW1`&NraG@ROH)c2mF>CWRO$YvZT|33kQy#*4(`L%L{OpGemB>*KA_IHg|yaBBHlLy zovi!Rk9_oIX|J)yyjnf4vcxeXXCMyF_;=$G{g%UTguWnrI#XcDNsMfRGaJ=dHf@v3 z9a$<^ztN0d{W`4R=zzS-1h|7`kk;R+MLaJn^z^ABwBrfej%i{@Y=B5S-frxJMb-ik zfNItsQujUBlsCCRAyqk!lUzoQaJrrgxVifGFTA)QsvxtG2(8gVpZW8BeuSwtmAI}C zv6{){LKS$dd}7_5QN%yv z6@5wb#_K&xIUC_oGFzKGMKGxTefxpF#J*Fs=I2$FSN*BzVka*5(f}!V(Qwz`?71p( zQS>o_AH?Sl9u)gs1YeIxqRbP$-)y;y^~kn&SBvZ)L3l-+hw(Y*VP;9?iPggioUib| z@**(L`;l77s&g*(SRsHuJyfm*MeX2Am_B2|XI6|vt+n9lv*o_oE^nKcm7HJ2rQlt8 zOMXR_w(pg;SjrKYzcVjk5*ls7A?xcDToLdqZl?QdUgEpIeIWP#lid6GoGZ8+(*rrv z84Zr$OpEvi)-c4fF2Ur?6Si26Ey-j0mNN0}y+BJ68QxRzjp!^kWkcK5d=pxjnJCKwA~k6Q`dYw z0e}Wen5U|;to)Co7B@akpiD@Pm8WKsS=NmC98(yfu2Sb*f7M*M51cK z!OHnH)PwAOv+Y6hN;Cto&gsmUG!-x7aO}Gb30vWaD=^G`o7K9X_ewcY^0@Qi8|m>< zd404%PRxW7+fE6ChysJUInm_Sl6uzZN||(}=ljx6`eDwG+6?k3vH+l#K&5dez9zb%-hj)1UVcl1 z;&f)8jy<`7{oa^!_)X1&MCm^wHBMau10xdquAX@z5L=ceXn_m+7AE_?#I2q~Y9~lX zbvmx*S~MT1kvArYFb2s7P!_8WDk|2(2RWrw)^lbHIukbd zG+|4&F4>x}+`5D6So(@Ov#=c}vZtFSA zc^9wrvnhT>O(sM~GSalchGCLhOGqz{yHmEV4&H4ib09XGayD7ww6*!rH{SB~UZ(NI8ZP35EeNpog9gJh#EODbB zB+>FOVtr-d8h_lsH3T0(es@FjWovk?_jt1VF+!XS@>q4*|7^#SNO?C=97qrdOtvW# zBeE=kDvmAfZkzG1rQOQd;Zo_7=Zk~JnwsKwxyKS8BzzrZI+fqk{$lO^4)M}FokLbh zLdZ;mu%P+M>p4!XgRJWiXBpX)q7zfAxkLVHsrT)5-+y6MF z-hAC2{mg8s?>eOl>{8w+!9!){#%Ehx?abUGPT4E%vfK?`M9sH2y}$J~ng7++*X?=+ zXsMH>2HbExZNGC`|Bh3`r|cN|tYnO~Tb&Lh6?h(`;H!ML3qIf!9PSisw+rg&I~p0O zmfDU-XWL{du*OPh{0W`j|4OQW$?>#Be|UqMuXkUwM?TwWn{M{CO>x@xQyPqwS8)!` zRsaN1K-4ePZiKK$rM>RDvrux%)chY{UI?!Ed6mDVB{!YI^<3w>$W~|a$OWB8C;}9k64YFcqR;3w; z5WWz6Q*Df4qnFBC?)R9pe@EawBgB;|ZpWxDj~8mmQ>o2(we6d#y*_jD59x)&Dkv7{ zr+f!Wi>{nlr``7|TL6mLPG)#6-T0L}>F^5v>O|E<;_{8D4^LX*g!N^oL*@n#_R;GO@~AQ5@S2%j_(KsC+$$8fp{|wwB+SwZ0=YjZI4<41h`I&Vpj^Y@eVG2q zq==cWUVe4%WX2`&Bt5a>F&?~?r|r`BzN9DK#VC^}vn00gn#@!Qqyn>PGuZ)h;;&m= zF-B|tDVy9T^8R~?i=k$&9N2057I|ch)!&B^0#KMbdHpG`GJB7+>N&mrC-_1EOco$- zDT{uoUlqLS4x2d2wrkr7W>_&<-IMJ4aX%7J_bcGY*>EgDKmha#I%Ms{z@ionr^^sK zkEl}%S5};_rG5)EKrmCk;a7j=eDX?n`r%Smk^U3+Phj&=**kQFK~-~Rv!@ zBil>L2VCg@#K)YNqp3g&1Y8-xj8cX4;W@rwW~hg=ScFVATceJ%>-m$z+TPr z2G<=~5A2FrOjY22sd}fDe1&ot+@88pK^p|vDfJdPEI<1Iwl=?3M9ns~$38inGlHAyG1kDl zYstA#g~UE$KTSgr>0j~w)oul5b65KiiyXg#(SE{1|4JXZ%6&o=(-V%l$}*I$Dmf+X zX{+QmVG&GsI|JoDoA|liw-7oP^guF{1T2_32Ww`Z&kYq|53G@DyG@H>1M#1 zy?3{kiom+cc2jBBY150aPhVB;UXEyf&3Z>`hOy@}kP zr``thrtmNe@?HWHDDs ze|Ii$yK{~_7%!41Kr?o?U-=+sG%4Z8l+sG#P?VVuVKGX!O9%?c;ZVM@nFBC<$McAi zTFG6@qM+9VdWiu`#pcGiBU*S}+ufutJ8oYc;RdR_q-;hOYuk65bFxNNFA|$Ap1t!G z@u>m$q$O)KU9#l|HHq9Oq9!qU3X`NK4(1ajO?L7B5smjd?l4ZG%;(LT@H1C1b!b2L zp?qB?4BW7|ngNG=)MQ2;C0oY7pDSCU`tSwidQ9ULo0!)BAV<7h_!G9-O0U%hNp7p7 zWP4wfO zS~qqqyDo8q$NVXm4vNO19%eOu%~wKL5sG9tm>qKpJj+gEtEyPZGQKgOIb#jW79b*% zu~UQq}WX9tgNT4-af~o12eMllFouox2){q!IOWYCt!nARhnR}#%6fOBYnlowS zr{C%86Y1%f^r3C6GqdNC=#G#9Me{p7dB)DR>z&W7gx#i{h*DSyNrUY*xBpZ~(l%>K z4!jGV%bn%S_i|==;?c8w8&hHHxmdGAkJoyg^~-7aDjK%(Xdsf&(L0K8{Ugv>hxI*0 zjhd5m5UhA*!J~Z_!5pjiIVVP%u4>G`*t2a{6x1;g$c|r?7<4iAqZ8s+-Q(jyO9e?K zG-T6NW3n0F1d2Ng&ZZ)-wTWj%`JBkU!lT)!L^hSxyHk-+Em^E^)ru$itnM?qRbicW z2@(NL;3Mf>oGRg;z7*mnq}DWVaKia}$q-3TN*B zO?q;mI`J8gqYAZqze1v(9@9|Hs-6SgDc#sJsC;k>LEd-~-Upc|_CX{~)Cb})XMR)= zDZjJmE=`PGCp;uJMf*dd!zY27QBgLGG=?maTa6Q;fY(~Thp|5cv@qiD@K=r4$B2^~ zIWF^zNMzP`*jg1~xD_U*;s!1G2_3fC-sTHP63$JDRl++7+qT0T+ieS1TI-1-H1+!K zw|zw5yw-^@rR1vClic)}2^)5uny^0e@|#^Y%!<;mR2Td)J~Cf}vw)Y(uQ(@Kn2D^8 zf9jp#M*vCv3Z#?;?Q1A}1ZaD+%$ut!fXNdr41CFOSUK3UA$Z&5vT*-w1`tn^Q5R_Q z{=yKeGcy~Mj4RXH`v;lU{HALMdl3AHLku&_EG0oza#2_6CT25-Km6WJtdsDApakO; zmnk%#Ou}TKAB6W(Y-5}@6|ZMAda`++rzD)8b&@j;56@&82-V$Zo-B0=D`~xi*hB#J z*);A{bh&i?5{fJfNw;p|$(<3@6ik+I4K~xTQ+G}G+pE@E{JwTtyolg5EkKlVJ8B3Z=!Rw^=-xlqhd#01DyWQ^md;1y*&Ncn9sbE7-LfUL>}gCyin@ou5vnF?Yqoi2OVcBK(gE&+%U%&-RN#``R9|oqQTQrwc?uQ3eP!$<4;uu zResSb=W3ISAos!oWHrjaM?Zh83aWE^u>WYuvzQ(ntK5mXhv!S2IawK?5kZEcY4&5bOnb3jX6O}PE}6>t|R1vdKy@X=L}CEh?^9k_nG4+ zLUa^11{j5D8(3Z+plU3kEs zAaN?iU7__O5k5ilAl4Ea0fE~w1kRmve2!CJTZ`~$j@MoHmjw0v+ahaoiaabuTqKaQ zW+~`_i_&3GN3d?oDzXsNBB-Fa16_cuB4Ik2q+i@lf4OzTtxahUQcu9)SWEchCg<9& z0y&M)fH2*4HXKCM6uTf=CRIC~WM<{u3^O}Us=i68Rzv<=pU7pCY@iXJNP8mZ9RIXP z&$e46`rYRRlAJkQaKh2ZLQ9#jSk_1U5z9~w$Bx|YFZq7| zV}(;fniBV7`F((23E{kmUzGHCZ6wu6B58N;7GAdTf&Zivru_1c#&+{a%4<%FTsg3o z=PkHf@%Us;^1hsBkJ|zA_;a2EInTqLXR?R`qx>@$zUH8?acJs8$z4%RoX`s47$Zi( zse3PySc7U#+hfP`D2t3=!4TNx>Dyu_$m|A(5%mX#csie@(^pB%`Z<~$1L95MdlphP zZMxG%pd1;6Hs^R}Jm?lZ>Ovj!vdO|}vBhfA0jE0Hxzup!=}$hTPpNh#JD`R=Lkybl z;OfSMGVR0XPyaU;m59JVRq$bi+c9=`n7(S!D7E9Tp##!oiEUn-GPli71{37sa&Ybb zuEaJiv5&w5IHo)g+!9AZ07h$FsPfq7b~<(qO1$fZJzf*Zcc3>DE<{sZne2-esB=_u z0-+9tMc$w=Yn-Hd)5?f2L)c{b)*$iBB{_ZF;P~@lTl4smF zxYIM7b1UD7a>H6AzcZ9~v$Sxz=pxF_-9~1$8+=;xM!FhFk6068Xf^4IH6G=Y@u%qXC8E`(EPlDKD)3+oDXxjIuumUv4`Y}-AEbB*>p z{uSXK{QCqH|fT&i7A&#%_J6w|-DI>p>JFxR`BgAUYf9zRZ8-*T!N zm|N8;PE}{As&3C#b^j4n$+k4x$4XW9?hrK+3yw@GcOcBCB^PD5s6s*`#YrdQbYnCN z9iB%(?;8UW1*wH}HcdA_@{gPis)l5+T}mua*hzOFiHtH!l2;CBEKxbZfcz361GpZv zHqx|T@QUt$q?SyuRWT$6J4Xi|5=<OaZtxz6fP?!(~P6mRIbp!z3n2*0yypg?lK8g?r5FwfgvctI z51as%ZRnw3ks2EJ`t;MY$K;|ImpTdH2p7aWbS<0Aua??B7<8xnO5d=b&<(HT$=FcZ zj$di-N*qi796hcJWsx-2<&%hh$BB1TSKc(E>JZ*tDDMUeeF+H%xJ77<4TnqdL}Aiw zY7)sj6$~*9+*BV6X~`J%B^D?Y5|W5v`=t8lopN$c4TAYP4URx++=`B0g$gpN&_C_v zO>&jVP;+wq`LJBOom^6FZmwS+mTQ^hqJO)|rIcl*?F^RQ3owc0yNqWW>2qr>Bdl|L z;pwn|-XMi<-CLmM4A9Y`kMlXZFeD#QU;=zpucaPAL4gg2nP)*>BuW0sXOmy-0j0al zC-EH-&+x6*T+(d)d3-h!gozpnWRN9G@gSiw`( z?2PC1KY@4JhEth3=3;(hnUFN)>&jt-d~PE^f$NV5_C%4(FBD`H3eeHiHY&hxK!B99 zX!ahBhrFow353V!)7NsAG*o1)1Gg@x0qi>6h0A*IcH&6vVLs&`Fx_4_h-N=2f52>54OtTJIn{G*4Z6GXYSk5P~L*QXEk?Wxu-pzbKQD=|Q!Z}F8jTCIEiIL{vK#AI+0 zd9~(li5Cg2mc9zjmKsEzmA+FA;Q?OFT4r#MR%jOy8X0~;uKB)S<{5Z{w(m8ULQ32h z;lj$yt|g2@dJs1DL-mVa?Fz}gAD%8nbfitGT*9<2;g@duyTI`9(!HszVQ#0{iz*#X zvwYRe)AaIHGlo>BuPHJ%M>2yyO8l5>0F#$vdqe>QBM>g%AKM~v1m6+3hjO+^HSKWM z^Q8rT7x1eapK-5lgO>}%m^zvFG8U)a*ceWKwIytr_VtD%3)A&}xdMhUOmg>YdC$zC zUfwff7=+iz5dML%gg^UbGu&tj~TCVv92_u7r&`{`>x6O_FY-WJ&56S zStSU*jd;@b)b7@eA#tf7lD@7m;$5rm^DY#SaBk0z=1(&UITXg_!U*#HL+3`s5iNM- za}#6v0j>Eoc2Br`Dv=)(&2)^8*IUnHe^GcXl6fe&TeyB_Pk^k=|Hs>zz(-YGkAEf! zG9dDzqJpAC37Uu^QLKr8&PakYI+3`bC@!>Aq;)C6B%pvyoEcyoqqKEvwJoltYU>^# z%8;-lDj+VXRlo(_BOs_XY)by$bMJdI6JV@-KL20&e8{|a-`(%IXS?T~!yx6KKmM6n zIUE#Sr_=l+A5e_Gcw-k5;^$WoyO6r|>enWHAo&qAB=9Zi5a9xTGcio&J|}@rC_>H$MEjF^7t|^-hvLx_QiFUfqsejK(%BR_b#A62NPQVL05!8 zp+J~l0bwVMkv~BYW*_^BG*0;Cugg4TtIQ^6C&CI%@W+Scr|hpt9TwT{_D0Q6A^1FW zD4R~OdF+$wE)I6C?x+wlW_4b+;Cwmr#v|gH4-f-VzX@3uHpD!kZJID0W=GNlB8w!~ zPP)_JD%9N>;g8&v&%j_B$mlG$ybA~!QO?3rK*HgC*EHbhr53=EoDS>>2dn^R2lAvl z0@o$W&6-Le5UxvxEBw^4HgEQvuyLjv)y9RM>UQQ7&Yj4mSSI`rKFn8{1;wl3OCvFw zlSef7LjZD;ub{12#ABFMz~yU_SRQE}cp|X> z2TRonj>4+Joze+ePhzSB6JzpKBrb!_Ii2W4C*UoAVCSSe@wKy$90reH`X#mO&!mdo zrZW*7Mqv|W!zYRy^aNey`bxw+Vt{-6Vfw>TFM9ydJ#kB+pWw6}z+)3V^(89taU42< zpd&;wctdUZmiGC?-TMxOwXnlO7+|pMdn58Boxz=ES3GDAv*iMD{Zi$3ULg2YRq7>y zTaWU1l~>8fEsMH_I?};B&Eo3ZkqLf!uvPUyF*Nx`>{eJ9BAP9CxkivxjI|Sfgcvl4 zZ;&tH>(q+@G!B$MM$Aj*+Bd}=px8c_T77w!{YB6eBYG3McRg&js&zGQ=6l0A7`ht0 zviYVwi5Z2$zvk=mI*Qlw1RfVzz$bR0yR74n{(hW%-;LT-(;@RvdH)6Z?e{&`@b2PW zi!71NT+>>bXPrg~Eww~8E5XIeCuIri1Yvmj25TqE(S32hApC2Grg5*cqZ?eOaf?m3 zP#rHj(XQpoK5Ex?WrxejE*O9((-6J@JT5QMMpD=FKpd_w`2kNHHJ@Te^crT<(IE^t zRd^c_l(3cp03}^Yllc$QM&w+WV{$wBk$@j-W&7q423%qE z0=1h|T8@(zPN#XCG?&{E4`=14(sEL1Vd7kg6y>oSz$hW4{^G)s1a5D(BElN;$J|wq{;e@M}!#4v=Y`z@QebQWzs0Vt`r?&CNxvnC2!5 zS&8H&8taS;1&I!_VI{y;P{?$AFW~NrcY4XUG*6T+_|oDN$}=N&kMw^ZtzJ@8lD;{T zF{^IRD&`<{?t$wu*r&@E-<=P48 z1&}$1o+?JQp?(NPQbWt7u?G}>jW1Nbx56D2h>7q6rRr)P@g?YwP*KR1=mc}%^xx)# zmX4gFBBS^dXQ~B{_w^^nGTbo;TVuh!;w)q=!qymaj4j}|AaPj{F0;~gNLe5yK8U#2 zzb?FDFKhai4Dmh?v1)A3NF0);Q{#toPjd%+7(ncLN;uv)sJ`c z`YS<>*TDHXDikyLSDD_$)<~78$z%Xl(%<4W3b2$_xaR_lzcd;F#$#B6sxU-H*s_h|7xZ<8SmX@RPd+t7+;!PQl%fIl(Se32ZRr74@lAj=MMY0~> z1+>g;0)6FtidPlZzM-Dj9aFeGV1HAUR25Qz%tc9y=9IF{hIGsv0mNEvn0*1-F)f26 z_Pe-GSEouDCrY9VV2=rvfoLdAjM)V&<2atfN{Ag7%za*EVaEzDMFXO8l_My5G`~Z2 zV%fRo~`;3gy?1tx1qrt6(?4WOX55R*fQff`(Eo5zpYZtmUkZzQHZx(pORrM$pE>bT+L*$?Y<}=&d6!Ed~KndKa#_IRSIlU27tFHDtr zxs0pPdPQ~_y_bO~(x`}}dG6@ia94{pJ4n9{g`WOxx}K5FS|$&l3|0L{7aLimAK=Xu5@%EE~u-w}8KM zVN+ZUAtu#ainnMmedtukheYBGov7%DmpU3lN6B+!5tMx0@c7r)wXRokh@BGudiZtL zvURd8qEtuSSNY;AwFyBW{-2@BWrONoQA>MI^`+vfAzV5!bR}oD5Pr-+#zQ}aM;h4= zBRSNJ>g5n#xYLmv88iX~@y(_D5tkIcYkk-GuJ_%rFk`&d>*E(1#~A+ccnWy zS#{;|Ql)Oi=e>E^;{a2v5#oSMKw%hPBBYirFrw?_O)=Ow;r|0K^CvN@%C`_+S-*S6 zh)pIj5t&JqxOs>44O}b>6*(WOEHn@q%#%EoujY^75;ebpy1R1K98H7|e}Oy*Z?zML z$=<<+pe`>4O?H8lx?qhqI9Kki-A$&*PEJeiP!EhuV4AVyHFr(VS7cY8(2+7JkzJER z9gSp1Rw%l>+6lN+3+-W@Vw79P>M6muiPH+5R2%CnlC!ewNU@Y0tythM0rb$si)G$MRFpIzpF29^+hit=3Lyt!0=;*0Ea z$!q?$ujDYTZjhbI_!51knk7kkSZuZITsXsHjAI(To0$p5$CX-PfewLEB`C?b)^Um; z+p?>5B@h92Uo19#lue$k82>v1iAZG3l5T|XT=T14|q&k4q zg>r&L1elom&S-LN`~6^Wu9V9iR2q5xDVaBAzAh`k_N~t+ zJbUBP%VZt=fRr(KvC}!pQT^xUXOwwYdjI>b;&k9jLL4h2FEQ~F`1&=1m~G#s#Z0hG z;=*AZnv6(d34mfmN6L`)<$0Do@K2s!)Q_wugjVpoJWMdZ&p!P0}OzWFM z!%>Z#8^Y*Bu0%@Mv+%BSLmk4qc#G4L##|SGo{rUIM0sirb+hT9*u=nX2z}8mT(?A* zhdiY#jOcxgEPU>DM%18A2HsZ=IQmL2xe4PavzZ95%lF15zkGw)1hvX%sLHq#C>iR8 zzL-M?*>vrKWcFU!q;*L8;Q^{7)69<9lxPsz4JCR#LSZcUln4SDU)8toORkCz7TW%5TMo}1#{F3ECcDuR>hp>ZC4nZ&;UJxkz*m$@xx*${uQu!p1 z=wd2=AulsGC>jxM{gD>_FLd)L!K|ZknKiLUjr@>P{klJ%w^D4A+E!Nm3e^VUsCYWS z&a^BJ36kzbI(S&^IEYS`-ORGvBLA5f^ zv`n2NRP(YPLegcuy=oFEJwkfP{9$jBxb{0wuEdHvMZs%jcFq&MU1h+8%Qoy z@Fz+wQL)aEwSXaSlwW*o=e>=Wy~xff%0#CoKnO~v<)xgO^LfH9@1@+Dv*oFW>!rM! z-tyF%`%=4_6V=m{mky~p#{W8Lt)l<(mo4;nTOQeP2-A0 zRqP&K{dL$NNg>1>eu8yf^2Z;Zxs|65$;cIeeVTfns^u5)=5nL{(;aIXo7>lJTu<4i zuiG{E_M)1LwU?$f9eJAYlK3^%S95 z*N`><3Z!z00no$b^5N%hb$pe+JsrUxIHBjy2LU|VNvWidaqwoSgX+m`QY38TsF(G~ zvutiQeK2t|fXSH@ds_PVD+OnQ68z1$?@J#0q$t(bu?2I?>L0naQnqDWS)i`G(0y^@ zimw0*(}@0xxx6@0{*~Av;$QI1YIN|)J{biE=z?R}H2|@#AuXm4&g>C~PxVM4>ucq{ zB{dJruQtRiO3@Z0x`G_@Ibm{{$8+aKD7;@z8N`^#TtU=3?llOrA!5WEymE*623Gis z92u#$cSv2od5rI=nnUe;OD=R{Q@GCTN5u`}kt0=2m^o0rc?O(9d;yrdK&;!9C!1v` zL$1OUV-GGJWVzSUZiW*2`r~P{c9BVHhPc8;gfD*vjfs$h*f&abB1rwG=|M%}zL`{{ zu3LA7*wGQ}5iaTL$Fo}?etjwXCEs7h1vYJ8VN5NTOp)EgalQd3sb8)&q9*|s!T2iH z*odxTDg$MUjQh`J6L;}Gqkhsk9`RP@1`iW{$YFzGyX3+kYzrlB=^#Kd zTDl+)=xstA_o1|)pxd&@2=D{w3i#*yb2tz{3K66h-Gg4(+p-vv_zh2%$sZJdz~5+! zQ#~}sn`0!KF`u!LCd{^6pivCBuXt4e1hd(^ZzCMc9$8#aGVR_nyG3;Neloc&ywX$+=gg&{V?g|1PzIV7?VvlzO#{RY}(m_SPL6- zB1=ld0_vuoqSt+BrkeJJf%t7On7VryphT}#L)baRn0gscjpiYdWsTDZVdSQ>EXmD@ ztUo`pEIfTsyFg^{usk9B{={I9umy)xLSx3k7|}f<-K4!!1~RV+UPjG`>}8V5fi2d* zAVrKF!jB?LP^NihZ|R`spY4kgu^b9n9r>gA*2KULP4I?xNkSn&G3ORY;j-RJ8)QU3 z1!6G3X9q7X`2>!m>ke>M(=CNvd!*$F5xe|XP~Z{R1mpf^DS|J@&m{TMi|l$Z+yxPr z5--*r`kg-k58*9H?LOP{$4z+tKwA$6f(4-$H76^E=T%9-%~X+bx3~v{e#0O(-;-{i zV&jL~Ic_G0D)lQKn%`IBRC~i5RiEo>zE|XDjy(G=7YK^(hC>F!e2-I@vagMDh6eeX zsaqd^x1-OB6SJF$BidQBFW!j5W570ajNrAsDjMvaG^P{{zL(u=Hg(tw!Z{{|*skMa zTf}xTDHz0$TxLua9ggrZ5=XXlnNJCJAwq5{y!Lf&3Wb&%$(00^T|TypPvJh_%Q?O^ zUzB%P=bH|K^^bhBC9h8Jg6PvsU9@pRn&WB&w+W5%f!uuIouIb`U<>eN;{_nN@I#l{ z@`N6@@lcb^xET*EC|zyD>fn2r((#AtDUM7QK1eOl`0nuqGAlA4$>1>_aZ1=;HrL%( zD_#lApl*0Ckrgwmx!x zu;k`Blol&O{jSAN8!rb5h1^$~u*OocQ@%k|&q?{?RAYYU-Mw^9F+Orl69%vbwtW3}E@YojN*;SJy~ zDSuLpy>mXAtH&f+{;1mY*v(h@l4{zX5Iv45nN?1ad6z$_Dko+wI5@N5sWJibCspu* ztOXCFU?m6>UZ^y=>?RZ@Io#jormqb$&b`C+pHZC+HoC8CfDtV}8_8umRySEaEb-1K zoA8axTvm+`A{zu7Qovx&Ij;>6q!z#E0E_?cUTMsW=AtG~;c2)8zx!GOxk8ug-i2sO zw;o~j91aX6I~yh#e-{q|reC$kW)VUwdIQd1tZh*5T~OlNc(9(~&-@o}2iP9N;!=ms zdYRD%5_eIcrY}lcWWt#=fKKs&CV%l>GxA3dpRX_V=W-w;Eem4{FUeX;N8lrc+8NW{ z;4Db-kTEfuutIJ?47@4)WAR#1CEWKo2*f#PY}e%>ZLZOsUt=0>qFoo&4Or=~>#~?i z(OdTW#N1W4r`7s;J9C)k3a*snB&4KRr95c%01I6XwrHp9c8<3C@c|jG<%;&|UOy~! zLG?GI=D6Jc-Y8KVg;W8JpjPqgoZbXzV z!`K{E6&C*DQlQA+KM0|Uo^IEK+`e7%N)BA^UB@eT;N&B2NmXM1bCrI?h;Bh2lVZGM zwY<$4PXDX`=XfHWJaaY-z*>fe;Gx3pFt&l!pU8RM$*np|E?MOLWpZUq^pm_=lYlrI zUz)?Es@K0EQ*ICmq}cKoe`I}($Crx4)S0xY4n~CnGicRyq>LkFX9<+}>MmFn+37c? zU5Q8u{h06=cPL<)3asBqjRM2w?tV1Tk5|RgTBSgde5f)v$cK*v4k+Qr8CV`&Z?#3j zq2QaeNO-PbA2y<3R?e~TtROk{eVEJgRZeC?nO)*ai6NSKQu%0}9Dcoct9VJcuZEF{ zh5TYMjKArR8d!hFuQ6>Aa4f)jQC*jV&x$19{eW^K&OOh1xN&X`8%MJdei)AuJLR22Z`(N4Dh#b#! zgiB91VqN4xSpR58o&u2{DIx;MYsgiK;Ww*47E}>Bw-S^p3aze46(hhe>MJ(QqABx~ z7dKXxEi(qMq8Seoaa^2VHF5B|2@WF#zR|(LwbnhaXlAfZD~KCTXFSBfR)V#~U7rWe zmEO{c`bNK-y(?(W%H!U@y?#RSh@Z}xG{Tw@Z{PvG>qQ}Q-qP(j*(bq4)k5;Rl<{uU zCF@>3I`xRyD7bwQ5b5+rY=niPH>^wb%FI2NGInRIFF3!CtnVR5Gyb3Uf&*z|1!Z3(qGj-638h;K`!LGx*+F;I(;JD3S zMx6ssfd~-W0E+nQ>`NR74l`x;a8A9P8=o@w^6rm+Y?{C0s8IZ8W$Xyx4fXTeul9kQ zM1RL9Y|3X$`xP&~M7?0>SWD>UG#mxw16PBBBJT~5A|n^ra=gcg_LhXm?i=RZKtUtg zgI9+qD38CJ+%8@r;0lB-C~gur2WHcUbl0Z4))uxndu|{df`8qu)N^_g%saaC2~s69 z!gw@&WLM*SjY6sZ#r`30iA!KZt}IQ?NVn%4R9%|c-lUA8;zOavK7jo9apL1c>2&~u z1<60{e{M9Fso8hhOP1S91`boFFf;j8&&>a5jy|(trSV`TanqN1xWef_NC}O>4=iwM ze9`G7|9pIagt!`PAV>j>F!Te61^2}c!?->6H~JP?R`813H~qrHXn7VIp9E>W*7HY; zr=h!ysbWt`42ezCI=Kd%u9ZBeBXzGw$@6tCSJ(E@D2>fm0uyQ;N1N2ruHS>5T;9-` zsnNlq_i~^@p`bSGq74^wVWBj4<|w-aEtJPMmd7`gY_&C7^mDWafwpM91{#8_3Uf@IVo4Cf`Xs$gAfEVE`z4rG~ zmMcz$+#o+k=E8*7&v^>G6#21-asNu#Xq2p8gpWl$g2J3LzH#t2d0@d|koO|$5dD@% zj=0>`pUJ7DzGC`%N1+|q2xK1Wnu*9SR-MsOhu?h*;lxHk*qnWf??>wx(P7lLn~$o< z5{6#1WbWpNWHJTO|4Y$bTf|8-@!y>(gG@e%4tRnE}nj>@J+T{_PdNeSUse|c_%VQ)@_2P+0epbp-pwo zkw3l$`D+cv;7|JuwJyxah8oT_NB;O4=k;3;wzZ%*01N z>_`IfyGqU994$q`&$*7sAlyM{F!=iT7Zko0N2-p7OH2QP4yO(#*?LBdz3jfD&vea^ zKR)FW%({nfPH!@i-ln7FD!0fsmw3buOfc;}h8K&LQp>!ae6Xs7pRil#BrV7vUxWO$ ziZWV1PQJ+>UxWO$I`Pdn4@T8x9Yz&0J0DyRYww7rDPh?>J~PkTjTpDhj1vREUr|_@t0!rcyQ^LCns+Y%?5>Sd$3<9lfXb1=BDaLxb zs_70Gzr4c&jxoT}_A$mnKDI^qFOgzv`vk|>+CFdTJDR@r@x_`2G5)nN(4=;jsOVQ;hnUW}ugZj&pzsRh#h7?_sXt0Hh*@)_m}&qZqjuT(uuS zG#4OmrlweI?bcl-K!MfS25w)!|*S&|6vHrM6ERUYh@|fuaX%Zf#_L%<0Ws zC>XIm%-k+%2tFcX1Qyajdb^~Fz}KgxN0~8qSPw}4y8TpnoxuaCe4@hJz@#WDur`y* zq^Uq14YZ{KFQ{pJEkir^n~Y9aGcxNDU7S+LnHA(Yup+K^X6ef^OQ$hM`^-FjGV`P{ z#}^zCI16rdB+pM_j)zu&Ilf}v_XmR0v_4H1_N<=(24mWalLY=X4siftJnpi!far*1 zHtwiq1P<dz_AOBkxEiI2U0wVL9xT3G5XOTocdrsu@ zffqu?toy(wC9USg7l~<5yH2x|%>Cov`SLCGn1c#2VL`i6_&Jq2h&Byfub!GQU8ily z$dg)pEj1;`m@$#Y;h=$Tpi(ah3mIA|@- z==Au^JZU)iBs0(Db*oZlaq&q4C!iKN zWx#b@tmD8x(uiBYrIm0^tY!NkF3_q1Tqxsn9!8j({3y1nWHREbwI4hY<$dwBNb~-9 zciU6=sXdeg7M|$7-Y?cW)$RRt7w7n1<4tURikC%pw!?Oefkbv55*iuVnHS=CQEacM zSXHZv&ELd)i#u=CCJjV3bFpo0x}60l06H=^$&q`j80|`PRgLH_s$b?_I3BGQL)o@k z-!W9}NAX6fk6h2{T=$BHgUW7O1ChnuthdQ!)cc6`_saoC8q;oNGiq^S?Q@qRBi>e8 z+5a{aPWcclUwE=>qP{X0n(S~}p-V-O^o7f?_d8QEC5~1;S(8)6Q2Lu6>7VF0BA@3q z2%h&F<=gqc4EcVHq67YTzry5$bWr;$-1IRl0G7tSc?INFN*6fu3?l}sI~}g9tJK;J z;uV$0*C;!$N|-!>&>}N3PH8v9jtkYs_te9Z4s|P&E>4vf5KucDIy!*GnUvw%;ZADx z<{(H%U0Ye9!RHo6%=X#Y9S<~BQeoYt=zUE0oH6pkl*XZs{P~CCVDZipu7{gm#p&hAO zaQ5kFHgZ%g`jmz$C}y1m+^_?!AE6`|7|7$d>hbzg>rl9L*#V4&ZD73!M=f!Qe#5V| zO|jQ}lck<>E~B!pA;~wdP#z^tfNvfr4=$@0kA9mXu&^UaI8VWn=QH!hm3-hb!=M!B z_{ayO#8>Jaa;1X(dke!iUzIFl~Jm?@;lscm>> zZNuBthA{&r(={Gxjg=amlEKW9C+<^HjQ`Rl54TDwsk>jQimf!ajn&FYv4u$IJk;u( z%6WmEbFrP1%Q6``53|19>eM;V&iSaF^Nuz-kGC39IWM$x-frg{(k5qnYep*P2s`J6 zcFtaHavo)kO6BZh=RDrdxd%}*J)+~R0jZqDcFyl^*JEGZCT9ohh*ZwA?3~N(oPTeV z)38jax}MKV?VNwJb53rP^B5~hPKPaY{7$~kx|Y1l9czcs@$L#;txxCW;z?dsL1{YX zBo4FFhK0ggY)VS1*BtO%5T^A$TKsgyo~#w0k*(skjC##0%}@BkLyEl_O~|3jzC)}= ztln>k_-bOHx;Kr2G^?}8gO9WQ|NAhVMk71D##A?F@v@&qc5;psocRrt)*ycZLiH@0 zaU5Vb;z)i<_}pJMsd*DF-m7Jdf6A2JEhJxAQpj4lvkv0lCuSMMzEhe}_sP`l4C`ls zi%57mSy%PyY+X12xO^{Tdj`%|k4-Ah4u`I674JJX1um!B;G&usL=y)!L;)4N6=Y%m zYhW1vJE&-Ijmr=h3gTDGClzO(yW_J}e83?V*+W!Kj1V&8$lG!!;W`1%Ho6BbmOKhf z8uei#ibG&KI7ai8Uj@a(9O?sSz4sYo6RGTO(3x0|@|7ITj zNx?nV26Fh!x%n9mp)#heIbPHeqT z@VZps)wo;ekAm5CHq7$X(a8OSZ<%n5{k-HB*q!8J($sS`b@Vp302e4VP525;TVemkk z7Y0DSE&P9$nIY^9;Ad~% z?0ELIW3vFn0cg}}*}OTM9Y~YSo1I2oo2}w~Ax+aLd-JL${)U9H?+|_5IR44aE8KuL z>*jrj`8y!ow;86>sM@?8Y4PAT?{Dlz4r22zmMMKfq^1;0lbtW?kZlnAPO09!s_x50 z{IcQwXM;;PD@vZ)_2iq_n%H-UXK|ePlRH9D?W{ZE z4Gt3za!35gN#4Qjh^y>I4q`_r^8FWa*P?cW;t;Y9V#iTg2C?sy>K&o#_EGn~bNQ1p zp{#259TCdbg*KQ)ucZ=Tn!a?#rUaO*;Bs8HiuWCxmI-ZeQB7P=69+X!ndR(&`+Jzj z{|+j8h?eY#&%SVmC>49N4zV;_#RnYXsrC?66BB7--ywDYKL6{E$jJ&!&mQ@6hUqk_ zXvCUB4|YdX*o_>-j!-l)A*UUw9g&xH5MLdUWf1#LsooK)?lY)6JuCz!0`8<3yuL7B zbL5YfnS?7d9A4~yC^OANvv44`tIT1$#^2tC|2%-a)R;wHnw80ShW@POCCCvlujM6{ zOxU*~8~$=9K-czg{GcITy>8*vnZln%W|gdwbz}56Jj*H`0I6vHpZ3#aHv3jylAopG zeZfN^mELYWMAbxx0}Sy)Zu9=+j#CPftiW2Dtv79k>CCIzaet%5gQG!f5O)Q89mI}P znv!noGN&~AjvHs!|KF@9UeP;F)jjXCg9I0$LD_lj?VYo%YMXh~Yx$rc=z+AKW?8a} z_77*P_<-P2Y=etx;^R*ba)^q7&$=TH%hr<4_(>pq5=}ntqI`gW)WeEiQ;K1b%b|VLY zK$Xz4_9JIXm0Xl{5NBo^#J*Fi5vZzr5_NMh5Y9;YjY=BQyC5TNC~10;m3`7+JBvqW zQR2Xvc3O^3Q>5+$op!2Sy+YX?RhrYHD!OBBW+zn1FWV%kf~zHI9|`=wF1upLv(A{S z!~bB}ANA-)4r19AXTIS>XW13=pLG!Z?fQQvmQZ!as5`yvDru}r8gi<=>?-YgJI!8a z#pGUOr`hYQ5cn^2TCu&(3K5;8(wucxMU6H|s^kwGN~b%b3R)^@NU_}!C5XK*X^ys0 zjv`iabl|8?!|cR4^5_51mhm&H|KHd$t^$+UDpc>kex@y>ryZbTt3A{FnR6hb41FB- z-kACUTGjMfU}w>K*Ss$vs;`8iI8SR<)8=4Lb0N)XqWRI3W;JbTC^y!e45_7(%h)$d zh5K6?KGnRp&5}+Xq@)Av&Ckv3LCV<7>`4Qec4kHl=ALe6S{kD?1d!$ArRisLokW!)4DA%n=y9$jG9|1%Mv zs{3B*PU9PubcaeBQfwnMm3E_~9W1Sp-ex~Xe<0_7Fy&|1jT{86iHjUly*hKsv#WMi zy0Z-8z$}KUyBl?r{P>BouHD26xsZfO6w?T2Rr3T zNXv@N%d++M|0gzo??*i)2QlSJT08db%qh>$I*5>6|Iftcs_x`lnNzNko>NIfifnAI z(jF!)ZKgSVL!KC->RYUThyB^-B3A!DU}kk9n|`iBH@~BBii=3|Ll5pr?>j5!i#E(kxLv4YXy6v~!P4mT1fFjE;W1 zC!?cjmS`Dy4$Kn$E3@=tnWfV#(LI@YCS>MGvqYmZ^ISompJIu+{TY_%3^K{RO&y;* z5dYD4#Zd9yx{Q@+lp8JOg7Giv z#^jXOjmgEIMqeCH)LroDfUAvZw~<#HocC?e_gBNaCyGB0;(XFzAYM&G#tNL304kS6s#VR8J7aefiz)0mqpx77q0 z+!1-C6*#$zZx&Z77>{q`ex+ID!kYph;&vdyAHN0H*LPb# zGEu4qfxl528Whn2C)O*Kh=!@vk^Qc_%hv{{$1^UvU|!8U7WyhbHq?fGp>) zyQ1)x^7uEl8^>+t>o?Gd!1~MBzA-zu;5$H>tS7ExR<7%d^A!bLHmFT~kWNvbz>BP_ zENUQ8Ic!#5QckPpjKo zmC^Y5tKfd_@^Y??$W94T2mStap|>*rPLSIJmGKWN%O>|Vrq0GWh_9u><*AJSV8jB# z^r_v0`=3tSa51KCq{{>F?AV!4#?;YVq#1C%hF2rHS-!E)K9}G5HTe~Zzs#f|33?a1 zgv+@BTxPp*>cX|ZP$BFk`ywwiCQ!S#m0ZTuv#64n8PZPlRshVHwpJ&}t#}qnlBTZ1 zdn&oyD%VX?Ywcc-yu=2xaDYoN(#kFye=Nvod89QDCq#7v;tV`!`{f|sTx4sxK|!FbqHj$Pquy0l^+A|Gnp5+De1Xy*WW+$}GyM7z^P~px5_1j( zW!~^F@N2#ZY>jb+Mg;40oY3Y{{Ko;B@g)K+Cn0e=PPF{)g?_hkQa&c&ehcS;<9c%u zM<5ExR*sAPkv(@A(|Tjz6J!PotTRM- zO$>FlECA+iWJ3V}eVdQb{`YLy3Quh9Xhe??GEug6yydH{9PMJ^;;XE?07UKY&e`1p zi*iq++V&kW^CKbM3O+r_iTJO#A^-j!YMYLZEb|bnHS(rs z7KU^cyL~N7S&xf%%LP9x26Y9PqB1_Uua@C8Or{l=jHffhDoTUQ;0V$cLi0t`reAEG z%s4b0%J&(3*I3XM@;C_DLBxM#fdmovvVqbIta0fnLN#@!OUsjh0R zz`(R3nU_9J|0?6(lr!1>%J{}$g019_f67HzLC12;ogZ4Qv1&HKIOJ1&ymfXfqTH?wIT5*F0k^KFkOauuke?GTn>JMD|jwsPw)P961XZwc>av3Fo*9Ns+y*tL6`F{44ai zKp z4i5qzubw24E1#sWWR>U;1MK46;b}5+4xJ=1ds`TRiqRmIb+B7VSHEdTx{wk56DtMy zji@Vk%fn=y`xUw6o; zctxJ|1}S>Ksqq`Jc>u2Nj z2vf>lPdh$B_t$he?(hdWG9GSc3Z0i(8N-+Y?j?Tr z8vL9Kf3TWZurhfW{DF9m`Rzq*_=82&&sWAbsICU%-vr~|2W98^<14HycCp{)fLUC? zV2<^J;D#B>U#(1M?h4tLi>)=^DL6|qGKEK)-_+@^>vUzd?(A0$ywNIZg71)x(KlJ9 z%f(kUnLXUAR`0AU&morMX4yFA{cBjydD3o*o+>mi?MLi(F1Op4eoFeyc6xuEuHEGQ z;$Fdw)wbVBnXzaiyb@eruy~{C@p)Xq+^5t`g1&|2EwCcra}Am>57RxMoxsQs0(FB6 zY;VpvL8D@O`Se%S`Us~ifs9<1MF}{%AimAJ0u1uVMd|;*ZjmKO4sJS;1=eZMf0%$s z#U!_N{x_mBm{gcEv9c~$2)i*CYAC)j!(>l$bt}b(8EAytJn{i-q>j^MAo6S;-LnHc z9T|eT+Uu$s2Jc)Z-*poLG;%0yLN+uLJ&D!!s6nv3o4Lle(i);6OArFV~ zAUYCa^vOZb{(x=71V$>EUEv+7DiROQq)UM~d`F$W^iH%pUfH!z^#Nq3Wvl+ArnETqSPA7bjdmf%Dy!sMNG1TnDCnp0J1*n zAjOD2$Xm&BJ+qKtPjdTM+uxd8vo7GmJ8O?)oyxlMj?go%;jRWP2IJxrpph%hXWs)f z!FUxwrwAw@Zk?(CD552Y&QVD@X*|&l1X%)#`B0%NRliwXwug}I6=PH##{Df!@4l-l zOZuV8ZLg}3X3><(stPolGZAtfcScKeO;i64sQEMo5d@@m?U%MM`#=S+Pl-%>x zeS-;he6hduPsJBg{Y4vM_qVr@Aw7uWQi(^W6Ct{GPPd(yE8di}rU;ic>@meg*psK7 zDm5x^N=2Zuppo2e-7ny!+dvw!t9x0tM*Z#XV4ctHHR|7S_#Pu#z?T5@0D$P5`K5ZZ z)s9cjx-di4zm^%&llCh<(TTTcfEA1#N1IH@736UCJH6d2XS1@XW`e2D6z9+}K z(h*q-G(9&kVpVacn*3!ejj06QqO6-@N8q8pdIO%)acJ}dPJbG!-xJ-gbX0ERx0t^z zfr)2WbAVh|&80F_M2k5xu9`ve1`2&Kx29A*_HezJS97|0Y|VYKUCl}QamtGlp=J&U zQ$?r=mTmWUYmBTv1YUyRWXzKF2DdeZ{t54i2Ro)aY@KTUiX@Q(pw^W+R-phOF9fLShUO7J zIj$JwUR&W{Z9SY3`8%zmi?gQiE0x?tCHyL#mDw>>BR*85F!gQRvbR<0g4f!X6jEot zCwnTsO-7RZg(R$5ptIP8%vUJVe6KJrMN0O}>2SF99PRBRz%*%Y%7_g@b`Ux$>tJ2~ zH5ns&FAsI(?>Hm&D7hR7kGKfN)O$z}0*nGy6haKGufM|@D76vW!&ORrmgL!j)E0Tw#jb*2q@|zE;oTDm#*hicNIq@$e6<#8JR7}dXhOx^9<;1J_Hc9 z;SqbXM6?<2_J#KjFdn3#P(F{RNN}UQIIJBC1)>pqk^FTxRec*A6Vr1YFqc))jzXbU7xMRX}sRf?B!i7F%>6EztNo!YPp_faX`@fl0i zt}Vd34sqBLmvu#P{bqhBFH+%g`x2Ed-_nX-3k)XNg|3#SyilQzDC4aU*kLV>BtC_= z-Y?fcA6NnnYl$ow9A7}k%{582feAAtDl}&HQ**?8*zqs8c9y)E`Xtj{GARukW72q6 zQcES@>yqy`cD@fX@-_ck5O+%57O5PalfvG_$1Ql-2v8>Cfe3|v95Kk)QYI3x_>^!d~_h6Vrm%HK)bBdhJ4+pdpWuy z*J6(R?L(Z@LCx3m^n6G+t#8;7$#yiQOr-YjksxcvStJ$h*WJhT$0|Omu-`JTGpJoU zlxKH0$GVRu(6ILPm#s7I{xdhc6em!;A_XuR+Snr&iL4Hz5ZNh(P@Wr2pASE;Q?^%xS*@Odj`zz2hW11=5{;fUBAH9(V66@cf@%`)kmoBzU zijB65J&{@LX^Mp>=1dGEZskPe&n$sbk(MnUi#Jy-JIGdJmPCG-UB^twDIm}rh~L_m zWP#tAPL0+HOqIgGk%c+JiHw%Q!ozPfKbZzrWcBuZNk^Uay~*xVXS)UshJc3EiH;?2 zu|IEnJ!7QbLIje|z_qF{yVhcPV(Tj? z{S&p)BVq4*ttSob>*RXzk*=dpIBuVRJBg-- zO6R&sqt{4ND3bAGDo?%SNg`h)Ipa~yANzBfZ`Y>z9VmKK^Inm<+BV-jkp?~>L-Isv z>Jyp2uJW{6p3sB2tflhA$&AaICr=^+SYz3kNyH7D=*yGHG1fZirZDOjr&z5?@UP2) z?PyI35wpCKuRxy0OD#R*=~j6#~N(6X$#`t3sX%<*C0s^^~U) zc{*91PT^^Ol_Ig`8@CJ9z_+A0YONQy7)pso{62`c(wB;U{P2uV#0`FrZ^9q2lU&vx zfJFdL@p0xq=d#wY8TmNjC$J`N%Z2xjd?A!t8u0ReyAvrobhMnmNd1|q)m!3C)&+1< zK1C;#P>PoAi&K>XZGjOzhTRkWB-9xd%$VW@s5kHXnC%zY-Qg|+U-s1gPiqgq3X~z2&LSUFHFUUAA&Prv zQKN|r?|>|dg+xWy{#8}R{en>ix>MxJ%e-*t=Nw~}D}8*P9AiSP24xZ}pKRHpIgmkn zyYrr+S1*!ooy9oBm4u$VWsdX~>Y^iW=NR>=G-hsrRm#kXAn=YvGPu5%$F+nJgJP^} zHOtdV-;Aj@vLaTYh;H%4C@yY^tUsoM9L>Z860HnG10qg}PCS8c~bsuqU9eCH|*i zNpki2*j!1jb*t#jIa*N~GfA~>B*mF7BYGu^B$V5zoowZFPmbQm_*l~L~PH!|ks z+5P9`pOk}194Y6mxlRQ_T!ai|jwq@sx{kA<3XgJjUH{&JoY?(^(~nd&XeMy)SkXoU zKS0&Pwi0Zga?a1;F#31M-vV@5-DE66_>13hs`AIbGh!QrZU34-3ZkrkFjW%EBD!9% z_W{Pf`t^*lm+n9Immq_wav6-rpHw-!i({N}ZMs+^MN>k}=r#@Ayx-#ZGa8b)&79ZM zR9XAXInQYfx3I;jGv^KzXWNXnmU02uTyf%_1CI6!T&<;cz$2Lz>7$K>@W8}9ddH-W z@w+^(q_sf2SQ1~H3~g0sS1^JfCy<`q(rQr>bPk>0dKXE$Oy*?baF zw!p3Tuyq#nNzkK}hXV$u>C85l%$3QpXE{G}a#FMWBJzgv zqMJsx2#GYJBNb*H*zejtG#7mg97*KZ<`Jp-Yj@A26{GHaMdAvK`-f8?vb%>-cdU9q zK_G$qBD>MOZ|6Zy`<~>t5@ls{hw5N|D&8tjiQ`1Nk8YP|4pMI4nd55lN+kMC>MLeQ zND_(5kS4AuL?1VB=I}oBMg=ZJ$fV5I=45ca`__<>LGXuiKA$AunE zdT}hh;Mkdt%q^sd^g^_4{=~#m^FC_i!E46!gWsGaE%oqH;@|doW878-8W!ctA}o}E z_MV25R7Fe8&JPhnQMCid+>v}UYIi53e~q=f|0?~9F6D1z_leb)q2u(VJNe@!bh2-{ zlhxPk*U8ItC#y`0Dy&8bi^huHRxdU=T71UTyHTJNdlNvwcpw=FC&;4t3QKQvU zRm6gRW&GIQrVW-Z>XmJ-$_VBJxp()uBQy86iGZYlWnC(b7+ zPTUnU=bm=LzW7E|MO|kQlG;DxytQ#8>umg?YKs zHxz{AkH4)jTkV!d$cVLTCuI%jgi6G~Y^Qs!-ZF6Z-53gC+|*ELq#*q3!h&indZI)TvS#u1;_shOtFmM){k*rfr_-!NN=Yb95%M7Yf0md*454d%WwjZ;7YrRbv@-r}u=f?RQ0ye6Fo~uud}k_}Heq7X z&{fNv)h?2i&#?GR!+*H7lMy{xrgy3k4qv$SBqRDqI;!Exm?jfK>S1WHc_J3gFUQ*P zRJuxk7|Ae+>HEs5>=1P~ki$z~ob!+eKq!nU)X$GXbp){p=e+a@-l_{|MMZ!}%9DBA z(R*4WJ9~^D7#wL@ODLk-4aPeamLn&m3xCOO+_&&&N2$U!3+ESjl&j~rf5kv#AE;?& z;XX{>Pedr$^$XqRwkbsMdQjR(o!2um><5p|81FQCMQR6417*A+d%Q)IlzQP>J~LlA zp8a1B$VMC0NsLjkOaR!r7K902ApV=66!YHy5K{VFl@_LAskv9^5dL0UJw#y12AbGg zl7*w(0^e&n(`nOsodjvT#%}yM-hqQlPI5{}JRr$%5+$rUUL2@_zzk#LU5@6sS`%dQXyQs-DrjBKtmXHI+AuZhIjNfi?l(YW4Q>m)lH)ks~H$SCz zrgbG>%)^h_(>lXT!Kreo@IpMBL^9bv}E5h$Bu_L%q8<~Tb?1$kI(2ET!_3s?JZu(Q8*&rtpu(I#HP z6Fc!Vnk%85_FEOGIp*{x#p0~64Cu?a)tj;8R2)W)kvw^&gbCP&?DWftxvs>ZPA!Ybyg_E`Ap{jZ znak9K4Rr-ZF7oGIz&!8lXiPg&hL9MJRKaAF>hZ{AggUB;h~=`N6?L~1wkCg&ElxGH zR3rHJIN^tqgSePUsxPwDZQjHeyn(k?Tj7Dn!t`QAvttmf-+G7)9HXnHLZk+_%#&Vc zN5H|p>KNUBvnO>V+Ql#I#x)(VW+VJwKmOO1;3 zgRamc#xK%mjtygt7>j`iX7Y*p)FPP=z?fRsD;ygpJv9hlWRcrk+KnB$f!;CS`SyIj zLRzBTKY+r2xIEi2B^NrjW7R)gqnP*DbY9^9?-C#-U@CUQH7ez(Ns=PaJ&O16xg|#I zIv&0?@{fArcoodGs>rzKB9e?)Ie%5>tR*y^g6BnWq1#k=ZoSz{TCCZGHnhJd-FE+u zRQ>y?ybV0Wwo_B{v*5L4M>}70R~g5NgHz*pn=GkuH1fhYS}OE7fX9E4GRnAW`6#20 zpRWFmSF1`PFEwvIQ93D{ZJyVh2gP;Zi{s}#&| z#pD|K@E#w8&!2a94!k_U?PaYmwYyv@IZR1;Nte<~c%mdfDg^~%yrsgG75Wo2TUCH| z!jn8xmj_U4#sku_Ijx(?-yopdyxupDVGvC6ODjNP`fUWMEsF|5RpEivCn&YST>uEP zGE8P=;Chf)XjF^0G%xfU^RNPm&yt(GRyU>EU~#=giYGDm*5ta(V)9tup)_k*lt06W zzDQ-UM%Cvk%=v|7OkSMo>06Z0J#CT_?fMVugI}bFf1-^)Q^IoMxCb`w0GSwsUa!z>(`ir87oiq1535muBW8zZtj8 z^~!W=kb*(rqQ!fyr}`LwVgh1HYltw|qBpW8Dp+QQhV@O1E;8TximvcQYPv;r`XgW5 zq+8cZCra$Cb@8_?DH6IVeKL2#cdIBTDn&=tMg^!IopPAj_$N7sAP zds>6`PzlRI^&=Jp-z4cmEx;Qsi6*z)S51+5Z&xIB*O z+cxuQ`l`@N+CTN#}v;m@nP6ps_{h9~8F&aM8dsw**}KoRYx6o3?vQ_5c1XHCHz#Ga@^8 z;0E$41nJB_lP~vYg;f+jvEgq5r>J-oYcd_8UDDX_Bxx0O)o$|>Ora8kyhl-!1A$Zg(91IFw@1*3Ykx<^HJ9u_(YKEdw_9Y-Y%E671P5X$9bL)qmwJA!EF z5P_U}NM}?h-cchJH05WV{V*ACkm4{I!?@uXL>-wJ?q&P8EDam6c8qezLa}bCDlJr8J_wD90nBqY7jrc?*n~h@5k0!22{5@F)J6 zfYV47&!@tr_(lbM)t58m_D~=O#MsPQ)Z#X$aR}8aPD2=ts7ZAVGZ{I+(p6>NmKJ8f z5q=6f@TQ=Xqub^uHGCz1kaDy?=x{LQO)0oberl)pmh{8Y=^v`}rRI^6Zi8YuB;^Y` z|DOC@RPiz~+PYweo&JSNZx7wnlMvklFj|wTSnKV!*!f=1%*VV%myxe|POATO)sL3Q z!T}s5RoCapyHv+}!yM|-69y1m!r`eU(RWk$OymFcvSA$j-!1dIx-Tw!{zE}I6?LQB zh)3TG*bBs$8?%2~V0t)Xu|XaMp)AeDW`HfeZj`U~t5&zUQ;sX-sCB6h5e-I3p1?W^ zmDpyU`yr!p;CJAyDExP^ngBBppU7K0^LdEa?4#Z|noTS`s)C1PF~xnx3-4h7Xzuzz zwt0WHxDkE3J;K^_+5;dPjv-U>Xm|}a(zg`W$8B$_>=(0Jmxs{e@+&v>D^}fr25Q-kF^J8g$tc_ z(Vo^87m#osGaF2JJ=Sg-QTu}Fx+A?jcTuIYAkp7Z+Cf=QZ_43_WT|r+frj#8xS9c6 z{dkTlxg;O06y3&7DV{k-)xQbdnB?Mt9BF{qF#W2Z0-&^T*DaIzLJlHWjeya0_5d&9c& zRd5KxAcT4)yxpb5C@E2Qk*8sJY97H1{phC9w~}||X4g8i->donVv>{4lZ1wwRgtFV zt5f(xp!q5K+g0^3^5codw3pO&kU-y&Ke0!o&+UzA5&Q8FBl1r>L%Zq|0QVwuC#0$2 z3I&)=8mQ>dlh`N9@>%L0b4p+7Ebt;M*;rtoF?+FAL>D|N{xPc{rL0aX0Npa^qykY6 z^mG~1-`1<8$cPbZqeZXu^Fqso$;4RMqu`Thl#q=*+8-#=YkMv-9{qFnEcg${#_ zF6SzxJ?Oj2(!*x z{ul;ByvMUqKe6ZB5zQzPyE^+U(v68QMWiKhvH=>6#XHH@vi4ORuV6+tkVKrmhoaV0u zOzsjeF$6#^06>`7p78~d&qsubNgaKLl<@8m-1kxs1;l~mK`={=Bupyo?5b|hkKqbk zFL>t(Qe`d^u24Vu4ZA|8aqT@OhMeG`=+U5!WP7Go=IDN0C|G%_B`G! zdDh#IeUGd9iRMRS-%H(pbs14HGDIt-;4<>#6r3!ORbT_H!1V7JD$HdO`Cg-aqTvo) zBinGX`QSZyu9QV$*N5|1lyOBR?5Fe-IY{qE?gbfZ;|yXws`eLa4~A7;Kq0 zypSi;b&_?D%&A`gG;kcg(&Mr&;Cg`cSCDN(-&A>xcg@?V#X3;~iH85=^Y*yMwa=Bh zPqfZsRnzm6e8T>Ix%2(#w%=#l-_PQ^)lt6bekJVm<0QS2{w8B~N(V{#7b((DS(c*b zK_;tZkBOg=RAiJqb>ky~a zkU-UYc50cEDyJIBx9rrOPO4W@zp_&gb5i}J`V%-vXvEl1z^2acvEn=^+XQXOJEmIB z*_%`h&wV@h6lQ_SPg8QYUG>ZD>?vs{4HnxV{}`#(i89_apqOs~D2Fk>8ENlH+Cpxg z0d|2D*q8%pMnPOxvilPqVG41j!%ASc>9N+zL+ya~8yAIK>&q`-rT#9<3eQqELnNU1 z&QW3?GAgpW-T1s&In~FqW1~^BB#*bd_hTO28!IVC*eT7V$kH{hQE;S=r+>WMeBd`S z7Yog|-a|Vi!lO1-I-YLZ+lX}&!o261AGq@|GT(fHoDGktp)8qCXW(4LJHgFZIBJo5 z3|AGt4iUX=o!W*a@0#2GF4~FV`Q|7o`*cQGOx!@fXHeF>NO~alyCOnYzUgt9rKAWu zCpsAstCXT8m%PBUh{4NB8f~Fqg+IQ!;W_Fxzg$N*L{d zCeVSF&>e}Y?&zt1tCZTox=|i11V8^&^ea-7ju1Xsl#HT@mXg6`o?ybQj=~Z?xSHy! zz{sjR#2nuo7x*3Bb|IEg!!^&JtfxbC9~Sf-hNJhdKk*A1uD(z5sL_f|!wt(JKRv?q z6RSr#X{(;q{A^qO0OnE*SBpTY(IN_=A7f7nhuq6nEs6>h)sxa?ZA-pRACwO3V!9x5 znw>5ajTY>yWs+L%a%Hdo54wJC#85=qh)gKh8JYq^y+AGGHgh}O_a_eZCwxDf9Yl4L zI6}BX^gC#57weh;g{PdlE-kRTI{Z47Wgc0W$*7tt@4n+Wo^i;8rT8`E$9Su#tXf2V z48-3I&d0%LC%NzDY82Zs`D{dwrJ`Q0=`Pnm`C~*+;yrotyRy^QneTI>*jHDv zJF?SbO#6<8S_>D?{NhsAj6foZOvtqq4zC2p($IvG9LAcn;v3OA#<4C7(B;dfG92M9G8aQam1PXMDzJeuyu|7#F^cH4F;3q9-?l`{x zKy0kJWxUdYyQzpLJj^aEV#sTGHQR>DV2`!O`us!W+CDye0(myQlf75)(wecy_SPo~ zd!!GMoZcgnCknVl^GQw>FtFuGz0#*ILI#5`eipH#IbySiE#q{-wE=ed7Wsq^N>ggS zL5};S-J@Q{Z7(uH)XU*zyL|gOq_~z&S77GB4vmFpCGHg^+w{a{1&%kC%!Z+ClheD| zTtaQdT2ph!c!oa4^ixVQsUM~i)NlA~12Af9=!bNn0&5{uh8rs*;iAWAQ|d&o8y+5? zd%ix=vuEkK6}bewuo0^-#p4^EltXx#zd;}M=5(;h(PeQm5X?PmX@!gs$ZB#Gr$T#jkO@m_P}<@L)yp z3S;qUxRdOxFiv=XmNBeJuLC>%#tEO&@4b{bbS?=+_Jdm#Kk zozk2uuy~BU#&%zW#gj=$OCLUwy^&%${Yv^{?+L+b@IY3bP4-A~dJvi~Ec@zwvC!D8 zhR{5Av-&pTcDhi!7GSY=fUfQXfMj`O2K$hUw0fbD%7kjMZzfSsz)TX7)a{oExID=y zviz-$Yzw=^N;sQSx=97Lp+|LPTOk;Z>(y=ob zb!pu8hd?eA5l3hYL%%jKwmX%T*1St*2k_*5n-RTG^c1$Z_$T5Z^M9z^>Ry8SbM(wYp5GzR;mSDG>;ZQ*MRS0U|ib6NH6@WeulMriT39&)Z zwo?HH9ornQ_5hLmz^rQ@1G7XjPwsEy{T!S-c6XLd(y~I-jFmq|?WZE?8BPv2Ijpz% zBKrWpc?0Yj5oWU9oyw7{HABSK?`-78B)L$%+ojE83$00%a`qYb&bM*=71FFhlyLZ2 zikrByJS;K%g@wVZ^s?j1*59%{!9npUPIGPmfcOh0mnN56=W$c+D$0o#+7lQU_c+}%$TIpgk zD^j&R8835cdw-Wxn-y^2h4y3{w|ybCY2MG8uu)!w&F;(VS5pOfc5=94-1fTU(Q8DU zCz*O8nMVAa^F9M>h()L_HRIm*GiY*VJ^O=ODC4YS%i36OV>SG-rGbC9(bxMsQ|W>n zZGUD;cIs~ur>aoY3vwMm-0$?N8w+%c2n`wg&6uU-C$;?Fz*~}rN35;TmcE?Y8n=Jg zLDF{q2;RgC99XXitdIC=&wrBjFH7}ET@T142^i7e(-+?IIsQYo@qLFuu%l!z{p!NTji zyN)QhA=OuC<@T`P*%eNGGT#HT1BH^aO6DXs?)@aKILrKjG(yXxv8kC!g{qS?cPS?a z{6_5~{YAo<&laRRaGd%Hy1~0al4HNhEG9Tqzc$tOk+FrOrda#mQYn+zAg&AaMi&;OYL+1L}`C$%Vp~C98e8+q-lo1M}km|cWEmx-}|4bh>St~YLA0IlHEe(2pNZKI%c47gyKE; zd2ajka97xuVmOyw4T*+kAk&UYKP)^MceH&>#gNS~knOn-~twfm^~C932? ze_4|eE(3e~#ZB?k^}uxa8@qae0Jp>(p}0IXUd(v<}VH%txBfsC#}8U zq`)CWFtmljJCG**5%$5c>r-{8T5>ujx3Ur)*Xk^vdKJf22E>zf+b4~V^vXP?vK1)$ zl&UTb?=;}05INexVj%PN!t-toW;5^NWH78e`a5^YHiRNLPrNF ziNhmdjifn+G^cFEf=B!W%qg@kpi#nK?JdybDcV=Ffv(B*#nd-OUii(#WJ-Nz%1Ba9 zOQ!5eaRFx@k4UDxn^~rmGVWx`rMnYiP2)8Dcq&ip2XYgO|RbmphCj!5dJqpwN z2^rP<$t?Eg*j7GrAVpoT_ej}G3iArRtH*jI9l(H*B=}m}Bk34BNs#>4J(5nbljymc z*duA2og{nsQ9Y6_APIFVDTnt+`ISx)GHIte+1Q19id>3opPYW*sE zDxALGmaa9fQy96}LwrmE@t3Omw}1!N>4klGkv5Hj&H1WxhOO#-KlwkM6^ktX)dF-_m7ODx<8>zzeEw(28u|$8I#K$kv z9|!A?Gx+#@`ePscaV8&of0S&t+PRW8R9B7R>rv^ipV(g+uGmTGuPuCyRQdSmO@Dle zkH(Uy;5`WwQwgEZ4Rya1sFkExbt<7zWoswo`MQp14XF$vW#^GaHptT@ArgdqiJx>O zG~=(nU*~cp|7E98MAnaX*uOtgH6KYWc6$mwQ+%X`P*rG84WOSTRrRsI4oiKF%h&H( zH4sM!Lf-e}>jwL)Kb3cjd|hFG#dFG`l0EYE1^erDu>(`;HrntIU#*!tgeQ35FHN@m zI=2sjIv@YeA#x80u}pSr^hSIuRZ+9E3(4Fp2H#E0hUEJ&9kiCy6rYUi(l#_ ze@UEuJNZ_U5pL}CR0ECMkEe6i76?J_1J85HJ(DUokaBhLnV;(V)gMydALG09LWDm} znMi|vRecS?Hm=Z7=QgYM0)k)26%$D1cW176!dr@4n8(^}l87`3`M`6A#U4#%BTH|x z2*XQnF7?jM4rkGG^R{cV-5woQ6`NEMA4VqoJ0aqG)PFT1ki;42B53=0W?YgtgO+O5no+yyvUJ?z$;u6n-h~_ zD7jtnll8(+Jn(NgT8*G!-R`eGKieO@K398asqe6%&`-8ErtO!uU46`Fye08s5;VQ- z?+7sBf39-||AxE|=u;ig&yzQ?PUe*HRc#+Qh<+)Q8|#~ruEC7=;SAPJ1y5SK15&6CZ8}oFE#cTXls^xk(+YJ#(_2#?H~&Pqi3emADTUifiAvN=^nY zP02XaHJjw0#S)3M-IF*k`$`i#ab96GoEsO$ew%{DW*OCmCl`lSzz!6!RiggAGnGT_ zL8%<6LXL?&p8lx#$ZCS>c2&R=do`5+kar~i{)}V)hGAUpQuUZ~07Ñum?D7+sa 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