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