Configure

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