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