add xfail for "print u_var" test in gdb.ada/packed_array.exp

[deliverable/binutils-gdb.git] / gdb / macrotab.h

diff --git a/gdb/macrotab.h b/gdb/macrotab.h
index c3b686a1c28eb6555fa53dde67bc042a930c1144..d2b2b63290e4b4913b2f80b30d5e3d22a94f2865 100644 (file)
--- a/gdb/macrotab.h
+++ b/gdb/macrotab.h
@@ -1,5 +1,6 @@
 /* Interface to C preprocessor macro tables for GDB.
-   Copyright (C) 2002, 2007 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2007, 2008, 2009, 2010, 2011
+   Free Software Foundation, Inc.
    Contributed by Red Hat, Inc.
 
    This file is part of GDB.
@@ -72,6 +73,8 @@ struct bcache;
 /* A table of all the macro definitions for a given compilation unit.  */
 struct macro_table;
 
+/* The definition of a single macro.  */
+struct macro_definition;
 
 /* A source file that participated in a compilation unit --- either a
    main file, or an #included file.  If a file is #included more than
@@ -152,15 +155,15 @@ struct macro_source_file
    amongst compilation units in an executable file; if BCACHE is zero,
    don't cache these things.
 
-   Note that, if either OBSTACK or BCACHE are non-zero, then you
-   should only ever add information the macro table --- you should
-   never remove things from it.  You'll get an error if you try.  At
-   the moment, since we only provide obstacks and bcaches for macro
-   tables for symtabs, this restriction makes a nice sanity check.
-   Obstacks and bcaches are pretty much grow-only structures anyway.
-   However, if we find that it's occasionally useful to delete things
-   even from the symtab's tables, and the storage leak isn't a
-   problem, this restriction could be lifted.  */
+   Note that, if either OBSTACK or BCACHE are non-zero, then removing
+   information from the table may leak memory.  Neither obstacks nor
+   bcaches really allow you to remove information, so although we can
+   update the data structure to record the change, we can't free the
+   old data.  At the moment, since we only provide obstacks and
+   bcaches for macro tables for symtabs, this isn't a problem; only
+   odd debugging information makes a definition and then deletes it at
+   the same source location (although 'gcc -DFOO -UFOO -DFOO=2' does
+   do that in GCC 4.1.2.).  */
 struct macro_table *new_macro_table (struct obstack *obstack,
                                      struct bcache *bcache);
 
@@ -189,6 +192,11 @@ struct macro_source_file *macro_set_main (struct macro_table *table,
 /* Return the main source file of the macro table TABLE.  */
 struct macro_source_file *macro_main (struct macro_table *table);
 
+/* Mark the macro table TABLE so that macros defined in this table can
+   be redefined without error.  Note that it invalid to call this if
+   TABLE is allocated on an obstack.  */
+void macro_allow_redefinitions (struct macro_table *table);
+
 
 /* Record a #inclusion.
    Record in SOURCE's macro table that, at line number LINE in SOURCE,
@@ -247,7 +255,6 @@ void macro_define_function (struct macro_source_file *source, int line,
 void macro_undef (struct macro_source_file *source, int line,
                   const char *name);
 
-
 /* Different kinds of macro definitions.  */
 enum macro_kind
 {
@@ -263,12 +270,12 @@ struct macro_definition
   struct macro_table *table;
 
   /* What kind of macro it is.  */
-  enum macro_kind kind;
+  ENUM_BITFIELD (macro_kind) kind : 1;
 
   /* If `kind' is `macro_function_like', the number of arguments it
      takes, and their names.  The names, and the array of pointers to
      them, are in the table's bcache, if it has one.  */
-  int argc;
+  int argc : 31;
   const char * const *argv;
 
   /* The replacement string (body) of the macro.  This is in the
@@ -298,5 +305,25 @@ struct macro_source_file *(macro_definition_location
                             const char *name,
                             int *definition_line));
 
+/* Callback function when walking a macro table.  NAME is the name of
+   the macro, and DEFINITION is the definition.  USER_DATA is an
+   arbitrary pointer which is passed by the caller to macro_for_each
+   or macro_for_each_in_scope.  */
+typedef void (*macro_callback_fn) (const char *name,
+                                  const struct macro_definition *definition,
+                                  void *user_data);
+
+/* Call the function FN for each macro in the macro table TABLE.
+   USER_DATA is passed, untranslated, to FN.  */
+void macro_for_each (struct macro_table *table, macro_callback_fn fn,
+                    void *user_data);
+
+/* Call the function FN for each macro that is visible in a given
+   scope.  The scope is represented by FILE and LINE.  USER_DATA is
+   passed, untranslated, to FN.  */
+void macro_for_each_in_scope (struct macro_source_file *file, int line,
+                             macro_callback_fn fn,
+                             void *user_data);
+
 
 #endif /* MACROTAB_H */