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