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