#include "ui-out.h"
#include "cli/cli-script.h"
#include "gdbcmd.h"
+#include "progspace.h"
#include "objfiles.h"
#include "observer.h"
#include "value.h"
#include "language.h"
+#include "exceptions.h"
#include <ctype.h>
#include "cli/cli-decode.h"
#include "charset.h"
#include "top.h"
-#include "exceptions.h"
#include "python-internal.h"
#include "version.h"
#include "target.h"
}
}
- return PyErr_Format (PyExc_RuntimeError, "programmer error: unhandled type");
+ return PyErr_Format (PyExc_RuntimeError,
+ _("Programmer error: unhandled type."));
}
/* A Python function which returns a gdb parameter's value as a Python
GDB_PY_HANDLE_EXCEPTION (except);
if (!found)
return PyErr_Format (PyExc_RuntimeError,
- "could not find parameter `%s'", arg);
+ _("Could not find parameter `%s'."), arg);
if (! cmd->var)
- return PyErr_Format (PyExc_RuntimeError, "`%s' is not a parameter", arg);
+ return PyErr_Format (PyExc_RuntimeError,
+ _("`%s' is not a parameter."), arg);
return parameter_to_python (cmd);
}
+/* Wrapper for target_charset. */
+
+static PyObject *
+gdbpy_target_charset (PyObject *self, PyObject *args)
+{
+ const char *cset = target_charset (python_gdbarch);
+ return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
+}
+
+/* Wrapper for target_wide_charset. */
+
+static PyObject *
+gdbpy_target_wide_charset (PyObject *self, PyObject *args)
+{
+ const char *cset = target_wide_charset (python_gdbarch);
+ return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
+}
+
/* A Python function which evaluates a string using the gdb CLI. */
static PyObject *
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. */
+
+void
+source_python_script (FILE *stream, const char *file)
+{
+ struct cleanup *cleanup;
+
+ cleanup = ensure_python_env (get_current_arch (), current_language);
+
+ PyRun_SimpleFile (stream, file);
+
+ do_cleanups (cleanup);
+}
+
\f
/* Printing. */
\f
+/* Return the current Progspace.
+ There always is one. */
+
+static PyObject *
+gdbpy_get_current_progspace (PyObject *unused1, PyObject *unused2)
+{
+ PyObject *result;
+
+ result = pspace_to_pspace_object (current_program_space);
+ if (result)
+ Py_INCREF (result);
+ return result;
+}
+
+/* Return a sequence holding all the Progspaces. */
+
+static PyObject *
+gdbpy_progspaces (PyObject *unused1, PyObject *unused2)
+{
+ struct program_space *ps;
+ PyObject *list;
+
+ list = PyList_New (0);
+ if (!list)
+ return NULL;
+
+ ALL_PSPACES (ps)
+ {
+ PyObject *item = pspace_to_pspace_object (ps);
+ if (!item || PyList_Append (list, item) == -1)
+ {
+ Py_DECREF (list);
+ return NULL;
+ }
+ }
+
+ return list;
+}
+
+\f
+
/* 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 gdbpy_new_objfile; it is NULL at other times. */
}
/* Return a sequence holding all the Objfiles. */
+
static PyObject *
gdbpy_objfiles (PyObject *unused1, PyObject *unused2)
{
error (_("Python scripting is not supported in this copy of GDB."));
}
+void
+source_python_script (FILE *stream, const char *file)
+{
+ throw_error (UNSUPPORTED_ERROR,
+ _("Python scripting is not supported in this copy of GDB."));
+}
+
#endif /* HAVE_PYTHON */
\f
gdbpy_initialize_values ();
gdbpy_initialize_frames ();
gdbpy_initialize_commands ();
+ gdbpy_initialize_symbols ();
+ gdbpy_initialize_symtabs ();
+ gdbpy_initialize_blocks ();
gdbpy_initialize_functions ();
gdbpy_initialize_types ();
+ gdbpy_initialize_pspace ();
gdbpy_initialize_objfile ();
+ gdbpy_initialize_breakpoints ();
+ gdbpy_initialize_lazy_string ();
PyRun_SimpleString ("import gdb");
PyRun_SimpleString ("gdb.pretty_printers = []");
{ "parameter", gdbpy_parameter, METH_VARARGS,
"Return a gdb parameter's value" },
+ { "breakpoints", gdbpy_breakpoints, METH_NOARGS,
+ "Return a tuple of all breakpoint objects" },
+
{ "default_visualizer", gdbpy_default_visualizer, METH_VARARGS,
"Find the default visualizer for a Value." },
+ { "current_progspace", gdbpy_get_current_progspace, METH_NOARGS,
+ "Return the current Progspace." },
+ { "progspaces", gdbpy_progspaces, METH_NOARGS,
+ "Return a sequence of all progspaces." },
+
{ "current_objfile", gdbpy_get_current_objfile, METH_NOARGS,
"Return the current Objfile being loaded, or None." },
{ "objfiles", gdbpy_objfiles, METH_NOARGS,
METH_VARARGS | METH_KEYWORDS,
"lookup_type (name [, block]) -> type\n\
Return a Type corresponding to the given name." },
-
+ { "lookup_symbol", (PyCFunction) gdbpy_lookup_symbol,
+ METH_VARARGS | METH_KEYWORDS,
+ "lookup_symbol (name [, block] [, domain]) -> (symbol, is_field_of_this)\n\
+Return a tuple with the symbol corresponding to the given name (or None) and\n\
+a boolean indicating if name is a field of the current implied argument\n\
+`this' (when the current language is object-oriented)." },
+ { "block_for_pc", gdbpy_block_for_pc, METH_VARARGS,
+ "Return the block containing the given pc value, or None." },
{ "parse_and_eval", gdbpy_parse_and_eval, METH_VARARGS,
"parse_and_eval (String) -> Value.\n\
Parse String as an expression, evaluate it, and return the result as a Value."
},
+ { "target_charset", gdbpy_target_charset, METH_NOARGS,
+ "target_charset () -> string.\n\
+Return the name of the current target charset." },
+ { "target_wide_charset", gdbpy_target_wide_charset, METH_NOARGS,
+ "target_wide_charset () -> string.\n\
+Return the name of the current target wide charset." },
+
{ "write", gdbpy_write, METH_VARARGS,
"Write a string using gdb's filtered stream." },
{ "flush", gdbpy_flush, METH_NOARGS,
projects / deliverable / binutils-gdb.git / blobdiff