���ѧۧݧ�ӧ�� �ާ֧ߧ֧էا֧� - ���֧էѧܧ�ڧ��ӧѧ�� - /home/ukubnwwtacc0unt/chapelbellstudios.com/uploads/cover/Platform.tar
���ѧ٧ѧ�
dec_osf.pm 0000644 00000000654 15204303763 0006514 0 ustar 00 package ExtUtils::CBuilder::Platform::dec_osf; use warnings; use strict; use ExtUtils::CBuilder::Platform::Unix; use File::Spec; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Platform::Unix); sub link_executable { my $self = shift; # $Config{ld} is 'ld' but that won't work: use the cc instead. local $self->{config}{ld} = $self->{config}{cc}; return $self->SUPER::link_executable(@_); } 1; Unix.pm 0000644 00000002026 15204303763 0006030 0 ustar 00 package ExtUtils::CBuilder::Platform::Unix; use warnings; use strict; use ExtUtils::CBuilder::Base; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Base); sub link_executable { my $self = shift; # On some platforms (which ones??) $Config{cc} seems to be a better # bet for linking executables than $Config{ld}. Cygwin is a notable # exception. local $self->{config}{ld} = $self->{config}{cc} . " " . $self->{config}{ldflags}; return $self->SUPER::link_executable(@_); } sub link { my $self = shift; my $cf = $self->{config}; # Some platforms (notably Mac OS X 10.3, but some others too) expect # the syntax "FOO=BAR /bin/command arg arg" to work in %Config # (notably $Config{ld}). It usually works in system(SCALAR), but we # use system(LIST). We fix it up here with 'env'. local $cf->{ld} = $cf->{ld}; if (ref $cf->{ld}) { unshift @{$cf->{ld}}, 'env' if $cf->{ld}[0] =~ /^\s*\w+=/; } else { $cf->{ld} =~ s/^(\s*\w+=)/env $1/; } return $self->SUPER::link(@_); } 1; linux.pm 0000644 00000001112 15204303763 0006237 0 ustar 00 package ExtUtils::CBuilder::Platform::linux; use strict; use ExtUtils::CBuilder::Platform::Unix; use File::Spec; our $VERSION = '0.280230'; our @ISA = qw(ExtUtils::CBuilder::Platform::Unix); sub link { my ($self, %args) = @_; my $cf = $self->{config}; # Link XS modules to libperl.so explicitly because multiple # dlopen(, RTLD_LOCAL) hides libperl symbols from XS module. local $cf->{lddlflags} = $cf->{lddlflags}; if ($ENV{PERL_CORE}) { $cf->{lddlflags} .= ' -L' . $self->perl_inc(); } $cf->{lddlflags} .= ' -lperl'; return $self->SUPER::link(%args); } 1; Windows/MSVC.pm 0000644 00000006260 15204303763 0007313 0 ustar 00 package ExtUtils::CBuilder::Platform::Windows::MSVC; our $VERSION = '0.280230'; # VERSION use warnings; use strict; sub arg_exec_file { my ($self, $file) = @_; return "/OUT:$file"; } sub format_compiler_cmd { my ($self, %spec) = @_; foreach my $path ( @{ $spec{includes} || [] }, @{ $spec{perlinc} || [] } ) { $path = '-I' . $path; } %spec = $self->write_compiler_script(%spec) if $spec{use_scripts}; return [ grep {defined && length} ( $spec{cc},'-nologo','-c', @{$spec{includes}} , @{$spec{cflags}} , @{$spec{optimize}} , @{$spec{defines}} , @{$spec{perlinc}} , "-Fo$spec{output}" , $spec{source} , ) ]; } sub write_compiler_script { my ($self, %spec) = @_; my $script = File::Spec->catfile( $spec{srcdir}, $spec{basename} . '.ccs' ); $self->add_to_cleanup($script); print "Generating script '$script'\n" if !$self->{quiet}; my $SCRIPT = IO::File->new( ">$script" ) or die( "Could not create script '$script': $!" ); print $SCRIPT join( "\n", map { ref $_ ? @{$_} : $_ } grep defined, delete( @spec{ qw(includes cflags optimize defines perlinc) } ) ); push @{$spec{includes}}, '@"' . $script . '"'; return %spec; } sub format_linker_cmd { my ($self, %spec) = @_; my $cf = $self->{config}; foreach my $path ( @{$spec{libpath}} ) { $path = "-libpath:$path"; } my $output = $spec{output}; my $manifest = $spec{manifest}; $spec{def_file} &&= '-def:' . $spec{def_file}; $spec{output} &&= '-out:' . $spec{output}; $spec{manifest} &&= '-manifest ' . $spec{manifest}; $spec{implib} &&= '-implib:' . $spec{implib}; $spec{map_file} &&= '-map:' . $spec{map_file}; %spec = $self->write_linker_script(%spec) if $spec{use_scripts}; my @cmds; # Stores the series of commands needed to build the module. push @cmds, [ grep {defined && length} ( $spec{ld} , @{$spec{lddlflags}} , @{$spec{libpath}} , @{$spec{other_ldflags}} , @{$spec{startup}} , @{$spec{objects}} , $spec{map_file} , $spec{libperl} , @{$spec{perllibs}} , $spec{def_file} , $spec{implib} , $spec{output} , ) ]; # Embed the manifest file if it exists push @cmds, [ 'if', 'exist', $manifest, 'mt', '-nologo', $spec{manifest}, '-outputresource:' . "$output;2" ]; return @cmds; } sub write_linker_script { my ($self, %spec) = @_; my $script = File::Spec->catfile( $spec{srcdir}, $spec{basename} . '.lds' ); $self->add_to_cleanup($script); print "Generating script '$script'\n" if !$self->{quiet}; my $SCRIPT = IO::File->new( ">$script" ) or die( "Could not create script '$script': $!" ); print $SCRIPT join( "\n", map { ref $_ ? @{$_} : $_ } grep defined, delete( @spec{ qw(lddlflags libpath other_ldflags startup objects libperl perllibs def_file implib map_file) } ) ); push @{$spec{lddlflags}}, '@"' . $script . '"'; return %spec; } 1; Windows/BCC.pm 0000644 00000006657 15204303763 0007144 0 ustar 00 package ExtUtils::CBuilder::Platform::Windows::BCC; our $VERSION = '0.280230'; # VERSION use strict; use warnings; sub format_compiler_cmd { my ($self, %spec) = @_; foreach my $path ( @{ $spec{includes} || [] }, @{ $spec{perlinc} || [] } ) { $path = '-I' . $path; } %spec = $self->write_compiler_script(%spec) if $spec{use_scripts}; return [ grep {defined && length} ( $spec{cc}, '-c' , @{$spec{includes}} , @{$spec{cflags}} , @{$spec{optimize}} , @{$spec{defines}} , @{$spec{perlinc}} , "-o$spec{output}" , $spec{source} , ) ]; } sub write_compiler_script { my ($self, %spec) = @_; my $script = File::Spec->catfile( $spec{srcdir}, $spec{basename} . '.ccs' ); $self->add_to_cleanup($script); print "Generating script '$script'\n" if !$self->{quiet}; my $SCRIPT = IO::File->new( ">$script" ) or die( "Could not create script '$script': $!" ); # XXX Borland "response files" seem to be unable to accept macro # definitions containing quoted strings. Escaping strings with # backslash doesn't work, and any level of quotes are stripped. The # result is a floating point number in the source file where a # string is expected. So we leave the macros on the command line. print $SCRIPT join( "\n", map { ref $_ ? @{$_} : $_ } grep defined, delete( @spec{ qw(includes cflags optimize perlinc) } ) ); push @{$spec{includes}}, '@"' . $script . '"'; return %spec; } sub format_linker_cmd { my ($self, %spec) = @_; foreach my $path ( @{$spec{libpath}} ) { $path = "-L$path"; } push( @{$spec{startup}}, 'c0d32.obj' ) unless ( $spec{startup} && @{$spec{startup}} ); %spec = $self->write_linker_script(%spec) if $spec{use_scripts}; return [ grep {defined && length} ( $spec{ld} , @{$spec{lddlflags}} , @{$spec{libpath}} , @{$spec{other_ldflags}} , @{$spec{startup}} , @{$spec{objects}} , ',', $spec{output} , ',', $spec{map_file} , ',', $spec{libperl} , @{$spec{perllibs}} , ',', $spec{def_file} ) ]; } sub write_linker_script { my ($self, %spec) = @_; # To work around Borlands "unique" commandline syntax, # two scripts are used: my $ld_script = File::Spec->catfile( $spec{srcdir}, $spec{basename} . '.lds' ); my $ld_libs = File::Spec->catfile( $spec{srcdir}, $spec{basename} . '.lbs' ); $self->add_to_cleanup($ld_script, $ld_libs); print "Generating scripts '$ld_script' and '$ld_libs'.\n" if !$self->{quiet}; # Script 1: contains options & names of object files. my $LD_SCRIPT = IO::File->new( ">$ld_script" ) or die( "Could not create linker script '$ld_script': $!" ); print $LD_SCRIPT join( " +\n", map { @{$_} } grep defined, delete( @spec{ qw(lddlflags libpath other_ldflags startup objects) } ) ); # Script 2: contains name of libs to link against. my $LD_LIBS = IO::File->new( ">$ld_libs" ) or die( "Could not create linker script '$ld_libs': $!" ); print $LD_LIBS join( " +\n", (delete $spec{libperl} || ''), @{delete $spec{perllibs} || []}, ); push @{$spec{lddlflags}}, '@"' . $ld_script . '"'; push @{$spec{perllibs}}, '@"' . $ld_libs . '"'; return %spec; } 1; Windows/GCC.pm 0000644 00000010244 15204303764 0007135 0 ustar 00 package ExtUtils::CBuilder::Platform::Windows::GCC; our $VERSION = '0.280230'; # VERSION use warnings; use strict; sub format_compiler_cmd { my ($self, %spec) = @_; foreach my $path ( @{ $spec{includes} || [] }, @{ $spec{perlinc} || [] } ) { $path = '-I' . $path; } # split off any -arguments included in cc my @cc = split / (?=-)/, $spec{cc}; return [ grep {defined && length} ( @cc, '-c' , @{$spec{includes}} , @{$spec{cflags}} , @{$spec{optimize}} , @{$spec{defines}} , @{$spec{perlinc}} , '-o', $spec{output} , $spec{source} , ) ]; } sub format_linker_cmd { my ($self, %spec) = @_; my $cf = $self->{config}; # The Config.pm variable 'libperl' is hardcoded to the full name # of the perl import library (i.e. 'libperl56.a'). GCC will not # find it unless the 'lib' prefix & the extension are stripped. $spec{libperl} =~ s/^(?:lib)?([^.]+).*$/-l$1/; unshift( @{$spec{other_ldflags}}, '-nostartfiles' ) if ( $spec{startup} && @{$spec{startup}} ); # From ExtUtils::MM_Win32: # ## one thing for GCC/Mingw32: ## we try to overcome non-relocateable-DLL problems by generating ## a (hopefully unique) image-base from the dll's name ## -- BKS, 10-19-1999 File::Basename::basename( $spec{output} ) =~ /(....)(.{0,4})/; $spec{image_base} = sprintf( "0x%x0000", unpack('n', $1 ^ $2) ); %spec = $self->write_linker_script(%spec) if $spec{use_scripts}; foreach my $path ( @{$spec{libpath}} ) { $path = "-L$path"; } my @cmds; # Stores the series of commands needed to build the module. my $DLLTOOL = $cf->{dlltool} || 'dlltool'; push @cmds, [ $DLLTOOL, '--def' , $spec{def_file}, '--output-exp' , $spec{explib} ]; # split off any -arguments included in ld my @ld = split / (?=-)/, $spec{ld}; push @cmds, [ grep {defined && length} ( @ld , '-o', $spec{output} , "-Wl,--base-file,$spec{base_file}" , "-Wl,--image-base,$spec{image_base}" , @{$spec{lddlflags}} , @{$spec{libpath}} , @{$spec{startup}} , @{$spec{objects}} , @{$spec{other_ldflags}} , $spec{libperl} , @{$spec{perllibs}} , $spec{explib} , $spec{map_file} ? ('-Map', $spec{map_file}) : '' ) ]; push @cmds, [ $DLLTOOL, '--def' , $spec{def_file}, '--output-exp' , $spec{explib}, '--base-file' , $spec{base_file} ]; push @cmds, [ grep {defined && length} ( @ld , '-o', $spec{output} , "-Wl,--image-base,$spec{image_base}" , @{$spec{lddlflags}} , @{$spec{libpath}} , @{$spec{startup}} , @{$spec{objects}} , @{$spec{other_ldflags}} , $spec{libperl} , @{$spec{perllibs}} , $spec{explib} , $spec{map_file} ? ('-Map', $spec{map_file}) : '' ) ]; return @cmds; } sub write_linker_script { my ($self, %spec) = @_; my $script = File::Spec->catfile( $spec{srcdir}, $spec{basename} . '.lds' ); $self->add_to_cleanup($script); print "Generating script '$script'\n" if !$self->{quiet}; my $SCRIPT = IO::File->new( ">$script" ) or die( "Could not create script '$script': $!" ); print $SCRIPT ( 'SEARCH_DIR(' . $_ . ")\n" ) for @{delete $spec{libpath} || []}; # gcc takes only one startup file, so the first object in startup is # specified as the startup file and any others are shifted into the # beginning of the list of objects. if ( $spec{startup} && @{$spec{startup}} ) { print $SCRIPT 'STARTUP(' . shift( @{$spec{startup}} ) . ")\n"; unshift @{$spec{objects}}, @{delete $spec{startup} || []}; } print $SCRIPT 'INPUT(' . join( ',', @{delete $spec{objects} || []} ) . ")\n"; print $SCRIPT 'INPUT(' . join( ' ', (delete $spec{libperl} || ''), @{delete $spec{perllibs} || []}, ) . ")\n"; #it is important to keep the order 1.linker_script - 2.other_ldflags unshift @{$spec{other_ldflags}}, '"' . $script . '"'; return %spec; } 1; cygwin.pm 0000644 00000001644 15204303764 0006413 0 ustar 00 package ExtUtils::CBuilder::Platform::cygwin; use warnings; use strict; use File::Spec; use ExtUtils::CBuilder::Platform::Unix; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Platform::Unix); # TODO: If a specific exe_file name is requested, if the exe created # doesn't have that name, we might want to rename it. Apparently asking # for an exe of "foo" might result in "foo.exe". Alternatively, we should # make sure the return value is correctly "foo.exe". # C.f http://rt.cpan.org/Public/Bug/Display.html?id=41003 sub link_executable { my $self = shift; return $self->SUPER::link_executable(@_); } sub link { my ($self, %args) = @_; my $lib = $self->{config}{useshrplib} ? 'libperl.dll.a' : 'libperl.a'; $args{extra_linker_flags} = [ File::Spec->catfile($self->perl_inc(), $lib), $self->split_like_shell($args{extra_linker_flags}) ]; return $self->SUPER::link(%args); } 1; Windows.pm 0000644 00000021401 15204303764 0006536 0 ustar 00 package ExtUtils::CBuilder::Platform::Windows; use strict; use warnings; use File::Basename; use File::Spec; use ExtUtils::CBuilder::Base; use IO::File; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Base); =begin comment The compiler-specific packages implement functions for generating properly formatted commandlines for the compiler being used. Each package defines two primary functions 'format_linker_cmd()' & 'format_compiler_cmd()' that accepts a list of named arguments (a hash) and returns a list of formatted options suitable for invoking the compiler. By default, if the compiler supports scripting of its operation then a script file is built containing the options while those options are removed from the commandline, and a reference to the script is pushed onto the commandline in their place. Scripting the compiler in this way helps to avoid the problems associated with long commandlines under some shells. =end comment =cut sub new { my $class = shift; my $self = $class->SUPER::new(@_); my $cf = $self->{config}; # Inherit from an appropriate compiler driver class my $driver = "ExtUtils::CBuilder::Platform::Windows::" . $self->_compiler_type; eval "require $driver" or die "Could not load compiler driver: $@"; unshift @ISA, $driver; return $self; } sub _compiler_type { my $self = shift; my $cc = $self->{config}{cc}; return ( $cc =~ /cl(\.exe)?$/ ? 'MSVC' : $cc =~ /bcc32(\.exe)?$/ ? 'BCC' : 'GCC'); } sub split_like_shell { # Since Windows will pass the whole command string (not an argument # array) to the target program and make the program parse it itself, # we don't actually need to do any processing here. (my $self, local $_) = @_; return @$_ if defined() && UNIVERSAL::isa($_, 'ARRAY'); return unless defined() && length(); return ($_); } sub do_system { # See above my $self = shift; my $cmd = join(" ", grep length, map {$a=$_;$a=~s/\t/ /g;$a=~s/^\s+|\s+$//;$a} grep defined, @_); return $self->SUPER::do_system($cmd); } sub arg_defines { my ($self, %args) = @_; s/"/\\"/g foreach values %args; return map qq{"-D$_=$args{$_}"}, sort keys %args; } sub compile { my ($self, %args) = @_; my $cf = $self->{config}; die "Missing 'source' argument to compile()" unless defined $args{source}; $args{include_dirs} = [ $args{include_dirs} ] if exists($args{include_dirs}) && ref($args{include_dirs}) ne "ARRAY"; my ($basename, $srcdir) = ( File::Basename::fileparse($args{source}, '\.[^.]+$') )[0,1]; $srcdir ||= File::Spec->curdir(); my @defines = $self->arg_defines( %{ $args{defines} || {} } ); my %spec = ( srcdir => $srcdir, builddir => $srcdir, basename => $basename, source => $args{source}, output => $args{object_file} || File::Spec->catfile($srcdir, $basename) . $cf->{obj_ext}, cc => $cf->{cc}, cflags => [ $self->split_like_shell($cf->{ccflags}), $self->split_like_shell($cf->{cccdlflags}), $self->split_like_shell($args{extra_compiler_flags}), ], optimize => [ $self->split_like_shell($cf->{optimize}) ], defines => \@defines, includes => [ @{$args{include_dirs} || []} ], perlinc => [ $self->perl_inc(), $self->split_like_shell($cf->{incpath}), ], use_scripts => 1, # XXX provide user option to change this??? ); $self->normalize_filespecs( \$spec{source}, \$spec{output}, $spec{includes}, $spec{perlinc}, ); my @cmds = $self->format_compiler_cmd(%spec); while ( my $cmd = shift @cmds ) { $self->do_system( @$cmd ) or die "error building $cf->{dlext} file from '$args{source}'"; } (my $out = $spec{output}) =~ tr/'"//d; return $out; } sub need_prelink { 1 } sub link { my ($self, %args) = @_; my $cf = $self->{config}; my @objects = ( ref $args{objects} eq 'ARRAY' ? @{$args{objects}} : $args{objects} ); my $to = join '', (File::Spec->splitpath($objects[0]))[0,1]; $to ||= File::Spec->curdir(); (my $file_base = $args{module_name}) =~ s/.*:://; my $output = $args{lib_file} || File::Spec->catfile($to, "$file_base.$cf->{dlext}"); # if running in perl source tree, look for libs there, not installed my $lddlflags = $cf->{lddlflags}; my $perl_src = $self->perl_src(); $lddlflags =~ s{\Q$cf->{archlibexp}\E[\\/]CORE}{$perl_src/lib/CORE} if $perl_src; my %spec = ( srcdir => $to, builddir => $to, startup => [ ], objects => \@objects, libs => [ ], output => $output, ld => $cf->{ld}, libperl => $cf->{libperl}, perllibs => [ $self->split_like_shell($cf->{perllibs}) ], libpath => [ $self->split_like_shell($cf->{libpth}) ], lddlflags => [ $self->split_like_shell($lddlflags) ], other_ldflags => [ $self->split_like_shell($args{extra_linker_flags} || '') ], use_scripts => 1, # XXX provide user option to change this??? ); unless ( $spec{basename} ) { ($spec{basename} = $args{module_name}) =~ s/.*:://; } $spec{srcdir} = File::Spec->canonpath( $spec{srcdir} ); $spec{builddir} = File::Spec->canonpath( $spec{builddir} ); $spec{output} ||= File::Spec->catfile( $spec{builddir}, $spec{basename} . '.'.$cf->{dlext} ); $spec{manifest} ||= $spec{output} . '.manifest'; $spec{implib} ||= File::Spec->catfile( $spec{builddir}, $spec{basename} . $cf->{lib_ext} ); $spec{explib} ||= File::Spec->catfile( $spec{builddir}, $spec{basename} . '.exp' ); if ($cf->{cc} eq 'cl') { $spec{dbg_file} ||= File::Spec->catfile( $spec{builddir}, $spec{basename} . '.pdb' ); } elsif ($cf->{cc} eq 'bcc32') { $spec{dbg_file} ||= File::Spec->catfile( $spec{builddir}, $spec{basename} . '.tds' ); } $spec{def_file} ||= File::Spec->catfile( $spec{srcdir} , $spec{basename} . '.def' ); $spec{base_file} ||= File::Spec->catfile( $spec{srcdir} , $spec{basename} . '.base' ); $self->add_to_cleanup( grep defined, @{[ @spec{qw(manifest implib explib dbg_file def_file base_file map_file)} ]} ); foreach my $opt ( qw(output manifest implib explib dbg_file def_file map_file base_file) ) { $self->normalize_filespecs( \$spec{$opt} ); } foreach my $opt ( qw(libpath startup objects) ) { $self->normalize_filespecs( $spec{$opt} ); } (my $def_base = $spec{def_file}) =~ tr/'"//d; $def_base =~ s/\.def$//; $self->prelink( %args, dl_name => $args{module_name}, dl_file => $def_base, dl_base => $spec{basename} ); my @cmds = $self->format_linker_cmd(%spec); while ( my $cmd = shift @cmds ) { $self->do_system( @$cmd ); } $spec{output} =~ tr/'"//d; return wantarray ? grep defined, @spec{qw[output manifest implib explib dbg_file def_file map_file base_file]} : $spec{output}; } # canonize & quote paths sub normalize_filespecs { my ($self, @specs) = @_; foreach my $spec ( grep defined, @specs ) { if ( ref $spec eq 'ARRAY') { $self->normalize_filespecs( map {\$_} grep defined, @$spec ) } elsif ( ref $spec eq 'SCALAR' ) { $$spec =~ tr/"//d if $$spec; next unless $$spec; $$spec = '"' . File::Spec->canonpath($$spec) . '"'; } elsif ( ref $spec eq '' ) { $spec = '"' . File::Spec->canonpath($spec) . '"'; } else { die "Don't know how to normalize " . (ref $spec || $spec) . "\n"; } } } # directory of perl's include files sub perl_inc { my $self = shift; my $perl_src = $self->perl_src(); if ($perl_src) { File::Spec->catdir($perl_src, "lib", "CORE"); } else { File::Spec->catdir($self->{config}{archlibexp},"CORE"); } } 1; __END__ =head1 NAME ExtUtils::CBuilder::Platform::Windows - Builder class for Windows platforms =head1 DESCRIPTION This module implements the Windows-specific parts of ExtUtils::CBuilder. Most of the Windows-specific stuff has to do with compiling and linking C code. Currently we support the 3 compilers perl itself supports: MSVC, BCC, and GCC. This module inherits from C<ExtUtils::CBuilder::Base>, so any functionality not implemented here will be implemented there. The interfaces are defined by the L<ExtUtils::CBuilder> documentation. =head1 AUTHOR Ken Williams <ken@mathforum.org> Most of the code here was written by Randy W. Sims <RandyS@ThePierianSpring.org>. =head1 SEE ALSO perl(1), ExtUtils::CBuilder(3), ExtUtils::MakeMaker(3) =cut VMS.pm 0000644 00000024060 15204303764 0005555 0 ustar 00 package ExtUtils::CBuilder::Platform::VMS; use warnings; use strict; use ExtUtils::CBuilder::Base; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Base); use File::Spec::Functions qw(catfile catdir); use Config; # We do prelink, but don't want the parent to redo it. sub need_prelink { 0 } sub arg_defines { my ($self, %args) = @_; s/"/""/g foreach values %args; my @config_defines; # VMS can only have one define qualifier; add the one from config, if any. if ($self->{config}{ccflags} =~ s{/ def[^=]+ =+ \(? ([^\/\)]*) } {}ix) { push @config_defines, $1; } return '' unless keys(%args) || @config_defines; return ('/define=(' . join(',', @config_defines, map "\"$_" . ( length($args{$_}) ? "=$args{$_}" : '') . "\"", sort keys %args) . ')'); } sub arg_include_dirs { my ($self, @dirs) = @_; # VMS can only have one include list, add the one from config. if ($self->{config}{ccflags} =~ s{/inc[^=]+(?:=)+(?:\()?([^\/\)]*)} {}i) { unshift @dirs, $1; } return unless @dirs; return ('/include=(' . join(',', @dirs) . ')'); } # We override the compile method because we consume the includes and defines # parts of ccflags in the process of compiling but don't save those parts # anywhere, so $self->{config}{ccflags} needs to be reset for each compile # operation. sub compile { my ($self, %args) = @_; $self->{config}{ccflags} = $Config{ccflags}; $self->{config}{ccflags} = $ENV{CFLAGS} if defined $ENV{CFLAGS}; return $self->SUPER::compile(%args); } sub _do_link { my ($self, $type, %args) = @_; my $objects = delete $args{objects}; $objects = [$objects] unless ref $objects; if ($args{lddl}) { # prelink will call Mksymlists, which creates the extension-specific # linker options file and populates it with the boot symbol. my @temp_files = $self->prelink(%args, dl_name => $args{module_name}); # We now add the rest of what we need to the linker options file. We # should replicate the functionality of C<ExtUtils::MM_VMS::dlsyms>, # but there is as yet no infrastructure for handling object libraries, # so for now we depend on object files being listed individually on the # command line, which should work for simple cases. We do bring in our # own version of C<ExtUtils::Liblist::Kid::ext> so that any additional # libraries (including PERLSHR) can be added to the options file. my @optlibs = $self->_liblist_ext( $args{'libs'} ); my $optfile = 'sys$disk:[]' . $temp_files[0]; open my $opt_fh, '>>', $optfile or die "_do_link: Unable to open $optfile: $!"; for my $lib (@optlibs) {print $opt_fh "$lib\n" if length $lib } close $opt_fh; $objects->[-1] .= ','; push @$objects, $optfile . '/OPTIONS,'; # This one not needed for DEC C, but leave for completeness. push @$objects, $self->perl_inc() . 'perlshr_attr.opt/OPTIONS'; } return $self->SUPER::_do_link($type, %args, objects => $objects); } sub arg_nolink { return; } sub arg_object_file { my ($self, $file) = @_; return "/obj=$file"; } sub arg_exec_file { my ($self, $file) = @_; return ("/exe=$file"); } sub arg_share_object_file { my ($self, $file) = @_; return ("$self->{config}{lddlflags}=$file"); } # The following is reproduced almost verbatim from ExtUtils::Liblist::Kid::_vms_ext. # We can't just call that because it's tied up with the MakeMaker object hierarchy. sub _liblist_ext { my($self, $potential_libs,$verbose,$give_libs) = @_; $verbose ||= 0; my(@crtls,$crtlstr); @crtls = ( ($self->{'config'}{'ldflags'} =~ m-/Debug-i ? $self->{'config'}{'dbgprefix'} : '') . 'PerlShr/Share' ); push(@crtls, grep { not /\(/ } split /\s+/, $self->{'config'}{'perllibs'}); push(@crtls, grep { not /\(/ } split /\s+/, $self->{'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 ensure 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($lib,$locspec,$type); foreach $lib (@crtls) { if (($locspec,$type) = $lib =~ m{^([\w\$-]+)(/\w+)?} and $locspec =~ /perl/i) { if (lc $type eq '/share') { $locspec .= $self->{'config'}{'exe_ext'}; } elsif (lc $type eq '/library') { $locspec .= $self->{'config'}{'lib_ext'}; } else { $locspec .= $self->{'config'}{'obj_ext'}; } $locspec = 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(@dirs,@libs,$dir,$lib,%found,@fndlibs,$ldlib); my $cwd = cwd(); my($so,$lib_ext,$obj_ext) = @{$self->{'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'); warn "Potential libraries are '$potential_libs'\n" if $verbose; # First, sort out directories and library names in the input foreach $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(' ',$self->{'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 $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 = catdir($cwd,$dir); } } @dirs = grep { length($_) } @dirs; unshift(@dirs,''); # Check each $lib without additions first LIB: foreach $lib (@libs) { if (exists $libmap{$lib}) { next unless length $libmap{$lib}; $lib = $libmap{$lib}; } my(@variants,$variant,$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 $variant (@variants) { my($fullname, $name); foreach $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) { 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"; } 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}; $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; darwin.pm 0000644 00000001010 15204303764 0006362 0 ustar 00 package ExtUtils::CBuilder::Platform::darwin; use warnings; use strict; use ExtUtils::CBuilder::Platform::Unix; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Platform::Unix); sub compile { my $self = shift; my $cf = $self->{config}; # -flat_namespace isn't a compile flag, it's a linker flag. But # it's mistakenly in Config.pm as both. Make the correction here. local $cf->{ccflags} = $cf->{ccflags}; $cf->{ccflags} =~ s/-flat_namespace//; $self->SUPER::compile(@_); } 1; aix.pm 0000644 00000001161 15204303764 0005666 0 ustar 00 package ExtUtils::CBuilder::Platform::aix; use warnings; use strict; use ExtUtils::CBuilder::Platform::Unix; use File::Spec; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Platform::Unix); sub need_prelink { 1 } sub link { my ($self, %args) = @_; my $cf = $self->{config}; (my $baseext = $args{module_name}) =~ s/.*:://; my $perl_inc = $self->perl_inc(); # Massage some very naughty bits in %Config local $cf->{lddlflags} = $cf->{lddlflags}; for ($cf->{lddlflags}) { s/\Q$(BASEEXT)\E/$baseext/; s/\Q$(PERL_INC)\E/$perl_inc/; } return $self->SUPER::link(%args); } 1; os2.pm 0000644 00000004553 15204303764 0005620 0 ustar 00 package ExtUtils::CBuilder::Platform::os2; use warnings; use strict; use ExtUtils::CBuilder::Platform::Unix; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Platform::Unix); sub need_prelink { 1 } sub prelink { # Generate import libraries (XXXX currently near .DEF; should be near DLL!) my $self = shift; my %args = @_; my @res = $self->SUPER::prelink(%args); die "Unexpected number of DEF files" unless @res == 1; die "Can't find DEF file in the output" unless $res[0] =~ m,^(.*)\.def$,si; my $libname = "$1$self->{config}{lib_ext}"; # Put .LIB file near .DEF file $self->do_system('emximp', '-o', $libname, $res[0]) or die "emxexp: res=$?"; return (@res, $libname); } sub _do_link { my $self = shift; my ($how, %args) = @_; if ($how eq 'lib_file' and (defined $args{module_name} and length $args{module_name})) { # Now know the basename, find directory parts via lib_file, or objects my $objs = ( (ref $args{objects}) ? $args{objects} : [$args{objects}] ); my $near_obj = $self->lib_file(@$objs); my $exp_dir = ($near_obj =~ m,(.*)[/\\],s ? "$1/" : '' ); $args{dl_file} = $1 if $near_obj =~ m,(.*)\.,s; # put ExportList near OBJ # XXX _do_link does not have place to put libraries? push @$objs, $self->perl_inc() . "/libperl$self->{config}{lib_ext}"; $args{objects} = $objs; } # Some 'env' do exec(), thus return too early when run from ksh; # To avoid 'env', remove (useless) shrpenv local $self->{config}{shrpenv} = ''; return $self->SUPER::_do_link($how, %args); } sub extra_link_args_after_prelink { # Add .DEF file to the link line my ($self, %args) = @_; my @DEF = grep /\.def$/i, @{$args{prelink_res}}; 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" unless @DEF or not @{$args{prelink_res}}; my @after_libs = ($OS2::is_aout ? () : $self->perl_inc() . "/libperl_override$self->{config}{lib_ext}"); # , "-L", "-lperl" (@after_libs, @DEF); } sub link_executable { # ldflags is not expecting .exe extension given on command line; remove -Zexe my $self = shift; local $self->{config}{ldflags} = $self->{config}{ldflags}; $self->{config}{ldflags} =~ s/(?<!\S)-Zexe(?!\S)//; return $self->SUPER::link_executable(@_); } 1; android.pm 0000644 00000002300 15204303764 0006521 0 ustar 00 package ExtUtils::CBuilder::Platform::android; use warnings; use strict; use File::Spec; use ExtUtils::CBuilder::Platform::Unix; use Config; our $VERSION = '0.280230'; # VERSION our @ISA = qw(ExtUtils::CBuilder::Platform::Unix); # The Android linker will not recognize symbols from # libperl unless the module explicitly depends on it. sub link { my ($self, %args) = @_; if ($self->{config}{useshrplib} eq 'true') { $args{extra_linker_flags} = [ $self->split_like_shell($args{extra_linker_flags}), '-L' . $self->perl_inc(), '-lperl', $self->split_like_shell($Config{perllibs}), ]; } # Several modules on CPAN rather rightfully expect being # able to pass $so_file to DynaLoader::dl_load_file and # have it Just Work. However, $so_file will more likely # than not be a relative path, and unless the module # author subclasses MakeMaker/Module::Build to modify # LD_LIBRARY_PATH, which would be insane, Android's linker # won't find the .so # So we make this all work by returning an absolute path. my($so_file, @so_tmps) = $self->SUPER::link(%args); $so_file = File::Spec->rel2abs($so_file); return wantarray ? ($so_file, @so_tmps) : $so_file; } 1;
| ver. 1.4 |
Github
|
.
| PHP 8.1.34 | ���֧ߧ֧�ѧ�ڧ� ����ѧߧڧ��: 0 |
proxy
|
phpinfo
|
���ѧ����ۧܧ�