From bd5192b1013b68373c47bdca8d68229906171695 Mon Sep 17 00:00:00 2001 From: Richard Levitte Date: Mon, 18 May 2015 02:57:24 +0200 Subject: [PATCH] Refactor config - split read_config into read_config and resolve_config Split the read_config function into read_config that ONLY reads the configuration files but doesn't try to resolve any of the inheritances, and resolve_config which resolves the inheritance chain of a given target. Move them to the bottom of Configure, with the rest of the helpers. Have a new small hash table, %target, which will hold the values for the target the user requested. This also means that all access to the current target data can be reduced from '$table{$target}->{key}' to a mere '$target{key}'. While we're at it, the old string formatted configurations are getting obsolete, so they may as well get deprecated entirely. Reviewed-by: Rich Salz --- Configure | 660 ++++++++++++++++++++---------------------------------- 1 file changed, 244 insertions(+), 416 deletions(-) diff --git a/Configure b/Configure index 9f88d12b16..594d917b36 100755 --- a/Configure +++ b/Configure @@ -148,56 +148,9 @@ my $apitable = { # table of known configurations, read in from files # -# The content of each entry can take one of two forms: -# -# - old style config-string, colon seperated fields with exactly the -# following structure.: -# -# $cc : $cflags : $unistd : $thread_cflag : $sys_id : $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 : $perlasm_scheme : $dso_scheme : $shared_target : $shared_cflag : $shared_ldflag : $shared_extension : $ranlib : $arflags : $multilib -# -# We use the stringtohash function - defined below - to combine with the -# fields and form a proper hash table from the string. -# -# - direct transfer of old style config string to hash table, using the names -# of the fields as keys: -# -# { -# cc => $cc, -# cflags => $cflags, -# unistd => $unistd, -# thread_cflag => $thread_cflag, -# sys_id => $sys_id, -# lflags => $lflags, -# bn_ops => $bn_ops, -# cpuid_obj => $cpuid_obj, -# bn_obj => $bn_obj, -# ec_obj => $ec_obj, -# des_obj => $des_obj, -# aes_obj => $aes_obj, -# bf_obj => $bf_obj, -# md5_obj => $md5_obj, -# sha1_obj => $sha1_obj, -# cast_obj => $cast_obj, -# rc4_obj => $rc4_obj, -# rmd160_obj => $rmd160_obj, -# rc5_obj => $rc5_obj, -# wp_obj => $wp_obj, -# cmll_obj => $cmll_obj, -# modes_obj => $modes_obj, -# engines_obj => $engines_obj, -# perlasm_scheme => $perlasm_scheme, -# dso_scheme => $dso_scheme, -# shared_target => $shared_target, -# shared_cflag => $shared_cflag, -# shared_ldflag => $shared_ldflag, -# shared_extension => $shared_extension, -# ranlib => $ranlib, -# arflags => $arflags, -# multilib => $multilib -# } -# -# - new style config hash table, which has additional attributes for debug -# and non-debug flags to be added to the common flags, for cflags and lflags: +# The content of each entry comes in the form of config hash table, +# which has additional attributes for debug and non-debug flags to be +# added to the common flags, for cflags and lflags: # # { # cc => $cc, @@ -239,10 +192,6 @@ my $apitable = { # multilib => $multilib # } # -# The configuration reader will do what it can to translate everything into -# new style config hash tables, including merging $target and debug-$target -# if they are similar enough. -# # The configuration hashes can refer to templates in two different manners: # # - as part of the hash, one can have a key called 'inherit_from' that @@ -322,7 +271,7 @@ my $apitable = { # } # -my %table=( +our %table=( # All these templates are merely a translation of the corresponding # variables further up. @@ -475,291 +424,20 @@ my %table=( }, ); -{ my $no_asm_templates=0; - foreach (@ARGV) { $no_asm_templates=1 if (/^\-?no\-asm$/); } - sub asm { $no_asm_templates?():@_; } -} - +# Forward declarations ############################################### -sub stringtohash { - my $in = shift @_; - if (ref($in) eq "HASH") { - return $in; - } - my @stringsequence = ( - "cc", - "cflags", - "unistd", - "thread_cflag", - "sys_id", - "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", - "perlasm_scheme", - "dso_scheme", - "shared_target", - "shared_cflag", - "shared_ldflag", - "shared_extension", - "ranlib", - "arflags", - "multilib", - ); - - # return a ref to a hash, that's what the outer braces are for. - return { map { shift @stringsequence => $_ } split /:/, $in }; -}; - -# Read configuration target stanzas from a file, so that people can have -# local files with their own definitions -sub read_config { - my $fname = shift; - open(CONFFILE, "< $fname") - or die "Can't open configuration file '$fname'!\n"; - my $x = $/; - undef $/; - my $content = ; - $/ = $x; - close(CONFFILE); - my %targets = (); - eval $content; - - # Make sure we have debug- targets first - my @keys = - sort { - my $a_nd = $a =~ m/^debug-/ ? $' :$a; - my $b_nd = $b =~ m/^debug-/ ? $' :$b; - my $res = 0; - - if (($a_nd == $a) == ($b_nd == $b)) { - # they are both debug- or not, compare them as they are - $res = $a cmp $b; - } elsif ($a_nd != $a) { - # $a is debug-, make it lesser - $res = -1; - } else { - # $b is debug-, make $a greater - $res = 1; - } - $res; - } keys %targets; - - foreach (@keys) { - if (ref($targets{$_}) ne "HASH") { - # Value is assumed to be a string. Split it up to - # become a hash table of parameters. Also, try to - # merge debug- variants with the non-debug target. - - # Start with converting the value from a string to a - # standardised hash of fields. Using $tohash is safe, - # if the input is already a hash ref, it's just returned - # back. - $targets{$_} = stringtohash($targets{$_}); - - # If the current target is a debug target, there might - # be a corresponding non-debug target that we can merge - # with. If it isn't a debug- target, we've already done - # as much merging as we can and do not need to bother - # with that any more. - if ($_ =~ m/^debug-/) { - my $debugkey = $_; - my $nondebugkey = $'; - my $debug = $targets{$debugkey}; - my $nondebug; - - if ($targets{$nondebugkey}) { - $nondebug = stringtohash($targets{$nondebugkey}); - } - - if ($nondebug) { - # There's both a debug and non-debug variant of - # this target, so we should try to merge them - # together. - - # First, check that the non-debug variant isn't - # already built up with all it should have. - if ($nondebug->{debug_cflags} - || $nondebug->{release_cflags} - || $nondebug->{debug_lflags} - || $nondebug->{release_lflags}) { - warn "there's a debug target $debugkey to be merged with a target $nondebugkey, but the latter seems to already have both nodebug and debug information. This requires human intervention. Skipping $debugkey..."; - next; - } - - # Now, check similarity. - # For keys they have in common, support that - # cflags and lflags can differ, otherwise they - # must have exactly the same values for them - # to be merged into one. - my $similarenough = 1; - for (keys %{$debug}) { - if ($nondebug->{$_} ne $debug->{$_} - && $_ !~ m/^[cl]flags$/) { - $similarenough = 0; - last; - } - } - - if ($similarenough) { - # Here's where the magic happens, split the - # options in the debug and non-debug variants - # cflags and ldflags into three strings each, - # one with common flags, one with extra debug - # flags and one with extra non-debug flags. - - # The result ends up in %h_nondebug, which - # becomes the merged variant when we're done. - # for each of cflags and lflags, they are - # replaced with cflags, debug_cflags, - # release_cflags and similar for lflags. - # - # The purpose is that 'cflags' should be - # used together with 'debug_cflags' or - # 'release_cflags' depending on what the - # user asks for. - foreach (("cflags", "lflags")) { - my @list_d = split /\s+/, $debug->{$_}; - my @list_nd = split /\s+/, $nondebug->{$_}; - my %presence = (); # bitmap - # 1: present in @list_d - # 2: present in @list_nd - # 3: present in both - map { $presence{$_} += 1; } @list_d; - map { $presence{$_} += 2; } @list_nd; - - delete $nondebug->{$_}; - # Note: we build from the original lists to - # preserve order, it might be important - $nondebug->{"debug-".$_} = - join(" ", - grep { $presence{$_} == 1 } @list_d); - $nondebug->{"nodebug-".$_} = - join(" ", - grep { $presence{$_} == 2 } @list_nd); - $nondebug->{$_} = - join(" ", - grep { $presence{$_} == 3 } @list_d); - } - - $targets{$nondebugkey} = $nondebug; - delete $targets{$debugkey}; - } - } - } - } - } - - %table = (%table, %targets); - - # Local function to resolve inheritance - my $resolve_inheritance; - $resolve_inheritance = - sub { - my $target = shift; - my @breadcrumbs = @_; - - if (grep { $_ eq $target } @breadcrumbs) { - die "inherit_from loop! target backtrace:\n " - ,$target,"\n ",join("\n ", @breadcrumbs),"\n"; - } - - # Recurse through all inheritances. They will be resolved on - # the fly, so when this operation is done, they will all just - # be a bunch of attributes with string values. - # What we get here, though, are keys with references to lists - # of the combined values of them all. We will deal with lists - # after this stage is done. - my %combined_inheritance = (); - if ($table{$target}->{inherit_from}) { - foreach (@{$table{$target}->{inherit_from}}) { - my %inherited_config = - $resolve_inheritance->($_, $target, @breadcrumbs); - - # 'template' is a marker that's considered private to - # the config that had it. - delete $inherited_config{template}; - - map { - if (!$combined_inheritance{$_}) { - $combined_inheritance{$_} = []; - } - push @{$combined_inheritance{$_}}, $inherited_config{$_}; - } keys %inherited_config; - } - } - - # We won't need inherit_from in this target any more, since - # we've resolved all the inheritances that lead to this - delete $table{$target}->{inherit_from}; - - # Now is the time to deal with those lists. Here's the place - # to decide what shall be done with those lists, all based on - # the values of the target we're currently dealing with. - # - If a value is a coderef, it will be executed with the list - # of inherited values as arguments. - # - If the corresponding key doesn't have a value at all or is - # the emoty string, the inherited value list will be run - # through the default combiner (below), and the result - # becomes this target's value. - # - Otherwise, this target's value is assumed to be a string - # that will simply override the inherited list of values. - my $default_combiner = sub { join(' ',@_) }; - - my %all_keys = - map { $_ => 1 } (keys %combined_inheritance, - keys %{$table{$target}}); - foreach (sort keys %all_keys) { - - # Current target doesn't have a value for the current key? - # Assign it the default combiner, the rest of this loop - # body will handle it just like any other coderef. - if (!exists $table{$target}->{$_}) { - $table{$target}->{$_} = $default_combiner; - } - - my $valuetype = ref($table{$target}->{$_}); - if ($valuetype eq "CODE") { - # CODE reference, execute it with the inherited values - # as arguments. - $table{$target}->{$_} = - $table{$target}->{$_}->(@{$combined_inheritance{$_}}); - } elsif ($valuetype eq "") { - # Scalar, just leave it as is. - } else { - # Some other type of reference that we don't handle. - # Better to abort at this point. - die "cannot handle reference type $valuetype," - ," found in target $target -> $_\n"; - } - } +# read_config(filename) +# +# Reads a configuration file and populates %table with the contents +# (which the configuration file places in %targets). +sub read_config; - # Finally done, return the result. - %{$table{$target}}; - }; +# resolve_config(target) +# +# Resolves all the late evalutations, inheritances and so on for the +# chosen target and any target it inherits from. +sub resolve_config; - # Go through all new targets and resolve inheritance and template - # references. - foreach (keys %targets) { - # We're ignoring the returned values here, they are only valuable - # to the inner recursion of this function. - $resolve_inheritance->($_); - } -} my ($vol, $dir, $dummy) = File::Spec->splitpath($0); my $pattern = File::Spec->catpath($vol, $dir, "Configurations/*.conf"); @@ -1363,8 +1041,9 @@ if ($d) { $target = $t; } } +my %target = resolve_config($target); -&usage if (!defined($table{$target}) || $table{$target}->{template}); +&usage if (!%target || $target{template}); if ($fips) { @@ -1462,49 +1141,49 @@ $openssldir=$prefix . "/" . $openssldir if $openssldir !~ /(^\/|^[a-zA-Z]:[\\\/] print "IsMK1MF=$IsMK1MF\n"; # Allow environment CC to override compiler... -my $cc = $ENV{CC} || $table{$target}->{cc}; +my $cc = $ENV{CC} || $target{cc}; # For cflags and lflags, 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 { $_ } ($table{$target}->{cflags}, - $table{$target}->{$build_prefix."cflags"})); + grep { $_ } ($target{cflags}, + $target{$build_prefix."cflags"})); my $lflags = join(" ", - grep { $_ } ($table{$target}->{lflags}, - $table{$target}->{$build_prefix."lflags"})); - -my $unistd = $table{$target}->{unistd}; -my $thread_cflag = $table{$target}->{thread_cflag}; -my $sys_id = $table{$target}->{sys_id}; -my $bn_ops = $table{$target}->{bn_ops}; -my $cpuid_obj = $table{$target}->{cpuid_obj}; -my $bn_obj = $table{$target}->{bn_obj}; -my $ec_obj = $table{$target}->{ec_obj}; -my $des_obj = $table{$target}->{des_obj}; -my $aes_obj = $table{$target}->{aes_obj}; -my $bf_obj = $table{$target}->{bf_obj}; -my $md5_obj = $table{$target}->{md5_obj}; -my $sha1_obj = $table{$target}->{sha1_obj}; -my $cast_obj = $table{$target}->{cast_obj}; -my $rc4_obj = $table{$target}->{rc4_obj}; -my $rmd160_obj = $table{$target}->{rmd160_obj}; -my $rc5_obj = $table{$target}->{rc5_obj}; -my $wp_obj = $table{$target}->{wp_obj}; -my $cmll_obj = $table{$target}->{cmll_obj}; -my $modes_obj = $table{$target}->{modes_obj}; -my $engines_obj = $table{$target}->{engines_obj}; -my $chacha_obj = $table{$target}->{chacha_obj}; -my $poly1305_obj = $table{$target}->{poly1305_obj}; -my $perlasm_scheme = $table{$target}->{perlasm_scheme}; -my $dso_scheme = $table{$target}->{dso_scheme}; -my $shared_target = $table{$target}->{shared_target}; -my $shared_cflag = $table{$target}->{shared_cflag}; -my $shared_ldflag = $table{$target}->{shared_ldflag}; -my $shared_extension = $table{$target}->{shared_extension}; -my $ranlib = $ENV{'RANLIB'} || $table{$target}->{ranlib}; + grep { $_ } ($target{lflags}, + $target{$build_prefix."lflags"})); + +my $unistd = $target{unistd}; +my $thread_cflag = $target{thread_cflag}; +my $sys_id = $target{sys_id}; +my $bn_ops = $target{bn_ops}; +my $cpuid_obj = $target{cpuid_obj}; +my $bn_obj = $target{bn_obj}; +my $ec_obj = $target{ec_obj}; +my $des_obj = $target{des_obj}; +my $aes_obj = $target{aes_obj}; +my $bf_obj = $target{bf_obj}; +my $md5_obj = $target{md5_obj}; +my $sha1_obj = $target{sha1_obj}; +my $cast_obj = $target{cast_obj}; +my $rc4_obj = $target{rc4_obj}; +my $rmd160_obj = $target{rmd160_obj}; +my $rc5_obj = $target{rc5_obj}; +my $wp_obj = $target{wp_obj}; +my $cmll_obj = $target{cmll_obj}; +my $modes_obj = $target{modes_obj}; +my $engines_obj = $target{engines_obj}; +my $chacha_obj = $target{chacha_obj}; +my $poly1305_obj = $target{poly1305_obj}; +my $perlasm_scheme = $target{perlasm_scheme}; +my $dso_scheme = $target{dso_scheme}; +my $shared_target = $target{shared_target}; +my $shared_cflag = $target{shared_cflag}; +my $shared_ldflag = $target{shared_ldflag}; +my $shared_extension = $target{shared_extension}; +my $ranlib = $ENV{'RANLIB'} || $target{ranlib}; my $ar = $ENV{'AR'} || "ar"; -my $arflags = $table{$target}->{arflags}; -my $multilib = $table{$target}->{multilib}; +my $arflags = $target{arflags}; +my $multilib = $target{multilib}; # if $prefix/lib$multilib is not an existing directory, then # assume that it's not searched by linker automatically, in @@ -2387,6 +2066,152 @@ EOF exit(0); +###################################################################### +# +# Helpers and utility functions +# + +# Configuration file reading ######################################### + +# Helper function to implement conditional inheritance depending on the +# value of $no_asm. Used in inherit_from values as follows: +# +# inherit_from => [ "template", asm("asm_tmpl") ] +# +sub asm { + my @x = @_; + sub { + $no_asm ? () : @x; + } +} + +# configuration reader, evaluates the input file as a perl script and expects +# it to fill %targets with target configurations. Those are then added to +# %table. +sub read_config { + my $fname = shift; + open(CONFFILE, "< $fname") + or die "Can't open configuration file '$fname'!\n"; + my $x = $/; + undef $/; + my $content = ; + $/ = $x; + close(CONFFILE); + my %targets = (); + { + local %table = %::table; # Protect %table from tampering + + eval $content; + warn $@ if $@; + } + + # For each target, check that it's configured with a hash table. + foreach (keys %targets) { + if (ref($targets{$_}) ne "HASH") { + if (ref($targets{$_}) eq "") { + warn "Deprecated target configuration for $_, ignoring...\n"; + } else { + warn "Misconfigured target configuration for $_ (should be a hash table), ignoring...\n"; + } + delete $targets{$_}; + } + } + + %table = (%table, %targets); + +} + +# configuration resolver. Will only resolve all the lazy evalutation +# codeblocks for the chozen target and all those it inherits from, +# recursively +sub resolve_config { + my $target = shift; + my @breadcrumbs = @_; + + if (grep { $_ eq $target } @breadcrumbs) { + die "inherit_from loop! target backtrace:\n " + ,$target,"\n ",join("\n ", @breadcrumbs),"\n"; + } + + if (!defined($table{$target})) { + warn "Warning! target $target doesn't exist!\n"; + return (); + } + # Recurse through all inheritances. They will be resolved on the + # fly, so when this operation is done, they will all just be a + # bunch of attributes with string values. + # What we get here, though, are keys with references to lists of + # the combined values of them all. We will deal with lists after + # this stage is done. + my %combined_inheritance = (); + if ($table{$target}->{inherit_from}) { + my @inherit_from = + map { ref($_) eq "CODE" ? $_->() : $_ } @{$table{$target}->{inherit_from}}; + foreach (@inherit_from) { + my %inherited_config = resolve_config($_, $target, @breadcrumbs); + + # 'template' is a marker that's considered private to + # the config that had it. + delete $inherited_config{template}; + + map { + if (!$combined_inheritance{$_}) { + $combined_inheritance{$_} = []; + } + push @{$combined_inheritance{$_}}, $inherited_config{$_}; + } keys %inherited_config; + } + } + + # We won't need inherit_from in this target any more, since we've + # resolved all the inheritances that lead to this + delete $table{$target}->{inherit_from}; + + # Now is the time to deal with those lists. Here's the place to + # decide what shall be done with those lists, all based on the + # values of the target we're currently dealing with. + # - If a value is a coderef, it will be executed with the list of + # inherited values as arguments. + # - If the corresponding key doesn't have a value at all or is the + # emoty string, the inherited value list will be run through the + # default combiner (below), and the result becomes this target's + # value. + # - Otherwise, this target's value is assumed to be a string that + # will simply override the inherited list of values. + my $default_combiner = sub { join(' ',@_) }; + + my %all_keys = + map { $_ => 1 } (keys %combined_inheritance, + keys %{$table{$target}}); + foreach (sort keys %all_keys) { + + # Current target doesn't have a value for the current key? + # Assign it the default combiner, the rest of this loop body + # will handle it just like any other coderef. + if (!exists $table{$target}->{$_}) { + $table{$target}->{$_} = $default_combiner; + } + + my $valuetype = ref($table{$target}->{$_}); + if ($valuetype eq "CODE") { + # CODE reference, execute it with the inherited values as + # arguments. + $table{$target}->{$_} = + $table{$target}->{$_}->(@{$combined_inheritance{$_}}); + } elsif ($valuetype eq "") { + # Scalar, just leave it as is. + } else { + # Some other type of reference that we don't handle. + # Better to abort at this point. + die "cannot handle reference type $valuetype," + ," found in target $target -> $_\n"; + } + } + + # Finally done, return the result. + return %{$table{$target}}; +} + sub usage { print STDERR $usage; @@ -2396,6 +2221,7 @@ sub usage my $k=0; foreach $i (sort keys %table) { + next if $table{$i}->{template}; next if $i =~ /^debug/; $k += length($i) + 1; if ($k > 78) @@ -2407,6 +2233,7 @@ sub usage } foreach $i (sort keys %table) { + next if $table{$i}->{template}; next if $i !~ /^debug/; $k += length($i) + 1; if ($k > 78) @@ -2456,53 +2283,54 @@ sub dofile sub print_table_entry { my $target = shift; + my %target = resolve_config($target); my $type = shift; # Don't print the templates - return if $table{$target}->{template}; + return if $target{template}; if ($type eq "TABLE") { print <<"EOF" *** $target -\$cc = $table{$target}->{cc} -\$cflags = $table{$target}->{cflags} -\$debug_cflags = $table{$target}->{debug_cflags} -\$release_cflags = $table{$target}->{release_cflags} -\$unistd = $table{$target}->{unistd} -\$thread_cflag = $table{$target}->{thread_cflag} -\$sys_id = $table{$target}->{sys_id} -\$lflags = $table{$target}->{lflags} -\$debug_lflags = $table{$target}->{debug_lflags} -\$release_lflags = $table{$target}->{release_lflags} -\$bn_ops = $table{$target}->{bn_ops} -\$cpuid_obj = $table{$target}->{cpuid_obj} -\$bn_obj = $table{$target}->{bn_obj} -\$ec_obj = $table{$target}->{ec_obj} -\$des_obj = $table{$target}->{des_obj} -\$aes_obj = $table{$target}->{aes_obj} -\$bf_obj = $table{$target}->{bf_obj} -\$md5_obj = $table{$target}->{md5_obj} -\$sha1_obj = $table{$target}->{sha1_obj} -\$cast_obj = $table{$target}->{cast_obj} -\$rc4_obj = $table{$target}->{rc4_obj} -\$rmd160_obj = $table{$target}->{rmd160_obj} -\$rc5_obj = $table{$target}->{rc5_obj} -\$wp_obj = $table{$target}->{wp_obj} -\$cmll_obj = $table{$target}->{cmll_obj} -\$modes_obj = $table{$target}->{modes_obj} -\$engines_obj = $table{$target}->{engines_obj} -\$chacha_obj = $table{$target}->{chacha_obj} -\$poly1305_obj = $table{$target}->{poly1305_obj} -\$perlasm_scheme = $table{$target}->{perlasm_scheme} -\$dso_scheme = $table{$target}->{dso_scheme} -\$shared_target= $table{$target}->{shared_target} -\$shared_cflag = $table{$target}->{shared_cflag} -\$shared_ldflag = $table{$target}->{shared_ldflag} -\$shared_extension = $table{$target}->{shared_extension} -\$ranlib = $table{$target}->{ranlib} -\$arflags = $table{$target}->{arflags} -\$multilib = $table{$target}->{multilib} +\$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 = ( @@ -2549,8 +2377,8 @@ EOF length((sort { length($a) <=> length($b) } @sequence)[-1]); print " '$target' => {\n"; foreach (@sequence) { - if ($table{$target}->{$_}) { - print " '",$_,"'"," " x ($largest - length($_))," => '",$table{$target}->{$_},"',\n"; + if ($target{$_}) { + print " '",$_,"'"," " x ($largest - length($_))," => '",$target{$_},"',\n"; } } print " },\n"; -- 2.40.0