gdb/python/py-lazy-string.c

   1 /* Python interface to lazy strings.
   2
   3    Copyright (C) 2010-2015 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 "python-internal.h"
  22 #include "charset.h"
  23 #include "value.h"
  24 #include "valprint.h"
  25 #include "language.h"
  26
  27 typedef struct {
  28   PyObject_HEAD
  29   /*  Holds the address of the lazy string.  */
  30   CORE_ADDR address;
  31
  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;
  37
  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;
  42
  43   /*  This attribute holds the type that is represented by the lazy
  44       string's type.  */
  45   struct type *type;
  46 } lazy_string_object;
  47
  48 extern PyTypeObject lazy_string_object_type
  49     CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("lazy_string_object");
  50
  51 static PyObject *
  52 stpy_get_address (PyObject *self, void *closure)
  53 {
  54   lazy_string_object *self_string = (lazy_string_object *) self;
  55
  56   return gdb_py_long_from_ulongest (self_string->address);
  57 }
  58
  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;
  64
  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     }
  74
  75   return result;
  76 }
  77
  78 static PyObject *
  79 stpy_get_length (PyObject *self, void *closure)
  80 {
  81   lazy_string_object *self_string = (lazy_string_object *) self;
  82
  83   return PyLong_FromLong (self_string->length);
  84 }
  85
  86 static PyObject *
  87 stpy_get_type (PyObject *self, void *closure)
  88 {
  89   lazy_string_object *str_obj = (lazy_string_object *) self;
  90
  91   return type_to_type_object (str_obj->type);
  92 }
  93
  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;
 100
 101   if (self_string->address == 0)
 102     {
 103       PyErr_SetString (PyExc_MemoryError,
 104                        _("Cannot create a value from NULL."));
 105       return NULL;
 106     }
 107
 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);
 113
 114   return value_to_value_object (val);
 115 }
 116
 117 static void
 118 stpy_dealloc (PyObject *self)
 119 {
 120   lazy_string_object *self_string = (lazy_string_object *) self;
 121
 122   xfree (self_string->encoding);
 123 }
 124
 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;
 130
 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     }
 138
 139   if (!type)
 140     {
 141       PyErr_SetString (PyExc_RuntimeError,
 142                        _("A lazy string's type cannot be NULL."));
 143       return NULL;
 144     }
 145
 146   str_obj = PyObject_New (lazy_string_object, &lazy_string_object_type);
 147   if (!str_obj)
 148     return NULL;
 149
 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;
 157
 158   return (PyObject *) str_obj;
 159 }
 160
 161 int
 162 gdbpy_initialize_lazy_string (void)
 163 {
 164   if (PyType_Ready (&lazy_string_object_type) < 0)
 165     return -1;
 166
 167   Py_INCREF (&lazy_string_object_type);
 168   return 0;
 169 }
 170
 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 }
 178
 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.  */
 183
 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;
 190
 191   gdb_assert (gdbpy_is_lazy_string (string));
 192
 193   lazy = (lazy_string_object *) string;
 194
 195   *addr = lazy->address;
 196   *str_type = lazy->type;
 197   *length = lazy->length;
 198   *encoding = lazy->encoding ? xstrdup (lazy->encoding) : NULL;
 199 }
 200
 201 \f
 202
 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 };
 208
 209
 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 };
 217
 218 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 };