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