1 /* General utility routines for GDB/Python.
2
3 Copyright (C) 2008-2013 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
26 /* This is a cleanup function which decrements the refcount on a
27 Python object. */
28
29 static void
py_decref(void * p)30 py_decref (void *p)
31 {
32 PyObject *py = p;
33
34 /* Note that we need the extra braces in this 'if' to avoid a
35 warning from gcc. */
36 if (py)
37 {
38 Py_DECREF (py);
39 }
40 }
41
42 /* Return a new cleanup which will decrement the Python object's
43 refcount when run. */
44
45 struct cleanup *
make_cleanup_py_decref(PyObject * py)46 make_cleanup_py_decref (PyObject *py)
47 {
48 return make_cleanup (py_decref, (void *) py);
49 }
50
51 /* Converts a Python 8-bit string to a unicode string object. Assumes the
52 8-bit string is in the host charset. If an error occurs during conversion,
53 returns NULL with a python exception set.
54
55 As an added bonus, the functions accepts a unicode string and returns it
56 right away, so callers don't need to check which kind of string they've
57 got. In Python 3, all strings are Unicode so this case is always the
58 one that applies.
59
60 If the given object is not one of the mentioned string types, NULL is
61 returned, with the TypeError python exception set. */
62 PyObject *
python_string_to_unicode(PyObject * obj)63 python_string_to_unicode (PyObject *obj)
64 {
65 PyObject *unicode_str;
66
67 /* If obj is already a unicode string, just return it.
68 I wish life was always that simple... */
69 if (PyUnicode_Check (obj))
70 {
71 unicode_str = obj;
72 Py_INCREF (obj);
73 }
74 #ifndef IS_PY3K
75 else if (PyString_Check (obj))
76 unicode_str = PyUnicode_FromEncodedObject (obj, host_charset (), NULL);
77 #endif
78 else
79 {
80 PyErr_SetString (PyExc_TypeError,
81 _("Expected a string or unicode object."));
82 unicode_str = NULL;
83 }
84
85 return unicode_str;
86 }
87
88 /* Returns a newly allocated string with the contents of the given unicode
89 string object converted to CHARSET. If an error occurs during the
90 conversion, NULL will be returned and a python exception will be set.
91
92 The caller is responsible for xfree'ing the string. */
93 static char *
unicode_to_encoded_string(PyObject * unicode_str,const char * charset)94 unicode_to_encoded_string (PyObject *unicode_str, const char *charset)
95 {
96 char *result;
97 PyObject *string;
98
99 /* Translate string to named charset. */
100 string = PyUnicode_AsEncodedString (unicode_str, charset, NULL);
101 if (string == NULL)
102 return NULL;
103
104 #ifdef IS_PY3K
105 result = xstrdup (PyBytes_AsString (string));
106 #else
107 result = xstrdup (PyString_AsString (string));
108 #endif
109
110 Py_DECREF (string);
111
112 return result;
113 }
114
115 /* Returns a PyObject with the contents of the given unicode string
116 object converted to a named charset. If an error occurs during
117 the conversion, NULL will be returned and a python exception will
118 be set. */
119 static PyObject *
unicode_to_encoded_python_string(PyObject * unicode_str,const char * charset)120 unicode_to_encoded_python_string (PyObject *unicode_str, const char *charset)
121 {
122 /* Translate string to named charset. */
123 return PyUnicode_AsEncodedString (unicode_str, charset, NULL);
124 }
125
126 /* Returns a newly allocated string with the contents of the given unicode
127 string object converted to the target's charset. If an error occurs during
128 the conversion, NULL will be returned and a python exception will be set.
129
130 The caller is responsible for xfree'ing the string. */
131 char *
unicode_to_target_string(PyObject * unicode_str)132 unicode_to_target_string (PyObject *unicode_str)
133 {
134 return unicode_to_encoded_string (unicode_str,
135 target_charset (python_gdbarch));
136 }
137
138 /* Returns a PyObject with the contents of the given unicode string
139 object converted to the target's charset. If an error occurs
140 during the conversion, NULL will be returned and a python exception
141 will be set. */
142 static PyObject *
unicode_to_target_python_string(PyObject * unicode_str)143 unicode_to_target_python_string (PyObject *unicode_str)
144 {
145 return unicode_to_encoded_python_string (unicode_str,
146 target_charset (python_gdbarch));
147 }
148
149 /* Converts a python string (8-bit or unicode) to a target string in
150 the target's charset. Returns NULL on error, with a python exception set.
151
152 The caller is responsible for xfree'ing the string. */
153 char *
python_string_to_target_string(PyObject * obj)154 python_string_to_target_string (PyObject *obj)
155 {
156 PyObject *str;
157 char *result;
158
159 str = python_string_to_unicode (obj);
160 if (str == NULL)
161 return NULL;
162
163 result = unicode_to_target_string (str);
164 Py_DECREF (str);
165 return result;
166 }
167
168 /* Converts a python string (8-bit or unicode) to a target string in the
169 target's charset. Returns NULL on error, with a python exception
170 set.
171
172 In Python 3, the returned object is a "bytes" object (not a string). */
173 PyObject *
python_string_to_target_python_string(PyObject * obj)174 python_string_to_target_python_string (PyObject *obj)
175 {
176 PyObject *str;
177 PyObject *result;
178
179 str = python_string_to_unicode (obj);
180 if (str == NULL)
181 return NULL;
182
183 result = unicode_to_target_python_string (str);
184 Py_DECREF (str);
185 return result;
186 }
187
188 /* Converts a python string (8-bit or unicode) to a target string in
189 the host's charset. Returns NULL on error, with a python exception set.
190
191 The caller is responsible for xfree'ing the string. */
192 char *
python_string_to_host_string(PyObject * obj)193 python_string_to_host_string (PyObject *obj)
194 {
195 PyObject *str;
196 char *result;
197
198 str = python_string_to_unicode (obj);
199 if (str == NULL)
200 return NULL;
201
202 result = unicode_to_encoded_string (str, host_charset ());
203 Py_DECREF (str);
204 return result;
205 }
206
207 /* Return true if OBJ is a Python string or unicode object, false
208 otherwise. */
209
210 int
gdbpy_is_string(PyObject * obj)211 gdbpy_is_string (PyObject *obj)
212 {
213 #ifdef IS_PY3K
214 return PyUnicode_Check (obj);
215 #else
216 return PyString_Check (obj) || PyUnicode_Check (obj);
217 #endif
218 }
219
220 /* Return the string representation of OBJ, i.e., str (obj).
221 Space for the result is malloc'd, the caller must free.
222 If the result is NULL a python error occurred, the caller must clear it. */
223
224 char *
gdbpy_obj_to_string(PyObject * obj)225 gdbpy_obj_to_string (PyObject *obj)
226 {
227 PyObject *str_obj = PyObject_Str (obj);
228
229 if (str_obj != NULL)
230 {
231 #ifdef IS_PY3K
232 char *msg = python_string_to_host_string (str_obj);
233 #else
234 char *msg = xstrdup (PyString_AsString (str_obj));
235 #endif
236
237 Py_DECREF (str_obj);
238 return msg;
239 }
240
241 return NULL;
242 }
243
244 /* Return the string representation of the exception represented by
245 TYPE, VALUE which is assumed to have been obtained with PyErr_Fetch,
246 i.e., the error indicator is currently clear.
247 Space for the result is malloc'd, the caller must free.
248 If the result is NULL a python error occurred, the caller must clear it. */
249
250 char *
gdbpy_exception_to_string(PyObject * ptype,PyObject * pvalue)251 gdbpy_exception_to_string (PyObject *ptype, PyObject *pvalue)
252 {
253 char *str;
254
255 /* There are a few cases to consider.
256 For example:
257 pvalue is a string when PyErr_SetString is used.
258 pvalue is not a string when raise "foo" is used, instead it is None
259 and ptype is "foo".
260 So the algorithm we use is to print `str (pvalue)' if it's not
261 None, otherwise we print `str (ptype)'.
262 Using str (aka PyObject_Str) will fetch the error message from
263 gdb.GdbError ("message"). */
264
265 if (pvalue && pvalue != Py_None)
266 str = gdbpy_obj_to_string (pvalue);
267 else
268 str = gdbpy_obj_to_string (ptype);
269
270 return str;
271 }
272
273 /* Convert a GDB exception to the appropriate Python exception.
274
275 This sets the Python error indicator, and returns NULL. */
276
277 PyObject *
gdbpy_convert_exception(struct gdb_exception exception)278 gdbpy_convert_exception (struct gdb_exception exception)
279 {
280 PyObject *exc_class;
281
282 if (exception.reason == RETURN_QUIT)
283 exc_class = PyExc_KeyboardInterrupt;
284 else if (exception.error == MEMORY_ERROR)
285 exc_class = gdbpy_gdb_memory_error;
286 else
287 exc_class = gdbpy_gdb_error;
288
289 return PyErr_Format (exc_class, "%s", exception.message);
290 }
291
292 /* Converts OBJ to a CORE_ADDR value.
293
294 Returns 1 on success or 0 on failure, with a Python exception set. This
295 function can also throw GDB exceptions.
296 */
297
298 int
get_addr_from_python(PyObject * obj,CORE_ADDR * addr)299 get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
300 {
301 if (gdbpy_is_value_object (obj))
302 *addr = value_as_address (value_object_to_value (obj));
303 else
304 {
305 PyObject *num = PyNumber_Long (obj);
306 gdb_py_ulongest val;
307
308 if (num == NULL)
309 return 0;
310
311 val = gdb_py_long_as_ulongest (num);
312 Py_XDECREF (num);
313 if (PyErr_Occurred ())
314 return 0;
315
316 if (sizeof (val) > sizeof (CORE_ADDR) && ((CORE_ADDR) val) != val)
317 {
318 PyErr_SetString (PyExc_ValueError,
319 _("Overflow converting to address."));
320 return 0;
321 }
322
323 *addr = val;
324 }
325
326 return 1;
327 }
328
329 /* Convert a LONGEST to the appropriate Python object -- either an
330 integer object or a long object, depending on its value. */
331
332 PyObject *
gdb_py_object_from_longest(LONGEST l)333 gdb_py_object_from_longest (LONGEST l)
334 {
335 #ifdef IS_PY3K
336 if (sizeof (l) > sizeof (long))
337 return PyLong_FromLongLong (l);
338 return PyLong_FromLong (l);
339 #else
340 #ifdef HAVE_LONG_LONG /* Defined by Python. */
341 /* If we have 'long long', and the value overflows a 'long', use a
342 Python Long; otherwise use a Python Int. */
343 if (sizeof (l) > sizeof (long)
344 && (l > PyInt_GetMax () || l < (- (LONGEST) PyInt_GetMax ()) - 1))
345 return PyLong_FromLongLong (l);
346 #endif
347 return PyInt_FromLong (l);
348 #endif
349 }
350
351 /* Convert a ULONGEST to the appropriate Python object -- either an
352 integer object or a long object, depending on its value. */
353
354 PyObject *
gdb_py_object_from_ulongest(ULONGEST l)355 gdb_py_object_from_ulongest (ULONGEST l)
356 {
357 #ifdef IS_PY3K
358 if (sizeof (l) > sizeof (unsigned long))
359 return PyLong_FromUnsignedLongLong (l);
360 return PyLong_FromUnsignedLong (l);
361 #else
362 #ifdef HAVE_LONG_LONG /* Defined by Python. */
363 /* If we have 'long long', and the value overflows a 'long', use a
364 Python Long; otherwise use a Python Int. */
365 if (sizeof (l) > sizeof (unsigned long) && l > PyInt_GetMax ())
366 return PyLong_FromUnsignedLongLong (l);
367 #endif
368
369 if (l > PyInt_GetMax ())
370 return PyLong_FromUnsignedLong (l);
371
372 return PyInt_FromLong (l);
373 #endif
374 }
375
376 /* Like PyInt_AsLong, but returns 0 on failure, 1 on success, and puts
377 the value into an out parameter. */
378
379 int
gdb_py_int_as_long(PyObject * obj,long * result)380 gdb_py_int_as_long (PyObject *obj, long *result)
381 {
382 *result = PyInt_AsLong (obj);
383 return ! (*result == -1 && PyErr_Occurred ());
384 }
385
386
387
388 /* Generic implementation of the __dict__ attribute for objects that
389 have a dictionary. The CLOSURE argument should be the type object.
390 This only handles positive values for tp_dictoffset. */
391
392 PyObject *
gdb_py_generic_dict(PyObject * self,void * closure)393 gdb_py_generic_dict (PyObject *self, void *closure)
394 {
395 PyObject *result;
396 PyTypeObject *type_obj = closure;
397 char *raw_ptr;
398
399 raw_ptr = (char *) self + type_obj->tp_dictoffset;
400 result = * (PyObject **) raw_ptr;
401
402 Py_INCREF (result);
403 return result;
404 }
405