Merge lp:~cjdahlin/libnih/async into lp:libnih/1.0

[Scott James Remnant (Canonical)]

[Scott James Remnant (Canonical) (canonical-scott)]

This got merged and then improved, thanks Casey!

review: Approve

=== modified file 'ChangeLog'
--- ChangeLog	2009-08-11 10:30:25 +0000
+++ ChangeLog	2009-10-03 06:00:27 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 2009-08-11  Scott James Remnant  <[e-mail]>
 
 	* nih/test_alloc.h (TEST_ALLOC_NOT_PARENT): Add the opposite test
@@ -2671,6 +2672,33 @@
 	Fix the test case to not compare a void * with strcmp
 
 2008-01-29  Casey Dahlin  <[e-mail]>
+=======
+2009-2-09  Casey Dahlin  <[e-mail]>
+
+	* nih/tests/test_com.netsplit.Nih.Test_proxy.c: Even more tests for
+	async calls.
+
+2009-2-01  Casey Dahlin  <[e-mail]>
+
+	* nih/nih_dbus_tool.py (Method.asyncDispatchPrototype): Rename
+	typedefs for callbacks from NihDBusCallback_foo_method to
+	FooMethodCallback. Same for Errback.
+
+	* nih/nih_dbus_tool.py (Method.asyncDispatchFunction): Check for and
+	properly handle error returns fron DBus. Also be sure to call the
+	errback for various memory/parse errors.
+
+	* nih/nih_dbus_tool.py (Method.exportTypedefs): More changes for new
+	typedef names.
+
+	* nih/nih_dbus_tool.py (camelate): New function to convert
+	underscore_delineated to CamelCase.
+
+	* nih/tests/test_com.netsplit.Nih.Test_proxy.c: Loads more tests for
+	async calls.
+
+2009-1-29  Casey Dahlin  <[e-mail]>
+>>>>>>> MERGE-SOURCE
 
 	* nih/nih_dbus_tool.py (Method.asyncDispatchPrototype): Prototype for
 	new asynchronous dispatch function, explained below.

=== modified file 'nih-dbus-tool/tests/test_com.netsplit.Nih.Test_proxy.c'
--- nih-dbus-tool/tests/test_com.netsplit.Nih.Test_proxy.c	2009-08-03 15:29:45 +0000
+++ nih-dbus-tool/tests/test_com.netsplit.Nih.Test_proxy.c	2009-10-03 06:00:27 +0000
@@ -37,6 +37,7 @@
 #include <nih/signal.h>
 #include <nih/main.h>
 #include <nih/error.h>
+<<<<<<< TREE
 
 #include <nih-dbus/dbus_connection.h>
 #include <nih-dbus/dbus_object.h>
@@ -50204,6 +50205,2167 @@
 	TEST_DBUS_END (dbus_pid);
 
 	dbus_shutdown ();
+=======
+#include <nih/errors.h>
+
+#include <nih/dbus.h>
+
+#include "com.netsplit.Nih.Test_proxy.h"
+#include "com.netsplit.Nih.Test_impl.h"
+
+
+static void async_fail_errback (NihDBusProxy *my_proxy, void *userdata);
+
+void
+test_method_dispatch (void)
+{
+	DBusConnection  *conn;
+	NihDBusProxy    *proxy;
+	NihError        *err;
+	NihDBusError    *dbus_err;
+	char            *output;
+	uint8_t          byte_arg;
+	int              boolean_arg;
+	int16_t          int16_arg;
+	uint16_t         uint16_arg;
+	int32_t          int32_arg;
+	uint32_t         uint32_arg;
+	int64_t          int64_arg;
+	uint64_t         uint64_arg;
+	double           double_arg;
+	int32_t         *int32_array;
+	char           **str_array;
+	size_t           array_len;
+	int              ret;
+	int              called;
+
+	TEST_GROUP ("method dispatching");
+
+
+	/* Check that we can make a D-Bus method call, passing in the
+	 * expected arguments and receiving the expected arguments in the
+	 * reply.
+	 */
+	TEST_FEATURE ("with valid argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_method (proxy, "test data", 0, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "test data");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that we can make an asynchronous D-Bus method call, passing in
+	 * the expected arguments and receiving the expected arguments in the
+	 * callback.
+	 */
+	TEST_FEATURE ("with valid argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void async_with_valid_argument (NihDBusProxy *proxy, void *userdata, char *output);
+
+	called = 0;
+
+	ret = proxy_test_method_async (proxy, "test data", 0,
+			async_with_valid_argument, async_fail_errback, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void async_with_valid_argument (NihDBusProxy *my_proxy, void *userdata, char *async_output)
+	{
+		TEST_NE_P (async_output, NULL);
+		TEST_ALLOC_PARENT (async_output, proxy);
+		TEST_EQ_STR (async_output, "test data");
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that if the method call returns a D-Bus error, the async proxy
+	 * call triggers the error handler and sets the appropriate error.
+	 */
+	TEST_FEATURE ("with returned D-Bus error");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_method (proxy, "test data", 1, &output);
+
+	TEST_LT (ret, 1);
+
+	err = nih_error_get ();
+	TEST_EQ (err->number, NIH_DBUS_ERROR);
+	TEST_ALLOC_SIZE (err, sizeof (NihDBusError));
+
+	dbus_err = (NihDBusError *)err;
+	TEST_EQ_STR (dbus_err->name, "com.netsplit.Nih.IllegalValue");
+
+	nih_free (dbus_err);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that if the method call returns a D-Bus error, the proxy
+	 * call returns a negative number and raises the same D-Bus error.
+	 */
+	TEST_FEATURE ("with returned D-Bus error (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	auto void async_with_dbus_error_errback (NihDBusProxy *proxy, void *userdata);
+
+	called = 0;
+
+	ret = proxy_test_method_async (proxy, "test data", 1, (ProxyTestMethodCallback)async_fail_errback,
+				       async_with_dbus_error_errback,"user data");
+
+	TEST_EQ (ret, 0);
+
+	void async_with_dbus_error_errback (NihDBusProxy *my_proxy, void *userdata)
+	{
+		err = nih_error_get ();
+		TEST_EQ (err->number, NIH_DBUS_ERROR);
+		TEST_ALLOC_SIZE (err, sizeof (NihDBusError));
+
+		dbus_err = (NihDBusError *)err;
+		TEST_EQ_STR (dbus_err->name, "com.netsplit.Nih.IllegalValue");
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (dbus_err);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that in out of memory conditions, D-Bus automatically
+	 * repeats the method call so we don't notice on the client side.
+	 */
+	TEST_FEATURE ("with out of memory error");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_method (proxy, "test data", 2, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "test data");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that in out of memory conditions, D-Bus automatically
+	 * repeats the method call so we don't notice on the client side, even
+	 * when the call is asynchronous.
+	 */
+	TEST_FEATURE ("with out of memory error (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void async_with_oom (NihDBusProxy *proxy, void *userdata, char *output);
+
+	called = 0;
+
+	ret = proxy_test_method_async (proxy, "test data", 2,
+			async_with_valid_argument, async_fail_errback, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void async_with_oom (NihDBusProxy *my_proxy, void *userdata, char *async_output)
+	{
+		TEST_NE_P (async_output, NULL);
+		TEST_ALLOC_PARENT (async_output, proxy);
+		TEST_EQ_STR (async_output, "test data");
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an error unknown to D-Bus is turned into a generic
+	 * failed error.
+	 */
+	TEST_FEATURE ("with unknown error");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_method (proxy, "test data", 3, &output);
+
+	TEST_LT (ret, 1);
+
+	err = nih_error_get ();
+	TEST_EQ (err->number, NIH_DBUS_ERROR);
+	TEST_ALLOC_SIZE (err, sizeof (NihDBusError));
+
+	dbus_err = (NihDBusError *)err;
+	TEST_EQ_STR (dbus_err->name, DBUS_ERROR_FAILED);
+
+	nih_free (dbus_err);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an error unknown to D-Bus is turned into a generic
+	 * failed error for an async call.
+	 */
+	TEST_FEATURE ("with unknown error (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void async_with_unknown (NihDBusProxy *proxy, void *userdata);
+
+	called = 0;
+
+	ret = proxy_test_method_async (proxy, "test data", 3,
+			(ProxyTestMethodCallback)async_fail_errback, async_with_unknown, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void async_with_unknown (NihDBusProxy *my_proxy, void *userdata)
+	{
+		err = nih_error_get ();
+		TEST_EQ (err->number, NIH_DBUS_ERROR);
+		TEST_ALLOC_SIZE (err, sizeof (NihDBusError));
+
+		dbus_err = (NihDBusError *)err;
+		TEST_EQ_STR (dbus_err->name, DBUS_ERROR_FAILED);
+
+		nih_free (dbus_err);
+
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that the fact the server implementation is asynchronous
+	 * is hidden and the call blocks until the reply comes back anyway.
+	 */
+	TEST_FEATURE ("with valid argument to async call");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_async_method (proxy, "test data", 0, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "test data");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that the fact the server implementation is asynchronous
+	 * doesn't affect asynchronous calls from us.
+	 */
+	TEST_FEATURE ("with valid argument to async call (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void async_with_async (NihDBusProxy *my_proxy, void *userdata, char *async_output);
+
+	called = 0;
+
+	ret = proxy_test_async_method_async (proxy, "test data", 0,
+			async_with_async, async_fail_errback, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void async_with_async (NihDBusProxy *my_proxy, void *userdata, char *async_output)
+	{
+		TEST_NE_P (async_output, NULL);
+		TEST_ALLOC_PARENT (async_output, proxy);
+		TEST_EQ_STR (async_output, "test data");
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an error returned from an asynchronous server-side
+	 * call still comes back as an error.
+	 */
+	TEST_FEATURE ("with returned D-Bus error from async call");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_async_method (proxy, "test data", 1, &output);
+
+	TEST_LT (ret, 1);
+
+	err = nih_error_get ();
+	TEST_EQ (err->number, NIH_DBUS_ERROR);
+	TEST_ALLOC_SIZE (err, sizeof (NihDBusError));
+
+	dbus_err = (NihDBusError *)err;
+	TEST_EQ_STR (dbus_err->name, "com.netsplit.Nih.IllegalValue");
+
+	nih_free (dbus_err);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an error returned from an asynchronous server-side
+	 * call still comes back as an error to an async client call.
+	 */
+	TEST_FEATURE ("with returned D-Bus error from async call (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void async_with_async_err (NihDBusProxy *my_proxy, void *userdata);
+
+	called = 0;
+
+	ret = proxy_test_async_method_async (proxy, "test data", 1,
+			(ProxyTestAsyncMethodCallback)async_fail_errback, async_with_async_err, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void async_with_async_err (NihDBusProxy *my_proxy, void *userdata)
+	{
+		err = nih_error_get ();
+		TEST_EQ (err->number, NIH_DBUS_ERROR);
+		TEST_ALLOC_SIZE (err, sizeof (NihDBusError));
+
+		dbus_err = (NihDBusError *)err;
+		TEST_EQ_STR (dbus_err->name, "com.netsplit.Nih.IllegalValue");
+
+		nih_free (dbus_err);
+
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that in out of memory conditions, D-Bus automatically
+	 * repeats the method call so we don't notice on the client side
+	 * even for async server-side calls.
+	 */
+	TEST_FEATURE ("with out of memory error from async call");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_async_method (proxy, "test data", 2, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "test data");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that in out of memory conditions, D-Bus automatically
+	 * repeats the method call so we don't notice on the client side
+	 * even for async server-side calls, when our call was async.
+	 */
+	TEST_FEATURE ("with out of memory error from async call (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void async_with_async_oom (NihDBusProxy *my_proxy, void *userdata, char *async_output);
+
+	called = 0;
+
+	ret = proxy_test_async_method_async (proxy, "test data", 2,
+			async_with_async_oom, async_fail_errback, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void async_with_async_oom (NihDBusProxy *my_proxy, void *userdata, char *async_output)
+	{
+		TEST_NE_P (async_output, NULL);
+		TEST_ALLOC_PARENT (async_output, proxy);
+		TEST_EQ_STR (async_output, "test data");
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an error unknown to D-Bus is turned into a generic
+	 * failed error.
+	 */
+	TEST_FEATURE ("with unknown error from async call");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_async_method (proxy, "test data", 3, &output);
+
+	TEST_LT (ret, 1);
+
+	err = nih_error_get ();
+	TEST_EQ (err->number, NIH_DBUS_ERROR);
+	TEST_ALLOC_SIZE (err, sizeof (NihDBusError));
+
+	dbus_err = (NihDBusError *)err;
+	TEST_EQ_STR (dbus_err->name, DBUS_ERROR_FAILED);
+
+	nih_free (dbus_err);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an error unknown to D-Bus is turned into a generic
+	 * failed error for an async call.
+	 */
+	TEST_FEATURE ("with unknown error from async call (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void async_with_async_unknown (NihDBusProxy *my_proxy, void *userdata);
+
+	called = 0;
+
+	ret = proxy_test_async_method_async (proxy, "test data", 3,
+			(ProxyTestAsyncMethodCallback)async_fail_errback, async_with_async_unknown, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void async_with_async_unknown (NihDBusProxy *my_proxy, void *userdata)
+	{
+		err = nih_error_get ();
+		TEST_EQ (err->number, NIH_DBUS_ERROR);
+		TEST_ALLOC_SIZE (err, sizeof (NihDBusError));
+
+		dbus_err = (NihDBusError *)err;
+		TEST_EQ_STR (dbus_err->name, DBUS_ERROR_FAILED);
+
+		nih_free (dbus_err);
+
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that a condition whereby the wrong arguments are returned
+	 * from a method call results in a special illegal arguments error
+	 * being returned.
+	 */
+	TEST_FEATURE ("with wrong argument type in reply");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_async_method (proxy, "test data", 4, &output);
+
+	TEST_LT (ret, 1);
+
+	err = nih_error_get ();
+	TEST_EQ (err->number, NIH_DBUS_INVALID_ARGS);
+	nih_free (err);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that a condition whereby the wrong arguments are returned
+	 * from a method call results in a special illegal arguments error
+	 * being passed to the errback.
+	 */
+	TEST_FEATURE ("with wrong argument type in reply (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_wrong_argument_type_in_reply_async (NihDBusProxy *my_proxy, void *userdata);
+
+	called = 0;
+
+	ret = proxy_test_async_method_async (proxy, "test data", 4,
+			(ProxyTestAsyncMethodCallback)async_fail_errback,
+			with_wrong_argument_type_in_reply_async, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void with_wrong_argument_type_in_reply_async (NihDBusProxy *my_proxy, void *userdata)
+	{
+		err = nih_error_get ();
+		TEST_EQ (err->number, NIH_DBUS_INVALID_ARGS);
+		nih_free (err);
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that a condition whereby too many arguments are returned
+	 * from a method call results in a special illegal arguments error
+	 * being returned.
+	 */
+	TEST_FEATURE ("with too many arguments in reply");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_too_many_args_in_reply_async (NihDBusProxy *my_proxy, void *userdata);
+
+	called = 0;
+
+	ret = proxy_test_async_method_async (proxy, "test data", 5,
+			(ProxyTestAsyncMethodCallback)async_fail_errback,
+			with_too_many_args_in_reply_async, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void with_too_many_args_in_reply_async (NihDBusProxy *my_proxy, void *userdata)
+	{
+		err = nih_error_get ();
+		TEST_EQ (err->number, NIH_DBUS_INVALID_ARGS);
+		nih_free (err);
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that a condition whereby too many arguments are returned
+	 * from a method call results in a special illegal arguments error
+	 * being passed to the errback.
+	 */
+	TEST_FEATURE ("with too many arguments in reply (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_async_method (proxy, "test data", 5, &output);
+
+	TEST_LT (ret, 1);
+
+	err = nih_error_get ();
+	TEST_EQ (err->number, NIH_DBUS_INVALID_ARGS);
+	nih_free (err);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that a condition whereby arguments are missing from the
+	 * method call return results in a special illegal arguments error
+	 * being returned.
+	 */
+	TEST_FEATURE ("with missing arguments in reply");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_test_async_method (proxy, "test data", 6, &output);
+
+	TEST_LT (ret, 1);
+
+	err = nih_error_get ();
+	TEST_EQ (err->number, NIH_DBUS_INVALID_ARGS);
+	nih_free (err);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that a condition whereby arguments are missing from the
+	 * method call return results in a special illegal arguments error
+	 * being passed to the errback.
+	 */
+	TEST_FEATURE ("with missing arguments in reply (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_missing_args_in_reply_async (NihDBusProxy *my_proxy, void *userdata);
+
+	called = 0;
+
+	ret = proxy_test_async_method_async (proxy, "test data", 6,
+			(ProxyTestAsyncMethodCallback)async_fail_errback,
+			with_missing_args_in_reply_async, "userdata");
+
+	TEST_EQ (ret, 0);
+
+	void with_missing_args_in_reply_async (NihDBusProxy *my_proxy, void *userdata)
+	{
+		err = nih_error_get ();
+		TEST_EQ (err->number, NIH_DBUS_INVALID_ARGS);
+		nih_free (err);
+		TEST_EQ_STR (userdata, "userdata");
+		TEST_EQ_P (my_proxy, proxy);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Byte type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Byte input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_byte_to_str (proxy, 65, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "65");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Byte type is dispatched
+	 * correctly by an async call.
+	 */
+	TEST_FEATURE ("with Byte input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_byte_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output);
+
+	called = 0;
+	ret = proxy_byte_to_str_async (proxy, 65, (ProxyByteToStrCallback)with_byte_input_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_byte_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "65");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Byte type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Byte output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	byte_arg = 0;
+
+	ret = proxy_str_to_byte (proxy, "65", &byte_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (byte_arg, 65);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Byte type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Byte output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_byte_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(byte_arg) my_byte_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_byte_async (proxy, "65", (ProxyStrToByteCallback)with_byte_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_byte_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(byte_arg) my_byte_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_byte_arg, 65);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Boolean type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Boolean input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_boolean_to_str (proxy, 1, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "True");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Boolean type is dispatched
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Boolean input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_boolean_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_boolean_to_str_async (proxy, 1, (ProxyBooleanToStrCallback)with_boolean_input_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_boolean_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "True");
+
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Boolean type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Boolean output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	boolean_arg = TRUE;
+
+	ret = proxy_str_to_boolean (proxy, "False", &boolean_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (boolean_arg, FALSE);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Boolean type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Boolean output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_boolean_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(boolean_arg) my_boolean_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_boolean_async (proxy, "False", (ProxyStrToBooleanCallback)with_boolean_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_boolean_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(boolean_arg) my_boolean_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_boolean_arg, 0);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Int16 type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Int16 input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_int16_to_str (proxy, 1701, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "1701");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Int16 type is dispatched
+	 * correctly from an asynchronous call.
+	 */
+	TEST_FEATURE ("with Int16 input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_int16_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_int16_to_str_async (proxy, 1701, (ProxyInt16ToStrCallback)with_int16_input_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_int16_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "1701");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Int16 type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Int16 output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	int16_arg = 0;
+
+	ret = proxy_str_to_int16 (proxy, "1701", &int16_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (int16_arg, 1701);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Int16 type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Int16 output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_int16_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(int16_arg) my_int16_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_int16_async (proxy, "65", (ProxyStrToInt16Callback)with_int16_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_int16_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(int16_arg) my_int16_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_int16_arg, 65);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of UInt16 type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with UInt16 input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_uint16_to_str (proxy, 1701, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "1701");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of UInt16 type is dispatched
+	 * correctly for an asynchronous call.
+	 */
+	TEST_FEATURE ("with UInt16 input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_uint16_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_uint16_to_str_async (proxy, 1701, (ProxyUint16ToStrCallback)with_uint16_input_argument, async_fail_errback, "user data" );
+
+	TEST_EQ (ret, 0);
+
+	void with_uint16_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "1701");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of UInt16 type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with UInt16 output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	uint16_arg = 0;
+
+	ret = proxy_str_to_uint16 (proxy, "1701", &uint16_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (uint16_arg, 1701);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of UInt16 type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with UInt16 output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_uint16_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(uint16_arg) my_uint16_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_uint16_async (proxy, "65", (ProxyStrToUint16Callback)with_uint16_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_uint16_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(uint16_arg) my_uint16_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_uint16_arg, 65);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Int32 type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Int32 input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_int32_to_str (proxy, 1701, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "1701");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Int32 type is dispatched
+	 * correctly during an asynchronous call.
+	 */
+	TEST_FEATURE ("with Int32 input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_int32_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_int32_to_str_async (proxy, 1701, (ProxyInt32ToStrCallback)with_int32_input_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_int32_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "1701");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Int32 type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Int32 output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	int32_arg = 0;
+
+	ret = proxy_str_to_int32 (proxy, "1701", &int32_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (int32_arg, 1701);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Int32 type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Int32 output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_int32_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(int32_arg) my_int32_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_int32_async (proxy, "65", (ProxyStrToInt32Callback)with_int32_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_int32_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(int32_arg) my_int32_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_int32_arg, 65);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of UInt32 type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with UInt32 input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_uint32_to_str (proxy, 1701, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "1701");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of UInt32 type is dispatched
+	 * correctly for an asynchronous call.
+	 */
+	TEST_FEATURE ("with UInt32 input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_uint32_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_uint32_to_str_async (proxy, 1701, (ProxyUint32ToStrCallback)with_uint32_input_argument, async_fail_errback, "user data" );
+
+	TEST_EQ (ret, 0);
+
+	void with_uint32_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "1701");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of UInt32 type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with UInt32 output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	uint32_arg = 0;
+
+	ret = proxy_str_to_uint32 (proxy, "1701", &uint32_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (uint32_arg, 1701);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of UInt32 type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with UInt32 output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_uint32_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(uint32_arg) my_uint32_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_uint32_async (proxy, "65", (ProxyStrToUint32Callback)with_uint32_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_uint32_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(uint32_arg) my_uint32_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_uint32_arg, 65);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Int64 type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Int64 input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_int64_to_str (proxy, 1701, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "1701");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Int64 type is dispatched
+	 * correctly for an asynchronous call.
+	 */
+	TEST_FEATURE ("with Int64 input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_int64_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_int64_to_str_async (proxy, 1701, (ProxyInt64ToStrCallback)with_int64_input_argument, async_fail_errback, "user data" );
+
+	TEST_EQ (ret, 0);
+
+	void with_int64_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "1701");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Int64 type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Int64 output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	int64_arg = 0;
+
+	ret = proxy_str_to_int64 (proxy, "1701", &int64_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (int64_arg, 1701);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Int64 type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Int64 output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_int64_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(int64_arg) my_int64_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_int64_async (proxy, "65", (ProxyStrToInt64Callback)with_int64_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_int64_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(int64_arg) my_int64_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_int64_arg, 65);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of UInt64 type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with UInt64 input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_uint64_to_str (proxy, 1701, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "1701");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of UInt64 type is dispatched
+	 * correctly for an asynchronous call.
+	 */
+	TEST_FEATURE ("with UInt64 input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_uint64_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_uint64_to_str_async (proxy, 1701, (ProxyUint64ToStrCallback)with_uint64_input_argument, async_fail_errback, "user data" );
+
+	TEST_EQ (ret, 0);
+
+	void with_uint64_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "1701");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of UInt64 type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with UInt64 output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	uint64_arg = 0;
+
+	ret = proxy_str_to_uint64 (proxy, "1701", &uint64_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (uint64_arg, 1701);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of UInt64 type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with UInt64 output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_uint64_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(uint64_arg) my_uint64_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_uint64_async (proxy, "65", (ProxyStrToUint64Callback)with_uint64_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_uint64_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(uint64_arg) my_uint64_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_uint64_arg, 65);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Double type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Double input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_double_to_str (proxy, 3.141592, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "3.141592");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Double type is dispatched
+	 * correctly for an asynchronous call.
+	 */
+	TEST_FEATURE ("with Double input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_double_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_double_to_str_async (proxy, 3.141592, (ProxyDoubleToStrCallback)with_double_input_argument, async_fail_errback, "user data" );
+
+	TEST_EQ (ret, 0);
+
+	void with_double_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "3.141592");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Double type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Double output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	double_arg = 0;
+
+	ret = proxy_str_to_double (proxy, "3.141592", &double_arg);
+
+	TEST_EQ (ret, 0);
+
+	TEST_EQ (double_arg, 3.141592);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Double type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Double output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_double_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(double_arg) my_double_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_double_async (proxy, "3.141592", (ProxyStrToDoubleCallback)with_double_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_double_output_argument (NihDBusProxy *my_proxy, char *userdata, typeof(double_arg) my_double_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ (my_double_arg, 3.141592);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of ObjectPath type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with ObjectPath input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_object_path_to_str (proxy, "/com/netsplit/Nih", &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "/com/netsplit/Nih");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of ObjectPath type is dispatched
+	 * correctly for an asynchronous call.
+	 */
+	TEST_FEATURE ("with ObjectPath input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_object_path_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_object_path_to_str_async (proxy, "/com/netsplit/Nih", (ProxyObjectPathToStrCallback)with_object_path_input_argument, async_fail_errback, "user data" );
+
+	TEST_EQ (ret, 0);
+
+	void with_object_path_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "/com/netsplit/Nih");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of ObjectPath type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with ObjectPath output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_str_to_object_path (proxy, "/com/netsplit/Nih", &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "/com/netsplit/Nih");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of ObjectPath type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with ObjectPath output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_object_path_output_argument (NihDBusProxy *my_proxy, char *userdata, char *my_object_path_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_object_path_async (proxy, "/com/netsplit/Nih", (ProxyStrToObjectPathCallback)with_object_path_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_object_path_output_argument (NihDBusProxy *my_proxy, char *userdata, char *my_object_path_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_NE_P (my_object_path_arg, NULL);
+		TEST_ALLOC_PARENT (my_object_path_arg, proxy);
+		TEST_EQ_STR (my_object_path_arg, "/com/netsplit/Nih");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Signature type is dispatched
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Signature input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_signature_to_str (proxy, "a{sv}", &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "a{sv}");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Signature type is dispatched
+	 * correctly for an asynchronous call.
+	 */
+	TEST_FEATURE ("with Signature input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_signature_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	called = 0;
+	ret = proxy_signature_to_str_async (proxy, "a{sv}", (ProxySignatureToStrCallback)with_signature_input_argument, async_fail_errback, "user data" );
+
+	TEST_EQ (ret, 0);
+
+	void with_signature_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "a{sv}");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Signature type is marshalled
+	 * correctly.
+	 */
+	TEST_FEATURE ("with Signature output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	output = NULL;
+
+	ret = proxy_str_to_signature (proxy, "a{sv}", &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "a{sv}");
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Signature type is marshalled
+	 * correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Signature output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_signature_output_argument (NihDBusProxy *my_proxy, char *userdata, char *my_signature_arg);
+
+	called = 0;
+
+	ret = proxy_str_to_signature_async (proxy, "a{sv}", (ProxyStrToSignatureCallback)with_signature_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_signature_output_argument (NihDBusProxy *my_proxy, char *userdata, char *my_signature_arg)
+	{
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_EQ_STR (userdata, "user data");
+		TEST_NE_P (my_signature_arg, NULL);
+		TEST_ALLOC_PARENT (my_signature_arg, proxy);
+		TEST_EQ_STR (my_signature_arg, "a{sv}");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Array type with Int32 members
+	 * is dispatched correctly.
+	 */
+	TEST_FEATURE ("with Int32 Array input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	int32_array = nih_alloc (NULL, sizeof (int32_t) * 6);
+	int32_array[0] = 4;
+	int32_array[1] = 8;
+	int32_array[2] = 15;
+	int32_array[3] = 16;
+	int32_array[4] = 23;
+	int32_array[5] = 42;
+	array_len = 6;
+
+	output = NULL;
+
+	ret = proxy_int32_array_to_str (proxy, int32_array, array_len,
+					&output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "4 8 15 16 23 42");
+
+	nih_free (proxy);
+	nih_free (int32_array);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Array type with Int32 members
+	 * is dispatched correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Int32 Array input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_int_array_input_argument (NihDBusProxy *proxy, char *userdata, char *output);
+
+	int32_array = nih_alloc (NULL, sizeof (int32_t) * 6);
+	int32_array[0] = 4;
+	int32_array[1] = 8;
+	int32_array[2] = 15;
+	int32_array[3] = 16;
+	int32_array[4] = 23;
+	int32_array[5] = 42;
+	array_len = 6;
+
+	called = 0;
+	ret = proxy_int32_array_to_str_async (proxy, int32_array, array_len,
+					(ProxyInt32ArrayToStrCallback)with_int_array_input_argument, async_fail_errback,
+					"user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_int_array_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "4 8 15 16 23 42");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+	nih_free (int32_array);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Array type with Int32 members
+	 * is marshalled correctly.
+	 */
+	TEST_FEATURE ("with Int32 Array output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	int32_array = NULL;
+	array_len = 0;
+
+	ret = proxy_str_to_int32_array (proxy, "4 8 15 16 23 42",
+					&int32_array, &array_len);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (int32_array, NULL);
+	TEST_ALLOC_PARENT (int32_array, proxy);
+	TEST_EQ (array_len, 6);
+	TEST_EQ (int32_array[0], 4);
+	TEST_EQ (int32_array[1], 8);
+	TEST_EQ (int32_array[2], 15);
+	TEST_EQ (int32_array[3], 16);
+	TEST_EQ (int32_array[4], 23);
+	TEST_EQ (int32_array[5], 42);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Array type with Int32 members
+	 * is marshalled correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with Int32 Array output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_int_array_output_argument (NihDBusProxy *my_proxy, char *userdata, int *my_intarray, int my_len);
+
+	called = 0;
+	ret = proxy_str_to_int32_array_async (proxy, "4 8 15 16 23 42",
+					(ProxyStrToInt32ArrayCallback)with_int_array_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_int_array_output_argument (NihDBusProxy *my_proxy, char *userdata, int *my_intarray, int my_len)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_intarray, NULL);
+		TEST_ALLOC_PARENT (my_intarray, proxy);
+		TEST_EQ (my_len, 6);
+		TEST_EQ (my_intarray[0], 4);
+		TEST_EQ (my_intarray[1], 8);
+		TEST_EQ (my_intarray[2], 15);
+		TEST_EQ (my_intarray[3], 16);
+		TEST_EQ (my_intarray[4], 23);
+		TEST_EQ (my_intarray[5], 42);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Array type with String members
+	 * is dispatched correctly.
+	 */
+	TEST_FEATURE ("with String Array input argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	str_array = nih_alloc (NULL, sizeof (char *) * 5);
+	str_array[0] = "this";
+	str_array[1] = "is";
+	str_array[2] = "a";
+	str_array[3] = "test";
+	str_array[4] = NULL;
+
+	output = NULL;
+
+	ret = proxy_str_array_to_str (proxy, str_array, &output);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (output, NULL);
+	TEST_ALLOC_PARENT (output, proxy);
+	TEST_EQ_STR (output, "this is a test");
+
+	nih_free (proxy);
+	nih_free (str_array);
+
+	my_teardown (conn);
+
+
+	/* Check that an input argument of Array type with String members
+	 * is dispatched correctly for async calls.
+	 */
+	TEST_FEATURE ("with String Array input argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_str_array_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output);
+
+	str_array = nih_alloc (NULL, sizeof (char *) * 5);
+	str_array[0] = "this";
+	str_array[1] = "is";
+	str_array[2] = "a";
+	str_array[3] = "test";
+	str_array[4] = NULL;
+
+	called = 0;
+	ret = proxy_str_array_to_str_async (proxy, str_array, (ProxyStrArrayToStrCallback)with_str_array_input_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_str_array_input_argument (NihDBusProxy *my_proxy, char *userdata, char *my_output)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_output, NULL);
+		TEST_ALLOC_PARENT (my_output, proxy);
+		TEST_EQ_STR (my_output, "this is a test");
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+	nih_free (str_array);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Array type with String members
+	 * is marshalled correctly.
+	 */
+	TEST_FEATURE ("with String Array output argument");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	str_array = NULL;
+
+	ret = proxy_str_to_str_array (proxy, "this is a test", &str_array);
+
+	TEST_EQ (ret, 0);
+
+	TEST_NE_P (str_array, NULL);
+	TEST_ALLOC_PARENT (str_array, proxy);
+	TEST_EQ_STR (str_array[0], "this");
+	TEST_EQ_STR (str_array[1], "is");
+	TEST_EQ_STR (str_array[2], "a");
+	TEST_EQ_STR (str_array[3], "test");
+	TEST_EQ_P (str_array[4], NULL);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+
+
+	/* Check that an output argument of Array type with String members
+	 * is marshalled correctly for asynchronous calls.
+	 */
+	TEST_FEATURE ("with String Array output argument (async)");
+	conn = my_setup ();
+	proxy = nih_dbus_proxy_new (NULL, conn, NULL, "/com/netsplit/Nih");
+
+	auto void with_str_array_output_argument (NihDBusProxy *my_proxy, char *userdata, char **my_str_array);
+
+	called = 0;
+
+	ret = proxy_str_to_str_array_async (proxy, "this is a test", (ProxyStrToStrArrayCallback)with_str_array_output_argument, async_fail_errback, "user data");
+
+	TEST_EQ (ret, 0);
+
+	void with_str_array_output_argument (NihDBusProxy *my_proxy, char *userdata, char **my_str_array)
+	{
+		TEST_EQ_STR (userdata, "user data");
+		TEST_EQ_P (my_proxy, proxy);
+		TEST_NE_P (my_str_array, NULL);
+		TEST_ALLOC_PARENT (my_str_array, proxy);
+		TEST_EQ_STR (my_str_array[0], "this");
+		TEST_EQ_STR (my_str_array[1], "is");
+		TEST_EQ_STR (my_str_array[2], "a");
+		TEST_EQ_STR (my_str_array[3], "test");
+		TEST_EQ_P (my_str_array[4], NULL);
+		called = 1;
+	}
+
+	while (! called)
+		dbus_connection_read_write_dispatch (conn, -1);
+
+	nih_free (proxy);
+
+	my_teardown (conn);
+}
+
+
+static void
+async_fail_errback (NihDBusProxy *my_proxy, void *userdata)
+{
+	TEST_FAILED ("Called wrong asynchronous handler");
+>>>>>>> MERGE-SOURCE
 }
 
 

=== added file 'nih/nih_dbus_tool.py.OTHER'
--- nih/nih_dbus_tool.py.OTHER	1970-01-01 00:00:00 +0000
+++ nih/nih_dbus_tool.py.OTHER	2009-10-03 06:00:27 +0000
@@ -0,0 +1,2635 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# nih_dbus_tool.py - D-Bus binding generation tool
+#
+# Copyright © 2008 Scott James Remnant <[e-mail]>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+import os
+import re
+import sys
+
+from optparse import OptionParser
+from xml.etree import ElementTree
+
+
+# Replaced by autoconf-obtained strings
+PACKAGE_NAME = "@PACKAGE_NAME@"
+PACKAGE_COPYRIGHT = "@PACKAGE_COPYRIGHT@"
+
+# Prefix for external functions
+extern_prefix = "dbus"
+
+# Generator mode
+mode = "object"
+
+
+# Conversion for external C names
+NAME_RE = re.compile(r'([a-z0-9])([A-Z])')
+
+# Namespace for our own tags and attributes
+XMLNS = "http://www.netsplit.com/nih/dbus"
+
+
+# arrays of arrays with length (ends up being an array of a struct)
+#  - instead of using self.type.c_type and name, we should iterate
+#    over its vars? -- array will have foo_elem and foo_elem_len
+#
+# struct type
+# variant type (at least fallback to requiring them to define the marshal?)
+ #  - one way might be just to pass a container or fake message?
+
+# "proxy" mode:
+#   async function dispatch
+#   function dispatch with no reply
+#   configurable timeout, autostart, etc. for function dispatch
+#   signal marshal
+#   - called when a signal we're expecting happens, will have a message
+#     object and will call a handler with that -- need an object equivalent,
+#     "proxy" likely
+
+
+class DBusType(object):
+    """D-Bus type.
+
+    This abstract class represents the base of all D-Bus types that we
+    can handle.
+    """
+
+    @classmethod
+    def fromElement(cls, elem):
+        name = elem.get("name")
+        if name is None:
+            raise AttributeError, "Argument name may not be null"
+
+        type = elem.get("type")
+        if type is None:
+            raise AttributeError, "Argument type may not be null"
+
+        direction = elem.get("direction", "in")
+        if direction not in ( "in", "out" ):
+            raise AttributeError, "Direction must be 'in' or 'out'"
+
+        type_cls = cls.typeOf(type)
+        return type_cls.fromArgument(name, direction)
+
+    @classmethod
+    def fromArgument(cls, name, direction="in"):
+        self = cls(name)
+        self.direction = direction
+
+        return self
+
+    def __init__(self, name):
+        self.name = name
+
+    @classmethod
+    def typeOf(cls, code):
+        """Return type for given type signature code."""
+        if code == "y":
+            return DBusByte
+        elif code == "b":
+            return DBusBoolean
+        elif code == "n":
+            return DBusInt16
+        elif code == "q":
+            return DBusUInt16
+        elif code == "i":
+            return DBusInt32
+        elif code == "u":
+            return DBusUInt32
+        elif code == "x":
+            return DBusInt64
+        elif code == "t":
+            return DBusUInt64
+        elif code == "d":
+            return DBusDouble
+        elif code == "s":
+            return DBusString
+        elif code == "o":
+            return DBusObjectPath
+        elif code == "g":
+            return DBusSignature
+        elif code[0] == "a":
+            return DBusArray.forType(cls.typeOf(code[-1]))
+        else:
+            raise AttributeError, "Unknown or unhandled type '%s'" % code
+
+    def realType(self, c_type, pointer=False, const=False):
+        """Real type.
+
+        Returns a string containing the C type name for this type, with
+        pointer and const modifications added.
+        """
+        if pointer:
+            c_type = pointerify(c_type)
+        if const:
+            c_type = constify(c_type)
+
+        return c_type
+
+    def signature(self, pointer=False, const=False):
+        """Type signature.
+
+        Returns a string containing the D-Bus type signature for this type.
+        """
+        return None
+
+    def vars(self, pointer=False, const=False):
+        """Variable type and name.
+
+        Returns a list containing a single tuple of the C type used for this
+        type and the name given when creating the instance.
+        """
+        return []
+
+    def names(self, pointer=False, const=False):
+        """Variable name.
+
+        Returns a list containing a single string; the name given when creating
+        the instance.
+        """
+        return []
+
+    def locals(self, pointer=False, const=False):
+        """Local variable type and name.
+
+        Returns a list containing necessary local variables for iteration
+        of this type.
+        """
+        return []
+
+    def marshal(self, iter_name, parent, type_error, mem_error,
+                pointer=False, const=False):
+        """Marshalling code.
+
+        Returns a string containing the code that will marshal from an
+        iterator with the name given into a local variable with the
+        type and name as returned by vars().
+        """
+        return None
+
+    def dispatch(self, iter_name, mem_error,
+                 pointer=False, const=False):
+        """Dispatching code.
+
+        Returns a string containing the code that will dispatch from a
+        local variable with the type and name as returned by vars() to
+        an iterator with the name given.
+        """
+        return None
+
+
+class DBusBasicType(DBusType):
+    """D-Bus basic type.
+
+    This abstract class represents the base of all basic D-Bus types that
+    we can handle.  These share the code to marshal from a DBusMessage into
+    a variable and dispatch from a variable back into a DBusMessage.
+    """
+
+    def signature(self, pointer=False, const=False):
+        """Type signature.
+
+        Returns a string containing the D-Bus type signature for this type.
+        """
+        return self.dbus_code
+
+    def vars(self, pointer=False, const=False):
+        """Variable type and name.
+
+        Returns a list containing a single tuple of the C type used for this
+        type and the name given when creating the instance.
+        """
+        return [ ( self.realType(self.c_type, pointer, const), self.name ) ]
+
+    def names(self, pointer=False, const=False):
+        """Variable name.
+
+        Returns a list containing a single string; the name given when creating
+        the instance.
+        """
+        return [ self.name ]
+
+    def locals(self, pointer=False, const=False):
+        """Local variable type and name.
+
+        Returns a list containing necessary local variables for iteration
+        of this type.
+        """
+        return []
+
+    def marshal(self, iter_name, parent, type_error, mem_error,
+                pointer=False, const=False):
+        """Marshalling code.
+
+        Returns a string containing the code that will marshal from an
+        iterator with the name given into a local variable with the
+        type and name as returned by vars().
+        """
+        name = self.name
+        if pointer:
+            name = "*%s" % (name, )
+
+        return """\
+if (dbus_message_iter_get_arg_type (&%s) != %s) {
+%s
+}
+
+dbus_message_iter_get_basic (&%s, &%s);
+
+dbus_message_iter_next (&%s);
+""" % (iter_name, self.dbus_type, type_error,
+       iter_name, name,
+       iter_name)
+
+    def dispatch(self, iter_name, mem_error,
+                 pointer=False, const=False):
+        """Dispatching code.
+
+        Returns a string containing the code that will dispatch from a
+        local variable with the type and name as returned by vars() to
+        an iterator with the name given.
+        """
+        name = self.name
+        if pointer:
+            name = "*%s" % (name, )
+
+        return """\
+if (! dbus_message_iter_append_basic (&%s, %s, &%s)) {
+%s
+}
+""" % (iter_name, self.dbus_type, name, mem_error)
+
+
+class DBusByte(DBusBasicType):
+    """D-Bus byte.
+
+    This class represents the D-Bus byte type and should be instantiated with
+    the name of the variable.  It shares marshalling and dispatch code with
+    the other basic types.
+    """
+    c_type    = "uint8_t"
+    dbus_code = "y"
+    dbus_type = "DBUS_TYPE_BYTE"
+
+class DBusBoolean(DBusBasicType):
+    """D-Bus boolean.
+
+    This class represents the D-Bus boolean type and should be instantiated
+    with the name of the variable.  It shares marshalling and dispatch code
+    with the other basic types.
+    """
+    c_type    = "int"
+    dbus_code = "b"
+    dbus_type = "DBUS_TYPE_BOOLEAN"
+
+class DBusInt16(DBusBasicType):
+    """D-Bus 16-bit integer.
+
+    This class represents the D-Bus int16 type and should be instantiated with
+    the name of the variable.  It shares marshalling and dispatch code with
+    the other basic types.
+    """
+    c_type     = "int16_t"
+    dbus_code = "n"
+    dbus_type = "DBUS_TYPE_INT16"
+
+class DBusUInt16(DBusBasicType):
+    """D-Bus 16-bit unsigned integer.
+
+    This class represents the D-Bus uint16 type and should be instantiated with
+    the name of the variable.  It shares marshalling and dispatch code with
+    the other basic types.
+    """
+    c_type    = "uint16_t"
+    dbus_code = "q"
+    dbus_type = "DBUS_TYPE_UINT16"
+
+class DBusInt32(DBusBasicType):
+    """D-Bus 32-bit integer.
+
+    This class represents the D-Bus int32 type and should be instantiated with
+    the name of the variable.  It shares marshalling and dispatch code with
+    the other basic types.
+    """
+    c_type    = "int32_t"
+    dbus_code = "i"
+    dbus_type = "DBUS_TYPE_INT32"
+
+class DBusUInt32(DBusBasicType):
+    """D-Bus 32-bit unsigned integer.
+
+    This class represents the D-Bus uint32 type and should be instantiated with
+    the name of the variable.  It shares marshalling and dispatch code with
+    the other basic types.
+    """
+    c_type    = "uint32_t"
+    dbus_code = "u"
+    dbus_type = "DBUS_TYPE_UINT32"
+
+class DBusInt64(DBusBasicType):
+    """D-Bus 64-bit integer.
+
+    This class represents the D-Bus int64 type and should be instantiated with
+    the name of the variable.  It shares marshalling and dispatch code with
+    the other basic types.
+    """
+    c_type    = "int64_t"
+    dbus_code = "x"
+    dbus_type = "DBUS_TYPE_INT64"
+
+class DBusUInt64(DBusBasicType):
+    """D-Bus 64-bit unsigned integer.
+
+    This class represents the D-Bus uint64 type and should be instantiated with
+    the name of the variable.  It shares marshalling and dispatch code with
+    the other basic types.
+    """
+    c_type    = "uint64_t"
+    dbus_code = "t"
+    dbus_type = "DBUS_TYPE_UINT64"
+
+class DBusDouble(DBusBasicType):
+    """D-Bus double.
+
+    This class represents the D-Bus double type and should be instantiated
+    with the name of the variable.  It shares marshalling and dispatch code
+    with the other basic types.
+    """
+    c_type    = "double"
+    dbus_code = "d"
+    dbus_type = "DBUS_TYPE_DOUBLE"
+
+
+class DBusStringType(DBusBasicType):
+    """D-Bus string type.
+
+    This abstract class represents the base of all string-derived D-Bus types
+    that we can handle.  These share the code to marshal from a DBusMessage
+    into a variable, the code to dispatch from a variable back into a
+    DBusMessage and the same basic C type.
+
+    They differ from the fundamental basic type in that the marshalled copy
+    of the string is not direct from the message, but an allocated copy;
+    this is because they cannot be simply passed by value, and may wish to
+    be stored.
+    """
+    c_type    = "char *"
+
+    def locals(self, pointer=False, const=False):
+        """Local variable type and name.
+
+        Returns a list containing necessary local variables for iteration
+        of this type.
+        """
+        return [ ( self.realType(self.c_type, const=const),
+                   "_".join((self.name, "value")) ) ]
+
+    def marshal(self, iter_name, parent, type_error, mem_error,
+                pointer=False, const=False):
+        """Marshalling code.
+
+        Returns a string containing the code that will marshal from an
+        iterator with the name given into a local variable with the
+        type and name as returned by vars().
+        """
+        name = self.name
+        if pointer:
+            name = "*%s" % (name, )
+
+        value_name = "_".join((self.name, "value"))
+
+        return """\
+if (dbus_message_iter_get_arg_type (&%s) != %s) {
+%s
+}
+
+dbus_message_iter_get_basic (&%s, &%s);
+
+%s = nih_strdup (%s, %s);
+if (! %s) {
+%s
+}
+
+dbus_message_iter_next (&%s);
+""" % (iter_name, self.dbus_type, type_error,
+       iter_name, value_name,
+       name, parent, value_name,
+       name, mem_error,
+       iter_name)
+
+    def dispatch(self, iter_name, mem_error,
+                 pointer=False, const=False):
+        """Dispatching code.
+
+        Returns a string containing the code that will dispatch from a
+        local variable with the type and name as returned by vars() to
+        an iterator with the name given.
+        """
+        name = self.name
+        if pointer:
+            name = "*%s" % (name, )
+
+        value_name = "_".join((self.name, "value"))
+
+        return """\
+%s = %s;
+if (! dbus_message_iter_append_basic (&%s, %s, &%s)) {
+%s
+}
+""" % (value_name, name,
+       iter_name, self.dbus_type, value_name, mem_error)
+
+
+class DBusString(DBusStringType):
+    """D-Bus string.
+
+    This class represents the D-Bus string type and should be instantiated
+    with the name of the variable.  It shares marshalling and dispatch code
+    and underlying C type with the other string types.
+    """
+    dbus_type = "DBUS_TYPE_STRING"
+    dbus_code = "s"
+
+class DBusObjectPath(DBusStringType):
+    """D-Bus object path.
+
+    This class represents the D-Bus object path type and should be instantiated
+    with the name of the variable.  It shares marshalling and dispatch code
+    and underlying C type with the other string types.
+    """
+    dbus_type = "DBUS_TYPE_OBJECT_PATH"
+    dbus_code = "o"
+
+class DBusSignature(DBusStringType):
+    """D-Bus type signature.
+
+    This class represents the D-Bus signature type and should be instantiated
+    with the name of the variable.  It shares marshalling and dispatch code
+    and underlying C type with the other string types.
+    """
+    dbus_type = "DBUS_TYPE_SIGNATURE"
+    dbus_code = "g"
+
+
+class DBusArray(DBusType):
+    """D-Bus array.
+
+    This class represents the D-Bus array type, it should be first
+    sub-classed with member_type set to an appropriate other class (the
+    forType classmethod can do that for you) and then instantiated with
+    the name of the variable.
+    """
+    dbus_type = "DBUS_TYPE_ARRAY"
+    dbus_code = "a"
+
+    @classmethod
+    def forType(cls, type):
+        class _DBusArray(DBusArray):
+            member_type = type
+
+        return _DBusArray
+
+    def __init__(self, name):
+        super(DBusArray, self).__init__(name)
+
+        self.iter_name = "%s_iter" % (self.name,)
+        self.len_name = "%s_len" % (self.name,)
+        self.loop_name = "%s_p" % (self.name,)
+
+        self.type = self.member_type("%s_elem" % (self.name, ))
+        # FIXME doesn't handle arrays of simple arrays since the length
+        # field is lost.
+        assert (len(self.type.vars()) == 1)
+
+        self.c_type = pointerify(self.type.c_type)
+
+    def signature(self, pointer=False, const=False):
+        """Type signature.
+
+        Returns a string containing the D-Bus type signature for this type.
+        """
+        return self.dbus_code + self.type.signature()
+
+    def locals(self, pointer=False, const=False):
+        """Local variable type and name.
+
+        Returns a list containing necessary local variables for iteration
+        of this type.
+        """
+        locals = [ ( "DBusMessageIter", self.iter_name )]
+        if self.type.c_type.endswith("*"):
+            locals.append(( "size_t", self.len_name ))
+
+        return locals
+
+    def vars(self, pointer=False, const=False):
+        """Variable type and name.
+
+        Returns a list containing tuples of C type and name for each type
+        within this group.
+        """
+        vars = [ ( self.realType(self.c_type, pointer, const),
+                   self.name ) ]
+        if not self.type.c_type.endswith("*"):
+            vars.append(( self.realType("size_t", pointer, const),
+                          self.len_name ))
+
+        return vars
+
+    def names(self, pointer=False, const=False):
+        """Variable name.
+
+        Returns a list containing a single string; the name given when creating
+        the instance.
+        """
+        names = [ self.name ]
+        if not self.type.c_type.endswith("*"):
+            names.append(self.len_name)
+
+        return names
+
+    def marshal(self, iter_name, parent, type_error, mem_error,
+                pointer=False, const=False):
+        """Marshalling code.
+
+        Returns a string containing the code that will marshal from an
+        iterator with the name given into local variables with the
+        types and names as returned by vars().
+        """
+        name = self.name
+        len_name = self.len_name
+        if pointer:
+            name = "*%s" % (name, )
+            if not self.type.c_type.endswith("*"):
+                len_name = "*%s" % (len_name, )
+
+        code = """\
+if (dbus_message_iter_get_arg_type (&%s) != %s) {
+%s
+}
+
+if (dbus_message_iter_get_element_type (&%s) != %s) {
+%s
+}
+
+dbus_message_iter_recurse (&%s, &%s);
+
+%s = NULL;
+%s = 0;
+
+while (dbus_message_iter_get_arg_type (&%s) != DBUS_TYPE_INVALID) {
+""" % (iter_name, self.dbus_type, type_error,
+       iter_name, self.type.dbus_type, type_error,
+       iter_name, self.iter_name,
+       name, len_name,
+       self.iter_name)
+
+        vars = self.type.vars()
+        vars.extend(self.type.locals())
+        code += indent(''.join("%s;\n" % var for var in lineup_vars(vars)), 1)
+
+        code += "\n"
+        code += indent(self.type.marshal("%s_iter" % self.name, parent,
+                                         type_error, mem_error), 1)
+
+        code += "\n"
+        code += indent("""\
+%s = nih_realloc (%s, %s, sizeof (%s) * ((%s) + 1));
+if (! %s) {
+%s
+}
+
+(%s)[(%s)++] = %s;
+""" % (name, name, parent, self.type.c_type, len_name,
+       name, mem_error,
+       name, len_name, self.type.name), 1)
+
+        code += "\n"
+        code += """\
+}
+
+dbus_message_iter_next (&%s);
+""" % (iter_name, )
+
+        if self.type.c_type.endswith("*"):
+            code += "\n"
+            code += """\
+%s = nih_realloc (%s, %s, sizeof (%s) * ((%s) + 1));
+if (! %s) {
+%s
+}
+
+(%s)[(%s)] = NULL;
+""" % (name, name, parent, self.type.c_type, len_name,
+       name, mem_error,
+       name, len_name)
+
+        return code
+
+    def dispatch(self, iter_name, mem_error,
+                 pointer=False, const=False):
+        """Dispatching code.
+
+        Returns a string containing the code that will dispatch from
+        local variables with the types and names as returned by vars() to
+        an iterator with the name given.
+        """
+        name = self.name
+        len_name = self.len_name
+        if pointer:
+            name = "*%s" % (name, )
+            if not self.type.c_type.endswith("*"):
+                len_name = "*%s" % (len_name, )
+
+        code = """\
+if (! dbus_message_iter_open_container (&%s, %s, \"%s\", &%s)) {
+%s
+}
+""" % (iter_name, self.dbus_type, self.type.signature(),
+       self.iter_name, mem_error)
+
+	code += "\n"
+	if self.type.c_type.endswith("*"):
+            code += """\
+%s = 0;
+for (%s%s = %s; %s && *%s; %s++) {
+""" % (len_name,
+       self.realType(self.c_type, const=const), self.loop_name, name,
+       self.loop_name, self.loop_name,
+       self.loop_name)
+        else:
+            code += """\
+for (%s%s = %s; %s < %s + %s; %s++) {
+""" % (self.realType(self.c_type, const=const), self.loop_name, name,
+       self.loop_name, name, len_name, self.loop_name)
+
+        vars = self.type.vars()
+        vars.extend(self.type.locals())
+        code += indent(''.join("%s;\n" % var for var in lineup_vars(vars)), 1)
+
+        code += "\n"
+        code += indent("""\
+%s = *%s;
+""" % (self.type.name, self.loop_name), 1)
+
+        code += "\n"
+        code += indent(self.type.dispatch(self.iter_name, mem_error), 1)
+
+	if self.type.c_type.endswith("*"):
+            code += "\n"
+            code += indent("""\
+(%s)++;
+""" % (len_name, ), 1)
+
+        code += """\
+}
+
+if (! dbus_message_iter_close_container (&%s, &%s)) {
+%s
+}
+""" % (iter_name, self.iter_name, mem_error)
+
+        return code
+
+
+class DBusGroup(object):
+    def __init__(self, types, pointer=False, const=False):
+        self.types = types
+        self.pointer = pointer
+        self.const = const
+
+    def signature(self):
+        """Type signature.
+
+        Returns a string containing the D-Bus type signature for this type.
+        """
+        signature = ""
+
+        for type in self.types:
+            signature += type.signature(pointer=self.pointer, const=self.const)
+
+        return signature
+
+    def vars(self):
+        """Variable type and name.
+
+        Returns a list containing tuples of C type and name for each type
+        within this group.
+        """
+        vars = []
+
+        for type in self.types:
+            vars.extend(type.vars(pointer=self.pointer, const=self.const))
+
+        return vars
+
+    def names(self):
+        """Variable names.
+
+        Returns a list of names of all types in this group.
+        """
+        names = []
+
+        for type in self.types:
+            names.extend(type.names())
+        return names
+
+    def locals(self):
+        """Local variable type and name.
+
+        Returns a list containing necessary local variables for iteration
+        of this type.
+        """
+        locals = []
+
+        for type in self.types:
+            locals.extend(type.locals(pointer=self.pointer, const=self.const))
+
+        return locals
+
+    def marshal(self, iter_name, parent, type_error, mem_error):
+        """Marshalling code.
+
+        Returns a string containing the code that will marshal from an
+        iterator with the name given into local variables with the
+        types and names as returned by vars().
+        """
+        code = ""
+
+        for type in self.types:
+            if code:
+                code += "\n"
+            code += type.marshal(iter_name, parent, type_error, mem_error,
+                                 pointer=self.pointer, const=self.const)
+
+        if code:
+            code += "\n"
+        code += """\
+if (dbus_message_iter_get_arg_type (&%s) != DBUS_TYPE_INVALID) {
+%s
+}
+""" % (iter_name, type_error)
+
+        return code
+
+    def dispatch(self, iter_name, mem_error):
+        """Dispatching code.
+
+        Returns a string containing the code that will dispatch from
+        local variables with the types and names as returned by vars() to
+        an iterator with the name given.
+        """
+        code = ""
+
+        for type in self.types:
+            if code:
+                code += "\n"
+            code += type.dispatch(iter_name, mem_error,
+                                  pointer=self.pointer, const=self.const)
+
+        return code
+
+
+class Generator(object):
+    def staticPrototypes(self):
+        """Static prototypes.
+
+        Returns an array of static function prototypes which are normally
+        placed in a block at the top of the source file.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        return []
+
+    def exportTypedefs(self):
+        """Exported typedefs.
+
+        Type definitions that should be placed in the header.
+
+        Each typedef is the code to define it, including any documentation and
+        default value.
+        """
+        return []
+
+    def externPrototypes(self):
+        """Extern prototypes.
+
+        Returns an array of extern function prototypes which are normally
+        placed in a block at the top of the source file, in lieu of
+        missing headers.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        return []
+
+    def variables(self):
+        """Variables.
+
+        Returns an array of both static and exported global variables
+        normally placed in a block at the top of the source file.
+
+        Each variable is the code to define it, including any documentation
+        and default value.
+        """
+        return []
+
+    def functions(self):
+        """Functions.
+
+        Returns an array of both static and exported functions which
+        consistute the bulk of the source file.
+
+        Each function is the code to define it, including any documentation.
+        """
+        return []
+
+    def definitions(self):
+        """Definitions.
+
+        Returns an array of structure and type definitions which are
+        normally placed in a block in the header file.
+
+        Each definition is the code to define it, including any documentation.
+        """
+        return []
+
+    def exports(self):
+        """Exports.
+
+        Returns an array of prototypes for exported variables which are
+        placed as a block inside the extern part of the header file.
+
+        Each export is a (type, name) tuple.
+        """
+        return []
+
+    def exportPrototypes(self):
+        """Function prototypes.
+
+        Returns an array of exported function prototypes which are normally
+        placed in a block inside the extern part of the header file.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        return []
+
+
+class Member(Generator):
+    def __init__(self, interface, name):
+        self.interface = interface
+        self.name = name
+
+    @property
+    def c_name(self):
+        return self.name
+
+    @property
+    def extern_name(self):
+        return "_".join(( extern_prefix,
+                          NAME_RE.sub("\\1_\\2", self.c_name).lower()))
+
+
+class MemberWithArgs(Member):
+    @classmethod
+    def fromElement(cls, interface, elem):
+        name = elem.get("name")
+        if name is None:
+            raise AttributeError, "Name may not be null"
+
+        types = [ DBusType.fromElement(e) for e in elem.findall("arg") ]
+
+        self = cls(interface, name, types)
+        self.style = elem.get(ElementTree.QName(XMLNS, mode), self.style)
+        return self
+
+    def __init__(self, interface, name, types):
+        super(MemberWithArgs, self).__init__(interface, name)
+
+        self.style = "sync"
+        self.types = types
+
+    def argArray(self):
+        """Argument array.
+
+        Returns a string containing code to initialise the array of arguments
+        used for nih_dbus_object_new().
+        """
+        code = """\
+static const NihDBusArg %s[] = {
+""" % "_".join([ self.interface.c_name, self.c_name, "args" ])
+
+        array = []
+        for type in self.types:
+            if type.direction == "in":
+                direction = "NIH_DBUS_ARG_IN"
+            elif type.direction == "out":
+                direction = "NIH_DBUS_ARG_OUT"
+
+            array.append(( "\"%s\"" % type.name,
+                           "\"%s\"" % type.signature(),
+                           direction ))
+
+        for line in lineup_array(array):
+            code += indent("%s,\n" % line, 1)
+
+        code += """\
+	{ NULL }
+};
+"""
+        return code
+
+    def variables(self):
+        """Variables.
+
+        Returns an array of both static and exported global variables
+        normally placed in a block at the top of the source file.
+
+        Each variable is the code to define it, including any documentation
+        and default value.
+        """
+        variables = []
+        if mode == "object":
+            variables.append(self.argArray())
+
+        return variables
+
+
+class Method(MemberWithArgs):
+    def __init__(self, interface, name, types):
+        super(Method, self).__init__(interface, name, types)
+
+    def marshalPrototype(self):
+        """Marshalling function prototype.
+
+        Returns a (retval, name, args, attributes) tuple for the prototype
+        of the marshaller function.
+        """
+        return ( "static DBusHandlerResult",
+                 "_".join([ self.interface.c_name, self.c_name, "marshal" ]),
+                 [ ( "NihDBusObject *", "object" ),
+                   ( "NihDBusMessage *", "message" ) ],
+                 None )
+
+    def marshalFunction(self):
+        """Marshalling function.
+
+        Returns a string containing a marshaller function that takes
+        arguments from a D-Bus message, calls a C handler function with
+        them passed properly, then constructs a reply if successful.
+        """
+        in_args = DBusGroup([t for t in self.types if t.direction == "in"])
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"])
+
+        name = "_".join([ self.interface.c_name, self.c_name, "marshal" ])
+        code = """\
+static DBusHandlerResult
+%s (NihDBusObject  *object,
+%s  NihDBusMessage *message)
+{
+""" % (name, " " * len(name))
+
+        # Declare local variables for the iterator, reply and those needed
+        # for both input and output arguments.
+        vars = [ ( "DBusMessageIter", "iter" ),
+                 ( "DBusMessage *", "reply = NULL" ) ]
+        vars.extend(in_args.vars())
+        vars.extend(in_args.locals())
+        if self.style != "async":
+            vars.extend(out_args.vars())
+            vars.extend(out_args.locals())
+
+        code += indent(''.join("%s;\n" % var for var in lineup_vars(vars)), 1)
+
+        # Pre-amble for the function
+        code += "\n"
+        code += indent("""\
+nih_assert (object != NULL);
+nih_assert (message != NULL);
+""", 1);
+
+        # Marshal the input arguments into local variables
+        code += "\n"
+        code += indent("""\
+/* Iterate the arguments to the message and marshal into arguments
+ * for our own function call.
+ */
+dbus_message_iter_init (message->message, &iter);
+""", 1)
+        code += "\n"
+
+        mem_error = indent("""\
+return DBUS_HANDLER_RESULT_NEED_MEMORY;
+""", 1)
+        type_error = indent("""\
+reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
+				_("Invalid arguments to %s method"));
+if (! reply) {
+%s
+}
+
+goto send;
+""" % (self.name, mem_error), 1)
+        code += indent(in_args.marshal("iter", "message",
+                                       type_error, mem_error), 1)
+
+        # Construct the function call
+        args = [ "object->data", "message" ]
+        args.extend(n for t, n in in_args.vars())
+        if self.style != "async":
+            args.extend("&%s" % n for t, n in out_args.vars())
+
+        code += "\n"
+        code += indent("""\
+/* Call the handler function. */
+if (%s (%s) < 0) {
+	NihError *err;
+
+	err = nih_error_get ();
+	if (err->number == ENOMEM) {
+		nih_free (err);
+
+		return DBUS_HANDLER_RESULT_NEED_MEMORY;
+	} else if (err->number == NIH_DBUS_ERROR) {
+		NihDBusError *dbus_err = (NihDBusError *)err;
+
+		reply = dbus_message_new_error (message->message,
+						dbus_err->name,
+						err->message);
+		nih_free (err);
+
+		if (! reply)
+			return DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+		goto send;
+	} else {
+		reply = dbus_message_new_error (message->message,
+						DBUS_ERROR_FAILED,
+						err->message);
+		nih_free (err);
+
+		if (! reply)
+			return DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+		goto send;
+	}
+}
+""" % (self.extern_name, ", ".join(args)), 1)
+
+        if self.style == "async":
+            code += "\n"
+            code += indent("return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;\n", 1)
+        else:
+            # Be well-behaved and make the function return immediately
+            # if no reply is expected
+            code += "\n"
+            code += indent("""\
+/* If the sender doesn't care about a reply, don't bother wasting
+ * effort constructing and sending one.
+ */
+if (dbus_message_get_no_reply (message->message))
+	return DBUS_HANDLER_RESULT_HANDLED;
+""", 1)
+
+            # Create reply and dispatch the local variables into output
+            # arguments
+            code += "\n"
+            code += indent("""\
+/* Construct the reply message */
+reply = dbus_message_new_method_return (message->message);
+if (! reply)
+	return DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+dbus_message_iter_init_append (reply, &iter);
+""", 1)
+            code += "\n"
+
+            mem_error = indent("""\
+dbus_message_unref (reply);
+return DBUS_HANDLER_RESULT_NEED_MEMORY;
+""", 1)
+            code += indent(out_args.dispatch("iter", mem_error), 1)
+
+        # Send the reply
+        code += "\nsend:\n"
+        code += indent("""\
+/* Send the reply, appending it to the outgoing queue. */
+if (! dbus_connection_send (message->conn, reply, NULL)) {
+	dbus_message_unref (reply);
+	return DBUS_HANDLER_RESULT_NEED_MEMORY;
+}
+
+dbus_message_unref (reply);
+
+return DBUS_HANDLER_RESULT_HANDLED;
+""", 1)
+
+        code += "}\n"
+
+        return code
+
+    def handlerPrototype(self):
+        """Handler function prototype.
+
+        Returns a (retval, name, args, attributes) tuple for the prototype
+        of the handler function that the user must define.
+        """
+        in_args = DBusGroup([t for t in self.types if t.direction == "in"],
+                            const=True)
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"],
+                             pointer=True)
+
+        vars = [ ("void *", "data"),
+                 ("NihDBusMessage *", "message") ]
+        vars.extend(in_args.vars())
+        if self.style != "async":
+            vars.extend(out_args.vars())
+
+        return ( "extern int",
+                 self.extern_name,
+                 vars,
+                 None )
+
+    def replyPrototype(self):
+        """Reply function prototype.
+
+        Returns a (retval, name, args, attributes) tuple for the prototype
+        of the reply function defined for async functions.
+        """
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"],
+                             const=True)
+
+        vars = [("NihDBusMessage *", "message") ]
+        vars.extend(out_args.vars())
+
+        return ( "int",
+                 "_".join([ self.extern_name, "reply" ]),
+                 vars,
+                 None )
+
+    def replyFunction(self):
+        """Reply function.
+
+        Returns a string containing a reply function that takes its
+        arguments and produces a D-Bus message reply.
+        """
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"],
+                             const=True)
+
+        name = "_".join([ self.extern_name, "reply" ])
+        vars = [ ( "NihDBusMessage *", "message" ) ]
+        vars.extend(out_args.vars())
+
+        code = "int\n%s (" % (name, )
+        code += (",\n" + " " * (len(name) + 2)).join(lineup_vars(vars))
+        code += ")\n{\n"
+
+        # Declare local variables for the iterator and the reply
+        vars = [ ( "DBusMessageIter", "iter" ),
+                 ( "DBusMessage *", "reply = NULL" ) ]
+        vars.extend(out_args.locals())
+
+        code += indent(''.join("%s;\n" % var for var in lineup_vars(vars)), 1)
+
+        # Pre-amble for the function
+        code += "\n"
+        code += indent("""\
+nih_assert (message != NULL);
+""", 1);
+
+        # Be well-behaved and don't actually send the reply if one is
+        # not expected
+        code += "\n"
+        code += indent("""\
+/* If the sender doesn't care about a reply, don't bother wasting
+ * effort constructing and sending one.
+ */
+if (dbus_message_get_no_reply (message->message)) {
+	nih_free (message);
+	return 0;
+}
+""", 1)
+
+        # Create reply and dispatch the local variables into output
+        # arguments
+        code += "\n"
+        code += indent("""\
+/* Construct the reply message */
+reply = dbus_message_new_method_return (message->message);
+if (! reply)
+	return -1;
+
+dbus_message_iter_init_append (reply, &iter);
+""", 1)
+        code += "\n"
+
+        mem_error = indent("""\
+dbus_message_unref (reply);
+return -1;
+""", 1)
+        code += indent(out_args.dispatch("iter", mem_error), 1)
+
+        # Send the reply
+        code += "\n"
+        code += indent("""\
+/* Send the reply, appending it to the outgoing queue. */
+if (! dbus_connection_send (message->conn, reply, NULL)) {
+	dbus_message_unref (reply);
+	return -1;
+}
+
+dbus_message_unref (reply);
+nih_free (message);
+
+return 0;
+""", 1)
+
+        code += "}\n"
+
+        return code
+
+    def asyncNotifyPrototype(self):
+        """Asynchronous dispatch function prototype.
+
+        Returns a (retval, name, args, attributes) tuple for the prototype
+        of the asynchronous dispatch function.
+        """
+        vars = [ ( "DBusPendingCall *", "call" ),
+                ( "NihAsyncNotifyData *", "data" ) ]
+
+        return ( "static void",
+                 self.extern_name + "_async_notify",
+                 vars, ( ) )
+
+    def asyncDispatchPrototype(self):
+        """Asynchronous dispatch function prototype.
+
+        Returns a (retval, name, args, attributes) tuple for the prototype
+        of the asynchronous dispatch function.
+        """
+        in_args = DBusGroup([t for t in self.types if t.direction == "in"],
+                            const=True)
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"])
+
+        vars =  [ ( "NihDBusProxy *", "proxy" ) ]
+        vars.extend(in_args.vars())
+        vars += [ ( "%sCallback" % camelate(self.extern_name), "callback" ),
+                  ( "%sErrback" % camelate(self.extern_name), "errback" ),
+                  ( "void *", "userdata" ) ]
+
+        return ( "int",
+                 self.extern_name + "_async",
+                 vars,
+                 ( "warn_unused_result", ) )
+
+    def dispatchPrototype(self):
+        """Dispatch function prototype.
+
+        Returns a (retval, name, args, attributes) tuple for the prototype
+        of the dispatch function.
+        """
+        in_args = DBusGroup([t for t in self.types if t.direction == "in"],
+                            const=True)
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"],
+                             pointer=True)
+
+        vars = [ ( "NihDBusProxy *", "proxy" ) ]
+        vars.extend(in_args.vars())
+        # FIXME async doesn't have these, but has a callback instead
+        vars.extend(out_args.vars())
+
+        return ( "int",
+                 self.extern_name,
+                 vars,
+                 ( "warn_unused_result", ) )
+
+    def asyncNotifyFunction(self):
+        """Asynchronous notification function.
+
+        Called when an asynchronously dispatched function returns something.
+        Fetches out the arguments and passes them to a user-supplied function.
+        """
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"])
+
+        vars = [ ( "DBusPendingCall *", "call" ),
+                ( "NihAsyncNotifyData *", "data" ) ]
+
+        code = "static void\n%s (" % (self.extern_name + "_async_notify", )
+        code += (",\n" + " " * (len(self.extern_name + "_async_notify") + 2)).join(lineup_vars(vars))
+        code += ")\n{\n"
+
+        # Declare local variables for the iterator, reply and those needed
+        # for both input and output arguments.
+        vars = [ ( "DBusMessage *", "reply" ),
+                 ( "DBusMessageIter", "iter" ),
+                 ( "int", "type" ) ]
+        vars.extend(out_args.locals())
+        vars.extend(out_args.vars())
+        code += indent(''.join("%s;\n" % var for var in lineup_vars(vars)), 1)
+
+        # Pre-amble for the function
+        code += "\n"
+
+        code += indent("""\
+reply = dbus_pending_call_steal_reply(call);
+
+nih_assert (reply != NULL);
+
+type = dbus_message_get_type (reply);
+
+nih_assert (type == DBUS_MESSAGE_TYPE_METHOD_RETURN ||
+	    type == DBUS_MESSAGE_TYPE_ERROR);
+
+if (type == DBUS_MESSAGE_TYPE_ERROR) {
+	char *name;
+	DBusError error;
+
+	dbus_error_init (&error);
+	dbus_set_error_from_message (&error, reply);
+
+	if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) {
+		errno = ENOMEM;
+		nih_error_raise_system ();
+	} else {
+		nih_dbus_error_raise (error.name, error.message);
+	}
+
+	((%sErrback)data->err_handler)(data->proxy, data->userdata);
+
+	dbus_error_free (&error);
+	goto out;
+}
+""" % camelate(self.extern_name), 1);
+
+        # Marshal the reply arguments into output arguments
+        code += "\n"
+        code += indent("""\
+/* Iterate the arguments to the reply and marshal into output
+ * arguments from our own function call.
+ */
+dbus_message_iter_init (reply, &iter);
+""", 1);
+        code += "\n"
+
+        mem_error = indent("""\
+errno = ENOMEM;
+nih_error_raise_system ();
+((%sErrback)data->err_handler)(data->proxy, data->userdata);
+goto out;
+""" % camelate(self.extern_name), 1)
+        type_error = indent("""\
+nih_error_raise (NIH_DBUS_INVALID_ARGS, NIH_DBUS_INVALID_ARGS_STR);
+((%sErrback)data->err_handler)(data->proxy, data->userdata);
+goto out;
+""" % camelate(self.extern_name), 1);
+        code += indent(out_args.marshal("iter", "data->proxy",
+                                        type_error, mem_error), 1)
+
+        code += "\n\n"
+        code += indent("""\
+((%sCallback)data->handler)(%s);
+""" % (camelate(self.extern_name), ", ".join([ "data->proxy", "data->userdata" ] + out_args.names())), 1)
+
+        code += "out:\n"
+        code += indent("""\
+
+dbus_message_unref (reply);
+dbus_pending_call_unref (call);
+
+return;
+""", 1)
+
+        code += "}\n"
+
+        return code
+
+    def asyncDispatchFunction(self):
+        """Asynchronous dispatching function.
+
+        Returns a string containing a dispatcher function that takes arguments
+        identical to those taken by a particular dbus method, and pointers to
+        variables where the return values from that method might be stored. Then
+        sends a dbus message and waits for a reply to come, and populates the
+        reply arguments with the contents of the reply message.
+        """
+        in_args = DBusGroup([t for t in self.types if t.direction == "in"],
+                            const=True)
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"])
+
+        vars =  [ ( "NihDBusProxy *", "proxy" ) ]
+        vars.extend(in_args.vars())
+        vars += [ ( "%sCallback" % camelate(self.extern_name), "callback" ),
+                  ( "%sErrback" % camelate(self.extern_name), "errback" ),
+                  ( "void *", "userdata" ) ]
+
+        code = "int\n%s (" % (self.extern_name + "_async", )
+        code += (",\n" + " " * (len(self.extern_name + "_async") + 2)).join(lineup_vars(vars))
+        code += ")\n{\n"
+
+        # Declare local variables for the iterator, reply and those needed
+        # for both input and output arguments.
+        vars = [ ( "DBusMessage *", "message" ),
+                 ( "DBusMessageIter", "iter" ),
+                 ( "DBusPendingCall *", "call" ),
+                 ( "NihAsyncNotifyData *", "data" ) ]
+        vars.extend(in_args.locals())
+        code += indent(''.join("%s;\n" % var for var in lineup_vars(vars)), 1)
+
+        # Pre-amble for the function
+        code += "\n"
+        code += indent("""\
+nih_assert (proxy != NULL);
+nih_assert ((errback != NULL && callback != NULL) ||
+	    (errback == NULL && callback == NULL));
+""", 1);
+
+        # Dispatch the input arguments into a new local message
+        code += "\n"
+        code += indent("""\
+message = dbus_message_new_method_call (proxy->name, proxy->path, "%s", "%s");
+if (! message)
+	nih_return_no_memory_error (-1);
+
+/* Iterate the arguments to the function and dispatch into
+ * message arguments.
+ */
+dbus_message_iter_init_append (message, &iter);
+""" % (self.interface.name, self.name), 1)
+        code += "\n"
+
+        # FIXME autostart?
+
+        mem_error = indent("""\
+dbus_message_unref (message);
+nih_return_no_memory_error (-1);
+""", 1)
+        code += indent(in_args.dispatch("iter", mem_error), 1)
+
+        # FIXME timeout should be configurable
+        # FIXME expect no reply?
+        code += "\n"
+        code += indent("""\
+/* If we don't specify a callback, just finish it now */
+if (! callback) {
+	dbus_bool_t succ = dbus_connection_send (proxy->conn, message, NULL);
+	dbus_message_unref (message);
+	if (! succ)
+		nih_return_no_memory_error (-1);
+	return 0;
+}
+
+/* Send the reply, appending it to the outgoing queue and blocking. */
+if (! dbus_connection_send_with_reply (proxy->conn, message, &call, -1)) {
+	dbus_message_unref (message);
+        nih_return_no_memory_error (-1);
+}
+
+data = nih_new (proxy, NihAsyncNotifyData);
+if (! data)
+	nih_return_no_memory_error (-1);
+
+data->proxy       = proxy;
+data->userdata    = userdata;
+data->handler     = callback;
+data->err_handler = errback;
+
+
+dbus_pending_call_set_notify(call, (DBusPendingCallNotifyFunction)%s_async_notify, data, (DBusFreeFunction)nih_free);
+
+dbus_message_unref (message);
+return 0;
+""" % self.extern_name, 1);
+
+        code += "}\n"
+
+        return code
+
+    def dispatchFunction(self):
+        """Dispatching function.
+
+        Returns a string containing a dispatcher function that takes arguments
+        identical to those taken by a particular dbus method, and pointers to
+        variables where the return values from that method might be stored. Then
+        sends a dbus message and waits for a reply to come, and populates the
+        reply arguments with the contents of the reply message.
+        """
+        in_args = DBusGroup([t for t in self.types if t.direction == "in"],
+                            const=True)
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"],
+                             pointer=True)
+
+        vars = [ ( "NihDBusProxy *", "proxy" ) ]
+        vars.extend(in_args.vars())
+        # FIXME async doesn't have these, but has a callback instead
+        vars.extend(out_args.vars())
+
+        code = "int\n%s (" % (self.extern_name, )
+        code += (",\n" + " " * (len(self.extern_name) + 2)).join(lineup_vars(vars))
+        code += ")\n{\n"
+
+        # Declare local variables for the iterator, reply and those needed
+        # for both input and output arguments.
+        vars = [ ( "DBusMessage *", "message" ),
+                 ( "DBusMessageIter", "iter" ),
+                 ( "DBusMessage *", "reply = NULL" ),
+                 ( "DBusError", "error" ) ]
+        vars.extend(in_args.locals())
+        # FIXME not for async
+        vars.extend(out_args.locals())
+        code += indent(''.join("%s;\n" % var for var in lineup_vars(vars)), 1)
+
+        # Pre-amble for the function
+        code += "\n"
+        code += indent("""\
+nih_assert (proxy != NULL);
+""", 1);
+
+        # Dispatch the input arguments into a new local message
+        code += "\n"
+        code += indent("""\
+message = dbus_message_new_method_call (proxy->name, proxy->path, "%s", "%s");
+if (! message)
+	nih_return_no_memory_error (-1);
+
+/* Iterate the arguments to the function and dispatch into
+ * message arguments.
+ */
+dbus_message_iter_init_append (message, &iter);
+""" % (self.interface.name, self.name), 1)
+        code += "\n"
+
+        # FIXME autostart?
+
+        mem_error = indent("""\
+dbus_message_unref (message);
+nih_return_no_memory_error (-1);
+""", 1)
+        code += indent(in_args.dispatch("iter", mem_error), 1)
+
+        # FIXME timeout should be configurable
+        # FIXME expect no reply?
+        code += "\n"
+        code += indent("""\
+dbus_error_init (&error);
+
+/* Send the reply, appending it to the outgoing queue and blocking. */
+reply = dbus_connection_send_with_reply_and_block (proxy->conn, message, -1, &error);
+if (! reply) {
+	dbus_message_unref (message);
+
+	if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) {
+		dbus_error_free (&error);
+		nih_return_no_memory_error (-1);
+	} else {
+		nih_dbus_error_raise (error.name, error.message);
+		dbus_error_free (&error);
+		return -1;
+	}
+}
+
+dbus_message_unref (message);
+""", 1);
+
+        # Marshal the reply arguments into output arguments
+        code += "\n"
+        code += indent("""\
+/* Iterate the arguments to the reply and marshal into output
+ * arguments from our own function call.
+ */
+dbus_message_iter_init (reply, &iter);
+""", 1);
+        code += "\n"
+
+        mem_error = indent("""\
+dbus_message_unref (reply);
+nih_return_no_memory_error (-1);
+""", 1)
+        type_error = indent("""\
+dbus_message_unref (reply);
+nih_return_error (-1, NIH_DBUS_INVALID_ARGS, NIH_DBUS_INVALID_ARGS_STR);
+""", 1);
+        code += indent(out_args.marshal("iter", "proxy",
+                                        type_error, mem_error), 1)
+
+        code += "\n"
+        code += indent("""\
+dbus_message_unref (reply);
+
+return 0;
+""", 1)
+
+        code += "}\n"
+
+        return code
+
+    def exportTypedefs(self):
+        """Exported typedefs.
+
+        Type definitions that should be placed in the header.
+
+        Each typedef is the code to define it, including any documentation and
+        default value.
+        """
+        typedefs = []
+        out_args = DBusGroup([t for t in self.types if t.direction == "out"])
+        if mode == "proxy":
+            typedefs.append( ("void",
+                              "(*%sCallback)" % camelate(self.extern_name),
+                              [ ( "NihDBusProxy *", "proxy" ),
+                                ( "void *", "userdata") ] + out_args.vars()
+                           ) )
+            typedefs.append( ("void",
+                              "(*%sErrback)" % camelate(self.extern_name),
+                              [ ( "NihDBusProxy *", "proxy" ),
+                                ( "void *", "userdata") ]
+                           ) )
+        return typedefs
+
+    def staticPrototypes(self):
+        """Static prototypes.
+
+        Returns an array of static function prototypes which are normally
+        placed in a block at the top of the source file.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        prototypes = []
+        if mode == "object":
+            prototypes.append(self.marshalPrototype())
+        else:
+            prototypes.append(self.asyncNotifyPrototype())
+
+        return prototypes
+
+    def externPrototypes(self):
+        """Extern prototypes.
+
+        Returns an array of extern function prototypes which are normally
+        placed in a block at the top of the source file, in lieu of
+        missing headers.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        prototypes = []
+        if mode =="object":
+            prototypes.append(self.handlerPrototype())
+
+        return prototypes
+
+    def functions(self):
+        """Functions.
+
+        Returns an array of both static and exported functions which
+        consistute the bulk of the source file.
+
+        Each function is the code to define it, including any documentation.
+        """
+        functions = []
+        if mode == "object":
+            functions.append(self.marshalFunction())
+            if self.style == "async":
+                functions.append(self.replyFunction())
+        else:
+            functions.append(self.dispatchFunction())
+            functions.append(self.asyncDispatchFunction())
+            functions.append(self.asyncNotifyFunction())
+
+        return functions
+
+    def exportPrototypes(self):
+        """Function prototypes.
+
+        Returns an array of exported function prototypes which are normally
+        placed in a block inside the extern part of the header file.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        prototypes = []
+        if mode == "object":
+            if self.style == "async":
+                prototypes.append(self.replyPrototype())
+        else:
+            prototypes.append(self.dispatchPrototype())
+            prototypes.append(self.asyncDispatchPrototype())
+
+        return prototypes
+
+
+class Signal(MemberWithArgs):
+    def __init__(self, interface, name, types):
+        super(Signal, self).__init__(interface, name, types)
+
+    def dispatchPrototype(self):
+        """Dispatch function prototype.
+
+        Returns a (retval, name, args, attributes) tuple for the prototype
+        of the dispatch function.
+        """
+        args = DBusGroup(self.types, const=True)
+
+        vars = [ ( "DBusConnection *", "connection" ),
+                 ( "const char *", "origin_path" ) ]
+        vars.extend(args.vars())
+
+        return ( "int",
+                 self.extern_name,
+                 vars,
+                 ( "warn_unused_result", ) )
+
+    def dispatchFunction(self):
+        """Dispatch function.
+
+        Returns a string containing a dispatch function that takes puts
+        its arguments into a D-Bus message and sends it.
+        """
+        args = DBusGroup(self.types, const=True)
+
+        vars = [ ( "DBusConnection *", "connection" ),
+                 ( "const char *", "origin_path" ) ]
+        vars.extend(args.vars())
+
+        code = "int\n%s (" % (self.extern_name, )
+        code += (",\n" + " " * (len(self.extern_name) + 2)).join(lineup_vars(vars))
+        code += ")\n{\n"
+
+        # Declare local variables for the message and iterator
+        vars = [ ( "DBusMessage *", "message"),
+                 ( "DBusMessageIter", "iter" ) ]
+        vars.extend(args.locals())
+        code += indent(''.join("%s;\n" % var for var in lineup_vars(vars)), 1)
+
+        # Pre-amble for the function
+        code += "\n"
+        code += indent("""\
+nih_assert (connection != NULL);
+nih_assert (origin_path != NULL);
+""", 1)
+
+        # Marshal the arguments into a new local message
+        code += "\n"
+        code += indent("""\
+message = dbus_message_new_signal (origin_path, "%s", "%s");
+if (! message)
+	return -1;
+
+/* Iterate the arguments to the function and dispatch into
+ * message arguments.
+ */
+dbus_message_iter_init_append (message, &iter);
+""" % (self.interface.name, self.name), 1)
+        code += "\n"
+
+        mem_error = indent("""\
+dbus_message_unref (message);
+return -1;
+""", 1)
+        code += indent(args.dispatch("iter", mem_error), 1)
+
+        code += "\n"
+        code += indent("""\
+/* Send the reply, appending it to the outgoing queue. */
+if (! dbus_connection_send (connection, message, NULL)) {
+	dbus_message_unref (message);
+	return -1;
+}
+
+dbus_message_unref (message);
+
+return 0;
+""", 1)
+
+        code += "}\n"
+
+        return code
+
+    def functions(self):
+        """Functions.
+
+        Returns an array of both static and exported functions which
+        consistute the bulk of the source file.
+
+        Each function is the code to define it, including any documentation.
+        """
+        functions = []
+        if mode == "object":
+            functions.append(self.dispatchFunction())
+
+        return functions
+
+    def exportPrototypes(self):
+        """Function prototypes.
+
+        Returns an array of exported function prototypes which are normally
+        placed in a block inside the extern part of the header file.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        prototypes = []
+        if mode == "object":
+            prototypes.append(self.dispatchPrototype())
+
+        return prototypes
+
+
+class Group(Generator):
+    def __init__(self, members):
+        self.members = members
+
+    def staticPrototypes(self):
+        """Static prototypes.
+
+        Returns an array of static function prototypes which are normally
+        placed in a block at the top of the source file.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        prototypes = []
+        for member in self.members:
+            prototypes.extend(member.staticPrototypes())
+
+        return prototypes
+
+    def externPrototypes(self):
+        """Extern prototypes.
+
+        Returns an array of extern function prototypes which are normally
+        placed in a block at the top of the source file, in lieu of
+        missing headers.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        prototypes = []
+        for member in self.members:
+            prototypes.extend(member.externPrototypes())
+
+        return prototypes
+
+    def exportTypedefs(self):
+        """Exported typedefs.
+
+        Type definitions that should be placed in the header.
+
+        Each typedef is the code to define it, including any documentation and
+        default value.
+        """
+        typedefs = []
+        for member in self.members:
+            typedefs.extend(member.exportTypedefs())
+
+        return typedefs
+
+    def variables(self):
+        """Variables.
+
+        Returns an array of both static and exported global variables
+        normally placed in a block at the top of the source file.
+
+        Each variable is the code to define it, including any documentation
+        and default value.
+        """
+        variables = []
+        for member in self.members:
+            variables.extend(member.variables())
+
+        return variables
+
+    def functions(self):
+        """Functions.
+
+        Returns an array of both static and exported functions which
+        consistute the bulk of the source file.
+
+        Each function is the code to define it, including any documentation.
+        """
+        functions = []
+        for member in self.members:
+            functions.extend(member.functions())
+
+        return functions
+
+    def definitions(self):
+        """Definitions.
+
+        Returns an array of structure and type definitions which are
+        normally placed in a block in the header file.
+
+        Each definition is the code to define it, including any documentation.
+        """
+        definitions = []
+        for member in self.members:
+            definitions.extend(member.definitions())
+
+        return definitions
+
+    def exports(self):
+        """Exports.
+
+        Returns an array of prototypes for exported variables which are
+        placed as a block inside the extern part of the header file.
+
+        Each export is a (type, name) tuple.
+        """
+        exports = []
+        for member in self.members:
+            exports.extend(member.exports())
+
+        return exports
+
+    def exportPrototypes(self):
+        """Function prototypes.
+
+        Returns an array of exported function prototypes which are normally
+        placed in a block inside the extern part of the header file.
+
+        Each prototype is a (retval, name, args, attributes) tuple.
+        """
+        prototypes = []
+        for member in self.members:
+            prototypes.extend(member.exportPrototypes())
+
+        return prototypes
+
+
+class Interface(Group):
+    @classmethod
+    def fromElement(cls, elem):
+        name = elem.get("name")
+        if name is None:
+            raise AttributeError, "Interface name may not be null"
+
+        self = cls(name, [])
+        for e in elem.findall("method"):
+            method = Method.fromElement(self, e)
+            self.methods.append(method)
+            self.members.append(method)
+        for e in elem.findall("signal"):
+            signal = Signal.fromElement(self, e)
+            self.signals.append(signal)
+            self.members.append(signal)
+
+        return self
+
+    def __init__(self, name, members):
+        super(Interface, self).__init__(members)
+
+        self.name = name
+        self.methods = []
+        self.signals = []
+
+    @property
+    def c_name(self):
+        return self.name.replace(".", "_")
+
+    def methodsArray(self):
+        """Methods array.
+
+        Returns a string containing code to initialise the array of methods
+        used for nih_dbus_object_new().
+        """
+        code = """\
+const NihDBusMethod %s_methods[] = {
+""" % self.c_name
+
+        array = []
+        for method in self.methods:
+            if mode == "object":
+                func = "%s_marshal" % "_".join([ self.c_name, method.c_name ])
+            else:
+                func = "NULL"
+
+            array.append(( "\"%s\"" % method.name,
+                           func,
+                           "%s_args" % "_".join([ self.c_name, method.c_name ])))
+
+        for line in lineup_array(array):
+            code += indent("%s,\n" % line, 1)
+
+        code += """\
+	{ NULL }
+};
+"""
+        return code
+
+    def signalsArray(self):
+        """Signals array.
+
+        Returns a string containing code to initialise the array of signals
+        used for nih_dbus_object_new().
+        """
+        code = """\
+const NihDBusSignal %s_signals[] = {
+""" % self.c_name
+
+        array = []
+        for signal in self.signals:
+            array.append(( "\"%s\"" % signal.name,
+                           "%s_args" % "_".join([ self.c_name, signal.c_name ])))
+
+        for line in lineup_array(array):
+            code += indent("%s,\n" % line, 1)
+
+        code += """\
+	{ NULL }
+};
+"""
+        return code
+
+    def interfacePrototype(self):
+        """Interface structure prototype.
+
+        Returns a (type, name) tuple for the prototype of the interface
+        struct.
+        """
+        return ( "const NihDBusInterface", "%s" % self.c_name )
+
+    def interfaceStruct(self):
+        """Interface structure.
+
+        Returns a string containing code to define a structure containing
+        information about the interface.
+        """
+        code = """\
+const NihDBusInterface %s = {
+	\"%s\",
+	%s_methods,
+	%s_signals,
+	NULL
+""" % (self.c_name, self.name, self.c_name, self.c_name)
+
+        code += """\
+};
+"""
+        return code
+
+    def variables(self):
+        """Variables.
+
+        Returns an array of both static and exported global variables
+        normally placed in a block at the top of the source file.
+
+        Each variable is the code to define it, including any documentation
+        and default value.
+        """
+        variables = super(Interface, self).variables()
+        if mode == "object":
+            variables.append(self.methodsArray())
+            variables.append(self.signalsArray())
+            variables.append(self.interfaceStruct())
+
+        return variables
+
+    def exports(self):
+        """Exports.
+
+        Returns an array of prototypes for exported variables which are
+        placed as a block inside the extern part of the header file.
+
+        Each export is a (type, name) tuple.
+        """
+        exports = super(Interface, self).exports()
+        if mode == "object":
+            exports.append(self.interfacePrototype())
+
+        return exports
+
+
+class Output(Group):
+    def __init__(self, basename, members):
+        super(Output, self).__init__(members)
+
+        self.basename = basename
+
+    def sourceFile(self):
+        """Generate source (.c) file.
+
+        Returns a string containing the code for the source (.c) file
+        of this code group.
+        """
+        code = """\
+/* %s
+ *
+ * %s - %s
+ *
+ * %s
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+""" % (PACKAGE_NAME, "%s.c" % self.basename, "Auto-generated d-bus bindings",
+       PACKAGE_COPYRIGHT)
+
+        # Usual includes
+        if code:
+            code += "\n"
+        code += """\
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+
+#include <dbus/dbus.h>
+
+#include <errno.h>
+
+#include <nih/macros.h>
+#include <nih/alloc.h>
+#include <nih/string.h>
+#include <nih/logging.h>
+#include <nih/error.h>
+#include <nih/errors.h>
+#include <nih/dbus.h>
+
+#include "%s.h"
+""" % (self.basename, )
+        if mode == "proxy":
+            if code:
+                code += "\n\n"
+            code += """\
+/**
+ * NihAsyncNotifyData:
+ * @handler: The user handler that our libnih handler should call,
+ * @userdata: Data to pass to @handler,
+ * @proxy: The proxy object to which the call was made.
+ *
+ * This structure contains information that is assembled during an asynchronous
+ * method call and passed to the handler on the method's return. It should never
+ * be used directly by the user.
+ **/
+typedef struct nih_async_notify_data {
+	void         *handler;
+	void         *err_handler;
+	void         *userdata;
+	NihDBusProxy *proxy;
+} NihAsyncNotifyData;"""
+        # Extern function prototypes
+        protos = self.externPrototypes()
+        if protos:
+            if code:
+                code += "\n\n"
+            code += """\
+/* Prototypes for handler functions */
+"""
+            for line in lineup_protos(protos):
+                code += line
+                code += ";\n"
+
+        # Static function prototypes
+        protos = self.staticPrototypes()
+        if protos:
+            if code:
+                code += "\n\n"
+            code += """\
+/* Prototypes for static functions */
+"""
+            for line in lineup_protos(protos):
+                code += line
+                code += ";\n"
+
+        # Global variables
+        variables = self.variables()
+        if variables:
+            if code:
+                code += "\n"
+            for g in variables:
+                if code:
+                    code += "\n"
+                code += g
+
+        # Function definitions
+        functions = self.functions()
+        if functions:
+            if code:
+                code += "\n"
+            for function in functions:
+                if code:
+                    code += "\n"
+                code += function
+
+        return code
+
+    def headerFile(self):
+        """Generate header (.h) file.
+
+        Returns a string containing the code for the header (.h) file
+        of this code group.
+        """
+        code = """\
+/* %s
+ *
+ * %s
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+""" % (PACKAGE_NAME, PACKAGE_COPYRIGHT)
+
+        # FIXME include sub-directory name in sentry?
+        sentry = "DBUS__%s_H" % self.basename.replace(".", "_").upper()
+        if code:
+            code += "\n"
+        code += """\
+#ifndef %s
+#define %s
+
+#include <dbus/dbus.h>
+
+#include <nih/macros.h>
+#include <nih/dbus.h>
+""" % (sentry, sentry)
+
+        # Append structure definitions
+        definitions = self.definitions()
+        if definitions:
+            if code:
+                code += "\n"
+            for definition in definitions:
+                if code:
+                    code += "\n"
+                code += definition
+
+        # Typedefs
+        typedefs = self.exportTypedefs()
+        if typedefs:
+            if code:
+                code += "\n\n"
+            for line in lineup_typedefs(typedefs):
+                code += line
+                code += "\n"
+
+        # Guard extern prototypes for C++ inclusion
+        if code:
+            code += "\n\n"
+        code += """\
+NIH_BEGIN_EXTERN
+"""
+
+        # Line up the variable prototypes together and place in a block
+        globals = self.exports()
+        if globals:
+            if code:
+                code += "\n"
+            for line in lineup_vars(globals):
+                code += line
+                code += ";\n"
+
+        # Line up the function prototypes together and place in a block
+        protos = self.exportPrototypes()
+        if protos:
+            if code:
+                code += "\n"
+            for line in lineup_protos(protos):
+                code += line
+                code += ";\n"
+
+        # End the extern guard and header sentry
+        if code:
+            code += "\n"
+        code += """\
+NIH_END_EXTERN
+
+#endif /* %s */
+""" % (sentry)
+
+        return code
+
+
+# Complex:
+#  s (struct) -> pointer to a struct of a defined type (named after func + arg)
+#       e.g. typedef struct job_find_by_name_what {
+#               ...
+#       } JobFindByNameWhat;
+#
+#    dbus_message_iter_recurse (ITER, SUB)
+#    OK = dbus_message_iter_close_container (ITER, SUB)
+#
+#    dbus_message_iter_open_container (ITER, TYPE, NULL, SUB)
+#    OK = dbus_message_iter_close_container (ITER, SUB)
+#
+# thus we can make arrays of it too :-)
+# struct-in-struct can just get arbitrary names
+#
+#
+# Annoying"
+#  v (variant) -> seems to be a problem
+#       has a type signature then the data
+#
+#  e (dict) -> problem for now (should be NihHash really)
+#       always arrays a{..}
+#       first type is basic
+#       second type is any (including struct)
+
+
+def lineup_vars(vars):
+    """Lineup variable lists.
+
+    Returns an array of lines of C code to declare each of the variables
+    in vars, which should be an array of (type, name) tuples.  The
+    declarations will be lined up in a pretty fashion.
+
+    It is up to the caller to add appropriate line-endings.
+    """
+    exp_vars = []
+    for type, name in vars:
+        basic = type.rstrip("*")
+        pointers = type[len(basic):]
+        basic = basic.rstrip()
+        exp_vars.append(( basic, pointers, name ))
+
+    if not exp_vars:
+        return []
+
+    max_basic = max(len(b) for b,p,n in exp_vars)
+    max_pointers = max(len(p) for b,p,n in exp_vars)
+
+    lines = []
+    for basic, pointers, name in exp_vars:
+        code = basic.ljust(max_basic)
+        code += pointers.rjust(max_pointers + 1)
+        code += name
+
+        lines.append(code)
+
+    return lines
+
+def typedef_lineup_prefix(type):
+    """Pads a type name on the left so indent starts past (*
+    
+    If a string begins with (* returns it. If it begins with * pad it on the
+    left with one space. If it begins with 0 pad with two spaces.
+    """
+    if type.startswith("(*"):
+        return type
+    if type.startswith("*"):
+        return " " + type
+    return "  " + type
+
+def lineup_typedefs(typedefs):
+    """ Lineup typedef lists.
+
+    Returns an array of lines of C code to declare each of the typedefs
+    in typedefs, which should be an array of (type, name, args)
+    """
+    defs = []
+    max_type = max(len(t) for t,n,a in typedefs)
+    max_name = max(len(typedef_lineup_prefix(n)) for t,n,a in typedefs)
+
+    for type,name,args in typedefs:
+        code = "typedef "
+        code += type.ljust(max_type+1)
+        code += typedef_lineup_prefix(name).ljust(max_name+1)
+        code += "("
+        code += ", ".join("%s%s%s" % (type, not type.endswith("*") and " " or "",
+                                      name) for type,name in args)
+        code += ");"
+        defs.append(code)
+
+    return defs
+
+def lineup_protos(protos):
+    """Lineup prototype lists.
+
+    Returns an array of lines of C code to declare each of the prototypes
+    in protos, which should be an array of (retval, name, args, attributes)
+    tuples.  The declarations will be lined up in a pretty fashion.
+
+    It is up to the caller to add appropriate line-endings.
+    """
+    if not protos:
+        return []
+
+    max_retval = max(len(r) for r,n,a,at in protos)
+    max_name = max(len(n) for r,n,a,at in protos)
+
+    if not [ True for r,n,a,at in protos if r.endswith("*") ]:
+        max_retval += 1
+
+    lines = []
+    for retval, name, args, attributes in protos:
+        code = retval.ljust(max_retval)
+        code += name.ljust(max_name + 1)
+        code += "("
+        # FIXME split arguments over multiple lines maybe?
+        code += ", ".join("%s%s%s" % (type, not type.endswith("*") and " " or "",
+                                      name) for type,name in args)
+        code += ")"
+        if attributes:
+            code += "\n\t__attribute__ ((" + ", ".join(attributes) + "))"
+
+        lines.append(code)
+
+    return lines
+
+def camelate(string):
+    """Make a _-delimited string CamelCase.
+
+    Not much else to say.
+    """
+    return "".join([ x.capitalize() for x in string.split("_") ])
+
+def lineup_array(array):
+    """Lineup array definitions.
+
+    Returns an array of lines of C code to declare each of the array struct
+    definitions in array, which should be an array of tuples for each structure
+    member.  The declarations will be lined up in a pretty fashion.
+
+    It is up to the caller to add appropriate line-endings.
+    """
+    if not array:
+        return []
+
+    max_len = [ max(len(entry[i]) for entry in array)
+                for i in range(0, len(array[0])) ]
+
+    lines = []
+    for entry in array:
+        code = "{ "
+
+        for i, str in enumerate(entry):
+            if i < len(array[0]) - 1:
+                code += (str + ", ").ljust(max_len[i] + 2)
+            else:
+                code += str.ljust(max_len[i])
+
+        code += " }"
+
+        lines.append(code)
+
+    return lines
+
+
+def indent(str, level):
+    """Increase indent of string.
+
+    Returns the string with each line indented to the given level of tabs.
+    """
+    output = ""
+    for line in str.splitlines(True):
+        if len(line.strip()):
+            output += ("\t" * level) + line
+        else:
+            output += line
+    return output
+
+
+def pointerify(type):
+    """Turn C type into a pointer.
+
+    Returns the string for a pointer to the given C type.
+    """
+    if type.endswith("*"):
+        return type + "*"
+    else:
+        return type + " *"
+
+def constify(type):
+    """Type C pointer type into a const pointer.
+
+    Returns the string modified so that the pointer is a const pointer.
+    """
+    if not type.endswith("*"):
+        return type
+
+    if type[:-1].endswith("*"):
+        return type[:-1] + " const *"
+    else:
+        return "const " + type
+
+
+def main():
+    global options
+    global extern_prefix
+    global mode
+
+    usage = "%prog [OPTION]... XMLFILE"
+    description = """\
+XMLFILE is a valid XML file containing information about one or more interfaces
+in the D-Bus Introspection format, except that the top-level node may be
+interface as well as node.
+
+C code to marshal methods and dispatch signals (if --mode is object) or to
+dispatch methods and marshal signals (if --mode is proxy) is written to
+a .c and .h file in the current directory with the same base name as XMLFILE,
+or to that specified by --output.
+"""
+
+    parser = OptionParser(usage, description=description)
+    parser.add_option("--mode", type="string", metavar="MODE",
+                      default="object",
+                      help="Output mode: object, or proxy [default: %default]")
+    parser.add_option("-o", "--output", type="string", metavar="FILENAME",
+                      help="Write C source to FILENAME, header alongside")
+    parser.add_option("--prefix", type="string", metavar="PREFIX",
+                      default="dbus",
+                      help="Prefix for externally supplied C functions [default: %default]")
+
+    (options, args) = parser.parse_args()
+    if len(args) != 1:
+        parser.error("incorrect number of arguments")
+    if options.mode not in ("object", "proxy"):
+        parser.error("invalid mode")
+
+    extern_prefix = options.prefix
+    mode = options.mode
+
+    # Figure out input and output filenames based on arguments; try and
+    # do the right thing in most circumstances
+    xml_filename = args.pop(0)
+    if options.output:
+        (root, ext) = os.path.splitext(options.output)
+        if ext and ext != ".h":
+            source_filename = options.output
+        else:
+            source_filename = os.path.extsep.join(( root, "c" ))
+
+        header_filename = os.path.extsep.join (( root, "h"))
+        basename = os.path.basename(root)
+    else:
+        basename = os.path.splitext(os.path.basename(xml_filename))[0]
+        source_filename = os.path.extsep.join(( basename, "c" ))
+        header_filename = os.path.extsep.join(( basename, "h" ))
+
+    (head, tail) = os.path.split(source_filename)
+    tmp_source_filename = os.path.join(head, ".%s.tmp" % tail)
+
+    (head, tail) = os.path.split(header_filename)
+    tmp_header_filename = os.path.join(head, ".%s.tmp" % tail)
+
+
+    # Parse the XML file into an ElementTree
+    tree = ElementTree.parse(xml_filename)
+    elem = tree.getroot()
+
+    # Walk the tree to find interfaces
+    interfaces = []
+    if elem.tag == "interface":
+        interfaces.append(Interface.fromElement(elem))
+    else:
+        for iface_e in elem.findall("interface"):
+            interfaces.append(Interface.fromElement(iface_e))
+
+    # Generate and write output
+    o = Output(basename, interfaces)
+    try:
+        f = open(tmp_source_filename, "w")
+        try:
+            print >>f, o.sourceFile()
+        finally:
+            f.close()
+
+        f = open(tmp_header_filename, "w")
+        try:
+            print >>f, o.headerFile()
+        finally:
+            f.close()
+
+        os.rename(tmp_source_filename, source_filename)
+        os.rename(tmp_header_filename, header_filename)
+    except:
+        if os.path.exists(tmp_source_filename):
+            os.unlink(tmp_source_filename)
+        if os.path.exists(tmp_header_filename):
+            os.unlink(tmp_header_filename)
+
+        raise
+
+
+if __name__ == "__main__":
+    main()