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