Configure

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