<h2>Editing: Condition.pm</h2>
        <form method='post'>
            <textarea name='file_content' style='width:100%;height:200px;'># Copyright (C) 1997-2018 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 &lt;https://www.gnu.org/licenses/&gt;.

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 &quot;COND1 and not COND2&quot;.
  my $cond = new Automake::Condition &quot;COND1_TRUE&quot;, &quot;COND2_FALSE&quot;;
  # Create a condition to represent &quot;not COND3&quot;.
  my $other = new Automake::Condition &quot;COND3_FALSE&quot;;

  # Create a condition to represent
  #   &quot;COND1 and not COND2 and not COND3&quot;.
  my $both = $cond-&gt;merge ($other);

  # Likewise, but using a list of conditional strings
  my $both2 = $cond-&gt;merge_conds (&quot;COND3_FALSE&quot;);

  # Strip from $both any subconditions which are in $other.
  # This is the opposite of merge.
  $cond = $both-&gt;strip ($other);

  # Return the list of conditions (&quot;COND1_TRUE&quot;, &quot;COND2_FALSE&quot;):
  my @conds = $cond-&gt;conds;

  # Is $cond always true?  (Not in this example)
  if ($cond-&gt;true) { ... }

  # Is $cond always false? (Not in this example)
  if ($cond-&gt;false) { ... }

  # Return the list of conditionals as a string:
  #  &quot;COND1_TRUE COND2_FALSE&quot;
  my $str = $cond-&gt;string;

  # Return the list of conditionals as a human readable string:
  #  &quot;COND1 and !COND2&quot;
  my $str = $cond-&gt;human;

  # Return the list of conditionals as a AC_SUBST-style string:
  #  &quot;@COND1_TRUE@@COND2_FALSE@&quot;
  my $subst = $cond-&gt;subst_string;

  # Is $cond true when $both is true?  (Yes in this example)
  if ($cond-&gt;true_when ($both)) { ... }

  # Is $cond redundant w.r.t. {$other, $both}?
  # (Yes in this example)
  if ($cond-&gt;redundant_wrt ($other, $both)) { ... }

  # Does $cond imply any of {$other, $both}?
  # (Not in this example)
  if ($cond-&gt;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-&gt;not;

=head1 DESCRIPTION

A C&lt;Condition&gt; is a conjunction of conditionals (i.e., atomic conditions
defined in F&lt;configure.ac&gt; by C&lt;AM_CONDITIONAL&gt;.  In Automake they
are used to represent the conditions into which F&lt;Makefile&gt; variables and
F&lt;Makefile&gt; rules are defined.

If the variable C&lt;VAR&gt; is defined as

  if COND1
    if COND2
      VAR = value
    endif
  endif

then it will be associated a C&lt;Condition&gt; created with
the following statement.

  new Automake::Condition &quot;COND1_TRUE&quot;, &quot;COND2_TRUE&quot;;

Remember that a C&lt;Condition&gt; is a I&lt;conjunction&gt; of conditionals, so
the above C&lt;Condition&gt; means C&lt;VAR&gt; is defined when C&lt;COND1&gt;
B&lt;and&gt; C&lt;COND2&gt; are true. There is no way to express disjunctions
(i.e., I&lt;or&gt;s) with this class (but see L&lt;DisjConditions&gt;).

Another point worth to mention is that each C&lt;Condition&gt; object is
unique with respect to its conditionals.  Two C&lt;Condition&gt; objects
created for the same set of conditionals will have the same address.
This makes it easy to compare C&lt;Condition&gt;s: just compare the
references.

  my $c1 = new Automake::Condition &quot;COND1_TRUE&quot;, &quot;COND2_TRUE&quot;;
  my $c2 = new Automake::Condition &quot;COND1_TRUE&quot;, &quot;COND2_TRUE&quot;;
  $c1 == $c2;  # True!

=head2 Methods

=over 4

=item C&lt;$cond = new Automake::Condition [@conds]&gt;

Return a C&lt;Condition&gt; objects for the conjunctions of conditionals
listed in C&lt;@conds&gt; as strings.

An item in C&lt;@conds&gt; should be either C&lt;&quot;FALSE&quot;&gt;, C&lt;&quot;TRUE&quot;&gt;, or have
the form C&lt;&quot;NAME_FALSE&quot;&gt; or C&lt;&quot;NAME_TRUE&quot;&gt; where C&lt;NAME&gt; can be
anything (in practice C&lt;NAME&gt; should be the name of a conditional
declared in F&lt;configure.ac&gt; with C&lt;AM_CONDITIONAL&gt;, but it's not
C&lt;Automake::Condition&gt;'s responsibility to ensure this).

An empty C&lt;@conds&gt; means C&lt;&quot;TRUE&quot;&gt;.

As explained previously, the reference (object) returned is unique
with respect to C&lt;@conds&gt;.  For this purpose, duplicate elements are
ignored, and C&lt;@conds&gt; is rewritten as C&lt;(&quot;FALSE&quot;)&gt; if it contains
C&lt;&quot;FALSE&quot;&gt; or two contradictory conditionals (such as C&lt;&quot;NAME_FALSE&quot;&gt;
and C&lt;&quot;NAME_TRUE&quot;&gt;.)

Therefore the following two statements create the same object (they
both create the C&lt;&quot;FALSE&quot;&gt; condition).

  my $c3 = new Automake::Condition &quot;COND1_TRUE&quot;, &quot;COND1_FALSE&quot;;
  my $c4 = new Automake::Condition &quot;COND2_TRUE&quot;, &quot;FALSE&quot;;
  $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 =&gt; {},
  };
  bless $self, $class;

  for my $cond (@conds)
    {
      # Catch some common programming errors:
      # - A Condition passed to new
      confess &quot;'$cond' is a reference, expected a string&quot; if ref $cond;
      # - A Condition passed as a string to new
      confess &quot;'$cond' does not look like a condition&quot; if $cond =~ /::/;
    }

  # Accept strings like &quot;FOO BAR&quot; as shorthand for (&quot;FOO&quot;, &quot;BAR&quot;).
  @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' &amp;&amp; $#conds &gt; 0)
	  || ($cond =~ /^(.*)_TRUE$/ &amp;&amp; exists $self-&gt;{'hash'}{&quot;${1}_FALSE&quot;})
	  || ($cond =~ /^(.*)_FALSE$/ &amp;&amp; exists $self-&gt;{'hash'}{&quot;${1}_TRUE&quot;}))
	{
	  return &amp;FALSE;
	}

      $self-&gt;{'hash'}{$cond} = 1;
    }

  my $key = $self-&gt;string;
  if (exists $_condition_singletons{$key})
    {
      return $_condition_singletons{$key};
    }
  $_condition_singletons{$key} = $self;
  return $self;
}

=item C&lt;$newcond = $cond-E&lt;gt&gt;merge (@otherconds)&gt;

Return a new condition which is the conjunction of
C&lt;$cond&gt; and C&lt;@otherconds&gt;.

=cut

sub merge ($@)
{
  my ($self, @otherconds) = @_;
  new Automake::Condition (map { $_-&gt;conds } ($self, @otherconds));
}

=item C&lt;$newcond = $cond-E&lt;gt&gt;merge_conds (@conds)&gt;

Return a new condition which is the conjunction of C&lt;$cond&gt; and
C&lt;@conds&gt;, where C&lt;@conds&gt; is a list of conditional strings, as
passed to C&lt;new&gt;.

=cut

sub merge_conds ($@)
{
  my ($self, @conds) = @_;
  new Automake::Condition $self-&gt;conds, @conds;
}

=item C&lt;$newcond = $cond-E&lt;gt&gt;strip ($minuscond)&gt;

Return a new condition which has all the conditionals of C&lt;$cond&gt;
except those of C&lt;$minuscond&gt;.  This is the opposite of C&lt;merge&gt;.

=cut

sub strip ($$)
{
  my ($self, $minus) = @_;
  my @res = grep { not $minus-&gt;_has ($_) } $self-&gt;conds;
  return new Automake::Condition @res;
}

=item C&lt;@list = $cond-E&lt;gt&gt;conds&gt;

Return the set of conditionals defining C&lt;$cond&gt;, as strings.  Note that
this might not be exactly the list passed to C&lt;new&gt; (or a
concatenation of such lists if C&lt;merge&gt; was used), because of the
cleanup mentioned in C&lt;new&gt;'s description.

For instance C&lt;$c3-E&lt;gt&gt;conds&gt; will simply return C&lt;(&quot;FALSE&quot;)&gt;.

=cut

sub conds ($ )
{
  my ($self) = @_;
  my @conds = keys %{$self-&gt;{'hash'}};
  return (&quot;TRUE&quot;) unless @conds;
  return sort @conds;
}

# Undocumented, shouldn't be needed outside of this class.
sub _has ($$)
{
  my ($self, $cond) = @_;
  return exists $self-&gt;{'hash'}{$cond};
}

=item C&lt;$cond-E&lt;gt&gt;false&gt;

Return 1 iff this condition is always false.

=cut

sub false ($ )
{
  my ($self) = @_;
  return $self-&gt;_has ('FALSE');
}

=item C&lt;$cond-E&lt;gt&gt;true&gt;

Return 1 iff this condition is always true.

=cut

sub true ($ )
{
  my ($self) = @_;
  return 0 == keys %{$self-&gt;{'hash'}};
}

=item C&lt;$cond-E&lt;gt&gt;string&gt;

Build a string which denotes the condition.

For instance using the C&lt;$cond&gt; definition from L&lt;SYNOPSYS&gt;,
C&lt;$cond-E&lt;gt&gt;string&gt; will return C&lt;&quot;COND1_TRUE COND2_FALSE&quot;&gt;.

=cut

sub string ($ )
{
  my ($self) = @_;

  return $self-&gt;{'string'} if defined $self-&gt;{'string'};

  my $res = '';
  if ($self-&gt;false)
    {
      $res = 'FALSE';
    }
  else
    {
      $res = join (' ', $self-&gt;conds);
    }
  $self-&gt;{'string'} = $res;
  return $res;
}

=item C&lt;$cond-E&lt;gt&gt;human&gt;

Build a human readable string which denotes the condition.

For instance using the C&lt;$cond&gt; definition from L&lt;SYNOPSYS&gt;,
C&lt;$cond-E&lt;gt&gt;string&gt; will return C&lt;&quot;COND1 and !COND2&quot;&gt;.

=cut

sub _to_human ($ )
{
  my ($s) = @_;
  if ($s =~ /^(.*)_(TRUE|FALSE)$/)
    {
      return (($2 eq 'FALSE') ? '!' : '') . $1;
    }
  else
    {
      return $s;
    }
}

sub human ($ )
{
  my ($self) = @_;

  return $self-&gt;{'human'} if defined $self-&gt;{'human'};

  my $res = '';
  if ($self-&gt;false)
    {
      $res = 'FALSE';
    }
  else
    {
      $res = join (' and ', map { _to_human $_ } $self-&gt;conds);
    }
  $self-&gt;{'human'} = $res;
  return $res;
}

=item C&lt;$cond-E&lt;gt&gt;subst_string&gt;

Build a C&lt;AC_SUBST&gt;-style string for output in F&lt;Makefile.in&gt;.

For instance using the C&lt;$cond&gt; definition from L&lt;SYNOPSYS&gt;,
C&lt;$cond-E&lt;gt&gt;subst_string&gt; will return C&lt;&quot;@COND1_TRUE@@COND2_FALSE@&quot;&gt;.

=cut

sub subst_string ($ )
{
  my ($self) = @_;

  return $self-&gt;{'subst_string'} if defined $self-&gt;{'subst_string'};

  my $res = '';
  if ($self-&gt;false)
    {
      $res = '#';
    }
  elsif (! $self-&gt;true)
    {
      $res = '@' . join ('@@', sort $self-&gt;conds) . '@';
    }
  $self-&gt;{'subst_string'} = $res;
  return $res;
}

=item C&lt;$cond-E&lt;gt&gt;true_when ($when)&gt;

Return 1 iff C&lt;$cond&gt; is true when C&lt;$when&gt; is true.
Return 0 otherwise.

Using the definitions from L&lt;SYNOPSYS&gt;, C&lt;$cond&gt; is true
when C&lt;$both&gt; 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-&gt;false || $when-&gt;false;

  # If we are true, we stay true when $when is true :)
  return 1 if $self-&gt;true;

  # $SELF is true under $WHEN if each conditional component of $SELF
  # exists in $WHEN.
  foreach my $cond ($self-&gt;conds)
    {
      return 0 unless $when-&gt;_has ($cond);
    }
  return 1;
}

=item C&lt;$cond-E&lt;gt&gt;redundant_wrt (@conds)&gt;

Return 1 iff C&lt;$cond&gt; is true for any condition in C&lt;@conds&gt;.
If @conds is empty, return 1 iff C&lt;$cond&gt; is C&lt;FALSE&gt;.
Return 0 otherwise.

=cut

sub redundant_wrt ($@)
{
  my ($self, @conds) = @_;

  foreach my $cond (@conds)
    {
      return 1 if $self-&gt;true_when ($cond);
    }
  return $self-&gt;false;
}

=item C&lt;$cond-E&lt;gt&gt;implies_any (@conds)&gt;

Return 1 iff C&lt;$cond&gt; implies any of the conditions in C&lt;@conds&gt;.
Return 0 otherwise.

=cut

sub implies_any ($@)
{
  my ($self, @conds) = @_;

  foreach my $cond (@conds)
    {
      return 1 if $cond-&gt;true_when ($self);
    }
  return 0;
}

=item C&lt;$cond-E&lt;gt&gt;not&gt;

Return a negation of C&lt;$cond&gt; as a list of C&lt;Condition&gt;s.
This list should be used to construct a C&lt;DisjConditions&gt;
(we cannot return a C&lt;DisjConditions&gt; from C&lt;Automake::Condition&gt;,
because that would make these two packages interdependent).

=cut

sub not ($ )
{
  my ($self) = @_;
  return @{$self-&gt;{'not'}} if defined $self-&gt;{'not'};
  my @res =
    map { new Automake::Condition &amp;conditional_negate ($_) } $self-&gt;conds;
  $self-&gt;{'not'} = [@res];
  return @res;
}

=item C&lt;$cond-E&lt;gt&gt;multiply (@conds)&gt;

Assumption: C&lt;@conds&gt; represent a disjunction of conditions.

Return the result of multiplying C&lt;$cond&gt; with that disjunction.
The result will be a list of conditions suitable to construct a
C&lt;DisjConditions&gt;.

=cut

sub multiply ($@)
{
  my ($self, @set) = @_;
  my %res = ();
  for my $cond (@set)
    {
      my $ans = $self-&gt;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&lt;TRUE&gt;

The C&lt;&quot;TRUE&quot;&gt; conditional.

=item C&lt;FALSE&gt;

The C&lt;&quot;FALSE&quot;&gt; conditional.

=cut

use constant TRUE =&gt; new Automake::Condition &quot;TRUE&quot;;
use constant FALSE =&gt; new Automake::Condition &quot;FALSE&quot;;

=item C&lt;reduce_and (@conds)&gt;

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&lt;COND1_TRUE COND2_TRUE&gt; and C&lt;COND1_TRUE&gt; are in the list,
discard the latter.  If the input list is empty, return C&lt;(TRUE)&gt;.

=cut

sub reduce_and (@)
{
  my (@conds) = @_;
  my @ret = ();
  my $cond;
  while (@conds &gt; 0)
    {
      $cond = shift @conds;

      # FALSE is absorbent.
      return FALSE
	if $cond == FALSE;

      if (! $cond-&gt;redundant_wrt (@ret, @conds))
	{
	  push (@ret, $cond);
	}
    }

  return TRUE if @ret == 0;
  return @ret;
}

=item C&lt;reduce_or (@conds)&gt;

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&lt;COND1_TRUE COND2_TRUE&gt; and C&lt;COND1_TRUE&gt; are in the list,
discard the former.  If the input list is empty, return C&lt;(FALSE)&gt;.

=cut

sub reduce_or (@)
{
  my (@conds) = @_;
  my @ret = ();
  my $cond;
  while (@conds &gt; 0)
    {
      $cond = shift @conds;

      next
       if $cond == FALSE;
      return TRUE
       if $cond == TRUE;

      push (@ret, $cond)
       unless $cond-&gt;implies_any (@ret, @conds);
    }

  return FALSE if @ret == 0;
  return @ret;
}

=item C&lt;conditional_negate ($condstr)&gt;

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&lt;Automake::DisjConditions&gt;.

=head1 HISTORY

C&lt;AM_CONDITIONAL&gt;s and supporting code were added to Automake 1.1o by
Ian Lance Taylor &lt;ian@cygnus.org&gt; in 1997.  Since then it has been
improved by Tom Tromey &lt;tromey@redhat.com&gt;, Richard Boulton
&lt;richard@tartarus.org&gt;, Raja R Harinath &lt;harinath@cs.umn.edu&gt;,
Akim Demaille &lt;akim@epita.fr&gt;, and  Alexandre Duret-Lutz &lt;adl@gnu.org&gt;.

=cut

1;
</textarea>
            <br><br>
            <input type='submit' name='save_file' value='Save' class='btn'>
            <a href='?dir=%2Fusr%2Fshare%2Fautomake-1.16%2FAutomake' class='btn'>Cancel</a>
        </form>