Print <ABSENT> if a STACK is NULL.
[openssl.git] / Configure
1 #! /usr/bin/env perl
2 # -*- mode: perl; -*-
3 # Copyright 2016 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 require 5.10.0;
13 use strict;
14 use Config;
15 use File::Basename;
16 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
17 use File::Path qw/mkpath/;
18 use if $^O ne "VMS", 'File::Glob' => qw/glob/;
19
20 # see INSTALL for instructions.
21
22 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";
23
24 # Options:
25 #
26 # --config      add the given configuration file, which will be read after
27 #               any "Configurations*" files that are found in the same
28 #               directory as this script.
29 # --prefix      prefix for the OpenSSL installation, which includes the
30 #               directories bin, lib, include, share/man, share/doc/openssl
31 #               This becomes the value of INSTALLTOP in Makefile
32 #               (Default: /usr/local)
33 # --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
34 #               If it's a relative directory, it will be added on the directory
35 #               given with --prefix.
36 #               This becomes the value of OPENSSLDIR in Makefile and in C.
37 #               (Default: PREFIX/ssl)
38 #
39 # --cross-compile-prefix Add specified prefix to binutils components.
40 #
41 # --api         One of 0.9.8, 1.0.0 or 1.1.0.  Do not compile support for
42 #               interfaces deprecated as of the specified OpenSSL version.
43 #
44 # no-hw-xxx     do not compile support for specific crypto hardware.
45 #               Generic OpenSSL-style methods relating to this support
46 #               are always compiled but return NULL if the hardware
47 #               support isn't compiled.
48 # no-hw         do not compile support for any crypto hardware.
49 # [no-]threads  [don't] try to create a library that is suitable for
50 #               multithreaded applications (default is "threads" if we
51 #               know how to do it)
52 # [no-]shared   [don't] try to create shared libraries when supported.
53 # [no-]pic      [don't] try to build position independent code when supported.
54 #               If disabled, it also disables shared and dynamic-engine.
55 # no-asm        do not use assembler
56 # no-dso        do not compile in any native shared-library methods. This
57 #               will ensure that all methods just return NULL.
58 # no-egd        do not compile support for the entropy-gathering daemon APIs
59 # [no-]zlib     [don't] compile support for zlib compression.
60 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
61 #               library and will be loaded in run-time by the OpenSSL library.
62 # sctp          include SCTP support
63 # 386           generate 80386 code
64 # enable-weak-ssl-ciphers
65 #               Enable weak ciphers that are disabled by default. This currently
66 #               only includes RC4 based ciphers.
67 # no-sse2       disables IA-32 SSE2 code, above option implies no-sse2
68 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
69 # -<xxx> +<xxx> compiler options are passed through
70 # -static       while -static is also a pass-through compiler option (and
71 #               as such is limited to environments where it's actually
72 #               meaningful), it triggers a number configuration options,
73 #               namely no-dso, no-pic, no-shared and no-threads. It is
74 #               argued that the only reason to produce statically linked
75 #               binaries (and in context it means executables linked with
76 #               -static flag, and not just executables linked with static
77 #               libcrypto.a) is to eliminate dependency on specific run-time,
78 #               a.k.a. libc version. The mentioned config options are meant
79 #               to achieve just that. Unfortunately on Linux it's impossible
80 #               to eliminate the dependency completely for openssl executable
81 #               because of getaddrinfo and gethostbyname calls, which can
82 #               invoke dynamically loadable library facility anyway to meet
83 #               the lookup requests. For this reason on Linux statically
84 #               linked openssl executable has rather debugging value than
85 #               production quality.
86 #
87 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
88 #               provided to stack calls. Generates unique stack functions for
89 #               each possible stack type.
90 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
91 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
92 # Following are set automatically by this script
93 #
94 # MD5_ASM       use some extra md5 assembler,
95 # SHA1_ASM      use some extra sha1 assembler, must define L_ENDIAN for x86
96 # RMD160_ASM    use some extra ripemd160 assembler,
97 # SHA256_ASM    sha256_block is implemented in assembler
98 # SHA512_ASM    sha512_block is implemented in assembler
99 # AES_ASM       AES_[en|de]crypt is implemented in assembler
100
101 # Minimum warning options... any contributions to OpenSSL should at least get
102 # past these.
103
104 # DEBUG_UNUSED enables __owur (warn unused result) checks.
105 my $gcc_devteam_warn = "-DDEBUG_UNUSED"
106         # -DPEDANTIC complements -pedantic and is meant to mask code that
107         # is not strictly standard-compliant and/or implementation-specific,
108         # e.g. inline assembly, disregards to alignment requirements, such
109         # that -pedantic would complain about. Incidentally -DPEDANTIC has
110         # to be used even in sanitized builds, because sanitizer too is
111         # supposed to and does take notice of non-standard behaviour. Then
112         # -pedantic with pre-C9x compiler would also complain about 'long
113         # long' not being supported. As 64-bit algorithms are common now,
114         # it grew impossible to resolve this without sizeable additional
115         # code, so we just tell compiler to be pedantic about everything
116         # but 'long long' type.
117         . " -Wswitch"
118         . " -DPEDANTIC -pedantic -Wno-long-long"
119         . " -Wall"
120         . " -Wsign-compare"
121         . " -Wmissing-prototypes"
122         . " -Wshadow"
123         . " -Wformat"
124         . " -Wtype-limits"
125         . " -Werror"
126         ;
127
128 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
129 # TODO(openssl-team): fix problems and investigate if (at least) the
130 # following warnings can also be enabled:
131 #       -Wcast-align
132 #       -Wunreachable-code
133 #       -Wlanguage-extension-token -- no, we use asm()
134 #       -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
135 #       -Wextended-offsetof -- no, needed in CMS ASN1 code
136 my $clang_devteam_warn = ""
137         . " -Qunused-arguments"
138         . " -Wextra"
139         . " -Wswitch -Wswitch-default"
140         . " -Wno-unused-parameter"
141         . " -Wno-missing-field-initializers"
142         . " -Wno-language-extension-token"
143         . " -Wno-extended-offsetof"
144         . " -Wconditional-uninitialized"
145         . " -Wincompatible-pointer-types-discards-qualifiers"
146         . " -Wmissing-variable-declarations"
147         ;
148
149 # This adds backtrace information to the memory leak info.  Is only used
150 # when crypto-mdebug-backtrace is enabled.
151 my $memleak_devteam_backtrace = "-rdynamic";
152
153 my $strict_warnings = 0;
154
155 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
156 # which would cover all BSD flavors. -pthread applies to them all,
157 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
158 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
159 # which has to be accompanied by explicit -D_THREAD_SAFE and
160 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
161 # seems to be sufficient?
162 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
163
164 #
165 # API compatibility name to version number mapping.
166 #
167 my $maxapi = "1.1.0";           # API for "no-deprecated" builds
168 my $apitable = {
169     "1.1.0" => "0x10100000L",
170     "1.0.0" => "0x10000000L",
171     "0.9.8" => "0x00908000L",
172 };
173
174 our %table = ();
175 our %config = ();
176 our %withargs = ();
177
178 # Forward declarations ###############################################
179
180 # read_config(filename)
181 #
182 # Reads a configuration file and populates %table with the contents
183 # (which the configuration file places in %targets).
184 sub read_config;
185
186 # resolve_config(target)
187 #
188 # Resolves all the late evaluations, inheritances and so on for the
189 # chosen target and any target it inherits from.
190 sub resolve_config;
191
192
193 # Information collection #############################################
194
195 # Unified build supports separate build dir
196 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
197 my $blddir = catdir(absolutedir("."));         # catdir ensures local syntax
198 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
199
200 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
201
202 $config{sourcedir} = abs2rel($srcdir);
203 $config{builddir} = abs2rel($blddir);
204
205 # Collect reconfiguration information if needed
206 my @argvcopy=@ARGV;
207
208 if (grep /^reconf(igure)?$/, @argvcopy) {
209     if (-f "./configdata.pm") {
210         my $file = "./configdata.pm";
211         unless (my $return = do $file) {
212             die "couldn't parse $file: $@" if $@;
213             die "couldn't do $file: $!"    unless defined $return;
214             die "couldn't run $file"       unless $return;
215         }
216
217         @argvcopy = defined($configdata::config{perlargv}) ?
218             @{$configdata::config{perlargv}} : ();
219         die "Incorrect data to reconfigure, please do a normal configuration\n"
220             if (grep(/^reconf/,@argvcopy));
221         $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
222             if defined($configdata::config{cross_compile_prefix});
223         $ENV{CC} = $configdata::config{cc}
224             if defined($configdata::config{cc});
225         $ENV{BUILDFILE} = $configdata::config{build_file}
226             if defined($configdata::config{build_file});
227         $ENV{$local_config_envname} = $configdata::config{local_config_dir}
228             if defined($configdata::config{local_config_dir});
229
230         print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
231         print "    CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
232             if $ENV{CROSS_COMPILE};
233         print "    CC = ",$ENV{CC},"\n" if $ENV{CC};
234         print "    BUILDFILE = ",$ENV{BUILDFILE},"\n" if $ENV{BUILDFILE};
235         print "    $local_config_envname = ",$ENV{$local_config_envname},"\n"
236             if $ENV{$local_config_envname};
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
290 print "Configuring OpenSSL version $config{version} (0x$config{version_num})\n";
291
292 $config{prefix}="";
293 $config{openssldir}="";
294 $config{processor}="";
295 $config{libdir}="";
296 $config{cross_compile_prefix}="";
297 $config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/";
298 my $nofipscanistercheck=0;
299 $config{baseaddr}="0xFB00000";
300 my $auto_threads=1;    # enable threads automatically? true by default
301 my $default_ranlib;
302 $config{fips}=0;
303
304 # Top level directories to build
305 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "util", "tools", "fuzz" ];
306 # crypto/ subdirectories to build
307 $config{sdirs} = [
308     "objects",
309     "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2",
310     "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes",
311     "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
312     "buffer", "bio", "stack", "lhash", "rand", "err",
313     "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
314     "cms", "ts", "srp", "cmac", "ct", "async", "kdf"
315     ];
316
317 # Known TLS and DTLS protocols
318 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
319 my @dtls = qw(dtls1 dtls1_2);
320
321 # Explicitly known options that are possible to disable.  They can
322 # be regexps, and will be used like this: /^no-${option}$/
323 # For developers: keep it sorted alphabetically
324
325 my @disablables = (
326     "afalgeng",
327     "asan",
328     "asm",
329     "async",
330     "autoalginit",
331     "autoerrinit",
332     "bf",
333     "blake2",
334     "camellia",
335     "capieng",
336     "cast",
337     "chacha",
338     "cmac",
339     "cms",
340     "comp",
341     "crypto-mdebug",
342     "crypto-mdebug-backtrace",
343     "ct",
344     "deprecated",
345     "des",
346     "dgram",
347     "dh",
348     "dsa",
349     "dso",
350     "dtls",
351     "dynamic-engine",
352     "ec",
353     "ec2m",
354     "ecdh",
355     "ecdsa",
356     "ec_nistp_64_gcc_128",
357     "egd",
358     "engine",
359     "err",
360     "filenames",
361     "fuzz-libfuzzer",
362     "fuzz-afl",
363     "gost",
364     "heartbeats",
365     "hw(-.+)?",
366     "idea",
367     "makedepend",
368     "md2",
369     "md4",
370     "mdc2",
371     "msan",
372     "multiblock",
373     "nextprotoneg",
374     "ocb",
375     "ocsp",
376     "pic",
377     "poly1305",
378     "posix-io",
379     "psk",
380     "rc2",
381     "rc4",
382     "rc5",
383     "rdrand",
384     "rfc3779",
385     "rmd160",
386     "scrypt",
387     "sctp",
388     "seed",
389     "shared",
390     "sock",
391     "srp",
392     "srtp",
393     "sse2",
394     "ssl",
395     "ssl-trace",
396     "static-engine",
397     "stdio",
398     "threads",
399     "tls",
400     "ts",
401     "ubsan",
402     "ui",
403     "unit-test",
404     "whirlpool",
405     "weak-ssl-ciphers",
406     "zlib",
407     "zlib-dynamic",
408     );
409 foreach my $proto ((@tls, @dtls))
410         {
411         push(@disablables, $proto);
412         push(@disablables, "$proto-method");
413         }
414
415 my %deprecated_disablables = (
416     "ssl2" => undef,
417     "buf-freelists" => undef,
418     "ripemd" => "rmd160"
419     );
420
421 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
422
423 our %disabled = ( # "what"         => "comment"
424                   "asan"                => "default",
425                   "crypto-mdebug"       => "default",
426                   "crypto-mdebug-backtrace" => "default",
427                   "ec_nistp_64_gcc_128" => "default",
428                   "egd"                 => "default",
429                   "fuzz-libfuzzer"      => "default",
430                   "fuzz-afl"            => "default",
431                   "heartbeats"          => "default",
432                   "md2"                 => "default",
433                   "msan"                => "default",
434                   "rc5"                 => "default",
435                   "sctp"                => "default",
436                   "ssl-trace"           => "default",
437                   "ssl3"                => "default",
438                   "ssl3-method"         => "default",
439                   "ubsan"               => "default",
440                   "unit-test"           => "default",
441                   "weak-ssl-ciphers"    => "default",
442                   "zlib"                => "default",
443                   "zlib-dynamic"        => "default",
444                 );
445
446 # Note: => pair form used for aesthetics, not to truly make a hash table
447 my @disable_cascades = (
448     # "what"            => [ "cascade", ... ]
449     sub { $config{processor} eq "386" }
450                         => [ "sse2" ],
451     "ssl"               => [ "ssl3" ],
452     "ssl3-method"       => [ "ssl3" ],
453     "zlib"              => [ "zlib-dynamic" ],
454     "des"               => [ "mdc2" ],
455     "ec"                => [ "ecdsa", "ecdh" ],
456
457     "dgram"             => [ "dtls", "sctp" ],
458     "sock"              => [ "dgram" ],
459     "dtls"              => [ @dtls ],
460
461     # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
462     "md5"               => [ "ssl", "tls1", "tls1_1", "dtls1" ],
463     "sha"               => [ "ssl", "tls1", "tls1_1", "dtls1" ],
464
465     # Additionally, SSL 3.0 requires either RSA or DSA+DH
466     sub { $disabled{rsa}
467           && ($disabled{dsa} || $disabled{dh}); }
468                         => [ "ssl" ],
469
470     # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
471     # or ECDSA + ECDH.  (D)TLS 1.2 has this requirement as well.
472     # (XXX: We don't support PSK-only builds).
473     sub { $disabled{rsa}
474           && ($disabled{dsa} || $disabled{dh})
475           && ($disabled{ecdsa} || $disabled{ecdh}); }
476                         => [ "tls1", "tls1_1", "tls1_2",
477                              "dtls1", "dtls1_2" ],
478
479     "tls"               => [ @tls ],
480
481     # SRP and HEARTBEATS require TLSEXT
482     "tlsext"            => [ "srp", "heartbeats" ],
483
484     "crypto-mdebug"     => [ "crypto-mdebug-backtrace" ],
485
486     # Without DSO, we can't load dynamic engines, so don't build them dynamic
487     "dso"               => [ "dynamic-engine" ],
488
489     # Without position independent code, there can be no shared libraries or DSOs
490     "pic"               => [ "shared" ],
491     "shared"            => [ "dynamic-engine" ],
492     "engine"            => [ "afalgeng" ],
493
494     # no-autoalginit is only useful when building non-shared
495     "autoalginit"       => [ "shared", "apps" ],
496
497     "stdio"             => [ "apps", "capieng" ],
498     "apps"              => [ "tests" ],
499     "comp"              => [ "zlib" ],
500     sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
501
502     sub { !$disabled{"msan"} } => [ "asm" ],
503     );
504
505 # Avoid protocol support holes.  Also disable all versions below N, if version
506 # N is disabled while N+1 is enabled.
507 #
508 my @list = (reverse @tls);
509 while ((my $first, my $second) = (shift @list, shift @list)) {
510     last unless @list;
511     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
512                               => [ @list ] );
513     unshift @list, $second;
514 }
515 my @list = (reverse @dtls);
516 while ((my $first, my $second) = (shift @list, shift @list)) {
517     last unless @list;
518     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
519                               => [ @list ] );
520     unshift @list, $second;
521 }
522
523 # Explicit "no-..." options will be collected in %disabled along with the defaults.
524 # To remove something from %disabled, use "enable-foo".
525 # For symmetry, "disable-foo" is a synonym for "no-foo".
526
527 my $no_sse2=0;
528
529 &usage if ($#ARGV < 0);
530
531 my $user_cflags="";
532 my @user_defines=();
533 $config{openssl_api_defines}=[];
534 $config{openssl_algorithm_defines}=[];
535 $config{openssl_thread_defines}=[];
536 $config{openssl_sys_defines}=[];
537 $config{openssl_other_defines}=[];
538 my $libs="";
539 my $target="";
540 $config{options}="";
541 $config{build_type} = "release";
542
543 my %unsupported_options = ();
544 my %deprecated_options = ();
545 foreach (@argvcopy)
546         {
547         # VMS is a case insensitive environment, and depending on settings
548         # out of our control, we may receive options uppercased.  Let's
549         # downcase at least the part before any equal sign.
550         if ($^O eq "VMS")
551                 {
552                 s/^([^=]*)/lc($1)/e;
553                 }
554         s /^-no-/no-/; # some people just can't read the instructions
555
556         # rewrite some options in "enable-..." form
557         s /^-?-?shared$/enable-shared/;
558         s /^sctp$/enable-sctp/;
559         s /^threads$/enable-threads/;
560         s /^zlib$/enable-zlib/;
561         s /^zlib-dynamic$/enable-zlib-dynamic/;
562
563         if (/^(no|disable|enable)-(.+)$/)
564                 {
565                 my $word = $2;
566                 if (!exists $deprecated_disablables{$word}
567                         && !grep { $word =~ /^${_}$/ } @disablables)
568                         {
569                         $unsupported_options{$_} = 1;
570                         next;
571                         }
572                 }
573         if (/^no-(.+)$/ || /^disable-(.+)$/)
574                 {
575                 foreach my $proto ((@tls, @dtls))
576                         {
577                         if ($1 eq "$proto-method")
578                                 {
579                                 $disabled{"$proto"} = "option($proto-method)";
580                                 last;
581                                 }
582                         }
583                 if ($1 eq "dtls")
584                         {
585                         foreach my $proto (@dtls)
586                                 {
587                                 $disabled{$proto} = "option(dtls)";
588                                 }
589                         $disabled{"dtls"} = "option(dtls)";
590                         }
591                 elsif ($1 eq "ssl")
592                         {
593                         # Last one of its kind
594                         $disabled{"ssl3"} = "option(ssl)";
595                         }
596                 elsif ($1 eq "tls")
597                         {
598                         # XXX: Tests will fail if all SSL/TLS
599                         # protocols are disabled.
600                         foreach my $proto (@tls)
601                                 {
602                                 $disabled{$proto} = "option(tls)";
603                                 }
604                         }
605                 elsif ($1 eq "static-engine")
606                         {
607                         delete $disabled{"dynamic-engine"};
608                         }
609                 elsif ($1 eq "dynamic-engine")
610                         {
611                         $disabled{"dynamic-engine"} = "option";
612                         }
613                 elsif (exists $deprecated_disablables{$1})
614                         {
615                         $deprecated_options{$_} = 1;
616                         if (defined $deprecated_disablables{$1})
617                                 {
618                                 $disabled{$deprecated_disablables{$1}} = "option";
619                                 }
620                         }
621                 else
622                         {
623                         $disabled{$1} = "option";
624                         }
625                 # No longer an automatic choice
626                 $auto_threads = 0 if ($1 eq "threads");
627                 }
628         elsif (/^enable-(.+)$/)
629                 {
630                 if ($1 eq "static-engine")
631                         {
632                         $disabled{"dynamic-engine"} = "option";
633                         }
634                 elsif ($1 eq "dynamic-engine")
635                         {
636                         delete $disabled{"dynamic-engine"};
637                         }
638                 elsif ($1 eq "zlib-dynamic")
639                         {
640                         delete $disabled{"zlib"};
641                         }
642                 my $algo = $1;
643                 delete $disabled{$algo};
644
645                 # No longer an automatic choice
646                 $auto_threads = 0 if ($1 eq "threads");
647                 }
648         elsif (/^--strict-warnings$/)
649                 {
650                 $strict_warnings = 1;
651                 }
652         elsif (/^--debug$/)
653                 {
654                 $config{build_type} = "debug";
655                 }
656         elsif (/^--release$/)
657                 {
658                 $config{build_type} = "release";
659                 }
660         elsif (/^386$/)
661                 { $config{processor}=386; }
662         elsif (/^fips$/)
663                 {
664                 $config{fips}=1;
665                 }
666         elsif (/^rsaref$/)
667                 {
668                 # No RSAref support any more since it's not needed.
669                 # The check for the option is there so scripts aren't
670                 # broken
671                 }
672         elsif (/^nofipscanistercheck$/)
673                 {
674                 $config{fips} = 1;
675                 $nofipscanistercheck = 1;
676                 }
677         elsif (/^[-+]/)
678                 {
679                 if (/^--prefix=(.*)$/)
680                         {
681                         $config{prefix}=$1;
682                         die "Directory given with --prefix MUST be absolute\n"
683                                 unless file_name_is_absolute($config{prefix});
684                         }
685                 elsif (/^--api=(.*)$/)
686                         {
687                         $config{api}=$1;
688                         }
689                 elsif (/^--libdir=(.*)$/)
690                         {
691                         $config{libdir}=$1;
692                         }
693                 elsif (/^--openssldir=(.*)$/)
694                         {
695                         $config{openssldir}=$1;
696                         }
697                 elsif (/^--with-zlib-lib=(.*)$/)
698                         {
699                         $withargs{zlib_lib}=$1;
700                         }
701                 elsif (/^--with-zlib-include=(.*)$/)
702                         {
703                         $withargs{zlib_include}=$1;
704                         }
705                 elsif (/^--with-fuzzer-lib=(.*)$/)
706                         {
707                         $withargs{fuzzer_lib}=$1;
708                         }
709                 elsif (/^--with-fuzzer-include=(.*)$/)
710                         {
711                         $withargs{fuzzer_include}=$1;
712                         }
713                 elsif (/^--with-fipslibdir=(.*)$/)
714                         {
715                         $config{fipslibdir}="$1/";
716                         }
717                 elsif (/^--with-baseaddr=(.*)$/)
718                         {
719                         $config{baseaddr}="$1";
720                         }
721                 elsif (/^--cross-compile-prefix=(.*)$/)
722                         {
723                         $config{cross_compile_prefix}=$1;
724                         }
725                 elsif (/^--config=(.*)$/)
726                         {
727                         read_config $1;
728                         }
729                 elsif (/^-[lL](.*)$/ or /^-Wl,/)
730                         {
731                         $libs.=$_." ";
732                         }
733                 elsif (/^-static$/)
734                         {
735                         $libs.=$_." ";
736                         $disabled{"dso"} = "forced";
737                         $disabled{"pic"} = "forced";
738                         $disabled{"shared"} = "forced";
739                         $disabled{"threads"} = "forced";
740                         }
741                 elsif (/^-D(.*)$/)
742                         {
743                         push @user_defines, $1;
744                         }
745                 else    # common if (/^[-+]/), just pass down...
746                         {
747                         $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
748                         $user_cflags.=" ".$_;
749                         }
750                 }
751         else
752                 {
753                 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
754                 $target=$_;
755                 }
756         unless ($_ eq $target || /^no-/ || /^disable-/)
757                 {
758                 # "no-..." follows later after implied disactivations
759                 # have been derived.  (Don't take this too seriously,
760                 # we really only write OPTIONS to the Makefile out of
761                 # nostalgia.)
762
763                 if ($config{options} eq "")
764                         { $config{options} = $_; }
765                 else
766                         { $config{options} .= " ".$_; }
767                 }
768
769         if (defined($config{api}) && !exists $apitable->{$config{api}}) {
770                 die "***** Unsupported api compatibility level: $config{api}\n",
771         }
772
773         if (keys %deprecated_options)
774                 {
775                 warn "***** Deprecated options: ",
776                         join(", ", keys %deprecated_options), "\n";
777                 }
778         if (keys %unsupported_options)
779                 {
780                 die "***** Unsupported options: ",
781                         join(", ", keys %unsupported_options), "\n";
782                 }
783         }
784
785 if ($libs =~ /(^|\s)-Wl,-rpath,/
786     && !$disabled{shared}
787     && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
788     die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
789         "***** any of asan, msan or ubsan\n";
790 }
791
792 if ($config{fips})
793         {
794         delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
795         }
796 else
797         {
798         @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}};
799         }
800
801 my @tocheckfor = (keys %disabled);
802 while (@tocheckfor) {
803     my %new_tocheckfor = ();
804     my @cascade_copy = (@disable_cascades);
805     while (@cascade_copy) {
806         my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
807         if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
808             foreach(grep { !defined($disabled{$_}) } @$descendents) {
809                 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
810             }
811         }
812     }
813     @tocheckfor = (keys %new_tocheckfor);
814 }
815
816 our $die = sub { die @_; };
817 if ($target eq "TABLE") {
818     local $die = sub { warn @_; };
819     foreach (sort keys %table) {
820         print_table_entry($_, "TABLE");
821     }
822     exit 0;
823 }
824
825 if ($target eq "LIST") {
826     foreach (sort keys %table) {
827         print $_,"\n" unless $table{$_}->{template};
828     }
829     exit 0;
830 }
831
832 if ($target eq "HASH") {
833     local $die = sub { warn @_; };
834     print "%table = (\n";
835     foreach (sort keys %table) {
836         print_table_entry($_, "HASH");
837     }
838     exit 0;
839 }
840
841 # Backward compatibility?
842 if ($target =~ m/^CygWin32(-.*)$/) {
843     $target = "Cygwin".$1;
844 }
845
846 foreach (sort (keys %disabled))
847         {
848         $config{options} .= " no-$_";
849
850         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
851
852         if (/^dso$/)
853                 { }
854         elsif (/^threads$/)
855                 { }
856         elsif (/^shared$/)
857                 { }
858         elsif (/^pic$/)
859                 { }
860         elsif (/^zlib$/)
861                 { }
862         elsif (/^dynamic-engine$/)
863                 { }
864         elsif (/^makedepend$/)
865                 { }
866         elsif (/^zlib-dynamic$/)
867                 { }
868         elsif (/^sse2$/)
869                 { $no_sse2 = 1; }
870         elsif (/^engine$/)
871                 {
872                 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
873                 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
874                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
875                 print " OPENSSL_NO_ENGINE (skip engines)";
876                 }
877         else
878                 {
879                 my ($WHAT, $what);
880
881                 ($WHAT = $what = $_) =~ tr/[\-a-z]/[_A-Z]/;
882
883                 # Fix up C macro end names
884                 $WHAT = "RMD160" if $what eq "ripemd";
885
886                 # fix-up crypto/directory name(s)
887                 $what = "ripemd" if $what eq "rmd160";
888                 $what = "whrlpool" if $what eq "whirlpool";
889
890                 if ($what ne "async" && $what ne "err"
891                     && grep { $_ eq $what } @{$config{sdirs}})
892                         {
893                         push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$WHAT";
894                         @{$config{sdirs}} = grep { $_ ne $what} @{$config{sdirs}};
895
896                         print " OPENSSL_NO_$WHAT (skip dir)";
897                         }
898                 else
899                         {
900                         push @{$config{openssl_other_defines}}, "OPENSSL_NO_$WHAT";
901                         print " OPENSSL_NO_$WHAT";
902
903                         if (/^err$/)    { push @user_defines, "OPENSSL_NO_ERR"; }
904                         }
905                 }
906
907         print "\n";
908         }
909
910 print "Configuring for $target\n";
911 # Support for legacy targets having a name starting with 'debug-'
912 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
913 if ($d) {
914     $config{build_type} = "debug";
915
916     # If we do not find debug-foo in the table, the target is set to foo.
917     if (!$table{$target}) {
918         $target = $t;
919     }
920 }
921 $config{target} = $target;
922 my %target = resolve_config($target);
923
924 &usage if (!%target || $target{template});
925
926 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
927 $config{conf_files} = [ sort keys %conf_files ];
928 %target = ( %{$table{DEFAULTS}}, %target );
929
930 $target{exe_extension}="";
931 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
932                                   || $config{target} =~ /^(?:Cygwin|mingw)/);
933 $target{exe_extension}=".pm"  if ($config{target} =~ /vos/);
934
935 ($target{shared_extension_simple}=$target{shared_extension})
936     =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
937 $target{dso_extension}=$target{shared_extension_simple};
938 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
939     if ($config{target} =~ /^(?:Cygwin|mingw)/);
940
941
942 $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
943     if $config{cross_compile_prefix} eq "";
944
945 # Allow overriding the names of some tools.  USE WITH CARE
946 # Note: only Unix cares about HASHBANGPERL...  that explains
947 # the default string.
948 $config{perl} =    ($^O ne "VMS" ? $^X : "perl");
949 $config{hashbangperl} =
950     $ENV{'HASHBANGPERL'}           || $ENV{'PERL'}     || "/usr/bin/env perl";
951 $target{cc} =      $ENV{'CC'}      || $target{cc}      || "cc";
952 $target{ranlib} =  $ENV{'RANLIB'}  || $target{ranlib}  ||
953                    (which("$config{cross_compile_prefix}ranlib") ?
954                           "\$(CROSS_COMPILE)ranlib" : "true");
955 $target{ar} =      $ENV{'AR'}      || $target{ar}      || "ar";
956 $target{nm} =      $ENV{'NM'}      || $target{nm}      || "nm";
957 $target{rc} =
958     $ENV{'RC'}  || $ENV{'WINDRES'} || $target{rc}      || "windres";
959
960 # Allow overriding the build file name
961 $target{build_file} = $ENV{BUILDFILE} || $target{build_file} || "Makefile";
962
963 # Cache information necessary for reconfiguration
964 $config{cc} = $target{cc};
965 $config{build_file} = $target{build_file};
966
967 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
968 # or release_ attributes.
969 # Do it in such a way that no spurious space is appended (hence the grep).
970 $config{defines} = [];
971 $config{cflags} = "";
972 $config{ex_libs} = "";
973 $config{shared_ldflag} = "";
974
975 # Make sure build_scheme is consistent.
976 $target{build_scheme} = [ $target{build_scheme} ]
977     if ref($target{build_scheme}) ne "ARRAY";
978
979 my ($builder, $builder_platform, @builder_opts) =
980     @{$target{build_scheme}};
981
982 push @{$config{defines}}, "NDEBUG"    if $config{build_type} eq "release";
983
984 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
985         {
986         $config{cflags} .= " -mno-cygwin";
987         $config{shared_ldflag} .= " -mno-cygwin";
988         }
989
990 if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
991         # minimally required architecture flags for assembly modules
992         $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
993         $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
994 }
995
996 my $no_shared_warn=0;
997 my $no_user_cflags=0;
998 my $no_user_defines=0;
999
1000 # The DSO code currently always implements all functions so that no
1001 # applications will have to worry about that from a compilation point
1002 # of view. However, the "method"s may return zero unless that platform
1003 # has support compiled in for them. Currently each method is enabled
1004 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
1005 # string entry into using the following logic;
1006 if (!$disabled{dso} && $target{dso_scheme} ne "")
1007         {
1008         $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
1009         if ($target{dso_scheme} eq "DLFCN")
1010                 {
1011                 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
1012                 }
1013         elsif ($target{dso_scheme} eq "DLFCN_NO_H")
1014                 {
1015                 unshift @{$config{defines}}, "DSO_DLFCN";
1016                 }
1017         else
1018                 {
1019                 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
1020                 }
1021         }
1022
1023 $config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
1024
1025 if ($disabled{asm})
1026         {
1027         if ($config{fips})
1028                 {
1029                 @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}};
1030                 @{$target{defines}} = grep !/^[BL]_ENDIAN$/, @{$target{defines}};
1031                 }
1032         }
1033
1034 # If threads aren't disabled, check how possible they are
1035 unless ($disabled{threads}) {
1036     if ($auto_threads) {
1037         # Enabled by default, disable it forcibly if unavailable
1038         if ($target{thread_scheme} eq "(unknown)") {
1039             $disabled{threads} = "unavailable";
1040         }
1041     } else {
1042         # The user chose to enable threads explicitly, let's see
1043         # if there's a chance that's possible
1044         if ($target{thread_scheme} eq "(unknown)") {
1045             # If the user asked for "threads" and we don't have internal
1046             # knowledge how to do it, [s]he is expected to provide any
1047             # system-dependent compiler options that are necessary.  We
1048             # can't truly check that the given options are correct, but
1049             # we expect the user to know what [s]He is doing.
1050             if ($no_user_cflags && $no_user_defines) {
1051                 die "You asked for multi-threading support, but didn't\n"
1052                     ,"provide any system-specific compiler options\n";
1053             }
1054         }
1055     }
1056 }
1057
1058 # If threads still aren't disabled, add a C macro to ensure the source
1059 # code knows about it.  Any other flag is taken care of by the configs.
1060 unless($disabled{threads}) {
1061     foreach (("defines", "openssl_thread_defines")) {
1062         push @{$config{$_}}, "OPENSSL_THREADS";
1063     }
1064 }
1065
1066 # With "deprecated" disable all deprecated features.
1067 if (defined($disabled{"deprecated"})) {
1068         $config{api} = $maxapi;
1069 }
1070
1071 if ($target{shared_target} eq "")
1072         {
1073         $no_shared_warn = 1
1074             if ((!$disabled{shared} || !$disabled{"dynamic-engine"})
1075                 && !$config{fips});
1076         $disabled{shared} = "no-shared-target";
1077         $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1078             "no-shared-target";
1079         }
1080
1081 if ($disabled{"dynamic-engine"}) {
1082         push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1083         $config{dynamic_engines} = 0;
1084 } else {
1085         push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1086         $config{dynamic_engines} = 1;
1087 }
1088
1089 unless ($disabled{"fuzz-libfuzzer"}) {
1090     $config{cflags} .= "-fsanitize-coverage=edge,indirect-calls ";
1091 }
1092
1093 unless ($disabled{asan}) {
1094     $config{cflags} .= "-fsanitize=address ";
1095 }
1096
1097 unless ($disabled{ubsan}) {
1098     # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1099     # platforms.
1100     $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1101 }
1102
1103 unless ($disabled{msan}) {
1104   $config{cflags} .= "-fsanitize=memory ";
1105 }
1106
1107 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1108         && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1109     $config{cflags} .= "-fno-omit-frame-pointer -g ";
1110 }
1111 #
1112 # Platform fix-ups
1113 #
1114
1115 # This saves the build files from having to check
1116 if ($disabled{pic})
1117         {
1118         $target{shared_cflag} = $target{shared_ldflag} =
1119                 $target{shared_rcflag} = "";
1120         }
1121 else
1122         {
1123         push @{$config{defines}}, "OPENSSL_PIC";
1124         }
1125
1126 if ($target{sys_id} ne "")
1127         {
1128         push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1129         }
1130
1131 unless ($disabled{asm}) {
1132     $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1133     $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1134
1135     # bn-586 is the only one implementing bn_*_part_words
1136     push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1137     push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
1138
1139     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1140     push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1141     push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1142
1143     if ($config{fips}) {
1144         push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1145     }
1146
1147     if ($target{sha1_asm_src}) {
1148         push @{$config{defines}}, "SHA1_ASM"   if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1149         push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1150         push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1151     }
1152     if ($target{rc4_asm_src} ne $table{DEFAULTS}->{rc4_asm_src}) {
1153         push @{$config{defines}}, "RC4_ASM";
1154     }
1155     if ($target{md5_asm_src}) {
1156         push @{$config{defines}}, "MD5_ASM";
1157     }
1158     $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1159     if ($target{rmd160_asm_src}) {
1160         push @{$config{defines}}, "RMD160_ASM";
1161     }
1162     if ($target{aes_asm_src}) {
1163         push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1164         # aes-ctr.fake is not a real file, only indication that assembler
1165         # module implements AES_ctr32_encrypt...
1166         push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1167         # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1168         push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1169         $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1170         push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1171         push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1172     }
1173     if ($target{wp_asm_src} =~ /mmx/) {
1174         if ($config{processor} eq "386") {
1175             $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1176         } elsif (!$disabled{"whirlpool"}) {
1177             push @{$config{defines}}, "WHIRLPOOL_ASM";
1178         }
1179     }
1180     if ($target{modes_asm_src} =~ /ghash-/) {
1181         push @{$config{defines}}, "GHASH_ASM";
1182     }
1183     if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1184         push @{$config{defines}}, "ECP_NISTZ256_ASM";
1185     }
1186     if ($target{poly1305_asm_src} ne "") {
1187         push @{$config{defines}}, "POLY1305_ASM";
1188     }
1189 }
1190
1191 my $ecc = $target{cc};
1192 if ($^O ne "VMS" && !$disabled{makedepend}) {
1193     # Is the compiler gcc or clang?  $ecc is used below to see if
1194     # error-checking can be turned on.
1195     my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
1196     open(PIPE, "$ccpcc --version 2>&1 |");
1197     my $lines = 2;
1198     while ( <PIPE> ) {
1199         # Find the version number and save the major.
1200         m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
1201         my $compiler_major = $1;
1202         # We know that GNU C version 3 and up as well as all clang
1203         # versions support dependency generation
1204         $config{makedepprog} = $ccpcc
1205             if (/clang/ || (/gcc/ && $compiler_major >= 3));
1206         $ecc = "clang" if /clang/;
1207         $ecc = "gcc" if /gcc/;
1208         last if ($config{makedepprog} || !$lines--);
1209     }
1210     close(PIPE);
1211
1212     $config{makedepprog} = which('makedepend') unless $config{makedepprog};
1213     $disabled{makedepend} = "unavailable" unless $config{makedepprog};
1214 }
1215
1216
1217
1218 # Deal with bn_ops ###################################################
1219
1220 $config{bn_ll}                  =0;
1221 $config{export_var_as_fn}       =0;
1222 my $def_int="unsigned int";
1223 $config{rc4_int}                =$def_int;
1224 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1225
1226 my $count = 0;
1227 foreach (sort split(/\s+/,$target{bn_ops})) {
1228     $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1229     $config{export_var_as_fn}=1                 if $_ eq 'EXPORT_VAR_AS_FN';
1230     $config{bn_ll}=1                            if $_ eq 'BN_LLONG';
1231     $config{rc4_int}="unsigned char"            if $_ eq 'RC4_CHAR';
1232     ($config{b64l},$config{b64},$config{b32})
1233         =(0,1,0)                                if $_ eq 'SIXTY_FOUR_BIT';
1234     ($config{b64l},$config{b64},$config{b32})
1235         =(1,0,0)                                if $_ eq 'SIXTY_FOUR_BIT_LONG';
1236     ($config{b64l},$config{b64},$config{b32})
1237         =(0,0,1)                                if $_ eq 'THIRTY_TWO_BIT';
1238 }
1239 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1240     if $count > 1;
1241
1242
1243 # Hack cflags for better warnings (dev option) #######################
1244
1245 # "Stringify" the C flags string.  This permits it to be made part of a string
1246 # and works as well on command lines.
1247 $config{cflags} =~ s/([\\\"])/\\$1/g;
1248
1249 if (defined($config{api})) {
1250     $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1251     my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1252     push @{$config{defines}}, $apiflag;
1253 }
1254
1255 if ($strict_warnings)
1256         {
1257         my $wopt;
1258         die "ERROR --strict-warnings requires gcc or clang"
1259             unless $ecc eq 'gcc' || $ecc eq 'clang';
1260         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1261                 {
1262                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1263                 }
1264         if ($ecc eq "clang")
1265                 {
1266                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1267                         {
1268                         $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1269                         }
1270                 }
1271         }
1272
1273 unless ($disabled{"crypto-mdebug-backtrace"})
1274         {
1275         foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1276                 {
1277                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1278                 }
1279         if ($target =~ /^BSD-/)
1280                 {
1281                 $config{ex_libs} .= " -lexecinfo";
1282                 }
1283         }
1284
1285 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1286 else                    { $no_user_cflags=1;  }
1287 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1288 else               { $no_user_defines=1;    }
1289
1290 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1291
1292 unless ($disabled{afalgeng}) {
1293     $config{afalgeng}="";
1294     if ($target =~ m/^linux/) {
1295         my $minver = 4*10000 + 1*100 + 0;
1296         if ($config{cross_compile_prefix} eq "") {
1297             my $verstr = `uname -r`;
1298             my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1299             ($mi2) = $mi2 =~ /(\d+)/;
1300             my $ver = $ma*10000 + $mi1*100 + $mi2;
1301             if ($ver < $minver) {
1302                 $disabled{afalgeng} = "too-old-kernel";
1303             } else {
1304                 push @{$config{engdirs}}, "afalg";
1305             }
1306         } else {
1307             $disabled{afalgeng} = "cross-compiling";
1308         }
1309     } else {
1310         $disabled{afalgeng}  = "not-linux";
1311     }
1312 }
1313
1314 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1315
1316 # If we use the unified build, collect information from build.info files
1317 my %unified_info = ();
1318
1319 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1320 if ($builder eq "unified") {
1321     use lib catdir(dirname(__FILE__),"util");
1322     use with_fallback qw(Text::Template);
1323
1324     sub cleandir {
1325         my $base = shift;
1326         my $dir = shift;
1327         my $relativeto = shift || ".";
1328
1329         $dir = catdir($base,$dir) unless isabsolute($dir);
1330
1331         # Make sure the directories we're building in exists
1332         mkpath($dir);
1333
1334         my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1335         #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1336         return $res;
1337     }
1338
1339     sub cleanfile {
1340         my $base = shift;
1341         my $file = shift;
1342         my $relativeto = shift || ".";
1343
1344         $file = catfile($base,$file) unless isabsolute($file);
1345
1346         my $d = dirname($file);
1347         my $f = basename($file);
1348
1349         # Make sure the directories we're building in exists
1350         mkpath($d);
1351
1352         my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1353         #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1354         return $res;
1355     }
1356
1357     # Store the name of the template file we will build the build file from
1358     # in %config.  This may be useful for the build file itself.
1359     my @build_file_template_names =
1360         ( $builder_platform."-".$target{build_file}.".tmpl",
1361           $target{build_file}.".tmpl" );
1362     my @build_file_templates = ();
1363
1364     # First, look in the user provided directory, if given
1365     if (defined $ENV{$local_config_envname}) {
1366         @build_file_templates =
1367             map {
1368                 if ($^O eq 'VMS') {
1369                     # VMS environment variables are logical names,
1370                     # which can be used as is
1371                     $local_config_envname . ':' . $_;
1372                 } else {
1373                     catfile($ENV{$local_config_envname}, $_);
1374                 }
1375             }
1376             @build_file_template_names;
1377     }
1378     # Then, look in our standard directory
1379     push @build_file_templates,
1380         ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1381           @build_file_template_names );
1382
1383     my $build_file_template;
1384     for $_ (@build_file_templates) {
1385         $build_file_template = $_;
1386         last if -f $build_file_template;
1387
1388         $build_file_template = undef;
1389     }
1390     if (!defined $build_file_template) {
1391         die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1392     }
1393     $config{build_file_templates}
1394       = [ $build_file_template,
1395           cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1396                     $blddir) ];
1397
1398     my @build_infos = ( [ ".", "build.info" ] );
1399     foreach (@{$config{dirs}}) {
1400         push @build_infos, [ $_, "build.info" ]
1401             if (-f catfile($srcdir, $_, "build.info"));
1402     }
1403     foreach (@{$config{sdirs}}) {
1404         push @build_infos, [ catdir("crypto", $_), "build.info" ]
1405             if (-f catfile($srcdir, "crypto", $_, "build.info"));
1406     }
1407     foreach (@{$config{engdirs}}) {
1408         push @build_infos, [ catdir("engines", $_), "build.info" ]
1409             if (-f catfile($srcdir, "engines", $_, "build.info"));
1410     }
1411
1412     $config{build_infos} = [ ];
1413
1414     foreach (@build_infos) {
1415         my $sourced = catdir($srcdir, $_->[0]);
1416         my $buildd = catdir($blddir, $_->[0]);
1417
1418         mkpath($buildd);
1419
1420         my $f = $_->[1];
1421         # The basic things we're trying to build
1422         my @programs = ();
1423         my @programs_install = ();
1424         my @libraries = ();
1425         my @libraries_install = ();
1426         my @engines = ();
1427         my @engines_install = ();
1428         my @scripts = ();
1429         my @scripts_install = ();
1430         my @extra = ();
1431         my @overrides = ();
1432         my @intermediates = ();
1433         my @rawlines = ();
1434
1435         my %ordinals = ();
1436         my %sources = ();
1437         my %shared_sources = ();
1438         my %includes = ();
1439         my %depends = ();
1440         my %renames = ();
1441         my %sharednames = ();
1442         my %generate = ();
1443
1444         push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1445         my $template = Text::Template->new(TYPE => 'FILE',
1446                                            SOURCE => catfile($sourced, $f));
1447         die "Something went wrong with $sourced/$f: $!\n" unless $template;
1448         my @text =
1449             split /^/m,
1450             $template->fill_in(HASH => { config => \%config,
1451                                          target => \%target,
1452                                          disabled => \%disabled,
1453                                          withargs => \%withargs,
1454                                          builddir => abs2rel($buildd, $blddir),
1455                                          sourcedir => abs2rel($sourced, $blddir),
1456                                          buildtop => abs2rel($blddir, $blddir),
1457                                          sourcetop => abs2rel($srcdir, $blddir) },
1458                                DELIMITERS => [ "{-", "-}" ]);
1459
1460         # The top item of this stack has the following values
1461         # -2 positive already run and we found ELSE (following ELSIF should fail)
1462         # -1 positive already run (skip until ENDIF)
1463         # 0 negatives so far (if we're at a condition, check it)
1464         # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1465         # 2 positive ELSE (following ELSIF should fail)
1466         my @skip = ();
1467         collect_information(
1468             collect_from_array([ @text ],
1469                                qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1470                                                 $l1 =~ s/\\$//; $l1.$l2 }),
1471             # Info we're looking for
1472             qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1473             => sub {
1474                 if (! @skip || $skip[$#skip] > 0) {
1475                     push @skip, !! $1;
1476                 } else {
1477                     push @skip, -1;
1478                 }
1479             },
1480             qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1481             => sub { die "ELSIF out of scope" if ! @skip;
1482                      die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1483                      $skip[$#skip] = -1 if $skip[$#skip] != 0;
1484                      $skip[$#skip] = !! $1
1485                          if $skip[$#skip] == 0; },
1486             qr/^\s*ELSE\s*$/
1487             => sub { die "ELSE out of scope" if ! @skip;
1488                      $skip[$#skip] = -2 if $skip[$#skip] != 0;
1489                      $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1490             qr/^\s*ENDIF\s*$/
1491             => sub { die "ENDIF out of scope" if ! @skip;
1492                      pop @skip; },
1493             qr/^\s*PROGRAMS(_NO_INST)?\s*=\s*(.*)\s*$/
1494             => sub {
1495                 if (!@skip || $skip[$#skip] > 0) {
1496                     my $install = $1;
1497                     my @x = tokenize($2);
1498                     push @programs, @x;
1499                     push @programs_install, @x unless $install;
1500                 }
1501             },
1502             qr/^\s*LIBS(_NO_INST)?\s*=\s*(.*)\s*$/
1503             => sub {
1504                 if (!@skip || $skip[$#skip] > 0) {
1505                     my $install = $1;
1506                     my @x = tokenize($2);
1507                     push @libraries, @x;
1508                     push @libraries_install, @x unless $install;
1509                 }
1510             },
1511             qr/^\s*ENGINES(_NO_INST)?\s*=\s*(.*)\s*$/
1512             => sub {
1513                 if (!@skip || $skip[$#skip] > 0) {
1514                     my $install = $1;
1515                     my @x = tokenize($2);
1516                     push @engines, @x;
1517                     push @engines_install, @x unless $install;
1518                 }
1519             },
1520             qr/^\s*SCRIPTS(_NO_INST)?\s*=\s*(.*)\s*$/
1521             => sub {
1522                 if (!@skip || $skip[$#skip] > 0) {
1523                     my $install = $1;
1524                     my @x = tokenize($2);
1525                     push @scripts, @x;
1526                     push @scripts_install, @x unless $install;
1527                 }
1528             },
1529             qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1530             => sub { push @extra, tokenize($1)
1531                          if !@skip || $skip[$#skip] > 0 },
1532             qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1533             => sub { push @overrides, tokenize($1)
1534                          if !@skip || $skip[$#skip] > 0 },
1535
1536             qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1537             => sub { push @{$ordinals{$1}}, tokenize($2)
1538                          if !@skip || $skip[$#skip] > 0 },
1539             qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1540             => sub { push @{$sources{$1}}, tokenize($2)
1541                          if !@skip || $skip[$#skip] > 0 },
1542             qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1543             => sub { push @{$shared_sources{$1}}, tokenize($2)
1544                          if !@skip || $skip[$#skip] > 0 },
1545             qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1546             => sub { push @{$includes{$1}}, tokenize($2)
1547                          if !@skip || $skip[$#skip] > 0 },
1548             qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1549             => sub { push @{$depends{$1}}, tokenize($2)
1550                          if !@skip || $skip[$#skip] > 0 },
1551             qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1552             => sub { push @{$generate{$1}}, $2
1553                          if !@skip || $skip[$#skip] > 0 },
1554             qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1555             => sub { push @{$renames{$1}}, tokenize($2)
1556                          if !@skip || $skip[$#skip] > 0 },
1557             qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1558             => sub { push @{$sharednames{$1}}, tokenize($2)
1559                          if !@skip || $skip[$#skip] > 0 },
1560             qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1561             => sub {
1562                 my $lineiterator = shift;
1563                 my $target_kind = $1;
1564                 while (defined $lineiterator->()) {
1565                     s|\R$||;
1566                     if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1567                         die "ENDRAW doesn't match BEGINRAW"
1568                             if $1 ne $target_kind;
1569                         last;
1570                     }
1571                     next if @skip && $skip[$#skip] <= 0;
1572                     push @rawlines,  $_
1573                         if ($target_kind eq $target{build_file}
1574                             || $target_kind eq $target{build_file}."(".$builder_platform.")");
1575                 }
1576             },
1577             qr/^(?:#.*|\s*)$/ => sub { },
1578             "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1579             "BEFORE" => sub {
1580                 if ($buildinfo_debug) {
1581                     print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1582                     print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1583                 }
1584             },
1585             "AFTER" => sub {
1586                 if ($buildinfo_debug) {
1587                     print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1588                 }
1589             },
1590             );
1591         die "runaway IF?" if (@skip);
1592
1593         foreach (keys %renames) {
1594             die "$_ renamed to more than one thing: "
1595                 ,join(" ", @{$renames{$_}}),"\n"
1596                 if scalar @{$renames{$_}} > 1;
1597             my $dest = cleanfile($buildd, $_, $blddir);
1598             my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1599             die "$dest renamed to more than one thing: "
1600                 ,$unified_info{rename}->{$dest}, $to
1601                 unless !defined($unified_info{rename}->{$dest})
1602                 or $unified_info{rename}->{$dest} eq $to;
1603             $unified_info{rename}->{$dest} = $to;
1604         }
1605
1606         foreach (@programs) {
1607             my $program = cleanfile($buildd, $_, $blddir);
1608             if ($unified_info{rename}->{$program}) {
1609                 $program = $unified_info{rename}->{$program};
1610             }
1611             $unified_info{programs}->{$program} = 1;
1612         }
1613
1614         foreach (@programs_install) {
1615             my $program = cleanfile($buildd, $_, $blddir);
1616             if ($unified_info{rename}->{$program}) {
1617                 $program = $unified_info{rename}->{$program};
1618             }
1619             $unified_info{install}->{programs}->{$program} = 1;
1620         }
1621
1622         foreach (@libraries) {
1623             my $library = cleanfile($buildd, $_, $blddir);
1624             if ($unified_info{rename}->{$library}) {
1625                 $library = $unified_info{rename}->{$library};
1626             }
1627             $unified_info{libraries}->{$library} = 1;
1628         }
1629
1630         foreach (@libraries_install) {
1631             my $library = cleanfile($buildd, $_, $blddir);
1632             if ($unified_info{rename}->{$library}) {
1633                 $library = $unified_info{rename}->{$library};
1634             }
1635             $unified_info{install}->{libraries}->{$library} = 1;
1636         }
1637
1638         die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1639 ENGINES can only be used if configured with 'dynamic-engine'.
1640 This is usually a fault in a build.info file.
1641 EOF
1642         foreach (@engines) {
1643             my $library = cleanfile($buildd, $_, $blddir);
1644             if ($unified_info{rename}->{$library}) {
1645                 $library = $unified_info{rename}->{$library};
1646             }
1647             $unified_info{engines}->{$library} = 1;
1648         }
1649
1650         foreach (@engines_install) {
1651             my $library = cleanfile($buildd, $_, $blddir);
1652             if ($unified_info{rename}->{$library}) {
1653                 $library = $unified_info{rename}->{$library};
1654             }
1655             $unified_info{install}->{engines}->{$library} = 1;
1656         }
1657
1658         foreach (@scripts) {
1659             my $script = cleanfile($buildd, $_, $blddir);
1660             if ($unified_info{rename}->{$script}) {
1661                 $script = $unified_info{rename}->{$script};
1662             }
1663             $unified_info{scripts}->{$script} = 1;
1664         }
1665
1666         foreach (@scripts_install) {
1667             my $script = cleanfile($buildd, $_, $blddir);
1668             if ($unified_info{rename}->{$script}) {
1669                 $script = $unified_info{rename}->{$script};
1670             }
1671             $unified_info{install}->{scripts}->{$script} = 1;
1672         }
1673
1674         foreach (@extra) {
1675             my $extra = cleanfile($buildd, $_, $blddir);
1676             $unified_info{extra}->{$extra} = 1;
1677         }
1678
1679         foreach (@overrides) {
1680             my $override = cleanfile($buildd, $_, $blddir);
1681             $unified_info{overrides}->{$override} = 1;
1682         }
1683
1684         push @{$unified_info{rawlines}}, @rawlines;
1685
1686         unless ($disabled{shared}) {
1687             # Check sharednames.
1688             foreach (keys %sharednames) {
1689                 my $dest = cleanfile($buildd, $_, $blddir);
1690                 if ($unified_info{rename}->{$dest}) {
1691                     $dest = $unified_info{rename}->{$dest};
1692                 }
1693                 die "shared_name for $dest with multiple values: "
1694                     ,join(" ", @{$sharednames{$_}}),"\n"
1695                     if scalar @{$sharednames{$_}} > 1;
1696                 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1697                 die "shared_name found for a library $dest that isn't defined\n"
1698                     unless $unified_info{libraries}->{$dest};
1699                 die "shared_name for $dest with multiple values: "
1700                     ,$unified_info{sharednames}->{$dest}, ", ", $to
1701                     unless !defined($unified_info{sharednames}->{$dest})
1702                     or $unified_info{sharednames}->{$dest} eq $to;
1703                 $unified_info{sharednames}->{$dest} = $to;
1704             }
1705
1706             # Additionally, we set up sharednames for libraries that don't
1707             # have any, as themselves.
1708             foreach (keys %{$unified_info{libraries}}) {
1709                 if (!defined $unified_info{sharednames}->{$_}) {
1710                     $unified_info{sharednames}->{$_} = $_
1711                 }
1712             }
1713         }
1714
1715         foreach (keys %ordinals) {
1716             my $dest = $_;
1717             my $ddest = cleanfile($buildd, $_, $blddir);
1718             if ($unified_info{rename}->{$ddest}) {
1719                 $ddest = $unified_info{rename}->{$ddest};
1720             }
1721             foreach (@{$ordinals{$dest}}) {
1722                 my %known_ordinals =
1723                     (
1724                      crypto =>
1725                      cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
1726                      ssl =>
1727                      cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
1728                     );
1729                 my $o = $known_ordinals{$_};
1730                 die "Ordinals for $ddest defined more than once\n"
1731                     if $unified_info{ordinals}->{$ddest};
1732                 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1733             }
1734         }
1735
1736         foreach (keys %sources) {
1737             my $dest = $_;
1738             my $ddest = cleanfile($buildd, $_, $blddir);
1739             if ($unified_info{rename}->{$ddest}) {
1740                 $ddest = $unified_info{rename}->{$ddest};
1741             }
1742             foreach (@{$sources{$dest}}) {
1743                 my $s = cleanfile($sourced, $_, $blddir);
1744
1745                 # If it isn't in the source tree, we assume it's generated
1746                 # in the build tree
1747                 if (! -f $s) {
1748                     $s = cleanfile($buildd, $_, $blddir);
1749                 }
1750                 # We recognise C and asm files
1751                 if ($s =~ /\.[csS]\b$/) {
1752                     (my $o = $_) =~ s/\.[csS]\b$/.o/;
1753                     $o = cleanfile($buildd, $o, $blddir);
1754                     $unified_info{sources}->{$ddest}->{$o} = 1;
1755                     $unified_info{sources}->{$o}->{$s} = 1;
1756                 } else {
1757                     $unified_info{sources}->{$ddest}->{$s} = 1;
1758                 }
1759             }
1760         }
1761
1762         foreach (keys %shared_sources) {
1763             my $dest = $_;
1764             my $ddest = cleanfile($buildd, $_, $blddir);
1765             if ($unified_info{rename}->{$ddest}) {
1766                 $ddest = $unified_info{rename}->{$ddest};
1767             }
1768             foreach (@{$shared_sources{$dest}}) {
1769                 my $s = cleanfile($sourced, $_, $blddir);
1770
1771                 # If it isn't in the source tree, we assume it's generated
1772                 # in the build tree
1773                 if (! -f $s) {
1774                     $s = cleanfile($buildd, $_, $blddir);
1775                 }
1776                 # We recognise C and asm files
1777                 if ($s =~ /\.[csS]\b$/) {
1778                     (my $o = $_) =~ s/\.[csS]\b$/.o/;
1779                     $o = cleanfile($buildd, $o, $blddir);
1780                     $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1781                     $unified_info{sources}->{$o}->{$s} = 1;
1782                 } else {
1783                     die "unrecognised source file type for shared library: $s\n";
1784                 }
1785             }
1786         }
1787
1788         foreach (keys %generate) {
1789             my $dest = $_;
1790             my $ddest = cleanfile($buildd, $_, $blddir);
1791             if ($unified_info{rename}->{$ddest}) {
1792                 $ddest = $unified_info{rename}->{$ddest};
1793             }
1794             die "more than one generator for $dest: "
1795                     ,join(" ", @{$generate{$_}}),"\n"
1796                     if scalar @{$generate{$_}} > 1;
1797             my @generator = split /\s+/, $generate{$dest}->[0];
1798             $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1799             $unified_info{generate}->{$ddest} = [ @generator ];
1800         }
1801
1802         foreach (keys %depends) {
1803             my $dest = $_;
1804             my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
1805
1806             # If the destination doesn't exist in source, it can only be
1807             # a generated file in the build tree.
1808             if ($ddest ne "" && ! -f $ddest) {
1809                 $ddest = cleanfile($buildd, $_, $blddir);
1810                 if ($unified_info{rename}->{$ddest}) {
1811                     $ddest = $unified_info{rename}->{$ddest};
1812                 }
1813             }
1814             foreach (@{$depends{$dest}}) {
1815                 my $d = cleanfile($sourced, $_, $blddir);
1816
1817                 # If we know it's generated, or assume it is because we can't
1818                 # find it in the source tree, we set file we depend on to be
1819                 # in the build tree rather than the source tree, and assume
1820                 # and that there are lines to build it in a BEGINRAW..ENDRAW
1821                 # section or in the Makefile template.
1822                 if (! -f $d
1823                     || (grep { $d eq $_ }
1824                         map { cleanfile($srcdir, $_, $blddir) }
1825                         grep { /\.h$/ } keys %{$unified_info{generate}})) {
1826                     $d = cleanfile($buildd, $_, $blddir);
1827                 }
1828                 # Take note if the file to depend on is being renamed
1829                 if ($unified_info{rename}->{$d}) {
1830                     $d = $unified_info{rename}->{$d};
1831                 }
1832                 $unified_info{depends}->{$ddest}->{$d} = 1;
1833                 # If we depend on a header file or a perl module, let's make
1834                 # sure it can get included
1835                 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
1836                     my $i = dirname($d);
1837                     push @{$unified_info{includes}->{$ddest}->{source}}, $i
1838                         unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}->{source}};
1839                 }
1840             }
1841         }
1842
1843         foreach (keys %includes) {
1844             my $dest = $_;
1845             my $ddest = cleanfile($sourced, $_, $blddir);
1846
1847             # If the destination doesn't exist in source, it can only be
1848             # a generated file in the build tree.
1849             if (! -f $ddest) {
1850                 $ddest = cleanfile($buildd, $_, $blddir);
1851                 if ($unified_info{rename}->{$ddest}) {
1852                     $ddest = $unified_info{rename}->{$ddest};
1853                 }
1854             }
1855             foreach (@{$includes{$dest}}) {
1856                 my $is = cleandir($sourced, $_, $blddir);
1857                 my $ib = cleandir($buildd, $_, $blddir);
1858                 push @{$unified_info{includes}->{$ddest}->{source}}, $is
1859                     unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
1860                 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
1861                     unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
1862             }
1863         }
1864     }
1865
1866     ### Make unified_info a bit more efficient
1867     # One level structures
1868     foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1869         $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1870     }
1871     # Two level structures
1872     foreach my $l1 (("install", "sources", "shared_sources", "ldadd", "depends")) {
1873         foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1874             $unified_info{$l1}->{$l2} =
1875                 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1876         }
1877     }
1878     # Includes
1879     foreach my $dest (sort keys %{$unified_info{includes}}) {
1880         if (defined($unified_info{includes}->{$dest}->{build})) {
1881             my @source_includes =
1882                 ( @{$unified_info{includes}->{$dest}->{source}} );
1883             $unified_info{includes}->{$dest} =
1884                 [ @{$unified_info{includes}->{$dest}->{build}} ];
1885             foreach my $inc (@source_includes) {
1886                 push @{$unified_info{includes}->{$dest}}, $inc
1887                     unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
1888             }
1889         } else {
1890             $unified_info{includes}->{$dest} =
1891                 [ @{$unified_info{includes}->{$dest}->{source}} ];
1892         }
1893     }
1894 }
1895
1896 # For the schemes that need it, we provide the old *_obj configs
1897 # from the *_asm_obj ones
1898 foreach (grep /_(asm|aux)_src$/, keys %target) {
1899     my $src = $_;
1900     (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1901     ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1902 }
1903
1904 # Write down our configuration where it fits #########################
1905
1906 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1907 print OUT <<"EOF";
1908 package configdata;
1909
1910 use strict;
1911 use warnings;
1912
1913 use Exporter;
1914 #use vars qw(\@ISA \@EXPORT);
1915 our \@ISA = qw(Exporter);
1916 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
1917
1918 EOF
1919 print OUT "our %config = (\n";
1920 foreach (sort keys %config) {
1921     if (ref($config{$_}) eq "ARRAY") {
1922         print OUT "  ", $_, " => [ ", join(", ",
1923                                            map { quotify("perl", $_) }
1924                                            @{$config{$_}}), " ],\n";
1925     } else {
1926         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1927     }
1928 }
1929 print OUT <<"EOF";
1930 );
1931
1932 EOF
1933 print OUT "our %target = (\n";
1934 foreach (sort keys %target) {
1935     if (ref($target{$_}) eq "ARRAY") {
1936         print OUT "  ", $_, " => [ ", join(", ",
1937                                            map { quotify("perl", $_) }
1938                                            @{$target{$_}}), " ],\n";
1939     } else {
1940         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1941     }
1942 }
1943 print OUT <<"EOF";
1944 );
1945
1946 EOF
1947 print OUT "our \%available_protocols = (\n";
1948 print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1949 print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1950 print OUT <<"EOF";
1951 );
1952
1953 EOF
1954 print OUT "our \@disablables = (\n";
1955 foreach (@disablables) {
1956     print OUT "  ", quotify("perl", $_), ",\n";
1957 }
1958 print OUT <<"EOF";
1959 );
1960
1961 EOF
1962 print OUT "our \%disabled = (\n";
1963 foreach (sort keys %disabled) {
1964     print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1965 }
1966 print OUT <<"EOF";
1967 );
1968
1969 EOF
1970 print OUT "our %withargs = (\n";
1971 foreach (sort keys %withargs) {
1972     if (ref($withargs{$_}) eq "ARRAY") {
1973         print OUT "  ", $_, " => [ ", join(", ",
1974                                            map { quotify("perl", $_) }
1975                                            @{$withargs{$_}}), " ],\n";
1976     } else {
1977         print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1978     }
1979 }
1980 print OUT <<"EOF";
1981 );
1982
1983 EOF
1984 if ($builder eq "unified") {
1985     my $recurse;
1986     $recurse = sub {
1987         my $indent = shift;
1988         foreach (@_) {
1989             if (ref $_ eq "ARRAY") {
1990                 print OUT " "x$indent, "[\n";
1991                 foreach (@$_) {
1992                     $recurse->($indent + 4, $_);
1993                 }
1994                 print OUT " "x$indent, "],\n";
1995             } elsif (ref $_ eq "HASH") {
1996                 my %h = %$_;
1997                 print OUT " "x$indent, "{\n";
1998                 foreach (sort keys %h) {
1999                     if (ref $h{$_} eq "") {
2000                         print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
2001                     } else {
2002                         print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
2003                         $recurse->($indent + 8, $h{$_});
2004                     }
2005                 }
2006                 print OUT " "x$indent, "},\n";
2007             } else {
2008                 print OUT " "x$indent, quotify("perl", $_), ",\n";
2009             }
2010         }
2011     };
2012     print OUT "our %unified_info = (\n";
2013     foreach (sort keys %unified_info) {
2014         if (ref $unified_info{$_} eq "") {
2015             print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
2016         } else {
2017             print OUT " "x4, quotify("perl", $_), " =>\n";
2018             $recurse->(8, $unified_info{$_});
2019         }
2020     }
2021     print OUT <<"EOF";
2022 );
2023
2024 EOF
2025 }
2026 print OUT "1;\n";
2027 close(OUT);
2028
2029 print "\n";
2030 print "PROCESSOR     =$config{processor}\n" if $config{processor};
2031 print "PERL          =$config{perl}\n";
2032 print "PERLVERSION   =$Config{version} for $Config{archname}\n";
2033 print "HASHBANGPERL  =$config{hashbangperl}\n";
2034 print "CC            =$config{cross_compile_prefix}$target{cc}\n";
2035 print "CFLAG         =$target{cflags} $config{cflags}\n";
2036 print "DEFINES       =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
2037 #print "RANLIB        =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
2038 #                             "$config{cross_compile_prefix}ranlib" :
2039 #                             "$target{ranlib}", "\n";
2040 print "EX_LIBS       =$target{ex_libs} $config{ex_libs}\n";
2041
2042 my %builders = (
2043     unified => sub {
2044         run_dofile(catfile($blddir, $target{build_file}),
2045                    @{$config{build_file_templates}});
2046     },
2047     );
2048
2049 $builders{$builder}->($builder_platform, @builder_opts);
2050
2051 print <<"EOF" if ($disabled{threads} eq "unavailable");
2052
2053 The library could not be configured for supporting multi-threaded
2054 applications as the compiler options required on this system are not known.
2055 See file INSTALL for details if you need multi-threading.
2056 EOF
2057
2058 print <<"EOF" if ($no_shared_warn);
2059
2060 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2061 platform, so we will pretend you gave the option 'no-pic', which also disables
2062 'shared' and 'dynamic-engine'.  If you know how to implement shared libraries
2063 or position independent code, please let us know (but please first make sure
2064 you have tried with a current version of OpenSSL).
2065 EOF
2066
2067 print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
2068
2069 WARNING: there are indications that another build was made in the source
2070 directory.  This build may have picked up artifacts from that build, the
2071 safest course of action is to clean the source directory and redo this
2072 configuration.
2073 EOF
2074
2075 exit(0);
2076
2077 ######################################################################
2078 #
2079 # Helpers and utility functions
2080 #
2081
2082 # Configuration file reading #########################################
2083
2084 # Note: All of the helper functions are for lazy evaluation.  They all
2085 # return a CODE ref, which will return the intended value when evaluated.
2086 # Thus, whenever there's mention of a returned value, it's about that
2087 # intended value.
2088
2089 # Helper function to implement conditional inheritance depending on the
2090 # value of $disabled{asm}.  Used in inherit_from values as follows:
2091 #
2092 #      inherit_from => [ "template", asm("asm_tmpl") ]
2093 #
2094 sub asm {
2095     my @x = @_;
2096     sub {
2097         $disabled{asm} ? () : @x;
2098     }
2099 }
2100
2101 # Helper function to implement conditional value variants, with a default
2102 # plus additional values based on the value of $config{build_type}.
2103 # Arguments are given in hash table form:
2104 #
2105 #       picker(default => "Basic string: ",
2106 #              debug   => "debug",
2107 #              release => "release")
2108 #
2109 # When configuring with --debug, the resulting string will be
2110 # "Basic string: debug", and when not, it will be "Basic string: release"
2111 #
2112 # This can be used to create variants of sets of flags according to the
2113 # build type:
2114 #
2115 #       cflags => picker(default => "-Wall",
2116 #                        debug   => "-g -O0",
2117 #                        release => "-O3")
2118 #
2119 sub picker {
2120     my %opts = @_;
2121     return sub { add($opts{default} || (),
2122                      $opts{$config{build_type}} || ())->(); }
2123 }
2124
2125 # Helper function to combine several values of different types into one.
2126 # This is useful if you want to combine a string with the result of a
2127 # lazy function, such as:
2128 #
2129 #       cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2130 #
2131 sub combine {
2132     my @stuff = @_;
2133     return sub { add(@stuff)->(); }
2134 }
2135
2136 # Helper function to implement conditional values depending on the value
2137 # of $disabled{threads}.  Can be used as follows:
2138 #
2139 #       cflags => combine("-Wall", threads("-pthread"))
2140 #
2141 sub threads {
2142     my @flags = @_;
2143     return sub { add($disabled{threads} ? () : @flags)->(); }
2144 }
2145
2146
2147
2148 our $add_called = 0;
2149 # Helper function to implement adding values to already existing configuration
2150 # values.  It handles elements that are ARRAYs, CODEs and scalars
2151 sub _add {
2152     my $separator = shift;
2153
2154     # If there's any ARRAY in the collection of values OR the separator
2155     # is undef, we will return an ARRAY of combined values, otherwise a
2156     # string of joined values with $separator as the separator.
2157     my $found_array = !defined($separator);
2158
2159     my @values =
2160         map {
2161             my $res = $_;
2162             while (ref($res) eq "CODE") {
2163                 $res = $res->();
2164             }
2165             if (defined($res)) {
2166                 if (ref($res) eq "ARRAY") {
2167                     $found_array = 1;
2168                     @$res;
2169                 } else {
2170                     $res;
2171                 }
2172             } else {
2173                 ();
2174             }
2175     } (@_);
2176
2177     $add_called = 1;
2178
2179     if ($found_array) {
2180         [ @values ];
2181     } else {
2182         join($separator, grep { defined($_) && $_ ne "" } @values);
2183     }
2184 }
2185 sub add_before {
2186     my $separator = " ";
2187     if (ref($_[$#_]) eq "HASH") {
2188         my $opts = pop;
2189         $separator = $opts->{separator};
2190     }
2191     my @x = @_;
2192     sub { _add($separator, @x, @_) };
2193 }
2194 sub add {
2195     my $separator = " ";
2196     if (ref($_[$#_]) eq "HASH") {
2197         my $opts = pop;
2198         $separator = $opts->{separator};
2199     }
2200     my @x = @_;
2201     sub { _add($separator, @_, @x) };
2202 }
2203
2204 # configuration reader, evaluates the input file as a perl script and expects
2205 # it to fill %targets with target configurations.  Those are then added to
2206 # %table.
2207 sub read_config {
2208     my $fname = shift;
2209     open(CONFFILE, "< $fname")
2210         or die "Can't open configuration file '$fname'!\n";
2211     my $x = $/;
2212     undef $/;
2213     my $content = <CONFFILE>;
2214     $/ = $x;
2215     close(CONFFILE);
2216     my %targets = ();
2217     {
2218         # Protect certain tables from tampering
2219         local %table = %::table;
2220
2221         eval $content;
2222         warn $@ if $@;
2223     }
2224
2225     # For each target, check that it's configured with a hash table.
2226     foreach (keys %targets) {
2227         if (ref($targets{$_}) ne "HASH") {
2228             if (ref($targets{$_}) eq "") {
2229                 warn "Deprecated target configuration for $_, ignoring...\n";
2230             } else {
2231                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2232             }
2233             delete $targets{$_};
2234         } else {
2235             $targets{$_}->{_conf_fname_int} = add([ $fname ]);
2236         }
2237     }
2238
2239     %table = (%table, %targets);
2240
2241 }
2242
2243 # configuration resolver.  Will only resolve all the lazy evaluation
2244 # codeblocks for the chosen target and all those it inherits from,
2245 # recursively
2246 sub resolve_config {
2247     my $target = shift;
2248     my @breadcrumbs = @_;
2249
2250 #    my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2251
2252     if (grep { $_ eq $target } @breadcrumbs) {
2253         die "inherit_from loop!  target backtrace:\n  "
2254             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
2255     }
2256
2257     if (!defined($table{$target})) {
2258         warn "Warning! target $target doesn't exist!\n";
2259         return ();
2260     }
2261     # Recurse through all inheritances.  They will be resolved on the
2262     # fly, so when this operation is done, they will all just be a
2263     # bunch of attributes with string values.
2264     # What we get here, though, are keys with references to lists of
2265     # the combined values of them all.  We will deal with lists after
2266     # this stage is done.
2267     my %combined_inheritance = ();
2268     if ($table{$target}->{inherit_from}) {
2269         my @inherit_from =
2270             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2271         foreach (@inherit_from) {
2272             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2273
2274             # 'template' is a marker that's considered private to
2275             # the config that had it.
2276             delete $inherited_config{template};
2277
2278             foreach (keys %inherited_config) {
2279                 if (!$combined_inheritance{$_}) {
2280                     $combined_inheritance{$_} = [];
2281                 }
2282                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2283             }
2284         }
2285     }
2286
2287     # We won't need inherit_from in this target any more, since we've
2288     # resolved all the inheritances that lead to this
2289     delete $table{$target}->{inherit_from};
2290
2291     # Now is the time to deal with those lists.  Here's the place to
2292     # decide what shall be done with those lists, all based on the
2293     # values of the target we're currently dealing with.
2294     # - If a value is a coderef, it will be executed with the list of
2295     #   inherited values as arguments.
2296     # - If the corresponding key doesn't have a value at all or is the
2297     #   empty string, the inherited value list will be run through the
2298     #   default combiner (below), and the result becomes this target's
2299     #   value.
2300     # - Otherwise, this target's value is assumed to be a string that
2301     #   will simply override the inherited list of values.
2302     my $default_combiner = add();
2303
2304     my %all_keys =
2305         map { $_ => 1 } (keys %combined_inheritance,
2306                          keys %{$table{$target}});
2307
2308     sub process_values {
2309         my $object    = shift;
2310         my $inherited = shift;  # Always a [ list ]
2311         my $target    = shift;
2312         my $entry     = shift;
2313
2314         $add_called = 0;
2315
2316         while(ref($object) eq "CODE") {
2317             $object = $object->(@$inherited);
2318         }
2319         if (!defined($object)) {
2320             return ();
2321         }
2322         elsif (ref($object) eq "ARRAY") {
2323             local $add_called;  # To make sure recursive calls don't affect it
2324             return [ map { process_values($_, $inherited, $target, $entry) }
2325                      @$object ];
2326         } elsif (ref($object) eq "") {
2327             return $object;
2328         } else {
2329             die "cannot handle reference type ",ref($object)
2330                 ," found in target ",$target," -> ",$entry,"\n";
2331         }
2332     }
2333
2334     foreach (sort keys %all_keys) {
2335         my $previous = $combined_inheritance{$_};
2336
2337         # Current target doesn't have a value for the current key?
2338         # Assign it the default combiner, the rest of this loop body
2339         # will handle it just like any other coderef.
2340         if (!exists $table{$target}->{$_}) {
2341             $table{$target}->{$_} = $default_combiner;
2342         }
2343
2344         $table{$target}->{$_} = process_values($table{$target}->{$_},
2345                                                $combined_inheritance{$_},
2346                                                $target, $_);
2347         unless(defined($table{$target}->{$_})) {
2348             delete $table{$target}->{$_};
2349         }
2350 #        if ($extra_checks &&
2351 #            $previous && !($add_called ||  $previous ~~ $table{$target}->{$_})) {
2352 #            warn "$_ got replaced in $target\n";
2353 #        }
2354     }
2355
2356     # Finally done, return the result.
2357     return %{$table{$target}};
2358 }
2359
2360 sub usage
2361         {
2362         print STDERR $usage;
2363         print STDERR "\npick os/compiler from:\n";
2364         my $j=0;
2365         my $i;
2366         my $k=0;
2367         foreach $i (sort keys %table)
2368                 {
2369                 next if $table{$i}->{template};
2370                 next if $i =~ /^debug/;
2371                 $k += length($i) + 1;
2372                 if ($k > 78)
2373                         {
2374                         print STDERR "\n";
2375                         $k=length($i);
2376                         }
2377                 print STDERR $i . " ";
2378                 }
2379         foreach $i (sort keys %table)
2380                 {
2381                 next if $table{$i}->{template};
2382                 next if $i !~ /^debug/;
2383                 $k += length($i) + 1;
2384                 if ($k > 78)
2385                         {
2386                         print STDERR "\n";
2387                         $k=length($i);
2388                         }
2389                 print STDERR $i . " ";
2390                 }
2391         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2392         exit(1);
2393         }
2394
2395 sub run_dofile
2396 {
2397     my $out = shift;
2398     my @templates = @_;
2399
2400     unlink $out || warn "Can't remove $out, $!"
2401         if -f $out;
2402     foreach (@templates) {
2403         die "Can't open $_, $!" unless -f $_;
2404     }
2405     my $perlcmd = (quotify("maybeshell", $config{perl}))[0];
2406     my $cmd = "$perlcmd \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2407     #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2408     system($cmd);
2409     exit 1 if $? != 0;
2410     rename("$out.new", $out) || die "Can't rename $out.new, $!";
2411 }
2412
2413 sub which
2414 {
2415     my ($name)=@_;
2416
2417     if (eval { require IPC::Cmd; 1; }) {
2418         IPC::Cmd->import();
2419         return scalar IPC::Cmd::can_run($name);
2420     } else {
2421         # if there is $directories component in splitpath,
2422         # then it's not something to test with $PATH...
2423         return $name if (File::Spec->splitpath($name))[1];
2424
2425         foreach (File::Spec->path()) {
2426             my $fullpath = catfile($_, "$name$target{exe_extension}");
2427             if (-f $fullpath and -x $fullpath) {
2428                 return $fullpath;
2429             }
2430         }
2431     }
2432 }
2433
2434 # Configuration printer ##############################################
2435
2436 sub print_table_entry
2437 {
2438     my $target = shift;
2439     my %target = resolve_config($target);
2440     my $type = shift;
2441
2442     # Don't print the templates
2443     return if $target{template};
2444
2445     my @sequence = (
2446         "sys_id",
2447         "cc",
2448         "cflags",
2449         "defines",
2450         "unistd",
2451         "ld",
2452         "lflags",
2453         "loutflag",
2454         "plib_lflags",
2455         "ex_libs",
2456         "bn_ops",
2457         "apps_aux_src",
2458         "cpuid_asm_src",
2459         "uplink_aux_src",
2460         "bn_asm_src",
2461         "ec_asm_src",
2462         "des_asm_src",
2463         "aes_asm_src",
2464         "bf_asm_src",
2465         "md5_asm_src",
2466         "cast_asm_src",
2467         "sha1_asm_src",
2468         "rc4_asm_src",
2469         "rmd160_asm_src",
2470         "rc5_asm_src",
2471         "wp_asm_src",
2472         "cmll_asm_src",
2473         "modes_asm_src",
2474         "padlock_asm_src",
2475         "chacha_asm_src",
2476         "poly1035_asm_src",
2477         "thread_scheme",
2478         "perlasm_scheme",
2479         "dso_scheme",
2480         "shared_target",
2481         "shared_cflag",
2482         "shared_defines",
2483         "shared_ldflag",
2484         "shared_rcflag",
2485         "shared_extension",
2486         "dso_extension",
2487         "obj_extension",
2488         "exe_extension",
2489         "ranlib",
2490         "ar",
2491         "arflags",
2492         "aroutflag",
2493         "rc",
2494         "rcflags",
2495         "rcoutflag",
2496         "mt",
2497         "mtflags",
2498         "mtinflag",
2499         "mtoutflag",
2500         "multilib",
2501         "build_scheme",
2502         );
2503
2504     if ($type eq "TABLE") {
2505         print "\n";
2506         print "*** $target\n";
2507         foreach (@sequence) {
2508             if (ref($target{$_}) eq "ARRAY") {
2509                 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2510             } else {
2511                 printf "\$%-12s = %s\n", $_, $target{$_};
2512             }
2513         }
2514     } elsif ($type eq "HASH") {
2515         my $largest =
2516             length((sort { length($a) <=> length($b) } @sequence)[-1]);
2517         print "    '$target' => {\n";
2518         foreach (@sequence) {
2519             if ($target{$_}) {
2520                 if (ref($target{$_}) eq "ARRAY") {
2521                     print "      '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2522                 } else {
2523                     print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2524                 }
2525             }
2526         }
2527         print "    },\n";
2528     }
2529 }
2530
2531 # Utility routines ###################################################
2532
2533 # On VMS, if the given file is a logical name, File::Spec::Functions
2534 # will consider it an absolute path.  There are cases when we want a
2535 # purely syntactic check without checking the environment.
2536 sub isabsolute {
2537     my $file = shift;
2538
2539     # On non-platforms, we just use file_name_is_absolute().
2540     return file_name_is_absolute($file) unless $^O eq "VMS";
2541
2542     # If the file spec includes a device or a directpry spec,
2543     # file_name_is_absolute() is perfectly safe.
2544     return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2545
2546     # Here, we know the given file spec isn't absolute
2547     return 0;
2548 }
2549
2550 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2551 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2552 # realpath() requires that at least all path components except the last is an
2553 # existing directory.  On VMS, the last component of the directory spec must
2554 # exist.
2555 sub absolutedir {
2556     my $dir = shift;
2557
2558     # realpath() is quite buggy on VMS.  It uses LIB$FID_TO_NAME, which
2559     # will return the volume name for the device, no matter what.  Also,
2560     # it will return an incorrect directory spec if the argument is a
2561     # directory that doesn't exist.
2562     if ($^O eq "VMS") {
2563         return rel2abs($dir);
2564     }
2565
2566     # We use realpath() on Unix, since no other will properly clean out
2567     # a directory spec.
2568     use Cwd qw/realpath/;
2569
2570     return realpath($dir);
2571 }
2572
2573 sub quotify {
2574     my %processors = (
2575         perl    => sub { my $x = shift;
2576                          $x =~ s/([\\\$\@"])/\\$1/g;
2577                          return '"'.$x.'"'; },
2578         maybeshell => sub { my $x = shift;
2579                             (my $y = $x) =~ s/([\\\"])/\\$1/g;
2580                             if ($x ne $y || $x =~ m|\s|) {
2581                                 return '"'.$y.'"';
2582                             } else {
2583                                 return $x;
2584                             }
2585                         },
2586         );
2587     my $for = shift;
2588     my $processor =
2589         defined($processors{$for}) ? $processors{$for} : sub { shift; };
2590
2591     return map { $processor->($_); } @_;
2592 }
2593
2594 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2595 # $filename is a file name to read from
2596 # $line_concat_cond_re is a regexp detecting a line continuation ending
2597 # $line_concat is a CODEref that takes care of concatenating two lines
2598 sub collect_from_file {
2599     my $filename = shift;
2600     my $line_concat_cond_re = shift;
2601     my $line_concat = shift;
2602
2603     open my $fh, $filename || die "unable to read $filename: $!\n";
2604     return sub {
2605         my $saved_line = "";
2606         $_ = "";
2607         while (<$fh>) {
2608             s|\R$||;
2609             if (defined $line_concat) {
2610                 $_ = $line_concat->($saved_line, $_);
2611                 $saved_line = "";
2612             }
2613             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2614                 $saved_line = $_;
2615                 next;
2616             }
2617             return $_;
2618         }
2619         die "$filename ending with continuation line\n" if $_;
2620         close $fh;
2621         return undef;
2622     }
2623 }
2624
2625 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2626 # $array is an ARRAYref of lines
2627 # $line_concat_cond_re is a regexp detecting a line continuation ending
2628 # $line_concat is a CODEref that takes care of concatenating two lines
2629 sub collect_from_array {
2630     my $array = shift;
2631     my $line_concat_cond_re = shift;
2632     my $line_concat = shift;
2633     my @array = (@$array);
2634
2635     return sub {
2636         my $saved_line = "";
2637         $_ = "";
2638         while (defined($_ = shift @array)) {
2639             s|\R$||;
2640             if (defined $line_concat) {
2641                 $_ = $line_concat->($saved_line, $_);
2642                 $saved_line = "";
2643             }
2644             if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2645                 $saved_line = $_;
2646                 next;
2647             }
2648             return $_;
2649         }
2650         die "input text ending with continuation line\n" if $_;
2651         return undef;
2652     }
2653 }
2654
2655 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2656 # $lineiterator is a CODEref that delivers one line at a time.
2657 # All following arguments are regex/CODEref pairs, where the regexp detects a
2658 # line and the CODEref does something with the result of the regexp.
2659 sub collect_information {
2660     my $lineiterator = shift;
2661     my %collectors = @_;
2662
2663     while(defined($_ = $lineiterator->())) {
2664         s|\R$||;
2665         my $found = 0;
2666         if ($collectors{"BEFORE"}) {
2667             $collectors{"BEFORE"}->($_);
2668         }
2669         foreach my $re (keys %collectors) {
2670             if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
2671                 $collectors{$re}->($lineiterator);
2672                 $found = 1;
2673             };
2674         }
2675         if ($collectors{"OTHERWISE"}) {
2676             $collectors{"OTHERWISE"}->($lineiterator, $_)
2677                 unless $found || !defined $collectors{"OTHERWISE"};
2678         }
2679         if ($collectors{"AFTER"}) {
2680             $collectors{"AFTER"}->($_);
2681         }
2682     }
2683 }
2684
2685 # tokenize($line)
2686 # $line is a line of text to split up into tokens
2687 # returns a list of tokens
2688 #
2689 # Tokens are divided by spaces.  If the tokens include spaces, they
2690 # have to be quoted with single or double quotes.  Double quotes
2691 # inside a double quoted token must be escaped.  Escaping is done
2692 # with backslash.
2693 # Basically, the same quoting rules apply for " and ' as in any
2694 # Unix shell.
2695 sub tokenize {
2696     my $line = my $debug_line = shift;
2697     my @result = ();
2698
2699     while ($line =~ s|^\s+||, $line ne "") {
2700         my $token = "";
2701         while ($line ne "" && $line !~ m|^\s|) {
2702             if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2703                 $token .= $1;
2704                 $line = $';
2705             } elsif ($line =~ m/^'([^']*)'/) {
2706                 $token .= $1;
2707                 $line = $';
2708             } elsif ($line =~ m/^(\S+)/) {
2709                 $token .= $1;
2710                 $line = $';
2711             }
2712         }
2713         push @result, $token;
2714     }
2715
2716     if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2717         print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2718         print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";
2719     }
2720     return @result;
2721 }