X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fpython%2Fpython.c;h=9854c79c103aa9fb2cab2516f67f8e57440e1e62;hb=e36122e9;hp=0f702a239de767ad7b7fe930f196c27938560e4a;hpb=ab821bc6473fe7fa3982d77a837cd5913a35d6f2;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/python/python.c b/gdb/python/python.c index 0f702a239d..9854c79c10 100644 --- a/gdb/python/python.c +++ b/gdb/python/python.c @@ -1,6 +1,6 @@ /* General python/gdb code - Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 2008-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -27,20 +27,64 @@ #include "objfiles.h" #include "value.h" #include "language.h" -#include "exceptions.h" #include "event-loop.h" #include "serial.h" +#include "readline/tilde.h" #include "python.h" - +#include "extension-priv.h" +#include "cli/cli-utils.h" #include -/* True if we should print the stack when catching a Python error, - false otherwise. */ -static int gdbpy_should_print_stack = 0; +/* Declared constants and enum for python stack printing. */ +static const char python_excp_none[] = "none"; +static const char python_excp_full[] = "full"; +static const char python_excp_message[] = "message"; + +/* "set python print-stack" choices. */ +static const char *const python_excp_enums[] = + { + python_excp_none, + python_excp_full, + python_excp_message, + NULL + }; + +/* The exception printing variable. 'full' if we want to print the + error message and stack, 'none' if we want to print nothing, and + 'message' if we only want to print the error message. 'message' is + the default. */ +static const char *gdbpy_should_print_stack = python_excp_message; +#ifdef HAVE_PYTHON +/* Forward decls, these are defined later. */ +extern const struct extension_language_script_ops python_extension_script_ops; +extern const struct extension_language_ops python_extension_ops; +#endif + +/* The main struct describing GDB's interface to the Python + extension language. */ +const struct extension_language_defn extension_language_python = +{ + EXT_LANG_PYTHON, + "python", + "Python", + + ".py", + "-gdb.py", + + python_control, + +#ifdef HAVE_PYTHON + &python_extension_script_ops, + &python_extension_ops +#else + NULL, + NULL +#endif +}; + #ifdef HAVE_PYTHON -#include "libiberty.h" #include "cli/cli-decode.h" #include "charset.h" #include "top.h" @@ -51,12 +95,22 @@ static int gdbpy_should_print_stack = 0; #include "version.h" #include "target.h" #include "gdbthread.h" -#include "observer.h" #include "interps.h" +#include "event-top.h" + +/* True if Python has been successfully initialized, false + otherwise. */ + +int gdb_python_initialized; static PyMethodDef GdbMethods[]; +#ifdef IS_PY3K +static struct PyModuleDef GdbModuleDef; +#endif + PyObject *gdb_module; +PyObject *gdb_python_module; /* Some string constants we may wish to use. */ PyObject *gdbpy_to_string_cst; @@ -75,6 +129,72 @@ PyObject *gdbpy_gdb_error; /* The `gdb.MemoryError' exception. */ PyObject *gdbpy_gdb_memory_error; +static script_sourcer_func gdbpy_source_script; +static objfile_script_sourcer_func gdbpy_source_objfile_script; +static objfile_script_executor_func gdbpy_execute_objfile_script; +static void gdbpy_finish_initialization + (const struct extension_language_defn *); +static int gdbpy_initialized (const struct extension_language_defn *); +static void gdbpy_eval_from_control_command + (const struct extension_language_defn *, struct command_line *cmd); +static void gdbpy_start_type_printers (const struct extension_language_defn *, + struct ext_lang_type_printers *); +static enum ext_lang_rc gdbpy_apply_type_printers + (const struct extension_language_defn *, + const struct ext_lang_type_printers *, struct type *, char **); +static void gdbpy_free_type_printers (const struct extension_language_defn *, + struct ext_lang_type_printers *); +static void gdbpy_clear_quit_flag (const struct extension_language_defn *); +static void gdbpy_set_quit_flag (const struct extension_language_defn *); +static int gdbpy_check_quit_flag (const struct extension_language_defn *); +static enum ext_lang_rc gdbpy_before_prompt_hook + (const struct extension_language_defn *, const char *current_gdb_prompt); + +/* The interface between gdb proper and loading of python scripts. */ + +const struct extension_language_script_ops python_extension_script_ops = +{ + gdbpy_source_script, + gdbpy_source_objfile_script, + gdbpy_execute_objfile_script, + gdbpy_auto_load_enabled +}; + +/* The interface between gdb proper and python extensions. */ + +const struct extension_language_ops python_extension_ops = +{ + gdbpy_finish_initialization, + gdbpy_initialized, + + gdbpy_eval_from_control_command, + + gdbpy_start_type_printers, + gdbpy_apply_type_printers, + gdbpy_free_type_printers, + + gdbpy_apply_val_pretty_printer, + + gdbpy_apply_frame_filter, + + gdbpy_preserve_values, + + gdbpy_breakpoint_has_cond, + gdbpy_breakpoint_cond_says_stop, + + gdbpy_clear_quit_flag, + gdbpy_set_quit_flag, + gdbpy_check_quit_flag, + + gdbpy_before_prompt_hook, + + gdbpy_clone_xmethod_worker_data, + gdbpy_free_xmethod_worker_data, + gdbpy_get_matching_xmethod_workers, + gdbpy_get_xmethod_arg_types, + gdbpy_invoke_xmethod +}; + /* Architecture and language to be used in callbacks from the Python interpreter. */ struct gdbarch *python_gdbarch; @@ -85,6 +205,7 @@ const struct language_defn *python_language; struct python_env { + struct active_ext_lang_state *previous_active; PyGILState_STATE state; struct gdbarch *gdbarch; const struct language_defn *language; @@ -109,11 +230,17 @@ restore_python_env (void *p) PyGILState_Release (env->state); python_gdbarch = env->gdbarch; python_language = env->language; + + restore_active_ext_lang (env->previous_active); + xfree (env); } /* Called before entering the Python interpreter to install the - current language and architecture to be used for Python values. */ + current language and architecture to be used for Python values. + Also set the active extension language for GDB so that SIGINT's + are directed our way, and if necessary install the right SIGINT + handler. */ struct cleanup * ensure_python_env (struct gdbarch *gdbarch, @@ -121,6 +248,12 @@ ensure_python_env (struct gdbarch *gdbarch, { struct python_env *env = xmalloc (sizeof *env); + /* We should not ever enter Python unless initialized. */ + if (!gdb_python_initialized) + error (_("Python not initialized")); + + env->previous_active = set_active_ext_lang (&extension_language_python); + env->state = PyGILState_Ensure (); env->gdbarch = python_gdbarch; env->language = python_language; @@ -130,10 +263,152 @@ ensure_python_env (struct gdbarch *gdbarch, /* Save it and ensure ! PyErr_Occurred () afterwards. */ PyErr_Fetch (&env->error_type, &env->error_value, &env->error_traceback); - + return make_cleanup (restore_python_env, env); } +/* Clear the quit flag. */ + +static void +gdbpy_clear_quit_flag (const struct extension_language_defn *extlang) +{ + /* This clears the flag as a side effect. */ + PyOS_InterruptOccurred (); +} + +/* Set the quit flag. */ + +static void +gdbpy_set_quit_flag (const struct extension_language_defn *extlang) +{ + PyErr_SetInterrupt (); +} + +/* Return true if the quit flag has been set, false otherwise. */ + +static int +gdbpy_check_quit_flag (const struct extension_language_defn *extlang) +{ + return PyOS_InterruptOccurred (); +} + +/* Evaluate a Python command like PyRun_SimpleString, but uses + Py_single_input which prints the result of expressions, and does + not automatically print the stack on errors. */ + +static int +eval_python_command (const char *command) +{ + PyObject *m, *d, *v; + + m = PyImport_AddModule ("__main__"); + if (m == NULL) + return -1; + + d = PyModule_GetDict (m); + if (d == NULL) + return -1; + v = PyRun_StringFlags (command, Py_single_input, d, d, NULL); + if (v == NULL) + return -1; + + Py_DECREF (v); +#ifndef IS_PY3K + if (Py_FlushLine ()) + PyErr_Clear (); +#endif + + return 0; +} + +/* Implementation of the gdb "python-interactive" command. */ + +static void +python_interactive_command (char *arg, int from_tty) +{ + struct cleanup *cleanup; + int err; + + cleanup = make_cleanup_restore_integer (&interpreter_async); + interpreter_async = 0; + + arg = skip_spaces (arg); + + ensure_python_env (get_current_arch (), current_language); + + if (arg && *arg) + { + int len = strlen (arg); + char *script = xmalloc (len + 2); + + strcpy (script, arg); + script[len] = '\n'; + script[len + 1] = '\0'; + err = eval_python_command (script); + xfree (script); + } + else + { + err = PyRun_InteractiveLoop (instream, ""); + dont_repeat (); + } + + if (err) + { + gdbpy_print_stack (); + error (_("Error while executing Python code.")); + } + + do_cleanups (cleanup); +} + +/* A wrapper around PyRun_SimpleFile. FILE is the Python script to run + named FILENAME. + + On Windows hosts few users would build Python themselves (this is no + trivial task on this platform), and thus use binaries built by + someone else instead. There may happen situation where the Python + library and GDB are using two different versions of the C runtime + library. Python, being built with VC, would use one version of the + msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll. + A FILE * from one runtime does not necessarily operate correctly in + the other runtime. + + To work around this potential issue, we create on Windows hosts the + FILE object using Python routines, thus making sure that it is + compatible with the Python library. */ + +static void +python_run_simple_file (FILE *file, const char *filename) +{ +#ifndef _WIN32 + + PyRun_SimpleFile (file, filename); + +#else /* _WIN32 */ + + char *full_path; + PyObject *python_file; + struct cleanup *cleanup; + + /* Because we have a string for a filename, and are using Python to + open the file, we need to expand any tilde in the path first. */ + full_path = tilde_expand (filename); + cleanup = make_cleanup (xfree, full_path); + python_file = PyFile_FromString (full_path, "r"); + if (! python_file) + { + do_cleanups (cleanup); + gdbpy_print_stack (); + error (_("Error while opening file: %s"), full_path); + } + + make_cleanup_py_decref (python_file); + PyRun_SimpleFile (PyFile_AsFile (python_file), filename); + do_cleanups (cleanup); + +#endif /* _WIN32 */ +} /* Given a command_line, return a command string suitable for passing to Python. Lines in the string are separated by newlines. The @@ -168,8 +443,9 @@ compute_python_string (struct command_line *l) /* Take a command line structure representing a 'python' command, and evaluate its body using the Python interpreter. */ -void -eval_python_from_control_command (struct command_line *cmd) +static void +gdbpy_eval_from_control_command (const struct extension_language_defn *extlang, + struct command_line *cmd) { int ret; char *script; @@ -184,10 +460,7 @@ eval_python_from_control_command (struct command_line *cmd) ret = PyRun_SimpleString (script); xfree (script); if (ret) - { - gdbpy_print_stack (); - error (_("Error while executing Python code.")); - } + error (_("Error while executing Python code.")); do_cleanups (cleanup); } @@ -204,15 +477,11 @@ python_command (char *arg, int from_tty) make_cleanup_restore_integer (&interpreter_async); interpreter_async = 0; - while (arg && *arg && isspace (*arg)) - ++arg; + arg = skip_spaces (arg); if (arg && *arg) { if (PyRun_SimpleString (arg)) - { - gdbpy_print_stack (); - error (_("Error while executing Python code.")); - } + error (_("Error while executing Python code.")); } else { @@ -285,7 +554,7 @@ gdbpy_parameter_value (enum var_types type, void *var) } } - return PyErr_Format (PyExc_RuntimeError, + return PyErr_Format (PyExc_RuntimeError, _("Programmer error: unhandled type.")); } @@ -317,7 +586,7 @@ gdbpy_parameter (PyObject *self, PyObject *args) _("Could not find parameter `%s'."), arg); if (! cmd->var) - return PyErr_Format (PyExc_RuntimeError, + return PyErr_Format (PyExc_RuntimeError, _("`%s' is not a parameter."), arg); return gdbpy_parameter_value (cmd->var_type, cmd->var); } @@ -445,7 +714,7 @@ gdbpy_decode_line (PyObject *self, PyObject *args) appease gcc. */ struct symtab_and_line sal; const char *arg = NULL; - char *copy = NULL; + char *copy_to_free = NULL, *copy = NULL; struct cleanup *cleanups; PyObject *result = NULL; PyObject *return_result = NULL; @@ -455,16 +724,16 @@ gdbpy_decode_line (PyObject *self, PyObject *args) if (! PyArg_ParseTuple (args, "|s", &arg)) return NULL; - cleanups = ensure_python_env (get_current_arch (), current_language); + cleanups = make_cleanup (null_cleanup, NULL); + sals.sals = NULL; TRY_CATCH (except, RETURN_MASK_ALL) { if (arg) { copy = xstrdup (arg); - make_cleanup (xfree, copy); - sals = decode_line_1 (©, 0, 0, 0, 0); - make_cleanup (xfree, sals.sals); + copy_to_free = copy; + sals = decode_line_1 (©, 0, 0, 0); } else { @@ -474,11 +743,19 @@ gdbpy_decode_line (PyObject *self, PyObject *args) sals.nelts = 1; } } + + if (sals.sals != NULL && sals.sals != &sal) + { + make_cleanup (xfree, copy_to_free); + make_cleanup (xfree, sals.sals); + } + if (except.reason < 0) { do_cleanups (cleanups); /* We know this will always throw. */ - GDB_PY_HANDLE_EXCEPTION (except); + gdbpy_convert_exception (except); + return NULL; } if (sals.nelts) @@ -491,7 +768,6 @@ gdbpy_decode_line (PyObject *self, PyObject *args) for (i = 0; i < sals.nelts; ++i) { PyObject *obj; - char *str; obj = symtab_and_line_to_sal_object (sals.sals[i]); if (! obj) @@ -517,7 +793,16 @@ gdbpy_decode_line (PyObject *self, PyObject *args) } if (copy && strlen (copy) > 0) - unparsed = PyString_FromString (copy); + { + unparsed = PyString_FromString (copy); + if (unparsed == NULL) + { + Py_DECREF (result); + Py_DECREF (return_result); + return_result = NULL; + goto error; + } + } else { unparsed = Py_None; @@ -527,13 +812,10 @@ gdbpy_decode_line (PyObject *self, PyObject *args) PyTuple_SetItem (return_result, 0, unparsed); PyTuple_SetItem (return_result, 1, result); + error: do_cleanups (cleanups); return return_result; - - error: - do_cleanups (cleanups); - return NULL; } /* Parse a string and evaluate it as an expression. */ @@ -549,32 +831,54 @@ gdbpy_parse_and_eval (PyObject *self, PyObject *args) TRY_CATCH (except, RETURN_MASK_ALL) { - char *copy = xstrdup (expr_str); - struct cleanup *cleanup = make_cleanup (xfree, copy); - - result = parse_and_eval (copy); - do_cleanups (cleanup); + result = parse_and_eval (expr_str); } GDB_PY_HANDLE_EXCEPTION (except); return value_to_value_object (result); } -/* Read a file as Python code. STREAM is the input file; FILE is the - name of the file. - STREAM is not closed, that is the caller's responsibility. */ +/* Implementation of gdb.find_pc_line function. + Returns the gdb.Symtab_and_line object corresponding to a PC value. */ -void -source_python_script (FILE *stream, const char *file) +static PyObject * +gdbpy_find_pc_line (PyObject *self, PyObject *args) { - struct cleanup *cleanup; + gdb_py_ulongest pc_llu; + volatile struct gdb_exception except; + PyObject *result = NULL; /* init for gcc -Wall */ - cleanup = ensure_python_env (get_current_arch (), current_language); + if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc_llu)) + return NULL; - /* Note: If an exception occurs python will print the traceback and - clear the error indicator. */ - PyRun_SimpleFile (stream, file); + TRY_CATCH (except, RETURN_MASK_ALL) + { + struct symtab_and_line sal; + CORE_ADDR pc; + pc = (CORE_ADDR) pc_llu; + sal = find_pc_line (pc, 0); + result = symtab_and_line_to_sal_object (sal); + } + GDB_PY_HANDLE_EXCEPTION (except); + + return result; +} + +/* Read a file as Python code. + This is the extension_language_script_ops.script_sourcer "method". + FILE is the file to load. FILENAME is name of the file FILE. + This does not throw any errors. If an exception occurs python will print + the traceback and clear the error indicator. */ + +static void +gdbpy_source_script (const struct extension_language_defn *extlang, + FILE *file, const char *filename) +{ + struct cleanup *cleanup; + + cleanup = ensure_python_env (get_current_arch (), current_language); + python_run_simple_file (file, filename); do_cleanups (cleanup); } @@ -608,7 +912,6 @@ static void gdbpy_run_events (struct serial *scb, void *context) { struct cleanup *cleanup; - int r; cleanup = ensure_python_env (get_current_arch (), current_language); @@ -620,6 +923,8 @@ gdbpy_run_events (struct serial *scb, void *context) while (gdbpy_event_list) { + PyObject *call_result; + /* Dispatching the event might push a new element onto the event loop, so we update here "atomically enough". */ struct gdbpy_event *item = gdbpy_event_list; @@ -628,9 +933,11 @@ gdbpy_run_events (struct serial *scb, void *context) gdbpy_event_list_end = &gdbpy_event_list; /* Ignore errors. */ - if (PyObject_CallObject (item->event, NULL) == NULL) + call_result = PyObject_CallObject (item->event, NULL); + if (call_result == NULL) PyErr_Clear (); + Py_XDECREF (call_result); Py_DECREF (item->event); xfree (item); } @@ -651,7 +958,7 @@ gdbpy_post_event (PyObject *self, PyObject *args) if (!PyCallable_Check (func)) { - PyErr_SetString (PyExc_RuntimeError, + PyErr_SetString (PyExc_RuntimeError, _("Posted event is not callable")); return NULL; } @@ -681,7 +988,7 @@ gdbpy_post_event (PyObject *self, PyObject *args) } /* Initialize the Python event handler. */ -static void +static int gdbpy_initialize_events (void) { if (serial_pipe (gdbpy_event_fds) == 0) @@ -689,26 +996,37 @@ gdbpy_initialize_events (void) gdbpy_event_list_end = &gdbpy_event_list; serial_async (gdbpy_event_fds[0], gdbpy_run_events, NULL); } + + return 0; } -static void -before_prompt_hook (const char *current_gdb_prompt) +/* This is the extension_language_ops.before_prompt "method". */ + +static enum ext_lang_rc +gdbpy_before_prompt_hook (const struct extension_language_defn *extlang, + const char *current_gdb_prompt) { struct cleanup *cleanup; char *prompt = NULL; + if (!gdb_python_initialized) + return EXT_LANG_RC_NOP; + cleanup = ensure_python_env (get_current_arch (), current_language); - if (PyObject_HasAttrString (gdb_module, "prompt_hook")) + if (gdb_python_module + && PyObject_HasAttrString (gdb_python_module, "prompt_hook")) { PyObject *hook; - hook = PyObject_GetAttrString (gdb_module, "prompt_hook"); + hook = PyObject_GetAttrString (gdb_python_module, "prompt_hook"); if (hook == NULL) goto fail; + make_cleanup_py_decref (hook); + if (PyCallable_Check (hook)) { PyObject *result; @@ -756,12 +1074,12 @@ before_prompt_hook (const char *current_gdb_prompt) set_prompt (prompt); do_cleanups (cleanup); - return; + return prompt != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_NOP; fail: gdbpy_print_stack (); do_cleanups (cleanup); - return; + return EXT_LANG_RC_ERROR; } @@ -778,27 +1096,32 @@ gdbpy_write (PyObject *self, PyObject *args, PyObject *kw) const char *arg; static char *keywords[] = {"text", "stream", NULL }; int stream_type = 0; - + volatile struct gdb_exception except; + if (! PyArg_ParseTupleAndKeywords (args, kw, "s|i", keywords, &arg, &stream_type)) return NULL; - switch (stream_type) + TRY_CATCH (except, RETURN_MASK_ALL) { - case 1: - { - fprintf_filtered (gdb_stderr, "%s", arg); - break; - } - case 2: - { - fprintf_filtered (gdb_stdlog, "%s", arg); - break; - } - default: - fprintf_filtered (gdb_stdout, "%s", arg); + switch (stream_type) + { + case 1: + { + fprintf_filtered (gdb_stderr, "%s", arg); + break; + } + case 2: + { + fprintf_filtered (gdb_stdlog, "%s", arg); + break; + } + default: + fprintf_filtered (gdb_stdout, "%s", arg); + } } - + GDB_PY_HANDLE_EXCEPTION (except); + Py_RETURN_NONE; } @@ -811,7 +1134,7 @@ gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw) { static char *keywords[] = {"stream", NULL }; int stream_type = 0; - + if (! PyArg_ParseTupleAndKeywords (args, kw, "|i", keywords, &stream_type)) return NULL; @@ -831,26 +1154,68 @@ gdbpy_flush (PyObject *self, PyObject *args, PyObject *kw) default: gdb_flush (gdb_stdout); } - + Py_RETURN_NONE; } -/* Print a python exception trace, or print nothing and clear the - python exception, depending on gdbpy_should_print_stack. Only call - this if a python exception is set. */ +/* Print a python exception trace, print just a message, or print + nothing and clear the python exception, depending on + gdbpy_should_print_stack. Only call this if a python exception is + set. */ void gdbpy_print_stack (void) { - if (gdbpy_should_print_stack) + volatile struct gdb_exception except; + + /* Print "none", just clear exception. */ + if (gdbpy_should_print_stack == python_excp_none) + { + PyErr_Clear (); + } + /* Print "full" message and backtrace. */ + else if (gdbpy_should_print_stack == python_excp_full) { PyErr_Print (); /* PyErr_Print doesn't necessarily end output with a newline. This works because Python's stdout/stderr is fed through printf_filtered. */ - begin_line (); + TRY_CATCH (except, RETURN_MASK_ALL) + { + begin_line (); + } } + /* Print "message", just error print message. */ else - PyErr_Clear (); + { + PyObject *ptype, *pvalue, *ptraceback; + char *msg = NULL, *type = NULL; + + PyErr_Fetch (&ptype, &pvalue, &ptraceback); + + /* Fetch the error message contained within ptype, pvalue. */ + msg = gdbpy_exception_to_string (ptype, pvalue); + type = gdbpy_obj_to_string (ptype); + + TRY_CATCH (except, RETURN_MASK_ALL) + { + if (msg == NULL) + { + /* An error occurred computing the string representation of the + error message. */ + fprintf_filtered (gdb_stderr, + _("Error occurred computing Python error" \ + "message.\n")); + } + else + fprintf_filtered (gdb_stderr, "Python Exception %s %s: \n", + type, msg); + } + + Py_XDECREF (ptype); + Py_XDECREF (pvalue); + Py_XDECREF (ptraceback); + xfree (msg); + } } @@ -899,24 +1264,55 @@ gdbpy_progspaces (PyObject *unused1, PyObject *unused2) /* The "current" objfile. This is set when gdb detects that a new objfile has been loaded. It is only set for the duration of a call to - source_python_script_for_objfile; it is NULL at other times. */ + gdbpy_source_objfile_script and gdbpy_execute_objfile_script; it is NULL + at other times. */ static struct objfile *gdbpy_current_objfile; -/* Set the current objfile to OBJFILE and then read STREAM,FILE as - Python code. */ +/* Set the current objfile to OBJFILE and then read FILE named FILENAME + as Python code. This does not throw any errors. If an exception + occurs python will print the traceback and clear the error indicator. + This is the extension_language_script_ops.objfile_script_sourcer + "method". */ -void -source_python_script_for_objfile (struct objfile *objfile, - FILE *stream, const char *file) +static void +gdbpy_source_objfile_script (const struct extension_language_defn *extlang, + struct objfile *objfile, FILE *file, + const char *filename) { struct cleanup *cleanups; + if (!gdb_python_initialized) + return; + cleanups = ensure_python_env (get_objfile_arch (objfile), current_language); gdbpy_current_objfile = objfile; - /* Note: If an exception occurs python will print the traceback and - clear the error indicator. */ - PyRun_SimpleFile (stream, file); + python_run_simple_file (file, filename); + + do_cleanups (cleanups); + gdbpy_current_objfile = NULL; +} + +/* Set the current objfile to OBJFILE and then execute SCRIPT + as Python code. This does not throw any errors. If an exception + occurs python will print the traceback and clear the error indicator. + This is the extension_language_script_ops.objfile_script_executor + "method". */ + +static void +gdbpy_execute_objfile_script (const struct extension_language_defn *extlang, + struct objfile *objfile, const char *name, + const char *script) +{ + struct cleanup *cleanups; + + if (!gdb_python_initialized) + return; + + cleanups = ensure_python_env (get_objfile_arch (objfile), current_language); + gdbpy_current_objfile = objfile; + + PyRun_SimpleString (script); do_cleanups (cleanups); gdbpy_current_objfile = NULL; @@ -964,87 +1360,179 @@ gdbpy_objfiles (PyObject *unused1, PyObject *unused2) return list; } -#else /* HAVE_PYTHON */ - -/* Dummy implementation of the gdb "python" command. */ +/* Compute the list of active python type printers and store them in + EXT_PRINTERS->py_type_printers. The product of this function is used by + gdbpy_apply_type_printers, and freed by gdbpy_free_type_printers. + This is the extension_language_ops.start_type_printers "method". */ static void -python_command (char *arg, int from_tty) +gdbpy_start_type_printers (const struct extension_language_defn *extlang, + struct ext_lang_type_printers *ext_printers) { - while (arg && *arg && isspace (*arg)) - ++arg; - if (arg && *arg) - error (_("Python scripting is not supported in this copy of GDB.")); - else + struct cleanup *cleanups; + PyObject *type_module, *func = NULL, *printers_obj = NULL; + + if (!gdb_python_initialized) + return; + + cleanups = ensure_python_env (get_current_arch (), current_language); + + type_module = PyImport_ImportModule ("gdb.types"); + if (type_module == NULL) { - struct command_line *l = get_command_line (python_control, ""); - struct cleanup *cleanups = make_cleanup_free_command_lines (&l); + gdbpy_print_stack (); + goto done; + } - execute_control_command_untraced (l); - do_cleanups (cleanups); + func = PyObject_GetAttrString (type_module, "get_type_recognizers"); + if (func == NULL) + { + gdbpy_print_stack (); + goto done; } -} -void -eval_python_from_control_command (struct command_line *cmd) -{ - error (_("Python scripting is not supported in this copy of GDB.")); -} + printers_obj = PyObject_CallFunctionObjArgs (func, (char *) NULL); + if (printers_obj == NULL) + gdbpy_print_stack (); + else + ext_printers->py_type_printers = printers_obj; -void -source_python_script (FILE *stream, const char *file) -{ - throw_error (UNSUPPORTED_ERROR, - _("Python scripting is not supported in this copy of GDB.")); + done: + Py_XDECREF (type_module); + Py_XDECREF (func); + do_cleanups (cleanups); } -int -gdbpy_should_stop (struct breakpoint_object *bp_obj) +/* If TYPE is recognized by some type printer, store in *PRETTIED_TYPE + a newly allocated string holding the type's replacement name, and return + EXT_LANG_RC_OK. The caller is responsible for freeing the string. + If there's a Python error return EXT_LANG_RC_ERROR. + Otherwise, return EXT_LANG_RC_NOP. + This is the extension_language_ops.apply_type_printers "method". */ + +static enum ext_lang_rc +gdbpy_apply_type_printers (const struct extension_language_defn *extlang, + const struct ext_lang_type_printers *ext_printers, + struct type *type, char **prettied_type) { - internal_error (__FILE__, __LINE__, - _("gdbpy_should_stop called when Python scripting is " \ - "not supported.")); -} + struct cleanup *cleanups; + PyObject *type_obj, *type_module = NULL, *func = NULL; + PyObject *result_obj = NULL; + PyObject *printers_obj = ext_printers->py_type_printers; + char *result = NULL; -int -gdbpy_breakpoint_has_py_cond (struct breakpoint_object *bp_obj) -{ - internal_error (__FILE__, __LINE__, - _("gdbpy_breakpoint_has_py_cond called when Python " \ - "scripting is not supported.")); -} + if (printers_obj == NULL) + return EXT_LANG_RC_NOP; -#endif /* HAVE_PYTHON */ + if (!gdb_python_initialized) + return EXT_LANG_RC_NOP; - + cleanups = ensure_python_env (get_current_arch (), current_language); -/* Lists for 'maint set python' commands. */ + type_obj = type_to_type_object (type); + if (type_obj == NULL) + { + gdbpy_print_stack (); + goto done; + } -static struct cmd_list_element *maint_set_python_list; -static struct cmd_list_element *maint_show_python_list; + type_module = PyImport_ImportModule ("gdb.types"); + if (type_module == NULL) + { + gdbpy_print_stack (); + goto done; + } -/* Lists for 'set python' commands. */ + func = PyObject_GetAttrString (type_module, "apply_type_recognizers"); + if (func == NULL) + { + gdbpy_print_stack (); + goto done; + } -static struct cmd_list_element *user_set_python_list; -static struct cmd_list_element *user_show_python_list; + result_obj = PyObject_CallFunctionObjArgs (func, printers_obj, + type_obj, (char *) NULL); + if (result_obj == NULL) + { + gdbpy_print_stack (); + goto done; + } -/* Function for use by 'maint set python' prefix command. */ + if (result_obj != Py_None) + { + result = python_string_to_host_string (result_obj); + if (result == NULL) + gdbpy_print_stack (); + } + + done: + Py_XDECREF (type_obj); + Py_XDECREF (type_module); + Py_XDECREF (func); + Py_XDECREF (result_obj); + do_cleanups (cleanups); + if (result != NULL) + *prettied_type = result; + return result != NULL ? EXT_LANG_RC_OK : EXT_LANG_RC_ERROR; +} + +/* Free the result of start_type_printers. + This is the extension_language_ops.free_type_printers "method". */ static void -maint_set_python (char *args, int from_tty) +gdbpy_free_type_printers (const struct extension_language_defn *extlang, + struct ext_lang_type_printers *ext_printers) { - help_list (maint_set_python_list, "maintenance set python ", - class_deprecated, gdb_stdout); + struct cleanup *cleanups; + PyObject *printers = ext_printers->py_type_printers; + + if (printers == NULL) + return; + + if (!gdb_python_initialized) + return; + + cleanups = ensure_python_env (get_current_arch (), current_language); + Py_DECREF (printers); + do_cleanups (cleanups); } -/* Function for use by 'maint show python' prefix command. */ +#else /* HAVE_PYTHON */ + +/* Dummy implementation of the gdb "python-interactive" and "python" + command. */ static void -maint_show_python (char *args, int from_tty) +python_interactive_command (char *arg, int from_tty) { - cmd_show_list (maint_show_python_list, from_tty, ""); + arg = skip_spaces (arg); + if (arg && *arg) + error (_("Python scripting is not supported in this copy of GDB.")); + else + { + struct command_line *l = get_command_line (python_control, ""); + struct cleanup *cleanups = make_cleanup_free_command_lines (&l); + + execute_control_command_untraced (l); + do_cleanups (cleanups); + } +} + +static void +python_command (char *arg, int from_tty) +{ + python_interactive_command (arg, from_tty); } +#endif /* HAVE_PYTHON */ + + + +/* Lists for 'set python' commands. */ + +static struct cmd_list_element *user_set_python_list; +static struct cmd_list_element *user_show_python_list; + /* Function for use by 'set python' prefix command. */ static void @@ -1064,14 +1552,75 @@ user_show_python (char *args, int from_tty) /* Initialize the Python code. */ +#ifdef HAVE_PYTHON + +/* This is installed as a final cleanup and cleans up the + interpreter. This lets Python's 'atexit' work. */ + +static void +finalize_python (void *ignore) +{ + struct active_ext_lang_state *previous_active; + + /* We don't use ensure_python_env here because if we ever ran the + cleanup, gdb would crash -- because the cleanup calls into the + Python interpreter, which we are about to destroy. It seems + clearer to make the needed calls explicitly here than to create a + cleanup and then mysteriously discard it. */ + + /* This is only called as a final cleanup so we can assume the active + SIGINT handler is gdb's. We still need to tell it to notify Python. */ + previous_active = set_active_ext_lang (&extension_language_python); + + (void) PyGILState_Ensure (); + python_gdbarch = target_gdbarch (); + python_language = current_language; + + Py_Finalize (); + + restore_active_ext_lang (previous_active); +} +#endif + /* Provide a prototype to silence -Wmissing-prototypes. */ extern initialize_file_ftype _initialize_python; void _initialize_python (void) { - char *cmd_name; - struct cmd_list_element *cmd; + char *progname; +#ifdef IS_PY3K + int i; + size_t progsize, count; + char *oldloc; + wchar_t *progname_copy; +#endif + + add_com ("python-interactive", class_obscure, + python_interactive_command, +#ifdef HAVE_PYTHON + _("\ +Start an interactive Python prompt.\n\ +\n\ +To return to GDB, type the EOF character (e.g., Ctrl-D on an empty\n\ +prompt).\n\ +\n\ +Alternatively, a single-line Python command can be given as an\n\ +argument, and if the command is an expression, the result will be\n\ +printed. For example:\n\ +\n\ + (gdb) python-interactive 2 + 3\n\ + 5\n\ +") +#else /* HAVE_PYTHON */ + _("\ +Start a Python interactive prompt.\n\ +\n\ +Python scripting is not supported in this copy of GDB.\n\ +This command is only a placeholder.") +#endif /* HAVE_PYTHON */ + ); + add_com_alias ("pi", "python-interactive", class_obscure, 1); add_com ("python", class_obscure, python_command, #ifdef HAVE_PYTHON @@ -1093,33 +1642,7 @@ Python scripting is not supported in this copy of GDB.\n\ This command is only a placeholder.") #endif /* HAVE_PYTHON */ ); - - add_prefix_cmd ("python", no_class, maint_show_python, - _("Prefix command for python maintenance settings."), - &maint_show_python_list, "maintenance show python ", 0, - &maintenance_show_cmdlist); - add_prefix_cmd ("python", no_class, maint_set_python, - _("Prefix command for python maintenance settings."), - &maint_set_python_list, "maintenance set python ", 0, - &maintenance_set_cmdlist); - - add_setshow_boolean_cmd ("print-stack", class_maintenance, - &gdbpy_should_print_stack, _("\ -Enable or disable printing of Python stack dump on error."), _("\ -Show whether Python stack will be printed on error."), _("\ -Enables or disables printing of Python stack traces."), - NULL, NULL, - &maint_set_python_list, - &maint_show_python_list); - - /* Deprecate maint set/show python print-stack in favour of - non-maintenance alternatives. */ - cmd_name = "print-stack"; - cmd = lookup_cmd (&cmd_name, maint_set_python_list, "", -1, 0); - deprecate_cmd (cmd, "set python print-stack"); - cmd_name = "print-stack"; /* Reset name. */ - cmd = lookup_cmd (&cmd_name, maint_show_python_list, "", -1, 0); - deprecate_cmd (cmd, "show python print-stack"); + add_com_alias ("py", "python", class_obscure, 1); /* Add set/show python print-stack. */ add_prefix_cmd ("python", no_class, user_show_python, @@ -1132,14 +1655,16 @@ Enables or disables printing of Python stack traces."), &user_set_python_list, "set python ", 0, &setlist); - add_setshow_boolean_cmd ("print-stack", no_class, - &gdbpy_should_print_stack, _("\ -Enable or disable printing of Python stack dump on error."), _("\ -Show whether Python stack will be printed on error."), _("\ -Enables or disables printing of Python stack traces."), - NULL, NULL, - &user_set_python_list, - &user_show_python_list); + add_setshow_enum_cmd ("print-stack", no_class, python_excp_enums, + &gdbpy_should_print_stack, _("\ +Set mode for Python stack dump on error."), _("\ +Show the mode of Python stack printing on error."), _("\ +none == no stack or message will be printed.\n\ +full == a message and a stack will be printed.\n\ +message == an error message without a stack will be printed."), + NULL, NULL, + &user_set_python_list, + &user_show_python_list); #ifdef HAVE_PYTHON #ifdef WITH_PYTHON_PATH @@ -1149,91 +1674,158 @@ Enables or disables printing of Python stack traces."), /foo/bin/python /foo/lib/pythonX.Y/... This must be done before calling Py_Initialize. */ - Py_SetProgramName (concat (ldirname (python_libdir), SLASH_STRING, "bin", - SLASH_STRING, "python", NULL)); + progname = concat (ldirname (python_libdir), SLASH_STRING, "bin", + SLASH_STRING, "python", NULL); +#ifdef IS_PY3K + oldloc = setlocale (LC_ALL, NULL); + setlocale (LC_ALL, ""); + progsize = strlen (progname); + if (progsize == (size_t) -1) + { + fprintf (stderr, "Could not convert python path to string\n"); + return; + } + progname_copy = PyMem_Malloc ((progsize + 1) * sizeof (wchar_t)); + if (!progname_copy) + { + fprintf (stderr, "out of memory\n"); + return; + } + count = mbstowcs (progname_copy, progname, progsize + 1); + if (count == (size_t) -1) + { + fprintf (stderr, "Could not convert python path to string\n"); + return; + } + setlocale (LC_ALL, oldloc); + + /* Note that Py_SetProgramName expects the string it is passed to + remain alive for the duration of the program's execution, so + it is not freed after this call. */ + Py_SetProgramName (progname_copy); +#else + Py_SetProgramName (progname); +#endif #endif Py_Initialize (); PyEval_InitThreads (); - gdb_module = Py_InitModule ("gdb", GdbMethods); +#ifdef IS_PY3K + gdb_module = PyModule_Create (&GdbModuleDef); + /* Add _gdb module to the list of known built-in modules. */ + _PyImport_FixupBuiltin (gdb_module, "_gdb"); +#else + gdb_module = Py_InitModule ("_gdb", GdbMethods); +#endif + if (gdb_module == NULL) + goto fail; /* The casts to (char*) are for python 2.4. */ - PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version); - PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", (char*) host_name); - PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", - (char*) target_name); + if (PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version) < 0 + || PyModule_AddStringConstant (gdb_module, "HOST_CONFIG", + (char*) host_name) < 0 + || PyModule_AddStringConstant (gdb_module, "TARGET_CONFIG", + (char*) target_name) < 0) + goto fail; /* Add stream constants. */ - PyModule_AddIntConstant (gdb_module, "STDOUT", 0); - PyModule_AddIntConstant (gdb_module, "STDERR", 1); - PyModule_AddIntConstant (gdb_module, "STDLOG", 2); - - /* gdb.parameter ("data-directory") doesn't necessarily exist when the python - script below is run (depending on order of _initialize_* functions). - Define the initial value of gdb.PYTHONDIR here. */ - { - char *gdb_pythondir; - - gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL); - PyModule_AddStringConstant (gdb_module, "PYTHONDIR", gdb_pythondir); - xfree (gdb_pythondir); - } + if (PyModule_AddIntConstant (gdb_module, "STDOUT", 0) < 0 + || PyModule_AddIntConstant (gdb_module, "STDERR", 1) < 0 + || PyModule_AddIntConstant (gdb_module, "STDLOG", 2) < 0) + goto fail; gdbpy_gdb_error = PyErr_NewException ("gdb.error", PyExc_RuntimeError, NULL); - PyModule_AddObject (gdb_module, "error", gdbpy_gdb_error); + if (gdbpy_gdb_error == NULL + || gdb_pymodule_addobject (gdb_module, "error", gdbpy_gdb_error) < 0) + goto fail; gdbpy_gdb_memory_error = PyErr_NewException ("gdb.MemoryError", gdbpy_gdb_error, NULL); - PyModule_AddObject (gdb_module, "MemoryError", gdbpy_gdb_memory_error); + if (gdbpy_gdb_memory_error == NULL + || gdb_pymodule_addobject (gdb_module, "MemoryError", + gdbpy_gdb_memory_error) < 0) + goto fail; gdbpy_gdberror_exc = PyErr_NewException ("gdb.GdbError", NULL, NULL); - PyModule_AddObject (gdb_module, "GdbError", gdbpy_gdberror_exc); - - gdbpy_initialize_auto_load (); - gdbpy_initialize_values (); - gdbpy_initialize_frames (); - gdbpy_initialize_commands (); - gdbpy_initialize_symbols (); - gdbpy_initialize_symtabs (); - gdbpy_initialize_blocks (); - gdbpy_initialize_functions (); - gdbpy_initialize_parameters (); - gdbpy_initialize_types (); - gdbpy_initialize_pspace (); - gdbpy_initialize_objfile (); - gdbpy_initialize_breakpoints (); - gdbpy_initialize_lazy_string (); - gdbpy_initialize_thread (); - gdbpy_initialize_inferior (); - gdbpy_initialize_events (); - - gdbpy_initialize_eventregistry (); - gdbpy_initialize_py_events (); - gdbpy_initialize_event (); - gdbpy_initialize_stop_event (); - gdbpy_initialize_signal_event (); - gdbpy_initialize_breakpoint_event (); - gdbpy_initialize_continue_event (); - gdbpy_initialize_exited_event (); - gdbpy_initialize_thread_event (); - - observer_attach_before_prompt (before_prompt_hook); - - PyRun_SimpleString ("import gdb"); - PyRun_SimpleString ("gdb.pretty_printers = []"); + if (gdbpy_gdberror_exc == NULL + || gdb_pymodule_addobject (gdb_module, "GdbError", + gdbpy_gdberror_exc) < 0) + goto fail; + + gdbpy_initialize_gdb_readline (); + + if (gdbpy_initialize_auto_load () < 0 + || gdbpy_initialize_values () < 0 + || gdbpy_initialize_frames () < 0 + || gdbpy_initialize_commands () < 0 + || gdbpy_initialize_symbols () < 0 + || gdbpy_initialize_symtabs () < 0 + || gdbpy_initialize_blocks () < 0 + || gdbpy_initialize_functions () < 0 + || gdbpy_initialize_parameters () < 0 + || gdbpy_initialize_types () < 0 + || gdbpy_initialize_pspace () < 0 + || gdbpy_initialize_objfile () < 0 + || gdbpy_initialize_breakpoints () < 0 + || gdbpy_initialize_finishbreakpoints () < 0 + || gdbpy_initialize_lazy_string () < 0 + || gdbpy_initialize_linetable () < 0 + || gdbpy_initialize_thread () < 0 + || gdbpy_initialize_inferior () < 0 + || gdbpy_initialize_events () < 0 + || gdbpy_initialize_eventregistry () < 0 + || gdbpy_initialize_py_events () < 0 + || gdbpy_initialize_event () < 0 + || gdbpy_initialize_stop_event () < 0 + || gdbpy_initialize_signal_event () < 0 + || gdbpy_initialize_breakpoint_event () < 0 + || gdbpy_initialize_continue_event () < 0 + || gdbpy_initialize_inferior_call_pre_event () < 0 + || gdbpy_initialize_inferior_call_post_event () < 0 + || gdbpy_initialize_register_changed_event () < 0 + || gdbpy_initialize_memory_changed_event () < 0 + || gdbpy_initialize_exited_event () < 0 + || gdbpy_initialize_thread_event () < 0 + || gdbpy_initialize_new_objfile_event () < 0 + || gdbpy_initialize_clear_objfiles_event () < 0 + || gdbpy_initialize_arch () < 0 + || gdbpy_initialize_xmethods () < 0) + goto fail; gdbpy_to_string_cst = PyString_FromString ("to_string"); + if (gdbpy_to_string_cst == NULL) + goto fail; gdbpy_children_cst = PyString_FromString ("children"); + if (gdbpy_children_cst == NULL) + goto fail; gdbpy_display_hint_cst = PyString_FromString ("display_hint"); + if (gdbpy_display_hint_cst == NULL) + goto fail; gdbpy_doc_cst = PyString_FromString ("__doc__"); + if (gdbpy_doc_cst == NULL) + goto fail; gdbpy_enabled_cst = PyString_FromString ("enabled"); + if (gdbpy_enabled_cst == NULL) + goto fail; gdbpy_value_cst = PyString_FromString ("value"); + if (gdbpy_value_cst == NULL) + goto fail; /* Release the GIL while gdb runs. */ PyThreadState_Swap (NULL); PyEval_ReleaseLock (); + make_final_cleanup (finalize_python, NULL); + + gdb_python_initialized = 1; + return; + + fail: + gdbpy_print_stack (); + /* Do not set 'gdb_python_initialized'. */ + return; + #endif /* HAVE_PYTHON */ } @@ -1242,93 +1834,98 @@ Enables or disables printing of Python stack traces."), /* Perform the remaining python initializations. These must be done after GDB is at least mostly initialized. E.g., The "info pretty-printer" command needs the "info" prefix - command installed. */ + command installed. + This is the extension_language_ops.finish_initialization "method". */ -void -finish_python_initialization (void) +static void +gdbpy_finish_initialization (const struct extension_language_defn *extlang) { + PyObject *m; + char *gdb_pythondir; + PyObject *sys_path; struct cleanup *cleanup; cleanup = ensure_python_env (get_current_arch (), current_language); - PyRun_SimpleString ("\ -import os\n\ -import sys\n\ -\n\ -class GdbOutputFile:\n\ - def close(self):\n\ - # Do nothing.\n\ - return None\n\ -\n\ - def isatty(self):\n\ - return False\n\ -\n\ - def write(self, s):\n\ - gdb.write(s, stream=gdb.STDOUT)\n \ -\n\ - def writelines(self, iterable):\n\ - for line in iterable:\n\ - self.write(line)\n\ -\n\ - def flush(self):\n\ - gdb.flush()\n\ -\n\ -sys.stdout = GdbOutputFile()\n\ -\n\ -class GdbOutputErrorFile:\n\ - def close(self):\n\ - # Do nothing.\n\ - return None\n\ -\n\ - def isatty(self):\n\ - return False\n\ -\n\ - def write(self, s):\n\ - gdb.write(s, stream=gdb.STDERR)\n \ -\n\ - def writelines(self, iterable):\n\ - for line in iterable:\n\ - self.write(line)\n \ -\n\ - def flush(self):\n\ - gdb.flush()\n\ -\n\ -sys.stderr = GdbOutputErrorFile()\n\ -\n\ -# Ideally this would live in the gdb module, but it's intentionally written\n\ -# in python, and we need this to bootstrap the gdb module.\n\ -\n\ -def GdbSetPythonDirectory (dir):\n\ - \"Set gdb.PYTHONDIR and update sys.path,etc.\"\n\ - old_dir = gdb.PYTHONDIR\n\ - gdb.PYTHONDIR = dir\n\ - # GDB's python scripts are stored inside gdb.PYTHONDIR. So insert\n\ - # that directory name at the start of sys.path to allow the Python\n\ - # interpreter to find them.\n\ - if old_dir in sys.path:\n\ - sys.path.remove (old_dir)\n\ - sys.path.insert (0, gdb.PYTHONDIR)\n\ -\n\ - # Tell python where to find submodules of gdb.\n\ - gdb.__path__ = [os.path.join (gdb.PYTHONDIR, 'gdb')]\n\ -\n\ - # The gdb module is implemented in C rather than in Python. As a result,\n\ - # the associated __init.py__ script is not not executed by default when\n\ - # the gdb module gets imported. Execute that script manually if it\n\ - # exists.\n\ - ipy = os.path.join (gdb.PYTHONDIR, 'gdb', '__init__.py')\n\ - if os.path.exists (ipy):\n\ - execfile (ipy)\n\ -\n\ -# Install the default gdb.PYTHONDIR.\n\ -GdbSetPythonDirectory (gdb.PYTHONDIR)\n\ -# Default prompt hook does nothing.\n\ -prompt_hook = None\n\ -"); + /* Add the initial data-directory to sys.path. */ + gdb_pythondir = concat (gdb_datadir, SLASH_STRING, "python", NULL); + make_cleanup (xfree, gdb_pythondir); + + sys_path = PySys_GetObject ("path"); + + /* If sys.path is not defined yet, define it first. */ + if (!(sys_path && PyList_Check (sys_path))) + { +#ifdef IS_PY3K + PySys_SetPath (L""); +#else + PySys_SetPath (""); +#endif + sys_path = PySys_GetObject ("path"); + } + if (sys_path && PyList_Check (sys_path)) + { + PyObject *pythondir; + int err; + + pythondir = PyString_FromString (gdb_pythondir); + if (pythondir == NULL) + goto fail; + + err = PyList_Insert (sys_path, 0, pythondir); + Py_DECREF (pythondir); + if (err) + goto fail; + } + else + goto fail; + + /* Import the gdb module to finish the initialization, and + add it to __main__ for convenience. */ + m = PyImport_AddModule ("__main__"); + if (m == NULL) + goto fail; + + gdb_python_module = PyImport_ImportModule ("gdb"); + if (gdb_python_module == NULL) + { + gdbpy_print_stack (); + /* This is passed in one call to warning so that blank lines aren't + inserted between each line of text. */ + warning (_("\n" + "Could not load the Python gdb module from `%s'.\n" + "Limited Python support is available from the _gdb module.\n" + "Suggest passing --data-directory=/path/to/gdb/data-directory.\n"), + gdb_pythondir); + do_cleanups (cleanup); + return; + } + + if (gdb_pymodule_addobject (m, "gdb", gdb_python_module) < 0) + goto fail; + + /* Keep the reference to gdb_python_module since it is in a global + variable. */ + + do_cleanups (cleanup); + return; + + fail: + gdbpy_print_stack (); + warning (_("internal error: Unhandled Python exception")); do_cleanups (cleanup); } +/* Return non-zero if Python has successfully initialized. + This is the extension_languages_ops.initialized "method". */ + +static int +gdbpy_initialized (const struct extension_language_defn *extlang) +{ + return gdb_python_initialized; +} + #endif /* HAVE_PYTHON */ @@ -1340,7 +1937,10 @@ static PyMethodDef GdbMethods[] = { "history", gdbpy_history, METH_VARARGS, "Get a value from history" }, { "execute", (PyCFunction) execute_gdb_command, METH_VARARGS | METH_KEYWORDS, - "Execute a gdb command" }, + "execute (command [, from_tty] [, to_string]) -> [String]\n\ +Evaluate command, a string, as a gdb CLI command. Optionally returns\n\ +a Python String containing the output of the command if to_string is\n\ +set to True." }, { "parameter", gdbpy_parameter, METH_VARARGS, "Return a gdb parameter's value" }, @@ -1384,6 +1984,14 @@ a boolean indicating if name is a field of the current implied argument\n\ METH_VARARGS | METH_KEYWORDS, "lookup_global_symbol (name [, domain]) -> symbol\n\ Return the symbol corresponding to the given name (or None)." }, + + { "lookup_objfile", (PyCFunction) gdbpy_lookup_objfile, + METH_VARARGS | METH_KEYWORDS, + "lookup_objfile (name, [by_build_id]) -> objfile\n\ +Look up the specified objfile.\n\ +If by_build_id is True, the objfile is looked up by using name\n\ +as its build id." }, + { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS, "Return the block containing the given pc value, or None." }, { "solib_name", gdbpy_solib_name, METH_VARARGS, @@ -1400,6 +2008,9 @@ gdb.Symtab_and_line objects (or None)."}, "parse_and_eval (String) -> Value.\n\ Parse String as an expression, evaluate it, and return the result as a Value." }, + { "find_pc_line", gdbpy_find_pc_line, METH_VARARGS, + "find_pc_line (pc) -> Symtab_and_line.\n\ +Return the gdb.Symtab_and_line object corresponding to the pc value." }, { "post_event", gdbpy_post_event, METH_VARARGS, "Post an event into gdb's event loop." }, @@ -1423,10 +2034,27 @@ Arguments are separate by spaces and may be quoted." { "selected_thread", gdbpy_selected_thread, METH_NOARGS, "selected_thread () -> gdb.InferiorThread.\n\ Return the selected thread object." }, + { "selected_inferior", gdbpy_selected_inferior, METH_NOARGS, + "selected_inferior () -> gdb.Inferior.\n\ +Return the selected inferior object." }, { "inferiors", gdbpy_inferiors, METH_NOARGS, "inferiors () -> (gdb.Inferior, ...).\n\ Return a tuple containing all inferiors." }, {NULL, NULL, 0, NULL} }; +#ifdef IS_PY3K +static struct PyModuleDef GdbModuleDef = +{ + PyModuleDef_HEAD_INIT, + "_gdb", + NULL, + -1, + GdbMethods, + NULL, + NULL, + NULL, + NULL +}; +#endif #endif /* HAVE_PYTHON */