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                 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2253                              && $disabled{shared});
2254
2255                 my @src = @{$intent->{$kind}->{src}};
2256                 my $dst = $intent->{$kind}->{dst};
2257                 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2258                 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2259                     # %prod_sources has all applicable objects as keys, and
2260                     # their corresponding sources as values
2261                     my %prod_sources =
2262                         map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2263                         map { keys %{$unified_copy{$_}->{$prod}} }
2264                         @src;
2265                     foreach (keys %prod_sources) {
2266                         # Only affect object files and resource files,
2267                         # the others simply get a new value
2268                         # (+1 instead of -1)
2269                         if ($_ =~ /\.(o|res)$/) {
2270                             (my $prodname = $prod) =~ s|\.a$||;
2271                             my $newobj =
2272                                 catfile(dirname($_),
2273                                         basename($prodname)
2274                                             . '-' . $kind
2275                                             . '-' . basename($_));
2276                             $unified_info{$dst}->{$prod}->{$newobj} = 1;
2277                             foreach my $src (@{$prod_sources{$_}}) {
2278                                 $unified_info{sources}->{$newobj}->{$src} = 1;
2279                             }
2280                             # Adjust dependencies
2281                             foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2282                                 $unified_info{depends}->{$_}->{$deps} = -1;
2283                                 $unified_info{depends}->{$newobj}->{$deps} = 1;
2284                             }
2285                             # Adjust includes
2286                             foreach my $k (('source', 'build')) {
2287                                 next unless
2288                                     defined($unified_info{includes}->{$_}->{$k});
2289                                 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2290                                 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2291                             }
2292                         } else {
2293                             $unified_info{$dst}->{$prod}->{$_} = 1;
2294                         }
2295                     }
2296                 }
2297             }
2298         }
2299     }
2300     # At this point, we have a number of sources with the value -1.  They
2301     # aren't part of the local build and are probably meant for a different
2302     # platform, and can therefore be cleaned away.  That happens when making
2303     # %unified_info more efficient below.
2304
2305     ### Make unified_info a bit more efficient
2306     # One level structures
2307     foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
2308         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2309     }
2310     # Two level structures
2311     foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
2312         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
2313             my @items =
2314                 sort
2315                 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2316                 keys %{$unified_info{$l1}->{$l2}};
2317             if (@items) {
2318                 $unified_info{$l1}->{$l2} = [ @items ];
2319             } else {
2320                 delete $unified_info{$l1}->{$l2};
2321             }
2322         }
2323     }
2324     # Defines
2325     foreach my $dest (sort keys %{$unified_info{defines}}) {
2326         $unified_info{defines}->{$dest}
2327             = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2328                 sort keys %{$unified_info{defines}->{$dest}} ];
2329     }
2330     # Includes
2331     foreach my $dest (sort keys %{$unified_info{includes}}) {
2332         if (defined($unified_info{includes}->{$dest}->{build})) {
2333             my @source_includes = ();
2334             @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2335                 if defined($unified_info{includes}->{$dest}->{source});
2336             $unified_info{includes}->{$dest} =
2337                 [ @{$unified_info{includes}->{$dest}->{build}} ];
2338             foreach my $inc (@source_includes) {
2339                 push @{$unified_info{includes}->{$dest}}, $inc
2340                     unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2341             }
2342         } elsif (defined($unified_info{includes}->{$dest}->{source})) {
2343             $unified_info{includes}->{$dest} =
2344                 [ @{$unified_info{includes}->{$dest}->{source}} ];
2345         } else {
2346             delete $unified_info{includes}->{$dest};
2347         }
2348     }
2349
2350     # For convenience collect information regarding directories where
2351     # files are generated, those generated files and the end product
2352     # they end up in where applicable.  Then, add build rules for those
2353     # directories
2354     my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
2355                      "dso" => [ @{$unified_info{engines}} ],
2356                      "bin" => [ @{$unified_info{programs}} ],
2357                      "script" => [ @{$unified_info{scripts}} ] );
2358     foreach my $type (keys %loopinfo) {
2359         foreach my $product (@{$loopinfo{$type}}) {
2360             my %dirs = ();
2361             my $pd = dirname($product);
2362
2363             foreach (@{$unified_info{sources}->{$product} // []},
2364                      @{$unified_info{shared_sources}->{$product} // []}) {
2365                 my $d = dirname($_);
2366
2367                 # We don't want to create targets for source directories
2368                 # when building out of source
2369                 next if ($config{sourcedir} ne $config{builddir}
2370                              && $d =~ m|^\Q$config{sourcedir}\E|);
2371                 # We already have a "test" target, and the current directory
2372                 # is just silly to make a target for
2373                 next if $d eq "test" || $d eq ".";
2374
2375                 $dirs{$d} = 1;
2376                 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2377                     if $d ne $pd;
2378             }
2379             foreach (keys %dirs) {
2380                 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2381                     $product;
2382             }
2383         }
2384     }
2385 }
2386
2387 # For the schemes that need it, we provide the old *_obj configs
2388 # from the *_asm_obj ones
2389 foreach (grep /_(asm|aux)_src$/, keys %target) {
2390     my $src = $_;
2391     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2392     $target{$obj} = $target{$src};
2393     $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2394     $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2395 }
2396
2397 # Write down our configuration where it fits #########################
2398
2399 print "Creating configdata.pm\n";
2400 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2401 print OUT <<"EOF";
2402 #! $config{HASHBANGPERL}
2403
2404 package configdata;
2405
2406 use strict;
2407 use warnings;
2408
2409 use Exporter;
2410 #use vars qw(\@ISA \@EXPORT);
2411 our \@ISA = qw(Exporter);
2412 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
2413
2414 EOF
2415 print OUT "our %config = (\n";
2416 foreach (sort keys %config) {
2417     if (ref($config{$_}) eq "ARRAY") {
2418         print OUT "  ", $_, " => [ ", join(", ",
2419                                            map { quotify("perl", $_) }
2420                                            @{$config{$_}}), " ],\n";
2421     } elsif (ref($config{$_}) eq "HASH") {
2422         print OUT "  ", $_, " => {";
2423         if (scalar keys %{$config{$_}} > 0) {
2424             print OUT "\n";
2425             foreach my $key (sort keys %{$config{$_}}) {
2426                 print OUT "      ",
2427                     join(" => ",
2428                          quotify("perl", $key),
2429                          defined $config{$_}->{$key}
2430                              ? quotify("perl", $config{$_}->{$key})
2431                              : "undef");
2432                 print OUT ",\n";
2433             }
2434             print OUT "  ";
2435         }
2436         print OUT "},\n";
2437     } else {
2438         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
2439     }
2440 }
2441 print OUT <<"EOF";
2442 );
2443
2444 EOF
2445 print OUT "our %target = (\n";
2446 foreach (sort keys %target) {
2447     if (ref($target{$_}) eq "ARRAY") {
2448         print OUT "  ", $_, " => [ ", join(", ",
2449                                            map { quotify("perl", $_) }
2450                                            @{$target{$_}}), " ],\n";
2451     } else {
2452         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
2453     }
2454 }
2455 print OUT <<"EOF";
2456 );
2457
2458 EOF
2459 print OUT "our \%available_protocols = (\n";
2460 print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2461 print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2462 print OUT <<"EOF";
2463 );
2464
2465 EOF
2466 print OUT "our \@disablables = (\n";
2467 foreach (@disablables) {
2468     print OUT "  ", quotify("perl", $_), ",\n";
2469 }
2470 print OUT <<"EOF";
2471 );
2472
2473 EOF
2474 print OUT "our \%disabled = (\n";
2475 foreach (sort keys %disabled) {
2476     print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2477 }
2478 print OUT <<"EOF";
2479 );
2480
2481 EOF
2482 print OUT "our %withargs = (\n";
2483 foreach (sort keys %withargs) {
2484     if (ref($withargs{$_}) eq "ARRAY") {
2485         print OUT "  ", $_, " => [ ", join(", ",
2486                                            map { quotify("perl", $_) }
2487                                            @{$withargs{$_}}), " ],\n";
2488     } else {
2489         print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
2490     }
2491 }
2492 print OUT <<"EOF";
2493 );
2494
2495 EOF
2496 if ($builder eq "unified") {
2497     my $recurse;
2498     $recurse = sub {
2499         my $indent = shift;
2500         foreach (@_) {
2501             if (ref $_ eq "ARRAY") {
2502                 print OUT " "x$indent, "[\n";
2503                 foreach (@$_) {
2504                     $recurse->($indent + 4, $_);
2505                 }
2506                 print OUT " "x$indent, "],\n";
2507             } elsif (ref $_ eq "HASH") {
2508                 my %h = %$_;
2509                 print OUT " "x$indent, "{\n";
2510                 foreach (sort keys %h) {
2511                     if (ref $h{$_} eq "") {
2512                         print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2513                     } else {
2514                         print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2515                         $recurse->($indent + 8, $h{$_});
2516                     }
2517                 }
2518                 print OUT " "x$indent, "},\n";
2519             } else {
2520                 print OUT " "x$indent, quotify("perl", $_), ",\n";
2521             }
2522         }
2523     };
2524     print OUT "our %unified_info = (\n";
2525     foreach (sort keys %unified_info) {
2526         if (ref $unified_info{$_} eq "") {
2527             print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2528         } else {
2529             print OUT " "x4, quotify("perl", $_), " =>\n";
2530             $recurse->(8, $unified_info{$_});
2531         }
2532     }
2533     print OUT <<"EOF";
2534 );
2535
2536 EOF
2537 }
2538 print OUT
2539     "# The following data is only used when this files is use as a script\n";
2540 print OUT "my \@makevars = (\n";
2541 foreach (sort keys %user) {
2542     print OUT "    '",$_,"',\n";
2543 }
2544 print OUT ");\n";
2545 print OUT "my \%disabled_info = (\n";
2546 foreach my $what (sort keys %disabled_info) {
2547     print OUT "    '$what' => {\n";
2548     foreach my $info (sort keys %{$disabled_info{$what}}) {
2549         if (ref $disabled_info{$what}->{$info} eq 'ARRAY') {
2550             print OUT "        $info => [ ",
2551                 join(', ', map { "'$_'" } @{$disabled_info{$what}->{$info}}),
2552                 " ],\n";
2553         } else {
2554             print OUT "        $info => '", $disabled_info{$what}->{$info},
2555                 "',\n";
2556         }
2557     }
2558     print OUT "    },\n";
2559 }
2560 print OUT ");\n";
2561 print OUT 'my @user_crossable = qw( ', join (' ', @user_crossable), " );\n";
2562 print OUT << 'EOF';
2563 # If run directly, we can give some answers, and even reconfigure
2564 unless (caller) {
2565     use Getopt::Long;
2566     use File::Spec::Functions;
2567     use File::Basename;
2568     use Pod::Usage;
2569
2570     my $here = dirname($0);
2571
2572     my $dump = undef;
2573     my $cmdline = undef;
2574     my $options = undef;
2575     my $target = undef;
2576     my $envvars = undef;
2577     my $makevars = undef;
2578     my $buildparams = undef;
2579     my $reconf = undef;
2580     my $verbose = undef;
2581     my $help = undef;
2582     my $man = undef;
2583     GetOptions('dump|d'                 => \$dump,
2584                'command-line|c'         => \$cmdline,
2585                'options|o'              => \$options,
2586                'target|t'               => \$target,
2587                'environment|e'          => \$envvars,
2588                'make-variables|m'       => \$makevars,
2589                'build-parameters|b'     => \$buildparams,
2590                'reconfigure|reconf|r'   => \$reconf,
2591                'verbose|v'              => \$verbose,
2592                'help'                   => \$help,
2593                'man'                    => \$man)
2594         or die "Errors in command line arguments\n";
2595
2596     unless ($dump || $cmdline || $options || $target || $envvars || $makevars
2597             || $buildparams || $reconf || $verbose || $help || $man) {
2598         print STDERR <<"_____";
2599 You must give at least one option.
2600 For more information, do '$0 --help'
2601 _____
2602         exit(2);
2603     }
2604
2605     if ($help) {
2606         pod2usage(-exitval => 0,
2607                   -verbose => 1);
2608     }
2609     if ($man) {
2610         pod2usage(-exitval => 0,
2611                   -verbose => 2);
2612     }
2613     if ($dump || $cmdline) {
2614         print "\nCommand line (with current working directory = $here):\n\n";
2615         print '    ',join(' ',
2616                           $config{PERL},
2617                           catfile($config{sourcedir}, 'Configure'),
2618                           @{$config{perlargv}}), "\n";
2619         print "\nPerl information:\n\n";
2620         print '    ',$config{perl_cmd},"\n";
2621         print '    ',$config{perl_version},' for ',$config{perl_archname},"\n";
2622     }
2623     if ($dump || $options) {
2624         my $longest = 0;
2625         my $longest2 = 0;
2626         foreach my $what (@disablables) {
2627             $longest = length($what) if $longest < length($what);
2628             $longest2 = length($disabled{$what})
2629                 if $disabled{$what} && $longest2 < length($disabled{$what});
2630         }
2631         print "\nEnabled features:\n\n";
2632         foreach my $what (@disablables) {
2633             print "    $what\n" unless $disabled{$what};
2634         }
2635         print "\nDisabled features:\n\n";
2636         foreach my $what (@disablables) {
2637             if ($disabled{$what}) {
2638                 print "    $what", ' ' x ($longest - length($what) + 1),
2639                     "[$disabled{$what}]", ' ' x ($longest2 - length($disabled{$what}) + 1);
2640                 print $disabled_info{$what}->{macro}
2641                     if $disabled_info{$what}->{macro};
2642                 print ' (skip ',
2643                     join(', ', @{$disabled_info{$what}->{skipped}}),
2644                     ')'
2645                     if $disabled_info{$what}->{skipped};
2646                 print "\n";
2647             }
2648         }
2649     }
2650     if ($dump || $target) {
2651         print "\nConfig target attributes:\n\n";
2652         foreach (sort keys %target) {
2653             next if $_ =~ m|^_| || $_ eq 'template';
2654             my $quotify = sub {
2655                 map { (my $x = $_) =~ s|([\\\$\@"])|\\$1|g; "\"$x\""} @_;
2656             };
2657             print '    ', $_, ' => ';
2658             if (ref($target{$_}) eq "ARRAY") {
2659                 print '[ ', join(', ', $quotify->(@{$target{$_}})), " ],\n";
2660             } else {
2661                 print $quotify->($target{$_}), ",\n"
2662             }
2663         }
2664     }
2665     if ($dump || $envvars) {
2666         print "\nRecorded environment:\n\n";
2667         foreach (sort keys %{$config{perlenv}}) {
2668             print '    ',$_,' = ',($config{perlenv}->{$_} || ''),"\n";
2669         }
2670     }
2671     if ($dump || $makevars) {
2672         print "\nMakevars:\n\n";
2673         foreach my $var (@makevars) {
2674             my $prefix = '';
2675             $prefix = $config{CROSS_COMPILE}
2676                 if grep { $var eq $_ } @user_crossable;
2677             $prefix //= '';
2678             print '    ',$var,' ' x (16 - length $var),'= ',
2679                 (ref $config{$var} eq 'ARRAY'
2680                  ? join(' ', @{$config{$var}})
2681                  : $prefix.$config{$var}),
2682                 "\n"
2683                 if defined $config{$var};
2684         }
2685
2686         my @buildfile = ($config{builddir}, $config{build_file});
2687         unshift @buildfile, $here
2688             unless file_name_is_absolute($config{builddir});
2689         my $buildfile = canonpath(catdir(@buildfile));
2690         print <<"_____";
2691
2692 NOTE: These variables only represent the configuration view.  The build file
2693 template may have processed these variables further, please have a look at the
2694 build file for more exact data:
2695     $buildfile
2696 _____
2697     }
2698     if ($dump || $buildparams) {
2699         my @buildfile = ($config{builddir}, $config{build_file});
2700         unshift @buildfile, $here
2701             unless file_name_is_absolute($config{builddir});
2702         print "\nbuild file:\n\n";
2703         print "    ", canonpath(catfile(@buildfile)),"\n";
2704
2705         print "\nbuild file templates:\n\n";
2706         foreach (@{$config{build_file_templates}}) {
2707             my @tmpl = ($_);
2708             unshift @tmpl, $here
2709                 unless file_name_is_absolute($config{sourcedir});
2710             print '    ',canonpath(catfile(@tmpl)),"\n";
2711         }
2712     }
2713     if ($reconf) {
2714         if ($verbose) {
2715             print 'Reconfiguring with: ', join(' ',@{$config{perlargv}}), "\n";
2716             foreach (sort keys %{$config{perlenv}}) {
2717                 print '    ',$_,' = ',($config{perlenv}->{$_} || ""),"\n";
2718             }
2719         }
2720
2721         chdir $here;
2722         exec $^X,catfile($config{sourcedir}, 'Configure'),'reconf';
2723     }
2724 }
2725
2726 1;
2727
2728 __END__
2729
2730 =head1 NAME
2731
2732 configdata.pm - configuration data for OpenSSL builds
2733
2734 =head1 SYNOPSIS
2735
2736 Interactive:
2737
2738   perl configdata.pm [options]
2739
2740 As data bank module:
2741
2742   use configdata;
2743
2744 =head1 DESCRIPTION
2745
2746 This module can be used in two modes, interactively and as a module containing
2747 all the data recorded by OpenSSL's Configure script.
2748
2749 When used interactively, simply run it as any perl script, with at least one
2750 option, and you will get the information you ask for.  See L</OPTIONS> below.
2751
2752 When loaded as a module, you get a few databanks with useful information to
2753 perform build related tasks.  The databanks are:
2754
2755     %config             Configured things.
2756     %target             The OpenSSL config target with all inheritances
2757                         resolved.
2758     %disabled           The features that are disabled.
2759     @disablables        The list of features that can be disabled.
2760     %withargs           All data given through --with-THING options.
2761     %unified_info       All information that was computed from the build.info
2762                         files.
2763
2764 =head1 OPTIONS
2765
2766 =over 4
2767
2768 =item B<--help>
2769
2770 Print a brief help message and exit.
2771
2772 =item B<--man>
2773
2774 Print the manual page and exit.
2775
2776 =item B<--dump> | B<-d>
2777
2778 Print all relevant configuration data.  This is equivalent to B<--command-line>
2779 B<--options> B<--target> B<--environment> B<--make-variables>
2780 B<--build-parameters>.
2781
2782 =item B<--command-line> | B<-c>
2783
2784 Print the current configuration command line.
2785
2786 =item B<--options> | B<-o>
2787
2788 Print the features, both enabled and disabled, and display defined macro and
2789 skipped directories where applicable.
2790
2791 =item B<--target> | B<-t>
2792
2793 Print the config attributes for this config target.
2794
2795 =item B<--environment> | B<-e>
2796
2797 Print the environment variables and their values at the time of configuration.
2798
2799 =item B<--make-variables> | B<-m>
2800
2801 Print the main make variables generated in the current configuration
2802
2803 =item B<--build-parameters> | B<-b>
2804
2805 Print the build parameters, i.e. build file and build file templates.
2806
2807 =item B<--reconfigure> | B<--reconf> | B<-r>
2808
2809 Redo the configuration.
2810
2811 =item B<--verbose> | B<-v>
2812
2813 Verbose output.
2814
2815 =back
2816
2817 =cut
2818
2819 EOF
2820 close(OUT);
2821 if ($builder_platform eq 'unix') {
2822     my $mode = (0755 & ~umask);
2823     chmod $mode, 'configdata.pm'
2824         or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2825 }
2826
2827 my %builders = (
2828     unified => sub {
2829         print 'Creating ',$target{build_file},"\n";
2830         run_dofile(catfile($blddir, $target{build_file}),
2831                    @{$config{build_file_templates}});
2832     },
2833     );
2834
2835 $builders{$builder}->($builder_platform, @builder_opts);
2836
2837 $SIG{__DIE__} = $orig_death_handler;
2838
2839 print <<"EOF" if ($disabled{threads} eq "unavailable");
2840
2841 The library could not be configured for supporting multi-threaded
2842 applications as the compiler options required on this system are not known.
2843 See file INSTALL for details if you need multi-threading.
2844 EOF
2845
2846 print <<"EOF" if ($no_shared_warn);
2847
2848 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2849 platform, so we will pretend you gave the option 'no-pic', which also disables
2850 'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
2851 or position independent code, please let us know (but please first make sure
2852 you have tried with a current version of OpenSSL).
2853 EOF
2854
2855 print <<"EOF";
2856
2857 **********************************************************************
2858 ***                                                                ***
2859 ***   OpenSSL has been successfully configured                     ***
2860 ***                                                                ***
2861 ***   If you encounter a problem while building, please open an    ***
2862 ***   issue on GitHub <https://github.com/openssl/openssl/issues>  ***
2863 ***   and include the output from the following command:           ***
2864 ***                                                                ***
2865 ***       perl configdata.pm --dump                                ***
2866 ***                                                                ***
2867 ***   (If you are new to OpenSSL, you might want to consult the    ***
2868 ***   'Troubleshooting' section in the INSTALL file first)         ***
2869 ***                                                                ***
2870 **********************************************************************
2871 EOF
2872
2873 exit(0);
2874
2875 ######################################################################
2876 #
2877 # Helpers and utility functions
2878 #
2879
2880 # Death handler, to print a helpful message in case of failure #######
2881 #
2882 sub death_handler {
2883     die @_ if $^S;              # To prevent the added message in eval blocks
2884     my $build_file = $target{build_file} // "build file";
2885     my @message = ( <<"_____", @_ );
2886
2887 Failure!  $build_file wasn't produced.
2888 Please read INSTALL and associated NOTES files.  You may also have to look over
2889 your available compiler tool chain or change your configuration.
2890
2891 _____
2892
2893     # Dying is terminal, so it's ok to reset the signal handler here.
2894     $SIG{__DIE__} = $orig_death_handler;
2895     die @message;
2896 }
2897
2898 # Configuration file reading #########################################
2899
2900 # Note: All of the helper functions are for lazy evaluation.  They all
2901 # return a CODE ref, which will return the intended value when evaluated.
2902 # Thus, whenever there's mention of a returned value, it's about that
2903 # intended value.
2904
2905 # Helper function to implement conditional inheritance depending on the
2906 # value of $disabled{asm}.  Used in inherit_from values as follows:
2907 #
2908 #      inherit_from => [ "template", asm("asm_tmpl") ]
2909 #
2910 sub asm {
2911     my @x = @_;
2912     sub {
2913         $disabled{asm} ? () : @x;
2914     }
2915 }
2916
2917 # Helper function to implement conditional value variants, with a default
2918 # plus additional values based on the value of $config{build_type}.
2919 # Arguments are given in hash table form:
2920 #
2921 #       picker(default => "Basic string: ",
2922 #              debug   => "debug",
2923 #              release => "release")
2924 #
2925 # When configuring with --debug, the resulting string will be
2926 # "Basic string: debug", and when not, it will be "Basic string: release"
2927 #
2928 # This can be used to create variants of sets of flags according to the
2929 # build type:
2930 #
2931 #       cflags => picker(default => "-Wall",
2932 #                        debug   => "-g -O0",
2933 #                        release => "-O3")
2934 #
2935 sub picker {
2936     my %opts = @_;
2937     return sub { add($opts{default} || (),
2938                      $opts{$config{build_type}} || ())->(); }
2939 }
2940
2941 # Helper function to combine several values of different types into one.
2942 # This is useful if you want to combine a string with the result of a
2943 # lazy function, such as:
2944 #
2945 #       cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2946 #
2947 sub combine {
2948     my @stuff = @_;
2949     return sub { add(@stuff)->(); }
2950 }
2951
2952 # Helper function to implement conditional values depending on the value
2953 # of $disabled{threads}.  Can be used as follows:
2954 #
2955 #       cflags => combine("-Wall", threads("-pthread"))
2956 #
2957 sub threads {
2958     my @flags = @_;
2959     return sub { add($disabled{threads} ? () : @flags)->(); }
2960 }
2961
2962 sub shared {
2963     my @flags = @_;
2964     return sub { add($disabled{shared} ? () : @flags)->(); }
2965 }
2966
2967 our $add_called = 0;
2968 # Helper function to implement adding values to already existing configuration
2969 # values.  It handles elements that are ARRAYs, CODEs and scalars
2970 sub _add {
2971     my $separator = shift;
2972
2973     # If there's any ARRAY in the collection of values OR the separator
2974     # is undef, we will return an ARRAY of combined values, otherwise a
2975     # string of joined values with $separator as the separator.
2976     my $found_array = !defined($separator);
2977
2978     my @values =
2979         map {
2980             my $res = $_;
2981             while (ref($res) eq "CODE") {
2982                 $res = $res->();
2983             }
2984             if (defined($res)) {
2985                 if (ref($res) eq "ARRAY") {
2986                     $found_array = 1;
2987                     @$res;
2988                 } else {
2989                     $res;
2990                 }
2991             } else {
2992                 ();
2993             }
2994     } (@_);
2995
2996     $add_called = 1;
2997
2998     if ($found_array) {
2999         [ @values ];
3000     } else {
3001         join($separator, grep { defined($_) && $_ ne "" } @values);
3002     }
3003 }
3004 sub add_before {
3005     my $separator = " ";
3006     if (ref($_[$#_]) eq "HASH") {
3007         my $opts = pop;
3008         $separator = $opts->{separator};
3009     }
3010     my @x = @_;
3011     sub { _add($separator, @x, @_) };
3012 }
3013 sub add {
3014     my $separator = " ";
3015     if (ref($_[$#_]) eq "HASH") {
3016         my $opts = pop;
3017         $separator = $opts->{separator};
3018     }
3019     my @x = @_;
3020     sub { _add($separator, @_, @x) };
3021 }
3022
3023 sub read_eval_file {
3024     my $fname = shift;
3025     my $content;
3026     my @result;
3027
3028     open F, "< $fname" or die "Can't open '$fname': $!\n";
3029     {
3030         undef local $/;
3031         $content = <F>;
3032     }
3033     close F;
3034     {
3035         local $@;
3036
3037         @result = ( eval $content );
3038         warn $@ if $@;
3039     }
3040     return wantarray ? @result : $result[0];
3041 }
3042
3043 # configuration reader, evaluates the input file as a perl script and expects
3044 # it to fill %targets with target configurations.  Those are then added to
3045 # %table.
3046 sub read_config {
3047     my $fname = shift;
3048     my %targets;
3049
3050     {
3051         # Protect certain tables from tampering
3052         local %table = ();
3053
3054         %targets = read_eval_file($fname);
3055     }
3056     my %preexisting = ();
3057     foreach (sort keys %targets) {
3058         $preexisting{$_} = 1 if $table{$_};
3059     }
3060     die <<"EOF",
3061 The following config targets from $fname
3062 shadow pre-existing config targets with the same name:
3063 EOF
3064         map { "  $_\n" } sort keys %preexisting
3065         if %preexisting;
3066
3067
3068     # For each target, check that it's configured with a hash table.
3069     foreach (keys %targets) {
3070         if (ref($targets{$_}) ne "HASH") {
3071             if (ref($targets{$_}) eq "") {
3072                 warn "Deprecated target configuration for $_, ignoring...\n";
3073             } else {
3074                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3075             }
3076             delete $targets{$_};
3077         } else {
3078             $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3079         }
3080     }
3081
3082     %table = (%table, %targets);
3083
3084 }
3085
3086 # configuration resolver.  Will only resolve all the lazy evaluation
3087 # codeblocks for the chosen target and all those it inherits from,
3088 # recursively
3089 sub resolve_config {
3090     my $target = shift;
3091     my @breadcrumbs = @_;
3092
3093 #    my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
3094
3095     if (grep { $_ eq $target } @breadcrumbs) {
3096         die "inherit_from loop!  target backtrace:\n  "
3097             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
3098     }
3099
3100     if (!defined($table{$target})) {
3101         warn "Warning! target $target doesn't exist!\n";
3102         return ();
3103     }
3104     # Recurse through all inheritances.  They will be resolved on the
3105     # fly, so when this operation is done, they will all just be a
3106     # bunch of attributes with string values.
3107     # What we get here, though, are keys with references to lists of
3108     # the combined values of them all.  We will deal with lists after
3109     # this stage is done.
3110     my %combined_inheritance = ();
3111     if ($table{$target}->{inherit_from}) {
3112         my @inherit_from =
3113             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3114         foreach (@inherit_from) {
3115             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3116
3117             # 'template' is a marker that's considered private to
3118             # the config that had it.
3119             delete $inherited_config{template};
3120
3121             foreach (keys %inherited_config) {
3122                 if (!$combined_inheritance{$_}) {
3123                     $combined_inheritance{$_} = [];
3124                 }
3125                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
3126             }
3127         }
3128     }
3129
3130     # We won't need inherit_from in this target any more, since we've
3131     # resolved all the inheritances that lead to this
3132     delete $table{$target}->{inherit_from};
3133
3134     # Now is the time to deal with those lists.  Here's the place to
3135     # decide what shall be done with those lists, all based on the
3136     # values of the target we're currently dealing with.
3137     # - If a value is a coderef, it will be executed with the list of
3138     #   inherited values as arguments.
3139     # - If the corresponding key doesn't have a value at all or is the
3140     #   empty string, the inherited value list will be run through the
3141     #   default combiner (below), and the result becomes this target's
3142     #   value.
3143     # - Otherwise, this target's value is assumed to be a string that
3144     #   will simply override the inherited list of values.
3145     my $default_combiner = add();
3146
3147     my %all_keys =
3148         map { $_ => 1 } (keys %combined_inheritance,
3149                          keys %{$table{$target}});
3150
3151     sub process_values {
3152         my $object    = shift;
3153         my $inherited = shift;  # Always a [ list ]
3154         my $target    = shift;
3155         my $entry     = shift;
3156
3157         $add_called = 0;
3158
3159         while(ref($object) eq "CODE") {
3160             $object = $object->(@$inherited);
3161         }
3162         if (!defined($object)) {
3163             return ();
3164         }
3165         elsif (ref($object) eq "ARRAY") {
3166             local $add_called;  # To make sure recursive calls don't affect it
3167             return [ map { process_values($_, $inherited, $target, $entry) }
3168                      @$object ];
3169         } elsif (ref($object) eq "") {
3170             return $object;
3171         } else {
3172             die "cannot handle reference type ",ref($object)
3173                 ," found in target ",$target," -> ",$entry,"\n";
3174         }
3175     }
3176
3177     foreach (sort keys %all_keys) {
3178         my $previous = $combined_inheritance{$_};
3179
3180         # Current target doesn't have a value for the current key?
3181         # Assign it the default combiner, the rest of this loop body
3182         # will handle it just like any other coderef.
3183         if (!exists $table{$target}->{$_}) {
3184             $table{$target}->{$_} = $default_combiner;
3185         }
3186
3187         $table{$target}->{$_} = process_values($table{$target}->{$_},
3188                                                $combined_inheritance{$_},
3189                                                $target, $_);
3190         unless(defined($table{$target}->{$_})) {
3191             delete $table{$target}->{$_};
3192         }
3193 #        if ($extra_checks &&
3194 #            $previous && !($add_called ||  $previous ~~ $table{$target}->{$_})) {
3195 #            warn "$_ got replaced in $target\n";
3196 #        }
3197     }
3198
3199     # Finally done, return the result.
3200     return %{$table{$target}};
3201 }
3202
3203 sub usage
3204         {
3205         print STDERR $usage;
3206         print STDERR "\npick os/compiler from:\n";
3207         my $j=0;
3208         my $i;
3209         my $k=0;
3210         foreach $i (sort keys %table)
3211                 {
3212                 next if $table{$i}->{template};
3213                 next if $i =~ /^debug/;
3214                 $k += length($i) + 1;
3215                 if ($k > 78)
3216                         {
3217                         print STDERR "\n";
3218                         $k=length($i);
3219                         }
3220                 print STDERR $i . " ";
3221                 }
3222         foreach $i (sort keys %table)
3223                 {
3224                 next if $table{$i}->{template};
3225                 next if $i !~ /^debug/;
3226                 $k += length($i) + 1;
3227                 if ($k > 78)
3228                         {
3229                         print STDERR "\n";
3230                         $k=length($i);
3231                         }
3232                 print STDERR $i . " ";
3233                 }
3234         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
3235         exit(1);
3236         }
3237
3238 sub run_dofile
3239 {
3240     my $out = shift;
3241     my @templates = @_;
3242
3243     unlink $out || warn "Can't remove $out, $!"
3244         if -f $out;
3245     foreach (@templates) {
3246         die "Can't open $_, $!" unless -f $_;
3247     }
3248     my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
3249     my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
3250     #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
3251     system($cmd);
3252     exit 1 if $? != 0;
3253     rename("$out.new", $out) || die "Can't rename $out.new, $!";
3254 }
3255
3256 sub compiler_predefined {
3257     state %predefined;
3258     my $cc = shift;
3259
3260     return () if $^O eq 'VMS';
3261
3262     die 'compiler_predefined called without a compiler command'
3263         unless $cc;
3264
3265     if (! $predefined{$cc}) {
3266
3267         $predefined{$cc} = {};
3268
3269         # collect compiler pre-defines from gcc or gcc-alike...
3270         open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
3271         while (my $l = <PIPE>) {
3272             $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
3273             $predefined{$cc}->{$1} = $2 // '';
3274         }
3275         close(PIPE);
3276     }
3277
3278     return %{$predefined{$cc}};
3279 }
3280
3281 sub which
3282 {
3283     my ($name)=@_;
3284
3285     if (eval { require IPC::Cmd; 1; }) {
3286         IPC::Cmd->import();
3287         return scalar IPC::Cmd::can_run($name);
3288     } else {
3289         # if there is $directories component in splitpath,
3290         # then it's not something to test with $PATH...
3291         return $name if (File::Spec->splitpath($name))[1];
3292
3293         foreach (File::Spec->path()) {
3294             my $fullpath = catfile($_, "$name$target{exe_extension}");
3295             if (-f $fullpath and -x $fullpath) {
3296                 return $fullpath;
3297             }
3298         }
3299     }
3300 }
3301
3302 sub env
3303 {
3304     my $name = shift;
3305     my %opts = @_;
3306
3307     unless ($opts{cacheonly}) {
3308         # Note that if $ENV{$name} doesn't exist or is undefined,
3309         # $config{perlenv}->{$name} will be created with the value
3310         # undef.  This is intentional.
3311
3312         $config{perlenv}->{$name} = $ENV{$name}
3313             if ! exists $config{perlenv}->{$name};
3314     }
3315     return $config{perlenv}->{$name};
3316 }
3317
3318 # Configuration printer ##############################################
3319
3320 sub print_table_entry
3321 {
3322     local $now_printing = shift;
3323     my %target = resolve_config($now_printing);
3324     my $type = shift;
3325
3326     # Don't print the templates
3327     return if $target{template};
3328
3329     my @sequence = (
3330         "sys_id",
3331         "cpp",
3332         "cppflags",
3333         "defines",
3334         "includes",
3335         "cc",
3336         "cflags",
3337         "unistd",
3338         "ld",
3339         "lflags",
3340         "loutflag",
3341         "ex_libs",
3342         "bn_ops",
3343         "apps_aux_src",
3344         "cpuid_asm_src",
3345         "uplink_aux_src",
3346         "bn_asm_src",
3347         "ec_asm_src",
3348         "des_asm_src",
3349         "aes_asm_src",
3350         "bf_asm_src",
3351         "md5_asm_src",
3352         "cast_asm_src",
3353         "sha1_asm_src",
3354         "rc4_asm_src",
3355         "rmd160_asm_src",
3356         "rc5_asm_src",
3357         "wp_asm_src",
3358         "cmll_asm_src",
3359         "modes_asm_src",
3360         "padlock_asm_src",
3361         "chacha_asm_src",
3362         "poly1035_asm_src",
3363         "thread_scheme",
3364         "perlasm_scheme",
3365         "dso_scheme",
3366         "shared_target",
3367         "shared_cflag",
3368         "shared_defines",
3369         "shared_ldflag",
3370         "shared_rcflag",
3371         "shared_extension",
3372         "dso_extension",
3373         "obj_extension",
3374         "exe_extension",
3375         "ranlib",
3376         "ar",
3377         "arflags",
3378         "aroutflag",
3379         "rc",
3380         "rcflags",
3381         "rcoutflag",
3382         "mt",
3383         "mtflags",
3384         "mtinflag",
3385         "mtoutflag",
3386         "multilib",
3387         "build_scheme",
3388         );
3389
3390     if ($type eq "TABLE") {
3391         print "\n";
3392         print "*** $now_printing\n";
3393         foreach (@sequence) {
3394             if (ref($target{$_}) eq "ARRAY") {
3395                 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3396             } else {
3397                 printf "\$%-12s = %s\n", $_, $target{$_};
3398             }
3399         }
3400     } elsif ($type eq "HASH") {
3401         my $largest =
3402             length((sort { length($a) <=> length($b) } @sequence)[-1]);
3403         print "    '$now_printing' => {\n";
3404         foreach (@sequence) {
3405             if ($target{$_}) {
3406                 if (ref($target{$_}) eq "ARRAY") {
3407                     print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3408                 } else {
3409                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3410                 }
3411             }
3412         }
3413         print "    },\n";
3414     }
3415 }
3416
3417 # Utility routines ###################################################
3418
3419 # On VMS, if the given file is a logical name, File::Spec::Functions
3420 # will consider it an absolute path.  There are cases when we want a
3421 # purely syntactic check without checking the environment.
3422 sub isabsolute {
3423     my $file = shift;
3424
3425     # On non-platforms, we just use file_name_is_absolute().
3426     return file_name_is_absolute($file) unless $^O eq "VMS";
3427
3428     # If the file spec includes a device or a directory spec,
3429     # file_name_is_absolute() is perfectly safe.
3430     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3431
3432     # Here, we know the given file spec isn't absolute
3433     return 0;
3434 }
3435
3436 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
3437 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
3438 # realpath() requires that at least all path components except the last is an
3439 # existing directory.  On VMS, the last component of the directory spec must
3440 # exist.
3441 sub absolutedir {
3442     my $dir = shift;
3443
3444     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
3445     # will return the volume name for the device, no matter what.  Also,
3446     # it will return an incorrect directory spec if the argument is a
3447     # directory that doesn't exist.
3448     if ($^O eq "VMS") {
3449         return rel2abs($dir);
3450     }
3451
3452     # We use realpath() on Unix, since no other will properly clean out
3453     # a directory spec.
3454     use Cwd qw/realpath/;
3455
3456     return realpath($dir);
3457 }
3458
3459 sub quotify {
3460     my %processors = (
3461         perl    => sub { my $x = shift;
3462                          $x =~ s/([\\\$\@"])/\\$1/g;
3463                          return '"'.$x.'"'; },
3464         maybeshell => sub { my $x = shift;
3465                             (my $y = $x) =~ s/([\\\"])/\\$1/g;
3466                             if ($x ne $y || $x =~ m|\s|) {
3467                                 return '"'.$y.'"';
3468                             } else {
3469                                 return $x;
3470                             }
3471                         },
3472         );
3473     my $for = shift;
3474     my $processor =
3475         defined($processors{$for}) ? $processors{$for} : sub { shift; };
3476
3477     return map { $processor->($_); } @_;
3478 }
3479
3480 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
3481 # $filename is a file name to read from
3482 # $line_concat_cond_re is a regexp detecting a line continuation ending
3483 # $line_concat is a CODEref that takes care of concatenating two lines
3484 sub collect_from_file {
3485     my $filename = shift;
3486     my $line_concat_cond_re = shift;
3487     my $line_concat = shift;
3488
3489     open my $fh, $filename || die "unable to read $filename: $!\n";
3490     return sub {
3491         my $saved_line = "";
3492         $_ = "";
3493         while (<$fh>) {
3494             s|\R$||;
3495             if (defined $line_concat) {
3496                 $_ = $line_concat->($saved_line, $_);
3497                 $saved_line = "";
3498             }
3499             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3500                 $saved_line = $_;
3501                 next;
3502             }
3503             return $_;
3504         }
3505         die "$filename ending with continuation line\n" if $_;
3506         close $fh;
3507         return undef;
3508     }
3509 }
3510
3511 # collect_from_array($array, $line_concat_cond_re, $line_concat)
3512 # $array is an ARRAYref of lines
3513 # $line_concat_cond_re is a regexp detecting a line continuation ending
3514 # $line_concat is a CODEref that takes care of concatenating two lines
3515 sub collect_from_array {
3516     my $array = shift;
3517     my $line_concat_cond_re = shift;
3518     my $line_concat = shift;
3519     my @array = (@$array);
3520
3521     return sub {
3522         my $saved_line = "";
3523         $_ = "";
3524         while (defined($_ = shift @array)) {
3525             s|\R$||;
3526             if (defined $line_concat) {
3527                 $_ = $line_concat->($saved_line, $_);
3528                 $saved_line = "";
3529             }
3530             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3531                 $saved_line = $_;
3532                 next;
3533             }
3534             return $_;
3535         }
3536         die "input text ending with continuation line\n" if $_;
3537         return undef;
3538     }
3539 }
3540
3541 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3542 # $lineiterator is a CODEref that delivers one line at a time.
3543 # All following arguments are regex/CODEref pairs, where the regexp detects a
3544 # line and the CODEref does something with the result of the regexp.
3545 sub collect_information {
3546     my $lineiterator = shift;
3547     my %collectors = @_;
3548
3549     while(defined($_ = $lineiterator->())) {
3550         s|\R$||;
3551         my $found = 0;
3552         if ($collectors{"BEFORE"}) {
3553             $collectors{"BEFORE"}->($_);
3554         }
3555         foreach my $re (keys %collectors) {
3556             if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
3557                 $collectors{$re}->($lineiterator);
3558                 $found = 1;
3559             };
3560         }
3561         if ($collectors{"OTHERWISE"}) {
3562             $collectors{"OTHERWISE"}->($lineiterator, $_)
3563                 unless $found || !defined $collectors{"OTHERWISE"};
3564         }
3565         if ($collectors{"AFTER"}) {
3566             $collectors{"AFTER"}->($_);
3567         }
3568     }
3569 }
3570
3571 # tokenize($line)
3572 # $line is a line of text to split up into tokens
3573 # returns a list of tokens
3574 #
3575 # Tokens are divided by spaces.  If the tokens include spaces, they
3576 # have to be quoted with single or double quotes.  Double quotes
3577 # inside a double quoted token must be escaped.  Escaping is done
3578 # with backslash.
3579 # Basically, the same quoting rules apply for " and ' as in any
3580 # Unix shell.
3581 sub tokenize {
3582     my $line = my $debug_line = shift;
3583     my @result = ();
3584
3585     while ($line =~ s|^\s+||, $line ne "") {
3586         my $token = "";
3587         while ($line ne "" && $line !~ m|^\s|) {
3588             if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3589                 $token .= $1;
3590                 $line = $';
3591             } elsif ($line =~ m/^'([^']*)'/) {
3592                 $token .= $1;
3593                 $line = $';
3594             } elsif ($line =~ m/^(\S+)/) {
3595                 $token .= $1;
3596                 $line = $';
3597             }
3598         }
3599         push @result, $token;
3600     }
3601
3602     if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3603         print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3604         print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
3605     }
3606     return @result;
3607 }