3 # Copyright 2016-2024 The OpenSSL Project Authors. All Rights Reserved.
5 # Licensed under the Apache License 2.0 (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
16 use lib "$FindBin::Bin/util/perl";
18 use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs splitdir/;
19 use File::Path qw/mkpath/;
20 use OpenSSL::fallback "$FindBin::Bin/external/perl/MODULES.txt";
22 use OpenSSL::Template;
25 # see INSTALL.md for instructions.
27 my $orig_death_handler = $SIG{__DIE__};
28 $SIG{__DIE__} = \&death_handler;
30 my $usage="Usage: Configure [no-<feature> ...] [enable-<feature> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]thread-pool] [[no-]default-thread-pool] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
34 **********************************************************************
36 *** OpenSSL has been successfully configured ***
38 *** If you encounter a problem while building, please open an ***
39 *** issue on GitHub <https://github.com/openssl/openssl/issues> ***
40 *** and include the output from the following command: ***
42 *** perl configdata.pm --dump ***
44 *** (If you are new to OpenSSL, you might want to consult the ***
45 *** 'Troubleshooting' section in the INSTALL.md file first) ***
47 **********************************************************************
52 # --config add the given configuration file, which will be read after
53 # any "Configurations*" files that are found in the same
54 # directory as this script.
55 # --prefix prefix for the OpenSSL installation, which includes the
56 # directories bin, lib, include, share/man, share/doc/openssl
57 # This becomes the value of INSTALLTOP in Makefile
58 # (Default: /usr/local)
59 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
60 # If it's a relative directory, it will be added on the directory
61 # given with --prefix.
62 # This becomes the value of OPENSSLDIR in Makefile and in C.
63 # (Default: PREFIX/ssl)
64 # --banner=".." Output specified text instead of default completion banner
66 # -w Don't wait after showing a Configure warning
68 # --cross-compile-prefix Add specified prefix to binutils components.
70 # --api One of 0.9.8, 1.0.0, 1.0.1, 1.0.2, 1.1.0, 1.1.1, or 3.0
71 # Define the public APIs as they were for that version
72 # including patch releases. If 'no-deprecated' is also
73 # given, do not compile support for interfaces deprecated
74 # up to and including the specified OpenSSL version.
76 # no-hw-xxx do not compile support for specific crypto hardware.
77 # Generic OpenSSL-style methods relating to this support
78 # are always compiled but return NULL if the hardware
79 # support isn't compiled.
81 # enable-demos Enable the building of the example code in the demos directory
82 # enable-h3demo Enable the http3 demo, which currently only links to the
83 # external nghttp3 library on unix platforms
84 # no-hw do not compile support for any crypto hardware.
85 # [no-]threads [don't] try to create a library that is suitable for
86 # multithreaded applications (default is "threads" if we
89 # [don't] allow thread pool functionality
90 # [no-]default-thread-pool
91 # [don't] allow default thread pool functionality
92 # [no-]shared [don't] try to create shared libraries when supported.
93 # [no-]pic [don't] try to build position independent code when supported.
94 # If disabled, it also disables shared and dynamic-engine.
95 # no-asm do not use assembler
96 # no-egd do not compile support for the entropy-gathering daemon APIs
97 # [no-]zlib [don't] compile support for zlib compression.
98 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
99 # library and will be loaded at run-time by the OpenSSL library.
100 # sctp include SCTP support
101 # no-quic disable QUIC support
102 # no-uplink Don't build support for UPLINK interface.
103 # enable-weak-ssl-ciphers
104 # Enable weak ciphers that are disabled by default.
105 # 386 generate 80386 code in assembly modules
106 # no-sse2 disables IA-32 SSE2 code in assembly modules, the above
107 # mentioned '386' option implies this one
108 # no-<cipher> build without specified algorithm (dsa, idea, rc5, ...)
109 # -<xxx> +<xxx> All options which are unknown to the 'Configure' script are
110 # /<xxx> passed through to the compiler. Unix-style options beginning
111 # with a '-' or '+' are recognized, as well as Windows-style
112 # options beginning with a '/'. If the option contains arguments
113 # separated by spaces, then the URL-style notation %20 can be
114 # used for the space character in order to avoid having to quote
115 # the option. For example, -opt%20arg gets expanded to -opt arg.
116 # In fact, any ASCII character can be encoded as %xx using its
117 # hexadecimal encoding.
118 # -static while -static is also a pass-through compiler option (and
119 # as such is limited to environments where it's actually
120 # meaningful), it triggers a number configuration options,
121 # namely no-pic, no-shared and no-threads. It is
122 # argued that the only reason to produce statically linked
123 # binaries (and in context it means executables linked with
124 # -static flag, and not just executables linked with static
125 # libcrypto.a) is to eliminate dependency on specific run-time,
126 # a.k.a. libc version. The mentioned config options are meant
127 # to achieve just that. Unfortunately on Linux it's impossible
128 # to eliminate the dependency completely for openssl executable
129 # because of getaddrinfo and gethostbyname calls, which can
130 # invoke dynamically loadable library facility anyway to meet
131 # the lookup requests. For this reason on Linux statically
132 # linked openssl executable has rather debugging value than
133 # production quality.
135 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
136 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
137 # Following are set automatically by this script
139 # MD5_ASM use some extra md5 assembler,
140 # SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
141 # RMD160_ASM use some extra ripemd160 assembler,
142 # SHA256_ASM sha256_block is implemented in assembler
143 # SHA512_ASM sha512_block is implemented in assembler
144 # AES_ASM AES_[en|de]crypt is implemented in assembler
146 # Minimum warning options... any contributions to OpenSSL should at least
147 # get past these. Note that we only use these with C compilers, not with
150 # -DPEDANTIC complements -pedantic and is meant to mask code that
151 # is not strictly standard-compliant and/or implementation-specific,
152 # e.g. inline assembly, disregards to alignment requirements, such
153 # that -pedantic would complain about. Incidentally -DPEDANTIC has
154 # to be used even in sanitized builds, because sanitizer too is
155 # supposed to and does take notice of non-standard behaviour. Then
156 # -pedantic with pre-C9x compiler would also complain about 'long
157 # long' not being supported. As 64-bit algorithms are common now,
158 # it grew impossible to resolve this without sizeable additional
159 # code, so we just tell compiler to be pedantic about everything
160 # but 'long long' type.
162 my @gcc_devteam_warn = qw(
163 -DPEDANTIC -pedantic -Wno-long-long -DUNUSEDRESULT_DEBUG
165 -Wmissing-declarations
167 -Wno-unused-parameter
168 -Wno-missing-field-initializers
174 -Wno-tautological-constant-out-of-range-compare
181 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
182 # TODO(openssl-team): fix problems and investigate if (at least) the
183 # following warnings can also be enabled:
185 # -Wunreachable-code -- no, too ugly/compiler-specific
186 # -Wlanguage-extension-token -- no, we use asm()
187 # -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
188 # -Wextended-offsetof -- no, needed in CMS ASN1 code
189 my @clang_devteam_warn = qw(
190 -Wno-unknown-warning-option
192 -Wno-parentheses-equality
193 -Wno-language-extension-token
194 -Wno-extended-offsetof
196 -Wconditional-uninitialized
197 -Wincompatible-pointer-types-discards-qualifiers
198 -Wmissing-variable-declarations
201 my @cl_devteam_warn = qw(
205 my $strict_warnings = 0;
207 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
208 # which would cover all BSD flavors. -pthread applies to them all,
209 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
210 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
211 # which has to be accompanied by explicit -D_THREAD_SAFE and
212 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
213 # seems to be sufficient?
214 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
217 # API compatibility name to version number mapping.
220 # This table expresses when API additions or changes can occur.
221 # The numbering used changes from 3.0 and on because we updated
222 # (solidified) our version numbering scheme at that point.
224 # From 3.0 and on, we internalise the given version number in decimal
225 # as MAJOR * 10000 + MINOR * 100 + 0
229 # Note that before 3.0, we didn't have the same version number scheme.
230 # Still, the numbering we use here covers what we need.
239 # For OpenSSL::config::get_platform
247 our $now_printing; # set to current entry's name in print_table_entry
248 # (todo: right thing would be to encapsulate name
249 # into %target [class] and make print_table_entry
252 # Forward declarations ###############################################
254 # read_config(filename)
256 # Reads a configuration file and populates %table with the contents
257 # (which the configuration file places in %targets).
260 # resolve_config(target)
262 # Resolves all the late evaluations, inheritances and so on for the
263 # chosen target and any target it inherits from.
267 # Information collection #############################################
269 # Unified build supports separate build dir
270 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
271 my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
273 # File::Spec::Unix doesn't detect case insensitivity, so we make sure to
274 # check if the source and build directory are really the same, and make
275 # them so. This avoids all kinds of confusion later on.
276 # We must check @File::Spec::ISA rather than using File::Spec->isa() to
277 # know if File::Spec ended up loading File::Spec::Unix.
279 if (grep(/::Unix$/, @File::Spec::ISA)
280 && samedir($srcdir, $blddir));
282 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
284 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
286 $config{sourcedir} = abs2rel($srcdir, $blddir);
287 $config{builddir} = abs2rel($blddir, $blddir);
288 # echo -n 'holy hand grenade of antioch' | openssl sha256
290 'f4556650ac31d35461610bac4ed81b1a181b2d8a43ea2854cbae22ca74560813';
292 # Collect reconfiguration information if needed
295 if (grep /^reconf(igure)?$/, @argvcopy) {
296 die "reconfiguring with other arguments present isn't supported"
297 if scalar @argvcopy > 1;
298 if (-f "./configdata.pm") {
299 my $file = "./configdata.pm";
300 unless (my $return = do $file) {
301 die "couldn't parse $file: $@" if $@;
302 die "couldn't do $file: $!" unless defined $return;
303 die "couldn't run $file" unless $return;
306 @argvcopy = defined($configdata::config{perlargv}) ?
307 @{$configdata::config{perlargv}} : ();
308 die "Incorrect data to reconfigure, please do a normal configuration\n"
309 if (grep(/^reconf/,@argvcopy));
310 $config{perlenv} = $configdata::config{perlenv} // {};
312 die "Insufficient data to reconfigure, please do a normal configuration\n";
316 $config{perlargv} = [ @argvcopy ];
318 # Historical: if known directories in crypto/ have been removed, it means
319 # that those sub-systems are disabled.
320 # (the other option would be to removed them from the SUBDIRS statement in
322 # We reverse the input list for cosmetic purely reasons, to compensate that
323 # 'unshift' adds at the front of the list (i.e. in reverse input order).
324 foreach ( reverse sort( 'aes', 'aria', 'bf', 'camellia', 'cast', 'des', 'dh',
325 'dsa', 'ec', 'hmac', 'idea', 'md2', 'md5', 'mdc2',
326 'rc2', 'rc4', 'rc5', 'ripemd', 'seed', 'sha',
327 'sm2', 'sm3', 'sm4') ) {
328 unshift @argvcopy, "no-$_" if ! -d catdir($srcdir, 'crypto', $_);
331 # Collect version numbers
335 collect_from_file(catfile($srcdir,'VERSION.dat')),
336 qr/\s*(\w+)\s*=\s*(.*?)\s*$/ =>
338 # Only define it if there is a value at all
342 # Some values are quoted. Trim the quotes
343 $v = $1 if $v =~ /^"(.*)"$/;
344 $version{uc $k} = $v;
348 sub { die "Something wrong with this line:\n$_\nin $srcdir/VERSION.dat" },
351 $config{major} = $version{MAJOR} // 'unknown';
352 $config{minor} = $version{MINOR} // 'unknown';
353 $config{patch} = $version{PATCH} // 'unknown';
354 $config{prerelease} =
355 defined $version{PRE_RELEASE_TAG} ? "-$version{PRE_RELEASE_TAG}" : '';
356 $config{build_metadata} =
357 defined $version{BUILD_METADATA} ? "+$version{BUILD_METADATA}" : '';
358 $config{shlib_version} = $version{SHLIB_VERSION} // 'unknown';
359 $config{release_date} = $version{RELEASE_DATE} // 'xx XXX xxxx';
361 $config{version} = "$config{major}.$config{minor}.$config{patch}";
362 $config{full_version} = "$config{version}$config{prerelease}$config{build_metadata}";
364 die "erroneous version information in VERSION.dat: ",
365 "$config{version}, $config{shlib_version}\n"
366 unless (defined $version{MAJOR}
367 && defined $version{MINOR}
368 && defined $version{PATCH}
369 && defined $version{SHLIB_VERSION});
371 # Collect target configurations
373 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
374 foreach (sort glob($pattern)) {
378 if (defined env($local_config_envname)) {
380 # VMS environment variables are logical names,
381 # which can be used as is
382 $pattern = $local_config_envname . ':' . '*.conf';
384 $pattern = catfile(env($local_config_envname), '*.conf');
387 foreach (sort glob($pattern)) {
392 # Fail if no configuration is apparent
394 print "Failed to find any os/compiler configurations. Please make sure the Configurations directory is included.\n";
398 # Save away perl command information
399 $config{perl_cmd} = $^X;
400 $config{perl_version} = $Config{version};
401 $config{perl_archname} = $Config{archname};
404 $config{openssldir}="";
405 $config{processor}="";
407 my $auto_threads=1; # enable threads automatically? true by default
410 # Known TLS and DTLS protocols
411 my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
412 my @dtls = qw(dtls1 dtls1_2);
414 # Explicitly known options that are possible to disable. They can
415 # be regexps, and will be used like this: /^no-${option}$/
416 # For developers: keep it sorted alphabetically
449 "default-thread-pool",
464 "ec_nistp_64_gcc_128",
474 "fips-securitychecks",
544 foreach my $proto ((@tls, @dtls))
546 push(@disablables, $proto);
547 push(@disablables, "$proto-method") unless $proto eq "tls1_3";
550 # Internal disablables, for aliasing purposes. They serve no special
551 # purpose here, but allow scripts to get to know them through configdata.pm,
552 # where these are merged with @disablables.
553 # The actual aliasing mechanism is done via %disable_cascades
554 my @disablables_int = qw(
558 my %deprecated_disablables = (
560 "buf-freelists" => undef,
561 "crypto-mdebug-backtrace" => undef,
562 "hw" => "hw", # causes cascade, but no macro
563 "hw-padlock" => "padlockeng",
564 "ripemd" => "rmd160",
565 "ui" => "ui-console",
566 "heartbeats" => undef,
569 # All of the following are disabled by default:
571 our %disabled = ( # "what" => "comment"
574 "brotli" => "default",
575 "brotli-dynamic" => "default",
576 "buildtest-c++" => "default",
577 "crypto-mdebug" => "default",
578 "crypto-mdebug-backtrace" => "default",
579 "demos" => "default",
580 "h3demo" => "default",
581 "devcryptoeng" => "default",
582 "ec_nistp_64_gcc_128" => "default",
584 "external-tests" => "default",
585 "fuzz-afl" => "default",
586 "fuzz-libfuzzer" => "default",
593 "ssl3-method" => "default",
595 "trace" => "default",
596 "ubsan" => "default",
597 "unit-test" => "default",
598 "weak-ssl-ciphers" => "default",
600 "zlib-dynamic" => "default",
602 "zstd-dynamic" => "default",
605 # Note: => pair form used for aesthetics, not to truly make a hash table
606 my @disable_cascades = (
607 # "what" => [ "cascade", ... ]
608 "bulk" => [ "shared", "dso",
609 "aria", "async", "atexit", "autoload-config",
610 "blake2", "bf", "camellia", "cast", "chacha",
611 "cmac", "cms", "cmp", "comp", "ct",
612 "des", "dgram", "dh", "dsa",
616 "md4", "multiblock", "nextprotoneg",
617 "ocsp", "ocb", "poly1305", "psk",
618 "rc2", "rc4", "rmd160",
619 "seed", "siphash", "siv",
621 "srtp", "ssl3-method", "ssl-trace",
623 "ts", "ui-console", "whirlpool",
624 "fips-securitychecks" ],
625 sub { $config{processor} eq "386" }
628 "ssl3-method" => [ "ssl3" ],
629 "zlib" => [ "zlib-dynamic" ],
630 "brotli" => [ "brotli-dynamic" ],
631 "zstd" => [ "zstd-dynamic" ],
633 "ec" => [ "ec2m", "ecdsa", "ecdh", "sm2", "gost", "ecx" ],
634 "dgram" => [ "dtls", "quic", "sctp" ],
635 "sock" => [ "dgram", "tfo" ],
637 sub { 0 == scalar grep { !$disabled{$_} } @dtls }
641 sub { 0 == scalar grep { !$disabled{$_} } @tls }
643 "tls1_3" => [ "quic" ],
644 "quic" => [ "unstable-qlog" ],
646 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
648 "module" => [ "dynamic-engine", "fips" ],
650 # Without shared libraries, dynamic engines aren't possible.
651 # This is due to them having to link with libcrypto and register features
652 # using the ENGINE functionality, and since that relies on global tables,
653 # those *have* to be exactly the same as the ones accessed from the app,
654 # which cannot be guaranteed if shared libraries aren't present.
655 # (note that even with shared libraries, both the app and dynamic engines
656 # must be linked with the same library)
657 "shared" => [ "dynamic-engine", "uplink" ],
658 "dso" => [ "dynamic-engine", "module" ],
659 # Other modules don't necessarily have to link with libcrypto, so shared
660 # libraries do not have to be a condition to produce those.
662 # Without position independent code, there can be no shared libraries
664 "pic" => [ "shared", "module" ],
666 "engine" => [ "dynamic-engine", grep(/eng$/, @disablables) ],
667 "dynamic-engine" => [ "loadereng" ],
668 "hw" => [ "padlockeng" ],
670 # no-autoalginit is only useful when building non-shared
671 "autoalginit" => [ "shared", "apps", "fips" ],
673 "stdio" => [ "apps", "capieng", "egd" ],
674 "apps" => [ "tests" ],
675 "tests" => [ "external-tests" ],
676 "comp" => [ "zlib", "brotli", "zstd" ],
678 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
680 sub { !$disabled{"msan"} } => [ "asm" ],
683 "legacy" => [ "md2" ],
687 "fips" => [ "fips-securitychecks", "acvp-tests" ],
689 "threads" => [ "thread-pool" ],
690 "thread-pool" => [ "default-thread-pool" ],
692 "blake2" => [ "argon2" ],
694 "deprecated-3.0" => [ "engine", "srp" ],
699 # Avoid protocol support holes. Also disable all versions below N, if version
700 # N is disabled while N+1 is enabled.
702 my @list = (reverse @tls);
703 while ((my $first, my $second) = (shift @list, shift @list)) {
705 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
707 unshift @list, $second;
709 my @list = (reverse @dtls);
710 while ((my $first, my $second) = (shift @list, shift @list)) {
712 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
714 unshift @list, $second;
717 # Explicit "no-..." options will be collected in %disabled along with the defaults.
718 # To remove something from %disabled, use "enable-foo".
719 # For symmetry, "disable-foo" is a synonym for "no-foo".
721 # For the "make variables" CPPINCLUDES and CPPDEFINES, we support lists with
722 # platform specific list separators. Users from those platforms should
723 # recognise those separators from how you set up the PATH to find executables.
724 # The default is the Unix like separator, :, but as an exception, we also
725 # support the space as separator.
726 my $list_separator_re =
727 { VMS => qr/(?<!\^),/,
728 MSWin32 => qr/(?<!\\);/ } -> {$^O} // qr/(?<!\\)[:\s]/;
729 # All the "make variables" we support
730 # Some get pre-populated for the sake of backward compatibility
731 # (we supported those before the change to "make variable" support.
738 CFLAGS => [ env('CFLAGS') || () ],
740 CXXFLAGS => [ env('CXXFLAGS') || () ],
742 CPPFLAGS => [ env('CPPFLAGS') || () ], # -D, -I, -Wp,
743 CPPDEFINES => [], # Alternative for -D
744 CPPINCLUDES => [], # Alternative for -I
745 CROSS_COMPILE => env('CROSS_COMPILE'),
746 HASHBANGPERL=> env('HASHBANGPERL') || env('PERL'),
748 LDFLAGS => [ env('LDFLAGS') || () ], # -L, -Wl,
749 LDLIBS => [ env('LDLIBS') || () ], # -l
752 PERL => env('PERL') || ($^O ne "VMS" ? $^X : "perl"),
753 RANLIB => env('RANLIB'),
754 RC => env('RC') || env('WINDRES'),
755 RCFLAGS => [ env('RCFLAGS') || () ],
758 # Info about what "make variables" may be prefixed with the cross compiler
759 # prefix. This should NEVER mention any such variable with a list for value.
760 my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
761 # The same but for flags given as Configure options. These are *additional*
762 # input, as opposed to the VAR=string option that override the corresponding
763 # config target attributes
776 my %user_synonyms = (
777 HASHBANGPERL=> 'PERL',
781 # Some target attributes have been renamed, this is the translation table
782 my %target_attr_translate =(
788 hashbangperl => 'HASHBANGPERL',
796 # Initialisers coming from 'config' scripts
797 $config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ];
798 $config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ];
799 $config{cppflags} = [ env('__CNF_CPPFLAGS') || () ];
800 $config{cflags} = [ env('__CNF_CFLAGS') || () ];
801 $config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ];
802 $config{lflags} = [ env('__CNF_LDFLAGS') || () ];
803 $config{ex_libs} = [ env('__CNF_LDLIBS') || () ];
805 $config{openssl_api_defines}=[];
806 $config{openssl_sys_defines}=[];
807 $config{openssl_feature_defines}=[];
809 $config{build_type} = "release";
812 my %cmdvars = (); # Stores FOO='blah' type arguments
813 my %unsupported_options = ();
814 my %deprecated_options = ();
815 # If you change this, update apps/version.c
816 my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
817 my @seed_sources = ();
820 $_ = shift @argvcopy;
822 # Support env variable assignments among the options
823 if (m|^(\w+)=(.+)?$|)
826 # Every time a variable is given as a configuration argument,
827 # it acts as a reset if the variable.
828 if (exists $user{$1})
830 $user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
832 #if (exists $useradd{$1})
839 # VMS is a case insensitive environment, and depending on settings
840 # out of our control, we may receive options uppercased. Let's
841 # downcase at least the part before any equal sign.
847 # some people just can't read the instructions, clang people have to...
848 s/^-no-(?!integrated-as)/no-/;
850 # rewrite some options in "enable-..." form
851 s /^-?-?shared$/enable-shared/;
852 s /^sctp$/enable-sctp/;
853 s /^threads$/enable-threads/;
854 s /^zlib$/enable-zlib/;
855 s /^zlib-dynamic$/enable-zlib-dynamic/;
856 s /^fips$/enable-fips/;
858 if (/^(no|disable|enable)-(.+)$/)
861 if ($word !~ m|hw(?:-.+)| # special treatment for hw regexp opt
862 && !exists $deprecated_disablables{$word}
863 && !grep { $word eq $_ } @disablables)
865 $unsupported_options{$_} = 1;
869 if (/^no-(.+)$/ || /^disable-(.+)$/)
871 foreach my $proto ((@tls, @dtls))
873 if ($1 eq "$proto-method")
875 $disabled{"$proto"} = "option($proto-method)";
881 foreach my $proto (@dtls)
883 $disabled{$proto} = "option(dtls)";
885 $disabled{"dtls"} = "option(dtls)";
889 # Last one of its kind
890 $disabled{"ssl3"} = "option(ssl)";
894 # XXX: Tests will fail if all SSL/TLS
895 # protocols are disabled.
896 foreach my $proto (@tls)
898 $disabled{$proto} = "option(tls)";
901 elsif ($1 eq "static-engine")
903 delete $disabled{"dynamic-engine"};
905 elsif ($1 eq "dynamic-engine")
907 $disabled{"dynamic-engine"} = "option";
909 elsif (exists $deprecated_disablables{$1})
911 $deprecated_options{$_} = 1;
912 if (defined $deprecated_disablables{$1})
914 $disabled{$deprecated_disablables{$1}} = "option";
917 elsif ($1 =~ m|hw(?:-.+)|) # deprecate hw options in regexp form
919 $deprecated_options{$_} = 1;
923 $disabled{$1} = "option";
925 # No longer an automatic choice
926 $auto_threads = 0 if ($1 eq "threads");
928 elsif (/^enable-(.+)$/)
930 if ($1 eq "static-engine")
932 $disabled{"dynamic-engine"} = "option";
934 elsif ($1 eq "dynamic-engine")
936 delete $disabled{"dynamic-engine"};
938 elsif ($1 eq "zlib-dynamic")
940 delete $disabled{"zlib"};
942 elsif ($1 eq "brotli-dynamic")
944 delete $disabled{"brotli"};
946 elsif ($1 eq "zstd-dynamic")
948 delete $disabled{"zstd"};
951 delete $disabled{$algo};
953 # No longer an automatic choice
954 $auto_threads = 0 if ($1 eq "threads");
956 elsif (/^-d$/) # From older 'config'
958 $config{build_type} = "debug";
960 elsif (/^-v$/) # From older 'config'
962 $guess_opts{verbose} = 1;
966 $guess_opts{nowait} = 1;
968 elsif (/^-t$/) # From older 'config'
972 elsif (/^--strict-warnings$/)
974 # Pretend that our strict flags is a C flag, and replace it
975 # with the proper flags later on
976 push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
981 $config{build_type} = "debug";
983 elsif (/^--release$/)
985 $config{build_type} = "release";
988 { $config{processor}=386; }
991 # No RSAref support any more since it's not needed.
992 # The check for the option is there so scripts aren't
997 if (/^--prefix=(.*)$/)
1001 elsif (/^--api=(.*)$/)
1004 die "Unknown API compatibility level $api"
1005 unless defined $apitable->{$api};
1006 $config{api}=$apitable->{$api};
1008 elsif (/^--libdir=(.*)$/)
1012 elsif (/^--openssldir=(.*)$/)
1014 $config{openssldir}=$1;
1016 elsif (/^--with-zlib-lib=(.*)$/)
1018 $withargs{zlib_lib}=$1;
1020 elsif (/^--with-zlib-include=(.*)$/)
1022 $withargs{zlib_include}=$1;
1024 elsif (/^--with-brotli-lib=(.*)$/)
1026 $withargs{brotli_lib}=$1;
1028 elsif (/^--with-brotli-include=(.*)$/)
1030 $withargs{brotli_include}=$1;
1032 elsif (/^--with-zstd-lib=(.*)$/)
1034 $withargs{zstd_lib}=$1;
1036 elsif (/^--with-zstd-include=(.*)$/)
1038 $withargs{zstd_include}=$1;
1040 elsif (/^--with-fuzzer-lib=(.*)$/)
1042 $withargs{fuzzer_lib}=$1;
1044 elsif (/^--with-fuzzer-include=(.*)$/)
1046 $withargs{fuzzer_include}=$1;
1048 elsif (/^--with-rand-seed=(.*)$/)
1050 foreach my $x (split(m|,|, $1))
1052 die "Unknown --with-rand-seed choice $x\n"
1053 if ! grep { $x eq $_ } @known_seed_sources;
1054 push @seed_sources, $x;
1057 elsif (/^--fips-key=(.*)$/)
1059 $user{FIPSKEY}=lc($1);
1060 die "Non-hex character in FIPS key\n"
1061 if $user{FIPSKEY} =~ /[^a-f0-9]/;
1062 die "FIPS key must have even number of characters\n"
1064 die "FIPS key too long (64 bytes max)\n"
1067 elsif (/^--banner=(.*)$/)
1069 $banner = $1 . "\n";
1071 elsif (/^--cross-compile-prefix=(.*)$/)
1073 $user{CROSS_COMPILE}=$1;
1075 elsif (/^--config=(.*)$/)
1081 push @{$useradd{LDLIBS}}, $_;
1083 elsif (/^-framework$/)
1085 push @{$useradd{LDLIBS}}, $_, shift(@argvcopy);
1087 elsif (/^-L(.*)$/ or /^-Wl,/)
1089 push @{$useradd{LDFLAGS}}, $_;
1091 elsif (/^-rpath$/ or /^-R$/)
1092 # -rpath is the OSF1 rpath flag
1093 # -R is the old Solaris rpath flag
1095 my $rpath = shift(@argvcopy) || "";
1096 $rpath .= " " if $rpath ne "";
1097 push @{$useradd{LDFLAGS}}, $_, $rpath;
1101 push @{$useradd{LDFLAGS}}, $_;
1103 elsif (m|^[-/]D(.*)$|)
1105 push @{$useradd{CPPDEFINES}}, $1;
1107 elsif (m|^[-/]I(.*)$|)
1109 push @{$useradd{CPPINCLUDES}}, $1;
1113 push @{$useradd{CPPFLAGS}}, $1;
1115 else # common if (/^[-+]/), just pass down...
1117 # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
1118 # This provides a simple way to pass options with arguments separated
1119 # by spaces without quoting (e.g. -opt%20arg translates to -opt arg).
1120 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1121 push @{$useradd{CFLAGS}}, $_;
1122 push @{$useradd{CXXFLAGS}}, $_;
1127 # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
1128 # This provides a simple way to pass options with arguments separated
1129 # by spaces without quoting (e.g. /opt%20arg translates to /opt arg).
1130 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
1131 push @{$useradd{CFLAGS}}, $_;
1132 push @{$useradd{CXXFLAGS}}, $_;
1136 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
1139 unless ($_ eq $target || /^no-/ || /^disable-/)
1141 # "no-..." follows later after implied deactivations
1142 # have been derived. (Don't take this too seriously,
1143 # we really only write OPTIONS to the Makefile out of
1146 if ($config{options} eq "")
1147 { $config{options} = $_; }
1149 { $config{options} .= " ".$_; }
1153 if (keys %deprecated_options)
1155 warn "***** Deprecated options: ",
1156 join(", ", keys %deprecated_options), "\n";
1158 if (keys %unsupported_options)
1160 die "***** Unsupported options: ",
1161 join(", ", keys %unsupported_options), "\n";
1164 # If any %useradd entry has been set, we must check that the "make
1165 # variables" haven't been set. We start by checking of any %useradd entry
1167 if (grep { scalar @$_ > 0 } values %useradd) {
1168 # Hash of env / make variables names. The possible values are:
1170 # 2 - %useradd entry set
1174 $v += 1 if $cmdvars{$_};
1175 $v += 2 if @{$useradd{$_}};
1179 # If any of the corresponding "make variables" is set, we error
1180 if (grep { $_ & 1 } values %detected_vars) {
1181 my $names = join(', ', grep { $detected_vars{$_} > 0 }
1182 sort keys %detected_vars);
1184 ***** Mixing make variables and additional compiler/linker flags as
1185 ***** configure command line option is not permitted.
1186 ***** Affected make variables: $names
1191 # Check through all supported command line variables to see if any of them
1192 # were set, and canonicalise the values we got. If no compiler or linker
1193 # flag or anything else that affects %useradd was set, we also check the
1194 # environment for values.
1196 grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
1197 foreach (keys %user) {
1198 my $value = $cmdvars{$_};
1199 $value //= env($_) unless $anyuseradd;
1201 defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
1202 $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
1205 if (defined $value) {
1206 if (ref $user{$_} eq 'ARRAY') {
1207 if ($_ eq 'CPPDEFINES' || $_ eq 'CPPINCLUDES') {
1208 $user{$_} = [ split /$list_separator_re/, $value ];
1210 $user{$_} = [ $value ];
1212 } elsif (!defined $user{$_}) {
1218 if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
1219 && !$disabled{shared}
1220 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
1221 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
1222 "***** any of asan, msan or ubsan\n";
1225 # If no target was given, try guessing.
1227 my %system_config = OpenSSL::config::get_platform(%guess_opts, %user);
1229 # The $system_config{disable} is used to populate %disabled with
1230 # entries that aren't already there.
1231 foreach ( @{$system_config{disable} // []} ) {
1232 $disabled{$_} = 'system' unless defined $disabled{$_};
1234 delete $system_config{disable};
1236 # Override config entries with stuff from the guesser.
1237 # It's assumed that this really is nothing new.
1238 %config = ( %config, %system_config );
1239 $target = $system_config{target};
1243 my $disable_type = shift;
1246 $disabled{$_} = $disable_type;
1249 my @tocheckfor = (@_ ? @_ : keys %disabled);
1250 while (@tocheckfor) {
1251 my %new_tocheckfor = ();
1252 my @cascade_copy = (@disable_cascades);
1253 while (@cascade_copy) {
1254 my ($test, $descendents) =
1255 (shift @cascade_copy, shift @cascade_copy);
1256 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
1257 foreach (grep { !defined($disabled{$_}) } @$descendents) {
1258 $new_tocheckfor{$_} = 1; $disabled{$_} = "cascade";
1262 @tocheckfor = (keys %new_tocheckfor);
1265 disable(); # First cascade run
1267 our $die = sub { die @_; };
1268 if ($target eq "TABLE") {
1269 local $die = sub { warn @_; };
1270 foreach (sort keys %table) {
1271 print_table_entry($_, "TABLE");
1276 if ($target eq "LIST") {
1277 foreach (sort keys %table) {
1278 print $_,"\n" unless $table{$_}->{template};
1283 if ($target eq "HASH") {
1284 local $die = sub { warn @_; };
1285 print "%table = (\n";
1286 foreach (sort keys %table) {
1287 print_table_entry($_, "HASH");
1292 print "Configuring OpenSSL version $config{full_version} ";
1293 print "for target $target\n";
1295 if (scalar(@seed_sources) == 0) {
1296 print "Using os-specific seed configuration\n";
1297 push @seed_sources, 'os';
1299 if (scalar(grep { $_ eq 'egd' } @seed_sources) > 0) {
1300 delete $disabled{'egd'};
1302 if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1303 die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1304 warn <<_____ if scalar(@seed_sources) == 1;
1306 ============================== WARNING ===============================
1307 You have selected the --with-rand-seed=none option, which effectively
1308 disables automatic reseeding of the OpenSSL random generator.
1309 All operations depending on the random generator such as creating keys
1310 will not work unless the random generator is seeded manually by the
1313 Please read the 'Note on random number generation' section in the
1314 INSTALL.md instructions and the RAND_DRBG(7) manual page for more
1316 ============================== WARNING ===============================
1320 push @{$config{openssl_feature_defines}},
1321 map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
1324 # Backward compatibility?
1325 if ($target =~ m/^CygWin32(-.*)$/) {
1326 $target = "Cygwin".$1;
1329 # Support for legacy targets having a name starting with 'debug-'
1330 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1332 $config{build_type} = "debug";
1334 # If we do not find debug-foo in the table, the target is set to foo.
1335 if (!$table{$target}) {
1341 # It's possible that we have different config targets for specific
1342 # toolchains, so we try to detect them, and go for the plain config
1345 foreach ( ( "$target-$user{CC}", "$target", undef ) ) {
1346 $found=$_ if $table{$_} && !$table{$_}->{template};
1351 # If we don't have a config target now, we try the C compiler as we
1353 my $cc = $user{CC} // 'cc';
1354 $target = $cc if $table{$cc} && !$table{$cc}->{template};
1357 &usage unless $target;
1359 exit 0 if $dryrun; # From older 'config'
1361 $config{target} = $target;
1362 my %target = resolve_config($target);
1364 foreach (keys %target_attr_translate) {
1365 $target{$target_attr_translate{$_}} = $target{$_}
1370 %target = ( %{$table{DEFAULTS}}, %target );
1372 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1373 $config{conf_files} = [ sort keys %conf_files ];
1375 # Using sub disable within these loops may prove fragile, so we run
1376 # a cascade afterwards
1377 foreach my $feature (@{$target{disable}}) {
1378 if (exists $deprecated_disablables{$feature}) {
1379 warn "***** config $target disables deprecated feature $feature\n";
1380 } elsif (!grep { $feature eq $_ } @disablables) {
1381 die "***** config $target disables unknown feature $feature\n";
1383 $disabled{$feature} = 'config';
1385 foreach my $feature (@{$target{enable}}) {
1386 if ("default" eq ($disabled{$feature} // "")) {
1387 if (exists $deprecated_disablables{$feature}) {
1388 warn "***** config $target enables deprecated feature $feature\n";
1389 } elsif (!grep { $feature eq $_ } @disablables) {
1390 die "***** config $target enables unknown feature $feature\n";
1392 delete $disabled{$feature};
1396 # If uplink_arch isn't defined, disable uplink
1397 $disabled{uplink} = 'no uplink_arch' unless (defined $target{uplink_arch});
1398 # If asm_arch isn't defined, disable asm
1399 $disabled{asm} = 'no asm_arch' unless (defined $target{asm_arch});
1401 disable(); # Run a cascade now
1403 $target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1404 $target{cxxflags}//=$target{cflags} if $target{CXX};
1405 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP");
1406 $target{exe_extension}=".pm" if ($config{target} =~ /vos/);
1408 # Fill %config with values from %user, and in case those are undefined or
1409 # empty, use values from %target (acting as a default).
1410 foreach (keys %user) {
1411 my $ref_type = ref $user{$_};
1413 # Temporary function. Takes an intended ref type (empty string or "ARRAY")
1414 # and a value that's to be coerced into that type.
1418 my $undef_p = shift;
1420 die "Too many arguments for \$mkvalue" if @_;
1422 while (ref $value eq 'CODE') {
1423 $value = $value->();
1426 if ($type eq 'ARRAY') {
1427 return undef unless defined $value;
1428 return undef if ref $value ne 'ARRAY' && !$value;
1429 return undef if ref $value eq 'ARRAY' && !@$value;
1430 return [ $value ] unless ref $value eq 'ARRAY';
1432 return undef unless $value;
1437 $mkvalue->($ref_type, $user{$_})
1438 || $mkvalue->($ref_type, $target{$_});
1439 delete $config{$_} unless defined $config{$_};
1442 # Finish up %config by appending things the user gave us on the command line
1443 # apart from "make variables"
1444 foreach (keys %useradd) {
1445 # The must all be lists, so we assert that here
1446 die "internal error: \$useradd{$_} isn't an ARRAY\n"
1447 unless ref $useradd{$_} eq 'ARRAY';
1449 if (defined $config{$_}) {
1450 push @{$config{$_}}, @{$useradd{$_}};
1452 $config{$_} = [ @{$useradd{$_}} ];
1455 # At this point, we can forget everything about %user and %useradd,
1456 # because it's now all been merged into the corresponding $config entry
1458 if ($config{prefix} && !$config{CROSS_COMPILE}) {
1459 die "Directory given with --prefix MUST be absolute\n"
1460 unless file_name_is_absolute($config{prefix});
1463 if (grep { $_ =~ /(?:^|\s)-static(?:\s|$)/ } @{$config{LDFLAGS}}) {
1464 disable('static', 'pic', 'threads');
1467 # Allow overriding the build file name
1468 $config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
1470 # Make sure build_scheme is consistent.
1471 $target{build_scheme} = [ $target{build_scheme} ]
1472 if ref($target{build_scheme}) ne "ARRAY";
1474 my ($builder, $builder_platform, @builder_opts) =
1475 @{$target{build_scheme}};
1477 foreach my $checker (($builder_platform."-".$config{build_file}."-checker.pm",
1478 $builder_platform."-checker.pm")) {
1479 my $checker_path = catfile($srcdir, "Configurations", $checker);
1480 if (-f $checker_path) {
1481 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1482 ? sub { warn $@; } : sub { die $@; };
1483 if (! do $checker_path) {
1489 $fn->("The detected tools didn't match the platform\n");
1496 push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1498 if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
1500 push @{$config{cflags}}, "-mno-cygwin";
1501 push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1502 push @{$config{shared_ldflag}}, "-mno-cygwin";
1505 if ($target =~ /linux.*-mips/ && !$disabled{asm}
1506 && !grep { $_ =~ /-m(ips|arch=)/ } (@{$config{CFLAGS}})) {
1507 # minimally required architecture flags for assembly modules
1509 $value = '-mips2' if ($target =~ /mips32/);
1510 $value = '-mips3' if ($target =~ /mips64/);
1511 unshift @{$config{cflags}}, $value;
1512 unshift @{$config{cxxflags}}, $value if $config{CXX};
1515 # If threads aren't disabled, check how possible they are
1516 unless ($disabled{threads}) {
1517 if ($auto_threads) {
1518 # Enabled by default, disable it forcibly if unavailable
1519 if ($target{thread_scheme} eq "(unknown)") {
1520 disable("unavailable", 'threads');
1523 # The user chose to enable threads explicitly, let's see
1524 # if there's a chance that's possible
1525 if ($target{thread_scheme} eq "(unknown)") {
1526 # If the user asked for "threads" and we don't have internal
1527 # knowledge how to do it, [s]he is expected to provide any
1528 # system-dependent compiler options that are necessary. We
1529 # can't truly check that the given options are correct, but
1530 # we expect the user to know what [s]He is doing.
1531 if (!@{$config{CFLAGS}} && !@{$config{CPPDEFINES}}) {
1532 die "You asked for multi-threading support, but didn't\n"
1533 ,"provide any system-specific compiler options\n";
1539 # Find out if clang's sanitizers have been enabled with -fsanitize
1540 # flags and ensure that the corresponding %disabled elements area
1541 # removed to reflect that the sanitizers are indeed enabled.
1542 my %detected_sanitizers = ();
1543 foreach (grep /^-fsanitize=/, @{$config{CFLAGS} || []}) {
1544 (my $checks = $_) =~ s/^-fsanitize=//;
1545 foreach (split /,/, $checks) {
1546 my $d = { address => 'asan',
1547 undefined => 'ubsan',
1548 memory => 'msan' } -> {$_};
1549 next unless defined $d;
1551 $detected_sanitizers{$d} = 1;
1552 if (defined $disabled{$d}) {
1553 die "***** Conflict between disabling $d and enabling $_ sanitizer"
1554 if $disabled{$d} ne "default";
1555 delete $disabled{$d};
1560 # If threads still aren't disabled, add a C macro to ensure the source
1561 # code knows about it. Any other flag is taken care of by the configs.
1562 unless($disabled{threads}) {
1563 push @{$config{openssl_feature_defines}}, "OPENSSL_THREADS";
1566 if ($disabled{"unstable-qlog"}) {
1567 $disabled{"qlog"} = 1;
1570 my $no_shared_warn=0;
1571 if (($target{shared_target} // '') eq "")
1574 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1575 disable('no-shared-target', 'pic');
1578 if ($disabled{"dynamic-engine"}) {
1579 $config{dynamic_engines} = 0;
1581 $config{dynamic_engines} = 1;
1584 unless ($disabled{asan} || defined $detected_sanitizers{asan}) {
1585 push @{$config{cflags}}, "-fsanitize=address";
1588 unless ($disabled{ubsan} || defined $detected_sanitizers{ubsan}) {
1589 push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all", "-DPEDANTIC";
1592 unless ($disabled{msan} || defined $detected_sanitizers{msan}) {
1593 push @{$config{cflags}}, "-fsanitize=memory";
1596 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1597 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1598 push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
1599 push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
1605 # This saves the build files from having to check
1608 foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1609 shared_defines shared_includes shared_ldflag
1610 module_cflags module_cxxflags module_cppflags
1611 module_defines module_includes module_lflags))
1619 push @{$config{lib_defines}}, "OPENSSL_PIC";
1622 if ($target{sys_id} ne "")
1624 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1627 my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1628 my %predefined_CXX = $config{CXX}
1629 ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1632 unless ($disabled{asm}) {
1633 # big endian systems can use ELFv2 ABI
1634 if ($target eq "linux-ppc64" || $target eq "BSD-ppc64") {
1635 $target{perlasm_scheme} = "linux64v2" if ($predefined_C{_CALL_ELF} == 2);
1639 # Check for makedepend capabilities.
1640 if (!$disabled{makedepend}) {
1641 # If the attribute makedep_scheme is defined, then we assume that the
1642 # config target and its associated build file are programmed to deal
1644 # If makedep_scheme is undefined, we go looking for GCC compatible
1645 # dependency making, and if that's not available, we try to fall back
1647 if ($target{makedep_scheme}) {
1648 $config{makedep_scheme} = $target{makedep_scheme};
1649 # If the makedepcmd attribute is defined, copy it. If not, the
1650 # build files will have to fend for themselves.
1651 $config{makedepcmd} = $target{makedepcmd} if $target{makedepcmd};
1652 } elsif (($predefined_C{__GNUC__} // -1) >= 3
1653 && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
1654 # We know that GNU C version 3 and up as well as all clang
1655 # versions support dependency generation, but Xcode did not
1656 # handle $cc -M before clang support (but claims __GNUC__ = 3)
1657 $config{makedep_scheme} = 'gcc';
1659 # In all other cases, we look for 'makedepend', and set the
1660 # makedep_scheme value if we found it.
1661 $config{makedepcmd} = which('makedepend');
1662 $config{makedep_scheme} = 'makedepend' if $config{makedepcmd};
1665 # If no depend scheme is set, we disable makedepend
1666 disable('unavailable', 'makedepend') unless $config{makedep_scheme};
1669 if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
1670 # probe for -Wa,--noexecstack option...
1671 if ($predefined_C{__clang__}) {
1672 # clang has builtin assembler, which doesn't recognize --help,
1673 # but it apparently recognizes the option in question on all
1674 # supported platforms even when it's meaningless. In other words
1675 # probe would fail, but probed option always accepted...
1676 push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
1678 my $cc = $config{CROSS_COMPILE}.$config{CC};
1679 open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1681 if (m/--noexecstack/) {
1682 push @{$config{cflags}}, "-Wa,--noexecstack";
1687 unlink("null.$$.o");
1691 # Deal with bn_ops ###################################################
1694 my $def_int="unsigned int";
1695 $config{rc4_int} =$def_int;
1696 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1699 foreach (sort split(/\s+/,$target{bn_ops})) {
1700 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1701 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1702 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1703 ($config{b64l},$config{b64},$config{b32})
1704 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1705 ($config{b64l},$config{b64},$config{b32})
1706 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1707 ($config{b64l},$config{b64},$config{b32})
1708 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1710 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1713 $config{api} = $config{major} * 10000 + $config{minor} * 100
1714 unless $config{api};
1715 foreach (keys %$apitable) {
1716 $disabled{"deprecated-$_"} = "deprecation"
1717 if $disabled{deprecated} && $config{api} >= $apitable->{$_};
1720 disable(); # Run a cascade now
1722 # Hack cflags for better warnings (dev option) #######################
1724 # "Stringify" the C and C++ flags string. This permits it to be made part of
1725 # a string and works as well on command lines.
1726 $config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1727 @{$config{cflags}} ];
1728 $config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1729 @{$config{cxxflags}} ] if $config{CXX};
1731 $config{openssl_api_defines} = [
1732 "OPENSSL_CONFIGURED_API=".$config{api},
1735 my @strict_warnings_collection=();
1736 if ($strict_warnings)
1739 my $gccver = $predefined_C{__GNUC__} // -1;
1743 push @strict_warnings_collection, @gcc_devteam_warn;
1744 push @strict_warnings_collection, @clang_devteam_warn
1745 if (defined($predefined_C{__clang__}));
1747 elsif ($config{target} =~ /^VC-/)
1749 push @strict_warnings_collection, @cl_devteam_warn;
1753 warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike, or MSVC"
1757 $config{CFLAGS} = [ map { $_ eq '--ossl-strict-warnings'
1758 ? @strict_warnings_collection
1760 @{$config{CFLAGS}} ];
1762 unless ($disabled{afalgeng}) {
1763 $config{afalgeng}="";
1764 if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
1765 push @{$config{engdirs}}, "afalg";
1767 disable('not-linux', 'afalgeng');
1771 unless ($disabled{devcryptoeng}) {
1772 if ($target =~ m/^BSD/) {
1773 my $maxver = 5*100 + 7;
1774 my $sysstr = `uname -s`;
1775 my $verstr = `uname -r`;
1778 my ($ma, $mi, @rest) = split m|\.|, $verstr;
1779 my $ver = $ma*100 + $mi;
1780 if ($sysstr eq 'OpenBSD' && $ver >= $maxver) {
1781 disable('too-new-kernel', 'devcryptoeng');
1786 unless ($disabled{ktls}) {
1788 my $cc = $config{CROSS_COMPILE}.$config{CC};
1789 if ($target =~ m/^linux/) {
1790 system("printf '#include <sys/types.h>\n#include <linux/tls.h>' | $cc -E - >/dev/null 2>&1");
1792 disable('too-old-kernel', 'ktls');
1794 } elsif ($target =~ m/^BSD/) {
1795 system("printf '#include <sys/types.h>\n#include <sys/ktls.h>' | $cc -E - >/dev/null 2>&1");
1797 disable('too-old-freebsd', 'ktls');
1800 disable('not-linux-or-freebsd', 'ktls');
1804 unless ($disabled{winstore}) {
1805 unless ($target =~ /^(?:Cygwin|mingw|VC-|BC-)/) {
1806 disable('not-windows', 'winstore');
1810 push @{$config{openssl_other_defines}}, "OPENSSL_NO_KTLS" if ($disabled{ktls});
1812 # Get the extra flags used when building shared libraries and modules. We
1813 # do this late because some of them depend on %disabled.
1815 # Make the flags to build DSOs the same as for shared libraries unless they
1816 # are already defined
1817 $target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1818 $target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1819 $target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
1821 my $shared_info_pl =
1822 catfile(dirname($0), "Configurations", "shared-info.pl");
1823 my %shared_info = read_eval_file($shared_info_pl);
1824 push @{$target{_conf_fname_int}}, $shared_info_pl;
1825 my $si = $target{shared_target};
1826 while (ref $si ne "HASH") {
1827 last if ! defined $si;
1828 if (ref $si eq "CODE") {
1831 $si = $shared_info{$si};
1835 # Some of the 'shared_target' values don't have any entries in
1836 # %shared_info. That's perfectly fine, AS LONG AS the build file
1837 # template knows how to handle this. That is currently the case for
1840 # Just as above, copy certain shared_* attributes to the corresponding
1841 # module_ attribute unless the latter is already defined
1842 $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1843 $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1844 $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
1845 foreach (sort keys %$si) {
1846 $target{$_} = defined $target{$_}
1847 ? add($si->{$_})->($target{$_})
1853 # ALL MODIFICATIONS TO %disabled, %config and %target MUST BE DONE FROM HERE ON
1855 ######################################################################
1856 # Build up information for skipping certain directories depending on disabled
1857 # features, as well as setting up macros for disabled features.
1859 # This is a tentative database of directories to skip. Some entries may not
1860 # correspond to anything real, but that's ok, they will simply be ignored.
1861 # The actual processing of these entries is done in the build.info lookup
1862 # loop further down.
1864 # The key is a Unix formatted path in the source tree, the value is an index
1865 # into %disabled_info, so any existing path gets added to a corresponding
1866 # 'skipped' entry in there with the list of skipped directories.
1868 my %disabled_info = (); # For configdata.pm
1869 foreach my $what (sort keys %disabled) {
1870 # There are deprecated disablables that translate to themselves.
1871 # They cause disabling cascades, but should otherwise not register.
1872 next if $deprecated_disablables{$what};
1873 # The generated $disabled{"deprecated-x.y"} entries are special
1874 # and treated properly elsewhere
1875 next if $what =~ m|^deprecated-|;
1877 $config{options} .= " no-$what";
1879 if (!grep { $what eq $_ } ( 'buildtest-c++', 'fips', 'threads', 'shared',
1880 'module', 'pic', 'dynamic-engine', 'makedepend',
1881 'sse2', 'legacy' )) {
1882 (my $WHAT = uc $what) =~ s|-|_|g;
1883 my $skipdir = $what;
1885 # fix-up crypto/directory name(s)
1886 $skipdir = "ripemd" if $what eq "rmd160";
1887 $skipdir = "whrlpool" if $what eq "whirlpool";
1889 my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
1890 push @{$config{openssl_feature_defines}}, $macro;
1892 $skipdir{engines} = $what if $what eq 'engine';
1893 $skipdir{"crypto/$skipdir"} = $what
1894 unless $what eq 'async' || $what eq 'err' || $what eq 'dso';
1898 if ($disabled{"dynamic-engine"}) {
1899 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1901 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1904 # If we use the unified build, collect information from build.info files
1905 my %unified_info = ();
1907 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1908 if ($builder eq "unified") {
1909 use Text::Template 1.46;
1914 my $relativeto = shift || ".";
1915 my $no_mkpath = shift // 0;
1917 $dir = catdir($base,$dir) unless isabsolute($dir);
1919 # Make sure the directories we're building in exists
1920 mkpath($dir) unless $no_mkpath;
1922 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1923 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1930 my $relativeto = shift || ".";
1931 my $no_mkpath = shift // 0;
1933 $file = catfile($base,$file) unless isabsolute($file);
1935 my $d = dirname($file);
1936 my $f = basename($file);
1938 # Make sure the directories we're building in exists
1939 mkpath($d) unless $no_mkpath;
1941 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1942 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1946 # Store the name of the template file we will build the build file from
1947 # in %config. This may be useful for the build file itself.
1948 my @build_file_template_names =
1949 ( $builder_platform."-".$config{build_file}.".tmpl",
1950 $config{build_file}.".tmpl" );
1951 my @build_file_templates = ();
1953 # First, look in the user provided directory, if given
1954 if (defined env($local_config_envname)) {
1955 @build_file_templates =
1958 # VMS environment variables are logical names,
1959 # which can be used as is
1960 $local_config_envname . ':' . $_;
1962 catfile(env($local_config_envname), $_);
1965 @build_file_template_names;
1967 # Then, look in our standard directory
1968 push @build_file_templates,
1969 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir, 1) }
1970 @build_file_template_names );
1972 my $build_file_template;
1973 for $_ (@build_file_templates) {
1974 $build_file_template = $_;
1975 last if -f $build_file_template;
1977 $build_file_template = undef;
1979 if (!defined $build_file_template) {
1980 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1982 $config{build_file_templates}
1983 = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1985 $build_file_template ];
1987 my @build_dirs = ( [ ] ); # current directory
1989 $config{build_infos} = [ ];
1991 # We want to detect configdata.pm in the source tree, so we
1992 # don't use it if the build tree is different.
1993 my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir, 1);
1995 # Any source file that we recognise is placed in this hash table, with
1996 # the list of its intended destinations as value. When everything has
1997 # been collected, there's a routine that checks that these source files
1998 # exist, or if they are generated, that the generator exists.
1999 my %check_exist = ();
2000 my %check_generate = ();
2003 while (@build_dirs) {
2004 my @curd = @{shift @build_dirs};
2005 my $sourced = catdir($srcdir, @curd);
2006 my $buildd = catdir($blddir, @curd);
2008 my $unixdir = join('/', @curd);
2009 if (exists $skipdir{$unixdir}) {
2010 my $what = $skipdir{$unixdir};
2011 push @{$disabled_info{$what}->{skipped}}, catdir(@curd);
2017 my $f = 'build.info';
2018 # The basic things we're trying to build
2025 my %shared_sources = ();
2034 # Support for $variablename in build.info files.
2035 # Embedded perl code is the ultimate master, still. If its output
2036 # contains a dollar sign, it had better be escaped, or it will be
2037 # taken for a variable name prefix.
2039 # Variable name syntax
2040 my $variable_name_re = qr/(?P<VARIABLE>[[:alpha:]][[:alnum:]_]*)/;
2041 # Value modifier syntaxes
2042 my $variable_subst_re = qr/\/(?P<RE>(?:\\\/|.)*?)\/(?P<SUBST>.*?)/;
2043 # Variable reference
2044 my $variable_simple_re = qr/(?<!\\)\$${variable_name_re}/;
2045 my $variable_w_mod_re =
2046 qr/(?<!\\)\$\{${variable_name_re}(?P<MOD>(?:\\\/|.)*?)\}/;
2047 # Tie it all together
2048 my $variable_re = qr/${variable_simple_re}|${variable_w_mod_re}/;
2050 my $expand_variables = sub {
2052 my $value_rest = shift;
2054 if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2056 "DEBUG[\$expand_variables] Parsed '$value_rest' ...\n"
2059 while ($value_rest =~ /${variable_re}/) {
2060 # We must save important regexp values, because the next
2061 # regexp clears them
2063 my $variable_value = $variables{$+{VARIABLE}};
2068 # Process modifier expressions, if present
2070 if ($mod =~ /^${variable_subst_re}$/) {
2072 my $subst = $+{SUBST};
2074 $variable_value =~ s/\Q$re\E/$subst/g;
2076 if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2078 "DEBUG[\$expand_variables] ... and substituted ",
2079 "'$re' with '$subst'\n";
2084 $value .= $variable_value;
2086 if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
2088 "DEBUG[\$expand_variables] ... into: '$value$value_rest'\n";
2090 return $value . $value_rest;
2093 # Support for attributes in build.info files
2094 my %attributes = ();
2095 my $handle_attributes = sub {
2096 my $attr_str = shift;
2100 return unless defined $attr_str;
2102 my @a = tokenize($attr_str, qr|\s*,\s*|);
2103 foreach my $a (@a) {
2107 if ($a =~ m|^(!)?(.*?)\s* = \s*(.*?)$|x) {
2112 foreach my $g (@goals) {
2114 $$ref->{$g}->{$ak} = $av;
2116 delete $$ref->{$g}->{$ak};
2122 # Support for pushing values on multiple indexes of a given hash
2125 my $valueref = shift;
2126 my $index_str = shift; # May be undef or empty
2127 my $attrref = shift; # May be undef
2128 my $attr_str = shift;
2131 if (defined $index_str) {
2132 my @indexes = ( '' );
2133 if ($index_str !~ m|^\s*$|) {
2134 @indexes = tokenize($index_str);
2136 foreach (@indexes) {
2137 push @{$valueref->{$_}}, @values;
2138 if (defined $attrref) {
2139 $handle_attributes->($attr_str, \$$attrref->{$_},
2144 push @$valueref, @values;
2145 $handle_attributes->($attr_str, $attrref, @values)
2146 if defined $attrref;
2150 if ($buildinfo_debug) {
2151 print STDERR "DEBUG: Reading ",catfile($sourced, $f),"\n";
2153 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
2155 Text::Template->new(TYPE => 'FILE',
2156 SOURCE => catfile($sourced, $f),
2157 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
2158 die "Something went wrong with $sourced/$f: $!\n" unless $template;
2161 $template->fill_in(HASH => { config => \%config,
2163 disabled => \%disabled,
2164 withargs => \%withargs,
2165 builddir => abs2rel($buildd, $blddir),
2166 sourcedir => abs2rel($sourced, $blddir),
2167 buildtop => abs2rel($blddir, $blddir),
2168 sourcetop => abs2rel($srcdir, $blddir) },
2169 DELIMITERS => [ "{-", "-}" ]);
2171 # The top item of this stack has the following values
2172 # -2 positive already run and we found ELSE (following ELSIF should fail)
2173 # -1 positive already run (skip until ENDIF)
2174 # 0 negatives so far (if we're at a condition, check it)
2175 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
2176 # 2 positive ELSE (following ELSIF should fail)
2179 # A few useful generic regexps
2180 my $index_re = qr/\[\s*(?P<INDEX>(?:\\.|.)*?)\s*\]/;
2181 my $cond_re = qr/\[\s*(?P<COND>(?:\\.|.)*?)\s*\]/;
2182 my $attribs_re = qr/(?:\{\s*(?P<ATTRIBS>(?:\\.|.)*?)\s*\})?/;
2183 my $value_re = qr/(?P<VALUE>.*?)/;
2184 collect_information(
2185 collect_from_array([ @text ],
2186 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
2187 $l1 =~ s/\\$//; $l1.$l2 }),
2188 # Info we're looking for
2189 qr/^\s* IF ${cond_re} \s*$/x
2191 if (! @skip || $skip[$#skip] > 0) {
2192 push @skip, !! $expand_variables->($+{COND});
2197 qr/^\s* ELSIF ${cond_re} \s*$/x
2198 => sub { die "ELSIF out of scope" if ! @skip;
2199 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
2200 $skip[$#skip] = -1 if $skip[$#skip] != 0;
2201 $skip[$#skip] = !! $expand_variables->($+{COND})
2202 if $skip[$#skip] == 0; },
2204 => sub { die "ELSE out of scope" if ! @skip;
2205 $skip[$#skip] = -2 if $skip[$#skip] != 0;
2206 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
2207 qr/^\s* ENDIF \s*$/x
2208 => sub { die "ENDIF out of scope" if ! @skip;
2210 qr/^\s* ${variable_re} \s* = \s* ${value_re} \s* $/x
2212 if (!@skip || $skip[$#skip] > 0) {
2213 $variables{$+{VARIABLE}} = $expand_variables->($+{VALUE});
2216 qr/^\s* SUBDIRS \s* = \s* ${value_re} \s* $/x
2218 if (!@skip || $skip[$#skip] > 0) {
2219 foreach (tokenize($expand_variables->($+{VALUE}))) {
2220 push @build_dirs, [ @curd, splitdir($_, 1) ];
2224 qr/^\s* PROGRAMS ${attribs_re} \s* = \s* ${value_re} \s* $/x
2225 => sub { $push_to->(\@programs, undef,
2226 \$attributes{programs}, $+{ATTRIBS},
2227 tokenize($expand_variables->($+{VALUE})))
2228 if !@skip || $skip[$#skip] > 0; },
2229 qr/^\s* LIBS ${attribs_re} \s* = \s* ${value_re} \s* $/x
2230 => sub { $push_to->(\@libraries, undef,
2231 \$attributes{libraries}, $+{ATTRIBS},
2232 tokenize($expand_variables->($+{VALUE})))
2233 if !@skip || $skip[$#skip] > 0; },
2234 qr/^\s* MODULES ${attribs_re} \s* = \s* ${value_re} \s* $/x
2235 => sub { $push_to->(\@modules, undef,
2236 \$attributes{modules}, $+{ATTRIBS},
2237 tokenize($expand_variables->($+{VALUE})))
2238 if !@skip || $skip[$#skip] > 0; },
2239 qr/^\s* SCRIPTS ${attribs_re} \s* = \s* ${value_re} \s* $/x
2240 => sub { $push_to->(\@scripts, undef,
2241 \$attributes{scripts}, $+{ATTRIBS},
2242 tokenize($expand_variables->($+{VALUE})))
2243 if !@skip || $skip[$#skip] > 0; },
2244 qr/^\s* IMAGEDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2245 => sub { $push_to->(\%imagedocs, $expand_variables->($+{INDEX}),
2247 tokenize($expand_variables->($+{VALUE})))
2248 if !@skip || $skip[$#skip] > 0; },
2249 qr/^\s* HTMLDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2250 => sub { $push_to->(\%htmldocs, $expand_variables->($+{INDEX}),
2252 tokenize($expand_variables->($+{VALUE})))
2253 if !@skip || $skip[$#skip] > 0; },
2254 qr/^\s* MANDOCS ${index_re} \s* = \s* ${value_re} \s* $/x
2255 => sub { $push_to->(\%mandocs, $expand_variables->($+{INDEX}),
2257 tokenize($expand_variables->($+{VALUE})))
2258 if !@skip || $skip[$#skip] > 0; },
2259 qr/^\s* SOURCE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2260 => sub { $push_to->(\%sources, $expand_variables->($+{INDEX}),
2261 \$attributes{sources}, $+{ATTRIBS},
2262 tokenize($expand_variables->($+{VALUE})))
2263 if !@skip || $skip[$#skip] > 0; },
2264 qr/^\s* SHARED_SOURCE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2265 => sub { $push_to->(\%shared_sources, $expand_variables->($+{INDEX}),
2266 \$attributes{sources}, $+{ATTRIBS},
2267 tokenize($expand_variables->($+{VALUE})))
2268 if !@skip || $skip[$#skip] > 0; },
2269 qr/^\s* INCLUDE ${index_re} \s* = \s* ${value_re} \s* $/x
2270 => sub { $push_to->(\%includes, $expand_variables->($+{INDEX}),
2272 tokenize($expand_variables->($+{VALUE})))
2273 if !@skip || $skip[$#skip] > 0; },
2274 qr/^\s* DEFINE ${index_re} \s* = \s* ${value_re} \s* $/x
2275 => sub { $push_to->(\%defines, $expand_variables->($+{INDEX}),
2277 tokenize($expand_variables->($+{VALUE})))
2278 if !@skip || $skip[$#skip] > 0; },
2279 qr/^\s* DEPEND ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2280 => sub { $push_to->(\%depends, $expand_variables->($+{INDEX}),
2281 \$attributes{depends}, $+{ATTRIBS},
2282 tokenize($expand_variables->($+{VALUE})))
2283 if !@skip || $skip[$#skip] > 0; },
2284 qr/^\s* GENERATE ${index_re} ${attribs_re} \s* = \s* ${value_re} \s* $/x
2285 => sub { $push_to->(\%generate, $expand_variables->($+{INDEX}),
2286 \$attributes{generate}, $+{ATTRIBS},
2287 $expand_variables->($+{VALUE}))
2288 if !@skip || $skip[$#skip] > 0; },
2289 qr/^\s* (?:\#.*)? $/x => sub { },
2290 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
2292 if ($buildinfo_debug) {
2293 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
2294 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2298 if ($buildinfo_debug) {
2299 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2303 die "runaway IF?" if (@skip);
2305 if (grep { defined $attributes{modules}->{$_}->{engine} } keys %attributes
2306 and !$config{dynamic_engines}) {
2308 ENGINES can only be used if configured with 'dynamic-engine'.
2309 This is usually a fault in a build.info file.
2314 my %infos = ( programs => [ @programs ],
2315 libraries => [ @libraries ],
2316 modules => [ @modules ],
2317 scripts => [ @scripts ] );
2318 foreach my $k (keys %infos) {
2319 foreach (@{$infos{$k}}) {
2320 my $item = cleanfile($buildd, $_, $blddir);
2321 $unified_info{$k}->{$item} = 1;
2323 # Fix up associated attributes
2324 $unified_info{attributes}->{$k}->{$item} =
2325 $attributes{$k}->{$_}
2326 if defined $attributes{$k}->{$_};
2331 # Check that we haven't defined any library as both shared and
2332 # explicitly static. That is forbidden.
2334 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
2335 (my $l = $_) =~ s/\.a$//;
2336 push @doubles, $l if defined $unified_info{libraries}->{$l};
2338 die "these libraries are both explicitly static and shared:\n ",
2339 join(" ", @doubles), "\n"
2342 foreach (keys %sources) {
2344 my $ddest = cleanfile($buildd, $_, $blddir);
2345 foreach (@{$sources{$dest}}) {
2346 my $s = cleanfile($sourced, $_, $blddir, 1);
2348 # If it's generated or we simply don't find it in the source
2349 # tree, we assume it's in the build tree.
2350 if ($s eq $src_configdata || $generate{$_} || ! -f $s) {
2351 $s = cleanfile($buildd, $_, $blddir);
2354 # We recognise C++, C and asm files
2355 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2356 push @{$check_exist{$s}}, $ddest;
2357 $o =~ s/\.[csS]$/.o/; # C and assembler
2358 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2359 $o = cleanfile($buildd, $o, $blddir);
2360 $unified_info{sources}->{$ddest}->{$o} = -1;
2361 $unified_info{sources}->{$o}->{$s} = -1;
2362 } elsif ($s =~ /\.rc$/) {
2363 # We also recognise resource files
2364 push @{$check_exist{$s}}, $ddest;
2365 $o =~ s/\.rc$/.res/; # Resource configuration
2366 $o = cleanfile($buildd, $o, $blddir);
2367 $unified_info{sources}->{$ddest}->{$o} = -1;
2368 $unified_info{sources}->{$o}->{$s} = -1;
2370 push @{$check_exist{$s}}, $ddest;
2371 $unified_info{sources}->{$ddest}->{$s} = 1;
2373 # Fix up associated attributes
2375 $unified_info{attributes}->{sources}->{$ddest}->{$o} =
2376 $unified_info{attributes}->{sources}->{$o}->{$s} =
2377 $attributes{sources}->{$dest}->{$_}
2378 if defined $attributes{sources}->{$dest}->{$_};
2380 $unified_info{attributes}->{sources}->{$ddest}->{$s} =
2381 $attributes{sources}->{$dest}->{$_}
2382 if defined $attributes{sources}->{$dest}->{$_};
2387 foreach (keys %shared_sources) {
2389 my $ddest = cleanfile($buildd, $_, $blddir);
2390 foreach (@{$shared_sources{$dest}}) {
2391 my $s = cleanfile($sourced, $_, $blddir, 1);
2393 # If it's generated or we simply don't find it in the source
2394 # tree, we assume it's in the build tree.
2395 if ($s eq $src_configdata || $generate{$_} || ! -f $s) {
2396 $s = cleanfile($buildd, $_, $blddir);
2400 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2401 # We recognise C++, C and asm files
2402 push @{$check_exist{$s}}, $ddest;
2403 $o =~ s/\.[csS]$/.o/; # C and assembler
2404 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2405 $o = cleanfile($buildd, $o, $blddir);
2406 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2407 $unified_info{sources}->{$o}->{$s} = -1;
2408 } elsif ($s =~ /\.rc$/) {
2409 # We also recognise resource files
2410 push @{$check_exist{$s}}, $ddest;
2411 $o =~ s/\.rc$/.res/; # Resource configuration
2412 $o = cleanfile($buildd, $o, $blddir);
2413 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2414 $unified_info{sources}->{$o}->{$s} = -1;
2415 } elsif ($s =~ /\.ld$/) {
2416 # We also recognise linker scripts (or corresponding)
2417 # We know they are generated files
2418 push @{$check_exist{$s}}, $ddest;
2419 $o = cleanfile($buildd, $_, $blddir);
2420 $unified_info{shared_sources}->{$ddest}->{$o} = 1;
2422 die "unrecognised source file type for shared library: $s\n";
2424 # Fix up associated attributes
2426 $unified_info{attributes}->{shared_sources}->{$ddest}->{$o} =
2427 $unified_info{attributes}->{sources}->{$o}->{$s} =
2428 $attributes{sources}->{$dest}->{$_}
2429 if defined $attributes{sources}->{$dest}->{$_};
2431 $unified_info{attributes}->{shared_sources}->{$ddest}->{$o} =
2432 $attributes{sources}->{$dest}->{$_}
2433 if defined $attributes{sources}->{$dest}->{$_};
2438 foreach (keys %generate) {
2440 my $ddest = cleanfile($buildd, $_, $blddir);
2441 die "more than one generator for $dest: "
2442 ,join(" ", @{$generate{$_}}),"\n"
2443 if scalar @{$generate{$_}} > 1;
2444 my @generator = split /\s+/, $generate{$dest}->[0];
2445 my $gen = $generator[0];
2446 $generator[0] = cleanfile($sourced, $gen, $blddir, 1);
2448 # If the generator is itself generated, it's in the build tree
2449 if ($generate{$gen} || ! -f $generator[0]) {
2450 $generator[0] = cleanfile($buildd, $gen, $blddir);
2452 $check_generate{$ddest}->{$generator[0]}++;
2454 $unified_info{generate}->{$ddest} = [ @generator ];
2455 # Fix up associated attributes
2456 $unified_info{attributes}->{generate}->{$ddest} =
2457 $attributes{generate}->{$dest}->{$gen}
2458 if defined $attributes{generate}->{$dest}->{$gen};
2461 foreach (keys %depends) {
2465 if ($dest =~ /^\|(.*)\|$/) {
2466 # Collect the raw target
2467 $unified_info{targets}->{$1} = 1;
2469 } elsif ($dest eq '') {
2472 $ddest = cleanfile($sourced, $dest, $blddir, 1);
2474 # If the destination doesn't exist in source, it can only be
2475 # a generated file in the build tree.
2476 if ($ddest eq $src_configdata || ! -f $ddest) {
2477 $ddest = cleanfile($buildd, $dest, $blddir);
2480 foreach my $f (@{$depends{$dest}}) {
2481 # If the dependency destination is generated, dependencies
2482 # may have an extra syntax to separate the intended inclusion
2483 # directory from the module to be loaded: a | instead of a
2484 # / as directory separator.
2485 # Do note that this has to be handled in the build file
2487 # $i = inclusion path in source directory
2488 # $i2 = inclusion path in build directory
2489 # $m = module path (within the inclusion path)
2490 # $i = full module path in source directory
2491 # $i2 = full module path in build directory
2492 my $i; my $i2; my $m; my $d; my $d2;
2493 if ($unified_info{generate}->{$ddest}
2494 && $f =~ m/^(.*?)\|(.*)$/) {
2497 # We must be very careful to modify $i last
2498 $d = cleanfile($sourced, "$i/$m", $blddir, 1);
2499 $d2 = cleanfile($buildd, "$i/$m", $blddir);
2500 $i2 = cleandir($buildd, $i, $blddir);
2501 $i = cleandir($sourced, $i, $blddir, 1);
2503 $d = cleanfile($sourced, $f, $blddir, 1);
2504 $d2 = cleanfile($buildd, $f, $blddir);
2507 # If we know it's generated, or assume it is because we can't
2508 # find it in the source tree, we set file we depend on to be
2509 # in the build tree rather than the source tree.
2510 if ($d eq $src_configdata
2511 || (grep { $d2 eq $_ }
2512 keys %{$unified_info{generate}})
2518 # Put together the computed inclusion dir with the
2519 # original module name. Do note that we conserve the
2520 # Unixly path syntax for the module path.
2523 $unified_info{depends}->{$ddest}->{$d} = 1;
2525 # Fix up associated attributes
2526 $unified_info{attributes}->{depends}->{$ddest}->{$d} =
2527 $attributes{depends}->{$dest}->{$f}
2528 if defined $attributes{depends}->{$dest}->{$f};
2532 foreach (keys %includes) {
2534 my $ddest = cleanfile($sourced, $_, $blddir, 1);
2536 # If the destination doesn't exist in source, it can only be
2537 # a generated file in the build tree.
2538 if ($ddest eq $src_configdata || ! -f $ddest) {
2539 $ddest = cleanfile($buildd, $_, $blddir);
2541 foreach (@{$includes{$dest}}) {
2542 my $is = cleandir($sourced, $_, $blddir, 1);
2543 my $ib = cleandir($buildd, $_, $blddir);
2544 push @{$unified_info{includes}->{$ddest}->{source}}, $is
2545 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2546 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2547 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
2551 foreach my $dest (keys %defines) {
2555 $ddest = cleanfile($sourced, $dest, $blddir, 1);
2557 # If the destination doesn't exist in source, it can only
2558 # be a generated file in the build tree.
2560 $ddest = cleanfile($buildd, $dest, $blddir);
2563 foreach my $v (@{$defines{$dest}}) {
2564 $v =~ m|^([^=]*)(=.*)?$|;
2565 die "0 length macro name not permitted\n" if $1 eq "";
2567 die "$1 defined more than once\n"
2568 if defined $unified_info{defines}->{$ddest}->{$1};
2569 $unified_info{defines}->{$ddest}->{$1} = $2;
2571 die "$1 defined more than once\n"
2572 if grep { $v eq $_ } @{$config{defines}};
2573 push @{$config{defines}}, $v;
2578 foreach my $section (keys %imagedocs) {
2579 foreach (@{$imagedocs{$section}}) {
2580 my $imagedocs = cleanfile($buildd, $_, $blddir);
2581 $unified_info{imagedocs}->{$section}->{$imagedocs} = 1;
2585 foreach my $section (keys %htmldocs) {
2586 foreach (@{$htmldocs{$section}}) {
2587 my $htmldocs = cleanfile($buildd, $_, $blddir);
2588 $unified_info{htmldocs}->{$section}->{$htmldocs} = 1;
2592 foreach my $section (keys %mandocs) {
2593 foreach (@{$mandocs{$section}}) {
2594 my $mandocs = cleanfile($buildd, $_, $blddir);
2595 $unified_info{mandocs}->{$section}->{$mandocs} = 1;
2600 my $ordinals_text = join(', ', sort keys %ordinals);
2601 warn <<"EOF" if $ordinals_text;
2603 WARNING: ORDINALS were specified for $ordinals_text
2604 They are ignored and should be replaced with a combination of GENERATE,
2605 DEPEND and SHARED_SOURCE.
2608 # Check that each generated file is only generated once
2609 my $ambiguous_generation = 0;
2610 foreach (sort keys %check_generate) {
2611 my @generators = sort keys %{$check_generate{$_}};
2612 my $generators_txt = join(', ', @generators);
2613 if (scalar @generators > 1) {
2614 warn "$_ is GENERATEd by more than one generator ($generators_txt)\n";
2615 $ambiguous_generation++;
2617 if ($check_generate{$_}->{$generators[0]} > 1) {
2618 warn "INFO: $_ has more than one GENERATE declaration (same generator)\n"
2621 die "There are ambiguous source file generations\n"
2622 if $ambiguous_generation > 0;
2624 # All given source files should exist, or if generated, their
2625 # generator should exist. This loop ensures this is true.
2627 foreach my $orig (sort keys %check_exist) {
2628 foreach my $dest (@{$check_exist{$orig}}) {
2629 if ($orig ne $src_configdata) {
2630 if ($orig =~ /\.a$/) {
2631 # Static library names may be used as sources, so we
2632 # need to detect those and give them special treatment.
2633 unless (grep { $_ eq $orig }
2634 keys %{$unified_info{libraries}}) {
2635 warn "$orig is given as source for $dest, but no such library is built\n";
2639 # A source may be generated, and its generator may be
2640 # generated as well. We therefore loop to dig out the
2644 while (my @next = keys %{$check_generate{$gen}}) {
2649 if ($gen ne $orig) {
2651 warn "$orig is given as source for $dest, but its generator (leading to $gen) is missing\n";
2654 warn "$orig is given as source for $dest, but is missing\n";
2661 die "There are files missing\n" if $missing > 0;
2663 # Go through the sources of all libraries and check that the same basename
2664 # doesn't appear more than once. Some static library archivers depend on
2665 # them being unique.
2668 foreach my $prod (keys %{$unified_info{libraries}}) {
2670 map { keys %{$unified_info{sources}->{$_}} }
2671 keys %{$unified_info{sources}->{$prod}};
2674 # Count how many times a given each source basename
2675 # appears for each product.
2676 foreach my $src (@prod_sources) {
2677 $srccnt{basename $src}++;
2680 foreach my $src (keys %srccnt) {
2681 if ((my $cnt = $srccnt{$src}) > 1) {
2682 print STDERR "$src appears $cnt times for the product $prod\n";
2690 # Massage the result
2692 # If we depend on a header file or a perl module, add an inclusion of
2693 # its directory to allow smoothe inclusion
2694 foreach my $dest (keys %{$unified_info{depends}}) {
2695 next if $dest eq "";
2696 foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2697 next unless $d =~ /\.(h|pm)$/;
2698 # Take into account when a dependency uses the inclusion|module
2700 my $i = $d =~ m/\|/ ? $` : dirname($d);
2702 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2703 ? 'build' : 'source';
2704 push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2705 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
2709 # Go through all intermediary files and change their names to something that
2710 # reflects what they will be built for. Note that for some source files,
2711 # this leads to duplicate object files because they are used multiple times.
2712 # the goal is to rename all object files according to this scheme:
2713 # {productname}-{midfix}-{origobjname}.[o|res]
2714 # the {midfix} is a keyword indicating the type of product, which is mostly
2715 # valuable for libraries since they come in two forms.
2717 # This also reorganises the {sources} and {shared_sources} so that the
2718 # former only contains ALL object files that are supposed to end up in
2719 # static libraries and programs, while the latter contains ALL object files
2720 # that are supposed to end up in shared libraries and DSOs.
2721 # The main reason for having two different source structures is to allow
2722 # the same name to be used for the static and the shared variants of a
2725 # Take copies so we don't get interference from added stuff
2726 my %unified_copy = ();
2727 foreach (('sources', 'shared_sources')) {
2728 $unified_copy{$_} = { %{$unified_info{$_}} }
2729 if defined($unified_info{$_});
2730 delete $unified_info{$_};
2732 foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
2733 # $intent serves multi purposes:
2734 # - give a prefix for the new object files names
2735 # - in the case of libraries, rearrange the object files so static
2736 # libraries use the 'sources' structure exclusively, while shared
2737 # libraries use the 'shared_sources' structure exclusively.
2739 programs => { bin => { src => [ 'sources' ],
2740 dst => 'sources' } },
2741 libraries => { lib => { src => [ 'sources' ],
2743 shlib => { prodselect =>
2744 sub { grep !/\.a$/, @_ },
2747 dst => 'shared_sources' } },
2748 modules => { dso => { src => [ 'sources' ],
2749 dst => 'sources' } },
2750 scripts => { script => { src => [ 'sources' ],
2751 dst => 'sources' } }
2753 foreach my $kind (keys %$intent) {
2754 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2755 && $disabled{shared});
2757 my @src = @{$intent->{$kind}->{src}};
2758 my $dst = $intent->{$kind}->{dst};
2759 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2760 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2761 # %prod_sources has all applicable objects as keys, and
2762 # their corresponding sources as values
2764 map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2765 map { keys %{$unified_copy{$_}->{$prod}} }
2767 foreach (keys %prod_sources) {
2768 # Only affect object files and resource files,
2769 # the others simply get a new value
2770 # (+1 instead of -1)
2771 if ($_ =~ /\.(o|res)$/) {
2772 (my $prodname = $prod) =~ s|\.a$||;
2774 catfile(dirname($_),
2777 . '-' . basename($_));
2778 $unified_info{$dst}->{$prod}->{$newobj} = 1;
2779 foreach my $src (@{$prod_sources{$_}}) {
2780 $unified_info{sources}->{$newobj}->{$src} = 1;
2781 # Adjust source attributes
2782 my $attrs = $unified_info{attributes}->{sources};
2783 if (defined $attrs->{$prod}
2784 && defined $attrs->{$prod}->{$_}) {
2785 $attrs->{$prod}->{$newobj} =
2786 $attrs->{$prod}->{$_};
2787 delete $attrs->{$prod}->{$_};
2789 foreach my $objsrc (keys %{$attrs->{$_} // {}}) {
2790 $attrs->{$newobj}->{$objsrc} =
2791 $attrs->{$_}->{$objsrc};
2792 delete $attrs->{$_}->{$objsrc};
2795 # Adjust dependencies
2796 foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2797 $unified_info{depends}->{$_}->{$deps} = -1;
2798 $unified_info{depends}->{$newobj}->{$deps} = 1;
2801 foreach my $k (('source', 'build')) {
2803 defined($unified_info{includes}->{$_}->{$k});
2804 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2805 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2808 $unified_info{$dst}->{$prod}->{$_} = 1;
2816 # At this point, we have a number of sources with the value -1. They
2817 # aren't part of the local build and are probably meant for a different
2818 # platform, and can therefore be cleaned away. That happens when making
2819 # %unified_info more efficient below.
2821 ### Make unified_info a bit more efficient
2822 # One level structures
2823 foreach (("programs", "libraries", "modules", "scripts", "targets")) {
2824 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2826 # Two level structures
2827 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends",
2828 "imagedocs", "htmldocs", "mandocs")) {
2829 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
2832 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2833 keys %{$unified_info{$l1}->{$l2}};
2835 $unified_info{$l1}->{$l2} = [ @items ];
2837 delete $unified_info{$l1}->{$l2};
2842 foreach my $dest (sort keys %{$unified_info{defines}}) {
2843 $unified_info{defines}->{$dest}
2844 = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2845 sort keys %{$unified_info{defines}->{$dest}} ];
2848 foreach my $dest (sort keys %{$unified_info{includes}}) {
2849 if (defined($unified_info{includes}->{$dest}->{build})) {
2850 my @source_includes = ();
2851 @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2852 if defined($unified_info{includes}->{$dest}->{source});
2853 $unified_info{includes}->{$dest} =
2854 [ @{$unified_info{includes}->{$dest}->{build}} ];
2855 foreach my $inc (@source_includes) {
2856 push @{$unified_info{includes}->{$dest}}, $inc
2857 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2859 } elsif (defined($unified_info{includes}->{$dest}->{source})) {
2860 $unified_info{includes}->{$dest} =
2861 [ @{$unified_info{includes}->{$dest}->{source}} ];
2863 delete $unified_info{includes}->{$dest};
2867 # For convenience collect information regarding directories where
2868 # files are generated, those generated files and the end product
2869 # they end up in where applicable. Then, add build rules for those
2871 my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
2872 "dso" => [ @{$unified_info{modules}} ],
2873 "bin" => [ @{$unified_info{programs}} ],
2874 "script" => [ @{$unified_info{scripts}} ],
2875 "docs" => [ (map { @{$unified_info{imagedocs}->{$_} // []} }
2876 keys %{$unified_info{imagedocs} // {}}),
2877 (map { @{$unified_info{htmldocs}->{$_} // []} }
2878 keys %{$unified_info{htmldocs} // {}}),
2879 (map { @{$unified_info{mandocs}->{$_} // []} }
2880 keys %{$unified_info{mandocs} // {}}) ] );
2881 foreach my $type (sort keys %loopinfo) {
2882 foreach my $product (@{$loopinfo{$type}}) {
2884 my $pd = dirname($product);
2886 foreach (@{$unified_info{sources}->{$product} // []},
2887 @{$unified_info{shared_sources}->{$product} // []}) {
2888 my $d = dirname($_);
2890 # We don't want to create targets for source directories
2891 # when building out of source
2892 next if ($config{sourcedir} ne $config{builddir}
2893 && $d =~ m|^\Q$config{sourcedir}\E|);
2894 # We already have a "test" target, and the current directory
2895 # is just silly to make a target for
2896 next if $d eq "test" || $d eq ".";
2899 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2902 foreach (sort keys %dirs) {
2903 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2910 # For the schemes that need it, we provide the old *_obj configs
2911 # from the *_asm_obj ones
2912 foreach (grep /_(asm|aux)_src$/, keys %target) {
2914 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2915 $target{$obj} = $target{$src};
2916 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2917 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2920 # Write down our configuration where it fits #########################
2922 my %template_vars = (
2925 disablables => \@disablables,
2926 disablables_int => \@disablables_int,
2927 disabled => \%disabled,
2928 withargs => \%withargs,
2929 unified_info => \%unified_info,
2932 makevars => [ sort keys %user ],
2933 disabled_info => \%disabled_info,
2934 user_crossable => \@user_crossable,
2936 my $configdata_outname = 'configdata.pm';
2937 open CONFIGDATA, ">$configdata_outname.new"
2938 or die "Trying to create $configdata_outname.new: $!";
2939 my $configdata_tmplname = cleanfile($srcdir, "configdata.pm.in", $blddir, 1);
2940 my $configdata_tmpl =
2941 OpenSSL::Template->new(TYPE => 'FILE', SOURCE => $configdata_tmplname);
2942 $configdata_tmpl->fill_in(
2943 FILENAME => $configdata_tmplname,
2944 OUTPUT => \*CONFIGDATA,
2945 HASH => { %template_vars,
2947 'WARNING: do not edit!',
2948 "Generated by Configure from $configdata_tmplname",
2950 ) or die $Text::Template::ERROR;
2953 rename "$configdata_outname.new", $configdata_outname;
2954 if ($builder_platform eq 'unix') {
2955 my $mode = (0755 & ~umask);
2956 chmod $mode, 'configdata.pm'
2957 or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2959 print "Created $configdata_outname\n";
2961 print "Running $configdata_outname\n";
2962 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
2963 my $cmd = "$perlcmd $configdata_outname";
2964 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2968 $SIG{__DIE__} = $orig_death_handler;
2970 print <<"EOF" if ($disabled{threads} eq "unavailable");
2972 The library could not be configured for supporting multi-threaded
2973 applications as the compiler options required on this system are not known.
2974 See file INSTALL.md for details if you need multi-threading.
2977 print <<"EOF" if ($no_shared_warn);
2979 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2980 platform, so we will pretend you gave the option 'no-pic', which also disables
2981 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2982 or position independent code, please let us know (but please first make sure
2983 you have tried with a current version of OpenSSL).
2990 ######################################################################
2992 # Helpers and utility functions
2995 # Death handler, to print a helpful message in case of failure #######
2998 die @_ if $^S; # To prevent the added message in eval blocks
2999 my $build_file = $config{build_file} // "build file";
3000 my @message = ( <<"_____", @_ );
3002 Failure! $build_file wasn't produced.
3003 Please read INSTALL.md and associated NOTES-* files. You may also have to
3004 look over your available compiler tool chain or change your configuration.
3008 # Dying is terminal, so it's ok to reset the signal handler here.
3009 $SIG{__DIE__} = $orig_death_handler;
3013 # Configuration file reading #########################################
3015 # Note: All of the helper functions are for lazy evaluation. They all
3016 # return a CODE ref, which will return the intended value when evaluated.
3017 # Thus, whenever there's mention of a returned value, it's about that
3020 # Helper function to implement conditional value variants, with a default
3021 # plus additional values based on the value of $config{build_type}.
3022 # Arguments are given in hash table form:
3024 # picker(default => "Basic string: ",
3026 # release => "release")
3028 # When configuring with --debug, the resulting string will be
3029 # "Basic string: debug", and when not, it will be "Basic string: release"
3031 # This can be used to create variants of sets of flags according to the
3034 # cflags => picker(default => "-Wall",
3035 # debug => "-g -O0",
3040 return sub { add($opts{default} || (),
3041 $opts{$config{build_type}} || ())->(); }
3044 # Helper function to combine several values of different types into one.
3045 # This is useful if you want to combine a string with the result of a
3046 # lazy function, such as:
3048 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
3052 return sub { add(@stuff)->(); }
3055 # Helper function to implement conditional values depending on the value
3056 # of $disabled{threads}. Can be used as follows:
3058 # cflags => combine("-Wall", threads("-pthread"))
3062 return sub { add($disabled{threads} ? () : @flags)->(); }
3067 return sub { add($disabled{shared} ? () : @flags)->(); }
3070 our $add_called = 0;
3071 # Helper function to implement adding values to already existing configuration
3072 # values. It handles elements that are ARRAYs, CODEs and scalars
3074 my $separator = shift;
3076 # If there's any ARRAY in the collection of values OR the separator
3077 # is undef, we will return an ARRAY of combined values, otherwise a
3078 # string of joined values with $separator as the separator.
3079 my $found_array = !defined($separator);
3084 while (ref($res) eq "CODE") {
3087 if (defined($res)) {
3088 if (ref($res) eq "ARRAY") {
3104 join($separator, grep { defined($_) && $_ ne "" } @values);
3108 my $separator = " ";
3109 if (ref($_[$#_]) eq "HASH") {
3111 $separator = $opts->{separator};
3114 sub { _add($separator, @x, @_) };
3117 my $separator = " ";
3118 if (ref($_[$#_]) eq "HASH") {
3120 $separator = $opts->{separator};
3123 sub { _add($separator, @_, @x) };
3126 sub read_eval_file {
3131 open F, "< $fname" or die "Can't open '$fname': $!\n";
3140 @result = ( eval $content );
3143 return wantarray ? @result : $result[0];
3146 # configuration reader, evaluates the input file as a perl script and expects
3147 # it to fill %targets with target configurations. Those are then added to
3154 # Protect certain tables from tampering
3157 %targets = read_eval_file($fname);
3159 my %preexisting = ();
3160 foreach (sort keys %targets) {
3161 $preexisting{$_} = 1 if $table{$_};
3164 The following config targets from $fname
3165 shadow pre-existing config targets with the same name:
3167 map { " $_\n" } sort keys %preexisting
3171 # For each target, check that it's configured with a hash table.
3172 foreach (keys %targets) {
3173 if (ref($targets{$_}) ne "HASH") {
3174 if (ref($targets{$_}) eq "") {
3175 warn "Deprecated target configuration for $_, ignoring...\n";
3177 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
3179 delete $targets{$_};
3181 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
3185 %table = (%table, %targets);
3189 # configuration resolver. Will only resolve all the lazy evaluation
3190 # codeblocks for the chosen target and all those it inherits from,
3192 sub resolve_config {
3194 my @breadcrumbs = @_;
3196 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
3198 if (grep { $_ eq $target } @breadcrumbs) {
3199 die "inherit_from loop! target backtrace:\n "
3200 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
3203 if (!defined($table{$target})) {
3204 warn "Warning! target $target doesn't exist!\n";
3207 # Recurse through all inheritances. They will be resolved on the
3208 # fly, so when this operation is done, they will all just be a
3209 # bunch of attributes with string values.
3210 # What we get here, though, are keys with references to lists of
3211 # the combined values of them all. We will deal with lists after
3212 # this stage is done.
3213 my %combined_inheritance = ();
3214 if ($table{$target}->{inherit_from}) {
3216 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
3217 foreach (@inherit_from) {
3218 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
3220 # 'template' is a marker that's considered private to
3221 # the config that had it.
3222 delete $inherited_config{template};
3224 foreach (keys %inherited_config) {
3225 if (!$combined_inheritance{$_}) {
3226 $combined_inheritance{$_} = [];
3228 push @{$combined_inheritance{$_}}, $inherited_config{$_};
3233 # We won't need inherit_from in this target any more, since we've
3234 # resolved all the inheritances that lead to this
3235 delete $table{$target}->{inherit_from};
3237 # Now is the time to deal with those lists. Here's the place to
3238 # decide what shall be done with those lists, all based on the
3239 # values of the target we're currently dealing with.
3240 # - If a value is a coderef, it will be executed with the list of
3241 # inherited values as arguments.
3242 # - If the corresponding key doesn't have a value at all or is the
3243 # empty string, the inherited value list will be run through the
3244 # default combiner (below), and the result becomes this target's
3246 # - Otherwise, this target's value is assumed to be a string that
3247 # will simply override the inherited list of values.
3248 my $default_combiner = add();
3251 map { $_ => 1 } (keys %combined_inheritance,
3252 keys %{$table{$target}});
3254 sub process_values {
3256 my $inherited = shift; # Always a [ list ]
3262 while(ref($object) eq "CODE") {
3263 $object = $object->(@$inherited);
3265 if (!defined($object)) {
3268 elsif (ref($object) eq "ARRAY") {
3269 local $add_called; # To make sure recursive calls don't affect it
3270 return [ map { process_values($_, $inherited, $target, $entry) }
3272 } elsif (ref($object) eq "") {
3275 die "cannot handle reference type ",ref($object)
3276 ," found in target ",$target," -> ",$entry,"\n";
3280 foreach my $key (sort keys %all_keys) {
3281 my $previous = $combined_inheritance{$key};
3283 # Current target doesn't have a value for the current key?
3284 # Assign it the default combiner, the rest of this loop body
3285 # will handle it just like any other coderef.
3286 if (!exists $table{$target}->{$key}) {
3287 $table{$target}->{$key} = $default_combiner;
3290 $table{$target}->{$key} = process_values($table{$target}->{$key},
3291 $combined_inheritance{$key},
3293 unless(defined($table{$target}->{$key})) {
3294 delete $table{$target}->{$key};
3296 # if ($extra_checks &&
3297 # $previous && !($add_called || $previous ~~ $table{$target}->{$key})) {
3298 # warn "$key got replaced in $target\n";
3302 # Finally done, return the result.
3303 return %{$table{$target}};
3308 print STDERR $usage;
3309 print STDERR "\npick os/compiler from:\n";
3313 foreach $i (sort keys %table)
3315 next if $table{$i}->{template};
3316 next if $i =~ /^debug/;
3317 $k += length($i) + 1;
3323 print STDERR $i . " ";
3325 foreach $i (sort keys %table)
3327 next if $table{$i}->{template};
3328 next if $i !~ /^debug/;
3329 $k += length($i) + 1;
3335 print STDERR $i . " ";
3340 sub compiler_predefined {
3344 return () if $^O eq 'VMS';
3346 die 'compiler_predefined called without a compiler command'
3349 if (! $predefined{$cc}) {
3351 $predefined{$cc} = {};
3353 # collect compiler pre-defines from gcc or gcc-alike...
3354 open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
3355 while (my $l = <PIPE>) {
3356 $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
3357 $predefined{$cc}->{$1} = $2 // '';
3362 return %{$predefined{$cc}};
3369 if (eval { require IPC::Cmd; 1; }) {
3371 return scalar IPC::Cmd::can_run($name);
3373 # if there is $directories component in splitpath,
3374 # then it's not something to test with $PATH...
3375 return $name if (File::Spec->splitpath($name))[1];
3377 foreach (File::Spec->path()) {
3378 my $fullpath = catfile($_, "$name$target{exe_extension}");
3379 if (-f $fullpath and -x $fullpath) {
3391 unless ($opts{cacheonly}) {
3392 # Note that if $ENV{$name} doesn't exist or is undefined,
3393 # $config{perlenv}->{$name} will be created with the value
3394 # undef. This is intentional.
3396 $config{perlenv}->{$name} = $ENV{$name}
3397 if ! exists $config{perlenv}->{$name};
3399 return $config{perlenv}->{$name};
3402 # Configuration printer ##############################################
3404 sub print_table_entry
3406 local $now_printing = shift;
3407 my %target = resolve_config($now_printing);
3410 # Don't print the templates
3411 return if $target{template};
3456 if ($type eq "TABLE") {
3458 print "*** $now_printing\n";
3459 foreach (@sequence) {
3460 if (ref($target{$_}) eq "ARRAY") {
3461 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3463 printf "\$%-12s = %s\n", $_, $target{$_};
3466 } elsif ($type eq "HASH") {
3468 length((sort { length($a) <=> length($b) } @sequence)[-1]);
3469 print " '$now_printing' => {\n";
3470 foreach (@sequence) {
3472 if (ref($target{$_}) eq "ARRAY") {
3473 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3475 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3483 # Utility routines ###################################################
3485 # On VMS, if the given file is a logical name, File::Spec::Functions
3486 # will consider it an absolute path. There are cases when we want a
3487 # purely syntactic check without checking the environment.
3491 # On non-platforms, we just use file_name_is_absolute().
3492 return file_name_is_absolute($file) unless $^O eq "VMS";
3494 # If the file spec includes a device or a directory spec,
3495 # file_name_is_absolute() is perfectly safe.
3496 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3498 # Here, we know the given file spec isn't absolute
3502 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
3503 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
3504 # realpath() requires that at least all path components except the last is an
3505 # existing directory. On VMS, the last component of the directory spec must
3510 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
3511 # will return the volume name for the device, no matter what. Also,
3512 # it will return an incorrect directory spec if the argument is a
3513 # directory that doesn't exist.
3515 return rel2abs($dir);
3518 # We use realpath() on Unix, since no other will properly clean out
3520 use Cwd qw/realpath/;
3522 return realpath($dir);
3525 # Check if all paths are one and the same, using stat. They must both exist
3526 # We need this for the cases when File::Spec doesn't detect case insensitivity
3527 # (File::Spec::Unix assumes case sensitivity)
3529 die "samedir expects two arguments\n" unless scalar @_ == 2;
3531 my @stat0 = stat($_[0]); # First argument
3532 my @stat1 = stat($_[1]); # Second argument
3534 die "Couldn't stat $_[0]" unless @stat0;
3535 die "Couldn't stat $_[1]" unless @stat1;
3537 # Compare device number
3538 return 0 unless ($stat0[0] == $stat1[0]);
3539 # Compare "inode". The perl manual recommends comparing as
3540 # string rather than as number.
3541 return 0 unless ($stat0[1] eq $stat1[1]);
3543 return 1; # All the same
3548 perl => sub { my $x = shift;
3549 $x =~ s/([\\\$\@"])/\\$1/g;
3550 return '"'.$x.'"'; },
3551 maybeshell => sub { my $x = shift;
3552 (my $y = $x) =~ s/([\\\"])/\\$1/g;
3553 if ($x ne $y || $x =~ m|\s|) {
3562 defined($processors{$for}) ? $processors{$for} : sub { shift; };
3564 return map { $processor->($_); } @_;
3567 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
3568 # $filename is a file name to read from
3569 # $line_concat_cond_re is a regexp detecting a line continuation ending
3570 # $line_concat is a CODEref that takes care of concatenating two lines
3571 sub collect_from_file {
3572 my $filename = shift;
3573 my $line_concat_cond_re = shift;
3574 my $line_concat = shift;
3576 open my $fh, $filename || die "unable to read $filename: $!\n";
3578 my $saved_line = "";
3582 if (defined $line_concat) {
3583 $_ = $line_concat->($saved_line, $_);
3586 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3592 die "$filename ending with continuation line\n" if $_;
3598 # collect_from_array($array, $line_concat_cond_re, $line_concat)
3599 # $array is an ARRAYref of lines
3600 # $line_concat_cond_re is a regexp detecting a line continuation ending
3601 # $line_concat is a CODEref that takes care of concatenating two lines
3602 sub collect_from_array {
3604 my $line_concat_cond_re = shift;
3605 my $line_concat = shift;
3606 my @array = (@$array);
3609 my $saved_line = "";
3611 while (defined($_ = shift @array)) {
3613 if (defined $line_concat) {
3614 $_ = $line_concat->($saved_line, $_);
3617 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3623 die "input text ending with continuation line\n" if $_;
3628 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3629 # $lineiterator is a CODEref that delivers one line at a time.
3630 # All following arguments are regex/CODEref pairs, where the regexp detects a
3631 # line and the CODEref does something with the result of the regexp.
3632 sub collect_information {
3633 my $lineiterator = shift;
3634 my %collectors = @_;
3636 while(defined($_ = $lineiterator->())) {
3639 if ($collectors{"BEFORE"}) {
3640 $collectors{"BEFORE"}->($_);
3642 foreach my $re (keys %collectors) {
3643 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
3644 $collectors{$re}->($lineiterator);
3648 if ($collectors{"OTHERWISE"}) {
3649 $collectors{"OTHERWISE"}->($lineiterator, $_)
3650 unless $found || !defined $collectors{"OTHERWISE"};
3652 if ($collectors{"AFTER"}) {
3653 $collectors{"AFTER"}->($_);
3659 # tokenize($line,$separator)
3660 # $line is a line of text to split up into tokens
3661 # $separator [optional] is a regular expression that separates the tokens,
3662 # the default being spaces. Do not use quotes of any kind as separators,
3663 # that will give undefined results.
3664 # Returns a list of tokens.
3666 # Tokens are divided by separator (spaces by default). If the tokens include
3667 # the separators, they have to be quoted with single or double quotes.
3668 # Double quotes inside a double quoted token must be escaped. Escaping is done
3670 # Basically, the same quoting rules apply for " and ' as in any
3673 my $line = my $debug_line = shift;
3674 my $separator = shift // qr|\s+|;
3677 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3678 print STDERR "DEBUG[tokenize]: \$separator = $separator\n";
3681 while ($line =~ s|^${separator}||, $line ne "") {
3684 $line =~ m/^(.*?)(${separator}|"|'|$)/;
3688 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3692 } elsif ($line =~ m/^'([^']*)'/) {
3697 push @result, $token;
3700 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3701 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3702 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";