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