contrib/gdb-7/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 /* 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 *
  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 *
  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 *
 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 *
 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
 172    In Python 3, the returned object is a "bytes" object (not a string).  */
 173 PyObject *
 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 *
 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
 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 *
 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 *
 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 *
 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
 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 *
 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 *
 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
 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 \f
 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 *
 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 }