| 1 | /* Python interface to lazy strings. |
| 2 | |
| 3 | Copyright (C) 2010 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 | |
| 28 | typedef struct { |
| 29 | PyObject_HEAD |
| 30 | /* Holds the address of the lazy string. */ |
| 31 | CORE_ADDR address; |
| 32 | |
| 33 | /* Holds the encoding that will be applied to the string |
| 34 | when the string is printed by GDB. If the encoding is set |
| 35 | to None then GDB will select the most appropriate |
| 36 | encoding when the sting is printed. */ |
| 37 | char *encoding; |
| 38 | |
| 39 | /* Holds the length of the string in characters. If the |
| 40 | length is -1, then the string will be fetched and encoded up to |
| 41 | the first null of appropriate width. */ |
| 42 | long length; |
| 43 | |
| 44 | /* This attribute holds the type that is represented by the lazy |
| 45 | string's type. */ |
| 46 | struct type *type; |
| 47 | } lazy_string_object; |
| 48 | |
| 49 | static PyTypeObject lazy_string_object_type; |
| 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 PyLong_FromUnsignedLongLong (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 | 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; |
| 99 | |
| 100 | if (self_string->address == 0) |
| 101 | { |
| 102 | PyErr_SetString (PyExc_MemoryError, |
| 103 | _("Cannot create a value from NULL.")); |
| 104 | return NULL; |
| 105 | } |
| 106 | |
| 107 | val = value_at_lazy (self_string->type, self_string->address); |
| 108 | return value_to_value_object (val); |
| 109 | } |
| 110 | |
| 111 | static void |
| 112 | stpy_dealloc (PyObject *self) |
| 113 | { |
| 114 | lazy_string_object *self_string = (lazy_string_object *) self; |
| 115 | |
| 116 | xfree (self_string->encoding); |
| 117 | } |
| 118 | |
| 119 | PyObject * |
| 120 | gdbpy_create_lazy_string_object (CORE_ADDR address, long length, |
| 121 | const char *encoding, struct type *type) |
| 122 | { |
| 123 | lazy_string_object *str_obj = NULL; |
| 124 | |
| 125 | if (address == 0 && length != 0) |
| 126 | { |
| 127 | PyErr_SetString (PyExc_MemoryError, |
| 128 | _("Cannot create a lazy string with address 0x0, " \ |
| 129 | "and a non-zero length.")); |
| 130 | return NULL; |
| 131 | } |
| 132 | |
| 133 | if (!type) |
| 134 | { |
| 135 | PyErr_SetString (PyExc_RuntimeError, |
| 136 | _("A lazy string's type cannot be NULL.")); |
| 137 | return NULL; |
| 138 | } |
| 139 | |
| 140 | str_obj = PyObject_New (lazy_string_object, &lazy_string_object_type); |
| 141 | if (!str_obj) |
| 142 | return NULL; |
| 143 | |
| 144 | str_obj->address = address; |
| 145 | str_obj->length = length; |
| 146 | if (encoding == NULL || !strcmp (encoding, "")) |
| 147 | str_obj->encoding = NULL; |
| 148 | else |
| 149 | str_obj->encoding = xstrdup (encoding); |
| 150 | str_obj->type = type; |
| 151 | |
| 152 | return (PyObject *) str_obj; |
| 153 | } |
| 154 | |
| 155 | void |
| 156 | gdbpy_initialize_lazy_string (void) |
| 157 | { |
| 158 | if (PyType_Ready (&lazy_string_object_type) < 0) |
| 159 | return; |
| 160 | |
| 161 | Py_INCREF (&lazy_string_object_type); |
| 162 | } |
| 163 | |
| 164 | /* Determine whether the printer object pointed to by OBJ is a |
| 165 | Python lazy string. */ |
| 166 | int |
| 167 | gdbpy_is_lazy_string (PyObject *result) |
| 168 | { |
| 169 | return PyObject_TypeCheck (result, &lazy_string_object_type); |
| 170 | } |
| 171 | |
| 172 | /* Extract and return the actual string from the lazy string object |
| 173 | STRING. Addtionally, the string type is written to *STR_TYPE, the |
| 174 | string length is written to *LENGTH, and the string encoding is |
| 175 | written to *ENCODING. On error, NULL is returned. The caller is |
| 176 | responsible for freeing the returned buffer. */ |
| 177 | gdb_byte * |
| 178 | gdbpy_extract_lazy_string (PyObject *string, struct type **str_type, |
| 179 | long *length, char **encoding) |
| 180 | { |
| 181 | int width; |
| 182 | int bytes_read; |
| 183 | gdb_byte *buffer = NULL; |
| 184 | int errcode = 0; |
| 185 | CORE_ADDR addr; |
| 186 | struct gdbarch *gdbarch; |
| 187 | enum bfd_endian byte_order; |
| 188 | PyObject *py_len = NULL, *py_encoding = NULL; |
| 189 | PyObject *py_addr = NULL, *py_type = NULL; |
| 190 | volatile struct gdb_exception except; |
| 191 | |
| 192 | py_len = PyObject_GetAttrString (string, "length"); |
| 193 | py_encoding = PyObject_GetAttrString (string, "encoding"); |
| 194 | py_addr = PyObject_GetAttrString (string, "address"); |
| 195 | py_type = PyObject_GetAttrString (string, "type"); |
| 196 | |
| 197 | /* A NULL encoding, length, address or type is not ok. */ |
| 198 | if (!py_len || !py_encoding || !py_addr || !py_type) |
| 199 | goto error; |
| 200 | |
| 201 | *length = PyLong_AsLong (py_len); |
| 202 | addr = PyLong_AsUnsignedLongLong (py_addr); |
| 203 | |
| 204 | /* If the user supplies Py_None an encoding, set encoding to NULL. |
| 205 | This will trigger the resulting LA_PRINT_CALL to automatically |
| 206 | select an encoding. */ |
| 207 | if (py_encoding == Py_None) |
| 208 | *encoding = NULL; |
| 209 | else |
| 210 | *encoding = xstrdup (PyString_AsString (py_encoding)); |
| 211 | |
| 212 | *str_type = type_object_to_type (py_type); |
| 213 | gdbarch = get_type_arch (*str_type); |
| 214 | byte_order = gdbarch_byte_order (gdbarch); |
| 215 | width = TYPE_LENGTH (*str_type); |
| 216 | |
| 217 | TRY_CATCH (except, RETURN_MASK_ALL) |
| 218 | { |
| 219 | errcode = read_string (addr, *length, width, |
| 220 | *length, byte_order, &buffer, |
| 221 | &bytes_read); |
| 222 | } |
| 223 | if (except.reason < 0) |
| 224 | { |
| 225 | PyErr_Format (except.reason == RETURN_QUIT \ |
| 226 | ? PyExc_KeyboardInterrupt : PyExc_RuntimeError, \ |
| 227 | "%s", except.message); \ |
| 228 | goto error; |
| 229 | |
| 230 | } |
| 231 | |
| 232 | if (errcode) |
| 233 | goto error; |
| 234 | |
| 235 | *length = bytes_read / width; |
| 236 | |
| 237 | Py_DECREF (py_encoding); |
| 238 | Py_DECREF (py_len); |
| 239 | Py_DECREF (py_addr); |
| 240 | Py_DECREF (py_type); |
| 241 | return buffer; |
| 242 | |
| 243 | error: |
| 244 | Py_XDECREF (py_encoding); |
| 245 | Py_XDECREF (py_len); |
| 246 | Py_XDECREF (py_addr); |
| 247 | Py_XDECREF (py_type); |
| 248 | xfree (buffer); |
| 249 | *length = 0; |
| 250 | *str_type = NULL; |
| 251 | return NULL; |
| 252 | } |
| 253 | |
| 254 | \f |
| 255 | |
| 256 | static PyMethodDef lazy_string_object_methods[] = { |
| 257 | { "value", stpy_convert_to_value, METH_NOARGS, |
| 258 | "Create a (lazy) value that contains a pointer to the string." }, |
| 259 | {NULL} /* Sentinel */ |
| 260 | }; |
| 261 | |
| 262 | |
| 263 | static PyGetSetDef lazy_string_object_getset[] = { |
| 264 | { "address", stpy_get_address, NULL, "Address of the string.", NULL }, |
| 265 | { "encoding", stpy_get_encoding, NULL, "Encoding of the string.", NULL }, |
| 266 | { "length", stpy_get_length, NULL, "Length of the string.", NULL }, |
| 267 | { "type", stpy_get_type, NULL, "Type associated with the string.", NULL }, |
| 268 | { NULL } /* Sentinel */ |
| 269 | }; |
| 270 | |
| 271 | static PyTypeObject lazy_string_object_type = { |
| 272 | PyObject_HEAD_INIT (NULL) |
| 273 | 0, /*ob_size*/ |
| 274 | "gdb.LazyString", /*tp_name*/ |
| 275 | sizeof (lazy_string_object), /*tp_basicsize*/ |
| 276 | 0, /*tp_itemsize*/ |
| 277 | stpy_dealloc, /*tp_dealloc*/ |
| 278 | 0, /*tp_print*/ |
| 279 | 0, /*tp_getattr*/ |
| 280 | 0, /*tp_setattr*/ |
| 281 | 0, /*tp_compare*/ |
| 282 | 0, /*tp_repr*/ |
| 283 | 0, /*tp_as_number*/ |
| 284 | 0, /*tp_as_sequence*/ |
| 285 | 0, /*tp_as_mapping*/ |
| 286 | 0, /*tp_hash */ |
| 287 | 0, /*tp_call*/ |
| 288 | 0, /*tp_str*/ |
| 289 | 0, /*tp_getattro*/ |
| 290 | 0, /*tp_setattro*/ |
| 291 | 0, /*tp_as_buffer*/ |
| 292 | Py_TPFLAGS_DEFAULT, /*tp_flags*/ |
| 293 | "GDB lazy string object", /* tp_doc */ |
| 294 | 0, /* tp_traverse */ |
| 295 | 0, /* tp_clear */ |
| 296 | 0, /* tp_richcompare */ |
| 297 | 0, /* tp_weaklistoffset */ |
| 298 | 0, /* tp_iter */ |
| 299 | 0, /* tp_iternext */ |
| 300 | lazy_string_object_methods, /* tp_methods */ |
| 301 | 0, /* tp_members */ |
| 302 | lazy_string_object_getset /* tp_getset */ |
| 303 | }; |