From 8c7bbdbaea747f465676380eae4104607ef99696 Mon Sep 17 00:00:00 2001 From: Colin Walters Date: Thu, 4 Aug 2005 15:49:30 +0000 Subject: 2005-08-04 Colin Walters * glib/dbus-gvalue-utils.h (_dbus_g_type_specialized_builtins_init) (dbus_g_type_is_fixed, dbus_g_type_fixed_get_size) (dbus_gvalue_set_from_pointer, dbus_g_hash_table_value_foreach) (dbus_g_hash_table_insert_values, dbus_g_hash_table_insert_steal_values) (dbus_gtype_is_valid_hash_key, dbus_gtype_is_valid_hash_value) (dbus_g_hash_func_from_gtype, dbus_g_hash_free_from_gtype) (dbus_g_hash_equal_from_gtype, dbus_gvalue_stor, dbus_gvalue_take): * glib/dbus-gvalue.h (dbus_g_value_types_init) (dbus_gvalue_demarshal, dbus_gvalue_demarshal_variant) (dbus_gvalue_demarshal_message, dbus_gvalue_marshal): Prefix name with _ to ensure they're not exported. All callers updated. * glib/dbus-gvalue.c (typecode_to_gtype) (dbus_typecode_maps_to_basic, basic_typecode_to_gtype) (signature_iter_to_g_type_dict) (signature_iter_to_g_type_array) (dbus_gtype_from_signature_iter, dbus_gtype_from_signature) (dbus_gtypes_from_arg_signature): Move to dbus-gsignature.c. * glib/dbus-binding-tool-glib.c (dbus_binding_tool_output_glib_server): Call dbus_g_type_specialized_builtins_init instead of dbus_g_value_types_init. (dbus_binding_tool_output_glib_client): Ditto. * glib/Makefile.am (DBUS_GLIB_INTERNALS): Add dbus-gsignature.c and dbus-gsignature.h * test/glib/test-service-glib.c (my_object_rec_arrays): Delete unused variable. --- ChangeLog | 34 ++++++ glib/Makefile.am | 5 +- glib/dbus-binding-tool-glib.c | 36 ++++--- glib/dbus-gmain.c | 23 ++-- glib/dbus-gobject.c | 35 ++++--- glib/dbus-gproxy.c | 13 +-- glib/dbus-gsignature.c | 189 +++++++++++++++++++++++++++++++++ glib/dbus-gsignature.h | 19 ++++ glib/dbus-gvalue-utils.c | 46 ++++---- glib/dbus-gvalue-utils.h | 28 ++--- glib/dbus-gvalue.c | 237 +++++++----------------------------------- glib/dbus-gvalue.h | 21 ++-- test/glib/test-service-glib.c | 1 - 13 files changed, 384 insertions(+), 303 deletions(-) create mode 100644 glib/dbus-gsignature.c create mode 100644 glib/dbus-gsignature.h diff --git a/ChangeLog b/ChangeLog index 15300f41..b93351c7 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,37 @@ +2005-08-04 Colin Walters + + * glib/dbus-gvalue-utils.h (_dbus_g_type_specialized_builtins_init) + (dbus_g_type_is_fixed, dbus_g_type_fixed_get_size) + (dbus_gvalue_set_from_pointer, dbus_g_hash_table_value_foreach) + (dbus_g_hash_table_insert_values, dbus_g_hash_table_insert_steal_values) + (dbus_gtype_is_valid_hash_key, dbus_gtype_is_valid_hash_value) + (dbus_g_hash_func_from_gtype, dbus_g_hash_free_from_gtype) + (dbus_g_hash_equal_from_gtype, dbus_gvalue_stor, dbus_gvalue_take): + * glib/dbus-gvalue.h (dbus_g_value_types_init) + (dbus_gvalue_demarshal, dbus_gvalue_demarshal_variant) + (dbus_gvalue_demarshal_message, dbus_gvalue_marshal): + + Prefix name with _ to ensure they're not exported. All callers + updated. + + * glib/dbus-gvalue.c (typecode_to_gtype) + (dbus_typecode_maps_to_basic, basic_typecode_to_gtype) + (signature_iter_to_g_type_dict) + (signature_iter_to_g_type_array) + (dbus_gtype_from_signature_iter, dbus_gtype_from_signature) + (dbus_gtypes_from_arg_signature): + Move to dbus-gsignature.c. + + * glib/dbus-binding-tool-glib.c (dbus_binding_tool_output_glib_server): Call + dbus_g_type_specialized_builtins_init instead of dbus_g_value_types_init. + (dbus_binding_tool_output_glib_client): Ditto. + + * glib/Makefile.am (DBUS_GLIB_INTERNALS): Add dbus-gsignature.c + and dbus-gsignature.h + + * test/glib/test-service-glib.c (my_object_rec_arrays): Delete + unused variable. + 2005-08-03 Colin Walters * glib/dbus-gobject.c: Add tests on hardcoded object info; this should diff --git a/glib/Makefile.am b/glib/Makefile.am index 4e3b796c..fd8cba50 100644 --- a/glib/Makefile.am +++ b/glib/Makefile.am @@ -15,6 +15,9 @@ DBUS_GLIB_INTERNALS = \ dbus-gtype-specialized.c \ dbus-gutils.c \ dbus-gutils.h \ + dbus-gsignature.c \ + dbus-gsignature.h \ + dbus-gvalue.h \ dbus-gvalue-utils.c \ dbus-gvalue-utils.h @@ -29,9 +32,9 @@ libdbus_glib_1_la_SOURCES = \ dbus-gproxy.c \ dbus-gtest.c \ dbus-gtest.h \ - dbus-gthread.c \ dbus-gvalue.c \ dbus-gvalue.h \ + dbus-gthread.c \ $(DBUS_GLIB_INTERNALS) libdbus_glib_HEADERS = \ diff --git a/glib/dbus-binding-tool-glib.c b/glib/dbus-binding-tool-glib.c index 39c180fd..7ad62f5a 100644 --- a/glib/dbus-binding-tool-glib.c +++ b/glib/dbus-binding-tool-glib.c @@ -23,10 +23,12 @@ */ #include +#include "dbus/dbus-glib.h" #include "dbus-gidl.h" #include "dbus-gparser.h" #include "dbus-gutils.h" -#include "dbus-gvalue.h" +#include "dbus-gtype-specialized.h" +#include "dbus-gsignature.h" #include "dbus-gvalue-utils.h" #include "dbus-glib-tool.h" #include "dbus-binding-tool-glib.h" @@ -146,7 +148,7 @@ compute_gsignature (MethodInfo *method, GType *rettype, GArray **params, GError if (returnval_annotation != NULL) { arg_type = arg_info_get_type (arg); - retval_type = dbus_gtype_from_signature (arg_type, FALSE); + retval_type = _dbus_gtype_from_signature (arg_type, FALSE); if (retval_type == G_TYPE_INVALID) goto invalid_type; found_retval = TRUE; @@ -173,7 +175,7 @@ compute_gsignature (MethodInfo *method, GType *rettype, GArray **params, GError GType gtype; arg_type = arg_info_get_type (arg); - gtype = dbus_gtype_from_signature (arg_type, FALSE); + gtype = _dbus_gtype_from_signature (arg_type, FALSE); if (gtype == G_TYPE_INVALID) goto invalid_type; @@ -196,7 +198,7 @@ compute_gsignature (MethodInfo *method, GType *rettype, GArray **params, GError { GType gtype; arg_type = arg_info_get_type (arg); - gtype = dbus_gtype_from_signature (arg_type, FALSE); + gtype = _dbus_gtype_from_signature (arg_type, FALSE); if (gtype == G_TYPE_INVALID) goto invalid_type; /* We actually just need a pointer for the return value @@ -658,7 +660,7 @@ generate_glue (BaseInfo *base, DBusBindingToolCData *data, GError **error) g_string_append_c (object_introspection_data_blob, 'R'); else if (!strcmp ("error", returnval_annotation)) { - gtype = dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); + gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); if (!_dbus_gtype_can_signal_error (gtype)) { g_set_error (error, @@ -769,7 +771,8 @@ dbus_binding_tool_output_glib_server (BaseInfo *info, GIOChannel *channel, const memset (&data, 0, sizeof (data)); - dbus_g_value_types_init (); + dbus_g_type_specialized_init (); + _dbus_g_type_specialized_builtins_init (); data.prefix = prefix; data.generated = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, NULL); @@ -917,7 +920,7 @@ write_formal_parameters (InterfaceInfo *iface, MethodInfo *method, GIOChannel *c direction = arg_info_get_direction (arg); - gtype = dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); + gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); if (gtype == G_TYPE_INVALID) { g_set_error (error, @@ -1056,7 +1059,7 @@ write_args_for_direction (InterfaceInfo *iface, MethodInfo *method, GIOChannel * if (direction != arg_info_get_direction (arg)) continue; - gtype = dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); + gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); g_assert (gtype != G_TYPE_INVALID); type_lookup = dbus_g_type_get_lookup_function (gtype); g_assert (type_lookup != NULL); @@ -1098,7 +1101,7 @@ check_supported_parameters (MethodInfo *method) GType gtype; arg = args->data; - gtype = dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); + gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); if (gtype == G_TYPE_INVALID) return FALSE; } @@ -1144,7 +1147,7 @@ write_formal_declarations_for_direction (InterfaceInfo *iface, MethodInfo *metho dir = arg_info_get_direction (arg); - gtype = dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); + gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); type_str = dbus_g_type_get_c_name (gtype); if (!type_str) @@ -1220,7 +1223,7 @@ write_formal_parameters_for_direction (InterfaceInfo *iface, MethodInfo *method, WRITE_OR_LOSE (", "); - gtype = dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); + gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); type_str = dbus_g_type_get_c_name (gtype); /* Variants are special...*/ if (gtype == G_TYPE_VALUE) @@ -1293,7 +1296,7 @@ write_typed_args_for_direction (InterfaceInfo *iface, MethodInfo *method, GIOCha if (dir != direction) continue; - gtype = dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); + gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); type_lookup = dbus_g_type_get_lookup_function (gtype); if (!write_printf_to_iochannel ("%s, &%s_%s, ", channel, error, type_lookup, direction == ARG_IN ? "IN" : "OUT", arg_info_get_name (arg))) @@ -1326,14 +1329,14 @@ write_async_method_client (GIOChannel *channel, InterfaceInfo *interface, Method if (arg_info_get_direction (arg) != ARG_OUT) continue; - gtype = dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); + gtype = _dbus_gtype_from_signature (arg_info_get_type (arg), TRUE); if (gtype != G_TYPE_VALUE && (g_type_is_a (gtype, G_TYPE_BOXED) || g_type_is_a (gtype, G_TYPE_OBJECT) || g_type_is_a (gtype, G_TYPE_POINTER))) type_suffix = "*"; else type_suffix = ""; - type_str = dbus_g_type_get_c_name (dbus_gtype_from_signature (arg_info_get_type (arg), TRUE)); + type_str = dbus_g_type_get_c_name (_dbus_gtype_from_signature (arg_info_get_type (arg), TRUE)); if (!write_printf_to_iochannel ("%s %sOUT_%s, ", channel, error, type_str, type_suffix, arg_info_get_name (arg))) goto io_lose; } @@ -1508,13 +1511,14 @@ dbus_binding_tool_output_glib_client (BaseInfo *info, GIOChannel *channel, gbool DBusBindingToolCData data; gboolean ret; - dbus_g_value_types_init (); - memset (&data, 0, sizeof (data)); data.channel = channel; data.ignore_unsupported = ignore_unsupported; + dbus_g_type_specialized_init (); + _dbus_g_type_specialized_builtins_init (); + WRITE_OR_LOSE ("/* Generated by dbus-binding-tool; do not edit! */\n\n"); WRITE_OR_LOSE ("#include \n"); WRITE_OR_LOSE ("#include \n"); diff --git a/glib/dbus-gmain.c b/glib/dbus-gmain.c index 85d7bca1..4904588e 100644 --- a/glib/dbus-gmain.c +++ b/glib/dbus-gmain.c @@ -30,6 +30,7 @@ #include "dbus-gvalue.h" #include "dbus-gobject.h" #include "dbus-gvalue-utils.h" +#include "dbus-gsignature.h" #include #include @@ -714,7 +715,7 @@ dbus_g_bus_get (DBusBusType type, g_return_val_if_fail (error == NULL || *error == NULL, NULL); - dbus_g_value_types_init (); + _dbus_g_value_types_init (); dbus_error_init (&derror); @@ -744,30 +745,30 @@ dbus_g_bus_get (DBusBusType type, gboolean _dbus_gmain_test (const char *test_data_dir) { + GType type; GType rectype; - GType gtype; g_type_init (); - dbus_g_value_types_init (); + _dbus_g_value_types_init (); rectype = dbus_g_type_get_collection ("GArray", G_TYPE_UINT); g_assert (rectype != G_TYPE_INVALID); g_assert (!strcmp (g_type_name (rectype), "GArray+guint")); - gtype = dbus_gtype_from_signature ("au", TRUE); - g_assert (gtype == rectype); + type = _dbus_gtype_from_signature ("au", TRUE); + g_assert (type == rectype); rectype = dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_STRING); g_assert (rectype != G_TYPE_INVALID); g_assert (!strcmp (g_type_name (rectype), "GHashTable+gchararray+gchararray")); - gtype = dbus_gtype_from_signature ("a{ss}", TRUE); - g_assert (gtype == rectype); + type = _dbus_gtype_from_signature ("a{ss}", TRUE); + g_assert (type == rectype); - gtype = dbus_gtype_from_signature ("o", FALSE); - g_assert (gtype == DBUS_TYPE_G_OBJECT_PATH); - gtype = dbus_gtype_from_signature ("o", TRUE); - g_assert (gtype == DBUS_TYPE_G_OBJECT_PATH); + type = _dbus_gtype_from_signature ("o", FALSE); + g_assert (type == DBUS_TYPE_G_OBJECT_PATH); + type = _dbus_gtype_from_signature ("o", TRUE); + g_assert (type == DBUS_TYPE_G_OBJECT_PATH); return TRUE; } diff --git a/glib/dbus-gobject.c b/glib/dbus-gobject.c index 56042520..e124f934 100644 --- a/glib/dbus-gobject.c +++ b/glib/dbus-gobject.c @@ -29,6 +29,7 @@ #include "dbus-gtest.h" #include "dbus-gutils.h" #include "dbus-gobject.h" +#include "dbus-gsignature.h" #include "dbus-gvalue.h" #include "dbus-gmarshal.h" #include "dbus-gvalue-utils.h" @@ -421,7 +422,7 @@ write_interface (gpointer key, gpointer val, gpointer user_data) for (arg = 0; arg < query.n_params; arg++) { - char *dbus_type = dbus_gtype_to_signature (query.param_types[arg]); + char *dbus_type = _dbus_gtype_to_signature (query.param_types[arg]); g_assert (dbus_type != NULL); @@ -453,7 +454,7 @@ write_interface (gpointer key, gpointer val, gpointer user_data) g_assert (spec != NULL); g_free (s); - dbus_type = dbus_gtype_to_signature (G_PARAM_SPEC_VALUE_TYPE (spec)); + dbus_type = _dbus_gtype_to_signature (G_PARAM_SPEC_VALUE_TYPE (spec)); g_assert (dbus_type != NULL); can_set = ((spec->flags & G_PARAM_WRITABLE) != 0 && @@ -658,7 +659,7 @@ set_object_property (DBusConnection *connection, context.proxy = NULL; g_value_init (&value, pspec->value_type); - if (dbus_gvalue_demarshal (&context, &sub, &value, NULL)) + if (_dbus_gvalue_demarshal (&context, &sub, &value, NULL)) { g_object_set_property (object, pspec->name, @@ -706,7 +707,7 @@ get_object_property (DBusConnection *connection, dbus_message_iter_init_append (message, &iter); - if (!dbus_gvalue_marshal (&iter, &value)) + if (!_dbus_gvalue_marshal (&iter, &value)) { dbus_message_unref (ret); ret = dbus_message_new_error (message, @@ -937,11 +938,11 @@ invoke_object_method (GObject *object, context.gconnection = DBUS_G_CONNECTION_FROM_CONNECTION (connection); context.proxy = NULL; - types_array = dbus_gtypes_from_arg_signature (in_signature, FALSE); + types_array = _dbus_gtypes_from_arg_signature (in_signature, FALSE); n_params = types_array->len; types = (const GType*) types_array->data; - value_array = dbus_gvalue_demarshal_message (&context, message, n_params, types, &error); + value_array = _dbus_gvalue_demarshal_message (&context, message, n_params, types, &error); if (value_array == NULL) { g_free (in_signature); @@ -1014,7 +1015,7 @@ invoke_object_method (GObject *object, /* Initialize our return GValue with the specified type */ dbus_signature_iter_init (&tmp_sigiter, argsig); - g_value_init (&return_value, dbus_gtype_from_signature_iter (&tmp_sigiter, FALSE)); + g_value_init (&return_value, _dbus_gtype_from_signature_iter (&tmp_sigiter, FALSE)); } else { @@ -1070,7 +1071,7 @@ invoke_object_method (GObject *object, continue; dbus_signature_iter_init (&tmp_sigiter, argsig); - current_gtype = dbus_gtype_from_signature_iter (&tmp_sigiter, FALSE); + current_gtype = _dbus_gtype_from_signature_iter (&tmp_sigiter, FALSE); g_value_init (&value, G_TYPE_POINTER); @@ -1130,7 +1131,7 @@ invoke_object_method (GObject *object, /* First, append the return value, unless it's synthetic */ if (have_retval && !retval_is_synthetic) { - if (!dbus_gvalue_marshal (&iter, &return_value)) + if (!_dbus_gvalue_marshal (&iter, &return_value)) goto nomem; if (!retval_is_constant) g_value_unset (&return_value); @@ -1168,10 +1169,10 @@ invoke_object_method (GObject *object, dbus_signature_iter_init (&argsigiter, arg_signature); - g_value_init (&gvalue, dbus_gtype_from_signature_iter (&argsigiter, FALSE)); + g_value_init (&gvalue, _dbus_gtype_from_signature_iter (&argsigiter, FALSE)); if (G_VALUE_TYPE (&gvalue) != G_TYPE_VALUE) { - if (!dbus_gvalue_take (&gvalue, + if (!_dbus_gvalue_take (&gvalue, &(g_array_index (out_param_values, GTypeCValue, out_param_pos)))) g_assert_not_reached (); out_param_pos++; @@ -1182,10 +1183,10 @@ invoke_object_method (GObject *object, out_param_gvalue_pos++; } - if (!dbus_gvalue_marshal (&iter, &gvalue)) + if (!_dbus_gvalue_marshal (&iter, &gvalue)) goto nomem; /* Here we actually free the allocated value; we - * took ownership of it with dbus_gvalue_take, unless + * took ownership of it with _dbus_gvalue_take, unless * an annotation has specified this value as constant. */ if (!constval) @@ -1404,7 +1405,7 @@ signal_emitter_marshaller (GClosure *closure, /* First argument is the object itself, and we can't marshall that */ for (i = 1; i < n_param_values; i++) { - if (!dbus_gvalue_marshal (&iter, + if (!_dbus_gvalue_marshal (&iter, (GValue *) (&(param_values[i])))) { g_warning ("failed to marshal parameter %d for signal %s", @@ -1536,7 +1537,7 @@ dbus_g_object_type_install_info (GType object_type, { g_return_if_fail (G_TYPE_IS_CLASSED (object_type)); - dbus_g_value_types_init (); + _dbus_g_value_types_init (); g_type_set_qdata (object_type, dbus_g_object_type_dbus_metadata_quark (), @@ -1874,7 +1875,7 @@ dbus_g_method_return (DBusGMethodInvocation *context, ...) reply = dbus_message_new_method_return (dbus_g_message_get_message (context->message)); out_sig = method_output_signature_from_object_info (context->object, context->method); - argsig = dbus_gtypes_from_arg_signature (out_sig, FALSE); + argsig = _dbus_gtypes_from_arg_signature (out_sig, FALSE); dbus_message_iter_init_append (reply, &iter); @@ -1891,7 +1892,7 @@ dbus_g_method_return (DBusGMethodInvocation *context, ...) g_warning(error); g_free (error); } - dbus_gvalue_marshal (&iter, &value); + _dbus_gvalue_marshal (&iter, &value); } va_end (args); diff --git a/glib/dbus-gproxy.c b/glib/dbus-gproxy.c index 9fd46020..ca1b5544 100644 --- a/glib/dbus-gproxy.c +++ b/glib/dbus-gproxy.c @@ -25,6 +25,7 @@ #include #include #include "dbus-gutils.h" +#include "dbus-gsignature.h" #include "dbus-gvalue.h" #include "dbus-gvalue-utils.h" #include "dbus-gobject.h" @@ -1551,7 +1552,7 @@ marshal_dbus_message_to_g_marshaller (GClosure *closure, context.proxy = proxy; types = (const GType*) gsignature->data; - value_array = dbus_gvalue_demarshal_message (&context, message, + value_array = _dbus_gvalue_demarshal_message (&context, message, gsignature->len, types, NULL); } @@ -1603,7 +1604,7 @@ dbus_g_proxy_emit_remote_signal (DBusGProxy *proxy, if (gsignature == NULL) goto out; - msg_gsignature = dbus_gtypes_from_arg_signature (dbus_message_get_signature (message), + msg_gsignature = _dbus_gtypes_from_arg_signature (dbus_message_get_signature (message), TRUE); for (i = 0; i < gsignature->len; i++) { @@ -2019,7 +2020,7 @@ dbus_g_proxy_marshal_args_to_message (DBusGProxy *proxy, gvalue = g_value_array_get_nth (args, i); - if (!dbus_gvalue_marshal (&msgiter, gvalue)) + if (!_dbus_gvalue_marshal (&msgiter, gvalue)) g_assert_not_reached (); } return message; @@ -2143,7 +2144,7 @@ dbus_g_proxy_end_call_internal (DBusGProxy *proxy, if (arg_type == DBUS_TYPE_VARIANT && g_type_is_a (valtype, G_TYPE_VALUE)) { - if (!dbus_gvalue_demarshal_variant (&context, &msgiter, (GValue*) return_storage, NULL)) + if (!_dbus_gvalue_demarshal_variant (&context, &msgiter, (GValue*) return_storage, NULL)) { g_set_error (error, DBUS_GERROR, @@ -2157,11 +2158,11 @@ dbus_g_proxy_end_call_internal (DBusGProxy *proxy, { g_value_init (&gvalue, valtype); - if (!dbus_gvalue_demarshal (&context, &msgiter, &gvalue, error)) + if (!_dbus_gvalue_demarshal (&context, &msgiter, &gvalue, error)) goto out; /* Anything that can be demarshaled must be storable */ - if (!dbus_gvalue_store (&gvalue, (gpointer*) return_storage)) + if (!_dbus_gvalue_store (&gvalue, (gpointer*) return_storage)) g_assert_not_reached (); /* Ownership of the value passes to the client, don't unset */ } diff --git a/glib/dbus-gsignature.c b/glib/dbus-gsignature.c new file mode 100644 index 00000000..a0370b0e --- /dev/null +++ b/glib/dbus-gsignature.c @@ -0,0 +1,189 @@ +/* -*- mode: C; c-file-style: "gnu" -*- */ +/* dbus-gsignature.c Mapping from dbus type signatures to GType + * + * Copyright (C) 2005 Red Hat, Inc. + * + * Licensed under the Academic Free License version 2.1 + * + * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "config.h" +#include "dbus-gtest.h" +#include "dbus-gsignature.h" +#include "dbus-gvalue-utils.h" +#include +#include + +#define MAP_BASIC(d_t, g_t) \ + case DBUS_TYPE_##d_t: \ + return G_TYPE_##g_t; +static GType +typecode_to_gtype (int type) +{ + switch (type) + { + MAP_BASIC (BOOLEAN, BOOLEAN); + MAP_BASIC (BYTE, UCHAR); + MAP_BASIC (INT16, INT); + MAP_BASIC (INT32, INT); + MAP_BASIC (UINT16, UINT); + MAP_BASIC (UINT32, UINT); + MAP_BASIC (INT64, INT64); + MAP_BASIC (UINT64, UINT64); + MAP_BASIC (DOUBLE, DOUBLE); + MAP_BASIC (STRING, STRING); + default: + return G_TYPE_INVALID; + } +} +#undef MAP_BASIC + +static gboolean +dbus_typecode_maps_to_basic (int typecode) +{ + return typecode_to_gtype (typecode) != G_TYPE_INVALID; +} + +GType +_dbus_gtype_from_basic_typecode (int typecode) +{ + g_assert (dbus_type_is_basic (typecode)); + g_assert (dbus_typecode_maps_to_basic (typecode)); + return typecode_to_gtype (typecode); +} + +static GType +signature_iter_to_g_type_dict (const DBusSignatureIter *subiter, gboolean is_client) +{ + DBusSignatureIter iter; + GType key_gtype; + GType value_gtype; + + g_assert (dbus_signature_iter_get_current_type (subiter) == DBUS_TYPE_DICT_ENTRY); + + dbus_signature_iter_recurse (subiter, &iter); + + key_gtype = _dbus_gtype_from_signature_iter (&iter, is_client); + if (key_gtype == G_TYPE_INVALID) + return G_TYPE_INVALID; + + dbus_signature_iter_next (&iter); + value_gtype = _dbus_gtype_from_signature_iter (&iter, is_client); + if (value_gtype == G_TYPE_INVALID) + return G_TYPE_INVALID; + + if (!_dbus_gtype_is_valid_hash_key (key_gtype) + || !_dbus_gtype_is_valid_hash_value (value_gtype)) + /* Later we need to return DBUS_TYPE_G_VALUE */ + return G_TYPE_INVALID; + + return dbus_g_type_get_map ("GHashTable", key_gtype, value_gtype); +} + +static GType +signature_iter_to_g_type_array (DBusSignatureIter *iter, gboolean is_client) +{ + GType elt_gtype; + + elt_gtype = _dbus_gtype_from_signature_iter (iter, is_client); + if (elt_gtype == G_TYPE_INVALID) + return G_TYPE_INVALID; + + if (elt_gtype == G_TYPE_OBJECT) + return DBUS_TYPE_G_OBJECT_ARRAY; + if (elt_gtype == G_TYPE_STRING) + return G_TYPE_STRV; + if (_dbus_g_type_is_fixed (elt_gtype)) + return dbus_g_type_get_collection ("GArray", elt_gtype); + else if (g_type_is_a (elt_gtype, G_TYPE_OBJECT) + || g_type_is_a (elt_gtype, G_TYPE_BOXED)) + return dbus_g_type_get_collection ("GPtrArray", elt_gtype); + + /* Later we need to return DBUS_TYPE_G_VALUE */ + return G_TYPE_INVALID; +} + +GType +_dbus_gtype_from_signature_iter (DBusSignatureIter *iter, gboolean is_client) +{ + int current_type; + + current_type = dbus_signature_iter_get_current_type (iter); + /* TODO: handle type 0? */ + if (dbus_typecode_maps_to_basic (current_type)) + return _dbus_gtype_from_basic_typecode (current_type); + else if (current_type == DBUS_TYPE_OBJECT_PATH) + return DBUS_TYPE_G_OBJECT_PATH; + else + { + DBusSignatureIter subiter; + + g_assert (dbus_type_is_container (current_type)); + + if (current_type == DBUS_TYPE_VARIANT) + return G_TYPE_VALUE; + if (current_type == DBUS_TYPE_STRUCT) + return G_TYPE_VALUE_ARRAY; + + dbus_signature_iter_recurse (iter, &subiter); + + if (current_type == DBUS_TYPE_ARRAY) + { + int elt_type = dbus_signature_iter_get_current_type (&subiter); + if (elt_type == DBUS_TYPE_DICT_ENTRY) + return signature_iter_to_g_type_dict (&subiter, is_client); + else + return signature_iter_to_g_type_array (&subiter, is_client); + } + else + { + g_assert_not_reached (); + return G_TYPE_INVALID; + } + } +} + +GType +_dbus_gtype_from_signature (const char *signature, gboolean is_client) +{ + DBusSignatureIter iter; + + dbus_signature_iter_init (&iter, signature); + + return _dbus_gtype_from_signature_iter (&iter, is_client); +} + +GArray * +_dbus_gtypes_from_arg_signature (const char *argsig, gboolean is_client) +{ + GArray *ret; + int current_type; + DBusSignatureIter sigiter; + + ret = g_array_new (FALSE, FALSE, sizeof (GType)); + + dbus_signature_iter_init (&sigiter, argsig); + while ((current_type = dbus_signature_iter_get_current_type (&sigiter)) != DBUS_TYPE_INVALID) + { + GType curtype; + + curtype = _dbus_gtype_from_signature_iter (&sigiter, is_client); + g_array_append_val (ret, curtype); + dbus_signature_iter_next (&sigiter); + } + return ret; +} diff --git a/glib/dbus-gsignature.h b/glib/dbus-gsignature.h new file mode 100644 index 00000000..08757e11 --- /dev/null +++ b/glib/dbus-gsignature.h @@ -0,0 +1,19 @@ +#ifndef DBUS_GOBJECT_SIGNATURE_H +#define DBUS_GOBJECT_SIGNATURE_H + +#include +#include +#include + +GType _dbus_gtype_from_basic_typecode (int typecode); + +GType _dbus_gtype_from_signature (const char *signature, + gboolean is_client); + +GType _dbus_gtype_from_signature_iter (DBusSignatureIter *sigiter, + gboolean is_client); + +GArray * _dbus_gtypes_from_arg_signature (const char *signature, + gboolean is_client); + +#endif diff --git a/glib/dbus-gvalue-utils.c b/glib/dbus-gvalue-utils.c index 04afaee2..c7b0d580 100644 --- a/glib/dbus-gvalue-utils.c +++ b/glib/dbus-gvalue-utils.c @@ -59,20 +59,20 @@ fixed_type_get_size (GType type) } gboolean -dbus_g_type_is_fixed (GType type) +_dbus_g_type_is_fixed (GType type) { return fixed_type_get_size (type) > 0; } guint -dbus_g_type_fixed_get_size (GType type) +_dbus_g_type_fixed_get_size (GType type) { - g_assert (dbus_g_type_is_fixed (type)); + g_assert (_dbus_g_type_is_fixed (type)); return fixed_type_get_size (type); } gboolean -dbus_gvalue_store (GValue *value, +_dbus_gvalue_store (GValue *value, gpointer storage) { /* FIXME - can we use the GValue lcopy_value method @@ -128,7 +128,7 @@ dbus_gvalue_store (GValue *value, } gboolean -dbus_gvalue_set_from_pointer (GValue *value, +_dbus_gvalue_set_from_pointer (GValue *value, gconstpointer storage) { /* FIXME - is there a better way to do this? */ @@ -182,7 +182,7 @@ dbus_gvalue_set_from_pointer (GValue *value, } gboolean -dbus_gvalue_take (GValue *value, +_dbus_gvalue_take (GValue *value, GTypeCValue *cvalue) { GType g_type; @@ -313,21 +313,21 @@ hash_free_from_gtype (GType gtype, GDestroyNotify *func) } gboolean -dbus_gtype_is_valid_hash_key (GType type) +_dbus_gtype_is_valid_hash_key (GType type) { GHashFunc func; return hash_func_from_gtype (type, &func); } gboolean -dbus_gtype_is_valid_hash_value (GType type) +_dbus_gtype_is_valid_hash_value (GType type) { GDestroyNotify func; return hash_free_from_gtype (type, &func); } GHashFunc -dbus_g_hash_func_from_gtype (GType gtype) +_dbus_g_hash_func_from_gtype (GType gtype) { GHashFunc func; gboolean ret; @@ -337,9 +337,9 @@ dbus_g_hash_func_from_gtype (GType gtype) } GEqualFunc -dbus_g_hash_equal_from_gtype (GType gtype) +_dbus_g_hash_equal_from_gtype (GType gtype) { - g_assert (dbus_gtype_is_valid_hash_key (gtype)); + g_assert (_dbus_gtype_is_valid_hash_key (gtype)); switch (gtype) { @@ -358,7 +358,7 @@ dbus_g_hash_equal_from_gtype (GType gtype) } GDestroyNotify -dbus_g_hash_free_from_gtype (GType gtype) +_dbus_g_hash_free_from_gtype (GType gtype) { GDestroyNotify func; gboolean ret; @@ -490,7 +490,7 @@ hashtable_iterator (GType hash_type, } void -dbus_g_hash_table_insert_steal_values (GHashTable *table, +_dbus_g_hash_table_insert_steal_values (GHashTable *table, GValue *key_val, GValue *value_val) { @@ -510,7 +510,7 @@ hashtable_append (DBusGTypeSpecializedAppendContext *ctx, GHashTable *table; table = g_value_get_boxed (ctx->val); - dbus_g_hash_table_insert_steal_values (table, key, val); + _dbus_g_hash_table_insert_steal_values (table, key, val); } static gpointer @@ -523,10 +523,10 @@ hashtable_constructor (GType type) key_gtype = dbus_g_type_get_map_key_specialization (type); value_gtype = dbus_g_type_get_map_value_specialization (type); - ret = g_hash_table_new_full (dbus_g_hash_func_from_gtype (key_gtype), - dbus_g_hash_equal_from_gtype (key_gtype), - dbus_g_hash_free_from_gtype (key_gtype), - dbus_g_hash_free_from_gtype (value_gtype)); + ret = g_hash_table_new_full (_dbus_g_hash_func_from_gtype (key_gtype), + _dbus_g_hash_equal_from_gtype (key_gtype), + _dbus_g_hash_free_from_gtype (key_gtype), + _dbus_g_hash_free_from_gtype (value_gtype)); return ret; } @@ -543,7 +543,7 @@ hashtable_insert_values (GHashTable *table, g_value_init (&value_copy, G_VALUE_TYPE (value_val)); g_value_copy (value_val, &value_copy); - dbus_g_hash_table_insert_steal_values (table, &key_copy, &value_copy); + _dbus_g_hash_table_insert_steal_values (table, &key_copy, &value_copy); } static void @@ -587,7 +587,7 @@ array_constructor (GType type) elt_type = dbus_g_type_get_collection_specialization (type); g_assert (elt_type != G_TYPE_INVALID); - elt_size = dbus_g_type_fixed_get_size (elt_type); + elt_size = _dbus_g_type_fixed_get_size (elt_type); /* These are "safe" defaults */ zero_terminated = TRUE; /* ((struct _DBusGRealArray*) garray)->zero_terminated; */ @@ -626,7 +626,7 @@ array_fixed_accessor (GType type, gpointer instance, gpointer *values, guint *le GArray *array = instance; elt_type = dbus_g_type_get_collection_specialization (type); - if (!dbus_g_type_is_fixed (elt_type)) + if (!_dbus_g_type_is_fixed (elt_type)) return FALSE; *values = array->data; @@ -841,7 +841,7 @@ slist_free (GType type, gpointer val) } void -dbus_g_type_specialized_builtins_init (void) +_dbus_g_type_specialized_builtins_init (void) { static const DBusGTypeSpecializedCollectionVtable array_vtable = { { @@ -967,7 +967,7 @@ _dbus_gvalue_utils_test (const char *datadir) GType type; dbus_g_type_specialized_init (); - dbus_g_type_specialized_builtins_init (); + _dbus_g_type_specialized_builtins_init (); type = dbus_g_type_get_collection ("GArray", G_TYPE_UINT); g_assert (dbus_g_type_is_collection (type)); diff --git a/glib/dbus-gvalue-utils.h b/glib/dbus-gvalue-utils.h index 4f81081e..139f4a31 100644 --- a/glib/dbus-gvalue-utils.h +++ b/glib/dbus-gvalue-utils.h @@ -29,39 +29,39 @@ G_BEGIN_DECLS -void dbus_g_type_specialized_builtins_init (void); +void _dbus_g_type_specialized_builtins_init (void); -gboolean dbus_g_type_is_fixed (GType gtype); -guint dbus_g_type_fixed_get_size (GType gtype); +gboolean _dbus_g_type_is_fixed (GType gtype); +guint _dbus_g_type_fixed_get_size (GType gtype); -gboolean dbus_gvalue_set_from_pointer (GValue *value, +gboolean _dbus_gvalue_set_from_pointer (GValue *value, gconstpointer storage); typedef void (*DBusGHashValueForeachFunc) (GValue * key, GValue *val, gpointer data); -void dbus_g_hash_table_value_foreach (GHashTable *table, +void _dbus_g_hash_table_value_foreach (GHashTable *table, GType hash_type, DBusGHashValueForeachFunc func, gpointer data); -void dbus_g_hash_table_insert_values (GHashTable *table, +void _dbus_g_hash_table_insert_values (GHashTable *table, GValue *key_val, GValue *value_val); -void dbus_g_hash_table_insert_steal_values (GHashTable *table, +void _dbus_g_hash_table_insert_steal_values (GHashTable *table, GValue *key_val, GValue *value_val); -gboolean dbus_gtype_is_valid_hash_key (GType type); -gboolean dbus_gtype_is_valid_hash_value (GType type); +gboolean _dbus_gtype_is_valid_hash_key (GType type); +gboolean _dbus_gtype_is_valid_hash_value (GType type); -GHashFunc dbus_g_hash_func_from_gtype (GType gtype); -GEqualFunc dbus_g_hash_equal_from_gtype (GType gtype); -GDestroyNotify dbus_g_hash_free_from_gtype (GType gtype); +GHashFunc _dbus_g_hash_func_from_gtype (GType gtype); +GEqualFunc _dbus_g_hash_equal_from_gtype (GType gtype); +GDestroyNotify _dbus_g_hash_free_from_gtype (GType gtype); -gboolean dbus_gvalue_store (GValue *value, +gboolean _dbus_gvalue_store (GValue *value, gpointer storage); -gboolean dbus_gvalue_take (GValue *value, +gboolean _dbus_gvalue_take (GValue *value, GTypeCValue *cvalue); gboolean _dbus_gtype_can_signal_error (GType gtype); diff --git a/glib/dbus-gvalue.c b/glib/dbus-gvalue.c index 282b3747..ebde24b0 100644 --- a/glib/dbus-gvalue.c +++ b/glib/dbus-gvalue.c @@ -25,6 +25,7 @@ #include "config.h" #include "dbus-gtest.h" #include "dbus-gvalue.h" +#include "dbus-gsignature.h" #include "dbus-gobject.h" #include "dbus-gvalue-utils.h" #include "dbus/dbus-glib.h" @@ -140,52 +141,14 @@ set_type_metadata (GType type, const DBusGTypeMarshalData *data) g_type_set_qdata (type, dbus_g_type_metadata_data_quark (), (gpointer) data); } -#define MAP_BASIC(d_t, g_t) \ - case DBUS_TYPE_##d_t: \ - return G_TYPE_##g_t; -static GType -typecode_to_gtype (int type) -{ - switch (type) - { - MAP_BASIC (BOOLEAN, BOOLEAN); - MAP_BASIC (BYTE, UCHAR); - MAP_BASIC (INT16, INT); - MAP_BASIC (INT32, INT); - MAP_BASIC (UINT16, UINT); - MAP_BASIC (UINT32, UINT); - MAP_BASIC (INT64, INT64); - MAP_BASIC (UINT64, UINT64); - MAP_BASIC (DOUBLE, DOUBLE); - MAP_BASIC (STRING, STRING); - default: - return G_TYPE_INVALID; - } -} -#undef MAP_BASIC - -static gboolean -dbus_typecode_maps_to_basic (int typecode) -{ - return typecode_to_gtype (typecode) != G_TYPE_INVALID; -} - -static GType -basic_typecode_to_gtype (int typecode) -{ - g_assert (dbus_type_is_basic (typecode)); - g_assert (dbus_typecode_maps_to_basic (typecode)); - return typecode_to_gtype (typecode); -} - static void register_basic (int typecode, const DBusGTypeMarshalData *typedata) { - set_type_metadata (basic_typecode_to_gtype (typecode), typedata); + set_type_metadata (_dbus_gtype_from_basic_typecode (typecode), typedata); } void -dbus_g_value_types_init (void) +_dbus_g_value_types_init (void) { static gboolean types_initialized; @@ -198,8 +161,7 @@ dbus_g_value_types_init (void) return; dbus_g_type_specialized_init (); - dbus_g_type_specialized_builtins_init (); - + _dbus_g_type_specialized_builtins_init (); /* Register basic types */ { @@ -384,109 +346,8 @@ dbus_g_object_path_get_g_type (void) return type_id; } -static GType -signature_iter_to_g_type_dict (const DBusSignatureIter *subiter, gboolean is_client) -{ - DBusSignatureIter iter; - GType key_gtype; - GType value_gtype; - - g_assert (dbus_signature_iter_get_current_type (subiter) == DBUS_TYPE_DICT_ENTRY); - - dbus_signature_iter_recurse (subiter, &iter); - - key_gtype = dbus_gtype_from_signature_iter (&iter, is_client); - if (key_gtype == G_TYPE_INVALID) - return G_TYPE_INVALID; - - dbus_signature_iter_next (&iter); - value_gtype = dbus_gtype_from_signature_iter (&iter, is_client); - if (value_gtype == G_TYPE_INVALID) - return G_TYPE_INVALID; - - if (!dbus_gtype_is_valid_hash_key (key_gtype) - || !dbus_gtype_is_valid_hash_value (value_gtype)) - /* Later we need to return DBUS_TYPE_G_VALUE */ - return G_TYPE_INVALID; - - return dbus_g_type_get_map ("GHashTable", key_gtype, value_gtype); -} - -static GType -signature_iter_to_g_type_array (DBusSignatureIter *iter, gboolean is_client) -{ - GType elt_gtype; - - elt_gtype = dbus_gtype_from_signature_iter (iter, is_client); - if (elt_gtype == G_TYPE_INVALID) - return G_TYPE_INVALID; - - if (elt_gtype == G_TYPE_OBJECT) - return DBUS_TYPE_G_OBJECT_ARRAY; - if (elt_gtype == G_TYPE_STRING) - return G_TYPE_STRV; - if (dbus_g_type_is_fixed (elt_gtype)) - return dbus_g_type_get_collection ("GArray", elt_gtype); - else if (g_type_is_a (elt_gtype, G_TYPE_OBJECT) - || g_type_is_a (elt_gtype, G_TYPE_BOXED)) - return dbus_g_type_get_collection ("GPtrArray", elt_gtype); - - /* Later we need to return DBUS_TYPE_G_VALUE */ - return G_TYPE_INVALID; -} - -GType -dbus_gtype_from_signature_iter (DBusSignatureIter *iter, gboolean is_client) -{ - int current_type; - - current_type = dbus_signature_iter_get_current_type (iter); - /* TODO: handle type 0? */ - if (dbus_typecode_maps_to_basic (current_type)) - return basic_typecode_to_gtype (current_type); - else if (current_type == DBUS_TYPE_OBJECT_PATH) - return DBUS_TYPE_G_OBJECT_PATH; - else - { - DBusSignatureIter subiter; - - g_assert (dbus_type_is_container (current_type)); - - if (current_type == DBUS_TYPE_VARIANT) - return G_TYPE_VALUE; - if (current_type == DBUS_TYPE_STRUCT) - return G_TYPE_VALUE_ARRAY; - - dbus_signature_iter_recurse (iter, &subiter); - - if (current_type == DBUS_TYPE_ARRAY) - { - int elt_type = dbus_signature_iter_get_current_type (&subiter); - if (elt_type == DBUS_TYPE_DICT_ENTRY) - return signature_iter_to_g_type_dict (&subiter, is_client); - else - return signature_iter_to_g_type_array (&subiter, is_client); - } - else - { - g_assert_not_reached (); - return G_TYPE_INVALID; - } - } -} - -GType -dbus_gtype_from_signature (const char *signature, gboolean is_client) -{ - DBusSignatureIter iter; - - dbus_signature_iter_init (&iter, signature); - - return dbus_gtype_from_signature_iter (&iter, is_client); -} - char * -dbus_gtype_to_signature (GType gtype) +_dbus_gtype_to_signature (GType gtype) { char *ret; DBusGTypeMarshalData *typedata; @@ -497,7 +358,7 @@ dbus_gtype_to_signature (GType gtype) char *subsig; elt_gtype = dbus_g_type_get_collection_specialization (gtype); - subsig = dbus_gtype_to_signature (elt_gtype); + subsig = _dbus_gtype_to_signature (elt_gtype); ret = g_strconcat (DBUS_TYPE_ARRAY_AS_STRING, subsig, NULL); g_free (subsig); } @@ -510,8 +371,8 @@ dbus_gtype_to_signature (GType gtype) key_gtype = dbus_g_type_get_map_key_specialization (gtype); val_gtype = dbus_g_type_get_map_value_specialization (gtype); - key_subsig = dbus_gtype_to_signature (key_gtype); - val_subsig = dbus_gtype_to_signature (val_gtype); + key_subsig = _dbus_gtype_to_signature (key_gtype); + val_subsig = _dbus_gtype_to_signature (val_gtype); ret = g_strconcat (DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING, key_subsig, val_subsig, DBUS_DICT_ENTRY_END_CHAR_AS_STRING, NULL); g_free (key_subsig); g_free (val_subsig); @@ -552,31 +413,9 @@ dbus_gvalue_to_signature (const GValue *val) return g_string_free (str, FALSE); } else - return dbus_gtype_to_signature (gtype); -} - -GArray * -dbus_gtypes_from_arg_signature (const char *argsig, gboolean is_client) -{ - GArray *ret; - int current_type; - DBusSignatureIter sigiter; - - ret = g_array_new (FALSE, FALSE, sizeof (GType)); - - dbus_signature_iter_init (&sigiter, argsig); - while ((current_type = dbus_signature_iter_get_current_type (&sigiter)) != DBUS_TYPE_INVALID) - { - GType curtype; - - curtype = dbus_gtype_from_signature_iter (&sigiter, is_client); - g_array_append_val (ret, curtype); - dbus_signature_iter_next (&sigiter); - } - return ret; + return _dbus_gtype_to_signature (gtype); } - static gboolean demarshal_basic (DBusGValueMarshalCtx *context, DBusMessageIter *iter, @@ -681,12 +520,12 @@ demarshal_static_variant (DBusGValueMarshalCtx *context, dbus_message_iter_recurse (iter, &subiter); sig = dbus_message_iter_get_signature (&subiter); - variant_type = dbus_gtype_from_signature (sig, context->proxy != NULL); + variant_type = _dbus_gtype_from_signature (sig, context->proxy != NULL); if (variant_type != G_TYPE_INVALID) { g_value_init (value, variant_type); - if (!dbus_gvalue_demarshal (context, &subiter, value, error)) + if (!_dbus_gvalue_demarshal (context, &subiter, value, error)) { dbus_free (sig); return FALSE; @@ -898,7 +737,7 @@ demarshal_valuearray (DBusGValueMarshalCtx *context, val = g_value_array_get_nth (ret, ret->n_values - 1); current_sig = dbus_message_iter_get_signature (&subiter); - elt_type = dbus_gtype_from_signature (current_sig, TRUE); + elt_type = _dbus_gtype_from_signature (current_sig, TRUE); g_free (current_sig); if (elt_type == G_TYPE_INVALID) @@ -913,7 +752,7 @@ demarshal_valuearray (DBusGValueMarshalCtx *context, g_value_init (val, elt_type); - if (!dbus_gvalue_demarshal (context, &subiter, val, error)) + if (!_dbus_gvalue_demarshal (context, &subiter, val, error)) { g_value_array_free (ret); return FALSE; @@ -986,7 +825,7 @@ demarshal_map (DBusGValueMarshalCtx *context, dbus_message_iter_recurse (&subiter, &entry_iter); g_value_init (&key_value, key_gtype); - if (!dbus_gvalue_demarshal (context, + if (!_dbus_gvalue_demarshal (context, &entry_iter, &key_value, error)) @@ -995,7 +834,7 @@ demarshal_map (DBusGValueMarshalCtx *context, dbus_message_iter_next (&entry_iter); g_value_init (&value_value, value_gtype); - if (!dbus_gvalue_demarshal (context, + if (!_dbus_gvalue_demarshal (context, &entry_iter, &value_value, error)) @@ -1044,7 +883,7 @@ demarshal_collection (DBusGValueMarshalCtx *context, coltype = G_VALUE_TYPE (value); subtype = dbus_g_type_get_collection_specialization (coltype); - if (dbus_g_type_is_fixed (subtype)) + if (_dbus_g_type_is_fixed (subtype)) return demarshal_collection_array (context, iter, value, error); else return demarshal_collection_ptrarray (context, iter, value, error); @@ -1136,9 +975,9 @@ demarshal_collection_array (DBusGValueMarshalCtx *context, elt_gtype = dbus_g_type_get_collection_specialization (G_VALUE_TYPE (value)); g_assert (elt_gtype != G_TYPE_INVALID); - g_assert (dbus_g_type_is_fixed (elt_gtype)); + g_assert (_dbus_g_type_is_fixed (elt_gtype)); - elt_size = dbus_g_type_fixed_get_size (elt_gtype); + elt_size = _dbus_g_type_fixed_get_size (elt_gtype); ret = g_array_new (FALSE, TRUE, elt_size); @@ -1156,7 +995,7 @@ demarshal_collection_array (DBusGValueMarshalCtx *context, } gboolean -dbus_gvalue_demarshal (DBusGValueMarshalCtx *context, +_dbus_gvalue_demarshal (DBusGValueMarshalCtx *context, DBusMessageIter *iter, GValue *value, GError **error) @@ -1182,7 +1021,7 @@ dbus_gvalue_demarshal (DBusGValueMarshalCtx *context, } gboolean -dbus_gvalue_demarshal_variant (DBusGValueMarshalCtx *context, +_dbus_gvalue_demarshal_variant (DBusGValueMarshalCtx *context, DBusMessageIter *iter, GValue *value, GError **error) @@ -1191,7 +1030,7 @@ dbus_gvalue_demarshal_variant (DBusGValueMarshalCtx *context, } GValueArray * -dbus_gvalue_demarshal_message (DBusGValueMarshalCtx *context, +_dbus_gvalue_demarshal_message (DBusGValueMarshalCtx *context, DBusMessage *message, guint n_types, const GType *types, @@ -1225,7 +1064,7 @@ dbus_gvalue_demarshal_message (DBusGValueMarshalCtx *context, gtype = types[index]; g_value_init (value, gtype); - if (!dbus_gvalue_demarshal (context, &iter, value, error)) + if (!_dbus_gvalue_demarshal (context, &iter, value, error)) goto lose; dbus_message_iter_next (&iter); index++; @@ -1433,7 +1272,7 @@ marshal_valuearray (DBusMessageIter *iter, for (i = 0; i < array->n_values; i++) { - if (!dbus_gvalue_marshal (&subiter, g_value_array_get_nth (array, i))) + if (!_dbus_gvalue_marshal (&subiter, g_value_array_get_nth (array, i))) return FALSE; } @@ -1527,10 +1366,10 @@ marshal_map_entry (const GValue *key, &subiter)) goto lose; - if (!dbus_gvalue_marshal (&subiter, key)) + if (!_dbus_gvalue_marshal (&subiter, key)) goto lose; - if (!dbus_gvalue_marshal (&subiter, value)) + if (!_dbus_gvalue_marshal (&subiter, value)) goto lose; if (!dbus_message_iter_close_container (hashdata->iter, &subiter)) @@ -1561,17 +1400,17 @@ marshal_map (DBusMessageIter *iter, ret = FALSE; key_type = dbus_g_type_get_map_key_specialization (gtype); - g_assert (dbus_gtype_is_valid_hash_key (key_type)); + g_assert (_dbus_gtype_is_valid_hash_key (key_type)); value_type = dbus_g_type_get_map_value_specialization (gtype); - g_assert (dbus_gtype_is_valid_hash_value (value_type)); + g_assert (_dbus_gtype_is_valid_hash_value (value_type)); - key_sig = dbus_gtype_to_signature (key_type); + key_sig = _dbus_gtype_to_signature (key_type); if (!key_sig) { g_warning ("Cannot marshal type \"%s\" in map\n", g_type_name (key_type)); return FALSE; } - value_sig = dbus_gtype_to_signature (value_type); + value_sig = _dbus_gtype_to_signature (value_type); if (!value_sig) { g_free (key_sig); @@ -1701,7 +1540,7 @@ marshal_collection (DBusMessageIter *iter, coltype = G_VALUE_TYPE (value); subtype = dbus_g_type_get_collection_specialization (coltype); - if (dbus_g_type_is_fixed (subtype)) + if (_dbus_g_type_is_fixed (subtype)) return marshal_collection_array (iter, value); else return marshal_collection_ptrarray (iter, value); @@ -1723,7 +1562,7 @@ marshal_collection_ptrarray (DBusMessageIter *iter, if (!data.marshaller) return FALSE; - elt_sig = dbus_gtype_to_signature (elt_gtype); + elt_sig = _dbus_gtype_to_signature (elt_gtype); if (!elt_sig) { g_warning ("Cannot marshal type \"%s\" in collection\n", g_type_name (elt_gtype)); @@ -1765,15 +1604,15 @@ marshal_collection_array (DBusMessageIter *iter, char *subsignature_str; elt_gtype = dbus_g_type_get_collection_specialization (G_VALUE_TYPE (value)); - g_assert (dbus_g_type_is_fixed (elt_gtype)); - subsignature_str = dbus_gtype_to_signature (elt_gtype); + g_assert (_dbus_g_type_is_fixed (elt_gtype)); + subsignature_str = _dbus_gtype_to_signature (elt_gtype); if (!subsignature_str) { g_warning ("Cannot marshal type \"%s\" in collection\n", g_type_name (elt_gtype)); return FALSE; } - elt_size = dbus_g_type_fixed_get_size (elt_gtype); + elt_size = _dbus_g_type_fixed_get_size (elt_gtype); array = g_value_get_boxed (value); @@ -1803,7 +1642,7 @@ marshal_collection_array (DBusMessageIter *iter, } gboolean -dbus_gvalue_marshal (DBusMessageIter *iter, +_dbus_gvalue_marshal (DBusMessageIter *iter, const GValue *value) { GType gtype; @@ -1823,7 +1662,7 @@ static void assert_type_maps_to (GType gtype, const char *expected_sig) { char *sig; - sig = dbus_gtype_to_signature (gtype); + sig = _dbus_gtype_to_signature (gtype); g_assert (sig != NULL); g_assert (!strcmp (expected_sig, sig)); g_free (sig); @@ -1832,7 +1671,7 @@ assert_type_maps_to (GType gtype, const char *expected_sig) static void assert_signature_maps_to (const char *sig, GType expected_gtype) { - g_assert (dbus_gtype_from_signature (sig, TRUE) == expected_gtype); + g_assert (_dbus_gtype_from_signature (sig, TRUE) == expected_gtype); } static void @@ -1850,7 +1689,7 @@ assert_bidirectional_mapping (GType gtype, const char *expected_sig) gboolean _dbus_gvalue_test (const char *test_data_dir) { - dbus_g_value_types_init (); + _dbus_g_value_types_init (); assert_bidirectional_mapping (G_TYPE_STRING, DBUS_TYPE_STRING_AS_STRING); assert_bidirectional_mapping (G_TYPE_UCHAR, DBUS_TYPE_BYTE_AS_STRING); diff --git a/glib/dbus-gvalue.h b/glib/dbus-gvalue.h index 99cfd07b..3b41747e 100644 --- a/glib/dbus-gvalue.h +++ b/glib/dbus-gvalue.h @@ -14,36 +14,27 @@ typedef struct { DBusGProxy *proxy; } DBusGValueMarshalCtx; -void dbus_g_value_types_init (void); +void _dbus_g_value_types_init (void); -GType dbus_gtype_from_signature (const char *signature, - gboolean is_client); +char * _dbus_gtype_to_signature (GType type); -GType dbus_gtype_from_signature_iter (DBusSignatureIter *sigiter, - gboolean is_client); - -char * dbus_gtype_to_signature (GType type); - -GArray * dbus_gtypes_from_arg_signature (const char *signature, - gboolean is_client); - -gboolean dbus_gvalue_demarshal (DBusGValueMarshalCtx *context, +gboolean _dbus_gvalue_demarshal (DBusGValueMarshalCtx *context, DBusMessageIter *iter, GValue *value, GError **error); -gboolean dbus_gvalue_demarshal_variant (DBusGValueMarshalCtx *context, +gboolean _dbus_gvalue_demarshal_variant (DBusGValueMarshalCtx *context, DBusMessageIter *iter, GValue *value, GError **error); -GValueArray * dbus_gvalue_demarshal_message (DBusGValueMarshalCtx *context, +GValueArray * _dbus_gvalue_demarshal_message (DBusGValueMarshalCtx *context, DBusMessage *message, guint n_params, const GType *types, GError **error); -gboolean dbus_gvalue_marshal (DBusMessageIter *iter, +gboolean _dbus_gvalue_marshal (DBusMessageIter *iter, const GValue *value); G_END_DECLS diff --git a/test/glib/test-service-glib.c b/test/glib/test-service-glib.c index 1c62a498..7230fd94 100644 --- a/test/glib/test-service-glib.c +++ b/test/glib/test-service-glib.c @@ -463,7 +463,6 @@ my_object_many_stringify (MyObject *obj, GHashTable /* char * -> GValue * */ *va gboolean my_object_rec_arrays (MyObject *obj, GPtrArray *in, GPtrArray **ret, GError **error) { - guint i; char **strs; GArray *ints; guint v_UINT; -- cgit