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