]> 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
Remove duplicate see also reference to BIO_s_mem.
[thirdparty/openssl.git] / Configure
CommitLineData
de17db91 1#! /usr/bin/env perl
f4d8f037 2# -*- mode: perl; -*-
d42d0a4d 3# Copyright 2016-2017 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;
f09e7ca9 15use File::Basename;
85152ca4 16use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
dca99383 17use File::Path qw/mkpath/;
23049aa5 18use if $^O ne "VMS", 'File::Glob' => qw/glob/;
1641cb60 19
22a4f969 20# see INSTALL for instructions.
462ba4f6 21
e4ef2e25 22my $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 23
434c5dd3 24# Options:
e5f3045f 25#
f09e7ca9
RS		 26# --config add the given configuration file, which will be read after
27# any "Configurations*" files that are found in the same
28# directory as this script.
d74dfafd
RL		 29# --prefix prefix for the OpenSSL installation, which includes the
30# directories bin, lib, include, share/man, share/doc/openssl
31# This becomes the value of INSTALLTOP in Makefile
32# (Default: /usr/local)
33# --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
34# If it's a relative directory, it will be added on the directory
35# given with --prefix.
36# This becomes the value of OPENSSLDIR in Makefile and in C.
37# (Default: PREFIX/ssl)
e5f3045f 38#
cbfb39d1
AP		 39# --cross-compile-prefix Add specified prefix to binutils components.
40#
98186eb4
VD		 41# --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for
42# interfaces deprecated as of the specified OpenSSL version.
43#
5270e702
RL		 44# no-hw-xxx do not compile support for specific crypto hardware.
45# Generic OpenSSL-style methods relating to this support
46# are always compiled but return NULL if the hardware
47# support isn't compiled.
48# no-hw do not compile support for any crypto hardware.
5f8d5c96
BM		 49# [no-]threads [don't] try to create a library that is suitable for
50# multithreaded applications (default is "threads" if we
51# know how to do it)
fcc6a1c4 52# [no-]shared [don't] try to create shared libraries when supported.
ae48242c 53# [no-]pic [don't] try to build position independent code when supported.
45b71abe 54# If disabled, it also disables shared and dynamic-engine.
a723979d 55# no-asm do not use assembler
bc2aadad
GT		 56# no-dso do not compile in any native shared-library methods. This
57# will ensure that all methods just return NULL.
0423f812 58# no-egd do not compile support for the entropy-gathering daemon APIs
e452de9d
RL		 59# [no-]zlib [don't] compile support for zlib compression.
60# zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
61# library and will be loaded in run-time by the OpenSSL library.
7e159e01 62# sctp include SCTP support
8b1a5af3 63# enable-weak-ssl-ciphers
edcdf38b 64# Enable weak ciphers that are disabled by default.
5ae5dc96
AP		 65# 386 generate 80386 code in assembly modules
66# no-sse2 disables IA-32 SSE2 code in assembly modules, the above
67# mentioned '386' option implies this one
79df9d62 68# no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
fce0ba5f 69# -<xxx> +<xxx> compiler options are passed through
047d97af
AP		 70# -static while -static is also a pass-through compiler option (and
71# as such is limited to environments where it's actually
72# meaningful), it triggers a number configuration options,
73# namely no-dso, no-pic, no-shared and no-threads. It is
74# argued that the only reason to produce statically linked
75# binaries (and in context it means executables linked with
76# -static flag, and not just executables linked with static
77# libcrypto.a) is to eliminate dependency on specific run-time,
78# a.k.a. libc version. The mentioned config options are meant
79# to achieve just that. Unfortunately on Linux it's impossible
80# to eliminate the dependency completely for openssl executable
81# because of getaddrinfo and gethostbyname calls, which can
82# invoke dynamically loadable library facility anyway to meet
83# the lookup requests. For this reason on Linux statically
84# linked openssl executable has rather debugging value than
85# production quality.
e41c8d6a
GT		 86#
87# DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
88# provided to stack calls. Generates unique stack functions for
89# each possible stack type.
d02b48c6 90# BN_LLONG use the type 'long long' in crypto/bn/bn.h
d02b48c6 91# RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
d0590fe6
AP		 92# Following are set automatically by this script
93#
8483a003
F		 94# MD5_ASM use some extra md5 assembler,
95# SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
96# RMD160_ASM use some extra ripemd160 assembler,
d0590fe6
AP		 97# SHA256_ASM sha256_block is implemented in assembler
98# SHA512_ASM sha512_block is implemented in assembler
28bd8e94 99# AES_ASM AES_[en|de]crypt is implemented in assembler
d02b48c6 100
363bd0b4 101# Minimum warning options... any contributions to OpenSSL should at least get
fce0ba5f 102# past these.
363bd0b4 103
463a7b8c 104# DEBUG_UNUSED enables __owur (warn unused result) checks.
77305338
RS		 105# -DPEDANTIC complements -pedantic and is meant to mask code that
106# is not strictly standard-compliant and/or implementation-specific,
107# e.g. inline assembly, disregards to alignment requirements, such
108# that -pedantic would complain about. Incidentally -DPEDANTIC has
109# to be used even in sanitized builds, because sanitizer too is
110# supposed to and does take notice of non-standard behaviour. Then
111# -pedantic with pre-C9x compiler would also complain about 'long
112# long' not being supported. As 64-bit algorithms are common now,
113# it grew impossible to resolve this without sizeable additional
114# code, so we just tell compiler to be pedantic about everything
115# but 'long long' type.
116
463a7b8c 117my $gcc_devteam_warn = "-DDEBUG_UNUSED"
f3b3d7f0 118 . " -Wswitch"
463a7b8c 119 . " -DPEDANTIC -pedantic -Wno-long-long"
8bccbce5 120 . " -Wall"
560ad13c
BK		 121 . " -Wextra"
122 . " -Wno-unused-parameter"
123 . " -Wno-missing-field-initializers"
8bccbce5
RS		 124 . " -Wsign-compare"
125 . " -Wmissing-prototypes"
126 . " -Wshadow"
127 . " -Wformat"
128 . " -Wtype-limits"
01b76c2c 129 . " -Wundef"
8bccbce5
RS		 130 . " -Werror"
131 ;
363bd0b4 132
190c8c60
BL		 133# These are used in addition to $gcc_devteam_warn when the compiler is clang.
134# TODO(openssl-team): fix problems and investigate if (at least) the
480405e4 135# following warnings can also be enabled:
8bccbce5 136# -Wcast-align
77305338 137# -Wunreachable-code -- no, too ugly/compiler-specific
a773b52a
RS		 138# -Wlanguage-extension-token -- no, we use asm()
139# -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
140# -Wextended-offsetof -- no, needed in CMS ASN1 code
8bccbce5
RS		 141my $clang_devteam_warn = ""
142 . " -Qunused-arguments"
96db2691 143 . " -Wswitch-default"
77305338 144 . " -Wno-parentheses-equality"
8bccbce5
RS		 145 . " -Wno-language-extension-token"
146 . " -Wno-extended-offsetof"
147 . " -Wconditional-uninitialized"
148 . " -Wincompatible-pointer-types-discards-qualifiers"
149 . " -Wmissing-variable-declarations"
150 ;
cb2bc054 151
ef8ca6bd
RL		 152# This adds backtrace information to the memory leak info. Is only used
153# when crypto-mdebug-backtrace is enabled.
154my $memleak_devteam_backtrace = "-rdynamic";
a1d3f3d1 155
0c28f277
DSH		 156my $strict_warnings = 0;
157
b7efa56a 158# As for $BSDthreads. Idea is to maintain "collective" set of flags,
fce0ba5f 159# which would cover all BSD flavors. -pthread applies to them all,
b7efa56a
AP		 160# but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
161# -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
162# which has to be accompanied by explicit -D_THREAD_SAFE and
163# sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
164# seems to be sufficient?
9c62a279 165our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
d02b48c6 166
98186eb4 167#
f430ba31 168# API compatibility name to version number mapping.
98186eb4
VD		 169#
170my $maxapi = "1.1.0"; # API for "no-deprecated" builds
171my $apitable = {
172 "1.1.0" => "0x10100000L",
173 "1.0.0" => "0x10000000L",
174 "0.9.8" => "0x00908000L",
175};
176
9e0724a1 177our %table = ();
291e94df 178our %config = ();
98fdbce0 179our %withargs = ();
3e83e686 180
bd5192b1 181# Forward declarations ###############################################
7ead0c89 182
bd5192b1
RL		 183# read_config(filename)
184#
185# Reads a configuration file and populates %table with the contents
186# (which the configuration file places in %targets).
187sub read_config;
7d46b942 188
bd5192b1
RL		 189# resolve_config(target)
190#
8483a003 191# Resolves all the late evaluations, inheritances and so on for the
bd5192b1
RL		 192# chosen target and any target it inherits from.
193sub resolve_config;
7d46b942 194
15c7adb0 195
107b5792
RL		 196# Information collection #############################################
197
9fe2bb77 198# Unified build supports separate build dir
ec182ef0
RL		 199my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
200my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
9fe2bb77
RL		 201my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
202
b5293d4c
RL		 203my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
204
9fe2bb77
RL		 205$config{sourcedir} = abs2rel($srcdir);
206$config{builddir} = abs2rel($blddir);
207
ee4cdb7f
RL		 208# Collect reconfiguration information if needed
209my @argvcopy=@ARGV;
210
211if (grep /^reconf(igure)?$/, @argvcopy) {
212 if (-f "./configdata.pm") {
213 my $file = "./configdata.pm";
214 unless (my $return = do $file) {
215 die "couldn't parse $file: $@" if $@;
216 die "couldn't do $file: $!" unless defined $return;
217 die "couldn't run $file" unless $return;
218 }
219
220 @argvcopy = defined($configdata::config{perlargv}) ?
221 @{$configdata::config{perlargv}} : ();
222 die "Incorrect data to reconfigure, please do a normal configuration\n"
223 if (grep(/^reconf/,@argvcopy));
224 $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
225 if defined($configdata::config{cross_compile_prefix});
226 $ENV{CC} = $configdata::config{cc}
227 if defined($configdata::config{cc});
ea241958
RL		 228 $ENV{CXX} = $configdata::config{cxx}
229 if defined($configdata::config{cxx});
ee4cdb7f
RL		 230 $ENV{BUILDFILE} = $configdata::config{build_file}
231 if defined($configdata::config{build_file});
232 $ENV{$local_config_envname} = $configdata::config{local_config_dir}
233 if defined($configdata::config{local_config_dir});
234
235 print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
236 print " CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
237 if $ENV{CROSS_COMPILE};
238 print " CC = ",$ENV{CC},"\n" if $ENV{CC};
ea241958 239 print " CXX = ",$ENV{CXX},"\n" if $ENV{CXX};
ee4cdb7f
RL		 240 print " BUILDFILE = ",$ENV{BUILDFILE},"\n" if $ENV{BUILDFILE};
241 print " $local_config_envname = ",$ENV{$local_config_envname},"\n"
242 if $ENV{$local_config_envname};
243 } else {
244 die "Insufficient data to reconfigure, please do a normal configuration\n";
245 }
246}
247
248$config{perlargv} = [ @argvcopy ];
249
107b5792
RL		 250# Collect version numbers
251$config{version} = "unknown";
252$config{version_num} = "unknown";
253$config{shlib_version_number} = "unknown";
254$config{shlib_version_history} = "unknown";
255
256collect_information(
9fe2bb77 257 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
107b5792
RL		 258 qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
259 qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 },
260 qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 },
261 qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 }
262 );
263if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
264
265($config{major}, $config{minor})
266 = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
267($config{shlib_major}, $config{shlib_minor})
268 = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
269die "erroneous version information in opensslv.h: ",
270 "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
271 if ($config{major} eq "" || $config{minor} eq ""
272 || $config{shlib_major} eq "" || $config{shlib_minor} eq "");
273
274# Collect target configurations
275
85152ca4 276my $pattern = catfile(dirname($0), "Configurations", "*.conf");
97855556 277foreach (sort glob($pattern)) {
f09e7ca9
RS		 278 &read_config($_);
279}
d02b48c6 280
b5293d4c
RL		 281if (defined $ENV{$local_config_envname}) {
282 if ($^O eq 'VMS') {
283 # VMS environment variables are logical names,
284 # which can be used as is
285 $pattern = $local_config_envname . ':' . '*.conf';
286 } else {
287 $pattern = catfile($ENV{$local_config_envname}, '*.conf');
288 }
289
97855556 290 foreach (sort glob($pattern)) {
b5293d4c
RL		 291 &read_config($_);
292 }
293}
294
291e94df
RL		 295$config{prefix}="";
296$config{openssldir}="";
7d130f68 297$config{processor}="";
107b5792 298$config{libdir}="";
642a6138 299$config{cross_compile_prefix}="";
9c62a279 300my $auto_threads=1; # enable threads automatically? true by default
0396479d 301my $default_ranlib;
107b5792
RL		 302
303# Top level directories to build
342a1a23 304$config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "util", "tools", "fuzz" ];
107b5792
RL		 305# crypto/ subdirectories to build
306$config{sdirs} = [
307 "objects",
3f5616d7 308 "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2", "siphash",
d42d0a4d 309 "des", "aes", "rc2", "rc4", "rc5", "idea", "aria", "bf", "cast", "camellia", "seed", "chacha", "modes",
107b5792
RL		 310 "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
311 "buffer", "bio", "stack", "lhash", "rand", "err",
312 "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
dba31777 313 "cms", "ts", "srp", "cmac", "ct", "async", "kdf"
107b5792 314 ];
cfa76979
RL		 315# test/ subdirectories to build
316$config{tdirs} = [ "ossl_shim" ];
99aab161 317
6b01bed2 318# Known TLS and DTLS protocols
84a68336 319my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
6b01bed2
VD		 320my @dtls = qw(dtls1 dtls1_2);
321
8483a003 322# Explicitly known options that are possible to disable. They can
8b527be2
RL		 323# be regexps, and will be used like this: /^no-${option}$/
324# For developers: keep it sorted alphabetically
325
326my @disablables = (
c91a0a83 327 "afalgeng",
d42d0a4d 328 "aria",
c38bb727 329 "asan",
8b527be2 330 "asm",
52739e40 331 "async",
b184e3ef 332 "autoalginit",
498abff0 333 "autoerrinit",
8b527be2 334 "bf",
2d0b4412 335 "blake2",
8b527be2
RL		 336 "camellia",
337 "capieng",
338 "cast",
48f14845 339 "chacha",
8b527be2
RL		 340 "cmac",
341 "cms",
342 "comp",
3e45d393 343 "crypto-mdebug",
ef8ca6bd 344 "crypto-mdebug-backtrace",
8b527be2
RL		 345 "ct",
346 "deprecated",
347 "des",
348 "dgram",
349 "dh",
350 "dsa",
351 "dso",
a5ecdc6a 352 "dtls",
343ec2b0 353 "dynamic-engine",
8b527be2
RL		 354 "ec",
355 "ec2m",
6b01bed2
VD		 356 "ecdh",
357 "ecdsa",
8b527be2 358 "ec_nistp_64_gcc_128",
b31feae6 359 "egd",
8b527be2 360 "engine",
1288f26f 361 "err",
ce2596d4 362 "external-tests",
02f7114a 363 "filenames",
f59d0131
KR		 364 "fuzz-libfuzzer",
365 "fuzz-afl",
168c3b73 366 "gost",
b612799a 367 "heartbeats",
8b527be2
RL		 368 "hw(-.+)?",
369 "idea",
09aa263a 370 "makedepend",
8b527be2
RL		 371 "md2",
372 "md4",
8b527be2 373 "mdc2",
29df3061 374 "msan",
fa22f98f 375 "multiblock",
8b527be2
RL		 376 "nextprotoneg",
377 "ocb",
378 "ocsp",
ae48242c 379 "pic",
48f14845 380 "poly1305",
8b527be2
RL		 381 "posix-io",
382 "psk",
383 "rc2",
384 "rc4",
385 "rc5",
386 "rdrand",
387 "rfc3779",
8b527be2 388 "rmd160",
8b527be2 389 "scrypt",
8b527be2
RL		 390 "sctp",
391 "seed",
8b527be2 392 "shared",
3f5616d7 393 "siphash",
8b527be2
RL		 394 "sock",
395 "srp",
396 "srtp",
397 "sse2",
398 "ssl",
8b527be2
RL		 399 "ssl-trace",
400 "static-engine",
401 "stdio",
93880ce1 402 "tests",
8b527be2
RL		 403 "threads",
404 "tls",
3556b83e 405 "tls13downgrade",
1288f26f 406 "ts",
c38bb727 407 "ubsan",
1288f26f 408 "ui",
8b527be2
RL		 409 "unit-test",
410 "whirlpool",
8b1a5af3 411 "weak-ssl-ciphers",
8b527be2
RL		 412 "zlib",
413 "zlib-dynamic",
414 );
6b01bed2
VD		 415foreach my $proto ((@tls, @dtls))
416 {
417 push(@disablables, $proto);
418 push(@disablables, "$proto-method");
419 }
8b527be2 420
2b1343b9
MC		 421my %deprecated_disablables = (
422 "ssl2" => undef,
423 "buf-freelists" => undef,
424 "ripemd" => "rmd160"
e80381e1
RL		 425 );
426
c9a112f5
BM		 427# All of the following is disabled by default (RC5 was enabled before 0.9.8):
428
9e04edf2 429our %disabled = ( # "what" => "comment"
d42d0a4d 430 "aria" => "default",
c38bb727 431 "asan" => "default",
a9c27fe1
BK		 432 "crypto-mdebug" => "default",
433 "crypto-mdebug-backtrace" => "default",
9e04edf2 434 "ec_nistp_64_gcc_128" => "default",
8b1a5af3 435 "egd" => "default",
ce2596d4 436 "external-tests" => "default",
f59d0131
KR		 437 "fuzz-libfuzzer" => "default",
438 "fuzz-afl" => "default",
b612799a 439 "heartbeats" => "default",
8b1a5af3 440 "md2" => "default",
29df3061 441 "msan" => "default",
8b1a5af3
MC		 442 "rc5" => "default",
443 "sctp" => "default",
8b1a5af3 444 "ssl-trace" => "default",
9829b5ab
KR		 445 "ssl3" => "default",
446 "ssl3-method" => "default",
c38bb727 447 "ubsan" => "default",
84a68336
MC		 448 #TODO(TLS1.3): Temporarily disabled while this is a WIP
449 "tls1_3" => "default",
3556b83e 450 "tls13downgrade" => "default",
8b1a5af3
MC		 451 "unit-test" => "default",
452 "weak-ssl-ciphers" => "default",
453 "zlib" => "default",
454 "zlib-dynamic" => "default",
9e04edf2 455 );
c9a112f5 456
c569e206
RL		 457# Note: => pair form used for aesthetics, not to truly make a hash table
458my @disable_cascades = (
459 # "what" => [ "cascade", ... ]
7d130f68 460 sub { $config{processor} eq "386" }
c569e206
RL		 461 => [ "sse2" ],
462 "ssl" => [ "ssl3" ],
463 "ssl3-method" => [ "ssl3" ],
464 "zlib" => [ "zlib-dynamic" ],
c569e206 465 "des" => [ "mdc2" ],
9e4d6fbf 466 "ec" => [ "ecdsa", "ecdh" ],
c569e206 467
3fd4d211 468 "dgram" => [ "dtls", "sctp" ],
505f74ca 469 "sock" => [ "dgram" ],
c569e206 470 "dtls" => [ @dtls ],
343a7467
RL		 471 sub { 0 == scalar grep { !$disabled{$_} } @dtls }
472 => [ "dtls" ],
c569e206
RL		 473
474 # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
475 "md5" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
476 "sha" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
477
478 # Additionally, SSL 3.0 requires either RSA or DSA+DH
479 sub { $disabled{rsa}
480 && ($disabled{dsa} || $disabled{dh}); }
481 => [ "ssl" ],
482
483 # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
484 # or ECDSA + ECDH. (D)TLS 1.2 has this requirement as well.
485 # (XXX: We don't support PSK-only builds).
486 sub { $disabled{rsa}
487 && ($disabled{dsa} || $disabled{dh})
488 && ($disabled{ecdsa} || $disabled{ecdh}); }
84a68336 489 => [ "tls1", "tls1_1", "tls1_2", "tls1_3",
c569e206
RL		 490 "dtls1", "dtls1_2" ],
491
492 "tls" => [ @tls ],
343a7467
RL		 493 sub { 0 == scalar grep { !$disabled{$_} } @tls }
494 => [ "tls" ],
c569e206 495
b612799a
RL		 496 # SRP and HEARTBEATS require TLSEXT
497 "tlsext" => [ "srp", "heartbeats" ],
ef8ca6bd
RL		 498
499 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
343ec2b0
RL		 500
501 # Without DSO, we can't load dynamic engines, so don't build them dynamic
502 "dso" => [ "dynamic-engine" ],
ae48242c
RL		 503
504 # Without position independent code, there can be no shared libraries or DSOs
00698061
RL		 505 "pic" => [ "shared" ],
506 "shared" => [ "dynamic-engine" ],
c91a0a83 507 "engine" => [ "afalgeng" ],
d90a6beb
MC		 508
509 # no-autoalginit is only useful when building non-shared
510 "autoalginit" => [ "shared", "apps" ],
511
25d498c1 512 "stdio" => [ "apps", "capieng" ],
d90a6beb 513 "apps" => [ "tests" ],
3cf96e88
MC		 514 "comp" => [ "zlib" ],
515 "ec" => [ "tls1_3" ],
b612799a 516 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
29df3061
EK		 517
518 sub { !$disabled{"msan"} } => [ "asm" ],
c569e206
RL		 519 );
520
521# Avoid protocol support holes. Also disable all versions below N, if version
522# N is disabled while N+1 is enabled.
523#
524my @list = (reverse @tls);
525while ((my $first, my $second) = (shift @list, shift @list)) {
526 last unless @list;
527 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
528 => [ @list ] );
529 unshift @list, $second;
530}
531my @list = (reverse @dtls);
532while ((my $first, my $second) = (shift @list, shift @list)) {
533 last unless @list;
534 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
535 => [ @list ] );
536 unshift @list, $second;
537}
538
7a762197 539# Explicit "no-..." options will be collected in %disabled along with the defaults.
e4ef2e25 540# To remove something from %disabled, use "enable-foo".
7a762197
BM		 541# For symmetry, "disable-foo" is a synonym for "no-foo".
542
d0590fe6 543my $no_sse2=0;
b6e4dac2 544
462ba4f6 545&usage if ($#ARGV < 0);
d02b48c6 546
bcb1977b
RL		 547my $user_cflags="";
548my @user_defines=();
7d130f68
RL		 549$config{openssl_api_defines}=[];
550$config{openssl_algorithm_defines}=[];
551$config{openssl_thread_defines}=[];
552$config{openssl_sys_defines}=[];
553$config{openssl_other_defines}=[];
fe05264e
RL		 554my $libs="";
555my $target="";
3fa04f0d 556$config{options}="";
8864f0de 557$config{build_type} = "release";
c59cb511 558
fe05264e 559my %unsupported_options = ();
e80381e1 560my %deprecated_options = ();
fad599f7 561while (@argvcopy)
16b6081e 562 {
fad599f7 563 $_ = shift @argvcopy;
7c55e22c
RL		 564 # VMS is a case insensitive environment, and depending on settings
565 # out of our control, we may receive options uppercased. Let's
566 # downcase at least the part before any equal sign.
567 if ($^O eq "VMS")
568 {
569 s/^([^=]*)/lc($1)/e;
570 }
fe05264e 571 s /^-no-/no-/; # some people just can't read the instructions
c9a112f5 572
fe05264e
RL		 573 # rewrite some options in "enable-..." form
574 s /^-?-?shared$/enable-shared/;
575 s /^sctp$/enable-sctp/;
576 s /^threads$/enable-threads/;
577 s /^zlib$/enable-zlib/;
578 s /^zlib-dynamic$/enable-zlib-dynamic/;
c9a112f5 579
e4ef2e25 580 if (/^(no|disable|enable)-(.+)$/)
2b1343b9
MC		 581 {
582 my $word = $2;
583 if (!exists $deprecated_disablables{$word}
584 && !grep { $word =~ /^${_}$/ } @disablables)
585 {
586 $unsupported_options{$_} = 1;
587 next;
588 }
589 }
590 if (/^no-(.+)$/ || /^disable-(.+)$/)
591 {
e4ef2e25
RS		 592 foreach my $proto ((@tls, @dtls))
593 {
594 if ($1 eq "$proto-method")
595 {
596 $disabled{"$proto"} = "option($proto-method)";
597 last;
598 }
599 }
600 if ($1 eq "dtls")
601 {
602 foreach my $proto (@dtls)
603 {
604 $disabled{$proto} = "option(dtls)";
605 }
c5c7700c 606 $disabled{"dtls"} = "option(dtls)";
e4ef2e25
RS		 607 }
608 elsif ($1 eq "ssl")
609 {
610 # Last one of its kind
611 $disabled{"ssl3"} = "option(ssl)";
612 }
613 elsif ($1 eq "tls")
614 {
615 # XXX: Tests will fail if all SSL/TLS
616 # protocols are disabled.
617 foreach my $proto (@tls)
618 {
619 $disabled{$proto} = "option(tls)";
620 }
621 }
343ec2b0
RL		 622 elsif ($1 eq "static-engine")
623 {
19ab5790 624 delete $disabled{"dynamic-engine"};
343ec2b0
RL		 625 }
626 elsif ($1 eq "dynamic-engine")
627 {
19ab5790 628 $disabled{"dynamic-engine"} = "option";
343ec2b0 629 }
2b1343b9
MC		 630 elsif (exists $deprecated_disablables{$1})
631 {
632 $deprecated_options{$_} = 1;
633 if (defined $deprecated_disablables{$1})
634 {
635 $disabled{$deprecated_disablables{$1}} = "option";
636 }
637 }
e4ef2e25
RS		 638 else
639 {
640 $disabled{$1} = "option";
641 }
9c62a279
RL		 642 # No longer an automatic choice
643 $auto_threads = 0 if ($1 eq "threads");
fe05264e 644 }
e4ef2e25 645 elsif (/^enable-(.+)$/)
fe05264e 646 {
343ec2b0
RL		 647 if ($1 eq "static-engine")
648 {
19ab5790 649 $disabled{"dynamic-engine"} = "option";
343ec2b0
RL		 650 }
651 elsif ($1 eq "dynamic-engine")
652 {
19ab5790 653 delete $disabled{"dynamic-engine"};
343ec2b0 654 }
25004db7
RL		 655 elsif ($1 eq "zlib-dynamic")
656 {
657 delete $disabled{"zlib"};
658 }
fe05264e 659 my $algo = $1;
fe05264e 660 delete $disabled{$algo};
c9a112f5 661
9c62a279
RL		 662 # No longer an automatic choice
663 $auto_threads = 0 if ($1 eq "threads");
fe05264e
RL		 664 }
665 elsif (/^--strict-warnings$/)
666 {
667 $strict_warnings = 1;
668 }
669 elsif (/^--debug$/)
670 {
8864f0de 671 $config{build_type} = "debug";
fe05264e
RL		 672 }
673 elsif (/^--release$/)
674 {
8864f0de 675 $config{build_type} = "release";
fe05264e
RL		 676 }
677 elsif (/^386$/)
7d130f68 678 { $config{processor}=386; }
fe05264e
RL		 679 elsif (/^fips$/)
680 {
b53338cb 681 die "FIPS mode not supported\n";
fe05264e
RL		 682 }
683 elsif (/^rsaref$/)
684 {
685 # No RSAref support any more since it's not needed.
686 # The check for the option is there so scripts aren't
687 # broken
688 }
689 elsif (/^nofipscanistercheck$/)
690 {
b53338cb 691 die "FIPS mode not supported\n";
fe05264e
RL		 692 }
693 elsif (/^[-+]/)
694 {
45c6e23c 695 if (/^--prefix=(.*)$/)
fe05264e 696 {
291e94df 697 $config{prefix}=$1;
5482dac9
RL		 698 die "Directory given with --prefix MUST be absolute\n"
699 unless file_name_is_absolute($config{prefix});
c9a112f5 700 }
fe05264e 701 elsif (/^--api=(.*)$/)
0c28f277 702 {
107b5792 703 $config{api}=$1;
0c28f277 704 }
fe05264e 705 elsif (/^--libdir=(.*)$/)
9e43c6b5 706 {
107b5792 707 $config{libdir}=$1;
9e43c6b5 708 }
fe05264e 709 elsif (/^--openssldir=(.*)$/)
9e43c6b5 710 {
291e94df 711 $config{openssldir}=$1;
9e43c6b5 712 }
fe05264e 713 elsif (/^--with-zlib-lib=(.*)$/)
9fdb2cc5 714 {
20a5819f 715 $withargs{zlib_lib}=$1;
7d8bb912 716 }
fe05264e 717 elsif (/^--with-zlib-include=(.*)$/)
3eb0ed6d 718 {
da430a55 719 $withargs{zlib_include}=$1;
462ba4f6 720 }
f59d0131
KR		 721 elsif (/^--with-fuzzer-lib=(.*)$/)
722 {
723 $withargs{fuzzer_lib}=$1;
724 }
725 elsif (/^--with-fuzzer-include=(.*)$/)
726 {
727 $withargs{fuzzer_include}=$1;
728 }
fe05264e 729 elsif (/^--cross-compile-prefix=(.*)$/)
e5f3045f 730 {
642a6138 731 $config{cross_compile_prefix}=$1;
e5f3045f 732 }
fe05264e 733 elsif (/^--config=(.*)$/)
d02b48c6 734 {
fe05264e 735 read_config $1;
c59cb511 736 }
fe05264e 737 elsif (/^-[lL](.*)$/ or /^-Wl,/)
c9a112f5 738 {
fe05264e 739 $libs.=$_." ";
d02b48c6 740 }
b7438b43
AP		 741 elsif (/^-framework$/)
742 {
743 $libs.=$_." ".shift(@argvcopy)." ";
744 }
fad599f7
RL		 745 elsif (/^-rpath$/ or /^-R$/)
746 # -rpath is the OSF1 rpath flag
747 # -R is the old Solaris rpath flag
748 {
749 my $rpath = shift(@argvcopy) || "";
750 $rpath .= " " if $rpath ne "";
751 $libs.=$_." ".$rpath;
752 }
9d46752d
AP		 753 elsif (/^-static$/)
754 {
755 $libs.=$_." ";
047d97af 756 $disabled{"dso"} = "forced";
9d46752d
AP		 757 $disabled{"pic"} = "forced";
758 $disabled{"shared"} = "forced";
759 $disabled{"threads"} = "forced";
760 }
bcb1977b
RL		 761 elsif (/^-D(.*)$/)
762 {
763 push @user_defines, $1;
764 }
fe05264e
RL		 765 else # common if (/^[-+]/), just pass down...
766 {
767 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
2b91ec75 768 $user_cflags.=" ".$_;
fe05264e
RL		 769 }
770 }
fe05264e
RL		 771 else
772 {
773 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
774 $target=$_;
775 }
776 unless ($_ eq $target || /^no-/ || /^disable-/)
777 {
778 # "no-..." follows later after implied disactivations
8483a003 779 # have been derived. (Don't take this too seriously,
fe05264e
RL		 780 # we really only write OPTIONS to the Makefile out of
781 # nostalgia.)
782
3fa04f0d
RL		 783 if ($config{options} eq "")
784 { $config{options} = $_; }
fe05264e 785 else
3fa04f0d 786 { $config{options} .= " ".$_; }
fbabb752 787 }
489eb740 788
107b5792
RL		 789 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
790 die "***** Unsupported api compatibility level: $config{api}\n",
98186eb4
VD		 791 }
792
e80381e1
RL		 793 if (keys %deprecated_options)
794 {
795 warn "***** Deprecated options: ",
796 join(", ", keys %deprecated_options), "\n";
797 }
489eb740
RL		 798 if (keys %unsupported_options)
799 {
800 die "***** Unsupported options: ",
801 join(", ", keys %unsupported_options), "\n";
802 }
fbabb752 803 }
b6e4dac2 804
342a1a23
RL		 805if ($libs =~ /(^|\s)-Wl,-rpath,/
806 && !$disabled{shared}
807 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
808 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
809 "***** any of asan, msan or ubsan\n";
810}
811
c569e206
RL		 812my @tocheckfor = (keys %disabled);
813while (@tocheckfor) {
814 my %new_tocheckfor = ();
815 my @cascade_copy = (@disable_cascades);
816 while (@cascade_copy) {
817 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
818 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
2110febb 819 foreach(grep { !defined($disabled{$_}) } @$descendents) {
01d99976 820 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
2110febb 821 }
ef236ec3 822 }
c569e206
RL		 823 }
824 @tocheckfor = (keys %new_tocheckfor);
825}
edc032b5 826
d63c12c6 827our $die = sub { die @_; };
436a376b 828if ($target eq "TABLE") {
d63c12c6 829 local $die = sub { warn @_; };
00ae96ca
RL		 830 foreach (sort keys %table) {
831 print_table_entry($_, "TABLE");
832 }
833 exit 0;
436a376b
BM		 834}
835
10a926c1 836if ($target eq "LIST") {
00ae96ca
RL		 837 foreach (sort keys %table) {
838 print $_,"\n" unless $table{$_}->{template};
839 }
840 exit 0;
10a926c1
UM		 841}
842
aaf878cc 843if ($target eq "HASH") {
d63c12c6 844 local $die = sub { warn @_; };
00ae96ca
RL		 845 print "%table = (\n";
846 foreach (sort keys %table) {
847 print_table_entry($_, "HASH");
848 }
849 exit 0;
aaf878cc
RL		 850}
851
64119271
RL		 852print "Configuring OpenSSL version $config{version} ($config{version_num})\n";
853print "for $target\n";
854
00ae96ca 855# Backward compatibility?
49e04548 856if ($target =~ m/^CygWin32(-.*)$/) {
00ae96ca 857 $target = "Cygwin".$1;
49e04548
RL		 858}
859
c9a112f5
BM		 860foreach (sort (keys %disabled))
861 {
3fa04f0d 862 $config{options} .= " no-$_";
c9a112f5
BM		 863
864 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
865
866 if (/^dso$/)
721f9058 867 { }
c9a112f5 868 elsif (/^threads$/)
22bfe05e 869 { }
c9a112f5 870 elsif (/^shared$/)
84af1bae 871 { }
ae48242c
RL		 872 elsif (/^pic$/)
873 { }
c9a112f5 874 elsif (/^zlib$/)
36a30909 875 { }
19ab5790 876 elsif (/^dynamic-engine$/)
fbf002bb 877 { }
09aa263a
RL		 878 elsif (/^makedepend$/)
879 { }
c9a112f5
BM		 880 elsif (/^zlib-dynamic$/)
881 { }
c9a112f5
BM		 882 elsif (/^sse2$/)
883 { $no_sse2 = 1; }
107b5792 884 elsif (/^engine$/)
1288f26f
RS		 885 {
886 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
887 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
888 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
3e2dd30d 889 print " OPENSSL_NO_ENGINE (skip engines)";
1288f26f 890 }
c9a112f5
BM		 891 else
892 {
3e2dd30d 893 my ($WHAT, $what);
c9a112f5 894
3e2dd30d
RL		 895 ($WHAT = $what = $_) =~ tr/[\-a-z]/[_A-Z]/;
896
897 # Fix up C macro end names
898 $WHAT = "RMD160" if $what eq "ripemd";
899
900 # fix-up crypto/directory name(s)
901 $what = "ripemd" if $what eq "rmd160";
902 $what = "whrlpool" if $what eq "whirlpool";
903
66fe388a
RL		 904 if ($what ne "async" && $what ne "err"
905 && grep { $_ eq $what } @{$config{sdirs}})
c9a112f5 906 {
3e2dd30d
RL		 907 push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$WHAT";
908 @{$config{sdirs}} = grep { $_ ne $what} @{$config{sdirs}};
fce0ba5f 909
3e2dd30d 910 print " OPENSSL_NO_$WHAT (skip dir)";
c9a112f5
BM		 911 }
912 else
913 {
3e2dd30d
RL		 914 push @{$config{openssl_other_defines}}, "OPENSSL_NO_$WHAT";
915 print " OPENSSL_NO_$WHAT";
2a4af947 916
3e2dd30d 917 if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; }
c9a112f5
BM		 918 }
919 }
920
921 print "\n";
922 }
923
9e0724a1
RL		 924# Support for legacy targets having a name starting with 'debug-'
925my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
926if ($d) {
8864f0de 927 $config{build_type} = "debug";
9e0724a1
RL		 928
929 # If we do not find debug-foo in the table, the target is set to foo.
930 if (!$table{$target}) {
931 $target = $t;
932 }
933}
291e94df 934$config{target} = $target;
79302211 935my %target = resolve_config($target);
9e0724a1
RL		 936
937&usage if (!%target || $target{template});
938
ee9b0bbb
RL		 939my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
940$config{conf_files} = [ sort keys %conf_files ];
d2b2221a 941%target = ( %{$table{DEFAULTS}}, %target );
79302211 942
ea241958 943$target{cxxflags}=$target{cflags} unless defined $target{cxxflags};
107b5792 944$target{exe_extension}="";
f99f91f1
RL		 945$target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
946 || $config{target} =~ /^(?:Cygwin|mingw)/);
107b5792 947$target{exe_extension}=".pm" if ($config{target} =~ /vos/);
462ba4f6 948
e987f9f2
RL		 949($target{shared_extension_simple}=$target{shared_extension})
950 =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
951$target{dso_extension}=$target{shared_extension_simple};
952($target{shared_import_extension}=$target{shared_extension_simple}.".a")
953 if ($config{target} =~ /^(?:Cygwin|mingw)/);
954
955
642a6138
RL		 956$config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
957 if $config{cross_compile_prefix} eq "";
f99f41cf 958
b0a1e8bf 959# Allow overriding the names of some tools. USE WITH CARE
d513369b
RL		 960# Note: only Unix cares about HASHBANGPERL... that explains
961# the default string.
758baa3d 962$config{perl} = ($^O ne "VMS" ? $^X : "perl");
d513369b
RL		 963$config{hashbangperl} =
964 $ENV{'HASHBANGPERL'} || $ENV{'PERL'} || "/usr/bin/env perl";
b0a1e8bf 965$target{cc} = $ENV{'CC'} || $target{cc} || "cc";
83bd048e 966$target{cxx} = $ENV{'CXX'} || $target{cxx} || "c++";
f58a0acb 967$target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} ||
656bbdc6 968 (which("$config{cross_compile_prefix}ranlib") ?
f58a0acb 969 "\$(CROSS_COMPILE)ranlib" : "true");
b0a1e8bf
RL		 970$target{ar} = $ENV{'AR'} || $target{ar} || "ar";
971$target{nm} = $ENV{'NM'} || $target{nm} || "nm";
8f41ff2d
RL		 972$target{rc} =
973 $ENV{'RC'} || $ENV{'WINDRES'} || $target{rc} || "windres";
aaf878cc 974
8b5156d1
RL		 975# Allow overriding the build file name
976$target{build_file} = $ENV{BUILDFILE} || $target{build_file} || "Makefile";
977
978# Cache information necessary for reconfiguration
a66234bc 979$config{cc} = $target{cc};
ea241958 980$config{cxx} = $target{cxx};
8b5156d1 981$config{build_file} = $target{build_file};
a66234bc 982
bcb1977b
RL		 983# For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
984# or release_ attributes.
aaf878cc 985# Do it in such a way that no spurious space is appended (hence the grep).
2952b9b8
RL		 986$config{defines} = [];
987$config{cflags} = "";
ea241958 988$config{cxxflags} = "";
2952b9b8
RL		 989$config{ex_libs} = "";
990$config{shared_ldflag} = "";
bd5192b1 991
291e94df
RL		 992# Make sure build_scheme is consistent.
993$target{build_scheme} = [ $target{build_scheme} ]
994 if ref($target{build_scheme}) ne "ARRAY";
995
ddf1847d
RL		 996my ($builder, $builder_platform, @builder_opts) =
997 @{$target{build_scheme}};
998
d192a3aa
RL		 999foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1000 $builder_platform."-checker.pm")) {
1001 my $checker_path = catfile($srcdir, "Configurations", $checker);
1002 if (-f $checker_path) {
1003 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1004 ? sub { warn $@; } : sub { die $@; };
1005 if (! do $checker_path) {
1006 if ($@) {
1007 $fn->($@);
1008 } elsif ($!) {
1009 $fn->($!);
1010 } else {
1011 $fn->("The detected tools didn't match the platform\n");
1012 }
1013 }
1014 last;
1015 }
1016}
1017
488e2b0f
RL		 1018push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1019
68ab559a 1020if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
cbecd29a 1021 {
68ab559a 1022 $config{cflags} .= " -mno-cygwin";
2952b9b8 1023 $config{shared_ldflag} .= " -mno-cygwin";
cbecd29a
AP		 1024 }
1025
00b0d663 1026if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
63d8834c 1027 # minimally required architecture flags for assembly modules
107b5792
RL		 1028 $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
1029 $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
63d8834c
AP		 1030}
1031
2964ba8c 1032my $no_shared_warn=0;
14bcdb08 1033my $no_user_cflags=0;
bcb1977b 1034my $no_user_defines=0;
2964ba8c 1035
bc2aadad
GT		 1036# The DSO code currently always implements all functions so that no
1037# applications will have to worry about that from a compilation point
1038# of view. However, the "method"s may return zero unless that platform
1039# has support compiled in for them. Currently each method is enabled
1040# by a define "DSO_<name>" ... we translate the "dso_scheme" config
1041# string entry into using the following logic;
721f9058 1042if (!$disabled{dso} && $target{dso_scheme} ne "")
bc2aadad 1043 {
291e94df
RL		 1044 $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
1045 if ($target{dso_scheme} eq "DLFCN")
bc2aadad 1046 {
2952b9b8 1047 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
bc2aadad 1048 }
291e94df 1049 elsif ($target{dso_scheme} eq "DLFCN_NO_H")
bc2aadad 1050 {
2952b9b8 1051 unshift @{$config{defines}}, "DSO_DLFCN";
bc2aadad
GT		 1052 }
1053 else
1054 {
2952b9b8 1055 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
bc2aadad
GT		 1056 }
1057 }
9ec0126e 1058
1740c162 1059$config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
d02b48c6 1060
9c62a279
RL		 1061# If threads aren't disabled, check how possible they are
1062unless ($disabled{threads}) {
1063 if ($auto_threads) {
1064 # Enabled by default, disable it forcibly if unavailable
1065 if ($target{thread_scheme} eq "(unknown)") {
1066 $disabled{threads} = "unavailable";
1067 }
1068 } else {
8483a003 1069 # The user chose to enable threads explicitly, let's see
9c62a279
RL		 1070 # if there's a chance that's possible
1071 if ($target{thread_scheme} eq "(unknown)") {
1072 # If the user asked for "threads" and we don't have internal
1073 # knowledge how to do it, [s]he is expected to provide any
1074 # system-dependent compiler options that are necessary. We
1075 # can't truly check that the given options are correct, but
1076 # we expect the user to know what [s]He is doing.
1077 if ($no_user_cflags && $no_user_defines) {
1078 die "You asked for multi-threading support, but didn't\n"
1079 ,"provide any system-specific compiler options\n";
1080 }
1081 }
1082 }
1083}
1084
1085# If threads still aren't disabled, add a C macro to ensure the source
1086# code knows about it. Any other flag is taken care of by the configs.
1087unless($disabled{threads}) {
1088 foreach (("defines", "openssl_thread_defines")) {
1089 push @{$config{$_}}, "OPENSSL_THREADS";
1090 }
1091}
e452de9d 1092
98186eb4
VD		 1093# With "deprecated" disable all deprecated features.
1094if (defined($disabled{"deprecated"})) {
107b5792 1095 $config{api} = $maxapi;
98186eb4 1096}
07c4c14c 1097
291e94df 1098if ($target{shared_target} eq "")
6f7ac8e1 1099 {
ae48242c 1100 $no_shared_warn = 1
b53338cb 1101 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
84af1bae 1102 $disabled{shared} = "no-shared-target";
ae48242c
RL		 1103 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1104 "no-shared-target";
6f7ac8e1 1105 }
b436a982 1106
19ab5790 1107if ($disabled{"dynamic-engine"}) {
343ec2b0
RL		 1108 push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1109 $config{dynamic_engines} = 0;
19ab5790
RL		 1110} else {
1111 push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1112 $config{dynamic_engines} = 1;
343ec2b0 1113}
ecd45314 1114
c38bb727
BL		 1115unless ($disabled{asan}) {
1116 $config{cflags} .= "-fsanitize=address ";
1117}
1118
1119unless ($disabled{ubsan}) {
f430ba31 1120 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
c38bb727
BL		 1121 # platforms.
1122 $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1123}
1124
29df3061
EK		 1125unless ($disabled{msan}) {
1126 $config{cflags} .= "-fsanitize=memory ";
1127}
1128
65cc6d5c 1129unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
29df3061 1130 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
c38bb727
BL		 1131 $config{cflags} .= "-fno-omit-frame-pointer -g ";
1132}
c313e32a
AP		 1133#
1134# Platform fix-ups
1135#
ae48242c
RL		 1136
1137# This saves the build files from having to check
1138if ($disabled{pic})
1139 {
1140 $target{shared_cflag} = $target{shared_ldflag} =
1141 $target{shared_rcflag} = "";
1142 }
4f16039e
RL		 1143else
1144 {
1145 push @{$config{defines}}, "OPENSSL_PIC";
1146 }
ae48242c 1147
291e94df 1148if ($target{sys_id} ne "")
cf1b7d96 1149 {
642a6138 1150 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
cf1b7d96
RL		 1151 }
1152
00b0d663 1153unless ($disabled{asm}) {
d2b2221a 1154 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
9fe2bb77 1155 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
f8c469de 1156
9e0724a1 1157 # bn-586 is the only one implementing bn_*_part_words
bcb1977b
RL		 1158 push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1159 push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
dfeab068 1160
bcb1977b
RL		 1161 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1162 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1163 push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
5ac7bde7 1164
9fe2bb77 1165 if ($target{sha1_asm_src}) {
bcb1977b
RL		 1166 push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1167 push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1168 push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
9e0724a1 1169 }
216e8d91
RL		 1170 if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
1171 push @{$config{defines}}, "RC4_ASM";
1172 }
9fe2bb77 1173 if ($target{md5_asm_src}) {
bcb1977b 1174 push @{$config{defines}}, "MD5_ASM";
9e0724a1 1175 }
d2b2221a 1176 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
9fe2bb77 1177 if ($target{rmd160_asm_src}) {
bcb1977b 1178 push @{$config{defines}}, "RMD160_ASM";
9e0724a1 1179 }
9fe2bb77 1180 if ($target{aes_asm_src}) {
bcb1977b 1181 push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
9fe2bb77 1182 # aes-ctr.fake is not a real file, only indication that assembler
874a3757 1183 # module implements AES_ctr32_encrypt...
bcb1977b 1184 push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
9fe2bb77 1185 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
bcb1977b 1186 push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
9fe2bb77 1187 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
bcb1977b
RL		 1188 push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1189 push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
9e0724a1 1190 }
9fe2bb77 1191 if ($target{wp_asm_src} =~ /mmx/) {
46d4d865 1192 if ($config{processor} eq "386") {
d2b2221a 1193 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
46d4d865 1194 } elsif (!$disabled{"whirlpool"}) {
2952b9b8 1195 push @{$config{defines}}, "WHIRLPOOL_ASM";
46d4d865 1196 }
9e0724a1 1197 }
9fe2bb77 1198 if ($target{modes_asm_src} =~ /ghash-/) {
bcb1977b 1199 push @{$config{defines}}, "GHASH_ASM";
9e0724a1 1200 }
9fe2bb77 1201 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
bcb1977b 1202 push @{$config{defines}}, "ECP_NISTZ256_ASM";
9e0724a1 1203 }
7b176a54
RL		 1204 if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
1205 push @{$config{defines}}, "PADLOCK_ASM";
1206 }
9fe2bb77 1207 if ($target{poly1305_asm_src} ne "") {
bcb1977b 1208 push @{$config{defines}}, "POLY1305_ASM";
9e0724a1
RL		 1209 }
1210}
d02b48c6 1211
8ed40b83 1212my $ecc = $target{cc};
09aa263a 1213if ($^O ne "VMS" && !$disabled{makedepend}) {
a583fc45
RL		 1214 # Is the compiler gcc or clang? $ecc is used below to see if
1215 # error-checking can be turned on.
1216 my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
d0db7ee0
AP		 1217 open(PIPE, "$ccpcc --version 2>&1 |");
1218 my $lines = 2;
a583fc45 1219 while ( <PIPE> ) {
30752dd7
RL		 1220 # Find the version number and save the major.
1221 m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
39affe19 1222 my $compiler_major = $1;
30752dd7
RL		 1223 # We know that GNU C version 3 and up as well as all clang
1224 # versions support dependency generation
39affe19 1225 $config{makedepprog} = $ccpcc
35c11bfc 1226 if (/clang/ || (/gcc/ && $compiler_major >= 3));
a583fc45
RL		 1227 $ecc = "clang" if /clang/;
1228 $ecc = "gcc" if /gcc/;
d0db7ee0 1229 last if ($config{makedepprog} || !$lines--);
a583fc45
RL		 1230 }
1231 close(PIPE);
09aa263a 1232
656bbdc6 1233 $config{makedepprog} = which('makedepend') unless $config{makedepprog};
09aa263a 1234 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
f1f07a23 1235}
8ed40b83 1236
7d130f68 1237
09aa263a 1238
7d130f68
RL		 1239# Deal with bn_ops ###################################################
1240
7d130f68 1241$config{bn_ll} =0;
7d130f68
RL		 1242$config{export_var_as_fn} =0;
1243my $def_int="unsigned int";
1244$config{rc4_int} =$def_int;
b4f35e5e 1245($config{b64l},$config{b64},$config{b32})=(0,0,1);
7d130f68 1246
94af0cd7 1247my $count = 0;
7d130f68 1248foreach (sort split(/\s+/,$target{bn_ops})) {
94af0cd7
RS		 1249 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1250 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1251 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1252 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1253 ($config{b64l},$config{b64},$config{b32})
1254 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1255 ($config{b64l},$config{b64},$config{b32})
1256 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1257 ($config{b64l},$config{b64},$config{b32})
1258 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
7d130f68 1259}
94af0cd7
RS		 1260die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1261 if $count > 1;
7d130f68
RL		 1262
1263
1264# Hack cflags for better warnings (dev option) #######################
1265
1ed0c662
RL		 1266# "Stringify" the C flags string. This permits it to be made part of a string
1267# and works as well on command lines.
01d99976 1268$config{cflags} =~ s/([\\\"])/\\$1/g;
b436a982 1269
107b5792
RL		 1270if (defined($config{api})) {
1271 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
bcb1977b 1272 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
bcb1977b 1273 push @{$config{defines}}, $apiflag;
98186eb4
VD		 1274}
1275
0c28f277
DSH		 1276if ($strict_warnings)
1277 {
1278 my $wopt;
f1f07a23
RS		 1279 die "ERROR --strict-warnings requires gcc or clang"
1280 unless $ecc eq 'gcc' || $ecc eq 'clang';
0c28f277
DSH		 1281 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1282 {
d918f9cb 1283 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
0c28f277 1284 }
190c8c60
BL		 1285 if ($ecc eq "clang")
1286 {
1287 foreach $wopt (split /\s+/, $clang_devteam_warn)
1288 {
d918f9cb 1289 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
190c8c60
BL		 1290 }
1291 }
ef8ca6bd
RL		 1292 }
1293
1294unless ($disabled{"crypto-mdebug-backtrace"})
1295 {
1296 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
a1d3f3d1 1297 {
d918f9cb 1298 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
ef8ca6bd
RL		 1299 }
1300 if ($target =~ /^BSD-/)
1301 {
1302 $config{ex_libs} .= " -lexecinfo";
291e94df 1303 }
0c28f277
DSH		 1304 }
1305
7cb58c0f 1306if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; $config{cxxflags}="$config{cxxflags}$user_cflags";}
63994098
RL		 1307else { $no_user_cflags=1; }
1308if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1309else { $no_user_defines=1; }
1310
1311# ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1312
c91a0a83
EK		 1313unless ($disabled{afalgeng}) {
1314 $config{afalgeng}="";
79fff39d
RL		 1315 if ($target =~ m/^linux/) {
1316 my $minver = 4*10000 + 1*100 + 0;
1317 if ($config{cross_compile_prefix} eq "") {
1318 my $verstr = `uname -r`;
1319 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1320 ($mi2) = $mi2 =~ /(\d+)/;
1321 my $ver = $ma*10000 + $mi1*100 + $mi2;
1322 if ($ver < $minver) {
c91a0a83 1323 $disabled{afalgeng} = "too-old-kernel";
79fff39d
RL		 1324 } else {
1325 push @{$config{engdirs}}, "afalg";
1326 }
68dc37c1
MC		 1327 } else {
1328 $disabled{afalgeng} = "cross-compiling";
6cba4a66 1329 }
79fff39d 1330 } else {
c91a0a83 1331 $disabled{afalgeng} = "not-linux";
7f458a48 1332 }
1333}
8da00a38 1334
c91a0a83 1335push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
7f458a48 1336
9fe2bb77
RL		 1337# If we use the unified build, collect information from build.info files
1338my %unified_info = ();
1339
2b6b606c 1340my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
ddf1847d 1341if ($builder eq "unified") {
9fe2bb77
RL		 1342 use lib catdir(dirname(__FILE__),"util");
1343 use with_fallback qw(Text::Template);
1344
9fe2bb77 1345 sub cleandir {
2e963849 1346 my $base = shift;
9fe2bb77 1347 my $dir = shift;
2e963849
RL		 1348 my $relativeto = shift || ".";
1349
1350 $dir = catdir($base,$dir) unless isabsolute($dir);
9fe2bb77 1351
ec182ef0
RL		 1352 # Make sure the directories we're building in exists
1353 mkpath($dir);
1354
2e963849 1355 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
9fe2bb77
RL		 1356 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1357 return $res;
1358 }
1359
1360 sub cleanfile {
2e963849 1361 my $base = shift;
9fe2bb77 1362 my $file = shift;
2e963849
RL		 1363 my $relativeto = shift || ".";
1364
1365 $file = catfile($base,$file) unless isabsolute($file);
1366
9fe2bb77
RL		 1367 my $d = dirname($file);
1368 my $f = basename($file);
1369
ec182ef0
RL		 1370 # Make sure the directories we're building in exists
1371 mkpath($d);
1372
2e963849 1373 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
9fe2bb77
RL		 1374 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1375 return $res;
1376 }
1377
1967a42e
RL		 1378 # Store the name of the template file we will build the build file from
1379 # in %config. This may be useful for the build file itself.
1380 my @build_file_template_names =
1381 ( $builder_platform."-".$target{build_file}.".tmpl",
1382 $target{build_file}.".tmpl" );
1383 my @build_file_templates = ();
1384
1385 # First, look in the user provided directory, if given
1386 if (defined $ENV{$local_config_envname}) {
1387 @build_file_templates =
1388 map {
1389 if ($^O eq 'VMS') {
1390 # VMS environment variables are logical names,
1391 # which can be used as is
1392 $local_config_envname . ':' . $_;
1393 } else {
1394 catfile($ENV{$local_config_envname}, $_);
1395 }
1396 }
1397 @build_file_template_names;
1398 }
1399 # Then, look in our standard directory
1400 push @build_file_templates,
1401 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1402 @build_file_template_names );
1403
1404 my $build_file_template;
1405 for $_ (@build_file_templates) {
1406 $build_file_template = $_;
1407 last if -f $build_file_template;
1408
1409 $build_file_template = undef;
1410 }
1411 if (!defined $build_file_template) {
1412 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1413 }
1414 $config{build_file_templates}
1415 = [ $build_file_template,
1416 cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1417 $blddir) ];
1418
9fe2bb77
RL		 1419 my @build_infos = ( [ ".", "build.info" ] );
1420 foreach (@{$config{dirs}}) {
1421 push @build_infos, [ $_, "build.info" ]
1422 if (-f catfile($srcdir, $_, "build.info"));
1423 }
1424 foreach (@{$config{sdirs}}) {
1425 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1426 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1427 }
1428 foreach (@{$config{engdirs}}) {
1429 push @build_infos, [ catdir("engines", $_), "build.info" ]
1430 if (-f catfile($srcdir, "engines", $_, "build.info"));
1431 }
cfa76979
RL		 1432 foreach (@{$config{tdirs}}) {
1433 push @build_infos, [ catdir("test", $_), "build.info" ]
1434 if (-f catfile($srcdir, "test", $_, "build.info"));
1435 }
9fe2bb77 1436
2e0956ba
RL		 1437 $config{build_infos} = [ ];
1438
9fe2bb77
RL		 1439 foreach (@build_infos) {
1440 my $sourced = catdir($srcdir, $_->[0]);
1441 my $buildd = catdir($blddir, $_->[0]);
1442
dca99383 1443 mkpath($buildd);
9fe2bb77
RL		 1444
1445 my $f = $_->[1];
1446 # The basic things we're trying to build
1447 my @programs = ();
7f5af797 1448 my @programs_install = ();
9fe2bb77 1449 my @libraries = ();
7f5af797 1450 my @libraries_install = ();
9fe2bb77 1451 my @engines = ();
7f5af797 1452 my @engines_install = ();
9fe2bb77 1453 my @scripts = ();
7f5af797 1454 my @scripts_install = ();
9fe2bb77 1455 my @extra = ();
8a67946e 1456 my @overrides = ();
9fe2bb77
RL		 1457 my @intermediates = ();
1458 my @rawlines = ();
1459
1460 my %ordinals = ();
1461 my %sources = ();
2a08d1a0 1462 my %shared_sources = ();
9fe2bb77
RL		 1463 my %includes = ();
1464 my %depends = ();
1465 my %renames = ();
1466 my %sharednames = ();
ae4c7450 1467 my %generate = ();
9fe2bb77 1468
2e0956ba 1469 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
9fe2bb77
RL		 1470 my $template = Text::Template->new(TYPE => 'FILE',
1471 SOURCE => catfile($sourced, $f));
1472 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1473 my @text =
1474 split /^/m,
1475 $template->fill_in(HASH => { config => \%config,
1476 target => \%target,
9e04edf2 1477 disabled => \%disabled,
f59d0131 1478 withargs => \%withargs,
9fe2bb77
RL		 1479 builddir => abs2rel($buildd, $blddir),
1480 sourcedir => abs2rel($sourced, $blddir),
1481 buildtop => abs2rel($blddir, $blddir),
1482 sourcetop => abs2rel($srcdir, $blddir) },
1483 DELIMITERS => [ "{-", "-}" ]);
1484
1485 # The top item of this stack has the following values
1486 # -2 positive already run and we found ELSE (following ELSIF should fail)
1487 # -1 positive already run (skip until ENDIF)
1488 # 0 negatives so far (if we're at a condition, check it)
1489 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1490 # 2 positive ELSE (following ELSIF should fail)
1491 my @skip = ();
1492 collect_information(
1493 collect_from_array([ @text ],
1494 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1495 $l1 =~ s/\\$//; $l1.$l2 }),
1496 # Info we're looking for
1497 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
635bd409 1498 => sub {
c5798e0e 1499 if (! @skip || $skip[$#skip] > 0) {
635bd409
RL		 1500 push @skip, !! $1;
1501 } else {
1502 push @skip, -1;
1503 }
1504 },
9fe2bb77
RL		 1505 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1506 => sub { die "ELSIF out of scope" if ! @skip;
1507 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1508 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1509 $skip[$#skip] = !! $1
1510 if $skip[$#skip] == 0; },
1511 qr/^\s*ELSE\s*$/
1512 => sub { die "ELSE out of scope" if ! @skip;
1513 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1514 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1515 qr/^\s*ENDIF\s*$/
1516 => sub { die "ENDIF out of scope" if ! @skip;
1517 pop @skip; },
7f5af797
RL		 1518 qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1519 => sub {
1520 if (!@skip || $skip[$#skip] > 0) {
1521 my $install = $1;
1522 my @x = tokenize($2);
1523 push @programs, @x;
1524 push @programs_install, @x unless $install;
1525 }
1526 },
1527 qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1528 => sub {
1529 if (!@skip || $skip[$#skip] > 0) {
1530 my $install = $1;
1531 my @x = tokenize($2);
1532 push @libraries, @x;
1533 push @libraries_install, @x unless $install;
1534 }
1535 },
1536 qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1537 => sub {
1538 if (!@skip || $skip[$#skip] > 0) {
1539 my $install = $1;
1540 my @x = tokenize($2);
1541 push @engines, @x;
1542 push @engines_install, @x unless $install;
1543 }
1544 },
1545 qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1546 => sub {
1547 if (!@skip || $skip[$#skip] > 0) {
1548 my $install = $1;
1549 my @x = tokenize($2);
1550 push @scripts, @x;
1551 push @scripts_install, @x unless $install;
1552 }
1553 },
9fe2bb77 1554 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
ce959812 1555 => sub { push @extra, tokenize($1)
9fe2bb77 1556 if !@skip || $skip[$#skip] > 0 },
8a67946e 1557 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
ce959812 1558 => sub { push @overrides, tokenize($1)
8a67946e 1559 if !@skip || $skip[$#skip] > 0 },
9fe2bb77
RL		 1560
1561 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
ce959812 1562 => sub { push @{$ordinals{$1}}, tokenize($2)
9fe2bb77
RL		 1563 if !@skip || $skip[$#skip] > 0 },
1564 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1565 => sub { push @{$sources{$1}}, tokenize($2)
9fe2bb77 1566 if !@skip || $skip[$#skip] > 0 },
2a08d1a0 1567 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1568 => sub { push @{$shared_sources{$1}}, tokenize($2)
2a08d1a0 1569 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1570 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1571 => sub { push @{$includes{$1}}, tokenize($2)
9fe2bb77 1572 if !@skip || $skip[$#skip] > 0 },
4f858293 1573 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
ce959812 1574 => sub { push @{$depends{$1}}, tokenize($2)
9fe2bb77 1575 if !@skip || $skip[$#skip] > 0 },
ae4c7450
RL		 1576 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1577 => sub { push @{$generate{$1}}, $2
1578 if !@skip || $skip[$#skip] > 0 },
9fe2bb77 1579 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1580 => sub { push @{$renames{$1}}, tokenize($2)
9fe2bb77
RL		 1581 if !@skip || $skip[$#skip] > 0 },
1582 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
ce959812 1583 => sub { push @{$sharednames{$1}}, tokenize($2)
9fe2bb77
RL		 1584 if !@skip || $skip[$#skip] > 0 },
1585 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1586 => sub {
1587 my $lineiterator = shift;
1588 my $target_kind = $1;
1589 while (defined $lineiterator->()) {
04f171c0 1590 s|\R$||;
9fe2bb77
RL		 1591 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1592 die "ENDRAW doesn't match BEGINRAW"
1593 if $1 ne $target_kind;
1594 last;
1595 }
1596 next if @skip && $skip[$#skip] <= 0;
1597 push @rawlines, $_
1598 if ($target_kind eq $target{build_file}
ddf1847d 1599 || $target_kind eq $target{build_file}."(".$builder_platform.")");
9fe2bb77
RL		 1600 }
1601 },
ab6e147c 1602 qr/^\s*(?:#.*)?$/ => sub { },
2b6b606c
RL		 1603 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1604 "BEFORE" => sub {
1605 if ($buildinfo_debug) {
1606 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1607 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1608 }
1609 },
1610 "AFTER" => sub {
1611 if ($buildinfo_debug) {
1612 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1613 }
1614 },
9fe2bb77
RL		 1615 );
1616 die "runaway IF?" if (@skip);
1617
1618 foreach (keys %renames) {
1619 die "$_ renamed to more than one thing: "
1620 ,join(" ", @{$renames{$_}}),"\n"
1621 if scalar @{$renames{$_}} > 1;
2e963849
RL		 1622 my $dest = cleanfile($buildd, $_, $blddir);
1623 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
9fe2bb77
RL		 1624 die "$dest renamed to more than one thing: "
1625 ,$unified_info{rename}->{$dest}, $to
1626 unless !defined($unified_info{rename}->{$dest})
1627 or $unified_info{rename}->{$dest} eq $to;
1628 $unified_info{rename}->{$dest} = $to;
1629 }
1630
1631 foreach (@programs) {
2e963849 1632 my $program = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1633 if ($unified_info{rename}->{$program}) {
1634 $program = $unified_info{rename}->{$program};
1635 }
1636 $unified_info{programs}->{$program} = 1;
1637 }
1638
7f5af797
RL		 1639 foreach (@programs_install) {
1640 my $program = cleanfile($buildd, $_, $blddir);
1641 if ($unified_info{rename}->{$program}) {
1642 $program = $unified_info{rename}->{$program};
1643 }
1644 $unified_info{install}->{programs}->{$program} = 1;
1645 }
1646
9fe2bb77 1647 foreach (@libraries) {
2e963849 1648 my $library = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1649 if ($unified_info{rename}->{$library}) {
1650 $library = $unified_info{rename}->{$library};
1651 }
1652 $unified_info{libraries}->{$library} = 1;
1653 }
1654
7f5af797
RL		 1655 foreach (@libraries_install) {
1656 my $library = cleanfile($buildd, $_, $blddir);
1657 if ($unified_info{rename}->{$library}) {
1658 $library = $unified_info{rename}->{$library};
1659 }
1660 $unified_info{install}->{libraries}->{$library} = 1;
1661 }
1662
343ec2b0 1663 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
19ab5790 1664ENGINES can only be used if configured with 'dynamic-engine'.
9fe2bb77
RL		 1665This is usually a fault in a build.info file.
1666EOF
1667 foreach (@engines) {
2e963849 1668 my $library = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1669 if ($unified_info{rename}->{$library}) {
1670 $library = $unified_info{rename}->{$library};
1671 }
1672 $unified_info{engines}->{$library} = 1;
1673 }
1674
7f5af797
RL		 1675 foreach (@engines_install) {
1676 my $library = cleanfile($buildd, $_, $blddir);
1677 if ($unified_info{rename}->{$library}) {
1678 $library = $unified_info{rename}->{$library};
1679 }
1680 $unified_info{install}->{engines}->{$library} = 1;
1681 }
1682
9fe2bb77 1683 foreach (@scripts) {
2e963849 1684 my $script = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1685 if ($unified_info{rename}->{$script}) {
1686 $script = $unified_info{rename}->{$script};
1687 }
1688 $unified_info{scripts}->{$script} = 1;
1689 }
1690
7f5af797
RL		 1691 foreach (@scripts_install) {
1692 my $script = cleanfile($buildd, $_, $blddir);
1693 if ($unified_info{rename}->{$script}) {
1694 $script = $unified_info{rename}->{$script};
1695 }
1696 $unified_info{install}->{scripts}->{$script} = 1;
1697 }
1698
9fe2bb77 1699 foreach (@extra) {
2e963849 1700 my $extra = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1701 $unified_info{extra}->{$extra} = 1;
1702 }
1703
8a67946e
RL		 1704 foreach (@overrides) {
1705 my $override = cleanfile($buildd, $_, $blddir);
1706 $unified_info{overrides}->{$override} = 1;
1707 }
1708
9fe2bb77
RL		 1709 push @{$unified_info{rawlines}}, @rawlines;
1710
84af1bae 1711 unless ($disabled{shared}) {
9fe2bb77
RL		 1712 # Check sharednames.
1713 foreach (keys %sharednames) {
2e963849 1714 my $dest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1715 if ($unified_info{rename}->{$dest}) {
1716 $dest = $unified_info{rename}->{$dest};
1717 }
1718 die "shared_name for $dest with multiple values: "
1719 ,join(" ", @{$sharednames{$_}}),"\n"
1720 if scalar @{$sharednames{$_}} > 1;
2e963849 1721 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
9fe2bb77
RL		 1722 die "shared_name found for a library $dest that isn't defined\n"
1723 unless $unified_info{libraries}->{$dest};
1724 die "shared_name for $dest with multiple values: "
1725 ,$unified_info{sharednames}->{$dest}, ", ", $to
1726 unless !defined($unified_info{sharednames}->{$dest})
1727 or $unified_info{sharednames}->{$dest} eq $to;
1728 $unified_info{sharednames}->{$dest} = $to;
1729 }
1730
1731 # Additionally, we set up sharednames for libraries that don't
33105818
RL		 1732 # have any, as themselves. Only for libraries that aren't
1733 # explicitely static.
1734 foreach (grep !/\.a$/, keys %{$unified_info{libraries}}) {
9fe2bb77
RL		 1735 if (!defined $unified_info{sharednames}->{$_}) {
1736 $unified_info{sharednames}->{$_} = $_
1737 }
1738 }
33105818
RL		 1739
1740 # Check that we haven't defined any library as both shared and
1741 # explicitely static. That is forbidden.
1742 my @doubles = ();
1743 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
1744 (my $l = $_) =~ s/\.a$//;
1745 push @doubles, $l if defined $unified_info{sharednames}->{$l};
1746 }
1747 die "these libraries are both explicitely static and shared:\n ",
1748 join(" ", @doubles), "\n"
1749 if @doubles;
9fe2bb77
RL		 1750 }
1751
1752 foreach (keys %ordinals) {
1753 my $dest = $_;
2e963849 1754 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1755 if ($unified_info{rename}->{$ddest}) {
1756 $ddest = $unified_info{rename}->{$ddest};
1757 }
1758 foreach (@{$ordinals{$dest}}) {
1759 my %known_ordinals =
1760 (
1761 crypto =>
6928b617 1762 cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
9fe2bb77 1763 ssl =>
6928b617 1764 cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
9fe2bb77
RL		 1765 );
1766 my $o = $known_ordinals{$_};
1767 die "Ordinals for $ddest defined more than once\n"
1768 if $unified_info{ordinals}->{$ddest};
1769 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1770 }
1771 }
1772
1773 foreach (keys %sources) {
1774 my $dest = $_;
2e963849 1775 my $ddest = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1776 if ($unified_info{rename}->{$ddest}) {
1777 $ddest = $unified_info{rename}->{$ddest};
1778 }
1779 foreach (@{$sources{$dest}}) {
2e963849 1780 my $s = cleanfile($sourced, $_, $blddir);
9fe2bb77
RL		 1781
1782 # If it isn't in the source tree, we assume it's generated
1783 # in the build tree
1784 if (! -f $s) {
2e963849 1785 $s = cleanfile($buildd, $_, $blddir);
9fe2bb77 1786 }
ea241958
RL		 1787 # We recognise C++, C and asm files
1788 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
1789 my $o = $_;
1790 $o =~ s/\.[csS]$/.o/; # C and assembler
1791 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2e963849 1792 $o = cleanfile($buildd, $o, $blddir);
9fe2bb77
RL		 1793 $unified_info{sources}->{$ddest}->{$o} = 1;
1794 $unified_info{sources}->{$o}->{$s} = 1;
1795 } else {
1796 $unified_info{sources}->{$ddest}->{$s} = 1;
1797 }
1798 }
1799 }
1800
2a08d1a0
RL		 1801 foreach (keys %shared_sources) {
1802 my $dest = $_;
1803 my $ddest = cleanfile($buildd, $_, $blddir);
1804 if ($unified_info{rename}->{$ddest}) {
1805 $ddest = $unified_info{rename}->{$ddest};
1806 }
1807 foreach (@{$shared_sources{$dest}}) {
1808 my $s = cleanfile($sourced, $_, $blddir);
1809
1810 # If it isn't in the source tree, we assume it's generated
1811 # in the build tree
1812 if (! -f $s) {
1813 $s = cleanfile($buildd, $_, $blddir);
1814 }
ea241958
RL		 1815 # We recognise C++, C and asm files
1816 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
1817 my $o = $_;
1818 $o =~ s/\.[csS]$/.o/; # C and assembler
1819 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2a08d1a0
RL		 1820 $o = cleanfile($buildd, $o, $blddir);
1821 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1822 $unified_info{sources}->{$o}->{$s} = 1;
1823 } else {
1824 die "unrecognised source file type for shared library: $s\n";
1825 }
1826 }
1827 }
1828
ae4c7450
RL		 1829 foreach (keys %generate) {
1830 my $dest = $_;
1831 my $ddest = cleanfile($buildd, $_, $blddir);
1832 if ($unified_info{rename}->{$ddest}) {
1833 $ddest = $unified_info{rename}->{$ddest};
1834 }
1835 die "more than one generator for $dest: "
1836 ,join(" ", @{$generate{$_}}),"\n"
1837 if scalar @{$generate{$_}} > 1;
1838 my @generator = split /\s+/, $generate{$dest}->[0];
1839 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1840 $unified_info{generate}->{$ddest} = [ @generator ];
1841 }
1842
9fe2bb77
RL		 1843 foreach (keys %depends) {
1844 my $dest = $_;
4f858293 1845 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
8d34daf0
RL		 1846
1847 # If the destination doesn't exist in source, it can only be
1848 # a generated file in the build tree.
4f858293 1849 if ($ddest ne "" && ! -f $ddest) {
8d34daf0
RL		 1850 $ddest = cleanfile($buildd, $_, $blddir);
1851 if ($unified_info{rename}->{$ddest}) {
1852 $ddest = $unified_info{rename}->{$ddest};
1853 }
9fe2bb77
RL		 1854 }
1855 foreach (@{$depends{$dest}}) {
2e963849 1856 my $d = cleanfile($sourced, $_, $blddir);
9fe2bb77 1857
e737d7b1
RL		 1858 # If we know it's generated, or assume it is because we can't
1859 # find it in the source tree, we set file we depend on to be
1860 # in the build tree rather than the source tree, and assume
1861 # and that there are lines to build it in a BEGINRAW..ENDRAW
1862 # section or in the Makefile template.
1863 if (! -f $d
da1f2104
RL		 1864 || (grep { $d eq $_ }
1865 map { cleanfile($srcdir, $_, $blddir) }
4f858293 1866 grep { /\.h$/ } keys %{$unified_info{generate}})) {
2e963849 1867 $d = cleanfile($buildd, $_, $blddir);
9fe2bb77
RL		 1868 }
1869 # Take note if the file to depend on is being renamed
186a31e5
RL		 1870 # Take extra care with files ending with .a, they should
1871 # be treated without that extension, and the extension
1872 # should be added back after treatment.
1873 $d =~ /(\.a)?$/;
1874 my $e = $1 // "";
1875 $d = $`;
9fe2bb77
RL		 1876 if ($unified_info{rename}->{$d}) {
1877 $d = $unified_info{rename}->{$d};
1878 }
186a31e5 1879 $d .= $e;
9fe2bb77 1880 $unified_info{depends}->{$ddest}->{$d} = 1;
8d34daf0
RL		 1881 # If we depend on a header file or a perl module, let's make
1882 # sure it can get included
4f858293 1883 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
9fe2bb77 1884 my $i = dirname($d);
4748f890
RL		 1885 push @{$unified_info{includes}->{$ddest}->{source}}, $i
1886 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}->{source}};
9fe2bb77
RL		 1887 }
1888 }
1889 }
1890
1891 foreach (keys %includes) {
1892 my $dest = $_;
8d34daf0
RL		 1893 my $ddest = cleanfile($sourced, $_, $blddir);
1894
1895 # If the destination doesn't exist in source, it can only be
1896 # a generated file in the build tree.
1897 if (! -f $ddest) {
1898 $ddest = cleanfile($buildd, $_, $blddir);
1899 if ($unified_info{rename}->{$ddest}) {
1900 $ddest = $unified_info{rename}->{$ddest};
1901 }
9fe2bb77
RL		 1902 }
1903 foreach (@{$includes{$dest}}) {
4748f890
RL		 1904 my $is = cleandir($sourced, $_, $blddir);
1905 my $ib = cleandir($buildd, $_, $blddir);
1906 push @{$unified_info{includes}->{$ddest}->{source}}, $is
1907 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
1908 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
1909 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
9fe2bb77
RL		 1910 }
1911 }
1912 }
1913
1914 ### Make unified_info a bit more efficient
1915 # One level structures
8a67946e 1916 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
9fe2bb77
RL		 1917 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1918 }
1919 # Two level structures
7f5af797 1920 foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
9fe2bb77
RL		 1921 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1922 $unified_info{$l1}->{$l2} =
1923 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1924 }
1925 }
4748f890
RL		 1926 # Includes
1927 foreach my $dest (sort keys %{$unified_info{includes}}) {
1928 if (defined($unified_info{includes}->{$dest}->{build})) {
1929 my @source_includes =
1930 ( @{$unified_info{includes}->{$dest}->{source}} );
1931 $unified_info{includes}->{$dest} =
1932 [ @{$unified_info{includes}->{$dest}->{build}} ];
1933 foreach my $inc (@source_includes) {
1934 push @{$unified_info{includes}->{$dest}}, $inc
1935 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
1936 }
1937 } else {
1938 $unified_info{includes}->{$dest} =
1939 [ @{$unified_info{includes}->{$dest}->{source}} ];
1940 }
1941 }
9fe2bb77
RL		 1942}
1943
1944# For the schemes that need it, we provide the old *_obj configs
1945# from the *_asm_obj ones
3a55c92b 1946foreach (grep /_(asm|aux)_src$/, keys %target) {
9fe2bb77 1947 my $src = $_;
3a55c92b 1948 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
ea241958
RL		 1949 $target{$obj} = $target{$src};
1950 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
1951 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
9fe2bb77
RL		 1952}
1953
291e94df
RL		 1954# Write down our configuration where it fits #########################
1955
1956open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1957print OUT <<"EOF";
1958package configdata;
1959
1960use strict;
1961use warnings;
1962
1963use Exporter;
1964#use vars qw(\@ISA \@EXPORT);
1965our \@ISA = qw(Exporter);
3850f8cb 1966our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
291e94df
RL		 1967
1968EOF
1969print OUT "our %config = (\n";
1970foreach (sort keys %config) {
1971 if (ref($config{$_}) eq "ARRAY") {
1972 print OUT " ", $_, " => [ ", join(", ",
1973 map { quotify("perl", $_) }
1974 @{$config{$_}}), " ],\n";
1975 } else {
1976 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1977 }
1978}
1979print OUT <<"EOF";
1980);
1981
1982EOF
1983print OUT "our %target = (\n";
1984foreach (sort keys %target) {
1985 if (ref($target{$_}) eq "ARRAY") {
1986 print OUT " ", $_, " => [ ", join(", ",
1987 map { quotify("perl", $_) }
1988 @{$target{$_}}), " ],\n";
1989 } else {
1990 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1991 }
1992}
1993print OUT <<"EOF";
1994);
1995
96d2d7bc
RL		 1996EOF
1997print OUT "our \%available_protocols = (\n";
1998print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1999print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2000print OUT <<"EOF";
2001);
2002
3850f8cb
RL		 2003EOF
2004print OUT "our \@disablables = (\n";
2005foreach (@disablables) {
2006 print OUT " ", quotify("perl", $_), ",\n";
2007}
2008print OUT <<"EOF";
2009);
2010
96d2d7bc
RL		 2011EOF
2012print OUT "our \%disabled = (\n";
2013foreach (sort keys %disabled) {
2014 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2015}
2016print OUT <<"EOF";
2017);
2018
291e94df 2019EOF
107b5792
RL		 2020print OUT "our %withargs = (\n";
2021foreach (sort keys %withargs) {
2022 if (ref($withargs{$_}) eq "ARRAY") {
2023 print OUT " ", $_, " => [ ", join(", ",
2024 map { quotify("perl", $_) }
2025 @{$withargs{$_}}), " ],\n";
2026 } else {
2027 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
2028 }
2029}
2030print OUT <<"EOF";
2031);
edd4d402 2032
107b5792 2033EOF
ddf1847d 2034if ($builder eq "unified") {
9fe2bb77
RL		 2035 my $recurse;
2036 $recurse = sub {
2037 my $indent = shift;
2038 foreach (@_) {
2039 if (ref $_ eq "ARRAY") {
2040 print OUT " "x$indent, "[\n";
2041 foreach (@$_) {
2042 $recurse->($indent + 4, $_);
2043 }
2044 print OUT " "x$indent, "],\n";
2045 } elsif (ref $_ eq "HASH") {
2046 my %h = %$_;
2047 print OUT " "x$indent, "{\n";
2048 foreach (sort keys %h) {
2049 if (ref $h{$_} eq "") {
2050 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2051 } else {
2052 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2053 $recurse->($indent + 8, $h{$_});
2054 }
2055 }
2056 print OUT " "x$indent, "},\n";
2057 } else {
2058 print OUT " "x$indent, quotify("perl", $_), ",\n";
2059 }
2060 }
2061 };
2062 print OUT "our %unified_info = (\n";
2063 foreach (sort keys %unified_info) {
2064 if (ref $unified_info{$_} eq "") {
2065 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2066 } else {
2067 print OUT " "x4, quotify("perl", $_), " =>\n";
2068 $recurse->(8, $unified_info{$_});
2069 }
2070 }
2071 print OUT <<"EOF";
2072);
2073
2074EOF
2075}
2076print OUT "1;\n";
d02b48c6 2077close(OUT);
f2d4be3b 2078
141d7325
RS		 2079print "\n";
2080print "PROCESSOR =$config{processor}\n" if $config{processor};
2081print "PERL =$config{perl}\n";
758baa3d 2082print "PERLVERSION =$Config{version} for $Config{archname}\n";
141d7325 2083print "HASHBANGPERL =$config{hashbangperl}\n";
f58a0acb 2084print "CC =$config{cross_compile_prefix}$target{cc}\n";
2952b9b8 2085print "CFLAG =$target{cflags} $config{cflags}\n";
ea241958
RL		 2086print "CXX =$config{cross_compile_prefix}$target{cxx}\n"
2087 if defined $target{cxx};
2088print "CXXFLAG =$target{cxxflags} $config{cxxflags}\n"
2089 if defined $target{cxx};
2952b9b8 2090print "DEFINES =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
141d7325
RS		 2091#print "RANLIB =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
2092# "$config{cross_compile_prefix}ranlib" :
2093# "$target{ranlib}", "\n";
2952b9b8 2094print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
cba5068d 2095
88087414 2096my %builders = (
9fe2bb77 2097 unified => sub {
ddf1847d 2098 run_dofile(catfile($blddir, $target{build_file}),
1967a42e 2099 @{$config{build_file_templates}});
9fe2bb77 2100 },
88087414
RL		 2101 );
2102
ddf1847d 2103$builders{$builder}->($builder_platform, @builder_opts);
fce0ba5f 2104
9c62a279 2105print <<"EOF" if ($disabled{threads} eq "unavailable");
5f8d5c96
BM		 2106
2107The library could not be configured for supporting multi-threaded
2108applications as the compiler options required on this system are not known.
ff1b7e09 2109See file INSTALL for details if you need multi-threading.
ec577822
BM		 2110EOF
2111
76ffb43d 2112print <<"EOF" if ($no_shared_warn);
2964ba8c 2113
ae48242c
RL		 2114The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2115platform, so we will pretend you gave the option 'no-pic', which also disables
2116'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2117or position independent code, please let us know (but please first make sure
2118you have tried with a current version of OpenSSL).
2e31ef03
RS		 2119EOF
2120
ddc606c9
RL		 2121print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
2122
2123WARNING: there are indications that another build was made in the source
2124directory. This build may have picked up artifacts from that build, the
2125safest course of action is to clean the source directory and redo this
2126configuration.
2127EOF
2128
d02b48c6
RE		 2129exit(0);
2130
bd5192b1
RL		 2131######################################################################
2132#
2133# Helpers and utility functions
2134#
2135
2136# Configuration file reading #########################################
2137
1f2e1cd5
RL		 2138# Note: All of the helper functions are for lazy evaluation. They all
2139# return a CODE ref, which will return the intended value when evaluated.
2140# Thus, whenever there's mention of a returned value, it's about that
2141# intended value.
2142
bd5192b1 2143# Helper function to implement conditional inheritance depending on the
00b0d663 2144# value of $disabled{asm}. Used in inherit_from values as follows:
bd5192b1
RL		 2145#
2146# inherit_from => [ "template", asm("asm_tmpl") ]
2147#
2148sub asm {
2149 my @x = @_;
2150 sub {
00b0d663 2151 $disabled{asm} ? () : @x;
bd5192b1
RL		 2152 }
2153}
2154
1f2e1cd5
RL		 2155# Helper function to implement conditional value variants, with a default
2156# plus additional values based on the value of $config{build_type}.
2157# Arguments are given in hash table form:
2158#
2159# picker(default => "Basic string: ",
2160# debug => "debug",
2161# release => "release")
2162#
2163# When configuring with --debug, the resulting string will be
2164# "Basic string: debug", and when not, it will be "Basic string: release"
2165#
2166# This can be used to create variants of sets of flags according to the
2167# build type:
2168#
2169# cflags => picker(default => "-Wall",
2170# debug => "-g -O0",
2171# release => "-O3")
2172#
2173sub picker {
2174 my %opts = @_;
2175 return sub { add($opts{default} || (),
2176 $opts{$config{build_type}} || ())->(); }
2177}
2178
2179# Helper function to combine several values of different types into one.
2180# This is useful if you want to combine a string with the result of a
2181# lazy function, such as:
2182#
2183# cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2184#
2185sub combine {
2186 my @stuff = @_;
2187 return sub { add(@stuff)->(); }
2188}
2189
2190# Helper function to implement conditional values depending on the value
2191# of $disabled{threads}. Can be used as follows:
2192#
2193# cflags => combine("-Wall", threads("-pthread"))
2194#
2195sub threads {
2196 my @flags = @_;
2197 return sub { add($disabled{threads} ? () : @flags)->(); }
2198}
2199
2200
2201
9c62a279 2202our $add_called = 0;
88087414
RL		 2203# Helper function to implement adding values to already existing configuration
2204# values. It handles elements that are ARRAYs, CODEs and scalars
2205sub _add {
2206 my $separator = shift;
2207
bcb1977b
RL		 2208 # If there's any ARRAY in the collection of values OR the separator
2209 # is undef, we will return an ARRAY of combined values, otherwise a
2210 # string of joined values with $separator as the separator.
2211 my $found_array = !defined($separator);
88087414
RL		 2212
2213 my @values =
2214 map {
b0b92a5b
RL		 2215 my $res = $_;
2216 while (ref($res) eq "CODE") {
2217 $res = $res->();
2218 }
2219 if (defined($res)) {
2220 if (ref($res) eq "ARRAY") {
2221 $found_array = 1;
2222 @$res;
2223 } else {
2224 $res;
2225 }
88087414 2226 } else {
b0b92a5b 2227 ();
88087414
RL		 2228 }
2229 } (@_);
2230
9c62a279
RL		 2231 $add_called = 1;
2232
88087414
RL		 2233 if ($found_array) {
2234 [ @values ];
2235 } else {
b0b92a5b 2236 join($separator, grep { defined($_) && $_ ne "" } @values);
88087414
RL		 2237 }
2238}
2239sub add_before {
bdcd83e1
RL		 2240 my $separator = " ";
2241 if (ref($_[$#_]) eq "HASH") {
2242 my $opts = pop;
2243 $separator = $opts->{separator};
2244 }
88087414
RL		 2245 my @x = @_;
2246 sub { _add($separator, @x, @_) };
2247}
2248sub add {
bdcd83e1
RL		 2249 my $separator = " ";
2250 if (ref($_[$#_]) eq "HASH") {
2251 my $opts = pop;
2252 $separator = $opts->{separator};
2253 }
88087414
RL		 2254 my @x = @_;
2255 sub { _add($separator, @_, @x) };
2256}
2257
bd5192b1
RL		 2258# configuration reader, evaluates the input file as a perl script and expects
2259# it to fill %targets with target configurations. Those are then added to
2260# %table.
2261sub read_config {
2262 my $fname = shift;
2263 open(CONFFILE, "< $fname")
2264 or die "Can't open configuration file '$fname'!\n";
2265 my $x = $/;
2266 undef $/;
2267 my $content = <CONFFILE>;
2268 $/ = $x;
2269 close(CONFFILE);
2270 my %targets = ();
2271 {
ee9b0bbb
RL		 2272 # Protect certain tables from tampering
2273 local %table = %::table;
bd5192b1
RL		 2274
2275 eval $content;
2276 warn $@ if $@;
2277 }
2278
2279 # For each target, check that it's configured with a hash table.
2280 foreach (keys %targets) {
2281 if (ref($targets{$_}) ne "HASH") {
2282 if (ref($targets{$_}) eq "") {
2283 warn "Deprecated target configuration for $_, ignoring...\n";
2284 } else {
2285 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2286 }
2287 delete $targets{$_};
ee9b0bbb
RL		 2288 } else {
2289 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
2290 }
bd5192b1
RL		 2291 }
2292
2293 %table = (%table, %targets);
2294
2295}
2296
8483a003
F		 2297# configuration resolver. Will only resolve all the lazy evaluation
2298# codeblocks for the chosen target and all those it inherits from,
bd5192b1
RL		 2299# recursively
2300sub resolve_config {
2301 my $target = shift;
2302 my @breadcrumbs = @_;
2303
c4718849 2304# my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
9c62a279 2305
bd5192b1
RL		 2306 if (grep { $_ eq $target } @breadcrumbs) {
2307 die "inherit_from loop! target backtrace:\n "
2308 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2309 }
2310
2311 if (!defined($table{$target})) {
2312 warn "Warning! target $target doesn't exist!\n";
2313 return ();
2314 }
2315 # Recurse through all inheritances. They will be resolved on the
2316 # fly, so when this operation is done, they will all just be a
2317 # bunch of attributes with string values.
2318 # What we get here, though, are keys with references to lists of
2319 # the combined values of them all. We will deal with lists after
2320 # this stage is done.
2321 my %combined_inheritance = ();
2322 if ($table{$target}->{inherit_from}) {
2323 my @inherit_from =
2324 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2325 foreach (@inherit_from) {
2326 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2327
2328 # 'template' is a marker that's considered private to
2329 # the config that had it.
2330 delete $inherited_config{template};
2331
2110febb 2332 foreach (keys %inherited_config) {
bd5192b1
RL		 2333 if (!$combined_inheritance{$_}) {
2334 $combined_inheritance{$_} = [];
2335 }
2336 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2110febb 2337 }
bd5192b1
RL		 2338 }
2339 }
2340
2341 # We won't need inherit_from in this target any more, since we've
2342 # resolved all the inheritances that lead to this
2343 delete $table{$target}->{inherit_from};
2344
2345 # Now is the time to deal with those lists. Here's the place to
2346 # decide what shall be done with those lists, all based on the
2347 # values of the target we're currently dealing with.
2348 # - If a value is a coderef, it will be executed with the list of
2349 # inherited values as arguments.
2350 # - If the corresponding key doesn't have a value at all or is the
8483a003 2351 # empty string, the inherited value list will be run through the
bd5192b1
RL		 2352 # default combiner (below), and the result becomes this target's
2353 # value.
2354 # - Otherwise, this target's value is assumed to be a string that
2355 # will simply override the inherited list of values.
a26d8be9 2356 my $default_combiner = add();
bd5192b1
RL		 2357
2358 my %all_keys =
2359 map { $_ => 1 } (keys %combined_inheritance,
2360 keys %{$table{$target}});
b0b92a5b
RL		 2361
2362 sub process_values {
2363 my $object = shift;
2364 my $inherited = shift; # Always a [ list ]
2365 my $target = shift;
2366 my $entry = shift;
2367
9c62a279
RL		 2368 $add_called = 0;
2369
b0b92a5b
RL		 2370 while(ref($object) eq "CODE") {
2371 $object = $object->(@$inherited);
2372 }
2373 if (!defined($object)) {
2374 return ();
2375 }
2376 elsif (ref($object) eq "ARRAY") {
9c62a279 2377 local $add_called; # To make sure recursive calls don't affect it
b0b92a5b
RL		 2378 return [ map { process_values($_, $inherited, $target, $entry) }
2379 @$object ];
2380 } elsif (ref($object) eq "") {
2381 return $object;
2382 } else {
2383 die "cannot handle reference type ",ref($object)
2384 ," found in target ",$target," -> ",$entry,"\n";
2385 }
2386 }
2387
bd5192b1 2388 foreach (sort keys %all_keys) {
9c62a279 2389 my $previous = $combined_inheritance{$_};
bd5192b1
RL		 2390
2391 # Current target doesn't have a value for the current key?
2392 # Assign it the default combiner, the rest of this loop body
2393 # will handle it just like any other coderef.
2394 if (!exists $table{$target}->{$_}) {
2395 $table{$target}->{$_} = $default_combiner;
2396 }
2397
b0b92a5b
RL		 2398 $table{$target}->{$_} = process_values($table{$target}->{$_},
2399 $combined_inheritance{$_},
2400 $target, $_);
2401 unless(defined($table{$target}->{$_})) {
2402 delete $table{$target}->{$_};
2403 }
c4718849
RL		 2404# if ($extra_checks &&
2405# $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2406# warn "$_ got replaced in $target\n";
2407# }
bd5192b1
RL		 2408 }
2409
2410 # Finally done, return the result.
2411 return %{$table{$target}};
2412}
2413
462ba4f6 2414sub usage
d02b48c6 2415 {
462ba4f6 2416 print STDERR $usage;
10a926c1 2417 print STDERR "\npick os/compiler from:\n";
1641cb60 2418 my $j=0;
6457ad15 2419 my $i;
10a926c1 2420 my $k=0;
6457ad15 2421 foreach $i (sort keys %table)
d02b48c6 2422 {
bd5192b1 2423 next if $table{$i}->{template};
462ba4f6 2424 next if $i =~ /^debug/;
10a926c1
UM		 2425 $k += length($i) + 1;
2426 if ($k > 78)
2427 {
2428 print STDERR "\n";
2429 $k=length($i);
2430 }
2431 print STDERR $i . " ";
462ba4f6
UM		 2432 }
2433 foreach $i (sort keys %table)
2434 {
bd5192b1 2435 next if $table{$i}->{template};
462ba4f6 2436 next if $i !~ /^debug/;
10a926c1
UM		 2437 $k += length($i) + 1;
2438 if ($k > 78)
2439 {
2440 print STDERR "\n";
2441 $k=length($i);
2442 }
2443 print STDERR $i . " ";
d02b48c6 2444 }
10a926c1 2445 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
462ba4f6 2446 exit(1);
d02b48c6
RE		 2447 }
2448
01d99976 2449sub run_dofile
107b5792 2450{
107b5792 2451 my $out = shift;
9fe2bb77 2452 my @templates = @_;
107b5792 2453
ced2c2c5
RS		 2454 unlink $out || warn "Can't remove $out, $!"
2455 if -f $out;
9fe2bb77
RL		 2456 foreach (@templates) {
2457 die "Can't open $_, $!" unless -f $_;
2458 }
f879d5ff
RL		 2459 my $perlcmd = (quotify("maybeshell", $config{perl}))[0];
2460 my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
9fe2bb77
RL		 2461 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2462 system($cmd);
107b5792
RL		 2463 exit 1 if $? != 0;
2464 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2465}
2466
656bbdc6
AP		 2467sub which
2468{
2469 my ($name)=@_;
2470
2471 if (eval { require IPC::Cmd; 1; }) {
2472 IPC::Cmd->import();
2473 return scalar IPC::Cmd::can_run($name);
2474 } else {
2475 # if there is $directories component in splitpath,
2476 # then it's not something to test with $PATH...
2477 return $name if (File::Spec->splitpath($name))[1];
2478
2479 foreach (File::Spec->path()) {
2480 my $fullpath = catfile($_, "$name$target{exe_extension}");
2481 if (-f $fullpath and -x $fullpath) {
2482 return $fullpath;
2483 }
2484 }
2485 }
2486}
2487
00ae96ca
RL		 2488# Configuration printer ##############################################
2489
2490sub print_table_entry
2491{
2492 my $target = shift;
2493 my %target = resolve_config($target);
2494 my $type = shift;
2495
2496 # Don't print the templates
2497 return if $target{template};
2498
2499 my @sequence = (
f0bd4686 2500 "sys_id",
00ae96ca
RL		 2501 "cc",
2502 "cflags",
bcb1977b 2503 "defines",
f0bd4686
RL		 2504 "unistd",
2505 "ld",
00ae96ca 2506 "lflags",
0c0d78b8 2507 "loutflag",
c86ddbe6 2508 "plib_lflags",
1740c162 2509 "ex_libs",
00ae96ca 2510 "bn_ops",
0c0d78b8
RL		 2511 "apps_aux_src",
2512 "cpuid_asm_src",
2513 "uplink_aux_src",
2514 "bn_asm_src",
2515 "ec_asm_src",
2516 "des_asm_src",
2517 "aes_asm_src",
2518 "bf_asm_src",
2519 "md5_asm_src",
2520 "cast_asm_src",
2521 "sha1_asm_src",
2522 "rc4_asm_src",
2523 "rmd160_asm_src",
2524 "rc5_asm_src",
2525 "wp_asm_src",
2526 "cmll_asm_src",
2527 "modes_asm_src",
2528 "padlock_asm_src",
2529 "chacha_asm_src",
2530 "poly1035_asm_src",
9c62a279 2531 "thread_scheme",
00ae96ca
RL		 2532 "perlasm_scheme",
2533 "dso_scheme",
2534 "shared_target",
2535 "shared_cflag",
0c0d78b8 2536 "shared_defines",
00ae96ca 2537 "shared_ldflag",
64c443e3 2538 "shared_rcflag",
00ae96ca 2539 "shared_extension",
e987f9f2 2540 "dso_extension",
f0bd4686
RL		 2541 "obj_extension",
2542 "exe_extension",
00ae96ca 2543 "ranlib",
f0bd4686 2544 "ar",
00ae96ca 2545 "arflags",
0c0d78b8
RL		 2546 "aroutflag",
2547 "rc",
2548 "rcflags",
2549 "rcoutflag",
2550 "mt",
2551 "mtflags",
2552 "mtinflag",
2553 "mtoutflag",
00ae96ca 2554 "multilib",
f0bd4686 2555 "build_scheme",
00ae96ca
RL		 2556 );
2557
2558 if ($type eq "TABLE") {
2559 print "\n";
2560 print "*** $target\n";
cb212f23
RL		 2561 foreach (@sequence) {
2562 if (ref($target{$_}) eq "ARRAY") {
2563 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2564 } else {
2565 printf "\$%-12s = %s\n", $_, $target{$_};
2566 }
2567 }
00ae96ca
RL		 2568 } elsif ($type eq "HASH") {
2569 my $largest =
2570 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2571 print " '$target' => {\n";
2572 foreach (@sequence) {
2573 if ($target{$_}) {
cb212f23
RL		 2574 if (ref($target{$_}) eq "ARRAY") {
2575 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2576 } else {
2577 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2578 }
00ae96ca
RL		 2579 }
2580 }
2581 print " },\n";
2582 }
2583}
2584
2585# Utility routines ###################################################
2586
2e963849
RL		 2587# On VMS, if the given file is a logical name, File::Spec::Functions
2588# will consider it an absolute path. There are cases when we want a
2589# purely syntactic check without checking the environment.
2590sub isabsolute {
2591 my $file = shift;
2592
2593 # On non-platforms, we just use file_name_is_absolute().
2594 return file_name_is_absolute($file) unless $^O eq "VMS";
2595
69687aa8 2596 # If the file spec includes a device or a directory spec,
2e963849
RL		 2597 # file_name_is_absolute() is perfectly safe.
2598 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2599
2600 # Here, we know the given file spec isn't absolute
2601 return 0;
2602}
2603
ec182ef0
RL		 2604# Makes a directory absolute and cleans out /../ in paths like foo/../bar
2605# On some platforms, this uses rel2abs(), while on others, realpath() is used.
2606# realpath() requires that at least all path components except the last is an
2607# existing directory. On VMS, the last component of the directory spec must
2608# exist.
2609sub absolutedir {
2610 my $dir = shift;
2611
2612 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2613 # will return the volume name for the device, no matter what. Also,
2614 # it will return an incorrect directory spec if the argument is a
2615 # directory that doesn't exist.
2616 if ($^O eq "VMS") {
2617 return rel2abs($dir);
2618 }
2619
2620 # We use realpath() on Unix, since no other will properly clean out
2621 # a directory spec.
2622 use Cwd qw/realpath/;
2623
2624 return realpath($dir);
2625}
2626
fe05264e
RL		 2627sub quotify {
2628 my %processors = (
2629 perl => sub { my $x = shift;
2630 $x =~ s/([\\\$\@"])/\\$1/g;
2631 return '"'.$x.'"'; },
f879d5ff
RL		 2632 maybeshell => sub { my $x = shift;
2633 (my $y = $x) =~ s/([\\\"])/\\$1/g;
2634 if ($x ne $y || $x =~ m|\s|) {
2635 return '"'.$y.'"';
2636 } else {
2637 return $x;
2638 }
2639 },
fe05264e
RL		 2640 );
2641 my $for = shift;
2642 my $processor =
2643 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2644
2110febb 2645 return map { $processor->($_); } @_;
fe05264e 2646}
107b5792 2647
9fe2bb77
RL		 2648# collect_from_file($filename, $line_concat_cond_re, $line_concat)
2649# $filename is a file name to read from
2650# $line_concat_cond_re is a regexp detecting a line continuation ending
2651# $line_concat is a CODEref that takes care of concatenating two lines
2652sub collect_from_file {
2653 my $filename = shift;
2654 my $line_concat_cond_re = shift;
2655 my $line_concat = shift;
2656
2657 open my $fh, $filename || die "unable to read $filename: $!\n";
2658 return sub {
2659 my $saved_line = "";
2660 $_ = "";
2661 while (<$fh>) {
04f171c0 2662 s|\R$||;
9fe2bb77
RL		 2663 if (defined $line_concat) {
2664 $_ = $line_concat->($saved_line, $_);
2665 $saved_line = "";
2666 }
2667 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2668 $saved_line = $_;
2669 next;
2670 }
2671 return $_;
2672 }
2673 die "$filename ending with continuation line\n" if $_;
2674 close $fh;
2675 return undef;
2676 }
2677}
2678
2679# collect_from_array($array, $line_concat_cond_re, $line_concat)
2680# $array is an ARRAYref of lines
2681# $line_concat_cond_re is a regexp detecting a line continuation ending
2682# $line_concat is a CODEref that takes care of concatenating two lines
2683sub collect_from_array {
2684 my $array = shift;
2685 my $line_concat_cond_re = shift;
2686 my $line_concat = shift;
2687 my @array = (@$array);
2688
2689 return sub {
2690 my $saved_line = "";
2691 $_ = "";
2692 while (defined($_ = shift @array)) {
04f171c0 2693 s|\R$||;
9fe2bb77
RL		 2694 if (defined $line_concat) {
2695 $_ = $line_concat->($saved_line, $_);
2696 $saved_line = "";
2697 }
2698 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2699 $saved_line = $_;
2700 next;
2701 }
2702 return $_;
2703 }
2704 die "input text ending with continuation line\n" if $_;
2705 return undef;
2706 }
2707}
2708
2709# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2710# $lineiterator is a CODEref that delivers one line at a time.
107b5792
RL		 2711# All following arguments are regex/CODEref pairs, where the regexp detects a
2712# line and the CODEref does something with the result of the regexp.
2713sub collect_information {
9fe2bb77 2714 my $lineiterator = shift;
107b5792
RL		 2715 my %collectors = @_;
2716
9fe2bb77 2717 while(defined($_ = $lineiterator->())) {
04f171c0 2718 s|\R$||;
9fe2bb77 2719 my $found = 0;
2b6b606c
RL		 2720 if ($collectors{"BEFORE"}) {
2721 $collectors{"BEFORE"}->($_);
2722 }
9fe2bb77 2723 foreach my $re (keys %collectors) {
2b6b606c 2724 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
9fe2bb77
RL		 2725 $collectors{$re}->($lineiterator);
2726 $found = 1;
2727 };
2728 }
2729 if ($collectors{"OTHERWISE"}) {
2730 $collectors{"OTHERWISE"}->($lineiterator, $_)
2731 unless $found || !defined $collectors{"OTHERWISE"};
2732 }
2b6b606c
RL		 2733 if ($collectors{"AFTER"}) {
2734 $collectors{"AFTER"}->($_);
2735 }
107b5792 2736 }
107b5792 2737}
ce959812
RL		 2738
2739# tokenize($line)
2740# $line is a line of text to split up into tokens
2741# returns a list of tokens
2742#
2743# Tokens are divided by spaces. If the tokens include spaces, they
2744# have to be quoted with single or double quotes. Double quotes
2745# inside a double quoted token must be escaped. Escaping is done
2746# with backslash.
2747# Basically, the same quoting rules apply for " and ' as in any
2748# Unix shell.
2749sub tokenize {
2750 my $line = my $debug_line = shift;
2751 my @result = ();
2752
2753 while ($line =~ s|^\s+||, $line ne "") {
2754 my $token = "";
2755 while ($line ne "" && $line !~ m|^\s|) {
2756 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2757 $token .= $1;
2758 $line = $';
2759 } elsif ($line =~ m/^'([^']*)'/) {
2760 $token .= $1;
2761 $line = $';
2762 } elsif ($line =~ m/^(\S+)/) {
2763 $token .= $1;
2764 $line = $';
2765 }
2766 }
2767 push @result, $token;
2768 }
2769
2770 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2771 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2772 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2773 }
2774 return @result;
2775}
A mirror of the official openssl repository