Fix check of what makedepprog should be
[openssl.git] / Configure
1 #! /usr/bin/env perl
2 # -*- mode: perl; -*-
3
4 ##
5 ##  Configure -- OpenSSL source tree configuration script
6 ##  If editing this file, run this command before committing
7 ##      make -f Makefile.in TABLE
8 ##
9
10 require 5.000;
11 use strict;
12 use File::Basename;
13 use File::Spec::Functions;
14
15 # see INSTALL for instructions.
16
17 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [experimental-<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";
18
19 # Options:
20 #
21 # --config      add the given configuration file, which will be read after
22 #               any "Configurations*" files that are found in the same
23 #               directory as this script.
24 # --prefix      prefix for the OpenSSL installation, which includes the
25 #               directories bin, lib, include, share/man, share/doc/openssl
26 #               This becomes the value of INSTALLTOP in Makefile
27 #               (Default: /usr/local)
28 # --openssldir  OpenSSL data area, such as openssl.cnf, certificates and keys.
29 #               If it's a relative directory, it will be added on the directory
30 #               given with --prefix.
31 #               This becomes the value of OPENSSLDIR in Makefile and in C.
32 #               (Default: PREFIX/ssl)
33 #
34 # --install_prefix  Additional prefix for package builders (empty by
35 #               default).  This needn't be set in advance, you can
36 #               just as well use "make INSTALL_PREFIX=/whatever install".
37 #
38 # --cross-compile-prefix Add specified prefix to binutils components.
39 #
40 # --api         One of 0.9.8, 1.0.0 or 1.1.0.  Do not compile support for
41 #               interfaces deprecated as of the specified OpenSSL version.
42 #
43 # no-hw-xxx     do not compile support for specific crypto hardware.
44 #               Generic OpenSSL-style methods relating to this support
45 #               are always compiled but return NULL if the hardware
46 #               support isn't compiled.
47 # no-hw         do not compile support for any crypto hardware.
48 # [no-]threads  [don't] try to create a library that is suitable for
49 #               multithreaded applications (default is "threads" if we
50 #               know how to do it)
51 # [no-]shared   [don't] try to create shared libraries when supported.
52 # no-asm        do not use assembler
53 # no-dso        do not compile in any native shared-library methods. This
54 #               will ensure that all methods just return NULL.
55 # no-egd        do not compile support for the entropy-gathering daemon APIs
56 # [no-]zlib     [don't] compile support for zlib compression.
57 # zlib-dynamic  Like "zlib", but the zlib library is expected to be a shared
58 #               library and will be loaded in run-time by the OpenSSL library.
59 # sctp          include SCTP support
60 # 386           generate 80386 code
61 # no-sse2       disables IA-32 SSE2 code, above option implies no-sse2
62 # no-<cipher>   build without specified algorithm (rsa, idea, rc5, ...)
63 # -<xxx> +<xxx> compiler options are passed through
64 #
65 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
66 #               provided to stack calls. Generates unique stack functions for
67 #               each possible stack type.
68 # DES_PTR       use pointer lookup vs arrays in the DES in crypto/des/des_locl.h
69 # DES_RISC1     use different DES_ENCRYPT macro that helps reduce register
70 #               dependancies but needs to more registers, good for RISC CPU's
71 # DES_RISC2     A different RISC variant.
72 # DES_UNROLL    unroll the inner DES loop, sometimes helps, somtimes hinders.
73 # DES_INT       use 'int' instead of 'long' for DES_LONG in crypto/des/des.h
74 #               This is used on the DEC Alpha where long is 8 bytes
75 #               and int is 4
76 # BN_LLONG      use the type 'long long' in crypto/bn/bn.h
77 # MD2_CHAR      use 'char' instead of 'int' for MD2_INT in crypto/md2/md2.h
78 # MD2_LONG      use 'long' instead of 'int' for MD2_INT in crypto/md2/md2.h
79 # IDEA_SHORT    use 'short' instead of 'int' for IDEA_INT in crypto/idea/idea.h
80 # IDEA_LONG     use 'long' instead of 'int' for IDEA_INT in crypto/idea/idea.h
81 # RC2_SHORT     use 'short' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
82 # RC2_LONG      use 'long' instead of 'int' for RC2_INT in crypto/rc2/rc2.h
83 # RC4_CHAR      use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
84 # RC4_LONG      use 'long' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
85 # RC4_INDEX     define RC4_INDEX in crypto/rc4/rc4_locl.h.  This turns on
86 #               array lookups instead of pointer use.
87 # RC4_CHUNK     enables code that handles data aligned at long (natural CPU
88 #               word) boundary.
89 # RC4_CHUNK_LL  enables code that handles data aligned at long long boundary
90 #               (intended for 64-bit CPUs running 32-bit OS).
91 # BF_PTR        use 'pointer arithmatic' for Blowfish (unsafe on Alpha).
92 # BF_PTR2       intel specific version (generic version is more efficient).
93 #
94 # Following are set automatically by this script
95 #
96 # MD5_ASM       use some extra md5 assember,
97 # SHA1_ASM      use some extra sha1 assember, must define L_ENDIAN for x86
98 # RMD160_ASM    use some extra ripemd160 assember,
99 # SHA256_ASM    sha256_block is implemented in assembler
100 # SHA512_ASM    sha512_block is implemented in assembler
101 # AES_ASM       ASE_[en|de]crypt is implemented in assembler
102
103 # Minimum warning options... any contributions to OpenSSL should at least get
104 # past these.
105
106 my $gcc_devteam_warn = "-Wall -pedantic -DPEDANTIC -Wno-long-long -Wsign-compare -Wmissing-prototypes -Wshadow -Wformat -Wtype-limits -Werror -DREF_CHECK -DDEBUG_UNUSED";
107
108 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
109 # TODO(openssl-team): fix problems and investigate if (at least) the
110 # following warnings can also be enabled:
111 # -Wswitch-enum, -Wunused-macros, -Wmissing-field-initializers,
112 # -Wcast-align,
113 # -Wunreachable-code -Wunused-parameter -Wlanguage-extension-token
114 # -Wextended-offsetof
115 my $clang_devteam_warn = "-Wno-unused-parameter -Wno-missing-field-initializers -Wno-language-extension-token -Wno-extended-offsetof -Wconditional-uninitialized -Qunused-arguments -Wincompatible-pointer-types-discards-qualifiers -Wmissing-variable-declarations";
116
117 # Warn that "make depend" should be run?
118 my $warn_make_depend = 0;
119
120 # These are used in addition to $gcc_devteam_warn unless this is a mingw build.
121 # This adds backtrace information to the memory leak info.
122 my $memleak_devteam_backtrace = "-rdynamic -DCRYPTO_MDEBUG_BACKTRACE";
123
124
125 my $strict_warnings = 0;
126
127 my $x86_gcc_des="DES_PTR DES_RISC1 DES_UNROLL";
128
129 # MD2_CHAR slags pentium pros
130 my $x86_gcc_opts="RC4_INDEX MD2_INT";
131
132 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
133 # which would cover all BSD flavors. -pthread applies to them all,
134 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
135 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
136 # which has to be accompanied by explicit -D_THREAD_SAFE and
137 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
138 # seems to be sufficient?
139 my $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
140
141 #
142 # API compability name to version number mapping.
143 #
144 my $maxapi = "1.1.0";           # API for "no-deprecated" builds
145 my $apitable = {
146     "1.1.0" => "0x10100000L",
147     "1.0.0" => "0x10000000L",
148     "0.9.8" => "0x00908000L",
149 };
150
151 my $base_target = "BASE";   # The template that all other inherit from
152 our %table = ();
153 our %config = ();
154
155 # Forward declarations ###############################################
156
157 # read_config(filename)
158 #
159 # Reads a configuration file and populates %table with the contents
160 # (which the configuration file places in %targets).
161 sub read_config;
162
163 # resolve_config(target)
164 #
165 # Resolves all the late evalutations, inheritances and so on for the
166 # chosen target and any target it inherits from.
167 sub resolve_config;
168
169
170 # Information collection #############################################
171
172 # Collect version numbers
173 $config{version} = "unknown";
174 $config{version_num} = "unknown";
175 $config{shlib_version_number} = "unknown";
176 $config{shlib_version_history} = "unknown";
177
178 collect_information(
179     '<include/openssl/opensslv.h',
180     undef,
181     qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
182     qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/      => sub { $config{version_num}=$1 },
183     qr/SHLIB_VERSION_NUMBER *"([^"]+)"/      => sub { $config{shlib_version_number}=$1 },
184     qr/SHLIB_VERSION_HISTORY *"([^"]*)"/     => sub { $config{shlib_version_history}=$1 }
185     );
186 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
187
188 ($config{major}, $config{minor})
189     = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
190 ($config{shlib_major}, $config{shlib_minor})
191     = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
192 die "erroneous version information in opensslv.h: ",
193     "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
194     if ($config{major} eq "" || $config{minor} eq ""
195         || $config{shlib_major} eq "" ||  $config{shlib_minor} eq "");
196
197 # Collect target configurations
198
199 my ($vol, $dir, $dummy) = File::Spec->splitpath($0);
200 my $pattern = File::Spec->catpath($vol, $dir, "Configurations/*.conf");
201 foreach (sort glob($pattern) ) {
202     &read_config($_);
203 }
204
205
206 print "Configuring OpenSSL version $config{version} (0x$config{version_num})\n";
207
208 $config{perl};
209 $config{prefix}="";
210 $config{openssldir}="";
211 $config{processor}="";
212 $config{libdir}="";
213 $config{install_prefix}= "$ENV{'INSTALL_PREFIX'}";
214 $config{cross_compile_prefix}="";
215 $config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/";
216 my $nofipscanistercheck=0;
217 $config{baseaddr}="0xFB00000";
218 my $no_threads=0;
219 my $threads=0;
220 $config{no_shared}=0; # but "no-shared" is default
221 my $zlib=1;      # but "no-zlib" is default
222 my $no_rfc3779=0;
223 my $no_asm=0;
224 my $no_dso=0;
225 my $Makefile="Makefile";
226 my $default_ranlib;
227 $config{fips}=0;
228
229 # Top level directories to build
230 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "tools" ];
231 # crypto/ subdirectories to build
232 $config{sdirs} = [
233     "objects",
234     "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305",
235     "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes",
236     "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
237     "buffer", "bio", "stack", "lhash", "rand", "err",
238     "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
239     "cms", "ts", "jpake", "srp", "store", "cmac", "ct", "async", "kdf"
240     ];
241
242 # Known TLS and DTLS protocols
243 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
244 my @dtls = qw(dtls1 dtls1_2);
245
246 # Explicitelly known options that are possible to disable.  They can
247 # be regexps, and will be used like this: /^no-${option}$/
248 # For developers: keep it sorted alphabetically
249
250 my @disablables = (
251     "aes",
252     "asm",
253     "bf",
254     "camellia",
255     "capieng",
256     "cast",
257     "chacha",
258     "cmac",
259     "cms",
260     "comp",
261     "crypto-mdebug",
262     "ct",
263     "deprecated",
264     "des",
265     "dgram",
266     "dh",
267     "dsa",
268     "dso",
269     "dtls",
270     "dynamic[-_]engine",
271     "ec",
272     "ec2m",
273     "ecdh",
274     "ecdsa",
275     "ec_nistp_64_gcc_128",
276     "engine",
277     "err",                      # Really???
278     "heartbeats",
279     "hmac",
280     "hw(-.+)?",
281     "idea",
282     "jpake",
283     "locking",                  # Really???
284     "md2",
285     "md4",
286     "md5",
287     "mdc2",
288     "md[-_]ghost94",
289     "nextprotoneg",
290     "ocb",
291     "ocsp",
292     "poly1305",
293     "posix-io",
294     "psk",
295     "rc2",
296     "rc4",
297     "rc5",
298     "rdrand",
299     "rfc3779",
300     "rijndael",                 # Old AES name
301     "rmd160",
302     "rsa",
303     "scrypt",
304     "sct",
305     "sctp",
306     "seed",
307     "sha",
308     "shared",
309     "sock",
310     "srp",
311     "srtp",
312     "sse2",
313     "ssl",
314     "ssl-trace",
315     "static-engine",
316     "stdio",
317     "store",
318     "threads",
319     "tls",
320     "unit-test",
321     "whirlpool",
322     "zlib",
323     "zlib-dynamic",
324     );
325 foreach my $proto ((@tls, @dtls))
326         {
327         push(@disablables, $proto);
328         push(@disablables, "$proto-method");
329         }
330
331 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
332
333 my %disabled = ( # "what"         => "comment" [or special keyword "experimental"]
334                  "ec_nistp_64_gcc_128" => "default",
335                  "egd"            => "default",
336                  "jpake"          => "experimental",
337                  "md2"            => "default",
338                  "rc5"            => "default",
339                  "sctp"           => "default",
340                  "shared"         => "default",
341                  "ssl-trace"      => "default",
342                  "store"          => "experimental",
343                  "unit-test"      => "default",
344                  "zlib"           => "default",
345                  "zlib-dynamic"   => "default",
346                  "crypto-mdebug"  => "default",
347                );
348 my @experimental = ();
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     "rijndael"          => [ "aes" ],
359     "des"               => [ "mdc2" ],
360     "ec"                => [ "ecdsa", "ecdh" ],
361     "psk"               => [ "jpake" ],
362
363     "dgram"             => [ "dtls" ],
364     "dtls"              => [ @dtls ],
365
366     # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
367     "md5"               => [ "ssl", "tls1", "tls1_1", "dtls1" ],
368     "sha"               => [ "ssl", "tls1", "tls1_1", "dtls1" ],
369
370     # Additionally, SSL 3.0 requires either RSA or DSA+DH
371     sub { $disabled{rsa}
372           && ($disabled{dsa} || $disabled{dh}); }
373                         => [ "ssl" ],
374
375     # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
376     # or ECDSA + ECDH.  (D)TLS 1.2 has this requirement as well.
377     # (XXX: We don't support PSK-only builds).
378     sub { $disabled{rsa}
379           && ($disabled{dsa} || $disabled{dh})
380           && ($disabled{ecdsa} || $disabled{ecdh}); }
381                         => [ "tls1", "tls1_1", "tls1_2",
382                              "dtls1", "dtls1_2" ],
383
384     "tls"               => [ @tls ],
385
386     # SRP and HEARTBEATS require TLSEXT
387     "tlsext"            => [ "srp", "heartbeats" ],
388     );
389
390 # Avoid protocol support holes.  Also disable all versions below N, if version
391 # N is disabled while N+1 is enabled.
392 #
393 my @list = (reverse @tls);
394 while ((my $first, my $second) = (shift @list, shift @list)) {
395     last unless @list;
396     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
397                               => [ @list ] );
398     unshift @list, $second;
399 }
400 my @list = (reverse @dtls);
401 while ((my $first, my $second) = (shift @list, shift @list)) {
402     last unless @list;
403     push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
404                               => [ @list ] );
405     unshift @list, $second;
406 }
407
408 # Construct the string of what $config{depflags} should look like with the defaults
409 # from %disabled above.  (we need this to see if we should advise the user
410 # to run "make depend"):
411 my $default_depflags = join(" ",
412     map { my $x = $_; $x =~ tr{[a-z]-}{[A-Z]_}; "-DOPENSSL_NO_$x"; }
413     grep { $disabled{$_} !~ /\(no-depflags\)$/ }
414     sort keys %disabled);
415
416 # Explicit "no-..." options will be collected in %disabled along with the defaults.
417 # To remove something from %disabled, use "enable-foo" (unless it's experimental).
418 # For symmetry, "disable-foo" is a synonym for "no-foo".
419
420 # For features called "experimental" here, a more explicit "experimental-foo" is needed to enable.
421 # We will collect such requests in @experimental.
422 # To avoid accidental use of experimental features, applications will have to use -DOPENSSL_EXPERIMENTAL_FOO.
423
424
425 my $no_sse2=0;
426
427 &usage if ($#ARGV < 0);
428
429 my $flags="";
430 $config{depflags}="";
431 $config{openssl_experimental_defines}=[];
432 $config{openssl_api_defines}=[];
433 $config{openssl_algorithm_defines}=[];
434 $config{openssl_thread_defines}=[];
435 $config{openssl_sys_defines}=[];
436 $config{openssl_other_defines}=[];
437 my $libs="";
438 my $target="";
439 $config{options}="";
440 my $make_depend=0;
441 my %withargs=();
442 my $build_prefix = "release_";
443
444 my @argvcopy=@ARGV;
445
446 if (grep /^reconf(igure)?$/, @argvcopy) {
447     if (-f "./configdata.pm") {
448         my $file = "./configdata.pm";
449         unless (my $return = do $file) {
450             die "couldn't parse $file: $@" if $@;
451             die "couldn't do $file: $!"    unless defined $return;
452             die "couldn't run $file"       unless $return;
453         }
454
455         @argvcopy = defined($configdata::config{perlargv}) ?
456             @{$configdata::config{perlargv}} : ();
457         die "Incorrect data to reconfigure, please do a normal configuration\n"
458             if (grep(/^reconf/,@argvcopy));
459         $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
460             if defined($configdata::config{cross_compile_prefix});
461         $ENV{CROSS_COMPILE} = $configdata::config{cc}
462             if defined($configdata::config{cc});
463
464         print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
465         print "    CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
466             if $ENV{CROSS_COMPILE};
467         print "    CC = ",$ENV{CC},"\n" if $ENV{CC};
468     } elsif (open IN, "<Makefile") {
469         #
470         # THIS SECTION IS TEMPORARY, it helps transitioning from Makefile
471         # centered information gathering the reading configdata.pm
472         #
473         while (<IN>) {
474             chomp;
475             if (/^CONFIGURE_ARGS=\s*(.*)\s*/) {
476                 # Older form, we split the string and hope for the best
477                 @argvcopy = split /\s+/, $_;
478                 die "Incorrect data to reconfigure, please do a normal configuration\n"
479                     if (grep(/^reconf/,@argvcopy));
480             } elsif (/^CROSS_COMPILE=\s*(.*)/) {
481                 $ENV{CROSS_COMPILE}=$1;
482             } elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/) {
483                 $ENV{CC}=$1;
484             }
485         }
486         #
487         # END OF TEMPORARY SECTION
488         #
489     } else {
490         die "Insufficient data to reconfigure, please do a normal configuration\n";
491     }
492 }
493
494 $config{perlargv} = [ @argvcopy ];
495
496 my %unsupported_options = ();
497 foreach (@argvcopy)
498         {
499         s /^-no-/no-/; # some people just can't read the instructions
500
501         # rewrite some options in "enable-..." form
502         s /^-?-?shared$/enable-shared/;
503         s /^sctp$/enable-sctp/;
504         s /^threads$/enable-threads/;
505         s /^zlib$/enable-zlib/;
506         s /^zlib-dynamic$/enable-zlib-dynamic/;
507
508         if (/^(no|disable|enable|experimental)-(.+)$/)
509                 {
510                 my $word = $2;
511                 if (!grep { $word =~ /^${_}$/ } @disablables)
512                         {
513                         $unsupported_options{$_} = 1;
514                         next;
515                         }
516                 }
517         if (/^no-(.+)$/ || /^disable-(.+)$/)
518                 {
519                 if (!($disabled{$1} eq "experimental"))
520                         {
521                         foreach my $proto ((@tls, @dtls))
522                                 {
523                                 if ($1 eq "$proto-method")
524                                         {
525                                         $disabled{"$proto"} = "option($proto-method)";
526                                         last;
527                                         }
528                                 }
529                         if ($1 eq "dtls")
530                                 {
531                                 foreach my $proto (@dtls)
532                                         {
533                                         $disabled{$proto} = "option(dtls)";
534                                         }
535                                 }
536                         elsif ($1 eq "ssl")
537                                 {
538                                 # Last one of its kind
539                                 $disabled{"ssl3"} = "option(ssl)";
540                                 }
541                         elsif ($1 eq "tls")
542                                 {
543                                 # XXX: Tests will fail if all SSL/TLS
544                                 # protocols are disabled.
545                                 foreach my $proto (@tls)
546                                         {
547                                         $disabled{$proto} = "option(tls)";
548                                         }
549                                 }
550                         else
551                                 {
552                                 $disabled{$1} = "option";
553                                 }
554                         }
555                 }
556         elsif (/^enable-(.+)$/ || /^experimental-(.+)$/)
557                 {
558                 my $algo = $1;
559                 if ($disabled{$algo} eq "experimental")
560                         {
561                         die "You are requesting an experimental feature; please say 'experimental-$algo' if you are sure\n"
562                                 unless (/^experimental-/);
563                         push @experimental, $algo;
564                         }
565                 delete $disabled{$algo};
566
567                 $threads = 1 if ($algo eq "threads");
568                 }
569         elsif (/^--strict-warnings$/)
570                 {
571                 $strict_warnings = 1;
572                 }
573         elsif (/^--debug$/)
574                 {
575                 $build_prefix = "debug_";
576                 }
577         elsif (/^--release$/)
578                 {
579                 $build_prefix = "release_";
580                 }
581         elsif (/^386$/)
582                 { $config{processor}=386; }
583         elsif (/^fips$/)
584                 {
585                 $config{fips}=1;
586                 }
587         elsif (/^rsaref$/)
588                 {
589                 # No RSAref support any more since it's not needed.
590                 # The check for the option is there so scripts aren't
591                 # broken
592                 }
593         elsif (/^nofipscanistercheck$/)
594                 {
595                 $config{fips} = 1;
596                 $nofipscanistercheck = 1;
597                 }
598         elsif (/^[-+]/)
599                 {
600                 if (/^--prefix=(.*)$/)
601                         {
602                         $config{prefix}=$1;
603                         }
604                 elsif (/^--api=(.*)$/)
605                         {
606                         $config{api}=$1;
607                         }
608                 elsif (/^--libdir=(.*)$/)
609                         {
610                         $config{libdir}=$1;
611                         }
612                 elsif (/^--openssldir=(.*)$/)
613                         {
614                         $config{openssldir}=$1;
615                         }
616                 elsif (/^--install.prefix=(.*)$/)
617                         {
618                         $config{install_prefix}=$1;
619                         }
620                 elsif (/^--with-zlib-lib=(.*)$/)
621                         {
622                         $withargs{"zlib-lib"}=$1;
623                         }
624                 elsif (/^--with-zlib-include=(.*)$/)
625                         {
626                         $withargs{"zlib-include"}="-I$1";
627                         }
628                 elsif (/^--with-fipslibdir=(.*)$/)
629                         {
630                         $config{fipslibdir}="$1/";
631                         }
632                 elsif (/^--with-baseaddr=(.*)$/)
633                         {
634                         $config{baseaddr}="$1";
635                         }
636                 elsif (/^--cross-compile-prefix=(.*)$/)
637                         {
638                         $config{cross_compile_prefix}=$1;
639                         }
640                 elsif (/^--config=(.*)$/)
641                         {
642                         read_config $1;
643                         }
644                 elsif (/^-[lL](.*)$/ or /^-Wl,/)
645                         {
646                         $libs.=$_." ";
647                         }
648                 else    # common if (/^[-+]/), just pass down...
649                         {
650                         $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
651                         $flags.=$_." ";
652                         }
653                 }
654         elsif ($_ =~ /^([^:]+):(.+)$/)
655                 {
656                 eval "\$table{\$1} = \"$2\""; # allow $xxx constructs in the string
657                 $target=$1;
658                 }
659         else
660                 {
661                 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
662                 $target=$_;
663                 }
664         unless ($_ eq $target || /^no-/ || /^disable-/)
665                 {
666                 # "no-..." follows later after implied disactivations
667                 # have been derived.  (Don't take this too seroiusly,
668                 # we really only write OPTIONS to the Makefile out of
669                 # nostalgia.)
670
671                 if ($config{options} eq "")
672                         { $config{options} = $_; }
673                 else
674                         { $config{options} .= " ".$_; }
675                 }
676
677         if (defined($config{api}) && !exists $apitable->{$config{api}}) {
678                 die "***** Unsupported api compatibility level: $config{api}\n",
679         }
680
681         if (keys %unsupported_options)
682                 {
683                 die "***** Unsupported options: ",
684                         join(", ", keys %unsupported_options), "\n";
685                 }
686         }
687
688 if ($config{fips})
689         {
690         delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
691         }
692 else
693         {
694         @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}};
695         }
696
697 my @tocheckfor = (keys %disabled);
698 while (@tocheckfor) {
699     my %new_tocheckfor = ();
700     my @cascade_copy = (@disable_cascades);
701     while (@cascade_copy) {
702         my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
703         if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
704             map {
705                 $new_tocheckfor{$_} => 1; $disabled{$_} = "forced";
706             } grep { !defined($disabled{$_}) } @$descendents;
707         }
708     }
709     @tocheckfor = (keys %new_tocheckfor);
710 }
711
712 if ($target eq "TABLE") {
713     foreach (sort keys %table) {
714         print_table_entry($_, "TABLE");
715     }
716     exit 0;
717 }
718
719 if ($target eq "LIST") {
720     foreach (sort keys %table) {
721         print $_,"\n" unless $table{$_}->{template};
722     }
723     exit 0;
724 }
725
726 if ($target eq "HASH") {
727     print "%table = (\n";
728     foreach (sort keys %table) {
729         print_table_entry($_, "HASH");
730     }
731     exit 0;
732 }
733
734 # Backward compatibility?
735 if ($target =~ m/^CygWin32(-.*)$/) {
736     $target = "Cygwin".$1;
737 }
738
739 foreach (sort (keys %disabled))
740         {
741         $config{options} .= " no-$_";
742
743         printf "    no-%-12s %-10s", $_, "[$disabled{$_}]";
744
745         if (/^dso$/)
746                 { $no_dso = 1; }
747         elsif (/^threads$/)
748                 { $no_threads = 1; }
749         elsif (/^shared$/)
750                 { $config{no_shared} = 1; }
751         elsif (/^zlib$/)
752                 { $zlib = 0; }
753         elsif (/^static-engine$/)
754                 { }
755         elsif (/^zlib-dynamic$/)
756                 { }
757         elsif (/^sse2$/)
758                 { $no_sse2 = 1; }
759         elsif (/^engine$/)
760                 { @{$config{dirs}} = grep !/^engine$/, @{$config{dirs}}; }
761         else
762                 {
763                 my ($ALGO, $algo);
764                 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
765
766                 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/)
767                         {
768                         push @{$config{openssl_other_defines}}, "OPENSSL_NO_$ALGO";
769                         print " OPENSSL_NO_$ALGO";
770
771                         if (/^err$/)    { $flags .= "-DOPENSSL_NO_ERR "; }
772                         elsif (/^asm$/) { $no_asm = 1; }
773                         }
774                 else
775                         {
776                         ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
777
778                         push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO";
779                         $config{depflags} .= " -DOPENSSL_NO_$ALGO";
780                         print " OPENSSL_NO_$ALGO";
781
782                         # fix-up crypto/directory name(s)
783                         $algo="whrlpool" if $algo eq "whirlpool";
784                         $algo="ripemd" if $algo eq "rmd160";
785                         @{$config{sdirs}} = grep { $_ ne $algo} @{$config{sdirs}};
786
787                         print " (skip dir)";
788                         }
789                 }
790
791         print "\n";
792         }
793
794 my $exp_cflags = "";
795
796 foreach (sort @experimental)
797         {
798         my $ALGO;
799         ($ALGO = $_) =~ tr/[a-z]/[A-Z]/;
800
801         # opensslconf.h will set OPENSSL_NO_... unless OPENSSL_EXPERIMENTAL_... is defined
802         push @{$config{openssl_experimental_defines}}, "OPENSSL_NO_$ALGO";
803         $exp_cflags .= " -DOPENSSL_EXPERIMENTAL_$ALGO";
804         }
805
806 print "Configuring for $target\n";
807
808 # Support for legacy targets having a name starting with 'debug-'
809 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
810 if ($d) {
811     $build_prefix = "debug_";
812
813     # If we do not find debug-foo in the table, the target is set to foo.
814     if (!$table{$target}) {
815         $target = $t;
816     }
817 }
818 $config{target} = $target;
819 delete $table{$base_target}->{template}; # or the next test will fail.
820 my %target = ( %{$table{$base_target}}, resolve_config($target) );
821
822 &usage if (!%target || $target{template});
823
824 $target{exe_extension}="";
825 $target{exe_extension}=".exe" if ($config{target} eq "Cygwin" || $config{target} eq "DJGPP" || $config{target} =~ /^mingw/);
826 $target{exe_extension}=".nlm" if ($config{target} =~ /netware/);
827 $target{exe_extension}=".pm"  if ($config{target} =~ /vos/);
828
829 $default_ranlib = which("ranlib") || "true";
830 $config{perl}   = $ENV{'PERL'} || which("perl5") || which("perl") || "perl";
831 my $make        = $ENV{'MAKE'} || "make";
832
833 $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
834     if $config{cross_compile_prefix} eq "";
835
836 $config{prefix} = "/usr/local" if !$config{prefix};
837 $config{openssldir} = "ssl" if !$config{openssldir};
838 $config{openssldir} = catdir($config{prefix}, $config{openssldir})
839     unless file_name_is_absolute($config{openssldir});
840
841 # Allow environment CC to override compiler...
842 $target{cc} = $ENV{CC} || $target{cc};
843
844 # For cflags and lflags, add the debug_ or release_ attributes
845 # Do it in such a way that no spurious space is appended (hence the grep).
846 $config{cflags} = join(" ",
847                        grep { $_ ne "" } ($target{cflags},
848                                           $target{$build_prefix."cflags"}));
849 $config{lflags} = join(" ",
850                        grep { $_ ne "" } ($target{lflags},
851                                           $target{$build_prefix."lflags"}));
852
853 $target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} || $default_ranlib;
854 $target{ar} = $ENV{'AR'} || "ar";
855 $target{arflags} = "" if !defined($target{arflags});
856 $target{nm} = "nm";
857 # Make sure build_scheme is consistent.
858 $target{build_scheme} = [ $target{build_scheme} ]
859     if ref($target{build_scheme}) ne "ARRAY";
860
861 # if $config{prefix}/lib$target{multilib} is not an existing directory, then
862 # assume that it's not searched by linker automatically, in
863 # which case adding $target{multilib} suffix causes more grief than
864 # we're ready to tolerate, so don't...
865 $target{multilib}="" if !-d "$config{prefix}/lib$target{multilib}";
866
867 $config{libdir}="lib$target{multilib}" if $config{libdir} eq "";
868 $config{enginesdir}=$config{prefix} . "/" . $config{libdir}  . "/engines";
869
870 $config{cflags} .= "$exp_cflags";
871
872 # '%' in $config{lflags} is used to split flags to "pre-" and post-flags
873 my ($pre,$post)=split('%',$config{lflags});
874 if (defined($post))     { $config{prelflags}=$pre; $config{lflags}=$post;       }
875 else                    { $config{prelflags}="";   $config{lflags}=$pre;        }
876
877 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` !~ m/-mno-cygwin/m)
878         {
879         $config{cflags} =~ s/-mno-cygwin\s*//;
880         $target{shared_ldflag} =~ s/-mno-cygwin\s*//;
881         }
882
883 if ($target =~ /linux.*-mips/ && !$no_asm && $flags !~ /-m(ips|arch=)/) {
884         # minimally required architecture flags for assembly modules
885         $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
886         $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
887 }
888
889 my $no_shared_warn=0;
890 my $no_user_cflags=0;
891
892 if ($flags ne "")       { $config{cflags}="$flags$config{cflags}"; }
893 else                    { $no_user_cflags=1;       }
894
895 # The DSO code currently always implements all functions so that no
896 # applications will have to worry about that from a compilation point
897 # of view. However, the "method"s may return zero unless that platform
898 # has support compiled in for them. Currently each method is enabled
899 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
900 # string entry into using the following logic;
901 my $dso_cflags;
902 if (!$no_dso && $target{dso_scheme} ne "")
903         {
904         $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
905         if ($target{dso_scheme} eq "DLFCN")
906                 {
907                 $dso_cflags = "-DDSO_DLFCN -DHAVE_DLFCN_H";
908                 }
909         elsif ($target{dso_scheme} eq "DLFCN_NO_H")
910                 {
911                 $dso_cflags = "-DDSO_DLFCN";
912                 }
913         else
914                 {
915                 $dso_cflags = "-DDSO_$target{dso_scheme}";
916                 }
917         $config{cflags} = "$dso_cflags $config{cflags}";
918         }
919
920 my $thread_cflags;
921 my @thread_defines;
922 if ($target{thread_cflag} ne "(unknown)" && !$no_threads)
923         {
924         # If we know how to do it, support threads by default.
925         $threads = 1;
926         }
927 if ($target{thread_cflag} eq "(unknown)" && $threads)
928         {
929         # If the user asked for "threads", [s]he is also expected to
930         # provide any system-dependent compiler options that are
931         # necessary.
932         if ($no_user_cflags)
933                 {
934                 print "You asked for multi-threading support, but didn't\n";
935                 print "provide any system-specific compiler options\n";
936                 exit(1);
937                 }
938         $thread_cflags="-DOPENSSL_THREADS $config{cflags}" ;
939         push @thread_defines, "OPENSSL_THREADS";
940         }
941 else
942         {
943         $thread_cflags="-DOPENSSL_THREADS $target{thread_cflag} $config{cflags}";
944         push @thread_defines, "OPENSSL_THREADS";
945 #       my $def;
946 #       foreach $def (split ' ',$target{thread_cflag})
947 #               {
948 #               if ($def =~ s/^-D// && $def !~ /^_/)
949 #                       {
950 #                       push @thread_defines, "$def";
951 #                       }
952 #               }
953         }
954
955 $config{lflags}="$libs$config{lflags}" if ($libs ne "");
956
957 if ($no_asm)
958         {
959         $config{cflags}=~s/-D[BL]_ENDIAN//              if ($config{fips});
960         $thread_cflags=~s/-D[BL]_ENDIAN//       if ($config{fips});
961         }
962
963 if ($threads)
964         {
965         $config{cflags}=$thread_cflags;
966         push @{$config{openssl_thread_defines}}, @thread_defines;
967         }
968
969 if ($zlib)
970         {
971         $config{cflags} = "-DZLIB $config{cflags}";
972         if (defined($disabled{"zlib-dynamic"}))
973                 {
974                 if (defined($withargs{"zlib-lib"}))
975                         {
976                         $config{lflags} .= " -L" . $withargs{"zlib-lib"} . " -lz";
977                         }
978                 else
979                         {
980                         $config{lflags} .= " -lz";
981                         }
982                 }
983         else
984                 {
985                 $config{cflags} = "-DZLIB_SHARED $config{cflags}";
986                 }
987         }
988
989 # With "deprecated" disable all deprecated features.
990 if (defined($disabled{"deprecated"})) {
991         $config{api} = $maxapi;
992 }
993
994 if ($target{shared_target} eq "")
995         {
996         $no_shared_warn = 1 if !$config{no_shared} && !$config{fips};
997         $config{no_shared} = 1;
998         }
999 if (!$config{no_shared})
1000         {
1001         if ($target{shared_cflag} ne "")
1002                 {
1003                 $config{cflags} = "$target{shared_cflag} -DOPENSSL_PIC $config{cflags}";
1004                 }
1005         }
1006
1007 if ($target{build_scheme}->[0] ne "mk1mf")
1008         {
1009         # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments
1010         if ($config{no_shared})
1011                 {
1012                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1013                 $config{options}.=" static-engine";
1014                 }
1015         else
1016                 {
1017                 push @{$config{openssl_other_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1018                 $config{options}.=" no-static-engine";
1019                 }
1020         }
1021
1022 #
1023 # Platform fix-ups
1024 #
1025 if ($target =~ /-icc$/) # Intel C compiler
1026         {
1027         my $iccver=0;
1028         if (open(FD,"$target{cc} -V 2>&1 |"))
1029                 {
1030                 while(<FD>) { $iccver=$1 if (/Version ([0-9]+)\./); }
1031                 close(FD);
1032                 }
1033         if ($iccver>=8)
1034                 {
1035                 $config{cflags}=~s/-KPIC/-fPIC/;
1036                 # Eliminate unnecessary dependency from libirc.a. This is
1037                 # essential for shared library support, as otherwise
1038                 # apps/openssl can end up in endless loop upon startup...
1039                 $config{cflags}.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset";
1040                 }
1041         if ($iccver>=9)
1042                 {
1043                 $config{lflags}.=" -i-static";
1044                 $config{lflags}=~s/-no_cpprt/-no-cpprt/;
1045                 }
1046         if ($iccver>=10)
1047                 {
1048                 $config{lflags}=~s/-i-static/-static-intel/;
1049                 }
1050         if ($iccver>=11)
1051                 {
1052                 $config{cflags}.=" -no-intel-extensions";       # disable Cilk
1053                 $config{lflags}=~s/-no-cpprt/-no-cxxlib/;
1054                 }
1055         }
1056
1057 # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time
1058 # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on
1059 # .so objects. Apparently application RPATH is not global and does
1060 # not apply to .so linked with other .so. Problem manifests itself
1061 # when libssl.so fails to load libcrypto.so. One can argue that we
1062 # should engrave this into Makefile.shared rules or into BSD-* config
1063 # lines above. Meanwhile let's try to be cautious and pass -rpath to
1064 # linker only when --prefix is not /usr.
1065 if ($target =~ /^BSD-/)
1066         {
1067         $target{shared_ldflag}.=" -Wl,-rpath,\$\$(LIBRPATH)" if ($config{prefix} !~ m|^/usr[/]*$|);
1068         }
1069
1070 if ($target{sys_id} ne "")
1071         {
1072         #$config{cflags}="-DOPENSSL_SYS_$target{sys_id} $config{cflags}";
1073         push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1074         }
1075
1076 if ($target{ranlib} eq "")
1077         {
1078         $target{ranlib} = $default_ranlib;
1079         }
1080
1081 if (!$no_asm) {
1082     $target{cpuid_obj}=$table{BASE}->{cpuid_obj} if ($config{processor} eq "386");
1083     $target{cpuid_obj}.=" uplink.o uplink-x86.o" if ($config{cflags} =~ /-DOPENSSL_USE_APPLINK/);
1084
1085     $target{bn_obj} =~ s/\w+-gf2m.o// if (defined($disabled{ec2m}));
1086
1087     # bn-586 is the only one implementing bn_*_part_words
1088     $config{cflags}.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($target{bn_obj} =~ /bn-586/);
1089     $config{cflags}.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_obj} =~ /86/);
1090
1091     $config{cflags}.=" -DOPENSSL_BN_ASM_MONT" if ($target{bn_obj} =~ /-mont/);
1092     $config{cflags}.=" -DOPENSSL_BN_ASM_MONT5" if ($target{bn_obj} =~ /-mont5/);
1093     $config{cflags}.=" -DOPENSSL_BN_ASM_GF2m" if ($target{bn_obj} =~ /-gf2m/);
1094
1095     if ($config{fips}) {
1096         push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1097     }
1098
1099     if ($target{sha1_obj} =~ /\.o$/) {
1100         $config{cflags}.=" -DSHA1_ASM"   if ($target{sha1_obj} =~ /sx86/ || $target{sha1_obj} =~ /sha1/);
1101         $config{cflags}.=" -DSHA256_ASM" if ($target{sha1_obj} =~ /sha256/);
1102         $config{cflags}.=" -DSHA512_ASM" if ($target{sha1_obj} =~ /sha512/);
1103         if ($target{sha1_obj} =~ /sse2/) {
1104             if ($no_sse2) {
1105                 $target{sha1_obj} =~ s/\S*sse2\S+//;
1106             } elsif ($config{cflags} !~ /OPENSSL_IA32_SSE2/) {
1107                 $config{cflags}.=" -DOPENSSL_IA32_SSE2";
1108             }
1109         }
1110     }
1111     if ($target{md5_obj} =~ /\.o$/) {
1112         $config{cflags}.=" -DMD5_ASM";
1113     }
1114     $target{cast_obj}=$table{BASE}->{cast_obj} if (!$config{no_shared}); # CAST assembler is not PIC
1115     if ($target{rmd160_obj} =~ /\.o$/) {
1116         $config{cflags}.=" -DRMD160_ASM";
1117     }
1118     if ($target{aes_obj} =~ /\.o$/) {
1119         $config{cflags}.=" -DAES_ASM" if ($target{aes_obj} =~ m/\baes-/);;
1120         # aes-ctr.o is not a real file, only indication that assembler
1121         # module implements AES_ctr32_encrypt...
1122         $config{cflags}.=" -DAES_CTR_ASM" if ($target{aes_obj} =~ s/\s*aes-ctr\.o//);
1123         # aes-xts.o indicates presence of AES_xts_[en|de]crypt...
1124         $config{cflags}.=" -DAES_XTS_ASM" if ($target{aes_obj} =~ s/\s*aes-xts\.o//);
1125         $target{aes_obj} =~ s/\s*(vpaes|aesni)-x86\.o//g if ($no_sse2);
1126         $config{cflags}.=" -DVPAES_ASM" if ($target{aes_obj} =~ m/vpaes/);
1127         $config{cflags}.=" -DBSAES_ASM" if ($target{aes_obj} =~ m/bsaes/);
1128     }
1129     if ($target{wp_obj} =~ /mmx/ && $config{processor} eq "386") {
1130         $target{wp_obj}=$table{BASE}->{wp_obj};
1131     } elsif (!$disabled{"whirlpool"}) {
1132         $config{cflags}.=" -DWHIRLPOOL_ASM";
1133     }
1134     if ($target{modes_obj} =~ /ghash-/) {
1135         $config{cflags}.=" -DGHASH_ASM";
1136     }
1137     if ($target{ec_obj} =~ /ecp_nistz256/) {
1138         $config{cflags}.=" -DECP_NISTZ256_ASM";
1139     }
1140     if ($target{poly1305_obj} =~ /\.o$/) {
1141         $config{cflags}.=" -DPOLY1305_ASM";
1142     }
1143 }
1144
1145 my $ecc = $target{cc};
1146 $ecc = "clang" if `$target{cc} --version 2>&1` =~ /clang/;
1147
1148 $config{makedepprog} =
1149     $ecc eq "gcc" || $ecc eq "clang" ? $target{cc} : "makedepend";
1150 $config{depflags} =~ s/^\s*//;
1151
1152
1153 # Deal with bn_ops ###################################################
1154
1155 $config{des_ptr}                =0;
1156 $config{des_risc1}              =0;
1157 $config{des_risc2}              =0;
1158 $config{des_unroll}             =0;
1159 $config{bn_ll}                  =0;
1160 $config{rc4_idx}                =0;
1161 $config{bf_ptr}                 =0;
1162 $config{export_var_as_fn}       =0;
1163 my $def_int="unsigned int";
1164 $config{rc4_int}                =$def_int;
1165 $config{rc4_chunk}              ="";
1166 $config{md2_int}                =$def_int;
1167 $config{idea_int}               =$def_int;
1168 $config{rc2_int}                =$def_int;
1169 ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})=(0,0,1,0,0);
1170
1171 $config{des_int} = "unsigned long";
1172
1173 foreach (sort split(/\s+/,$target{bn_ops})) {
1174     $config{des_ptr}=1                          if /DES_PTR/;
1175     $config{des_risc1}=1                        if /DES_RISC1/;
1176     $config{des_risc2}=1                        if /DES_RISC2/;
1177     $config{des_unroll}=1                       if /DES_UNROLL/;
1178     $config{des_int}="unsigned int"             if /DES_INT/;
1179     $config{bn_ll}=1                            if /BN_LLONG/;
1180     $config{rc4_int}="unsigned char"            if /RC4_CHAR/;
1181     $config{rc4_int}="unsigned long"            if /RC4_LONG/;
1182     $config{rc4_idx}=1                          if /RC4_INDEX/;
1183     $config{rc4_chunk}="unsigned long"          if /RC4_CHUNK/;
1184     $config{rc4_chunk}="unsigned long long"     if /RC4_CHUNK_LL/;
1185     $config{md2_int}="unsigned char"            if /MD2_CHAR/;
1186     $config{md2_int}="unsigned long"            if /MD2_LONG/;
1187     $config{idea_int}="unsigned char"           if /IDEA_CHAR/;
1188     $config{idea_int}="unsigned long"           if /IDEA_LONG/;
1189     $config{rc2_int}="unsigned char"            if /RC2_CHAR/;
1190     $config{rc2_int}="unsigned long"            if /RC2_LONG/;
1191     $config{bf_ptr}=1                           if $_ eq "BF_PTR";
1192     $config{bf_ptr}=2                           if $_ eq "BF_PTR2";
1193     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1194         =(0,1,0,0,0)                            if /SIXTY_FOUR_BIT/;
1195     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1196         =(1,0,0,0,0)                            if /SIXTY_FOUR_BIT_LONG/;
1197     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1198         =(0,0,1,0,0)                            if /THIRTY_TWO_BIT/;
1199     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1200         =(0,0,0,1,0)                            if /SIXTEEN_BIT/;
1201     ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})
1202         =(0,0,0,0,1)                            if /EIGHT_BIT/;
1203     $config{export_var_as_fn}=1                 if /EXPORT_VAR_AS_FN/;
1204 }
1205
1206
1207 # Hack cflags for better warnings (dev option) #######################
1208
1209 # "Stringify" the C flags string.  This permits it to be made part of a string
1210 # and works as well on command lines.
1211 $config{cflags} =~ s/([\\\"])/\\\1/g;
1212
1213 if (defined($config{api})) {
1214     $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1215     my $apiflag = sprintf("-DOPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1216     $default_depflags .= " $apiflag";
1217     $config{cflags} .= " $apiflag";
1218 }
1219
1220 if ($strict_warnings)
1221         {
1222         my $wopt;
1223         die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/);
1224         foreach $wopt (split /\s+/, $gcc_devteam_warn)
1225                 {
1226                 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/)
1227                 }
1228         if ($ecc eq "clang")
1229                 {
1230                 foreach $wopt (split /\s+/, $clang_devteam_warn)
1231                         {
1232                         $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/)
1233                         }
1234                 }
1235         if ($target !~ /^mingw/)
1236                 {
1237                 foreach $wopt (split /\s+/, $memleak_devteam_backtrace)
1238                         {
1239                         $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/)
1240                         }
1241                 if ($target =~ /^BSD-/)
1242                         {
1243                         $config{lflags} .= " -lexecinfo";
1244                         }
1245                 }
1246         }
1247
1248 # Write down our configuration where it fits #########################
1249
1250 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1251 print OUT <<"EOF";
1252 package configdata;
1253
1254 use strict;
1255 use warnings;
1256
1257 use Exporter;
1258 #use vars qw(\@ISA \@EXPORT);
1259 our \@ISA = qw(Exporter);
1260 our \@EXPORT = qw(\%config \%target %withargs);
1261
1262 EOF
1263 print OUT "our %config = (\n";
1264 foreach (sort keys %config) {
1265     if (ref($config{$_}) eq "ARRAY") {
1266         print OUT "  ", $_, " => [ ", join(", ",
1267                                            map { quotify("perl", $_) }
1268                                            @{$config{$_}}), " ],\n";
1269     } else {
1270         print OUT "  ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1271     }
1272 }
1273 print OUT <<"EOF";
1274 );
1275
1276 EOF
1277 print OUT "our %target = (\n";
1278 foreach (sort keys %target) {
1279     if (ref($target{$_}) eq "ARRAY") {
1280         print OUT "  ", $_, " => [ ", join(", ",
1281                                            map { quotify("perl", $_) }
1282                                            @{$target{$_}}), " ],\n";
1283     } else {
1284         print OUT "  ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1285     }
1286 }
1287 print OUT <<"EOF";
1288 );
1289
1290 EOF
1291 print OUT "our \%available_protocols = (\n";
1292 print OUT "  tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1293 print OUT "  dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1294 print OUT <<"EOF";
1295 );
1296
1297 EOF
1298 print OUT "our \%disabled = (\n";
1299 foreach (sort keys %disabled) {
1300     print OUT "  ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1301 }
1302 print OUT <<"EOF";
1303 );
1304
1305 EOF
1306 print OUT "our %withargs = (\n";
1307 foreach (sort keys %withargs) {
1308     if (ref($withargs{$_}) eq "ARRAY") {
1309         print OUT "  ", $_, " => [ ", join(", ",
1310                                            map { quotify("perl", $_) }
1311                                            @{$withargs{$_}}), " ],\n";
1312     } else {
1313         print OUT "  ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1314     }
1315 }
1316 print OUT <<"EOF";
1317 );
1318
1319 1;
1320 EOF
1321 close(OUT);
1322
1323 print "IsMK1MF       =", ($target{build_scheme}->[0] eq "mk1mf" ? "yes" : "no"), "\n";
1324 print "CC            =$target{cc}\n";
1325 print "CFLAG         =$config{cflags}\n";
1326 print "EX_LIBS       =$config{lflags}\n";
1327 print "CPUID_OBJ     =$target{cpuid_obj}\n";
1328 print "BN_ASM        =$target{bn_obj}\n";
1329 print "EC_ASM        =$target{ec_obj}\n";
1330 print "DES_ENC       =$target{des_obj}\n";
1331 print "AES_ENC       =$target{aes_obj}\n";
1332 print "BF_ENC        =$target{bf_obj}\n";
1333 print "CAST_ENC      =$target{cast_obj}\n";
1334 print "RC4_ENC       =$target{rc4_obj}\n";
1335 print "RC5_ENC       =$target{rc5_obj}\n";
1336 print "MD5_OBJ_ASM   =$target{md5_obj}\n";
1337 print "SHA1_OBJ_ASM  =$target{sha1_obj}\n";
1338 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1339 print "CMLL_ENC      =$target{cmll_obj}\n";
1340 print "MODES_OBJ     =$target{modes_obj}\n";
1341 print "PADLOCK_OBJ   =$target{padlock_obj}\n";
1342 print "CHACHA_ENC    =$target{chacha_obj}\n";
1343 print "POLY1305_OBJ  =$target{poly1305_obj}\n";
1344 print "PROCESSOR     =$config{processor}\n";
1345 print "RANLIB        =$target{ranlib}\n";
1346 print "ARFLAGS       =$target{arflags}\n";
1347 print "PERL          =$config{perl}\n";
1348 print "\n";
1349 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1350 print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1351 print "THIRTY_TWO_BIT mode\n" if $config{b32};
1352 print "SIXTEEN_BIT mode\n" if $config{b16};
1353 print "EIGHT_BIT mode\n" if $config{b8};
1354 print "DES_PTR used\n" if $config{des_ptr};
1355 print "DES_RISC1 used\n" if $config{des_risc1};
1356 print "DES_RISC2 used\n" if $config{des_risc2};
1357 print "DES_UNROLL used\n" if $config{des_unroll};
1358 print "DES_INT used\n" if $config{des_int} =~ / int$/;
1359 print "BN_LLONG mode\n" if $config{bn_ll};
1360 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} != $def_int;
1361 print "RC4_INDEX mode\n" if $config{rc4_idx};
1362 print "RC4_CHUNK is undefined\n" unless $config{rc4_chunk};
1363 print "RC4_CHUNK is $config{rc4_chunk}\n" if $config{rc4_chunk};
1364 print "MD2 uses $config{md2_int}\n" if $config{md2_int} != $def_int;
1365 print "IDEA uses $config{idea_int}\n" if $config{idea_int} != $def_int;
1366 print "RC2 uses $config{rc2_int}\n" if $config{rc2_int} != $def_int;
1367 print "BF_PTR used\n" if $config{bf_ptr} == 1;
1368 print "BF_PTR2 used\n" if $config{bf_ptr} == 2;
1369
1370 run_dofile("$Makefile.in","$Makefile");
1371
1372 run_dofile("include/openssl/opensslconf.h.in", "include/openssl/opensslconf.h");
1373
1374 foreach my $alg ( 'bf', 'bn', 'des', 'rc4' ) {
1375     run_dofile("crypto/include/internal/${alg}_conf.h.in",
1376                "crypto/include/internal/${alg}_conf.h");
1377 }
1378
1379 # Copy all Makefile.in to Makefile (except top-level)
1380 use File::Find;
1381 use IO::File;
1382 find(sub {
1383         return if ($_ ne "Makefile.in" || $File::Find::dir eq ".");
1384         my $in = IO::File->new($_, "r") or
1385             die sprintf "Error reading Makefile.in in %s: !$\n",
1386                 $File::Find::dir;
1387         my $out = IO::File->new("Makefile", "w") or
1388             die sprintf "Error writing Makefile in %s: !$\n",
1389                 $File::Find::dir;
1390         print $out "# Generated from $_, do not edit\n";
1391         while (my $line = <$in>) { print $out $line }
1392         $in->close() or
1393             die sprintf "Error reading Makefile.in in %s: !$\n",
1394                 $File::Find::dir;
1395         $out->close() or
1396             die sprintf "Error writing Makefile in %s: !$\n",
1397                 $File::Find::dir;
1398     }, ".");
1399
1400 my %builders = (
1401     unixmake => sub {
1402         my $make_command = "$make PERL=\'$config{perl}\'";
1403         my $make_targets = "";
1404         $make_targets .= " depend" if $config{depflags} ne $default_depflags && $make_depend;
1405         (system $make_command.$make_targets) == 0 or die "make $make_targets failed"
1406             if $make_targets ne "";
1407         if ($config{depflags} ne $default_depflags && !$make_depend) {
1408             $warn_make_depend++;
1409         }
1410     },
1411     mk1mf => sub {
1412         open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h";
1413         printf OUT <<"EOF";
1414 #ifndef MK1MF_BUILD
1415   /* auto-generated by Configure for crypto/cversion.c:
1416    * for Unix builds, crypto/Makefile.ssl generates functional definitions;
1417    * Windows builds (and other mk1mf builds) compile cversion.c with
1418    * -DMK1MF_BUILD and use definitions added to this file by util/mk1mf.pl. */
1419   #error "Windows builds (PLATFORM=$target) use mk1mf.pl-created Makefiles"
1420 #endif
1421 EOF
1422         close(OUT);
1423
1424         # create the ms/version32.rc file if needed
1425         if (! grep /^netware/, @{$target{build_scheme}}) {
1426             my ($v1, $v2, $v3, $v4);
1427             if ($config{version_num} =~ /^0x([0-9a-f]{1})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{1})L$/i) {
1428                 $v1=hex $1;
1429                 $v2=hex $2;
1430                 $v3=hex $3;
1431                 $v4=hex $4;
1432             }
1433             open (OUT,">ms/version32.rc") || die "Can't open ms/version32.rc";
1434             print OUT <<"EOF";
1435 #include <winver.h>
1436
1437 LANGUAGE 0x09,0x01
1438
1439 1 VERSIONINFO
1440   FILEVERSION $v1,$v2,$v3,$v4
1441   PRODUCTVERSION $v1,$v2,$v3,$v4
1442   FILEFLAGSMASK 0x3fL
1443 #ifdef _DEBUG
1444   FILEFLAGS 0x01L
1445 #else
1446   FILEFLAGS 0x00L
1447 #endif
1448   FILEOS VOS__WINDOWS32
1449   FILETYPE VFT_DLL
1450   FILESUBTYPE 0x0L
1451 BEGIN
1452     BLOCK "StringFileInfo"
1453     BEGIN
1454         BLOCK "040904b0"
1455         BEGIN
1456             // Required:
1457             VALUE "CompanyName", "The OpenSSL Project, http://www.openssl.org/\\0"
1458             VALUE "FileDescription", "OpenSSL Shared Library\\0"
1459             VALUE "FileVersion", "$config{version}\\0"
1460 #if defined(CRYPTO)
1461             VALUE "InternalName", "libeay32\\0"
1462             VALUE "OriginalFilename", "libeay32.dll\\0"
1463 #elif defined(SSL)
1464             VALUE "InternalName", "ssleay32\\0"
1465             VALUE "OriginalFilename", "ssleay32.dll\\0"
1466 #endif
1467             VALUE "ProductName", "The OpenSSL Toolkit\\0"
1468             VALUE "ProductVersion", "$config{version}\\0"
1469             // Optional:
1470             //VALUE "Comments", "\\0"
1471             VALUE "LegalCopyright", "Copyright © 1998-2015 The OpenSSL Project. Copyright © 1995-1998 Eric A. Young, Tim J. Hudson. All rights reserved.\\0"
1472             //VALUE "LegalTrademarks", "\\0"
1473             //VALUE "PrivateBuild", "\\0"
1474             //VALUE "SpecialBuild", "\\0"
1475         END
1476     END
1477     BLOCK "VarFileInfo"
1478     BEGIN
1479         VALUE "Translation", 0x409, 0x4b0
1480     END
1481 END
1482 EOF
1483             close(OUT);
1484         }
1485     },
1486     );
1487
1488 my ($builder, @builder_opts) = @{$target{build_scheme}};
1489 $builders{$builder}->(@builder_opts);
1490
1491 print <<"EOF";
1492
1493 Configured for $target.
1494 EOF
1495
1496 print <<"EOF" if (!$no_threads && !$threads);
1497
1498 The library could not be configured for supporting multi-threaded
1499 applications as the compiler options required on this system are not known.
1500 See file INSTALL for details if you need multi-threading.
1501 EOF
1502
1503 print <<"EOF" if ($no_shared_warn);
1504
1505 You gave the option 'shared', which is not supported on this platform, so
1506 we will pretend you gave the option 'no-shared'.  If you know how to implement
1507 shared libraries, please let us know (but please first make sure you have
1508 tried with a current version of OpenSSL).
1509 EOF
1510
1511 print <<"EOF" if ($warn_make_depend);
1512
1513 *** Because of configuration changes, you MUST do the following before
1514 *** building:
1515
1516         make depend
1517 EOF
1518
1519 exit(0);
1520
1521 ######################################################################
1522 #
1523 # Helpers and utility functions
1524 #
1525
1526 # Configuration file reading #########################################
1527
1528 # Helper function to implement conditional inheritance depending on the
1529 # value of $no_asm.  Used in inherit_from values as follows:
1530 #
1531 #      inherit_from => [ "template", asm("asm_tmpl") ]
1532 #
1533 sub asm {
1534     my @x = @_;
1535     sub {
1536         $no_asm ? () : @x;
1537     }
1538 }
1539
1540 # Helper function to implement adding values to already existing configuration
1541 # values.  It handles elements that are ARRAYs, CODEs and scalars
1542 sub _add {
1543     my $separator = shift;
1544
1545     # If there's any ARRAY in the collection of values, we will return
1546     # an ARRAY of combined values, otherwise a string of joined values
1547     # with $separator as the separator.
1548     my $found_array = 0;
1549
1550     my @values =
1551         map {
1552             if (ref($_) eq "ARRAY") {
1553                 $found_array = 1;
1554                 @$_;
1555             } else {
1556                 $_;
1557             }
1558     } (@_);
1559
1560     if ($found_array) {
1561         [ @values ];
1562     } else {
1563         join($separator, @values);
1564     }
1565 }
1566 sub add_before {
1567     my $separator = shift;
1568     my @x = @_;
1569     sub { _add($separator, @x, @_) };
1570 }
1571 sub add {
1572     my $separator = shift;
1573     my @x = @_;
1574     sub { _add($separator, @_, @x) };
1575 }
1576
1577 # configuration reader, evaluates the input file as a perl script and expects
1578 # it to fill %targets with target configurations.  Those are then added to
1579 # %table.
1580 sub read_config {
1581     my $fname = shift;
1582     open(CONFFILE, "< $fname")
1583         or die "Can't open configuration file '$fname'!\n";
1584     my $x = $/;
1585     undef $/;
1586     my $content = <CONFFILE>;
1587     $/ = $x;
1588     close(CONFFILE);
1589     my %targets = ();
1590     {
1591         local %table = %::table;    # Protect %table from tampering
1592
1593         eval $content;
1594         warn $@ if $@;
1595     }
1596
1597     # For each target, check that it's configured with a hash table.
1598     foreach (keys %targets) {
1599         if (ref($targets{$_}) ne "HASH") {
1600             if (ref($targets{$_}) eq "") {
1601                 warn "Deprecated target configuration for $_, ignoring...\n";
1602             } else {
1603                 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
1604             }
1605             delete $targets{$_};
1606         }
1607     }
1608
1609     %table = (%table, %targets);
1610
1611 }
1612
1613 # configuration resolver.  Will only resolve all the lazy evalutation
1614 # codeblocks for the chozen target and all those it inherits from,
1615 # recursively
1616 sub resolve_config {
1617     my $target = shift;
1618     my @breadcrumbs = @_;
1619
1620     if (grep { $_ eq $target } @breadcrumbs) {
1621         die "inherit_from loop!  target backtrace:\n  "
1622             ,$target,"\n  ",join("\n  ", @breadcrumbs),"\n";
1623     }
1624
1625     if (!defined($table{$target})) {
1626         warn "Warning! target $target doesn't exist!\n";
1627         return ();
1628     }
1629     # Recurse through all inheritances.  They will be resolved on the
1630     # fly, so when this operation is done, they will all just be a
1631     # bunch of attributes with string values.
1632     # What we get here, though, are keys with references to lists of
1633     # the combined values of them all.  We will deal with lists after
1634     # this stage is done.
1635     my %combined_inheritance = ();
1636     if ($table{$target}->{inherit_from}) {
1637         my @inherit_from =
1638             map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
1639         foreach (@inherit_from) {
1640             my %inherited_config = resolve_config($_, $target, @breadcrumbs);
1641
1642             # 'template' is a marker that's considered private to
1643             # the config that had it.
1644             delete $inherited_config{template};
1645
1646             map {
1647                 if (!$combined_inheritance{$_}) {
1648                     $combined_inheritance{$_} = [];
1649                 }
1650                 push @{$combined_inheritance{$_}}, $inherited_config{$_};
1651             } keys %inherited_config;
1652         }
1653     }
1654
1655     # We won't need inherit_from in this target any more, since we've
1656     # resolved all the inheritances that lead to this
1657     delete $table{$target}->{inherit_from};
1658
1659     # Now is the time to deal with those lists.  Here's the place to
1660     # decide what shall be done with those lists, all based on the
1661     # values of the target we're currently dealing with.
1662     # - If a value is a coderef, it will be executed with the list of
1663     #   inherited values as arguments.
1664     # - If the corresponding key doesn't have a value at all or is the
1665     #   emoty string, the inherited value list will be run through the
1666     #   default combiner (below), and the result becomes this target's
1667     #   value.
1668     # - Otherwise, this target's value is assumed to be a string that
1669     #   will simply override the inherited list of values.
1670     my $default_combiner = add(" ");
1671
1672     my %all_keys =
1673         map { $_ => 1 } (keys %combined_inheritance,
1674                          keys %{$table{$target}});
1675     foreach (sort keys %all_keys) {
1676
1677         # Current target doesn't have a value for the current key?
1678         # Assign it the default combiner, the rest of this loop body
1679         # will handle it just like any other coderef.
1680         if (!exists $table{$target}->{$_}) {
1681             $table{$target}->{$_} = $default_combiner;
1682         }
1683
1684         my $valuetype = ref($table{$target}->{$_});
1685         if ($valuetype eq "CODE") {
1686             # CODE reference, execute it with the inherited values as
1687             # arguments.
1688             $table{$target}->{$_} =
1689                 $table{$target}->{$_}->(@{$combined_inheritance{$_}});
1690         } elsif ($valuetype eq "ARRAY" || $valuetype eq "") {
1691             # ARRAY or Scalar, just leave it as is.
1692         } else {
1693             # Some other type of reference that we don't handle.
1694             # Better to abort at this point.
1695             die "cannot handle reference type $valuetype,"
1696                 ," found in target $target -> $_\n";
1697         }
1698     }
1699
1700     # Finally done, return the result.
1701     return %{$table{$target}};
1702 }
1703
1704 sub usage
1705         {
1706         print STDERR $usage;
1707         print STDERR "\npick os/compiler from:\n";
1708         my $j=0;
1709         my $i;
1710         my $k=0;
1711         foreach $i (sort keys %table)
1712                 {
1713                 next if $table{$i}->{template};
1714                 next if $i =~ /^debug/;
1715                 $k += length($i) + 1;
1716                 if ($k > 78)
1717                         {
1718                         print STDERR "\n";
1719                         $k=length($i);
1720                         }
1721                 print STDERR $i . " ";
1722                 }
1723         foreach $i (sort keys %table)
1724                 {
1725                 next if $table{$i}->{template};
1726                 next if $i !~ /^debug/;
1727                 $k += length($i) + 1;
1728                 if ($k > 78)
1729                         {
1730                         print STDERR "\n";
1731                         $k=length($i);
1732                         }
1733                 print STDERR $i . " ";
1734                 }
1735         print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
1736         exit(1);
1737         }
1738
1739 sub run_dofile()
1740 {
1741     my $in = shift;
1742     my $out = shift;
1743
1744     # should we remove $out ?
1745     system("$config{perl} -I. -Mconfigdata util/dofile.pl -o\"Configure\" $in > $out.new");
1746     exit 1 if $? != 0;
1747     rename("$out.new", $out) || die "Can't rename $out.new, $!";
1748 }
1749
1750 # Configuration printer ##############################################
1751
1752 sub print_table_entry
1753 {
1754     my $target = shift;
1755     my %target = resolve_config($target);
1756     my $type = shift;
1757
1758     # Don't print the templates
1759     return if $target{template};
1760
1761     my @sequence = (
1762         "sys_id",
1763         "cc",
1764         "cflags",
1765         "debug_cflags",
1766         "release_cflags",
1767         "thread_cflag",
1768         "unistd",
1769         "ld",
1770         "lflags",
1771         "debug_lflags",
1772         "release_lflags",
1773         "bn_ops",
1774         "cpuid_obj",
1775         "bn_obj",
1776         "ec_obj",
1777         "des_obj",
1778         "aes_obj",
1779         "bf_obj",
1780         "md5_obj",
1781         "sha1_obj",
1782         "cast_obj",
1783         "rc4_obj",
1784         "rmd160_obj",
1785         "rc5_obj",
1786         "wp_obj",
1787         "cmll_obj",
1788         "modes_obj",
1789         "padlock_obj",
1790         "perlasm_scheme",
1791         "dso_scheme",
1792         "shared_target",
1793         "shared_cflag",
1794         "shared_ldflag",
1795         "shared_extension",
1796         "obj_extension",
1797         "exe_extension",
1798         "ranlib",
1799         "ar",
1800         "arflags",
1801         "multilib",
1802         "build_scheme",
1803         );
1804
1805     if ($type eq "TABLE") {
1806         print "\n";
1807         print "*** $target\n";
1808         printf "\$%-12s = %s\n", $_, $target{$_} foreach (@sequence);
1809     } elsif ($type eq "HASH") {
1810         my $largest =
1811             length((sort { length($a) <=> length($b) } @sequence)[-1]);
1812         print "    '$target' => {\n";
1813         foreach (@sequence) {
1814             if ($target{$_}) {
1815                 print "      '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
1816             }
1817         }
1818         print "    },\n";
1819     }
1820 }
1821
1822 # Utility routines ###################################################
1823
1824 sub which
1825         {
1826         my($name)=@_;
1827         my $path;
1828         foreach $path (split /:/, $ENV{PATH})
1829                 {
1830                 if (-f "$path/$name$target{exe_extension}" and -x _)
1831                         {
1832                         return "$path/$name$target{exe_extension}" unless ($name eq "perl" and
1833                          system("$path/$name$target{exe_extension} -e " . '\'exit($]<5.0);\''));
1834                         }
1835                 }
1836         }
1837
1838 sub quotify {
1839     my %processors = (
1840         perl    => sub { my $x = shift;
1841                          $x =~ s/([\\\$\@"])/\\$1/g;
1842                          return '"'.$x.'"'; },
1843         );
1844     my $for = shift;
1845     my $processor =
1846         defined($processors{$for}) ? $processors{$for} : sub { shift; };
1847
1848     map { $processor->($_); } @_;
1849 }
1850
1851 # collect_information($filename, $line_continue, $regexp => $CODEref, ...)
1852 # $filename is the file to read.
1853 # $line_continue is either undef (which is a noop), or two arguments, where
1854 # the first is a regexp detecting a line continuation ending, and the
1855 # following argument is a CODEref that takes care of concatenating two
1856 # lines.
1857 # All following arguments are regex/CODEref pairs, where the regexp detects a
1858 # line and the CODEref does something with the result of the regexp.
1859 sub collect_information {
1860     my $filename = shift;
1861     my $line_continue_re = shift;
1862     my $line_concat = defined($line_continue_re) ? shift : undef;
1863     my %collectors = @_;
1864
1865     my $saved_line = "";
1866     open IN, $filename || die "unable to read $filename: $!\n";
1867     while(<IN>) {
1868         chomp;
1869         if (defined $line_concat) {
1870             $_ = $line_concat->($saved_line, $_);
1871         }
1872         if (defined $line_continue_re && /$line_continue_re/) {
1873             $saved_line = $_;
1874             next;
1875         }
1876         foreach my $re (keys %collectors) {
1877             if (/$re/) { $collectors{$re}->() };
1878         }
1879     }
1880     close IN;
1881 }