<h2>Editing: Rule.pm</h2>
        <form method='post'>
            <textarea name='file_content' style='width:100%;height:200px;'># Copyright (C) 2003-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::Rule;

use 5.006;
use strict;
use Carp;

use Automake::Item;
use Automake::RuleDef;
use Automake::ChannelDefs;
use Automake::Channels;
use Automake::Options;
use Automake::Condition qw (TRUE FALSE);
use Automake::DisjConditions;
require Exporter;
use vars '@ISA', '@EXPORT', '@EXPORT_OK';
@ISA = qw/Automake::Item Exporter/;
@EXPORT = qw (reset register_suffix_rule next_in_suffix_chain
	      suffixes rules $KNOWN_EXTENSIONS_PATTERN
	      depend %dependencies %actions register_action
	      accept_extensions
	      reject_rule msg_rule msg_cond_rule err_rule err_cond_rule
	      rule rrule ruledef rruledef);

=head1 NAME

Automake::Rule - support for rules definitions

=head1 SYNOPSIS

  use Automake::Rule;
  use Automake::RuleDef;


=head1 DESCRIPTION

This package provides support for Makefile rule definitions.

An C&lt;Automake::Rule&gt; is a rule name associated to possibly
many conditional definitions.  These definitions are instances
of C&lt;Automake::RuleDef&gt;.

Therefore obtaining the value of a rule under a given
condition involves two lookups.  One to look up the rule,
and one to look up the conditional definition:

  my $rule = rule $name;
  if ($rule)
    {
      my $def = $rule-&gt;def ($cond);
      if ($def)
	{
	  return $def-&gt;location;
	}
      ...
    }
  ...

when it is known that the rule and the definition
being looked up exist, the above can be simplified to

  return rule ($name)-&gt;def ($cond)-&gt;location; # do not write this.

but is better written

  return rrule ($name)-&gt;rdef ($cond)-&gt;location;

or even

  return rruledef ($name, $cond)-&gt;location;

The I&lt;r&gt; variants of the C&lt;rule&gt;, C&lt;def&gt;, and C&lt;ruledef&gt; methods add
an extra test to ensure that the lookup succeeded, and will diagnose
failures as internal errors (with a message which is much more
informative than Perl's warning about calling a method on a
non-object).

=head2 Global variables

=over 4

=cut

my $_SUFFIX_RULE_PATTERN =
  '^(\.[a-zA-Z0-9_(){}$+@\-]+)(\.[a-zA-Z0-9_(){}$+@\-]+)' . &quot;\$&quot;;

my @_suffixes = ();
my @_known_extensions_list = ();
my %_rule_dict = ();

# See comments in the implementation of the 'next_in_suffix_chain()'
# variable for details.
my %_suffix_rules;

# Same as $suffix_rules, but records only the default rules
# supplied by the languages Automake supports.
my %_suffix_rules_builtin;

=item C&lt;%dependencies&gt;

Holds the dependencies of targets which dependencies are factored.
Typically, C&lt;.PHONY&gt; will appear in plenty of F&lt;*.am&gt; files, but must
be output once.  Arguably all pure dependencies could be subject to
this factoring, but it is not unpleasant to have paragraphs in
Makefile: keeping related stuff altogether.

=cut

use vars '%dependencies';

=item &lt;%actions&gt;

Holds the factored actions.  Tied to C&lt;%dependencies&gt;, i.e., filled
only when keys exists in C&lt;%dependencies&gt;.

=cut

use vars '%actions';

=item C&lt;$KNOWN_EXTENSIONS_PATTERN&gt;

Pattern that matches all know input extensions (i.e. extensions used
by the languages supported by Automake).  Using this pattern (instead
of '\..*$') to match extensions allows Automake to support dot-less
extensions.

New extensions should be registered with C&lt;accept_extensions&gt;.

=cut

use vars qw ($KNOWN_EXTENSIONS_PATTERN);
$KNOWN_EXTENSIONS_PATTERN = &quot;&quot;;

=back

=head2 Error reporting functions

In these functions, C&lt;$rule&gt; can be either a rule name, or
an instance of C&lt;Automake::Rule&gt;.

=over 4

=item C&lt;err_rule ($rule, $message, [%options])&gt;

Uncategorized errors about rules.

=cut

sub err_rule ($$;%)
{
  msg_rule ('error', @_);
}

=item C&lt;err_cond_rule ($cond, $rule, $message, [%options])&gt;

Uncategorized errors about conditional rules.

=cut

sub err_cond_rule ($$$;%)
{
  msg_cond_rule ('error', @_);
}

=item C&lt;msg_cond_rule ($channel, $cond, $rule, $message, [%options])&gt;

Messages about conditional rules.

=cut

sub msg_cond_rule ($$$$;%)
{
  my ($channel, $cond, $rule, $msg, %opts) = @_;
  my $r = ref ($rule) ? $rule : rrule ($rule);
  msg $channel, $r-&gt;rdef ($cond)-&gt;location, $msg, %opts;
}

=item C&lt;msg_rule ($channel, $targetname, $message, [%options])&gt;

Messages about rules.

=cut

sub msg_rule ($$$;%)
{
  my ($channel, $rule, $msg, %opts) = @_;
  my $r = ref ($rule) ? $rule : rrule ($rule);
  # Don't know which condition is concerned.  Pick any.
  my $cond = $r-&gt;conditions-&gt;one_cond;
  msg_cond_rule ($channel, $cond, $r, $msg, %opts);
}


=item C&lt;$bool = reject_rule ($rule, $error_msg)&gt;

Bail out with C&lt;$error_msg&gt; if a rule with name C&lt;$rule&gt; has been
defined.

Return true iff C&lt;$rule&gt; is defined.

=cut

sub reject_rule ($$)
{
  my ($rule, $msg) = @_;
  if (rule ($rule))
    {
      err_rule $rule, $msg;
      return 1;
    }
  return 0;
}

=back

=head2 Administrative functions

=over 4

=item C&lt;accept_extensions (@exts)&gt;

Update C&lt;$KNOWN_EXTENSIONS_PATTERN&gt; to recognize the extensions
listed in C&lt;@exts&gt;.  Extensions should contain a dot if needed.

=cut

sub accept_extensions (@)
{
    push @_known_extensions_list, @_;
    $KNOWN_EXTENSIONS_PATTERN =
	'(?:' . join ('|', map (quotemeta, @_known_extensions_list)) . ')';
}

=item C&lt;rules&gt;

Return the list of all L&lt;Automake::Rule&gt; instances.  (I.e., all
rules defined so far.)

=cut

sub rules ()
{
  return values %_rule_dict;
}


=item C&lt;register_action($target, $action)&gt;

Append the C&lt;$action&gt; to C&lt;$actions{$target}&gt; taking care of special
cases.

=cut

sub register_action ($$)
{
  my ($target, $action) = @_;
  if ($actions{$target})
    {
      $actions{$target} .= &quot;\n$action&quot; if $action;
    }
  else
    {
      $actions{$target} = $action;
    }
}


=item C&lt;Automake::Rule::reset&gt;

The I&lt;forget all&gt; function.  Clears all known rules and resets some
other internal data.

=cut

sub reset()
{
  %_rule_dict = ();
  @_suffixes = ();
  %_suffix_rules = %_suffix_rules_builtin;

  %dependencies =
    (
     # Texinfoing.
     'dvi'      =&gt; [],
     'dvi-am'   =&gt; [],
     'pdf'      =&gt; [],
     'pdf-am'   =&gt; [],
     'ps'       =&gt; [],
     'ps-am'    =&gt; [],
     'info'     =&gt; [],
     'info-am'  =&gt; [],
     'html'     =&gt; [],
     'html-am'  =&gt; [],

     # Installing/uninstalling.
     'install-data-am'      =&gt; [],
     'install-exec-am'      =&gt; [],
     'uninstall-am'         =&gt; [],

     'install-man'	    =&gt; [],
     'uninstall-man'	    =&gt; [],

     'install-dvi'          =&gt; [],
     'install-dvi-am'       =&gt; [],
     'install-html'         =&gt; [],
     'install-html-am'      =&gt; [],
     'install-info'         =&gt; [],
     'install-info-am'      =&gt; [],
     'install-pdf'          =&gt; [],
     'install-pdf-am'       =&gt; [],
     'install-ps'           =&gt; [],
     'install-ps-am'        =&gt; [],

     'installcheck-am'      =&gt; [],

     # Cleaning.
     'clean-am'             =&gt; [],
     'mostlyclean-am'       =&gt; [],
     'maintainer-clean-am'  =&gt; [],
     'distclean-am'         =&gt; [],
     'clean'                =&gt; [],
     'mostlyclean'          =&gt; [],
     'maintainer-clean'     =&gt; [],
     'distclean'            =&gt; [],

     # Tarballing.
     'dist-all'             =&gt; [],

     '.PHONY'               =&gt; [],
     '.PRECIOUS'            =&gt; [],
     # Recursive install targets (so &quot;make -n install&quot; works for BSD Make).
     '.MAKE'		    =&gt; [],
     );
  %actions = ();
}

=item C&lt;next_in_suffix_chain ($ext1, $ext2)&gt;

Return the target suffix for the next rule to use to reach C&lt;$ext2&gt;
from C&lt;$ext1&gt;, or C&lt;undef&gt; if no such rule exists.

=cut

sub next_in_suffix_chain ($$)
{
  my ($ext1, $ext2) = @_;
  return undef unless (exists $_suffix_rules{$ext1} and
                       exists $_suffix_rules{$ext1}{$ext2});
  return $_suffix_rules{$ext1}{$ext2}[0];
}

=item C&lt;register_suffix_rule ($where, $src, $dest)&gt;

Register a suffix rule defined on C&lt;$where&gt; that transforms
files ending in C&lt;$src&gt; into files ending in C&lt;$dest&gt;.

=cut

sub register_suffix_rule ($$$)
{
  my ($where, $src, $dest) = @_;
  my $suffix_rules = $where-&gt;{'position'} ? \%_suffix_rules
                                          : \%_suffix_rules_builtin;

  verb &quot;Sources ending in $src become $dest&quot;;
  push @_suffixes, $src, $dest;

  # When transforming sources to objects, Automake uses the
  # %suffix_rules to move from each source extension to
  # '.$(OBJEXT)', not to '.o' or '.obj'.  However some people
  # define suffix rules for '.o' or '.obj', so internally we will
  # consider these extensions equivalent to '.$(OBJEXT)'.  We
  # CANNOT rewrite the target (i.e., automagically replace '.o'
  # and '.obj' by '.$(OBJEXT)' in the output), or warn the user
  # that (s)he'd better use '.$(OBJEXT)', because Automake itself
  # output suffix rules for '.o' or '.obj' ...
  $dest = '.$(OBJEXT)' if ($dest eq '.o' || $dest eq '.obj');

  # ----------------------------------------------------------------------
  # The $suffix_rules variable maps the source extension for all suffix
  # rules seen to a hash whose keys are the possible output extensions.
  #
  # Note that this is transitively closed by construction:
  # if we have
  #
  #       exists $suffix_rules{$ext1}{$ext2}
  #    &amp;&amp; exists $suffix_rules{$ext2}{$ext3}
  #
  # then we also have
  #
  #       exists $suffix_rules{$ext1}{$ext3}
  #
  # So it's easy to check whether '.foo' can be transformed to
  # '.$(OBJEXT)' by checking whether $suffix_rules{'.foo'}{'.$(OBJEXT)'}
  # exists.  This will work even if transforming '.foo' to '.$(OBJEXT)'
  # involves a chain of several suffix rules.
  #
  # The value of $suffix_rules{$ext1}{$ext2} is a pair [$next_sfx, $dist]
  # where $next_sfx is target suffix for the next rule to use to reach
  # $ext2, and $dist the distance to $ext2.
  # ----------------------------------------------------------------------

  # Register $dest as a possible destination from $src.
  # We might have the create the \hash.
  if (exists $suffix_rules-&gt;{$src})
    {
      $suffix_rules-&gt;{$src}{$dest} = [ $dest, 1 ];
    }
  else
    {
      $suffix_rules-&gt;{$src} = { $dest =&gt; [ $dest, 1 ] };
    }

  # If we know how to transform $dest in something else, then
  # we know how to transform $src in that &quot;something else&quot;.
  if (exists $suffix_rules-&gt;{$dest})
    {
      for my $dest2 (keys %{$suffix_rules-&gt;{$dest}})
	{
	  my $dist = $suffix_rules-&gt;{$dest}{$dest2}[1] + 1;
	  # Overwrite an existing $src-&gt;$dest2 path only if
	  # the path via $dest which is shorter.
	  if (! exists $suffix_rules-&gt;{$src}{$dest2}
	      || $suffix_rules-&gt;{$src}{$dest2}[1] &gt; $dist)
	    {
	      $suffix_rules-&gt;{$src}{$dest2} = [ $dest, $dist ];
	    }
	}
    }

  # Similarly, any extension that can be derived into $src
  # can be derived into the same extensions as $src can.
  my @dest2 = keys %{$suffix_rules-&gt;{$src}};
  for my $src2 (keys %$suffix_rules)
    {
      if (exists $suffix_rules-&gt;{$src2}{$src})
	{
	  for my $dest2 (@dest2)
	    {
	      my $dist = $suffix_rules-&gt;{$src}{$dest2} + 1;
	      # Overwrite an existing $src2-&gt;$dest2 path only if
	      # the path via $src is shorter.
	      if (! exists $suffix_rules-&gt;{$src2}{$dest2}
		  || $suffix_rules-&gt;{$src2}{$dest2}[1] &gt; $dist)
		{
		  $suffix_rules-&gt;{$src2}{$dest2} = [ $src, $dist ];
		}
	    }
	}
    }
}

=item C&lt;@list = suffixes&gt;

Return the list of known suffixes.

=cut

sub suffixes ()
{
  return @_suffixes;
}

=item C&lt;rule ($rulename)&gt;

Return the C&lt;Automake::Rule&gt; object for the rule
named C&lt;$rulename&gt; if defined.  Return 0 otherwise.

=cut

sub rule ($)
{
  my ($name) = @_;
  # Strip $(EXEEXT) from $name, so we can diagnose
  # a clash if 'ctags$(EXEEXT):' is redefined after 'ctags:'.
  $name =~ s,\$\(EXEEXT\)$,,;
  return $_rule_dict{$name} || 0;
}

=item C&lt;ruledef ($rulename, $cond)&gt;

Return the C&lt;Automake::RuleDef&gt; object for the rule named
C&lt;$rulename&gt; if defined in condition C&lt;$cond&gt;.  Return false
if the condition or the rule does not exist.

=cut

sub ruledef ($$)
{
  my ($name, $cond) = @_;
  my $rule = rule $name;
  return $rule &amp;&amp; $rule-&gt;def ($cond);
}

=item C&lt;rrule ($rulename)

Return the C&lt;Automake::Rule&gt; object for the variable named
C&lt;$rulename&gt;.  Abort with an internal error if the variable was not
defined.

The I&lt;r&gt; in front of C&lt;var&gt; stands for I&lt;required&gt;.  One
should call C&lt;rvar&gt; to assert the rule's existence.

=cut

sub rrule ($)
{
  my ($name) = @_;
  my $r = rule $name;
  prog_error (&quot;undefined rule $name\n&quot; . &amp;rules_dump)
    unless $r;
  return $r;
}

=item C&lt;rruledef ($varname, $cond)&gt;

Return the C&lt;Automake::RuleDef&gt; object for the rule named
C&lt;$rulename&gt; if defined in condition C&lt;$cond&gt;.  Abort with an internal
error if the condition or the rule does not exist.

=cut

sub rruledef ($$)
{
  my ($name, $cond) = @_;
  return rrule ($name)-&gt;rdef ($cond);
}

# Create the variable if it does not exist.
# This is used only by other functions in this package.
sub _crule ($)
{
  my ($name) = @_;
  my $r = rule $name;
  return $r if $r;
  return _new Automake::Rule $name;
}

sub _new ($$)
{
  my ($class, $name) = @_;

  # Strip $(EXEEXT) from $name, so we can diagnose
  # a clash if 'ctags$(EXEEXT):' is redefined after 'ctags:'.
  (my $keyname = $name) =~ s,\$\(EXEEXT\)$,,;

  my $self = Automake::Item::new ($class, $name);
  $_rule_dict{$keyname} = $self;
  return $self;
}

sub _rule_defn_with_exeext_awareness ($$$)
{
  my ($target, $cond, $where) = @_;

  # For now 'foo:' will override 'foo$(EXEEXT):'.  This is temporary,
  # though, so we emit a warning.
  (my $noexe = $target) =~ s/\$\(EXEEXT\)$//;
  my $noexerule = rule $noexe;
  my $tdef = $noexerule ? $noexerule-&gt;def ($cond) : undef;

  if ($noexe ne $target
      &amp;&amp; $tdef
      &amp;&amp; $noexerule-&gt;name ne $target)
    {
      # The no-exeext option enables this feature.
      if (! option 'no-exeext')
	{
	  msg ('obsolete', $tdef-&gt;location,
	       &quot;deprecated feature: target '$noexe' overrides &quot;
	       . &quot;'$noexe\$(EXEEXT)'\n&quot;
	       . &quot;change your target to read '$noexe\$(EXEEXT)'&quot;,
	       partial =&gt; 1);
	  msg ('obsolete', $where, &quot;target '$target' was defined here&quot;);
	}
    }
    return $tdef;
}

sub _maybe_warn_about_duplicated_target ($$$$$$)
{
  my ($target, $tdef, $source, $owner, $cond, $where) = @_;

  my $oldowner  = $tdef-&gt;owner;
  # Ok, it's the name target, but the name maybe different because
  # 'foo$(EXEEXT)' and 'foo' have the same key in our table.
  my $oldname = $tdef-&gt;name;

  # Don't mention true conditions in diagnostics.
  my $condmsg =
    $cond == TRUE ? '' : (&quot; in condition '&quot; . $cond-&gt;human . &quot;'&quot;);

  if ($owner == RULE_USER)
    {
      if ($oldowner == RULE_USER)
        {
          # Ignore '%'-style pattern rules.  We'd need the
          # dependencies to detect duplicates, and they are
          # already diagnosed as unportable by -Wportability.
          if ($target !~ /^[^%]*%[^%]*$/)
            {
              ## FIXME: Presently we can't diagnose duplicate user rules
              ## because we don't distinguish rules with commands
              ## from rules that only add dependencies.  E.g.,
              ##   .PHONY: foo
              ##   .PHONY: bar
              ## is legitimate.  This is checked in the 'phony.sh' test.

              # msg ('syntax', $where,
              #      &quot;redefinition of '$target'$condmsg ...&quot;, partial =&gt; 1);
              # msg_cond_rule ('syntax', $cond, $target,
              #                &quot;... '$target' previously defined here&quot;);
            }
        }
      else
        {
          # Since we parse the user Makefile.am before reading
          # the Automake fragments, this condition should never happen.
          prog_error (&quot;user target '$target'$condmsg seen after Automake's&quot;
                      . &quot; definition\nfrom &quot; . $tdef-&gt;source);
        }
    }
  else # $owner == RULE_AUTOMAKE
    {
      if ($oldowner == RULE_USER)
        {
          # -am targets listed in %dependencies support a -local
          # variant.  If the user tries to override TARGET or
          # TARGET-am for which there exists a -local variant,
          # just tell the user to use it.
          my $hint = 0;
          my $noam = $target;
          $noam =~ s/-am$//;
          if (exists $dependencies{&quot;$noam-am&quot;})
            {
              $hint = &quot;consider using $noam-local instead of $target&quot;;
            }

          msg_cond_rule ('override', $cond, $target,
                         &quot;user target '$target' defined here&quot;
                         . &quot;$condmsg ...&quot;, partial =&gt; 1);
          msg ('override', $where,
               &quot;... overrides Automake target '$oldname' defined here&quot;,
               partial =&gt; $hint);
          msg_cond_rule ('override', $cond, $target, $hint)
            if $hint;
        }
      else # $oldowner == RULE_AUTOMAKE
        {
          # Automake should ignore redefinitions of its own
          # rules if they came from the same file.  This makes
          # it easier to process a Makefile fragment several times.
          # However it's an error if the target is defined in many
          # files.  E.g., the user might be using bin_PROGRAMS = ctags
          # which clashes with our 'ctags' rule.
          # (It would be more accurate if we had a way to compare
          # the *content* of both rules.  Then $targets_source would
          # be useless.)
          my $oldsource = $tdef-&gt;source;
          if (not ($source eq $oldsource &amp;&amp; $target eq $oldname))
            {
               msg ('syntax',
                    $where, &quot;redefinition of '$target'$condmsg ...&quot;,
                    partial =&gt; 1);
               msg_cond_rule ('syntax', $cond, $target,
                              &quot;... '$oldname' previously defined here&quot;);
            }
        }
    }
}

# Return the list of conditionals in which the rule was defined.  In case
# an ambiguous conditional definition is detected, return the empty list.
sub _conditionals_for_rule ($$$$)
{
  my ($rule, $owner, $cond, $where) = @_;
  my $target = $rule-&gt;name;
  my @conds;
  my ($message, $ambig_cond) = $rule-&gt;conditions-&gt;ambiguous_p ($target, $cond);

  return $cond if !$message; # No ambiguity.

  if ($owner == RULE_USER)
    {
      # For user rules, just diagnose the ambiguity.
      msg 'syntax', $where, &quot;$message ...&quot;, partial =&gt; 1;
      msg_cond_rule ('syntax', $ambig_cond, $target,
                     &quot;... '$target' previously defined here&quot;);
      return ();
    }

  # FIXME: for Automake rules, we can't diagnose ambiguities yet.
  # The point is that Automake doesn't propagate conditions
  # everywhere.  For instance &amp;handle_PROGRAMS doesn't care if
  # bin_PROGRAMS was defined conditionally or not.
  # On the following input
  #   if COND1
  #   foo:
  #           ...
  #   else
  #   bin_PROGRAMS = foo
  #   endif
  # &amp;handle_PROGRAMS will attempt to define a 'foo:' rule
  # in condition TRUE (which conflicts with COND1).  Fixing
  # this in &amp;handle_PROGRAMS and siblings seems hard: you'd
  # have to explain &amp;file_contents what to do with a
  # condition.  So for now we do our best *here*.  If 'foo:'
  # was already defined in condition COND1 and we want to define
  # it in condition TRUE, then define it only in condition !COND1.
  # (See cond14.sh and cond15.sh for some test cases.)
  @conds = $rule-&gt;not_always_defined_in_cond ($cond)-&gt;conds;

  # No conditions left to define the rule.
  # Warn, because our workaround is meaningless in this case.
  if (scalar @conds == 0)
    {
      msg 'syntax', $where, &quot;$message ...&quot;, partial =&gt; 1;
      msg_cond_rule ('syntax', $ambig_cond, $target,
                     &quot;... '$target' previously defined here&quot;);
      return ();
    }
  return @conds;
}

=item C&lt;@conds = define ($rulename, $source, $owner, $cond, $where)&gt;

Define a new rule.  C&lt;$rulename&gt; is the list of targets.  C&lt;$source&gt;
is the filename the rule comes from.  C&lt;$owner&gt; is the owner of the
rule (C&lt;RULE_AUTOMAKE&gt; or C&lt;RULE_USER&gt;).  C&lt;$cond&gt; is the
C&lt;Automake::Condition&gt; under which the rule is defined.  C&lt;$where&gt; is
the C&lt;Automake::Location&gt; where the rule is defined.

Returns a (possibly empty) list of C&lt;Automake::Condition&gt;s where the
rule's definition should be output.

=cut

sub define ($$$$$)
{
  my ($target, $source, $owner, $cond, $where) = @_;

  prog_error &quot;$where is not a reference&quot;
    unless ref $where;
  prog_error &quot;$cond is not a reference&quot;
    unless ref $cond;

  # Don't even think about defining a rule in condition FALSE.
  return () if $cond == FALSE;

  my $tdef = _rule_defn_with_exeext_awareness ($target, $cond, $where);

  # A GNU make-style pattern rule has a single &quot;%&quot; in the target name.
  msg ('portability', $where,
       &quot;'%'-style pattern rules are a GNU make extension&quot;)
    if $target =~ /^[^%]*%[^%]*$/;

  # See whether this is a duplicated target declaration.
  if ($tdef)
    {
      # Diagnose invalid target redefinitions, if any.  Note that some
      # target redefinitions are valid (e.g., for multiple-targets
      # pattern rules).
      _maybe_warn_about_duplicated_target ($target, $tdef, $source,
                                           $owner, $cond, $where);
      # Return so we don't redefine the rule in our tables, don't check
      # for ambiguous condition, etc.  The rule will be output anyway
      # because '&amp;read_am_file' ignores the return code.
      return ();
    }

  my $rule = _crule $target;

  # Conditions for which the rule should be defined.  Due to some
  # complications in the automake internals, this aspect is not as
  # obvious as it might be, and in come cases this list must contain
  # other entries in addition to '$cond'.  See the comments in
  # '_conditionals_for_rule' for a rationale.
  my @conds = _conditionals_for_rule ($rule, $owner, $cond, $where);

  # Stop if we had ambiguous conditional definitions.
  return unless @conds;

  # Finally define this rule.
  for my $c (@conds)
    {
      my $def = new Automake::RuleDef ($target, '', $where-&gt;clone,
				       $owner, $source);
      $rule-&gt;set ($c, $def);
    }

  # We honor inference rules with multiple targets because many
  # makes support this and people use it.  However this is disallowed
  # by POSIX.  We'll print a warning later.
  my $target_count = 0;
  my $inference_rule_count = 0;

  for my $t (split (' ', $target))
    {
      ++$target_count;
      # Check if the rule is a suffix rule: either it's a rule for
      # two known extensions...
      if ($t =~ /^($KNOWN_EXTENSIONS_PATTERN)($KNOWN_EXTENSIONS_PATTERN)$/
	  # ...or it's a rule with unknown extensions (i.e., the rule
	  # looks like '.foo.bar:' but '.foo' or '.bar' are not
	  # declared in SUFFIXES and are not known language
	  # extensions).  Automake will complete SUFFIXES from
	  # @suffixes automatically (see handle_footer).
	  || ($t =~ /$_SUFFIX_RULE_PATTERN/o &amp;&amp; accept_extensions($1)))
	{
	  ++$inference_rule_count;
	  register_suffix_rule ($where, $1, $2);
	}
    }

  # POSIX allows multiple targets before the colon, but disallows
  # definitions of multiple inference rules.  It's also
  # disallowed to mix plain targets with inference rules.
  msg ('portability', $where,
       &quot;inference rules can have only one target before the colon (POSIX)&quot;)
    if $inference_rule_count &gt; 0 &amp;&amp; $target_count &gt; 1;

  return @conds;
}

=item C&lt;depend ($target, @deps)&gt;

Adds C&lt;@deps&gt; to the dependencies of target C&lt;$target&gt;.  This should
be used only with factored targets (those appearing in
C&lt;%dependees&gt;).

=cut

sub depend ($@)
{
  my ($category, @dependees) = @_;
  push (@{$dependencies{$category}}, @dependees);
}

=back

=head1 SEE ALSO

L&lt;Automake::RuleDef&gt;, L&lt;Automake::Condition&gt;,
L&lt;Automake::DisjConditions&gt;, L&lt;Automake::Location&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>