Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / python / python.c
CommitLineData
5796c8dc
SS
1/* General python/gdb code
2
ef5ccd6c 3 Copyright (C) 2008-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "arch-utils.h"
22#include "command.h"
23#include "ui-out.h"
24#include "cli/cli-script.h"
25#include "gdbcmd.h"
cf7f2e2d 26#include "progspace.h"
5796c8dc 27#include "objfiles.h"
5796c8dc
SS
28#include "value.h"
29#include "language.h"
cf7f2e2d 30#include "exceptions.h"
c50c785c
JM
31#include "event-loop.h"
32#include "serial.h"
a45ae5f8 33#include "readline/tilde.h"
c50c785c 34#include "python.h"
ef5ccd6c 35#include "cli/cli-utils.h"
5796c8dc
SS
36
37#include <ctype.h>
38
a45ae5f8
JM
39/* Declared constants and enum for python stack printing. */
40static const char python_excp_none[] = "none";
41static const char python_excp_full[] = "full";
42static const char python_excp_message[] = "message";
43
44/* "set python print-stack" choices. */
ef5ccd6c 45static const char *const python_excp_enums[] =
a45ae5f8
JM
46 {
47 python_excp_none,
48 python_excp_full,
49 python_excp_message,
50 NULL
51 };
52
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
56 the default. */
57static const char *gdbpy_should_print_stack = python_excp_message;
5796c8dc 58
5796c8dc
SS
59#ifdef HAVE_PYTHON
60
5796c8dc
SS
61#include "libiberty.h"
62#include "cli/cli-decode.h"
63#include "charset.h"
64#include "top.h"
c50c785c 65#include "solib.h"
5796c8dc 66#include "python-internal.h"
c50c785c
JM
67#include "linespec.h"
68#include "source.h"
5796c8dc
SS
69#include "version.h"
70#include "target.h"
71#include "gdbthread.h"
a45ae5f8
JM
72#include "observer.h"
73#include "interps.h"
ef5ccd6c 74#include "event-top.h"
5796c8dc
SS
75
76static PyMethodDef GdbMethods[];
77
ef5ccd6c
JM
78#ifdef IS_PY3K
79static struct PyModuleDef GdbModuleDef;
80#endif
81
5796c8dc 82PyObject *gdb_module;
ef5ccd6c 83PyObject *gdb_python_module;
5796c8dc
SS
84
85/* Some string constants we may wish to use. */
86PyObject *gdbpy_to_string_cst;
87PyObject *gdbpy_children_cst;
88PyObject *gdbpy_display_hint_cst;
89PyObject *gdbpy_doc_cst;
cf7f2e2d 90PyObject *gdbpy_enabled_cst;
c50c785c 91PyObject *gdbpy_value_cst;
5796c8dc 92
cf7f2e2d
JM
93/* The GdbError exception. */
94PyObject *gdbpy_gdberror_exc;
5796c8dc 95
c50c785c
JM
96/* The `gdb.error' base class. */
97PyObject *gdbpy_gdb_error;
98
99/* The `gdb.MemoryError' exception. */
100PyObject *gdbpy_gdb_memory_error;
101
5796c8dc
SS
102/* Architecture and language to be used in callbacks from
103 the Python interpreter. */
104struct gdbarch *python_gdbarch;
105const struct language_defn *python_language;
106
107/* Restore global language and architecture and Python GIL state
108 when leaving the Python interpreter. */
109
110struct python_env
111{
112 PyGILState_STATE state;
113 struct gdbarch *gdbarch;
114 const struct language_defn *language;
c50c785c 115 PyObject *error_type, *error_value, *error_traceback;
5796c8dc
SS
116};
117
118static void
119restore_python_env (void *p)
120{
121 struct python_env *env = (struct python_env *)p;
cf7f2e2d 122
c50c785c
JM
123 /* Leftover Python error is forbidden by Python Exception Handling. */
124 if (PyErr_Occurred ())
125 {
126 /* This order is similar to the one calling error afterwards. */
127 gdbpy_print_stack ();
128 warning (_("internal error: Unhandled Python exception"));
129 }
130
131 PyErr_Restore (env->error_type, env->error_value, env->error_traceback);
132
5796c8dc
SS
133 PyGILState_Release (env->state);
134 python_gdbarch = env->gdbarch;
135 python_language = env->language;
136 xfree (env);
137}
138
139/* Called before entering the Python interpreter to install the
140 current language and architecture to be used for Python values. */
141
142struct cleanup *
143ensure_python_env (struct gdbarch *gdbarch,
144 const struct language_defn *language)
145{
146 struct python_env *env = xmalloc (sizeof *env);
147
148 env->state = PyGILState_Ensure ();
149 env->gdbarch = python_gdbarch;
150 env->language = python_language;
151
152 python_gdbarch = gdbarch;
153 python_language = language;
154
c50c785c
JM
155 /* Save it and ensure ! PyErr_Occurred () afterwards. */
156 PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback);
157
5796c8dc
SS
158 return make_cleanup (restore_python_env, env);
159}
160
ef5ccd6c
JM
161/* Clear the quit flag. */
162
163void
164clear_quit_flag (void)
165{
166 /* This clears the flag as a side effect. */
167 PyOS_InterruptOccurred ();
168}
169
170/* Set the quit flag. */
171
172void
173set_quit_flag (void)
174{
175 PyErr_SetInterrupt ();
176}
177
178/* Return true if the quit flag has been set, false otherwise. */
179
180int
181check_quit_flag (void)
182{
183 return PyOS_InterruptOccurred ();
184}
185
186/* Evaluate a Python command like PyRun_SimpleString, but uses
187 Py_single_input which prints the result of expressions, and does
188 not automatically print the stack on errors. */
189
190static int
191eval_python_command (const char *command)
192{
193 PyObject *m, *d, *v;
194
195 m = PyImport_AddModule ("__main__");
196 if (m == NULL)
197 return -1;
198
199 d = PyModule_GetDict (m);
200 if (d == NULL)
201 return -1;
202 v = PyRun_StringFlags (command, Py_single_input, d, d, NULL);
203 if (v == NULL)
204 return -1;
205
206 Py_DECREF (v);
207#ifndef IS_PY3K
208 if (Py_FlushLine ())
209 PyErr_Clear ();
210#endif
211
212 return 0;
213}
214
215/* Implementation of the gdb "python-interactive" command. */
216
217static void
218python_interactive_command (char *arg, int from_tty)
219{
220 struct cleanup *cleanup;
221 int err;
222
223 cleanup = make_cleanup_restore_integer (&interpreter_async);
224 interpreter_async = 0;
225
226 arg = skip_spaces (arg);
227
228 ensure_python_env (get_current_arch (), current_language);
229
230 if (arg && *arg)
231 {
232 int len = strlen (arg);
233 char *script = xmalloc (len + 2);
234
235 strcpy (script, arg);
236 script[len] = '\n';
237 script[len + 1] = '\0';
238 err = eval_python_command (script);
239 xfree (script);
240 }
241 else
242 {
243 err = PyRun_InteractiveLoop (instream, "<stdin>");
244 dont_repeat ();
245 }
246
247 if (err)
248 {
249 gdbpy_print_stack ();
250 error (_("Error while executing Python code."));
251 }
252
253 do_cleanups (cleanup);
254}
255
256/* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
257 named FILENAME.
258
259 On Windows hosts few users would build Python themselves (this is no
260 trivial task on this platform), and thus use binaries built by
261 someone else instead. There may happen situation where the Python
262 library and GDB are using two different versions of the C runtime
263 library. Python, being built with VC, would use one version of the
264 msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
265 A FILE * from one runtime does not necessarily operate correctly in
a45ae5f8
JM
266 the other runtime.
267
ef5ccd6c
JM
268 To work around this potential issue, we create on Windows hosts the
269 FILE object using Python routines, thus making sure that it is
270 compatible with the Python library. */
a45ae5f8
JM
271
272static void
ef5ccd6c 273python_run_simple_file (FILE *file, const char *filename)
a45ae5f8 274{
ef5ccd6c
JM
275#ifndef _WIN32
276
277 PyRun_SimpleFile (file, filename);
278
279#else /* _WIN32 */
280
a45ae5f8
JM
281 char *full_path;
282 PyObject *python_file;
283 struct cleanup *cleanup;
284
285 /* Because we have a string for a filename, and are using Python to
286 open the file, we need to expand any tilde in the path first. */
287 full_path = tilde_expand (filename);
288 cleanup = make_cleanup (xfree, full_path);
289 python_file = PyFile_FromString (full_path, "r");
290 if (! python_file)
291 {
292 do_cleanups (cleanup);
293 gdbpy_print_stack ();
294 error (_("Error while opening file: %s"), full_path);
295 }
296
297 make_cleanup_py_decref (python_file);
298 PyRun_SimpleFile (PyFile_AsFile (python_file), filename);
299 do_cleanups (cleanup);
ef5ccd6c
JM
300
301#endif /* _WIN32 */
a45ae5f8 302}
5796c8dc
SS
303
304/* Given a command_line, return a command string suitable for passing
305 to Python. Lines in the string are separated by newlines. The
306 return value is allocated using xmalloc and the caller is
307 responsible for freeing it. */
308
309static char *
310compute_python_string (struct command_line *l)
311{
312 struct command_line *iter;
313 char *script = NULL;
314 int size = 0;
315 int here;
316
317 for (iter = l; iter; iter = iter->next)
318 size += strlen (iter->line) + 1;
319
320 script = xmalloc (size + 1);
321 here = 0;
322 for (iter = l; iter; iter = iter->next)
323 {
324 int len = strlen (iter->line);
cf7f2e2d 325
5796c8dc
SS
326 strcpy (&script[here], iter->line);
327 here += len;
328 script[here++] = '\n';
329 }
330 script[here] = '\0';
331 return script;
332}
333
334/* Take a command line structure representing a 'python' command, and
335 evaluate its body using the Python interpreter. */
336
337void
338eval_python_from_control_command (struct command_line *cmd)
339{
340 int ret;
341 char *script;
342 struct cleanup *cleanup;
343
344 if (cmd->body_count != 1)
345 error (_("Invalid \"python\" block structure."));
346
347 cleanup = ensure_python_env (get_current_arch (), current_language);
348
349 script = compute_python_string (cmd->body_list[0]);
350 ret = PyRun_SimpleString (script);
351 xfree (script);
352 if (ret)
a45ae5f8 353 error (_("Error while executing Python code."));
5796c8dc
SS
354
355 do_cleanups (cleanup);
356}
357
358/* Implementation of the gdb "python" command. */
359
360static void
361python_command (char *arg, int from_tty)
362{
363 struct cleanup *cleanup;
5796c8dc 364
cf7f2e2d 365 cleanup = ensure_python_env (get_current_arch (), current_language);
a45ae5f8
JM
366
367 make_cleanup_restore_integer (&interpreter_async);
368 interpreter_async = 0;
369
ef5ccd6c 370 arg = skip_spaces (arg);
5796c8dc
SS
371 if (arg && *arg)
372 {
373 if (PyRun_SimpleString (arg))
a45ae5f8 374 error (_("Error while executing Python code."));
5796c8dc
SS
375 }
376 else
377 {
378 struct command_line *l = get_command_line (python_control, "");
cf7f2e2d 379
5796c8dc
SS
380 make_cleanup_free_command_lines (&l);
381 execute_control_command_untraced (l);
382 }
383
384 do_cleanups (cleanup);
385}
386
387\f
388
389/* Transform a gdb parameters's value into a Python value. May return
390 NULL (and set a Python exception) on error. Helper function for
391 get_parameter. */
cf7f2e2d
JM
392PyObject *
393gdbpy_parameter_value (enum var_types type, void *var)
5796c8dc 394{
cf7f2e2d 395 switch (type)
5796c8dc
SS
396 {
397 case var_string:
398 case var_string_noescape:
399 case var_optional_filename:
400 case var_filename:
401 case var_enum:
402 {
cf7f2e2d
JM
403 char *str = * (char **) var;
404
5796c8dc
SS
405 if (! str)
406 str = "";
407 return PyString_Decode (str, strlen (str), host_charset (), NULL);
408 }
409
410 case var_boolean:
411 {
cf7f2e2d 412 if (* (int *) var)
5796c8dc
SS
413 Py_RETURN_TRUE;
414 else
415 Py_RETURN_FALSE;
416 }
417
418 case var_auto_boolean:
419 {
cf7f2e2d
JM
420 enum auto_boolean ab = * (enum auto_boolean *) var;
421
5796c8dc
SS
422 if (ab == AUTO_BOOLEAN_TRUE)
423 Py_RETURN_TRUE;
424 else if (ab == AUTO_BOOLEAN_FALSE)
425 Py_RETURN_FALSE;
426 else
427 Py_RETURN_NONE;
428 }
429
430 case var_integer:
cf7f2e2d 431 if ((* (int *) var) == INT_MAX)
5796c8dc
SS
432 Py_RETURN_NONE;
433 /* Fall through. */
434 case var_zinteger:
cf7f2e2d 435 return PyLong_FromLong (* (int *) var);
5796c8dc
SS
436
437 case var_uinteger:
438 {
cf7f2e2d
JM
439 unsigned int val = * (unsigned int *) var;
440
5796c8dc
SS
441 if (val == UINT_MAX)
442 Py_RETURN_NONE;
443 return PyLong_FromUnsignedLong (val);
444 }
445 }
446
cf7f2e2d
JM
447 return PyErr_Format (PyExc_RuntimeError,
448 _("Programmer error: unhandled type."));
5796c8dc
SS
449}
450
451/* A Python function which returns a gdb parameter's value as a Python
452 value. */
453
cf7f2e2d 454PyObject *
5796c8dc
SS
455gdbpy_parameter (PyObject *self, PyObject *args)
456{
457 struct cmd_list_element *alias, *prefix, *cmd;
a45ae5f8
JM
458 const char *arg;
459 char *newarg;
5796c8dc
SS
460 int found = -1;
461 volatile struct gdb_exception except;
462
463 if (! PyArg_ParseTuple (args, "s", &arg))
464 return NULL;
465
466 newarg = concat ("show ", arg, (char *) NULL);
467
468 TRY_CATCH (except, RETURN_MASK_ALL)
469 {
470 found = lookup_cmd_composition (newarg, &alias, &prefix, &cmd);
471 }
472 xfree (newarg);
473 GDB_PY_HANDLE_EXCEPTION (except);
474 if (!found)
475 return PyErr_Format (PyExc_RuntimeError,
cf7f2e2d 476 _("Could not find parameter `%s'."), arg);
5796c8dc
SS
477
478 if (! cmd->var)
cf7f2e2d
JM
479 return PyErr_Format (PyExc_RuntimeError,
480 _("`%s' is not a parameter."), arg);
481 return gdbpy_parameter_value (cmd->var_type, cmd->var);
482}
483
484/* Wrapper for target_charset. */
485
486static PyObject *
487gdbpy_target_charset (PyObject *self, PyObject *args)
488{
489 const char *cset = target_charset (python_gdbarch);
490
491 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
492}
493
494/* Wrapper for target_wide_charset. */
495
496static PyObject *
497gdbpy_target_wide_charset (PyObject *self, PyObject *args)
498{
499 const char *cset = target_wide_charset (python_gdbarch);
500
501 return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
5796c8dc
SS
502}
503
504/* A Python function which evaluates a string using the gdb CLI. */
505
506static PyObject *
cf7f2e2d 507execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
5796c8dc 508{
a45ae5f8 509 const char *arg;
cf7f2e2d
JM
510 PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
511 int from_tty, to_string;
5796c8dc 512 volatile struct gdb_exception except;
cf7f2e2d
JM
513 static char *keywords[] = {"command", "from_tty", "to_string", NULL };
514 char *result = NULL;
5796c8dc 515
cf7f2e2d
JM
516 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
517 &PyBool_Type, &from_tty_obj,
518 &PyBool_Type, &to_string_obj))
5796c8dc
SS
519 return NULL;
520
521 from_tty = 0;
522 if (from_tty_obj)
523 {
cf7f2e2d 524 int cmp = PyObject_IsTrue (from_tty_obj);
5796c8dc 525 if (cmp < 0)
cf7f2e2d 526 return NULL;
5796c8dc
SS
527 from_tty = cmp;
528 }
529
cf7f2e2d
JM
530 to_string = 0;
531 if (to_string_obj)
532 {
533 int cmp = PyObject_IsTrue (to_string_obj);
534 if (cmp < 0)
535 return NULL;
536 to_string = cmp;
537 }
538
5796c8dc
SS
539 TRY_CATCH (except, RETURN_MASK_ALL)
540 {
cf7f2e2d
JM
541 /* Copy the argument text in case the command modifies it. */
542 char *copy = xstrdup (arg);
543 struct cleanup *cleanup = make_cleanup (xfree, copy);
544
a45ae5f8
JM
545 make_cleanup_restore_integer (&interpreter_async);
546 interpreter_async = 0;
547
c50c785c 548 prevent_dont_repeat ();
cf7f2e2d
JM
549 if (to_string)
550 result = execute_command_to_string (copy, from_tty);
551 else
552 {
553 result = NULL;
554 execute_command (copy, from_tty);
555 }
556
557 do_cleanups (cleanup);
5796c8dc
SS
558 }
559 GDB_PY_HANDLE_EXCEPTION (except);
560
561 /* Do any commands attached to breakpoint we stopped at. */
562 bpstat_do_actions ();
563
cf7f2e2d
JM
564 if (result)
565 {
566 PyObject *r = PyString_FromString (result);
567 xfree (result);
568 return r;
569 }
5796c8dc
SS
570 Py_RETURN_NONE;
571}
572
c50c785c
JM
573/* Implementation of gdb.solib_name (Long) -> String.
574 Returns the name of the shared library holding a given address, or None. */
575
576static PyObject *
577gdbpy_solib_name (PyObject *self, PyObject *args)
578{
579 char *soname;
580 PyObject *str_obj;
581 gdb_py_longest pc;
582
583 if (!PyArg_ParseTuple (args, GDB_PY_LL_ARG, &pc))
584 return NULL;
585
586 soname = solib_name_from_address (current_program_space, pc);
587 if (soname)
588 str_obj = PyString_Decode (soname, strlen (soname), host_charset (), NULL);
589 else
590 {
591 str_obj = Py_None;
592 Py_INCREF (Py_None);
593 }
594
595 return str_obj;
596}
597
598/* A Python function which is a wrapper for decode_line_1. */
599
600static PyObject *
601gdbpy_decode_line (PyObject *self, PyObject *args)
602{
603 struct symtabs_and_lines sals = { NULL, 0 }; /* Initialize to
604 appease gcc. */
605 struct symtab_and_line sal;
a45ae5f8 606 const char *arg = NULL;
ef5ccd6c 607 char *copy_to_free = NULL, *copy = NULL;
c50c785c
JM
608 struct cleanup *cleanups;
609 PyObject *result = NULL;
610 PyObject *return_result = NULL;
611 PyObject *unparsed = NULL;
612 volatile struct gdb_exception except;
613
614 if (! PyArg_ParseTuple (args, "|s", &arg))
615 return NULL;
616
a45ae5f8 617 cleanups = make_cleanup (null_cleanup, NULL);
c50c785c 618
ef5ccd6c 619 sals.sals = NULL;
c50c785c
JM
620 TRY_CATCH (except, RETURN_MASK_ALL)
621 {
622 if (arg)
623 {
a45ae5f8 624 copy = xstrdup (arg);
ef5ccd6c 625 copy_to_free = copy;
a45ae5f8 626 sals = decode_line_1 (&copy, 0, 0, 0);
c50c785c
JM
627 }
628 else
629 {
630 set_default_source_symtab_and_line ();
631 sal = get_current_source_symtab_and_line ();
632 sals.sals = &sal;
633 sals.nelts = 1;
634 }
635 }
ef5ccd6c
JM
636
637 if (sals.sals != NULL && sals.sals != &sal)
638 {
639 make_cleanup (xfree, copy_to_free);
640 make_cleanup (xfree, sals.sals);
641 }
642
c50c785c
JM
643 if (except.reason < 0)
644 {
645 do_cleanups (cleanups);
646 /* We know this will always throw. */
647 GDB_PY_HANDLE_EXCEPTION (except);
648 }
649
650 if (sals.nelts)
651 {
652 int i;
653
654 result = PyTuple_New (sals.nelts);
655 if (! result)
656 goto error;
657 for (i = 0; i < sals.nelts; ++i)
658 {
659 PyObject *obj;
c50c785c
JM
660
661 obj = symtab_and_line_to_sal_object (sals.sals[i]);
662 if (! obj)
663 {
664 Py_DECREF (result);
665 goto error;
666 }
667
668 PyTuple_SetItem (result, i, obj);
669 }
670 }
671 else
672 {
673 result = Py_None;
674 Py_INCREF (Py_None);
675 }
676
677 return_result = PyTuple_New (2);
678 if (! return_result)
679 {
680 Py_DECREF (result);
681 goto error;
682 }
683
684 if (copy && strlen (copy) > 0)
ef5ccd6c
JM
685 {
686 unparsed = PyString_FromString (copy);
687 if (unparsed == NULL)
688 {
689 Py_DECREF (result);
690 Py_DECREF (return_result);
691 return_result = NULL;
692 goto error;
693 }
694 }
c50c785c
JM
695 else
696 {
697 unparsed = Py_None;
698 Py_INCREF (Py_None);
699 }
700
701 PyTuple_SetItem (return_result, 0, unparsed);
702 PyTuple_SetItem (return_result, 1, result);
703
ef5ccd6c 704 error:
c50c785c
JM
705 do_cleanups (cleanups);
706
707 return return_result;
c50c785c
JM
708}
709
cf7f2e2d
JM
710/* Parse a string and evaluate it as an expression. */
711static PyObject *
712gdbpy_parse_and_eval (PyObject *self, PyObject *args)
713{
a45ae5f8 714 const char *expr_str;
cf7f2e2d
JM
715 struct value *result = NULL;
716 volatile struct gdb_exception except;
717
718 if (!PyArg_ParseTuple (args, "s", &expr_str))
719 return NULL;
720
721 TRY_CATCH (except, RETURN_MASK_ALL)
722 {
ef5ccd6c 723 result = parse_and_eval (expr_str);
cf7f2e2d
JM
724 }
725 GDB_PY_HANDLE_EXCEPTION (except);
726
727 return value_to_value_object (result);
728}
729
ef5ccd6c
JM
730/* Implementation of gdb.find_pc_line function.
731 Returns the gdb.Symtab_and_line object corresponding to a PC value. */
732
733static PyObject *
734gdbpy_find_pc_line (PyObject *self, PyObject *args)
735{
736 gdb_py_ulongest pc_llu;
737 volatile struct gdb_exception except;
738 PyObject *result = NULL; /* init for gcc -Wall */
739
740 if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu))
741 return NULL;
742
743 TRY_CATCH (except, RETURN_MASK_ALL)
744 {
745 struct symtab_and_line sal;
746 CORE_ADDR pc;
747
748 pc = (CORE_ADDR) pc_llu;
749 sal = find_pc_line (pc, 0);
750 result = symtab_and_line_to_sal_object (sal);
751 }
752 GDB_PY_HANDLE_EXCEPTION (except);
753
754 return result;
755}
756
a45ae5f8 757/* Read a file as Python code.
ef5ccd6c 758 FILE is the file to run. FILENAME is name of the file FILE.
a45ae5f8
JM
759 This does not throw any errors. If an exception occurs python will print
760 the traceback and clear the error indicator. */
cf7f2e2d
JM
761
762void
ef5ccd6c 763source_python_script (FILE *file, const char *filename)
cf7f2e2d
JM
764{
765 struct cleanup *cleanup;
766
767 cleanup = ensure_python_env (get_current_arch (), current_language);
ef5ccd6c 768 python_run_simple_file (file, filename);
cf7f2e2d
JM
769 do_cleanups (cleanup);
770}
771
5796c8dc
SS
772\f
773
c50c785c
JM
774/* Posting and handling events. */
775
776/* A single event. */
777struct gdbpy_event
778{
779 /* The Python event. This is just a callable object. */
780 PyObject *event;
781 /* The next event. */
782 struct gdbpy_event *next;
783};
784
785/* All pending events. */
786static struct gdbpy_event *gdbpy_event_list;
787/* The final link of the event list. */
788static struct gdbpy_event **gdbpy_event_list_end;
789
790/* We use a file handler, and not an async handler, so that we can
791 wake up the main thread even when it is blocked in poll(). */
792static struct serial *gdbpy_event_fds[2];
793
794/* The file handler callback. This reads from the internal pipe, and
795 then processes the Python event queue. This will always be run in
796 the main gdb thread. */
797
798static void
799gdbpy_run_events (struct serial *scb, void *context)
800{
801 struct cleanup *cleanup;
c50c785c
JM
802
803 cleanup = ensure_python_env (get_current_arch (), current_language);
804
805 /* Flush the fd. Do this before flushing the events list, so that
806 any new event post afterwards is sure to re-awake the event
807 loop. */
808 while (serial_readchar (gdbpy_event_fds[0], 0) >= 0)
809 ;
810
811 while (gdbpy_event_list)
812 {
813 /* Dispatching the event might push a new element onto the event
814 loop, so we update here "atomically enough". */
815 struct gdbpy_event *item = gdbpy_event_list;
816 gdbpy_event_list = gdbpy_event_list->next;
817 if (gdbpy_event_list == NULL)
818 gdbpy_event_list_end = &gdbpy_event_list;
819
820 /* Ignore errors. */
821 if (PyObject_CallObject (item->event, NULL) == NULL)
822 PyErr_Clear ();
823
824 Py_DECREF (item->event);
825 xfree (item);
826 }
827
828 do_cleanups (cleanup);
829}
830
831/* Submit an event to the gdb thread. */
832static PyObject *
833gdbpy_post_event (PyObject *self, PyObject *args)
834{
835 struct gdbpy_event *event;
836 PyObject *func;
837 int wakeup;
838
839 if (!PyArg_ParseTuple (args, "O", &func))
840 return NULL;
841
842 if (!PyCallable_Check (func))
843 {
844 PyErr_SetString (PyExc_RuntimeError,
845 _("Posted event is not callable"));
846 return NULL;
847 }
848
849 Py_INCREF (func);
850
851 /* From here until the end of the function, we have the GIL, so we
852 can operate on our global data structures without worrying. */
853 wakeup = gdbpy_event_list == NULL;
854
855 event = XNEW (struct gdbpy_event);
856 event->event = func;
857 event->next = NULL;
858 *gdbpy_event_list_end = event;
859 gdbpy_event_list_end = &event->next;
860
861 /* Wake up gdb when needed. */
862 if (wakeup)
863 {
864 char c = 'q'; /* Anything. */
865
866 if (serial_write (gdbpy_event_fds[1], &c, 1))
867 return PyErr_SetFromErrno (PyExc_IOError);
868 }
869
870 Py_RETURN_NONE;
871}
872
873/* Initialize the Python event handler. */
874static void
875gdbpy_initialize_events (void)
876{
877 if (serial_pipe (gdbpy_event_fds) == 0)
878 {
879 gdbpy_event_list_end = &gdbpy_event_list;
880 serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL);
881 }
882}
883
a45ae5f8
JM
884\f
885
886static void
887before_prompt_hook (const char *current_gdb_prompt)
888{
889 struct cleanup *cleanup;
890 char *prompt = NULL;
891
892 cleanup = ensure_python_env (get_current_arch (), current_language);
893
ef5ccd6c
JM
894 if (gdb_python_module
895 && PyObject_HasAttrString (gdb_python_module, "prompt_hook"))
a45ae5f8
JM
896 {
897 PyObject *hook;
898
ef5ccd6c 899 hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook");
a45ae5f8
JM
900 if (hook == NULL)
901 goto fail;
902
903 if (PyCallable_Check (hook))
904 {
905 PyObject *result;
906 PyObject *current_prompt;
907
908 current_prompt = PyString_FromString (current_gdb_prompt);
909 if (current_prompt == NULL)
910 goto fail;
911
912 result = PyObject_CallFunctionObjArgs (hook, current_prompt, NULL);
913
914 Py_DECREF (current_prompt);
915
916 if (result == NULL)
917 goto fail;
918
919 make_cleanup_py_decref (result);
920
921 /* Return type should be None, or a String. If it is None,
922 fall through, we will not set a prompt. If it is a
923 string, set PROMPT. Anything else, set an exception. */
924 if (result != Py_None && ! PyString_Check (result))
925 {
926 PyErr_Format (PyExc_RuntimeError,
927 _("Return from prompt_hook must " \
928 "be either a Python string, or None"));
929 goto fail;
930 }
931
932 if (result != Py_None)
933 {
934 prompt = python_string_to_host_string (result);
935
936 if (prompt == NULL)
937 goto fail;
938 else
939 make_cleanup (xfree, prompt);
940 }
941 }
942 }
943
944 /* If a prompt has been set, PROMPT will not be NULL. If it is
945 NULL, do not set the prompt. */
946 if (prompt != NULL)
947 set_prompt (prompt);
948
949 do_cleanups (cleanup);
950 return;
951
952 fail:
953 gdbpy_print_stack ();
954 do_cleanups (cleanup);
955 return;
956}
957
958\f
959
5796c8dc
SS
960/* Printing. */
961
962/* A python function to write a single string using gdb's filtered
c50c785c
JM
963 output stream . The optional keyword STREAM can be used to write
964 to a particular stream. The default stream is to gdb_stdout. */
965
5796c8dc 966static PyObject *
c50c785c 967gdbpy_write (PyObject *self, PyObject *args, PyObject *kw)
5796c8dc 968{
a45ae5f8 969 const char *arg;
c50c785c
JM
970 static char *keywords[] = {"text", "stream", NULL };
971 int stream_type = 0;
ef5ccd6c 972 volatile struct gdb_exception except;
c50c785c
JM
973
974 if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg,
975 &stream_type))
5796c8dc 976 return NULL;
c50c785c 977
ef5ccd6c 978 TRY_CATCH (except, RETURN_MASK_ALL)
c50c785c 979 {
ef5ccd6c
JM
980 switch (stream_type)
981 {
982 case 1:
983 {
984 fprintf_filtered (gdb_stderr, "%s", arg);
985 break;
986 }
987 case 2:
988 {
989 fprintf_filtered (gdb_stdlog, "%s", arg);
990 break;
991 }
992 default:
993 fprintf_filtered (gdb_stdout, "%s", arg);
994 }
c50c785c 995 }
ef5ccd6c 996 GDB_PY_HANDLE_EXCEPTION (except);
c50c785c 997
5796c8dc
SS
998 Py_RETURN_NONE;
999}
1000
c50c785c
JM
1001/* A python function to flush a gdb stream. The optional keyword
1002 STREAM can be used to flush a particular stream. The default stream
1003 is gdb_stdout. */
1004
5796c8dc 1005static PyObject *
c50c785c 1006gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw)
5796c8dc 1007{
c50c785c
JM
1008 static char *keywords[] = {"stream", NULL };
1009 int stream_type = 0;
1010
1011 if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords,
1012 &stream_type))
1013 return NULL;
1014
1015 switch (stream_type)
1016 {
1017 case 1:
1018 {
1019 gdb_flush (gdb_stderr);
1020 break;
1021 }
1022 case 2:
1023 {
1024 gdb_flush (gdb_stdlog);
1025 break;
1026 }
1027 default:
1028 gdb_flush (gdb_stdout);
1029 }
1030
5796c8dc
SS
1031 Py_RETURN_NONE;
1032}
1033
a45ae5f8
JM
1034/* Print a python exception trace, print just a message, or print
1035 nothing and clear the python exception, depending on
1036 gdbpy_should_print_stack. Only call this if a python exception is
1037 set. */
5796c8dc
SS
1038void
1039gdbpy_print_stack (void)
1040{
ef5ccd6c
JM
1041 volatile struct gdb_exception except;
1042
a45ae5f8
JM
1043 /* Print "none", just clear exception. */
1044 if (gdbpy_should_print_stack == python_excp_none)
1045 {
1046 PyErr_Clear ();
1047 }
1048 /* Print "full" message and backtrace. */
1049 else if (gdbpy_should_print_stack == python_excp_full)
cf7f2e2d
JM
1050 {
1051 PyErr_Print ();
1052 /* PyErr_Print doesn't necessarily end output with a newline.
1053 This works because Python's stdout/stderr is fed through
1054 printf_filtered. */
ef5ccd6c
JM
1055 TRY_CATCH (except, RETURN_MASK_ALL)
1056 {
1057 begin_line ();
1058 }
cf7f2e2d 1059 }
a45ae5f8 1060 /* Print "message", just error print message. */
5796c8dc 1061 else
a45ae5f8
JM
1062 {
1063 PyObject *ptype, *pvalue, *ptraceback;
1064 char *msg = NULL, *type = NULL;
1065
1066 PyErr_Fetch (&ptype, &pvalue, &ptraceback);
1067
1068 /* Fetch the error message contained within ptype, pvalue. */
1069 msg = gdbpy_exception_to_string (ptype, pvalue);
1070 type = gdbpy_obj_to_string (ptype);
ef5ccd6c
JM
1071
1072 TRY_CATCH (except, RETURN_MASK_ALL)
a45ae5f8 1073 {
ef5ccd6c
JM
1074 if (msg == NULL)
1075 {
1076 /* An error occurred computing the string representation of the
1077 error message. */
1078 fprintf_filtered (gdb_stderr,
1079 _("Error occurred computing Python error" \
1080 "message.\n"));
1081 }
1082 else
1083 fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n",
1084 type, msg);
a45ae5f8 1085 }
a45ae5f8
JM
1086
1087 Py_XDECREF (ptype);
1088 Py_XDECREF (pvalue);
1089 Py_XDECREF (ptraceback);
1090 xfree (msg);
1091 }
5796c8dc
SS
1092}
1093
1094\f
1095
cf7f2e2d
JM
1096/* Return the current Progspace.
1097 There always is one. */
5796c8dc 1098
cf7f2e2d
JM
1099static PyObject *
1100gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
1101{
1102 PyObject *result;
5796c8dc 1103
cf7f2e2d
JM
1104 result = pspace_to_pspace_object (current_program_space);
1105 if (result)
1106 Py_INCREF (result);
1107 return result;
1108}
1109
1110/* Return a sequence holding all the Progspaces. */
1111
1112static PyObject *
1113gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
5796c8dc 1114{
cf7f2e2d
JM
1115 struct program_space *ps;
1116 PyObject *list;
5796c8dc 1117
cf7f2e2d
JM
1118 list = PyList_New (0);
1119 if (!list)
1120 return NULL;
5796c8dc 1121
cf7f2e2d
JM
1122 ALL_PSPACES (ps)
1123 {
1124 PyObject *item = pspace_to_pspace_object (ps);
5796c8dc 1125
cf7f2e2d
JM
1126 if (!item || PyList_Append (list, item) == -1)
1127 {
1128 Py_DECREF (list);
1129 return NULL;
1130 }
1131 }
5796c8dc 1132
cf7f2e2d
JM
1133 return list;
1134}
5796c8dc 1135
cf7f2e2d 1136\f
5796c8dc 1137
cf7f2e2d
JM
1138/* The "current" objfile. This is set when gdb detects that a new
1139 objfile has been loaded. It is only set for the duration of a call to
1140 source_python_script_for_objfile; it is NULL at other times. */
1141static struct objfile *gdbpy_current_objfile;
5796c8dc 1142
ef5ccd6c
JM
1143/* Set the current objfile to OBJFILE and then read FILE named FILENAME
1144 as Python code. This does not throw any errors. If an exception
1145 occurs python will print the traceback and clear the error indicator. */
5796c8dc 1146
cf7f2e2d 1147void
ef5ccd6c
JM
1148source_python_script_for_objfile (struct objfile *objfile, FILE *file,
1149 const char *filename)
cf7f2e2d
JM
1150{
1151 struct cleanup *cleanups;
5796c8dc 1152
cf7f2e2d
JM
1153 cleanups = ensure_python_env (get_objfile_arch (objfile), current_language);
1154 gdbpy_current_objfile = objfile;
1155
ef5ccd6c 1156 python_run_simple_file (file, filename);
5796c8dc
SS
1157
1158 do_cleanups (cleanups);
1159 gdbpy_current_objfile = NULL;
1160}
1161
1162/* Return the current Objfile, or None if there isn't one. */
cf7f2e2d 1163
5796c8dc
SS
1164static PyObject *
1165gdbpy_get_current_objfile (PyObject *unused1, PyObject *unused2)
1166{
1167 PyObject *result;
1168
1169 if (! gdbpy_current_objfile)
1170 Py_RETURN_NONE;
1171
1172 result = objfile_to_objfile_object (gdbpy_current_objfile);
1173 if (result)
1174 Py_INCREF (result);
1175 return result;
1176}
1177
1178/* Return a sequence holding all the Objfiles. */
cf7f2e2d 1179
5796c8dc
SS
1180static PyObject *
1181gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
1182{
1183 struct objfile *objf;
1184 PyObject *list;
1185
1186 list = PyList_New (0);
1187 if (!list)
1188 return NULL;
1189
1190 ALL_OBJFILES (objf)
1191 {
1192 PyObject *item = objfile_to_objfile_object (objf);
cf7f2e2d 1193
5796c8dc
SS
1194 if (!item || PyList_Append (list, item) == -1)
1195 {
1196 Py_DECREF (list);
1197 return NULL;
1198 }
1199 }
1200
1201 return list;
1202}
1203
ef5ccd6c
JM
1204/* Compute the list of active type printers and return it. The result
1205 of this function can be passed to apply_type_printers, and should
1206 be freed by free_type_printers. */
1207
1208void *
1209start_type_printers (void)
1210{
1211 struct cleanup *cleanups;
1212 PyObject *type_module, *func, *result_obj = NULL;
1213
1214 cleanups = ensure_python_env (get_current_arch (), current_language);
1215
1216 type_module = PyImport_ImportModule ("gdb.types");
1217 if (type_module == NULL)
1218 {
1219 gdbpy_print_stack ();
1220 goto done;
1221 }
1222 make_cleanup_py_decref (type_module);
1223
1224 func = PyObject_GetAttrString (type_module, "get_type_recognizers");
1225 if (func == NULL)
1226 {
1227 gdbpy_print_stack ();
1228 goto done;
1229 }
1230 make_cleanup_py_decref (func);
1231
1232 result_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL);
1233 if (result_obj == NULL)
1234 gdbpy_print_stack ();
1235
1236 done:
1237 do_cleanups (cleanups);
1238 return result_obj;
1239}
1240
1241/* If TYPE is recognized by some type printer, return a newly
1242 allocated string holding the type's replacement name. The caller
1243 is responsible for freeing the string. Otherwise, return NULL.
1244
1245 This function has a bit of a funny name, since it actually applies
1246 recognizers, but this seemed clearer given the start_type_printers
1247 and free_type_printers functions. */
1248
1249char *
1250apply_type_printers (void *printers, struct type *type)
1251{
1252 struct cleanup *cleanups;
1253 PyObject *type_obj, *type_module, *func, *result_obj;
1254 PyObject *printers_obj = printers;
1255 char *result = NULL;
1256
1257 if (printers_obj == NULL)
1258 return NULL;
1259
1260 cleanups = ensure_python_env (get_current_arch (), current_language);
1261
1262 type_obj = type_to_type_object (type);
1263 if (type_obj == NULL)
1264 {
1265 gdbpy_print_stack ();
1266 goto done;
1267 }
1268 make_cleanup_py_decref (type_obj);
1269
1270 type_module = PyImport_ImportModule ("gdb.types");
1271 if (type_module == NULL)
1272 {
1273 gdbpy_print_stack ();
1274 goto done;
1275 }
1276 make_cleanup_py_decref (type_module);
1277
1278 func = PyObject_GetAttrString (type_module, "apply_type_recognizers");
1279 if (func == NULL)
1280 {
1281 gdbpy_print_stack ();
1282 goto done;
1283 }
1284 make_cleanup_py_decref (func);
1285
1286 result_obj = PyObject_CallFunctionObjArgs (func, printers_obj,
1287 type_obj, (char *) NULL);
1288 if (result_obj == NULL)
1289 {
1290 gdbpy_print_stack ();
1291 goto done;
1292 }
1293 make_cleanup_py_decref (result_obj);
1294
1295 if (result_obj != Py_None)
1296 {
1297 result = python_string_to_host_string (result_obj);
1298 if (result == NULL)
1299 gdbpy_print_stack ();
1300 }
1301
1302 done:
1303 do_cleanups (cleanups);
1304 return result;
1305}
1306
1307/* Free the result of start_type_printers. */
1308
1309void
1310free_type_printers (void *arg)
1311{
1312 struct cleanup *cleanups;
1313 PyObject *printers = arg;
1314
1315 if (printers == NULL)
1316 return;
1317
1318 cleanups = ensure_python_env (get_current_arch (), current_language);
1319 Py_DECREF (printers);
1320 do_cleanups (cleanups);
1321}
1322
5796c8dc
SS
1323#else /* HAVE_PYTHON */
1324
ef5ccd6c
JM
1325/* Dummy implementation of the gdb "python-interactive" and "python"
1326 command. */
5796c8dc
SS
1327
1328static void
ef5ccd6c 1329python_interactive_command (char *arg, int from_tty)
5796c8dc 1330{
ef5ccd6c 1331 arg = skip_spaces (arg);
5796c8dc
SS
1332 if (arg && *arg)
1333 error (_("Python scripting is not supported in this copy of GDB."));
1334 else
1335 {
1336 struct command_line *l = get_command_line (python_control, "");
1337 struct cleanup *cleanups = make_cleanup_free_command_lines (&l);
cf7f2e2d 1338
5796c8dc
SS
1339 execute_control_command_untraced (l);
1340 do_cleanups (cleanups);
1341 }
1342}
1343
ef5ccd6c
JM
1344static void
1345python_command (char *arg, int from_tty)
1346{
1347 python_interactive_command (arg, from_tty);
1348}
1349
5796c8dc
SS
1350void
1351eval_python_from_control_command (struct command_line *cmd)
1352{
1353 error (_("Python scripting is not supported in this copy of GDB."));
1354}
1355
cf7f2e2d 1356void
ef5ccd6c 1357source_python_script (FILE *file, const char *filename)
cf7f2e2d
JM
1358{
1359 throw_error (UNSUPPORTED_ERROR,
1360 _("Python scripting is not supported in this copy of GDB."));
1361}
1362
c50c785c
JM
1363int
1364gdbpy_should_stop (struct breakpoint_object *bp_obj)
1365{
1366 internal_error (__FILE__, __LINE__,
1367 _("gdbpy_should_stop called when Python scripting is " \
1368 "not supported."));
1369}
1370
1371int
1372gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj)
1373{
1374 internal_error (__FILE__, __LINE__,
1375 _("gdbpy_breakpoint_has_py_cond called when Python " \
1376 "scripting is not supported."));
1377}
1378
ef5ccd6c
JM
1379void *
1380start_type_printers (void)
5796c8dc 1381{
ef5ccd6c 1382 return NULL;
5796c8dc
SS
1383}
1384
ef5ccd6c
JM
1385char *
1386apply_type_printers (void *ignore, struct type *type)
a45ae5f8 1387{
ef5ccd6c 1388 return NULL;
a45ae5f8
JM
1389}
1390
ef5ccd6c
JM
1391void
1392free_type_printers (void *arg)
5796c8dc 1393{
a45ae5f8
JM
1394}
1395
ef5ccd6c 1396#endif /* HAVE_PYTHON */
a45ae5f8
JM
1397
1398\f
1399
1400/* Lists for 'set python' commands. */
1401
1402static struct cmd_list_element *user_set_python_list;
1403static struct cmd_list_element *user_show_python_list;
1404
1405/* Function for use by 'set python' prefix command. */
1406
1407static void
1408user_set_python (char *args, int from_tty)
1409{
1410 help_list (user_set_python_list, "set python ", all_commands,
1411 gdb_stdout);
1412}
1413
1414/* Function for use by 'show python' prefix command. */
1415
1416static void
1417user_show_python (char *args, int from_tty)
1418{
1419 cmd_show_list (user_show_python_list, from_tty, "");
5796c8dc
SS
1420}
1421
1422/* Initialize the Python code. */
1423
ef5ccd6c
JM
1424#ifdef HAVE_PYTHON
1425
1426/* This is installed as a final cleanup and cleans up the
1427 interpreter. This lets Python's 'atexit' work. */
1428
1429static void
1430finalize_python (void *ignore)
1431{
1432 /* We don't use ensure_python_env here because if we ever ran the
1433 cleanup, gdb would crash -- because the cleanup calls into the
1434 Python interpreter, which we are about to destroy. It seems
1435 clearer to make the needed calls explicitly here than to create a
1436 cleanup and then mysteriously discard it. */
1437 (void) PyGILState_Ensure ();
1438 python_gdbarch = target_gdbarch ();
1439 python_language = current_language;
1440
1441 Py_Finalize ();
1442}
1443#endif
1444
5796c8dc
SS
1445/* Provide a prototype to silence -Wmissing-prototypes. */
1446extern initialize_file_ftype _initialize_python;
1447
1448void
1449_initialize_python (void)
1450{
ef5ccd6c
JM
1451 char *progname;
1452#ifdef IS_PY3K
1453 int i;
1454 size_t progsize, count;
1455 char *oldloc;
1456 wchar_t *progname_copy;
1457#endif
1458
1459 add_com ("python-interactive", class_obscure,
1460 python_interactive_command,
1461#ifdef HAVE_PYTHON
1462 _("\
1463Start an interactive Python prompt.\n\
1464\n\
1465To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\
1466prompt).\n\
1467\n\
1468Alternatively, a single-line Python command can be given as an\n\
1469argument, and if the command is an expression, the result will be\n\
1470printed. For example:\n\
1471\n\
1472 (gdb) python-interactive 2 + 3\n\
1473 5\n\
1474")
1475#else /* HAVE_PYTHON */
1476 _("\
1477Start a Python interactive prompt.\n\
1478\n\
1479Python scripting is not supported in this copy of GDB.\n\
1480This command is only a placeholder.")
1481#endif /* HAVE_PYTHON */
1482 );
1483 add_com_alias ("pi", "python-interactive", class_obscure, 1);
a45ae5f8 1484
5796c8dc
SS
1485 add_com ("python", class_obscure, python_command,
1486#ifdef HAVE_PYTHON
1487 _("\
1488Evaluate a Python command.\n\
1489\n\
1490The command can be given as an argument, for instance:\n\
1491\n\
1492 python print 23\n\
1493\n\
1494If no argument is given, the following lines are read and used\n\
1495as the Python commands. Type a line containing \"end\" to indicate\n\
1496the end of the command.")
1497#else /* HAVE_PYTHON */
1498 _("\
1499Evaluate a Python command.\n\
1500\n\
1501Python scripting is not supported in this copy of GDB.\n\
1502This command is only a placeholder.")
1503#endif /* HAVE_PYTHON */
1504 );
ef5ccd6c 1505 add_com_alias ("py", "python", class_obscure, 1);
a45ae5f8
JM
1506
1507 /* Add set/show python print-stack. */
1508 add_prefix_cmd ("python", no_class, user_show_python,
1509 _("Prefix command for python preference settings."),
1510 &user_show_python_list, "show python ", 0,
1511 &showlist);
1512
1513 add_prefix_cmd ("python", no_class, user_set_python,
1514 _("Prefix command for python preference settings."),
1515 &user_set_python_list, "set python ", 0,
1516 &setlist);
1517
1518 add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums,
1519 &gdbpy_should_print_stack, _("\
1520Set mode for Python stack dump on error."), _("\
1521Show the mode of Python stack printing on error."), _("\
1522none == no stack or message will be printed.\n\
1523full == a message and a stack will be printed.\n\
1524message == an error message without a stack will be printed."),
1525 NULL, NULL,
1526 &user_set_python_list,
1527 &user_show_python_list);
5796c8dc 1528
5796c8dc 1529#ifdef HAVE_PYTHON
cf7f2e2d
JM
1530#ifdef WITH_PYTHON_PATH
1531 /* Work around problem where python gets confused about where it is,
1532 and then can't find its libraries, etc.
1533 NOTE: Python assumes the following layout:
1534 /foo/bin/python
1535 /foo/lib/pythonX.Y/...
1536 This must be done before calling Py_Initialize. */
ef5ccd6c
JM
1537 progname = concat (ldirname (python_libdir), SLASH_STRING, "bin",
1538 SLASH_STRING, "python", NULL);
1539#ifdef IS_PY3K
1540 oldloc = setlocale (LC_ALL, NULL);
1541 setlocale (LC_ALL, "");
1542 progsize = strlen (progname);
1543 if (progsize == (size_t) -1)
1544 {
1545 fprintf (stderr, "Could not convert python path to string\n");
1546 return;
1547 }
1548 progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t));
1549 if (!progname_copy)
1550 {
1551 fprintf (stderr, "out of memory\n");
1552 return;
1553 }
1554 count = mbstowcs (progname_copy, progname, progsize + 1);
1555 if (count == (size_t) -1)
1556 {
1557 fprintf (stderr, "Could not convert python path to string\n");
1558 return;
1559 }
1560 setlocale (LC_ALL, oldloc);
1561
1562 /* Note that Py_SetProgramName expects the string it is passed to
1563 remain alive for the duration of the program's execution, so
1564 it is not freed after this call. */
1565 Py_SetProgramName (progname_copy);
1566#else
1567 Py_SetProgramName (progname);
1568#endif
cf7f2e2d
JM
1569#endif
1570
5796c8dc
SS
1571 Py_Initialize ();
1572 PyEval_InitThreads ();
1573
ef5ccd6c
JM
1574#ifdef IS_PY3K
1575 gdb_module = PyModule_Create (&GdbModuleDef);
1576 /* Add _gdb module to the list of known built-in modules. */
1577 _PyImport_FixupBuiltin (gdb_module, "_gdb");
1578#else
1579 gdb_module = Py_InitModule ("_gdb", GdbMethods);
1580#endif
5796c8dc
SS
1581
1582 /* The casts to (char*) are for python 2.4. */
1583 PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
1584 PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name);
c50c785c
JM
1585 PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG",
1586 (char*) target_name);
1587
1588 /* Add stream constants. */
1589 PyModule_AddIntConstant (gdb_module, "STDOUT", 0);
1590 PyModule_AddIntConstant (gdb_module, "STDERR", 1);
1591 PyModule_AddIntConstant (gdb_module, "STDLOG", 2);
5796c8dc 1592
c50c785c
JM
1593 gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL);
1594 PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error);
1595
1596 gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError",
1597 gdbpy_gdb_error, NULL);
1598 PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error);
1599
cf7f2e2d
JM
1600 gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL);
1601 PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc);
1602
ef5ccd6c 1603 gdbpy_initialize_gdb_readline ();
cf7f2e2d 1604 gdbpy_initialize_auto_load ();
5796c8dc
SS
1605 gdbpy_initialize_values ();
1606 gdbpy_initialize_frames ();
1607 gdbpy_initialize_commands ();
cf7f2e2d
JM
1608 gdbpy_initialize_symbols ();
1609 gdbpy_initialize_symtabs ();
1610 gdbpy_initialize_blocks ();
5796c8dc 1611 gdbpy_initialize_functions ();
cf7f2e2d 1612 gdbpy_initialize_parameters ();
5796c8dc 1613 gdbpy_initialize_types ();
cf7f2e2d 1614 gdbpy_initialize_pspace ();
5796c8dc 1615 gdbpy_initialize_objfile ();
cf7f2e2d 1616 gdbpy_initialize_breakpoints ();
a45ae5f8 1617 gdbpy_initialize_finishbreakpoints ();
cf7f2e2d
JM
1618 gdbpy_initialize_lazy_string ();
1619 gdbpy_initialize_thread ();
1620 gdbpy_initialize_inferior ();
c50c785c
JM
1621 gdbpy_initialize_events ();
1622
1623 gdbpy_initialize_eventregistry ();
1624 gdbpy_initialize_py_events ();
1625 gdbpy_initialize_event ();
1626 gdbpy_initialize_stop_event ();
1627 gdbpy_initialize_signal_event ();
1628 gdbpy_initialize_breakpoint_event ();
1629 gdbpy_initialize_continue_event ();
1630 gdbpy_initialize_exited_event ();
1631 gdbpy_initialize_thread_event ();
a45ae5f8 1632 gdbpy_initialize_new_objfile_event () ;
ef5ccd6c 1633 gdbpy_initialize_arch ();
a45ae5f8
JM
1634
1635 observer_attach_before_prompt (before_prompt_hook);
5796c8dc 1636
5796c8dc
SS
1637 gdbpy_to_string_cst = PyString_FromString ("to_string");
1638 gdbpy_children_cst = PyString_FromString ("children");
1639 gdbpy_display_hint_cst = PyString_FromString ("display_hint");
1640 gdbpy_doc_cst = PyString_FromString ("__doc__");
cf7f2e2d 1641 gdbpy_enabled_cst = PyString_FromString ("enabled");
c50c785c
JM
1642 gdbpy_value_cst = PyString_FromString ("value");
1643
1644 /* Release the GIL while gdb runs. */
1645 PyThreadState_Swap (NULL);
1646 PyEval_ReleaseLock ();
1647
ef5ccd6c 1648 make_final_cleanup (finalize_python, NULL);
c50c785c
JM
1649#endif /* HAVE_PYTHON */
1650}
1651
1652#ifdef HAVE_PYTHON
1653
1654/* Perform the remaining python initializations.
1655 These must be done after GDB is at least mostly initialized.
1656 E.g., The "info pretty-printer" command needs the "info" prefix
1657 command installed. */
1658
1659void
1660finish_python_initialization (void)
1661{
ef5ccd6c
JM
1662 PyObject *m;
1663 char *gdb_pythondir;
1664 PyObject *sys_path;
c50c785c
JM
1665 struct cleanup *cleanup;
1666
1667 cleanup = ensure_python_env (get_current_arch (), current_language);
5796c8dc 1668
ef5ccd6c
JM
1669 /* Add the initial data-directory to sys.path. */
1670
1671 gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL);
1672 make_cleanup (xfree, gdb_pythondir);
1673
1674 sys_path = PySys_GetObject ("path");
1675
1676 /* If sys.path is not defined yet, define it first. */
1677 if (!(sys_path && PyList_Check (sys_path)))
1678 {
1679#ifdef IS_PY3K
1680 PySys_SetPath (L"");
1681#else
1682 PySys_SetPath ("");
1683#endif
1684 sys_path = PySys_GetObject ("path");
1685 }
1686 if (sys_path && PyList_Check (sys_path))
1687 {
1688 PyObject *pythondir;
1689 int err;
1690
1691 pythondir = PyString_FromString (gdb_pythondir);
1692 if (pythondir == NULL)
1693 goto fail;
1694
1695 err = PyList_Insert (sys_path, 0, pythondir);
1696 if (err)
1697 goto fail;
1698
1699 Py_DECREF (pythondir);
1700 }
1701 else
1702 goto fail;
1703
1704 /* Import the gdb module to finish the initialization, and
1705 add it to __main__ for convenience. */
1706 m = PyImport_AddModule ("__main__");
1707 if (m == NULL)
1708 goto fail;
1709
1710 gdb_python_module = PyImport_ImportModule ("gdb");
1711 if (gdb_python_module == NULL)
1712 {
1713 gdbpy_print_stack ();
1714 /* This is passed in one call to warning so that blank lines aren't
1715 inserted between each line of text. */
1716 warning (_("\n"
1717 "Could not load the Python gdb module from `%s'.\n"
1718 "Limited Python support is available from the _gdb module.\n"
1719 "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"),
1720 gdb_pythondir);
1721 do_cleanups (cleanup);
1722 return;
1723 }
1724
1725 if (PyModule_AddObject (m, "gdb", gdb_python_module))
1726 goto fail;
1727
1728 /* Keep the reference to gdb_python_module since it is in a global
1729 variable. */
5796c8dc 1730
c50c785c 1731 do_cleanups (cleanup);
ef5ccd6c
JM
1732 return;
1733
1734 fail:
1735 gdbpy_print_stack ();
1736 warning (_("internal error: Unhandled Python exception"));
1737 do_cleanups (cleanup);
c50c785c 1738}
5796c8dc
SS
1739
1740#endif /* HAVE_PYTHON */
5796c8dc
SS
1741
1742\f
1743
c50c785c 1744#ifdef HAVE_PYTHON
5796c8dc
SS
1745
1746static PyMethodDef GdbMethods[] =
1747{
1748 { "history", gdbpy_history, METH_VARARGS,
1749 "Get a value from history" },
cf7f2e2d 1750 { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS,
5796c8dc
SS
1751 "Execute a gdb command" },
1752 { "parameter", gdbpy_parameter, METH_VARARGS,
1753 "Return a gdb parameter's value" },
1754
cf7f2e2d
JM
1755 { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
1756 "Return a tuple of all breakpoint objects" },
1757
5796c8dc
SS
1758 { "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
1759 "Find the default visualizer for a Value." },
1760
cf7f2e2d
JM
1761 { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
1762 "Return the current Progspace." },
1763 { "progspaces", gdbpy_progspaces, METH_NOARGS,
1764 "Return a sequence of all progspaces." },
1765
5796c8dc
SS
1766 { "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
1767 "Return the current Objfile being loaded, or None." },
1768 { "objfiles", gdbpy_objfiles, METH_NOARGS,
1769 "Return a sequence of all loaded objfiles." },
1770
c50c785c
JM
1771 { "newest_frame", gdbpy_newest_frame, METH_NOARGS,
1772 "newest_frame () -> gdb.Frame.\n\
1773Return the newest frame object." },
5796c8dc
SS
1774 { "selected_frame", gdbpy_selected_frame, METH_NOARGS,
1775 "selected_frame () -> gdb.Frame.\n\
1776Return the selected frame object." },
1777 { "frame_stop_reason_string", gdbpy_frame_stop_reason_string, METH_VARARGS,
1778 "stop_reason_string (Integer) -> String.\n\
1779Return a string explaining unwind stop reason." },
1780
1781 { "lookup_type", (PyCFunction) gdbpy_lookup_type,
1782 METH_VARARGS | METH_KEYWORDS,
1783 "lookup_type (name [, block]) -> type\n\
1784Return a Type corresponding to the given name." },
cf7f2e2d
JM
1785 { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
1786 METH_VARARGS | METH_KEYWORDS,
1787 "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
1788Return a tuple with the symbol corresponding to the given name (or None) and\n\
1789a boolean indicating if name is a field of the current implied argument\n\
1790`this' (when the current language is object-oriented)." },
c50c785c
JM
1791 { "lookup_global_symbol", (PyCFunction) gdbpy_lookup_global_symbol,
1792 METH_VARARGS | METH_KEYWORDS,
1793 "lookup_global_symbol (name [, domain]) -> symbol\n\
1794Return the symbol corresponding to the given name (or None)." },
cf7f2e2d
JM
1795 { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
1796 "Return the block containing the given pc value, or None." },
c50c785c
JM
1797 { "solib_name", gdbpy_solib_name, METH_VARARGS,
1798 "solib_name (Long) -> String.\n\
1799Return the name of the shared library holding a given address, or None." },
1800 { "decode_line", gdbpy_decode_line, METH_VARARGS,
1801 "decode_line (String) -> Tuple. Decode a string argument the way\n\
1802that 'break' or 'edit' does. Return a tuple containing two elements.\n\
1803The first element contains any unparsed portion of the String parameter\n\
1804(or None if the string was fully parsed). The second element contains\n\
1805a tuple that contains all the locations that match, represented as\n\
1806gdb.Symtab_and_line objects (or None)."},
cf7f2e2d
JM
1807 { "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
1808 "parse_and_eval (String) -> Value.\n\
1809Parse String as an expression, evaluate it, and return the result as a Value."
1810 },
ef5ccd6c
JM
1811 { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS,
1812 "find_pc_line (pc) -> Symtab_and_line.\n\
1813Return the gdb.Symtab_and_line object corresponding to the pc value." },
cf7f2e2d 1814
c50c785c
JM
1815 { "post_event", gdbpy_post_event, METH_VARARGS,
1816 "Post an event into gdb's event loop." },
1817
cf7f2e2d
JM
1818 { "target_charset", gdbpy_target_charset, METH_NOARGS,
1819 "target_charset () -> string.\n\
1820Return the name of the current target charset." },
1821 { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
1822 "target_wide_charset () -> string.\n\
1823Return the name of the current target wide charset." },
1824
1825 { "string_to_argv", gdbpy_string_to_argv, METH_VARARGS,
1826 "string_to_argv (String) -> Array.\n\
1827Parse String and return an argv-like array.\n\
1828Arguments are separate by spaces and may be quoted."
1829 },
c50c785c 1830 { "write", (PyCFunction)gdbpy_write, METH_VARARGS | METH_KEYWORDS,
5796c8dc 1831 "Write a string using gdb's filtered stream." },
c50c785c 1832 { "flush", (PyCFunction)gdbpy_flush, METH_VARARGS | METH_KEYWORDS,
5796c8dc 1833 "Flush gdb's filtered stdout stream." },
cf7f2e2d
JM
1834 { "selected_thread", gdbpy_selected_thread, METH_NOARGS,
1835 "selected_thread () -> gdb.InferiorThread.\n\
1836Return the selected thread object." },
a45ae5f8
JM
1837 { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS,
1838 "selected_inferior () -> gdb.Inferior.\n\
1839Return the selected inferior object." },
cf7f2e2d
JM
1840 { "inferiors", gdbpy_inferiors, METH_NOARGS,
1841 "inferiors () -> (gdb.Inferior, ...).\n\
1842Return a tuple containing all inferiors." },
5796c8dc
SS
1843 {NULL, NULL, 0, NULL}
1844};
1845
ef5ccd6c
JM
1846#ifdef IS_PY3K
1847static struct PyModuleDef GdbModuleDef =
1848{
1849 PyModuleDef_HEAD_INIT,
1850 "_gdb",
1851 NULL,
1852 -1,
1853 GdbMethods,
1854 NULL,
1855 NULL,
1856 NULL,
1857 NULL
1858};
1859#endif
5796c8dc 1860#endif /* HAVE_PYTHON */