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 <rsalz@openssl.org>

1 files 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 = <CONFFILE>;
-        $/ = $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 = <CONFFILE>;
+    $/ = $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";