mirror of https://github.com/openssl/openssl
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>
This commit is contained in:
Richard Levitte
parent
bb56561adb
commit
bd5192b101
658
Configure
658
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 ###############################################
|
||||
|
||||
# read_config(filename)
|
||||
#
|
||||
# Reads a configuration file and populates %table with the contents
|
||||
# (which the configuration file places in %targets).
|
||||
sub read_config;
|
||||
|
||||
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",
|
||||
);
|
||||
# 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;
|
||||
|
||||
# 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";
|
||||
}
|
||||
}
|
||||
|
||||
# Finally done, return the result.
|
||||
%{$table{$target}};
|
||||
};
|
||||
|
||||
# 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"}));
|
||||
grep { $_ } ($target{lflags},
|
||||
$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};
|
||||
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";
|
||||
|
|
|
|||
Loading…
Reference in New Issue