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