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