1 /* General python/gdb code
3 Copyright (C) 2008-2013 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 "exceptions.h"
31 #include "event-loop.h"
33 #include "readline/tilde.h"
35 #include "cli/cli-utils.h"
39 /* Declared constants and enum for python stack printing. */
40 static const char python_excp_none
[] = "none";
41 static const char python_excp_full
[] = "full";
42 static const char python_excp_message
[] = "message";
44 /* "set python print-stack" choices. */
45 static const char *const python_excp_enums
[] =
53 /* The exception printing variable. 'full' if we want to print the
54 error message and stack, 'none' if we want to print nothing, and
55 'message' if we only want to print the error message. 'message' is
57 static const char *gdbpy_should_print_stack
= python_excp_message
;
61 #include "libiberty.h"
62 #include "cli/cli-decode.h"
66 #include "python-internal.h"
71 #include "gdbthread.h"
74 #include "event-top.h"
76 /* True if Python has been successfully initialized, false
79 int gdb_python_initialized
;
81 static PyMethodDef GdbMethods
[];
84 static struct PyModuleDef GdbModuleDef
;
88 PyObject
*gdb_python_module
;
90 /* Some string constants we may wish to use. */
91 PyObject
*gdbpy_to_string_cst
;
92 PyObject
*gdbpy_children_cst
;
93 PyObject
*gdbpy_display_hint_cst
;
94 PyObject
*gdbpy_doc_cst
;
95 PyObject
*gdbpy_enabled_cst
;
96 PyObject
*gdbpy_value_cst
;
98 /* The GdbError exception. */
99 PyObject
*gdbpy_gdberror_exc
;
101 /* The `gdb.error' base class. */
102 PyObject
*gdbpy_gdb_error
;
104 /* The `gdb.MemoryError' exception. */
105 PyObject
*gdbpy_gdb_memory_error
;
107 /* Architecture and language to be used in callbacks from
108 the Python interpreter. */
109 struct gdbarch
*python_gdbarch
;
110 const struct language_defn
*python_language
;
112 /* Restore global language and architecture and Python GIL state
113 when leaving the Python interpreter. */
117 PyGILState_STATE state
;
118 struct gdbarch
*gdbarch
;
119 const struct language_defn
*language
;
120 PyObject
*error_type
, *error_value
, *error_traceback
;
124 restore_python_env (void *p
)
126 struct python_env
*env
= (struct python_env
*)p
;
128 /* Leftover Python error is forbidden by Python Exception Handling. */
129 if (PyErr_Occurred ())
131 /* This order is similar to the one calling error afterwards. */
132 gdbpy_print_stack ();
133 warning (_("internal error: Unhandled Python exception"));
136 PyErr_Restore (env
->error_type
, env
->error_value
, env
->error_traceback
);
138 PyGILState_Release (env
->state
);
139 python_gdbarch
= env
->gdbarch
;
140 python_language
= env
->language
;
144 /* Called before entering the Python interpreter to install the
145 current language and architecture to be used for Python values. */
148 ensure_python_env (struct gdbarch
*gdbarch
,
149 const struct language_defn
*language
)
151 struct python_env
*env
= xmalloc (sizeof *env
);
153 /* We should not ever enter Python unless initialized. */
154 if (!gdb_python_initialized
)
155 error (_("Python not initialized"));
157 env
->state
= PyGILState_Ensure ();
158 env
->gdbarch
= python_gdbarch
;
159 env
->language
= python_language
;
161 python_gdbarch
= gdbarch
;
162 python_language
= language
;
164 /* Save it and ensure ! PyErr_Occurred () afterwards. */
165 PyErr_Fetch (&env
->error_type
, &env
->error_value
, &env
->error_traceback
);
167 return make_cleanup (restore_python_env
, env
);
170 /* Clear the quit flag. */
173 clear_quit_flag (void)
175 /* This clears the flag as a side effect. */
176 PyOS_InterruptOccurred ();
179 /* Set the quit flag. */
184 PyErr_SetInterrupt ();
187 /* Return true if the quit flag has been set, false otherwise. */
190 check_quit_flag (void)
192 return PyOS_InterruptOccurred ();
195 /* Evaluate a Python command like PyRun_SimpleString, but uses
196 Py_single_input which prints the result of expressions, and does
197 not automatically print the stack on errors. */
200 eval_python_command (const char *command
)
204 m
= PyImport_AddModule ("__main__");
208 d
= PyModule_GetDict (m
);
211 v
= PyRun_StringFlags (command
, Py_single_input
, d
, d
, NULL
);
224 /* Implementation of the gdb "python-interactive" command. */
227 python_interactive_command (char *arg
, int from_tty
)
229 struct cleanup
*cleanup
;
232 cleanup
= make_cleanup_restore_integer (&interpreter_async
);
233 interpreter_async
= 0;
235 arg
= skip_spaces (arg
);
237 ensure_python_env (get_current_arch (), current_language
);
241 int len
= strlen (arg
);
242 char *script
= xmalloc (len
+ 2);
244 strcpy (script
, arg
);
246 script
[len
+ 1] = '\0';
247 err
= eval_python_command (script
);
252 err
= PyRun_InteractiveLoop (instream
, "<stdin>");
258 gdbpy_print_stack ();
259 error (_("Error while executing Python code."));
262 do_cleanups (cleanup
);
265 /* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
268 On Windows hosts few users would build Python themselves (this is no
269 trivial task on this platform), and thus use binaries built by
270 someone else instead. There may happen situation where the Python
271 library and GDB are using two different versions of the C runtime
272 library. Python, being built with VC, would use one version of the
273 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
274 A FILE * from one runtime does not necessarily operate correctly in
277 To work around this potential issue, we create on Windows hosts the
278 FILE object using Python routines, thus making sure that it is
279 compatible with the Python library. */
282 python_run_simple_file (FILE *file
, const char *filename
)
286 PyRun_SimpleFile (file
, filename
);
291 PyObject
*python_file
;
292 struct cleanup
*cleanup
;
294 /* Because we have a string for a filename, and are using Python to
295 open the file, we need to expand any tilde in the path first. */
296 full_path
= tilde_expand (filename
);
297 cleanup
= make_cleanup (xfree
, full_path
);
298 python_file
= PyFile_FromString (full_path
, "r");
301 do_cleanups (cleanup
);
302 gdbpy_print_stack ();
303 error (_("Error while opening file: %s"), full_path
);
306 make_cleanup_py_decref (python_file
);
307 PyRun_SimpleFile (PyFile_AsFile (python_file
), filename
);
308 do_cleanups (cleanup
);
313 /* Given a command_line, return a command string suitable for passing
314 to Python. Lines in the string are separated by newlines. The
315 return value is allocated using xmalloc and the caller is
316 responsible for freeing it. */
319 compute_python_string (struct command_line
*l
)
321 struct command_line
*iter
;
326 for (iter
= l
; iter
; iter
= iter
->next
)
327 size
+= strlen (iter
->line
) + 1;
329 script
= xmalloc (size
+ 1);
331 for (iter
= l
; iter
; iter
= iter
->next
)
333 int len
= strlen (iter
->line
);
335 strcpy (&script
[here
], iter
->line
);
337 script
[here
++] = '\n';
343 /* Take a command line structure representing a 'python' command, and
344 evaluate its body using the Python interpreter. */
347 eval_python_from_control_command (struct command_line
*cmd
)
351 struct cleanup
*cleanup
;
353 if (cmd
->body_count
!= 1)
354 error (_("Invalid \"python\" block structure."));
356 cleanup
= ensure_python_env (get_current_arch (), current_language
);
358 script
= compute_python_string (cmd
->body_list
[0]);
359 ret
= PyRun_SimpleString (script
);
362 error (_("Error while executing Python code."));
364 do_cleanups (cleanup
);
367 /* Implementation of the gdb "python" command. */
370 python_command (char *arg
, int from_tty
)
372 struct cleanup
*cleanup
;
374 cleanup
= ensure_python_env (get_current_arch (), current_language
);
376 make_cleanup_restore_integer (&interpreter_async
);
377 interpreter_async
= 0;
379 arg
= skip_spaces (arg
);
382 if (PyRun_SimpleString (arg
))
383 error (_("Error while executing Python code."));
387 struct command_line
*l
= get_command_line (python_control
, "");
389 make_cleanup_free_command_lines (&l
);
390 execute_control_command_untraced (l
);
393 do_cleanups (cleanup
);
398 /* Transform a gdb parameters's value into a Python value. May return
399 NULL (and set a Python exception) on error. Helper function for
402 gdbpy_parameter_value (enum var_types type
, void *var
)
407 case var_string_noescape
:
408 case var_optional_filename
:
412 char *str
= * (char **) var
;
416 return PyString_Decode (str
, strlen (str
), host_charset (), NULL
);
427 case var_auto_boolean
:
429 enum auto_boolean ab
= * (enum auto_boolean
*) var
;
431 if (ab
== AUTO_BOOLEAN_TRUE
)
433 else if (ab
== AUTO_BOOLEAN_FALSE
)
440 if ((* (int *) var
) == INT_MAX
)
444 return PyLong_FromLong (* (int *) var
);
448 unsigned int val
= * (unsigned int *) var
;
452 return PyLong_FromUnsignedLong (val
);
456 return PyErr_Format (PyExc_RuntimeError
,
457 _("Programmer error: unhandled type."));
460 /* A Python function which returns a gdb parameter's value as a Python
464 gdbpy_parameter (PyObject
*self
, PyObject
*args
)
466 struct cmd_list_element
*alias
, *prefix
, *cmd
;
470 volatile struct gdb_exception except
;
472 if (! PyArg_ParseTuple (args
, "s", &arg
))
475 newarg
= concat ("show ", arg
, (char *) NULL
);
477 TRY_CATCH (except
, RETURN_MASK_ALL
)
479 found
= lookup_cmd_composition (newarg
, &alias
, &prefix
, &cmd
);
482 GDB_PY_HANDLE_EXCEPTION (except
);
484 return PyErr_Format (PyExc_RuntimeError
,
485 _("Could not find parameter `%s'."), arg
);
488 return PyErr_Format (PyExc_RuntimeError
,
489 _("`%s' is not a parameter."), arg
);
490 return gdbpy_parameter_value (cmd
->var_type
, cmd
->var
);
493 /* Wrapper for target_charset. */
496 gdbpy_target_charset (PyObject
*self
, PyObject
*args
)
498 const char *cset
= target_charset (python_gdbarch
);
500 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
503 /* Wrapper for target_wide_charset. */
506 gdbpy_target_wide_charset (PyObject
*self
, PyObject
*args
)
508 const char *cset
= target_wide_charset (python_gdbarch
);
510 return PyUnicode_Decode (cset
, strlen (cset
), host_charset (), NULL
);
513 /* A Python function which evaluates a string using the gdb CLI. */
516 execute_gdb_command (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
519 PyObject
*from_tty_obj
= NULL
, *to_string_obj
= NULL
;
520 int from_tty
, to_string
;
521 volatile struct gdb_exception except
;
522 static char *keywords
[] = {"command", "from_tty", "to_string", NULL
};
525 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|O!O!", keywords
, &arg
,
526 &PyBool_Type
, &from_tty_obj
,
527 &PyBool_Type
, &to_string_obj
))
533 int cmp
= PyObject_IsTrue (from_tty_obj
);
542 int cmp
= PyObject_IsTrue (to_string_obj
);
548 TRY_CATCH (except
, RETURN_MASK_ALL
)
550 /* Copy the argument text in case the command modifies it. */
551 char *copy
= xstrdup (arg
);
552 struct cleanup
*cleanup
= make_cleanup (xfree
, copy
);
554 make_cleanup_restore_integer (&interpreter_async
);
555 interpreter_async
= 0;
557 prevent_dont_repeat ();
559 result
= execute_command_to_string (copy
, from_tty
);
563 execute_command (copy
, from_tty
);
566 do_cleanups (cleanup
);
568 GDB_PY_HANDLE_EXCEPTION (except
);
570 /* Do any commands attached to breakpoint we stopped at. */
571 bpstat_do_actions ();
575 PyObject
*r
= PyString_FromString (result
);
582 /* Implementation of gdb.solib_name (Long) -> String.
583 Returns the name of the shared library holding a given address, or None. */
586 gdbpy_solib_name (PyObject
*self
, PyObject
*args
)
592 if (!PyArg_ParseTuple (args
, GDB_PY_LL_ARG
, &pc
))
595 soname
= solib_name_from_address (current_program_space
, pc
);
597 str_obj
= PyString_Decode (soname
, strlen (soname
), host_charset (), NULL
);
607 /* A Python function which is a wrapper for decode_line_1. */
610 gdbpy_decode_line (PyObject
*self
, PyObject
*args
)
612 struct symtabs_and_lines sals
= { NULL
, 0 }; /* Initialize to
614 struct symtab_and_line sal
;
615 const char *arg
= NULL
;
616 char *copy_to_free
= NULL
, *copy
= NULL
;
617 struct cleanup
*cleanups
;
618 PyObject
*result
= NULL
;
619 PyObject
*return_result
= NULL
;
620 PyObject
*unparsed
= NULL
;
621 volatile struct gdb_exception except
;
623 if (! PyArg_ParseTuple (args
, "|s", &arg
))
626 cleanups
= make_cleanup (null_cleanup
, NULL
);
629 TRY_CATCH (except
, RETURN_MASK_ALL
)
633 copy
= xstrdup (arg
);
635 sals
= decode_line_1 (©
, 0, 0, 0);
639 set_default_source_symtab_and_line ();
640 sal
= get_current_source_symtab_and_line ();
646 if (sals
.sals
!= NULL
&& sals
.sals
!= &sal
)
648 make_cleanup (xfree
, copy_to_free
);
649 make_cleanup (xfree
, sals
.sals
);
652 if (except
.reason
< 0)
654 do_cleanups (cleanups
);
655 /* We know this will always throw. */
656 gdbpy_convert_exception (except
);
664 result
= PyTuple_New (sals
.nelts
);
667 for (i
= 0; i
< sals
.nelts
; ++i
)
671 obj
= symtab_and_line_to_sal_object (sals
.sals
[i
]);
678 PyTuple_SetItem (result
, i
, obj
);
687 return_result
= PyTuple_New (2);
694 if (copy
&& strlen (copy
) > 0)
696 unparsed
= PyString_FromString (copy
);
697 if (unparsed
== NULL
)
700 Py_DECREF (return_result
);
701 return_result
= NULL
;
711 PyTuple_SetItem (return_result
, 0, unparsed
);
712 PyTuple_SetItem (return_result
, 1, result
);
715 do_cleanups (cleanups
);
717 return return_result
;
720 /* Parse a string and evaluate it as an expression. */
722 gdbpy_parse_and_eval (PyObject
*self
, PyObject
*args
)
724 const char *expr_str
;
725 struct value
*result
= NULL
;
726 volatile struct gdb_exception except
;
728 if (!PyArg_ParseTuple (args
, "s", &expr_str
))
731 TRY_CATCH (except
, RETURN_MASK_ALL
)
733 result
= parse_and_eval (expr_str
);
735 GDB_PY_HANDLE_EXCEPTION (except
);
737 return value_to_value_object (result
);
740 /* Implementation of gdb.find_pc_line function.
741 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
744 gdbpy_find_pc_line (PyObject
*self
, PyObject
*args
)
746 gdb_py_ulongest pc_llu
;
747 volatile struct gdb_exception except
;
748 PyObject
*result
= NULL
; /* init for gcc -Wall */
750 if (!PyArg_ParseTuple (args
, GDB_PY_LLU_ARG
, &pc_llu
))
753 TRY_CATCH (except
, RETURN_MASK_ALL
)
755 struct symtab_and_line sal
;
758 pc
= (CORE_ADDR
) pc_llu
;
759 sal
= find_pc_line (pc
, 0);
760 result
= symtab_and_line_to_sal_object (sal
);
762 GDB_PY_HANDLE_EXCEPTION (except
);
767 /* Read a file as Python code.
768 FILE is the file to run. FILENAME is name of the file FILE.
769 This does not throw any errors. If an exception occurs python will print
770 the traceback and clear the error indicator. */
773 source_python_script (FILE *file
, const char *filename
)
775 struct cleanup
*cleanup
;
777 cleanup
= ensure_python_env (get_current_arch (), current_language
);
778 python_run_simple_file (file
, filename
);
779 do_cleanups (cleanup
);
784 /* Posting and handling events. */
786 /* A single event. */
789 /* The Python event. This is just a callable object. */
791 /* The next event. */
792 struct gdbpy_event
*next
;
795 /* All pending events. */
796 static struct gdbpy_event
*gdbpy_event_list
;
797 /* The final link of the event list. */
798 static struct gdbpy_event
**gdbpy_event_list_end
;
800 /* We use a file handler, and not an async handler, so that we can
801 wake up the main thread even when it is blocked in poll(). */
802 static struct serial
*gdbpy_event_fds
[2];
804 /* The file handler callback. This reads from the internal pipe, and
805 then processes the Python event queue. This will always be run in
806 the main gdb thread. */
809 gdbpy_run_events (struct serial
*scb
, void *context
)
811 struct cleanup
*cleanup
;
813 cleanup
= ensure_python_env (get_current_arch (), current_language
);
815 /* Flush the fd. Do this before flushing the events list, so that
816 any new event post afterwards is sure to re-awake the event
818 while (serial_readchar (gdbpy_event_fds
[0], 0) >= 0)
821 while (gdbpy_event_list
)
823 PyObject
*call_result
;
825 /* Dispatching the event might push a new element onto the event
826 loop, so we update here "atomically enough". */
827 struct gdbpy_event
*item
= gdbpy_event_list
;
828 gdbpy_event_list
= gdbpy_event_list
->next
;
829 if (gdbpy_event_list
== NULL
)
830 gdbpy_event_list_end
= &gdbpy_event_list
;
833 call_result
= PyObject_CallObject (item
->event
, NULL
);
834 if (call_result
== NULL
)
837 Py_XDECREF (call_result
);
838 Py_DECREF (item
->event
);
842 do_cleanups (cleanup
);
845 /* Submit an event to the gdb thread. */
847 gdbpy_post_event (PyObject
*self
, PyObject
*args
)
849 struct gdbpy_event
*event
;
853 if (!PyArg_ParseTuple (args
, "O", &func
))
856 if (!PyCallable_Check (func
))
858 PyErr_SetString (PyExc_RuntimeError
,
859 _("Posted event is not callable"));
865 /* From here until the end of the function, we have the GIL, so we
866 can operate on our global data structures without worrying. */
867 wakeup
= gdbpy_event_list
== NULL
;
869 event
= XNEW (struct gdbpy_event
);
872 *gdbpy_event_list_end
= event
;
873 gdbpy_event_list_end
= &event
->next
;
875 /* Wake up gdb when needed. */
878 char c
= 'q'; /* Anything. */
880 if (serial_write (gdbpy_event_fds
[1], &c
, 1))
881 return PyErr_SetFromErrno (PyExc_IOError
);
887 /* Initialize the Python event handler. */
889 gdbpy_initialize_events (void)
891 if (serial_pipe (gdbpy_event_fds
) == 0)
893 gdbpy_event_list_end
= &gdbpy_event_list
;
894 serial_async (gdbpy_event_fds
[0], gdbpy_run_events
, NULL
);
903 before_prompt_hook (const char *current_gdb_prompt
)
905 struct cleanup
*cleanup
;
908 if (!gdb_python_initialized
)
911 cleanup
= ensure_python_env (get_current_arch (), current_language
);
913 if (gdb_python_module
914 && PyObject_HasAttrString (gdb_python_module
, "prompt_hook"))
918 hook
= PyObject_GetAttrString (gdb_python_module
, "prompt_hook");
922 make_cleanup_py_decref (hook
);
924 if (PyCallable_Check (hook
))
927 PyObject
*current_prompt
;
929 current_prompt
= PyString_FromString (current_gdb_prompt
);
930 if (current_prompt
== NULL
)
933 result
= PyObject_CallFunctionObjArgs (hook
, current_prompt
, NULL
);
935 Py_DECREF (current_prompt
);
940 make_cleanup_py_decref (result
);
942 /* Return type should be None, or a String. If it is None,
943 fall through, we will not set a prompt. If it is a
944 string, set PROMPT. Anything else, set an exception. */
945 if (result
!= Py_None
&& ! PyString_Check (result
))
947 PyErr_Format (PyExc_RuntimeError
,
948 _("Return from prompt_hook must " \
949 "be either a Python string, or None"));
953 if (result
!= Py_None
)
955 prompt
= python_string_to_host_string (result
);
960 make_cleanup (xfree
, prompt
);
965 /* If a prompt has been set, PROMPT will not be NULL. If it is
966 NULL, do not set the prompt. */
970 do_cleanups (cleanup
);
974 gdbpy_print_stack ();
975 do_cleanups (cleanup
);
983 /* A python function to write a single string using gdb's filtered
984 output stream . The optional keyword STREAM can be used to write
985 to a particular stream. The default stream is to gdb_stdout. */
988 gdbpy_write (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
991 static char *keywords
[] = {"text", "stream", NULL
};
993 volatile struct gdb_exception except
;
995 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "s|i", keywords
, &arg
,
999 TRY_CATCH (except
, RETURN_MASK_ALL
)
1001 switch (stream_type
)
1005 fprintf_filtered (gdb_stderr
, "%s", arg
);
1010 fprintf_filtered (gdb_stdlog
, "%s", arg
);
1014 fprintf_filtered (gdb_stdout
, "%s", arg
);
1017 GDB_PY_HANDLE_EXCEPTION (except
);
1022 /* A python function to flush a gdb stream. The optional keyword
1023 STREAM can be used to flush a particular stream. The default stream
1027 gdbpy_flush (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
1029 static char *keywords
[] = {"stream", NULL
};
1030 int stream_type
= 0;
1032 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "|i", keywords
,
1036 switch (stream_type
)
1040 gdb_flush (gdb_stderr
);
1045 gdb_flush (gdb_stdlog
);
1049 gdb_flush (gdb_stdout
);
1055 /* Print a python exception trace, print just a message, or print
1056 nothing and clear the python exception, depending on
1057 gdbpy_should_print_stack. Only call this if a python exception is
1060 gdbpy_print_stack (void)
1062 volatile struct gdb_exception except
;
1064 /* Print "none", just clear exception. */
1065 if (gdbpy_should_print_stack
== python_excp_none
)
1069 /* Print "full" message and backtrace. */
1070 else if (gdbpy_should_print_stack
== python_excp_full
)
1073 /* PyErr_Print doesn't necessarily end output with a newline.
1074 This works because Python's stdout/stderr is fed through
1076 TRY_CATCH (except
, RETURN_MASK_ALL
)
1081 /* Print "message", just error print message. */
1084 PyObject
*ptype
, *pvalue
, *ptraceback
;
1085 char *msg
= NULL
, *type
= NULL
;
1087 PyErr_Fetch (&ptype
, &pvalue
, &ptraceback
);
1089 /* Fetch the error message contained within ptype, pvalue. */
1090 msg
= gdbpy_exception_to_string (ptype
, pvalue
);
1091 type
= gdbpy_obj_to_string (ptype
);
1093 TRY_CATCH (except
, RETURN_MASK_ALL
)
1097 /* An error occurred computing the string representation of the
1099 fprintf_filtered (gdb_stderr
,
1100 _("Error occurred computing Python error" \
1104 fprintf_filtered (gdb_stderr
, "Python Exception %s %s: \n",
1109 Py_XDECREF (pvalue
);
1110 Py_XDECREF (ptraceback
);
1117 /* Return the current Progspace.
1118 There always is one. */
1121 gdbpy_get_current_progspace (PyObject
*unused1
, PyObject
*unused2
)
1125 result
= pspace_to_pspace_object (current_program_space
);
1131 /* Return a sequence holding all the Progspaces. */
1134 gdbpy_progspaces (PyObject
*unused1
, PyObject
*unused2
)
1136 struct program_space
*ps
;
1139 list
= PyList_New (0);
1145 PyObject
*item
= pspace_to_pspace_object (ps
);
1147 if (!item
|| PyList_Append (list
, item
) == -1)
1159 /* The "current" objfile. This is set when gdb detects that a new
1160 objfile has been loaded. It is only set for the duration of a call to
1161 source_python_script_for_objfile; it is NULL at other times. */
1162 static struct objfile
*gdbpy_current_objfile
;
1164 /* Set the current objfile to OBJFILE and then read FILE named FILENAME
1165 as Python code. This does not throw any errors. If an exception
1166 occurs python will print the traceback and clear the error indicator. */
1169 source_python_script_for_objfile (struct objfile
*objfile
, FILE *file
,
1170 const char *filename
)
1172 struct cleanup
*cleanups
;
1174 if (!gdb_python_initialized
)
1177 cleanups
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
1178 gdbpy_current_objfile
= objfile
;
1180 python_run_simple_file (file
, filename
);
1182 do_cleanups (cleanups
);
1183 gdbpy_current_objfile
= NULL
;
1186 /* Return the current Objfile, or None if there isn't one. */
1189 gdbpy_get_current_objfile (PyObject
*unused1
, PyObject
*unused2
)
1193 if (! gdbpy_current_objfile
)
1196 result
= objfile_to_objfile_object (gdbpy_current_objfile
);
1202 /* Return a sequence holding all the Objfiles. */
1205 gdbpy_objfiles (PyObject
*unused1
, PyObject
*unused2
)
1207 struct objfile
*objf
;
1210 list
= PyList_New (0);
1216 PyObject
*item
= objfile_to_objfile_object (objf
);
1218 if (!item
|| PyList_Append (list
, item
) == -1)
1228 /* Compute the list of active type printers and return it. The result
1229 of this function can be passed to apply_type_printers, and should
1230 be freed by free_type_printers. */
1233 start_type_printers (void)
1235 struct cleanup
*cleanups
;
1236 PyObject
*type_module
, *func
= NULL
, *result_obj
= NULL
;
1238 if (!gdb_python_initialized
)
1241 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1243 type_module
= PyImport_ImportModule ("gdb.types");
1244 if (type_module
== NULL
)
1246 gdbpy_print_stack ();
1250 func
= PyObject_GetAttrString (type_module
, "get_type_recognizers");
1253 gdbpy_print_stack ();
1257 result_obj
= PyObject_CallFunctionObjArgs (func
, (char *) NULL
);
1258 if (result_obj
== NULL
)
1259 gdbpy_print_stack ();
1262 Py_XDECREF (type_module
);
1264 do_cleanups (cleanups
);
1268 /* If TYPE is recognized by some type printer, return a newly
1269 allocated string holding the type's replacement name. The caller
1270 is responsible for freeing the string. Otherwise, return NULL.
1272 This function has a bit of a funny name, since it actually applies
1273 recognizers, but this seemed clearer given the start_type_printers
1274 and free_type_printers functions. */
1277 apply_type_printers (void *printers
, struct type
*type
)
1279 struct cleanup
*cleanups
;
1280 PyObject
*type_obj
, *type_module
= NULL
, *func
= NULL
;
1281 PyObject
*result_obj
= NULL
;
1282 PyObject
*printers_obj
= printers
;
1283 char *result
= NULL
;
1285 if (printers_obj
== NULL
)
1288 if (!gdb_python_initialized
)
1291 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1293 type_obj
= type_to_type_object (type
);
1294 if (type_obj
== NULL
)
1296 gdbpy_print_stack ();
1300 type_module
= PyImport_ImportModule ("gdb.types");
1301 if (type_module
== NULL
)
1303 gdbpy_print_stack ();
1307 func
= PyObject_GetAttrString (type_module
, "apply_type_recognizers");
1310 gdbpy_print_stack ();
1314 result_obj
= PyObject_CallFunctionObjArgs (func
, printers_obj
,
1315 type_obj
, (char *) NULL
);
1316 if (result_obj
== NULL
)
1318 gdbpy_print_stack ();
1322 if (result_obj
!= Py_None
)
1324 result
= python_string_to_host_string (result_obj
);
1326 gdbpy_print_stack ();
1330 Py_XDECREF (type_obj
);
1331 Py_XDECREF (type_module
);
1333 Py_XDECREF (result_obj
);
1334 do_cleanups (cleanups
);
1338 /* Free the result of start_type_printers. */
1341 free_type_printers (void *arg
)
1343 struct cleanup
*cleanups
;
1344 PyObject
*printers
= arg
;
1346 if (printers
== NULL
)
1349 if (!gdb_python_initialized
)
1352 cleanups
= ensure_python_env (get_current_arch (), current_language
);
1353 Py_DECREF (printers
);
1354 do_cleanups (cleanups
);
1357 #else /* HAVE_PYTHON */
1359 /* Dummy implementation of the gdb "python-interactive" and "python"
1363 python_interactive_command (char *arg
, int from_tty
)
1365 arg
= skip_spaces (arg
);
1367 error (_("Python scripting is not supported in this copy of GDB."));
1370 struct command_line
*l
= get_command_line (python_control
, "");
1371 struct cleanup
*cleanups
= make_cleanup_free_command_lines (&l
);
1373 execute_control_command_untraced (l
);
1374 do_cleanups (cleanups
);
1379 python_command (char *arg
, int from_tty
)
1381 python_interactive_command (arg
, from_tty
);
1385 eval_python_from_control_command (struct command_line
*cmd
)
1387 error (_("Python scripting is not supported in this copy of GDB."));
1391 source_python_script (FILE *file
, const char *filename
)
1393 throw_error (UNSUPPORTED_ERROR
,
1394 _("Python scripting is not supported in this copy of GDB."));
1398 gdbpy_should_stop (struct gdbpy_breakpoint_object
*bp_obj
)
1400 internal_error (__FILE__
, __LINE__
,
1401 _("gdbpy_should_stop called when Python scripting is " \
1406 gdbpy_breakpoint_has_py_cond (struct gdbpy_breakpoint_object
*bp_obj
)
1408 internal_error (__FILE__
, __LINE__
,
1409 _("gdbpy_breakpoint_has_py_cond called when Python " \
1410 "scripting is not supported."));
1414 start_type_printers (void)
1420 apply_type_printers (void *ignore
, struct type
*type
)
1426 free_type_printers (void *arg
)
1431 apply_frame_filter (struct frame_info
*frame
, int flags
,
1432 enum py_frame_args args_type
,
1433 struct ui_out
*out
, int frame_low
,
1436 return PY_BT_NO_FILTERS
;
1439 #endif /* HAVE_PYTHON */
1443 /* Lists for 'set python' commands. */
1445 static struct cmd_list_element
*user_set_python_list
;
1446 static struct cmd_list_element
*user_show_python_list
;
1448 /* Function for use by 'set python' prefix command. */
1451 user_set_python (char *args
, int from_tty
)
1453 help_list (user_set_python_list
, "set python ", all_commands
,
1457 /* Function for use by 'show python' prefix command. */
1460 user_show_python (char *args
, int from_tty
)
1462 cmd_show_list (user_show_python_list
, from_tty
, "");
1465 /* Initialize the Python code. */
1469 /* This is installed as a final cleanup and cleans up the
1470 interpreter. This lets Python's 'atexit' work. */
1473 finalize_python (void *ignore
)
1475 /* We don't use ensure_python_env here because if we ever ran the
1476 cleanup, gdb would crash -- because the cleanup calls into the
1477 Python interpreter, which we are about to destroy. It seems
1478 clearer to make the needed calls explicitly here than to create a
1479 cleanup and then mysteriously discard it. */
1480 (void) PyGILState_Ensure ();
1481 python_gdbarch
= target_gdbarch ();
1482 python_language
= current_language
;
1488 /* Provide a prototype to silence -Wmissing-prototypes. */
1489 extern initialize_file_ftype _initialize_python
;
1492 _initialize_python (void)
1497 size_t progsize
, count
;
1499 wchar_t *progname_copy
;
1502 add_com ("python-interactive", class_obscure
,
1503 python_interactive_command
,
1506 Start an interactive Python prompt.\n\
1508 To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1511 Alternatively, a single-line Python command can be given as an\n\
1512 argument, and if the command is an expression, the result will be\n\
1513 printed. For example:\n\
1515 (gdb) python-interactive 2 + 3\n\
1518 #else /* HAVE_PYTHON */
1520 Start a Python interactive prompt.\n\
1522 Python scripting is not supported in this copy of GDB.\n\
1523 This command is only a placeholder.")
1524 #endif /* HAVE_PYTHON */
1526 add_com_alias ("pi", "python-interactive", class_obscure
, 1);
1528 add_com ("python", class_obscure
, python_command
,
1531 Evaluate a Python command.\n\
1533 The command can be given as an argument, for instance:\n\
1537 If no argument is given, the following lines are read and used\n\
1538 as the Python commands. Type a line containing \"end\" to indicate\n\
1539 the end of the command.")
1540 #else /* HAVE_PYTHON */
1542 Evaluate a Python command.\n\
1544 Python scripting is not supported in this copy of GDB.\n\
1545 This command is only a placeholder.")
1546 #endif /* HAVE_PYTHON */
1548 add_com_alias ("py", "python", class_obscure
, 1);
1550 /* Add set/show python print-stack. */
1551 add_prefix_cmd ("python", no_class
, user_show_python
,
1552 _("Prefix command for python preference settings."),
1553 &user_show_python_list
, "show python ", 0,
1556 add_prefix_cmd ("python", no_class
, user_set_python
,
1557 _("Prefix command for python preference settings."),
1558 &user_set_python_list
, "set python ", 0,
1561 add_setshow_enum_cmd ("print-stack", no_class
, python_excp_enums
,
1562 &gdbpy_should_print_stack
, _("\
1563 Set mode for Python stack dump on error."), _("\
1564 Show the mode of Python stack printing on error."), _("\
1565 none == no stack or message will be printed.\n\
1566 full == a message and a stack will be printed.\n\
1567 message == an error message without a stack will be printed."),
1569 &user_set_python_list
,
1570 &user_show_python_list
);
1573 #ifdef WITH_PYTHON_PATH
1574 /* Work around problem where python gets confused about where it is,
1575 and then can't find its libraries, etc.
1576 NOTE: Python assumes the following layout:
1578 /foo/lib/pythonX.Y/...
1579 This must be done before calling Py_Initialize. */
1580 progname
= concat (ldirname (python_libdir
), SLASH_STRING
, "bin",
1581 SLASH_STRING
, "python", NULL
);
1583 oldloc
= setlocale (LC_ALL
, NULL
);
1584 setlocale (LC_ALL
, "");
1585 progsize
= strlen (progname
);
1586 if (progsize
== (size_t) -1)
1588 fprintf (stderr
, "Could not convert python path to string\n");
1591 progname_copy
= PyMem_Malloc ((progsize
+ 1) * sizeof (wchar_t));
1594 fprintf (stderr
, "out of memory\n");
1597 count
= mbstowcs (progname_copy
, progname
, progsize
+ 1);
1598 if (count
== (size_t) -1)
1600 fprintf (stderr
, "Could not convert python path to string\n");
1603 setlocale (LC_ALL
, oldloc
);
1605 /* Note that Py_SetProgramName expects the string it is passed to
1606 remain alive for the duration of the program's execution, so
1607 it is not freed after this call. */
1608 Py_SetProgramName (progname_copy
);
1610 Py_SetProgramName (progname
);
1615 PyEval_InitThreads ();
1618 gdb_module
= PyModule_Create (&GdbModuleDef
);
1619 /* Add _gdb module to the list of known built-in modules. */
1620 _PyImport_FixupBuiltin (gdb_module
, "_gdb");
1622 gdb_module
= Py_InitModule ("_gdb", GdbMethods
);
1624 if (gdb_module
== NULL
)
1627 /* The casts to (char*) are for python 2.4. */
1628 if (PyModule_AddStringConstant (gdb_module
, "VERSION", (char*) version
) < 0
1629 || PyModule_AddStringConstant (gdb_module
, "HOST_CONFIG",
1630 (char*) host_name
) < 0
1631 || PyModule_AddStringConstant (gdb_module
, "TARGET_CONFIG",
1632 (char*) target_name
) < 0)
1635 /* Add stream constants. */
1636 if (PyModule_AddIntConstant (gdb_module
, "STDOUT", 0) < 0
1637 || PyModule_AddIntConstant (gdb_module
, "STDERR", 1) < 0
1638 || PyModule_AddIntConstant (gdb_module
, "STDLOG", 2) < 0)
1641 gdbpy_gdb_error
= PyErr_NewException ("gdb.error", PyExc_RuntimeError
, NULL
);
1642 if (gdbpy_gdb_error
== NULL
1643 || gdb_pymodule_addobject (gdb_module
, "error", gdbpy_gdb_error
) < 0)
1646 gdbpy_gdb_memory_error
= PyErr_NewException ("gdb.MemoryError",
1647 gdbpy_gdb_error
, NULL
);
1648 if (gdbpy_gdb_memory_error
== NULL
1649 || gdb_pymodule_addobject (gdb_module
, "MemoryError",
1650 gdbpy_gdb_memory_error
) < 0)
1653 gdbpy_gdberror_exc
= PyErr_NewException ("gdb.GdbError", NULL
, NULL
);
1654 if (gdbpy_gdberror_exc
== NULL
1655 || gdb_pymodule_addobject (gdb_module
, "GdbError",
1656 gdbpy_gdberror_exc
) < 0)
1659 gdbpy_initialize_gdb_readline ();
1661 if (gdbpy_initialize_auto_load () < 0
1662 || gdbpy_initialize_values () < 0
1663 || gdbpy_initialize_frames () < 0
1664 || gdbpy_initialize_commands () < 0
1665 || gdbpy_initialize_symbols () < 0
1666 || gdbpy_initialize_symtabs () < 0
1667 || gdbpy_initialize_blocks () < 0
1668 || gdbpy_initialize_functions () < 0
1669 || gdbpy_initialize_parameters () < 0
1670 || gdbpy_initialize_types () < 0
1671 || gdbpy_initialize_pspace () < 0
1672 || gdbpy_initialize_objfile () < 0
1673 || gdbpy_initialize_breakpoints () < 0
1674 || gdbpy_initialize_finishbreakpoints () < 0
1675 || gdbpy_initialize_lazy_string () < 0
1676 || gdbpy_initialize_linetable () < 0
1677 || gdbpy_initialize_thread () < 0
1678 || gdbpy_initialize_inferior () < 0
1679 || gdbpy_initialize_events () < 0
1680 || gdbpy_initialize_eventregistry () < 0
1681 || gdbpy_initialize_py_events () < 0
1682 || gdbpy_initialize_event () < 0
1683 || gdbpy_initialize_stop_event () < 0
1684 || gdbpy_initialize_signal_event () < 0
1685 || gdbpy_initialize_breakpoint_event () < 0
1686 || gdbpy_initialize_continue_event () < 0
1687 || gdbpy_initialize_exited_event () < 0
1688 || gdbpy_initialize_thread_event () < 0
1689 || gdbpy_initialize_new_objfile_event () < 0
1690 || gdbpy_initialize_arch () < 0)
1693 observer_attach_before_prompt (before_prompt_hook
);
1695 gdbpy_to_string_cst
= PyString_FromString ("to_string");
1696 if (gdbpy_to_string_cst
== NULL
)
1698 gdbpy_children_cst
= PyString_FromString ("children");
1699 if (gdbpy_children_cst
== NULL
)
1701 gdbpy_display_hint_cst
= PyString_FromString ("display_hint");
1702 if (gdbpy_display_hint_cst
== NULL
)
1704 gdbpy_doc_cst
= PyString_FromString ("__doc__");
1705 if (gdbpy_doc_cst
== NULL
)
1707 gdbpy_enabled_cst
= PyString_FromString ("enabled");
1708 if (gdbpy_enabled_cst
== NULL
)
1710 gdbpy_value_cst
= PyString_FromString ("value");
1711 if (gdbpy_value_cst
== NULL
)
1714 /* Release the GIL while gdb runs. */
1715 PyThreadState_Swap (NULL
);
1716 PyEval_ReleaseLock ();
1718 make_final_cleanup (finalize_python
, NULL
);
1720 gdb_python_initialized
= 1;
1724 gdbpy_print_stack ();
1725 /* Do not set 'gdb_python_initialized'. */
1728 #endif /* HAVE_PYTHON */
1733 /* Perform the remaining python initializations.
1734 These must be done after GDB is at least mostly initialized.
1735 E.g., The "info pretty-printer" command needs the "info" prefix
1736 command installed. */
1739 finish_python_initialization (void)
1742 char *gdb_pythondir
;
1744 struct cleanup
*cleanup
;
1746 cleanup
= ensure_python_env (get_current_arch (), current_language
);
1748 /* Add the initial data-directory to sys.path. */
1750 gdb_pythondir
= concat (gdb_datadir
, SLASH_STRING
, "python", NULL
);
1751 make_cleanup (xfree
, gdb_pythondir
);
1753 sys_path
= PySys_GetObject ("path");
1755 /* If sys.path is not defined yet, define it first. */
1756 if (!(sys_path
&& PyList_Check (sys_path
)))
1759 PySys_SetPath (L
"");
1763 sys_path
= PySys_GetObject ("path");
1765 if (sys_path
&& PyList_Check (sys_path
))
1767 PyObject
*pythondir
;
1770 pythondir
= PyString_FromString (gdb_pythondir
);
1771 if (pythondir
== NULL
)
1774 err
= PyList_Insert (sys_path
, 0, pythondir
);
1775 Py_DECREF (pythondir
);
1782 /* Import the gdb module to finish the initialization, and
1783 add it to __main__ for convenience. */
1784 m
= PyImport_AddModule ("__main__");
1788 gdb_python_module
= PyImport_ImportModule ("gdb");
1789 if (gdb_python_module
== NULL
)
1791 gdbpy_print_stack ();
1792 /* This is passed in one call to warning so that blank lines aren't
1793 inserted between each line of text. */
1795 "Could not load the Python gdb module from `%s'.\n"
1796 "Limited Python support is available from the _gdb module.\n"
1797 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1799 do_cleanups (cleanup
);
1803 if (gdb_pymodule_addobject (m
, "gdb", gdb_python_module
) < 0)
1806 /* Keep the reference to gdb_python_module since it is in a global
1809 do_cleanups (cleanup
);
1813 gdbpy_print_stack ();
1814 warning (_("internal error: Unhandled Python exception"));
1815 do_cleanups (cleanup
);
1818 #endif /* HAVE_PYTHON */
1824 static PyMethodDef GdbMethods
[] =
1826 { "history", gdbpy_history
, METH_VARARGS
,
1827 "Get a value from history" },
1828 { "execute", (PyCFunction
) execute_gdb_command
, METH_VARARGS
| METH_KEYWORDS
,
1829 "execute (command [, from_tty] [, to_string]) -> [String]\n\
1830 Evaluate command, a string, as a gdb CLI command. Optionally returns\n\
1831 a Python String containing the output of the command if to_string is\n\
1833 { "parameter", gdbpy_parameter
, METH_VARARGS
,
1834 "Return a gdb parameter's value" },
1836 { "breakpoints", gdbpy_breakpoints
, METH_NOARGS
,
1837 "Return a tuple of all breakpoint objects" },
1839 { "default_visualizer", gdbpy_default_visualizer
, METH_VARARGS
,
1840 "Find the default visualizer for a Value." },
1842 { "current_progspace", gdbpy_get_current_progspace
, METH_NOARGS
,
1843 "Return the current Progspace." },
1844 { "progspaces", gdbpy_progspaces
, METH_NOARGS
,
1845 "Return a sequence of all progspaces." },
1847 { "current_objfile", gdbpy_get_current_objfile
, METH_NOARGS
,
1848 "Return the current Objfile being loaded, or None." },
1849 { "objfiles", gdbpy_objfiles
, METH_NOARGS
,
1850 "Return a sequence of all loaded objfiles." },
1852 { "newest_frame", gdbpy_newest_frame
, METH_NOARGS
,
1853 "newest_frame () -> gdb.Frame.\n\
1854 Return the newest frame object." },
1855 { "selected_frame", gdbpy_selected_frame
, METH_NOARGS
,
1856 "selected_frame () -> gdb.Frame.\n\
1857 Return the selected frame object." },
1858 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string
, METH_VARARGS
,
1859 "stop_reason_string (Integer) -> String.\n\
1860 Return a string explaining unwind stop reason." },
1862 { "lookup_type", (PyCFunction
) gdbpy_lookup_type
,
1863 METH_VARARGS
| METH_KEYWORDS
,
1864 "lookup_type (name [, block]) -> type\n\
1865 Return a Type corresponding to the given name." },
1866 { "lookup_symbol", (PyCFunction
) gdbpy_lookup_symbol
,
1867 METH_VARARGS
| METH_KEYWORDS
,
1868 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1869 Return a tuple with the symbol corresponding to the given name (or None) and\n\
1870 a boolean indicating if name is a field of the current implied argument\n\
1871 `this' (when the current language is object-oriented)." },
1872 { "lookup_global_symbol", (PyCFunction
) gdbpy_lookup_global_symbol
,
1873 METH_VARARGS
| METH_KEYWORDS
,
1874 "lookup_global_symbol (name [, domain]) -> symbol\n\
1875 Return the symbol corresponding to the given name (or None)." },
1876 { "block_for_pc", gdbpy_block_for_pc
, METH_VARARGS
,
1877 "Return the block containing the given pc value, or None." },
1878 { "solib_name", gdbpy_solib_name
, METH_VARARGS
,
1879 "solib_name (Long) -> String.\n\
1880 Return the name of the shared library holding a given address, or None." },
1881 { "decode_line", gdbpy_decode_line
, METH_VARARGS
,
1882 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1883 that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1884 The first element contains any unparsed portion of the String parameter\n\
1885 (or None if the string was fully parsed). The second element contains\n\
1886 a tuple that contains all the locations that match, represented as\n\
1887 gdb.Symtab_and_line objects (or None)."},
1888 { "parse_and_eval", gdbpy_parse_and_eval
, METH_VARARGS
,
1889 "parse_and_eval (String) -> Value.\n\
1890 Parse String as an expression, evaluate it, and return the result as a Value."
1892 { "find_pc_line", gdbpy_find_pc_line
, METH_VARARGS
,
1893 "find_pc_line (pc) -> Symtab_and_line.\n\
1894 Return the gdb.Symtab_and_line object corresponding to the pc value." },
1896 { "post_event", gdbpy_post_event
, METH_VARARGS
,
1897 "Post an event into gdb's event loop." },
1899 { "target_charset", gdbpy_target_charset
, METH_NOARGS
,
1900 "target_charset () -> string.\n\
1901 Return the name of the current target charset." },
1902 { "target_wide_charset", gdbpy_target_wide_charset
, METH_NOARGS
,
1903 "target_wide_charset () -> string.\n\
1904 Return the name of the current target wide charset." },
1906 { "string_to_argv", gdbpy_string_to_argv
, METH_VARARGS
,
1907 "string_to_argv (String) -> Array.\n\
1908 Parse String and return an argv-like array.\n\
1909 Arguments are separate by spaces and may be quoted."
1911 { "write", (PyCFunction
)gdbpy_write
, METH_VARARGS
| METH_KEYWORDS
,
1912 "Write a string using gdb's filtered stream." },
1913 { "flush", (PyCFunction
)gdbpy_flush
, METH_VARARGS
| METH_KEYWORDS
,
1914 "Flush gdb's filtered stdout stream." },
1915 { "selected_thread", gdbpy_selected_thread
, METH_NOARGS
,
1916 "selected_thread () -> gdb.InferiorThread.\n\
1917 Return the selected thread object." },
1918 { "selected_inferior", gdbpy_selected_inferior
, METH_NOARGS
,
1919 "selected_inferior () -> gdb.Inferior.\n\
1920 Return the selected inferior object." },
1921 { "inferiors", gdbpy_inferiors
, METH_NOARGS
,
1922 "inferiors () -> (gdb.Inferior, ...).\n\
1923 Return a tuple containing all inferiors." },
1924 {NULL
, NULL
, 0, NULL
}
1928 static struct PyModuleDef GdbModuleDef
=
1930 PyModuleDef_HEAD_INIT
,
1941 #endif /* HAVE_PYTHON */