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