[Automake-commit] [SCM] GNU Automake branch, ng/master, updated. v1.11b-123-g35341b2

[Stefano Lattarini]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Automake".

http://git.sv.gnu.org/gitweb/?p=automake.git;a=commitdiff;h=35341b28e47f9725c9d79b7a37bec3139773045f

The branch, ng/master has been updated
       via  35341b28e47f9725c9d79b7a37bec3139773045f (commit)
       via  64b18e07df13c9cc96232cc77e03f7d31a0b5046 (commit)
       via  f1895f943d9f58e05fbb3f6ba1d3c5e53733a6a9 (commit)
       via  99217a1b31b9a0c78c9f0182bd024ddf0be03030 (commit)
       via  89ba2a738c9eb543d499cc6dabe3341cbb21857a (commit)
      from  e1e9b1be8b9cf185e5881c4813d597c2ffb5884b (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
-----------------------------------------------------------------------

Summary of changes:
 automake.in             |   41 ++++--
 doc/automake.texi       |   34 ++---
 lib/Automake/Rule.pm    |  362 +++++++++++++++++++++++++----------------------
 t/ax/tap-summary-aux.sh |    2 +-
 4 files changed, 230 insertions(+), 209 deletions(-)

diff --git a/automake.in b/automake.in
index e22aac9..86da5a0 100644
--- a/automake.in
+++ b/automake.in
@@ -6831,13 +6831,13 @@ sub transform ($$)
     }
 }
 
-
-# @PARAGRAPHS
-# &make_paragraphs ($MAKEFILE, [%TRANSFORM])
-# ------------------------------------------
-# Load a $MAKEFILE, apply the %TRANSFORM, and return it as a list of
-# paragraphs.
-sub make_paragraphs ($%)
+# $TEXT
+# preprocess_file ($MAKEFILE, [%TRANSFORM])
+# -----------------------------------------
+# Load a $MAKEFILE, apply the %TRANSFORM, and return the result.
+# No extra parsing of post-processing is done (i.e., recognition of
+# rules declaration or of make variables definitions).
+sub preprocess_file ($%)
 {
   my ($file, %transform) = @_;
 
@@ -6870,13 +6870,9 @@ sub make_paragraphs ($%)
 
                 'LIBTOOL'      => !! var ('LIBTOOL'),
                 'NONLIBTOOL'   => 1,
-                'FIRST'        => ! $transformed_files{$file},
                %transform);
 
-  $transformed_files{$file} = 1;
-  $_ = $am_file_cache{$file};
-
-  if (! defined $_)
+  if (! defined ($_ = $am_file_cache{$file}))
     {
       verb "reading $file";
       # Swallow the whole file.
@@ -6886,11 +6882,10 @@ sub make_paragraphs ($%)
       $_ = $fc_file->getline;
       $/ = $saved_dollar_slash;
       $fc_file->close;
-
       # Remove ##-comments.
       # Besides we don't need more than two consecutive new-lines.
       s/(?:$IGNORE_PATTERN|(?<=\n\n)\n+)//gom;
-
+      # Remember the contents of the just-read file.
       $am_file_cache{$file} = $_;
     }
 
@@ -6904,8 +6899,22 @@ sub make_paragraphs ($%)
   # ####### and do not remove the latter.)
   s/^[ \t]*(?:##%)+.*\n//gm;
 
-  # Split at unescaped new lines.
-  my @lines = split (/(?<!\\)\n/, $_);
+  return $_;
+}
+
+
+# @PARAGRAPHS
+# &make_paragraphs ($MAKEFILE, [%TRANSFORM])
+# ------------------------------------------
+# Load a $MAKEFILE, apply the %TRANSFORM, and return it as a list of
+# paragraphs.
+sub make_paragraphs ($%)
+{
+  my ($file, %transform) = @_;
+  $transform{FIRST} = !$transformed_files{$file};
+  $transformed_files{$file} = 1;
+
+  my @lines = split /(?<!\\)\n/, preprocess_file ($file, %transform);
   my @res;
 
   while (defined ($_ = shift @lines))
diff --git a/doc/automake.texi b/doc/automake.texi
index 263b907..2661af5 100644
--- a/doc/automake.texi
+++ b/doc/automake.texi
@@ -430,11 +430,7 @@ should generally be one @file{Makefile.am} per directory 
of a project.
 Automake does constrain a project in certain ways; for instance, it
 assumes that the project uses Autoconf (@pxref{Top, , Introduction,
 autoconf, The Autoconf Manual}), and enforces certain restrictions on
-the @file{configure.ac} address@hidden Autoconf versions used
address@hidden  Autoconf 2.50 and greater promotes
address@hidden over @file{configure.in}.  The rest of this
-documentation will refer to @file{configure.ac}, but Automake also
-supports @file{configure.in} for backward compatibility.}.
+the @file{configure.ac} contents.
 
 @cindex Automake requirements
 @cindex Requirements, Automake
@@ -3038,8 +3034,7 @@ This is required if any Objective C source is included.  
@xref{Particular
 Programs, , Particular Program Checks, autoconf, The Autoconf Manual}.
 
 @item AC_PROG_F77
-This is required if any Fortran 77 source is included.  This macro is
-distributed with Autoconf version 2.13 and later.  @xref{Particular
+This is required if any Fortran 77 source is included.  @xref{Particular
 Programs, , Particular Program Checks, autoconf, The Autoconf Manual}.
 
 @item AC_F77_LIBRARY_LDFLAGS
@@ -3575,7 +3570,7 @@ For instance,
 
 @example
 # bad style
-AC_PREREQ(2.57)
+AC_PREREQ(2.68)
 AC_DEFUN(AX_FOOBAR,
 [AC_REQUIRE([AX_SOMETHING])dnl
 AX_FOO
@@ -3588,7 +3583,7 @@ should be rewritten as
 
 @example
 AC_DEFUN([AX_FOOBAR],
-[AC_PREREQ([2.57])dnl
+[AC_PREREQ([2.68])dnl
 AC_REQUIRE([AX_SOMETHING])dnl
 AX_FOO
 AX_BAR
@@ -3596,11 +3591,11 @@ AX_BAR
 @end example
 
 Wrapping the @code{AC_PREREQ} call inside the macro ensures that
-Autoconf 2.57 will not be required if @code{AX_FOOBAR} is not actually
+Autoconf 2.68 will not be required if @code{AX_FOOBAR} is not actually
 used.  Most importantly, quoting the first argument of @code{AC_DEFUN}
 allows the macro to be redefined or included twice (otherwise this
 first argument would be expanded during the second definition).  For
-consistency we like to quote even arguments such as @code{2.57} that
+consistency we like to quote even arguments such as @code{2.68} that
 do not require it.
 
 If you have been directed here by the @command{aclocal} diagnostic but
@@ -6590,10 +6585,9 @@ in the appropriate Fortran 77 intrinsic and run-time 
libraries.
 @cindex @code{FLIBS}, defined
 @vindex FLIBS
 These extra Fortran 77 linker flags are supplied in the output variable
address@hidden by the @code{AC_F77_LIBRARY_LDFLAGS} Autoconf macro
-supplied with newer versions of Autoconf (Autoconf version 2.13 and
-later).  @xref{Fortran Compiler, , Fortran Compiler Characteristics,
-autoconf, The Autoconf Manual}.
address@hidden by the @code{AC_F77_LIBRARY_LDFLAGS} Autoconf macro.
address@hidden Compiler, , Fortran Compiler Characteristics, autoconf,
+The Autoconf Manual}.
 @end enumerate
 
 If Automake detects that a program or shared library (as mentioned in
@@ -6954,20 +6948,14 @@ substitutions.  This means that if you are 
conditionally building a
 program using such a substitution, then your @file{configure.ac} must
 take care to add @samp{$(EXEEXT)} when constructing the output variable.
 
-With Autoconf 2.13 and earlier, you must explicitly use @code{AC_EXEEXT}
-to get this support.  With Autoconf 2.50, @code{AC_EXEEXT} is run
-automatically if you configure a compiler (say, through
address@hidden).
-
 Sometimes maintainers like to write an explicit link rule for their
 program.  Without executable extension support, this is easy---you
 simply write a rule whose target is the name of the program.  However,
 when executable extension support is enabled, you must instead add the
 @samp{$(EXEEXT)} suffix.
 
-Unfortunately, due to the change in Autoconf 2.50, this means you must
-always add this extension.  However, this is a problem for maintainers
-who know their package will never run on a platform that has
+This might be a nuisance for maintainers who know their package will
+never run on a platform that has
 executable extensions.  For those maintainers, the @option{no-exeext}
 option (@pxref{Options}) will disable this feature.  This works in a
 fairly ugly way; if @option{no-exeext} is seen, then the presence of a
diff --git a/lib/Automake/Rule.pm b/lib/Automake/Rule.pm
index 43c3956..f7bf545 100644
--- a/lib/Automake/Rule.pm
+++ b/lib/Automake/Rule.pm
@@ -573,35 +573,13 @@ sub _new ($$)
   return $self;
 }
 
-
-=item C<@conds = define ($rulename, $source, $owner, $cond, $where)>
-
-Define a new rule.  C<$rulename> is the list of targets.  C<$source>
-is the filename the rule comes from.  C<$owner> is the owner of the
-rule (C<RULE_AUTOMAKE> or C<RULE_USER>).  C<$cond> is the
-C<Automake::Condition> under which the rule is defined.  C<$where> is
-the C<Automake::Location> where the rule is defined.
-
-Returns a (possibly empty) list of C<Automake::Condition>s where the
-rule's definition should be output.
-
-=cut
-
-sub define ($$$$$)
+sub _rule_defn_with_exeext_awareness ($$$)
 {
-  my ($target, $source, $owner, $cond, $where) = @_;
-
-  prog_error "$where is not a reference"
-    unless ref $where;
-  prog_error "$cond is not a reference"
-    unless ref $cond;
-
-  # Don't even think about defining a rule in condition FALSE.
-  return () if $cond == FALSE;
+  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 $noexe = $target) =~ s/\$\(EXEEXT\)$//;
   my $noexerule = rule $noexe;
   my $tdef = $noexerule ? $noexerule->def ($cond) : undef;
 
@@ -619,160 +597,208 @@ sub define ($$$$$)
               partial => 1);
          msg ('obsolete', $where, "target '$target' was defined here");
        }
-      # Don't 'return ()' now, as this might hide target clashes
-      # detected below.
     }
+    return $tdef;
+}
 
-  # Diagnose target redefinitions.
-  if ($tdef)
+sub _maybe_warn_about_duplicated_target ($$$$$$)
+{
+  my ($target, $tdef, $source, $owner, $cond, $where) = @_;
+
+  my $oldowner  = $tdef->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->name;
+
+  # Don't mention true conditions in diagnostics.
+  my $condmsg =
+    $cond == TRUE ? '' : (" in condition '" . $cond->human . "'");
+
+  if ($owner == RULE_USER)
     {
-      my $oldowner  = $tdef->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->name;
+      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 phony.test.)
+
+              # msg ('syntax', $where,
+              #      "redefinition of '$target'$condmsg ...", partial => 1);
+              # msg_cond_rule ('syntax', $cond, $target,
+              #                "... '$target' previously defined here");
+            }
+        }
+      else
+        {
+          # Since we parse the user Makefile.am before reading
+          # the Automake fragments, this condition should never happen.
+          prog_error ("user target '$target'$condmsg seen after Automake's"
+                      . " definition\nfrom " . $tdef->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{"$noam-am"})
+            {
+              $hint = "consider using $noam-local instead of $target";
+            }
+
+          msg_cond_rule ('override', $cond, $target,
+                         "user target '$target' defined here"
+                         . "$condmsg ...", partial => 1);
+          msg ('override', $where,
+               "... overrides Automake target '$oldname' defined here",
+               partial => $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->source;
+          if (not ($source eq $oldsource && $target eq $oldname))
+            {
+               msg ('syntax',
+                    $where, "redefinition of '$target'$condmsg ...",
+                    partial => 1);
+               msg_cond_rule ('syntax', $cond, $target,
+                              "... '$oldname' previously defined here");
+            }
+        }
+    }
+}
 
-      # Don't mention true conditions in diagnostics.
-      my $condmsg =
-       $cond == TRUE ? '' : " in condition '" . $cond->human . "'";
+# 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->name;
+  my @conds;
+  my ($message, $ambig_cond) = $rule->conditions->ambiguous_p ($target, $cond);
 
-      if ($owner == RULE_USER)
-       {
-         if ($oldowner == RULE_USER)
-           {
-             # Ignore '%'-style pattern rules.  We'd need the
-             # dependencies to detect duplicates.
-             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 phony.test.)
-
-                 # msg ('syntax', $where,
-                 #      "redefinition of '$target'$condmsg ...", partial => 1);
-                 # msg_cond_rule ('syntax', $cond, $target,
-                 #                "... '$target' previously defined here");
-               }
-             # 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 &read_am_file ignore the
-             # return code.
-             return ();
-           }
-         else
-           {
-             # Since we parse the user Makefile.am before reading
-             # the Automake fragments, this condition should never happen.
-             prog_error ("user target '$target'$condmsg seen after Automake's"
-                         . " definition\nfrom " . $tdef->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{"$noam-am"})
-               {
-                 $hint = "consider using $noam-local instead of $target";
-               }
+  return $cond if !$message; # No ambiguity.
 
-             msg_cond_rule ('override', $cond, $target,
-                            "user target '$target' defined here"
-                            . "$condmsg ...", partial => 1);
-             msg ('override', $where,
-                  "... overrides Automake target '$oldname' defined here",
-                  partial => $hint);
-             msg_cond_rule ('override', $cond, $target, $hint)
-               if $hint;
-
-             # Don't overwrite the user definition of TARGET.
-             return ();
-           }
-         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->source;
-             return () if $source eq $oldsource && $target eq $oldname;
-
-             msg ('syntax', $where, "redefinition of '$target'$condmsg ...",
-                  partial => 1);
-             msg_cond_rule ('syntax', $cond, $target,
-                            "... '$oldname' previously defined here");
-             return ();
-           }
-       }
-      # Never reached.
-      prog_error ("unreachable place reached");
+  if ($owner == RULE_USER)
+    {
+      # For user rules, just diagnose the ambiguity.
+      msg 'syntax', $where, "$message ...", partial => 1;
+      msg_cond_rule ('syntax', $ambig_cond, $target,
+                     "... '$target' previously defined here");
+      return ();
     }
 
-  # Conditions for which the rule should be defined.
-  my @conds = $cond;
+  # FIXME: for Automake rules, we can't diagnose ambiguities yet.
+  # The point is that Automake doesn't propagate conditions
+  # everywhere.  For instance &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
+  # &handle_PROGRAMS will attempt to define a 'foo:' rule
+  # in condition TRUE (which conflicts with COND1).  Fixing
+  # this in &handle_PROGRAMS and siblings seems hard: you'd
+  # have to explain &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.test and cond15.test for some test cases.)
+  @conds = $rule->not_always_defined_in_cond ($cond)->conds;
+
+  # No conditions left to define the rule.
+  # Warn, because our workaround is meaningless in this case.
+  if (scalar @conds == 0)
+    {
+      msg 'syntax', $where, "$message ...", partial => 1;
+      msg_cond_rule ('syntax', $ambig_cond, $target,
+                     "... '$target' previously defined here");
+      return ();
+    }
+  return @conds;
+}
 
-  # Check ambiguous conditional definitions.
-  my $rule = _crule $target;
-  my ($message, $ambig_cond) = $rule->conditions->ambiguous_p ($target, $cond);
-  if ($message)                        # We have an ambiguity.
+=item C<@conds = define ($rulename, $source, $owner, $cond, $where)>
+
+Define a new rule.  C<$rulename> is the list of targets.  C<$source>
+is the filename the rule comes from.  C<$owner> is the owner of the
+rule (C<RULE_AUTOMAKE> or C<RULE_USER>).  C<$cond> is the
+C<Automake::Condition> under which the rule is defined.  C<$where> is
+the C<Automake::Location> where the rule is defined.
+
+Returns a (possibly empty) list of C<Automake::Condition>s where the
+rule's definition should be output.
+
+=cut
+
+sub define ($$$$$)
+{
+  my ($target, $source, $owner, $cond, $where) = @_;
+
+  prog_error "$where is not a reference"
+    unless ref $where;
+  prog_error "$cond is not a reference"
+    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);
+
+  # See whether this is a duplicated target declaration.
+  if ($tdef)
     {
-      if ($owner == RULE_USER)
-       {
-         # For user rules, just diagnose the ambiguity.
-         msg 'syntax', $where, "$message ...", partial => 1;
-         msg_cond_rule ('syntax', $ambig_cond, $target,
-                        "... '$target' previously defined here");
-         return ();
-       }
-      else
-       {
-         # FIXME: for Automake rules, we can't diagnose ambiguities yet.
-         # The point is that Automake doesn't propagate conditions
-         # everywhere.  For instance &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
-         # &handle_PROGRAMS will attempt to define a 'foo:' rule
-         # in condition TRUE (which conflicts with COND1).  Fixing
-         # this in &handle_PROGRAMS and siblings seems hard: you'd
-         # have to explain &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.test and cond15.test for some test cases.)
-         @conds = $rule->not_always_defined_in_cond ($cond)->conds;
-
-         # No conditions left to define the rule.
-         # Warn, because our workaround is meaningless in this case.
-         if (scalar @conds == 0)
-           {
-             msg 'syntax', $where, "$message ...", partial => 1;
-             msg_cond_rule ('syntax', $ambig_cond, $target,
-                            "... '$target' previously defined here");
-             return ();
-           }
-       }
+      # 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 '&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)
     {
@@ -798,8 +824,6 @@ sub define ($$$$$)
          # declared in SUFFIXES and are not known language
          # extensions).  Automake will complete SUFFIXES from
          # @suffixes automatically (see handle_footer).
-
-
          || ($t =~ /$_SUFFIX_RULE_PATTERN/o && accept_extensions($1)))
        {
          ++$inference_rule_count;
diff --git a/t/ax/tap-summary-aux.sh b/t/ax/tap-summary-aux.sh
index 2e2ac4c..49b86f2 100644
--- a/t/ax/tap-summary-aux.sh
+++ b/t/ax/tap-summary-aux.sh
@@ -56,7 +56,7 @@ do_check ()
   cat all.test
   st=0
   if test $use_colors = yes; then
-    make_cmd="$MAKE AM_COLOR_TESTS=always"
+    make_cmd="$MAKE TERM=ansi AM_COLOR_TESTS=always"
   else
     make_cmd=$MAKE
   fi


hooks/post-receive
-- 
GNU Automake