gdb/python/py-utils.c

   1 /* General utility routines for GDB/Python.
   2
   3    Copyright (C) 2008-2012 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 /* 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.
  58
  59    If the given object is not one of the mentioned string types, NULL is
  60    returned, with the TypeError python exception set.  */
  61 PyObject *
  62 python_string_to_unicode (PyObject *obj)
  63 {
  64   PyObject *unicode_str;
  65
  66   /* If obj is already a unicode string, just return it.
  67      I wish life was always that simple...  */
  68   if (PyUnicode_Check (obj))
  69     {
  70       unicode_str = obj;
  71       Py_INCREF (obj);
  72     }
  73
  74   else if (PyString_Check (obj))
  75     unicode_str = PyUnicode_FromEncodedObject (obj, host_charset (), NULL);
  76   else
  77     {
  78       PyErr_SetString (PyExc_TypeError,
  79                        _("Expected a string or unicode object."));
  80       unicode_str = NULL;
  81     }
  82
  83   return unicode_str;
  84 }
  85
  86 /* Returns a newly allocated string with the contents of the given unicode
  87    string object converted to CHARSET.  If an error occurs during the
  88    conversion, NULL will be returned and a python exception will be set.
  89
  90    The caller is responsible for xfree'ing the string.  */
  91 static char *
  92 unicode_to_encoded_string (PyObject *unicode_str, const char *charset)
  93 {
  94   char *result;
  95   PyObject *string;
  96
  97   /* Translate string to named charset.  */
  98   string = PyUnicode_AsEncodedString (unicode_str, charset, NULL);
  99   if (string == NULL)
 100     return NULL;
 101
 102   result = xstrdup (PyString_AsString (string));
 103
 104   Py_DECREF (string);
 105
 106   return result;
 107 }
 108
 109 /* Returns a PyObject with the contents of the given unicode string
 110    object converted to a named charset.  If an error occurs during
 111    the conversion, NULL will be returned and a python exception will
 112    be set.  */
 113 static PyObject *
 114 unicode_to_encoded_python_string (PyObject *unicode_str, const char *charset)
 115 {
 116   PyObject *string;
 117
 118   /* Translate string to named charset.  */
 119   string = PyUnicode_AsEncodedString (unicode_str, charset, NULL);
 120   if (string == NULL)
 121     return NULL;
 122
 123   return string;
 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 *
 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 *
 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 *
 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 PyObject *
 172 python_string_to_target_python_string (PyObject *obj)
 173 {
 174   PyObject *str;
 175   PyObject *result;
 176
 177   str = python_string_to_unicode (obj);
 178   if (str == NULL)
 179     return NULL;
 180
 181   result = unicode_to_target_python_string (str);
 182   Py_DECREF (str);
 183   return result;
 184 }
 185
 186 /* Converts a python string (8-bit or unicode) to a target string in
 187    the host's charset.  Returns NULL on error, with a python exception set.
 188
 189    The caller is responsible for xfree'ing the string.  */
 190 char *
 191 python_string_to_host_string (PyObject *obj)
 192 {
 193   PyObject *str;
 194   char *result;
 195
 196   str = python_string_to_unicode (obj);
 197   if (str == NULL)
 198     return NULL;
 199
 200   result = unicode_to_encoded_string (str, host_charset ());
 201   Py_DECREF (str);
 202   return result;
 203 }
 204
 205 /* Converts a target string of LENGTH bytes in the target's charset to a
 206    Python Unicode string. If LENGTH is -1, convert until a null byte is found.
 207
 208    Returns NULL on error, with a python exception set.  */
 209 PyObject *
 210 target_string_to_unicode (const gdb_byte *str, int length)
 211 {
 212   if (length == -1)
 213     length = strlen (str);
 214
 215   return PyUnicode_Decode (str, length, target_charset (python_gdbarch), NULL);
 216 }
 217
 218 /* Return true if OBJ is a Python string or unicode object, false
 219    otherwise.  */
 220
 221 int
 222 gdbpy_is_string (PyObject *obj)
 223 {
 224   return PyString_Check (obj) || PyUnicode_Check (obj);
 225 }
 226
 227 /* Return the string representation of OBJ, i.e., str (obj).
 228    Space for the result is malloc'd, the caller must free.
 229    If the result is NULL a python error occurred, the caller must clear it.  */
 230
 231 char *
 232 gdbpy_obj_to_string (PyObject *obj)
 233 {
 234   PyObject *str_obj = PyObject_Str (obj);
 235
 236   if (str_obj != NULL)
 237     {
 238       char *msg = xstrdup (PyString_AsString (str_obj));
 239
 240       Py_DECREF (str_obj);
 241       return msg;
 242     }
 243
 244   return NULL;
 245 }
 246
 247 /* Return the string representation of the exception represented by
 248    TYPE, VALUE which is assumed to have been obtained with PyErr_Fetch,
 249    i.e., the error indicator is currently clear.
 250    Space for the result is malloc'd, the caller must free.
 251    If the result is NULL a python error occurred, the caller must clear it.  */
 252
 253 char *
 254 gdbpy_exception_to_string (PyObject *ptype, PyObject *pvalue)
 255 {
 256   char *str;
 257
 258   /* There are a few cases to consider.
 259      For example:
 260      pvalue is a string when PyErr_SetString is used.
 261      pvalue is not a string when raise "foo" is used, instead it is None
 262      and ptype is "foo".
 263      So the algorithm we use is to print `str (pvalue)' if it's not
 264      None, otherwise we print `str (ptype)'.
 265      Using str (aka PyObject_Str) will fetch the error message from
 266      gdb.GdbError ("message").  */
 267
 268   if (pvalue && pvalue != Py_None)
 269     str = gdbpy_obj_to_string (pvalue);
 270   else
 271     str = gdbpy_obj_to_string (ptype);
 272
 273   return str;
 274 }
 275
 276 /* Convert a GDB exception to the appropriate Python exception.
 277
 278    This sets the Python error indicator, and returns NULL.  */
 279
 280 PyObject *
 281 gdbpy_convert_exception (struct gdb_exception exception)
 282 {
 283   PyObject *exc_class;
 284
 285   if (exception.reason == RETURN_QUIT)
 286     exc_class = PyExc_KeyboardInterrupt;
 287   else if (exception.error == MEMORY_ERROR)
 288     exc_class = gdbpy_gdb_memory_error;
 289   else
 290     exc_class = gdbpy_gdb_error;
 291
 292   return PyErr_Format (exc_class, "%s", exception.message);
 293 }
 294
 295 /* Converts OBJ to a CORE_ADDR value.
 296
 297    Returns 1 on success or 0 on failure, with a Python exception set.  This
 298    function can also throw GDB exceptions.
 299 */
 300
 301 int
 302 get_addr_from_python (PyObject *obj, CORE_ADDR *addr)
 303 {
 304   if (gdbpy_is_value_object (obj))
 305     *addr = value_as_address (value_object_to_value (obj));
 306   else
 307     {
 308       PyObject *num = PyNumber_Long (obj);
 309       gdb_py_ulongest val;
 310
 311       if (num == NULL)
 312         return 0;
 313
 314       val = gdb_py_long_as_ulongest (num);
 315       Py_XDECREF (num);
 316       if (PyErr_Occurred ())
 317         return 0;
 318
 319       if (sizeof (val) > sizeof (CORE_ADDR) && ((CORE_ADDR) val) != val)
 320         {
 321           PyErr_SetString (PyExc_ValueError,
 322                            _("Overflow converting to address."));
 323           return 0;
 324         }
 325
 326       *addr = val;
 327     }
 328
 329   return 1;
 330 }
 331
 332 /* Convert a LONGEST to the appropriate Python object -- either an
 333    integer object or a long object, depending on its value.  */
 334
 335 PyObject *
 336 gdb_py_object_from_longest (LONGEST l)
 337 {
 338 #ifdef HAVE_LONG_LONG           /* Defined by Python.  */
 339   /* If we have 'long long', and the value overflows a 'long', use a
 340      Python Long; otherwise use a Python Int.  */
 341   if (sizeof (l) > sizeof (long)
 342       && (l > PyInt_GetMax () || l < (- (LONGEST) PyInt_GetMax ()) - 1))
 343     return PyLong_FromLongLong (l);
 344 #endif
 345   return PyInt_FromLong (l);
 346 }
 347
 348 /* Convert a ULONGEST to the appropriate Python object -- either an
 349    integer object or a long object, depending on its value.  */
 350
 351 PyObject *
 352 gdb_py_object_from_ulongest (ULONGEST l)
 353 {
 354 #ifdef HAVE_LONG_LONG           /* Defined by Python.  */
 355   /* If we have 'long long', and the value overflows a 'long', use a
 356      Python Long; otherwise use a Python Int.  */
 357   if (sizeof (l) > sizeof (unsigned long) && l > PyInt_GetMax ())
 358     return PyLong_FromUnsignedLongLong (l);
 359 #endif
 360
 361   if (l > PyInt_GetMax ())
 362     return PyLong_FromUnsignedLong (l);
 363
 364   return PyInt_FromLong (l);
 365 }
 366
 367 /* Like PyInt_AsLong, but returns 0 on failure, 1 on success, and puts
 368    the value into an out parameter.  */
 369
 370 int
 371 gdb_py_int_as_long (PyObject *obj, long *result)
 372 {
 373   *result = PyInt_AsLong (obj);
 374   return ! (*result == -1 && PyErr_Occurred ());
 375 }
 376
 377 \f
 378
 379 /* Generic implementation of the __dict__ attribute for objects that
 380    have a dictionary.  The CLOSURE argument should be the type object.
 381    This only handles positive values for tp_dictoffset.  */
 382
 383 PyObject *
 384 gdb_py_generic_dict (PyObject *self, void *closure)
 385 {
 386   PyObject *result;
 387   PyTypeObject *type_obj = closure;
 388   char *raw_ptr;
 389
 390   raw_ptr = (char *) self + type_obj->tp_dictoffset;
 391   result = * (PyObject **) raw_ptr;
 392
 393   Py_INCREF (result);
 394   return result;
 395 }