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