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