struct macro_scope * default_macro_scope (void) { struct symtab_and_line sal; struct macro_scope *ms; struct frame_info *frame; /* If there's a selected frame, use its PC. */ frame = deprecated_safe_get_selected_frame (); if (frame) sal = find_pc_line (get_frame_pc (frame), 0); /* Fall back to the current listing position. */ else { /* Don't call select_source_symtab here. That can raise an error if symbols aren't loaded, but GDB calls the expression evaluator in all sorts of contexts. For example, commands like `set width' call the expression evaluator to evaluate their numeric arguments. If the current language is C, then that may call this function to choose a scope for macro expansion. If you don't have any symbol files loaded, then get_current_or_default would raise an error. But `set width' shouldn't raise an error just because it can't decide which scope to macro-expand its argument in. */ struct symtab_and_line cursal = get_current_source_symtab_and_line (); sal.symtab = cursal.symtab; sal.line = cursal.line; } return sal_macro_scope (sal); }
static int c_preprocess_and_parse (void) { /* 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; } }
static void write_macro_definitions (const struct block *block, CORE_ADDR pc, struct ui_file *file) { struct macro_scope *scope; if (block != NULL) scope = sal_macro_scope (find_pc_line (pc, 0)); else scope = default_macro_scope (); if (scope == NULL) scope = user_macro_scope (); if (scope != NULL && scope->file != NULL && scope->file->table != NULL) macro_for_each_in_scope (scope->file, scope->line, print_one_macro, file); }
/* Implementation of the "info macros" command. */ static void info_macros_command (const char *args, int from_tty) { gdb::unique_xmalloc_ptr<struct macro_scope> ms; if (args == NULL) ms = default_macro_scope (); else { std::vector<symtab_and_line> sals = decode_line_with_current_source (args, 0); if (!sals.empty ()) ms = sal_macro_scope (sals[0]); } if (! ms || ! ms->file || ! ms->file->table) macro_inform_no_debuginfo (); else macro_for_each_in_scope (ms->file, ms->line, print_macro_definition); }
/* Implementation of the "info macros" command. */ static void info_macros_command (char *args, int from_tty) { struct macro_scope *ms = NULL; struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &ms); if (args == NULL) ms = default_macro_scope (); else { struct symtabs_and_lines sals = decode_line_with_current_source (args, 0); if (sals.nelts) ms = sal_macro_scope (sals.sals[0]); } if (! ms || ! ms->file || ! ms->file->table) macro_inform_no_debuginfo (); else macro_for_each_in_scope (ms->file, ms->line, print_macro_callback, NULL); do_cleanups (cleanup_chain); }
struct macro_scope * default_macro_scope (void) { struct symtab_and_line sal; struct macro_source_file *main; struct macro_scope *ms; /* If there's a selected frame, use its PC. */ if (selected_frame) sal = find_pc_line (selected_frame->pc, 0); /* If the target has any registers at all, then use its PC. Why we would have registers but no stack, I'm not sure. */ else if (target_has_registers) sal = find_pc_line (read_pc (), 0); /* If all else fails, fall back to the current listing position. */ else { /* Don't call select_source_symtab here. That can raise an error if symbols aren't loaded, but GDB calls the expression evaluator in all sorts of contexts. For example, commands like `set width' call the expression evaluator to evaluate their numeric arguments. If the current language is C, then that may call this function to choose a scope for macro expansion. If you don't have any symbol files loaded, then select_source_symtab will raise an error. But `set width' shouldn't raise an error just because it can't decide which scope to macro-expand its argument in. */ sal.symtab = current_source_symtab; sal.line = current_source_line; } return sal_macro_scope (sal); }