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