GDB (xrefs)

py-type.c
Go to the documentation of this file.
1 /* Python interface to types.
2
3 Copyright (C) 2008-2018 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 "value.h"
22 #include "python-internal.h"
23 #include "charset.h"
24 #include "gdbtypes.h"
25 #include "cp-support.h"
26 #include "demangle.h"
27 #include "objfiles.h"
28 #include "language.h"
29 #include "vec.h"
30 #include "typeprint.h"
31 #include "py-ref.h"
32
33 typedef struct pyty_type_object
34 {
35 PyObject_HEAD
36 struct type *type;
37
38 /* If a Type object is associated with an objfile, it is kept on a
39 doubly-linked list, rooted in the objfile. This lets us copy the
40 underlying struct type when the objfile is deleted. */
41 struct pyty_type_object *prev;
42 struct pyty_type_object *next;
43 } type_object;
44
45 extern PyTypeObject type_object_type
46 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
47
48 /* A Field object. */
49 typedef struct pyty_field_object
50 {
51 PyObject_HEAD
52
53 /* Dictionary holding our attributes. */
54 PyObject *dict;
55 } field_object;
56
57 extern PyTypeObject field_object_type
58 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
59
60 /* A type iterator object. */
61 typedef struct {
62 PyObject_HEAD
63 /* The current field index. */
64 int field;
65 /* What to return. */
66 enum gdbpy_iter_kind kind;
67 /* Pointer back to the original source type object. */
68 struct pyty_type_object *source;
69 } typy_iterator_object;
70
71 extern PyTypeObject type_iterator_object_type
72 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
73
74 /* This is used to initialize various gdb.TYPE_ constants. */
75 struct pyty_code
76 {
77 /* The code. */
78 enum type_code code;
79 /* The name. */
80 const char *name;
81 };
82
83 /* Forward declarations. */
84 static PyObject *typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind);
85
86 #define ENTRY(X) { X, #X }
87
88 static struct pyty_code pyty_codes[] =
89 {
90 ENTRY (TYPE_CODE_BITSTRING),
91 ENTRY (TYPE_CODE_PTR),
92 ENTRY (TYPE_CODE_ARRAY),
93 ENTRY (TYPE_CODE_STRUCT),
94 ENTRY (TYPE_CODE_UNION),
95 ENTRY (TYPE_CODE_ENUM),
96 ENTRY (TYPE_CODE_FLAGS),
97 ENTRY (TYPE_CODE_FUNC),
98 ENTRY (TYPE_CODE_INT),
99 ENTRY (TYPE_CODE_FLT),
100 ENTRY (TYPE_CODE_VOID),
101 ENTRY (TYPE_CODE_SET),
102 ENTRY (TYPE_CODE_RANGE),
103 ENTRY (TYPE_CODE_STRING),
104 ENTRY (TYPE_CODE_ERROR),
105 ENTRY (TYPE_CODE_METHOD),
106 ENTRY (TYPE_CODE_METHODPTR),
107 ENTRY (TYPE_CODE_MEMBERPTR),
108 ENTRY (TYPE_CODE_REF),
109 ENTRY (TYPE_CODE_RVALUE_REF),
110 ENTRY (TYPE_CODE_CHAR),
111 ENTRY (TYPE_CODE_BOOL),
112 ENTRY (TYPE_CODE_COMPLEX),
113 ENTRY (TYPE_CODE_TYPEDEF),
114 ENTRY (TYPE_CODE_NAMESPACE),
115 ENTRY (TYPE_CODE_DECFLOAT),
116 ENTRY (TYPE_CODE_INTERNAL_FUNCTION),
117 { TYPE_CODE_UNDEF, NULL }
118 };
119
120
121
122 static void
123 field_dealloc (PyObject *obj)
124 {
125 field_object *f = (field_object *) obj;
126
127 Py_XDECREF (f->dict);
128 Py_TYPE (obj)->tp_free (obj);
129 }
130
131 static PyObject *
132 field_new (void)
133 {
134 gdbpy_ref<field_object> result (PyObject_New (field_object,
135 &field_object_type));
136
137 if (result != NULL)
138 {
139 result->dict = PyDict_New ();
140 if (!result->dict)
141 return NULL;
142 }
143 return (PyObject *) result.release ();
144 }
145
146
147
148 /* Return true if OBJ is of type gdb.Field, false otherwise. */
149
150 int
151 gdbpy_is_field (PyObject *obj)
152 {
153 return PyObject_TypeCheck (obj, &field_object_type);
154 }
155
156 /* Return the code for this type. */
157 static PyObject *
158 typy_get_code (PyObject *self, void *closure)
159 {
160 struct type *type = ((type_object *) self)->type;
161
162 return PyInt_FromLong (TYPE_CODE (type));
163 }
164
165 /* Helper function for typy_fields which converts a single field to a
166 gdb.Field object. Returns NULL on error. */
167
168 static PyObject *
169 convert_field (struct type *type, int field)
170 {
171 gdbpy_ref<> result (field_new ());
172
173 if (result == NULL)
174 return NULL;
175
176 gdbpy_ref<> arg (type_to_type_object (type));
177 if (arg == NULL)
178 return NULL;
179 if (PyObject_SetAttrString (result.get (), "parent_type", arg.get ()) < 0)
180 return NULL;
181
182 if (!field_is_static (&TYPE_FIELD (type, field)))
183 {
184 const char *attrstring;
185
186 if (TYPE_CODE (type) == TYPE_CODE_ENUM)
187 {
188 arg.reset (gdb_py_long_from_longest (TYPE_FIELD_ENUMVAL (type,
189 field)));
190 attrstring = "enumval";
191 }
192 else
193 {
194 arg.reset (gdb_py_long_from_longest (TYPE_FIELD_BITPOS (type,
195 field)));
196 attrstring = "bitpos";
197 }
198
199 if (arg == NULL)
200 return NULL;
201
202 /* At least python-2.4 had the second parameter non-const. */
203 if (PyObject_SetAttrString (result.get (), (char *) attrstring,
204 arg.get ()) < 0)
205 return NULL;
206 }
207
208 arg.reset (NULL);
209 if (TYPE_FIELD_NAME (type, field))
210 {
211 const char *field_name = TYPE_FIELD_NAME (type, field);
212
213 if (field_name[0] != '\0')
214 {
215 arg.reset (PyString_FromString (TYPE_FIELD_NAME (type, field)));
216 if (arg == NULL)
217 return NULL;
218 }
219 }
220 if (arg == NULL)
221 {
222 arg.reset (Py_None);
223 Py_INCREF (arg.get ());
224 }
225 if (PyObject_SetAttrString (result.get (), "name", arg.get ()) < 0)
226 return NULL;
227
228 arg.reset (TYPE_FIELD_ARTIFICIAL (type, field) ? Py_True : Py_False);
229 Py_INCREF (arg.get ());
230 if (PyObject_SetAttrString (result.get (), "artificial", arg.get ()) < 0)
231 return NULL;
232
233 if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
234 arg.reset (field < TYPE_N_BASECLASSES (type) ? Py_True : Py_False);
235 else
236 arg.reset (Py_False);
237 Py_INCREF (arg.get ());
238 if (PyObject_SetAttrString (result.get (), "is_base_class", arg.get ()) < 0)
239 return NULL;
240
241 arg.reset (PyLong_FromLong (TYPE_FIELD_BITSIZE (type, field)));
242 if (arg == NULL)
243 return NULL;
244 if (PyObject_SetAttrString (result.get (), "bitsize", arg.get ()) < 0)
245 return NULL;
246
247 /* A field can have a NULL type in some situations. */
248 if (TYPE_FIELD_TYPE (type, field) == NULL)
249 {
250 arg.reset (Py_None);
251 Py_INCREF (arg.get ());
252 }
253 else
254 arg.reset (type_to_type_object (TYPE_FIELD_TYPE (type, field)));
255 if (arg == NULL)
256 return NULL;
257 if (PyObject_SetAttrString (result.get (), "type", arg.get ()) < 0)
258 return NULL;
259
260 return result.release ();
261 }
262
263 /* Helper function to return the name of a field, as a gdb.Field object.
264 If the field doesn't have a name, None is returned. */
265
266 static PyObject *
267 field_name (struct type *type, int field)
268 {
269 PyObject *result;
270
271 if (TYPE_FIELD_NAME (type, field))
272 result = PyString_FromString (TYPE_FIELD_NAME (type, field));
273 else
274 {
275 result = Py_None;
276 Py_INCREF (result);
277 }
278 return result;
279 }
280
281 /* Helper function for Type standard mapping methods. Returns a
282 Python object for field i of the type. "kind" specifies what to
283 return: the name of the field, a gdb.Field object corresponding to
284 the field, or a tuple consisting of field name and gdb.Field
285 object. */
286
287 static PyObject *
288 make_fielditem (struct type *type, int i, enum gdbpy_iter_kind kind)
289 {
290 switch (kind)
291 {
292 case iter_items:
293 {
294 gdbpy_ref<> key (field_name (type, i));
295 if (key == NULL)
296 return NULL;
297 gdbpy_ref<> value (convert_field (type, i));
298 if (value == NULL)
299 return NULL;
300 gdbpy_ref<> item (PyTuple_New (2));
301 if (item == NULL)
302 return NULL;
303 PyTuple_SET_ITEM (item.get (), 0, key.release ());
304 PyTuple_SET_ITEM (item.get (), 1, value.release ());
305 return item.release ();
306 }
307 case iter_keys:
308 return field_name (type, i);
309 case iter_values:
310 return convert_field (type, i);
311 }
312 gdb_assert_not_reached ("invalid gdbpy_iter_kind");
313 }
314
315 /* Return a sequence of all field names, fields, or (name, field) pairs.
316 Each field is a gdb.Field object. */
317
318 static PyObject *
319 typy_fields_items (PyObject *self, enum gdbpy_iter_kind kind)
320 {
321 PyObject *py_type = self;
322 PyObject *result = NULL, *iter = NULL;
323 struct type *type = ((type_object *) py_type)->type;
324 struct type *checked_type = type;
325
326 TRY
327 {
328 checked_type = check_typedef (checked_type);
329 }
330 CATCH (except, RETURN_MASK_ALL)
331 {
332 GDB_PY_HANDLE_EXCEPTION (except);
333 }
334 END_CATCH
335
336 if (checked_type != type)
337 py_type = type_to_type_object (checked_type);
338 iter = typy_make_iter (py_type, kind);
339 if (checked_type != type)
340 {
341 /* Need to wrap this in braces because Py_DECREF isn't wrapped
342 in a do{}while(0). */
343 Py_DECREF (py_type);
344 }
345 if (iter != NULL)
346 {
347 result = PySequence_List (iter);
348 Py_DECREF (iter);
349 }
350
351 return result;
352 }
353
354 /* Return a sequence of all fields. Each field is a gdb.Field object. */
355
356 static PyObject *
357 typy_values (PyObject *self, PyObject *args)
358 {
359 return typy_fields_items (self, iter_values);
360 }
361
362 /* Return a sequence of all fields. Each field is a gdb.Field object.
363 This method is similar to typy_values, except where the supplied
364 gdb.Type is an array, in which case it returns a list of one entry
365 which is a gdb.Field object for a range (the array bounds). */
366
367 static PyObject *
368 typy_fields (PyObject *self, PyObject *args)
369 {
370 struct type *type = ((type_object *) self)->type;
371
372 if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
373 return typy_fields_items (self, iter_values);
374
375 /* Array type. Handle this as a special case because the common
376 machinery wants struct or union or enum types. Build a list of
377 one entry which is the range for the array. */
378 gdbpy_ref<> r (convert_field (type, 0));
379 if (r == NULL)
380 return NULL;
381
382 return Py_BuildValue ("[O]", r.get ());
383 }
384
385 /* Return a sequence of all field names. Each field is a gdb.Field object. */
386
387 static PyObject *
388 typy_field_names (PyObject *self, PyObject *args)
389 {
390 return typy_fields_items (self, iter_keys);
391 }
392
393 /* Return a sequence of all (name, fields) pairs. Each field is a
394 gdb.Field object. */
395
396 static PyObject *
397 typy_items (PyObject *self, PyObject *args)
398 {
399 return typy_fields_items (self, iter_items);
400 }
401
402 /* Return the type's name, or None. */
403
404 static PyObject *
405 typy_get_name (PyObject *self, void *closure)
406 {
407 struct type *type = ((type_object *) self)->type;
408
409 if (TYPE_NAME (type) == NULL)
410 Py_RETURN_NONE;
411 return PyString_FromString (TYPE_NAME (type));
412 }
413
414 /* Return the type's tag, or None. */
415 static PyObject *
416 typy_get_tag (PyObject *self, void *closure)
417 {
418 struct type *type = ((type_object *) self)->type;
419
420 if (!TYPE_TAG_NAME (type))
421 Py_RETURN_NONE;
422 return PyString_FromString (TYPE_TAG_NAME (type));
423 }
424
425 /* Return the type, stripped of typedefs. */
426 static PyObject *
427 typy_strip_typedefs (PyObject *self, PyObject *args)
428 {
429 struct type *type = ((type_object *) self)->type;
430
431 TRY
432 {
433 type = check_typedef (type);
434 }
435 CATCH (except, RETURN_MASK_ALL)
436 {
437 GDB_PY_HANDLE_EXCEPTION (except);
438 }
439 END_CATCH
440
441 return type_to_type_object (type);
442 }
443
444 /* Strip typedefs and pointers/reference from a type. Then check that
445 it is a struct, union, or enum type. If not, raise TypeError. */
446
447 static struct type *
448 typy_get_composite (struct type *type)
449 {
450
451 for (;;)
452 {
453 TRY
454 {
455 type = check_typedef (type);
456 }
457 CATCH (except, RETURN_MASK_ALL)
458 {
459 GDB_PY_HANDLE_EXCEPTION (except);
460 }
461 END_CATCH
462
463 if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
464 break;
465 type = TYPE_TARGET_TYPE (type);
466 }
467
468 /* If this is not a struct, union, or enum type, raise TypeError
469 exception. */
470 if (TYPE_CODE (type) != TYPE_CODE_STRUCT
471 && TYPE_CODE (type) != TYPE_CODE_UNION
472 && TYPE_CODE (type) != TYPE_CODE_ENUM
473 && TYPE_CODE (type) != TYPE_CODE_FUNC)
474 {
475 PyErr_SetString (PyExc_TypeError,
476 "Type is not a structure, union, enum, or function type.");
477 return NULL;
478 }
479
480 return type;
481 }
482
483 /* Helper for typy_array and typy_vector. */
484
485 static PyObject *
486 typy_array_1 (PyObject *self, PyObject *args, int is_vector)
487 {
488 long n1, n2;
489 PyObject *n2_obj = NULL;
490 struct type *array = NULL;
491 struct type *type = ((type_object *) self)->type;
492
493 if (! PyArg_ParseTuple (args, "l|O", &n1, &n2_obj))
494 return NULL;
495
496 if (n2_obj)
497 {
498 if (!PyInt_Check (n2_obj))
499 {
500 PyErr_SetString (PyExc_RuntimeError,
501 _("Array bound must be an integer"));
502 return NULL;
503 }
504
505 if (! gdb_py_int_as_long (n2_obj, &n2))
506 return NULL;
507 }
508 else
509 {
510 n2 = n1;
511 n1 = 0;
512 }
513
514 if (n2 < n1 - 1) /* Note: An empty array has n2 == n1 - 1. */
515 {
516 PyErr_SetString (PyExc_ValueError,
517 _("Array length must not be negative"));
518 return NULL;
519 }
520
521 TRY
522 {
523 array = lookup_array_range_type (type, n1, n2);
524 if (is_vector)
525 make_vector_type (array);
526 }
527 CATCH (except, RETURN_MASK_ALL)
528 {
529 GDB_PY_HANDLE_EXCEPTION (except);
530 }
531 END_CATCH
532
533 return type_to_type_object (array);
534 }
535
536 /* Return an array type. */
537
538 static PyObject *
539 typy_array (PyObject *self, PyObject *args)
540 {
541 return typy_array_1 (self, args, 0);
542 }
543
544 /* Return a vector type. */
545
546 static PyObject *
547 typy_vector (PyObject *self, PyObject *args)
548 {
549 return typy_array_1 (self, args, 1);
550 }
551
552 /* Return a Type object which represents a pointer to SELF. */
553 static PyObject *
554 typy_pointer (PyObject *self, PyObject *args)
555 {
556 struct type *type = ((type_object *) self)->type;
557
558 TRY
559 {
560 type = lookup_pointer_type (type);
561 }
562 CATCH (except, RETURN_MASK_ALL)
563 {
564 GDB_PY_HANDLE_EXCEPTION (except);
565 }
566 END_CATCH
567
568 return type_to_type_object (type);
569 }
570
571 /* Return the range of a type represented by SELF. The return type is
572 a tuple. The first element of the tuple contains the low bound,
573 while the second element of the tuple contains the high bound. */
574 static PyObject *
575 typy_range (PyObject *self, PyObject *args)
576 {
577 struct type *type = ((type_object *) self)->type;
578 /* Initialize these to appease GCC warnings. */
579 LONGEST low = 0, high = 0;
580
581 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
582 && TYPE_CODE (type) != TYPE_CODE_STRING
583 && TYPE_CODE (type) != TYPE_CODE_RANGE)
584 {
585 PyErr_SetString (PyExc_RuntimeError,
586 _("This type does not have a range."));
587 return NULL;
588 }
589
590 switch (TYPE_CODE (type))
591 {
592 case TYPE_CODE_ARRAY:
593 case TYPE_CODE_STRING:
594 low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
595 high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type));
596 break;
597 case TYPE_CODE_RANGE:
598 low = TYPE_LOW_BOUND (type);
599 high = TYPE_HIGH_BOUND (type);
600 break;
601 }
602
603 gdbpy_ref<> low_bound (PyLong_FromLong (low));
604 if (low_bound == NULL)
605 return NULL;
606
607 gdbpy_ref<> high_bound (PyLong_FromLong (high));
608 if (high_bound == NULL)
609 return NULL;
610
611 gdbpy_ref<> result (PyTuple_New (2));
612 if (result == NULL)
613 return NULL;
614
615 if (PyTuple_SetItem (result.get (), 0, low_bound.release ()) != 0
616 || PyTuple_SetItem (result.get (), 1, high_bound.release ()) != 0)
617 return NULL;
618 return result.release ();
619 }
620
621 /* Return a Type object which represents a reference to SELF. */
622 static PyObject *
623 typy_reference (PyObject *self, PyObject *args)
624 {
625 struct type *type = ((type_object *) self)->type;
626
627 TRY
628 {
629 type = lookup_lvalue_reference_type (type);
630 }
631 CATCH (except, RETURN_MASK_ALL)
632 {
633 GDB_PY_HANDLE_EXCEPTION (except);
634 }
635 END_CATCH
636
637 return type_to_type_object (type);
638 }
639
640 /* Return a Type object which represents the target type of SELF. */
641 static PyObject *
642 typy_target (PyObject *self, PyObject *args)
643 {
644 struct type *type = ((type_object *) self)->type;
645
646 if (!TYPE_TARGET_TYPE (type))
647 {
648 PyErr_SetString (PyExc_RuntimeError,
649 _("Type does not have a target."));
650 return NULL;
651 }
652
653 return type_to_type_object (TYPE_TARGET_TYPE (type));
654 }
655
656 /* Return a const-qualified type variant. */
657 static PyObject *
658 typy_const (PyObject *self, PyObject *args)
659 {
660 struct type *type = ((type_object *) self)->type;
661
662 TRY
663 {
664 type = make_cv_type (1, 0, type, NULL);
665 }
666 CATCH (except, RETURN_MASK_ALL)
667 {
668 GDB_PY_HANDLE_EXCEPTION (except);
669 }
670 END_CATCH
671
672 return type_to_type_object (type);
673 }
674
675 /* Return a volatile-qualified type variant. */
676 static PyObject *
677 typy_volatile (PyObject *self, PyObject *args)
678 {
679 struct type *type = ((type_object *) self)->type;
680
681 TRY
682 {
683 type = make_cv_type (0, 1, type, NULL);
684 }
685 CATCH (except, RETURN_MASK_ALL)
686 {
687 GDB_PY_HANDLE_EXCEPTION (except);
688 }
689 END_CATCH
690
691 return type_to_type_object (type);
692 }
693
694 /* Return an unqualified type variant. */
695 static PyObject *
696 typy_unqualified (PyObject *self, PyObject *args)
697 {
698 struct type *type = ((type_object *) self)->type;
699
700 TRY
701 {
702 type = make_cv_type (0, 0, type, NULL);
703 }
704 CATCH (except, RETURN_MASK_ALL)
705 {
706 GDB_PY_HANDLE_EXCEPTION (except);
707 }
708 END_CATCH
709
710 return type_to_type_object (type);
711 }
712
713 /* Return the size of the type represented by SELF, in bytes. */
714 static PyObject *
715 typy_get_sizeof (PyObject *self, void *closure)
716 {
717 struct type *type = ((type_object *) self)->type;
718
719 TRY
720 {
721 check_typedef (type);
722 }
723 CATCH (except, RETURN_MASK_ALL)
724 {
725 }
726 END_CATCH
727
728 /* Ignore exceptions. */
729
730 return gdb_py_long_from_longest (TYPE_LENGTH (type));
731 }
732
733 static struct type *
734 typy_lookup_typename (const char *type_name, const struct block *block)
735 {
736 struct type *type = NULL;
737
738 TRY
739 {
740 if (startswith (type_name, "struct "))
741 type = lookup_struct (type_name + 7, NULL);
742 else if (startswith (type_name, "union "))
743 type = lookup_union (type_name + 6, NULL);
744 else if (startswith (type_name, "enum "))
745 type = lookup_enum (type_name + 5, NULL);
746 else
747 type = lookup_typename (python_language, python_gdbarch,
748 type_name, block, 0);
749 }
750 CATCH (except, RETURN_MASK_ALL)
751 {
752 GDB_PY_HANDLE_EXCEPTION (except);
753 }
754 END_CATCH
755
756 return type;
757 }
758
759 static struct type *
760 typy_lookup_type (struct demangle_component *demangled,
761 const struct block *block)
762 {
763 struct type *type, *rtype = NULL;
764 enum demangle_component_type demangled_type;
765
766 /* Save the type: typy_lookup_type() may (indirectly) overwrite
767 memory pointed by demangled. */
768 demangled_type = demangled->type;
769
770 if (demangled_type == DEMANGLE_COMPONENT_POINTER
771 || demangled_type == DEMANGLE_COMPONENT_REFERENCE
772 || demangled_type == DEMANGLE_COMPONENT_RVALUE_REFERENCE
773 || demangled_type == DEMANGLE_COMPONENT_CONST
774 || demangled_type == DEMANGLE_COMPONENT_VOLATILE)
775 {
776 type = typy_lookup_type (demangled->u.s_binary.left, block);
777 if (! type)
778 return NULL;
779
780 TRY
781 {
782 /* If the demangled_type matches with one of the types
783 below, run the corresponding function and save the type
784 to return later. We cannot just return here as we are in
785 an exception handler. */
786 switch (demangled_type)
787 {
788 case DEMANGLE_COMPONENT_REFERENCE:
789 rtype = lookup_lvalue_reference_type (type);
790 break;
791 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
792 rtype = lookup_rvalue_reference_type (type);
793 break;
794 case DEMANGLE_COMPONENT_POINTER:
795 rtype = lookup_pointer_type (type);
796 break;
797 case DEMANGLE_COMPONENT_CONST:
798 rtype = make_cv_type (1, 0, type, NULL);
799 break;
800 case DEMANGLE_COMPONENT_VOLATILE:
801 rtype = make_cv_type (0, 1, type, NULL);
802 break;
803 }
804 }
805 CATCH (except, RETURN_MASK_ALL)
806 {
807 GDB_PY_HANDLE_EXCEPTION (except);
808 }
809 END_CATCH
810 }
811
812 /* If we have a type from the switch statement above, just return
813 that. */
814 if (rtype)
815 return rtype;
816
817 /* We don't have a type, so lookup the type. */
818 gdb::unique_xmalloc_ptr<char> type_name = cp_comp_to_string (demangled, 10);
819 return typy_lookup_typename (type_name.get (), block);
820 }
821
822 /* This is a helper function for typy_template_argument that is used
823 when the type does not have template symbols attached. It works by
824 parsing the type name. This happens with compilers, like older
825 versions of GCC, that do not emit DW_TAG_template_*. */
826
827 static PyObject *
828 typy_legacy_template_argument (struct type *type, const struct block *block,
829 int argno)
830 {
831 int i;
832 struct demangle_component *demangled;
833 std::unique_ptr<demangle_parse_info> info;
834 const char *err;
835 struct type *argtype;
836
837 if (TYPE_NAME (type) == NULL)
838 {
839 PyErr_SetString (PyExc_RuntimeError, _("Null type name."));
840 return NULL;
841 }
842
843 TRY
844 {
845 /* Note -- this is not thread-safe. */
846 info = cp_demangled_name_to_comp (TYPE_NAME (type), &err);
847 }
848 CATCH (except, RETURN_MASK_ALL)
849 {
850 GDB_PY_HANDLE_EXCEPTION (except);
851 }
852 END_CATCH
853
854 if (! info)
855 {
856 PyErr_SetString (PyExc_RuntimeError, err);
857 return NULL;
858 }
859 demangled = info->tree;
860
861 /* Strip off component names. */
862 while (demangled->type == DEMANGLE_COMPONENT_QUAL_NAME
863 || demangled->type == DEMANGLE_COMPONENT_LOCAL_NAME)
864 demangled = demangled->u.s_binary.right;
865
866 if (demangled->type != DEMANGLE_COMPONENT_TEMPLATE)
867 {
868 PyErr_SetString (PyExc_RuntimeError, _("Type is not a template."));
869 return NULL;
870 }
871
872 /* Skip from the template to the arguments. */
873 demangled = demangled->u.s_binary.right;
874
875 for (i = 0; demangled && i < argno; ++i)
876 demangled = demangled->u.s_binary.right;
877
878 if (! demangled)
879 {
880 PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
881 argno);
882 return NULL;
883 }
884
885 argtype = typy_lookup_type (demangled->u.s_binary.left, block);
886 if (! argtype)
887 return NULL;
888
889 return type_to_type_object (argtype);
890 }
891
892 static PyObject *
893 typy_template_argument (PyObject *self, PyObject *args)
894 {
895 int argno;
896 struct type *type = ((type_object *) self)->type;
897 const struct block *block = NULL;
898 PyObject *block_obj = NULL;
899 struct symbol *sym;
900 struct value *val = NULL;
901
902 if (! PyArg_ParseTuple (args, "i|O", &argno, &block_obj))
903 return NULL;
904
905 if (block_obj)
906 {
907 block = block_object_to_block (block_obj);
908 if (! block)
909 {
910 PyErr_SetString (PyExc_RuntimeError,
911 _("Second argument must be block."));
912 return NULL;
913 }
914 }
915
916 TRY
917 {
918 type = check_typedef (type);
919 if (TYPE_IS_REFERENCE (type))
920 type = check_typedef (TYPE_TARGET_TYPE (type));
921 }
922 CATCH (except, RETURN_MASK_ALL)
923 {
924 GDB_PY_HANDLE_EXCEPTION (except);
925 }
926 END_CATCH
927
928 /* We might not have DW_TAG_template_*, so try to parse the type's
929 name. This is inefficient if we do not have a template type --
930 but that is going to wind up as an error anyhow. */
931 if (! TYPE_N_TEMPLATE_ARGUMENTS (type))
932 return typy_legacy_template_argument (type, block, argno);
933
934 if (argno >= TYPE_N_TEMPLATE_ARGUMENTS (type))
935 {
936 PyErr_Format (PyExc_RuntimeError, _("No argument %d in template."),
937 argno);
938 return NULL;
939 }
940
941 sym = TYPE_TEMPLATE_ARGUMENT (type, argno);
942 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
943 return type_to_type_object (SYMBOL_TYPE (sym));
944 else if (SYMBOL_CLASS (sym) == LOC_OPTIMIZED_OUT)
945 {
946 PyErr_Format (PyExc_RuntimeError,
947 _("Template argument is optimized out"));
948 return NULL;
949 }
950
951 TRY
952 {
953 val = value_of_variable (sym, block);
954 }
955 CATCH (except, RETURN_MASK_ALL)
956 {
957 GDB_PY_HANDLE_EXCEPTION (except);
958 }
959 END_CATCH
960
961 return value_to_value_object (val);
962 }
963
964 static PyObject *
965 typy_str (PyObject *self)
966 {
967 string_file thetype;
968
969 TRY
970 {
971 LA_PRINT_TYPE (type_object_to_type (self), "", &thetype, -1, 0,
972 &type_print_raw_options);
973 }
974 CATCH (except, RETURN_MASK_ALL)
975 {
976 GDB_PY_HANDLE_EXCEPTION (except);
977 }
978 END_CATCH
979
980 return PyUnicode_Decode (thetype.c_str (), thetype.size (),
981 host_charset (), NULL);
982 }
983
984 /* Implement the richcompare method. */
985
986 static PyObject *
987 typy_richcompare (PyObject *self, PyObject *other, int op)
988 {
989 int result = Py_NE;
990 struct type *type1 = type_object_to_type (self);
991 struct type *type2 = type_object_to_type (other);
992
993 /* We can only compare ourselves to another Type object, and only
994 for equality or inequality. */
995 if (type2 == NULL || (op != Py_EQ && op != Py_NE))
996 {
997 Py_INCREF (Py_NotImplemented);
998 return Py_NotImplemented;
999 }
1000
1001 if (type1 == type2)
1002 result = Py_EQ;
1003 else
1004 {
1005 TRY
1006 {
1007 result = types_deeply_equal (type1, type2);
1008 }
1009 CATCH (except, RETURN_MASK_ALL)
1010 {
1011 /* If there is a GDB exception, a comparison is not capable
1012 (or trusted), so exit. */
1013 GDB_PY_HANDLE_EXCEPTION (except);
1014 }
1015 END_CATCH
1016 }
1017
1018 if (op == (result ? Py_EQ : Py_NE))
1019 Py_RETURN_TRUE;
1020 Py_RETURN_FALSE;
1021 }
1022
1023
1024
1025 static const struct objfile_data *typy_objfile_data_key;
1026
1027 static void
1028 save_objfile_types (struct objfile *objfile, void *datum)
1029 {
1030 type_object *obj = (type_object *) datum;
1031 htab_t copied_types;
1032
1033 if (!gdb_python_initialized)
1034 return;
1035
1036 /* This prevents another thread from freeing the objects we're
1037 operating on. */
1038 gdbpy_enter enter_py (get_objfile_arch (objfile), current_language);
1039
1040 copied_types = create_copied_types_hash (objfile);
1041
1042 while (obj)
1043 {
1044 type_object *next = obj->next;
1045
1046 htab_empty (copied_types);
1047
1048 obj->type = copy_type_recursive (objfile, obj->type, copied_types);
1049
1050 obj->next = NULL;
1051 obj->prev = NULL;
1052
1053 obj = next;
1054 }
1055
1056 htab_delete (copied_types);
1057 }
1058
1059 static void
1060 set_type (type_object *obj, struct type *type)
1061 {
1062 obj->type = type;
1063 obj->prev = NULL;
1064 if (type && TYPE_OBJFILE (type))
1065 {
1066 struct objfile *objfile = TYPE_OBJFILE (type);
1067
1068 obj->next = ((struct pyty_type_object *)
1069 objfile_data (objfile, typy_objfile_data_key));
1070 if (obj->next)
1071 obj->next->prev = obj;
1072 set_objfile_data (objfile, typy_objfile_data_key, obj);
1073 }
1074 else
1075 obj->next = NULL;
1076 }
1077
1078 static void
1079 typy_dealloc (PyObject *obj)
1080 {
1081 type_object *type = (type_object *) obj;
1082
1083 if (type->prev)
1084 type->prev->next = type->next;
1085 else if (type->type && TYPE_OBJFILE (type->type))
1086 {
1087 /* Must reset head of list. */
1088 struct objfile *objfile = TYPE_OBJFILE (type->type);
1089
1090 if (objfile)
1091 set_objfile_data (objfile, typy_objfile_data_key, type->next);
1092 }
1093 if (type->next)
1094 type->next->prev = type->prev;
1095
1096 Py_TYPE (type)->tp_free (type);
1097 }
1098
1099 /* Return number of fields ("length" of the field dictionary). */
1100
1101 static Py_ssize_t
1102 typy_length (PyObject *self)
1103 {
1104 struct type *type = ((type_object *) self)->type;
1105
1106 type = typy_get_composite (type);
1107 if (type == NULL)
1108 return -1;
1109
1110 return TYPE_NFIELDS (type);
1111 }
1112
1113 /* Implements boolean evaluation of gdb.Type. Handle this like other
1114 Python objects that don't have a meaningful truth value -- all
1115 values are true. */
1116
1117 static int
1118 typy_nonzero (PyObject *self)
1119 {
1120 return 1;
1121 }
1122
1123 /* Return optimized out value of this type. */
1124
1125 static PyObject *
1126 typy_optimized_out (PyObject *self, PyObject *args)
1127 {
1128 struct type *type = ((type_object *) self)->type;
1129
1130 return value_to_value_object (allocate_optimized_out_value (type));
1131 }
1132
1133 /* Return a gdb.Field object for the field named by the argument. */
1134
1135 static PyObject *
1136 typy_getitem (PyObject *self, PyObject *key)
1137 {
1138 struct type *type = ((type_object *) self)->type;
1139 int i;
1140
1141 gdb::unique_xmalloc_ptr<char> field = python_string_to_host_string (key);
1142 if (field == NULL)
1143 return NULL;
1144
1145 /* We want just fields of this type, not of base types, so instead of
1146 using lookup_struct_elt_type, portions of that function are
1147 copied here. */
1148
1149 type = typy_get_composite (type);
1150 if (type == NULL)
1151 return NULL;
1152
1153 for (i = 0; i < TYPE_NFIELDS (type); i++)
1154 {
1155 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1156
1157 if (t_field_name && (strcmp_iw (t_field_name, field.get ()) == 0))
1158 {
1159 return convert_field (type, i);
1160 }
1161 }
1162 PyErr_SetObject (PyExc_KeyError, key);
1163 return NULL;
1164 }
1165
1166 /* Implement the "get" method on the type object. This is the
1167 same as getitem if the key is present, but returns the supplied
1168 default value or None if the key is not found. */
1169
1170 static PyObject *
1171 typy_get (PyObject *self, PyObject *args)
1172 {
1173 PyObject *key, *defval = Py_None, *result;
1174
1175 if (!PyArg_UnpackTuple (args, "get", 1, 2, &key, &defval))
1176 return NULL;
1177
1178 result = typy_getitem (self, key);
1179 if (result != NULL)
1180 return result;
1181
1182 /* typy_getitem returned error status. If the exception is
1183 KeyError, clear the exception status and return the defval
1184 instead. Otherwise return the exception unchanged. */
1185 if (!PyErr_ExceptionMatches (PyExc_KeyError))
1186 return NULL;
1187
1188 PyErr_Clear ();
1189 Py_INCREF (defval);
1190 return defval;
1191 }
1192
1193 /* Implement the "has_key" method on the type object. */
1194
1195 static PyObject *
1196 typy_has_key (PyObject *self, PyObject *args)
1197 {
1198 struct type *type = ((type_object *) self)->type;
1199 const char *field;
1200 int i;
1201
1202 if (!PyArg_ParseTuple (args, "s", &field))
1203 return NULL;
1204
1205 /* We want just fields of this type, not of base types, so instead of
1206 using lookup_struct_elt_type, portions of that function are
1207 copied here. */
1208
1209 type = typy_get_composite (type);
1210 if (type == NULL)
1211 return NULL;
1212
1213 for (i = 0; i < TYPE_NFIELDS (type); i++)
1214 {
1215 const char *t_field_name = TYPE_FIELD_NAME (type, i);
1216
1217 if (t_field_name && (strcmp_iw (t_field_name, field) == 0))
1218 Py_RETURN_TRUE;
1219 }
1220 Py_RETURN_FALSE;
1221 }
1222
1223 /* Make an iterator object to iterate over keys, values, or items. */
1224
1225 static PyObject *
1226 typy_make_iter (PyObject *self, enum gdbpy_iter_kind kind)
1227 {
1228 typy_iterator_object *typy_iter_obj;
1229
1230 /* Check that "self" is a structure or union type. */
1231 if (typy_get_composite (((type_object *) self)->type) == NULL)
1232 return NULL;
1233
1234 typy_iter_obj = PyObject_New (typy_iterator_object,
1235 &type_iterator_object_type);
1236 if (typy_iter_obj == NULL)
1237 return NULL;
1238
1239 typy_iter_obj->field = 0;
1240 typy_iter_obj->kind = kind;
1241 Py_INCREF (self);
1242 typy_iter_obj->source = (type_object *) self;
1243
1244 return (PyObject *) typy_iter_obj;
1245 }
1246
1247 /* iteritems() method. */
1248
1249 static PyObject *
1250 typy_iteritems (PyObject *self, PyObject *args)
1251 {
1252 return typy_make_iter (self, iter_items);
1253 }
1254
1255 /* iterkeys() method. */
1256
1257 static PyObject *
1258 typy_iterkeys (PyObject *self, PyObject *args)
1259 {
1260 return typy_make_iter (self, iter_keys);
1261 }
1262
1263 /* Iterating over the class, same as iterkeys except for the function
1264 signature. */
1265
1266 static PyObject *
1267 typy_iter (PyObject *self)
1268 {
1269 return typy_make_iter (self, iter_keys);
1270 }
1271
1272 /* itervalues() method. */
1273
1274 static PyObject *
1275 typy_itervalues (PyObject *self, PyObject *args)
1276 {
1277 return typy_make_iter (self, iter_values);
1278 }
1279
1280 /* Return a reference to the type iterator. */
1281
1282 static PyObject *
1283 typy_iterator_iter (PyObject *self)
1284 {
1285 Py_INCREF (self);
1286 return self;
1287 }
1288
1289 /* Return the next field in the iteration through the list of fields
1290 of the type. */
1291
1292 static PyObject *
1293 typy_iterator_iternext (PyObject *self)
1294 {
1295 typy_iterator_object *iter_obj = (typy_iterator_object *) self;
1296 struct type *type = iter_obj->source->type;
1297 PyObject *result;
1298
1299 if (iter_obj->field < TYPE_NFIELDS (type))
1300 {
1301 result = make_fielditem (type, iter_obj->field, iter_obj->kind);
1302 if (result != NULL)
1303 iter_obj->field++;
1304 return result;
1305 }
1306
1307 return NULL;
1308 }
1309
1310 static void
1311 typy_iterator_dealloc (PyObject *obj)
1312 {
1313 typy_iterator_object *iter_obj = (typy_iterator_object *) obj;
1314
1315 Py_DECREF (iter_obj->source);
1316 }
1317
1318 /* Create a new Type referring to TYPE. */
1319 PyObject *
1320 type_to_type_object (struct type *type)
1321 {
1322 type_object *type_obj;
1323
1324 type_obj = PyObject_New (type_object, &type_object_type);
1325 if (type_obj)
1326 set_type (type_obj, type);
1327
1328 return (PyObject *) type_obj;
1329 }
1330
1331 struct type *
1332 type_object_to_type (PyObject *obj)
1333 {
1334 if (! PyObject_TypeCheck (obj, &type_object_type))
1335 return NULL;
1336 return ((type_object *) obj)->type;
1337 }
1338
1339
1340
1341 /* Implementation of gdb.lookup_type. */
1342 PyObject *
1343 gdbpy_lookup_type (PyObject *self, PyObject *args, PyObject *kw)
1344 {
1345 static const char *keywords[] = { "name", "block", NULL };
1346 const char *type_name = NULL;
1347 struct type *type = NULL;
1348 PyObject *block_obj = NULL;
1349 const struct block *block = NULL;
1350
1351 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O", keywords,
1352 &type_name, &block_obj))
1353 return NULL;
1354
1355 if (block_obj)
1356 {
1357 block = block_object_to_block (block_obj);
1358 if (! block)
1359 {
1360 PyErr_SetString (PyExc_RuntimeError,
1361 _("'block' argument must be a Block."));
1362 return NULL;
1363 }
1364 }
1365
1366 type = typy_lookup_typename (type_name, block);
1367 if (! type)
1368 return NULL;
1369
1370 return (PyObject *) type_to_type_object (type);
1371 }
1372
1373 int
1374 gdbpy_initialize_types (void)
1375 {
1376 int i;
1377
1378 typy_objfile_data_key
1379 = register_objfile_data_with_cleanup (save_objfile_types, NULL);
1380
1381 if (PyType_Ready (&type_object_type) < 0)
1382 return -1;
1383 if (PyType_Ready (&field_object_type) < 0)
1384 return -1;
1385 if (PyType_Ready (&type_iterator_object_type) < 0)
1386 return -1;
1387
1388 for (i = 0; pyty_codes[i].name; ++i)
1389 {
1390 if (PyModule_AddIntConstant (gdb_module,
1391 /* Cast needed for Python 2.4. */
1392 (char *) pyty_codes[i].name,
1393 pyty_codes[i].code) < 0)
1394 return -1;
1395 }
1396
1397 if (gdb_pymodule_addobject (gdb_module, "Type",
1398 (PyObject *) &type_object_type) < 0)
1399 return -1;
1400
1401 if (gdb_pymodule_addobject (gdb_module, "TypeIterator",
1402 (PyObject *) &type_iterator_object_type) < 0)
1403 return -1;
1404
1405 return gdb_pymodule_addobject (gdb_module, "Field",
1406 (PyObject *) &field_object_type);
1407 }
1408
1409
1410
1411 static gdb_PyGetSetDef type_object_getset[] =
1412 {
1413 { "code", typy_get_code, NULL,
1414 "The code for this type.", NULL },
1415 { "name", typy_get_name, NULL,
1416 "The name for this type, or None.", NULL },
1417 { "sizeof", typy_get_sizeof, NULL,
1418 "The size of this type, in bytes.", NULL },
1419 { "tag", typy_get_tag, NULL,
1420 "The tag name for this type, or None.", NULL },
1421 { NULL }
1422 };
1423
1424 static PyMethodDef type_object_methods[] =
1425 {
1426 { "array", typy_array, METH_VARARGS,
1427 "array ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1428 Return a type which represents an array of objects of this type.\n\
1429 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1430 If LOW_BOUND is omitted, a value of zero is used." },
1431 { "vector", typy_vector, METH_VARARGS,
1432 "vector ([LOW_BOUND,] HIGH_BOUND) -> Type\n\
1433 Return a type which represents a vector of objects of this type.\n\
1434 The bounds of the array are [LOW_BOUND, HIGH_BOUND] inclusive.\n\
1435 If LOW_BOUND is omitted, a value of zero is used.\n\
1436 Vectors differ from arrays in that if the current language has C-style\n\
1437 arrays, vectors don't decay to a pointer to the first element.\n\
1438 They are first class values." },
1439 { "__contains__", typy_has_key, METH_VARARGS,
1440 "T.__contains__(k) -> True if T has a field named k, else False" },
1441 { "const", typy_const, METH_NOARGS,
1442 "const () -> Type\n\
1443 Return a const variant of this type." },
1444 { "optimized_out", typy_optimized_out, METH_NOARGS,
1445 "optimized_out() -> Value\n\
1446 Return optimized out value of this type." },
1447 { "fields", typy_fields, METH_NOARGS,
1448 "fields () -> list\n\
1449 Return a list holding all the fields of this type.\n\
1450 Each field is a gdb.Field object." },
1451 { "get", typy_get, METH_VARARGS,
1452 "T.get(k[,default]) -> returns field named k in T, if it exists;\n\
1453 otherwise returns default, if supplied, or None if not." },
1454 { "has_key", typy_has_key, METH_VARARGS,
1455 "T.has_key(k) -> True if T has a field named k, else False" },
1456 { "items", typy_items, METH_NOARGS,
1457 "items () -> list\n\
1458 Return a list of (name, field) pairs of this type.\n\
1459 Each field is a gdb.Field object." },
1460 { "iteritems", typy_iteritems, METH_NOARGS,
1461 "iteritems () -> an iterator over the (name, field)\n\
1462 pairs of this type. Each field is a gdb.Field object." },
1463 { "iterkeys", typy_iterkeys, METH_NOARGS,
1464 "iterkeys () -> an iterator over the field names of this type." },
1465 { "itervalues", typy_itervalues, METH_NOARGS,
1466 "itervalues () -> an iterator over the fields of this type.\n\
1467 Each field is a gdb.Field object." },
1468 { "keys", typy_field_names, METH_NOARGS,
1469 "keys () -> list\n\
1470 Return a list holding all the fields names of this type." },
1471 { "pointer", typy_pointer, METH_NOARGS,
1472 "pointer () -> Type\n\
1473 Return a type of pointer to this type." },
1474 { "range", typy_range, METH_NOARGS,
1475 "range () -> tuple\n\
1476 Return a tuple containing the lower and upper range for this type."},
1477 { "reference", typy_reference, METH_NOARGS,
1478 "reference () -> Type\n\
1479 Return a type of reference to this type." },
1480 { "strip_typedefs", typy_strip_typedefs, METH_NOARGS,
1481 "strip_typedefs () -> Type\n\
1482 Return a type formed by stripping this type of all typedefs."},
1483 { "target", typy_target, METH_NOARGS,
1484 "target () -> Type\n\
1485 Return the target type of this type." },
1486 { "template_argument", typy_template_argument, METH_VARARGS,
1487 "template_argument (arg, [block]) -> Type\n\
1488 Return the type of a template argument." },
1489 { "unqualified", typy_unqualified, METH_NOARGS,
1490 "unqualified () -> Type\n\
1491 Return a variant of this type without const or volatile attributes." },
1492 { "values", typy_values, METH_NOARGS,
1493 "values () -> list\n\
1494 Return a list holding all the fields of this type.\n\
1495 Each field is a gdb.Field object." },
1496 { "volatile", typy_volatile, METH_NOARGS,
1497 "volatile () -> Type\n\
1498 Return a volatile variant of this type" },
1499 { NULL }
1500 };
1501
1502 static PyNumberMethods type_object_as_number = {
1503 NULL, /* nb_add */
1504 NULL, /* nb_subtract */
1505 NULL, /* nb_multiply */
1506 #ifndef IS_PY3K
1507 NULL, /* nb_divide */
1508 #endif
1509 NULL, /* nb_remainder */
1510 NULL, /* nb_divmod */
1511 NULL, /* nb_power */
1512 NULL, /* nb_negative */
1513 NULL, /* nb_positive */
1514 NULL, /* nb_absolute */
1515 typy_nonzero, /* nb_nonzero */
1516 NULL, /* nb_invert */
1517 NULL, /* nb_lshift */
1518 NULL, /* nb_rshift */
1519 NULL, /* nb_and */
1520 NULL, /* nb_xor */
1521 NULL, /* nb_or */
1522 #ifdef IS_PY3K
1523 NULL, /* nb_int */
1524 NULL, /* reserved */
1525 #else
1526 NULL, /* nb_coerce */
1527 NULL, /* nb_int */
1528 NULL, /* nb_long */
1529 #endif
1530 NULL, /* nb_float */
1531 #ifndef IS_PY3K
1532 NULL, /* nb_oct */
1533 NULL /* nb_hex */
1534 #endif
1535 };
1536
1537 static PyMappingMethods typy_mapping = {
1538 typy_length,
1539 typy_getitem,
1540 NULL /* no "set" method */
1541 };
1542
1543 PyTypeObject type_object_type =
1544 {
1545 PyVarObject_HEAD_INIT (NULL, 0)
1546 "gdb.Type", /*tp_name*/
1547 sizeof (type_object), /*tp_basicsize*/
1548 0, /*tp_itemsize*/
1549 typy_dealloc, /*tp_dealloc*/
1550 0, /*tp_print*/
1551 0, /*tp_getattr*/
1552 0, /*tp_setattr*/
1553 0, /*tp_compare*/
1554 0, /*tp_repr*/
1555 &type_object_as_number, /*tp_as_number*/
1556 0, /*tp_as_sequence*/
1557 &typy_mapping, /*tp_as_mapping*/
1558 0, /*tp_hash */
1559 0, /*tp_call*/
1560 typy_str, /*tp_str*/
1561 0, /*tp_getattro*/
1562 0, /*tp_setattro*/
1563 0, /*tp_as_buffer*/
1564 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
1565 "GDB type object", /* tp_doc */
1566 0, /* tp_traverse */
1567 0, /* tp_clear */
1568 typy_richcompare, /* tp_richcompare */
1569 0, /* tp_weaklistoffset */
1570 typy_iter, /* tp_iter */
1571 0, /* tp_iternext */
1572 type_object_methods, /* tp_methods */
1573 0, /* tp_members */
1574 type_object_getset, /* tp_getset */
1575 0, /* tp_base */
1576 0, /* tp_dict */
1577 0, /* tp_descr_get */
1578 0, /* tp_descr_set */
1579 0, /* tp_dictoffset */
1580 0, /* tp_init */
1581 0, /* tp_alloc */
1582 0, /* tp_new */
1583 };
1584
1585 static gdb_PyGetSetDef field_object_getset[] =
1586 {
1587 { "__dict__", gdb_py_generic_dict, NULL,
1588 "The __dict__ for this field.", &field_object_type },
1589 { NULL }
1590 };
1591
1592 PyTypeObject field_object_type =
1593 {
1594 PyVarObject_HEAD_INIT (NULL, 0)
1595 "gdb.Field", /*tp_name*/
1596 sizeof (field_object), /*tp_basicsize*/
1597 0, /*tp_itemsize*/
1598 field_dealloc, /*tp_dealloc*/
1599 0, /*tp_print*/
1600 0, /*tp_getattr*/
1601 0, /*tp_setattr*/
1602 0, /*tp_compare*/
1603 0, /*tp_repr*/
1604 0, /*tp_as_number*/
1605 0, /*tp_as_sequence*/
1606 0, /*tp_as_mapping*/
1607 0, /*tp_hash */
1608 0, /*tp_call*/
1609 0, /*tp_str*/
1610 0, /*tp_getattro*/
1611 0, /*tp_setattro*/
1612 0, /*tp_as_buffer*/
1613 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
1614 "GDB field object", /* tp_doc */
1615 0, /* tp_traverse */
1616 0, /* tp_clear */
1617 0, /* tp_richcompare */
1618 0, /* tp_weaklistoffset */
1619 0, /* tp_iter */
1620 0, /* tp_iternext */
1621 0, /* tp_methods */
1622 0, /* tp_members */
1623 field_object_getset, /* tp_getset */
1624 0, /* tp_base */
1625 0, /* tp_dict */
1626 0, /* tp_descr_get */
1627 0, /* tp_descr_set */
1628 offsetof (field_object, dict), /* tp_dictoffset */
1629 0, /* tp_init */
1630 0, /* tp_alloc */
1631 0, /* tp_new */
1632 };
1633
1634 PyTypeObject type_iterator_object_type = {
1635 PyVarObject_HEAD_INIT (NULL, 0)
1636 "gdb.TypeIterator", /*tp_name*/
1637 sizeof (typy_iterator_object), /*tp_basicsize*/
1638 0, /*tp_itemsize*/
1639 typy_iterator_dealloc, /*tp_dealloc*/
1640 0, /*tp_print*/
1641 0, /*tp_getattr*/
1642 0, /*tp_setattr*/
1643 0, /*tp_compare*/
1644 0, /*tp_repr*/
1645 0, /*tp_as_number*/
1646 0, /*tp_as_sequence*/
1647 0, /*tp_as_mapping*/
1648 0, /*tp_hash */
1649 0, /*tp_call*/
1650 0, /*tp_str*/
1651 0, /*tp_getattro*/
1652 0, /*tp_setattro*/
1653 0, /*tp_as_buffer*/
1654 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/
1655 "GDB type iterator object", /*tp_doc */
1656 0, /*tp_traverse */
1657 0, /*tp_clear */
1658 0, /*tp_richcompare */
1659 0, /*tp_weaklistoffset */
1660 typy_iterator_iter, /*tp_iter */
1661 typy_iterator_iternext, /*tp_iternext */
1662 0 /*tp_methods */
1663 };
TYPE_CODE_NAMESPACE
Definition: gdbtypes.h:171
ENTRY
#define ENTRY(X)
Definition: py-type.c:86
err
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition: gnu-nat.c:1822
type_object_type
PyTypeObject type_object_type
Definition: py-type.c:1543
iter_keys
Definition: python-internal.h:361
gdb_pymodule_addobject
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition: py-utils.c:376
Py_DECREF
#define Py_DECREF(op)
Definition: python-internal.h:204
TYPE_CODE_BOOL
Definition: gdbtypes.h:164
type_code
type_code
Definition: gdbtypes.h:80
TYPE_CODE_ARRAY
Definition: gdbtypes.h:104
cp_demangled_name_to_comp
struct std::unique_ptr< demangle_parse_info > cp_demangled_name_to_comp(const char *demangled_name, const char **errmsg)
Definition: cp-name-parser.c:4266
lookup_array_range_type
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1232
gdb_py_generic_dict
PyObject * gdb_py_generic_dict(PyObject *self, void *closure)
Definition: py-utils.c:359
type_object_getset
static gdb_PyGetSetDef type_object_getset[]
Definition: py-type.c:1411
typy_volatile
static PyObject * typy_volatile(PyObject *self, PyObject *args)
Definition: py-type.c:677
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
typy_fields
static PyObject * typy_fields(PyObject *self, PyObject *args)
Definition: py-type.c:368
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
RETURN_MASK_ALL
Definition: common-exceptions.h:44
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
TYPE_LOW_BOUND
#define TYPE_LOW_BOUND(range_type)
Definition: gdbtypes.h:1244
cp_comp_to_string
gdb::unique_xmalloc_ptr< char > cp_comp_to_string(struct demangle_component *result, int estimated_len)
Definition: cp-name-parser.c:4195
typy_str
static PyObject * typy_str(PyObject *self)
Definition: py-type.c:965
strcmp_iw
int strcmp_iw(const char *string1, const char *string2)
Definition: utils.c:2517
TYPE_OBJFILE
#define TYPE_OBJFILE(t)
Definition: gdbtypes.h:291
if
if(!(yy_init))
Definition: ada-lex.c:1075
typy_iterator_object
Definition: py-type.c:61
type_object_to_type
struct type * type_object_to_type(PyObject *obj)
Definition: py-type.c:1332
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
TYPE_FIELD_ARTIFICIAL
#define TYPE_FIELD_ARTIFICIAL(thistype, n)
Definition: gdbtypes.h:1379
TYPE_HIGH_BOUND
#define TYPE_HIGH_BOUND(range_type)
Definition: gdbtypes.h:1246
typy_const
static PyObject * typy_const(PyObject *self, PyObject *args)
Definition: py-type.c:658
TYPE_CODE_RANGE
Definition: gdbtypes.h:127
TYPE_CODE_FLAGS
Definition: gdbtypes.h:109
type_print_raw_options
const struct type_print_options type_print_raw_options
Definition: typeprint.c:40
type_object
struct pyty_type_object type_object
convert_field
static PyObject * convert_field(struct type *type, int field)
Definition: py-type.c:169
charset.h
TYPE_CODE_INT
Definition: gdbtypes.h:111
gdbpy_enter
Definition: python-internal.h:627
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
typy_unqualified
static PyObject * typy_unqualified(PyObject *self, PyObject *args)
Definition: py-type.c:696
TYPE_CODE_SET
Definition: gdbtypes.h:126
gdb_PyGetSetDef
Definition: python-internal.h:304
gdbpy_is_field
int gdbpy_is_field(PyObject *obj)
Definition: py-type.c:151
typy_length
static Py_ssize_t typy_length(PyObject *self)
Definition: py-type.c:1102
TYPE_CODE_DECFLOAT
Definition: gdbtypes.h:173
typy_fields_items
static PyObject * typy_fields_items(PyObject *self, enum gdbpy_iter_kind kind)
Definition: py-type.c:319
cp-support.h
TYPE_CODE_UNDEF
Definition: gdbtypes.h:83
LOC_TYPEDEF
Definition: symtab.h:844
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF
PyTypeObject type_object_type CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF("type_object")
_
#define _(String)
Definition: gdb_locale.h:35
gdb_PyArg_ParseTupleAndKeywords
static int gdb_PyArg_ParseTupleAndKeywords(PyObject *args, PyObject *kw, const char *format, const char **keywords,...)
Definition: python-internal.h:338
PyVarObject_HEAD_INIT
#define PyVarObject_HEAD_INIT(type, size)
Definition: python-internal.h:133
TYPE_CODE_RVALUE_REF
Definition: gdbtypes.h:158
defs.h
TYPE_FIELD
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1370
gdbpy_lookup_type
PyObject * gdbpy_lookup_type(PyObject *self, PyObject *args, PyObject *kw)
Definition: py-type.c:1343
field_new
static PyObject * field_new(void)
Definition: py-type.c:132
pyty_field_object
Definition: py-type.c:49
typy_dealloc
static void typy_dealloc(PyObject *obj)
Definition: py-type.c:1079
TYPE_FIELD_ENUMVAL
#define TYPE_FIELD_ENUMVAL(thistype, n)
Definition: gdbtypes.h:1375
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
typy_get_composite
static struct type * typy_get_composite(struct type *type)
Definition: py-type.c:448
objfiles.h
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
block::dict
struct dictionary * dict
Definition: block.h:83
gdb::ref_ptr::reset
void reset(T *obj)
Definition: gdb_ref_ptr.h:121
GDB_PY_HANDLE_EXCEPTION
#define GDB_PY_HANDLE_EXCEPTION(Exception)
Definition: python-internal.h:663
typy_range
static PyObject * typy_range(PyObject *self, PyObject *args)
Definition: py-type.c:575
TYPE_N_TEMPLATE_ARGUMENTS
#define TYPE_N_TEMPLATE_ARGUMENTS(thistype)
Definition: gdbtypes.h:1418
types_deeply_equal
int types_deeply_equal(struct type *type1, struct type *type2)
Definition: gdbtypes.c:3666
TYPE_CODE_STRING
Definition: gdbtypes.h:133
TRY
#define TRY
Definition: common-exceptions.h:246
TYPE_CODE_VOID
Definition: gdbtypes.h:124
TYPE_CODE_TYPEDEF
Definition: gdbtypes.h:169
set_type
static void set_type(type_object *obj, struct type *type)
Definition: py-type.c:1060
lookup_typename
struct type * lookup_typename(const struct language_defn *language, struct gdbarch *gdbarch, const char *name, const struct block *block, int noerr)
Definition: gdbtypes.c:1509
typy_array_1
static PyObject * typy_array_1(PyObject *self, PyObject *args, int is_vector)
Definition: py-type.c:486
name
const char *const name
Definition: aarch64-tdep.c:76
typy_make_iter
static PyObject * typy_make_iter(PyObject *self, enum gdbpy_iter_kind kind)
Definition: py-type.c:1226
typy_iter
static PyObject * typy_iter(PyObject *self)
Definition: py-type.c:1267
typy_iterator_dealloc
static void typy_iterator_dealloc(PyObject *obj)
Definition: py-type.c:1311
gdb::ref_ptr< T, gdbpy_ref_policy< T > >
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
lookup_rvalue_reference_type
struct type * lookup_rvalue_reference_type(struct type *type)
Definition: gdbtypes.c:478
typy_items
static PyObject * typy_items(PyObject *self, PyObject *args)
Definition: py-type.c:397
TYPE_CODE_CHAR
Definition: gdbtypes.h:160
pyty_code::name
const char * name
Definition: py-type.c:80
pyty_field_object::dict
PyObject_HEAD PyObject * dict
Definition: py-type.c:54
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
typy_get_name
static PyObject * typy_get_name(PyObject *self, void *closure)
Definition: py-type.c:405
iter_values
Definition: python-internal.h:361
field_is_static
int field_is_static(struct field *f)
Definition: gdbtypes.c:4224
lookup_struct
struct type * lookup_struct(const char *name, const struct block *block)
Definition: gdbtypes.c:1556
TYPE_CODE_FLT
Definition: gdbtypes.h:116
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
typy_lookup_typename
static struct type * typy_lookup_typename(const char *type_name, const struct block *block)
Definition: py-type.c:734
typy_has_key
static PyObject * typy_has_key(PyObject *self, PyObject *args)
Definition: py-type.c:1196
lookup_enum
struct type * lookup_enum(const char *name, const struct block *block)
Definition: gdbtypes.c:1602
copy_type_recursive
struct type * copy_type_recursive(struct objfile *objfile, struct type *type, htab_t copied_types)
Definition: gdbtypes.c:4763
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
TYPE_CODE_UNION
Definition: gdbtypes.h:107
field_object_type
PyTypeObject field_object_type
Definition: py-type.c:1592
type
Definition: gdbtypes.h:749
language.h
typy_nonzero
static int typy_nonzero(PyObject *self)
Definition: py-type.c:1118
block_object_to_block
const struct block * block_object_to_block(PyObject *obj)
Definition: py-block.c:285
save_objfile_types
static void save_objfile_types(struct objfile *objfile, void *datum)
Definition: py-type.c:1028
typy_strip_typedefs
static PyObject * typy_strip_typedefs(PyObject *self, PyObject *args)
Definition: py-type.c:427
type
static const char * type
Definition: language.c:113
python_gdbarch
struct gdbarch * python_gdbarch
Definition: python.c:203
field
Definition: gdbtypes.h:517
typy_iterator_object::source
struct pyty_type_object * source
Definition: py-type.c:68
typy_target
static PyObject * typy_target(PyObject *self, PyObject *args)
Definition: py-type.c:642
value_to_value_object
PyObject * value_to_value_object(struct value *val)
Definition: py-value.c:1579
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
create_copied_types_hash
htab_t create_copied_types_hash(struct objfile *objfile)
Definition: gdbtypes.c:4724
lookup_union
struct type * lookup_union(const char *name, const struct block *block)
Definition: gdbtypes.c:1578
string_file::size
size_t size() const
Definition: ui-file.h:138
gdb_python_initialized
int gdb_python_initialized
Definition: python.c:108
python-internal.h
typy_get_code
static PyObject * typy_get_code(PyObject *self, void *closure)
Definition: py-type.c:158
python_string_to_host_string
gdb::unique_xmalloc_ptr< char > python_string_to_host_string(PyObject *obj)
Definition: py-utils.c:152
typy_richcompare
static PyObject * typy_richcompare(PyObject *self, PyObject *other, int op)
Definition: py-type.c:987
TYPE_CODE_METHODPTR
Definition: gdbtypes.h:147
typy_reference
static PyObject * typy_reference(PyObject *self, PyObject *args)
Definition: py-type.c:623
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
TYPE_FIELD_BITSIZE
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1380
TYPE_CODE_ERROR
Definition: gdbtypes.h:138
TYPE_CODE_REF
Definition: gdbtypes.h:156
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
TYPE_FIELD_BITPOS
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1374
pyty_code
Definition: py-type.c:75
typy_array
static PyObject * typy_array(PyObject *self, PyObject *args)
Definition: py-type.c:539
block
Definition: block.h:60
value
Definition: value.c:169
typy_iterator_iternext
static PyObject * typy_iterator_iternext(PyObject *self)
Definition: py-type.c:1293
gdb_py_long_from_longest
#define gdb_py_long_from_longest
Definition: python-internal.h:173
LA_PRINT_TYPE
#define LA_PRINT_TYPE(type, varstring, stream, show, level, flags)
Definition: language.h:518
objfile
Definition: objfiles.h:286
TYPE_CODE_PTR
Definition: gdbtypes.h:84
typy_iterator_object::kind
enum gdbpy_iter_kind kind
Definition: py-type.c:66
type_object_methods
static PyMethodDef type_object_methods[]
Definition: py-type.c:1424
make_cv_type
struct type * make_cv_type(int cnst, int voltl, struct type *type, struct type **typeptr)
Definition: gdbtypes.c:691
current_language
const struct language_defn * current_language
Definition: language.c:81
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
make_fielditem
static PyObject * make_fielditem(struct type *type, int i, enum gdbpy_iter_kind kind)
Definition: py-type.c:288
gdbpy_initialize_types
int gdbpy_initialize_types(void)
Definition: py-type.c:1374
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
TYPE_INDEX_TYPE
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1242
string_file::c_str
const char * c_str() const
Definition: ui-file.h:137
typy_iterator_iter
static PyObject * typy_iterator_iter(PyObject *self)
Definition: py-type.c:1283
field_object
struct pyty_field_object field_object
value_of_variable
struct value * value_of_variable(struct symbol *var, const struct block *b)
Definition: valops.c:1296
gdb::ref_ptr::release
T * release()
Definition: gdb_ref_ptr.h:138
typy_getitem
static PyObject * typy_getitem(PyObject *self, PyObject *key)
Definition: py-type.c:1136
gdbpy_iter_kind
gdbpy_iter_kind
Definition: python-internal.h:361
code
int code
Definition: ser-unix.c:239
typy_field_names
static PyObject * typy_field_names(PyObject *self, PyObject *args)
Definition: py-type.c:388
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
typy_iteritems
static PyObject * typy_iteritems(PyObject *self, PyObject *args)
Definition: py-type.c:1250
typy_values
static PyObject * typy_values(PyObject *self, PyObject *args)
Definition: py-type.c:357
typy_objfile_data_key
static const struct objfile_data * typy_objfile_data_key
Definition: py-type.c:1025
TYPE_CODE_MEMBERPTR
Definition: gdbtypes.h:154
pyty_type_object::next
struct pyty_type_object * next
Definition: py-type.c:42
gdb::ref_ptr::get
T * get() const
Definition: gdb_ref_ptr.h:130
TYPE_CODE_INTERNAL_FUNCTION
Definition: gdbtypes.h:178
pyty_type_object::prev
struct pyty_type_object * prev
Definition: py-type.c:41
value.h
TYPE_TAG_NAME
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1225
typy_optimized_out
static PyObject * typy_optimized_out(PyObject *self, PyObject *args)
Definition: py-type.c:1126
gdbtypes.h
typeprint.h
type_iterator_object_type
PyTypeObject type_iterator_object_type
Definition: py-type.c:1634
typy_pointer
static PyObject * typy_pointer(PyObject *self, PyObject *args)
Definition: py-type.c:554
field_name
static PyObject * field_name(struct type *type, int field)
Definition: py-type.c:267
gdb_py_int_as_long
int gdb_py_int_as_long(PyObject *obj, long *result)
Definition: py-utils.c:346
TYPE_TEMPLATE_ARGUMENT
#define TYPE_TEMPLATE_ARGUMENT(thistype, n)
Definition: gdbtypes.h:1422
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
Py_TYPE
#define Py_TYPE(ob)
Definition: python-internal.h:140
typy_legacy_template_argument
static PyObject * typy_legacy_template_argument(struct type *type, const struct block *block, int argno)
Definition: py-type.c:828
symbol
Definition: symtab.h:1049
gdb_module
PyObject * gdb_module
Definition: python.c:116
LOC_OPTIMIZED_OUT
Definition: symtab.h:888
pyty_type_object
Definition: py-type.c:33
python_language
const struct language_defn * python_language
Definition: python.c:204
typy_iterkeys
static PyObject * typy_iterkeys(PyObject *self, PyObject *args)
Definition: py-type.c:1258
host_charset
const char * host_charset(void)
Definition: charset.c:417
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
typy_get
static PyObject * typy_get(PyObject *self, PyObject *args)
Definition: py-type.c:1171
allocate_optimized_out_value
struct value * allocate_optimized_out_value(struct type *type)
Definition: value.c:1077
pyty_codes
static struct pyty_code pyty_codes[]
Definition: py-type.c:88
TYPE_CODE_BITSTRING
Definition: gdbtypes.h:82
TYPE_CODE_METHOD
Definition: gdbtypes.h:141
typy_template_argument
static PyObject * typy_template_argument(PyObject *self, PyObject *args)
Definition: py-type.c:893
typy_lookup_type
static struct type * typy_lookup_type(struct demangle_component *demangled, const struct block *block)
Definition: py-type.c:760
typy_itervalues
static PyObject * typy_itervalues(PyObject *self, PyObject *args)
Definition: py-type.c:1275
py-ref.h
field_object_getset
static gdb_PyGetSetDef field_object_getset[]
Definition: py-type.c:1585
typy_get_tag
static PyObject * typy_get_tag(PyObject *self, void *closure)
Definition: py-type.c:416
typy_vector
static PyObject * typy_vector(PyObject *self, PyObject *args)
Definition: py-type.c:547
typy_get_sizeof
static PyObject * typy_get_sizeof(PyObject *self, void *closure)
Definition: py-type.c:715
typy_iterator_object::field
PyObject_HEAD int field
Definition: py-type.c:64
lookup_lvalue_reference_type
struct type * lookup_lvalue_reference_type(struct type *type)
Definition: gdbtypes.c:470
make_vector_type
void make_vector_type(struct type *array_type)
Definition: gdbtypes.c:1311
field_dealloc
static void field_dealloc(PyObject *obj)
Definition: py-type.c:123
lookup_pointer_type
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:381
LONGEST
long long LONGEST
Definition: common-types.h:52
pyty_code::code
enum type_code code
Definition: py-type.c:78
iter_items
Definition: python-internal.h:361
vec.h
TYPE_CODE_COMPLEX
Definition: gdbtypes.h:167
typy_mapping
static PyMappingMethods typy_mapping
Definition: py-type.c:1537
type_object_as_number
static PyNumberMethods type_object_as_number
Definition: py-type.c:1502
pyty_type_object::type
PyObject_HEAD struct type * type
Definition: py-type.c:36
string_file
Definition: ui-file.h:106
type_to_type_object
PyObject * type_to_type_object(struct type *type)
Definition: py-type.c:1320