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