gdb/python/py-lazy-string.c

   1 /* Python interface to lazy strings.
   2
   3    Copyright (C) 2010, 2011 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 "exceptions.h"
  25 #include "valprint.h"
  26 #include "language.h"
  27 #include "gdb_assert.h"
  28
  29 typedef struct {
  30   PyObject_HEAD
  31   /*  Holds the address of the lazy string.  */
  32   CORE_ADDR address;
  33
  34   /*  Holds the encoding that will be applied to the string
  35       when the string is printed by GDB.  If the encoding is set
  36       to None then GDB will select the most appropriate
  37       encoding when the sting is printed.  */
  38   char *encoding;
  39
  40   /* Holds the length of the string in characters.  If the
  41      length is -1, then the string will be fetched and encoded up to
  42      the first null of appropriate width.  */
  43   long length;
  44
  45   /*  This attribute holds the type that is represented by the lazy
  46       string's type.  */
  47   struct type *type;
  48 } lazy_string_object;
  49
  50 static PyTypeObject lazy_string_object_type;
  51
  52 static PyObject *
  53 stpy_get_address (PyObject *self, void *closure)
  54 {
  55   lazy_string_object *self_string = (lazy_string_object *) self;
  56
  57   return gdb_py_long_from_ulongest (self_string->address);
  58 }
  59
  60 static PyObject *
  61 stpy_get_encoding (PyObject *self, void *closure)
  62 {
  63   lazy_string_object *self_string = (lazy_string_object *) self;
  64   PyObject *result;
  65
  66   /* An encoding can be set to NULL by the user, so check before
  67      attempting a Python FromString call.  If NULL return Py_None.  */
  68   if (self_string->encoding)
  69     result = PyString_FromString (self_string->encoding);
  70   else
  71     {
  72       result = Py_None;
  73       Py_INCREF (result);
  74     }
  75
  76   return result;
  77 }
  78
  79 static PyObject *
  80 stpy_get_length (PyObject *self, void *closure)
  81 {
  82   lazy_string_object *self_string = (lazy_string_object *) self;
  83
  84   return PyLong_FromLong (self_string->length);
  85 }
  86
  87 PyObject *
  88 stpy_get_type (PyObject *self, void *closure)
  89 {
  90   lazy_string_object *str_obj = (lazy_string_object *) self;
  91
  92   return type_to_type_object (str_obj->type);
  93 }
  94
  95 static PyObject *
  96 stpy_convert_to_value  (PyObject *self, PyObject *args)
  97 {
  98   lazy_string_object *self_string = (lazy_string_object *) self;
  99   struct value *val;
 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   val = value_at_lazy (self_string->type, self_string->address);
 109   return value_to_value_object (val);
 110 }
 111
 112 static void
 113 stpy_dealloc (PyObject *self)
 114 {
 115   lazy_string_object *self_string = (lazy_string_object *) self;
 116
 117   xfree (self_string->encoding);
 118 }
 119
 120 PyObject *
 121 gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
 122                            const char *encoding, struct type *type)
 123 {
 124   lazy_string_object *str_obj = NULL;
 125
 126   if (address == 0 && length != 0)
 127     {
 128       PyErr_SetString (PyExc_MemoryError,
 129                        _("Cannot create a lazy string with address 0x0, " \
 130                          "and a non-zero length."));
 131       return NULL;
 132     }
 133
 134   if (!type)
 135     {
 136       PyErr_SetString (PyExc_RuntimeError,
 137                        _("A lazy string's type cannot be NULL."));
 138       return NULL;
 139     }
 140
 141   str_obj = PyObject_New (lazy_string_object, &lazy_string_object_type);
 142   if (!str_obj)
 143     return NULL;
 144
 145   str_obj->address = address;
 146   str_obj->length = length;
 147   if (encoding == NULL || !strcmp (encoding, ""))
 148     str_obj->encoding = NULL;
 149   else
 150     str_obj->encoding = xstrdup (encoding);
 151   str_obj->type = type;
 152
 153   return (PyObject *) str_obj;
 154 }
 155
 156 void
 157 gdbpy_initialize_lazy_string (void)
 158 {
 159   if (PyType_Ready (&lazy_string_object_type) < 0)
 160     return;
 161
 162   Py_INCREF (&lazy_string_object_type);
 163 }
 164
 165 /* Determine whether the printer object pointed to by OBJ is a
 166    Python lazy string.  */
 167 int
 168 gdbpy_is_lazy_string (PyObject *result)
 169 {
 170   return PyObject_TypeCheck (result, &lazy_string_object_type);
 171 }
 172
 173 /* Extract the parameters from the lazy string object STRING.
 174    ENCODING will either be set to NULL, or will be allocated with
 175    xmalloc, in which case the callers is responsible for freeing
 176    it.  */
 177
 178 void
 179 gdbpy_extract_lazy_string (PyObject *string, CORE_ADDR *addr,
 180                            struct type **str_type,
 181                            long *length, char **encoding)
 182 {
 183   lazy_string_object *lazy;
 184
 185   gdb_assert (gdbpy_is_lazy_string (string));
 186
 187   lazy = (lazy_string_object *) string;
 188
 189   *addr = lazy->address;
 190   *str_type = lazy->type;
 191   *length = lazy->length;
 192   *encoding = lazy->encoding ? xstrdup (lazy->encoding) : NULL;
 193 }
 194
 195 \f
 196
 197 static PyMethodDef lazy_string_object_methods[] = {
 198   { "value", stpy_convert_to_value, METH_NOARGS,
 199     "Create a (lazy) value that contains a pointer to the string." },
 200   {NULL}  /* Sentinel */
 201 };
 202
 203
 204 static PyGetSetDef lazy_string_object_getset[] = {
 205   { "address", stpy_get_address, NULL, "Address of the string.", NULL },
 206   { "encoding", stpy_get_encoding, NULL, "Encoding of the string.", NULL },
 207   { "length", stpy_get_length, NULL, "Length of the string.", NULL },
 208   { "type", stpy_get_type, NULL, "Type associated with the string.", NULL },
 209   { NULL }  /* Sentinel */
 210 };
 211
 212 static PyTypeObject lazy_string_object_type = {
 213   PyObject_HEAD_INIT (NULL)
 214   0,                              /*ob_size*/
 215   "gdb.LazyString",               /*tp_name*/
 216   sizeof (lazy_string_object),    /*tp_basicsize*/
 217   0,                              /*tp_itemsize*/
 218   stpy_dealloc,                   /*tp_dealloc*/
 219   0,                              /*tp_print*/
 220   0,                              /*tp_getattr*/
 221   0,                              /*tp_setattr*/
 222   0,                              /*tp_compare*/
 223   0,                              /*tp_repr*/
 224   0,                              /*tp_as_number*/
 225   0,                              /*tp_as_sequence*/
 226   0,                              /*tp_as_mapping*/
 227   0,                              /*tp_hash */
 228   0,                              /*tp_call*/
 229   0,                              /*tp_str*/
 230   0,                              /*tp_getattro*/
 231   0,                              /*tp_setattro*/
 232   0,                              /*tp_as_buffer*/
 233   Py_TPFLAGS_DEFAULT,             /*tp_flags*/
 234   "GDB lazy string object",       /* tp_doc */
 235   0,                              /* tp_traverse */
 236   0,                              /* tp_clear */
 237   0,                              /* tp_richcompare */
 238   0,                              /* tp_weaklistoffset */
 239   0,                              /* tp_iter */
 240   0,                              /* tp_iternext */
 241   lazy_string_object_methods,     /* tp_methods */
 242   0,                              /* tp_members */
 243   lazy_string_object_getset       /* tp_getset */
 244 };