File Coverage

File:/tmp/automake/lib/Automake/Item.pm
Coverage:0.0%

linestmtbrancondsubpodtimecode
1# Copyright (C) 2003, 2004 Free Software Foundation, Inc.
2
3# This program is free software; you can redistribute it and/or modify
4# it under the terms of the GNU General Public License as published by
5# the Free Software Foundation; either version 2, or (at your option)
6# any later version.
7
8# This program is distributed in the hope that it will be useful,
9# but WITHOUT ANY WARRANTY; without even the implied warranty of
10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11# GNU General Public License for more details.
12
13# You should have received a copy of the GNU General Public License
14# along with this program. If not, see <http://www.gnu.org/licenses/>.
15
16package Automake::Item;
17use strict;
18use Carp;
19
20use Automake::ChannelDefs;
21use Automake::DisjConditions;
22
23 - 37
=head1 NAME

Automake::Item - base class for Automake::Variable and Automake::Rule

=head1 DESCRIPTION

=head2 Methods

=over 4

=item C<new Automake::Item $name>

Create and return an empty Item called C<$name>.

=cut
38
39sub new ($$)
40{
41  my ($class, $name) = @_;
42  my $self = {
43    name => $name,
44    defs => {},
45    conds => {},
46  };
47  bless $self, $class;
48  return $self;
49}
50
51 - 55
=item C<$item-E<gt>name>

Return the name of C<$item>.

=cut
56
57sub name ($)
58{
59  my ($self) = @_;
60  return $self->{'name'};
61}
62
63 - 68
=item C<$item-E<gt>def ($cond)>

Return the definition for this item in condition C<$cond>, if it
exists.  Return 0 otherwise.

=cut
69
70sub def ($$)
71{
72  # This method is called very often, so keep it small and fast. We
73  # don't mind the extra undefined items introduced by lookup failure;
74  # avoiding this with `exists' means doing two hash lookup on
75  # success, and proved worse on benchmark.
76  my $def = $_[0]->{'defs'}{$_[1]};
77  return defined $def && $def;
78}
79
80 - 88
=item C<$item-E<gt>rdef ($cond)>

Return the definition for this item in condition C<$cond>.  Abort with
an internal error if the item was not defined under this condition.

The I<r> in front of C<def> stands for I<required>.  One
should call C<rdef> to assert the conditional definition's existence.

=cut
89
90sub rdef ($$)
91{
92  my ($self, $cond) = @_;
93  my $d = $self->def ($cond);
94  prog_error ("undefined condition `" . $cond->human . "' for `"
95              . $self->name . "'\n" . $self->dump)
96    unless $d;
97  return $d;
98}
99
100 - 104
=item C<$item-E<gt>set ($cond, $def)>

Add a new definition to an existing item.

=cut
105
106sub set ($$$)
107{
108  my ($self, $cond, $def) = @_;
109  $self->{'defs'}{$cond} = $def;
110  $self->{'conds'}{$cond} = $cond;
111}
112
113 - 121
=item C<$var-E<gt>conditions>

Return an L<Automake::DisjConditions> describing the conditions that
that an item is defined in.

These are all the conditions for which is would be safe to call
C<rdef>.

=cut
122
123sub conditions ($)
124{
125  my ($self) = @_;
126  prog_error ("self is not a reference")
127    unless ref $self;
128  return new Automake::DisjConditions (values %{$self->{'conds'}});
129}
130
131 - 173
=item C<@missing_conds = $var-E<gt>not_always_defined_in_cond ($cond)>

Check whether C<$var> is always defined for condition C<$cond>.
Return a list of conditions where the definition is missing.

For instance, given

  if COND1
    if COND2
      A = foo
      D = d1
    else
      A = bar
      D = d2
    endif
  else
    D = d3
  endif
  if COND3
    A = baz
    B = mumble
  endif
  C = mumble

we should have (we display result as conditional strings in this
illustration, but we really return DisjConditions objects):

  var ('A')->not_always_defined_in_cond ('COND1_TRUE COND2_TRUE')
    => ()
  var ('A')->not_always_defined_in_cond ('COND1_TRUE')
    => ()
  var ('A')->not_always_defined_in_cond ('TRUE')
    => ("COND1_FALSE COND3_FALSE")
  var ('B')->not_always_defined_in_cond ('COND1_TRUE')
    => ("COND1_TRUE COND3_FALSE")
  var ('C')->not_always_defined_in_cond ('COND1_TRUE')
    => ()
  var ('D')->not_always_defined_in_cond ('TRUE')
    => ()
  var ('Z')->not_always_defined_in_cond ('TRUE')
    => ("TRUE")

=cut
174
175sub not_always_defined_in_cond ($$)
176{
177  my ($self, $cond) = @_;
178
179  # Compute the subconditions where $var isn't defined.
180  return
181    $self->conditions
182      ->sub_conditions ($cond)
183        ->invert
184          ->multiply ($cond);
185}
186
187
1881;
189
190### Setup "GNU" style for perl-mode and cperl-mode.
191## Local Variables:
192## perl-indent-level: 2
193## perl-continued-statement-offset: 2
194## perl-continued-brace-offset: 0
195## perl-brace-offset: 0
196## perl-brace-imaginary-offset: 0
197## perl-label-offset: -2
198## cperl-indent-level: 2
199## cperl-brace-offset: 0
200## cperl-continued-brace-offset: 0
201## cperl-label-offset: -2
202## cperl-extra-newline-before-brace: t
203## cperl-merge-trailing-else: nil
204## cperl-continued-statement-offset: 2
205## End: