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