658 lines
15 KiB
Perl
Executable File
658 lines
15 KiB
Perl
Executable File
# Copyright (C) 1997-2014 Free Software Foundation, Inc.
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2, or (at your option)
|
|
# any later version.
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package Automake::Condition;
|
|
|
|
use 5.006;
|
|
use strict;
|
|
use Carp;
|
|
|
|
require Exporter;
|
|
use vars '@ISA', '@EXPORT_OK';
|
|
@ISA = qw/Exporter/;
|
|
@EXPORT_OK = qw/TRUE FALSE reduce_and reduce_or/;
|
|
|
|
=head1 NAME
|
|
|
|
Automake::Condition - record a conjunction of conditionals
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
use Automake::Condition;
|
|
|
|
# Create a condition to represent "COND1 and not COND2".
|
|
my $cond = new Automake::Condition "COND1_TRUE", "COND2_FALSE";
|
|
# Create a condition to represent "not COND3".
|
|
my $other = new Automake::Condition "COND3_FALSE";
|
|
|
|
# Create a condition to represent
|
|
# "COND1 and not COND2 and not COND3".
|
|
my $both = $cond->merge ($other);
|
|
|
|
# Likewise, but using a list of conditional strings
|
|
my $both2 = $cond->merge_conds ("COND3_FALSE");
|
|
|
|
# Strip from $both any subconditions which are in $other.
|
|
# This is the opposite of merge.
|
|
$cond = $both->strip ($other);
|
|
|
|
# Return the list of conditions ("COND1_TRUE", "COND2_FALSE"):
|
|
my @conds = $cond->conds;
|
|
|
|
# Is $cond always true? (Not in this example)
|
|
if ($cond->true) { ... }
|
|
|
|
# Is $cond always false? (Not in this example)
|
|
if ($cond->false) { ... }
|
|
|
|
# Return the list of conditionals as a string:
|
|
# "COND1_TRUE COND2_FALSE"
|
|
my $str = $cond->string;
|
|
|
|
# Return the list of conditionals as a human readable string:
|
|
# "COND1 and !COND2"
|
|
my $str = $cond->human;
|
|
|
|
# Return the list of conditionals as a AC_SUBST-style string:
|
|
# "@COND1_TRUE@@COND2_FALSE@"
|
|
my $subst = $cond->subst_string;
|
|
|
|
# Is $cond true when $both is true? (Yes in this example)
|
|
if ($cond->true_when ($both)) { ... }
|
|
|
|
# Is $cond redundant w.r.t. {$other, $both}?
|
|
# (Yes in this example)
|
|
if ($cond->redundant_wrt ($other, $both)) { ... }
|
|
|
|
# Does $cond imply any of {$other, $both}?
|
|
# (Not in this example)
|
|
if ($cond->implies_any ($other, $both)) { ... }
|
|
|
|
# Remove superfluous conditionals assuming they will eventually
|
|
# be multiplied together.
|
|
# (Returns @conds = ($both) in this example, because
|
|
# $other and $cond are implied by $both.)
|
|
@conds = Automake::Condition::reduce_and ($other, $both, $cond);
|
|
|
|
# Remove superfluous conditionals assuming they will eventually
|
|
# be summed together.
|
|
# (Returns @conds = ($cond, $other) in this example, because
|
|
# $both is a subset condition of $cond: $cond is true whenever $both
|
|
# is true.)
|
|
@conds = Automake::Condition::reduce_or ($other, $both, $cond);
|
|
|
|
# Invert a Condition. This returns a list of Conditions.
|
|
@conds = $both->not;
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
A C<Condition> is a conjunction of conditionals (i.e., atomic conditions
|
|
defined in F<configure.ac> by C<AM_CONDITIONAL>. In Automake they
|
|
are used to represent the conditions into which F<Makefile> variables and
|
|
F<Makefile> rules are defined.
|
|
|
|
If the variable C<VAR> is defined as
|
|
|
|
if COND1
|
|
if COND2
|
|
VAR = value
|
|
endif
|
|
endif
|
|
|
|
then it will be associated a C<Condition> created with
|
|
the following statement.
|
|
|
|
new Automake::Condition "COND1_TRUE", "COND2_TRUE";
|
|
|
|
Remember that a C<Condition> is a I<conjunction> of conditionals, so
|
|
the above C<Condition> means C<VAR> is defined when C<COND1>
|
|
B<and> C<COND2> are true. There is no way to express disjunctions
|
|
(i.e., I<or>s) with this class (but see L<DisjConditions>).
|
|
|
|
Another point worth to mention is that each C<Condition> object is
|
|
unique with respect to its conditionals. Two C<Condition> objects
|
|
created for the same set of conditionals will have the same address.
|
|
This makes it easy to compare C<Condition>s: just compare the
|
|
references.
|
|
|
|
my $c1 = new Automake::Condition "COND1_TRUE", "COND2_TRUE";
|
|
my $c2 = new Automake::Condition "COND1_TRUE", "COND2_TRUE";
|
|
$c1 == $c2; # True!
|
|
|
|
=head2 Methods
|
|
|
|
=over 4
|
|
|
|
=item C<$cond = new Automake::Condition [@conds]>
|
|
|
|
Return a C<Condition> objects for the conjunctions of conditionals
|
|
listed in C<@conds> as strings.
|
|
|
|
An item in C<@conds> should be either C<"FALSE">, C<"TRUE">, or have
|
|
the form C<"NAME_FALSE"> or C<"NAME_TRUE"> where C<NAME> can be
|
|
anything (in practice C<NAME> should be the name of a conditional
|
|
declared in F<configure.ac> with C<AM_CONDITIONAL>, but it's not
|
|
C<Automake::Condition>'s responsibility to ensure this).
|
|
|
|
An empty C<@conds> means C<"TRUE">.
|
|
|
|
As explained previously, the reference (object) returned is unique
|
|
with respect to C<@conds>. For this purpose, duplicate elements are
|
|
ignored, and C<@conds> is rewritten as C<("FALSE")> if it contains
|
|
C<"FALSE"> or two contradictory conditionals (such as C<"NAME_FALSE">
|
|
and C<"NAME_TRUE">.)
|
|
|
|
Therefore the following two statements create the same object (they
|
|
both create the C<"FALSE"> condition).
|
|
|
|
my $c3 = new Automake::Condition "COND1_TRUE", "COND1_FALSE";
|
|
my $c4 = new Automake::Condition "COND2_TRUE", "FALSE";
|
|
$c3 == $c4; # True!
|
|
$c3 == FALSE; # True!
|
|
|
|
=cut
|
|
|
|
# Keys in this hash are conditional strings. Values are the
|
|
# associated object conditions. This is used by 'new' to reuse
|
|
# Condition objects with identical conditionals.
|
|
use vars '%_condition_singletons';
|
|
# Do NOT reset this hash here. It's already empty by default,
|
|
# and any setting would otherwise occur AFTER the 'TRUE' and 'FALSE'
|
|
# constants definitions.
|
|
# %_condition_singletons = ();
|
|
|
|
sub new ($;@)
|
|
{
|
|
my ($class, @conds) = @_;
|
|
my $self = {
|
|
hash => {},
|
|
};
|
|
bless $self, $class;
|
|
|
|
for my $cond (@conds)
|
|
{
|
|
# Catch some common programming errors:
|
|
# - A Condition passed to new
|
|
confess "'$cond' is a reference, expected a string" if ref $cond;
|
|
# - A Condition passed as a string to new
|
|
confess "'$cond' does not look like a condition" if $cond =~ /::/;
|
|
}
|
|
|
|
# Accept strings like "FOO BAR" as shorthand for ("FOO", "BAR").
|
|
@conds = map { split (' ', $_) } @conds;
|
|
|
|
for my $cond (@conds)
|
|
{
|
|
next if $cond eq 'TRUE';
|
|
|
|
# Detect cases when @conds can be simplified to FALSE.
|
|
if (($cond eq 'FALSE' && $#conds > 0)
|
|
|| ($cond =~ /^(.*)_TRUE$/ && exists $self->{'hash'}{"${1}_FALSE"})
|
|
|| ($cond =~ /^(.*)_FALSE$/ && exists $self->{'hash'}{"${1}_TRUE"}))
|
|
{
|
|
return &FALSE;
|
|
}
|
|
|
|
$self->{'hash'}{$cond} = 1;
|
|
}
|
|
|
|
my $key = $self->string;
|
|
if (exists $_condition_singletons{$key})
|
|
{
|
|
return $_condition_singletons{$key};
|
|
}
|
|
$_condition_singletons{$key} = $self;
|
|
return $self;
|
|
}
|
|
|
|
=item C<$newcond = $cond-E<gt>merge (@otherconds)>
|
|
|
|
Return a new condition which is the conjunction of
|
|
C<$cond> and C<@otherconds>.
|
|
|
|
=cut
|
|
|
|
sub merge ($@)
|
|
{
|
|
my ($self, @otherconds) = @_;
|
|
new Automake::Condition (map { $_->conds } ($self, @otherconds));
|
|
}
|
|
|
|
=item C<$newcond = $cond-E<gt>merge_conds (@conds)>
|
|
|
|
Return a new condition which is the conjunction of C<$cond> and
|
|
C<@conds>, where C<@conds> is a list of conditional strings, as
|
|
passed to C<new>.
|
|
|
|
=cut
|
|
|
|
sub merge_conds ($@)
|
|
{
|
|
my ($self, @conds) = @_;
|
|
new Automake::Condition $self->conds, @conds;
|
|
}
|
|
|
|
=item C<$newcond = $cond-E<gt>strip ($minuscond)>
|
|
|
|
Return a new condition which has all the conditionals of C<$cond>
|
|
except those of C<$minuscond>. This is the opposite of C<merge>.
|
|
|
|
=cut
|
|
|
|
sub strip ($$)
|
|
{
|
|
my ($self, $minus) = @_;
|
|
my @res = grep { not $minus->_has ($_) } $self->conds;
|
|
return new Automake::Condition @res;
|
|
}
|
|
|
|
=item C<@list = $cond-E<gt>conds>
|
|
|
|
Return the set of conditionals defining C<$cond>, as strings. Note that
|
|
this might not be exactly the list passed to C<new> (or a
|
|
concatenation of such lists if C<merge> was used), because of the
|
|
cleanup mentioned in C<new>'s description.
|
|
|
|
For instance C<$c3-E<gt>conds> will simply return C<("FALSE")>.
|
|
|
|
=cut
|
|
|
|
sub conds ($ )
|
|
{
|
|
my ($self) = @_;
|
|
my @conds = keys %{$self->{'hash'}};
|
|
return ("TRUE") unless @conds;
|
|
return sort @conds;
|
|
}
|
|
|
|
# Undocumented, shouldn't be needed outside of this class.
|
|
sub _has ($$)
|
|
{
|
|
my ($self, $cond) = @_;
|
|
return exists $self->{'hash'}{$cond};
|
|
}
|
|
|
|
=item C<$cond-E<gt>false>
|
|
|
|
Return 1 iff this condition is always false.
|
|
|
|
=cut
|
|
|
|
sub false ($ )
|
|
{
|
|
my ($self) = @_;
|
|
return $self->_has ('FALSE');
|
|
}
|
|
|
|
=item C<$cond-E<gt>true>
|
|
|
|
Return 1 iff this condition is always true.
|
|
|
|
=cut
|
|
|
|
sub true ($ )
|
|
{
|
|
my ($self) = @_;
|
|
return 0 == keys %{$self->{'hash'}};
|
|
}
|
|
|
|
=item C<$cond-E<gt>string>
|
|
|
|
Build a string which denotes the condition.
|
|
|
|
For instance using the C<$cond> definition from L<SYNOPSYS>,
|
|
C<$cond-E<gt>string> will return C<"COND1_TRUE COND2_FALSE">.
|
|
|
|
=cut
|
|
|
|
sub string ($ )
|
|
{
|
|
my ($self) = @_;
|
|
|
|
return $self->{'string'} if defined $self->{'string'};
|
|
|
|
my $res = '';
|
|
if ($self->false)
|
|
{
|
|
$res = 'FALSE';
|
|
}
|
|
else
|
|
{
|
|
$res = join (' ', $self->conds);
|
|
}
|
|
$self->{'string'} = $res;
|
|
return $res;
|
|
}
|
|
|
|
=item C<$cond-E<gt>human>
|
|
|
|
Build a human readable string which denotes the condition.
|
|
|
|
For instance using the C<$cond> definition from L<SYNOPSYS>,
|
|
C<$cond-E<gt>string> will return C<"COND1 and !COND2">.
|
|
|
|
=cut
|
|
|
|
sub _to_human ($ )
|
|
{
|
|
my ($s) = @_;
|
|
if ($s =~ /^(.*)_(TRUE|FALSE)$/)
|
|
{
|
|
return (($2 eq 'FALSE') ? '!' : '') . $1;
|
|
}
|
|
else
|
|
{
|
|
return $s;
|
|
}
|
|
}
|
|
|
|
sub human ($ )
|
|
{
|
|
my ($self) = @_;
|
|
|
|
return $self->{'human'} if defined $self->{'human'};
|
|
|
|
my $res = '';
|
|
if ($self->false)
|
|
{
|
|
$res = 'FALSE';
|
|
}
|
|
else
|
|
{
|
|
$res = join (' and ', map { _to_human $_ } $self->conds);
|
|
}
|
|
$self->{'human'} = $res;
|
|
return $res;
|
|
}
|
|
|
|
=item C<$cond-E<gt>subst_string>
|
|
|
|
Build a C<AC_SUBST>-style string for output in F<Makefile.in>.
|
|
|
|
For instance using the C<$cond> definition from L<SYNOPSYS>,
|
|
C<$cond-E<gt>subst_string> will return C<"@COND1_TRUE@@COND2_FALSE@">.
|
|
|
|
=cut
|
|
|
|
sub subst_string ($ )
|
|
{
|
|
my ($self) = @_;
|
|
|
|
return $self->{'subst_string'} if defined $self->{'subst_string'};
|
|
|
|
my $res = '';
|
|
if ($self->false)
|
|
{
|
|
$res = '#';
|
|
}
|
|
elsif (! $self->true)
|
|
{
|
|
$res = '@' . join ('@@', sort $self->conds) . '@';
|
|
}
|
|
$self->{'subst_string'} = $res;
|
|
return $res;
|
|
}
|
|
|
|
=item C<$cond-E<gt>true_when ($when)>
|
|
|
|
Return 1 iff C<$cond> is true when C<$when> is true.
|
|
Return 0 otherwise.
|
|
|
|
Using the definitions from L<SYNOPSYS>, C<$cond> is true
|
|
when C<$both> is true, but the converse is wrong.
|
|
|
|
=cut
|
|
|
|
sub true_when ($$)
|
|
{
|
|
my ($self, $when) = @_;
|
|
|
|
# Nothing is true when FALSE (not even FALSE itself, but it
|
|
# shouldn't hurt if you decide to change that).
|
|
return 0 if $self->false || $when->false;
|
|
|
|
# If we are true, we stay true when $when is true :)
|
|
return 1 if $self->true;
|
|
|
|
# $SELF is true under $WHEN if each conditional component of $SELF
|
|
# exists in $WHEN.
|
|
foreach my $cond ($self->conds)
|
|
{
|
|
return 0 unless $when->_has ($cond);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
=item C<$cond-E<gt>redundant_wrt (@conds)>
|
|
|
|
Return 1 iff C<$cond> is true for any condition in C<@conds>.
|
|
If @conds is empty, return 1 iff C<$cond> is C<FALSE>.
|
|
Return 0 otherwise.
|
|
|
|
=cut
|
|
|
|
sub redundant_wrt ($@)
|
|
{
|
|
my ($self, @conds) = @_;
|
|
|
|
foreach my $cond (@conds)
|
|
{
|
|
return 1 if $self->true_when ($cond);
|
|
}
|
|
return $self->false;
|
|
}
|
|
|
|
=item C<$cond-E<gt>implies_any (@conds)>
|
|
|
|
Return 1 iff C<$cond> implies any of the conditions in C<@conds>.
|
|
Return 0 otherwise.
|
|
|
|
=cut
|
|
|
|
sub implies_any ($@)
|
|
{
|
|
my ($self, @conds) = @_;
|
|
|
|
foreach my $cond (@conds)
|
|
{
|
|
return 1 if $cond->true_when ($self);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
=item C<$cond-E<gt>not>
|
|
|
|
Return a negation of C<$cond> as a list of C<Condition>s.
|
|
This list should be used to construct a C<DisjConditions>
|
|
(we cannot return a C<DisjConditions> from C<Automake::Condition>,
|
|
because that would make these two packages interdependent).
|
|
|
|
=cut
|
|
|
|
sub not ($ )
|
|
{
|
|
my ($self) = @_;
|
|
return @{$self->{'not'}} if defined $self->{'not'};
|
|
my @res =
|
|
map { new Automake::Condition &conditional_negate ($_) } $self->conds;
|
|
$self->{'not'} = [@res];
|
|
return @res;
|
|
}
|
|
|
|
=item C<$cond-E<gt>multiply (@conds)>
|
|
|
|
Assumption: C<@conds> represent a disjunction of conditions.
|
|
|
|
Return the result of multiplying C<$cond> with that disjunction.
|
|
The result will be a list of conditions suitable to construct a
|
|
C<DisjConditions>.
|
|
|
|
=cut
|
|
|
|
sub multiply ($@)
|
|
{
|
|
my ($self, @set) = @_;
|
|
my %res = ();
|
|
for my $cond (@set)
|
|
{
|
|
my $ans = $self->merge ($cond);
|
|
$res{$ans} = $ans;
|
|
}
|
|
|
|
# FALSE can always be removed from a disjunction.
|
|
delete $res{FALSE};
|
|
|
|
# Now, $self is a common factor of the remaining conditions.
|
|
# If one of the conditions is $self, we can discard the rest.
|
|
return ($self, ())
|
|
if exists $res{$self};
|
|
|
|
return (values %res);
|
|
}
|
|
|
|
=back
|
|
|
|
=head2 Other helper functions
|
|
|
|
=over 4
|
|
|
|
=item C<TRUE>
|
|
|
|
The C<"TRUE"> conditional.
|
|
|
|
=item C<FALSE>
|
|
|
|
The C<"FALSE"> conditional.
|
|
|
|
=cut
|
|
|
|
use constant TRUE => new Automake::Condition "TRUE";
|
|
use constant FALSE => new Automake::Condition "FALSE";
|
|
|
|
=item C<reduce_and (@conds)>
|
|
|
|
Return a subset of @conds with the property that the conjunction of
|
|
the subset is the same as the conjunction of @conds. For example, if
|
|
both C<COND1_TRUE COND2_TRUE> and C<COND1_TRUE> are in the list,
|
|
discard the latter. If the input list is empty, return C<(TRUE)>.
|
|
|
|
=cut
|
|
|
|
sub reduce_and (@)
|
|
{
|
|
my (@conds) = @_;
|
|
my @ret = ();
|
|
my $cond;
|
|
while (@conds > 0)
|
|
{
|
|
$cond = shift @conds;
|
|
|
|
# FALSE is absorbent.
|
|
return FALSE
|
|
if $cond == FALSE;
|
|
|
|
if (! $cond->redundant_wrt (@ret, @conds))
|
|
{
|
|
push (@ret, $cond);
|
|
}
|
|
}
|
|
|
|
return TRUE if @ret == 0;
|
|
return @ret;
|
|
}
|
|
|
|
=item C<reduce_or (@conds)>
|
|
|
|
Return a subset of @conds with the property that the disjunction of
|
|
the subset is equivalent to the disjunction of @conds. For example,
|
|
if both C<COND1_TRUE COND2_TRUE> and C<COND1_TRUE> are in the list,
|
|
discard the former. If the input list is empty, return C<(FALSE)>.
|
|
|
|
=cut
|
|
|
|
sub reduce_or (@)
|
|
{
|
|
my (@conds) = @_;
|
|
my @ret = ();
|
|
my $cond;
|
|
while (@conds > 0)
|
|
{
|
|
$cond = shift @conds;
|
|
|
|
next
|
|
if $cond == FALSE;
|
|
return TRUE
|
|
if $cond == TRUE;
|
|
|
|
push (@ret, $cond)
|
|
unless $cond->implies_any (@ret, @conds);
|
|
}
|
|
|
|
return FALSE if @ret == 0;
|
|
return @ret;
|
|
}
|
|
|
|
=item C<conditional_negate ($condstr)>
|
|
|
|
Negate a conditional string.
|
|
|
|
=cut
|
|
|
|
sub conditional_negate ($)
|
|
{
|
|
my ($cond) = @_;
|
|
|
|
$cond =~ s/TRUE$/TRUEO/;
|
|
$cond =~ s/FALSE$/TRUE/;
|
|
$cond =~ s/TRUEO$/FALSE/;
|
|
|
|
return $cond;
|
|
}
|
|
|
|
=back
|
|
|
|
=head1 SEE ALSO
|
|
|
|
L<Automake::DisjConditions>.
|
|
|
|
=head1 HISTORY
|
|
|
|
C<AM_CONDITIONAL>s and supporting code were added to Automake 1.1o by
|
|
Ian Lance Taylor <ian@cygnus.org> in 1997. Since then it has been
|
|
improved by Tom Tromey <tromey@redhat.com>, Richard Boulton
|
|
<richard@tartarus.org>, Raja R Harinath <harinath@cs.umn.edu>,
|
|
Akim Demaille <akim@epita.fr>, and Alexandre Duret-Lutz <adl@gnu.org>.
|
|
|
|
=cut
|
|
|
|
1;
|
|
|
|
### Setup "GNU" style for perl-mode and cperl-mode.
|
|
## Local Variables:
|
|
## perl-indent-level: 2
|
|
## perl-continued-statement-offset: 2
|
|
## perl-continued-brace-offset: 0
|
|
## perl-brace-offset: 0
|
|
## perl-brace-imaginary-offset: 0
|
|
## perl-label-offset: -2
|
|
## cperl-indent-level: 2
|
|
## cperl-brace-offset: 0
|
|
## cperl-continued-brace-offset: 0
|
|
## cperl-label-offset: -2
|
|
## cperl-extra-newline-before-brace: t
|
|
## cperl-merge-trailing-else: nil
|
|
## cperl-continued-statement-offset: 2
|
|
## End:
|