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