lib/ExtUtils/MakeMaker.pm

   1 BEGIN {require 5.002;} # MakeMaker 5.17 was the last MakeMaker that was compatible with perl5.001m
   2
   3 package ExtUtils::MakeMaker;
   4
   5 $VERSION = "5.48_03";
   6 $Version_OK = "5.17";   # Makefiles older than $Version_OK will die
   7                         # (Will be checked from MakeMaker version 4.13 onwards)
   8 ($Revision = substr(q$Revision: 1.4 $, 10)) =~ s/\s+$//;
   9
  10
  11
  12 require Exporter;
  13 use Config;
  14 use Carp ();
  15
  16 use vars qw(
  17             @ISA @EXPORT @EXPORT_OK $AUTOLOAD
  18             $ISA_TTY $Revision $VERSION $Verbose $Version_OK %Config
  19             %Keep_after_flush %MM_Sections %Prepend_dot_dot
  20             %Recognized_Att_Keys @Get_from_Config @MM_Sections @Overridable
  21             @Parent $PACKNAME
  22            );
  23 use strict;
  24
  25 # &DynaLoader::mod2fname should be available to miniperl, thus
  26 # should be a pseudo-builtin (cmp. os2.c).
  27 #eval {require DynaLoader;};
  28
  29 #
  30 # Set up the inheritance before we pull in the MM_* packages, because they
  31 # import variables and functions from here
  32 #
  33 @ISA = qw(Exporter);
  34 @EXPORT = qw(&WriteMakefile &writeMakefile $Verbose &prompt);
  35 @EXPORT_OK = qw($VERSION &Version_check &neatvalue &mkbootstrap &mksymlists);
  36
  37 #
  38 # Dummy package MM inherits actual methods from OS-specific
  39 # default packages.  We use this intermediate package so
  40 # MY::XYZ->func() can call MM->func() and get the proper
  41 # default routine without having to know under what OS
  42 # it's running.
  43 #
  44 @MM::ISA = qw[ExtUtils::MM_Unix ExtUtils::Liblist::Kid ExtUtils::MakeMaker];
  45
  46 #
  47 # Setup dummy package:
  48 # MY exists for overriding methods to be defined within
  49 #
  50 {
  51     package MY;
  52     @MY::ISA = qw(MM);
  53 ###    sub AUTOLOAD { use Devel::Symdump; print Devel::Symdump->rnew->as_string; Carp::confess "hey why? $AUTOLOAD" }
  54     package MM;
  55     sub DESTROY {}
  56 }
  57
  58 # "predeclare the package: we only load it via AUTOLOAD
  59 # but we have already mentioned it in @ISA
  60 package ExtUtils::Liblist::Kid;
  61
  62 package ExtUtils::MakeMaker;
  63 #
  64 # Now we can pull in the friends
  65 #
  66 my $Is_VMS     = $^O eq 'VMS';
  67 my $Is_OS2     = $^O eq 'os2';
  68 my $Is_Mac     = $^O eq 'MacOS';
  69 my $Is_Win32   = $^O eq 'MSWin32';
  70 my $Is_Cygwin  = $^O eq 'cygwin';
  71 my $Is_NetWare = $Config{'osname'} eq 'NetWare'; # Config{'osname'} intentional
  72 my $Is_BeOS    = $^O =~ /beos/i;    # XXX should this be that loose?
  73
  74 require ExtUtils::MM_Unix;
  75
  76 if ($Is_VMS) {
  77     require ExtUtils::MM_VMS;
  78     require VMS::Filespec; # is a noop as long as we require it within MM_VMS
  79 }
  80 if ($Is_OS2) {
  81     require ExtUtils::MM_OS2;
  82 }
  83 if ($Is_Mac) {
  84     require ExtUtils::MM_MacOS;
  85 }
  86 if ($Is_NetWare) {
  87         $^O = 'NetWare';
  88         require ExtUtils::MM_NW5;
  89         $Is_Win32=0;
  90 }
  91 if ($Is_Win32) {
  92     require ExtUtils::MM_Win32;
  93 }
  94 if ($Is_Cygwin) {
  95     require ExtUtils::MM_Cygwin;
  96 }
  97 if ($Is_BeOS) {
  98     require ExtUtils::MM_BeOS;
  99 }
 100
 101 full_setup();
 102
 103 # The use of the Version_check target has been dropped between perl
 104 # 5.5.63 and 5.5.64. We must keep the subroutine for a while so that
 105 # old Makefiles can satisfy the Version_check target.
 106
 107 sub Version_check {
 108     my($checkversion) = @_;
 109     die "Your Makefile was built with ExtUtils::MakeMaker v $checkversion.
 110 Current Version is $ExtUtils::MakeMaker::VERSION. There have been considerable
 111 changes in the meantime.
 112 Please rerun 'perl Makefile.PL' to regenerate the Makefile.\n"
 113     if $checkversion < $Version_OK;
 114     printf STDOUT "%s %s %s %s.\n", "Makefile built with ExtUtils::MakeMaker v",
 115     $checkversion, "Current Version is", $VERSION
 116         unless $checkversion == $VERSION;
 117 }
 118
 119 sub warnhandler {
 120     $_[0] =~ /^Use of uninitialized value/ && return;
 121     $_[0] =~ /used only once/ && return;
 122     $_[0] =~ /^Subroutine\s+[\w:]+\s+redefined/ && return;
 123     warn @_;
 124 }
 125
 126 sub WriteMakefile {
 127     Carp::croak "WriteMakefile: Need even number of args" if @_ % 2;
 128     local $SIG{__WARN__} = \&warnhandler;
 129
 130     my %att = @_;
 131     MM->new(\%att)->flush;
 132 }
 133
 134 sub prompt ($;$) {
 135     my($mess,$def)=@_;
 136     $ISA_TTY = -t STDIN && (-t STDOUT || !(-f STDOUT || -c STDOUT)) ;   # Pipe?
 137     Carp::confess("prompt function called without an argument") unless defined $mess;
 138     my $dispdef = defined $def ? "[$def] " : " ";
 139     $def = defined $def ? $def : "";
 140     my $ans;
 141     local $|=1;
 142     print "$mess $dispdef";
 143     if ($ISA_TTY && !$ENV{PERL_MM_USE_DEFAULT}) {
 144         chomp($ans = <STDIN>);
 145     } else {
 146         print "$def\n";
 147     }
 148     return ($ans ne '') ? $ans : $def;
 149 }
 150
 151 sub eval_in_subdirs {
 152     my($self) = @_;
 153     use Cwd qw(cwd abs_path);
 154     my $pwd = cwd();
 155     local @INC = map eval {abs_path($_) if -e} || $_, @INC;
 156
 157     foreach my $dir (@{$self->{DIR}}){
 158         my($abs) = $self->catdir($pwd,$dir);
 159         $self->eval_in_x($abs);
 160     }
 161     chdir $pwd;
 162 }
 163
 164 sub eval_in_x {
 165     my($self,$dir) = @_;
 166     package main;
 167     chdir $dir or Carp::carp("Couldn't change to directory $dir: $!");
 168
 169     eval { do './Makefile.PL' };
 170     if ($@) {
 171 #         if ($@ =~ /prerequisites/) {
 172 #             die "MakeMaker WARNING: $@";
 173 #         } else {
 174 #             warn "WARNING from evaluation of $dir/Makefile.PL: $@";
 175 #         }
 176         warn "WARNING from evaluation of $dir/Makefile.PL: $@";
 177     }
 178 }
 179
 180 sub full_setup {
 181     $Verbose ||= 0;
 182
 183     # package name for the classes into which the first object will be blessed
 184     $PACKNAME = "PACK000";
 185
 186     my @attrib_help = qw/
 187
 188     AUTHOR ABSTRACT ABSTRACT_FROM BINARY_LOCATION
 189     C CAPI CCFLAGS CONFIG CONFIGURE DEFINE DIR DISTNAME DL_FUNCS DL_VARS
 190     EXCLUDE_EXT EXE_FILES FIRST_MAKEFILE FULLPERL FUNCLIST H
 191     HTMLLIBPODS HTMLSCRIPTPODS IMPORTS
 192     INC INCLUDE_EXT INSTALLARCHLIB INSTALLBIN INSTALLDIRS INSTALLHTMLPRIVLIBDIR
 193     INSTALLHTMLSCRIPTDIR INSTALLHTMLSITELIBDIR INSTALLMAN1DIR
 194     INSTALLMAN3DIR INSTALLPRIVLIB INSTALLSCRIPT INSTALLSITEARCH
 195     INSTALLSITELIB INST_ARCHLIB INST_BIN INST_EXE INST_LIB
 196     INST_HTMLLIBDIR INST_HTMLSCRIPTDIR
 197     INST_MAN1DIR INST_MAN3DIR INST_SCRIPT LDFROM LIB LIBPERL_A LIBS
 198     LINKTYPE MAKEAPERL MAKEFILE MAN1PODS MAN3PODS MAP_TARGET MYEXTLIB
 199     PERL_MALLOC_OK
 200     NAME NEEDS_LINKING NOECHO NORECURS NO_VC OBJECT OPTIMIZE PERL PERLMAINCC
 201     PERLRUN PERLRUNINST PERL_ARCHLIB PERL_CORE
 202     PERL_LIB PERL_SRC PERM_RW PERM_RWX
 203     PL_FILES PM PM_FILTER PMLIBDIRS POLLUTE PPM_INSTALL_EXEC
 204     PPM_INSTALL_SCRIPT PREFIX
 205     PREREQ_FATAL PREREQ_PM PREREQ_PRINT PRINT_PREREQ
 206     SKIP TEST_LIBS TYPEMAPS VERSION VERSION_FROM XS XSOPT XSPROTOARG
 207     XS_VERSION clean depend dist dynamic_lib linkext macro realclean
 208     tool_autosplit
 209     MACPERL_SRC MACPERL_LIB MACLIBS_68K MACLIBS_PPC MACLIBS_SC MACLIBS_MRC
 210     MACLIBS_ALL_68K MACLIBS_ALL_PPC MACLIBS_SHARED
 211         /;
 212
 213     # IMPORTS is used under OS/2 and Win32
 214
 215     # @Overridable is close to @MM_Sections but not identical.  The
 216     # order is important. Many subroutines declare macros. These
 217     # depend on each other. Let's try to collect the macros up front,
 218     # then pasthru, then the rules.
 219
 220     # MM_Sections are the sections we have to call explicitly
 221     # in Overridable we have subroutines that are used indirectly
 222
 223
 224     @MM_Sections =
 225         qw(
 226
 227  post_initialize const_config constants tool_autosplit tool_xsubpp
 228  tools_other dist macro depend cflags const_loadlibs const_cccmd
 229  post_constants
 230
 231  pasthru
 232
 233  c_o xs_c xs_o top_targets linkext dlsyms dynamic dynamic_bs
 234  dynamic_lib static static_lib htmlifypods manifypods processPL
 235  installbin subdirs
 236  clean realclean dist_basics dist_core dist_dir dist_test dist_ci
 237  install force perldepend makefile staticmake test ppd
 238
 239           ); # loses section ordering
 240
 241     @Overridable = @MM_Sections;
 242     push @Overridable, qw[
 243
 244  dir_target libscan makeaperl needs_linking perm_rw perm_rwx
 245  subdir_x test_via_harness test_via_script
 246                          ];
 247
 248     push @MM_Sections, qw[
 249
 250  pm_to_blib selfdocument
 251
 252                          ];
 253
 254     # Postamble needs to be the last that was always the case
 255     push @MM_Sections, "postamble";
 256     push @Overridable, "postamble";
 257
 258     # All sections are valid keys.
 259     @Recognized_Att_Keys{@MM_Sections} = (1) x @MM_Sections;
 260
 261     # we will use all these variables in the Makefile
 262     @Get_from_Config =
 263         qw(
 264            ar cc cccdlflags ccdlflags dlext dlsrc ld lddlflags ldflags libc
 265            lib_ext obj_ext osname osvers ranlib sitelibexp sitearchexp so
 266            exe_ext full_ar
 267           );
 268
 269     foreach my $item (@attrib_help){
 270         $Recognized_Att_Keys{$item} = 1;
 271     }
 272     foreach my $item (@Get_from_Config) {
 273         $Recognized_Att_Keys{uc $item} = $Config{$item};
 274         print "Attribute '\U$item\E' => '$Config{$item}'\n"
 275             if ($Verbose >= 2);
 276     }
 277
 278     #
 279     # When we eval a Makefile.PL in a subdirectory, that one will ask
 280     # us (the parent) for the values and will prepend "..", so that
 281     # all files to be installed end up below OUR ./blib
 282     #
 283     %Prepend_dot_dot =
 284         qw(
 285
 286            INST_BIN 1 INST_EXE 1 INST_LIB 1 INST_ARCHLIB 1 INST_SCRIPT 1
 287            MAP_TARGET 1 INST_HTMLLIBDIR 1 INST_HTMLSCRIPTDIR 1
 288            INST_MAN1DIR 1 INST_MAN3DIR 1 PERL_SRC 1 PERL 1 FULLPERL 1
 289
 290           );
 291
 292     my @keep = qw/
 293         NEEDS_LINKING HAS_LINK_CODE
 294         /;
 295     @Keep_after_flush{@keep} = (1) x @keep;
 296 }
 297
 298 sub writeMakefile {
 299     die <<END;
 300
 301 The extension you are trying to build apparently is rather old and
 302 most probably outdated. We detect that from the fact, that a
 303 subroutine "writeMakefile" is called, and this subroutine is not
 304 supported anymore since about October 1994.
 305
 306 Please contact the author or look into CPAN (details about CPAN can be
 307 found in the FAQ and at http:/www.perl.com) for a more recent version
 308 of the extension. If you're really desperate, you can try to change
 309 the subroutine name from writeMakefile to WriteMakefile and rerun
 310 'perl Makefile.PL', but you're most probably left alone, when you do
 311 so.
 312
 313 The MakeMaker team
 314
 315 END
 316 }
 317
 318 sub ExtUtils::MakeMaker::new {
 319     my($class,$self) = @_;
 320     my($key);
 321
 322     if ("@ARGV" =~ /\bPREREQ_PRINT\b/) {
 323         require Data::Dumper;
 324         print Data::Dumper->Dump([$self->{PREREQ_PM}], [qw(PREREQ_PM)]);
 325    }
 326
 327     # PRINT_PREREQ is RedHatism.
 328     if ("@ARGV" =~ /\bPRINT_PREREQ\b/) {
 329         print join(" ", map { "perl($_)>=$self->{PREREQ_PM}->{$_} " } sort keys %{$self->{PREREQ_PM}}), "\n";
 330         exit 0;
 331    }
 332
 333     print STDOUT "MakeMaker (v$VERSION)\n" if $Verbose;
 334     if (-f "MANIFEST" && ! -f "Makefile"){
 335         check_manifest();
 336     }
 337
 338     $self = {} unless (defined $self);
 339
 340     check_hints($self);
 341
 342     my %configure_att;         # record &{$self->{CONFIGURE}} attributes
 343     my(%initial_att) = %$self; # record initial attributes
 344
 345     my(%unsatisfied) = ();
 346     foreach my $prereq (sort keys %{$self->{PREREQ_PM}}) {
 347         eval "require $prereq";
 348
 349         if ($@) {
 350             warn "Warning: prerequisite $prereq $self->{PREREQ_PM}->{$prereq} not found.\n" unless $self->{PREREQ_FATAL};
 351             $unsatisfied{$prereq} = 'not installed';
 352         } elsif ($prereq->VERSION < $self->{PREREQ_PM}->{$prereq} ){
 353             warn "Warning: prerequisite $prereq $self->{PREREQ_PM}->{$prereq} not found. We have "
 354                . ($prereq->VERSION || 'unknown version') unless $self->{PREREQ_FATAL};
 355             $unsatisfied{$prereq} = $self->{PREREQ_PM}->{$prereq} ? $self->{PREREQ_PM}->{$prereq} : 'unknown version' ;
 356         }
 357     }
 358     if (%unsatisfied && $self->{PREREQ_FATAL}){
 359 #         unless (defined $ExtUtils::MakeMaker::useCPAN) {
 360         my $failedprereqs = join ', ', map {"$_ $unsatisfied{$_}"} keys %unsatisfied;
 361         die qq{MakeMaker FATAL: prerequisites not found ($failedprereqs)
 362                  Please install these modules first and rerun 'perl Makefile.PL'.\n};
 363 #             if ($ExtUtils::MakeMaker::hasCPAN) {
 364 #                 $ExtUtils::MakeMaker::useCPAN = prompt(qq{Should I try to use the CPAN module to fetch them for you?},"yes");
 365 #             } else {
 366 #                 print qq{Hint: You may want to install the CPAN module to autofetch the needed modules\n};
 367 #                 $ExtUtils::MakeMaker::useCPAN=0;
 368 #             }
 369 #         }
 370 #         if ($ExtUtils::MakeMaker::useCPAN) {
 371 #             require CPAN;
 372 #             CPAN->import(@unsatisfied);
 373 #         } else {
 374 #             die qq{prerequisites not found (@unsatisfied)};
 375 #         }
 376 #       warn qq{WARNING: prerequisites not found (@unsatisfied)};
 377     }
 378
 379     if (defined $self->{CONFIGURE}) {
 380         if (ref $self->{CONFIGURE} eq 'CODE') {
 381             %configure_att = %{&{$self->{CONFIGURE}}};
 382             $self = { %$self, %configure_att };
 383         } else {
 384             Carp::croak "Attribute 'CONFIGURE' to WriteMakefile() not a code reference\n";
 385         }
 386     }
 387
 388     # This is for old Makefiles written pre 5.00, will go away
 389     if ( Carp::longmess("") =~ /runsubdirpl/s ){
 390         Carp::carp("WARNING: Please rerun 'perl Makefile.PL' to regenerate your Makefiles\n");
 391     }
 392
 393     my $newclass = ++$PACKNAME;
 394     local @Parent = @Parent;    # Protect against non-local exits
 395     {
 396         no strict 'refs';
 397         print "Blessing Object into class [$newclass]\n" if $Verbose>=2;
 398         mv_all_methods("MY",$newclass);
 399         bless $self, $newclass;
 400         push @Parent, $self;
 401         @{"$newclass\:\:ISA"} = 'MM';
 402     }
 403
 404     if (defined $Parent[-2]){
 405         $self->{PARENT} = $Parent[-2];
 406         my $key;
 407         for $key (keys %Prepend_dot_dot) {
 408             next unless defined $self->{PARENT}{$key};
 409             $self->{$key} = $self->{PARENT}{$key};
 410             unless ($^O eq 'VMS' && $key =~ /PERL$/) {
 411                 $self->{$key} = $self->catdir("..",$self->{$key})
 412                     unless $self->file_name_is_absolute($self->{$key});
 413             } else {
 414                 # PERL or FULLPERL will be a command verb or even a command with
 415                 # an argument instead of a full file specification under VMS.  So,
 416                 # don't turn the command into a filespec, but do add a level to the
 417                 # path of the argument if not already absolute.
 418
 419                 my @cmd = split /\s+/, $self->{$key};
 420                 $cmd[1] = $self->catfile('[-]',$cmd[1])
 421                     unless (scalar(@cmd) < 2 || $self->file_name_is_absolute($cmd[1]));
 422                 $self->{$key} = join(' ', @cmd);
 423             }
 424         }
 425         if ($self->{PARENT}) {
 426             $self->{PARENT}->{CHILDREN}->{$newclass} = $self;
 427             foreach my $opt (qw(POLLUTE PERL_CORE)) {
 428                 if (exists $self->{PARENT}->{$opt}
 429                     and not exists $self->{$opt})
 430                     {
 431                         # inherit, but only if already unspecified
 432                         $self->{$opt} = $self->{PARENT}->{$opt};
 433                     }
 434             }
 435         }
 436         my @fm = grep /^FIRST_MAKEFILE=/, @ARGV;
 437         parse_args($self,@fm) if @fm;
 438     } else {
 439         parse_args($self,split(' ', $ENV{PERL_MM_OPT} || ''),@ARGV);
 440     }
 441
 442     $self->{NAME} ||= $self->guess_name;
 443
 444     ($self->{NAME_SYM} = $self->{NAME}) =~ s/\W+/_/g;
 445
 446     $self->init_main();
 447
 448     if (! $self->{PERL_SRC} ) {
 449         my($pthinks) = $self->canonpath($INC{'Config.pm'});
 450         my($cthinks) = $self->catfile($Config{'archlibexp'},'Config.pm');
 451         $pthinks = VMS::Filespec::vmsify($pthinks) if $Is_VMS;
 452         if ($pthinks ne $cthinks &&
 453             !($Is_Win32 and lc($pthinks) eq lc($cthinks))) {
 454             print "Have $pthinks expected $cthinks\n";
 455             if ($Is_Win32) {
 456                 $pthinks =~ s![/\\]Config\.pm$!!i; $pthinks =~ s!.*[/\\]!!;
 457             }
 458             else {
 459                 $pthinks =~ s!/Config\.pm$!!; $pthinks =~ s!.*/!!;
 460             }
 461             print STDOUT <<END unless $self->{UNINSTALLED_PERL};
 462 Your perl and your Config.pm seem to have different ideas about the architecture
 463 they are running on.
 464 Perl thinks: [$pthinks]
 465 Config says: [$Config{archname}]
 466 This may or may not cause problems. Please check your installation of perl if you
 467 have problems building this extension.
 468 END
 469         }
 470     }
 471
 472     $self->init_dirscan();
 473     $self->init_others();
 474     my($argv) = neatvalue(\@ARGV);
 475     $argv =~ s/^\[/(/;
 476     $argv =~ s/\]$/)/;
 477
 478     push @{$self->{RESULT}}, <<END;
 479 # This Makefile is for the $self->{NAME} extension to perl.
 480 #
 481 # It was generated automatically by MakeMaker version
 482 # $VERSION (Revision: $Revision) from the contents of
 483 # Makefile.PL. Don't edit this file, edit Makefile.PL instead.
 484 #
 485 #       ANY CHANGES MADE HERE WILL BE LOST!
 486 #
 487 #   MakeMaker ARGV: $argv
 488 #
 489 #   MakeMaker Parameters:
 490 END
 491
 492     foreach my $key (sort keys %initial_att){
 493         my($v) = neatvalue($initial_att{$key});
 494         $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
 495         $v =~ tr/\n/ /s;
 496         push @{$self->{RESULT}}, "#     $key => $v";
 497     }
 498     undef %initial_att;        # free memory
 499
 500     if (defined $self->{CONFIGURE}) {
 501        push @{$self->{RESULT}}, <<END;
 502
 503 #   MakeMaker 'CONFIGURE' Parameters:
 504 END
 505         if (scalar(keys %configure_att) > 0) {
 506             foreach my $key (sort keys %configure_att){
 507                my($v) = neatvalue($configure_att{$key});
 508                $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
 509                $v =~ tr/\n/ /s;
 510                push @{$self->{RESULT}}, "#     $key => $v";
 511             }
 512         }
 513         else
 514         {
 515            push @{$self->{RESULT}}, "# no values returned";
 516         }
 517         undef %configure_att;  # free memory
 518     }
 519
 520     # turn the SKIP array into a SKIPHASH hash
 521     my (%skip,$skip);
 522     for $skip (@{$self->{SKIP} || []}) {
 523         $self->{SKIPHASH}{$skip} = 1;
 524     }
 525     delete $self->{SKIP}; # free memory
 526
 527     if ($self->{PARENT}) {
 528         for (qw/install dist dist_basics dist_core dist_dir dist_test dist_ci/) {
 529             $self->{SKIPHASH}{$_} = 1;
 530         }
 531     }
 532
 533     # We run all the subdirectories now. They don't have much to query
 534     # from the parent, but the parent has to query them: if they need linking!
 535     unless ($self->{NORECURS}) {
 536         $self->eval_in_subdirs if @{$self->{DIR}};
 537     }
 538
 539     foreach my $section ( @MM_Sections ){
 540         print "Processing Makefile '$section' section\n" if ($Verbose >= 2);
 541         my($skipit) = $self->skipcheck($section);
 542         if ($skipit){
 543             push @{$self->{RESULT}}, "\n# --- MakeMaker $section section $skipit.";
 544         } else {
 545             my(%a) = %{$self->{$section} || {}};
 546             push @{$self->{RESULT}}, "\n# --- MakeMaker $section section:";
 547             push @{$self->{RESULT}}, "# " . join ", ", %a if $Verbose && %a;
 548             push @{$self->{RESULT}}, $self->nicetext($self->$section( %a ));
 549         }
 550     }
 551
 552     push @{$self->{RESULT}}, "\n# End.";
 553
 554     $self;
 555 }
 556
 557 sub WriteEmptyMakefile {
 558     Carp::croak "WriteEmptyMakefile: Need even number of args" if @_ % 2;
 559     local $SIG{__WARN__} = \&warnhandler;
 560
 561     my %att = @_;
 562     my $self = MM->new(\%att);
 563     if (-f "$self->{MAKEFILE}.old") {
 564       chmod 0666, "$self->{MAKEFILE}.old";
 565       unlink "$self->{MAKEFILE}.old" or warn "unlink $self->{MAKEFILE}.old: $!";
 566     }
 567     rename $self->{MAKEFILE}, "$self->{MAKEFILE}.old"
 568       or warn "rename $self->{MAKEFILE} $self->{MAKEFILE}.old: $!"
 569         if -f $self->{MAKEFILE};
 570     open MF, '>', $self->{MAKEFILE} or die "open $self->{MAKEFILE} for write: $!";
 571     print MF <<'EOP';
 572 all:
 573
 574 clean:
 575
 576 install:
 577
 578 makemakerdflt:
 579
 580 test:
 581
 582 EOP
 583     close MF or die "close $self->{MAKEFILE} for write: $!";
 584 }
 585
 586 sub check_manifest {
 587     print STDOUT "Checking if your kit is complete...\n";
 588     require ExtUtils::Manifest;
 589     # avoid warning
 590     $ExtUtils::Manifest::Quiet = $ExtUtils::Manifest::Quiet = 1;
 591     my(@missed) = ExtUtils::Manifest::manicheck();
 592     if (@missed) {
 593         print STDOUT "Warning: the following files are missing in your kit:\n";
 594         print "\t", join "\n\t", @missed;
 595         print STDOUT "\n";
 596         print STDOUT "Please inform the author.\n";
 597     } else {
 598         print STDOUT "Looks good\n";
 599     }
 600 }
 601
 602 sub parse_args{
 603     my($self, @args) = @_;
 604     foreach (@args) {
 605         unless (m/(.*?)=(.*)/) {
 606             help(),exit 1 if m/^help$/;
 607             ++$Verbose if m/^verb/;
 608             next;
 609         }
 610         my($name, $value) = ($1, $2);
 611         if ($value =~ m/^~(\w+)?/) { # tilde with optional username
 612             $value =~ s [^~(\w*)]
 613                 [$1 ?
 614                  ((getpwnam($1))[7] || "~$1") :
 615                  (getpwuid($>))[7]
 616                  ]ex;
 617         }
 618         $self->{uc($name)} = $value;
 619     }
 620
 621     # catch old-style 'potential_libs' and inform user how to 'upgrade'
 622     if (defined $self->{potential_libs}){
 623         my($msg)="'potential_libs' => '$self->{potential_libs}' should be";
 624         if ($self->{potential_libs}){
 625             print STDOUT "$msg changed to:\n\t'LIBS' => ['$self->{potential_libs}']\n";
 626         } else {
 627             print STDOUT "$msg deleted.\n";
 628         }
 629         $self->{LIBS} = [$self->{potential_libs}];
 630         delete $self->{potential_libs};
 631     }
 632     # catch old-style 'ARMAYBE' and inform user how to 'upgrade'
 633     if (defined $self->{ARMAYBE}){
 634         my($armaybe) = $self->{ARMAYBE};
 635         print STDOUT "ARMAYBE => '$armaybe' should be changed to:\n",
 636                         "\t'dynamic_lib' => {ARMAYBE => '$armaybe'}\n";
 637         my(%dl) = %{$self->{dynamic_lib} || {}};
 638         $self->{dynamic_lib} = { %dl, ARMAYBE => $armaybe};
 639         delete $self->{ARMAYBE};
 640     }
 641     if (defined $self->{LDTARGET}){
 642         print STDOUT "LDTARGET should be changed to LDFROM\n";
 643         $self->{LDFROM} = $self->{LDTARGET};
 644         delete $self->{LDTARGET};
 645     }
 646     # Turn a DIR argument on the command line into an array
 647     if (defined $self->{DIR} && ref \$self->{DIR} eq 'SCALAR') {
 648         # So they can choose from the command line, which extensions they want
 649         # the grep enables them to have some colons too much in case they
 650         # have to build a list with the shell
 651         $self->{DIR} = [grep $_, split ":", $self->{DIR}];
 652     }
 653     # Turn a INCLUDE_EXT argument on the command line into an array
 654     if (defined $self->{INCLUDE_EXT} && ref \$self->{INCLUDE_EXT} eq 'SCALAR') {
 655         $self->{INCLUDE_EXT} = [grep $_, split '\s+', $self->{INCLUDE_EXT}];
 656     }
 657     # Turn a EXCLUDE_EXT argument on the command line into an array
 658     if (defined $self->{EXCLUDE_EXT} && ref \$self->{EXCLUDE_EXT} eq 'SCALAR') {
 659         $self->{EXCLUDE_EXT} = [grep $_, split '\s+', $self->{EXCLUDE_EXT}];
 660     }
 661
 662     foreach my $mmkey (sort keys %$self){
 663         print STDOUT "  $mmkey => ", neatvalue($self->{$mmkey}), "\n" if $Verbose;
 664         print STDOUT "'$mmkey' is not a known MakeMaker parameter name.\n"
 665             unless exists $Recognized_Att_Keys{$mmkey};
 666     }
 667     $| = 1 if $Verbose;
 668 }
 669
 670 sub check_hints {
 671     my($self) = @_;
 672     # We allow extension-specific hints files.
 673
 674     return unless -d "hints";
 675
 676     # First we look for the best hintsfile we have
 677     my($hint)="${^O}_$Config{osvers}";
 678     $hint =~ s/\./_/g;
 679     $hint =~ s/_$//;
 680     return unless $hint;
 681
 682     # Also try without trailing minor version numbers.
 683     while (1) {
 684         last if -f "hints/$hint.pl";      # found
 685     } continue {
 686         last unless $hint =~ s/_[^_]*$//; # nothing to cut off
 687     }
 688     my $hint_file = "hints/$hint.pl";
 689
 690     return unless -f $hint_file;    # really there
 691
 692     # execute the hintsfile:
 693     print STDERR "Processing hints file $hint_file\n";
 694     {
 695         local *HINT;
 696         open(HINT, $hint_file) || die "Can't open $hint_file: $!";
 697         eval join '', <HINT>;
 698         close HINT;
 699     }
 700     print STDERR $@ if $@;
 701 }
 702
 703 sub mv_all_methods {
 704     my($from,$to) = @_;
 705     no strict 'refs';
 706     my($symtab) = \%{"${from}::"};
 707
 708     # Here you see the *current* list of methods that are overridable
 709     # from Makefile.PL via MY:: subroutines. As of VERSION 5.07 I'm
 710     # still trying to reduce the list to some reasonable minimum --
 711     # because I want to make it easier for the user. A.K.
 712
 713     foreach my $method (@Overridable) {
 714
 715         # We cannot say "next" here. Nick might call MY->makeaperl
 716         # which isn't defined right now
 717
 718         # Above statement was written at 4.23 time when Tk-b8 was
 719         # around. As Tk-b9 only builds with 5.002something and MM 5 is
 720         # standard, we try to enable the next line again. It was
 721         # commented out until MM 5.23
 722
 723         next unless defined &{"${from}::$method"};
 724
 725         *{"${to}::$method"} = \&{"${from}::$method"};
 726
 727         # delete would do, if we were sure, nobody ever called
 728         # MY->makeaperl directly
 729
 730         # delete $symtab->{$method};
 731
 732         # If we delete a method, then it will be undefined and cannot
 733         # be called.  But as long as we have Makefile.PLs that rely on
 734         # %MY:: being intact, we have to fill the hole with an
 735         # inheriting method:
 736
 737         eval "package MY; sub $method { shift->SUPER::$method(\@_); }";
 738     }
 739
 740     # We have to clean out %INC also, because the current directory is
 741     # changed frequently and Graham Barr prefers to get his version
 742     # out of a History.pl file which is "required" so woudn't get
 743     # loaded again in another extension requiring a History.pl
 744
 745     # With perl5.002_01 the deletion of entries in %INC caused Tk-b11
 746     # to core dump in the middle of a require statement. The required
 747     # file was Tk/MMutil.pm.  The consequence is, we have to be
 748     # extremely careful when we try to give perl a reason to reload a
 749     # library with same name.  The workaround prefers to drop nothing
 750     # from %INC and teach the writers not to use such libraries.
 751
 752 #    my $inc;
 753 #    foreach $inc (keys %INC) {
 754 #       #warn "***$inc*** deleted";
 755 #       delete $INC{$inc};
 756 #    }
 757 }
 758
 759 sub skipcheck {
 760     my($self) = shift;
 761     my($section) = @_;
 762     if ($section eq 'dynamic') {
 763         print STDOUT "Warning (non-fatal): Target 'dynamic' depends on targets ",
 764         "in skipped section 'dynamic_bs'\n"
 765             if $self->{SKIPHASH}{dynamic_bs} && $Verbose;
 766         print STDOUT "Warning (non-fatal): Target 'dynamic' depends on targets ",
 767         "in skipped section 'dynamic_lib'\n"
 768             if $self->{SKIPHASH}{dynamic_lib} && $Verbose;
 769     }
 770     if ($section eq 'dynamic_lib') {
 771         print STDOUT "Warning (non-fatal): Target '\$(INST_DYNAMIC)' depends on ",
 772         "targets in skipped section 'dynamic_bs'\n"
 773             if $self->{SKIPHASH}{dynamic_bs} && $Verbose;
 774     }
 775     if ($section eq 'static') {
 776         print STDOUT "Warning (non-fatal): Target 'static' depends on targets ",
 777         "in skipped section 'static_lib'\n"
 778             if $self->{SKIPHASH}{static_lib} && $Verbose;
 779     }
 780     return 'skipped' if $self->{SKIPHASH}{$section};
 781     return '';
 782 }
 783
 784 sub flush {
 785     my $self = shift;
 786     my($chunk);
 787 #    use FileHandle ();
 788 #    my $fh = new FileHandle;
 789     local *FH;
 790     print STDOUT "Writing $self->{MAKEFILE} for $self->{NAME}\n";
 791
 792     unlink($self->{MAKEFILE}, "MakeMaker.tmp", $Is_VMS ? 'Descrip.MMS' : '');
 793 #    $fh->open(">MakeMaker.tmp") or die "Unable to open MakeMaker.tmp: $!";
 794     open(FH,">MakeMaker.tmp") or die "Unable to open MakeMaker.tmp: $!";
 795
 796     for $chunk (@{$self->{RESULT}}) {
 797 #       print $fh "$chunk\n";
 798         print FH "$chunk\n";
 799     }
 800
 801 #    $fh->close;
 802     close FH;
 803     my($finalname) = $self->{MAKEFILE};
 804     rename("MakeMaker.tmp", $finalname);
 805     chmod 0644, $finalname unless $Is_VMS;
 806
 807     if ($self->{PARENT}) {
 808         foreach (keys %$self) { # safe memory
 809             delete $self->{$_} unless $Keep_after_flush{$_};
 810         }
 811     }
 812
 813     system("$Config::Config{eunicefix} $finalname") unless $Config::Config{eunicefix} eq ":";
 814 }
 815
 816 # The following mkbootstrap() is only for installations that are calling
 817 # the pre-4.1 mkbootstrap() from their old Makefiles. This MakeMaker
 818 # writes Makefiles, that use ExtUtils::Mkbootstrap directly.
 819 sub mkbootstrap {
 820     die <<END;
 821 !!! Your Makefile has been built such a long time ago, !!!
 822 !!! that is unlikely to work with current MakeMaker.   !!!
 823 !!! Please rebuild your Makefile                       !!!
 824 END
 825 }
 826
 827 # Ditto for mksymlists() as of MakeMaker 5.17
 828 sub mksymlists {
 829     die <<END;
 830 !!! Your Makefile has been built such a long time ago, !!!
 831 !!! that is unlikely to work with current MakeMaker.   !!!
 832 !!! Please rebuild your Makefile                       !!!
 833 END
 834 }
 835
 836 sub neatvalue {
 837     my($v) = @_;
 838     return "undef" unless defined $v;
 839     my($t) = ref $v;
 840     return "q[$v]" unless $t;
 841     if ($t eq 'ARRAY') {
 842         my(@m, @neat);
 843         push @m, "[";
 844         foreach my $elem (@$v) {
 845             push @neat, "q[$elem]";
 846         }
 847         push @m, join ", ", @neat;
 848         push @m, "]";
 849         return join "", @m;
 850     }
 851     return "$v" unless $t eq 'HASH';
 852     my(@m, $key, $val);
 853     while (($key,$val) = each %$v){
 854         last unless defined $key; # cautious programming in case (undef,undef) is true
 855         push(@m,"$key=>".neatvalue($val)) ;
 856     }
 857     return "{ ".join(', ',@m)." }";
 858 }
 859
 860 sub selfdocument {
 861     my($self) = @_;
 862     my(@m);
 863     if ($Verbose){
 864         push @m, "\n# Full list of MakeMaker attribute values:";
 865         foreach my $key (sort keys %$self){
 866             next if $key eq 'RESULT' || $key =~ /^[A-Z][a-z]/;
 867             my($v) = neatvalue($self->{$key});
 868             $v =~ s/(CODE|HASH|ARRAY|SCALAR)\([\dxa-f]+\)/$1\(...\)/;
 869             $v =~ tr/\n/ /s;
 870             push @m, "# $key => $v";
 871         }
 872     }
 873     join "\n", @m;
 874 }
 875
 876 package ExtUtils::MakeMaker;
 877 1;
 878
 879 __END__
 880
 881 =head1 NAME
 882
 883 ExtUtils::MakeMaker - create an extension Makefile
 884
 885 =head1 SYNOPSIS
 886
 887 C<use ExtUtils::MakeMaker;>
 888
 889 C<WriteMakefile( ATTRIBUTE =E<gt> VALUE [, ...] );>
 890
 891 which is really
 892
 893 C<MM-E<gt>new(\%att)-E<gt>flush;>
 894
 895 =head1 DESCRIPTION
 896
 897 This utility is designed to write a Makefile for an extension module
 898 from a Makefile.PL. It is based on the Makefile.SH model provided by
 899 Andy Dougherty and the perl5-porters.
 900
 901 It splits the task of generating the Makefile into several subroutines
 902 that can be individually overridden.  Each subroutine returns the text
 903 it wishes to have written to the Makefile.
 904
 905 MakeMaker is object oriented. Each directory below the current
 906 directory that contains a Makefile.PL. Is treated as a separate
 907 object. This makes it possible to write an unlimited number of
 908 Makefiles with a single invocation of WriteMakefile().
 909
 910 =head2 How To Write A Makefile.PL
 911
 912 The short answer is: Don't.
 913
 914         Always begin with h2xs.
 915         Always begin with h2xs!
 916         ALWAYS BEGIN WITH H2XS!
 917
 918 even if you're not building around a header file, and even if you
 919 don't have an XS component.
 920
 921 Run h2xs(1) before you start thinking about writing a module. For so
 922 called pm-only modules that consist of C<*.pm> files only, h2xs has
 923 the C<-X> switch. This will generate dummy files of all kinds that are
 924 useful for the module developer.
 925
 926 The medium answer is:
 927
 928     use ExtUtils::MakeMaker;
 929     WriteMakefile( NAME => "Foo::Bar" );
 930
 931 The long answer is the rest of the manpage :-)
 932
 933 =head2 Default Makefile Behaviour
 934
 935 The generated Makefile enables the user of the extension to invoke
 936
 937   perl Makefile.PL # optionally "perl Makefile.PL verbose"
 938   make
 939   make test        # optionally set TEST_VERBOSE=1
 940   make install     # See below
 941
 942 The Makefile to be produced may be altered by adding arguments of the
 943 form C<KEY=VALUE>. E.g.
 944
 945   perl Makefile.PL PREFIX=/tmp/myperl5
 946
 947 Other interesting targets in the generated Makefile are
 948
 949   make config     # to check if the Makefile is up-to-date
 950   make clean      # delete local temp files (Makefile gets renamed)
 951   make realclean  # delete derived files (including ./blib)
 952   make ci         # check in all the files in the MANIFEST file
 953   make dist       # see below the Distribution Support section
 954
 955 =head2 make test
 956
 957 MakeMaker checks for the existence of a file named F<test.pl> in the
 958 current directory and if it exists it adds commands to the test target
 959 of the generated Makefile that will execute the script with the proper
 960 set of perl C<-I> options.
 961
 962 MakeMaker also checks for any files matching glob("t/*.t"). It will
 963 add commands to the test target of the generated Makefile that execute
 964 all matching files via the L<Test::Harness> module with the C<-I>
 965 switches set correctly.
 966
 967 =head2 make testdb
 968
 969 A useful variation of the above is the target C<testdb>. It runs the
 970 test under the Perl debugger (see L<perldebug>). If the file
 971 F<test.pl> exists in the current directory, it is used for the test.
 972
 973 If you want to debug some other testfile, set C<TEST_FILE> variable
 974 thusly:
 975
 976   make testdb TEST_FILE=t/mytest.t
 977
 978 By default the debugger is called using C<-d> option to perl. If you
 979 want to specify some other option, set C<TESTDB_SW> variable:
 980
 981   make testdb TESTDB_SW=-Dx
 982
 983 =head2 make install
 984
 985 make alone puts all relevant files into directories that are named by
 986 the macros INST_LIB, INST_ARCHLIB, INST_SCRIPT, INST_HTMLLIBDIR,
 987 INST_HTMLSCRIPTDIR, INST_MAN1DIR, and INST_MAN3DIR.  All these default
 988 to something below ./blib if you are I<not> building below the perl
 989 source directory. If you I<are> building below the perl source,
 990 INST_LIB and INST_ARCHLIB default to ../../lib, and INST_SCRIPT is not
 991 defined.
 992
 993 The I<install> target of the generated Makefile copies the files found
 994 below each of the INST_* directories to their INSTALL*
 995 counterparts. Which counterparts are chosen depends on the setting of
 996 INSTALLDIRS according to the following table:
 997
 998                                  INSTALLDIRS set to
 999                               perl                site
1000
1001     INST_ARCHLIB        INSTALLARCHLIB        INSTALLSITEARCH
1002     INST_LIB            INSTALLPRIVLIB        INSTALLSITELIB
1003     INST_HTMLLIBDIR     INSTALLHTMLPRIVLIBDIR INSTALLHTMLSITELIBDIR
1004     INST_HTMLSCRIPTDIR            INSTALLHTMLSCRIPTDIR
1005     INST_BIN                      INSTALLBIN
1006     INST_SCRIPT                   INSTALLSCRIPT
1007     INST_MAN1DIR                  INSTALLMAN1DIR
1008     INST_MAN3DIR                  INSTALLMAN3DIR
1009
1010 The INSTALL... macros in turn default to their %Config
1011 ($Config{installprivlib}, $Config{installarchlib}, etc.) counterparts.
1012
1013 You can check the values of these variables on your system with
1014
1015     perl '-V:install.*'
1016
1017 And to check the sequence in which the library directories are
1018 searched by perl, run
1019
1020     perl -le 'print join $/, @INC'
1021
1022
1023 =head2 PREFIX and LIB attribute
1024
1025 PREFIX and LIB can be used to set several INSTALL* attributes in one
1026 go. The quickest way to install a module in a non-standard place might
1027 be
1028
1029     perl Makefile.PL LIB=~/lib
1030
1031 This will install the module's architecture-independent files into
1032 ~/lib, the architecture-dependent files into ~/lib/$archname.
1033
1034 Another way to specify many INSTALL directories with a single
1035 parameter is PREFIX.
1036
1037     perl Makefile.PL PREFIX=~
1038
1039 This will replace the string specified by C<$Config{prefix}> in all
1040 C<$Config{install*}> values.
1041
1042 Note, that in both cases the tilde expansion is done by MakeMaker, not
1043 by perl by default, nor by make.
1044
1045 Conflicts between parameters LIB,
1046 PREFIX and the various INSTALL* arguments are resolved so that:
1047
1048 =over 4
1049
1050 =item *
1051
1052 setting LIB overrides any setting of INSTALLPRIVLIB, INSTALLARCHLIB,
1053 INSTALLSITELIB, INSTALLSITEARCH (and they are not affected by PREFIX);
1054
1055 =item *
1056
1057 without LIB, setting PREFIX replaces the initial C<$Config{prefix}>
1058 part of those INSTALL* arguments, even if the latter are explicitly
1059 set (but are set to still start with C<$Config{prefix}>).
1060
1061 =back
1062
1063 If the user has superuser privileges, and is not working on AFS
1064 or relatives, then the defaults for
1065 INSTALLPRIVLIB, INSTALLARCHLIB, INSTALLSCRIPT, etc. will be appropriate,
1066 and this incantation will be the best:
1067
1068     perl Makefile.PL; make; make test
1069     make install
1070
1071 make install per default writes some documentation of what has been
1072 done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This feature
1073 can be bypassed by calling make pure_install.
1074
1075 =head2 AFS users
1076
1077 will have to specify the installation directories as these most
1078 probably have changed since perl itself has been installed. They will
1079 have to do this by calling
1080
1081     perl Makefile.PL INSTALLSITELIB=/afs/here/today \
1082         INSTALLSCRIPT=/afs/there/now INSTALLMAN3DIR=/afs/for/manpages
1083     make
1084
1085 Be careful to repeat this procedure every time you recompile an
1086 extension, unless you are sure the AFS installation directories are
1087 still valid.
1088
1089 =head2 Static Linking of a new Perl Binary
1090
1091 An extension that is built with the above steps is ready to use on
1092 systems supporting dynamic loading. On systems that do not support
1093 dynamic loading, any newly created extension has to be linked together
1094 with the available resources. MakeMaker supports the linking process
1095 by creating appropriate targets in the Makefile whenever an extension
1096 is built. You can invoke the corresponding section of the makefile with
1097
1098     make perl
1099
1100 That produces a new perl binary in the current directory with all
1101 extensions linked in that can be found in INST_ARCHLIB, SITELIBEXP,
1102 and PERL_ARCHLIB. To do that, MakeMaker writes a new Makefile, on
1103 UNIX, this is called Makefile.aperl (may be system dependent). If you
1104 want to force the creation of a new perl, it is recommended, that you
1105 delete this Makefile.aperl, so the directories are searched-through
1106 for linkable libraries again.
1107
1108 The binary can be installed into the directory where perl normally
1109 resides on your machine with
1110
1111     make inst_perl
1112
1113 To produce a perl binary with a different name than C<perl>, either say
1114
1115     perl Makefile.PL MAP_TARGET=myperl
1116     make myperl
1117     make inst_perl
1118
1119 or say
1120
1121     perl Makefile.PL
1122     make myperl MAP_TARGET=myperl
1123     make inst_perl MAP_TARGET=myperl
1124
1125 In any case you will be prompted with the correct invocation of the
1126 C<inst_perl> target that installs the new binary into INSTALLBIN.
1127
1128 make inst_perl per default writes some documentation of what has been
1129 done into the file C<$(INSTALLARCHLIB)/perllocal.pod>. This
1130 can be bypassed by calling make pure_inst_perl.
1131
1132 Warning: the inst_perl: target will most probably overwrite your
1133 existing perl binary. Use with care!
1134
1135 Sometimes you might want to build a statically linked perl although
1136 your system supports dynamic loading. In this case you may explicitly
1137 set the linktype with the invocation of the Makefile.PL or make:
1138
1139     perl Makefile.PL LINKTYPE=static    # recommended
1140
1141 or
1142
1143     make LINKTYPE=static                # works on most systems
1144
1145 =head2 Determination of Perl Library and Installation Locations
1146
1147 MakeMaker needs to know, or to guess, where certain things are
1148 located.  Especially INST_LIB and INST_ARCHLIB (where to put the files
1149 during the make(1) run), PERL_LIB and PERL_ARCHLIB (where to read
1150 existing modules from), and PERL_INC (header files and C<libperl*.*>).
1151
1152 Extensions may be built either using the contents of the perl source
1153 directory tree or from the installed perl library. The recommended way
1154 is to build extensions after you have run 'make install' on perl
1155 itself. You can do that in any directory on your hard disk that is not
1156 below the perl source tree. The support for extensions below the ext
1157 directory of the perl distribution is only good for the standard
1158 extensions that come with perl.
1159
1160 If an extension is being built below the C<ext/> directory of the perl
1161 source then MakeMaker will set PERL_SRC automatically (e.g.,
1162 C<../..>).  If PERL_SRC is defined and the extension is recognized as
1163 a standard extension, then other variables default to the following:
1164
1165   PERL_INC     = PERL_SRC
1166   PERL_LIB     = PERL_SRC/lib
1167   PERL_ARCHLIB = PERL_SRC/lib
1168   INST_LIB     = PERL_LIB
1169   INST_ARCHLIB = PERL_ARCHLIB
1170
1171 If an extension is being built away from the perl source then MakeMaker
1172 will leave PERL_SRC undefined and default to using the installed copy
1173 of the perl library. The other variables default to the following:
1174
1175   PERL_INC     = $archlibexp/CORE
1176   PERL_LIB     = $privlibexp
1177   PERL_ARCHLIB = $archlibexp
1178   INST_LIB     = ./blib/lib
1179   INST_ARCHLIB = ./blib/arch
1180
1181 If perl has not yet been installed then PERL_SRC can be defined on the
1182 command line as shown in the previous section.
1183
1184
1185 =head2 Which architecture dependent directory?
1186
1187 If you don't want to keep the defaults for the INSTALL* macros,
1188 MakeMaker helps you to minimize the typing needed: the usual
1189 relationship between INSTALLPRIVLIB and INSTALLARCHLIB is determined
1190 by Configure at perl compilation time. MakeMaker supports the user who
1191 sets INSTALLPRIVLIB. If INSTALLPRIVLIB is set, but INSTALLARCHLIB not,
1192 then MakeMaker defaults the latter to be the same subdirectory of
1193 INSTALLPRIVLIB as Configure decided for the counterparts in %Config ,
1194 otherwise it defaults to INSTALLPRIVLIB. The same relationship holds
1195 for INSTALLSITELIB and INSTALLSITEARCH.
1196
1197 MakeMaker gives you much more freedom than needed to configure
1198 internal variables and get different results. It is worth to mention,
1199 that make(1) also lets you configure most of the variables that are
1200 used in the Makefile. But in the majority of situations this will not
1201 be necessary, and should only be done if the author of a package
1202 recommends it (or you know what you're doing).
1203
1204 =head2 Using Attributes and Parameters
1205
1206 The following attributes can be specified as arguments to WriteMakefile()
1207 or as NAME=VALUE pairs on the command line:
1208
1209 =over 2
1210
1211 =item ABSTRACT
1212
1213 One line description of the module. Will be included in PPD file.
1214
1215 =item ABSTRACT_FROM
1216
1217 Name of the file that contains the package description. MakeMaker looks
1218 for a line in the POD matching /^($package\s-\s)(.*)/. This is typically
1219 the first line in the "=head1 NAME" section. $2 becomes the abstract.
1220
1221 =item AUTHOR
1222
1223 String containing name (and email address) of package author(s). Is used
1224 in PPD (Perl Package Description) files for PPM (Perl Package Manager).
1225
1226 =item BINARY_LOCATION
1227
1228 Used when creating PPD files for binary packages.  It can be set to a
1229 full or relative path or URL to the binary archive for a particular
1230 architecture.  For example:
1231
1232         perl Makefile.PL BINARY_LOCATION=x86/Agent.tar.gz
1233
1234 builds a PPD package that references a binary of the C<Agent> package,
1235 located in the C<x86> directory relative to the PPD itself.
1236
1237 =item C
1238
1239 Ref to array of *.c file names. Initialised from a directory scan
1240 and the values portion of the XS attribute hash. This is not
1241 currently used by MakeMaker but may be handy in Makefile.PLs.
1242
1243 =item CCFLAGS
1244
1245 String that will be included in the compiler call command line between
1246 the arguments INC and OPTIMIZE.
1247
1248 =item CONFIG
1249
1250 Arrayref. E.g. [qw(archname manext)] defines ARCHNAME & MANEXT from
1251 config.sh. MakeMaker will add to CONFIG the following values anyway:
1252 ar
1253 cc
1254 cccdlflags
1255 ccdlflags
1256 dlext
1257 dlsrc
1258 ld
1259 lddlflags
1260 ldflags
1261 libc
1262 lib_ext
1263 obj_ext
1264 ranlib
1265 sitelibexp
1266 sitearchexp
1267 so
1268
1269 =item CONFIGURE
1270
1271 CODE reference. The subroutine should return a hash reference. The
1272 hash may contain further attributes, e.g. {LIBS =E<gt> ...}, that have to
1273 be determined by some evaluation method.
1274
1275 =item DEFINE
1276
1277 Something like C<"-DHAVE_UNISTD_H">
1278
1279 =item DIR
1280
1281 Ref to array of subdirectories containing Makefile.PLs e.g. [ 'sdbm'
1282 ] in ext/SDBM_File
1283
1284 =item DISTNAME
1285
1286 Your name for distributing the package (by tar file). This defaults to
1287 NAME above.
1288
1289 =item DL_FUNCS
1290
1291 Hashref of symbol names for routines to be made available as universal
1292 symbols.  Each key/value pair consists of the package name and an
1293 array of routine names in that package.  Used only under AIX, OS/2,
1294 VMS and Win32 at present.  The routine names supplied will be expanded
1295 in the same way as XSUB names are expanded by the XS() macro.
1296 Defaults to
1297
1298   {"$(NAME)" => ["boot_$(NAME)" ] }
1299
1300 e.g.
1301
1302   {"RPC" => [qw( boot_rpcb rpcb_gettime getnetconfigent )],
1303    "NetconfigPtr" => [ 'DESTROY'] }
1304
1305 Please see the L<ExtUtils::Mksymlists> documentation for more information
1306 about the DL_FUNCS, DL_VARS and FUNCLIST attributes.
1307
1308 =item DL_VARS
1309
1310 Array of symbol names for variables to be made available as universal symbols.
1311 Used only under AIX, OS/2, VMS and Win32 at present.  Defaults to [].
1312 (e.g. [ qw(Foo_version Foo_numstreams Foo_tree ) ])
1313
1314 =item EXCLUDE_EXT
1315
1316 Array of extension names to exclude when doing a static build.  This
1317 is ignored if INCLUDE_EXT is present.  Consult INCLUDE_EXT for more
1318 details.  (e.g.  [ qw( Socket POSIX ) ] )
1319
1320 This attribute may be most useful when specified as a string on the
1321 command line:  perl Makefile.PL EXCLUDE_EXT='Socket Safe'
1322
1323 =item EXE_FILES
1324
1325 Ref to array of executable files. The files will be copied to the
1326 INST_SCRIPT directory. Make realclean will delete them from there
1327 again.
1328
1329 =item FIRST_MAKEFILE
1330
1331 The name of the Makefile to be produced. Defaults to the contents of
1332 MAKEFILE, but can be overridden. This is used for the second Makefile
1333 that will be produced for the MAP_TARGET.
1334
1335 =item FULLPERL
1336
1337 Perl binary able to run this extension.
1338
1339 =item FUNCLIST
1340
1341 This provides an alternate means to specify function names to be
1342 exported from the extension.  Its value is a reference to an
1343 array of function names to be exported by the extension.  These
1344 names are passed through unaltered to the linker options file.
1345
1346 =item H
1347
1348 Ref to array of *.h file names. Similar to C.
1349
1350 =item HTMLLIBPODS
1351
1352 Hashref of .pm and .pod files.  MakeMaker will default this to all
1353  .pod and any .pm files that include POD directives.  The files listed
1354 here will be converted to HTML format and installed as was requested
1355 at Configure time.
1356
1357 =item HTMLSCRIPTPODS
1358
1359 Hashref of pod-containing files.  MakeMaker will default this to all
1360 EXE_FILES files that include POD directives.  The files listed
1361 here will be converted to HTML format and installed as was requested
1362 at Configure time.
1363
1364 =item IMPORTS
1365
1366 This attribute is used to specify names to be imported into the
1367 extension. It is only used on OS/2 and Win32.
1368
1369 =item INC
1370
1371 Include file dirs eg: C<"-I/usr/5include -I/path/to/inc">
1372
1373 =item INCLUDE_EXT
1374
1375 Array of extension names to be included when doing a static build.
1376 MakeMaker will normally build with all of the installed extensions when
1377 doing a static build, and that is usually the desired behavior.  If
1378 INCLUDE_EXT is present then MakeMaker will build only with those extensions
1379 which are explicitly mentioned. (e.g.  [ qw( Socket POSIX ) ])
1380
1381 It is not necessary to mention DynaLoader or the current extension when
1382 filling in INCLUDE_EXT.  If the INCLUDE_EXT is mentioned but is empty then
1383 only DynaLoader and the current extension will be included in the build.
1384
1385 This attribute may be most useful when specified as a string on the
1386 command line:  perl Makefile.PL INCLUDE_EXT='POSIX Socket Devel::Peek'
1387
1388 =item INSTALLARCHLIB
1389
1390 Used by 'make install', which copies files from INST_ARCHLIB to this
1391 directory if INSTALLDIRS is set to perl.
1392
1393 =item INSTALLBIN
1394
1395 Directory to install binary files (e.g. tkperl) into.
1396
1397 =item INSTALLDIRS
1398
1399 Determines which of the two sets of installation directories to
1400 choose: installprivlib and installarchlib versus installsitelib and
1401 installsitearch. The first pair is chosen with INSTALLDIRS=perl, the
1402 second with INSTALLDIRS=site. Default is site.
1403
1404 =item INSTALLHTMLPRIVLIBDIR
1405
1406 This directory gets the HTML pages at 'make install' time. Defaults to
1407 $Config{installhtmlprivlibdir}.
1408
1409 =item INSTALLHTMLSCRIPTDIR
1410
1411 This directory gets the HTML pages at 'make install' time. Defaults to
1412 $Config{installhtmlscriptdir}.
1413
1414 =item INSTALLHTMLSITELIBDIR
1415
1416 This directory gets the HTML pages at 'make install' time. Defaults to
1417 $Config{installhtmlsitelibdir}.
1418
1419
1420 =item INSTALLMAN1DIR
1421
1422 This directory gets the man pages at 'make install' time. Defaults to
1423 $Config{installman1dir}.
1424
1425 =item INSTALLMAN3DIR
1426
1427 This directory gets the man pages at 'make install' time. Defaults to
1428 $Config{installman3dir}.
1429
1430 =item INSTALLPRIVLIB
1431
1432 Used by 'make install', which copies files from INST_LIB to this
1433 directory if INSTALLDIRS is set to perl.
1434
1435 =item INSTALLSCRIPT
1436
1437 Used by 'make install' which copies files from INST_SCRIPT to this
1438 directory.
1439
1440 =item INSTALLSITEARCH
1441
1442 Used by 'make install', which copies files from INST_ARCHLIB to this
1443 directory if INSTALLDIRS is set to site (default).
1444
1445 =item INSTALLSITELIB
1446
1447 Used by 'make install', which copies files from INST_LIB to this
1448 directory if INSTALLDIRS is set to site (default).
1449
1450 =item INST_ARCHLIB
1451
1452 Same as INST_LIB for architecture dependent files.
1453
1454 =item INST_BIN
1455
1456 Directory to put real binary files during 'make'. These will be copied
1457 to INSTALLBIN during 'make install'
1458
1459 =item INST_EXE
1460
1461 Old name for INST_SCRIPT. Deprecated. Please use INST_SCRIPT if you
1462 need to use it.
1463
1464 =item INST_HTMLLIBDIR
1465
1466 Directory to hold the man pages in HTML format at 'make' time
1467
1468 =item INST_HTMLSCRIPTDIR
1469
1470 Directory to hold the man pages in HTML format at 'make' time
1471
1472 =item INST_LIB
1473
1474 Directory where we put library files of this extension while building
1475 it.
1476
1477 =item INST_MAN1DIR
1478
1479 Directory to hold the man pages at 'make' time
1480
1481 =item INST_MAN3DIR
1482
1483 Directory to hold the man pages at 'make' time
1484
1485 =item INST_SCRIPT
1486
1487 Directory, where executable files should be installed during
1488 'make'. Defaults to "./blib/script", just to have a dummy location during
1489 testing. make install will copy the files in INST_SCRIPT to
1490 INSTALLSCRIPT.
1491
1492 =item LDFROM
1493
1494 defaults to "$(OBJECT)" and is used in the ld command to specify
1495 what files to link/load from (also see dynamic_lib below for how to
1496 specify ld flags)
1497
1498 =item LIB
1499
1500 LIB should only be set at C<perl Makefile.PL> time but is allowed as a
1501 MakeMaker argument. It has the effect of
1502 setting both INSTALLPRIVLIB and INSTALLSITELIB to that value regardless any
1503 explicit setting of those arguments (or of PREFIX).
1504 INSTALLARCHLIB and INSTALLSITEARCH are set to the corresponding
1505 architecture subdirectory.
1506
1507 =item LIBPERL_A
1508
1509 The filename of the perllibrary that will be used together with this
1510 extension. Defaults to libperl.a.
1511
1512 =item LIBS
1513
1514 An anonymous array of alternative library
1515 specifications to be searched for (in order) until
1516 at least one library is found. E.g.
1517
1518   'LIBS' => ["-lgdbm", "-ldbm -lfoo", "-L/path -ldbm.nfs"]
1519
1520 Mind, that any element of the array
1521 contains a complete set of arguments for the ld
1522 command. So do not specify
1523
1524   'LIBS' => ["-ltcl", "-ltk", "-lX11"]
1525
1526 See ODBM_File/Makefile.PL for an example, where an array is needed. If
1527 you specify a scalar as in
1528
1529   'LIBS' => "-ltcl -ltk -lX11"
1530
1531 MakeMaker will turn it into an array with one element.
1532
1533 =item LINKTYPE
1534
1535 'static' or 'dynamic' (default unless usedl=undef in
1536 config.sh). Should only be used to force static linking (also see
1537 linkext below).
1538
1539 =item MAKEAPERL
1540
1541 Boolean which tells MakeMaker, that it should include the rules to
1542 make a perl. This is handled automatically as a switch by
1543 MakeMaker. The user normally does not need it.
1544
1545 =item MAKEFILE
1546
1547 The name of the Makefile to be produced.
1548
1549 =item MAN1PODS
1550
1551 Hashref of pod-containing files. MakeMaker will default this to all
1552 EXE_FILES files that include POD directives. The files listed
1553 here will be converted to man pages and installed as was requested
1554 at Configure time.
1555
1556 =item MAN3PODS
1557
1558 Hashref that assigns to *.pm and *.pod files the files into which the
1559 manpages are to be written. MakeMaker parses all *.pod and *.pm files
1560 for POD directives. Files that contain POD will be the default keys of
1561 the MAN3PODS hashref. These will then be converted to man pages during
1562 C<make> and will be installed during C<make install>.
1563
1564 =item MAP_TARGET
1565
1566 If it is intended, that a new perl binary be produced, this variable
1567 may hold a name for that binary. Defaults to perl
1568
1569 =item MYEXTLIB
1570
1571 If the extension links to a library that it builds set this to the
1572 name of the library (see SDBM_File)
1573
1574 =item NAME
1575
1576 Perl module name for this extension (DBD::Oracle). This will default
1577 to the directory name but should be explicitly defined in the
1578 Makefile.PL.
1579
1580 =item NEEDS_LINKING
1581
1582 MakeMaker will figure out if an extension contains linkable code
1583 anywhere down the directory tree, and will set this variable
1584 accordingly, but you can speed it up a very little bit if you define
1585 this boolean variable yourself.
1586
1587 =item NOECHO
1588
1589 Defaults to C<@>. By setting it to an empty string you can generate a
1590 Makefile that echos all commands. Mainly used in debugging MakeMaker
1591 itself.
1592
1593 =item NORECURS
1594
1595 Boolean.  Attribute to inhibit descending into subdirectories.
1596
1597 =item NO_VC
1598
1599 In general, any generated Makefile checks for the current version of
1600 MakeMaker and the version the Makefile was built under. If NO_VC is
1601 set, the version check is neglected. Do not write this into your
1602 Makefile.PL, use it interactively instead.
1603
1604 =item OBJECT
1605
1606 List of object files, defaults to '$(BASEEXT)$(OBJ_EXT)', but can be a long
1607 string containing all object files, e.g. "tkpBind.o
1608 tkpButton.o tkpCanvas.o"
1609
1610 (Where BASEEXT is the last component of NAME, and OBJ_EXT is $Config{obj_ext}.)
1611
1612 =item OPTIMIZE
1613
1614 Defaults to C<-O>. Set it to C<-g> to turn debugging on. The flag is
1615 passed to subdirectory makes.
1616
1617 =item PERL
1618
1619 Perl binary for tasks that can be done by miniperl
1620
1621 =item PERL_CORE
1622
1623 Set only when MakeMaker is building the extensions of the Perl core
1624 distribution.
1625
1626 =item PERLMAINCC
1627
1628 The call to the program that is able to compile perlmain.c. Defaults
1629 to $(CC).
1630
1631 =item PERL_ARCHLIB
1632
1633 Same as for PERL_LIB, but for architecture dependent files.
1634
1635 Used only when MakeMaker is building the extensions of the Perl core
1636 distribution (because normally $(PERL_ARCHLIB) is automatically in @INC,
1637 and adding it would get in the way of PERL5LIB).
1638
1639 =item PERL_LIB
1640
1641 Directory containing the Perl library to use.
1642
1643 Used only when MakeMaker is building the extensions of the Perl core
1644 distribution (because normally $(PERL_LIB) is automatically in @INC,
1645 and adding it would get in the way of PERL5LIB).
1646
1647 =item PERL_MALLOC_OK
1648
1649 defaults to 0.  Should be set to TRUE if the extension can work with
1650 the memory allocation routines substituted by the Perl malloc() subsystem.
1651 This should be applicable to most extensions with exceptions of those
1652
1653 =over 4
1654
1655 =item *
1656
1657 with bugs in memory allocations which are caught by Perl's malloc();
1658
1659 =item *
1660
1661 which interact with the memory allocator in other ways than via
1662 malloc(), realloc(), free(), calloc(), sbrk() and brk();
1663
1664 =item *
1665
1666 which rely on special alignment which is not provided by Perl's malloc().
1667
1668 =back
1669
1670 B<NOTE.>  Negligence to set this flag in I<any one> of loaded extension
1671 nullifies many advantages of Perl's malloc(), such as better usage of
1672 system resources, error detection, memory usage reporting, catchable failure
1673 of memory allocations, etc.
1674
1675 =item PERLRUN
1676
1677 Use this instead of $(PERL) or $(FULLPERL) when you wish to run perl.
1678 It will set up extra necessary flags for you.
1679
1680 =item PERLRUNINST
1681
1682 Use this instead of $(PERL) or $(FULLPERL) when you wish to run
1683 perl to work with modules.  It will add things like -I$(INST_ARCH)
1684 and other necessary flags.
1685
1686 =item PERL_SRC
1687
1688 Directory containing the Perl source code (use of this should be
1689 avoided, it may be undefined)
1690
1691 =item PERM_RW
1692
1693 Desired permission for read/writable files. Defaults to C<644>.
1694 See also L<MM_Unix/perm_rw>.
1695
1696 =item PERM_RWX
1697
1698 Desired permission for executable files. Defaults to C<755>.
1699 See also L<MM_Unix/perm_rwx>.
1700
1701 =item PL_FILES
1702
1703 Ref to hash of files to be processed as perl programs. MakeMaker
1704 will default to any found *.PL file (except Makefile.PL) being keys
1705 and the basename of the file being the value. E.g.
1706
1707   {'foobar.PL' => 'foobar'}
1708
1709 The *.PL files are expected to produce output to the target files
1710 themselves. If multiple files can be generated from the same *.PL
1711 file then the value in the hash can be a reference to an array of
1712 target file names. E.g.
1713
1714   {'foobar.PL' => ['foobar1','foobar2']}
1715
1716 =item PM
1717
1718 Hashref of .pm files and *.pl files to be installed.  e.g.
1719
1720   {'name_of_file.pm' => '$(INST_LIBDIR)/install_as.pm'}
1721
1722 By default this will include *.pm and *.pl and the files found in
1723 the PMLIBDIRS directories.  Defining PM in the
1724 Makefile.PL will override PMLIBDIRS.
1725
1726 =item PMLIBDIRS
1727
1728 Ref to array of subdirectories containing library files.  Defaults to
1729 [ 'lib', $(BASEEXT) ]. The directories will be scanned and I<any> files
1730 they contain will be installed in the corresponding location in the
1731 library.  A libscan() method can be used to alter the behaviour.
1732 Defining PM in the Makefile.PL will override PMLIBDIRS.
1733
1734 (Where BASEEXT is the last component of NAME.)
1735
1736 =item PM_FILTER
1737
1738 A filter program, in the traditional Unix sense (input from stdin, output
1739 to stdout) that is passed on each .pm file during the build (in the
1740 pm_to_blib() phase).  It is empty by default, meaning no filtering is done.
1741
1742 Great care is necessary when defining the command if quoting needs to be
1743 done.  For instance, you would need to say:
1744
1745   {'PM_FILTER' => 'grep -v \\"^\\#\\"'}
1746
1747 to remove all the leading coments on the fly during the build.  The
1748 extra \\ are necessary, unfortunately, because this variable is interpolated
1749 within the context of a Perl program built on the command line, and double
1750 quotes are what is used with the -e switch to build that command line.  The
1751 # is escaped for the Makefile, since what is going to be generated will then
1752 be:
1753
1754   PM_FILTER = grep -v \"^\#\"
1755
1756 Without the \\ before the #, we'd have the start of a Makefile comment,
1757 and the macro would be incorrectly defined.
1758
1759 =item POLLUTE
1760
1761 Release 5.005 grandfathered old global symbol names by providing preprocessor
1762 macros for extension source compatibility.  As of release 5.6, these
1763 preprocessor definitions are not available by default.  The POLLUTE flag
1764 specifies that the old names should still be defined:
1765
1766   perl Makefile.PL POLLUTE=1
1767
1768 Please inform the module author if this is necessary to successfully install
1769 a module under 5.6 or later.
1770
1771 =item PPM_INSTALL_EXEC
1772
1773 Name of the executable used to run C<PPM_INSTALL_SCRIPT> below. (e.g. perl)
1774
1775 =item PPM_INSTALL_SCRIPT
1776
1777 Name of the script that gets executed by the Perl Package Manager after
1778 the installation of a package.
1779
1780 =item PREFIX
1781
1782 Can be used to set the three INSTALL* attributes in one go (except for
1783 probably INSTALLMAN1DIR, if it is not below PREFIX according to
1784 %Config).  They will have PREFIX as a common directory node and will
1785 branch from that node into lib/, lib/ARCHNAME or whatever Configure
1786 decided at the build time of your perl (unless you override one of
1787 them, of course).
1788
1789 =item PREREQ_PM
1790
1791 Hashref: Names of modules that need to be available to run this
1792 extension (e.g. Fcntl for SDBM_File) are the keys of the hash and the
1793 desired version is the value. If the required version number is 0, we
1794 only check if any version is installed already.
1795
1796 =item PREREQ_FATAL
1797
1798 Bool. If this parameter is true, failing to have the required modules
1799 (or the right versions thereof) will be fatal. perl Makefile.PL will die
1800 with the proper message.
1801
1802 Note: see L<Test::Harness> for a shortcut for stopping tests early if
1803 you are missing dependencies.
1804
1805 Do I<not> use this parameter for simple requirements, which could be resolved
1806 at a later time, e.g. after an unsuccessful B<make test> of your module.
1807
1808 It is I<extremely> rare to have to use C<PREREQ_FATAL> at all!
1809
1810 =item PREREQ_PRINT
1811
1812 Bool.  If this parameter is true, the prerequisites will be printed to
1813 stdout and MakeMaker will exit.  The output format is
1814
1815 $PREREQ_PM = {
1816                'A::B' => Vers1,
1817                'C::D' => Vers2,
1818                ...
1819              };
1820
1821 =item PRINT_PREREQ
1822
1823 RedHatism for C<PREREQ_PRINT>.  The output format is different, though:
1824
1825     perl(A::B)>=Vers1 perl(C::D)>=Vers2 ...
1826
1827 =item SKIP
1828
1829 Arrayref. E.g. [qw(name1 name2)] skip (do not write) sections of the
1830 Makefile. Caution! Do not use the SKIP attribute for the negligible
1831 speedup. It may seriously damage the resulting Makefile. Only use it
1832 if you really need it.
1833
1834 =item TEST_LIBS
1835
1836 The set of -I's necessary to run a "make test".  Use as:
1837 $(PERL) $(TEST_LIBS) -e '...' for example.
1838
1839 =item TYPEMAPS
1840
1841 Ref to array of typemap file names.  Use this when the typemaps are
1842 in some directory other than the current directory or when they are
1843 not named B<typemap>.  The last typemap in the list takes
1844 precedence.  A typemap in the current directory has highest
1845 precedence, even if it isn't listed in TYPEMAPS.  The default system
1846 typemap has lowest precedence.
1847
1848 =item VERSION
1849
1850 Your version number for distributing the package.  This defaults to
1851 0.1.
1852
1853 =item VERSION_FROM
1854
1855 Instead of specifying the VERSION in the Makefile.PL you can let
1856 MakeMaker parse a file to determine the version number. The parsing
1857 routine requires that the file named by VERSION_FROM contains one
1858 single line to compute the version number. The first line in the file
1859 that contains the regular expression
1860
1861     /([\$*])(([\w\:\']*)\bVERSION)\b.*\=/
1862
1863 will be evaluated with eval() and the value of the named variable
1864 B<after> the eval() will be assigned to the VERSION attribute of the
1865 MakeMaker object. The following lines will be parsed o.k.:
1866
1867     $VERSION = '1.00';
1868     *VERSION = \'1.01';
1869     ( $VERSION ) = '$Revision: 1.4 $ ' =~ /\$Revision:\s+([^\s]+)/;
1870     $FOO::VERSION = '1.10';
1871     *FOO::VERSION = \'1.11';
1872     our $VERSION = 1.2.3;       # new for perl5.6.0
1873
1874 but these will fail:
1875
1876     my $VERSION = '1.01';
1877     local $VERSION = '1.02';
1878     local $FOO::VERSION = '1.30';
1879
1880 (Putting C<my> or C<local> on the preceding line will work o.k.)
1881
1882 The file named in VERSION_FROM is not added as a dependency to
1883 Makefile. This is not really correct, but it would be a major pain
1884 during development to have to rewrite the Makefile for any smallish
1885 change in that file. If you want to make sure that the Makefile
1886 contains the correct VERSION macro after any change of the file, you
1887 would have to do something like
1888
1889     depend => { Makefile => '$(VERSION_FROM)' }
1890
1891 See attribute C<depend> below.
1892
1893 =item XS
1894
1895 Hashref of .xs files. MakeMaker will default this.  e.g.
1896
1897   {'name_of_file.xs' => 'name_of_file.c'}
1898
1899 The .c files will automatically be included in the list of files
1900 deleted by a make clean.
1901
1902 =item XSOPT
1903
1904 String of options to pass to xsubpp.  This might include C<-C++> or
1905 C<-extern>.  Do not include typemaps here; the TYPEMAP parameter exists for
1906 that purpose.
1907
1908 =item XSPROTOARG
1909
1910 May be set to an empty string, which is identical to C<-prototypes>, or
1911 C<-noprototypes>. See the xsubpp documentation for details. MakeMaker
1912 defaults to the empty string.
1913
1914 =item XS_VERSION
1915
1916 Your version number for the .xs file of this package.  This defaults
1917 to the value of the VERSION attribute.
1918
1919 =back
1920
1921 =head2 Additional lowercase attributes
1922
1923 can be used to pass parameters to the methods which implement that
1924 part of the Makefile.
1925
1926 =over 2
1927
1928 =item clean
1929
1930   {FILES => "*.xyz foo"}
1931
1932 =item depend
1933
1934   {ANY_TARGET => ANY_DEPENDECY, ...}
1935
1936 (ANY_TARGET must not be given a double-colon rule by MakeMaker.)
1937
1938 =item dist
1939
1940   {TARFLAGS => 'cvfF', COMPRESS => 'gzip', SUFFIX => '.gz',
1941   SHAR => 'shar -m', DIST_CP => 'ln', ZIP => '/bin/zip',
1942   ZIPFLAGS => '-rl', DIST_DEFAULT => 'private tardist' }
1943
1944 If you specify COMPRESS, then SUFFIX should also be altered, as it is
1945 needed to tell make the target file of the compression. Setting
1946 DIST_CP to ln can be useful, if you need to preserve the timestamps on
1947 your files. DIST_CP can take the values 'cp', which copies the file,
1948 'ln', which links the file, and 'best' which copies symbolic links and
1949 links the rest. Default is 'best'.
1950
1951 =item dynamic_lib
1952
1953   {ARMAYBE => 'ar', OTHERLDFLAGS => '...', INST_DYNAMIC_DEP => '...'}
1954
1955 =item linkext
1956
1957   {LINKTYPE => 'static', 'dynamic' or ''}
1958
1959 NB: Extensions that have nothing but *.pm files had to say
1960
1961   {LINKTYPE => ''}
1962
1963 with Pre-5.0 MakeMakers. Since version 5.00 of MakeMaker such a line
1964 can be deleted safely. MakeMaker recognizes when there's nothing to
1965 be linked.
1966
1967 =item macro
1968
1969   {ANY_MACRO => ANY_VALUE, ...}
1970
1971 =item realclean
1972
1973   {FILES => '$(INST_ARCHAUTODIR)/*.xyz'}
1974
1975 =item test
1976
1977   {TESTS => 't/*.t'}
1978
1979 =item tool_autosplit
1980
1981   {MAXLEN => 8}
1982
1983 =back
1984
1985 =head2 Overriding MakeMaker Methods
1986
1987 If you cannot achieve the desired Makefile behaviour by specifying
1988 attributes you may define private subroutines in the Makefile.PL.
1989 Each subroutines returns the text it wishes to have written to
1990 the Makefile. To override a section of the Makefile you can
1991 either say:
1992
1993         sub MY::c_o { "new literal text" }
1994
1995 or you can edit the default by saying something like:
1996
1997         sub MY::c_o {
1998             package MY; # so that "SUPER" works right
1999             my $inherited = shift->SUPER::c_o(@_);
2000             $inherited =~ s/old text/new text/;
2001             $inherited;
2002         }
2003
2004 If you are running experiments with embedding perl as a library into
2005 other applications, you might find MakeMaker is not sufficient. You'd
2006 better have a look at ExtUtils::Embed which is a collection of utilities
2007 for embedding.
2008
2009 If you still need a different solution, try to develop another
2010 subroutine that fits your needs and submit the diffs to
2011 F<perl5-porters@perl.org> or F<comp.lang.perl.moderated> as appropriate.
2012
2013 For a complete description of all MakeMaker methods see L<ExtUtils::MM_Unix>.
2014
2015 Here is a simple example of how to add a new target to the generated
2016 Makefile:
2017
2018     sub MY::postamble {
2019         '
2020     $(MYEXTLIB): sdbm/Makefile
2021             cd sdbm && $(MAKE) all
2022     ';
2023     }
2024
2025
2026 =head2 Hintsfile support
2027
2028 MakeMaker.pm uses the architecture specific information from
2029 Config.pm. In addition it evaluates architecture specific hints files
2030 in a C<hints/> directory. The hints files are expected to be named
2031 like their counterparts in C<PERL_SRC/hints>, but with an C<.pl> file
2032 name extension (eg. C<next_3_2.pl>). They are simply C<eval>ed by
2033 MakeMaker within the WriteMakefile() subroutine, and can be used to
2034 execute commands as well as to include special variables. The rules
2035 which hintsfile is chosen are the same as in Configure.
2036
2037 The hintsfile is eval()ed immediately after the arguments given to
2038 WriteMakefile are stuffed into a hash reference $self but before this
2039 reference becomes blessed. So if you want to do the equivalent to
2040 override or create an attribute you would say something like
2041
2042     $self->{LIBS} = ['-ldbm -lucb -lc'];
2043
2044 =head2 Distribution Support
2045
2046 For authors of extensions MakeMaker provides several Makefile
2047 targets. Most of the support comes from the ExtUtils::Manifest module,
2048 where additional documentation can be found.
2049
2050 =over 4
2051
2052 =item    make distcheck
2053
2054 reports which files are below the build directory but not in the
2055 MANIFEST file and vice versa. (See ExtUtils::Manifest::fullcheck() for
2056 details)
2057
2058 =item    make skipcheck
2059
2060 reports which files are skipped due to the entries in the
2061 C<MANIFEST.SKIP> file (See ExtUtils::Manifest::skipcheck() for
2062 details)
2063
2064 =item    make distclean
2065
2066 does a realclean first and then the distcheck. Note that this is not
2067 needed to build a new distribution as long as you are sure that the
2068 MANIFEST file is ok.
2069
2070 =item    make manifest
2071
2072 rewrites the MANIFEST file, adding all remaining files found (See
2073 ExtUtils::Manifest::mkmanifest() for details)
2074
2075 =item    make distdir
2076
2077 Copies all the files that are in the MANIFEST file to a newly created
2078 directory with the name C<$(DISTNAME)-$(VERSION)>. If that directory
2079 exists, it will be removed first.
2080
2081 =item   make disttest
2082
2083 Makes a distdir first, and runs a C<perl Makefile.PL>, a make, and
2084 a make test in that directory.
2085
2086 =item    make tardist
2087
2088 First does a distdir. Then a command $(PREOP) which defaults to a null
2089 command, followed by $(TOUNIX), which defaults to a null command under
2090 UNIX, and will convert files in distribution directory to UNIX format
2091 otherwise. Next it runs C<tar> on that directory into a tarfile and
2092 deletes the directory. Finishes with a command $(POSTOP) which
2093 defaults to a null command.
2094
2095 =item    make dist
2096
2097 Defaults to $(DIST_DEFAULT) which in turn defaults to tardist.
2098
2099 =item    make uutardist
2100
2101 Runs a tardist first and uuencodes the tarfile.
2102
2103 =item    make shdist
2104
2105 First does a distdir. Then a command $(PREOP) which defaults to a null
2106 command. Next it runs C<shar> on that directory into a sharfile and
2107 deletes the intermediate directory again. Finishes with a command
2108 $(POSTOP) which defaults to a null command.  Note: For shdist to work
2109 properly a C<shar> program that can handle directories is mandatory.
2110
2111 =item    make zipdist
2112
2113 First does a distdir. Then a command $(PREOP) which defaults to a null
2114 command. Runs C<$(ZIP) $(ZIPFLAGS)> on that directory into a
2115 zipfile. Then deletes that directory. Finishes with a command
2116 $(POSTOP) which defaults to a null command.
2117
2118 =item    make ci
2119
2120 Does a $(CI) and a $(RCS_LABEL) on all files in the MANIFEST file.
2121
2122 =back
2123
2124 Customization of the dist targets can be done by specifying a hash
2125 reference to the dist attribute of the WriteMakefile call. The
2126 following parameters are recognized:
2127
2128     CI           ('ci -u')
2129     COMPRESS     ('gzip --best')
2130     POSTOP       ('@ :')
2131     PREOP        ('@ :')
2132     TO_UNIX      (depends on the system)
2133     RCS_LABEL    ('rcs -q -Nv$(VERSION_SYM):')
2134     SHAR         ('shar')
2135     SUFFIX       ('.gz')
2136     TAR          ('tar')
2137     TARFLAGS     ('cvf')
2138     ZIP          ('zip')
2139     ZIPFLAGS     ('-r')
2140
2141 An example:
2142
2143     WriteMakefile( 'dist' => { COMPRESS=>"bzip2", SUFFIX=>".bz2" })
2144
2145 =head2 Disabling an extension
2146
2147 If some events detected in F<Makefile.PL> imply that there is no way
2148 to create the Module, but this is a normal state of things, then you
2149 can create a F<Makefile> which does nothing, but succeeds on all the
2150 "usual" build targets.  To do so, use
2151
2152    ExtUtils::MakeMaker::WriteEmptyMakefile();
2153
2154 instead of WriteMakefile().
2155
2156 This may be useful if other modules expect this module to be I<built>
2157 OK, as opposed to I<work> OK (say, this system-dependent module builds
2158 in a subdirectory of some other distribution, or is listed as a
2159 dependency in a CPAN::Bundle, but the functionality is supported by
2160 different means on the current architecture).
2161
2162 =head1 ENVIRONMENT
2163
2164 =over 8
2165
2166 =item PERL_MM_OPT
2167
2168 Command line options used by C<MakeMaker-E<gt>new()>, and thus by
2169 C<WriteMakefile()>.  The string is split on whitespace, and the result
2170 is processed before any actual command line arguments are processed.
2171
2172 =item PERL_MM_USE_DEFAULT
2173
2174 If set to a true value then MakeMaker's prompt function will
2175 always return the default without waiting for user input.
2176
2177 =back
2178
2179 =head1 SEE ALSO
2180
2181 ExtUtils::MM_Unix, ExtUtils::Manifest, ExtUtils::testlib,
2182 ExtUtils::Install, ExtUtils::Embed
2183
2184 =head1 AUTHORS
2185
2186 Andy Dougherty <F<doughera@lafcol.lafayette.edu>>, Andreas KE<ouml>nig
2187 <F<andreas.koenig@mind.de>>, Tim Bunce <F<Tim.Bunce@ig.co.uk>>.  VMS
2188 support by Charles Bailey <F<bailey@newman.upenn.edu>>.  OS/2 support
2189 by Ilya Zakharevich <F<ilya@math.ohio-state.edu>>.
2190
2191 Contact the MakeMaker mailing list <F<makemaker@perl.org>> if you have
2192 any questions.
2193
2194 Send patches and bug reports to <F<perlbug@perl.org>>.
2195
2196 =cut