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