From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 393 invoked by alias); 10 May 2002 05:09:11 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 375 invoked from network); 10 May 2002 05:09:08 -0000 Received: from unknown (HELO zwingli.cygnus.com) (208.245.165.35) by sources.redhat.com with SMTP; 10 May 2002 05:09:08 -0000 Received: by zwingli.cygnus.com (Postfix, from userid 442) id 358FC5EA11; Fri, 10 May 2002 00:09:07 -0500 (EST) From: Jim Blandy To: gdb-patches@sources.redhat.com Subject: RFA: expand macros in C expressions Message-Id: <20020510050907.358FC5EA11@zwingli.cygnus.com> Date: Thu, 09 May 2002 22:09:00 -0000 X-SW-Source: 2002-05/txt/msg00325.txt.bz2 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 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;