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