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