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