Configure

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