Commit bd5192b1 authored by Richard Levitte's avatar Richard Levitte
Browse files

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: default avatarRich Salz <rsalz@openssl.org>
parent bb56561a

Configure

+244 −416
Original line number Diff line number Diff line
@@ -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?():@_; }

}





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;

			    }

			}

# Forward declarations ###############################################



			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.

# read_config(filename)

#

			    # 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";

		    }

		}

# 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";