implemented closure chaining.

Thu Dec 13 08:03:17 2001  Tim Janik  <timj@gtk.org>

        * gsignal.c: implemented closure chaining.

6 files changed, 382 insertions, 175 deletions

diff --git a/gobject/ChangeLog b/gobject/ChangeLog
index 8ca563392..8d20b3ae5 100644
--- a/gobject/ChangeLog
+++ b/gobject/ChangeLog
@@ -1,3 +1,7 @@
+Thu Dec 13 08:03:17 2001  Tim Janik  <timj@gtk.org>
+
+	* gsignal.c: implemented closure chaining.
+
 2001-12-08  Christopher Blizzard  <blizzard@redhat.com>
 
 	* gsignal.h (g_signal_connect): Explicitly add a cast to the last
diff --git a/gobject/gboxed.c b/gobject/gboxed.c
index 02adca97c..c186a4dce 100644
--- a/gobject/gboxed.c
+++ b/gobject/gboxed.c
@@ -41,7 +41,8 @@ static gint	boxed_nodes_cmp		(gconstpointer	p1,
 
 
 /* --- variables --- */
-static GBSearchArray boxed_bsa = G_STATIC_BSEARCH_ARRAY_INIT (sizeof (BoxedNode), boxed_nodes_cmp, 0);
+static GBSearchArray *boxed_bsa = NULL;
+static GBSearchConfig boxed_bconfig = G_STATIC_BCONFIG (sizeof (BoxedNode), boxed_nodes_cmp, 0);
 
 
 /* --- functions --- */
@@ -120,6 +121,8 @@ g_boxed_type_init (void)  /* sync with gtype.c */
   const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
   GType type;
 
+  boxed_bsa = g_bsearch_array_new (&boxed_bconfig);
+
   /* G_TYPE_BOXED
    */
   type = g_type_register_fundamental (G_TYPE_BOXED, "GBoxed", &info, &finfo,
@@ -181,7 +184,7 @@ boxed_proxy_value_init (GValue *value)
   BoxedNode key, *node;
 
   key.type = G_VALUE_TYPE (value);
-  node = g_bsearch_array_lookup (&boxed_bsa, &key);
+  node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
   value->data[0].v_pointer = NULL;
 }
 
@@ -193,7 +196,7 @@ boxed_proxy_value_free (GValue *value)
       BoxedNode key, *node;
 
       key.type = G_VALUE_TYPE (value);
-      node = g_bsearch_array_lookup (&boxed_bsa, &key);
+      node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
       node->free (value->data[0].v_pointer);
     }
 }
@@ -207,7 +210,7 @@ boxed_proxy_value_copy (const GValue *src_value,
       BoxedNode key, *node;
 
       key.type = G_VALUE_TYPE (src_value);
-      node = g_bsearch_array_lookup (&boxed_bsa, &key);
+      node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
       dest_value->data[0].v_pointer = node->copy (src_value->data[0].v_pointer);
     }
   else
@@ -229,7 +232,7 @@ boxed_proxy_collect_value (GValue      *value,
   BoxedNode key, *node;
 
   key.type = G_VALUE_TYPE (value);
-  node = g_bsearch_array_lookup (&boxed_bsa, &key);
+  node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
 
   if (!collect_values[0].v_pointer)
     value->data[0].v_pointer = NULL;
@@ -267,7 +270,7 @@ boxed_proxy_lcopy_value (const GValue *value,
       BoxedNode key, *node;
 
       key.type = G_VALUE_TYPE (value);
-      node = g_bsearch_array_lookup (&boxed_bsa, &key);
+      node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
       *boxed_p = node->copy (value->data[0].v_pointer);
     }
 
@@ -318,7 +321,7 @@ g_boxed_type_register_static (const gchar   *name,
       key.type = type;
       key.copy = boxed_copy;
       key.free = boxed_free;
-      g_bsearch_array_insert (&boxed_bsa, &key, TRUE);
+      boxed_bsa = g_bsearch_array_insert (boxed_bsa, &boxed_bconfig, &key, TRUE);
     }
 
   return type;
@@ -345,7 +348,7 @@ g_boxed_copy (GType         boxed_type,
       BoxedNode key, *node;
 
       key.type = boxed_type;
-      node = g_bsearch_array_lookup (&boxed_bsa, &key);
+      node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
       dest_boxed = node->copy ((gpointer) src_boxed);
     }
   else
@@ -404,7 +407,7 @@ g_boxed_free (GType    boxed_type,
       BoxedNode key, *node;
 
       key.type = boxed_type;
-      node = g_bsearch_array_lookup (&boxed_bsa, &key);
+      node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
       node->free (boxed);
     }
   else
@@ -457,7 +460,7 @@ value_set_boxed_internal (GValue       *value,
     }
 
   key.type = G_VALUE_TYPE (value);
-  node = g_bsearch_array_lookup (&boxed_bsa, &key);
+  node = g_bsearch_array_lookup (boxed_bsa, &boxed_bconfig, &key);
 
   if (node)
     {
diff --git a/gobject/gsignal.c b/gobject/gsignal.c
index 7394de1ea..40780dca3 100644
--- a/gobject/gsignal.c
+++ b/gobject/gsignal.c
@@ -36,7 +36,6 @@
  */
 #define	MAX_STACK_VALUES	(16)
 #define HANDLER_PRE_ALLOC       (48)
-#define EMISSION_PRE_ALLOC      (16)
 
 #define REPORT_BUG      "please report occourance circumstances to gtk-devel-list@gnome.org"
 #ifdef	G_ENABLE_DEBUG
@@ -129,17 +128,18 @@ static inline void		handler_ref		(Handler	 *handler);
 static inline void		handler_unref_R		(guint		  signal_id,
 							 gpointer	  instance,
 							 Handler	 *handler);
+static gint			handler_lists_cmp	(gconstpointer	  node1,
+							 gconstpointer	  node2);
 static inline void		emission_push		(Emission	**emission_list_p,
-							 guint		  signal_id,
-							 GQuark		  detail,
-							 gpointer	  instance,
-							 EmissionState	 *state_p);
+							 Emission	 *emission);
 static inline void		emission_pop		(Emission	**emission_list_p,
-							 EmissionState	 *state_p);
+							 Emission	 *emission);
 static inline Emission*		emission_find		(Emission	 *emission_list,
 							 guint		  signal_id,
 							 GQuark		  detail,
 							 gpointer	  instance);
+static gint			class_closures_cmp	(gconstpointer	  node1,
+							 gconstpointer	  node2);
 static gint			signal_key_cmp		(gconstpointer	  node1,
 							 gconstpointer	  node2);
 static	      gboolean		signal_emit_unlocked_R	(SignalNode	 *node,
@@ -175,7 +175,7 @@ struct _SignalNode
   guint              n_params : 8;
   GType		    *param_types; /* mangled with G_SIGNAL_TYPE_STATIC_SCOPE flag */
   GType		     return_type; /* mangled with G_SIGNAL_TYPE_STATIC_SCOPE flag */
-  GClosure          *class_closure;
+  GBSearchArray     *class_closure_bsa;
   SignalAccumulator *accumulator;
   GSignalCMarshaller c_marshaller;
   GHookList         *emission_hooks;
@@ -190,11 +190,11 @@ struct _SignalKey
 
 struct _Emission
 {
-  Emission      *next;
-  guint          signal_id;
-  GQuark	 detail;
-  gpointer       instance;
-  EmissionState *state_p;
+  Emission             *next;
+  gpointer              instance;
+  GSignalInvocationHint ihint;
+  EmissionState         state;
+  GType			chain_type;
 };
 
 struct _HandlerList
@@ -225,16 +225,28 @@ struct _HandlerMatch
   } d;
 };
 
+typedef struct
+{
+  GType     instance_type; /* 0 for default closure */
+  GClosure *closure;
+} ClassClosure;
+
 
 /* --- variables --- */
-static GBSearchArray  g_signal_key_bsa = G_STATIC_BSEARCH_ARRAY_INIT (sizeof (SignalKey),
-								      signal_key_cmp,
-								      G_BSEARCH_ARRAY_ALIGN_POWER2);
+static GBSearchArray *g_signal_key_bsa = NULL;
+static GBSearchConfig g_signal_key_bconfig = G_STATIC_BCONFIG (sizeof (SignalKey),
+							       signal_key_cmp,
+							       G_BSEARCH_ARRAY_ALIGN_POWER2);
+static GBSearchConfig g_signal_hlbsa_bconfig = G_STATIC_BCONFIG (sizeof (HandlerList),
+								 handler_lists_cmp,
+								 G_BSEARCH_ARRAY_DEFER_SHRINK);
+static GBSearchConfig g_class_closure_bconfig = G_STATIC_BCONFIG (sizeof (ClassClosure),
+								  class_closures_cmp,
+								  0);
 static GHashTable    *g_handler_list_bsa_ht = NULL;
 static Emission      *g_recursive_emissions = NULL;
 static Emission      *g_restart_emissions = NULL;
 static GTrashStack   *g_handler_ts = NULL;
-static GTrashStack   *g_emission_ts = NULL;
 static gulong         g_handler_sequential_number = 1;
 G_LOCK_DEFINE_STATIC (g_signal_mutex);
 #define	SIGNAL_LOCK()		G_LOCK (g_signal_mutex)
@@ -272,7 +284,7 @@ signal_id_lookup (GQuark quark,
       SignalKey *signal_key;
       
       key.itype = type;
-      signal_key = g_bsearch_array_lookup (&g_signal_key_bsa, &key);
+      signal_key = g_bsearch_array_lookup (g_signal_key_bsa, &g_signal_key_bconfig, &key);
       
       if (signal_key)
 	return signal_key->signal_id;
@@ -288,7 +300,7 @@ signal_id_lookup (GQuark quark,
       SignalKey *signal_key;
 
       key.itype = ifaces[n_ifaces];
-      signal_key = g_bsearch_array_lookup (&g_signal_key_bsa, &key);
+      signal_key = g_bsearch_array_lookup (g_signal_key_bsa, &g_signal_key_bconfig, &key);
 
       if (signal_key)
 	{
@@ -302,6 +314,15 @@ signal_id_lookup (GQuark quark,
 }
 
 static gint
+class_closures_cmp (gconstpointer node1,
+		    gconstpointer node2)
+{
+  const ClassClosure *c1 = node1, *c2 = node2;
+  
+  return G_BSEARCH_ARRAY_CMP (c1->instance_type, c2->instance_type);
+}
+
+static gint
 handler_lists_cmp (gconstpointer node1,
                    gconstpointer node2)
 {
@@ -317,15 +338,23 @@ handler_list_ensure (guint    signal_id,
   GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
   HandlerList key;
   
+  key.signal_id = signal_id;
+  key.handlers = NULL;
   if (!hlbsa)
     {
-      hlbsa = g_bsearch_array_new (sizeof (HandlerList), handler_lists_cmp, G_BSEARCH_ARRAY_DEFER_SHRINK);
+      hlbsa = g_bsearch_array_new (&g_signal_hlbsa_bconfig);
+      hlbsa = g_bsearch_array_insert (hlbsa, &g_signal_hlbsa_bconfig, &key, FALSE);
       g_hash_table_insert (g_handler_list_bsa_ht, instance, hlbsa);
     }
-  key.signal_id = signal_id;
-  key.handlers = NULL;
-  
-  return g_bsearch_array_insert (hlbsa, &key, FALSE);
+  else
+    {
+      GBSearchArray *o = hlbsa;
+
+      hlbsa = g_bsearch_array_insert (o, &g_signal_hlbsa_bconfig, &key, FALSE);
+      if (hlbsa != o)
+	g_hash_table_insert (g_handler_list_bsa_ht, instance, hlbsa);
+    }
+  return g_bsearch_array_lookup (hlbsa, &g_signal_hlbsa_bconfig, &key);
 }
 
 static inline HandlerList*
@@ -337,7 +366,7 @@ handler_list_lookup (guint    signal_id,
   
   key.signal_id = signal_id;
   
-  return hlbsa ? g_bsearch_array_lookup (hlbsa, &key) : NULL;
+  return hlbsa ? g_bsearch_array_lookup (hlbsa, &g_signal_hlbsa_bconfig, &key) : NULL;
 }
 
 static Handler*
@@ -353,7 +382,7 @@ handler_lookup (gpointer instance,
       
       for (i = 0; i < hlbsa->n_nodes; i++)
         {
-          HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, i);
+          HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, &g_signal_hlbsa_bconfig, i);
           Handler *handler;
           
           for (handler = hlist->handlers; handler; handler = handler->next)
@@ -454,7 +483,7 @@ handlers_find (gpointer         instance,
           
           for (i = 0; i < hlbsa->n_nodes; i++)
             {
-              HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, i);
+              HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, &g_signal_hlbsa_bconfig, i);
 	      SignalNode *node = NULL;
               Handler *handler;
               
@@ -586,36 +615,29 @@ handler_insert (guint    signal_id,
 }
 
 static inline void
-emission_push (Emission     **emission_list_p,
-	       guint          signal_id,
-	       GQuark	      detail,
-	       gpointer       instance,
-	       EmissionState *state_p)
-{
-  Emission *emission = g_generic_node_alloc (&g_emission_ts,
-                                             sizeof (Emission),
-                                             EMISSION_PRE_ALLOC);
+emission_push (Emission **emission_list_p,
+	       Emission  *emission)
+{
   emission->next = *emission_list_p;
-  emission->signal_id = signal_id;
-  emission->detail = detail;
-  emission->instance = instance;
-  emission->state_p = state_p;
   *emission_list_p = emission;
 }
 
 static inline void
-emission_pop (Emission     **emission_list_p,
-	      EmissionState *state_p)
+emission_pop (Emission **emission_list_p,
+	      Emission  *emission)
 {
-  Emission **loc = emission_list_p, *emission = *loc;
-  
-  while (emission->state_p != state_p)
-    {
-      loc = &emission->next;
-      emission = *loc;
-    }
-  *loc = emission->next;
-  g_generic_node_free (&g_emission_ts, emission);
+  Emission *node, *last = NULL;
+
+  for (node = *emission_list_p; node; last = node, node = last->next)
+    if (node == emission)
+      {
+	if (last)
+	  last->next = node->next;
+	else
+	  *emission_list_p = node->next;
+	return;
+      }
+  g_assert_not_reached ();
 }
 
 static inline Emission*
@@ -628,8 +650,20 @@ emission_find (Emission *emission_list,
   
   for (emission = emission_list; emission; emission = emission->next)
     if (emission->instance == instance &&
-	emission->signal_id == signal_id &&
-	emission->detail == detail)
+	emission->ihint.signal_id == signal_id &&
+	emission->ihint.detail == detail)
+      return emission;
+  return NULL;
+}
+
+static inline Emission*
+emission_find_innermost (Emission *emission_list,
+			 gpointer  instance)
+{
+  Emission *emission;
+  
+  for (emission = emission_list; emission; emission = emission->next)
+    if (emission->instance == instance)
       return emission;
   return NULL;
 }
@@ -657,6 +691,7 @@ g_signal_init (void) /* sync with gtype.c */
       
       /* setup handler list binary searchable array hash table (in german, that'd be one word ;) */
       g_handler_list_bsa_ht = g_hash_table_new (g_direct_hash, NULL);
+      g_signal_key_bsa = g_bsearch_array_new (&g_signal_key_bconfig);
       
       /* invalid (0) signal_id */
       g_n_signal_nodes = 1;
@@ -714,11 +749,11 @@ g_signal_stop_emission (gpointer instance,
       
       if (emission)
         {
-          if (*emission->state_p == EMISSION_HOOK)
+          if (emission->state == EMISSION_HOOK)
             g_warning (G_STRLOC ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook",
                        node->name, instance);
-          else if (*emission->state_p == EMISSION_RUN)
-            *emission->state_p = EMISSION_STOP;
+          else if (emission->state == EMISSION_RUN)
+            emission->state = EMISSION_STOP;
         }
       else
         g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance `%p'",
@@ -915,11 +950,11 @@ g_signal_stop_emission_by_name (gpointer     instance,
 	  
 	  if (emission)
 	    {
-	      if (*emission->state_p == EMISSION_HOOK)
+	      if (emission->state == EMISSION_HOOK)
 		g_warning (G_STRLOC ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook",
 			   node->name, instance);
-	      else if (*emission->state_p == EMISSION_RUN)
-		*emission->state_p = EMISSION_STOP;
+	      else if (emission->state == EMISSION_RUN)
+		emission->state = EMISSION_STOP;
 	    }
 	  else
 	    g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance `%p'",
@@ -973,8 +1008,8 @@ g_signal_list_ids (GType  itype,
   g_return_val_if_fail (n_ids != NULL, NULL);
   
   SIGNAL_LOCK ();
-  keys = g_signal_key_bsa.nodes;
-  n_nodes  = g_signal_key_bsa.n_nodes;
+  keys = G_BSEARCH_ARRAY_NODES (&g_signal_key_bsa);
+  n_nodes = g_signal_key_bsa->n_nodes;
   result = g_array_new (FALSE, FALSE, sizeof (guint));
   
   for (i = 0; i < n_nodes; i++)
@@ -1047,40 +1082,6 @@ g_signal_query (guint         signal_id,
 }
 
 guint
-g_signal_new_valist (const gchar       *signal_name,
-                     GType              itype,
-                     GSignalFlags       signal_flags,
-                     GClosure          *class_closure,
-                     GSignalAccumulator accumulator,
-		     gpointer		accu_data,
-                     GSignalCMarshaller c_marshaller,
-                     GType              return_type,
-                     guint              n_params,
-                     va_list            args)
-{
-  GType *param_types;
-  guint i;
-  guint signal_id;
-
-  if (n_params > 0)
-    {
-      param_types = g_new (GType, n_params);
-
-      for (i = 0; i < n_params; i++)
-	param_types[i] = va_arg (args, GType);
-    }
-  else
-    param_types = NULL;
-
-  signal_id = g_signal_newv (signal_name, itype, signal_flags,
-			     class_closure, accumulator, accu_data, c_marshaller,
-			     return_type, n_params, param_types);
-  g_free (param_types);
-
-  return signal_id;
-}
-
-guint
 g_signal_new (const gchar	 *signal_name,
 	      GType		  itype,
 	      GSignalFlags	  signal_flags,
@@ -1109,6 +1110,65 @@ g_signal_new (const gchar	 *signal_name,
   return signal_id;
 }
 
+static inline ClassClosure*
+signal_find_class_closure (SignalNode *node,
+			   GType       itype)
+{
+  GBSearchArray *bsa = node->class_closure_bsa;
+  ClassClosure *cc;
+
+  if (bsa)
+    {
+      ClassClosure key;
+
+      /* cc->instance_type is 0 for default closure */
+      
+      key.instance_type = itype;
+      cc = g_bsearch_array_lookup (bsa, &g_class_closure_bconfig, &key);
+      while (!cc && key.instance_type)
+	{
+	  key.instance_type = g_type_parent (key.instance_type);
+	  cc = g_bsearch_array_lookup (bsa, &g_class_closure_bconfig, &key);
+	}
+    }
+  else
+    cc = NULL;
+  return cc;
+}
+
+static inline GClosure*
+signal_lookup_closure (SignalNode    *node,
+		       GTypeInstance *instance)
+{
+  ClassClosure *cc;
+
+  if (node->class_closure_bsa && node->class_closure_bsa->n_nodes == 1)
+    cc = G_BSEARCH_ARRAY_NODES (node->class_closure_bsa);
+  else
+    cc = signal_find_class_closure (node, G_TYPE_FROM_INSTANCE (instance));
+  return cc ? cc->closure : NULL;
+}
+
+static void
+signal_add_class_closure (SignalNode *node,
+			  GType       itype,
+			  GClosure   *closure)
+{
+  ClassClosure key;
+
+  if (!node->class_closure_bsa)
+    node->class_closure_bsa = g_bsearch_array_new (&g_class_closure_bconfig);
+  key.instance_type = itype;
+  key.closure = g_closure_ref (closure);
+  node->class_closure_bsa = g_bsearch_array_insert (node->class_closure_bsa,
+						    &g_class_closure_bconfig,
+						    &key,
+						    FALSE);
+  g_closure_sink (closure);
+  if (node->c_marshaller && closure && G_CLOSURE_NEEDS_MARSHAL (closure))
+    g_closure_set_marshal (closure, node->c_marshaller);
+}
+
 guint
 g_signal_newv (const gchar       *signal_name,
                GType              itype,
@@ -1205,10 +1265,10 @@ g_signal_newv (const gchar       *signal_name,
       key.itype = itype;
       key.quark = g_quark_from_string (node->name);
       key.signal_id = signal_id;
-      g_bsearch_array_insert (&g_signal_key_bsa, &key, FALSE);
+      g_signal_key_bsa = g_bsearch_array_insert (g_signal_key_bsa, &g_signal_key_bconfig, &key, FALSE);
       g_strdelimit (node->name, "_", '-');
       key.quark = g_quark_from_static_string (node->name);
-      g_bsearch_array_insert (&g_signal_key_bsa, &key, FALSE);
+      g_signal_key_bsa = g_bsearch_array_insert (g_signal_key_bsa, &g_signal_key_bconfig, &key, FALSE);
     }
   node->destroyed = FALSE;
   
@@ -1217,9 +1277,7 @@ g_signal_newv (const gchar       *signal_name,
   node->n_params = n_params;
   node->param_types = g_memdup (param_types, sizeof (GType) * n_params);
   node->return_type = return_type;
-  node->class_closure = class_closure ? g_closure_ref (class_closure) : NULL;
-  if (class_closure)
-    g_closure_sink (class_closure);
+  node->class_closure_bsa = NULL;
   if (accumulator)
     {
       node->accumulator = g_new (SignalAccumulator, 1);
@@ -1230,9 +1288,44 @@ g_signal_newv (const gchar       *signal_name,
     node->accumulator = NULL;
   node->c_marshaller = c_marshaller;
   node->emission_hooks = NULL;
-  if (node->c_marshaller && class_closure && G_CLOSURE_NEEDS_MARSHAL (class_closure))
-    g_closure_set_marshal (class_closure, node->c_marshaller);
+  if (class_closure)
+    signal_add_class_closure (node, 0, class_closure);
   SIGNAL_UNLOCK ();
+
+  return signal_id;
+}
+
+guint
+g_signal_new_valist (const gchar       *signal_name,
+                     GType              itype,
+                     GSignalFlags       signal_flags,
+                     GClosure          *class_closure,
+                     GSignalAccumulator accumulator,
+		     gpointer		accu_data,
+                     GSignalCMarshaller c_marshaller,
+                     GType              return_type,
+                     guint              n_params,
+                     va_list            args)
+{
+  GType *param_types;
+  guint i;
+  guint signal_id;
+
+  if (n_params > 0)
+    {
+      param_types = g_new (GType, n_params);
+
+      for (i = 0; i < n_params; i++)
+	param_types[i] = va_arg (args, GType);
+    }
+  else
+    param_types = NULL;
+
+  signal_id = g_signal_newv (signal_name, itype, signal_flags,
+			     class_closure, accumulator, accu_data, c_marshaller,
+			     return_type, n_params, param_types);
+  g_free (param_types);
+
   return signal_id;
 }
 
@@ -1240,14 +1333,14 @@ static void
 signal_destroy_R (SignalNode *signal_node)
 {
   SignalNode node = *signal_node;
-  
+
   signal_node->destroyed = TRUE;
   
   /* reentrancy caution, zero out real contents first */
   signal_node->n_params = 0;
   signal_node->param_types = NULL;
   signal_node->return_type = 0;
-  signal_node->class_closure = NULL;
+  signal_node->class_closure_bsa = NULL;
   signal_node->accumulator = NULL;
   signal_node->c_marshaller = NULL;
   signal_node->emission_hooks = NULL;
@@ -1259,7 +1352,7 @@ signal_destroy_R (SignalNode *signal_node)
     
     for (emission = (node.flags & G_SIGNAL_NO_RECURSE) ? g_restart_emissions : g_recursive_emissions;
          emission; emission = emission->next)
-      if (emission->signal_id == node.signal_id)
+      if (emission->ihint.signal_id == node.signal_id)
         g_critical (G_STRLOC ": signal \"%s\" being destroyed is currently in emission (instance `%p')",
                     node.name, emission->instance);
   }
@@ -1269,7 +1362,18 @@ signal_destroy_R (SignalNode *signal_node)
    */
   SIGNAL_UNLOCK ();
   g_free (node.param_types);
-  g_closure_unref (node.class_closure);
+  if (node.class_closure_bsa)
+    {
+      guint i;
+
+      for (i = 0; i < node.class_closure_bsa->n_nodes; i++)
+	{
+	  ClassClosure *cc = g_bsearch_array_get_nth (node.class_closure_bsa, &g_class_closure_bconfig, i);
+
+	  g_closure_unref (cc->closure);
+	}
+      g_bsearch_array_destroy (node.class_closure_bsa, &g_class_closure_bconfig);
+    }
   g_free (node.accumulator);
   if (node.emission_hooks)
     {
@@ -1284,6 +1388,25 @@ g_signal_override_class_closure (guint     signal_id,
 				 GType     instance_type,
 				 GClosure *class_closure)
 {
+  SignalNode *node;
+
+  g_return_if_fail (signal_id > 0);
+  g_return_if_fail (class_closure != NULL);
+
+  SIGNAL_LOCK ();
+  node = LOOKUP_SIGNAL_NODE (signal_id);
+  if (!g_type_is_a (instance_type, node->itype))
+    g_warning ("%s: type `%s' cannot be overridden for signal id `%u'", G_STRLOC, g_type_name (instance_type), signal_id);
+  else
+    {
+      ClassClosure *cc = signal_find_class_closure (node, instance_type);
+
+      if (cc && cc->instance_type == instance_type)
+	g_warning ("%s: type `%s' is already overridden for signal id `%u'", G_STRLOC, g_type_name (instance_type), signal_id);
+      else
+	signal_add_class_closure (node, instance_type, class_closure);
+    }
+  SIGNAL_UNLOCK ();
 }
 
 void
@@ -1291,6 +1414,65 @@ g_signal_chain_from_overridden (const GValue *instance_and_params,
 				guint         signal_id,
 				GValue       *return_value)
 {
+  GType chain_type = 0, restore_type = 0;
+  Emission *emission = NULL;
+  GClosure *closure = NULL;
+  gpointer instance;
+  SignalNode *node;
+  
+  g_return_if_fail (instance_and_params != NULL);
+  instance = g_value_peek_pointer (instance_and_params);
+  g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
+  g_return_if_fail (signal_id > 0);
+  
+  SIGNAL_LOCK ();
+  node = LOOKUP_SIGNAL_NODE (signal_id);
+  if (node && g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype))
+    {
+      Emission *emission_list = node->flags & G_SIGNAL_NO_RECURSE ? g_restart_emissions : g_recursive_emissions;
+
+      emission = emission_find_innermost (emission_list, instance);
+
+      /* what we don't catch here is the scenario:
+       * 1) signal1 being in class_closure, emitting signal2
+       * 2) signal2 being in class closure, trying to chain signal1
+       * 3) signal1&G_SIGNAL_NO_RECURSE != signal2&G_SIGNAL_NO_RECURSE.
+       *
+       * also, it'd be a good idea to perform the same checks on parameters
+       * as g_signal_emitv() here.
+       */
+      if (emission && emission->ihint.signal_id == signal_id && emission->chain_type != G_TYPE_NONE)
+	{
+	  ClassClosure *cc = signal_find_class_closure (node, emission->chain_type);
+
+	  g_assert (cc != NULL);	/* closure currently in call stack */
+
+	  restore_type = cc->instance_type;
+	  cc = signal_find_class_closure (node, g_type_parent (cc->instance_type));
+	  if (cc && cc->instance_type != restore_type)
+	    {
+	      closure = cc->closure;
+	      chain_type = cc->instance_type;
+	    }
+	}
+      else
+	g_warning ("%s: signal id `%u' is not innermost class closure emission for instance `%p'", G_STRLOC, signal_id, instance);
+    }
+  else
+    g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
+  if (closure)
+    {
+      emission->chain_type = chain_type;
+      SIGNAL_UNLOCK ();
+      g_closure_invoke (closure,
+			return_value,
+			node->n_params + 1,
+			instance_and_params,
+			&emission->ihint);
+      SIGNAL_LOCK ();
+      emission->chain_type = restore_type;
+    }
+  SIGNAL_UNLOCK ();
 }
 
 gulong
@@ -1539,7 +1721,7 @@ g_signal_handlers_destroy (gpointer instance)
       
       for (i = 0; i < hlbsa->n_nodes; i++)
         {
-          HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, i);
+          HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, &g_signal_hlbsa_bconfig, i);
           Handler *handler = hlist->handlers;
 	  
           while (handler)
@@ -1558,7 +1740,7 @@ g_signal_handlers_destroy (gpointer instance)
 		}
             }
         }
-      g_bsearch_array_destroy (hlbsa);
+      g_bsearch_array_destroy (hlbsa, &g_signal_hlbsa_bconfig);
     }
   SIGNAL_UNLOCK ();
 }
@@ -1993,9 +2175,8 @@ signal_emit_unlocked_R (SignalNode   *node,
 			GValue	     *emission_return,
 			const GValue *instance_and_params)
 {
-  EmissionState emission_state = 0;
   SignalAccumulator *accumulator;
-  GSignalInvocationHint ihint;
+  Emission emission;
   GClosure *class_closure;
   HandlerList *hlist;
   Handler *handler_list = NULL;
@@ -2020,17 +2201,15 @@ signal_emit_unlocked_R (SignalNode   *node,
   signal_id = node->signal_id;
   if (node->flags & G_SIGNAL_NO_RECURSE)
     {
-      Emission *emission = emission_find (g_restart_emissions, signal_id, detail, instance);
+      Emission *node = emission_find (g_restart_emissions, signal_id, detail, instance);
       
-      if (emission)
+      if (node)
 	{
-	  *emission->state_p = EMISSION_RESTART;
+	  node->state = EMISSION_RESTART;
 	  SIGNAL_UNLOCK ();
 	  return return_value_altered;
 	}
     }
-  ihint.signal_id = node->signal_id;
-  ihint.detail = detail;
   accumulator = node->accumulator;
   if (accumulator)
     {
@@ -2041,9 +2220,14 @@ signal_emit_unlocked_R (SignalNode   *node,
     }
   else
     return_accu = emission_return;
-  emission_push ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions,
-		 signal_id, detail, instance, &emission_state);
-  class_closure = node->class_closure;
+  emission.instance = instance;
+  emission.ihint.signal_id = node->signal_id;
+  emission.ihint.detail = detail;
+  emission.ihint.run_type = 0;
+  emission.state = 0;
+  emission.chain_type = G_TYPE_NONE;
+  emission_push ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions, &emission);
+  class_closure = signal_lookup_closure (node, instance);
   
  EMIT_RESTART:
   
@@ -2055,27 +2239,29 @@ signal_emit_unlocked_R (SignalNode   *node,
   if (handler_list)
     handler_ref (handler_list);
   
-  ihint.run_type = G_SIGNAL_RUN_FIRST;
+  emission.ihint.run_type = G_SIGNAL_RUN_FIRST;
   
   if ((node->flags & G_SIGNAL_RUN_FIRST) && class_closure)
     {
-      emission_state = EMISSION_RUN;
-      
+      emission.state = EMISSION_RUN;
+
+      emission.chain_type = G_TYPE_FROM_INSTANCE (instance);
       SIGNAL_UNLOCK ();
       g_closure_invoke (class_closure,
 			return_accu,
 			node->n_params + 1,
 			instance_and_params,
-			&ihint);
-      if (!accumulate (&ihint, emission_return, &accu, accumulator) &&
-	  emission_state == EMISSION_RUN)
-	emission_state = EMISSION_STOP;
+			&emission.ihint);
+      if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
+	  emission.state == EMISSION_RUN)
+	emission.state = EMISSION_STOP;
       SIGNAL_LOCK ();
+      emission.chain_type = G_TYPE_NONE;
       return_value_altered = TRUE;
       
-      if (emission_state == EMISSION_STOP)
+      if (emission.state == EMISSION_STOP)
 	goto EMIT_CLEANUP;
-      else if (emission_state == EMISSION_RESTART)
+      else if (emission.state == EMISSION_RESTART)
 	goto EMIT_RESTART;
     }
   
@@ -2084,7 +2270,7 @@ signal_emit_unlocked_R (SignalNode   *node,
       gboolean need_destroy, was_in_call, may_recurse = TRUE;
       GHook *hook;
 
-      emission_state = EMISSION_HOOK;
+      emission.state = EMISSION_HOOK;
       hook = g_hook_first_valid (node->emission_hooks, may_recurse);
       while (hook)
 	{
@@ -2097,7 +2283,7 @@ signal_emit_unlocked_R (SignalNode   *node,
 	      was_in_call = G_HOOK_IN_CALL (hook);
 	      hook->flags |= G_HOOK_FLAG_IN_CALL;
               SIGNAL_UNLOCK ();
-	      need_destroy = !hook_func (&ihint, node->n_params + 1, instance_and_params, hook->data);
+	      need_destroy = !hook_func (&emission.ihint, node->n_params + 1, instance_and_params, hook->data);
 	      SIGNAL_LOCK ();
 	      if (!was_in_call)
 		hook->flags &= ~G_HOOK_FLAG_IN_CALL;
@@ -2107,7 +2293,7 @@ signal_emit_unlocked_R (SignalNode   *node,
 	  hook = g_hook_next_valid (node->emission_hooks, hook, may_recurse);
 	}
       
-      if (emission_state == EMISSION_RESTART)
+      if (emission.state == EMISSION_RESTART)
 	goto EMIT_RESTART;
     }
   
@@ -2115,7 +2301,7 @@ signal_emit_unlocked_R (SignalNode   *node,
     {
       Handler *handler = handler_list;
       
-      emission_state = EMISSION_RUN;
+      emission.state = EMISSION_RUN;
       handler_ref (handler);
       do
 	{
@@ -2135,14 +2321,14 @@ signal_emit_unlocked_R (SignalNode   *node,
 				return_accu,
 				node->n_params + 1,
 				instance_and_params,
-				&ihint);
-	      if (!accumulate (&ihint, emission_return, &accu, accumulator) &&
-		  emission_state == EMISSION_RUN)
-		emission_state = EMISSION_STOP;
+				&emission.ihint);
+	      if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
+		  emission.state == EMISSION_RUN)
+		emission.state = EMISSION_STOP;
 	      SIGNAL_LOCK ();
 	      return_value_altered = TRUE;
 	      
-	      tmp = emission_state == EMISSION_RUN ? handler->next : NULL;
+	      tmp = emission.state == EMISSION_RUN ? handler->next : NULL;
 	    }
 	  else
 	    tmp = handler->next;
@@ -2155,33 +2341,35 @@ signal_emit_unlocked_R (SignalNode   *node,
 	}
       while (handler);
       
-      if (emission_state == EMISSION_STOP)
+      if (emission.state == EMISSION_STOP)
 	goto EMIT_CLEANUP;
-      else if (emission_state == EMISSION_RESTART)
+      else if (emission.state == EMISSION_RESTART)
 	goto EMIT_RESTART;
     }
   
-  ihint.run_type = G_SIGNAL_RUN_LAST;
+  emission.ihint.run_type = G_SIGNAL_RUN_LAST;
   
   if ((node->flags & G_SIGNAL_RUN_LAST) && class_closure)
     {
-      emission_state = EMISSION_RUN;
+      emission.state = EMISSION_RUN;
       
+      emission.chain_type = G_TYPE_FROM_INSTANCE (instance);
       SIGNAL_UNLOCK ();
       g_closure_invoke (class_closure,
 			return_accu,
 			node->n_params + 1,
 			instance_and_params,
-			&ihint);
-      if (!accumulate (&ihint, emission_return, &accu, accumulator) &&
-	  emission_state == EMISSION_RUN)
-	emission_state = EMISSION_STOP;
+			&emission.ihint);
+      if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
+	  emission.state == EMISSION_RUN)
+	emission.state = EMISSION_STOP;
       SIGNAL_LOCK ();
+      emission.chain_type = G_TYPE_NONE;
       return_value_altered = TRUE;
       
-      if (emission_state == EMISSION_STOP)
+      if (emission.state == EMISSION_STOP)
 	goto EMIT_CLEANUP;
-      else if (emission_state == EMISSION_RESTART)
+      else if (emission.state == EMISSION_RESTART)
 	goto EMIT_RESTART;
     }
   
@@ -2189,7 +2377,7 @@ signal_emit_unlocked_R (SignalNode   *node,
     {
       Handler *handler = handler_list;
       
-      emission_state = EMISSION_RUN;
+      emission.state = EMISSION_RUN;
       handler_ref (handler);
       do
 	{
@@ -2203,14 +2391,14 @@ signal_emit_unlocked_R (SignalNode   *node,
 				return_accu,
 				node->n_params + 1,
 				instance_and_params,
-				&ihint);
-	      if (!accumulate (&ihint, emission_return, &accu, accumulator) &&
-		  emission_state == EMISSION_RUN)
-		emission_state = EMISSION_STOP;
+				&emission.ihint);
+	      if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
+		  emission.state == EMISSION_RUN)
+		emission.state = EMISSION_STOP;
 	      SIGNAL_LOCK ();
 	      return_value_altered = TRUE;
 	      
-	      tmp = emission_state == EMISSION_RUN ? handler->next : NULL;
+	      tmp = emission.state == EMISSION_RUN ? handler->next : NULL;
 	    }
 	  else
 	    tmp = handler->next;
@@ -2222,22 +2410,23 @@ signal_emit_unlocked_R (SignalNode   *node,
 	}
       while (handler);
       
-      if (emission_state == EMISSION_STOP)
+      if (emission.state == EMISSION_STOP)
 	goto EMIT_CLEANUP;
-      else if (emission_state == EMISSION_RESTART)
+      else if (emission.state == EMISSION_RESTART)
 	goto EMIT_RESTART;
     }
   
  EMIT_CLEANUP:
   
-  ihint.run_type = G_SIGNAL_RUN_CLEANUP;
+  emission.ihint.run_type = G_SIGNAL_RUN_CLEANUP;
   
   if ((node->flags & G_SIGNAL_RUN_CLEANUP) && class_closure)
     {
       gboolean need_unset = FALSE;
       
-      emission_state = EMISSION_STOP;
+      emission.state = EMISSION_STOP;
       
+      emission.chain_type = G_TYPE_FROM_INSTANCE (instance);
       SIGNAL_UNLOCK ();
       if (node->return_type != G_TYPE_NONE && !accumulator)
 	{
@@ -2248,19 +2437,20 @@ signal_emit_unlocked_R (SignalNode   *node,
 			node->return_type != G_TYPE_NONE ? &accu : NULL,
 			node->n_params + 1,
 			instance_and_params,
-			&ihint);
+			&emission.ihint);
       if (need_unset)
 	g_value_unset (&accu);
       SIGNAL_LOCK ();
+      emission.chain_type = G_TYPE_NONE;
       
-      if (emission_state == EMISSION_RESTART)
+      if (emission.state == EMISSION_RESTART)
 	goto EMIT_RESTART;
     }
   
   if (handler_list)
     handler_unref_R (signal_id, instance, handler_list);
   
-  emission_pop ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions, &emission_state);
+  emission_pop ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions, &emission);
   SIGNAL_UNLOCK ();
   if (accumulator)
     g_value_unset (&accu);
diff --git a/gobject/gsignal.h b/gobject/gsignal.h
index 0a3b4bba5..6b9628581 100644
--- a/gobject/gsignal.h
+++ b/gobject/gsignal.h
@@ -238,7 +238,7 @@ void	g_signal_chain_from_overridden	      (const GValue      *instance_and_param
 
 /* --- convenience --- */
 #define g_signal_connect(instance, detailed_signal, c_handler, data) \
-    g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, (GConnectFlags)0)
+    g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, (GConnectFlags) 0)
 #define g_signal_connect_after(instance, detailed_signal, c_handler, data) \
     g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, G_CONNECT_AFTER)
 #define g_signal_connect_swapped(instance, detailed_signal, c_handler, data) \
diff --git a/gobject/gtype.c b/gobject/gtype.c
index d2c9b2a29..adafc2b40 100644
--- a/gobject/gtype.c
+++ b/gobject/gtype.c
@@ -2822,6 +2822,7 @@ g_type_name_from_class (GTypeClass *g_class)
 
 
 /* --- foreign prototypes --- */
+extern void	g_value_c_init		(void); /* sync with gvalue.c */
 extern void	g_value_types_init	(void); /* sync with gvaluetypes.c */
 extern void	g_enum_types_init	(void);	/* sync with genums.c */
 extern void     g_param_type_init       (void);	/* sync with gparam.c */
@@ -2897,6 +2898,8 @@ g_type_init_with_debug_flags (GTypeDebugFlags debug_flags)
   
   G_WRITE_UNLOCK (&type_rw_lock);
   
+  g_value_c_init ();
+
   /* G_TYPE_TYPE_PLUGIN
    */
   g_type_plugin_get_type ();
diff --git a/gobject/gvalue.c b/gobject/gvalue.c
index c6853d115..b23577a62 100644
--- a/gobject/gvalue.c
+++ b/gobject/gvalue.c
@@ -42,12 +42,19 @@ static gint	transform_entries_cmp	(gconstpointer bsearch_node1,
 
 
 /* --- variables --- */
-static GBSearchArray transform_array = G_STATIC_BSEARCH_ARRAY_INIT (sizeof (TransformEntry),
-								    transform_entries_cmp,
-								    0);
+static GBSearchArray *transform_array = NULL;
+static GBSearchConfig transform_bconfig = G_STATIC_BCONFIG (sizeof (TransformEntry),
+							    transform_entries_cmp,
+							    0);
 
 
 /* --- functions --- */
+void
+g_value_c_init (void)	/* sync with gtype.c */
+{
+  transform_array = g_bsearch_array_new (&transform_bconfig);
+}
+
 static inline void		/* keep this function in sync with gvaluecollector.h and gboxed.c */
 value_meminit (GValue *value,
 	       GType   value_type)
@@ -230,7 +237,7 @@ transform_func_lookup (GType src_type,
 	{
 	  TransformEntry *e;
 	  
-	  e = g_bsearch_array_lookup (&transform_array, &entry);
+	  e = g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry);
 	  if (e)
 	    {
 	      /* need to check that there hasn't been a change in value handling */
@@ -277,7 +284,7 @@ g_value_register_transform_func (GType           src_type,
   entry.src_type = src_type;
   entry.dest_type = dest_type;
   
-  if (g_bsearch_array_lookup (&transform_array, &entry))
+  if (g_bsearch_array_lookup (transform_array, &transform_bconfig, &entry))
     g_warning ("reregistering value transformation function (%p) for `%s' to `%s'",
 	       transform_func,
 	       g_type_name (src_type),
@@ -285,7 +292,7 @@ g_value_register_transform_func (GType           src_type,
 
   entry.func = transform_func;
 
-  g_bsearch_array_insert (&transform_array, &entry, TRUE);
+  transform_array = g_bsearch_array_insert (transform_array, &transform_bconfig, &entry, TRUE);
 }
 
 gboolean