Really commit fixes; make unit tests pass

11 files changed, 183 insertions, 78 deletions

diff --git a/atspi/Makefile.am b/atspi/Makefile.am
index aab0393c..6c8105ab 100644
--- a/atspi/Makefile.am
+++ b/atspi/Makefile.am
@@ -51,6 +51,8 @@ libatspi_la_SOURCES =		\
 	atspi-private.h \
 	atspi-registry.c \
 	atspi-registry.h \
+	atspi-relation.c \
+	atspi-relation.h \
 	atspi-selection.c \
 	atspi-selection.h \
 	atspi-stateset.c \
diff --git a/atspi/atspi-accessible.c b/atspi/atspi-accessible.c
index e7ff0229..383732b3 100644
--- a/atspi/atspi-accessible.c
+++ b/atspi/atspi-accessible.c
@@ -30,6 +30,11 @@ atspi_action_interface_init (AtspiAction *action)
 }
 
 static void
+atspi_collection_interface_init (AtspiCollection *component)
+{
+}
+
+static void
 atspi_component_interface_init (AtspiComponent *component)
 {
 }
@@ -65,6 +70,7 @@ atspi_value_interface_init (AtspiValue *value)
 
 G_DEFINE_TYPE_WITH_CODE (AtspiAccessible, atspi_accessible, ATSPI_TYPE_OBJECT,
                          G_IMPLEMENT_INTERFACE (ATSPI_TYPE_ACTION, atspi_action_interface_init)
+                         G_IMPLEMENT_INTERFACE (ATSPI_TYPE_COLLECTION, atspi_collection_interface_init)
                          G_IMPLEMENT_INTERFACE (ATSPI_TYPE_COMPONENT, atspi_component_interface_init)
                          G_IMPLEMENT_INTERFACE (ATSPI_TYPE_EDITABLE_TEXT, atspi_editable_text_interface_init)
                          G_IMPLEMENT_INTERFACE (ATSPI_TYPE_IMAGE, atspi_image_interface_init)
@@ -388,22 +394,35 @@ typedef struct
  * Get the set of #AtspiRelation objects which describe this #AtspiAccessible object's
  *       relationships with other #AtspiAccessible objects.
  *
- * Returns: an array of #AtspiAccessibleRelation pointers. or NULL on exception
- * TODO:: Annotate array type
+ * Returns: (element-type AtspiAccessible*) (transfer full): an array of
+ *          #AtspiAccessibleRelation pointers. or NULL on exception
  **/
 GArray *
 atspi_accessible_get_relation_set (AtspiAccessible *obj, GError **error)
 {
-  int i;
-  int n_relations;
-  GArray *relation_set;
+  DBusMessage *reply;
+  DBusMessageIter iter, iter_array;
+  GArray *ret;
 
   g_return_val_if_fail (obj != NULL, NULL);
 
-  if (!_atspi_dbus_call (obj, atspi_interface_accessible, "GetRelationSet", error, "=>a(uao)", &relation_set))
-    return NULL;
+  reply = _atspi_dbus_call_partial (obj, atspi_interface_accessible, "GetRelationSet", error, "");
+  _ATSPI_DBUS_CHECK_SIG (reply, "a(ua(so))", NULL);
 
-  return relation_set;
+  ret = g_array_new (TRUE, TRUE, sizeof (AtspiRelation *));
+  dbus_message_iter_init (reply, &iter);
+  dbus_message_iter_recurse (&iter, &iter_array);
+  while (dbus_message_iter_get_arg_type (&iter_array) != DBUS_TYPE_INVALID)
+  {
+    GArray *new_array;
+    AtspiRelation *relation;
+    relation = _atspi_relation_new_from_iter (&iter_array);
+    new_array = g_array_append_val (ret, relation);
+    if (new_array)
+      ret = new_array;
+    dbus_message_iter_next (&iter_array);
+  }
+  return ret;
 }
 
 /**
diff --git a/atspi/atspi-collection.c b/atspi/atspi-collection.c
index 9841369e..144def5a 100644
--- a/atspi/atspi-collection.c
+++ b/atspi/atspi-collection.c
@@ -64,19 +64,16 @@ append_match_rule (DBusMessage *message, AtspiMatchRule *rule)
   DBusMessageIter iter;
 
   dbus_message_iter_init_append (message, &iter);
-  return _atspi_match_rule_marshal (&iter, rule);
+  return _atspi_match_rule_marshal (rule, &iter);
 }
 
 static gboolean
 append_accessible (DBusMessage *message, AtspiAccessible *accessible)
 {
-  DBusMessageIter iter, iter_struct;
+  DBusMessageIter iter;
 
   dbus_message_iter_init_append (message, &iter);
-  dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL, &iter_struct);
-  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_STRING,
-                                  &accessible->parent.app->bus_name);
-  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_OBJECT_PATH,
+  dbus_message_iter_append_basic (&iter, DBUS_TYPE_OBJECT_PATH,
                                   &accessible->parent.path);
 }
 
@@ -86,7 +83,7 @@ return_accessibles (DBusMessage *message)
   DBusMessageIter iter, iter_array;
   GArray *ret = g_array_new (TRUE, TRUE, sizeof (AtspiAccessible *));
 
-  _ATSPI_DBUS_CHECK_SIG (message, "(so)", NULL);
+  _ATSPI_DBUS_CHECK_SIG (message, "a(so)", NULL);
 
   dbus_message_iter_init (message, &iter);
   dbus_message_iter_recurse (&iter, &iter_array);
@@ -99,7 +96,7 @@ return_accessibles (DBusMessage *message)
     new_array = g_array_append_val (ret, accessible);
     if (new_array)
       ret = new_array;
-    dbus_message_iter_next (&iter_array);
+    /* Iter was moved already, so no need to call dbus_message_iter_next */
   }
   dbus_message_unref (message);
   return ret;
@@ -137,7 +134,7 @@ atspi_collection_get_matches (AtspiCollection *collection,
 
   if (!append_match_rule (message, rule))
     return NULL;
-  dbus_message_append_args (message, DBUS_TYPE_INT32, &d_sortby,
+  dbus_message_append_args (message, DBUS_TYPE_UINT32, &d_sortby,
                             DBUS_TYPE_INT32, &d_count,
                             DBUS_TYPE_BOOLEAN, &d_traverse,
                             DBUS_TYPE_INVALID);
@@ -191,8 +188,8 @@ atspi_collection_get_matches_to (AtspiCollection *collection,
     return NULL;
   if (!append_match_rule (message, rule))
     return NULL;
-  dbus_message_append_args (message, DBUS_TYPE_INT32, &d_sortby,
-                                     DBUS_TYPE_INT32, &d_tree,
+  dbus_message_append_args (message, DBUS_TYPE_UINT32, &d_sortby,
+                                     DBUS_TYPE_UINT32, &d_tree,
                             DBUS_TYPE_BOOLEAN, &d_recurse,
                             DBUS_TYPE_INT32, &d_count,
                             DBUS_TYPE_BOOLEAN, &d_traverse,
@@ -244,8 +241,8 @@ atspi_collection_get_matches_from (AtspiCollection *collection,
     return NULL;
   if (!append_match_rule (message, rule))
     return NULL;
-  dbus_message_append_args (message, DBUS_TYPE_INT32, &d_sortby,
-                            DBUS_TYPE_INT32, &d_tree,
+  dbus_message_append_args (message, DBUS_TYPE_UINT32, &d_sortby,
+                            DBUS_TYPE_UINT32, &d_tree,
                             DBUS_TYPE_INT32, &d_count,
                             DBUS_TYPE_BOOLEAN, &d_traverse,
                             DBUS_TYPE_INVALID);
diff --git a/atspi/atspi-matchrule.c b/atspi/atspi-matchrule.c
index e867d0ea..f706f564 100644
--- a/atspi/atspi-matchrule.c
+++ b/atspi/atspi-matchrule.c
@@ -39,8 +39,6 @@ atspi_match_rule_finalize (GObject *obj)
     g_object_unref (rule->states);
   if (rule->attributes)
     g_hash_table_unref (rule->attributes);
-  if (rule->roles)
-    g_array_free (rule->roles, TRUE);
   /* TODO: Check that interfaces don't leak */
   if (rule->interfaces)
     g_array_free (rule->interfaces, TRUE);
@@ -64,14 +62,16 @@ atspi_match_rule_class_init (AtspiMatchRuleClass *klass)
  *              attributes to match.
  * @attributematchtype: An #AtspiCollectionMatchType specifying how to
  *                      interpret @attributes.
- * @roles: (element-type AtspiRole): A #GArray of roles to match, or NULL if
- *         not applicable.
  * @interfaces: (element-type gchar*): An array of interfaces to match, or
- *              NUL if not appliable.  Interface names should be specified
+ *              NUL if not applicable.  Interface names should be specified
  *              by their DBus names (org.a11y.Atspi.Accessible,
  *              org.a11y.Atspi.Component, etc).
  * @interfacematchtype: An #AtspiCollectionMatchType specifying how to
  *                      interpret @interfaces.
+ * @roles: (element-type AtspiRole): A #GArray of roles to match, or NULL if
+ *         not applicable.
+ * @rolematchtype: An #AtspiCollectionMatchType specifying how to
+ *                      interpret @roles.
  * @invert: Specifies whether results should be inverted.
  * TODO: Document this parameter better.
  *
@@ -84,9 +84,12 @@ atspi_match_rule_new (AtspiStateSet *states,
                       AtspiCollectionMatchType attributematchtype,
                       GArray *roles,
                       AtspiCollectionMatchType rolematchtype,
+                      GArray *interfaces,
+                      AtspiCollectionMatchType interfacematchtype,
                       gboolean invert)
 {
   AtspiMatchRule *rule = g_object_new (ATSPI_TYPE_MATCH_RULE, NULL);
+  int i;
 
   if (!rule)
     return NULL;
@@ -96,11 +99,26 @@ atspi_match_rule_new (AtspiStateSet *states,
   rule->statematchtype = statematchtype;
 
   if (attributes)
-    rule->attributes = g_object_ref (attributes);
+    rule->attributes = g_hash_table_ref (attributes);
     rule->attributematchtype = attributematchtype;
 
+  if (interfaces)
+    rule->interfaces = g_array_ref (interfaces);
+  rule->interfacematchtype = interfacematchtype;
+
   if (roles)
-    rule->roles = g_array_ref(roles);
+  {
+    for (i = 0; i < roles->len; i++)
+    {
+      AtspiRole role = g_array_index (roles, AtspiRole, i);
+      if (role < 128)
+        rule->roles [role / 32] |= (1 << (role % 32));
+      else
+        g_warning ("Atspi: unexpected role %d\n", role);
+    }
+  }
+  else
+    rule->roles [0] = rule->roles [1] = 0;
   rule->rolematchtype = rolematchtype;
 
   rule->invert = invert;
@@ -133,8 +151,9 @@ _atspi_match_rule_marshal (AtspiMatchRule *rule, DBusMessageIter *iter)
   dbus_uint32_t d_rolematchtype = rule->rolematchtype;
   dbus_bool_t d_invert = rule->invert;
   gint i;
+  dbus_int32_t d_role;
 
-  if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, "(aiiasiaiisib)",
+  if (!dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL,
                                          &iter_struct))
     return FALSE;
 
@@ -148,35 +167,49 @@ _atspi_match_rule_marshal (AtspiMatchRule *rule, DBusMessageIter *iter)
   {
     states [0] = states [1] = 0;
   }
-  dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "u", &iter_array);
+  dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "i", &iter_array);
   dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &states [0]);
   dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &states [1]);
   dbus_message_iter_close_container (&iter_struct, &iter_array);
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &d_statematchtype);
 
   /* attributes */
-  if (!dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY, "{ss}",
+  if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "{ss}",
                                          &iter_dict))
     return FALSE;
   g_hash_table_foreach (rule->attributes, append_entry, &iter_dict);
-  dbus_message_iter_close_container (iter, &iter_dict);
+  dbus_message_iter_close_container (&iter_struct, &iter_dict);
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &d_attributematchtype);
 
-  /* roles */
   if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "i",
       &iter_array))
     return FALSE;
-  if (rule->roles)
+  d_role = rule->roles [0];
+  dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+  d_role = rule->roles [1];
+  dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+  d_role = rule->roles [2];
+  dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+  d_role = rule->roles [3];
+  dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+  dbus_message_iter_close_container (&iter_struct, &iter_array);
+  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32,
+                                  &d_rolematchtype);
+
+  /* interfaces */
+  if (!dbus_message_iter_open_container (&iter_struct, DBUS_TYPE_ARRAY, "s",
+      &iter_array))
+    return FALSE;
+  if (rule->interfaces)
   {
-    for (i = 0; i < rule->roles->len; i++)
+    for (i = 0; i < rule->interfaces->len; i++)
     {
-      dbus_int32_t d_role = g_array_index (rule->roles, AtspiRole, i);
-      dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_INT32, &d_role);
+      char *val = g_array_index (rule->interfaces, gchar *, i);
+      dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_STRING, &val);
     }
   }
   dbus_message_iter_close_container (&iter_struct, &iter_array);
-  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32,
-                                  &d_rolematchtype);
+  dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_INT32, &d_interfacematchtype);
 
   dbus_message_iter_append_basic (&iter_struct, DBUS_TYPE_BOOLEAN, &d_invert);
 
diff --git a/atspi/atspi-matchrule.h b/atspi/atspi-matchrule.h
index ff3a685c..074bf9f7 100644
--- a/atspi/atspi-matchrule.h
+++ b/atspi/atspi-matchrule.h
@@ -41,14 +41,15 @@
 typedef struct _AtspiMatchRule AtspiMatchRule;
 struct _AtspiMatchRule
 {
+  GObject parent;
   AtspiStateSet *states;
   AtspiCollectionMatchType statematchtype;
   GHashTable *attributes;
   AtspiCollectionMatchType attributematchtype;
-  GArray *roles;
-  AtspiCollectionMatchType rolematchtype;
   GArray *interfaces;
   AtspiCollectionMatchType interfacematchtype;
+  gint roles [4];
+  AtspiCollectionMatchType rolematchtype;
   gboolean invert;
 };
 
@@ -58,6 +59,8 @@ struct _AtspiMatchRuleClass
   GObjectClass parent_class;
 };
 
+GType atspi_match_rule_get_type ();
+
 AtspiMatchRule *
 atspi_match_rule_new (AtspiStateSet *states,
                       AtspiCollectionMatchType statematchtype,
@@ -65,6 +68,8 @@ atspi_match_rule_new (AtspiStateSet *states,
                       AtspiCollectionMatchType attributematchtype,
                       GArray *roles,
                       AtspiCollectionMatchType rolematchtype,
+                      GArray *interfaces,
+                      AtspiCollectionMatchType interfacematchtype,
                       gboolean invert);
 
 gboolean
diff --git a/atspi/atspi-misc.c b/atspi/atspi-misc.c
index 2523e65b..a9fb7f7c 100644
--- a/atspi/atspi-misc.c
+++ b/atspi/atspi-misc.c
@@ -928,7 +928,7 @@ _atspi_dbus_call_partial_va (gpointer obj,
 
     p = type;
     dbus_message_iter_init_append (msg, &iter);
-    dbind_any_marshal_va (&iter, &p, &args);
+    dbind_any_marshal_va (&iter, &p, args);
 
     reply = dbind_send_and_allow_reentry (_atspi_bus(), msg, &err);
 out:
@@ -1013,15 +1013,8 @@ GHashTable *
 _atspi_dbus_hash_from_message (DBusMessage *message)
 {
   DBusMessageIter iter;
-  const char *signature;
 
-  signature = dbus_message_get_signature (message);
-
-  if (strcmp (signature, "a{ss}") != 0)
-    {
-      g_warning ("Trying to get hash from message of unexpected type %s\n", signature);
-      return NULL;
-    }
+  _ATSPI_DBUS_CHECK_SIG (message, "a{ss}", NULL);
 
   dbus_message_iter_init (message, &iter);
   return _atspi_dbus_hash_from_iter (&iter);
@@ -1039,6 +1032,7 @@ _atspi_dbus_hash_from_iter (DBusMessageIter *iter)
     const char *name, *value;
     dbus_message_iter_recurse (&iter_array, &iter_dict);
     dbus_message_iter_get_basic (&iter_dict, &name);
+    dbus_message_iter_next (&iter_dict);
     dbus_message_iter_get_basic (&iter_dict, &value);
     g_hash_table_insert (hash, g_strdup (name), g_strdup (value));
     dbus_message_iter_next (&iter_array);
@@ -1050,15 +1044,10 @@ GArray *
 _atspi_dbus_attribute_array_from_message (DBusMessage *message)
 {
   DBusMessageIter iter;
-  const char *signature;
 
-  signature = dbus_message_get_signature (message);
+  _ATSPI_DBUS_CHECK_SIG (message, "a{ss}", NULL);
 
-  if (strcmp (signature, "a{ss}") != 0)
-    {
-      g_warning ("Trying to get hash from message of unexpected type %s\n", signature);
-      return NULL;
-    }
+  dbus_message_iter_init (message, &iter);
 
   return _atspi_dbus_attribute_array_from_iter (&iter);
 }
@@ -1078,12 +1067,13 @@ _atspi_dbus_attribute_array_from_iter (DBusMessageIter *iter)
     GArray *new_array;
     dbus_message_iter_recurse (&iter_array, &iter_dict);
     dbus_message_iter_get_basic (&iter_dict, &name);
+    dbus_message_iter_next (&iter_dict);
     dbus_message_iter_get_basic (&iter_dict, &value);
-    str = g_strdup_printf ("%s:;%s", name, value);
+    str = g_strdup_printf ("%s:%s", name, value);
     new_array = g_array_append_val (array, str);
     if (new_array)
       array = new_array;
-    dbus_message_iter_next (iter);;
+    dbus_message_iter_next (&iter_array);;
   }
   return array;
 }
diff --git a/atspi/atspi-stateset.c b/atspi/atspi-stateset.c
index 4cba34e2..958b734b 100644
--- a/atspi/atspi-stateset.c
+++ b/atspi/atspi-stateset.c
@@ -80,7 +80,7 @@ atspi_state_set_new (GArray *states)
 
   for (i = 0; i < states->len; i++)
     atspi_state_set_add (set, g_array_index (states, AtspiStateType, i));
-  return states;
+  return set;
 }
 
 AtspiStateSet *
@@ -154,7 +154,7 @@ void
 atspi_state_set_add (AtspiStateSet *set, AtspiStateType state)
 {
   g_return_if_fail (set != NULL);
-  set->states |= (1 << state);
+  set->states |= (((gint64)1) << state);
 }
 
 /**
diff --git a/atspi/atspi.h b/atspi/atspi.h
index fbf712aa..57214a54 100644
--- a/atspi/atspi.h
+++ b/atspi/atspi.h
@@ -42,7 +42,9 @@
 #include "atspi-matchrule.h"
 #include "atspi-misc.h"
 #include "atspi-registry.h"
+#include "atspi-relation.h"
 #include "atspi-selection.h"
+#include "atspi-stateset.h"
 #include "atspi-table.h"
 #include "atspi-text.h"
 #include "atspi-value.h"
diff --git a/dbind/dbind-any.c b/dbind/dbind-any.c
index 8b224480..088a2076 100644
--- a/dbind/dbind-any.c
+++ b/dbind/dbind-any.c
@@ -434,7 +434,7 @@ dbind_any_marshal (DBusMessageIter *iter,
 void
 dbind_any_marshal_va (DBusMessageIter *iter,
                       const char           **arg_types,
-                      va_list          *args)
+                      va_list          args)
 {
     const char *p = *arg_types;
 
@@ -460,16 +460,16 @@ dbind_any_marshal_va (DBusMessageIter *iter,
             case DBUS_TYPE_UINT16:
             case DBUS_TYPE_INT32:
             case DBUS_TYPE_UINT32:
-                intarg = va_arg (*args, int);
+                intarg = va_arg (args, int);
                 arg = &intarg;
                 break;
             case DBUS_TYPE_INT64:
             case DBUS_TYPE_UINT64:
-                int64arg = va_arg (*args, dbus_int64_t);
+                int64arg = va_arg (args, dbus_int64_t);
                 arg = &int64arg;
                 break;
             case DBUS_TYPE_DOUBLE:
-                doublearg = va_arg (*args, double);
+                doublearg = va_arg (args, double);
                 arg = &doublearg;
                 break;
             /* ptr types */
@@ -478,21 +478,21 @@ dbind_any_marshal_va (DBusMessageIter *iter,
             case DBUS_TYPE_SIGNATURE:
             case DBUS_TYPE_ARRAY:
             case DBUS_TYPE_DICT_ENTRY:
-                ptrarg = va_arg (*args, void *);
+                ptrarg = va_arg (args, void *);
                 arg = &ptrarg;
                 break;
             case DBUS_STRUCT_BEGIN_CHAR:
-                ptrarg = va_arg (*args, void *);
+                ptrarg = va_arg (args, void *);
                 arg = ptrarg;
                 break;
             case DBUS_DICT_ENTRY_BEGIN_CHAR:
-                ptrarg = va_arg (*args, void *);
+                ptrarg = va_arg (args, void *);
                 arg = ptrarg;
                 break;
 
             case DBUS_TYPE_VARIANT:
                 fprintf (stderr, "No variant support yet - very toolkit specific\n");
-                ptrarg = va_arg (*args, void *);
+                ptrarg = va_arg (args, void *);
                 arg = &ptrarg;
                 break;
             default:
@@ -635,11 +635,65 @@ dbind_any_demarshal (DBusMessageIter *iter,
 void
 dbind_any_demarshal_va (DBusMessageIter *iter,
                         const char           **arg_types,
-                        va_list          *args)
+                        va_list          args)
 {
     const char *p = *arg_types;
+
+        /* Pass in args */
+    for (;*p != '\0' && *p != '=';) {
+        int intarg;
+        void *ptrarg;
+        double doublearg;
+        dbus_int64_t int64arg;
+        void *arg = NULL;
+
+        switch (*p) {
+        case DBUS_TYPE_BYTE:
+        case DBUS_TYPE_BOOLEAN:
+        case DBUS_TYPE_INT16:
+        case DBUS_TYPE_UINT16:
+        case DBUS_TYPE_INT32:
+        case DBUS_TYPE_UINT32:
+            intarg = va_arg (args, int);
+            break;
+        case DBUS_TYPE_INT64:
+        case DBUS_TYPE_UINT64:
+            int64arg = va_arg (args, dbus_int64_t);
+            break;
+        case DBUS_TYPE_DOUBLE:
+            doublearg = va_arg (args, double);
+            break;
+        /* ptr types */
+        case DBUS_TYPE_STRING:
+        case DBUS_TYPE_OBJECT_PATH:
+        case DBUS_TYPE_SIGNATURE:
+        case DBUS_TYPE_ARRAY:
+        case DBUS_TYPE_DICT_ENTRY:
+            ptrarg = va_arg (args, void *);
+            break;
+        case DBUS_STRUCT_BEGIN_CHAR:
+            ptrarg = va_arg (args, void *);
+            break;
+        case DBUS_DICT_ENTRY_BEGIN_CHAR:
+            ptrarg = va_arg (args, void *);
+            break;
+
+        case DBUS_TYPE_VARIANT:
+            fprintf (stderr, "No variant support yet - very toolkit specific\n");
+            ptrarg = va_arg (args, void *);
+            break;
+        default:
+            fprintf (stderr, "Unknown / invalid arg type %c\n", *p);
+            break;
+        }
+      p++;
+    }
+
+    if (p [0] == '=' && p[1] == '>')
+      p += 2;
+
     for (;*p != '\0';) {
-        void *arg = va_arg (*args, void *);
+        void *arg = va_arg (args, void *);
         dbind_any_demarshal (iter, &p, &arg);
     }
 }
diff --git a/dbind/dbind-any.h b/dbind/dbind-any.h
index ae69caad..094b7166 100644
--- a/dbind/dbind-any.h
+++ b/dbind/dbind-any.h
@@ -11,8 +11,8 @@ void   dbind_any_marshal       (DBusMessageIter *iter,
                                 void           **val);
 
 void   dbind_any_marshal_va    (DBusMessageIter *iter,
-                                const const char           **arg_types,
-                                va_list          *args);
+                                const char           **arg_types,
+                                va_list          args);
 
 void   dbind_any_demarshal     (DBusMessageIter *iter,
                                 const char           **type,
@@ -20,7 +20,7 @@ void   dbind_any_demarshal     (DBusMessageIter *iter,
 
 void   dbind_any_demarshal_va  (DBusMessageIter *iter,
                                 const char           **arg_types,
-                                va_list          *args);
+                                va_list          args);
 
 void   dbind_any_free          (const char      *type,
                                 void            *ptr_to_ptr);
diff --git a/dbind/dbind.c b/dbind/dbind.c
index 9f284e92..a5da81d9 100644
--- a/dbind/dbind.c
+++ b/dbind/dbind.c
@@ -80,7 +80,9 @@ dbind_method_call_reentrant_va (DBusConnection *cnx,
     DBusMessageIter iter;
     DBusError *err, real_err;
     const char *p;
+  va_list args_demarshal;
 
+  va_copy (args_demarshal, args);
     if (opt_error)
         err = opt_error;
     else {
@@ -94,7 +96,7 @@ dbind_method_call_reentrant_va (DBusConnection *cnx,
 
     p = arg_types;
     dbus_message_iter_init_append (msg, &iter);
-    dbind_any_marshal_va (&iter, &p, &args);
+    dbind_any_marshal_va (&iter, &p, args);
 
     reply = dbind_send_and_allow_reentry (cnx, msg, err);
     if (!reply)
@@ -110,9 +112,9 @@ dbind_method_call_reentrant_va (DBusConnection *cnx,
     if (p[0] == '=' && p[1] == '>')
     {
         DBusMessageIter iter;
-        p += 2;
         dbus_message_iter_init (reply, &iter);
-        dbind_any_demarshal_va (&iter, &p, &args);
+        p = arg_types;
+        dbind_any_demarshal_va (&iter, &p, args_demarshal);
     }
 
     success = TRUE;
@@ -126,6 +128,7 @@ out:
     if (err == &real_err)
         dbus_error_free (err);
 
+    va_end (args_demarshal);
     return success;
 }
 
@@ -203,7 +206,7 @@ dbind_emit_signal_va (DBusConnection *cnx,
 
     p = arg_types;
     dbus_message_iter_init_append (msg, &iter);
-    dbind_any_marshal_va (&iter, &p, &args);
+    dbind_any_marshal_va (&iter, &p, args);
 
     if (!dbus_connection_send (cnx, msg, NULL))
        goto out;