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