diff options
author | Karl Berry <karl@freefriends.org> | 2012-11-20 18:08:54 +0000 |
---|---|---|
committer | Karl Berry <karl@freefriends.org> | 2012-11-20 18:08:54 +0000 |
commit | c5add2ea5067382269ae6f19e345fda0b9a7bd21 (patch) | |
tree | 02f512fda46d93079c9dc59c0d76f0e398150f83 /Master/tlpkg/tlperl/lib/ExtUtils | |
parent | 6c35e87bdc5a3f64833dbbc42e7d42e683db9d5b (diff) |
perl 5.16.2, compiled without optimization for Windows (from siep)
git-svn-id: svn://tug.org/texlive/trunk@28315 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/tlpkg/tlperl/lib/ExtUtils')
59 files changed, 5488 insertions, 2998 deletions
diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder.pm index 969b3596832..aff607d7ee1 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder.pm @@ -6,7 +6,7 @@ use File::Basename (); use Perl::OSType qw/os_type/; use vars qw($VERSION @ISA); -$VERSION = '0.280203'; +$VERSION = '0.280206'; $VERSION = eval $VERSION; # We only use this once - don't waste a symbol table entry on it. @@ -265,10 +265,23 @@ other platform-specific issues. Ilya Zakharevich has contributed fixes for OS/2; John E. Malmberg and Peter Prymmer have done likewise for VMS. +=head1 SUPPORT + +ExtUtils::CBuilder is maintained as part of the Perl 5 core. Please +submit any bug reports via the F<perlbug> tool included with Perl 5. +Bug reports will be included in the Perl 5 ticket system at +L<http://rt.perl.org>. + +The Perl 5 source code is available at <http://perl5.git.perl.org/perl.git> +and ExtUtils-CBuilder may be found in the F<dist/ExtUtils-CBuilder> directory +of the repository. + =head1 AUTHOR Ken Williams, kwilliams@cpan.org +Additional contributions by The Perl 5 Porters. + =head1 COPYRIGHT Copyright (c) 2003-2005 Ken Williams. All rights reserved. diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Base.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Base.pm index b57231272a6..6d983cd2f48 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Base.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Base.pm @@ -12,7 +12,7 @@ use IPC::Cmd qw(can_run); use File::Temp qw(tempfile); use vars qw($VERSION); -$VERSION = '0.280203'; +$VERSION = '0.280206'; # More details about C/C++ compilers: # http://developers.sun.com/sunstudio/documentation/product/compiler.jsp @@ -40,11 +40,13 @@ sub new { $self->{config}{$k} = $v unless exists $self->{config}{$k}; } $self->{config}{cc} = $ENV{CC} if defined $ENV{CC}; - $self->{config}{ccflags} = $ENV{CFLAGS} if defined $ENV{CFLAGS}; + $self->{config}{ccflags} = join(" ", $self->{config}{ccflags}, $ENV{CFLAGS}) + if defined $ENV{CFLAGS}; $self->{config}{cxx} = $ENV{CXX} if defined $ENV{CXX}; $self->{config}{cxxflags} = $ENV{CXXFLAGS} if defined $ENV{CXXFLAGS}; $self->{config}{ld} = $ENV{LD} if defined $ENV{LD}; - $self->{config}{ldflags} = $ENV{LDFLAGS} if defined $ENV{LDFLAGS}; + $self->{config}{ldflags} = join(" ", $self->{config}{ldflags}, $ENV{LDFLAGS}) + if defined $ENV{LDFLAGS}; unless ( exists $self->{config}{cxx} ) { my ($ccpath, $ccbase, $ccsfx ) = fileparse($self->{config}{cc}, qr/\.[^.]*/); @@ -64,7 +66,7 @@ sub new { } unless ( exists $self->{config}{cxx} ) { $self->{config}{cxx} = $self->{config}{cc}; - my $cflags = $self->{config}{cflags}; + my $cflags = $self->{config}{ccflags}; $self->{config}{cxxflags} = '-x c++'; $self->{config}{cxxflags} .= " $cflags" if defined $cflags; } diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Unix.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Unix.pm index c8610b3841c..4bc71939f6e 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Unix.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Unix.pm @@ -4,7 +4,7 @@ use strict; use ExtUtils::CBuilder::Base; use vars qw($VERSION @ISA); -$VERSION = '0.280203'; +$VERSION = '0.280206'; @ISA = qw(ExtUtils::CBuilder::Base); sub link_executable { diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/VMS.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/VMS.pm index 7e3120dc008..47238e8b025 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/VMS.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/VMS.pm @@ -4,7 +4,7 @@ use strict; use ExtUtils::CBuilder::Base; use vars qw($VERSION @ISA); -$VERSION = '0.280203'; +$VERSION = '0.280206'; @ISA = qw(ExtUtils::CBuilder::Base); use File::Spec::Functions qw(catfile catdir); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows.pm index 6e7d52384e5..080f2b4be71 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows.pm @@ -10,7 +10,7 @@ use ExtUtils::CBuilder::Base; use IO::File; use vars qw($VERSION @ISA); -$VERSION = '0.280203'; +$VERSION = '0.280206'; @ISA = qw(ExtUtils::CBuilder::Base); =begin comment diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/BCC.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/BCC.pm index 46938661253..01acec5d530 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/BCC.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/BCC.pm @@ -1,7 +1,7 @@ package ExtUtils::CBuilder::Platform::Windows::BCC; use vars qw($VERSION); -$VERSION = '0.280203'; +$VERSION = '0.280206'; sub format_compiler_cmd { my ($self, %spec) = @_; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/GCC.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/GCC.pm index afeeb7cd838..ccc575fb58f 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/GCC.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/GCC.pm @@ -1,7 +1,7 @@ package ExtUtils::CBuilder::Platform::Windows::GCC; use vars qw($VERSION); -$VERSION = '0.280203'; +$VERSION = '0.280206'; sub format_compiler_cmd { my ($self, %spec) = @_; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/MSVC.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/MSVC.pm index ad0695b5ae0..a847699ea64 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/MSVC.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/Windows/MSVC.pm @@ -1,7 +1,7 @@ package ExtUtils::CBuilder::Platform::Windows::MSVC; use vars qw($VERSION); -$VERSION = '0.280203'; +$VERSION = '0.280206'; sub arg_exec_file { my ($self, $file) = @_; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/aix.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/aix.pm index 358cf8516f8..2ed318b8854 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/aix.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/aix.pm @@ -5,7 +5,7 @@ use ExtUtils::CBuilder::Platform::Unix; use File::Spec; use vars qw($VERSION @ISA); -$VERSION = '0.280203'; +$VERSION = '0.280206'; @ISA = qw(ExtUtils::CBuilder::Platform::Unix); sub need_prelink { 1 } diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/cygwin.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/cygwin.pm index b1069296213..b30497ec8d6 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/cygwin.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/cygwin.pm @@ -5,7 +5,7 @@ use File::Spec; use ExtUtils::CBuilder::Platform::Unix; use vars qw($VERSION @ISA); -$VERSION = '0.280203'; +$VERSION = '0.280206'; @ISA = qw(ExtUtils::CBuilder::Platform::Unix); # TODO: If a specific exe_file name is requested, if the exe created diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/darwin.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/darwin.pm index 3a30e6f333b..62eddd7b014 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/darwin.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/darwin.pm @@ -4,7 +4,7 @@ use strict; use ExtUtils::CBuilder::Platform::Unix; use vars qw($VERSION @ISA); -$VERSION = '0.280203'; +$VERSION = '0.280206'; @ISA = qw(ExtUtils::CBuilder::Platform::Unix); sub compile { diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/dec_osf.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/dec_osf.pm index 5d0a7fd5020..587dbbd097f 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/dec_osf.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/dec_osf.pm @@ -6,7 +6,7 @@ use File::Spec; use vars qw($VERSION @ISA); @ISA = qw(ExtUtils::CBuilder::Platform::Unix); -$VERSION = '0.280203'; +$VERSION = '0.280206'; sub link_executable { my $self = shift; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/os2.pm b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/os2.pm index 828a9571682..531a812e358 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/os2.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/CBuilder/Platform/os2.pm @@ -4,7 +4,7 @@ use strict; use ExtUtils::CBuilder::Platform::Unix; use vars qw($VERSION @ISA); -$VERSION = '0.280203'; +$VERSION = '0.280206'; @ISA = qw(ExtUtils::CBuilder::Platform::Unix); sub need_prelink { 1 } @@ -57,9 +57,9 @@ sub extra_link_args_after_prelink { my ($self, %args) = @_; my @DEF = grep /\.def$/i, @{$args{prelink_res}}; - die "More than one .def files created by `prelink' stage" if @DEF > 1; + die "More than one .def files created by 'prelink' stage" if @DEF > 1; # XXXX No "$how" argument here, so how to test for dynamic link? - die "No .def file created by `prelink' stage" + die "No .def file created by 'prelink' stage" unless @DEF or not @{$args{prelink_res}}; my @after_libs = ($OS2::is_aout ? () diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Command/MM.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Command/MM.pm index 40bf780deab..8d82ee49b12 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Command/MM.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Command/MM.pm @@ -8,9 +8,9 @@ use warnings; require Exporter; our @ISA = qw(Exporter); -our @EXPORT = qw(test_harness pod2man perllocal_install uninstall +our @EXPORT = qw(test_harness pod2man perllocal_install uninstall warn_if_old_packlist); -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; my $Is_VMS = $^O eq 'VMS'; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Install.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Install.pm index 3b030a511af..7e4cd7fade0 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Install.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Install.pm @@ -38,11 +38,11 @@ ExtUtils::Install - install files from here to there =head1 VERSION -1.55 +1.58 =cut -$VERSION = '1.56'; # <---- dont forget to update the POD section just above this line! +$VERSION = '1.58'; # <---- dont forget to update the POD section just above this line! $VERSION = eval $VERSION; =pod @@ -73,10 +73,10 @@ has occured. If this value is defined but false then such an operation has ocurred, but should not impact later operations. -=begin _private - =over +=begin _private + =item _chmod($$;$) Wrapper to chmod() for debugging and error trapping. diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Installed.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Installed.pm index 9cb1fc10d75..b4b7f7580fa 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Installed.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Installed.pm @@ -17,7 +17,7 @@ my $DOSISH = ($^O =~ /^(MSWin\d\d|os2|dos|mint)$/); require VMS::Filespec if $Is_VMS; use vars qw($VERSION); -$VERSION = '1.999_001'; +$VERSION = '1.999002'; $VERSION = eval $VERSION; sub _is_prefix { @@ -162,7 +162,9 @@ sub new { } { my %dupe; - @{$self->{':private:'}{LIBDIRS}} = grep { -e $_ && !$dupe{$_}++ } + @{$self->{':private:'}{LIBDIRS}} = + grep { $_ ne '.' || ! $args{skip_cwd} } + grep { -e $_ && !$dupe{$_}++ } @{$self->{':private:'}{EXTRA}}, @{$self->{':private:'}{INC}}; } @@ -327,7 +329,7 @@ ExtUtils::Installed - Inventory management of installed modules =head1 SYNOPSIS use ExtUtils::Installed; - my ($inst) = ExtUtils::Installed->new(); + my ($inst) = ExtUtils::Installed->new( skip_cwd => 1 ); my (@modules) = $inst->modules(); my (@missing) = $inst->validate("DBI"); my $all_files = $inst->files("DBI"); @@ -369,6 +371,11 @@ information from C<%Config::Config> and the default module search paths C<@INC>. The packlists are read using the L<ExtUtils::Packlist> module. +If the named parameter C<skip_cwd> is true, the current directory C<.> will +be stripped from C<@INC> before searching for .packlists. This keeps +ExtUtils::Installed from finding modules installed in other perls that +happen to be located below the current directory. + If the named parameter C<config_override> is specified, it should be a reference to a hash which contains all information usually found in C<%Config::Config>. For example, you can obtain @@ -376,7 +383,8 @@ the configuration information for a separate perl installation and pass that in. my $yoda_cfg = get_fake_config('yoda'); - my $yoda_inst = ExtUtils::Installed->new(config_override=>$yoda_cfg); + my $yoda_inst = + ExtUtils::Installed->new(config_override=>$yoda_cfg); Similarly, the parameter C<inc_override> may be a reference to an array which is used in place of the default module search paths @@ -389,10 +397,11 @@ from C<@INC>. B<Note>: You probably do not want to use these options alone, almost always you will want to set both together. -The parameter c<extra_libs> can be used to specify B<additional> paths to +The parameter C<extra_libs> can be used to specify B<additional> paths to search for installed modules. For instance - my $installed = ExtUtils::Installed->new(extra_libs=>["/my/lib/path"]); + my $installed = + ExtUtils::Installed->new(extra_libs=>["/my/lib/path"]); This should only be necessary if C</my/lib/path> is not in PERL5LIB. diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Liblist.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Liblist.pm index 2184c4a6d7d..a2ef4268d1d 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Liblist.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Liblist.pm @@ -2,7 +2,7 @@ package ExtUtils::Liblist; use strict; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; use File::Spec; require ExtUtils::Liblist::Kid; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Liblist/Kid.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Liblist/Kid.pm index cf4826fe36f..eddcc72c749 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Liblist/Kid.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Liblist/Kid.pm @@ -6,214 +6,241 @@ package ExtUtils::Liblist::Kid; # $self is not a Makemaker. use 5.006; + # Broken out of MakeMaker from version 4.11 use strict; -our $VERSION = 6.57_05; +use warnings; +our $VERSION = '6.63_02'; -use Config; +use ExtUtils::MakeMaker::Config; use Cwd 'cwd'; use File::Basename; use File::Spec; sub ext { - if ($^O eq 'VMS') { return &_vms_ext; } - elsif($^O eq 'MSWin32') { return &_win32_ext; } - else { return &_unix_os2_ext; } + if ( $^O eq 'VMS' ) { return &_vms_ext; } + elsif ( $^O eq 'MSWin32' ) { return &_win32_ext; } + else { return &_unix_os2_ext; } } sub _unix_os2_ext { - my($self,$potential_libs, $verbose, $give_libs) = @_; + my ( $self, $potential_libs, $verbose, $give_libs ) = @_; $verbose ||= 0; - if ($^O =~ 'os2' and $Config{perllibs}) { - # Dynamic libraries are not transitive, so we may need including - # the libraries linked against perl.dll again. + if ( $^O =~ 'os2' and $Config{perllibs} ) { + + # Dynamic libraries are not transitive, so we may need including + # the libraries linked against perl.dll again. - $potential_libs .= " " if $potential_libs; - $potential_libs .= $Config{perllibs}; + $potential_libs .= " " if $potential_libs; + $potential_libs .= $Config{perllibs}; } - return ("", "", "", "", ($give_libs ? [] : ())) unless $potential_libs; + return ( "", "", "", "", ( $give_libs ? [] : () ) ) unless $potential_libs; warn "Potential libraries are '$potential_libs':\n" if $verbose; - my($so) = $Config{so}; - my($libs) = defined $Config{perllibs} ? $Config{perllibs} : $Config{libs}; + my ( $so ) = $Config{so}; + my ( $libs ) = defined $Config{perllibs} ? $Config{perllibs} : $Config{libs}; my $Config_libext = $Config{lib_ext} || ".a"; my $Config_dlext = $Config{dlext}; - # compute $extralibs, $bsloadlibs and $ldloadlibs from # $potential_libs # this is a rewrite of Andy Dougherty's extliblist in perl - my(@searchpath); # from "-L/path" entries in $potential_libs - my(@libpath) = split " ", $Config{'libpth'}; - my(@ldloadlibs, @bsloadlibs, @extralibs, @ld_run_path, %ld_run_path_seen); - my(@libs, %libs_seen); - my($fullname, @fullname); - my($pwd) = cwd(); # from Cwd.pm - my($found) = 0; - - foreach my $thislib (split ' ', $potential_libs) { - - # Handle possible linker path arguments. - if ($thislib =~ s/^(-[LR]|-Wl,-R)//){ # save path flag type - my($ptype) = $1; - unless (-d $thislib){ - warn "$ptype$thislib ignored, directory does not exist\n" - if $verbose; - next; - } - my($rtype) = $ptype; - if (($ptype eq '-R') or ($ptype eq '-Wl,-R')) { - if ($Config{'lddlflags'} =~ /-Wl,-R/) { - $rtype = '-Wl,-R'; - } elsif ($Config{'lddlflags'} =~ /-R/) { - $rtype = '-R'; - } - } - unless (File::Spec->file_name_is_absolute($thislib)) { - warn "Warning: $ptype$thislib changed to $ptype$pwd/$thislib\n"; - $thislib = $self->catdir($pwd,$thislib); - } - push(@searchpath, $thislib); - push(@extralibs, "$ptype$thislib"); - push(@ldloadlibs, "$rtype$thislib"); - next; - } - - # Handle possible library arguments. - unless ($thislib =~ s/^-l//){ - warn "Unrecognized argument in LIBS ignored: '$thislib'\n"; - next; - } - - my($found_lib)=0; - foreach my $thispth (@searchpath, @libpath) { - - # Try to find the full name of the library. We need this to - # determine whether it's a dynamically-loadable library or not. - # This tends to be subject to various os-specific quirks. - # For gcc-2.6.2 on linux (March 1995), DLD can not load - # .sa libraries, with the exception of libm.sa, so we - # deliberately skip them. - if (@fullname = - $self->lsdir($thispth,"^\Qlib$thislib.$so.\E[0-9]+")){ - # Take care that libfoo.so.10 wins against libfoo.so.9. - # Compare two libraries to find the most recent version - # number. E.g. if you have libfoo.so.9.0.7 and - # libfoo.so.10.1, first convert all digits into two - # decimal places. Then we'll add ".00" to the shorter - # strings so that we're comparing strings of equal length - # Thus we'll compare libfoo.so.09.07.00 with - # libfoo.so.10.01.00. Some libraries might have letters - # in the version. We don't know what they mean, but will - # try to skip them gracefully -- we'll set any letter to - # '0'. Finally, sort in reverse so we can take the - # first element. - - #TODO: iterate through the directory instead of sorting - - $fullname = "$thispth/" . - (sort { my($ma) = $a; - my($mb) = $b; - $ma =~ tr/A-Za-z/0/s; - $ma =~ s/\b(\d)\b/0$1/g; - $mb =~ tr/A-Za-z/0/s; - $mb =~ s/\b(\d)\b/0$1/g; - while (length($ma) < length($mb)) { $ma .= ".00"; } - while (length($mb) < length($ma)) { $mb .= ".00"; } - # Comparison deliberately backwards - $mb cmp $ma;} @fullname)[0]; - } elsif (-f ($fullname="$thispth/lib$thislib.$so") - && (($Config{'dlsrc'} ne "dl_dld.xs") || ($thislib eq "m"))){ - } elsif (-f ($fullname="$thispth/lib${thislib}_s$Config_libext") - && ($Config{'archname'} !~ /RM\d\d\d-svr4/) - && ($thislib .= "_s") ){ # we must explicitly use _s version - } elsif (-f ($fullname="$thispth/lib$thislib$Config_libext")){ - } elsif (defined($Config_dlext) - && -f ($fullname="$thispth/lib$thislib.$Config_dlext")){ - } elsif (-f ($fullname="$thispth/$thislib$Config_libext")){ - } elsif (-f ($fullname="$thispth/lib$thislib.dll$Config_libext")){ - } elsif (-f ($fullname="$thispth/Slib$thislib$Config_libext")){ - } elsif ($^O eq 'dgux' - && -l ($fullname="$thispth/lib$thislib$Config_libext") - && readlink($fullname) =~ /^elink:/s) { - # Some of DG's libraries look like misconnected symbolic - # links, but development tools can follow them. (They - # look like this: - # - # libm.a -> elink:${SDE_PATH:-/usr}/sde/\ - # ${TARGET_BINARY_INTERFACE:-m88kdgux}/usr/lib/libm.a - # - # , the compilation tools expand the environment variables.) - } else { - warn "$thislib not found in $thispth\n" if $verbose; - next; - } - warn "'-l$thislib' found at $fullname\n" if $verbose; - push @libs, $fullname unless $libs_seen{$fullname}++; - $found++; - $found_lib++; - - # Now update library lists - - # what do we know about this library... - my $is_dyna = ($fullname !~ /\Q$Config_libext\E\z/); - my $in_perl = ($libs =~ /\B-l\Q${thislib}\E\b/s); + my ( @searchpath ); # from "-L/path" entries in $potential_libs + my ( @libpath ) = split " ", $Config{'libpth'}; + my ( @ldloadlibs, @bsloadlibs, @extralibs, @ld_run_path, %ld_run_path_seen ); + my ( @libs, %libs_seen ); + my ( $fullname, @fullname ); + my ( $pwd ) = cwd(); # from Cwd.pm + my ( $found ) = 0; + + foreach my $thislib ( split ' ', $potential_libs ) { + + # Handle possible linker path arguments. + if ( $thislib =~ s/^(-[LR]|-Wl,-R)// ) { # save path flag type + my ( $ptype ) = $1; + unless ( -d $thislib ) { + warn "$ptype$thislib ignored, directory does not exist\n" + if $verbose; + next; + } + my ( $rtype ) = $ptype; + if ( ( $ptype eq '-R' ) or ( $ptype eq '-Wl,-R' ) ) { + if ( $Config{'lddlflags'} =~ /-Wl,-R/ ) { + $rtype = '-Wl,-R'; + } + elsif ( $Config{'lddlflags'} =~ /-R/ ) { + $rtype = '-R'; + } + } + unless ( File::Spec->file_name_is_absolute( $thislib ) ) { + warn "Warning: $ptype$thislib changed to $ptype$pwd/$thislib\n"; + $thislib = $self->catdir( $pwd, $thislib ); + } + push( @searchpath, $thislib ); + push( @extralibs, "$ptype$thislib" ); + push( @ldloadlibs, "$rtype$thislib" ); + next; + } + + # Handle possible library arguments. + unless ( $thislib =~ s/^-l// ) { + warn "Unrecognized argument in LIBS ignored: '$thislib'\n"; + next; + } + + my ( $found_lib ) = 0; + foreach my $thispth ( @searchpath, @libpath ) { + + # Try to find the full name of the library. We need this to + # determine whether it's a dynamically-loadable library or not. + # This tends to be subject to various os-specific quirks. + # For gcc-2.6.2 on linux (March 1995), DLD can not load + # .sa libraries, with the exception of libm.sa, so we + # deliberately skip them. + if ( @fullname = $self->lsdir( $thispth, "^\Qlib$thislib.$so.\E[0-9]+" ) ) { + + # Take care that libfoo.so.10 wins against libfoo.so.9. + # Compare two libraries to find the most recent version + # number. E.g. if you have libfoo.so.9.0.7 and + # libfoo.so.10.1, first convert all digits into two + # decimal places. Then we'll add ".00" to the shorter + # strings so that we're comparing strings of equal length + # Thus we'll compare libfoo.so.09.07.00 with + # libfoo.so.10.01.00. Some libraries might have letters + # in the version. We don't know what they mean, but will + # try to skip them gracefully -- we'll set any letter to + # '0'. Finally, sort in reverse so we can take the + # first element. + + #TODO: iterate through the directory instead of sorting + + $fullname = "$thispth/" . ( + sort { + my ( $ma ) = $a; + my ( $mb ) = $b; + $ma =~ tr/A-Za-z/0/s; + $ma =~ s/\b(\d)\b/0$1/g; + $mb =~ tr/A-Za-z/0/s; + $mb =~ s/\b(\d)\b/0$1/g; + while ( length( $ma ) < length( $mb ) ) { $ma .= ".00"; } + while ( length( $mb ) < length( $ma ) ) { $mb .= ".00"; } + + # Comparison deliberately backwards + $mb cmp $ma; + } @fullname + )[0]; + } + elsif ( -f ( $fullname = "$thispth/lib$thislib.$so" ) + && ( ( $Config{'dlsrc'} ne "dl_dld.xs" ) || ( $thislib eq "m" ) ) ) + { + } + elsif (-f ( $fullname = "$thispth/lib${thislib}_s$Config_libext" ) + && ( $Config{'archname'} !~ /RM\d\d\d-svr4/ ) + && ( $thislib .= "_s" ) ) + { # we must explicitly use _s version + } + elsif ( -f ( $fullname = "$thispth/lib$thislib$Config_libext" ) ) { + } + elsif ( defined( $Config_dlext ) + && -f ( $fullname = "$thispth/lib$thislib.$Config_dlext" ) ) + { + } + elsif ( -f ( $fullname = "$thispth/$thislib$Config_libext" ) ) { + } + elsif ( -f ( $fullname = "$thispth/lib$thislib.dll$Config_libext" ) ) { + } + elsif ( -f ( $fullname = "$thispth/Slib$thislib$Config_libext" ) ) { + } + elsif ($^O eq 'dgux' + && -l ( $fullname = "$thispth/lib$thislib$Config_libext" ) + && readlink( $fullname ) =~ /^elink:/s ) + { + + # Some of DG's libraries look like misconnected symbolic + # links, but development tools can follow them. (They + # look like this: + # + # libm.a -> elink:${SDE_PATH:-/usr}/sde/\ + # ${TARGET_BINARY_INTERFACE:-m88kdgux}/usr/lib/libm.a + # + # , the compilation tools expand the environment variables.) + } + else { + warn "$thislib not found in $thispth\n" if $verbose; + next; + } + warn "'-l$thislib' found at $fullname\n" if $verbose; + push @libs, $fullname unless $libs_seen{$fullname}++; + $found++; + $found_lib++; + + # Now update library lists + + # what do we know about this library... + my $is_dyna = ( $fullname !~ /\Q$Config_libext\E\z/ ); + my $in_perl = ( $libs =~ /\B-l\Q${thislib}\E\b/s ); # include the path to the lib once in the dynamic linker path # but only if it is a dynamic lib and not in Perl itself - my($fullnamedir) = dirname($fullname); + my ( $fullnamedir ) = dirname( $fullname ); push @ld_run_path, $fullnamedir - if $is_dyna && !$in_perl && - !$ld_run_path_seen{$fullnamedir}++; - - # Do not add it into the list if it is already linked in - # with the main perl executable. - # We have to special-case the NeXT, because math and ndbm - # are both in libsys_s - unless ($in_perl || - ($Config{'osname'} eq 'next' && - ($thislib eq 'm' || $thislib eq 'ndbm')) ){ - push(@extralibs, "-l$thislib"); - } - - # We might be able to load this archive file dynamically - if ( ($Config{'dlsrc'} =~ /dl_next/ && $Config{'osvers'} lt '4_0') - || ($Config{'dlsrc'} =~ /dl_dld/) ) - { - # We push -l$thislib instead of $fullname because - # it avoids hardwiring a fixed path into the .bs file. - # Mkbootstrap will automatically add dl_findfile() to - # the .bs file if it sees a name in the -l format. - # USE THIS, when dl_findfile() is fixed: - # push(@bsloadlibs, "-l$thislib"); - # OLD USE WAS while checking results against old_extliblist - push(@bsloadlibs, "$fullname"); - } else { - if ($is_dyna){ + if $is_dyna + && !$in_perl + && !$ld_run_path_seen{$fullnamedir}++; + + # Do not add it into the list if it is already linked in + # with the main perl executable. + # We have to special-case the NeXT, because math and ndbm + # are both in libsys_s + unless ( + $in_perl + || ( $Config{'osname'} eq 'next' + && ( $thislib eq 'm' || $thislib eq 'ndbm' ) ) + ) + { + push( @extralibs, "-l$thislib" ); + } + + # We might be able to load this archive file dynamically + if ( ( $Config{'dlsrc'} =~ /dl_next/ && $Config{'osvers'} lt '4_0' ) + || ( $Config{'dlsrc'} =~ /dl_dld/ ) ) + { + + # We push -l$thislib instead of $fullname because + # it avoids hardwiring a fixed path into the .bs file. + # Mkbootstrap will automatically add dl_findfile() to + # the .bs file if it sees a name in the -l format. + # USE THIS, when dl_findfile() is fixed: + # push(@bsloadlibs, "-l$thislib"); + # OLD USE WAS while checking results against old_extliblist + push( @bsloadlibs, "$fullname" ); + } + else { + if ( $is_dyna ) { + # For SunOS4, do not add in this shared library if # it is already linked in the main perl executable - push(@ldloadlibs, "-l$thislib") - unless ($in_perl and $^O eq 'sunos'); - } else { - push(@ldloadlibs, "-l$thislib"); - } - } - last; # found one here so don't bother looking further - } - warn "Note (probably harmless): " - ."No library found for -l$thislib\n" - unless $found_lib>0; + push( @ldloadlibs, "-l$thislib" ) + unless ( $in_perl and $^O eq 'sunos' ); + } + else { + push( @ldloadlibs, "-l$thislib" ); + } + } + last; # found one here so don't bother looking further + } + warn "Note (probably harmless): " . "No library found for -l$thislib\n" + unless $found_lib > 0; } - unless( $found ) { - return ('','','','', ($give_libs ? \@libs : ())); + unless ( $found ) { + return ( '', '', '', '', ( $give_libs ? \@libs : () ) ); } else { - return ("@extralibs", "@bsloadlibs", "@ldloadlibs", - join(":",@ld_run_path), ($give_libs ? \@libs : ())); + return ( "@extralibs", "@bsloadlibs", "@ldloadlibs", join( ":", @ld_run_path ), ( $give_libs ? \@libs : () ) ); } } @@ -221,329 +248,378 @@ sub _win32_ext { require Text::ParseWords; - my($self, $potential_libs, $verbose, $give_libs) = @_; + my ( $self, $potential_libs, $verbose, $give_libs ) = @_; $verbose ||= 0; # If user did not supply a list, we punt. # (caller should probably use the list in $Config{libs}) - return ("", "", "", "", ($give_libs ? [] : ())) unless $potential_libs; - - my $cc = $Config{cc}; - my $VC = $cc =~ /^cl/i; - my $BC = $cc =~ /^bcc/i; - my $GC = $cc =~ /^gcc/i; - my $so = $Config{'so'}; - my $libs = $Config{'perllibs'}; - my $libpth = $Config{'libpth'}; - my $libext = $Config{'lib_ext'} || ".lib"; - my(@libs, %libs_seen); - - if ($libs and $potential_libs !~ /:nodefault/i) { - # If Config.pm defines a set of default libs, we always - # tack them on to the user-supplied list, unless the user - # specified :nodefault - - $potential_libs .= " " if $potential_libs; - $potential_libs .= $libs; - } - warn "Potential libraries are '$potential_libs':\n" if $verbose; + return ( "", "", "", "", ( $give_libs ? [] : () ) ) unless $potential_libs; - # normalize to forward slashes - $libpth =~ s,\\,/,g; - $potential_libs =~ s,\\,/,g; + # TODO: make this use MM_Win32.pm's compiler detection + my %libs_seen; + my @extralibs; + my $cc = $Config{cc} || ''; + my $VC = $cc =~ /\bcl\b/i; + my $GC = $cc =~ /\bgcc\b/i; - # compute $extralibs from $potential_libs + my $libext = _win32_lib_extensions(); + my @searchpath = ( '' ); # from "-L/path" entries in $potential_libs + my @libpath = _win32_default_search_paths( $VC, $GC ); + my $pwd = cwd(); # from Cwd.pm + my $search = 1; - my @searchpath; # from "-L/path" in $potential_libs - my @libpath = Text::ParseWords::quotewords('\s+', 0, $libpth); - my @extralibs; - my $pwd = cwd(); # from Cwd.pm - my $lib = ''; - my $found = 0; - my $search = 1; - my($fullname); + # compute @extralibs from $potential_libs + my @lib_search_list = _win32_make_lib_search_list( $potential_libs, $verbose ); + for ( @lib_search_list ) { - # add "$Config{installarchlib}/CORE" to default search path - push @libpath, "$Config{installarchlib}/CORE"; + my $thislib = $_; - if ($VC and exists $ENV{LIB} and $ENV{LIB}) { - push @libpath, split /;/, $ENV{LIB}; - } + # see if entry is a flag + if ( /^:\w+$/ ) { + $search = 0 if lc eq ':nosearch'; + $search = 1 if lc eq ':search'; + _debug( "Ignoring unknown flag '$thislib'\n", $verbose ) if !/^:(no)?(search|default)$/i; + next; + } + + # if searching is disabled, do compiler-specific translations + unless ( $search ) { + s/^-l(.+)$/$1.lib/ unless $GC; + s/^-L/-libpath:/ if $VC; + push( @extralibs, $_ ); + next; + } - foreach (Text::ParseWords::quotewords('\s+', 0, $potential_libs)){ + # handle possible linker path arguments + if ( s/^-L// and not -d ) { + _debug( "$thislib ignored, directory does not exist\n", $verbose ); + next; + } + elsif ( -d ) { + unless ( File::Spec->file_name_is_absolute( $_ ) ) { + warn "Warning: '$thislib' changed to '-L$pwd/$_'\n"; + $_ = $self->catdir( $pwd, $_ ); + } + push( @searchpath, $_ ); + next; + } - my $thislib = $_; + my @paths = ( @searchpath, @libpath ); + my ( $fullname, $path ) = _win32_search_file( $thislib, $libext, \@paths, $verbose, $GC ); - # see if entry is a flag - if (/^:\w+$/) { - $search = 0 if lc eq ':nosearch'; - $search = 1 if lc eq ':search'; - warn "Ignoring unknown flag '$thislib'\n" - if $verbose and !/^:(no)?(search|default)$/i; - next; - } - - # if searching is disabled, do compiler-specific translations - unless ($search) { - s/^-l(.+)$/$1.lib/ unless $GC; - s/^-L/-libpath:/ if $VC; - push(@extralibs, $_); - $found++; - next; - } - - # handle possible linker path arguments - if (s/^-L// and not -d) { - warn "$thislib ignored, directory does not exist\n" - if $verbose; - next; - } - elsif (-d) { - unless (File::Spec->file_name_is_absolute($_)) { - warn "Warning: '$thislib' changed to '-L$pwd/$_'\n"; - $_ = $self->catdir($pwd,$_); - } - push(@searchpath, $_); - next; - } - - # handle possible library arguments - if (s/^-l// and $GC and !/^lib/i) { - $_ = "lib$_"; - } - $_ .= $libext if !/\Q$libext\E$/i; - - my $secondpass = 0; - LOOKAGAIN: - - # look for the file itself - if (-f) { - warn "'$thislib' found as '$_'\n" if $verbose; - $found++; - push(@extralibs, $_); - next; - } - - my $found_lib = 0; - foreach my $thispth (@searchpath, @libpath){ - unless (-f ($fullname="$thispth\\$_")) { - warn "'$thislib' not found as '$fullname'\n" if $verbose; - next; - } - warn "'$thislib' found as '$fullname'\n" if $verbose; - $found++; - $found_lib++; - push(@extralibs, $fullname); - push @libs, $fullname unless $libs_seen{$fullname}++; - last; - } - - # do another pass with (or without) leading 'lib' if they used -l - if (!$found_lib and $thislib =~ /^-l/ and !$secondpass++) { - if ($GC) { - goto LOOKAGAIN if s/^lib//i; - } - elsif (!/^lib/i) { - $_ = "lib$_"; - goto LOOKAGAIN; - } - } - - # give up - warn "Note (probably harmless): " - ."No library found for $thislib\n" - unless $found_lib>0; + if ( !$fullname ) { + warn "Note (probably harmless): No library found for $thislib\n"; + next; + } + _debug( "'$thislib' found as '$fullname'\n", $verbose ); + push( @extralibs, $fullname ); + $libs_seen{$fullname} = 1 if $path; # why is this a special case? } - return ('','','','', ($give_libs ? \@libs : ())) unless $found; + my @libs = keys %libs_seen; + + return ( '', '', '', '', ( $give_libs ? \@libs : () ) ) unless @extralibs; # make sure paths with spaces are properly quoted - @extralibs = map { (/\s/ && !/^".*"$/) ? qq["$_"] : $_ } @extralibs; - @libs = map { (/\s/ && !/^".*"$/) ? qq["$_"] : $_ } @libs; - $lib = join(' ',@extralibs); + @extralibs = map { /\s/ ? qq["$_"] : $_ } @extralibs; + @libs = map { /\s/ ? qq["$_"] : $_ } @libs; + + my $lib = join( ' ', @extralibs ); # normalize back to backward slashes (to help braindead tools) # XXX this may break equally braindead GNU tools that don't understand # backslashes, either. Seems like one can't win here. Cursed be CP/M. $lib =~ s,/,\\,g; - warn "Result: $lib\n" if $verbose; - wantarray ? ($lib, '', $lib, '', ($give_libs ? \@libs : ())) : $lib; + _debug( "Result: $lib\n", $verbose ); + wantarray ? ( $lib, '', $lib, '', ( $give_libs ? \@libs : () ) ) : $lib; } +sub _win32_make_lib_search_list { + my ( $potential_libs, $verbose ) = @_; -sub _vms_ext { - my($self, $potential_libs, $verbose, $give_libs) = @_; - $verbose ||= 0; - - my(@crtls,$crtlstr); - @crtls = ( ($Config{'ldflags'} =~ m-/Debug-i ? $Config{'dbgprefix'} : '') - . 'PerlShr/Share' ); - push(@crtls, grep { not /\(/ } split /\s+/, $Config{'perllibs'}); - push(@crtls, grep { not /\(/ } split /\s+/, $Config{'libc'}); - # In general, we pass through the basic libraries from %Config unchanged. - # The one exception is that if we're building in the Perl source tree, and - # a library spec could be resolved via a logical name, we go to some trouble - # to insure that the copy in the local tree is used, rather than one to - # which a system-wide logical may point. - if ($self->{PERL_SRC}) { - my($locspec,$type); - foreach my $lib (@crtls) { - if (($locspec,$type) = $lib =~ m{^([\w\$-]+)(/\w+)?} and $locspec =~ /perl/i) { - if (lc $type eq '/share') { $locspec .= $Config{'exe_ext'}; } - elsif (lc $type eq '/library') { $locspec .= $Config{'lib_ext'}; } - else { $locspec .= $Config{'obj_ext'}; } - $locspec = $self->catfile($self->{PERL_SRC},$locspec); - $lib = "$locspec$type" if -e $locspec; - } - } - } - $crtlstr = @crtls ? join(' ',@crtls) : ''; - - unless ($potential_libs) { - warn "Result:\n\tEXTRALIBS: \n\tLDLOADLIBS: $crtlstr\n" if $verbose; - return ('', '', $crtlstr, '', ($give_libs ? [] : ())); - } - - my(%found,@fndlibs,$ldlib); - my $cwd = cwd(); - my($so,$lib_ext,$obj_ext) = @Config{'so','lib_ext','obj_ext'}; - # List of common Unix library names and their VMS equivalents - # (VMS equivalent of '' indicates that the library is automatically - # searched by the linker, and should be skipped here.) - my(@flibs, %libs_seen); - my %libmap = ( 'm' => '', 'f77' => '', 'F77' => '', 'V77' => '', 'c' => '', - 'malloc' => '', 'crypt' => '', 'resolv' => '', 'c_s' => '', - 'socket' => '', 'X11' => 'DECW$XLIBSHR', - 'Xt' => 'DECW$XTSHR', 'Xm' => 'DECW$XMLIBSHR', - 'Xmu' => 'DECW$XMULIBSHR'); - if ($Config{'vms_cc_type'} ne 'decc') { $libmap{'curses'} = 'VAXCCURSE'; } - - warn "Potential libraries are '$potential_libs'\n" if $verbose; - - # First, sort out directories and library names in the input - my(@dirs, @libs); - foreach my $lib (split ' ',$potential_libs) { - push(@dirs,$1), next if $lib =~ /^-L(.*)/; - push(@dirs,$lib), next if $lib =~ /[:>\]]$/; - push(@dirs,$lib), next if -d $lib; - push(@libs,$1), next if $lib =~ /^-l(.*)/; - push(@libs,$lib); - } - push(@dirs,split(' ',$Config{'libpth'})); - - # Now make sure we've got VMS-syntax absolute directory specs - # (We don't, however, check whether someone's hidden a relative - # path in a logical name.) - foreach my $dir (@dirs) { - unless (-d $dir) { - warn "Skipping nonexistent Directory $dir\n" if $verbose > 1; - $dir = ''; - next; - } - warn "Resolving directory $dir\n" if $verbose; - if (File::Spec->file_name_is_absolute($dir)) { - $dir = $self->fixpath($dir,1); - } - else { - $dir = $self->catdir($cwd,$dir); + # If Config.pm defines a set of default libs, we always + # tack them on to the user-supplied list, unless the user + # specified :nodefault + my $libs = $Config{'perllibs'}; + $potential_libs = join( ' ', $potential_libs, $libs ) if $libs and $potential_libs !~ /:nodefault/i; + _debug( "Potential libraries are '$potential_libs':\n", $verbose ); + + $potential_libs =~ s,\\,/,g; # normalize to forward slashes + + my @list = Text::ParseWords::quotewords( '\s+', 0, $potential_libs ); + + return @list; +} + +sub _win32_default_search_paths { + my ( $VC, $GC ) = @_; + + my $libpth = $Config{'libpth'} || ''; + $libpth =~ s,\\,/,g; # normalize to forward slashes + + my @libpath = Text::ParseWords::quotewords( '\s+', 0, $libpth ); + push @libpath, "$Config{installarchlib}/CORE"; # add "$Config{installarchlib}/CORE" to default search path + + push @libpath, split /;/, $ENV{LIB} if $VC and $ENV{LIB}; + push @libpath, split /;/, $ENV{LIBRARY_PATH} if $GC and $ENV{LIBRARY_PATH}; + + return @libpath; +} + +sub _win32_search_file { + my ( $thislib, $libext, $paths, $verbose, $GC ) = @_; + + my @file_list = _win32_build_file_list( $thislib, $GC, $libext ); + + for my $lib_file ( @file_list ) { + for my $path ( @{$paths} ) { + my $fullname = $lib_file; + $fullname = "$path\\$fullname" if $path; + + return ( $fullname, $path ) if -f $fullname; + + _debug( "'$thislib' not found as '$fullname'\n", $verbose ); + } } - } - @dirs = grep { length($_) } @dirs; - unshift(@dirs,''); # Check each $lib without additions first - - LIB: foreach my $lib (@libs) { - if (exists $libmap{$lib}) { - next unless length $libmap{$lib}; - $lib = $libmap{$lib}; + + return; +} + +sub _win32_build_file_list { + my ( $lib, $GC, $extensions ) = @_; + + my @pre_fixed = _win32_build_prefixed_list( $lib, $GC ); + return map _win32_attach_extensions( $_, $extensions ), @pre_fixed; +} + +sub _win32_build_prefixed_list { + my ( $lib, $GC ) = @_; + + return $lib if $lib !~ s/^-l//; + return $lib if $lib =~ /^lib/ and !$GC; + + ( my $no_prefix = $lib ) =~ s/^lib//i; + $lib = "lib$lib" if $no_prefix eq $lib; + + return ( $lib, $no_prefix ) if $GC; + return ( $no_prefix, $lib ); +} + +sub _win32_attach_extensions { + my ( $lib, $extensions ) = @_; + return map _win32_try_attach_extension( $lib, $_ ), @{$extensions}; +} + +sub _win32_try_attach_extension { + my ( $lib, $extension ) = @_; + + return $lib if $lib =~ /\Q$extension\E$/i; + return "$lib$extension"; +} + +sub _win32_lib_extensions { + my %extensions; + $extensions{ $Config{'lib_ext'} } = 1 if $Config{'lib_ext'}; + $extensions{".lib"} = 1; + return [ keys %extensions ]; +} + +sub _debug { + my ( $message, $verbose ) = @_; + return if !$verbose; + warn $message; + return; +} + +sub _vms_ext { + my ( $self, $potential_libs, $verbose, $give_libs ) = @_; + $verbose ||= 0; + + my ( @crtls, $crtlstr ); + @crtls = ( ( $Config{'ldflags'} =~ m-/Debug-i ? $Config{'dbgprefix'} : '' ) . 'PerlShr/Share' ); + push( @crtls, grep { not /\(/ } split /\s+/, $Config{'perllibs'} ); + push( @crtls, grep { not /\(/ } split /\s+/, $Config{'libc'} ); + + # In general, we pass through the basic libraries from %Config unchanged. + # The one exception is that if we're building in the Perl source tree, and + # a library spec could be resolved via a logical name, we go to some trouble + # to insure that the copy in the local tree is used, rather than one to + # which a system-wide logical may point. + if ( $self->{PERL_SRC} ) { + my ( $locspec, $type ); + foreach my $lib ( @crtls ) { + if ( ( $locspec, $type ) = $lib =~ m{^([\w\$-]+)(/\w+)?} and $locspec =~ /perl/i ) { + if ( lc $type eq '/share' ) { $locspec .= $Config{'exe_ext'}; } + elsif ( lc $type eq '/library' ) { $locspec .= $Config{'lib_ext'}; } + else { $locspec .= $Config{'obj_ext'}; } + $locspec = $self->catfile( $self->{PERL_SRC}, $locspec ); + $lib = "$locspec$type" if -e $locspec; + } + } } + $crtlstr = @crtls ? join( ' ', @crtls ) : ''; - my(@variants,$cand); - my($ctype) = ''; + unless ( $potential_libs ) { + warn "Result:\n\tEXTRALIBS: \n\tLDLOADLIBS: $crtlstr\n" if $verbose; + return ( '', '', $crtlstr, '', ( $give_libs ? [] : () ) ); + } - # If we don't have a file type, consider it a possibly abbreviated name and - # check for common variants. We try these first to grab libraries before - # a like-named executable image (e.g. -lperl resolves to perlshr.exe - # before perl.exe). - if ($lib !~ /\.[^:>\]]*$/) { - push(@variants,"${lib}shr","${lib}rtl","${lib}lib"); - push(@variants,"lib$lib") if $lib !~ /[:>\]]/; + my ( %found, @fndlibs, $ldlib ); + my $cwd = cwd(); + my ( $so, $lib_ext, $obj_ext ) = @Config{ 'so', 'lib_ext', 'obj_ext' }; + + # List of common Unix library names and their VMS equivalents + # (VMS equivalent of '' indicates that the library is automatically + # searched by the linker, and should be skipped here.) + my ( @flibs, %libs_seen ); + my %libmap = ( + 'm' => '', + 'f77' => '', + 'F77' => '', + 'V77' => '', + 'c' => '', + 'malloc' => '', + 'crypt' => '', + 'resolv' => '', + 'c_s' => '', + 'socket' => '', + 'X11' => 'DECW$XLIBSHR', + 'Xt' => 'DECW$XTSHR', + 'Xm' => 'DECW$XMLIBSHR', + 'Xmu' => 'DECW$XMULIBSHR' + ); + if ( $Config{'vms_cc_type'} ne 'decc' ) { $libmap{'curses'} = 'VAXCCURSE'; } + + warn "Potential libraries are '$potential_libs'\n" if $verbose; + + # First, sort out directories and library names in the input + my ( @dirs, @libs ); + foreach my $lib ( split ' ', $potential_libs ) { + push( @dirs, $1 ), next if $lib =~ /^-L(.*)/; + push( @dirs, $lib ), next if $lib =~ /[:>\]]$/; + push( @dirs, $lib ), next if -d $lib; + push( @libs, $1 ), next if $lib =~ /^-l(.*)/; + push( @libs, $lib ); } - push(@variants,$lib); - warn "Looking for $lib\n" if $verbose; - foreach my $variant (@variants) { - my($fullname, $name); - - foreach my $dir (@dirs) { - my($type); - - $name = "$dir$variant"; - warn "\tChecking $name\n" if $verbose > 2; - $fullname = VMS::Filespec::rmsexpand($name); - if (defined $fullname and -f $fullname) { - # It's got its own suffix, so we'll have to figure out the type - if ($fullname =~ /(?:$so|exe)$/i) { $type = 'SHR'; } - elsif ($fullname =~ /(?:$lib_ext|olb)$/i) { $type = 'OLB'; } - elsif ($fullname =~ /(?:$obj_ext|obj)$/i) { - warn "Note (probably harmless): " - ."Plain object file $fullname found in library list\n"; - $type = 'OBJ'; - } - else { - warn "Note (probably harmless): " - ."Unknown library type for $fullname; assuming shared\n"; - $type = 'SHR'; - } + push( @dirs, split( ' ', $Config{'libpth'} ) ); + + # Now make sure we've got VMS-syntax absolute directory specs + # (We don't, however, check whether someone's hidden a relative + # path in a logical name.) + foreach my $dir ( @dirs ) { + unless ( -d $dir ) { + warn "Skipping nonexistent Directory $dir\n" if $verbose > 1; + $dir = ''; + next; } - elsif (-f ($fullname = VMS::Filespec::rmsexpand($name,$so)) or - -f ($fullname = VMS::Filespec::rmsexpand($name,'.exe'))) { - $type = 'SHR'; - $name = $fullname unless $fullname =~ /exe;?\d*$/i; + warn "Resolving directory $dir\n" if $verbose; + if ( File::Spec->file_name_is_absolute( $dir ) ) { + $dir = $self->fixpath( $dir, 1 ); } - elsif (not length($ctype) and # If we've got a lib already, - # don't bother - ( -f ($fullname = VMS::Filespec::rmsexpand($name,$lib_ext)) or - -f ($fullname = VMS::Filespec::rmsexpand($name,'.olb')))) { - $type = 'OLB'; - $name = $fullname unless $fullname =~ /olb;?\d*$/i; + else { + $dir = $self->catdir( $cwd, $dir ); } - elsif (not length($ctype) and # If we've got a lib already, - # don't bother - ( -f ($fullname = VMS::Filespec::rmsexpand($name,$obj_ext)) or - -f ($fullname = VMS::Filespec::rmsexpand($name,'.obj')))) { - warn "Note (probably harmless): " - ."Plain object file $fullname found in library list\n"; - $type = 'OBJ'; - $name = $fullname unless $fullname =~ /obj;?\d*$/i; + } + @dirs = grep { length( $_ ) } @dirs; + unshift( @dirs, '' ); # Check each $lib without additions first + + LIB: foreach my $lib ( @libs ) { + if ( exists $libmap{$lib} ) { + next unless length $libmap{$lib}; + $lib = $libmap{$lib}; } - if (defined $type) { - $ctype = $type; $cand = $name; - last if $ctype eq 'SHR'; + + my ( @variants, $cand ); + my ( $ctype ) = ''; + + # If we don't have a file type, consider it a possibly abbreviated name and + # check for common variants. We try these first to grab libraries before + # a like-named executable image (e.g. -lperl resolves to perlshr.exe + # before perl.exe). + if ( $lib !~ /\.[^:>\]]*$/ ) { + push( @variants, "${lib}shr", "${lib}rtl", "${lib}lib" ); + push( @variants, "lib$lib" ) if $lib !~ /[:>\]]/; + } + push( @variants, $lib ); + warn "Looking for $lib\n" if $verbose; + foreach my $variant ( @variants ) { + my ( $fullname, $name ); + + foreach my $dir ( @dirs ) { + my ( $type ); + + $name = "$dir$variant"; + warn "\tChecking $name\n" if $verbose > 2; + $fullname = VMS::Filespec::rmsexpand( $name ); + if ( defined $fullname and -f $fullname ) { + + # It's got its own suffix, so we'll have to figure out the type + if ( $fullname =~ /(?:$so|exe)$/i ) { $type = 'SHR'; } + elsif ( $fullname =~ /(?:$lib_ext|olb)$/i ) { $type = 'OLB'; } + elsif ( $fullname =~ /(?:$obj_ext|obj)$/i ) { + warn "Note (probably harmless): " . "Plain object file $fullname found in library list\n"; + $type = 'OBJ'; + } + else { + warn "Note (probably harmless): " . "Unknown library type for $fullname; assuming shared\n"; + $type = 'SHR'; + } + } + elsif (-f ( $fullname = VMS::Filespec::rmsexpand( $name, $so ) ) + or -f ( $fullname = VMS::Filespec::rmsexpand( $name, '.exe' ) ) ) + { + $type = 'SHR'; + $name = $fullname unless $fullname =~ /exe;?\d*$/i; + } + elsif ( + not length( $ctype ) and # If we've got a lib already, + # don't bother + ( -f ( $fullname = VMS::Filespec::rmsexpand( $name, $lib_ext ) ) or -f ( $fullname = VMS::Filespec::rmsexpand( $name, '.olb' ) ) ) + ) + { + $type = 'OLB'; + $name = $fullname unless $fullname =~ /olb;?\d*$/i; + } + elsif ( + not length( $ctype ) and # If we've got a lib already, + # don't bother + ( -f ( $fullname = VMS::Filespec::rmsexpand( $name, $obj_ext ) ) or -f ( $fullname = VMS::Filespec::rmsexpand( $name, '.obj' ) ) ) + ) + { + warn "Note (probably harmless): " . "Plain object file $fullname found in library list\n"; + $type = 'OBJ'; + $name = $fullname unless $fullname =~ /obj;?\d*$/i; + } + if ( defined $type ) { + $ctype = $type; + $cand = $name; + last if $ctype eq 'SHR'; + } + } + if ( $ctype ) { + + # This has to precede any other CRTLs, so just make it first + if ( $cand eq 'VAXCCURSE' ) { unshift @{ $found{$ctype} }, $cand; } + else { push @{ $found{$ctype} }, $cand; } + warn "\tFound as $cand (really $fullname), type $ctype\n" + if $verbose > 1; + push @flibs, $name unless $libs_seen{$fullname}++; + next LIB; + } } - } - if ($ctype) { - # This has to precede any other CRTLs, so just make it first - if ($cand eq 'VAXCCURSE') { unshift @{$found{$ctype}}, $cand; } - else { push @{$found{$ctype}}, $cand; } - warn "\tFound as $cand (really $fullname), type $ctype\n" - if $verbose > 1; - push @flibs, $name unless $libs_seen{$fullname}++; - next LIB; - } + warn "Note (probably harmless): " . "No library found for $lib\n"; } - warn "Note (probably harmless): " - ."No library found for $lib\n"; - } - - push @fndlibs, @{$found{OBJ}} if exists $found{OBJ}; - push @fndlibs, map { "$_/Library" } @{$found{OLB}} if exists $found{OLB}; - push @fndlibs, map { "$_/Share" } @{$found{SHR}} if exists $found{SHR}; - my $lib = join(' ',@fndlibs); - - $ldlib = $crtlstr ? "$lib $crtlstr" : $lib; - warn "Result:\n\tEXTRALIBS: $lib\n\tLDLOADLIBS: $ldlib\n" if $verbose; - wantarray ? ($lib, '', $ldlib, '', ($give_libs ? \@flibs : ())) : $lib; + + push @fndlibs, @{ $found{OBJ} } if exists $found{OBJ}; + push @fndlibs, map { "$_/Library" } @{ $found{OLB} } if exists $found{OLB}; + push @fndlibs, map { "$_/Share" } @{ $found{SHR} } if exists $found{SHR}; + my $lib = join( ' ', @fndlibs ); + + $ldlib = $crtlstr ? "$lib $crtlstr" : $lib; + warn "Result:\n\tEXTRALIBS: $lib\n\tLDLOADLIBS: $ldlib\n" if $verbose; + wantarray ? ( $lib, '', $ldlib, '', ( $give_libs ? \@flibs : () ) ) : $lib; } 1; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM.pm index 945f24513b7..418eb190dd1 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM.pm @@ -3,7 +3,7 @@ package ExtUtils::MM; use strict; use ExtUtils::MakeMaker::Config; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require ExtUtils::Liblist; require ExtUtils::MakeMaker; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_AIX.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_AIX.pm index 021238523e1..0b0547ff521 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_AIX.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_AIX.pm @@ -1,7 +1,7 @@ package ExtUtils::MM_AIX; use strict; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require ExtUtils::MM_Unix; our @ISA = qw(ExtUtils::MM_Unix); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Any.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Any.pm index a38f2740f7f..fd856129af3 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Any.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Any.pm @@ -1,7 +1,7 @@ package ExtUtils::MM_Any; use strict; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; use Carp; use File::Spec; @@ -206,25 +206,40 @@ sub _expand_macros { my @commands = $MM->echo($text); my @commands = $MM->echo($text, $file); - my @commands = $MM->echo($text, $file, $appending); + my @commands = $MM->echo($text, $file, \%opts); Generates a set of @commands which print the $text to a $file. If $file is not given, output goes to STDOUT. -If $appending is true the $file will be appended to rather than -overwritten. +If $opts{append} is true the $file will be appended to rather than +overwritten. Default is to overwrite. + +If $opts{allow_variables} is true, make variables of the form +C<$(...)> will not be escaped. Other C<$> will. Default is to escape +all C<$>. + +Example of use: + + my $make = map "\t$_\n", $MM->echo($text, $file); =cut sub echo { - my($self, $text, $file, $appending) = @_; - $appending ||= 0; + my($self, $text, $file, $opts) = @_; - my @cmds = map { '$(NOECHO) $(ECHO) '.$self->quote_literal($_) } + # Compatibility with old options + if( !ref $opts ) { + my $append = $opts; + $opts = { append => $append || 0 }; + } + $opts->{allow_variables} = 0 unless defined $opts->{allow_variables}; + + my $ql_opts = { allow_variables => $opts->{allow_variables} }; + my @cmds = map { '$(NOECHO) $(ECHO) '.$self->quote_literal($_, $ql_opts) } split /\n/, $text; if( $file ) { - my $redirect = $appending ? '>>' : '>'; + my $redirect = $opts->{append} ? '>>' : '>'; $cmds[0] .= " $redirect $file"; $_ .= " >> $file" foreach @cmds[1..$#cmds]; } @@ -334,12 +349,54 @@ to include more flexible code and switches. =head3 quote_literal I<Abstract> my $safe_text = $MM->quote_literal($text); + my $safe_text = $MM->quote_literal($text, \%options); This will quote $text so it is interpreted literally in the shell. For example, on Unix this would escape any single-quotes in $text and put single-quotes around the whole thing. +If $options{allow_variables} is true it will leave C<'$(FOO)'> make +variables untouched. If false they will be escaped like any other +C<$>. Defaults to true. + +=head3 escape_dollarsigns + + my $escaped_text = $MM->escape_dollarsigns($text); + +Escapes stray C<$> so they are not interpreted as make variables. + +It lets by C<$(...)>. + +=cut + +sub escape_dollarsigns { + my($self, $text) = @_; + + # Escape dollar signs which are not starting a variable + $text =~ s{\$ (?!\() }{\$\$}gx; + + return $text; +} + + +=head3 escape_all_dollarsigns + + my $escaped_text = $MM->escape_all_dollarsigns($text); + +Escapes all C<$> so they are not interpreted as make variables. + +=cut + +sub escape_all_dollarsigns { + my($self, $text) = @_; + + # Escape dollar signs + $text =~ s{\$}{\$\$}gx; + + return $text; +} + =head3 escape_newlines I<Abstract> @@ -486,8 +543,8 @@ clean :: clean_subdirs split /\s+/, $attribs{FILES} ; } - push(@files, qw[$(MAKE_APERL_FILE) - MYMETA.yml perlmain.c tmon.out mon.out so_locations + push(@files, qw[$(MAKE_APERL_FILE) + MYMETA.json MYMETA.yml perlmain.c tmon.out mon.out so_locations blibdirs.ts pm_to_blib pm_to_blib.ts *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT) $(BOOTSTRAP) $(BASEEXT).bso @@ -728,6 +785,13 @@ CMD return $manify; } +sub _has_cpan_meta { + return eval { + require CPAN::Meta; + CPAN::Meta->VERSION(2.112150); + 1; + }; +} =head3 metafile_target @@ -743,28 +807,111 @@ possible. sub metafile_target { my $self = shift; - - return <<'MAKE_FRAG' if $self->{NO_META}; + return <<'MAKE_FRAG' if $self->{NO_META} or ! _has_cpan_meta(); metafile : $(NOECHO) $(NOOP) MAKE_FRAG - my @metadata = $self->metafile_data( + my %metadata = $self->metafile_data( $self->{META_ADD} || {}, $self->{META_MERGE} || {}, ); - my $meta = $self->metafile_file(@metadata); - my @write_meta = $self->echo($meta, 'META_new.yml'); + + _fix_metadata_before_conversion( \%metadata ); + + # paper over validation issues, but still complain, necessary because + # there's no guarantee that the above will fix ALL errors + my $meta = eval { CPAN::Meta->create( \%metadata, { lazy_validation => 1 } ) }; + warn $@ if $@ and + $@ !~ /encountered CODE.*, but JSON can only represent references to arrays or hashes/; + + # use the original metadata straight if the conversion failed + # or if it can't be stringified. + if( !$meta || + !eval { $meta->as_string( { version => "1.4" } ) } || + !eval { $meta->as_string } + ) + { + $meta = bless \%metadata, 'CPAN::Meta'; + } - return sprintf <<'MAKE_FRAG', join("\n\t", @write_meta); + my @write_metayml = $self->echo( + $meta->as_string({version => "1.4"}), 'META_new.yml' + ); + my @write_metajson = $self->echo( + $meta->as_string(), 'META_new.json' + ); + + my $metayml = join("\n\t", @write_metayml); + my $metajson = join("\n\t", @write_metajson); + return sprintf <<'MAKE_FRAG', $metayml, $metajson; metafile : create_distdir $(NOECHO) $(ECHO) Generating META.yml %s -$(NOECHO) $(MV) META_new.yml $(DISTVNAME)/META.yml + $(NOECHO) $(ECHO) Generating META.json + %s + -$(NOECHO) $(MV) META_new.json $(DISTVNAME)/META.json MAKE_FRAG } +=begin private + +=head3 _fix_metadata_before_conversion + + _fix_metadata_before_conversion( \%metadata ); + +Fixes errors in the metadata before it's handed off to CPAN::Meta for +conversion. This hopefully results in something that can be used further +on, no guarantee is made though. + +=end private + +=cut + +sub _fix_metadata_before_conversion { + my ( $metadata ) = @_; + + # we should never be called unless this already passed but + # prefer to be defensive in case somebody else calls this + + return unless _has_cpan_meta; + + my $bad_version = $metadata->{version} && + !CPAN::Meta::Validator->new->version( 'version', $metadata->{version} ); + + # just delete all invalid versions + if( $bad_version ) { + warn "Can't parse version '$metadata->{version}'\n"; + $metadata->{version} = ''; + } + + my $validator = CPAN::Meta::Validator->new( $metadata ); + return if $validator->is_valid; + + # fix non-camelcase custom resource keys (only other trick we know) + for my $error ( $validator->errors ) { + my ( $key ) = ( $error =~ /Custom resource '(.*)' must be in CamelCase./ ); + next if !$key; + + # first try to remove all non-alphabetic chars + ( my $new_key = $key ) =~ s/[^_a-zA-Z]//g; + + # if that doesn't work, uppercase first one + $new_key = ucfirst $new_key if !$validator->custom_1( $new_key ); + + # copy to new key if that worked + $metadata->{resources}{$new_key} = $metadata->{resources}{$key} + if $validator->custom_1( $new_key ); + + # and delete old one in any case + delete $metadata->{resources}{$key}; + } + + return; +} + =begin private @@ -816,57 +963,16 @@ sub metafile_data { my $self = shift; my($meta_add, $meta_merge) = @_; - # The order in which standard meta keys should be written. - my @meta_order = qw( - name - version - abstract - author - license - distribution_type - - configure_requires - build_requires - requires - - resources - - provides - no_index - - generated_by - meta-spec - ); - - # Check the original args so we can tell between the user setting it - # to an empty hash and it just being initialized. - my $configure_requires; - if( $self->{ARGS}{CONFIGURE_REQUIRES} ) { - $configure_requires = $self->{CONFIGURE_REQUIRES}; - } else { - $configure_requires = { - 'ExtUtils::MakeMaker' => 0, - }; - } - my $build_requires; - if( $self->{ARGS}{BUILD_REQUIRES} ) { - $build_requires = $self->{BUILD_REQUIRES}; - } else { - $build_requires = { - 'ExtUtils::MakeMaker' => 0, - }; - } - my %meta = ( + # required name => $self->{DISTNAME}, - version => $self->{VERSION}, - abstract => $self->{ABSTRACT}, + version => _normalize_version($self->{VERSION}), + abstract => $self->{ABSTRACT} || 'unknown', license => $self->{LICENSE} || 'unknown', - distribution_type => $self->{PM} ? 'module' : 'script', + dynamic_config => 1, - configure_requires => $configure_requires, - - build_requires => $build_requires, + # optional + distribution_type => $self->{PM} ? 'module' : 'script', no_index => { directory => [qw(t inc)] @@ -882,8 +988,18 @@ sub metafile_data { # The author key is required and it takes a list. $meta{author} = defined $self->{AUTHOR} ? $self->{AUTHOR} : []; - $meta{requires} = $self->{PREREQ_PM} if defined $self->{PREREQ_PM}; - $meta{requires}{perl} = $self->{MIN_PERL_VERSION} if $self->{MIN_PERL_VERSION}; + # Check the original args so we can tell between the user setting it + # to an empty hash and it just being initialized. + if( $self->{ARGS}{CONFIGURE_REQUIRES} ) { + $meta{configure_requires} + = _normalize_prereqs($self->{CONFIGURE_REQUIRES}); + } else { + $meta{configure_requires} = { + 'ExtUtils::MakeMaker' => 0, + }; + } + + %meta = $self->_add_requirements_to_meta( %meta ); while( my($key, $val) = each %$meta_add ) { $meta{$key} = $val; @@ -893,24 +1009,62 @@ sub metafile_data { $self->_hash_merge(\%meta, $key, $val); } - my @meta_pairs; + return %meta; +} - # Put the standard keys first in the proper order. - for my $key (@meta_order) { - next unless exists $meta{$key}; - push @meta_pairs, $key, delete $meta{$key}; - } +=begin private + +=cut + +sub _add_requirements_to_meta { + my ( $self, %meta ) = @_; - # Then tack everything else onto the end, alpha sorted. - for my $key (sort {lc $a cmp lc $b} keys %meta) { - push @meta_pairs, $key, $meta{$key}; + # Check the original args so we can tell between the user setting it + # to an empty hash and it just being initialized. + + if( $self->{ARGS}{BUILD_REQUIRES} ) { + $meta{build_requires} = _normalize_prereqs($self->{BUILD_REQUIRES}); + } else { + $meta{build_requires} = { + 'ExtUtils::MakeMaker' => 0, + }; } - return @meta_pairs + $meta{requires} = _normalize_prereqs($self->{PREREQ_PM}) + if defined $self->{PREREQ_PM}; + $meta{requires}{perl} = _normalize_version($self->{MIN_PERL_VERSION}) + if $self->{MIN_PERL_VERSION}; + + return %meta; } -=begin private +sub _normalize_prereqs { + my ($hash) = @_; + my %prereqs; + while ( my ($k,$v) = each %$hash ) { + $prereqs{$k} = _normalize_version($v); + } + return \%prereqs; +} + +# Adapted from Module::Build::Base +sub _normalize_version { + my ($version) = @_; + $version = 0 unless defined $version; + + if ( ref $version eq 'version' ) { # version objects + $version = $version->is_qv ? $version->normal : $version->stringify; + } + elsif ( $version =~ /^[^v][^.]*\.[^.]+\./ ) { # no leading v, multiple dots + # normalize string tuples without "v": "1.2.3" -> "v1.2.3" + $version = "v$version"; + } + else { + # leave alone + } + return $version; +} =head3 _dump_hash @@ -1069,16 +1223,25 @@ distdir. sub distmeta_target { my $self = shift; - my $add_meta = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']); -eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } + my @add_meta = ( + $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']), +exit unless -e q{META.yml}; +eval { maniadd({q{META.yml} => q{Module YAML meta-data (added by MakeMaker)}}) } or print "Could not add META.yml to MANIFEST: $${'@'}\n" CODE + $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']) +exit unless -f q{META.json}; +eval { maniadd({q{META.json} => q{Module JSON meta-data (added by MakeMaker)}}) } + or print "Could not add META.json to MANIFEST: $${'@'}\n" +CODE + ); - my $add_meta_to_distdir = $self->cd('$(DISTVNAME)', $add_meta); + my @add_meta_to_distdir = map { $self->cd('$(DISTVNAME)', $_) } @add_meta; - return sprintf <<'MAKE', $add_meta_to_distdir; + return sprintf <<'MAKE', @add_meta_to_distdir; distmeta : create_distdir metafile $(NOECHO) %s + $(NOECHO) %s MAKE @@ -1096,12 +1259,9 @@ or from internal data. sub mymeta { my $self = shift; + my $file = shift || ''; # for testing - my $mymeta; - - if ( -e 'META.yml' ) { - $mymeta = $self->_mymeta_from_meta(); - } + my $mymeta = $self->_mymeta_from_meta($file); unless ( $mymeta ) { my @metadata = $self->metafile_data( @@ -1111,6 +1271,10 @@ sub mymeta { $mymeta = {@metadata}; } + # Overwrite the non-configure dependency hashes + + $mymeta = { $self->_add_requirements_to_meta( %$mymeta ) }; + $mymeta->{dynamic_config} = 0; return $mymeta; @@ -1119,14 +1283,20 @@ sub mymeta { sub _mymeta_from_meta { my $self = shift; + my $metafile = shift || ''; # for testing + + return unless _has_cpan_meta(); my $meta; - eval { - my @yaml = ExtUtils::MakeMaker::YAML::LoadFile('META.yml'); - $meta = $yaml[0]; - }; + for my $file ( $metafile, "META.json", "META.yml" ) { + next unless -e $file; + eval { + $meta = CPAN::Meta->load_file($file)->as_struct( {version => "1.4"} ); + }; + last if $meta; + } return undef unless $meta; - + # META.yml before 6.25_01 cannot be trusted. META.yml lived in the source directory. # There was a good chance the author accidentally uploaded a stale META.yml if they # rolled their own tarball rather than using "make dist". @@ -1138,20 +1308,9 @@ sub _mymeta_from_meta { } } - # Overwrite the non-configure dependency hashs - delete $meta->{requires}; - delete $meta->{build_requires}; - delete $meta->{recommends}; - if ( exists $self->{PREREQ_PM} ) { - $meta->{requires} = $self->{PREREQ_PM} || {}; - } - if ( exists $self->{BUILD_REQUIRES} ) { - $meta->{build_requires} = $self->{BUILD_REQUIRES} || {}; - } return $meta; } - =head3 write_mymeta $self->write_mymeta( $mymeta ); @@ -1166,18 +1325,19 @@ sub write_mymeta { my $self = shift; my $mymeta = shift; - require ExtUtils::MakeMaker::YAML; - my $mymeta_content = ExtUtils::MakeMaker::YAML::Dump($mymeta); + return unless _has_cpan_meta(); - open(my $myfh, ">", "MYMETA.yml") - or die "Unable to open MYMETA.yml: $!"; - print $myfh $mymeta_content; - close $myfh; - - return; + _fix_metadata_before_conversion( $mymeta ); + + # this can still blow up + # not sure if i should just eval this and skip file creation if it + # blows up + my $meta_obj = CPAN::Meta->new( $mymeta, { lazy_validation => 1 } ); + $meta_obj->save( 'MYMETA.json' ); + $meta_obj->save( 'MYMETA.yml', { version => "1.4" } ); + return 1; } - =head3 realclean (o) Defines the realclean target. @@ -1193,7 +1353,7 @@ sub realclean { # Special exception for the perl core where INST_* is not in blib. # This cleans up the files built from the ext/ directory (all XS). if( $self->{PERL_CORE} ) { - push @dirs, qw($(INST_AUTODIR) $(INST_ARCHAUTODIR)); + push @dirs, qw($(INST_AUTODIR) $(INST_ARCHAUTODIR)); push @files, values %{$self->{PM}}; } @@ -1398,7 +1558,7 @@ sub init_INST { # perl has been built and installed. Setting INST_LIB allows # you to build directly into, say $Config{privlibexp}. unless ($self->{INST_LIB}){ - if ($self->{PERL_CORE}) { + if ($self->{PERL_CORE}) { if (defined $Cross::platform) { $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->catdir($self->{PERL_LIB},"..","xlib", @@ -1407,9 +1567,9 @@ sub init_INST { else { $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB}; } - } else { - $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib"); - } + } else { + $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib"); + } } my @parentdir = split(/::/, $self->{PARENT_NAME}); @@ -1790,15 +1950,14 @@ sub init_VERSION { } -=head3 init_others - - $MM->init_others(); +=head3 init_tools -Initializes the macro definitions used by tools_other() and places them -in the $MM object. + $MM->init_tools(); -If there is no description, its the same as the parameter to -WriteMakefile() documented in ExtUtils::MakeMaker. +Initializes the simple macro definitions used by tools_other() and +places them in the $MM object. These use conservative cross platform +versions and should be overridden with platform specific versions for +performance. Defines at least these macros. @@ -1807,11 +1966,6 @@ Defines at least these macros. NOOP Do nothing NOECHO Tell make not to display the command itself - MAKEFILE - FIRST_MAKEFILE - MAKEFILE_OLD - MAKE_APERL_FILE File used by MAKE_APERL - SHELL Program used to run shell commands ECHO Print text adding a newline on the end @@ -1830,7 +1984,7 @@ Defines at least these macros. =cut -sub init_others { +sub init_tools { my $self = shift; $self->{ECHO} ||= $self->oneliner('print qq{@ARGV}', ['-l']); @@ -1863,6 +2017,18 @@ CODE $self->{UNINST} ||= 0; $self->{VERBINST} ||= 0; + $self->{SHELL} ||= $Config{sh}; + + # UMASK_NULL is not used by MakeMaker but some CPAN modules + # make use of it. + $self->{UMASK_NULL} ||= "umask 0"; + + # Not the greatest default, but its something. + $self->{DEV_NULL} ||= "> /dev/null 2>&1"; + + $self->{NOOP} ||= '$(TRUE)'; + $self->{NOECHO} = '@' unless defined $self->{NOECHO}; + $self->{FIRST_MAKEFILE} ||= $self->{MAKEFILE} || 'Makefile'; $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE}; $self->{MAKEFILE_OLD} ||= $self->{MAKEFILE}.'.old'; @@ -1876,17 +2042,24 @@ CODE $self->{MACROSTART} ||= ''; $self->{MACROEND} ||= ''; - $self->{SHELL} ||= $Config{sh}; + return; +} - # UMASK_NULL is not used by MakeMaker but some CPAN modules - # make use of it. - $self->{UMASK_NULL} ||= "umask 0"; - # Not the greatest default, but its something. - $self->{DEV_NULL} ||= "> /dev/null 2>&1"; +=head3 init_others - $self->{NOOP} ||= '$(TRUE)'; - $self->{NOECHO} = '@' unless defined $self->{NOECHO}; + $MM->init_others(); + +Initializes the macro definitions having to do with compiling and +linking used by tools_other() and places them in the $MM object. + +If there is no description, its the same as the parameter to +WriteMakefile() documented in ExtUtils::MakeMaker. + +=cut + +sub init_others { + my $self = shift; $self->{LD_RUN_PATH} = ""; @@ -1927,7 +2100,7 @@ CODE : ($Config{usedl} ? 'dynamic' : 'static'); } - return 1; + return; } diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_BeOS.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_BeOS.pm index 0eeb795e485..a31cf2320c3 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_BeOS.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_BeOS.pm @@ -26,7 +26,7 @@ require ExtUtils::MM_Any; require ExtUtils::MM_Unix; our @ISA = qw( ExtUtils::MM_Any ExtUtils::MM_Unix ); -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; =item os_flavor diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Cygwin.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Cygwin.pm index d6ce3a7d68c..de6f13085ee 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Cygwin.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Cygwin.pm @@ -9,7 +9,7 @@ require ExtUtils::MM_Unix; require ExtUtils::MM_Win32; our @ISA = qw( ExtUtils::MM_Unix ); -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; =head1 NAME diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_DOS.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_DOS.pm index 68612a80acd..d902038412b 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_DOS.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_DOS.pm @@ -2,7 +2,7 @@ package ExtUtils::MM_DOS; use strict; -our $VERSION = 6.57_05; +our $VERSION = '6.63_02'; require ExtUtils::MM_Any; require ExtUtils::MM_Unix; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Darwin.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Darwin.pm index 20aeb791642..6d78157fe5f 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Darwin.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Darwin.pm @@ -7,7 +7,7 @@ BEGIN { our @ISA = qw( ExtUtils::MM_Unix ); } -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; =head1 NAME diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_MacOS.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_MacOS.pm index 4dcb6e55ec0..17bcde790e4 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_MacOS.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_MacOS.pm @@ -2,7 +2,7 @@ package ExtUtils::MM_MacOS; use strict; -our $VERSION = 6.57_05; +our $VERSION = '6.63_02'; sub new { die <<'UNSUPPORTED'; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_NW5.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_NW5.pm index 2089e8f88c2..be1e1555576 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_NW5.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_NW5.pm @@ -22,7 +22,7 @@ use strict; use ExtUtils::MakeMaker::Config; use File::Basename; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require ExtUtils::MM_Win32; our @ISA = qw(ExtUtils::MM_Win32); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_OS2.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_OS2.pm index 46d57be2933..f4ebd1e738e 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_OS2.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_OS2.pm @@ -5,7 +5,7 @@ use strict; use ExtUtils::MakeMaker qw(neatvalue); use File::Spec; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require ExtUtils::MM_Any; require ExtUtils::MM_Unix; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_QNX.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_QNX.pm index 5efd3771f39..9d1f29223d0 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_QNX.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_QNX.pm @@ -1,7 +1,7 @@ package ExtUtils::MM_QNX; use strict; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require ExtUtils::MM_Unix; our @ISA = qw(ExtUtils::MM_Unix); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_UWIN.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_UWIN.pm index 032bf35b84b..d4b9370bd1a 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_UWIN.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_UWIN.pm @@ -1,7 +1,7 @@ package ExtUtils::MM_UWIN; use strict; -our $VERSION = 6.57_05; +our $VERSION = '6.63_02'; require ExtUtils::MM_Unix; our @ISA = qw(ExtUtils::MM_Unix); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Unix.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Unix.pm index 6964eea0883..b537393d3e1 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Unix.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Unix.pm @@ -15,7 +15,8 @@ use ExtUtils::MakeMaker qw($Verbose neatvalue); # If we make $VERSION an our variable parse_version() breaks use vars qw($VERSION); -$VERSION = '6.57_05'; +$VERSION = '6.63_02'; +$VERSION = eval $VERSION; require ExtUtils::MM_Any; our @ISA = qw(ExtUtils::MM_Any); @@ -1738,17 +1739,14 @@ EOP $self->{NAME} eq "ExtUtils::MakeMaker"; } -=item init_others +=item init_tools -Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH, LD, -OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, SHELL, NOOP, -FIRST_MAKEFILE, MAKEFILE_OLD, NOECHO, RM_F, RM_RF, TEST_F, -TOUCH, CP, MV, CHMOD, UMASK_NULL, ECHO, ECHO_N +Initializes tools to use their common (and faster) Unix commands. =cut -sub init_others { # --- Initialize Other Attributes - my($self) = shift; +sub init_tools { + my $self = shift; $self->{ECHO} ||= 'echo'; $self->{ECHO_N} ||= 'echo -n'; @@ -1764,13 +1762,13 @@ sub init_others { # --- Initialize Other Attributes $self->{LD} ||= 'ld'; - $self->SUPER::init_others(@_); + return $self->SUPER::init_tools(@_); - # After SUPER::init_others so $Config{shell} has a + # After SUPER::init_tools so $Config{shell} has a # chance to get set. $self->{SHELL} ||= '/bin/sh'; - return 1; + return; } @@ -2894,8 +2892,13 @@ sub ppd { $author =~ s/</</g; $author =~ s/>/>/g; - my $ppd_xml = sprintf <<'PPD_HTML', $self->{VERSION}, $abstract, $author; -<SOFTPKG NAME="$(DISTNAME)" VERSION="%s"> + my $ppd_file = '$(DISTNAME).ppd'; + + my @ppd_cmds = $self->echo(<<'PPD_HTML', $ppd_file, { append => 0, allow_variables => 1 }); +<SOFTPKG NAME="$(DISTNAME)" VERSION="$(VERSION)"> +PPD_HTML + + my $ppd_xml = sprintf <<'PPD_HTML', $abstract, $author; <ABSTRACT>%s</ABSTRACT> <AUTHOR>%s</AUTHOR> PPD_HTML @@ -2957,7 +2960,7 @@ PPD_OUT </SOFTPKG> PPD_XML - my @ppd_cmds = $self->echo($ppd_xml, '$(DISTNAME).ppd'); + push @ppd_cmds, $self->echo($ppd_xml, $ppd_file, { append => 1 }); return sprintf <<'PPD_OUT', join "\n\t", @ppd_cmds; # Creates a PPD (Perl Package Description) for a binary distribution. @@ -3148,12 +3151,15 @@ sub oneliner { =cut sub quote_literal { - my($self, $text) = @_; + my($self, $text, $opts) = @_; + $opts->{allow_variables} = 1 unless defined $opts->{allow_variables}; - # I think all we have to quote is single quotes and I think - # this is a safe way to do it. + # Quote single quotes $text =~ s{'}{'\\''}g; + $text = $opts->{allow_variables} + ? $self->escape_dollarsigns($text) : $self->escape_all_dollarsigns($text); + return "'$text'"; } diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_VMS.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_VMS.pm index d6b63eba63f..c204abcb2d1 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_VMS.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_VMS.pm @@ -15,7 +15,7 @@ BEGIN { use File::Basename; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require ExtUtils::MM_Any; require ExtUtils::MM_Unix; @@ -447,21 +447,20 @@ sub init_main { } } -=item init_others (override) +=item init_tools (override) -Provide VMS-specific forms of various utility commands, then hand -off to the default MM_Unix method. +Provide VMS-specific forms of various utility commands. -DEV_NULL should probably be overriden with something. +Sets DEV_NULL to nothing because I don't know how to do it on VMS. -Also changes EQUALIZE_TIMESTAMP to set revision date of target file to +Changes EQUALIZE_TIMESTAMP to set revision date of target file to one second later than source file, since MMK interprets precisely equal revision dates for a source and target file as a sign that the target needs to be updated. =cut -sub init_others { +sub init_tools { my($self) = @_; $self->{NOOP} = 'Continue'; @@ -493,17 +492,34 @@ sub init_others { install([ from_to => {split(' ', <STDIN>)}, verbose => '$(VERBINST)', uninstall_shadows => '$(UNINST)', dir_mode => '$(PERM_DIR)' ]); CODE - $self->SUPER::init_others; + $self->{UMASK_NULL} = '! '; - $self->{SHELL} ||= 'Posix'; + $self->SUPER::init_tools; - $self->{UMASK_NULL} = '! '; + # Use the default shell + $self->{SHELL} ||= 'Posix'; # Redirection on VMS goes before the command, not after as on Unix. # $(DEV_NULL) is used once and its not worth going nuts over making # it work. However, Unix's DEV_NULL is quite wrong for VMS. $self->{DEV_NULL} = ''; + return; +} + + +=item init_others (override) + +Provide VMS-specific forms of various compile and link commands + +=cut + +sub init_others { + my $self = shift; + + # Must come first as we're modifying and deriving from the defaults. + $self->SUPER::init_others; + if ($self->{OBJECT} =~ /\s/) { $self->{OBJECT} =~ s/(\\)?\n+\s+/ /g; $self->{OBJECT} = $self->wraplist( @@ -514,6 +530,8 @@ CODE $self->{LDFROM} = $self->wraplist( map $self->fixpath($_,0), split /,?\s+/, $self->{LDFROM} ); + + return; } @@ -1753,13 +1771,21 @@ native Write command instead. Besides, its faster. =cut sub echo { - my($self, $text, $file, $appending) = @_; - $appending ||= 0; + my($self, $text, $file, $opts) = @_; + + # Compatibility with old options + if( !ref $opts ) { + my $append = $opts; + $opts = { append => $append || 0 }; + } + my $opencmd = $opts->{append} ? 'Open/Append' : 'Open/Write'; + + $opts->{allow_variables} = 0 unless defined $opts->{allow_variables}; - my $opencmd = $appending ? 'Open/Append' : 'Open/Write'; + my $ql_opts = { allow_variables => $opts->{allow_variables} }; my @cmds = ("\$(NOECHO) $opencmd MMECHOFILE $file "); - push @cmds, map { '$(NOECHO) Write MMECHOFILE '.$self->quote_literal($_) } + push @cmds, map { '$(NOECHO) Write MMECHOFILE '.$self->quote_literal($_, $ql_opts) } split /\n/, $text; push @cmds, '$(NOECHO) Close MMECHOFILE'; return @cmds; @@ -1771,14 +1797,49 @@ sub echo { =cut sub quote_literal { - my($self, $text) = @_; + my($self, $text, $opts) = @_; + $opts->{allow_variables} = 1 unless defined $opts->{allow_variables}; # I believe this is all we should need. $text =~ s{"}{""}g; + $text = $opts->{allow_variables} + ? $self->escape_dollarsigns($text) : $self->escape_all_dollarsigns($text); + return qq{"$text"}; } +=item escape_dollarsigns + +Quote, don't escape. + +=cut + +sub escape_dollarsigns { + my($self, $text) = @_; + + # Quote dollar signs which are not starting a variable + $text =~ s{\$ (?!\() }{"\$"}gx; + + return $text; +} + + +=item escape_all_dollarsigns + +Quote, don't escape. + +=cut + +sub escape_all_dollarsigns { + my($self, $text) = @_; + + # Quote dollar signs + $text =~ s{\$}{"\$\"}gx; + + return $text; +} + =item escape_newlines =cut diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_VOS.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_VOS.pm index e5b60d78e38..cdc6659b7f5 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_VOS.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_VOS.pm @@ -1,7 +1,7 @@ package ExtUtils::MM_VOS; use strict; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require ExtUtils::MM_Unix; our @ISA = qw(ExtUtils::MM_Unix); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Win32.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Win32.pm index faaf219ecba..43ae9a4dd5f 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Win32.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Win32.pm @@ -27,13 +27,21 @@ use ExtUtils::MakeMaker qw( neatvalue ); require ExtUtils::MM_Any; require ExtUtils::MM_Unix; our @ISA = qw( ExtUtils::MM_Any ExtUtils::MM_Unix ); -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; $ENV{EMXSHELL} = 'sh'; # to run `commands` -my $BORLAND = $Config{'cc'} =~ /^bcc/i ? 1 : 0; -my $GCC = $Config{'cc'} =~ /\bgcc$/i ? 1 : 0; -my $DLLTOOL = $Config{'dlltool'} || 'dlltool'; +my ( $BORLAND, $GCC, $DLLTOOL ) = _identify_compiler_environment( \%Config ); + +sub _identify_compiler_environment { + my ( $config ) = @_; + + my $BORLAND = $config->{cc} =~ /^bcc/i ? 1 : 0; + my $GCC = $config->{cc} =~ /\bgcc\b/i ? 1 : 0; + my $DLLTOOL = $config->{dlltool} || 'dlltool'; + + return ( $BORLAND, $GCC, $DLLTOOL ); +} =head2 Overridden methods @@ -133,21 +141,13 @@ sub init_DIRFILESEP { : '\\'; } -=item B<init_others> +=item init_tools -Override some of the Unix specific commands with portable -ExtUtils::Command ones. - -Also provide defaults for LD and AR in case the %Config values aren't -set. - -LDLOADLIBS's default is changed to $Config{libs}. - -Adjustments are made for Borland's quirks needing -L to come first. +Override some of the slower, portable commands with Windows specific ones. =cut -sub init_others { +sub init_tools { my ($self) = @_; $self->{NOOP} ||= 'rem'; @@ -157,14 +157,33 @@ sub init_others { "\$(PERLRUN) $self->{PERL_SRC}/win32/bin/pl2bat.pl" : 'pl2bat.bat'; + $self->SUPER::init_tools; + + # Setting SHELL from $Config{sh} can break dmake. Its ok without it. + delete $self->{SHELL}; + + return; +} + + +=item init_others + +Override the default link and compile tools. + +LDLOADLIBS's default is changed to $Config{libs}. + +Adjustments are made for Borland's quirks needing -L to come first. + +=cut + +sub init_others { + my $self = shift; + $self->{LD} ||= 'link'; $self->{AR} ||= 'lib'; $self->SUPER::init_others; - # Setting SHELL from $Config{sh} can break dmake. Its ok without it. - delete $self->{SHELL}; - $self->{LDLOADLIBS} ||= $Config{libs}; # -Lfoo must come first for Borland, so we put it in LDDLFLAGS if ($BORLAND) { @@ -179,7 +198,7 @@ sub init_others { $self->{LDDLFLAGS} .= " $libpath"; } - return 1; + return; } @@ -195,6 +214,8 @@ sub init_platform { my($self) = shift; $self->{MM_Win32_VERSION} = $VERSION; + + return; } sub platform_constants { @@ -211,6 +232,36 @@ sub platform_constants { } +=item constants + +Add MAXLINELENGTH for dmake before all the constants are output. + +=cut + +sub constants { + my $self = shift; + + my $make_text = $self->SUPER::constants; + return $make_text unless $self->is_make_type('dmake'); + + # dmake won't read any single "line" (even those with escaped newlines) + # larger than a certain size which can be as small as 8k. PM_TO_BLIB + # on large modules like DateTime::TimeZone can create lines over 32k. + # So we'll crank it up to a <ironic>WHOPPING</ironic> 64k. + # + # This has to come here before all the constants and not in + # platform_constants which is after constants. + my $size = $self->{MAXLINELENGTH} || 64 * 1024; + my $prefix = qq{ +# Get dmake to read long commands like PM_TO_BLIB +MAXLINELENGTH = $size + +}; + + return $prefix . $make_text; +} + + =item special_targets Add .USESHELL target for dmake. @@ -445,22 +496,34 @@ sub oneliner { sub quote_literal { - my($self, $text) = @_; - - # I don't know if this is correct, but it seems to work on - # Win98's command.com - $text =~ s{"}{\\"}g; - - # dmake eats '{' inside double quotes and leaves alone { outside double - # quotes; however it transforms {{ into { either inside and outside double - # quotes. It also translates }} into }. The escaping below is not - # 100% correct. + my($self, $text, $opts) = @_; + $opts->{allow_variables} = 1 unless defined $opts->{allow_variables}; + + # See: http://www.autohotkey.net/~deleyd/parameters/parameters.htm#CPP + + # Apply the Microsoft C/C++ parsing rules + $text =~ s{\\\\"}{\\\\\\\\\\"}g; # \\" -> \\\\\" + $text =~ s{(?<!\\)\\"}{\\\\\\"}g; # \" -> \\\" + $text =~ s{(?<!\\)"}{\\"}g; # " -> \" + $text = qq{"$text"} if $text =~ /[ \t]/; + + # Apply the Command Prompt parsing rules (cmd.exe) + my @text = split /("[^"]*")/, $text; + # We should also escape parentheses, but it breaks one-liners containing + # $(MACRO)s in makefiles. + s{([<>|&^@!])}{^$1}g foreach grep { !/^"[^"]*"$/ } @text; + $text = join('', @text); + + # dmake expands {{ to { and }} to }. if( $self->is_make_type('dmake') ) { $text =~ s/{/{{/g; - $text =~ s/}}/}}}/g; + $text =~ s/}/}}/g; } - return qq{"$text"}; + $text = $opts->{allow_variables} + ? $self->escape_dollarsigns($text) : $self->escape_all_dollarsigns($text); + + return $text; } diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Win95.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Win95.pm index 19f5c7d61ed..694655c1baf 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MM_Win95.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MM_Win95.pm @@ -2,7 +2,7 @@ package ExtUtils::MM_Win95; use strict; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require ExtUtils::MM_Win32; our @ISA = qw(ExtUtils::MM_Win32); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MY.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MY.pm index 464f814f0f7..92d4da0a4b9 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MY.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MY.pm @@ -3,7 +3,7 @@ package ExtUtils::MY; use strict; require ExtUtils::MM; -our $VERSION = 6.57_05; +our $VERSION = '6.63_02'; our @ISA = qw(ExtUtils::MM); { diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker.pm index be9624e389e..3885ab00f1b 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker.pm @@ -7,7 +7,7 @@ BEGIN {require 5.006;} require Exporter; use ExtUtils::MakeMaker::Config; -use Carp (); +use Carp; use File::Path; our $Verbose = 0; # exported @@ -18,7 +18,8 @@ our @Overridable; my @Prepend_parent; my %Recognized_Att_Keys; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; +$VERSION = eval $VERSION; # Emulate something resembling CVS $Revision$ (our $Revision = $VERSION) =~ s{_}{}; @@ -47,13 +48,13 @@ require ExtUtils::MY; # XXX pre-5.8 versions of ExtUtils::Embed expect sub WriteMakefile { - Carp::croak "WriteMakefile: Need even number of args" if @_ % 2; + croak "WriteMakefile: Need even number of args" if @_ % 2; require ExtUtils::MY; my %att = @_; _convert_compat_attrs(\%att); - + _verify_att(\%att); my $mm = MM->new(\%att); @@ -114,7 +115,7 @@ my %Special_Sigs = ( @Att_Sigs{keys %Recognized_Att_Keys} = ('') x keys %Recognized_Att_Keys; @Att_Sigs{keys %Special_Sigs} = values %Special_Sigs; -sub _convert_compat_attrs { +sub _convert_compat_attrs { #result of running several times should be same my($att) = @_; if (exists $att->{AUTHOR}) { if ($att->{AUTHOR}) { @@ -176,7 +177,7 @@ sub _format_att { sub prompt ($;$) { ## no critic my($mess, $def) = @_; - Carp::confess("prompt function called without an argument") + confess("prompt function called without an argument") unless defined $mess; my $isa_tty = -t STDIN && (-t STDOUT || !(-f STDOUT || -c STDOUT)) ; @@ -224,7 +225,7 @@ sub eval_in_subdirs { sub eval_in_x { my($self,$dir) = @_; - chdir $dir or Carp::carp("Couldn't change to directory $dir: $!"); + chdir $dir or carp("Couldn't change to directory $dir: $!"); { package main; @@ -401,6 +402,8 @@ sub new { my($class,$self) = @_; my($key); + _convert_compat_attrs($self) if defined $self && $self; + # Store the original args passed to WriteMakefile() foreach my $k (keys %$self) { $self->{ARGS}{$k} = $self->{$k}; @@ -408,13 +411,17 @@ sub new { $self = {} unless defined $self; - $self->{PREREQ_PM} ||= {}; - $self->{BUILD_REQUIRES} ||= {}; - # Temporarily bless it into MM so it can be used as an # object. It will be blessed into a temp package later. bless $self, "MM"; + # Cleanup all the module requirement bits + for my $key (qw(PREREQ_PM BUILD_REQUIRES CONFIGURE_REQUIRES)) { + $self->{$key} ||= {}; + $self->clean_versions( $key ); + } + + if ("@ARGV" =~ /\bPREREQ_PRINT\b/) { $self->_PREREQ_PRINT; } @@ -446,7 +453,7 @@ sub new { }; if (!$perl_version_ok) { if (!defined $perl_version_ok) { - warn <<'END'; + die <<'END'; Warning: MIN_PERL_VERSION is not in a recognized format. Recommended is a quoted numerical value like '5.005' or '5.008001'. END @@ -515,13 +522,13 @@ END _convert_compat_attrs(\%configure_att); $self = { %$self, %configure_att }; } else { - Carp::croak "Attribute 'CONFIGURE' to WriteMakefile() not a code reference\n"; + croak "Attribute 'CONFIGURE' to WriteMakefile() not a code reference\n"; } } # This is for old Makefiles written pre 5.00, will go away if ( Carp::longmess("") =~ /runsubdirpl/s ){ - Carp::carp("WARNING: Please rerun 'perl Makefile.PL' to regenerate your Makefiles\n"); + carp("WARNING: Please rerun 'perl Makefile.PL' to regenerate your Makefiles\n"); } my $newclass = ++$PACKNAME; @@ -606,6 +613,7 @@ END $self->catfile($Config{'archlibexp'}, "Config.pm") ); + $self->init_tools(); $self->init_others(); $self->init_platform(); $self->init_PERM(); @@ -692,11 +700,11 @@ END } sub WriteEmptyMakefile { - Carp::croak "WriteEmptyMakefile: Need an even number of args" if @_ % 2; + croak "WriteEmptyMakefile: Need an even number of args" if @_ % 2; my %att = @_; my $self = MM->new(\%att); - + my $new = $self->{MAKEFILE}; my $old = $self->{MAKEFILE_OLD}; if (-f $old) { @@ -1029,9 +1037,10 @@ sub flush { unless ($self->{NO_MYMETA}) { # Write MYMETA.yml to communicate metadata up to the CPAN clients - print STDOUT "Writing MYMETA.yml\n"; + if ( $self->write_mymeta( $self->mymeta ) ) {; + print STDOUT "Writing MYMETA.yml and MYMETA.json\n"; + } - $self->write_mymeta( $self->mymeta ); } my %keep = map { ($_ => 1) } qw(NEEDS_LINKING HAS_LINK_CODE); if ($self->{PARENT} && !$self->{_KEEP_AFTER_FLUSH}) { @@ -1103,6 +1112,22 @@ sub neatvalue { return "{ ".join(', ',@m)." }"; } +# Look for weird version numbers, warn about them and set them to 0 +# before CPAN::Meta chokes. +sub clean_versions { + my($self, $key) = @_; + + my $reqs = $self->{$key}; + for my $module (keys %$reqs) { + my $version = $reqs->{$module}; + + if( !defined $version or $version !~ /^[\d_\.]+$/ ) { + carp "Unparsable version '$version' for prerequisite $module"; + $reqs->{$module} = 0; + } + } +} + sub selfdocument { my($self) = @_; my(@m); @@ -1491,8 +1516,8 @@ the first line in the "=head1 NAME" section. $2 becomes the abstract. =item AUTHOR Array of strings containing name (and email address) of package author(s). -Is used in META.yml and PPD (Perl Package Description) files for PPM (Perl -Package Manager). +Is used in CPAN Meta files (META.yml or META.json) and PPD +(Perl Package Description) files for PPM (Perl Package Manager). =item BINARY_LOCATION @@ -1509,7 +1534,8 @@ located in the C<x86> directory relative to the PPD itself. A hash of modules that are needed to build your module but not run it. -This will go into the C<build_requires> field of your F<META.yml>. +This will go into the C<build_requires> field of your CPAN Meta file. +(F<META.yml> or F<META.json>). The format is the same as PREREQ_PM. @@ -1556,7 +1582,8 @@ be determined by some evaluation method. A hash of modules that are required to run Makefile.PL itself, but not to run your distribution. -This will go into the C<configure_requires> field of your F<META.yml>. +This will go into the C<configure_requires> field of your CPAN Meta file +(F<META.yml> or F<META.json>) Defaults to C<<< { "ExtUtils::MakeMaker" => 0 } >>> @@ -1963,7 +1990,8 @@ may hold a name for that binary. Defaults to perl =item META_MERGE -A hashrefs of items to add to the F<META.yml>. +A hashrefs of items to add to the CPAN Meta file (F<META.yml> or +F<META.json>). They differ in how they behave if they have the same key as the default metadata. META_ADD will override the default value with its @@ -2012,14 +2040,14 @@ Boolean. Attribute to inhibit descending into subdirectories. =item NO_META When true, suppresses the generation and addition to the MANIFEST of -the META.yml module meta-data file during 'make distdir'. +the META.yml and META.json module meta-data files during 'make distdir'. Defaults to false. =item NO_MYMETA -When true, suppresses the generation of MYMETA.yml module meta-data file -during 'perl Makefile.PL'. +When true, suppresses the generation of MYMETA.yml and MYMETA.json module +meta-data files during 'perl Makefile.PL'. Defaults to false. @@ -2276,7 +2304,8 @@ A hash of modules that are needed to run your module. The keys are the module names ie. Test::More, and the minimum version is the value. If the required version number is 0 any version will do. -This will go into the C<requires> field of your F<META.yml>. +This will go into the C<requires> field of your CPAN Meta file +(F<META.yml> or F<META.json>). PREREQ_PM => { # Require Test::More at least 0.47 @@ -2641,8 +2670,8 @@ Copies all the files that are in the MANIFEST file to a newly created directory with the name C<$(DISTNAME)-$(VERSION)>. If that directory exists, it will be removed first. -Additionally, it will create a META.yml module meta-data file in the -distdir and add this to the distdir's MANIFEST. You can shut this +Additionally, it will create META.yml and META.json module meta-data file +in the distdir and add this to the distdir's MANIFEST. You can shut this behavior off with the NO_META flag. =item make disttest @@ -2716,26 +2745,37 @@ An example: ); -=head2 Module Meta-Data +=head2 Module Meta-Data (META and MYMETA) Long plaguing users of MakeMaker based modules has been the problem of getting basic information about the module out of the sources I<without> running the F<Makefile.PL> and doing a bunch of messy -heuristics on the resulting F<Makefile>. To this end a simple module -meta-data file has been introduced, F<META.yml>. - -F<META.yml> is a YAML document (see http://www.yaml.org) containing -basic information about the module (name, version, prerequisites...) -in an easy to read format. The format is developed and defined by the -Module::Build developers (see -http://module-build.sourceforge.net/META-spec.html) - -MakeMaker will automatically generate a F<META.yml> file for you and -add it to your F<MANIFEST> as part of the 'distdir' target (and thus -the 'dist' target). This is intended to seamlessly and rapidly -populate CPAN with module meta-data. If you wish to shut this feature -off, set the C<NO_META> C<WriteMakefile()> flag to true. - +heuristics on the resulting F<Makefile>. Over the years, it has become +standard to keep this information in one or more CPAN Meta files +distributed with each distribution. + +The original format of CPAN Meta files was L<YAML> and the corresponding +file was called F<META.yml>. In 2010, version 2 of the L<CPAN::Meta::Spec> +was released, which mandates JSON format for the metadata in order to +overcome certain compatibility issues between YAML serializers and to +avoid breaking older clients unable to handle a new version of the spec. +The L<CPAN::Meta> library is now standard for accessing old and new-style +Meta files. + +If L<CPAN::Meta> is installed, MakeMaker will automatically generate +F<META.json> and F<META.yml> files for you and add them to your F<MANIFEST> as +part of the 'distdir' target (and thus the 'dist' target). This is intended to +seamlessly and rapidly populate CPAN with module meta-data. If you wish to +shut this feature off, set the C<NO_META> C<WriteMakefile()> flag to true. + +At the 2008 QA Hackathon in Oslo, Perl module toolchain maintainers agrees +to use the CPAN Meta format to communicate post-configuration requirements +between toolchain components. These files, F<MYMETA.json> and F<MYMETA.yml>, +are generated when F<Makefile.PL> generates a F<Makefile> (if L<CPAN::Meta> +is installed). Clients like L<CPAN> or L<CPANPLUS> will read this +files to see what prerequisites must be fulfilled before building or testing +the distribution. If you with to shut this feature off, set the C<NO_MYMETA> +C<WriteMakeFile()> flag to true. =head2 Disabling an extension @@ -2812,6 +2852,8 @@ not normally available. L<ExtUtils::ModuleMaker> and L<Module::Starter> are both modules to help you setup your distribution. +L<CPAN::Meta> and L<CPAN::Meta::Spec> explain CPAN Meta files in detail. + =head1 AUTHORS Andy Dougherty C<doughera@lafayette.edu>, Andreas KE<ouml>nig @@ -2828,7 +2870,7 @@ generated Makefile along with your report. For more up-to-date information, see L<http://www.makemaker.org>. -Repository available at L<http://github.com/schwern/extutils-makemaker>. +Repository available at L<https://github.com/Perl-Toolchain-Gang/ExtUtils-MakeMaker>. =head1 LICENSE diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/Config.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/Config.pm index a7ac47d94a6..872f8c181cf 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/Config.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/Config.pm @@ -2,7 +2,7 @@ package ExtUtils::MakeMaker::Config; use strict; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; use Config (); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/FAQ.pod b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/FAQ.pod index f3354231d1e..675c95fc11e 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/FAQ.pod +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/FAQ.pod @@ -1,6 +1,6 @@ package ExtUtils::MakeMaker::FAQ; -our $VERSION = '6.57_01'; +our $VERSION = '6.63_02'; 1; __END__ diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/Tutorial.pod b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/Tutorial.pod index d5ff9086c36..5120271979f 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/Tutorial.pod +++ b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/Tutorial.pod @@ -1,6 +1,6 @@ package ExtUtils::MakeMaker::Tutorial; -our $VERSION = 6.57_01; +our $VERSION = 6.63_02; =head1 NAME diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/YAML.pm b/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/YAML.pm deleted file mode 100644 index 7582c5781f2..00000000000 --- a/Master/tlpkg/tlperl/lib/ExtUtils/MakeMaker/YAML.pm +++ /dev/null @@ -1,658 +0,0 @@ -package ExtUtils::MakeMaker::YAML; - -use strict; - -# UTF Support? -sub HAVE_UTF8 () { $] >= 5.007003 } -BEGIN { - if ( HAVE_UTF8 ) { - # The string eval helps hide this from Test::MinimumVersion - eval "require utf8;"; - die "Failed to load UTF-8 support" if $@; - } - - # Class structure - require 5.004; - require Exporter; - require Carp; - $ExtUtils::MakeMaker::YAML::VERSION = '1.44'; - @ExtUtils::MakeMaker::YAML::ISA = qw{ Exporter }; - @ExtUtils::MakeMaker::YAML::EXPORT = qw{ Load Dump }; - @ExtUtils::MakeMaker::YAML::EXPORT_OK = qw{ LoadFile DumpFile freeze thaw }; - - # Error storage - $ExtUtils::MakeMaker::YAML::errstr = ''; -} - -# The character class of all characters we need to escape -# NOTE: Inlined, since it's only used once -# my $RE_ESCAPE = '[\\x00-\\x08\\x0b-\\x0d\\x0e-\\x1f\"\n]'; - -# Printed form of the unprintable characters in the lowest range -# of ASCII characters, listed by ASCII ordinal position. -my @UNPRINTABLE = qw( - z x01 x02 x03 x04 x05 x06 a - x08 t n v f r x0e x0f - x10 x11 x12 x13 x14 x15 x16 x17 - x18 x19 x1a e x1c x1d x1e x1f -); - -# Printable characters for escapes -my %UNESCAPES = ( - z => "\x00", a => "\x07", t => "\x09", - n => "\x0a", v => "\x0b", f => "\x0c", - r => "\x0d", e => "\x1b", '\\' => '\\', -); - -# Special magic boolean words -my %QUOTE = map { $_ => 1 } qw{ - null Null NULL - y Y yes Yes YES n N no No NO - true True TRUE false False FALSE - on On ON off Off OFF -}; - - - - - -##################################################################### -# Implementation - -# Create an empty ExtUtils::MakeMaker::YAML object -sub new { - my $class = shift; - bless [ @_ ], $class; -} - -# Create an object from a file -sub read { - my $class = ref $_[0] ? ref shift : shift; - - # Check the file - my $file = shift or return $class->_error( 'You did not specify a file name' ); - return $class->_error( "File '$file' does not exist" ) unless -e $file; - return $class->_error( "'$file' is a directory, not a file" ) unless -f _; - return $class->_error( "Insufficient permissions to read '$file'" ) unless -r _; - - # Slurp in the file - local $/ = undef; - local *CFG; - unless ( open(CFG, $file) ) { - return $class->_error("Failed to open file '$file': $!"); - } - my $contents = <CFG>; - unless ( close(CFG) ) { - return $class->_error("Failed to close file '$file': $!"); - } - - $class->read_string( $contents ); -} - -# Create an object from a string -sub read_string { - my $class = ref $_[0] ? ref shift : shift; - my $self = bless [], $class; - my $string = $_[0]; - unless ( defined $string ) { - return $self->_error("Did not provide a string to load"); - } - - # Byte order marks - # NOTE: Keeping this here to educate maintainers - # my %BOM = ( - # "\357\273\277" => 'UTF-8', - # "\376\377" => 'UTF-16BE', - # "\377\376" => 'UTF-16LE', - # "\377\376\0\0" => 'UTF-32LE' - # "\0\0\376\377" => 'UTF-32BE', - # ); - if ( $string =~ /^(?:\376\377|\377\376|\377\376\0\0|\0\0\376\377)/ ) { - return $self->_error("Stream has a non UTF-8 BOM"); - } else { - # Strip UTF-8 bom if found, we'll just ignore it - $string =~ s/^\357\273\277//; - } - - # Try to decode as utf8 - utf8::decode($string) if HAVE_UTF8; - - # Check for some special cases - return $self unless length $string; - unless ( $string =~ /[\012\015]+\z/ ) { - return $self->_error("Stream does not end with newline character"); - } - - # Split the file into lines - my @lines = grep { ! /^\s*(?:\#.*)?\z/ } - split /(?:\015{1,2}\012|\015|\012)/, $string; - - # Strip the initial YAML header - @lines and $lines[0] =~ /^\%YAML[: ][\d\.]+.*\z/ and shift @lines; - - # A nibbling parser - while ( @lines ) { - # Do we have a document header? - if ( $lines[0] =~ /^---\s*(?:(.+)\s*)?\z/ ) { - # Handle scalar documents - shift @lines; - if ( defined $1 and $1 !~ /^(?:\#.+|\%YAML[: ][\d\.]+)\z/ ) { - push @$self, $self->_read_scalar( "$1", [ undef ], \@lines ); - next; - } - } - - if ( ! @lines or $lines[0] =~ /^(?:---|\.\.\.)/ ) { - # A naked document - push @$self, undef; - while ( @lines and $lines[0] !~ /^---/ ) { - shift @lines; - } - - } elsif ( $lines[0] =~ /^\s*\-/ ) { - # An array at the root - my $document = [ ]; - push @$self, $document; - $self->_read_array( $document, [ 0 ], \@lines ); - - } elsif ( $lines[0] =~ /^(\s*)\S/ ) { - # A hash at the root - my $document = { }; - push @$self, $document; - $self->_read_hash( $document, [ length($1) ], \@lines ); - - } else { - Carp::croak("ExtUtils::MakeMaker::YAML failed to classify the line '$lines[0]'"); - } - } - - $self; -} - -# Deparse a scalar string to the actual scalar -sub _read_scalar { - my ($self, $string, $indent, $lines) = @_; - - # Trim trailing whitespace - $string =~ s/\s*\z//; - - # Explitic null/undef - return undef if $string eq '~'; - - # Single quote - if ( $string =~ /^\'(.*?)\'\z/ ) { - return '' unless defined $1; - $string = $1; - $string =~ s/\'\'/\'/g; - return $string; - } - - # Double quote. - # The commented out form is simpler, but overloaded the Perl regex - # engine due to recursion and backtracking problems on strings - # larger than 32,000ish characters. Keep it for reference purposes. - # if ( $string =~ /^\"((?:\\.|[^\"])*)\"\z/ ) { - if ( $string =~ /^\"([^\\"]*(?:\\.[^\\"]*)*)\"\z/ ) { - # Reusing the variable is a little ugly, - # but avoids a new variable and a string copy. - $string = $1; - $string =~ s/\\"/"/g; - $string =~ s/\\([never\\fartz]|x([0-9a-fA-F]{2}))/(length($1)>1)?pack("H2",$2):$UNESCAPES{$1}/gex; - return $string; - } - - # Special cases - if ( $string =~ /^[\'\"!&]/ ) { - Carp::croak("ExtUtils::MakeMaker::YAML does not support a feature in line '$lines->[0]'"); - } - return {} if $string eq '{}'; - return [] if $string eq '[]'; - - # Regular unquoted string - return $string unless $string =~ /^[>|]/; - - # Error - Carp::croak("ExtUtils::MakeMaker::YAML failed to find multi-line scalar content") unless @$lines; - - # Check the indent depth - $lines->[0] =~ /^(\s*)/; - $indent->[-1] = length("$1"); - if ( defined $indent->[-2] and $indent->[-1] <= $indent->[-2] ) { - Carp::croak("ExtUtils::MakeMaker::YAML found bad indenting in line '$lines->[0]'"); - } - - # Pull the lines - my @multiline = (); - while ( @$lines ) { - $lines->[0] =~ /^(\s*)/; - last unless length($1) >= $indent->[-1]; - push @multiline, substr(shift(@$lines), length($1)); - } - - my $j = (substr($string, 0, 1) eq '>') ? ' ' : "\n"; - my $t = (substr($string, 1, 1) eq '-') ? '' : "\n"; - return join( $j, @multiline ) . $t; -} - -# Parse an array -sub _read_array { - my ($self, $array, $indent, $lines) = @_; - - while ( @$lines ) { - # Check for a new document - if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) { - while ( @$lines and $lines->[0] !~ /^---/ ) { - shift @$lines; - } - return 1; - } - - # Check the indent level - $lines->[0] =~ /^(\s*)/; - if ( length($1) < $indent->[-1] ) { - return 1; - } elsif ( length($1) > $indent->[-1] ) { - Carp::croak("ExtUtils::MakeMaker::YAML found bad indenting in line '$lines->[0]'"); - } - - if ( $lines->[0] =~ /^(\s*\-\s+)[^\'\"]\S*\s*:(?:\s+|$)/ ) { - # Inline nested hash - my $indent2 = length("$1"); - $lines->[0] =~ s/-/ /; - push @$array, { }; - $self->_read_hash( $array->[-1], [ @$indent, $indent2 ], $lines ); - - } elsif ( $lines->[0] =~ /^\s*\-(\s*)(.+?)\s*\z/ ) { - # Array entry with a value - shift @$lines; - push @$array, $self->_read_scalar( "$2", [ @$indent, undef ], $lines ); - - } elsif ( $lines->[0] =~ /^\s*\-\s*\z/ ) { - shift @$lines; - unless ( @$lines ) { - push @$array, undef; - return 1; - } - if ( $lines->[0] =~ /^(\s*)\-/ ) { - my $indent2 = length("$1"); - if ( $indent->[-1] == $indent2 ) { - # Null array entry - push @$array, undef; - } else { - # Naked indenter - push @$array, [ ]; - $self->_read_array( $array->[-1], [ @$indent, $indent2 ], $lines ); - } - - } elsif ( $lines->[0] =~ /^(\s*)\S/ ) { - push @$array, { }; - $self->_read_hash( $array->[-1], [ @$indent, length("$1") ], $lines ); - - } else { - Carp::croak("ExtUtils::MakeMaker::YAML failed to classify line '$lines->[0]'"); - } - - } elsif ( defined $indent->[-2] and $indent->[-1] == $indent->[-2] ) { - # This is probably a structure like the following... - # --- - # foo: - # - list - # bar: value - # - # ... so lets return and let the hash parser handle it - return 1; - - } else { - Carp::croak("ExtUtils::MakeMaker::YAML failed to classify line '$lines->[0]'"); - } - } - - return 1; -} - -# Parse an array -sub _read_hash { - my ($self, $hash, $indent, $lines) = @_; - - while ( @$lines ) { - # Check for a new document - if ( $lines->[0] =~ /^(?:---|\.\.\.)/ ) { - while ( @$lines and $lines->[0] !~ /^---/ ) { - shift @$lines; - } - return 1; - } - - # Check the indent level - $lines->[0] =~ /^(\s*)/; - if ( length($1) < $indent->[-1] ) { - return 1; - } elsif ( length($1) > $indent->[-1] ) { - Carp::croak("ExtUtils::MakeMaker::YAML found bad indenting in line '$lines->[0]'"); - } - - # Get the key - unless ( $lines->[0] =~ s/^\s*([^\'\" ][^\n]*?)\s*:(\s+|$)// ) { - if ( $lines->[0] =~ /^\s*[?\'\"]/ ) { - Carp::croak("ExtUtils::MakeMaker::YAML does not support a feature in line '$lines->[0]'"); - } - Carp::croak("ExtUtils::MakeMaker::YAML failed to classify line '$lines->[0]'"); - } - my $key = $1; - - # Do we have a value? - if ( length $lines->[0] ) { - # Yes - $hash->{$key} = $self->_read_scalar( shift(@$lines), [ @$indent, undef ], $lines ); - } else { - # An indent - shift @$lines; - unless ( @$lines ) { - $hash->{$key} = undef; - return 1; - } - if ( $lines->[0] =~ /^(\s*)-/ ) { - $hash->{$key} = []; - $self->_read_array( $hash->{$key}, [ @$indent, length($1) ], $lines ); - } elsif ( $lines->[0] =~ /^(\s*)./ ) { - my $indent2 = length("$1"); - if ( $indent->[-1] >= $indent2 ) { - # Null hash entry - $hash->{$key} = undef; - } else { - $hash->{$key} = {}; - $self->_read_hash( $hash->{$key}, [ @$indent, length($1) ], $lines ); - } - } - } - } - - return 1; -} - -# Save an object to a file -sub write { - my $self = shift; - my $file = shift or return $self->_error('No file name provided'); - - # Write it to the file - open( CFG, '>' . $file ) or return $self->_error( - "Failed to open file '$file' for writing: $!" - ); - print CFG $self->write_string; - close CFG; - - return 1; -} - -# Save an object to a string -sub write_string { - my $self = shift; - return '' unless @$self; - - # Iterate over the documents - my $indent = 0; - my @lines = (); - foreach my $cursor ( @$self ) { - push @lines, '---'; - - # An empty document - if ( ! defined $cursor ) { - # Do nothing - - # A scalar document - } elsif ( ! ref $cursor ) { - $lines[-1] .= ' ' . $self->_write_scalar( $cursor, $indent ); - - # version object - } elsif ( ref $cursor eq 'version' ) { - $lines[-1] .= ' ' . $self->_write_scalar( $cursor->stringify, $indent ); - - # A list at the root - } elsif ( ref $cursor eq 'ARRAY' ) { - unless ( @$cursor ) { - $lines[-1] .= ' []'; - next; - } - push @lines, $self->_write_array( $cursor, $indent, {} ); - - # A hash at the root - } elsif ( ref $cursor eq 'HASH' ) { - unless ( %$cursor ) { - $lines[-1] .= ' {}'; - next; - } - push @lines, $self->_write_hash( $cursor, $indent, {} ); - - } else { - Carp::croak("Cannot serialize " . ref($cursor)); - } - } - - join '', map { "$_\n" } @lines; -} - -sub _write_scalar { - my $string = $_[1]; - return '~' unless defined $string; - return "''" unless length $string; - if ( $string =~ /[\x00-\x08\x0b-\x0d\x0e-\x1f\"\'\n]/ ) { - $string =~ s/\\/\\\\/g; - $string =~ s/"/\\"/g; - $string =~ s/\n/\\n/g; - $string =~ s/([\x00-\x1f])/\\$UNPRINTABLE[ord($1)]/g; - return qq|"$string"|; - } - if ( $string =~ /(?:^\W|\s)/ or $QUOTE{$string} ) { - return "'$string'"; - } - return $string; -} - -sub _write_array { - my ($self, $array, $indent, $seen) = @_; - if ( $seen->{refaddr($array)}++ ) { - die "ExtUtils::MakeMaker::YAML does not support circular references"; - } - my @lines = (); - foreach my $el ( @$array ) { - my $line = (' ' x $indent) . '-'; - my $type = ref $el; - if ( ! $type ) { - $line .= ' ' . $self->_write_scalar( $el, $indent + 1 ); - push @lines, $line; - - # version object - } elsif ( $type eq 'version' ) { - $line .= ' ' . $self->_write_scalar( $el->stringify, $indent + 1 ); - push @lines, $line; - - } elsif ( $type eq 'ARRAY' ) { - if ( @$el ) { - push @lines, $line; - push @lines, $self->_write_array( $el, $indent + 1, $seen ); - } else { - $line .= ' []'; - push @lines, $line; - } - - } elsif ( $type eq 'HASH' ) { - if ( keys %$el ) { - push @lines, $line; - push @lines, $self->_write_hash( $el, $indent + 1, $seen ); - } else { - $line .= ' {}'; - push @lines, $line; - } - - } else { - die "ExtUtils::MakeMaker::YAML does not support $type references"; - } - } - - @lines; -} - -sub _write_hash { - my ($self, $hash, $indent, $seen) = @_; - if ( $seen->{refaddr($hash)}++ ) { - die "ExtUtils::MakeMaker::YAML does not support circular references"; - } - my @lines = (); - foreach my $name ( sort keys %$hash ) { - my $el = $hash->{$name}; - my $line = (' ' x $indent) . "$name:"; - my $type = ref $el; - if ( ! $type ) { - $line .= ' ' . $self->_write_scalar( $el, $indent + 1 ); - push @lines, $line; - - # version object - } elsif ( $type eq 'version' ) { - $line .= ' ' . $self->_write_scalar( $el->stringify, $indent + 1 ); - push @lines, $line; - - } elsif ( $type eq 'ARRAY' ) { - if ( @$el ) { - push @lines, $line; - push @lines, $self->_write_array( $el, $indent + 1, $seen ); - } else { - $line .= ' []'; - push @lines, $line; - } - - } elsif ( $type eq 'HASH' ) { - if ( keys %$el ) { - push @lines, $line; - push @lines, $self->_write_hash( $el, $indent + 1, $seen ); - } else { - $line .= ' {}'; - push @lines, $line; - } - - } else { - die "ExtUtils::MakeMaker::YAML does not support $type references"; - } - } - - @lines; -} - -# Set error -sub _error { - $ExtUtils::MakeMaker::YAML::errstr = $_[1]; - undef; -} - -# Retrieve error -sub errstr { - $ExtUtils::MakeMaker::YAML::errstr; -} - - - - - -##################################################################### -# YAML Compatibility - -sub Dump { - ExtUtils::MakeMaker::YAML->new(@_)->write_string; -} - -sub Load { - my $self = ExtUtils::MakeMaker::YAML->read_string(@_); - unless ( $self ) { - Carp::croak("Failed to load YAML document from string"); - } - if ( wantarray ) { - return @$self; - } else { - # To match YAML.pm, return the last document - return $self->[-1]; - } -} - -BEGIN { - *freeze = *Dump; - *thaw = *Load; -} - -sub DumpFile { - my $file = shift; - ExtUtils::MakeMaker::YAML->new(@_)->write($file); -} - -sub LoadFile { - my $self = ExtUtils::MakeMaker::YAML->read($_[0]); - unless ( $self ) { - Carp::croak("Failed to load YAML document from '" . ($_[0] || '') . "'"); - } - if ( wantarray ) { - return @$self; - } else { - # Return only the last document to match YAML.pm, - return $self->[-1]; - } -} - - - - - -##################################################################### -# Use Scalar::Util if possible, otherwise emulate it - -BEGIN { - eval { - require Scalar::Util; - *refaddr = *Scalar::Util::refaddr; - }; - eval <<'END_PERL' if $@; -# Failed to load Scalar::Util -sub refaddr { - my $pkg = ref($_[0]) or return undef; - if (!!UNIVERSAL::can($_[0], 'can')) { - bless $_[0], 'Scalar::Util::Fake'; - } else { - $pkg = undef; - } - "$_[0]" =~ /0x(\w+)/; - my $i = do { local $^W; hex $1 }; - bless $_[0], $pkg if defined $pkg; - $i; -} -END_PERL - -} - -1; - -__END__ - -=pod - -=head1 NAME - -ExtUtils::MakeMaker::YAML - clone of YAML::Tiny - -=head1 SYNOPSIS - -See L<YAML::Tiny> - -=head1 AUTHOR - -Adam Kennedy E<lt>adamk@cpan.orgE<gt> - -=head1 SEE ALSO - -L<YAML>, L<YAML::Syck> - -=head1 COPYRIGHT - -Copyright 2006 - 2010 Adam Kennedy. - -This program is free software; you can redistribute -it and/or modify it under the same terms as Perl itself. - -=cut diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Manifest.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Manifest.pm index ce4314c419d..b1e61200187 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Manifest.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Manifest.pm @@ -13,7 +13,7 @@ use vars qw($VERSION @ISA @EXPORT_OK $Is_MacOS $Is_VMS $Is_VMS_mode $Is_VMS_lc $Is_VMS_nodot $Debug $Verbose $Quiet $MANIFEST $DEFAULT_MSKIP); -$VERSION = '1.58'; +$VERSION = '1.61'; @ISA=('Exporter'); @EXPORT_OK = qw(mkmanifest manicheck filecheck fullcheck skipcheck @@ -706,21 +706,36 @@ sub maniadd { } -# Sometimes MANIFESTs are missing a trailing newline. Fix this. +# Make sure this MANIFEST is consistently written with native +# newlines and has a terminal newline. sub _fix_manifest { my $manifest_file = shift; open MANIFEST, $MANIFEST or die "Could not open $MANIFEST: $!"; - - # Yes, we should be using seek(), but I'd like to avoid loading POSIX - # to get SEEK_* - my @manifest = <MANIFEST>; + local $/; + my @manifest = split /(\015\012|\012|\015)/, <MANIFEST>, -1; close MANIFEST; + my $must_rewrite = ""; + if ($manifest[-1] eq ""){ + # sane case: last line had a terminal newline + pop @manifest; + for (my $i=1; $i<=$#manifest; $i+=2) { + unless ($manifest[$i] eq "\n") { + $must_rewrite = "not a newline at pos $i"; + last; + } + } + } else { + $must_rewrite = "last line without newline"; + } - unless( $manifest[-1] =~ /\n\z/ ) { - open MANIFEST, ">>$MANIFEST" or die "Could not open $MANIFEST: $!"; - print MANIFEST "\n"; - close MANIFEST; + if ( $must_rewrite ) { + 1 while unlink $MANIFEST; # avoid multiple versions on VMS + open MANIFEST, ">", $MANIFEST or die "(must_rewrite=$must_rewrite) Could not open >$MANIFEST: $!"; + for (my $i=0; $i<=$#manifest; $i+=2) { + print MANIFEST "$manifest[$i]\n"; + } + close MANIFEST or die "could not write $MANIFEST: $!"; } } diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Miniperl.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Miniperl.pm index 379eb118ed5..0a2cb627abe 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Miniperl.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Miniperl.pm @@ -94,7 +94,7 @@ main(int argc, char **argv, char **env) PERL_UNUSED_ARG(env); #endif #ifndef PERL_USE_SAFE_PUTENV - PL_use_safe_putenv = 0; + PL_use_safe_putenv = FALSE; #endif /* PERL_USE_SAFE_PUTENV */ /* if user wants control of gprof profiling off by default */ diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Mkbootstrap.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Mkbootstrap.pm index fbf24156c6a..b5f19ea95ce 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Mkbootstrap.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Mkbootstrap.pm @@ -3,7 +3,7 @@ package ExtUtils::Mkbootstrap; # There's just too much Dynaloader incest here to turn on strict vars. use strict 'refs'; -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; require Exporter; our @ISA = ('Exporter'); diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Mksymlists.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Mksymlists.pm index 9aac3fd74a4..f0860855923 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Mksymlists.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Mksymlists.pm @@ -10,7 +10,7 @@ use Config; our @ISA = qw(Exporter); our @EXPORT = qw(&Mksymlists); -our $VERSION = '6.57_05'; +our $VERSION = '6.63_02'; sub Mksymlists { my(%spec) = @_; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Packlist.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Packlist.pm index b77a556be50..a268e300d3c 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/Packlist.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Packlist.pm @@ -5,7 +5,7 @@ use strict; use Carp qw(); use Config; use vars qw($VERSION $Relocations); -$VERSION = '1.44'; +$VERSION = '1.46'; $VERSION = eval $VERSION; # Used for generating filehandle globs. IO::File might not be available! @@ -24,6 +24,7 @@ Make a filehandle. Same kind of idea as Symbol::gensym(). sub mkfh() { no strict; +local $^W; my $fh = \*{$fhname++}; use strict; return($fh); @@ -34,10 +35,10 @@ return($fh); Works out what absolute paths in the configuration have been located at run time relative to $^X, and generates a regexp that matches them -=end _undocumented - =back +=end _undocumented + =cut sub __find_relocations diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm index 79b39688492..883d9059311 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pm @@ -1,109 +1,117 @@ package ExtUtils::ParseXS; +use strict; -use 5.006; # We use /??{}/ in regexes +use 5.006001; use Cwd; use Config; +use Exporter; use File::Basename; use File::Spec; use Symbol; -require Exporter; - -@ISA = qw(Exporter); -@EXPORT_OK = qw(process_file); - -# use strict; # One of these days... - -my(@XSStack); # Stack of conditionals and INCLUDEs -my($XSS_work_idx, $cpp_next_tmp); - -use vars qw($VERSION); -$VERSION = '2.2210'; +our $VERSION; +BEGIN { + $VERSION = '3.16'; +} +use ExtUtils::ParseXS::Constants $VERSION; +use ExtUtils::ParseXS::CountLines $VERSION; +use ExtUtils::ParseXS::Utilities $VERSION; $VERSION = eval $VERSION if $VERSION =~ /_/; -use vars qw(%input_expr %output_expr $ProtoUsed @InitFileCode $FH $proto_re $Overload $errors $Fallback - $cplusplus $hiertype $WantPrototypes $WantVersionChk $except $WantLineNumbers - $WantOptimize $process_inout $process_argtypes @tm - $dir $filename $filepathname %IncludedFiles - %type_kind %proto_letter - %targetable $BLOCK_re $lastline $lastline_no - $Package $Prefix @line @BootCode %args_match %defaults %var_types %arg_list @proto_arg - $processing_arg_with_types %argtype_seen @outlist %in_out %lengthof - $proto_in_this_xsub $scope_in_this_xsub $interface $prepush_done $interface_macro $interface_macro_set - $ProtoThisXSUB $ScopeThisXSUB $xsreturn - @line_no $ret_type $func_header $orig_args - ); # Add these just to get compilation to happen. - +use ExtUtils::ParseXS::Utilities qw( + standard_typemap_locations + trim_whitespace + tidy_type + C_string + valid_proto_string + process_typemaps + make_targetable + map_type + standard_XS_defs + assign_func_args + analyze_preprocessor_statements + set_cond + Warn + current_line_number + blurt + death + check_conditional_preprocessor_statements + escape_file_for_line_directive + report_typemap_failure +); + +our @ISA = qw(Exporter); +our @EXPORT_OK = qw( + process_file + report_error_count +); + +# The scalars in the line below remain as 'our' variables because pulling +# them into $self led to build problems. In most cases, strings being +# 'eval'-ed contain the variables' names hard-coded. +our ( + $Package, $func_name, $Full_func_name, $pname, $ALIAS, +); + +our $self = bless {} => __PACKAGE__; sub process_file { - + # Allow for $package->process_file(%hash) in the future - my ($pkg, %args) = @_ % 2 ? @_ : (__PACKAGE__, @_); - - $ProtoUsed = exists $args{prototypes}; - + my ($pkg, %options) = @_ % 2 ? @_ : (__PACKAGE__, @_); + + $self->{ProtoUsed} = exists $options{prototypes}; + # Set defaults. - %args = ( - # 'C++' => 0, # Doesn't seem to *do* anything... - hiertype => 0, - except => 0, - prototypes => 0, - versioncheck => 1, - linenumbers => 1, - optimize => 1, - prototypes => 0, - inout => 1, - argtypes => 1, - typemap => [], - output => \*STDOUT, - csuffix => '.c', - %args, - ); + my %args = ( + argtypes => 1, + csuffix => '.c', + except => 0, + hiertype => 0, + inout => 1, + linenumbers => 1, + optimize => 1, + output => \*STDOUT, + prototypes => 0, + typemap => [], + versioncheck => 1, + FH => Symbol::gensym(), + %options, + ); + $args{except} = $args{except} ? ' TRY' : ''; # Global Constants - + my ($Is_VMS, $SymSet); if ($^O eq 'VMS') { $Is_VMS = 1; # Establish set of global symbols with max length 28, since xsubpp # will later add the 'XS_' prefix. require ExtUtils::XSSymSet; - $SymSet = new ExtUtils::XSSymSet 28; + $SymSet = ExtUtils::XSSymSet->new(28); } - @XSStack = ({type => 'none'}); - ($XSS_work_idx, $cpp_next_tmp) = (0, "XSubPPtmpAAAA"); - @InitFileCode = (); - $FH = Symbol::gensym(); - $proto_re = "[" . quotemeta('\$%&*@;[]_') . "]" ; - $Overload = 0; - $errors = 0; - $Fallback = '&PL_sv_undef'; + @{ $self->{XSStack} } = ({type => 'none'}); + $self->{InitFileCode} = [ @ExtUtils::ParseXS::Constants::InitFileCode ]; + $self->{Overload} = 0; + $self->{errors} = 0; + $self->{Fallback} = '&PL_sv_undef'; # Most of the 1500 lines below uses these globals. We'll have to # clean this up sometime, probably. For now, we just pull them out # of %args. -Ken - - $cplusplus = $args{'C++'}; - $hiertype = $args{hiertype}; - $WantPrototypes = $args{prototypes}; - $WantVersionChk = $args{versioncheck}; - $except = $args{except} ? ' TRY' : ''; - $WantLineNumbers = $args{linenumbers}; - $WantOptimize = $args{optimize}; - $process_inout = $args{inout}; - $process_argtypes = $args{argtypes}; - @tm = ref $args{typemap} ? @{$args{typemap}} : ($args{typemap}); - - for ($args{filename}) { - die "Missing required parameter 'filename'" unless $_; - $filepathname = $_; - ($dir, $filename) = (dirname($_), basename($_)); - $filepathname =~ s/\\/\\\\/g; - $IncludedFiles{$_}++; - } - - # Open the input file - open($FH, $args{filename}) or die "cannot open $args{filename}: $!\n"; + + $self->{hiertype} = $args{hiertype}; + $self->{WantPrototypes} = $args{prototypes}; + $self->{WantVersionChk} = $args{versioncheck}; + $self->{WantLineNumbers} = $args{linenumbers}; + $self->{IncludedFiles} = {}; + + die "Missing required parameter 'filename'" unless $args{filename}; + $self->{filepathname} = $args{filename}; + ($self->{dir}, $self->{filename}) = + (dirname($args{filename}), basename($args{filename})); + $self->{filepathname} =~ s/\\/\\\\/g; + $self->{IncludedFiles}->{$args{filename}}++; # Open the output file if given as a string. If they provide some # other kind of reference, trust them that we can print to it. @@ -114,194 +122,121 @@ sub process_file { } # Really, we shouldn't have to chdir() or select() in the first - # place. For now, just save & restore. + # place. For now, just save and restore. my $orig_cwd = cwd(); my $orig_fh = select(); - - chdir($dir); + + chdir($self->{dir}); my $pwd = cwd(); my $csuffix = $args{csuffix}; - - if ($WantLineNumbers) { + + if ($self->{WantLineNumbers}) { my $cfile; if ( $args{outfile} ) { $cfile = $args{outfile}; - } else { + } + else { $cfile = $args{filename}; $cfile =~ s/\.xs$/$csuffix/i or $cfile .= $csuffix; } tie(*PSEUDO_STDOUT, 'ExtUtils::ParseXS::CountLines', $cfile, $args{output}); select PSEUDO_STDOUT; - } else { - select $args{output}; - } - - foreach my $typemap (@tm) { - die "Can't find $typemap in $pwd\n" unless -r $typemap; } - - push @tm, standard_typemap_locations(); - - foreach my $typemap (@tm) { - next unless -f $typemap ; - # skip directories, binary files etc. - warn("Warning: ignoring non-text typemap file '$typemap'\n"), next - unless -T $typemap ; - open(TYPEMAP, $typemap) - or warn ("Warning: could not open typemap file '$typemap': $!\n"), next; - my $mode = 'Typemap'; - my $junk = "" ; - my $current = \$junk; - while (<TYPEMAP>) { - next if /^\s* #/; - my $line_no = $. + 1; - if (/^INPUT\s*$/) { - $mode = 'Input'; $current = \$junk; next; - } - if (/^OUTPUT\s*$/) { - $mode = 'Output'; $current = \$junk; next; - } - if (/^TYPEMAP\s*$/) { - $mode = 'Typemap'; $current = \$junk; next; - } - if ($mode eq 'Typemap') { - chomp; - my $line = $_ ; - TrimWhitespace($_) ; - # skip blank lines and comment lines - next if /^$/ or /^#/ ; - my($type,$kind, $proto) = /^\s*(.*?\S)\s+(\S+)\s*($proto_re*)\s*$/ or - warn("Warning: File '$typemap' Line $. '$line' TYPEMAP entry needs 2 or 3 columns\n"), next; - $type = TidyType($type) ; - $type_kind{$type} = $kind ; - # prototype defaults to '$' - $proto = "\$" unless $proto ; - warn("Warning: File '$typemap' Line $. '$line' Invalid prototype '$proto'\n") - unless ValidProtoString($proto) ; - $proto_letter{$type} = C_string($proto) ; - } elsif (/^\s/) { - $$current .= $_; - } elsif ($mode eq 'Input') { - s/\s+$//; - $input_expr{$_} = ''; - $current = \$input_expr{$_}; - } else { - s/\s+$//; - $output_expr{$_} = ''; - $current = \$output_expr{$_}; - } - } - close(TYPEMAP); - } - - foreach my $value (values %input_expr) { - $value =~ s/;*\s+\z//; - # Move C pre-processor instructions to column 1 to be strictly ANSI - # conformant. Some pre-processors are fussy about this. - $value =~ s/^\s+#/#/mg; - } - foreach my $value (values %output_expr) { - # And again. - $value =~ s/^\s+#/#/mg; + else { + select $args{output}; } - my ($cast, $size); - our $bal = qr[(?:(?>[^()]+)|\((??{ $bal })\))*]; # ()-balanced - $cast = qr[(?:\(\s*SV\s*\*\s*\)\s*)?]; # Optional (SV*) cast - $size = qr[,\s* (??{ $bal }) ]x; # Third arg (to setpvn) - - foreach my $key (keys %output_expr) { - # We can still bootstrap compile 're', because in code re.pm is - # available to miniperl, and does not attempt to load the XS code. - use re 'eval'; - - my ($t, $with_size, $arg, $sarg) = - ($output_expr{$key} =~ - m[^ \s+ sv_set ( [iunp] ) v (n)? # Type, is_setpvn - \s* \( \s* $cast \$arg \s* , - \s* ( (??{ $bal }) ) # Set from - ( (??{ $size }) )? # Possible sizeof set-from - \) \s* ; \s* $ - ]x); - $targetable{$key} = [$t, $with_size, $arg, $sarg] if $t; - } + $self->{typemap} = process_typemaps( $args{typemap}, $pwd ); - my $END = "!End!\n\n"; # "impossible" keyword (multiple newline) + my $END = "!End!\n\n"; # "impossible" keyword (multiple newline) # Match an XS keyword - $BLOCK_re= '\s*(' . join('|', qw( - REQUIRE BOOT CASE PREINIT INPUT INIT CODE PPCODE - OUTPUT CLEANUP ALIAS ATTRS PROTOTYPES PROTOTYPE - VERSIONCHECK INCLUDE INCLUDE_COMMAND SCOPE INTERFACE - INTERFACE_MACRO C_ARGS POSTCALL OVERLOAD FALLBACK - )) . "|$END)\\s*:"; - - + $self->{BLOCK_re} = '\s*(' . + join('|' => @ExtUtils::ParseXS::Constants::XSKeywords) . + "|$END)\\s*:"; + our ($C_group_rex, $C_arg); # Group in C (no support for comments or literals) $C_group_rex = qr/ [({\[] - (?: (?> [^()\[\]{}]+ ) | (??{ $C_group_rex }) )* - [)}\]] /x ; + (?: (?> [^()\[\]{}]+ ) | (??{ $C_group_rex }) )* + [)}\]] /x; # Chunk in C without comma at toplevel (no comments): $C_arg = qr/ (?: (?> [^()\[\]{},"']+ ) - | (??{ $C_group_rex }) - | " (?: (?> [^\\"]+ ) - | \\. - )* " # String literal - | ' (?: (?> [^\\']+ ) | \\. )* ' # Char literal - )* /xs; - + | (??{ $C_group_rex }) + | " (?: (?> [^\\"]+ ) + | \\. + )* " # String literal + | ' (?: (?> [^\\']+ ) | \\. )* ' # Char literal + )* /xs; + + # Since at this point we're ready to begin printing to the output file and + # reading from the input file, I want to get as much data as possible into + # the proto-object $self. That means assigning to $self and elements of + # %args referenced below this point. + # HOWEVER: This resulted in an error when I tried: + # $args{'s'} ---> $self->{s}. + # Use of uninitialized value in quotemeta at + # .../blib/lib/ExtUtils/ParseXS.pm line 733 + + foreach my $datum ( qw| argtypes except inout optimize | ) { + $self->{$datum} = $args{$datum}; + } + # Identify the version of xsubpp used - print <<EOM ; + print <<EOM; /* * This file was generated automatically by ExtUtils::ParseXS version $VERSION from the - * contents of $filename. Do not edit this file, edit $filename instead. + * contents of $self->{filename}. Do not edit this file, edit $self->{filename} instead. * - * ANY CHANGES MADE HERE WILL BE LOST! + * ANY CHANGES MADE HERE WILL BE LOST! * */ EOM - print("#line 1 \"$filepathname\"\n") - if $WantLineNumbers; + print("#line 1 \"" . escape_file_for_line_directive($self->{filepathname}) . "\"\n") + if $self->{WantLineNumbers}; + + # Open the input file (using $self->{filename} which + # is a basename'd $args{filename} due to chdir above) + open($self->{FH}, '<', $self->{filename}) or die "cannot open $self->{filename}: $!\n"; firstmodule: - while (<$FH>) { + while (readline($self->{FH})) { if (/^=/) { my $podstartline = $.; do { - if (/^=cut\s*$/) { - # We can't just write out a /* */ comment, as our embedded - # POD might itself be in a comment. We can't put a /**/ - # comment inside #if 0, as the C standard says that the source - # file is decomposed into preprocessing characters in the stage - # before preprocessing commands are executed. - # I don't want to leave the text as barewords, because the spec - # isn't clear whether macros are expanded before or after - # preprocessing commands are executed, and someone pathological - # may just have defined one of the 3 words as a macro that does - # something strange. Multiline strings are illegal in C, so - # the "" we write must be a string literal. And they aren't - # concatenated until 2 steps later, so we are safe. - # - Nicholas Clark - print("#if 0\n \"Skipped embedded POD.\"\n#endif\n"); - printf("#line %d \"$filepathname\"\n", $. + 1) - if $WantLineNumbers; - next firstmodule - } - - } while (<$FH>); + if (/^=cut\s*$/) { + # We can't just write out a /* */ comment, as our embedded + # POD might itself be in a comment. We can't put a /**/ + # comment inside #if 0, as the C standard says that the source + # file is decomposed into preprocessing characters in the stage + # before preprocessing commands are executed. + # I don't want to leave the text as barewords, because the spec + # isn't clear whether macros are expanded before or after + # preprocessing commands are executed, and someone pathological + # may just have defined one of the 3 words as a macro that does + # something strange. Multiline strings are illegal in C, so + # the "" we write must be a string literal. And they aren't + # concatenated until 2 steps later, so we are safe. + # - Nicholas Clark + print("#if 0\n \"Skipped embedded POD.\"\n#endif\n"); + printf("#line %d \"%s\"\n", $. + 1, escape_file_for_line_directive($self->{filepathname})) + if $self->{WantLineNumbers}; + next firstmodule + } + + } while (readline($self->{FH})); # At this point $. is at end of file so die won't state the start # of the problem, and as we haven't yet read any lines &death won't # show the correct line in the message either. - die ("Error: Unterminated pod in $filename, line $podstartline\n") - unless $lastline; + die ("Error: Unterminated pod in $self->{filename}, line $podstartline\n") + unless $self->{lastline}; } - last if ($Package, $Prefix) = + last if ($Package, $self->{Prefix}) = /^MODULE\s*=\s*[\w:]+(?:\s+PACKAGE\s*=\s*([\w:]+))?(?:\s+PREFIX\s*=\s*(\S+))?\s*$/; - + print $_; } unless (defined $_) { @@ -309,313 +244,259 @@ EOM exit 0; # Not a fatal error for the caller process } - print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; - - print <<"EOF"; -#ifndef PERL_UNUSED_VAR -# define PERL_UNUSED_VAR(var) if (0) var = var -#endif - -EOF - - print <<"EOF"; -#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE -#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params) - -/* prototype to pass -Wmissing-prototypes */ -STATIC void -S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params); - -STATIC void -S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params) -{ - const GV *const gv = CvGV(cv); - - PERL_ARGS_ASSERT_CROAK_XS_USAGE; - - if (gv) { - const char *const gvname = GvNAME(gv); - const HV *const stash = GvSTASH(gv); - const char *const hvname = stash ? HvNAME(stash) : NULL; - - if (hvname) - Perl_croak(aTHX_ "Usage: %s::%s(%s)", hvname, gvname, params); - else - Perl_croak(aTHX_ "Usage: %s(%s)", gvname, params); - } else { - /* Pants. I don't think that it should be possible to get here. */ - Perl_croak(aTHX_ "Usage: CODE(0x%"UVxf")(%s)", PTR2UV(cv), params); - } -} -#undef PERL_ARGS_ASSERT_CROAK_XS_USAGE - -#ifdef PERL_IMPLICIT_CONTEXT -#define croak_xs_usage(a,b) S_croak_xs_usage(aTHX_ a,b) -#else -#define croak_xs_usage S_croak_xs_usage -#endif - -#endif - -/* NOTE: the prototype of newXSproto() is different in versions of perls, - * so we define a portable version of newXSproto() - */ -#ifdef newXS_flags -#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0) -#else -#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv) -#endif /* !defined(newXS_flags) */ + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $self->{WantLineNumbers}; -EOF + standard_XS_defs(); - print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $self->{WantLineNumbers}; - $lastline = $_; - $lastline_no = $.; + $self->{lastline} = $_; + $self->{lastline_no} = $.; + my $BootCode_ref = []; + my $XSS_work_idx = 0; + my $cpp_next_tmp = 'XSubPPtmpAAAA'; PARAGRAPH: - while (fetch_para()) { + while ($self->fetch_para()) { + my $outlist_ref = []; # Print initial preprocessor statements and blank lines - while (@line && $line[0] !~ /^[^\#]/) { - my $line = shift(@line); - print $line, "\n"; - next unless $line =~ /^\#\s*((if)(?:n?def)?|elsif|else|endif)\b/; + while (@{ $self->{line} } && $self->{line}->[0] !~ /^[^\#]/) { + my $ln = shift(@{ $self->{line} }); + print $ln, "\n"; + next unless $ln =~ /^\#\s*((if)(?:n?def)?|elsif|else|endif)\b/; my $statement = $+; - if ($statement eq 'if') { - $XSS_work_idx = @XSStack; - push(@XSStack, {type => 'if'}); - } else { - death ("Error: `$statement' with no matching `if'") - if $XSStack[-1]{type} ne 'if'; - if ($XSStack[-1]{varname}) { - push(@InitFileCode, "#endif\n"); - push(@BootCode, "#endif"); - } - - my(@fns) = keys %{$XSStack[-1]{functions}}; - if ($statement ne 'endif') { - # Hide the functions defined in other #if branches, and reset. - @{$XSStack[-1]{other_functions}}{@fns} = (1) x @fns; - @{$XSStack[-1]}{qw(varname functions)} = ('', {}); - } else { - my($tmp) = pop(@XSStack); - 0 while (--$XSS_work_idx - && $XSStack[$XSS_work_idx]{type} ne 'if'); - # Keep all new defined functions - push(@fns, keys %{$tmp->{other_functions}}); - @{$XSStack[$XSS_work_idx]{functions}}{@fns} = (1) x @fns; - } - } + ( $self, $XSS_work_idx, $BootCode_ref ) = + analyze_preprocessor_statements( + $self, $statement, $XSS_work_idx, $BootCode_ref + ); } - - next PARAGRAPH unless @line; - - if ($XSS_work_idx && !$XSStack[$XSS_work_idx]{varname}) { + + next PARAGRAPH unless @{ $self->{line} }; + + if ($XSS_work_idx && !$self->{XSStack}->[$XSS_work_idx]{varname}) { # We are inside an #if, but have not yet #defined its xsubpp variable. print "#define $cpp_next_tmp 1\n\n"; - push(@InitFileCode, "#if $cpp_next_tmp\n"); - push(@BootCode, "#if $cpp_next_tmp"); - $XSStack[$XSS_work_idx]{varname} = $cpp_next_tmp++; + push(@{ $self->{InitFileCode} }, "#if $cpp_next_tmp\n"); + push(@{ $BootCode_ref }, "#if $cpp_next_tmp"); + $self->{XSStack}->[$XSS_work_idx]{varname} = $cpp_next_tmp++; } - death ("Code is not inside a function" - ." (maybe last function was ended by a blank line " - ." followed by a statement on column one?)") - if $line[0] =~ /^\s/; - - my ($class, $externC, $static, $ellipsis, $wantRETVAL, $RETVAL_no_return); - my (@fake_INPUT_pre); # For length(s) generated variables - my (@fake_INPUT); - + $self->death( + "Code is not inside a function" + ." (maybe last function was ended by a blank line " + ." followed by a statement on column one?)") + if $self->{line}->[0] =~ /^\s/; + # initialize info arrays - undef(%args_match); - undef(%var_types); - undef(%defaults); - undef(%arg_list) ; - undef(@proto_arg) ; - undef($processing_arg_with_types) ; - undef(%argtype_seen) ; - undef(@outlist) ; - undef(%in_out) ; - undef(%lengthof) ; - undef($proto_in_this_xsub) ; - undef($scope_in_this_xsub) ; - undef($interface); - undef($prepush_done); - $interface_macro = 'XSINTERFACE_FUNC' ; - $interface_macro_set = 'XSINTERFACE_FUNC_SET' ; - $ProtoThisXSUB = $WantPrototypes ; - $ScopeThisXSUB = 0; - $xsreturn = 0; - - $_ = shift(@line); - while (my $kwd = check_keyword("REQUIRE|PROTOTYPES|FALLBACK|VERSIONCHECK|INCLUDE(?:_COMMAND)?|SCOPE")) { - &{"${kwd}_handler"}() ; - next PARAGRAPH unless @line ; - $_ = shift(@line); + foreach my $member (qw(args_match var_types defaults arg_list + argtype_seen in_out lengthof)) + { + $self->{$member} = {}; } - - if (check_keyword("BOOT")) { - &check_cpp; - push (@BootCode, "#line $line_no[@line_no - @line] \"$filepathname\"") - if $WantLineNumbers && $line[0] !~ /^\s*#\s*line\b/; - push (@BootCode, @line, "") ; - next PARAGRAPH ; + $self->{proto_arg} = []; + $self->{processing_arg_with_types} = undef; + $self->{proto_in_this_xsub} = undef; + $self->{scope_in_this_xsub} = undef; + $self->{interface} = undef; + $self->{interface_macro} = 'XSINTERFACE_FUNC'; + $self->{interface_macro_set} = 'XSINTERFACE_FUNC_SET'; + $self->{ProtoThisXSUB} = $self->{WantPrototypes}; + $self->{ScopeThisXSUB} = 0; + + my $xsreturn = 0; + + $_ = shift(@{ $self->{line} }); + while (my $kwd = $self->check_keyword("REQUIRE|PROTOTYPES|EXPORT_XSUB_SYMBOLS|FALLBACK|VERSIONCHECK|INCLUDE(?:_COMMAND)?|SCOPE")) { + my $method = $kwd . "_handler"; + $self->$method($_); + next PARAGRAPH unless @{ $self->{line} }; + $_ = shift(@{ $self->{line} }); } + if ($self->check_keyword("BOOT")) { + check_conditional_preprocessor_statements($self); + push (@{ $BootCode_ref }, "#line $self->{line_no}->[@{ $self->{line_no} } - @{ $self->{line} }] \"" + . escape_file_for_line_directive($self->{filepathname}) . "\"") + if $self->{WantLineNumbers} && $self->{line}->[0] !~ /^\s*#\s*line\b/; + push (@{ $BootCode_ref }, @{ $self->{line} }, ""); + next PARAGRAPH; + } # extract return type, function name and arguments - ($ret_type) = TidyType($_); - $RETVAL_no_return = 1 if $ret_type =~ s/^NO_OUTPUT\s+//; + ($self->{ret_type}) = tidy_type($_); + my $RETVAL_no_return = 1 if $self->{ret_type} =~ s/^NO_OUTPUT\s+//; # Allow one-line ANSI-like declaration - unshift @line, $2 - if $process_argtypes - and $ret_type =~ s/^(.*?\w.*?)\s*\b(\w+\s*\(.*)/$1/s; + unshift @{ $self->{line} }, $2 + if $self->{argtypes} + and $self->{ret_type} =~ s/^(.*?\w.*?)\s*\b(\w+\s*\(.*)/$1/s; # a function definition needs at least 2 lines - blurt ("Error: Function definition too short '$ret_type'"), next PARAGRAPH - unless @line ; + $self->blurt("Error: Function definition too short '$self->{ret_type}'"), next PARAGRAPH + unless @{ $self->{line} }; - $externC = 1 if $ret_type =~ s/^extern "C"\s+//; - $static = 1 if $ret_type =~ s/^static\s+//; + my $externC = 1 if $self->{ret_type} =~ s/^extern "C"\s+//; + my $static = 1 if $self->{ret_type} =~ s/^static\s+//; - $func_header = shift(@line); - blurt ("Error: Cannot parse function definition from '$func_header'"), next PARAGRAPH + my $func_header = shift(@{ $self->{line} }); + $self->blurt("Error: Cannot parse function definition from '$func_header'"), next PARAGRAPH unless $func_header =~ /^(?:([\w:]*)::)?(\w+)\s*\(\s*(.*?)\s*\)\s*(const)?\s*(;\s*)?$/s; - ($class, $func_name, $orig_args) = ($1, $2, $3) ; + my ($class, $orig_args); + ($class, $func_name, $orig_args) = ($1, $2, $3); $class = "$4 $class" if $4; - ($pname = $func_name) =~ s/^($Prefix)?/$Packprefix/; - ($clean_func_name = $func_name) =~ s/^$Prefix//; - $Full_func_name = "${Packid}_$clean_func_name"; + ($pname = $func_name) =~ s/^($self->{Prefix})?/$self->{Packprefix}/; + my $clean_func_name; + ($clean_func_name = $func_name) =~ s/^$self->{Prefix}//; + $Full_func_name = "$self->{Packid}_$clean_func_name"; if ($Is_VMS) { $Full_func_name = $SymSet->addsym($Full_func_name); } # Check for duplicate function definition - for my $tmp (@XSStack) { + for my $tmp (@{ $self->{XSStack} }) { next unless defined $tmp->{functions}{$Full_func_name}; - Warn("Warning: duplicate function definition '$clean_func_name' detected"); + Warn( $self, "Warning: duplicate function definition '$clean_func_name' detected"); last; } - $XSStack[$XSS_work_idx]{functions}{$Full_func_name} ++ ; - %XsubAliases = %XsubAliasValues = %Interfaces = @Attributes = (); - $DoSetMagic = 1; - - $orig_args =~ s/\\\s*/ /g; # process line continuations + $self->{XSStack}->[$XSS_work_idx]{functions}{$Full_func_name}++; + %{ $self->{XsubAliases} } = (); + %{ $self->{XsubAliasValues} } = (); + %{ $self->{Interfaces} } = (); + @{ $self->{Attributes} } = (); + $self->{DoSetMagic} = 1; + + $orig_args =~ s/\\\s*/ /g; # process line continuations my @args; - my %only_C_inlist; # Not in the signature of Perl function - if ($process_argtypes and $orig_args =~ /\S/) { + my (@fake_INPUT_pre); # For length(s) generated variables + my (@fake_INPUT); + my $only_C_inlist_ref = {}; # Not in the signature of Perl function + if ($self->{argtypes} and $orig_args =~ /\S/) { my $args = "$orig_args ,"; if ($args =~ /^( (??{ $C_arg }) , )* $ /x) { - @args = ($args =~ /\G ( (??{ $C_arg }) ) , /xg); - for ( @args ) { - s/^\s+//; - s/\s+$//; - my ($arg, $default) = / ( [^=]* ) ( (?: = .* )? ) /x; - my ($pre, $name) = ($arg =~ /(.*?) \s* - \b ( \w+ | length\( \s*\w+\s* \) ) - \s* $ /x); - next unless defined($pre) && length($pre); - my $out_type = ''; - my $inout_var; - if ($process_inout and s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//) { - my $type = $1; - $out_type = $type if $type ne 'IN'; - $arg =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; - $pre =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; - } - my $islength; - if ($name =~ /^length\( \s* (\w+) \s* \)\z/x) { - $name = "XSauto_length_of_$1"; - $islength = 1; - die "Default value on length() argument: `$_'" - if length $default; - } - if (length $pre or $islength) { # Has a type - if ($islength) { - push @fake_INPUT_pre, $arg; - } else { - push @fake_INPUT, $arg; - } - # warn "pushing '$arg'\n"; - $argtype_seen{$name}++; - $_ = "$name$default"; # Assigns to @args - } - $only_C_inlist{$_} = 1 if $out_type eq "OUTLIST" or $islength; - push @outlist, $name if $out_type =~ /OUTLIST$/; - $in_out{$name} = $out_type if $out_type; - } - } else { - @args = split(/\s*,\s*/, $orig_args); - Warn("Warning: cannot parse argument list '$orig_args', fallback to split"); + @args = ($args =~ /\G ( (??{ $C_arg }) ) , /xg); + for ( @args ) { + s/^\s+//; + s/\s+$//; + my ($arg, $default) = ($_ =~ m/ ( [^=]* ) ( (?: = .* )? ) /x); + my ($pre, $len_name) = ($arg =~ /(.*?) \s* + \b ( \w+ | length\( \s*\w+\s* \) ) + \s* $ /x); + next unless defined($pre) && length($pre); + my $out_type = ''; + my $inout_var; + if ($self->{inout} and s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//) { + my $type = $1; + $out_type = $type if $type ne 'IN'; + $arg =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; + $pre =~ s/^(IN|IN_OUTLIST|OUTLIST|OUT|IN_OUT)\b\s*//; + } + my $islength; + if ($len_name =~ /^length\( \s* (\w+) \s* \)\z/x) { + $len_name = "XSauto_length_of_$1"; + $islength = 1; + die "Default value on length() argument: '$_'" + if length $default; + } + if (length $pre or $islength) { # Has a type + if ($islength) { + push @fake_INPUT_pre, $arg; + } + else { + push @fake_INPUT, $arg; + } + # warn "pushing '$arg'\n"; + $self->{argtype_seen}->{$len_name}++; + $_ = "$len_name$default"; # Assigns to @args + } + $only_C_inlist_ref->{$_} = 1 if $out_type eq "OUTLIST" or $islength; + push @{ $outlist_ref }, $len_name if $out_type =~ /OUTLIST$/; + $self->{in_out}->{$len_name} = $out_type if $out_type; + } + } + else { + @args = split(/\s*,\s*/, $orig_args); + Warn( $self, "Warning: cannot parse argument list '$orig_args', fallback to split"); } - } else { + } + else { @args = split(/\s*,\s*/, $orig_args); for (@args) { - if ($process_inout and s/^(IN|IN_OUTLIST|OUTLIST|IN_OUT|OUT)\b\s*//) { - my $out_type = $1; - next if $out_type eq 'IN'; - $only_C_inlist{$_} = 1 if $out_type eq "OUTLIST"; - push @outlist, $name if $out_type =~ /OUTLIST$/; - $in_out{$_} = $out_type; - } + if ($self->{inout} and s/^(IN|IN_OUTLIST|OUTLIST|IN_OUT|OUT)\b\s*//) { + my $out_type = $1; + next if $out_type eq 'IN'; + $only_C_inlist_ref->{$_} = 1 if $out_type eq "OUTLIST"; + if ($out_type =~ /OUTLIST$/) { + push @{ $outlist_ref }, undef; + } + $self->{in_out}->{$_} = $out_type; + } } } if (defined($class)) { my $arg0 = ((defined($static) or $func_name eq 'new') - ? "CLASS" : "THIS"); + ? "CLASS" : "THIS"); unshift(@args, $arg0); } my $extra_args = 0; - @args_num = (); - $num_args = 0; + my @args_num = (); + my $num_args = 0; my $report_args = ''; + my $ellipsis; foreach my $i (0 .. $#args) { if ($args[$i] =~ s/\.\.\.//) { - $ellipsis = 1; - if ($args[$i] eq '' && $i == $#args) { - $report_args .= ", ..."; - pop(@args); - last; - } + $ellipsis = 1; + if ($args[$i] eq '' && $i == $#args) { + $report_args .= ", ..."; + pop(@args); + last; + } + } + if ($only_C_inlist_ref->{$args[$i]}) { + push @args_num, undef; } - if ($only_C_inlist{$args[$i]}) { - push @args_num, undef; - } else { - push @args_num, ++$num_args; - $report_args .= ", $args[$i]"; + else { + push @args_num, ++$num_args; + $report_args .= ", $args[$i]"; } if ($args[$i] =~ /^([^=]*[^\s=])\s*=\s*(.*)/s) { - $extra_args++; - $args[$i] = $1; - $defaults{$args[$i]} = $2; - $defaults{$args[$i]} =~ s/"/\\"/g; + $extra_args++; + $args[$i] = $1; + $self->{defaults}->{$args[$i]} = $2; + $self->{defaults}->{$args[$i]} =~ s/"/\\"/g; } - $proto_arg[$i+1] = '$' ; + $self->{proto_arg}->[$i+1] = '$'; } - $min_args = $num_args - $extra_args; + my $min_args = $num_args - $extra_args; $report_args =~ s/"/\\"/g; $report_args =~ s/^,\s+//; - my @func_args = @args; - shift @func_args if defined($class); - - for (@func_args) { - s/^/&/ if $in_out{$_}; - } - $func_args = join(", ", @func_args); - @args_match{@args} = @args_num; + $self->{func_args} = assign_func_args($self, \@args, $class); + @{ $self->{args_match} }{@args} = @args_num; - $PPCODE = grep(/^\s*PPCODE\s*:/, @line); - $CODE = grep(/^\s*CODE\s*:/, @line); + my $PPCODE = grep(/^\s*PPCODE\s*:/, @{ $self->{line} }); + my $CODE = grep(/^\s*CODE\s*:/, @{ $self->{line} }); # Detect CODE: blocks which use ST(n)= or XST_m*(n,v) - # to set explicit return values. - $EXPLICIT_RETURN = ($CODE && - ("@line" =~ /(\bST\s*\([^;]*=) | (\bXST_m\w+\s*\()/x )); - $ALIAS = grep(/^\s*ALIAS\s*:/, @line); - $INTERFACE = grep(/^\s*INTERFACE\s*:/, @line); + # to set explicit return values. + my $EXPLICIT_RETURN = ($CODE && + ("@{ $self->{line} }" =~ /(\bST\s*\([^;]*=) | (\bXST_m\w+\s*\()/x )); + + # The $ALIAS which follows is only explicitly called within the scope of + # process_file(). In principle, it ought to be a lexical, i.e., 'my + # $ALIAS' like the other nearby variables. However, implementing that + # change produced a slight difference in the resulting .c output in at + # least two distributions: B/BD/BDFOY/Crypt-Rijndael and + # G/GF/GFUJI/Hash-FieldHash. The difference is, arguably, an improvement + # in the resulting C code. Example: + # 388c388 + # < GvNAME(CvGV(cv)), + # --- + # > "Crypt::Rijndael::encrypt", + # But at this point we're committed to generating the *same* C code that + # the current version of ParseXS.pm does. So we're declaring it as 'our'. + $ALIAS = grep(/^\s*ALIAS\s*:/, @{ $self->{line} }); + + my $INTERFACE = grep(/^\s*INTERFACE\s*:/, @{ $self->{line} }); $xsreturn = 1 if $EXPLICIT_RETURN; @@ -624,40 +505,32 @@ EOF # print function header print Q(<<"EOF"); #$externC -#XS(XS_${Full_func_name}); /* prototype to pass -Wmissing-prototypes */ -#XS(XS_${Full_func_name}) +#XS_EUPXS(XS_${Full_func_name}); /* prototype to pass -Wmissing-prototypes */ +#XS_EUPXS(XS_${Full_func_name}) #[[ -##ifdef dVAR # dVAR; dXSARGS; -##else -# dXSARGS; -##endif EOF - print Q(<<"EOF") if $ALIAS ; + print Q(<<"EOF") if $ALIAS; # dXSI32; EOF - print Q(<<"EOF") if $INTERFACE ; -# dXSFUNCTION($ret_type); + print Q(<<"EOF") if $INTERFACE; +# dXSFUNCTION($self->{ret_type}); EOF - if ($ellipsis) { - $cond = ($min_args ? qq(items < $min_args) : 0); - } elsif ($min_args == $num_args) { - $cond = qq(items != $min_args); - } else { - $cond = qq(items < $min_args || items > $num_args); - } - print Q(<<"EOF") if $except; + $self->{cond} = set_cond($ellipsis, $min_args, $num_args); + + print Q(<<"EOF") if $self->{except}; # char errbuf[1024]; -# *errbuf = '\0'; +# *errbuf = '\\0'; EOF - if($cond) { - print Q(<<"EOF"); -# if ($cond) + if($self->{cond}) { + print Q(<<"EOF"); +# if ($self->{cond}) # croak_xs_usage(cv, "$report_args"); EOF - } else { + } + else { # cv likely to be unused print Q(<<"EOF"); # PERL_UNUSED_VAR(cv); /* -W */ @@ -666,7 +539,7 @@ EOF #gcc -Wall: if an xsub has PPCODE is used #it is possible none of ST, XSRETURN or XSprePUSH macros are used - #hence `ax' (setup by dXSARGS) is unused + #hence 'ax' (setup by dXSARGS) is unused #XXX: could breakup the dXSARGS; into dSP;dMARK;dITEMS #but such a move could break third-party extensions print Q(<<"EOF") if $PPCODE; @@ -679,199 +552,258 @@ EOF # Now do a block of some sort. - $condnum = 0; - $cond = ''; # last CASE: conditional - push(@line, "$END:"); - push(@line_no, $line_no[-1]); + $self->{condnum} = 0; + $self->{cond} = ''; # last CASE: conditional + push(@{ $self->{line} }, "$END:"); + push(@{ $self->{line_no} }, $self->{line_no}->[-1]); $_ = ''; - &check_cpp; - while (@line) { - &CASE_handler if check_keyword("CASE"); + check_conditional_preprocessor_statements(); + while (@{ $self->{line} }) { + + $self->CASE_handler($_) if $self->check_keyword("CASE"); print Q(<<"EOF"); -# $except [[ +# $self->{except} [[ EOF # do initialization of input variables - $thisdone = 0; - $retvaldone = 0; - $deferred = ""; - %arg_list = () ; - $gotRETVAL = 0; - - INPUT_handler() ; - process_keyword("INPUT|PREINIT|INTERFACE_MACRO|C_ARGS|ALIAS|ATTRS|PROTOTYPE|SCOPE|OVERLOAD") ; - - print Q(<<"EOF") if $ScopeThisXSUB; + $self->{thisdone} = 0; + $self->{retvaldone} = 0; + $self->{deferred} = ""; + %{ $self->{arg_list} } = (); + $self->{gotRETVAL} = 0; + $self->INPUT_handler($_); + $self->process_keyword("INPUT|PREINIT|INTERFACE_MACRO|C_ARGS|ALIAS|ATTRS|PROTOTYPE|SCOPE|OVERLOAD"); + + print Q(<<"EOF") if $self->{ScopeThisXSUB}; # ENTER; # [[ EOF - - if (!$thisdone && defined($class)) { - if (defined($static) or $func_name eq 'new') { - print "\tchar *"; - $var_types{"CLASS"} = "char *"; - &generate_init("char *", 1, "CLASS"); - } - else { - print "\t$class *"; - $var_types{"THIS"} = "$class *"; - &generate_init("$class *", 1, "THIS"); - } + + if (!$self->{thisdone} && defined($class)) { + if (defined($static) or $func_name eq 'new') { + print "\tchar *"; + $self->{var_types}->{"CLASS"} = "char *"; + generate_init( { + type => "char *", + num => 1, + var => "CLASS", + printed_name => undef, + } ); + } + else { + print "\t$class *"; + $self->{var_types}->{"THIS"} = "$class *"; + generate_init( { + type => "$class *", + num => 1, + var => "THIS", + printed_name => undef, + } ); + } } - + + # These are set if OUTPUT is found and/or CODE using RETVAL + $self->{have_OUTPUT} = $self->{have_CODE_with_RETVAL} = 0; + + my ($wantRETVAL); # do code if (/^\s*NOT_IMPLEMENTED_YET/) { - print "\n\tPerl_croak(aTHX_ \"$pname: not implemented yet\");\n"; - $_ = '' ; - } else { - if ($ret_type ne "void") { - print "\t" . &map_type($ret_type, 'RETVAL') . ";\n" - if !$retvaldone; - $args_match{"RETVAL"} = 0; - $var_types{"RETVAL"} = $ret_type; - print "\tdXSTARG;\n" - if $WantOptimize and $targetable{$type_kind{$ret_type}}; - } - - if (@fake_INPUT or @fake_INPUT_pre) { - unshift @line, @fake_INPUT_pre, @fake_INPUT, $_; - $_ = ""; - $processing_arg_with_types = 1; - INPUT_handler() ; - } - print $deferred; - - process_keyword("INIT|ALIAS|ATTRS|PROTOTYPE|INTERFACE_MACRO|INTERFACE|C_ARGS|OVERLOAD") ; - - if (check_keyword("PPCODE")) { - print_section(); - death ("PPCODE must be last thing") if @line; - print "\tLEAVE;\n" if $ScopeThisXSUB; - print "\tPUTBACK;\n\treturn;\n"; - } elsif (check_keyword("CODE")) { - print_section() ; - } elsif (defined($class) and $func_name eq "DESTROY") { - print "\n\t"; - print "delete THIS;\n"; - } else { - print "\n\t"; - if ($ret_type ne "void") { - print "RETVAL = "; - $wantRETVAL = 1; - } - if (defined($static)) { - if ($func_name eq 'new') { - $func_name = "$class"; - } else { - print "${class}::"; - } - } elsif (defined($class)) { - if ($func_name eq 'new') { - $func_name .= " $class"; - } else { - print "THIS->"; - } - } - $func_name =~ s/^\Q$args{'s'}// - if exists $args{'s'}; - $func_name = 'XSFUNCTION' if $interface; - print "$func_name($func_args);\n"; - } + print "\n\tPerl_croak(aTHX_ \"$pname: not implemented yet\");\n"; + $_ = ''; } - + else { + if ($self->{ret_type} ne "void") { + print "\t" . map_type($self, $self->{ret_type}, 'RETVAL') . ";\n" + if !$self->{retvaldone}; + $self->{args_match}->{"RETVAL"} = 0; + $self->{var_types}->{"RETVAL"} = $self->{ret_type}; + my $outputmap = $self->{typemap}->get_outputmap( ctype => $self->{ret_type} ); + print "\tdXSTARG;\n" + if $self->{optimize} and $outputmap and $outputmap->targetable; + } + + if (@fake_INPUT or @fake_INPUT_pre) { + unshift @{ $self->{line} }, @fake_INPUT_pre, @fake_INPUT, $_; + $_ = ""; + $self->{processing_arg_with_types} = 1; + $self->INPUT_handler($_); + } + print $self->{deferred}; + + $self->process_keyword("INIT|ALIAS|ATTRS|PROTOTYPE|INTERFACE_MACRO|INTERFACE|C_ARGS|OVERLOAD"); + + if ($self->check_keyword("PPCODE")) { + $self->print_section(); + $self->death("PPCODE must be last thing") if @{ $self->{line} }; + print "\tLEAVE;\n" if $self->{ScopeThisXSUB}; + print "\tPUTBACK;\n\treturn;\n"; + } + elsif ($self->check_keyword("CODE")) { + my $consumed_code = $self->print_section(); + if ($consumed_code =~ /\bRETVAL\b/) { + $self->{have_CODE_with_RETVAL} = 1; + } + } + elsif (defined($class) and $func_name eq "DESTROY") { + print "\n\t"; + print "delete THIS;\n"; + } + else { + print "\n\t"; + if ($self->{ret_type} ne "void") { + print "RETVAL = "; + $wantRETVAL = 1; + } + if (defined($static)) { + if ($func_name eq 'new') { + $func_name = "$class"; + } + else { + print "${class}::"; + } + } + elsif (defined($class)) { + if ($func_name eq 'new') { + $func_name .= " $class"; + } + else { + print "THIS->"; + } + } + $func_name =~ s/^\Q$args{'s'}// + if exists $args{'s'}; + $func_name = 'XSFUNCTION' if $self->{interface}; + print "$func_name($self->{func_args});\n"; + } + } + # do output variables - $gotRETVAL = 0; # 1 if RETVAL seen in OUTPUT section; - undef $RETVAL_code ; # code to set RETVAL (from OUTPUT section); + $self->{gotRETVAL} = 0; # 1 if RETVAL seen in OUTPUT section; + undef $self->{RETVAL_code} ; # code to set RETVAL (from OUTPUT section); # $wantRETVAL set if 'RETVAL =' autogenerated - ($wantRETVAL, $ret_type) = (0, 'void') if $RETVAL_no_return; - undef %outargs ; - process_keyword("POSTCALL|OUTPUT|ALIAS|ATTRS|PROTOTYPE|OVERLOAD"); - - &generate_output($var_types{$_}, $args_match{$_}, $_, $DoSetMagic) - for grep $in_out{$_} =~ /OUT$/, keys %in_out; - + ($wantRETVAL, $self->{ret_type}) = (0, 'void') if $RETVAL_no_return; + undef %{ $self->{outargs} }; + + $self->process_keyword("POSTCALL|OUTPUT|ALIAS|ATTRS|PROTOTYPE|OVERLOAD"); + + # A CODE section with RETVAL, but no OUTPUT? FAIL! + if ($self->{have_CODE_with_RETVAL} and not $self->{have_OUTPUT} and $self->{ret_type} ne 'void') { + $self->Warn("Warning: Found a 'CODE' section which seems to be using 'RETVAL' but no 'OUTPUT' section."); + } + + generate_output( { + type => $self->{var_types}->{$_}, + num => $self->{args_match}->{$_}, + var => $_, + do_setmagic => $self->{DoSetMagic}, + do_push => undef, + } ) for grep $self->{in_out}->{$_} =~ /OUT$/, keys %{ $self->{in_out} }; + + my $prepush_done; # all OUTPUT done, so now push the return value on the stack - if ($gotRETVAL && $RETVAL_code) { - print "\t$RETVAL_code\n"; - } elsif ($gotRETVAL || $wantRETVAL) { - my $t = $WantOptimize && $targetable{$type_kind{$ret_type}}; - my $var = 'RETVAL'; - my $type = $ret_type; - - # 0: type, 1: with_size, 2: how, 3: how_size - if ($t and not $t->[1] and $t->[0] eq 'p') { - # PUSHp corresponds to setpvn. Treat setpv directly - my $what = eval qq("$t->[2]"); - warn $@ if $@; - - print "\tsv_setpv(TARG, $what); XSprePUSH; PUSHTARG;\n"; - $prepush_done = 1; - } - elsif ($t) { - my $what = eval qq("$t->[2]"); - warn $@ if $@; - - my $size = $t->[3]; - $size = '' unless defined $size; - $size = eval qq("$size"); - warn $@ if $@; - print "\tXSprePUSH; PUSH$t->[0]($what$size);\n"; - $prepush_done = 1; - } - else { - # RETVAL almost never needs SvSETMAGIC() - &generate_output($ret_type, 0, 'RETVAL', 0); - } + if ($self->{gotRETVAL} && $self->{RETVAL_code}) { + print "\t$self->{RETVAL_code}\n"; + } + elsif ($self->{gotRETVAL} || $wantRETVAL) { + my $outputmap = $self->{typemap}->get_outputmap( ctype => $self->{ret_type} ); + my $t = $self->{optimize} && $outputmap && $outputmap->targetable; + # Although the '$var' declared in the next line is never explicitly + # used within this 'elsif' block, commenting it out leads to + # disaster, starting with the first 'eval qq' inside the 'elsif' block + # below. + # It appears that this is related to the fact that at this point the + # value of $t is a reference to an array whose [2] element includes + # '$var' as a substring: + # <i> <> <(IV)$var> + my $var = 'RETVAL'; + my $type = $self->{ret_type}; + + if ($t and not $t->{with_size} and $t->{type} eq 'p') { + # PUSHp corresponds to setpvn. Treat setpv directly + my $what = eval qq("$t->{what}"); + warn $@ if $@; + + print "\tsv_setpv(TARG, $what); XSprePUSH; PUSHTARG;\n"; + $prepush_done = 1; + } + elsif ($t) { + my $what = eval qq("$t->{what}"); + warn $@ if $@; + + my $tsize = $t->{what_size}; + $tsize = '' unless defined $tsize; + $tsize = eval qq("$tsize"); + warn $@ if $@; + print "\tXSprePUSH; PUSH$t->{type}($what$tsize);\n"; + $prepush_done = 1; + } + else { + # RETVAL almost never needs SvSETMAGIC() + generate_output( { + type => $self->{ret_type}, + num => 0, + var => 'RETVAL', + do_setmagic => 0, + do_push => undef, + } ); + } } - - $xsreturn = 1 if $ret_type ne "void"; + + $xsreturn = 1 if $self->{ret_type} ne "void"; my $num = $xsreturn; - my $c = @outlist; + my $c = @{ $outlist_ref }; print "\tXSprePUSH;" if $c and not $prepush_done; print "\tEXTEND(SP,$c);\n" if $c; $xsreturn += $c; - generate_output($var_types{$_}, $num++, $_, 0, 1) for @outlist; - + generate_output( { + type => $self->{var_types}->{$_}, + num => $num++, + var => $_, + do_setmagic => 0, + do_push => 1, + } ) for @{ $outlist_ref }; + # do cleanup - process_keyword("CLEANUP|ALIAS|ATTRS|PROTOTYPE|OVERLOAD") ; - - print Q(<<"EOF") if $ScopeThisXSUB; + $self->process_keyword("CLEANUP|ALIAS|ATTRS|PROTOTYPE|OVERLOAD"); + + print Q(<<"EOF") if $self->{ScopeThisXSUB}; # ]] EOF - print Q(<<"EOF") if $ScopeThisXSUB and not $PPCODE; + print Q(<<"EOF") if $self->{ScopeThisXSUB} and not $PPCODE; # LEAVE; EOF - + # print function trailer print Q(<<"EOF"); # ]] EOF - print Q(<<"EOF") if $except; + print Q(<<"EOF") if $self->{except}; # BEGHANDLERS # CATCHALL -# sprintf(errbuf, "%s: %s\\tpropagated", Xname, Xreason); +# sprintf(errbuf, "%s: %s\\tpropagated", Xname, Xreason); # ENDHANDLERS EOF - if (check_keyword("CASE")) { - blurt ("Error: No `CASE:' at top of function") - unless $condnum; - $_ = "CASE: $_"; # Restore CASE: label - next; + if ($self->check_keyword("CASE")) { + $self->blurt("Error: No 'CASE:' at top of function") + unless $self->{condnum}; + $_ = "CASE: $_"; # Restore CASE: label + next; } last if $_ eq "$END:"; - death(/^$BLOCK_re/o ? "Misplaced `$1:'" : "Junk at end of function ($_)"); + $self->death(/^$self->{BLOCK_re}/o ? "Misplaced '$1:'" : "Junk at end of function ($_)"); } - - print Q(<<"EOF") if $except; + + print Q(<<"EOF") if $self->{except}; # if (errbuf[0]) -# Perl_croak(aTHX_ errbuf); +# Perl_croak(aTHX_ errbuf); EOF - + if ($xsreturn) { print Q(<<"EOF") unless $PPCODE; # XSRETURN($xsreturn); EOF - } else { + } + else { print Q(<<"EOF") unless $PPCODE; # XSRETURN_EMPTY; EOF @@ -882,85 +814,84 @@ EOF # EOF - our $newXS = "newXS" ; - our $proto = "" ; - + $self->{newXS} = "newXS"; + $self->{proto} = ""; + # Build the prototype string for the xsub - if ($ProtoThisXSUB) { - $newXS = "newXSproto_portable"; - - if ($ProtoThisXSUB eq 2) { - # User has specified empty prototype + if ($self->{ProtoThisXSUB}) { + $self->{newXS} = "newXSproto_portable"; + + if ($self->{ProtoThisXSUB} eq 2) { + # User has specified empty prototype } - elsif ($ProtoThisXSUB eq 1) { - my $s = ';'; - if ($min_args < $num_args) { - $s = ''; - $proto_arg[$min_args] .= ";" ; - } - push @proto_arg, "$s\@" - if $ellipsis ; - - $proto = join ("", grep defined, @proto_arg); + elsif ($self->{ProtoThisXSUB} eq 1) { + my $s = ';'; + if ($min_args < $num_args) { + $s = ''; + $self->{proto_arg}->[$min_args] .= ";"; + } + push @{ $self->{proto_arg} }, "$s\@" + if $ellipsis; + + $self->{proto} = join ("", grep defined, @{ $self->{proto_arg} } ); } else { - # User has specified a prototype - $proto = $ProtoThisXSUB; + # User has specified a prototype + $self->{proto} = $self->{ProtoThisXSUB}; } - $proto = qq{, "$proto"}; + $self->{proto} = qq{, "$self->{proto}"}; } - if (%XsubAliases) { - $XsubAliases{$pname} = 0 - unless defined $XsubAliases{$pname} ; - while ( ($name, $value) = each %XsubAliases) { - push(@InitFileCode, Q(<<"EOF")); -# cv = ${newXS}(\"$name\", XS_$Full_func_name, file$proto); -# XSANY.any_i32 = $value ; + if (%{ $self->{XsubAliases} }) { + $self->{XsubAliases}->{$pname} = 0 + unless defined $self->{XsubAliases}->{$pname}; + while ( my ($xname, $value) = each %{ $self->{XsubAliases} }) { + push(@{ $self->{InitFileCode} }, Q(<<"EOF")); +# cv = $self->{newXS}(\"$xname\", XS_$Full_func_name, file$self->{proto}); +# XSANY.any_i32 = $value; EOF } } - elsif (@Attributes) { - push(@InitFileCode, Q(<<"EOF")); -# cv = ${newXS}(\"$pname\", XS_$Full_func_name, file$proto); -# apply_attrs_string("$Package", cv, "@Attributes", 0); + elsif (@{ $self->{Attributes} }) { + push(@{ $self->{InitFileCode} }, Q(<<"EOF")); +# cv = $self->{newXS}(\"$pname\", XS_$Full_func_name, file$self->{proto}); +# apply_attrs_string("$Package", cv, "@{ $self->{Attributes} }", 0); EOF } - elsif ($interface) { - while ( ($name, $value) = each %Interfaces) { - $name = "$Package\::$name" unless $name =~ /::/; - push(@InitFileCode, Q(<<"EOF")); -# cv = ${newXS}(\"$name\", XS_$Full_func_name, file$proto); -# $interface_macro_set(cv,$value) ; + elsif ($self->{interface}) { + while ( my ($yname, $value) = each %{ $self->{Interfaces} }) { + $yname = "$Package\::$yname" unless $yname =~ /::/; + push(@{ $self->{InitFileCode} }, Q(<<"EOF")); +# cv = $self->{newXS}(\"$yname\", XS_$Full_func_name, file$self->{proto}); +# $self->{interface_macro_set}(cv,$value); EOF } } - elsif($newXS eq 'newXS'){ # work around P5NCI's empty newXS macro - push(@InitFileCode, - " ${newXS}(\"$pname\", XS_$Full_func_name, file$proto);\n"); + elsif($self->{newXS} eq 'newXS'){ # work around P5NCI's empty newXS macro + push(@{ $self->{InitFileCode} }, + " $self->{newXS}(\"$pname\", XS_$Full_func_name, file$self->{proto});\n"); } else { - push(@InitFileCode, - " (void)${newXS}(\"$pname\", XS_$Full_func_name, file$proto);\n"); + push(@{ $self->{InitFileCode} }, + " (void)$self->{newXS}(\"$pname\", XS_$Full_func_name, file$self->{proto});\n"); } - } + } # END 'PARAGRAPH' 'while' loop - if ($Overload) # make it findable with fetchmethod - { + if ($self->{Overload}) { # make it findable with fetchmethod print Q(<<"EOF"); -#XS(XS_${Packid}_nil); /* prototype to pass -Wmissing-prototypes */ -#XS(XS_${Packid}_nil) +#XS_EUPXS(XS_$self->{Packid}_nil); /* prototype to pass -Wmissing-prototypes */ +#XS_EUPXS(XS_$self->{Packid}_nil) #{ # dXSARGS; # XSRETURN_EMPTY; #} # EOF - unshift(@InitFileCode, <<"MAKE_FETCHMETHOD_WORK"); + unshift(@{ $self->{InitFileCode} }, <<"MAKE_FETCHMETHOD_WORK"); /* Making a sub named "${Package}::()" allows the package */ /* to be findable via fetchmethod(), and causes */ /* overload::Overloaded("${Package}") to return true. */ - (void)${newXS}("${Package}::()", XS_${Packid}_nil, file$proto); + (void)$self->{newXS}("${Package}::()", XS_$self->{Packid}_nil, file$self->{proto}); MAKE_FETCHMETHOD_WORK } @@ -973,24 +904,20 @@ MAKE_FETCHMETHOD_WORK EOF print Q(<<"EOF"); -#XS(boot_$Module_cname); /* prototype to pass -Wmissing-prototypes */ -#XS(boot_$Module_cname) +#XS_EXTERNAL(boot_$self->{Module_cname}); /* prototype to pass -Wmissing-prototypes */ +#XS_EXTERNAL(boot_$self->{Module_cname}) EOF print Q(<<"EOF"); #[[ -##ifdef dVAR # dVAR; dXSARGS; -##else -# dXSARGS; -##endif EOF #Under 5.8.x and lower, newXS is declared in proto.h as expecting a non-const #file name argument. If the wrong qualifier is used, it causes breakage with #C++ compilers and warnings with recent gcc. #-Wall: if there is no $Full_func_name there are no xsubs in this .xs - #so `file' is unused + #so 'file' is unused print Q(<<"EOF") if $Full_func_name; ##if (PERL_REVISION == 5 && PERL_VERSION < 9) # char* file = __FILE__; @@ -1009,18 +936,18 @@ EOF ##endif EOF - print Q(<<"EOF") if $WantVersionChk ; -# XS_VERSION_BOOTCHECK ; + print Q(<<"EOF") if $self->{WantVersionChk}; +# XS_VERSION_BOOTCHECK; # EOF - print Q(<<"EOF") if defined $XsubAliases or defined $Interfaces ; + print Q(<<"EOF") if defined $self->{xsubaliases} or defined $self->{interfaces}; # { -# CV * cv ; +# CV * cv; # EOF - print Q(<<"EOF") if ($Overload); + print Q(<<"EOF") if ($self->{Overload}); # /* register the overloading (type 'A') magic */ # PL_amagic_generation++; # /* The magic for overload gets a GV* via gv_fetchmeth as */ @@ -1028,22 +955,21 @@ EOF # /* the "fallback" status. */ # sv_setsv( # get_sv( "${Package}::()", TRUE ), -# $Fallback +# $self->{Fallback} # ); EOF - print @InitFileCode; + print @{ $self->{InitFileCode} }; - print Q(<<"EOF") if defined $XsubAliases or defined $Interfaces ; + print Q(<<"EOF") if defined $self->{xsubaliases} or defined $self->{interfaces}; # } EOF - if (@BootCode) - { - print "\n /* Initialisation Section */\n\n" ; - @line = @BootCode; - print_section(); - print "\n /* End of Initialisation Section */\n\n" ; + if (@{ $BootCode_ref }) { + print "\n /* Initialisation Section */\n\n"; + @{ $self->{line} } = @{ $BootCode_ref }; + $self->print_section(); + print "\n /* End of Initialisation Section */\n\n"; } print Q(<<'EOF'); @@ -1059,654 +985,682 @@ EOF # EOF - warn("Please specify prototyping behavior for $filename (see perlxs manual)\n") - unless $ProtoUsed ; + warn("Please specify prototyping behavior for $self->{filename} (see perlxs manual)\n") + unless $self->{ProtoUsed}; chdir($orig_cwd); select($orig_fh); untie *PSEUDO_STDOUT if tied *PSEUDO_STDOUT; - close $FH; + close $self->{FH}; return 1; } -sub errors { $errors } - -sub standard_typemap_locations { - # Add all the default typemap locations to the search path - my @tm = qw(typemap); - - my $updir = File::Spec->updir; - foreach my $dir (File::Spec->catdir(($updir) x 1), File::Spec->catdir(($updir) x 2), - File::Spec->catdir(($updir) x 3), File::Spec->catdir(($updir) x 4)) { - - unshift @tm, File::Spec->catfile($dir, 'typemap'); - unshift @tm, File::Spec->catfile($dir, lib => ExtUtils => 'typemap'); - } - foreach my $dir (@INC) { - my $file = File::Spec->catfile($dir, ExtUtils => 'typemap'); - unshift @tm, $file if -e $file; - } - return @tm; -} - -sub TrimWhitespace -{ - $_[0] =~ s/^\s+|\s+$//go ; -} - -sub TidyType - { - local ($_) = @_ ; - - # rationalise any '*' by joining them into bunches and removing whitespace - s#\s*(\*+)\s*#$1#g; - s#(\*+)# $1 #g ; - - # change multiple whitespace into a single space - s/\s+/ /g ; +sub report_error_count { $self->{errors} } - # trim leading & trailing whitespace - TrimWhitespace($_) ; - - $_ ; -} - -# Input: ($_, @line) == unparsed input. -# Output: ($_, @line) == (rest of line, following lines). +# Input: ($self, $_, @{ $self->{line} }) == unparsed input. +# Output: ($_, @{ $self->{line} }) == (rest of line, following lines). # Return: the matched keyword if found, otherwise 0 sub check_keyword { - $_ = shift(@line) while !/\S/ && @line; - s/^(\s*)($_[0])\s*:\s*(?:#.*)?/$1/s && $2; + my $self = shift; + $_ = shift(@{ $self->{line} }) while !/\S/ && @{ $self->{line} }; + s/^(\s*)($_[0])\s*:\s*(?:#.*)?/$1/s && $2; } sub print_section { - # the "do" is required for right semantics - do { $_ = shift(@line) } while !/\S/ && @line; + my $self = shift; - print("#line ", $line_no[@line_no - @line -1], " \"$filepathname\"\n") - if $WantLineNumbers && !/^\s*#\s*line\b/ && !/^#if XSubPPtmp/; - for (; defined($_) && !/^$BLOCK_re/o; $_ = shift(@line)) { - print "$_\n"; - } - print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $WantLineNumbers; + # the "do" is required for right semantics + do { $_ = shift(@{ $self->{line} }) } while !/\S/ && @{ $self->{line} }; + + my $consumed_code = ''; + + print("#line ", $self->{line_no}->[@{ $self->{line_no} } - @{ $self->{line} } -1], " \"", + escape_file_for_line_directive($self->{filepathname}), "\"\n") + if $self->{WantLineNumbers} && !/^\s*#\s*line\b/ && !/^#if XSubPPtmp/; + for (; defined($_) && !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + print "$_\n"; + $consumed_code .= "$_\n"; + } + print 'ExtUtils::ParseXS::CountLines'->end_marker, "\n" if $self->{WantLineNumbers}; + + return $consumed_code; } sub merge_section { - my $in = ''; + my $self = shift; + my $in = ''; - while (!/\S/ && @line) { - $_ = shift(@line); - } + while (!/\S/ && @{ $self->{line} }) { + $_ = shift(@{ $self->{line} }); + } - for (; defined($_) && !/^$BLOCK_re/o; $_ = shift(@line)) { - $in .= "$_\n"; - } - chomp $in; - return $in; + for (; defined($_) && !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + $in .= "$_\n"; } + chomp $in; + return $in; +} -sub process_keyword($) - { - my($pattern) = @_ ; - my $kwd ; +sub process_keyword { + my($self, $pattern) = @_; - &{"${kwd}_handler"}() - while $kwd = check_keyword($pattern) ; + while (my $kwd = $self->check_keyword($pattern)) { + my $method = $kwd . "_handler"; + $self->$method($_); } +} sub CASE_handler { - blurt ("Error: `CASE:' after unconditional `CASE:'") - if $condnum && $cond eq ''; - $cond = $_; - TrimWhitespace($cond); - print " ", ($condnum++ ? " else" : ""), ($cond ? " if ($cond)\n" : "\n"); - $_ = '' ; + my $self = shift; + $_ = shift; + $self->blurt("Error: 'CASE:' after unconditional 'CASE:'") + if $self->{condnum} && $self->{cond} eq ''; + $self->{cond} = $_; + trim_whitespace($self->{cond}); + print " ", ($self->{condnum}++ ? " else" : ""), ($self->{cond} ? " if ($self->{cond})\n" : "\n"); + $_ = ''; } sub INPUT_handler { - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + my $self = shift; + $_ = shift; + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { last if /^\s*NOT_IMPLEMENTED_YET/; - next unless /\S/; # skip blank lines + next unless /\S/; # skip blank lines - TrimWhitespace($_) ; - my $line = $_ ; + trim_whitespace($_); + my $ln = $_; # remove trailing semicolon if no initialisation - s/\s*;$//g unless /[=;+].*\S/ ; + s/\s*;$//g unless /[=;+].*\S/; # Process the length(foo) declarations if (s/^([^=]*)\blength\(\s*(\w+)\s*\)\s*$/$1 XSauto_length_of_$2=NO_INIT/x) { print "\tSTRLEN\tSTRLEN_length_of_$2;\n"; - $lengthof{$2} = $name; - # $islengthof{$name} = $1; - $deferred .= "\n\tXSauto_length_of_$2 = STRLEN_length_of_$2;\n"; + $self->{lengthof}->{$2} = undef; + $self->{deferred} .= "\n\tXSauto_length_of_$2 = STRLEN_length_of_$2;\n"; } # check for optional initialisation code - my $var_init = '' ; - $var_init = $1 if s/\s*([=;+].*)$//s ; + my $var_init = ''; + $var_init = $1 if s/\s*([=;+].*)$//s; $var_init =~ s/"/\\"/g; + # *sigh* It's valid to supply explicit input typemaps in the argument list... + my $is_overridden_typemap = $var_init =~ /ST\s*\(|\$arg\b/; s/\s+/ /g; my ($var_type, $var_addr, $var_name) = /^(.*?[^&\s])\s*(\&?)\s*\b(\w+)$/s - or blurt("Error: invalid argument declaration '$line'"), next; + or $self->blurt("Error: invalid argument declaration '$ln'"), next; # Check for duplicate definitions - blurt ("Error: duplicate definition of argument '$var_name' ignored"), next - if $arg_list{$var_name}++ - or defined $argtype_seen{$var_name} and not $processing_arg_with_types; + $self->blurt("Error: duplicate definition of argument '$var_name' ignored"), next + if $self->{arg_list}->{$var_name}++ + or defined $self->{argtype_seen}->{$var_name} and not $self->{processing_arg_with_types}; - $thisdone |= $var_name eq "THIS"; - $retvaldone |= $var_name eq "RETVAL"; - $var_types{$var_name} = $var_type; + $self->{thisdone} |= $var_name eq "THIS"; + $self->{retvaldone} |= $var_name eq "RETVAL"; + $self->{var_types}->{$var_name} = $var_type; # XXXX This check is a safeguard against the unfinished conversion of # generate_init(). When generate_init() is fixed, # one can use 2-args map_type() unconditionally. + my $printed_name; if ($var_type =~ / \( \s* \* \s* \) /x) { - # Function pointers are not yet supported with &output_init! - print "\t" . &map_type($var_type, $var_name); - $name_printed = 1; - } else { - print "\t" . &map_type($var_type); - $name_printed = 0; + # Function pointers are not yet supported with output_init()! + print "\t" . map_type($self, $var_type, $var_name); + $printed_name = 1; } - $var_num = $args_match{$var_name}; + else { + print "\t" . map_type($self, $var_type, undef); + $printed_name = 0; + } + $self->{var_num} = $self->{args_match}->{$var_name}; - $proto_arg[$var_num] = ProtoString($var_type) - if $var_num ; - $func_args =~ s/\b($var_name)\b/&$1/ if $var_addr; + if ($self->{var_num}) { + my $typemap = $self->{typemap}->get_typemap(ctype => $var_type); + $self->report_typemap_failure($self->{typemap}, $var_type, "death") + if not $typemap and not $is_overridden_typemap; + $self->{proto_arg}->[$self->{var_num}] = ($typemap && $typemap->proto) || "\$"; + } + $self->{func_args} =~ s/\b($var_name)\b/&$1/ if $var_addr; if ($var_init =~ /^[=;]\s*NO_INIT\s*;?\s*$/ - or $in_out{$var_name} and $in_out{$var_name} =~ /^OUT/ - and $var_init !~ /\S/) { - if ($name_printed) { - print ";\n"; - } else { - print "\t$var_name;\n"; + or $self->{in_out}->{$var_name} and $self->{in_out}->{$var_name} =~ /^OUT/ + and $var_init !~ /\S/) { + if ($printed_name) { + print ";\n"; } - } elsif ($var_init =~ /\S/) { - &output_init($var_type, $var_num, $var_name, $var_init, $name_printed); - } elsif ($var_num) { - # generate initialization code - &generate_init($var_type, $var_num, $var_name, $name_printed); - } else { + else { + print "\t$var_name;\n"; + } + } + elsif ($var_init =~ /\S/) { + output_init( { + type => $var_type, + num => $self->{var_num}, + var => $var_name, + init => $var_init, + printed_name => $printed_name, + } ); + } + elsif ($self->{var_num}) { + generate_init( { + type => $var_type, + num => $self->{var_num}, + var => $var_name, + printed_name => $printed_name, + } ); + } + else { print ";\n"; } } } sub OUTPUT_handler { - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + my $self = shift; + $self->{have_OUTPUT} = 1; + + $_ = shift; + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { next unless /\S/; if (/^\s*SETMAGIC\s*:\s*(ENABLE|DISABLE)\s*/) { - $DoSetMagic = ($1 eq "ENABLE" ? 1 : 0); + $self->{DoSetMagic} = ($1 eq "ENABLE" ? 1 : 0); next; } - my ($outarg, $outcode) = /^\s*(\S+)\s*(.*?)\s*$/s ; - blurt ("Error: duplicate OUTPUT argument '$outarg' ignored"), next - if $outargs{$outarg} ++ ; - if (!$gotRETVAL and $outarg eq 'RETVAL') { + my ($outarg, $outcode) = /^\s*(\S+)\s*(.*?)\s*$/s; + $self->blurt("Error: duplicate OUTPUT argument '$outarg' ignored"), next + if $self->{outargs}->{$outarg}++; + if (!$self->{gotRETVAL} and $outarg eq 'RETVAL') { # deal with RETVAL last - $RETVAL_code = $outcode ; - $gotRETVAL = 1 ; - next ; + $self->{RETVAL_code} = $outcode; + $self->{gotRETVAL} = 1; + next; } - blurt ("Error: OUTPUT $outarg not an argument"), next - unless defined($args_match{$outarg}); - blurt("Error: No input definition for OUTPUT argument '$outarg' - ignored"), next - unless defined $var_types{$outarg} ; - $var_num = $args_match{$outarg}; + $self->blurt("Error: OUTPUT $outarg not an argument"), next + unless defined($self->{args_match}->{$outarg}); + $self->blurt("Error: No input definition for OUTPUT argument '$outarg' - ignored"), next + unless defined $self->{var_types}->{$outarg}; + $self->{var_num} = $self->{args_match}->{$outarg}; if ($outcode) { print "\t$outcode\n"; - print "\tSvSETMAGIC(ST(" , $var_num-1 , "));\n" if $DoSetMagic; - } else { - &generate_output($var_types{$outarg}, $var_num, $outarg, $DoSetMagic); + print "\tSvSETMAGIC(ST(" , $self->{var_num} - 1 , "));\n" if $self->{DoSetMagic}; } - delete $in_out{$outarg} # No need to auto-OUTPUT - if exists $in_out{$outarg} and $in_out{$outarg} =~ /OUT$/; + else { + generate_output( { + type => $self->{var_types}->{$outarg}, + num => $self->{var_num}, + var => $outarg, + do_setmagic => $self->{DoSetMagic}, + do_push => undef, + } ); + } + delete $self->{in_out}->{$outarg} # No need to auto-OUTPUT + if exists $self->{in_out}->{$outarg} and $self->{in_out}->{$outarg} =~ /OUT$/; } } -sub C_ARGS_handler() { - my $in = merge_section(); +sub C_ARGS_handler { + my $self = shift; + $_ = shift; + my $in = $self->merge_section(); - TrimWhitespace($in); - $func_args = $in; + trim_whitespace($in); + $self->{func_args} = $in; } -sub INTERFACE_MACRO_handler() { - my $in = merge_section(); +sub INTERFACE_MACRO_handler { + my $self = shift; + $_ = shift; + my $in = $self->merge_section(); - TrimWhitespace($in); - if ($in =~ /\s/) { # two - ($interface_macro, $interface_macro_set) = split ' ', $in; - } else { - $interface_macro = $in; - $interface_macro_set = 'UNKNOWN_CVT'; # catch later + trim_whitespace($in); + if ($in =~ /\s/) { # two + ($self->{interface_macro}, $self->{interface_macro_set}) = split ' ', $in; + } + else { + $self->{interface_macro} = $in; + $self->{interface_macro_set} = 'UNKNOWN_CVT'; # catch later } - $interface = 1; # local - $Interfaces = 1; # global + $self->{interface} = 1; # local + $self->{interfaces} = 1; # global } -sub INTERFACE_handler() { - my $in = merge_section(); +sub INTERFACE_handler { + my $self = shift; + $_ = shift; + my $in = $self->merge_section(); - TrimWhitespace($in); + trim_whitespace($in); foreach (split /[\s,]+/, $in) { - my $name = $_; - $name =~ s/^$Prefix//; - $Interfaces{$name} = $_; + my $iface_name = $_; + $iface_name =~ s/^$self->{Prefix}//; + $self->{Interfaces}->{$iface_name} = $_; } print Q(<<"EOF"); -# XSFUNCTION = $interface_macro($ret_type,cv,XSANY.any_dptr); +# XSFUNCTION = $self->{interface_macro}($self->{ret_type},cv,XSANY.any_dptr); EOF - $interface = 1; # local - $Interfaces = 1; # global + $self->{interface} = 1; # local + $self->{interfaces} = 1; # global +} + +sub CLEANUP_handler { + my $self = shift; + $self->print_section(); } -sub CLEANUP_handler() { print_section() } -sub PREINIT_handler() { print_section() } -sub POSTCALL_handler() { print_section() } -sub INIT_handler() { print_section() } +sub PREINIT_handler { + my $self = shift; + $self->print_section(); +} -sub GetAliases - { - my ($line) = @_ ; - my ($orig) = $line ; - my ($alias) ; - my ($value) ; +sub POSTCALL_handler { + my $self = shift; + $self->print_section(); +} - # Parse alias definitions - # format is - # alias = value alias = value ... +sub INIT_handler { + my $self = shift; + $self->print_section(); +} - while ($line =~ s/^\s*([\w:]+)\s*=\s*(\w+)\s*//) { - $alias = $1 ; - $orig_alias = $alias ; - $value = $2 ; +sub get_aliases { + my $self = shift; + my ($line) = @_; + my ($orig) = $line; - # check for optional package definition in the alias - $alias = $Packprefix . $alias if $alias !~ /::/ ; + # Parse alias definitions + # format is + # alias = value alias = value ... - # check for duplicate alias name & duplicate value - Warn("Warning: Ignoring duplicate alias '$orig_alias'") - if defined $XsubAliases{$alias} ; + while ($line =~ s/^\s*([\w:]+)\s*=\s*(\w+)\s*//) { + my ($alias, $value) = ($1, $2); + my $orig_alias = $alias; - Warn("Warning: Aliases '$orig_alias' and '$XsubAliasValues{$value}' have identical values") - if $XsubAliasValues{$value} ; + # check for optional package definition in the alias + $alias = $self->{Packprefix} . $alias if $alias !~ /::/; - $XsubAliases = 1; - $XsubAliases{$alias} = $value ; - $XsubAliasValues{$value} = $orig_alias ; - } + # check for duplicate alias name & duplicate value + Warn( $self, "Warning: Ignoring duplicate alias '$orig_alias'") + if defined $self->{XsubAliases}->{$alias}; - blurt("Error: Cannot parse ALIAS definitions from '$orig'") - if $line ; + Warn( $self, "Warning: Aliases '$orig_alias' and '$self->{XsubAliasValues}->{$value}' have identical values") + if $self->{XsubAliasValues}->{$value}; + + $self->{xsubaliases} = 1; + $self->{XsubAliases}->{$alias} = $value; + $self->{XsubAliasValues}->{$value} = $orig_alias; } -sub ATTRS_handler () - { - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { - next unless /\S/; - TrimWhitespace($_) ; - push @Attributes, $_; - } + blurt( $self, "Error: Cannot parse ALIAS definitions from '$orig'") + if $line; +} + +sub ATTRS_handler { + my $self = shift; + $_ = shift; + + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + next unless /\S/; + trim_whitespace($_); + push @{ $self->{Attributes} }, $_; } +} -sub ALIAS_handler () - { - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { - next unless /\S/; - TrimWhitespace($_) ; - GetAliases($_) if $_ ; - } +sub ALIAS_handler { + my $self = shift; + $_ = shift; + + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + next unless /\S/; + trim_whitespace($_); + $self->get_aliases($_) if $_; } +} + +sub OVERLOAD_handler { + my $self = shift; + $_ = shift; -sub OVERLOAD_handler() -{ - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { next unless /\S/; - TrimWhitespace($_) ; + trim_whitespace($_); while ( s/^\s*([\w:"\\)\+\-\*\/\%\<\>\.\&\|\^\!\~\{\}\=]+)\s*//) { - $Overload = 1 unless $Overload; - my $overload = "$Package\::(".$1 ; - push(@InitFileCode, - " (void)${newXS}(\"$overload\", XS_$Full_func_name, file$proto);\n"); + $self->{Overload} = 1 unless $self->{Overload}; + my $overload = "$Package\::(".$1; + push(@{ $self->{InitFileCode} }, + " (void)$self->{newXS}(\"$overload\", XS_$Full_func_name, file$self->{proto});\n"); } - } + } } -sub FALLBACK_handler() -{ - # the rest of the current line should contain either TRUE, +sub FALLBACK_handler { + my $self = shift; + $_ = shift; + + # the rest of the current line should contain either TRUE, # FALSE or UNDEF - - TrimWhitespace($_) ; + + trim_whitespace($_); my %map = ( - TRUE => "&PL_sv_yes", 1 => "&PL_sv_yes", - FALSE => "&PL_sv_no", 0 => "&PL_sv_no", - UNDEF => "&PL_sv_undef", - ) ; - + TRUE => "&PL_sv_yes", 1 => "&PL_sv_yes", + FALSE => "&PL_sv_no", 0 => "&PL_sv_no", + UNDEF => "&PL_sv_undef", + ); + # check for valid FALLBACK value - death ("Error: FALLBACK: TRUE/FALSE/UNDEF") unless exists $map{uc $_} ; - - $Fallback = $map{uc $_} ; + $self->death("Error: FALLBACK: TRUE/FALSE/UNDEF") unless exists $map{uc $_}; + + $self->{Fallback} = $map{uc $_}; } -sub REQUIRE_handler () - { - # the rest of the current line should contain a version number - my ($Ver) = $_ ; +sub REQUIRE_handler { + my $self = shift; + # the rest of the current line should contain a version number + my $Ver = shift; - TrimWhitespace($Ver) ; + trim_whitespace($Ver); - death ("Error: REQUIRE expects a version number") - unless $Ver ; + $self->death("Error: REQUIRE expects a version number") + unless $Ver; - # check that the version number is of the form n.n - death ("Error: REQUIRE: expected a number, got '$Ver'") - unless $Ver =~ /^\d+(\.\d*)?/ ; + # check that the version number is of the form n.n + $self->death("Error: REQUIRE: expected a number, got '$Ver'") + unless $Ver =~ /^\d+(\.\d*)?/; - death ("Error: xsubpp $Ver (or better) required--this is only $VERSION.") - unless $VERSION >= $Ver ; - } + $self->death("Error: xsubpp $Ver (or better) required--this is only $VERSION.") + unless $VERSION >= $Ver; +} -sub VERSIONCHECK_handler () - { - # the rest of the current line should contain either ENABLE or - # DISABLE +sub VERSIONCHECK_handler { + my $self = shift; + $_ = shift; - TrimWhitespace($_) ; + # the rest of the current line should contain either ENABLE or + # DISABLE - # check for ENABLE/DISABLE - death ("Error: VERSIONCHECK: ENABLE/DISABLE") - unless /^(ENABLE|DISABLE)/i ; + trim_whitespace($_); - $WantVersionChk = 1 if $1 eq 'ENABLE' ; - $WantVersionChk = 0 if $1 eq 'DISABLE' ; + # check for ENABLE/DISABLE + $self->death("Error: VERSIONCHECK: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)/i; - } + $self->{WantVersionChk} = 1 if $1 eq 'ENABLE'; + $self->{WantVersionChk} = 0 if $1 eq 'DISABLE'; -sub PROTOTYPE_handler () - { - my $specified ; - - death("Error: Only 1 PROTOTYPE definition allowed per xsub") - if $proto_in_this_xsub ++ ; - - for (; !/^$BLOCK_re/o; $_ = shift(@line)) { - next unless /\S/; - $specified = 1 ; - TrimWhitespace($_) ; - if ($_ eq 'DISABLE') { - $ProtoThisXSUB = 0 - } elsif ($_ eq 'ENABLE') { - $ProtoThisXSUB = 1 - } else { - # remove any whitespace - s/\s+//g ; - death("Error: Invalid prototype '$_'") - unless ValidProtoString($_) ; - $ProtoThisXSUB = C_string($_) ; - } - } +} - # If no prototype specified, then assume empty prototype "" - $ProtoThisXSUB = 2 unless $specified ; +sub PROTOTYPE_handler { + my $self = shift; + $_ = shift; + + my $specified; - $ProtoUsed = 1 ; + $self->death("Error: Only 1 PROTOTYPE definition allowed per xsub") + if $self->{proto_in_this_xsub}++; + for (; !/^$self->{BLOCK_re}/o; $_ = shift(@{ $self->{line} })) { + next unless /\S/; + $specified = 1; + trim_whitespace($_); + if ($_ eq 'DISABLE') { + $self->{ProtoThisXSUB} = 0; + } + elsif ($_ eq 'ENABLE') { + $self->{ProtoThisXSUB} = 1; + } + else { + # remove any whitespace + s/\s+//g; + $self->death("Error: Invalid prototype '$_'") + unless valid_proto_string($_); + $self->{ProtoThisXSUB} = C_string($_); + } } -sub SCOPE_handler () - { - death("Error: Only 1 SCOPE declaration allowed per xsub") - if $scope_in_this_xsub ++ ; + # If no prototype specified, then assume empty prototype "" + $self->{ProtoThisXSUB} = 2 unless $specified; - TrimWhitespace($_); - death ("Error: SCOPE: ENABLE/DISABLE") - unless /^(ENABLE|DISABLE)\b/i; - $ScopeThisXSUB = ( uc($1) eq 'ENABLE' ); - } + $self->{ProtoUsed} = 1; +} -sub PROTOTYPES_handler () - { - # the rest of the current line should contain either ENABLE or - # DISABLE +sub SCOPE_handler { + my $self = shift; + $_ = shift; - TrimWhitespace($_) ; + $self->death("Error: Only 1 SCOPE declaration allowed per xsub") + if $self->{scope_in_this_xsub}++; - # check for ENABLE/DISABLE - death ("Error: PROTOTYPES: ENABLE/DISABLE") - unless /^(ENABLE|DISABLE)/i ; + trim_whitespace($_); + $self->death("Error: SCOPE: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)\b/i; + $self->{ScopeThisXSUB} = ( uc($1) eq 'ENABLE' ); +} - $WantPrototypes = 1 if $1 eq 'ENABLE' ; - $WantPrototypes = 0 if $1 eq 'DISABLE' ; - $ProtoUsed = 1 ; +sub PROTOTYPES_handler { + my $self = shift; + $_ = shift; - } + # the rest of the current line should contain either ENABLE or + # DISABLE -sub PushXSStack - { - my %args = @_; - # Save the current file context. - push(@XSStack, { - type => 'file', - LastLine => $lastline, - LastLineNo => $lastline_no, - Line => \@line, - LineNo => \@line_no, - Filename => $filename, - Filepathname => $filepathname, - Handle => $FH, - IsPipe => scalar($filename =~ /\|\s*$/), - %args, - }) ; + trim_whitespace($_); - } + # check for ENABLE/DISABLE + $self->death("Error: PROTOTYPES: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)/i; -sub INCLUDE_handler () - { - # the rest of the current line should contain a valid filename + $self->{WantPrototypes} = 1 if $1 eq 'ENABLE'; + $self->{WantPrototypes} = 0 if $1 eq 'DISABLE'; + $self->{ProtoUsed} = 1; +} - TrimWhitespace($_) ; +sub EXPORT_XSUB_SYMBOLS_handler { + my $self = shift; + $_ = shift; - death("INCLUDE: filename missing") - unless $_ ; + # the rest of the current line should contain either ENABLE or + # DISABLE - death("INCLUDE: output pipe is illegal") - if /^\s*\|/ ; + trim_whitespace($_); - # simple minded recursion detector - death("INCLUDE loop detected") - if $IncludedFiles{$_} ; + # check for ENABLE/DISABLE + $self->death("Error: EXPORT_XSUB_SYMBOLS: ENABLE/DISABLE") + unless /^(ENABLE|DISABLE)/i; - ++ $IncludedFiles{$_} unless /\|\s*$/ ; + my $xs_impl = $1 eq 'ENABLE' ? 'XS_EXTERNAL' : 'XS_INTERNAL'; + + print Q(<<"EOF"); +##undef XS_EUPXS +##if defined(PERL_EUPXS_ALWAYS_EXPORT) +## define XS_EUPXS(name) XS_EXTERNAL(name) +##elif defined(PERL_EUPXS_NEVER_EXPORT) +## define XS_EUPXS(name) XS_INTERNAL(name) +##else +## define XS_EUPXS(name) $xs_impl(name) +##endif +EOF +} - if (/\|\s*$/ && /^\s*perl\s/) { - Warn("The INCLUDE directive with a command is discouraged." . - " Use INCLUDE_COMMAND instead! In particular using 'perl'" . - " in an 'INCLUDE: ... |' directive is not guaranteed to pick" . - " up the correct perl. The INCLUDE_COMMAND directive allows" . - " the use of \$^X as the currently running perl, see" . - " 'perldoc perlxs' for details."); - } - PushXSStack(); +sub PushXSStack { + my $self = shift; + my %args = @_; + # Save the current file context. + push(@{ $self->{XSStack} }, { + type => 'file', + LastLine => $self->{lastline}, + LastLineNo => $self->{lastline_no}, + Line => $self->{line}, + LineNo => $self->{line_no}, + Filename => $self->{filename}, + Filepathname => $self->{filepathname}, + Handle => $self->{FH}, + IsPipe => scalar($self->{filename} =~ /\|\s*$/), + %args, + }); + +} - $FH = Symbol::gensym(); +sub INCLUDE_handler { + my $self = shift; + $_ = shift; + # the rest of the current line should contain a valid filename - # open the new file - open ($FH, "$_") or death("Cannot open '$_': $!") ; + trim_whitespace($_); - print Q(<<"EOF"); + $self->death("INCLUDE: filename missing") + unless $_; + + $self->death("INCLUDE: output pipe is illegal") + if /^\s*\|/; + + # simple minded recursion detector + $self->death("INCLUDE loop detected") + if $self->{IncludedFiles}->{$_}; + + ++$self->{IncludedFiles}->{$_} unless /\|\s*$/; + + if (/\|\s*$/ && /^\s*perl\s/) { + Warn( $self, "The INCLUDE directive with a command is discouraged." . + " Use INCLUDE_COMMAND instead! In particular using 'perl'" . + " in an 'INCLUDE: ... |' directive is not guaranteed to pick" . + " up the correct perl. The INCLUDE_COMMAND directive allows" . + " the use of \$^X as the currently running perl, see" . + " 'perldoc perlxs' for details."); + } + + $self->PushXSStack(); + + $self->{FH} = Symbol::gensym(); + + # open the new file + open($self->{FH}, $_) or $self->death("Cannot open '$_': $!"); + + print Q(<<"EOF"); # -#/* INCLUDE: Including '$_' from '$filename' */ +#/* INCLUDE: Including '$_' from '$self->{filename}' */ # EOF - $filename = $_ ; - $filepathname = File::Spec->catfile($dir, $filename); + $self->{filename} = $_; + $self->{filepathname} = ( $^O =~ /^mswin/i ) + ? qq($self->{dir}/$self->{filename}) # See CPAN RT #61908: gcc doesn't like backslashes on win32? + : File::Spec->catfile($self->{dir}, $self->{filename}); - # Prime the pump by reading the first - # non-blank line + # Prime the pump by reading the first + # non-blank line - # skip leading blank lines - while (<$FH>) { - last unless /^\s*$/ ; - } - - $lastline = $_ ; - $lastline_no = $. ; + # skip leading blank lines + while (readline($self->{FH})) { + last unless /^\s*$/; } + $self->{lastline} = $_; + $self->{lastline_no} = $.; +} + sub QuoteArgs { - my $cmd = shift; - my @args = split /\s+/, $cmd; - $cmd = shift @args; - for (@args) { - $_ = q(").$_.q(") if !/^\"/ && length($_) > 0; - } - return join (' ', ($cmd, @args)); + my $cmd = shift; + my @args = split /\s+/, $cmd; + $cmd = shift @args; + for (@args) { + $_ = q(").$_.q(") if !/^\"/ && length($_) > 0; } + return join (' ', ($cmd, @args)); +} -sub INCLUDE_COMMAND_handler () - { - # the rest of the current line should contain a valid command +sub INCLUDE_COMMAND_handler { + my $self = shift; + $_ = shift; + # the rest of the current line should contain a valid command - TrimWhitespace($_) ; + trim_whitespace($_); - $_ = QuoteArgs($_) if $^O eq 'VMS'; + $_ = QuoteArgs($_) if $^O eq 'VMS'; - death("INCLUDE_COMMAND: command missing") - unless $_ ; + $self->death("INCLUDE_COMMAND: command missing") + unless $_; - death("INCLUDE_COMMAND: pipes are illegal") - if /^\s*\|/ or /\|\s*$/ ; + $self->death("INCLUDE_COMMAND: pipes are illegal") + if /^\s*\|/ or /\|\s*$/; - PushXSStack( IsPipe => 1 ); + $self->PushXSStack( IsPipe => 1 ); - $FH = Symbol::gensym(); + $self->{FH} = Symbol::gensym(); - # If $^X is used in INCLUDE_COMMAND, we know it's supposed to be - # the same perl interpreter as we're currently running - s/^\s*\$\^X/$^X/; + # If $^X is used in INCLUDE_COMMAND, we know it's supposed to be + # the same perl interpreter as we're currently running + s/^\s*\$\^X/$^X/; - # open the new file - open ($FH, "-|", "$_") - or death("Cannot run command '$_' to include its output: $!") ; + # open the new file + open ($self->{FH}, "-|", $_) + or $self->death( $self, "Cannot run command '$_' to include its output: $!"); - print Q(<<"EOF"); + print Q(<<"EOF"); # -#/* INCLUDE_COMMAND: Including output of '$_' from '$filename' */ +#/* INCLUDE_COMMAND: Including output of '$_' from '$self->{filename}' */ # EOF - $filename = $_ ; - $filepathname = $filename; - $filepathname =~ s/\"/\\"/g; + $self->{filename} = $_; + $self->{filepathname} = $self->{filename}; + #$self->{filepathname} =~ s/\"/\\"/g; # Fails? See CPAN RT #53938: MinGW Broken after 2.21 + $self->{filepathname} =~ s/\\/\\\\/g; # Works according to reporter of #53938 - # Prime the pump by reading the first - # non-blank line + # Prime the pump by reading the first + # non-blank line - # skip leading blank lines - while (<$FH>) { - last unless /^\s*$/ ; - } - - $lastline = $_ ; - $lastline_no = $. ; + # skip leading blank lines + while (readline($self->{FH})) { + last unless /^\s*$/; } -sub PopFile() - { - return 0 unless $XSStack[-1]{type} eq 'file' ; - - my $data = pop @XSStack ; - my $ThisFile = $filename ; - my $isPipe = $data->{IsPipe}; - - -- $IncludedFiles{$filename} - unless $isPipe ; - - close $FH ; - - $FH = $data->{Handle} ; - # $filename is the leafname, which for some reason isused for diagnostic - # messages, whereas $filepathname is the full pathname, and is used for - # #line directives. - $filename = $data->{Filename} ; - $filepathname = $data->{Filepathname} ; - $lastline = $data->{LastLine} ; - $lastline_no = $data->{LastLineNo} ; - @line = @{ $data->{Line} } ; - @line_no = @{ $data->{LineNo} } ; - - if ($isPipe and $? ) { - -- $lastline_no ; - print STDERR "Error reading from pipe '$ThisFile': $! in $filename, line $lastline_no\n" ; - exit 1 ; - } + $self->{lastline} = $_; + $self->{lastline_no} = $.; +} - print Q(<<"EOF"); -# -#/* INCLUDE: Returning to '$filename' from '$ThisFile' */ -# -EOF +sub PopFile { + my $self = shift; - return 1 ; - } + return 0 unless $self->{XSStack}->[-1]{type} eq 'file'; -sub ValidProtoString ($) - { - my($string) = @_ ; + my $data = pop @{ $self->{XSStack} }; + my $ThisFile = $self->{filename}; + my $isPipe = $data->{IsPipe}; - if ( $string =~ /^$proto_re+$/ ) { - return $string ; - } + --$self->{IncludedFiles}->{$self->{filename}} + unless $isPipe; - return 0 ; - } + close $self->{FH}; -sub C_string ($) - { - my($string) = @_ ; + $self->{FH} = $data->{Handle}; + # $filename is the leafname, which for some reason isused for diagnostic + # messages, whereas $filepathname is the full pathname, and is used for + # #line directives. + $self->{filename} = $data->{Filename}; + $self->{filepathname} = $data->{Filepathname}; + $self->{lastline} = $data->{LastLine}; + $self->{lastline_no} = $data->{LastLineNo}; + @{ $self->{line} } = @{ $data->{Line} }; + @{ $self->{line_no} } = @{ $data->{LineNo} }; - $string =~ s[\\][\\\\]g ; - $string ; + if ($isPipe and $? ) { + --$self->{lastline_no}; + print STDERR "Error reading from pipe '$ThisFile': $! in $self->{filename}, line $self->{lastline_no}\n" ; + exit 1; } -sub ProtoString ($) - { - my ($type) = @_ ; - - $proto_letter{$type} or "\$" ; - } + print Q(<<"EOF"); +# +#/* INCLUDE: Returning to '$self->{filename}' from '$ThisFile' */ +# +EOF -sub check_cpp { - my @cpp = grep(/^\#\s*(?:if|e\w+)/, @line); - if (@cpp) { - my ($cpp, $cpplevel); - for $cpp (@cpp) { - if ($cpp =~ /^\#\s*if/) { - $cpplevel++; - } elsif (!$cpplevel) { - Warn("Warning: #else/elif/endif without #if in this function"); - print STDERR " (precede it with a blank line if the matching #if is outside the function)\n" - if $XSStack[-1]{type} eq 'if'; - return; - } elsif ($cpp =~ /^\#\s*endif/) { - $cpplevel--; - } - } - Warn("Warning: #if without #endif in this function") if $cpplevel; - } + return 1; } - sub Q { my($text) = @_; $text =~ s/^#//gm; @@ -1715,480 +1669,325 @@ sub Q { $text; } -# Read next xsub into @line from ($lastline, <$FH>). +# Read next xsub into @{ $self->{line} } from ($lastline, readline($self->{FH})). sub fetch_para { + my $self = shift; + # parse paragraph - death ("Error: Unterminated `#if/#ifdef/#ifndef'") - if !defined $lastline && $XSStack[-1]{type} eq 'if'; - @line = (); - @line_no = () ; - return PopFile() if !defined $lastline; + $self->death("Error: Unterminated '#if/#ifdef/#ifndef'") + if !defined $self->{lastline} && $self->{XSStack}->[-1]{type} eq 'if'; + @{ $self->{line} } = (); + @{ $self->{line_no} } = (); + return $self->PopFile() if !defined $self->{lastline}; - if ($lastline =~ + if ($self->{lastline} =~ /^MODULE\s*=\s*([\w:]+)(?:\s+PACKAGE\s*=\s*([\w:]+))?(?:\s+PREFIX\s*=\s*(\S+))?\s*$/) { - $Module = $1; + my $Module = $1; $Package = defined($2) ? $2 : ''; # keep -w happy - $Prefix = defined($3) ? $3 : ''; # keep -w happy - $Prefix = quotemeta $Prefix ; - ($Module_cname = $Module) =~ s/\W/_/g; - ($Packid = $Package) =~ tr/:/_/; - $Packprefix = $Package; - $Packprefix .= "::" if $Packprefix ne ""; - $lastline = ""; + $self->{Prefix} = defined($3) ? $3 : ''; # keep -w happy + $self->{Prefix} = quotemeta $self->{Prefix}; + ($self->{Module_cname} = $Module) =~ s/\W/_/g; + ($self->{Packid} = $Package) =~ tr/:/_/; + $self->{Packprefix} = $Package; + $self->{Packprefix} .= "::" if $self->{Packprefix} ne ""; + $self->{lastline} = ""; } for (;;) { # Skip embedded PODs - while ($lastline =~ /^=/) { - while ($lastline = <$FH>) { - last if ($lastline =~ /^=cut\s*$/); + while ($self->{lastline} =~ /^=/) { + while ($self->{lastline} = readline($self->{FH})) { + last if ($self->{lastline} =~ /^=cut\s*$/); } - death ("Error: Unterminated pod") unless $lastline; - $lastline = <$FH>; - chomp $lastline; - $lastline =~ s/^\s+$//; + $self->death("Error: Unterminated pod") unless $self->{lastline}; + $self->{lastline} = readline($self->{FH}); + chomp $self->{lastline}; + $self->{lastline} =~ s/^\s+$//; } - if ($lastline !~ /^\s*#/ || - # CPP directives: - # ANSI: if ifdef ifndef elif else endif define undef - # line error pragma - # gcc: warning include_next - # obj-c: import - # others: ident (gcc notes that some cpps have this one) - $lastline =~ /^#[ \t]*(?:(?:if|ifn?def|elif|else|endif|define|undef|pragma|error|warning|line\s+\d+|ident)\b|(?:include(?:_next)?|import)\s*["<].*[>"])/) { - last if $lastline =~ /^\S/ && @line && $line[-1] eq ""; - push(@line, $lastline); - push(@line_no, $lastline_no) ; + + # This chunk of code strips out (and parses) embedded TYPEMAP blocks + # which support a HEREdoc-alike block syntax. + # This is special cased from the usual paragraph-handler logic + # due to the HEREdoc-ish syntax. + if ($self->{lastline} =~ /^TYPEMAP\s*:\s*<<\s*(?:(["'])(.+?)\1|([^\s'"]+))\s*;?\s*$/) { + my $end_marker = quotemeta(defined($1) ? $2 : $3); + my @tmaplines; + while (1) { + $self->{lastline} = readline($self->{FH}); + $self->death("Error: Unterminated typemap") if not defined $self->{lastline}; + last if $self->{lastline} =~ /^$end_marker\s*$/; + push @tmaplines, $self->{lastline}; + } + + my $tmapcode = join "", @tmaplines; + my $tmap = ExtUtils::Typemaps->new( + string => $tmapcode, + lineno_offset => ($self->current_line_number()||0)+1, + fake_filename => $self->{filename}, + ); + $self->{typemap}->merge(typemap => $tmap, replace => 1); + + $self->{lastline} = ""; + } + + if ($self->{lastline} !~ /^\s*#/ || + # CPP directives: + # ANSI: if ifdef ifndef elif else endif define undef + # line error pragma + # gcc: warning include_next + # obj-c: import + # others: ident (gcc notes that some cpps have this one) + $self->{lastline} =~ /^#[ \t]*(?:(?:if|ifn?def|elif|else|endif|define|undef|pragma|error|warning|line\s+\d+|ident)\b|(?:include(?:_next)?|import)\s*["<].*[>"])/) { + last if $self->{lastline} =~ /^\S/ && @{ $self->{line} } && $self->{line}->[-1] eq ""; + push(@{ $self->{line} }, $self->{lastline}); + push(@{ $self->{line_no} }, $self->{lastline_no}); } # Read next line and continuation lines - last unless defined($lastline = <$FH>); - $lastline_no = $.; + last unless defined($self->{lastline} = readline($self->{FH})); + $self->{lastline_no} = $.; my $tmp_line; - $lastline .= $tmp_line - while ($lastline =~ /\\$/ && defined($tmp_line = <$FH>)); + $self->{lastline} .= $tmp_line + while ($self->{lastline} =~ /\\$/ && defined($tmp_line = readline($self->{FH}))); - chomp $lastline; - $lastline =~ s/^\s+$//; + chomp $self->{lastline}; + $self->{lastline} =~ s/^\s+$//; } - pop(@line), pop(@line_no) while @line && $line[-1] eq ""; + pop(@{ $self->{line} }), pop(@{ $self->{line_no} }) while @{ $self->{line} } && $self->{line}->[-1] eq ""; 1; } sub output_init { - local($type, $num, $var, $init, $name_printed) = @_; - local($arg) = "ST(" . ($num - 1) . ")"; + my $argsref = shift; + my ($type, $num, $var, $init, $printed_name) = ( + $argsref->{type}, + $argsref->{num}, + $argsref->{var}, + $argsref->{init}, + $argsref->{printed_name} + ); + my $arg = "ST(" . ($num - 1) . ")"; if ( $init =~ /^=/ ) { - if ($name_printed) { + if ($printed_name) { eval qq/print " $init\\n"/; - } else { + } + else { eval qq/print "\\t$var $init\\n"/; } - warn $@ if $@; - } else { + warn $@ if $@; + } + else { if ( $init =~ s/^\+// && $num ) { - &generate_init($type, $num, $var, $name_printed); - } elsif ($name_printed) { + generate_init( { + type => $type, + num => $num, + var => $var, + printed_name => $printed_name, + } ); + } + elsif ($printed_name) { print ";\n"; $init =~ s/^;//; - } else { + } + else { eval qq/print "\\t$var;\\n"/; - warn $@ if $@; + warn $@ if $@; $init =~ s/^;//; } - $deferred .= eval qq/"\\n\\t$init\\n"/; - warn $@ if $@; + $self->{deferred} .= eval qq/"\\n\\t$init\\n"/; + warn $@ if $@; } } -sub Warn - { - # work out the line number - my $line_no = $line_no[@line_no - @line -1] ; - - print STDERR "@_ in $filename, line $line_no\n" ; - } - -sub blurt - { - Warn @_ ; - $errors ++ - } - -sub death - { - Warn @_ ; - exit 1 ; - } - sub generate_init { - local($type, $num, $var) = @_; - local($arg) = "ST(" . ($num - 1) . ")"; - local($argoff) = $num - 1; - local($ntype); - local($tk); - - $type = TidyType($type) ; - blurt("Error: '$type' not in typemap"), return - unless defined($type_kind{$type}); + my $argsref = shift; + my ($type, $num, $var, $printed_name) = ( + $argsref->{type}, + $argsref->{num}, + $argsref->{var}, + $argsref->{printed_name}, + ); + my $arg = "ST(" . ($num - 1) . ")"; + my ($argoff, $ntype); + $argoff = $num - 1; + + my $typemaps = $self->{typemap}; + + $type = tidy_type($type); + $self->report_typemap_failure($typemaps, $type), return + unless $typemaps->get_typemap(ctype => $type); ($ntype = $type) =~ s/\s*\*/Ptr/g; + my $subtype; ($subtype = $ntype) =~ s/(?:Array)?(?:Ptr)?$//; - $tk = $type_kind{$type}; - $tk =~ s/OBJ$/REF/ if $func_name =~ /DESTROY$/; - if ($tk eq 'T_PV' and exists $lengthof{$var}) { - print "\t$var" unless $name_printed; + my $typem = $typemaps->get_typemap(ctype => $type); + my $xstype = $typem->xstype; + $xstype =~ s/OBJ$/REF/ if $func_name =~ /DESTROY$/; + if ($xstype eq 'T_PV' and exists $self->{lengthof}->{$var}) { + print "\t$var" unless $printed_name; print " = ($type)SvPV($arg, STRLEN_length_of_$var);\n"; die "default value not supported with length(NAME) supplied" - if defined $defaults{$var}; + if defined $self->{defaults}->{$var}; return; } - $type =~ tr/:/_/ unless $hiertype; - blurt("Error: No INPUT definition for type '$type', typekind '$type_kind{$type}' found"), return - unless defined $input_expr{$tk} ; - $expr = $input_expr{$tk}; + $type =~ tr/:/_/ unless $self->{hiertype}; + + my $inputmap = $typemaps->get_inputmap(xstype => $xstype); + $self->blurt("Error: No INPUT definition for type '$type', typekind '" . $type->xstype . "' found"), return + unless defined $inputmap; + + my $expr = $inputmap->cleaned_code; + # Note: This gruesome bit either needs heavy rethinking or documentation. I vote for the former. --Steffen if ($expr =~ /DO_ARRAY_ELEM/) { - blurt("Error: '$subtype' not in typemap"), return - unless defined($type_kind{$subtype}); - blurt("Error: No INPUT definition for type '$subtype', typekind '$type_kind{$subtype}' found"), return - unless defined $input_expr{$type_kind{$subtype}} ; - $subexpr = $input_expr{$type_kind{$subtype}}; + my $subtypemap = $typemaps->get_typemap(ctype => $subtype); + $self->report_typemap_failure($typemaps, $subtype), return + if not $subtypemap; + my $subinputmap = $typemaps->get_inputmap(xstype => $subtypemap->xstype); + $self->blurt("Error: No INPUT definition for type '$subtype', typekind '" . $subtypemap->xstype . "' found"), return + unless $subinputmap; + my $subexpr = $subinputmap->cleaned_code; $subexpr =~ s/\$type/\$subtype/g; $subexpr =~ s/ntype/subtype/g; $subexpr =~ s/\$arg/ST(ix_$var)/g; $subexpr =~ s/\n\t/\n\t\t/g; $subexpr =~ s/is not of (.*\")/[arg %d] is not of $1, ix_$var + 1/g; - $subexpr =~ s/\$var/${var}[ix_$var - $argoff]/; + $subexpr =~ s/\$var/${var}\[ix_$var - $argoff]/; $expr =~ s/DO_ARRAY_ELEM/$subexpr/; } if ($expr =~ m#/\*.*scope.*\*/#i) { # "scope" in C comments - $ScopeThisXSUB = 1; + $self->{ScopeThisXSUB} = 1; } - if (defined($defaults{$var})) { + if (defined($self->{defaults}->{$var})) { $expr =~ s/(\t+)/$1 /g; $expr =~ s/ /\t/g; - if ($name_printed) { + if ($printed_name) { print ";\n"; - } else { + } + else { eval qq/print "\\t$var;\\n"/; - warn $@ if $@; + warn $@ if $@; } - if ($defaults{$var} eq 'NO_INIT') { - $deferred .= eval qq/"\\n\\tif (items >= $num) {\\n$expr;\\n\\t}\\n"/; - } else { - $deferred .= eval qq/"\\n\\tif (items < $num)\\n\\t $var = $defaults{$var};\\n\\telse {\\n$expr;\\n\\t}\\n"/; + if ($self->{defaults}->{$var} eq 'NO_INIT') { + $self->{deferred} .= eval qq/"\\n\\tif (items >= $num) {\\n$expr;\\n\\t}\\n"/; } - warn $@ if $@; - } elsif ($ScopeThisXSUB or $expr !~ /^\s*\$var =/) { - if ($name_printed) { + else { + $self->{deferred} .= eval qq/"\\n\\tif (items < $num)\\n\\t $var = $self->{defaults}->{$var};\\n\\telse {\\n$expr;\\n\\t}\\n"/; + } + warn $@ if $@; + } + elsif ($self->{ScopeThisXSUB} or $expr !~ /^\s*\$var =/) { + if ($printed_name) { print ";\n"; - } else { + } + else { eval qq/print "\\t$var;\\n"/; - warn $@ if $@; + warn $@ if $@; } - $deferred .= eval qq/"\\n$expr;\\n"/; - warn $@ if $@; - } else { + $self->{deferred} .= eval qq/"\\n$expr;\\n"/; + warn $@ if $@; + } + else { die "panic: do not know how to handle this branch for function pointers" - if $name_printed; + if $printed_name; eval qq/print "$expr;\\n"/; - warn $@ if $@; + warn $@ if $@; } } sub generate_output { - local($type, $num, $var, $do_setmagic, $do_push) = @_; - local($arg) = "ST(" . ($num - ($num != 0)) . ")"; - local($argoff) = $num - 1; - local($ntype); - - $type = TidyType($type) ; + my $argsref = shift; + my ($type, $num, $var, $do_setmagic, $do_push) = ( + $argsref->{type}, + $argsref->{num}, + $argsref->{var}, + $argsref->{do_setmagic}, + $argsref->{do_push} + ); + my $arg = "ST(" . ($num - ($num != 0)) . ")"; + my $ntype; + + my $typemaps = $self->{typemap}; + + $type = tidy_type($type); if ($type =~ /^array\(([^,]*),(.*)\)/) { print "\t$arg = sv_newmortal();\n"; print "\tsv_setpvn($arg, (char *)$var, $2 * sizeof($1));\n"; print "\tSvSETMAGIC($arg);\n" if $do_setmagic; - } else { - blurt("Error: '$type' not in typemap"), return - unless defined($type_kind{$type}); - blurt("Error: No OUTPUT definition for type '$type', typekind '$type_kind{$type}' found"), return - unless defined $output_expr{$type_kind{$type}} ; + } + else { + my $typemap = $typemaps->get_typemap(ctype => $type); + $self->report_typemap_failure($typemaps, $type), return + if not $typemap; + my $outputmap = $typemaps->get_outputmap(xstype => $typemap->xstype); + $self->blurt("Error: No OUTPUT definition for type '$type', typekind '" . $typemap->xstype . "' found"), return + unless $outputmap; ($ntype = $type) =~ s/\s*\*/Ptr/g; $ntype =~ s/\(\)//g; + my $subtype; ($subtype = $ntype) =~ s/(?:Array)?(?:Ptr)?$//; - $expr = $output_expr{$type_kind{$type}}; + + my $expr = $outputmap->cleaned_code; if ($expr =~ /DO_ARRAY_ELEM/) { - blurt("Error: '$subtype' not in typemap"), return - unless defined($type_kind{$subtype}); - blurt("Error: No OUTPUT definition for type '$subtype', typekind '$type_kind{$subtype}' found"), return - unless defined $output_expr{$type_kind{$subtype}} ; - $subexpr = $output_expr{$type_kind{$subtype}}; + my $subtypemap = $typemaps->get_typemap(ctype => $subtype); + $self->report_typemap_failure($typemaps, $subtype), return + if not $subtypemap; + my $suboutputmap = $typemaps->get_outputmap(xstype => $subtypemap->xstype); + $self->blurt("Error: No OUTPUT definition for type '$subtype', typekind '" . $subtypemap->xstype . "' found"), return + unless $suboutputmap; + my $subexpr = $suboutputmap->cleaned_code; $subexpr =~ s/ntype/subtype/g; $subexpr =~ s/\$arg/ST(ix_$var)/g; - $subexpr =~ s/\$var/${var}[ix_$var]/g; + $subexpr =~ s/\$var/${var}\[ix_$var]/g; $subexpr =~ s/\n\t/\n\t\t/g; $expr =~ s/DO_ARRAY_ELEM\n/$subexpr/; eval "print qq\a$expr\a"; - warn $@ if $@; + warn $@ if $@; print "\t\tSvSETMAGIC(ST(ix_$var));\n" if $do_setmagic; - } elsif ($var eq 'RETVAL') { + } + elsif ($var eq 'RETVAL') { if ($expr =~ /^\t\$arg = new/) { - # We expect that $arg has refcnt 1, so we need to - # mortalize it. - eval "print qq\a$expr\a"; - warn $@ if $@; - print "\tsv_2mortal(ST($num));\n"; - print "\tSvSETMAGIC(ST($num));\n" if $do_setmagic; - } elsif ($expr =~ /^\s*\$arg\s*=/) { - # We expect that $arg has refcnt >=1, so we need - # to mortalize it! - eval "print qq\a$expr\a"; - warn $@ if $@; - print "\tsv_2mortal(ST(0));\n"; - print "\tSvSETMAGIC(ST(0));\n" if $do_setmagic; - } else { - # Just hope that the entry would safely write it - # over an already mortalized value. By - # coincidence, something like $arg = &sv_undef - # works too. - print "\tST(0) = sv_newmortal();\n"; - eval "print qq\a$expr\a"; - warn $@ if $@; - # new mortals don't have set magic + # We expect that $arg has refcnt 1, so we need to + # mortalize it. + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\tsv_2mortal(ST($num));\n"; + print "\tSvSETMAGIC(ST($num));\n" if $do_setmagic; + } + elsif ($expr =~ /^\s*\$arg\s*=/) { + # We expect that $arg has refcnt >=1, so we need + # to mortalize it! + eval "print qq\a$expr\a"; + warn $@ if $@; + print "\tsv_2mortal(ST(0));\n"; + print "\tSvSETMAGIC(ST(0));\n" if $do_setmagic; + } + else { + # Just hope that the entry would safely write it + # over an already mortalized value. By + # coincidence, something like $arg = &sv_undef + # works too. + print "\tST(0) = sv_newmortal();\n"; + eval "print qq\a$expr\a"; + warn $@ if $@; + # new mortals don't have set magic } - } elsif ($do_push) { + } + elsif ($do_push) { print "\tPUSHs(sv_newmortal());\n"; $arg = "ST($num)"; eval "print qq\a$expr\a"; - warn $@ if $@; + warn $@ if $@; print "\tSvSETMAGIC($arg);\n" if $do_setmagic; - } elsif ($arg =~ /^ST\(\d+\)$/) { + } + elsif ($arg =~ /^ST\(\d+\)$/) { eval "print qq\a$expr\a"; - warn $@ if $@; + warn $@ if $@; print "\tSvSETMAGIC($arg);\n" if $do_setmagic; } } } -sub map_type { - my($type, $varname) = @_; - - # C++ has :: in types too so skip this - $type =~ tr/:/_/ unless $hiertype; - $type =~ s/^array\(([^,]*),(.*)\).*/$1 */s; - if ($varname) { - if ($varname && $type =~ / \( \s* \* (?= \s* \) ) /xg) { - (substr $type, pos $type, 0) = " $varname "; - } else { - $type .= "\t$varname"; - } - } - $type; -} - - -######################################################### -package - ExtUtils::ParseXS::CountLines; -use strict; -use vars qw($SECTION_END_MARKER); - -sub TIEHANDLE { - my ($class, $cfile, $fh) = @_; - $cfile =~ s/\\/\\\\/g; - $SECTION_END_MARKER = qq{#line --- "$cfile"}; - - return bless {buffer => '', - fh => $fh, - line_no => 1, - }, $class; -} - -sub PRINT { - my $self = shift; - for (@_) { - $self->{buffer} .= $_; - while ($self->{buffer} =~ s/^([^\n]*\n)//) { - my $line = $1; - ++ $self->{line_no}; - $line =~ s|^\#line\s+---(?=\s)|#line $self->{line_no}|; - print {$self->{fh}} $line; - } - } -} - -sub PRINTF { - my $self = shift; - my $fmt = shift; - $self->PRINT(sprintf($fmt, @_)); -} - -sub DESTROY { - # Not necessary if we're careful to end with a "\n" - my $self = shift; - print {$self->{fh}} $self->{buffer}; -} - -sub UNTIE { - # This sub does nothing, but is necessary for references to be released. -} - -sub end_marker { - return $SECTION_END_MARKER; -} - - 1; -__END__ - -=head1 NAME - -ExtUtils::ParseXS - converts Perl XS code into C code - -=head1 SYNOPSIS - - use ExtUtils::ParseXS qw(process_file); - - process_file( filename => 'foo.xs' ); - - process_file( filename => 'foo.xs', - output => 'bar.c', - 'C++' => 1, - typemap => 'path/to/typemap', - hiertype => 1, - except => 1, - prototypes => 1, - versioncheck => 1, - linenumbers => 1, - optimize => 1, - prototypes => 1, - ); -=head1 DESCRIPTION - -C<ExtUtils::ParseXS> will compile XS code into C code by embedding the constructs -necessary to let C functions manipulate Perl values and creates the glue -necessary to let Perl access those functions. The compiler uses typemaps to -determine how to map C function parameters and variables to Perl values. - -The compiler will search for typemap files called I<typemap>. It will use -the following search path to find default typemaps, with the rightmost -typemap taking precedence. - - ../../../typemap:../../typemap:../typemap:typemap - -=head1 EXPORT - -None by default. C<process_file()> may be exported upon request. - - -=head1 FUNCTIONS - -=over 4 - -=item process_xs() - -This function processes an XS file and sends output to a C file. -Named parameters control how the processing is done. The following -parameters are accepted: - -=over 4 - -=item B<C++> - -Adds C<extern "C"> to the C code. Default is false. - -=item B<hiertype> - -Retains C<::> in type names so that C++ hierarchical types can be -mapped. Default is false. - -=item B<except> - -Adds exception handling stubs to the C code. Default is false. - -=item B<typemap> - -Indicates that a user-supplied typemap should take precedence over the -default typemaps. A single typemap may be specified as a string, or -multiple typemaps can be specified in an array reference, with the -last typemap having the highest precedence. - -=item B<prototypes> - -Generates prototype code for all xsubs. Default is false. - -=item B<versioncheck> - -Makes sure at run time that the object file (derived from the C<.xs> -file) and the C<.pm> files have the same version number. Default is -true. - -=item B<linenumbers> - -Adds C<#line> directives to the C output so error messages will look -like they came from the original XS file. Default is true. - -=item B<optimize> - -Enables certain optimizations. The only optimization that is currently -affected is the use of I<target>s by the output C code (see L<perlguts>). -Not optimizing may significantly slow down the generated code, but this is the way -B<xsubpp> of 5.005 and earlier operated. Default is to optimize. - -=item B<inout> - -Enable recognition of C<IN>, C<OUT_LIST> and C<INOUT_LIST> -declarations. Default is true. - -=item B<argtypes> - -Enable recognition of ANSI-like descriptions of function signature. -Default is true. - -=item B<s> - -I have no clue what this does. Strips function prefixes? - -=back - -=item errors() - -This function returns the number of [a certain kind of] errors -encountered during processing of the XS file. - -=back - -=head1 AUTHOR - -Based on xsubpp code, written by Larry Wall. - -Maintained by: - -=over 4 - -=item * - -Ken Williams, <ken@mathforum.org> - -=item * - -David Golden, <dagolden@cpan.org> - -=back - -=head1 COPYRIGHT - -Copyright 2002-2009 by Ken Williams, David Golden and other contributors. All -rights reserved. - -This library is free software; you can redistribute it and/or -modify it under the same terms as Perl itself. - -Based on the ExtUtils::xsubpp code by Larry Wall and the Perl 5 -Porters, which was released under the same license terms. - -=head1 SEE ALSO - -L<perl>, ExtUtils::xsubpp, ExtUtils::MakeMaker, L<perlxs>, L<perlxstut>. -=cut +# vim: ts=2 sw=2 et: diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pod b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pod new file mode 100644 index 00000000000..e0d1511e4a9 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS.pod @@ -0,0 +1,161 @@ +=head1 NAME + +ExtUtils::ParseXS - converts Perl XS code into C code + +=head1 SYNOPSIS + + use ExtUtils::ParseXS qw(process_file); + + process_file( filename => 'foo.xs' ); + + process_file( filename => 'foo.xs', + output => 'bar.c', + 'C++' => 1, + typemap => 'path/to/typemap', + hiertype => 1, + except => 1, + prototypes => 1, + versioncheck => 1, + linenumbers => 1, + optimize => 1, + prototypes => 1, + ); + +=head1 DESCRIPTION + +C<ExtUtils::ParseXS> will compile XS code into C code by embedding the constructs +necessary to let C functions manipulate Perl values and creates the glue +necessary to let Perl access those functions. The compiler uses typemaps to +determine how to map C function parameters and variables to Perl values. + +The compiler will search for typemap files called I<typemap>. It will use +the following search path to find default typemaps, with the rightmost +typemap taking precedence. + + ../../../typemap:../../typemap:../typemap:typemap + +=head1 EXPORT + +None by default. C<process_file()> may be exported upon request. + +=head1 FUNCTIONS + +=over 4 + +=item process_file() + +This function processes an XS file and sends output to a C file. +Named parameters control how the processing is done. The following +parameters are accepted: + +=over 4 + +=item B<C++> + +Adds C<extern "C"> to the C code. Default is false. + +=item B<hiertype> + +Retains C<::> in type names so that C++ hierarchical types can be +mapped. Default is false. + +=item B<except> + +Adds exception handling stubs to the C code. Default is false. + +=item B<typemap> + +Indicates that a user-supplied typemap should take precedence over the +default typemaps. A single typemap may be specified as a string, or +multiple typemaps can be specified in an array reference, with the +last typemap having the highest precedence. + +=item B<prototypes> + +Generates prototype code for all xsubs. Default is false. + +=item B<versioncheck> + +Makes sure at run time that the object file (derived from the C<.xs> +file) and the C<.pm> files have the same version number. Default is +true. + +=item B<linenumbers> + +Adds C<#line> directives to the C output so error messages will look +like they came from the original XS file. Default is true. + +=item B<optimize> + +Enables certain optimizations. The only optimization that is currently +affected is the use of I<target>s by the output C code (see L<perlguts>). +Not optimizing may significantly slow down the generated code, but this is the way +B<xsubpp> of 5.005 and earlier operated. Default is to optimize. + +=item B<inout> + +Enable recognition of C<IN>, C<OUT_LIST> and C<INOUT_LIST> +declarations. Default is true. + +=item B<argtypes> + +Enable recognition of ANSI-like descriptions of function signature. +Default is true. + +=item B<s> + +I<Maintainer note:> I have no clue what this does. Strips function prefixes? + +=back + +=item errors() + +This function returns the number of [a certain kind of] errors +encountered during processing of the XS file. + +=back + +=head1 AUTHOR + +Based on xsubpp code, written by Larry Wall. + +Maintained by: + +=over 4 + +=item * + +Ken Williams, <ken@mathforum.org> + +=item * + +David Golden, <dagolden@cpan.org> + +=item * + +James Keenan, <jkeenan@cpan.org> + +=item * + +Steffen Mueller, <smueller@cpan.org> + +=back + +=head1 COPYRIGHT + +Copyright 2002-2012 by Ken Williams, David Golden and other contributors. All +rights reserved. + +This library is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +Based on the C<ExtUtils::xsubpp> code by Larry Wall and the Perl 5 +Porters, which was released under the same license terms. + +=head1 SEE ALSO + +L<perl>, ExtUtils::xsubpp, ExtUtils::MakeMaker, L<perlxs>, L<perlxstut>. + +=cut + + diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/Constants.pm b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/Constants.pm new file mode 100644 index 00000000000..2f822dacbe9 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/Constants.pm @@ -0,0 +1,42 @@ +package ExtUtils::ParseXS::Constants; +use strict; +use warnings; +use Symbol; + +our $VERSION = '3.16'; + +=head1 NAME + +ExtUtils::ParseXS::Constants - Initialization values for some globals + +=head1 SYNOPSIS + + use ExtUtils::ParseXS::Constants (); + + $PrototypeRegexp = $ExtUtils::ParseXS::Constants::PrototypeRegexp; + +=head1 DESCRIPTION + +Initialization of certain non-subroutine variables in ExtUtils::ParseXS and some of its +supporting packages has been moved into this package so that those values can +be defined exactly once and then re-used in any package. + +Nothing is exported. Use fully qualified variable names. + +=cut + +# FIXME: THESE ARE NOT CONSTANTS! +our @InitFileCode; + +# Note that to reduce maintenance, $PrototypeRegexp is used +# by ExtUtils::Typemaps, too! +our $PrototypeRegexp = "[" . quotemeta('\$%&*@;[]_') . "]"; +our @XSKeywords = qw( + REQUIRE BOOT CASE PREINIT INPUT INIT CODE PPCODE + OUTPUT CLEANUP ALIAS ATTRS PROTOTYPES PROTOTYPE + VERSIONCHECK INCLUDE INCLUDE_COMMAND SCOPE INTERFACE + INTERFACE_MACRO C_ARGS POSTCALL OVERLOAD FALLBACK + EXPORT_XSUB_SYMBOLS +); + +1; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/CountLines.pm b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/CountLines.pm new file mode 100644 index 00000000000..66944cd629d --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/CountLines.pm @@ -0,0 +1,54 @@ +package ExtUtils::ParseXS::CountLines; +use strict; + +our $VERSION = '3.16'; + +our $SECTION_END_MARKER; + +sub TIEHANDLE { + my ($class, $cfile, $fh) = @_; + $cfile =~ s/\\/\\\\/g; + $cfile =~ s/"/\\"/g; + $SECTION_END_MARKER = qq{#line --- "$cfile"}; + + return bless { + buffer => '', + fh => $fh, + line_no => 1, + }, $class; +} + +sub PRINT { + my $self = shift; + for (@_) { + $self->{buffer} .= $_; + while ($self->{buffer} =~ s/^([^\n]*\n)//) { + my $line = $1; + ++$self->{line_no}; + $line =~ s|^\#line\s+---(?=\s)|#line $self->{line_no}|; + print {$self->{fh}} $line; + } + } +} + +sub PRINTF { + my $self = shift; + my $fmt = shift; + $self->PRINT(sprintf($fmt, @_)); +} + +sub DESTROY { + # Not necessary if we're careful to end with a "\n" + my $self = shift; + print {$self->{fh}} $self->{buffer}; +} + +sub UNTIE { + # This sub does nothing, but is necessary for references to be released. +} + +sub end_marker { + return $SECTION_END_MARKER; +} + +1; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/Utilities.pm b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/Utilities.pm new file mode 100644 index 00000000000..c4172d017ee --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/ParseXS/Utilities.pm @@ -0,0 +1,924 @@ +package ExtUtils::ParseXS::Utilities; +use strict; +use warnings; +use Exporter; +use File::Spec; +use lib qw( lib ); +use ExtUtils::ParseXS::Constants (); + +our $VERSION = '3.16'; + +our (@ISA, @EXPORT_OK); +@ISA = qw(Exporter); +@EXPORT_OK = qw( + standard_typemap_locations + trim_whitespace + tidy_type + C_string + valid_proto_string + process_typemaps + make_targetable + map_type + standard_XS_defs + assign_func_args + analyze_preprocessor_statements + set_cond + Warn + current_line_number + blurt + death + check_conditional_preprocessor_statements + escape_file_for_line_directive + report_typemap_failure +); + +=head1 NAME + +ExtUtils::ParseXS::Utilities - Subroutines used with ExtUtils::ParseXS + +=head1 SYNOPSIS + + use ExtUtils::ParseXS::Utilities qw( + standard_typemap_locations + trim_whitespace + tidy_type + C_string + valid_proto_string + process_typemaps + make_targetable + map_type + standard_XS_defs + assign_func_args + analyze_preprocessor_statements + set_cond + Warn + blurt + death + check_conditional_preprocessor_statements + escape_file_for_line_directive + report_typemap_failure + ); + +=head1 SUBROUTINES + +The following functions are not considered to be part of the public interface. +They are documented here for the benefit of future maintainers of this module. + +=head2 C<standard_typemap_locations()> + +=over 4 + +=item * Purpose + +Provide a list of filepaths where F<typemap> files may be found. The +filepaths -- relative paths to files (not just directory paths) -- appear in this list in lowest-to-highest priority. + +The highest priority is to look in the current directory. + + 'typemap' + +The second and third highest priorities are to look in the parent of the +current directory and a directory called F<lib/ExtUtils> underneath the parent +directory. + + '../typemap', + '../lib/ExtUtils/typemap', + +The fourth through ninth highest priorities are to look in the corresponding +grandparent, great-grandparent and great-great-grandparent directories. + + '../../typemap', + '../../lib/ExtUtils/typemap', + '../../../typemap', + '../../../lib/ExtUtils/typemap', + '../../../../typemap', + '../../../../lib/ExtUtils/typemap', + +The tenth and subsequent priorities are to look in directories named +F<ExtUtils> which are subdirectories of directories found in C<@INC> -- +I<provided> a file named F<typemap> actually exists in such a directory. +Example: + + '/usr/local/lib/perl5/5.10.1/ExtUtils/typemap', + +However, these filepaths appear in the list returned by +C<standard_typemap_locations()> in reverse order, I<i.e.>, lowest-to-highest. + + '/usr/local/lib/perl5/5.10.1/ExtUtils/typemap', + '../../../../lib/ExtUtils/typemap', + '../../../../typemap', + '../../../lib/ExtUtils/typemap', + '../../../typemap', + '../../lib/ExtUtils/typemap', + '../../typemap', + '../lib/ExtUtils/typemap', + '../typemap', + 'typemap' + +=item * Arguments + + my @stl = standard_typemap_locations( \@INC ); + +Reference to C<@INC>. + +=item * Return Value + +Array holding list of directories to be searched for F<typemap> files. + +=back + +=cut + +sub standard_typemap_locations { + my $include_ref = shift; + my @tm = qw(typemap); + + my $updir = File::Spec->updir(); + foreach my $dir ( + File::Spec->catdir(($updir) x 1), + File::Spec->catdir(($updir) x 2), + File::Spec->catdir(($updir) x 3), + File::Spec->catdir(($updir) x 4), + ) { + unshift @tm, File::Spec->catfile($dir, 'typemap'); + unshift @tm, File::Spec->catfile($dir, lib => ExtUtils => 'typemap'); + } + foreach my $dir (@{ $include_ref}) { + my $file = File::Spec->catfile($dir, ExtUtils => 'typemap'); + unshift @tm, $file if -e $file; + } + return @tm; +} + +=head2 C<trim_whitespace()> + +=over 4 + +=item * Purpose + +Perform an in-place trimming of leading and trailing whitespace from the +first argument provided to the function. + +=item * Argument + + trim_whitespace($arg); + +=item * Return Value + +None. Remember: this is an I<in-place> modification of the argument. + +=back + +=cut + +sub trim_whitespace { + $_[0] =~ s/^\s+|\s+$//go; +} + +=head2 C<tidy_type()> + +=over 4 + +=item * Purpose + +Rationalize any asterisks (C<*>) by joining them into bunches, removing +interior whitespace, then trimming leading and trailing whitespace. + +=item * Arguments + + ($ret_type) = tidy_type($_); + +String to be cleaned up. + +=item * Return Value + +String cleaned up. + +=back + +=cut + +sub tidy_type { + local ($_) = @_; + + # rationalise any '*' by joining them into bunches and removing whitespace + s#\s*(\*+)\s*#$1#g; + s#(\*+)# $1 #g; + + # change multiple whitespace into a single space + s/\s+/ /g; + + # trim leading & trailing whitespace + trim_whitespace($_); + + $_; +} + +=head2 C<C_string()> + +=over 4 + +=item * Purpose + +Escape backslashes (C<\>) in prototype strings. + +=item * Arguments + + $ProtoThisXSUB = C_string($_); + +String needing escaping. + +=item * Return Value + +Properly escaped string. + +=back + +=cut + +sub C_string { + my($string) = @_; + + $string =~ s[\\][\\\\]g; + $string; +} + +=head2 C<valid_proto_string()> + +=over 4 + +=item * Purpose + +Validate prototype string. + +=item * Arguments + +String needing checking. + +=item * Return Value + +Upon success, returns the same string passed as argument. + +Upon failure, returns C<0>. + +=back + +=cut + +sub valid_proto_string { + my($string) = @_; + + if ( $string =~ /^$ExtUtils::ParseXS::Constants::PrototypeRegexp+$/ ) { + return $string; + } + + return 0; +} + +=head2 C<process_typemaps()> + +=over 4 + +=item * Purpose + +Process all typemap files. + +=item * Arguments + + my $typemaps_object = process_typemaps( $args{typemap}, $pwd ); + +List of two elements: C<typemap> element from C<%args>; current working +directory. + +=item * Return Value + +Upon success, returns an L<ExtUtils::Typemaps> object. + +=back + +=cut + +sub process_typemaps { + my ($tmap, $pwd) = @_; + + my @tm = ref $tmap ? @{$tmap} : ($tmap); + + foreach my $typemap (@tm) { + die "Can't find $typemap in $pwd\n" unless -r $typemap; + } + + push @tm, standard_typemap_locations( \@INC ); + + require ExtUtils::Typemaps; + my $typemap = ExtUtils::Typemaps->new; + foreach my $typemap_loc (@tm) { + next unless -f $typemap_loc; + # skip directories, binary files etc. + warn("Warning: ignoring non-text typemap file '$typemap_loc'\n"), next + unless -T $typemap_loc; + + $typemap->merge(file => $typemap_loc, replace => 1); + } + + return $typemap; +} + +=head2 C<make_targetable()> + +=over 4 + +=item * Purpose + +Populate C<%targetable>. This constitutes a refinement of the output of +C<process_typemaps()> with respect to its fourth output, C<$output_expr_ref>. + +=item * Arguments + + %targetable = make_targetable($output_expr_ref); + +Single hash reference: the fourth such ref returned by C<process_typemaps()>. + +=item * Return Value + +Hash. + +=back + +=cut + +sub make_targetable { + my $output_expr_ref = shift; + + our $bal; # ()-balanced + $bal = qr[ + (?: + (?>[^()]+) + | + \( (??{ $bal }) \) + )* + ]x; + + # matches variations on (SV*) + my $sv_cast = qr[ + (?: + \( \s* SV \s* \* \s* \) \s* + )? + ]x; + + my $size = qr[ # Third arg (to setpvn) + , \s* (??{ $bal }) + ]x; + + my %targetable; + foreach my $key (keys %{ $output_expr_ref }) { + # We can still bootstrap compile 're', because in code re.pm is + # available to miniperl, and does not attempt to load the XS code. + use re 'eval'; + + my ($type, $with_size, $arg, $sarg) = + ($output_expr_ref->{$key} =~ + m[^ + \s+ + sv_set([iunp])v(n)? # Type, is_setpvn + \s* + \( \s* + $sv_cast \$arg \s* , \s* + ( (??{ $bal }) ) # Set from + ( (??{ $size }) )? # Possible sizeof set-from + \) \s* ; \s* $ + ]x + ); + $targetable{$key} = [$type, $with_size, $arg, $sarg] if $type; + } + return %targetable; +} + +=head2 C<map_type()> + +=over 4 + +=item * Purpose + +Performs a mapping at several places inside C<PARAGRAPH> loop. + +=item * Arguments + + $type = map_type($self, $type, $varname); + +List of three arguments. + +=item * Return Value + +String holding augmented version of second argument. + +=back + +=cut + +sub map_type { + my ($self, $type, $varname) = @_; + + # C++ has :: in types too so skip this + $type =~ tr/:/_/ unless $self->{hiertype}; + $type =~ s/^array\(([^,]*),(.*)\).*/$1 */s; + if ($varname) { + if ($type =~ / \( \s* \* (?= \s* \) ) /xg) { + (substr $type, pos $type, 0) = " $varname "; + } + else { + $type .= "\t$varname"; + } + } + return $type; +} + +=head2 C<standard_XS_defs()> + +=over 4 + +=item * Purpose + +Writes to the C<.c> output file certain preprocessor directives and function +headers needed in all such files. + +=item * Arguments + +None. + +=item * Return Value + +Returns true. + +=back + +=cut + +sub standard_XS_defs { + print <<"EOF"; +#ifndef PERL_UNUSED_VAR +# define PERL_UNUSED_VAR(var) if (0) var = var +#endif + +#ifndef dVAR +# define dVAR dNOOP +#endif + + +/* This stuff is not part of the API! You have been warned. */ +#ifndef PERL_VERSION_DECIMAL +# define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s) +#endif +#ifndef PERL_DECIMAL_VERSION +# define PERL_DECIMAL_VERSION \\ + PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION) +#endif +#ifndef PERL_VERSION_GE +# define PERL_VERSION_GE(r,v,s) \\ + (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s)) +#endif +#ifndef PERL_VERSION_LE +# define PERL_VERSION_LE(r,v,s) \\ + (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s)) +#endif + +/* XS_INTERNAL is the explicit static-linkage variant of the default + * XS macro. + * + * XS_EXTERNAL is the same as XS_INTERNAL except it does not include + * "STATIC", ie. it exports XSUB symbols. You probably don't want that + * for anything but the BOOT XSUB. + * + * See XSUB.h in core! + */ + + +/* TODO: This might be compatible further back than 5.10.0. */ +#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1) +# undef XS_EXTERNAL +# undef XS_INTERNAL +# if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING) +# define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name) +# define XS_INTERNAL(name) STATIC XSPROTO(name) +# endif +# if defined(__SYMBIAN32__) +# define XS_EXTERNAL(name) EXPORT_C XSPROTO(name) +# define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name) +# endif +# ifndef XS_EXTERNAL +# if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus) +# define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__) +# define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__) +# else +# ifdef __cplusplus +# define XS_EXTERNAL(name) extern "C" XSPROTO(name) +# define XS_INTERNAL(name) static XSPROTO(name) +# else +# define XS_EXTERNAL(name) XSPROTO(name) +# define XS_INTERNAL(name) STATIC XSPROTO(name) +# endif +# endif +# endif +#endif + +/* perl >= 5.10.0 && perl <= 5.15.1 */ + + +/* The XS_EXTERNAL macro is used for functions that must not be static + * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL + * macro defined, the best we can do is assume XS is the same. + * Dito for XS_INTERNAL. + */ +#ifndef XS_EXTERNAL +# define XS_EXTERNAL(name) XS(name) +#endif +#ifndef XS_INTERNAL +# define XS_INTERNAL(name) XS(name) +#endif + +/* Now, finally, after all this mess, we want an ExtUtils::ParseXS + * internal macro that we're free to redefine for varying linkage due + * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use + * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to! + */ + +#undef XS_EUPXS +#if defined(PERL_EUPXS_ALWAYS_EXPORT) +# define XS_EUPXS(name) XS_EXTERNAL(name) +#else + /* default to internal */ +# define XS_EUPXS(name) XS_INTERNAL(name) +#endif + +EOF + + print <<"EOF"; +#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE +#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params) + +/* prototype to pass -Wmissing-prototypes */ +STATIC void +S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params); + +STATIC void +S_croak_xs_usage(pTHX_ const CV *const cv, const char *const params) +{ + const GV *const gv = CvGV(cv); + + PERL_ARGS_ASSERT_CROAK_XS_USAGE; + + if (gv) { + const char *const gvname = GvNAME(gv); + const HV *const stash = GvSTASH(gv); + const char *const hvname = stash ? HvNAME(stash) : NULL; + + if (hvname) + Perl_croak(aTHX_ "Usage: %s::%s(%s)", hvname, gvname, params); + else + Perl_croak(aTHX_ "Usage: %s(%s)", gvname, params); + } else { + /* Pants. I don't think that it should be possible to get here. */ + Perl_croak(aTHX_ "Usage: CODE(0x%"UVxf")(%s)", PTR2UV(cv), params); + } +} +#undef PERL_ARGS_ASSERT_CROAK_XS_USAGE + +#ifdef PERL_IMPLICIT_CONTEXT +#define croak_xs_usage(a,b) S_croak_xs_usage(aTHX_ a,b) +#else +#define croak_xs_usage S_croak_xs_usage +#endif + +#endif + +/* NOTE: the prototype of newXSproto() is different in versions of perls, + * so we define a portable version of newXSproto() + */ +#ifdef newXS_flags +#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0) +#else +#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv) +#endif /* !defined(newXS_flags) */ + +EOF + return 1; +} + +=head2 C<assign_func_args()> + +=over 4 + +=item * Purpose + +Perform assignment to the C<func_args> attribute. + +=item * Arguments + + $string = assign_func_args($self, $argsref, $class); + +List of three elements. Second is an array reference; third is a string. + +=item * Return Value + +String. + +=back + +=cut + +sub assign_func_args { + my ($self, $argsref, $class) = @_; + my @func_args = @{$argsref}; + shift @func_args if defined($class); + + for my $arg (@func_args) { + $arg =~ s/^/&/ if $self->{in_out}->{$arg}; + } + return join(", ", @func_args); +} + +=head2 C<analyze_preprocessor_statements()> + +=over 4 + +=item * Purpose + +Within each function inside each Xsub, print to the F<.c> output file certain +preprocessor statements. + +=item * Arguments + + ( $self, $XSS_work_idx, $BootCode_ref ) = + analyze_preprocessor_statements( + $self, $statement, $XSS_work_idx, $BootCode_ref + ); + +List of four elements. + +=item * Return Value + +Modifed values of three of the arguments passed to the function. In +particular, the C<XSStack> and C<InitFileCode> attributes are modified. + +=back + +=cut + +sub analyze_preprocessor_statements { + my ($self, $statement, $XSS_work_idx, $BootCode_ref) = @_; + + if ($statement eq 'if') { + $XSS_work_idx = @{ $self->{XSStack} }; + push(@{ $self->{XSStack} }, {type => 'if'}); + } + else { + $self->death("Error: '$statement' with no matching 'if'") + if $self->{XSStack}->[-1]{type} ne 'if'; + if ($self->{XSStack}->[-1]{varname}) { + push(@{ $self->{InitFileCode} }, "#endif\n"); + push(@{ $BootCode_ref }, "#endif"); + } + + my(@fns) = keys %{$self->{XSStack}->[-1]{functions}}; + if ($statement ne 'endif') { + # Hide the functions defined in other #if branches, and reset. + @{$self->{XSStack}->[-1]{other_functions}}{@fns} = (1) x @fns; + @{$self->{XSStack}->[-1]}{qw(varname functions)} = ('', {}); + } + else { + my($tmp) = pop(@{ $self->{XSStack} }); + 0 while (--$XSS_work_idx + && $self->{XSStack}->[$XSS_work_idx]{type} ne 'if'); + # Keep all new defined functions + push(@fns, keys %{$tmp->{other_functions}}); + @{$self->{XSStack}->[$XSS_work_idx]{functions}}{@fns} = (1) x @fns; + } + } + return ($self, $XSS_work_idx, $BootCode_ref); +} + +=head2 C<set_cond()> + +=over 4 + +=item * Purpose + +=item * Arguments + +=item * Return Value + +=back + +=cut + +sub set_cond { + my ($ellipsis, $min_args, $num_args) = @_; + my $cond; + if ($ellipsis) { + $cond = ($min_args ? qq(items < $min_args) : 0); + } + elsif ($min_args == $num_args) { + $cond = qq(items != $min_args); + } + else { + $cond = qq(items < $min_args || items > $num_args); + } + return $cond; +} + +=head2 C<current_line_number()> + +=over 4 + +=item * Purpose + +Figures out the current line number in the XS file. + +=item * Arguments + +C<$self> + +=item * Return Value + +The current line number. + +=back + +=cut + +sub current_line_number { + my $self = shift; + my $line_number = $self->{line_no}->[@{ $self->{line_no} } - @{ $self->{line} } -1]; + return $line_number; +} + +=head2 C<Warn()> + +=over 4 + +=item * Purpose + +=item * Arguments + +=item * Return Value + +=back + +=cut + +sub Warn { + my $self = shift; + my $warn_line_number = $self->current_line_number(); + print STDERR "@_ in $self->{filename}, line $warn_line_number\n"; +} + +=head2 C<blurt()> + +=over 4 + +=item * Purpose + +=item * Arguments + +=item * Return Value + +=back + +=cut + +sub blurt { + my $self = shift; + $self->Warn(@_); + $self->{errors}++ +} + +=head2 C<death()> + +=over 4 + +=item * Purpose + +=item * Arguments + +=item * Return Value + +=back + +=cut + +sub death { + my $self = shift; + $self->Warn(@_); + exit 1; +} + +=head2 C<check_conditional_preprocessor_statements()> + +=over 4 + +=item * Purpose + +=item * Arguments + +=item * Return Value + +=back + +=cut + +sub check_conditional_preprocessor_statements { + my ($self) = @_; + my @cpp = grep(/^\#\s*(?:if|e\w+)/, @{ $self->{line} }); + if (@cpp) { + my $cpplevel; + for my $cpp (@cpp) { + if ($cpp =~ /^\#\s*if/) { + $cpplevel++; + } + elsif (!$cpplevel) { + $self->Warn("Warning: #else/elif/endif without #if in this function"); + print STDERR " (precede it with a blank line if the matching #if is outside the function)\n" + if $self->{XSStack}->[-1]{type} eq 'if'; + return; + } + elsif ($cpp =~ /^\#\s*endif/) { + $cpplevel--; + } + } + $self->Warn("Warning: #if without #endif in this function") if $cpplevel; + } +} + +=head2 C<escape_file_for_line_directive()> + +=over 4 + +=item * Purpose + +Escapes a given code source name (typically a file name but can also +be a command that was read from) so that double-quotes and backslashes are escaped. + +=item * Arguments + +A string. + +=item * Return Value + +A string with escapes for double-quotes and backslashes. + +=back + +=cut + +sub escape_file_for_line_directive { + my $string = shift; + $string =~ s/\\/\\\\/g; + $string =~ s/"/\\"/g; + return $string; +} + +=head2 C<report_typemap_failure> + +=over 4 + +=item * Purpose + +Do error reporting for missing typemaps. + +=item * Arguments + +The C<ExtUtils::ParseXS> object. + +An C<ExtUtils::Typemaps> object. + +The string that represents the C type that was not found in the typemap. + +Optionally, the string C<death> or C<blurt> to choose +whether the error is immediately fatal or not. Default: C<blurt> + +=item * Return Value + +Returns nothing. Depending on the arguments, this +may call C<death> or C<blurt>, the former of which is +fatal. + +=back + +=cut + +sub report_typemap_failure { + my ($self, $tm, $ctype, $error_method) = @_; + $error_method ||= 'blurt'; + + my @avail_ctypes = $tm->list_mapped_ctypes; + + my $err = "Could not find a typemap for C type '$ctype'.\n" + . "The following C types are mapped by the current typemap:\n'" + . join("', '", @avail_ctypes) . "'\n"; + + $self->$error_method($err); + return(); +} + +1; + +# vim: ts=2 sw=2 et: diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps.pm new file mode 100644 index 00000000000..2bc9c8036f1 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps.pm @@ -0,0 +1,1031 @@ +package ExtUtils::Typemaps; +use 5.006001; +use strict; +use warnings; +our $VERSION = '3.16'; +#use Carp qw(croak); + +require ExtUtils::ParseXS; +require ExtUtils::ParseXS::Constants; +require ExtUtils::Typemaps::InputMap; +require ExtUtils::Typemaps::OutputMap; +require ExtUtils::Typemaps::Type; + +=head1 NAME + +ExtUtils::Typemaps - Read/Write/Modify Perl/XS typemap files + +=head1 SYNOPSIS + + # read/create file + my $typemap = ExtUtils::Typemaps->new(file => 'typemap'); + # alternatively create an in-memory typemap + # $typemap = ExtUtils::Typemaps->new(); + # alternatively create an in-memory typemap by parsing a string + # $typemap = ExtUtils::Typemaps->new(string => $sometypemap); + + # add a mapping + $typemap->add_typemap(ctype => 'NV', xstype => 'T_NV'); + $typemap->add_inputmap( + xstype => 'T_NV', code => '$var = ($type)SvNV($arg);' + ); + $typemap->add_outputmap( + xstype => 'T_NV', code => 'sv_setnv($arg, (NV)$var);' + ); + $typemap->add_string(string => $typemapstring); + # will be parsed and merged + + # remove a mapping (same for remove_typemap and remove_outputmap...) + $typemap->remove_inputmap(xstype => 'SomeType'); + + # save a typemap to a file + $typemap->write(file => 'anotherfile.map'); + + # merge the other typemap into this one + $typemap->merge(typemap => $another_typemap); + +=head1 DESCRIPTION + +This module can read, modify, create and write Perl XS typemap files. If you don't know +what a typemap is, please confer the L<perlxstut> and L<perlxs> manuals. + +The module is not entirely round-trip safe: For example it currently simply strips all comments. +The order of entries in the maps is, however, preserved. + +We check for duplicate entries in the typemap, but do not check for missing +C<TYPEMAP> entries for C<INPUTMAP> or C<OUTPUTMAP> entries since these might be hidden +in a different typemap. + +=head1 METHODS + +=cut + +=head2 new + +Returns a new typemap object. Takes an optional C<file> parameter. +If set, the given file will be read. If the file doesn't exist, an empty typemap +is returned. + +Alternatively, if the C<string> parameter is given, the supplied +string will be parsed instead of a file. + +=cut + +sub new { + my $class = shift; + my %args = @_; + + if (defined $args{file} and defined $args{string}) { + die("Cannot handle both 'file' and 'string' arguments to constructor"); + } + + my $self = bless { + file => undef, + %args, + typemap_section => [], + typemap_lookup => {}, + input_section => [], + input_lookup => {}, + output_section => [], + output_lookup => {}, + } => $class; + + $self->_init(); + + return $self; +} + +sub _init { + my $self = shift; + if (defined $self->{string}) { + $self->_parse(\($self->{string}), $self->{lineno_offset}, $self->{fake_filename}); + delete $self->{string}; + } + elsif (defined $self->{file} and -e $self->{file}) { + open my $fh, '<', $self->{file} + or die "Cannot open typemap file '" + . $self->{file} . "' for reading: $!"; + local $/ = undef; + my $string = <$fh>; + $self->_parse(\$string, $self->{lineno_offset}, $self->{file}); + } +} + +=head2 file + +Get/set the file that the typemap is written to when the +C<write> method is called. + +=cut + +sub file { + $_[0]->{file} = $_[1] if @_ > 1; + $_[0]->{file} +} + +=head2 add_typemap + +Add a C<TYPEMAP> entry to the typemap. + +Required named arguments: The C<ctype> (e.g. C<ctype =E<gt> 'double'>) +and the C<xstype> (e.g. C<xstype =E<gt> 'T_NV'>). + +Optional named arguments: C<replace =E<gt> 1> forces removal/replacement of +existing C<TYPEMAP> entries of the same C<ctype>. C<skip =E<gt> 1> +triggers a I<"first come first serve"> logic by which new entries that conflict +with existing entries are silently ignored. + +As an alternative to the named parameters usage, you may pass in +an C<ExtUtils::Typemaps::Type> object as first argument, a copy of which will be +added to the typemap. In that case, only the C<replace> or C<skip> named parameters +may be used after the object. Example: + + $map->add_typemap($type_obj, replace => 1); + +=cut + +sub add_typemap { + my $self = shift; + my $type; + my %args; + + if ((@_ % 2) == 1) { + my $orig = shift; + $type = $orig->new(); + %args = @_; + } + else { + %args = @_; + my $ctype = $args{ctype}; + die("Need ctype argument") if not defined $ctype; + my $xstype = $args{xstype}; + die("Need xstype argument") if not defined $xstype; + + $type = ExtUtils::Typemaps::Type->new( + xstype => $xstype, + 'prototype' => $args{'prototype'}, + ctype => $ctype, + ); + } + + if ($args{skip} and $args{replace}) { + die("Cannot use both 'skip' and 'replace'"); + } + + if ($args{replace}) { + $self->remove_typemap(ctype => $type->ctype); + } + elsif ($args{skip}) { + return() if exists $self->{typemap_lookup}{$type->ctype}; + } + else { + $self->validate(typemap_xstype => $type->xstype, ctype => $type->ctype); + } + + # store + push @{$self->{typemap_section}}, $type; + # remember type for lookup, too. + $self->{typemap_lookup}{$type->tidy_ctype} = $#{$self->{typemap_section}}; + + return 1; +} + +=head2 add_inputmap + +Add an C<INPUT> entry to the typemap. + +Required named arguments: +The C<xstype> (e.g. C<xstype =E<gt> 'T_NV'>) +and the C<code> to associate with it for input. + +Optional named arguments: C<replace =E<gt> 1> forces removal/replacement of +existing C<INPUT> entries of the same C<xstype>. C<skip =E<gt> 1> +triggers a I<"first come first serve"> logic by which new entries that conflict +with existing entries are silently ignored. + +As an alternative to the named parameters usage, you may pass in +an C<ExtUtils::Typemaps::InputMap> object as first argument, a copy of which will be +added to the typemap. In that case, only the C<replace> or C<skip> named parameters +may be used after the object. Example: + + $map->add_inputmap($type_obj, replace => 1); + +=cut + +sub add_inputmap { + my $self = shift; + my $input; + my %args; + + if ((@_ % 2) == 1) { + my $orig = shift; + $input = $orig->new(); + %args = @_; + } + else { + %args = @_; + my $xstype = $args{xstype}; + die("Need xstype argument") if not defined $xstype; + my $code = $args{code}; + die("Need code argument") if not defined $code; + + $input = ExtUtils::Typemaps::InputMap->new( + xstype => $xstype, + code => $code, + ); + } + + if ($args{skip} and $args{replace}) { + die("Cannot use both 'skip' and 'replace'"); + } + + if ($args{replace}) { + $self->remove_inputmap(xstype => $input->xstype); + } + elsif ($args{skip}) { + return() if exists $self->{input_lookup}{$input->xstype}; + } + else { + $self->validate(inputmap_xstype => $input->xstype); + } + + # store + push @{$self->{input_section}}, $input; + # remember type for lookup, too. + $self->{input_lookup}{$input->xstype} = $#{$self->{input_section}}; + + return 1; +} + +=head2 add_outputmap + +Add an C<OUTPUT> entry to the typemap. +Works exactly the same as C<add_inputmap>. + +=cut + +sub add_outputmap { + my $self = shift; + my $output; + my %args; + + if ((@_ % 2) == 1) { + my $orig = shift; + $output = $orig->new(); + %args = @_; + } + else { + %args = @_; + my $xstype = $args{xstype}; + die("Need xstype argument") if not defined $xstype; + my $code = $args{code}; + die("Need code argument") if not defined $code; + + $output = ExtUtils::Typemaps::OutputMap->new( + xstype => $xstype, + code => $code, + ); + } + + if ($args{skip} and $args{replace}) { + die("Cannot use both 'skip' and 'replace'"); + } + + if ($args{replace}) { + $self->remove_outputmap(xstype => $output->xstype); + } + elsif ($args{skip}) { + return() if exists $self->{output_lookup}{$output->xstype}; + } + else { + $self->validate(outputmap_xstype => $output->xstype); + } + + # store + push @{$self->{output_section}}, $output; + # remember type for lookup, too. + $self->{output_lookup}{$output->xstype} = $#{$self->{output_section}}; + + return 1; +} + +=head2 add_string + +Parses a string as a typemap and merge it into the typemap object. + +Required named argument: C<string> to specify the string to parse. + +=cut + +sub add_string { + my $self = shift; + my %args = @_; + die("Need 'string' argument") if not defined $args{string}; + + # no, this is not elegant. + my $other = ExtUtils::Typemaps->new(string => $args{string}); + $self->merge(typemap => $other); +} + +=head2 remove_typemap + +Removes a C<TYPEMAP> entry from the typemap. + +Required named argument: C<ctype> to specify the entry to remove from the typemap. + +Alternatively, you may pass a single C<ExtUtils::Typemaps::Type> object. + +=cut + +sub remove_typemap { + my $self = shift; + my $ctype; + if (@_ > 1) { + my %args = @_; + $ctype = $args{ctype}; + die("Need ctype argument") if not defined $ctype; + $ctype = _tidy_type($ctype); + } + else { + $ctype = $_[0]->tidy_ctype; + } + + return $self->_remove($ctype, $self->{typemap_section}, $self->{typemap_lookup}); +} + +=head2 remove_inputmap + +Removes an C<INPUT> entry from the typemap. + +Required named argument: C<xstype> to specify the entry to remove from the typemap. + +Alternatively, you may pass a single C<ExtUtils::Typemaps::InputMap> object. + +=cut + +sub remove_inputmap { + my $self = shift; + my $xstype; + if (@_ > 1) { + my %args = @_; + $xstype = $args{xstype}; + die("Need xstype argument") if not defined $xstype; + } + else { + $xstype = $_[0]->xstype; + } + + return $self->_remove($xstype, $self->{input_section}, $self->{input_lookup}); +} + +=head2 remove_inputmap + +Removes an C<OUTPUT> entry from the typemap. + +Required named argument: C<xstype> to specify the entry to remove from the typemap. + +Alternatively, you may pass a single C<ExtUtils::Typemaps::OutputMap> object. + +=cut + +sub remove_outputmap { + my $self = shift; + my $xstype; + if (@_ > 1) { + my %args = @_; + $xstype = $args{xstype}; + die("Need xstype argument") if not defined $xstype; + } + else { + $xstype = $_[0]->xstype; + } + + return $self->_remove($xstype, $self->{output_section}, $self->{output_lookup}); +} + +sub _remove { + my $self = shift; + my $rm = shift; + my $array = shift; + my $lookup = shift; + + # Just fetch the index of the item from the lookup table + my $index = $lookup->{$rm}; + return() if not defined $index; + + # Nuke the item from storage + splice(@$array, $index, 1); + + # Decrement the storage position of all items thereafter + foreach my $key (keys %$lookup) { + if ($lookup->{$key} > $index) { + $lookup->{$key}--; + } + } + return(); +} + +=head2 get_typemap + +Fetches an entry of the TYPEMAP section of the typemap. + +Mandatory named arguments: The C<ctype> of the entry. + +Returns the C<ExtUtils::Typemaps::Type> +object for the entry if found. + +=cut + +sub get_typemap { + my $self = shift; + die("Need named parameters, got uneven number") if @_ % 2; + + my %args = @_; + my $ctype = $args{ctype}; + die("Need ctype argument") if not defined $ctype; + $ctype = _tidy_type($ctype); + + my $index = $self->{typemap_lookup}{$ctype}; + return() if not defined $index; + return $self->{typemap_section}[$index]; +} + +=head2 get_inputmap + +Fetches an entry of the INPUT section of the +typemap. + +Mandatory named arguments: The C<xstype> of the +entry or the C<ctype> of the typemap that can be used to find +the C<xstype>. To wit, the following pieces of code +are equivalent: + + my $type = $typemap->get_typemap(ctype => $ctype) + my $input_map = $typemap->get_inputmap(xstype => $type->xstype); + + my $input_map = $typemap->get_inputmap(ctype => $ctype); + +Returns the C<ExtUtils::Typemaps::InputMap> +object for the entry if found. + +=cut + +sub get_inputmap { + my $self = shift; + die("Need named parameters, got uneven number") if @_ % 2; + + my %args = @_; + my $xstype = $args{xstype}; + my $ctype = $args{ctype}; + die("Need xstype or ctype argument") + if not defined $xstype + and not defined $ctype; + die("Need xstype OR ctype arguments, not both") + if defined $xstype and defined $ctype; + + if (defined $ctype) { + my $tm = $self->get_typemap(ctype => $ctype); + $xstype = $tm && $tm->xstype; + return() if not defined $xstype; + } + + my $index = $self->{input_lookup}{$xstype}; + return() if not defined $index; + return $self->{input_section}[$index]; +} + +=head2 get_outputmap + +Fetches an entry of the OUTPUT section of the +typemap. + +Mandatory named arguments: The C<xstype> of the +entry or the C<ctype> of the typemap that can be used to +resolve the C<xstype>. (See above for an example.) + +Returns the C<ExtUtils::Typemaps::InputMap> +object for the entry if found. + +=cut + +sub get_outputmap { + my $self = shift; + die("Need named parameters, got uneven number") if @_ % 2; + + my %args = @_; + my $xstype = $args{xstype}; + my $ctype = $args{ctype}; + die("Need xstype or ctype argument") + if not defined $xstype + and not defined $ctype; + die("Need xstype OR ctype arguments, not both") + if defined $xstype and defined $ctype; + + if (defined $ctype) { + my $tm = $self->get_typemap(ctype => $ctype); + $xstype = $tm && $tm->xstype; + return() if not defined $xstype; + } + + my $index = $self->{output_lookup}{$xstype}; + return() if not defined $index; + return $self->{output_section}[$index]; +} + +=head2 write + +Write the typemap to a file. Optionally takes a C<file> argument. If given, the +typemap will be written to the specified file. If not, the typemap is written +to the currently stored file name (see C<-E<gt>file> above, this defaults to the file +it was read from if any). + +=cut + +sub write { + my $self = shift; + my %args = @_; + my $file = defined $args{file} ? $args{file} : $self->file(); + die("write() needs a file argument (or set the file name of the typemap using the 'file' method)") + if not defined $file; + + open my $fh, '>', $file + or die "Cannot open typemap file '$file' for writing: $!"; + print $fh $self->as_string(); + close $fh; +} + +=head2 as_string + +Generates and returns the string form of the typemap. + +=cut + +sub as_string { + my $self = shift; + my $typemap = $self->{typemap_section}; + my @code; + push @code, "TYPEMAP\n"; + foreach my $entry (@$typemap) { + # type kind proto + # /^(.*?\S)\s+(\S+)\s*($ExtUtils::ParseXS::Constants::PrototypeRegexp*)$/o + push @code, $entry->ctype . "\t" . $entry->xstype + . ($entry->proto ne '' ? "\t".$entry->proto : '') . "\n"; + } + + my $input = $self->{input_section}; + if (@$input) { + push @code, "\nINPUT\n"; + foreach my $entry (@$input) { + push @code, $entry->xstype, "\n", $entry->code, "\n"; + } + } + + my $output = $self->{output_section}; + if (@$output) { + push @code, "\nOUTPUT\n"; + foreach my $entry (@$output) { + push @code, $entry->xstype, "\n", $entry->code, "\n"; + } + } + return join '', @code; +} + +=head2 as_embedded_typemap + +Generates and returns the string form of the typemap with the +appropriate prefix around it for verbatim inclusion into an +XS file as an embedded typemap. This will return a string like + + TYPEMAP: <<END_OF_TYPEMAP + ... typemap here (see as_string) ... + END_OF_TYPEMAP + +The method takes care not to use a HERE-doc end marker that +appears in the typemap string itself. + +=cut + +sub as_embedded_typemap { + my $self = shift; + my $string = $self->as_string; + + my @ident_cand = qw(END_TYPEMAP END_OF_TYPEMAP END); + my $icand = 0; + my $cand_suffix = ""; + while ($string =~ /^\Q$ident_cand[$icand]$cand_suffix\E\s*$/m) { + $icand++; + if ($icand == @ident_cand) { + $icand = 0; + ++$cand_suffix; + } + } + + my $marker = "$ident_cand[$icand]$cand_suffix"; + return "TYPEMAP: <<$marker;\n$string\n$marker\n"; +} + +=head2 merge + +Merges a given typemap into the object. Note that a failed merge +operation leaves the object in an inconsistent state so clone it if necessary. + +Mandatory named arguments: Either C<typemap =E<gt> $another_typemap_obj> +or C<file =E<gt> $path_to_typemap_file> but not both. + +Optional arguments: C<replace =E<gt> 1> to force replacement +of existing typemap entries without warning or C<skip =E<gt> 1> +to skip entries that exist already in the typemap. + +=cut + +sub merge { + my $self = shift; + my %args = @_; + + if (exists $args{typemap} and exists $args{file}) { + die("Need {file} OR {typemap} argument. Not both!"); + } + elsif (not exists $args{typemap} and not exists $args{file}) { + die("Need {file} or {typemap} argument!"); + } + + my @params; + push @params, 'replace' => $args{replace} if exists $args{replace}; + push @params, 'skip' => $args{skip} if exists $args{skip}; + + my $typemap = $args{typemap}; + if (not defined $typemap) { + $typemap = ref($self)->new(file => $args{file}, @params); + } + + # FIXME breaking encapsulation. Add accessor code. + foreach my $entry (@{$typemap->{typemap_section}}) { + $self->add_typemap( $entry, @params ); + } + + foreach my $entry (@{$typemap->{input_section}}) { + $self->add_inputmap( $entry, @params ); + } + + foreach my $entry (@{$typemap->{output_section}}) { + $self->add_outputmap( $entry, @params ); + } + + return 1; +} + +=head2 is_empty + +Returns a bool indicating whether this typemap is entirely empty. + +=cut + +sub is_empty { + my $self = shift; + + return @{ $self->{typemap_section} } == 0 + && @{ $self->{input_section} } == 0 + && @{ $self->{output_section} } == 0; +} + +=head2 list_mapped_ctypes + +Returns a list of the C types that are mappable by +this typemap object. + +=cut + +sub list_mapped_ctypes { + my $self = shift; + return sort keys %{ $self->{typemap_lookup} }; +} + +=head2 _get_typemap_hash + +Returns a hash mapping the C types to the XS types: + + { + 'char **' => 'T_PACKEDARRAY', + 'bool_t' => 'T_IV', + 'AV *' => 'T_AVREF', + 'InputStream' => 'T_IN', + 'double' => 'T_DOUBLE', + # ... + } + +This is documented because it is used by C<ExtUtils::ParseXS>, +but it's not intended for general consumption. May be removed +at any time. + +=cut + +sub _get_typemap_hash { + my $self = shift; + my $lookup = $self->{typemap_lookup}; + my $storage = $self->{typemap_section}; + + my %rv; + foreach my $ctype (keys %$lookup) { + $rv{$ctype} = $storage->[ $lookup->{$ctype} ]->xstype; + } + + return \%rv; +} + +=head2 _get_inputmap_hash + +Returns a hash mapping the XS types (identifiers) to the +corresponding INPUT code: + + { + 'T_CALLBACK' => ' $var = make_perl_cb_$type($arg) + ', + 'T_OUT' => ' $var = IoOFP(sv_2io($arg)) + ', + 'T_REF_IV_PTR' => ' if (sv_isa($arg, \\"${ntype}\\")) { + # ... + } + +This is documented because it is used by C<ExtUtils::ParseXS>, +but it's not intended for general consumption. May be removed +at any time. + +=cut + +sub _get_inputmap_hash { + my $self = shift; + my $lookup = $self->{input_lookup}; + my $storage = $self->{input_section}; + + my %rv; + foreach my $xstype (keys %$lookup) { + $rv{$xstype} = $storage->[ $lookup->{$xstype} ]->code; + + # Squash trailing whitespace to one line break + # This isn't strictly necessary, but makes the output more similar + # to the original ExtUtils::ParseXS. + $rv{$xstype} =~ s/\s*\z/\n/; + } + + return \%rv; +} + + +=head2 _get_outputmap_hash + +Returns a hash mapping the XS types (identifiers) to the +corresponding OUTPUT code: + + { + 'T_CALLBACK' => ' sv_setpvn($arg, $var.context.value().chp(), + $var.context.value().size()); + ', + 'T_OUT' => ' { + GV *gv = newGVgen("$Package"); + if ( do_open(gv, "+>&", 3, FALSE, 0, 0, $var) ) + sv_setsv( + $arg, + sv_bless(newRV((SV*)gv), gv_stashpv("$Package",1)) + ); + else + $arg = &PL_sv_undef; + } + ', + # ... + } + +This is documented because it is used by C<ExtUtils::ParseXS>, +but it's not intended for general consumption. May be removed +at any time. + +=cut + +sub _get_outputmap_hash { + my $self = shift; + my $lookup = $self->{output_lookup}; + my $storage = $self->{output_section}; + + my %rv; + foreach my $xstype (keys %$lookup) { + $rv{$xstype} = $storage->[ $lookup->{$xstype} ]->code; + + # Squash trailing whitespace to one line break + # This isn't strictly necessary, but makes the output more similar + # to the original ExtUtils::ParseXS. + $rv{$xstype} =~ s/\s*\z/\n/; + } + + return \%rv; +} + +=head2 _get_prototype_hash + +Returns a hash mapping the C types of the typemap to their +corresponding prototypes. + + { + 'char **' => '$', + 'bool_t' => '$', + 'AV *' => '$', + 'InputStream' => '$', + 'double' => '$', + # ... + } + +This is documented because it is used by C<ExtUtils::ParseXS>, +but it's not intended for general consumption. May be removed +at any time. + +=cut + +sub _get_prototype_hash { + my $self = shift; + my $lookup = $self->{typemap_lookup}; + my $storage = $self->{typemap_section}; + + my %rv; + foreach my $ctype (keys %$lookup) { + $rv{$ctype} = $storage->[ $lookup->{$ctype} ]->proto || '$'; + } + + return \%rv; +} + + + +# make sure that the provided types wouldn't collide with what's +# in the object already. +sub validate { + my $self = shift; + my %args = @_; + + if ( exists $args{ctype} + and exists $self->{typemap_lookup}{_tidy_type($args{ctype})} ) + { + die("Multiple definition of ctype '$args{ctype}' in TYPEMAP section"); + } + + if ( exists $args{inputmap_xstype} + and exists $self->{input_lookup}{$args{inputmap_xstype}} ) + { + die("Multiple definition of xstype '$args{inputmap_xstype}' in INPUTMAP section"); + } + + if ( exists $args{outputmap_xstype} + and exists $self->{output_lookup}{$args{outputmap_xstype}} ) + { + die("Multiple definition of xstype '$args{outputmap_xstype}' in OUTPUTMAP section"); + } + + return 1; +} + +sub _parse { + my $self = shift; + my $stringref = shift; + my $lineno_offset = shift; + $lineno_offset = 0 if not defined $lineno_offset; + my $filename = shift; + $filename = '<string>' if not defined $filename; + + my $replace = $self->{replace}; + my $skip = $self->{skip}; + die "Can only replace OR skip" if $replace and $skip; + my @add_params; + push @add_params, replace => 1 if $replace; + push @add_params, skip => 1 if $skip; + + # TODO comments should round-trip, currently ignoring + # TODO order of sections, multiple sections of same type + # Heavily influenced by ExtUtils::ParseXS + my $section = 'typemap'; + my $lineno = $lineno_offset; + my $junk = ""; + my $current = \$junk; + my @input_expr; + my @output_expr; + while ($$stringref =~ /^(.*)$/gcm) { + local $_ = $1; + ++$lineno; + chomp; + next if /^\s*#/; + if (/^INPUT\s*$/) { + $section = 'input'; + $current = \$junk; + next; + } + elsif (/^OUTPUT\s*$/) { + $section = 'output'; + $current = \$junk; + next; + } + elsif (/^TYPEMAP\s*$/) { + $section = 'typemap'; + $current = \$junk; + next; + } + + if ($section eq 'typemap') { + my $line = $_; + s/^\s+//; s/\s+$//; + next if $_ eq '' or /^#/; + my($type, $kind, $proto) = /^(.*?\S)\s+(\S+)\s*($ExtUtils::ParseXS::Constants::PrototypeRegexp*)$/o + or warn("Warning: File '$filename' Line $lineno '$line' TYPEMAP entry needs 2 or 3 columns\n"), + next; + # prototype defaults to '$' + $proto = '$' unless $proto; + warn("Warning: File '$filename' Line $lineno '$line' Invalid prototype '$proto'\n") + unless _valid_proto_string($proto); + $self->add_typemap( + ExtUtils::Typemaps::Type->new( + xstype => $kind, proto => $proto, ctype => $type + ), + @add_params + ); + } elsif (/^\s/) { + s/\s+$//; + $$current .= $$current eq '' ? $_ : "\n".$_; + } elsif ($_ eq '') { + next; + } elsif ($section eq 'input') { + s/\s+$//; + push @input_expr, {xstype => $_, code => ''}; + $current = \$input_expr[-1]{code}; + } else { # output section + s/\s+$//; + push @output_expr, {xstype => $_, code => ''}; + $current = \$output_expr[-1]{code}; + } + + } # end while lines + + foreach my $inexpr (@input_expr) { + $self->add_inputmap( ExtUtils::Typemaps::InputMap->new(%$inexpr), @add_params ); + } + foreach my $outexpr (@output_expr) { + $self->add_outputmap( ExtUtils::Typemaps::OutputMap->new(%$outexpr), @add_params ); + } + + return 1; +} + +# taken from ExtUtils::ParseXS +sub _tidy_type { + local $_ = shift; + + # rationalise any '*' by joining them into bunches and removing whitespace + s#\s*(\*+)\s*#$1#g; + s#(\*+)# $1 #g ; + + # trim leading & trailing whitespace + s/^\s+//; s/\s+$//; + + # change multiple whitespace into a single space + s/\s+/ /g; + + $_; +} + + +# taken from ExtUtils::ParseXS +sub _valid_proto_string { + my $string = shift; + if ($string =~ /^$ExtUtils::ParseXS::Constants::PrototypeRegexp+$/o) { + return $string; + } + + return 0 ; +} + +# taken from ExtUtils::ParseXS (C_string) +sub _escape_backslashes { + my $string = shift; + $string =~ s[\\][\\\\]g; + $string; +} + +=head1 CAVEATS + +Inherits some evil code from C<ExtUtils::ParseXS>. + +=head1 SEE ALSO + +The parser is heavily inspired from the one in L<ExtUtils::ParseXS>. + +For details on typemaps: L<perlxstut>, L<perlxs>. + +=head1 AUTHOR + +Steffen Mueller C<<smueller@cpan.org>> + +=head1 COPYRIGHT & LICENSE + +Copyright 2009, 2010, 2011, 2012 Steffen Mueller + +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=cut + +1; + diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/Cmd.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/Cmd.pm new file mode 100644 index 00000000000..671110fb97a --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/Cmd.pm @@ -0,0 +1,168 @@ +package ExtUtils::Typemaps::Cmd; +use 5.006001; +use strict; +use warnings; +our $VERSION = '3.16'; + +use ExtUtils::Typemaps; + +require Exporter; + +our @ISA = qw(Exporter); +our @EXPORT = qw(embeddable_typemap); +our %EXPORT_TAGS = (all => \@EXPORT); + +sub embeddable_typemap { + my @tms = @_; + + # Get typemap objects + my @tm_objs = map [$_, _intuit_typemap_source($_)], @tms; + + # merge or short-circuit + my $final_tm; + if (@tm_objs == 1) { + # just one, merge would be pointless + $final_tm = shift(@tm_objs)->[1]; + } + else { + # multiple, need merge + $final_tm = ExtUtils::Typemaps->new; + foreach my $other_tm (@tm_objs) { + my ($tm_ident, $tm_obj) = @$other_tm; + eval { + $final_tm->merge(typemap => $tm_obj); + 1 + } or do { + my $err = $@ || 'Zombie error'; + die "Failed to merge typ"; + } + } + } + + # stringify for embedding + return $final_tm->as_embedded_typemap(); +} + +sub _load_module { + my $name = shift; + return eval "require $name; 1"; +} + +SCOPE: { + my %sources = ( + module => sub { + my $ident = shift; + my $tm; + if (/::/) { # looks like FQ module name, try that first + foreach my $module ($ident, "ExtUtils::Typemaps::$ident") { + if (_load_module($module)) { + eval { $tm = $module->new } + and return $tm; + } + } + } + else { + foreach my $module ("ExtUtils::Typemaps::$ident", "$ident") { + if (_load_module($module)) { + eval { $tm = $module->new } + and return $tm; + } + } + } + return(); + }, + file => sub { + my $ident = shift; + return unless -e $ident and -r _; + return ExtUtils::Typemaps->new(file => $ident); + }, + ); + # Try to find typemap either from module or file + sub _intuit_typemap_source { + my $identifier = shift; + + my @locate_attempts; + if ($identifier =~ /::/ || $identifier !~ /[^\w_]/) { + @locate_attempts = qw(module file); + } + else { + @locate_attempts = qw(file module); + } + + foreach my $source (@locate_attempts) { + my $tm = $sources{$source}->($identifier); + return $tm if defined $tm; + } + + die "Unable to find typemap for '$identifier': " + . "Tried to load both as file or module and failed.\n"; + } +} # end SCOPE + +=head1 NAME + +ExtUtils::Typemaps::Cmd - Quick commands for handling typemaps + +=head1 SYNOPSIS + +From XS: + + INCLUDE_COMMAND: $^X -MExtUtils::Typemaps::Cmd \ + -e "print embeddable_typemap(q{Excommunicated})" + +Loads C<ExtUtils::Typemaps::Excommunicated>, instantiates an object, +and dumps it as an embeddable typemap for use directly in your XS file. + +=head1 DESCRIPTION + +This is a helper module for L<ExtUtils::Typemaps> for quick +one-liners, specifically for inclusion of shared typemaps +that live on CPAN into an XS file (see SYNOPSIS). + +For this reason, the following functions are exported by default: + +=head1 EXPORTED FUNCTIONS + +=head2 embeddable_typemap + +Given a list of identifiers, C<embeddable_typemap> +tries to load typemaps from a file of the given name(s), +or from a module that is an C<ExtUtils::Typemaps> subclass. + +Returns a string representation of the merged typemaps that can +be included verbatim into XS. Example: + + print embeddable_typemap( + "Excommunicated", "ExtUtils::Typemaps::Basic", "./typemap" + ); + +This will try to load a module C<ExtUtils::Typemaps::Excommunicated> +and use it as an C<ExtUtils::Typemaps> subclass. If that fails, it'll +try loading C<Excommunicated> as a module, if that fails, it'll try to +read a file called F<Excommunicated>. It'll work similarly for the +second argument, but the third will be loaded as a file first. + +After loading all typemap files or modules, it will merge them in the +specified order and dump the result as an embeddable typemap. + +=head1 SEE ALSO + +L<ExtUtils::Typemaps> + +L<perlxs> + +=head1 AUTHOR + +Steffen Mueller C<<smueller@cpan.org>> + +=head1 COPYRIGHT & LICENSE + +Copyright 2012 Steffen Mueller + +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=cut + +1; + diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/InputMap.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/InputMap.pm new file mode 100644 index 00000000000..9e7053f2290 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/InputMap.pm @@ -0,0 +1,116 @@ +package ExtUtils::Typemaps::InputMap; +use 5.006001; +use strict; +use warnings; +our $VERSION = '3.16'; + +=head1 NAME + +ExtUtils::Typemaps::InputMap - Entry in the INPUT section of a typemap + +=head1 SYNOPSIS + + use ExtUtils::Typemaps; + ... + my $input = $typemap->get_input_map('T_NV'); + my $code = $input->code(); + $input->code("..."); + +=head1 DESCRIPTION + +Refer to L<ExtUtils::Typemaps> for details. + +=head1 METHODS + +=cut + +=head2 new + +Requires C<xstype> and C<code> parameters. + +=cut + +sub new { + my $prot = shift; + my $class = ref($prot)||$prot; + my %args = @_; + + if (!ref($prot)) { + if (not defined $args{xstype} or not defined $args{code}) { + die("Need xstype and code parameters"); + } + } + + my $self = bless( + (ref($prot) ? {%$prot} : {}) + => $class + ); + + $self->{xstype} = $args{xstype} if defined $args{xstype}; + $self->{code} = $args{code} if defined $args{code}; + $self->{code} =~ s/^(?=\S)/\t/mg; + + return $self; +} + +=head2 code + +Returns or sets the INPUT mapping code for this entry. + +=cut + +sub code { + $_[0]->{code} = $_[1] if @_ > 1; + return $_[0]->{code}; +} + +=head2 xstype + +Returns the name of the XS type of the INPUT map. + +=cut + +sub xstype { + return $_[0]->{xstype}; +} + +=head2 cleaned_code + +Returns a cleaned-up copy of the code to which certain transformations +have been applied to make it more ANSI compliant. + +=cut + +sub cleaned_code { + my $self = shift; + my $code = $self->code; + + $code =~ s/(?:;+\s*|;*\s+)\z//s; + + # Move C pre-processor instructions to column 1 to be strictly ANSI + # conformant. Some pre-processors are fussy about this. + $code =~ s/^\s+#/#/mg; + $code =~ s/\s*\z/\n/; + + return $code; +} + +=head1 SEE ALSO + +L<ExtUtils::Typemaps> + +=head1 AUTHOR + +Steffen Mueller C<<smueller@cpan.org>> + +=head1 COPYRIGHT & LICENSE + +Copyright 2009, 2010, 2011, 2012 Steffen Mueller + +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=cut + +1; + diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/OutputMap.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/OutputMap.pm new file mode 100644 index 00000000000..95cbbccf5c3 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/OutputMap.pm @@ -0,0 +1,195 @@ +package ExtUtils::Typemaps::OutputMap; +use 5.006001; +use strict; +use warnings; +our $VERSION = '3.16'; + +=head1 NAME + +ExtUtils::Typemaps::OutputMap - Entry in the OUTPUT section of a typemap + +=head1 SYNOPSIS + + use ExtUtils::Typemaps; + ... + my $output = $typemap->get_output_map('T_NV'); + my $code = $output->code(); + $output->code("..."); + +=head1 DESCRIPTION + +Refer to L<ExtUtils::Typemaps> for details. + +=head1 METHODS + +=cut + +=head2 new + +Requires C<xstype> and C<code> parameters. + +=cut + +sub new { + my $prot = shift; + my $class = ref($prot)||$prot; + my %args = @_; + + if (!ref($prot)) { + if (not defined $args{xstype} or not defined $args{code}) { + die("Need xstype and code parameters"); + } + } + + my $self = bless( + (ref($prot) ? {%$prot} : {}) + => $class + ); + + $self->{xstype} = $args{xstype} if defined $args{xstype}; + $self->{code} = $args{code} if defined $args{code}; + $self->{code} =~ s/^(?=\S)/\t/mg; + + return $self; +} + +=head2 code + +Returns or sets the OUTPUT mapping code for this entry. + +=cut + +sub code { + $_[0]->{code} = $_[1] if @_ > 1; + return $_[0]->{code}; +} + +=head2 xstype + +Returns the name of the XS type of the OUTPUT map. + +=cut + +sub xstype { + return $_[0]->{xstype}; +} + +=head2 cleaned_code + +Returns a cleaned-up copy of the code to which certain transformations +have been applied to make it more ANSI compliant. + +=cut + +sub cleaned_code { + my $self = shift; + my $code = $self->code; + + # Move C pre-processor instructions to column 1 to be strictly ANSI + # conformant. Some pre-processors are fussy about this. + $code =~ s/^\s+#/#/mg; + $code =~ s/\s*\z/\n/; + + return $code; +} + +=head2 targetable + +This is an obscure optimization that used to live in C<ExtUtils::ParseXS> +directly. + +In a nutshell, this will check whether the output code +involves calling C<set_iv>, C<set_uv>, C<set_nv>, C<set_pv> or C<set_pvn> +to set the special C<$arg> placeholder to a new value +B<AT THE END OF THE OUTPUT CODE>. If that is the case, the code is +eligible for using the C<TARG>-related macros to optimize this. +Thus the name of the method: C<targetable>. + +If the optimization can not be applied, this returns undef. +If it can be applied, this method returns a hash reference containing +the following information: + + type: Any of the characters i, u, n, p + with_size: Bool indicating whether this is the sv_setpvn variant + what: The code that actually evaluates to the output scalar + what_size: If "with_size", this has the string length (as code, + not constant) + +=cut + +sub targetable { + my $self = shift; + return $self->{targetable} if exists $self->{targetable}; + + our $bal; # ()-balanced + $bal = qr[ + (?: + (?>[^()]+) + | + \( (??{ $bal }) \) + )* + ]x; + + # matches variations on (SV*) + my $sv_cast = qr[ + (?: + \( \s* SV \s* \* \s* \) \s* + )? + ]x; + + my $size = qr[ # Third arg (to setpvn) + , \s* (??{ $bal }) + ]x; + + my $code = $self->code; + + # We can still bootstrap compile 're', because in code re.pm is + # available to miniperl, and does not attempt to load the XS code. + use re 'eval'; + + my ($type, $with_size, $arg, $sarg) = + ($code =~ + m[^ + \s+ + sv_set([iunp])v(n)? # Type, is_setpvn + \s* + \( \s* + $sv_cast \$arg \s* , \s* + ( (??{ $bal }) ) # Set from + ( (??{ $size }) )? # Possible sizeof set-from + \) \s* ; \s* $ + ]x + ); + + my $rv = undef; + if ($type) { + $rv = { + type => $type, + with_size => $with_size, + what => $arg, + what_size => $sarg, + }; + } + $self->{targetable} = $rv; + return $rv; +} + +=head1 SEE ALSO + +L<ExtUtils::Typemaps> + +=head1 AUTHOR + +Steffen Mueller C<<smueller@cpan.org>> + +=head1 COPYRIGHT & LICENSE + +Copyright 2009, 2010, 2011, 2012 Steffen Mueller + +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=cut + +1; + diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/Type.pm b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/Type.pm new file mode 100644 index 00000000000..b29e212d455 --- /dev/null +++ b/Master/tlpkg/tlperl/lib/ExtUtils/Typemaps/Type.pm @@ -0,0 +1,121 @@ +package ExtUtils::Typemaps::Type; +use 5.006001; +use strict; +use warnings; +require ExtUtils::Typemaps; + +our $VERSION = '3.16'; + +=head1 NAME + +ExtUtils::Typemaps::Type - Entry in the TYPEMAP section of a typemap + +=head1 SYNOPSIS + + use ExtUtils::Typemaps; + ... + my $type = $typemap->get_type_map('char*'); + my $input = $typemap->get_input_map($type->xstype); + +=head1 DESCRIPTION + +Refer to L<ExtUtils::Typemaps> for details. +Object associates C<ctype> with C<xstype>, which is the index +into the in- and output mapping tables. + +=head1 METHODS + +=cut + +=head2 new + +Requires C<xstype> and C<ctype> parameters. + +Optionally takes C<prototype> parameter. + +=cut + +sub new { + my $prot = shift; + my $class = ref($prot)||$prot; + my %args = @_; + + if (!ref($prot)) { + if (not defined $args{xstype} or not defined $args{ctype}) { + die("Need xstype and ctype parameters"); + } + } + + my $self = bless( + (ref($prot) ? {%$prot} : {proto => ''}) + => $class + ); + + $self->{xstype} = $args{xstype} if defined $args{xstype}; + $self->{ctype} = $args{ctype} if defined $args{ctype}; + $self->{tidy_ctype} = ExtUtils::Typemaps::_tidy_type($self->{ctype}); + $self->{proto} = $args{'prototype'} if defined $args{'prototype'}; + + return $self; +} + +=head2 proto + +Returns or sets the prototype. + +=cut + +sub proto { + $_[0]->{proto} = $_[1] if @_ > 1; + return $_[0]->{proto}; +} + +=head2 xstype + +Returns the name of the XS type that this C type is associated to. + +=cut + +sub xstype { + return $_[0]->{xstype}; +} + +=head2 ctype + +Returns the name of the C type as it was set on construction. + +=cut + +sub ctype { + return defined($_[0]->{ctype}) ? $_[0]->{ctype} : $_[0]->{tidy_ctype}; +} + +=head2 tidy_ctype + +Returns the canonicalized name of the C type. + +=cut + +sub tidy_ctype { + return $_[0]->{tidy_ctype}; +} + +=head1 SEE ALSO + +L<ExtUtils::Typemaps> + +=head1 AUTHOR + +Steffen Mueller C<<smueller@cpan.org>> + +=head1 COPYRIGHT & LICENSE + +Copyright 2009, 2010, 2011, 2012 Steffen Mueller + +This program is free software; you can redistribute it and/or +modify it under the same terms as Perl itself. + +=cut + +1; + diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/testlib.pm b/Master/tlpkg/tlperl/lib/ExtUtils/testlib.pm index 73144109262..44832ee3531 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/testlib.pm +++ b/Master/tlpkg/tlperl/lib/ExtUtils/testlib.pm @@ -3,7 +3,7 @@ package ExtUtils::testlib; use strict; use warnings; -our $VERSION = 6.57_05; +our $VERSION = '6.63_02'; use Cwd; use File::Spec; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/typemap b/Master/tlpkg/tlperl/lib/ExtUtils/typemap index c88238a48da..607c6c8f586 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/typemap +++ b/Master/tlpkg/tlperl/lib/ExtUtils/typemap @@ -24,10 +24,16 @@ char ** T_PACKEDARRAY void * T_PTR Time_t * T_PV SV * T_SV + +# These are the backwards-compatibility AV*/HV* typemaps that +# do not decrement refcounts. Locally override with +# "AV* T_AVREF_REFCOUNT_FIXED", "HV* T_HVREF_REFCOUNT_FIXED", +# "CV* T_CVREF_REFCOUNT_FIXED", "SVREF T_SVREF_REFCOUNT_FIXED", +# to get the fixed versions. SVREF T_SVREF +CV * T_CVREF AV * T_AVREF HV * T_HVREF -CV * T_CVREF IV T_IV UV T_UV @@ -70,6 +76,19 @@ T_SVREF \"$var\"); } } STMT_END +T_SVREF_REFCOUNT_FIXED + STMT_START { + SV* const xsub_tmp_sv = $arg; + SvGETMAGIC(xsub_tmp_sv); + if (SvROK(xsub_tmp_sv)){ + $var = SvRV(xsub_tmp_sv); + } + else{ + Perl_croak(aTHX_ \"%s: %s is not a reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\"); + } + } STMT_END T_AVREF STMT_START { SV* const xsub_tmp_sv = $arg; @@ -83,6 +102,19 @@ T_AVREF \"$var\"); } } STMT_END +T_AVREF_REFCOUNT_FIXED + STMT_START { + SV* const xsub_tmp_sv = $arg; + SvGETMAGIC(xsub_tmp_sv); + if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){ + $var = (AV*)SvRV(xsub_tmp_sv); + } + else{ + Perl_croak(aTHX_ \"%s: %s is not an ARRAY reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\"); + } + } STMT_END T_HVREF STMT_START { SV* const xsub_tmp_sv = $arg; @@ -96,6 +128,19 @@ T_HVREF \"$var\"); } } STMT_END +T_HVREF_REFCOUNT_FIXED + STMT_START { + SV* const xsub_tmp_sv = $arg; + SvGETMAGIC(xsub_tmp_sv); + if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVHV){ + $var = (HV*)SvRV(xsub_tmp_sv); + } + else{ + Perl_croak(aTHX_ \"%s: %s is not a HASH reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\"); + } + } STMT_END T_CVREF STMT_START { SV* const xsub_tmp_sv = $arg; @@ -109,6 +154,19 @@ T_CVREF \"$var\"); } } STMT_END +T_CVREF_REFCOUNT_FIXED + STMT_START { + SV* const xsub_tmp_sv = $arg; + SvGETMAGIC(xsub_tmp_sv); + if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVCV){ + $var = (CV*)SvRV(xsub_tmp_sv); + } + else{ + Perl_croak(aTHX_ \"%s: %s is not a CODE reference\", + ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]}, + \"$var\"); + } + } STMT_END T_SYSRET $var NOT IMPLEMENTED T_UV @@ -217,8 +275,6 @@ T_PACKED $var = XS_unpack_$ntype($arg) T_PACKEDARRAY $var = XS_unpack_$ntype($arg) -T_CALLBACK - $var = make_perl_cb_$type($arg) T_ARRAY U32 ix_$var = $argoff; $var = $ntype(items -= $argoff); @@ -242,12 +298,20 @@ T_SV $arg = $var; T_SVREF $arg = newRV((SV*)$var); +T_SVREF_REFCOUNT_FIXED + $arg = newRV_noinc((SV*)$var); T_AVREF $arg = newRV((SV*)$var); +T_AVREF_REFCOUNT_FIXED + $arg = newRV_noinc((SV*)$var); T_HVREF $arg = newRV((SV*)$var); +T_HVREF_REFCOUNT_FIXED + $arg = newRV_noinc((SV*)$var); T_CVREF $arg = newRV((SV*)$var); +T_CVREF_REFCOUNT_FIXED + $arg = newRV_noinc((SV*)$var); T_IV sv_setiv($arg, (IV)$var); T_UV @@ -311,11 +375,6 @@ T_PACKED XS_pack_$ntype($arg, $var); T_PACKEDARRAY XS_pack_$ntype($arg, $var, count_$ntype); -T_DATAUNIT - sv_setpvn($arg, $var.chp(), $var.size()); -T_CALLBACK - sv_setpvn($arg, $var.context.value().chp(), - $var.context.value().size()); T_ARRAY { U32 ix_$var; diff --git a/Master/tlpkg/tlperl/lib/ExtUtils/xsubpp b/Master/tlpkg/tlperl/lib/ExtUtils/xsubpp index e4e5b774d82..fa0cd50426a 100644 --- a/Master/tlpkg/tlperl/lib/ExtUtils/xsubpp +++ b/Master/tlpkg/tlperl/lib/ExtUtils/xsubpp @@ -1,7 +1,23 @@ -#!./miniperl +#!perl +use 5.006; +use strict; +eval { + require ExtUtils::ParseXS; + ExtUtils::ParseXS->import( + qw( + process_file + report_error_count + ) + ); + 1; +} +or do { + my $err = $@ || 'Zombie error'; + my $v = $ExtUtils::ParseXS::VERSION; + $v = '<undef>' if not defined $v; + die "Failed to load or import from ExtUtils::ParseXS (version $v). Please check that ExtUtils::ParseXS is installed correctly and that the newest version will be found in your \@INC path: $err"; +}; -require 5.002; -use ExtUtils::ParseXS qw(process_file); use Getopt::Long; my %args = (); @@ -38,7 +54,7 @@ if ($args{v}) { $args{filename} = shift @ARGV; process_file(%args); -exit( ExtUtils::ParseXS::errors() ? 1 : 0 ); +exit( report_error_count() ? 1 : 0 ); __END__ @@ -52,7 +68,8 @@ B<xsubpp> [B<-v>] [B<-except>] [B<-s pattern>] [B<-prototypes>] [B<-noversionche =head1 DESCRIPTION -This compiler is typically run by the makefiles created by L<ExtUtils::MakeMaker>. +This compiler is typically run by the makefiles created by L<ExtUtils::MakeMaker> +or by L<Module::Build> or other Perl module build tools. I<xsubpp> will compile XS code into C code by embedding the constructs necessary to let C functions manipulate Perl values and creates the glue @@ -110,7 +127,7 @@ number. =item B<-nolinenumbers> -Prevents the inclusion of `#line' directives in the output. +Prevents the inclusion of '#line' directives in the output. =item B<-nooptimize> |