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