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
;
322 struct cleanup
*cleanup
;
325 cleanup
= make_cleanup_restore_integer (¤t_ui
->async
);
326 current_ui
->async
= 0;
328 arg
= skip_spaces (arg
);
330 ensure_python_env (get_current_arch (), current_language
);
334 int len
= strlen (arg
);
335 char *script
= (char *) xmalloc (len
+ 2);
337 strcpy (script
, arg
);
339 script
[len
+ 1] = '\0';
340 err
= eval_python_command (script
);
345 err
= PyRun_InteractiveLoop (ui
->instream
, "<stdin>");
351 gdbpy_print_stack ();
352 error (_("Error while executing Python code."));
355 do_cleanups (cleanup
);
358 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
361 On Windows hosts few users would build Python themselves (this is no
362 trivial task on this platform), and thus use binaries built by
363 someone else instead. There may happen situation where the Python
364 library and GDB are using two different versions of the C runtime
365 library. Python, being built with VC, would use one version of the
366 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
367 A FILE * from one runtime does not necessarily operate correctly in
370 To work around this potential issue, we create on Windows hosts the
371 FILE object using Python routines, thus making sure that it is
372 compatible with the Python library. */
375 python_run_simple_file (FILE *file
, const char *filename
)
379 PyRun_SimpleFile (file
, filename
);
384 PyObject
*python_file
;
385 struct cleanup
*cleanup
;
387 /* Because we have a string for a filename, and are using Python to
388 open the file, we need to expand any tilde in the path first. */
389 full_path
= tilde_expand (filename
);
390 cleanup
= make_cleanup (xfree
, full_path
);
391 python_file
= PyFile_FromString (full_path
, "r");
394 do_cleanups (cleanup
);
395 gdbpy_print_stack ();
396 error (_("Error while opening file: %s"), full_path
);
399 make_cleanup_py_decref (python_file
);
400 PyRun_SimpleFile (PyFile_AsFile (python_file
), filename
);
401 do_cleanups (cleanup
);
406 /* Given a command_line, return a command string suitable for passing
407 to Python. Lines in the string are separated by newlines. The
408 return value is allocated using xmalloc and the caller is
409 responsible for freeing it. */
412 compute_python_string (struct command_line
*l
)
414 struct command_line
*iter
;
419 for (iter
= l
; iter
; iter
= iter
->next
)
420 size
+= strlen (iter
->line
) + 1;
422 script
= (char *) xmalloc (size
+ 1);
424 for (iter
= l
; iter
; iter
= iter
->next
)
426 int len
= strlen (iter
->line
);
428 strcpy (&script
[here
], iter
->line
);
430 script
[here
++] = '\n';
436 /* Take a command line structure representing a 'python' command, and
437 evaluate its body using the Python interpreter. */
440 gdbpy_eval_from_control_command (const struct extension_language_defn
*extlang
,
441 struct command_line
*cmd
)
445 struct cleanup
*cleanup
;
447 if (cmd
->body_count
!= 1)
448 error (_("Invalid \"python\" block structure."));
450 cleanup
= ensure_python_env (get_current_arch (), current_language
);
452 script
= compute_python_string (cmd
->body_list
[0]);
453 ret
= PyRun_SimpleString (script
);
456 error (_("Error while executing Python code."));
458 do_cleanups (cleanup
);
461 /* Implementation of the gdb "python" command. */
464 python_command (char *arg
, int from_tty
)
466 struct cleanup
*cleanup
;
468 cleanup
= ensure_python_env (get_current_arch (), current_language
);
470 make_cleanup_restore_integer (¤t_ui
->async
);
471 current_ui
->async
= 0;
473 arg
= skip_spaces (arg
);
476 if (PyRun_SimpleString (arg
))
477 error (_("Error while executing Python code."));
481 struct command_line
*l
= get_command_line (python_control
, "");
483 make_cleanup_free_command_lines (&l
);
484 execute_control_command_untraced (l
);
487 do_cleanups (cleanup
);
492 /* Transform a gdb parameters's value into a Python value. May return
493 NULL (and set a Python exception) on error. Helper function for
496 gdbpy_parameter_value (enum var_types type
, void *var
)
501 case var_string_noescape
:
502 case var_optional_filename
:
506 char *str
= * (char **) var
;
510 return host_string_to_python_string (str
);
521 case var_auto_boolean
:
523 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
525 if (ab
== AUTO_BOOLEAN_TRUE
)
527 else if (ab
== AUTO_BOOLEAN_FALSE
)
534 if ((* (int *) var
) == INT_MAX
)
538 return PyLong_FromLong (* (int *) var
);
542 unsigned int val
= * (unsigned int *) var
;
546 return PyLong_FromUnsignedLong (val
);
550 return PyErr_Format (PyExc_RuntimeError
,
551 _("Programmer error: unhandled type."));
554 /* A Python function which returns a gdb parameter's value as a Python
558 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
560 struct gdb_exception except
= exception_none
;
561 struct cmd_list_element
*alias
, *prefix
, *cmd
;
566 if (! PyArg_ParseTuple (args
, "s", &arg
))
569 newarg
= concat ("show ", arg
, (char *) NULL
);
573 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
575 CATCH (ex
, RETURN_MASK_ALL
)
582 GDB_PY_HANDLE_EXCEPTION (except
);
584 return PyErr_Format (PyExc_RuntimeError
,
585 _("Could not find parameter `%s'."), arg
);
588 return PyErr_Format (PyExc_RuntimeError
,
589 _("`%s' is not a parameter."), arg
);
590 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
593 /* Wrapper for target_charset. */
596 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
598 const char *cset
= target_charset (python_gdbarch
);
600 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
603 /* Wrapper for target_wide_charset. */
606 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
608 const char *cset
= target_wide_charset (python_gdbarch
);
610 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
613 /* A Python function which evaluates a string using the gdb CLI. */
616 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
619 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
620 int from_tty
, to_string
;
621 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
624 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
625 &PyBool_Type
, &from_tty_obj
,
626 &PyBool_Type
, &to_string_obj
))
632 int cmp
= PyObject_IsTrue (from_tty_obj
);
641 int cmp
= PyObject_IsTrue (to_string_obj
);
649 /* Copy the argument text in case the command modifies it. */
650 char *copy
= xstrdup (arg
);
651 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
652 struct interp
*interp
;
654 make_cleanup_restore_integer (¤t_ui
->async
);
655 current_ui
->async
= 0;
657 make_cleanup_restore_ui_out (¤t_uiout
);
658 /* Use the console interpreter uiout to have the same print format
659 for console or MI. */
660 interp
= interp_lookup (current_ui
, "console");
661 current_uiout
= interp_ui_out (interp
);
663 prevent_dont_repeat ();
665 result
= execute_command_to_string (copy
, from_tty
);
669 execute_command (copy
, from_tty
);
672 do_cleanups (cleanup
);
674 CATCH (except
, RETURN_MASK_ALL
)
676 GDB_PY_HANDLE_EXCEPTION (except
);
680 /* Do any commands attached to breakpoint we stopped at. */
681 bpstat_do_actions ();
685 PyObject
*r
= PyString_FromString (result
);
692 /* Implementation of gdb.solib_name (Long) -> String.
693 Returns the name of the shared library holding a given address, or None. */
696 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
702 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc
))
705 soname
= solib_name_from_address (current_program_space
, pc
);
707 str_obj
= host_string_to_python_string (soname
);
717 /* A Python function which is a wrapper for decode_line_1. */
720 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
722 struct gdb_exception except
= exception_none
;
723 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
725 struct symtab_and_line sal
;
727 struct cleanup
*cleanups
;
728 PyObject
*result
= NULL
;
729 PyObject
*return_result
= NULL
;
730 PyObject
*unparsed
= NULL
;
731 struct event_location
*location
= NULL
;
733 if (! PyArg_ParseTuple (args
, "|s", &arg
))
736 cleanups
= make_cleanup (null_cleanup
, NULL
);
742 location
= new_linespec_location (&arg
);
743 make_cleanup_delete_event_location (location
);
748 if (location
!= NULL
)
749 sals
= decode_line_1 (location
, 0, NULL
, NULL
, 0);
752 set_default_source_symtab_and_line ();
753 sal
= get_current_source_symtab_and_line ();
758 CATCH (ex
, RETURN_MASK_ALL
)
764 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
765 make_cleanup (xfree
, sals
.sals
);
767 if (except
.reason
< 0)
769 do_cleanups (cleanups
);
770 /* We know this will always throw. */
771 gdbpy_convert_exception (except
);
779 result
= PyTuple_New (sals
.nelts
);
782 for (i
= 0; i
< sals
.nelts
; ++i
)
786 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
793 PyTuple_SetItem (result
, i
, obj
);
802 return_result
= PyTuple_New (2);
809 if (arg
!= NULL
&& strlen (arg
) > 0)
811 unparsed
= PyString_FromString (arg
);
812 if (unparsed
== NULL
)
815 Py_DECREF (return_result
);
816 return_result
= NULL
;
826 PyTuple_SetItem (return_result
, 0, unparsed
);
827 PyTuple_SetItem (return_result
, 1, result
);
830 do_cleanups (cleanups
);
832 return return_result
;
835 /* Parse a string and evaluate it as an expression. */
837 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
839 const char *expr_str
;
840 struct value
*result
= NULL
;
842 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
847 result
= parse_and_eval (expr_str
);
849 CATCH (except
, RETURN_MASK_ALL
)
851 GDB_PY_HANDLE_EXCEPTION (except
);
855 return value_to_value_object (result
);
858 /* Implementation of gdb.find_pc_line function.
859 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
862 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
864 gdb_py_ulongest pc_llu
;
865 PyObject
*result
= NULL
; /* init for gcc -Wall */
867 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
872 struct symtab_and_line sal
;
875 pc
= (CORE_ADDR
) pc_llu
;
876 sal
= find_pc_line (pc
, 0);
877 result
= symtab_and_line_to_sal_object (sal
);
879 CATCH (except
, RETURN_MASK_ALL
)
881 GDB_PY_HANDLE_EXCEPTION (except
);
888 /* Implementation of gdb.invalidate_cached_frames. */
891 gdbpy_invalidate_cached_frames (PyObject
*self
, PyObject
*args
)
893 reinit_frame_cache ();
897 /* Read a file as Python code.
898 This is the extension_language_script_ops.script_sourcer "method".
899 FILE is the file to load. FILENAME is name of the file FILE.
900 This does not throw any errors. If an exception occurs python will print
901 the traceback and clear the error indicator. */
904 gdbpy_source_script (const struct extension_language_defn
*extlang
,
905 FILE *file
, const char *filename
)
907 struct cleanup
*cleanup
;
909 cleanup
= ensure_python_env (get_current_arch (), current_language
);
910 python_run_simple_file (file
, filename
);
911 do_cleanups (cleanup
);
916 /* Posting and handling events. */
918 /* A single event. */
921 /* The Python event. This is just a callable object. */
923 /* The next event. */
924 struct gdbpy_event
*next
;
927 /* All pending events. */
928 static struct gdbpy_event
*gdbpy_event_list
;
929 /* The final link of the event list. */
930 static struct gdbpy_event
**gdbpy_event_list_end
;
932 /* So that we can wake up the main thread even when it is blocked in
934 static struct serial_event
*gdbpy_serial_event
;
936 /* The file handler callback. This reads from the internal pipe, and
937 then processes the Python event queue. This will always be run in
938 the main gdb thread. */
941 gdbpy_run_events (int error
, gdb_client_data client_data
)
943 struct cleanup
*cleanup
;
945 cleanup
= ensure_python_env (get_current_arch (), current_language
);
947 /* Clear the event fd. Do this before flushing the events list, so
948 that any new event post afterwards is sure to re-awake the event
950 serial_event_clear (gdbpy_serial_event
);
952 while (gdbpy_event_list
)
954 PyObject
*call_result
;
956 /* Dispatching the event might push a new element onto the event
957 loop, so we update here "atomically enough". */
958 struct gdbpy_event
*item
= gdbpy_event_list
;
959 gdbpy_event_list
= gdbpy_event_list
->next
;
960 if (gdbpy_event_list
== NULL
)
961 gdbpy_event_list_end
= &gdbpy_event_list
;
964 call_result
= PyObject_CallObject (item
->event
, NULL
);
965 if (call_result
== NULL
)
968 Py_XDECREF (call_result
);
969 Py_DECREF (item
->event
);
973 do_cleanups (cleanup
);
976 /* Submit an event to the gdb thread. */
978 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
980 struct gdbpy_event
*event
;
984 if (!PyArg_ParseTuple (args
, "O", &func
))
987 if (!PyCallable_Check (func
))
989 PyErr_SetString (PyExc_RuntimeError
,
990 _("Posted event is not callable"));
996 /* From here until the end of the function, we have the GIL, so we
997 can operate on our global data structures without worrying. */
998 wakeup
= gdbpy_event_list
== NULL
;
1000 event
= XNEW (struct gdbpy_event
);
1001 event
->event
= func
;
1003 *gdbpy_event_list_end
= event
;
1004 gdbpy_event_list_end
= &event
->next
;
1006 /* Wake up gdb when needed. */
1008 serial_event_set (gdbpy_serial_event
);
1013 /* Initialize the Python event handler. */
1015 gdbpy_initialize_events (void)
1017 gdbpy_event_list_end
= &gdbpy_event_list
;
1019 gdbpy_serial_event
= make_serial_event ();
1020 add_file_handler (serial_event_fd (gdbpy_serial_event
),
1021 gdbpy_run_events
, NULL
);
1028 /* This is the extension_language_ops.before_prompt "method". */
1030 static enum ext_lang_rc
1031 gdbpy_before_prompt_hook (const struct extension_language_defn
*extlang
,
1032 const char *current_gdb_prompt
)
1034 struct cleanup
*cleanup
;
1035 char *prompt
= NULL
;
1037 if (!gdb_python_initialized
)
1038 return EXT_LANG_RC_NOP
;
1040 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1042 if (gdb_python_module
1043 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
1047 hook
= PyObject_GetAttrString (gdb_python_module
, "prompt_hook");
1051 make_cleanup_py_decref (hook
);
1053 if (PyCallable_Check (hook
))
1056 PyObject
*current_prompt
;
1058 current_prompt
= PyString_FromString (current_gdb_prompt
);
1059 if (current_prompt
== NULL
)
1062 result
= PyObject_CallFunctionObjArgs (hook
, current_prompt
, NULL
);
1064 Py_DECREF (current_prompt
);
1069 make_cleanup_py_decref (result
);
1071 /* Return type should be None, or a String. If it is None,
1072 fall through, we will not set a prompt. If it is a
1073 string, set PROMPT. Anything else, set an exception. */
1074 if (result
!= Py_None
&& ! PyString_Check (result
))
1076 PyErr_Format (PyExc_RuntimeError
,
1077 _("Return from prompt_hook must " \
1078 "be either a Python string, or None"));
1082 if (result
!= Py_None
)
1084 prompt
= python_string_to_host_string (result
);
1089 make_cleanup (xfree
, prompt
);
1094 /* If a prompt has been set, PROMPT will not be NULL. If it is
1095 NULL, do not set the prompt. */
1097 set_prompt (prompt
);
1099 do_cleanups (cleanup
);
1100 return prompt
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_NOP
;
1103 gdbpy_print_stack ();
1104 do_cleanups (cleanup
);
1105 return EXT_LANG_RC_ERROR
;
1112 /* A python function to write a single string using gdb's filtered
1113 output stream . The optional keyword STREAM can be used to write
1114 to a particular stream. The default stream is to gdb_stdout. */
1117 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1120 static char *keywords
[] = {"text", "stream", NULL
};
1121 int stream_type
= 0;
1123 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
1129 switch (stream_type
)
1133 fprintf_filtered (gdb_stderr
, "%s", arg
);
1138 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1142 fprintf_filtered (gdb_stdout
, "%s", arg
);
1145 CATCH (except
, RETURN_MASK_ALL
)
1147 GDB_PY_HANDLE_EXCEPTION (except
);
1154 /* A python function to flush a gdb stream. The optional keyword
1155 STREAM can be used to flush a particular stream. The default stream
1159 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1161 static char *keywords
[] = {"stream", NULL
};
1162 int stream_type
= 0;
1164 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1168 switch (stream_type
)
1172 gdb_flush (gdb_stderr
);
1177 gdb_flush (gdb_stdlog
);
1181 gdb_flush (gdb_stdout
);
1187 /* Return non-zero if print-stack is not "none". */
1190 gdbpy_print_python_errors_p (void)
1192 return gdbpy_should_print_stack
!= python_excp_none
;
1195 /* Print a python exception trace, print just a message, or print
1196 nothing and clear the python exception, depending on
1197 gdbpy_should_print_stack. Only call this if a python exception is
1200 gdbpy_print_stack (void)
1203 /* Print "none", just clear exception. */
1204 if (gdbpy_should_print_stack
== python_excp_none
)
1208 /* Print "full" message and backtrace. */
1209 else if (gdbpy_should_print_stack
== python_excp_full
)
1212 /* PyErr_Print doesn't necessarily end output with a newline.
1213 This works because Python's stdout/stderr is fed through
1219 CATCH (except
, RETURN_MASK_ALL
)
1224 /* Print "message", just error print message. */
1227 PyObject
*ptype
, *pvalue
, *ptraceback
;
1228 char *msg
= NULL
, *type
= NULL
;
1230 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1232 /* Fetch the error message contained within ptype, pvalue. */
1233 msg
= gdbpy_exception_to_string (ptype
, pvalue
);
1234 type
= gdbpy_obj_to_string (ptype
);
1240 /* An error occurred computing the string representation of the
1242 fprintf_filtered (gdb_stderr
,
1243 _("Error occurred computing Python error" \
1247 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1250 CATCH (except
, RETURN_MASK_ALL
)
1256 Py_XDECREF (pvalue
);
1257 Py_XDECREF (ptraceback
);
1264 /* Return the current Progspace.
1265 There always is one. */
1268 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1272 result
= pspace_to_pspace_object (current_program_space
);
1278 /* Return a sequence holding all the Progspaces. */
1281 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1283 struct program_space
*ps
;
1286 list
= PyList_New (0);
1292 PyObject
*item
= pspace_to_pspace_object (ps
);
1294 if (!item
|| PyList_Append (list
, item
) == -1)
1306 /* The "current" objfile. This is set when gdb detects that a new
1307 objfile has been loaded. It is only set for the duration of a call to
1308 gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL
1310 static struct objfile
*gdbpy_current_objfile
;
1312 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1313 as Python code. This does not throw any errors. If an exception
1314 occurs python will print the traceback and clear the error indicator.
1315 This is the extension_language_script_ops.objfile_script_sourcer
1319 gdbpy_source_objfile_script (const struct extension_language_defn
*extlang
,
1320 struct objfile
*objfile
, FILE *file
,
1321 const char *filename
)
1323 struct cleanup
*cleanups
;
1325 if (!gdb_python_initialized
)
1328 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1329 gdbpy_current_objfile
= objfile
;
1331 python_run_simple_file (file
, filename
);
1333 do_cleanups (cleanups
);
1334 gdbpy_current_objfile
= NULL
;
1337 /* Set the current objfile to OBJFILE and then execute SCRIPT
1338 as Python code. This does not throw any errors. If an exception
1339 occurs python will print the traceback and clear the error indicator.
1340 This is the extension_language_script_ops.objfile_script_executor
1344 gdbpy_execute_objfile_script (const struct extension_language_defn
*extlang
,
1345 struct objfile
*objfile
, const char *name
,
1348 struct cleanup
*cleanups
;
1350 if (!gdb_python_initialized
)
1353 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1354 gdbpy_current_objfile
= objfile
;
1356 PyRun_SimpleString (script
);
1358 do_cleanups (cleanups
);
1359 gdbpy_current_objfile
= NULL
;
1362 /* Return the current Objfile, or None if there isn't one. */
1365 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1369 if (! gdbpy_current_objfile
)
1372 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1378 /* Return a sequence holding all the Objfiles. */
1381 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1383 struct objfile
*objf
;
1386 list
= PyList_New (0);
1392 PyObject
*item
= objfile_to_objfile_object (objf
);
1394 if (!item
|| PyList_Append (list
, item
) == -1)
1404 /* Compute the list of active python type printers and store them in
1405 EXT_PRINTERS->py_type_printers. The product of this function is used by
1406 gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers.
1407 This is the extension_language_ops.start_type_printers "method". */
1410 gdbpy_start_type_printers (const struct extension_language_defn
*extlang
,
1411 struct ext_lang_type_printers
*ext_printers
)
1413 struct cleanup
*cleanups
;
1414 PyObject
*type_module
, *func
= NULL
, *printers_obj
= NULL
;
1416 if (!gdb_python_initialized
)
1419 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1421 type_module
= PyImport_ImportModule ("gdb.types");
1422 if (type_module
== NULL
)
1424 gdbpy_print_stack ();
1428 func
= PyObject_GetAttrString (type_module
, "get_type_recognizers");
1431 gdbpy_print_stack ();
1435 printers_obj
= PyObject_CallFunctionObjArgs (func
, (char *) NULL
);
1436 if (printers_obj
== NULL
)
1437 gdbpy_print_stack ();
1439 ext_printers
->py_type_printers
= printers_obj
;
1442 Py_XDECREF (type_module
);
1444 do_cleanups (cleanups
);
1447 /* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE
1448 a newly allocated string holding the type's replacement name, and return
1449 EXT_LANG_RC_OK. The caller is responsible for freeing the string.
1450 If there's a Python error return EXT_LANG_RC_ERROR.
1451 Otherwise, return EXT_LANG_RC_NOP.
1452 This is the extension_language_ops.apply_type_printers "method". */
1454 static enum ext_lang_rc
1455 gdbpy_apply_type_printers (const struct extension_language_defn
*extlang
,
1456 const struct ext_lang_type_printers
*ext_printers
,
1457 struct type
*type
, char **prettied_type
)
1459 struct cleanup
*cleanups
;
1460 PyObject
*type_obj
, *type_module
= NULL
, *func
= NULL
;
1461 PyObject
*result_obj
= NULL
;
1462 PyObject
*printers_obj
= (PyObject
*) ext_printers
->py_type_printers
;
1463 char *result
= NULL
;
1465 if (printers_obj
== NULL
)
1466 return EXT_LANG_RC_NOP
;
1468 if (!gdb_python_initialized
)
1469 return EXT_LANG_RC_NOP
;
1471 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1473 type_obj
= type_to_type_object (type
);
1474 if (type_obj
== NULL
)
1476 gdbpy_print_stack ();
1480 type_module
= PyImport_ImportModule ("gdb.types");
1481 if (type_module
== NULL
)
1483 gdbpy_print_stack ();
1487 func
= PyObject_GetAttrString (type_module
, "apply_type_recognizers");
1490 gdbpy_print_stack ();
1494 result_obj
= PyObject_CallFunctionObjArgs (func
, printers_obj
,
1495 type_obj
, (char *) NULL
);
1496 if (result_obj
== NULL
)
1498 gdbpy_print_stack ();
1502 if (result_obj
!= Py_None
)
1504 result
= python_string_to_host_string (result_obj
);
1506 gdbpy_print_stack ();
1510 Py_XDECREF (type_obj
);
1511 Py_XDECREF (type_module
);
1513 Py_XDECREF (result_obj
);
1514 do_cleanups (cleanups
);
1516 *prettied_type
= result
;
1517 return result
!= NULL
? EXT_LANG_RC_OK
: EXT_LANG_RC_ERROR
;
1520 /* Free the result of start_type_printers.
1521 This is the extension_language_ops.free_type_printers "method". */
1524 gdbpy_free_type_printers (const struct extension_language_defn
*extlang
,
1525 struct ext_lang_type_printers
*ext_printers
)
1527 struct cleanup
*cleanups
;
1528 PyObject
*printers
= (PyObject
*) ext_printers
->py_type_printers
;
1530 if (printers
== NULL
)
1533 if (!gdb_python_initialized
)
1536 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1537 Py_DECREF (printers
);
1538 do_cleanups (cleanups
);
1541 #else /* HAVE_PYTHON */
1543 /* Dummy implementation of the gdb "python-interactive" and "python"
1547 python_interactive_command (char *arg
, int from_tty
)
1549 arg
= skip_spaces (arg
);
1551 error (_("Python scripting is not supported in this copy of GDB."));
1554 struct command_line
*l
= get_command_line (python_control
, "");
1555 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1557 execute_control_command_untraced (l
);
1558 do_cleanups (cleanups
);
1563 python_command (char *arg
, int from_tty
)
1565 python_interactive_command (arg
, from_tty
);
1568 #endif /* HAVE_PYTHON */
1572 /* Lists for 'set python' commands. */
1574 static struct cmd_list_element
*user_set_python_list
;
1575 static struct cmd_list_element
*user_show_python_list
;
1577 /* Function for use by 'set python' prefix command. */
1580 user_set_python (char *args
, int from_tty
)
1582 help_list (user_set_python_list
, "set python ", all_commands
,
1586 /* Function for use by 'show python' prefix command. */
1589 user_show_python (char *args
, int from_tty
)
1591 cmd_show_list (user_show_python_list
, from_tty
, "");
1594 /* Initialize the Python code. */
1598 /* This is installed as a final cleanup and cleans up the
1599 interpreter. This lets Python's 'atexit' work. */
1602 finalize_python (void *ignore
)
1604 struct active_ext_lang_state
*previous_active
;
1606 /* We don't use ensure_python_env here because if we ever ran the
1607 cleanup, gdb would crash -- because the cleanup calls into the
1608 Python interpreter, which we are about to destroy. It seems
1609 clearer to make the needed calls explicitly here than to create a
1610 cleanup and then mysteriously discard it. */
1612 /* This is only called as a final cleanup so we can assume the active
1613 SIGINT handler is gdb's. We still need to tell it to notify Python. */
1614 previous_active
= set_active_ext_lang (&extension_language_python
);
1616 (void) PyGILState_Ensure ();
1617 python_gdbarch
= target_gdbarch ();
1618 python_language
= current_language
;
1622 restore_active_ext_lang (previous_active
);
1626 /* Provide a prototype to silence -Wmissing-prototypes. */
1627 extern initialize_file_ftype _initialize_python
;
1630 _initialize_python (void)
1635 size_t progsize
, count
;
1637 wchar_t *progname_copy
;
1640 add_com ("python-interactive", class_obscure
,
1641 python_interactive_command
,
1644 Start an interactive Python prompt.\n\
1646 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1649 Alternatively, a single-line Python command can be given as an\n\
1650 argument, and if the command is an expression, the result will be\n\
1651 printed. For example:\n\
1653 (gdb) python-interactive 2 + 3\n\
1656 #else /* HAVE_PYTHON */
1658 Start a Python interactive prompt.\n\
1660 Python scripting is not supported in this copy of GDB.\n\
1661 This command is only a placeholder.")
1662 #endif /* HAVE_PYTHON */
1664 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1666 add_com ("python", class_obscure
, python_command
,
1669 Evaluate a Python command.\n\
1671 The command can be given as an argument, for instance:\n\
1675 If no argument is given, the following lines are read and used\n\
1676 as the Python commands. Type a line containing \"end\" to indicate\n\
1677 the end of the command.")
1678 #else /* HAVE_PYTHON */
1680 Evaluate a Python command.\n\
1682 Python scripting is not supported in this copy of GDB.\n\
1683 This command is only a placeholder.")
1684 #endif /* HAVE_PYTHON */
1686 add_com_alias ("py", "python", class_obscure
, 1);
1688 /* Add set/show python print-stack. */
1689 add_prefix_cmd ("python", no_class
, user_show_python
,
1690 _("Prefix command for python preference settings."),
1691 &user_show_python_list
, "show python ", 0,
1694 add_prefix_cmd ("python", no_class
, user_set_python
,
1695 _("Prefix command for python preference settings."),
1696 &user_set_python_list
, "set python ", 0,
1699 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1700 &gdbpy_should_print_stack
, _("\
1701 Set mode for Python stack dump on error."), _("\
1702 Show the mode of Python stack printing on error."), _("\
1703 none == no stack or message will be printed.\n\
1704 full == a message and a stack will be printed.\n\
1705 message == an error message without a stack will be printed."),
1707 &user_set_python_list
,
1708 &user_show_python_list
);
1711 #ifdef WITH_PYTHON_PATH
1712 /* Work around problem where python gets confused about where it is,
1713 and then can't find its libraries, etc.
1714 NOTE: Python assumes the following layout:
1716 /foo/lib/pythonX.Y/...
1717 This must be done before calling Py_Initialize. */
1718 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1719 SLASH_STRING
, "python", (char *) NULL
);
1721 oldloc
= xstrdup (setlocale (LC_ALL
, NULL
));
1722 setlocale (LC_ALL
, "");
1723 progsize
= strlen (progname
);
1724 progname_copy
= (wchar_t *) PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1728 fprintf (stderr
, "out of memory\n");
1731 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1732 if (count
== (size_t) -1)
1735 fprintf (stderr
, "Could not convert python path to string\n");
1738 setlocale (LC_ALL
, oldloc
);
1741 /* Note that Py_SetProgramName expects the string it is passed to
1742 remain alive for the duration of the program's execution, so
1743 it is not freed after this call. */
1744 Py_SetProgramName (progname_copy
);
1746 Py_SetProgramName (progname
);
1751 PyEval_InitThreads ();
1754 gdb_module
= PyModule_Create (&python_GdbModuleDef
);
1755 /* Add _gdb module to the list of known built-in modules. */
1756 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1758 gdb_module
= Py_InitModule ("_gdb", python_GdbMethods
);
1760 if (gdb_module
== NULL
)
1763 /* The casts to (char*) are for python 2.4. */
1764 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1765 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1766 (char*) host_name
) < 0
1767 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1768 (char*) target_name
) < 0)
1771 /* Add stream constants. */
1772 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1773 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1774 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1777 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1778 if (gdbpy_gdb_error
== NULL
1779 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1782 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1783 gdbpy_gdb_error
, NULL
);
1784 if (gdbpy_gdb_memory_error
== NULL
1785 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1786 gdbpy_gdb_memory_error
) < 0)
1789 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1790 if (gdbpy_gdberror_exc
== NULL
1791 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1792 gdbpy_gdberror_exc
) < 0)
1795 gdbpy_initialize_gdb_readline ();
1797 if (gdbpy_initialize_auto_load () < 0
1798 || gdbpy_initialize_values () < 0
1799 || gdbpy_initialize_frames () < 0
1800 || gdbpy_initialize_commands () < 0
1801 || gdbpy_initialize_symbols () < 0
1802 || gdbpy_initialize_symtabs () < 0
1803 || gdbpy_initialize_blocks () < 0
1804 || gdbpy_initialize_functions () < 0
1805 || gdbpy_initialize_parameters () < 0
1806 || gdbpy_initialize_types () < 0
1807 || gdbpy_initialize_pspace () < 0
1808 || gdbpy_initialize_objfile () < 0
1809 || gdbpy_initialize_breakpoints () < 0
1810 || gdbpy_initialize_finishbreakpoints () < 0
1811 || gdbpy_initialize_lazy_string () < 0
1812 || gdbpy_initialize_linetable () < 0
1813 || gdbpy_initialize_thread () < 0
1814 || gdbpy_initialize_inferior () < 0
1815 || gdbpy_initialize_events () < 0
1816 || gdbpy_initialize_eventregistry () < 0
1817 || gdbpy_initialize_py_events () < 0
1818 || gdbpy_initialize_event () < 0
1819 || gdbpy_initialize_stop_event () < 0
1820 || gdbpy_initialize_signal_event () < 0
1821 || gdbpy_initialize_breakpoint_event () < 0
1822 || gdbpy_initialize_continue_event () < 0
1823 || gdbpy_initialize_inferior_call_pre_event () < 0
1824 || gdbpy_initialize_inferior_call_post_event () < 0
1825 || gdbpy_initialize_register_changed_event () < 0
1826 || gdbpy_initialize_memory_changed_event () < 0
1827 || gdbpy_initialize_exited_event () < 0
1828 || gdbpy_initialize_thread_event () < 0
1829 || gdbpy_initialize_new_objfile_event () < 0
1830 || gdbpy_initialize_clear_objfiles_event () < 0
1831 || gdbpy_initialize_arch () < 0
1832 || gdbpy_initialize_xmethods () < 0
1833 || gdbpy_initialize_unwind () < 0)
1836 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1837 if (gdbpy_to_string_cst
== NULL
)
1839 gdbpy_children_cst
= PyString_FromString ("children");
1840 if (gdbpy_children_cst
== NULL
)
1842 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1843 if (gdbpy_display_hint_cst
== NULL
)
1845 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1846 if (gdbpy_doc_cst
== NULL
)
1848 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1849 if (gdbpy_enabled_cst
== NULL
)
1851 gdbpy_value_cst
= PyString_FromString ("value");
1852 if (gdbpy_value_cst
== NULL
)
1855 /* Release the GIL while gdb runs. */
1856 PyThreadState_Swap (NULL
);
1857 PyEval_ReleaseLock ();
1859 make_final_cleanup (finalize_python
, NULL
);
1861 gdb_python_initialized
= 1;
1865 gdbpy_print_stack ();
1866 /* Do not set 'gdb_python_initialized'. */
1869 #endif /* HAVE_PYTHON */
1874 /* Perform the remaining python initializations.
1875 These must be done after GDB is at least mostly initialized.
1876 E.g., The "info pretty-printer" command needs the "info" prefix
1878 This is the extension_language_ops.finish_initialization "method". */
1881 gdbpy_finish_initialization (const struct extension_language_defn
*extlang
)
1884 char *gdb_pythondir
;
1886 struct cleanup
*cleanup
;
1888 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1890 /* Add the initial data-directory to sys.path. */
1892 gdb_pythondir
= concat (gdb_datadir
, SLASH_STRING
, "python", (char *) NULL
);
1893 make_cleanup (xfree
, gdb_pythondir
);
1895 sys_path
= PySys_GetObject ("path");
1897 /* If sys.path is not defined yet, define it first. */
1898 if (!(sys_path
&& PyList_Check (sys_path
)))
1901 PySys_SetPath (L
"");
1905 sys_path
= PySys_GetObject ("path");
1907 if (sys_path
&& PyList_Check (sys_path
))
1909 PyObject
*pythondir
;
1912 pythondir
= PyString_FromString (gdb_pythondir
);
1913 if (pythondir
== NULL
)
1916 err
= PyList_Insert (sys_path
, 0, pythondir
);
1917 Py_DECREF (pythondir
);
1924 /* Import the gdb module to finish the initialization, and
1925 add it to __main__ for convenience. */
1926 m
= PyImport_AddModule ("__main__");
1930 gdb_python_module
= PyImport_ImportModule ("gdb");
1931 if (gdb_python_module
== NULL
)
1933 gdbpy_print_stack ();
1934 /* This is passed in one call to warning so that blank lines aren't
1935 inserted between each line of text. */
1937 "Could not load the Python gdb module from `%s'.\n"
1938 "Limited Python support is available from the _gdb module.\n"
1939 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1941 do_cleanups (cleanup
);
1945 if (gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) < 0)
1948 /* Keep the reference to gdb_python_module since it is in a global
1951 do_cleanups (cleanup
);
1955 gdbpy_print_stack ();
1956 warning (_("internal error: Unhandled Python exception"));
1957 do_cleanups (cleanup
);
1960 /* Return non-zero if Python has successfully initialized.
1961 This is the extension_languages_ops.initialized "method". */
1964 gdbpy_initialized (const struct extension_language_defn
*extlang
)
1966 return gdb_python_initialized
;
1969 #endif /* HAVE_PYTHON */
1975 PyMethodDef python_GdbMethods
[] =
1977 { "history", gdbpy_history
, METH_VARARGS
,
1978 "Get a value from history" },
1979 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1980 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1981 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1982 a Python String containing the output of the command if to_string is\n\
1984 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1985 "Return a gdb parameter's value" },
1987 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1988 "Return a tuple of all breakpoint objects" },
1990 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1991 "Find the default visualizer for a Value." },
1993 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1994 "Return the current Progspace." },
1995 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1996 "Return a sequence of all progspaces." },
1998 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1999 "Return the current Objfile being loaded, or None." },
2000 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
2001 "Return a sequence of all loaded objfiles." },
2003 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
2004 "newest_frame () -> gdb.Frame.\n\
2005 Return the newest frame object." },
2006 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
2007 "selected_frame () -> gdb.Frame.\n\
2008 Return the selected frame object." },
2009 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
2010 "stop_reason_string (Integer) -> String.\n\
2011 Return a string explaining unwind stop reason." },
2013 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
2014 METH_VARARGS
| METH_KEYWORDS
,
2015 "lookup_type (name [, block]) -> type\n\
2016 Return a Type corresponding to the given name." },
2017 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
2018 METH_VARARGS
| METH_KEYWORDS
,
2019 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
2020 Return a tuple with the symbol corresponding to the given name (or None) and\n\
2021 a boolean indicating if name is a field of the current implied argument\n\
2022 `this' (when the current language is object-oriented)." },
2023 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
2024 METH_VARARGS
| METH_KEYWORDS
,
2025 "lookup_global_symbol (name [, domain]) -> symbol\n\
2026 Return the symbol corresponding to the given name (or None)." },
2028 { "lookup_objfile", (PyCFunction
) gdbpy_lookup_objfile
,
2029 METH_VARARGS
| METH_KEYWORDS
,
2030 "lookup_objfile (name, [by_build_id]) -> objfile\n\
2031 Look up the specified objfile.\n\
2032 If by_build_id is True, the objfile is looked up by using name\n\
2033 as its build id." },
2035 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
2036 "Return the block containing the given pc value, or None." },
2037 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
2038 "solib_name (Long) -> String.\n\
2039 Return the name of the shared library holding a given address, or None." },
2040 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
2041 "decode_line (String) -> Tuple. Decode a string argument the way\n\
2042 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
2043 The first element contains any unparsed portion of the String parameter\n\
2044 (or None if the string was fully parsed). The second element contains\n\
2045 a tuple that contains all the locations that match, represented as\n\
2046 gdb.Symtab_and_line objects (or None)."},
2047 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
2048 "parse_and_eval (String) -> Value.\n\
2049 Parse String as an expression, evaluate it, and return the result as a Value."
2051 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
2052 "find_pc_line (pc) -> Symtab_and_line.\n\
2053 Return the gdb.Symtab_and_line object corresponding to the pc value." },
2055 { "post_event", gdbpy_post_event
, METH_VARARGS
,
2056 "Post an event into gdb's event loop." },
2058 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
2059 "target_charset () -> string.\n\
2060 Return the name of the current target charset." },
2061 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
2062 "target_wide_charset () -> string.\n\
2063 Return the name of the current target wide charset." },
2065 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
2066 "string_to_argv (String) -> Array.\n\
2067 Parse String and return an argv-like array.\n\
2068 Arguments are separate by spaces and may be quoted."
2070 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
2071 "Write a string using gdb's filtered stream." },
2072 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
2073 "Flush gdb's filtered stdout stream." },
2074 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
2075 "selected_thread () -> gdb.InferiorThread.\n\
2076 Return the selected thread object." },
2077 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
2078 "selected_inferior () -> gdb.Inferior.\n\
2079 Return the selected inferior object." },
2080 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
2081 "inferiors () -> (gdb.Inferior, ...).\n\
2082 Return a tuple containing all inferiors." },
2084 { "invalidate_cached_frames", gdbpy_invalidate_cached_frames
, METH_NOARGS
,
2085 "invalidate_cached_frames () -> None.\n\
2086 Invalidate any cached frame objects in gdb.\n\
2087 Intended for internal use only." },
2089 {NULL
, NULL
, 0, NULL
}
2093 struct PyModuleDef python_GdbModuleDef
=
2095 PyModuleDef_HEAD_INIT
,
2106 #endif /* HAVE_PYTHON */