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