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