lib/ExtUtils/MakeMaker.pm

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