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