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