[deliverable/binutils-gdb.git] / gdb / python / py-progspace.c

/* Python interface to program spaces.

   Copyright (C) 2010-2015 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "python-internal.h"
#include "charset.h"
#include "progspace.h"
#include "objfiles.h"
#include "language.h"
#include "arch-utils.h"

typedef struct
{
  PyObject_HEAD

  /* The corresponding pspace.  */
  struct program_space *pspace;

  /* Dictionary holding user-added attributes.
     This is the __dict__ attribute of the object.  */
  PyObject *dict;

  /* The pretty-printer list of functions.  */
  PyObject *printers;

  /* The frame filter list of functions.  */
  PyObject *frame_filters;

  /* The frame unwinder list.  */
  PyObject *frame_unwinders;

  /* The type-printer list.  */
  PyObject *type_printers;

  /* The debug method list.  */
  PyObject *xmethods;
} pspace_object;

extern PyTypeObject pspace_object_type
    CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pspace_object");

static const struct program_space_data *pspy_pspace_data_key;

\f

/* An Objfile method which returns the objfile's file name, or None.  */

static PyObject *
pspy_get_filename (PyObject *self, void *closure)
{
  pspace_object *obj = (pspace_object *) self;

  if (obj->pspace)
    {
      struct objfile *objfile = obj->pspace->symfile_object_file;

      if (objfile)
	return PyString_Decode (objfile_name (objfile),
				strlen (objfile_name (objfile)),
				host_charset (), NULL);
    }
  Py_RETURN_NONE;
}

static void
pspy_dealloc (PyObject *self)
{
  pspace_object *ps_self = (pspace_object *) self;

  Py_XDECREF (ps_self->dict);
  Py_XDECREF (ps_self->printers);
  Py_XDECREF (ps_self->frame_filters);
  Py_XDECREF (ps_self->frame_unwinders);
  Py_XDECREF (ps_self->type_printers);
  Py_XDECREF (ps_self->xmethods);
  Py_TYPE (self)->tp_free (self);
}

/* Initialize a pspace_object.
   The result is a boolean indicating success.  */

static int
pspy_initialize (pspace_object *self)
{
  self->pspace = NULL;
  self->dict = NULL;

  self->printers = PyList_New (0);
  if (self->printers == NULL)
    return 0;

  self->frame_filters = PyDict_New ();
  if (self->frame_filters == NULL)
    return 0;

  self->frame_unwinders = PyList_New (0);
  if (self->frame_unwinders == NULL)
    return 0;

  self->type_printers = PyList_New (0);
  if (self->type_printers == NULL)
    return 0;

  self->xmethods = PyList_New (0);
  if (self->xmethods == NULL)
    return 0;

  return 1;
}

static PyObject *
pspy_new (PyTypeObject *type, PyObject *args, PyObject *keywords)
{
  pspace_object *self = (pspace_object *) type->tp_alloc (type, 0);

  if (self)
    {
      if (!pspy_initialize (self))
	{
	  Py_DECREF (self);
	  return NULL;
	}
    }

  return (PyObject *) self;
}

PyObject *
pspy_get_printers (PyObject *o, void *ignore)
{
  pspace_object *self = (pspace_object *) o;

  Py_INCREF (self->printers);
  return self->printers;
}

static int
pspy_set_printers (PyObject *o, PyObject *value, void *ignore)
{
  PyObject *tmp;
  pspace_object *self = (pspace_object *) o;

  if (! value)
    {
      PyErr_SetString (PyExc_TypeError,
		       "cannot delete the pretty_printers attribute");
      return -1;
    }

  if (! PyList_Check (value))
    {
      PyErr_SetString (PyExc_TypeError,
		       "the pretty_printers attribute must be a list");
      return -1;
    }

  /* Take care in case the LHS and RHS are related somehow.  */
  tmp = self->printers;
  Py_INCREF (value);
  self->printers = value;
  Py_XDECREF (tmp);

  return 0;
}

/* Return the Python dictionary attribute containing frame filters for
   this program space.  */
PyObject *
pspy_get_frame_filters (PyObject *o, void *ignore)
{
  pspace_object *self = (pspace_object *) o;

  Py_INCREF (self->frame_filters);
  return self->frame_filters;
}

/* Set this object file's frame filters dictionary to FILTERS.  */
static int
pspy_set_frame_filters (PyObject *o, PyObject *frame, void *ignore)
{
  PyObject *tmp;
  pspace_object *self = (pspace_object *) o;

  if (! frame)
    {
      PyErr_SetString (PyExc_TypeError,
		       "cannot delete the frame filter attribute");
      return -1;
    }

  if (! PyDict_Check (frame))
    {
      PyErr_SetString (PyExc_TypeError,
		       "the frame filter attribute must be a dictionary");
      return -1;
    }

  /* Take care in case the LHS and RHS are related somehow.  */
  tmp = self->frame_filters;
  Py_INCREF (frame);
  self->frame_filters = frame;
  Py_XDECREF (tmp);

  return 0;
}

/* Return the list of the frame unwinders for this program space.  */

PyObject *
pspy_get_frame_unwinders (PyObject *o, void *ignore)
{
  pspace_object *self = (pspace_object *) o;

  Py_INCREF (self->frame_unwinders);
  return self->frame_unwinders;
}

/* Set this program space's list of the unwinders to UNWINDERS.  */

static int
pspy_set_frame_unwinders (PyObject *o, PyObject *unwinders, void *ignore)
{
  PyObject *tmp;
  pspace_object *self = (pspace_object *) o;

  if (!unwinders)
    {
      PyErr_SetString (PyExc_TypeError,
		       "cannot delete the frame unwinders list");
      return -1;
    }

  if (!PyList_Check (unwinders))
    {
      PyErr_SetString (PyExc_TypeError,
		       "the frame unwinders attribute must be a list");
      return -1;
    }

  /* Take care in case the LHS and RHS are related somehow.  */
  tmp = self->frame_unwinders;
  Py_INCREF (unwinders);
  self->frame_unwinders = unwinders;
  Py_XDECREF (tmp);

  return 0;
}

/* Get the 'type_printers' attribute.  */

static PyObject *
pspy_get_type_printers (PyObject *o, void *ignore)
{
  pspace_object *self = (pspace_object *) o;

  Py_INCREF (self->type_printers);
  return self->type_printers;
}

/* Get the 'xmethods' attribute.  */

PyObject *
pspy_get_xmethods (PyObject *o, void *ignore)
{
  pspace_object *self = (pspace_object *) o;

  Py_INCREF (self->xmethods);
  return self->xmethods;
}

/* Set the 'type_printers' attribute.  */

static int
pspy_set_type_printers (PyObject *o, PyObject *value, void *ignore)
{
  PyObject *tmp;
  pspace_object *self = (pspace_object *) o;

  if (! value)
    {
      PyErr_SetString (PyExc_TypeError,
		       "cannot delete the type_printers attribute");
      return -1;
    }

  if (! PyList_Check (value))
    {
      PyErr_SetString (PyExc_TypeError,
		       "the type_printers attribute must be a list");
      return -1;
    }

  /* Take care in case the LHS and RHS are related somehow.  */
  tmp = self->type_printers;
  Py_INCREF (value);
  self->type_printers = value;
  Py_XDECREF (tmp);

  return 0;
}

\f

/* Clear the PSPACE pointer in a Pspace object and remove the reference.  */

static void
py_free_pspace (struct program_space *pspace, void *datum)
{
  struct cleanup *cleanup;
  pspace_object *object = datum;
  /* This is a fiction, but we're in a nasty spot: The pspace is in the
     process of being deleted, we can't rely on anything in it.  Plus
     this is one time when the current program space and current inferior
     are not in sync: All inferiors that use PSPACE may no longer exist.
     We don't need to do much here, and since "there is always an inferior"
     using target_gdbarch suffices.
     Note: We cannot call get_current_arch because it may try to access
     the target, which may involve accessing data in the pspace currently
     being deleted.  */
  struct gdbarch *arch = target_gdbarch ();

  cleanup = ensure_python_env (arch, current_language);
  object->pspace = NULL;
  Py_DECREF ((PyObject *) object);
  do_cleanups (cleanup);
}

/* Return a borrowed reference to the Python object of type Pspace
   representing PSPACE.  If the object has already been created,
   return it.  Otherwise, create it.  Return NULL and set the Python
   error on failure.  */

PyObject *
pspace_to_pspace_object (struct program_space *pspace)
{
  pspace_object *object;

  object = program_space_data (pspace, pspy_pspace_data_key);
  if (!object)
    {
      object = PyObject_New (pspace_object, &pspace_object_type);
      if (object)
	{
	  if (!pspy_initialize (object))
	    {
	      Py_DECREF (object);
	      return NULL;
	    }

	  object->pspace = pspace;
	  set_program_space_data (pspace, pspy_pspace_data_key, object);
	}
    }

  return (PyObject *) object;
}

int
gdbpy_initialize_pspace (void)
{
  pspy_pspace_data_key
    = register_program_space_data_with_cleanup (NULL, py_free_pspace);

  if (PyType_Ready (&pspace_object_type) < 0)
    return -1;

  return gdb_pymodule_addobject (gdb_module, "Progspace",
				 (PyObject *) &pspace_object_type);
}

\f

static PyGetSetDef pspace_getset[] =
{
  { "__dict__", gdb_py_generic_dict, NULL,
    "The __dict__ for this progspace.", &pspace_object_type },
  { "filename", pspy_get_filename, NULL,
    "The progspace's main filename, or None.", NULL },
  { "pretty_printers", pspy_get_printers, pspy_set_printers,
    "Pretty printers.", NULL },
  { "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters,
    "Frame filters.", NULL },
  { "frame_unwinders", pspy_get_frame_unwinders, pspy_set_frame_unwinders,
    "Frame unwinders.", NULL },
  { "type_printers", pspy_get_type_printers, pspy_set_type_printers,
    "Type printers.", NULL },
  { "xmethods", pspy_get_xmethods, NULL,
    "Debug methods.", NULL },
  { NULL }
};

PyTypeObject pspace_object_type =
{
  PyVarObject_HEAD_INIT (NULL, 0)
  "gdb.Progspace",		  /*tp_name*/
  sizeof (pspace_object),	  /*tp_basicsize*/
  0,				  /*tp_itemsize*/
  pspy_dealloc,			  /*tp_dealloc*/
  0,				  /*tp_print*/
  0,				  /*tp_getattr*/
  0,				  /*tp_setattr*/
  0,				  /*tp_compare*/
  0,				  /*tp_repr*/
  0,				  /*tp_as_number*/
  0,				  /*tp_as_sequence*/
  0,				  /*tp_as_mapping*/
  0,				  /*tp_hash */
  0,				  /*tp_call*/
  0,				  /*tp_str*/
  0,				  /*tp_getattro*/
  0,				  /*tp_setattro*/
  0,				  /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT,		  /*tp_flags*/
  "GDB progspace object",	  /* tp_doc */
  0,				  /* tp_traverse */
  0,				  /* tp_clear */
  0,				  /* tp_richcompare */
  0,				  /* tp_weaklistoffset */
  0,				  /* tp_iter */
  0,				  /* tp_iternext */
  0,				  /* tp_methods */
  0,				  /* tp_members */
  pspace_getset,		  /* tp_getset */
  0,				  /* tp_base */
  0,				  /* tp_dict */
  0,				  /* tp_descr_get */
  0,				  /* tp_descr_set */
  offsetof (pspace_object, dict), /* tp_dictoffset */
  0,				  /* tp_init */
  0,				  /* tp_alloc */
  pspy_new,			  /* tp_new */
};
Commit	Line	Data
fa33c3cd DE	1	/* Python interface to program spaces.
fa33c3cd DE	2
32d0add0	3	Copyright (C) 2010-2015 Free Software Foundation, Inc.
fa33c3cd DE	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "defs.h"
	21	#include "python-internal.h"
	22	#include "charset.h"
	23	#include "progspace.h"
	24	#include "objfiles.h"
	25	#include "language.h"
b3422a0d	26	#include "arch-utils.h"
fa33c3cd DE	27
	28	typedef struct
	29	{
	30	PyObject_HEAD
	31
	32	/* The corresponding pspace. */
	33	struct program_space *pspace;
	34
02be9a71 DE	35	/* Dictionary holding user-added attributes.
	36	This is the __dict__ attribute of the object. */
	37	PyObject *dict;
	38
fa33c3cd DE	39	/* The pretty-printer list of functions. */
fa33c3cd DE	40	PyObject *printers;
18a9fc12	41
1e611234 PM	42	/* The frame filter list of functions. */
1e611234 PM	43	PyObject *frame_filters;
d11916aa SS	44
	45	/* The frame unwinder list. */
	46	PyObject *frame_unwinders;
	47
18a9fc12 TT	48	/* The type-printer list. */
18a9fc12 TT	49	PyObject *type_printers;
883964a7 SC	50
	51	/* The debug method list. */
	52	PyObject *xmethods;
fa33c3cd DE	53	} pspace_object;
fa33c3cd DE	54
e36122e9	55	extern PyTypeObject pspace_object_type
62eec1a5	56	CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("pspace_object");
fa33c3cd DE	57
	58	static const struct program_space_data *pspy_pspace_data_key;
	59
	60	\f
	61
	62	/* An Objfile method which returns the objfile's file name, or None. */
	63
	64	static PyObject *
	65	pspy_get_filename (PyObject self, void closure)
	66	{
	67	pspace_object obj = (pspace_object ) self;
d59b6f6c	68
fa33c3cd DE	69	if (obj->pspace)
	70	{
	71	struct objfile *objfile = obj->pspace->symfile_object_file;
d59b6f6c	72
d31d2fc3	73	if (objfile)
4262abfb JK	74	return PyString_Decode (objfile_name (objfile),
4262abfb JK	75	strlen (objfile_name (objfile)),
fa33c3cd DE	76	host_charset (), NULL);
	77	}
	78	Py_RETURN_NONE;
	79	}
	80
	81	static void
	82	pspy_dealloc (PyObject *self)
	83	{
	84	pspace_object ps_self = (pspace_object ) self;
d59b6f6c	85
02be9a71	86	Py_XDECREF (ps_self->dict);
fa33c3cd	87	Py_XDECREF (ps_self->printers);
1e611234	88	Py_XDECREF (ps_self->frame_filters);
d11916aa	89	Py_XDECREF (ps_self->frame_unwinders);
18a9fc12	90	Py_XDECREF (ps_self->type_printers);
883964a7	91	Py_XDECREF (ps_self->xmethods);
9a27f2c6	92	Py_TYPE (self)->tp_free (self);
fa33c3cd DE	93	}
fa33c3cd DE	94
4e1bbde0 DE	95	/* Initialize a pspace_object.
	96	The result is a boolean indicating success. */
	97
	98	static int
	99	pspy_initialize (pspace_object *self)
	100	{
	101	self->pspace = NULL;
02be9a71	102	self->dict = NULL;
4e1bbde0 DE	103
	104	self->printers = PyList_New (0);
	105	if (self->printers == NULL)
	106	return 0;
	107
	108	self->frame_filters = PyDict_New ();
	109	if (self->frame_filters == NULL)
	110	return 0;
	111
d11916aa SS	112	self->frame_unwinders = PyList_New (0);
	113	if (self->frame_unwinders == NULL)
	114	return 0;
	115
4e1bbde0 DE	116	self->type_printers = PyList_New (0);
	117	if (self->type_printers == NULL)
	118	return 0;
	119
	120	self->xmethods = PyList_New (0);
	121	if (self->xmethods == NULL)
	122	return 0;
	123
	124	return 1;
	125	}
	126
fa33c3cd DE	127	static PyObject *
	128	pspy_new (PyTypeObject type, PyObject args, PyObject *keywords)
	129	{
	130	pspace_object self = (pspace_object ) type->tp_alloc (type, 0);
d59b6f6c	131
fa33c3cd DE	132	if (self)
fa33c3cd DE	133	{
4e1bbde0	134	if (!pspy_initialize (self))
883964a7 SC	135	{
	136	Py_DECREF (self);
	137	return NULL;
	138	}
fa33c3cd	139	}
4e1bbde0	140
fa33c3cd DE	141	return (PyObject *) self;
	142	}
	143
	144	PyObject *
	145	pspy_get_printers (PyObject o, void ignore)
	146	{
	147	pspace_object self = (pspace_object ) o;
d59b6f6c	148
fa33c3cd DE	149	Py_INCREF (self->printers);
	150	return self->printers;
	151	}
	152
	153	static int
	154	pspy_set_printers (PyObject o, PyObject value, void *ignore)
	155	{
	156	PyObject *tmp;
	157	pspace_object self = (pspace_object ) o;
d59b6f6c	158
fa33c3cd DE	159	if (! value)
	160	{
	161	PyErr_SetString (PyExc_TypeError,
	162	"cannot delete the pretty_printers attribute");
	163	return -1;
	164	}
	165
	166	if (! PyList_Check (value))
	167	{
	168	PyErr_SetString (PyExc_TypeError,
	169	"the pretty_printers attribute must be a list");
	170	return -1;
	171	}
	172
	173	/* Take care in case the LHS and RHS are related somehow. */
	174	tmp = self->printers;
	175	Py_INCREF (value);
	176	self->printers = value;
	177	Py_XDECREF (tmp);
	178
	179	return 0;
	180	}
	181
1e611234 PM	182	/* Return the Python dictionary attribute containing frame filters for
	183	this program space. */
	184	PyObject *
	185	pspy_get_frame_filters (PyObject o, void ignore)
	186	{
	187	pspace_object self = (pspace_object ) o;
	188
	189	Py_INCREF (self->frame_filters);
	190	return self->frame_filters;
	191	}
	192
	193	/* Set this object file's frame filters dictionary to FILTERS. */
	194	static int
	195	pspy_set_frame_filters (PyObject o, PyObject frame, void *ignore)
	196	{
	197	PyObject *tmp;
	198	pspace_object self = (pspace_object ) o;
	199
	200	if (! frame)
	201	{
	202	PyErr_SetString (PyExc_TypeError,
	203	"cannot delete the frame filter attribute");
	204	return -1;
	205	}
	206
	207	if (! PyDict_Check (frame))
	208	{
	209	PyErr_SetString (PyExc_TypeError,
	210	"the frame filter attribute must be a dictionary");
	211	return -1;
	212	}
	213
	214	/* Take care in case the LHS and RHS are related somehow. */
	215	tmp = self->frame_filters;
	216	Py_INCREF (frame);
	217	self->frame_filters = frame;
	218	Py_XDECREF (tmp);
	219
	220	return 0;
	221	}
	222
d11916aa SS	223	/* Return the list of the frame unwinders for this program space. */
	224
	225	PyObject *
	226	pspy_get_frame_unwinders (PyObject o, void ignore)
	227	{
	228	pspace_object self = (pspace_object ) o;
	229
	230	Py_INCREF (self->frame_unwinders);
	231	return self->frame_unwinders;
	232	}
	233
	234	/* Set this program space's list of the unwinders to UNWINDERS. */
	235
	236	static int
	237	pspy_set_frame_unwinders (PyObject o, PyObject unwinders, void *ignore)
	238	{
	239	PyObject *tmp;
	240	pspace_object self = (pspace_object ) o;
	241
	242	if (!unwinders)
	243	{
	244	PyErr_SetString (PyExc_TypeError,
	245	"cannot delete the frame unwinders list");
	246	return -1;
	247	}
	248
	249	if (!PyList_Check (unwinders))
	250	{
	251	PyErr_SetString (PyExc_TypeError,
	252	"the frame unwinders attribute must be a list");
	253	return -1;
	254	}
	255
	256	/* Take care in case the LHS and RHS are related somehow. */
	257	tmp = self->frame_unwinders;
	258	Py_INCREF (unwinders);
	259	self->frame_unwinders = unwinders;
	260	Py_XDECREF (tmp);
	261
	262	return 0;
	263	}
	264
18a9fc12 TT	265	/* Get the 'type_printers' attribute. */
	266
	267	static PyObject *
	268	pspy_get_type_printers (PyObject o, void ignore)
	269	{
	270	pspace_object self = (pspace_object ) o;
	271
	272	Py_INCREF (self->type_printers);
	273	return self->type_printers;
	274	}
	275
883964a7 SC	276	/* Get the 'xmethods' attribute. */
	277
	278	PyObject *
	279	pspy_get_xmethods (PyObject o, void ignore)
	280	{
	281	pspace_object self = (pspace_object ) o;
	282
	283	Py_INCREF (self->xmethods);
	284	return self->xmethods;
	285	}
	286
18a9fc12 TT	287	/* Set the 'type_printers' attribute. */
	288
	289	static int
	290	pspy_set_type_printers (PyObject o, PyObject value, void *ignore)
	291	{
	292	PyObject *tmp;
	293	pspace_object self = (pspace_object ) o;
	294
	295	if (! value)
	296	{
	297	PyErr_SetString (PyExc_TypeError,
	298	"cannot delete the type_printers attribute");
	299	return -1;
	300	}
	301
	302	if (! PyList_Check (value))
	303	{
	304	PyErr_SetString (PyExc_TypeError,
	305	"the type_printers attribute must be a list");
	306	return -1;
	307	}
	308
	309	/* Take care in case the LHS and RHS are related somehow. */
	310	tmp = self->type_printers;
	311	Py_INCREF (value);
	312	self->type_printers = value;
	313	Py_XDECREF (tmp);
	314
	315	return 0;
	316	}
	317
fa33c3cd DE	318	\f
	319
	320	/* Clear the PSPACE pointer in a Pspace object and remove the reference. */
	321
	322	static void
	323	py_free_pspace (struct program_space pspace, void datum)
	324	{
	325	struct cleanup *cleanup;
	326	pspace_object *object = datum;
227533ac DE	327	/* This is a fiction, but we're in a nasty spot: The pspace is in the
	328	process of being deleted, we can't rely on anything in it. Plus
	329	this is one time when the current program space and current inferior
	330	are not in sync: All inferiors that use PSPACE may no longer exist.
	331	We don't need to do much here, and since "there is always an inferior"
	332	using target_gdbarch suffices.
	333	Note: We cannot call get_current_arch because it may try to access
	334	the target, which may involve accessing data in the pspace currently
	335	being deleted. */
	336	struct gdbarch *arch = target_gdbarch ();
fa33c3cd DE	337
	338	cleanup = ensure_python_env (arch, current_language);
	339	object->pspace = NULL;
	340	Py_DECREF ((PyObject *) object);
	341	do_cleanups (cleanup);
	342	}
	343
	344	/* Return a borrowed reference to the Python object of type Pspace
	345	representing PSPACE. If the object has already been created,
	346	return it. Otherwise, create it. Return NULL and set the Python
	347	error on failure. */
	348
	349	PyObject *
	350	pspace_to_pspace_object (struct program_space *pspace)
	351	{
	352	pspace_object *object;
	353
	354	object = program_space_data (pspace, pspy_pspace_data_key);
	355	if (!object)
	356	{
	357	object = PyObject_New (pspace_object, &pspace_object_type);
	358	if (object)
	359	{
4e1bbde0	360	if (!pspy_initialize (object))
883964a7 SC	361	{
	362	Py_DECREF (object);
	363	return NULL;
	364	}
	365
4e1bbde0	366	object->pspace = pspace;
fa33c3cd DE	367	set_program_space_data (pspace, pspy_pspace_data_key, object);
	368	}
	369	}
	370
	371	return (PyObject *) object;
	372	}
	373
999633ed	374	int
fa33c3cd DE	375	gdbpy_initialize_pspace (void)
	376	{
	377	pspy_pspace_data_key
8e260fc0	378	= register_program_space_data_with_cleanup (NULL, py_free_pspace);
fa33c3cd DE	379
fa33c3cd DE	380	if (PyType_Ready (&pspace_object_type) < 0)
999633ed	381	return -1;
fa33c3cd	382
aa36459a TT	383	return gdb_pymodule_addobject (gdb_module, "Progspace",
aa36459a TT	384	(PyObject *) &pspace_object_type);
fa33c3cd DE	385	}
	386
	387	\f
	388
	389	static PyGetSetDef pspace_getset[] =
	390	{
02be9a71 DE	391	{ "__dict__", gdb_py_generic_dict, NULL,
02be9a71 DE	392	"The __dict__ for this progspace.", &pspace_object_type },
fa33c3cd DE	393	{ "filename", pspy_get_filename, NULL,
	394	"The progspace's main filename, or None.", NULL },
	395	{ "pretty_printers", pspy_get_printers, pspy_set_printers,
	396	"Pretty printers.", NULL },
1e611234 PM	397	{ "frame_filters", pspy_get_frame_filters, pspy_set_frame_filters,
1e611234 PM	398	"Frame filters.", NULL },
d11916aa SS	399	{ "frame_unwinders", pspy_get_frame_unwinders, pspy_set_frame_unwinders,
d11916aa SS	400	"Frame unwinders.", NULL },
18a9fc12 TT	401	{ "type_printers", pspy_get_type_printers, pspy_set_type_printers,
18a9fc12 TT	402	"Type printers.", NULL },
883964a7 SC	403	{ "xmethods", pspy_get_xmethods, NULL,
883964a7 SC	404	"Debug methods.", NULL },
fa33c3cd DE	405	{ NULL }
	406	};
	407
e36122e9	408	PyTypeObject pspace_object_type =
fa33c3cd	409	{
9a27f2c6	410	PyVarObject_HEAD_INIT (NULL, 0)
fa33c3cd DE	411	"gdb.Progspace", /tp_name/
	412	sizeof (pspace_object), /tp_basicsize/
	413	0, /tp_itemsize/
	414	pspy_dealloc, /tp_dealloc/
	415	0, /tp_print/
	416	0, /tp_getattr/
	417	0, /tp_setattr/
	418	0, /tp_compare/
	419	0, /tp_repr/
	420	0, /tp_as_number/
	421	0, /tp_as_sequence/
	422	0, /tp_as_mapping/
	423	0, /tp_hash /
	424	0, /tp_call/
	425	0, /tp_str/
	426	0, /tp_getattro/
	427	0, /tp_setattro/
	428	0, /tp_as_buffer/
	429	Py_TPFLAGS_DEFAULT, /tp_flags/
	430	"GDB progspace object", /* tp_doc */
	431	0, /* tp_traverse */
	432	0, /* tp_clear */
	433	0, /* tp_richcompare */
	434	0, /* tp_weaklistoffset */
	435	0, /* tp_iter */
	436	0, /* tp_iternext */
	437	0, /* tp_methods */
	438	0, /* tp_members */
	439	pspace_getset, /* tp_getset */
	440	0, /* tp_base */
	441	0, /* tp_dict */
	442	0, /* tp_descr_get */
	443	0, /* tp_descr_set */
02be9a71	444	offsetof (pspace_object, dict), /* tp_dictoffset */
fa33c3cd DE	445	0, /* tp_init */
	446	0, /* tp_alloc */
	447	pspy_new, /* tp_new */
	448	};