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