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