Reformat all the *.[ch] files with clang-format

I ran this on each directory with C files:

  clang-format -i *.[ch]

"-i" is the in-place option.

I also adjusted the order of #includes for some files which failed to
build after that:

Clang-format reorders blocks of #include directives alphabetically,
but they can be grouped and separated by blank lines.  If there is a
blank line between blocks, like

  #include "zork.h"

  #include "bar.h"
  #include "foo.h"

then it will not put zork.h after the other two.  The last two header
files will be sorted alphabetically.

We can adjust the formatting of chunks of code by hand with comments
like these:

  /* clang-format off */

     this code {
       is, formatted, by, hand;
     }

  /* clang-format on */

See https://clang.llvm.org/docs/ClangFormat.html for the general
manual and https://clang.llvm.org/docs/ClangFormatStyleOptions.html
for the style options and the comments described above.

5 files changed, 832 insertions, 781 deletions

diff --git a/dbind/dbind-any.c b/dbind/dbind-any.c
index 512c1b34..bcbe3911 100644
--- a/dbind/dbind-any.c
+++ b/dbind/dbind-any.c
@@ -18,8 +18,8 @@
  */
 
 /* type driven marshalling */
-#include <stdio.h>
 #include <glib.h>
+#include <stdio.h>
 
 #include "config.h"
 #include "dbind-any.h"
@@ -34,32 +34,32 @@
  *    ~(boundary - 1)
  */
 #define ALIGN_VALUE(this, boundary) \
-  (( ((gulong)(this)) + (((gulong)(boundary)) -1)) & (~(((gulong)(boundary))-1)))
+  ((((gulong) (this)) + (((gulong) (boundary)) - 1)) & (~(((gulong) (boundary)) - 1)))
 
 #define ALIGN_ADDRESS(this, boundary) \
-  ((gpointer)ALIGN_VALUE(this, boundary))
+  ((gpointer) ALIGN_VALUE (this, boundary))
 
 #define PTR_PLUS(ptr, offset) \
-        ((gpointer) (((guchar *)(ptr)) + (offset)))
-
-#define DBIND_POD_CASES \
-         DBUS_TYPE_BYTE: \
-    case DBUS_TYPE_INT16: \
-    case DBUS_TYPE_UINT16: \
-    case DBUS_TYPE_INT32: \
-    case DBUS_TYPE_UINT32: \
-    case DBUS_TYPE_BOOLEAN: \
-    case DBUS_TYPE_INT64: \
-    case DBUS_TYPE_UINT64: \
-    case DBUS_TYPE_DOUBLE
+  ((gpointer) (((guchar *) (ptr)) + (offset)))
+
+#define DBIND_POD_CASES   \
+  DBUS_TYPE_BYTE:         \
+  case DBUS_TYPE_INT16:   \
+  case DBUS_TYPE_UINT16:  \
+  case DBUS_TYPE_INT32:   \
+  case DBUS_TYPE_UINT32:  \
+  case DBUS_TYPE_BOOLEAN: \
+  case DBUS_TYPE_INT64:   \
+  case DBUS_TYPE_UINT64:  \
+  case DBUS_TYPE_DOUBLE
 
 /*---------------------------------------------------------------------------*/
 
 static void
 warn_braces ()
 {
-    fprintf (stderr, "Error: dbus flags structures & dicts with braces rather than "
-             " an explicit type member of 'struct'\n");
+  fprintf (stderr, "Error: dbus flags structures & dicts with braces rather than "
+                   " an explicit type member of 'struct'\n");
 }
 
 /*---------------------------------------------------------------------------*/
@@ -67,68 +67,71 @@ warn_braces ()
 static unsigned int
 dbind_find_c_alignment_r (const char **type)
 {
-    unsigned int retval = 1;
+  unsigned int retval = 1;
 
-    char t = **type;
-    (*type)++;
+  char t = **type;
+  (*type)++;
 
 #ifdef DEBUG
-    fprintf (stderr, "\tfind align for %c (0x%x)\n", t, t);
+  fprintf (stderr, "\tfind align for %c (0x%x)\n", t, t);
 #endif
 
-        switch (t) {
+  switch (t)
+    {
     case DBUS_TYPE_BYTE:
-        return ALIGNOF_CHAR;
+      return ALIGNOF_CHAR;
     case DBUS_TYPE_BOOLEAN:
-        return ALIGNOF_DBUS_BOOL_T;
+      return ALIGNOF_DBUS_BOOL_T;
     case DBUS_TYPE_INT16:
     case DBUS_TYPE_UINT16:
-        return ALIGNOF_DBUS_INT16_T;
+      return ALIGNOF_DBUS_INT16_T;
     case DBUS_TYPE_INT32:
     case DBUS_TYPE_UINT32:
-        return ALIGNOF_DBUS_INT32_T;
+      return ALIGNOF_DBUS_INT32_T;
     case DBUS_TYPE_INT64:
     case DBUS_TYPE_UINT64:
-        return ALIGNOF_DBUS_INT64_T;
+      return ALIGNOF_DBUS_INT64_T;
     case DBUS_TYPE_DOUBLE:
-        return ALIGNOF_DOUBLE;
+      return ALIGNOF_DOUBLE;
     /* ptr types */
     case DBUS_TYPE_STRING:
     case DBUS_TYPE_OBJECT_PATH:
     case DBUS_TYPE_SIGNATURE:
     case DBUS_TYPE_ARRAY:
-        return ALIGNOF_DBIND_POINTER;
+      return ALIGNOF_DBIND_POINTER;
     case DBUS_STRUCT_BEGIN_CHAR:
       /* TODO: I think this would break with a nested struct */
 #if ALIGNOF_DBIND_STRUCT > 1
-                retval = MAX (retval, ALIGNOF_DBIND_STRUCT);
+      retval = MAX (retval, ALIGNOF_DBIND_STRUCT);
 #endif
-        while (**type != DBUS_STRUCT_END_CHAR) {
-            int elem_align = dbind_find_c_alignment_r (type);
-                        retval = MAX (retval, elem_align);
+      while (**type != DBUS_STRUCT_END_CHAR)
+        {
+          int elem_align = dbind_find_c_alignment_r (type);
+          retval = MAX (retval, elem_align);
         }
-        (*type)++;
-        return retval;
+      (*type)++;
+      return retval;
     case DBUS_DICT_ENTRY_BEGIN_CHAR:
 #if ALIGNOF_DBIND_STRUCT > 1
-                retval = MAX (retval, ALIGNOF_DBIND_STRUCT);
+      retval = MAX (retval, ALIGNOF_DBIND_STRUCT);
 #endif
-        while (**type != DBUS_DICT_ENTRY_END_CHAR) {
-            int elem_align = dbind_find_c_alignment_r (type);
-                        retval = MAX (retval, elem_align);
+      while (**type != DBUS_DICT_ENTRY_END_CHAR)
+        {
+          int elem_align = dbind_find_c_alignment_r (type);
+          retval = MAX (retval, elem_align);
         }
-        (*type)++;
-        return retval;
+      (*type)++;
+      return retval;
     case DBUS_TYPE_STRUCT:
     case DBUS_TYPE_DICT_ENTRY:
-        warn_braces ();
-        return ALIGNOF_DBIND_POINTER;
+      warn_braces ();
+      return ALIGNOF_DBIND_POINTER;
     case '\0':
-        g_assert_not_reached();
-        break;
+      g_assert_not_reached ();
+      break;
     default:
-                return 1;
-  }
+      return 1;
+    }
 }
 
 /*---------------------------------------------------------------------------*/
@@ -143,82 +146,91 @@ dbind_gather_alloc_info_r (const char **type)
     {
       switch (**type)
         {
-          case DBUS_STRUCT_BEGIN_CHAR:
-              while (**type != DBUS_STRUCT_END_CHAR && **type != '\0') (*type)++;
-              if (**type != '\0') (*type)++;
-              break;
-          case DBUS_DICT_ENTRY_BEGIN_CHAR:
-              while (**type != DBUS_DICT_ENTRY_END_CHAR && **type != '\0') (*type)++;
-              if (**type != '\0') (*type)++;
-              break;
-          case '\0':
-              break;
-          default:
-              (*type)++;
-              break;
+        case DBUS_STRUCT_BEGIN_CHAR:
+          while (**type != DBUS_STRUCT_END_CHAR && **type != '\0')
+            (*type)++;
+          if (**type != '\0')
+            (*type)++;
+          break;
+        case DBUS_DICT_ENTRY_BEGIN_CHAR:
+          while (**type != DBUS_DICT_ENTRY_END_CHAR && **type != '\0')
+            (*type)++;
+          if (**type != '\0')
+            (*type)++;
+          break;
+        case '\0':
+          break;
+        default:
+          (*type)++;
+          break;
         }
     }
 
-  switch (t) {
+  switch (t)
+    {
     case DBUS_TYPE_BYTE:
-        return sizeof (char);
+      return sizeof (char);
     case DBUS_TYPE_BOOLEAN:
-        return sizeof (dbus_bool_t);
+      return sizeof (dbus_bool_t);
     case DBUS_TYPE_INT16:
     case DBUS_TYPE_UINT16:
-        return sizeof (dbus_int16_t);
+      return sizeof (dbus_int16_t);
     case DBUS_TYPE_INT32:
     case DBUS_TYPE_UINT32:
-        return sizeof (dbus_int32_t);
+      return sizeof (dbus_int32_t);
     case DBUS_TYPE_INT64:
     case DBUS_TYPE_UINT64:
-        return sizeof (dbus_int64_t);
+      return sizeof (dbus_int64_t);
     case DBUS_TYPE_DOUBLE:
-        return sizeof (double);
+      return sizeof (double);
     /* ptr types */
     case DBUS_TYPE_STRING:
     case DBUS_TYPE_OBJECT_PATH:
     case DBUS_TYPE_SIGNATURE:
     case DBUS_TYPE_ARRAY:
-        return sizeof (void *);
-    case DBUS_STRUCT_BEGIN_CHAR: {
-                int sum = 0, stralign;
+      return sizeof (void *);
+    case DBUS_STRUCT_BEGIN_CHAR:
+      {
+        int sum = 0, stralign;
 
         stralign = dbind_find_c_alignment (*type - 1);
 
-        while (**type != DBUS_STRUCT_END_CHAR) {
-                        sum = ALIGN_VALUE (sum, dbind_find_c_alignment (*type));
-                        sum += dbind_gather_alloc_info_r (type);
-        }
-                sum = ALIGN_VALUE (sum, stralign);
+        while (**type != DBUS_STRUCT_END_CHAR)
+          {
+            sum = ALIGN_VALUE (sum, dbind_find_c_alignment (*type));
+            sum += dbind_gather_alloc_info_r (type);
+          }
+        sum = ALIGN_VALUE (sum, stralign);
 
         g_assert (**type == DBUS_STRUCT_END_CHAR);
         (*type)++;
 
-                return sum;
-    }
-    case DBUS_DICT_ENTRY_BEGIN_CHAR: {
-                int sum = 0, stralign;
+        return sum;
+      }
+    case DBUS_DICT_ENTRY_BEGIN_CHAR:
+      {
+        int sum = 0, stralign;
 
         stralign = dbind_find_c_alignment (*type - 1);
 
-        while (**type != DBUS_DICT_ENTRY_END_CHAR) {
-                        sum = ALIGN_VALUE (sum, dbind_find_c_alignment (*type));
-                        sum += dbind_gather_alloc_info_r (type);
-        }
-                sum = ALIGN_VALUE (sum, stralign);
+        while (**type != DBUS_DICT_ENTRY_END_CHAR)
+          {
+            sum = ALIGN_VALUE (sum, dbind_find_c_alignment (*type));
+            sum += dbind_gather_alloc_info_r (type);
+          }
+        sum = ALIGN_VALUE (sum, stralign);
 
         g_assert (**type == DBUS_DICT_ENTRY_END_CHAR);
         (*type)++;
 
-                return sum;
-    }
+        return sum;
+      }
     case DBUS_TYPE_STRUCT:
     case DBUS_TYPE_DICT_ENTRY:
-        warn_braces ();
+      warn_braces ();
     default:
-        return 0;
-  }
+      return 0;
+    }
 }
 
 static size_t
@@ -233,27 +245,29 @@ static void
 dbind_any_free_r (const char **type, void **data)
 {
 #ifdef DEBUG
-    fprintf (stderr, "any free '%c' to %p\n", **type, *data);
+  fprintf (stderr, "any free '%c' to %p\n", **type, *data);
 #endif
 
-    switch (**type) {
+  switch (**type)
+    {
     case DBIND_POD_CASES:
-        *data = ((guchar *)*data) + dbind_gather_alloc_info (*type);
-        (*type)++;
-        break;
+      *data = ((guchar *) *data) + dbind_gather_alloc_info (*type);
+      (*type)++;
+      break;
     case DBUS_TYPE_STRING:
     case DBUS_TYPE_OBJECT_PATH:
     case DBUS_TYPE_SIGNATURE:
 #ifdef DEBUG
-        fprintf (stderr, "string free %p\n", **(void ***)data);
+      fprintf (stderr, "string free %p\n", **(void ***) data);
 #endif
-        g_free (**(void ***)data);
-        *data = ((guchar *)*data) + dbind_gather_alloc_info (*type);
-        (*type)++;
-        break;
-    case DBUS_TYPE_ARRAY: {
+      g_free (**(void ***) data);
+      *data = ((guchar *) *data) + dbind_gather_alloc_info (*type);
+      (*type)++;
+      break;
+    case DBUS_TYPE_ARRAY:
+      {
         int i;
-        GArray *vals = **(void ***)data;
+        GArray *vals = **(void ***) data;
         size_t elem_size, elem_align;
         const char *saved_child_type;
 
@@ -261,69 +275,74 @@ dbind_any_free_r (const char **type, void **data)
         saved_child_type = *type;
 
         elem_size = dbind_gather_alloc_info (*type);
-        elem_align = dbind_find_c_alignment_r (type); 
+        elem_align = dbind_find_c_alignment_r (type);
 
-        for (i = 0; i < vals->len; i++) {
+        for (i = 0; i < vals->len; i++)
+          {
             void *ptr = vals->data + elem_size * i;
             *type = saved_child_type; /* rewind type info */
             ptr = ALIGN_ADDRESS (ptr, elem_align);
             dbind_any_free_r (type, &ptr);
-        }
+          }
         g_array_free (vals, TRUE);
         break;
-    }
-    case DBUS_STRUCT_BEGIN_CHAR: {
-                gconstpointer data0 = *data;
-                int offset = 0, stralign;
+      }
+    case DBUS_STRUCT_BEGIN_CHAR:
+      {
+        gconstpointer data0 = *data;
+        int offset = 0, stralign;
 
         stralign = dbind_find_c_alignment (*type);
         (*type)++;
 
-        offset = 0 ;
-        while (**type != DBUS_STRUCT_END_CHAR) {
+        offset = 0;
+        while (**type != DBUS_STRUCT_END_CHAR)
+          {
             const char *subt = *type;
-                        offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
-                        *data = PTR_PLUS (data0, offset);
+            offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+            *data = PTR_PLUS (data0, offset);
             dbind_any_free_r (type, data);
             offset += dbind_gather_alloc_info (subt);
-        }
+          }
 
-                offset = ALIGN_VALUE (offset, stralign);
-                *data = PTR_PLUS (data0, offset);
+        offset = ALIGN_VALUE (offset, stralign);
+        *data = PTR_PLUS (data0, offset);
 
         g_assert (**type == DBUS_STRUCT_END_CHAR);
         (*type)++;
 
         break;
-    }
-    case DBUS_DICT_ENTRY_BEGIN_CHAR: {
-                gconstpointer data0 = *data;
-                int offset = 0, stralign;
+      }
+    case DBUS_DICT_ENTRY_BEGIN_CHAR:
+      {
+        gconstpointer data0 = *data;
+        int offset = 0, stralign;
 
         stralign = dbind_find_c_alignment (*type);
         (*type)++;
 
-        offset = 0 ;
-        while (**type != DBUS_DICT_ENTRY_END_CHAR) {
+        offset = 0;
+        while (**type != DBUS_DICT_ENTRY_END_CHAR)
+          {
             const char *subt = *type;
-                        offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
-                        *data = PTR_PLUS (data0, offset);
+            offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+            *data = PTR_PLUS (data0, offset);
             dbind_any_free_r (type, data);
             offset += dbind_gather_alloc_info (subt);
-        }
+          }
 
-                offset = ALIGN_VALUE (offset, stralign);
-                *data = PTR_PLUS (data0, offset);
+        offset = ALIGN_VALUE (offset, stralign);
+        *data = PTR_PLUS (data0, offset);
 
         g_assert (**type == DBUS_DICT_ENTRY_END_CHAR);
         (*type)++;
 
         break;
-    }
+      }
     case DBUS_TYPE_STRUCT:
     case DBUS_TYPE_DICT_ENTRY:
-        warn_braces ();
-        break;
+      warn_braces ();
+      break;
     }
 }
 
@@ -331,28 +350,30 @@ dbind_any_free_r (const char **type, void **data)
 
 void
 dbind_any_marshal (DBusMessageIter *iter,
-                   const char           **type,
-                   void           **data)
+                   const char **type,
+                   void **data)
 {
-    size_t len;
+  size_t len;
 
 #ifdef DEBUG
-    fprintf (stderr, "any marshal '%c' to %p\n", **type, *data);
+  fprintf (stderr, "any marshal '%c' to %p\n", **type, *data);
 #endif
 
-    switch (**type) {
+  switch (**type)
+    {
     case DBIND_POD_CASES:
     case DBUS_TYPE_STRING:
     case DBUS_TYPE_OBJECT_PATH:
     case DBUS_TYPE_SIGNATURE:
-        len = dbind_gather_alloc_info (*type);
-        dbus_message_iter_append_basic (iter, **type, *data);
-        *data = ((guchar *)*data) + len;
-        (*type)++;
-        break;
-    case DBUS_TYPE_ARRAY: {
+      len = dbind_gather_alloc_info (*type);
+      dbus_message_iter_append_basic (iter, **type, *data);
+      *data = ((guchar *) *data) + len;
+      (*type)++;
+      break;
+    case DBUS_TYPE_ARRAY:
+      {
         int i;
-        GArray *vals = **(void ***)data;
+        GArray *vals = **(void ***) data;
         size_t elem_size, elem_align;
         DBusMessageIter sub;
         const char *saved_child_type;
@@ -362,27 +383,29 @@ dbind_any_marshal (DBusMessageIter *iter,
         saved_child_type = *type;
 
         elem_size = dbind_gather_alloc_info (*type);
-        elem_align = dbind_find_c_alignment_r (type); 
+        elem_align = dbind_find_c_alignment_r (type);
 
         /* wow this part of the API sucks too ... */
         child_type_string = g_strndup (saved_child_type, *type - saved_child_type);
         /* fprintf (stderr, "array child type '%s'\n", child_type_string); */
         dbus_message_iter_open_container (iter, DBUS_TYPE_ARRAY,
                                           child_type_string, &sub);
-        for (i = 0; i < vals->len; i++) {
+        for (i = 0; i < vals->len; i++)
+          {
             void *ptr = vals->data + elem_size * i;
             *type = saved_child_type; /* rewind type info */
             ptr = ALIGN_ADDRESS (ptr, elem_align);
             dbind_any_marshal (&sub, type, &ptr);
-        }
+          }
 
         dbus_message_iter_close_container (iter, &sub);
         g_free (child_type_string);
         break;
-    }
-    case DBUS_STRUCT_BEGIN_CHAR: {
-                gconstpointer data0 = *data;
-                int offset = 0, stralign;
+      }
+    case DBUS_STRUCT_BEGIN_CHAR:
+      {
+        gconstpointer data0 = *data;
+        int offset = 0, stralign;
         DBusMessageIter sub;
 
         stralign = dbind_find_c_alignment (*type);
@@ -391,17 +414,18 @@ dbind_any_marshal (DBusMessageIter *iter,
 
         dbus_message_iter_open_container (iter, DBUS_TYPE_STRUCT, NULL, &sub);
 
-        offset = 0 ;
-        while (**type != DBUS_STRUCT_END_CHAR) {
+        offset = 0;
+        while (**type != DBUS_STRUCT_END_CHAR)
+          {
             const char *subt = *type;
-                        offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
-                        *data = PTR_PLUS (data0, offset);
+            offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+            *data = PTR_PLUS (data0, offset);
             dbind_any_marshal (&sub, type, data);
             offset += dbind_gather_alloc_info (subt);
-        }
+          }
 
-                offset = ALIGN_VALUE (offset, stralign);
-                *data = PTR_PLUS (data0, offset);
+        offset = ALIGN_VALUE (offset, stralign);
+        *data = PTR_PLUS (data0, offset);
 
         dbus_message_iter_close_container (iter, &sub);
 
@@ -409,10 +433,11 @@ dbind_any_marshal (DBusMessageIter *iter,
         (*type)++;
 
         break;
-    }
-    case DBUS_DICT_ENTRY_BEGIN_CHAR: {
-                gconstpointer data0 = *data;
-                int offset = 0, stralign;
+      }
+    case DBUS_DICT_ENTRY_BEGIN_CHAR:
+      {
+        gconstpointer data0 = *data;
+        int offset = 0, stralign;
         DBusMessageIter sub;
 
         stralign = dbind_find_c_alignment (*type);
@@ -421,17 +446,18 @@ dbind_any_marshal (DBusMessageIter *iter,
 
         dbus_message_iter_open_container (iter, DBUS_TYPE_DICT_ENTRY, NULL, &sub);
 
-        offset = 0 ;
-        while (**type != DBUS_DICT_ENTRY_END_CHAR) {
+        offset = 0;
+        while (**type != DBUS_DICT_ENTRY_END_CHAR)
+          {
             const char *subt = *type;
-                        offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
-                        *data = PTR_PLUS (data0, offset);
+            offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+            *data = PTR_PLUS (data0, offset);
             dbind_any_marshal (&sub, type, data);
             offset += dbind_gather_alloc_info (subt);
-        }
+          }
 
-                offset = ALIGN_VALUE (offset, stralign);
-                *data = PTR_PLUS (data0, offset);
+        offset = ALIGN_VALUE (offset, stralign);
+        *data = PTR_PLUS (data0, offset);
 
         dbus_message_iter_close_container (iter, &sub);
 
@@ -439,11 +465,11 @@ dbind_any_marshal (DBusMessageIter *iter,
         (*type)++;
 
         break;
-    }
+      }
     case DBUS_TYPE_STRUCT:
     case DBUS_TYPE_DICT_ENTRY:
-        warn_braces ();
-        break;
+      warn_braces ();
+      break;
     }
 }
 
@@ -451,113 +477,117 @@ dbind_any_marshal (DBusMessageIter *iter,
 
 void
 dbind_any_marshal_va (DBusMessageIter *iter,
-                      const char           **arg_types,
-                      va_list          args)
+                      const char **arg_types,
+                      va_list args)
 {
-    const char *p = *arg_types;
+  const char *p = *arg_types;
 
-    /* Guard against null arg types 
-       Fix for - http://bugs.freedesktop.org/show_bug.cgi?id=23027
-     */
-    if (p == NULL)
-        p = "";
+  /* Guard against null arg types
+     Fix for - http://bugs.freedesktop.org/show_bug.cgi?id=23027
+   */
+  if (p == NULL)
+    p = "";
 
-    {
-        /* special case base-types since we need to walk the stack worse-luck */
-        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);
-                arg = &intarg;
-                break;
-            case DBUS_TYPE_INT64:
-            case DBUS_TYPE_UINT64:
-                int64arg = va_arg (args, dbus_int64_t);
-                arg = &int64arg;
-                break;
-            case DBUS_TYPE_DOUBLE:
-                doublearg = va_arg (args, double);
-                arg = &doublearg;
-                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 *);
-                arg = &ptrarg;
-                break;
-            case DBUS_STRUCT_BEGIN_CHAR:
-                ptrarg = va_arg (args, void *);
-                arg = ptrarg;
-                break;
-            case DBUS_DICT_ENTRY_BEGIN_CHAR:
-                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 *);
-                arg = &ptrarg;
-                break;
-            default:
-                fprintf (stderr, "Unknown / invalid arg type %c\n", *p);
-                break;
-            }
-            if (arg != NULL)
-                dbind_any_marshal (iter, &p, &arg);
-            }
-        if (*arg_types)
-          *arg_types = p;
-    }
+  {
+    /* special case base-types since we need to walk the stack worse-luck */
+    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);
+            arg = &intarg;
+            break;
+          case DBUS_TYPE_INT64:
+          case DBUS_TYPE_UINT64:
+            int64arg = va_arg (args, dbus_int64_t);
+            arg = &int64arg;
+            break;
+          case DBUS_TYPE_DOUBLE:
+            doublearg = va_arg (args, double);
+            arg = &doublearg;
+            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 *);
+            arg = &ptrarg;
+            break;
+          case DBUS_STRUCT_BEGIN_CHAR:
+            ptrarg = va_arg (args, void *);
+            arg = ptrarg;
+            break;
+          case DBUS_DICT_ENTRY_BEGIN_CHAR:
+            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 *);
+            arg = &ptrarg;
+            break;
+          default:
+            fprintf (stderr, "Unknown / invalid arg type %c\n", *p);
+            break;
+          }
+        if (arg != NULL)
+          dbind_any_marshal (iter, &p, &arg);
+      }
+    if (*arg_types)
+      *arg_types = p;
+  }
 }
 
 /*---------------------------------------------------------------------------*/
 
 void
 dbind_any_demarshal (DBusMessageIter *iter,
-                     const char           **type,
-                     void           **data)
+                     const char **type,
+                     void **data)
 {
-    size_t len;
+  size_t len;
 
 #ifdef DEBUG
-    fprintf (stderr, "any demarshal '%c' to %p\n", **type, *data);
+  fprintf (stderr, "any demarshal '%c' to %p\n", **type, *data);
 #endif
 
-    switch (**type) {
+  switch (**type)
+    {
     case DBIND_POD_CASES:
-        len = dbind_gather_alloc_info (*type);
-        dbus_message_iter_get_basic (iter, *data);
-        *data = ((guchar *)*data) + len;
-        (*type)++;
-        break;
+      len = dbind_gather_alloc_info (*type);
+      dbus_message_iter_get_basic (iter, *data);
+      *data = ((guchar *) *data) + len;
+      (*type)++;
+      break;
     case DBUS_TYPE_STRING:
     case DBUS_TYPE_OBJECT_PATH:
     case DBUS_TYPE_SIGNATURE:
-        len = dbind_gather_alloc_info (*type);
-        dbus_message_iter_get_basic (iter, *data);
+      len = dbind_gather_alloc_info (*type);
+      dbus_message_iter_get_basic (iter, *data);
 #ifdef DEBUG
-        fprintf (stderr, "dup string '%s' (%p)\n", **(void ***)data, **(void ***)data);
+      fprintf (stderr, "dup string '%s' (%p)\n", **(void ***) data, **(void ***) data);
 #endif
-        **(void ***)data = g_strdup (**(void ***)data);
-        *data = ((guchar *)*data) + len;
-        (*type)++;
-        break;
-    case DBUS_TYPE_ARRAY: {
+      **(void ***) data = g_strdup (**(void ***) data);
+      *data = ((guchar *) *data) + len;
+      (*type)++;
+      break;
+    case DBUS_TYPE_ARRAY:
+      {
         GArray *vals;
         DBusMessageIter child;
         size_t elem_size, elem_align;
@@ -570,12 +600,13 @@ dbind_any_demarshal (DBusMessageIter *iter,
         elem_size = dbind_gather_alloc_info (*type);
         elem_align = dbind_find_c_alignment_r (type);
         vals = g_array_new (FALSE, FALSE, elem_size);
-        (**(void ***)data) = vals;
-        *data = ((guchar *)*data) + sizeof (void *);
+        (**(void ***) data) = vals;
+        *data = ((guchar *) *data) + sizeof (void *);
 
         i = 0;
         dbus_message_iter_recurse (iter, &child);
-        while (dbus_message_iter_get_arg_type (&child) != DBUS_TYPE_INVALID) {
+        while (dbus_message_iter_get_arg_type (&child) != DBUS_TYPE_INVALID)
+          {
             void *ptr;
             const char *subt = stored_child_type;
             g_array_set_size (vals, i + 1);
@@ -583,12 +614,13 @@ dbind_any_demarshal (DBusMessageIter *iter,
             ptr = ALIGN_ADDRESS (ptr, elem_align);
             dbind_any_demarshal (&child, &subt, &ptr);
             i++;
-        };
+          };
         break;
-    }
-    case DBUS_STRUCT_BEGIN_CHAR: {
-                gconstpointer data0 = *data;
-                int offset = 0, stralign;
+      }
+    case DBUS_STRUCT_BEGIN_CHAR:
+      {
+        gconstpointer data0 = *data;
+        int offset = 0, stralign;
         DBusMessageIter child;
 
         stralign = dbind_find_c_alignment (*type);
@@ -597,25 +629,27 @@ dbind_any_demarshal (DBusMessageIter *iter,
 
         dbus_message_iter_recurse (iter, &child);
 
-        while (**type != DBUS_STRUCT_END_CHAR) {
+        while (**type != DBUS_STRUCT_END_CHAR)
+          {
             const char *subt = *type;
-                        offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
-                        *data = PTR_PLUS (data0, offset);
+            offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+            *data = PTR_PLUS (data0, offset);
             dbind_any_demarshal (&child, type, data);
             offset += dbind_gather_alloc_info (subt);
-        }
+          }
 
-                offset = ALIGN_VALUE (offset, stralign);
-                *data = PTR_PLUS (data0, offset);
+        offset = ALIGN_VALUE (offset, stralign);
+        *data = PTR_PLUS (data0, offset);
 
         g_assert (**type == DBUS_STRUCT_END_CHAR);
         (*type)++;
 
         break;
-    }
-    case DBUS_DICT_ENTRY_BEGIN_CHAR: {
-                gconstpointer data0 = *data;
-                int offset = 0, stralign;
+      }
+    case DBUS_DICT_ENTRY_BEGIN_CHAR:
+      {
+        gconstpointer data0 = *data;
+        int offset = 0, stralign;
         DBusMessageIter child;
 
         stralign = dbind_find_c_alignment (*type);
@@ -624,32 +658,33 @@ dbind_any_demarshal (DBusMessageIter *iter,
 
         dbus_message_iter_recurse (iter, &child);
 
-        while (**type != DBUS_DICT_ENTRY_END_CHAR) {
+        while (**type != DBUS_DICT_ENTRY_END_CHAR)
+          {
             const char *subt = *type;
-                        offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
-                        *data = PTR_PLUS (data0, offset);
+            offset = ALIGN_VALUE (offset, dbind_find_c_alignment (*type));
+            *data = PTR_PLUS (data0, offset);
             dbind_any_demarshal (&child, type, data);
             offset += dbind_gather_alloc_info (subt);
-        }
+          }
 
-                offset = ALIGN_VALUE (offset, stralign);
-                *data = PTR_PLUS (data0, offset);
+        offset = ALIGN_VALUE (offset, stralign);
+        *data = PTR_PLUS (data0, offset);
 
         g_assert (**type == DBUS_DICT_ENTRY_END_CHAR);
         (*type)++;
 
         break;
-    case DBUS_TYPE_VARIANT:
+      case DBUS_TYPE_VARIANT:
         /* skip; unimplemented for now */
         (*type)++;
         break;
-    }
+      }
     case DBUS_TYPE_STRUCT:
     case DBUS_TYPE_DICT_ENTRY:
-        warn_braces ();
-        break;
+      warn_braces ();
+      break;
     }
-    dbus_message_iter_next (iter);
+  dbus_message_iter_next (iter);
 }
 
 static const char *
@@ -659,13 +694,13 @@ pass_complex_arg (const char *p, char begin, char end)
 
   p++;
   while (*p && level > 0)
-  {
-    if (*p == begin)
-      level++;
-    else if (*p == end)
-      level--;
-    p++;
-  }
+    {
+      if (*p == begin)
+        level++;
+      else if (*p == end)
+        level--;
+      p++;
+    }
   if (*p == end)
     p++;
   return p;
@@ -675,77 +710,80 @@ static const char *
 pass_arg (const char *p)
 {
   switch (*p)
-  {
-  case '(':
-    return pass_complex_arg (p, '(', ')');
-  case '{':
-    return pass_complex_arg (p, '{', '}');
-  case 'a':
-    return pass_arg (p+1);
-  default:
-    return p + 1;
-  }
+    {
+    case '(':
+      return pass_complex_arg (p, '(', ')');
+    case '{':
+      return pass_complex_arg (p, '{', '}');
+    case 'a':
+      return pass_arg (p + 1);
+    default:
+      return p + 1;
+    }
 }
 
 /*---------------------------------------------------------------------------*/
 
 void
 dbind_any_demarshal_va (DBusMessageIter *iter,
-                        const char           **arg_types,
-                        va_list          args)
+                        const char **arg_types,
+                        va_list args)
 {
-    const char *p = *arg_types;
+  const char *p = *arg_types;
 
-    /* Just consume the in args without doing anything to them */
-    for (;*p != '\0' && *p != '=';) {
-        switch (*p) {
+  /* Just consume the in args without doing anything to them */
+  for (; *p != '\0' && *p != '=';)
+    {
+      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:
-            va_arg (args, int);
-            break;
+          va_arg (args, int);
+          break;
         case DBUS_TYPE_INT64:
         case DBUS_TYPE_UINT64:
-            va_arg (args, dbus_int64_t);
-            break;
+          va_arg (args, dbus_int64_t);
+          break;
         case DBUS_TYPE_DOUBLE:
-            va_arg (args, double);
-            break;
+          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:
-            va_arg (args, void *);
-            break;
+          va_arg (args, void *);
+          break;
         case DBUS_STRUCT_BEGIN_CHAR:
-            va_arg (args, void *);
-            break;
+          va_arg (args, void *);
+          break;
         case DBUS_DICT_ENTRY_BEGIN_CHAR:
-            va_arg (args, void *);
-            break;
+          va_arg (args, void *);
+          break;
 
         case DBUS_TYPE_VARIANT:
-            fprintf (stderr, "No variant support yet - very toolkit specific\n");
-            va_arg (args, void *);
-            break;
+          fprintf (stderr, "No variant support yet - very toolkit specific\n");
+          va_arg (args, void *);
+          break;
         default:
-            fprintf (stderr, "Unknown / invalid arg type %c\n", *p);
-            break;
+          fprintf (stderr, "Unknown / invalid arg type %c\n", *p);
+          break;
         }
       p = pass_arg (p);
     }
 
-    if (p [0] == '=' && p[1] == '>')
-      p += 2;
+  if (p[0] == '=' && p[1] == '>')
+    p += 2;
 
-    for (;*p != '\0';) {
-        void *arg = va_arg (args, void *);
-        dbind_any_demarshal (iter, &p, &arg);
+  for (; *p != '\0';)
+    {
+      void *arg = va_arg (args, void *);
+      dbind_any_demarshal (iter, &p, &arg);
     }
 }
 
@@ -756,14 +794,14 @@ void
 dbind_any_free (const char *type,
                 void *ptr)
 {
-    dbind_any_free_r (&type, &ptr);
+  dbind_any_free_r (&type, &ptr);
 }
 
 /* should this be the default normalization ? */
 void
 dbind_any_free_ptr (const char *type, void *ptr)
 {
-    dbind_any_free (type, &ptr);
+  dbind_any_free (type, &ptr);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -771,7 +809,7 @@ dbind_any_free_ptr (const char *type, void *ptr)
 unsigned int
 dbind_find_c_alignment (const char *type)
 {
-    return dbind_find_c_alignment_r (&type);
+  return dbind_find_c_alignment_r (&type);
 }
 
 /*END------------------------------------------------------------------------*/
diff --git a/dbind/dbind-any.h b/dbind/dbind-any.h
index 859c8953..f13539bd 100644
--- a/dbind/dbind-any.h
+++ b/dbind/dbind-any.h
@@ -25,26 +25,26 @@
 
 unsigned int dbind_find_c_alignment (const char *type);
 
-void   dbind_any_marshal       (DBusMessageIter *iter,
-                                const char           **type,
-                                void           **val);
+void dbind_any_marshal (DBusMessageIter *iter,
+                        const char **type,
+                        void **val);
 
-void   dbind_any_marshal_va    (DBusMessageIter *iter,
-                                const char           **arg_types,
-                                va_list          args);
+void dbind_any_marshal_va (DBusMessageIter *iter,
+                           const char **arg_types,
+                           va_list args);
 
-void   dbind_any_demarshal     (DBusMessageIter *iter,
-                                const char           **type,
-                                void           **val);
+void dbind_any_demarshal (DBusMessageIter *iter,
+                          const char **type,
+                          void **val);
 
-void   dbind_any_demarshal_va  (DBusMessageIter *iter,
-                                const char           **arg_types,
-                                va_list          args);
+void dbind_any_demarshal_va (DBusMessageIter *iter,
+                             const char **arg_types,
+                             va_list args);
 
-void   dbind_any_free          (const char      *type,
-                                void            *ptr_to_ptr);
+void dbind_any_free (const char *type,
+                     void *ptr_to_ptr);
 
-void   dbind_any_free_ptr      (const char      *type,
-                                void            *ptr);
+void dbind_any_free_ptr (const char *type,
+                         void *ptr);
 
 #endif /* _DBIND_ANY_H_ */
diff --git a/dbind/dbind.c b/dbind/dbind.c
index e154f857..8c6c65d7 100644
--- a/dbind/dbind.c
+++ b/dbind/dbind.c
@@ -17,15 +17,15 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <stdio.h>
+#include <glib.h>
 #include <stdarg.h>
-#include <sys/time.h>
+#include <stdio.h>
 #include <string.h>
-#include <glib.h>
+#include <sys/time.h>
 
+#include "atspi/atspi-gmain.h"
 #include "config.h"
 #include "dbind/dbind.h"
-#include "atspi/atspi-gmain.h"
 
 static int dbind_timeout = -1;
 
@@ -36,15 +36,15 @@ static int dbind_timeout = -1;
 
 /*---------------------------------------------------------------------------*/
 
-typedef struct _SpiReentrantCallClosure 
+typedef struct _SpiReentrantCallClosure
 {
   DBusMessage *reply;
 } SpiReentrantCallClosure;
 
 static void
-set_reply (DBusPendingCall * pending, void *user_data)
+set_reply (DBusPendingCall *pending, void *user_data)
 {
-  SpiReentrantCallClosure* closure = (SpiReentrantCallClosure *) user_data; 
+  SpiReentrantCallClosure *closure = (SpiReentrantCallClosure *) user_data;
 
   closure->reply = dbus_pending_call_steal_reply (pending);
   dbus_pending_call_unref (pending);
@@ -60,7 +60,7 @@ time_elapsed (struct timeval *origin)
 }
 
 DBusMessage *
-dbind_send_and_allow_reentry (DBusConnection * bus, DBusMessage * message, DBusError *error)
+dbind_send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, DBusError *error)
 {
   DBusPendingCall *pending;
   SpiReentrantCallClosure *closure;
@@ -76,18 +76,18 @@ dbind_send_and_allow_reentry (DBusConnection * bus, DBusMessage * message, DBusE
       ret = dbus_connection_send_with_reply_and_block (bus, message,
                                                        dbind_timeout, error);
       if (g_main_depth () == 0 && !in_dispatch)
-      {
-        in_dispatch = TRUE;
-        while (dbus_connection_dispatch (bus) == DBUS_DISPATCH_DATA_REMAINS);
-        in_dispatch = FALSE;
-      }
+        {
+          in_dispatch = TRUE;
+          while (dbus_connection_dispatch (bus) == DBUS_DISPATCH_DATA_REMAINS)
+            ;
+          in_dispatch = FALSE;
+        }
       return ret;
     }
 
   closure = g_new0 (SpiReentrantCallClosure, 1);
   closure->reply = NULL;
-  if (!dbus_connection_send_with_reply (bus, message, &pending, dbind_timeout)
-      || !pending)
+  if (!dbus_connection_send_with_reply (bus, message, &pending, dbind_timeout) || !pending)
     {
       g_free (closure);
       return NULL;
@@ -101,14 +101,14 @@ dbind_send_and_allow_reentry (DBusConnection * bus, DBusMessage * message, DBusE
     {
       if (!dbus_connection_read_write_dispatch (bus, dbind_timeout))
         {
-          //dbus_pending_call_set_notify (pending, NULL, NULL, NULL);
+          // dbus_pending_call_set_notify (pending, NULL, NULL, NULL);
           dbus_pending_call_cancel (pending);
           dbus_pending_call_unref (pending);
           return NULL;
         }
       if (time_elapsed (&tv) > dbind_timeout)
         {
-          //dbus_pending_call_set_notify (pending, NULL, NULL, NULL);
+          // dbus_pending_call_set_notify (pending, NULL, NULL, NULL);
           dbus_pending_call_cancel (pending);
           dbus_pending_call_unref (pending);
           dbus_set_error_const (error, "org.freedesktop.DBus.Error.NoReply",
@@ -116,7 +116,7 @@ dbind_send_and_allow_reentry (DBusConnection * bus, DBusMessage * message, DBusE
           return NULL;
         }
     }
-  
+
   ret = closure->reply;
   dbus_pending_call_unref (pending);
   return ret;
@@ -124,79 +124,80 @@ dbind_send_and_allow_reentry (DBusConnection * bus, DBusMessage * message, DBusE
 
 dbus_bool_t
 dbind_method_call_reentrant_va (DBusConnection *cnx,
-                                const char     *bus_name,
-                                const char     *path,
-                                const char     *interface,
-                                const char     *method,
-                                DBusError      *opt_error,
-                                const char     *arg_types,
-                                va_list         args)
+                                const char *bus_name,
+                                const char *path,
+                                const char *interface,
+                                const char *method,
+                                DBusError *opt_error,
+                                const char *arg_types,
+                                va_list args)
 {
-    dbus_bool_t success = FALSE;
-    DBusMessage *msg = NULL, *reply = NULL;
-    DBusMessageIter iter;
-    DBusError *err, real_err;
-    const char *p;
+  dbus_bool_t success = FALSE;
+  DBusMessage *msg = NULL, *reply = NULL;
+  DBusMessageIter iter;
+  DBusError *err, real_err;
+  const char *p;
   va_list args_demarshal;
 
   dbus_error_init (&real_err);
 
   va_copy (args_demarshal, args);
-    if (opt_error)
-        err = opt_error;
-    else {
-        err = &real_err;
+  if (opt_error)
+    err = opt_error;
+  else
+    {
+      err = &real_err;
     }
 
-    msg = dbus_message_new_method_call (bus_name, path, interface, method);
-    if (!msg)
-        goto out;
+  msg = dbus_message_new_method_call (bus_name, path, interface, method);
+  if (!msg)
+    goto out;
 
-    p = arg_types;
-    dbus_message_iter_init_append (msg, &iter);
-    dbind_any_marshal_va (&iter, &p, args);
+  p = arg_types;
+  dbus_message_iter_init_append (msg, &iter);
+  dbind_any_marshal_va (&iter, &p, args);
 
-    reply = dbind_send_and_allow_reentry (cnx, msg, err);
-    if (!reply)
-        goto out;
+  reply = dbind_send_and_allow_reentry (cnx, msg, err);
+  if (!reply)
+    goto out;
 
-    if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)
+  if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_ERROR)
     {
       goto out;
     }
-    /* demarshal */
-    if (p[0] == '=' && p[1] == '>')
+  /* demarshal */
+  if (p[0] == '=' && p[1] == '>')
     {
-        DBusMessageIter iter;
-        dbus_message_iter_init (reply, &iter);
-	if (strcmp (p + 2, dbus_message_get_signature (reply)) != 0)
-	{
-	    g_warning ("dbind: Call to \"%s\" returned signature %s; expected %s",
-		       method, dbus_message_get_signature (reply), p + 2);
-	    if (opt_error)
-	        dbus_set_error (opt_error, DBUS_ERROR_INVALID_ARGS,
-		                "Call to \"%s\" returned signature %s; expected %s",
-		                method, dbus_message_get_signature (reply),
-                                p + 2);
-	    goto out;
-	}
-        p = arg_types;
-        dbind_any_demarshal_va (&iter, &p, args_demarshal);
+      DBusMessageIter iter;
+      dbus_message_iter_init (reply, &iter);
+      if (strcmp (p + 2, dbus_message_get_signature (reply)) != 0)
+        {
+          g_warning ("dbind: Call to \"%s\" returned signature %s; expected %s",
+                     method, dbus_message_get_signature (reply), p + 2);
+          if (opt_error)
+            dbus_set_error (opt_error, DBUS_ERROR_INVALID_ARGS,
+                            "Call to \"%s\" returned signature %s; expected %s",
+                            method, dbus_message_get_signature (reply),
+                            p + 2);
+          goto out;
+        }
+      p = arg_types;
+      dbind_any_demarshal_va (&iter, &p, args_demarshal);
     }
 
-    success = TRUE;
+  success = TRUE;
 out:
-    if (msg)
-        dbus_message_unref (msg);
+  if (msg)
+    dbus_message_unref (msg);
 
-    if (reply)
-        dbus_message_unref (reply);
+  if (reply)
+    dbus_message_unref (reply);
 
-    if (dbus_error_is_set (&real_err))
-        dbus_error_free (&real_err);
+  if (dbus_error_is_set (&real_err))
+    dbus_error_free (&real_err);
 
-    va_end (args_demarshal);
-    return success;
+  va_end (args_demarshal);
+  return success;
 }
 
 /**
@@ -218,29 +219,29 @@ out:
  **/
 dbus_bool_t
 dbind_method_call_reentrant (DBusConnection *cnx,
-                             const char     *bus_name,
-                             const char     *path,
-                             const char     *interface,
-                             const char     *method,
-                             DBusError      *opt_error,
-                             const char     *arg_types,
+                             const char *bus_name,
+                             const char *path,
+                             const char *interface,
+                             const char *method,
+                             DBusError *opt_error,
+                             const char *arg_types,
                              ...)
 {
-    dbus_bool_t success = FALSE;
-    va_list args;
-
-    va_start (args, arg_types);
-    success = dbind_method_call_reentrant_va (cnx,
-                                              bus_name,
-                                              path,
-                                              interface,
-                                              method,
-                                              opt_error,
-                                              arg_types,
-                                              args);
-    va_end (args);
-
-    return success;
+  dbus_bool_t success = FALSE;
+  va_list args;
+
+  va_start (args, arg_types);
+  success = dbind_method_call_reentrant_va (cnx,
+                                            bus_name,
+                                            path,
+                                            interface,
+                                            method,
+                                            opt_error,
+                                            arg_types,
+                                            args);
+  va_end (args);
+
+  return success;
 }
 
 /*---------------------------------------------------------------------------*/
@@ -248,36 +249,36 @@ dbind_method_call_reentrant (DBusConnection *cnx,
 /* TODO: opt_error is unused; should be removed */
 dbus_bool_t
 dbind_emit_signal_va (DBusConnection *cnx,
-                      const char     *path,
-                      const char     *interface,
-                      const char     *signal,
-                      DBusError      *opt_error,
-                      const char     *arg_types,
-                      va_list         args)
+                      const char *path,
+                      const char *interface,
+                      const char *signal,
+                      DBusError *opt_error,
+                      const char *arg_types,
+                      va_list args)
 {
-    dbus_bool_t success = FALSE;
-    DBusMessage *msg = NULL;
-    DBusMessageIter iter;
-    const char *p;
+  dbus_bool_t success = FALSE;
+  DBusMessage *msg = NULL;
+  DBusMessageIter iter;
+  const char *p;
 
-    msg = dbus_message_new_signal (path, interface, signal);
-    if (!msg)
-        goto out;
+  msg = dbus_message_new_signal (path, interface, signal);
+  if (!msg)
+    goto out;
 
-    p = arg_types;
-    dbus_message_iter_init_append (msg, &iter);
-    dbind_any_marshal_va (&iter, &p, args);
+  p = arg_types;
+  dbus_message_iter_init_append (msg, &iter);
+  dbind_any_marshal_va (&iter, &p, args);
 
-    if (!dbus_connection_send (cnx, msg, NULL))
-       goto out;
+  if (!dbus_connection_send (cnx, msg, NULL))
+    goto out;
 
-    success = TRUE;
+  success = TRUE;
 out:
 
-    if (msg)
-        dbus_message_unref (msg);
+  if (msg)
+    dbus_message_unref (msg);
 
-    return success;
+  return success;
 }
 
 /**
@@ -295,21 +296,21 @@ out:
  **/
 dbus_bool_t
 dbind_emit_signal (DBusConnection *cnx,
-                   const char     *path,
-                   const char     *interface,
-                   const char     *signal,
-                   DBusError      *opt_error,
-                   const char     *arg_types,
+                   const char *path,
+                   const char *interface,
+                   const char *signal,
+                   DBusError *opt_error,
+                   const char *arg_types,
                    ...)
 {
-    dbus_bool_t success = FALSE;
-    va_list args;
+  dbus_bool_t success = FALSE;
+  va_list args;
 
-    va_start (args, arg_types);
-    success = dbind_emit_signal_va (cnx, path, interface, signal, opt_error, arg_types, args);
-    va_end (args);
+  va_start (args, arg_types);
+  success = dbind_emit_signal_va (cnx, path, interface, signal, opt_error, arg_types, args);
+  va_end (args);
 
-    return success;
+  return success;
 }
 void
 dbind_set_timeout (int timeout)
@@ -317,5 +318,4 @@ dbind_set_timeout (int timeout)
   dbind_timeout = timeout;
 }
 
-
 /*END------------------------------------------------------------------------*/
diff --git a/dbind/dbind.h b/dbind/dbind.h
index 0c10c7dd..e27dcfe8 100644
--- a/dbind/dbind.h
+++ b/dbind/dbind.h
@@ -21,48 +21,48 @@
 #define _DBIND_H_
 
 #define DBUS_API_SUBJECT_TO_CHANGE
-#include <dbus/dbus.h>
 #include <dbind/dbind-any.h>
+#include <dbus/dbus.h>
 
 DBusMessage *
 dbind_send_and_allow_reentry (DBusConnection *bus, DBusMessage *message, DBusError *error);
 
 dbus_bool_t
 dbind_method_call_reentrant_va (DBusConnection *cnx,
-                                const char     *bus_name,
-                                const char     *path,
-                                const char     *interface,
-                                const char     *method,
-                                DBusError      *opt_error,
-                                const char     *arg_types,
-                                va_list         args);
+                                const char *bus_name,
+                                const char *path,
+                                const char *interface,
+                                const char *method,
+                                DBusError *opt_error,
+                                const char *arg_types,
+                                va_list args);
 
 dbus_bool_t
 dbind_method_call_reentrant (DBusConnection *cnx,
-                             const char     *bus_name,
-                             const char     *path,
-                             const char     *interface,
-                             const char     *method,
-                             DBusError      *opt_error,
-                             const char     *arg_types,
+                             const char *bus_name,
+                             const char *path,
+                             const char *interface,
+                             const char *method,
+                             DBusError *opt_error,
+                             const char *arg_types,
                              ...);
 
 dbus_bool_t
 dbind_emit_signal_va (DBusConnection *cnx,
-                      const char     *path,
-                      const char     *interface,
-                      const char     *signal,
-                      DBusError      *opt_error,
-                      const char     *arg_types,
-                      va_list         args);
+                      const char *path,
+                      const char *interface,
+                      const char *signal,
+                      DBusError *opt_error,
+                      const char *arg_types,
+                      va_list args);
 
 dbus_bool_t
 dbind_emit_signal (DBusConnection *cnx,
-                   const char     *path,
-                   const char     *interface,
-                   const char     *signal,
-                   DBusError      *opt_error,
-                   const char     *arg_types,
+                   const char *path,
+                   const char *interface,
+                   const char *signal,
+                   DBusError *opt_error,
+                   const char *arg_types,
                    ...);
 
 void dbind_set_timeout (int timeout);
diff --git a/dbind/dbtest.c b/dbind/dbtest.c
index 22ea2165..a6f15263 100644
--- a/dbind/dbtest.c
+++ b/dbind/dbtest.c
@@ -17,30 +17,32 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#include <stdio.h>
+#include <dbind/dbind.h>
 #include <glib.h>
+#include <stdio.h>
 #include <string.h>
-#include <dbind/dbind.h>
 
-void marshal (DBusMessage *msg, const char *type, void *ptr)
+void
+marshal (DBusMessage *msg, const char *type, void *ptr)
 {
-    DBusMessageIter iter;
+  DBusMessageIter iter;
 
-    dbus_message_iter_init_append (msg, &iter);
-    dbind_any_marshal (&iter, &type, &ptr);
+  dbus_message_iter_init_append (msg, &iter);
+  dbind_any_marshal (&iter, &type, &ptr);
 }
 
-void demarshal (DBusMessage *msg, const char *type, void *ptr)
+void
+demarshal (DBusMessage *msg, const char *type, void *ptr)
 {
-    DBusMessageIter iter;
-
-    if (!dbus_message_iter_init (msg, &iter))
-      {
-        fprintf (stderr, "no data in msg\n");
-        g_assert_not_reached ();
-      }
-    else
-        dbind_any_demarshal (&iter, &type, &ptr);
+  DBusMessageIter iter;
+
+  if (!dbus_message_iter_init (msg, &iter))
+    {
+      fprintf (stderr, "no data in msg\n");
+      g_assert_not_reached ();
+    }
+  else
+    dbind_any_demarshal (&iter, &type, &ptr);
 }
 
 #if 0
@@ -69,309 +71,320 @@ void dump_msg (DBusMessage *msg)
 }
 #endif
 
-void test_simple ()
+void
+test_simple ()
 {
-    dbus_int32_t v1, v2;
-    DBusMessage *msg;
+  dbus_int32_t v1, v2;
+  DBusMessage *msg;
 
-    msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
-    v1 = 42;
-    marshal (msg, "i", &v1);
-    demarshal (msg, "i", &v2);
-    g_assert (v2 == 42);
-    g_assert (v1 == v2);
+  msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+  v1 = 42;
+  marshal (msg, "i", &v1);
+  demarshal (msg, "i", &v2);
+  g_assert (v2 == 42);
+  g_assert (v1 == v2);
 
-    dbind_any_free ("i", &v2); /* nop */
-    dbus_message_unref (msg);
+  dbind_any_free ("i", &v2); /* nop */
+  dbus_message_unref (msg);
 
-    printf ("simple ok\n");
+  printf ("simple ok\n");
 }
 
-void test_array ()
+void
+test_array ()
 {
-    GArray *a1, *a2;
-    DBusMessage *msg;
-
-    /* pod types */
-    a1 = g_array_new (FALSE, FALSE, sizeof (dbus_int32_t));
-    g_array_set_size (a1, 4);
-    g_array_index (a1, dbus_int32_t, 0) = 42;
-    g_array_index (a1, dbus_int32_t, 1) = 17;
-    g_array_index (a1, dbus_int32_t, 2) = 26;
-    g_array_index (a1, dbus_int32_t, 3) = 38;
-
-    msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
-    marshal (msg, "ai", &a1);
-    demarshal (msg, "ai", &a2);
-
-    g_assert (a2 != NULL);
-    g_assert (a2->len == 4);
-    g_assert (g_array_index (a2, dbus_int32_t, 0) == 42);
-    g_assert (g_array_index (a2, dbus_int32_t, 1) == 17);
-    g_assert (g_array_index (a2, dbus_int32_t, 2) == 26);
-    g_assert (g_array_index (a2, dbus_int32_t, 3) == 38);
-    g_array_free (a1, TRUE);
-
-    dbind_any_free ("ai", &a2);
-    dbus_message_unref (msg);
-
-    printf ("array ok\n");
+  GArray *a1, *a2;
+  DBusMessage *msg;
+
+  /* pod types */
+  a1 = g_array_new (FALSE, FALSE, sizeof (dbus_int32_t));
+  g_array_set_size (a1, 4);
+  g_array_index (a1, dbus_int32_t, 0) = 42;
+  g_array_index (a1, dbus_int32_t, 1) = 17;
+  g_array_index (a1, dbus_int32_t, 2) = 26;
+  g_array_index (a1, dbus_int32_t, 3) = 38;
+
+  msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+  marshal (msg, "ai", &a1);
+  demarshal (msg, "ai", &a2);
+
+  g_assert (a2 != NULL);
+  g_assert (a2->len == 4);
+  g_assert (g_array_index (a2, dbus_int32_t, 0) == 42);
+  g_assert (g_array_index (a2, dbus_int32_t, 1) == 17);
+  g_assert (g_array_index (a2, dbus_int32_t, 2) == 26);
+  g_assert (g_array_index (a2, dbus_int32_t, 3) == 38);
+  g_array_free (a1, TRUE);
+
+  dbind_any_free ("ai", &a2);
+  dbus_message_unref (msg);
+
+  printf ("array ok\n");
 }
 
-/* this taught me that the struct type is a mis-nomer, 
+/* this taught me that the struct type is a mis-nomer,
    it is generated by brackets */
-void test_struct_native ()
+void
+test_struct_native ()
 {
-    DBusMessage *msg;
-    DBusMessageIter iter, arr, str;
+  DBusMessage *msg;
+  DBusMessageIter iter, arr, str;
 
-    /* manually create ar(ss) */
-    msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+  /* manually create ar(ss) */
+  msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
 
-    dbus_message_iter_init_append (msg, &iter);
+  dbus_message_iter_init_append (msg, &iter);
 
-    dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(ss)", &arr);
-    {
-        char *foo;
-        dbus_message_iter_open_container (&arr, DBUS_TYPE_STRUCT, NULL, &str);
-
-        foo = "foo";
-        dbus_message_iter_append_basic (&str, DBUS_TYPE_STRING, &foo);
-        foo = "baa";
-        dbus_message_iter_append_basic (&str, DBUS_TYPE_STRING, &foo);
-        
-        dbus_message_iter_close_container (&arr, &str);
-    }
-    dbus_message_iter_close_container (&iter, &arr);
+  dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "(ss)", &arr);
+  {
+    char *foo;
+    dbus_message_iter_open_container (&arr, DBUS_TYPE_STRUCT, NULL, &str);
 
-    printf ("native struct marshalling ok\n");
-    
-    dbus_message_unref (msg);
-}
+    foo = "foo";
+    dbus_message_iter_append_basic (&str, DBUS_TYPE_STRING, &foo);
+    foo = "baa";
+    dbus_message_iter_append_basic (&str, DBUS_TYPE_STRING, &foo);
+
+    dbus_message_iter_close_container (&arr, &str);
+  }
+  dbus_message_iter_close_container (&iter, &arr);
 
+  printf ("native struct marshalling ok\n");
+
+  dbus_message_unref (msg);
+}
 
-void test_struct_simple ()
+void
+test_struct_simple ()
 {
-    typedef struct {
-        char *foo;
-        char *baa;
-        char *baz;
-    } FooBaa;
-    GArray *a1 = NULL, *a2 = NULL;
-    DBusMessage *msg;
-
-    a1 = g_array_new (FALSE, FALSE, sizeof (FooBaa));
-    g_array_set_size (a1, 2);
-    g_array_index (a1, FooBaa, 0).foo = "foo";
-    g_array_index (a1, FooBaa, 0).baa = "baa";
-    g_array_index (a1, FooBaa, 0).baz = "baz";
-    g_array_index (a1, FooBaa, 1).foo = "Foo";
-    g_array_index (a1, FooBaa, 1).baa = "baA";
-    g_array_index (a1, FooBaa, 1).baz = "BaZ";
-
-    msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
-    marshal (msg, "a(sss)", &a1);
-    demarshal (msg, "a(sss)", &a2);
-
-    g_assert (a2 != NULL);
-    g_assert (a2 != a1);
-    g_assert (a2->len == 2);
-    g_assert (!strcmp (g_array_index (a2, FooBaa, 0).foo, "foo"));
-    g_assert (!strcmp (g_array_index (a2, FooBaa, 0).baa, "baa"));
-    g_assert (!strcmp (g_array_index (a2, FooBaa, 0).baz, "baz"));
-    g_assert (!strcmp (g_array_index (a2, FooBaa, 1).foo, "Foo"));
-    g_assert (!strcmp (g_array_index (a2, FooBaa, 1).baa, "baA"));
-    g_assert (!strcmp (g_array_index (a2, FooBaa, 1).baz, "BaZ"));
-    
-    printf ("simple struct ok\n");
-
-    dbind_any_free ("a(sss)", &a2);
-    dbus_message_unref (msg);
+  typedef struct
+  {
+    char *foo;
+    char *baa;
+    char *baz;
+  } FooBaa;
+  GArray *a1 = NULL, *a2 = NULL;
+  DBusMessage *msg;
+
+  a1 = g_array_new (FALSE, FALSE, sizeof (FooBaa));
+  g_array_set_size (a1, 2);
+  g_array_index (a1, FooBaa, 0).foo = "foo";
+  g_array_index (a1, FooBaa, 0).baa = "baa";
+  g_array_index (a1, FooBaa, 0).baz = "baz";
+  g_array_index (a1, FooBaa, 1).foo = "Foo";
+  g_array_index (a1, FooBaa, 1).baa = "baA";
+  g_array_index (a1, FooBaa, 1).baz = "BaZ";
+
+  msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+  marshal (msg, "a(sss)", &a1);
+  demarshal (msg, "a(sss)", &a2);
+
+  g_assert (a2 != NULL);
+  g_assert (a2 != a1);
+  g_assert (a2->len == 2);
+  g_assert (!strcmp (g_array_index (a2, FooBaa, 0).foo, "foo"));
+  g_assert (!strcmp (g_array_index (a2, FooBaa, 0).baa, "baa"));
+  g_assert (!strcmp (g_array_index (a2, FooBaa, 0).baz, "baz"));
+  g_assert (!strcmp (g_array_index (a2, FooBaa, 1).foo, "Foo"));
+  g_assert (!strcmp (g_array_index (a2, FooBaa, 1).baa, "baA"));
+  g_assert (!strcmp (g_array_index (a2, FooBaa, 1).baz, "BaZ"));
+
+  printf ("simple struct ok\n");
+
+  dbind_any_free ("a(sss)", &a2);
+  dbus_message_unref (msg);
 }
 
-void test_struct_complex ()
+void
+test_struct_complex ()
 {
-    typedef struct {
-        dbus_int32_t x, y;
-    } Point;
-    typedef struct {
-        unsigned char pad1;
-        double        val;
-        Point         tl, br;
-        char          pad2;
-        char         *name;
-    } Complex;
-#define TYPEOF_POINT \
-    DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
-        DBUS_TYPE_INT32_AS_STRING \
-        DBUS_TYPE_INT32_AS_STRING \
-    DBUS_STRUCT_END_CHAR_AS_STRING
-#define TYPEOF_COMPLEX \
-    DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
-        DBUS_TYPE_BYTE_AS_STRING \
-        DBUS_TYPE_DOUBLE_AS_STRING \
-        TYPEOF_POINT \
-        TYPEOF_POINT \
-        DBUS_TYPE_BYTE_AS_STRING \
-        DBUS_TYPE_STRING_AS_STRING \
-    DBUS_STRUCT_END_CHAR_AS_STRING
-
-
-    DBusMessage *msg;
-    Complex c1, c2;
-
-    memset (&c1, 0, sizeof (c1));
-    memset (&c2, 0, sizeof (c2));
-
-    c1.pad1 = 2;
-    c1.val = 0.1327569;
-    c1.tl.x = 1;
-    c1.tl.y = 17;
-    c1.br.x = 2587;
-    c1.br.y = -1;
-    c1.pad2 = 1;
-    c1.name = "stroustrup";
-
-    msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
-    marshal (msg, TYPEOF_COMPLEX, &c1);
-    demarshal (msg, TYPEOF_COMPLEX, &c2);
-
-    g_assert (c2.pad1 == 2);
-    g_assert (c2.val == c1.val);
-    g_assert (c2.val != 0);
-    g_assert (c2.tl.x == 1);
-    g_assert (c2.tl.y == 17);
-    g_assert (c2.br.x == 2587);
-    g_assert (c2.br.y == -1);
-    g_assert (c2.pad2 == 1);
-    g_assert (!strcmp (c1.name, "stroustrup"));
-    
-    printf ("complex struct ok\n");
-
-    dbind_any_free (TYPEOF_COMPLEX, &c2);
-    dbus_message_unref (msg);
+  typedef struct
+  {
+    dbus_int32_t x, y;
+  } Point;
+  typedef struct
+  {
+    unsigned char pad1;
+    double val;
+    Point tl, br;
+    char pad2;
+    char *name;
+  } Complex;
+#define TYPEOF_POINT               \
+  DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+  DBUS_TYPE_INT32_AS_STRING        \
+  DBUS_TYPE_INT32_AS_STRING        \
+  DBUS_STRUCT_END_CHAR_AS_STRING
+#define TYPEOF_COMPLEX             \
+  DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+  DBUS_TYPE_BYTE_AS_STRING         \
+  DBUS_TYPE_DOUBLE_AS_STRING       \
+  TYPEOF_POINT                     \
+  TYPEOF_POINT                     \
+  DBUS_TYPE_BYTE_AS_STRING         \
+  DBUS_TYPE_STRING_AS_STRING       \
+  DBUS_STRUCT_END_CHAR_AS_STRING
+
+  DBusMessage *msg;
+  Complex c1, c2;
+
+  memset (&c1, 0, sizeof (c1));
+  memset (&c2, 0, sizeof (c2));
+
+  c1.pad1 = 2;
+  c1.val = 0.1327569;
+  c1.tl.x = 1;
+  c1.tl.y = 17;
+  c1.br.x = 2587;
+  c1.br.y = -1;
+  c1.pad2 = 1;
+  c1.name = "stroustrup";
+
+  msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+  marshal (msg, TYPEOF_COMPLEX, &c1);
+  demarshal (msg, TYPEOF_COMPLEX, &c2);
+
+  g_assert (c2.pad1 == 2);
+  g_assert (c2.val == c1.val);
+  g_assert (c2.val != 0);
+  g_assert (c2.tl.x == 1);
+  g_assert (c2.tl.y == 17);
+  g_assert (c2.br.x == 2587);
+  g_assert (c2.br.y == -1);
+  g_assert (c2.pad2 == 1);
+  g_assert (!strcmp (c1.name, "stroustrup"));
+
+  printf ("complex struct ok\n");
+
+  dbind_any_free (TYPEOF_COMPLEX, &c2);
+  dbus_message_unref (msg);
 }
 
-void test_struct_with_array ()
+void
+test_struct_with_array ()
 {
-    typedef struct {
-        GArray *vals;
-        unsigned char pad1;
-    } ArrayStruct;
-#define TYPEOF_ARRAYSTRUCT \
-        DBUS_TYPE_ARRAY_AS_STRING \
-    DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
-        DBUS_TYPE_ARRAY_AS_STRING \
-        DBUS_TYPE_UINT32_AS_STRING \
-        DBUS_TYPE_BYTE_AS_STRING \
-    DBUS_STRUCT_END_CHAR_AS_STRING
-
-
-    DBusMessage *msg;
-    GArray *a1, *a2;
-    ArrayStruct *p, *q;
-
-
-    a1 = g_array_new (FALSE, FALSE, sizeof (ArrayStruct));
-    g_array_set_size (a1, 2);
-    p = &g_array_index (a1, ArrayStruct, 0);
-    p[0].vals = g_array_new (FALSE, FALSE, sizeof (dbus_uint32_t));
-    g_array_set_size (p[0].vals, 2);
-    g_array_index (p[0].vals, dbus_uint32_t, 0) = 1;
-    g_array_index (p[0].vals, dbus_uint32_t, 1) = 1000;
-    p[0].pad1 = 2;
-    p[1].vals = g_array_new (FALSE, FALSE, sizeof (dbus_uint32_t));
-    g_array_set_size (p[1].vals, 2);
-    g_array_index (p[1].vals, dbus_uint32_t, 0) = 1000000;
-    g_array_index (p[1].vals, dbus_uint32_t, 1) = 1000000000;
-    p[1].pad1 = 8;
-
-    msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
-    marshal (msg, TYPEOF_ARRAYSTRUCT, &a1);
-    demarshal (msg, TYPEOF_ARRAYSTRUCT, &a2);
-
-    q = &g_array_index (a2, ArrayStruct, 0);
-    g_assert (q[0].pad1 == 2);
-    g_assert (g_array_index (q[1].vals, dbus_uint32_t, 1) == 1000000000);
-    
-    printf ("struct with array ok\n");
-
-    dbind_any_free (TYPEOF_ARRAYSTRUCT, &a2);
-    dbus_message_unref (msg);
-    g_array_free (p[0].vals, TRUE);
-    g_array_free (p[1].vals, TRUE);
+  typedef struct
+  {
+    GArray *vals;
+    unsigned char pad1;
+  } ArrayStruct;
+#define TYPEOF_ARRAYSTRUCT         \
+  DBUS_TYPE_ARRAY_AS_STRING        \
+  DBUS_STRUCT_BEGIN_CHAR_AS_STRING \
+  DBUS_TYPE_ARRAY_AS_STRING        \
+  DBUS_TYPE_UINT32_AS_STRING       \
+  DBUS_TYPE_BYTE_AS_STRING         \
+  DBUS_STRUCT_END_CHAR_AS_STRING
+
+  DBusMessage *msg;
+  GArray *a1, *a2;
+  ArrayStruct *p, *q;
+
+  a1 = g_array_new (FALSE, FALSE, sizeof (ArrayStruct));
+  g_array_set_size (a1, 2);
+  p = &g_array_index (a1, ArrayStruct, 0);
+  p[0].vals = g_array_new (FALSE, FALSE, sizeof (dbus_uint32_t));
+  g_array_set_size (p[0].vals, 2);
+  g_array_index (p[0].vals, dbus_uint32_t, 0) = 1;
+  g_array_index (p[0].vals, dbus_uint32_t, 1) = 1000;
+  p[0].pad1 = 2;
+  p[1].vals = g_array_new (FALSE, FALSE, sizeof (dbus_uint32_t));
+  g_array_set_size (p[1].vals, 2);
+  g_array_index (p[1].vals, dbus_uint32_t, 0) = 1000000;
+  g_array_index (p[1].vals, dbus_uint32_t, 1) = 1000000000;
+  p[1].pad1 = 8;
+
+  msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+  marshal (msg, TYPEOF_ARRAYSTRUCT, &a1);
+  demarshal (msg, TYPEOF_ARRAYSTRUCT, &a2);
+
+  q = &g_array_index (a2, ArrayStruct, 0);
+  g_assert (q[0].pad1 == 2);
+  g_assert (g_array_index (q[1].vals, dbus_uint32_t, 1) == 1000000000);
+
+  printf ("struct with array ok\n");
+
+  dbind_any_free (TYPEOF_ARRAYSTRUCT, &a2);
+  dbus_message_unref (msg);
+  g_array_free (p[0].vals, TRUE);
+  g_array_free (p[1].vals, TRUE);
 }
 
-void test_twovals ()
+void
+test_twovals ()
 {
-    typedef struct {
-        dbus_int32_t v1;
-        dbus_int32_t v2;
-    } TwoVal;
-#define TYPEOF_TWOVAL \
-        DBUS_TYPE_INT32_AS_STRING \
-        DBUS_TYPE_INT32_AS_STRING \
-
-    DBusMessage *msg;
-    DBusMessageIter iter;
-    TwoVal i, o;
-    const char *type_twoval = TYPEOF_TWOVAL;
-    const char *type;
-    void *ptr;
-
-    msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
-    i.v1 = 42;
+  typedef struct
+  {
+    dbus_int32_t v1;
+    dbus_int32_t v2;
+  } TwoVal;
+#define TYPEOF_TWOVAL       \
+  DBUS_TYPE_INT32_AS_STRING \
+  DBUS_TYPE_INT32_AS_STRING
+
+  DBusMessage *msg;
+  DBusMessageIter iter;
+  TwoVal i, o;
+  const char *type_twoval = TYPEOF_TWOVAL;
+  const char *type;
+  void *ptr;
+
+  msg = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_CALL);
+  i.v1 = 42;
   i.v2 = 1764;
-    dbus_message_iter_init_append (msg, &iter);
-    type = type_twoval;
-    ptr = &i;
-    dbind_any_marshal (&iter, &type, &ptr);
-    dbind_any_marshal (&iter, &type, &ptr);
-    dbus_message_iter_init (msg, &iter);
-    type = type_twoval;
-    ptr = &o;
-    dbind_any_demarshal (&iter, &type, &ptr);
-    dbind_any_demarshal (&iter, &type, &ptr);
-    g_assert (o.v1 == 42);
-    g_assert (o.v2 == 1764);
-    g_assert (i.v1 == o.v1);
-    g_assert (i.v2 == o.v2);
-
-    dbind_any_free ("ii", &o); /* nop */
-    dbus_message_unref (msg);
-
-    printf ("two-val ok\n");
+  dbus_message_iter_init_append (msg, &iter);
+  type = type_twoval;
+  ptr = &i;
+  dbind_any_marshal (&iter, &type, &ptr);
+  dbind_any_marshal (&iter, &type, &ptr);
+  dbus_message_iter_init (msg, &iter);
+  type = type_twoval;
+  ptr = &o;
+  dbind_any_demarshal (&iter, &type, &ptr);
+  dbind_any_demarshal (&iter, &type, &ptr);
+  g_assert (o.v1 == 42);
+  g_assert (o.v2 == 1764);
+  g_assert (i.v1 == o.v1);
+  g_assert (i.v2 == o.v2);
+
+  dbind_any_free ("ii", &o); /* nop */
+  dbus_message_unref (msg);
+
+  printf ("two-val ok\n");
 }
 
-void test_marshalling ()
+void
+test_marshalling ()
 {
-    test_simple ();
-    test_array ();
-    test_struct_native ();
-    test_struct_simple ();
-    test_struct_complex ();
-    test_struct_with_array ();
-    test_twovals ();
-
-    printf ("Marshalling ok\n");
+  test_simple ();
+  test_array ();
+  test_struct_native ();
+  test_struct_simple ();
+  test_struct_complex ();
+  test_struct_with_array ();
+  test_twovals ();
+
+  printf ("Marshalling ok\n");
 }
 
-void test_helpers ()
+void
+test_helpers ()
 {
-    dbind_find_c_alignment ("(sss)");
-    dbind_find_c_alignment ("a(sss)");
-    dbind_find_c_alignment ("(s(s)yd(d)s)");
-    dbind_find_c_alignment ("a{ss}");
-    printf ("helpers passed\n");
+  dbind_find_c_alignment ("(sss)");
+  dbind_find_c_alignment ("a(sss)");
+  dbind_find_c_alignment ("(s(s)yd(d)s)");
+  dbind_find_c_alignment ("a{ss}");
+  printf ("helpers passed\n");
 }
 
-int main (int argc, char **argv)
+int
+main (int argc, char **argv)
 {
-    DBusConnection *bus = dbus_bus_get (DBUS_BUS_SESSION, NULL);
-    g_assert (bus != NULL);
+  DBusConnection *bus = dbus_bus_get (DBUS_BUS_SESSION, NULL);
+  g_assert (bus != NULL);
 
-    test_helpers ();
-    test_marshalling ();
+  test_helpers ();
+  test_marshalling ();
 
-    return 0;
+  return 0;
 }