macos/configpm

   1 #!./miniperl -w
   2
   3 # commonly used names to put first (and hence lookup fastest)
   4 my %Common = map {($_,$_)}
   5              qw(archname osname osvers prefix libs libpth
   6                 dynamic_ext static_ext dlsrc so
   7                 cc ccflags cppflags
   8                 privlibexp archlibexp installprivlib installarchlib
   9                 sharpbang startsh shsharp
  10                );
  11
  12 # names of things which may need to have slashes changed to double-colons
  13 my %Extensions = map {($_,$_)}
  14                  qw(dynamic_ext static_ext extensions known_extensions);
  15
  16 # allowed opts as well as specifies default and initial values
  17 my %Allowed_Opts = (
  18     'cross'    => '', # --cross=PALTFORM - crosscompiling for PLATFORM
  19     'glossary' => 1,  # --no-glossary  - no glossary file inclusion,
  20                       #                  for compactness
  21 );
  22
  23 sub opts {
  24     # user specified options
  25     my %given_opts = (
  26         # --opt=smth
  27         (map {/^--([\-_\w]+)=(.*)$/} @ARGV),
  28         # --opt --no-opt --noopt
  29         (map {/^no-?(.*)$/i?($1=>0):($_=>1)} map {/^--([\-_\w]+)$/} @ARGV),
  30     );
  31
  32     my %opts = (%Allowed_Opts, %given_opts);
  33
  34     for my $opt (grep {!exists $Allowed_Opts{$_}} keys %given_opts) {
  35         die "option '$opt' is not recognized";
  36     }
  37     @ARGV = grep {!/^--/} @ARGV;
  38
  39     return %opts;
  40 }
  41
  42
  43 my %Opts = opts();
  44
  45 my $Config_PM;
  46 my $Glossary = $ARGV[1] || ($^O eq 'MacOS' ? '::Porting:Glossary' : 'Porting/Glossary');
  47
  48 if ($Opts{cross}) {
  49   # creating cross-platform config file
  50   mkdir "xlib";
  51   mkdir "xlib/$Opts{cross}";
  52   $Config_PM = $ARGV[0] || "xlib/$Opts{cross}/Config.pm";
  53 }
  54 else {
  55   $Config_PM = $ARGV[0] || ($^O eq 'MacOS' ? ':lib:Config.pm' : 'lib/Config.pm');
  56 }
  57
  58
  59 open CONFIG, ">$Config_PM" or die "Can't open $Config_PM: $!\n";
  60
  61 my $myver = sprintf "v%vd", $^V;
  62
  63 printf CONFIG <<'ENDOFBEG', ($myver) x 3;
  64 # This file was created by configpm when Perl was built. Any changes
  65 # made to this file will be lost the next time perl is built.
  66
  67 package Config;
  68 @EXPORT = qw(%%Config);
  69 @EXPORT_OK = qw(myconfig config_sh config_vars config_re);
  70
  71 my %%Export_Cache = map {($_ => 1)} (@EXPORT, @EXPORT_OK);
  72
  73 # Define our own import method to avoid pulling in the full Exporter:
  74 sub import {
  75     my $pkg = shift;
  76     @_ = @EXPORT unless @_;
  77
  78     my @funcs = grep $_ ne '%%Config', @_;
  79     my $export_Config = @funcs < @_ ? 1 : 0;
  80
  81     my $callpkg = caller(0);
  82     foreach my $func (@funcs) {
  83         die sprintf qq{"%%s" is not exported by the %%s module\n},
  84             $func, __PACKAGE__ unless $Export_Cache{$func};
  85         *{$callpkg.'::'.$func} = \&{$func};
  86     }
  87
  88     *{"$callpkg\::Config"} = \%%Config if $export_Config;
  89     return;
  90 }
  91
  92 die "Perl lib version (%s) doesn't match executable version ($])"
  93     unless $^V;
  94
  95 $^V eq %s
  96     or die "Perl lib version (%s) doesn't match executable version (" .
  97         sprintf("v%%vd",$^V) . ")";
  98
  99 ENDOFBEG
 100
 101
 102 my @non_v    = ();
 103 my @v_fast   = ();
 104 my %v_fast   = ();
 105 my @v_others = ();
 106 my $in_v     = 0;
 107 my %Data     = ();
 108
 109 # This is somewhat grim, but I want the code for parsing config.sh here and
 110 # now so that I can expand $Config{ivsize} and $Config{ivtype}
 111
 112 my $fetch_string = <<'EOT';
 113
 114 # Search for it in the big string
 115 sub fetch_string {
 116     my($self, $key) = @_;
 117
 118     my $quote_type = "'";
 119     my $marker = "$key=";
 120
 121     # Check for the common case, ' delimited
 122     my $start = index($Config_SH, "\n$marker$quote_type");
 123     # If that failed, check for " delimited
 124     if ($start == -1) {
 125         $quote_type = '"';
 126         $start = index($Config_SH, "\n$marker$quote_type");
 127     }
 128     return undef if ( ($start == -1) &&  # in case it's first
 129                       (substr($Config_SH, 0, length($marker)) ne $marker) );
 130     if ($start == -1) {
 131         # It's the very first thing we found. Skip $start forward
 132         # and figure out the quote mark after the =.
 133         $start = length($marker) + 1;
 134         $quote_type = substr($Config_SH, $start - 1, 1);
 135     }
 136     else {
 137         $start += length($marker) + 2;
 138     }
 139
 140     my $value = substr($Config_SH, $start,
 141                        index($Config_SH, "$quote_type\n", $start) - $start);
 142
 143     # If we had a double-quote, we'd better eval it so escape
 144     # sequences and such can be interpolated. Since the incoming
 145     # value is supposed to follow shell rules and not perl rules,
 146     # we escape any perl variable markers
 147     if ($quote_type eq '"') {
 148         $value =~ s/\$/\\\$/g;
 149         $value =~ s/\@/\\\@/g;
 150         eval "\$value = \"$value\"";
 151     }
 152
 153     # So we can say "if $Config{'foo'}".
 154     $value = undef if $value eq 'undef';
 155     $self->{$key} = $value; # cache it
 156 }
 157 EOT
 158
 159 eval $fetch_string;
 160 die if $@;
 161
 162 open(CONFIG_SH, 'config.sh') || die "Can't open config.sh: $!";
 163 while (<CONFIG_SH>) {
 164     next if m:^#!/bin/sh:;
 165
 166     # Catch PERL_CONFIG_SH=true and PERL_VERSION=n line from Configure.
 167     s/^(\w+)=(true|\d+)\s*$/$1='$2'\n/ or m/^(\w+)='(.*)'$/;
 168     my($k, $v) = ($1, $2);
 169
 170     # grandfather PATCHLEVEL and SUBVERSION and CONFIG
 171     if ($k) {
 172         if ($k eq 'PERL_VERSION') {
 173             push @v_others, "PATCHLEVEL='$v'\n";
 174         }
 175         elsif ($k eq 'PERL_SUBVERSION') {
 176             push @v_others, "SUBVERSION='$v'\n";
 177         }
 178         elsif ($k eq 'PERL_CONFIG_SH') {
 179             push @v_others, "CONFIG='$v'\n";
 180         }
 181     }
 182
 183     # We can delimit things in config.sh with either ' or ".
 184     unless ($in_v or m/^(\w+)=(['"])(.*\n)/){
 185         push(@non_v, "#$_"); # not a name='value' line
 186         next;
 187     }
 188     $quote = $2;
 189     if ($in_v) {
 190         $val .= $_;
 191     }
 192     else {
 193         ($name,$val) = ($1,$3);
 194     }
 195     $in_v = $val !~ /$quote\n/;
 196     next if $in_v;
 197
 198     s,/,::,g if $Extensions{$name};
 199
 200     $val =~ s/$quote\n?\z//;
 201
 202     my $line = "$name=$quote$val$quote\n";
 203     if (!$Common{$name}){
 204         push(@v_others, $line);
 205     }
 206     else {
 207         push(@v_fast, $line);
 208         $v_fast{$name} = "'$name' => $quote$val$quote";
 209     }
 210 }
 211 close CONFIG_SH;
 212
 213 print CONFIG @non_v, "\n";
 214
 215 # copy config summary format from the myconfig.SH script
 216 print CONFIG "my \$summary = <<'!END!';\n";
 217
 218 open(MYCONFIG, ($^O eq 'MacOS' ? "<::myconfig.SH" : "<myconfig.SH"))
 219         || die "open myconfig.SH failed: $!";
 220 1 while defined($_ = <MYCONFIG>) && !/^Summary of/;
 221 do { print CONFIG $_ } until !defined($_ = <MYCONFIG>) || /^\s*$/;
 222 close(MYCONFIG);
 223
 224 print CONFIG "\n!END!\n", <<'EOT';
 225 my $summary_expanded = 0;
 226
 227 sub myconfig {
 228     return $summary if $summary_expanded;
 229     $summary =~ s{\$(\w+)}
 230                  { my $c = $Config{$1}; defined($c) ? $c : 'undef' }ge;
 231     $summary_expanded = 1;
 232     $summary;
 233 }
 234
 235 our $Config_SH : unique = <<'!END!';
 236 EOT
 237
 238 print CONFIG join("", @v_fast, sort @v_others);
 239
 240 print CONFIG "!END!\n", $fetch_string;
 241
 242 print CONFIG <<'ENDOFEND';
 243
 244 sub fetch_virtual {
 245     my($self, $key) = @_;
 246
 247     my $value;
 248
 249     if ($key =~ /^((?:cc|ld)flags|libs(?:wanted)?)_nolargefiles/) {
 250         # These are purely virtual, they do not exist, but need to
 251         # be computed on demand for largefile-incapable extensions.
 252         my $new_key = "${1}_uselargefiles";
 253         $value = $Config{$1};
 254         my $withlargefiles = $Config{$new_key};
 255         if ($new_key =~ /^(?:cc|ld)flags_/) {
 256             $value =~ s/\Q$withlargefiles\E\b//;
 257         } elsif ($new_key =~ /^libs/) {
 258             my @lflibswanted = split(' ', $Config{libswanted_uselargefiles});
 259             if (@lflibswanted) {
 260                 my %lflibswanted;
 261                 @lflibswanted{@lflibswanted} = ();
 262                 if ($new_key =~ /^libs_/) {
 263                     my @libs = grep { /^-l(.+)/ &&
 264                                       not exists $lflibswanted{$1} }
 265                                     split(' ', $Config{libs});
 266                     $Config{libs} = join(' ', @libs);
 267                 } elsif ($new_key =~ /^libswanted_/) {
 268                     my @libswanted = grep { not exists $lflibswanted{$_} }
 269                                           split(' ', $Config{libswanted});
 270                     $Config{libswanted} = join(' ', @libswanted);
 271                 }
 272             }
 273         }
 274     }
 275
 276     $self->{$key} = $value;
 277 }
 278
 279 sub FETCH {
 280     my($self, $key) = @_;
 281
 282     # check for cached value (which may be undef so we use exists not defined)
 283     return $self->{$key} if exists $self->{$key};
 284
 285     $self->fetch_string($key);
 286     return $self->{$key} if exists $self->{$key};
 287     $self->fetch_virtual($key);
 288
 289     # Might not exist, in which undef is correct.
 290     return $self->{$key};
 291 }
 292
 293 my $prevpos = 0;
 294
 295 sub FIRSTKEY {
 296     $prevpos = 0;
 297     substr($Config_SH, 0, index($Config_SH, '=') );
 298 }
 299
 300 sub NEXTKEY {
 301     # Find out how the current key's quoted so we can skip to its end.
 302     my $quote = substr($Config_SH, index($Config_SH, "=", $prevpos)+1, 1);
 303     my $pos = index($Config_SH, qq($quote\n), $prevpos) + 2;
 304     my $len = index($Config_SH, "=", $pos) - $pos;
 305     $prevpos = $pos;
 306     $len > 0 ? substr($Config_SH, $pos, $len) : undef;
 307 }
 308
 309 sub EXISTS {
 310     return 1 if exists($_[0]->{$_[1]});
 311
 312     return(index($Config_SH, "\n$_[1]='") != -1 or
 313            substr($Config_SH, 0, length($_[1])+2) eq "$_[1]='" or
 314            index($Config_SH, "\n$_[1]=\"") != -1 or
 315            substr($Config_SH, 0, length($_[1])+2) eq "$_[1]=\"" or
 316            $_[1] =~ /^(?:(?:cc|ld)flags|libs(?:wanted)?)_nolargefiles$/
 317           );
 318 }
 319
 320 sub STORE  { die "\%Config::Config is read-only\n" }
 321 *DELETE = \&STORE;
 322 *CLEAR  = \&STORE;
 323
 324
 325 sub config_sh {
 326     $Config_SH
 327 }
 328
 329 sub config_re {
 330     my $re = shift;
 331     return map { chomp; $_ } grep /^$re=/, split /^/, $Config_SH;
 332 }
 333
 334 sub config_vars {
 335     foreach (@_) {
 336         if (/\W/) {
 337             my @matches = config_re($_);
 338             print map "$_\n", @matches ? @matches : "$_: not found";
 339         } else {
 340             my $v = (exists $Config{$_}) ? $Config{$_} : 'UNKNOWN';
 341             $v = 'undef' unless defined $v;
 342             print "$_='$v';\n";
 343         }
 344     }
 345 }
 346
 347 ENDOFEND
 348
 349 if ($^O eq 'os2') {
 350     print CONFIG <<'ENDOFSET';
 351 my %preconfig;
 352 if ($OS2::is_aout) {
 353     my ($value, $v) = $Config_SH =~ m/^used_aout='(.*)'\s*$/m;
 354     for (split ' ', $value) {
 355         ($v) = $Config_SH =~ m/^aout_$_='(.*)'\s*$/m;
 356         $preconfig{$_} = $v eq 'undef' ? undef : $v;
 357     }
 358 }
 359 $preconfig{d_fork} = undef unless $OS2::can_fork; # Some funny cases can't
 360 sub TIEHASH { bless {%preconfig} }
 361 ENDOFSET
 362     # Extract the name of the DLL from the makefile to avoid duplication
 363     my ($f) = grep -r, qw(GNUMakefile Makefile);
 364     my $dll;
 365     if (open my $fh, '<', $f) {
 366         while (<$fh>) {
 367             $dll = $1, last if /^PERL_DLL_BASE\s*=\s*(\S*)\s*$/;
 368         }
 369     }
 370     print CONFIG <<ENDOFSET if $dll;
 371 \$preconfig{dll_name} = '$dll';
 372 ENDOFSET
 373 } elsif ($^O eq 'MacOS') {
 374   print CONFIG <<'ENDOFSET';
 375 my %preconfig;
 376 {
 377         local $^W;
 378         my $inst = ($ENV{MACPERL} || "") . "site_perl:";
 379         my $arch = $MacPerl::Architecture || "";
 380         my $cc   = $MacPerl::Compiler || "";
 381
 382         %preconfig = (
 383                 installsitelib          => $inst,
 384                 installsitearch         => "$inst$arch:",
 385                 archname                => $arch,
 386                 myarchname              => $arch,
 387                 cc                      => $cc,
 388         );
 389 }
 390
 391 sub TIEHASH { bless { %preconfig } }
 392 ENDOFSET
 393 } else {
 394     print CONFIG <<'ENDOFSET';
 395 sub TIEHASH {
 396     bless $_[1], $_[0];
 397 }
 398 ENDOFSET
 399 }
 400
 401
 402 # Calculation for the keys for byteorder
 403 # This is somewhat grim, but I need to run fetch_string here.
 404 our $Config_SH = join "\n", @v_fast, @v_others;
 405
 406 my $t = fetch_string ({}, 'ivtype');
 407 my $s = fetch_string ({}, 'ivsize');
 408
 409 # byteorder does exist on its own but we overlay a virtual
 410 # dynamically recomputed value.
 411
 412 # However, ivtype and ivsize will not vary for sane fat binaries
 413
 414 my $f = $t eq 'long' ? 'L!' : $s == 8 ? 'Q': 'I';
 415
 416 my $byteorder_code;
 417 if ($s == 4 || $s == 8) {
 418     my $list = join ',', reverse(2..$s);
 419     my $format = 'a'x$s;
 420     $byteorder_code = <<"EOT";
 421 my \$i = 0;
 422 foreach my \$c ($list) { \$i |= ord(\$c); \$i <<= 8 }
 423 \$i |= ord(1);
 424 my \$value = join('', unpack('$format', pack('$f', \$i)));
 425 EOT
 426 } else {
 427     $byteorder_code = "\$value = '?'x$s;\n";
 428 }
 429
 430 my $fast_config = join '', map { "    $_,\n" }
 431     values (%v_fast), 'byteorder => $value' ;
 432
 433 print CONFIG sprintf <<'ENDOFTIE', $byteorder_code, $fast_config;
 434
 435 # avoid Config..Exporter..UNIVERSAL search for DESTROY then AUTOLOAD
 436 sub DESTROY { }
 437
 438 %s
 439
 440 tie %%Config, 'Config', {
 441 %s
 442 };
 443
 444 1;
 445 ENDOFTIE
 446
 447
 448 my $podfile = $^O eq 'MacOS' ? '::lib:Config.pod' : 'lib/Config.pod';
 449 open(CONFIG_POD, ">$podfile") or die "Can't open $podfile: $!";
 450 print CONFIG_POD <<'ENDOFTAIL';
 451 =head1 NAME
 452
 453 Config - access Perl configuration information
 454
 455 =head1 SYNOPSIS
 456
 457     use Config;
 458     if ($Config{'cc'} =~ /gcc/) {
 459         print "built by gcc\n";
 460     }
 461
 462     use Config qw(myconfig config_sh config_vars config_re);
 463
 464     print myconfig();
 465
 466     print config_sh();
 467
 468     print config_re();
 469
 470     config_vars(qw(osname archname));
 471
 472
 473 =head1 DESCRIPTION
 474
 475 The Config module contains all the information that was available to
 476 the C<Configure> program at Perl build time (over 900 values).
 477
 478 Shell variables from the F<config.sh> file (written by Configure) are
 479 stored in the readonly-variable C<%Config>, indexed by their names.
 480
 481 Values stored in config.sh as 'undef' are returned as undefined
 482 values.  The perl C<exists> function can be used to check if a
 483 named variable exists.
 484
 485 =over 4
 486
 487 =item myconfig()
 488
 489 Returns a textual summary of the major perl configuration values.
 490 See also C<-V> in L<perlrun/Switches>.
 491
 492 =item config_sh()
 493
 494 Returns the entire perl configuration information in the form of the
 495 original config.sh shell variable assignment script.
 496
 497 =item config_re($regex)
 498
 499 Like config_sh() but returns, as a list, only the config entries who's
 500 names match the $regex.
 501
 502 =item config_vars(@names)
 503
 504 Prints to STDOUT the values of the named configuration variable. Each is
 505 printed on a separate line in the form:
 506
 507   name='value';
 508
 509 Names which are unknown are output as C<name='UNKNOWN';>.
 510 See also C<-V:name> in L<perlrun/Switches>.
 511
 512 =back
 513
 514 =head1 EXAMPLE
 515
 516 Here's a more sophisticated example of using %Config:
 517
 518     use Config;
 519     use strict;
 520
 521     my %sig_num;
 522     my @sig_name;
 523     unless($Config{sig_name} && $Config{sig_num}) {
 524         die "No sigs?";
 525     } else {
 526         my @names = split ' ', $Config{sig_name};
 527         @sig_num{@names} = split ' ', $Config{sig_num};
 528         foreach (@names) {
 529             $sig_name[$sig_num{$_}] ||= $_;
 530         }
 531     }
 532
 533     print "signal #17 = $sig_name[17]\n";
 534     if ($sig_num{ALRM}) {
 535         print "SIGALRM is $sig_num{ALRM}\n";
 536     }
 537
 538 =head1 WARNING
 539
 540 Because this information is not stored within the perl executable
 541 itself it is possible (but unlikely) that the information does not
 542 relate to the actual perl binary which is being used to access it.
 543
 544 The Config module is installed into the architecture and version
 545 specific library directory ($Config{installarchlib}) and it checks the
 546 perl version number when loaded.
 547
 548 The values stored in config.sh may be either single-quoted or
 549 double-quoted. Double-quoted strings are handy for those cases where you
 550 need to include escape sequences in the strings. To avoid runtime variable
 551 interpolation, any C<$> and C<@> characters are replaced by C<\$> and
 552 C<\@>, respectively. This isn't foolproof, of course, so don't embed C<\$>
 553 or C<\@> in double-quoted strings unless you're willing to deal with the
 554 consequences. (The slashes will end up escaped and the C<$> or C<@> will
 555 trigger variable interpolation)
 556
 557 =head1 GLOSSARY
 558
 559 Most C<Config> variables are determined by the C<Configure> script
 560 on platforms supported by it (which is most UNIX platforms).  Some
 561 platforms have custom-made C<Config> variables, and may thus not have
 562 some of the variables described below, or may have extraneous variables
 563 specific to that particular port.  See the port specific documentation
 564 in such cases.
 565
 566 ENDOFTAIL
 567
 568 if ($Opts{glossary}) {
 569   open(GLOS, "<$Glossary") or die "Can't open $Glossary: $!";
 570 }
 571 %seen = ();
 572 $text = 0;
 573 $/ = '';
 574
 575 sub process {
 576   if (s/\A(\w*)\s+\(([\w.]+)\):\s*\n(\t?)/=item C<$1>\n\nFrom F<$2>:\n\n/m) {
 577     my $c = substr $1, 0, 1;
 578     unless ($seen{$c}++) {
 579       print CONFIG_POD <<EOF if $text;
 580 =back
 581
 582 EOF
 583       print CONFIG_POD <<EOF;
 584 =head2 $c
 585
 586 =over 4
 587
 588 EOF
 589      $text = 1;
 590     }
 591   }
 592   elsif (!$text || !/\A\t/) {
 593     warn "Expected a Configure variable header",
 594       ($text ? " or another paragraph of description" : () );
 595   }
 596   s/n't/n\00t/g;                # leave can't, won't etc untouched
 597   s/^\t\s+(.*)/\n$1/gm;         # Indented lines ===> new paragraph
 598   s/^(?<!\n\n)\t(.*)/$1/gm;     # Not indented lines ===> text
 599   s{([\'\"])(?=[^\'\"\s]*[./][^\'\"\s]*\1)([^\'\"\s]+)\1}(F<$2>)g; # '.o'
 600   s{([\'\"])([^\'\"\s]+)\1}(C<$2>)g; # "date" command
 601   s{\'([A-Za-z_\- *=/]+)\'}(C<$1>)g; # 'ln -s'
 602   s{
 603      (?<! [\w./<\'\"] )         # Only standalone file names
 604      (?! e \. g \. )            # Not e.g.
 605      (?! \. \. \. )             # Not ...
 606      (?! \d )                   # Not 5.004
 607      (?! read/ )                # Not read/write
 608      (?! etc\. )                # Not etc.
 609      (?! I/O )                  # Not I/O
 610      (
 611         \$ ?                    # Allow leading $
 612         [\w./]* [./] [\w./]*    # Require . or / inside
 613      )
 614      (?<! \. (?= [\s)] ) )      # Do not include trailing dot
 615      (?! [\w/] )                # Include all of it
 616    }
 617    (F<$1>)xg;                   # /usr/local
 618   s/((?<=\s)~\w*)/F<$1>/g;      # ~name
 619   s/(?<![.<\'\"])\b([A-Z_]{2,})\b(?![\'\"])/C<$1>/g;    # UNISTD
 620   s/(?<![.<\'\"])\b(?!the\b)(\w+)\s+macro\b/C<$1> macro/g; # FILE_cnt macro
 621   s/n[\0]t/n't/g;               # undo can't, won't damage
 622 }
 623
 624 if ($Opts{glossary}) {
 625     <GLOS>;                             # Skip the "DO NOT EDIT"
 626     <GLOS>;                             # Skip the preamble
 627   while (<GLOS>) {
 628     process;
 629     print CONFIG_POD;
 630   }
 631 }
 632
 633 print CONFIG_POD <<'ENDOFTAIL';
 634
 635 =back
 636
 637 =head1 NOTE
 638
 639 This module contains a good example of how to use tie to implement a
 640 cache and an example of how to make a tied variable readonly to those
 641 outside of it.
 642
 643 =cut
 644
 645 ENDOFTAIL
 646
 647 close(CONFIG);
 648 close(GLOS);
 649 close(CONFIG_POD);
 650
 651 # Now create Cross.pm if needed
 652 if ($Opts{cross}) {
 653   open CROSS, ">lib/Cross.pm" or die "Can not open >lib/Cross.pm: $!";
 654   my $cross = <<'EOS';
 655 # typical invocation:
 656 #   perl -MCross Makefile.PL
 657 #   perl -MCross=wince -V:cc
 658 package Cross;
 659
 660 sub import {
 661   my ($package,$platform) = @_;
 662   unless (defined $platform) {
 663     # if $platform is not specified, then use last one when
 664     # 'configpm; was invoked with --cross option
 665     $platform = '***replace-marker***';
 666   }
 667   @INC = map {/\blib\b/?(do{local $_=$_;s/\blib\b/xlib\/$platform/;$_},$_):($_)} @INC;
 668   $::Cross::platform = $platform;
 669 }
 670
 671 1;
 672 EOS
 673   $cross =~ s/\*\*\*replace-marker\*\*\*/$Opts{cross}/g;
 674   print CROSS $cross;
 675   close CROSS;
 676 }
 677
 678 # Now do some simple tests on the Config.pm file we have created
 679 unshift(@INC,'lib');
 680 require $Config_PM;
 681 import Config;
 682
 683 die "$0: $Config_PM not valid"
 684         unless $Config{'PERL_CONFIG_SH'} eq 'true';
 685
 686 die "$0: error processing $Config_PM"
 687         if defined($Config{'an impossible name'})
 688         or $Config{'PERL_CONFIG_SH'} ne 'true' # test cache
 689         ;
 690
 691 die "$0: error processing $Config_PM"
 692         if eval '$Config{"cc"} = 1'
 693         or eval 'delete $Config{"cc"}'
 694         ;
 695
 696
 697 exit 0;