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