RFA: expand macros in C expressions

[Jim Blandy <jimb at redhat dot com>]

The last code patch!  Doc and test patches on the way.

This one is the real mess.  A twistly little maze of global variables.
Swapping lexptr values back and forth.  Your stomach will churn.

I'd love to see a better solution, but before you suggest an
alternative, please take some time to read the code (or try it out!)
and make sure it works.  GDB seems to have a lot of expectations about
how lexptr behaves that make the simple solutions unusable.  For
example, I don't think one can use the nice simple macro_expand
function.  Hopefully I've missed something.

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

	Expand preprocessor macros in C expressions.
	* c-lang.h: #include "macroexp.h", for macro_lookup_ftype.
	(scan_macro_expansion, scanning_macro_expansion,
	finished_macro_expansion): New function declarations.
	(expression_macro_lookup_func, expression_macro_lookup_baton): New
	variable declarations.
	* parser-defs.h (expression_context_pc): New declaration.
	* parse.c (expression_context_pc): New variable.
	(parse_exp_1): Set expression_context_pc, as well as
	expression_context_block.
	* c-exp.y (yylex): If we're not already reading the result of a
	macro expansion, try to macro-expand the next token.  When we're
	done scanning a macro expansion, switch back to the mainline text.
	Commas and `if's in a macro's expansion don't terminate the input.
	* c-lang.c: #include "macroscope.h" and "gdb_assert.h".
	(macro_original_text, macro_expanded_text,
	expression_macro_lookup_func, expression_macro_lookup_baton): New
	variables.
	(scan_macro_expansion, scanning_macro_expansion,
	finished_macro_expansion, scan_macro_cleanup, null_macro_lookup,
	c_preprocess_and_parse): New functions.
	(c_language_defn, cplus_language_defn, asm_language_defn): Call
	c_preprocess_and_parse, instead of c_parse.
	* Makefile.in (c_lang_h): Note that this #includes macroexp.h.
	(c-lang.o): Note dependency on macroscope.h and gdb_assert.h.

Index: gdb/Makefile.in
===================================================================
RCS file: /cvs/src/src/gdb/Makefile.in,v
retrieving revision 1.180.2.7
diff -c -r1.180.2.7 Makefile.in
*** gdb/Makefile.in	9 May 2002 23:58:46 -0000	1.180.2.7
--- gdb/Makefile.in	10 May 2002 00:11:25 -0000
***************
*** 599,605 ****
  builtin_regs_h = builtin-regs.h
  breakpoint_h =	breakpoint.h $(frame_h) $(value_h)
  buildsym_h =	buildsym.h
! c_lang_h =	c-lang.h $(value_h)
  call_cmds_h =	call-cmds.h
  cli_cmds_h =	$(srcdir)/cli/cli-cmds.h
  cli_decode_h =	$(srcdir)/cli/cli-decode.h $(command_h)
--- 599,605 ----
  builtin_regs_h = builtin-regs.h
  breakpoint_h =	breakpoint.h $(frame_h) $(value_h)
  buildsym_h =	buildsym.h
! c_lang_h =	c-lang.h $(value_h) $(macroexp_h)
  call_cmds_h =	call-cmds.h
  cli_cmds_h =	$(srcdir)/cli/cli-cmds.h
  cli_decode_h =	$(srcdir)/cli/cli-decode.h $(command_h)
***************
*** 1311,1317 ****
  	$(gdb_string_h) $(value_h) $(frame_h)
  
  c-lang.o: c-lang.c $(c_lang_h) $(defs_h) $(expression_h) $(gdbtypes_h) \
! 	$(language_h) $(parser_defs_h) $(symtab_h)
  
  c-typeprint.o: c-typeprint.c $(c_lang_h) $(defs_h) $(expression_h) \
  	$(gdbcmd_h) $(gdbcore_h) $(gdbtypes_h) $(language_h) $(symtab_h) \
--- 1311,1318 ----
  	$(gdb_string_h) $(value_h) $(frame_h)
  
  c-lang.o: c-lang.c $(c_lang_h) $(defs_h) $(expression_h) $(gdbtypes_h) \
! 	$(language_h) $(parser_defs_h) $(symtab_h) $(macroscope_h) \
! 	gdb_assert.h
  
  c-typeprint.o: c-typeprint.c $(c_lang_h) $(defs_h) $(expression_h) \
  	$(gdbcmd_h) $(gdbcore_h) $(gdbtypes_h) $(language_h) $(symtab_h) \
Index: gdb/c-exp.y
===================================================================
RCS file: /cvs/src/src/gdb/c-exp.y,v
retrieving revision 1.9
diff -c -r1.9 c-exp.y
*** gdb/c-exp.y	24 Apr 2002 22:26:32 -0000	1.9
--- gdb/c-exp.y	10 May 2002 00:11:27 -0000
***************
*** 1246,1251 ****
--- 1246,1262 ----
     
   retry:
  
+   /* Check if this is a macro invocation that we need to expand.  */
+   if (! scanning_macro_expansion ())
+     {
+       char *expanded = macro_expand_next (&lexptr,
+                                           expression_macro_lookup_func,
+                                           expression_macro_lookup_baton);
+ 
+       if (expanded)
+         scan_macro_expansion (expanded);
+     }
+ 
    prev_lexptr = lexptr;
    unquoted_expr = 1;
  
***************
*** 1271,1277 ****
    switch (c = *tokstart)
      {
      case 0:
!       return 0;
  
      case ' ':
      case '\t':
--- 1282,1298 ----
    switch (c = *tokstart)
      {
      case 0:
!       /* If we were just scanning the result of a macro expansion,
!          then we need to resume scanning the original text.
!          Otherwise, we were already scanning the original text, and
!          we're really done.  */
!       if (scanning_macro_expansion ())
!         {
!           finished_macro_expansion ();
!           goto retry;
!         }
!       else
!         return 0;
  
      case ' ':
      case '\t':
***************
*** 1324,1330 ****
        return c;
  
      case ',':
!       if (comma_terminates && paren_depth == 0)
  	return 0;
        lexptr++;
        return c;
--- 1345,1353 ----
        return c;
  
      case ',':
!       if (comma_terminates
!           && paren_depth == 0
!           && ! scanning_macro_expansion ())
  	return 0;
        lexptr++;
        return c;
***************
*** 1503,1511 ****
        c = tokstart[++namelen];
      }
  
!   /* The token "if" terminates the expression and is NOT 
!      removed from the input stream.  */
!   if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f')
      {
        return 0;
      }
--- 1526,1538 ----
        c = tokstart[++namelen];
      }
  
!   /* The token "if" terminates the expression and is NOT removed from
!      the input stream.  It doesn't count if it appears in the
!      expansion of a macro.  */
!   if (namelen == 2
!       && tokstart[0] == 'i'
!       && tokstart[1] == 'f'
!       && ! scanning_macro_expansion ())
      {
        return 0;
      }
Index: gdb/c-lang.c
===================================================================
RCS file: /cvs/src/src/gdb/c-lang.c,v
retrieving revision 1.11
diff -c -r1.11 c-lang.c
*** gdb/c-lang.c	21 Mar 2002 00:53:44 -0000	1.11
--- gdb/c-lang.c	10 May 2002 00:11:27 -0000
***************
*** 27,32 ****
--- 27,34 ----
  #include "language.h"
  #include "c-lang.h"
  #include "valprint.h"
+ #include "macroscope.h"
+ #include "gdb_assert.h"
  
  extern void _initialize_c_language (void);
  static void c_emit_char (int c, struct ui_file * stream, int quoter);
***************
*** 371,377 ****
--- 373,500 ----
    return (type);
  }
  
+ /* Preprocessing and parsing C and C++ expressions.  */
  
+ 
+ /* When we find that lexptr (the global var defined in parse.c) is
+    pointing at a macro invocation, we expand the invocation, and call
+    scan_macro_expansion to save the old lexptr here and point lexptr
+    into the expanded text.  When we reach the end of that, we call
+    end_macro_expansion to pop back to the value we saved here.  The
+    macro expansion code promises to return only fully-expanded text,
+    so we don't need to "push" more than one level.
+ 
+    This is disgusting, of course.  It would be cleaner to do all macro
+    expansion beforehand, and then hand that to lexptr.  But we don't
+    really know where the expression ends.  Remember, in a command like
+ 
+      (gdb) break *ADDRESS if CONDITION
+ 
+    we evaluate ADDRESS in the scope of the current frame, but we
+    evaluate CONDITION in the scope of the breakpoint's location.  So
+    it's simply wrong to try to macro-expand the whole thing at once.  */
+ static char *macro_original_text;
+ static char *macro_expanded_text;
+ 
+ 
+ void
+ scan_macro_expansion (char *expansion)
+ {
+   /* We'd better not be trying to push the stack twice.  */
+   gdb_assert (! macro_original_text);
+   gdb_assert (! macro_expanded_text);
+ 
+   /* Save the old lexptr value, so we can return to it when we're done
+      parsing the expanded text.  */
+   macro_original_text = lexptr;
+   lexptr = expansion;
+ 
+   /* Save the expanded text, so we can free it when we're finished.  */
+   macro_expanded_text = expansion;
+ }
+ 
+ 
+ int
+ scanning_macro_expansion ()
+ {
+   return macro_original_text != 0;
+ }
+ 
+ 
+ void 
+ finished_macro_expansion ()
+ {
+   /* There'd better be something to pop back to, and we better have
+      saved a pointer to the start of the expanded text.  */
+   gdb_assert (macro_original_text);
+   gdb_assert (macro_expanded_text);
+ 
+   /* Pop back to the original text.  */
+   lexptr = macro_original_text;
+   macro_original_text = 0;
+ 
+   /* Free the expanded text.  */
+   xfree (macro_expanded_text);
+   macro_expanded_text = 0;
+ }
+ 
+ 
+ static void
+ scan_macro_cleanup (void *dummy)
+ {
+   if (macro_original_text)
+     finished_macro_expansion ();
+ }
+ 
+ 
+ /* We set these global variables before calling c_parse, to tell it
+    how it to find macro definitions for the expression at hand.  */
+ macro_lookup_ftype *expression_macro_lookup_func;
+ void *expression_macro_lookup_baton;
+ 
+ 
+ static struct macro_definition *
+ null_macro_lookup (const char *name, void *baton)
+ {
+   return 0;
+ }
+ 
+ 
+ static int
+ c_preprocess_and_parse ()
+ {
+   /* Set up a lookup function for the macro expander.  */
+   struct macro_scope *scope = 0;
+   struct cleanup *back_to = make_cleanup (free_current_contents, &scope);
+ 
+   if (expression_context_block)
+     scope = sal_macro_scope (find_pc_line (expression_context_pc, 0));
+   else
+     scope = default_macro_scope ();
+ 
+   if (scope)
+     {
+       expression_macro_lookup_func = standard_macro_lookup;
+       expression_macro_lookup_baton = (void *) scope;
+     }
+   else
+     {
+       expression_macro_lookup_func = null_macro_lookup;
+       expression_macro_lookup_baton = 0;      
+     }
+ 
+   gdb_assert (! macro_original_text);
+   make_cleanup (scan_macro_cleanup, 0);
+ 
+   {
+     int result = c_parse ();
+     do_cleanups (back_to);
+     return result;
+   }
+ }
+ 
+ 
+ 
  /* Table mapping opcodes into strings for printing operators
     and precedences of the operators.  */
  
***************
*** 439,445 ****
    range_check_off,
    type_check_off,
    case_sensitive_on,
!   c_parse,
    c_error,
    evaluate_subexp_standard,
    c_printchar,			/* Print a character constant */
--- 562,568 ----
    range_check_off,
    type_check_off,
    case_sensitive_on,
!   c_preprocess_and_parse,
    c_error,
    evaluate_subexp_standard,
    c_printchar,			/* Print a character constant */
***************
*** 491,497 ****
    range_check_off,
    type_check_off,
    case_sensitive_on,
!   c_parse,
    c_error,
    evaluate_subexp_standard,
    c_printchar,			/* Print a character constant */
--- 614,620 ----
    range_check_off,
    type_check_off,
    case_sensitive_on,
!   c_preprocess_and_parse,
    c_error,
    evaluate_subexp_standard,
    c_printchar,			/* Print a character constant */
***************
*** 520,526 ****
    range_check_off,
    type_check_off,
    case_sensitive_on,
!   c_parse,
    c_error,
    evaluate_subexp_standard,
    c_printchar,			/* Print a character constant */
--- 643,649 ----
    range_check_off,
    type_check_off,
    case_sensitive_on,
!   c_preprocess_and_parse,
    c_error,
    evaluate_subexp_standard,
    c_printchar,			/* Print a character constant */
Index: gdb/c-lang.h
===================================================================
RCS file: /cvs/src/src/gdb/c-lang.h,v
retrieving revision 1.4
diff -c -r1.4 c-lang.h
*** gdb/c-lang.h	13 Feb 2002 18:49:29 -0000	1.4
--- gdb/c-lang.h	10 May 2002 00:11:27 -0000
***************
*** 24,29 ****
--- 24,30 ----
  #define C_LANG_H 1
  
  #include "value.h"
+ #include "macroexp.h"
  
  
  extern int c_parse (void);	/* Defined in c-exp.y */
***************
*** 48,53 ****
--- 49,61 ----
  extern void c_printstr (struct ui_file * stream, char *string,
  			unsigned int length, int width,
  			int force_ellipses);
+ 
+ extern void scan_macro_expansion (char *expansion);
+ extern int scanning_macro_expansion (void);
+ extern void finished_macro_expansion (void);
+ 
+ extern macro_lookup_ftype *expression_macro_lookup_func;
+ extern void *expression_macro_lookup_baton;
  
  extern struct type *c_create_fundamental_type (struct objfile *, int);
  
Index: gdb/parse.c
===================================================================
RCS file: /cvs/src/src/gdb/parse.c,v
retrieving revision 1.23
diff -c -r1.23 parse.c
*** gdb/parse.c	24 Apr 2002 22:26:32 -0000	1.23
--- gdb/parse.c	10 May 2002 00:11:32 -0000
***************
*** 71,76 ****
--- 71,77 ----
  int expout_size;
  int expout_ptr;
  struct block *expression_context_block;
+ CORE_ADDR expression_context_pc;
  struct block *innermost_block;
  int arglist_len;
  union type_stack_elt *type_stack;
***************
*** 1140,1146 ****
    old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
    funcall_chain = 0;
  
!   expression_context_block = block ? block : get_selected_block (0);
  
    namecopy = (char *) alloca (strlen (lexptr) + 1);
    expout_size = 10;
--- 1141,1153 ----
    old_chain = make_cleanup (free_funcalls, 0 /*ignore*/);
    funcall_chain = 0;
  
!   if (block)
!     {
!       expression_context_block = block;
!       expression_context_pc = block->startaddr;
!     }
!   else
!     expression_context_block = get_selected_block (&expression_context_pc);
  
    namecopy = (char *) alloca (strlen (lexptr) + 1);
    expout_size = 10;
Index: gdb/parser-defs.h
===================================================================
RCS file: /cvs/src/src/gdb/parser-defs.h,v
retrieving revision 1.8
diff -c -r1.8 parser-defs.h
*** gdb/parser-defs.h	24 Apr 2002 22:26:32 -0000	1.8
--- gdb/parser-defs.h	10 May 2002 00:11:32 -0000
***************
*** 37,42 ****
--- 37,48 ----
  
  extern struct block *expression_context_block;
  
+ /* If expression_context_block is non-zero, then this is the PC within
+    the block that we want to evaluate expressions at.  When debugging
+    C or C++ code, we use this to find the exact line we're at, and
+    then look up the macro definitions active at that point.  */
+ CORE_ADDR expression_context_pc;
+ 
  /* The innermost context required by the stack and register variables
     we've encountered so far. */
  extern struct block *innermost_block;