This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Upgrade to MakeMaker 6.13.
[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.06;
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_EXE_macro = $self->POD2MAN_EXE_macro();
330     my $manifypods_target = $self->manifypods_target();
331
332     return <<END_OF_TARGET;
333
334 # --- Begin manifypods section:
335 $POD2MAN_EXE_macro
336
337 $manifypods_target
338
339 # --- End manifypods section --- #
340
341 END_OF_TARGET
342
343 }
344
345
346 =item manifypods_target
347
348   my $manifypods_target = $self->manifypods_target;
349
350 Generates the manifypods target.  This target generates man pages from
351 all POD files in MAN1PODS and MAN3PODS.
352
353 =cut
354
355 sub manifypods_target {
356     my($self) = shift;
357
358     my $man1pods      = '';
359     my $man3pods      = '';
360     my $dependencies  = '';
361
362     # populate manXpods & dependencies:
363     foreach my $name (keys %{$self->{MAN1PODS}}, keys %{$self->{MAN3PODS}}) {
364         $dependencies .= " \\\n\t$name";
365     }
366
367     foreach my $name (keys %{$self->{MAN3PODS}}) {
368         $dependencies .= " \\\n\t$name"
369     }
370
371     my $manify = <<END;
372 manifypods : pure_all $dependencies
373 END
374
375     my @man_cmds;
376     foreach my $section (qw(1 3)) {
377         my $pods = $self->{"MAN${section}PODS"};
378         push @man_cmds, $self->split_command(<<CMD, %$pods);
379         \$(NOECHO) \$(POD2MAN_EXE) --section=$section --perm_rw=\$(PERM_RW)
380 CMD
381     }
382
383     $manify .= "\t\$(NOECHO) \$(NOOP)\n" unless @man_cmds;
384     $manify .= join '', map { "$_\n" } @man_cmds;
385
386     return $manify;
387 }
388
389
390 =item makemakerdflt_target
391
392   my $make_frag = $mm->makemakerdflt_target
393
394 Returns a make fragment with the makemakerdeflt_target specified.
395 This target is the first target in the Makefile, is the default target
396 and simply points off to 'all' just in case any make variant gets
397 confused or something gets snuck in before the real 'all' target.
398
399 =cut
400
401 sub makemakerdflt_target {
402     return <<'MAKE_FRAG';
403 makemakerdflt: all
404         $(NOECHO) $(NOOP)
405 MAKE_FRAG
406
407 }
408
409
410 =item special_targets
411
412   my $make_frag = $mm->special_targets
413
414 Returns a make fragment containing any targets which have special
415 meaning to make.  For example, .SUFFIXES and .PHONY.
416
417 =cut
418
419 sub special_targets {
420     my $make_frag = <<'MAKE_FRAG';
421 .SUFFIXES: .xs .c .C .cpp .i .s .cxx .cc $(OBJ_EXT)
422
423 .PHONY: all config static dynamic test linkext manifest
424
425 MAKE_FRAG
426
427     $make_frag .= <<'MAKE_FRAG' if $ENV{CLEARCASE_ROOT};
428 .NO_CONFIG_REC: Makefile
429
430 MAKE_FRAG
431
432     return $make_frag;
433 }
434
435 =item POD2MAN_EXE_macro
436
437   my $pod2man_exe_macro = $self->POD2MAN_EXE_macro
438
439 Returns a definition for the POD2MAN_EXE macro.  This is a program
440 which emulates the pod2man utility.  You can add more switches to the
441 command by simply appending them on the macro.
442
443 Typical usage:
444
445     $(POD2MAN_EXE) --section=3 --perm_rw=$(PERM_RW) podfile man_page
446
447 =cut
448
449 sub POD2MAN_EXE_macro {
450     my $self = shift;
451
452 # Need the trailing '--' so perl stops gobbling arguments and - happens
453 # to be an alternative end of line seperator on VMS so we quote it
454     return <<'END_OF_DEF';
455 POD2MAN_EXE = $(PERLRUN) "-MExtUtils::Command::MM" -e pod2man "--"
456 END_OF_DEF
457 }
458
459
460 =item test_via_harness
461
462   my $command = $mm->test_via_harness($perl, $tests);
463
464 Returns a $command line which runs the given set of $tests with
465 Test::Harness and the given $perl.
466
467 Used on the t/*.t files.
468
469 =cut
470
471 sub test_via_harness {
472     my($self, $perl, $tests) = @_;
473
474     return qq{\t$perl "-MExtUtils::Command::MM" }.
475            qq{"-e" "test_harness(\$(TEST_VERBOSE), '\$(INST_LIB)', '\$(INST_ARCHLIB)')" $tests\n};
476 }
477
478 =item test_via_script
479
480   my $command = $mm->test_via_script($perl, $script);
481
482 Returns a $command line which just runs a single test without
483 Test::Harness.  No checks are done on the results, they're just
484 printed.
485
486 Used for test.pl, since they don't always follow Test::Harness
487 formatting.
488
489 =cut
490
491 sub test_via_script {
492     my($self, $perl, $script) = @_;
493     return qq{\t$perl "-I\$(INST_LIB)" "-I\$(INST_ARCHLIB)" $script\n};
494 }
495
496 =item libscan
497
498   my $wanted = $self->libscan($path);
499
500 Takes a path to a file or dir and returns an empty string if we don't
501 want to include this file in the library.  Otherwise it returns the
502 the $path unchanged.
503
504 Mainly used to exclude RCS, CVS, and SCCS directories from
505 installation.
506
507 =cut
508
509 sub libscan {
510     my($self,$path) = @_;
511     my($dirs,$file) = ($self->splitpath($path))[1,2];
512     return '' if grep /^(?:RCS|CVS|SCCS|\.svn)$/, 
513                      $self->splitdir($dirs), $file;
514
515     return $path;
516 }
517
518 =item tool_autosplit
519
520 Defines a simple perl call that runs autosplit. May be deprecated by
521 pm_to_blib soon.
522
523 =cut
524
525 sub tool_autosplit {
526     my($self, %attribs) = @_;
527
528     my $maxlen = $attribs{MAXLEN} ? '$$AutoSplit::Maxlen=$attribs{MAXLEN};' 
529                                   : '';
530
531     my $asplit = $self->oneliner(sprintf <<'PERL_CODE', $maxlen);
532 use AutoSplit; %s autosplit($$ARGV[0], $$ARGV[1], 0, 1, 1)
533 PERL_CODE
534
535     return sprintf <<'MAKE_FRAG', $asplit;
536 # Usage: $(AUTOSPLITFILE) FileToSplit AutoDirToSplitInto
537 AUTOSPLITFILE = %s
538
539 MAKE_FRAG
540
541 }
542
543
544 =item all_target
545
546 Generate the default target 'all'.
547
548 =cut
549
550 sub all_target {
551     my $self = shift;
552
553     return <<'MAKE_EXT';
554 all :: pure_all
555         $(NOECHO) $(NOOP)
556 MAKE_EXT
557
558 }
559
560
561 =item metafile_target
562
563     my $target = $mm->metafile_target;
564
565 Generate the metafile target.
566
567 Writes the file META.yml, YAML encoded meta-data about the module.  The
568 format follows Module::Build's as closely as possible.  Additionally, we
569 include:
570
571     version_from
572     installdirs
573
574 =cut
575
576 sub metafile_target {
577     my $self = shift;
578
579     return <<'MAKE_FRAG' if $self->{NO_META};
580 metafile:
581         $(NOECHO) $(NOOP)
582 MAKE_FRAG
583
584     my $prereq_pm = '';
585     foreach my $mod ( sort { lc $a cmp lc $b } keys %{$self->{PREREQ_PM}} ) {
586         my $ver = $self->{PREREQ_PM}{$mod};
587         $prereq_pm .= sprintf "    %-30s %s\n", "$mod:", $ver;
588     }
589     
590     my $meta = <<YAML;
591 #XXXXXXX This is a prototype!!!  It will change in the future!!! XXXXX#
592 name:         $self->{DISTNAME}
593 version:      $self->{VERSION}
594 version_from: $self->{VERSION_FROM}
595 installdirs:  $self->{INSTALLDIRS}
596 requires:
597 $prereq_pm
598 distribution_type: module
599 generated_by: ExtUtils::MakeMaker version $ExtUtils::MakeMaker::VERSION
600 YAML
601
602     my @write_meta = $self->echo($meta, 'META.yml');
603     return sprintf <<'MAKE_FRAG', join "\n\t", @write_meta;
604 metafile :
605         %s
606 MAKE_FRAG
607
608 }
609
610
611 =item metafile_addtomanifest_target
612
613   my $target = $mm->metafile_addtomanifest_target
614
615 Adds the META.yml file to the MANIFEST.
616
617 =cut
618
619 sub metafile_addtomanifest_target {
620     my $self = shift;
621
622     return <<'MAKE_FRAG' if $self->{NO_META};
623 metafile_addtomanifest:
624         $(NOECHO) $(NOOP)
625 MAKE_FRAG
626
627     my $add_meta = $self->oneliner(<<'CODE', ['-MExtUtils::Manifest=maniadd']);
628 eval { maniadd({q{META.yml} => q{Module meta-data (added by MakeMaker)}}) } 
629     or print "Could not add META.yml to MANIFEST: $${'@'}\n"
630 CODE
631
632     return sprintf <<'MAKE_FRAG', $add_meta;
633 metafile_addtomanifest:
634         $(NOECHO) %s
635 MAKE_FRAG
636
637 }
638
639
640 =back
641
642 =head2 Abstract methods
643
644 Methods which cannot be made cross-platform and each subclass will
645 have to do their own implementation.
646
647 =over 4
648
649 =item oneliner
650
651   my $oneliner = $MM->oneliner($perl_code);
652   my $oneliner = $MM->oneliner($perl_code, \@switches);
653
654 This will generate a perl one-liner safe for the particular platform
655 you're on based on the given $perl_code and @switches (a -e is
656 assumed) suitable for using in a make target.  It will use the proper
657 shell quoting and escapes.
658
659 $(PERLRUN) will be used as perl.
660
661 Any newlines in $perl_code will be escaped.  Leading and trailing
662 newlines will be stripped.  Makes this idiom much easier:
663
664     my $code = $MM->oneliner(<<'CODE', [...switches...]);
665 some code here
666 another line here
667 CODE
668
669 Usage might be something like:
670
671     # an echo emulation
672     $oneliner = $MM->oneliner('print "Foo\n"');
673     $make = '$oneliner > somefile';
674
675 All dollar signs must be doubled in the $perl_code if you expect them
676 to be interpreted normally, otherwise it will be considered a make
677 macro.  Also remember to quote make macros else it might be used as a
678 bareword.  For example:
679
680     # Assign the value of the $(VERSION_FROM) make macro to $vf.
681     $oneliner = $MM->oneliner('$$vf = "$(VERSION_FROM)"');
682
683 Its currently very simple and may be expanded sometime in the figure
684 to include more flexible code and switches.
685
686
687 =item B<quote_literal>
688
689     my $safe_text = $MM->quote_literal($text);
690
691 This will quote $text so it is interpreted literally in the shell.
692
693 For example, on Unix this would escape any single-quotes in $text and
694 put single-quotes around the whole thing.
695
696
697 =item B<escape_newlines>
698
699     my $escaped_text = $MM->escape_newlines($text);
700
701 Shell escapes newlines in $text.
702
703
704 =item max_exec_len
705
706     my $max_exec_len = $MM->max_exec_len;
707
708 Calculates the maximum command size the OS can exec.  Effectively,
709 this is the max size of a shell command line.
710
711 =for _private
712 $self->{_MAX_EXEC_LEN} is set by this method, but only for testing purposes.
713
714 =item B<init_others>
715
716     $MM->init_others();
717
718 Initializes the macro definitions used by tools_other() and places them
719 in the $MM object.
720
721 If there is no description, its the same as the parameter to
722 WriteMakefile() documented in ExtUtils::MakeMaker.
723
724 Defines at least these macros.
725
726   Macro             Description
727
728   NOOP              Do nothing
729   NOECHO            Tell make not to display the command itself
730
731   MAKEFILE
732   FIRST_MAKEFILE
733   MAKEFILE_OLD
734   MAKE_APERL_FILE   File used by MAKE_APERL
735
736   SHELL             Program used to run
737                     shell commands
738
739   ECHO              Print text adding a newline on the end
740   RM_F              Remove a file 
741   RM_RF             Remove a directory          
742   TOUCH             Update a file's timestamp   
743   TEST_F            Test for a file's existence 
744   CP                Copy a file                 
745   MV                Move a file                 
746   CHMOD             Change permissions on a     
747                     file
748
749   UMASK_NULL        Nullify umask
750   DEV_NULL          Supress all command output
751
752 =item init_DIRFILESEP
753
754   $MM->init_DIRFILESEP;
755   my $dirfilesep = $MM->{DIRFILESEP};
756
757 Initializes the DIRFILESEP macro which is the seperator between the
758 directory and filename in a filepath.  ie. / on Unix, \ on Win32 and
759 nothing on VMS.
760
761 For example:
762
763     # instead of $(INST_ARCHAUTODIR)/extralibs.ld
764     $(INST_ARCHAUTODIR)$(DIRFILESEP)extralibs.ld
765
766 Something of a hack but it prevents a lot of code duplication between
767 MM_* variants.
768
769 Do not use this as a seperator between directories.  Some operating
770 systems use different seperators between subdirectories as between
771 directories and filenames (for example:  VOLUME:[dir1.dir2]file on VMS).
772
773 =item init_linker
774
775     $mm->init_linker;
776
777 Initialize macros which have to do with linking.
778
779 PERL_ARCHIVE: path to libperl.a equivalent to be linked to dynamic
780 extensions.
781
782 PERL_ARCHIVE_AFTER: path to a library which should be put on the
783 linker command line I<after> the external libraries to be linked to
784 dynamic extensions.  This may be needed if the linker is one-pass, and
785 Perl includes some overrides for C RTL functions, such as malloc().
786
787 EXPORT_LIST: name of a file that is passed to linker to define symbols
788 to be exported.
789
790 Some OSes do not need these in which case leave it blank.
791
792
793 =item init_platform
794
795     $mm->init_platform
796
797 Initialize any macros which are for platform specific use only.
798
799 A typical one is the version number of your OS specific mocule.
800 (ie. MM_Unix_VERSION or MM_VMS_VERSION).
801
802 =item platform_constants
803
804     my $make_frag = $mm->platform_constants
805
806 Returns a make fragment defining all the macros initialized in
807 init_platform() rather than put them in constants().
808
809 =cut
810
811 sub init_platform {
812     return '';
813 }
814
815 sub platform_constants {
816     return '';
817 }
818
819 =item os_flavor
820
821     my @os_flavor = $mm->os_flavor;
822
823 @os_flavor is the style of operating system this is, usually
824 corresponding to the MM_*.pm file we're using.  
825
826 The first element of @os_flavor is the major family (ie. Unix,
827 Windows, VMS, OS/2, MacOS, etc...) and the rest are sub families.
828
829 Some examples:
830
831     Cygwin98       ('Unix',  'Cygwin', 'Cygwin9x')
832     Windows NT     ('Win32', 'WinNT')
833     Win98          ('Win32', 'Win9x')
834     Linux          ('Unix',  'Linux')
835     MacOS Classic  ('MacOS', 'MacOS Classic')
836     MacOS X        ('Unix',  'Darwin', 'MacOS', 'MacOS X')
837     OS/2           ('OS/2')
838
839 This is used to write code for styles of operating system.  
840 See os_flavor_is() for use.
841
842
843 =back
844
845 =head1 AUTHOR
846
847 Michael G Schwern <schwern@pobox.com> and the denizens of
848 makemaker@perl.org with code from ExtUtils::MM_Unix and
849 ExtUtils::MM_Win32.
850
851
852 =cut
853
854 1;