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