]> Git Repo - binutils.git/blob - gdb/python/py-frame.c
Update copyright year range in all GDB files
[binutils.git] / gdb / python / py-frame.c
1 /* Python interface to stack frames
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 "charset.h"
22 #include "block.h"
23 #include "frame.h"
24 #include "symtab.h"
25 #include "stack.h"
26 #include "value.h"
27 #include "python-internal.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "user-regs.h"
31 #include "py-ref.h"
32
33 typedef struct {
34   PyObject_HEAD
35   struct frame_id frame_id;
36   struct gdbarch *gdbarch;
37
38   /* Marks that the FRAME_ID member actually holds the ID of the frame next
39      to this, and not this frames' ID itself.  This is a hack to permit Python
40      frame objects which represent invalid frames (i.e., the last frame_info
41      in a corrupt stack).  The problem arises from the fact that this code
42      relies on FRAME_ID to uniquely identify a frame, which is not always true
43      for the last "frame" in a corrupt stack (it can have a null ID, or the same
44      ID as the  previous frame).  Whenever get_prev_frame returns NULL, we
45      record the frame_id of the next frame and set FRAME_ID_IS_NEXT to 1.  */
46   int frame_id_is_next;
47 } frame_object;
48
49 /* Require a valid frame.  This must be called inside a TRY_CATCH, or
50    another context in which a gdb exception is allowed.  */
51 #define FRAPY_REQUIRE_VALID(frame_obj, frame)           \
52     do {                                                \
53       frame = frame_object_to_frame_info (frame_obj);   \
54       if (frame == NULL)                                \
55         error (_("Frame is invalid."));                 \
56     } while (0)
57
58 /* Returns the frame_info object corresponding to the given Python Frame
59    object.  If the frame doesn't exist anymore (the frame id doesn't
60    correspond to any frame in the inferior), returns NULL.  */
61
62 struct frame_info *
63 frame_object_to_frame_info (PyObject *obj)
64 {
65   frame_object *frame_obj = (frame_object *) obj;
66   struct frame_info *frame;
67
68   frame = frame_find_by_id (frame_obj->frame_id);
69   if (frame == NULL)
70     return NULL;
71
72   if (frame_obj->frame_id_is_next)
73     frame = get_prev_frame (frame);
74
75   return frame;
76 }
77
78 /* Called by the Python interpreter to obtain string representation
79    of the object.  */
80
81 static PyObject *
82 frapy_str (PyObject *self)
83 {
84   string_file strfile;
85
86   fprint_frame_id (&strfile, ((frame_object *) self)->frame_id);
87   return PyString_FromString (strfile.c_str ());
88 }
89
90 /* Implementation of gdb.Frame.is_valid (self) -> Boolean.
91    Returns True if the frame corresponding to the frame_id of this
92    object still exists in the inferior.  */
93
94 static PyObject *
95 frapy_is_valid (PyObject *self, PyObject *args)
96 {
97   struct frame_info *frame = NULL;
98
99   TRY
100     {
101       frame = frame_object_to_frame_info (self);
102     }
103   CATCH (except, RETURN_MASK_ALL)
104     {
105       GDB_PY_HANDLE_EXCEPTION (except);
106     }
107   END_CATCH
108
109   if (frame == NULL)
110     Py_RETURN_FALSE;
111
112   Py_RETURN_TRUE;
113 }
114
115 /* Implementation of gdb.Frame.name (self) -> String.
116    Returns the name of the function corresponding to this frame.  */
117
118 static PyObject *
119 frapy_name (PyObject *self, PyObject *args)
120 {
121   struct frame_info *frame;
122   gdb::unique_xmalloc_ptr<char> name;
123   enum language lang;
124   PyObject *result;
125
126   TRY
127     {
128       FRAPY_REQUIRE_VALID (self, frame);
129
130       name = find_frame_funname (frame, &lang, NULL);
131     }
132   CATCH (except, RETURN_MASK_ALL)
133     {
134       GDB_PY_HANDLE_EXCEPTION (except);
135     }
136   END_CATCH
137
138   if (name)
139     {
140       result = PyUnicode_Decode (name.get (), strlen (name.get ()),
141                                  host_charset (), NULL);
142     }
143   else
144     {
145       result = Py_None;
146       Py_INCREF (Py_None);
147     }
148
149   return result;
150 }
151
152 /* Implementation of gdb.Frame.type (self) -> Integer.
153    Returns the frame type, namely one of the gdb.*_FRAME constants.  */
154
155 static PyObject *
156 frapy_type (PyObject *self, PyObject *args)
157 {
158   struct frame_info *frame;
159   enum frame_type type = NORMAL_FRAME;/* Initialize to appease gcc warning.  */
160
161   TRY
162     {
163       FRAPY_REQUIRE_VALID (self, frame);
164
165       type = get_frame_type (frame);
166     }
167   CATCH (except, RETURN_MASK_ALL)
168     {
169       GDB_PY_HANDLE_EXCEPTION (except);
170     }
171   END_CATCH
172
173   return PyInt_FromLong (type);
174 }
175
176 /* Implementation of gdb.Frame.architecture (self) -> gdb.Architecture.
177    Returns the frame's architecture as a gdb.Architecture object.  */
178
179 static PyObject *
180 frapy_arch (PyObject *self, PyObject *args)
181 {
182   struct frame_info *frame = NULL;    /* Initialize to appease gcc warning.  */
183   frame_object *obj = (frame_object *) self;
184
185   TRY
186     {
187       FRAPY_REQUIRE_VALID (self, frame);
188     }
189   CATCH (except, RETURN_MASK_ALL)
190     {
191       GDB_PY_HANDLE_EXCEPTION (except);
192     }
193   END_CATCH
194
195   return gdbarch_to_arch_object (obj->gdbarch);
196 }
197
198 /* Implementation of gdb.Frame.unwind_stop_reason (self) -> Integer.
199    Returns one of the gdb.FRAME_UNWIND_* constants.  */
200
201 static PyObject *
202 frapy_unwind_stop_reason (PyObject *self, PyObject *args)
203 {
204   struct frame_info *frame = NULL;    /* Initialize to appease gcc warning.  */
205   enum unwind_stop_reason stop_reason;
206
207   TRY
208     {
209       FRAPY_REQUIRE_VALID (self, frame);
210     }
211   CATCH (except, RETURN_MASK_ALL)
212     {
213       GDB_PY_HANDLE_EXCEPTION (except);
214     }
215   END_CATCH
216
217   stop_reason = get_frame_unwind_stop_reason (frame);
218
219   return PyInt_FromLong (stop_reason);
220 }
221
222 /* Implementation of gdb.Frame.pc (self) -> Long.
223    Returns the frame's resume address.  */
224
225 static PyObject *
226 frapy_pc (PyObject *self, PyObject *args)
227 {
228   CORE_ADDR pc = 0;           /* Initialize to appease gcc warning.  */
229   struct frame_info *frame;
230
231   TRY
232     {
233       FRAPY_REQUIRE_VALID (self, frame);
234
235       pc = get_frame_pc (frame);
236     }
237   CATCH (except, RETURN_MASK_ALL)
238     {
239       GDB_PY_HANDLE_EXCEPTION (except);
240     }
241   END_CATCH
242
243   return gdb_py_long_from_ulongest (pc);
244 }
245
246 /* Implementation of gdb.Frame.read_register (self, register) -> gdb.Value.
247    Returns the value of a register in this frame.  */
248
249 static PyObject *
250 frapy_read_register (PyObject *self, PyObject *args)
251 {
252   const char *regnum_str;
253   struct value *val = NULL;
254
255   if (!PyArg_ParseTuple (args, "s", &regnum_str))
256     return NULL;
257
258   TRY
259     {
260       struct frame_info *frame;
261       int regnum;
262
263       FRAPY_REQUIRE_VALID (self, frame);
264
265       regnum = user_reg_map_name_to_regnum (get_frame_arch (frame),
266                                             regnum_str,
267                                             strlen (regnum_str));
268       if (regnum >= 0)
269         val = value_of_register (regnum, frame);
270
271       if (val == NULL)
272         PyErr_SetString (PyExc_ValueError, _("Unknown register."));
273     }
274   CATCH (except, RETURN_MASK_ALL)
275     {
276       GDB_PY_HANDLE_EXCEPTION (except);
277     }
278   END_CATCH
279
280   return val == NULL ? NULL : value_to_value_object (val);
281 }
282
283 /* Implementation of gdb.Frame.block (self) -> gdb.Block.
284    Returns the frame's code block.  */
285
286 static PyObject *
287 frapy_block (PyObject *self, PyObject *args)
288 {
289   struct frame_info *frame;
290   const struct block *block = NULL, *fn_block;
291
292   TRY
293     {
294       FRAPY_REQUIRE_VALID (self, frame);
295       block = get_frame_block (frame, NULL);
296     }
297   CATCH (except, RETURN_MASK_ALL)
298     {
299       GDB_PY_HANDLE_EXCEPTION (except);
300     }
301   END_CATCH
302
303   for (fn_block = block;
304        fn_block != NULL && BLOCK_FUNCTION (fn_block) == NULL;
305        fn_block = BLOCK_SUPERBLOCK (fn_block))
306     ;
307
308   if (block == NULL || fn_block == NULL || BLOCK_FUNCTION (fn_block) == NULL)
309     {
310       PyErr_SetString (PyExc_RuntimeError,
311                        _("Cannot locate block for frame."));
312       return NULL;
313     }
314
315   if (block)
316     {
317       return block_to_block_object
318         (block, symbol_objfile (BLOCK_FUNCTION (fn_block)));
319     }
320
321   Py_RETURN_NONE;
322 }
323
324
325 /* Implementation of gdb.Frame.function (self) -> gdb.Symbol.
326    Returns the symbol for the function corresponding to this frame.  */
327
328 static PyObject *
329 frapy_function (PyObject *self, PyObject *args)
330 {
331   struct symbol *sym = NULL;
332   struct frame_info *frame;
333
334   TRY
335     {
336       enum language funlang;
337
338       FRAPY_REQUIRE_VALID (self, frame);
339
340       gdb::unique_xmalloc_ptr<char> funname
341         = find_frame_funname (frame, &funlang, &sym);
342     }
343   CATCH (except, RETURN_MASK_ALL)
344     {
345       GDB_PY_HANDLE_EXCEPTION (except);
346     }
347   END_CATCH
348
349   if (sym)
350     return symbol_to_symbol_object (sym);
351
352   Py_RETURN_NONE;
353 }
354
355 /* Convert a frame_info struct to a Python Frame object.
356    Sets a Python exception and returns NULL on error.  */
357
358 PyObject *
359 frame_info_to_frame_object (struct frame_info *frame)
360 {
361   gdbpy_ref<frame_object> frame_obj (PyObject_New (frame_object,
362                                                    &frame_object_type));
363   if (frame_obj == NULL)
364     return NULL;
365
366   TRY
367     {
368
369       /* Try to get the previous frame, to determine if this is the last frame
370          in a corrupt stack.  If so, we need to store the frame_id of the next
371          frame and not of this one (which is possibly invalid).  */
372       if (get_prev_frame (frame) == NULL
373           && get_frame_unwind_stop_reason (frame) != UNWIND_NO_REASON
374           && get_next_frame (frame) != NULL)
375         {
376           frame_obj->frame_id = get_frame_id (get_next_frame (frame));
377           frame_obj->frame_id_is_next = 1;
378         }
379       else
380         {
381           frame_obj->frame_id = get_frame_id (frame);
382           frame_obj->frame_id_is_next = 0;
383         }
384       frame_obj->gdbarch = get_frame_arch (frame);
385     }
386   CATCH (except, RETURN_MASK_ALL)
387     {
388       gdbpy_convert_exception (except);
389       return NULL;
390     }
391   END_CATCH
392
393   return (PyObject *) frame_obj.release ();
394 }
395
396 /* Implementation of gdb.Frame.older (self) -> gdb.Frame.
397    Returns the frame immediately older (outer) to this frame, or None if
398    there isn't one.  */
399
400 static PyObject *
401 frapy_older (PyObject *self, PyObject *args)
402 {
403   struct frame_info *frame, *prev = NULL;
404   PyObject *prev_obj = NULL;   /* Initialize to appease gcc warning.  */
405
406   TRY
407     {
408       FRAPY_REQUIRE_VALID (self, frame);
409
410       prev = get_prev_frame (frame);
411     }
412   CATCH (except, RETURN_MASK_ALL)
413     {
414       GDB_PY_HANDLE_EXCEPTION (except);
415     }
416   END_CATCH
417
418   if (prev)
419     prev_obj = (PyObject *) frame_info_to_frame_object (prev);
420   else
421     {
422       Py_INCREF (Py_None);
423       prev_obj = Py_None;
424     }
425
426   return prev_obj;
427 }
428
429 /* Implementation of gdb.Frame.newer (self) -> gdb.Frame.
430    Returns the frame immediately newer (inner) to this frame, or None if
431    there isn't one.  */
432
433 static PyObject *
434 frapy_newer (PyObject *self, PyObject *args)
435 {
436   struct frame_info *frame, *next = NULL;
437   PyObject *next_obj = NULL;   /* Initialize to appease gcc warning.  */
438
439   TRY
440     {
441       FRAPY_REQUIRE_VALID (self, frame);
442
443       next = get_next_frame (frame);
444     }
445   CATCH (except, RETURN_MASK_ALL)
446     {
447       GDB_PY_HANDLE_EXCEPTION (except);
448     }
449   END_CATCH
450
451   if (next)
452     next_obj = (PyObject *) frame_info_to_frame_object (next);
453   else
454     {
455       Py_INCREF (Py_None);
456       next_obj = Py_None;
457     }
458
459   return next_obj;
460 }
461
462 /* Implementation of gdb.Frame.find_sal (self) -> gdb.Symtab_and_line.
463    Returns the frame's symtab and line.  */
464
465 static PyObject *
466 frapy_find_sal (PyObject *self, PyObject *args)
467 {
468   struct frame_info *frame;
469   PyObject *sal_obj = NULL;   /* Initialize to appease gcc warning.  */
470
471   TRY
472     {
473       FRAPY_REQUIRE_VALID (self, frame);
474
475       symtab_and_line sal = find_frame_sal (frame);
476       sal_obj = symtab_and_line_to_sal_object (sal);
477     }
478   CATCH (except, RETURN_MASK_ALL)
479     {
480       GDB_PY_HANDLE_EXCEPTION (except);
481     }
482   END_CATCH
483
484   return sal_obj;
485 }
486
487 /* Implementation of gdb.Frame.read_var_value (self, variable,
488    [block]) -> gdb.Value.  If the optional block argument is provided
489    start the search from that block, otherwise search from the frame's
490    current block (determined by examining the resume address of the
491    frame).  The variable argument must be a string or an instance of a
492    gdb.Symbol.  The block argument must be an instance of gdb.Block.  Returns
493    NULL on error, with a python exception set.  */
494 static PyObject *
495 frapy_read_var (PyObject *self, PyObject *args)
496 {
497   struct frame_info *frame;
498   PyObject *sym_obj, *block_obj = NULL;
499   struct symbol *var = NULL;    /* gcc-4.3.2 false warning.  */
500   const struct block *block = NULL;
501   struct value *val = NULL;
502
503   if (!PyArg_ParseTuple (args, "O|O", &sym_obj, &block_obj))
504     return NULL;
505
506   if (PyObject_TypeCheck (sym_obj, &symbol_object_type))
507     var = symbol_object_to_symbol (sym_obj);
508   else if (gdbpy_is_string (sym_obj))
509     {
510       gdb::unique_xmalloc_ptr<char>
511         var_name (python_string_to_target_string (sym_obj));
512
513       if (!var_name)
514         return NULL;
515
516       if (block_obj)
517         {
518           block = block_object_to_block (block_obj);
519           if (!block)
520             {
521               PyErr_SetString (PyExc_RuntimeError,
522                                _("Second argument must be block."));
523               return NULL;
524             }
525         }
526
527       TRY
528         {
529           struct block_symbol lookup_sym;
530           FRAPY_REQUIRE_VALID (self, frame);
531
532           if (!block)
533             block = get_frame_block (frame, NULL);
534           lookup_sym = lookup_symbol (var_name.get (), block, VAR_DOMAIN, NULL);
535           var = lookup_sym.symbol;
536           block = lookup_sym.block;
537         }
538       CATCH (except, RETURN_MASK_ALL)
539         {
540           gdbpy_convert_exception (except);
541           return NULL;
542         }
543       END_CATCH
544
545       if (!var)
546         {
547           PyErr_Format (PyExc_ValueError,
548                         _("Variable '%s' not found."), var_name.get ());
549
550           return NULL;
551         }
552     }
553   else
554     {
555       PyErr_SetString (PyExc_TypeError,
556                        _("Argument must be a symbol or string."));
557       return NULL;
558     }
559
560   TRY
561     {
562       FRAPY_REQUIRE_VALID (self, frame);
563
564       val = read_var_value (var, block, frame);
565     }
566   CATCH (except, RETURN_MASK_ALL)
567     {
568       GDB_PY_HANDLE_EXCEPTION (except);
569     }
570   END_CATCH
571
572   return value_to_value_object (val);
573 }
574
575 /* Select this frame.  */
576
577 static PyObject *
578 frapy_select (PyObject *self, PyObject *args)
579 {
580   struct frame_info *fi;
581
582   TRY
583     {
584       FRAPY_REQUIRE_VALID (self, fi);
585
586       select_frame (fi);
587     }
588   CATCH (except, RETURN_MASK_ALL)
589     {
590       GDB_PY_HANDLE_EXCEPTION (except);
591     }
592   END_CATCH
593
594   Py_RETURN_NONE;
595 }
596
597 /* Implementation of gdb.newest_frame () -> gdb.Frame.
598    Returns the newest frame object.  */
599
600 PyObject *
601 gdbpy_newest_frame (PyObject *self, PyObject *args)
602 {
603   struct frame_info *frame = NULL;
604
605   TRY
606     {
607       frame = get_current_frame ();
608     }
609   CATCH (except, RETURN_MASK_ALL)
610     {
611       GDB_PY_HANDLE_EXCEPTION (except);
612     }
613   END_CATCH
614
615   return frame_info_to_frame_object (frame);
616 }
617
618 /* Implementation of gdb.selected_frame () -> gdb.Frame.
619    Returns the selected frame object.  */
620
621 PyObject *
622 gdbpy_selected_frame (PyObject *self, PyObject *args)
623 {
624   struct frame_info *frame = NULL;
625
626   TRY
627     {
628       frame = get_selected_frame ("No frame is currently selected.");
629     }
630   CATCH (except, RETURN_MASK_ALL)
631     {
632       GDB_PY_HANDLE_EXCEPTION (except);
633     }
634   END_CATCH
635
636   return frame_info_to_frame_object (frame);
637 }
638
639 /* Implementation of gdb.stop_reason_string (Integer) -> String.
640    Return a string explaining the unwind stop reason.  */
641
642 PyObject *
643 gdbpy_frame_stop_reason_string (PyObject *self, PyObject *args)
644 {
645   int reason;
646   const char *str;
647
648   if (!PyArg_ParseTuple (args, "i", &reason))
649     return NULL;
650
651   if (reason < UNWIND_FIRST || reason > UNWIND_LAST)
652     {
653       PyErr_SetString (PyExc_ValueError,
654                        _("Invalid frame stop reason."));
655       return NULL;
656     }
657
658   str = unwind_stop_reason_to_string ((enum unwind_stop_reason) reason);
659   return PyUnicode_Decode (str, strlen (str), host_charset (), NULL);
660 }
661
662 /* Implements the equality comparison for Frame objects.
663    All other comparison operators will throw a TypeError Python exception,
664    as they aren't valid for frames.  */
665
666 static PyObject *
667 frapy_richcompare (PyObject *self, PyObject *other, int op)
668 {
669   int result;
670
671   if (!PyObject_TypeCheck (other, &frame_object_type)
672       || (op != Py_EQ && op != Py_NE))
673     {
674       Py_INCREF (Py_NotImplemented);
675       return Py_NotImplemented;
676     }
677
678   if (frame_id_eq (((frame_object *) self)->frame_id,
679                    ((frame_object *) other)->frame_id))
680     result = Py_EQ;
681   else
682     result = Py_NE;
683
684   if (op == result)
685     Py_RETURN_TRUE;
686   Py_RETURN_FALSE;
687 }
688
689 /* Sets up the Frame API in the gdb module.  */
690
691 int
692 gdbpy_initialize_frames (void)
693 {
694   frame_object_type.tp_new = PyType_GenericNew;
695   if (PyType_Ready (&frame_object_type) < 0)
696     return -1;
697
698   /* Note: These would probably be best exposed as class attributes of
699      Frame, but I don't know how to do it except by messing with the
700      type's dictionary.  That seems too messy.  */
701   if (PyModule_AddIntConstant (gdb_module, "NORMAL_FRAME", NORMAL_FRAME) < 0
702       || PyModule_AddIntConstant (gdb_module, "DUMMY_FRAME", DUMMY_FRAME) < 0
703       || PyModule_AddIntConstant (gdb_module, "INLINE_FRAME", INLINE_FRAME) < 0
704       || PyModule_AddIntConstant (gdb_module, "TAILCALL_FRAME",
705                                   TAILCALL_FRAME) < 0
706       || PyModule_AddIntConstant (gdb_module, "SIGTRAMP_FRAME",
707                                   SIGTRAMP_FRAME) < 0
708       || PyModule_AddIntConstant (gdb_module, "ARCH_FRAME", ARCH_FRAME) < 0
709       || PyModule_AddIntConstant (gdb_module, "SENTINEL_FRAME",
710                                   SENTINEL_FRAME) < 0)
711     return -1;
712
713 #define SET(name, description) \
714   if (PyModule_AddIntConstant (gdb_module, "FRAME_"#name, name) < 0) \
715     return -1;
716 #include "unwind_stop_reasons.def"
717 #undef SET
718
719   return gdb_pymodule_addobject (gdb_module, "Frame",
720                                  (PyObject *) &frame_object_type);
721 }
722
723 \f
724
725 static PyMethodDef frame_object_methods[] = {
726   { "is_valid", frapy_is_valid, METH_NOARGS,
727     "is_valid () -> Boolean.\n\
728 Return true if this frame is valid, false if not." },
729   { "name", frapy_name, METH_NOARGS,
730     "name () -> String.\n\
731 Return the function name of the frame, or None if it can't be determined." },
732   { "type", frapy_type, METH_NOARGS,
733     "type () -> Integer.\n\
734 Return the type of the frame." },
735   { "architecture", frapy_arch, METH_NOARGS,
736     "architecture () -> gdb.Architecture.\n\
737 Return the architecture of the frame." },
738   { "unwind_stop_reason", frapy_unwind_stop_reason, METH_NOARGS,
739     "unwind_stop_reason () -> Integer.\n\
740 Return the reason why it's not possible to find frames older than this." },
741   { "pc", frapy_pc, METH_NOARGS,
742     "pc () -> Long.\n\
743 Return the frame's resume address." },
744   { "read_register", frapy_read_register, METH_VARARGS,
745     "read_register (register_name) -> gdb.Value\n\
746 Return the value of the register in the frame." },
747   { "block", frapy_block, METH_NOARGS,
748     "block () -> gdb.Block.\n\
749 Return the frame's code block." },
750   { "function", frapy_function, METH_NOARGS,
751     "function () -> gdb.Symbol.\n\
752 Returns the symbol for the function corresponding to this frame." },
753   { "older", frapy_older, METH_NOARGS,
754     "older () -> gdb.Frame.\n\
755 Return the frame that called this frame." },
756   { "newer", frapy_newer, METH_NOARGS,
757     "newer () -> gdb.Frame.\n\
758 Return the frame called by this frame." },
759   { "find_sal", frapy_find_sal, METH_NOARGS,
760     "find_sal () -> gdb.Symtab_and_line.\n\
761 Return the frame's symtab and line." },
762   { "read_var", frapy_read_var, METH_VARARGS,
763     "read_var (variable) -> gdb.Value.\n\
764 Return the value of the variable in this frame." },
765   { "select", frapy_select, METH_NOARGS,
766     "Select this frame as the user's current frame." },
767   {NULL}  /* Sentinel */
768 };
769
770 PyTypeObject frame_object_type = {
771   PyVarObject_HEAD_INIT (NULL, 0)
772   "gdb.Frame",                    /* tp_name */
773   sizeof (frame_object),          /* tp_basicsize */
774   0,                              /* tp_itemsize */
775   0,                              /* tp_dealloc */
776   0,                              /* tp_print */
777   0,                              /* tp_getattr */
778   0,                              /* tp_setattr */
779   0,                              /* tp_compare */
780   0,                              /* tp_repr */
781   0,                              /* tp_as_number */
782   0,                              /* tp_as_sequence */
783   0,                              /* tp_as_mapping */
784   0,                              /* tp_hash  */
785   0,                              /* tp_call */
786   frapy_str,                      /* tp_str */
787   0,                              /* tp_getattro */
788   0,                              /* tp_setattro */
789   0,                              /* tp_as_buffer */
790   Py_TPFLAGS_DEFAULT,             /* tp_flags */
791   "GDB frame object",             /* tp_doc */
792   0,                              /* tp_traverse */
793   0,                              /* tp_clear */
794   frapy_richcompare,              /* tp_richcompare */
795   0,                              /* tp_weaklistoffset */
796   0,                              /* tp_iter */
797   0,                              /* tp_iternext */
798   frame_object_methods,           /* tp_methods */
799   0,                              /* tp_members */
800   0,                              /* tp_getset */
801   0,                              /* tp_base */
802   0,                              /* tp_dict */
803   0,                              /* tp_descr_get */
804   0,                              /* tp_descr_set */
805   0,                              /* tp_dictoffset */
806   0,                              /* tp_init */
807   0,                              /* tp_alloc */
808 };
This page took 0.073019 seconds and 4 git commands to generate.