1#! /usr/bin/env perl
2# -*- mode: perl; -*-
3# Copyright 2016-2021 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
9
10##  Configure -- OpenSSL source tree configuration script
11
12use 5.10.0;
13use strict;
14use Config;
15use FindBin;
16use lib "$FindBin::Bin/util/perl";
17use File::Basename;
18use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
19use File::Path qw/mkpath/;
20use OpenSSL::Glob;
21
22# see INSTALL for instructions.
23
24my $orig_death_handler = $SIG{__DIE__};
25$SIG{__DIE__} = \&death_handler;
26
27my $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-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
28
29# Options:
30#
31# --config      add the given configuration file, which will be read after
32#               any "Configurations*" files that are found in the same
33#               directory as this script.
34# --prefix      prefix for the OpenSSL installation, which includes the
35#               directories bin, lib, include, share/man, share/doc/openssl
36#               This becomes the value of INSTALLTOP in Makefile
37#               (Default: /usr/local)
38# --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
39#               If it's a relative directory, it will be added on the directory
40#               given with --prefix.
41#               This becomes the value of OPENSSLDIR in Makefile and in C.
42#               (Default: PREFIX/ssl)
43#
44# --cross-compile-prefix Add specified prefix to binutils components.
45#
46# --api         One of 0.9.8, 1.0.0 or 1.1.0.  Do not compile support for
47#               interfaces deprecated as of the specified OpenSSL version.
48#
49# no-hw-xxx     do not compile support for specific crypto hardware.
50#               Generic OpenSSL-style methods relating to this support
51#               are always compiled but return NULL if the hardware
52#               support isn't compiled.
53# no-hw         do not compile support for any crypto hardware.
54# [no-]threads  [don't] try to create a library that is suitable for
55#               multithreaded applications (default is "threads" if we
56#               know how to do it)
57# [no-]shared   [don't] try to create shared libraries when supported.
58# [no-]pic      [don't] try to build position independent code when supported.
59#               If disabled, it also disables shared and dynamic-engine.
60# no-asm        do not use assembler
61# no-egd        do not compile support for the entropy-gathering daemon APIs
62# [no-]zlib     [don't] compile support for zlib compression.
63# zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
64#               library and will be loaded in run-time by the OpenSSL library.
65# sctp          include SCTP support
66# enable-weak-ssl-ciphers
67#               Enable weak ciphers that are disabled by default.
68# 386           generate 80386 code in assembly modules
69# no-sse2       disables IA-32 SSE2 code in assembly modules, the above
70#               mentioned '386' option implies this one
71# no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
72# -<xxx> +<xxx> All options which are unknown to the 'Configure' script are
73# /<xxx>        passed through to the compiler. Unix-style options beginning
74#               with a '-' or '+' are recognized, as well as Windows-style
75#               options beginning with a '/'. If the option contains arguments
76#               separated by spaces, then the URL-style notation %20 can be
77#               used for the space character in order to avoid having to quote
78#               the option. For example, -opt%20arg gets expanded to -opt arg.
79#               In fact, any ASCII character can be encoded as %xx using its
80#               hexadecimal encoding.
81# -static       while -static is also a pass-through compiler option (and
82#               as such is limited to environments where it's actually
83#               meaningful), it triggers a number configuration options,
84#               namely no-pic, no-shared and no-threads. It is
85#               argued that the only reason to produce statically linked
86#               binaries (and in context it means executables linked with
87#               -static flag, and not just executables linked with static
88#               libcrypto.a) is to eliminate dependency on specific run-time,
89#               a.k.a. libc version. The mentioned config options are meant
90#               to achieve just that. Unfortunately on Linux it's impossible
91#               to eliminate the dependency completely for openssl executable
92#               because of getaddrinfo and gethostbyname calls, which can
93#               invoke dynamically loadable library facility anyway to meet
94#               the lookup requests. For this reason on Linux statically
95#               linked openssl executable has rather debugging value than
96#               production quality.
97#
98# BN_LLONG      use the type 'long long' in crypto/bn/bn.h
99# RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
100# Following are set automatically by this script
101#
102# MD5_ASM       use some extra md5 assembler,
103# SHA1_ASM      use some extra sha1 assembler, must define L_ENDIAN for x86
104# RMD160_ASM    use some extra ripemd160 assembler,
105# SHA256_ASM    sha256_block is implemented in assembler
106# SHA512_ASM    sha512_block is implemented in assembler
107# AES_ASM       AES_[en|de]crypt is implemented in assembler
108
109# Minimum warning options... any contributions to OpenSSL should at least
110# get past these.  Note that we only use these with C compilers, not with
111# C++ compilers.
112
113# DEBUG_UNUSED enables __owur (warn unused result) checks.
114# -DPEDANTIC complements -pedantic and is meant to mask code that
115# is not strictly standard-compliant and/or implementation-specific,
116# e.g. inline assembly, disregards to alignment requirements, such
117# that -pedantic would complain about. Incidentally -DPEDANTIC has
118# to be used even in sanitized builds, because sanitizer too is
119# supposed to and does take notice of non-standard behaviour. Then
120# -pedantic with pre-C9x compiler would also complain about 'long
121# long' not being supported. As 64-bit algorithms are common now,
122# it grew impossible to resolve this without sizeable additional
123# code, so we just tell compiler to be pedantic about everything
124# but 'long long' type.
125
126my @gcc_devteam_warn = qw(
127    -DDEBUG_UNUSED
128    -DPEDANTIC -pedantic -Wno-long-long
129    -Wall
130    -Wextra
131    -Wno-unused-parameter
132    -Wno-missing-field-initializers
133    -Wswitch
134    -Wsign-compare
135    -Wshadow
136    -Wformat
137    -Wtype-limits
138    -Wundef
139    -Werror
140    -Wmissing-prototypes
141    -Wstrict-prototypes
142);
143
144# These are used in addition to $gcc_devteam_warn when the compiler is clang.
145# TODO(openssl-team): fix problems and investigate if (at least) the
146# following warnings can also be enabled:
147#       -Wcast-align
148#       -Wunreachable-code -- no, too ugly/compiler-specific
149#       -Wlanguage-extension-token -- no, we use asm()
150#       -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
151#       -Wextended-offsetof -- no, needed in CMS ASN1 code
152my @clang_devteam_warn = qw(
153    -Wno-unknown-warning-option
154    -Wswitch-default
155    -Wno-parentheses-equality
156    -Wno-language-extension-token
157    -Wno-extended-offsetof
158    -Wconditional-uninitialized
159    -Wincompatible-pointer-types-discards-qualifiers
160    -Wmissing-variable-declarations
161);
162
163my @cl_devteam_warn = qw(
164    /WX
165);
166
167# This adds backtrace information to the memory leak info.  Is only used
168# when crypto-mdebug-backtrace is enabled.
169my $memleak_devteam_backtrace = "-rdynamic";
170
171my $strict_warnings = 0;
172
173# As for $BSDthreads. Idea is to maintain "collective" set of flags,
174# which would cover all BSD flavors. -pthread applies to them all,
175# but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
176# -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
177# which has to be accompanied by explicit -D_THREAD_SAFE and
178# sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
179# seems to be sufficient?
180our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
181
182#
183# API compatibility name to version number mapping.
184#
185my $maxapi = "1.1.0";           # API for "no-deprecated" builds
186my $apitable = {
187    "1.1.0" => "0x10100000L",
188    "1.0.0" => "0x10000000L",
189    "0.9.8" => "0x00908000L",
190};
191
192our %table = ();
193our %config = ();
194our %withargs = ();
195our $now_printing;      # set to current entry's name in print_table_entry
196                        # (todo: right thing would be to encapsulate name
197                        # into %target [class] and make print_table_entry
198                        # a method)
199
200# Forward declarations ###############################################
201
202# read_config(filename)
203#
204# Reads a configuration file and populates %table with the contents
205# (which the configuration file places in %targets).
206sub read_config;
207
208# resolve_config(target)
209#
210# Resolves all the late evaluations, inheritances and so on for the
211# chosen target and any target it inherits from.
212sub resolve_config;
213
214
215# Information collection #############################################
216
217# Unified build supports separate build dir
218my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
219my $blddir = catdir(absolutedir("."));         # catdir ensures local syntax
220
221# File::Spec::Unix doesn't detect case insensitivity, so we make sure to
222# check if the source and build directory are really the same, and make
223# them so.  This avoids all kinds of confusion later on.
224# We must check @File::Spec::ISA rather than using File::Spec->isa() to
225# know if File::Spec ended up loading File::Spec::Unix.
226$srcdir = $blddir
227    if (grep(/::Unix$/, @File::Spec::ISA)
228        && samedir($srcdir, $blddir));
229
230my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
231
232my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
233
234$config{sourcedir} = abs2rel($srcdir, $blddir);
235$config{builddir} = abs2rel($blddir, $blddir);
236
237# Collect reconfiguration information if needed
238my @argvcopy=@ARGV;
239
240if (grep /^reconf(igure)?$/, @argvcopy) {
241    die "reconfiguring with other arguments present isn't supported"
242        if scalar @argvcopy > 1;
243    if (-f "./configdata.pm") {
244        my $file = "./configdata.pm";
245        unless (my $return = do $file) {
246            die "couldn't parse $file: $@" if $@;
247            die "couldn't do $file: $!"    unless defined $return;
248            die "couldn't run $file"       unless $return;
249        }
250
251        @argvcopy = defined($configdata::config{perlargv}) ?
252            @{$configdata::config{perlargv}} : ();
253        die "Incorrect data to reconfigure, please do a normal configuration\n"
254            if (grep(/^reconf/,@argvcopy));
255        $config{perlenv} = $configdata::config{perlenv} // {};
256    } else {
257        die "Insufficient data to reconfigure, please do a normal configuration\n";
258    }
259}
260
261$config{perlargv} = [ @argvcopy ];
262
263# Collect version numbers
264$config{version} = "unknown";
265$config{version_num} = "unknown";
266$config{shlib_version_number} = "unknown";
267$config{shlib_version_history} = "unknown";
268
269collect_information(
270    collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
271    qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
272    qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/      => sub { $config{version_num}=$1 },
273    qr/SHLIB_VERSION_NUMBER *"([^"]+)"/      => sub { $config{shlib_version_number}=$1 },
274    qr/SHLIB_VERSION_HISTORY *"([^"]*)"/     => sub { $config{shlib_version_history}=$1 }
275    );
276if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
277
278($config{major}, $config{minor})
279    = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
280($config{shlib_major}, $config{shlib_minor})
281    = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
282die "erroneous version information in opensslv.h: ",
283    "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
284    if ($config{major} eq "" || $config{minor} eq ""
285        || $config{shlib_major} eq "" ||  $config{shlib_minor} eq "");
286
287# Collect target configurations
288
289my $pattern = catfile(dirname($0), "Configurations", "*.conf");
290foreach (sort glob($pattern)) {
291    &read_config($_);
292}
293
294if (defined env($local_config_envname)) {
295    if ($^O eq 'VMS') {
296        # VMS environment variables are logical names,
297        # which can be used as is
298        $pattern = $local_config_envname . ':' . '*.conf';
299    } else {
300        $pattern = catfile(env($local_config_envname), '*.conf');
301    }
302
303    foreach (sort glob($pattern)) {
304        &read_config($_);
305    }
306}
307
308# Save away perl command information
309$config{perl_cmd} = $^X;
310$config{perl_version} = $Config{version};
311$config{perl_archname} = $Config{archname};
312
313$config{prefix}="";
314$config{openssldir}="";
315$config{processor}="";
316$config{libdir}="";
317my $auto_threads=1;    # enable threads automatically? true by default
318my $default_ranlib;
319
320# Top level directories to build
321$config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "util", "tools", "fuzz" ];
322# crypto/ subdirectories to build
323$config{sdirs} = [
324    "objects",
325    "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2", "siphash", "sm3",
326    "des", "aes", "rc2", "rc4", "rc5", "idea", "aria", "bf", "cast", "camellia", "seed", "sm4", "chacha", "modes",
327    "bn", "ec", "rsa", "dsa", "dh", "sm2", "dso", "engine",
328    "buffer", "bio", "stack", "lhash", "rand", "err",
329    "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
330    "cms", "ts", "srp", "cmac", "ct", "async", "kdf", "store"
331    ];
332# test/ subdirectories to build
333$config{tdirs} = [ "ossl_shim" ];
334
335# Known TLS and DTLS protocols
336my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
337my @dtls = qw(dtls1 dtls1_2);
338
339# Explicitly known options that are possible to disable.  They can
340# be regexps, and will be used like this: /^no-${option}$/
341# For developers: keep it sorted alphabetically
342
343my @disablables = (
344    "afalgeng",
345    "aria",
346    "asan",
347    "asm",
348    "async",
349    "autoalginit",
350    "autoerrinit",
351    "autoload-config",
352    "bf",
353    "blake2",
354    "buildtest-c\\+\\+",
355    "camellia",
356    "capieng",
357    "cast",
358    "chacha",
359    "cmac",
360    "cms",
361    "comp",
362    "crypto-mdebug",
363    "crypto-mdebug-backtrace",
364    "ct",
365    "deprecated",
366    "des",
367    "devcryptoeng",
368    "dgram",
369    "dh",
370    "dsa",
371    "dso",
372    "dtls",
373    "dynamic-engine",
374    "ec",
375    "ec2m",
376    "ecdh",
377    "ecdsa",
378    "ec_nistp_64_gcc_128",
379    "egd",
380    "engine",
381    "err",
382    "external-tests",
383    "filenames",
384    "fuzz-libfuzzer",
385    "fuzz-afl",
386    "gost",
387    "heartbeats",
388    "hw(-.+)?",
389    "idea",
390    "makedepend",
391    "md2",
392    "md4",
393    "mdc2",
394    "msan",
395    "multiblock",
396    "nextprotoneg",
397    "pinshared",
398    "ocb",
399    "ocsp",
400    "pic",
401    "poly1305",
402    "posix-io",
403    "psk",
404    "rc2",
405    "rc4",
406    "rc5",
407    "rdrand",
408    "rfc3779",
409    "rmd160",
410    "scrypt",
411    "sctp",
412    "seed",
413    "shared",
414    "siphash",
415    "sm2",
416    "sm3",
417    "sm4",
418    "sock",
419    "srp",
420    "srtp",
421    "sse2",
422    "ssl",
423    "ssl-trace",
424    "static-engine",
425    "stdio",
426    "tests",
427    "threads",
428    "tls",
429    "ts",
430    "ubsan",
431    "ui-console",
432    "unit-test",
433    "whirlpool",
434    "weak-ssl-ciphers",
435    "zlib",
436    "zlib-dynamic",
437    );
438foreach my $proto ((@tls, @dtls))
439        {
440        push(@disablables, $proto);
441        push(@disablables, "$proto-method") unless $proto eq "tls1_3";
442        }
443
444my %deprecated_disablables = (
445    "ssl2" => undef,
446    "buf-freelists" => undef,
447    "ripemd" => "rmd160",
448    "ui" => "ui-console",
449    );
450
451# All of the following are disabled by default:
452
453our %disabled = ( # "what"         => "comment"
454                  "asan"                => "default",
455                  "buildtest-c++"       => "default",
456                  "crypto-mdebug"       => "default",
457                  "crypto-mdebug-backtrace" => "default",
458                  "devcryptoeng"        => "default",
459                  "ec_nistp_64_gcc_128" => "default",
460                  "egd"                 => "default",
461                  "external-tests"      => "default",
462                  "fuzz-libfuzzer"      => "default",
463                  "fuzz-afl"            => "default",
464                  "heartbeats"          => "default",
465                  "md2"                 => "default",
466                  "msan"                => "default",
467                  "rc5"                 => "default",
468                  "sctp"                => "default",
469                  "ssl-trace"           => "default",
470                  "ssl3"                => "default",
471                  "ssl3-method"         => "default",
472                  "ubsan"               => "default",
473                  "unit-test"           => "default",
474                  "weak-ssl-ciphers"    => "default",
475                  "zlib"                => "default",
476                  "zlib-dynamic"        => "default",
477                );
478
479# Note: => pair form used for aesthetics, not to truly make a hash table
480my @disable_cascades = (
481    # "what"            => [ "cascade", ... ]
482    sub { $config{processor} eq "386" }
483                        => [ "sse2" ],
484    "ssl"               => [ "ssl3" ],
485    "ssl3-method"       => [ "ssl3" ],
486    "zlib"              => [ "zlib-dynamic" ],
487    "des"               => [ "mdc2" ],
488    "ec"                => [ "ecdsa", "ecdh" ],
489
490    "dgram"             => [ "dtls", "sctp" ],
491    "sock"              => [ "dgram" ],
492    "dtls"              => [ @dtls ],
493    sub { 0 == scalar grep { !$disabled{$_} } @dtls }
494                        => [ "dtls" ],
495
496    "tls"               => [ @tls ],
497    sub { 0 == scalar grep { !$disabled{$_} } @tls }
498                        => [ "tls" ],
499
500    "crypto-mdebug"     => [ "crypto-mdebug-backtrace" ],
501
502    # Without position independent code, there can be no shared libraries or DSOs
503    "pic"               => [ "shared" ],
504    "shared"            => [ "dynamic-engine" ],
505    "dso"               => [ "dynamic-engine" ],
506    "engine"            => [ "afalgeng", "devcryptoeng" ],
507
508    # no-autoalginit is only useful when building non-shared
509    "autoalginit"       => [ "shared", "apps" ],
510
511    "stdio"             => [ "apps", "capieng", "egd" ],
512    "apps"              => [ "tests" ],
513    "tests"             => [ "external-tests" ],
514    "comp"              => [ "zlib" ],
515    "ec"                => [ "tls1_3", "sm2" ],
516    "sm3"               => [ "sm2" ],
517    sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
518
519    sub { !$disabled{"msan"} } => [ "asm" ],
520    );
521
522# Avoid protocol support holes.  Also disable all versions below N, if version
523# N is disabled while N+1 is enabled.
524#
525my @list = (reverse @tls);
526while ((my $first, my $second) = (shift @list, shift @list)) {
527    last unless @list;
528    push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
529                              => [ @list ] );
530    unshift @list, $second;
531}
532my @list = (reverse @dtls);
533while ((my $first, my $second) = (shift @list, shift @list)) {
534    last unless @list;
535    push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
536                              => [ @list ] );
537    unshift @list, $second;
538}
539
540# Explicit "no-..." options will be collected in %disabled along with the defaults.
541# To remove something from %disabled, use "enable-foo".
542# For symmetry, "disable-foo" is a synonym for "no-foo".
543
544&usage if ($#ARGV < 0);
545
546# For the "make variables" CPPINCLUDES and CPPDEFINES, we support lists with
547# platform specific list separators.  Users from those platforms should
548# recognise those separators from how you set up the PATH to find executables.
549# The default is the Unix like separator, :, but as an exception, we also
550# support the space as separator.
551my $list_separator_re =
552    { VMS           => qr/(?<!\^),/,
553      MSWin32       => qr/(?<!\\);/ } -> {$^O} // qr/(?<!\\)[:\s]/;
554# All the "make variables" we support
555# Some get pre-populated for the sake of backward compatibility
556# (we supported those before the change to "make variable" support.
557my %user = (
558    AR          => env('AR'),
559    ARFLAGS     => [],
560    AS          => undef,
561    ASFLAGS     => [],
562    CC          => env('CC'),
563    CFLAGS      => [ env('CFLAGS') || () ],
564    CXX         => env('CXX'),
565    CXXFLAGS    => [ env('CXXFLAGS') || () ],
566    CPP         => undef,
567    CPPFLAGS    => [ env('CPPFLAGS') || () ],  # -D, -I, -Wp,
568    CPPDEFINES  => [],  # Alternative for -D
569    CPPINCLUDES => [],  # Alternative for -I
570    CROSS_COMPILE => env('CROSS_COMPILE'),
571    HASHBANGPERL=> env('HASHBANGPERL') || env('PERL'),
572    LD          => undef,
573    LDFLAGS     => [ env('LDFLAGS') || () ],  # -L, -Wl,
574    LDLIBS      => [ env('LDLIBS') || () ],  # -l
575    MT          => undef,
576    MTFLAGS     => [],
577    PERL        => env('PERL') || ($^O ne "VMS" ? $^X : "perl"),
578    RANLIB      => env('RANLIB'),
579    RC          => env('RC') || env('WINDRES'),
580    RCFLAGS     => [ env('RCFLAGS') || () ],
581    RM          => undef,
582   );
583# Info about what "make variables" may be prefixed with the cross compiler
584# prefix.  This should NEVER mention any such variable with a list for value.
585my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
586# The same but for flags given as Configure options.  These are *additional*
587# input, as opposed to the VAR=string option that override the corresponding
588# config target attributes
589my %useradd = (
590    CPPDEFINES  => [],
591    CPPINCLUDES => [],
592    CPPFLAGS    => [],
593    CFLAGS      => [],
594    CXXFLAGS    => [],
595    LDFLAGS     => [],
596    LDLIBS      => [],
597    RCFLAGS     => [],
598   );
599
600my %user_synonyms = (
601    HASHBANGPERL=> 'PERL',
602    RC          => 'WINDRES',
603   );
604
605# Some target attributes have been renamed, this is the translation table
606my %target_attr_translate =(
607    ar          => 'AR',
608    as          => 'AS',
609    cc          => 'CC',
610    cxx         => 'CXX',
611    cpp         => 'CPP',
612    hashbangperl => 'HASHBANGPERL',
613    ld          => 'LD',
614    mt          => 'MT',
615    ranlib      => 'RANLIB',
616    rc          => 'RC',
617    rm          => 'RM',
618   );
619
620# Initialisers coming from 'config' scripts
621$config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ];
622$config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ];
623$config{cppflags} = [ env('__CNF_CPPFLAGS') || () ];
624$config{cflags} = [ env('__CNF_CFLAGS') || () ];
625$config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ];
626$config{lflags} = [ env('__CNF_LDFLAGS') || () ];
627$config{ex_libs} = [ env('__CNF_LDLIBS') || () ];
628
629$config{openssl_api_defines}=[];
630$config{openssl_algorithm_defines}=[];
631$config{openssl_thread_defines}=[];
632$config{openssl_sys_defines}=[];
633$config{openssl_other_defines}=[];
634$config{options}="";
635$config{build_type} = "release";
636my $target="";
637
638my %cmdvars = ();               # Stores FOO='blah' type arguments
639my %unsupported_options = ();
640my %deprecated_options = ();
641# If you change this, update apps/version.c
642my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
643my @seed_sources = ();
644while (@argvcopy)
645        {
646        $_ = shift @argvcopy;
647
648        # Support env variable assignments among the options
649        if (m|^(\w+)=(.+)?$|)
650                {
651                $cmdvars{$1} = $2;
652                # Every time a variable is given as a configuration argument,
653                # it acts as a reset if the variable.
654                if (exists $user{$1})
655                        {
656                        $user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
657                        }
658                #if (exists $useradd{$1})
659                #       {
660                #       $useradd{$1} = [];
661                #       }
662                next;
663                }
664
665        # VMS is a case insensitive environment, and depending on settings
666        # out of our control, we may receive options uppercased.  Let's
667        # downcase at least the part before any equal sign.
668        if ($^O eq "VMS")
669                {
670                s/^([^=]*)/lc($1)/e;
671                }
672
673        # some people just can't read the instructions, clang people have to...
674        s/^-no-(?!integrated-as)/no-/;
675
676        # rewrite some options in "enable-..." form
677        s /^-?-?shared$/enable-shared/;
678        s /^sctp$/enable-sctp/;
679        s /^threads$/enable-threads/;
680        s /^zlib$/enable-zlib/;
681        s /^zlib-dynamic$/enable-zlib-dynamic/;
682
683        if (/^(no|disable|enable)-(.+)$/)
684                {
685                my $word = $2;
686                if (!exists $deprecated_disablables{$word}
687                        && !grep { $word =~ /^${_}$/ } @disablables)
688                        {
689                        $unsupported_options{$_} = 1;
690                        next;
691                        }
692                }
693        if (/^no-(.+)$/ || /^disable-(.+)$/)
694                {
695                foreach my $proto ((@tls, @dtls))
696                        {
697                        if ($1 eq "$proto-method")
698                                {
699                                $disabled{"$proto"} = "option($proto-method)";
700                                last;
701                                }
702                        }
703                if ($1 eq "dtls")
704                        {
705                        foreach my $proto (@dtls)
706                                {
707                                $disabled{$proto} = "option(dtls)";
708                                }
709                        $disabled{"dtls"} = "option(dtls)";
710                        }
711                elsif ($1 eq "ssl")
712                        {
713                        # Last one of its kind
714                        $disabled{"ssl3"} = "option(ssl)";
715                        }
716                elsif ($1 eq "tls")
717                        {
718                        # XXX: Tests will fail if all SSL/TLS
719                        # protocols are disabled.
720                        foreach my $proto (@tls)
721                                {
722                                $disabled{$proto} = "option(tls)";
723                                }
724                        }
725                elsif ($1 eq "static-engine")
726                        {
727                        delete $disabled{"dynamic-engine"};
728                        }
729                elsif ($1 eq "dynamic-engine")
730                        {
731                        $disabled{"dynamic-engine"} = "option";
732                        }
733                elsif (exists $deprecated_disablables{$1})
734                        {
735                        if ($deprecated_disablables{$1} ne "")
736                                {
737                                $deprecated_options{$_} = 1;
738                                if (defined $deprecated_disablables{$1})
739                                        {
740                                        $disabled{$deprecated_disablables{$1}} = "option";
741                                        }
742                                }
743                        }
744                else
745                        {
746                        $disabled{$1} = "option";
747                        }
748                # No longer an automatic choice
749                $auto_threads = 0 if ($1 eq "threads");
750                }
751        elsif (/^enable-(.+)$/)
752                {
753                if ($1 eq "static-engine")
754                        {
755                        $disabled{"dynamic-engine"} = "option";
756                        }
757                elsif ($1 eq "dynamic-engine")
758                        {
759                        delete $disabled{"dynamic-engine"};
760                        }
761                elsif ($1 eq "zlib-dynamic")
762                        {
763                        delete $disabled{"zlib"};
764                        }
765                my $algo = $1;
766                delete $disabled{$algo};
767
768                # No longer an automatic choice
769                $auto_threads = 0 if ($1 eq "threads");
770                }
771        elsif (/^--strict-warnings$/)
772                {
773                # Pretend that our strict flags is a C flag, and replace it
774                # with the proper flags later on
775                push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
776                $strict_warnings=1;
777                }
778        elsif (/^--debug$/)
779                {
780                $config{build_type} = "debug";
781                }
782        elsif (/^--release$/)
783                {
784                $config{build_type} = "release";
785                }
786        elsif (/^386$/)
787                { $config{processor}=386; }
788        elsif (/^fips$/)
789                {
790                die "FIPS mode not supported\n";
791                }
792        elsif (/^rsaref$/)
793                {
794                # No RSAref support any more since it's not needed.
795                # The check for the option is there so scripts aren't
796                # broken
797                }
798        elsif (/^nofipscanistercheck$/)
799                {
800                die "FIPS mode not supported\n";
801                }
802        elsif (m|^[-+/]|)
803                {
804                if (/^--prefix=(.*)$/)
805                        {
806                        $config{prefix}=$1;
807                        die "Directory given with --prefix MUST be absolute\n"
808                                unless file_name_is_absolute($config{prefix});
809                        }
810                elsif (/^--api=(.*)$/)
811                        {
812                        $config{api}=$1;
813                        }
814                elsif (/^--libdir=(.*)$/)
815                        {
816                        $config{libdir}=$1;
817                        }
818                elsif (/^--openssldir=(.*)$/)
819                        {
820                        $config{openssldir}=$1;
821                        }
822                elsif (/^--with-zlib-lib=(.*)$/)
823                        {
824                        $withargs{zlib_lib}=$1;
825                        }
826                elsif (/^--with-zlib-include=(.*)$/)
827                        {
828                        $withargs{zlib_include}=$1;
829                        }
830                elsif (/^--with-fuzzer-lib=(.*)$/)
831                        {
832                        $withargs{fuzzer_lib}=$1;
833                        }
834                elsif (/^--with-fuzzer-include=(.*)$/)
835                        {
836                        $withargs{fuzzer_include}=$1;
837                        }
838                elsif (/^--with-rand-seed=(.*)$/)
839                        {
840                        foreach my $x (split(m|,|, $1))
841                            {
842                            die "Unknown --with-rand-seed choice $x\n"
843                                if ! grep { $x eq $_ } @known_seed_sources;
844                            push @seed_sources, $x;
845                            }
846                        }
847                elsif (/^--cross-compile-prefix=(.*)$/)
848                        {
849                        $user{CROSS_COMPILE}=$1;
850                        }
851                elsif (/^--config=(.*)$/)
852                        {
853                        read_config $1;
854                        }
855                elsif (/^-l(.*)$/)
856                        {
857                        push @{$useradd{LDLIBS}}, $_;
858                        }
859                elsif (/^-framework$/)
860                        {
861                        push @{$useradd{LDLIBS}}, $_, shift(@argvcopy);
862                        }
863                elsif (/^-L(.*)$/ or /^-Wl,/)
864                        {
865                        push @{$useradd{LDFLAGS}}, $_;
866                        }
867                elsif (/^-rpath$/ or /^-R$/)
868                        # -rpath is the OSF1 rpath flag
869                        # -R is the old Solaris rpath flag
870                        {
871                        my $rpath = shift(@argvcopy) || "";
872                        $rpath .= " " if $rpath ne "";
873                        push @{$useradd{LDFLAGS}}, $_, $rpath;
874                        }
875                elsif (/^-static$/)
876                        {
877                        push @{$useradd{LDFLAGS}}, $_;
878                        }
879                elsif (m|^[-/]D(.*)$|)
880                        {
881                        push @{$useradd{CPPDEFINES}}, $1;
882                        }
883                elsif (m|^[-/]I(.*)$|)
884                        {
885                        push @{$useradd{CPPINCLUDES}}, $1;
886                        }
887                elsif (/^-Wp,$/)
888                        {
889                        push @{$useradd{CPPFLAGS}}, $1;
890                        }
891                else    # common if (/^[-+]/), just pass down...
892                        {
893                        # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
894                        # This provides a simple way to pass options with arguments separated
895                        # by spaces without quoting (e.g. -opt%20arg translates to -opt arg).
896                        $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
897                        push @{$useradd{CFLAGS}}, $_;
898                        push @{$useradd{CXXFLAGS}}, $_;
899                        }
900                }
901        elsif (m|^/|)
902                {
903                # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
904                # This provides a simple way to pass options with arguments separated
905                # by spaces without quoting (e.g. /opt%20arg translates to /opt arg).
906                $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
907                push @{$useradd{CFLAGS}}, $_;
908                push @{$useradd{CXXFLAGS}}, $_;
909                }
910        else
911                {
912                die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
913                $target=$_;
914                }
915        unless ($_ eq $target || /^no-/ || /^disable-/)
916                {
917                # "no-..." follows later after implied deactivations
918                # have been derived.  (Don't take this too seriously,
919                # we really only write OPTIONS to the Makefile out of
920                # nostalgia.)
921
922                if ($config{options} eq "")
923                        { $config{options} = $_; }
924                else
925                        { $config{options} .= " ".$_; }
926                }
927        }
928
929if (defined($config{api}) && !exists $apitable->{$config{api}}) {
930        die "***** Unsupported api compatibility level: $config{api}\n",
931}
932
933if (keys %deprecated_options)
934        {
935        warn "***** Deprecated options: ",
936                join(", ", keys %deprecated_options), "\n";
937        }
938if (keys %unsupported_options)
939        {
940        die "***** Unsupported options: ",
941                join(", ", keys %unsupported_options), "\n";
942        }
943
944# If any %useradd entry has been set, we must check that the "make
945# variables" haven't been set.  We start by checking of any %useradd entry
946# is set.
947if (grep { scalar @$_ > 0 } values %useradd) {
948    # Hash of env / make variables names.  The possible values are:
949    # 1 - "make vars"
950    # 2 - %useradd entry set
951    # 3 - both set
952    my %detected_vars =
953        map { my $v = 0;
954              $v += 1 if $cmdvars{$_};
955              $v += 2 if @{$useradd{$_}};
956              $_ => $v }
957        keys %useradd;
958
959    # If any of the corresponding "make variables" is set, we error
960    if (grep { $_ & 1 } values %detected_vars) {
961        my $names = join(', ', grep { $detected_vars{$_} > 0 }
962                               sort keys %detected_vars);
963        die <<"_____";
964***** Mixing make variables and additional compiler/linker flags as
965***** configure command line option is not permitted.
966***** Affected make variables: $names
967_____
968    }
969}
970
971# Check through all supported command line variables to see if any of them
972# were set, and canonicalise the values we got.  If no compiler or linker
973# flag or anything else that affects %useradd was set, we also check the
974# environment for values.
975my $anyuseradd =
976    grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
977foreach (keys %user) {
978    my $value = $cmdvars{$_};
979    $value //= env($_) unless $anyuseradd;
980    $value //=
981        defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
982    $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
983        unless $anyuseradd;
984
985    if (defined $value) {
986        if (ref $user{$_} eq 'ARRAY') {
987            if ($_ eq 'CPPDEFINES' || $_ eq 'CPPINCLUDES') {
988                $user{$_} = [ split /$list_separator_re/, $value ];
989            } else {
990                $user{$_} = [ $value ];
991            }
992        } elsif (!defined $user{$_}) {
993            $user{$_} = $value;
994        }
995    }
996}
997
998if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
999    && !$disabled{shared}
1000    && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
1001    die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
1002        "***** any of asan, msan or ubsan\n";
1003}
1004
1005sub disable {
1006    my $disable_type = shift;
1007
1008    for (@_) {
1009        $disabled{$_} = $disable_type;
1010    }
1011
1012    my @tocheckfor = (@_ ? @_ : keys %disabled);
1013    while (@tocheckfor) {
1014        my %new_tocheckfor = ();
1015        my @cascade_copy = (@disable_cascades);
1016        while (@cascade_copy) {
1017            my ($test, $descendents) =
1018                (shift @cascade_copy, shift @cascade_copy);
1019            if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
1020                foreach (grep { !defined($disabled{$_}) } @$descendents) {
1021                    $new_tocheckfor{$_} = 1; $disabled{$_} = "cascade";
1022                }
1023            }
1024        }
1025        @tocheckfor = (keys %new_tocheckfor);
1026    }
1027}
1028disable();                     # First cascade run
1029
1030our $die = sub { die @_; };
1031if ($target eq "TABLE") {
1032    local $die = sub { warn @_; };
1033    foreach (sort keys %table) {
1034        print_table_entry($_, "TABLE");
1035    }
1036    exit 0;
1037}
1038
1039if ($target eq "LIST") {
1040    foreach (sort keys %table) {
1041        print $_,"\n" unless $table{$_}->{template};
1042    }
1043    exit 0;
1044}
1045
1046if ($target eq "HASH") {
1047    local $die = sub { warn @_; };
1048    print "%table = (\n";
1049    foreach (sort keys %table) {
1050        print_table_entry($_, "HASH");
1051    }
1052    exit 0;
1053}
1054
1055print "Configuring OpenSSL version $config{version} ($config{version_num}) ";
1056print "for $target\n";
1057
1058if (scalar(@seed_sources) == 0) {
1059    print "Using os-specific seed configuration\n";
1060    push @seed_sources, 'os';
1061}
1062if (scalar(grep { $_ eq 'egd' } @seed_sources) > 0) {
1063    delete $disabled{'egd'};
1064}
1065if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1066    die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1067    warn <<_____ if scalar(@seed_sources) == 1;
1068
1069============================== WARNING ===============================
1070You have selected the --with-rand-seed=none option, which effectively
1071disables automatic reseeding of the OpenSSL random generator.
1072All operations depending on the random generator such as creating keys
1073will not work unless the random generator is seeded manually by the
1074application.
1075
1076Please read the 'Note on random number generation' section in the
1077INSTALL instructions and the RAND_DRBG(7) manual page for more details.
1078============================== WARNING ===============================
1079
1080_____
1081}
1082push @{$config{openssl_other_defines}},
1083     map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
1084        @seed_sources;
1085
1086# Backward compatibility?
1087if ($target =~ m/^CygWin32(-.*)$/) {
1088    $target = "Cygwin".$1;
1089}
1090
1091# Support for legacy targets having a name starting with 'debug-'
1092my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1093if ($d) {
1094    $config{build_type} = "debug";
1095
1096    # If we do not find debug-foo in the table, the target is set to foo.
1097    if (!$table{$target}) {
1098        $target = $t;
1099    }
1100}
1101
1102&usage if !$table{$target} || $table{$target}->{template};
1103
1104$config{target} = $target;
1105my %target = resolve_config($target);
1106
1107foreach (keys %target_attr_translate) {
1108    $target{$target_attr_translate{$_}} = $target{$_}
1109        if $target{$_};
1110    delete $target{$_};
1111}
1112
1113%target = ( %{$table{DEFAULTS}}, %target );
1114
1115my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1116$config{conf_files} = [ sort keys %conf_files ];
1117
1118# Using sub disable within these loops may prove fragile, so we run
1119# a cascade afterwards
1120foreach my $feature (@{$target{disable}}) {
1121    if (exists $deprecated_disablables{$feature}) {
1122        warn "***** config $target disables deprecated feature $feature\n";
1123    } elsif (!grep { $feature eq $_ } @disablables) {
1124        die "***** config $target disables unknown feature $feature\n";
1125    }
1126    $disabled{$feature} = 'config';
1127}
1128foreach my $feature (@{$target{enable}}) {
1129    if ("default" eq ($disabled{$feature} // "")) {
1130        if (exists $deprecated_disablables{$feature}) {
1131            warn "***** config $target enables deprecated feature $feature\n";
1132        } elsif (!grep { $feature eq $_ } @disablables) {
1133            die "***** config $target enables unknown feature $feature\n";
1134        }
1135        delete $disabled{$feature};
1136    }
1137}
1138disable();                      # Run a cascade now
1139
1140$target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1141$target{cxxflags}//=$target{cflags} if $target{CXX};
1142$target{exe_extension}="";
1143$target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
1144                                  || $config{target} =~ /^(?:Cygwin|mingw)/);
1145$target{exe_extension}=".pm"  if ($config{target} =~ /vos/);
1146
1147($target{shared_extension_simple}=$target{shared_extension})
1148    =~ s|\.\$\(SHLIB_VERSION_NUMBER\)||
1149    unless defined($target{shared_extension_simple});
1150$target{dso_extension}//=$target{shared_extension_simple};
1151($target{shared_import_extension}=$target{shared_extension_simple}.".a")
1152    if ($config{target} =~ /^(?:Cygwin|mingw)/);
1153
1154# Fill %config with values from %user, and in case those are undefined or
1155# empty, use values from %target (acting as a default).
1156foreach (keys %user) {
1157    my $ref_type = ref $user{$_};
1158
1159    # Temporary function.  Takes an intended ref type (empty string or "ARRAY")
1160    # and a value that's to be coerced into that type.
1161    my $mkvalue = sub {
1162        my $type = shift;
1163        my $value = shift;
1164        my $undef_p = shift;
1165
1166        die "Too many arguments for \$mkvalue" if @_;
1167
1168        while (ref $value eq 'CODE') {
1169            $value = $value->();
1170        }
1171
1172        if ($type eq 'ARRAY') {
1173            return undef unless defined $value;
1174            return undef if ref $value ne 'ARRAY' && !$value;
1175            return undef if ref $value eq 'ARRAY' && !@$value;
1176            return [ $value ] unless ref $value eq 'ARRAY';
1177        }
1178        return undef unless $value;
1179        return $value;
1180    };
1181
1182    $config{$_} =
1183        $mkvalue->($ref_type, $user{$_})
1184        || $mkvalue->($ref_type, $target{$_});
1185    delete $config{$_} unless defined $config{$_};
1186}
1187
1188# Finish up %config by appending things the user gave us on the command line
1189# apart from "make variables"
1190foreach (keys %useradd) {
1191    # The must all be lists, so we assert that here
1192    die "internal error: \$useradd{$_} isn't an ARRAY\n"
1193        unless ref $useradd{$_} eq 'ARRAY';
1194
1195    if (defined $config{$_}) {
1196        push @{$config{$_}}, @{$useradd{$_}};
1197    } else {
1198        $config{$_} = [ @{$useradd{$_}} ];
1199    }
1200}
1201# At this point, we can forget everything about %user and %useradd,
1202# because it's now all been merged into the corresponding $config entry
1203
1204if (grep { $_ eq '-static' } @{$config{LDFLAGS}}) {
1205    disable('static', 'pic', 'threads');
1206}
1207
1208# Allow overriding the build file name
1209$config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
1210
1211# Make sure build_scheme is consistent.
1212$target{build_scheme} = [ $target{build_scheme} ]
1213    if ref($target{build_scheme}) ne "ARRAY";
1214
1215my ($builder, $builder_platform, @builder_opts) =
1216    @{$target{build_scheme}};
1217
1218foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1219                      $builder_platform."-checker.pm")) {
1220    my $checker_path = catfile($srcdir, "Configurations", $checker);
1221    if (-f $checker_path) {
1222        my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1223            ? sub { warn $@; } : sub { die $@; };
1224        if (! do $checker_path) {
1225            if ($@) {
1226                $fn->($@);
1227            } elsif ($!) {
1228                $fn->($!);
1229            } else {
1230                $fn->("The detected tools didn't match the platform\n");
1231            }
1232        }
1233        last;
1234    }
1235}
1236
1237push @{$config{defines}}, "NDEBUG"    if $config{build_type} eq "release";
1238
1239if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
1240        {
1241        push @{$config{cflags}}, "-mno-cygwin";
1242        push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1243        push @{$config{shared_ldflag}}, "-mno-cygwin";
1244        }
1245
1246if ($target =~ /linux.*-mips/ && !$disabled{asm}
1247        && !grep { $_ !~ /-m(ips|arch=)/ } (@{$config{CFLAGS}})) {
1248        # minimally required architecture flags for assembly modules
1249        my $value;
1250        $value = '-mips2' if ($target =~ /mips32/);
1251        $value = '-mips3' if ($target =~ /mips64/);
1252        unshift @{$config{cflags}}, $value;
1253        unshift @{$config{cxxflags}}, $value if $config{CXX};
1254}
1255
1256# If threads aren't disabled, check how possible they are
1257unless ($disabled{threads}) {
1258    if ($auto_threads) {
1259        # Enabled by default, disable it forcibly if unavailable
1260        if ($target{thread_scheme} eq "(unknown)") {
1261            disable("unavailable", 'threads');
1262        }
1263    } else {
1264        # The user chose to enable threads explicitly, let's see
1265        # if there's a chance that's possible
1266        if ($target{thread_scheme} eq "(unknown)") {
1267            # If the user asked for "threads" and we don't have internal
1268            # knowledge how to do it, [s]he is expected to provide any
1269            # system-dependent compiler options that are necessary.  We
1270            # can't truly check that the given options are correct, but
1271            # we expect the user to know what [s]He is doing.
1272            if (!@{$config{CFLAGS}} && !@{$config{CPPDEFINES}}) {
1273                die "You asked for multi-threading support, but didn't\n"
1274                    ,"provide any system-specific compiler options\n";
1275            }
1276        }
1277    }
1278}
1279
1280# If threads still aren't disabled, add a C macro to ensure the source
1281# code knows about it.  Any other flag is taken care of by the configs.
1282unless($disabled{threads}) {
1283    push @{$config{openssl_thread_defines}}, "OPENSSL_THREADS";
1284}
1285
1286# With "deprecated" disable all deprecated features.
1287if (defined($disabled{"deprecated"})) {
1288        $config{api} = $maxapi;
1289}
1290
1291my $no_shared_warn=0;
1292if ($target{shared_target} eq "")
1293        {
1294        $no_shared_warn = 1
1295            if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1296        disable('no-shared-target', 'pic');
1297        }
1298
1299if ($disabled{"dynamic-engine"}) {
1300        $config{dynamic_engines} = 0;
1301} else {
1302        $config{dynamic_engines} = 1;
1303}
1304
1305unless ($disabled{asan}) {
1306    push @{$config{cflags}}, "-fsanitize=address";
1307}
1308
1309unless ($disabled{ubsan}) {
1310    # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1311    # platforms.
1312    push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all";
1313}
1314
1315unless ($disabled{msan}) {
1316  push @{$config{cflags}}, "-fsanitize=memory";
1317}
1318
1319unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1320        && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1321    push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
1322    push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
1323}
1324#
1325# Platform fix-ups
1326#
1327
1328# This saves the build files from having to check
1329if ($disabled{pic})
1330        {
1331        foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1332                    shared_defines shared_includes shared_ldflag
1333                    module_cflags module_cxxflags module_cppflags
1334                    module_defines module_includes module_lflags))
1335                {
1336                delete $config{$_};
1337                $target{$_} = "";
1338                }
1339        }
1340else
1341        {
1342        push @{$config{lib_defines}}, "OPENSSL_PIC";
1343        }
1344
1345if ($target{sys_id} ne "")
1346        {
1347        push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1348        }
1349
1350unless ($disabled{asm}) {
1351    $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1352    push @{$config{lib_defines}}, "OPENSSL_CPUID_OBJ" if ($target{cpuid_asm_src} ne "mem_clr.c");
1353
1354    $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1355
1356    # bn-586 is the only one implementing bn_*_part_words
1357    push @{$config{lib_defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1358    push @{$config{lib_defines}}, "OPENSSL_IA32_SSE2" if (!$disabled{sse2} && $target{bn_asm_src} =~ /86/);
1359
1360    push @{$config{lib_defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1361    push @{$config{lib_defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1362    push @{$config{lib_defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1363    push @{$config{lib_defines}}, "BN_DIV3W" if ($target{bn_asm_src} =~ /-div3w/);
1364
1365    if ($target{sha1_asm_src}) {
1366        push @{$config{lib_defines}}, "SHA1_ASM"   if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1367        push @{$config{lib_defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1368        push @{$config{lib_defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1369    }
1370    if ($target{keccak1600_asm_src} ne $table{DEFAULTS}->{keccak1600_asm_src}) {
1371        push @{$config{lib_defines}}, "KECCAK1600_ASM";
1372    }
1373    if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
1374        push @{$config{lib_defines}}, "RC4_ASM";
1375    }
1376    if ($target{md5_asm_src}) {
1377        push @{$config{lib_defines}}, "MD5_ASM";
1378    }
1379    $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1380    if ($target{rmd160_asm_src}) {
1381        push @{$config{lib_defines}}, "RMD160_ASM";
1382    }
1383    if ($target{aes_asm_src}) {
1384        push @{$config{lib_defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1385        push @{$config{lib_defines}}, "AESNI_ASM" if ($target{aes_asm_src} =~ m/\baesni-/);;
1386        # aes-ctr.fake is not a real file, only indication that assembler
1387        # module implements AES_ctr32_encrypt...
1388        push @{$config{lib_defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1389        # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1390        push @{$config{lib_defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1391        $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($disabled{sse2});
1392        push @{$config{lib_defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1393        push @{$config{lib_defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1394    }
1395    if ($target{wp_asm_src} =~ /mmx/) {
1396        if ($config{processor} eq "386") {
1397            $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1398        } elsif (!$disabled{"whirlpool"}) {
1399            push @{$config{lib_defines}}, "WHIRLPOOL_ASM";
1400        }
1401    }
1402    if ($target{modes_asm_src} =~ /ghash-/) {
1403        push @{$config{lib_defines}}, "GHASH_ASM";
1404    }
1405    if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1406        push @{$config{lib_defines}}, "ECP_NISTZ256_ASM";
1407    }
1408    if ($target{ec_asm_src} =~ /x25519/) {
1409        push @{$config{lib_defines}}, "X25519_ASM";
1410    }
1411    if ($target{padlock_asm_src} ne $table{DEFAULTS}->{padlock_asm_src}) {
1412        push @{$config{dso_defines}}, "PADLOCK_ASM";
1413    }
1414    if ($target{poly1305_asm_src} ne "") {
1415        push @{$config{lib_defines}}, "POLY1305_ASM";
1416    }
1417}
1418
1419my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1420my %predefined_CXX = $config{CXX}
1421    ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1422    : ();
1423
1424# Check for makedepend capabilities.
1425if (!$disabled{makedepend}) {
1426    if ($config{target} =~ /^(VC|vms)-/) {
1427        # For VC- and vms- targets, there's nothing more to do here.  The
1428        # functionality is hard coded in the corresponding build files for
1429        # cl (Windows) and CC/DECC (VMS).
1430    } elsif (($predefined_C{__GNUC__} // -1) >= 3
1431             && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
1432        # We know that GNU C version 3 and up as well as all clang
1433        # versions support dependency generation, but Xcode did not
1434        # handle $cc -M before clang support (but claims __GNUC__ = 3)
1435        $config{makedepprog} = "\$(CROSS_COMPILE)$config{CC}";
1436    } else {
1437        # In all other cases, we look for 'makedepend', and disable the
1438        # capability if not found.
1439        $config{makedepprog} = which('makedepend');
1440        disable('unavailable', 'makedepend') unless $config{makedepprog};
1441    }
1442}
1443
1444if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
1445    # probe for -Wa,--noexecstack option...
1446    if ($predefined_C{__clang__}) {
1447        # clang has builtin assembler, which doesn't recognize --help,
1448        # but it apparently recognizes the option in question on all
1449        # supported platforms even when it's meaningless. In other words
1450        # probe would fail, but probed option always accepted...
1451        push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
1452    } else {
1453        my $cc = $config{CROSS_COMPILE}.$config{CC};
1454        open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1455        while(<PIPE>) {
1456            if (m/--noexecstack/) {
1457                push @{$config{cflags}}, "-Wa,--noexecstack";
1458                last;
1459            }
1460        }
1461        close(PIPE);
1462        unlink("null.$$.o");
1463    }
1464}
1465
1466# Deal with bn_ops ###################################################
1467
1468$config{bn_ll}                  =0;
1469$config{export_var_as_fn}       =0;
1470my $def_int="unsigned int";
1471$config{rc4_int}                =$def_int;
1472($config{b64l},$config{b64},$config{b32})=(0,0,1);
1473
1474my $count = 0;
1475foreach (sort split(/\s+/,$target{bn_ops})) {
1476    $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1477    $config{export_var_as_fn}=1                 if $_ eq 'EXPORT_VAR_AS_FN';
1478    $config{bn_ll}=1                            if $_ eq 'BN_LLONG';
1479    $config{rc4_int}="unsigned char"            if $_ eq 'RC4_CHAR';
1480    ($config{b64l},$config{b64},$config{b32})
1481        =(0,1,0)                                if $_ eq 'SIXTY_FOUR_BIT';
1482    ($config{b64l},$config{b64},$config{b32})
1483        =(1,0,0)                                if $_ eq 'SIXTY_FOUR_BIT_LONG';
1484    ($config{b64l},$config{b64},$config{b32})
1485        =(0,0,1)                                if $_ eq 'THIRTY_TWO_BIT';
1486}
1487die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1488    if $count > 1;
1489
1490
1491# Hack cflags for better warnings (dev option) #######################
1492
1493# "Stringify" the C and C++ flags string.  This permits it to be made part of
1494# a string and works as well on command lines.
1495$config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1496                        @{$config{cflags}} ];
1497$config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1498                          @{$config{cxxflags}} ] if $config{CXX};
1499
1500if (defined($config{api})) {
1501    $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1502    my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1503    push @{$config{defines}}, $apiflag;
1504}
1505
1506my @strict_warnings_collection=();
1507if ($strict_warnings)
1508        {
1509        my $wopt;
1510        my $gccver = $predefined_C{__GNUC__} // -1;
1511
1512        if ($gccver >= 4)
1513                {
1514                push @strict_warnings_collection, @gcc_devteam_warn;
1515                push @strict_warnings_collection, @clang_devteam_warn
1516                    if (defined($predefined_C{__clang__}));
1517                }
1518        elsif ($config{target} =~ /^VC-/)
1519                {
1520                push @strict_warnings_collection, @cl_devteam_warn;
1521                }
1522        else
1523                {
1524                warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike, or MSVC"
1525                }
1526        }
1527
1528$config{CFLAGS} = [ map { $_ eq '--ossl-strict-warnings'
1529                              ? @strict_warnings_collection
1530                              : ( $_ ) }
1531                    @{$config{CFLAGS}} ];
1532
1533unless ($disabled{"crypto-mdebug-backtrace"})
1534        {
1535        foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1536                {
1537                push @{$config{cflags}}, $wopt
1538                        unless grep { $_ eq $wopt } @{$config{cflags}};
1539                }
1540        if ($target =~ /^BSD-/)
1541                {
1542                push @{$config{ex_libs}}, "-lexecinfo";
1543                }
1544        }
1545
1546unless ($disabled{afalgeng}) {
1547    $config{afalgeng}="";
1548    if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
1549        my $minver = 4*10000 + 1*100 + 0;
1550        if ($config{CROSS_COMPILE} eq "") {
1551            my $verstr = `uname -r`;
1552            my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1553            ($mi2) = $mi2 =~ /(\d+)/;
1554            my $ver = $ma*10000 + $mi1*100 + $mi2;
1555            if ($ver < $minver) {
1556                disable('too-old-kernel', 'afalgeng');
1557            } else {
1558                push @{$config{engdirs}}, "afalg";
1559            }
1560        } else {
1561            disable('cross-compiling', 'afalgeng');
1562        }
1563    } else {
1564        disable('not-linux', 'afalgeng');
1565    }
1566}
1567
1568unless ($disabled{devcryptoeng}) {
1569    if ($target =~ m/^BSD/) {
1570        my $maxver = 5*100 + 7;
1571        my $sysstr = `uname -s`;
1572        my $verstr = `uname -r`;
1573        $sysstr =~ s|\R$||;
1574        $verstr =~ s|\R$||;
1575        my ($ma, $mi, @rest) = split m|\.|, $verstr;
1576        my $ver = $ma*100 + $mi;
1577        if ($sysstr eq 'OpenBSD' && $ver >= $maxver) {
1578            disable('too-new-kernel', 'devcryptoeng');
1579        }
1580    }
1581}
1582
1583# Get the extra flags used when building shared libraries and modules.  We
1584# do this late because some of them depend on %disabled.
1585
1586# Make the flags to build DSOs the same as for shared libraries unless they
1587# are already defined
1588$target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1589$target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1590$target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
1591{
1592    my $shared_info_pl =
1593        catfile(dirname($0), "Configurations", "shared-info.pl");
1594    my %shared_info = read_eval_file($shared_info_pl);
1595    push @{$target{_conf_fname_int}}, $shared_info_pl;
1596    my $si = $target{shared_target};
1597    while (ref $si ne "HASH") {
1598        last if ! defined $si;
1599        if (ref $si eq "CODE") {
1600            $si = $si->();
1601        } else {
1602            $si = $shared_info{$si};
1603        }
1604    }
1605
1606    # Some of the 'shared_target' values don't have any entries in
1607    # %shared_info.  That's perfectly fine, AS LONG AS the build file
1608    # template knows how to handle this.  That is currently the case for
1609    # Windows and VMS.
1610    if (defined $si) {
1611        # Just as above, copy certain shared_* attributes to the corresponding
1612        # module_ attribute unless the latter is already defined
1613        $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1614        $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1615        $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
1616        foreach (sort keys %$si) {
1617            $target{$_} = defined $target{$_}
1618                ? add($si->{$_})->($target{$_})
1619                : $si->{$_};
1620        }
1621    }
1622}
1623
1624# ALL MODIFICATIONS TO %disabled, %config and %target MUST BE DONE FROM HERE ON
1625
1626my %disabled_info = ();         # For configdata.pm
1627foreach my $what (sort keys %disabled) {
1628    $config{options} .= " no-$what";
1629
1630    if (!grep { $what eq $_ } ( 'buildtest-c++', 'threads', 'shared', 'pic',
1631                                'dynamic-engine', 'makedepend',
1632                                'zlib-dynamic', 'zlib', 'sse2' )) {
1633        (my $WHAT = uc $what) =~ s|-|_|g;
1634
1635        # Fix up C macro end names
1636        $WHAT = "RMD160" if $what eq "ripemd";
1637
1638        # fix-up crypto/directory name(s)
1639        $what = "ripemd" if $what eq "rmd160";
1640        $what = "whrlpool" if $what eq "whirlpool";
1641
1642        my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
1643
1644        if ((grep { $what eq $_ } @{$config{sdirs}})
1645                && $what ne 'async' && $what ne 'err' && $what ne 'dso') {
1646            @{$config{sdirs}} = grep { $what ne $_} @{$config{sdirs}};
1647            $disabled_info{$what}->{skipped} = [ catdir('crypto', $what) ];
1648
1649            if ($what ne 'engine') {
1650                push @{$config{openssl_algorithm_defines}}, $macro;
1651            } else {
1652                @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
1653                push @{$disabled_info{engine}->{skipped}}, catdir('engines');
1654                push @{$config{openssl_other_defines}}, $macro;
1655            }
1656        } else {
1657            push @{$config{openssl_other_defines}}, $macro;
1658        }
1659
1660    }
1661}
1662
1663if ($disabled{"dynamic-engine"}) {
1664    push @{$config{openssl_other_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1665} else {
1666    push @{$config{openssl_other_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1667}
1668
1669# If we use the unified build, collect information from build.info files
1670my %unified_info = ();
1671
1672my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1673if ($builder eq "unified") {
1674    use with_fallback qw(Text::Template);
1675
1676    sub cleandir {
1677        my $base = shift;
1678        my $dir = shift;
1679        my $relativeto = shift || ".";
1680
1681        $dir = catdir($base,$dir) unless isabsolute($dir);
1682
1683        # Make sure the directories we're building in exists
1684        mkpath($dir);
1685
1686        my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1687        #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1688        return $res;
1689    }
1690
1691    sub cleanfile {
1692        my $base = shift;
1693        my $file = shift;
1694        my $relativeto = shift || ".";
1695
1696        $file = catfile($base,$file) unless isabsolute($file);
1697
1698        my $d = dirname($file);
1699        my $f = basename($file);
1700
1701        # Make sure the directories we're building in exists
1702        mkpath($d);
1703
1704        my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1705        #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1706        return $res;
1707    }
1708
1709    # Store the name of the template file we will build the build file from
1710    # in %config.  This may be useful for the build file itself.
1711    my @build_file_template_names =
1712        ( $builder_platform."-".$target{build_file}.".tmpl",
1713          $target{build_file}.".tmpl" );
1714    my @build_file_templates = ();
1715
1716    # First, look in the user provided directory, if given
1717    if (defined env($local_config_envname)) {
1718        @build_file_templates =
1719            map {
1720                if ($^O eq 'VMS') {
1721                    # VMS environment variables are logical names,
1722                    # which can be used as is
1723                    $local_config_envname . ':' . $_;
1724                } else {
1725                    catfile(env($local_config_envname), $_);
1726                }
1727            }
1728            @build_file_template_names;
1729    }
1730    # Then, look in our standard directory
1731    push @build_file_templates,
1732        ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1733          @build_file_template_names );
1734
1735    my $build_file_template;
1736    for $_ (@build_file_templates) {
1737        $build_file_template = $_;
1738        last if -f $build_file_template;
1739
1740        $build_file_template = undef;
1741    }
1742    if (!defined $build_file_template) {
1743        die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1744    }
1745    $config{build_file_templates}
1746      = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1747                    $blddir),
1748          $build_file_template,
1749          cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1750                    $blddir) ];
1751
1752    my @build_infos = ( [ ".", "build.info" ] );
1753    foreach (@{$config{dirs}}) {
1754        push @build_infos, [ $_, "build.info" ]
1755            if (-f catfile($srcdir, $_, "build.info"));
1756    }
1757    foreach (@{$config{sdirs}}) {
1758        push @build_infos, [ catdir("crypto", $_), "build.info" ]
1759            if (-f catfile($srcdir, "crypto", $_, "build.info"));
1760    }
1761    foreach (@{$config{engdirs}}) {
1762        push @build_infos, [ catdir("engines", $_), "build.info" ]
1763            if (-f catfile($srcdir, "engines", $_, "build.info"));
1764    }
1765    foreach (@{$config{tdirs}}) {
1766        push @build_infos, [ catdir("test", $_), "build.info" ]
1767            if (-f catfile($srcdir, "test", $_, "build.info"));
1768    }
1769
1770    $config{build_infos} = [ ];
1771
1772    my %ordinals = ();
1773    foreach (@build_infos) {
1774        my $sourced = catdir($srcdir, $_->[0]);
1775        my $buildd = catdir($blddir, $_->[0]);
1776
1777        mkpath($buildd);
1778
1779        my $f = $_->[1];
1780        # The basic things we're trying to build
1781        my @programs = ();
1782        my @programs_install = ();
1783        my @libraries = ();
1784        my @libraries_install = ();
1785        my @engines = ();
1786        my @engines_install = ();
1787        my @scripts = ();
1788        my @scripts_install = ();
1789        my @extra = ();
1790        my @overrides = ();
1791        my @intermediates = ();
1792        my @rawlines = ();
1793
1794        my %sources = ();
1795        my %shared_sources = ();
1796        my %includes = ();
1797        my %depends = ();
1798        my %renames = ();
1799        my %sharednames = ();
1800        my %generate = ();
1801
1802        # We want to detect configdata.pm in the source tree, so we
1803        # don't use it if the build tree is different.
1804        my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1805
1806        push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1807        my $template =
1808            Text::Template->new(TYPE => 'FILE',
1809                                SOURCE => catfile($sourced, $f),
1810                                PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
1811        die "Something went wrong with $sourced/$f: $!\n" unless $template;
1812        my @text =
1813            split /^/m,
1814            $template->fill_in(HASH => { config => \%config,
1815                                         target => \%target,
1816                                         disabled => \%disabled,
1817                                         withargs => \%withargs,
1818                                         builddir => abs2rel($buildd, $blddir),
1819                                         sourcedir => abs2rel($sourced, $blddir),
1820                                         buildtop => abs2rel($blddir, $blddir),
1821                                         sourcetop => abs2rel($srcdir, $blddir) },
1822                               DELIMITERS => [ "{-", "-}" ]);
1823
1824        # The top item of this stack has the following values
1825        # -2 positive already run and we found ELSE (following ELSIF should fail)
1826        # -1 positive already run (skip until ENDIF)
1827        # 0 negatives so far (if we're at a condition, check it)
1828        # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1829        # 2 positive ELSE (following ELSIF should fail)
1830        my @skip = ();
1831        collect_information(
1832            collect_from_array([ @text ],
1833                               qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1834                                                $l1 =~ s/\\$//; $l1.$l2 }),
1835            # Info we're looking for
1836            qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1837            => sub {
1838                if (! @skip || $skip[$#skip] > 0) {
1839                    push @skip, !! $1;
1840                } else {
1841                    push @skip, -1;
1842                }
1843            },
1844            qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1845            => sub { die "ELSIF out of scope" if ! @skip;
1846                     die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1847                     $skip[$#skip] = -1 if $skip[$#skip] != 0;
1848                     $skip[$#skip] = !! $1
1849                         if $skip[$#skip] == 0; },
1850            qr/^\s*ELSE\s*$/
1851            => sub { die "ELSE out of scope" if ! @skip;
1852                     $skip[$#skip] = -2 if $skip[$#skip] != 0;
1853                     $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1854            qr/^\s*ENDIF\s*$/
1855            => sub { die "ENDIF out of scope" if ! @skip;
1856                     pop @skip; },
1857            qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1858            => sub {
1859                if (!@skip || $skip[$#skip] > 0) {
1860                    my $install = $1;
1861                    my @x = tokenize($2);
1862                    push @programs, @x;
1863                    push @programs_install, @x unless $install;
1864                }
1865            },
1866            qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1867            => sub {
1868                if (!@skip || $skip[$#skip] > 0) {
1869                    my $install = $1;
1870                    my @x = tokenize($2);
1871                    push @libraries, @x;
1872                    push @libraries_install, @x unless $install;
1873                }
1874            },
1875            qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1876            => sub {
1877                if (!@skip || $skip[$#skip] > 0) {
1878                    my $install = $1;
1879                    my @x = tokenize($2);
1880                    push @engines, @x;
1881                    push @engines_install, @x unless $install;
1882                }
1883            },
1884            qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1885            => sub {
1886                if (!@skip || $skip[$#skip] > 0) {
1887                    my $install = $1;
1888                    my @x = tokenize($2);
1889                    push @scripts, @x;
1890                    push @scripts_install, @x unless $install;
1891                }
1892            },
1893            qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1894            => sub { push @extra, tokenize($1)
1895                         if !@skip || $skip[$#skip] > 0 },
1896            qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1897            => sub { push @overrides, tokenize($1)
1898                         if !@skip || $skip[$#skip] > 0 },
1899
1900            qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1901            => sub { push @{$ordinals{$1}}, tokenize($2)
1902                         if !@skip || $skip[$#skip] > 0 },
1903            qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1904            => sub { push @{$sources{$1}}, tokenize($2)
1905                         if !@skip || $skip[$#skip] > 0 },
1906            qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1907            => sub { push @{$shared_sources{$1}}, tokenize($2)
1908                         if !@skip || $skip[$#skip] > 0 },
1909            qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1910            => sub { push @{$includes{$1}}, tokenize($2)
1911                         if !@skip || $skip[$#skip] > 0 },
1912            qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1913            => sub { push @{$depends{$1}}, tokenize($2)
1914                         if !@skip || $skip[$#skip] > 0 },
1915            qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1916            => sub { push @{$generate{$1}}, $2
1917                         if !@skip || $skip[$#skip] > 0 },
1918            qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1919            => sub { push @{$renames{$1}}, tokenize($2)
1920                         if !@skip || $skip[$#skip] > 0 },
1921            qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1922            => sub { push @{$sharednames{$1}}, tokenize($2)
1923                         if !@skip || $skip[$#skip] > 0 },
1924            qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1925            => sub {
1926                my $lineiterator = shift;
1927                my $target_kind = $1;
1928                while (defined $lineiterator->()) {
1929                    s|\R$||;
1930                    if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1931                        die "ENDRAW doesn't match BEGINRAW"
1932                            if $1 ne $target_kind;
1933                        last;
1934                    }
1935                    next if @skip && $skip[$#skip] <= 0;
1936                    push @rawlines,  $_
1937                        if ($target_kind eq $target{build_file}
1938                            || $target_kind eq $target{build_file}."(".$builder_platform.")");
1939                }
1940            },
1941            qr/^\s*(?:#.*)?$/ => sub { },
1942            "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1943            "BEFORE" => sub {
1944                if ($buildinfo_debug) {
1945                    print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1946                    print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1947                }
1948            },
1949            "AFTER" => sub {
1950                if ($buildinfo_debug) {
1951                    print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1952                }
1953            },
1954            );
1955        die "runaway IF?" if (@skip);
1956
1957        foreach (keys %renames) {
1958            die "$_ renamed to more than one thing: "
1959                ,join(" ", @{$renames{$_}}),"\n"
1960                if scalar @{$renames{$_}} > 1;
1961            my $dest = cleanfile($buildd, $_, $blddir);
1962            my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1963            die "$dest renamed to more than one thing: "
1964                ,$unified_info{rename}->{$dest}, $to
1965                unless !defined($unified_info{rename}->{$dest})
1966                or $unified_info{rename}->{$dest} eq $to;
1967            $unified_info{rename}->{$dest} = $to;
1968        }
1969
1970        foreach (@programs) {
1971            my $program = cleanfile($buildd, $_, $blddir);
1972            if ($unified_info{rename}->{$program}) {
1973                $program = $unified_info{rename}->{$program};
1974            }
1975            $unified_info{programs}->{$program} = 1;
1976        }
1977
1978        foreach (@programs_install) {
1979            my $program = cleanfile($buildd, $_, $blddir);
1980            if ($unified_info{rename}->{$program}) {
1981                $program = $unified_info{rename}->{$program};
1982            }
1983            $unified_info{install}->{programs}->{$program} = 1;
1984        }
1985
1986        foreach (@libraries) {
1987            my $library = cleanfile($buildd, $_, $blddir);
1988            if ($unified_info{rename}->{$library}) {
1989                $library = $unified_info{rename}->{$library};
1990            }
1991            $unified_info{libraries}->{$library} = 1;
1992        }
1993
1994        foreach (@libraries_install) {
1995            my $library = cleanfile($buildd, $_, $blddir);
1996            if ($unified_info{rename}->{$library}) {
1997                $library = $unified_info{rename}->{$library};
1998            }
1999            $unified_info{install}->{libraries}->{$library} = 1;
2000        }
2001
2002        die <<"EOF" if scalar @engines and !$config{dynamic_engines};
2003ENGINES can only be used if configured with 'dynamic-engine'.
2004This is usually a fault in a build.info file.
2005EOF
2006        foreach (@engines) {
2007            my $library = cleanfile($buildd, $_, $blddir);
2008            if ($unified_info{rename}->{$library}) {
2009                $library = $unified_info{rename}->{$library};
2010            }
2011            $unified_info{engines}->{$library} = 1;
2012        }
2013
2014        foreach (@engines_install) {
2015            my $library = cleanfile($buildd, $_, $blddir);
2016            if ($unified_info{rename}->{$library}) {
2017                $library = $unified_info{rename}->{$library};
2018            }
2019            $unified_info{install}->{engines}->{$library} = 1;
2020        }
2021
2022        foreach (@scripts) {
2023            my $script = cleanfile($buildd, $_, $blddir);
2024            if ($unified_info{rename}->{$script}) {
2025                $script = $unified_info{rename}->{$script};
2026            }
2027            $unified_info{scripts}->{$script} = 1;
2028        }
2029
2030        foreach (@scripts_install) {
2031            my $script = cleanfile($buildd, $_, $blddir);
2032            if ($unified_info{rename}->{$script}) {
2033                $script = $unified_info{rename}->{$script};
2034            }
2035            $unified_info{install}->{scripts}->{$script} = 1;
2036        }
2037
2038        foreach (@extra) {
2039            my $extra = cleanfile($buildd, $_, $blddir);
2040            $unified_info{extra}->{$extra} = 1;
2041        }
2042
2043        foreach (@overrides) {
2044            my $override = cleanfile($buildd, $_, $blddir);
2045            $unified_info{overrides}->{$override} = 1;
2046        }
2047
2048        push @{$unified_info{rawlines}}, @rawlines;
2049
2050        unless ($disabled{shared}) {
2051            # Check sharednames.
2052            foreach (keys %sharednames) {
2053                my $dest = cleanfile($buildd, $_, $blddir);
2054                if ($unified_info{rename}->{$dest}) {
2055                    $dest = $unified_info{rename}->{$dest};
2056                }
2057                die "shared_name for $dest with multiple values: "
2058                    ,join(" ", @{$sharednames{$_}}),"\n"
2059                    if scalar @{$sharednames{$_}} > 1;
2060                my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
2061                die "shared_name found for a library $dest that isn't defined\n"
2062                    unless $unified_info{libraries}->{$dest};
2063                die "shared_name for $dest with multiple values: "
2064                    ,$unified_info{sharednames}->{$dest}, ", ", $to
2065                    unless !defined($unified_info{sharednames}->{$dest})
2066                    or $unified_info{sharednames}->{$dest} eq $to;
2067                $unified_info{sharednames}->{$dest} = $to;
2068            }
2069
2070            # Additionally, we set up sharednames for libraries that don't
2071            # have any, as themselves.  Only for libraries that aren't
2072            # explicitly static.
2073            foreach (grep !/\.a$/, keys %{$unified_info{libraries}}) {
2074                if (!defined $unified_info{sharednames}->{$_}) {
2075                    $unified_info{sharednames}->{$_} = $_
2076                }
2077            }
2078
2079            # Check that we haven't defined any library as both shared and
2080            # explicitly static.  That is forbidden.
2081            my @doubles = ();
2082            foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
2083                (my $l = $_) =~ s/\.a$//;
2084                push @doubles, $l if defined $unified_info{sharednames}->{$l};
2085            }
2086            die "these libraries are both explicitly static and shared:\n  ",
2087                join(" ", @doubles), "\n"
2088                if @doubles;
2089        }
2090
2091        foreach (keys %sources) {
2092            my $dest = $_;
2093            my $ddest = cleanfile($buildd, $_, $blddir);
2094            if ($unified_info{rename}->{$ddest}) {
2095                $ddest = $unified_info{rename}->{$ddest};
2096            }
2097            foreach (@{$sources{$dest}}) {
2098                my $s = cleanfile($sourced, $_, $blddir);
2099
2100                # If it isn't in the source tree, we assume it's generated
2101                # in the build tree
2102                if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2103                    $s = cleanfile($buildd, $_, $blddir);
2104                }
2105                # We recognise C++, C and asm files
2106                if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2107                    my $o = $_;
2108                    $o =~ s/\.[csS]$/.o/; # C and assembler
2109                    $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2110                    $o = cleanfile($buildd, $o, $blddir);
2111                    $unified_info{sources}->{$ddest}->{$o} = 1;
2112                    $unified_info{sources}->{$o}->{$s} = 1;
2113                } elsif ($s =~ /\.rc$/) {
2114                    # We also recognise resource files
2115                    my $o = $_;
2116                    $o =~ s/\.rc$/.res/; # Resource configuration
2117                    my $o = cleanfile($buildd, $o, $blddir);
2118                    $unified_info{sources}->{$ddest}->{$o} = 1;
2119                    $unified_info{sources}->{$o}->{$s} = 1;
2120                } else {
2121                    $unified_info{sources}->{$ddest}->{$s} = 1;
2122                }
2123            }
2124        }
2125
2126        foreach (keys %shared_sources) {
2127            my $dest = $_;
2128            my $ddest = cleanfile($buildd, $_, $blddir);
2129            if ($unified_info{rename}->{$ddest}) {
2130                $ddest = $unified_info{rename}->{$ddest};
2131            }
2132            foreach (@{$shared_sources{$dest}}) {
2133                my $s = cleanfile($sourced, $_, $blddir);
2134
2135                # If it isn't in the source tree, we assume it's generated
2136                # in the build tree
2137                if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2138                    $s = cleanfile($buildd, $_, $blddir);
2139                }
2140
2141                if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2142                    # We recognise C++, C and asm files
2143                    my $o = $_;
2144                    $o =~ s/\.[csS]$/.o/; # C and assembler
2145                    $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2146                    $o = cleanfile($buildd, $o, $blddir);
2147                    $unified_info{shared_sources}->{$ddest}->{$o} = 1;
2148                    $unified_info{sources}->{$o}->{$s} = 1;
2149                } elsif ($s =~ /\.rc$/) {
2150                    # We also recognise resource files
2151                    my $o = $_;
2152                    $o =~ s/\.rc$/.res/; # Resource configuration
2153                    my $o = cleanfile($buildd, $o, $blddir);
2154                    $unified_info{shared_sources}->{$ddest}->{$o} = 1;
2155                    $unified_info{sources}->{$o}->{$s} = 1;
2156                } elsif ($s =~ /\.(def|map|opt)$/) {
2157                    # We also recognise .def / .map / .opt files
2158                    # We know they are generated files
2159                    my $def = cleanfile($buildd, $s, $blddir);
2160                    $unified_info{shared_sources}->{$ddest}->{$def} = 1;
2161                } else {
2162                    die "unrecognised source file type for shared library: $s\n";
2163                }
2164            }
2165        }
2166
2167        foreach (keys %generate) {
2168            my $dest = $_;
2169            my $ddest = cleanfile($buildd, $_, $blddir);
2170            if ($unified_info{rename}->{$ddest}) {
2171                $ddest = $unified_info{rename}->{$ddest};
2172            }
2173            die "more than one generator for $dest: "
2174                    ,join(" ", @{$generate{$_}}),"\n"
2175                    if scalar @{$generate{$_}} > 1;
2176            my @generator = split /\s+/, $generate{$dest}->[0];
2177            $generator[0] = cleanfile($sourced, $generator[0], $blddir),
2178            $unified_info{generate}->{$ddest} = [ @generator ];
2179        }
2180
2181        foreach (keys %depends) {
2182            my $dest = $_;
2183            my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
2184
2185            # If the destination doesn't exist in source, it can only be
2186            # a generated file in the build tree.
2187            if ($ddest ne "" && ($ddest eq $src_configdata || ! -f $ddest)) {
2188                $ddest = cleanfile($buildd, $_, $blddir);
2189                if ($unified_info{rename}->{$ddest}) {
2190                    $ddest = $unified_info{rename}->{$ddest};
2191                }
2192            }
2193            foreach (@{$depends{$dest}}) {
2194                my $d = cleanfile($sourced, $_, $blddir);
2195
2196                # If we know it's generated, or assume it is because we can't
2197                # find it in the source tree, we set file we depend on to be
2198                # in the build tree rather than the source tree, and assume
2199                # and that there are lines to build it in a BEGINRAW..ENDRAW
2200                # section or in the Makefile template.
2201                if ($d eq $src_configdata
2202                    || ! -f $d
2203                    || (grep { $d eq $_ }
2204                        map { cleanfile($srcdir, $_, $blddir) }
2205                        grep { /\.h$/ } keys %{$unified_info{generate}})) {
2206                    $d = cleanfile($buildd, $_, $blddir);
2207                }
2208                # Take note if the file to depend on is being renamed
2209                # Take extra care with files ending with .a, they should
2210                # be treated without that extension, and the extension
2211                # should be added back after treatment.
2212                $d =~ /(\.a)?$/;
2213                my $e = $1 // "";
2214                $d = $`;
2215                if ($unified_info{rename}->{$d}) {
2216                    $d = $unified_info{rename}->{$d};
2217                }
2218                $d .= $e;
2219                $unified_info{depends}->{$ddest}->{$d} = 1;
2220            }
2221        }
2222
2223        foreach (keys %includes) {
2224            my $dest = $_;
2225            my $ddest = cleanfile($sourced, $_, $blddir);
2226
2227            # If the destination doesn't exist in source, it can only be
2228            # a generated file in the build tree.
2229            if ($ddest eq $src_configdata || ! -f $ddest) {
2230                $ddest = cleanfile($buildd, $_, $blddir);
2231                if ($unified_info{rename}->{$ddest}) {
2232                    $ddest = $unified_info{rename}->{$ddest};
2233                }
2234            }
2235            foreach (@{$includes{$dest}}) {
2236                my $is = cleandir($sourced, $_, $blddir);
2237                my $ib = cleandir($buildd, $_, $blddir);
2238                push @{$unified_info{includes}->{$ddest}->{source}}, $is
2239                    unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2240                push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2241                    unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
2242            }
2243        }
2244    }
2245
2246    my $ordinals_text = join(', ', sort keys %ordinals);
2247    warn <<"EOF" if $ordinals_text;
2248
2249WARNING: ORDINALS were specified for $ordinals_text
2250They are ignored and should be replaced with a combination of GENERATE,
2251DEPEND and SHARED_SOURCE.
2252EOF
2253
2254    # Massage the result
2255
2256    # If the user configured no-shared, we allow no shared sources
2257    if ($disabled{shared}) {
2258        foreach (keys %{$unified_info{shared_sources}}) {
2259            foreach (keys %{$unified_info{shared_sources}->{$_}}) {
2260                delete $unified_info{sources}->{$_};
2261            }
2262        }
2263        $unified_info{shared_sources} = {};
2264    }
2265
2266    # If we depend on a header file or a perl module, add an inclusion of
2267    # its directory to allow smoothe inclusion
2268    foreach my $dest (keys %{$unified_info{depends}}) {
2269        next if $dest eq "";
2270        foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2271            next unless $d =~ /\.(h|pm)$/;
2272            my $i = dirname($d);
2273            my $spot =
2274                $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2275                ? 'build' : 'source';
2276            push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2277                unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
2278        }
2279    }
2280
2281    # Trickle down includes placed on libraries, engines and programs to
2282    # their sources (i.e. object files)
2283    foreach my $dest (keys %{$unified_info{engines}},
2284                      keys %{$unified_info{libraries}},
2285                      keys %{$unified_info{programs}}) {
2286        foreach my $k (("source", "build")) {
2287            next unless defined($unified_info{includes}->{$dest}->{$k});
2288            my @incs = reverse @{$unified_info{includes}->{$dest}->{$k}};
2289            foreach my $obj (grep /\.o$/,
2290                             (keys %{$unified_info{sources}->{$dest} // {}},
2291                              keys %{$unified_info{shared_sources}->{$dest} // {}})) {
2292                foreach my $inc (@incs) {
2293                    unshift @{$unified_info{includes}->{$obj}->{$k}}, $inc
2294                        unless grep { $_ eq $inc } @{$unified_info{includes}->{$obj}->{$k}};
2295                }
2296            }
2297        }
2298        delete $unified_info{includes}->{$dest};
2299    }
2300
2301    ### Make unified_info a bit more efficient
2302    # One level structures
2303    foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
2304        $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2305    }
2306    # Two level structures
2307    foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
2308        foreach my $l2 (sort keys %{$unified_info{$l1}}) {
2309            $unified_info{$l1}->{$l2} =
2310                [ sort keys %{$unified_info{$l1}->{$l2}} ];
2311        }
2312    }
2313    # Includes
2314    foreach my $dest (sort keys %{$unified_info{includes}}) {
2315        if (defined($unified_info{includes}->{$dest}->{build})) {
2316            my @source_includes = ();
2317            @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2318                if defined($unified_info{includes}->{$dest}->{source});
2319            $unified_info{includes}->{$dest} =
2320                [ @{$unified_info{includes}->{$dest}->{build}} ];
2321            foreach my $inc (@source_includes) {
2322                push @{$unified_info{includes}->{$dest}}, $inc
2323                    unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2324            }
2325        } else {
2326            $unified_info{includes}->{$dest} =
2327                [ @{$unified_info{includes}->{$dest}->{source}} ];
2328        }
2329    }
2330
2331    # For convenience collect information regarding directories where
2332    # files are generated, those generated files and the end product
2333    # they end up in where applicable.  Then, add build rules for those
2334    # directories
2335    my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
2336                     "dso" => [ @{$unified_info{engines}} ],
2337                     "bin" => [ @{$unified_info{programs}} ],
2338                     "script" => [ @{$unified_info{scripts}} ] );
2339    foreach my $type (keys %loopinfo) {
2340        foreach my $product (@{$loopinfo{$type}}) {
2341            my %dirs = ();
2342            my $pd = dirname($product);
2343
2344            foreach (@{$unified_info{sources}->{$product} // []},
2345                     @{$unified_info{shared_sources}->{$product} // []}) {
2346                my $d = dirname($_);
2347
2348                # We don't want to create targets for source directories
2349                # when building out of source
2350                next if ($config{sourcedir} ne $config{builddir}
2351                             && $d =~ m|^\Q$config{sourcedir}\E|);
2352                # We already have a "test" target, and the current directory
2353                # is just silly to make a target for
2354                next if $d eq "test" || $d eq ".";
2355
2356                $dirs{$d} = 1;
2357                push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2358                    if $d ne $pd;
2359            }
2360            foreach (keys %dirs) {
2361                push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2362                    $product;
2363            }
2364        }
2365    }
2366}
2367
2368# For the schemes that need it, we provide the old *_obj configs
2369# from the *_asm_obj ones
2370foreach (grep /_(asm|aux)_src$/, keys %target) {
2371    my $src = $_;
2372    (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2373    $target{$obj} = $target{$src};
2374    $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2375    $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2376}
2377
2378# Write down our configuration where it fits #########################
2379
2380print "Creating configdata.pm\n";
2381open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
2382print OUT <<"EOF";
2383#! $config{HASHBANGPERL}
2384
2385package configdata;
2386
2387use strict;
2388use warnings;
2389
2390use Exporter;
2391#use vars qw(\@ISA \@EXPORT);
2392our \@ISA = qw(Exporter);
2393our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
2394
2395EOF
2396print OUT "our %config = (\n";
2397foreach (sort keys %config) {
2398    if (ref($config{$_}) eq "ARRAY") {
2399        print OUT "  ", $_, " => [ ", join(", ",
2400                                           map { quotify("perl", $_) }
2401                                           @{$config{$_}}), " ],\n";
2402    } elsif (ref($config{$_}) eq "HASH") {
2403        print OUT "  ", $_, " => {";
2404        if (scalar keys %{$config{$_}} > 0) {
2405            print OUT "\n";
2406            foreach my $key (sort keys %{$config{$_}}) {
2407                print OUT "      ",
2408                    join(" => ",
2409                         quotify("perl", $key),
2410                         defined $config{$_}->{$key}
2411                             ? quotify("perl", $config{$_}->{$key})
2412                             : "undef");
2413                print OUT ",\n";
2414            }
2415            print OUT "  ";
2416        }
2417        print OUT "},\n";
2418    } else {
2419        print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
2420    }
2421}
2422print OUT <<"EOF";
2423);
2424
2425EOF
2426print OUT "our %target = (\n";
2427foreach (sort keys %target) {
2428    if (ref($target{$_}) eq "ARRAY") {
2429        print OUT "  ", $_, " => [ ", join(", ",
2430                                           map { quotify("perl", $_) }
2431                                           @{$target{$_}}), " ],\n";
2432    } else {
2433        print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
2434    }
2435}
2436print OUT <<"EOF";
2437);
2438
2439EOF
2440print OUT "our \%available_protocols = (\n";
2441print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
2442print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
2443print OUT <<"EOF";
2444);
2445
2446EOF
2447print OUT "our \@disablables = (\n";
2448foreach (@disablables) {
2449    print OUT "  ", quotify("perl", $_), ",\n";
2450}
2451print OUT <<"EOF";
2452);
2453
2454EOF
2455print OUT "our \%disabled = (\n";
2456foreach (sort keys %disabled) {
2457    print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
2458}
2459print OUT <<"EOF";
2460);
2461
2462EOF
2463print OUT "our %withargs = (\n";
2464foreach (sort keys %withargs) {
2465    if (ref($withargs{$_}) eq "ARRAY") {
2466        print OUT "  ", $_, " => [ ", join(", ",
2467                                           map { quotify("perl", $_) }
2468                                           @{$withargs{$_}}), " ],\n";
2469    } else {
2470        print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
2471    }
2472}
2473print OUT <<"EOF";
2474);
2475
2476EOF
2477if ($builder eq "unified") {
2478    my $recurse;
2479    $recurse = sub {
2480        my $indent = shift;
2481        foreach (@_) {
2482            if (ref $_ eq "ARRAY") {
2483                print OUT " "x$indent, "[\n";
2484                foreach (@$_) {
2485                    $recurse->($indent + 4, $_);
2486                }
2487                print OUT " "x$indent, "],\n";
2488            } elsif (ref $_ eq "HASH") {
2489                my %h = %$_;
2490                print OUT " "x$indent, "{\n";
2491                foreach (sort keys %h) {
2492                    if (ref $h{$_} eq "") {
2493                        print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2494                    } else {
2495                        print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2496                        $recurse->($indent + 8, $h{$_});
2497                    }
2498                }
2499                print OUT " "x$indent, "},\n";
2500            } else {
2501                print OUT " "x$indent, quotify("perl", $_), ",\n";
2502            }
2503        }
2504    };
2505    print OUT "our %unified_info = (\n";
2506    foreach (sort keys %unified_info) {
2507        if (ref $unified_info{$_} eq "") {
2508            print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2509        } else {
2510            print OUT " "x4, quotify("perl", $_), " =>\n";
2511            $recurse->(8, $unified_info{$_});
2512        }
2513    }
2514    print OUT <<"EOF";
2515);
2516
2517EOF
2518}
2519print OUT
2520    "# The following data is only used when this files is use as a script\n";
2521print OUT "my \@makevars = (\n";
2522foreach (sort keys %user) {
2523    print OUT "    '",$_,"',\n";
2524}
2525print OUT ");\n";
2526print OUT "my \%disabled_info = (\n";
2527foreach my $what (sort keys %disabled_info) {
2528    print OUT "    '$what' => {\n";
2529    foreach my $info (sort keys %{$disabled_info{$what}}) {
2530        if (ref $disabled_info{$what}->{$info} eq 'ARRAY') {
2531            print OUT "        $info => [ ",
2532                join(', ', map { "'$_'" } @{$disabled_info{$what}->{$info}}),
2533                " ],\n";
2534        } else {
2535            print OUT "        $info => '", $disabled_info{$what}->{$info},
2536                "',\n";
2537        }
2538    }
2539    print OUT "    },\n";
2540}
2541print OUT ");\n";
2542print OUT 'my @user_crossable = qw( ', join (' ', @user_crossable), " );\n";
2543print OUT << 'EOF';
2544# If run directly, we can give some answers, and even reconfigure
2545unless (caller) {
2546    use Getopt::Long;
2547    use File::Spec::Functions;
2548    use File::Basename;
2549    use Pod::Usage;
2550
2551    my $here = dirname($0);
2552
2553    my $dump = undef;
2554    my $cmdline = undef;
2555    my $options = undef;
2556    my $target = undef;
2557    my $envvars = undef;
2558    my $makevars = undef;
2559    my $buildparams = undef;
2560    my $reconf = undef;
2561    my $verbose = undef;
2562    my $help = undef;
2563    my $man = undef;
2564    GetOptions('dump|d'                 => \$dump,
2565               'command-line|c'         => \$cmdline,
2566               'options|o'              => \$options,
2567               'target|t'               => \$target,
2568               'environment|e'          => \$envvars,
2569               'make-variables|m'       => \$makevars,
2570               'build-parameters|b'     => \$buildparams,
2571               'reconfigure|reconf|r'   => \$reconf,
2572               'verbose|v'              => \$verbose,
2573               'help'                   => \$help,
2574               'man'                    => \$man)
2575        or die "Errors in command line arguments\n";
2576
2577    unless ($dump || $cmdline || $options || $target || $envvars || $makevars
2578            || $buildparams || $reconf || $verbose || $help || $man) {
2579        print STDERR <<"_____";
2580You must give at least one option.
2581For more information, do '$0 --help'
2582_____
2583        exit(2);
2584    }
2585
2586    if ($help) {
2587        pod2usage(-exitval => 0,
2588                  -verbose => 1);
2589    }
2590    if ($man) {
2591        pod2usage(-exitval => 0,
2592                  -verbose => 2);
2593    }
2594    if ($dump || $cmdline) {
2595        print "\nCommand line (with current working directory = $here):\n\n";
2596        print '    ',join(' ',
2597                          $config{PERL},
2598                          catfile($config{sourcedir}, 'Configure'),
2599                          @{$config{perlargv}}), "\n";
2600        print "\nPerl information:\n\n";
2601        print '    ',$config{perl_cmd},"\n";
2602        print '    ',$config{perl_version},' for ',$config{perl_archname},"\n";
2603    }
2604    if ($dump || $options) {
2605        my $longest = 0;
2606        my $longest2 = 0;
2607        foreach my $what (@disablables) {
2608            $longest = length($what) if $longest < length($what);
2609            $longest2 = length($disabled{$what})
2610                if $disabled{$what} && $longest2 < length($disabled{$what});
2611        }
2612        print "\nEnabled features:\n\n";
2613        foreach my $what (@disablables) {
2614            print "    $what\n"
2615                unless grep { $_ =~ /^${what}$/ } keys %disabled;
2616        }
2617        print "\nDisabled features:\n\n";
2618        foreach my $what (@disablables) {
2619            my @what2 = grep { $_ =~ /^${what}$/ } keys %disabled;
2620            my $what3 = $what2[0];
2621            if ($what3) {
2622                print "    $what3", ' ' x ($longest - length($what3) + 1),
2623                    "[$disabled{$what3}]", ' ' x ($longest2 - length($disabled{$what3}) + 1);
2624                print $disabled_info{$what3}->{macro}
2625                    if $disabled_info{$what3}->{macro};
2626                print ' (skip ',
2627                    join(', ', @{$disabled_info{$what3}->{skipped}}),
2628                    ')'
2629                    if $disabled_info{$what3}->{skipped};
2630                print "\n";
2631            }
2632        }
2633    }
2634    if ($dump || $target) {
2635        print "\nConfig target attributes:\n\n";
2636        foreach (sort keys %target) {
2637            next if $_ =~ m|^_| || $_ eq 'template';
2638            my $quotify = sub {
2639                map { (my $x = $_) =~ s|([\\\$\@"])|\\$1|g; "\"$x\""} @_;
2640            };
2641            print '    ', $_, ' => ';
2642            if (ref($target{$_}) eq "ARRAY") {
2643                print '[ ', join(', ', $quotify->(@{$target{$_}})), " ],\n";
2644            } else {
2645                print $quotify->($target{$_}), ",\n"
2646            }
2647        }
2648    }
2649    if ($dump || $envvars) {
2650        print "\nRecorded environment:\n\n";
2651        foreach (sort keys %{$config{perlenv}}) {
2652            print '    ',$_,' = ',($config{perlenv}->{$_} || ''),"\n";
2653        }
2654    }
2655    if ($dump || $makevars) {
2656        print "\nMakevars:\n\n";
2657        foreach my $var (@makevars) {
2658            my $prefix = '';
2659            $prefix = $config{CROSS_COMPILE}
2660                if grep { $var eq $_ } @user_crossable;
2661            $prefix //= '';
2662            print '    ',$var,' ' x (16 - length $var),'= ',
2663                (ref $config{$var} eq 'ARRAY'
2664                 ? join(' ', @{$config{$var}})
2665                 : $prefix.$config{$var}),
2666                "\n"
2667                if defined $config{$var};
2668        }
2669
2670        my @buildfile = ($config{builddir}, $config{build_file});
2671        unshift @buildfile, $here
2672            unless file_name_is_absolute($config{builddir});
2673        my $buildfile = canonpath(catdir(@buildfile));
2674        print <<"_____";
2675
2676NOTE: These variables only represent the configuration view.  The build file
2677template may have processed these variables further, please have a look at the
2678build file for more exact data:
2679    $buildfile
2680_____
2681    }
2682    if ($dump || $buildparams) {
2683        my @buildfile = ($config{builddir}, $config{build_file});
2684        unshift @buildfile, $here
2685            unless file_name_is_absolute($config{builddir});
2686        print "\nbuild file:\n\n";
2687        print "    ", canonpath(catfile(@buildfile)),"\n";
2688
2689        print "\nbuild file templates:\n\n";
2690        foreach (@{$config{build_file_templates}}) {
2691            my @tmpl = ($_);
2692            unshift @tmpl, $here
2693                unless file_name_is_absolute($config{sourcedir});
2694            print '    ',canonpath(catfile(@tmpl)),"\n";
2695        }
2696    }
2697    if ($reconf) {
2698        if ($verbose) {
2699            print 'Reconfiguring with: ', join(' ',@{$config{perlargv}}), "\n";
2700            foreach (sort keys %{$config{perlenv}}) {
2701                print '    ',$_,' = ',($config{perlenv}->{$_} || ""),"\n";
2702            }
2703        }
2704
2705        chdir $here;
2706        exec $^X,catfile($config{sourcedir}, 'Configure'),'reconf';
2707    }
2708}
2709
27101;
2711
2712__END__
2713
2714=head1 NAME
2715
2716configdata.pm - configuration data for OpenSSL builds
2717
2718=head1 SYNOPSIS
2719
2720Interactive:
2721
2722  perl configdata.pm [options]
2723
2724As data bank module:
2725
2726  use configdata;
2727
2728=head1 DESCRIPTION
2729
2730This module can be used in two modes, interactively and as a module containing
2731all the data recorded by OpenSSL's Configure script.
2732
2733When used interactively, simply run it as any perl script, with at least one
2734option, and you will get the information you ask for.  See L</OPTIONS> below.
2735
2736When loaded as a module, you get a few databanks with useful information to
2737perform build related tasks.  The databanks are:
2738
2739    %config             Configured things.
2740    %target             The OpenSSL config target with all inheritances
2741                        resolved.
2742    %disabled           The features that are disabled.
2743    @disablables        The list of features that can be disabled.
2744    %withargs           All data given through --with-THING options.
2745    %unified_info       All information that was computed from the build.info
2746                        files.
2747
2748=head1 OPTIONS
2749
2750=over 4
2751
2752=item B<--help>
2753
2754Print a brief help message and exit.
2755
2756=item B<--man>
2757
2758Print the manual page and exit.
2759
2760=item B<--dump> | B<-d>
2761
2762Print all relevant configuration data.  This is equivalent to B<--command-line>
2763B<--options> B<--target> B<--environment> B<--make-variables>
2764B<--build-parameters>.
2765
2766=item B<--command-line> | B<-c>
2767
2768Print the current configuration command line.
2769
2770=item B<--options> | B<-o>
2771
2772Print the features, both enabled and disabled, and display defined macro and
2773skipped directories where applicable.
2774
2775=item B<--target> | B<-t>
2776
2777Print the config attributes for this config target.
2778
2779=item B<--environment> | B<-e>
2780
2781Print the environment variables and their values at the time of configuration.
2782
2783=item B<--make-variables> | B<-m>
2784
2785Print the main make variables generated in the current configuration
2786
2787=item B<--build-parameters> | B<-b>
2788
2789Print the build parameters, i.e. build file and build file templates.
2790
2791=item B<--reconfigure> | B<--reconf> | B<-r>
2792
2793Redo the configuration.
2794
2795=item B<--verbose> | B<-v>
2796
2797Verbose output.
2798
2799=back
2800
2801=cut
2802
2803EOF
2804close(OUT);
2805if ($builder_platform eq 'unix') {
2806    my $mode = (0755 & ~umask);
2807    chmod $mode, 'configdata.pm'
2808        or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2809}
2810
2811my %builders = (
2812    unified => sub {
2813        print 'Creating ',$target{build_file},"\n";
2814        run_dofile(catfile($blddir, $target{build_file}),
2815                   @{$config{build_file_templates}});
2816    },
2817    );
2818
2819$builders{$builder}->($builder_platform, @builder_opts);
2820
2821$SIG{__DIE__} = $orig_death_handler;
2822
2823print <<"EOF" if ($disabled{threads} eq "unavailable");
2824
2825The library could not be configured for supporting multi-threaded
2826applications as the compiler options required on this system are not known.
2827See file INSTALL for details if you need multi-threading.
2828EOF
2829
2830print <<"EOF" if ($no_shared_warn);
2831
2832The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2833platform, so we will pretend you gave the option 'no-pic', which also disables
2834'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
2835or position independent code, please let us know (but please first make sure
2836you have tried with a current version of OpenSSL).
2837EOF
2838
2839print <<"EOF";
2840
2841**********************************************************************
2842***                                                                ***
2843***   OpenSSL has been successfully configured                     ***
2844***                                                                ***
2845***   If you encounter a problem while building, please open an    ***
2846***   issue on GitHub <https://github.com/openssl/openssl/issues>  ***
2847***   and include the output from the following command:           ***
2848***                                                                ***
2849***       perl configdata.pm --dump                                ***
2850***                                                                ***
2851***   (If you are new to OpenSSL, you might want to consult the    ***
2852***   'Troubleshooting' section in the INSTALL file first)         ***
2853***                                                                ***
2854**********************************************************************
2855EOF
2856
2857exit(0);
2858
2859######################################################################
2860#
2861# Helpers and utility functions
2862#
2863
2864# Death handler, to print a helpful message in case of failure #######
2865#
2866sub death_handler {
2867    die @_ if $^S;              # To prevent the added message in eval blocks
2868    my $build_file = $target{build_file} // "build file";
2869    my @message = ( <<"_____", @_ );
2870
2871Failure!  $build_file wasn't produced.
2872Please read INSTALL and associated NOTES files.  You may also have to look over
2873your available compiler tool chain or change your configuration.
2874
2875_____
2876
2877    # Dying is terminal, so it's ok to reset the signal handler here.
2878    $SIG{__DIE__} = $orig_death_handler;
2879    die @message;
2880}
2881
2882# Configuration file reading #########################################
2883
2884# Note: All of the helper functions are for lazy evaluation.  They all
2885# return a CODE ref, which will return the intended value when evaluated.
2886# Thus, whenever there's mention of a returned value, it's about that
2887# intended value.
2888
2889# Helper function to implement conditional inheritance depending on the
2890# value of $disabled{asm}.  Used in inherit_from values as follows:
2891#
2892#      inherit_from => [ "template", asm("asm_tmpl") ]
2893#
2894sub asm {
2895    my @x = @_;
2896    sub {
2897        $disabled{asm} ? () : @x;
2898    }
2899}
2900
2901# Helper function to implement conditional value variants, with a default
2902# plus additional values based on the value of $config{build_type}.
2903# Arguments are given in hash table form:
2904#
2905#       picker(default => "Basic string: ",
2906#              debug   => "debug",
2907#              release => "release")
2908#
2909# When configuring with --debug, the resulting string will be
2910# "Basic string: debug", and when not, it will be "Basic string: release"
2911#
2912# This can be used to create variants of sets of flags according to the
2913# build type:
2914#
2915#       cflags => picker(default => "-Wall",
2916#                        debug   => "-g -O0",
2917#                        release => "-O3")
2918#
2919sub picker {
2920    my %opts = @_;
2921    return sub { add($opts{default} || (),
2922                     $opts{$config{build_type}} || ())->(); }
2923}
2924
2925# Helper function to combine several values of different types into one.
2926# This is useful if you want to combine a string with the result of a
2927# lazy function, such as:
2928#
2929#       cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2930#
2931sub combine {
2932    my @stuff = @_;
2933    return sub { add(@stuff)->(); }
2934}
2935
2936# Helper function to implement conditional values depending on the value
2937# of $disabled{threads}.  Can be used as follows:
2938#
2939#       cflags => combine("-Wall", threads("-pthread"))
2940#
2941sub threads {
2942    my @flags = @_;
2943    return sub { add($disabled{threads} ? () : @flags)->(); }
2944}
2945
2946sub shared {
2947    my @flags = @_;
2948    return sub { add($disabled{shared} ? () : @flags)->(); }
2949}
2950
2951our $add_called = 0;
2952# Helper function to implement adding values to already existing configuration
2953# values.  It handles elements that are ARRAYs, CODEs and scalars
2954sub _add {
2955    my $separator = shift;
2956
2957    # If there's any ARRAY in the collection of values OR the separator
2958    # is undef, we will return an ARRAY of combined values, otherwise a
2959    # string of joined values with $separator as the separator.
2960    my $found_array = !defined($separator);
2961
2962    my @values =
2963        map {
2964            my $res = $_;
2965            while (ref($res) eq "CODE") {
2966                $res = $res->();
2967            }
2968            if (defined($res)) {
2969                if (ref($res) eq "ARRAY") {
2970                    $found_array = 1;
2971                    @$res;
2972                } else {
2973                    $res;
2974                }
2975            } else {
2976                ();
2977            }
2978    } (@_);
2979
2980    $add_called = 1;
2981
2982    if ($found_array) {
2983        [ @values ];
2984    } else {
2985        join($separator, grep { defined($_) && $_ ne "" } @values);
2986    }
2987}
2988sub add_before {
2989    my $separator = " ";
2990    if (ref($_[$#_]) eq "HASH") {
2991        my $opts = pop;
2992        $separator = $opts->{separator};
2993    }
2994    my @x = @_;
2995    sub { _add($separator, @x, @_) };
2996}
2997sub add {
2998    my $separator = " ";
2999    if (ref($_[$#_]) eq "HASH") {
3000        my $opts = pop;
3001        $separator = $opts->{separator};
3002    }
3003    my @x = @_;
3004    sub { _add($separator, @_, @x) };
3005}
3006
3007sub read_eval_file {
3008    my $fname = shift;
3009    my $content;
3010    my @result;
3011
3012    open F, "< $fname" or die "Can't open '$fname': $!\n";
3013    {
3014        undef local $/;
3015        $content = <F>;
3016    }
3017    close F;
3018    {
3019        local $@;
3020
3021        @result = ( eval $content );
3022        warn $@ if $@;
3023    }
3024    return wantarray ? @result : $result[0];
3025}
3026
3027# configuration reader, evaluates the input file as a perl script and expects
3028# it to fill %targets with target configurations.  Those are then added to
3029# %table.
3030sub read_config {
3031    my $fname = shift;
3032    my %targets;
3033
3034    {
3035        # Protect certain tables from tampering
3036        local %table = ();
3037
3038        %targets = read_eval_file($fname);
3039    }
3040    my %preexisting = ();
3041    foreach (sort keys %targets) {
3042        $preexisting{$_} = 1 if $table{$_};
3043    }
3044    die <<"EOF",
3045The following config targets from $fname
3046shadow pre-existing config targets with the same name:
3047EOF
3048        map { "  $_\n" } sort keys %preexisting
3049        if %preexisting;
3050
3051
3052    # For each target, check that it's configured with a hash table.
3053    foreach (keys %targets) {
3054        if (ref($targets{$_}) ne "HASH") {
3055            if (ref($targets{$_}) eq "") {
3056                warn "Deprecated target configuration for $_, ignoring...\n";
3057            } else {
3058                warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3059            }
3060            delete $targets{$_};
3061        } else {
3062            $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3063        }
3064    }
3065
3066    %table = (%table, %targets);
3067
3068}
3069
3070# configuration resolver.  Will only resolve all the lazy evaluation
3071# codeblocks for the chosen target and all those it inherits from,
3072# recursively
3073sub resolve_config {
3074    my $target = shift;
3075    my @breadcrumbs = @_;
3076
3077#    my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
3078
3079    if (grep { $_ eq $target } @breadcrumbs) {
3080        die "inherit_from loop!  target backtrace:\n  "
3081            ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
3082    }
3083
3084    if (!defined($table{$target})) {
3085        warn "Warning! target $target doesn't exist!\n";
3086        return ();
3087    }
3088    # Recurse through all inheritances.  They will be resolved on the
3089    # fly, so when this operation is done, they will all just be a
3090    # bunch of attributes with string values.
3091    # What we get here, though, are keys with references to lists of
3092    # the combined values of them all.  We will deal with lists after
3093    # this stage is done.
3094    my %combined_inheritance = ();
3095    if ($table{$target}->{inherit_from}) {
3096        my @inherit_from =
3097            map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3098        foreach (@inherit_from) {
3099            my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3100
3101            # 'template' is a marker that's considered private to
3102            # the config that had it.
3103            delete $inherited_config{template};
3104
3105            foreach (keys %inherited_config) {
3106                if (!$combined_inheritance{$_}) {
3107                    $combined_inheritance{$_} = [];
3108                }
3109                push @{$combined_inheritance{$_}}, $inherited_config{$_};
3110            }
3111        }
3112    }
3113
3114    # We won't need inherit_from in this target any more, since we've
3115    # resolved all the inheritances that lead to this
3116    delete $table{$target}->{inherit_from};
3117
3118    # Now is the time to deal with those lists.  Here's the place to
3119    # decide what shall be done with those lists, all based on the
3120    # values of the target we're currently dealing with.
3121    # - If a value is a coderef, it will be executed with the list of
3122    #   inherited values as arguments.
3123    # - If the corresponding key doesn't have a value at all or is the
3124    #   empty string, the inherited value list will be run through the
3125    #   default combiner (below), and the result becomes this target's
3126    #   value.
3127    # - Otherwise, this target's value is assumed to be a string that
3128    #   will simply override the inherited list of values.
3129    my $default_combiner = add();
3130
3131    my %all_keys =
3132        map { $_ => 1 } (keys %combined_inheritance,
3133                         keys %{$table{$target}});
3134
3135    sub process_values {
3136        my $object    = shift;
3137        my $inherited = shift;  # Always a [ list ]
3138        my $target    = shift;
3139        my $entry     = shift;
3140
3141        $add_called = 0;
3142
3143        while(ref($object) eq "CODE") {
3144            $object = $object->(@$inherited);
3145        }
3146        if (!defined($object)) {
3147            return ();
3148        }
3149        elsif (ref($object) eq "ARRAY") {
3150            local $add_called;  # To make sure recursive calls don't affect it
3151            return [ map { process_values($_, $inherited, $target, $entry) }
3152                     @$object ];
3153        } elsif (ref($object) eq "") {
3154            return $object;
3155        } else {
3156            die "cannot handle reference type ",ref($object)
3157                ," found in target ",$target," -> ",$entry,"\n";
3158        }
3159    }
3160
3161    foreach (sort keys %all_keys) {
3162        my $previous = $combined_inheritance{$_};
3163
3164        # Current target doesn't have a value for the current key?
3165        # Assign it the default combiner, the rest of this loop body
3166        # will handle it just like any other coderef.
3167        if (!exists $table{$target}->{$_}) {
3168            $table{$target}->{$_} = $default_combiner;
3169        }
3170
3171        $table{$target}->{$_} = process_values($table{$target}->{$_},
3172                                               $combined_inheritance{$_},
3173                                               $target, $_);
3174        unless(defined($table{$target}->{$_})) {
3175            delete $table{$target}->{$_};
3176        }
3177#        if ($extra_checks &&
3178#            $previous && !($add_called ||  $previous ~~ $table{$target}->{$_})) {
3179#            warn "$_ got replaced in $target\n";
3180#        }
3181    }
3182
3183    # Finally done, return the result.
3184    return %{$table{$target}};
3185}
3186
3187sub usage
3188        {
3189        print STDERR $usage;
3190        print STDERR "\npick os/compiler from:\n";
3191        my $j=0;
3192        my $i;
3193        my $k=0;
3194        foreach $i (sort keys %table)
3195                {
3196                next if $table{$i}->{template};
3197                next if $i =~ /^debug/;
3198                $k += length($i) + 1;
3199                if ($k > 78)
3200                        {
3201                        print STDERR "\n";
3202                        $k=length($i);
3203                        }
3204                print STDERR $i . " ";
3205                }
3206        foreach $i (sort keys %table)
3207                {
3208                next if $table{$i}->{template};
3209                next if $i !~ /^debug/;
3210                $k += length($i) + 1;
3211                if ($k > 78)
3212                        {
3213                        print STDERR "\n";
3214                        $k=length($i);
3215                        }
3216                print STDERR $i . " ";
3217                }
3218        print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
3219        exit(1);
3220        }
3221
3222sub run_dofile
3223{
3224    my $out = shift;
3225    my @templates = @_;
3226
3227    unlink $out || warn "Can't remove $out, $!"
3228        if -f $out;
3229    foreach (@templates) {
3230        die "Can't open $_, $!" unless -f $_;
3231    }
3232    my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
3233    my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
3234    #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
3235    system($cmd);
3236    exit 1 if $? != 0;
3237    rename("$out.new", $out) || die "Can't rename $out.new, $!";
3238}
3239
3240sub compiler_predefined {
3241    state %predefined;
3242    my $cc = shift;
3243
3244    return () if $^O eq 'VMS';
3245
3246    die 'compiler_predefined called without a compiler command'
3247        unless $cc;
3248
3249    if (! $predefined{$cc}) {
3250
3251        $predefined{$cc} = {};
3252
3253        # collect compiler pre-defines from gcc or gcc-alike...
3254        open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
3255        while (my $l = <PIPE>) {
3256            $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
3257            $predefined{$cc}->{$1} = $2 // '';
3258        }
3259        close(PIPE);
3260    }
3261
3262    return %{$predefined{$cc}};
3263}
3264
3265sub which
3266{
3267    my ($name)=@_;
3268
3269    if (eval { require IPC::Cmd; 1; }) {
3270        IPC::Cmd->import();
3271        return scalar IPC::Cmd::can_run($name);
3272    } else {
3273        # if there is $directories component in splitpath,
3274        # then it's not something to test with $PATH...
3275        return $name if (File::Spec->splitpath($name))[1];
3276
3277        foreach (File::Spec->path()) {
3278            my $fullpath = catfile($_, "$name$target{exe_extension}");
3279            if (-f $fullpath and -x $fullpath) {
3280                return $fullpath;
3281            }
3282        }
3283    }
3284}
3285
3286sub env
3287{
3288    my $name = shift;
3289    my %opts = @_;
3290
3291    unless ($opts{cacheonly}) {
3292        # Note that if $ENV{$name} doesn't exist or is undefined,
3293        # $config{perlenv}->{$name} will be created with the value
3294        # undef.  This is intentional.
3295
3296        $config{perlenv}->{$name} = $ENV{$name}
3297            if ! exists $config{perlenv}->{$name};
3298    }
3299    return $config{perlenv}->{$name};
3300}
3301
3302# Configuration printer ##############################################
3303
3304sub print_table_entry
3305{
3306    local $now_printing = shift;
3307    my %target = resolve_config($now_printing);
3308    my $type = shift;
3309
3310    # Don't print the templates
3311    return if $target{template};
3312
3313    my @sequence = (
3314        "sys_id",
3315        "cpp",
3316        "cppflags",
3317        "defines",
3318        "includes",
3319        "cc",
3320        "cflags",
3321        "unistd",
3322        "ld",
3323        "lflags",
3324        "loutflag",
3325        "ex_libs",
3326        "bn_ops",
3327        "apps_aux_src",
3328        "cpuid_asm_src",
3329        "uplink_aux_src",
3330        "bn_asm_src",
3331        "ec_asm_src",
3332        "des_asm_src",
3333        "aes_asm_src",
3334        "bf_asm_src",
3335        "md5_asm_src",
3336        "cast_asm_src",
3337        "sha1_asm_src",
3338        "rc4_asm_src",
3339        "rmd160_asm_src",
3340        "rc5_asm_src",
3341        "wp_asm_src",
3342        "cmll_asm_src",
3343        "modes_asm_src",
3344        "padlock_asm_src",
3345        "chacha_asm_src",
3346        "poly1035_asm_src",
3347        "thread_scheme",
3348        "perlasm_scheme",
3349        "dso_scheme",
3350        "shared_target",
3351        "shared_cflag",
3352        "shared_defines",
3353        "shared_ldflag",
3354        "shared_rcflag",
3355        "shared_extension",
3356        "dso_extension",
3357        "obj_extension",
3358        "exe_extension",
3359        "ranlib",
3360        "ar",
3361        "arflags",
3362        "aroutflag",
3363        "rc",
3364        "rcflags",
3365        "rcoutflag",
3366        "mt",
3367        "mtflags",
3368        "mtinflag",
3369        "mtoutflag",
3370        "multilib",
3371        "build_scheme",
3372        );
3373
3374    if ($type eq "TABLE") {
3375        print "\n";
3376        print "*** $now_printing\n";
3377        foreach (@sequence) {
3378            if (ref($target{$_}) eq "ARRAY") {
3379                printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3380            } else {
3381                printf "\$%-12s = %s\n", $_, $target{$_};
3382            }
3383        }
3384    } elsif ($type eq "HASH") {
3385        my $largest =
3386            length((sort { length($a) <=> length($b) } @sequence)[-1]);
3387        print "    '$now_printing' => {\n";
3388        foreach (@sequence) {
3389            if ($target{$_}) {
3390                if (ref($target{$_}) eq "ARRAY") {
3391                    print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3392                } else {
3393                    print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3394                }
3395            }
3396        }
3397        print "    },\n";
3398    }
3399}
3400
3401# Utility routines ###################################################
3402
3403# On VMS, if the given file is a logical name, File::Spec::Functions
3404# will consider it an absolute path.  There are cases when we want a
3405# purely syntactic check without checking the environment.
3406sub isabsolute {
3407    my $file = shift;
3408
3409    # On non-platforms, we just use file_name_is_absolute().
3410    return file_name_is_absolute($file) unless $^O eq "VMS";
3411
3412    # If the file spec includes a device or a directory spec,
3413    # file_name_is_absolute() is perfectly safe.
3414    return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3415
3416    # Here, we know the given file spec isn't absolute
3417    return 0;
3418}
3419
3420# Makes a directory absolute and cleans out /../ in paths like foo/../bar
3421# On some platforms, this uses rel2abs(), while on others, realpath() is used.
3422# realpath() requires that at least all path components except the last is an
3423# existing directory.  On VMS, the last component of the directory spec must
3424# exist.
3425sub absolutedir {
3426    my $dir = shift;
3427
3428    # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
3429    # will return the volume name for the device, no matter what.  Also,
3430    # it will return an incorrect directory spec if the argument is a
3431    # directory that doesn't exist.
3432    if ($^O eq "VMS") {
3433        return rel2abs($dir);
3434    }
3435
3436    # We use realpath() on Unix, since no other will properly clean out
3437    # a directory spec.
3438    use Cwd qw/realpath/;
3439
3440    return realpath($dir);
3441}
3442
3443# Check if all paths are one and the same, using stat.  They must both exist
3444# We need this for the cases when File::Spec doesn't detect case insensitivity
3445# (File::Spec::Unix assumes case sensitivity)
3446sub samedir {
3447    die "samedir expects two arguments\n" unless scalar @_ == 2;
3448
3449    my @stat0 = stat($_[0]);    # First argument
3450    my @stat1 = stat($_[1]);    # Second argument
3451
3452    die "Couldn't stat $_[0]" unless @stat0;
3453    die "Couldn't stat $_[1]" unless @stat1;
3454
3455    # Compare device number
3456    return 0 unless ($stat0[0] == $stat1[0]);
3457    # Compare "inode".  The perl manual recommends comparing as
3458    # string rather than as number.
3459    return 0 unless ($stat0[1] eq $stat1[1]);
3460
3461    return 1;                   # All the same
3462}
3463
3464sub quotify {
3465    my %processors = (
3466        perl    => sub { my $x = shift;
3467                         $x =~ s/([\\\$\@"])/\\$1/g;
3468                         return '"'.$x.'"'; },
3469        maybeshell => sub { my $x = shift;
3470                            (my $y = $x) =~ s/([\\\"])/\\$1/g;
3471                            if ($x ne $y || $x =~ m|\s|) {
3472                                return '"'.$y.'"';
3473                            } else {
3474                                return $x;
3475                            }
3476                        },
3477        );
3478    my $for = shift;
3479    my $processor =
3480        defined($processors{$for}) ? $processors{$for} : sub { shift; };
3481
3482    return map { $processor->($_); } @_;
3483}
3484
3485# collect_from_file($filename, $line_concat_cond_re, $line_concat)
3486# $filename is a file name to read from
3487# $line_concat_cond_re is a regexp detecting a line continuation ending
3488# $line_concat is a CODEref that takes care of concatenating two lines
3489sub collect_from_file {
3490    my $filename = shift;
3491    my $line_concat_cond_re = shift;
3492    my $line_concat = shift;
3493
3494    open my $fh, $filename || die "unable to read $filename: $!\n";
3495    return sub {
3496        my $saved_line = "";
3497        $_ = "";
3498        while (<$fh>) {
3499            s|\R$||;
3500            if (defined $line_concat) {
3501                $_ = $line_concat->($saved_line, $_);
3502                $saved_line = "";
3503            }
3504            if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3505                $saved_line = $_;
3506                next;
3507            }
3508            return $_;
3509        }
3510        die "$filename ending with continuation line\n" if $_;
3511        close $fh;
3512        return undef;
3513    }
3514}
3515
3516# collect_from_array($array, $line_concat_cond_re, $line_concat)
3517# $array is an ARRAYref of lines
3518# $line_concat_cond_re is a regexp detecting a line continuation ending
3519# $line_concat is a CODEref that takes care of concatenating two lines
3520sub collect_from_array {
3521    my $array = shift;
3522    my $line_concat_cond_re = shift;
3523    my $line_concat = shift;
3524    my @array = (@$array);
3525
3526    return sub {
3527        my $saved_line = "";
3528        $_ = "";
3529        while (defined($_ = shift @array)) {
3530            s|\R$||;
3531            if (defined $line_concat) {
3532                $_ = $line_concat->($saved_line, $_);
3533                $saved_line = "";
3534            }
3535            if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3536                $saved_line = $_;
3537                next;
3538            }
3539            return $_;
3540        }
3541        die "input text ending with continuation line\n" if $_;
3542        return undef;
3543    }
3544}
3545
3546# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3547# $lineiterator is a CODEref that delivers one line at a time.
3548# All following arguments are regex/CODEref pairs, where the regexp detects a
3549# line and the CODEref does something with the result of the regexp.
3550sub collect_information {
3551    my $lineiterator = shift;
3552    my %collectors = @_;
3553
3554    while(defined($_ = $lineiterator->())) {
3555        s|\R$||;
3556        my $found = 0;
3557        if ($collectors{"BEFORE"}) {
3558            $collectors{"BEFORE"}->($_);
3559        }
3560        foreach my $re (keys %collectors) {
3561            if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
3562                $collectors{$re}->($lineiterator);
3563                $found = 1;
3564            };
3565        }
3566        if ($collectors{"OTHERWISE"}) {
3567            $collectors{"OTHERWISE"}->($lineiterator, $_)
3568                unless $found || !defined $collectors{"OTHERWISE"};
3569        }
3570        if ($collectors{"AFTER"}) {
3571            $collectors{"AFTER"}->($_);
3572        }
3573    }
3574}
3575
3576# tokenize($line)
3577# $line is a line of text to split up into tokens
3578# returns a list of tokens
3579#
3580# Tokens are divided by spaces.  If the tokens include spaces, they
3581# have to be quoted with single or double quotes.  Double quotes
3582# inside a double quoted token must be escaped.  Escaping is done
3583# with backslash.
3584# Basically, the same quoting rules apply for " and ' as in any
3585# Unix shell.
3586sub tokenize {
3587    my $line = my $debug_line = shift;
3588    my @result = ();
3589
3590    while ($line =~ s|^\s+||, $line ne "") {
3591        my $token = "";
3592        while ($line ne "" && $line !~ m|^\s|) {
3593            if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3594                $token .= $1;
3595                $line = $';
3596            } elsif ($line =~ m/^'([^']*)'/) {
3597                $token .= $1;
3598                $line = $';
3599            } elsif ($line =~ m/^(\S+)/) {
3600                $token .= $1;
3601                $line = $';
3602            }
3603        }
3604        push @result, $token;
3605    }
3606
3607    if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3608        print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3609        print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
3610    }
3611    return @result;
3612}
3613