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