3 # Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
5 # Licensed under the OpenSSL license (the "License"). You may not use
6 # this file except in compliance with the License. You can obtain a copy
7 # in the file LICENSE in the source distribution or at
8 # https://www.openssl.org/source/license.html
10 ## Configure -- OpenSSL source tree configuration script
15 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs/;
16 use File::Path qw/mkpath/;
17 use if $^O ne "VMS", 'File::Glob' => qw/glob/;
19 # see INSTALL for instructions.
21 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";
25 # --config add the given configuration file, which will be read after
26 # any "Configurations*" files that are found in the same
27 # directory as this script.
28 # --prefix prefix for the OpenSSL installation, which includes the
29 # directories bin, lib, include, share/man, share/doc/openssl
30 # This becomes the value of INSTALLTOP in Makefile
31 # (Default: /usr/local)
32 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
33 # If it's a relative directory, it will be added on the directory
34 # given with --prefix.
35 # This becomes the value of OPENSSLDIR in Makefile and in C.
36 # (Default: PREFIX/ssl)
38 # --cross-compile-prefix Add specified prefix to binutils components.
40 # --api One of 0.9.8, 1.0.0 or 1.1.0. Do not compile support for
41 # interfaces deprecated as of the specified OpenSSL version.
43 # no-hw-xxx do not compile support for specific crypto hardware.
44 # Generic OpenSSL-style methods relating to this support
45 # are always compiled but return NULL if the hardware
46 # support isn't compiled.
47 # no-hw do not compile support for any crypto hardware.
48 # [no-]threads [don't] try to create a library that is suitable for
49 # multithreaded applications (default is "threads" if we
51 # [no-]shared [don't] try to create shared libraries when supported.
52 # [no-]pic [don't] try to build position independent code when supported.
53 # If disabled, it also disables shared and dynamic-engine.
54 # no-asm do not use assembler
55 # no-dso do not compile in any native shared-library methods. This
56 # will ensure that all methods just return NULL.
57 # no-egd do not compile support for the entropy-gathering daemon APIs
58 # [no-]zlib [don't] compile support for zlib compression.
59 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
60 # library and will be loaded in run-time by the OpenSSL library.
61 # sctp include SCTP support
62 # 386 generate 80386 code
63 # enable-weak-ssl-ciphers
64 # Enable weak ciphers that are disabled by default. This currently
65 # only includes RC4 based ciphers.
66 # no-sse2 disables IA-32 SSE2 code, above option implies no-sse2
67 # no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
68 # -<xxx> +<xxx> compiler options are passed through
70 # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items
71 # provided to stack calls. Generates unique stack functions for
72 # each possible stack type.
73 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
74 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
75 # Following are set automatically by this script
77 # MD5_ASM use some extra md5 assembler,
78 # SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
79 # RMD160_ASM use some extra ripemd160 assembler,
80 # SHA256_ASM sha256_block is implemented in assembler
81 # SHA512_ASM sha512_block is implemented in assembler
82 # AES_ASM ASE_[en|de]crypt is implemented in assembler
84 # Minimum warning options... any contributions to OpenSSL should at least get
87 # DEBUG_UNUSED enables __owur (warn unused result) checks.
88 my $gcc_devteam_warn = "-DDEBUG_UNUSED"
89 # -DPEDANTIC complements -pedantic and is meant to mask code that
90 # is not strictly standard-compliant and/or implementation-specifc,
91 # e.g. inline assembly, disregards to alignment requirements, such
92 # that -pedantic would complain about. Incidentally -DPEDANTIC has
93 # to be used even in sanitized builds, because sanitizer too is
94 # supposed to and does take notice of non-standard behaviour. Then
95 # -pedantic with pre-C9x compiler would also complain about 'long
96 # long' not being supported. As 64-bit algorithms are common now,
97 # it grew impossible to resolve this without sizeable additional
98 # code, so we just tell compiler to be pedantic about everything
99 # but 'long long' type.
100 . " -DPEDANTIC -pedantic -Wno-long-long"
103 . " -Wmissing-prototypes"
110 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
111 # TODO(openssl-team): fix problems and investigate if (at least) the
112 # following warnings can also be enabled:
116 # -Wlanguage-extension-token -- no, we use asm()
117 # -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
118 # -Wextended-offsetof -- no, needed in CMS ASN1 code
119 my $clang_devteam_warn = ""
120 . " -Qunused-arguments"
122 . " -Wno-unused-parameter"
123 . " -Wno-missing-field-initializers"
124 . " -Wno-language-extension-token"
125 . " -Wno-extended-offsetof"
126 . " -Wconditional-uninitialized"
127 . " -Wincompatible-pointer-types-discards-qualifiers"
128 . " -Wmissing-variable-declarations"
131 # This adds backtrace information to the memory leak info. Is only used
132 # when crypto-mdebug-backtrace is enabled.
133 my $memleak_devteam_backtrace = "-rdynamic";
135 my $strict_warnings = 0;
137 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
138 # which would cover all BSD flavors. -pthread applies to them all,
139 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
140 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
141 # which has to be accompanied by explicit -D_THREAD_SAFE and
142 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
143 # seems to be sufficient?
144 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
147 # API compability name to version number mapping.
149 my $maxapi = "1.1.0"; # API for "no-deprecated" builds
151 "1.1.0" => "0x10100000L",
152 "1.0.0" => "0x10000000L",
153 "0.9.8" => "0x00908000L",
160 # Forward declarations ###############################################
162 # read_config(filename)
164 # Reads a configuration file and populates %table with the contents
165 # (which the configuration file places in %targets).
168 # resolve_config(target)
170 # Resolves all the late evaluations, inheritances and so on for the
171 # chosen target and any target it inherits from.
175 # Information collection #############################################
177 # Unified build supports separate build dir
178 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
179 my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
180 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
182 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
184 $config{sourcedir} = abs2rel($srcdir);
185 $config{builddir} = abs2rel($blddir);
187 # Collect version numbers
188 $config{version} = "unknown";
189 $config{version_num} = "unknown";
190 $config{shlib_version_number} = "unknown";
191 $config{shlib_version_history} = "unknown";
194 collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')),
195 qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; },
196 qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 },
197 qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 },
198 qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 }
200 if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; }
202 ($config{major}, $config{minor})
203 = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/);
204 ($config{shlib_major}, $config{shlib_minor})
205 = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/);
206 die "erroneous version information in opensslv.h: ",
207 "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n"
208 if ($config{major} eq "" || $config{minor} eq ""
209 || $config{shlib_major} eq "" || $config{shlib_minor} eq "");
211 # Collect target configurations
213 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
214 foreach (sort glob($pattern)) {
218 if (defined $ENV{$local_config_envname}) {
220 # VMS environment variables are logical names,
221 # which can be used as is
222 $pattern = $local_config_envname . ':' . '*.conf';
224 $pattern = catfile($ENV{$local_config_envname}, '*.conf');
227 foreach (sort glob($pattern)) {
233 print "Configuring OpenSSL version $config{version} (0x$config{version_num})\n";
236 $config{openssldir}="";
237 $config{processor}="";
239 $config{cross_compile_prefix}="";
240 $config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/";
241 my $nofipscanistercheck=0;
242 $config{baseaddr}="0xFB00000";
243 my $auto_threads=1; # enable threads automatically? true by default
247 # Top level directories to build
248 $config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "tools" ];
249 # crypto/ subdirectories to build
252 "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", "blake2",
253 "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes",
254 "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
255 "buffer", "bio", "stack", "lhash", "rand", "err",
256 "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
257 "cms", "ts", "srp", "cmac", "ct", "async", "kdf"
260 # Known TLS and DTLS protocols
261 my @tls = qw(ssl3 tls1 tls1_1 tls1_2);
262 my @dtls = qw(dtls1 dtls1_2);
264 # Explicitly known options that are possible to disable. They can
265 # be regexps, and will be used like this: /^no-${option}$/
266 # For developers: keep it sorted alphabetically
285 "crypto-mdebug-backtrace",
299 "ec_nistp_64_gcc_128",
352 foreach my $proto ((@tls, @dtls))
354 push(@disablables, $proto);
355 push(@disablables, "$proto-method");
358 my @deprecated_disablables = (
363 # All of the following is disabled by default (RC5 was enabled before 0.9.8):
365 our %disabled = ( # "what" => "comment"
367 "ec_nistp_64_gcc_128" => "default",
369 "fuzz-libfuzzer" => "default",
370 "fuzz-afl" => "default",
374 "ssl-trace" => "default",
376 "ssl3-method" => "default",
377 "ubsan" => "default",
378 "unit-test" => "default",
379 "weak-ssl-ciphers" => "default",
381 "zlib-dynamic" => "default",
382 "crypto-mdebug" => "default",
383 "crypto-mdebug-backtrace" => "default",
384 "heartbeats" => "default",
387 # Note: => pair form used for aesthetics, not to truly make a hash table
388 my @disable_cascades = (
389 # "what" => [ "cascade", ... ]
390 sub { $config{processor} eq "386" }
393 "ssl3-method" => [ "ssl3" ],
394 "zlib" => [ "zlib-dynamic" ],
396 "ec" => [ "ecdsa", "ecdh" ],
398 "dgram" => [ "dtls", "sctp" ],
399 "sock" => [ "dgram" ],
402 # SSL 3.0, (D)TLS 1.0 and TLS 1.1 require MD5 and SHA
403 "md5" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
404 "sha" => [ "ssl", "tls1", "tls1_1", "dtls1" ],
406 # Additionally, SSL 3.0 requires either RSA or DSA+DH
408 && ($disabled{dsa} || $disabled{dh}); }
411 # (D)TLS 1.0 and TLS 1.1 also require either RSA or DSA+DH
412 # or ECDSA + ECDH. (D)TLS 1.2 has this requirement as well.
413 # (XXX: We don't support PSK-only builds).
415 && ($disabled{dsa} || $disabled{dh})
416 && ($disabled{ecdsa} || $disabled{ecdh}); }
417 => [ "tls1", "tls1_1", "tls1_2",
418 "dtls1", "dtls1_2" ],
422 # SRP and HEARTBEATS require TLSEXT
423 "tlsext" => [ "srp", "heartbeats" ],
425 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
427 # Without DSO, we can't load dynamic engines, so don't build them dynamic
428 "dso" => [ "dynamic-engine" ],
430 # Without position independent code, there can be no shared libraries or DSOs
431 "pic" => [ "shared" ],
432 "shared" => [ "dynamic-engine" ],
433 "engine" => [ "afalgeng" ],
435 # no-autoalginit is only useful when building non-shared
436 "autoalginit" => [ "shared", "apps" ],
438 "stdio" => [ "apps" ],
439 "apps" => [ "tests" ],
440 "comp" => [ "zlib" ],
441 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
444 # Avoid protocol support holes. Also disable all versions below N, if version
445 # N is disabled while N+1 is enabled.
447 my @list = (reverse @tls);
448 while ((my $first, my $second) = (shift @list, shift @list)) {
450 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
452 unshift @list, $second;
454 my @list = (reverse @dtls);
455 while ((my $first, my $second) = (shift @list, shift @list)) {
457 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
459 unshift @list, $second;
462 # Explicit "no-..." options will be collected in %disabled along with the defaults.
463 # To remove something from %disabled, use "enable-foo".
464 # For symmetry, "disable-foo" is a synonym for "no-foo".
468 &usage if ($#ARGV < 0);
472 $config{openssl_api_defines}=[];
473 $config{openssl_algorithm_defines}=[];
474 $config{openssl_thread_defines}=[];
475 $config{openssl_sys_defines}=[];
476 $config{openssl_other_defines}=[];
480 $config{build_type} = "release";
484 if (grep /^reconf(igure)?$/, @argvcopy) {
485 if (-f "./configdata.pm") {
486 my $file = "./configdata.pm";
487 unless (my $return = do $file) {
488 die "couldn't parse $file: $@" if $@;
489 die "couldn't do $file: $!" unless defined $return;
490 die "couldn't run $file" unless $return;
493 @argvcopy = defined($configdata::config{perlargv}) ?
494 @{$configdata::config{perlargv}} : ();
495 die "Incorrect data to reconfigure, please do a normal configuration\n"
496 if (grep(/^reconf/,@argvcopy));
497 $ENV{CROSS_COMPILE} = $configdata::config{cross_compile_prefix}
498 if defined($configdata::config{cross_compile_prefix});
499 $ENV{CROSS_COMPILE} = $configdata::config{cc}
500 if defined($configdata::config{cc});
502 print "Reconfiguring with: ", join(" ",@argvcopy), "\n";
503 print " CROSS_COMPILE = ",$ENV{CROSS_COMPILE},"\n"
504 if $ENV{CROSS_COMPILE};
505 print " CC = ",$ENV{CC},"\n" if $ENV{CC};
506 } elsif (open IN, "<Makefile") {
508 # THIS SECTION IS TEMPORARY, it helps transitioning from Makefile
509 # centered information gathering the reading configdata.pm
513 if (/^CONFIGURE_ARGS=\s*(.*)\s*/) {
514 # Older form, we split the string and hope for the best
515 @argvcopy = split /\s+/, $_;
516 die "Incorrect data to reconfigure, please do a normal configuration\n"
517 if (grep(/^reconf/,@argvcopy));
518 } elsif (/^CROSS_COMPILE=\s*(.*)/) {
519 $ENV{CROSS_COMPILE}=$1;
520 } elsif (/^CC=\s*(?:\$\(CROSS_COMPILE\))?(.*?)$/) {
525 # END OF TEMPORARY SECTION
528 die "Insufficient data to reconfigure, please do a normal configuration\n";
532 $config{perlargv} = [ @argvcopy ];
534 my %unsupported_options = ();
535 my %deprecated_options = ();
538 # VMS is a case insensitive environment, and depending on settings
539 # out of our control, we may receive options uppercased. Let's
540 # downcase at least the part before any equal sign.
545 s /^-no-/no-/; # some people just can't read the instructions
547 # rewrite some options in "enable-..." form
548 s /^-?-?shared$/enable-shared/;
549 s /^sctp$/enable-sctp/;
550 s /^threads$/enable-threads/;
551 s /^zlib$/enable-zlib/;
552 s /^zlib-dynamic$/enable-zlib-dynamic/;
554 if (/^(no|disable|enable)-(.+)$/)
557 if (grep { $word =~ /^${_}$/ } @deprecated_disablables)
559 $deprecated_options{$_} = 1;
562 elsif (!grep { $word =~ /^${_}$/ } @disablables)
564 $unsupported_options{$_} = 1;
568 if (/^no-(.+)$/ || /^disable-(.+)$/)
570 foreach my $proto ((@tls, @dtls))
572 if ($1 eq "$proto-method")
574 $disabled{"$proto"} = "option($proto-method)";
580 foreach my $proto (@dtls)
582 $disabled{$proto} = "option(dtls)";
584 $disabled{"dtls"} = "option(dtls)";
588 # Last one of its kind
589 $disabled{"ssl3"} = "option(ssl)";
593 # XXX: Tests will fail if all SSL/TLS
594 # protocols are disabled.
595 foreach my $proto (@tls)
597 $disabled{$proto} = "option(tls)";
600 elsif ($1 eq "static-engine")
602 delete $disabled{"dynamic-engine"};
604 elsif ($1 eq "dynamic-engine")
606 $disabled{"dynamic-engine"} = "option";
610 $disabled{$1} = "option";
612 # No longer an automatic choice
613 $auto_threads = 0 if ($1 eq "threads");
615 elsif (/^enable-(.+)$/)
617 if ($1 eq "static-engine")
619 $disabled{"dynamic-engine"} = "option";
621 elsif ($1 eq "dynamic-engine")
623 delete $disabled{"dynamic-engine"};
625 elsif ($1 eq "zlib-dynamic")
627 delete $disabled{"zlib"};
630 delete $disabled{$algo};
632 # No longer an automatic choice
633 $auto_threads = 0 if ($1 eq "threads");
635 elsif (/^--strict-warnings$/)
637 $strict_warnings = 1;
641 $config{build_type} = "debug";
643 elsif (/^--release$/)
645 $config{build_type} = "release";
648 { $config{processor}=386; }
655 # No RSAref support any more since it's not needed.
656 # The check for the option is there so scripts aren't
659 elsif (/^nofipscanistercheck$/)
662 $nofipscanistercheck = 1;
666 if (/^--prefix=(.*)$/)
669 die "Directory given with --prefix MUST be absolute\n"
670 unless file_name_is_absolute($config{prefix});
672 elsif (/^--api=(.*)$/)
676 elsif (/^--libdir=(.*)$/)
680 elsif (/^--openssldir=(.*)$/)
682 $config{openssldir}=$1;
684 elsif (/^--with-zlib-lib=(.*)$/)
686 $withargs{zlib_lib}=$1;
688 elsif (/^--with-zlib-include=(.*)$/)
690 $withargs{zlib_include}=$1;
692 elsif (/^--with-fuzzer-lib=(.*)$/)
694 $withargs{fuzzer_lib}=$1;
696 elsif (/^--with-fuzzer-include=(.*)$/)
698 $withargs{fuzzer_include}=$1;
700 elsif (/^--with-fipslibdir=(.*)$/)
702 $config{fipslibdir}="$1/";
704 elsif (/^--with-baseaddr=(.*)$/)
706 $config{baseaddr}="$1";
708 elsif (/^--cross-compile-prefix=(.*)$/)
710 $config{cross_compile_prefix}=$1;
712 elsif (/^--config=(.*)$/)
716 elsif (/^-[lL](.*)$/ or /^-Wl,/)
722 push @user_defines, $1;
724 else # common if (/^[-+]/), just pass down...
726 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
727 $user_cflags.=" ".$_;
732 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
735 unless ($_ eq $target || /^no-/ || /^disable-/)
737 # "no-..." follows later after implied disactivations
738 # have been derived. (Don't take this too seriously,
739 # we really only write OPTIONS to the Makefile out of
742 if ($config{options} eq "")
743 { $config{options} = $_; }
745 { $config{options} .= " ".$_; }
748 if (defined($config{api}) && !exists $apitable->{$config{api}}) {
749 die "***** Unsupported api compatibility level: $config{api}\n",
752 if (keys %deprecated_options)
754 warn "***** Deprecated options: ",
755 join(", ", keys %deprecated_options), "\n";
757 if (keys %unsupported_options)
759 die "***** Unsupported options: ",
760 join(", ", keys %unsupported_options), "\n";
766 delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
770 @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}};
773 my @tocheckfor = (keys %disabled);
774 while (@tocheckfor) {
775 my %new_tocheckfor = ();
776 my @cascade_copy = (@disable_cascades);
777 while (@cascade_copy) {
778 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
779 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
780 foreach(grep { !defined($disabled{$_}) } @$descendents) {
781 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
785 @tocheckfor = (keys %new_tocheckfor);
788 if ($target eq "TABLE") {
789 foreach (sort keys %table) {
790 print_table_entry($_, "TABLE");
795 if ($target eq "LIST") {
796 foreach (sort keys %table) {
797 print $_,"\n" unless $table{$_}->{template};
802 if ($target eq "HASH") {
803 print "%table = (\n";
804 foreach (sort keys %table) {
805 print_table_entry($_, "HASH");
810 # Backward compatibility?
811 if ($target =~ m/^CygWin32(-.*)$/) {
812 $target = "Cygwin".$1;
815 foreach (sort (keys %disabled))
817 $config{options} .= " no-$_";
819 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
831 elsif (/^dynamic-engine$/)
833 elsif (/^makedepend$/)
835 elsif (/^zlib-dynamic$/)
841 @{$config{dirs}} = grep !/^engines$/, @{$config{dirs}};
842 @{$config{sdirs}} = grep !/^engine$/, @{$config{sdirs}};
843 push @{$config{openssl_other_defines}}, "OPENSSL_NO_ENGINE";
848 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
850 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/ || /^async$/
851 || /^autoalginit/ || /^autoerrinit/)
853 push @{$config{openssl_other_defines}}, "OPENSSL_NO_$ALGO";
854 print " OPENSSL_NO_$ALGO";
856 if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; }
860 ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
862 push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO";
863 print " OPENSSL_NO_$ALGO";
865 # fix-up crypto/directory name(s)
866 $algo="whrlpool" if $algo eq "whirlpool";
867 $algo="ripemd" if $algo eq "rmd160";
868 @{$config{sdirs}} = grep { $_ ne $algo} @{$config{sdirs}};
877 print "Configuring for $target\n";
879 # Support for legacy targets having a name starting with 'debug-'
880 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
882 $config{build_type} = "debug";
884 # If we do not find debug-foo in the table, the target is set to foo.
885 if (!$table{$target}) {
889 $config{target} = $target;
890 my %target = resolve_config($target);
892 &usage if (!%target || $target{template});
894 %target = ( %{$table{DEFAULTS}}, %target );
896 $target{exe_extension}="";
897 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP"
898 || $config{target} =~ /^(?:Cygwin|mingw)/);
899 $target{exe_extension}=".pm" if ($config{target} =~ /vos/);
901 ($target{shared_extension_simple}=$target{shared_extension})
902 =~ s|\.\$\(SHLIB_MAJOR\)\.\$\(SHLIB_MINOR\)||;
903 $target{dso_extension}=$target{shared_extension_simple};
904 ($target{shared_import_extension}=$target{shared_extension_simple}.".a")
905 if ($config{target} =~ /^(?:Cygwin|mingw)/);
908 $config{cross_compile_prefix} = $ENV{'CROSS_COMPILE'}
909 if $config{cross_compile_prefix} eq "";
911 # Allow overriding the names of some tools. USE WITH CARE
912 $config{perl} = $ENV{'PERL'} || ($^O ne "VMS" ? $^X : "perl");
913 $target{cc} = $ENV{'CC'} || $target{cc} || "cc";
914 $target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} ||
915 (which("$config{cross_compile_prefix}ranlib") ?
916 "\$(CROSS_COMPILE)ranlib" : "true");
917 $target{ar} = $ENV{'AR'} || $target{ar} || "ar";
918 $target{nm} = $ENV{'NM'} || $target{nm} || "nm";
920 $ENV{'RC'} || $ENV{'WINDRES'} || $target{rc} || "windres";
922 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
923 # or release_ attributes.
924 # Do it in such a way that no spurious space is appended (hence the grep).
925 $config{defines} = [];
926 $config{cflags} = "";
927 $config{ex_libs} = "";
928 $config{shared_ldflag} = "";
930 # Make sure build_scheme is consistent.
931 $target{build_scheme} = [ $target{build_scheme} ]
932 if ref($target{build_scheme}) ne "ARRAY";
934 my ($builder, $builder_platform, @builder_opts) =
935 @{$target{build_scheme}};
937 push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
939 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
941 $config{cflags} .= " -mno-cygwin";
942 $config{shared_ldflag} .= " -mno-cygwin";
945 if ($target =~ /linux.*-mips/ && !$disabled{asm} && $user_cflags !~ /-m(ips|arch=)/) {
946 # minimally required architecture flags for assembly modules
947 $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/);
948 $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/);
951 my $no_shared_warn=0;
952 my $no_user_cflags=0;
953 my $no_user_defines=0;
955 # The DSO code currently always implements all functions so that no
956 # applications will have to worry about that from a compilation point
957 # of view. However, the "method"s may return zero unless that platform
958 # has support compiled in for them. Currently each method is enabled
959 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
960 # string entry into using the following logic;
961 if (!$disabled{dso} && $target{dso_scheme} ne "")
963 $target{dso_scheme} =~ tr/[a-z]/[A-Z]/;
964 if ($target{dso_scheme} eq "DLFCN")
966 unshift @{$config{defines}}, "DSO_DLFCN", "HAVE_DLFCN_H";
968 elsif ($target{dso_scheme} eq "DLFCN_NO_H")
970 unshift @{$config{defines}}, "DSO_DLFCN";
974 unshift @{$config{defines}}, "DSO_$target{dso_scheme}";
978 $config{ex_libs}="$libs$config{ex_libs}" if ($libs ne "");
984 @{$config{defines}} = grep !/^[BL]_ENDIAN$/, @{$config{defines}};
985 @{$target{defines}} = grep !/^[BL]_ENDIAN$/, @{$target{defines}};
989 # If threads aren't disabled, check how possible they are
990 unless ($disabled{threads}) {
992 # Enabled by default, disable it forcibly if unavailable
993 if ($target{thread_scheme} eq "(unknown)") {
994 $disabled{threads} = "unavailable";
997 # The user chose to enable threads explicitly, let's see
998 # if there's a chance that's possible
999 if ($target{thread_scheme} eq "(unknown)") {
1000 # If the user asked for "threads" and we don't have internal
1001 # knowledge how to do it, [s]he is expected to provide any
1002 # system-dependent compiler options that are necessary. We
1003 # can't truly check that the given options are correct, but
1004 # we expect the user to know what [s]He is doing.
1005 if ($no_user_cflags && $no_user_defines) {
1006 die "You asked for multi-threading support, but didn't\n"
1007 ,"provide any system-specific compiler options\n";
1013 # If threads still aren't disabled, add a C macro to ensure the source
1014 # code knows about it. Any other flag is taken care of by the configs.
1015 unless($disabled{threads}) {
1016 foreach (("defines", "openssl_thread_defines")) {
1017 push @{$config{$_}}, "OPENSSL_THREADS";
1021 # With "deprecated" disable all deprecated features.
1022 if (defined($disabled{"deprecated"})) {
1023 $config{api} = $maxapi;
1026 if ($target{shared_target} eq "")
1029 if ((!$disabled{shared} || !$disabled{"dynamic-engine"})
1031 $disabled{shared} = "no-shared-target";
1032 $disabled{pic} = $disabled{shared} = $disabled{"dynamic-engine"} =
1036 if ($disabled{"dynamic-engine"}) {
1037 push @{$config{defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1038 $config{dynamic_engines} = 0;
1040 push @{$config{defines}}, "OPENSSL_NO_STATIC_ENGINE";
1041 $config{dynamic_engines} = 1;
1044 unless ($disabled{"fuzz-libfuzzer"}) {
1045 push @{$config{dirs}}, "fuzz";
1046 $config{cflags} .= "-fsanitize-coverage=edge,indirect-calls ";
1049 unless ($disabled{"fuzz-afl"}) {
1050 push @{$config{dirs}}, "fuzz";
1053 unless ($disabled{asan}) {
1054 $config{cflags} .= "-fsanitize=address ";
1057 unless ($disabled{ubsan}) {
1058 # -DPEDANTIC or -fnosanitize=aligmnent may also be required on some
1060 $config{cflags} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1063 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1064 && $disabled{asan} && $disabled{ubsan}) {
1065 $config{cflags} .= "-fno-omit-frame-pointer -g ";
1071 # This saves the build files from having to check
1074 $target{shared_cflag} = $target{shared_ldflag} =
1075 $target{shared_rcflag} = "";
1079 push @{$config{defines}}, "OPENSSL_PIC";
1082 if ($target{sys_id} ne "")
1084 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1087 unless ($disabled{asm}) {
1088 $target{cpuid_asm_src}=$table{DEFAULTS}->{cpuid_asm_src} if ($config{processor} eq "386");
1089 $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m}));
1091 # bn-586 is the only one implementing bn_*_part_words
1092 push @{$config{defines}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/);
1093 push @{$config{defines}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/);
1095 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/);
1096 push @{$config{defines}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/);
1097 push @{$config{defines}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/);
1099 if ($config{fips}) {
1100 push @{$config{openssl_other_defines}}, "OPENSSL_FIPS";
1103 if ($target{sha1_asm_src}) {
1104 push @{$config{defines}}, "SHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/);
1105 push @{$config{defines}}, "SHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/);
1106 push @{$config{defines}}, "SHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/);
1108 if ($target{md5_asm_src}) {
1109 push @{$config{defines}}, "MD5_ASM";
1111 $target{cast_asm_src}=$table{DEFAULTS}->{cast_asm_src} unless $disabled{pic}; # CAST assembler is not PIC
1112 if ($target{rmd160_asm_src}) {
1113 push @{$config{defines}}, "RMD160_ASM";
1115 if ($target{aes_asm_src}) {
1116 push @{$config{defines}}, "AES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);;
1117 # aes-ctr.fake is not a real file, only indication that assembler
1118 # module implements AES_ctr32_encrypt...
1119 push @{$config{defines}}, "AES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//);
1120 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1121 push @{$config{defines}}, "AES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//);
1122 $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1123 push @{$config{defines}}, "VPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/);
1124 push @{$config{defines}}, "BSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/);
1126 if ($target{wp_asm_src} =~ /mmx/) {
1127 if ($config{processor} eq "386") {
1128 $target{wp_asm_src}=$table{DEFAULTS}->{wp_asm_src};
1129 } elsif (!$disabled{"whirlpool"}) {
1130 push @{$config{defines}}, "WHIRLPOOL_ASM";
1133 if ($target{modes_asm_src} =~ /ghash-/) {
1134 push @{$config{defines}}, "GHASH_ASM";
1136 if ($target{ec_asm_src} =~ /ecp_nistz256/) {
1137 push @{$config{defines}}, "ECP_NISTZ256_ASM";
1139 if ($target{poly1305_asm_src} ne "") {
1140 push @{$config{defines}}, "POLY1305_ASM";
1144 my $ecc = $target{cc};
1145 if ($^O ne "VMS" && !$disabled{makedepend}) {
1146 # Is the compiler gcc or clang? $ecc is used below to see if
1147 # error-checking can be turned on.
1148 my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
1149 open(PIPE, "$ccpcc --version 2>&1 |");
1152 # Find the version number and save the major.
1153 m|(?:.*)\b(\d+)\.\d+\.\d+\b(?:.*)|;
1154 my $compiler_major = $1;
1155 # We know that GNU C version 3 and up as well as all clang
1156 # versions support dependency generation
1157 $config{makedepprog} = $ccpcc
1158 if (/clang/ || (/gcc/ && $compiler_major > 3));
1159 $ecc = "clang" if /clang/;
1160 $ecc = "gcc" if /gcc/;
1161 last if ($config{makedepprog} || !$lines--);
1165 $config{makedepprog} = which('makedepend') unless $config{makedepprog};
1166 $disabled{makedepend} = "unavailable" unless $config{makedepprog};
1171 # Deal with bn_ops ###################################################
1174 $config{export_var_as_fn} =0;
1175 my $def_int="unsigned int";
1176 $config{rc4_int} =$def_int;
1177 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1180 foreach (sort split(/\s+/,$target{bn_ops})) {
1181 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1182 $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1183 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1184 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1185 ($config{b64l},$config{b64},$config{b32})
1186 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1187 ($config{b64l},$config{b64},$config{b32})
1188 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1189 ($config{b64l},$config{b64},$config{b32})
1190 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1192 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1196 # Hack cflags for better warnings (dev option) #######################
1198 # "Stringify" the C flags string. This permits it to be made part of a string
1199 # and works as well on command lines.
1200 $config{cflags} =~ s/([\\\"])/\\$1/g;
1202 if (defined($config{api})) {
1203 $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ];
1204 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api}});
1205 push @{$config{defines}}, $apiflag;
1208 if ($strict_warnings)
1211 die "ERROR --strict-warnings requires gcc or clang"
1212 unless $ecc eq 'gcc' || $ecc eq 'clang';
1213 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1215 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1217 if ($ecc eq "clang")
1219 foreach $wopt (split /\s+/, $clang_devteam_warn)
1221 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1226 unless ($disabled{"crypto-mdebug-backtrace"})
1228 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1230 $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(?:^|\s)$wopt(?:\s|$)/)
1232 if ($target =~ /^BSD-/)
1234 $config{ex_libs} .= " -lexecinfo";
1238 if ($user_cflags ne "") { $config{cflags}="$config{cflags}$user_cflags"; }
1239 else { $no_user_cflags=1; }
1240 if (@user_defines) { $config{defines}=[ @{$config{defines}}, @user_defines ]; }
1241 else { $no_user_defines=1; }
1243 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1245 unless ($disabled{afalgeng}) {
1246 $config{afalgeng}="";
1247 if ($target =~ m/^linux/) {
1248 my $minver = 4*10000 + 1*100 + 0;
1249 if ($config{cross_compile_prefix} eq "") {
1250 my $verstr = `uname -r`;
1251 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1252 ($mi2) = $mi2 =~ /(\d+)/;
1253 my $ver = $ma*10000 + $mi1*100 + $mi2;
1254 if ($ver < $minver) {
1255 $disabled{afalgeng} = "too-old-kernel";
1257 push @{$config{engdirs}}, "afalg";
1260 $disabled{afalgeng} = "cross-compiling";
1263 $disabled{afalgeng} = "not-linux";
1267 push @{$config{openssl_other_defines}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng});
1269 # If we use the unified build, collect information from build.info files
1270 my %unified_info = ();
1272 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1273 if ($builder eq "unified") {
1274 # Store the name of the template file we will build the build file from
1275 # in %config. This may be useful for the build file itself.
1276 my $build_file_template;
1278 for my $filename (( $builder_platform."-".$target{build_file}.".tmpl",
1279 $target{build_file}.".tmpl" )) {
1280 if (defined $ENV{$local_config_envname}) {
1282 # VMS environment variables are logical names,
1283 # which can be used as is
1284 $build_file_template = $local_config_envname . ':' . $filename;
1286 $build_file_template = catfile($ENV{$local_config_envname},
1291 last if -f $build_file_template;
1293 $build_file_template = catfile($srcdir, "Configurations", $filename);
1295 last if -f $build_file_template;
1297 $config{build_file_template} = $build_file_template;
1299 use lib catdir(dirname(__FILE__),"util");
1300 use with_fallback qw(Text::Template);
1305 my $relativeto = shift || ".";
1307 $dir = catdir($base,$dir) unless isabsolute($dir);
1309 # Make sure the directories we're building in exists
1312 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1313 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1320 my $relativeto = shift || ".";
1322 $file = catfile($base,$file) unless isabsolute($file);
1324 my $d = dirname($file);
1325 my $f = basename($file);
1327 # Make sure the directories we're building in exists
1330 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1331 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1335 my @build_infos = ( [ ".", "build.info" ] );
1336 foreach (@{$config{dirs}}) {
1337 push @build_infos, [ $_, "build.info" ]
1338 if (-f catfile($srcdir, $_, "build.info"));
1340 foreach (@{$config{sdirs}}) {
1341 push @build_infos, [ catdir("crypto", $_), "build.info" ]
1342 if (-f catfile($srcdir, "crypto", $_, "build.info"));
1344 foreach (@{$config{engdirs}}) {
1345 push @build_infos, [ catdir("engines", $_), "build.info" ]
1346 if (-f catfile($srcdir, "engines", $_, "build.info"));
1349 $config{build_infos} = [ ];
1351 foreach (@build_infos) {
1352 my $sourced = catdir($srcdir, $_->[0]);
1353 my $buildd = catdir($blddir, $_->[0]);
1358 # The basic things we're trying to build
1365 my @intermediates = ();
1370 my %shared_sources = ();
1374 my %sharednames = ();
1377 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1378 my $template = Text::Template->new(TYPE => 'FILE',
1379 SOURCE => catfile($sourced, $f));
1380 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1383 $template->fill_in(HASH => { config => \%config,
1385 disabled => \%disabled,
1386 withargs => \%withargs,
1387 builddir => abs2rel($buildd, $blddir),
1388 sourcedir => abs2rel($sourced, $blddir),
1389 buildtop => abs2rel($blddir, $blddir),
1390 sourcetop => abs2rel($srcdir, $blddir) },
1391 DELIMITERS => [ "{-", "-}" ]);
1393 # The top item of this stack has the following values
1394 # -2 positive already run and we found ELSE (following ELSIF should fail)
1395 # -1 positive already run (skip until ENDIF)
1396 # 0 negatives so far (if we're at a condition, check it)
1397 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1398 # 2 positive ELSE (following ELSIF should fail)
1400 collect_information(
1401 collect_from_array([ @text ],
1402 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1403 $l1 =~ s/\\$//; $l1.$l2 }),
1404 # Info we're looking for
1405 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1407 if (! @skip || $skip[$#skip] > 0) {
1413 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1414 => sub { die "ELSIF out of scope" if ! @skip;
1415 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1416 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1417 $skip[$#skip] = !! $1
1418 if $skip[$#skip] == 0; },
1420 => sub { die "ELSE out of scope" if ! @skip;
1421 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1422 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1424 => sub { die "ENDIF out of scope" if ! @skip;
1426 qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/
1427 => sub { push @programs, tokenize($1)
1428 if !@skip || $skip[$#skip] > 0 },
1429 qr/^\s*LIBS\s*=\s*(.*)\s*$/
1430 => sub { push @libraries, tokenize($1)
1431 if !@skip || $skip[$#skip] > 0 },
1432 qr/^\s*ENGINES\s*=\s*(.*)\s*$/
1433 => sub { push @engines, tokenize($1)
1434 if !@skip || $skip[$#skip] > 0 },
1435 qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/
1436 => sub { push @scripts, tokenize($1)
1437 if !@skip || $skip[$#skip] > 0 },
1438 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1439 => sub { push @extra, tokenize($1)
1440 if !@skip || $skip[$#skip] > 0 },
1441 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1442 => sub { push @overrides, tokenize($1)
1443 if !@skip || $skip[$#skip] > 0 },
1445 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1446 => sub { push @{$ordinals{$1}}, tokenize($2)
1447 if !@skip || $skip[$#skip] > 0 },
1448 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1449 => sub { push @{$sources{$1}}, tokenize($2)
1450 if !@skip || $skip[$#skip] > 0 },
1451 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1452 => sub { push @{$shared_sources{$1}}, tokenize($2)
1453 if !@skip || $skip[$#skip] > 0 },
1454 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1455 => sub { push @{$includes{$1}}, tokenize($2)
1456 if !@skip || $skip[$#skip] > 0 },
1457 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1458 => sub { push @{$depends{$1}}, tokenize($2)
1459 if !@skip || $skip[$#skip] > 0 },
1460 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1461 => sub { push @{$generate{$1}}, $2
1462 if !@skip || $skip[$#skip] > 0 },
1463 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1464 => sub { push @{$renames{$1}}, tokenize($2)
1465 if !@skip || $skip[$#skip] > 0 },
1466 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1467 => sub { push @{$sharednames{$1}}, tokenize($2)
1468 if !@skip || $skip[$#skip] > 0 },
1469 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1471 my $lineiterator = shift;
1472 my $target_kind = $1;
1473 while (defined $lineiterator->()) {
1475 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1476 die "ENDRAW doesn't match BEGINRAW"
1477 if $1 ne $target_kind;
1480 next if @skip && $skip[$#skip] <= 0;
1482 if ($target_kind eq $target{build_file}
1483 || $target_kind eq $target{build_file}."(".$builder_platform.")");
1486 qr/^(?:#.*|\s*)$/ => sub { },
1487 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1489 if ($buildinfo_debug) {
1490 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
1491 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1495 if ($buildinfo_debug) {
1496 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1500 die "runaway IF?" if (@skip);
1502 foreach (keys %renames) {
1503 die "$_ renamed to more than one thing: "
1504 ,join(" ", @{$renames{$_}}),"\n"
1505 if scalar @{$renames{$_}} > 1;
1506 my $dest = cleanfile($buildd, $_, $blddir);
1507 my $to = cleanfile($buildd, $renames{$_}->[0], $blddir);
1508 die "$dest renamed to more than one thing: "
1509 ,$unified_info{rename}->{$dest}, $to
1510 unless !defined($unified_info{rename}->{$dest})
1511 or $unified_info{rename}->{$dest} eq $to;
1512 $unified_info{rename}->{$dest} = $to;
1515 foreach (@programs) {
1516 my $program = cleanfile($buildd, $_, $blddir);
1517 if ($unified_info{rename}->{$program}) {
1518 $program = $unified_info{rename}->{$program};
1520 $unified_info{programs}->{$program} = 1;
1523 foreach (@libraries) {
1524 my $library = cleanfile($buildd, $_, $blddir);
1525 if ($unified_info{rename}->{$library}) {
1526 $library = $unified_info{rename}->{$library};
1528 $unified_info{libraries}->{$library} = 1;
1531 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1532 ENGINES can only be used if configured with 'dynamic-engine'.
1533 This is usually a fault in a build.info file.
1535 foreach (@engines) {
1536 my $library = cleanfile($buildd, $_, $blddir);
1537 if ($unified_info{rename}->{$library}) {
1538 $library = $unified_info{rename}->{$library};
1540 $unified_info{engines}->{$library} = 1;
1543 foreach (@scripts) {
1544 my $script = cleanfile($buildd, $_, $blddir);
1545 if ($unified_info{rename}->{$script}) {
1546 $script = $unified_info{rename}->{$script};
1548 $unified_info{scripts}->{$script} = 1;
1552 my $extra = cleanfile($buildd, $_, $blddir);
1553 $unified_info{extra}->{$extra} = 1;
1556 foreach (@overrides) {
1557 my $override = cleanfile($buildd, $_, $blddir);
1558 $unified_info{overrides}->{$override} = 1;
1561 push @{$unified_info{rawlines}}, @rawlines;
1563 unless ($disabled{shared}) {
1564 # Check sharednames.
1565 foreach (keys %sharednames) {
1566 my $dest = cleanfile($buildd, $_, $blddir);
1567 if ($unified_info{rename}->{$dest}) {
1568 $dest = $unified_info{rename}->{$dest};
1570 die "shared_name for $dest with multiple values: "
1571 ,join(" ", @{$sharednames{$_}}),"\n"
1572 if scalar @{$sharednames{$_}} > 1;
1573 my $to = cleanfile($buildd, $sharednames{$_}->[0], $blddir);
1574 die "shared_name found for a library $dest that isn't defined\n"
1575 unless $unified_info{libraries}->{$dest};
1576 die "shared_name for $dest with multiple values: "
1577 ,$unified_info{sharednames}->{$dest}, ", ", $to
1578 unless !defined($unified_info{sharednames}->{$dest})
1579 or $unified_info{sharednames}->{$dest} eq $to;
1580 $unified_info{sharednames}->{$dest} = $to;
1583 # Additionally, we set up sharednames for libraries that don't
1584 # have any, as themselves.
1585 foreach (keys %{$unified_info{libraries}}) {
1586 if (!defined $unified_info{sharednames}->{$_}) {
1587 $unified_info{sharednames}->{$_} = $_
1592 foreach (keys %ordinals) {
1594 my $ddest = cleanfile($buildd, $_, $blddir);
1595 if ($unified_info{rename}->{$ddest}) {
1596 $ddest = $unified_info{rename}->{$ddest};
1598 foreach (@{$ordinals{$dest}}) {
1599 my %known_ordinals =
1602 cleanfile($sourced, catfile("util", "libcrypto.num"), $blddir),
1604 cleanfile($sourced, catfile("util", "libssl.num"), $blddir)
1606 my $o = $known_ordinals{$_};
1607 die "Ordinals for $ddest defined more than once\n"
1608 if $unified_info{ordinals}->{$ddest};
1609 $unified_info{ordinals}->{$ddest} = [ $_, $o ];
1613 foreach (keys %sources) {
1615 my $ddest = cleanfile($buildd, $_, $blddir);
1616 if ($unified_info{rename}->{$ddest}) {
1617 $ddest = $unified_info{rename}->{$ddest};
1619 foreach (@{$sources{$dest}}) {
1620 my $s = cleanfile($sourced, $_, $blddir);
1622 # If it isn't in the source tree, we assume it's generated
1625 $s = cleanfile($buildd, $_, $blddir);
1627 # We recognise C and asm files
1628 if ($s =~ /\.[csS]\b$/) {
1629 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1630 $o = cleanfile($buildd, $o, $blddir);
1631 $unified_info{sources}->{$ddest}->{$o} = 1;
1632 $unified_info{sources}->{$o}->{$s} = 1;
1634 $unified_info{sources}->{$ddest}->{$s} = 1;
1639 foreach (keys %shared_sources) {
1641 my $ddest = cleanfile($buildd, $_, $blddir);
1642 if ($unified_info{rename}->{$ddest}) {
1643 $ddest = $unified_info{rename}->{$ddest};
1645 foreach (@{$shared_sources{$dest}}) {
1646 my $s = cleanfile($sourced, $_, $blddir);
1648 # If it isn't in the source tree, we assume it's generated
1651 $s = cleanfile($buildd, $_, $blddir);
1653 # We recognise C and asm files
1654 if ($s =~ /\.[csS]\b$/) {
1655 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1656 $o = cleanfile($buildd, $o, $blddir);
1657 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
1658 $unified_info{sources}->{$o}->{$s} = 1;
1660 die "unrecognised source file type for shared library: $s\n";
1665 foreach (keys %generate) {
1667 my $ddest = cleanfile($buildd, $_, $blddir);
1668 if ($unified_info{rename}->{$ddest}) {
1669 $ddest = $unified_info{rename}->{$ddest};
1671 die "more than one generator for $dest: "
1672 ,join(" ", @{$generate{$_}}),"\n"
1673 if scalar @{$generate{$_}} > 1;
1674 my @generator = split /\s+/, $generate{$dest}->[0];
1675 $generator[0] = cleanfile($sourced, $generator[0], $blddir),
1676 $unified_info{generate}->{$ddest} = [ @generator ];
1679 foreach (keys %depends) {
1681 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
1683 # If the destination doesn't exist in source, it can only be
1684 # a generated file in the build tree.
1685 if ($ddest ne "" && ! -f $ddest) {
1686 $ddest = cleanfile($buildd, $_, $blddir);
1687 if ($unified_info{rename}->{$ddest}) {
1688 $ddest = $unified_info{rename}->{$ddest};
1691 foreach (@{$depends{$dest}}) {
1692 my $d = cleanfile($sourced, $_, $blddir);
1694 # If we know it's generated, or assume it is because we can't
1695 # find it in the source tree, we set file we depend on to be
1696 # in the build tree rather than the source tree, and assume
1697 # and that there are lines to build it in a BEGINRAW..ENDRAW
1698 # section or in the Makefile template.
1700 || (grep { $d eq $_ }
1701 map { cleanfile($srcdir, $_, $blddir) }
1702 grep { /\.h$/ } keys %{$unified_info{generate}})) {
1703 $d = cleanfile($buildd, $_, $blddir);
1705 # Take note if the file to depend on is being renamed
1706 if ($unified_info{rename}->{$d}) {
1707 $d = $unified_info{rename}->{$d};
1709 $unified_info{depends}->{$ddest}->{$d} = 1;
1710 # If we depend on a header file or a perl module, let's make
1711 # sure it can get included
1712 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
1713 my $i = dirname($d);
1714 push @{$unified_info{includes}->{$ddest}}, $i
1715 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1720 foreach (keys %includes) {
1722 my $ddest = cleanfile($sourced, $_, $blddir);
1724 # If the destination doesn't exist in source, it can only be
1725 # a generated file in the build tree.
1727 $ddest = cleanfile($buildd, $_, $blddir);
1728 if ($unified_info{rename}->{$ddest}) {
1729 $ddest = $unified_info{rename}->{$ddest};
1732 foreach (@{$includes{$dest}}) {
1733 my $i = cleandir($sourced, $_, $blddir);
1734 push @{$unified_info{includes}->{$ddest}}, $i
1735 unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}};
1740 ### Make unified_info a bit more efficient
1741 # One level structures
1742 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1743 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1745 # Two level structures
1746 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends")) {
1747 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1748 $unified_info{$l1}->{$l2} =
1749 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1754 # For the schemes that need it, we provide the old *_obj configs
1755 # from the *_asm_obj ones
1756 foreach (grep /_(asm|aux)_src$/, keys %target) {
1758 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1759 ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1762 # Write down our configuration where it fits #########################
1764 open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1772 #use vars qw(\@ISA \@EXPORT);
1773 our \@ISA = qw(Exporter);
1774 our \@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
1777 print OUT "our %config = (\n";
1778 foreach (sort keys %config) {
1779 if (ref($config{$_}) eq "ARRAY") {
1780 print OUT " ", $_, " => [ ", join(", ",
1781 map { quotify("perl", $_) }
1782 @{$config{$_}}), " ],\n";
1784 print OUT " ", $_, " => ", quotify("perl", $config{$_}), ",\n"
1791 print OUT "our %target = (\n";
1792 foreach (sort keys %target) {
1793 if (ref($target{$_}) eq "ARRAY") {
1794 print OUT " ", $_, " => [ ", join(", ",
1795 map { quotify("perl", $_) }
1796 @{$target{$_}}), " ],\n";
1798 print OUT " ", $_, " => ", quotify("perl", $target{$_}), ",\n"
1805 print OUT "our \%available_protocols = (\n";
1806 print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n";
1807 print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n";
1812 print OUT "our \@disablables = (\n";
1813 foreach (@disablables) {
1814 print OUT " ", quotify("perl", $_), ",\n";
1820 print OUT "our \%disabled = (\n";
1821 foreach (sort keys %disabled) {
1822 print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n";
1828 print OUT "our %withargs = (\n";
1829 foreach (sort keys %withargs) {
1830 if (ref($withargs{$_}) eq "ARRAY") {
1831 print OUT " ", $_, " => [ ", join(", ",
1832 map { quotify("perl", $_) }
1833 @{$withargs{$_}}), " ],\n";
1835 print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n"
1842 if ($builder eq "unified") {
1847 if (ref $_ eq "ARRAY") {
1848 print OUT " "x$indent, "[\n";
1850 $recurse->($indent + 4, $_);
1852 print OUT " "x$indent, "],\n";
1853 } elsif (ref $_ eq "HASH") {
1855 print OUT " "x$indent, "{\n";
1856 foreach (sort keys %h) {
1857 if (ref $h{$_} eq "") {
1858 print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n";
1860 print OUT " "x($indent + 4), quotify("perl", $_), " =>\n";
1861 $recurse->($indent + 8, $h{$_});
1864 print OUT " "x$indent, "},\n";
1866 print OUT " "x$indent, quotify("perl", $_), ",\n";
1870 print OUT "our %unified_info = (\n";
1871 foreach (sort keys %unified_info) {
1872 if (ref $unified_info{$_} eq "") {
1873 print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n";
1875 print OUT " "x4, quotify("perl", $_), " =>\n";
1876 $recurse->(8, $unified_info{$_});
1888 print "CC =$config{cross_compile_prefix}$target{cc}\n";
1889 print "CFLAG =$target{cflags} $config{cflags}\n";
1890 print "SHARED_CFLAG =$target{shared_cflag}\n";
1891 print "DEFINES =",join(" ", @{$target{defines}}, @{$config{defines}}),"\n";
1892 print "LFLAG =$target{lflags}\n";
1893 print "PLIB_LFLAG =$target{plib_lflags}\n";
1894 print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
1895 print "APPS_OBJ =$target{apps_obj}\n";
1896 print "CPUID_OBJ =$target{cpuid_obj}\n";
1897 print "UPLINK_OBJ =$target{uplink_obj}\n";
1898 print "BN_ASM =$target{bn_obj}\n";
1899 print "EC_ASM =$target{ec_obj}\n";
1900 print "DES_ENC =$target{des_obj}\n";
1901 print "AES_ENC =$target{aes_obj}\n";
1902 print "BF_ENC =$target{bf_obj}\n";
1903 print "CAST_ENC =$target{cast_obj}\n";
1904 print "RC4_ENC =$target{rc4_obj}\n";
1905 print "RC5_ENC =$target{rc5_obj}\n";
1906 print "MD5_OBJ_ASM =$target{md5_obj}\n";
1907 print "SHA1_OBJ_ASM =$target{sha1_obj}\n";
1908 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1909 print "CMLL_ENC =$target{cmll_obj}\n";
1910 print "MODES_OBJ =$target{modes_obj}\n";
1911 print "PADLOCK_OBJ =$target{padlock_obj}\n";
1912 print "CHACHA_ENC =$target{chacha_obj}\n";
1913 print "POLY1305_OBJ =$target{poly1305_obj}\n";
1914 print "BLAKE2_OBJ =$target{blake2_obj}\n";
1915 print "PROCESSOR =$config{processor}\n";
1916 print "RANLIB =", $target{ranlib} eq '$(CROSS_COMPILE)ranlib' ?
1917 "$config{cross_compile_prefix}ranlib" :
1918 "$target{ranlib}", "\n";
1919 print "ARFLAGS =$target{arflags}\n";
1920 print "PERL =$config{perl}\n";
1922 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l};
1923 print "SIXTY_FOUR_BIT mode\n" if $config{b64};
1924 print "THIRTY_TWO_BIT mode\n" if $config{b32};
1925 print "BN_LLONG mode\n" if $config{bn_ll};
1926 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} ne $def_int;
1930 run_dofile(catfile($blddir, $target{build_file}),
1931 $config{build_file_template},
1932 catfile($srcdir, "Configurations", "common.tmpl"));
1936 $builders{$builder}->($builder_platform, @builder_opts);
1940 Configured for $target.
1943 print <<"EOF" if ($disabled{threads} eq "unavailable");
1945 The library could not be configured for supporting multi-threaded
1946 applications as the compiler options required on this system are not known.
1947 See file INSTALL for details if you need multi-threading.
1950 print <<"EOF" if ($no_shared_warn);
1952 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
1953 platform, so we will pretend you gave the option 'no-pic', which also disables
1954 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
1955 or position independent code, please let us know (but please first make sure
1956 you have tried with a current version of OpenSSL).
1959 print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
1961 WARNING: there are indications that another build was made in the source
1962 directory. This build may have picked up artifacts from that build, the
1963 safest course of action is to clean the source directory and redo this
1969 ######################################################################
1971 # Helpers and utility functions
1974 # Configuration file reading #########################################
1976 # Note: All of the helper functions are for lazy evaluation. They all
1977 # return a CODE ref, which will return the intended value when evaluated.
1978 # Thus, whenever there's mention of a returned value, it's about that
1981 # Helper function to implement conditional inheritance depending on the
1982 # value of $disabled{asm}. Used in inherit_from values as follows:
1984 # inherit_from => [ "template", asm("asm_tmpl") ]
1989 $disabled{asm} ? () : @x;
1993 # Helper function to implement conditional value variants, with a default
1994 # plus additional values based on the value of $config{build_type}.
1995 # Arguments are given in hash table form:
1997 # picker(default => "Basic string: ",
1999 # release => "release")
2001 # When configuring with --debug, the resulting string will be
2002 # "Basic string: debug", and when not, it will be "Basic string: release"
2004 # This can be used to create variants of sets of flags according to the
2007 # cflags => picker(default => "-Wall",
2008 # debug => "-g -O0",
2013 return sub { add($opts{default} || (),
2014 $opts{$config{build_type}} || ())->(); }
2017 # Helper function to combine several values of different types into one.
2018 # This is useful if you want to combine a string with the result of a
2019 # lazy function, such as:
2021 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2025 return sub { add(@stuff)->(); }
2028 # Helper function to implement conditional values depending on the value
2029 # of $disabled{threads}. Can be used as follows:
2031 # cflags => combine("-Wall", threads("-pthread"))
2035 return sub { add($disabled{threads} ? () : @flags)->(); }
2040 our $add_called = 0;
2041 # Helper function to implement adding values to already existing configuration
2042 # values. It handles elements that are ARRAYs, CODEs and scalars
2044 my $separator = shift;
2046 # If there's any ARRAY in the collection of values OR the separator
2047 # is undef, we will return an ARRAY of combined values, otherwise a
2048 # string of joined values with $separator as the separator.
2049 my $found_array = !defined($separator);
2054 while (ref($res) eq "CODE") {
2057 if (defined($res)) {
2058 if (ref($res) eq "ARRAY") {
2074 join($separator, grep { defined($_) && $_ ne "" } @values);
2078 my $separator = " ";
2079 if (ref($_[$#_]) eq "HASH") {
2081 $separator = $opts->{separator};
2084 sub { _add($separator, @x, @_) };
2087 my $separator = " ";
2088 if (ref($_[$#_]) eq "HASH") {
2090 $separator = $opts->{separator};
2093 sub { _add($separator, @_, @x) };
2096 # configuration reader, evaluates the input file as a perl script and expects
2097 # it to fill %targets with target configurations. Those are then added to
2101 open(CONFFILE, "< $fname")
2102 or die "Can't open configuration file '$fname'!\n";
2105 my $content = <CONFFILE>;
2110 local %table = %::table; # Protect %table from tampering
2116 # For each target, check that it's configured with a hash table.
2117 foreach (keys %targets) {
2118 if (ref($targets{$_}) ne "HASH") {
2119 if (ref($targets{$_}) eq "") {
2120 warn "Deprecated target configuration for $_, ignoring...\n";
2122 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2124 delete $targets{$_};
2128 %table = (%table, %targets);
2132 # configuration resolver. Will only resolve all the lazy evaluation
2133 # codeblocks for the chosen target and all those it inherits from,
2135 sub resolve_config {
2137 my @breadcrumbs = @_;
2139 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2141 if (grep { $_ eq $target } @breadcrumbs) {
2142 die "inherit_from loop! target backtrace:\n "
2143 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2146 if (!defined($table{$target})) {
2147 warn "Warning! target $target doesn't exist!\n";
2150 # Recurse through all inheritances. They will be resolved on the
2151 # fly, so when this operation is done, they will all just be a
2152 # bunch of attributes with string values.
2153 # What we get here, though, are keys with references to lists of
2154 # the combined values of them all. We will deal with lists after
2155 # this stage is done.
2156 my %combined_inheritance = ();
2157 if ($table{$target}->{inherit_from}) {
2159 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2160 foreach (@inherit_from) {
2161 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2163 # 'template' is a marker that's considered private to
2164 # the config that had it.
2165 delete $inherited_config{template};
2167 foreach (keys %inherited_config) {
2168 if (!$combined_inheritance{$_}) {
2169 $combined_inheritance{$_} = [];
2171 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2176 # We won't need inherit_from in this target any more, since we've
2177 # resolved all the inheritances that lead to this
2178 delete $table{$target}->{inherit_from};
2180 # Now is the time to deal with those lists. Here's the place to
2181 # decide what shall be done with those lists, all based on the
2182 # values of the target we're currently dealing with.
2183 # - If a value is a coderef, it will be executed with the list of
2184 # inherited values as arguments.
2185 # - If the corresponding key doesn't have a value at all or is the
2186 # empty string, the inherited value list will be run through the
2187 # default combiner (below), and the result becomes this target's
2189 # - Otherwise, this target's value is assumed to be a string that
2190 # will simply override the inherited list of values.
2191 my $default_combiner = add();
2194 map { $_ => 1 } (keys %combined_inheritance,
2195 keys %{$table{$target}});
2197 sub process_values {
2199 my $inherited = shift; # Always a [ list ]
2205 while(ref($object) eq "CODE") {
2206 $object = $object->(@$inherited);
2208 if (!defined($object)) {
2211 elsif (ref($object) eq "ARRAY") {
2212 local $add_called; # To make sure recursive calls don't affect it
2213 return [ map { process_values($_, $inherited, $target, $entry) }
2215 } elsif (ref($object) eq "") {
2218 die "cannot handle reference type ",ref($object)
2219 ," found in target ",$target," -> ",$entry,"\n";
2223 foreach (sort keys %all_keys) {
2224 my $previous = $combined_inheritance{$_};
2226 # Current target doesn't have a value for the current key?
2227 # Assign it the default combiner, the rest of this loop body
2228 # will handle it just like any other coderef.
2229 if (!exists $table{$target}->{$_}) {
2230 $table{$target}->{$_} = $default_combiner;
2233 $table{$target}->{$_} = process_values($table{$target}->{$_},
2234 $combined_inheritance{$_},
2236 unless(defined($table{$target}->{$_})) {
2237 delete $table{$target}->{$_};
2239 # if ($extra_checks &&
2240 # $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2241 # warn "$_ got replaced in $target\n";
2245 # Finally done, return the result.
2246 return %{$table{$target}};
2251 print STDERR $usage;
2252 print STDERR "\npick os/compiler from:\n";
2256 foreach $i (sort keys %table)
2258 next if $table{$i}->{template};
2259 next if $i =~ /^debug/;
2260 $k += length($i) + 1;
2266 print STDERR $i . " ";
2268 foreach $i (sort keys %table)
2270 next if $table{$i}->{template};
2271 next if $i !~ /^debug/;
2272 $k += length($i) + 1;
2278 print STDERR $i . " ";
2280 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2289 unlink $out || warn "Can't remove $out, $!"
2291 foreach (@templates) {
2292 die "Can't open $_, $!" unless -f $_;
2294 my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2295 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2298 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2305 if (eval { require IPC::Cmd; 1; }) {
2307 return scalar IPC::Cmd::can_run($name);
2309 # if there is $directories component in splitpath,
2310 # then it's not something to test with $PATH...
2311 return $name if (File::Spec->splitpath($name))[1];
2313 foreach (File::Spec->path()) {
2314 my $fullpath = catfile($_, "$name$target{exe_extension}");
2315 if (-f $fullpath and -x $fullpath) {
2322 # Configuration printer ##############################################
2324 sub print_table_entry
2327 my %target = resolve_config($target);
2330 # Don't print the templates
2331 return if $target{template};
2368 "shared_extension_simple",
2369 "shared_import_extension",
2380 if ($type eq "TABLE") {
2382 print "*** $target\n";
2383 foreach (@sequence) {
2384 if (ref($target{$_}) eq "ARRAY") {
2385 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
2387 printf "\$%-12s = %s\n", $_, $target{$_};
2390 } elsif ($type eq "HASH") {
2392 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2393 print " '$target' => {\n";
2394 foreach (@sequence) {
2396 if (ref($target{$_}) eq "ARRAY") {
2397 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
2399 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
2407 # Utility routines ###################################################
2409 # On VMS, if the given file is a logical name, File::Spec::Functions
2410 # will consider it an absolute path. There are cases when we want a
2411 # purely syntactic check without checking the environment.
2415 # On non-platforms, we just use file_name_is_absolute().
2416 return file_name_is_absolute($file) unless $^O eq "VMS";
2418 # If the file spec includes a device or a directpry spec,
2419 # file_name_is_absolute() is perfectly safe.
2420 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
2422 # Here, we know the given file spec isn't absolute
2426 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2427 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2428 # realpath() requires that at least all path components except the last is an
2429 # existing directory. On VMS, the last component of the directory spec must
2434 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2435 # will return the volume name for the device, no matter what. Also,
2436 # it will return an incorrect directory spec if the argument is a
2437 # directory that doesn't exist.
2439 return rel2abs($dir);
2442 # We use realpath() on Unix, since no other will properly clean out
2444 use Cwd qw/realpath/;
2446 return realpath($dir);
2451 perl => sub { my $x = shift;
2452 $x =~ s/([\\\$\@"])/\\$1/g;
2453 return '"'.$x.'"'; },
2457 defined($processors{$for}) ? $processors{$for} : sub { shift; };
2459 return map { $processor->($_); } @_;
2462 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2463 # $filename is a file name to read from
2464 # $line_concat_cond_re is a regexp detecting a line continuation ending
2465 # $line_concat is a CODEref that takes care of concatenating two lines
2466 sub collect_from_file {
2467 my $filename = shift;
2468 my $line_concat_cond_re = shift;
2469 my $line_concat = shift;
2471 open my $fh, $filename || die "unable to read $filename: $!\n";
2473 my $saved_line = "";
2477 if (defined $line_concat) {
2478 $_ = $line_concat->($saved_line, $_);
2481 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2487 die "$filename ending with continuation line\n" if $_;
2493 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2494 # $array is an ARRAYref of lines
2495 # $line_concat_cond_re is a regexp detecting a line continuation ending
2496 # $line_concat is a CODEref that takes care of concatenating two lines
2497 sub collect_from_array {
2499 my $line_concat_cond_re = shift;
2500 my $line_concat = shift;
2501 my @array = (@$array);
2504 my $saved_line = "";
2506 while (defined($_ = shift @array)) {
2508 if (defined $line_concat) {
2509 $_ = $line_concat->($saved_line, $_);
2512 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2518 die "input text ending with continuation line\n" if $_;
2523 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2524 # $lineiterator is a CODEref that delivers one line at a time.
2525 # All following arguments are regex/CODEref pairs, where the regexp detects a
2526 # line and the CODEref does something with the result of the regexp.
2527 sub collect_information {
2528 my $lineiterator = shift;
2529 my %collectors = @_;
2531 while(defined($_ = $lineiterator->())) {
2534 if ($collectors{"BEFORE"}) {
2535 $collectors{"BEFORE"}->($_);
2537 foreach my $re (keys %collectors) {
2538 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
2539 $collectors{$re}->($lineiterator);
2543 if ($collectors{"OTHERWISE"}) {
2544 $collectors{"OTHERWISE"}->($lineiterator, $_)
2545 unless $found || !defined $collectors{"OTHERWISE"};
2547 if ($collectors{"AFTER"}) {
2548 $collectors{"AFTER"}->($_);
2554 # $line is a line of text to split up into tokens
2555 # returns a list of tokens
2557 # Tokens are divided by spaces. If the tokens include spaces, they
2558 # have to be quoted with single or double quotes. Double quotes
2559 # inside a double quoted token must be escaped. Escaping is done
2561 # Basically, the same quoting rules apply for " and ' as in any
2564 my $line = my $debug_line = shift;
2567 while ($line =~ s|^\s+||, $line ne "") {
2569 while ($line ne "" && $line !~ m|^\s|) {
2570 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2573 } elsif ($line =~ m/^'([^']*)'/) {
2576 } elsif ($line =~ m/^(\S+)/) {
2581 push @result, $token;
2584 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2585 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2586 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";