py-utils.c revision 1.8
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. */ 36gdbpy_ref<> 37python_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. */ 66static gdb::unique_xmalloc_ptr<char> 67unicode_to_encoded_string (PyObject *unicode_str, const char *charset) 68{ 69 gdb::unique_xmalloc_ptr<char> result; 70 71 /* Translate string to named charset. */ 72 gdbpy_ref<> string (PyUnicode_AsEncodedString (unicode_str, charset, NULL)); 73 if (string == NULL) 74 return NULL; 75 76#ifdef IS_PY3K 77 result.reset (xstrdup (PyBytes_AsString (string.get ()))); 78#else 79 result.reset (xstrdup (PyString_AsString (string.get ()))); 80#endif 81 82 return result; 83} 84 85/* Returns a PyObject with the contents of the given unicode string 86 object converted to a named charset. If an error occurs during 87 the conversion, NULL will be returned and a python exception will 88 be set. */ 89static gdbpy_ref<> 90unicode_to_encoded_python_string (PyObject *unicode_str, const char *charset) 91{ 92 /* Translate string to named charset. */ 93 return gdbpy_ref<> (PyUnicode_AsEncodedString (unicode_str, charset, NULL)); 94} 95 96/* Returns a newly allocated string with the contents of the given 97 unicode string object converted to the target's charset. If an 98 error occurs during the conversion, NULL will be returned and a 99 python exception will be set. */ 100gdb::unique_xmalloc_ptr<char> 101unicode_to_target_string (PyObject *unicode_str) 102{ 103 return unicode_to_encoded_string (unicode_str, 104 target_charset (python_gdbarch)); 105} 106 107/* Returns a PyObject with the contents of the given unicode string 108 object converted to the target's charset. If an error occurs 109 during the conversion, NULL will be returned and a python exception 110 will be set. */ 111static gdbpy_ref<> 112unicode_to_target_python_string (PyObject *unicode_str) 113{ 114 return unicode_to_encoded_python_string (unicode_str, 115 target_charset (python_gdbarch)); 116} 117 118/* Converts a python string (8-bit or unicode) to a target string in 119 the target's charset. Returns NULL on error, with a python 120 exception set. */ 121gdb::unique_xmalloc_ptr<char> 122python_string_to_target_string (PyObject *obj) 123{ 124 gdbpy_ref<> str = python_string_to_unicode (obj); 125 if (str == NULL) 126 return NULL; 127 128 return unicode_to_target_string (str.get ()); 129} 130 131/* Converts a python string (8-bit or unicode) to a target string in the 132 target's charset. Returns NULL on error, with a python exception 133 set. 134 135 In Python 3, the returned object is a "bytes" object (not a string). */ 136gdbpy_ref<> 137python_string_to_target_python_string (PyObject *obj) 138{ 139 gdbpy_ref<> str = python_string_to_unicode (obj); 140 if (str == NULL) 141 return str; 142 143 return unicode_to_target_python_string (str.get ()); 144} 145 146/* Converts a python string (8-bit or unicode) to a target string in 147 the host's charset. Returns NULL on error, with a python exception 148 set. */ 149gdb::unique_xmalloc_ptr<char> 150python_string_to_host_string (PyObject *obj) 151{ 152 gdbpy_ref<> str = python_string_to_unicode (obj); 153 if (str == NULL) 154 return NULL; 155 156 return unicode_to_encoded_string (str.get (), host_charset ()); 157} 158 159/* Convert a host string to a python string. */ 160 161gdbpy_ref<> 162host_string_to_python_string (const char *str) 163{ 164 return gdbpy_ref<> (PyString_Decode (str, strlen (str), host_charset (), 165 NULL)); 166} 167 168/* Return true if OBJ is a Python string or unicode object, false 169 otherwise. */ 170 171int 172gdbpy_is_string (PyObject *obj) 173{ 174#ifdef IS_PY3K 175 return PyUnicode_Check (obj); 176#else 177 return PyString_Check (obj) || PyUnicode_Check (obj); 178#endif 179} 180 181/* Return the string representation of OBJ, i.e., str (obj). 182 If the result is NULL a python error occurred, the caller must clear it. */ 183 184gdb::unique_xmalloc_ptr<char> 185gdbpy_obj_to_string (PyObject *obj) 186{ 187 gdbpy_ref<> str_obj (PyObject_Str (obj)); 188 189 if (str_obj != NULL) 190 { 191 gdb::unique_xmalloc_ptr<char> msg; 192 193#ifdef IS_PY3K 194 msg = python_string_to_host_string (str_obj.get ()); 195#else 196 msg.reset (xstrdup (PyString_AsString (str_obj.get ()))); 197#endif 198 199 return msg; 200 } 201 202 return NULL; 203} 204 205/* See python-internal.h. */ 206 207gdb::unique_xmalloc_ptr<char> 208gdbpy_err_fetch::to_string () const 209{ 210 /* There are a few cases to consider. 211 For example: 212 value is a string when PyErr_SetString is used. 213 value is not a string when raise "foo" is used, instead it is None 214 and type is "foo". 215 So the algorithm we use is to print `str (value)' if it's not 216 None, otherwise we print `str (type)'. 217 Using str (aka PyObject_Str) will fetch the error message from 218 gdb.GdbError ("message"). */ 219 220 if (m_error_value && m_error_value != Py_None) 221 return gdbpy_obj_to_string (m_error_value); 222 else 223 return gdbpy_obj_to_string (m_error_type); 224} 225 226/* See python-internal.h. */ 227 228gdb::unique_xmalloc_ptr<char> 229gdbpy_err_fetch::type_to_string () const 230{ 231 return gdbpy_obj_to_string (m_error_type); 232} 233 234/* Convert a GDB exception to the appropriate Python exception. 235 236 This sets the Python error indicator. */ 237 238void 239gdbpy_convert_exception (struct gdb_exception exception) 240{ 241 PyObject *exc_class; 242 243 if (exception.reason == RETURN_QUIT) 244 exc_class = PyExc_KeyboardInterrupt; 245 else if (exception.error == MEMORY_ERROR) 246 exc_class = gdbpy_gdb_memory_error; 247 else 248 exc_class = gdbpy_gdb_error; 249 250 PyErr_Format (exc_class, "%s", exception.message); 251} 252 253/* Converts OBJ to a CORE_ADDR value. 254 255 Returns 0 on success or -1 on failure, with a Python exception set. 256*/ 257 258int 259get_addr_from_python (PyObject *obj, CORE_ADDR *addr) 260{ 261 if (gdbpy_is_value_object (obj)) 262 { 263 264 TRY 265 { 266 *addr = value_as_address (value_object_to_value (obj)); 267 } 268 CATCH (except, RETURN_MASK_ALL) 269 { 270 GDB_PY_SET_HANDLE_EXCEPTION (except); 271 } 272 END_CATCH 273 } 274 else 275 { 276 gdbpy_ref<> num (PyNumber_Long (obj)); 277 gdb_py_ulongest val; 278 279 if (num == NULL) 280 return -1; 281 282 val = gdb_py_long_as_ulongest (num.get ()); 283 if (PyErr_Occurred ()) 284 return -1; 285 286 if (sizeof (val) > sizeof (CORE_ADDR) && ((CORE_ADDR) val) != val) 287 { 288 PyErr_SetString (PyExc_ValueError, 289 _("Overflow converting to address.")); 290 return -1; 291 } 292 293 *addr = val; 294 } 295 296 return 0; 297} 298 299/* Convert a LONGEST to the appropriate Python object -- either an 300 integer object or a long object, depending on its value. */ 301 302gdbpy_ref<> 303gdb_py_object_from_longest (LONGEST l) 304{ 305#ifdef IS_PY3K 306 if (sizeof (l) > sizeof (long)) 307 return gdbpy_ref<> (PyLong_FromLongLong (l)); 308 return gdbpy_ref<> (PyLong_FromLong (l)); 309#else 310#ifdef HAVE_LONG_LONG /* Defined by Python. */ 311 /* If we have 'long long', and the value overflows a 'long', use a 312 Python Long; otherwise use a Python Int. */ 313 if (sizeof (l) > sizeof (long) 314 && (l > PyInt_GetMax () || l < (- (LONGEST) PyInt_GetMax ()) - 1)) 315 return gdbpy_ref<> (PyLong_FromLongLong (l)); 316#endif 317 return gdbpy_ref<> (PyInt_FromLong (l)); 318#endif 319} 320 321/* Convert a ULONGEST to the appropriate Python object -- either an 322 integer object or a long object, depending on its value. */ 323 324gdbpy_ref<> 325gdb_py_object_from_ulongest (ULONGEST l) 326{ 327#ifdef IS_PY3K 328 if (sizeof (l) > sizeof (unsigned long)) 329 return gdbpy_ref<> (PyLong_FromUnsignedLongLong (l)); 330 return gdbpy_ref<> (PyLong_FromUnsignedLong (l)); 331#else 332#ifdef HAVE_LONG_LONG /* Defined by Python. */ 333 /* If we have 'long long', and the value overflows a 'long', use a 334 Python Long; otherwise use a Python Int. */ 335 if (sizeof (l) > sizeof (unsigned long) && l > PyInt_GetMax ()) 336 return gdbpy_ref<> (PyLong_FromUnsignedLongLong (l)); 337#endif 338 339 if (l > PyInt_GetMax ()) 340 return gdbpy_ref<> (PyLong_FromUnsignedLong (l)); 341 342 return gdbpy_ref<> (PyInt_FromLong (l)); 343#endif 344} 345 346/* Like PyInt_AsLong, but returns 0 on failure, 1 on success, and puts 347 the value into an out parameter. */ 348 349int 350gdb_py_int_as_long (PyObject *obj, long *result) 351{ 352 *result = PyInt_AsLong (obj); 353 return ! (*result == -1 && PyErr_Occurred ()); 354} 355 356 357 358/* Generic implementation of the __dict__ attribute for objects that 359 have a dictionary. The CLOSURE argument should be the type object. 360 This only handles positive values for tp_dictoffset. */ 361 362PyObject * 363gdb_py_generic_dict (PyObject *self, void *closure) 364{ 365 PyObject *result; 366 PyTypeObject *type_obj = (PyTypeObject *) closure; 367 char *raw_ptr; 368 369 raw_ptr = (char *) self + type_obj->tp_dictoffset; 370 result = * (PyObject **) raw_ptr; 371 372 Py_INCREF (result); 373 return result; 374} 375 376/* Like PyModule_AddObject, but does not steal a reference to 377 OBJECT. */ 378 379int 380gdb_pymodule_addobject (PyObject *module, const char *name, PyObject *object) 381{ 382 int result; 383 384 Py_INCREF (object); 385 /* Python 2.4 did not have a 'const' here. */ 386 result = PyModule_AddObject (module, (char *) name, object); 387 if (result < 0) 388 Py_DECREF (object); 389 return result; 390} 391 392/* Handle a Python exception when the special gdb.GdbError treatment 393 is desired. This should only be called when an exception is set. 394 If the exception is a gdb.GdbError, throw a gdb exception with the 395 exception text. For other exceptions, print the Python stack and 396 then throw a gdb exception. */ 397 398void 399gdbpy_handle_exception () 400{ 401 gdbpy_err_fetch fetched_error; 402 gdb::unique_xmalloc_ptr<char> msg = fetched_error.to_string (); 403 404 if (msg == NULL) 405 { 406 /* An error occurred computing the string representation of the 407 error message. This is rare, but we should inform the user. */ 408 printf_filtered (_("An error occurred in Python " 409 "and then another occurred computing the " 410 "error message.\n")); 411 gdbpy_print_stack (); 412 } 413 414 /* Don't print the stack for gdb.GdbError exceptions. 415 It is generally used to flag user errors. 416 417 We also don't want to print "Error occurred in Python command" 418 for user errors. However, a missing message for gdb.GdbError 419 exceptions is arguably a bug, so we flag it as such. */ 420 421 if (fetched_error.type_matches (PyExc_KeyboardInterrupt)) 422 throw_quit ("Quit"); 423 else if (! fetched_error.type_matches (gdbpy_gdberror_exc) 424 || msg == NULL || *msg == '\0') 425 { 426 fetched_error.restore (); 427 gdbpy_print_stack (); 428 if (msg != NULL && *msg != '\0') 429 error (_("Error occurred in Python: %s"), msg.get ()); 430 else 431 error (_("Error occurred in Python.")); 432 } 433 else 434 error ("%s", msg.get ()); 435} 436