gdb/python/py-utils.c

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