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