gdb/python/py-utils.c

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