RFA: tolerate benign redefinitions

[Jim Blandy <jimb at redhat dot com>]

It's okay to re-#define a macro, as long as the new definition is the
same as the old one; at the moment, GDB always complains.  The exact
definition of "the same as" is technical, but this patch uses a
tolerable approximation.

2002-05-16  Jim Blandy  <jimb@redhat.com>

	* macrotab.c (check_for_redefinition): Don't complain if the new
	definition is the same as the previous one.  Take more arguments
	to allow the comparison.
	(macro_define_object, macro_define_function): Pass more arguments
	to check_for_redefinition.

Index: gdb/macrotab.c
===================================================================
RCS file: /cvs/src/src/gdb/macrotab.c,v
retrieving revision 1.1.2.3
diff -c -r1.1.2.3 macrotab.c
*** gdb/macrotab.c	9 May 2002 15:18:33 -0000	1.1.2.3
--- gdb/macrotab.c	16 May 2002 23:05:48 -0000
***************
*** 660,686 ****
  }
  
  
! /* If NAME already has a definition in scope at LINE in FILE, and
!    return the key.  Otherwise, return zero.  */
  static struct macro_key *
  check_for_redefinition (struct macro_source_file *source, int line,
!                         const char *name)
  {
    splay_tree_node n = find_definition (name, source, line);
  
-   /* This isn't really right.  There's nothing wrong with redefining a
-      macro if the new replacement list is the same as the old one.  */
    if (n)
      {
        struct macro_key *found_key = (struct macro_key *) n->key;
!       static struct complaint macro_redefined = {
!         "macro `%s' redefined at %s:%d;"
!         "original definition at %s:%d", 0, 0
!       };
!       complain (&macro_redefined, name,
!                 source->filename, line,
!                 found_key->start_file->filename,
!                 found_key->start_line);
        return found_key;
      }
    else
--- 660,723 ----
  }
  
  
! /* If NAME already has a definition in scope at LINE in SOURCE, return
!    the key.  If the old definition is different from the definition
!    given by KIND, ARGC, ARGV, and REPLACEMENT, complain, too.
!    Otherwise, return zero.  (ARGC and ARGV are meaningless unless KIND
!    is `macro_function_like'.)  */
  static struct macro_key *
  check_for_redefinition (struct macro_source_file *source, int line,
!                         const char *name, enum macro_kind kind,
!                         int argc, const char **argv,
!                         const char *replacement)
  {
    splay_tree_node n = find_definition (name, source, line);
  
    if (n)
      {
        struct macro_key *found_key = (struct macro_key *) n->key;
!       struct macro_definition *found_def
!         = (struct macro_definition *) n->value;
!       int same = 1;
! 
!       /* Is this definition the same as the existing one?
!          According to the standard, this comparison needs to be done
!          on lists of tokens, not byte-by-byte, as we do here.  But
!          that's too hard for us at the moment, and comparing
!          byte-by-byte will only yield false negatives (i.e., extra
!          warning messages), not false positives (i.e., unnoticed
!          definition changes).  */
!       if (kind != found_def->kind)
!         same = 0;
!       else if (strcmp (replacement, found_def->replacement))
!         same = 0;
!       else if (kind == macro_function_like)
!         {
!           if (argc != found_def->argc)
!             same = 0;
!           else
!             {
!               int i;
! 
!               for (i = 0; i < argc; i++)
!                 if (strcmp (argv[i], found_def->argv[i]))
!                   same = 0;
!             }
!         }
! 
!       if (! same)
!         {
!           static struct complaint macro_redefined = {
!             "macro `%s' redefined at %s:%d; original definition at %s:%d",
!             0, 0
!           };
!           complain (&macro_redefined,
!                     name,
!                     source->filename, line,
!                     found_key->start_file->filename,
!                     found_key->start_line);
!         }
! 
        return found_key;
      }
    else
***************
*** 696,702 ****
    struct macro_key *k;
    struct macro_definition *d;
  
!   k = check_for_redefinition (source, line, name);
  
    /* If we're redefining a symbol, and the existing key would be
       identical to our new key, then the splay_tree_insert function
--- 733,742 ----
    struct macro_key *k;
    struct macro_definition *d;
  
!   k = check_for_redefinition (source, line, 
!                               name, macro_object_like,
!                               0, 0,
!                               replacement);
  
    /* If we're redefining a symbol, and the existing key would be
       identical to our new key, then the splay_tree_insert function
***************
*** 726,732 ****
    struct macro_key *k;
    struct macro_definition *d;
  
!   k = check_for_redefinition (source, line, name);
  
    /* See comments about duplicate keys in macro_define_object.  */
    if (k && ! key_compare (k, name, source, line))
--- 766,775 ----
    struct macro_key *k;
    struct macro_definition *d;
  
!   k = check_for_redefinition (source, line,
!                               name, macro_function_like,
!                               argc, argv,
!                               replacement);
  
    /* See comments about duplicate keys in macro_define_object.  */
    if (k && ! key_compare (k, name, source, line))