* automake.in (SUFFIX_RULE_PATTERN): Add '_(){}$@' to the

set of accepted characters in extensions.
(rule_define): Convert '.o' and '.obj' into '$(OBJEXT)' for
internall use.
* tests/suffix6.test: Ensure that `.o' is handled like `.$(OBJEXT)'.

diff --git a/ChangeLog b/ChangeLog
index 8ef11b41f7c5abb43404865cc7859ad25450dfb0..e7b1783a006141f0490553fd91718f3e4dc784ee 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2001-11-16  Alexandre Duret-Lutz  <duret_g@epita.fr>
+
+       * automake.in (SUFFIX_RULE_PATTERN): Add '_(){}$@' to the
+       set of accepted characters in extensions.
+       (rule_define): Convert '.o' and '.obj' into '$(OBJEXT)' for
+       internall use.
+       * tests/suffix6.test: Ensure that `.o' is handled like `.$(OBJEXT)'.
+
 2001-11-16  Alexandre Duret-Lutz  <duret_g@epita.fr>
 
        * automake.texi (Suffixes): Don't require SUFFIXES, but document

diff --git a/automake.in b/automake.in
index b15a96356802fb0e2b9a0c303d2e5f6ea5bf1b7e..d9726782917089889e543de21a38b1728b4b2005 100755 (executable)
--- a/automake.in
+++ b/automake.in
@@ -137,7 +137,7 @@ my $TARGET_PATTERN='[$a-zA-Z_.@][-.a-zA-Z0-9_(){}/$+@]*';
 my $RULE_PATTERN =
   "^($TARGET_PATTERN(?:(?:\\\\\n|\\s)+$TARGET_PATTERN)*) *:([^=].*|)\$";
 
-my $SUFFIX_RULE_PATTERN = '^(\.[a-zA-Z0-9+]+)(\.[a-zA-Z0-9+]+)$';
+my $SUFFIX_RULE_PATTERN = '^(\.[a-zA-Z0-9_(){}$+@]+)(\.[a-zA-Z0-9_(){}$+@]+)$';
 # Only recognize leading spaces, not leading tabs.  If we recognize
 # leading tabs here then we need to make the reader smarter, because
 # otherwise it will think rules like `foo=bar; \' are errors.
@@ -6609,26 +6609,32 @@ sub rule_define ($$$$)
       $target_conditional{$target}{$cond} = $where;
   }
 
-
   # Check the rule for being a suffix rule. If so, store in a hash.
   # Either it's a rule for two known extensions...
-  if ($target =~ /^($KNOWN_EXTENSIONS_PATTERN)($KNOWN_EXTENSIONS_PATTERN)$/)
-  {
-      $suffix_rules{$1} = $2;
-      verbose "Sources ending in $1 become $2";
-      push @suffixes, $1, $2;
-  }
+  if ($target =~ /^($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).
-  elsif ($target =~ /$SUFFIX_RULE_PATTERN/o)
+      || ($target =~ /$SUFFIX_RULE_PATTERN/o && accept_extensions($1)))
   {
-      $suffix_rules{$1} = $2;
+      my $internal_ext = $2;
+
+      # When tranforming 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'...
+      $internal_ext = '.$(OBJEXT)' if ($2 eq '.o' || $2 eq '.obj');
+
+      $suffix_rules{$1} = $internal_ext;
       verbose "Sources ending in $1 become $2";
       push @suffixes, $1, $2;
-      accept_extensions($1);
   }
 
   return 1;

diff --git a/tests/suffix6.test b/tests/suffix6.test
index 72bb2a1b40b0213824435d2dcaea5198e6889295..3ab398b16c048b201b15c91b54ad8aa261898b4d 100755 (executable)
--- a/tests/suffix6.test
+++ b/tests/suffix6.test
@@ -1,18 +1,20 @@
 #! /bin/sh
 
 # Test to make sure Automake supports implicit rules with dot-less
-# extensions.
+# extensions.  Also make sure that `.o' is handled like `.$(OBJEXT)'.
 
 . $srcdir/defs || exit 1
 
 cat > Makefile.am << 'END'
-SUFFIXES = a b .$(OBJEXT)
+SUFFIXES = a b .$(OBJEXT) c .o
 bin_PROGRAMS = foo
-foo_SOURCES = fooa
+foo_SOURCES = fooa fuc
 ab:
         cp $< $@
 b.$(OBJEXT):
        cp $< $@
+c.o:
+       cp $< $@
 END
 
 : > fooa
@@ -20,7 +22,9 @@ END
 $ACLOCAL || exit 1
 $AUTOMAKE || exit 1
 
-# Automake must figure that fooa translates to foo.o using the
-# following rules:
+# Automake must figure that fooa translates to foo.$(OBJEXT) and
+# foo.$(OBJEXT) using the following rules:
 #  fooa --[ab]--> foob --[b.$(OBJEXT)]--> foo.$(OBJEXT)
-grep '_OBJECTS.*foo\.$(OBJEXT)' Makefile.in || exit 1
+grep '_OBJECTS.* foo\.$(OBJEXT)' Makefile.in || exit 1
+#  fuc --[c.o]--> fu.$(OBJEXT)  ## This is really meant !
+grep '_OBJECTS.* fu\.$(OBJEXT)' Makefile.in || exit 1