mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-15 04:31:49 +08:00
19ba03f495
See previous patch's description. gdb/ChangeLog: * macrocmd.c (print_macro_callback): Add cast(s). * macrotab.c (macro_bcache_str): Likewise. (new_macro_definition): Likewise. * main.c (captured_main): Likewise. * maint.c (print_bfd_section_info): Likewise. * mdebugread.c (mdebug_build_psymtabs): Likewise. (basic_type): Likewise. * memattr.c (mem_region_cmp): Likewise. * memory-map.c (memory_map_start_memory): Likewise. (memory_map_end_memory): Likewise. (memory_map_start_property): Likewise. (memory_map_end_property): Likewise. (clear_result): Likewise. * memrange.c (compare_mem_ranges): Likewise. * mep-tdep.c (mep_analyze_frame_prologue): Likewise. * mi/mi-cmd-var.c (mi_cmd_var_update_iter): Likewise. * mi/mi-console.c (mi_console_file_delete): Likewise. (mi_console_file_fputs): Likewise. (mi_console_raw_packet): Likewise. (mi_console_file_flush): Likewise. (mi_console_set_raw): Likewise. * mi/mi-interp.c (mi_interpreter_resume): Likewise. (mi_new_thread): Likewise. (mi_thread_exit): Likewise. (mi_record_changed): Likewise. (mi_inferior_added): Likewise. (mi_inferior_appeared): Likewise. (mi_inferior_exit): Likewise. (mi_inferior_removed): Likewise. (mi_interp_data): Likewise. (mi_on_normal_stop): Likewise. (mi_traceframe_changed): Likewise. (mi_tsv_created): Likewise. (mi_tsv_deleted): Likewise. (mi_tsv_modified): Likewise. (mi_breakpoint_created): Likewise. (mi_breakpoint_deleted): Likewise. (mi_breakpoint_modified): Likewise. (mi_output_running_pid): Likewise. (mi_inferior_count): Likewise. (mi_solib_loaded): Likewise. (mi_solib_unloaded): Likewise. (mi_command_param_changed): Likewise. (mi_memory_changed): Likewise. (report_initial_inferior): Likewise. (mi_ui_out): Likewise. (mi_set_logging): Likewise. * mi/mi-main.c (collect_cores): Likewise. (print_one_inferior): Likewise. (free_vector_of_ints): Likewise. (free_splay_tree): Likewise. (mi_execute_command): Likewise. * mi/mi-out.c (mi_table_body): Likewise. (mi_table_end): Likewise. (mi_table_header): Likewise. (mi_begin): Likewise. (mi_end): Likewise. (mi_field_int): Likewise. (mi_field_string): Likewise. (mi_field_fmt): Likewise. (mi_flush): Likewise. (mi_redirect): Likewise. (field_separator): Likewise. (mi_open): Likewise. (mi_close): Likewise. (mi_out_buffered): Likewise. (mi_out_rewind): Likewise. (mi_out_put): Likewise. (mi_version): Likewise. (mi_out_data_dtor): Likewise. * mi/mi-parse.c (mi_parse_cleanup): Likewise. * microblaze-tdep.c (microblaze_frame_cache): Likewise. * minidebug.c (lzma_open): Likewise. (lzma_pread): Likewise. (lzma_close): Likewise. (lzma_stat): Likewise. * mips-linux-tdep.c (mips_linux_init_abi): Likewise. * mips-sde-tdep.c (mips_sde_frame_cache): Likewise. (mips_sde_elf_osabi_sniff_abi_tag_sections): Likewise. * mips-tdep.c (mips_insn16_frame_cache): Likewise. (mips_micro_frame_cache): Likewise. (mips_insn32_frame_cache): Likewise. (mips_stub_frame_cache): Likewise. (gdb_print_insn_mips): Likewise. (value_of_mips_user_reg): Likewise. (mips_gdbarch_init): Likewise. * mips64obsd-tdep.c (mips64obsd_supply_gregset): Likewise. * mipsnbsd-tdep.c (mipsnbsd_supply_fpregset): Likewise. (mipsnbsd_supply_gregset): Likewise. * mn10300-linux-tdep.c (am33_supply_fpregset_method): Likewise. (am33_collect_gregset_method): Likewise. (am33_collect_fpregset_method): Likewise. * mn10300-tdep.c (mn10300_analyze_frame_prologue): Likewise. * moxie-tdep.c (moxie_frame_cache): Likewise. * msp430-tdep.c (msp430_get_opcode_byte): Likewise. (msp430_analyze_frame_prologue): Likewise. * mt-tdep.c (mt_frame_unwind_cache): Likewise. * nios2-linux-tdep.c (nios2_supply_gregset): Likewise. (nios2_collect_gregset): Likewise. * nios2-tdep.c (nios2_frame_unwind_cache): Likewise. (nios2_stub_frame_cache): Likewise. * objc-lang.c (find_methods): Likewise. * objfiles.c (objfiles_pspace_data_cleanup): Likewise. (get_objfile_pspace_data): Likewise. (get_objfile_bfd_data): Likewise. (objfile_bfd_data_free): Likewise. (add_to_objfile_sections): Likewise. (do_free_objfile_cleanup): Likewise. (resume_section_map_updates_cleanup): Likewise. * opencl-lang.c (builtin_opencl_type): Likewise. * osabi.c (generic_elf_osabi_sniff_abi_tag_sections): Likewise. * osdata.c (osdata_start_osdata): Likewise. (osdata_start_item): Likewise. (osdata_start_column): Likewise. (osdata_end_column): Likewise. (clear_parsing_data): Likewise. (osdata_free_cleanup): Likewise. * parse.c (type_stack_cleanup): Likewise. (exp_uses_objfile_iter): Likewise. * ppc-linux-tdep.c (ppc_linux_supply_gregset): Likewise. (ppc_linux_collect_gregset): Likewise. (ppu2spu_prev_arch): Likewise. (ppu2spu_this_id): Likewise. (ppu2spu_prev_register): Likewise. (ppu2spu_unwind_register): Likewise. (ppu2spu_sniffer): Likewise. (ppu2spu_dealloc_cache): Likewise. (ppc_linux_init_abi): Likewise. * ppcfbsd-tdep.c (ppcfbsd_sigtramp_frame_cache): Likewise. * ppcobsd-tdep.c (ppcobsd_sigtramp_frame_cache): Likewise. * progspace.c (restore_program_space): Likewise. * psymtab.c (find_pc_sect_psymtab): Likewise. (compare_psymbols): Likewise. (psymbol_bcache_full): Likewise. (allocate_psymtab): Likewise. (discard_psymtabs_upto): Likewise. * python/py-block.c (set_block): Likewise. (del_objfile_blocks): Likewise. * python/py-breakpoint.c (build_bp_list): Likewise. * python/py-inferior.c (inferior_to_inferior_object): Likewise. (build_inferior_list): Likewise. (py_free_inferior): Likewise. * python/py-objfile.c (py_free_objfile): Likewise. (objfile_to_objfile_object): Likewise. * python/py-prettyprint.c (py_restore_tstate): Likewise. * python/py-progspace.c (py_free_pspace): Likewise. (pspace_to_pspace_object): Likewise. * python/py-symbol.c (set_symbol): Likewise. (del_objfile_symbols): Likewise. * python/py-symtab.c (set_sal): Likewise. (set_symtab): Likewise. (del_objfile_symtab): Likewise. (del_objfile_sal): Likewise. * python/py-type.c (save_objfile_types): Likewise. (set_type): Likewise. * python/py-unwind.c (pyuw_prev_register): Likewise. (pyuw_on_new_gdbarch): Likewise. * python/py-utils.c (py_decref): Likewise. (py_xdecref): Likewise. (gdb_py_generic_dict): Likewise. * python/py-xmethods.c (gdbpy_free_xmethod_worker_data): Likewise. (gdbpy_clone_xmethod_worker_data): Likewise. (gdbpy_get_xmethod_arg_types): Likewise. (gdbpy_get_xmethod_result_type): Likewise. (gdbpy_invoke_xmethod): Likewise. * python/python.c (gdbpy_apply_type_printers): Likewise. (gdbpy_free_type_printers): Likewise. * record-btrace.c (record_btrace_disable_callback): Likewise. (bfcache_hash): Likewise. (bfcache_eq): Likewise. (btrace_get_frame_function): Likewise. (record_btrace_frame_unwind_stop_reason): Likewise. (record_btrace_frame_this_id): Likewise. (record_btrace_frame_prev_register): Likewise. (record_btrace_frame_dealloc_cache): Likewise. * record-full.c (record_full_message_wrapper): Likewise. (record_full_save_cleanups): Likewise. * regcache.c (regcache_descr): Likewise. (do_regcache_xfree): Likewise. (do_regcache_invalidate): Likewise. (do_cooked_read): Likewise. (regcache_transfer_regset): Likewise. * reggroups.c (reggroup_add): Likewise. (reggroup_next): Likewise. (reggroup_prev): Likewise. * remote-fileio.c (do_remote_fileio_request): Likewise. * remote-notif.c (remote_async_get_pending_events_handler): Likewise. (do_notif_event_xfree): Likewise. * remote.c (get_remote_arch_state): Likewise. (remote_pspace_data_cleanup): Likewise. (get_remote_exec_file): Likewise. (set_pspace_remote_exec_file): Likewise. (compare_pnums): Likewise. (clear_threads_listing_context): Likewise. (remote_newthread_step): Likewise. (start_thread): Likewise. (end_thread): Likewise. (remove_child_of_pending_fork): Likewise. (remove_stop_reply_for_inferior): Likewise. (remove_stop_reply_of_remote_state): Likewise. (remote_notif_remove_once_on_match): Likewise. (stop_reply_match_ptid_and_ws): Likewise. (kill_child_of_pending_fork): Likewise. (register_remote_g_packet_guess): Likewise. (remote_read_description_p): Likewise. (remote_read_description): Likewise. (free_actions_list_cleanup_wrapper): Likewise. (remote_async_serial_handler): Likewise. * rl78-tdep.c (rl78_get_opcode_byte): Likewise. (rl78_analyze_frame_prologue): Likewise. * rs6000-tdep.c (ppc_supply_gregset): Likewise. (ppc_supply_fpregset): Likewise. (ppc_supply_vsxregset): Likewise. (ppc_supply_vrregset): Likewise. (ppc_collect_gregset): Likewise. (ppc_collect_fpregset): Likewise. (ppc_collect_vsxregset): Likewise. (ppc_collect_vrregset): Likewise. (e500_move_ev_register): Likewise. (do_regcache_raw_write): Likewise. (rs6000_frame_cache): Likewise. (rs6000_epilogue_frame_cache): Likewise. (rs6000_gdbarch_init): Likewise. * rx-tdep.c (rx_get_opcode_byte): Likewise. (rx_analyze_frame_prologue): Likewise. (rx_frame_type): Likewise. (rx_frame_sniffer_common): Likewise. * s390-linux-tdep.c (s390_check_for_saved): Likewise. (s390_frame_unwind_cache): Likewise. (s390_stub_frame_unwind_cache): Likewise. (s390_sigtramp_frame_unwind_cache): Likewise. * score-tdep.c (score_make_prologue_cache): Likewise. * sentinel-frame.c (sentinel_frame_prev_register): Likewise. (sentinel_frame_prev_arch): Likewise. * ser-base.c (fd_event): Likewise. (push_event): Likewise. (ser_base_write): Likewise. * ser-pipe.c (pipe_close): Likewise. * serial.c (serial_write): Likewise. * sh-tdep.c (sh_frame_cache): Likewise. (sh_stub_this_id): Likewise. * sh64-tdep.c (sh64_frame_cache): Likewise. * solib-aix.c (get_solib_aix_inferior_data): Likewise. (library_list_start_library): Likewise. (library_list_start_list): Likewise. (solib_aix_free_library_list): Likewise. * solib-darwin.c (get_darwin_info): Likewise. * solib-dsbt.c (get_dsbt_info): Likewise. * solib-spu.c (append_ocl_sos): Likewise. * solib-svr4.c (svr4_pspace_data_cleanup): Likewise. (get_svr4_info): Likewise. (library_list_start_library): Likewise. (svr4_library_list_start_list): Likewise. (hash_probe_and_action): Likewise. (equal_probe_and_action): Likewise. (svr4_update_solib_event_breakpoint): Likewise. (set_solib_svr4_fetch_link_map_offsets): Likewise. (svr4_fetch_link_map_offsets): Likewise. (svr4_have_link_map_offsets): Likewise. * solib-target.c (library_list_start_segment): Likewise. (library_list_start_section): Likewise. (library_list_start_library): Likewise. (library_list_end_library): Likewise. (library_list_start_list): Likewise. (solib_target_free_library_list): Likewise. * solib.c (solib_ops): Likewise. (set_solib_ops): Likewise. * sparc-sol2-tdep.c (sparc32_sol2_sigtramp_frame_cache): Likewise. * sparc-tdep.c (sparc_frame_cache): Likewise. (sparc32_frame_cache): Likewise. (sparc32_supply_gregset): Likewise. (sparc32_collect_gregset): Likewise. (sparc32_supply_fpregset): Likewise. (sparc32_collect_fpregset): Likewise. * sparc64-sol2-tdep.c (sparc64_sol2_sigtramp_frame_cache): Likewise. * sparc64-tdep.c (sparc64_supply_gregset): Likewise. (sparc64_collect_gregset): Likewise. (sparc64_supply_fpregset): Likewise. (sparc64_collect_fpregset): Likewise. * sparc64fbsd-tdep.c (sparc64fbsd_sigtramp_frame_cache): Likewise. * sparc64nbsd-tdep.c (sparc64nbsd_sigcontext_frame_cache): Likewise. * sparc64obsd-tdep.c (sparc64obsd_frame_cache): Likewise. (sparc64obsd_trapframe_cache): Likewise. * sparcnbsd-tdep.c (sparc32nbsd_sigcontext_frame_cache): Likewise. * sparcobsd-tdep.c (sparc32obsd_sigtramp_frame_cache): Likewise. * spu-multiarch.c (spu_gdbarch): Likewise. * spu-tdep.c (spu_frame_unwind_cache): Likewise. (spu2ppu_prev_arch): Likewise. (spu2ppu_this_id): Likewise. (spu2ppu_prev_register): Likewise. (spu2ppu_dealloc_cache): Likewise. (spu_dis_asm_print_address): Likewise. (gdb_print_insn_spu): Likewise. (spu_get_overlay_table): Likewise. * stabsread.c (rs6000_builtin_type): Likewise. * stack.c (do_print_variable_and_value): Likewise. * stap-probe.c (get_stap_base_address_1): Likewise. * symfile-debug.c (debug_qf_has_symbols): Likewise. (debug_qf_find_last_source_symtab): Likewise. (debug_qf_forget_cached_source_info): Likewise. (debug_qf_map_symtabs_matching_filename): Likewise. (debug_qf_lookup_symbol): Likewise. (debug_qf_print_stats): Likewise. (debug_qf_dump): Likewise. (debug_qf_relocate): Likewise. (debug_qf_expand_symtabs_for_function): Likewise. (debug_qf_expand_all_symtabs): Likewise. (debug_qf_expand_symtabs_with_fullname): Likewise. (debug_qf_map_matching_symbols): Likewise. (debug_qf_expand_symtabs_matching): Likewise. (debug_qf_find_pc_sect_compunit_symtab): Likewise. (debug_qf_map_symbol_filenames): Likewise. (debug_sym_get_probes): Likewise. (debug_sym_new_init): Likewise. (debug_sym_init): Likewise. (debug_sym_read): Likewise. (debug_sym_read_psymbols): Likewise. (debug_sym_finish): Likewise. (debug_sym_offsets): Likewise. (debug_sym_read_linetable): Likewise. (debug_sym_relocate): Likewise. (uninstall_symfile_debug_logging): Likewise. * symfile-mem.c (symbol_file_add_from_memory_wrapper): Likewise. * symfile.c (place_section): Likewise. (add_section_size_callback): Likewise. (load_progress): Likewise. (load_section_callback): Likewise. (clear_memory_write_data): Likewise. (allocate_symtab): Likewise. * symmisc.c (maintenance_expand_file_matcher): Likewise. * symtab.c (lookup_symtab_callback): Likewise. (hash_demangled_name_entry): Likewise. (eq_demangled_name_entry): Likewise. (get_symbol_cache): Likewise. (symbol_cache_cleanup): Likewise. (set_symbol_cache_size): Likewise. (symbol_cache_flush): Likewise. (maintenance_print_symbol_cache): Likewise. (maintenance_print_symbol_cache_statistics): Likewise. (delete_filename_seen_cache): Likewise. (output_partial_symbol_filename): Likewise. (search_symbols_file_matches): Likewise. (search_symbols_name_matches): Likewise. (do_free_completion_list): Likewise. (maybe_add_partial_symtab_filename): Likewise. (get_main_info): Likewise. (main_info_cleanup): Likewise. * target-dcache.c (target_dcache_cleanup): Likewise. (target_dcache_init_p): Likewise. (target_dcache_invalidate): Likewise. (target_dcache_get): Likewise. (target_dcache_get_or_init): Likewise. * target-descriptions.c (target_find_description): Likewise. (tdesc_find_type): Likewise. (tdesc_data_cleanup): Likewise. (tdesc_find_arch_register): Likewise. (tdesc_register_name): Likewise. (tdesc_register_type): Likewise. (tdesc_register_reggroup_p): Likewise. (set_tdesc_pseudo_register_name): Likewise. (set_tdesc_pseudo_register_type): Likewise. (set_tdesc_pseudo_register_reggroup_p): Likewise. (tdesc_use_registers): Likewise. (free_target_description): Likewise. * target-memory.c (compare_block_starting_address): Likewise. (cleanup_request_data): Likewise. (cleanup_write_requests_vector): Likewise. * target.c (open_target): Likewise. (cleanup_restore_target_terminal): Likewise. (free_memory_read_result_vector): Likewise. * thread.c (disable_thread_stack_temporaries): Likewise. (finish_thread_state_cleanup): Likewise. (do_restore_current_thread_cleanup): Likewise. (restore_current_thread_cleanup_dtor): Likewise. (set_thread_refcount): Likewise. (tp_array_compar): Likewise. (do_captured_thread_select): Likewise. * tic6x-tdep.c (tic6x_frame_unwind_cache): Likewise. (tic6x_stub_this_id): Likewise. * tilegx-tdep.c (tilegx_frame_cache): Likewise. * top.c (do_restore_instream_cleanup): Likewise. (gdb_readline_wrapper_cleanup): Likewise. (kill_or_detach): Likewise. (print_inferior_quit_action): Likewise. * tracefile-tfile.c (match_blocktype): Likewise. (build_traceframe_info): Likewise. * tracefile.c (trace_file_writer_xfree): Likewise. * tracepoint.c (memrange_cmp): Likewise. (do_collect_symbol): Likewise. (do_clear_collection_list): Likewise. (do_restore_current_traceframe_cleanup): Likewise. (restore_current_traceframe_cleanup_dtor): Likewise. (free_current_marker): Likewise. (traceframe_info_start_memory): Likewise. (traceframe_info_start_tvar): Likewise. (free_result): Likewise. * tramp-frame.c (tramp_frame_cache): Likewise. * tui/tui-file.c (tui_file_delete): Likewise. (tui_fileopen): Likewise. (tui_sfileopen): Likewise. (tui_file_isatty): Likewise. (tui_file_rewind): Likewise. (tui_file_put): Likewise. (tui_file_fputs): Likewise. (tui_file_get_strbuf): Likewise. (tui_file_adjust_strbuf): Likewise. (tui_file_flush): Likewise. * tui/tui-layout.c (make_command_window): Likewise. (make_data_window): Likewise. (show_source_disasm_command): Likewise. (show_data): Likewise. (make_source_or_disasm_window): Likewise. (show_source_or_disasm_and_command): Likewise. * tui/tui-out.c (tui_field_int): Likewise. (tui_field_string): Likewise. (tui_field_fmt): Likewise. (tui_text): Likewise. * typeprint.c (hash_typedef_field): Likewise. (eq_typedef_field): Likewise. (do_free_typedef_hash): Likewise. (copy_typedef_hash_element): Likewise. (do_free_global_table): Likewise. (find_global_typedef): Likewise. (find_typedef_in_hash): Likewise. * ui-file.c (ui_file_write_for_put): Likewise. (do_ui_file_xstrdup): Likewise. (mem_file_delete): Likewise. (mem_file_rewind): Likewise. (mem_file_put): Likewise. (mem_file_write): Likewise. (stdio_file_delete): Likewise. (stdio_file_flush): Likewise. (stdio_file_read): Likewise. (stdio_file_write): Likewise. (stdio_file_write_async_safe): Likewise. (stdio_file_fputs): Likewise. (stdio_file_isatty): Likewise. (stdio_file_fseek): Likewise. (tee_file_delete): Likewise. (tee_file_flush): Likewise. (tee_file_write): Likewise. (tee_file_fputs): Likewise. (tee_file_isatty): Likewise. * ui-out.c (do_cleanup_table_end): Likewise. (do_cleanup_end): Likewise. * user-regs.c (user_reg_add): Likewise. (user_reg_map_name_to_regnum): Likewise. (usernum_to_user_reg): Likewise. (maintenance_print_user_registers): Likewise. * utils.c (do_bfd_close_cleanup): Likewise. (do_fclose_cleanup): Likewise. (do_obstack_free): Likewise. (do_ui_file_delete): Likewise. (do_ui_out_redirect_pop): Likewise. (do_free_section_addr_info): Likewise. (restore_integer): Likewise. (do_unpush_target): Likewise. (do_htab_delete_cleanup): Likewise. (do_restore_ui_file): Likewise. (do_value_free): Likewise. (do_free_so): Likewise. (free_current_contents): Likewise. (do_regfree_cleanup): Likewise. (core_addr_hash): Likewise. (core_addr_eq): Likewise. (do_free_char_ptr_vec): Likewise. * v850-tdep.c (v850_frame_cache): Likewise. * varobj.c (do_free_variable_cleanup): Likewise. * vax-tdep.c (vax_supply_gregset): Likewise. (vax_frame_cache): Likewise. * vaxobsd-tdep.c (vaxobsd_sigtramp_frame_cache): Likewise. * xml-support.c (gdb_xml_body_text): Likewise. (gdb_xml_values_cleanup): Likewise. (gdb_xml_start_element): Likewise. (gdb_xml_start_element_wrapper): Likewise. (gdb_xml_end_element): Likewise. (gdb_xml_end_element_wrapper): Likewise. (gdb_xml_cleanup): Likewise. (gdb_xml_fetch_external_entity): Likewise. (gdb_xml_parse_attr_enum): Likewise. (xinclude_start_include): Likewise. (xinclude_end_include): Likewise. (xml_xinclude_default): Likewise. (xml_xinclude_start_doctype): Likewise. (xml_xinclude_end_doctype): Likewise. (xml_xinclude_cleanup): Likewise. (xml_fetch_content_from_file): Likewise. * xml-syscall.c (free_syscalls_info): Likewise. (syscall_start_syscall): Likewise. * xml-tdesc.c (tdesc_end_arch): Likewise. (tdesc_end_osabi): Likewise. (tdesc_end_compatible): Likewise. (tdesc_start_target): Likewise. (tdesc_start_feature): Likewise. (tdesc_start_reg): Likewise. (tdesc_start_union): Likewise. (tdesc_start_struct): Likewise. (tdesc_start_flags): Likewise. (tdesc_start_field): Likewise. (tdesc_start_vector): Likewise. (fetch_available_features_from_target): Likewise. * xstormy16-tdep.c (xstormy16_frame_cache): Likewise. * xtensa-tdep.c (xtensa_supply_gregset): Likewise. (xtensa_frame_cache): Likewise. (xtensa_frame_prev_register): Likewise. (xtensa_extract_return_value): Likewise.
2102 lines
54 KiB
C
2102 lines
54 KiB
C
/* General python/gdb code
|
||
|
||
Copyright (C) 2008-2015 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
#include "defs.h"
|
||
#include "arch-utils.h"
|
||
#include "command.h"
|
||
#include "ui-out.h"
|
||
#include "cli/cli-script.h"
|
||
#include "gdbcmd.h"
|
||
#include "progspace.h"
|
||
#include "objfiles.h"
|
||
#include "value.h"
|
||
#include "language.h"
|
||
#include "event-loop.h"
|
||
#include "serial.h"
|
||
#include "readline/tilde.h"
|
||
#include "python.h"
|
||
#include "extension-priv.h"
|
||
#include "cli/cli-utils.h"
|
||
#include <ctype.h>
|
||
#include "location.h"
|
||
|
||
/* Declared constants and enum for python stack printing. */
|
||
static const char python_excp_none[] = "none";
|
||
static const char python_excp_full[] = "full";
|
||
static const char python_excp_message[] = "message";
|
||
|
||
/* "set python print-stack" choices. */
|
||
static const char *const python_excp_enums[] =
|
||
{
|
||
python_excp_none,
|
||
python_excp_full,
|
||
python_excp_message,
|
||
NULL
|
||
};
|
||
|
||
/* The exception printing variable. 'full' if we want to print the
|
||
error message and stack, 'none' if we want to print nothing, and
|
||
'message' if we only want to print the error message. 'message' is
|
||
the default. */
|
||
static const char *gdbpy_should_print_stack = python_excp_message;
|
||
|
||
#ifdef HAVE_PYTHON
|
||
/* Forward decls, these are defined later. */
|
||
extern const struct extension_language_script_ops python_extension_script_ops;
|
||
extern const struct extension_language_ops python_extension_ops;
|
||
#endif
|
||
|
||
/* The main struct describing GDB's interface to the Python
|
||
extension language. */
|
||
const struct extension_language_defn extension_language_python =
|
||
{
|
||
EXT_LANG_PYTHON,
|
||
"python",
|
||
"Python",
|
||
|
||
".py",
|
||
"-gdb.py",
|
||
|
||
python_control,
|
||
|
||
#ifdef HAVE_PYTHON
|
||
&python_extension_script_ops,
|
||
&python_extension_ops
|
||
#else
|
||
NULL,
|
||
NULL
|
||
#endif
|
||
};
|
||
|
||
#ifdef HAVE_PYTHON
|
||
|
||
#include "cli/cli-decode.h"
|
||
#include "charset.h"
|
||
#include "top.h"
|
||
#include "solib.h"
|
||
#include "python-internal.h"
|
||
#include "linespec.h"
|
||
#include "source.h"
|
||
#include "version.h"
|
||
#include "target.h"
|
||
#include "gdbthread.h"
|
||
#include "interps.h"
|
||
#include "event-top.h"
|
||
|
||
/* True if Python has been successfully initialized, false
|
||
otherwise. */
|
||
|
||
int gdb_python_initialized;
|
||
|
||
extern PyMethodDef python_GdbMethods[];
|
||
|
||
#ifdef IS_PY3K
|
||
extern struct PyModuleDef python_GdbModuleDef;
|
||
#endif
|
||
|
||
PyObject *gdb_module;
|
||
PyObject *gdb_python_module;
|
||
|
||
/* Some string constants we may wish to use. */
|
||
PyObject *gdbpy_to_string_cst;
|
||
PyObject *gdbpy_children_cst;
|
||
PyObject *gdbpy_display_hint_cst;
|
||
PyObject *gdbpy_doc_cst;
|
||
PyObject *gdbpy_enabled_cst;
|
||
PyObject *gdbpy_value_cst;
|
||
|
||
/* The GdbError exception. */
|
||
PyObject *gdbpy_gdberror_exc;
|
||
|
||
/* The `gdb.error' base class. */
|
||
PyObject *gdbpy_gdb_error;
|
||
|
||
/* The `gdb.MemoryError' exception. */
|
||
PyObject *gdbpy_gdb_memory_error;
|
||
|
||
static script_sourcer_func gdbpy_source_script;
|
||
static objfile_script_sourcer_func gdbpy_source_objfile_script;
|
||
static objfile_script_executor_func gdbpy_execute_objfile_script;
|
||
static void gdbpy_finish_initialization
|
||
(const struct extension_language_defn *);
|
||
static int gdbpy_initialized (const struct extension_language_defn *);
|
||
static void gdbpy_eval_from_control_command
|
||
(const struct extension_language_defn *, struct command_line *cmd);
|
||
static void gdbpy_start_type_printers (const struct extension_language_defn *,
|
||
struct ext_lang_type_printers *);
|
||
static enum ext_lang_rc gdbpy_apply_type_printers
|
||
(const struct extension_language_defn *,
|
||
const struct ext_lang_type_printers *, struct type *, char **);
|
||
static void gdbpy_free_type_printers (const struct extension_language_defn *,
|
||
struct ext_lang_type_printers *);
|
||
static void gdbpy_clear_quit_flag (const struct extension_language_defn *);
|
||
static void gdbpy_set_quit_flag (const struct extension_language_defn *);
|
||
static int gdbpy_check_quit_flag (const struct extension_language_defn *);
|
||
static enum ext_lang_rc gdbpy_before_prompt_hook
|
||
(const struct extension_language_defn *, const char *current_gdb_prompt);
|
||
|
||
/* The interface between gdb proper and loading of python scripts. */
|
||
|
||
const struct extension_language_script_ops python_extension_script_ops =
|
||
{
|
||
gdbpy_source_script,
|
||
gdbpy_source_objfile_script,
|
||
gdbpy_execute_objfile_script,
|
||
gdbpy_auto_load_enabled
|
||
};
|
||
|
||
/* The interface between gdb proper and python extensions. */
|
||
|
||
const struct extension_language_ops python_extension_ops =
|
||
{
|
||
gdbpy_finish_initialization,
|
||
gdbpy_initialized,
|
||
|
||
gdbpy_eval_from_control_command,
|
||
|
||
gdbpy_start_type_printers,
|
||
gdbpy_apply_type_printers,
|
||
gdbpy_free_type_printers,
|
||
|
||
gdbpy_apply_val_pretty_printer,
|
||
|
||
gdbpy_apply_frame_filter,
|
||
|
||
gdbpy_preserve_values,
|
||
|
||
gdbpy_breakpoint_has_cond,
|
||
gdbpy_breakpoint_cond_says_stop,
|
||
|
||
gdbpy_clear_quit_flag,
|
||
gdbpy_set_quit_flag,
|
||
gdbpy_check_quit_flag,
|
||
|
||
gdbpy_before_prompt_hook,
|
||
|
||
gdbpy_clone_xmethod_worker_data,
|
||
gdbpy_free_xmethod_worker_data,
|
||
gdbpy_get_matching_xmethod_workers,
|
||
gdbpy_get_xmethod_arg_types,
|
||
gdbpy_get_xmethod_result_type,
|
||
gdbpy_invoke_xmethod
|
||
};
|
||
|
||
/* Architecture and language to be used in callbacks from
|
||
the Python interpreter. */
|
||
struct gdbarch *python_gdbarch;
|
||
const struct language_defn *python_language;
|
||
|
||
/* Restore global language and architecture and Python GIL state
|
||
when leaving the Python interpreter. */
|
||
|
||
struct python_env
|
||
{
|
||
struct active_ext_lang_state *previous_active;
|
||
PyGILState_STATE state;
|
||
struct gdbarch *gdbarch;
|
||
const struct language_defn *language;
|
||
PyObject *error_type, *error_value, *error_traceback;
|
||
};
|
||
|
||
static void
|
||
restore_python_env (void *p)
|
||
{
|
||
struct python_env *env = (struct python_env *)p;
|
||
|
||
/* Leftover Python error is forbidden by Python Exception Handling. */
|
||
if (PyErr_Occurred ())
|
||
{
|
||
/* This order is similar to the one calling error afterwards. */
|
||
gdbpy_print_stack ();
|
||
warning (_("internal error: Unhandled Python exception"));
|
||
}
|
||
|
||
PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
|
||
|
||
PyGILState_Release (env->state);
|
||
python_gdbarch = env->gdbarch;
|
||
python_language = env->language;
|
||
|
||
restore_active_ext_lang (env->previous_active);
|
||
|
||
xfree (env);
|
||
}
|
||
|
||
/* Called before entering the Python interpreter to install the
|
||
current language and architecture to be used for Python values.
|
||
Also set the active extension language for GDB so that SIGINT's
|
||
are directed our way, and if necessary install the right SIGINT
|
||
handler. */
|
||
|
||
struct cleanup *
|
||
ensure_python_env (struct gdbarch *gdbarch,
|
||
const struct language_defn *language)
|
||
{
|
||
struct python_env *env = XNEW (struct python_env);
|
||
|
||
/* We should not ever enter Python unless initialized. */
|
||
if (!gdb_python_initialized)
|
||
error (_("Python not initialized"));
|
||
|
||
env->previous_active = set_active_ext_lang (&extension_language_python);
|
||
|
||
env->state = PyGILState_Ensure ();
|
||
env->gdbarch = python_gdbarch;
|
||
env->language = python_language;
|
||
|
||
python_gdbarch = gdbarch;
|
||
python_language = language;
|
||
|
||
/* Save it and ensure ! PyErr_Occurred () afterwards. */
|
||
PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
|
||
|
||
return make_cleanup (restore_python_env, env);
|
||
}
|
||
|
||
/* Clear the quit flag. */
|
||
|
||
static void
|
||
gdbpy_clear_quit_flag (const struct extension_language_defn *extlang)
|
||
{
|
||
/* This clears the flag as a side effect. */
|
||
PyOS_InterruptOccurred ();
|
||
}
|
||
|
||
/* Set the quit flag. */
|
||
|
||
static void
|
||
gdbpy_set_quit_flag (const struct extension_language_defn *extlang)
|
||
{
|
||
PyErr_SetInterrupt ();
|
||
}
|
||
|
||
/* Return true if the quit flag has been set, false otherwise. */
|
||
|
||
static int
|
||
gdbpy_check_quit_flag (const struct extension_language_defn *extlang)
|
||
{
|
||
return PyOS_InterruptOccurred ();
|
||
}
|
||
|
||
/* Evaluate a Python command like PyRun_SimpleString, but uses
|
||
Py_single_input which prints the result of expressions, and does
|
||
not automatically print the stack on errors. */
|
||
|
||
static int
|
||
eval_python_command (const char *command)
|
||
{
|
||
PyObject *m, *d, *v;
|
||
|
||
m = PyImport_AddModule ("__main__");
|
||
if (m == NULL)
|
||
return -1;
|
||
|
||
d = PyModule_GetDict (m);
|
||
if (d == NULL)
|
||
return -1;
|
||
v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
|
||
if (v == NULL)
|
||
return -1;
|
||
|
||
Py_DECREF (v);
|
||
#ifndef IS_PY3K
|
||
if (Py_FlushLine ())
|
||
PyErr_Clear ();
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
/* Implementation of the gdb "python-interactive" command. */
|
||
|
||
static void
|
||
python_interactive_command (char *arg, int from_tty)
|
||
{
|
||
struct cleanup *cleanup;
|
||
int err;
|
||
|
||
cleanup = make_cleanup_restore_integer (&interpreter_async);
|
||
interpreter_async = 0;
|
||
|
||
arg = skip_spaces (arg);
|
||
|
||
ensure_python_env (get_current_arch (), current_language);
|
||
|
||
if (arg && *arg)
|
||
{
|
||
int len = strlen (arg);
|
||
char *script = (char *) xmalloc (len + 2);
|
||
|
||
strcpy (script, arg);
|
||
script[len] = '\n';
|
||
script[len + 1] = '\0';
|
||
err = eval_python_command (script);
|
||
xfree (script);
|
||
}
|
||
else
|
||
{
|
||
err = PyRun_InteractiveLoop (instream, "<stdin>");
|
||
dont_repeat ();
|
||
}
|
||
|
||
if (err)
|
||
{
|
||
gdbpy_print_stack ();
|
||
error (_("Error while executing Python code."));
|
||
}
|
||
|
||
do_cleanups (cleanup);
|
||
}
|
||
|
||
/* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
|
||
named FILENAME.
|
||
|
||
On Windows hosts few users would build Python themselves (this is no
|
||
trivial task on this platform), and thus use binaries built by
|
||
someone else instead. There may happen situation where the Python
|
||
library and GDB are using two different versions of the C runtime
|
||
library. Python, being built with VC, would use one version of the
|
||
msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
|
||
A FILE * from one runtime does not necessarily operate correctly in
|
||
the other runtime.
|
||
|
||
To work around this potential issue, we create on Windows hosts the
|
||
FILE object using Python routines, thus making sure that it is
|
||
compatible with the Python library. */
|
||
|
||
static void
|
||
python_run_simple_file (FILE *file, const char *filename)
|
||
{
|
||
#ifndef _WIN32
|
||
|
||
PyRun_SimpleFile (file, filename);
|
||
|
||
#else /* _WIN32 */
|
||
|
||
char *full_path;
|
||
PyObject *python_file;
|
||
struct cleanup *cleanup;
|
||
|
||
/* Because we have a string for a filename, and are using Python to
|
||
open the file, we need to expand any tilde in the path first. */
|
||
full_path = tilde_expand (filename);
|
||
cleanup = make_cleanup (xfree, full_path);
|
||
python_file = PyFile_FromString (full_path, "r");
|
||
if (! python_file)
|
||
{
|
||
do_cleanups (cleanup);
|
||
gdbpy_print_stack ();
|
||
error (_("Error while opening file: %s"), full_path);
|
||
}
|
||
|
||
make_cleanup_py_decref (python_file);
|
||
PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
|
||
do_cleanups (cleanup);
|
||
|
||
#endif /* _WIN32 */
|
||
}
|
||
|
||
/* Given a command_line, return a command string suitable for passing
|
||
to Python. Lines in the string are separated by newlines. The
|
||
return value is allocated using xmalloc and the caller is
|
||
responsible for freeing it. */
|
||
|
||
static char *
|
||
compute_python_string (struct command_line *l)
|
||
{
|
||
struct command_line *iter;
|
||
char *script = NULL;
|
||
int size = 0;
|
||
int here;
|
||
|
||
for (iter = l; iter; iter = iter->next)
|
||
size += strlen (iter->line) + 1;
|
||
|
||
script = (char *) xmalloc (size + 1);
|
||
here = 0;
|
||
for (iter = l; iter; iter = iter->next)
|
||
{
|
||
int len = strlen (iter->line);
|
||
|
||
strcpy (&script[here], iter->line);
|
||
here += len;
|
||
script[here++] = '\n';
|
||
}
|
||
script[here] = '\0';
|
||
return script;
|
||
}
|
||
|
||
/* Take a command line structure representing a 'python' command, and
|
||
evaluate its body using the Python interpreter. */
|
||
|
||
static void
|
||
gdbpy_eval_from_control_command (const struct extension_language_defn *extlang,
|
||
struct command_line *cmd)
|
||
{
|
||
int ret;
|
||
char *script;
|
||
struct cleanup *cleanup;
|
||
|
||
if (cmd->body_count != 1)
|
||
error (_("Invalid \"python\" block structure."));
|
||
|
||
cleanup = ensure_python_env (get_current_arch (), current_language);
|
||
|
||
script = compute_python_string (cmd->body_list[0]);
|
||
ret = PyRun_SimpleString (script);
|
||
xfree (script);
|
||
if (ret)
|
||
error (_("Error while executing Python code."));
|
||
|
||
do_cleanups (cleanup);
|
||
}
|
||
|
||
/* Implementation of the gdb "python" command. */
|
||
|
||
static void
|
||
python_command (char *arg, int from_tty)
|
||
{
|
||
struct cleanup *cleanup;
|
||
|
||
cleanup = ensure_python_env (get_current_arch (), current_language);
|
||
|
||
make_cleanup_restore_integer (&interpreter_async);
|
||
interpreter_async = 0;
|
||
|
||
arg = skip_spaces (arg);
|
||
if (arg && *arg)
|
||
{
|
||
if (PyRun_SimpleString (arg))
|
||
error (_("Error while executing Python code."));
|
||
}
|
||
else
|
||
{
|
||
struct command_line *l = get_command_line (python_control, "");
|
||
|
||
make_cleanup_free_command_lines (&l);
|
||
execute_control_command_untraced (l);
|
||
}
|
||
|
||
do_cleanups (cleanup);
|
||
}
|
||
|
||
|
||
|
||
/* Transform a gdb parameters's value into a Python value. May return
|
||
NULL (and set a Python exception) on error. Helper function for
|
||
get_parameter. */
|
||
PyObject *
|
||
gdbpy_parameter_value (enum var_types type, void *var)
|
||
{
|
||
switch (type)
|
||
{
|
||
case var_string:
|
||
case var_string_noescape:
|
||
case var_optional_filename:
|
||
case var_filename:
|
||
case var_enum:
|
||
{
|
||
char *str = * (char **) var;
|
||
|
||
if (! str)
|
||
str = "";
|
||
return PyString_Decode (str, strlen (str), host_charset (), NULL);
|
||
}
|
||
|
||
case var_boolean:
|
||
{
|
||
if (* (int *) var)
|
||
Py_RETURN_TRUE;
|
||
else
|
||
Py_RETURN_FALSE;
|
||
}
|
||
|
||
case var_auto_boolean:
|
||
{
|
||
enum auto_boolean ab = * (enum auto_boolean *) var;
|
||
|
||
if (ab == AUTO_BOOLEAN_TRUE)
|
||
Py_RETURN_TRUE;
|
||
else if (ab == AUTO_BOOLEAN_FALSE)
|
||
Py_RETURN_FALSE;
|
||
else
|
||
Py_RETURN_NONE;
|
||
}
|
||
|
||
case var_integer:
|
||
if ((* (int *) var) == INT_MAX)
|
||
Py_RETURN_NONE;
|
||
/* Fall through. */
|
||
case var_zinteger:
|
||
return PyLong_FromLong (* (int *) var);
|
||
|
||
case var_uinteger:
|
||
{
|
||
unsigned int val = * (unsigned int *) var;
|
||
|
||
if (val == UINT_MAX)
|
||
Py_RETURN_NONE;
|
||
return PyLong_FromUnsignedLong (val);
|
||
}
|
||
}
|
||
|
||
return PyErr_Format (PyExc_RuntimeError,
|
||
_("Programmer error: unhandled type."));
|
||
}
|
||
|
||
/* A Python function which returns a gdb parameter's value as a Python
|
||
value. */
|
||
|
||
PyObject *
|
||
gdbpy_parameter (PyObject *self, PyObject *args)
|
||
{
|
||
struct gdb_exception except = exception_none;
|
||
struct cmd_list_element *alias, *prefix, *cmd;
|
||
const char *arg;
|
||
char *newarg;
|
||
int found = -1;
|
||
|
||
if (! PyArg_ParseTuple (args, "s", &arg))
|
||
return NULL;
|
||
|
||
newarg = concat ("show ", arg, (char *) NULL);
|
||
|
||
TRY
|
||
{
|
||
found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
|
||
}
|
||
CATCH (ex, RETURN_MASK_ALL)
|
||
{
|
||
except = ex;
|
||
}
|
||
END_CATCH
|
||
|
||
xfree (newarg);
|
||
GDB_PY_HANDLE_EXCEPTION (except);
|
||
if (!found)
|
||
return PyErr_Format (PyExc_RuntimeError,
|
||
_("Could not find parameter `%s'."), arg);
|
||
|
||
if (! cmd->var)
|
||
return PyErr_Format (PyExc_RuntimeError,
|
||
_("`%s' is not a parameter."), arg);
|
||
return gdbpy_parameter_value (cmd->var_type, cmd->var);
|
||
}
|
||
|
||
/* Wrapper for target_charset. */
|
||
|
||
static PyObject *
|
||
gdbpy_target_charset (PyObject *self, PyObject *args)
|
||
{
|
||
const char *cset = target_charset (python_gdbarch);
|
||
|
||
return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
|
||
}
|
||
|
||
/* Wrapper for target_wide_charset. */
|
||
|
||
static PyObject *
|
||
gdbpy_target_wide_charset (PyObject *self, PyObject *args)
|
||
{
|
||
const char *cset = target_wide_charset (python_gdbarch);
|
||
|
||
return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
|
||
}
|
||
|
||
/* A Python function which evaluates a string using the gdb CLI. */
|
||
|
||
static PyObject *
|
||
execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
|
||
{
|
||
const char *arg;
|
||
PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
|
||
int from_tty, to_string;
|
||
static char *keywords[] = {"command", "from_tty", "to_string", NULL };
|
||
char *result = NULL;
|
||
|
||
if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
|
||
&PyBool_Type, &from_tty_obj,
|
||
&PyBool_Type, &to_string_obj))
|
||
return NULL;
|
||
|
||
from_tty = 0;
|
||
if (from_tty_obj)
|
||
{
|
||
int cmp = PyObject_IsTrue (from_tty_obj);
|
||
if (cmp < 0)
|
||
return NULL;
|
||
from_tty = cmp;
|
||
}
|
||
|
||
to_string = 0;
|
||
if (to_string_obj)
|
||
{
|
||
int cmp = PyObject_IsTrue (to_string_obj);
|
||
if (cmp < 0)
|
||
return NULL;
|
||
to_string = cmp;
|
||
}
|
||
|
||
TRY
|
||
{
|
||
/* Copy the argument text in case the command modifies it. */
|
||
char *copy = xstrdup (arg);
|
||
struct cleanup *cleanup = make_cleanup (xfree, copy);
|
||
|
||
make_cleanup_restore_integer (&interpreter_async);
|
||
interpreter_async = 0;
|
||
|
||
prevent_dont_repeat ();
|
||
if (to_string)
|
||
result = execute_command_to_string (copy, from_tty);
|
||
else
|
||
{
|
||
result = NULL;
|
||
execute_command (copy, from_tty);
|
||
}
|
||
|
||
do_cleanups (cleanup);
|
||
}
|
||
CATCH (except, RETURN_MASK_ALL)
|
||
{
|
||
GDB_PY_HANDLE_EXCEPTION (except);
|
||
}
|
||
END_CATCH
|
||
|
||
/* Do any commands attached to breakpoint we stopped at. */
|
||
bpstat_do_actions ();
|
||
|
||
if (result)
|
||
{
|
||
PyObject *r = PyString_FromString (result);
|
||
xfree (result);
|
||
return r;
|
||
}
|
||
Py_RETURN_NONE;
|
||
}
|
||
|
||
/* Implementation of gdb.solib_name (Long) -> String.
|
||
Returns the name of the shared library holding a given address, or None. */
|
||
|
||
static PyObject *
|
||
gdbpy_solib_name (PyObject *self, PyObject *args)
|
||
{
|
||
char *soname;
|
||
PyObject *str_obj;
|
||
gdb_py_longest pc;
|
||
|
||
if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
|
||
return NULL;
|
||
|
||
soname = solib_name_from_address (current_program_space, pc);
|
||
if (soname)
|
||
str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
|
||
else
|
||
{
|
||
str_obj = Py_None;
|
||
Py_INCREF (Py_None);
|
||
}
|
||
|
||
return str_obj;
|
||
}
|
||
|
||
/* A Python function which is a wrapper for decode_line_1. */
|
||
|
||
static PyObject *
|
||
gdbpy_decode_line (PyObject *self, PyObject *args)
|
||
{
|
||
struct gdb_exception except = exception_none;
|
||
struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
|
||
appease gcc. */
|
||
struct symtab_and_line sal;
|
||
char *arg = NULL;
|
||
struct cleanup *cleanups;
|
||
PyObject *result = NULL;
|
||
PyObject *return_result = NULL;
|
||
PyObject *unparsed = NULL;
|
||
struct event_location *location = NULL;
|
||
|
||
if (! PyArg_ParseTuple (args, "|s", &arg))
|
||
return NULL;
|
||
|
||
cleanups = make_cleanup (null_cleanup, NULL);
|
||
|
||
sals.sals = NULL;
|
||
|
||
if (arg != NULL)
|
||
{
|
||
location = new_linespec_location (&arg);
|
||
make_cleanup_delete_event_location (location);
|
||
}
|
||
|
||
TRY
|
||
{
|
||
if (location != NULL)
|
||
sals = decode_line_1 (location, 0, 0, 0);
|
||
else
|
||
{
|
||
set_default_source_symtab_and_line ();
|
||
sal = get_current_source_symtab_and_line ();
|
||
sals.sals = &sal;
|
||
sals.nelts = 1;
|
||
}
|
||
}
|
||
CATCH (ex, RETURN_MASK_ALL)
|
||
{
|
||
except = ex;
|
||
}
|
||
END_CATCH
|
||
|
||
if (sals.sals != NULL && sals.sals != &sal)
|
||
make_cleanup (xfree, sals.sals);
|
||
|
||
if (except.reason < 0)
|
||
{
|
||
do_cleanups (cleanups);
|
||
/* We know this will always throw. */
|
||
gdbpy_convert_exception (except);
|
||
return NULL;
|
||
}
|
||
|
||
if (sals.nelts)
|
||
{
|
||
int i;
|
||
|
||
result = PyTuple_New (sals.nelts);
|
||
if (! result)
|
||
goto error;
|
||
for (i = 0; i < sals.nelts; ++i)
|
||
{
|
||
PyObject *obj;
|
||
|
||
obj = symtab_and_line_to_sal_object (sals.sals[i]);
|
||
if (! obj)
|
||
{
|
||
Py_DECREF (result);
|
||
goto error;
|
||
}
|
||
|
||
PyTuple_SetItem (result, i, obj);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
result = Py_None;
|
||
Py_INCREF (Py_None);
|
||
}
|
||
|
||
return_result = PyTuple_New (2);
|
||
if (! return_result)
|
||
{
|
||
Py_DECREF (result);
|
||
goto error;
|
||
}
|
||
|
||
if (arg != NULL && strlen (arg) > 0)
|
||
{
|
||
unparsed = PyString_FromString (arg);
|
||
if (unparsed == NULL)
|
||
{
|
||
Py_DECREF (result);
|
||
Py_DECREF (return_result);
|
||
return_result = NULL;
|
||
goto error;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
unparsed = Py_None;
|
||
Py_INCREF (Py_None);
|
||
}
|
||
|
||
PyTuple_SetItem (return_result, 0, unparsed);
|
||
PyTuple_SetItem (return_result, 1, result);
|
||
|
||
error:
|
||
do_cleanups (cleanups);
|
||
|
||
return return_result;
|
||
}
|
||
|
||
/* Parse a string and evaluate it as an expression. */
|
||
static PyObject *
|
||
gdbpy_parse_and_eval (PyObject *self, PyObject *args)
|
||
{
|
||
const char *expr_str;
|
||
struct value *result = NULL;
|
||
|
||
if (!PyArg_ParseTuple (args, "s", &expr_str))
|
||
return NULL;
|
||
|
||
TRY
|
||
{
|
||
result = parse_and_eval (expr_str);
|
||
}
|
||
CATCH (except, RETURN_MASK_ALL)
|
||
{
|
||
GDB_PY_HANDLE_EXCEPTION (except);
|
||
}
|
||
END_CATCH
|
||
|
||
return value_to_value_object (result);
|
||
}
|
||
|
||
/* Implementation of gdb.find_pc_line function.
|
||
Returns the gdb.Symtab_and_line object corresponding to a PC value. */
|
||
|
||
static PyObject *
|
||
gdbpy_find_pc_line (PyObject *self, PyObject *args)
|
||
{
|
||
gdb_py_ulongest pc_llu;
|
||
PyObject *result = NULL; /* init for gcc -Wall */
|
||
|
||
if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
|
||
return NULL;
|
||
|
||
TRY
|
||
{
|
||
struct symtab_and_line sal;
|
||
CORE_ADDR pc;
|
||
|
||
pc = (CORE_ADDR) pc_llu;
|
||
sal = find_pc_line (pc, 0);
|
||
result = symtab_and_line_to_sal_object (sal);
|
||
}
|
||
CATCH (except, RETURN_MASK_ALL)
|
||
{
|
||
GDB_PY_HANDLE_EXCEPTION (except);
|
||
}
|
||
END_CATCH
|
||
|
||
return result;
|
||
}
|
||
|
||
/* Read a file as Python code.
|
||
This is the extension_language_script_ops.script_sourcer "method".
|
||
FILE is the file to load. FILENAME is name of the file FILE.
|
||
This does not throw any errors. If an exception occurs python will print
|
||
the traceback and clear the error indicator. */
|
||
|
||
static void
|
||
gdbpy_source_script (const struct extension_language_defn *extlang,
|
||
FILE *file, const char *filename)
|
||
{
|
||
struct cleanup *cleanup;
|
||
|
||
cleanup = ensure_python_env (get_current_arch (), current_language);
|
||
python_run_simple_file (file, filename);
|
||
do_cleanups (cleanup);
|
||
}
|
||
|
||
|
||
|
||
/* Posting and handling events. */
|
||
|
||
/* A single event. */
|
||
struct gdbpy_event
|
||
{
|
||
/* The Python event. This is just a callable object. */
|
||
PyObject *event;
|
||
/* The next event. */
|
||
struct gdbpy_event *next;
|
||
};
|
||
|
||
/* All pending events. */
|
||
static struct gdbpy_event *gdbpy_event_list;
|
||
/* The final link of the event list. */
|
||
static struct gdbpy_event **gdbpy_event_list_end;
|
||
|
||
/* We use a file handler, and not an async handler, so that we can
|
||
wake up the main thread even when it is blocked in poll(). */
|
||
static struct serial *gdbpy_event_fds[2];
|
||
|
||
/* The file handler callback. This reads from the internal pipe, and
|
||
then processes the Python event queue. This will always be run in
|
||
the main gdb thread. */
|
||
|
||
static void
|
||
gdbpy_run_events (struct serial *scb, void *context)
|
||
{
|
||
struct cleanup *cleanup;
|
||
|
||
cleanup = ensure_python_env (get_current_arch (), current_language);
|
||
|
||
/* Flush the fd. Do this before flushing the events list, so that
|
||
any new event post afterwards is sure to re-awake the event
|
||
loop. */
|
||
while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
|
||
;
|
||
|
||
while (gdbpy_event_list)
|
||
{
|
||
PyObject *call_result;
|
||
|
||
/* Dispatching the event might push a new element onto the event
|
||
loop, so we update here "atomically enough". */
|
||
struct gdbpy_event *item = gdbpy_event_list;
|
||
gdbpy_event_list = gdbpy_event_list->next;
|
||
if (gdbpy_event_list == NULL)
|
||
gdbpy_event_list_end = &gdbpy_event_list;
|
||
|
||
/* Ignore errors. */
|
||
call_result = PyObject_CallObject (item->event, NULL);
|
||
if (call_result == NULL)
|
||
PyErr_Clear ();
|
||
|
||
Py_XDECREF (call_result);
|
||
Py_DECREF (item->event);
|
||
xfree (item);
|
||
}
|
||
|
||
do_cleanups (cleanup);
|
||
}
|
||
|
||
/* Submit an event to the gdb thread. */
|
||
static PyObject *
|
||
gdbpy_post_event (PyObject *self, PyObject *args)
|
||
{
|
||
struct gdbpy_event *event;
|
||
PyObject *func;
|
||
int wakeup;
|
||
|
||
if (!PyArg_ParseTuple (args, "O", &func))
|
||
return NULL;
|
||
|
||
if (!PyCallable_Check (func))
|
||
{
|
||
PyErr_SetString (PyExc_RuntimeError,
|
||
_("Posted event is not callable"));
|
||
return NULL;
|
||
}
|
||
|
||
Py_INCREF (func);
|
||
|
||
/* From here until the end of the function, we have the GIL, so we
|
||
can operate on our global data structures without worrying. */
|
||
wakeup = gdbpy_event_list == NULL;
|
||
|
||
event = XNEW (struct gdbpy_event);
|
||
event->event = func;
|
||
event->next = NULL;
|
||
*gdbpy_event_list_end = event;
|
||
gdbpy_event_list_end = &event->next;
|
||
|
||
/* Wake up gdb when needed. */
|
||
if (wakeup)
|
||
{
|
||
char c = 'q'; /* Anything. */
|
||
|
||
if (serial_write (gdbpy_event_fds[1], &c, 1))
|
||
return PyErr_SetFromErrno (PyExc_IOError);
|
||
}
|
||
|
||
Py_RETURN_NONE;
|
||
}
|
||
|
||
/* Initialize the Python event handler. */
|
||
static int
|
||
gdbpy_initialize_events (void)
|
||
{
|
||
if (serial_pipe (gdbpy_event_fds) == 0)
|
||
{
|
||
gdbpy_event_list_end = &gdbpy_event_list;
|
||
serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
/* This is the extension_language_ops.before_prompt "method". */
|
||
|
||
static enum ext_lang_rc
|
||
gdbpy_before_prompt_hook (const struct extension_language_defn *extlang,
|
||
const char *current_gdb_prompt)
|
||
{
|
||
struct cleanup *cleanup;
|
||
char *prompt = NULL;
|
||
|
||
if (!gdb_python_initialized)
|
||
return EXT_LANG_RC_NOP;
|
||
|
||
cleanup = ensure_python_env (get_current_arch (), current_language);
|
||
|
||
if (gdb_python_module
|
||
&& PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
|
||
{
|
||
PyObject *hook;
|
||
|
||
hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook");
|
||
if (hook == NULL)
|
||
goto fail;
|
||
|
||
make_cleanup_py_decref (hook);
|
||
|
||
if (PyCallable_Check (hook))
|
||
{
|
||
PyObject *result;
|
||
PyObject *current_prompt;
|
||
|
||
current_prompt = PyString_FromString (current_gdb_prompt);
|
||
if (current_prompt == NULL)
|
||
goto fail;
|
||
|
||
result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
|
||
|
||
Py_DECREF (current_prompt);
|
||
|
||
if (result == NULL)
|
||
goto fail;
|
||
|
||
make_cleanup_py_decref (result);
|
||
|
||
/* Return type should be None, or a String. If it is None,
|
||
fall through, we will not set a prompt. If it is a
|
||
string, set PROMPT. Anything else, set an exception. */
|
||
if (result != Py_None && ! PyString_Check (result))
|
||
{
|
||
PyErr_Format (PyExc_RuntimeError,
|
||
_("Return from prompt_hook must " \
|
||
"be either a Python string, or None"));
|
||
goto fail;
|
||
}
|
||
|
||
if (result != Py_None)
|
||
{
|
||
prompt = python_string_to_host_string (result);
|
||
|
||
if (prompt == NULL)
|
||
goto fail;
|
||
else
|
||
make_cleanup (xfree, prompt);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* If a prompt has been set, PROMPT will not be NULL. If it is
|
||
NULL, do not set the prompt. */
|
||
if (prompt != NULL)
|
||
set_prompt (prompt);
|
||
|
||
do_cleanups (cleanup);
|
||
return prompt != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_NOP;
|
||
|
||
fail:
|
||
gdbpy_print_stack ();
|
||
do_cleanups (cleanup);
|
||
return EXT_LANG_RC_ERROR;
|
||
}
|
||
|
||
|
||
|
||
/* Printing. */
|
||
|
||
/* A python function to write a single string using gdb's filtered
|
||
output stream . The optional keyword STREAM can be used to write
|
||
to a particular stream. The default stream is to gdb_stdout. */
|
||
|
||
static PyObject *
|
||
gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
|
||
{
|
||
const char *arg;
|
||
static char *keywords[] = {"text", "stream", NULL };
|
||
int stream_type = 0;
|
||
|
||
if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
|
||
&stream_type))
|
||
return NULL;
|
||
|
||
TRY
|
||
{
|
||
switch (stream_type)
|
||
{
|
||
case 1:
|
||
{
|
||
fprintf_filtered (gdb_stderr, "%s", arg);
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
fprintf_filtered (gdb_stdlog, "%s", arg);
|
||
break;
|
||
}
|
||
default:
|
||
fprintf_filtered (gdb_stdout, "%s", arg);
|
||
}
|
||
}
|
||
CATCH (except, RETURN_MASK_ALL)
|
||
{
|
||
GDB_PY_HANDLE_EXCEPTION (except);
|
||
}
|
||
END_CATCH
|
||
|
||
Py_RETURN_NONE;
|
||
}
|
||
|
||
/* A python function to flush a gdb stream. The optional keyword
|
||
STREAM can be used to flush a particular stream. The default stream
|
||
is gdb_stdout. */
|
||
|
||
static PyObject *
|
||
gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
|
||
{
|
||
static char *keywords[] = {"stream", NULL };
|
||
int stream_type = 0;
|
||
|
||
if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
|
||
&stream_type))
|
||
return NULL;
|
||
|
||
switch (stream_type)
|
||
{
|
||
case 1:
|
||
{
|
||
gdb_flush (gdb_stderr);
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
gdb_flush (gdb_stdlog);
|
||
break;
|
||
}
|
||
default:
|
||
gdb_flush (gdb_stdout);
|
||
}
|
||
|
||
Py_RETURN_NONE;
|
||
}
|
||
|
||
/* Return non-zero if print-stack is not "none". */
|
||
|
||
int
|
||
gdbpy_print_python_errors_p (void)
|
||
{
|
||
return gdbpy_should_print_stack != python_excp_none;
|
||
}
|
||
|
||
/* Print a python exception trace, print just a message, or print
|
||
nothing and clear the python exception, depending on
|
||
gdbpy_should_print_stack. Only call this if a python exception is
|
||
set. */
|
||
void
|
||
gdbpy_print_stack (void)
|
||
{
|
||
|
||
/* Print "none", just clear exception. */
|
||
if (gdbpy_should_print_stack == python_excp_none)
|
||
{
|
||
PyErr_Clear ();
|
||
}
|
||
/* Print "full" message and backtrace. */
|
||
else if (gdbpy_should_print_stack == python_excp_full)
|
||
{
|
||
PyErr_Print ();
|
||
/* PyErr_Print doesn't necessarily end output with a newline.
|
||
This works because Python's stdout/stderr is fed through
|
||
printf_filtered. */
|
||
TRY
|
||
{
|
||
begin_line ();
|
||
}
|
||
CATCH (except, RETURN_MASK_ALL)
|
||
{
|
||
}
|
||
END_CATCH
|
||
}
|
||
/* Print "message", just error print message. */
|
||
else
|
||
{
|
||
PyObject *ptype, *pvalue, *ptraceback;
|
||
char *msg = NULL, *type = NULL;
|
||
|
||
PyErr_Fetch (&ptype, &pvalue, &ptraceback);
|
||
|
||
/* Fetch the error message contained within ptype, pvalue. */
|
||
msg = gdbpy_exception_to_string (ptype, pvalue);
|
||
type = gdbpy_obj_to_string (ptype);
|
||
|
||
TRY
|
||
{
|
||
if (msg == NULL)
|
||
{
|
||
/* An error occurred computing the string representation of the
|
||
error message. */
|
||
fprintf_filtered (gdb_stderr,
|
||
_("Error occurred computing Python error" \
|
||
"message.\n"));
|
||
}
|
||
else
|
||
fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
|
||
type, msg);
|
||
}
|
||
CATCH (except, RETURN_MASK_ALL)
|
||
{
|
||
}
|
||
END_CATCH
|
||
|
||
Py_XDECREF (ptype);
|
||
Py_XDECREF (pvalue);
|
||
Py_XDECREF (ptraceback);
|
||
xfree (msg);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* Return the current Progspace.
|
||
There always is one. */
|
||
|
||
static PyObject *
|
||
gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
|
||
{
|
||
PyObject *result;
|
||
|
||
result = pspace_to_pspace_object (current_program_space);
|
||
if (result)
|
||
Py_INCREF (result);
|
||
return result;
|
||
}
|
||
|
||
/* Return a sequence holding all the Progspaces. */
|
||
|
||
static PyObject *
|
||
gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
|
||
{
|
||
struct program_space *ps;
|
||
PyObject *list;
|
||
|
||
list = PyList_New (0);
|
||
if (!list)
|
||
return NULL;
|
||
|
||
ALL_PSPACES (ps)
|
||
{
|
||
PyObject *item = pspace_to_pspace_object (ps);
|
||
|
||
if (!item || PyList_Append (list, item) == -1)
|
||
{
|
||
Py_DECREF (list);
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
return list;
|
||
}
|
||
|
||
|
||
|
||
/* The "current" objfile. This is set when gdb detects that a new
|
||
objfile has been loaded. It is only set for the duration of a call to
|
||
gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
|
||
at other times. */
|
||
static struct objfile *gdbpy_current_objfile;
|
||
|
||
/* Set the current objfile to OBJFILE and then read FILE named FILENAME
|
||
as Python code. This does not throw any errors. If an exception
|
||
occurs python will print the traceback and clear the error indicator.
|
||
This is the extension_language_script_ops.objfile_script_sourcer
|
||
"method". */
|
||
|
||
static void
|
||
gdbpy_source_objfile_script (const struct extension_language_defn *extlang,
|
||
struct objfile *objfile, FILE *file,
|
||
const char *filename)
|
||
{
|
||
struct cleanup *cleanups;
|
||
|
||
if (!gdb_python_initialized)
|
||
return;
|
||
|
||
cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
|
||
gdbpy_current_objfile = objfile;
|
||
|
||
python_run_simple_file (file, filename);
|
||
|
||
do_cleanups (cleanups);
|
||
gdbpy_current_objfile = NULL;
|
||
}
|
||
|
||
/* Set the current objfile to OBJFILE and then execute SCRIPT
|
||
as Python code. This does not throw any errors. If an exception
|
||
occurs python will print the traceback and clear the error indicator.
|
||
This is the extension_language_script_ops.objfile_script_executor
|
||
"method". */
|
||
|
||
static void
|
||
gdbpy_execute_objfile_script (const struct extension_language_defn *extlang,
|
||
struct objfile *objfile, const char *name,
|
||
const char *script)
|
||
{
|
||
struct cleanup *cleanups;
|
||
|
||
if (!gdb_python_initialized)
|
||
return;
|
||
|
||
cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
|
||
gdbpy_current_objfile = objfile;
|
||
|
||
PyRun_SimpleString (script);
|
||
|
||
do_cleanups (cleanups);
|
||
gdbpy_current_objfile = NULL;
|
||
}
|
||
|
||
/* Return the current Objfile, or None if there isn't one. */
|
||
|
||
static PyObject *
|
||
gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
|
||
{
|
||
PyObject *result;
|
||
|
||
if (! gdbpy_current_objfile)
|
||
Py_RETURN_NONE;
|
||
|
||
result = objfile_to_objfile_object (gdbpy_current_objfile);
|
||
if (result)
|
||
Py_INCREF (result);
|
||
return result;
|
||
}
|
||
|
||
/* Return a sequence holding all the Objfiles. */
|
||
|
||
static PyObject *
|
||
gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
|
||
{
|
||
struct objfile *objf;
|
||
PyObject *list;
|
||
|
||
list = PyList_New (0);
|
||
if (!list)
|
||
return NULL;
|
||
|
||
ALL_OBJFILES (objf)
|
||
{
|
||
PyObject *item = objfile_to_objfile_object (objf);
|
||
|
||
if (!item || PyList_Append (list, item) == -1)
|
||
{
|
||
Py_DECREF (list);
|
||
return NULL;
|
||
}
|
||
}
|
||
|
||
return list;
|
||
}
|
||
|
||
/* Compute the list of active python type printers and store them in
|
||
EXT_PRINTERS->py_type_printers. The product of this function is used by
|
||
gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
|
||
This is the extension_language_ops.start_type_printers "method". */
|
||
|
||
static void
|
||
gdbpy_start_type_printers (const struct extension_language_defn *extlang,
|
||
struct ext_lang_type_printers *ext_printers)
|
||
{
|
||
struct cleanup *cleanups;
|
||
PyObject *type_module, *func = NULL, *printers_obj = NULL;
|
||
|
||
if (!gdb_python_initialized)
|
||
return;
|
||
|
||
cleanups = ensure_python_env (get_current_arch (), current_language);
|
||
|
||
type_module = PyImport_ImportModule ("gdb.types");
|
||
if (type_module == NULL)
|
||
{
|
||
gdbpy_print_stack ();
|
||
goto done;
|
||
}
|
||
|
||
func = PyObject_GetAttrString (type_module, "get_type_recognizers");
|
||
if (func == NULL)
|
||
{
|
||
gdbpy_print_stack ();
|
||
goto done;
|
||
}
|
||
|
||
printers_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
|
||
if (printers_obj == NULL)
|
||
gdbpy_print_stack ();
|
||
else
|
||
ext_printers->py_type_printers = printers_obj;
|
||
|
||
done:
|
||
Py_XDECREF (type_module);
|
||
Py_XDECREF (func);
|
||
do_cleanups (cleanups);
|
||
}
|
||
|
||
/* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
|
||
a newly allocated string holding the type's replacement name, and return
|
||
EXT_LANG_RC_OK. The caller is responsible for freeing the string.
|
||
If there's a Python error return EXT_LANG_RC_ERROR.
|
||
Otherwise, return EXT_LANG_RC_NOP.
|
||
This is the extension_language_ops.apply_type_printers "method". */
|
||
|
||
static enum ext_lang_rc
|
||
gdbpy_apply_type_printers (const struct extension_language_defn *extlang,
|
||
const struct ext_lang_type_printers *ext_printers,
|
||
struct type *type, char **prettied_type)
|
||
{
|
||
struct cleanup *cleanups;
|
||
PyObject *type_obj, *type_module = NULL, *func = NULL;
|
||
PyObject *result_obj = NULL;
|
||
PyObject *printers_obj = (PyObject *) ext_printers->py_type_printers;
|
||
char *result = NULL;
|
||
|
||
if (printers_obj == NULL)
|
||
return EXT_LANG_RC_NOP;
|
||
|
||
if (!gdb_python_initialized)
|
||
return EXT_LANG_RC_NOP;
|
||
|
||
cleanups = ensure_python_env (get_current_arch (), current_language);
|
||
|
||
type_obj = type_to_type_object (type);
|
||
if (type_obj == NULL)
|
||
{
|
||
gdbpy_print_stack ();
|
||
goto done;
|
||
}
|
||
|
||
type_module = PyImport_ImportModule ("gdb.types");
|
||
if (type_module == NULL)
|
||
{
|
||
gdbpy_print_stack ();
|
||
goto done;
|
||
}
|
||
|
||
func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
|
||
if (func == NULL)
|
||
{
|
||
gdbpy_print_stack ();
|
||
goto done;
|
||
}
|
||
|
||
result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
|
||
type_obj, (char *) NULL);
|
||
if (result_obj == NULL)
|
||
{
|
||
gdbpy_print_stack ();
|
||
goto done;
|
||
}
|
||
|
||
if (result_obj != Py_None)
|
||
{
|
||
result = python_string_to_host_string (result_obj);
|
||
if (result == NULL)
|
||
gdbpy_print_stack ();
|
||
}
|
||
|
||
done:
|
||
Py_XDECREF (type_obj);
|
||
Py_XDECREF (type_module);
|
||
Py_XDECREF (func);
|
||
Py_XDECREF (result_obj);
|
||
do_cleanups (cleanups);
|
||
if (result != NULL)
|
||
*prettied_type = result;
|
||
return result != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_ERROR;
|
||
}
|
||
|
||
/* Free the result of start_type_printers.
|
||
This is the extension_language_ops.free_type_printers "method". */
|
||
|
||
static void
|
||
gdbpy_free_type_printers (const struct extension_language_defn *extlang,
|
||
struct ext_lang_type_printers *ext_printers)
|
||
{
|
||
struct cleanup *cleanups;
|
||
PyObject *printers = (PyObject *) ext_printers->py_type_printers;
|
||
|
||
if (printers == NULL)
|
||
return;
|
||
|
||
if (!gdb_python_initialized)
|
||
return;
|
||
|
||
cleanups = ensure_python_env (get_current_arch (), current_language);
|
||
Py_DECREF (printers);
|
||
do_cleanups (cleanups);
|
||
}
|
||
|
||
#else /* HAVE_PYTHON */
|
||
|
||
/* Dummy implementation of the gdb "python-interactive" and "python"
|
||
command. */
|
||
|
||
static void
|
||
python_interactive_command (char *arg, int from_tty)
|
||
{
|
||
arg = skip_spaces (arg);
|
||
if (arg && *arg)
|
||
error (_("Python scripting is not supported in this copy of GDB."));
|
||
else
|
||
{
|
||
struct command_line *l = get_command_line (python_control, "");
|
||
struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
|
||
|
||
execute_control_command_untraced (l);
|
||
do_cleanups (cleanups);
|
||
}
|
||
}
|
||
|
||
static void
|
||
python_command (char *arg, int from_tty)
|
||
{
|
||
python_interactive_command (arg, from_tty);
|
||
}
|
||
|
||
#endif /* HAVE_PYTHON */
|
||
|
||
|
||
|
||
/* Lists for 'set python' commands. */
|
||
|
||
static struct cmd_list_element *user_set_python_list;
|
||
static struct cmd_list_element *user_show_python_list;
|
||
|
||
/* Function for use by 'set python' prefix command. */
|
||
|
||
static void
|
||
user_set_python (char *args, int from_tty)
|
||
{
|
||
help_list (user_set_python_list, "set python ", all_commands,
|
||
gdb_stdout);
|
||
}
|
||
|
||
/* Function for use by 'show python' prefix command. */
|
||
|
||
static void
|
||
user_show_python (char *args, int from_tty)
|
||
{
|
||
cmd_show_list (user_show_python_list, from_tty, "");
|
||
}
|
||
|
||
/* Initialize the Python code. */
|
||
|
||
#ifdef HAVE_PYTHON
|
||
|
||
/* This is installed as a final cleanup and cleans up the
|
||
interpreter. This lets Python's 'atexit' work. */
|
||
|
||
static void
|
||
finalize_python (void *ignore)
|
||
{
|
||
struct active_ext_lang_state *previous_active;
|
||
|
||
/* We don't use ensure_python_env here because if we ever ran the
|
||
cleanup, gdb would crash -- because the cleanup calls into the
|
||
Python interpreter, which we are about to destroy. It seems
|
||
clearer to make the needed calls explicitly here than to create a
|
||
cleanup and then mysteriously discard it. */
|
||
|
||
/* This is only called as a final cleanup so we can assume the active
|
||
SIGINT handler is gdb's. We still need to tell it to notify Python. */
|
||
previous_active = set_active_ext_lang (&extension_language_python);
|
||
|
||
(void) PyGILState_Ensure ();
|
||
python_gdbarch = target_gdbarch ();
|
||
python_language = current_language;
|
||
|
||
Py_Finalize ();
|
||
|
||
restore_active_ext_lang (previous_active);
|
||
}
|
||
#endif
|
||
|
||
/* Provide a prototype to silence -Wmissing-prototypes. */
|
||
extern initialize_file_ftype _initialize_python;
|
||
|
||
void
|
||
_initialize_python (void)
|
||
{
|
||
char *progname;
|
||
#ifdef IS_PY3K
|
||
int i;
|
||
size_t progsize, count;
|
||
char *oldloc;
|
||
wchar_t *progname_copy;
|
||
#endif
|
||
|
||
add_com ("python-interactive", class_obscure,
|
||
python_interactive_command,
|
||
#ifdef HAVE_PYTHON
|
||
_("\
|
||
Start an interactive Python prompt.\n\
|
||
\n\
|
||
To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
|
||
prompt).\n\
|
||
\n\
|
||
Alternatively, a single-line Python command can be given as an\n\
|
||
argument, and if the command is an expression, the result will be\n\
|
||
printed. For example:\n\
|
||
\n\
|
||
(gdb) python-interactive 2 + 3\n\
|
||
5\n\
|
||
")
|
||
#else /* HAVE_PYTHON */
|
||
_("\
|
||
Start a Python interactive prompt.\n\
|
||
\n\
|
||
Python scripting is not supported in this copy of GDB.\n\
|
||
This command is only a placeholder.")
|
||
#endif /* HAVE_PYTHON */
|
||
);
|
||
add_com_alias ("pi", "python-interactive", class_obscure, 1);
|
||
|
||
add_com ("python", class_obscure, python_command,
|
||
#ifdef HAVE_PYTHON
|
||
_("\
|
||
Evaluate a Python command.\n\
|
||
\n\
|
||
The command can be given as an argument, for instance:\n\
|
||
\n\
|
||
python print 23\n\
|
||
\n\
|
||
If no argument is given, the following lines are read and used\n\
|
||
as the Python commands. Type a line containing \"end\" to indicate\n\
|
||
the end of the command.")
|
||
#else /* HAVE_PYTHON */
|
||
_("\
|
||
Evaluate a Python command.\n\
|
||
\n\
|
||
Python scripting is not supported in this copy of GDB.\n\
|
||
This command is only a placeholder.")
|
||
#endif /* HAVE_PYTHON */
|
||
);
|
||
add_com_alias ("py", "python", class_obscure, 1);
|
||
|
||
/* Add set/show python print-stack. */
|
||
add_prefix_cmd ("python", no_class, user_show_python,
|
||
_("Prefix command for python preference settings."),
|
||
&user_show_python_list, "show python ", 0,
|
||
&showlist);
|
||
|
||
add_prefix_cmd ("python", no_class, user_set_python,
|
||
_("Prefix command for python preference settings."),
|
||
&user_set_python_list, "set python ", 0,
|
||
&setlist);
|
||
|
||
add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
|
||
&gdbpy_should_print_stack, _("\
|
||
Set mode for Python stack dump on error."), _("\
|
||
Show the mode of Python stack printing on error."), _("\
|
||
none == no stack or message will be printed.\n\
|
||
full == a message and a stack will be printed.\n\
|
||
message == an error message without a stack will be printed."),
|
||
NULL, NULL,
|
||
&user_set_python_list,
|
||
&user_show_python_list);
|
||
|
||
#ifdef HAVE_PYTHON
|
||
#ifdef WITH_PYTHON_PATH
|
||
/* Work around problem where python gets confused about where it is,
|
||
and then can't find its libraries, etc.
|
||
NOTE: Python assumes the following layout:
|
||
/foo/bin/python
|
||
/foo/lib/pythonX.Y/...
|
||
This must be done before calling Py_Initialize. */
|
||
progname = concat (ldirname (python_libdir), SLASH_STRING, "bin",
|
||
SLASH_STRING, "python", NULL);
|
||
#ifdef IS_PY3K
|
||
oldloc = setlocale (LC_ALL, NULL);
|
||
setlocale (LC_ALL, "");
|
||
progsize = strlen (progname);
|
||
if (progsize == (size_t) -1)
|
||
{
|
||
fprintf (stderr, "Could not convert python path to string\n");
|
||
return;
|
||
}
|
||
progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
|
||
if (!progname_copy)
|
||
{
|
||
fprintf (stderr, "out of memory\n");
|
||
return;
|
||
}
|
||
count = mbstowcs (progname_copy, progname, progsize + 1);
|
||
if (count == (size_t) -1)
|
||
{
|
||
fprintf (stderr, "Could not convert python path to string\n");
|
||
return;
|
||
}
|
||
setlocale (LC_ALL, oldloc);
|
||
|
||
/* Note that Py_SetProgramName expects the string it is passed to
|
||
remain alive for the duration of the program's execution, so
|
||
it is not freed after this call. */
|
||
Py_SetProgramName (progname_copy);
|
||
#else
|
||
Py_SetProgramName (progname);
|
||
#endif
|
||
#endif
|
||
|
||
Py_Initialize ();
|
||
PyEval_InitThreads ();
|
||
|
||
#ifdef IS_PY3K
|
||
gdb_module = PyModule_Create (&python_GdbModuleDef);
|
||
/* Add _gdb module to the list of known built-in modules. */
|
||
_PyImport_FixupBuiltin (gdb_module, "_gdb");
|
||
#else
|
||
gdb_module = Py_InitModule ("_gdb", python_GdbMethods);
|
||
#endif
|
||
if (gdb_module == NULL)
|
||
goto fail;
|
||
|
||
/* The casts to (char*) are for python 2.4. */
|
||
if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0
|
||
|| PyModule_AddStringConstant (gdb_module, "HOST_CONFIG",
|
||
(char*) host_name) < 0
|
||
|| PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
|
||
(char*) target_name) < 0)
|
||
goto fail;
|
||
|
||
/* Add stream constants. */
|
||
if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0
|
||
|| PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0
|
||
|| PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0)
|
||
goto fail;
|
||
|
||
gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
|
||
if (gdbpy_gdb_error == NULL
|
||
|| gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0)
|
||
goto fail;
|
||
|
||
gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
|
||
gdbpy_gdb_error, NULL);
|
||
if (gdbpy_gdb_memory_error == NULL
|
||
|| gdb_pymodule_addobject (gdb_module, "MemoryError",
|
||
gdbpy_gdb_memory_error) < 0)
|
||
goto fail;
|
||
|
||
gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
|
||
if (gdbpy_gdberror_exc == NULL
|
||
|| gdb_pymodule_addobject (gdb_module, "GdbError",
|
||
gdbpy_gdberror_exc) < 0)
|
||
goto fail;
|
||
|
||
gdbpy_initialize_gdb_readline ();
|
||
|
||
if (gdbpy_initialize_auto_load () < 0
|
||
|| gdbpy_initialize_values () < 0
|
||
|| gdbpy_initialize_frames () < 0
|
||
|| gdbpy_initialize_commands () < 0
|
||
|| gdbpy_initialize_symbols () < 0
|
||
|| gdbpy_initialize_symtabs () < 0
|
||
|| gdbpy_initialize_blocks () < 0
|
||
|| gdbpy_initialize_functions () < 0
|
||
|| gdbpy_initialize_parameters () < 0
|
||
|| gdbpy_initialize_types () < 0
|
||
|| gdbpy_initialize_pspace () < 0
|
||
|| gdbpy_initialize_objfile () < 0
|
||
|| gdbpy_initialize_breakpoints () < 0
|
||
|| gdbpy_initialize_finishbreakpoints () < 0
|
||
|| gdbpy_initialize_lazy_string () < 0
|
||
|| gdbpy_initialize_linetable () < 0
|
||
|| gdbpy_initialize_thread () < 0
|
||
|| gdbpy_initialize_inferior () < 0
|
||
|| gdbpy_initialize_events () < 0
|
||
|| gdbpy_initialize_eventregistry () < 0
|
||
|| gdbpy_initialize_py_events () < 0
|
||
|| gdbpy_initialize_event () < 0
|
||
|| gdbpy_initialize_stop_event () < 0
|
||
|| gdbpy_initialize_signal_event () < 0
|
||
|| gdbpy_initialize_breakpoint_event () < 0
|
||
|| gdbpy_initialize_continue_event () < 0
|
||
|| gdbpy_initialize_inferior_call_pre_event () < 0
|
||
|| gdbpy_initialize_inferior_call_post_event () < 0
|
||
|| gdbpy_initialize_register_changed_event () < 0
|
||
|| gdbpy_initialize_memory_changed_event () < 0
|
||
|| gdbpy_initialize_exited_event () < 0
|
||
|| gdbpy_initialize_thread_event () < 0
|
||
|| gdbpy_initialize_new_objfile_event () < 0
|
||
|| gdbpy_initialize_clear_objfiles_event () < 0
|
||
|| gdbpy_initialize_arch () < 0
|
||
|| gdbpy_initialize_xmethods () < 0
|
||
|| gdbpy_initialize_unwind () < 0)
|
||
goto fail;
|
||
|
||
gdbpy_to_string_cst = PyString_FromString ("to_string");
|
||
if (gdbpy_to_string_cst == NULL)
|
||
goto fail;
|
||
gdbpy_children_cst = PyString_FromString ("children");
|
||
if (gdbpy_children_cst == NULL)
|
||
goto fail;
|
||
gdbpy_display_hint_cst = PyString_FromString ("display_hint");
|
||
if (gdbpy_display_hint_cst == NULL)
|
||
goto fail;
|
||
gdbpy_doc_cst = PyString_FromString ("__doc__");
|
||
if (gdbpy_doc_cst == NULL)
|
||
goto fail;
|
||
gdbpy_enabled_cst = PyString_FromString ("enabled");
|
||
if (gdbpy_enabled_cst == NULL)
|
||
goto fail;
|
||
gdbpy_value_cst = PyString_FromString ("value");
|
||
if (gdbpy_value_cst == NULL)
|
||
goto fail;
|
||
|
||
/* Release the GIL while gdb runs. */
|
||
PyThreadState_Swap (NULL);
|
||
PyEval_ReleaseLock ();
|
||
|
||
make_final_cleanup (finalize_python, NULL);
|
||
|
||
gdb_python_initialized = 1;
|
||
return;
|
||
|
||
fail:
|
||
gdbpy_print_stack ();
|
||
/* Do not set 'gdb_python_initialized'. */
|
||
return;
|
||
|
||
#endif /* HAVE_PYTHON */
|
||
}
|
||
|
||
#ifdef HAVE_PYTHON
|
||
|
||
/* Perform the remaining python initializations.
|
||
These must be done after GDB is at least mostly initialized.
|
||
E.g., The "info pretty-printer" command needs the "info" prefix
|
||
command installed.
|
||
This is the extension_language_ops.finish_initialization "method". */
|
||
|
||
static void
|
||
gdbpy_finish_initialization (const struct extension_language_defn *extlang)
|
||
{
|
||
PyObject *m;
|
||
char *gdb_pythondir;
|
||
PyObject *sys_path;
|
||
struct cleanup *cleanup;
|
||
|
||
cleanup = ensure_python_env (get_current_arch (), current_language);
|
||
|
||
/* Add the initial data-directory to sys.path. */
|
||
|
||
gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
|
||
make_cleanup (xfree, gdb_pythondir);
|
||
|
||
sys_path = PySys_GetObject ("path");
|
||
|
||
/* If sys.path is not defined yet, define it first. */
|
||
if (!(sys_path && PyList_Check (sys_path)))
|
||
{
|
||
#ifdef IS_PY3K
|
||
PySys_SetPath (L"");
|
||
#else
|
||
PySys_SetPath ("");
|
||
#endif
|
||
sys_path = PySys_GetObject ("path");
|
||
}
|
||
if (sys_path && PyList_Check (sys_path))
|
||
{
|
||
PyObject *pythondir;
|
||
int err;
|
||
|
||
pythondir = PyString_FromString (gdb_pythondir);
|
||
if (pythondir == NULL)
|
||
goto fail;
|
||
|
||
err = PyList_Insert (sys_path, 0, pythondir);
|
||
Py_DECREF (pythondir);
|
||
if (err)
|
||
goto fail;
|
||
}
|
||
else
|
||
goto fail;
|
||
|
||
/* Import the gdb module to finish the initialization, and
|
||
add it to __main__ for convenience. */
|
||
m = PyImport_AddModule ("__main__");
|
||
if (m == NULL)
|
||
goto fail;
|
||
|
||
gdb_python_module = PyImport_ImportModule ("gdb");
|
||
if (gdb_python_module == NULL)
|
||
{
|
||
gdbpy_print_stack ();
|
||
/* This is passed in one call to warning so that blank lines aren't
|
||
inserted between each line of text. */
|
||
warning (_("\n"
|
||
"Could not load the Python gdb module from `%s'.\n"
|
||
"Limited Python support is available from the _gdb module.\n"
|
||
"Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
|
||
gdb_pythondir);
|
||
do_cleanups (cleanup);
|
||
return;
|
||
}
|
||
|
||
if (gdb_pymodule_addobject (m, "gdb", gdb_python_module) < 0)
|
||
goto fail;
|
||
|
||
/* Keep the reference to gdb_python_module since it is in a global
|
||
variable. */
|
||
|
||
do_cleanups (cleanup);
|
||
return;
|
||
|
||
fail:
|
||
gdbpy_print_stack ();
|
||
warning (_("internal error: Unhandled Python exception"));
|
||
do_cleanups (cleanup);
|
||
}
|
||
|
||
/* Return non-zero if Python has successfully initialized.
|
||
This is the extension_languages_ops.initialized "method". */
|
||
|
||
static int
|
||
gdbpy_initialized (const struct extension_language_defn *extlang)
|
||
{
|
||
return gdb_python_initialized;
|
||
}
|
||
|
||
#endif /* HAVE_PYTHON */
|
||
|
||
|
||
|
||
#ifdef HAVE_PYTHON
|
||
|
||
PyMethodDef python_GdbMethods[] =
|
||
{
|
||
{ "history", gdbpy_history, METH_VARARGS,
|
||
"Get a value from history" },
|
||
{ "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
|
||
"execute (command [, from_tty] [, to_string]) -> [String]\n\
|
||
Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
|
||
a Python String containing the output of the command if to_string is\n\
|
||
set to True." },
|
||
{ "parameter", gdbpy_parameter, METH_VARARGS,
|
||
"Return a gdb parameter's value" },
|
||
|
||
{ "breakpoints", gdbpy_breakpoints, METH_NOARGS,
|
||
"Return a tuple of all breakpoint objects" },
|
||
|
||
{ "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
|
||
"Find the default visualizer for a Value." },
|
||
|
||
{ "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
|
||
"Return the current Progspace." },
|
||
{ "progspaces", gdbpy_progspaces, METH_NOARGS,
|
||
"Return a sequence of all progspaces." },
|
||
|
||
{ "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
|
||
"Return the current Objfile being loaded, or None." },
|
||
{ "objfiles", gdbpy_objfiles, METH_NOARGS,
|
||
"Return a sequence of all loaded objfiles." },
|
||
|
||
{ "newest_frame", gdbpy_newest_frame, METH_NOARGS,
|
||
"newest_frame () -> gdb.Frame.\n\
|
||
Return the newest frame object." },
|
||
{ "selected_frame", gdbpy_selected_frame, METH_NOARGS,
|
||
"selected_frame () -> gdb.Frame.\n\
|
||
Return the selected frame object." },
|
||
{ "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
|
||
"stop_reason_string (Integer) -> String.\n\
|
||
Return a string explaining unwind stop reason." },
|
||
|
||
{ "lookup_type", (PyCFunction) gdbpy_lookup_type,
|
||
METH_VARARGS | METH_KEYWORDS,
|
||
"lookup_type (name [, block]) -> type\n\
|
||
Return a Type corresponding to the given name." },
|
||
{ "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
|
||
METH_VARARGS | METH_KEYWORDS,
|
||
"lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
|
||
Return a tuple with the symbol corresponding to the given name (or None) and\n\
|
||
a boolean indicating if name is a field of the current implied argument\n\
|
||
`this' (when the current language is object-oriented)." },
|
||
{ "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
|
||
METH_VARARGS | METH_KEYWORDS,
|
||
"lookup_global_symbol (name [, domain]) -> symbol\n\
|
||
Return the symbol corresponding to the given name (or None)." },
|
||
|
||
{ "lookup_objfile", (PyCFunction) gdbpy_lookup_objfile,
|
||
METH_VARARGS | METH_KEYWORDS,
|
||
"lookup_objfile (name, [by_build_id]) -> objfile\n\
|
||
Look up the specified objfile.\n\
|
||
If by_build_id is True, the objfile is looked up by using name\n\
|
||
as its build id." },
|
||
|
||
{ "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
|
||
"Return the block containing the given pc value, or None." },
|
||
{ "solib_name", gdbpy_solib_name, METH_VARARGS,
|
||
"solib_name (Long) -> String.\n\
|
||
Return the name of the shared library holding a given address, or None." },
|
||
{ "decode_line", gdbpy_decode_line, METH_VARARGS,
|
||
"decode_line (String) -> Tuple. Decode a string argument the way\n\
|
||
that 'break' or 'edit' does. Return a tuple containing two elements.\n\
|
||
The first element contains any unparsed portion of the String parameter\n\
|
||
(or None if the string was fully parsed). The second element contains\n\
|
||
a tuple that contains all the locations that match, represented as\n\
|
||
gdb.Symtab_and_line objects (or None)."},
|
||
{ "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
|
||
"parse_and_eval (String) -> Value.\n\
|
||
Parse String as an expression, evaluate it, and return the result as a Value."
|
||
},
|
||
{ "find_pc_line", gdbpy_find_pc_line, METH_VARARGS,
|
||
"find_pc_line (pc) -> Symtab_and_line.\n\
|
||
Return the gdb.Symtab_and_line object corresponding to the pc value." },
|
||
|
||
{ "post_event", gdbpy_post_event, METH_VARARGS,
|
||
"Post an event into gdb's event loop." },
|
||
|
||
{ "target_charset", gdbpy_target_charset, METH_NOARGS,
|
||
"target_charset () -> string.\n\
|
||
Return the name of the current target charset." },
|
||
{ "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
|
||
"target_wide_charset () -> string.\n\
|
||
Return the name of the current target wide charset." },
|
||
|
||
{ "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
|
||
"string_to_argv (String) -> Array.\n\
|
||
Parse String and return an argv-like array.\n\
|
||
Arguments are separate by spaces and may be quoted."
|
||
},
|
||
{ "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
|
||
"Write a string using gdb's filtered stream." },
|
||
{ "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
|
||
"Flush gdb's filtered stdout stream." },
|
||
{ "selected_thread", gdbpy_selected_thread, METH_NOARGS,
|
||
"selected_thread () -> gdb.InferiorThread.\n\
|
||
Return the selected thread object." },
|
||
{ "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
|
||
"selected_inferior () -> gdb.Inferior.\n\
|
||
Return the selected inferior object." },
|
||
{ "inferiors", gdbpy_inferiors, METH_NOARGS,
|
||
"inferiors () -> (gdb.Inferior, ...).\n\
|
||
Return a tuple containing all inferiors." },
|
||
{NULL, NULL, 0, NULL}
|
||
};
|
||
|
||
#ifdef IS_PY3K
|
||
struct PyModuleDef python_GdbModuleDef =
|
||
{
|
||
PyModuleDef_HEAD_INIT,
|
||
"_gdb",
|
||
NULL,
|
||
-1,
|
||
python_GdbMethods,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
NULL
|
||
};
|
||
#endif
|
||
#endif /* HAVE_PYTHON */
|