X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gobject%2Fgvaluetypes.c;h=3b73876d56a9353ac75cfb24257d249698eaced3;hb=465c7d1ead296b70b8d47ca333554a18f71da11d;hp=d27171c8f6abc5a960661606cd6e24df0a1d9931;hpb=09f8e937f21552d441a5a2b06767a67459195653;p=platform%2Fupstream%2Fglib.git diff --git a/gobject/gvaluetypes.c b/gobject/gvaluetypes.c index d27171c..3b73876 100644 --- a/gobject/gvaluetypes.c +++ b/gobject/gvaluetypes.c @@ -1,5 +1,5 @@ /* GObject - GLib Type, Object, Parameter and Signal Library - * Copyright (C) 1997, 1998, 1999, 2000 Tim Janik and Red Hat, Inc. + * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -16,254 +16,349 @@ * Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, MA 02111-1307, USA. */ + +/* + * MT safe + */ + +#include "gobjectalias.h" #include "gvaluetypes.h" #include "gvaluecollector.h" #include +#include /* qsort() */ /* --- value functions --- */ static void -value_long0_init (GValue *value) +value_init_long0 (GValue *value) { value->data[0].v_long = 0; } static void -value_long0_copy (const GValue *src_value, +value_copy_long0 (const GValue *src_value, GValue *dest_value) { dest_value->data[0].v_long = src_value->data[0].v_long; } static gchar* -value_char_lcopy_value (const GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_lcopy_char (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - gint8 *int8_p = collect_value->v_pointer; + gint8 *int8_p = collect_values[0].v_pointer; if (!int8_p) return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); *int8_p = value->data[0].v_int; - *collect_type = 0; return NULL; } static gchar* -value_boolean_lcopy_value (const GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_lcopy_boolean (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - gboolean *bool_p = collect_value->v_pointer; + gboolean *bool_p = collect_values[0].v_pointer; if (!bool_p) return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); *bool_p = value->data[0].v_int; - *collect_type = 0; return NULL; } static gchar* -value_int_collect_value (GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_collect_int (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - value->data[0].v_int = collect_value->v_int; + value->data[0].v_int = collect_values[0].v_int; - *collect_type = 0; return NULL; } static gchar* -value_int_lcopy_value (const GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_lcopy_int (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - gint *int_p = collect_value->v_pointer; + gint *int_p = collect_values[0].v_pointer; if (!int_p) return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); *int_p = value->data[0].v_int; - *collect_type = 0; return NULL; } static gchar* -value_long_collect_value (GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_collect_long (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - value->data[0].v_long = collect_value->v_long; + value->data[0].v_long = collect_values[0].v_long; - *collect_type = 0; return NULL; } static gchar* -value_long_lcopy_value (const GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_lcopy_long (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - glong *long_p = collect_value->v_pointer; + glong *long_p = collect_values[0].v_pointer; if (!long_p) return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); *long_p = value->data[0].v_long; - *collect_type = 0; return NULL; } static void -value_float_init (GValue *value) +value_init_int64 (GValue *value) +{ + value->data[0].v_int64 = 0; +} + +static void +value_copy_int64 (const GValue *src_value, + GValue *dest_value) +{ + dest_value->data[0].v_int64 = src_value->data[0].v_int64; +} + +static gchar* +value_collect_int64 (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) +{ + value->data[0].v_int64 = collect_values[0].v_int64; + + return NULL; +} + +static gchar* +value_lcopy_int64 (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) +{ + gint64 *int64_p = collect_values[0].v_pointer; + + if (!int64_p) + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + + *int64_p = value->data[0].v_int64; + + return NULL; +} + +static void +value_init_float (GValue *value) { value->data[0].v_float = 0.0; } static void -value_float_copy (const GValue *src_value, +value_copy_float (const GValue *src_value, GValue *dest_value) { dest_value->data[0].v_float = src_value->data[0].v_float; } static gchar* -value_float_collect_value (GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_collect_float (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - value->data[0].v_float = collect_value->v_double; + value->data[0].v_float = collect_values[0].v_double; - *collect_type = 0; return NULL; } static gchar* -value_float_lcopy_value (const GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_lcopy_float (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - gfloat *float_p = collect_value->v_pointer; + gfloat *float_p = collect_values[0].v_pointer; if (!float_p) return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); *float_p = value->data[0].v_float; - *collect_type = 0; return NULL; } static void -value_double_init (GValue *value) +value_init_double (GValue *value) { value->data[0].v_double = 0.0; } static void -value_double_copy (const GValue *src_value, +value_copy_double (const GValue *src_value, GValue *dest_value) { dest_value->data[0].v_double = src_value->data[0].v_double; } static gchar* -value_double_collect_value (GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_collect_double (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - value->data[0].v_double = collect_value->v_double; + value->data[0].v_double = collect_values[0].v_double; - *collect_type = 0; return NULL; } static gchar* -value_double_lcopy_value (const GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_lcopy_double (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - gdouble *double_p = collect_value->v_pointer; + gdouble *double_p = collect_values[0].v_pointer; if (!double_p) return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); *double_p = value->data[0].v_double; - *collect_type = 0; return NULL; } static void -value_string_init (GValue *value) +value_init_string (GValue *value) { value->data[0].v_pointer = NULL; } static void -value_string_free_value (GValue *value) +value_free_string (GValue *value) { - g_free (value->data[0].v_pointer); + if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)) + g_free (value->data[0].v_pointer); } static void -value_string_copy_value (const GValue *src_value, - GValue *dest_value) +value_copy_string (const GValue *src_value, + GValue *dest_value) { dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer); } static gchar* -value_string_collect_value (GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) -{ - value->data[0].v_pointer = g_strdup (collect_value->v_pointer); +value_collect_string (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) +{ + if (!collect_values[0].v_pointer) + value->data[0].v_pointer = NULL; + else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) + { + value->data[0].v_pointer = collect_values[0].v_pointer; + value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS; + } + else + value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer); - *collect_type = 0; return NULL; } static gchar* -value_string_lcopy_value (const GValue *value, - guint nth_value, - GType *collect_type, - GTypeCValue *collect_value) +value_lcopy_string (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) { - gchar **string_p = collect_value->v_pointer; + gchar **string_p = collect_values[0].v_pointer; if (!string_p) return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); - *string_p = g_strdup (value->data[0].v_pointer); + if (!value->data[0].v_pointer) + *string_p = NULL; + else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) + *string_p = value->data[0].v_pointer; + else + *string_p = g_strdup (value->data[0].v_pointer); - *collect_type = 0; + return NULL; +} + +static void +value_init_pointer (GValue *value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_copy_pointer (const GValue *src_value, + GValue *dest_value) +{ + dest_value->data[0].v_pointer = src_value->data[0].v_pointer; +} + +static gpointer +value_peek_pointer0 (const GValue *value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_collect_pointer (GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) +{ + value->data[0].v_pointer = collect_values[0].v_pointer; + + return NULL; +} + +static gchar* +value_lcopy_pointer (const GValue *value, + guint n_collect_values, + GTypeCValue *collect_values, + guint collect_flags) +{ + gpointer *pointer_p = collect_values[0].v_pointer; + + if (!pointer_p) + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + + *pointer_p = value->data[0].v_pointer; + return NULL; } /* --- type initialization --- */ void -g_value_types_init (void) /* sync with gtype.c */ +g_value_types_init (void) { GTypeInfo info = { 0, /* class_size */ @@ -284,18 +379,19 @@ g_value_types_init (void) /* sync with gtype.c */ */ { static const GTypeValueTable value_table = { - value_long0_init, /* value_init */ + value_init_long0, /* value_init */ NULL, /* value_free */ - value_long0_copy, /* value_copy */ - G_VALUE_COLLECT_INT, /* collect_type */ - value_int_collect_value, /* collect_value */ - G_VALUE_COLLECT_POINTER, /* lcopy_type */ - value_char_lcopy_value, /* lcopy_value */ + value_copy_long0, /* value_copy */ + NULL, /* value_peek_pointer */ + "i", /* collect_format */ + value_collect_int, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_char, /* lcopy_value */ }; info.value_table = &value_table; - type = g_type_register_fundamental (G_TYPE_CHAR, "gchar", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_CHAR, "gchar", &info, &finfo, 0); g_assert (type == G_TYPE_CHAR); - type = g_type_register_fundamental (G_TYPE_UCHAR, "guchar", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_UCHAR, "guchar", &info, &finfo, 0); g_assert (type == G_TYPE_UCHAR); } @@ -303,16 +399,17 @@ g_value_types_init (void) /* sync with gtype.c */ */ { static const GTypeValueTable value_table = { - value_long0_init, /* value_init */ + value_init_long0, /* value_init */ NULL, /* value_free */ - value_long0_copy, /* value_copy */ - G_VALUE_COLLECT_INT, /* collect_type */ - value_int_collect_value, /* collect_value */ - G_VALUE_COLLECT_POINTER, /* lcopy_type */ - value_boolean_lcopy_value, /* lcopy_value */ + value_copy_long0, /* value_copy */ + NULL, /* value_peek_pointer */ + "i", /* collect_format */ + value_collect_int, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_boolean, /* lcopy_value */ }; info.value_table = &value_table; - type = g_type_register_fundamental (G_TYPE_BOOLEAN, "gboolean", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_BOOLEAN, "gboolean", &info, &finfo, 0); g_assert (type == G_TYPE_BOOLEAN); } @@ -320,18 +417,19 @@ g_value_types_init (void) /* sync with gtype.c */ */ { static const GTypeValueTable value_table = { - value_long0_init, /* value_init */ + value_init_long0, /* value_init */ NULL, /* value_free */ - value_long0_copy, /* value_copy */ - G_VALUE_COLLECT_INT, /* collect_type */ - value_int_collect_value, /* collect_value */ - G_VALUE_COLLECT_POINTER, /* lcopy_type */ - value_int_lcopy_value, /* lcopy_value */ + value_copy_long0, /* value_copy */ + NULL, /* value_peek_pointer */ + "i", /* collect_format */ + value_collect_int, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_int, /* lcopy_value */ }; info.value_table = &value_table; - type = g_type_register_fundamental (G_TYPE_INT, "gint", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_INT, "gint", &info, &finfo, 0); g_assert (type == G_TYPE_INT); - type = g_type_register_fundamental (G_TYPE_UINT, "guint", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_UINT, "guint", &info, &finfo, 0); g_assert (type == G_TYPE_UINT); } @@ -339,35 +437,57 @@ g_value_types_init (void) /* sync with gtype.c */ */ { static const GTypeValueTable value_table = { - value_long0_init, /* value_init */ + value_init_long0, /* value_init */ NULL, /* value_free */ - value_long0_copy, /* value_copy */ - G_VALUE_COLLECT_LONG, /* collect_type */ - value_long_collect_value, /* collect_value */ - G_VALUE_COLLECT_POINTER, /* lcopy_type */ - value_long_lcopy_value, /* lcopy_value */ + value_copy_long0, /* value_copy */ + NULL, /* value_peek_pointer */ + "l", /* collect_format */ + value_collect_long, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_long, /* lcopy_value */ }; info.value_table = &value_table; - type = g_type_register_fundamental (G_TYPE_LONG, "glong", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_LONG, "glong", &info, &finfo, 0); g_assert (type == G_TYPE_LONG); - type = g_type_register_fundamental (G_TYPE_ULONG, "gulong", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_ULONG, "gulong", &info, &finfo, 0); g_assert (type == G_TYPE_ULONG); } + /* G_TYPE_INT64 / G_TYPE_UINT64 + */ + { + static const GTypeValueTable value_table = { + value_init_int64, /* value_init */ + NULL, /* value_free */ + value_copy_int64, /* value_copy */ + NULL, /* value_peek_pointer */ + "q", /* collect_format */ + value_collect_int64, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_int64, /* lcopy_value */ + }; + info.value_table = &value_table; + type = g_type_register_fundamental (G_TYPE_INT64, "gint64", &info, &finfo, 0); + g_assert (type == G_TYPE_INT64); + type = g_type_register_fundamental (G_TYPE_UINT64, "guint64", &info, &finfo, 0); + g_assert (type == G_TYPE_UINT64); + } + /* G_TYPE_FLOAT */ { static const GTypeValueTable value_table = { - value_float_init, /* value_init */ + value_init_float, /* value_init */ NULL, /* value_free */ - value_float_copy, /* value_copy */ - G_VALUE_COLLECT_DOUBLE, /* collect_type */ - value_float_collect_value, /* collect_value */ - G_VALUE_COLLECT_POINTER, /* lcopy_type */ - value_float_lcopy_value, /* lcopy_value */ + value_copy_float, /* value_copy */ + NULL, /* value_peek_pointer */ + "d", /* collect_format */ + value_collect_float, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_float, /* lcopy_value */ }; info.value_table = &value_table; - type = g_type_register_fundamental (G_TYPE_FLOAT, "gfloat", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_FLOAT, "gfloat", &info, &finfo, 0); g_assert (type == G_TYPE_FLOAT); } @@ -375,16 +495,17 @@ g_value_types_init (void) /* sync with gtype.c */ */ { static const GTypeValueTable value_table = { - value_double_init, /* value_init */ - NULL, /* value_free */ - value_double_copy, /* value_copy */ - G_VALUE_COLLECT_DOUBLE, /* collect_type */ - value_double_collect_value, /* collect_value */ - G_VALUE_COLLECT_POINTER, /* lcopy_type */ - value_double_lcopy_value, /* lcopy_value */ + value_init_double, /* value_init */ + NULL, /* value_free */ + value_copy_double, /* value_copy */ + NULL, /* value_peek_pointer */ + "d", /* collect_format */ + value_collect_double, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_double, /* lcopy_value */ }; info.value_table = &value_table; - type = g_type_register_fundamental (G_TYPE_DOUBLE, "gdouble", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_DOUBLE, "gdouble", &info, &finfo, 0); g_assert (type == G_TYPE_DOUBLE); } @@ -392,52 +513,71 @@ g_value_types_init (void) /* sync with gtype.c */ */ { static const GTypeValueTable value_table = { - value_string_init, /* value_init */ - value_string_free_value, /* value_free */ - value_string_copy_value, /* value_copy */ - G_VALUE_COLLECT_POINTER, /* collect_type */ - value_string_collect_value, /* collect_value */ - G_VALUE_COLLECT_POINTER, /* lcopy_type */ - value_string_lcopy_value, /* lcopy_value */ + value_init_string, /* value_init */ + value_free_string, /* value_free */ + value_copy_string, /* value_copy */ + value_peek_pointer0, /* value_peek_pointer */ + "p", /* collect_format */ + value_collect_string, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_string, /* lcopy_value */ }; info.value_table = &value_table; - type = g_type_register_fundamental (G_TYPE_STRING, "gstring", &info, &finfo); + type = g_type_register_fundamental (G_TYPE_STRING, "gchararray", &info, &finfo, 0); g_assert (type == G_TYPE_STRING); } + + /* G_TYPE_POINTER + */ + { + static const GTypeValueTable value_table = { + value_init_pointer, /* value_init */ + NULL, /* value_free */ + value_copy_pointer, /* value_copy */ + value_peek_pointer0, /* value_peek_pointer */ + "p", /* collect_format */ + value_collect_pointer, /* collect_value */ + "p", /* lcopy_format */ + value_lcopy_pointer, /* lcopy_value */ + }; + info.value_table = &value_table; + type = g_type_register_fundamental (G_TYPE_POINTER, "gpointer", &info, &finfo, 0); + g_assert (type == G_TYPE_POINTER); + } } /* --- GValue functions --- */ void g_value_set_char (GValue *value, - gint8 v_char) + gchar v_char) { - g_return_if_fail (G_IS_VALUE_CHAR (value)); + g_return_if_fail (G_VALUE_HOLDS_CHAR (value)); value->data[0].v_int = v_char; } -gint8 -g_value_get_char (GValue *value) +gchar +g_value_get_char (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_CHAR (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0); return value->data[0].v_int; } void g_value_set_uchar (GValue *value, - guint8 v_uchar) + guchar v_uchar) { - g_return_if_fail (G_IS_VALUE_UCHAR (value)); + g_return_if_fail (G_VALUE_HOLDS_UCHAR (value)); value->data[0].v_uint = v_uchar; } -guint8 -g_value_get_uchar (GValue *value) +guchar +g_value_get_uchar (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_UCHAR (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0); return value->data[0].v_uint; } @@ -446,15 +586,15 @@ void g_value_set_boolean (GValue *value, gboolean v_boolean) { - g_return_if_fail (G_IS_VALUE_BOOLEAN (value)); + g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value)); - value->data[0].v_int = v_boolean; + value->data[0].v_int = v_boolean != FALSE; } gboolean -g_value_get_boolean (GValue *value) +g_value_get_boolean (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_BOOLEAN (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0); return value->data[0].v_int; } @@ -463,15 +603,15 @@ void g_value_set_int (GValue *value, gint v_int) { - g_return_if_fail (G_IS_VALUE_INT (value)); + g_return_if_fail (G_VALUE_HOLDS_INT (value)); value->data[0].v_int = v_int; } gint -g_value_get_int (GValue *value) +g_value_get_int (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_INT (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0); return value->data[0].v_int; } @@ -480,15 +620,15 @@ void g_value_set_uint (GValue *value, guint v_uint) { - g_return_if_fail (G_IS_VALUE_UINT (value)); + g_return_if_fail (G_VALUE_HOLDS_UINT (value)); value->data[0].v_uint = v_uint; } guint -g_value_get_uint (GValue *value) +g_value_get_uint (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_UINT (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0); return value->data[0].v_uint; } @@ -497,15 +637,15 @@ void g_value_set_long (GValue *value, glong v_long) { - g_return_if_fail (G_IS_VALUE_LONG (value)); + g_return_if_fail (G_VALUE_HOLDS_LONG (value)); value->data[0].v_long = v_long; } glong -g_value_get_long (GValue *value) +g_value_get_long (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_LONG (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0); return value->data[0].v_long; } @@ -514,32 +654,66 @@ void g_value_set_ulong (GValue *value, gulong v_ulong) { - g_return_if_fail (G_IS_VALUE_ULONG (value)); + g_return_if_fail (G_VALUE_HOLDS_ULONG (value)); value->data[0].v_ulong = v_ulong; } gulong -g_value_get_ulong (GValue *value) +g_value_get_ulong (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_ULONG (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0); return value->data[0].v_ulong; } void +g_value_set_int64 (GValue *value, + gint64 v_int64) +{ + g_return_if_fail (G_VALUE_HOLDS_INT64 (value)); + + value->data[0].v_int64 = v_int64; +} + +gint64 +g_value_get_int64 (const GValue *value) +{ + g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0); + + return value->data[0].v_int64; +} + +void +g_value_set_uint64 (GValue *value, + guint64 v_uint64) +{ + g_return_if_fail (G_VALUE_HOLDS_UINT64 (value)); + + value->data[0].v_uint64 = v_uint64; +} + +guint64 +g_value_get_uint64 (const GValue *value) +{ + g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0); + + return value->data[0].v_uint64; +} + +void g_value_set_float (GValue *value, gfloat v_float) { - g_return_if_fail (G_IS_VALUE_FLOAT (value)); + g_return_if_fail (G_VALUE_HOLDS_FLOAT (value)); value->data[0].v_float = v_float; } gfloat -g_value_get_float (GValue *value) +g_value_get_float (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_FLOAT (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0); return value->data[0].v_float; } @@ -548,15 +722,15 @@ void g_value_set_double (GValue *value, gdouble v_double) { - g_return_if_fail (G_IS_VALUE_DOUBLE (value)); + g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value)); value->data[0].v_double = v_double; } gdouble -g_value_get_double (GValue *value) +g_value_get_double (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_DOUBLE (value), 0); + g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0); return value->data[0].v_double; } @@ -565,24 +739,170 @@ void g_value_set_string (GValue *value, const gchar *v_string) { - g_return_if_fail (G_IS_VALUE_STRING (value)); + g_return_if_fail (G_VALUE_HOLDS_STRING (value)); - g_free (value->data[0].v_pointer); + if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) + value->data[1].v_uint = 0; + else + g_free (value->data[0].v_pointer); value->data[0].v_pointer = g_strdup (v_string); } -gchar* -g_value_get_string (GValue *value) +void +g_value_set_static_string (GValue *value, + const gchar *v_string) { - g_return_val_if_fail (G_IS_VALUE_STRING (value), NULL); + g_return_if_fail (G_VALUE_HOLDS_STRING (value)); + + if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)) + g_free (value->data[0].v_pointer); + value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS; + value->data[0].v_pointer = (gchar*) v_string; +} + +void +g_value_set_string_take_ownership (GValue *value, + gchar *v_string) +{ + g_value_take_string (value, v_string); +} + +void +g_value_take_string (GValue *value, + gchar *v_string) +{ + g_return_if_fail (G_VALUE_HOLDS_STRING (value)); + + if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) + value->data[1].v_uint = 0; + else + g_free (value->data[0].v_pointer); + value->data[0].v_pointer = v_string; +} + +G_CONST_RETURN gchar* +g_value_get_string (const GValue *value) +{ + g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL); return value->data[0].v_pointer; } gchar* -g_value_dup_string (GValue *value) +g_value_dup_string (const GValue *value) { - g_return_val_if_fail (G_IS_VALUE_STRING (value), NULL); + g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL); return g_strdup (value->data[0].v_pointer); } + +void +g_value_set_pointer (GValue *value, + gpointer v_pointer) +{ + g_return_if_fail (G_VALUE_HOLDS_POINTER (value)); + + value->data[0].v_pointer = v_pointer; +} + +gpointer +g_value_get_pointer (const GValue *value) +{ + g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL); + + return value->data[0].v_pointer; +} + +/* need extra includes for g_strdup_value_contents() ;( */ +#include "gobject.h" +#include "gparam.h" +#include "gboxed.h" +#include "genums.h" + +gchar* +g_strdup_value_contents (const GValue *value) +{ + const gchar *src; + gchar *contents; + + g_return_val_if_fail (G_IS_VALUE (value), NULL); + + if (G_VALUE_HOLDS_STRING (value)) + { + src = g_value_get_string (value); + + if (!src) + contents = g_strdup ("NULL"); + else + { + gchar *s = g_strescape (src, NULL); + + contents = g_strdup_printf ("\"%s\"", s); + g_free (s); + } + } + else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING)) + { + GValue tmp_value = { 0, }; + gchar *s; + + g_value_init (&tmp_value, G_TYPE_STRING); + g_value_transform (value, &tmp_value); + s = g_strescape (g_value_get_string (&tmp_value), NULL); + g_value_unset (&tmp_value); + if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value)) + contents = g_strdup_printf ("((%s) %s)", + g_type_name (G_VALUE_TYPE (value)), + s); + else + contents = g_strdup (s ? s : "NULL"); + g_free (s); + } + else if (g_value_fits_pointer (value)) + { + gpointer p = g_value_peek_pointer (value); + + if (!p) + contents = g_strdup ("NULL"); + else if (G_VALUE_HOLDS_OBJECT (value)) + contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p); + else if (G_VALUE_HOLDS_PARAM (value)) + contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p); + else if (G_VALUE_HOLDS_BOXED (value)) + contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p); + else if (G_VALUE_HOLDS_POINTER (value)) + contents = g_strdup_printf ("((gpointer) %p)", p); + else + contents = g_strdup ("???"); + } + else + contents = g_strdup ("???"); + + return contents; +} + +GType +g_pointer_type_register_static (const gchar *name) +{ + static const GTypeInfo type_info = { + 0, /* class_size */ + NULL, /* base_init */ + NULL, /* base_finalize */ + NULL, /* class_init */ + NULL, /* class_finalize */ + NULL, /* class_data */ + 0, /* instance_size */ + 0, /* n_preallocs */ + NULL, /* instance_init */ + NULL /* value_table */ + }; + GType type; + + g_return_val_if_fail (name != NULL, 0); + g_return_val_if_fail (g_type_from_name (name) == 0, 0); + + type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0); + + return type; +} +