Configure

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