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