Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / python / py-lazy-string.c
1 /* Python interface to lazy strings.
2
3    Copyright (C) 2010-2013 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 static 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 = NULL;
100   volatile struct gdb_exception except;
101
102   if (self_string->address == 0)
103     {
104       PyErr_SetString (PyExc_MemoryError,
105                        _("Cannot create a value from NULL."));
106       return NULL;
107     }
108
109   TRY_CATCH (except, RETURN_MASK_ALL)
110     {
111       val = value_at_lazy (self_string->type, self_string->address);
112     }
113   GDB_PY_HANDLE_EXCEPTION (except);
114
115   return value_to_value_object (val);
116 }
117
118 static void
119 stpy_dealloc (PyObject *self)
120 {
121   lazy_string_object *self_string = (lazy_string_object *) self;
122
123   xfree (self_string->encoding);
124 }
125
126 PyObject *
127 gdbpy_create_lazy_string_object (CORE_ADDR address, long length,
128                            const char *encoding, struct type *type)
129 {
130   lazy_string_object *str_obj = NULL;
131
132   if (address == 0 && length != 0)
133     {
134       PyErr_SetString (PyExc_MemoryError,
135                        _("Cannot create a lazy string with address 0x0, " \
136                          "and a non-zero length."));
137       return NULL;
138     }
139
140   if (!type)
141     {
142       PyErr_SetString (PyExc_RuntimeError,
143                        _("A lazy string's type cannot be NULL."));
144       return NULL;
145     }
146
147   str_obj = PyObject_New (lazy_string_object, &lazy_string_object_type);
148   if (!str_obj)
149     return NULL;
150
151   str_obj->address = address;
152   str_obj->length = length;
153   if (encoding == NULL || !strcmp (encoding, ""))
154     str_obj->encoding = NULL;
155   else
156     str_obj->encoding = xstrdup (encoding);
157   str_obj->type = type;
158
159   return (PyObject *) str_obj;
160 }
161
162 void
163 gdbpy_initialize_lazy_string (void)
164 {
165   if (PyType_Ready (&lazy_string_object_type) < 0)
166     return;
167
168   Py_INCREF (&lazy_string_object_type);
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 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 };