+2020-12-04 Tom Tromey <tromey@adacore.com>
+
+ * linespec.c (struct linespec_token): Rename; remove typedef.
+ * guile/scm-block.c (struct block_smob): Remove typedef.
+ (struct block_syms_progress_smob): Likewise.
+ * guile/scm-symbol.c (struct symbol_smob): Remove typedef.
+ * guile/scm-symtab.c (symtab_smob): Remove typedef.
+ (struct sal_smob): Remove typedef.
+ * guile/scm-param.c (struct param_smob): Remove typedef.
+ * guile/scm-progspace.c (struct pspace_smob): Rename.
+ * guile/scm-objfile.c (struct objfile_smob): Rename.
+ * guile/scm-iterator.c (struct iterator_smob): Rename.
+ * guile/scm-frame.c (struct frame_smob): Rename.
+ * guile/scm-arch.c (struct arch_smob): Rename.
+ * guile/scm-type.c (struct field_smob): Remove typedef.
+ (struct type_smob): Rename.
+ * guile/scm-cmd.c (struct command_smob): Remove typedef.
+ * guile/scm-ports.c (struct ioscm_memory_port): Remove typedef.
+ * guile/scm-value.c (struct value_smob): Remove typedef.
+ * guile/scm-lazy-string.c (lazy_string_smob): Remove typedef.
+ * guile/guile-internal.h (struct scheme_variable)
+ (struct scheme_function, struct scheme_integer_constant)
+ (struct gdb_smob, struct chained_gdb_smob)
+ (struct eqable_gdb_smob, arch_smob, frame_smob, iterator_smob)
+ (objfile_smob, pspace_smob, type_smob): Remove typedef.
+ * guile/scm-pretty-print.c (pretty_printer_smob): Remove typedef.
+ (struct pretty_printer_worker_smob): Remove typedef.
+ * guile/scm-exception.c (struct exception_smob): Remove typedef.
+ * python/py-block.c (struct block_object): Remove typedef.
+ (block_syms_iterator_object): Update.
+ (set_block): Update.
+ (block_syms_iterator_object): Remove typedef.
+ * python/py-inferior.c (struct membuf_object): Remove typedef.
+ * python/py-symtab.c (struct symtab_object): Remove typedef.
+ (set_symtab): Update.
+ (sal_object): Remove typedef.
+ (set_sal): Update.
+ * python/py-frame.c (frame_object): Remove typedef.
+ * python/py-record-btrace.c (struct btpy_list_object): Remove
+ typedef.
+ * python/py-arch.c (struct arch_object): Remove typedef.
+ * python/py-linetable.c (struct linetable_entry_object)
+ (linetable_object, struct ltpy_iterator_object): Remove typedef.
+ * python/py-events.h (eventregistry_object): Remove typedef.
+ (struct events_object): Remove typedef.
+ * python/python-internal.h (gdbpy_breakpoint_object): Remove
+ typedef.
+ (thread_object): Remove typedef.
+ * python/py-progspace.c (pspace_object): Remove typedef.
+ * python/py-value.c (struct value_object): Remove typedef.
+ * python/py-record.h (recpy_record_object): Remove typedef.
+ (struct recpy_element_object): Remove typedef.
+ * python/py-lazy-string.c (lazy_string_object): Remove typedef.
+ * python/py-objfile.c (objfile_object): Remove typedef.
+ * python/py-cmd.c (struct cmdpy_object): Remove typedef.
+ * python/py-type.c (type_object): Remove typedef.
+ (typy_iterator_object): Update.
+ (set_type): Update.
+ (field_object): Remove typedef.
+ (typy_iterator_object): Remove typedef.
+ * python/py-registers.c (register_descriptor_iterator_object):
+ Remove typedef.
+ (struct register_descriptor_object)
+ (struct reggroup_iterator_object, struct reggroup_object): Remove
+ typedef.
+ * python/py-record.c (recpy_gap_object): Remove typedef.
+ * python/py-symbol.c (symbol_object): Remove typedef.
+ (set_symbol): Update.
+ * python/py-event.h (event_object): Remove typedef.
+ * python/py-param.c (parmpy_object): Remove typedef.
+ * python/py-instruction.c (struct py_insn_obj): Remove typedef.
+ * python/py-unwind.c (struct pending_frame_object): Remove typedef.
+ (unwind_info_object, struct cached_frame_info): Likewise.
+
2020-12-04 Tom Tromey <tromey@adacore.com>
* value.c (value_internal_function_name): Make return type const.
/* Scheme variables to define during initialization. */
-typedef struct
+struct scheme_variable
{
const char *name;
SCM value;
const char *doc_string;
-} scheme_variable;
+};
/* End of scheme_variable table mark. */
/* Scheme functions to define during initialization. */
-typedef struct
+struct scheme_function
{
const char *name;
int required;
int rest;
scm_t_subr func;
const char *doc_string;
-} scheme_function;
+};
/* End of scheme_function table mark. */
/* Useful for defining a set of constants. */
-typedef struct
+struct scheme_integer_constant
{
const char *name;
int value;
-} scheme_integer_constant;
+};
#define END_INTEGER_CONSTANTS { NULL, 0 }
#define GDB_SMOB_HEAD \
int empty_base_class;
-typedef struct
+struct gdb_smob
{
GDB_SMOB_HEAD
-} gdb_smob;
+};
-typedef struct _chained_gdb_smob
+struct chained_gdb_smob
{
GDB_SMOB_HEAD
- struct _chained_gdb_smob *prev;
- struct _chained_gdb_smob *next;
-} chained_gdb_smob;
+ chained_gdb_smob *prev;
+ chained_gdb_smob *next;
+};
-typedef struct _eqable_gdb_smob
+struct eqable_gdb_smob
{
GDB_SMOB_HEAD
we need to invalidate the objects: we can do that using the same hashtab
used to record the smob for eq-ability. */
SCM containing_scm;
-} eqable_gdb_smob;
+};
#undef GDB_SMOB_HEAD
/* scm-arch.c */
-typedef struct _arch_smob arch_smob;
+struct arch_smob;
extern struct gdbarch *arscm_get_gdbarch (arch_smob *a_smob);
/* scm-frame.c */
-typedef struct _frame_smob frame_smob;
+struct frame_smob;
extern int frscm_is_frame (SCM scm);
/* scm-iterator.c */
-typedef struct _iterator_smob iterator_smob;
+struct iterator_smob;
extern SCM itscm_iterator_smob_object (iterator_smob *i_smob);
/* scm-objfile.c */
-typedef struct _objfile_smob objfile_smob;
+struct objfile_smob;
extern SCM ofscm_objfile_smob_pretty_printers (objfile_smob *o_smob);
/* scm-progspace.c */
-typedef struct _pspace_smob pspace_smob;
+struct pspace_smob;
extern SCM psscm_pspace_smob_pretty_printers (const pspace_smob *);
/* scm-type.c */
-typedef struct _type_smob type_smob;
+struct type_smob;
extern int tyscm_is_type (SCM scm);
#include "arch-utils.h"
#include "guile-internal.h"
-/* The <gdb:arch> smob.
- The typedef for this struct is in guile-internal.h. */
+/* The <gdb:arch> smob. */
-struct _arch_smob
+struct arch_smob
{
/* This always appears first. */
gdb_smob base;
/* A smob describing a gdb block. */
-typedef struct _block_smob
+struct block_smob
{
/* This always appears first.
We want blocks to be eq?-able. And we need to be able to invalidate
between a block and an object file. When a block is created also
store a pointer to the object file for later use. */
struct objfile *objfile;
-} block_smob;
+};
/* To iterate over block symbols from Scheme we need to store
struct block_iterator somewhere. This is stored in the "progress" field
Remember: While iterating over block symbols, you must continually check
whether the block is still valid. */
-typedef struct
+struct block_syms_progress_smob
{
/* This always appears first. */
gdb_smob base;
/* Has the iterator been initialized flag. */
int initialized_p;
-} block_syms_progress_smob;
+};
static const char block_smob_name[] = "gdb:block";
static const char block_syms_progress_smob_name[] = "gdb:block-symbols-iterator";
any side-effects. This means that the smob needs to store everything
that was passed to make-command. */
-typedef struct _command_smob
+struct command_smob
{
/* This always appears first. */
gdb_smob base;
the object since a reference to it comes from non-gc-managed space
(the command context pointer). */
SCM containing_scm;
-} command_smob;
+};
static const char command_smob_name[] = "gdb:command";
One important invariant is that <gdb:exception> smobs are never a valid
result of a function, other than to signify an exception occurred. */
-typedef struct
+struct exception_smob
{
/* This always appears first. */
gdb_smob base;
/* The key and args parameters to "throw". */
SCM key;
SCM args;
-} exception_smob;
+};
static const char exception_smob_name[] = "gdb:exception";
#include "value.h"
#include "guile-internal.h"
-/* The <gdb:frame> smob.
- The typedef for this struct is in guile-internal.h. */
+/* The <gdb:frame> smob. */
-struct _frame_smob
+struct frame_smob
{
/* This always appears first. */
eqable_gdb_smob base;
/* A smob for iterating over something.
Typically this is used when computing a list of everything is
- too expensive.
- The typedef for this struct is in guile-internal.h. */
+ too expensive. */
-struct _iterator_smob
+struct iterator_smob
{
/* This always appears first. */
gdb_smob base;
/* The <gdb:lazy-string> smob. */
-typedef struct
+struct lazy_string_smob
{
/* This always appears first. */
gdb_smob base;
This is recorded as an SCM object so that we take advantage of support for
preserving the type should its owning objfile go away. */
SCM type;
-} lazy_string_smob;
+};
static const char lazy_string_smob_name[] = "gdb:lazy-string";
#include "language.h"
#include "guile-internal.h"
-/* The <gdb:objfile> smob.
- The typedef for this struct is in guile-internal.h. */
+/* The <gdb:objfile> smob. */
-struct _objfile_smob
+struct objfile_smob
{
/* This always appears first. */
gdb_smob base;
N.B. There is no free function for this smob.
All objects pointed to by this smob must live in GC space. */
-typedef struct _param_smob
+struct param_smob
{
/* This always appears first. */
gdb_smob base;
protect/unprotect the object since a reference to it comes from
non-gc-managed space (the command context pointer). */
SCM containing_scm;
-} param_smob;
+};
static const char param_smob_name[] = "gdb:parameter";
/* Data for a memory port. */
-typedef struct
+struct ioscm_memory_port
{
/* Bounds of memory range this port is allowed to access: [start, end).
This means that 0xff..ff is not accessible. I can live with that. */
the user to specify these values to help get something similar. */
unsigned read_buf_size, write_buf_size;
#endif
-} ioscm_memory_port;
+};
/* Copies of the original system input/output/error ports.
These are recorded for debugging purposes. */
/* The <gdb:pretty-printer> smob. */
-typedef struct
+struct pretty_printer_smob
{
/* This must appear first. */
gdb_smob base;
SCM lookup;
/* Note: Attaching subprinters to this smob is left to Scheme. */
-} pretty_printer_smob;
+};
/* The <gdb:pretty-printer-worker> smob. */
-typedef struct
+struct pretty_printer_worker_smob
{
/* This must appear first. */
gdb_smob base;
The iterator returns a pair for each iteration: (name . value),
where "value" can have the same types as to_string. */
SCM children;
-} pretty_printer_worker_smob;
+};
static const char pretty_printer_smob_name[] =
"gdb:pretty-printer";
/* NOTE: Python exports the name "Progspace", so we export "progspace".
Internally we shorten that to "pspace". */
-/* The <gdb:progspace> smob.
- The typedef for this struct is in guile-internal.h. */
+/* The <gdb:progspace> smob. */
-struct _pspace_smob
+struct pspace_smob
{
/* This always appears first. */
gdb_smob base;
/* The <gdb:symbol> smob. */
-typedef struct
+struct symbol_smob
{
/* This always appears first. */
eqable_gdb_smob base;
/* The GDB symbol structure this smob is wrapping. */
struct symbol *symbol;
-} symbol_smob;
+};
static const char symbol_smob_name[] = "gdb:symbol";
/* A <gdb:symtab> smob. */
-typedef struct
+struct symtab_smob
{
/* This always appears first.
eqable_gdb_smob is used so that symtabs are eq?-able.
If this is NULL the symtab is invalid. This can happen when the
underlying objfile is freed. */
struct symtab *symtab;
-} symtab_smob;
+};
/* A <gdb:sal> smob.
A smob describing a gdb symtab-and-line object.
the validity of symtab_scm.
TODO: Sals are not eq?-able at the moment, or even comparable. */
-typedef struct
+struct sal_smob
{
/* This always appears first. */
gdb_smob base;
this pointer will not be updated. Use symtab_scm instead to determine
if this sal is valid. */
struct symtab_and_line sal;
-} sal_smob;
+};
static const char symtab_smob_name[] = "gdb:symtab";
/* "symtab-and-line" is pretty long, and "sal" is short and unique. */
/* The <gdb:type> smob.
The type is chained with all types associated with its objfile, if any.
This lets us copy the underlying struct type when the objfile is
- deleted.
- The typedef for this struct is in guile-internal.h. */
+ deleted. */
-struct _type_smob
+struct type_smob
{
/* This always appears first.
eqable_gdb_smob is used so that types are eq?-able.
/* A field smob. */
-typedef struct
+struct field_smob
{
/* This always appears first. */
gdb_smob base;
/* The field number in TYPE_SCM. */
int field_num;
-} field_smob;
+};
static const char type_smob_name[] = "gdb:type";
static const char field_smob_name[] = "gdb:field";
/* The <gdb:value> smob. */
-typedef struct _value_smob
+struct value_smob
{
/* This always appears first. */
gdb_smob base;
/* Doubly linked list of values in values_in_scheme.
IWBN to use a chained_gdb_smob instead, which is doable, it just requires
a bit more casting than normal. */
- struct _value_smob *next;
- struct _value_smob *prev;
+ value_smob *next;
+ value_smob *prev;
struct value *value;
SCM address;
SCM type;
SCM dynamic_type;
-} value_smob;
+};
static const char value_smob_name[] = "gdb:value";
/* A token of the linespec lexer */
-struct ls_token
+struct linespec_token
{
/* The type of the token */
linespec_token_type type;
const char *keyword;
} data;
};
-typedef struct ls_token linespec_token;
#define LS_TOKEN_STOKEN(TOK) (TOK).data.string
#define LS_TOKEN_KEYWORD(TOK) (TOK).data.keyword
#include "disasm.h"
#include "python-internal.h"
-typedef struct arch_object_type_object {
+struct arch_object {
PyObject_HEAD
struct gdbarch *gdbarch;
-} arch_object;
+};
static struct gdbarch_data *arch_object_data = NULL;
#include "python-internal.h"
#include "objfiles.h"
-typedef struct blpy_block_object {
+struct block_object {
PyObject_HEAD
/* The GDB block structure that represents a frame's code block. */
const struct block *block;
struct objfile *objfile;
/* Keep track of all blocks with a doubly-linked list. Needed for
block invalidation if the source object file has been freed. */
- struct blpy_block_object *prev;
- struct blpy_block_object *next;
-} block_object;
+ block_object *prev;
+ block_object *next;
+};
-typedef struct {
+struct block_syms_iterator_object {
PyObject_HEAD
/* The block. */
const struct block *block;
/* Pointer back to the original source block object. Needed to
check if the block is still valid, and has not been invalidated
when an object file has been freed. */
- struct blpy_block_object *source;
-} block_syms_iterator_object;
+ block_object *source;
+};
/* Require a valid block. All access to block_object->block should be
gated by this call. */
if (objfile)
{
obj->objfile = objfile;
- obj->next = ((struct blpy_block_object *)
+ obj->next = ((block_object *)
objfile_data (objfile, blpy_objfile_data_key));
if (obj->next)
obj->next->prev = obj;
struct cmd_list_element *sub_list;
};
-typedef struct cmdpy_object cmdpy_object;
-
extern PyTypeObject cmdpy_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("cmdpy_object");
#include "py-event-types.def"
#undef GDB_PY_DEFINE_EVENT_TYPE
-typedef struct
+struct event_object
{
PyObject_HEAD
PyObject *dict;
-} event_object;
+};
extern int emit_continue_event (ptid_t ptid);
extern int emit_exited_event (const LONGEST *exit_code, struct inferior *inf);
/* Stores a list of objects to be notified when the event for which this
registry tracks occurs. */
-typedef struct
+struct eventregistry_object
{
PyObject_HEAD
PyObject *callbacks;
-} eventregistry_object;
+};
/* Struct holding references to event registries both in python and c.
This is meant to be a singleton. */
-typedef struct
+struct events_object
{
#define GDB_PY_DEFINE_EVENT(name) \
eventregistry_object *name;
PyObject *module;
-} events_object;
+};
/* Python events singleton. */
extern events_object gdb_py_events;
#include "symfile.h"
#include "objfiles.h"
-typedef struct {
+struct frame_object {
PyObject_HEAD
struct frame_id frame_id;
struct gdbarch *gdbarch;
ID as the previous frame). Whenever get_prev_frame returns NULL, we
record the frame_id of the next frame and set FRAME_ID_IS_NEXT to 1. */
int frame_id_is_next;
-} frame_object;
+};
/* Require a valid frame. This must be called inside a TRY_CATCH, or
another context in which a gdb exception is allowed. */
static const struct inferior_data *infpy_inf_data_key;
-typedef struct {
+struct membuf_object {
PyObject_HEAD
void *buffer;
/* These are kept just for mbpy_str. */
CORE_ADDR addr;
CORE_ADDR length;
-} membuf_object;
+};
extern PyTypeObject membuf_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("membuf_object");
/* Python instruction object. */
-typedef struct {
+struct py_insn_obj {
PyObject_HEAD
-} py_insn_obj;
+};
/* Getter function for gdb.Instruction attributes. */
#include "valprint.h"
#include "language.h"
-typedef struct {
+struct lazy_string_object {
PyObject_HEAD
/* Holds the address of the lazy string. */
This is recorded as a PyObject so that we take advantage of support for
preserving the type should its owning objfile go away. */
PyObject *type;
-} lazy_string_object;
+};
extern PyTypeObject lazy_string_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("lazy_string_object");
#include "defs.h"
#include "python-internal.h"
-typedef struct {
+struct linetable_entry_object {
PyObject_HEAD
/* The line table source line. */
int line;
/* The pc associated with the source line. */
CORE_ADDR pc;
-} linetable_entry_object;
+};
extern PyTypeObject linetable_entry_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("linetable_entry_object");
-typedef struct {
+struct linetable_object {
PyObject_HEAD
/* The symtab python object. We store the Python object here as the
underlying symtab can become invalid, and we have to run validity
checks on it. */
PyObject *symtab;
-} linetable_object;
+};
extern PyTypeObject linetable_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("linetable_object");
-typedef struct {
+struct ltpy_iterator_object {
PyObject_HEAD
/* The current entry in the line table for the iterator */
int current_index;
check if the line table is still valid, and has not been invalidated
when an object file has been freed. */
PyObject *source;
-} ltpy_iterator_object;
+};
extern PyTypeObject ltpy_iterator_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("ltpy_iterator_object");
#include "build-id.h"
#include "symtab.h"
-typedef struct
+struct objfile_object
{
PyObject_HEAD
/* The debug method matcher list. */
PyObject *xmethods;
-} objfile_object;
+};
extern PyTypeObject objfile_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("objfile_object");
const char **enumeration;
};
-typedef struct parmpy_object parmpy_object;
-
extern PyTypeObject parmpy_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("parmpy_object");
#include "solib.h"
#include "block.h"
-typedef struct
+struct pspace_object
{
PyObject_HEAD
/* The debug method list. */
PyObject *xmethods;
-} pspace_object;
+};
extern PyTypeObject pspace_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pspace_object");
/* Python object for btrace record lists. */
-typedef struct {
+struct btpy_list_object {
PyObject_HEAD
/* The thread this list belongs to. */
/* Either &BTPY_CALL_TYPE or &RECPY_INSN_TYPE. */
PyTypeObject* element_type;
-} btpy_list_object;
+};
/* Python type for btrace lists. */
};
/* Python RecordGap object. */
-typedef struct
+struct recpy_gap_object
{
PyObject_HEAD
/* Element number. */
Py_ssize_t number;
-} recpy_gap_object;
+};
/* Implementation of record.method. */
#include "record.h"
/* Python Record object. */
-typedef struct
+struct recpy_record_object
{
PyObject_HEAD
/* The current recording method. */
enum record_method method;
-} recpy_record_object;
+};
/* Python recorded element object. This is generic enough to represent
recorded instructions as well as recorded function call segments, hence the
generic name. */
-typedef struct
+struct recpy_element_object
{
PyObject_HEAD
/* Element number. */
Py_ssize_t number;
-} recpy_element_object;
+};
/* Python RecordInstruction type. */
extern PyTypeObject recpy_insn_type;
static struct gdbarch_data *gdbpy_register_object_data = NULL;
/* Structure for iterator over register descriptors. */
-typedef struct {
+struct register_descriptor_iterator_object {
PyObject_HEAD
/* The register group that the user is iterating over. This will never
/* Pointer back to the architecture we're finding registers for. */
struct gdbarch *gdbarch;
-} register_descriptor_iterator_object;
+};
extern PyTypeObject register_descriptor_iterator_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_iterator_object");
/* A register descriptor. */
-typedef struct {
+struct register_descriptor_object {
PyObject_HEAD
/* The register this is a descriptor for. */
/* The architecture this is a register for. */
struct gdbarch *gdbarch;
-} register_descriptor_object;
+};
extern PyTypeObject register_descriptor_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_object");
/* Structure for iterator over register groups. */
-typedef struct {
+struct reggroup_iterator_object {
PyObject_HEAD
/* The last register group returned. Initially this will be NULL. */
/* Pointer back to the architecture we're finding registers for. */
struct gdbarch *gdbarch;
-} reggroup_iterator_object;
+};
extern PyTypeObject reggroup_iterator_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_iterator_object");
/* A register group object. */
-typedef struct {
+struct reggroup_object {
PyObject_HEAD
/* The register group being described. */
struct reggroup *reggroup;
-} reggroup_object;
+};
extern PyTypeObject reggroup_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_object");
#include "objfiles.h"
#include "symfile.h"
-typedef struct sympy_symbol_object {
+struct symbol_object {
PyObject_HEAD
/* The GDB symbol structure this object is wrapping. */
struct symbol *symbol;
doubly-linked list, rooted in the objfile. This lets us
invalidate the underlying struct symbol when the objfile is
deleted. */
- struct sympy_symbol_object *prev;
- struct sympy_symbol_object *next;
-} symbol_object;
+ symbol_object *prev;
+ symbol_object *next;
+};
/* Require a valid symbol. All access to symbol_object->symbol should be
gated by this call. */
{
struct objfile *objfile = symbol_objfile (symbol);
- obj->next = ((struct sympy_symbol_object *)
+ obj->next = ((symbol_object *)
objfile_data (objfile, sympy_objfile_data_key));
if (obj->next)
obj->next->prev = obj;
#include "objfiles.h"
#include "block.h"
-typedef struct stpy_symtab_object {
+struct symtab_object {
PyObject_HEAD
/* The GDB Symbol table structure. */
struct symtab *symtab;
a doubly-linked list, rooted in the objfile. This allows
invalidation of the underlying struct symtab when the objfile is
deleted. */
- struct stpy_symtab_object *prev;
- struct stpy_symtab_object *next;
-} symtab_object;
+ symtab_object *prev;
+ symtab_object *next;
+};
extern PyTypeObject symtab_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("symtab_object");
} \
} while (0)
-typedef struct salpy_sal_object {
+struct sal_object {
PyObject_HEAD
/* The GDB Symbol table structure. */
PyObject *symtab;
track with a doubly-linked list, rooted in the objfile. This
allows invalidation of the underlying struct symtab_and_line
when the objfile is deleted. */
- struct salpy_sal_object *prev;
- struct salpy_sal_object *next;
-} sal_object;
+ sal_object *prev;
+ sal_object *next;
+};
extern PyTypeObject sal_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("sal_object");
symtab *symtab = symtab_object_to_symtab (sal_obj->symtab);
sal_obj->next
- = ((struct salpy_sal_object *) objfile_data (SYMTAB_OBJFILE (symtab),
- salpy_objfile_data_key));
+ = ((sal_object *) objfile_data (SYMTAB_OBJFILE (symtab),
+ salpy_objfile_data_key));
if (sal_obj->next)
sal_obj->next->prev = sal_obj;
if (symtab)
{
obj->next
- = ((struct stpy_symtab_object *)
+ = ((symtab_object *)
objfile_data (SYMTAB_OBJFILE (symtab), stpy_objfile_data_key));
if (obj->next)
obj->next->prev = obj;
#include "language.h"
#include "typeprint.h"
-typedef struct pyty_type_object
+struct type_object
{
PyObject_HEAD
struct type *type;
/* If a Type object is associated with an objfile, it is kept on a
doubly-linked list, rooted in the objfile. This lets us copy the
underlying struct type when the objfile is deleted. */
- struct pyty_type_object *prev;
- struct pyty_type_object *next;
-} type_object;
+ struct type_object *prev;
+ struct type_object *next;
+};
extern PyTypeObject type_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("type_object");
/* A Field object. */
-typedef struct pyty_field_object
+struct field_object
{
PyObject_HEAD
/* Dictionary holding our attributes. */
PyObject *dict;
-} field_object;
+};
extern PyTypeObject field_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("field_object");
/* A type iterator object. */
-typedef struct {
+struct typy_iterator_object {
PyObject_HEAD
/* The current field index. */
int field;
/* What to return. */
enum gdbpy_iter_kind kind;
/* Pointer back to the original source type object. */
- struct pyty_type_object *source;
-} typy_iterator_object;
+ type_object *source;
+};
extern PyTypeObject type_iterator_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("typy_iterator_object");
{
struct objfile *objfile = TYPE_OBJFILE (type);
- obj->next = ((struct pyty_type_object *)
+ obj->next = ((type_object *)
objfile_data (objfile, typy_objfile_data_key));
if (obj->next)
obj->next->prev = obj;
#define TRACE_PY_UNWIND(level, args...) if (pyuw_debug >= level) \
{ fprintf_unfiltered (gdb_stdlog, args); }
-typedef struct
+struct pending_frame_object
{
PyObject_HEAD
/* Its architecture, passed by the sniffer caller. */
struct gdbarch *gdbarch;
-} pending_frame_object;
+};
/* Saved registers array item. */
/* The data we keep for the PyUnwindInfo: pending_frame, saved registers
and frame ID. */
-typedef struct
+struct unwind_info_object
{
PyObject_HEAD
/* Saved registers array. */
std::vector<saved_reg> *saved_regs;
-} unwind_info_object;
+};
/* The data we keep for a frame we can unwind: frame ID and an array of
(register_number, register_value) pairs. */
-typedef struct
+struct cached_frame_info
{
/* Frame ID. */
struct frame_id frame_id;
int reg_count;
cached_reg_t reg[];
-} cached_frame_info;
+};
extern PyTypeObject pending_frame_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pending_frame_object");
#define builtin_type_pychar \
language_string_char_type (python_language, python_gdbarch)
-typedef struct value_object {
+struct value_object {
PyObject_HEAD
struct value_object *next;
struct value_object *prev;
PyObject *address;
PyObject *type;
PyObject *dynamic_type;
-} value_object;
+};
/* List of all values which are currently exposed to Python. It is
maintained so that when an objfile is discarded, preserve_values
extern PyTypeObject thread_object_type
CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("thread_object");
-typedef struct gdbpy_breakpoint_object
+struct gdbpy_breakpoint_object
{
PyObject_HEAD
/* 1 is this is a FinishBreakpoint object, 0 otherwise. */
int is_finish_bp;
-} gdbpy_breakpoint_object;
+};
/* Require that BREAKPOINT be a valid breakpoint ID; throw a Python
exception if it is invalid. */
extern gdbpy_breakpoint_object *bppy_pending_object;
-typedef struct
+struct thread_object
{
PyObject_HEAD
/* The Inferior object to which this thread belongs. */
PyObject *inf_obj;
-} thread_object;
+};
struct inferior_object;
projects / binutils-gdb.git / commitdiff