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