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