X-Git-Url: https://git.openssl.org/gitweb/?p=openssl.git;a=blobdiff_plain;f=Configure;h=06eca504b59b8c35d4ae17141e284e2210a9bdad;hp=5e973c69a3d5fa419178db2fe5c2abf3b7654c17;hb=f1f07a2367e5381ff6e96a89b2512adfa3e14d0e;hpb=642a613809ef68432eefbbd957ec542c70a8d7b4 diff --git a/Configure b/Configure index 5e973c69a3..06eca504b5 100755 --- a/Configure +++ b/Configure @@ -10,7 +10,9 @@ require 5.000; use strict; use File::Basename; -use File::Spec::Functions; +use File::Spec::Functions qw/:DEFAULT abs2rel rel2abs catpath splitpath/; +use File::Path qw/make_path/; +use Cwd qw/:DEFAULT realpath/; # see INSTALL for instructions. @@ -65,32 +67,8 @@ my $usage="Usage: Configure [no- ...] [enable- ...] [experimenta # DEBUG_SAFESTACK use type-safe stacks to enforce type-safety on stack items # provided to stack calls. Generates unique stack functions for # each possible stack type. -# DES_PTR use pointer lookup vs arrays in the DES in crypto/des/des_locl.h -# DES_RISC1 use different DES_ENCRYPT macro that helps reduce register -# dependancies but needs to more registers, good for RISC CPU's -# DES_RISC2 A different RISC variant. -# DES_UNROLL unroll the inner DES loop, sometimes helps, somtimes hinders. -# DES_INT use 'int' instead of 'long' for DES_LONG in crypto/des/des.h -# This is used on the DEC Alpha where long is 8 bytes -# and int is 4 # BN_LLONG use the type 'long long' in crypto/bn/bn.h -# MD2_CHAR use 'char' instead of 'int' for MD2_INT in crypto/md2/md2.h -# MD2_LONG use 'long' instead of 'int' for MD2_INT in crypto/md2/md2.h -# IDEA_SHORT use 'short' instead of 'int' for IDEA_INT in crypto/idea/idea.h -# IDEA_LONG use 'long' instead of 'int' for IDEA_INT in crypto/idea/idea.h -# RC2_SHORT use 'short' instead of 'int' for RC2_INT in crypto/rc2/rc2.h -# RC2_LONG use 'long' instead of 'int' for RC2_INT in crypto/rc2/rc2.h # RC4_CHAR use 'char' instead of 'int' for RC4_INT in crypto/rc4/rc4.h -# RC4_LONG use 'long' instead of 'int' for RC4_INT in crypto/rc4/rc4.h -# RC4_INDEX define RC4_INDEX in crypto/rc4/rc4_locl.h. This turns on -# array lookups instead of pointer use. -# RC4_CHUNK enables code that handles data aligned at long (natural CPU -# word) boundary. -# RC4_CHUNK_LL enables code that handles data aligned at long long boundary -# (intended for 64-bit CPUs running 32-bit OS). -# BF_PTR use 'pointer arithmatic' for Blowfish (unsafe on Alpha). -# BF_PTR2 intel specific version (generic version is more efficient). -# # Following are set automatically by this script # # MD5_ASM use some extra md5 assember, @@ -121,14 +99,8 @@ my $warn_make_depend = 0; # This adds backtrace information to the memory leak info. my $memleak_devteam_backtrace = "-rdynamic -DCRYPTO_MDEBUG_BACKTRACE"; - my $strict_warnings = 0; -my $x86_gcc_des="DES_PTR DES_RISC1 DES_UNROLL"; - -# MD2_CHAR slags pentium pros -my $x86_gcc_opts="RC4_INDEX MD2_INT"; - # As for $BSDthreads. Idea is to maintain "collective" set of flags, # which would cover all BSD flavors. -pthread applies to them all, # but is treated differently. OpenBSD expands is as -D_POSIX_THREAD @@ -167,35 +139,83 @@ sub read_config; sub resolve_config; -my ($vol, $dir, $dummy) = File::Spec->splitpath($0); -my $pattern = File::Spec->catpath($vol, $dir, "Configurations/*.conf"); +# Information collection ############################################# + +# Unified build supports separate build dir +my $srcdir = catdir(realpath(dirname($0))); # catdir ensures local syntax +my $blddir = catdir(realpath(".")); # catdir ensures local syntax +my $dofile = abs2rel(catfile($srcdir, "util/dofile.pl")); + +$config{sourcedir} = abs2rel($srcdir); +$config{builddir} = abs2rel($blddir); + +# Collect version numbers +$config{version} = "unknown"; +$config{version_num} = "unknown"; +$config{shlib_version_number} = "unknown"; +$config{shlib_version_history} = "unknown"; + +collect_information( + collect_from_file(catfile($srcdir,'include/openssl/opensslv.h')), + qr/OPENSSL.VERSION.TEXT.*OpenSSL (\S+) / => sub { $config{version} = $1; }, + qr/OPENSSL.VERSION.NUMBER.*(0x\S+)/ => sub { $config{version_num}=$1 }, + qr/SHLIB_VERSION_NUMBER *"([^"]+)"/ => sub { $config{shlib_version_number}=$1 }, + qr/SHLIB_VERSION_HISTORY *"([^"]*)"/ => sub { $config{shlib_version_history}=$1 } + ); +if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; } + +($config{major}, $config{minor}) + = ($config{version} =~ /^([0-9]+)\.([0-9\.]+)/); +($config{shlib_major}, $config{shlib_minor}) + = ($config{shlib_version_number} =~ /^([0-9]+)\.([0-9\.]+)/); +die "erroneous version information in opensslv.h: ", + "$config{major}, $config{minor}, $config{shlib_major}, $config{shlib_minor}\n" + if ($config{major} eq "" || $config{minor} eq "" + || $config{shlib_major} eq "" || $config{shlib_minor} eq ""); + +# Collect target configurations + +my ($vol, $dir, $dummy) = splitpath($0); +my $pattern = catpath($vol, catdir($dir, "Configurations"), "*.conf"); foreach (sort glob($pattern) ) { &read_config($_); } +print "Configuring OpenSSL version $config{version} (0x$config{version_num})\n"; + $config{perl}; $config{prefix}=""; $config{openssldir}=""; $config{processor}=""; -my $libdir=""; -my $exe_ext=""; -my $install_prefix= "$ENV{'INSTALL_PREFIX'}"; +$config{libdir}=""; +$config{install_prefix}= "$ENV{'INSTALL_PREFIX'}"; $config{cross_compile_prefix}=""; -my $fipslibdir="/usr/local/ssl/fips-2.0/lib/"; +$config{fipslibdir}="/usr/local/ssl/fips-2.0/lib/"; my $nofipscanistercheck=0; -my $baseaddr="0xFB00000"; +$config{baseaddr}="0xFB00000"; my $no_threads=0; my $threads=0; -my $no_shared=0; # but "no-shared" is default +$config{no_shared}=0; # but "no-shared" is default my $zlib=1; # but "no-zlib" is default my $no_rfc3779=0; my $no_asm=0; my $no_dso=0; -my @skip=(); -my $Makefile="Makefile"; my $default_ranlib; -my $fips=0; +$config{fips}=0; + +# Top level directories to build +$config{dirs} = [ "crypto", "ssl", "engines", "apps", "test", "tools" ]; +# crypto/ subdirectories to build +$config{sdirs} = [ + "objects", + "md2", "md4", "md5", "sha", "mdc2", "hmac", "ripemd", "whrlpool", "poly1305", + "des", "aes", "rc2", "rc4", "rc5", "idea", "bf", "cast", "camellia", "seed", "chacha", "modes", + "bn", "ec", "rsa", "dsa", "dh", "dso", "engine", + "buffer", "bio", "stack", "lhash", "rand", "err", + "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui", + "cms", "ts", "jpake", "srp", "store", "cmac", "ct", "async", "kdf" + ]; # Known TLS and DTLS protocols my @tls = qw(ssl3 tls1 tls1_1 tls1_2); @@ -233,7 +253,6 @@ my @disablables = ( "ec_nistp_64_gcc_128", "engine", "err", # Really??? - "gost", "heartbeats", "hmac", "hw(-.+)?", @@ -316,9 +335,7 @@ my @disable_cascades = ( "zlib" => [ "zlib-dynamic" ], "rijndael" => [ "aes" ], "des" => [ "mdc2" ], - "ec" => [ "ecdsa", "ecdh", "gost" ], - "dsa" => [ "gost" ], - "dh" => [ "gost" ], + "ec" => [ "ecdsa", "ecdh" ], "psk" => [ "jpake" ], "dgram" => [ "dtls" ], @@ -366,10 +383,10 @@ while ((my $first, my $second) = (shift @list, shift @list)) { unshift @list, $second; } -# Construct the string of what $depflags should look like with the defaults +# Construct the string of what $config{depflags} should look like with the defaults # from %disabled above. (we need this to see if we should advise the user # to run "make depend"): -my $default_depflags = " ".join(" ", +my $default_depflags = join(" ", map { my $x = $_; $x =~ tr{[a-z]-}{[A-Z]_}; "-DOPENSSL_NO_$x"; } grep { $disabled{$_} !~ /\(no-depflags\)$/ } sort keys %disabled); @@ -388,7 +405,7 @@ my $no_sse2=0; &usage if ($#ARGV < 0); my $flags=""; -my $depflags=""; +$config{depflags}=""; $config{openssl_experimental_defines}=[]; $config{openssl_api_defines}=[]; $config{openssl_algorithm_defines}=[]; @@ -398,7 +415,6 @@ $config{openssl_other_defines}=[]; my $libs=""; my $target=""; $config{options}=""; -my $api; my $make_depend=0; my %withargs=(); my $build_prefix = "release_"; @@ -544,7 +560,7 @@ foreach (@argvcopy) { $config{processor}=386; } elsif (/^fips$/) { - $fips=1; + $config{fips}=1; } elsif (/^rsaref$/) { @@ -554,7 +570,7 @@ foreach (@argvcopy) } elsif (/^nofipscanistercheck$/) { - $fips = 1; + $config{fips} = 1; $nofipscanistercheck = 1; } elsif (/^[-+]/) @@ -565,11 +581,11 @@ foreach (@argvcopy) } elsif (/^--api=(.*)$/) { - $api=$1; + $config{api}=$1; } elsif (/^--libdir=(.*)$/) { - $libdir=$1; + $config{libdir}=$1; } elsif (/^--openssldir=(.*)$/) { @@ -577,7 +593,7 @@ foreach (@argvcopy) } elsif (/^--install.prefix=(.*)$/) { - $install_prefix=$1; + $config{install_prefix}=$1; } elsif (/^--with-zlib-lib=(.*)$/) { @@ -589,11 +605,11 @@ foreach (@argvcopy) } elsif (/^--with-fipslibdir=(.*)$/) { - $fipslibdir="$1/"; + $config{fipslibdir}="$1/"; } elsif (/^--with-baseaddr=(.*)$/) { - $baseaddr="$1"; + $config{baseaddr}="$1"; } elsif (/^--cross-compile-prefix=(.*)$/) { @@ -636,8 +652,8 @@ foreach (@argvcopy) { $config{options} .= " ".$_; } } - if (defined($api) && !exists $apitable->{$api}) { - die "***** Unsupported api compatibility level: $api\n", + if (defined($config{api}) && !exists $apitable->{$config{api}}) { + die "***** Unsupported api compatibility level: $config{api}\n", } if (keys %unsupported_options) @@ -647,10 +663,14 @@ foreach (@argvcopy) } } -if ($fips) +if ($config{fips}) { delete $disabled{"shared"} if ($disabled{"shared"} =~ /^default/); } +else + { + @{$config{dirs}} = grep !/^fips$/, @{$config{dirs}}; + } my @tocheckfor = (keys %disabled); while (@tocheckfor) { @@ -705,7 +725,7 @@ foreach (sort (keys %disabled)) elsif (/^threads$/) { $no_threads = 1; } elsif (/^shared$/) - { $no_shared = 1; } + { $config{no_shared} = 1; } elsif (/^zlib$/) { $zlib = 0; } elsif (/^static-engine$/) @@ -714,6 +734,8 @@ foreach (sort (keys %disabled)) { } elsif (/^sse2$/) { $no_sse2 = 1; } + elsif (/^engine$/) + { @{$config{dirs}} = grep !/^engine$/, @{$config{dirs}}; } else { my ($ALGO, $algo); @@ -732,16 +754,15 @@ foreach (sort (keys %disabled)) ($ALGO,$algo) = ("RMD160","rmd160") if ($algo eq "ripemd"); push @{$config{openssl_algorithm_defines}}, "OPENSSL_NO_$ALGO"; + $config{depflags} .= " -DOPENSSL_NO_$ALGO"; print " OPENSSL_NO_$ALGO"; - push @skip, $algo; # fix-up crypto/directory name(s) - $skip[$#skip]="whrlpool" if $algo eq "whirlpool"; - $skip[$#skip]="ripemd" if $algo eq "rmd160"; + $algo="whrlpool" if $algo eq "whirlpool"; + $algo="ripemd" if $algo eq "rmd160"; + @{$config{sdirs}} = grep { $_ ne $algo} @{$config{sdirs}}; print " (skip dir)"; - - $depflags .= " -DOPENSSL_NO_$ALGO"; } } @@ -778,9 +799,10 @@ my %target = ( %{$table{$base_target}}, resolve_config($target) ); &usage if (!%target || $target{template}); -$exe_ext=".exe" if ($target eq "Cygwin" || $target eq "DJGPP" || $target =~ /^mingw/); -$exe_ext=".nlm" if ($target =~ /netware/); -$exe_ext=".pm" if ($target =~ /vos/); +$target{exe_extension}=""; +$target{exe_extension}=".exe" if ($config{target} eq "Cygwin" || $config{target} eq "DJGPP" || $config{target} =~ /^mingw/); +$target{exe_extension}=".nlm" if ($config{target} =~ /netware/); +$target{exe_extension}=".pm" if ($config{target} =~ /vos/); $default_ranlib = which("ranlib") || "true"; $config{perl} = $ENV{'PERL'} || which("perl5") || which("perl") || "perl"; @@ -797,17 +819,22 @@ $config{openssldir} = catdir($config{prefix}, $config{openssldir}) # Allow environment CC to override compiler... $target{cc} = $ENV{CC} || $target{cc}; -# For cflags and lflags, add the debug_ or release_ attributes +# For cflags, lflags and ex_libs, add the debug_ or release_ attributes # Do it in such a way that no spurious space is appended (hence the grep). -my $cflags = join(" ", - grep { $_ } ($target{cflags}, - $target{$build_prefix."cflags"})); -my $lflags = join(" ", - grep { $_ } ($target{lflags}, - $target{$build_prefix."lflags"})); +$config{cflags} = join(" ", + grep { $_ ne "" } ($target{cflags}, + $target{$build_prefix."cflags"})); +$config{lflags} = join(" ", + grep { $_ ne "" } ($target{lflags}, + $target{$build_prefix."lflags"})); +$config{ex_libs} = join(" ", + grep { $_ ne "" } ($target{ex_libs}, + $target{$build_prefix."ex_libs"})); $target{ranlib} = $ENV{'RANLIB'} || $target{ranlib} || $default_ranlib; $target{ar} = $ENV{'AR'} || "ar"; +$target{arflags} = "" if !defined($target{arflags}); +$target{nm} = "nm"; # Make sure build_scheme is consistent. $target{build_scheme} = [ $target{build_scheme} ] if ref($target{build_scheme}) ne "ARRAY"; @@ -818,32 +845,27 @@ $target{build_scheme} = [ $target{build_scheme} ] # we're ready to tolerate, so don't... $target{multilib}="" if !-d "$config{prefix}/lib$target{multilib}"; -$libdir="lib$target{multilib}" if $libdir eq ""; -$config{enginesdir}=$config{prefix} . "/" . $libdir . "/engines"; - -$cflags = "$cflags$exp_cflags"; +$config{libdir}="lib$target{multilib}" if $config{libdir} eq ""; +$config{enginesdir}=$config{prefix} . "/" . $config{libdir} . "/engines"; -# '%' in $lflags is used to split flags to "pre-" and post-flags -my ($prelflags,$postlflags)=split('%',$lflags); -if (defined($postlflags)) { $lflags=$postlflags; } -else { $lflags=$prelflags; undef $prelflags; } +$config{cflags} .= "$exp_cflags"; -if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` !~ m/\-mno\-cygwin/m) +if ($target =~ /^mingw/ && `$target{cc} --target-help 2>&1` !~ m/-mno-cygwin/m) { - $cflags =~ s/\-mno\-cygwin\s*//; - $target{shared_ldflag} =~ s/\-mno\-cygwin\s*//; + $config{cflags} =~ s/-mno-cygwin\s*//; + $target{shared_ldflag} =~ s/-mno-cygwin\s*//; } -if ($target =~ /linux.*\-mips/ && !$no_asm && $flags !~ /\-m(ips|arch=)/) { +if ($target =~ /linux.*-mips/ && !$no_asm && $flags !~ /-m(ips|arch=)/) { # minimally required architecture flags for assembly modules - $cflags="-mips2 $cflags" if ($target =~ /mips32/); - $cflags="-mips3 $cflags" if ($target =~ /mips64/); + $config{cflags}="-mips2 $config{cflags}" if ($target =~ /mips32/); + $config{cflags}="-mips3 $config{cflags}" if ($target =~ /mips64/); } my $no_shared_warn=0; my $no_user_cflags=0; -if ($flags ne "") { $cflags="$flags$cflags"; } +if ($flags ne "") { $config{cflags}="$flags$config{cflags}"; } else { $no_user_cflags=1; } # The DSO code currently always implements all functions so that no @@ -868,10 +890,10 @@ if (!$no_dso && $target{dso_scheme} ne "") { $dso_cflags = "-DDSO_$target{dso_scheme}"; } - $cflags = "$dso_cflags $cflags"; + $config{cflags} = "$dso_cflags $config{cflags}"; } -my $thread_cflags; +my $thread_cflags = ""; my @thread_defines; if ($target{thread_cflag} ne "(unknown)" && !$no_threads) { @@ -889,81 +911,70 @@ if ($target{thread_cflag} eq "(unknown)" && $threads) print "provide any system-specific compiler options\n"; exit(1); } - $thread_cflags="-DOPENSSL_THREADS $cflags" ; + $thread_cflags="-DOPENSSL_THREADS" ; push @thread_defines, "OPENSSL_THREADS"; } else { - $thread_cflags="-DOPENSSL_THREADS $target{thread_cflag} $cflags"; + $thread_cflags="-DOPENSSL_THREADS $target{thread_cflag}"; push @thread_defines, "OPENSSL_THREADS"; -# my $def; -# foreach $def (split ' ',$target{thread_cflag}) -# { -# if ($def =~ s/^-D// && $def !~ /^_/) -# { -# push @thread_defines, "$def"; -# } -# } } -$lflags="$libs$lflags" if ($libs ne ""); +$config{ex_libs}="$libs$config{ex_libs}" if ($libs ne ""); if ($no_asm) { - $cflags=~s/\-D[BL]_ENDIAN// if ($fips); - $thread_cflags=~s/\-D[BL]_ENDIAN// if ($fips); + $config{cflags}=~s/-D[BL]_ENDIAN// if ($config{fips}); } if ($threads) { - $cflags=$thread_cflags; + $config{cflags} = "$thread_cflags $config{cflags}" if $thread_cflags; push @{$config{openssl_thread_defines}}, @thread_defines; } if ($zlib) { - $cflags = "-DZLIB $cflags"; + $config{cflags} = "-DZLIB $config{cflags}"; if (defined($disabled{"zlib-dynamic"})) { if (defined($withargs{"zlib-lib"})) { - $lflags = "$lflags -L" . $withargs{"zlib-lib"} . " -lz"; + $config{ex_libs} .= " -L" . $withargs{"zlib-lib"} . " -lz"; } else { - $lflags = "$lflags -lz"; + $config{ex_libs} .= " -lz"; } } else { - $cflags = "-DZLIB_SHARED $cflags"; + $config{cflags} = "-DZLIB_SHARED $config{cflags}"; } } # With "deprecated" disable all deprecated features. if (defined($disabled{"deprecated"})) { - $api = $maxapi; + $config{api} = $maxapi; } -# You will find shlib_mark1 and shlib_mark2 explained in Makefile.in -my $shared_mark = ""; if ($target{shared_target} eq "") { - $no_shared_warn = 1 if !$no_shared && !$fips; - $no_shared = 1; + $no_shared_warn = 1 if !$config{no_shared} && !$config{fips}; + $config{no_shared} = 1; } -if (!$no_shared) +if (!$config{no_shared}) { if ($target{shared_cflag} ne "") { - $cflags = "$target{shared_cflag} -DOPENSSL_PIC $cflags"; + $config{cflags} = "$target{shared_cflag} -DOPENSSL_PIC $config{cflags}"; } } if ($target{build_scheme}->[0] ne "mk1mf") { # add {no-}static-engine to options to allow mkdef.pl to work without extra arguments - if ($no_shared) + if ($config{no_shared}) { push @{$config{openssl_other_defines}}, "OPENSSL_NO_DYNAMIC_ENGINE"; $config{options}.=" static-engine"; @@ -978,38 +989,6 @@ if ($target{build_scheme}->[0] ne "mk1mf") # # Platform fix-ups # -if ($target =~ /\-icc$/) # Intel C compiler - { - my $iccver=0; - if (open(FD,"$target{cc} -V 2>&1 |")) - { - while() { $iccver=$1 if (/Version ([0-9]+)\./); } - close(FD); - } - if ($iccver>=8) - { - $cflags=~s/\-KPIC/-fPIC/; - # Eliminate unnecessary dependency from libirc.a. This is - # essential for shared library support, as otherwise - # apps/openssl can end up in endless loop upon startup... - $cflags.=" -Dmemcpy=__builtin_memcpy -Dmemset=__builtin_memset"; - } - if ($iccver>=9) - { - $lflags.=" -i-static"; - $lflags=~s/\-no_cpprt/-no-cpprt/; - } - if ($iccver>=10) - { - $lflags=~s/\-i\-static/-static-intel/; - } - if ($iccver>=11) - { - $cflags.=" -no-intel-extensions"; # disable Cilk - $lflags=~s/\-no\-cpprt/-no-cxxlib/; - } - } - # Unlike other OSes (like Solaris, Linux, Tru64, IRIX) BSD run-time # linkers (tested OpenBSD, NetBSD and FreeBSD) "demand" RPATH set on # .so objects. Apparently application RPATH is not global and does @@ -1018,14 +997,14 @@ if ($target =~ /\-icc$/) # Intel C compiler # should engrave this into Makefile.shared rules or into BSD-* config # lines above. Meanwhile let's try to be cautious and pass -rpath to # linker only when --prefix is not /usr. -if ($target =~ /^BSD\-/) +if ($target =~ /^BSD-/) { $target{shared_ldflag}.=" -Wl,-rpath,\$\$(LIBRPATH)" if ($config{prefix} !~ m|^/usr[/]*$|); } if ($target{sys_id} ne "") { - #$cflags="-DOPENSSL_SYS_$target{sys_id} $cflags"; + #$config{cflags}="-DOPENSSL_SYS_$target{sys_id} $config{cflags}"; push @{$config{openssl_sys_defines}}, "OPENSSL_SYS_$target{sys_id}"; } @@ -1035,200 +1014,516 @@ if ($target{ranlib} eq "") } if (!$no_asm) { - $target{cpuid_obj}=$table{BASE}->{cpuid_obj} if ($config{processor} eq "386"); - $target{cpuid_obj}.=" uplink.o uplink-x86.o" if ($cflags =~ /\-DOPENSSL_USE_APPLINK/); + $target{cpuid_asm_src}=$table{BASE}->{cpuid_asm_src} if ($config{processor} eq "386"); + $target{cpuid_asm_src}.=" uplink.c uplink-x86.s" if ($config{cflags} =~ /-DOPENSSL_USE_APPLINK/); - $target{bn_obj} =~ s/\w+-gf2m.o// if (defined($disabled{ec2m})); + $target{bn_asm_src} =~ s/\w+-gf2m.c// if (defined($disabled{ec2m})); # bn-586 is the only one implementing bn_*_part_words - $cflags.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($target{bn_obj} =~ /bn-586/); - $cflags.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_obj} =~ /86/); + $config{cflags}.=" -DOPENSSL_BN_ASM_PART_WORDS" if ($target{bn_asm_src} =~ /bn-586/); + $config{cflags}.=" -DOPENSSL_IA32_SSE2" if (!$no_sse2 && $target{bn_asm_src} =~ /86/); - $cflags.=" -DOPENSSL_BN_ASM_MONT" if ($target{bn_obj} =~ /-mont/); - $cflags.=" -DOPENSSL_BN_ASM_MONT5" if ($target{bn_obj} =~ /-mont5/); - $cflags.=" -DOPENSSL_BN_ASM_GF2m" if ($target{bn_obj} =~ /-gf2m/); + $config{cflags}.=" -DOPENSSL_BN_ASM_MONT" if ($target{bn_asm_src} =~ /-mont/); + $config{cflags}.=" -DOPENSSL_BN_ASM_MONT5" if ($target{bn_asm_src} =~ /-mont5/); + $config{cflags}.=" -DOPENSSL_BN_ASM_GF2m" if ($target{bn_asm_src} =~ /-gf2m/); - if ($fips) { + if ($config{fips}) { push @{$config{openssl_other_defines}}, "OPENSSL_FIPS"; } - if ($target{sha1_obj} =~ /\.o$/) { - $cflags.=" -DSHA1_ASM" if ($target{sha1_obj} =~ /sx86/ || $target{sha1_obj} =~ /sha1/); - $cflags.=" -DSHA256_ASM" if ($target{sha1_obj} =~ /sha256/); - $cflags.=" -DSHA512_ASM" if ($target{sha1_obj} =~ /sha512/); - if ($target{sha1_obj} =~ /sse2/) { - if ($no_sse2) { - $target{sha1_obj} =~ s/\S*sse2\S+//; - } elsif ($cflags !~ /OPENSSL_IA32_SSE2/) { - $cflags.=" -DOPENSSL_IA32_SSE2"; - } - } + if ($target{sha1_asm_src}) { + $config{cflags}.=" -DSHA1_ASM" if ($target{sha1_asm_src} =~ /sx86/ || $target{sha1_asm_src} =~ /sha1/); + $config{cflags}.=" -DSHA256_ASM" if ($target{sha1_asm_src} =~ /sha256/); + $config{cflags}.=" -DSHA512_ASM" if ($target{sha1_asm_src} =~ /sha512/); } - if ($target{md5_obj} =~ /\.o$/) { - $cflags.=" -DMD5_ASM"; + if ($target{md5_asm_src}) { + $config{cflags}.=" -DMD5_ASM"; } - $target{cast_obj}=$table{BASE}->{cast_obj} if (!$no_shared); # CAST assembler is not PIC - if ($target{rmd160_obj} =~ /\.o$/) { - $cflags.=" -DRMD160_ASM"; + $target{cast_asm_src}=$table{BASE}->{cast_asm_src} if (!$config{no_shared}); # CAST assembler is not PIC + if ($target{rmd160_asm_src}) { + $config{cflags}.=" -DRMD160_ASM"; } - if ($target{aes_obj} =~ /\.o$/) { - $cflags.=" -DAES_ASM" if ($target{aes_obj} =~ m/\baes\-/);; - # aes-ctr.o is not a real file, only indication that assembler + if ($target{aes_asm_src}) { + $config{cflags}.=" -DAES_ASM" if ($target{aes_asm_src} =~ m/\baes-/);; + # aes-ctr.fake is not a real file, only indication that assembler # module implements AES_ctr32_encrypt... - $cflags.=" -DAES_CTR_ASM" if ($target{aes_obj} =~ s/\s*aes\-ctr\.o//); - # aes-xts.o indicates presence of AES_xts_[en|de]crypt... - $cflags.=" -DAES_XTS_ASM" if ($target{aes_obj} =~ s/\s*aes\-xts\.o//); - $target{aes_obj} =~ s/\s*(vpaes|aesni)\-x86\.o//g if ($no_sse2); - $cflags.=" -DVPAES_ASM" if ($target{aes_obj} =~ m/vpaes/); - $cflags.=" -DBSAES_ASM" if ($target{aes_obj} =~ m/bsaes/); + $config{cflags}.=" -DAES_CTR_ASM" if ($target{aes_asm_src} =~ s/\s*aes-ctr\.fake//); + # aes-xts.fake indicates presence of AES_xts_[en|de]crypt... + $config{cflags}.=" -DAES_XTS_ASM" if ($target{aes_asm_src} =~ s/\s*aes-xts\.fake//); + $target{aes_asm_src} =~ s/\s*(vpaes|aesni)-x86\.s//g if ($no_sse2); + $config{cflags}.=" -DVPAES_ASM" if ($target{aes_asm_src} =~ m/vpaes/); + $config{cflags}.=" -DBSAES_ASM" if ($target{aes_asm_src} =~ m/bsaes/); } - if ($target{wp_obj} =~ /mmx/ && $config{processor} eq "386") { - $target{wp_obj}=$table{BASE}->{wp_obj}; - } elsif (!$disabled{"whirlpool"}) { - $cflags.=" -DWHIRLPOOL_ASM"; + if ($target{wp_asm_src} =~ /mmx/) { + if ($config{processor} eq "386") { + $target{wp_asm_src}=$table{BASE}->{wp_asm_src}; + } elsif (!$disabled{"whirlpool"}) { + $config{cflags}.=" -DWHIRLPOOL_ASM"; + } } - if ($target{modes_obj} =~ /ghash\-/) { - $cflags.=" -DGHASH_ASM"; + if ($target{modes_asm_src} =~ /ghash-/) { + $config{cflags}.=" -DGHASH_ASM"; } - if ($target{ec_obj} =~ /ecp_nistz256/) { - $cflags.=" -DECP_NISTZ256_ASM"; + if ($target{ec_asm_src} =~ /ecp_nistz256/) { + $config{cflags}.=" -DECP_NISTZ256_ASM"; } - if ($target{poly1305_obj} =~ /\.o$/) { - $cflags.=" -DPOLY1305_ASM"; + if ($target{poly1305_asm_src} ne "") { + $config{cflags}.=" -DPOLY1305_ASM"; } } +# Is the compiler gcc or clang? $ecc is used below to see if error-checking +# can be turned on. +my $ecc = $target{cc}; +my $ccpcc = "$config{cross_compile_prefix}$target{cc}"; +$config{makedepprog} = 'makedepend'; +open(PIPE, "$ccpcc --version 2>&1 | head -2 |"); +while ( ) { + $config{makedepprog} = $ccpcc if /clang|gcc/; + $ecc = "clang" if /clang/; + $ecc = "gcc" if /gcc/; +} +close(PIPE); + +$config{depflags} =~ s/^\s*//; + # Deal with bn_ops ################################################### -$config{des_ptr} =0; -$config{des_risc1} =0; -$config{des_risc2} =0; -$config{des_unroll} =0; $config{bn_ll} =0; -$config{rc4_idx} =0; -$config{bf_ptr} =0; $config{export_var_as_fn} =0; my $def_int="unsigned int"; $config{rc4_int} =$def_int; -$config{rc4_chunk} =""; -$config{md2_int} =$def_int; -$config{idea_int} =$def_int; -$config{rc2_int} =$def_int; -($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8})=(0,0,1,0,0); - -$config{des_int} = "unsigned long"; +($config{b64l},$config{b64},$config{b32})=(0,0,1); +my $count = 0; foreach (sort split(/\s+/,$target{bn_ops})) { - $config{des_ptr}=1 if /DES_PTR/; - $config{des_risc1}=1 if /DES_RISC1/; - $config{des_risc2}=1 if /DES_RISC2/; - $config{des_unroll}=1 if /DES_UNROLL/; - $config{des_int}="unsigned int" if /DES_INT/; - $config{bn_ll}=1 if /BN_LLONG/; - $config{rc4_int}="unsigned char" if /RC4_CHAR/; - $config{rc4_int}="unsigned long" if /RC4_LONG/; - $config{rc4_idx}=1 if /RC4_INDEX/; - $config{rc4_chunk}="unsigned long" if /RC4_CHUNK/; - $config{rc4_chunk}="unsigned long long" if /RC4_CHUNK_LL/; - $config{md2_int}="unsigned char" if /MD2_CHAR/; - $config{md2_int}="unsigned long" if /MD2_LONG/; - $config{idea_int}="unsigned char" if /IDEA_CHAR/; - $config{idea_int}="unsigned long" if /IDEA_LONG/; - $config{rc2_int}="unsigned char" if /RC2_CHAR/; - $config{rc2_int}="unsigned long" if /RC2_LONG/; - $config{bf_ptr}=1 if $_ eq "BF_PTR"; - $config{bf_ptr}=2 if $_ eq "BF_PTR2"; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(0,1,0,0,0) if /SIXTY_FOUR_BIT/; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(1,0,0,0,0) if /SIXTY_FOUR_BIT_LONG/; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(0,0,1,0,0) if /THIRTY_TWO_BIT/; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(0,0,0,1,0) if /SIXTEEN_BIT/; - ($config{b64l},$config{b64},$config{b32},$config{b16},$config{b8}) - =(0,0,0,0,1) if /EIGHT_BIT/; - $config{export_var_as_fn}=1 if /EXPORT_VAR_AS_FN/; + $count++ if /SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT/; + $config{export_var_as_fn}=1 if $_ eq 'EXPORT_VAR_AS_FN'; + $config{bn_ll}=1 if $_ eq 'BN_LLONG'; + $config{rc4_int}="unsigned char" if $_ eq 'RC4_CHAR'; + ($config{b64l},$config{b64},$config{b32}) + =(0,1,0) if $_ eq 'SIXTY_FOUR_BIT'; + ($config{b64l},$config{b64},$config{b32}) + =(1,0,0) if $_ eq 'SIXTY_FOUR_BIT_LONG'; + ($config{b64l},$config{b64},$config{b32}) + =(0,0,1) if $_ eq 'THIRTY_TWO_BIT'; } +die "Exactly one of SIXTY_FOUR_BIT|SIXTY_FOUR_BIT_LONG|THIRTY_TWO_BIT can be set in bn_ops\n" + if $count > 1; # Hack cflags for better warnings (dev option) ####################### # "Stringify" the C flags string. This permits it to be made part of a string # and works as well on command lines. -$cflags =~ s/([\\\"])/\\\1/g; - -$config{version} = "unknown"; -$config{version_num} = "unknown"; -$config{major} = "unknown"; -$config{minor} = "unknown"; -$config{shlib_version_number} = "unknown"; -$config{shlib_version_history} = "unknown"; -$config{shlib_major} = "unknown"; -$config{shlib_minor} = "unknown"; - -open(IN,') - { - $config{version}=$1 if /OPENSSL.VERSION.TEXT.*OpenSSL (\S+) /; - $config{version_num}=$1 if /OPENSSL.VERSION.NUMBER.*(0x\S+)/; - $config{shlib_version_number}=$1 if /SHLIB_VERSION_NUMBER *"([^"]+)"/; - $config{shlib_version_history}=$1 if /SHLIB_VERSION_HISTORY *"([^"]*)"/; - } -close(IN); -if ($config{shlib_version_history} ne "") { $config{shlib_version_history} .= ":"; } - -if ($config{version} =~ /(^[0-9]*)\.([0-9\.]*)/) - { - $config{major}=$1; - $config{minor}=$2; - } +$config{cflags} =~ s/([\\\"])/\\\1/g; -if ($config{shlib_version_number} =~ /(^[0-9]*)\.([0-9\.]*)/) - { - $config{shlib_major}=$1; - $config{shlib_minor}=$2; - } - -if (defined($api)) { - $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$api} ]; - my $apiflag = sprintf("-DOPENSSL_API_COMPAT=%s", $apitable->{$api}); +if (defined($config{api})) { + $config{openssl_api_defines} = [ "OPENSSL_MIN_API=".$apitable->{$config{api}} ]; + my $apiflag = sprintf("-DOPENSSL_API_COMPAT=%s", $apitable->{$config{api}}); $default_depflags .= " $apiflag"; - $cflags .= " $apiflag"; + $config{cflags} .= " $apiflag"; } -my $ecc = $target{cc}; -$ecc = "clang" if `$target{cc} --version 2>&1` =~ /clang/; - if ($strict_warnings) { my $wopt; - die "ERROR --strict-warnings requires gcc or clang" unless ($ecc =~ /gcc(-\d(\.\d)*)?$/ or $ecc =~ /clang$/); + die "ERROR --strict-warnings requires gcc or clang" + unless $ecc eq 'gcc' || $ecc eq 'clang'; foreach $wopt (split /\s+/, $gcc_devteam_warn) { - $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/) + $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/) } if ($ecc eq "clang") { foreach $wopt (split /\s+/, $clang_devteam_warn) { - $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/) + $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/) } } if ($target !~ /^mingw/) { foreach $wopt (split /\s+/, $memleak_devteam_backtrace) { - $cflags .= " $wopt" unless ($cflags =~ /(^|\s)$wopt(\s|$)/) + $config{cflags} .= " $wopt" unless ($config{cflags} =~ /(^|\s)$wopt(\s|$)/) } if ($target =~ /^BSD-/) { - $lflags .= " -lexecinfo"; + $config{ex_libs} .= " -lexecinfo"; } } } +# If we use the unified build, collect information from build.info files +my %unified_info = (); + +if ($target{build_scheme}->[0] eq "unified") { + use lib catdir(dirname(__FILE__),"util"); + use with_fallback qw(Text::Template); + + # Helpers to produce clean paths with no /../ in the middle and so on. + sub int_absolutedir { + my $dir = shift; + + # Required, because realpath only works properly with existing dirs + make_path($dir); + + my $res = realpath($dir); + return $res; + } + + sub cleandir { + my $dir = shift; + my $base = shift || "."; + + my $res = abs2rel(int_absolutedir($dir), rel2abs($base)); + #print STDERR "DEBUG[cleandir]: $dir , $base => $res\n"; + return $res; + } + + sub cleanfile { + my $file = shift; + my $base = shift || "."; + my $d = dirname($file); + my $f = basename($file); + + my $res = abs2rel(catfile(int_absolutedir($d), $f), rel2abs($base)); + #print STDERR "DEBUG[cleanfile]: $d , $f => $res\n"; + return $res; + } + + my @build_infos = ( [ ".", "build.info" ] ); + foreach (@{$config{dirs}}) { + push @build_infos, [ $_, "build.info" ] + if (-f catfile($srcdir, $_, "build.info")); + } + foreach (@{$config{sdirs}}) { + push @build_infos, [ catdir("crypto", $_), "build.info" ] + if (-f catfile($srcdir, "crypto", $_, "build.info")); + } + foreach (@{$config{engdirs}}) { + push @build_infos, [ catdir("engines", $_), "build.info" ] + if (-f catfile($srcdir, "engines", $_, "build.info")); + } + + foreach (@build_infos) { + my $sourced = catdir($srcdir, $_->[0]); + my $buildd = catdir($blddir, $_->[0]); + + make_path($buildd); + + my $f = $_->[1]; + # The basic things we're trying to build + my @programs = (); + my @libraries = (); + my @engines = (); + my @scripts = (); + my @extra = (); + my @intermediates = (); + my @rawlines = (); + + my %ordinals = (); + my %sources = (); + my %includes = (); + my %depends = (); + my %renames = (); + my %sharednames = (); + + my $template = Text::Template->new(TYPE => 'FILE', + SOURCE => catfile($sourced, $f)); + die "Something went wrong with $sourced/$f: $!\n" unless $template; + my @text = + split /^/m, + $template->fill_in(HASH => { config => \%config, + target => \%target, + builddir => abs2rel($buildd, $blddir), + sourcedir => abs2rel($sourced, $blddir), + buildtop => abs2rel($blddir, $blddir), + sourcetop => abs2rel($srcdir, $blddir) }, + DELIMITERS => [ "{-", "-}" ]); + + # The top item of this stack has the following values + # -2 positive already run and we found ELSE (following ELSIF should fail) + # -1 positive already run (skip until ENDIF) + # 0 negatives so far (if we're at a condition, check it) + # 1 last was positive (don't skip lines until next ELSE, ELSIF or ENDIF) + # 2 positive ELSE (following ELSIF should fail) + my @skip = (); + collect_information( + collect_from_array([ @text ], + qr/\\$/ => sub { my $l1 = shift; my $l2 = shift; + $l1 =~ s/\\$//; $l1.$l2 }), + # Info we're looking for + qr/^\s*IF\[((?:\\.|[^\\\]])*)\]\s*$/ + => sub { push @skip, !! $1; }, + qr/^\s*ELSIF\[((?:\\.|[^\\\]])*)\]\s*$/ + => sub { die "ELSIF out of scope" if ! @skip; + die "ELSIF following ELSE" if abs($skip[$#skip]) == 2; + $skip[$#skip] = -1 if $skip[$#skip] != 0; + $skip[$#skip] = !! $1 + if $skip[$#skip] == 0; }, + qr/^\s*ELSE\s*$/ + => sub { die "ELSE out of scope" if ! @skip; + $skip[$#skip] = -2 if $skip[$#skip] != 0; + $skip[$#skip] = 2 if $skip[$#skip] == 0; }, + qr/^\s*ENDIF\s*$/ + => sub { die "ENDIF out of scope" if ! @skip; + pop @skip; }, + qr/^\s*PROGRAMS\s*=\s*(.*)\s*$/ + => sub { push @programs, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*LIBS\s*=\s*(.*)\s*$/ + => sub { push @libraries, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*ENGINES\s*=\s*(.*)\s*$/ + => sub { push @engines, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*SCRIPTS\s*=\s*(.*)\s*$/ + => sub { push @scripts, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*EXTRA\s*=\s*(.*)\s*$/ + => sub { push @extra, split(/\s+/, $1) + if !@skip || $skip[$#skip] > 0 }, + + qr/^\s*ORDINALS\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/, + => sub { push @{$ordinals{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*SOURCE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$sources{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*INCLUDE\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$includes{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*DEPEND\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$depends{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*RENAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$renames{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*SHARED_NAME\[((?:\\.|[^\\\]])+)\]\s*=\s*(.*)\s*$/ + => sub { push @{$sharednames{$1}}, split(/\s+/, $2) + if !@skip || $skip[$#skip] > 0 }, + qr/^\s*BEGINRAW\[((?:\\.|[^\\\]])+)\]\s*$/ + => sub { + my $lineiterator = shift; + my $target_kind = $1; + while (defined $lineiterator->()) { + chomp; + if (/^\s*ENDRAW\[((?:\\.|[^\\\]])+)\]\s*$/) { + die "ENDRAW doesn't match BEGINRAW" + if $1 ne $target_kind; + last; + } + next if @skip && $skip[$#skip] <= 0; + push @rawlines, $_ + if ($target_kind eq $target{build_file} + || $target_kind eq $target{build_file}."(".$target{build_scheme}->[1].")"); + } + }, + qr/^(?:#.*|\s*)$/ => sub { }, + "OTHERWISE" => sub { die "Something wrong with this line:\n$_\nat $sourced/$f" } + ); + die "runaway IF?" if (@skip); + + foreach (keys %renames) { + die "$_ renamed to more than one thing: " + ,join(" ", @{$renames{$_}}),"\n" + if scalar @{$renames{$_}} > 1; + my $dest = cleanfile(catfile($buildd, $_), $blddir); + my $to = cleanfile(catfile($buildd, $renames{$_}->[0]), $blddir); + die "$dest renamed to more than one thing: " + ,$unified_info{rename}->{$dest}, $to + unless !defined($unified_info{rename}->{$dest}) + or $unified_info{rename}->{$dest} eq $to; + $unified_info{rename}->{$dest} = $to; + } + + foreach (@programs) { + my $program = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$program}) { + $program = $unified_info{rename}->{$program}; + } + $unified_info{programs}->{$program} = 1; + } + + foreach (@libraries) { + my $library = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$library}) { + $library = $unified_info{rename}->{$library}; + } + $unified_info{libraries}->{$library} = 1; + } + + die <<"EOF" if $config{no_shared} && scalar @engines; +ENGINES can only be used if configured with 'shared'. +This is usually a fault in a build.info file. +EOF + foreach (@engines) { + my $library = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$library}) { + $library = $unified_info{rename}->{$library}; + } + $unified_info{engines}->{$library} = 1; + } + + foreach (@scripts) { + my $script = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$script}) { + $script = $unified_info{rename}->{$script}; + } + $unified_info{scripts}->{$script} = 1; + } + + foreach (@extra) { + my $extra = cleanfile(catfile($buildd, $_), $blddir); + $unified_info{extra}->{$extra} = 1; + } + + push @{$unified_info{rawlines}}, @rawlines; + + if (!$config{no_shared}) { + # Check sharednames. + foreach (keys %sharednames) { + my $dest = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$dest}) { + $dest = $unified_info{rename}->{$dest}; + } + die "shared_name for $dest with multiple values: " + ,join(" ", @{$sharednames{$_}}),"\n" + if scalar @{$sharednames{$_}} > 1; + my $to = cleanfile(catfile($buildd, $sharednames{$_}->[0]), + $blddir); + die "shared_name found for a library $dest that isn't defined\n" + unless $unified_info{libraries}->{$dest}; + die "shared_name for $dest with multiple values: " + ,$unified_info{sharednames}->{$dest}, ", ", $to + unless !defined($unified_info{sharednames}->{$dest}) + or $unified_info{sharednames}->{$dest} eq $to; + $unified_info{sharednames}->{$dest} = $to; + } + + # Additionally, we set up sharednames for libraries that don't + # have any, as themselves. + foreach (keys %{$unified_info{libraries}}) { + if (!defined $unified_info{sharednames}->{$_}) { + $unified_info{sharednames}->{$_} = $_ + } + } + } + + foreach (keys %ordinals) { + my $dest = $_; + my $ddest = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$ddest}) { + $ddest = $unified_info{rename}->{$ddest}; + } + foreach (@{$ordinals{$dest}}) { + my %known_ordinals = + ( + crypto => + cleanfile(catfile($sourced, "util", "libeay.num"), $blddir), + ssl => + cleanfile(catfile($sourced, "util", "ssleay.num"), $blddir) + ); + my $o = $known_ordinals{$_}; + die "Ordinals for $ddest defined more than once\n" + if $unified_info{ordinals}->{$ddest}; + $unified_info{ordinals}->{$ddest} = [ $_, $o ]; + } + } + + foreach (keys %sources) { + my $dest = $_; + my $ddest = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$ddest}) { + $ddest = $unified_info{rename}->{$ddest}; + } + foreach (@{$sources{$dest}}) { + my $s = cleanfile(catfile($sourced, $_), $blddir); + + # If it isn't in the source tree, we assume it's generated + # in the build tree + if (! -f $s) { + $s = cleanfile(catfile($buildd, $_), $blddir); + } + # We recognise C and asm files + if ($s =~ /\.[csS]\b$/) { + (my $o = $_) =~ s/\.[csS]\b$/.o/; + $o = cleanfile(catfile($buildd, $o), $blddir); + $unified_info{sources}->{$ddest}->{$o} = 1; + $unified_info{sources}->{$o}->{$s} = 1; + } else { + $unified_info{sources}->{$ddest}->{$s} = 1; + } + } + } + + foreach (keys %depends) { + my $dest = $_; + my $ddest = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$ddest}) { + $ddest = $unified_info{rename}->{$ddest}; + } + foreach (@{$depends{$dest}}) { + my $d = cleanfile(catfile($sourced, $_), $blddir); + + # If it isn't found in the source, let's assume it's generated + # and that the Makefile template has the lines + if (! -f $d) { + $d = cleanfile(catfile($buildd, $_), $blddir); + } + # Take note if the file to depend on is being renamed + if ($unified_info{rename}->{$d}) { + $d = $unified_info{rename}->{$d}; + } + $unified_info{depends}->{$ddest}->{$d} = 1; + # If we depend on a header file, let's make sure it + # can get included + if ($d =~ /\.h$/) { + my $i = dirname($d); + push @{$unified_info{includes}->{$ddest}}, $i + unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}}; + } + } + } + + foreach (keys %includes) { + my $dest = $_; + my $ddest = cleanfile(catfile($buildd, $_), $blddir); + if ($unified_info{rename}->{$ddest}) { + $ddest = $unified_info{rename}->{$ddest}; + } + foreach (@{$includes{$dest}}) { + my $i = cleandir(catdir($sourced, $_), $blddir); + push @{$unified_info{includes}->{$ddest}}, $i + unless grep { $_ eq $i } @{$unified_info{includes}->{$ddest}}; + } + } + } + + ### Make unified_info a bit more efficient + # One level structures + foreach (("programs", "libraries", "engines", "scripts", "extra")) { + $unified_info{$_} = [ sort keys %{$unified_info{$_}} ]; + } + # Two level structures + foreach my $l1 (("sources", "ldadd", "depends")) { + foreach my $l2 (sort keys %{$unified_info{$l1}}) { + $unified_info{$l1}->{$l2} = + [ sort keys %{$unified_info{$l1}->{$l2}} ]; + } + } +} + +# For the schemes that need it, we provide the old *_obj configs +# from the *_asm_obj ones +foreach (grep /_asm_src$/, keys %target) { + my $src = $_; + (my $obj = $_) =~ s/_asm_src$/_obj/; + ($target{$obj} = $target{$src}) =~ s/\.[csS]\b/.o/g; +} + # Write down our configuration where it fits ######################### open(OUT,">configdata.pm") || die "unable to create configdata.pm: $!\n"; @@ -1241,7 +1536,7 @@ use warnings; use Exporter; #use vars qw(\@ISA \@EXPORT); our \@ISA = qw(Exporter); -our \@EXPORT = qw(\%config \%target); +our \@EXPORT = qw(\%config \%target %withargs %unified_info); EOF print OUT "our %config = (\n"; @@ -1271,126 +1566,94 @@ foreach (sort keys %target) { print OUT <<"EOF"; ); -1; EOF -close(OUT); +print OUT "our \%available_protocols = (\n"; +print OUT " tls => [ ", join(", ", map { quotify("perl", $_) } @tls), " ],\n"; +print OUT " dtls => [ ", join(", ", map { quotify("perl", $_) } @dtls), " ],\n"; +print OUT <<"EOF"; +); -open(IN,"$Makefile.new") || die "unable to create $Makefile.new:$!\n"; -print OUT "### Generated automatically from Makefile.in by Configure.\n\n"; -my $sdirs=0; +EOF +print OUT "our \%disabled = (\n"; +foreach (sort keys %disabled) { + print OUT " ", quotify("perl", $_), " => ", quotify("perl", $disabled{$_}), ",\n"; +} +print OUT <<"EOF"; +); -while () - { - chomp; - $sdirs = 1 if /^SDIRS=/; - if ($sdirs) { - my $dir; - foreach $dir (@skip) { - s/(\s)$dir /$1/; - s/\s$dir$//; - } - } - $sdirs = 0 unless /\\$/; - s/fips // if (/^DIRS=/ && !$fips); - s/engines // if (/^DIRS=/ && $disabled{"engine"}); - s/^VERSION=.*/VERSION=$config{version}/; - s/^MAJOR=.*/MAJOR=$config{major}/; - s/^MINOR=.*/MINOR=$config{minor}/; - s/^SHLIB_VERSION_NUMBER=.*/SHLIB_VERSION_NUMBER=$config{shlib_version_number}/; - s/^SHLIB_VERSION_HISTORY=.*/SHLIB_VERSION_HISTORY=$config{shlib_version_history}/; - s/^SHLIB_MAJOR=.*/SHLIB_MAJOR=$config{shlib_major}/; - s/^SHLIB_MINOR=.*/SHLIB_MINOR=$config{shlib_minor}/; - s/^SHLIB_EXT=.*/SHLIB_EXT=$target{shared_extension}/; - s/^INSTALLTOP=.*$/INSTALLTOP=$config{prefix}/; - s/^MULTILIB=.*$/MULTILIB=$target{multilib}/; - s/^OPENSSLDIR=.*$/OPENSSLDIR=$config{openssldir}/; - s/^LIBDIR=.*$/LIBDIR=$libdir/; - s/^INSTALL_PREFIX=.*$/INSTALL_PREFIX=$install_prefix/; - s/^PLATFORM=.*$/PLATFORM=$target/; - s/^OPTIONS=.*$/OPTIONS=$config{options}/; - my $argvstring = "(".join(", ", map { quotify("perl", $_) } @argvcopy).")"; - s/^CONFIGURE_ARGS=.*$/CONFIGURE_ARGS=$argvstring/; - if ($config{cross_compile_prefix}) - { - s/^CC=.*$/CROSS_COMPILE= $config{cross_compile_prefix}\nCC= \$\(CROSS_COMPILE\)$target{cc}/; - s/^AR=\s*/AR= \$\(CROSS_COMPILE\)/; - s/^NM=\s*/NM= \$\(CROSS_COMPILE\)/; - s/^RANLIB=\s*/RANLIB= \$\(CROSS_COMPILE\)/; - s/^MAKEDEPPROG=.*$/MAKEDEPPROG= \$\(CROSS_COMPILE\)$target{cc}/ if $target{cc} eq "gcc"; - } - else { - s/^CC=.*$/CC= $target{cc}/; - s/^AR=\s*ar/AR= $target{ar}/; - s/^RANLIB=.*/RANLIB= $target{ranlib}/; - s/^MAKEDEPPROG=.*$/MAKEDEPPROG= $target{cc}/ if $ecc eq "gcc" || $ecc eq "clang"; - } - s/^CFLAG=.*$/CFLAG= $cflags/; - s/^DEPFLAG=.*$/DEPFLAG=$depflags/; - s/^PEX_LIBS=.*$/PEX_LIBS= $prelflags/; - s/^EX_LIBS=.*$/EX_LIBS= $lflags/; - s/^EXE_EXT=.*$/EXE_EXT= $exe_ext/; - s/^CPUID_OBJ=.*$/CPUID_OBJ= $target{cpuid_obj}/; - s/^BN_ASM=.*$/BN_ASM= $target{bn_obj}/; - s/^EC_ASM=.*$/EC_ASM= $target{ec_obj}/; - s/^DES_ENC=.*$/DES_ENC= $target{des_obj}/; - s/^AES_ENC=.*$/AES_ENC= $target{aes_obj}/; - s/^BF_ENC=.*$/BF_ENC= $target{bf_obj}/; - s/^CAST_ENC=.*$/CAST_ENC= $target{cast_obj}/; - s/^RC4_ENC=.*$/RC4_ENC= $target{rc4_obj}/; - s/^RC5_ENC=.*$/RC5_ENC= $target{rc5_obj}/; - s/^MD5_ASM_OBJ=.*$/MD5_ASM_OBJ= $target{md5_obj}/; - s/^SHA1_ASM_OBJ=.*$/SHA1_ASM_OBJ= $target{sha1_obj}/; - s/^RMD160_ASM_OBJ=.*$/RMD160_ASM_OBJ= $target{rmd160_obj}/; - s/^WP_ASM_OBJ=.*$/WP_ASM_OBJ= $target{wp_obj}/; - s/^CMLL_ENC=.*$/CMLL_ENC= $target{cmll_obj}/; - s/^MODES_ASM_OBJ.=*$/MODES_ASM_OBJ= $target{modes_obj}/; - s/^ENGINES_ASM_OBJ.=*$/ENGINES_ASM_OBJ= $target{engines_obj}/; - s/^CHACHA_ENC=.*$/CHACHA_ENC= $target{chacha_obj}/; - s/^POLY1305_ASM_OBJ=.*$/POLY1305_ASM_OBJ= $target{poly1305_obj}/; - s/^PERLASM_SCHEME=.*$/PERLASM_SCHEME= $target{perlasm_scheme}/; - s/^PROCESSOR=.*/PROCESSOR= $config{processor}/; - s/^ARFLAGS=.*/ARFLAGS= $target{arflags}/; - s/^PERL=.*/PERL= $config{perl}/; - s/^LIBZLIB=.*/LIBZLIB=$withargs{"zlib-lib"}/; - s/^ZLIB_INCLUDE=.*/ZLIB_INCLUDE=$withargs{"zlib-include"}/; - s/^FIPSLIBDIR=.*/FIPSLIBDIR=$fipslibdir/; - s/^FIPSCANLIB=.*/FIPSCANLIB=libcrypto/ if $fips; - s/^SHARED_FIPS=.*/SHARED_FIPS=/; - s/^SHLIBDIRS=.*/SHLIBDIRS= crypto ssl/; - s/^BASEADDR=.*/BASEADDR=$baseaddr/; - s/^SHLIB_TARGET=.*/SHLIB_TARGET=$target{shared_target}/; - s/^SHLIB_MARK=.*/SHLIB_MARK=$shared_mark/; - s/^SHARED_LIBS=.*/SHARED_LIBS=\$(SHARED_CRYPTO) \$(SHARED_SSL)/ if (!$no_shared); - if ($target{shared_extension} ne "" && $target{shared_extension} =~ /^\.s([ol])\.[^\.]*$/) - { - my $sotmp = $1; - s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp/; - } - elsif ($target{shared_extension} ne "" && $target{shared_extension} =~ /^\.[^\.]*\.dylib$/) - { - s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.dylib/; - } - elsif ($target{shared_extension} ne "" && $target{shared_extension} =~ /^\.s([ol])\.[^\.]*\.[^\.]*$/) - { - my $sotmp = $1; - s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.s$sotmp.\$(SHLIB_MAJOR) .s$sotmp/; - } - elsif ($target{shared_extension} ne "" && $target{shared_extension} =~ /^\.[^\.]*\.[^\.]*\.dylib$/) - { - s/^SHARED_LIBS_LINK_EXTS=.*/SHARED_LIBS_LINK_EXTS=.\$(SHLIB_MAJOR).dylib .dylib/; - } - s/^SHARED_LDFLAGS=.*/SHARED_LDFLAGS=$target{shared_ldflag}/; - print OUT $_."\n"; - } -close(IN); +EOF +print OUT "our %withargs = (\n"; +foreach (sort keys %withargs) { + if (ref($withargs{$_}) eq "ARRAY") { + print OUT " ", $_, " => [ ", join(", ", + map { quotify("perl", $_) } + @{$withargs{$_}}), " ],\n"; + } else { + print OUT " ", $_, " => ", quotify("perl", $withargs{$_}), ",\n" + } +} +print OUT <<"EOF"; +); + +EOF +if ($target{build_scheme}->[0] eq "unified") { + my $recurse; + $recurse = sub { + my $indent = shift; + foreach (@_) { + if (ref $_ eq "ARRAY") { + print OUT " "x$indent, "[\n"; + foreach (@$_) { + $recurse->($indent + 4, $_); + } + print OUT " "x$indent, "],\n"; + } elsif (ref $_ eq "HASH") { + my %h = %$_; + print OUT " "x$indent, "{\n"; + foreach (sort keys %h) { + if (ref $h{$_} eq "") { + print OUT " "x($indent + 4), quotify("perl", $_), " => ", quotify("perl", $h{$_}), ",\n"; + } else { + print OUT " "x($indent + 4), quotify("perl", $_), " =>\n"; + $recurse->($indent + 8, $h{$_}); + } + } + print OUT " "x$indent, "},\n"; + } else { + print OUT " "x$indent, quotify("perl", $_), ",\n"; + } + } + }; + print OUT "our %unified_info = (\n"; + foreach (sort keys %unified_info) { + if (ref $unified_info{$_} eq "") { + print OUT " "x4, quotify("perl", $_), " => ", quotify("perl", $unified_info{$_}), ",\n"; + } else { + print OUT " "x4, quotify("perl", $_), " =>\n"; + $recurse->(8, $unified_info{$_}); + } + } + print OUT <<"EOF"; +); + +EOF +} +print OUT "1;\n"; close(OUT); -rename("$Makefile.new",$Makefile) || die "unable to rename $Makefile.new\n"; + +die <<"EOF" if $target{build_scheme}->[0] ne "unified" && $srcdir ne $blddir; + +***** Trying building anywhere else than in the source tree will not +***** work for target $config{target}. To make it possible, it needs +***** to use the "unified" build scheme. + +EOF print "IsMK1MF =", ($target{build_scheme}->[0] eq "mk1mf" ? "yes" : "no"), "\n"; print "CC =$target{cc}\n"; -print "CFLAG =$cflags\n"; -print "EX_LIBS =$lflags\n"; +print "CFLAG =$config{cflags}\n"; +print "LFLAGS =$config{lflags}\n"; +print "EX_LIBS =$config{ex_libs}\n"; print "CPUID_OBJ =$target{cpuid_obj}\n"; print "BN_ASM =$target{bn_obj}\n"; print "EC_ASM =$target{ec_obj}\n"; @@ -1405,75 +1668,88 @@ print "SHA1_OBJ_ASM =$target{sha1_obj}\n"; print "RMD160_OBJ_ASM=$target{rmd160_obj}\n"; print "CMLL_ENC =$target{cmll_obj}\n"; print "MODES_OBJ =$target{modes_obj}\n"; -print "ENGINES_OBJ =$target{engines_obj}\n"; +print "PADLOCK_OBJ =$target{padlock_obj}\n"; print "CHACHA_ENC =$target{chacha_obj}\n"; print "POLY1305_OBJ =$target{poly1305_obj}\n"; print "PROCESSOR =$config{processor}\n"; print "RANLIB =$target{ranlib}\n"; print "ARFLAGS =$target{arflags}\n"; print "PERL =$config{perl}\n"; - -system("$config{perl} -I. -Mconfigdata util/dofile.pl < crypto/opensslconf.h.in > include/openssl/opensslconf.h.new"); -exit 1 if $? != 0; -rename("include/openssl/opensslconf.h.new","include/openssl/opensslconf.h") || die "unable to rename include/openssl/opensslconf.h.new\n"; - - -# Fix the date - +print "\n"; print "SIXTY_FOUR_BIT_LONG mode\n" if $config{b64l}; print "SIXTY_FOUR_BIT mode\n" if $config{b64}; print "THIRTY_TWO_BIT mode\n" if $config{b32}; -print "SIXTEEN_BIT mode\n" if $config{b16}; -print "EIGHT_BIT mode\n" if $config{b8}; -print "DES_PTR used\n" if $config{des_ptr}; -print "DES_RISC1 used\n" if $config{des_risc1}; -print "DES_RISC2 used\n" if $config{des_risc2}; -print "DES_UNROLL used\n" if $config{des_unroll}; -print "DES_INT used\n" if $config{des_int} =~ / int$/; print "BN_LLONG mode\n" if $config{bn_ll}; print "RC4 uses $config{rc4_int}\n" if $config{rc4_int} != $def_int; -print "RC4_INDEX mode\n" if $config{rc4_idx}; -print "RC4_CHUNK is undefined\n" unless $config{rc4_chunk}; -print "RC4_CHUNK is $config{rc4_chunk}\n" if $config{rc4_chunk}; -print "MD2 uses $config{md2_int}\n" if $config{md2_int} != $def_int; -print "IDEA uses $config{idea_int}\n" if $config{idea_int} != $def_int; -print "RC2 uses $config{rc2_int}\n" if $config{rc2_int} != $def_int; -print "BF_PTR used\n" if $config{bf_ptr} == 1; -print "BF_PTR2 used\n" if $config{bf_ptr} == 2; - -# Copy all Makefile.in to Makefile (except top-level) -use File::Find; -use IO::File; -find(sub { - return if ($_ ne "Makefile.in" || $File::Find::dir eq "."); - my $in = IO::File->new($_, "r") or - die sprintf "Error reading Makefile.in in %s: !$\n", - $File::Find::dir; - my $out = IO::File->new("Makefile", "w") or - die sprintf "Error writing Makefile in %s: !$\n", - $File::Find::dir; - print $out "# Generated from $_, do not edit\n"; - while (my $line = <$in>) { print $out $line } - $in->close() or - die sprintf "Error reading Makefile.in in %s: !$\n", - $File::Find::dir; - $out->close() or - die sprintf "Error writing Makefile in %s: !$\n", - $File::Find::dir; - }, "."); + +make_path(catdir($blddir, "include/openssl")); +run_dofile(catfile($blddir, "include/openssl/opensslconf.h"), + catfile($srcdir, "include/openssl/opensslconf.h.in")); + +make_path(catdir($blddir, "crypto/include/internal")); +foreach my $alg ( 'bn' ) { + run_dofile(catfile($blddir, "crypto/include/internal/${alg}_conf.h"), + catfile($srcdir, "crypto/include/internal/${alg}_conf.h.in")); +} + +### +### When the old "unixmake" scheme goes away, so does this function +### +sub build_Makefile { + run_dofile("Makefile","Makefile.in"); + + # Copy all Makefile.in to Makefile (except top-level) + use File::Find; + use IO::File; + find( + { + preprocess => sub { + grep(!/^\./, @_); + }, + wanted => sub { + return if ($_ ne "Makefile.in" || $File::Find::dir eq "."); + my $in = IO::File->new($_, "r") or + die sprintf "Error reading Makefile.in in %s: !$\n", + $File::Find::dir; + my $out = IO::File->new("Makefile", "w") or + die sprintf "Error writing Makefile in %s: !$\n", + $File::Find::dir; + print $out "# Generated from $_, do not edit\n"; + while (my $line = <$in>) { print $out $line } + $in->close() or + die sprintf "Error reading Makefile.in in %s: !$\n", + $File::Find::dir; + $out->close() or + die sprintf "Error writing Makefile in %s: !$\n", + $File::Find::dir; + }, + }, + "."); +} my %builders = ( + unified => sub { + die "unified build currently does nothing"; + }, unixmake => sub { + build_Makefile(); + + run_dofile("util/domd", "util/domd.in"); + chmod 0755, "util/domd"; + my $make_command = "$make PERL=\'$config{perl}\'"; my $make_targets = ""; - $make_targets .= " depend" if $depflags ne $default_depflags && $make_depend; + $make_targets .= " depend" if $config{depflags} ne $default_depflags && $make_depend; (system $make_command.$make_targets) == 0 or die "make $make_targets failed" if $make_targets ne ""; - if ($depflags ne $default_depflags && !$make_depend) { + if ($config{depflags} ne $default_depflags && !$make_depend) { $warn_make_depend++; } }, mk1mf => sub { + # The only reason we do this is to have something to build MINFO from + build_Makefile(); + open (OUT,">crypto/buildinf.h") || die "Can't open buildinf.h"; printf OUT <<"EOF"; #ifndef MK1MF_BUILD @@ -1801,6 +2077,23 @@ sub usage exit(1); } +sub run_dofile() +{ + my $out = shift; + my @templates = @_; + + unlink $out || warn "Can't remove $out, $!" + if -f $out; + foreach (@templates) { + die "Can't open $_, $!" unless -f $_; + } + my $cmd = "$config{perl} \"-I.\" \"-Mconfigdata\" $dofile -o\"Configure\" \"".join("\" \"",@templates)."\" > \"$out.new\""; + #print STDERR "DEBUG[run_dofile]: \$cmd = $cmd\n"; + system($cmd); + exit 1 if $? != 0; + rename("$out.new", $out) || die "Can't rename $out.new, $!"; +} + # Configuration printer ############################################## sub print_table_entry @@ -1813,16 +2106,20 @@ sub print_table_entry return if $target{template}; my @sequence = ( + "sys_id", "cc", "cflags", "debug_cflags", "release_cflags", - "unistd", "thread_cflag", - "sys_id", + "unistd", + "ld", "lflags", + "ex_libs", "debug_lflags", + "debug_ex_libs", "release_lflags", + "release_ex_libs", "bn_ops", "cpuid_obj", "bn_obj", @@ -1839,16 +2136,20 @@ sub print_table_entry "wp_obj", "cmll_obj", "modes_obj", - "engines_obj", + "padlock_obj", "perlasm_scheme", "dso_scheme", "shared_target", "shared_cflag", "shared_ldflag", "shared_extension", + "obj_extension", + "exe_extension", "ranlib", + "ar", "arflags", "multilib", + "build_scheme", ); if ($type eq "TABLE") { @@ -1876,119 +2177,14 @@ sub which my $path; foreach $path (split /:/, $ENV{PATH}) { - if (-f "$path/$name$exe_ext" and -x _) + if (-f "$path/$name$target{exe_extension}" and -x _) { - return "$path/$name$exe_ext" unless ($name eq "perl" and - system("$path/$name$exe_ext -e " . '\'exit($]<5.0);\'')); + return "$path/$name$target{exe_extension}" unless ($name eq "perl" and + system("$path/$name$target{exe_extension} -e " . '\'exit($]<5.0);\'')); } } } -sub print_table_entry - { - my $target = shift; - my %target = resolve_config($target); - my $type = shift; - - # Don't print the templates - return if $target{template}; - - if ($type eq "TABLE") { - print <<"EOF" - -*** $target -\$cc = $target{cc} -\$cflags = $target{cflags} -\$debug_cflags = $target{debug_cflags} -\$release_cflags = $target{release_cflags} -\$unistd = $target{unistd} -\$thread_cflag = $target{thread_cflag} -\$sys_id = $target{sys_id} -\$lflags = $target{lflags} -\$debug_lflags = $target{debug_lflags} -\$release_lflags = $target{release_lflags} -\$bn_ops = $target{bn_ops} -\$cpuid_obj = $target{cpuid_obj} -\$bn_obj = $target{bn_obj} -\$ec_obj = $target{ec_obj} -\$des_obj = $target{des_obj} -\$aes_obj = $target{aes_obj} -\$bf_obj = $target{bf_obj} -\$md5_obj = $target{md5_obj} -\$sha1_obj = $target{sha1_obj} -\$cast_obj = $target{cast_obj} -\$rc4_obj = $target{rc4_obj} -\$rmd160_obj = $target{rmd160_obj} -\$rc5_obj = $target{rc5_obj} -\$wp_obj = $target{wp_obj} -\$cmll_obj = $target{cmll_obj} -\$modes_obj = $target{modes_obj} -\$engines_obj = $target{engines_obj} -\$chacha_obj = $target{chacha_obj} -\$poly1305_obj = $target{poly1305_obj} -\$perlasm_scheme = $target{perlasm_scheme} -\$dso_scheme = $target{dso_scheme} -\$shared_target= $target{shared_target} -\$shared_cflag = $target{shared_cflag} -\$shared_ldflag = $target{shared_ldflag} -\$shared_extension = $target{shared_extension} -\$ranlib = $target{ranlib} -\$arflags = $target{arflags} -\$multilib = $target{multilib} -EOF - } elsif ($type eq "HASH") { - my @sequence = ( - "cc", - "cflags", - "debug_cflags", - "release_cflags", - "unistd", - "thread_cflag", - "sys_id", - "lflags", - "debug_lflags", - "release_lflags", - "bn_ops", - "cpuid_obj", - "bn_obj", - "ec_obj", - "des_obj", - "aes_obj", - "bf_obj", - "md5_obj", - "sha1_obj", - "cast_obj", - "rc4_obj", - "rmd160_obj", - "rc5_obj", - "wp_obj", - "cmll_obj", - "modes_obj", - "engines_obj", - "chacha_obj", - "poly1305_obj", - "perlasm_scheme", - "dso_scheme", - "shared_target", - "shared_cflag", - "shared_ldflag", - "shared_extension", - "ranlib", - "arflags", - "multilib", - ); - my $largest = - length((sort { length($a) <=> length($b) } @sequence)[-1]); - print " '$target' => {\n"; - foreach (@sequence) { - if ($target{$_}) { - print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n"; - } - } - print " },\n"; - } - } - sub quotify { my %processors = ( perl => sub { my $x = shift; @@ -2001,3 +2197,88 @@ sub quotify { map { $processor->($_); } @_; } + +# collect_from_file($filename, $line_concat_cond_re, $line_concat) +# $filename is a file name to read from +# $line_concat_cond_re is a regexp detecting a line continuation ending +# $line_concat is a CODEref that takes care of concatenating two lines +sub collect_from_file { + my $filename = shift; + my $line_concat_cond_re = shift; + my $line_concat = shift; + + open my $fh, $filename || die "unable to read $filename: $!\n"; + return sub { + my $saved_line = ""; + $_ = ""; + while (<$fh>) { + chomp; + if (defined $line_concat) { + $_ = $line_concat->($saved_line, $_); + $saved_line = ""; + } + if (defined $line_concat_cond_re && /$line_concat_cond_re/) { + $saved_line = $_; + next; + } + return $_; + } + die "$filename ending with continuation line\n" if $_; + close $fh; + return undef; + } +} + +# collect_from_array($array, $line_concat_cond_re, $line_concat) +# $array is an ARRAYref of lines +# $line_concat_cond_re is a regexp detecting a line continuation ending +# $line_concat is a CODEref that takes care of concatenating two lines +sub collect_from_array { + my $array = shift; + my $line_concat_cond_re = shift; + my $line_concat = shift; + my @array = (@$array); + + return sub { + my $saved_line = ""; + $_ = ""; + while (defined($_ = shift @array)) { + chomp; + if (defined $line_concat) { + $_ = $line_concat->($saved_line, $_); + $saved_line = ""; + } + if (defined $line_concat_cond_re && /$line_concat_cond_re/) { + $saved_line = $_; + next; + } + return $_; + } + die "input text ending with continuation line\n" if $_; + return undef; + } +} + +# collect_information($lineiterator, $line_continue, $regexp => $CODEref, ...) +# $lineiterator is a CODEref that delivers one line at a time. +# All following arguments are regex/CODEref pairs, where the regexp detects a +# line and the CODEref does something with the result of the regexp. +sub collect_information { + my $lineiterator = shift; + my %collectors = @_; + + while(defined($_ = $lineiterator->())) { + chomp; + my $found = 0; + foreach my $re (keys %collectors) { + if ($re ne "OTHERWISE" && /$re/) { + $collectors{$re}->($lineiterator); + $found = 1; + }; + } + if ($collectors{"OTHERWISE"}) { + $collectors{"OTHERWISE"}->($lineiterator, $_) + unless $found || !defined $collectors{"OTHERWISE"}; + } + } +}