* NEWS: Mention Python 3 support.
* varobj.c (value_get_print_value): Use
python_string_to_target_string.
* python/py-block.c: Use PyVarObject_HEAD_INIT in initialization
of type objects.
* python/py-breakpoint.c: Ditto.
* python/py-cmd.c: Ditto.
* python/py-event.c: Ditto.
* python/py-event.h: Ditto.
* python/py-evtregistry.c: Ditto.
* python/py-finishbreakpoint.c: Ditto.
* python/py-frame.c: Ditto.
* python/py-function.c: Ditto.
* python/py-infthread.c: Ditto.
* python/py-lazy-string.c: Ditto.
* python/py-progspace.c: Ditto.
* /python/py-symbol.c: Ditto.
* python/py-evts.c: (gdbpy_initialize_py_events): Add module
initialization for Python 3.
* python/py-inferior.c: Use PyVarObject_HEAD_INIT in initialization
of type objects.
(infpy_read_memory): Return memoryview object if Python 3.
(infpy_write_memory): Use "s*" operand parsing code for Python 3.
(infpy_search_memory): Ditto.
(get_buffer): New function for Python 3.
* python/py-objfile.c: Use PyVarObject_HEAD_INIT in initialization
of type objects.
(objfpy_dealloc): Use Py_TYPE to call tp_free.
* python/py-param.c: Use PyVarObject_HEAD_INIT in initialization
of type objects.
(get_attr): Use PyUnicode_CompareWithASCIIString if Python 3.
(set_attr): Ditto.
* python/py-prettyprint.c (print_string_repr): use PyBytes methods
instead of PyString methods if Python 3.
(print_children): Skip push_dummy_python_frame call if Python 3.
* python/py-symtab.c: Use PyVarObject_HEAD_INIT in initialization
of type objects.
(salpy_dealloc): Use Py_TYPE to call tp_free.
* python/py-type.c: Use PyVarObject_HEAD_INIT in initialization
of type objects.
(field_dealloc): Use Py_TYPE to call tp_free.
(typy_dealloc): Ditto.
(type_object_as_number): Adjust struct initializations for
differences in layout for Python 2 vs. Python 3.
* python/py-utils.c (python_string_to_unicode): Omit non-Unicode
string case for Python 3.
(unicode_to_encoded_python_string): Shorten code (no functional
change).
(python_string_to_target_python_string): Comment that in Python 3
returned value is a Python "bytes" type.
(gdbpy_is_string): Omit non-Unicode string check in Python 3.
(gdb_py_object_from_longest): Omit non-long integer case in Python
3.
(gdb_py_object_from_ulongest): Ditto.
* python/py-value.c: Use PyVarObject_HEAD_INIT in initialization
of type objects.
(valpy_dealloc): Use Py_TYPE to call tp_free.
(valpy_int): Omit function if Python 3.
(convert_value_from_python): Use "%S" format (Python object as a
string) if Python 3.
(value_object_as_number): Adjust struct initializations for
differences in layout for Python 2 vs. Python 3.
* python/python-config.py: Adjust syntax for Python 3
compatibility.
Include "sys.abiflags" string as part of python library name, if
that attribute exists (Python 3).
* python/python-internal.h (IS_PY3): Define if Python 3.
(Py_TPFLAGS_HAVE_ITER, Py_TPFLAGS_CHECKTYPES): Define with
placeholder value if Python 3.
(PyInt_Check, PyInt_FromLong, PyInt_AsLong, PyString_FromString,
PyString_Decode, PyString_FromFormat, PyString_Check): Define as
analogous Python 3 API function if Python 3.
(PyVarObject_HEAD_INIT): Define if not already defined.
(Py_TYPE): Ditto.
* python/python.c (eval_python_command): Omit Py_FlushLine call if
Python 3.
Check return values of all Python API calls for error.
Supply dummy "python" and "python-interactive" commands if Python
initialization failed.
(_initialize_python): Convert argc to wchar_t** if Python 3.
Add module initialization for Python 3.
(finish_python_initialization): Pass wchar_t * argument to
PySys_SetPath if Python 3.
* python/lib/gdb/__init__.py: Define "reload" if Python 3.
(_GdbFile): New class for common output file behavior.
(GdbOutFile): Subclass from _GdbFile.
(GdbOutputErrorFile): Ditto.
(auto_load_packages): Adjust syntax for Python 3 compatibility.
* python/lib/gdb/printing.py: Define basestr and int if Python 3.
* python/lib/gdb/prompt.py: Use sorted() function rather than
sort() method.
* python/lib/gdb/command/explore.py: Define raw_input if Python 3.
Adjust syntax for Python 3 compatibility.
* python/lib/gdb/command/pretty_printers.py: Use sorted() function
rather than sort() method.
Adjust syntax for Python 3 compatibility.
* python/lib/gdb/command/type_printers.py: Ditto.
* doc/gdb.texinfo (Inferior.read_memory): Mention that the return
value is a memoryview object if Python 3.
+2012-12-12 Paul Koning <paul_koning@dell.com>
+
+ Add support for Python 3.
+ * NEWS: Mention Python 3 support.
+ * varobj.c (value_get_print_value): Use
+ python_string_to_target_string.
+ * python/py-block.c: Use PyVarObject_HEAD_INIT in initialization
+ of type objects.
+ * python/py-breakpoint.c: Ditto.
+ * python/py-cmd.c: Ditto.
+ * python/py-event.c: Ditto.
+ * python/py-event.h: Ditto.
+ * python/py-evtregistry.c: Ditto.
+ * python/py-finishbreakpoint.c: Ditto.
+ * python/py-frame.c: Ditto.
+ * python/py-function.c: Ditto.
+ * python/py-infthread.c: Ditto.
+ * python/py-lazy-string.c: Ditto.
+ * python/py-progspace.c: Ditto.
+ * /python/py-symbol.c: Ditto.
+ * python/py-evts.c: (gdbpy_initialize_py_events): Add module
+ initialization for Python 3.
+ * python/py-inferior.c: Use PyVarObject_HEAD_INIT in initialization
+ of type objects.
+ (infpy_read_memory): Return memoryview object if Python 3.
+ (infpy_write_memory): Use "s*" operand parsing code for Python 3.
+ (infpy_search_memory): Ditto.
+ (get_buffer): New function for Python 3.
+ * python/py-objfile.c: Use PyVarObject_HEAD_INIT in initialization
+ of type objects.
+ (objfpy_dealloc): Use Py_TYPE to call tp_free.
+ * python/py-param.c: Use PyVarObject_HEAD_INIT in initialization
+ of type objects.
+ (get_attr): Use PyUnicode_CompareWithASCIIString if Python 3.
+ (set_attr): Ditto.
+ * python/py-prettyprint.c (print_string_repr): use PyBytes methods
+ instead of PyString methods if Python 3.
+ (print_children): Skip push_dummy_python_frame call if Python 3.
+ * python/py-symtab.c: Use PyVarObject_HEAD_INIT in initialization
+ of type objects.
+ (salpy_dealloc): Use Py_TYPE to call tp_free.
+ * python/py-type.c: Use PyVarObject_HEAD_INIT in initialization
+ of type objects.
+ (field_dealloc): Use Py_TYPE to call tp_free.
+ (typy_dealloc): Ditto.
+ (type_object_as_number): Adjust struct initializations for
+ differences in layout for Python 2 vs. Python 3.
+ * python/py-utils.c (python_string_to_unicode): Omit non-Unicode
+ string case for Python 3.
+ (unicode_to_encoded_python_string): Shorten code (no functional
+ change).
+ (python_string_to_target_python_string): Comment that in Python 3
+ returned value is a Python "bytes" type.
+ (gdbpy_is_string): Omit non-Unicode string check in Python 3.
+ (gdb_py_object_from_longest): Omit non-long integer case in Python
+ 3.
+ (gdb_py_object_from_ulongest): Ditto.
+ * python/py-value.c: Use PyVarObject_HEAD_INIT in initialization
+ of type objects.
+ (valpy_dealloc): Use Py_TYPE to call tp_free.
+ (valpy_int): Omit function if Python 3.
+ (convert_value_from_python): Use "%S" format (Python object as a
+ string) if Python 3.
+ (value_object_as_number): Adjust struct initializations for
+ differences in layout for Python 2 vs. Python 3.
+ * python/python-config.py: Adjust syntax for Python 3
+ compatibility.
+ Include "sys.abiflags" string as part of python library name, if
+ that attribute exists (Python 3).
+ * python/python-internal.h (IS_PY3): Define if Python 3.
+ (Py_TPFLAGS_HAVE_ITER, Py_TPFLAGS_CHECKTYPES): Define with
+ placeholder value if Python 3.
+ (PyInt_Check, PyInt_FromLong, PyInt_AsLong, PyString_FromString,
+ PyString_Decode, PyString_FromFormat, PyString_Check): Define as
+ analogous Python 3 API function if Python 3.
+ (PyVarObject_HEAD_INIT): Define if not already defined.
+ (Py_TYPE): Ditto.
+ * python/python.c (eval_python_command): Omit Py_FlushLine call if
+ Python 3.
+ Check return values of all Python API calls for error.
+ Supply dummy "python" and "python-interactive" commands if Python
+ initialization failed.
+ (_initialize_python): Convert argc to wchar_t** if Python 3.
+ Add module initialization for Python 3.
+ (finish_python_initialization): Pass wchar_t * argument to
+ PySys_SetPath if Python 3.
+ * python/lib/gdb/__init__.py: Define "reload" if Python 3.
+ (_GdbFile): New class for common output file behavior.
+ (GdbOutFile): Subclass from _GdbFile.
+ (GdbOutputErrorFile): Ditto.
+ (auto_load_packages): Adjust syntax for Python 3 compatibility.
+ * python/lib/gdb/printing.py: Define basestr and int if Python 3.
+ * python/lib/gdb/prompt.py: Use sorted() function rather than
+ sort() method.
+ * python/lib/gdb/command/explore.py: Define raw_input if Python 3.
+ Adjust syntax for Python 3 compatibility.
+ * python/lib/gdb/command/pretty_printers.py: Use sorted() function
+ rather than sort() method.
+ Adjust syntax for Python 3 compatibility.
+ * python/lib/gdb/command/type_printers.py: Ditto.
+ * doc/gdb.texinfo (Inferior.read_memory): Mention that the return
+ value is a memoryview object if Python 3.
+
2012-12-12 Tom Tromey <tromey@redhat.com>
* coffread.c (coff_objfile_data_key): New global.
** Types can be pretty-printed via a Python API.
+ ** Python 3 is now supported (in addition to Python 2.4 or later)
+
* New Python-based convenience functions:
** $_memeq(buf1, buf2, length)
Read @var{length} bytes of memory from the inferior, starting at
@var{address}. Returns a buffer object, which behaves much like an array
or a string. It can be modified and given to the
-@code{Inferior.write_memory} function.
+@code{Inferior.write_memory} function. In @code{Python} 3, the return
+value is a @code{memoryview} object.
@end defun
@findex Inferior.write_memory
import sys
import _gdb
+if sys.version_info[0] > 2:
+ # Python 3 moved "reload"
+ from imp import reload
+
from _gdb import *
-class GdbOutputFile:
+class _GdbFile (object):
+ # These two are needed in Python 3
+ encoding = "UTF-8"
+ errors = "strict"
+
def close(self):
# Do nothing.
return None
def isatty(self):
return False
- def write(self, s):
- write(s, stream=STDOUT)
-
def writelines(self, iterable):
for line in iterable:
self.write(line)
def flush(self):
flush()
-sys.stdout = GdbOutputFile()
-
-class GdbOutputErrorFile:
- def close(self):
- # Do nothing.
- return None
+class GdbOutputFile (_GdbFile):
+ def write(self, s):
+ write(s, stream=STDOUT)
- def isatty(self):
- return False
+sys.stdout = GdbOutputFile()
+class GdbOutputErrorFile (_GdbFile):
def write(self, s):
write(s, stream=STDERR)
- def writelines(self, iterable):
- for line in iterable:
- self.write(line)
-
- def flush(self):
- flush()
-
sys.stderr = GdbOutputErrorFile()
# Default prompt hook does nothing.
else:
__import__(modname)
except:
- print >> sys.stderr, traceback.format_exc()
+ sys.stderr.write (traceback.format_exc() + "\n")
auto_load_packages()
"""Implementation of the GDB 'explore' command using the GDB Python API."""
import gdb
+import sys
+if sys.version_info[0] > 2:
+ # Python 3 renamed raw_input to input
+ raw_input = input
+
class Explorer(object):
"""Internal class which invokes other explorers."""
"""A utility function which prints that the current exploration session
is returning to the parent value. Useful when exploring values.
"""
- print "\nReturning to parent value...\n"
+ print ("\nReturning to parent value...\n")
@staticmethod
def return_to_parent_value_prompt():
"""A utility function which prints that the current exploration session
is returning to the enclosing type. Useful when exploring types.
"""
- print "\nReturning to enclosing type...\n"
+ print ("\nReturning to enclosing type...\n")
@staticmethod
def return_to_enclosing_type_prompt():
"""
print ("'%s' is a scalar value of type '%s'." %
(expr, value.type))
- print "%s = %s" % (expr, str(value))
+ print ("%s = %s" % (expr, str(value)))
if is_child:
Explorer.return_to_parent_value_prompt()
print ("%s is of an enumerated type '%s'." %
(name, str(datatype)))
else:
- print "'%s' is an enumerated type." % name
+ print ("'%s' is an enumerated type." % name)
else:
if is_child:
print ("%s is of a scalar type '%s'." %
(name, str(datatype)))
else:
- print "'%s' is a scalar type." % name
+ print ("'%s' is a scalar type." % name)
if is_child:
Explorer.return_to_enclosing_type_prompt()
try:
str(element)
except gdb.MemoryError:
- print "Cannot read value at index %d." % index
+ print ("Cannot read value at index %d." % index)
continue
Explorer.explore_expr(element_expr, element, True)
return False
element = value[index]
str(element)
except gdb.MemoryError:
- print "Cannot read value at index %d." % index
+ print ("Cannot read value at index %d." % index)
raw_input("Press enter to continue... ")
return True
See Explorer.explore_type for more information.
"""
target_type = datatype.target()
- print "%s is an array of '%s'." % (name, str(target_type))
+ print ("%s is an array of '%s'." % (name, str(target_type)))
Explorer.explore_type("the array element of %s" % name, target_type,
is_child)
if max_field_name_length < len(pair[0]):
max_field_name_length = len(pair[0])
- format_str = " {0:>%d} = {1}" % max_field_name_length
for pair in print_list:
- print format_str.format(pair[0], pair[1])
+ print (" %*s = %s" % (max_field_name_length, pair[0], pair[1]))
@staticmethod
def _get_real_field_count(fields):
print_list.append((field.name, literal_value))
CompoundExplorer._print_fields(print_list)
- print ""
+ print ("")
if has_explorable_fields:
choice = raw_input("Enter the field number of choice: ")
(name, type_desc, str(datatype)))
Explorer.return_to_enclosing_type_prompt()
else:
- print "'%s' is a %s with no fields." % (name, type_desc)
+ print ("'%s' is a %s with no fields." % (name, type_desc))
return False
if is_child:
current_choice = current_choice + 1
CompoundExplorer._print_fields(print_list)
- print ""
+ print ("")
if len(choice_to_compound_field_map) > 0:
choice = raw_input("Enter the field number of choice: ")
value = ExploreUtils.get_value_from_str(arg_str)
if value is not None:
- print "'%s' is of type '%s'." % (arg_str, str(value.type))
+ print ("'%s' is of type '%s'." % (arg_str, str(value.type)))
Explorer.explore_type(str(value.type), value.type, False)
raise gdb.GdbError(("'%s' is not a type or value in the current "
"""Print a list of pretty-printers."""
# A potential enhancement is to provide an option to list printers in
# "lookup order" (i.e. unsorted).
- sorted_pretty_printers = copy.copy(pretty_printers)
- sorted_pretty_printers.sort(lambda x, y:
- cmp(self.printer_name(x),
- self.printer_name(y)))
+ sorted_pretty_printers = sorted (copy.copy(pretty_printers),
+ key = self.printer_name)
for printer in sorted_pretty_printers:
name = self.printer_name(printer)
enabled = self.enabled_string(printer)
if name_re.match(name):
- print " %s%s" % (name, enabled)
+ print (" %s%s" % (name, enabled))
if (hasattr(printer, "subprinters") and
printer.subprinters is not None):
- sorted_subprinters = copy.copy(printer.subprinters)
- sorted_subprinters.sort(lambda x, y:
- cmp(self.printer_name(x),
- self.printer_name(y)))
+ sorted_subprinters = sorted (copy.copy(printer.subprinters),
+ key = self.printer_name)
for subprinter in sorted_subprinters:
if (not subname_re or
subname_re.match(subprinter.name)):
obj_name_to_match, object_re, name_re, subname_re):
"""Subroutine of invoke to simplify it."""
if printer_list and object_re.match(obj_name_to_match):
- print title
+ print (title)
self.list_pretty_printers(printer_list, name_re, subname_re)
def invoke(self, arg, from_tty):
We count subprinters individually.
"""
(enabled_count, total_count) = count_all_enabled_printers()
- print "%d of %d printers enabled" % (enabled_count, total_count)
+ print ("%d of %d printers enabled" % (enabled_count, total_count))
def do_enable_pretty_printer_1 (pretty_printers, name_re, subname_re, flag):
state = "enabled"
else:
state = "disabled"
- print "%d %s %s" % (total, pluralize("printer", total), state)
+ print ("%d %s %s" % (total, pluralize("printer", total), state))
# Print the total list of printers currently enabled/disabled.
# This is to further assist the user in determining whether the result
"""Print a list of type printers."""
# A potential enhancement is to provide an option to list printers in
# "lookup order" (i.e. unsorted).
- sorted_type_printers = copy.copy(type_printers)
- sorted_type_printers.sort(lambda x, y: cmp(x.name, y.name))
+ sorted_type_printers = sorted (copy.copy(type_printers),
+ key = lambda x: x.name)
for printer in sorted_type_printers:
if printer.enabled:
enabled = ''
else:
enabled = " [disabled]"
- print " %s%s" % (printer.name, enabled)
+ print (" %s%s" % (printer.name, enabled))
def invoke(self, arg, from_tty):
"""GDB calls this to perform the command."""
sep = ''
for objfile in gdb.objfiles():
if objfile.type_printers:
- print "%sType printers for %s:" % (sep, objfile.name)
+ print ("%sType printers for %s:" % (sep, objfile.name))
self.list_type_printers(objfile.type_printers)
sep = '\n'
if gdb.current_progspace().type_printers:
- print "%sType printers for program space:" % sep
+ print ("%sType printers for program space:" % sep)
self.list_type_printers(gdb.current_progspace().type_printers)
sep = '\n'
if gdb.type_printers:
- print "%sGlobal type printers:" % sep
+ print ("%sGlobal type printers:" % sep)
self.list_type_printers(gdb.type_printers)
class _EnableOrDisableCommand(gdb.Command):
if self.set_some(name, gdb.type_printers):
ok = True
if not ok:
- print "No type printer named '%s'" % name
+ print ("No type printer named '%s'" % name)
def add_some(self, result, word, printers):
for p in printers:
import gdb
import gdb.types
import re
+import sys
+if sys.version_info[0] > 2:
+ # Python 3 removed basestring and long
+ basestring = str
+ long = int
class PrettyPrinter(object):
"""A basic pretty-printer.
functions."""
result = ''
- keys = prompt_substitutions.keys()
- keys.sort()
+ keys = sorted (prompt_substitutions.keys())
for key in keys:
result += ' \\%s\t%s\n' % (key, prompt_substitutions[key].__doc__)
result += """
};
PyTypeObject block_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Block", /*tp_name*/
sizeof (block_object), /*tp_basicsize*/
0, /*tp_itemsize*/
};
static PyTypeObject block_syms_iterator_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.BlockIterator", /*tp_name*/
sizeof (block_syms_iterator_object), /*tp_basicsize*/
0, /*tp_itemsize*/
PyTypeObject breakpoint_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Breakpoint", /*tp_name*/
sizeof (breakpoint_object), /*tp_basicsize*/
0, /*tp_itemsize*/
static PyTypeObject cmdpy_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Command", /*tp_name*/
sizeof (cmdpy_object), /*tp_basicsize*/
0, /*tp_itemsize*/
evpy_dealloc (PyObject *self)
{
Py_XDECREF (((event_object *) self)->dict);
- self->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
PyObject *
PyTypeObject event_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /* ob_size */
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Event", /* tp_name */
sizeof (event_object), /* tp_basicsize */
0, /* tp_itemsize */
\
qual PyTypeObject name##_event_object_type = \
{ \
- PyObject_HEAD_INIT (NULL) \
- 0, /* ob_size */ \
+ PyVarObject_HEAD_INIT (NULL, 0) \
py_path, /* tp_name */ \
sizeof (event_object), /* tp_basicsize */ \
0, /* tp_itemsize */ \
evregpy_dealloc (PyObject *self)
{
Py_XDECREF (((eventregistry_object *) self)->callbacks);
- self->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
/* Initialize the Python event registry code. */
static PyTypeObject eventregistry_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /* ob_size */
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.EventRegistry", /* tp_name */
sizeof (eventregistry_object), /* tp_basicsize */
0, /* tp_itemsize */
#include "defs.h"
#include "py-events.h"
+#ifdef IS_PY3K
+static struct PyModuleDef EventModuleDef =
+{
+ PyModuleDef_HEAD_INIT,
+ "gdb.events",
+ NULL,
+ -1,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL
+};
+#endif
+
/* Initialize python events. */
static int
void
gdbpy_initialize_py_events (void)
{
+#ifdef IS_PY3K
+ gdb_py_events.module = PyModule_Create (&EventModuleDef);
+#else
gdb_py_events.module = Py_InitModule ("events", NULL);
+#endif
if (!gdb_py_events.module)
goto fail;
if (add_new_registry (&gdb_py_events.new_objfile, "new_objfile") < 0)
goto fail;
+#ifndef IS_PY3K
Py_INCREF (gdb_py_events.module);
+#endif
if (PyModule_AddObject (gdb_module,
"events",
(PyObject *) gdb_py_events.module) < 0)
static PyTypeObject finish_breakpoint_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.FinishBreakpoint", /*tp_name*/
sizeof (struct finish_breakpoint_object), /*tp_basicsize*/
0, /*tp_itemsize*/
};
PyTypeObject frame_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /* ob_size */
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Frame", /* tp_name */
sizeof (frame_object), /* tp_basicsize */
0, /* tp_itemsize */
static PyTypeObject fnpy_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Function", /*tp_name*/
sizeof (PyObject), /*tp_basicsize*/
0, /*tp_itemsize*/
membuf_obj->addr = addr;
membuf_obj->length = length;
+#ifdef IS_PY3K
+ result = PyMemoryView_FromObject ((PyObject *) membuf_obj);
+#else
result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj, 0,
Py_END_OF_BUFFER);
+#endif
Py_DECREF (membuf_obj);
+
return result;
}
PyObject *addr_obj, *length_obj = NULL;
volatile struct gdb_exception except;
static char *keywords[] = { "address", "buffer", "length", NULL };
+#ifdef IS_PY3K
+ Py_buffer pybuf;
+ if (! PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
+ &addr_obj, &pybuf,
+ &length_obj))
+ return NULL;
+ buffer = pybuf.buf;
+ buf_len = pybuf.len;
+#else
if (! PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
&addr_obj, &buffer, &buf_len,
&length_obj))
return NULL;
+#endif
TRY_CATCH (except, RETURN_MASK_ALL)
{
}
write_memory_with_notification (addr, buffer, length);
}
+#ifdef IS_PY3K
+ PyBuffer_Release (&pybuf);
+#endif
GDB_PY_HANDLE_EXCEPTION (except);
+
if (error)
return NULL;
mbpy_dealloc (PyObject *self)
{
xfree (((membuf_object *) self)->buffer);
- self->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
/* Return a description of the Membuf object. */
pulongest (membuf_obj->length));
}
+#ifdef IS_PY3K
+
+static int
+get_buffer (PyObject *self, Py_buffer *buf, int flags)
+{
+ membuf_object *membuf_obj = (membuf_object *) self;
+ int ret;
+
+ ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
+ membuf_obj->length, 0,
+ PyBUF_CONTIG);
+ buf->format = "c";
+
+ return ret;
+}
+
+#else
+
static Py_ssize_t
get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
{
return ret;
}
+#endif /* IS_PY3K */
+
/* Implementation of
gdb.search_memory (address, length, pattern). ADDRESS is the
address to start the search. LENGTH specifies the scope of the
{
CORE_ADDR start_addr, length;
static char *keywords[] = { "address", "length", "pattern", NULL };
- PyObject *pattern, *start_addr_obj, *length_obj;
+ PyObject *start_addr_obj, *length_obj;
volatile struct gdb_exception except;
Py_ssize_t pattern_size;
const void *buffer;
CORE_ADDR found_addr;
int found = 0;
+#ifdef IS_PY3K
+ Py_buffer pybuf;
- if (! PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
+ if (! PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
&start_addr_obj, &length_obj,
+ &pybuf))
+ return NULL;
+
+ buffer = pybuf.buf;
+ pattern_size = pybuf.len;
+#else
+ PyObject *pattern;
+
+ if (! PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
+ &start_addr_obj, &length_obj,
&pattern))
+ return NULL;
+
+ if (!PyObject_CheckReadBuffer (pattern))
+ {
+ PyErr_SetString (PyExc_RuntimeError,
+ _("The pattern is not a Python buffer."));
+
+ return NULL;
+ }
+
+ if (PyObject_AsReadBuffer (pattern, &buffer, &pattern_size) == -1)
return NULL;
+#endif
if (get_addr_from_python (start_addr_obj, &start_addr)
&& get_addr_from_python (length_obj, &length))
{
PyErr_SetString (PyExc_ValueError,
_("Search range is empty."));
+
+#ifdef IS_PY3K
+ PyBuffer_Release (&pybuf);
+#endif
return NULL;
}
/* Watch for overflows. */
PyErr_SetString (PyExc_ValueError,
_("The search range is too large."));
+#ifdef IS_PY3K
+ PyBuffer_Release (&pybuf);
+#endif
return NULL;
}
}
else
return NULL;
- if (!PyObject_CheckReadBuffer (pattern))
- {
- PyErr_SetString (PyExc_RuntimeError,
- _("The pattern is not a Python buffer."));
-
- return NULL;
- }
-
- if (PyObject_AsReadBuffer (pattern, &buffer, &pattern_size) == -1)
- return NULL;
-
TRY_CATCH (except, RETURN_MASK_ALL)
{
found = target_search_memory (start_addr, length,
}
GDB_PY_HANDLE_EXCEPTION (except);
+#ifdef IS_PY3K
+ PyBuffer_Release (&pybuf);
+#endif
+
if (found)
return PyLong_FromLong (found_addr);
else
static PyTypeObject inferior_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /* ob_size */
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Inferior", /* tp_name */
sizeof (inferior_object), /* tp_basicsize */
0, /* tp_itemsize */
0 /* tp_alloc */
};
+#ifdef IS_PY3K
+
+static PyBufferProcs buffer_procs =
+{
+ get_buffer
+};
+
+#else
+
/* Python doesn't provide a decent way to get compatibility here. */
#if HAVE_LIBPYTHON2_4
#define CHARBUFFERPROC_NAME getcharbufferproc
Python 2.5. */
(CHARBUFFERPROC_NAME) get_char_buffer
};
+#endif /* IS_PY3K */
static PyTypeObject membuf_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Membuf", /*tp_name*/
sizeof (membuf_object), /*tp_basicsize*/
0, /*tp_itemsize*/
thpy_dealloc (PyObject *self)
{
Py_DECREF (((thread_object *) self)->inf_obj);
- self->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
static PyObject *
static PyTypeObject thread_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.InferiorThread", /*tp_name*/
sizeof (thread_object), /*tp_basicsize*/
0, /*tp_itemsize*/
};
static PyTypeObject lazy_string_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.LazyString", /*tp_name*/
sizeof (lazy_string_object), /*tp_basicsize*/
0, /*tp_itemsize*/
Py_XDECREF (self->printers);
Py_XDECREF (self->type_printers);
- self->ob_type->tp_free ((PyObject *) self);
+ Py_TYPE (self)->tp_free (self);
}
static PyObject *
static PyTypeObject objfile_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Objfile", /*tp_name*/
sizeof (objfile_object), /*tp_basicsize*/
0, /*tp_itemsize*/
get_attr (PyObject *obj, PyObject *attr_name)
{
if (PyString_Check (attr_name)
+#ifdef IS_PY3K
+ && ! PyUnicode_CompareWithASCIIString (attr_name, "value"))
+#else
&& ! strcmp (PyString_AsString (attr_name), "value"))
+#endif
{
parmpy_object *self = (parmpy_object *) obj;
set_attr (PyObject *obj, PyObject *attr_name, PyObject *val)
{
if (PyString_Check (attr_name)
+#ifdef IS_PY3K
+ && ! PyUnicode_CompareWithASCIIString (attr_name, "value"))
+#else
&& ! strcmp (PyString_AsString (attr_name), "value"))
+#endif
{
if (!val)
{
static PyTypeObject parmpy_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Parameter", /*tp_name*/
sizeof (parmpy_object), /*tp_basicsize*/
0, /*tp_itemsize*/
struct type *type;
make_cleanup_py_decref (string);
+#ifdef IS_PY3K
+ output = (gdb_byte *) PyBytes_AS_STRING (string);
+ length = PyBytes_GET_SIZE (string);
+#else
output = PyString_AsString (string);
length = PyString_Size (string);
+#endif
type = builtin_type (gdbarch)->builtin_char;
if (hint && !strcmp (hint, "string"))
return result;
}
+#ifndef IS_PY3K
static void
py_restore_tstate (void *p)
{
make_cleanup (py_restore_tstate, frame->f_back);
return (PyObject *) frame;
}
+#endif
/* Helper for apply_val_pretty_printer that formats children of the
printer, if any exist. If is_py_none is true, then nothing has
{
int is_map, is_array, done_flag, pretty;
unsigned int i;
- PyObject *children, *iter, *frame;
+ PyObject *children, *iter;
+#ifndef IS_PY3K
+ PyObject *frame;
+#endif
struct cleanup *cleanups;
if (! PyObject_HasAttr (printer, gdbpy_children_cst))
/* Manufacture a dummy Python frame to work around Python 2.4 bug,
where it insists on having a non-NULL tstate->frame when
a generator is called. */
+#ifndef IS_PY3K
frame = push_dummy_python_frame ();
if (!frame)
{
goto done;
}
make_cleanup_py_decref (frame);
+#endif
done_flag = 0;
for (i = 0; i < options->print_max; ++i)
Py_XDECREF (ps_self->printers);
Py_XDECREF (ps_self->type_printers);
- self->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
static PyObject *
static PyTypeObject pspace_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Progspace", /*tp_name*/
sizeof (pspace_object), /*tp_basicsize*/
0, /*tp_itemsize*/
};
PyTypeObject symbol_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Symbol", /*tp_name*/
sizeof (symbol_object), /*tp_basicsize*/
0, /*tp_itemsize*/
Py_DECREF (self_sal->symtab);
xfree (self_sal->sal);
- self_sal->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
/* Given a sal, and a sal_object that has previously been allocated
};
static PyTypeObject symtab_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Symtab", /*tp_name*/
sizeof (symtab_object), /*tp_basicsize*/
0, /*tp_itemsize*/
};
static PyTypeObject sal_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Symtab_and_line", /*tp_name*/
sizeof (sal_object), /*tp_basicsize*/
0, /*tp_itemsize*/
field_object *f = (field_object *) obj;
Py_XDECREF (f->dict);
- f->ob_type->tp_free (obj);
+ Py_TYPE (obj)->tp_free (obj);
}
static PyObject *
if (type->next)
type->next->prev = type->prev;
- type->ob_type->tp_free (type);
+ Py_TYPE (type)->tp_free (type);
}
/* Return number of fields ("length" of the field dictionary). */
NULL, /* nb_add */
NULL, /* nb_subtract */
NULL, /* nb_multiply */
+#ifndef IS_PY3K
NULL, /* nb_divide */
+#endif
NULL, /* nb_remainder */
NULL, /* nb_divmod */
NULL, /* nb_power */
NULL, /* nb_and */
NULL, /* nb_xor */
NULL, /* nb_or */
+#ifdef IS_PY3K
+ NULL, /* nb_int */
+ NULL, /* reserved */
+#else
NULL, /* nb_coerce */
NULL, /* nb_int */
NULL, /* nb_long */
+#endif
NULL, /* nb_float */
+#ifndef IS_PY3K
NULL, /* nb_oct */
NULL /* nb_hex */
+#endif
};
static PyMappingMethods typy_mapping = {
static PyTypeObject type_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Type", /*tp_name*/
sizeof (type_object), /*tp_basicsize*/
0, /*tp_itemsize*/
static PyTypeObject field_object_type =
{
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Field", /*tp_name*/
sizeof (field_object), /*tp_basicsize*/
0, /*tp_itemsize*/
};
static PyTypeObject type_iterator_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.TypeIterator", /*tp_name*/
sizeof (typy_iterator_object), /*tp_basicsize*/
0, /*tp_itemsize*/
As an added bonus, the functions accepts a unicode string and returns it
right away, so callers don't need to check which kind of string they've
- got.
+ got. In Python 3, all strings are Unicode so this case is always the
+ one that applies.
If the given object is not one of the mentioned string types, NULL is
returned, with the TypeError python exception set. */
unicode_str = obj;
Py_INCREF (obj);
}
-
+#ifndef IS_PY3K
else if (PyString_Check (obj))
unicode_str = PyUnicode_FromEncodedObject (obj, host_charset (), NULL);
+#endif
else
{
PyErr_SetString (PyExc_TypeError,
if (string == NULL)
return NULL;
+#ifdef IS_PY3K
+ result = xstrdup (PyBytes_AsString (string));
+#else
result = xstrdup (PyString_AsString (string));
+#endif
Py_DECREF (string);
static PyObject *
unicode_to_encoded_python_string (PyObject *unicode_str, const char *charset)
{
- PyObject *string;
-
/* Translate string to named charset. */
- string = PyUnicode_AsEncodedString (unicode_str, charset, NULL);
- if (string == NULL)
- return NULL;
-
- return string;
+ return PyUnicode_AsEncodedString (unicode_str, charset, NULL);
}
/* Returns a newly allocated string with the contents of the given unicode
/* Converts a python string (8-bit or unicode) to a target string in the
target's charset. Returns NULL on error, with a python exception
- set. */
+ set.
+
+ In Python 3, the returned object is a "bytes" object (not a string). */
PyObject *
python_string_to_target_python_string (PyObject *obj)
{
int
gdbpy_is_string (PyObject *obj)
{
+#ifdef IS_PY3K
+ return PyUnicode_Check (obj);
+#else
return PyString_Check (obj) || PyUnicode_Check (obj);
+#endif
}
/* Return the string representation of OBJ, i.e., str (obj).
if (str_obj != NULL)
{
+#ifdef IS_PY3K
+ char *msg = python_string_to_host_string (str_obj);
+#else
char *msg = xstrdup (PyString_AsString (str_obj));
+#endif
Py_DECREF (str_obj);
return msg;
PyObject *
gdb_py_object_from_longest (LONGEST l)
{
+#ifdef IS_PY3K
+ if (sizeof (l) > sizeof (long))
+ return PyLong_FromLongLong (l);
+ return PyLong_FromLong (l);
+#else
#ifdef HAVE_LONG_LONG /* Defined by Python. */
/* If we have 'long long', and the value overflows a 'long', use a
Python Long; otherwise use a Python Int. */
return PyLong_FromLongLong (l);
#endif
return PyInt_FromLong (l);
+#endif
}
/* Convert a ULONGEST to the appropriate Python object -- either an
PyObject *
gdb_py_object_from_ulongest (ULONGEST l)
{
+#ifdef IS_PY3K
+ if (sizeof (l) > sizeof (unsigned long))
+ return PyLong_FromUnsignedLongLong (l);
+ return PyLong_FromUnsignedLong (l);
+#else
#ifdef HAVE_LONG_LONG /* Defined by Python. */
/* If we have 'long long', and the value overflows a 'long', use a
Python Long; otherwise use a Python Int. */
return PyLong_FromUnsignedLong (l);
return PyInt_FromLong (l);
+#endif
}
/* Like PyInt_AsLong, but returns 0 on failure, 1 on success, and puts
Py_XDECREF (self->dynamic_type);
- self->ob_type->tp_free (self);
+ Py_TYPE (self)->tp_free (self);
}
/* Helper to push a Value object on the global list. */
|| (ptr_ok && TYPE_CODE (type) == TYPE_CODE_PTR));
}
+#ifndef IS_PY3K
/* Implements conversion to int. */
static PyObject *
valpy_int (PyObject *self)
return gdb_py_object_from_longest (l);
}
+#endif
/* Implements conversion to long. */
static PyObject *
value = value_copy (((value_object *) result)->value);
}
else
+#ifdef IS_PY3K
+ PyErr_Format (PyExc_TypeError,
+ _("Could not convert Python object: %S."), obj);
+#else
PyErr_Format (PyExc_TypeError,
_("Could not convert Python object: %s."),
PyString_AsString (PyObject_Str (obj)));
+#endif
}
if (except.reason < 0)
{
valpy_add,
valpy_subtract,
valpy_multiply,
+#ifndef IS_PY3K
valpy_divide,
+#endif
valpy_remainder,
NULL, /* nb_divmod */
valpy_power, /* nb_power */
valpy_and, /* nb_and */
valpy_xor, /* nb_xor */
valpy_or, /* nb_or */
+#ifdef IS_PY3K
+ valpy_long, /* nb_int */
+ NULL, /* reserved */
+#else
NULL, /* nb_coerce */
valpy_int, /* nb_int */
valpy_long, /* nb_long */
+#endif
valpy_float, /* nb_float */
+#ifndef IS_PY3K
NULL, /* nb_oct */
- NULL /* nb_hex */
+ NULL, /* nb_hex */
+#endif
+ NULL, /* nb_inplace_add */
+ NULL, /* nb_inplace_subtract */
+ NULL, /* nb_inplace_multiply */
+ NULL, /* nb_inplace_remainder */
+ NULL, /* nb_inplace_power */
+ NULL, /* nb_inplace_lshift */
+ NULL, /* nb_inplace_rshift */
+ NULL, /* nb_inplace_and */
+ NULL, /* nb_inplace_xor */
+ NULL, /* nb_inplace_or */
+ NULL, /* nb_floor_divide */
+ valpy_divide /* nb_true_divide */
};
static PyMappingMethods value_object_as_mapping = {
};
PyTypeObject value_object_type = {
- PyObject_HEAD_INIT (NULL)
- 0, /*ob_size*/
+ PyVarObject_HEAD_INIT (NULL, 0)
"gdb.Value", /*tp_name*/
sizeof (value_object), /*tp_basicsize*/
0, /*tp_itemsize*/
'ldflags', 'help']
def exit_with_usage(code=1):
- print >>sys.stderr, "Usage: %s [%s]" % (sys.argv[0],
- '|'.join('--'+opt for opt in valid_opts))
+ sys.stderr.write ("Usage: %s [%s]\n" % (sys.argv[0],
+ '|'.join('--'+opt for opt in valid_opts)))
sys.exit(code)
try:
pyver = sysconfig.get_config_var('VERSION')
getvar = sysconfig.get_config_var
+abiflags = getattr (sys, "abiflags", "")
opt_flags = [flag for (flag, val) in opts]
for opt in opt_flags:
if opt == '--prefix':
- print to_unix_path(sysconfig.PREFIX)
+ print (to_unix_path(sysconfig.PREFIX))
elif opt == '--exec-prefix':
- print to_unix_path(sysconfig.EXEC_PREFIX)
+ print (to_unix_path(sysconfig.EXEC_PREFIX))
elif opt in ('--includes', '--cflags'):
flags = ['-I' + sysconfig.get_python_inc(),
'-I' + sysconfig.get_python_inc(plat_specific=True)]
if opt == '--cflags':
flags.extend(getvar('CFLAGS').split())
- print to_unix_path(' '.join(flags))
+ print (to_unix_path(' '.join(flags)))
elif opt in ('--libs', '--ldflags'):
libs = []
libs.extend(getvar('LIBS').split())
if getvar('SYSLIBS') is not None:
libs.extend(getvar('SYSLIBS').split())
- libs.append('-lpython'+pyver)
+ libs.append('-lpython'+pyver + abiflags)
# add the prefix/lib/pythonX.Y/config dir, but only if there is no
# shared library in prefix/lib/.
if opt == '--ldflags':
libs.insert(0, '-L' + sysconfig.PREFIX + '/libs')
if getvar('LINKFORSHARED') is not None:
libs.extend(getvar('LINKFORSHARED').split())
- print to_unix_path(' '.join(libs))
+ print (to_unix_path(' '.join(libs)))
from including our python/python.h header file. */
#include <Python.h>
#include <frameobject.h>
+
+#if PY_MAJOR_VERSION >= 3
+#define IS_PY3K 1
+#endif
+
+#ifdef IS_PY3K
+#define Py_TPFLAGS_HAVE_ITER 0
+#define Py_TPFLAGS_CHECKTYPES 0
+
+#define PyInt_Check PyLong_Check
+#define PyInt_FromLong PyLong_FromLong
+#define PyInt_AsLong PyLong_AsLong
+
+#define PyString_FromString PyUnicode_FromString
+#define PyString_Decode PyUnicode_Decode
+#define PyString_FromFormat PyUnicode_FromFormat
+#define PyString_Check PyUnicode_Check
+#endif
+
#if HAVE_LIBPYTHON2_4
/* Py_ssize_t is not defined until 2.5.
Logical type for Py_ssize_t is Py_intptr_t, but that fails in 64-bit
typedef int Py_ssize_t;
#endif
+#ifndef PyVarObject_HEAD_INIT
+/* Python 2.4 does not define PyVarObject_HEAD_INIT. */
+#define PyVarObject_HEAD_INIT(type, size) \
+ PyObject_HEAD_INIT(type) size,
+
+#endif
+
+#ifndef Py_TYPE
+/* Python 2.4 does not define Py_TYPE. */
+#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
+#endif
+
/* If Python.h does not define WITH_THREAD, then the various
GIL-related functions will not be defined. However,
PyGILState_STATE will be. */
#include "gdbthread.h"
#include "observer.h"
#include "interps.h"
+#include "event-top.h"
static PyMethodDef GdbMethods[];
+#ifdef IS_PY3K
+static struct PyModuleDef GdbModuleDef;
+#endif
+
PyObject *gdb_module;
PyObject *gdb_python_module;
return -1;
Py_DECREF (v);
+#ifndef IS_PY3K
if (Py_FlushLine ())
PyErr_Clear ();
+#endif
return 0;
}
{
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,
/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 ();
+#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
/* The casts to (char*) are for python 2.4. */
PyModule_AddStringConstant (gdb_module, "VERSION", (char*) version);
sys_path = PySys_GetObject ("path");
- if (sys_path && PyList_Check (sys_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;
Py_DECREF (pythondir);
}
else
- PySys_SetPath (gdb_pythondir);
+ goto fail;
/* Import the gdb module to finish the initialization, and
add it to __main__ for convenience. */
{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 */
string_print. Otherwise just return the extracted
string as a value. */
- PyObject *py_str
- = python_string_to_target_python_string (output);
+ char *s = python_string_to_target_string (output);
- if (py_str)
+ if (s)
{
- char *s = PyString_AsString (py_str);
char *hint;
hint = gdbpy_get_display_hint (value_formatter);
xfree (hint);
}
- len = PyString_Size (py_str);
+ len = strlen (s);
thevalue = xmemdup (s, len + 1, len + 1);
type = builtin_type (gdbarch)->builtin_char;
- Py_DECREF (py_str);
+ xfree (s);
if (!string_print)
{
projects / thirdparty / binutils-gdb.git / commitdiff
