Configure

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