X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gobject%2Fgvaluetypes.c;h=4b234a3f71741c589ae02432942c0d26ded6a2ce;hb=2e5bd8cf47f9e1559ccc44823a2f321b8ff8c1ea;hp=cdbcc070edacf14734125a0b144defd3d8d2a150;hpb=791bfecb790b42763e8f5e955e1c882e5f91edaf;p=platform%2Fupstream%2Fglib.git

diff --git a/gobject/gvaluetypes.c b/gobject/gvaluetypes.c
index cdbcc07..4b234a3 100644
--- a/gobject/gvaluetypes.c
+++ b/gobject/gvaluetypes.c
@@ -1,5 +1,6 @@
 /* GObject - GLib Type, Object, Parameter and Signal Library
  * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
+ * Copyright © 2010 Christian Persch
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -12,20 +13,25 @@
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General
- * Public License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  */
 
 /*
  * MT safe
  */
 
-#include	"gvaluetypes.h"
+#include "config.h"
 
-#include	"gvaluecollector.h"
-#include	<string.h>
-#include	<stdlib.h>	/* qsort() */
+#include <string.h>
+#include <stdlib.h> /* qsort() */
+
+#include "gvaluetypes.h"
+#include "gtype-private.h"
+#include "gvaluecollector.h"
+#include "gobject.h"
+#include "gparam.h"
+#include "gboxed.h"
+#include "genums.h"
 
 
 /* --- value functions --- */
@@ -51,7 +57,7 @@ value_lcopy_char (const GValue *value,
   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));
+    return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
   
   *int8_p = value->data[0].v_int;
   
@@ -67,7 +73,7 @@ value_lcopy_boolean (const GValue *value,
   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));
+    return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
   
   *bool_p = value->data[0].v_int;
   
@@ -94,7 +100,7 @@ value_lcopy_int (const GValue *value,
   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));
+    return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
   
   *int_p = value->data[0].v_int;
   
@@ -121,7 +127,7 @@ value_lcopy_long (const GValue *value,
   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));
+    return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
   
   *long_p = value->data[0].v_long;
   
@@ -129,6 +135,46 @@ value_lcopy_long (const GValue *value,
 }
 
 static void
+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;
@@ -161,7 +207,7 @@ value_lcopy_float (const GValue *value,
   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));
+    return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
   
   *float_p = value->data[0].v_float;
   
@@ -201,7 +247,7 @@ value_lcopy_double (const GValue *value,
   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));
+    return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
   
   *double_p = value->data[0].v_double;
   
@@ -256,7 +302,7 @@ value_lcopy_string (const GValue *value,
   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));
+    return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
   
   if (!value->data[0].v_pointer)
     *string_p = NULL;
@@ -307,17 +353,74 @@ value_lcopy_pointer (const GValue *value,
   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));
+    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;
 }
 
+static void
+value_free_variant (GValue *value)
+{
+  if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) &&
+      value->data[0].v_pointer)
+    g_variant_unref (value->data[0].v_pointer);
+}
+
+static void
+value_copy_variant (const GValue *src_value,
+		   GValue	*dest_value)
+{
+  if (src_value->data[0].v_pointer)
+    dest_value->data[0].v_pointer = g_variant_ref_sink (src_value->data[0].v_pointer);
+  else
+    dest_value->data[0].v_pointer = NULL;
+}
+
+static gchar*
+value_collect_variant (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_variant_ref_sink (collect_values[0].v_pointer);
+
+  return NULL;
+}
+
+static gchar*
+value_lcopy_variant (const GValue *value,
+		    guint         n_collect_values,
+		    GTypeCValue  *collect_values,
+		    guint         collect_flags)
+{
+  GVariant **variant_p = collect_values[0].v_pointer;
+
+  if (!variant_p)
+    return g_strdup_printf ("value location for '%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+
+  if (!value->data[0].v_pointer)
+    *variant_p = NULL;
+  else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
+    *variant_p = value->data[0].v_pointer;
+  else
+    *variant_p = g_variant_ref_sink (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 */
@@ -348,9 +451,9 @@ g_value_types_init (void)  /* sync with gtype.c */
       value_lcopy_char,		/* lcopy_value */
     };
     info.value_table = &value_table;
-    type = g_type_register_fundamental (G_TYPE_CHAR, "gchar", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0);
     g_assert (type == G_TYPE_CHAR);
-    type = g_type_register_fundamental (G_TYPE_UCHAR, "guchar", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0);
     g_assert (type == G_TYPE_UCHAR);
   }
 
@@ -368,7 +471,7 @@ g_value_types_init (void)  /* sync with gtype.c */
       value_lcopy_boolean,	 /* lcopy_value */
     };
     info.value_table = &value_table;
-    type = g_type_register_fundamental (G_TYPE_BOOLEAN, "gboolean", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0);
     g_assert (type == G_TYPE_BOOLEAN);
   }
   
@@ -386,9 +489,9 @@ g_value_types_init (void)  /* sync with gtype.c */
       value_lcopy_int,		/* lcopy_value */
     };
     info.value_table = &value_table;
-    type = g_type_register_fundamental (G_TYPE_INT, "gint", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0);
     g_assert (type == G_TYPE_INT);
-    type = g_type_register_fundamental (G_TYPE_UINT, "guint", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0);
     g_assert (type == G_TYPE_UINT);
   }
 
@@ -406,12 +509,32 @@ g_value_types_init (void)  /* sync with gtype.c */
       value_lcopy_long,		/* lcopy_value */
     };
     info.value_table = &value_table;
-    type = g_type_register_fundamental (G_TYPE_LONG, "glong", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0);
     g_assert (type == G_TYPE_LONG);
-    type = g_type_register_fundamental (G_TYPE_ULONG, "gulong", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("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, g_intern_static_string ("gint64"), &info, &finfo, 0);
+    g_assert (type == G_TYPE_INT64);
+    type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0);
+    g_assert (type == G_TYPE_UINT64);
+  }
+  
   /* G_TYPE_FLOAT
    */
   {
@@ -426,7 +549,7 @@ g_value_types_init (void)  /* sync with gtype.c */
       value_lcopy_float,	 /* lcopy_value */
     };
     info.value_table = &value_table;
-    type = g_type_register_fundamental (G_TYPE_FLOAT, "gfloat", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0);
     g_assert (type == G_TYPE_FLOAT);
   }
   
@@ -444,7 +567,7 @@ g_value_types_init (void)  /* sync with gtype.c */
       value_lcopy_double,	/* lcopy_value */
     };
     info.value_table = &value_table;
-    type = g_type_register_fundamental (G_TYPE_DOUBLE, "gdouble", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0);
     g_assert (type == G_TYPE_DOUBLE);
   }
 
@@ -462,7 +585,7 @@ g_value_types_init (void)  /* sync with gtype.c */
       value_lcopy_string,	/* lcopy_value */
     };
     info.value_table = &value_table;
-    type = g_type_register_fundamental (G_TYPE_STRING, "gchararray", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_STRING, g_intern_static_string ("gchararray"), &info, &finfo, 0);
     g_assert (type == G_TYPE_STRING);
   }
 
@@ -480,13 +603,39 @@ g_value_types_init (void)  /* sync with gtype.c */
       value_lcopy_pointer,	/* lcopy_value */
     };
     info.value_table = &value_table;
-    type = g_type_register_fundamental (G_TYPE_POINTER, "gpointer", &info, &finfo, 0);
+    type = g_type_register_fundamental (G_TYPE_POINTER, g_intern_static_string ("gpointer"), &info, &finfo, 0);
     g_assert (type == G_TYPE_POINTER);
   }
+
+  /* G_TYPE_VARIANT
+   */
+  {
+    static const GTypeValueTable value_table = {
+      value_init_pointer,	/* value_init */
+      value_free_variant,	/* value_free */
+      value_copy_variant,	/* value_copy */
+      value_peek_pointer0,	/* value_peek_pointer */
+      "p",			/* collect_format */
+      value_collect_variant,	/* collect_value */
+      "p",			/* lcopy_format */
+      value_lcopy_variant,	/* lcopy_value */
+    };
+    info.value_table = &value_table;
+    type = g_type_register_fundamental (G_TYPE_VARIANT, g_intern_static_string ("GVariant"), &info, &finfo, 0);
+    g_assert (type == G_TYPE_VARIANT);
+  }
 }
 
 
 /* --- GValue functions --- */
+/**
+ * g_value_set_char:
+ * @value: a valid #GValue of type %G_TYPE_CHAR
+ * @v_char: character value to be set
+ *
+ * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
+ * Deprecated: 2.32: This function's input type is broken, see g_value_set_schar()
+ */
 void
 g_value_set_char (GValue *value,
 		  gchar	  v_char)
@@ -496,6 +645,18 @@ g_value_set_char (GValue *value,
   value->data[0].v_int = v_char;
 }
 
+/**
+ * g_value_get_char:
+ * @value: a valid #GValue of type %G_TYPE_CHAR
+ *
+ * Do not use this function; it is broken on platforms where the %char
+ * type is unsigned, such as ARM and PowerPC.  See g_value_get_schar().
+ *
+ * Get the contents of a %G_TYPE_CHAR #GValue.  
+ * 
+ * Returns: character contents of @value
+ * Deprecated: 2.32: This function's return type is broken, see g_value_get_schar()
+ */
 gchar
 g_value_get_char (const GValue *value)
 {
@@ -504,6 +665,48 @@ g_value_get_char (const GValue *value)
   return value->data[0].v_int;
 }
 
+/**
+ * g_value_set_schar:
+ * @value: a valid #GValue of type %G_TYPE_CHAR
+ * @v_char: signed 8 bit integer to be set
+ *
+ * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
+ *
+ * Since: 2.32
+ */
+void
+g_value_set_schar (GValue *value,
+		   gint8   v_char)
+{
+  g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
+  
+  value->data[0].v_int = v_char;
+}
+
+/**
+ * g_value_get_schar:
+ * @value: a valid #GValue of type %G_TYPE_CHAR
+ *
+ * Get the contents of a %G_TYPE_CHAR #GValue.
+ * 
+ * Returns: signed 8 bit integer contents of @value
+ * Since: 2.32
+ */
+gint8
+g_value_get_schar (const GValue *value)
+{
+  g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
+  
+  return value->data[0].v_int;
+}
+
+/**
+ * g_value_set_uchar:
+ * @value: a valid #GValue of type %G_TYPE_UCHAR
+ * @v_uchar: unsigned character value to be set
+ *
+ * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
+ */
 void
 g_value_set_uchar (GValue *value,
 		   guchar  v_uchar)
@@ -513,6 +716,14 @@ g_value_set_uchar (GValue *value,
   value->data[0].v_uint = v_uchar;
 }
 
+/**
+ * g_value_get_uchar:
+ * @value: a valid #GValue of type %G_TYPE_UCHAR
+ *
+ * Get the contents of a %G_TYPE_UCHAR #GValue.
+ *
+ * Returns: unsigned character contents of @value
+ */
 guchar
 g_value_get_uchar (const GValue *value)
 {
@@ -521,6 +732,13 @@ g_value_get_uchar (const GValue *value)
   return value->data[0].v_uint;
 }
 
+/**
+ * g_value_set_boolean:
+ * @value: a valid #GValue of type %G_TYPE_BOOLEAN
+ * @v_boolean: boolean value to be set
+ *
+ * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
+ */
 void
 g_value_set_boolean (GValue  *value,
 		     gboolean v_boolean)
@@ -530,6 +748,14 @@ g_value_set_boolean (GValue  *value,
   value->data[0].v_int = v_boolean != FALSE;
 }
 
+/**
+ * g_value_get_boolean:
+ * @value: a valid #GValue of type %G_TYPE_BOOLEAN
+ *
+ * Get the contents of a %G_TYPE_BOOLEAN #GValue.
+ *
+ * Returns: boolean contents of @value
+ */
 gboolean
 g_value_get_boolean (const GValue *value)
 {
@@ -538,6 +764,13 @@ g_value_get_boolean (const GValue *value)
   return value->data[0].v_int;
 }
 
+/**
+ * g_value_set_int:
+ * @value: a valid #GValue of type %G_TYPE_INT
+ * @v_int: integer value to be set
+ *
+ * Set the contents of a %G_TYPE_INT #GValue to @v_int.
+ */
 void
 g_value_set_int (GValue *value,
 		 gint	 v_int)
@@ -547,6 +780,14 @@ g_value_set_int (GValue *value,
   value->data[0].v_int = v_int;
 }
 
+/**
+ * g_value_get_int:
+ * @value: a valid #GValue of type %G_TYPE_INT
+ *
+ * Get the contents of a %G_TYPE_INT #GValue.
+ *
+ * Returns: integer contents of @value
+ */
 gint
 g_value_get_int (const GValue *value)
 {
@@ -555,6 +796,13 @@ g_value_get_int (const GValue *value)
   return value->data[0].v_int;
 }
 
+/**
+ * g_value_set_uint:
+ * @value: a valid #GValue of type %G_TYPE_UINT
+ * @v_uint: unsigned integer value to be set
+ *
+ * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
+ */
 void
 g_value_set_uint (GValue *value,
 		  guint	  v_uint)
@@ -564,6 +812,14 @@ g_value_set_uint (GValue *value,
   value->data[0].v_uint = v_uint;
 }
 
+/**
+ * g_value_get_uint:
+ * @value: a valid #GValue of type %G_TYPE_UINT
+ *
+ * Get the contents of a %G_TYPE_UINT #GValue.
+ *
+ * Returns: unsigned integer contents of @value
+ */
 guint
 g_value_get_uint (const GValue *value)
 {
@@ -572,6 +828,13 @@ g_value_get_uint (const GValue *value)
   return value->data[0].v_uint;
 }
 
+/**
+ * g_value_set_long:
+ * @value: a valid #GValue of type %G_TYPE_LONG
+ * @v_long: long integer value to be set
+ *
+ * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
+ */
 void
 g_value_set_long (GValue *value,
 		  glong	  v_long)
@@ -581,6 +844,14 @@ g_value_set_long (GValue *value,
   value->data[0].v_long = v_long;
 }
 
+/**
+ * g_value_get_long:
+ * @value: a valid #GValue of type %G_TYPE_LONG
+ *
+ * Get the contents of a %G_TYPE_LONG #GValue.
+ *
+ * Returns: long integer contents of @value
+ */
 glong
 g_value_get_long (const GValue *value)
 {
@@ -589,6 +860,13 @@ g_value_get_long (const GValue *value)
   return value->data[0].v_long;
 }
 
+/**
+ * g_value_set_ulong:
+ * @value: a valid #GValue of type %G_TYPE_ULONG
+ * @v_ulong: unsigned long integer value to be set
+ *
+ * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
+ */
 void
 g_value_set_ulong (GValue *value,
 		   gulong  v_ulong)
@@ -598,6 +876,14 @@ g_value_set_ulong (GValue *value,
   value->data[0].v_ulong = v_ulong;
 }
 
+/**
+ * g_value_get_ulong:
+ * @value: a valid #GValue of type %G_TYPE_ULONG
+ *
+ * Get the contents of a %G_TYPE_ULONG #GValue.
+ *
+ * Returns: unsigned long integer contents of @value
+ */
 gulong
 g_value_get_ulong (const GValue *value)
 {
@@ -606,6 +892,77 @@ g_value_get_ulong (const GValue *value)
   return value->data[0].v_ulong;
 }
 
+/**
+ * g_value_get_int64:
+ * @value: a valid #GValue of type %G_TYPE_INT64
+ *
+ * Get the contents of a %G_TYPE_INT64 #GValue.
+ *
+ * Returns: 64bit integer contents of @value
+ */
+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;
+}
+
+/**
+ * g_value_set_int64:
+ * @value: a valid #GValue of type %G_TYPE_INT64
+ * @v_int64: 64bit integer value to be set
+ *
+ * Set the contents of a %G_TYPE_INT64 #GValue to @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;
+}
+
+/**
+ * g_value_set_uint64:
+ * @value: a valid #GValue of type %G_TYPE_UINT64
+ * @v_uint64: unsigned 64bit integer value to be set
+ *
+ * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
+ */
+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;
+}
+
+/**
+ * g_value_get_uint64:
+ * @value: a valid #GValue of type %G_TYPE_UINT64
+ *
+ * Get the contents of a %G_TYPE_UINT64 #GValue.
+ *
+ * Returns: unsigned 64bit integer contents of @value
+ */
+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;
+}
+
+/**
+ * g_value_set_float:
+ * @value: a valid #GValue of type %G_TYPE_FLOAT
+ * @v_float: float value to be set
+ *
+ * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
+ */
 void
 g_value_set_float (GValue *value,
 		   gfloat  v_float)
@@ -615,6 +972,14 @@ g_value_set_float (GValue *value,
   value->data[0].v_float = v_float;
 }
 
+/**
+ * g_value_get_float:
+ * @value: a valid #GValue of type %G_TYPE_FLOAT
+ *
+ * Get the contents of a %G_TYPE_FLOAT #GValue.
+ *
+ * Returns: float contents of @value
+ */
 gfloat
 g_value_get_float (const GValue *value)
 {
@@ -623,6 +988,13 @@ g_value_get_float (const GValue *value)
   return value->data[0].v_float;
 }
 
+/**
+ * g_value_set_double:
+ * @value: a valid #GValue of type %G_TYPE_DOUBLE
+ * @v_double: double value to be set
+ *
+ * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
+ */
 void
 g_value_set_double (GValue *value,
 		    gdouble v_double)
@@ -632,6 +1004,14 @@ g_value_set_double (GValue *value,
   value->data[0].v_double = v_double;
 }
 
+/**
+ * g_value_get_double:
+ * @value: a valid #GValue of type %G_TYPE_DOUBLE
+ *
+ * Get the contents of a %G_TYPE_DOUBLE #GValue.
+ *
+ * Returns: double contents of @value
+ */
 gdouble
 g_value_get_double (const GValue *value)
 {
@@ -640,19 +1020,40 @@ g_value_get_double (const GValue *value)
   return value->data[0].v_double;
 }
 
+/**
+ * g_value_set_string:
+ * @value: a valid #GValue of type %G_TYPE_STRING
+ * @v_string: (allow-none): caller-owned string to be duplicated for the #GValue
+ *
+ * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
+ */
 void
 g_value_set_string (GValue	*value,
 		    const gchar *v_string)
 {
+  gchar *new_val;
+
   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
-  
+
+  new_val = g_strdup (v_string);
+
   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);
+
+  value->data[0].v_pointer = new_val;
 }
 
+/**
+ * g_value_set_static_string:
+ * @value: a valid #GValue of type %G_TYPE_STRING
+ * @v_string: (allow-none): static string to be set
+ *
+ * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
+ * The string is assumed to be static, and is thus not duplicated
+ * when setting the #GValue.
+ */
 void
 g_value_set_static_string (GValue      *value,
 			   const gchar *v_string)
@@ -665,10 +1066,35 @@ g_value_set_static_string (GValue      *value,
   value->data[0].v_pointer = (gchar*) v_string;
 }
 
+/**
+ * g_value_set_string_take_ownership:
+ * @value: a valid #GValue of type %G_TYPE_STRING
+ * @v_string: (allow-none): duplicated unowned string to be set
+ *
+ * This is an internal function introduced mainly for C marshallers.
+ *
+ * Deprecated: 2.4: Use g_value_take_string() instead.
+ */
 void
 g_value_set_string_take_ownership (GValue *value,
 				   gchar  *v_string)
 {
+  g_value_take_string (value, v_string);
+}
+
+/**
+ * g_value_take_string:
+ * @value: a valid #GValue of type %G_TYPE_STRING
+ * @v_string: (allow-none): string to take ownership of
+ *
+ * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
+ *
+ * Since: 2.4
+ */
+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)
@@ -678,7 +1104,15 @@ g_value_set_string_take_ownership (GValue *value,
   value->data[0].v_pointer = v_string;
 }
 
-G_CONST_RETURN gchar*
+/**
+ * g_value_get_string:
+ * @value: a valid #GValue of type %G_TYPE_STRING
+ *
+ * Get the contents of a %G_TYPE_STRING #GValue.
+ *
+ * Returns: string content of @value
+ */
+const gchar*
 g_value_get_string (const GValue *value)
 {
   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
@@ -686,6 +1120,14 @@ g_value_get_string (const GValue *value)
   return value->data[0].v_pointer;
 }
 
+/**
+ * g_value_dup_string:
+ * @value: a valid #GValue of type %G_TYPE_STRING
+ *
+ * Get a copy the contents of a %G_TYPE_STRING #GValue.
+ *
+ * Returns: a newly allocated copy of the string content of @value
+ */
 gchar*
 g_value_dup_string (const GValue *value)
 {
@@ -694,6 +1136,13 @@ g_value_dup_string (const GValue *value)
   return g_strdup (value->data[0].v_pointer);
 }
 
+/**
+ * g_value_set_pointer:
+ * @value: a valid #GValue of %G_TYPE_POINTER
+ * @v_pointer: pointer value to be set
+ *
+ * Set the contents of a pointer #GValue to @v_pointer.
+ */
 void
 g_value_set_pointer (GValue  *value,
 		     gpointer v_pointer)
@@ -703,6 +1152,14 @@ g_value_set_pointer (GValue  *value,
   value->data[0].v_pointer = v_pointer;
 }
 
+/**
+ * g_value_get_pointer:
+ * @value: a valid #GValue of %G_TYPE_POINTER
+ *
+ * Get the contents of a pointer #GValue.
+ *
+ * Returns: (transfer none): pointer contents of @value
+ */
 gpointer
 g_value_get_pointer (const GValue *value)
 {
@@ -711,48 +1168,167 @@ g_value_get_pointer (const GValue *value)
   return value->data[0].v_pointer;
 }
 
-#ifdef G_HAVE_GINT64
+G_DEFINE_POINTER_TYPE (GType, g_gtype)
+
+/**
+ * g_value_set_gtype:
+ * @value: a valid #GValue of type %G_TYPE_GTYPE
+ * @v_gtype: #GType to be set
+ *
+ * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
+ *
+ * Since: 2.12
+ */
 void
-g_value_set_int64 (GValue *value,
-		  gint64 v_int64)
+g_value_set_gtype (GValue *value,
+		   GType   v_gtype)
 {
-  g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
+  g_return_if_fail (G_VALUE_HOLDS_GTYPE (value));
 
-  value->data[0].v_int64 = v_int64;
+  value->data[0].v_pointer = GSIZE_TO_POINTER (v_gtype);
+  
 }
 
-gint64
-g_value_get_int64 (const GValue *value)
+/**
+ * g_value_get_gtype:
+ * @value: a valid #GValue of type %G_TYPE_GTYPE
+ *
+ * Get the contents of a %G_TYPE_GTYPE #GValue.
+ *
+ * Since: 2.12
+ *
+ * Returns: the #GType stored in @value
+ */
+GType
+g_value_get_gtype (const GValue *value)
 {
-  g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
+  g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value), 0);
 
-  return value->data[0].v_int64;
+  return GPOINTER_TO_SIZE (value->data[0].v_pointer);
 }
 
+/**
+ * g_value_set_variant:
+ * @value: a valid #GValue of type %G_TYPE_VARIANT
+ * @variant: (allow-none): a #GVariant, or %NULL
+ *
+ * Set the contents of a variant #GValue to @variant.
+ * If the variant is floating, it is consumed.
+ *
+ * Since: 2.26
+ */
 void
-g_value_set_uint64 (GValue *value,
-		   guint64 v_uint64)
+g_value_set_variant (GValue   *value,
+                     GVariant *variant)
 {
-  g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
+  GVariant *old_variant;
 
-  value->data[0].v_uint64 = v_uint64;
+  g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
+
+  old_variant = value->data[0].v_pointer;
+
+  if (variant)
+    value->data[0].v_pointer = g_variant_ref_sink (variant);
+  else
+    value->data[0].v_pointer = NULL;
+
+  if (old_variant)
+    g_variant_unref (old_variant);
 }
 
-guint64
-g_value_get_uint64 (const GValue *value)
+/**
+ * g_value_take_variant:
+ * @value: a valid #GValue of type %G_TYPE_VARIANT
+ * @variant: (allow-none): a #GVariant, or %NULL
+ *
+ * Set the contents of a variant #GValue to @variant, and takes over
+ * the ownership of the caller's reference to @variant;
+ * the caller doesn't have to unref it any more (i.e. the reference
+ * count of the variant is not increased).
+ *
+ * If @variant was floating then its floating reference is converted to
+ * a hard reference.
+ *
+ * If you want the #GValue to hold its own reference to @variant, use
+ * g_value_set_variant() instead.
+ *
+ * This is an internal function introduced mainly for C marshallers.
+ *
+ * Since: 2.26
+ */
+void
+g_value_take_variant (GValue   *value,
+                      GVariant *variant)
 {
-  g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
+  GVariant *old_variant;
 
-  return value->data[0].v_uint64;
+  g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
+
+  old_variant = value->data[0].v_pointer;
+
+  if (variant)
+    value->data[0].v_pointer = g_variant_take_ref (variant);
+  else
+    value->data[0].v_pointer = NULL;
+
+  if (old_variant)
+    g_variant_unref (old_variant);
 }
-#endif /* G_HAVE_GINT64 */
 
-/* need extra includes for g_strdup_value_contents() ;( */
-#include "gobject.h"
-#include "gparam.h"
-#include "gboxed.h"
-#include "genums.h"
+/**
+ * g_value_get_variant:
+ * @value: a valid #GValue of type %G_TYPE_VARIANT
+ *
+ * Get the contents of a variant #GValue.
+ *
+ * Returns: variant contents of @value
+ *
+ * Since: 2.26
+ */
+GVariant*
+g_value_get_variant (const GValue *value)
+{
+  g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
+
+  return value->data[0].v_pointer;
+}
+
+/**
+ * g_value_dup_variant:
+ * @value: a valid #GValue of type %G_TYPE_VARIANT
+ *
+ * Get the contents of a variant #GValue, increasing its refcount.
+ *
+ * Returns: variant contents of @value, should be unrefed using
+ *   g_variant_unref() when no longer needed
+ *
+ * Since: 2.26
+ */
+GVariant*
+g_value_dup_variant (const GValue *value)
+{
+  GVariant *variant;
+
+  g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
 
+  variant = value->data[0].v_pointer;
+  if (variant)
+    g_variant_ref_sink (variant);
+
+  return variant;
+}
+
+/**
+ * g_strdup_value_contents:
+ * @value: #GValue which contents are to be described.
+ *
+ * Return a newly allocated string, which describes the contents of a
+ * #GValue.  The main purpose of this function is to describe #GValue
+ * contents for debugging output, the way in which the contents are
+ * described may change between different GLib versions.
+ *
+ * Returns: Newly allocated string.
+ */
 gchar*
 g_strdup_value_contents (const GValue *value)
 {
@@ -777,7 +1353,7 @@ g_strdup_value_contents (const GValue *value)
     }
   else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
     {
-      GValue tmp_value = { 0, };
+      GValue tmp_value = G_VALUE_INIT;
       gchar *s;
 
       g_value_init (&tmp_value, G_TYPE_STRING);
@@ -802,6 +1378,25 @@ g_strdup_value_contents (const GValue *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 (value, G_TYPE_STRV))
+        {
+          GStrv strv = g_value_get_boxed (value);
+          GString *tmp = g_string_new ("[");
+
+          while (*strv != NULL)
+            {
+              gchar *escaped = g_strescape (*strv, NULL);
+
+              g_string_append_printf (tmp, "\"%s\"", escaped);
+              g_free (escaped);
+
+              if (*++strv != NULL)
+                g_string_append (tmp, ", ");
+            }
+
+          g_string_append (tmp, "]");
+          contents = g_string_free (tmp, FALSE);
+        }
       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))
@@ -814,3 +1409,37 @@ g_strdup_value_contents (const GValue *value)
 
   return contents;
 }
+
+/**
+ * g_pointer_type_register_static:
+ * @name: the name of the new pointer type.
+ *
+ * Creates a new %G_TYPE_POINTER derived type id for a new
+ * pointer type with name @name.
+ *
+ * Returns: a new %G_TYPE_POINTER derived type id for @name.
+ */
+GType
+g_pointer_type_register_static (const gchar *name)
+{
+  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;
+}