3 # Copyright 2016-2018 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;
24 # see INSTALL for instructions.
26 my $orig_death_handler = $SIG{__DIE__};
27 $SIG{__DIE__} = \&death_handler;
29 my $usage="Usage: Configure [no-<cipher> ...] [enable-<cipher> ...] [-Dxxx] [-lxxx] [-Lxxx] [-fxxx] [-Kxxx] [no-hw-xxx|no-hw] [[no-]threads] [[no-]shared] [[no-]zlib|zlib-dynamic] [no-asm] [no-egd] [sctp] [386] [--prefix=DIR] [--openssldir=OPENSSLDIR] [--with-xxx[=vvv]] [--config=FILE] os/compiler[:flags]\n";
33 # --config add the given configuration file, which will be read after
34 # any "Configurations*" files that are found in the same
35 # directory as this script.
36 # --prefix prefix for the OpenSSL installation, which includes the
37 # directories bin, lib, include, share/man, share/doc/openssl
38 # This becomes the value of INSTALLTOP in Makefile
39 # (Default: /usr/local)
40 # --openssldir OpenSSL data area, such as openssl.cnf, certificates and keys.
41 # If it's a relative directory, it will be added on the directory
42 # given with --prefix.
43 # This becomes the value of OPENSSLDIR in Makefile and in C.
44 # (Default: PREFIX/ssl)
46 # --cross-compile-prefix Add specified prefix to binutils components.
48 # --api One of 0.9.8, 1.0.0, 1.0.1, 1.0.2, 1.1.0, 1.1.1, or 3.0
49 # Define the public APIs as they were for that version
50 # including patch releases. If 'no-deprecated' is also
51 # given, do not compile support for interfaces deprecated
52 # up to and including the specified OpenSSL version.
54 # no-hw-xxx do not compile support for specific crypto hardware.
55 # Generic OpenSSL-style methods relating to this support
56 # are always compiled but return NULL if the hardware
57 # support isn't compiled.
58 # no-hw do not compile support for any crypto hardware.
59 # [no-]threads [don't] try to create a library that is suitable for
60 # multithreaded applications (default is "threads" if we
62 # [no-]shared [don't] try to create shared libraries when supported.
63 # [no-]pic [don't] try to build position independent code when supported.
64 # If disabled, it also disables shared and dynamic-engine.
65 # no-asm do not use assembler
66 # no-egd do not compile support for the entropy-gathering daemon APIs
67 # [no-]zlib [don't] compile support for zlib compression.
68 # zlib-dynamic Like "zlib", but the zlib library is expected to be a shared
69 # library and will be loaded in run-time by the OpenSSL library.
70 # sctp include SCTP support
71 # no-uplink Don't build support for UPLINK interface.
72 # enable-weak-ssl-ciphers
73 # Enable weak ciphers that are disabled by default.
74 # 386 generate 80386 code in assembly modules
75 # no-sse2 disables IA-32 SSE2 code in assembly modules, the above
76 # mentioned '386' option implies this one
77 # no-<cipher> build without specified algorithm (rsa, idea, rc5, ...)
78 # -<xxx> +<xxx> All options which are unknown to the 'Configure' script are
79 # /<xxx> passed through to the compiler. Unix-style options beginning
80 # with a '-' or '+' are recognized, as well as Windows-style
81 # options beginning with a '/'. If the option contains arguments
82 # separated by spaces, then the URL-style notation %20 can be
83 # used for the space character in order to avoid having to quote
84 # the option. For example, -opt%20arg gets expanded to -opt arg.
85 # In fact, any ASCII character can be encoded as %xx using its
86 # hexadecimal encoding.
87 # -static while -static is also a pass-through compiler option (and
88 # as such is limited to environments where it's actually
89 # meaningful), it triggers a number configuration options,
90 # namely no-pic, no-shared and no-threads. It is
91 # argued that the only reason to produce statically linked
92 # binaries (and in context it means executables linked with
93 # -static flag, and not just executables linked with static
94 # libcrypto.a) is to eliminate dependency on specific run-time,
95 # a.k.a. libc version. The mentioned config options are meant
96 # to achieve just that. Unfortunately on Linux it's impossible
97 # to eliminate the dependency completely for openssl executable
98 # because of getaddrinfo and gethostbyname calls, which can
99 # invoke dynamically loadable library facility anyway to meet
100 # the lookup requests. For this reason on Linux statically
101 # linked openssl executable has rather debugging value than
102 # production quality.
104 # BN_LLONG use the type 'long long' in crypto/bn/bn.h
105 # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h
106 # Following are set automatically by this script
108 # MD5_ASM use some extra md5 assembler,
109 # SHA1_ASM use some extra sha1 assembler, must define L_ENDIAN for x86
110 # RMD160_ASM use some extra ripemd160 assembler,
111 # SHA256_ASM sha256_block is implemented in assembler
112 # SHA512_ASM sha512_block is implemented in assembler
113 # AES_ASM AES_[en|de]crypt is implemented in assembler
115 # Minimum warning options... any contributions to OpenSSL should at least
116 # get past these. Note that we only use these with C compilers, not with
119 # DEBUG_UNUSED enables __owur (warn unused result) checks.
120 # -DPEDANTIC complements -pedantic and is meant to mask code that
121 # is not strictly standard-compliant and/or implementation-specific,
122 # e.g. inline assembly, disregards to alignment requirements, such
123 # that -pedantic would complain about. Incidentally -DPEDANTIC has
124 # to be used even in sanitized builds, because sanitizer too is
125 # supposed to and does take notice of non-standard behaviour. Then
126 # -pedantic with pre-C9x compiler would also complain about 'long
127 # long' not being supported. As 64-bit algorithms are common now,
128 # it grew impossible to resolve this without sizeable additional
129 # code, so we just tell compiler to be pedantic about everything
130 # but 'long long' type.
132 my @gcc_devteam_warn = qw(
134 -DPEDANTIC -pedantic -Wno-long-long
137 -Wno-unused-parameter
138 -Wno-missing-field-initializers
150 # These are used in addition to $gcc_devteam_warn when the compiler is clang.
151 # TODO(openssl-team): fix problems and investigate if (at least) the
152 # following warnings can also be enabled:
154 # -Wunreachable-code -- no, too ugly/compiler-specific
155 # -Wlanguage-extension-token -- no, we use asm()
156 # -Wunused-macros -- no, too tricky for BN and _XOPEN_SOURCE etc
157 # -Wextended-offsetof -- no, needed in CMS ASN1 code
158 my @clang_devteam_warn = qw(
159 -Wno-unknown-warning-option
161 -Wno-parentheses-equality
162 -Wno-language-extension-token
163 -Wno-extended-offsetof
164 -Wconditional-uninitialized
165 -Wincompatible-pointer-types-discards-qualifiers
166 -Wmissing-variable-declarations
169 my @cl_devteam_warn = qw(
173 my $strict_warnings = 0;
175 # As for $BSDthreads. Idea is to maintain "collective" set of flags,
176 # which would cover all BSD flavors. -pthread applies to them all,
177 # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD
178 # -lc_r, which is sufficient. FreeBSD 4.x expands it as -lc_r,
179 # which has to be accompanied by explicit -D_THREAD_SAFE and
180 # sometimes -D_REENTRANT. FreeBSD 5.x expands it as -lc_r, which
181 # seems to be sufficient?
182 our $BSDthreads="-pthread -D_THREAD_SAFE -D_REENTRANT";
185 # API compatibility name to version number mapping.
188 # This table expresses when API additions or changes can occur.
189 # The numbering used changes from 3.0 and on because we updated
190 # (solidified) our version numbering scheme at that point.
192 # From 3.0 and on, we internalise the given version number in dedcimal
193 # as MAJOR * 10000 + MINOR * 100 + 0
197 # Note that before 3.0, we didn't have the same version number scheme.
198 # Still, the numbering we use here covers what we need.
210 our $now_printing; # set to current entry's name in print_table_entry
211 # (todo: right thing would be to encapsulate name
212 # into %target [class] and make print_table_entry
215 # Forward declarations ###############################################
217 # read_config(filename)
219 # Reads a configuration file and populates %table with the contents
220 # (which the configuration file places in %targets).
223 # resolve_config(target)
225 # Resolves all the late evaluations, inheritances and so on for the
226 # chosen target and any target it inherits from.
230 # Information collection #############################################
232 # Unified build supports separate build dir
233 my $srcdir = catdir(absolutedir(dirname($0))); # catdir ensures local syntax
234 my $blddir = catdir(absolutedir(".")); # catdir ensures local syntax
235 my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl"));
237 my $local_config_envname = 'OPENSSL_LOCAL_CONFIG_DIR';
239 $config{sourcedir} = abs2rel($srcdir);
240 $config{builddir} = abs2rel($blddir);
242 # Collect reconfiguration information if needed
245 if (grep /^reconf(igure)?$/, @argvcopy) {
246 die "reconfiguring with other arguments present isn't supported"
247 if scalar @argvcopy > 1;
248 if (-f "./configdata.pm") {
249 my $file = "./configdata.pm";
250 unless (my $return = do $file) {
251 die "couldn't parse $file: $@" if $@;
252 die "couldn't do $file: $!" unless defined $return;
253 die "couldn't run $file" unless $return;
256 @argvcopy = defined($configdata::config{perlargv}) ?
257 @{$configdata::config{perlargv}} : ();
258 die "Incorrect data to reconfigure, please do a normal configuration\n"
259 if (grep(/^reconf/,@argvcopy));
260 $config{perlenv} = $configdata::config{perlenv} // {};
262 die "Insufficient data to reconfigure, please do a normal configuration\n";
266 $config{perlargv} = [ @argvcopy ];
268 # Collect version numbers
272 collect_from_file(catfile($srcdir,'VERSION')),
273 qr/\s*(\w+)\s*=\s*(.*?)\s*$/ =>
275 # Only define it if there is a value at all
276 $version{uc $1} = $2 if $2 ne '';
279 sub { die "Something wrong with this line:\n$_\nin $srcdir/VERSION" },
282 $config{major} = $version{MAJOR} // 'unknown';
283 $config{minor} = $version{MINOR} // 'unknown';
284 $config{patch} = $version{PATCH} // 'unknown';
285 $config{prerelease} =
286 defined $version{PRE_RELEASE_TAG} ? "-$version{PRE_RELEASE_TAG}" : '';
287 $config{build_metadata} =
288 defined $version{BUILD_METADATA} ? "+$version{BUILD_METADATA}" : '';
289 $config{shlib_version} = $version{SHLIB_VERSION} // 'unknown';
290 $config{release_date} = $version{RELEASE_DATE} // 'xx XXX xxxx';
292 $config{version} = "$config{major}.$config{minor}.$config{patch}";
293 $config{full_version} = "$config{version}$config{prerelease}$config{build_metadata}";
295 die "erroneous version information in VERSION: ",
296 "$config{version}, $config{shlib_version}\n"
297 unless (defined $version{MAJOR}
298 && defined $version{MINOR}
299 && defined $version{PATCH}
300 && defined $version{SHLIB_VERSION});
302 # Collect target configurations
304 my $pattern = catfile(dirname($0), "Configurations", "*.conf");
305 foreach (sort glob($pattern)) {
309 if (defined env($local_config_envname)) {
311 # VMS environment variables are logical names,
312 # which can be used as is
313 $pattern = $local_config_envname . ':' . '*.conf';
315 $pattern = catfile(env($local_config_envname), '*.conf');
318 foreach (sort glob($pattern)) {
323 # Save away perl command information
324 $config{perl_cmd} = $^X;
325 $config{perl_version} = $Config{version};
326 $config{perl_archname} = $Config{archname};
329 $config{openssldir}="";
330 $config{processor}="";
332 my $auto_threads=1; # enable threads automatically? true by default
335 # Known TLS and DTLS protocols
336 my @tls = qw(ssl3 tls1 tls1_1 tls1_2 tls1_3);
337 my @dtls = qw(dtls1 dtls1_2);
339 # Explicitly known options that are possible to disable. They can
340 # be regexps, and will be used like this: /^no-${option}$/
341 # For developers: keep it sorted alphabetically
378 "ec_nistp_64_gcc_128",
444 foreach my $proto ((@tls, @dtls))
446 push(@disablables, $proto);
447 push(@disablables, "$proto-method") unless $proto eq "tls1_3";
450 # Internal disablables, for aliasing purposes. They serve no special
451 # purpose here, but allow scripts to get to know them through configdata.pm,
452 # where these are merged with @disablables.
453 # The actual aliasing mechanism is done via %disable_cascades
454 my @disablables_int = qw(
458 my %deprecated_disablables = (
460 "buf-freelists" => undef,
461 "crypto-mdebug-backtrace" => undef,
462 "hw" => "hw", # causes cascade, but no macro
463 "hw-padlock" => "padlockeng",
464 "ripemd" => "rmd160",
465 "ui" => "ui-console",
466 "heartbeats" => undef,
469 # All of the following are disabled by default:
471 our %disabled = ( # "what" => "comment"
473 "buildtest-c++" => "default",
474 "crypto-mdebug" => "default",
475 "crypto-mdebug-backtrace" => "default",
476 "devcryptoeng" => "default",
477 "ec_nistp_64_gcc_128" => "default",
479 "external-tests" => "default",
480 "fuzz-libfuzzer" => "default",
481 "fuzz-afl" => "default",
486 "ssl-trace" => "default",
488 "ssl3-method" => "default",
489 "trace" => "default",
490 "ubsan" => "default",
491 "unit-test" => "default",
492 "weak-ssl-ciphers" => "default",
494 "zlib-dynamic" => "default",
498 # Note: => pair form used for aesthetics, not to truly make a hash table
499 my @disable_cascades = (
500 # "what" => [ "cascade", ... ]
501 sub { $config{processor} eq "386" }
504 "ssl3-method" => [ "ssl3" ],
505 "zlib" => [ "zlib-dynamic" ],
507 "ec" => [ "ecdsa", "ecdh", "sm2" ],
508 sub { $disabled{"ec"} && $disabled{"dh"} }
510 "dgram" => [ "dtls", "sctp" ],
511 "sock" => [ "dgram" ],
513 sub { 0 == scalar grep { !$disabled{$_} } @dtls }
517 sub { 0 == scalar grep { !$disabled{$_} } @tls }
520 "crypto-mdebug" => [ "crypto-mdebug-backtrace" ],
522 # If no modules, then no dynamic engines either
523 "module" => [ "dynamic-engine" ],
525 # Without shared libraries, dynamic engines aren't possible.
526 # This is due to them having to link with libcrypto and register features
527 # using the ENGINE functionality, and since that relies on global tables,
528 # those *have* to be exacty the same as the ones accessed from the app,
529 # which cannot be guaranteed if shared libraries aren't present.
530 # (note that even with shared libraries, both the app and dynamic engines
531 # must be linked with the same library)
532 "shared" => [ "dynamic-engine", "uplink" ],
533 "dso" => [ "dynamic-engine", "module" ],
534 # Other modules don't necessarily have to link with libcrypto, so shared
535 # libraries do not have to be a condition to produce those.
537 # Without position independent code, there can be no shared libraries
539 "pic" => [ "shared", "module" ],
541 "module" => [ "fips" ],
543 "engine" => [ grep /eng$/, @disablables ],
544 "hw" => [ "padlockeng" ],
546 # no-autoalginit is only useful when building non-shared
547 "autoalginit" => [ "shared", "apps" ],
549 "stdio" => [ "apps", "capieng", "egd" ],
550 "apps" => [ "tests" ],
551 "tests" => [ "external-tests" ],
552 "comp" => [ "zlib" ],
554 sub { !$disabled{"unit-test"} } => [ "heartbeats" ],
556 sub { !$disabled{"msan"} } => [ "asm" ],
558 sub { $disabled{cmac}; } => [ "siv" ],
559 "legacy" => [ "md2" ],
564 # Avoid protocol support holes. Also disable all versions below N, if version
565 # N is disabled while N+1 is enabled.
567 my @list = (reverse @tls);
568 while ((my $first, my $second) = (shift @list, shift @list)) {
570 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
572 unshift @list, $second;
574 my @list = (reverse @dtls);
575 while ((my $first, my $second) = (shift @list, shift @list)) {
577 push @disable_cascades, ( sub { !$disabled{$first} && $disabled{$second} }
579 unshift @list, $second;
582 # Explicit "no-..." options will be collected in %disabled along with the defaults.
583 # To remove something from %disabled, use "enable-foo".
584 # For symmetry, "disable-foo" is a synonym for "no-foo".
586 &usage if ($#ARGV < 0);
588 # For the "make variables" CINCLUDES and CDEFINES, we support lists with
589 # platform specific list separators. Users from those platforms should
590 # recognise those separators from how you set up the PATH to find executables.
591 # The default is the Unix like separator, :, but as an exception, we also
592 # support the space as separator.
593 my $list_separator_re =
594 { VMS => qr/(?<!\^),/,
595 MSWin32 => qr/(?<!\\);/ } -> {$^O} // qr/(?<!\\)[:\s]/;
596 # All the "make variables" we support
597 # Some get pre-populated for the sake of backward compatibility
598 # (we supported those before the change to "make variable" support.
605 CFLAGS => [ env('CFLAGS') || () ],
607 CXXFLAGS => [ env('CXXFLAGS') || () ],
609 CPPFLAGS => [ env('CPPFLAGS') || () ], # -D, -I, -Wp,
610 CPPDEFINES => [], # Alternative for -D
611 CPPINCLUDES => [], # Alternative for -I
612 CROSS_COMPILE => env('CROSS_COMPILE'),
613 HASHBANGPERL=> env('HASHBANGPERL') || env('PERL'),
615 LDFLAGS => [ env('LDFLAGS') || () ], # -L, -Wl,
616 LDLIBS => [ env('LDLIBS') || () ], # -l
619 PERL => env('PERL') || ($^O ne "VMS" ? $^X : "perl"),
620 RANLIB => env('RANLIB'),
621 RC => env('RC') || env('WINDRES'),
622 RCFLAGS => [ env('RCFLAGS') || () ],
625 # Info about what "make variables" may be prefixed with the cross compiler
626 # prefix. This should NEVER mention any such variable with a list for value.
627 my @user_crossable = qw ( AR AS CC CXX CPP LD MT RANLIB RC );
628 # The same but for flags given as Configure options. These are *additional*
629 # input, as opposed to the VAR=string option that override the corresponding
630 # config target attributes
642 my %user_synonyms = (
643 HASHBANGPERL=> 'PERL',
647 # Some target attributes have been renamed, this is the translation table
648 my %target_attr_translate =(
654 hashbangperl => 'HASHBANGPERL',
662 # Initialisers coming from 'config' scripts
663 $config{defines} = [ split(/$list_separator_re/, env('__CNF_CPPDEFINES')) ];
664 $config{includes} = [ split(/$list_separator_re/, env('__CNF_CPPINCLUDES')) ];
665 $config{cppflags} = [ env('__CNF_CPPFLAGS') || () ];
666 $config{cflags} = [ env('__CNF_CFLAGS') || () ];
667 $config{cxxflags} = [ env('__CNF_CXXFLAGS') || () ];
668 $config{lflags} = [ env('__CNF_LDFLAGS') || () ];
669 $config{ex_libs} = [ env('__CNF_LDLIBS') || () ];
671 $config{openssl_api_defines}=[];
672 $config{openssl_sys_defines}=[];
673 $config{openssl_feature_defines}=[];
675 $config{build_type} = "release";
678 my %cmdvars = (); # Stores FOO='blah' type arguments
679 my %unsupported_options = ();
680 my %deprecated_options = ();
681 # If you change this, update apps/version.c
682 my @known_seed_sources = qw(getrandom devrandom os egd none rdcpu librandom);
683 my @seed_sources = ();
686 $_ = shift @argvcopy;
688 # Support env variable assignments among the options
689 if (m|^(\w+)=(.+)?$|)
692 # Every time a variable is given as a configuration argument,
693 # it acts as a reset if the variable.
694 if (exists $user{$1})
696 $user{$1} = ref $user{$1} eq "ARRAY" ? [] : undef;
698 #if (exists $useradd{$1})
705 # VMS is a case insensitive environment, and depending on settings
706 # out of our control, we may receive options uppercased. Let's
707 # downcase at least the part before any equal sign.
713 # some people just can't read the instructions, clang people have to...
714 s/^-no-(?!integrated-as)/no-/;
716 # rewrite some options in "enable-..." form
717 s /^-?-?shared$/enable-shared/;
718 s /^sctp$/enable-sctp/;
719 s /^threads$/enable-threads/;
720 s /^zlib$/enable-zlib/;
721 s /^zlib-dynamic$/enable-zlib-dynamic/;
723 if (/^(no|disable|enable)-(.+)$/)
726 if ($word !~ m|hw(?:-.+)| # special treatment for hw regexp opt
727 && !exists $deprecated_disablables{$word}
728 && !grep { $word eq $_ } @disablables)
730 $unsupported_options{$_} = 1;
734 if (/^no-(.+)$/ || /^disable-(.+)$/)
736 foreach my $proto ((@tls, @dtls))
738 if ($1 eq "$proto-method")
740 $disabled{"$proto"} = "option($proto-method)";
746 foreach my $proto (@dtls)
748 $disabled{$proto} = "option(dtls)";
750 $disabled{"dtls"} = "option(dtls)";
754 # Last one of its kind
755 $disabled{"ssl3"} = "option(ssl)";
759 # XXX: Tests will fail if all SSL/TLS
760 # protocols are disabled.
761 foreach my $proto (@tls)
763 $disabled{$proto} = "option(tls)";
766 elsif ($1 eq "static-engine")
768 delete $disabled{"dynamic-engine"};
770 elsif ($1 eq "dynamic-engine")
772 $disabled{"dynamic-engine"} = "option";
774 elsif (exists $deprecated_disablables{$1})
776 $deprecated_options{$_} = 1;
777 if (defined $deprecated_disablables{$1})
779 $disabled{$deprecated_disablables{$1}} = "option";
782 elsif ($1 =~ m|hw(?:-.+)|) # deprecate hw options in regexp form
784 $deprecated_options{$_} = 1;
788 $disabled{$1} = "option";
790 # No longer an automatic choice
791 $auto_threads = 0 if ($1 eq "threads");
793 elsif (/^enable-(.+)$/)
795 if ($1 eq "static-engine")
797 $disabled{"dynamic-engine"} = "option";
799 elsif ($1 eq "dynamic-engine")
801 delete $disabled{"dynamic-engine"};
803 elsif ($1 eq "zlib-dynamic")
805 delete $disabled{"zlib"};
808 delete $disabled{$algo};
810 # No longer an automatic choice
811 $auto_threads = 0 if ($1 eq "threads");
813 elsif (/^--strict-warnings$/)
815 # Pretend that our strict flags is a C flag, and replace it
816 # with the proper flags later on
817 push @{$useradd{CFLAGS}}, '--ossl-strict-warnings';
822 $config{build_type} = "debug";
824 elsif (/^--release$/)
826 $config{build_type} = "release";
829 { $config{processor}=386; }
832 die "FIPS mode not supported\n";
836 # No RSAref support any more since it's not needed.
837 # The check for the option is there so scripts aren't
840 elsif (/^nofipscanistercheck$/)
842 die "FIPS mode not supported\n";
846 if (/^--prefix=(.*)$/)
849 die "Directory given with --prefix MUST be absolute\n"
850 unless file_name_is_absolute($config{prefix});
852 elsif (/^--api=(.*)$/)
855 die "Unknown API compatibility level $api"
856 unless defined $apitable->{$api};
857 $config{api}=$apitable->{$api};
859 elsif (/^--libdir=(.*)$/)
863 elsif (/^--openssldir=(.*)$/)
865 $config{openssldir}=$1;
867 elsif (/^--with-zlib-lib=(.*)$/)
869 $withargs{zlib_lib}=$1;
871 elsif (/^--with-zlib-include=(.*)$/)
873 $withargs{zlib_include}=$1;
875 elsif (/^--with-fuzzer-lib=(.*)$/)
877 $withargs{fuzzer_lib}=$1;
879 elsif (/^--with-fuzzer-include=(.*)$/)
881 $withargs{fuzzer_include}=$1;
883 elsif (/^--with-rand-seed=(.*)$/)
885 foreach my $x (split(m|,|, $1))
887 die "Unknown --with-rand-seed choice $x\n"
888 if ! grep { $x eq $_ } @known_seed_sources;
889 push @seed_sources, $x;
892 elsif (/^--cross-compile-prefix=(.*)$/)
894 $user{CROSS_COMPILE}=$1;
896 elsif (/^--config=(.*)$/)
902 push @{$useradd{LDLIBS}}, $_;
904 elsif (/^-framework$/)
906 push @{$useradd{LDLIBS}}, $_, shift(@argvcopy);
908 elsif (/^-L(.*)$/ or /^-Wl,/)
910 push @{$useradd{LDFLAGS}}, $_;
912 elsif (/^-rpath$/ or /^-R$/)
913 # -rpath is the OSF1 rpath flag
914 # -R is the old Solaris rpath flag
916 my $rpath = shift(@argvcopy) || "";
917 $rpath .= " " if $rpath ne "";
918 push @{$useradd{LDFLAGS}}, $_, $rpath;
922 push @{$useradd{LDFLAGS}}, $_;
924 elsif (m|^[-/]D(.*)$|)
926 push @{$useradd{CPPDEFINES}}, $1;
928 elsif (m|^[-/]I(.*)$|)
930 push @{$useradd{CPPINCLUDES}}, $1;
934 push @{$useradd{CPPFLAGS}}, $1;
936 else # common if (/^[-+]/), just pass down...
938 # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
939 # This provides a simple way to pass options with arguments separated
940 # by spaces without quoting (e.g. -opt%20arg translates to -opt arg).
941 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
942 push @{$useradd{CFLAGS}}, $_;
943 push @{$useradd{CXXFLAGS}}, $_;
948 # Treat %xx as an ASCII code (e.g. replace %20 by a space character).
949 # This provides a simple way to pass options with arguments separated
950 # by spaces without quoting (e.g. /opt%20arg translates to /opt arg).
951 $_ =~ s/%([0-9a-f]{1,2})/chr(hex($1))/gei;
952 push @{$useradd{CFLAGS}}, $_;
953 push @{$useradd{CXXFLAGS}}, $_;
957 die "target already defined - $target (offending arg: $_)\n" if ($target ne "");
960 unless ($_ eq $target || /^no-/ || /^disable-/)
962 # "no-..." follows later after implied deactivations
963 # have been derived. (Don't take this too seriously,
964 # we really only write OPTIONS to the Makefile out of
967 if ($config{options} eq "")
968 { $config{options} = $_; }
970 { $config{options} .= " ".$_; }
974 if (keys %deprecated_options)
976 warn "***** Deprecated options: ",
977 join(", ", keys %deprecated_options), "\n";
979 if (keys %unsupported_options)
981 die "***** Unsupported options: ",
982 join(", ", keys %unsupported_options), "\n";
985 # If any %useradd entry has been set, we must check that the "make
986 # variables" haven't been set. We start by checking of any %useradd entry
988 if (grep { scalar @$_ > 0 } values %useradd) {
989 # Hash of env / make variables names. The possible values are:
991 # 2 - %useradd entry set
995 $v += 1 if $cmdvars{$_};
996 $v += 2 if @{$useradd{$_}};
1000 # If any of the corresponding "make variables" is set, we error
1001 if (grep { $_ & 1 } values %detected_vars) {
1002 my $names = join(', ', grep { $detected_vars{$_} > 0 }
1003 sort keys %detected_vars);
1005 ***** Mixing make variables and additional compiler/linker flags as
1006 ***** configure command line option is not permitted.
1007 ***** Affected make variables: $names
1012 # Check through all supported command line variables to see if any of them
1013 # were set, and canonicalise the values we got. If no compiler or linker
1014 # flag or anything else that affects %useradd was set, we also check the
1015 # environment for values.
1017 grep { defined $_ && (ref $_ ne 'ARRAY' || @$_) } values %useradd;
1018 foreach (keys %user) {
1019 my $value = $cmdvars{$_};
1020 $value //= env($_) unless $anyuseradd;
1022 defined $user_synonyms{$_} ? $cmdvars{$user_synonyms{$_}} : undef;
1023 $value //= defined $user_synonyms{$_} ? env($user_synonyms{$_}) : undef
1026 if (defined $value) {
1027 if (ref $user{$_} eq 'ARRAY') {
1028 $user{$_} = [ split /$list_separator_re/, $value ];
1029 } elsif (!defined $user{$_}) {
1035 if (grep { /-rpath\b/ } ($user{LDFLAGS} ? @{$user{LDFLAGS}} : ())
1036 && !$disabled{shared}
1037 && !($disabled{asan} && $disabled{msan} && $disabled{ubsan})) {
1038 die "***** Cannot simultaneously use -rpath, shared libraries, and\n",
1039 "***** any of asan, msan or ubsan\n";
1043 my $disable_type = shift;
1046 $disabled{$_} = $disable_type;
1049 my @tocheckfor = (@_ ? @_ : keys %disabled);
1050 while (@tocheckfor) {
1051 my %new_tocheckfor = ();
1052 my @cascade_copy = (@disable_cascades);
1053 while (@cascade_copy) {
1054 my ($test, $descendents) =
1055 (shift @cascade_copy, shift @cascade_copy);
1056 if (ref($test) eq "CODE" ? $test->() : defined($disabled{$test})) {
1057 foreach (grep { !defined($disabled{$_}) } @$descendents) {
1058 $new_tocheckfor{$_} = 1; $disabled{$_} = "cascade";
1062 @tocheckfor = (keys %new_tocheckfor);
1065 disable(); # First cascade run
1067 our $die = sub { die @_; };
1068 if ($target eq "TABLE") {
1069 local $die = sub { warn @_; };
1070 foreach (sort keys %table) {
1071 print_table_entry($_, "TABLE");
1076 if ($target eq "LIST") {
1077 foreach (sort keys %table) {
1078 print $_,"\n" unless $table{$_}->{template};
1083 if ($target eq "HASH") {
1084 local $die = sub { warn @_; };
1085 print "%table = (\n";
1086 foreach (sort keys %table) {
1087 print_table_entry($_, "HASH");
1092 print "Configuring OpenSSL version $config{full_version} ";
1093 print "for target $target\n";
1095 if (scalar(@seed_sources) == 0) {
1096 print "Using os-specific seed configuration\n";
1097 push @seed_sources, 'os';
1099 if (scalar(grep { $_ eq 'none' } @seed_sources) > 0) {
1100 die "Cannot seed with none and anything else" if scalar(@seed_sources) > 1;
1101 warn <<_____ if scalar(@seed_sources) == 1;
1103 ============================== WARNING ===============================
1104 You have selected the --with-rand-seed=none option, which effectively
1105 disables automatic reseeding of the OpenSSL random generator.
1106 All operations depending on the random generator such as creating keys
1107 will not work unless the random generator is seeded manually by the
1110 Please read the 'Note on random number generation' section in the
1111 INSTALL instructions and the RAND_DRBG(7) manual page for more details.
1112 ============================== WARNING ===============================
1116 push @{$config{openssl_feature_defines}},
1117 map { (my $x = $_) =~ tr|[\-a-z]|[_A-Z]|; "OPENSSL_RAND_SEED_$x" }
1120 # Backward compatibility?
1121 if ($target =~ m/^CygWin32(-.*)$/) {
1122 $target = "Cygwin".$1;
1125 # Support for legacy targets having a name starting with 'debug-'
1126 my ($d, $t) = $target =~ m/^(debug-)?(.*)$/;
1128 $config{build_type} = "debug";
1130 # If we do not find debug-foo in the table, the target is set to foo.
1131 if (!$table{$target}) {
1136 &usage if !$table{$target} || $table{$target}->{template};
1138 $config{target} = $target;
1139 my %target = resolve_config($target);
1141 foreach (keys %target_attr_translate) {
1142 $target{$target_attr_translate{$_}} = $target{$_}
1147 %target = ( %{$table{DEFAULTS}}, %target );
1149 my %conf_files = map { $_ => 1 } (@{$target{_conf_fname_int}});
1150 $config{conf_files} = [ sort keys %conf_files ];
1152 # Using sub disable within these loops may prove fragile, so we run
1153 # a cascade afterwards
1154 foreach my $feature (@{$target{disable}}) {
1155 if (exists $deprecated_disablables{$feature}) {
1156 warn "***** config $target disables deprecated feature $feature\n";
1157 } elsif (!grep { $feature eq $_ } @disablables) {
1158 die "***** config $target disables unknown feature $feature\n";
1160 $disabled{$feature} = 'config';
1162 foreach my $feature (@{$target{enable}}) {
1163 if ("default" eq ($disabled{$feature} // "")) {
1164 if (exists $deprecated_disablables{$feature}) {
1165 warn "***** config $target enables deprecated feature $feature\n";
1166 } elsif (!grep { $feature eq $_ } @disablables) {
1167 die "***** config $target enables unknown feature $feature\n";
1169 delete $disabled{$feature};
1173 # If uplink_arch isn't defined, disable uplink
1174 $disabled{uplink} = 'no uplink_arch' unless (defined $target{uplink_arch});
1175 # If asm_arch isn't defined, disable asm
1176 $disabled{asm} = 'no asm_arch' unless (defined $target{asm_arch});
1178 disable(); # Run a cascade now
1180 $target{CXXFLAGS}//=$target{CFLAGS} if $target{CXX};
1181 $target{cxxflags}//=$target{cflags} if $target{CXX};
1182 $target{exe_extension}=".exe" if ($config{target} eq "DJGPP");
1183 $target{exe_extension}=".pm" if ($config{target} =~ /vos/);
1185 # Fill %config with values from %user, and in case those are undefined or
1186 # empty, use values from %target (acting as a default).
1187 foreach (keys %user) {
1188 my $ref_type = ref $user{$_};
1190 # Temporary function. Takes an intended ref type (empty string or "ARRAY")
1191 # and a value that's to be coerced into that type.
1195 my $undef_p = shift;
1197 die "Too many arguments for \$mkvalue" if @_;
1199 while (ref $value eq 'CODE') {
1200 $value = $value->();
1203 if ($type eq 'ARRAY') {
1204 return undef unless defined $value;
1205 return undef if ref $value ne 'ARRAY' && !$value;
1206 return undef if ref $value eq 'ARRAY' && !@$value;
1207 return [ $value ] unless ref $value eq 'ARRAY';
1209 return undef unless $value;
1214 $mkvalue->($ref_type, $user{$_})
1215 || $mkvalue->($ref_type, $target{$_});
1216 delete $config{$_} unless defined $config{$_};
1219 # Finish up %config by appending things the user gave us on the command line
1220 # apart from "make variables"
1221 foreach (keys %useradd) {
1222 # The must all be lists, so we assert that here
1223 die "internal error: \$useradd{$_} isn't an ARRAY\n"
1224 unless ref $useradd{$_} eq 'ARRAY';
1226 if (defined $config{$_}) {
1227 push @{$config{$_}}, @{$useradd{$_}};
1229 $config{$_} = [ @{$useradd{$_}} ];
1232 # At this point, we can forget everything about %user and %useradd,
1233 # because it's now all been merged into the corresponding $config entry
1235 # Allow overriding the build file name
1236 $config{build_file} = env('BUILDFILE') || $target{build_file} || "Makefile";
1238 # Make sure build_scheme is consistent.
1239 $target{build_scheme} = [ $target{build_scheme} ]
1240 if ref($target{build_scheme}) ne "ARRAY";
1242 my ($builder, $builder_platform, @builder_opts) =
1243 @{$target{build_scheme}};
1245 foreach my $checker (($builder_platform."-".$target{build_file}."-checker.pm",
1246 $builder_platform."-checker.pm")) {
1247 my $checker_path = catfile($srcdir, "Configurations", $checker);
1248 if (-f $checker_path) {
1249 my $fn = $ENV{CONFIGURE_CHECKER_WARN}
1250 ? sub { warn $@; } : sub { die $@; };
1251 if (! do $checker_path) {
1257 $fn->("The detected tools didn't match the platform\n");
1264 push @{$config{defines}}, "NDEBUG" if $config{build_type} eq "release";
1266 if ($target =~ /^mingw/ && `$config{CC} --target-help 2>&1` =~ m/-mno-cygwin/m)
1268 push @{$config{cflags}}, "-mno-cygwin";
1269 push @{$config{cxxflags}}, "-mno-cygwin" if $config{CXX};
1270 push @{$config{shared_ldflag}}, "-mno-cygwin";
1273 if ($target =~ /linux.*-mips/ && !$disabled{asm}
1274 && !grep { $_ !~ /-m(ips|arch=)/ } (@{$config{CFLAGS}})) {
1275 # minimally required architecture flags for assembly modules
1277 $value = '-mips2' if ($target =~ /mips32/);
1278 $value = '-mips3' if ($target =~ /mips64/);
1279 unshift @{$config{cflags}}, $value;
1280 unshift @{$config{cxxflags}}, $value if $config{CXX};
1283 # If threads aren't disabled, check how possible they are
1284 unless ($disabled{threads}) {
1285 if ($auto_threads) {
1286 # Enabled by default, disable it forcibly if unavailable
1287 if ($target{thread_scheme} eq "(unknown)") {
1288 disable("unavailable", 'threads');
1291 # The user chose to enable threads explicitly, let's see
1292 # if there's a chance that's possible
1293 if ($target{thread_scheme} eq "(unknown)") {
1294 # If the user asked for "threads" and we don't have internal
1295 # knowledge how to do it, [s]he is expected to provide any
1296 # system-dependent compiler options that are necessary. We
1297 # can't truly check that the given options are correct, but
1298 # we expect the user to know what [s]He is doing.
1299 if (!@{$config{CFLAGS}} && !@{$config{CPPDEFINES}}) {
1300 die "You asked for multi-threading support, but didn't\n"
1301 ,"provide any system-specific compiler options\n";
1307 # Find out if clang's sanitizers have been enabled with -fsanitize
1308 # flags and ensure that the corresponding %disabled elements area
1309 # removed to reflect that the sanitizers are indeed enabled.
1310 my %detected_sanitizers = ();
1311 foreach (grep /^-fsanitize=/, @{$config{CFLAGS} || []}) {
1312 (my $checks = $_) =~ s/^-fsanitize=//;
1313 foreach (split /,/, $checks) {
1314 my $d = { address => 'asan',
1315 undefined => 'ubsan',
1316 memory => 'msan' } -> {$_};
1317 next unless defined $d;
1319 $detected_sanitizers{$d} = 1;
1320 if (defined $disabled{$d}) {
1321 die "***** Conflict between disabling $d and enabling $_ sanitizer"
1322 if $disabled{$d} ne "default";
1323 delete $disabled{$d};
1328 # If threads still aren't disabled, add a C macro to ensure the source
1329 # code knows about it. Any other flag is taken care of by the configs.
1330 unless($disabled{threads}) {
1331 push @{$config{openssl_feature_defines}}, "OPENSSL_THREADS";
1334 my $no_shared_warn=0;
1335 if ($target{shared_target} eq "")
1338 if (!$disabled{shared} || !$disabled{"dynamic-engine"});
1339 disable('no-shared-target', 'pic');
1342 if ($disabled{"dynamic-engine"}) {
1343 $config{dynamic_engines} = 0;
1345 $config{dynamic_engines} = 1;
1348 unless ($disabled{asan} || defined $detected_sanitizers{asan}) {
1349 push @{$config{cflags}}, "-fsanitize=address";
1352 unless ($disabled{ubsan} || defined $detected_sanitizers{ubsan}) {
1353 # -DPEDANTIC or -fnosanitize=alignment may also be required on some
1355 push @{$config{cflags}}, "-fsanitize=undefined", "-fno-sanitize-recover=all";
1358 unless ($disabled{msan} || defined $detected_sanitizers{msan}) {
1359 push @{$config{cflags}}, "-fsanitize=memory";
1362 unless ($disabled{"fuzz-libfuzzer"} && $disabled{"fuzz-afl"}
1363 && $disabled{asan} && $disabled{ubsan} && $disabled{msan}) {
1364 push @{$config{cflags}}, "-fno-omit-frame-pointer", "-g";
1365 push @{$config{cxxflags}}, "-fno-omit-frame-pointer", "-g" if $config{CXX};
1371 # This saves the build files from having to check
1374 foreach (qw(shared_cflag shared_cxxflag shared_cppflag
1375 shared_defines shared_includes shared_ldflag
1376 module_cflags module_cxxflags module_cppflags
1377 module_defines module_includes module_lflags))
1385 push @{$config{lib_defines}}, "OPENSSL_PIC";
1388 if ($target{sys_id} ne "")
1390 push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}";
1393 my %predefined_C = compiler_predefined($config{CROSS_COMPILE}.$config{CC});
1394 my %predefined_CXX = $config{CXX}
1395 ? compiler_predefined($config{CROSS_COMPILE}.$config{CXX})
1398 unless ($disabled{asm}) {
1399 # big endian systems can use ELFv2 ABI
1400 if ($target eq "linux-ppc64") {
1401 $target{perlasm_scheme} = "linux64v2" if ($predefined_C{_CALL_ELF} == 2);
1405 # Check for makedepend capabilities.
1406 if (!$disabled{makedepend}) {
1407 if ($config{target} =~ /^(VC|vms)-/) {
1408 # For VC- and vms- targets, there's nothing more to do here. The
1409 # functionality is hard coded in the corresponding build files for
1410 # cl (Windows) and CC/DECC (VMS).
1411 } elsif (($predefined_C{__GNUC__} // -1) >= 3
1412 && !($predefined_C{__APPLE_CC__} && !$predefined_C{__clang__})) {
1413 # We know that GNU C version 3 and up as well as all clang
1414 # versions support dependency generation, but Xcode did not
1415 # handle $cc -M before clang support (but claims __GNUC__ = 3)
1416 $config{makedepprog} = "\$(CROSS_COMPILE)$config{CC}";
1418 # In all other cases, we look for 'makedepend', and disable the
1419 # capability if not found.
1420 $config{makedepprog} = which('makedepend');
1421 disable('unavailable', 'makedepend') unless $config{makedepprog};
1425 if (!$disabled{asm} && !$predefined_C{__MACH__} && $^O ne 'VMS') {
1426 # probe for -Wa,--noexecstack option...
1427 if ($predefined_C{__clang__}) {
1428 # clang has builtin assembler, which doesn't recognize --help,
1429 # but it apparently recognizes the option in question on all
1430 # supported platforms even when it's meaningless. In other words
1431 # probe would fail, but probed option always accepted...
1432 push @{$config{cflags}}, "-Wa,--noexecstack", "-Qunused-arguments";
1434 my $cc = $config{CROSS_COMPILE}.$config{CC};
1435 open(PIPE, "$cc -Wa,--help -c -o null.$$.o -x assembler /dev/null 2>&1 |");
1437 if (m/--noexecstack/) {
1438 push @{$config{cflags}}, "-Wa,--noexecstack";
1443 unlink("null.$$.o");
1447 # Deal with bn_ops ###################################################
1450 my $def_int="unsigned int";
1451 $config{rc4_int} =$def_int;
1452 ($config{b64l},$config{b64},$config{b32})=(0,0,1);
1455 foreach (sort split(/\s+/,$target{bn_ops})) {
1456 $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/;
1457 $config{bn_ll}=1 if $_ eq 'BN_LLONG';
1458 $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR';
1459 ($config{b64l},$config{b64},$config{b32})
1460 =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT';
1461 ($config{b64l},$config{b64},$config{b32})
1462 =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG';
1463 ($config{b64l},$config{b64},$config{b32})
1464 =(0,0,1) if $_ eq 'THIRTY_TWO_BIT';
1466 die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n"
1469 $config{api} = $config{major} * 10000 + $config{minor} * 100
1470 unless $config{api};
1472 # Hack cflags for better warnings (dev option) #######################
1474 # "Stringify" the C and C++ flags string. This permits it to be made part of
1475 # a string and works as well on command lines.
1476 $config{cflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1477 @{$config{cflags}} ];
1478 $config{cxxflags} = [ map { (my $x = $_) =~ s/([\\\"])/\\$1/g; $x }
1479 @{$config{cxxflags}} ] if $config{CXX};
1481 $config{openssl_api_defines} = [
1482 "OPENSSL_CONFIGURED_API=".$config{api}
1485 my @strict_warnings_collection=();
1486 if ($strict_warnings)
1489 my $gccver = $predefined_C{__GNUC__} // -1;
1493 push @strict_warnings_collection, @gcc_devteam_warn;
1494 push @strict_warnings_collection, @clang_devteam_warn
1495 if (defined($predefined_C{__clang__}));
1497 elsif ($config{target} =~ /^VC-/)
1499 push @strict_warnings_collection, @cl_devteam_warn;
1503 warn "WARNING --strict-warnings requires gcc[>=4] or gcc-alike, or MSVC"
1507 if (grep { $_ eq '-static' } @{$config{LDFLAGS}}) {
1508 disable('static', 'pic', 'threads');
1511 $config{CFLAGS} = [ map { $_ eq '--ossl-strict-warnings'
1512 ? @strict_warnings_collection
1514 @{$config{CFLAGS}} ];
1516 unless ($disabled{afalgeng}) {
1517 $config{afalgeng}="";
1518 if (grep { $_ eq 'afalgeng' } @{$target{enable}}) {
1519 my $minver = 4*10000 + 1*100 + 0;
1520 if ($config{CROSS_COMPILE} eq "") {
1521 my $verstr = `uname -r`;
1522 my ($ma, $mi1, $mi2) = split("\\.", $verstr);
1523 ($mi2) = $mi2 =~ /(\d+)/;
1524 my $ver = $ma*10000 + $mi1*100 + $mi2;
1525 if ($ver < $minver) {
1526 disable('too-old-kernel', 'afalgeng');
1528 push @{$config{engdirs}}, "afalg";
1531 disable('cross-compiling', 'afalgeng');
1534 disable('not-linux', 'afalgeng');
1538 unless ($disabled{devcryptoeng}) {
1539 if ($target =~ m/^BSD/) {
1540 my $maxver = 5*100 + 7;
1541 my $sysstr = `uname -s`;
1542 my $verstr = `uname -r`;
1545 my ($ma, $mi, @rest) = split m|\.|, $verstr;
1546 my $ver = $ma*100 + $mi;
1547 if ($sysstr eq 'OpenBSD' && $ver >= $maxver) {
1548 disable('too-new-kernel', 'devcryptoeng');
1553 unless ($disabled{ktls}) {
1555 if ($target =~ m/^linux/) {
1556 my $usr = "/usr/$config{cross_compile_prefix}";
1558 if ($config{cross_compile_prefix} eq "") {
1561 my $minver = (4 << 16) + (13 << 8) + 0;
1562 my @verstr = split(" ",`cat $usr/include/linux/version.h | grep LINUX_VERSION_CODE`);
1564 if ($verstr[2] < $minver) {
1565 disable('too-old-kernel', 'ktls');
1567 } elsif ($target =~ m/^BSD/) {
1568 my $cc = $config{CROSS_COMPILE}.$config{CC};
1569 system("printf '#include <sys/types.h>\n#include <sys/ktls.h>' | $cc -E - >/dev/null 2>&1");
1571 disable('too-old-freebsd', 'ktls');
1574 disable('not-linux-or-freebsd', 'ktls');
1578 push @{$config{openssl_other_defines}}, "OPENSSL_NO_KTLS" if ($disabled{ktls});
1580 # Get the extra flags used when building shared libraries and modules. We
1581 # do this late because some of them depend on %disabled.
1583 # Make the flags to build DSOs the same as for shared libraries unless they
1584 # are already defined
1585 $target{module_cflags} = $target{shared_cflag} unless defined $target{module_cflags};
1586 $target{module_cxxflags} = $target{shared_cxxflag} unless defined $target{module_cxxflags};
1587 $target{module_ldflags} = $target{shared_ldflag} unless defined $target{module_ldflags};
1589 my $shared_info_pl =
1590 catfile(dirname($0), "Configurations", "shared-info.pl");
1591 my %shared_info = read_eval_file($shared_info_pl);
1592 push @{$target{_conf_fname_int}}, $shared_info_pl;
1593 my $si = $target{shared_target};
1594 while (ref $si ne "HASH") {
1595 last if ! defined $si;
1596 if (ref $si eq "CODE") {
1599 $si = $shared_info{$si};
1603 # Some of the 'shared_target' values don't have any entries in
1604 # %shared_info. That's perfectly fine, AS LONG AS the build file
1605 # template knows how to handle this. That is currently the case for
1608 # Just as above, copy certain shared_* attributes to the corresponding
1609 # module_ attribute unless the latter is already defined
1610 $si->{module_cflags} = $si->{shared_cflag} unless defined $si->{module_cflags};
1611 $si->{module_cxxflags} = $si->{shared_cxxflag} unless defined $si->{module_cxxflags};
1612 $si->{module_ldflags} = $si->{shared_ldflag} unless defined $si->{module_ldflags};
1613 foreach (sort keys %$si) {
1614 $target{$_} = defined $target{$_}
1615 ? add($si->{$_})->($target{$_})
1621 # ALL MODIFICATIONS TO %disabled, %config and %target MUST BE DONE FROM HERE ON
1623 ######################################################################
1624 # Build up information for skipping certain directories depending on disabled
1625 # features, as well as setting up macros for disabled features.
1627 # This is a tentative database of directories to skip. Some entries may not
1628 # correspond to anything real, but that's ok, they will simply be ignored.
1629 # The actual processing of these entries is done in the build.info lookup
1630 # loop further down.
1632 # The key is a Unix formatted path in the source tree, the value is an index
1633 # into %disabled_info, so any existing path gets added to a corresponding
1634 # 'skipped' entry in there with the list of skipped directories.
1636 my %disabled_info = (); # For configdata.pm
1637 foreach my $what (sort keys %disabled) {
1638 # There are deprecated disablables that translate to themselves.
1639 # They cause disabling cascades, but should otherwise not regiter.
1640 next if $deprecated_disablables{$what};
1642 $config{options} .= " no-$what";
1644 if (!grep { $what eq $_ } ( 'buildtest-c++', 'fips', 'threads', 'shared',
1645 'module', 'pic', 'dynamic-engine', 'makedepend',
1646 'zlib-dynamic', 'zlib', 'sse2', 'legacy' )) {
1647 (my $WHAT = uc $what) =~ s|-|_|g;
1648 my $skipdir = $what;
1650 # fix-up crypto/directory name(s)
1651 $skipdir = "ripemd" if $what eq "rmd160";
1652 $skipdir = "whrlpool" if $what eq "whirlpool";
1654 my $macro = $disabled_info{$what}->{macro} = "OPENSSL_NO_$WHAT";
1655 push @{$config{openssl_feature_defines}}, $macro;
1657 $skipdir{engines} = $what if $what eq 'engine';
1658 $skipdir{"crypto/$skipdir"} = $what
1659 unless $what eq 'async' || $what eq 'err' || $what eq 'dso';
1663 if ($disabled{"dynamic-engine"}) {
1664 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE";
1666 push @{$config{openssl_feature_defines}}, "OPENSSL_NO_STATIC_ENGINE";
1669 # If we use the unified build, collect information from build.info files
1670 my %unified_info = ();
1672 my $buildinfo_debug = defined($ENV{CONFIGURE_DEBUG_BUILDINFO});
1673 if ($builder eq "unified") {
1674 use Text::Template 1.46;
1679 my $relativeto = shift || ".";
1681 $dir = catdir($base,$dir) unless isabsolute($dir);
1683 # Make sure the directories we're building in exists
1686 my $res = abs2rel(absolutedir($dir), rel2abs($relativeto));
1687 #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n";
1694 my $relativeto = shift || ".";
1696 $file = catfile($base,$file) unless isabsolute($file);
1698 my $d = dirname($file);
1699 my $f = basename($file);
1701 # Make sure the directories we're building in exists
1704 my $res = abs2rel(catfile(absolutedir($d), $f), rel2abs($relativeto));
1705 #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n";
1709 # Store the name of the template file we will build the build file from
1710 # in %config. This may be useful for the build file itself.
1711 my @build_file_template_names =
1712 ( $builder_platform."-".$target{build_file}.".tmpl",
1713 $target{build_file}.".tmpl" );
1714 my @build_file_templates = ();
1716 # First, look in the user provided directory, if given
1717 if (defined env($local_config_envname)) {
1718 @build_file_templates =
1721 # VMS environment variables are logical names,
1722 # which can be used as is
1723 $local_config_envname . ':' . $_;
1725 catfile(env($local_config_envname), $_);
1728 @build_file_template_names;
1730 # Then, look in our standard directory
1731 push @build_file_templates,
1732 ( map { cleanfile($srcdir, catfile("Configurations", $_), $blddir) }
1733 @build_file_template_names );
1735 my $build_file_template;
1736 for $_ (@build_file_templates) {
1737 $build_file_template = $_;
1738 last if -f $build_file_template;
1740 $build_file_template = undef;
1742 if (!defined $build_file_template) {
1743 die "*** Couldn't find any of:\n", join("\n", @build_file_templates), "\n";
1745 $config{build_file_templates}
1746 = [ cleanfile($srcdir, catfile("Configurations", "common0.tmpl"),
1748 $build_file_template,
1749 cleanfile($srcdir, catfile("Configurations", "common.tmpl"),
1752 my @build_dirs = ( [ ] ); # current directory
1754 $config{build_infos} = [ ];
1757 while (@build_dirs) {
1758 my @curd = @{shift @build_dirs};
1759 my $sourced = catdir($srcdir, @curd);
1760 my $buildd = catdir($blddir, @curd);
1762 my $unixdir = join('/', @curd);
1763 if (exists $skipdir{$unixdir}) {
1764 my $what = $skipdir{$unixdir};
1765 push @{$disabled_info{$what}->{skipped}}, catdir(@curd);
1771 my $f = 'build.info';
1772 # The basic things we're trying to build
1779 my %shared_sources = ();
1787 # Support for $variablename in build.info files.
1788 # Embedded perl code is the ultimate master, still. If its output
1789 # contains a dollar sign, it had better be escaped, or it will be
1790 # taken for a variable name prefix.
1792 my $variable_re = qr/\$(?P<VARIABLE>[[:alpha:]][[:alnum:]_]*)/;
1793 my $expand_variables = sub {
1795 my $value_rest = shift;
1797 if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
1799 "DEBUG[\$expand_variables] Parsed '$value_rest' into:\n"
1801 while ($value_rest =~ /(?<!\\)${variable_re}/) {
1803 $value .= $variables{$+{VARIABLE}};
1806 if ($ENV{CONFIGURE_DEBUG_VARIABLE_EXPAND}) {
1808 "DEBUG[\$expand_variables] ... '$value$value_rest'\n";
1810 return $value . $value_rest;
1813 # Support for attributes in build.info files
1814 my %attributes = ();
1815 my $handle_attributes = sub {
1816 my $attr_str = shift;
1820 return unless defined $attr_str;
1822 my @a = tokenize($attr_str, qr|\s*,\s*|);
1823 foreach my $a (@a) {
1827 if ($a =~ m|^(!)?(.*?)\s* = \s*(.*?)$|) {
1832 foreach my $g (@goals) {
1834 $$ref->{$g}->{$ak} = $av;
1836 delete $$ref->{$g}->{$ak};
1842 # We want to detect configdata.pm in the source tree, so we
1843 # don't use it if the build tree is different.
1844 my $src_configdata = cleanfile($srcdir, "configdata.pm", $blddir);
1847 if ($buildinfo_debug) {
1848 print STDERR "DEBUG: Reading ",catfile($sourced, $f),"\n";
1850 push @{$config{build_infos}}, catfile(abs2rel($sourced, $blddir), $f);
1852 Text::Template->new(TYPE => 'FILE',
1853 SOURCE => catfile($sourced, $f),
1854 PREPEND => qq{use lib "$FindBin::Bin/util/perl";});
1855 die "Something went wrong with $sourced/$f: $!\n" unless $template;
1858 $template->fill_in(HASH => { config => \%config,
1860 disabled => \%disabled,
1861 withargs => \%withargs,
1862 builddir => abs2rel($buildd, $blddir),
1863 sourcedir => abs2rel($sourced, $blddir),
1864 buildtop => abs2rel($blddir, $blddir),
1865 sourcetop => abs2rel($srcdir, $blddir) },
1866 DELIMITERS => [ "{-", "-}" ]);
1868 # The top item of this stack has the following values
1869 # -2 positive already run and we found ELSE (following ELSIF should fail)
1870 # -1 positive already run (skip until ENDIF)
1871 # 0 negatives so far (if we're at a condition, check it)
1872 # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF)
1873 # 2 positive ELSE (following ELSIF should fail)
1876 # A few useful generic regexps
1877 my $index_re = qr/\[\s*(?P<INDEX>(?:\\.|.)*?)\s*\]/;
1878 my $cond_re = qr/\[\s*(?P<COND>(?:\\.|.)*?)\s*\]/;
1879 my $attribs_re = qr/(?:\{\s*(?P<ATTRIBS>(?:\\.|.)*?)\s*\})?/;
1880 my $value_re = qr/\s*(?P<VALUE>.*?)\s*/;
1881 collect_information(
1882 collect_from_array([ @text ],
1883 qr/\\$/ => sub { my $l1 = shift; my $l2 = shift;
1884 $l1 =~ s/\\$//; $l1.$l2 }),
1885 # Info we're looking for
1886 qr/^\s* IF ${cond_re} \s*$/x
1888 if (! @skip || $skip[$#skip] > 0) {
1889 push @skip, !! $expand_variables->($+{COND});
1894 qr/^\s* ELSIF ${cond_re} \s*$/x
1895 => sub { die "ELSIF out of scope" if ! @skip;
1896 die "ELSIF following ELSE" if abs($skip[$#skip]) == 2;
1897 $skip[$#skip] = -1 if $skip[$#skip] != 0;
1898 $skip[$#skip] = !! $expand_variables->($+{COND})
1899 if $skip[$#skip] == 0; },
1901 => sub { die "ELSE out of scope" if ! @skip;
1902 $skip[$#skip] = -2 if $skip[$#skip] != 0;
1903 $skip[$#skip] = 2 if $skip[$#skip] == 0; },
1904 qr/^\s* ENDIF \s*$/x
1905 => sub { die "ENDIF out of scope" if ! @skip;
1907 qr/^\s* ${variable_re} \s* = ${value_re} $/x
1909 if (!@skip || $skip[$#skip] > 0) {
1910 $variables{$+{VARIABLE}} = $expand_variables->($+{VALUE});
1913 qr/^\s* SUBDIRS \s* = ${value_re} $/x
1915 if (!@skip || $skip[$#skip] > 0) {
1916 foreach (tokenize($expand_variables->($+{VALUE}))) {
1917 push @build_dirs, [ @curd, splitdir($_, 1) ];
1921 qr/^\s* PROGRAMS ${attribs_re} \s* = ${value_re} $/x
1923 if (!@skip || $skip[$#skip] > 0) {
1924 my @p = tokenize($expand_variables->($+{VALUE}));
1926 $handle_attributes->($+{ATTRIBS},
1927 \$attributes{programs},
1931 qr/^\s* LIBS ${attribs_re} \s* = ${value_re} $/x
1933 if (!@skip || $skip[$#skip] > 0) {
1934 my @l = tokenize($expand_variables->($+{VALUE}));
1935 push @libraries, @l;
1936 $handle_attributes->($+{ATTRIBS},
1937 \$attributes{libraries},
1941 qr/^\s* MODULES ${attribs_re} \s* = ${value_re} $/x
1943 if (!@skip || $skip[$#skip] > 0) {
1944 my @m = tokenize($expand_variables->($+{VALUE}));
1946 $handle_attributes->($+{ATTRIBS},
1947 \$attributes{modules},
1951 qr/^\s* SCRIPTS ${attribs_re} \s* = ${value_re} $/x
1953 if (!@skip || $skip[$#skip] > 0) {
1954 my @s = tokenize($expand_variables->($+{VALUE}));
1956 $handle_attributes->($+{ATTRIBS},
1957 \$attributes{scripts},
1961 qr/^\s* HTMLDOCS ${index_re} = ${value_re} $/x
1962 => sub { push @{$htmldocs{$expand_variables->($+{INDEX})}},
1963 tokenize($expand_variables->($+{VALUE}))
1964 if !@skip || $skip[$#skip] > 0 },
1965 qr/^\s* MANDOCS ${index_re} = ${value_re} $/x
1966 => sub { push @{$mandocs{$expand_variables->($+{INDEX})}},
1967 tokenize($expand_variables->($+{VALUE}))
1968 if !@skip || $skip[$#skip] > 0 },
1969 qr/^\s* ORDINALS ${index_re} = ${value_re} $/x
1970 => sub { push @{$ordinals{$expand_variables->($+{INDEX})}},
1971 tokenize($expand_variables->($+{VALUE}))
1972 if !@skip || $skip[$#skip] > 0 },
1973 qr/^\s* SOURCE ${index_re} = ${value_re} $/x
1974 => sub { push @{$sources{$expand_variables->($+{INDEX})}},
1975 tokenize($expand_variables->($+{VALUE}))
1976 if !@skip || $skip[$#skip] > 0 },
1977 qr/^\s* SHARED_SOURCE ${index_re} = ${value_re} $/x
1978 => sub { push @{$shared_sources{$expand_variables->($+{INDEX})}},
1979 tokenize($expand_variables->($+{VALUE}))
1980 if !@skip || $skip[$#skip] > 0 },
1981 qr/^\s* INCLUDE ${index_re} = ${value_re} $/x
1982 => sub { push @{$includes{$expand_variables->($+{INDEX})}},
1983 tokenize($expand_variables->($+{VALUE}))
1984 if !@skip || $skip[$#skip] > 0 },
1985 qr/^\s* DEFINE ${index_re} = ${value_re} $/x
1986 => sub { push @{$defines{$expand_variables->($+{INDEX})}},
1987 tokenize($expand_variables->($+{VALUE}))
1988 if !@skip || $skip[$#skip] > 0 },
1989 qr/^\s* DEPEND ${index_re} ${attribs_re} = ${value_re} $/x
1991 if (!@skip || $skip[$#skip] > 0) {
1992 my $i = $expand_variables->($+{INDEX});
1993 my @d = tokenize($expand_variables->($+{VALUE}));
1994 push @{$depends{$i}}, @d;
1995 $handle_attributes->($+{ATTRIBS},
1996 \$attributes{depends}->{$i},
2000 qr/^\s* GENERATE ${index_re} = ${value_re} $/x
2001 => sub { push @{$generate{$expand_variables->($+{INDEX})}},
2003 if !@skip || $skip[$#skip] > 0 },
2004 qr/^\s* (?:\#.*)? $/x => sub { },
2005 "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" },
2007 if ($buildinfo_debug) {
2008 print STDERR "DEBUG: Parsing ",join(" ", @_),"\n";
2009 print STDERR "DEBUG: ... before parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2013 if ($buildinfo_debug) {
2014 print STDERR "DEBUG: .... after parsing, skip stack is ",join(" ", map { int($_) } @skip),"\n";
2018 die "runaway IF?" if (@skip);
2020 if (grep { defined $attributes{modules}->{$_}->{engine} } keys %attributes
2021 and !$config{dynamic_engines}) {
2023 ENGINES can only be used if configured with 'dynamic-engine'.
2024 This is usually a fault in a build.info file.
2029 my %infos = ( programs => [ @programs ],
2030 libraries => [ @libraries ],
2031 modules => [ @modules ],
2032 scripts => [ @scripts ] );
2033 foreach my $k (keys %infos) {
2034 foreach (@{$infos{$k}}) {
2035 my $item = cleanfile($buildd, $_, $blddir);
2036 $unified_info{$k}->{$item} = 1;
2038 # Fix up associated attributes
2039 $unified_info{attributes}->{$k}->{$item} =
2040 $attributes{$k}->{$_}
2041 if defined $attributes{$k}->{$_};
2046 # Check that we haven't defined any library as both shared and
2047 # explicitly static. That is forbidden.
2049 foreach (grep /\.a$/, keys %{$unified_info{libraries}}) {
2050 (my $l = $_) =~ s/\.a$//;
2051 push @doubles, $l if defined $unified_info{libraries}->{$l};
2053 die "these libraries are both explicitly static and shared:\n ",
2054 join(" ", @doubles), "\n"
2057 foreach (keys %sources) {
2059 my $ddest = cleanfile($buildd, $_, $blddir);
2060 foreach (@{$sources{$dest}}) {
2061 my $s = cleanfile($sourced, $_, $blddir);
2063 # If it isn't in the source tree, we assume it's generated
2065 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2066 $s = cleanfile($buildd, $_, $blddir);
2068 # We recognise C++, C and asm files
2069 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2071 $o =~ s/\.[csS]$/.o/; # C and assembler
2072 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2073 $o = cleanfile($buildd, $o, $blddir);
2074 $unified_info{sources}->{$ddest}->{$o} = -1;
2075 $unified_info{sources}->{$o}->{$s} = -1;
2076 } elsif ($s =~ /\.rc$/) {
2077 # We also recognise resource files
2079 $o =~ s/\.rc$/.res/; # Resource configuration
2080 my $o = cleanfile($buildd, $o, $blddir);
2081 $unified_info{sources}->{$ddest}->{$o} = -1;
2082 $unified_info{sources}->{$o}->{$s} = -1;
2084 $unified_info{sources}->{$ddest}->{$s} = 1;
2089 foreach (keys %shared_sources) {
2091 my $ddest = cleanfile($buildd, $_, $blddir);
2092 foreach (@{$shared_sources{$dest}}) {
2093 my $s = cleanfile($sourced, $_, $blddir);
2095 # If it isn't in the source tree, we assume it's generated
2097 if ($s eq $src_configdata || ! -f $s || $generate{$_}) {
2098 $s = cleanfile($buildd, $_, $blddir);
2101 if ($s =~ /\.(cc|cpp|c|s|S)$/) {
2102 # We recognise C++, C and asm files
2104 $o =~ s/\.[csS]$/.o/; # C and assembler
2105 $o =~ s/\.(cc|cpp)$/_cc.o/; # C++
2106 $o = cleanfile($buildd, $o, $blddir);
2107 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2108 $unified_info{sources}->{$o}->{$s} = -1;
2109 } elsif ($s =~ /\.rc$/) {
2110 # We also recognise resource files
2112 $o =~ s/\.rc$/.res/; # Resource configuration
2113 my $o = cleanfile($buildd, $o, $blddir);
2114 $unified_info{shared_sources}->{$ddest}->{$o} = -1;
2115 $unified_info{sources}->{$o}->{$s} = -1;
2116 } elsif ($s =~ /\.ld$/) {
2117 # We also recognise linker scripts (or corresponding)
2118 # We know they are generated files
2119 my $ld = cleanfile($buildd, $_, $blddir);
2120 $unified_info{shared_sources}->{$ddest}->{$ld} = 1;
2122 die "unrecognised source file type for shared library: $s\n";
2127 foreach (keys %generate) {
2129 my $ddest = cleanfile($buildd, $_, $blddir);
2130 die "more than one generator for $dest: "
2131 ,join(" ", @{$generate{$_}}),"\n"
2132 if scalar @{$generate{$_}} > 1;
2133 my @generator = split /\s+/, $generate{$dest}->[0];
2134 my $gen = $generator[0];
2135 $generator[0] = cleanfile($sourced, $gen, $blddir);
2137 # If the generator isn't in the source tree, we assume it's
2138 # generated in the build tree
2139 if ($generate{$gen}) {
2140 $generator[0] = cleanfile($buildd, $gen, $blddir);
2143 $unified_info{generate}->{$ddest} = [ @generator ];
2146 foreach (keys %depends) {
2148 my $ddest = $dest eq "" ? "" : cleanfile($sourced, $_, $blddir);
2150 # If the destination doesn't exist in source, it can only be
2151 # a generated file in the build tree.
2152 if ($ddest ne "" && ($ddest eq $src_configdata || ! -f $ddest)) {
2153 $ddest = cleanfile($buildd, $_, $blddir);
2155 foreach (@{$depends{$dest}}) {
2156 my $d = cleanfile($sourced, $_, $blddir);
2158 # If we know it's generated, or assume it is because we can't
2159 # find it in the source tree, we set file we depend on to be
2160 # in the build tree rather than the source tree, and assume
2161 # and that there are lines to build it in a BEGINRAW..ENDRAW
2162 # section or in the Makefile template.
2163 if ($d eq $src_configdata
2165 || (grep { $d eq $_ }
2166 map { cleanfile($srcdir, $_, $blddir) }
2167 grep { /\.h$/ } keys %{$unified_info{generate}})) {
2168 $d = cleanfile($buildd, $_, $blddir);
2170 # Take note if the file to depend on is being renamed
2171 # Take extra care with files ending with .a, they should
2172 # be treated without that extension, and the extension
2173 # should be added back after treatment.
2177 $unified_info{depends}->{$ddest}->{$d} = 1;
2179 # Fix up associated attributes
2180 $unified_info{attributes}->{depends}->{$ddest}->{$d} =
2181 $attributes{depends}->{$dest}->{$_}
2182 if defined $attributes{depends}->{$dest}->{$_};
2186 foreach (keys %includes) {
2188 my $ddest = cleanfile($sourced, $_, $blddir);
2190 # If the destination doesn't exist in source, it can only be
2191 # a generated file in the build tree.
2192 if ($ddest eq $src_configdata || ! -f $ddest) {
2193 $ddest = cleanfile($buildd, $_, $blddir);
2195 foreach (@{$includes{$dest}}) {
2196 my $is = cleandir($sourced, $_, $blddir);
2197 my $ib = cleandir($buildd, $_, $blddir);
2198 push @{$unified_info{includes}->{$ddest}->{source}}, $is
2199 unless grep { $_ eq $is } @{$unified_info{includes}->{$ddest}->{source}};
2200 push @{$unified_info{includes}->{$ddest}->{build}}, $ib
2201 unless grep { $_ eq $ib } @{$unified_info{includes}->{$ddest}->{build}};
2205 foreach my $dest (keys %defines) {
2209 $ddest = cleanfile($sourced, $dest, $blddir);
2211 # If the destination doesn't exist in source, it can only
2212 # be a generated file in the build tree.
2214 $ddest = cleanfile($buildd, $dest, $blddir);
2215 if ($unified_info{rename}->{$ddest}) {
2216 $ddest = $unified_info{rename}->{$ddest};
2220 foreach my $v (@{$defines{$dest}}) {
2221 $v =~ m|^([^=]*)(=.*)?$|;
2222 die "0 length macro name not permitted\n" if $1 eq "";
2224 die "$1 defined more than once\n"
2225 if defined $unified_info{defines}->{$ddest}->{$1};
2226 $unified_info{defines}->{$ddest}->{$1} = $2;
2228 die "$1 defined more than once\n"
2229 if grep { $v eq $_ } @{$config{defines}};
2230 push @{$config{defines}}, $v;
2235 foreach my $section (keys %htmldocs) {
2236 foreach (@{$htmldocs{$section}}) {
2237 my $htmldocs = cleanfile($buildd, $_, $blddir);
2238 $unified_info{htmldocs}->{$section}->{$htmldocs} = 1;
2242 foreach my $section (keys %mandocs) {
2243 foreach (@{$mandocs{$section}}) {
2244 my $mandocs = cleanfile($buildd, $_, $blddir);
2245 $unified_info{mandocs}->{$section}->{$mandocs} = 1;
2250 my $ordinals_text = join(', ', sort keys %ordinals);
2251 warn <<"EOF" if $ordinals_text;
2253 WARNING: ORDINALS were specified for $ordinals_text
2254 They are ignored and should be replaced with a combination of GENERATE,
2255 DEPEND and SHARED_SOURCE.
2259 # Go through the sources of all libraries and check that the same basename
2260 # doesn't appear more than once. Some static library archivers depend on
2261 # them being unique.
2264 foreach my $prod (keys %{$unified_info{libraries}}) {
2266 map { keys %{$unified_info{sources}->{$_}} }
2267 keys %{$unified_info{sources}->{$prod}};
2270 # Count how many times a given each source basename
2271 # appears for each product.
2272 foreach my $src (@prod_sources) {
2273 $srccnt{basename $src}++;
2276 foreach my $src (keys %srccnt) {
2277 if ((my $cnt = $srccnt{$src}) > 1) {
2278 print STDERR "$src appears $cnt times for the product $prod\n";
2286 # Massage the result
2288 # If we depend on a header file or a perl module, add an inclusion of
2289 # its directory to allow smoothe inclusion
2290 foreach my $dest (keys %{$unified_info{depends}}) {
2291 next if $dest eq "";
2292 foreach my $d (keys %{$unified_info{depends}->{$dest}}) {
2293 next unless $d =~ /\.(h|pm)$/;
2294 my $i = dirname($d);
2296 $d eq "configdata.pm" || defined($unified_info{generate}->{$d})
2297 ? 'build' : 'source';
2298 push @{$unified_info{includes}->{$dest}->{$spot}}, $i
2299 unless grep { $_ eq $i } @{$unified_info{includes}->{$dest}->{$spot}};
2303 # Go through all intermediary files and change their names to something that
2304 # reflects what they will be built for. Note that for some source files,
2305 # this leads to duplicate object files because they are used multiple times.
2306 # the goal is to rename all object files according to this scheme:
2307 # {productname}-{midfix}-{origobjname}.[o|res]
2308 # the {midfix} is a keyword indicating the type of product, which is mostly
2309 # valuable for libraries since they come in two forms.
2311 # This also reorganises the {sources} and {shared_sources} so that the
2312 # former only contains ALL object files that are supposed to end up in
2313 # static libraries and programs, while the latter contains ALL object files
2314 # that are supposed to end up in shared libraries and DSOs.
2315 # The main reason for having two different source structures is to allow
2316 # the same name to be used for the static and the shared variants of a
2319 # Take copies so we don't get interference from added stuff
2320 my %unified_copy = ();
2321 foreach (('sources', 'shared_sources')) {
2322 $unified_copy{$_} = { %{$unified_info{$_}} }
2323 if defined($unified_info{$_});
2324 delete $unified_info{$_};
2326 foreach my $prodtype (('programs', 'libraries', 'modules', 'scripts')) {
2327 # $intent serves multi purposes:
2328 # - give a prefix for the new object files names
2329 # - in the case of libraries, rearrange the object files so static
2330 # libraries use the 'sources' structure exclusively, while shared
2331 # libraries use the 'shared_sources' structure exclusively.
2333 programs => { bin => { src => [ 'sources' ],
2334 dst => 'sources' } },
2335 libraries => { lib => { src => [ 'sources' ],
2337 shlib => { prodselect =>
2338 sub { grep !/\.a$/, @_ },
2341 dst => 'shared_sources' } },
2342 modules => { dso => { src => [ 'sources' ],
2343 dst => 'sources' } },
2344 scripts => { script => { src => [ 'sources' ],
2345 dst => 'sources' } }
2347 foreach my $kind (keys %$intent) {
2348 next if ($intent->{$kind}->{dst} eq 'shared_sources'
2349 && $disabled{shared});
2351 my @src = @{$intent->{$kind}->{src}};
2352 my $dst = $intent->{$kind}->{dst};
2353 my $prodselect = $intent->{$kind}->{prodselect} // sub { @_ };
2354 foreach my $prod ($prodselect->(keys %{$unified_info{$prodtype}})) {
2355 # %prod_sources has all applicable objects as keys, and
2356 # their corresponding sources as values
2358 map { $_ => [ keys %{$unified_copy{sources}->{$_}} ] }
2359 map { keys %{$unified_copy{$_}->{$prod}} }
2361 foreach (keys %prod_sources) {
2362 # Only affect object files and resource files,
2363 # the others simply get a new value
2364 # (+1 instead of -1)
2365 if ($_ =~ /\.(o|res)$/) {
2366 (my $prodname = $prod) =~ s|\.a$||;
2368 catfile(dirname($_),
2371 . '-' . basename($_));
2372 $unified_info{$dst}->{$prod}->{$newobj} = 1;
2373 foreach my $src (@{$prod_sources{$_}}) {
2374 $unified_info{sources}->{$newobj}->{$src} = 1;
2376 # Adjust dependencies
2377 foreach my $deps (keys %{$unified_info{depends}->{$_}}) {
2378 $unified_info{depends}->{$_}->{$deps} = -1;
2379 $unified_info{depends}->{$newobj}->{$deps} = 1;
2382 foreach my $k (('source', 'build')) {
2384 defined($unified_info{includes}->{$_}->{$k});
2385 my @incs = @{$unified_info{includes}->{$_}->{$k}};
2386 $unified_info{includes}->{$newobj}->{$k} = [ @incs ];
2389 $unified_info{$dst}->{$prod}->{$_} = 1;
2397 # At this point, we have a number of sources with the value -1. They
2398 # aren't part of the local build and are probably meant for a different
2399 # platform, and can therefore be cleaned away. That happens when making
2400 # %unified_info more efficient below.
2402 ### Make unified_info a bit more efficient
2403 # One level structures
2404 foreach (("programs", "libraries", "modules", "scripts")) {
2405 $unified_info{$_} = [ sort keys %{$unified_info{$_}} ];
2407 # Two level structures
2408 foreach my $l1 (("sources", "shared_sources", "ldadd", "depends",
2409 "htmldocs", "mandocs")) {
2410 foreach my $l2 (sort keys %{$unified_info{$l1}}) {
2413 grep { $unified_info{$l1}->{$l2}->{$_} > 0 }
2414 keys %{$unified_info{$l1}->{$l2}};
2416 $unified_info{$l1}->{$l2} = [ @items ];
2418 delete $unified_info{$l1}->{$l2};
2423 foreach my $dest (sort keys %{$unified_info{defines}}) {
2424 $unified_info{defines}->{$dest}
2425 = [ map { $_.$unified_info{defines}->{$dest}->{$_} }
2426 sort keys %{$unified_info{defines}->{$dest}} ];
2429 foreach my $dest (sort keys %{$unified_info{includes}}) {
2430 if (defined($unified_info{includes}->{$dest}->{build})) {
2431 my @source_includes = ();
2432 @source_includes = ( @{$unified_info{includes}->{$dest}->{source}} )
2433 if defined($unified_info{includes}->{$dest}->{source});
2434 $unified_info{includes}->{$dest} =
2435 [ @{$unified_info{includes}->{$dest}->{build}} ];
2436 foreach my $inc (@source_includes) {
2437 push @{$unified_info{includes}->{$dest}}, $inc
2438 unless grep { $_ eq $inc } @{$unified_info{includes}->{$dest}};
2440 } elsif (defined($unified_info{includes}->{$dest}->{source})) {
2441 $unified_info{includes}->{$dest} =
2442 [ @{$unified_info{includes}->{$dest}->{source}} ];
2444 delete $unified_info{includes}->{$dest};
2448 # For convenience collect information regarding directories where
2449 # files are generated, those generated files and the end product
2450 # they end up in where applicable. Then, add build rules for those
2452 my %loopinfo = ( "lib" => [ @{$unified_info{libraries}} ],
2453 "dso" => [ @{$unified_info{modules}} ],
2454 "bin" => [ @{$unified_info{programs}} ],
2455 "script" => [ @{$unified_info{scripts}} ],
2456 "docs" => [ (map { @{$unified_info{htmldocs}->{$_} // []} }
2457 keys %{$unified_info{htmldocs} // {}}),
2458 (map { @{$unified_info{mandocs}->{$_} // []} }
2459 keys %{$unified_info{mandocs} // {}}) ] );
2460 foreach my $type (keys %loopinfo) {
2461 foreach my $product (@{$loopinfo{$type}}) {
2463 my $pd = dirname($product);
2465 foreach (@{$unified_info{sources}->{$product} // []},
2466 @{$unified_info{shared_sources}->{$product} // []}) {
2467 my $d = dirname($_);
2469 # We don't want to create targets for source directories
2470 # when building out of source
2471 next if ($config{sourcedir} ne $config{builddir}
2472 && $d =~ m|^\Q$config{sourcedir}\E|);
2473 # We already have a "test" target, and the current directory
2474 # is just silly to make a target for
2475 next if $d eq "test" || $d eq ".";
2478 push @{$unified_info{dirinfo}->{$d}->{deps}}, $_
2481 foreach (keys %dirs) {
2482 push @{$unified_info{dirinfo}->{$_}->{products}->{$type}},
2489 # For the schemes that need it, we provide the old *_obj configs
2490 # from the *_asm_obj ones
2491 foreach (grep /_(asm|aux)_src$/, keys %target) {
2493 (my $obj = $_) =~ s/_(asm|aux)_src$/_obj/;
2494 $target{$obj} = $target{$src};
2495 $target{$obj} =~ s/\.[csS]\b/.o/g; # C and assembler
2496 $target{$obj} =~ s/\.(cc|cpp)\b/_cc.o/g; # C++
2499 # Write down our configuration where it fits #########################
2501 my %template_vars = (
2504 disablables => \@disablables,
2505 disablables_int => \@disablables_int,
2506 disabled => \%disabled,
2507 withargs => \%withargs,
2508 unified_info => \%unified_info,
2511 makevars => [ sort keys %user ],
2512 disabled_info => \%disabled_info,
2513 user_crossable => \@user_crossable,
2515 my $configdata_outname = 'configdata.pm';
2516 print "Creating $configdata_outname\n";
2517 open CONFIGDATA, ">$configdata_outname.new"
2518 or die "Trying to create $configdata_outname.new: $!";
2519 my $configdata_tmplname = cleanfile($srcdir, "configdata.pm.in", $blddir);
2520 my $configdata_tmpl =
2521 OpenSSL::Template->new(TYPE => 'FILE', SOURCE => $configdata_tmplname);
2522 $configdata_tmpl->fill_in(
2523 FILENAME => $configdata_tmplname,
2524 OUTPUT => \*CONFIGDATA,
2525 HASH => { %template_vars,
2527 'WARNING: do not edit!',
2528 "Generated by Configure from $configdata_tmplname",
2530 ) or die $Text::Template::ERROR;
2532 rename "$configdata_outname.new", $configdata_outname;
2533 if ($builder_platform eq 'unix') {
2534 my $mode = (0755 & ~umask);
2535 chmod $mode, 'configdata.pm'
2536 or warn sprintf("WARNING: Couldn't change mode for 'configdata.pm' to 0%03o: %s\n",$mode,$!);
2539 print "Running $configdata_outname\n";
2540 my $perlcmd = (quotify("maybeshell", $config{PERL}))[0];
2541 my $cmd = "$perlcmd $configdata_outname";
2542 #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n";
2546 $SIG{__DIE__} = $orig_death_handler;
2548 print <<"EOF" if ($disabled{threads} eq "unavailable");
2550 The library could not be configured for supporting multi-threaded
2551 applications as the compiler options required on this system are not known.
2552 See file INSTALL for details if you need multi-threading.
2555 print <<"EOF" if ($no_shared_warn);
2557 The options 'shared', 'pic' and 'dynamic-engine' aren't supported on this
2558 platform, so we will pretend you gave the option 'no-pic', which also disables
2559 'shared' and 'dynamic-engine'. If you know how to implement shared libraries
2560 or position independent code, please let us know (but please first make sure
2561 you have tried with a current version of OpenSSL).
2566 **********************************************************************
2568 *** OpenSSL has been successfully configured ***
2570 *** If you encounter a problem while building, please open an ***
2571 *** issue on GitHub <https://github.com/openssl/openssl/issues> ***
2572 *** and include the output from the following command: ***
2574 *** perl configdata.pm --dump ***
2576 *** (If you are new to OpenSSL, you might want to consult the ***
2577 *** 'Troubleshooting' section in the INSTALL file first) ***
2579 **********************************************************************
2584 ######################################################################
2586 # Helpers and utility functions
2589 # Death handler, to print a helpful message in case of failure #######
2592 die @_ if $^S; # To prevent the added message in eval blocks
2593 my $build_file = $target{build_file} // "build file";
2594 my @message = ( <<"_____", @_ );
2596 Failure! $build_file wasn't produced.
2597 Please read INSTALL and associated NOTES files. You may also have to look over
2598 your available compiler tool chain or change your configuration.
2602 # Dying is terminal, so it's ok to reset the signal handler here.
2603 $SIG{__DIE__} = $orig_death_handler;
2607 # Configuration file reading #########################################
2609 # Note: All of the helper functions are for lazy evaluation. They all
2610 # return a CODE ref, which will return the intended value when evaluated.
2611 # Thus, whenever there's mention of a returned value, it's about that
2614 # Helper function to implement conditional value variants, with a default
2615 # plus additional values based on the value of $config{build_type}.
2616 # Arguments are given in hash table form:
2618 # picker(default => "Basic string: ",
2620 # release => "release")
2622 # When configuring with --debug, the resulting string will be
2623 # "Basic string: debug", and when not, it will be "Basic string: release"
2625 # This can be used to create variants of sets of flags according to the
2628 # cflags => picker(default => "-Wall",
2629 # debug => "-g -O0",
2634 return sub { add($opts{default} || (),
2635 $opts{$config{build_type}} || ())->(); }
2638 # Helper function to combine several values of different types into one.
2639 # This is useful if you want to combine a string with the result of a
2640 # lazy function, such as:
2642 # cflags => combine("-Wall", sub { $disabled{zlib} ? () : "-DZLIB" })
2646 return sub { add(@stuff)->(); }
2649 # Helper function to implement conditional values depending on the value
2650 # of $disabled{threads}. Can be used as follows:
2652 # cflags => combine("-Wall", threads("-pthread"))
2656 return sub { add($disabled{threads} ? () : @flags)->(); }
2661 return sub { add($disabled{shared} ? () : @flags)->(); }
2664 our $add_called = 0;
2665 # Helper function to implement adding values to already existing configuration
2666 # values. It handles elements that are ARRAYs, CODEs and scalars
2668 my $separator = shift;
2670 # If there's any ARRAY in the collection of values OR the separator
2671 # is undef, we will return an ARRAY of combined values, otherwise a
2672 # string of joined values with $separator as the separator.
2673 my $found_array = !defined($separator);
2678 while (ref($res) eq "CODE") {
2681 if (defined($res)) {
2682 if (ref($res) eq "ARRAY") {
2698 join($separator, grep { defined($_) && $_ ne "" } @values);
2702 my $separator = " ";
2703 if (ref($_[$#_]) eq "HASH") {
2705 $separator = $opts->{separator};
2708 sub { _add($separator, @x, @_) };
2711 my $separator = " ";
2712 if (ref($_[$#_]) eq "HASH") {
2714 $separator = $opts->{separator};
2717 sub { _add($separator, @_, @x) };
2720 sub read_eval_file {
2725 open F, "< $fname" or die "Can't open '$fname': $!\n";
2734 @result = ( eval $content );
2737 return wantarray ? @result : $result[0];
2740 # configuration reader, evaluates the input file as a perl script and expects
2741 # it to fill %targets with target configurations. Those are then added to
2748 # Protect certain tables from tampering
2751 %targets = read_eval_file($fname);
2753 my %preexisting = ();
2754 foreach (sort keys %targets) {
2755 $preexisting{$_} = 1 if $table{$_};
2758 The following config targets from $fname
2759 shadow pre-existing config targets with the same name:
2761 map { " $_\n" } sort keys %preexisting
2765 # For each target, check that it's configured with a hash table.
2766 foreach (keys %targets) {
2767 if (ref($targets{$_}) ne "HASH") {
2768 if (ref($targets{$_}) eq "") {
2769 warn "Deprecated target configuration for $_, ignoring...\n";
2771 warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n";
2773 delete $targets{$_};
2775 $targets{$_}->{_conf_fname_int} = add([ $fname ]);
2779 %table = (%table, %targets);
2783 # configuration resolver. Will only resolve all the lazy evaluation
2784 # codeblocks for the chosen target and all those it inherits from,
2786 sub resolve_config {
2788 my @breadcrumbs = @_;
2790 # my $extra_checks = defined($ENV{CONFIGURE_EXTRA_CHECKS});
2792 if (grep { $_ eq $target } @breadcrumbs) {
2793 die "inherit_from loop! target backtrace:\n "
2794 ,$target,"\n ",join("\n ", @breadcrumbs),"\n";
2797 if (!defined($table{$target})) {
2798 warn "Warning! target $target doesn't exist!\n";
2801 # Recurse through all inheritances. They will be resolved on the
2802 # fly, so when this operation is done, they will all just be a
2803 # bunch of attributes with string values.
2804 # What we get here, though, are keys with references to lists of
2805 # the combined values of them all. We will deal with lists after
2806 # this stage is done.
2807 my %combined_inheritance = ();
2808 if ($table{$target}->{inherit_from}) {
2810 map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}};
2811 foreach (@inherit_from) {
2812 my %inherited_config = resolve_config($_, $target, @breadcrumbs);
2814 # 'template' is a marker that's considered private to
2815 # the config that had it.
2816 delete $inherited_config{template};
2818 foreach (keys %inherited_config) {
2819 if (!$combined_inheritance{$_}) {
2820 $combined_inheritance{$_} = [];
2822 push @{$combined_inheritance{$_}}, $inherited_config{$_};
2827 # We won't need inherit_from in this target any more, since we've
2828 # resolved all the inheritances that lead to this
2829 delete $table{$target}->{inherit_from};
2831 # Now is the time to deal with those lists. Here's the place to
2832 # decide what shall be done with those lists, all based on the
2833 # values of the target we're currently dealing with.
2834 # - If a value is a coderef, it will be executed with the list of
2835 # inherited values as arguments.
2836 # - If the corresponding key doesn't have a value at all or is the
2837 # empty string, the inherited value list will be run through the
2838 # default combiner (below), and the result becomes this target's
2840 # - Otherwise, this target's value is assumed to be a string that
2841 # will simply override the inherited list of values.
2842 my $default_combiner = add();
2845 map { $_ => 1 } (keys %combined_inheritance,
2846 keys %{$table{$target}});
2848 sub process_values {
2850 my $inherited = shift; # Always a [ list ]
2856 while(ref($object) eq "CODE") {
2857 $object = $object->(@$inherited);
2859 if (!defined($object)) {
2862 elsif (ref($object) eq "ARRAY") {
2863 local $add_called; # To make sure recursive calls don't affect it
2864 return [ map { process_values($_, $inherited, $target, $entry) }
2866 } elsif (ref($object) eq "") {
2869 die "cannot handle reference type ",ref($object)
2870 ," found in target ",$target," -> ",$entry,"\n";
2874 foreach (sort keys %all_keys) {
2875 my $previous = $combined_inheritance{$_};
2877 # Current target doesn't have a value for the current key?
2878 # Assign it the default combiner, the rest of this loop body
2879 # will handle it just like any other coderef.
2880 if (!exists $table{$target}->{$_}) {
2881 $table{$target}->{$_} = $default_combiner;
2884 $table{$target}->{$_} = process_values($table{$target}->{$_},
2885 $combined_inheritance{$_},
2887 unless(defined($table{$target}->{$_})) {
2888 delete $table{$target}->{$_};
2890 # if ($extra_checks &&
2891 # $previous && !($add_called || $previous ~~ $table{$target}->{$_})) {
2892 # warn "$_ got replaced in $target\n";
2896 # Finally done, return the result.
2897 return %{$table{$target}};
2902 print STDERR $usage;
2903 print STDERR "\npick os/compiler from:\n";
2907 foreach $i (sort keys %table)
2909 next if $table{$i}->{template};
2910 next if $i =~ /^debug/;
2911 $k += length($i) + 1;
2917 print STDERR $i . " ";
2919 foreach $i (sort keys %table)
2921 next if $table{$i}->{template};
2922 next if $i !~ /^debug/;
2923 $k += length($i) + 1;
2929 print STDERR $i . " ";
2931 print STDERR "\n\nNOTE: If in doubt, on Unix-ish systems use './config'.\n";
2935 sub compiler_predefined {
2939 return () if $^O eq 'VMS';
2941 die 'compiler_predefined called without a compiler command'
2944 if (! $predefined{$cc}) {
2946 $predefined{$cc} = {};
2948 # collect compiler pre-defines from gcc or gcc-alike...
2949 open(PIPE, "$cc -dM -E -x c /dev/null 2>&1 |");
2950 while (my $l = <PIPE>) {
2951 $l =~ m/^#define\s+(\w+(?:\(\w+\))?)(?:\s+(.+))?/ or last;
2952 $predefined{$cc}->{$1} = $2 // '';
2957 return %{$predefined{$cc}};
2964 if (eval { require IPC::Cmd; 1; }) {
2966 return scalar IPC::Cmd::can_run($name);
2968 # if there is $directories component in splitpath,
2969 # then it's not something to test with $PATH...
2970 return $name if (File::Spec->splitpath($name))[1];
2972 foreach (File::Spec->path()) {
2973 my $fullpath = catfile($_, "$name$target{exe_extension}");
2974 if (-f $fullpath and -x $fullpath) {
2986 unless ($opts{cacheonly}) {
2987 # Note that if $ENV{$name} doesn't exist or is undefined,
2988 # $config{perlenv}->{$name} will be created with the value
2989 # undef. This is intentional.
2991 $config{perlenv}->{$name} = $ENV{$name}
2992 if ! exists $config{perlenv}->{$name};
2994 return $config{perlenv}->{$name};
2997 # Configuration printer ##############################################
2999 sub print_table_entry
3001 local $now_printing = shift;
3002 my %target = resolve_config($now_printing);
3005 # Don't print the templates
3006 return if $target{template};
3049 if ($type eq "TABLE") {
3051 print "*** $now_printing\n";
3052 foreach (@sequence) {
3053 if (ref($target{$_}) eq "ARRAY") {
3054 printf "\$%-12s = %s\n", $_, join(" ", @{$target{$_}});
3056 printf "\$%-12s = %s\n", $_, $target{$_};
3059 } elsif ($type eq "HASH") {
3061 length((sort { length($a) <=> length($b) } @sequence)[-1]);
3062 print " '$now_printing' => {\n";
3063 foreach (@sequence) {
3065 if (ref($target{$_}) eq "ARRAY") {
3066 print " '",$_,"'"," " x ($largest - length($_))," => [ ",join(", ", map { "'$_'" } @{$target{$_}})," ],\n";
3068 print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n";
3076 # Utility routines ###################################################
3078 # On VMS, if the given file is a logical name, File::Spec::Functions
3079 # will consider it an absolute path. There are cases when we want a
3080 # purely syntactic check without checking the environment.
3084 # On non-platforms, we just use file_name_is_absolute().
3085 return file_name_is_absolute($file) unless $^O eq "VMS";
3087 # If the file spec includes a device or a directory spec,
3088 # file_name_is_absolute() is perfectly safe.
3089 return file_name_is_absolute($file) if $file =~ m|[:\[]|;
3091 # Here, we know the given file spec isn't absolute
3095 # Makes a directory absolute and cleans out /../ in paths like foo/../bar
3096 # On some platforms, this uses rel2abs(), while on others, realpath() is used.
3097 # realpath() requires that at least all path components except the last is an
3098 # existing directory. On VMS, the last component of the directory spec must
3103 # realpath() is quite buggy on VMS. It uses LIB$FID_TO_NAME, which
3104 # will return the volume name for the device, no matter what. Also,
3105 # it will return an incorrect directory spec if the argument is a
3106 # directory that doesn't exist.
3108 return rel2abs($dir);
3111 # We use realpath() on Unix, since no other will properly clean out
3113 use Cwd qw/realpath/;
3115 return realpath($dir);
3120 perl => sub { my $x = shift;
3121 $x =~ s/([\\\$\@"])/\\$1/g;
3122 return '"'.$x.'"'; },
3123 maybeshell => sub { my $x = shift;
3124 (my $y = $x) =~ s/([\\\"])/\\$1/g;
3125 if ($x ne $y || $x =~ m|\s|) {
3134 defined($processors{$for}) ? $processors{$for} : sub { shift; };
3136 return map { $processor->($_); } @_;
3139 # collect_from_file($filename, $line_concat_cond_re, $line_concat)
3140 # $filename is a file name to read from
3141 # $line_concat_cond_re is a regexp detecting a line continuation ending
3142 # $line_concat is a CODEref that takes care of concatenating two lines
3143 sub collect_from_file {
3144 my $filename = shift;
3145 my $line_concat_cond_re = shift;
3146 my $line_concat = shift;
3148 open my $fh, $filename || die "unable to read $filename: $!\n";
3150 my $saved_line = "";
3154 if (defined $line_concat) {
3155 $_ = $line_concat->($saved_line, $_);
3158 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3164 die "$filename ending with continuation line\n" if $_;
3170 # collect_from_array($array, $line_concat_cond_re, $line_concat)
3171 # $array is an ARRAYref of lines
3172 # $line_concat_cond_re is a regexp detecting a line continuation ending
3173 # $line_concat is a CODEref that takes care of concatenating two lines
3174 sub collect_from_array {
3176 my $line_concat_cond_re = shift;
3177 my $line_concat = shift;
3178 my @array = (@$array);
3181 my $saved_line = "";
3183 while (defined($_ = shift @array)) {
3185 if (defined $line_concat) {
3186 $_ = $line_concat->($saved_line, $_);
3189 if (defined $line_concat_cond_re && /$line_concat_cond_re/) {
3195 die "input text ending with continuation line\n" if $_;
3200 # collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...)
3201 # $lineiterator is a CODEref that delivers one line at a time.
3202 # All following arguments are regex/CODEref pairs, where the regexp detects a
3203 # line and the CODEref does something with the result of the regexp.
3204 sub collect_information {
3205 my $lineiterator = shift;
3206 my %collectors = @_;
3208 while(defined($_ = $lineiterator->())) {
3211 if ($collectors{"BEFORE"}) {
3212 $collectors{"BEFORE"}->($_);
3214 foreach my $re (keys %collectors) {
3215 if ($re !~ /^OTHERWISE|BEFORE|AFTER$/ && /$re/) {
3216 $collectors{$re}->($lineiterator);
3220 if ($collectors{"OTHERWISE"}) {
3221 $collectors{"OTHERWISE"}->($lineiterator, $_)
3222 unless $found || !defined $collectors{"OTHERWISE"};
3224 if ($collectors{"AFTER"}) {
3225 $collectors{"AFTER"}->($_);
3231 # tokenize($line,$separator)
3232 # $line is a line of text to split up into tokens
3233 # $separator [optional] is a regular expression that separates the tokens,
3234 # the default being spaces. Do not use quotes of any kind as separators,
3235 # that will give undefined results.
3236 # Returns a list of tokens.
3238 # Tokens are divided by separator (spaces by default). If the tokens include
3239 # the separators, they have to be quoted with single or double quotes.
3240 # Double quotes inside a double quoted token must be escaped. Escaping is done
3242 # Basically, the same quoting rules apply for " and ' as in any
3245 my $line = my $debug_line = shift;
3246 my $separator = shift // qr|\s+|;
3249 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3250 print STDERR "DEBUG[tokenize]: \$separator = $separator\n";
3253 while ($line =~ s|^${separator}||, $line ne "") {
3256 $line =~ m/^(.*?)(${separator}|"|'|$)/;
3260 if ($line =~ m/^"((?:[^"\\]+|\\.)*)"/) {
3264 } elsif ($line =~ m/^'([^']*)'/) {
3269 push @result, $token;
3272 if ($ENV{CONFIGURE_DEBUG_TOKENIZE}) {
3273 print STDERR "DEBUG[tokenize]: Parsed '$debug_line' into:\n";
3274 print STDERR "DEBUG[tokenize]: ('", join("', '", @result), "')\n";