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