1 /* General python/gdb code
3 Copyright (C) 2008-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
24 #include "cli/cli-script.h"
26 #include "progspace.h"
30 #include "event-loop.h"
32 #include "readline/tilde.h"
34 #include "extension-priv.h"
35 #include "cli/cli-utils.h"
38 #include "ser-event.h"
40 /* Declared constants and enum for python stack printing. */
41 static const char python_excp_none
[] = "none";
42 static const char python_excp_full
[] = "full";
43 static const char python_excp_message
[] = "message";
45 /* "set python print-stack" choices. */
46 static const char *const python_excp_enums
[] =
54 /* The exception printing variable. 'full' if we want to print the
55 error message and stack, 'none' if we want to print nothing, and
56 'message' if we only want to print the error message. 'message' is
58 static const char *gdbpy_should_print_stack
= python_excp_message
;
61 /* Forward decls, these are defined later. */
62 extern const struct extension_language_script_ops python_extension_script_ops
;
63 extern const struct extension_language_ops python_extension_ops
;
66 /* The main struct describing GDB's interface to the Python
67 extension language. */
68 const struct extension_language_defn extension_language_python
=
80 &python_extension_script_ops
,
90 #include "cli/cli-decode.h"
94 #include "python-internal.h"
99 #include "gdbthread.h"
101 #include "event-top.h"
103 /* True if Python has been successfully initialized, false
106 int gdb_python_initialized
;
108 extern PyMethodDef python_GdbMethods
[];
111 extern struct PyModuleDef python_GdbModuleDef
;
114 PyObject
*gdb_module
;
115 PyObject
*gdb_python_module
;
117 /* Some string constants we may wish to use. */
118 PyObject
*gdbpy_to_string_cst
;
119 PyObject
*gdbpy_children_cst
;
120 PyObject
*gdbpy_display_hint_cst
;
121 PyObject
*gdbpy_doc_cst
;
122 PyObject
*gdbpy_enabled_cst
;
123 PyObject
*gdbpy_value_cst
;
125 /* The GdbError exception. */
126 PyObject
*gdbpy_gdberror_exc
;
128 /* The `gdb.error' base class. */
129 PyObject
*gdbpy_gdb_error
;
131 /* The `gdb.MemoryError' exception. */
132 PyObject
*gdbpy_gdb_memory_error
;
134 static script_sourcer_func gdbpy_source_script
;
135 static objfile_script_sourcer_func gdbpy_source_objfile_script
;
136 static objfile_script_executor_func gdbpy_execute_objfile_script
;
137 static void gdbpy_finish_initialization
138 (const struct extension_language_defn
*);
139 static int gdbpy_initialized (const struct extension_language_defn
*);
140 static void gdbpy_eval_from_control_command
141 (const struct extension_language_defn
*, struct command_line
*cmd
);
142 static void gdbpy_start_type_printers (const struct extension_language_defn
*,
143 struct ext_lang_type_printers
*);
144 static enum ext_lang_rc gdbpy_apply_type_printers
145 (const struct extension_language_defn
*,
146 const struct ext_lang_type_printers
*, struct type
*, char **);
147 static void gdbpy_free_type_printers (const struct extension_language_defn
*,
148 struct ext_lang_type_printers
*);
149 static void gdbpy_set_quit_flag (const struct extension_language_defn
*);
150 static int gdbpy_check_quit_flag (const struct extension_language_defn
*);
151 static enum ext_lang_rc gdbpy_before_prompt_hook
152 (const struct extension_language_defn
*, const char *current_gdb_prompt
);
154 /* The interface between gdb proper and loading of python scripts. */
156 const struct extension_language_script_ops python_extension_script_ops
=
159 gdbpy_source_objfile_script
,
160 gdbpy_execute_objfile_script
,
161 gdbpy_auto_load_enabled
164 /* The interface between gdb proper and python extensions. */
166 const struct extension_language_ops python_extension_ops
=
168 gdbpy_finish_initialization
,
171 gdbpy_eval_from_control_command
,
173 gdbpy_start_type_printers
,
174 gdbpy_apply_type_printers
,
175 gdbpy_free_type_printers
,
177 gdbpy_apply_val_pretty_printer
,
179 gdbpy_apply_frame_filter
,
181 gdbpy_preserve_values
,
183 gdbpy_breakpoint_has_cond
,
184 gdbpy_breakpoint_cond_says_stop
,
187 gdbpy_check_quit_flag
,
189 gdbpy_before_prompt_hook
,
191 gdbpy_clone_xmethod_worker_data
,
192 gdbpy_free_xmethod_worker_data
,
193 gdbpy_get_matching_xmethod_workers
,
194 gdbpy_get_xmethod_arg_types
,
195 gdbpy_get_xmethod_result_type
,
199 /* Architecture and language to be used in callbacks from
200 the Python interpreter. */
201 struct gdbarch
*python_gdbarch
;
202 const struct language_defn
*python_language
;
204 /* Restore global language and architecture and Python GIL state
205 when leaving the Python interpreter. */
209 struct active_ext_lang_state
*previous_active
;
210 PyGILState_STATE state
;
211 struct gdbarch
*gdbarch
;
212 const struct language_defn
*language
;
213 PyObject
*error_type
, *error_value
, *error_traceback
;
217 restore_python_env (void *p
)
219 struct python_env
*env
= (struct python_env
*)p
;
221 /* Leftover Python error is forbidden by Python Exception Handling. */
222 if (PyErr_Occurred ())
224 /* This order is similar to the one calling error afterwards. */
225 gdbpy_print_stack ();
226 warning (_("internal error: Unhandled Python exception"));
229 PyErr_Restore (env
->error_type
, env
->error_value
, env
->error_traceback
);
231 PyGILState_Release (env
->state
);
232 python_gdbarch
= env
->gdbarch
;
233 python_language
= env
->language
;
235 restore_active_ext_lang (env
->previous_active
);
240 /* Called before entering the Python interpreter to install the
241 current language and architecture to be used for Python values.
242 Also set the active extension language for GDB so that SIGINT's
243 are directed our way, and if necessary install the right SIGINT
247 ensure_python_env (struct gdbarch
*gdbarch
,
248 const struct language_defn
*language
)
250 struct python_env
*env
= XNEW (struct python_env
);
252 /* We should not ever enter Python unless initialized. */
253 if (!gdb_python_initialized
)
254 error (_("Python not initialized"));
256 env
->previous_active
= set_active_ext_lang (&extension_language_python
);
258 env
->state
= PyGILState_Ensure ();
259 env
->gdbarch
= python_gdbarch
;
260 env
->language
= python_language
;
262 python_gdbarch
= gdbarch
;
263 python_language
= language
;
265 /* Save it and ensure ! PyErr_Occurred () afterwards. */
266 PyErr_Fetch (&env
->error_type
, &env
->error_value
, &env
->error_traceback
);
268 return make_cleanup (restore_python_env
, env
);
271 /* Set the quit flag. */
274 gdbpy_set_quit_flag (const struct extension_language_defn
*extlang
)
276 PyErr_SetInterrupt ();
279 /* Return true if the quit flag has been set, false otherwise. */
282 gdbpy_check_quit_flag (const struct extension_language_defn
*extlang
)
284 return PyOS_InterruptOccurred ();
287 /* Evaluate a Python command like PyRun_SimpleString, but uses
288 Py_single_input which prints the result of expressions, and does
289 not automatically print the stack on errors. */
292 eval_python_command (const char *command
)
296 m
= PyImport_AddModule ("__main__");
300 d
= PyModule_GetDict (m
);
303 v
= PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
);
316 /* Implementation of the gdb "python-interactive" command. */
319 python_interactive_command (char *arg
, int from_tty
)
321 struct ui
*ui
= current_ui
;
324 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
326 arg
= skip_spaces (arg
);
328 ensure_python_env (get_current_arch (), current_language
);
332 int len
= strlen (arg
);
333 char *script
= (char *) xmalloc (len
+ 2);
335 strcpy (script
, arg
);
337 script
[len
+ 1] = '\0';
338 err
= eval_python_command (script
);
343 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
349 gdbpy_print_stack ();
350 error (_("Error while executing Python code."));
354 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
357 On Windows hosts few users would build Python themselves (this is no
358 trivial task on this platform), and thus use binaries built by
359 someone else instead. There may happen situation where the Python
360 library and GDB are using two different versions of the C runtime
361 library. Python, being built with VC, would use one version of the
362 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
363 A FILE * from one runtime does not necessarily operate correctly in
366 To work around this potential issue, we create on Windows hosts the
367 FILE object using Python routines, thus making sure that it is
368 compatible with the Python library. */
371 python_run_simple_file (FILE *file
, const char *filename
)
375 PyRun_SimpleFile (file
, filename
);
380 PyObject
*python_file
;
381 struct cleanup
*cleanup
;
383 /* Because we have a string for a filename, and are using Python to
384 open the file, we need to expand any tilde in the path first. */
385 full_path
= tilde_expand (filename
);
386 cleanup
= make_cleanup (xfree
, full_path
);
387 python_file
= PyFile_FromString (full_path
, "r");
390 do_cleanups (cleanup
);
391 gdbpy_print_stack ();
392 error (_("Error while opening file: %s"), full_path
);
395 make_cleanup_py_decref (python_file
);
396 PyRun_SimpleFile (PyFile_AsFile (python_file
), filename
);
397 do_cleanups (cleanup
);
402 /* Given a command_line, return a command string suitable for passing
403 to Python. Lines in the string are separated by newlines. The
404 return value is allocated using xmalloc and the caller is
405 responsible for freeing it. */
408 compute_python_string (struct command_line
*l
)
410 struct command_line
*iter
;
415 for (iter
= l
; iter
; iter
= iter
->next
)
416 size
+= strlen (iter
->line
) + 1;
418 script
= (char *) xmalloc (size
+ 1);
420 for (iter
= l
; iter
; iter
= iter
->next
)
422 int len
= strlen (iter
->line
);
424 strcpy (&script
[here
], iter
->line
);
426 script
[here
++] = '\n';
432 /* Take a command line structure representing a 'python' command, and
433 evaluate its body using the Python interpreter. */
436 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
437 struct command_line
*cmd
)
441 struct cleanup
*cleanup
;
443 if (cmd
->body_count
!= 1)
444 error (_("Invalid \"python\" block structure."));
446 cleanup
= ensure_python_env (get_current_arch (), current_language
);
448 script
= compute_python_string (cmd
->body_list
[0]);
449 ret
= PyRun_SimpleString (script
);
452 error (_("Error while executing Python code."));
454 do_cleanups (cleanup
);
457 /* Implementation of the gdb "python" command. */
460 python_command (char *arg
, int from_tty
)
462 struct cleanup
*cleanup
;
464 cleanup
= ensure_python_env (get_current_arch (), current_language
);
466 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
468 arg
= skip_spaces (arg
);
471 if (PyRun_SimpleString (arg
))
472 error (_("Error while executing Python code."));
476 struct command_line
*l
= get_command_line (python_control
, "");
478 make_cleanup_free_command_lines (&l
);
479 execute_control_command_untraced (l
);
482 do_cleanups (cleanup
);
487 /* Transform a gdb parameters's value into a Python value. May return
488 NULL (and set a Python exception) on error. Helper function for
491 gdbpy_parameter_value (enum var_types type
, void *var
)
496 case var_string_noescape
:
497 case var_optional_filename
:
501 char *str
= * (char **) var
;
505 return host_string_to_python_string (str
);
516 case var_auto_boolean
:
518 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
520 if (ab
== AUTO_BOOLEAN_TRUE
)
522 else if (ab
== AUTO_BOOLEAN_FALSE
)
529 if ((* (int *) var
) == INT_MAX
)
533 return PyLong_FromLong (* (int *) var
);
537 unsigned int val
= * (unsigned int *) var
;
541 return PyLong_FromUnsignedLong (val
);
545 return PyErr_Format (PyExc_RuntimeError
,
546 _("Programmer error: unhandled type."));
549 /* A Python function which returns a gdb parameter's value as a Python
553 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
555 struct gdb_exception except
= exception_none
;
556 struct cmd_list_element
*alias
, *prefix
, *cmd
;
561 if (! PyArg_ParseTuple (args
, "s", &arg
))
564 newarg
= concat ("show ", arg
, (char *) NULL
);
568 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
570 CATCH (ex
, RETURN_MASK_ALL
)
577 GDB_PY_HANDLE_EXCEPTION (except
);
579 return PyErr_Format (PyExc_RuntimeError
,
580 _("Could not find parameter `%s'."), arg
);
583 return PyErr_Format (PyExc_RuntimeError
,
584 _("`%s' is not a parameter."), arg
);
585 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
588 /* Wrapper for target_charset. */
591 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
593 const char *cset
= target_charset (python_gdbarch
);
595 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
598 /* Wrapper for target_wide_charset. */
601 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
603 const char *cset
= target_wide_charset (python_gdbarch
);
605 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
608 /* A Python function which evaluates a string using the gdb CLI. */
611 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
614 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
615 int from_tty
, to_string
;
616 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
618 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
619 &PyBool_Type
, &from_tty_obj
,
620 &PyBool_Type
, &to_string_obj
))
626 int cmp
= PyObject_IsTrue (from_tty_obj
);
635 int cmp
= PyObject_IsTrue (to_string_obj
);
641 std::string to_string_res
;
645 /* Copy the argument text in case the command modifies it. */
646 char *copy
= xstrdup (arg
);
647 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
648 struct interp
*interp
;
650 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
652 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
);
654 /* Use the console interpreter uiout to have the same print format
655 for console or MI. */
656 interp
= interp_lookup (current_ui
, "console");
657 current_uiout
= interp_ui_out (interp
);
659 prevent_dont_repeat ();
661 to_string_res
= execute_command_to_string (copy
, from_tty
);
663 execute_command (copy
, from_tty
);
664 do_cleanups (cleanup
);
666 CATCH (except
, RETURN_MASK_ALL
)
668 GDB_PY_HANDLE_EXCEPTION (except
);
672 /* Do any commands attached to breakpoint we stopped at. */
673 bpstat_do_actions ();
676 return PyString_FromString (to_string_res
.c_str ());
680 /* Implementation of gdb.solib_name (Long) -> String.
681 Returns the name of the shared library holding a given address, or None. */
684 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
690 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
693 soname
= solib_name_from_address (current_program_space
, pc
);
695 str_obj
= host_string_to_python_string (soname
);
705 /* A Python function which is a wrapper for decode_line_1. */
708 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
710 struct gdb_exception except
= exception_none
;
711 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
713 struct symtab_and_line sal
;
715 struct cleanup
*cleanups
;
716 PyObject
*result
= NULL
;
717 PyObject
*return_result
= NULL
;
718 PyObject
*unparsed
= NULL
;
719 struct event_location
*location
= NULL
;
721 if (! PyArg_ParseTuple (args
, "|s", &arg
))
724 cleanups
= make_cleanup (null_cleanup
, NULL
);
730 location
= string_to_event_location_basic (&arg
, python_language
);
731 make_cleanup_delete_event_location (location
);
736 if (location
!= NULL
)
737 sals
= decode_line_1 (location
, 0, NULL
, NULL
, 0);
740 set_default_source_symtab_and_line ();
741 sal
= get_current_source_symtab_and_line ();
746 CATCH (ex
, RETURN_MASK_ALL
)
752 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
753 make_cleanup (xfree
, sals
.sals
);
755 if (except
.reason
< 0)
757 do_cleanups (cleanups
);
758 /* We know this will always throw. */
759 gdbpy_convert_exception (except
);
767 result
= PyTuple_New (sals
.nelts
);
770 for (i
= 0; i
< sals
.nelts
; ++i
)
774 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
781 PyTuple_SetItem (result
, i
, obj
);
790 return_result
= PyTuple_New (2);
797 if (arg
!= NULL
&& strlen (arg
) > 0)
799 unparsed
= PyString_FromString (arg
);
800 if (unparsed
== NULL
)
803 Py_DECREF (return_result
);
804 return_result
= NULL
;
814 PyTuple_SetItem (return_result
, 0, unparsed
);
815 PyTuple_SetItem (return_result
, 1, result
);
818 do_cleanups (cleanups
);
820 return return_result
;
823 /* Parse a string and evaluate it as an expression. */
825 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
827 const char *expr_str
;
828 struct value
*result
= NULL
;
830 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
835 result
= parse_and_eval (expr_str
);
837 CATCH (except
, RETURN_MASK_ALL
)
839 GDB_PY_HANDLE_EXCEPTION (except
);
843 return value_to_value_object (result
);
846 /* Implementation of gdb.find_pc_line function.
847 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
850 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
852 gdb_py_ulongest pc_llu
;
853 PyObject
*result
= NULL
; /* init for gcc -Wall */
855 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
860 struct symtab_and_line sal
;
863 pc
= (CORE_ADDR
) pc_llu
;
864 sal
= find_pc_line (pc
, 0);
865 result
= symtab_and_line_to_sal_object (sal
);
867 CATCH (except
, RETURN_MASK_ALL
)
869 GDB_PY_HANDLE_EXCEPTION (except
);
876 /* Implementation of gdb.invalidate_cached_frames. */
879 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
881 reinit_frame_cache ();
885 /* Read a file as Python code.
886 This is the extension_language_script_ops.script_sourcer "method".
887 FILE is the file to load. FILENAME is name of the file FILE.
888 This does not throw any errors. If an exception occurs python will print
889 the traceback and clear the error indicator. */
892 gdbpy_source_script (const struct extension_language_defn
*extlang
,
893 FILE *file
, const char *filename
)
895 struct cleanup
*cleanup
;
897 cleanup
= ensure_python_env (get_current_arch (), current_language
);
898 python_run_simple_file (file
, filename
);
899 do_cleanups (cleanup
);
904 /* Posting and handling events. */
906 /* A single event. */
909 /* The Python event. This is just a callable object. */
911 /* The next event. */
912 struct gdbpy_event
*next
;
915 /* All pending events. */
916 static struct gdbpy_event
*gdbpy_event_list
;
917 /* The final link of the event list. */
918 static struct gdbpy_event
**gdbpy_event_list_end
;
920 /* So that we can wake up the main thread even when it is blocked in
922 static struct serial_event
*gdbpy_serial_event
;
924 /* The file handler callback. This reads from the internal pipe, and
925 then processes the Python event queue. This will always be run in
926 the main gdb thread. */
929 gdbpy_run_events (int error
, gdb_client_data client_data
)
931 struct cleanup
*cleanup
;
933 cleanup
= ensure_python_env (get_current_arch (), current_language
);
935 /* Clear the event fd. Do this before flushing the events list, so
936 that any new event post afterwards is sure to re-awake the event
938 serial_event_clear (gdbpy_serial_event
);
940 while (gdbpy_event_list
)
942 PyObject
*call_result
;
944 /* Dispatching the event might push a new element onto the event
945 loop, so we update here "atomically enough". */
946 struct gdbpy_event
*item
= gdbpy_event_list
;
947 gdbpy_event_list
= gdbpy_event_list
->next
;
948 if (gdbpy_event_list
== NULL
)
949 gdbpy_event_list_end
= &gdbpy_event_list
;
952 call_result
= PyObject_CallObject (item
->event
, NULL
);
953 if (call_result
== NULL
)
956 Py_XDECREF (call_result
);
957 Py_DECREF (item
->event
);
961 do_cleanups (cleanup
);
964 /* Submit an event to the gdb thread. */
966 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
968 struct gdbpy_event
*event
;
972 if (!PyArg_ParseTuple (args
, "O", &func
))
975 if (!PyCallable_Check (func
))
977 PyErr_SetString (PyExc_RuntimeError
,
978 _("Posted event is not callable"));
984 /* From here until the end of the function, we have the GIL, so we
985 can operate on our global data structures without worrying. */
986 wakeup
= gdbpy_event_list
== NULL
;
988 event
= XNEW (struct gdbpy_event
);
991 *gdbpy_event_list_end
= event
;
992 gdbpy_event_list_end
= &event
->next
;
994 /* Wake up gdb when needed. */
996 serial_event_set (gdbpy_serial_event
);
1001 /* Initialize the Python event handler. */
1003 gdbpy_initialize_events (void)
1005 gdbpy_event_list_end
= &gdbpy_event_list
;
1007 gdbpy_serial_event
= make_serial_event ();
1008 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1009 gdbpy_run_events
, NULL
);
1016 /* This is the extension_language_ops.before_prompt "method". */
1018 static enum ext_lang_rc
1019 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1020 const char *current_gdb_prompt
)
1022 struct cleanup
*cleanup
;
1023 char *prompt
= NULL
;
1025 if (!gdb_python_initialized
)
1026 return EXT_LANG_RC_NOP
;
1028 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1030 if (gdb_python_module
1031 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1035 hook
= PyObject_GetAttrString (gdb_python_module
, "prompt_hook");
1039 make_cleanup_py_decref (hook
);
1041 if (PyCallable_Check (hook
))
1044 PyObject
*current_prompt
;
1046 current_prompt
= PyString_FromString (current_gdb_prompt
);
1047 if (current_prompt
== NULL
)
1050 result
= PyObject_CallFunctionObjArgs (hook
, current_prompt
, NULL
);
1052 Py_DECREF (current_prompt
);
1057 make_cleanup_py_decref (result
);
1059 /* Return type should be None, or a String. If it is None,
1060 fall through, we will not set a prompt. If it is a
1061 string, set PROMPT. Anything else, set an exception. */
1062 if (result
!= Py_None
&& ! PyString_Check (result
))
1064 PyErr_Format (PyExc_RuntimeError
,
1065 _("Return from prompt_hook must " \
1066 "be either a Python string, or None"));
1070 if (result
!= Py_None
)
1072 prompt
= python_string_to_host_string (result
);
1077 make_cleanup (xfree
, prompt
);
1082 /* If a prompt has been set, PROMPT will not be NULL. If it is
1083 NULL, do not set the prompt. */
1085 set_prompt (prompt
);
1087 do_cleanups (cleanup
);
1088 return prompt
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_NOP
;
1091 gdbpy_print_stack ();
1092 do_cleanups (cleanup
);
1093 return EXT_LANG_RC_ERROR
;
1100 /* A python function to write a single string using gdb's filtered
1101 output stream . The optional keyword STREAM can be used to write
1102 to a particular stream. The default stream is to gdb_stdout. */
1105 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1108 static char *keywords
[] = {"text", "stream", NULL
};
1109 int stream_type
= 0;
1111 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1117 switch (stream_type
)
1121 fprintf_filtered (gdb_stderr
, "%s", arg
);
1126 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1130 fprintf_filtered (gdb_stdout
, "%s", arg
);
1133 CATCH (except
, RETURN_MASK_ALL
)
1135 GDB_PY_HANDLE_EXCEPTION (except
);
1142 /* A python function to flush a gdb stream. The optional keyword
1143 STREAM can be used to flush a particular stream. The default stream
1147 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1149 static char *keywords
[] = {"stream", NULL
};
1150 int stream_type
= 0;
1152 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1156 switch (stream_type
)
1160 gdb_flush (gdb_stderr
);
1165 gdb_flush (gdb_stdlog
);
1169 gdb_flush (gdb_stdout
);
1175 /* Return non-zero if print-stack is not "none". */
1178 gdbpy_print_python_errors_p (void)
1180 return gdbpy_should_print_stack
!= python_excp_none
;
1183 /* Print a python exception trace, print just a message, or print
1184 nothing and clear the python exception, depending on
1185 gdbpy_should_print_stack. Only call this if a python exception is
1188 gdbpy_print_stack (void)
1191 /* Print "none", just clear exception. */
1192 if (gdbpy_should_print_stack
== python_excp_none
)
1196 /* Print "full" message and backtrace. */
1197 else if (gdbpy_should_print_stack
== python_excp_full
)
1200 /* PyErr_Print doesn't necessarily end output with a newline.
1201 This works because Python's stdout/stderr is fed through
1207 CATCH (except
, RETURN_MASK_ALL
)
1212 /* Print "message", just error print message. */
1215 PyObject
*ptype
, *pvalue
, *ptraceback
;
1216 char *msg
= NULL
, *type
= NULL
;
1218 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1220 /* Fetch the error message contained within ptype, pvalue. */
1221 msg
= gdbpy_exception_to_string (ptype
, pvalue
);
1222 type
= gdbpy_obj_to_string (ptype
);
1228 /* An error occurred computing the string representation of the
1230 fprintf_filtered (gdb_stderr
,
1231 _("Error occurred computing Python error" \
1235 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1238 CATCH (except
, RETURN_MASK_ALL
)
1244 Py_XDECREF (pvalue
);
1245 Py_XDECREF (ptraceback
);
1252 /* Return the current Progspace.
1253 There always is one. */
1256 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1260 result
= pspace_to_pspace_object (current_program_space
);
1266 /* Return a sequence holding all the Progspaces. */
1269 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1271 struct program_space
*ps
;
1274 list
= PyList_New (0);
1280 PyObject
*item
= pspace_to_pspace_object (ps
);
1282 if (!item
|| PyList_Append (list
, item
) == -1)
1294 /* The "current" objfile. This is set when gdb detects that a new
1295 objfile has been loaded. It is only set for the duration of a call to
1296 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1298 static struct objfile
*gdbpy_current_objfile
;
1300 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1301 as Python code. This does not throw any errors. If an exception
1302 occurs python will print the traceback and clear the error indicator.
1303 This is the extension_language_script_ops.objfile_script_sourcer
1307 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1308 struct objfile
*objfile
, FILE *file
,
1309 const char *filename
)
1311 struct cleanup
*cleanups
;
1313 if (!gdb_python_initialized
)
1316 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1317 gdbpy_current_objfile
= objfile
;
1319 python_run_simple_file (file
, filename
);
1321 do_cleanups (cleanups
);
1322 gdbpy_current_objfile
= NULL
;
1325 /* Set the current objfile to OBJFILE and then execute SCRIPT
1326 as Python code. This does not throw any errors. If an exception
1327 occurs python will print the traceback and clear the error indicator.
1328 This is the extension_language_script_ops.objfile_script_executor
1332 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1333 struct objfile
*objfile
, const char *name
,
1336 struct cleanup
*cleanups
;
1338 if (!gdb_python_initialized
)
1341 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1342 gdbpy_current_objfile
= objfile
;
1344 PyRun_SimpleString (script
);
1346 do_cleanups (cleanups
);
1347 gdbpy_current_objfile
= NULL
;
1350 /* Return the current Objfile, or None if there isn't one. */
1353 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1357 if (! gdbpy_current_objfile
)
1360 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1366 /* Return a sequence holding all the Objfiles. */
1369 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1371 struct objfile
*objf
;
1374 list
= PyList_New (0);
1380 PyObject
*item
= objfile_to_objfile_object (objf
);
1382 if (!item
|| PyList_Append (list
, item
) == -1)
1392 /* Compute the list of active python type printers and store them in
1393 EXT_PRINTERS->py_type_printers. The product of this function is used by
1394 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1395 This is the extension_language_ops.start_type_printers "method". */
1398 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1399 struct ext_lang_type_printers
*ext_printers
)
1401 struct cleanup
*cleanups
;
1402 PyObject
*type_module
, *func
= NULL
, *printers_obj
= NULL
;
1404 if (!gdb_python_initialized
)
1407 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1409 type_module
= PyImport_ImportModule ("gdb.types");
1410 if (type_module
== NULL
)
1412 gdbpy_print_stack ();
1416 func
= PyObject_GetAttrString (type_module
, "get_type_recognizers");
1419 gdbpy_print_stack ();
1423 printers_obj
= PyObject_CallFunctionObjArgs (func
, (char *) NULL
);
1424 if (printers_obj
== NULL
)
1425 gdbpy_print_stack ();
1427 ext_printers
->py_type_printers
= printers_obj
;
1430 Py_XDECREF (type_module
);
1432 do_cleanups (cleanups
);
1435 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1436 a newly allocated string holding the type's replacement name, and return
1437 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1438 If there's a Python error return EXT_LANG_RC_ERROR.
1439 Otherwise, return EXT_LANG_RC_NOP.
1440 This is the extension_language_ops.apply_type_printers "method". */
1442 static enum ext_lang_rc
1443 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1444 const struct ext_lang_type_printers
*ext_printers
,
1445 struct type
*type
, char **prettied_type
)
1447 struct cleanup
*cleanups
;
1448 PyObject
*type_obj
, *type_module
= NULL
, *func
= NULL
;
1449 PyObject
*result_obj
= NULL
;
1450 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1451 char *result
= NULL
;
1453 if (printers_obj
== NULL
)
1454 return EXT_LANG_RC_NOP
;
1456 if (!gdb_python_initialized
)
1457 return EXT_LANG_RC_NOP
;
1459 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1461 type_obj
= type_to_type_object (type
);
1462 if (type_obj
== NULL
)
1464 gdbpy_print_stack ();
1468 type_module
= PyImport_ImportModule ("gdb.types");
1469 if (type_module
== NULL
)
1471 gdbpy_print_stack ();
1475 func
= PyObject_GetAttrString (type_module
, "apply_type_recognizers");
1478 gdbpy_print_stack ();
1482 result_obj
= PyObject_CallFunctionObjArgs (func
, printers_obj
,
1483 type_obj
, (char *) NULL
);
1484 if (result_obj
== NULL
)
1486 gdbpy_print_stack ();
1490 if (result_obj
!= Py_None
)
1492 result
= python_string_to_host_string (result_obj
);
1494 gdbpy_print_stack ();
1498 Py_XDECREF (type_obj
);
1499 Py_XDECREF (type_module
);
1501 Py_XDECREF (result_obj
);
1502 do_cleanups (cleanups
);
1504 *prettied_type
= result
;
1505 return result
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_ERROR
;
1508 /* Free the result of start_type_printers.
1509 This is the extension_language_ops.free_type_printers "method". */
1512 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1513 struct ext_lang_type_printers
*ext_printers
)
1515 struct cleanup
*cleanups
;
1516 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1518 if (printers
== NULL
)
1521 if (!gdb_python_initialized
)
1524 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1525 Py_DECREF (printers
);
1526 do_cleanups (cleanups
);
1529 #else /* HAVE_PYTHON */
1531 /* Dummy implementation of the gdb "python-interactive" and "python"
1535 python_interactive_command (char *arg
, int from_tty
)
1537 arg
= skip_spaces (arg
);
1539 error (_("Python scripting is not supported in this copy of GDB."));
1542 struct command_line
*l
= get_command_line (python_control
, "");
1543 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1545 execute_control_command_untraced (l
);
1546 do_cleanups (cleanups
);
1551 python_command (char *arg
, int from_tty
)
1553 python_interactive_command (arg
, from_tty
);
1556 #endif /* HAVE_PYTHON */
1560 /* Lists for 'set python' commands. */
1562 static struct cmd_list_element
*user_set_python_list
;
1563 static struct cmd_list_element
*user_show_python_list
;
1565 /* Function for use by 'set python' prefix command. */
1568 user_set_python (char *args
, int from_tty
)
1570 help_list (user_set_python_list
, "set python ", all_commands
,
1574 /* Function for use by 'show python' prefix command. */
1577 user_show_python (char *args
, int from_tty
)
1579 cmd_show_list (user_show_python_list
, from_tty
, "");
1582 /* Initialize the Python code. */
1586 /* This is installed as a final cleanup and cleans up the
1587 interpreter. This lets Python's 'atexit' work. */
1590 finalize_python (void *ignore
)
1592 struct active_ext_lang_state
*previous_active
;
1594 /* We don't use ensure_python_env here because if we ever ran the
1595 cleanup, gdb would crash -- because the cleanup calls into the
1596 Python interpreter, which we are about to destroy. It seems
1597 clearer to make the needed calls explicitly here than to create a
1598 cleanup and then mysteriously discard it. */
1600 /* This is only called as a final cleanup so we can assume the active
1601 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1602 previous_active
= set_active_ext_lang (&extension_language_python
);
1604 (void) PyGILState_Ensure ();
1605 python_gdbarch
= target_gdbarch ();
1606 python_language
= current_language
;
1610 restore_active_ext_lang (previous_active
);
1614 /* Provide a prototype to silence -Wmissing-prototypes. */
1615 extern initialize_file_ftype _initialize_python
;
1618 _initialize_python (void)
1623 size_t progsize
, count
;
1625 wchar_t *progname_copy
;
1628 add_com ("python-interactive", class_obscure
,
1629 python_interactive_command
,
1632 Start an interactive Python prompt.\n\
1634 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1637 Alternatively, a single-line Python command can be given as an\n\
1638 argument, and if the command is an expression, the result will be\n\
1639 printed. For example:\n\
1641 (gdb) python-interactive 2 + 3\n\
1644 #else /* HAVE_PYTHON */
1646 Start a Python interactive prompt.\n\
1648 Python scripting is not supported in this copy of GDB.\n\
1649 This command is only a placeholder.")
1650 #endif /* HAVE_PYTHON */
1652 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1654 add_com ("python", class_obscure
, python_command
,
1657 Evaluate a Python command.\n\
1659 The command can be given as an argument, for instance:\n\
1663 If no argument is given, the following lines are read and used\n\
1664 as the Python commands. Type a line containing \"end\" to indicate\n\
1665 the end of the command.")
1666 #else /* HAVE_PYTHON */
1668 Evaluate a Python command.\n\
1670 Python scripting is not supported in this copy of GDB.\n\
1671 This command is only a placeholder.")
1672 #endif /* HAVE_PYTHON */
1674 add_com_alias ("py", "python", class_obscure
, 1);
1676 /* Add set/show python print-stack. */
1677 add_prefix_cmd ("python", no_class
, user_show_python
,
1678 _("Prefix command for python preference settings."),
1679 &user_show_python_list
, "show python ", 0,
1682 add_prefix_cmd ("python", no_class
, user_set_python
,
1683 _("Prefix command for python preference settings."),
1684 &user_set_python_list
, "set python ", 0,
1687 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1688 &gdbpy_should_print_stack
, _("\
1689 Set mode for Python stack dump on error."), _("\
1690 Show the mode of Python stack printing on error."), _("\
1691 none == no stack or message will be printed.\n\
1692 full == a message and a stack will be printed.\n\
1693 message == an error message without a stack will be printed."),
1695 &user_set_python_list
,
1696 &user_show_python_list
);
1699 #ifdef WITH_PYTHON_PATH
1700 /* Work around problem where python gets confused about where it is,
1701 and then can't find its libraries, etc.
1702 NOTE: Python assumes the following layout:
1704 /foo/lib/pythonX.Y/...
1705 This must be done before calling Py_Initialize. */
1706 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1707 SLASH_STRING
, "python", (char *) NULL
);
1709 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1710 setlocale (LC_ALL
, "");
1711 progsize
= strlen (progname
);
1712 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1716 fprintf (stderr
, "out of memory\n");
1719 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1720 if (count
== (size_t) -1)
1723 fprintf (stderr
, "Could not convert python path to string\n");
1726 setlocale (LC_ALL
, oldloc
);
1729 /* Note that Py_SetProgramName expects the string it is passed to
1730 remain alive for the duration of the program's execution, so
1731 it is not freed after this call. */
1732 Py_SetProgramName (progname_copy
);
1734 Py_SetProgramName (progname
);
1739 PyEval_InitThreads ();
1742 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1743 /* Add _gdb module to the list of known built-in modules. */
1744 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1746 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1748 if (gdb_module
== NULL
)
1751 /* The casts to (char*) are for python 2.4. */
1752 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1753 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1754 (char*) host_name
) < 0
1755 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1756 (char*) target_name
) < 0)
1759 /* Add stream constants. */
1760 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1761 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1762 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1765 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1766 if (gdbpy_gdb_error
== NULL
1767 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1770 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1771 gdbpy_gdb_error
, NULL
);
1772 if (gdbpy_gdb_memory_error
== NULL
1773 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1774 gdbpy_gdb_memory_error
) < 0)
1777 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1778 if (gdbpy_gdberror_exc
== NULL
1779 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1780 gdbpy_gdberror_exc
) < 0)
1783 gdbpy_initialize_gdb_readline ();
1785 if (gdbpy_initialize_auto_load () < 0
1786 || gdbpy_initialize_values () < 0
1787 || gdbpy_initialize_frames () < 0
1788 || gdbpy_initialize_commands () < 0
1789 || gdbpy_initialize_symbols () < 0
1790 || gdbpy_initialize_symtabs () < 0
1791 || gdbpy_initialize_blocks () < 0
1792 || gdbpy_initialize_functions () < 0
1793 || gdbpy_initialize_parameters () < 0
1794 || gdbpy_initialize_types () < 0
1795 || gdbpy_initialize_pspace () < 0
1796 || gdbpy_initialize_objfile () < 0
1797 || gdbpy_initialize_breakpoints () < 0
1798 || gdbpy_initialize_finishbreakpoints () < 0
1799 || gdbpy_initialize_lazy_string () < 0
1800 || gdbpy_initialize_linetable () < 0
1801 || gdbpy_initialize_thread () < 0
1802 || gdbpy_initialize_inferior () < 0
1803 || gdbpy_initialize_events () < 0
1804 || gdbpy_initialize_eventregistry () < 0
1805 || gdbpy_initialize_py_events () < 0
1806 || gdbpy_initialize_event () < 0
1807 || gdbpy_initialize_stop_event () < 0
1808 || gdbpy_initialize_signal_event () < 0
1809 || gdbpy_initialize_breakpoint_event () < 0
1810 || gdbpy_initialize_continue_event () < 0
1811 || gdbpy_initialize_inferior_call_pre_event () < 0
1812 || gdbpy_initialize_inferior_call_post_event () < 0
1813 || gdbpy_initialize_register_changed_event () < 0
1814 || gdbpy_initialize_memory_changed_event () < 0
1815 || gdbpy_initialize_exited_event () < 0
1816 || gdbpy_initialize_thread_event () < 0
1817 || gdbpy_initialize_new_objfile_event () < 0
1818 || gdbpy_initialize_clear_objfiles_event () < 0
1819 || gdbpy_initialize_arch () < 0
1820 || gdbpy_initialize_xmethods () < 0
1821 || gdbpy_initialize_unwind () < 0)
1824 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1825 if (gdbpy_to_string_cst
== NULL
)
1827 gdbpy_children_cst
= PyString_FromString ("children");
1828 if (gdbpy_children_cst
== NULL
)
1830 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1831 if (gdbpy_display_hint_cst
== NULL
)
1833 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1834 if (gdbpy_doc_cst
== NULL
)
1836 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1837 if (gdbpy_enabled_cst
== NULL
)
1839 gdbpy_value_cst
= PyString_FromString ("value");
1840 if (gdbpy_value_cst
== NULL
)
1843 /* Release the GIL while gdb runs. */
1844 PyThreadState_Swap (NULL
);
1845 PyEval_ReleaseLock ();
1847 make_final_cleanup (finalize_python
, NULL
);
1849 gdb_python_initialized
= 1;
1853 gdbpy_print_stack ();
1854 /* Do not set 'gdb_python_initialized'. */
1857 #endif /* HAVE_PYTHON */
1862 /* Perform the remaining python initializations.
1863 These must be done after GDB is at least mostly initialized.
1864 E.g., The "info pretty-printer" command needs the "info" prefix
1866 This is the extension_language_ops.finish_initialization "method". */
1869 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1872 char *gdb_pythondir
;
1874 struct cleanup
*cleanup
;
1876 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1878 /* Add the initial data-directory to sys.path. */
1880 gdb_pythondir
= concat (gdb_datadir
, SLASH_STRING
, "python", (char *) NULL
);
1881 make_cleanup (xfree
, gdb_pythondir
);
1883 sys_path
= PySys_GetObject ("path");
1885 /* If sys.path is not defined yet, define it first. */
1886 if (!(sys_path
&& PyList_Check (sys_path
)))
1889 PySys_SetPath (L
"");
1893 sys_path
= PySys_GetObject ("path");
1895 if (sys_path
&& PyList_Check (sys_path
))
1897 PyObject
*pythondir
;
1900 pythondir
= PyString_FromString (gdb_pythondir
);
1901 if (pythondir
== NULL
)
1904 err
= PyList_Insert (sys_path
, 0, pythondir
);
1905 Py_DECREF (pythondir
);
1912 /* Import the gdb module to finish the initialization, and
1913 add it to __main__ for convenience. */
1914 m
= PyImport_AddModule ("__main__");
1918 gdb_python_module
= PyImport_ImportModule ("gdb");
1919 if (gdb_python_module
== NULL
)
1921 gdbpy_print_stack ();
1922 /* This is passed in one call to warning so that blank lines aren't
1923 inserted between each line of text. */
1925 "Could not load the Python gdb module from `%s'.\n"
1926 "Limited Python support is available from the _gdb module.\n"
1927 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1929 do_cleanups (cleanup
);
1933 if (gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) < 0)
1936 /* Keep the reference to gdb_python_module since it is in a global
1939 do_cleanups (cleanup
);
1943 gdbpy_print_stack ();
1944 warning (_("internal error: Unhandled Python exception"));
1945 do_cleanups (cleanup
);
1948 /* Return non-zero if Python has successfully initialized.
1949 This is the extension_languages_ops.initialized "method". */
1952 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1954 return gdb_python_initialized
;
1957 #endif /* HAVE_PYTHON */
1963 PyMethodDef python_GdbMethods
[] =
1965 { "history", gdbpy_history
, METH_VARARGS
,
1966 "Get a value from history" },
1967 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1968 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1969 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1970 a Python String containing the output of the command if to_string is\n\
1972 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1973 "Return a gdb parameter's value" },
1975 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1976 "Return a tuple of all breakpoint objects" },
1978 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1979 "Find the default visualizer for a Value." },
1981 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1982 "Return the current Progspace." },
1983 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1984 "Return a sequence of all progspaces." },
1986 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1987 "Return the current Objfile being loaded, or None." },
1988 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1989 "Return a sequence of all loaded objfiles." },
1991 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1992 "newest_frame () -> gdb.Frame.\n\
1993 Return the newest frame object." },
1994 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1995 "selected_frame () -> gdb.Frame.\n\
1996 Return the selected frame object." },
1997 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1998 "stop_reason_string (Integer) -> String.\n\
1999 Return a string explaining unwind stop reason." },
2001 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2002 METH_VARARGS
| METH_KEYWORDS
,
2003 "lookup_type (name [, block]) -> type\n\
2004 Return a Type corresponding to the given name." },
2005 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2006 METH_VARARGS
| METH_KEYWORDS
,
2007 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2008 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2009 a boolean indicating if name is a field of the current implied argument\n\
2010 `this' (when the current language is object-oriented)." },
2011 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2012 METH_VARARGS
| METH_KEYWORDS
,
2013 "lookup_global_symbol (name [, domain]) -> symbol\n\
2014 Return the symbol corresponding to the given name (or None)." },
2016 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2017 METH_VARARGS
| METH_KEYWORDS
,
2018 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2019 Look up the specified objfile.\n\
2020 If by_build_id is True, the objfile is looked up by using name\n\
2021 as its build id." },
2023 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2024 "Return the block containing the given pc value, or None." },
2025 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2026 "solib_name (Long) -> String.\n\
2027 Return the name of the shared library holding a given address, or None." },
2028 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2029 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2030 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2031 The first element contains any unparsed portion of the String parameter\n\
2032 (or None if the string was fully parsed). The second element contains\n\
2033 a tuple that contains all the locations that match, represented as\n\
2034 gdb.Symtab_and_line objects (or None)."},
2035 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2036 "parse_and_eval (String) -> Value.\n\
2037 Parse String as an expression, evaluate it, and return the result as a Value."
2039 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2040 "find_pc_line (pc) -> Symtab_and_line.\n\
2041 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2043 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2044 "Post an event into gdb's event loop." },
2046 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2047 "target_charset () -> string.\n\
2048 Return the name of the current target charset." },
2049 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2050 "target_wide_charset () -> string.\n\
2051 Return the name of the current target wide charset." },
2053 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2054 "string_to_argv (String) -> Array.\n\
2055 Parse String and return an argv-like array.\n\
2056 Arguments are separate by spaces and may be quoted."
2058 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2059 "Write a string using gdb's filtered stream." },
2060 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2061 "Flush gdb's filtered stdout stream." },
2062 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2063 "selected_thread () -> gdb.InferiorThread.\n\
2064 Return the selected thread object." },
2065 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2066 "selected_inferior () -> gdb.Inferior.\n\
2067 Return the selected inferior object." },
2068 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2069 "inferiors () -> (gdb.Inferior, ...).\n\
2070 Return a tuple containing all inferiors." },
2072 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2073 "invalidate_cached_frames () -> None.\n\
2074 Invalidate any cached frame objects in gdb.\n\
2075 Intended for internal use only." },
2077 {NULL
, NULL
, 0, NULL
}
2081 struct PyModuleDef python_GdbModuleDef
=
2083 PyModuleDef_HEAD_INIT
,
2094 #endif /* HAVE_PYTHON */