Commit | Line | Data |
f6d6199c |
1 | package ExtUtils::MM_Any; |
2 | |
3 | use strict; |
4 | use vars qw($VERSION @ISA); |
002b9267 |
5 | $VERSION = '0.13_01'; |
f6d6199c |
6 | |
f6d6199c |
7 | use File::Spec; |
7292dc67 |
8 | BEGIN { @ISA = qw(File::Spec); } |
9 | |
10 | # We need $Verbose |
11 | use ExtUtils::MakeMaker qw($Verbose); |
12 | |
13 | use ExtUtils::MakeMaker::Config; |
14 | |
15 | |
16 | # So we don't have to keep calling the methods over and over again, |
17 | # we have these globals to cache the values. Faster and shrtr. |
18 | my $Curdir = __PACKAGE__->curdir; |
19 | my $Rootdir = __PACKAGE__->rootdir; |
20 | my $Updir = __PACKAGE__->updir; |
f6d6199c |
21 | |
22 | |
23 | =head1 NAME |
24 | |
30361541 |
25 | ExtUtils::MM_Any - Platform-agnostic MM methods |
f6d6199c |
26 | |
27 | =head1 SYNOPSIS |
28 | |
29 | FOR INTERNAL USE ONLY! |
30 | |
31 | package ExtUtils::MM_SomeOS; |
32 | |
33 | # Temporarily, you have to subclass both. Put MM_Any first. |
34 | require ExtUtils::MM_Any; |
35 | require ExtUtils::MM_Unix; |
36 | @ISA = qw(ExtUtils::MM_Any ExtUtils::Unix); |
37 | |
38 | =head1 DESCRIPTION |
39 | |
40 | B<FOR INTERNAL USE ONLY!> |
41 | |
42 | ExtUtils::MM_Any is a superclass for the ExtUtils::MM_* set of |
43 | modules. It contains methods which are either inherently |
44 | cross-platform or are written in a cross-platform manner. |
45 | |
46 | Subclass off of ExtUtils::MM_Any I<and> ExtUtils::MM_Unix. This is a |
47 | temporary solution. |
48 | |
49 | B<THIS MAY BE TEMPORARY!> |
50 | |
f6d6199c |
51 | |
7292dc67 |
52 | =head1 METHODS |
f6d6199c |
53 | |
7292dc67 |
54 | Any methods marked I<Abstract> must be implemented by subclasses. |
dedf98bc |
55 | |
5e719f03 |
56 | |
7292dc67 |
57 | =head2 Cross-platform helper methods |
5e719f03 |
58 | |
7292dc67 |
59 | These are methods which help writing cross-platform code. |
5e719f03 |
60 | |
5e719f03 |
61 | |
5e719f03 |
62 | |
7292dc67 |
63 | =head3 os_flavor I<Abstract> |
64 | |
65 | my @os_flavor = $mm->os_flavor; |
66 | |
67 | @os_flavor is the style of operating system this is, usually |
68 | corresponding to the MM_*.pm file we're using. |
69 | |
70 | The first element of @os_flavor is the major family (ie. Unix, |
71 | Windows, VMS, OS/2, etc...) and the rest are sub families. |
72 | |
73 | Some examples: |
74 | |
75 | Cygwin98 ('Unix', 'Cygwin', 'Cygwin9x') |
76 | Windows NT ('Win32', 'WinNT') |
77 | Win98 ('Win32', 'Win9x') |
78 | Linux ('Unix', 'Linux') |
79 | MacOS X ('Unix', 'Darwin', 'MacOS', 'MacOS X') |
80 | OS/2 ('OS/2') |
81 | |
82 | This is used to write code for styles of operating system. |
83 | See os_flavor_is() for use. |
84 | |
dedf98bc |
85 | |
7292dc67 |
86 | =head3 os_flavor_is |
87 | |
88 | my $is_this_flavor = $mm->os_flavor_is($this_flavor); |
89 | my $is_this_flavor = $mm->os_flavor_is(@one_of_these_flavors); |
dedf98bc |
90 | |
91 | Checks to see if the current operating system is one of the given flavors. |
92 | |
93 | This is useful for code like: |
94 | |
95 | if( $mm->os_flavor_is('Unix') ) { |
96 | $out = `foo 2>&1`; |
97 | } |
98 | else { |
99 | $out = `foo`; |
100 | } |
101 | |
102 | =cut |
103 | |
104 | sub os_flavor_is { |
105 | my $self = shift; |
106 | my %flavors = map { ($_ => 1) } $self->os_flavor; |
107 | return (grep { $flavors{$_} } @_) ? 1 : 0; |
108 | } |
109 | |
5dca256e |
110 | |
7292dc67 |
111 | =head3 split_command |
479d2113 |
112 | |
113 | my @cmds = $MM->split_command($cmd, @args); |
114 | |
115 | Most OS have a maximum command length they can execute at once. Large |
116 | modules can easily generate commands well past that limit. Its |
117 | necessary to split long commands up into a series of shorter commands. |
118 | |
7292dc67 |
119 | C<split_command> will return a series of @cmds each processing part of |
479d2113 |
120 | the args. Collectively they will process all the arguments. Each |
121 | individual line in @cmds will not be longer than the |
122 | $self->max_exec_len being careful to take into account macro expansion. |
123 | |
124 | $cmd should include any switches and repeated initial arguments. |
125 | |
126 | If no @args are given, no @cmds will be returned. |
127 | |
128 | Pairs of arguments will always be preserved in a single command, this |
129 | is a heuristic for things like pm_to_blib and pod2man which work on |
130 | pairs of arguments. This makes things like this safe: |
131 | |
132 | $self->split_command($cmd, %pod2man); |
133 | |
f6d6199c |
134 | |
135 | =cut |
136 | |
479d2113 |
137 | sub split_command { |
138 | my($self, $cmd, @args) = @_; |
139 | |
140 | my @cmds = (); |
141 | return(@cmds) unless @args; |
142 | |
143 | # If the command was given as a here-doc, there's probably a trailing |
144 | # newline. |
145 | chomp $cmd; |
146 | |
147 | # set aside 20% for macro expansion. |
148 | my $len_left = int($self->max_exec_len * 0.80); |
149 | $len_left -= length $self->_expand_macros($cmd); |
150 | |
151 | do { |
152 | my $arg_str = ''; |
153 | my @next_args; |
154 | while( @next_args = splice(@args, 0, 2) ) { |
155 | # Two at a time to preserve pairs. |
156 | my $next_arg_str = "\t ". join ' ', @next_args, "\n"; |
157 | |
158 | if( !length $arg_str ) { |
159 | $arg_str .= $next_arg_str |
160 | } |
161 | elsif( length($arg_str) + length($next_arg_str) > $len_left ) { |
162 | unshift @args, @next_args; |
163 | last; |
164 | } |
165 | else { |
166 | $arg_str .= $next_arg_str; |
167 | } |
168 | } |
169 | chop $arg_str; |
170 | |
a7d1454b |
171 | push @cmds, $self->escape_newlines("$cmd \n$arg_str"); |
479d2113 |
172 | } while @args; |
173 | |
174 | return @cmds; |
f6d6199c |
175 | } |
176 | |
479d2113 |
177 | |
178 | sub _expand_macros { |
179 | my($self, $cmd) = @_; |
180 | |
181 | $cmd =~ s{\$\((\w+)\)}{ |
182 | defined $self->{$1} ? $self->{$1} : "\$($1)" |
183 | }e; |
184 | return $cmd; |
185 | } |
186 | |
187 | |
7292dc67 |
188 | =head3 echo |
479d2113 |
189 | |
190 | my @commands = $MM->echo($text); |
191 | my @commands = $MM->echo($text, $file); |
192 | my @commands = $MM->echo($text, $file, $appending); |
193 | |
194 | Generates a set of @commands which print the $text to a $file. |
195 | |
196 | If $file is not given, output goes to STDOUT. |
197 | |
198 | If $appending is true the $file will be appended to rather than |
199 | overwritten. |
f6d6199c |
200 | |
201 | =cut |
202 | |
479d2113 |
203 | sub echo { |
204 | my($self, $text, $file, $appending) = @_; |
205 | $appending ||= 0; |
206 | |
207 | my @cmds = map { '$(NOECHO) $(ECHO) '.$self->quote_literal($_) } |
208 | split /\n/, $text; |
209 | if( $file ) { |
210 | my $redirect = $appending ? '>>' : '>'; |
211 | $cmds[0] .= " $redirect $file"; |
212 | $_ .= " >> $file" foreach @cmds[1..$#cmds]; |
213 | } |
214 | |
215 | return @cmds; |
f6d6199c |
216 | } |
217 | |
479d2113 |
218 | |
7292dc67 |
219 | =head3 wraplist |
479d2113 |
220 | |
7292dc67 |
221 | my $args = $mm->wraplist(@list); |
479d2113 |
222 | |
7292dc67 |
223 | Takes an array of items and turns them into a well-formatted list of |
224 | arguments. In most cases this is simply something like: |
479d2113 |
225 | |
7292dc67 |
226 | FOO \ |
227 | BAR \ |
228 | BAZ |
479d2113 |
229 | |
7292dc67 |
230 | =cut |
479d2113 |
231 | |
7292dc67 |
232 | sub wraplist { |
233 | my $self = shift; |
234 | return join " \\\n\t", @_; |
235 | } |
479d2113 |
236 | |
479d2113 |
237 | |
7292dc67 |
238 | =head3 cd I<Abstract> |
479d2113 |
239 | |
7292dc67 |
240 | my $subdir_cmd = $MM->cd($subdir, @cmds); |
479d2113 |
241 | |
7292dc67 |
242 | This will generate a make fragment which runs the @cmds in the given |
243 | $dir. The rough equivalent to this, except cross platform. |
479d2113 |
244 | |
7292dc67 |
245 | cd $subdir && $cmd |
479d2113 |
246 | |
7292dc67 |
247 | Currently $dir can only go down one level. "foo" is fine. "foo/bar" is |
248 | not. "../foo" is right out. |
479d2113 |
249 | |
7292dc67 |
250 | The resulting $subdir_cmd has no leading tab nor trailing newline. This |
251 | makes it easier to embed in a make string. For example. |
479d2113 |
252 | |
7292dc67 |
253 | my $make = sprintf <<'CODE', $subdir_cmd; |
254 | foo : |
255 | $(ECHO) what |
256 | %s |
257 | $(ECHO) mouche |
258 | CODE |
f6d6199c |
259 | |
f6d6199c |
260 | |
7292dc67 |
261 | =head3 oneliner I<Abstract> |
479d2113 |
262 | |
7292dc67 |
263 | my $oneliner = $MM->oneliner($perl_code); |
264 | my $oneliner = $MM->oneliner($perl_code, \@switches); |
479d2113 |
265 | |
7292dc67 |
266 | This will generate a perl one-liner safe for the particular platform |
267 | you're on based on the given $perl_code and @switches (a -e is |
268 | assumed) suitable for using in a make target. It will use the proper |
269 | shell quoting and escapes. |
479d2113 |
270 | |
7292dc67 |
271 | $(PERLRUN) will be used as perl. |
479d2113 |
272 | |
7292dc67 |
273 | Any newlines in $perl_code will be escaped. Leading and trailing |
274 | newlines will be stripped. Makes this idiom much easier: |
479d2113 |
275 | |
7292dc67 |
276 | my $code = $MM->oneliner(<<'CODE', [...switches...]); |
277 | some code here |
278 | another line here |
279 | CODE |
479d2113 |
280 | |
7292dc67 |
281 | Usage might be something like: |
479d2113 |
282 | |
7292dc67 |
283 | # an echo emulation |
284 | $oneliner = $MM->oneliner('print "Foo\n"'); |
285 | $make = '$oneliner > somefile'; |
479d2113 |
286 | |
7292dc67 |
287 | All dollar signs must be doubled in the $perl_code if you expect them |
288 | to be interpreted normally, otherwise it will be considered a make |
289 | macro. Also remember to quote make macros else it might be used as a |
290 | bareword. For example: |
479d2113 |
291 | |
7292dc67 |
292 | # Assign the value of the $(VERSION_FROM) make macro to $vf. |
293 | $oneliner = $MM->oneliner('$$vf = "$(VERSION_FROM)"'); |
f6d6199c |
294 | |
7292dc67 |
295 | Its currently very simple and may be expanded sometime in the figure |
296 | to include more flexible code and switches. |
479d2113 |
297 | |
479d2113 |
298 | |
7292dc67 |
299 | =head3 quote_literal I<Abstract> |
f6d6199c |
300 | |
7292dc67 |
301 | my $safe_text = $MM->quote_literal($text); |
f6d6199c |
302 | |
7292dc67 |
303 | This will quote $text so it is interpreted literally in the shell. |
f6d6199c |
304 | |
7292dc67 |
305 | For example, on Unix this would escape any single-quotes in $text and |
306 | put single-quotes around the whole thing. |
479d2113 |
307 | |
f6d6199c |
308 | |
7292dc67 |
309 | =head3 escape_newlines I<Abstract> |
f6d6199c |
310 | |
7292dc67 |
311 | my $escaped_text = $MM->escape_newlines($text); |
479d2113 |
312 | |
7292dc67 |
313 | Shell escapes newlines in $text. |
479d2113 |
314 | |
479d2113 |
315 | |
7292dc67 |
316 | =head3 max_exec_len I<Abstract> |
479d2113 |
317 | |
7292dc67 |
318 | my $max_exec_len = $MM->max_exec_len; |
479d2113 |
319 | |
7292dc67 |
320 | Calculates the maximum command size the OS can exec. Effectively, |
321 | this is the max size of a shell command line. |
479d2113 |
322 | |
7292dc67 |
323 | =for _private |
324 | $self->{_MAX_EXEC_LEN} is set by this method, but only for testing purposes. |
f6d6199c |
325 | |
479d2113 |
326 | |
479d2113 |
327 | |
479d2113 |
328 | |
f6d6199c |
329 | |
7292dc67 |
330 | =head2 Targets |
f6d6199c |
331 | |
7292dc67 |
332 | These are methods which produce make targets. |
479d2113 |
333 | |
479d2113 |
334 | |
7292dc67 |
335 | =head3 all_target |
479d2113 |
336 | |
7292dc67 |
337 | Generate the default target 'all'. |
479d2113 |
338 | |
7292dc67 |
339 | =cut |
479d2113 |
340 | |
7292dc67 |
341 | sub all_target { |
342 | my $self = shift; |
479d2113 |
343 | |
7292dc67 |
344 | return <<'MAKE_EXT'; |
345 | all :: pure_all |
346 | $(NOECHO) $(NOOP) |
347 | MAKE_EXT |
479d2113 |
348 | |
f6d6199c |
349 | } |
350 | |
479d2113 |
351 | |
7292dc67 |
352 | =head3 blibdirs_target |
479d2113 |
353 | |
7292dc67 |
354 | my $make_frag = $mm->blibdirs_target; |
479d2113 |
355 | |
7292dc67 |
356 | Creates the blibdirs target which creates all the directories we use |
357 | in blib/. |
f6d6199c |
358 | |
7292dc67 |
359 | The blibdirs.ts target is deprecated. Depend on blibdirs instead. |
f6d6199c |
360 | |
479d2113 |
361 | |
7292dc67 |
362 | =cut |
363 | |
364 | sub blibdirs_target { |
365 | my $self = shift; |
366 | |
367 | my @dirs = map { uc "\$(INST_$_)" } qw(libdir archlib |
368 | autodir archautodir |
369 | bin script |
370 | man1dir man3dir |
371 | ); |
f6d6199c |
372 | |
7292dc67 |
373 | my @exists = map { $_.'$(DFSEP).exists' } @dirs; |
479d2113 |
374 | |
7292dc67 |
375 | my $make = sprintf <<'MAKE', join(' ', @exists); |
376 | blibdirs : %s |
377 | $(NOECHO) $(NOOP) |
479d2113 |
378 | |
7292dc67 |
379 | # Backwards compat with 6.18 through 6.25 |
380 | blibdirs.ts : blibdirs |
381 | $(NOECHO) $(NOOP) |
479d2113 |
382 | |
7292dc67 |
383 | MAKE |
384 | |
385 | $make .= $self->dir_target(@dirs); |
386 | |
387 | return $make; |
388 | } |
389 | |
390 | |
391 | =head3 clean (o) |
392 | |
393 | Defines the clean target. |
f6d6199c |
394 | |
395 | =cut |
396 | |
7292dc67 |
397 | sub clean { |
398 | # --- Cleanup and Distribution Sections --- |
479d2113 |
399 | |
7292dc67 |
400 | my($self, %attribs) = @_; |
401 | my @m; |
402 | push(@m, ' |
403 | # Delete temporary files but do not touch installed files. We don\'t delete |
404 | # the Makefile here so a later make realclean still has a makefile to use. |
405 | |
406 | clean :: clean_subdirs |
407 | '); |
408 | |
409 | my @files = values %{$self->{XS}}; # .c files from *.xs files |
410 | my @dirs = qw(blib); |
411 | |
412 | # Normally these are all under blib but they might have been |
413 | # redefined. |
414 | # XXX normally this would be a good idea, but the Perl core sets |
415 | # INST_LIB = ../../lib rather than actually installing the files. |
416 | # So a "make clean" in an ext/ directory would blow away lib. |
417 | # Until the core is adjusted let's leave this out. |
418 | # push @dirs, qw($(INST_ARCHLIB) $(INST_LIB) |
419 | # $(INST_BIN) $(INST_SCRIPT) |
420 | # $(INST_MAN1DIR) $(INST_MAN3DIR) |
421 | # $(INST_LIBDIR) $(INST_ARCHLIBDIR) $(INST_AUTODIR) |
422 | # $(INST_STATIC) $(INST_DYNAMIC) $(INST_BOOT) |
423 | # ); |
424 | |
425 | |
426 | if( $attribs{FILES} ) { |
427 | # Use @dirs because we don't know what's in here. |
428 | push @dirs, ref $attribs{FILES} ? |
429 | @{$attribs{FILES}} : |
430 | split /\s+/, $attribs{FILES} ; |
431 | } |
479d2113 |
432 | |
7292dc67 |
433 | push(@files, qw[$(MAKE_APERL_FILE) |
434 | perlmain.c tmon.out mon.out so_locations |
435 | blibdirs.ts pm_to_blib pm_to_blib.ts |
436 | *$(OBJ_EXT) *$(LIB_EXT) perl.exe perl perl$(EXE_EXT) |
437 | $(BOOTSTRAP) $(BASEEXT).bso |
438 | $(BASEEXT).def lib$(BASEEXT).def |
439 | $(BASEEXT).exp $(BASEEXT).x |
440 | ]); |
479d2113 |
441 | |
7292dc67 |
442 | push(@files, $self->catfile('$(INST_ARCHAUTODIR)','extralibs.all')); |
443 | push(@files, $self->catfile('$(INST_ARCHAUTODIR)','extralibs.ld')); |
479d2113 |
444 | |
7292dc67 |
445 | # core files |
446 | push(@files, qw[core core.*perl.*.? *perl.core]); |
447 | push(@files, map { "core." . "[0-9]"x$_ } (1..5)); |
479d2113 |
448 | |
7292dc67 |
449 | # OS specific things to clean up. Use @dirs since we don't know |
450 | # what might be in here. |
451 | push @dirs, $self->extra_clean_files; |
f6d6199c |
452 | |
7292dc67 |
453 | # Occasionally files are repeated several times from different sources |
454 | { my(%f) = map { ($_ => 1) } @files; @files = keys %f; } |
455 | { my(%d) = map { ($_ => 1) } @dirs; @dirs = keys %d; } |
f6d6199c |
456 | |
7292dc67 |
457 | push @m, map "\t$_\n", $self->split_command('- $(RM_F)', @files); |
458 | push @m, map "\t$_\n", $self->split_command('- $(RM_RF)', @dirs); |
f6d6199c |
459 | |
7292dc67 |
460 | # Leave Makefile.old around for realclean |
461 | push @m, <<'MAKE'; |
462 | - $(MV) $(FIRST_MAKEFILE) $(MAKEFILE_OLD) $(DEV_NULL) |
463 | MAKE |
479d2113 |
464 | |
7292dc67 |
465 | push(@m, "\t$attribs{POSTOP}\n") if $attribs{POSTOP}; |
479d2113 |
466 | |
7292dc67 |
467 | join("", @m); |
468 | } |
469 | |
470 | |
471 | =head3 clean_subdirs_target |
472 | |
473 | my $make_frag = $MM->clean_subdirs_target; |
474 | |
475 | Returns the clean_subdirs target. This is used by the clean target to |
476 | call clean on any subdirectories which contain Makefiles. |
479d2113 |
477 | |
478 | =cut |
479 | |
7292dc67 |
480 | sub clean_subdirs_target { |
481 | my($self) = shift; |
479d2113 |
482 | |
7292dc67 |
483 | # No subdirectories, no cleaning. |
484 | return <<'NOOP_FRAG' unless @{$self->{DIR}}; |
485 | clean_subdirs : |
486 | $(NOECHO) $(NOOP) |
487 | NOOP_FRAG |
488 | |
489 | |
490 | my $clean = "clean_subdirs :\n"; |
491 | |
492 | for my $dir (@{$self->{DIR}}) { |
493 | my $subclean = $self->oneliner(sprintf <<'CODE', $dir); |
494 | chdir '%s'; system '$(MAKE) clean' if -f '$(FIRST_MAKEFILE)'; |
495 | CODE |
496 | |
497 | $clean .= "\t$subclean\n"; |
498 | } |
499 | |
500 | return $clean; |
479d2113 |
501 | } |
f6d6199c |
502 | |
f6d6199c |
503 | |
7292dc67 |
504 | =head3 dir_target |
f6d6199c |
505 | |
7292dc67 |
506 | my $make_frag = $mm->dir_target(@directories); |
f6d6199c |
507 | |
7292dc67 |
508 | Generates targets to create the specified directories and set its |
509 | permission to 0755. |
f6d6199c |
510 | |
7292dc67 |
511 | Because depending on a directory to just ensure it exists doesn't work |
512 | too well (the modified time changes too often) dir_target() creates a |
513 | .exists file in the created directory. It is this you should depend on. |
514 | For portability purposes you should use the $(DIRFILESEP) macro rather |
515 | than a '/' to seperate the directory from the file. |
516 | |
517 | yourdirectory$(DIRFILESEP).exists |
f6d6199c |
518 | |
519 | =cut |
520 | |
7292dc67 |
521 | sub dir_target { |
522 | my($self, @dirs) = @_; |
f6d6199c |
523 | |
7292dc67 |
524 | my $make = ''; |
525 | foreach my $dir (@dirs) { |
526 | $make .= sprintf <<'MAKE', ($dir) x 7; |
087dded7 |
527 | %s$(DFSEP).exists :: Makefile.PL |
7292dc67 |
528 | $(NOECHO) $(MKPATH) %s |
529 | $(NOECHO) $(CHMOD) 755 %s |
530 | $(NOECHO) $(TOUCH) %s$(DFSEP).exists |
f6d6199c |
531 | |
7292dc67 |
532 | MAKE |
f6d6199c |
533 | |
7292dc67 |
534 | } |
f6d6199c |
535 | |
7292dc67 |
536 | return $make; |
537 | } |
f6d6199c |
538 | |
7292dc67 |
539 | |
540 | =head3 distdir |
541 | |
542 | Defines the scratch directory target that will hold the distribution |
543 | before tar-ing (or shar-ing). |
f6d6199c |
544 | |
545 | =cut |
546 | |
7292dc67 |
547 | # For backwards compatibility. |
548 | *dist_dir = *distdir; |
f6d6199c |
549 | |
7292dc67 |
550 | sub distdir { |
551 | my($self) = shift; |
479d2113 |
552 | |
7292dc67 |
553 | my $meta_target = $self->{NO_META} ? '' : 'distmeta'; |
554 | my $sign_target = !$self->{SIGN} ? '' : 'distsignature'; |
479d2113 |
555 | |
7292dc67 |
556 | return sprintf <<'MAKE_FRAG', $meta_target, $sign_target; |
557 | create_distdir : |
558 | $(RM_RF) $(DISTVNAME) |
559 | $(PERLRUN) "-MExtUtils::Manifest=manicopy,maniread" \ |
560 | -e "manicopy(maniread(),'$(DISTVNAME)', '$(DIST_CP)');" |
479d2113 |
561 | |
7292dc67 |
562 | distdir : create_distdir %s %s |
563 | $(NOECHO) $(NOOP) |
564 | |
565 | MAKE_FRAG |
566 | |
567 | } |
568 | |
569 | |
570 | =head3 dist_test |
571 | |
572 | Defines a target that produces the distribution in the |
573 | scratchdirectory, and runs 'perl Makefile.PL; make ;make test' in that |
574 | subdirectory. |
479d2113 |
575 | |
576 | =cut |
577 | |
7292dc67 |
578 | sub dist_test { |
579 | my($self) = shift; |
580 | |
581 | my $mpl_args = join " ", map qq["$_"], @ARGV; |
582 | |
583 | my $test = $self->cd('$(DISTVNAME)', |
584 | '$(ABSPERLRUN) Makefile.PL '.$mpl_args, |
585 | '$(MAKE) $(PASTHRU)', |
586 | '$(MAKE) test $(PASTHRU)' |
587 | ); |
588 | |
589 | return sprintf <<'MAKE_FRAG', $test; |
590 | disttest : distdir |
591 | %s |
592 | |
593 | MAKE_FRAG |
594 | |
479d2113 |
595 | |
479d2113 |
596 | } |
597 | |
479d2113 |
598 | |
7292dc67 |
599 | =head3 dynamic (o) |
600 | |
601 | Defines the dynamic target. |
479d2113 |
602 | |
603 | =cut |
604 | |
7292dc67 |
605 | sub dynamic { |
606 | # --- Dynamic Loading Sections --- |
479d2113 |
607 | |
7292dc67 |
608 | my($self) = shift; |
609 | ' |
610 | dynamic :: $(FIRST_MAKEFILE) $(INST_DYNAMIC) $(INST_BOOT) |
611 | $(NOECHO) $(NOOP) |
612 | '; |
613 | } |
479d2113 |
614 | |
479d2113 |
615 | |
7292dc67 |
616 | =head3 makemakerdflt_target |
617 | |
618 | my $make_frag = $mm->makemakerdflt_target |
619 | |
620 | Returns a make fragment with the makemakerdeflt_target specified. |
621 | This target is the first target in the Makefile, is the default target |
622 | and simply points off to 'all' just in case any make variant gets |
623 | confused or something gets snuck in before the real 'all' target. |
479d2113 |
624 | |
7292dc67 |
625 | =cut |
626 | |
627 | sub makemakerdflt_target { |
628 | return <<'MAKE_FRAG'; |
629 | makemakerdflt: all |
630 | $(NOECHO) $(NOOP) |
479d2113 |
631 | MAKE_FRAG |
632 | |
633 | } |
634 | |
635 | |
7292dc67 |
636 | =head3 manifypods_target |
479d2113 |
637 | |
7292dc67 |
638 | my $manifypods_target = $self->manifypods_target; |
639 | |
640 | Generates the manifypods target. This target generates man pages from |
641 | all POD files in MAN1PODS and MAN3PODS. |
479d2113 |
642 | |
643 | =cut |
644 | |
7292dc67 |
645 | sub manifypods_target { |
646 | my($self) = shift; |
479d2113 |
647 | |
7292dc67 |
648 | my $man1pods = ''; |
649 | my $man3pods = ''; |
650 | my $dependencies = ''; |
651 | |
652 | # populate manXpods & dependencies: |
653 | foreach my $name (keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}}) { |
654 | $dependencies .= " \\\n\t$name"; |
655 | } |
656 | |
657 | foreach my $name (keys %{$self->{MAN3PODS}}) { |
658 | $dependencies .= " \\\n\t$name" |
659 | } |
660 | |
661 | my $manify = <<END; |
662 | manifypods : pure_all $dependencies |
663 | END |
664 | |
665 | my @man_cmds; |
666 | foreach my $section (qw(1 3)) { |
667 | my $pods = $self->{"MAN${section}PODS"}; |
668 | push @man_cmds, $self->split_command(<<CMD, %$pods); |
669 | \$(NOECHO) \$(POD2MAN) --section=$section --perm_rw=\$(PERM_RW) |
670 | CMD |
671 | } |
672 | |
673 | $manify .= "\t\$(NOECHO) \$(NOOP)\n" unless @man_cmds; |
674 | $manify .= join '', map { "$_\n" } @man_cmds; |
479d2113 |
675 | |
7292dc67 |
676 | return $manify; |
479d2113 |
677 | } |
678 | |
679 | |
7292dc67 |
680 | =head3 metafile_target |
479d2113 |
681 | |
682 | my $target = $mm->metafile_target; |
683 | |
684 | Generate the metafile target. |
685 | |
7292dc67 |
686 | Writes the file META.yml YAML encoded meta-data about the module in |
687 | the distdir. The format follows Module::Build's as closely as |
688 | possible. Additionally, we include: |
479d2113 |
689 | |
690 | version_from |
691 | installdirs |
692 | |
693 | =cut |
694 | |
695 | sub metafile_target { |
696 | my $self = shift; |
697 | |
431b0fc4 |
698 | return <<'MAKE_FRAG' if $self->{NO_META}; |
699 | metafile: |
700 | $(NOECHO) $(NOOP) |
701 | MAKE_FRAG |
702 | |
479d2113 |
703 | my $prereq_pm = ''; |
0fdc96ff |
704 | foreach my $mod ( sort { lc $a cmp lc $b } keys %{$self->{PREREQ_PM}} ) { |
705 | my $ver = $self->{PREREQ_PM}{$mod}; |
479d2113 |
706 | $prereq_pm .= sprintf " %-30s %s\n", "$mod:", $ver; |
707 | } |
a7d1454b |
708 | |
479d2113 |
709 | my $meta = <<YAML; |
64964e6d |
710 | # http://module-build.sourceforge.net/META-spec.html |
479d2113 |
711 | #XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX# |
712 | name: $self->{DISTNAME} |
713 | version: $self->{VERSION} |
714 | version_from: $self->{VERSION_FROM} |
715 | installdirs: $self->{INSTALLDIRS} |
716 | requires: |
717 | $prereq_pm |
718 | distribution_type: module |
719 | generated_by: ExtUtils::MakeMaker version $ExtUtils::MakeMaker::VERSION |
720 | YAML |
721 | |
a7d1454b |
722 | my @write_meta = $self->echo($meta, 'META_new.yml'); |
a7d1454b |
723 | |
7292dc67 |
724 | return sprintf <<'MAKE_FRAG', join("\n\t", @write_meta); |
725 | metafile : create_distdir |
a7d1454b |
726 | $(NOECHO) $(ECHO) Generating META.yml |
479d2113 |
727 | %s |
7292dc67 |
728 | -$(NOECHO) $(MV) META_new.yml $(DISTVNAME)/META.yml |
479d2113 |
729 | MAKE_FRAG |
730 | |
731 | } |
732 | |
733 | |
7292dc67 |
734 | =head3 distmeta_target |
bb68fe9e |
735 | |
7292dc67 |
736 | my $make_frag = $mm->distmeta_target; |
bb68fe9e |
737 | |
7292dc67 |
738 | Generates the distmeta target to add META.yml to the MANIFEST in the |
739 | distdir. |
bb68fe9e |
740 | |
741 | =cut |
742 | |
7292dc67 |
743 | sub distmeta_target { |
bb68fe9e |
744 | my $self = shift; |
745 | |
7292dc67 |
746 | my $add_meta = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']); |
747 | eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } |
748 | or print "Could not add META.yml to MANIFEST: $${'@'}\n" |
749 | CODE |
bb68fe9e |
750 | |
7292dc67 |
751 | my $add_meta_to_distdir = $self->cd('$(DISTVNAME)', $add_meta); |
bb68fe9e |
752 | |
7292dc67 |
753 | return sprintf <<'MAKE', $add_meta_to_distdir; |
754 | distmeta : create_distdir metafile |
755 | $(NOECHO) %s |
756 | |
757 | MAKE |
bb68fe9e |
758 | |
7292dc67 |
759 | } |
bb68fe9e |
760 | |
479d2113 |
761 | |
7292dc67 |
762 | =head3 realclean (o) |
479d2113 |
763 | |
7292dc67 |
764 | Defines the realclean target. |
479d2113 |
765 | |
766 | =cut |
767 | |
7292dc67 |
768 | sub realclean { |
769 | my($self, %attribs) = @_; |
479d2113 |
770 | |
7292dc67 |
771 | my @dirs = qw($(DISTVNAME)); |
772 | my @files = qw($(FIRST_MAKEFILE) $(MAKEFILE_OLD)); |
431b0fc4 |
773 | |
76ca89ed |
774 | # Special exception for the perl core where INST_* is not in blib. |
775 | # This cleans up the files built from the ext/ directory (all XS). |
776 | if( $self->{PERL_CORE} ) { |
7292dc67 |
777 | push @dirs, qw($(INST_AUTODIR) $(INST_ARCHAUTODIR)); |
76ca89ed |
778 | push @files, values %{$self->{PM}}; |
7292dc67 |
779 | } |
479d2113 |
780 | |
7292dc67 |
781 | if( $self->has_link_code ){ |
782 | push @files, qw($(OBJECT)); |
783 | } |
784 | |
785 | if( $attribs{FILES} ) { |
786 | if( ref $attribs{FILES} ) { |
787 | push @dirs, @{ $attribs{FILES} }; |
788 | } |
789 | else { |
790 | push @dirs, split /\s+/, $attribs{FILES}; |
791 | } |
792 | } |
793 | |
794 | # Occasionally files are repeated several times from different sources |
795 | { my(%f) = map { ($_ => 1) } @files; @files = keys %f; } |
796 | { my(%d) = map { ($_ => 1) } @dirs; @dirs = keys %d; } |
797 | |
798 | my $rm_cmd = join "\n\t", map { "$_" } |
799 | $self->split_command('- $(RM_F)', @files); |
800 | my $rmf_cmd = join "\n\t", map { "$_" } |
801 | $self->split_command('- $(RM_RF)', @dirs); |
802 | |
803 | my $m = sprintf <<'MAKE', $rm_cmd, $rmf_cmd; |
804 | # Delete temporary files (via clean) and also delete dist files |
805 | realclean purge :: clean realclean_subdirs |
806 | %s |
807 | %s |
808 | MAKE |
809 | |
810 | $m .= "\t$attribs{POSTOP}\n" if $attribs{POSTOP}; |
479d2113 |
811 | |
7292dc67 |
812 | return $m; |
479d2113 |
813 | } |
814 | |
815 | |
7292dc67 |
816 | =head3 realclean_subdirs_target |
bb68fe9e |
817 | |
7292dc67 |
818 | my $make_frag = $MM->realclean_subdirs_target; |
bb68fe9e |
819 | |
7292dc67 |
820 | Returns the realclean_subdirs target. This is used by the realclean |
821 | target to call realclean on any subdirectories which contain Makefiles. |
bb68fe9e |
822 | |
823 | =cut |
824 | |
7292dc67 |
825 | sub realclean_subdirs_target { |
bb68fe9e |
826 | my $self = shift; |
827 | |
7292dc67 |
828 | return <<'NOOP_FRAG' unless @{$self->{DIR}}; |
829 | realclean_subdirs : |
bb68fe9e |
830 | $(NOECHO) $(NOOP) |
7292dc67 |
831 | NOOP_FRAG |
bb68fe9e |
832 | |
7292dc67 |
833 | my $rclean = "realclean_subdirs :\n"; |
834 | |
835 | foreach my $dir (@{$self->{DIR}}) { |
836 | foreach my $makefile ('$(MAKEFILE_OLD)', '$(FIRST_MAKEFILE)' ) { |
837 | my $subrclean .= $self->oneliner(sprintf <<'CODE', $dir, ($makefile) x 2); |
838 | chdir '%s'; system '$(MAKE) $(USEMAKEFILE) %s realclean' if -f '%s'; |
bb68fe9e |
839 | CODE |
840 | |
7292dc67 |
841 | $rclean .= sprintf <<'RCLEAN', $subrclean; |
842 | - %s |
843 | RCLEAN |
bb68fe9e |
844 | |
7292dc67 |
845 | } |
846 | } |
bb68fe9e |
847 | |
7292dc67 |
848 | return $rclean; |
849 | } |
bb68fe9e |
850 | |
479d2113 |
851 | |
7292dc67 |
852 | =head3 signature_target |
479d2113 |
853 | |
7292dc67 |
854 | my $target = $mm->signature_target; |
479d2113 |
855 | |
7292dc67 |
856 | Generate the signature target. |
479d2113 |
857 | |
7292dc67 |
858 | Writes the file SIGNATURE with "cpansign -s". |
479d2113 |
859 | |
7292dc67 |
860 | =cut |
479d2113 |
861 | |
7292dc67 |
862 | sub signature_target { |
863 | my $self = shift; |
479d2113 |
864 | |
7292dc67 |
865 | return <<'MAKE_FRAG'; |
866 | signature : |
867 | cpansign -s |
868 | MAKE_FRAG |
479d2113 |
869 | |
7292dc67 |
870 | } |
479d2113 |
871 | |
7292dc67 |
872 | |
873 | =head3 distsignature_target |
874 | |
875 | my $make_frag = $mm->distsignature_target; |
876 | |
877 | Generates the distsignature target to add SIGNATURE to the MANIFEST in the |
878 | distdir. |
879 | |
880 | =cut |
881 | |
882 | sub distsignature_target { |
883 | my $self = shift; |
884 | |
885 | my $add_sign = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']); |
886 | eval { maniadd({q{SIGNATURE} => q{Public-key signature (added by MakeMaker)}}) } |
887 | or print "Could not add SIGNATURE to MANIFEST: $${'@'}\n" |
479d2113 |
888 | CODE |
889 | |
7292dc67 |
890 | my $sign_dist = $self->cd('$(DISTVNAME)' => 'cpansign -s'); |
479d2113 |
891 | |
7292dc67 |
892 | # cpansign -s complains if SIGNATURE is in the MANIFEST yet does not |
893 | # exist |
894 | my $touch_sig = $self->cd('$(DISTVNAME)' => '$(TOUCH) SIGNATURE'); |
895 | my $add_sign_to_dist = $self->cd('$(DISTVNAME)' => $add_sign ); |
479d2113 |
896 | |
7292dc67 |
897 | return sprintf <<'MAKE', $add_sign_to_dist, $touch_sig, $sign_dist |
898 | distsignature : create_distdir |
899 | $(NOECHO) %s |
900 | $(NOECHO) %s |
901 | %s |
479d2113 |
902 | |
7292dc67 |
903 | MAKE |
479d2113 |
904 | |
7292dc67 |
905 | } |
479d2113 |
906 | |
907 | |
7292dc67 |
908 | =head3 special_targets |
479d2113 |
909 | |
7292dc67 |
910 | my $make_frag = $mm->special_targets |
479d2113 |
911 | |
7292dc67 |
912 | Returns a make fragment containing any targets which have special |
913 | meaning to make. For example, .SUFFIXES and .PHONY. |
479d2113 |
914 | |
7292dc67 |
915 | =cut |
479d2113 |
916 | |
7292dc67 |
917 | sub special_targets { |
918 | my $make_frag = <<'MAKE_FRAG'; |
919 | .SUFFIXES : .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT) |
479d2113 |
920 | |
7292dc67 |
921 | .PHONY: all config static dynamic test linkext manifest blibdirs clean realclean disttest distdir |
479d2113 |
922 | |
7292dc67 |
923 | MAKE_FRAG |
479d2113 |
924 | |
7292dc67 |
925 | $make_frag .= <<'MAKE_FRAG' if $ENV{CLEARCASE_ROOT}; |
926 | .NO_CONFIG_REC: Makefile |
479d2113 |
927 | |
7292dc67 |
928 | MAKE_FRAG |
479d2113 |
929 | |
7292dc67 |
930 | return $make_frag; |
931 | } |
479d2113 |
932 | |
479d2113 |
933 | |
479d2113 |
934 | |
479d2113 |
935 | |
7292dc67 |
936 | =head2 Init methods |
937 | |
938 | Methods which help initialize the MakeMaker object and macros. |
939 | |
940 | |
941 | =head3 init_INST |
942 | |
943 | $mm->init_INST; |
944 | |
945 | Called by init_main. Sets up all INST_* variables except those related |
946 | to XS code. Those are handled in init_xs. |
947 | |
948 | =cut |
949 | |
950 | sub init_INST { |
951 | my($self) = shift; |
952 | |
953 | $self->{INST_ARCHLIB} ||= $self->catdir($Curdir,"blib","arch"); |
954 | $self->{INST_BIN} ||= $self->catdir($Curdir,'blib','bin'); |
955 | |
956 | # INST_LIB typically pre-set if building an extension after |
957 | # perl has been built and installed. Setting INST_LIB allows |
958 | # you to build directly into, say $Config{privlibexp}. |
959 | unless ($self->{INST_LIB}){ |
960 | if ($self->{PERL_CORE}) { |
961 | if (defined $Cross::platform) { |
962 | $self->{INST_LIB} = $self->{INST_ARCHLIB} = |
963 | $self->catdir($self->{PERL_LIB},"..","xlib", |
964 | $Cross::platform); |
965 | } |
966 | else { |
967 | $self->{INST_LIB} = $self->{INST_ARCHLIB} = $self->{PERL_LIB}; |
968 | } |
969 | } else { |
970 | $self->{INST_LIB} = $self->catdir($Curdir,"blib","lib"); |
971 | } |
972 | } |
973 | |
974 | my @parentdir = split(/::/, $self->{PARENT_NAME}); |
975 | $self->{INST_LIBDIR} = $self->catdir('$(INST_LIB)', @parentdir); |
976 | $self->{INST_ARCHLIBDIR} = $self->catdir('$(INST_ARCHLIB)', @parentdir); |
977 | $self->{INST_AUTODIR} = $self->catdir('$(INST_LIB)', 'auto', |
978 | '$(FULLEXT)'); |
979 | $self->{INST_ARCHAUTODIR} = $self->catdir('$(INST_ARCHLIB)', 'auto', |
980 | '$(FULLEXT)'); |
981 | |
982 | $self->{INST_SCRIPT} ||= $self->catdir($Curdir,'blib','script'); |
983 | |
984 | $self->{INST_MAN1DIR} ||= $self->catdir($Curdir,'blib','man1'); |
985 | $self->{INST_MAN3DIR} ||= $self->catdir($Curdir,'blib','man3'); |
986 | |
987 | return 1; |
988 | } |
989 | |
990 | |
991 | =head3 init_INSTALL |
992 | |
993 | $mm->init_INSTALL; |
994 | |
995 | Called by init_main. Sets up all INSTALL_* variables (except |
996 | INSTALLDIRS) and *PREFIX. |
997 | |
998 | =cut |
999 | |
1000 | sub init_INSTALL { |
1001 | my($self) = shift; |
1002 | |
1003 | if( $self->{ARGS}{INSTALLBASE} and $self->{ARGS}{PREFIX} ) { |
1004 | die "Only one of PREFIX or INSTALLBASE can be given. Not both.\n"; |
1005 | } |
1006 | |
1007 | if( $self->{ARGS}{INSTALLBASE} ) { |
1008 | $self->init_INSTALL_from_INSTALLBASE; |
1009 | } |
1010 | else { |
1011 | $self->init_INSTALL_from_PREFIX; |
1012 | } |
1013 | } |
1014 | |
1015 | |
1016 | =head3 init_INSTALL_from_PREFIX |
1017 | |
1018 | $mm->init_INSTALL_from_PREFIX; |
1019 | |
1020 | =cut |
1021 | |
1022 | sub init_INSTALL_from_PREFIX { |
1023 | my $self = shift; |
1024 | |
1025 | $self->init_lib2arch; |
1026 | |
1027 | # There are often no Config.pm defaults for these new man variables so |
1028 | # we fall back to the old behavior which is to use installman*dir |
1029 | foreach my $num (1, 3) { |
1030 | my $k = 'installsiteman'.$num.'dir'; |
1031 | |
1032 | $self->{uc $k} ||= uc "\$(installman${num}dir)" |
1033 | unless $Config{$k}; |
1034 | } |
1035 | |
1036 | foreach my $num (1, 3) { |
1037 | my $k = 'installvendorman'.$num.'dir'; |
1038 | |
1039 | unless( $Config{$k} ) { |
1040 | $self->{uc $k} ||= $Config{usevendorprefix} |
1041 | ? uc "\$(installman${num}dir)" |
1042 | : ''; |
1043 | } |
1044 | } |
1045 | |
1046 | $self->{INSTALLSITEBIN} ||= '$(INSTALLBIN)' |
1047 | unless $Config{installsitebin}; |
002b9267 |
1048 | $self->{INSTALLSITESCRIPT} ||= '$(INSTALLSCRIPT)' |
1049 | unless $Config{installsitescript}; |
7292dc67 |
1050 | |
1051 | unless( $Config{installvendorbin} ) { |
1052 | $self->{INSTALLVENDORBIN} ||= $Config{usevendorprefix} |
1053 | ? $Config{installbin} |
1054 | : ''; |
1055 | } |
002b9267 |
1056 | unless( $Config{installvendorscript} ) { |
1057 | $self->{INSTALLVENDORSCRIPT} ||= $Config{usevendorprefix} |
1058 | ? $Config{installscript} |
1059 | : ''; |
1060 | } |
7292dc67 |
1061 | |
1062 | |
1063 | my $iprefix = $Config{installprefixexp} || $Config{installprefix} || |
1064 | $Config{prefixexp} || $Config{prefix} || ''; |
1065 | my $vprefix = $Config{usevendorprefix} ? $Config{vendorprefixexp} : ''; |
1066 | my $sprefix = $Config{siteprefixexp} || ''; |
1067 | |
1068 | # 5.005_03 doesn't have a siteprefix. |
1069 | $sprefix = $iprefix unless $sprefix; |
1070 | |
1071 | |
1072 | $self->{PREFIX} ||= ''; |
1073 | |
1074 | if( $self->{PREFIX} ) { |
1075 | @{$self}{qw(PERLPREFIX SITEPREFIX VENDORPREFIX)} = |
1076 | ('$(PREFIX)') x 3; |
1077 | } |
1078 | else { |
1079 | $self->{PERLPREFIX} ||= $iprefix; |
1080 | $self->{SITEPREFIX} ||= $sprefix; |
1081 | $self->{VENDORPREFIX} ||= $vprefix; |
1082 | |
1083 | # Lots of MM extension authors like to use $(PREFIX) so we |
1084 | # put something sensible in there no matter what. |
1085 | $self->{PREFIX} = '$('.uc $self->{INSTALLDIRS}.'PREFIX)'; |
1086 | } |
1087 | |
1088 | my $arch = $Config{archname}; |
1089 | my $version = $Config{version}; |
1090 | |
1091 | # default style |
1092 | my $libstyle = $Config{installstyle} || 'lib/perl5'; |
1093 | my $manstyle = ''; |
1094 | |
1095 | if( $self->{LIBSTYLE} ) { |
1096 | $libstyle = $self->{LIBSTYLE}; |
1097 | $manstyle = $self->{LIBSTYLE} eq 'lib/perl5' ? 'lib/perl5' : ''; |
1098 | } |
1099 | |
1100 | # Some systems, like VOS, set installman*dir to '' if they can't |
1101 | # read man pages. |
1102 | for my $num (1, 3) { |
1103 | $self->{'INSTALLMAN'.$num.'DIR'} ||= 'none' |
1104 | unless $Config{'installman'.$num.'dir'}; |
1105 | } |
1106 | |
1107 | my %bin_layouts = |
1108 | ( |
1109 | bin => { s => $iprefix, |
1110 | t => 'perl', |
1111 | d => 'bin' }, |
1112 | vendorbin => { s => $vprefix, |
1113 | t => 'vendor', |
1114 | d => 'bin' }, |
1115 | sitebin => { s => $sprefix, |
1116 | t => 'site', |
1117 | d => 'bin' }, |
1118 | script => { s => $iprefix, |
1119 | t => 'perl', |
1120 | d => 'bin' }, |
002b9267 |
1121 | vendorscript=> { s => $vprefix, |
1122 | t => 'vendor', |
1123 | d => 'bin' }, |
1124 | sitescript => { s => $sprefix, |
1125 | t => 'site', |
1126 | d => 'bin' }, |
7292dc67 |
1127 | ); |
1128 | |
1129 | my %man_layouts = |
1130 | ( |
1131 | man1dir => { s => $iprefix, |
1132 | t => 'perl', |
1133 | d => 'man/man1', |
1134 | style => $manstyle, }, |
1135 | siteman1dir => { s => $sprefix, |
1136 | t => 'site', |
1137 | d => 'man/man1', |
1138 | style => $manstyle, }, |
1139 | vendorman1dir => { s => $vprefix, |
1140 | t => 'vendor', |
1141 | d => 'man/man1', |
1142 | style => $manstyle, }, |
1143 | |
1144 | man3dir => { s => $iprefix, |
1145 | t => 'perl', |
1146 | d => 'man/man3', |
1147 | style => $manstyle, }, |
1148 | siteman3dir => { s => $sprefix, |
1149 | t => 'site', |
1150 | d => 'man/man3', |
1151 | style => $manstyle, }, |
1152 | vendorman3dir => { s => $vprefix, |
1153 | t => 'vendor', |
1154 | d => 'man/man3', |
1155 | style => $manstyle, }, |
1156 | ); |
1157 | |
1158 | my %lib_layouts = |
1159 | ( |
1160 | privlib => { s => $iprefix, |
1161 | t => 'perl', |
1162 | d => '', |
1163 | style => $libstyle, }, |
1164 | vendorlib => { s => $vprefix, |
1165 | t => 'vendor', |
1166 | d => '', |
1167 | style => $libstyle, }, |
1168 | sitelib => { s => $sprefix, |
1169 | t => 'site', |
1170 | d => 'site_perl', |
1171 | style => $libstyle, }, |
1172 | |
1173 | archlib => { s => $iprefix, |
1174 | t => 'perl', |
1175 | d => "$version/$arch", |
1176 | style => $libstyle }, |
1177 | vendorarch => { s => $vprefix, |
1178 | t => 'vendor', |
1179 | d => "$version/$arch", |
1180 | style => $libstyle }, |
1181 | sitearch => { s => $sprefix, |
1182 | t => 'site', |
1183 | d => "site_perl/$version/$arch", |
1184 | style => $libstyle }, |
1185 | ); |
1186 | |
1187 | |
1188 | # Special case for LIB. |
1189 | if( $self->{LIB} ) { |
1190 | foreach my $var (keys %lib_layouts) { |
1191 | my $Installvar = uc "install$var"; |
1192 | |
1193 | if( $var =~ /arch/ ) { |
1194 | $self->{$Installvar} ||= |
1195 | $self->catdir($self->{LIB}, $Config{archname}); |
1196 | } |
1197 | else { |
1198 | $self->{$Installvar} ||= $self->{LIB}; |
1199 | } |
1200 | } |
1201 | } |
1202 | |
1203 | my %type2prefix = ( perl => 'PERLPREFIX', |
1204 | site => 'SITEPREFIX', |
1205 | vendor => 'VENDORPREFIX' |
1206 | ); |
1207 | |
1208 | my %layouts = (%bin_layouts, %man_layouts, %lib_layouts); |
1209 | while( my($var, $layout) = each(%layouts) ) { |
1210 | my($s, $t, $d, $style) = @{$layout}{qw(s t d style)}; |
1211 | my $r = '$('.$type2prefix{$t}.')'; |
1212 | |
1213 | print STDERR "Prefixing $var\n" if $Verbose >= 2; |
1214 | |
1215 | my $installvar = "install$var"; |
1216 | my $Installvar = uc $installvar; |
1217 | next if $self->{$Installvar}; |
1218 | |
1219 | $d = "$style/$d" if $style; |
1220 | $self->prefixify($installvar, $s, $r, $d); |
1221 | |
1222 | print STDERR " $Installvar == $self->{$Installvar}\n" |
1223 | if $Verbose >= 2; |
1224 | } |
1225 | |
1226 | # Generate these if they weren't figured out. |
1227 | $self->{VENDORARCHEXP} ||= $self->{INSTALLVENDORARCH}; |
1228 | $self->{VENDORLIBEXP} ||= $self->{INSTALLVENDORLIB}; |
1229 | |
1230 | return 1; |
1231 | } |
1232 | |
1233 | |
1234 | =head3 init_from_INSTALLBASE |
1235 | |
1236 | $mm->init_from_INSTALLBASE |
1237 | |
1238 | =cut |
1239 | |
1240 | my %map = ( |
1241 | lib => [qw(lib perl5)], |
1242 | arch => [('lib', 'perl5', $Config{archname})], |
1243 | bin => [qw(bin)], |
1244 | man1dir => [qw(man man1)], |
1245 | man3dir => [qw(man man3)] |
1246 | ); |
1247 | $map{script} = $map{bin}; |
1248 | |
1249 | sub init_INSTALL_from_INSTALLBASE { |
1250 | my $self = shift; |
1251 | |
1252 | @{$self}{qw(PREFIX VENDORPREFIX SITEPREFIX PERLPREFIX)} = |
1253 | '$(INSTALLBASE)'; |
1254 | |
1255 | my %install; |
1256 | foreach my $thing (keys %map) { |
1257 | foreach my $dir (('', 'SITE', 'VENDOR')) { |
1258 | my $uc_thing = uc $thing; |
1259 | my $key = "INSTALL".$dir.$uc_thing; |
1260 | |
1261 | $install{$key} ||= |
1262 | $self->catdir('$(INSTALLBASE)', @{$map{$thing}}); |
1263 | } |
1264 | } |
1265 | |
1266 | # Adjust for variable quirks. |
1267 | $install{INSTALLARCHLIB} ||= delete $install{INSTALLARCH}; |
1268 | $install{INSTALLPRIVLIB} ||= delete $install{INSTALLLIB}; |
7292dc67 |
1269 | |
1270 | foreach my $key (keys %install) { |
1271 | $self->{$key} ||= $install{$key}; |
1272 | } |
1273 | |
1274 | return 1; |
1275 | } |
1276 | |
1277 | |
1278 | =head3 init_VERSION I<Abstract> |
1279 | |
1280 | $mm->init_VERSION |
1281 | |
1282 | Initialize macros representing versions of MakeMaker and other tools |
1283 | |
1284 | MAKEMAKER: path to the MakeMaker module. |
1285 | |
1286 | MM_VERSION: ExtUtils::MakeMaker Version |
1287 | |
1288 | MM_REVISION: ExtUtils::MakeMaker version control revision (for backwards |
1289 | compat) |
1290 | |
1291 | VERSION: version of your module |
1292 | |
1293 | VERSION_MACRO: which macro represents the version (usually 'VERSION') |
1294 | |
1295 | VERSION_SYM: like version but safe for use as an RCS revision number |
1296 | |
1297 | DEFINE_VERSION: -D line to set the module version when compiling |
1298 | |
1299 | XS_VERSION: version in your .xs file. Defaults to $(VERSION) |
1300 | |
1301 | XS_VERSION_MACRO: which macro represents the XS version. |
1302 | |
1303 | XS_DEFINE_VERSION: -D line to set the xs version when compiling. |
1304 | |
1305 | Called by init_main. |
1306 | |
1307 | =cut |
1308 | |
1309 | sub init_VERSION { |
1310 | my($self) = shift; |
1311 | |
1312 | $self->{MAKEMAKER} = $ExtUtils::MakeMaker::Filename; |
1313 | $self->{MM_VERSION} = $ExtUtils::MakeMaker::VERSION; |
1314 | $self->{MM_REVISION}= $ExtUtils::MakeMaker::Revision; |
1315 | $self->{VERSION_FROM} ||= ''; |
1316 | |
1317 | if ($self->{VERSION_FROM}){ |
1318 | $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}); |
1319 | if( $self->{VERSION} eq 'undef' ) { |
1320 | require Carp; |
1321 | Carp::carp("WARNING: Setting VERSION via file ". |
1322 | "'$self->{VERSION_FROM}' failed\n"); |
1323 | } |
1324 | } |
1325 | |
1326 | # strip blanks |
1327 | if (defined $self->{VERSION}) { |
1328 | $self->{VERSION} =~ s/^\s+//; |
1329 | $self->{VERSION} =~ s/\s+$//; |
1330 | } |
1331 | else { |
1332 | $self->{VERSION} = ''; |
1333 | } |
1334 | |
1335 | |
1336 | $self->{VERSION_MACRO} = 'VERSION'; |
1337 | ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g; |
1338 | $self->{DEFINE_VERSION} = '-D$(VERSION_MACRO)=\"$(VERSION)\"'; |
1339 | |
1340 | |
1341 | # Graham Barr and Paul Marquess had some ideas how to ensure |
1342 | # version compatibility between the *.pm file and the |
1343 | # corresponding *.xs file. The bottomline was, that we need an |
1344 | # XS_VERSION macro that defaults to VERSION: |
1345 | $self->{XS_VERSION} ||= $self->{VERSION}; |
1346 | |
1347 | $self->{XS_VERSION_MACRO} = 'XS_VERSION'; |
1348 | $self->{XS_DEFINE_VERSION} = '-D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"'; |
1349 | |
1350 | } |
1351 | |
1352 | |
1353 | =head3 init_others I<Abstract> |
479d2113 |
1354 | |
1355 | $MM->init_others(); |
1356 | |
1357 | Initializes the macro definitions used by tools_other() and places them |
1358 | in the $MM object. |
1359 | |
1360 | If there is no description, its the same as the parameter to |
1361 | WriteMakefile() documented in ExtUtils::MakeMaker. |
1362 | |
1363 | Defines at least these macros. |
1364 | |
1365 | Macro Description |
1366 | |
dedf98bc |
1367 | NOOP Do nothing |
1368 | NOECHO Tell make not to display the command itself |
479d2113 |
1369 | |
1370 | MAKEFILE |
1371 | FIRST_MAKEFILE |
1372 | MAKEFILE_OLD |
1373 | MAKE_APERL_FILE File used by MAKE_APERL |
1374 | |
1375 | SHELL Program used to run |
1376 | shell commands |
1377 | |
dedf98bc |
1378 | ECHO Print text adding a newline on the end |
479d2113 |
1379 | RM_F Remove a file |
1380 | RM_RF Remove a directory |
1381 | TOUCH Update a file's timestamp |
1382 | TEST_F Test for a file's existence |
1383 | CP Copy a file |
1384 | MV Move a file |
1385 | CHMOD Change permissions on a |
1386 | file |
1387 | |
1388 | UMASK_NULL Nullify umask |
3c4b39be |
1389 | DEV_NULL Suppress all command output |
479d2113 |
1390 | |
7292dc67 |
1391 | |
1392 | =head3 init_DIRFILESEP I<Abstract> |
479d2113 |
1393 | |
1394 | $MM->init_DIRFILESEP; |
1395 | my $dirfilesep = $MM->{DIRFILESEP}; |
1396 | |
1397 | Initializes the DIRFILESEP macro which is the seperator between the |
1398 | directory and filename in a filepath. ie. / on Unix, \ on Win32 and |
1399 | nothing on VMS. |
1400 | |
1401 | For example: |
1402 | |
1403 | # instead of $(INST_ARCHAUTODIR)/extralibs.ld |
1404 | $(INST_ARCHAUTODIR)$(DIRFILESEP)extralibs.ld |
1405 | |
1406 | Something of a hack but it prevents a lot of code duplication between |
1407 | MM_* variants. |
1408 | |
1409 | Do not use this as a seperator between directories. Some operating |
1410 | systems use different seperators between subdirectories as between |
1411 | directories and filenames (for example: VOLUME:[dir1.dir2]file on VMS). |
1412 | |
7292dc67 |
1413 | =head3 init_linker I<Abstract> |
479d2113 |
1414 | |
1415 | $mm->init_linker; |
1416 | |
1417 | Initialize macros which have to do with linking. |
1418 | |
1419 | PERL_ARCHIVE: path to libperl.a equivalent to be linked to dynamic |
1420 | extensions. |
1421 | |
1422 | PERL_ARCHIVE_AFTER: path to a library which should be put on the |
1423 | linker command line I<after> the external libraries to be linked to |
1424 | dynamic extensions. This may be needed if the linker is one-pass, and |
1425 | Perl includes some overrides for C RTL functions, such as malloc(). |
1426 | |
1427 | EXPORT_LIST: name of a file that is passed to linker to define symbols |
1428 | to be exported. |
1429 | |
1430 | Some OSes do not need these in which case leave it blank. |
1431 | |
1432 | |
7292dc67 |
1433 | =head3 init_platform |
479d2113 |
1434 | |
1435 | $mm->init_platform |
1436 | |
1437 | Initialize any macros which are for platform specific use only. |
1438 | |
1439 | A typical one is the version number of your OS specific mocule. |
1440 | (ie. MM_Unix_VERSION or MM_VMS_VERSION). |
1441 | |
7292dc67 |
1442 | =cut |
479d2113 |
1443 | |
7292dc67 |
1444 | sub init_platform { |
1445 | return ''; |
1446 | } |
479d2113 |
1447 | |
7292dc67 |
1448 | |
1449 | |
1450 | |
1451 | |
1452 | =head2 Tools |
1453 | |
1454 | A grab bag of methods to generate specific macros and commands. |
1455 | |
1456 | |
1457 | |
1458 | =head3 manifypods |
1459 | |
1460 | Defines targets and routines to translate the pods into manpages and |
1461 | put them into the INST_* directories. |
479d2113 |
1462 | |
1463 | =cut |
1464 | |
7292dc67 |
1465 | sub manifypods { |
1466 | my $self = shift; |
1467 | |
1468 | my $POD2MAN_macro = $self->POD2MAN_macro(); |
1469 | my $manifypods_target = $self->manifypods_target(); |
1470 | |
1471 | return <<END_OF_TARGET; |
1472 | |
1473 | $POD2MAN_macro |
1474 | |
1475 | $manifypods_target |
1476 | |
1477 | END_OF_TARGET |
1478 | |
479d2113 |
1479 | } |
1480 | |
7292dc67 |
1481 | |
1482 | =head3 POD2MAN_macro |
1483 | |
1484 | my $pod2man_macro = $self->POD2MAN_macro |
1485 | |
1486 | Returns a definition for the POD2MAN macro. This is a program |
1487 | which emulates the pod2man utility. You can add more switches to the |
1488 | command by simply appending them on the macro. |
1489 | |
1490 | Typical usage: |
1491 | |
1492 | $(POD2MAN) --section=3 --perm_rw=$(PERM_RW) podfile1 man_page1 ... |
1493 | |
1494 | =cut |
1495 | |
1496 | sub POD2MAN_macro { |
1497 | my $self = shift; |
1498 | |
1499 | # Need the trailing '--' so perl stops gobbling arguments and - happens |
1500 | # to be an alternative end of line seperator on VMS so we quote it |
1501 | return <<'END_OF_DEF'; |
1502 | POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--" |
1503 | POD2MAN = $(POD2MAN_EXE) |
1504 | END_OF_DEF |
479d2113 |
1505 | } |
1506 | |
dedf98bc |
1507 | |
7292dc67 |
1508 | =head3 test_via_harness |
dedf98bc |
1509 | |
7292dc67 |
1510 | my $command = $mm->test_via_harness($perl, $tests); |
dedf98bc |
1511 | |
7292dc67 |
1512 | Returns a $command line which runs the given set of $tests with |
1513 | Test::Harness and the given $perl. |
dedf98bc |
1514 | |
7292dc67 |
1515 | Used on the t/*.t files. |
dedf98bc |
1516 | |
7292dc67 |
1517 | =cut |
dedf98bc |
1518 | |
7292dc67 |
1519 | sub test_via_harness { |
1520 | my($self, $perl, $tests) = @_; |
1521 | |
1522 | return qq{\t$perl "-MExtUtils::Command::MM" }. |
1523 | qq{"-e" "test_harness(\$(TEST_VERBOSE), '\$(INST_LIB)', '\$(INST_ARCHLIB)')" $tests\n}; |
1524 | } |
1525 | |
1526 | =head3 test_via_script |
1527 | |
1528 | my $command = $mm->test_via_script($perl, $script); |
1529 | |
1530 | Returns a $command line which just runs a single test without |
1531 | Test::Harness. No checks are done on the results, they're just |
1532 | printed. |
dedf98bc |
1533 | |
7292dc67 |
1534 | Used for test.pl, since they don't always follow Test::Harness |
1535 | formatting. |
1536 | |
1537 | =cut |
1538 | |
1539 | sub test_via_script { |
1540 | my($self, $perl, $script) = @_; |
1541 | return qq{\t$perl "-I\$(INST_LIB)" "-I\$(INST_ARCHLIB)" $script\n}; |
1542 | } |
1543 | |
1544 | |
1545 | =head3 tool_autosplit |
1546 | |
1547 | Defines a simple perl call that runs autosplit. May be deprecated by |
1548 | pm_to_blib soon. |
1549 | |
1550 | =cut |
1551 | |
1552 | sub tool_autosplit { |
1553 | my($self, %attribs) = @_; |
1554 | |
1555 | my $maxlen = $attribs{MAXLEN} ? '$$AutoSplit::Maxlen=$attribs{MAXLEN};' |
1556 | : ''; |
1557 | |
1558 | my $asplit = $self->oneliner(sprintf <<'PERL_CODE', $maxlen); |
1559 | use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) |
1560 | PERL_CODE |
1561 | |
1562 | return sprintf <<'MAKE_FRAG', $asplit; |
1563 | # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto |
1564 | AUTOSPLITFILE = %s |
1565 | |
1566 | MAKE_FRAG |
1567 | |
1568 | } |
1569 | |
1570 | |
1571 | |
1572 | |
1573 | =head2 File::Spec wrappers |
1574 | |
1575 | ExtUtils::MM_Any is a subclass of File::Spec. The methods noted here |
1576 | override File::Spec. |
1577 | |
1578 | |
1579 | |
1580 | =head3 catfile |
1581 | |
1582 | File::Spec <= 0.83 has a bug where the file part of catfile is not |
1583 | canonicalized. This override fixes that bug. |
1584 | |
1585 | =cut |
1586 | |
1587 | sub catfile { |
1588 | my $self = shift; |
1589 | return $self->canonpath($self->SUPER::catfile(@_)); |
1590 | } |
1591 | |
1592 | |
1593 | |
1594 | =head2 Misc |
1595 | |
1596 | Methods I can't really figure out where they should go yet. |
1597 | |
1598 | |
1599 | =head3 find_tests |
1600 | |
1601 | my $test = $mm->find_tests; |
1602 | |
1603 | Returns a string suitable for feeding to the shell to return all |
1604 | tests in t/*.t. |
1605 | |
1606 | =cut |
1607 | |
1608 | sub find_tests { |
1609 | my($self) = shift; |
1610 | return -d 't' ? 't/*.t' : ''; |
1611 | } |
1612 | |
1613 | |
1614 | =head3 extra_clean_files |
1615 | |
1616 | my @files_to_clean = $MM->extra_clean_files; |
1617 | |
1618 | Returns a list of OS specific files to be removed in the clean target in |
1619 | addition to the usual set. |
1620 | |
1621 | =cut |
1622 | |
1623 | # An empty method here tickled a perl 5.8.1 bug and would return its object. |
1624 | sub extra_clean_files { |
1625 | return; |
1626 | } |
1627 | |
1628 | |
1629 | =head3 installvars |
1630 | |
1631 | my @installvars = $mm->installvars; |
1632 | |
1633 | A list of all the INSTALL* variables without the INSTALL prefix. Useful |
1634 | for iteration or building related variable sets. |
1635 | |
1636 | =cut |
1637 | |
1638 | sub installvars { |
1639 | return qw(PRIVLIB SITELIB VENDORLIB |
1640 | ARCHLIB SITEARCH VENDORARCH |
1641 | BIN SITEBIN VENDORBIN |
002b9267 |
1642 | SCRIPT SITESCRIPT VENDORSCRIPT |
7292dc67 |
1643 | MAN1DIR SITEMAN1DIR VENDORMAN1DIR |
1644 | MAN3DIR SITEMAN3DIR VENDORMAN3DIR |
1645 | ); |
1646 | } |
1647 | |
1648 | |
1649 | =head3 libscan |
1650 | |
1651 | my $wanted = $self->libscan($path); |
1652 | |
1653 | Takes a path to a file or dir and returns an empty string if we don't |
1654 | want to include this file in the library. Otherwise it returns the |
1655 | the $path unchanged. |
1656 | |
1657 | Mainly used to exclude version control administrative directories from |
1658 | installation. |
1659 | |
1660 | =cut |
1661 | |
1662 | sub libscan { |
1663 | my($self,$path) = @_; |
1664 | my($dirs,$file) = ($self->splitpath($path))[1,2]; |
1665 | return '' if grep /^(?:RCS|CVS|SCCS|\.svn|_darcs)$/, |
1666 | $self->splitdir($dirs), $file; |
1667 | |
1668 | return $path; |
1669 | } |
1670 | |
1671 | |
1672 | =head3 platform_constants |
1673 | |
1674 | my $make_frag = $mm->platform_constants |
1675 | |
1676 | Returns a make fragment defining all the macros initialized in |
1677 | init_platform() rather than put them in constants(). |
1678 | |
1679 | =cut |
1680 | |
1681 | sub platform_constants { |
1682 | return ''; |
1683 | } |
479d2113 |
1684 | |
f6d6199c |
1685 | |
1686 | =head1 AUTHOR |
1687 | |
479d2113 |
1688 | Michael G Schwern <schwern@pobox.com> and the denizens of |
1689 | makemaker@perl.org with code from ExtUtils::MM_Unix and |
1690 | ExtUtils::MM_Win32. |
f6d6199c |
1691 | |
1692 | |
1693 | =cut |
1694 | |
1695 | 1; |