From 94980b7f6dc84758466bf8c6b0c04cc0acaa8fec Mon Sep 17 00:00:00 2001 From: Jim Blandy Date: Fri, 17 May 2002 17:57:48 +0000 Subject: 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. --- gdb/c-lang.c | 129 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 126 insertions(+), 3 deletions(-) (limited to 'gdb/c-lang.c') diff --git a/gdb/c-lang.c b/gdb/c-lang.c index f98548a63af..09a2e6a968a 100644 --- a/gdb/c-lang.c +++ b/gdb/c-lang.c @@ -27,6 +27,8 @@ #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,7 +373,128 @@ c_create_fundamental_type (struct objfile *objfile, int typeid) 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,7 +562,7 @@ const struct language_defn c_language_defn = range_check_off, type_check_off, case_sensitive_on, - c_parse, + c_preprocess_and_parse, c_error, evaluate_subexp_standard, c_printchar, /* Print a character constant */ @@ -491,7 +614,7 @@ const struct language_defn cplus_language_defn = range_check_off, type_check_off, case_sensitive_on, - c_parse, + c_preprocess_and_parse, c_error, evaluate_subexp_standard, c_printchar, /* Print a character constant */ @@ -520,7 +643,7 @@ const struct language_defn asm_language_defn = range_check_off, type_check_off, case_sensitive_on, - c_parse, + c_preprocess_and_parse, c_error, evaluate_subexp_standard, c_printchar, /* Print a character constant */ -- cgit v1.2.1