| [ Index ] |
PHP Cross Reference of Unnamed Project |
[Summary view] [Print] [Text view]
1 package ExtUtils::MM_Unix; 2 3 require 5.005_03; # Maybe further back, dunno 4 5 use strict; 6 7 use Carp; 8 use ExtUtils::MakeMaker::Config; 9 use File::Basename qw(basename dirname); 10 use DirHandle; 11 12 use vars qw($VERSION @ISA 13 $Is_OS2 $Is_VMS $Is_Win32 $Is_Dos 14 $Is_OSF $Is_IRIX $Is_NetBSD $Is_BSD 15 $Is_SunOS4 $Is_Solaris $Is_SunOS $Is_Interix 16 %Config_Override 17 ); 18 19 use ExtUtils::MakeMaker qw($Verbose neatvalue); 20 21 $VERSION = '6.42'; 22 23 require ExtUtils::MM_Any; 24 @ISA = qw(ExtUtils::MM_Any); 25 26 BEGIN { 27 $Is_OS2 = $^O eq 'os2'; 28 $Is_Win32 = $^O eq 'MSWin32' || $Config{osname} eq 'NetWare'; 29 $Is_Dos = $^O eq 'dos'; 30 $Is_VMS = $^O eq 'VMS'; 31 $Is_OSF = $^O eq 'dec_osf'; 32 $Is_IRIX = $^O eq 'irix'; 33 $Is_NetBSD = $^O eq 'netbsd'; 34 $Is_Interix = $^O eq 'interix'; 35 $Is_SunOS4 = $^O eq 'sunos'; 36 $Is_Solaris = $^O eq 'solaris'; 37 $Is_SunOS = $Is_SunOS4 || $Is_Solaris; 38 $Is_BSD = ($^O =~ /^(?:free|net|open)bsd$/ or 39 grep( $^O eq $_, qw(bsdos interix dragonfly) ) 40 ); 41 } 42 43 BEGIN { 44 if( $Is_VMS ) { 45 # For things like vmsify() 46 require VMS::Filespec; 47 VMS::Filespec->import; 48 } 49 } 50 51 52 =head1 NAME 53 54 ExtUtils::MM_Unix - methods used by ExtUtils::MakeMaker 55 56 =head1 SYNOPSIS 57 58 C<require ExtUtils::MM_Unix;> 59 60 =head1 DESCRIPTION 61 62 The methods provided by this package are designed to be used in 63 conjunction with ExtUtils::MakeMaker. When MakeMaker writes a 64 Makefile, it creates one or more objects that inherit their methods 65 from a package C<MM>. MM itself doesn't provide any methods, but it 66 ISA ExtUtils::MM_Unix class. The inheritance tree of MM lets operating 67 specific packages take the responsibility for all the methods provided 68 by MM_Unix. We are trying to reduce the number of the necessary 69 overrides by defining rather primitive operations within 70 ExtUtils::MM_Unix. 71 72 If you are going to write a platform specific MM package, please try 73 to limit the necessary overrides to primitive methods, and if it is not 74 possible to do so, let's work out how to achieve that gain. 75 76 If you are overriding any of these methods in your Makefile.PL (in the 77 MY class), please report that to the makemaker mailing list. We are 78 trying to minimize the necessary method overrides and switch to data 79 driven Makefile.PLs wherever possible. In the long run less methods 80 will be overridable via the MY class. 81 82 =head1 METHODS 83 84 The following description of methods is still under 85 development. Please refer to the code for not suitably documented 86 sections and complain loudly to the makemaker@perl.org mailing list. 87 Better yet, provide a patch. 88 89 Not all of the methods below are overridable in a 90 Makefile.PL. Overridable methods are marked as (o). All methods are 91 overridable by a platform specific MM_*.pm file. 92 93 Cross-platform methods are being moved into MM_Any. If you can't find 94 something that used to be in here, look in MM_Any. 95 96 =cut 97 98 # So we don't have to keep calling the methods over and over again, 99 # we have these globals to cache the values. Faster and shrtr. 100 my $Curdir = __PACKAGE__->curdir; 101 my $Rootdir = __PACKAGE__->rootdir; 102 my $Updir = __PACKAGE__->updir; 103 104 105 =head2 Methods 106 107 =over 4 108 109 =item os_flavor 110 111 Simply says that we're Unix. 112 113 =cut 114 115 sub os_flavor { 116 return('Unix'); 117 } 118 119 120 =item c_o (o) 121 122 Defines the suffix rules to compile different flavors of C files to 123 object files. 124 125 =cut 126 127 sub c_o { 128 # --- Translation Sections --- 129 130 my($self) = shift; 131 return '' unless $self->needs_linking(); 132 my(@m); 133 134 my $command = '$(CCCMD)'; 135 my $flags = '$(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE)'; 136 137 if (my $cpp = $Config{cpprun}) { 138 my $cpp_cmd = $self->const_cccmd; 139 $cpp_cmd =~ s/^CCCMD\s*=\s*\$\(CC\)/$cpp/; 140 push @m, qq{ 141 .c.i: 142 $cpp_cmd $flags \$*.c > \$*.i 143 }; 144 } 145 146 push @m, qq{ 147 .c.s: 148 $command -S $flags \$*.c 149 150 .c\$(OBJ_EXT): 151 $command $flags \$*.c 152 153 .cpp\$(OBJ_EXT): 154 $command $flags \$*.cpp 155 156 .cxx\$(OBJ_EXT): 157 $command $flags \$*.cxx 158 159 .cc\$(OBJ_EXT): 160 $command $flags \$*.cc 161 }; 162 163 push @m, qq{ 164 .C\$(OBJ_EXT): 165 $command \$*.C 166 } if !$Is_OS2 and !$Is_Win32 and !$Is_Dos; #Case-specific 167 168 return join "", @m; 169 } 170 171 =item cflags (o) 172 173 Does very much the same as the cflags script in the perl 174 distribution. It doesn't return the whole compiler command line, but 175 initializes all of its parts. The const_cccmd method then actually 176 returns the definition of the CCCMD macro which uses these parts. 177 178 =cut 179 180 #' 181 182 sub cflags { 183 my($self,$libperl)=@_; 184 return $self->{CFLAGS} if $self->{CFLAGS}; 185 return '' unless $self->needs_linking(); 186 187 my($prog, $uc, $perltype, %cflags); 188 $libperl ||= $self->{LIBPERL_A} || "libperl$self->{LIB_EXT}" ; 189 $libperl =~ s/\.\$\(A\)$/$self->{LIB_EXT}/; 190 191 @cflags{qw(cc ccflags optimize shellflags)} 192 = @Config{qw(cc ccflags optimize shellflags)}; 193 my($optdebug) = ""; 194 195 $cflags{shellflags} ||= ''; 196 197 my(%map) = ( 198 D => '-DDEBUGGING', 199 E => '-DEMBED', 200 DE => '-DDEBUGGING -DEMBED', 201 M => '-DEMBED -DMULTIPLICITY', 202 DM => '-DDEBUGGING -DEMBED -DMULTIPLICITY', 203 ); 204 205 if ($libperl =~ /libperl(\w*)\Q$self->{LIB_EXT}/){ 206 $uc = uc($1); 207 } else { 208 $uc = ""; # avoid warning 209 } 210 $perltype = $map{$uc} ? $map{$uc} : ""; 211 212 if ($uc =~ /^D/) { 213 $optdebug = "-g"; 214 } 215 216 217 my($name); 218 ( $name = $self->{NAME} . "_cflags" ) =~ s/:/_/g ; 219 if ($prog = $Config{$name}) { 220 # Expand hints for this extension via the shell 221 print STDOUT "Processing $name hint:\n" if $Verbose; 222 my(@o)=`cc=\"$cflags{cc}\" 223 ccflags=\"$cflags{ccflags}\" 224 optimize=\"$cflags{optimize}\" 225 perltype=\"$cflags{perltype}\" 226 optdebug=\"$cflags{optdebug}\" 227 eval '$prog' 228 echo cc=\$cc 229 echo ccflags=\$ccflags 230 echo optimize=\$optimize 231 echo perltype=\$perltype 232 echo optdebug=\$optdebug 233 `; 234 my($line); 235 foreach $line (@o){ 236 chomp $line; 237 if ($line =~ /(.*?)=\s*(.*)\s*$/){ 238 $cflags{$1} = $2; 239 print STDOUT " $1 = $2\n" if $Verbose; 240 } else { 241 print STDOUT "Unrecognised result from hint: '$line'\n"; 242 } 243 } 244 } 245 246 if ($optdebug) { 247 $cflags{optimize} = $optdebug; 248 } 249 250 for (qw(ccflags optimize perltype)) { 251 $cflags{$_} ||= ''; 252 $cflags{$_} =~ s/^\s+//; 253 $cflags{$_} =~ s/\s+/ /g; 254 $cflags{$_} =~ s/\s+$//; 255 $self->{uc $_} ||= $cflags{$_}; 256 } 257 258 if ($self->{POLLUTE}) { 259 $self->{CCFLAGS} .= ' -DPERL_POLLUTE '; 260 } 261 262 my $pollute = ''; 263 if ($Config{usemymalloc} and not $Config{bincompat5005} 264 and not $Config{ccflags} =~ /-DPERL_POLLUTE_MALLOC\b/ 265 and $self->{PERL_MALLOC_OK}) { 266 $pollute = '$(PERL_MALLOC_DEF)'; 267 } 268 269 $self->{CCFLAGS} = quote_paren($self->{CCFLAGS}); 270 $self->{OPTIMIZE} = quote_paren($self->{OPTIMIZE}); 271 272 return $self->{CFLAGS} = qq{ 273 CCFLAGS = $self->{CCFLAGS} 274 OPTIMIZE = $self->{OPTIMIZE} 275 PERLTYPE = $self->{PERLTYPE} 276 MPOLLUTE = $pollute 277 }; 278 279 } 280 281 282 =item const_cccmd (o) 283 284 Returns the full compiler call for C programs and stores the 285 definition in CONST_CCCMD. 286 287 =cut 288 289 sub const_cccmd { 290 my($self,$libperl)=@_; 291 return $self->{CONST_CCCMD} if $self->{CONST_CCCMD}; 292 return '' unless $self->needs_linking(); 293 return $self->{CONST_CCCMD} = 294 q{CCCMD = $(CC) -c $(PASTHRU_INC) $(INC) \\ 295 $(CCFLAGS) $(OPTIMIZE) \\ 296 $(PERLTYPE) $(MPOLLUTE) $(DEFINE_VERSION) \\ 297 $(XS_DEFINE_VERSION)}; 298 } 299 300 =item const_config (o) 301 302 Defines a couple of constants in the Makefile that are imported from 303 %Config. 304 305 =cut 306 307 sub const_config { 308 # --- Constants Sections --- 309 310 my($self) = shift; 311 my(@m,$m); 312 push(@m,"\n# These definitions are from config.sh (via $INC{'Config.pm'})\n"); 313 push(@m,"\n# They may have been overridden via Makefile.PL or on the command line\n"); 314 my(%once_only); 315 foreach $m (@{$self->{CONFIG}}){ 316 # SITE*EXP macros are defined in &constants; avoid duplicates here 317 next if $once_only{$m}; 318 $self->{uc $m} = quote_paren($self->{uc $m}); 319 push @m, uc($m) , ' = ' , $self->{uc $m}, "\n"; 320 $once_only{$m} = 1; 321 } 322 join('', @m); 323 } 324 325 =item const_loadlibs (o) 326 327 Defines EXTRALIBS, LDLOADLIBS, BSLOADLIBS, LD_RUN_PATH. See 328 L<ExtUtils::Liblist> for details. 329 330 =cut 331 332 sub const_loadlibs { 333 my($self) = shift; 334 return "" unless $self->needs_linking; 335 my @m; 336 push @m, qq{ 337 # $self->{NAME} might depend on some other libraries: 338 # See ExtUtils::Liblist for details 339 # 340 }; 341 my($tmp); 342 for $tmp (qw/ 343 EXTRALIBS LDLOADLIBS BSLOADLIBS 344 /) { 345 next unless defined $self->{$tmp}; 346 push @m, "$tmp = $self->{$tmp}\n"; 347 } 348 # don't set LD_RUN_PATH if empty 349 for $tmp (qw/ 350 LD_RUN_PATH 351 /) { 352 next unless $self->{$tmp}; 353 push @m, "$tmp = $self->{$tmp}\n"; 354 } 355 return join "", @m; 356 } 357 358 =item constants (o) 359 360 my $make_frag = $mm->constants; 361 362 Prints out macros for lots of constants. 363 364 =cut 365 366 sub constants { 367 my($self) = @_; 368 my @m = (); 369 370 $self->{DFSEP} = '$(DIRFILESEP)'; # alias for internal use 371 372 for my $macro (qw( 373 374 AR_STATIC_ARGS DIRFILESEP DFSEP 375 NAME NAME_SYM 376 VERSION VERSION_MACRO VERSION_SYM DEFINE_VERSION 377 XS_VERSION XS_VERSION_MACRO XS_DEFINE_VERSION 378 INST_ARCHLIB INST_SCRIPT INST_BIN INST_LIB 379 INST_MAN1DIR INST_MAN3DIR 380 MAN1EXT MAN3EXT 381 INSTALLDIRS INSTALL_BASE DESTDIR PREFIX 382 PERLPREFIX SITEPREFIX VENDORPREFIX 383 ), 384 (map { ("INSTALL".$_, 385 "DESTINSTALL".$_) 386 } $self->installvars), 387 qw( 388 PERL_LIB 389 PERL_ARCHLIB 390 LIBPERL_A MYEXTLIB 391 FIRST_MAKEFILE MAKEFILE_OLD MAKE_APERL_FILE 392 PERLMAINCC PERL_SRC PERL_INC 393 PERL FULLPERL ABSPERL 394 PERLRUN FULLPERLRUN ABSPERLRUN 395 PERLRUNINST FULLPERLRUNINST ABSPERLRUNINST 396 PERL_CORE 397 PERM_RW PERM_RWX 398 399 ) ) 400 { 401 next unless defined $self->{$macro}; 402 403 # pathnames can have sharp signs in them; escape them so 404 # make doesn't think it is a comment-start character. 405 $self->{$macro} =~ s/#/\\#/g; 406 push @m, "$macro = $self->{$macro}\n"; 407 } 408 409 push @m, qq{ 410 MAKEMAKER = $self->{MAKEMAKER} 411 MM_VERSION = $self->{MM_VERSION} 412 MM_REVISION = $self->{MM_REVISION} 413 }; 414 415 push @m, q{ 416 # FULLEXT = Pathname for extension directory (eg Foo/Bar/Oracle). 417 # BASEEXT = Basename part of FULLEXT. May be just equal FULLEXT. (eg Oracle) 418 # PARENT_NAME = NAME without BASEEXT and no trailing :: (eg Foo::Bar) 419 # DLBASE = Basename part of dynamic library. May be just equal BASEEXT. 420 }; 421 422 for my $macro (qw/ 423 MAKE 424 FULLEXT BASEEXT PARENT_NAME DLBASE VERSION_FROM INC DEFINE OBJECT 425 LDFROM LINKTYPE BOOTDEP 426 / ) 427 { 428 next unless defined $self->{$macro}; 429 push @m, "$macro = $self->{$macro}\n"; 430 } 431 432 push @m, " 433 # Handy lists of source code files: 434 XS_FILES = ".$self->wraplist(sort keys %{$self->{XS}})." 435 C_FILES = ".$self->wraplist(@{$self->{C}})." 436 O_FILES = ".$self->wraplist(@{$self->{O_FILES}})." 437 H_FILES = ".$self->wraplist(@{$self->{H}})." 438 MAN1PODS = ".$self->wraplist(sort keys %{$self->{MAN1PODS}})." 439 MAN3PODS = ".$self->wraplist(sort keys %{$self->{MAN3PODS}})." 440 "; 441 442 443 push @m, q{ 444 # Where is the Config information that we are using/depend on 445 CONFIGDEP = $(PERL_ARCHLIB)$(DFSEP)Config.pm $(PERL_INC)$(DFSEP)config.h 446 }; 447 448 449 push @m, qq{ 450 # Where to build things 451 INST_LIBDIR = $self->{INST_LIBDIR} 452 INST_ARCHLIBDIR = $self->{INST_ARCHLIBDIR} 453 454 INST_AUTODIR = $self->{INST_AUTODIR} 455 INST_ARCHAUTODIR = $self->{INST_ARCHAUTODIR} 456 457 INST_STATIC = $self->{INST_STATIC} 458 INST_DYNAMIC = $self->{INST_DYNAMIC} 459 INST_BOOT = $self->{INST_BOOT} 460 }; 461 462 463 push @m, qq{ 464 # Extra linker info 465 EXPORT_LIST = $self->{EXPORT_LIST} 466 PERL_ARCHIVE = $self->{PERL_ARCHIVE} 467 PERL_ARCHIVE_AFTER = $self->{PERL_ARCHIVE_AFTER} 468 }; 469 470 push @m, " 471 472 TO_INST_PM = ".$self->wraplist(sort keys %{$self->{PM}})." 473 474 PM_TO_BLIB = ".$self->wraplist(%{$self->{PM}})." 475 "; 476 477 join('',@m); 478 } 479 480 481 =item depend (o) 482 483 Same as macro for the depend attribute. 484 485 =cut 486 487 sub depend { 488 my($self,%attribs) = @_; 489 my(@m,$key,$val); 490 while (($key,$val) = each %attribs){ 491 last unless defined $key; 492 push @m, "$key : $val\n"; 493 } 494 join "", @m; 495 } 496 497 498 =item init_DEST 499 500 $mm->init_DEST 501 502 Defines the DESTDIR and DEST* variables paralleling the INSTALL*. 503 504 =cut 505 506 sub init_DEST { 507 my $self = shift; 508 509 # Initialize DESTDIR 510 $self->{DESTDIR} ||= ''; 511 512 # Make DEST variables. 513 foreach my $var ($self->installvars) { 514 my $destvar = 'DESTINSTALL'.$var; 515 $self->{$destvar} ||= '$(DESTDIR)$(INSTALL'.$var.')'; 516 } 517 } 518 519 520 =item init_dist 521 522 $mm->init_dist; 523 524 Defines a lot of macros for distribution support. 525 526 macro description default 527 528 TAR tar command to use tar 529 TARFLAGS flags to pass to TAR cvf 530 531 ZIP zip command to use zip 532 ZIPFLAGS flags to pass to ZIP -r 533 534 COMPRESS compression command to gzip --best 535 use for tarfiles 536 SUFFIX suffix to put on .gz 537 compressed files 538 539 SHAR shar command to use shar 540 541 PREOP extra commands to run before 542 making the archive 543 POSTOP extra commands to run after 544 making the archive 545 546 TO_UNIX a command to convert linefeeds 547 to Unix style in your archive 548 549 CI command to checkin your ci -u 550 sources to version control 551 RCS_LABEL command to label your sources rcs -Nv$(VERSION_SYM): -q 552 just after CI is run 553 554 DIST_CP $how argument to manicopy() best 555 when the distdir is created 556 557 DIST_DEFAULT default target to use to tardist 558 create a distribution 559 560 DISTVNAME name of the resulting archive $(DISTNAME)-$(VERSION) 561 (minus suffixes) 562 563 =cut 564 565 sub init_dist { 566 my $self = shift; 567 568 $self->{TAR} ||= 'tar'; 569 $self->{TARFLAGS} ||= 'cvf'; 570 $self->{ZIP} ||= 'zip'; 571 $self->{ZIPFLAGS} ||= '-r'; 572 $self->{COMPRESS} ||= 'gzip --best'; 573 $self->{SUFFIX} ||= '.gz'; 574 $self->{SHAR} ||= 'shar'; 575 $self->{PREOP} ||= '$(NOECHO) $(NOOP)'; # eg update MANIFEST 576 $self->{POSTOP} ||= '$(NOECHO) $(NOOP)'; # eg remove the distdir 577 $self->{TO_UNIX} ||= '$(NOECHO) $(NOOP)'; 578 579 $self->{CI} ||= 'ci -u'; 580 $self->{RCS_LABEL}||= 'rcs -Nv$(VERSION_SYM): -q'; 581 $self->{DIST_CP} ||= 'best'; 582 $self->{DIST_DEFAULT} ||= 'tardist'; 583 584 ($self->{DISTNAME} = $self->{NAME}) =~ s{::}{-}g unless $self->{DISTNAME}; 585 $self->{DISTVNAME} ||= $self->{DISTNAME}.'-'.$self->{VERSION}; 586 587 } 588 589 =item dist (o) 590 591 my $dist_macros = $mm->dist(%overrides); 592 593 Generates a make fragment defining all the macros initialized in 594 init_dist. 595 596 %overrides can be used to override any of the above. 597 598 =cut 599 600 sub dist { 601 my($self, %attribs) = @_; 602 603 my $make = ''; 604 foreach my $key (qw( 605 TAR TARFLAGS ZIP ZIPFLAGS COMPRESS SUFFIX SHAR 606 PREOP POSTOP TO_UNIX 607 CI RCS_LABEL DIST_CP DIST_DEFAULT 608 DISTNAME DISTVNAME 609 )) 610 { 611 my $value = $attribs{$key} || $self->{$key}; 612 $make .= "$key = $value\n"; 613 } 614 615 return $make; 616 } 617 618 =item dist_basics (o) 619 620 Defines the targets distclean, distcheck, skipcheck, manifest, veryclean. 621 622 =cut 623 624 sub dist_basics { 625 my($self) = shift; 626 627 return <<'MAKE_FRAG'; 628 distclean :: realclean distcheck 629 $(NOECHO) $(NOOP) 630 631 distcheck : 632 $(PERLRUN) "-MExtUtils::Manifest=fullcheck" -e fullcheck 633 634 skipcheck : 635 $(PERLRUN) "-MExtUtils::Manifest=skipcheck" -e skipcheck 636 637 manifest : 638 $(PERLRUN) "-MExtUtils::Manifest=mkmanifest" -e mkmanifest 639 640 veryclean : realclean 641 $(RM_F) *~ */*~ *.orig */*.orig *.bak */*.bak *.old */*.old 642 643 MAKE_FRAG 644 645 } 646 647 =item dist_ci (o) 648 649 Defines a check in target for RCS. 650 651 =cut 652 653 sub dist_ci { 654 my($self) = shift; 655 return q{ 656 ci : 657 $(PERLRUN) "-MExtUtils::Manifest=maniread" \\ 658 -e "@all = keys %{ maniread() };" \\ 659 -e "print(qq{Executing $(CI) @all\n}); system(qq{$(CI) @all});" \\ 660 -e "print(qq{Executing $(RCS_LABEL) ...\n}); system(qq{$(RCS_LABEL) @all});" 661 }; 662 } 663 664 =item dist_core (o) 665 666 my $dist_make_fragment = $MM->dist_core; 667 668 Puts the targets necessary for 'make dist' together into one make 669 fragment. 670 671 =cut 672 673 sub dist_core { 674 my($self) = shift; 675 676 my $make_frag = ''; 677 foreach my $target (qw(dist tardist uutardist tarfile zipdist zipfile 678 shdist)) 679 { 680 my $method = $target.'_target'; 681 $make_frag .= "\n"; 682 $make_frag .= $self->$method(); 683 } 684 685 return $make_frag; 686 } 687 688 689 =item B<dist_target> 690 691 my $make_frag = $MM->dist_target; 692 693 Returns the 'dist' target to make an archive for distribution. This 694 target simply checks to make sure the Makefile is up-to-date and 695 depends on $(DIST_DEFAULT). 696 697 =cut 698 699 sub dist_target { 700 my($self) = shift; 701 702 my $date_check = $self->oneliner(<<'CODE', ['-l']); 703 print 'Warning: Makefile possibly out of date with $(VERSION_FROM)' 704 if -e '$(VERSION_FROM)' and -M '$(VERSION_FROM)' < -M '$(FIRST_MAKEFILE)'; 705 CODE 706 707 return sprintf <<'MAKE_FRAG', $date_check; 708 dist : $(DIST_DEFAULT) $(FIRST_MAKEFILE) 709 $(NOECHO) %s 710 MAKE_FRAG 711 } 712 713 =item B<tardist_target> 714 715 my $make_frag = $MM->tardist_target; 716 717 Returns the 'tardist' target which is simply so 'make tardist' works. 718 The real work is done by the dynamically named tardistfile_target() 719 method, tardist should have that as a dependency. 720 721 =cut 722 723 sub tardist_target { 724 my($self) = shift; 725 726 return <<'MAKE_FRAG'; 727 tardist : $(DISTVNAME).tar$(SUFFIX) 728 $(NOECHO) $(NOOP) 729 MAKE_FRAG 730 } 731 732 =item B<zipdist_target> 733 734 my $make_frag = $MM->zipdist_target; 735 736 Returns the 'zipdist' target which is simply so 'make zipdist' works. 737 The real work is done by the dynamically named zipdistfile_target() 738 method, zipdist should have that as a dependency. 739 740 =cut 741 742 sub zipdist_target { 743 my($self) = shift; 744 745 return <<'MAKE_FRAG'; 746 zipdist : $(DISTVNAME).zip 747 $(NOECHO) $(NOOP) 748 MAKE_FRAG 749 } 750 751 =item B<tarfile_target> 752 753 my $make_frag = $MM->tarfile_target; 754 755 The name of this target is the name of the tarball generated by 756 tardist. This target does the actual work of turning the distdir into 757 a tarball. 758 759 =cut 760 761 sub tarfile_target { 762 my($self) = shift; 763 764 return <<'MAKE_FRAG'; 765 $(DISTVNAME).tar$(SUFFIX) : distdir 766 $(PREOP) 767 $(TO_UNIX) 768 $(TAR) $(TARFLAGS) $(DISTVNAME).tar $(DISTVNAME) 769 $(RM_RF) $(DISTVNAME) 770 $(COMPRESS) $(DISTVNAME).tar 771 $(POSTOP) 772 MAKE_FRAG 773 } 774 775 =item zipfile_target 776 777 my $make_frag = $MM->zipfile_target; 778 779 The name of this target is the name of the zip file generated by 780 zipdist. This target does the actual work of turning the distdir into 781 a zip file. 782 783 =cut 784 785 sub zipfile_target { 786 my($self) = shift; 787 788 return <<'MAKE_FRAG'; 789 $(DISTVNAME).zip : distdir 790 $(PREOP) 791 $(ZIP) $(ZIPFLAGS) $(DISTVNAME).zip $(DISTVNAME) 792 $(RM_RF) $(DISTVNAME) 793 $(POSTOP) 794 MAKE_FRAG 795 } 796 797 =item uutardist_target 798 799 my $make_frag = $MM->uutardist_target; 800 801 Converts the tarfile into a uuencoded file 802 803 =cut 804 805 sub uutardist_target { 806 my($self) = shift; 807 808 return <<'MAKE_FRAG'; 809 uutardist : $(DISTVNAME).tar$(SUFFIX) 810 uuencode $(DISTVNAME).tar$(SUFFIX) $(DISTVNAME).tar$(SUFFIX) > $(DISTVNAME).tar$(SUFFIX)_uu 811 MAKE_FRAG 812 } 813 814 815 =item shdist_target 816 817 my $make_frag = $MM->shdist_target; 818 819 Converts the distdir into a shell archive. 820 821 =cut 822 823 sub shdist_target { 824 my($self) = shift; 825 826 return <<'MAKE_FRAG'; 827 shdist : distdir 828 $(PREOP) 829 $(SHAR) $(DISTVNAME) > $(DISTVNAME).shar 830 $(RM_RF) $(DISTVNAME) 831 $(POSTOP) 832 MAKE_FRAG 833 } 834 835 836 =item dlsyms (o) 837 838 Used by some OS' to define DL_FUNCS and DL_VARS and write the *.exp files. 839 840 Normally just returns an empty string. 841 842 =cut 843 844 sub dlsyms { 845 return ''; 846 } 847 848 849 =item dynamic_bs (o) 850 851 Defines targets for bootstrap files. 852 853 =cut 854 855 sub dynamic_bs { 856 my($self, %attribs) = @_; 857 return ' 858 BOOTSTRAP = 859 ' unless $self->has_link_code(); 860 861 my $target = $Is_VMS ? '$(MMS$TARGET)' : '$@'; 862 863 return sprintf <<'MAKE_FRAG', ($target) x 5; 864 BOOTSTRAP = $(BASEEXT).bs 865 866 # As Mkbootstrap might not write a file (if none is required) 867 # we use touch to prevent make continually trying to remake it. 868 # The DynaLoader only reads a non-empty file. 869 $(BOOTSTRAP) : $(FIRST_MAKEFILE) $(BOOTDEP) $(INST_ARCHAUTODIR)$(DFSEP).exists 870 $(NOECHO) $(ECHO) "Running Mkbootstrap for $(NAME) ($(BSLOADLIBS))" 871 $(NOECHO) $(PERLRUN) \ 872 "-MExtUtils::Mkbootstrap" \ 873 -e "Mkbootstrap('$(BASEEXT)','$(BSLOADLIBS)');" 874 $(NOECHO) $(TOUCH) %s 875 $(CHMOD) $(PERM_RW) %s 876 877 $(INST_BOOT) : $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DFSEP).exists 878 $(NOECHO) $(RM_RF) %s 879 - $(CP) $(BOOTSTRAP) %s 880 $(CHMOD) $(PERM_RW) %s 881 MAKE_FRAG 882 } 883 884 =item dynamic_lib (o) 885 886 Defines how to produce the *.so (or equivalent) files. 887 888 =cut 889 890 sub dynamic_lib { 891 my($self, %attribs) = @_; 892 return '' unless $self->needs_linking(); #might be because of a subdir 893 894 return '' unless $self->has_link_code; 895 896 my($otherldflags) = $attribs{OTHERLDFLAGS} || ""; 897 my($inst_dynamic_dep) = $attribs{INST_DYNAMIC_DEP} || ""; 898 my($armaybe) = $attribs{ARMAYBE} || $self->{ARMAYBE} || ":"; 899 my($ldfrom) = '$(LDFROM)'; 900 $armaybe = 'ar' if ($Is_OSF and $armaybe eq ':'); 901 my(@m); 902 my $ld_opt = $Is_OS2 ? '$(OPTIMIZE) ' : ''; # Useful on other systems too? 903 my $ld_fix = $Is_OS2 ? '|| ( $(RM_F) $@ && sh -c false )' : ''; 904 push(@m,' 905 # This section creates the dynamically loadable $(INST_DYNAMIC) 906 # from $(OBJECT) and possibly $(MYEXTLIB). 907 ARMAYBE = '.$armaybe.' 908 OTHERLDFLAGS = '.$ld_opt.$otherldflags.' 909 INST_DYNAMIC_DEP = '.$inst_dynamic_dep.' 910 INST_DYNAMIC_FIX = '.$ld_fix.' 911 912 $(INST_DYNAMIC): $(OBJECT) $(MYEXTLIB) $(BOOTSTRAP) $(INST_ARCHAUTODIR)$(DFSEP).exists $(EXPORT_LIST) $(PERL_ARCHIVE) $(PERL_ARCHIVE_AFTER) $(INST_DYNAMIC_DEP) 913 '); 914 if ($armaybe ne ':'){ 915 $ldfrom = 'tmp$(LIB_EXT)'; 916 push(@m,' $(ARMAYBE) cr '.$ldfrom.' $(OBJECT)'."\n"); 917 push(@m,' $(RANLIB) '."$ldfrom\n"); 918 } 919 $ldfrom = "-all $ldfrom -none" if $Is_OSF; 920 921 # The IRIX linker doesn't use LD_RUN_PATH 922 my $ldrun = $Is_IRIX && $self->{LD_RUN_PATH} ? 923 qq{-rpath "$self->{LD_RUN_PATH}"} : ''; 924 925 # For example in AIX the shared objects/libraries from previous builds 926 # linger quite a while in the shared dynalinker cache even when nobody 927 # is using them. This is painful if one for instance tries to restart 928 # a failed build because the link command will fail unnecessarily 'cos 929 # the shared object/library is 'busy'. 930 push(@m,' $(RM_F) $@ 931 '); 932 933 my $libs = '$(LDLOADLIBS)'; 934 935 if (($Is_NetBSD || $Is_Interix) && $Config{'useshrplib'} eq 'true') { 936 # Use nothing on static perl platforms, and to the flags needed 937 # to link against the shared libperl library on shared perl 938 # platforms. We peek at lddlflags to see if we need -Wl,-R 939 # or -R to add paths to the run-time library search path. 940 if ($Config{'lddlflags'} =~ /-Wl,-R/) { 941 $libs .= ' -L$(PERL_INC) -Wl,-R$(INSTALLARCHLIB)/CORE -Wl,-R$(PERL_ARCHLIB)/CORE -lperl'; 942 } elsif ($Config{'lddlflags'} =~ /-R/) { 943 $libs .= ' -L$(PERL_INC) -R$(INSTALLARCHLIB)/CORE -R$(PERL_ARCHLIB)/CORE -lperl'; 944 } 945 } 946 947 my $ld_run_path_shell = ""; 948 if ($self->{LD_RUN_PATH} ne "") { 949 $ld_run_path_shell = 'LD_RUN_PATH="$(LD_RUN_PATH)" '; 950 } 951 952 push @m, sprintf <<'MAKE', $ld_run_path_shell, $ldrun, $ldfrom, $libs; 953 %s$(LD) %s $(LDDLFLAGS) %s $(OTHERLDFLAGS) -o $@ $(MYEXTLIB) \ 954 $(PERL_ARCHIVE) %s $(PERL_ARCHIVE_AFTER) $(EXPORT_LIST) \ 955 $(INST_DYNAMIC_FIX) 956 MAKE 957 958 push @m, <<'MAKE'; 959 $(CHMOD) $(PERM_RWX) $@ 960 MAKE 961 962 return join('',@m); 963 } 964 965 =item exescan 966 967 Deprecated method. Use libscan instead. 968 969 =cut 970 971 sub exescan { 972 my($self,$path) = @_; 973 $path; 974 } 975 976 =item extliblist 977 978 Called by init_others, and calls ext ExtUtils::Liblist. See 979 L<ExtUtils::Liblist> for details. 980 981 =cut 982 983 sub extliblist { 984 my($self,$libs) = @_; 985 require ExtUtils::Liblist; 986 $self->ext($libs, $Verbose); 987 } 988 989 =item find_perl 990 991 Finds the executables PERL and FULLPERL 992 993 =cut 994 995 sub find_perl { 996 my($self, $ver, $names, $dirs, $trace) = @_; 997 my($name, $dir); 998 if ($trace >= 2){ 999 print "Looking for perl $ver by these names: 1000 @$names 1001 in these dirs: 1002 @$dirs 1003 "; 1004 } 1005 1006 my $stderr_duped = 0; 1007 local *STDERR_COPY; 1008 unless ($Is_BSD) { 1009 if( open(STDERR_COPY, '>&STDERR') ) { 1010 $stderr_duped = 1; 1011 } 1012 else { 1013 warn <<WARNING; 1014 find_perl() can't dup STDERR: $! 1015 You might see some garbage while we search for Perl 1016 WARNING 1017 } 1018 } 1019 1020 foreach $name (@$names){ 1021 foreach $dir (@$dirs){ 1022 next unless defined $dir; # $self->{PERL_SRC} may be undefined 1023 my ($abs, $val); 1024 if ($self->file_name_is_absolute($name)) { # /foo/bar 1025 $abs = $name; 1026 } elsif ($self->canonpath($name) eq 1027 $self->canonpath(basename($name))) { # foo 1028 $abs = $self->catfile($dir, $name); 1029 } else { # foo/bar 1030 $abs = $self->catfile($Curdir, $name); 1031 } 1032 print "Checking $abs\n" if ($trace >= 2); 1033 next unless $self->maybe_command($abs); 1034 print "Executing $abs\n" if ($trace >= 2); 1035 1036 my $version_check = qq{$abs -le "require $ver; print qq{VER_OK}"}; 1037 $version_check = "$Config{run} $version_check" 1038 if defined $Config{run} and length $Config{run}; 1039 1040 # To avoid using the unportable 2>&1 to suppress STDERR, 1041 # we close it before running the command. 1042 # However, thanks to a thread library bug in many BSDs 1043 # ( http://www.freebsd.org/cgi/query-pr.cgi?pr=51535 ) 1044 # we cannot use the fancier more portable way in here 1045 # but instead need to use the traditional 2>&1 construct. 1046 if ($Is_BSD) { 1047 $val = `$version_check 2>&1`; 1048 } else { 1049 close STDERR if $stderr_duped; 1050 $val = `$version_check`; 1051 open STDERR, '>&STDERR_COPY' if $stderr_duped; 1052 } 1053 1054 if ($val =~ /^VER_OK/m) { 1055 print "Using PERL=$abs\n" if $trace; 1056 return $abs; 1057 } elsif ($trace >= 2) { 1058 print "Result: '$val' ".($? >> 8)."\n"; 1059 } 1060 } 1061 } 1062 print STDOUT "Unable to find a perl $ver (by these names: @$names, in these dirs: @$dirs)\n"; 1063 0; # false and not empty 1064 } 1065 1066 1067 =item fixin 1068 1069 $mm->fixin(@files); 1070 1071 Inserts the sharpbang or equivalent magic number to a set of @files. 1072 1073 =cut 1074 1075 sub fixin { # stolen from the pink Camel book, more or less 1076 my ( $self, @files ) = @_; 1077 1078 my ($does_shbang) = $Config{'sharpbang'} =~ /^\s*\#\!/; 1079 for my $file (@files) { 1080 my $file_new = "$file.new"; 1081 my $file_bak = "$file.bak"; 1082 1083 local (*FIXIN); 1084 local (*FIXOUT); 1085 open( FIXIN, $file ) or croak "Can't process '$file': $!"; 1086 local $/ = "\n"; 1087 chomp( my $line = <FIXIN> ); 1088 next unless $line =~ s/^\s*\#!\s*//; # Not a shbang file. 1089 # Now figure out the interpreter name. 1090 my ( $cmd, $arg ) = split ' ', $line, 2; 1091 $cmd =~ s!^.*/!!; 1092 1093 # Now look (in reverse) for interpreter in absolute PATH (unless perl). 1094 my $interpreter; 1095 if ( $cmd eq "perl" ) { 1096 if ( $Config{startperl} =~ m,^\#!.*/perl, ) { 1097 $interpreter = $Config{startperl}; 1098 $interpreter =~ s,^\#!,,; 1099 } 1100 else { 1101 $interpreter = $Config{perlpath}; 1102 } 1103 } 1104 else { 1105 my (@absdirs) 1106 = reverse grep { $self->file_name_is_absolute } $self->path; 1107 $interpreter = ''; 1108 my ($dir); 1109 foreach $dir (@absdirs) { 1110 if ( $self->maybe_command($cmd) ) { 1111 warn "Ignoring $interpreter in $file\n" 1112 if $Verbose && $interpreter; 1113 $interpreter = $self->catfile( $dir, $cmd ); 1114 } 1115 } 1116 } 1117 1118 # Figure out how to invoke interpreter on this machine. 1119 1120 my ($shb) = ""; 1121 if ($interpreter) { 1122 print STDOUT "Changing sharpbang in $file to $interpreter" 1123 if $Verbose; 1124 1125 # this is probably value-free on DOSISH platforms 1126 if ($does_shbang) { 1127 $shb .= "$Config{'sharpbang'}$interpreter"; 1128 $shb .= ' ' . $arg if defined $arg; 1129 $shb .= "\n"; 1130 } 1131 $shb .= qq{ 1132 eval 'exec $interpreter $arg -S \$0 \$1+"\$\@"}' 1133 if 0; # not running under some shell 1134 } unless $Is_Win32; # this won't work on win32, so don't 1135 } 1136 else { 1137 warn "Can't find $cmd in PATH, $file unchanged" 1138 if $Verbose; 1139 next; 1140 } 1141 1142 unless ( open( FIXOUT, ">$file_new" ) ) { 1143 warn "Can't create new $file: $!\n"; 1144 next; 1145 } 1146 1147 # Print out the new #! line (or equivalent). 1148 local $\; 1149 local $/; 1150 print FIXOUT $shb, <FIXIN>; 1151 close FIXIN; 1152 close FIXOUT; 1153 1154 chmod 0666, $file_bak; 1155 unlink $file_bak; 1156 unless ( _rename( $file, $file_bak ) ) { 1157 warn "Can't rename $file to $file_bak: $!"; 1158 next; 1159 } 1160 unless ( _rename( $file_new, $file ) ) { 1161 warn "Can't rename $file_new to $file: $!"; 1162 unless ( _rename( $file_bak, $file ) ) { 1163 warn "Can't rename $file_bak back to $file either: $!"; 1164 warn "Leaving $file renamed as $file_bak\n"; 1165 } 1166 next; 1167 } 1168 unlink $file_bak; 1169 } 1170 continue { 1171 close(FIXIN) if fileno(FIXIN); 1172 system("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':'; 1173 } 1174 } 1175 1176 1177 sub _rename { 1178 my($old, $new) = @_; 1179 1180 foreach my $file ($old, $new) { 1181 if( $Is_VMS and basename($file) !~ /\./ ) { 1182 # rename() in 5.8.0 on VMS will not rename a file if it 1183 # does not contain a dot yet it returns success. 1184 $file = "$file."; 1185 } 1186 } 1187 1188 return rename($old, $new); 1189 } 1190 1191 1192 =item force (o) 1193 1194 Writes an empty FORCE: target. 1195 1196 =cut 1197 1198 sub force { 1199 my($self) = shift; 1200 '# Phony target to force checking subdirectories. 1201 FORCE : 1202 $(NOECHO) $(NOOP) 1203 '; 1204 } 1205 1206 =item guess_name 1207 1208 Guess the name of this package by examining the working directory's 1209 name. MakeMaker calls this only if the developer has not supplied a 1210 NAME attribute. 1211 1212 =cut 1213 1214 # '; 1215 1216 sub guess_name { 1217 my($self) = @_; 1218 use Cwd 'cwd'; 1219 my $name = basename(cwd()); 1220 $name =~ s|[\-_][\d\.\-]+\z||; # this is new with MM 5.00, we 1221 # strip minus or underline 1222 # followed by a float or some such 1223 print "Warning: Guessing NAME [$name] from current directory name.\n"; 1224 $name; 1225 } 1226 1227 =item has_link_code 1228 1229 Returns true if C, XS, MYEXTLIB or similar objects exist within this 1230 object that need a compiler. Does not descend into subdirectories as 1231 needs_linking() does. 1232 1233 =cut 1234 1235 sub has_link_code { 1236 my($self) = shift; 1237 return $self->{HAS_LINK_CODE} if defined $self->{HAS_LINK_CODE}; 1238 if ($self->{OBJECT} or @{$self->{C} || []} or $self->{MYEXTLIB}){ 1239 $self->{HAS_LINK_CODE} = 1; 1240 return 1; 1241 } 1242 return $self->{HAS_LINK_CODE} = 0; 1243 } 1244 1245 1246 =item init_dirscan 1247 1248 Scans the directory structure and initializes DIR, XS, XS_FILES, 1249 C, C_FILES, O_FILES, H, H_FILES, PL_FILES, EXE_FILES. 1250 1251 Called by init_main. 1252 1253 =cut 1254 1255 sub init_dirscan { # --- File and Directory Lists (.xs .pm .pod etc) 1256 my($self) = @_; 1257 my($name, %dir, %xs, %c, %h, %pl_files, %pm); 1258 1259 my %ignore = map {( $_ => 1 )} qw(Makefile.PL Build.PL test.pl t); 1260 1261 # ignore the distdir 1262 $Is_VMS ? $ignore{"$self->{DISTVNAME}.dir"} = 1 1263 : $ignore{$self->{DISTVNAME}} = 1; 1264 1265 @ignore{map lc, keys %ignore} = values %ignore if $Is_VMS; 1266 1267 foreach $name ($self->lsdir($Curdir)){ 1268 next if $name =~ /\#/; 1269 next if $name eq $Curdir or $name eq $Updir or $ignore{$name}; 1270 next unless $self->libscan($name); 1271 if (-d $name){ 1272 next if -l $name; # We do not support symlinks at all 1273 next if $self->{NORECURS}; 1274 $dir{$name} = $name if (-f $self->catfile($name,"Makefile.PL")); 1275 } elsif ($name =~ /\.xs\z/){ 1276 my($c); ($c = $name) =~ s/\.xs\z/.c/; 1277 $xs{$name} = $c; 1278 $c{$c} = 1; 1279 } elsif ($name =~ /\.c(pp|xx|c)?\z/i){ # .c .C .cpp .cxx .cc 1280 $c{$name} = 1 1281 unless $name =~ m/perlmain\.c/; # See MAP_TARGET 1282 } elsif ($name =~ /\.h\z/i){ 1283 $h{$name} = 1; 1284 } elsif ($name =~ /\.PL\z/) { 1285 ($pl_files{$name} = $name) =~ s/\.PL\z// ; 1286 } elsif (($Is_VMS || $Is_Dos) && $name =~ /[._]pl$/i) { 1287 # case-insensitive filesystem, one dot per name, so foo.h.PL 1288 # under Unix appears as foo.h_pl under VMS or fooh.pl on Dos 1289 local($/); open(PL,$name); my $txt = <PL>; close PL; 1290 if ($txt =~ /Extracting \S+ \(with variable substitutions/) { 1291 ($pl_files{$name} = $name) =~ s/[._]pl\z//i ; 1292 } 1293 else { 1294 $pm{$name} = $self->catfile($self->{INST_LIBDIR},$name); 1295 } 1296 } elsif ($name =~ /\.(p[ml]|pod)\z/){ 1297 $pm{$name} = $self->catfile($self->{INST_LIBDIR},$name); 1298 } 1299 } 1300 1301 $self->{PL_FILES} ||= \%pl_files; 1302 $self->{DIR} ||= [sort keys %dir]; 1303 $self->{XS} ||= \%xs; 1304 $self->{C} ||= [sort keys %c]; 1305 $self->{H} ||= [sort keys %h]; 1306 $self->{PM} ||= \%pm; 1307 1308 my @o_files = @{$self->{C}}; 1309 $self->{O_FILES} = [grep s/\.c(pp|xx|c)?\z/$self->{OBJ_EXT}/i, @o_files]; 1310 } 1311 1312 1313 =item init_MANPODS 1314 1315 Determines if man pages should be generated and initializes MAN1PODS 1316 and MAN3PODS as appropriate. 1317 1318 =cut 1319 1320 sub init_MANPODS { 1321 my $self = shift; 1322 1323 # Set up names of manual pages to generate from pods 1324 foreach my $man (qw(MAN1 MAN3)) { 1325 if ( $self->{"$man}PODS"} 1326 or $self->{"INSTALL$man}DIR"} =~ /^(none|\s*)$/ 1327 ) { 1328 $self->{"$man}PODS"} ||= {}; 1329 } 1330 else { 1331 my $init_method = "init_$man}PODS"; 1332 $self->$init_method(); 1333 } 1334 } 1335 } 1336 1337 1338 sub _has_pod { 1339 my($self, $file) = @_; 1340 1341 local *FH; 1342 my($ispod)=0; 1343 if (open(FH,"<$file")) { 1344 while (<FH>) { 1345 if (/^=(?:head\d+|item|pod)\b/) { 1346 $ispod=1; 1347 last; 1348 } 1349 } 1350 close FH; 1351 } else { 1352 # If it doesn't exist yet, we assume, it has pods in it 1353 $ispod = 1; 1354 } 1355 1356 return $ispod; 1357 } 1358 1359 1360 =item init_MAN1PODS 1361 1362 Initializes MAN1PODS from the list of EXE_FILES. 1363 1364 =cut 1365 1366 sub init_MAN1PODS { 1367 my($self) = @_; 1368 1369 if ( exists $self->{EXE_FILES} ) { 1370 foreach my $name (@{$self->{EXE_FILES}}) { 1371 next unless $self->_has_pod($name); 1372 1373 $self->{MAN1PODS}->{$name} = 1374 $self->catfile("\$(INST_MAN1DIR)", 1375 basename($name).".\$(MAN1EXT)"); 1376 } 1377 } 1378 } 1379 1380 1381 =item init_MAN3PODS 1382 1383 Initializes MAN3PODS from the list of PM files. 1384 1385 =cut 1386 1387 sub init_MAN3PODS { 1388 my $self = shift; 1389 1390 my %manifypods = (); # we collect the keys first, i.e. the files 1391 # we have to convert to pod 1392 1393 foreach my $name (keys %{$self->{PM}}) { 1394 if ($name =~ /\.pod\z/ ) { 1395 $manifypods{$name} = $self->{PM}{$name}; 1396 } elsif ($name =~ /\.p[ml]\z/ ) { 1397 if( $self->_has_pod($name) ) { 1398 $manifypods{$name} = $self->{PM}{$name}; 1399 } 1400 } 1401 } 1402 1403 my $parentlibs_re = join '|', @{$self->{PMLIBPARENTDIRS}}; 1404 1405 # Remove "Configure.pm" and similar, if it's not the only pod listed 1406 # To force inclusion, just name it "Configure.pod", or override 1407 # MAN3PODS 1408 foreach my $name (keys %manifypods) { 1409 if ($self->{PERL_CORE} and $name =~ /(config|setup).*\.pm/is) { 1410 delete $manifypods{$name}; 1411 next; 1412 } 1413 my($manpagename) = $name; 1414 $manpagename =~ s/\.p(od|m|l)\z//; 1415 # everything below lib is ok 1416 unless($manpagename =~ s!^\W*($parentlibs_re)\W+!!s) { 1417 $manpagename = $self->catfile( 1418 split(/::/,$self->{PARENT_NAME}),$manpagename 1419 ); 1420 } 1421 $manpagename = $self->replace_manpage_separator($manpagename); 1422 $self->{MAN3PODS}->{$name} = 1423 $self->catfile("\$(INST_MAN3DIR)", "$manpagename.\$(MAN3EXT)"); 1424 } 1425 } 1426 1427 1428 =item init_PM 1429 1430 Initializes PMLIBDIRS and PM from PMLIBDIRS. 1431 1432 =cut 1433 1434 sub init_PM { 1435 my $self = shift; 1436 1437 # Some larger extensions often wish to install a number of *.pm/pl 1438 # files into the library in various locations. 1439 1440 # The attribute PMLIBDIRS holds an array reference which lists 1441 # subdirectories which we should search for library files to 1442 # install. PMLIBDIRS defaults to [ 'lib', $self->{BASEEXT} ]. We 1443 # recursively search through the named directories (skipping any 1444 # which don't exist or contain Makefile.PL files). 1445 1446 # For each *.pm or *.pl file found $self->libscan() is called with 1447 # the default installation path in $_[1]. The return value of 1448 # libscan defines the actual installation location. The default 1449 # libscan function simply returns the path. The file is skipped 1450 # if libscan returns false. 1451 1452 # The default installation location passed to libscan in $_[1] is: 1453 # 1454 # ./*.pm => $(INST_LIBDIR)/*.pm 1455 # ./xyz/... => $(INST_LIBDIR)/xyz/... 1456 # ./lib/... => $(INST_LIB)/... 1457 # 1458 # In this way the 'lib' directory is seen as the root of the actual 1459 # perl library whereas the others are relative to INST_LIBDIR 1460 # (which includes PARENT_NAME). This is a subtle distinction but one 1461 # that's important for nested modules. 1462 1463 unless( $self->{PMLIBDIRS} ) { 1464 if( $Is_VMS ) { 1465 # Avoid logical name vs directory collisions 1466 $self->{PMLIBDIRS} = ['./lib', "./$self->{BASEEXT}"]; 1467 } 1468 else { 1469 $self->{PMLIBDIRS} = ['lib', $self->{BASEEXT}]; 1470 } 1471 } 1472 1473 #only existing directories that aren't in $dir are allowed 1474 1475 # Avoid $_ wherever possible: 1476 # @{$self->{PMLIBDIRS}} = grep -d && !$dir{$_}, @{$self->{PMLIBDIRS}}; 1477 my (@pmlibdirs) = @{$self->{PMLIBDIRS}}; 1478 @{$self->{PMLIBDIRS}} = (); 1479 my %dir = map { ($_ => $_) } @{$self->{DIR}}; 1480 foreach my $pmlibdir (@pmlibdirs) { 1481 -d $pmlibdir && !$dir{$pmlibdir} && push @{$self->{PMLIBDIRS}}, $pmlibdir; 1482 } 1483 1484 unless( $self->{PMLIBPARENTDIRS} ) { 1485 @{$self->{PMLIBPARENTDIRS}} = ('lib'); 1486 } 1487 1488 return if $self->{PM} and $self->{ARGS}{PM}; 1489 1490 if (@{$self->{PMLIBDIRS}}){ 1491 print "Searching PMLIBDIRS: @{$self->{PMLIBDIRS}}\n" 1492 if ($Verbose >= 2); 1493 require File::Find; 1494 File::Find::find(sub { 1495 if (-d $_){ 1496 unless ($self->libscan($_)){ 1497 $File::Find::prune = 1; 1498 } 1499 return; 1500 } 1501 return if /\#/; 1502 return if /~$/; # emacs temp files 1503 return if /,v$/; # RCS files 1504 1505 my $path = $File::Find::name; 1506 my $prefix = $self->{INST_LIBDIR}; 1507 my $striplibpath; 1508 1509 my $parentlibs_re = join '|', @{$self->{PMLIBPARENTDIRS}}; 1510 $prefix = $self->{INST_LIB} 1511 if ($striplibpath = $path) =~ s{^(\W*)($parentlibs_re)\W} 1512 {$1}i; 1513 1514 my($inst) = $self->catfile($prefix,$striplibpath); 1515 local($_) = $inst; # for backwards compatibility 1516 $inst = $self->libscan($inst); 1517 print "libscan($path) => '$inst'\n" if ($Verbose >= 2); 1518 return unless $inst; 1519 $self->{PM}{$path} = $inst; 1520 }, @{$self->{PMLIBDIRS}}); 1521 } 1522 } 1523 1524 1525 =item init_DIRFILESEP 1526 1527 Using / for Unix. Called by init_main. 1528 1529 =cut 1530 1531 sub init_DIRFILESEP { 1532 my($self) = shift; 1533 1534 $self->{DIRFILESEP} = '/'; 1535 } 1536 1537 1538 =item init_main 1539 1540 Initializes AR, AR_STATIC_ARGS, BASEEXT, CONFIG, DISTNAME, DLBASE, 1541 EXE_EXT, FULLEXT, FULLPERL, FULLPERLRUN, FULLPERLRUNINST, INST_*, 1542 INSTALL*, INSTALLDIRS, LIB_EXT, LIBPERL_A, MAP_TARGET, NAME, 1543 OBJ_EXT, PARENT_NAME, PERL, PERL_ARCHLIB, PERL_INC, PERL_LIB, 1544 PERL_SRC, PERLRUN, PERLRUNINST, PREFIX, VERSION, 1545 VERSION_SYM, XS_VERSION. 1546 1547 =cut 1548 1549 sub init_main { 1550 my($self) = @_; 1551 1552 # --- Initialize Module Name and Paths 1553 1554 # NAME = Foo::Bar::Oracle 1555 # FULLEXT = Foo/Bar/Oracle 1556 # BASEEXT = Oracle 1557 # PARENT_NAME = Foo::Bar 1558 ### Only UNIX: 1559 ### ($self->{FULLEXT} = 1560 ### $self->{NAME}) =~ s!::!/!g ; #eg. BSD/Foo/Socket 1561 $self->{FULLEXT} = $self->catdir(split /::/, $self->{NAME}); 1562 1563 1564 # Copied from DynaLoader: 1565 1566 my(@modparts) = split(/::/,$self->{NAME}); 1567 my($modfname) = $modparts[-1]; 1568 1569 # Some systems have restrictions on files names for DLL's etc. 1570 # mod2fname returns appropriate file base name (typically truncated) 1571 # It may also edit @modparts if required. 1572 if (defined &DynaLoader::mod2fname) { 1573 $modfname = &DynaLoader::mod2fname(\@modparts); 1574 } 1575 1576 ($self->{PARENT_NAME}, $self->{BASEEXT}) = $self->{NAME} =~ m!(?:([\w:]+)::)?(\w+)\z! ; 1577 $self->{PARENT_NAME} ||= ''; 1578 1579 if (defined &DynaLoader::mod2fname) { 1580 # As of 5.001m, dl_os2 appends '_' 1581 $self->{DLBASE} = $modfname; 1582 } else { 1583 $self->{DLBASE} = '$(BASEEXT)'; 1584 } 1585 1586 1587 # --- Initialize PERL_LIB, PERL_SRC 1588 1589 # *Real* information: where did we get these two from? ... 1590 my $inc_config_dir = dirname($INC{'Config.pm'}); 1591 my $inc_carp_dir = dirname($INC{'Carp.pm'}); 1592 1593 unless ($self->{PERL_SRC}){ 1594 foreach my $dir_count (1..8) { # 8 is the VMS limit for nesting 1595 my $dir = $self->catdir(($Updir) x $dir_count); 1596 1597 if (-f $self->catfile($dir,"config_h.SH") && 1598 -f $self->catfile($dir,"perl.h") && 1599 -f $self->catfile($dir,"lib","Exporter.pm") 1600 ) { 1601 $self->{PERL_SRC}=$dir ; 1602 last; 1603 } 1604 } 1605 } 1606 1607 warn "PERL_CORE is set but I can't find your PERL_SRC!\n" if 1608 $self->{PERL_CORE} and !$self->{PERL_SRC}; 1609 1610 if ($self->{PERL_SRC}){ 1611 $self->{PERL_LIB} ||= $self->catdir("$self->{PERL_SRC}","lib"); 1612 1613 if (defined $Cross::platform) { 1614 $self->{PERL_ARCHLIB} = 1615 $self->catdir("$self->{PERL_SRC}","xlib",$Cross::platform); 1616 $self->{PERL_INC} = 1617 $self->catdir("$self->{PERL_SRC}","xlib",$Cross::platform, 1618 $Is_Win32?("CORE"):()); 1619 } 1620 else { 1621 $self->{PERL_ARCHLIB} = $self->{PERL_LIB}; 1622 $self->{PERL_INC} = ($Is_Win32) ? 1623 $self->catdir($self->{PERL_LIB},"CORE") : $self->{PERL_SRC}; 1624 } 1625 1626 # catch a situation that has occurred a few times in the past: 1627 unless ( 1628 -s $self->catfile($self->{PERL_SRC},'cflags') 1629 or 1630 $Is_VMS 1631 && 1632 -s $self->catfile($self->{PERL_SRC},'perlshr_attr.opt') 1633 or 1634 $Is_Win32 1635 ){ 1636 warn qq{ 1637 You cannot build extensions below the perl source tree after executing 1638 a 'make clean' in the perl source tree. 1639 1640 To rebuild extensions distributed with the perl source you should 1641 simply Configure (to include those extensions) and then build perl as 1642 normal. After installing perl the source tree can be deleted. It is 1643 not needed for building extensions by running 'perl Makefile.PL' 1644 usually without extra arguments. 1645 1646 It is recommended that you unpack and build additional extensions away 1647 from the perl source tree. 1648 }; 1649 } 1650 } else { 1651 # we should also consider $ENV{PERL5LIB} here 1652 my $old = $self->{PERL_LIB} || $self->{PERL_ARCHLIB} || $self->{PERL_INC}; 1653 $self->{PERL_LIB} ||= $Config{privlibexp}; 1654 $self->{PERL_ARCHLIB} ||= $Config{archlibexp}; 1655 $self->{PERL_INC} = $self->catdir("$self->{PERL_ARCHLIB}","CORE"); # wild guess for now 1656 my $perl_h; 1657 1658 if (not -f ($perl_h = $self->catfile($self->{PERL_INC},"perl.h")) 1659 and not $old){ 1660 # Maybe somebody tries to build an extension with an 1661 # uninstalled Perl outside of Perl build tree 1662 my $lib; 1663 for my $dir (@INC) { 1664 $lib = $dir, last if -e $self->catdir($dir, "Config.pm"); 1665 } 1666 if ($lib) { 1667 # Win32 puts its header files in /perl/src/lib/CORE. 1668 # Unix leaves them in /perl/src. 1669 my $inc = $Is_Win32 ? $self->catdir($lib, "CORE" ) 1670 : dirname $lib; 1671 if (-e $self->catdir($inc, "perl.h")) { 1672 $self->{PERL_LIB} = $lib; 1673 $self->{PERL_ARCHLIB} = $lib; 1674 $self->{PERL_INC} = $inc; 1675 $self->{UNINSTALLED_PERL} = 1; 1676 print STDOUT <<EOP; 1677 ... Detected uninstalled Perl. Trying to continue. 1678 EOP 1679 } 1680 } 1681 } 1682 } 1683 1684 # We get SITELIBEXP and SITEARCHEXP directly via 1685 # Get_from_Config. When we are running standard modules, these 1686 # won't matter, we will set INSTALLDIRS to "perl". Otherwise we 1687 # set it to "site". I prefer that INSTALLDIRS be set from outside 1688 # MakeMaker. 1689 $self->{INSTALLDIRS} ||= "site"; 1690 1691 $self->{MAN1EXT} ||= $Config{man1ext}; 1692 $self->{MAN3EXT} ||= $Config{man3ext}; 1693 1694 # Get some stuff out of %Config if we haven't yet done so 1695 print STDOUT "CONFIG must be an array ref\n" 1696 if ($self->{CONFIG} and ref $self->{CONFIG} ne 'ARRAY'); 1697 $self->{CONFIG} = [] unless (ref $self->{CONFIG}); 1698 push(@{$self->{CONFIG}}, @ExtUtils::MakeMaker::Get_from_Config); 1699 push(@{$self->{CONFIG}}, 'shellflags') if $Config{shellflags}; 1700 my(%once_only); 1701 foreach my $m (@{$self->{CONFIG}}){ 1702 next if $once_only{$m}; 1703 print STDOUT "CONFIG key '$m' does not exist in Config.pm\n" 1704 unless exists $Config{$m}; 1705 $self->{uc $m} ||= $Config{$m}; 1706 $once_only{$m} = 1; 1707 } 1708 1709 # This is too dangerous: 1710 # if ($^O eq "next") { 1711 # $self->{AR} = "libtool"; 1712 # $self->{AR_STATIC_ARGS} = "-o"; 1713 # } 1714 # But I leave it as a placeholder 1715 1716 $self->{AR_STATIC_ARGS} ||= "cr"; 1717 1718 # These should never be needed 1719 $self->{OBJ_EXT} ||= '.o'; 1720 $self->{LIB_EXT} ||= '.a'; 1721 1722 $self->{MAP_TARGET} ||= "perl"; 1723 1724 $self->{LIBPERL_A} ||= "libperl$self->{LIB_EXT}"; 1725 1726 # make a simple check if we find Exporter 1727 warn "Warning: PERL_LIB ($self->{PERL_LIB}) seems not to be a perl library directory 1728 (Exporter.pm not found)" 1729 unless -f $self->catfile("$self->{PERL_LIB}","Exporter.pm") || 1730 $self->{NAME} eq "ExtUtils::MakeMaker"; 1731 } 1732 1733 =item init_others 1734 1735 Initializes EXTRALIBS, BSLOADLIBS, LDLOADLIBS, LIBS, LD_RUN_PATH, LD, 1736 OBJECT, BOOTDEP, PERLMAINCC, LDFROM, LINKTYPE, SHELL, NOOP, 1737 FIRST_MAKEFILE, MAKEFILE_OLD, NOECHO, RM_F, RM_RF, TEST_F, 1738 TOUCH, CP, MV, CHMOD, UMASK_NULL, ECHO, ECHO_N 1739 1740 =cut 1741 1742 sub init_others { # --- Initialize Other Attributes 1743 my($self) = shift; 1744 1745 $self->{LD} ||= 'ld'; 1746 1747 # Compute EXTRALIBS, BSLOADLIBS and LDLOADLIBS from $self->{LIBS} 1748 # Lets look at $self->{LIBS} carefully: It may be an anon array, a string or 1749 # undefined. In any case we turn it into an anon array: 1750 1751 # May check $Config{libs} too, thus not empty. 1752 $self->{LIBS} = [$self->{LIBS}] unless ref $self->{LIBS}; 1753 1754 $self->{LIBS} = [''] unless @{$self->{LIBS}} && defined $self->{LIBS}[0]; 1755 $self->{LD_RUN_PATH} = ""; 1756 my($libs); 1757 foreach $libs ( @{$self->{LIBS}} ){ 1758 $libs =~ s/^\s*(.*\S)\s*$/$1/; # remove leading and trailing whitespace 1759 my(@libs) = $self->extliblist($libs); 1760 if ($libs[0] or $libs[1] or $libs[2]){ 1761 # LD_RUN_PATH now computed by ExtUtils::Liblist 1762 ($self->{EXTRALIBS}, $self->{BSLOADLIBS}, 1763 $self->{LDLOADLIBS}, $self->{LD_RUN_PATH}) = @libs; 1764 last; 1765 } 1766 } 1767 1768 if ( $self->{OBJECT} ) { 1769 $self->{OBJECT} =~ s!\.o(bj)?\b!\$(OBJ_EXT)!g; 1770 } else { 1771 # init_dirscan should have found out, if we have C files 1772 $self->{OBJECT} = ""; 1773 $self->{OBJECT} = '$(BASEEXT)$(OBJ_EXT)' if @{$self->{C}||[]}; 1774 } 1775 $self->{OBJECT} =~ s/\n+/ \\\n\t/g; 1776 $self->{BOOTDEP} = (-f "$self->{BASEEXT}_BS") ? "$self->{BASEEXT}_BS" : ""; 1777 $self->{PERLMAINCC} ||= '$(CC)'; 1778 $self->{LDFROM} = '$(OBJECT)' unless $self->{LDFROM}; 1779 1780 # Sanity check: don't define LINKTYPE = dynamic if we're skipping 1781 # the 'dynamic' section of MM. We don't have this problem with 1782 # 'static', since we either must use it (%Config says we can't 1783 # use dynamic loading) or the caller asked for it explicitly. 1784 if (!$self->{LINKTYPE}) { 1785 $self->{LINKTYPE} = $self->{SKIPHASH}{'dynamic'} 1786 ? 'static' 1787 : ($Config{usedl} ? 'dynamic' : 'static'); 1788 }; 1789 1790 $self->{NOOP} ||= '$(SHELL) -c true'; 1791 $self->{NOECHO} = '@' unless defined $self->{NOECHO}; 1792 1793 $self->{FIRST_MAKEFILE} ||= $self->{MAKEFILE} || 'Makefile'; 1794 $self->{MAKEFILE} ||= $self->{FIRST_MAKEFILE}; 1795 $self->{MAKEFILE_OLD} ||= $self->{MAKEFILE}.'.old'; 1796 $self->{MAKE_APERL_FILE} ||= $self->{MAKEFILE}.'.aperl'; 1797 1798 # Some makes require a wrapper around macros passed in on the command 1799 # line. 1800 $self->{MACROSTART} ||= ''; 1801 $self->{MACROEND} ||= ''; 1802 1803 # Not everybody uses -f to indicate "use this Makefile instead" 1804 $self->{USEMAKEFILE} ||= '-f'; 1805 1806 $self->{SHELL} ||= $Config{sh} || '/bin/sh'; 1807 1808 $self->{ECHO} ||= 'echo'; 1809 $self->{ECHO_N} ||= 'echo -n'; 1810 $self->{RM_F} ||= "rm -f"; 1811 $self->{RM_RF} ||= "rm -rf"; 1812 $self->{TOUCH} ||= "touch"; 1813 $self->{TEST_F} ||= "test -f"; 1814 $self->{CP} ||= "cp"; 1815 $self->{MV} ||= "mv"; 1816 $self->{CHMOD} ||= "chmod"; 1817 $self->{MKPATH} ||= '$(ABSPERLRUN) "-MExtUtils::Command" -e mkpath'; 1818 $self->{EQUALIZE_TIMESTAMP} ||= 1819 '$(ABSPERLRUN) "-MExtUtils::Command" -e eqtime'; 1820 1821 $self->{UNINST} ||= 0; 1822 $self->{VERBINST} ||= 0; 1823 $self->{MOD_INSTALL} ||= 1824 $self->oneliner(<<'CODE', ['-MExtUtils::Install']); 1825 install({@ARGV}, '$(VERBINST)', 0, '$(UNINST)'); 1826 CODE 1827 $self->{DOC_INSTALL} ||= 1828 '$(ABSPERLRUN) "-MExtUtils::Command::MM" -e perllocal_install'; 1829 $self->{UNINSTALL} ||= 1830 '$(ABSPERLRUN) "-MExtUtils::Command::MM" -e uninstall'; 1831 $self->{WARN_IF_OLD_PACKLIST} ||= 1832 '$(ABSPERLRUN) "-MExtUtils::Command::MM" -e warn_if_old_packlist'; 1833 $self->{FIXIN} ||= 1834 q{$(PERLRUN) "-MExtUtils::MY" -e "MY->fixin(shift)"}; 1835 1836 $self->{UMASK_NULL} ||= "umask 0"; 1837 $self->{DEV_NULL} ||= "> /dev/null 2>&1"; 1838 1839 return 1; 1840 } 1841 1842 1843 =item init_linker 1844 1845 Unix has no need of special linker flags. 1846 1847 =cut 1848 1849 sub init_linker { 1850 my($self) = shift; 1851 $self->{PERL_ARCHIVE} ||= ''; 1852 $self->{PERL_ARCHIVE_AFTER} ||= ''; 1853 $self->{EXPORT_LIST} ||= ''; 1854 } 1855 1856 1857 =begin _protected 1858 1859 =item init_lib2arch 1860 1861 $mm->init_lib2arch 1862 1863 =end _protected 1864 1865 =cut 1866 1867 sub init_lib2arch { 1868 my($self) = shift; 1869 1870 # The user who requests an installation directory explicitly 1871 # should not have to tell us an architecture installation directory 1872 # as well. We look if a directory exists that is named after the 1873 # architecture. If not we take it as a sign that it should be the 1874 # same as the requested installation directory. Otherwise we take 1875 # the found one. 1876 for my $libpair ({l=>"privlib", a=>"archlib"}, 1877 {l=>"sitelib", a=>"sitearch"}, 1878 {l=>"vendorlib", a=>"vendorarch"}, 1879 ) 1880 { 1881 my $lib = "install$libpair->{l}"; 1882 my $Lib = uc $lib; 1883 my $Arch = uc "install$libpair->{a}"; 1884 if( $self->{$Lib} && ! $self->{$Arch} ){ 1885 my($ilib) = $Config{$lib}; 1886 1887 $self->prefixify($Arch,$ilib,$self->{$Lib}); 1888 1889 unless (-d $self->{$Arch}) { 1890 print STDOUT "Directory $self->{$Arch} not found\n" 1891 if $Verbose; 1892 $self->{$Arch} = $self->{$Lib}; 1893 } 1894 print STDOUT "Defaulting $Arch to $self->{$Arch}\n" if $Verbose; 1895 } 1896 } 1897 } 1898 1899 1900 =item init_PERL 1901 1902 $mm->init_PERL; 1903 1904 Called by init_main. Sets up ABSPERL, PERL, FULLPERL and all the 1905 *PERLRUN* permutations. 1906 1907 PERL is allowed to be miniperl 1908 FULLPERL must be a complete perl 1909 1910 ABSPERL is PERL converted to an absolute path 1911 1912 *PERLRUN contains everything necessary to run perl, find it's 1913 libraries, etc... 1914 1915 *PERLRUNINST is *PERLRUN + everything necessary to find the 1916 modules being built. 1917 1918 =cut 1919 1920 sub init_PERL { 1921 my($self) = shift; 1922 1923 my @defpath = (); 1924 foreach my $component ($self->{PERL_SRC}, $self->path(), 1925 $Config{binexp}) 1926 { 1927 push @defpath, $component if defined $component; 1928 } 1929 1930 # Build up a set of file names (not command names). 1931 my $thisperl = $self->canonpath($^X); 1932 $thisperl .= $Config{exe_ext} unless 1933 # VMS might have a file version # at the end 1934 $Is_VMS ? $thisperl =~ m/$Config{exe_ext}(;\d+)?$/i 1935 : $thisperl =~ m/$Config{exe_ext}$/i; 1936 1937 # We need a relative path to perl when in the core. 1938 $thisperl = $self->abs2rel($thisperl) if $self->{PERL_CORE}; 1939 1940 my @perls = ($thisperl); 1941 push @perls, map { "$_$Config{exe_ext}" } 1942 ('perl', 'perl5', "perl$Config{version}"); 1943 1944 # miniperl has priority over all but the cannonical perl when in the 1945 # core. Otherwise its a last resort. 1946 my $miniperl = "miniperl$Config{exe_ext}"; 1947 if( $self->{PERL_CORE} ) { 1948 splice @perls, 1, 0, $miniperl; 1949 } 1950 else { 1951 push @perls, $miniperl; 1952 } 1953 1954 $self->{PERL} ||= 1955 $self->find_perl(5.0, \@perls, \@defpath, $Verbose ); 1956 # don't check if perl is executable, maybe they have decided to 1957 # supply switches with perl 1958 1959 # When built for debugging, VMS doesn't create perl.exe but ndbgperl.exe. 1960 my $perl_name = 'perl'; 1961 $perl_name = 'ndbgperl' if $Is_VMS && 1962 defined $Config{usevmsdebug} && $Config{usevmsdebug} eq 'define'; 1963 1964 # XXX This logic is flawed. If "miniperl" is anywhere in the path 1965 # it will get confused. It should be fixed to work only on the filename. 1966 # Define 'FULLPERL' to be a non-miniperl (used in test: target) 1967 ($self->{FULLPERL} = $self->{PERL}) =~ s/miniperl/$perl_name/i 1968 unless $self->{FULLPERL}; 1969 1970 # Little hack to get around VMS's find_perl putting "MCR" in front 1971 # sometimes. 1972 $self->{ABSPERL} = $self->{PERL}; 1973 my $has_mcr = $self->{ABSPERL} =~ s/^MCR\s*//; 1974 if( $self->file_name_is_absolute($self->{ABSPERL}) ) { 1975 $self->{ABSPERL} = '$(PERL)'; 1976 } 1977 else { 1978 $self->{ABSPERL} = $self->rel2abs($self->{ABSPERL}); 1979 $self->{ABSPERL} = 'MCR '.$self->{ABSPERL} if $has_mcr; 1980 } 1981 1982 # Are we building the core? 1983 $self->{PERL_CORE} = $ENV{PERL_CORE} unless exists $self->{PERL_CORE}; 1984 $self->{PERL_CORE} = 0 unless defined $self->{PERL_CORE}; 1985 1986 # How do we run perl? 1987 foreach my $perl (qw(PERL FULLPERL ABSPERL)) { 1988 my $run = $perl.'RUN'; 1989 1990 $self->{$run} = "\$($perl)"; 1991 1992 # Make sure perl can find itself before it's installed. 1993 $self->{$run} .= q{ "-I$(PERL_LIB)" "-I$(PERL_ARCHLIB)"} 1994 if $self->{UNINSTALLED_PERL} || $self->{PERL_CORE}; 1995 1996 $self->{$perl.'RUNINST'} = 1997 sprintf q{$(%sRUN) "-I$(INST_ARCHLIB)" "-I$(INST_LIB)"}, $perl; 1998 } 1999 2000 return 1; 2001 } 2002 2003 2004 =item init_platform 2005 2006 =item platform_constants 2007 2008 Add MM_Unix_VERSION. 2009 2010 =cut 2011 2012 sub init_platform { 2013 my($self) = shift; 2014 2015 $self->{MM_Unix_VERSION} = $VERSION; 2016 $self->{PERL_MALLOC_DEF} = '-DPERL_EXTMALLOC_DEF -Dmalloc=Perl_malloc '. 2017 '-Dfree=Perl_mfree -Drealloc=Perl_realloc '. 2018 '-Dcalloc=Perl_calloc'; 2019 2020 } 2021 2022 sub platform_constants { 2023 my($self) = shift; 2024 my $make_frag = ''; 2025 2026 foreach my $macro (qw(MM_Unix_VERSION PERL_MALLOC_DEF)) 2027 { 2028 next unless defined $self->{$macro}; 2029 $make_frag .= "$macro = $self->{$macro}\n"; 2030 } 2031 2032 return $make_frag; 2033 } 2034 2035 2036 =item init_PERM 2037 2038 $mm->init_PERM 2039 2040 Called by init_main. Initializes PERL_* 2041 2042 =cut 2043 2044 sub init_PERM { 2045 my($self) = shift; 2046 2047 $self->{PERM_RW} = 644 unless defined $self->{PERM_RW}; 2048 $self->{PERM_RWX} = 755 unless defined $self->{PERM_RWX}; 2049 2050 return 1; 2051 } 2052 2053 2054 =item init_xs 2055 2056 $mm->init_xs 2057 2058 Sets up macros having to do with XS code. Currently just INST_STATIC, 2059 INST_DYNAMIC and INST_BOOT. 2060 2061 =cut 2062 2063 sub init_xs { 2064 my $self = shift; 2065 2066 if ($self->has_link_code()) { 2067 $self->{INST_STATIC} = 2068 $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT)$(LIB_EXT)'); 2069 $self->{INST_DYNAMIC} = 2070 $self->catfile('$(INST_ARCHAUTODIR)', '$(DLBASE).$(DLEXT)'); 2071 $self->{INST_BOOT} = 2072 $self->catfile('$(INST_ARCHAUTODIR)', '$(BASEEXT).bs'); 2073 } else { 2074 $self->{INST_STATIC} = ''; 2075 $self->{INST_DYNAMIC} = ''; 2076 $self->{INST_BOOT} = ''; 2077 } 2078 } 2079 2080 =item install (o) 2081 2082 Defines the install target. 2083 2084 =cut 2085 2086 sub install { 2087 my($self, %attribs) = @_; 2088 my(@m); 2089 2090 push @m, q{ 2091 install :: all pure_install doc_install 2092 $(NOECHO) $(NOOP) 2093 2094 install_perl :: all pure_perl_install doc_perl_install 2095 $(NOECHO) $(NOOP) 2096 2097 install_site :: all pure_site_install doc_site_install 2098 $(NOECHO) $(NOOP) 2099 2100 install_vendor :: all pure_vendor_install doc_vendor_install 2101 $(NOECHO) $(NOOP) 2102 2103 pure_install :: pure_$(INSTALLDIRS)_install 2104 $(NOECHO) $(NOOP) 2105 2106 doc_install :: doc_$(INSTALLDIRS)_install 2107 $(NOECHO) $(NOOP) 2108 2109 pure__install : pure_site_install 2110 $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site 2111 2112 doc__install : doc_site_install 2113 $(NOECHO) $(ECHO) INSTALLDIRS not defined, defaulting to INSTALLDIRS=site 2114 2115 pure_perl_install :: 2116 $(NOECHO) $(MOD_INSTALL) \ 2117 read }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \ 2118 write }.$self->catfile('$(DESTINSTALLARCHLIB)','auto','$(FULLEXT)','.packlist').q{ \ 2119 $(INST_LIB) $(DESTINSTALLPRIVLIB) \ 2120 $(INST_ARCHLIB) $(DESTINSTALLARCHLIB) \ 2121 $(INST_BIN) $(DESTINSTALLBIN) \ 2122 $(INST_SCRIPT) $(DESTINSTALLSCRIPT) \ 2123 $(INST_MAN1DIR) $(DESTINSTALLMAN1DIR) \ 2124 $(INST_MAN3DIR) $(DESTINSTALLMAN3DIR) 2125 $(NOECHO) $(WARN_IF_OLD_PACKLIST) \ 2126 }.$self->catdir('$(SITEARCHEXP)','auto','$(FULLEXT)').q{ 2127 2128 2129 pure_site_install :: 2130 $(NOECHO) $(MOD_INSTALL) \ 2131 read }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \ 2132 write }.$self->catfile('$(DESTINSTALLSITEARCH)','auto','$(FULLEXT)','.packlist').q{ \ 2133 $(INST_LIB) $(DESTINSTALLSITELIB) \ 2134 $(INST_ARCHLIB) $(DESTINSTALLSITEARCH) \ 2135 $(INST_BIN) $(DESTINSTALLSITEBIN) \ 2136 $(INST_SCRIPT) $(DESTINSTALLSITESCRIPT) \ 2137 $(INST_MAN1DIR) $(DESTINSTALLSITEMAN1DIR) \ 2138 $(INST_MAN3DIR) $(DESTINSTALLSITEMAN3DIR) 2139 $(NOECHO) $(WARN_IF_OLD_PACKLIST) \ 2140 }.$self->catdir('$(PERL_ARCHLIB)','auto','$(FULLEXT)').q{ 2141 2142 pure_vendor_install :: 2143 $(NOECHO) $(MOD_INSTALL) \ 2144 read }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{ \ 2145 write }.$self->catfile('$(DESTINSTALLVENDORARCH)','auto','$(FULLEXT)','.packlist').q{ \ 2146 $(INST_LIB) $(DESTINSTALLVENDORLIB) \ 2147 $(INST_ARCHLIB) $(DESTINSTALLVENDORARCH) \ 2148 $(INST_BIN) $(DESTINSTALLVENDORBIN) \ 2149 $(INST_SCRIPT) $(DESTINSTALLVENDORSCRIPT) \ 2150 $(INST_MAN1DIR) $(DESTINSTALLVENDORMAN1DIR) \ 2151 $(INST_MAN3DIR) $(DESTINSTALLVENDORMAN3DIR) 2152 2153 doc_perl_install :: 2154 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod 2155 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB) 2156 -$(NOECHO) $(DOC_INSTALL) \ 2157 "Module" "$(NAME)" \ 2158 "installed into" "$(INSTALLPRIVLIB)" \ 2159 LINKTYPE "$(LINKTYPE)" \ 2160 VERSION "$(VERSION)" \ 2161 EXE_FILES "$(EXE_FILES)" \ 2162 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{ 2163 2164 doc_site_install :: 2165 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod 2166 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB) 2167 -$(NOECHO) $(DOC_INSTALL) \ 2168 "Module" "$(NAME)" \ 2169 "installed into" "$(INSTALLSITELIB)" \ 2170 LINKTYPE "$(LINKTYPE)" \ 2171 VERSION "$(VERSION)" \ 2172 EXE_FILES "$(EXE_FILES)" \ 2173 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{ 2174 2175 doc_vendor_install :: 2176 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod 2177 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB) 2178 -$(NOECHO) $(DOC_INSTALL) \ 2179 "Module" "$(NAME)" \ 2180 "installed into" "$(INSTALLVENDORLIB)" \ 2181 LINKTYPE "$(LINKTYPE)" \ 2182 VERSION "$(VERSION)" \ 2183 EXE_FILES "$(EXE_FILES)" \ 2184 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{ 2185 2186 }; 2187 2188 push @m, q{ 2189 uninstall :: uninstall_from_$(INSTALLDIRS)dirs 2190 $(NOECHO) $(NOOP) 2191 2192 uninstall_from_perldirs :: 2193 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(PERL_ARCHLIB)','auto','$(FULLEXT)','.packlist').q{ 2194 2195 uninstall_from_sitedirs :: 2196 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(SITEARCHEXP)','auto','$(FULLEXT)','.packlist').q{ 2197 2198 uninstall_from_vendordirs :: 2199 $(NOECHO) $(UNINSTALL) }.$self->catfile('$(VENDORARCHEXP)','auto','$(FULLEXT)','.packlist').q{ 2200 }; 2201 2202 join("",@m); 2203 } 2204 2205 =item installbin (o) 2206 2207 Defines targets to make and to install EXE_FILES. 2208 2209 =cut 2210 2211 sub installbin { 2212 my($self) = shift; 2213 2214 return "" unless $self->{EXE_FILES} && ref $self->{EXE_FILES} eq "ARRAY"; 2215 my @exefiles = @{$self->{EXE_FILES}}; 2216 return "" unless @exefiles; 2217 2218 @exefiles = map vmsify($_), @exefiles if $Is_VMS; 2219 2220 my %fromto; 2221 for my $from (@exefiles) { 2222 my($path)= $self->catfile('$(INST_SCRIPT)', basename($from)); 2223 2224 local($_) = $path; # for backwards compatibility 2225 my $to = $self->libscan($path); 2226 print "libscan($from) => '$to'\n" if ($Verbose >=2); 2227 2228 $to = vmsify($to) if $Is_VMS; 2229 $fromto{$from} = $to; 2230 } 2231 my @to = values %fromto; 2232 2233 my @m; 2234 push(@m, qq{ 2235 EXE_FILES = @exefiles 2236 2237 pure_all :: @to 2238 \$(NOECHO) \$(NOOP) 2239 2240 realclean :: 2241 }); 2242 2243 # realclean can get rather large. 2244 push @m, map "\t$_\n", $self->split_command('$(RM_F)', @to); 2245 push @m, "\n"; 2246 2247 2248 # A target for each exe file. 2249 while (my($from,$to) = each %fromto) { 2250 last unless defined $from; 2251 2252 push @m, sprintf <<'MAKE', $to, $from, $to, $from, $to, $to, $to; 2253 %s : %s $(FIRST_MAKEFILE) $(INST_SCRIPT)$(DFSEP).exists $(INST_BIN)$(DFSEP).exists 2254 $(NOECHO) $(RM_F) %s 2255 $(CP) %s %s 2256 $(FIXIN) %s 2257 -$(NOECHO) $(CHMOD) $(PERM_RWX) %s 2258 2259 MAKE 2260 2261 } 2262 2263 join "", @m; 2264 } 2265 2266 2267 =item linkext (o) 2268 2269 Defines the linkext target which in turn defines the LINKTYPE. 2270 2271 =cut 2272 2273 sub linkext { 2274 my($self, %attribs) = @_; 2275 # LINKTYPE => static or dynamic or '' 2276 my($linktype) = defined $attribs{LINKTYPE} ? 2277 $attribs{LINKTYPE} : '$(LINKTYPE)'; 2278 " 2279 linkext :: $linktype 2280 \$(NOECHO) \$(NOOP) 2281 "; 2282 } 2283 2284 =item lsdir 2285 2286 Takes as arguments a directory name and a regular expression. Returns 2287 all entries in the directory that match the regular expression. 2288 2289 =cut 2290 2291 sub lsdir { 2292 my($self) = shift; 2293 my($dir, $regex) = @_; 2294 my(@ls); 2295 my $dh = new DirHandle; 2296 $dh->open($dir || ".") or return (); 2297 @ls = $dh->read; 2298 $dh->close; 2299 @ls = grep(/$regex/, @ls) if $regex; 2300 @ls; 2301 } 2302 2303 =item macro (o) 2304 2305 Simple subroutine to insert the macros defined by the macro attribute 2306 into the Makefile. 2307 2308 =cut 2309 2310 sub macro { 2311 my($self,%attribs) = @_; 2312 my(@m,$key,$val); 2313 while (($key,$val) = each %attribs){ 2314 last unless defined $key; 2315 push @m, "$key = $val\n"; 2316 } 2317 join "", @m; 2318 } 2319 2320 =item makeaperl (o) 2321 2322 Called by staticmake. Defines how to write the Makefile to produce a 2323 static new perl. 2324 2325 By default the Makefile produced includes all the static extensions in 2326 the perl library. (Purified versions of library files, e.g., 2327 DynaLoader_pure_p1_c0_032.a are automatically ignored to avoid link errors.) 2328 2329 =cut 2330 2331 sub makeaperl { 2332 my($self, %attribs) = @_; 2333 my($makefilename, $searchdirs, $static, $extra, $perlinc, $target, $tmp, $libperl) = 2334 @attribs{qw(MAKE DIRS STAT EXTRA INCL TARGET TMP LIBPERL)}; 2335 my(@m); 2336 push @m, " 2337 # --- MakeMaker makeaperl section --- 2338 MAP_TARGET = $target 2339 FULLPERL = $self->{FULLPERL} 2340 "; 2341 return join '', @m if $self->{PARENT}; 2342 2343 my($dir) = join ":", @{$self->{DIR}}; 2344 2345 unless ($self->{MAKEAPERL}) { 2346 push @m, q{ 2347 $(MAP_TARGET) :: static $(MAKE_APERL_FILE) 2348 $(MAKE) $(USEMAKEFILE) $(MAKE_APERL_FILE) $@ 2349 2350 $(MAKE_APERL_FILE) : $(FIRST_MAKEFILE) pm_to_blib 2351 $(NOECHO) $(ECHO) Writing \"$(MAKE_APERL_FILE)\" for this $(MAP_TARGET) 2352 $(NOECHO) $(PERLRUNINST) \ 2353 Makefile.PL DIR=}, $dir, q{ \ 2354 MAKEFILE=$(MAKE_APERL_FILE) LINKTYPE=static \ 2355 MAKEAPERL=1 NORECURS=1 CCCDLFLAGS=}; 2356 2357 foreach (@ARGV){ 2358 if( /\s/ ){ 2359 s/=(.*)/='$1'/; 2360 } 2361 push @m, " \\\n\t\t$_"; 2362 } 2363 # push @m, map( " \\\n\t\t$_", @ARGV ); 2364 push @m, "\n"; 2365 2366 return join '', @m; 2367 } 2368 2369 2370 2371 my($cccmd, $linkcmd, $lperl); 2372 2373 2374 $cccmd = $self->const_cccmd($libperl); 2375 $cccmd =~ s/^CCCMD\s*=\s*//; 2376 $cccmd =~ s/\$\(INC\)/ "-I$self->{PERL_INC}" /; 2377 $cccmd .= " $Config{cccdlflags}" 2378 if ($Config{useshrplib} eq 'true'); 2379 $cccmd =~ s/\(CC\)/\(PERLMAINCC\)/; 2380 2381 # The front matter of the linkcommand... 2382 $linkcmd = join ' ', "\$(CC)", 2383 grep($_, @Config{qw(ldflags ccdlflags)}); 2384 $linkcmd =~ s/\s+/ /g; 2385 $linkcmd =~ s,(perl\.exp),\$(PERL_INC)/$1,; 2386 2387 # Which *.a files could we make use of... 2388 my %static; 2389 require File::Find; 2390 File::Find::find(sub { 2391 return unless m/\Q$self->{LIB_EXT}\E$/; 2392 2393 # Skip perl's libraries. 2394 return if m/^libperl/ or m/^perl\Q$self->{LIB_EXT}\E$/; 2395 2396 # Skip purified versions of libraries 2397 # (e.g., DynaLoader_pure_p1_c0_032.a) 2398 return if m/_pure_\w+_\w+_\w+\.\w+$/ and -f "$File::Find::dir/.pure"; 2399 2400 if( exists $self->{INCLUDE_EXT} ){ 2401 my $found = 0; 2402 my $incl; 2403 my $xx; 2404 2405 ($xx = $File::Find::name) =~ s,.*?/auto/,,s; 2406 $xx =~ s,/?$_,,; 2407 $xx =~ s,/,::,g; 2408 2409 # Throw away anything not explicitly marked for inclusion. 2410 # DynaLoader is implied. 2411 foreach $incl ((@{$self->{INCLUDE_EXT}},'DynaLoader')){ 2412 if( $xx eq $incl ){ 2413 $found++; 2414 last; 2415 } 2416 } 2417 return unless $found; 2418 } 2419 elsif( exists $self->{EXCLUDE_EXT} ){ 2420 my $excl; 2421 my $xx; 2422 2423 ($xx = $File::Find::name) =~ s,.*?/auto/,,s; 2424 $xx =~ s,/?$_,,; 2425 $xx =~ s,/,::,g; 2426 2427 # Throw away anything explicitly marked for exclusion 2428 foreach $excl (@{$self->{EXCLUDE_EXT}}){ 2429 return if( $xx eq $excl ); 2430 } 2431 } 2432 2433 # don't include the installed version of this extension. I 2434 # leave this line here, although it is not necessary anymore: 2435 # I patched minimod.PL instead, so that Miniperl.pm won't 2436 # enclude duplicates 2437 2438 # Once the patch to minimod.PL is in the distribution, I can 2439 # drop it 2440 return if $File::Find::name =~ m:auto/$self->{FULLEXT}/$self->{BASEEXT}$self->{LIB_EXT}\z:; 2441 use Cwd 'cwd'; 2442 $static{cwd() . "/" . $_}++; 2443 }, grep( -d $_, @{$searchdirs || []}) ); 2444 2445 # We trust that what has been handed in as argument, will be buildable 2446 $static = [] unless $static; 2447 @static{@{$static}} = (1) x @{$static}; 2448 2449 $extra = [] unless $extra && ref $extra eq 'ARRAY'; 2450 for (sort keys %static) { 2451 next unless /\Q$self->{LIB_EXT}\E\z/; 2452 $_ = dirname($_) . "/extralibs.ld"; 2453 push @$extra, $_; 2454 } 2455 2456 grep(s/^(.*)/"-I$1"/, @{$perlinc || []}); 2457 2458 $target ||= "perl"; 2459 $tmp ||= "."; 2460 2461 # MAP_STATIC doesn't look into subdirs yet. Once "all" is made and we 2462 # regenerate the Makefiles, MAP_STATIC and the dependencies for 2463 # extralibs.all are computed correctly 2464 push @m, " 2465 MAP_LINKCMD = $linkcmd 2466 MAP_PERLINC = @{$perlinc || []} 2467 MAP_STATIC = ", 2468 join(" \\\n\t", reverse sort keys %static), " 2469 2470 MAP_PRELIBS = $Config{perllibs} $Config{cryptlib} 2471 "; 2472 2473 if (defined $libperl) { 2474 ($lperl = $libperl) =~ s/\$\(A\)/$self->{LIB_EXT}/; 2475 } 2476 unless ($libperl && -f $lperl) { # Ilya's code... 2477 my $dir = $self->{PERL_SRC} || "$self->{PERL_ARCHLIB}/CORE"; 2478 $dir = "$self->{PERL_ARCHLIB}/.." if $self->{UNINSTALLED_PERL}; 2479 $libperl ||= "libperl$self->{LIB_EXT}"; 2480 $libperl = "$dir/$libperl"; 2481 $lperl ||= "libperl$self->{LIB_EXT}"; 2482 $lperl = "$dir/$lperl"; 2483 2484 if (! -f $libperl and ! -f $lperl) { 2485 # We did not find a static libperl. Maybe there is a shared one? 2486 if ($Is_SunOS) { 2487 $lperl = $libperl = "$dir/$Config{libperl}"; 2488 # SUNOS ld does not take the full path to a shared library 2489 $libperl = '' if $Is_SunOS4; 2490 } 2491 } 2492 2493 print STDOUT "Warning: $libperl not found 2494 If you're going to build a static perl binary, make sure perl is installed 2495 otherwise ignore this warning\n" 2496 unless (-f $lperl || defined($self->{PERL_SRC})); 2497 } 2498 2499 # SUNOS ld does not take the full path to a shared library 2500 my $llibperl = $libperl ? '$(MAP_LIBPERL)' : '-lperl'; 2501 2502 push @m, " 2503 MAP_LIBPERL = $libperl 2504 LLIBPERL = $llibperl 2505 "; 2506 2507 push @m, ' 2508 $(INST_ARCHAUTODIR)/extralibs.all : $(INST_ARCHAUTODIR)$(DFSEP).exists '.join(" \\\n\t", @$extra).' 2509 $(NOECHO) $(RM_F) $@ 2510 $(NOECHO) $(TOUCH) $@ 2511 '; 2512 2513 my $catfile; 2514 foreach $catfile (@$extra){ 2515 push @m, "\tcat $catfile >> \$\@\n"; 2516 } 2517 2518 push @m, " 2519 \$(MAP_TARGET) :: $tmp/perlmain\$(OBJ_EXT) \$(MAP_LIBPERL) \$(MAP_STATIC) \$(INST_ARCHAUTODIR)/extralibs.all 2520 \$(MAP_LINKCMD) -o \$\@ \$(OPTIMIZE) $tmp/perlmain\$(OBJ_EXT) \$(LDFROM) \$(MAP_STATIC) \$(LLIBPERL) `cat \$(INST_ARCHAUTODIR)/extralibs.all` \$(MAP_PRELIBS) 2521 \$(NOECHO) \$(ECHO) 'To install the new \"\$(MAP_TARGET)\" binary, call' 2522 \$(NOECHO) \$(ECHO) ' \$(MAKE) \$(USEMAKEFILE) $makefilename inst_perl MAP_TARGET=\$(MAP_TARGET)' 2523 \$(NOECHO) \$(ECHO) 'To remove the intermediate files say' 2524 \$(NOECHO) \$(ECHO) ' \$(MAKE) \$(USEMAKEFILE) $makefilename map_clean' 2525 2526 $tmp/perlmain\$(OBJ_EXT): $tmp/perlmain.c 2527 "; 2528 push @m, "\t".$self->cd($tmp, qq[$cccmd "-I\$(PERL_INC)" perlmain.c])."\n"; 2529 2530 push @m, qq{ 2531 $tmp/perlmain.c: $makefilename}, q{ 2532 $(NOECHO) $(ECHO) Writing $@ 2533 $(NOECHO) $(PERL) $(MAP_PERLINC) "-MExtUtils::Miniperl" \\ 2534 -e "writemain(grep s#.*/auto/##s, split(q| |, q|$(MAP_STATIC)|))" > $@t && $(MV) $@t $@ 2535 2536 }; 2537 push @m, "\t", q{$(NOECHO) $(PERL) $(INSTALLSCRIPT)/fixpmain 2538 } if (defined (&Dos::UseLFN) && Dos::UseLFN()==0); 2539 2540 2541 push @m, q{ 2542 doc_inst_perl : 2543 $(NOECHO) $(ECHO) Appending installation info to $(DESTINSTALLARCHLIB)/perllocal.pod 2544 -$(NOECHO) $(MKPATH) $(DESTINSTALLARCHLIB) 2545 -$(NOECHO) $(DOC_INSTALL) \ 2546 "Perl binary" "$(MAP_TARGET)" \ 2547 MAP_STATIC "$(MAP_STATIC)" \ 2548 MAP_EXTRA "`cat $(INST_ARCHAUTODIR)/extralibs.all`" \ 2549 MAP_LIBPERL "$(MAP_LIBPERL)" \ 2550 >> }.$self->catfile('$(DESTINSTALLARCHLIB)','perllocal.pod').q{ 2551 2552 }; 2553 2554 push @m, q{ 2555 inst_perl : pure_inst_perl doc_inst_perl 2556 2557 pure_inst_perl : $(MAP_TARGET) 2558 }.$self->{CP}.q{ $(MAP_TARGET) }.$self->catfile('$(DESTINSTALLBIN)','$(MAP_TARGET)').q{ 2559 2560 clean :: map_clean 2561 2562 map_clean : 2563 }.$self->{RM_F}.qq{ $tmp/perlmain\$(OBJ_EXT) $tmp/perlmain.c \$(MAP_TARGET) $makefilename \$(INST_ARCHAUTODIR)/extralibs.all 2564 }; 2565 2566 join '', @m; 2567 } 2568 2569 =item makefile (o) 2570 2571 Defines how to rewrite the Makefile. 2572 2573 =cut 2574 2575 sub makefile { 2576 my($self) = shift; 2577 my $m; 2578 # We do not know what target was originally specified so we 2579 # must force a manual rerun to be sure. But as it should only 2580 # happen very rarely it is not a significant problem. 2581 $m = ' 2582 $(OBJECT) : $(FIRST_MAKEFILE) 2583 2584 ' if $self->{OBJECT}; 2585 2586 my $newer_than_target = $Is_VMS ? '$(MMS$SOURCE_LIST)' : '$?'; 2587 my $mpl_args = join " ", map qq["$_"], @ARGV; 2588 2589 $m .= sprintf <<'MAKE_FRAG', $newer_than_target, $mpl_args; 2590 # We take a very conservative approach here, but it's worth it. 2591 # We move Makefile to Makefile.old here to avoid gnu make looping. 2592 $(FIRST_MAKEFILE) : Makefile.PL $(CONFIGDEP) 2593 $(NOECHO) $(ECHO) "Makefile out-of-date with respect to %s" 2594 $(NOECHO) $(ECHO) "Cleaning current config before rebuilding Makefile..." 2595 -$(NOECHO) $(RM_F) $(MAKEFILE_OLD) 2596 -$(NOECHO) $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) 2597 - $(MAKE) $(USEMAKEFILE) $(MAKEFILE_OLD) clean $(DEV_NULL) 2598 $(PERLRUN) Makefile.PL %s 2599 $(NOECHO) $(ECHO) "==> Your Makefile has been rebuilt. <==" 2600 $(NOECHO) $(ECHO) "==> Please rerun the $(MAKE) command. <==" 2601 false 2602 2603 MAKE_FRAG 2604 2605 return $m; 2606 } 2607 2608 2609 =item maybe_command 2610 2611 Returns true, if the argument is likely to be a command. 2612 2613 =cut 2614 2615 sub maybe_command { 2616 my($self,$file) = @_; 2617 return $file if -x $file && ! -d $file; 2618 return; 2619 } 2620 2621 2622 =item needs_linking (o) 2623 2624 Does this module need linking? Looks into subdirectory objects (see 2625 also has_link_code()) 2626 2627 =cut 2628 2629 sub needs_linking { 2630 my($self) = shift; 2631 my($child,$caller); 2632 $caller = (caller(0))[3]; 2633 confess("needs_linking called too early") if 2634 $caller =~ /^ExtUtils::MakeMaker::/; 2635 return $self->{NEEDS_LINKING} if defined $self->{NEEDS_LINKING}; 2636 if ($self->has_link_code or $self->{MAKEAPERL}){ 2637 $self->{NEEDS_LINKING} = 1; 2638 return 1; 2639 } 2640 foreach $child (keys %{$self->{CHILDREN}}) { 2641 if ($self->{CHILDREN}->{$child}->needs_linking) { 2642 $self->{NEEDS_LINKING} = 1; 2643 return 1; 2644 } 2645 } 2646 return $self->{NEEDS_LINKING} = 0; 2647 } 2648 2649 2650 =item parse_abstract 2651 2652 parse a file and return what you think is the ABSTRACT 2653 2654 =cut 2655 2656 sub parse_abstract { 2657 my($self,$parsefile) = @_; 2658 my $result; 2659 local *FH; 2660 local $/ = "\n"; 2661 open(FH,$parsefile) or die "Could not open '$parsefile': $!"; 2662 my $inpod = 0; 2663 my $package = $self->{DISTNAME}; 2664 $package =~ s/-/::/g; 2665 while (<FH>) { 2666 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod; 2667 next if !$inpod; 2668 chop; 2669 next unless /^($package\s-\s)(.*)/; 2670 $result = $2; 2671 last; 2672 } 2673 close FH; 2674 return $result; 2675 } 2676 2677 =item parse_version 2678 2679 my $version = MM->parse_version($file); 2680 2681 Parse a $file and return what $VERSION is set to by the first assignment. 2682 It will return the string "undef" if it can't figure out what $VERSION 2683 is. $VERSION should be for all to see, so C<our $VERSION> or plain $VERSION 2684 are okay, but C<my $VERSION> is not. 2685 2686 parse_version() will try to C<use version> before checking for C<$VERSION> so the following will work. 2687 2688 $VERSION = qv(1.2.3); 2689 2690 =cut 2691 2692 sub parse_version { 2693 my($self,$parsefile) = @_; 2694 my $result; 2695 local *FH; 2696 local $/ = "\n"; 2697 local $_; 2698 open(FH,$parsefile) or die "Could not open '$parsefile': $!"; 2699 my $inpod = 0; 2700 while (<FH>) { 2701 $inpod = /^=(?!cut)/ ? 1 : /^=cut/ ? 0 : $inpod; 2702 next if $inpod || /^\s*#/; 2703 chop; 2704 next unless /(?<!\\)([\$*])(([\w\:\']*)\bVERSION)\b.*\=/; 2705 my $eval = qq{ 2706 package ExtUtils::MakeMaker::_version; 2707 no strict; 2708 BEGIN { eval { 2709 # Ensure any version() routine which might have leaked 2710 # into this package has been deleted. Interferes with 2711 # version->import() 2712 undef *version; 2713 require version; 2714 "version"->import; 2715 } } 2716 2717 local $1$2; 2718 \$$2=undef; 2719 do { 2720 $_ 2721 }; \$$2 2722 }; 2723 local $^W = 0; 2724 $result = eval($eval); 2725 warn "Could not eval '$eval' in $parsefile: $@" if $@; 2726 last; 2727 } 2728 close FH; 2729 2730 $result = "undef" unless defined $result; 2731 return $result; 2732 } 2733 2734 2735 =item pasthru (o) 2736 2737 Defines the string that is passed to recursive make calls in 2738 subdirectories. 2739 2740 =cut 2741 2742 sub pasthru { 2743 my($self) = shift; 2744 my(@m,$key); 2745 2746 my(@pasthru); 2747 my($sep) = $Is_VMS ? ',' : ''; 2748 $sep .= "\\\n\t"; 2749 2750 foreach $key (qw(LIB LIBPERL_A LINKTYPE OPTIMIZE 2751 PREFIX INSTALL_BASE) 2752 ) 2753 { 2754 next unless defined $self->{$key}; 2755 push @pasthru, "$key=\"\$($key)\""; 2756 } 2757 2758 foreach $key (qw(DEFINE INC)) { 2759 next unless defined $self->{$key}; 2760 push @pasthru, "PASTHRU_$key=\"\$(PASTHRU_$key)\""; 2761 } 2762 2763 push @m, "\nPASTHRU = ", join ($sep, @pasthru), "\n"; 2764 join "", @m; 2765 } 2766 2767 =item perl_script 2768 2769 Takes one argument, a file name, and returns the file name, if the 2770 argument is likely to be a perl script. On MM_Unix this is true for 2771 any ordinary, readable file. 2772 2773 =cut 2774 2775 sub perl_script { 2776 my($self,$file) = @_; 2777 return $file if -r $file && -f _; 2778 return; 2779 } 2780 2781 =item perldepend (o) 2782 2783 Defines the dependency from all *.h files that come with the perl 2784 distribution. 2785 2786 =cut 2787 2788 sub perldepend { 2789 my($self) = shift; 2790 my(@m); 2791 2792 my $make_config = $self->cd('$(PERL_SRC)', '$(MAKE) lib/Config.pm'); 2793 2794 push @m, sprintf <<'MAKE_FRAG', $make_config if $self->{PERL_SRC}; 2795 # Check for unpropogated config.sh changes. Should never happen. 2796 # We do NOT just update config.h because that is not sufficient. 2797 # An out of date config.h is not fatal but complains loudly! 2798 $(PERL_INC)/config.h: $(PERL_SRC)/config.sh 2799 -$(NOECHO) $(ECHO) "Warning: $(PERL_INC)/config.h out of date with $(PERL_SRC)/config.sh"; false 2800 2801 $(PERL_ARCHLIB)/Config.pm: $(PERL_SRC)/config.sh 2802 $(NOECHO) $(ECHO) "Warning: $(PERL_ARCHLIB)/Config.pm may be out of date with $(PERL_SRC)/config.sh" 2803 %s 2804 MAKE_FRAG 2805 2806 return join "", @m unless $self->needs_linking; 2807 2808 push @m, q{ 2809 PERL_HDRS = \ 2810 $(PERL_INC)/EXTERN.h \ 2811 $(PERL_INC)/INTERN.h \ 2812 $(PERL_INC)/XSUB.h \ 2813 $(PERL_INC)/av.h \ 2814 $(PERL_INC)/cc_runtime.h \ 2815 $(PERL_INC)/config.h \ 2816 $(PERL_INC)/cop.h \ 2817 $(PERL_INC)/cv.h \ 2818 $(PERL_INC)/dosish.h \ 2819 $(PERL_INC)/embed.h \ 2820 $(PERL_INC)/embedvar.h \ 2821 $(PERL_INC)/fakethr.h \ 2822 $(PERL_INC)/form.h \ 2823 $(PERL_INC)/gv.h \ 2824 $(PERL_INC)/handy.h \ 2825 $(PERL_INC)/hv.h \ 2826 $(PERL_INC)/intrpvar.h \ 2827 $(PERL_INC)/iperlsys.h \ 2828 $(PERL_INC)/keywords.h \ 2829 $(PERL_INC)/mg.h \ 2830 $(PERL_INC)/nostdio.h \ 2831 $(PERL_INC)/op.h \ 2832 $(PERL_INC)/opcode.h \ 2833 $(PERL_INC)/patchlevel.h \ 2834 $(PERL_INC)/perl.h \ 2835 $(PERL_INC)/perlio.h \ 2836 $(PERL_INC)/perlsdio.h \ 2837 $(PERL_INC)/perlsfio.h \ 2838 $(PERL_INC)/perlvars.h \ 2839 $(PERL_INC)/perly.h \ 2840 $(PERL_INC)/pp.h \ 2841 $(PERL_INC)/pp_proto.h \ 2842 $(PERL_INC)/proto.h \ 2843 $(PERL_INC)/regcomp.h \ 2844 $(PERL_INC)/regexp.h \ 2845 $(PERL_INC)/regnodes.h \ 2846 $(PERL_INC)/scope.h \ 2847 $(PERL_INC)/sv.h \ 2848 $(PERL_INC)/thread.h \ 2849 $(PERL_INC)/unixish.h \ 2850 $(PERL_INC)/util.h 2851 2852 $(OBJECT) : $(PERL_HDRS) 2853 } if $self->{OBJECT}; 2854 2855 push @m, join(" ", values %{$self->{XS}})." : \$(XSUBPPDEPS)\n" if %{$self->{XS}}; 2856 2857 join "\n", @m; 2858 } 2859 2860 2861 =item perm_rw (o) 2862 2863 Returns the attribute C<PERM_RW> or the string C<644>. 2864 Used as the string that is passed 2865 to the C<chmod> command to set the permissions for read/writeable files. 2866 MakeMaker chooses C<644> because it has turned out in the past that 2867 relying on the umask provokes hard-to-track bug reports. 2868 When the return value is used by the perl function C<chmod>, it is 2869 interpreted as an octal value. 2870 2871 =cut 2872 2873 sub perm_rw { 2874 return shift->{PERM_RW}; 2875 } 2876 2877 =item perm_rwx (o) 2878 2879 Returns the attribute C<PERM_RWX> or the string C<755>, 2880 i.e. the string that is passed 2881 to the C<chmod> command to set the permissions for executable files. 2882 See also perl_rw. 2883 2884 =cut 2885 2886 sub perm_rwx { 2887 return shift->{PERM_RWX}; 2888 } 2889 2890 =item pm_to_blib 2891 2892 Defines target that copies all files in the hash PM to their 2893 destination and autosplits them. See L<ExtUtils::Install/DESCRIPTION> 2894 2895 =cut 2896 2897 sub pm_to_blib { 2898 my $self = shift; 2899 my($autodir) = $self->catdir('$(INST_LIB)','auto'); 2900 my $r = q{ 2901 pm_to_blib : $(TO_INST_PM) 2902 }; 2903 2904 my $pm_to_blib = $self->oneliner(<<CODE, ['-MExtUtils::Install']); 2905 pm_to_blib({\@ARGV}, '$autodir', '\$(PM_FILTER)') 2906 CODE 2907 2908 my @cmds = $self->split_command($pm_to_blib, %{$self->{PM}}); 2909 2910 $r .= join '', map { "\t\$(NOECHO) $_\n" } @cmds; 2911 $r .= qq{\t\$(NOECHO) \$(TOUCH) pm_to_blib\n}; 2912 2913 return $r; 2914 } 2915 2916 =item post_constants (o) 2917 2918 Returns an empty string per default. Dedicated to overrides from 2919 within Makefile.PL after all constants have been defined. 2920 2921 =cut 2922 2923 sub post_constants{ 2924 ""; 2925 } 2926 2927 =item post_initialize (o) 2928 2929 Returns an empty string per default. Used in Makefile.PLs to add some 2930 chunk of text to the Makefile after the object is initialized. 2931 2932 =cut 2933 2934 sub post_initialize { 2935 ""; 2936 } 2937 2938 =item postamble (o) 2939 2940 Returns an empty string. Can be used in Makefile.PLs to write some 2941 text to the Makefile at the end. 2942 2943 =cut 2944 2945 sub postamble { 2946 ""; 2947 } 2948 2949 =item ppd 2950 2951 Defines target that creates a PPD (Perl Package Description) file 2952 for a binary distribution. 2953 2954 =cut 2955 2956 sub ppd { 2957 my($self) = @_; 2958 2959 my ($pack_ver) = join ",", (split (/\./, $self->{VERSION}), (0)x4)[0..3]; 2960 2961 my $abstract = $self->{ABSTRACT} || ''; 2962 $abstract =~ s/\n/\\n/sg; 2963 $abstract =~ s/</</g; 2964 $abstract =~ s/>/>/g; 2965 2966 my $author = $self->{AUTHOR} || ''; 2967 $author =~ s/</</g; 2968 $author =~ s/>/>/g; 2969 2970 my $ppd_xml = sprintf <<'PPD_HTML', $pack_ver, $abstract, $author; 2971 <SOFTPKG NAME="$(DISTNAME)" VERSION="%s"> 2972 <TITLE>$(DISTNAME)</TITLE> 2973 <ABSTRACT>%s</ABSTRACT> 2974 <AUTHOR>%s</AUTHOR> 2975 PPD_HTML 2976 2977 $ppd_xml .= " <IMPLEMENTATION>\n"; 2978 foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) { 2979 my $pre_req = $prereq; 2980 $pre_req =~ s/::/-/g; 2981 my ($dep_ver) = join ",", (split (/\./, $self->{PREREQ_PM}{$prereq}), 2982 (0) x 4) [0 .. 3]; 2983 $ppd_xml .= sprintf <<'PPD_OUT', $pre_req, $dep_ver; 2984 <DEPENDENCY NAME="%s" VERSION="%s" /> 2985 PPD_OUT 2986 2987 } 2988 2989 my $archname = $Config{archname}; 2990 if ($] >= 5.008) { 2991 # archname did not change from 5.6 to 5.8, but those versions may 2992 # not be not binary compatible so now we append the part of the 2993 # version that changes when binary compatibility may change 2994 $archname .= "-". substr($Config{version},0,3); 2995 } 2996 $ppd_xml .= sprintf <<'PPD_OUT', $archname; 2997 <OS NAME="$(OSNAME)" /> 2998 <ARCHITECTURE NAME="%s" /> 2999 PPD_OUT 3000 3001 if ($self->{PPM_INSTALL_SCRIPT}) { 3002 if ($self->{PPM_INSTALL_EXEC}) { 3003 $ppd_xml .= sprintf qq{ <INSTALL EXEC="%s">%s</INSTALL>\n}, 3004 $self->{PPM_INSTALL_EXEC}, $self->{PPM_INSTALL_SCRIPT}; 3005 } 3006 else { 3007 $ppd_xml .= sprintf qq{ <INSTALL>%s</INSTALL>\n}, 3008 $self->{PPM_INSTALL_SCRIPT}; 3009 } 3010 } 3011 3012 my ($bin_location) = $self->{BINARY_LOCATION} || ''; 3013 $bin_location =~ s/\\/\\\\/g; 3014 3015 $ppd_xml .= sprintf <<'PPD_XML', $bin_location; 3016 <CODEBASE HREF="%s" /> 3017 </IMPLEMENTATION> 3018 </SOFTPKG> 3019 PPD_XML 3020 3021 my @ppd_cmds = $self->echo($ppd_xml, '$(DISTNAME).ppd'); 3022 3023 return sprintf <<'PPD_OUT', join "\n\t", @ppd_cmds; 3024 # Creates a PPD (Perl Package Description) for a binary distribution. 3025 ppd : 3026 %s 3027 PPD_OUT 3028 3029 } 3030 3031 =item prefixify 3032 3033 $MM->prefixify($var, $prefix, $new_prefix, $default); 3034 3035 Using either $MM->{uc $var} || $Config{lc $var}, it will attempt to 3036 replace it's $prefix with a $new_prefix. 3037 3038 Should the $prefix fail to match I<AND> a PREFIX was given as an 3039 argument to WriteMakefile() it will set it to the $new_prefix + 3040 $default. This is for systems whose file layouts don't neatly fit into 3041 our ideas of prefixes. 3042 3043 This is for heuristics which attempt to create directory structures 3044 that mirror those of the installed perl. 3045 3046 For example: 3047 3048 $MM->prefixify('installman1dir', '/usr', '/home/foo', 'man/man1'); 3049 3050 this will attempt to remove '/usr' from the front of the 3051 $MM->{INSTALLMAN1DIR} path (initializing it to $Config{installman1dir} 3052 if necessary) and replace it with '/home/foo'. If this fails it will 3053 simply use '/home/foo/man/man1'. 3054 3055 =cut 3056 3057 sub prefixify { 3058 my($self,$var,$sprefix,$rprefix,$default) = @_; 3059 3060 my $path = $self->{uc $var} || 3061 $Config_Override{lc $var} || $Config{lc $var} || ''; 3062 3063 $rprefix .= '/' if $sprefix =~ m|/$|; 3064 3065 print STDERR " prefixify $var => $path\n" if $Verbose >= 2; 3066 print STDERR " from $sprefix to $rprefix\n" if $Verbose >= 2; 3067 3068 if( $self->{ARGS}{PREFIX} && $self->file_name_is_absolute($path) && 3069 $path !~ s{^\Q$sprefix\E\b}{$rprefix}s ) 3070 { 3071 3072 print STDERR " cannot prefix, using default.\n" if $Verbose >= 2; 3073 print STDERR " no default!\n" if !$default && $Verbose >= 2; 3074 3075 $path = $self->catdir($rprefix, $default) if $default; 3076 } 3077 3078 print " now $path\n" if $Verbose >= 2; 3079 return $self->{uc $var} = $path; 3080 } 3081 3082 3083 =item processPL (o) 3084 3085 Defines targets to run *.PL files. 3086 3087 =cut 3088 3089 sub processPL { 3090 my $self = shift; 3091 my $pl_files = $self->{PL_FILES}; 3092 3093 return "" unless $pl_files; 3094 3095 my $m = ''; 3096 foreach my $plfile (sort keys %$pl_files) { 3097 my $list = ref($pl_files->{$plfile}) 3098 ? $pl_files->{$plfile} 3099 : [$pl_files->{$plfile}]; 3100 3101 foreach my $target (@$list) { 3102 if( $Is_VMS ) { 3103 $plfile = vmsify($self->eliminate_macros($plfile)); 3104 $target = vmsify($self->eliminate_macros($target)); 3105 } 3106 3107 # Normally a .PL file runs AFTER pm_to_blib so it can have 3108 # blib in its @INC and load the just built modules. BUT if 3109 # the generated module is something in $(TO_INST_PM) which 3110 # pm_to_blib depends on then it can't depend on pm_to_blib 3111 # else we have a dependency loop. 3112 my $pm_dep; 3113 my $perlrun; 3114 if( defined $self->{PM}{$target} ) { 3115 $pm_dep = ''; 3116 $perlrun = 'PERLRUN'; 3117 } 3118 else { 3119 $pm_dep = 'pm_to_blib'; 3120 $perlrun = 'PERLRUNINST'; 3121 } 3122 3123 $m .= <<MAKE_FRAG; 3124 3125 all :: $target 3126 \$(NOECHO) \$(NOOP) 3127 3128 $target :: $plfile $pm_dep 3129 \$($perlrun) $plfile $target 3130 MAKE_FRAG 3131 3132 } 3133 } 3134 3135 return $m; 3136 } 3137 3138 =item quote_paren 3139 3140 Backslashes parentheses C<()> in command line arguments. 3141 Doesn't handle recursive Makefile C<$(...)> constructs, 3142 but handles simple ones. 3143 3144 =cut 3145 3146 sub quote_paren { 3147 my $arg = shift; 3148 $arg =~ s{\$\((.+?)\)}{\$\\\\($1\\\\)}g; # protect $(...) 3149 $arg =~ s{(?<!\\)([()])}{\\$1}g; # quote unprotected 3150 $arg =~ s{\$\\\\\((.+?)\\\\\)}{\$($1)}g; # unprotect $(...) 3151 return $arg; 3152 } 3153 3154 =item replace_manpage_separator 3155 3156 my $man_name = $MM->replace_manpage_separator($file_path); 3157 3158 Takes the name of a package, which may be a nested package, in the 3159 form 'Foo/Bar.pm' and replaces the slash with C<::> or something else 3160 safe for a man page file name. Returns the replacement. 3161 3162 =cut 3163 3164 sub replace_manpage_separator { 3165 my($self,$man) = @_; 3166 3167 $man =~ s,/+,::,g; 3168 return $man; 3169 } 3170 3171 3172 =item cd 3173 3174 =cut 3175 3176 sub cd { 3177 my($self, $dir, @cmds) = @_; 3178 3179 # No leading tab and no trailing newline makes for easier embedding 3180 my $make_frag = join "\n\t", map { "cd $dir && $_" } @cmds; 3181 3182 return $make_frag; 3183 } 3184 3185 =item oneliner 3186 3187 =cut 3188 3189 sub oneliner { 3190 my($self, $cmd, $switches) = @_; 3191 $switches = [] unless defined $switches; 3192 3193 # Strip leading and trailing newlines 3194 $cmd =~ s{^\n+}{}; 3195 $cmd =~ s{\n+$}{}; 3196 3197 my @cmds = split /\n/, $cmd; 3198 $cmd = join " \n\t -e ", map $self->quote_literal($_), @cmds; 3199 $cmd = $self->escape_newlines($cmd); 3200 3201 $switches = join ' ', @$switches; 3202 3203 return qq{\$(ABSPERLRUN) $switches -e $cmd --}; 3204 } 3205 3206 3207 =item quote_literal 3208 3209 =cut 3210 3211 sub quote_literal { 3212 my($self, $text) = @_; 3213 3214 # I think all we have to quote is single quotes and I think 3215 # this is a safe way to do it. 3216 $text =~ s{'}{'\\''}g; 3217 3218 return "'$text'"; 3219 } 3220 3221 3222 =item escape_newlines 3223 3224 =cut 3225 3226 sub escape_newlines { 3227 my($self, $text) = @_; 3228 3229 $text =~ s{\n}{\\\n}g; 3230 3231 return $text; 3232 } 3233 3234 3235 =item max_exec_len 3236 3237 Using POSIX::ARG_MAX. Otherwise falling back to 4096. 3238 3239 =cut 3240 3241 sub max_exec_len { 3242 my $self = shift; 3243 3244 if (!defined $self->{_MAX_EXEC_LEN}) { 3245 if (my $arg_max = eval { require POSIX; &POSIX::ARG_MAX }) { 3246 $self->{_MAX_EXEC_LEN} = $arg_max; 3247 } 3248 else { # POSIX minimum exec size 3249 $self->{_MAX_EXEC_LEN} = 4096; 3250 } 3251 } 3252 3253 return $self->{_MAX_EXEC_LEN}; 3254 } 3255 3256 3257 =item static (o) 3258 3259 Defines the static target. 3260 3261 =cut 3262 3263 sub static { 3264 # --- Static Loading Sections --- 3265 3266 my($self) = shift; 3267 ' 3268 ## $(INST_PM) has been moved to the all: target. 3269 ## It remains here for awhile to allow for old usage: "make static" 3270 static :: $(FIRST_MAKEFILE) $(INST_STATIC) 3271 $(NOECHO) $(NOOP) 3272 '; 3273 } 3274 3275 =item static_lib (o) 3276 3277 Defines how to produce the *.a (or equivalent) files. 3278 3279 =cut 3280 3281 sub static_lib { 3282 my($self) = @_; 3283 return '' unless $self->has_link_code; 3284 3285 my(@m); 3286 push(@m, <<'END'); 3287 3288 $(INST_STATIC) : $(OBJECT) $(MYEXTLIB) $(INST_ARCHAUTODIR)$(DFSEP).exists 3289 $(RM_RF) $@ 3290 END 3291 3292 # If this extension has its own library (eg SDBM_File) 3293 # then copy that to $(INST_STATIC) and add $(OBJECT) into it. 3294 push(@m, <<'MAKE_FRAG') if $self->{MYEXTLIB}; 3295 $(CP) $(MYEXTLIB) $@ 3296 MAKE_FRAG 3297 3298 my $ar; 3299 if (exists $self->{FULL_AR} && -x $self->{FULL_AR}) { 3300 # Prefer the absolute pathed ar if available so that PATH 3301 # doesn't confuse us. Perl itself is built with the full_ar. 3302 $ar = 'FULL_AR'; 3303 } else { 3304 $ar = 'AR'; 3305 } 3306 push @m, sprintf <<'MAKE_FRAG', $ar; 3307 $(%s) $(AR_STATIC_ARGS) $@ $(OBJECT) && $(RANLIB) $@ 3308 $(CHMOD) $(PERM_RWX) $@ 3309 $(NOECHO) $(ECHO) "$(EXTRALIBS)" > $(INST_ARCHAUTODIR)/extralibs.ld 3310 MAKE_FRAG 3311 3312 # Old mechanism - still available: 3313 push @m, <<'MAKE_FRAG' if $self->{PERL_SRC} && $self->{EXTRALIBS}; 3314 $(NOECHO) $(ECHO) "$(EXTRALIBS)" >> $(PERL_SRC)/ext.libs 3315 MAKE_FRAG 3316 3317 join('', @m); 3318 } 3319 3320 =item staticmake (o) 3321 3322 Calls makeaperl. 3323 3324 =cut 3325 3326 sub staticmake { 3327 my($self, %attribs) = @_; 3328 my(@static); 3329 3330 my(@searchdirs)=($self->{PERL_ARCHLIB}, $self->{SITEARCHEXP}, $self->{INST_ARCHLIB}); 3331 3332 # And as it's not yet built, we add the current extension 3333 # but only if it has some C code (or XS code, which implies C code) 3334 if (@{$self->{C}}) { 3335 @static = $self->catfile($self->{INST_ARCHLIB}, 3336 "auto", 3337 $self->{FULLEXT}, 3338 "$self->{BASEEXT}$self->{LIB_EXT}" 3339 ); 3340 } 3341 3342 # Either we determine now, which libraries we will produce in the 3343 # subdirectories or we do it at runtime of the make. 3344 3345 # We could ask all subdir objects, but I cannot imagine, why it 3346 # would be necessary. 3347 3348 # Instead we determine all libraries for the new perl at 3349 # runtime. 3350 my(@perlinc) = ($self->{INST_ARCHLIB}, $self->{INST_LIB}, $self->{PERL_ARCHLIB}, $self->{PERL_LIB}); 3351 3352 $self->makeaperl(MAKE => $self->{MAKEFILE}, 3353 DIRS => \@searchdirs, 3354 STAT => \@static, 3355 INCL => \@perlinc, 3356 TARGET => $self->{MAP_TARGET}, 3357 TMP => "", 3358 LIBPERL => $self->{LIBPERL_A} 3359 ); 3360 } 3361 3362 =item subdir_x (o) 3363 3364 Helper subroutine for subdirs 3365 3366 =cut 3367 3368 sub subdir_x { 3369 my($self, $subdir) = @_; 3370 3371 my $subdir_cmd = $self->cd($subdir, 3372 '$(MAKE) $(USEMAKEFILE) $(FIRST_MAKEFILE) all $(PASTHRU)' 3373 ); 3374 return sprintf <<'EOT', $subdir_cmd; 3375 3376 subdirs :: 3377 $(NOECHO) %s 3378 EOT 3379 3380 } 3381 3382 =item subdirs (o) 3383 3384 Defines targets to process subdirectories. 3385 3386 =cut 3387 3388 sub subdirs { 3389 # --- Sub-directory Sections --- 3390 my($self) = shift; 3391 my(@m,$dir); 3392 # This method provides a mechanism to automatically deal with 3393 # subdirectories containing further Makefile.PL scripts. 3394 # It calls the subdir_x() method for each subdirectory. 3395 foreach $dir (@{$self->{DIR}}){ 3396 push(@m, $self->subdir_x($dir)); 3397 #### print "Including $dir subdirectory\n"; 3398 } 3399 if (@m){ 3400 unshift(@m, " 3401 # The default clean, realclean and test targets in this Makefile 3402 # have automatically been given entries for each subdir. 3403 3404 "); 3405 } else { 3406 push(@m, "\n# none") 3407 } 3408 join('',@m); 3409 } 3410 3411 =item test (o) 3412 3413 Defines the test targets. 3414 3415 =cut 3416 3417 sub test { 3418 # --- Test and Installation Sections --- 3419 3420 my($self, %attribs) = @_; 3421 my $tests = $attribs{TESTS} || ''; 3422 if (!$tests && -d 't') { 3423 $tests = $self->find_tests; 3424 } 3425 # note: 'test.pl' name is also hardcoded in init_dirscan() 3426 my(@m); 3427 push(@m," 3428 TEST_VERBOSE=0 3429 TEST_TYPE=test_\$(LINKTYPE) 3430 TEST_FILE = test.pl 3431 TEST_FILES = $tests 3432 TESTDB_SW = -d 3433 3434 testdb :: testdb_\$(LINKTYPE) 3435 3436 test :: \$(TEST_TYPE) subdirs-test 3437 3438 subdirs-test :: 3439 \$(NOECHO) \$(NOOP) 3440 3441 "); 3442 3443 foreach my $dir (@{ $self->{DIR} }) { 3444 my $test = $self->cd($dir, '$(MAKE) test $(PASTHRU)'); 3445 3446 push @m, <<END 3447 subdirs-test :: 3448 \$(NOECHO) $test 3449 3450 END 3451 } 3452 3453 push(@m, "\t\$(NOECHO) \$(ECHO) 'No tests defined for \$(NAME) extension.'\n") 3454 unless $tests or -f "test.pl" or @{$self->{DIR}}; 3455 push(@m, "\n"); 3456 3457 push(@m, "test_dynamic :: pure_all\n"); 3458 push(@m, $self->test_via_harness('$(FULLPERLRUN)', '$(TEST_FILES)')) 3459 if $tests; 3460 push(@m, $self->test_via_script('$(FULLPERLRUN)', '$(TEST_FILE)')) 3461 if -f "test.pl"; 3462 push(@m, "\n"); 3463 3464 push(@m, "testdb_dynamic :: pure_all\n"); 3465 push(@m, $self->test_via_script('$(FULLPERLRUN) $(TESTDB_SW)', 3466 '$(TEST_FILE)')); 3467 push(@m, "\n"); 3468 3469 # Occasionally we may face this degenerate target: 3470 push @m, "test_ : test_dynamic\n\n"; 3471 3472 if ($self->needs_linking()) { 3473 push(@m, "test_static :: pure_all \$(MAP_TARGET)\n"); 3474 push(@m, $self->test_via_harness('./$(MAP_TARGET)', '$(TEST_FILES)')) if $tests; 3475 push(@m, $self->test_via_script('./$(MAP_TARGET)', '$(TEST_FILE)')) if -f "test.pl"; 3476 push(@m, "\n"); 3477 push(@m, "testdb_static :: pure_all \$(MAP_TARGET)\n"); 3478 push(@m, $self->test_via_script('./$(MAP_TARGET) $(TESTDB_SW)', '$(TEST_FILE)')); 3479 push(@m, "\n"); 3480 } else { 3481 push @m, "test_static :: test_dynamic\n"; 3482 push @m, "testdb_static :: testdb_dynamic\n"; 3483 } 3484 join("", @m); 3485 } 3486 3487 =item test_via_harness (override) 3488 3489 For some reason which I forget, Unix machines like to have 3490 PERL_DL_NONLAZY set for tests. 3491 3492 =cut 3493 3494 sub test_via_harness { 3495 my($self, $perl, $tests) = @_; 3496 return $self->SUPER::test_via_harness("PERL_DL_NONLAZY=1 $perl", $tests); 3497 } 3498 3499 =item test_via_script (override) 3500 3501 Again, the PERL_DL_NONLAZY thing. 3502 3503 =cut 3504 3505 sub test_via_script { 3506 my($self, $perl, $script) = @_; 3507 return $self->SUPER::test_via_script("PERL_DL_NONLAZY=1 $perl", $script); 3508 } 3509 3510 3511 =item tools_other (o) 3512 3513 my $make_frag = $MM->tools_other; 3514 3515 Returns a make fragment containing definitions for the macros init_others() 3516 initializes. 3517 3518 =cut 3519 3520 sub tools_other { 3521 my($self) = shift; 3522 my @m; 3523 3524 # We set PM_FILTER as late as possible so it can see all the earlier 3525 # on macro-order sensitive makes such as nmake. 3526 for my $tool (qw{ SHELL CHMOD CP MV NOOP NOECHO RM_F RM_RF TEST_F TOUCH 3527 UMASK_NULL DEV_NULL MKPATH EQUALIZE_TIMESTAMP 3528 ECHO ECHO_N 3529 UNINST VERBINST 3530 MOD_INSTALL DOC_INSTALL UNINSTALL 3531 WARN_IF_OLD_PACKLIST 3532 MACROSTART MACROEND 3533 USEMAKEFILE 3534 PM_FILTER 3535 FIXIN 3536 } ) 3537 { 3538 next unless defined $self->{$tool}; 3539 push @m, "$tool = $self->{$tool}\n"; 3540 } 3541 3542 return join "", @m; 3543 } 3544 3545 =item tool_xsubpp (o) 3546 3547 Determines typemaps, xsubpp version, prototype behaviour. 3548 3549 =cut 3550 3551 sub tool_xsubpp { 3552 my($self) = shift; 3553 return "" unless $self->needs_linking; 3554 3555 my $xsdir; 3556 my @xsubpp_dirs = @INC; 3557 3558 # Make sure we pick up the new xsubpp if we're building perl. 3559 unshift @xsubpp_dirs, $self->{PERL_LIB} if $self->{PERL_CORE}; 3560 3561 foreach my $dir (@xsubpp_dirs) { 3562 $xsdir = $self->catdir($dir, 'ExtUtils'); 3563 if( -r $self->catfile($xsdir, "xsubpp") ) { 3564 last; 3565 } 3566 } 3567 3568 my $tmdir = File::Spec->catdir($self->{PERL_LIB},"ExtUtils"); 3569 my(@tmdeps) = $self->catfile($tmdir,'typemap'); 3570 if( $self->{TYPEMAPS} ){ 3571 my $typemap; 3572 foreach $typemap (@{$self->{TYPEMAPS}}){ 3573 if( ! -f $typemap ){ 3574 warn "Typemap $typemap not found.\n"; 3575 } 3576 else{ 3577 push(@tmdeps, $typemap); 3578 } 3579 } 3580 } 3581 push(@tmdeps, "typemap") if -f "typemap"; 3582 my(@tmargs) = map("-typemap $_", @tmdeps); 3583 if( exists $self->{XSOPT} ){ 3584 unshift( @tmargs, $self->{XSOPT} ); 3585 } 3586 3587 if ($Is_VMS && 3588 $Config{'ldflags'} && 3589 $Config{'ldflags'} =~ m!/Debug!i && 3590 (!exists($self->{XSOPT}) || $self->{XSOPT} !~ /linenumbers/) 3591 ) 3592 { 3593 unshift(@tmargs,'-nolinenumbers'); 3594 } 3595 3596 3597 $self->{XSPROTOARG} = "" unless defined $self->{XSPROTOARG}; 3598 3599 return qq{ 3600 XSUBPPDIR = $xsdir 3601 XSUBPP = \$(XSUBPPDIR)\$(DFSEP)xsubpp 3602 XSUBPPRUN = \$(PERLRUN) \$(XSUBPP) 3603 XSPROTOARG = $self->{XSPROTOARG} 3604 XSUBPPDEPS = @tmdeps \$(XSUBPP) 3605 XSUBPPARGS = @tmargs 3606 XSUBPP_EXTRA_ARGS = 3607 }; 3608 }; 3609 3610 3611 =item all_target 3612 3613 Build man pages, too 3614 3615 =cut 3616 3617 sub all_target { 3618 my $self = shift; 3619 3620 return <<'MAKE_EXT'; 3621 all :: pure_all manifypods 3622 $(NOECHO) $(NOOP) 3623 MAKE_EXT 3624 } 3625 3626 =item top_targets (o) 3627 3628 Defines the targets all, subdirs, config, and O_FILES 3629 3630 =cut 3631 3632 sub top_targets { 3633 # --- Target Sections --- 3634 3635 my($self) = shift; 3636 my(@m); 3637 3638 push @m, $self->all_target, "\n" unless $self->{SKIPHASH}{'all'}; 3639 3640 push @m, ' 3641 pure_all :: config pm_to_blib subdirs linkext 3642 $(NOECHO) $(NOOP) 3643 3644 subdirs :: $(MYEXTLIB) 3645 $(NOECHO) $(NOOP) 3646 3647 config :: $(FIRST_MAKEFILE) blibdirs 3648 $(NOECHO) $(NOOP) 3649 '; 3650 3651 push @m, ' 3652 $(O_FILES): $(H_FILES) 3653 ' if @{$self->{O_FILES} || []} && @{$self->{H} || []}; 3654 3655 push @m, q{ 3656 help : 3657 perldoc ExtUtils::MakeMaker 3658 }; 3659 3660 join('',@m); 3661 } 3662 3663 =item writedoc 3664 3665 Obsolete, deprecated method. Not used since Version 5.21. 3666 3667 =cut 3668 3669 sub writedoc { 3670 # --- perllocal.pod section --- 3671 my($self,$what,$name,@attribs)=@_; 3672 my $time = localtime; 3673 print "=head2 $time: $what C<$name>\n\n=over 4\n\n=item *\n\n"; 3674 print join "\n\n=item *\n\n", map("C<$_>",@attribs); 3675 print "\n\n=back\n\n"; 3676 } 3677 3678 =item xs_c (o) 3679 3680 Defines the suffix rules to compile XS files to C. 3681 3682 =cut 3683 3684 sub xs_c { 3685 my($self) = shift; 3686 return '' unless $self->needs_linking(); 3687 ' 3688 .xs.c: 3689 $(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $(XSUBPP_EXTRA_ARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c 3690 '; 3691 } 3692 3693 =item xs_cpp (o) 3694 3695 Defines the suffix rules to compile XS files to C++. 3696 3697 =cut 3698 3699 sub xs_cpp { 3700 my($self) = shift; 3701 return '' unless $self->needs_linking(); 3702 ' 3703 .xs.cpp: 3704 $(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.cpp 3705 '; 3706 } 3707 3708 =item xs_o (o) 3709 3710 Defines suffix rules to go from XS to object files directly. This is 3711 only intended for broken make implementations. 3712 3713 =cut 3714 3715 sub xs_o { # many makes are too dumb to use xs_c then c_o 3716 my($self) = shift; 3717 return '' unless $self->needs_linking(); 3718 ' 3719 .xs$(OBJ_EXT): 3720 $(XSUBPPRUN) $(XSPROTOARG) $(XSUBPPARGS) $*.xs > $*.xsc && $(MV) $*.xsc $*.c 3721 $(CCCMD) $(CCCDLFLAGS) "-I$(PERL_INC)" $(PASTHRU_DEFINE) $(DEFINE) $*.c 3722 '; 3723 } 3724 3725 3726 1; 3727 3728 =back 3729 3730 =head1 SEE ALSO 3731 3732 L<ExtUtils::MakeMaker> 3733 3734 =cut 3735 3736 __END__
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
| Generated: Tue Mar 17 22:47:18 2015 | Cross-referenced by PHPXref 0.7.1 |