Configure

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