]> Git Repo - binutils.git/blob - gdb/python/py-utils.c
e07da034e34175b3622637b7395afc0260f6e5d0
[binutils.git] / gdb / python / py-utils.c
1 /* General utility routines for GDB/Python.
2
3    Copyright (C) 2008-2019 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "charset.h"
22 #include "value.h"
23 #include "python-internal.h"
24
25 /* Converts a Python 8-bit string to a unicode string object.  Assumes the
26    8-bit string is in the host charset.  If an error occurs during conversion,
27    returns NULL with a python exception set.
28
29    As an added bonus, the functions accepts a unicode string and returns it
30    right away, so callers don't need to check which kind of string they've
31    got.  In Python 3, all strings are Unicode so this case is always the
32    one that applies.
33
34    If the given object is not one of the mentioned string types, NULL is
35    returned, with the TypeError python exception set.  */
36 gdbpy_ref<>
37 python_string_to_unicode (PyObject *obj)
38 {
39   PyObject *unicode_str;
40
41   /* If obj is already a unicode string, just return it.
42      I wish life was always that simple...  */
43   if (PyUnicode_Check (obj))
44     {
45       unicode_str = obj;
46       Py_INCREF (obj);
47     }
48 #ifndef IS_PY3K
49   else if (PyString_Check (obj))
50     unicode_str = PyUnicode_FromEncodedObject (obj, host_charset (), NULL);
51 #endif
52   else
53     {
54       PyErr_SetString (PyExc_TypeError,
55                        _("Expected a string or unicode object."));
56       unicode_str = NULL;
57     }
58
59   return gdbpy_ref<> (unicode_str);
60 }
61
62 /* Returns a newly allocated string with the contents of the given unicode
63    string object converted to CHARSET.  If an error occurs during the
64    conversion, NULL will be returned and a python exception will be
65    set.  */
66 static gdb::unique_xmalloc_ptr<char>
67 unicode_to_encoded_string (PyObject *unicode_str, const char *charset)
68 {
69   /* Translate string to named charset.  */
70   gdbpy_ref<> string (PyUnicode_AsEncodedString (unicode_str, charset, NULL));
71   if (string == NULL)
72     return NULL;
73
74   return gdb::unique_xmalloc_ptr<char>
75     (xstrdup (PyBytes_AsString (string.get ())));
76 }
77
78 /* Returns a PyObject with the contents of the given unicode string
79    object converted to a named charset.  If an error occurs during
80    the conversion, NULL will be returned and a python exception will
81    be set.  */
82 static gdbpy_ref<>
83 unicode_to_encoded_python_string (PyObject *unicode_str, const char *charset)
84 {
85   /* Translate string to named charset.  */
86   return gdbpy_ref<> (PyUnicode_AsEncodedString (unicode_str, charset, NULL));
87 }
88
89 /* Returns a newly allocated string with the contents of the given
90    unicode string object converted to the target's charset.  If an
91    error occurs during the conversion, NULL will be returned and a
92    python exception will be set.  */
93 gdb::unique_xmalloc_ptr<char>
94 unicode_to_target_string (PyObject *unicode_str)
95 {
96   return unicode_to_encoded_string (unicode_str,
97                                     target_charset (python_gdbarch));
98 }
99
100 /* Returns a PyObject with the contents of the given unicode string
101    object converted to the target's charset.  If an error occurs
102    during the conversion, NULL will be returned and a python exception
103    will be set.  */
104 static gdbpy_ref<>
105 unicode_to_target_python_string (PyObject *unicode_str)
106 {
107   return unicode_to_encoded_python_string (unicode_str,
108                                            target_charset (python_gdbarch));
109 }
110
111 /* Converts a python string (8-bit or unicode) to a target string in
112    the target's charset.  Returns NULL on error, with a python
113    exception set.  */
114 gdb::unique_xmalloc_ptr<char>
115 python_string_to_target_string (PyObject *obj)
116 {
117   gdbpy_ref<> str = python_string_to_unicode (obj);
118   if (str == NULL)
119     return NULL;
120
121   return unicode_to_target_string (str.get ());
122 }
123
124 /* Converts a python string (8-bit or unicode) to a target string in the
125    target's charset.  Returns NULL on error, with a python exception
126    set.
127
128    In Python 3, the returned object is a "bytes" object (not a string).  */
129 gdbpy_ref<>
130 python_string_to_target_python_string (PyObject *obj)
131 {
132   gdbpy_ref<> str = python_string_to_unicode (obj);
133   if (str == NULL)
134     return str;
135
136   return unicode_to_target_python_string (str.get ());
137 }
138
139 /* Converts a python string (8-bit or unicode) to a target string in
140    the host's charset.  Returns NULL on error, with a python exception
141    set.  */
142 gdb::unique_xmalloc_ptr<char>
143 python_string_to_host_string (PyObject *obj)
144 {
145   gdbpy_ref<> str = python_string_to_unicode (obj);
146   if (str == NULL)
147     return NULL;
148
149   return unicode_to_encoded_string (str.get (), host_charset ());
150 }
151
152 /* Convert a host string to a python string.  */
153
154 gdbpy_ref<>
155 host_string_to_python_string (const char *str)
156 {
157   return gdbpy_ref<> (PyString_Decode (str, strlen (str), host_charset (),
158                                        NULL));
159 }
160
161 /* Return true if OBJ is a Python string or unicode object, false
162    otherwise.  */
163
164 int
165 gdbpy_is_string (PyObject *obj)
166 {
167 #ifdef IS_PY3K
168   return PyUnicode_Check (obj);
169 #else
170   return PyString_Check (obj) || PyUnicode_Check (obj);
171 #endif
172 }
173
174 /* Return the string representation of OBJ, i.e., str (obj).
175    If the result is NULL a python error occurred, the caller must clear it.  */
176
177 gdb::unique_xmalloc_ptr<char>
178 gdbpy_obj_to_string (PyObject *obj)
179 {
180   gdbpy_ref<> str_obj (PyObject_Str (obj));
181
182   if (str_obj != NULL)
183     {
184       gdb::unique_xmalloc_ptr<char> msg;
185
186 #ifdef IS_PY3K
187       msg = python_string_to_host_string (str_obj.get ());
188 #else
189       msg.reset (xstrdup (PyString_AsString (str_obj.get ())));
190 #endif
191
192       return msg;
193     }
194
195   return NULL;
196 }
197
198 /* See python-internal.h.  */
199
200 gdb::unique_xmalloc_ptr<char>
201 gdbpy_err_fetch::to_string () const
202 {
203   /* There are a few cases to consider.
204      For example:
205      value is a string when PyErr_SetString is used.
206      value is not a string when raise "foo" is used, instead it is None
207      and type is "foo".
208      So the algorithm we use is to print `str (value)' if it's not
209      None, otherwise we print `str (type)'.
210      Using str (aka PyObject_Str) will fetch the error message from
211      gdb.GdbError ("message").  */
212
213   if (m_error_value && m_error_value != Py_None)
214     return gdbpy_obj_to_string (m_error_value);
215   else
216     return gdbpy_obj_to_string (m_error_type);
217 }
218
219 /* See python-internal.h.  */
220
221 gdb::unique_xmalloc_ptr<char>
222 gdbpy_err_fetch::type_to_string () const
223 {
224   return gdbpy_obj_to_string (m_error_type);
225 }
226
227 /* Convert a GDB exception to the appropriate Python exception.
228
229    This sets the Python error indicator.  */
230
231 void
232 gdbpy_convert_exception (const struct gdb_exception &exception)
233 {
234   PyObject *exc_class;
235
236   if (exception.reason == RETURN_QUIT)
237     exc_class = PyExc_KeyboardInterrupt;
238   else if (exception.error == MEMORY_ERROR)
239     exc_class = gdbpy_gdb_memory_error;
240   else
241     exc_class = gdbpy_gdb_error;
242
243   PyErr_Format (exc_class, "%s", exception.what ());
244 }
245
246 /* Converts OBJ to a CORE_ADDR value.
247
248    Returns 0 on success or -1 on failure, with a Python exception set.
249 */
250
251 int
252 get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
253 {
254   if (gdbpy_is_value_object (obj))
255     {
256
257       try
258         {
259           *addr = value_as_address (value_object_to_value (obj));
260         }
261       catch (const gdb_exception &except)
262         {
263           GDB_PY_SET_HANDLE_EXCEPTION (except);
264         }
265     }
266   else
267     {
268       gdbpy_ref<> num (PyNumber_Long (obj));
269       gdb_py_ulongest val;
270
271       if (num == NULL)
272         return -1;
273
274       val = gdb_py_long_as_ulongest (num.get ());
275       if (PyErr_Occurred ())
276         return -1;
277
278       if (sizeof (val) > sizeof (CORE_ADDR) && ((CORE_ADDR) val) != val)
279         {
280           PyErr_SetString (PyExc_ValueError,
281                            _("Overflow converting to address."));
282           return -1;
283         }
284
285       *addr = val;
286     }
287
288   return 0;
289 }
290
291 /* Convert a LONGEST to the appropriate Python object -- either an
292    integer object or a long object, depending on its value.  */
293
294 gdbpy_ref<>
295 gdb_py_object_from_longest (LONGEST l)
296 {
297 #ifdef IS_PY3K
298   if (sizeof (l) > sizeof (long))
299     return gdbpy_ref<> (PyLong_FromLongLong (l));
300   return gdbpy_ref<> (PyLong_FromLong (l));
301 #else
302 #ifdef HAVE_LONG_LONG           /* Defined by Python.  */
303   /* If we have 'long long', and the value overflows a 'long', use a
304      Python Long; otherwise use a Python Int.  */
305   if (sizeof (l) > sizeof (long)
306       && (l > PyInt_GetMax () || l < (- (LONGEST) PyInt_GetMax ()) - 1))
307     return gdbpy_ref<> (PyLong_FromLongLong (l));
308 #endif
309   return gdbpy_ref<> (PyInt_FromLong (l));
310 #endif
311 }
312
313 /* Convert a ULONGEST to the appropriate Python object -- either an
314    integer object or a long object, depending on its value.  */
315
316 gdbpy_ref<>
317 gdb_py_object_from_ulongest (ULONGEST l)
318 {
319 #ifdef IS_PY3K
320   if (sizeof (l) > sizeof (unsigned long))
321     return gdbpy_ref<> (PyLong_FromUnsignedLongLong (l));
322   return gdbpy_ref<> (PyLong_FromUnsignedLong (l));
323 #else
324 #ifdef HAVE_LONG_LONG           /* Defined by Python.  */
325   /* If we have 'long long', and the value overflows a 'long', use a
326      Python Long; otherwise use a Python Int.  */
327   if (sizeof (l) > sizeof (unsigned long) && l > PyInt_GetMax ())
328     return gdbpy_ref<> (PyLong_FromUnsignedLongLong (l));
329 #endif
330
331   if (l > PyInt_GetMax ())
332     return gdbpy_ref<> (PyLong_FromUnsignedLong (l));
333
334   return gdbpy_ref<> (PyInt_FromLong (l));
335 #endif
336 }
337
338 /* Like PyInt_AsLong, but returns 0 on failure, 1 on success, and puts
339    the value into an out parameter.  */
340
341 int
342 gdb_py_int_as_long (PyObject *obj, long *result)
343 {
344   *result = PyInt_AsLong (obj);
345   return ! (*result == -1 && PyErr_Occurred ());
346 }
347
348 \f
349
350 /* Generic implementation of the __dict__ attribute for objects that
351    have a dictionary.  The CLOSURE argument should be the type object.
352    This only handles positive values for tp_dictoffset.  */
353
354 PyObject *
355 gdb_py_generic_dict (PyObject *self, void *closure)
356 {
357   PyObject *result;
358   PyTypeObject *type_obj = (PyTypeObject *) closure;
359   char *raw_ptr;
360
361   raw_ptr = (char *) self + type_obj->tp_dictoffset;
362   result = * (PyObject **) raw_ptr;
363
364   Py_INCREF (result);
365   return result;
366 }
367
368 /* Like PyModule_AddObject, but does not steal a reference to
369    OBJECT.  */
370
371 int
372 gdb_pymodule_addobject (PyObject *module, const char *name, PyObject *object)
373 {
374   int result;
375
376   Py_INCREF (object);
377   result = PyModule_AddObject (module, name, object);
378   if (result < 0)
379     Py_DECREF (object);
380   return result;
381 }
382
383 /* Handle a Python exception when the special gdb.GdbError treatment
384    is desired.  This should only be called when an exception is set.
385    If the exception is a gdb.GdbError, throw a gdb exception with the
386    exception text.  For other exceptions, print the Python stack and
387    then throw a gdb exception.  */
388
389 void
390 gdbpy_handle_exception ()
391 {
392   gdbpy_err_fetch fetched_error;
393   gdb::unique_xmalloc_ptr<char> msg = fetched_error.to_string ();
394
395   if (msg == NULL)
396     {
397       /* An error occurred computing the string representation of the
398          error message.  This is rare, but we should inform the user.  */
399       printf_filtered (_("An error occurred in Python "
400                          "and then another occurred computing the "
401                          "error message.\n"));
402       gdbpy_print_stack ();
403     }
404
405   /* Don't print the stack for gdb.GdbError exceptions.
406      It is generally used to flag user errors.
407
408      We also don't want to print "Error occurred in Python command"
409      for user errors.  However, a missing message for gdb.GdbError
410      exceptions is arguably a bug, so we flag it as such.  */
411
412   if (fetched_error.type_matches (PyExc_KeyboardInterrupt))
413     throw_quit ("Quit");
414   else if (! fetched_error.type_matches (gdbpy_gdberror_exc)
415            || msg == NULL || *msg == '\0')
416     {
417       fetched_error.restore ();
418       gdbpy_print_stack ();
419       if (msg != NULL && *msg != '\0')
420         error (_("Error occurred in Python: %s"), msg.get ());
421       else
422         error (_("Error occurred in Python."));
423     }
424   else
425     error ("%s", msg.get ());
426 }
This page took 0.038867 seconds and 2 git commands to generate.