Commit | Line | Data |
---|---|---|
86530b38 AT |
1 | package ExtUtils::MM_Any; |
2 | ||
3 | use strict; | |
4 | use vars qw($VERSION @ISA); | |
5 | $VERSION = 0.09; | |
6 | @ISA = qw(File::Spec); | |
7 | ||
8 | use Config; | |
9 | use File::Spec; | |
10 | ||
11 | ||
12 | =head1 NAME | |
13 | ||
14 | ExtUtils::MM_Any - Platform-agnostic MM methods | |
15 | ||
16 | =head1 SYNOPSIS | |
17 | ||
18 | FOR INTERNAL USE ONLY! | |
19 | ||
20 | package ExtUtils::MM_SomeOS; | |
21 | ||
22 | # Temporarily, you have to subclass both. Put MM_Any first. | |
23 | require ExtUtils::MM_Any; | |
24 | require ExtUtils::MM_Unix; | |
25 | @ISA = qw(ExtUtils::MM_Any ExtUtils::Unix); | |
26 | ||
27 | =head1 DESCRIPTION | |
28 | ||
29 | B<FOR INTERNAL USE ONLY!> | |
30 | ||
31 | ExtUtils::MM_Any is a superclass for the ExtUtils::MM_* set of | |
32 | modules. It contains methods which are either inherently | |
33 | cross-platform or are written in a cross-platform manner. | |
34 | ||
35 | Subclass off of ExtUtils::MM_Any I<and> ExtUtils::MM_Unix. This is a | |
36 | temporary solution. | |
37 | ||
38 | B<THIS MAY BE TEMPORARY!> | |
39 | ||
40 | =head1 Inherently Cross-Platform Methods | |
41 | ||
42 | These are methods which are by their nature cross-platform and should | |
43 | always be cross-platform. | |
44 | ||
45 | =over 4 | |
46 | ||
47 | =item installvars | |
48 | ||
49 | my @installvars = $mm->installvars; | |
50 | ||
51 | A list of all the INSTALL* variables without the INSTALL prefix. Useful | |
52 | for iteration or building related variable sets. | |
53 | ||
54 | =cut | |
55 | ||
56 | sub installvars { | |
57 | return qw(PRIVLIB SITELIB VENDORLIB | |
58 | ARCHLIB SITEARCH VENDORARCH | |
59 | BIN SITEBIN VENDORBIN | |
60 | SCRIPT | |
61 | MAN1DIR SITEMAN1DIR VENDORMAN1DIR | |
62 | MAN3DIR SITEMAN3DIR VENDORMAN3DIR | |
63 | ); | |
64 | } | |
65 | ||
66 | =item os_flavor_is | |
67 | ||
68 | $mm->os_flavor_is($this_flavor); | |
69 | $mm->os_flavor_is(@one_of_these_flavors); | |
70 | ||
71 | Checks to see if the current operating system is one of the given flavors. | |
72 | ||
73 | This is useful for code like: | |
74 | ||
75 | if( $mm->os_flavor_is('Unix') ) { | |
76 | $out = `foo 2>&1`; | |
77 | } | |
78 | else { | |
79 | $out = `foo`; | |
80 | } | |
81 | ||
82 | =cut | |
83 | ||
84 | sub os_flavor_is { | |
85 | my $self = shift; | |
86 | my %flavors = map { ($_ => 1) } $self->os_flavor; | |
87 | return (grep { $flavors{$_} } @_) ? 1 : 0; | |
88 | } | |
89 | ||
90 | ||
91 | =item dir_targets B<DEPRECATED> | |
92 | ||
93 | my $make_frag = $mm->dir_target(@directories); | |
94 | ||
95 | I<This function is deprecated> its use is no longer necessary and is | |
96 | I<only provided for backwards compatibility>. It is now a no-op. | |
97 | blibdirs_target provides a much simpler mechanism and pm_to_blib() can | |
98 | create its own directories anyway. | |
99 | ||
100 | =cut | |
101 | ||
102 | sub dir_targets {} | |
103 | ||
104 | ||
105 | =item blibdirs_target (o) | |
106 | ||
107 | my $make_frag = $mm->blibdirs_target; | |
108 | ||
109 | Creates the blibdirs.ts target which creates all the directories we use in | |
110 | blib/. | |
111 | ||
112 | =cut | |
113 | ||
114 | sub blibdirs_target { | |
115 | my $self = shift; | |
116 | ||
117 | my @dirs = map { uc "\$(INST_$_)" } qw(libdir archlib | |
118 | autodir archautodir | |
119 | bin script | |
120 | man1dir man3dir | |
121 | ); | |
122 | my @mkpath = $self->split_command('$(NOECHO) $(MKPATH)', @dirs); | |
123 | my @chmod = $self->split_command('$(NOECHO) $(CHMOD) 755', @dirs); | |
124 | ||
125 | my $make = "\nblibdirs.ts :\n"; | |
126 | $make .= join "", map { "\t$_\n" } @mkpath, @chmod; | |
127 | $make .= <<'MAKE'; | |
128 | $(NOECHO) $(TOUCH) $@ | |
129 | ||
130 | MAKE | |
131 | ||
132 | return $make; | |
133 | } | |
134 | ||
135 | ||
136 | =back | |
137 | ||
138 | =head2 File::Spec wrappers | |
139 | ||
140 | ExtUtils::MM_Any is a subclass of File::Spec. The methods noted here | |
141 | override File::Spec. | |
142 | ||
143 | =over 4 | |
144 | ||
145 | =item catfile | |
146 | ||
147 | File::Spec <= 0.83 has a bug where the file part of catfile is not | |
148 | canonicalized. This override fixes that bug. | |
149 | ||
150 | =cut | |
151 | ||
152 | sub catfile { | |
153 | my $self = shift; | |
154 | return $self->canonpath($self->SUPER::catfile(@_)); | |
155 | } | |
156 | ||
157 | =back | |
158 | ||
159 | =head1 Thought To Be Cross-Platform Methods | |
160 | ||
161 | These are methods which are thought to be cross-platform by virtue of | |
162 | having been written in a way to avoid incompatibilities. They may | |
163 | require partial overrides. | |
164 | ||
165 | =over 4 | |
166 | ||
167 | =item B<split_command> | |
168 | ||
169 | my @cmds = $MM->split_command($cmd, @args); | |
170 | ||
171 | Most OS have a maximum command length they can execute at once. Large | |
172 | modules can easily generate commands well past that limit. Its | |
173 | necessary to split long commands up into a series of shorter commands. | |
174 | ||
175 | split_command() will return a series of @cmds each processing part of | |
176 | the args. Collectively they will process all the arguments. Each | |
177 | individual line in @cmds will not be longer than the | |
178 | $self->max_exec_len being careful to take into account macro expansion. | |
179 | ||
180 | $cmd should include any switches and repeated initial arguments. | |
181 | ||
182 | If no @args are given, no @cmds will be returned. | |
183 | ||
184 | Pairs of arguments will always be preserved in a single command, this | |
185 | is a heuristic for things like pm_to_blib and pod2man which work on | |
186 | pairs of arguments. This makes things like this safe: | |
187 | ||
188 | $self->split_command($cmd, %pod2man); | |
189 | ||
190 | ||
191 | =cut | |
192 | ||
193 | sub split_command { | |
194 | my($self, $cmd, @args) = @_; | |
195 | ||
196 | my @cmds = (); | |
197 | return(@cmds) unless @args; | |
198 | ||
199 | # If the command was given as a here-doc, there's probably a trailing | |
200 | # newline. | |
201 | chomp $cmd; | |
202 | ||
203 | # set aside 20% for macro expansion. | |
204 | my $len_left = int($self->max_exec_len * 0.80); | |
205 | $len_left -= length $self->_expand_macros($cmd); | |
206 | ||
207 | do { | |
208 | my $arg_str = ''; | |
209 | my @next_args; | |
210 | while( @next_args = splice(@args, 0, 2) ) { | |
211 | # Two at a time to preserve pairs. | |
212 | my $next_arg_str = "\t ". join ' ', @next_args, "\n"; | |
213 | ||
214 | if( !length $arg_str ) { | |
215 | $arg_str .= $next_arg_str | |
216 | } | |
217 | elsif( length($arg_str) + length($next_arg_str) > $len_left ) { | |
218 | unshift @args, @next_args; | |
219 | last; | |
220 | } | |
221 | else { | |
222 | $arg_str .= $next_arg_str; | |
223 | } | |
224 | } | |
225 | chop $arg_str; | |
226 | ||
227 | push @cmds, $self->escape_newlines("$cmd \n$arg_str"); | |
228 | } while @args; | |
229 | ||
230 | return @cmds; | |
231 | } | |
232 | ||
233 | ||
234 | sub _expand_macros { | |
235 | my($self, $cmd) = @_; | |
236 | ||
237 | $cmd =~ s{\$\((\w+)\)}{ | |
238 | defined $self->{$1} ? $self->{$1} : "\$($1)" | |
239 | }e; | |
240 | return $cmd; | |
241 | } | |
242 | ||
243 | ||
244 | =item B<echo> | |
245 | ||
246 | my @commands = $MM->echo($text); | |
247 | my @commands = $MM->echo($text, $file); | |
248 | my @commands = $MM->echo($text, $file, $appending); | |
249 | ||
250 | Generates a set of @commands which print the $text to a $file. | |
251 | ||
252 | If $file is not given, output goes to STDOUT. | |
253 | ||
254 | If $appending is true the $file will be appended to rather than | |
255 | overwritten. | |
256 | ||
257 | =cut | |
258 | ||
259 | sub echo { | |
260 | my($self, $text, $file, $appending) = @_; | |
261 | $appending ||= 0; | |
262 | ||
263 | my @cmds = map { '$(NOECHO) $(ECHO) '.$self->quote_literal($_) } | |
264 | split /\n/, $text; | |
265 | if( $file ) { | |
266 | my $redirect = $appending ? '>>' : '>'; | |
267 | $cmds[0] .= " $redirect $file"; | |
268 | $_ .= " >> $file" foreach @cmds[1..$#cmds]; | |
269 | } | |
270 | ||
271 | return @cmds; | |
272 | } | |
273 | ||
274 | ||
275 | =item init_VERSION | |
276 | ||
277 | $mm->init_VERSION | |
278 | ||
279 | Initialize macros representing versions of MakeMaker and other tools | |
280 | ||
281 | MAKEMAKER: path to the MakeMaker module. | |
282 | ||
283 | MM_VERSION: ExtUtils::MakeMaker Version | |
284 | ||
285 | MM_REVISION: ExtUtils::MakeMaker version control revision (for backwards | |
286 | compat) | |
287 | ||
288 | VERSION: version of your module | |
289 | ||
290 | VERSION_MACRO: which macro represents the version (usually 'VERSION') | |
291 | ||
292 | VERSION_SYM: like version but safe for use as an RCS revision number | |
293 | ||
294 | DEFINE_VERSION: -D line to set the module version when compiling | |
295 | ||
296 | XS_VERSION: version in your .xs file. Defaults to $(VERSION) | |
297 | ||
298 | XS_VERSION_MACRO: which macro represents the XS version. | |
299 | ||
300 | XS_DEFINE_VERSION: -D line to set the xs version when compiling. | |
301 | ||
302 | Called by init_main. | |
303 | ||
304 | =cut | |
305 | ||
306 | sub init_VERSION { | |
307 | my($self) = shift; | |
308 | ||
309 | $self->{MAKEMAKER} = $ExtUtils::MakeMaker::Filename; | |
310 | $self->{MM_VERSION} = $ExtUtils::MakeMaker::VERSION; | |
311 | $self->{MM_REVISION}= $ExtUtils::MakeMaker::Revision; | |
312 | $self->{VERSION_FROM} ||= ''; | |
313 | ||
314 | if ($self->{VERSION_FROM}){ | |
315 | $self->{VERSION} = $self->parse_version($self->{VERSION_FROM}); | |
316 | if( $self->{VERSION} eq 'undef' ) { | |
317 | require Carp; | |
318 | Carp::carp("WARNING: Setting VERSION via file ". | |
319 | "'$self->{VERSION_FROM}' failed\n"); | |
320 | } | |
321 | } | |
322 | ||
323 | # strip blanks | |
324 | if (defined $self->{VERSION}) { | |
325 | $self->{VERSION} =~ s/^\s+//; | |
326 | $self->{VERSION} =~ s/\s+$//; | |
327 | } | |
328 | else { | |
329 | $self->{VERSION} = ''; | |
330 | } | |
331 | ||
332 | ||
333 | $self->{VERSION_MACRO} = 'VERSION'; | |
334 | ($self->{VERSION_SYM} = $self->{VERSION}) =~ s/\W/_/g; | |
335 | $self->{DEFINE_VERSION} = '-D$(VERSION_MACRO)=\"$(VERSION)\"'; | |
336 | ||
337 | ||
338 | # Graham Barr and Paul Marquess had some ideas how to ensure | |
339 | # version compatibility between the *.pm file and the | |
340 | # corresponding *.xs file. The bottomline was, that we need an | |
341 | # XS_VERSION macro that defaults to VERSION: | |
342 | $self->{XS_VERSION} ||= $self->{VERSION}; | |
343 | ||
344 | $self->{XS_VERSION_MACRO} = 'XS_VERSION'; | |
345 | $self->{XS_DEFINE_VERSION} = '-D$(XS_VERSION_MACRO)=\"$(XS_VERSION)\"'; | |
346 | ||
347 | } | |
348 | ||
349 | =item wraplist | |
350 | ||
351 | Takes an array of items and turns them into a well-formatted list of | |
352 | arguments. In most cases this is simply something like: | |
353 | ||
354 | FOO \ | |
355 | BAR \ | |
356 | BAZ | |
357 | ||
358 | =cut | |
359 | ||
360 | sub wraplist { | |
361 | my $self = shift; | |
362 | return join " \\\n\t", @_; | |
363 | } | |
364 | ||
365 | =item manifypods | |
366 | ||
367 | Defines targets and routines to translate the pods into manpages and | |
368 | put them into the INST_* directories. | |
369 | ||
370 | =cut | |
371 | ||
372 | sub manifypods { | |
373 | my $self = shift; | |
374 | ||
375 | my $POD2MAN_macro = $self->POD2MAN_macro(); | |
376 | my $manifypods_target = $self->manifypods_target(); | |
377 | ||
378 | return <<END_OF_TARGET; | |
379 | ||
380 | $POD2MAN_macro | |
381 | ||
382 | $manifypods_target | |
383 | ||
384 | END_OF_TARGET | |
385 | ||
386 | } | |
387 | ||
388 | ||
389 | =item manifypods_target | |
390 | ||
391 | my $manifypods_target = $self->manifypods_target; | |
392 | ||
393 | Generates the manifypods target. This target generates man pages from | |
394 | all POD files in MAN1PODS and MAN3PODS. | |
395 | ||
396 | =cut | |
397 | ||
398 | sub manifypods_target { | |
399 | my($self) = shift; | |
400 | ||
401 | my $man1pods = ''; | |
402 | my $man3pods = ''; | |
403 | my $dependencies = ''; | |
404 | ||
405 | # populate manXpods & dependencies: | |
406 | foreach my $name (keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}}) { | |
407 | $dependencies .= " \\\n\t$name"; | |
408 | } | |
409 | ||
410 | foreach my $name (keys %{$self->{MAN3PODS}}) { | |
411 | $dependencies .= " \\\n\t$name" | |
412 | } | |
413 | ||
414 | my $manify = <<END; | |
415 | manifypods : pure_all $dependencies | |
416 | END | |
417 | ||
418 | my @man_cmds; | |
419 | foreach my $section (qw(1 3)) { | |
420 | my $pods = $self->{"MAN${section}PODS"}; | |
421 | push @man_cmds, $self->split_command(<<CMD, %$pods); | |
422 | \$(NOECHO) \$(POD2MAN) --section=$section --perm_rw=\$(PERM_RW) | |
423 | CMD | |
424 | } | |
425 | ||
426 | $manify .= "\t\$(NOECHO) \$(NOOP)\n" unless @man_cmds; | |
427 | $manify .= join '', map { "$_\n" } @man_cmds; | |
428 | ||
429 | return $manify; | |
430 | } | |
431 | ||
432 | ||
433 | =item makemakerdflt_target | |
434 | ||
435 | my $make_frag = $mm->makemakerdflt_target | |
436 | ||
437 | Returns a make fragment with the makemakerdeflt_target specified. | |
438 | This target is the first target in the Makefile, is the default target | |
439 | and simply points off to 'all' just in case any make variant gets | |
440 | confused or something gets snuck in before the real 'all' target. | |
441 | ||
442 | =cut | |
443 | ||
444 | sub makemakerdflt_target { | |
445 | return <<'MAKE_FRAG'; | |
446 | makemakerdflt: all | |
447 | $(NOECHO) $(NOOP) | |
448 | MAKE_FRAG | |
449 | ||
450 | } | |
451 | ||
452 | ||
453 | =item special_targets | |
454 | ||
455 | my $make_frag = $mm->special_targets | |
456 | ||
457 | Returns a make fragment containing any targets which have special | |
458 | meaning to make. For example, .SUFFIXES and .PHONY. | |
459 | ||
460 | =cut | |
461 | ||
462 | sub special_targets { | |
463 | my $make_frag = <<'MAKE_FRAG'; | |
464 | .SUFFIXES: .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT) | |
465 | ||
466 | .PHONY: all config static dynamic test linkext manifest | |
467 | ||
468 | MAKE_FRAG | |
469 | ||
470 | $make_frag .= <<'MAKE_FRAG' if $ENV{CLEARCASE_ROOT}; | |
471 | .NO_CONFIG_REC: Makefile | |
472 | ||
473 | MAKE_FRAG | |
474 | ||
475 | return $make_frag; | |
476 | } | |
477 | ||
478 | =item POD2MAN_macro | |
479 | ||
480 | my $pod2man_macro = $self->POD2MAN_macro | |
481 | ||
482 | Returns a definition for the POD2MAN macro. This is a program | |
483 | which emulates the pod2man utility. You can add more switches to the | |
484 | command by simply appending them on the macro. | |
485 | ||
486 | Typical usage: | |
487 | ||
488 | $(POD2MAN) --section=3 --perm_rw=$(PERM_RW) podfile1 man_page1 ... | |
489 | ||
490 | =cut | |
491 | ||
492 | sub POD2MAN_macro { | |
493 | my $self = shift; | |
494 | ||
495 | # Need the trailing '--' so perl stops gobbling arguments and - happens | |
496 | # to be an alternative end of line seperator on VMS so we quote it | |
497 | return <<'END_OF_DEF'; | |
498 | POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--" | |
499 | POD2MAN = $(POD2MAN_EXE) | |
500 | END_OF_DEF | |
501 | } | |
502 | ||
503 | ||
504 | =item test_via_harness | |
505 | ||
506 | my $command = $mm->test_via_harness($perl, $tests); | |
507 | ||
508 | Returns a $command line which runs the given set of $tests with | |
509 | Test::Harness and the given $perl. | |
510 | ||
511 | Used on the t/*.t files. | |
512 | ||
513 | =cut | |
514 | ||
515 | sub test_via_harness { | |
516 | my($self, $perl, $tests) = @_; | |
517 | ||
518 | return qq{\t$perl "-MExtUtils::Command::MM" }. | |
519 | qq{"-e" "test_harness(\$(TEST_VERBOSE), '\$(INST_LIB)', '\$(INST_ARCHLIB)')" $tests\n}; | |
520 | } | |
521 | ||
522 | =item test_via_script | |
523 | ||
524 | my $command = $mm->test_via_script($perl, $script); | |
525 | ||
526 | Returns a $command line which just runs a single test without | |
527 | Test::Harness. No checks are done on the results, they're just | |
528 | printed. | |
529 | ||
530 | Used for test.pl, since they don't always follow Test::Harness | |
531 | formatting. | |
532 | ||
533 | =cut | |
534 | ||
535 | sub test_via_script { | |
536 | my($self, $perl, $script) = @_; | |
537 | return qq{\t$perl "-I\$(INST_LIB)" "-I\$(INST_ARCHLIB)" $script\n}; | |
538 | } | |
539 | ||
540 | =item libscan | |
541 | ||
542 | my $wanted = $self->libscan($path); | |
543 | ||
544 | Takes a path to a file or dir and returns an empty string if we don't | |
545 | want to include this file in the library. Otherwise it returns the | |
546 | the $path unchanged. | |
547 | ||
548 | Mainly used to exclude RCS, CVS, and SCCS directories from | |
549 | installation. | |
550 | ||
551 | =cut | |
552 | ||
553 | sub libscan { | |
554 | my($self,$path) = @_; | |
555 | my($dirs,$file) = ($self->splitpath($path))[1,2]; | |
556 | return '' if grep /^(?:RCS|CVS|SCCS|\.svn)$/, | |
557 | $self->splitdir($dirs), $file; | |
558 | ||
559 | return $path; | |
560 | } | |
561 | ||
562 | =item tool_autosplit | |
563 | ||
564 | Defines a simple perl call that runs autosplit. May be deprecated by | |
565 | pm_to_blib soon. | |
566 | ||
567 | =cut | |
568 | ||
569 | sub tool_autosplit { | |
570 | my($self, %attribs) = @_; | |
571 | ||
572 | my $maxlen = $attribs{MAXLEN} ? '$$AutoSplit::Maxlen=$attribs{MAXLEN};' | |
573 | : ''; | |
574 | ||
575 | my $asplit = $self->oneliner(sprintf <<'PERL_CODE', $maxlen); | |
576 | use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1) | |
577 | PERL_CODE | |
578 | ||
579 | return sprintf <<'MAKE_FRAG', $asplit; | |
580 | # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto | |
581 | AUTOSPLITFILE = %s | |
582 | ||
583 | MAKE_FRAG | |
584 | ||
585 | } | |
586 | ||
587 | ||
588 | =item all_target | |
589 | ||
590 | Generate the default target 'all'. | |
591 | ||
592 | =cut | |
593 | ||
594 | sub all_target { | |
595 | my $self = shift; | |
596 | ||
597 | return <<'MAKE_EXT'; | |
598 | all :: pure_all | |
599 | $(NOECHO) $(NOOP) | |
600 | MAKE_EXT | |
601 | ||
602 | } | |
603 | ||
604 | ||
605 | =item metafile_target | |
606 | ||
607 | my $target = $mm->metafile_target; | |
608 | ||
609 | Generate the metafile target. | |
610 | ||
611 | Writes the file META.yml, YAML encoded meta-data about the module. The | |
612 | format follows Module::Build's as closely as possible. Additionally, we | |
613 | include: | |
614 | ||
615 | version_from | |
616 | installdirs | |
617 | ||
618 | =cut | |
619 | ||
620 | sub metafile_target { | |
621 | my $self = shift; | |
622 | ||
623 | return <<'MAKE_FRAG' if $self->{NO_META}; | |
624 | metafile: | |
625 | $(NOECHO) $(NOOP) | |
626 | MAKE_FRAG | |
627 | ||
628 | my $prereq_pm = ''; | |
629 | foreach my $mod ( sort { lc $a cmp lc $b } keys %{$self->{PREREQ_PM}} ) { | |
630 | my $ver = $self->{PREREQ_PM}{$mod}; | |
631 | $prereq_pm .= sprintf " %-30s %s\n", "$mod:", $ver; | |
632 | } | |
633 | ||
634 | my $meta = <<YAML; | |
635 | # http://module-build.sourceforge.net/META-spec.html | |
636 | #XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX# | |
637 | name: $self->{DISTNAME} | |
638 | version: $self->{VERSION} | |
639 | version_from: $self->{VERSION_FROM} | |
640 | installdirs: $self->{INSTALLDIRS} | |
641 | requires: | |
642 | $prereq_pm | |
643 | distribution_type: module | |
644 | generated_by: ExtUtils::MakeMaker version $ExtUtils::MakeMaker::VERSION | |
645 | YAML | |
646 | ||
647 | my @write_meta = $self->echo($meta, 'META_new.yml'); | |
648 | my $move = $self->oneliner(<<'CODE', ['-MExtUtils::Command', '-MFile::Compare']); | |
649 | compare(@ARGV) != 0 ? (mv or warn "Cannot move @ARGV: $$!\n") : unlink(shift); | |
650 | CODE | |
651 | ||
652 | return sprintf <<'MAKE_FRAG', join("\n\t", @write_meta), $move; | |
653 | metafile : | |
654 | $(NOECHO) $(ECHO) Generating META.yml | |
655 | %s | |
656 | -$(NOECHO) %s META_new.yml META.yml | |
657 | MAKE_FRAG | |
658 | ||
659 | } | |
660 | ||
661 | ||
662 | =item signature_target | |
663 | ||
664 | my $target = $mm->signature_target; | |
665 | ||
666 | Generate the signature target. | |
667 | ||
668 | Writes the file SIGNATURE with "cpansign -s". | |
669 | ||
670 | =cut | |
671 | ||
672 | sub signature_target { | |
673 | my $self = shift; | |
674 | ||
675 | return <<'MAKE_FRAG' if !$self->{SIGN}; | |
676 | signature : | |
677 | $(NOECHO) $(NOOP) | |
678 | MAKE_FRAG | |
679 | ||
680 | return <<'MAKE_FRAG'; | |
681 | signature : signature_addtomanifest | |
682 | cpansign -s | |
683 | MAKE_FRAG | |
684 | ||
685 | } | |
686 | ||
687 | ||
688 | =item metafile_addtomanifest_target | |
689 | ||
690 | my $target = $mm->metafile_addtomanifest_target | |
691 | ||
692 | Adds the META.yml file to the MANIFEST. | |
693 | ||
694 | =cut | |
695 | ||
696 | sub metafile_addtomanifest_target { | |
697 | my $self = shift; | |
698 | ||
699 | return <<'MAKE_FRAG' if $self->{NO_META}; | |
700 | metafile_addtomanifest: | |
701 | $(NOECHO) $(NOOP) | |
702 | MAKE_FRAG | |
703 | ||
704 | my $add_meta = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']); | |
705 | eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } | |
706 | or print "Could not add META.yml to MANIFEST: $${'@'}\n" | |
707 | CODE | |
708 | ||
709 | return sprintf <<'MAKE_FRAG', $add_meta; | |
710 | metafile_addtomanifest: | |
711 | $(NOECHO) $(ECHO) Adding META.yml to MANIFEST | |
712 | $(NOECHO) %s | |
713 | MAKE_FRAG | |
714 | ||
715 | } | |
716 | ||
717 | ||
718 | =item signature_addtomanifest_target | |
719 | ||
720 | my $target = $mm->signature_addtomanifest_target | |
721 | ||
722 | Adds the META.yml file to the MANIFEST. | |
723 | ||
724 | =cut | |
725 | ||
726 | sub signature_addtomanifest_target { | |
727 | my $self = shift; | |
728 | ||
729 | return <<'MAKE_FRAG' if !$self->{SIGN}; | |
730 | signature_addtomanifest : | |
731 | $(NOECHO) $(NOOP) | |
732 | MAKE_FRAG | |
733 | ||
734 | my $add_sign = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']); | |
735 | eval { maniadd({q{SIGNATURE} => q{Public-key signature (added by MakeMaker)}}) } | |
736 | or print "Could not add SIGNATURE to MANIFEST: $${'@'}\n" | |
737 | CODE | |
738 | ||
739 | return sprintf <<'MAKE_FRAG', $add_sign; | |
740 | signature_addtomanifest : | |
741 | $(NOECHO) $(ECHO) Adding SIGNATURE to MANIFEST | |
742 | $(NOECHO) %s | |
743 | MAKE_FRAG | |
744 | ||
745 | } | |
746 | ||
747 | ||
748 | =back | |
749 | ||
750 | =head2 Abstract methods | |
751 | ||
752 | Methods which cannot be made cross-platform and each subclass will | |
753 | have to do their own implementation. | |
754 | ||
755 | =over 4 | |
756 | ||
757 | =item oneliner | |
758 | ||
759 | my $oneliner = $MM->oneliner($perl_code); | |
760 | my $oneliner = $MM->oneliner($perl_code, \@switches); | |
761 | ||
762 | This will generate a perl one-liner safe for the particular platform | |
763 | you're on based on the given $perl_code and @switches (a -e is | |
764 | assumed) suitable for using in a make target. It will use the proper | |
765 | shell quoting and escapes. | |
766 | ||
767 | $(PERLRUN) will be used as perl. | |
768 | ||
769 | Any newlines in $perl_code will be escaped. Leading and trailing | |
770 | newlines will be stripped. Makes this idiom much easier: | |
771 | ||
772 | my $code = $MM->oneliner(<<'CODE', [...switches...]); | |
773 | some code here | |
774 | another line here | |
775 | CODE | |
776 | ||
777 | Usage might be something like: | |
778 | ||
779 | # an echo emulation | |
780 | $oneliner = $MM->oneliner('print "Foo\n"'); | |
781 | $make = '$oneliner > somefile'; | |
782 | ||
783 | All dollar signs must be doubled in the $perl_code if you expect them | |
784 | to be interpreted normally, otherwise it will be considered a make | |
785 | macro. Also remember to quote make macros else it might be used as a | |
786 | bareword. For example: | |
787 | ||
788 | # Assign the value of the $(VERSION_FROM) make macro to $vf. | |
789 | $oneliner = $MM->oneliner('$$vf = "$(VERSION_FROM)"'); | |
790 | ||
791 | Its currently very simple and may be expanded sometime in the figure | |
792 | to include more flexible code and switches. | |
793 | ||
794 | ||
795 | =item B<quote_literal> | |
796 | ||
797 | my $safe_text = $MM->quote_literal($text); | |
798 | ||
799 | This will quote $text so it is interpreted literally in the shell. | |
800 | ||
801 | For example, on Unix this would escape any single-quotes in $text and | |
802 | put single-quotes around the whole thing. | |
803 | ||
804 | ||
805 | =item B<escape_newlines> | |
806 | ||
807 | my $escaped_text = $MM->escape_newlines($text); | |
808 | ||
809 | Shell escapes newlines in $text. | |
810 | ||
811 | ||
812 | =item max_exec_len | |
813 | ||
814 | my $max_exec_len = $MM->max_exec_len; | |
815 | ||
816 | Calculates the maximum command size the OS can exec. Effectively, | |
817 | this is the max size of a shell command line. | |
818 | ||
819 | =for _private | |
820 | $self->{_MAX_EXEC_LEN} is set by this method, but only for testing purposes. | |
821 | ||
822 | =item B<init_others> | |
823 | ||
824 | $MM->init_others(); | |
825 | ||
826 | Initializes the macro definitions used by tools_other() and places them | |
827 | in the $MM object. | |
828 | ||
829 | If there is no description, its the same as the parameter to | |
830 | WriteMakefile() documented in ExtUtils::MakeMaker. | |
831 | ||
832 | Defines at least these macros. | |
833 | ||
834 | Macro Description | |
835 | ||
836 | NOOP Do nothing | |
837 | NOECHO Tell make not to display the command itself | |
838 | ||
839 | MAKEFILE | |
840 | FIRST_MAKEFILE | |
841 | MAKEFILE_OLD | |
842 | MAKE_APERL_FILE File used by MAKE_APERL | |
843 | ||
844 | SHELL Program used to run | |
845 | shell commands | |
846 | ||
847 | ECHO Print text adding a newline on the end | |
848 | RM_F Remove a file | |
849 | RM_RF Remove a directory | |
850 | TOUCH Update a file's timestamp | |
851 | TEST_F Test for a file's existence | |
852 | CP Copy a file | |
853 | MV Move a file | |
854 | CHMOD Change permissions on a | |
855 | file | |
856 | ||
857 | UMASK_NULL Nullify umask | |
858 | DEV_NULL Supress all command output | |
859 | ||
860 | =item init_DIRFILESEP | |
861 | ||
862 | $MM->init_DIRFILESEP; | |
863 | my $dirfilesep = $MM->{DIRFILESEP}; | |
864 | ||
865 | Initializes the DIRFILESEP macro which is the seperator between the | |
866 | directory and filename in a filepath. ie. / on Unix, \ on Win32 and | |
867 | nothing on VMS. | |
868 | ||
869 | For example: | |
870 | ||
871 | # instead of $(INST_ARCHAUTODIR)/extralibs.ld | |
872 | $(INST_ARCHAUTODIR)$(DIRFILESEP)extralibs.ld | |
873 | ||
874 | Something of a hack but it prevents a lot of code duplication between | |
875 | MM_* variants. | |
876 | ||
877 | Do not use this as a seperator between directories. Some operating | |
878 | systems use different seperators between subdirectories as between | |
879 | directories and filenames (for example: VOLUME:[dir1.dir2]file on VMS). | |
880 | ||
881 | =item init_linker | |
882 | ||
883 | $mm->init_linker; | |
884 | ||
885 | Initialize macros which have to do with linking. | |
886 | ||
887 | PERL_ARCHIVE: path to libperl.a equivalent to be linked to dynamic | |
888 | extensions. | |
889 | ||
890 | PERL_ARCHIVE_AFTER: path to a library which should be put on the | |
891 | linker command line I<after> the external libraries to be linked to | |
892 | dynamic extensions. This may be needed if the linker is one-pass, and | |
893 | Perl includes some overrides for C RTL functions, such as malloc(). | |
894 | ||
895 | EXPORT_LIST: name of a file that is passed to linker to define symbols | |
896 | to be exported. | |
897 | ||
898 | Some OSes do not need these in which case leave it blank. | |
899 | ||
900 | ||
901 | =item init_platform | |
902 | ||
903 | $mm->init_platform | |
904 | ||
905 | Initialize any macros which are for platform specific use only. | |
906 | ||
907 | A typical one is the version number of your OS specific mocule. | |
908 | (ie. MM_Unix_VERSION or MM_VMS_VERSION). | |
909 | ||
910 | =item platform_constants | |
911 | ||
912 | my $make_frag = $mm->platform_constants | |
913 | ||
914 | Returns a make fragment defining all the macros initialized in | |
915 | init_platform() rather than put them in constants(). | |
916 | ||
917 | =cut | |
918 | ||
919 | sub init_platform { | |
920 | return ''; | |
921 | } | |
922 | ||
923 | sub platform_constants { | |
924 | return ''; | |
925 | } | |
926 | ||
927 | =item os_flavor | |
928 | ||
929 | my @os_flavor = $mm->os_flavor; | |
930 | ||
931 | @os_flavor is the style of operating system this is, usually | |
932 | corresponding to the MM_*.pm file we're using. | |
933 | ||
934 | The first element of @os_flavor is the major family (ie. Unix, | |
935 | Windows, VMS, OS/2, etc...) and the rest are sub families. | |
936 | ||
937 | Some examples: | |
938 | ||
939 | Cygwin98 ('Unix', 'Cygwin', 'Cygwin9x') | |
940 | Windows NT ('Win32', 'WinNT') | |
941 | Win98 ('Win32', 'Win9x') | |
942 | Linux ('Unix', 'Linux') | |
943 | MacOS X ('Unix', 'Darwin', 'MacOS', 'MacOS X') | |
944 | OS/2 ('OS/2') | |
945 | ||
946 | This is used to write code for styles of operating system. | |
947 | See os_flavor_is() for use. | |
948 | ||
949 | ||
950 | =back | |
951 | ||
952 | =head1 AUTHOR | |
953 | ||
954 | Michael G Schwern <schwern@pobox.com> and the denizens of | |
955 | makemaker@perl.org with code from ExtUtils::MM_Unix and | |
956 | ExtUtils::MM_Win32. | |
957 | ||
958 | ||
959 | =cut | |
960 | ||
961 | 1; |