* registry.h (struct registry_fields): New.

	(REGISTRY_FIELDS): Redefine.
	(REGISTRY_ACCESS_FIELD): New macro.
	(DEFINE_REGISTRY): Add ACCESS argument.  Update defined
	functions.

5 files changed, 63 insertions, 27 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 385e312..f274c43 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,13 @@
 2012-08-22  Tom Tromey  <tromey@redhat.com>
 
+	* registry.h (struct registry_fields): New.
+	(REGISTRY_FIELDS): Redefine.
+	(REGISTRY_ACCESS_FIELD): New macro.
+	(DEFINE_REGISTRY): Add ACCESS argument.  Update defined
+	functions.
+
+2012-08-22  Tom Tromey  <tromey@redhat.com>
+
 	* auto-load.c (_initialize_auto_load): Update.
 	* solib-svr4.c (_initialize_svr4_solib): Update
 	* solib-dsbt.c (_initialize_dsbt_solib): Update.
diff --git a/gdb/inferior.c b/gdb/inferior.c
index c812d39..f45058a 100644
--- a/gdb/inferior.c
+++ b/gdb/inferior.c
@@ -39,7 +39,7 @@ void _initialize_inferiors (void);
 /* Keep a registry of per-inferior data-pointers required by other GDB
    modules.  */
 
-DEFINE_REGISTRY (inferior)
+DEFINE_REGISTRY (inferior, REGISTRY_ACCESS_FIELD)
 
 struct inferior *inferior_list = NULL;
 static int highest_inferior_num;
diff --git a/gdb/objfiles.c b/gdb/objfiles.c
index b33a0cf..57dd594 100644
--- a/gdb/objfiles.c
+++ b/gdb/objfiles.c
@@ -58,7 +58,7 @@
 /* Keep a registry of per-objfile data-pointers required by other GDB
    modules.  */
 
-DEFINE_REGISTRY (objfile)
+DEFINE_REGISTRY (objfile, REGISTRY_ACCESS_FIELD)
 
 /* Externally visible variables that are owned by this module.
    See declarations in objfile.h for more info.  */
diff --git a/gdb/progspace.c b/gdb/progspace.c
index 6498738..db8c5a3 100644
--- a/gdb/progspace.c
+++ b/gdb/progspace.c
@@ -42,7 +42,7 @@ static int highest_address_space_num;
 /* Keep a registry of per-program_space data-pointers required by other GDB
    modules.  */
 
-DEFINE_REGISTRY (program_space)
+DEFINE_REGISTRY (program_space, REGISTRY_ACCESS_FIELD)
 
 
 
diff --git a/gdb/registry.h b/gdb/registry.h
index d696781..423caa6 100644
--- a/gdb/registry.h
+++ b/gdb/registry.h
@@ -24,12 +24,21 @@
 /* The macros here implement a template type and functions for
    associating some user data with a container object.
 
+   A registry is associated with a struct tag name.  To attach a
+   registry to a structure, use DEFINE_REGISTRY.  This takes the
+   structure tag and an access method as arguments.  In the usual
+   case, where the registry fields appear directly in the struct, you
+   can use the 'REGISTRY_FIELDS' macro to declare the fields in the
+   struct definition, and you can pass 'REGISTRY_ACCESS_FIELD' as the
+   access argument to DEFINE_REGISTRY.  In other cases, use
+   REGISTRY_FIELDS to define the fields in the appropriate spot, and
+   then define your own accessor to find the registry field structure
+   given an instance of your type.
+
    The API user requests a key from a registry during gdb
    initialization.  Later this key can be used to associate some
    module-specific data with a specific container object.
 
-   A registry is associated with a struct tag name.
-
    The exported API is best used via the wrapper macros:
    
    - register_TAG_data(TAG)
@@ -54,16 +63,31 @@
    Fetch the data for an object; returns NULL if it has not been set.
 */
 
+/* This structure is used in a container to hold the data that the
+   registry uses.  */
+
+struct registry_fields
+{
+  void **data;
+  unsigned num_data;
+};
+
 /* This macro is used in a container struct definition to define the
    fields used by the registry code.  */
 
 #define REGISTRY_FIELDS				\
-  void **data;					\
-  unsigned num_data
+  struct registry_fields registry_data
+
+/* A convenience macro for the typical case where the registry data is
+   kept as fields of the object.  This can be passed as the ACCESS
+   method to DEFINE_REGISTRY.  */
+
+#define REGISTRY_ACCESS_FIELD(CONTAINER) \
+  (CONTAINER)
 
 /* Define a new registry implementation.  */
 
-#define DEFINE_REGISTRY(TAG)						\
+#define DEFINE_REGISTRY(TAG, ACCESS)					\
 struct TAG ## _data							\
 {									\
   unsigned index;							\
@@ -114,61 +138,65 @@ register_ ## TAG ## _data (void)					\
 static void								\
 TAG ## _alloc_data (struct TAG *container)				\
 {									\
-  gdb_assert (container->data == NULL);					\
-  container->num_data = TAG ## _data_registry.num_registrations;	\
-  container->data = XCALLOC (container->num_data, void *);		\
+  struct registry_fields *rdata = &ACCESS (container)->registry_data;	\
+  gdb_assert (rdata->data == NULL);					\
+  rdata->num_data = TAG ## _data_registry.num_registrations;		\
+  rdata->data = XCALLOC (rdata->num_data, void *);			\
 }									\
 									\
 void									\
 clear_ ## TAG ## _data (struct TAG *container)				\
 {									\
+  struct registry_fields *rdata = &ACCESS (container)->registry_data;	\
   struct TAG ## _data_registration *registration;			\
   int i;								\
 									\
-  gdb_assert (container->data != NULL);					\
+  gdb_assert (rdata->data != NULL);					\
 									\
   /* Process all the save handlers.  */					\
 									\
   for (registration = TAG ## _data_registry.registrations, i = 0;	\
-       i < container->num_data;						\
+       i < rdata->num_data;						\
        registration = registration->next, i++)				\
-    if (container->data[i] != NULL && registration->data->save != NULL)	\
-      registration->data->save (container, container->data[i]);		\
+    if (rdata->data[i] != NULL && registration->data->save != NULL)	\
+      registration->data->save (container, rdata->data[i]);		\
 									\
   /* Now process all the free handlers.  */				\
 									\
   for (registration = TAG ## _data_registry.registrations, i = 0;	\
-       i < container->num_data;						\
+       i < rdata->num_data;						\
        registration = registration->next, i++)				\
-    if (container->data[i] != NULL && registration->data->free != NULL)	\
-      registration->data->free (container, container->data[i]);		\
+    if (rdata->data[i] != NULL && registration->data->free != NULL)	\
+      registration->data->free (container, rdata->data[i]);		\
 									\
-  memset (container->data, 0, container->num_data * sizeof (void *));	\
+  memset (rdata->data, 0, rdata->num_data * sizeof (void *));		\
 }									\
 									\
 static void								\
 TAG ## _free_data (struct TAG *container)				\
 {									\
-  void ***rdata = &container->data;					\
-  gdb_assert (*rdata != NULL);						\
+  struct registry_fields *rdata = &ACCESS (container)->registry_data;	\
+  gdb_assert (rdata->data != NULL);					\
   clear_ ## TAG ## _data (container);					\
-  xfree (*rdata);							\
-  *rdata = NULL;							\
+  xfree (rdata->data);							\
+  rdata->data = NULL;							\
 }									\
 									\
 void									\
 set_ ## TAG ## _data (struct TAG *container, const struct TAG ## _data *data, \
 		  void *value)						\
 {									\
-  gdb_assert (data->index < container->num_data);			\
-  container->data[data->index] = value;					\
+  struct registry_fields *rdata = &ACCESS (container)->registry_data;	\
+  gdb_assert (data->index < rdata->num_data);				\
+  rdata->data[data->index] = value;					\
 }									\
 									\
 void *									\
 TAG ## _data (struct TAG *container, const struct TAG ## _data *data)	\
 {									\
-  gdb_assert (data->index < container->num_data);			\
-  return container->data[data->index];					\
+  struct registry_fields *rdata = &ACCESS (container)->registry_data;	\
+  gdb_assert (data->index < rdata->num_data);				\
+  return rdata->data[data->index];					\
 }