Configure

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