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 AES_[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",
351 foreach my $proto ((@tls, @dtls))
353 push(@disablables, $proto);
354 push(@disablables, "$proto-method");
357 my %deprecated_disablables = (
359 "buf-freelists" => undef,
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 (!exists $deprecated_disablables{$word}
558 && !grep { $word =~ /^${_}$/ } @disablables)
560 $unsupported_options{$_} = 1;
564 if (/^no-(.+)$/ || /^disable-(.+)$/)
566 foreach my $proto ((@tls, @dtls))
568 if ($1 eq "$proto-method")
570 $disabled{"$proto"} = "option($proto-method)";
576 foreach my $proto (@dtls)
578 $disabled{$proto} = "option(dtls)";
580 $disabled{"dtls"} = "option(dtls)";
584 # Last one of its kind
585 $disabled{"ssl3"} = "option(ssl)";
589 # XXX: Tests will fail if all SSL/TLS
590 # protocols are disabled.
591 foreach my $proto (@tls)
593 $disabled{$proto} = "option(tls)";
596 elsif ($1 eq "static-engine")
598 delete $disabled{"dynamic-engine"};
600 elsif ($1 eq "dynamic-engine")
602 $disabled{"dynamic-engine"} = "option";
604 elsif (exists $deprecated_disablables{$1})
606 $deprecated_options{$_} = 1;
607 if (defined $deprecated_disablables{$1})
609 $disabled{$deprecated_disablables{$1}} = "option";
614 $disabled{$1} = "option";
616 # No longer an automatic choice
617 $auto_threads = 0 if ($1 eq "threads");
619 elsif (/^enable-(.+)$/)
621 if ($1 eq "static-engine")
623 $disabled{"dynamic-engine"} = "option";
625 elsif ($1 eq "dynamic-engine")
627 delete $disabled{"dynamic-engine"};
629 elsif ($1 eq "zlib-dynamic")
631 delete $disabled{"zlib"};
634 delete $disabled{$algo};
636 # No longer an automatic choice
637 $auto_threads = 0 if ($1 eq "threads");
639 elsif (/^--strict-warnings$/)
641 $strict_warnings = 1;
645 $config{build_type
} = "debug";
647 elsif (/^--release$/)
649 $config{build_type
} = "release";
652 { $config{processor
}=386; }
659 # No RSAref support any more since it's not needed.
660 # The check for the option is there so scripts aren't
663 elsif (/^nofipscanistercheck$/)
666 $nofipscanistercheck = 1;
670 if (/^--prefix=(.*)$/)
673 die "Directory given with --prefix MUST be absolute\n"
674 unless file_name_is_absolute
($config{prefix
});
676 elsif (/^--api=(.*)$/)
680 elsif (/^--libdir=(.*)$/)
684 elsif (/^--openssldir=(.*)$/)
686 $config{openssldir
}=$1;
688 elsif (/^--with-zlib-lib=(.*)$/)
690 $withargs{zlib_lib
}=$1;
692 elsif (/^--with-zlib-include=(.*)$/)
694 $withargs{zlib_include
}=$1;
696 elsif (/^--with-fuzzer-lib=(.*)$/)
698 $withargs{fuzzer_lib
}=$1;
700 elsif (/^--with-fuzzer-include=(.*)$/)
702 $withargs{fuzzer_include
}=$1;
704 elsif (/^--with-fipslibdir=(.*)$/)
706 $config{fipslibdir
}="$1/";
708 elsif (/^--with-baseaddr=(.*)$/)
710 $config{baseaddr
}="$1";
712 elsif (/^--cross-compile-prefix=(.*)$/)
714 $config{cross_compile_prefix
}=$1;
716 elsif (/^--config=(.*)$/)
720 elsif (/^-[lL](.*)$/ or /^-Wl,/)
726 push @user_defines, $1;
728 else # common if (/^[-+]/), just pass down...
730 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
731 $user_cflags.=" ".$_;
736 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
739 unless ($_ eq $target || /^no-/ || /^disable-/)
741 # "no-..." follows later after implied disactivations
742 # have been derived. (Don't take this too seriously,
743 # we really only write OPTIONS to the Makefile out of
746 if ($config{options
} eq "")
747 { $config{options
} = $_; }
749 { $config{options
} .= " ".$_; }
752 if (defined($config{api
}) && !exists $apitable->{$config{api
}}) {
753 die "***** Unsupported api compatibility level: $config{api}\n",
756 if (keys %deprecated_options)
758 warn "***** Deprecated options: ",
759 join(", ", keys %deprecated_options), "\n";
761 if (keys %unsupported_options)
763 die "***** Unsupported options: ",
764 join(", ", keys %unsupported_options), "\n";
770 delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/);
774 @
{$config{dirs
}} = grep !/^fips$/, @
{$config{dirs
}};
777 my @tocheckfor = (keys %disabled);
778 while (@tocheckfor) {
779 my %new_tocheckfor = ();
780 my @cascade_copy = (@disable_cascades);
781 while (@cascade_copy) {
782 my ($test, $descendents) = (shift @cascade_copy, shift @cascade_copy);
783 if (ref($test) eq "CODE" ?
$test->() : defined($disabled{$test})) {
784 foreach(grep { !defined($disabled{$_}) } @
$descendents) {
785 $new_tocheckfor{$_} = 1; $disabled{$_} = "forced";
789 @tocheckfor = (keys %new_tocheckfor);
792 if ($target eq "TABLE") {
793 foreach (sort keys %table) {
794 print_table_entry
($_, "TABLE");
799 if ($target eq "LIST") {
800 foreach (sort keys %table) {
801 print $_,"\n" unless $table{$_}->{template
};
806 if ($target eq "HASH") {
807 print "%table = (\n";
808 foreach (sort keys %table) {
809 print_table_entry
($_, "HASH");
814 # Backward compatibility?
815 if ($target =~ m/^CygWin32(-.*)$/) {
816 $target = "Cygwin".$1;
819 foreach (sort (keys %disabled))
821 $config{options
} .= " no-$_";
823 printf " no-%-12s %-10s", $_, "[$disabled{$_}]";
835 elsif (/^dynamic-engine$/)
837 elsif (/^makedepend$/)
839 elsif (/^zlib-dynamic$/)
845 @
{$config{dirs
}} = grep !/^engines$/, @
{$config{dirs
}};
846 @
{$config{sdirs
}} = grep !/^engine$/, @
{$config{sdirs
}};
847 push @
{$config{openssl_other_defines
}}, "OPENSSL_NO_ENGINE";
852 ($ALGO = $algo = $_) =~ tr/[\-a-z]/[_A-Z]/;
854 if (/^asm$/ || /^err$/ || /^hw$/ || /^hw-/ || /^async$/
855 || /^autoalginit/ || /^autoerrinit/)
857 push @
{$config{openssl_other_defines
}}, "OPENSSL_NO_$ALGO";
858 print " OPENSSL_NO_$ALGO";
860 if (/^err$/) { push @user_defines, "OPENSSL_NO_ERR"; }
864 ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd");
866 push @
{$config{openssl_algorithm_defines
}}, "OPENSSL_NO_$ALGO";
867 print " OPENSSL_NO_$ALGO";
869 # fix-up crypto/directory name(s)
870 $algo="whrlpool" if $algo eq "whirlpool";
871 $algo="ripemd" if $algo eq "rmd160";
872 @
{$config{sdirs
}} = grep { $_ ne $algo} @
{$config{sdirs
}};
881 print "Configuring for $target\n";
883 # Support for legacy targets having a name starting with 'debug-'
884 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
886 $config{build_type
} = "debug";
888 # If we do not find debug-foo in the table, the target is set to foo.
889 if (!$table{$target}) {
893 $config{target
} = $target;
894 my %target = resolve_config
($target);
896 &usage
if (!%target || $target{template
});
898 %target = ( %{$table{DEFAULTS
}}, %target );
900 $target{exe_extension
}="";
901 $target{exe_extension
}=".exe" if ($config{target
} eq "DJGPP"
902 || $config{target
} =~ /^(?:Cygwin|mingw)/);
903 $target{exe_extension
}=".pm" if ($config{target
} =~ /vos/);
905 ($target{shared_extension_simple
}=$target{shared_extension
})
906 =~ s
|\
.\
$\
(SHLIB_MAJOR\
)\
.\
$\
(SHLIB_MINOR\
)||;
907 $target{dso_extension
}=$target{shared_extension_simple
};
908 ($target{shared_import_extension
}=$target{shared_extension_simple
}.".a")
909 if ($config{target
} =~ /^(?:Cygwin|mingw)/);
912 $config{cross_compile_prefix
} = $ENV{'CROSS_COMPILE'}
913 if $config{cross_compile_prefix
} eq "";
915 # Allow overriding the names of some tools. USE WITH CARE
916 $config{perl
} = $ENV{'PERL'} || ($^O
ne "VMS" ?
$^X
: "perl");
917 $target{cc
} = $ENV{'CC'} || $target{cc
} || "cc";
918 $target{ranlib
} = $ENV{'RANLIB'} || $target{ranlib
} ||
919 (which
("$config{cross_compile_prefix}ranlib") ?
920 "\$(CROSS_COMPILE)ranlib" : "true");
921 $target{ar
} = $ENV{'AR'} || $target{ar
} || "ar";
922 $target{nm
} = $ENV{'NM'} || $target{nm
} || "nm";
924 $ENV{'RC'} || $ENV{'WINDRES'} || $target{rc
} || "windres";
926 # For cflags, lflags, plib_lflags, ex_libs and defines, add the debug_
927 # or release_ attributes.
928 # Do it in such a way that no spurious space is appended (hence the grep).
929 $config{defines
} = [];
930 $config{cflags
} = "";
931 $config{ex_libs
} = "";
932 $config{shared_ldflag
} = "";
934 # Make sure build_scheme is consistent.
935 $target{build_scheme
} = [ $target{build_scheme
} ]
936 if ref($target{build_scheme
}) ne "ARRAY";
938 my ($builder, $builder_platform, @builder_opts) =
939 @
{$target{build_scheme
}};
941 push @
{$config{defines
}}, "NDEBUG" if $config{build_type
} eq "release";
943 if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` =~ m/-mno-cygwin/m)
945 $config{cflags
} .= " -mno-cygwin";
946 $config{shared_ldflag
} .= " -mno-cygwin";
949 if ($target =~ /linux.*-mips/ && !$disabled{asm
} && $user_cflags !~ /-m(ips|arch=)/) {
950 # minimally required architecture flags for assembly modules
951 $config{cflags
}="-mips2 $config{cflags}" if ($target =~ /mips32/);
952 $config{cflags
}="-mips3 $config{cflags}" if ($target =~ /mips64/);
955 my $no_shared_warn=0;
956 my $no_user_cflags=0;
957 my $no_user_defines=0;
959 # The DSO code currently always implements all functions so that no
960 # applications will have to worry about that from a compilation point
961 # of view. However, the "method"s may return zero unless that platform
962 # has support compiled in for them. Currently each method is enabled
963 # by a define "DSO_<name>" ... we translate the "dso_scheme" config
964 # string entry into using the following logic;
965 if (!$disabled{dso
} && $target{dso_scheme
} ne "")
967 $target{dso_scheme
} =~ tr/[a-z]/[A-Z]/;
968 if ($target{dso_scheme
} eq "DLFCN")
970 unshift @
{$config{defines
}}, "DSO_DLFCN", "HAVE_DLFCN_H";
972 elsif ($target{dso_scheme
} eq "DLFCN_NO_H")
974 unshift @
{$config{defines
}}, "DSO_DLFCN";
978 unshift @
{$config{defines
}}, "DSO_$target{dso_scheme}";
982 $config{ex_libs
}="$libs$config{ex_libs}" if ($libs ne "");
988 @
{$config{defines
}} = grep !/^[BL]_ENDIAN$/, @
{$config{defines
}};
989 @
{$target{defines
}} = grep !/^[BL]_ENDIAN$/, @
{$target{defines
}};
993 # If threads aren't disabled, check how possible they are
994 unless ($disabled{threads
}) {
996 # Enabled by default, disable it forcibly if unavailable
997 if ($target{thread_scheme
} eq "(unknown)") {
998 $disabled{threads
} = "unavailable";
1001 # The user chose to enable threads explicitly, let's see
1002 # if there's a chance that's possible
1003 if ($target{thread_scheme
} eq "(unknown)") {
1004 # If the user asked for "threads" and we don't have internal
1005 # knowledge how to do it, [s]he is expected to provide any
1006 # system-dependent compiler options that are necessary. We
1007 # can't truly check that the given options are correct, but
1008 # we expect the user to know what [s]He is doing.
1009 if ($no_user_cflags && $no_user_defines) {
1010 die "You asked for multi-threading support, but didn't\n"
1011 ,"provide any system-specific compiler options\n";
1017 # If threads still aren't disabled, add a C macro to ensure the source
1018 # code knows about it. Any other flag is taken care of by the configs.
1019 unless($disabled{threads
}) {
1020 foreach (("defines", "openssl_thread_defines")) {
1021 push @
{$config{$_}}, "OPENSSL_THREADS";
1025 # With "deprecated" disable all deprecated features.
1026 if (defined($disabled{"deprecated"})) {
1027 $config{api
} = $maxapi;
1030 if ($target{shared_target
} eq "")
1033 if ((!$disabled{shared
} || !$disabled{"dynamic-engine"})
1035 $disabled{shared
} = "no-shared-target";
1036 $disabled{pic
} = $disabled{shared
} = $disabled{"dynamic-engine"} =
1040 if ($disabled{"dynamic-engine"}) {
1041 push @
{$config{defines
}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1042 $config{dynamic_engines
} = 0;
1044 push @
{$config{defines
}}, "OPENSSL_NO_STATIC_ENGINE";
1045 $config{dynamic_engines
} = 1;
1048 unless ($disabled{"fuzz-libfuzzer"}) {
1049 push @
{$config{dirs
}}, "fuzz";
1050 $config{cflags
} .= "-fsanitize-coverage=edge,indirect-calls ";
1053 unless ($disabled{"fuzz-afl"}) {
1054 push @
{$config{dirs
}}, "fuzz";
1057 unless ($disabled{asan
}) {
1058 $config{cflags
} .= "-fsanitize=address ";
1061 unless ($disabled{ubsan
}) {
1062 # -DPEDANTIC or -fnosanitize=aligmnent may also be required on some
1064 $config{cflags
} .= "-fsanitize=undefined -fno-sanitize-recover=all ";
1067 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1068 && $disabled{asan
} && $disabled{ubsan
}) {
1069 $config{cflags
} .= "-fno-omit-frame-pointer -g ";
1075 # This saves the build files from having to check
1078 $target{shared_cflag
} = $target{shared_ldflag
} =
1079 $target{shared_rcflag
} = "";
1083 push @
{$config{defines
}}, "OPENSSL_PIC";
1086 if ($target{sys_id
} ne "")
1088 push @
{$config{openssl_sys_defines
}}, "OPENSSL_SYS_$target{sys_id}";
1091 unless ($disabled{asm
}) {
1092 $target{cpuid_asm_src
}=$table{DEFAULTS
}->{cpuid_asm_src
} if ($config{processor
} eq "386");
1093 $target{bn_asm_src
} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m
}));
1095 # bn-586 is the only one implementing bn_*_part_words
1096 push @
{$config{defines
}}, "OPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src
} =~ /bn-586/);
1097 push @
{$config{defines
}}, "OPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src
} =~ /86/);
1099 push @
{$config{defines
}}, "OPENSSL_BN_ASM_MONT" if ($target{bn_asm_src
} =~ /-mont/);
1100 push @
{$config{defines
}}, "OPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src
} =~ /-mont5/);
1101 push @
{$config{defines
}}, "OPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src
} =~ /-gf2m/);
1103 if ($config{fips
}) {
1104 push @
{$config{openssl_other_defines
}}, "OPENSSL_FIPS";
1107 if ($target{sha1_asm_src
}) {
1108 push @
{$config{defines
}}, "SHA1_ASM" if ($target{sha1_asm_src
} =~ /sx86/ || $target{sha1_asm_src
} =~ /sha1/);
1109 push @
{$config{defines
}}, "SHA256_ASM" if ($target{sha1_asm_src
} =~ /sha256/);
1110 push @
{$config{defines
}}, "SHA512_ASM" if ($target{sha1_asm_src
} =~ /sha512/);
1112 if ($target{md5_asm_src
}) {
1113 push @
{$config{defines
}}, "MD5_ASM";
1115 $target{cast_asm_src
}=$table{DEFAULTS
}->{cast_asm_src
} unless $disabled{pic
}; # CAST assembler is not PIC
1116 if ($target{rmd160_asm_src
}) {
1117 push @
{$config{defines
}}, "RMD160_ASM";
1119 if ($target{aes_asm_src
}) {
1120 push @
{$config{defines
}}, "AES_ASM" if ($target{aes_asm_src
} =~ m/\baes-/);;
1121 # aes-ctr.fake is not a real file, only indication that assembler
1122 # module implements AES_ctr32_encrypt...
1123 push @
{$config{defines
}}, "AES_CTR_ASM" if ($target{aes_asm_src
} =~ s/\s*aes-ctr\.fake//);
1124 # aes-xts.fake indicates presence of AES_xts_[en|de]crypt...
1125 push @
{$config{defines
}}, "AES_XTS_ASM" if ($target{aes_asm_src
} =~ s/\s*aes-xts\.fake//);
1126 $target{aes_asm_src
} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2);
1127 push @
{$config{defines
}}, "VPAES_ASM" if ($target{aes_asm_src
} =~ m/vpaes/);
1128 push @
{$config{defines
}}, "BSAES_ASM" if ($target{aes_asm_src
} =~ m/bsaes/);
1130 if ($target{wp_asm_src
} =~ /mmx/) {
1131 if ($config{processor
} eq "386") {
1132 $target{wp_asm_src
}=$table{DEFAULTS
}->{wp_asm_src
};
1133 } elsif (!$disabled{"whirlpool"}) {
1134 push @
{$config{defines
}}, "WHIRLPOOL_ASM";
1137 if ($target{modes_asm_src
} =~ /ghash-/) {
1138 push @
{$config{defines
}}, "GHASH_ASM";
1140 if ($target{ec_asm_src
} =~ /ecp_nistz256/) {
1141 push @
{$config{defines
}}, "ECP_NISTZ256_ASM";
1143 if ($target{poly1305_asm_src
} ne "") {
1144 push @
{$config{defines
}}, "POLY1305_ASM";
1148 my $ecc = $target{cc
};
1149 if ($^O
ne "VMS" && !$disabled{makedepend
}) {
1150 # Is the compiler gcc or clang? $ecc is used below to see if
1151 # error-checking can be turned on.
1152 my $ccpcc = "$config{cross_compile_prefix}$target{cc}";
1153 open(PIPE
, "$ccpcc --version 2>&1 |");
1156 # Find the version number and save the major.
1157 m
|(?
:.*)\b(\d
+)\
.\d
+\
.\d
+\b(?
:.*)|;
1158 my $compiler_major = $1;
1159 # We know that GNU C version 3 and up as well as all clang
1160 # versions support dependency generation
1161 $config{makedepprog
} = $ccpcc
1162 if (/clang/ || (/gcc/ && $compiler_major > 3));
1163 $ecc = "clang" if /clang/;
1164 $ecc = "gcc" if /gcc/;
1165 last if ($config{makedepprog
} || !$lines--);
1169 $config{makedepprog
} = which
('makedepend') unless $config{makedepprog
};
1170 $disabled{makedepend
} = "unavailable" unless $config{makedepprog
};
1175 # Deal with bn_ops ###################################################
1178 $config{export_var_as_fn
} =0;
1179 my $def_int="unsigned int";
1180 $config{rc4_int
} =$def_int;
1181 ($config{b64l
},$config{b64
},$config{b32
})=(0,0,1);
1184 foreach (sort split(/\s+/,$target{bn_ops
})) {
1185 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1186 $config{export_var_as_fn
}=1 if $_ eq 'EXPORT_VAR_AS_FN';
1187 $config{bn_ll
}=1 if $_ eq 'BN_LLONG';
1188 $config{rc4_int
}="unsigned char" if $_ eq 'RC4_CHAR';
1189 ($config{b64l
},$config{b64
},$config{b32
})
1190 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1191 ($config{b64l
},$config{b64
},$config{b32
})
1192 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1193 ($config{b64l
},$config{b64
},$config{b32
})
1194 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1196 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1200 # Hack cflags for better warnings (dev option) #######################
1202 # "Stringify" the C flags string. This permits it to be made part of a string
1203 # and works as well on command lines.
1204 $config{cflags
} =~ s/([\\\"])/\\$1/g;
1206 if (defined($config{api
})) {
1207 $config{openssl_api_defines
} = [ "OPENSSL_MIN_API=".$apitable->{$config{api
}} ];
1208 my $apiflag = sprintf("OPENSSL_API_COMPAT=%s", $apitable->{$config{api
}});
1209 push @
{$config{defines
}}, $apiflag;
1212 if ($strict_warnings)
1215 die "ERROR --strict-warnings requires gcc or clang"
1216 unless $ecc eq 'gcc' || $ecc eq 'clang';
1217 foreach $wopt (split /\s+/, $gcc_devteam_warn)
1219 $config{cflags
} .= " $wopt" unless ($config{cflags
} =~ /(?:^|\s)$wopt(?:\s|$)/)
1221 if ($ecc eq "clang")
1223 foreach $wopt (split /\s+/, $clang_devteam_warn)
1225 $config{cflags
} .= " $wopt" unless ($config{cflags
} =~ /(?:^|\s)$wopt(?:\s|$)/)
1230 unless ($disabled{"crypto-mdebug-backtrace"})
1232 foreach my $wopt (split /\s+/, $memleak_devteam_backtrace)
1234 $config{cflags
} .= " $wopt" unless ($config{cflags
} =~ /(?:^|\s)$wopt(?:\s|$)/)
1236 if ($target =~ /^BSD-/)
1238 $config{ex_libs
} .= " -lexecinfo";
1242 if ($user_cflags ne "") { $config{cflags
}="$config{cflags}$user_cflags"; }
1243 else { $no_user_cflags=1; }
1244 if (@user_defines) { $config{defines
}=[ @
{$config{defines
}}, @user_defines ]; }
1245 else { $no_user_defines=1; }
1247 # ALL MODIFICATIONS TO %config and %target MUST BE DONE FROM HERE ON
1249 unless ($disabled{afalgeng
}) {
1250 $config{afalgeng
}="";
1251 if ($target =~ m/^linux/) {
1252 my $minver = 4*10000 + 1*100 + 0;
1253 if ($config{cross_compile_prefix
} eq "") {
1254 my $verstr = `uname -r`;
1255 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1256 ($mi2) = $mi2 =~ /(\d+)/;
1257 my $ver = $ma*10000 + $mi1*100 + $mi2;
1258 if ($ver < $minver) {
1259 $disabled{afalgeng
} = "too-old-kernel";
1261 push @
{$config{engdirs
}}, "afalg";
1264 $disabled{afalgeng
} = "cross-compiling";
1267 $disabled{afalgeng
} = "not-linux";
1271 push @
{$config{openssl_other_defines
}}, "OPENSSL_NO_AFALGENG" if ($disabled{afalgeng
});
1273 # If we use the unified build, collect information from build.info files
1274 my %unified_info = ();
1276 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO
});
1277 if ($builder eq "unified") {
1278 # Store the name of the template file we will build the build file from
1279 # in %config. This may be useful for the build file itself.
1280 my $build_file_template;
1282 for my $filename (( $builder_platform."-".$target{build_file
}.".tmpl",
1283 $target{build_file
}.".tmpl" )) {
1284 if (defined $ENV{$local_config_envname}) {
1286 # VMS environment variables are logical names,
1287 # which can be used as is
1288 $build_file_template = $local_config_envname . ':' . $filename;
1290 $build_file_template = catfile
($ENV{$local_config_envname},
1295 last if -f
$build_file_template;
1297 $build_file_template = catfile
($srcdir, "Configurations", $filename);
1299 last if -f
$build_file_template;
1301 $config{build_file_template
} = $build_file_template;
1303 use lib catdir
(dirname
(__FILE__
),"util");
1304 use with_fallback
qw(Text::Template);
1309 my $relativeto = shift || ".";
1311 $dir = catdir
($base,$dir) unless isabsolute
($dir);
1313 # Make sure the directories we're building in exists
1316 my $res = abs2rel
(absolutedir
($dir), rel2abs
($relativeto));
1317 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1324 my $relativeto = shift || ".";
1326 $file = catfile
($base,$file) unless isabsolute
($file);
1328 my $d = dirname
($file);
1329 my $f = basename
($file);
1331 # Make sure the directories we're building in exists
1334 my $res = abs2rel
(catfile
(absolutedir
($d), $f), rel2abs
($relativeto));
1335 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1339 my @build_infos = ( [ ".", "build.info" ] );
1340 foreach (@
{$config{dirs
}}) {
1341 push @build_infos, [ $_, "build.info" ]
1342 if (-f catfile
($srcdir, $_, "build.info"));
1344 foreach (@
{$config{sdirs
}}) {
1345 push @build_infos, [ catdir
("crypto", $_), "build.info" ]
1346 if (-f catfile
($srcdir, "crypto", $_, "build.info"));
1348 foreach (@
{$config{engdirs
}}) {
1349 push @build_infos, [ catdir
("engines", $_), "build.info" ]
1350 if (-f catfile
($srcdir, "engines", $_, "build.info"));
1353 $config{build_infos
} = [ ];
1355 foreach (@build_infos) {
1356 my $sourced = catdir
($srcdir, $_->[0]);
1357 my $buildd = catdir
($blddir, $_->[0]);
1362 # The basic things we're trying to build
1369 my @intermediates = ();
1374 my %shared_sources = ();
1378 my %sharednames = ();
1381 push @
{$config{build_infos
}}, catfile
(abs2rel
($sourced, $blddir), $f);
1382 my $template = Text
::Template
->new(TYPE
=> 'FILE',
1383 SOURCE
=> catfile
($sourced, $f));
1384 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1387 $template->fill_in(HASH
=> { config
=> \
%config,
1389 disabled
=> \
%disabled,
1390 withargs
=> \
%withargs,
1391 builddir
=> abs2rel
($buildd, $blddir),
1392 sourcedir
=> abs2rel
($sourced, $blddir),
1393 buildtop
=> abs2rel
($blddir, $blddir),
1394 sourcetop
=> abs2rel
($srcdir, $blddir) },
1395 DELIMITERS
=> [ "{-", "-}" ]);
1397 # The top item of this stack has the following values
1398 # -2 positive already run and we found ELSE (following ELSIF should fail)
1399 # -1 positive already run (skip until ENDIF)
1400 # 0 negatives so far (if we're at a condition, check it)
1401 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1402 # 2 positive ELSE (following ELSIF should fail)
1404 collect_information
(
1405 collect_from_array
([ @text ],
1406 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1407 $l1 =~ s/\\$//; $l1.$l2 }),
1408 # Info we're looking for
1409 qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/
1411 if (! @skip || $skip[$#skip] > 0) {
1417 qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/
1418 => sub { die "ELSIF out of scope" if ! @skip;
1419 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1420 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1421 $skip[$#skip] = !! $1
1422 if $skip[$#skip] == 0; },
1424 => sub { die "ELSE out of scope" if ! @skip;
1425 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1426 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1428 => sub { die "ENDIF out of scope" if ! @skip;
1430 qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/
1431 => sub { push @programs, tokenize
($1)
1432 if !@skip || $skip[$#skip] > 0 },
1433 qr/^\s*LIBS\s*=\s*(.*)\s*$/
1434 => sub { push @libraries, tokenize
($1)
1435 if !@skip || $skip[$#skip] > 0 },
1436 qr/^\s*ENGINES\s*=\s*(.*)\s*$/
1437 => sub { push @engines, tokenize
($1)
1438 if !@skip || $skip[$#skip] > 0 },
1439 qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/
1440 => sub { push @scripts, tokenize
($1)
1441 if !@skip || $skip[$#skip] > 0 },
1442 qr/^\s*EXTRA\s*=\s*(.*)\s*$/
1443 => sub { push @extra, tokenize
($1)
1444 if !@skip || $skip[$#skip] > 0 },
1445 qr/^\s*OVERRIDES\s*=\s*(.*)\s*$/
1446 => sub { push @overrides, tokenize
($1)
1447 if !@skip || $skip[$#skip] > 0 },
1449 qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/,
1450 => sub { push @
{$ordinals{$1}}, tokenize
($2)
1451 if !@skip || $skip[$#skip] > 0 },
1452 qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1453 => sub { push @
{$sources{$1}}, tokenize
($2)
1454 if !@skip || $skip[$#skip] > 0 },
1455 qr/^\s*SHARED_SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1456 => sub { push @
{$shared_sources{$1}}, tokenize
($2)
1457 if !@skip || $skip[$#skip] > 0 },
1458 qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1459 => sub { push @
{$includes{$1}}, tokenize
($2)
1460 if !@skip || $skip[$#skip] > 0 },
1461 qr/^\s*DEPEND\[((?:\\.|[^\\\]])*)\]\s*=\s*(.*)\s*$/
1462 => sub { push @
{$depends{$1}}, tokenize
($2)
1463 if !@skip || $skip[$#skip] > 0 },
1464 qr/^\s*GENERATE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1465 => sub { push @
{$generate{$1}}, $2
1466 if !@skip || $skip[$#skip] > 0 },
1467 qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1468 => sub { push @
{$renames{$1}}, tokenize
($2)
1469 if !@skip || $skip[$#skip] > 0 },
1470 qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/
1471 => sub { push @
{$sharednames{$1}}, tokenize
($2)
1472 if !@skip || $skip[$#skip] > 0 },
1473 qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/
1475 my $lineiterator = shift;
1476 my $target_kind = $1;
1477 while (defined $lineiterator->()) {
1479 if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) {
1480 die "ENDRAW doesn't match BEGINRAW"
1481 if $1 ne $target_kind;
1484 next if @skip && $skip[$#skip] <= 0;
1486 if ($target_kind eq $target{build_file
}
1487 || $target_kind eq $target{build_file
}."(".$builder_platform.")");
1490 qr/^(?:#.*|\s*)$/ => sub { },
1491 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
1493 if ($buildinfo_debug) {
1494 print STDERR
"DEBUG: Parsing ",join(" ", @_),"\n";
1495 print STDERR
"DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1499 if ($buildinfo_debug) {
1500 print STDERR
"DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
1504 die "runaway IF?" if (@skip);
1506 foreach (keys %renames) {
1507 die "$_ renamed to more than one thing: "
1508 ,join(" ", @
{$renames{$_}}),"\n"
1509 if scalar @
{$renames{$_}} > 1;
1510 my $dest = cleanfile
($buildd, $_, $blddir);
1511 my $to = cleanfile
($buildd, $renames{$_}->[0], $blddir);
1512 die "$dest renamed to more than one thing: "
1513 ,$unified_info{rename}->{$dest}, $to
1514 unless !defined($unified_info{rename}->{$dest})
1515 or $unified_info{rename}->{$dest} eq $to;
1516 $unified_info{rename}->{$dest} = $to;
1519 foreach (@programs) {
1520 my $program = cleanfile
($buildd, $_, $blddir);
1521 if ($unified_info{rename}->{$program}) {
1522 $program = $unified_info{rename}->{$program};
1524 $unified_info{programs
}->{$program} = 1;
1527 foreach (@libraries) {
1528 my $library = cleanfile
($buildd, $_, $blddir);
1529 if ($unified_info{rename}->{$library}) {
1530 $library = $unified_info{rename}->{$library};
1532 $unified_info{libraries
}->{$library} = 1;
1535 die <<"EOF" if scalar @engines and !$config{dynamic_engines};
1536 ENGINES can only be used if configured with 'dynamic-engine'.
1537 This is usually a fault in a build.info file.
1539 foreach (@engines) {
1540 my $library = cleanfile
($buildd, $_, $blddir);
1541 if ($unified_info{rename}->{$library}) {
1542 $library = $unified_info{rename}->{$library};
1544 $unified_info{engines
}->{$library} = 1;
1547 foreach (@scripts) {
1548 my $script = cleanfile
($buildd, $_, $blddir);
1549 if ($unified_info{rename}->{$script}) {
1550 $script = $unified_info{rename}->{$script};
1552 $unified_info{scripts
}->{$script} = 1;
1556 my $extra = cleanfile
($buildd, $_, $blddir);
1557 $unified_info{extra
}->{$extra} = 1;
1560 foreach (@overrides) {
1561 my $override = cleanfile
($buildd, $_, $blddir);
1562 $unified_info{overrides
}->{$override} = 1;
1565 push @
{$unified_info{rawlines
}}, @rawlines;
1567 unless ($disabled{shared
}) {
1568 # Check sharednames.
1569 foreach (keys %sharednames) {
1570 my $dest = cleanfile
($buildd, $_, $blddir);
1571 if ($unified_info{rename}->{$dest}) {
1572 $dest = $unified_info{rename}->{$dest};
1574 die "shared_name for $dest with multiple values: "
1575 ,join(" ", @
{$sharednames{$_}}),"\n"
1576 if scalar @
{$sharednames{$_}} > 1;
1577 my $to = cleanfile
($buildd, $sharednames{$_}->[0], $blddir);
1578 die "shared_name found for a library $dest that isn't defined\n"
1579 unless $unified_info{libraries
}->{$dest};
1580 die "shared_name for $dest with multiple values: "
1581 ,$unified_info{sharednames
}->{$dest}, ", ", $to
1582 unless !defined($unified_info{sharednames
}->{$dest})
1583 or $unified_info{sharednames
}->{$dest} eq $to;
1584 $unified_info{sharednames
}->{$dest} = $to;
1587 # Additionally, we set up sharednames for libraries that don't
1588 # have any, as themselves.
1589 foreach (keys %{$unified_info{libraries
}}) {
1590 if (!defined $unified_info{sharednames
}->{$_}) {
1591 $unified_info{sharednames
}->{$_} = $_
1596 foreach (keys %ordinals) {
1598 my $ddest = cleanfile
($buildd, $_, $blddir);
1599 if ($unified_info{rename}->{$ddest}) {
1600 $ddest = $unified_info{rename}->{$ddest};
1602 foreach (@
{$ordinals{$dest}}) {
1603 my %known_ordinals =
1606 cleanfile
($sourced, catfile
("util", "libcrypto.num"), $blddir),
1608 cleanfile
($sourced, catfile
("util", "libssl.num"), $blddir)
1610 my $o = $known_ordinals{$_};
1611 die "Ordinals for $ddest defined more than once\n"
1612 if $unified_info{ordinals
}->{$ddest};
1613 $unified_info{ordinals
}->{$ddest} = [ $_, $o ];
1617 foreach (keys %sources) {
1619 my $ddest = cleanfile
($buildd, $_, $blddir);
1620 if ($unified_info{rename}->{$ddest}) {
1621 $ddest = $unified_info{rename}->{$ddest};
1623 foreach (@
{$sources{$dest}}) {
1624 my $s = cleanfile
($sourced, $_, $blddir);
1626 # If it isn't in the source tree, we assume it's generated
1629 $s = cleanfile
($buildd, $_, $blddir);
1631 # We recognise C and asm files
1632 if ($s =~ /\.[csS]\b$/) {
1633 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1634 $o = cleanfile
($buildd, $o, $blddir);
1635 $unified_info{sources
}->{$ddest}->{$o} = 1;
1636 $unified_info{sources
}->{$o}->{$s} = 1;
1638 $unified_info{sources
}->{$ddest}->{$s} = 1;
1643 foreach (keys %shared_sources) {
1645 my $ddest = cleanfile
($buildd, $_, $blddir);
1646 if ($unified_info{rename}->{$ddest}) {
1647 $ddest = $unified_info{rename}->{$ddest};
1649 foreach (@
{$shared_sources{$dest}}) {
1650 my $s = cleanfile
($sourced, $_, $blddir);
1652 # If it isn't in the source tree, we assume it's generated
1655 $s = cleanfile
($buildd, $_, $blddir);
1657 # We recognise C and asm files
1658 if ($s =~ /\.[csS]\b$/) {
1659 (my $o = $_) =~ s/\.[csS]\b$/.o/;
1660 $o = cleanfile
($buildd, $o, $blddir);
1661 $unified_info{shared_sources
}->{$ddest}->{$o} = 1;
1662 $unified_info{sources
}->{$o}->{$s} = 1;
1664 die "unrecognised source file type for shared library: $s\n";
1669 foreach (keys %generate) {
1671 my $ddest = cleanfile
($buildd, $_, $blddir);
1672 if ($unified_info{rename}->{$ddest}) {
1673 $ddest = $unified_info{rename}->{$ddest};
1675 die "more than one generator for $dest: "
1676 ,join(" ", @
{$generate{$_}}),"\n"
1677 if scalar @
{$generate{$_}} > 1;
1678 my @generator = split /\s+/, $generate{$dest}->[0];
1679 $generator[0] = cleanfile
($sourced, $generator[0], $blddir),
1680 $unified_info{generate
}->{$ddest} = [ @generator ];
1683 foreach (keys %depends) {
1685 my $ddest = $dest eq "" ?
"" : cleanfile
($sourced, $_, $blddir);
1687 # If the destination doesn't exist in source, it can only be
1688 # a generated file in the build tree.
1689 if ($ddest ne "" && ! -f
$ddest) {
1690 $ddest = cleanfile
($buildd, $_, $blddir);
1691 if ($unified_info{rename}->{$ddest}) {
1692 $ddest = $unified_info{rename}->{$ddest};
1695 foreach (@
{$depends{$dest}}) {
1696 my $d = cleanfile
($sourced, $_, $blddir);
1698 # If we know it's generated, or assume it is because we can't
1699 # find it in the source tree, we set file we depend on to be
1700 # in the build tree rather than the source tree, and assume
1701 # and that there are lines to build it in a BEGINRAW..ENDRAW
1702 # section or in the Makefile template.
1704 || (grep { $d eq $_ }
1705 map { cleanfile
($srcdir, $_, $blddir) }
1706 grep { /\.h$/ } keys %{$unified_info{generate
}})) {
1707 $d = cleanfile
($buildd, $_, $blddir);
1709 # Take note if the file to depend on is being renamed
1710 if ($unified_info{rename}->{$d}) {
1711 $d = $unified_info{rename}->{$d};
1713 $unified_info{depends
}->{$ddest}->{$d} = 1;
1714 # If we depend on a header file or a perl module, let's make
1715 # sure it can get included
1716 if ($dest ne "" && $d =~ /\.(h|pm)$/) {
1717 my $i = dirname
($d);
1718 push @
{$unified_info{includes
}->{$ddest}}, $i
1719 unless grep { $_ eq $i } @
{$unified_info{includes
}->{$ddest}};
1724 foreach (keys %includes) {
1726 my $ddest = cleanfile
($sourced, $_, $blddir);
1728 # If the destination doesn't exist in source, it can only be
1729 # a generated file in the build tree.
1731 $ddest = cleanfile
($buildd, $_, $blddir);
1732 if ($unified_info{rename}->{$ddest}) {
1733 $ddest = $unified_info{rename}->{$ddest};
1736 foreach (@
{$includes{$dest}}) {
1737 my $i = cleandir
($sourced, $_, $blddir);
1738 push @
{$unified_info{includes
}->{$ddest}}, $i
1739 unless grep { $_ eq $i } @
{$unified_info{includes
}->{$ddest}};
1744 ### Make unified_info a bit more efficient
1745 # One level structures
1746 foreach (("programs", "libraries", "engines", "scripts", "extra", "overrides")) {
1747 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
1749 # Two level structures
1750 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends")) {
1751 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
1752 $unified_info{$l1}->{$l2} =
1753 [ sort keys %{$unified_info{$l1}->{$l2}} ];
1758 # For the schemes that need it, we provide the old *_obj configs
1759 # from the *_asm_obj ones
1760 foreach (grep /_(asm|aux)_src$/, keys %target) {
1762 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
1763 ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g;
1766 # Write down our configuration where it fits #########################
1768 open(OUT
,">configdata.pm") || die "unable to create configdata.pm: $!\n";
1776 #use vars qw(\@ISA \@EXPORT);
1777 our \@ISA = qw(Exporter);
1778 our \
@EXPORT = qw(\%config \%target \%disabled \%withargs \%unified_info \@disablables);
1781 print OUT
"our %config = (\n";
1782 foreach (sort keys %config) {
1783 if (ref($config{$_}) eq "ARRAY") {
1784 print OUT
" ", $_, " => [ ", join(", ",
1785 map { quotify
("perl", $_) }
1786 @
{$config{$_}}), " ],\n";
1788 print OUT
" ", $_, " => ", quotify
("perl", $config{$_}), ",\n"
1795 print OUT
"our %target = (\n";
1796 foreach (sort keys %target) {
1797 if (ref($target{$_}) eq "ARRAY") {
1798 print OUT
" ", $_, " => [ ", join(", ",
1799 map { quotify
("perl", $_) }
1800 @
{$target{$_}}), " ],\n";
1802 print OUT
" ", $_, " => ", quotify
("perl", $target{$_}), ",\n"
1809 print OUT
"our \%available_protocols = (\n";
1810 print OUT
" tls => [ ", join(", ", map { quotify
("perl", $_) } @tls), " ],\n";
1811 print OUT
" dtls => [ ", join(", ", map { quotify
("perl", $_) } @dtls), " ],\n";
1816 print OUT
"our \@disablables = (\n";
1817 foreach (@disablables) {
1818 print OUT
" ", quotify
("perl", $_), ",\n";
1824 print OUT
"our \%disabled = (\n";
1825 foreach (sort keys %disabled) {
1826 print OUT
" ", quotify
("perl", $_), " => ", quotify
("perl", $disabled{$_}), ",\n";
1832 print OUT
"our %withargs = (\n";
1833 foreach (sort keys %withargs) {
1834 if (ref($withargs{$_}) eq "ARRAY") {
1835 print OUT
" ", $_, " => [ ", join(", ",
1836 map { quotify
("perl", $_) }
1837 @
{$withargs{$_}}), " ],\n";
1839 print OUT
" ", $_, " => ", quotify
("perl", $withargs{$_}), ",\n"
1846 if ($builder eq "unified") {
1851 if (ref $_ eq "ARRAY") {
1852 print OUT
" "x
$indent, "[\n";
1854 $recurse->($indent + 4, $_);
1856 print OUT
" "x
$indent, "],\n";
1857 } elsif (ref $_ eq "HASH") {
1859 print OUT
" "x
$indent, "{\n";
1860 foreach (sort keys %h) {
1861 if (ref $h{$_} eq "") {
1862 print OUT
" "x
($indent + 4), quotify
("perl", $_), " => ", quotify
("perl", $h{$_}), ",\n";
1864 print OUT
" "x
($indent + 4), quotify
("perl", $_), " =>\n";
1865 $recurse->($indent + 8, $h{$_});
1868 print OUT
" "x
$indent, "},\n";
1870 print OUT
" "x
$indent, quotify
("perl", $_), ",\n";
1874 print OUT
"our %unified_info = (\n";
1875 foreach (sort keys %unified_info) {
1876 if (ref $unified_info{$_} eq "") {
1877 print OUT
" "x4
, quotify
("perl", $_), " => ", quotify
("perl", $unified_info{$_}), ",\n";
1879 print OUT
" "x4
, quotify
("perl", $_), " =>\n";
1880 $recurse->(8, $unified_info{$_});
1892 print "CC =$config{cross_compile_prefix}$target{cc}\n";
1893 print "CFLAG =$target{cflags} $config{cflags}\n";
1894 print "SHARED_CFLAG =$target{shared_cflag}\n";
1895 print "DEFINES =",join(" ", @
{$target{defines
}}, @
{$config{defines
}}),"\n";
1896 print "LFLAG =$target{lflags}\n";
1897 print "PLIB_LFLAG =$target{plib_lflags}\n";
1898 print "EX_LIBS =$target{ex_libs} $config{ex_libs}\n";
1899 print "APPS_OBJ =$target{apps_obj}\n";
1900 print "CPUID_OBJ =$target{cpuid_obj}\n";
1901 print "UPLINK_OBJ =$target{uplink_obj}\n";
1902 print "BN_ASM =$target{bn_obj}\n";
1903 print "EC_ASM =$target{ec_obj}\n";
1904 print "DES_ENC =$target{des_obj}\n";
1905 print "AES_ENC =$target{aes_obj}\n";
1906 print "BF_ENC =$target{bf_obj}\n";
1907 print "CAST_ENC =$target{cast_obj}\n";
1908 print "RC4_ENC =$target{rc4_obj}\n";
1909 print "RC5_ENC =$target{rc5_obj}\n";
1910 print "MD5_OBJ_ASM =$target{md5_obj}\n";
1911 print "SHA1_OBJ_ASM =$target{sha1_obj}\n";
1912 print "RMD160_OBJ_ASM=$target{rmd160_obj}\n";
1913 print "CMLL_ENC =$target{cmll_obj}\n";
1914 print "MODES_OBJ =$target{modes_obj}\n";
1915 print "PADLOCK_OBJ =$target{padlock_obj}\n";
1916 print "CHACHA_ENC =$target{chacha_obj}\n";
1917 print "POLY1305_OBJ =$target{poly1305_obj}\n";
1918 print "BLAKE2_OBJ =$target{blake2_obj}\n";
1919 print "PROCESSOR =$config{processor}\n";
1920 print "RANLIB =", $target{ranlib
} eq '$(CROSS_COMPILE)ranlib' ?
1921 "$config{cross_compile_prefix}ranlib" :
1922 "$target{ranlib}", "\n";
1923 print "ARFLAGS =$target{arflags}\n";
1924 print "PERL =$config{perl}\n";
1926 print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l
};
1927 print "SIXTY_FOUR_BIT mode\n" if $config{b64
};
1928 print "THIRTY_TWO_BIT mode\n" if $config{b32
};
1929 print "BN_LLONG mode\n" if $config{bn_ll
};
1930 print "RC4 uses $config{rc4_int}\n" if $config{rc4_int
} ne $def_int;
1934 run_dofile
(catfile
($blddir, $target{build_file
}),
1935 $config{build_file_template
},
1936 catfile
($srcdir, "Configurations", "common.tmpl"));
1940 $builders{$builder}->($builder_platform, @builder_opts);
1944 Configured for $target.
1947 print <<"EOF" if ($disabled{threads} eq "unavailable");
1949 The library could not be configured for supporting multi-threaded
1950 applications as the compiler options required on this system are not known.
1951 See file INSTALL for details if you need multi-threading.
1954 print <<"EOF" if ($no_shared_warn);
1956 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
1957 platform, so we will pretend you gave the option 'no-pic', which also disables
1958 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
1959 or position independent code, please let us know (but please first make sure
1960 you have tried with a current version of OpenSSL).
1963 print <<"EOF" if (-f catfile($srcdir, "configdata.pm") && $srcdir ne $blddir);
1965 WARNING: there are indications that another build was made in the source
1966 directory. This build may have picked up artifacts from that build, the
1967 safest course of action is to clean the source directory and redo this
1973 ######################################################################
1975 # Helpers and utility functions
1978 # Configuration file reading #########################################
1980 # Note: All of the helper functions are for lazy evaluation. They all
1981 # return a CODE ref, which will return the intended value when evaluated.
1982 # Thus, whenever there's mention of a returned value, it's about that
1985 # Helper function to implement conditional inheritance depending on the
1986 # value of $disabled{asm}. Used in inherit_from values as follows:
1988 # inherit_from => [ "template", asm("asm_tmpl") ]
1993 $disabled{asm
} ?
() : @x;
1997 # Helper function to implement conditional value variants, with a default
1998 # plus additional values based on the value of $config{build_type}.
1999 # Arguments are given in hash table form:
2001 # picker(default => "Basic string: ",
2003 # release => "release")
2005 # When configuring with --debug, the resulting string will be
2006 # "Basic string: debug", and when not, it will be "Basic string: release"
2008 # This can be used to create variants of sets of flags according to the
2011 # cflags => picker(default => "-Wall",
2012 # debug => "-g -O0",
2017 return sub { add
($opts{default} || (),
2018 $opts{$config{build_type
}} || ())->(); }
2021 # Helper function to combine several values of different types into one.
2022 # This is useful if you want to combine a string with the result of a
2023 # lazy function, such as:
2025 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2029 return sub { add
(@stuff)->(); }
2032 # Helper function to implement conditional values depending on the value
2033 # of $disabled{threads}. Can be used as follows:
2035 # cflags => combine("-Wall", threads("-pthread"))
2039 return sub { add
($disabled{threads
} ?
() : @flags)->(); }
2044 our $add_called = 0;
2045 # Helper function to implement adding values to already existing configuration
2046 # values. It handles elements that are ARRAYs, CODEs and scalars
2048 my $separator = shift;
2050 # If there's any ARRAY in the collection of values OR the separator
2051 # is undef, we will return an ARRAY of combined values, otherwise a
2052 # string of joined values with $separator as the separator.
2053 my $found_array = !defined($separator);
2058 while (ref($res) eq "CODE") {
2061 if (defined($res)) {
2062 if (ref($res) eq "ARRAY") {
2078 join($separator, grep { defined($_) && $_ ne "" } @values);
2082 my $separator = " ";
2083 if (ref($_[$#_]) eq "HASH") {
2085 $separator = $opts->{separator
};
2088 sub { _add
($separator, @x, @_) };
2091 my $separator = " ";
2092 if (ref($_[$#_]) eq "HASH") {
2094 $separator = $opts->{separator
};
2097 sub { _add
($separator, @_, @x) };
2100 # configuration reader, evaluates the input file as a perl script and expects
2101 # it to fill %targets with target configurations. Those are then added to
2105 open(CONFFILE
, "< $fname")
2106 or die "Can't open configuration file '$fname'!\n";
2109 my $content = <CONFFILE
>;
2114 local %table = %::table
; # Protect %table from tampering
2120 # For each target, check that it's configured with a hash table.
2121 foreach (keys %targets) {
2122 if (ref($targets{$_}) ne "HASH") {
2123 if (ref($targets{$_}) eq "") {
2124 warn "Deprecated target configuration for $_, ignoring...\n";
2126 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2128 delete $targets{$_};
2132 %table = (%table, %targets);
2136 # configuration resolver. Will only resolve all the lazy evaluation
2137 # codeblocks for the chosen target and all those it inherits from,
2139 sub resolve_config
{
2141 my @breadcrumbs = @_;
2143 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2145 if (grep { $_ eq $target } @breadcrumbs) {
2146 die "inherit_from loop! target backtrace:\n "
2147 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2150 if (!defined($table{$target})) {
2151 warn "Warning! target $target doesn't exist!\n";
2154 # Recurse through all inheritances. They will be resolved on the
2155 # fly, so when this operation is done, they will all just be a
2156 # bunch of attributes with string values.
2157 # What we get here, though, are keys with references to lists of
2158 # the combined values of them all. We will deal with lists after
2159 # this stage is done.
2160 my %combined_inheritance = ();
2161 if ($table{$target}->{inherit_from
}) {
2163 map { ref($_) eq "CODE" ?
$_->() : $_ } @
{$table{$target}->{inherit_from
}};
2164 foreach (@inherit_from) {
2165 my %inherited_config = resolve_config
($_, $target, @breadcrumbs);
2167 # 'template' is a marker that's considered private to
2168 # the config that had it.
2169 delete $inherited_config{template
};
2171 foreach (keys %inherited_config) {
2172 if (!$combined_inheritance{$_}) {
2173 $combined_inheritance{$_} = [];
2175 push @
{$combined_inheritance{$_}}, $inherited_config{$_};
2180 # We won't need inherit_from in this target any more, since we've
2181 # resolved all the inheritances that lead to this
2182 delete $table{$target}->{inherit_from
};
2184 # Now is the time to deal with those lists. Here's the place to
2185 # decide what shall be done with those lists, all based on the
2186 # values of the target we're currently dealing with.
2187 # - If a value is a coderef, it will be executed with the list of
2188 # inherited values as arguments.
2189 # - If the corresponding key doesn't have a value at all or is the
2190 # empty string, the inherited value list will be run through the
2191 # default combiner (below), and the result becomes this target's
2193 # - Otherwise, this target's value is assumed to be a string that
2194 # will simply override the inherited list of values.
2195 my $default_combiner = add
();
2198 map { $_ => 1 } (keys %combined_inheritance,
2199 keys %{$table{$target}});
2201 sub process_values
{
2203 my $inherited = shift; # Always a [ list ]
2209 while(ref($object) eq "CODE") {
2210 $object = $object->(@
$inherited);
2212 if (!defined($object)) {
2215 elsif (ref($object) eq "ARRAY") {
2216 local $add_called; # To make sure recursive calls don't affect it
2217 return [ map { process_values
($_, $inherited, $target, $entry) }
2219 } elsif (ref($object) eq "") {
2222 die "cannot handle reference type ",ref($object)
2223 ," found in target ",$target," -> ",$entry,"\n";
2227 foreach (sort keys %all_keys) {
2228 my $previous = $combined_inheritance{$_};
2230 # Current target doesn't have a value for the current key?
2231 # Assign it the default combiner, the rest of this loop body
2232 # will handle it just like any other coderef.
2233 if (!exists $table{$target}->{$_}) {
2234 $table{$target}->{$_} = $default_combiner;
2237 $table{$target}->{$_} = process_values
($table{$target}->{$_},
2238 $combined_inheritance{$_},
2240 unless(defined($table{$target}->{$_})) {
2241 delete $table{$target}->{$_};
2243 # if ($extra_checks &&
2244 # $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2245 # warn "$_ got replaced in $target\n";
2249 # Finally done, return the result.
2250 return %{$table{$target}};
2255 print STDERR
$usage;
2256 print STDERR
"\npick os/compiler from:\n";
2260 foreach $i (sort keys %table)
2262 next if $table{$i}->{template
};
2263 next if $i =~ /^debug/;
2264 $k += length($i) + 1;
2270 print STDERR
$i . " ";
2272 foreach $i (sort keys %table)
2274 next if $table{$i}->{template
};
2275 next if $i !~ /^debug/;
2276 $k += length($i) + 1;
2282 print STDERR
$i . " ";
2284 print STDERR
"\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2293 unlink $out || warn "Can't remove $out, $!"
2295 foreach (@templates) {
2296 die "Can't open $_, $!" unless -f
$_;
2298 my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" \"$dofile\" -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\"";
2299 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2302 rename("$out.new", $out) || die "Can't rename $out.new, $!";
2309 if (eval { require IPC
::Cmd
; 1; }) {
2311 return scalar IPC
::Cmd
::can_run
($name);
2313 # if there is $directories component in splitpath,
2314 # then it's not something to test with $PATH...
2315 return $name if (File
::Spec
->splitpath($name))[1];
2317 foreach (File
::Spec
->path()) {
2318 my $fullpath = catfile
($_, "$name$target{exe_extension}");
2319 if (-f
$fullpath and -x
$fullpath) {
2326 # Configuration printer ##############################################
2328 sub print_table_entry
2331 my %target = resolve_config
($target);
2334 # Don't print the templates
2335 return if $target{template
};
2372 "shared_extension_simple",
2373 "shared_import_extension",
2384 if ($type eq "TABLE") {
2386 print "*** $target\n";
2387 foreach (@sequence) {
2388 if (ref($target{$_}) eq "ARRAY") {
2389 printf "\$%-12s = %s\n", $_, join(" ", @
{$target{$_}});
2391 printf "\$%-12s = %s\n", $_, $target{$_};
2394 } elsif ($type eq "HASH") {
2396 length((sort { length($a) <=> length($b) } @sequence)[-1]);
2397 print " '$target' => {\n";
2398 foreach (@sequence) {
2400 if (ref($target{$_}) eq "ARRAY") {
2401 print " '",$_,"'"," " x
($largest - length($_))," => [ ",join(", ", map { "'$_'" } @
{$target{$_}})," ],\n";
2403 print " '",$_,"'"," " x
($largest - length($_))," => '",$target{$_},"',\n";
2411 # Utility routines ###################################################
2413 # On VMS, if the given file is a logical name, File::Spec::Functions
2414 # will consider it an absolute path. There are cases when we want a
2415 # purely syntactic check without checking the environment.
2419 # On non-platforms, we just use file_name_is_absolute().
2420 return file_name_is_absolute
($file) unless $^O
eq "VMS";
2422 # If the file spec includes a device or a directpry spec,
2423 # file_name_is_absolute() is perfectly safe.
2424 return file_name_is_absolute
($file) if $file =~ m
|[:\
[]|;
2426 # Here, we know the given file spec isn't absolute
2430 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
2431 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
2432 # realpath() requires that at least all path components except the last is an
2433 # existing directory. On VMS, the last component of the directory spec must
2438 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
2439 # will return the volume name for the device, no matter what. Also,
2440 # it will return an incorrect directory spec if the argument is a
2441 # directory that doesn't exist.
2443 return rel2abs
($dir);
2446 # We use realpath() on Unix, since no other will properly clean out
2448 use Cwd qw
/realpath/;
2450 return realpath
($dir);
2455 perl
=> sub { my $x = shift;
2456 $x =~ s/([\\\$\@"])/\\$1/g;
2457 return '"'.$x.'"'; },
2461 defined($processors{$for}) ?
$processors{$for} : sub { shift; };
2463 return map { $processor->($_); } @_;
2466 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
2467 # $filename is a file name to read from
2468 # $line_concat_cond_re is a regexp detecting a line continuation ending
2469 # $line_concat is a CODEref that takes care of concatenating two lines
2470 sub collect_from_file
{
2471 my $filename = shift;
2472 my $line_concat_cond_re = shift;
2473 my $line_concat = shift;
2475 open my $fh, $filename || die "unable to read $filename: $!\n";
2477 my $saved_line = "";
2481 if (defined $line_concat) {
2482 $_ = $line_concat->($saved_line, $_);
2485 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2491 die "$filename ending with continuation line\n" if $_;
2497 # collect_from_array($array, $line_concat_cond_re, $line_concat)
2498 # $array is an ARRAYref of lines
2499 # $line_concat_cond_re is a regexp detecting a line continuation ending
2500 # $line_concat is a CODEref that takes care of concatenating two lines
2501 sub collect_from_array
{
2503 my $line_concat_cond_re = shift;
2504 my $line_concat = shift;
2505 my @array = (@
$array);
2508 my $saved_line = "";
2510 while (defined($_ = shift @array)) {
2512 if (defined $line_concat) {
2513 $_ = $line_concat->($saved_line, $_);
2516 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
2522 die "input text ending with continuation line\n" if $_;
2527 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
2528 # $lineiterator is a CODEref that delivers one line at a time.
2529 # All following arguments are regex/CODEref pairs, where the regexp detects a
2530 # line and the CODEref does something with the result of the regexp.
2531 sub collect_information
{
2532 my $lineiterator = shift;
2533 my %collectors = @_;
2535 while(defined($_ = $lineiterator->())) {
2538 if ($collectors{"BEFORE"}) {
2539 $collectors{"BEFORE"}->($_);
2541 foreach my $re (keys %collectors) {
2542 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
2543 $collectors{$re}->($lineiterator);
2547 if ($collectors{"OTHERWISE"}) {
2548 $collectors{"OTHERWISE"}->($lineiterator, $_)
2549 unless $found || !defined $collectors{"OTHERWISE"};
2551 if ($collectors{"AFTER"}) {
2552 $collectors{"AFTER"}->($_);
2558 # $line is a line of text to split up into tokens
2559 # returns a list of tokens
2561 # Tokens are divided by spaces. If the tokens include spaces, they
2562 # have to be quoted with single or double quotes. Double quotes
2563 # inside a double quoted token must be escaped. Escaping is done
2565 # Basically, the same quoting rules apply for " and ' as in any
2568 my $line = my $debug_line = shift;
2571 while ($line =~ s
|^\s
+||, $line ne "") {
2573 while ($line ne "" && $line !~ m
|^\s
|) {
2574 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
2577 } elsif ($line =~ m/^'([^']*)'/) {
2580 } elsif ($line =~ m/^(\S+)/) {
2585 push @result, $token;
2588 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
2589 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
2590 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";