gdb/python/py-lazy-string.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Python interface to lazy strings.

  3.    Copyright (C) 2010-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"
  21. #include "python-internal.h"
  22. #include "charset.h"
  23. #include "value.h"
  24. #include "valprint.h"
  25. #include "language.h"

  27. typedef struct {
  28.   PyObject_HEAD
  29.   /*  Holds the address of the lazy string.  */
  30.   CORE_ADDR address;

  32.   /*  Holds the encoding that will be applied to the string
  33.       when the string is printed by GDB.  If the encoding is set
  34.       to None then GDB will select the most appropriate
  35.       encoding when the sting is printed.  */
  36.   char *encoding;

  38.   /* Holds the length of the string in characters.  If the
  39.      length is -1, then the string will be fetched and encoded up to
  40.      the first null of appropriate width.  */
  41.   long length;

  43.   /*  This attribute holds the type that is represented by the lazy
  44.       string's type.  */
  45.   struct type *type;
  46. ‌} lazy_string_object;

  48. static PyTypeObject lazy_string_object_type
  49.     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("lazy_string_object");

  51. static PyObject *
  52. ‌stpy_get_address (PyObject *self, void *closure)
  53. {
  54.   lazy_string_object *self_string = (lazy_string_object *) self;

  56.   return gdb_py_long_from_ulongest (self_string->address);
  57. }

  59. static PyObject *
  60. ‌stpy_get_encoding (PyObject *self, void *closure)
  61. {
  62.   lazy_string_object *self_string = (lazy_string_object *) self;
  63.   PyObject *result;

  65.   /* An encoding can be set to NULL by the user, so check before
  66.      attempting a Python FromString call.  If NULL return Py_None.  */
  67.   if (self_string->encoding)
  68.     result = PyString_FromString (self_string->encoding);
  69.   else
  70.     {
  71.       result = Py_None;
  72.       Py_INCREF (result);
  73.     }

  75.   return result;
  76. }

  78. static PyObject *
  79. ‌stpy_get_length (PyObject *self, void *closure)
  80. {
  81.   lazy_string_object *self_string = (lazy_string_object *) self;

  83.   return PyLong_FromLong (self_string->length);
  84. }

  86. static PyObject *
  87. ‌stpy_get_type (PyObject *self, void *closure)
  88. {
  89.   lazy_string_object *str_obj = (lazy_string_object *) self;

  91.   return type_to_type_object (str_obj->type);
  92. }

  94. static PyObject *
  95. ‌stpy_convert_to_value  (PyObject *self, PyObject *args)
  96. {
  97.   lazy_string_object *self_string = (lazy_string_object *) self;
  98.   struct value *val = NULL;
  99.   volatile struct gdb_exception except;

  101.   if (self_string->address == 0)
  102.     {
  103.       PyErr_SetString (PyExc_MemoryError,
  104.                        _("Cannot create a value from NULL."));
  105.       return NULL;
  106.     }

  108.   TRY_CATCH (except, RETURN_MASK_ALL)
  109.     {
  110.       val = value_at_lazy (self_string->type, self_string->address);
  111.     }
  112.   GDB_PY_HANDLE_EXCEPTION (except);

  114.   return value_to_value_object (val);
  115. }

  117. static void
  118. ‌stpy_dealloc (PyObject *self)
  119. {
  120.   lazy_string_object *self_string = (lazy_string_object *) self;

  122.   xfree (self_string->encoding);
  123. }

  125. PyObject *
  126. ‌gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
  127.                            const char *encoding, struct type *type)
  128. {
  129.   lazy_string_object *str_obj = NULL;

  131.   if (address == 0 && length != 0)
  132.     {
  133.       PyErr_SetString (PyExc_MemoryError,
  134.                        _("Cannot create a lazy string with address 0x0, " \
  135.                          "and a non-zero length."));
  136.       return NULL;
  137.     }

  139.   if (!type)
  140.     {
  141.       PyErr_SetString (PyExc_RuntimeError,
  142.                        _("A lazy string's type cannot be NULL."));
  143.       return NULL;
  144.     }

  146.   str_obj = PyObject_New (lazy_string_object, &lazy_string_object_type);
  147.   if (!str_obj)
  148.     return NULL;

  150.   str_obj->address = address;
  151.   str_obj->length = length;
  152.   if (encoding == NULL || !strcmp (encoding, ""))
  153.     str_obj->encoding = NULL;
  154.   else
  155.     str_obj->encoding = xstrdup (encoding);
  156.   str_obj->type = type;

  158.   return (PyObject *) str_obj;
  159. }

  161. int
  162. ‌gdbpy_initialize_lazy_string (void)
  163. {
  164.   if (PyType_Ready (&lazy_string_object_type) < 0)
  165.     return -1;

  167.   Py_INCREF (&lazy_string_object_type);
  168.   return 0;
  169. }

  171. /* Determine whether the printer object pointed to by OBJ is a
  172.    Python lazy string.  */
  173. int
  174. ‌gdbpy_is_lazy_string (PyObject *result)
  175. {
  176.   return PyObject_TypeCheck (result, &lazy_string_object_type);
  177. }

  179. /* Extract the parameters from the lazy string object STRING.
  180.    ENCODING will either be set to NULL, or will be allocated with
  181.    xmalloc, in which case the callers is responsible for freeing
  182.    it.  */

  184. void
  185. ‌gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
  186.                            struct type **str_type,
  187.                            long *length, char **encoding)
  188. {
  189.   lazy_string_object *lazy;

  191.   gdb_assert (gdbpy_is_lazy_string (string));

  193.   lazy = (lazy_string_object *) string;

  195.   *addr = lazy->address;
  196.   *str_type = lazy->type;
  197.   *length = lazy->length;
  198.   *encoding = lazy->encoding ? xstrdup (lazy->encoding) : NULL;
  199. }



  203. ‌static PyMethodDef lazy_string_object_methods[] = {
  204.   { "value", stpy_convert_to_value, METH_NOARGS,
  205.     "Create a (lazy) value that contains a pointer to the string." },
  206.   {NULL}  /* Sentinel */
  207. };


  210. ‌static PyGetSetDef lazy_string_object_getset[] = {
  211.   { "address", stpy_get_address, NULL, "Address of the string.", NULL },
  212.   { "encoding", stpy_get_encoding, NULL, "Encoding of the string.", NULL },
  213.   { "length", stpy_get_length, NULL, "Length of the string.", NULL },
  214.   { "type", stpy_get_type, NULL, "Type associated with the string.", NULL },
  215.   { NULL }  /* Sentinel */
  216. };

  218. ‌static PyTypeObject lazy_string_object_type = {
  219.   PyVarObject_HEAD_INIT (NULL, 0)
  220.   "gdb.LazyString",                  /*tp_name*/
  221.   sizeof (lazy_string_object),          /*tp_basicsize*/
  222.   0,                                  /*tp_itemsize*/
  223.   stpy_dealloc,                   /*tp_dealloc*/
  224.   0,                                  /*tp_print*/
  225.   0,                                  /*tp_getattr*/
  226.   0,                                  /*tp_setattr*/
  227.   0,                                  /*tp_compare*/
  228.   0,                                  /*tp_repr*/
  229.   0,                                  /*tp_as_number*/
  230.   0,                                  /*tp_as_sequence*/
  231.   0,                                  /*tp_as_mapping*/
  232.   0,                                  /*tp_hash */
  233.   0,                                  /*tp_call*/
  234.   0,                                  /*tp_str*/
  235.   0,                                  /*tp_getattro*/
  236.   0,                                  /*tp_setattro*/
  237.   0,                                  /*tp_as_buffer*/
  238.   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
  239.   "GDB lazy string object",          /* tp_doc */
  240.   0,                                  /* tp_traverse */
  241.   0,                                  /* tp_clear */
  242.   0,                                  /* tp_richcompare */
  243.   0,                                  /* tp_weaklistoffset */
  244.   0,                                  /* tp_iter */
  245.   0,                                  /* tp_iternext */
  246.   lazy_string_object_methods,          /* tp_methods */
  247.   0,                                  /* tp_members */
  248.   lazy_string_object_getset          /* tp_getset */
  249. };