+2005-08-04 Colin Walters <walters@verbum.org>
+
+ * 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 <walters@verbum.org>
* glib/dbus-gobject.c: Add tests on hardcoded object info; this should
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
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 = \
*/
#include <config.h>
+#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"
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;
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;
{
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
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,
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);
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,
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);
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;
}
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)
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)
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)))
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;
}
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 <glib/gtypes.h>\n");
WRITE_OR_LOSE ("#include <glib/gerror.h>\n");
#include "dbus-gvalue.h"
#include "dbus-gobject.h"
#include "dbus-gvalue-utils.h"
+#include "dbus-gsignature.h"
#include <string.h>
#include <libintl.h>
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
- dbus_g_value_types_init ();
+ _dbus_g_value_types_init ();
dbus_error_init (&derror);
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;
}
#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"
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);
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 &&
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,
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,
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);
/* 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
{
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);
/* 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);
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++;
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)
/* 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",
{
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 (),
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);
g_warning(error);
g_free (error);
}
- dbus_gvalue_marshal (&iter, &value);
+ _dbus_gvalue_marshal (&iter, &value);
}
va_end (args);
#include <dbus/dbus-glib-lowlevel.h>
#include <dbus/dbus-signature.h>
#include "dbus-gutils.h"
+#include "dbus-gsignature.h"
#include "dbus-gvalue.h"
#include "dbus-gvalue-utils.h"
#include "dbus-gobject.h"
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);
}
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++)
{
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;
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,
{
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 */
}
--- /dev/null
+/* -*- 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 <string.h>
+#include <glib.h>
+
+#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;
+}
--- /dev/null
+#ifndef DBUS_GOBJECT_SIGNATURE_H
+#define DBUS_GOBJECT_SIGNATURE_H
+
+#include <dbus/dbus.h>
+#include <dbus/dbus-signature.h>
+#include <glib.h>
+
+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
}
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
}
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? */
}
gboolean
-dbus_gvalue_take (GValue *value,
+_dbus_gvalue_take (GValue *value,
GTypeCValue *cvalue)
{
GType g_type;
}
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;
}
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)
{
}
GDestroyNotify
-dbus_g_hash_free_from_gtype (GType gtype)
+_dbus_g_hash_free_from_gtype (GType gtype)
{
GDestroyNotify func;
gboolean ret;
}
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)
{
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
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;
}
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
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; */
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;
}
void
-dbus_g_type_specialized_builtins_init (void)
+_dbus_g_type_specialized_builtins_init (void)
{
static const DBusGTypeSpecializedCollectionVtable array_vtable = {
{
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));
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);
#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"
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;
return;
dbus_g_type_specialized_init ();
- dbus_g_type_specialized_builtins_init ();
-
+ _dbus_g_type_specialized_builtins_init ();
/* Register basic types */
{
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;
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);
}
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);
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,
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;
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)
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;
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))
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))
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);
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);
}
gboolean
-dbus_gvalue_demarshal (DBusGValueMarshalCtx *context,
+_dbus_gvalue_demarshal (DBusGValueMarshalCtx *context,
DBusMessageIter *iter,
GValue *value,
GError **error)
}
gboolean
-dbus_gvalue_demarshal_variant (DBusGValueMarshalCtx *context,
+_dbus_gvalue_demarshal_variant (DBusGValueMarshalCtx *context,
DBusMessageIter *iter,
GValue *value,
GError **error)
}
GValueArray *
-dbus_gvalue_demarshal_message (DBusGValueMarshalCtx *context,
+_dbus_gvalue_demarshal_message (DBusGValueMarshalCtx *context,
DBusMessage *message,
guint n_types,
const GType *types,
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++;
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;
}
&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))
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);
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);
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));
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);
}
gboolean
-dbus_gvalue_marshal (DBusMessageIter *iter,
+_dbus_gvalue_marshal (DBusMessageIter *iter,
const GValue *value)
{
GType gtype;
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);
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
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);
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
gboolean
my_object_rec_arrays (MyObject *obj, GPtrArray *in, GPtrArray **ret, GError **error)
{
- guint i;
char **strs;
GArray *ints;
guint v_UINT;