# 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,
# 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
# }
#
-my %table=(
+our %table=(
# All these templates are merely a translation of the corresponding
# variables further up.
},
);
-{ 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");
$target = $t;
}
}
+my %target = resolve_config($target);
-&usage if (!defined($table{$target}) || $table{$target}->{template});
+&usage if (!%target || $target{template});
if ($fips)
{
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
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;
my $k=0;
foreach $i (sort keys %table)
{
+ next if $table{$i}->{template};
next if $i =~ /^debug/;
$k += length($i) + 1;
if ($k > 78)
}
foreach $i (sort keys %table)
{
+ next if $table{$i}->{template};
next if $i !~ /^debug/;
$k += length($i) + 1;
if ($k > 78)
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 = (
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";
projects / openssl.git / commitdiff