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