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