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