gdb/python/py-utils.c

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