Configure

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