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