2008-08-06 21:41:33 +02:00
|
|
|
|
/* General utility routines for GDB/Python.
|
|
|
|
|
|
2017-01-01 07:50:51 +01:00
|
|
|
|
Copyright (C) 2008-2017 Free Software Foundation, Inc.
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
|
#include "charset.h"
|
2010-06-28 23:16:04 +02:00
|
|
|
|
#include "value.h"
|
2008-08-06 21:41:33 +02:00
|
|
|
|
#include "python-internal.h"
|
2016-11-20 18:52:25 +01:00
|
|
|
|
#include "py-ref.h"
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
/* Converts a Python 8-bit string to a unicode string object. Assumes the
|
|
|
|
|
8-bit string is in the host charset. If an error occurs during conversion,
|
|
|
|
|
returns NULL with a python exception set.
|
|
|
|
|
|
|
|
|
|
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
|
2013-11-29 21:00:47 +01:00
|
|
|
|
got. In Python 3, all strings are Unicode so this case is always the
|
2012-12-12 17:47:30 +01:00
|
|
|
|
one that applies.
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
If the given object is not one of the mentioned string types, NULL is
|
|
|
|
|
returned, with the TypeError python exception set. */
|
|
|
|
|
PyObject *
|
|
|
|
|
python_string_to_unicode (PyObject *obj)
|
|
|
|
|
{
|
|
|
|
|
PyObject *unicode_str;
|
|
|
|
|
|
|
|
|
|
/* If obj is already a unicode string, just return it.
|
|
|
|
|
I wish life was always that simple... */
|
|
|
|
|
if (PyUnicode_Check (obj))
|
2009-02-26 21:45:21 +01:00
|
|
|
|
{
|
|
|
|
|
unicode_str = obj;
|
|
|
|
|
Py_INCREF (obj);
|
|
|
|
|
}
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#ifndef IS_PY3K
|
2008-08-06 21:41:33 +02:00
|
|
|
|
else if (PyString_Check (obj))
|
|
|
|
|
unicode_str = PyUnicode_FromEncodedObject (obj, host_charset (), NULL);
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#endif
|
2008-08-06 21:41:33 +02:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
PyErr_SetString (PyExc_TypeError,
|
|
|
|
|
_("Expected a string or unicode object."));
|
|
|
|
|
unicode_str = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return unicode_str;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Returns a newly allocated string with the contents of the given unicode
|
2009-02-04 22:55:40 +01:00
|
|
|
|
string object converted to CHARSET. If an error occurs during the
|
|
|
|
|
conversion, NULL will be returned and a python exception will be set.
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
|
|
|
|
The caller is responsible for xfree'ing the string. */
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
static gdb::unique_xmalloc_ptr<char>
|
2009-02-04 22:55:40 +01:00
|
|
|
|
unicode_to_encoded_string (PyObject *unicode_str, const char *charset)
|
2008-08-06 21:41:33 +02:00
|
|
|
|
{
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
gdb::unique_xmalloc_ptr<char> result;
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
2009-02-04 22:55:40 +01:00
|
|
|
|
/* Translate string to named charset. */
|
2016-11-20 18:52:25 +01:00
|
|
|
|
gdbpy_ref string (PyUnicode_AsEncodedString (unicode_str, charset, NULL));
|
2008-08-06 21:41:33 +02:00
|
|
|
|
if (string == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#ifdef IS_PY3K
|
2016-11-20 18:52:25 +01:00
|
|
|
|
result.reset (xstrdup (PyBytes_AsString (string.get ())));
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#else
|
2016-11-20 18:52:25 +01:00
|
|
|
|
result.reset (xstrdup (PyString_AsString (string.get ())));
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#endif
|
2008-08-06 21:41:33 +02:00
|
|
|
|
|
2009-02-04 22:55:40 +01:00
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2009-07-10 12:35:17 +02:00
|
|
|
|
/* Returns a PyObject with the contents of the given unicode string
|
|
|
|
|
object converted to a named charset. If an error occurs during
|
|
|
|
|
the conversion, NULL will be returned and a python exception will
|
|
|
|
|
be set. */
|
|
|
|
|
static PyObject *
|
|
|
|
|
unicode_to_encoded_python_string (PyObject *unicode_str, const char *charset)
|
|
|
|
|
{
|
|
|
|
|
/* Translate string to named charset. */
|
2012-12-12 17:47:30 +01:00
|
|
|
|
return PyUnicode_AsEncodedString (unicode_str, charset, NULL);
|
2009-07-10 12:35:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
/* Returns a newly allocated string with the contents of the given
|
|
|
|
|
unicode string object converted to the target's charset. If an
|
|
|
|
|
error occurs during the conversion, NULL will be returned and a
|
|
|
|
|
python exception will be set. */
|
|
|
|
|
gdb::unique_xmalloc_ptr<char>
|
2009-02-04 22:55:40 +01:00
|
|
|
|
unicode_to_target_string (PyObject *unicode_str)
|
|
|
|
|
{
|
2010-03-05 21:18:19 +01:00
|
|
|
|
return unicode_to_encoded_string (unicode_str,
|
|
|
|
|
target_charset (python_gdbarch));
|
2008-08-06 21:41:33 +02:00
|
|
|
|
}
|
|
|
|
|
|
2009-07-10 12:35:17 +02:00
|
|
|
|
/* Returns a PyObject with the contents of the given unicode string
|
|
|
|
|
object converted to the target's charset. If an error occurs
|
|
|
|
|
during the conversion, NULL will be returned and a python exception
|
|
|
|
|
will be set. */
|
2012-03-01 22:06:54 +01:00
|
|
|
|
static PyObject *
|
2009-07-10 12:35:17 +02:00
|
|
|
|
unicode_to_target_python_string (PyObject *unicode_str)
|
|
|
|
|
{
|
2010-03-05 21:18:19 +01:00
|
|
|
|
return unicode_to_encoded_python_string (unicode_str,
|
|
|
|
|
target_charset (python_gdbarch));
|
2009-07-10 12:35:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
2008-08-06 21:41:33 +02:00
|
|
|
|
/* Converts a python string (8-bit or unicode) to a target string in
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
the target's charset. Returns NULL on error, with a python
|
|
|
|
|
exception set. */
|
|
|
|
|
gdb::unique_xmalloc_ptr<char>
|
2008-08-06 21:41:33 +02:00
|
|
|
|
python_string_to_target_string (PyObject *obj)
|
|
|
|
|
{
|
2016-11-20 18:52:25 +01:00
|
|
|
|
gdbpy_ref str (python_string_to_unicode (obj));
|
2008-08-06 21:41:33 +02:00
|
|
|
|
if (str == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2016-11-20 18:52:25 +01:00
|
|
|
|
return unicode_to_target_string (str.get ());
|
2008-08-06 21:41:33 +02:00
|
|
|
|
}
|
2009-02-04 22:55:40 +01:00
|
|
|
|
|
2009-07-10 12:35:17 +02:00
|
|
|
|
/* 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
|
2012-12-12 17:47:30 +01:00
|
|
|
|
set.
|
|
|
|
|
|
|
|
|
|
In Python 3, the returned object is a "bytes" object (not a string). */
|
2009-07-10 12:35:17 +02:00
|
|
|
|
PyObject *
|
|
|
|
|
python_string_to_target_python_string (PyObject *obj)
|
|
|
|
|
{
|
2016-11-20 18:52:25 +01:00
|
|
|
|
gdbpy_ref str (python_string_to_unicode (obj));
|
2009-07-10 12:35:17 +02:00
|
|
|
|
if (str == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2016-11-20 18:52:25 +01:00
|
|
|
|
return unicode_to_target_python_string (str.get ());
|
2009-07-10 12:35:17 +02:00
|
|
|
|
}
|
|
|
|
|
|
2009-02-04 22:55:40 +01:00
|
|
|
|
/* Converts a python string (8-bit or unicode) to a target string in
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
the host's charset. Returns NULL on error, with a python exception
|
|
|
|
|
set. */
|
|
|
|
|
gdb::unique_xmalloc_ptr<char>
|
2009-02-04 22:55:40 +01:00
|
|
|
|
python_string_to_host_string (PyObject *obj)
|
|
|
|
|
{
|
2016-11-20 18:52:25 +01:00
|
|
|
|
gdbpy_ref str (python_string_to_unicode (obj));
|
2009-02-04 22:55:40 +01:00
|
|
|
|
if (str == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2016-11-20 18:52:25 +01:00
|
|
|
|
return unicode_to_encoded_string (str.get (), host_charset ());
|
2009-02-04 22:55:40 +01:00
|
|
|
|
}
|
|
|
|
|
|
2016-03-30 08:48:35 +02:00
|
|
|
|
/* Convert a host string to a python string. */
|
|
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
|
host_string_to_python_string (const char *str)
|
|
|
|
|
{
|
|
|
|
|
return PyString_Decode (str, strlen (str), host_charset (), NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2009-02-04 22:55:40 +01:00
|
|
|
|
/* Return true if OBJ is a Python string or unicode object, false
|
|
|
|
|
otherwise. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
gdbpy_is_string (PyObject *obj)
|
|
|
|
|
{
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#ifdef IS_PY3K
|
|
|
|
|
return PyUnicode_Check (obj);
|
|
|
|
|
#else
|
2009-02-04 22:55:40 +01:00
|
|
|
|
return PyString_Check (obj) || PyUnicode_Check (obj);
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#endif
|
2009-02-04 22:55:40 +01:00
|
|
|
|
}
|
2010-05-25 17:27:17 +02:00
|
|
|
|
|
|
|
|
|
/* Return the string representation of OBJ, i.e., str (obj).
|
|
|
|
|
If the result is NULL a python error occurred, the caller must clear it. */
|
|
|
|
|
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
gdb::unique_xmalloc_ptr<char>
|
2010-05-25 17:27:17 +02:00
|
|
|
|
gdbpy_obj_to_string (PyObject *obj)
|
|
|
|
|
{
|
2016-11-20 18:52:25 +01:00
|
|
|
|
gdbpy_ref str_obj (PyObject_Str (obj));
|
2010-05-25 17:27:17 +02:00
|
|
|
|
|
|
|
|
|
if (str_obj != NULL)
|
|
|
|
|
{
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
gdb::unique_xmalloc_ptr<char> msg;
|
|
|
|
|
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#ifdef IS_PY3K
|
2016-11-20 18:52:25 +01:00
|
|
|
|
msg = python_string_to_host_string (str_obj.get ());
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#else
|
2016-11-20 18:52:25 +01:00
|
|
|
|
msg.reset (xstrdup (PyString_AsString (str_obj.get ())));
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#endif
|
2010-05-25 17:27:17 +02:00
|
|
|
|
|
|
|
|
|
return msg;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return the string representation of the exception represented by
|
|
|
|
|
TYPE, VALUE which is assumed to have been obtained with PyErr_Fetch,
|
|
|
|
|
i.e., the error indicator is currently clear.
|
|
|
|
|
If the result is NULL a python error occurred, the caller must clear it. */
|
|
|
|
|
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
gdb::unique_xmalloc_ptr<char>
|
2010-05-25 17:27:17 +02:00
|
|
|
|
gdbpy_exception_to_string (PyObject *ptype, PyObject *pvalue)
|
|
|
|
|
{
|
|
|
|
|
/* There are a few cases to consider.
|
|
|
|
|
For example:
|
|
|
|
|
pvalue is a string when PyErr_SetString is used.
|
|
|
|
|
pvalue is not a string when raise "foo" is used, instead it is None
|
|
|
|
|
and ptype is "foo".
|
|
|
|
|
So the algorithm we use is to print `str (pvalue)' if it's not
|
|
|
|
|
None, otherwise we print `str (ptype)'.
|
|
|
|
|
Using str (aka PyObject_Str) will fetch the error message from
|
|
|
|
|
gdb.GdbError ("message"). */
|
|
|
|
|
|
|
|
|
|
if (pvalue && pvalue != Py_None)
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
return gdbpy_obj_to_string (pvalue);
|
2010-05-25 17:27:17 +02:00
|
|
|
|
else
|
Use unique_xmalloc_ptr in Python code
This changes some utility functions in the Python code to return
unique_xmalloc_ptr, and then fixes up the callers.
I chose unique_xmalloc_ptr rather than std::string because at a few
call points the xmalloc'd string is released and ownership transferred
elsewhere.
This patch found a few existing memory leaks. For example,
py-unwind.c called gdbpy_obj_to_string but never freed the result.
Built and regression tested on the buildbot.
2016-11-09 Tom Tromey <tom@tromey.com>
* varobj.h (varobj_get_display_hint): Change return type.
* varobj.c (varobj_get_display_hint): Return unique_xmalloc_ptr.
(varobj_value_get_print_value): Update.
* python/python.c (gdbpy_before_prompt_hook, gdbpy_print_stack)
(gdbpy_apply_type_printers): Update.
* python/python-internal.h (unicode_to_target_string)
(python_string_to_target_string, python_string_to_host_string)
(gdbpy_obj_to_string, gdbpy_exception_to_string)
(gdbpy_get_display_hint): Change return types.
* python/py-varobj.c (py_varobj_iter_next): Update.
* python/py-value.c (valpy_getitem, convert_value_from_python):
Update.
* python/py-utils.c (unicode_to_encoded_string)
(unicode_to_target_string, python_string_to_target_string)
(python_string_to_host_string, gdbpy_obj_to_string)
(gdbpy_exception_to_string): Return unique_xmalloc_ptr.
* python/py-unwind.c (pyuw_parse_register_id): Update.
* python/py-type.c (typy_getitem): Update.
* python/py-prettyprint.c (gdbpy_get_display_hint)
(print_stack_unless_memory_error, print_children)
(gdbpy_apply_val_pretty_printer): Update.
* python/py-param.c (set_parameter_value): Update.
(get_doc_string, call_doc_function): Return unique_xmalloc_ptr.
(get_set_value, get_show_value, compute_enum_values, parmpy_init):
Update.
* python/py-infthread.c (thpy_set_name): Update.
* python/py-function.c (fnpy_call, fnpy_init): Update.
* python/py-framefilter.c (extract_sym): Change "name" to
unique_xmalloc_ptr.
(enumerate_args, enumerate_locals): Update.
(py_print_frame): Use unique_xmalloc_ptr.
* python/py-frame.c (frapy_read_var): Update. Remove cleanup.
* python/py-cmd.c (cmdpy_function, cmdpy_completer, cmdpy_init):
Update.
* python/py-breakpoint.c (bppy_set_condition): Use
unique_xmalloc_ptr.
(bppy_init): Likewise. Remove cleanup.
(local_setattro): Update.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_list_children)
(varobj_update_one): Update.
2016-10-15 17:20:02 +02:00
|
|
|
|
return gdbpy_obj_to_string (ptype);
|
2010-05-25 17:27:17 +02:00
|
|
|
|
}
|
2010-06-28 23:16:04 +02:00
|
|
|
|
|
2010-11-12 21:49:43 +01:00
|
|
|
|
/* Convert a GDB exception to the appropriate Python exception.
|
2013-11-29 21:00:47 +01:00
|
|
|
|
|
2013-05-20 22:19:03 +02:00
|
|
|
|
This sets the Python error indicator. */
|
2010-11-12 21:49:43 +01:00
|
|
|
|
|
2013-05-20 22:19:03 +02:00
|
|
|
|
void
|
2010-11-12 21:49:43 +01:00
|
|
|
|
gdbpy_convert_exception (struct gdb_exception exception)
|
|
|
|
|
{
|
|
|
|
|
PyObject *exc_class;
|
|
|
|
|
|
|
|
|
|
if (exception.reason == RETURN_QUIT)
|
|
|
|
|
exc_class = PyExc_KeyboardInterrupt;
|
|
|
|
|
else if (exception.error == MEMORY_ERROR)
|
|
|
|
|
exc_class = gdbpy_gdb_memory_error;
|
|
|
|
|
else
|
|
|
|
|
exc_class = gdbpy_gdb_error;
|
|
|
|
|
|
2013-05-20 22:19:03 +02:00
|
|
|
|
PyErr_Format (exc_class, "%s", exception.message);
|
2010-11-12 21:49:43 +01:00
|
|
|
|
}
|
|
|
|
|
|
2010-06-28 23:16:04 +02:00
|
|
|
|
/* Converts OBJ to a CORE_ADDR value.
|
|
|
|
|
|
2013-05-20 22:24:49 +02:00
|
|
|
|
Returns 0 on success or -1 on failure, with a Python exception set.
|
2010-06-28 23:16:04 +02:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
|
|
|
|
|
{
|
|
|
|
|
if (gdbpy_is_value_object (obj))
|
2013-05-20 22:24:49 +02:00
|
|
|
|
{
|
|
|
|
|
|
Split TRY_CATCH into TRY + CATCH
This patch splits the TRY_CATCH macro into three, so that we go from
this:
~~~
volatile gdb_exception ex;
TRY_CATCH (ex, RETURN_MASK_ERROR)
{
}
if (ex.reason < 0)
{
}
~~~
to this:
~~~
TRY
{
}
CATCH (ex, RETURN_MASK_ERROR)
{
}
END_CATCH
~~~
Thus, we'll be getting rid of the local volatile exception object, and
declaring the caught exception in the catch block.
This allows reimplementing TRY/CATCH in terms of C++ exceptions when
building in C++ mode, while still allowing to build GDB in C mode
(using setjmp/longjmp), as a transition step.
TBC, after this patch, is it _not_ valid to have code between the TRY
and the CATCH blocks, like:
TRY
{
}
// some code here.
CATCH (ex, RETURN_MASK_ERROR)
{
}
END_CATCH
Just like it isn't valid to do that with C++'s native try/catch.
By switching to creating the exception object inside the CATCH block
scope, we can get rid of all the explicitly allocated volatile
exception objects all over the tree, and map the CATCH block more
directly to C++'s catch blocks.
The majority of the TRY_CATCH -> TRY+CATCH+END_CATCH conversion was
done with a script, rerun from scratch at every rebase, no manual
editing involved. After the mechanical conversion, a few places
needed manual intervention, to fix preexisting cases where we were
using the exception object outside of the TRY_CATCH block, and cases
where we were using "else" after a 'if (ex.reason) < 0)' [a CATCH
after this patch]. The result was folded into this patch so that GDB
still builds at each incremental step.
END_CATCH is necessary for two reasons:
First, because we name the exception object in the CATCH block, which
requires creating a scope, which in turn must be closed somewhere.
Declaring the exception variable in the initializer field of a for
block, like:
#define CATCH(EXCEPTION, mask) \
for (struct gdb_exception EXCEPTION; \
exceptions_state_mc_catch (&EXCEPTION, MASK); \
EXCEPTION = exception_none)
would avoid needing END_CATCH, but alas, in C mode, we build with C90,
which doesn't allow mixed declarations and code.
Second, because when TRY/CATCH are wired to real C++ try/catch, as
long as we need to handle cleanup chains, even if there's no CATCH
block that wants to catch the exception, we need for stop at every
frame in the unwind chain and run cleanups, then rethrow. That will
be done in END_CATCH.
After we require C++, we'll still need TRY/CATCH/END_CATCH until
cleanups are completely phased out -- TRY/CATCH in C++ mode will
save/restore the current cleanup chain, like in C mode, and END_CATCH
catches otherwise uncaugh exceptions, runs cleanups and rethrows, so
that C++ cleanups and exceptions can coexist.
IMO, this still makes the TRY/CATCH code look a bit more like a
newcomer would expect, so IMO worth it even if we weren't considering
C++.
gdb/ChangeLog.
2015-03-07 Pedro Alves <palves@redhat.com>
* common/common-exceptions.c (struct catcher) <exception>: No
longer a pointer to volatile exception. Now an exception value.
<mask>: Delete field.
(exceptions_state_mc_init): Remove all parameters. Adjust.
(exceptions_state_mc): No longer pop the catcher here.
(exceptions_state_mc_catch): New function.
(throw_exception): Adjust.
* common/common-exceptions.h (exceptions_state_mc_init): Remove
all parameters.
(exceptions_state_mc_catch): Declare.
(TRY_CATCH): Rename to ...
(TRY): ... this. Remove EXCEPTION and MASK parameters.
(CATCH, END_CATCH): New.
All callers adjusted.
gdb/gdbserver/ChangeLog:
2015-03-07 Pedro Alves <palves@redhat.com>
Adjust all callers of TRY_CATCH to use TRY/CATCH/END_CATCH
instead.
2015-03-07 16:14:14 +01:00
|
|
|
|
TRY
|
2013-05-20 22:24:49 +02:00
|
|
|
|
{
|
|
|
|
|
*addr = value_as_address (value_object_to_value (obj));
|
|
|
|
|
}
|
Split TRY_CATCH into TRY + CATCH
This patch splits the TRY_CATCH macro into three, so that we go from
this:
~~~
volatile gdb_exception ex;
TRY_CATCH (ex, RETURN_MASK_ERROR)
{
}
if (ex.reason < 0)
{
}
~~~
to this:
~~~
TRY
{
}
CATCH (ex, RETURN_MASK_ERROR)
{
}
END_CATCH
~~~
Thus, we'll be getting rid of the local volatile exception object, and
declaring the caught exception in the catch block.
This allows reimplementing TRY/CATCH in terms of C++ exceptions when
building in C++ mode, while still allowing to build GDB in C mode
(using setjmp/longjmp), as a transition step.
TBC, after this patch, is it _not_ valid to have code between the TRY
and the CATCH blocks, like:
TRY
{
}
// some code here.
CATCH (ex, RETURN_MASK_ERROR)
{
}
END_CATCH
Just like it isn't valid to do that with C++'s native try/catch.
By switching to creating the exception object inside the CATCH block
scope, we can get rid of all the explicitly allocated volatile
exception objects all over the tree, and map the CATCH block more
directly to C++'s catch blocks.
The majority of the TRY_CATCH -> TRY+CATCH+END_CATCH conversion was
done with a script, rerun from scratch at every rebase, no manual
editing involved. After the mechanical conversion, a few places
needed manual intervention, to fix preexisting cases where we were
using the exception object outside of the TRY_CATCH block, and cases
where we were using "else" after a 'if (ex.reason) < 0)' [a CATCH
after this patch]. The result was folded into this patch so that GDB
still builds at each incremental step.
END_CATCH is necessary for two reasons:
First, because we name the exception object in the CATCH block, which
requires creating a scope, which in turn must be closed somewhere.
Declaring the exception variable in the initializer field of a for
block, like:
#define CATCH(EXCEPTION, mask) \
for (struct gdb_exception EXCEPTION; \
exceptions_state_mc_catch (&EXCEPTION, MASK); \
EXCEPTION = exception_none)
would avoid needing END_CATCH, but alas, in C mode, we build with C90,
which doesn't allow mixed declarations and code.
Second, because when TRY/CATCH are wired to real C++ try/catch, as
long as we need to handle cleanup chains, even if there's no CATCH
block that wants to catch the exception, we need for stop at every
frame in the unwind chain and run cleanups, then rethrow. That will
be done in END_CATCH.
After we require C++, we'll still need TRY/CATCH/END_CATCH until
cleanups are completely phased out -- TRY/CATCH in C++ mode will
save/restore the current cleanup chain, like in C mode, and END_CATCH
catches otherwise uncaugh exceptions, runs cleanups and rethrows, so
that C++ cleanups and exceptions can coexist.
IMO, this still makes the TRY/CATCH code look a bit more like a
newcomer would expect, so IMO worth it even if we weren't considering
C++.
gdb/ChangeLog.
2015-03-07 Pedro Alves <palves@redhat.com>
* common/common-exceptions.c (struct catcher) <exception>: No
longer a pointer to volatile exception. Now an exception value.
<mask>: Delete field.
(exceptions_state_mc_init): Remove all parameters. Adjust.
(exceptions_state_mc): No longer pop the catcher here.
(exceptions_state_mc_catch): New function.
(throw_exception): Adjust.
* common/common-exceptions.h (exceptions_state_mc_init): Remove
all parameters.
(exceptions_state_mc_catch): Declare.
(TRY_CATCH): Rename to ...
(TRY): ... this. Remove EXCEPTION and MASK parameters.
(CATCH, END_CATCH): New.
All callers adjusted.
gdb/gdbserver/ChangeLog:
2015-03-07 Pedro Alves <palves@redhat.com>
Adjust all callers of TRY_CATCH to use TRY/CATCH/END_CATCH
instead.
2015-03-07 16:14:14 +01:00
|
|
|
|
CATCH (except, RETURN_MASK_ALL)
|
|
|
|
|
{
|
|
|
|
|
GDB_PY_SET_HANDLE_EXCEPTION (except);
|
|
|
|
|
}
|
|
|
|
|
END_CATCH
|
2013-05-20 22:24:49 +02:00
|
|
|
|
}
|
2011-01-26 21:53:45 +01:00
|
|
|
|
else
|
2010-06-28 23:16:04 +02:00
|
|
|
|
{
|
2016-11-20 18:52:25 +01:00
|
|
|
|
gdbpy_ref num (PyNumber_Long (obj));
|
2011-01-26 21:53:45 +01:00
|
|
|
|
gdb_py_ulongest val;
|
|
|
|
|
|
|
|
|
|
if (num == NULL)
|
2013-05-20 22:24:49 +02:00
|
|
|
|
return -1;
|
2010-06-28 23:16:04 +02:00
|
|
|
|
|
2016-11-20 18:52:25 +01:00
|
|
|
|
val = gdb_py_long_as_ulongest (num.get ());
|
2011-01-26 21:53:45 +01:00
|
|
|
|
if (PyErr_Occurred ())
|
2013-05-20 22:24:49 +02:00
|
|
|
|
return -1;
|
2010-06-28 23:16:04 +02:00
|
|
|
|
|
2011-01-26 21:53:45 +01:00
|
|
|
|
if (sizeof (val) > sizeof (CORE_ADDR) && ((CORE_ADDR) val) != val)
|
|
|
|
|
{
|
|
|
|
|
PyErr_SetString (PyExc_ValueError,
|
|
|
|
|
_("Overflow converting to address."));
|
2013-05-20 22:24:49 +02:00
|
|
|
|
return -1;
|
2011-01-26 21:53:45 +01:00
|
|
|
|
}
|
2010-06-28 23:16:04 +02:00
|
|
|
|
|
2011-01-26 21:53:45 +01:00
|
|
|
|
*addr = val;
|
2010-06-28 23:16:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2013-05-20 22:24:49 +02:00
|
|
|
|
return 0;
|
2010-06-28 23:16:04 +02:00
|
|
|
|
}
|
2011-01-26 21:53:45 +01:00
|
|
|
|
|
|
|
|
|
/* Convert a LONGEST to the appropriate Python object -- either an
|
|
|
|
|
integer object or a long object, depending on its value. */
|
|
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
|
gdb_py_object_from_longest (LONGEST l)
|
|
|
|
|
{
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#ifdef IS_PY3K
|
|
|
|
|
if (sizeof (l) > sizeof (long))
|
|
|
|
|
return PyLong_FromLongLong (l);
|
|
|
|
|
return PyLong_FromLong (l);
|
|
|
|
|
#else
|
2011-01-26 21:53:45 +01:00
|
|
|
|
#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. */
|
|
|
|
|
if (sizeof (l) > sizeof (long)
|
|
|
|
|
&& (l > PyInt_GetMax () || l < (- (LONGEST) PyInt_GetMax ()) - 1))
|
|
|
|
|
return PyLong_FromLongLong (l);
|
|
|
|
|
#endif
|
|
|
|
|
return PyInt_FromLong (l);
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#endif
|
2011-01-26 21:53:45 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Convert a ULONGEST to the appropriate Python object -- either an
|
|
|
|
|
integer object or a long object, depending on its value. */
|
|
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
|
gdb_py_object_from_ulongest (ULONGEST l)
|
|
|
|
|
{
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#ifdef IS_PY3K
|
|
|
|
|
if (sizeof (l) > sizeof (unsigned long))
|
|
|
|
|
return PyLong_FromUnsignedLongLong (l);
|
|
|
|
|
return PyLong_FromUnsignedLong (l);
|
|
|
|
|
#else
|
2011-01-26 21:53:45 +01:00
|
|
|
|
#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. */
|
|
|
|
|
if (sizeof (l) > sizeof (unsigned long) && l > PyInt_GetMax ())
|
|
|
|
|
return PyLong_FromUnsignedLongLong (l);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (l > PyInt_GetMax ())
|
|
|
|
|
return PyLong_FromUnsignedLong (l);
|
|
|
|
|
|
|
|
|
|
return PyInt_FromLong (l);
|
2012-12-12 17:47:30 +01:00
|
|
|
|
#endif
|
2011-01-26 21:53:45 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Like PyInt_AsLong, but returns 0 on failure, 1 on success, and puts
|
|
|
|
|
the value into an out parameter. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
gdb_py_int_as_long (PyObject *obj, long *result)
|
|
|
|
|
{
|
|
|
|
|
*result = PyInt_AsLong (obj);
|
|
|
|
|
return ! (*result == -1 && PyErr_Occurred ());
|
|
|
|
|
}
|
2012-02-17 20:24:27 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Generic implementation of the __dict__ attribute for objects that
|
|
|
|
|
have a dictionary. The CLOSURE argument should be the type object.
|
|
|
|
|
This only handles positive values for tp_dictoffset. */
|
|
|
|
|
|
|
|
|
|
PyObject *
|
|
|
|
|
gdb_py_generic_dict (PyObject *self, void *closure)
|
|
|
|
|
{
|
|
|
|
|
PyObject *result;
|
2015-09-25 20:08:07 +02:00
|
|
|
|
PyTypeObject *type_obj = (PyTypeObject *) closure;
|
2012-02-17 20:24:27 +01:00
|
|
|
|
char *raw_ptr;
|
|
|
|
|
|
|
|
|
|
raw_ptr = (char *) self + type_obj->tp_dictoffset;
|
|
|
|
|
result = * (PyObject **) raw_ptr;
|
|
|
|
|
|
|
|
|
|
Py_INCREF (result);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
2013-05-20 22:36:19 +02:00
|
|
|
|
|
|
|
|
|
/* Like PyModule_AddObject, but does not steal a reference to
|
|
|
|
|
OBJECT. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
gdb_pymodule_addobject (PyObject *module, const char *name, PyObject *object)
|
|
|
|
|
{
|
|
|
|
|
int result;
|
|
|
|
|
|
|
|
|
|
Py_INCREF (object);
|
2013-06-05 19:32:51 +02:00
|
|
|
|
/* Python 2.4 did not have a 'const' here. */
|
|
|
|
|
result = PyModule_AddObject (module, (char *) name, object);
|
2013-05-20 22:36:19 +02:00
|
|
|
|
if (result < 0)
|
2013-05-21 22:52:30 +02:00
|
|
|
|
Py_DECREF (object);
|
2013-05-20 22:36:19 +02:00
|
|
|
|
return result;
|
|
|
|
|
}
|