Configure

   1 #! /usr/bin/env perl
   2 # -*- mode: perl; -*-
   3 # Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
   4 #
   5 # Licensed under the Apache License 2.0 (the "License").  You may not use
   6 # this file except in compliance with the License.  You can obtain a copy
   7 # in the file LICENSE in the source distribution or at
   8 # https://www.openssl.org/source/license.html
   9
  10 ##  Configure -- OpenSSL source tree configuration script
  11
  12 use 5.10.0;
  13 use strict;
  14 use Config;
  15 use FindBin;
  16 use lib "$FindBin::Bin/util/perl";
  17 use File::Basename;
  18 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs splitdir/;
  19 use File::Path qw/mkpath/;
  20 use OpenSSL::fallback "$FindBin::Bin/external/perl/MODULES.txt";
  21 use OpenSSL::Glob;
  22 use OpenSSL::Template;
  23
  24 # see INSTALL for instructions.
  25
  26 my $orig_death_handler = $SIG{__DIE__};
  27 $SIG{__DIE__} = \&death_handler;
  28
  29 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
  30
  31 # Options:
  32 #
  33 # --config      add the given configuration file, which will be read after
  34 #               any "Configurations*" files that are found in the same
  35 #               directory as this script.
  36 # --prefix      prefix for the OpenSSL installation, which includes the
  37 #               directories bin, lib, include, share/man, share/doc/openssl
  38 #               This becomes the value of INSTALLTOP in Makefile
  39 #               (Default: /usr/local)
  40 # --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
  41 #               If it's a relative directory, it will be added on the directory
  42 #               given with --prefix.
  43 #               This becomes the value of OPENSSLDIR in Makefile and in C.
  44 #               (Default: PREFIX/ssl)
  45 #
  46 # --cross-compile-prefix Add specified prefix to binutils components.
  47 #
  48 # --api         One of 0.9.8, 1.0.0, 1.0.1, 1.0.2, 1.1.0, 1.1.1, or 3.0
  49 #               Define the public APIs as they were for that version
  50 #               including patch releases.  If 'no-deprecated' is also
  51 #               given, do not compile support for interfaces deprecated
  52 #               up to and including the specified OpenSSL version.
  53 #
  54 # no-hw-xxx     do not compile support for specific crypto hardware.
  55 #               Generic OpenSSL-style methods relating to this support
  56 #               are always compiled but return NULL if the hardware
  57 #               support isn't compiled.
  58 # no-hw         do not compile support for any crypto hardware.
  59 # [no-]threads  [don't] try to create a library that is suitable for
  60 #               multithreaded applications (default is "threads" if we
  61 #               know how to do it)
  62 # [no-]shared   [don't] try to create shared libraries when supported.
  63 # [no-]pic      [don't] try to build position independent code when supported.
  64 #               If disabled, it also disables shared and dynamic-engine.
  65 # no-asm        do not use assembler
  66 # no-egd        do not compile support for the entropy-gathering daemon APIs
  67 # [no-]zlib     [don't] compile support for zlib compression.
  68 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
  69 #               library and will be loaded in run-time by the OpenSSL library.
  70 # sctp          include SCTP support
  71 # no-uplink     Don't build support for UPLINK interface.
  72 # enable-weak-ssl-ciphers
  73 #               Enable weak ciphers that are disabled by default.
  74 # 386           generate 80386 code in assembly modules
  75 # no-sse2       disables IA-32 SSE2 code in assembly modules, the above
  76 #               mentioned '386' option implies this one
  77 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
  78 # -<xxx> +<xxx> All options which are unknown to the 'Configure' script are
  79 # /<xxx>        passed through to the compiler. Unix-style options beginning
  80 #               with a '-' or '+' are recognized, as well as Windows-style
  81 #               options beginning with a '/'. If the option contains arguments
  82 #               separated by spaces, then the URL-style notation %20 can be
  83 #               used for the space character in order to avoid having to quote
  84 #               the option. For example, -opt%20arg gets expanded to -opt arg.
  85 #               In fact, any ASCII character can be encoded as %xx using its
  86 #               hexadecimal encoding.
  87 # -static       while -static is also a pass-through compiler option (and
  88 #               as such is limited to environments where it's actually
  89 #               meaningful), it triggers a number configuration options,
  90 #               namely no-pic, no-shared and no-threads. It is
  91 #               argued that the only reason to produce statically linked
  92 #               binaries (and in context it means executables linked with
  93 #               -static flag, and not just executables linked with static
  94 #               libcrypto.a) is to eliminate dependency on specific run-time,
  95 #               a.k.a. libc version. The mentioned config options are meant
  96 #               to achieve just that. Unfortunately on Linux it's impossible
  97 #               to eliminate the dependency completely for openssl executable
  98 #               because of getaddrinfo and gethostbyname calls, which can
  99 #               invoke dynamically loadable library facility anyway to meet
 100 #               the lookup requests. For this reason on Linux statically
 101 #               linked openssl executable has rather debugging value than
 102 #               production quality.
 103 #
 104 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
 105 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
 106 # Following are set automatically by this script
 107 #
 108 # MD5_ASM       use some extra md5 assembler,
 109 # SHA1_ASM      use some extra sha1 assembler, must define L_ENDIAN for x86
 110 # RMD160_ASM    use some extra ripemd160 assembler,
 111 # SHA256_ASM    sha256_block is implemented in assembler
 112 # SHA512_ASM    sha512_block is implemented in assembler
 113 # AES_ASM       AES_[en|de]crypt is implemented in assembler
 114
 115 # Minimum warning options... any contributions to OpenSSL should at least
 116 # get past these.  Note that we only use these with C compilers, not with
 117 # C++ compilers.
 118
 119 # DEBUG_UNUSED enables __owur (warn unused result) checks.
 120 # -DPEDANTIC complements -pedantic and is meant to mask code that
 121 # is not strictly standard-compliant and/or implementation-specific,
 122 # e.g. inline assembly, disregards to alignment requirements, such
 123 # that -pedantic would complain about. Incidentally -DPEDANTIC has
 124 # to be used even in sanitized builds, because sanitizer too is
 125 # supposed to and does take notice of non-standard behaviour. Then
 126 # -pedantic with pre-C9x compiler would also complain about 'long
 127 # long' not being supported. As 64-bit algorithms are common now,
 128 # it grew impossible to resolve this without sizeable additional
 129 # code, so we just tell compiler to be pedantic about everything
 130 # but 'long long' type.
 131
 132 my @gcc_devteam_warn = qw(
 133     -DDEBUG_UNUSED
 134     -DPEDANTIC -pedantic -Wno-long-long
 135     -Wall
 136     -Wextra
 137     -Wno-unused-parameter
 138     -Wno-missing-field-initializers
 139     -Wswitch
 140     -Wsign-compare
 141     -Wshadow
 142     -Wformat
 143     -Wtype-limits
 144     -Wundef
 145     -Werror
 146     -Wmissing-prototypes
 147     -Wstrict-prototypes
 148 );
 149
 150 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
 151 # TODO(openssl-team): fix problems and investigate if (at least) the
 152 # following warnings can also be enabled:
 153 #       -Wcast-align
 154 #       -Wunreachable-code -- no, too ugly/compiler-specific
 155 #       -Wlanguage-extension-token -- no, we use asm()
 156 #       -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
 157 #       -Wextended-offsetof -- no, needed in CMS ASN1 code
 158 my @clang_devteam_warn = qw(
 159     -Wno-unknown-warning-option
 160     -Wswitch-default
 161     -Wno-parentheses-equality
 162     -Wno-language-extension-token
 163     -Wno-extended-offsetof
 164     -Wconditional-uninitialized
 165     -Wincompatible-pointer-types-discards-qualifiers
 166     -Wmissing-variable-declarations
 167 );
 168
 169 my @cl_devteam_warn = qw(
 170     /WX
 171 );
 172
 173 # This adds backtrace information to the memory leak info.  Is only used
 174 # when crypto-mdebug-backtrace is enabled.
 175 my $memleak_devteam_backtrace = "-rdynamic";
 176
 177 my $strict_warnings = 0;
 178
 179 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
 180 # which would cover all BSD flavors. -pthread applies to them all,
 181 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
 182 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
 183 # which has to be accompanied by explicit -D_THREAD_SAFE and
 184 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
 185 # seems to be sufficient?
 186 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
 187
 188 #
 189 # API compatibility name to version number mapping.
 190 #
 191 my $apitable = {
 192     # This table expresses when API additions or changes can occur.
 193     # The numbering used changes from 3.0 and on because we updated
 194     # (solidified) our version numbering scheme at that point.
 195
 196     # From 3.0 and on, we internalise the given version number in dedcimal
 197     # as MAJOR * 10000 + MINOR * 100 + 0
 198     "3.0.0" => 30000,
 199     "3.0"   => 30000,
 200
 201     # Note that before 3.0, we didn't have the same version number scheme.
 202     # Still, the numbering we use here covers what we need.
 203     "1.1.1" => 10101,
 204     "1.1.0" => 10100,
 205     "1.0.2" => 10002,
 206     "1.0.1" => 10001,
 207     "1.0.0" => 10000,
 208     "0.9.8" =>   908,
 209 };
 210
 211 our %table = ();
 212 our %config = ();
 213 our %withargs = ();
 214 our $now_printing;      # set to current entry's name in print_table_entry
 215                         # (todo: right thing would be to encapsulate name
 216                         # into %target [class] and make print_table_entry
 217                         # a method)
 218
 219 # Forward declarations ###############################################
 220
 221 # read_config(filename)
 222 #
 223 # Reads a configuration file and populates %table with the contents
 224 # (which the configuration file places in %targets).
 225 sub read_config;
 226
 227 # resolve_config(target)
 228 #
 229 # Resolves all the late evaluations, inheritances and so on for the
 230 # chosen target and any target it inherits from.
 231 sub resolve_config;
 232
 233
 234 # Information collection #############################################
 235
 236 # Unified build supports separate build dir
 237 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
 238 my $blddir = catdir(absolutedir("."));         # catdir ensures local syntax
 239 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
 240
 241 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
 242
 243 $config{sourcedir} = abs2rel($srcdir);
 244 $config{builddir} = abs2rel($blddir);
 245
 246 # Collect reconfiguration information if needed
 247 my @argvcopy=@ARGV;
 248
 249 if (grep /^reconf(igure)?$/, @argvcopy) {
 250     die "reconfiguring with other arguments present isn't supported"
 251         if scalar @argvcopy > 1;
 252     if (-f "./configdata.pm") {
 253         my $file = "./configdata.pm";
 254         unless (my $return = do $file) {
 255             die "couldn't parse $file: $@" if $@;
 256             die "couldn't do $file: $!"    unless defined $return;
 257             die "couldn't run $file"       unless $return;
 258         }
 259
 260         @argvcopy = defined($configdata::config{perlargv}) ?
 261             @{$configdata::config{perlargv}} : ();
 262         die "Incorrect data to reconfigure, please do a normal configuration\n"
 263             if (grep(/^reconf/,@argvcopy));
 264         $config{perlenv} = $configdata::config{perlenv} // {};
 265     } else {
 266         die "Insufficient data to reconfigure, please do a normal configuration\n";
 267     }
 268 }
 269
 270 $config{perlargv} = [ @argvcopy ];
 271
 272 # Collect version numbers
 273 my %version = ();
 274
 275 collect_information(
 276     collect_from_file(catfile($srcdir,'VERSION')),
 277     qr/\s*(\w+)\s*=\s*(.*?)\s*$/ =>
 278         sub {
 279             # Only define it if there is a value at all
 280             $version{uc $1} = $2 if $2 ne '';
 281         },
 282     "OTHERWISE" =>
 283         sub { die "Something wrong with this line:\n$_\nin $srcdir/VERSION" },
 284     );
 285
 286 $config{major} = $version{MAJOR} // 'unknown';
 287 $config{minor} = $version{MINOR} // 'unknown';
 288 $config{patch} = $version{PATCH} // 'unknown';
 289 $config{prerelease} =
 290     defined $version{PRE_RELEASE_TAG} ? "-$version{PRE_RELEASE_TAG}" : '';
 291 $config{build_metadata} =
 292     defined $version{BUILD_METADATA} ? "+$version{BUILD_METADATA}" : '';
 293 $config{shlib_version} = $version{SHLIB_VERSION} // 'unknown';
 294 $config{release_date} = $version{RELEASE_DATE} // 'xx XXX xxxx';
 295
 296 $config{version} = "$config{major}.$config{minor}.$config{patch}";
 297 $config{full_version} = "$config{version}$config{prerelease}$config{build_metadata}";
 298
 299 die "erroneous version information in VERSION: ",
 300     "$config{version}, $config{shlib_version}\n"
 301     unless (defined $version{MAJOR}
 302             && defined $version{MINOR}
 303             && defined $version{PATCH}
 304             && defined $version{SHLIB_VERSION});
 305
 306 # Collect target configurations
 307
 308 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
 309 foreach (sort glob($pattern)) {
 310     &read_config($_);
 311 }
 312
 313 if (defined env($local_config_envname)) {
 314     if ($^O eq 'VMS') {
 315         # VMS environment variables are logical names,
 316         # which can be used as is
 317         $pattern = $local_config_envname . ':' . '*.conf';
 318     } else {
 319         $pattern = catfile(env($local_config_envname), '*.conf');
 320     }
 321
 322     foreach (sort glob($pattern)) {
 323         &read_config($_);
 324     }
 325 }
 326
 327 # Save away perl command information
 328 $config{perl_cmd} = $^X;
 329 $config{perl_version} = $Config{version};
 330 $config{perl_archname} = $Config{archname};
 331
 332 $config{prefix}="";
 333 $config{openssldir}="";
 334 $config{processor}="";
 335 $config{libdir}="";
 336 my $auto_threads=1;    # enable threads automatically? true by default
 337 my $default_ranlib;
 338
 339 # Known TLS and DTLS protocols
 340 my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
 341 my @dtls = qw(dtls1 dtls1_2);
 342
 343 # Explicitly known options that are possible to disable.  They can
 344 # be regexps, and will be used like this: /^no-${option}$/
 345 # For developers: keep it sorted alphabetically
 346
 347 my @disablables = (
 348     "ktls",
 349     "afalgeng",
 350     "aria",
 351     "asan",
 352     "asm",
 353     "async",
 354     "autoalginit",
 355     "autoerrinit",
 356     "autoload-config",
 357     "bf",
 358     "blake2",
 359     "buildtest-c++",
 360     "camellia",
 361     "capieng",
 362     "cast",
 363     "chacha",
 364     "cmac",
 365     "cmp",
 366     "cms",
 367     "comp",
 368     "crypto-mdebug",
 369     "crypto-mdebug-backtrace",
 370     "ct",
 371     "deprecated",
 372     "des",
 373     "devcryptoeng",
 374     "dgram",
 375     "dh",
 376     "dsa",
 377     "dso",
 378     "dtls",
 379     "dynamic-engine",
 380     "ec",
 381     "ec2m",
 382     "ecdh",
 383     "ecdsa",
 384     "ec_nistp_64_gcc_128",
 385     "egd",
 386     "engine",
 387     "err",
 388     "external-tests",
 389     "filenames",
 390     "fips",
 391     "fuzz-libfuzzer",
 392     "fuzz-afl",
 393     "gost",
 394     "idea",
 395     "legacy",
 396     "makedepend",
 397     "md2",
 398     "md4",
 399     "mdc2",
 400     "module",
 401     "msan",
 402     "multiblock",
 403     "nextprotoneg",
 404     "pinshared",
 405     "ocb",
 406     "ocsp",
 407     "padlockeng",
 408     "pic",
 409     "poly1305",
 410     "posix-io",
 411     "psk",
 412     "rc2",
 413     "rc4",
 414     "rc5",
 415     "rdrand",
 416     "rfc3779",
 417     "rmd160",
 418     "scrypt",
 419     "sctp",
 420     "seed",
 421     "shared",
 422     "siphash",
 423     "siv",
 424     "sm2",
 425     "sm3",
 426     "sm4",
 427     "sock",
 428     "srp",
 429     "srtp",
 430     "sse2",
 431     "ssl",
 432     "ssl-trace",
 433     "static-engine",
 434     "stdio",
 435     "tests",
 436     "threads",
 437     "tls",
 438     "trace",
 439     "ts",
 440     "ubsan",
 441     "ui-console",
 442     "unit-test",
 443     "uplink",
 444     "whirlpool",
 445     "weak-ssl-ciphers",
 446     "zlib",
 447     "zlib-dynamic",
 448     );
 449 foreach my $proto ((@tls, @dtls))
 450         {
 451         push(@disablables, $proto);
 452         push(@disablables, "$proto-method") unless $proto eq "tls1_3";
 453         }
 454
 455 # Internal disablables, for aliasing purposes.  They serve no special
 456 # purpose here, but allow scripts to get to know them through configdata.pm,
 457 # where these are merged with @disablables.
 458 # The actual aliasing mechanism is done via %disable_cascades
 459 my @disablables_int = qw(
 460     crmf
 461     );
 462
 463 my %deprecated_disablables = (
 464     "ssl2" => undef,
 465     "buf-freelists" => undef,
 466     "hw" => "hw",               # causes cascade, but no macro
 467     "hw-padlock" => "padlockeng",
 468     "ripemd" => "rmd160",
 469     "ui" => "ui-console",
 470     "heartbeats" => undef,
 471     );
 472
 473 # All of the following are disabled by default:
 474
 475 our %disabled = ( # "what"         => "comment"
 476                   "asan"                => "default",
 477                   "buildtest-c++"       => "default",
 478                   "crypto-mdebug"       => "default",
 479                   "crypto-mdebug-backtrace" => "default",
 480                   "devcryptoeng"        => "default",
 481                   "ec_nistp_64_gcc_128" => "default",
 482                   "egd"                 => "default",
 483                   "external-tests"      => "default",
 484                   "fuzz-libfuzzer"      => "default",
 485                   "fuzz-afl"            => "default",
 486                   "md2"                 => "default",
 487                   "msan"                => "default",
 488                   "rc5"                 => "default",
 489                   "sctp"                => "default",
 490                   "ssl-trace"           => "default",
 491                   "ssl3"                => "default",
 492                   "ssl3-method"         => "default",
 493                   "trace"               => "default",
 494                   "ubsan"               => "default",
 495                   "unit-test"           => "default",
 496                   "weak-ssl-ciphers"    => "default",
 497                   "zlib"                => "default",
 498                   "zlib-dynamic"        => "default",
 499                   "ktls"                => "default",
 500                 );
 501
 502 # Note: => pair form used for aesthetics, not to truly make a hash table
 503 my @disable_cascades = (
 504     # "what"            => [ "cascade", ... ]
 505     sub { $config{processor} eq "386" }
 506                         => [ "sse2" ],
 507     "ssl"               => [ "ssl3" ],
 508     "ssl3-method"       => [ "ssl3" ],
 509     "zlib"              => [ "zlib-dynamic" ],
 510     "des"               => [ "mdc2" ],
 511     "ec"                => [ "ecdsa", "ecdh", "sm2" ],
 512     sub { $disabled{"ec"} && $disabled{"dh"} }
 513                         => [ "tls1_3" ],
 514     "dgram"             => [ "dtls", "sctp" ],
 515     "sock"              => [ "dgram" ],
 516     "dtls"              => [ @dtls ],
 517     sub { 0 == scalar grep { !$disabled{$_} } @dtls }
 518                         => [ "dtls" ],
 519
 520     "tls"               => [ @tls ],
 521     sub { 0 == scalar grep { !$disabled{$_} } @tls }
 522                         => [ "tls" ],
 523
 524     "crypto-mdebug"     => [ "crypto-mdebug-backtrace" ],
 525
 526     # If no modules, then no dynamic engines either
 527     "module"            => [ "dynamic-engine" ],
 528
 529     # Without shared libraries, dynamic engines aren't possible.
 530     # This is due to them having to link with libcrypto and register features
 531     # using the ENGINE functionality, and since that relies on global tables,
 532     # those *have* to be exacty the same as the ones accessed from the app,
 533     # which cannot be guaranteed if shared libraries aren't present.
 534     # (note that even with shared libraries, both the app and dynamic engines
 535     # must be linked with the same library)
 536     "shared"            => [ "dynamic-engine", "uplink" ],
 537     "dso"               => [ "dynamic-engine", "module" ],
 538     # Other modules don't necessarily have to link with libcrypto, so shared
 539     # libraries do not have to be a condition to produce those.
 540
 541     # Without position independent code, there can be no shared libraries
 542     # or modules.
 543     "pic"               => [ "shared", "module" ],
 544
 545     "module"            => [ "fips" ],
 546
 547     "engine"            => [ grep /eng$/, @disablables ],
 548     "hw"                => [ "padlockeng" ],
 549
 550     # no-autoalginit is only useful when building non-shared
 551     "autoalginit"       => [ "shared", "apps" ],
 552
 553     "stdio"             => [ "apps", "capieng", "egd" ],
 554     "apps"              => [ "tests" ],
 555     "tests"             => [ "external-tests" ],
 556     "comp"              => [ "zlib" ],
 557     "sm3"               => [ "sm2" ],
 558     sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
 559
 560     sub { !$disabled{"msan"} } => [ "asm" ],
 561
 562     sub { $disabled{cmac}; } => [ "siv" ],
 563     "legacy"                 => [ "md2" ],
 564
 565     "cmp"               => [ "crmf" ],
 566     );
 567
 568 # Avoid protocol support holes.  Also disable all versions below N, if version
 569 # N is disabled while N+1 is enabled.
 570 #
 571 my @list = (reverse @tls);
 572 while ((my $first, my $second) = (shift @list, shift @list)) {
 573     last unless @list;
 574     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 575                               => [ @list ] );
 576     unshift @list, $second;
 577 }
 578 my @list = (reverse @dtls);
 579 while ((my $first, my $second) = (shift @list, shift @list)) {
 580     last unless @list;
 581     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
 582                               => [ @list ] );
 583     unshift @list, $second;
 584 }
 585
 586 # Explicit "no-..." options will be collected in %disabled along with the defaults.
 587 # To remove something from %disabled, use "enable-foo".
 588 # For symmetry, "disable-foo" is a synonym for "no-foo".
 589
 590 &usage if ($#ARGV < 0);
 591
 592 # For the "make variables" CINCLUDES and CDEFINES, we support lists with
 593 # platform specific list separators.  Users from those platforms should
 594 # recognise those separators from how you set up the PATH to find executables.
 595 # The default is the Unix like separator, :, but as an exception, we also
 596 # support the space as separator.
 597 my $list_separator_re =
 598     { VMS           => qr/(?<!\^),/,
 599       MSWin32       => qr/(?<!\\);/ } -> {$^O} // qr/(?<!\\)[:\s]/;
 600 # All the "make variables" we support
 601 # Some get pre-populated for the sake of backward compatibility
 602 # (we supported those before the change to "make variable" support.
 603 my %user = (
 604     AR          => env('AR'),
 605     ARFLAGS     => [],
 606     AS          => undef,
 607     ASFLAGS     => [],
 608     CC          => env('CC'),
 609     CFLAGS      => [ env('CFLAGS') || () ],
 610     CXX         => env('CXX'),
 611     CXXFLAGS    => [ env('CXXFLAGS') || () ],
 612     CPP         => undef,
 613     CPPFLAGS    => [ env('CPPFLAGS') || () ],  # -D, -I, -Wp,
 614     CPPDEFINES  => [],  # Alternative for -D
 615     CPPINCLUDES => [],  # Alternative for -I
 616     CROSS_COMPILE => env('CROSS_COMPILE'),
 617     HASHBANGPERL=> env('HASHBANGPERL') || env('PERL'),
 618     LD          => undef,
 619     LDFLAGS     => [ env('LDFLAGS') || () ],  # -L, -Wl,
 620     LDLIBS      => [ env('LDLIBS') || () ],  # -l
 621     MT          => undef,
 622     MTFLAGS     => [],
 623     PERL        => env('PERL') || ($^O ne "VMS" ? $^X : "perl"),
 624     RANLIB      => env('RANLIB'),
 625     RC          => env('RC') || env('WINDRES'),
 626     RCFLAGS     => [ env('RCFLAGS') || () ],
 627     RM          => undef,
 628    );
 629 # Info about what "make variables" may be prefixed with the cross compiler
 630 # prefix.  This should NEVER mention any such variable with a list for value.
 631 my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
 632 # The same but for flags given as Configure options.  These are *additional*
 633 # input, as opposed to the VAR=string option that override the corresponding
 634 # config target attributes
 635 my %useradd = (
 636     CPPDEFINES  => [],
 637     CPPINCLUDES => [],
 638     CPPFLAGS    => [],
 639     CFLAGS      => [],
 640     CXXFLAGS    => [],
 641     LDFLAGS     => [],
 642     LDLIBS      => [],
 643     RCFLAGS     => [],
 644    );
 645
 646 my %user_synonyms = (
 647     HASHBANGPERL=> 'PERL',
 648     RC          => 'WINDRES',
 649    );
 650
 651 # Some target attributes have been renamed, this is the translation table
 652 my %target_attr_translate =(
 653     ar          => 'AR',
 654     as          => 'AS',
 655     cc          => 'CC',
 656     cxx         => 'CXX',
 657     cpp         => 'CPP',
 658     hashbangperl => 'HASHBANGPERL',
 659     ld          => 'LD',
 660     mt          => 'MT',
 661     ranlib      => 'RANLIB',
 662     rc          => 'RC',
 663     rm          => 'RM',
 664    );
 665
 666 # Initialisers coming from 'config' scripts
 667 $config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ];
 668 $config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ];
 669 $config{cppflags} = [ env('__CNF_CPPFLAGS') || () ];
 670 $config{cflags} = [ env('__CNF_CFLAGS') || () ];
 671 $config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ];
 672 $config{lflags} = [ env('__CNF_LDFLAGS') || () ];
 673 $config{ex_libs} = [ env('__CNF_LDLIBS') || () ];
 674
 675 $config{openssl_api_defines}=[];
 676 $config{openssl_sys_defines}=[];
 677 $config{openssl_feature_defines}=[];
 678 $config{options}="";
 679 $config{build_type} = "release";
 680 my $target="";
 681
 682 my %cmdvars = ();               # Stores FOO='blah' type arguments
 683 my %unsupported_options = ();
 684 my %deprecated_options = ();
 685 # If you change this, update apps/version.c
 686 my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
 687 my @seed_sources = ();
 688 while (@argvcopy)
 689         {
 690         $_ = shift @argvcopy;
 691
 692         # Support env variable assignments among the options
 693         if (m|^(\w+)=(.+)?$|)
 694                 {
 695                 $cmdvars{$1} = $2;
 696                 # Every time a variable is given as a configuration argument,
 697                 # it acts as a reset if the variable.
 698                 if (exists $user{$1})
 699                         {
 700                         $user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
 701                         }
 702                 #if (exists $useradd{$1})
 703                 #       {
 704                 #       $useradd{$1} = [];
 705                 #       }
 706                 next;
 707                 }
 708
 709         # VMS is a case insensitive environment, and depending on settings
 710         # out of our control, we may receive options uppercased.  Let's
 711         # downcase at least the part before any equal sign.
 712         if ($^O eq "VMS")
 713                 {
 714                 s/^([^=]*)/lc($1)/e;
 715                 }
 716
 717         # some people just can't read the instructions, clang people have to...
 718         s/^-no-(?!integrated-as)/no-/;
 719
 720         # rewrite some options in "enable-..." form
 721         s /^-?-?shared$/enable-shared/;
 722         s /^sctp$/enable-sctp/;
 723         s /^threads$/enable-threads/;
 724         s /^zlib$/enable-zlib/;
 725         s /^zlib-dynamic$/enable-zlib-dynamic/;
 726
 727         if (/^(no|disable|enable)-(.+)$/)
 728                 {
 729                 my $word = $2;
 730                 if ($word !~ m|hw(?:-.+)| # special treatment for hw regexp opt
 731                         && !exists $deprecated_disablables{$word}
 732                         && !grep { $word eq $_ } @disablables)
 733                         {
 734                         $unsupported_options{$_} = 1;
 735                         next;
 736                         }
 737                 }
 738         if (/^no-(.+)$/ || /^disable-(.+)$/)
 739                 {
 740                 foreach my $proto ((@tls, @dtls))
 741                         {
 742                         if ($1 eq "$proto-method")
 743                                 {
 744                                 $disabled{"$proto"} = "option($proto-method)";
 745                                 last;
 746                                 }
 747                         }
 748                 if ($1 eq "dtls")
 749                         {
 750                         foreach my $proto (@dtls)
 751                                 {
 752                                 $disabled{$proto} = "option(dtls)";
 753                                 }
 754                         $disabled{"dtls"} = "option(dtls)";
 755                         }
 756                 elsif ($1 eq "ssl")
 757                         {
 758                         # Last one of its kind
 759                         $disabled{"ssl3"} = "option(ssl)";
 760                         }
 761                 elsif ($1 eq "tls")
 762                         {
 763                         # XXX: Tests will fail if all SSL/TLS
 764                         # protocols are disabled.
 765                         foreach my $proto (@tls)
 766                                 {
 767                                 $disabled{$proto} = "option(tls)";
 768                                 }
 769                         }
 770                 elsif ($1 eq "static-engine")
 771                         {
 772                         delete $disabled{"dynamic-engine"};
 773                         }
 774                 elsif ($1 eq "dynamic-engine")
 775                         {
 776                         $disabled{"dynamic-engine"} = "option";
 777                         }
 778                 elsif (exists $deprecated_disablables{$1})
 779                         {
 780                         $deprecated_options{$_} = 1;
 781                         if (defined $deprecated_disablables{$1})
 782                                 {
 783                                 $disabled{$deprecated_disablables{$1}} = "option";
 784                                 }
 785                         }
 786                 elsif ($1 =~ m|hw(?:-.+)|) # deprecate hw options in regexp form
 787                         {
 788                         $deprecated_options{$_} = 1;
 789                         }
 790                 else
 791                         {
 792                         $disabled{$1} = "option";
 793                         }
 794                 # No longer an automatic choice
 795                 $auto_threads = 0 if ($1 eq "threads");
 796                 }
 797         elsif (/^enable-(.+)$/)
 798                 {
 799                 if ($1 eq "static-engine")
 800                         {
 801                         $disabled{"dynamic-engine"} = "option";
 802                         }
 803                 elsif ($1 eq "dynamic-engine")
 804                         {
 805                         delete $disabled{"dynamic-engine"};
 806                         }
 807                 elsif ($1 eq "zlib-dynamic")
 808                         {
 809                         delete $disabled{"zlib"};
 810                         }
 811                 my $algo = $1;
 812                 delete $disabled{$algo};
 813
 814                 # No longer an automatic choice
 815                 $auto_threads = 0 if ($1 eq "threads");
 816                 }
 817         elsif (/^--strict-warnings$/)
 818                 {
 819                 # Pretend that our strict flags is a C flag, and replace it
 820                 # with the proper flags later on
 821                 push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
 822                 $strict_warnings=1;
 823                 }
 824         elsif (/^--debug$/)
 825                 {
 826                 $config{build_type} = "debug";
 827                 }
 828         elsif (/^--release$/)
 829                 {
 830                 $config{build_type} = "release";
 831                 }
 832         elsif (/^386$/)
 833                 { $config{processor}=386; }
 834         elsif (/^fips$/)
 835                 {
 836                 die "FIPS mode not supported\n";
 837                 }
 838         elsif (/^rsaref$/)
 839                 {
 840                 # No RSAref support any more since it's not needed.
 841                 # The check for the option is there so scripts aren't
 842                 # broken
 843                 }
 844         elsif (/^nofipscanistercheck$/)
 845                 {
 846                 die "FIPS mode not supported\n";
 847                 }
 848         elsif (m|^[-+/]|)
 849                 {
 850                 if (/^--prefix=(.*)$/)
 851                         {
 852                         $config{prefix}=$1;
 853                         die "Directory given with --prefix MUST be absolute\n"
 854                                 unless file_name_is_absolute($config{prefix});
 855                         }
 856                 elsif (/^--api=(.*)$/)
 857                         {
 858                         my $api = $1;
 859                         die "Unknown API compatibility level $api"
 860                                 unless defined $apitable->{$api};
 861                         $config{api}=$apitable->{$api};
 862                         }
 863                 elsif (/^--libdir=(.*)$/)
 864                         {
 865                         $config{libdir}=$1;
 866                         }
 867                 elsif (/^--openssldir=(.*)$/)
 868                         {
 869                         $config{openssldir}=$1;
 870                         }
 871                 elsif (/^--with-zlib-lib=(.*)$/)
 872                         {
 873                         $withargs{zlib_lib}=$1;
 874                         }
 875                 elsif (/^--with-zlib-include=(.*)$/)
 876                         {
 877                         $withargs{zlib_include}=$1;
 878                         }
 879                 elsif (/^--with-fuzzer-lib=(.*)$/)
 880                         {
 881                         $withargs{fuzzer_lib}=$1;
 882                         }
 883                 elsif (/^--with-fuzzer-include=(.*)$/)
 884                         {
 885                         $withargs{fuzzer_include}=$1;
 886                         }
 887                 elsif (/^--with-rand-seed=(.*)$/)
 888                         {
 889                         foreach my $x (split(m|,|, $1))
 890                             {
 891                             die "Unknown --with-rand-seed choice $x\n"
 892                                 if ! grep { $x eq $_ } @known_seed_sources;
 893                             push @seed_sources, $x;
 894                             }
 895                         }
 896                 elsif (/^--cross-compile-prefix=(.*)$/)
 897                         {
 898                         $user{CROSS_COMPILE}=$1;
 899                         }
 900                 elsif (/^--config=(.*)$/)
 901                         {
 902                         read_config $1;
 903                         }
 904                 elsif (/^-l(.*)$/)
 905                         {
 906                         push @{$useradd{LDLIBS}}, $_;
 907                         }
 908                 elsif (/^-framework$/)
 909                         {
 910                         push @{$useradd{LDLIBS}}, $_, shift(@argvcopy);
 911                         }
 912                 elsif (/^-L(.*)$/ or /^-Wl,/)
 913                         {
 914                         push @{$useradd{LDFLAGS}}, $_;
 915                         }
 916                 elsif (/^-rpath$/ or /^-R$/)
 917                         # -rpath is the OSF1 rpath flag
 918                         # -R is the old Solaris rpath flag
 919                         {
 920                         my $rpath = shift(@argvcopy) || "";
 921                         $rpath .= " " if $rpath ne "";
 922                         push @{$useradd{LDFLAGS}}, $_, $rpath;
 923                         }
 924                 elsif (/^-static$/)
 925                         {
 926                         push @{$useradd{LDFLAGS}}, $_;
 927                         }
 928                 elsif (m|^[-/]D(.*)$|)
 929                         {
 930                         push @{$useradd{CPPDEFINES}}, $1;
 931                         }
 932                 elsif (m|^[-/]I(.*)$|)
 933                         {
 934                         push @{$useradd{CPPINCLUDES}}, $1;
 935                         }
 936                 elsif (/^-Wp,$/)
 937                         {
 938                         push @{$useradd{CPPFLAGS}}, $1;
 939                         }
 940                 else    # common if (/^[-+]/), just pass down...
 941                         {
 942                         # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
 943                         # This provides a simple way to pass options with arguments separated
 944                         # by spaces without quoting (e.g. -opt%20arg translates to -opt arg).
 945                         $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
 946                         push @{$useradd{CFLAGS}}, $_;
 947                         push @{$useradd{CXXFLAGS}}, $_;
 948                         }
 949                 }
 950         elsif (m|^/|)
 951                 {
 952                 # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
 953                 # This provides a simple way to pass options with arguments separated
 954                 # by spaces without quoting (e.g. /opt%20arg translates to /opt arg).
 955                 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
 956                 push @{$useradd{CFLAGS}}, $_;
 957                 push @{$useradd{CXXFLAGS}}, $_;
 958                 }
 959         else
 960                 {
 961                 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
 962                 $target=$_;
 963                 }
 964         unless ($_ eq $target || /^no-/ || /^disable-/)
 965                 {
 966                 # "no-..." follows later after implied deactivations
 967                 # have been derived.  (Don't take this too seriously,
 968                 # we really only write OPTIONS to the Makefile out of
 969                 # nostalgia.)
 970
 971                 if ($config{options} eq "")
 972                         { $config{options} = $_; }
 973                 else
 974                         { $config{options} .= " ".$_; }
 975                 }
 976         }
 977
 978 if (keys %deprecated_options)
 979         {
 980         warn "***** Deprecated options: ",
 981                 join(", ", keys %deprecated_options), "\n";
 982         }
 983 if (keys %unsupported_options)
 984         {
 985         die "***** Unsupported options: ",
 986                 join(", ", keys %unsupported_options), "\n";
 987         }
 988
 989 # If any %useradd entry has been set, we must check that the "make
 990 # variables" haven't been set.  We start by checking of any %useradd entry
 991 # is set.
 992 if (grep { scalar @$_ > 0 } values %useradd) {
 993     # Hash of env / make variables names.  The possible values are:
 994     # 1 - "make vars"
 995     # 2 - %useradd entry set
 996     # 3 - both set
 997     my %detected_vars =
 998         map { my $v = 0;
 999               $v += 1 if $cmdvars{$_};
1000               $v += 2 if @{$useradd{$_}};
1001               $_ => $v }
1002         keys %useradd;
1003
1004     # If any of the corresponding "make variables" is set, we error
1005     if (grep { $_ & 1 } values %detected_vars) {
1006         my $names = join(', ', grep { $detected_vars{$_} > 0 }
1007                                sort keys %detected_vars);
1008         die <<"_____";
1009 ***** Mixing make variables and additional compiler/linker flags as
1010 ***** configure command line option is not permitted.
1011 ***** Affected make variables: $names
1012 _____
1013     }
1014 }
1015
1016 # Check through all supported command line variables to see if any of them
1017 # were set, and canonicalise the values we got.  If no compiler or linker
1018 # flag or anything else that affects %useradd was set, we also check the
1019 # environment for values.
1020 my $anyuseradd =
1021     grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
1022 foreach (keys %user) {
1023     my $value = $cmdvars{$_};
1024     $value //= env($_) unless $anyuseradd;
1025     $value //=
1026         defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
1027     $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
1028         unless $anyuseradd;
1029
1030     if (defined $value) {
1031         if (ref $user{$_} eq 'ARRAY') {
1032             $user{$_} = [ split /$list_separator_re/, $value ];
1033         } elsif (!defined $user{$_}) {
1034             $user{$_} = $value;
1035         }
1036     }
1037 }
1038
1039 if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
1040     && !$disabled{shared}
1041     && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
1042     die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
1043         "***** any of asan, msan or ubsan\n";
1044 }
1045
1046 sub disable {
1047     my $disable_type = shift;
1048
1049     for (@_) {
1050         $disabled{$_} = $disable_type;
1051     }
1052
1053     my @tocheckfor = (@_ ? @_ : keys %disabled);
1054     while (@tocheckfor) {
1055         my %new_tocheckfor = ();
1056         my @cascade_copy = (@disable_cascades);
1057         while (@cascade_copy) {
1058             my ($test, $descendents) =
1059                 (shift @cascade_copy, shift @cascade_copy);
1060             if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
1061                 foreach (grep { !defined($disabled{$_}) } @$descendents) {
1062                     $new_tocheckfor{$_} = 1; $disabled{$_} = "cascade";
1063                 }
1064             }
1065         }
1066         @tocheckfor = (keys %new_tocheckfor);
1067     }
1068 }
1069 disable();                     # First cascade run
1070
1071 our $die = sub { die @_; };
1072 if ($target eq "TABLE") {
1073     local $die = sub { warn @_; };
1074     foreach (sort keys %table) {
1075         print_table_entry($_, "TABLE");
1076     }
1077     exit 0;
1078 }
1079
1080 if ($target eq "LIST") {
1081     foreach (sort keys %table) {
1082         print $_,"\n" unless $table{$_}->{template};
1083     }
1084     exit 0;
1085 }
1086
1087 if ($target eq "HASH") {
1088     local $die = sub { warn @_; };
1089     print "%table = (\n";
1090     foreach (sort keys %table) {
1091         print_table_entry($_, "HASH");
1092     }
1093     exit 0;
1094 }
1095
1096 print "Configuring OpenSSL version $config{full_version} ";
1097 print "for target $target\n";
1098
1099 if (scalar(@seed_sources) == 0) {
1100     print "Using os-specific seed configuration\n";
1101     push @seed_sources, 'os';
1102 }
1103 if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1104     die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1105     warn <<_____ if scalar(@seed_sources) == 1;
1106
1107 ============================== WARNING ===============================
1108 You have selected the --with-rand-seed=none option, which effectively
1109 disables automatic reseeding of the OpenSSL random generator.
1110 All operations depending on the random generator such as creating keys
1111 will not work unless the random generator is seeded manually by the
1112 application.
1113
1114 Please read the 'Note on random number generation' section in the
1115 INSTALL instructions and the RAND_DRBG(7) manual page for more details.
1116 ============================== WARNING ===============================
1117
1118 _____
1119 }
1120 push @{$config{openssl_feature_defines}},
1121      map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
1122         @seed_sources;
1123
1124 # Backward compatibility?
1125 if ($target =~ m/^CygWin32(-.*)$/) {
1126     $target = "Cygwin".$1;
1127 }
1128
1129 # Support for legacy targets having a name starting with 'debug-'
1130 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1131 if ($d) {
1132     $config{build_type} = "debug";
1133
1134     # If we do not find debug-foo in the table, the target is set to foo.
1135     if (!$table{$target}) {
1136         $target = $t;
1137     }
1138 }
1139
1140 &usage if !$table{$target} || $table{$target}->{template};
1141
1142 $config{target} = $target;
1143 my %target = resolve_config($target);
1144
1145 foreach (keys %target_attr_translate) {
1146     $target{$target_attr_translate{$_}} = $target{$_}
1147         if $target{$_};
1148     delete $target{$_};
1149 }
1150
1151 %target = ( %{$table{DEFAULTS}}, %target );
1152
1153 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1154 $config{conf_files} = [ sort keys %conf_files ];
1155
1156 # Using sub disable within these loops may prove fragile, so we run
1157 # a cascade afterwards
1158 foreach my $feature (@{$target{disable}}) {
1159     if (exists $deprecated_disablables{$feature}) {
1160         warn "***** config $target disables deprecated feature $feature\n";
1161     } elsif (!grep { $feature eq $_ } @disablables) {
1162         die "***** config $target disables unknown feature $feature\n";
1163     }
1164     $disabled{$feature} = 'config';
1165 }
1166 foreach my $feature (@{$target{enable}}) {
1167     if ("default" eq ($disabled{$feature} // "")) {
1168         if (exists $deprecated_disablables{$feature}) {
1169             warn "***** config $target enables deprecated feature $feature\n";
1170         } elsif (!grep { $feature eq $_ } @disablables) {
1171             die "***** config $target enables unknown feature $feature\n";
1172         }
1173         delete $disabled{$feature};
1174     }
1175 }
1176
1177 # If uplink_arch isn't defined, disable uplink
1178 $disabled{uplink} = 'no uplink_arch' unless (defined $target{uplink_arch});
1179 # If asm_arch isn't defined, disable asm
1180 $disabled{asm} = 'no asm_arch' unless (defined $target{asm_arch});
1181
1182 disable();                      # Run a cascade now
1183
1184 $target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1185 $target{cxxflags}//=$target{cflags} if $target{CXX};
1186 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP");
1187 $target{exe_extension}=".pm"  if ($config{target} =~ /vos/);
1188
1189 # Fill %config with values from %user, and in case those are undefined or
1190 # empty, use values from %target (acting as a default).
1191 foreach (keys %user) {
1192     my $ref_type = ref $user{$_};
1193
1194     # Temporary function.  Takes an intended ref type (empty string or "ARRAY")
1195     # and a value that's to be coerced into that type.
1196     my $mkvalue = sub {
1197         my $type = shift;
1198         my $value = shift;
1199         my $undef_p = shift;
1200
1201         die "Too many arguments for \$mkvalue" if @_;
1202
1203         while (ref $value eq 'CODE') {
1204             $value = $value->();
1205         }
1206
1207         if ($type eq 'ARRAY') {
1208             return undef unless defined $value;
1209             return undef if ref $value ne 'ARRAY' && !$value;
1210             return undef if ref $value eq 'ARRAY' && !@$value;
1211             return [ $value ] unless ref $value eq 'ARRAY';
1212         }
1213         return undef unless $value;
1214         return $value;
1215     };
1216
1217     $config{$_} =
1218         $mkvalue->($ref_type, $user{$_})
1219         || $mkvalue->($ref_type, $target{$_});
1220     delete $config{$_} unless defined $config{$_};
1221 }
1222
1223 # Finish up %config by appending things the user gave us on the command line
1224 # apart from "make variables"
1225 foreach (keys %useradd) {
1226     # The must all be lists, so we assert that here
1227     die "internal error: \$useradd{$_} isn't an ARRAY\n"
1228         unless ref $useradd{$_} eq 'ARRAY';
1229
1230     if (defined $config{$_}) {
1231         push @{$config{$_}}, @{$useradd{$_}};
1232     } else {
1233         $config{$_} = [ @{$useradd{$_}} ];
1234     }
1235 }
1236 # At this point, we can forget everything about %user and %useradd,
1237 # because it's now all been merged into the corresponding $config entry
1238
1239 # Allow overriding the build file name
1240 $config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
1241
1242 ######################################################################
1243 # Build up information for skipping certain directories depending on disabled
1244 # features, as well as setting up macros for disabled features.
1245
1246 # This is a tentative database of directories to skip.  Some entries may not
1247 # correspond to anything real, but that's ok, they will simply be ignored.
1248 # The actual processing of these entries is done in the build.info lookup
1249 # loop further down.
1250 #
1251 # The key is a Unix formatted path in the source tree, the value is an index
1252 # into %disabled_info, so any existing path gets added to a corresponding
1253 # 'skipped' entry in there with the list of skipped directories.
1254 my %skipdir = ();
1255 my %disabled_info = ();         # For configdata.pm
1256 foreach my $what (sort keys %disabled) {
1257     # There are deprecated disablables that translate to themselves.
1258     # They cause disabling cascades, but should otherwise not regiter.
1259     next if $deprecated_disablables{$what};
1260
1261     $config{options} .= " no-$what";
1262
1263     if (!grep { $what eq $_ } ( 'buildtest-c++', 'fips', 'threads', 'shared',
1264                                 'module', 'pic', 'dynamic-engine', 'makedepend',
1265                                 'zlib-dynamic', 'zlib', 'sse2', 'legacy' )) {
1266         (my $WHAT = uc $what) =~ s|-|_|g;
1267         my $skipdir = $what;
1268
1269         # fix-up crypto/directory name(s)
1270         $skipdir = "ripemd" if $what eq "rmd160";
1271         $skipdir = "whrlpool" if $what eq "whirlpool";
1272
1273         my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
1274         push @{$config{openssl_feature_defines}}, $macro;
1275
1276         $skipdir{engines} = $what if $what eq 'engine';
1277         $skipdir{"crypto/$skipdir"} = $what
1278             unless $what eq 'async' || $what eq 'err' || $what eq 'dso';
1279     }
1280 }
1281
1282 # Make sure build_scheme is consistent.
1283 $target{build_scheme} = [ $target{build_scheme} ]
1284     if ref($target{build_scheme}) ne "ARRAY";
1285
1286 my ($builder, $builder_platform, @builder_opts) =
1287     @{$target{build_scheme}};
1288
1289 foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1290                       $builder_platform."-checker.pm")) {
1291     my $checker_path = catfile($srcdir, "Configurations", $checker);
1292     if (-f $checker_path) {
1293         my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1294             ? sub { warn $@; } : sub { die $@; };
1295         if (! do $checker_path) {
1296             if ($@) {
1297                 $fn->($@);
1298             } elsif ($!) {
1299                 $fn->($!);
1300             } else {
1301                 $fn->("The detected tools didn't match the platform\n");
1302             }
1303         }
1304         last;
1305     }
1306 }
1307
1308 push @{$config{defines}}, "NDEBUG"    if $config{build_type} eq "release";
1309
1310 if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
1311         {
1312         push @{$config{cflags}}, "-mno-cygwin";
1313         push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1314         push @{$config{shared_ldflag}}, "-mno-cygwin";
1315         }
1316
1317 if ($target =~ /linux.*-mips/ && !$disabled{asm}
1318         && !grep { $_ !~ /-m(ips|arch=)/ } (@{$config{CFLAGS}})) {
1319         # minimally required architecture flags for assembly modules
1320         my $value;
1321         $value = '-mips2' if ($target =~ /mips32/);
1322         $value = '-mips3' if ($target =~ /mips64/);
1323         unshift @{$config{cflags}}, $value;
1324         unshift @{$config{cxxflags}}, $value if $config{CXX};
1325 }
1326
1327 # If threads aren't disabled, check how possible they are
1328 unless ($disabled{threads}) {
1329     if ($auto_threads) {
1330         # Enabled by default, disable it forcibly if unavailable
1331         if ($target{thread_scheme} eq "(unknown)") {
1332             disable("unavailable", 'threads');
1333         }
1334     } else {
1335         # The user chose to enable threads explicitly, let's see
1336         # if there's a chance that's possible
1337         if ($target{thread_scheme} eq "(unknown)") {
1338             # If the user asked for "threads" and we don't have internal
1339             # knowledge how to do it, [s]he is expected to provide any
1340             # system-dependent compiler options that are necessary.  We
1341             # can't truly check that the given options are correct, but
1342             # we expect the user to know what [s]He is doing.
1343             if (!@{$config{CFLAGS}} && !@{$config{CPPDEFINES}}) {
1344                 die "You asked for multi-threading support, but didn't\n"
1345                     ,"provide any system-specific compiler options\n";
1346             }
1347         }
1348     }
1349 }
1350
1351 # Find out if clang's sanitizers have been enabled with -fsanitize
1352 # flags and ensure that the corresponding %disabled elements area
1353 # removed to reflect that the sanitizers are indeed enabled.
1354 my %detected_sanitizers = ();
1355 foreach (grep /^-fsanitize=/, @{$config{CFLAGS} || []}) {
1356     (my $checks = $_) =~ s/^-fsanitize=//;
1357     foreach (split /,/, $checks) {
1358         my $d = { address       => 'asan',
1359                   undefined     => 'ubsan',
1360                   memory        => 'msan' } -> {$_};
1361         next unless defined $d;
1362
1363         $detected_sanitizers{$d} = 1;
1364         if (defined $disabled{$d}) {
1365             die "***** Conflict between disabling $d and enabling $_ sanitizer"
1366                 if $disabled{$d} ne "default";
1367             delete $disabled{$d};
1368         }
1369     }
1370 }
1371
1372 # If threads still aren't disabled, add a C macro to ensure the source
1373 # code knows about it.  Any other flag is taken care of by the configs.
1374 unless($disabled{threads}) {
1375     push @{$config{openssl_feature_defines}}, "OPENSSL_THREADS";
1376 }
1377
1378 my $no_shared_warn=0;
1379 if ($target{shared_target} eq "")
1380         {
1381         $no_shared_warn = 1
1382             if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1383         disable('no-shared-target', 'pic');
1384         }
1385
1386 if ($disabled{"dynamic-engine"}) {
1387         push @{$config{openssl_feature_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1388         $config{dynamic_engines} = 0;
1389 } else {
1390         push @{$config{openssl_feature_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1391         $config{dynamic_engines} = 1;
1392 }
1393
1394 unless ($disabled{asan} || defined $detected_sanitizers{asan}) {
1395     push @{$config{cflags}}, "-fsanitize=address";
1396 }
1397
1398 unless ($disabled{ubsan} || defined $detected_sanitizers{ubsan}) {
1399     # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1400     # platforms.
1401     push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all";
1402 }
1403
1404 unless ($disabled{msan} || defined $detected_sanitizers{msan}) {
1405   push @{$config{cflags}}, "-fsanitize=memory";
1406 }
1407
1408 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1409         && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1410     push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
1411     push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
1412 }
1413 #
1414 # Platform fix-ups
1415 #
1416
1417 # This saves the build files from having to check
1418 if ($disabled{pic})
1419         {
1420         foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1421                     shared_defines shared_includes shared_ldflag
1422                     module_cflags module_cxxflags module_cppflags
1423                     module_defines module_includes module_lflags))
1424                 {
1425                 delete $config{$_};
1426                 $target{$_} = "";
1427                 }
1428         }
1429 else
1430         {
1431         push @{$config{lib_defines}}, "OPENSSL_PIC";
1432         }
1433
1434 if ($target{sys_id} ne "")
1435         {
1436         push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1437         }
1438
1439 unless ($disabled{asm}) {
1440 }
1441
1442 my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1443 my %predefined_CXX = $config{CXX}
1444     ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1445     : ();
1446
1447 # Check for makedepend capabilities.
1448 if (!$disabled{makedepend}) {
1449     if ($config{target} =~ /^(VC|vms)-/) {
1450         # For VC- and vms- targets, there's nothing more to do here.  The
1451         # functionality is hard coded in the corresponding build files for
1452         # cl (Windows) and CC/DECC (VMS).
1453     } elsif (($predefined_C{__GNUC__} // -1) >= 3
1454              && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
1455         # We know that GNU C version 3 and up as well as all clang
1456         # versions support dependency generation, but Xcode did not
1457         # handle $cc -M before clang support (but claims __GNUC__ = 3)
1458         $config{makedepprog} = "\$(CROSS_COMPILE)$config{CC}";
1459     } else {
1460         # In all other cases, we look for 'makedepend', and disable the
1461         # capability if not found.
1462         $config{makedepprog} = which('makedepend');
1463         disable('unavailable', 'makedepend') unless $config{makedepprog};
1464     }
1465 }
1466
1467 if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
1468     # probe for -Wa,--noexecstack option...
1469     if ($predefined_C{__clang__}) {
1470         # clang has builtin assembler, which doesn't recognize --help,
1471         # but it apparently recognizes the option in question on all
1472         # supported platforms even when it's meaningless. In other words
1473         # probe would fail, but probed option always accepted...
1474         push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
1475     } else {
1476         my $cc = $config{CROSS_COMPILE}.$config{CC};
1477         open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1478         while(<PIPE>) {
1479             if (m/--noexecstack/) {
1480                 push @{$config{cflags}}, "-Wa,--noexecstack";
1481                 last;
1482             }
1483         }
1484         close(PIPE);
1485         unlink("null.$$.o");
1486     }
1487 }
1488
1489 # Deal with bn_ops ###################################################
1490
1491 $config{bn_ll}                  =0;
1492 my $def_int="unsigned int";
1493 $config{rc4_int}                =$def_int;
1494 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1495
1496 my $count = 0;
1497 foreach (sort split(/\s+/,$target{bn_ops})) {
1498     $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1499     $config{bn_ll}=1                            if $_ eq 'BN_LLONG';
1500     $config{rc4_int}="unsigned char"            if $_ eq 'RC4_CHAR';
1501     ($config{b64l},$config{b64},$config{b32})
1502         =(0,1,0)                                if $_ eq 'SIXTY_FOUR_BIT';
1503     ($config{b64l},$config{b64},$config{b32})
1504         =(1,0,0)                                if $_ eq 'SIXTY_FOUR_BIT_LONG';
1505     ($config{b64l},$config{b64},$config{b32})
1506         =(0,0,1)                                if $_ eq 'THIRTY_TWO_BIT';
1507 }
1508 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1509     if $count > 1;
1510
1511 $config{api} = $config{major} * 10000 + $config{minor} * 100
1512     unless $config{api};
1513
1514 # Hack cflags for better warnings (dev option) #######################
1515
1516 # "Stringify" the C and C++ flags string.  This permits it to be made part of
1517 # a string and works as well on command lines.
1518 $config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1519                         @{$config{cflags}} ];
1520 $config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1521                           @{$config{cxxflags}} ] if $config{CXX};
1522
1523 $config{openssl_api_defines} = [
1524     "OPENSSL_CONFIGURED_API=".$config{api}
1525 ];
1526
1527 my @strict_warnings_collection=();
1528 if ($strict_warnings)
1529         {
1530         my $wopt;
1531         my $gccver = $predefined_C{__GNUC__} // -1;
1532
1533         if ($gccver >= 4)
1534                 {
1535                 push @strict_warnings_collection, @gcc_devteam_warn;
1536                 push @strict_warnings_collection, @clang_devteam_warn
1537                     if (defined($predefined_C{__clang__}));
1538                 }
1539         elsif ($config{target} =~ /^VC-/)
1540                 {
1541                 push @strict_warnings_collection, @cl_devteam_warn;
1542                 }
1543         else
1544                 {
1545                 warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike, or MSVC"
1546                 }
1547         }
1548
1549 if (grep { $_ eq '-static' } @{$config{LDFLAGS}}) {
1550     disable('static', 'pic', 'threads');
1551 }
1552
1553 $config{CFLAGS} = [ map { $_ eq '--ossl-strict-warnings'
1554                               ? @strict_warnings_collection
1555                               : ( $_ ) }
1556                     @{$config{CFLAGS}} ];
1557
1558 unless ($disabled{"crypto-mdebug-backtrace"})
1559         {
1560         foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1561                 {
1562                 push @{$config{cflags}}, $wopt
1563                         unless grep { $_ eq $wopt } @{$config{cflags}};
1564                 }
1565         if ($target =~ /^BSD-/)
1566                 {
1567                 push @{$config{ex_libs}}, "-lexecinfo";
1568                 }
1569         }
1570
1571 unless ($disabled{afalgeng}) {
1572     $config{afalgeng}="";
1573     if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
1574         my $minver = 4*10000 + 1*100 + 0;
1575         if ($config{CROSS_COMPILE} eq "") {
1576             my $verstr = `uname -r`;
1577             my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1578             ($mi2) = $mi2 =~ /(\d+)/;
1579             my $ver = $ma*10000 + $mi1*100 + $mi2;
1580             if ($ver < $minver) {
1581                 disable('too-old-kernel', 'afalgeng');
1582             } else {
1583                 push @{$config{engdirs}}, "afalg";
1584             }
1585         } else {
1586             disable('cross-compiling', 'afalgeng');
1587         }
1588     } else {
1589         disable('not-linux', 'afalgeng');
1590     }
1591 }
1592
1593 unless ($disabled{devcryptoeng}) {
1594     if ($target =~ m/^BSD/) {
1595         my $maxver = 5*100 + 7;
1596         my $sysstr = `uname -s`;
1597         my $verstr = `uname -r`;
1598         $sysstr =~ s|\R$||;
1599         $verstr =~ s|\R$||;
1600         my ($ma, $mi, @rest) = split m|\.|, $verstr;
1601         my $ver = $ma*100 + $mi;
1602         if ($sysstr eq 'OpenBSD' && $ver >= $maxver) {
1603             disable('too-new-kernel', 'devcryptoeng');
1604         }
1605     }
1606 }
1607
1608 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1609
1610 unless ($disabled{ktls}) {
1611     $config{ktls}="";
1612     if ($target =~ m/^linux/) {
1613         my $usr = "/usr/$config{cross_compile_prefix}";
1614         chop($usr);
1615         if ($config{cross_compile_prefix} eq "") {
1616             $usr = "/usr";
1617         }
1618         my $minver = (4 << 16) + (13 << 8) + 0;
1619         my @verstr = split(" ",`cat $usr/include/linux/version.h | grep LINUX_VERSION_CODE`);
1620
1621         if ($verstr[2] < $minver) {
1622             disable('too-old-kernel', 'ktls');
1623         }
1624     } elsif ($target =~ m/^BSD/) {
1625         my $cc = $config{CROSS_COMPILE}.$config{CC};
1626         system("printf '#include <sys/types.h>\n#include <sys/ktls.h>' | $cc -E - >/dev/null 2>&1");
1627         if ($? != 0) {
1628             disable('too-old-freebsd', 'ktls');
1629         }
1630     } else {
1631         disable('not-linux-or-freebsd', 'ktls');
1632     }
1633 }
1634
1635 push @{$config{openssl_other_defines}}, "OPENSSL_NO_KTLS" if ($disabled{ktls});
1636
1637 # Get the extra flags used when building shared libraries and modules.  We
1638 # do this late because some of them depend on %disabled.
1639
1640 # Make the flags to build DSOs the same as for shared libraries unless they
1641 # are already defined
1642 $target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1643 $target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1644 $target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
1645 {
1646     my $shared_info_pl =
1647         catfile(dirname($0), "Configurations", "shared-info.pl");
1648     my %shared_info = read_eval_file($shared_info_pl);
1649     push @{$target{_conf_fname_int}}, $shared_info_pl;
1650     my $si = $target{shared_target};
1651     while (ref $si ne "HASH") {
1652         last if ! defined $si;
1653         if (ref $si eq "CODE") {
1654             $si = $si->();
1655         } else {
1656             $si = $shared_info{$si};
1657         }
1658     }
1659
1660     # Some of the 'shared_target' values don't have any entries in
1661     # %shared_info.  That's perfectly fine, AS LONG AS the build file
1662     # template knows how to handle this.  That is currently the case for
1663     # Windows and VMS.
1664     if (defined $si) {
1665         # Just as above, copy certain shared_* attributes to the corresponding
1666         # module_ attribute unless the latter is already defined
1667         $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1668         $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1669         $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
1670         foreach (sort keys %$si) {
1671             $target{$_} = defined $target{$_}
1672                 ? add($si->{$_})->($target{$_})
1673                 : $si->{$_};
1674         }
1675     }
1676 }
1677
1678 # ALL MODIFICATIONS TO %disabled, %config and %target MUST BE DONE FROM HERE ON
1679
1680 # If we use the unified build, collect information from build.info files
1681 my %unified_info = ();
1682
1683 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1684 if ($builder eq "unified") {
1685     use Text::Template 1.46;
1686
1687     sub cleandir {
1688         my $base = shift;
1689         my $dir = shift;
1690         my $relativeto = shift || ".";
1691
1692         $dir = catdir($base,$dir) unless isabsolute($dir);
1693
1694         # Make sure the directories we're building in exists
1695         mkpath($dir);
1696
1697         my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1698         #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1699         return $res;
1700     }
1701
1702     sub cleanfile {
1703         my $base = shift;
1704         my $file = shift;
1705         my $relativeto = shift || ".";
1706
1707         $file = catfile($base,$file) unless isabsolute($file);
1708
1709         my $d = dirname($file);
1710         my $f = basename($file);
1711
1712         # Make sure the directories we're building in exists
1713         mkpath($d);
1714
1715         my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1716         #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1717         return $res;
1718     }
1719
1720     # Store the name of the template file we will build the build file from
1721     # in %config.  This may be useful for the build file itself.
1722     my @build_file_template_names =
1723         ( $builder_platform."-".$target{build_file}.".tmpl",
1724           $target{build_file}.".tmpl" );
1725     my @build_file_templates = ();
1726
1727     # First, look in the user provided directory, if given
1728     if (defined env($local_config_envname)) {
1729         @build_file_templates =
1730             map {
1731                 if ($^O eq 'VMS') {
1732                     # VMS environment variables are logical names,
1733                     # which can be used as is
1734                     $local_config_envname . ':' . $_;
1735                 } else {
1736                     catfile(env($local_config_envname), $_);
1737                 }
1738             }
1739             @build_file_template_names;
1740     }
1741     # Then, look in our standard directory
1742     push @build_file_templates,
1743         ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1744           @build_file_template_names );
1745
1746     my $build_file_template;
1747     for $_ (@build_file_templates) {
1748         $build_file_template = $_;
1749         last if -f $build_file_template;
1750
1751         $build_file_template = undef;
1752     }
1753     if (!defined $build_file_template) {
1754         die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1755     }
1756     $config{build_file_templates}
1757       = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1758                     $blddir),
1759           $build_file_template,
1760           cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1761                     $blddir) ];
1762
1763     my @build_dirs = ( [ ] );   # current directory
1764
1765     $config{build_infos} = [ ];
1766
1767     my %ordinals = ();
1768     while (@build_dirs) {
1769         my @curd = @{shift @build_dirs};
1770         my $sourced = catdir($srcdir, @curd);
1771         my $buildd = catdir($blddir, @curd);
1772
1773         my $unixdir = join('/', @curd);
1774         if (exists $skipdir{$unixdir}) {
1775             my $what = $skipdir{$unixdir};
1776             push @{$disabled_info{$what}->{skipped}}, catdir(@curd);
1777             next;
1778         }
1779
1780         mkpath($buildd);
1781
1782         my $f = 'build.info';
1783         # The basic things we're trying to build
1784         my @programs = ();
1785         my @libraries = ();
1786         my @modules = ();
1787         my @scripts = ();
1788
1789         my %sources = ();
1790         my %shared_sources = ();
1791         my %includes = ();
1792         my %defines = ();
1793         my %depends = ();
1794         my %generate = ();
1795         my %htmldocs = ();
1796         my %mandocs = ();
1797
1798         # Support for $variablename in build.info files.
1799         # Embedded perl code is the ultimate master, still.  If its output
1800         # contains a dollar sign, it had better be escaped, or it will be
1801         # taken for a variable name prefix.
1802         my %variables = ();
1803         my $variable_re = qr/\$(?P<VARIABLE>[[:alpha:]][[:alnum:]_]*)/;
1804         my $expand_variables = sub {
1805             my $value = '';
1806             my $value_rest = shift;
1807
1808             if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
1809                 print STDERR
1810                     "DEBUG[\$expand_variables] Parsed '$value_rest' into:\n"
1811             }
1812             while ($value_rest =~ /(?<!\\)${variable_re}/) {
1813                 $value .= $`;
1814                 $value .= $variables{$+{VARIABLE}};
1815                 $value_rest = $';
1816             }
1817             if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
1818                 print STDERR
1819                     "DEBUG[\$expand_variables] ... '$value$value_rest'\n";
1820             }
1821             return $value . $value_rest;
1822         };
1823
1824         # Support for attributes in build.info files
1825         my %attributes = ();
1826         my $handle_attributes = sub {
1827             my $attr_str = shift;
1828             my $ref = shift;
1829             my @goals = @_;
1830
1831             return unless defined $attr_str;
1832
1833             my @a = tokenize($attr_str, qr|\s*,\s*|);
1834             foreach my $a (@a) {
1835                 my $ac = 1;
1836                 my $ak = $a;
1837                 my $av = 1;
1838                 if ($a =~ m|^(!)?(.*?)\s* = \s*(.*?)$|) {
1839                     $ac = ! $1;
1840                     $ak = $1;
1841                     $av = $2;
1842                 }
1843                 foreach my $g (@goals) {
1844                     if ($ac) {
1845                         $$ref->{$g}->{$ak} = $av;
1846                     } else {
1847                         delete $$ref->{$g}->{$ak};
1848                     }
1849                 }
1850             }
1851         };
1852
1853         # We want to detect configdata.pm in the source tree, so we
1854         # don't use it if the build tree is different.
1855         my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1856
1857
1858         if ($buildinfo_debug) {
1859             print STDERR "DEBUG: Reading ",catfile($sourced, $f),"\n";
1860         }
1861         push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1862         my $template =
1863             Text::Template->new(TYPE => 'FILE',
1864                                 SOURCE => catfile($sourced, $f),
1865                                 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
1866         die "Something went wrong with $sourced/$f: $!\n" unless $template;
1867         my @text =
1868             split /^/m,
1869             $template->fill_in(HASH => { config => \%config,
1870                                          target => \%target,
1871                                          disabled => \%disabled,
1872                                          withargs => \%withargs,
1873                                          builddir => abs2rel($buildd, $blddir),
1874                                          sourcedir => abs2rel($sourced, $blddir),
1875                                          buildtop => abs2rel($blddir, $blddir),
1876                                          sourcetop => abs2rel($srcdir, $blddir) },
1877                                DELIMITERS => [ "{-", "-}" ]);
1878
1879         # The top item of this stack has the following values
1880         # -2 positive already run and we found ELSE (following ELSIF should fail)
1881         # -1 positive already run (skip until ENDIF)
1882         # 0 negatives so far (if we're at a condition, check it)
1883         # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1884         # 2 positive ELSE (following ELSIF should fail)
1885         my @skip = ();
1886
1887         # A few useful generic regexps
1888         my $index_re = qr/\[\s*(?P<INDEX>(?:\\.|.)*?)\s*\]/;
1889         my $cond_re = qr/\[\s*(?P<COND>(?:\\.|.)*?)\s*\]/;
1890         my $attribs_re = qr/(?:\{\s*(?P<ATTRIBS>(?:\\.|.)*?)\s*\})?/;
1891         my $value_re = qr/\s*(?P<VALUE>.*?)\s*/;
1892         collect_information(
1893             collect_from_array([ @text ],
1894                                qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1895                                                 $l1 =~ s/\\$//; $l1.$l2 }),
1896             # Info we're looking for
1897             qr/^\s* IF ${cond_re} \s*$/x
1898             => sub {
1899                 if (! @skip || $skip[$#skip] > 0) {
1900                     push @skip, !! $expand_variables->($+{COND});
1901                 } else {
1902                     push @skip, -1;
1903                 }
1904             },
1905             qr/^\s* ELSIF ${cond_re} \s*$/x
1906             => sub { die "ELSIF out of scope" if ! @skip;
1907                      die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1908                      $skip[$#skip] = -1 if $skip[$#skip] != 0;
1909                      $skip[$#skip] = !! $expand_variables->($+{COND})
1910                          if $skip[$#skip] == 0; },
1911             qr/^\s* ELSE \s*$/x
1912             => sub { die "ELSE out of scope" if ! @skip;
1913                      $skip[$#skip] = -2 if $skip[$#skip] != 0;
1914                      $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1915             qr/^\s* ENDIF \s*$/x
1916             => sub { die "ENDIF out of scope" if ! @skip;
1917                      pop @skip; },
1918             qr/^\s* ${variable_re} \s* = ${value_re} $/x
1919             => sub {
1920                 if (!@skip || $skip[$#skip] > 0) {
1921                     $variables{$+{VARIABLE}} = $expand_variables->($+{VALUE});
1922                 }
1923             },
1924             qr/^\s* SUBDIRS \s* = ${value_re} $/x
1925             => sub {
1926                 if (!@skip || $skip[$#skip] > 0) {
1927                     foreach (tokenize($expand_variables->($+{VALUE}))) {
1928                         push @build_dirs, [ @curd, splitdir($_, 1) ];
1929                     }
1930                 }
1931             },
1932             qr/^\s* PROGRAMS ${attribs_re} \s* =  ${value_re} $/x
1933             => sub {
1934                 if (!@skip || $skip[$#skip] > 0) {
1935                     my @p = tokenize($expand_variables->($+{VALUE}));
1936                     push @programs, @p;
1937                     $handle_attributes->($+{ATTRIBS},
1938                                          \$attributes{programs},
1939                                          @p);
1940                 }
1941             },
1942             qr/^\s* LIBS ${attribs_re} \s* =  ${value_re} $/x
1943             => sub {
1944                 if (!@skip || $skip[$#skip] > 0) {
1945                     my @l = tokenize($expand_variables->($+{VALUE}));
1946                     push @libraries, @l;
1947                     $handle_attributes->($+{ATTRIBS},
1948                                          \$attributes{libraries},
1949                                          @l);
1950                 }
1951             },
1952             qr/^\s* MODULES ${attribs_re} \s* =  ${value_re} $/x
1953             => sub {
1954                 if (!@skip || $skip[$#skip] > 0) {
1955                     my @m = tokenize($expand_variables->($+{VALUE}));
1956                     push @modules, @m;
1957                     $handle_attributes->($+{ATTRIBS},
1958                                          \$attributes{modules},
1959                                          @m);
1960                 }
1961             },
1962             qr/^\s* SCRIPTS ${attribs_re} \s* =  ${value_re} $/x
1963             => sub {
1964                 if (!@skip || $skip[$#skip] > 0) {
1965                     my @s = tokenize($expand_variables->($+{VALUE}));
1966                     push @scripts, @s;
1967                     $handle_attributes->($+{ATTRIBS},
1968                                          \$attributes{scripts},
1969                                          @s);
1970                 }
1971             },
1972             qr/^\s* HTMLDOCS ${index_re} = ${value_re} $/x
1973             => sub { push @{$htmldocs{$expand_variables->($+{INDEX})}},
1974                          tokenize($expand_variables->($+{VALUE}))
1975                          if !@skip || $skip[$#skip] > 0 },
1976             qr/^\s* MANDOCS ${index_re} = ${value_re} $/x
1977             => sub { push @{$mandocs{$expand_variables->($+{INDEX})}},
1978                          tokenize($expand_variables->($+{VALUE}))
1979                          if !@skip || $skip[$#skip] > 0 },
1980             qr/^\s* ORDINALS ${index_re} = ${value_re} $/x
1981             => sub { push @{$ordinals{$expand_variables->($+{INDEX})}},
1982                          tokenize($expand_variables->($+{VALUE}))
1983                          if !@skip || $skip[$#skip] > 0 },
1984             qr/^\s* SOURCE ${index_re} = ${value_re} $/x
1985             => sub { push @{$sources{$expand_variables->($+{INDEX})}},
1986                          tokenize($expand_variables->($+{VALUE}))
1987                          if !@skip || $skip[$#skip] > 0 },
1988             qr/^\s* SHARED_SOURCE ${index_re} = ${value_re} $/x
1989             => sub { push @{$shared_sources{$expand_variables->($+{INDEX})}},
1990                          tokenize($expand_variables->($+{VALUE}))
1991                          if !@skip || $skip[$#skip] > 0 },
1992             qr/^\s* INCLUDE ${index_re} = ${value_re} $/x
1993             => sub { push @{$includes{$expand_variables->($+{INDEX})}},
1994                          tokenize($expand_variables->($+{VALUE}))
1995                          if !@skip || $skip[$#skip] > 0 },
1996             qr/^\s* DEFINE ${index_re} = ${value_re} $/x
1997             => sub { push @{$defines{$expand_variables->($+{INDEX})}},
1998                          tokenize($expand_variables->($+{VALUE}))
1999                          if !@skip || $skip[$#skip] > 0 },
2000             qr/^\s* DEPEND ${index_re} ${attribs_re} = ${value_re} $/x
2001             => sub {
2002                 if (!@skip || $skip[$#skip] > 0) {
2003                     my $i = $expand_variables->($+{INDEX});
2004                     my @d = tokenize($expand_variables->($+{VALUE}));
2005                     push @{$depends{$i}}, @d;
2006                     $handle_attributes->($+{ATTRIBS},
2007                                          \$attributes{depends}->{$i},
2008                                          @d);
2009                 }
2010             },
2011             qr/^\s* GENERATE ${index_re} = ${value_re} $/x
2012             => sub { push @{$generate{$expand_variables->($+{INDEX})}},
2013                          $+{VALUE}
2014                          if !@skip || $skip[$#skip] > 0 },
2015             qr/^\s* (?:\#.*)? $/x => sub { },
2016             "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
2017             "BEFORE" => sub {
2018                 if ($buildinfo_debug) {
2019                     print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
2020                     print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2021                 }
2022             },
2023             "AFTER" => sub {
2024                 if ($buildinfo_debug) {
2025                     print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2026                 }
2027             },
2028             );
2029         die "runaway IF?" if (@skip);
2030
2031         if (grep { defined $attributes{modules}->{$_}->{engine} } keys %attributes
2032                 and !$config{dynamic_engines}) {
2033             die <<"EOF"
2034 ENGINES can only be used if configured with 'dynamic-engine'.
2035 This is usually a fault in a build.info file.
2036 EOF
2037         }
2038
2039         {
2040             my %infos = ( programs  => [ @programs  ],
2041                           libraries => [ @libraries ],
2042                           modules   => [ @modules   ],
2043                           scripts   => [ @scripts   ] );
2044             foreach my $k (keys %infos) {
2045                 foreach (@{$infos{$k}}) {
2046                     my $item = cleanfile($buildd, $_, $blddir);
2047                     $unified_info{$k}->{$item} = 1;
2048
2049                     # Fix up associated attributes
2050                     $unified_info{attributes}->{$k}->{$item} =
2051                         $attributes{$k}->{$_}
2052                         if defined $attributes{$k}->{$_};
2053                 }
2054             }
2055         }
2056
2057         # Check that we haven't defined any library as both shared and
2058         # explicitly static.  That is forbidden.
2059         my @doubles = ();
2060         foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
2061             (my $l = $_) =~ s/\.a$//;
2062             push @doubles, $l if defined $unified_info{libraries}->{$l};
2063         }
2064         die "these libraries are both explicitly static and shared:\n  ",
2065             join(" ", @doubles), "\n"
2066             if @doubles;
2067
2068         foreach (keys %sources) {
2069             my $dest = $_;
2070             my $ddest = cleanfile($buildd, $_, $blddir);
2071             foreach (@{$sources{$dest}}) {
2072                 my $s = cleanfile($sourced, $_, $blddir);
2073
2074                 # If it isn't in the source tree, we assume it's generated
2075                 # in the build tree
2076                 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2077                     $s = cleanfile($buildd, $_, $blddir);
2078                 }
2079                 # We recognise C++, C and asm files
2080                 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2081                     my $o = $_;
2082                     $o =~ s/\.[csS]$/.o/; # C and assembler
2083                     $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2084                     $o = cleanfile($buildd, $o, $blddir);
2085                     $unified_info{sources}->{$ddest}->{$o} = -1;
2086                     $unified_info{sources}->{$o}->{$s} = -1;
2087                 } elsif ($s =~ /\.rc$/) {
2088                     # We also recognise resource files
2089                     my $o = $_;
2090                     $o =~ s/\.rc$/.res/; # Resource configuration
2091                     my $o = cleanfile($buildd, $o, $blddir);
2092                     $unified_info{sources}->{$ddest}->{$o} = -1;
2093                     $unified_info{sources}->{$o}->{$s} = -1;
2094                 } else {
2095                     $unified_info{sources}->{$ddest}->{$s} = 1;
2096                 }
2097             }
2098         }
2099
2100         foreach (keys %shared_sources) {
2101             my $dest = $_;
2102             my $ddest = cleanfile($buildd, $_, $blddir);
2103             foreach (@{$shared_sources{$dest}}) {
2104                 my $s = cleanfile($sourced, $_, $blddir);
2105
2106                 # If it isn't in the source tree, we assume it's generated
2107                 # in the build tree
2108                 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2109                     $s = cleanfile($buildd, $_, $blddir);
2110                 }
2111
2112                 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2113                     # We recognise C++, C and asm files
2114                     my $o = $_;
2115                     $o =~ s/\.[csS]$/.o/; # C and assembler
2116                     $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2117                     $o = cleanfile($buildd, $o, $blddir);
2118                     $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2119                     $unified_info{sources}->{$o}->{$s} = -1;
2120                 } elsif ($s =~ /\.rc$/) {
2121                     # We also recognise resource files
2122                     my $o = $_;
2123                     $o =~ s/\.rc$/.res/; # Resource configuration
2124                     my $o = cleanfile($buildd, $o, $blddir);
2125                     $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2126                     $unified_info{sources}->{$o}->{$s} = -1;
2127                 } elsif ($s =~ /\.ld$/) {
2128                     # We also recognise linker scripts (or corresponding)
2129                     # We know they are generated files
2130                     my $ld = cleanfile($buildd, $_, $blddir);
2131                     $unified_info{shared_sources}->{$ddest}->{$ld} = 1;
2132                 } else {
2133                     die "unrecognised source file type for shared library: $s\n";
2134                 }
2135             }
2136         }
2137
2138         foreach (keys %generate) {
2139             my $dest = $_;
2140             my $ddest = cleanfile($buildd, $_, $blddir);
2141             die "more than one generator for $dest: "
2142                 ,join(" ", @{$generate{$_}}),"\n"
2143                 if scalar @{$generate{$_}} > 1;
2144             my @generator = split /\s+/, $generate{$dest}->[0];
2145             my $gen = $generator[0];
2146             $generator[0] = cleanfile($sourced, $gen, $blddir);
2147
2148             # If the generator isn't in the source tree, we assume it's
2149             # generated in the build tree
2150             if ($generate{$gen}) {
2151                 $generator[0] = cleanfile($buildd, $gen, $blddir);
2152             }
2153
2154             $unified_info{generate}->{$ddest} = [ @generator ];
2155         }
2156
2157         foreach (keys %depends) {
2158             my $dest = $_;
2159             my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
2160
2161             # If the destination doesn't exist in source, it can only be
2162             # a generated file in the build tree.
2163             if ($ddest ne "" && ($ddest eq $src_configdata || ! -f $ddest)) {
2164                 $ddest = cleanfile($buildd, $_, $blddir);
2165             }
2166             foreach (@{$depends{$dest}}) {
2167                 my $d = cleanfile($sourced, $_, $blddir);
2168
2169                 # If we know it's generated, or assume it is because we can't
2170                 # find it in the source tree, we set file we depend on to be
2171                 # in the build tree rather than the source tree, and assume
2172                 # and that there are lines to build it in a BEGINRAW..ENDRAW
2173                 # section or in the Makefile template.
2174                 if ($d eq $src_configdata
2175                     || ! -f $d
2176                     || (grep { $d eq $_ }
2177                         map { cleanfile($srcdir, $_, $blddir) }
2178                         grep { /\.h$/ } keys %{$unified_info{generate}})) {
2179                     $d = cleanfile($buildd, $_, $blddir);
2180                 }
2181                 # Take note if the file to depend on is being renamed
2182                 # Take extra care with files ending with .a, they should
2183                 # be treated without that extension, and the extension
2184                 # should be added back after treatment.
2185                 $d =~ /(\.a)?$/;
2186                 my $e = $1 // "";
2187                 $d = $`.$e;
2188                 $unified_info{depends}->{$ddest}->{$d} = 1;
2189
2190                 # Fix up associated attributes
2191                 $unified_info{attributes}->{depends}->{$ddest}->{$d} =
2192                     $attributes{depends}->{$dest}->{$_}
2193                     if defined $attributes{depends}->{$dest}->{$_};
2194             }
2195         }
2196
2197         foreach (keys %includes) {
2198             my $dest = $_;
2199             my $ddest = cleanfile($sourced, $_, $blddir);
2200
2201             # If the destination doesn't exist in source, it can only be
2202             # a generated file in the build tree.
2203             if ($ddest eq $src_configdata || ! -f $ddest) {
2204                 $ddest = cleanfile($buildd, $_, $blddir);
2205             }
2206             foreach (@{$includes{$dest}}) {
2207                 my $is = cleandir($sourced, $_, $blddir);
2208                 my $ib = cleandir($buildd, $_, $blddir);
2209                 push @{$unified_info{includes}->{$ddest}->{source}}, $is
2210                     unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2211                 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2212                     unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
2213             }
2214         }
2215
2216         foreach my $dest (keys %defines) {
2217             my $ddest;
2218
2219             if ($dest ne "") {
2220                 $ddest = cleanfile($sourced, $dest, $blddir);
2221
2222                 # If the destination doesn't exist in source, it can only
2223                 # be a generated file in the build tree.
2224                 if (! -f $ddest) {
2225                     $ddest = cleanfile($buildd, $dest, $blddir);
2226                     if ($unified_info{rename}->{$ddest}) {
2227                         $ddest = $unified_info{rename}->{$ddest};
2228                     }
2229                 }
2230             }
2231             foreach my $v (@{$defines{$dest}}) {
2232                 $v =~ m|^([^=]*)(=.*)?$|;
2233                 die "0 length macro name not permitted\n" if $1 eq "";
2234                 if ($dest ne "") {
2235                     die "$1 defined more than once\n"
2236                         if defined $unified_info{defines}->{$ddest}->{$1};
2237                     $unified_info{defines}->{$ddest}->{$1} = $2;
2238                 } else {
2239                     die "$1 defined more than once\n"
2240                         if grep { $v eq $_ } @{$config{defines}};
2241                     push @{$config{defines}}, $v;
2242                 }
2243             }
2244         }
2245
2246         foreach my $section (keys %htmldocs) {
2247             foreach (@{$htmldocs{$section}}) {
2248                 my $htmldocs = cleanfile($buildd, $_, $blddir);
2249                 $unified_info{htmldocs}->{$section}->{$htmldocs} = 1;
2250             }
2251         }
2252
2253         foreach my $section (keys %mandocs) {
2254             foreach (@{$mandocs{$section}}) {
2255                 my $mandocs = cleanfile($buildd, $_, $blddir);
2256                 $unified_info{mandocs}->{$section}->{$mandocs} = 1;
2257             }
2258         }
2259     }
2260
2261     my $ordinals_text = join(', ', sort keys %ordinals);
2262     warn <<"EOF" if $ordinals_text;
2263
2264 WARNING: ORDINALS were specified for $ordinals_text
2265 They are ignored and should be replaced with a combination of GENERATE,
2266 DEPEND and SHARED_SOURCE.
2267 EOF
2268
2269
2270     # Go through the sources of all libraries and check that the same basename
2271     # doesn't appear more than once.  Some static library archivers depend on
2272     # them being unique.
2273     {
2274         my $err = 0;
2275         foreach my $prod (keys %{$unified_info{libraries}}) {
2276             my @prod_sources =
2277                 map { keys %{$unified_info{sources}->{$_}} }
2278                 keys %{$unified_info{sources}->{$prod}};
2279             my %srccnt = ();
2280
2281             # Count how many times a given each source basename
2282             # appears for each product.
2283             foreach my $src (@prod_sources) {
2284                 $srccnt{basename $src}++;
2285             }
2286
2287             foreach my $src (keys %srccnt) {
2288                 if ((my $cnt = $srccnt{$src}) > 1) {
2289                     print STDERR "$src appears $cnt times for the product $prod\n";
2290                     $err++
2291                 }
2292             }
2293         }
2294         die if $err > 0;
2295     }
2296
2297     # Massage the result
2298
2299     # If we depend on a header file or a perl module, add an inclusion of
2300     # its directory to allow smoothe inclusion
2301     foreach my $dest (keys %{$unified_info{depends}}) {
2302         next if $dest eq "";
2303         foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2304             next unless $d =~ /\.(h|pm)$/;
2305             my $i = dirname($d);
2306             my $spot =
2307                 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2308                 ? 'build' : 'source';
2309             push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2310                 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
2311         }
2312     }
2313
2314     # Go through all intermediary files and change their names to something that
2315     # reflects what they will be built for.  Note that for some source files,
2316     # this leads to duplicate object files because they are used multiple times.
2317     # the goal is to rename all object files according to this scheme:
2318     #    {productname}-{midfix}-{origobjname}.[o|res]
2319     # the {midfix} is a keyword indicating the type of product, which is mostly
2320     # valuable for libraries since they come in two forms.
2321     #
2322     # This also reorganises the {sources} and {shared_sources} so that the
2323     # former only contains ALL object files that are supposed to end up in
2324     # static libraries and programs, while the latter contains ALL object files
2325     # that are supposed to end up in shared libraries and DSOs.
2326     # The main reason for having two different source structures is to allow
2327     # the same name to be used for the static and the shared variants of a
2328     # library.
2329     {
2330         # Take copies so we don't get interference from added stuff
2331         my %unified_copy = ();
2332         foreach (('sources', 'shared_sources')) {
2333             $unified_copy{$_} = { %{$unified_info{$_}} }
2334                 if defined($unified_info{$_});
2335             delete $unified_info{$_};
2336         }
2337         foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
2338             # $intent serves multi purposes:
2339             # - give a prefix for the new object files names
2340             # - in the case of libraries, rearrange the object files so static
2341             #   libraries use the 'sources' structure exclusively, while shared
2342             #   libraries use the 'shared_sources' structure exclusively.
2343             my $intent = {
2344                 programs  => { bin    => { src => [ 'sources' ],
2345                                            dst => 'sources' } },
2346                 libraries => { lib    => { src => [ 'sources' ],
2347                                            dst => 'sources' },
2348                                shlib  => { prodselect =>
2349                                                sub { grep !/\.a$/, @_ },
2350                                            src => [ 'sources',
2351                                                     'shared_sources' ],
2352                                            dst => 'shared_sources' } },
2353                 modules   => { dso    => { src => [ 'sources' ],
2354                                            dst => 'sources' } },
2355                 scripts   => { script => { src => [ 'sources' ],
2356                                            dst => 'sources' } }
2357                } -> {$prodtype};
2358             foreach my $kind (keys %$intent) {
2359                 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2360                              && $disabled{shared});
2361
2362                 my @src = @{$intent->{$kind}->{src}};
2363                 my $dst = $intent->{$kind}->{dst};
2364                 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2365                 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2366                     # %prod_sources has all applicable objects as keys, and
2367                     # their corresponding sources as values
2368                     my %prod_sources =
2369                         map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2370                         map { keys %{$unified_copy{$_}->{$prod}} }
2371                         @src;
2372                     foreach (keys %prod_sources) {
2373                         # Only affect object files and resource files,
2374                         # the others simply get a new value
2375                         # (+1 instead of -1)
2376                         if ($_ =~ /\.(o|res)$/) {
2377                             (my $prodname = $prod) =~ s|\.a$||;
2378                             my $newobj =
2379                                 catfile(dirname($_),
2380                                         basename($prodname)
2381                                             . '-' . $kind
2382                                             . '-' . basename($_));
2383                             $unified_info{$dst}->{$prod}->{$newobj} = 1;
2384                             foreach my $src (@{$prod_sources{$_}}) {
2385                                 $unified_info{sources}->{$newobj}->{$src} = 1;
2386                             }
2387                             # Adjust dependencies
2388                             foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2389                                 $unified_info{depends}->{$_}->{$deps} = -1;
2390                                 $unified_info{depends}->{$newobj}->{$deps} = 1;
2391                             }
2392                             # Adjust includes
2393                             foreach my $k (('source', 'build')) {
2394                                 next unless
2395                                     defined($unified_info{includes}->{$_}->{$k});
2396                                 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2397                                 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2398                             }
2399                         } else {
2400                             $unified_info{$dst}->{$prod}->{$_} = 1;
2401                         }
2402                     }
2403                 }
2404             }
2405         }
2406     }
2407
2408     # At this point, we have a number of sources with the value -1.  They
2409     # aren't part of the local build and are probably meant for a different
2410     # platform, and can therefore be cleaned away.  That happens when making
2411     # %unified_info more efficient below.
2412
2413     ### Make unified_info a bit more efficient
2414     # One level structures
2415     foreach (("programs", "libraries", "modules", "scripts")) {
2416         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2417     }
2418     # Two level structures
2419     foreach my $l1 (("sources", "shared_sources", "ldadd", "depends",
2420                      "htmldocs", "mandocs")) {
2421         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
2422             my @items =
2423                 sort
2424                 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2425                 keys %{$unified_info{$l1}->{$l2}};
2426             if (@items) {
2427                 $unified_info{$l1}->{$l2} = [ @items ];
2428             } else {
2429                 delete $unified_info{$l1}->{$l2};
2430             }
2431         }
2432     }
2433     # Defines
2434     foreach my $dest (sort keys %{$unified_info{defines}}) {
2435         $unified_info{defines}->{$dest}
2436             = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2437                 sort keys %{$unified_info{defines}->{$dest}} ];
2438     }
2439     # Includes
2440     foreach my $dest (sort keys %{$unified_info{includes}}) {
2441         if (defined($unified_info{includes}->{$dest}->{build})) {
2442             my @source_includes = ();
2443             @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2444                 if defined($unified_info{includes}->{$dest}->{source});
2445             $unified_info{includes}->{$dest} =
2446                 [ @{$unified_info{includes}->{$dest}->{build}} ];
2447             foreach my $inc (@source_includes) {
2448                 push @{$unified_info{includes}->{$dest}}, $inc
2449                     unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2450             }
2451         } elsif (defined($unified_info{includes}->{$dest}->{source})) {
2452             $unified_info{includes}->{$dest} =
2453                 [ @{$unified_info{includes}->{$dest}->{source}} ];
2454         } else {
2455             delete $unified_info{includes}->{$dest};
2456         }
2457     }
2458
2459     # For convenience collect information regarding directories where
2460     # files are generated, those generated files and the end product
2461     # they end up in where applicable.  Then, add build rules for those
2462     # directories
2463     my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
2464                      "dso" => [ @{$unified_info{modules}} ],
2465                      "bin" => [ @{$unified_info{programs}} ],
2466                      "script" => [ @{$unified_info{scripts}} ],
2467                      "docs" => [ (map { @{$unified_info{htmldocs}->{$_} // []} }
2468                                   keys %{$unified_info{htmldocs} // {}}),
2469                                  (map { @{$unified_info{mandocs}->{$_} // []} }
2470                                   keys %{$unified_info{mandocs} // {}}) ] );
2471     foreach my $type (keys %loopinfo) {
2472         foreach my $product (@{$loopinfo{$type}}) {
2473             my %dirs = ();
2474             my $pd = dirname($product);
2475
2476             foreach (@{$unified_info{sources}->{$product} // []},
2477                      @{$unified_info{shared_sources}->{$product} // []}) {
2478                 my $d = dirname($_);
2479
2480                 # We don't want to create targets for source directories
2481                 # when building out of source
2482                 next if ($config{sourcedir} ne $config{builddir}
2483                              && $d =~ m|^\Q$config{sourcedir}\E|);
2484                 # We already have a "test" target, and the current directory
2485                 # is just silly to make a target for
2486                 next if $d eq "test" || $d eq ".";
2487
2488                 $dirs{$d} = 1;
2489                 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2490                     if $d ne $pd;
2491             }
2492             foreach (keys %dirs) {
2493                 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2494                     $product;
2495             }
2496         }
2497     }
2498 }
2499
2500 # For the schemes that need it, we provide the old *_obj configs
2501 # from the *_asm_obj ones
2502 foreach (grep /_(asm|aux)_src$/, keys %target) {
2503     my $src = $_;
2504     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2505     $target{$obj} = $target{$src};
2506     $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2507     $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2508 }
2509
2510 # Write down our configuration where it fits #########################
2511
2512 my %template_vars = (
2513     config => \%config,
2514     target => \%target,
2515     disablables => \@disablables,
2516     disablables_int => \@disablables_int,
2517     disabled => \%disabled,
2518     withargs => \%withargs,
2519     unified_info => \%unified_info,
2520     tls => \@tls,
2521     dtls => \@dtls,
2522     makevars => [ sort keys %user ],
2523     disabled_info => \%disabled_info,
2524     user_crossable => \@user_crossable,
2525 );
2526 my $configdata_outname = 'configdata.pm';
2527 print "Creating $configdata_outname\n";
2528 open CONFIGDATA, ">$configdata_outname.new"
2529             or die "Trying to create $configdata_outname.new: $!";
2530 my $configdata_tmplname = cleanfile($srcdir, "configdata.pm.in", $blddir);
2531 my $configdata_tmpl =
2532     OpenSSL::Template->new(TYPE => 'FILE', SOURCE => $configdata_tmplname);
2533 $configdata_tmpl->fill_in(
2534     FILENAME => $configdata_tmplname,
2535     OUTPUT => \*CONFIGDATA,
2536     HASH => { %template_vars,
2537               autowarntext => [
2538                   'WARNING: do not edit!',
2539                   "Generated by Configure from $configdata_tmplname",
2540               ] }
2541 ) or die $Text::Template::ERROR;
2542 close CONFIGDATA;
2543 rename "$configdata_outname.new", $configdata_outname;
2544 if ($builder_platform eq 'unix') {
2545     my $mode = (0755 & ~umask);
2546     chmod $mode, 'configdata.pm'
2547         or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2548 }
2549
2550 print "Running $configdata_outname\n";
2551 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
2552 my $cmd = "$perlcmd $configdata_outname";
2553 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2554 system($cmd);
2555 exit 1 if $? != 0;
2556
2557 $SIG{__DIE__} = $orig_death_handler;
2558
2559 print <<"EOF" if ($disabled{threads} eq "unavailable");
2560
2561 The library could not be configured for supporting multi-threaded
2562 applications as the compiler options required on this system are not known.
2563 See file INSTALL for details if you need multi-threading.
2564 EOF
2565
2566 print <<"EOF" if ($no_shared_warn);
2567
2568 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2569 platform, so we will pretend you gave the option 'no-pic', which also disables
2570 'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
2571 or position independent code, please let us know (but please first make sure
2572 you have tried with a current version of OpenSSL).
2573 EOF
2574
2575 print <<"EOF";
2576
2577 **********************************************************************
2578 ***                                                                ***
2579 ***   OpenSSL has been successfully configured                     ***
2580 ***                                                                ***
2581 ***   If you encounter a problem while building, please open an    ***
2582 ***   issue on GitHub <https://github.com/openssl/openssl/issues>  ***
2583 ***   and include the output from the following command:           ***
2584 ***                                                                ***
2585 ***       perl configdata.pm --dump                                ***
2586 ***                                                                ***
2587 ***   (If you are new to OpenSSL, you might want to consult the    ***
2588 ***   'Troubleshooting' section in the INSTALL file first)         ***
2589 ***                                                                ***
2590 **********************************************************************
2591 EOF
2592
2593 exit(0);
2594
2595 ######################################################################
2596 #
2597 # Helpers and utility functions
2598 #
2599
2600 # Death handler, to print a helpful message in case of failure #######
2601 #
2602 sub death_handler {
2603     die @_ if $^S;              # To prevent the added message in eval blocks
2604     my $build_file = $target{build_file} // "build file";
2605     my @message = ( <<"_____", @_ );
2606
2607 Failure!  $build_file wasn't produced.
2608 Please read INSTALL and associated NOTES files.  You may also have to look over
2609 your available compiler tool chain or change your configuration.
2610
2611 _____
2612
2613     # Dying is terminal, so it's ok to reset the signal handler here.
2614     $SIG{__DIE__} = $orig_death_handler;
2615     die @message;
2616 }
2617
2618 # Configuration file reading #########################################
2619
2620 # Note: All of the helper functions are for lazy evaluation.  They all
2621 # return a CODE ref, which will return the intended value when evaluated.
2622 # Thus, whenever there's mention of a returned value, it's about that
2623 # intended value.
2624
2625 # Helper function to implement conditional value variants, with a default
2626 # plus additional values based on the value of $config{build_type}.
2627 # Arguments are given in hash table form:
2628 #
2629 #       picker(default => "Basic string: ",
2630 #              debug   => "debug",
2631 #              release => "release")
2632 #
2633 # When configuring with --debug, the resulting string will be
2634 # "Basic string: debug", and when not, it will be "Basic string: release"
2635 #
2636 # This can be used to create variants of sets of flags according to the
2637 # build type:
2638 #
2639 #       cflags => picker(default => "-Wall",
2640 #                        debug   => "-g -O0",
2641 #                        release => "-O3")
2642 #
2643 sub picker {
2644     my %opts = @_;
2645     return sub { add($opts{default} || (),
2646                      $opts{$config{build_type}} || ())->(); }
2647 }
2648
2649 # Helper function to combine several values of different types into one.
2650 # This is useful if you want to combine a string with the result of a
2651 # lazy function, such as:
2652 #
2653 #       cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2654 #
2655 sub combine {
2656     my @stuff = @_;
2657     return sub { add(@stuff)->(); }
2658 }
2659
2660 # Helper function to implement conditional values depending on the value
2661 # of $disabled{threads}.  Can be used as follows:
2662 #
2663 #       cflags => combine("-Wall", threads("-pthread"))
2664 #
2665 sub threads {
2666     my @flags = @_;
2667     return sub { add($disabled{threads} ? () : @flags)->(); }
2668 }
2669
2670 sub shared {
2671     my @flags = @_;
2672     return sub { add($disabled{shared} ? () : @flags)->(); }
2673 }
2674
2675 our $add_called = 0;
2676 # Helper function to implement adding values to already existing configuration
2677 # values.  It handles elements that are ARRAYs, CODEs and scalars
2678 sub _add {
2679     my $separator = shift;
2680
2681     # If there's any ARRAY in the collection of values OR the separator
2682     # is undef, we will return an ARRAY of combined values, otherwise a
2683     # string of joined values with $separator as the separator.
2684     my $found_array = !defined($separator);
2685
2686     my @values =
2687         map {
2688             my $res = $_;
2689             while (ref($res) eq "CODE") {
2690                 $res = $res->();
2691             }
2692             if (defined($res)) {
2693                 if (ref($res) eq "ARRAY") {
2694                     $found_array = 1;
2695                     @$res;
2696                 } else {
2697                     $res;
2698                 }
2699             } else {
2700                 ();
2701             }
2702     } (@_);
2703
2704     $add_called = 1;
2705
2706     if ($found_array) {
2707         [ @values ];
2708     } else {
2709         join($separator, grep { defined($_) && $_ ne "" } @values);
2710     }
2711 }
2712 sub add_before {
2713     my $separator = " ";
2714     if (ref($_[$#_]) eq "HASH") {
2715         my $opts = pop;
2716         $separator = $opts->{separator};
2717     }
2718     my @x = @_;
2719     sub { _add($separator, @x, @_) };
2720 }
2721 sub add {
2722     my $separator = " ";
2723     if (ref($_[$#_]) eq "HASH") {
2724         my $opts = pop;
2725         $separator = $opts->{separator};
2726     }
2727     my @x = @_;
2728     sub { _add($separator, @_, @x) };
2729 }
2730
2731 sub read_eval_file {
2732     my $fname = shift;
2733     my $content;
2734     my @result;
2735
2736     open F, "< $fname" or die "Can't open '$fname': $!\n";
2737     {
2738         undef local $/;
2739         $content = <F>;
2740     }
2741     close F;
2742     {
2743         local $@;
2744
2745         @result = ( eval $content );
2746         warn $@ if $@;
2747     }
2748     return wantarray ? @result : $result[0];
2749 }
2750
2751 # configuration reader, evaluates the input file as a perl script and expects
2752 # it to fill %targets with target configurations.  Those are then added to
2753 # %table.
2754 sub read_config {
2755     my $fname = shift;
2756     my %targets;
2757
2758     {
2759         # Protect certain tables from tampering
2760         local %table = ();
2761
2762         %targets = read_eval_file($fname);
2763     }
2764     my %preexisting = ();
2765     foreach (sort keys %targets) {
2766         $preexisting{$_} = 1 if $table{$_};
2767     }
2768     die <<"EOF",
2769 The following config targets from $fname
2770 shadow pre-existing config targets with the same name:
2771 EOF
2772         map { "  $_\n" } sort keys %preexisting
2773         if %preexisting;
2774
2775
2776     # For each target, check that it's configured with a hash table.
2777     foreach (keys %targets) {
2778         if (ref($targets{$_}) ne "HASH") {
2779             if (ref($targets{$_}) eq "") {
2780                 warn "Deprecated target configuration for $_, ignoring...\n";
2781             } else {
2782                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2783             }
2784             delete $targets{$_};
2785         } else {
2786             $targets{$_}->{_conf_fname_int} = add([ $fname ]);
2787         }
2788     }
2789
2790     %table = (%table, %targets);
2791
2792 }
2793
2794 # configuration resolver.  Will only resolve all the lazy evaluation
2795 # codeblocks for the chosen target and all those it inherits from,
2796 # recursively
2797 sub resolve_config {
2798     my $target = shift;
2799     my @breadcrumbs = @_;
2800
2801 #    my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2802
2803     if (grep { $_ eq $target } @breadcrumbs) {
2804         die "inherit_from loop!  target backtrace:\n  "
2805             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
2806     }
2807
2808     if (!defined($table{$target})) {
2809         warn "Warning! target $target doesn't exist!\n";
2810         return ();
2811     }
2812     # Recurse through all inheritances.  They will be resolved on the
2813     # fly, so when this operation is done, they will all just be a
2814     # bunch of attributes with string values.
2815     # What we get here, though, are keys with references to lists of
2816     # the combined values of them all.  We will deal with lists after
2817     # this stage is done.
2818     my %combined_inheritance = ();
2819     if ($table{$target}->{inherit_from}) {
2820         my @inherit_from =
2821             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2822         foreach (@inherit_from) {
2823             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2824
2825             # 'template' is a marker that's considered private to
2826             # the config that had it.
2827             delete $inherited_config{template};
2828
2829             foreach (keys %inherited_config) {
2830                 if (!$combined_inheritance{$_}) {
2831                     $combined_inheritance{$_} = [];
2832                 }
2833                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2834             }
2835         }
2836     }
2837
2838     # We won't need inherit_from in this target any more, since we've
2839     # resolved all the inheritances that lead to this
2840     delete $table{$target}->{inherit_from};
2841
2842     # Now is the time to deal with those lists.  Here's the place to
2843     # decide what shall be done with those lists, all based on the
2844     # values of the target we're currently dealing with.
2845     # - If a value is a coderef, it will be executed with the list of
2846     #   inherited values as arguments.
2847     # - If the corresponding key doesn't have a value at all or is the
2848     #   empty string, the inherited value list will be run through the
2849     #   default combiner (below), and the result becomes this target's
2850     #   value.
2851     # - Otherwise, this target's value is assumed to be a string that
2852     #   will simply override the inherited list of values.
2853     my $default_combiner = add();
2854
2855     my %all_keys =
2856         map { $_ => 1 } (keys %combined_inheritance,
2857                          keys %{$table{$target}});
2858
2859     sub process_values {
2860         my $object    = shift;
2861         my $inherited = shift;  # Always a [ list ]
2862         my $target    = shift;
2863         my $entry     = shift;
2864
2865         $add_called = 0;
2866
2867         while(ref($object) eq "CODE") {
2868             $object = $object->(@$inherited);
2869         }
2870         if (!defined($object)) {
2871             return ();
2872         }
2873         elsif (ref($object) eq "ARRAY") {
2874             local $add_called;  # To make sure recursive calls don't affect it
2875             return [ map { process_values($_, $inherited, $target, $entry) }
2876                      @$object ];
2877         } elsif (ref($object) eq "") {
2878             return $object;
2879         } else {
2880             die "cannot handle reference type ",ref($object)
2881                 ," found in target ",$target," -> ",$entry,"\n";
2882         }
2883     }
2884
2885     foreach (sort keys %all_keys) {
2886         my $previous = $combined_inheritance{$_};
2887
2888         # Current target doesn't have a value for the current key?
2889         # Assign it the default combiner, the rest of this loop body
2890         # will handle it just like any other coderef.
2891         if (!exists $table{$target}->{$_}) {
2892             $table{$target}->{$_} = $default_combiner;
2893         }
2894
2895         $table{$target}->{$_} = process_values($table{$target}->{$_},
2896                                                $combined_inheritance{$_},
2897                                                $target, $_);
2898         unless(defined($table{$target}->{$_})) {
2899             delete $table{$target}->{$_};
2900         }
2901 #        if ($extra_checks &&
2902 #            $previous && !($add_called ||  $previous ~~ $table{$target}->{$_})) {
2903 #            warn "$_ got replaced in $target\n";
2904 #        }
2905     }
2906
2907     # Finally done, return the result.
2908     return %{$table{$target}};
2909 }
2910
2911 sub usage
2912         {
2913         print STDERR $usage;
2914         print STDERR "\npick os/compiler from:\n";
2915         my $j=0;
2916         my $i;
2917         my $k=0;
2918         foreach $i (sort keys %table)
2919                 {
2920                 next if $table{$i}->{template};
2921                 next if $i =~ /^debug/;
2922                 $k += length($i) + 1;
2923                 if ($k > 78)
2924                         {
2925                         print STDERR "\n";
2926                         $k=length($i);
2927                         }
2928                 print STDERR $i . " ";
2929                 }
2930         foreach $i (sort keys %table)
2931                 {
2932                 next if $table{$i}->{template};
2933                 next if $i !~ /^debug/;
2934                 $k += length($i) + 1;
2935                 if ($k > 78)
2936                         {
2937                         print STDERR "\n";
2938                         $k=length($i);
2939                         }
2940                 print STDERR $i . " ";
2941                 }
2942         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2943         exit(1);
2944         }
2945
2946 sub compiler_predefined {
2947     state %predefined;
2948     my $cc = shift;
2949
2950     return () if $^O eq 'VMS';
2951
2952     die 'compiler_predefined called without a compiler command'
2953         unless $cc;
2954
2955     if (! $predefined{$cc}) {
2956
2957         $predefined{$cc} = {};
2958
2959         # collect compiler pre-defines from gcc or gcc-alike...
2960         open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
2961         while (my $l = <PIPE>) {
2962             $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
2963             $predefined{$cc}->{$1} = $2 // '';
2964         }
2965         close(PIPE);
2966     }
2967
2968     return %{$predefined{$cc}};
2969 }
2970
2971 sub which
2972 {
2973     my ($name)=@_;
2974
2975     if (eval { require IPC::Cmd; 1; }) {
2976         IPC::Cmd->import();
2977         return scalar IPC::Cmd::can_run($name);
2978     } else {
2979         # if there is $directories component in splitpath,
2980         # then it's not something to test with $PATH...
2981         return $name if (File::Spec->splitpath($name))[1];
2982
2983         foreach (File::Spec->path()) {
2984             my $fullpath = catfile($_, "$name$target{exe_extension}");
2985             if (-f $fullpath and -x $fullpath) {
2986                 return $fullpath;
2987             }
2988         }
2989     }
2990 }
2991
2992 sub env
2993 {
2994     my $name = shift;
2995     my %opts = @_;
2996
2997     unless ($opts{cacheonly}) {
2998         # Note that if $ENV{$name} doesn't exist or is undefined,
2999         # $config{perlenv}->{$name} will be created with the value
3000         # undef.  This is intentional.
3001
3002         $config{perlenv}->{$name} = $ENV{$name}
3003             if ! exists $config{perlenv}->{$name};
3004     }
3005     return $config{perlenv}->{$name};
3006 }
3007
3008 # Configuration printer ##############################################
3009
3010 sub print_table_entry
3011 {
3012     local $now_printing = shift;
3013     my %target = resolve_config($now_printing);
3014     my $type = shift;
3015
3016     # Don't print the templates
3017     return if $target{template};
3018
3019     my @sequence = (
3020         "sys_id",
3021         "cpp",
3022         "cppflags",
3023         "defines",
3024         "includes",
3025         "cc",
3026         "cflags",
3027         "ld",
3028         "lflags",
3029         "loutflag",
3030         "ex_libs",
3031         "bn_ops",
3032         "poly1035_asm_src",
3033         "thread_scheme",
3034         "perlasm_scheme",
3035         "dso_scheme",
3036         "shared_target",
3037         "shared_cflag",
3038         "shared_defines",
3039         "shared_ldflag",
3040         "shared_rcflag",
3041         "shared_extension",
3042         "dso_extension",
3043         "obj_extension",
3044         "exe_extension",
3045         "ranlib",
3046         "ar",
3047         "arflags",
3048         "aroutflag",
3049         "rc",
3050         "rcflags",
3051         "rcoutflag",
3052         "mt",
3053         "mtflags",
3054         "mtinflag",
3055         "mtoutflag",
3056         "multilib",
3057         "build_scheme",
3058         );
3059
3060     if ($type eq "TABLE") {
3061         print "\n";
3062         print "*** $now_printing\n";
3063         foreach (@sequence) {
3064             if (ref($target{$_}) eq "ARRAY") {
3065                 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3066             } else {
3067                 printf "\$%-12s = %s\n", $_, $target{$_};
3068             }
3069         }
3070     } elsif ($type eq "HASH") {
3071         my $largest =
3072             length((sort { length($a) <=> length($b) } @sequence)[-1]);
3073         print "    '$now_printing' => {\n";
3074         foreach (@sequence) {
3075             if ($target{$_}) {
3076                 if (ref($target{$_}) eq "ARRAY") {
3077                     print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3078                 } else {
3079                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3080                 }
3081             }
3082         }
3083         print "    },\n";
3084     }
3085 }
3086
3087 # Utility routines ###################################################
3088
3089 # On VMS, if the given file is a logical name, File::Spec::Functions
3090 # will consider it an absolute path.  There are cases when we want a
3091 # purely syntactic check without checking the environment.
3092 sub isabsolute {
3093     my $file = shift;
3094
3095     # On non-platforms, we just use file_name_is_absolute().
3096     return file_name_is_absolute($file) unless $^O eq "VMS";
3097
3098     # If the file spec includes a device or a directory spec,
3099     # file_name_is_absolute() is perfectly safe.
3100     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3101
3102     # Here, we know the given file spec isn't absolute
3103     return 0;
3104 }
3105
3106 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
3107 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
3108 # realpath() requires that at least all path components except the last is an
3109 # existing directory.  On VMS, the last component of the directory spec must
3110 # exist.
3111 sub absolutedir {
3112     my $dir = shift;
3113
3114     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
3115     # will return the volume name for the device, no matter what.  Also,
3116     # it will return an incorrect directory spec if the argument is a
3117     # directory that doesn't exist.
3118     if ($^O eq "VMS") {
3119         return rel2abs($dir);
3120     }
3121
3122     # We use realpath() on Unix, since no other will properly clean out
3123     # a directory spec.
3124     use Cwd qw/realpath/;
3125
3126     return realpath($dir);
3127 }
3128
3129 sub quotify {
3130     my %processors = (
3131         perl    => sub { my $x = shift;
3132                          $x =~ s/([\\\$\@"])/\\$1/g;
3133                          return '"'.$x.'"'; },
3134         maybeshell => sub { my $x = shift;
3135                             (my $y = $x) =~ s/([\\\"])/\\$1/g;
3136                             if ($x ne $y || $x =~ m|\s|) {
3137                                 return '"'.$y.'"';
3138                             } else {
3139                                 return $x;
3140                             }
3141                         },
3142         );
3143     my $for = shift;
3144     my $processor =
3145         defined($processors{$for}) ? $processors{$for} : sub { shift; };
3146
3147     return map { $processor->($_); } @_;
3148 }
3149
3150 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
3151 # $filename is a file name to read from
3152 # $line_concat_cond_re is a regexp detecting a line continuation ending
3153 # $line_concat is a CODEref that takes care of concatenating two lines
3154 sub collect_from_file {
3155     my $filename = shift;
3156     my $line_concat_cond_re = shift;
3157     my $line_concat = shift;
3158
3159     open my $fh, $filename || die "unable to read $filename: $!\n";
3160     return sub {
3161         my $saved_line = "";
3162         $_ = "";
3163         while (<$fh>) {
3164             s|\R$||;
3165             if (defined $line_concat) {
3166                 $_ = $line_concat->($saved_line, $_);
3167                 $saved_line = "";
3168             }
3169             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3170                 $saved_line = $_;
3171                 next;
3172             }
3173             return $_;
3174         }
3175         die "$filename ending with continuation line\n" if $_;
3176         close $fh;
3177         return undef;
3178     }
3179 }
3180
3181 # collect_from_array($array, $line_concat_cond_re, $line_concat)
3182 # $array is an ARRAYref of lines
3183 # $line_concat_cond_re is a regexp detecting a line continuation ending
3184 # $line_concat is a CODEref that takes care of concatenating two lines
3185 sub collect_from_array {
3186     my $array = shift;
3187     my $line_concat_cond_re = shift;
3188     my $line_concat = shift;
3189     my @array = (@$array);
3190
3191     return sub {
3192         my $saved_line = "";
3193         $_ = "";
3194         while (defined($_ = shift @array)) {
3195             s|\R$||;
3196             if (defined $line_concat) {
3197                 $_ = $line_concat->($saved_line, $_);
3198                 $saved_line = "";
3199             }
3200             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3201                 $saved_line = $_;
3202                 next;
3203             }
3204             return $_;
3205         }
3206         die "input text ending with continuation line\n" if $_;
3207         return undef;
3208     }
3209 }
3210
3211 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3212 # $lineiterator is a CODEref that delivers one line at a time.
3213 # All following arguments are regex/CODEref pairs, where the regexp detects a
3214 # line and the CODEref does something with the result of the regexp.
3215 sub collect_information {
3216     my $lineiterator = shift;
3217     my %collectors = @_;
3218
3219     while(defined($_ = $lineiterator->())) {
3220         s|\R$||;
3221         my $found = 0;
3222         if ($collectors{"BEFORE"}) {
3223             $collectors{"BEFORE"}->($_);
3224         }
3225         foreach my $re (keys %collectors) {
3226             if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
3227                 $collectors{$re}->($lineiterator);
3228                 $found = 1;
3229             };
3230         }
3231         if ($collectors{"OTHERWISE"}) {
3232             $collectors{"OTHERWISE"}->($lineiterator, $_)
3233                 unless $found || !defined $collectors{"OTHERWISE"};
3234         }
3235         if ($collectors{"AFTER"}) {
3236             $collectors{"AFTER"}->($_);
3237         }
3238     }
3239 }
3240
3241 # tokenize($line)
3242 # tokenize($line,$separator)
3243 # $line is a line of text to split up into tokens
3244 # $separator [optional] is a regular expression that separates the tokens,
3245 # the default being spaces.  Do not use quotes of any kind as separators,
3246 # that will give undefined results.
3247 # Returns a list of tokens.
3248 #
3249 # Tokens are divided by separator (spaces by default).  If the tokens include
3250 # the separators, they have to be quoted with single or double quotes.
3251 # Double quotes inside a double quoted token must be escaped.  Escaping is done
3252 # with backslash.
3253 # Basically, the same quoting rules apply for " and ' as in any
3254 # Unix shell.
3255 sub tokenize {
3256     my $line = my $debug_line = shift;
3257     my $separator = shift // qr|\s+|;
3258     my @result = ();
3259
3260     if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3261         print STDERR "DEBUG[tokenize]: \$separator = $separator\n";
3262     }
3263
3264     while ($line =~ s|^${separator}||, $line ne "") {
3265         my $token = "";
3266     again:
3267         $line =~ m/^(.*?)(${separator}|"|'|$)/;
3268         $token .= $1;
3269         $line = $2.$';
3270
3271         if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3272             $token .= $1;
3273             $line = $';
3274             goto again;
3275         } elsif ($line =~ m/^'([^']*)'/) {
3276             $token .= $1;
3277             $line = $';
3278             goto again;
3279         }
3280         push @result, $token;
3281     }
3282
3283     if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3284         print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3285         print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
3286     }
3287     return @result;
3288 }