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