gobject/gvaluetypes.c

   1 /* GObject - GLib Type, Object, Parameter and Signal Library
   2  * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.
   3  * Copyright © 2010 Christian Persch
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22  * MT safe
  23  */
  24
  25 #include "config.h"
  26
  27 #include <string.h>
  28 #include <stdlib.h> /* qsort() */
  29
  30 #include "gvaluetypes.h"
  31 #include "gtype-private.h"
  32 #include "gvaluecollector.h"
  33 #include "gobject.h"
  34 #include "gparam.h"
  35 #include "gboxed.h"
  36 #include "genums.h"
  37
  38
  39 /* --- value functions --- */
  40 static void
  41 value_init_long0 (GValue *value)
  42 {
  43   value->data[0].v_long = 0;
  44 }
  45
  46 static void
  47 value_copy_long0 (const GValue *src_value,
  48                   GValue       *dest_value)
  49 {
  50   dest_value->data[0].v_long = src_value->data[0].v_long;
  51 }
  52
  53 static gchar*
  54 value_lcopy_char (const GValue *value,
  55                   guint         n_collect_values,
  56                   GTypeCValue  *collect_values,
  57                   guint         collect_flags)
  58 {
  59   gint8 *int8_p = collect_values[0].v_pointer;
  60
  61   if (!int8_p)
  62     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  63
  64   *int8_p = value->data[0].v_int;
  65
  66   return NULL;
  67 }
  68
  69 static gchar*
  70 value_lcopy_boolean (const GValue *value,
  71                      guint         n_collect_values,
  72                      GTypeCValue  *collect_values,
  73                      guint         collect_flags)
  74 {
  75   gboolean *bool_p = collect_values[0].v_pointer;
  76
  77   if (!bool_p)
  78     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  79
  80   *bool_p = value->data[0].v_int;
  81
  82   return NULL;
  83 }
  84
  85 static gchar*
  86 value_collect_int (GValue      *value,
  87                    guint        n_collect_values,
  88                    GTypeCValue *collect_values,
  89                    guint        collect_flags)
  90 {
  91   value->data[0].v_int = collect_values[0].v_int;
  92
  93   return NULL;
  94 }
  95
  96 static gchar*
  97 value_lcopy_int (const GValue *value,
  98                  guint         n_collect_values,
  99                  GTypeCValue  *collect_values,
 100                  guint         collect_flags)
 101 {
 102   gint *int_p = collect_values[0].v_pointer;
 103
 104   if (!int_p)
 105     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 106
 107   *int_p = value->data[0].v_int;
 108
 109   return NULL;
 110 }
 111
 112 static gchar*
 113 value_collect_long (GValue      *value,
 114                     guint        n_collect_values,
 115                     GTypeCValue *collect_values,
 116                     guint        collect_flags)
 117 {
 118   value->data[0].v_long = collect_values[0].v_long;
 119
 120   return NULL;
 121 }
 122
 123 static gchar*
 124 value_lcopy_long (const GValue *value,
 125                   guint         n_collect_values,
 126                   GTypeCValue  *collect_values,
 127                   guint         collect_flags)
 128 {
 129   glong *long_p = collect_values[0].v_pointer;
 130
 131   if (!long_p)
 132     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 133
 134   *long_p = value->data[0].v_long;
 135
 136   return NULL;
 137 }
 138
 139 static void
 140 value_init_int64 (GValue *value)
 141 {
 142   value->data[0].v_int64 = 0;
 143 }
 144
 145 static void
 146 value_copy_int64 (const GValue *src_value,
 147                   GValue       *dest_value)
 148 {
 149   dest_value->data[0].v_int64 = src_value->data[0].v_int64;
 150 }
 151
 152 static gchar*
 153 value_collect_int64 (GValue      *value,
 154                      guint        n_collect_values,
 155                      GTypeCValue *collect_values,
 156                      guint        collect_flags)
 157 {
 158   value->data[0].v_int64 = collect_values[0].v_int64;
 159
 160   return NULL;
 161 }
 162
 163 static gchar*
 164 value_lcopy_int64 (const GValue *value,
 165                    guint         n_collect_values,
 166                    GTypeCValue  *collect_values,
 167                    guint         collect_flags)
 168 {
 169   gint64 *int64_p = collect_values[0].v_pointer;
 170
 171   if (!int64_p)
 172     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 173
 174   *int64_p = value->data[0].v_int64;
 175
 176   return NULL;
 177 }
 178
 179 static void
 180 value_init_float (GValue *value)
 181 {
 182   value->data[0].v_float = 0.0;
 183 }
 184
 185 static void
 186 value_copy_float (const GValue *src_value,
 187                   GValue       *dest_value)
 188 {
 189   dest_value->data[0].v_float = src_value->data[0].v_float;
 190 }
 191
 192 static gchar*
 193 value_collect_float (GValue      *value,
 194                      guint        n_collect_values,
 195                      GTypeCValue *collect_values,
 196                      guint        collect_flags)
 197 {
 198   value->data[0].v_float = collect_values[0].v_double;
 199
 200   return NULL;
 201 }
 202
 203 static gchar*
 204 value_lcopy_float (const GValue *value,
 205                    guint         n_collect_values,
 206                    GTypeCValue  *collect_values,
 207                    guint         collect_flags)
 208 {
 209   gfloat *float_p = collect_values[0].v_pointer;
 210
 211   if (!float_p)
 212     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 213
 214   *float_p = value->data[0].v_float;
 215
 216   return NULL;
 217 }
 218
 219 static void
 220 value_init_double (GValue *value)
 221 {
 222   value->data[0].v_double = 0.0;
 223 }
 224
 225 static void
 226 value_copy_double (const GValue *src_value,
 227                    GValue       *dest_value)
 228 {
 229   dest_value->data[0].v_double = src_value->data[0].v_double;
 230 }
 231
 232 static gchar*
 233 value_collect_double (GValue      *value,
 234                       guint        n_collect_values,
 235                       GTypeCValue *collect_values,
 236                       guint        collect_flags)
 237 {
 238   value->data[0].v_double = collect_values[0].v_double;
 239
 240   return NULL;
 241 }
 242
 243 static gchar*
 244 value_lcopy_double (const GValue *value,
 245                     guint         n_collect_values,
 246                     GTypeCValue  *collect_values,
 247                     guint         collect_flags)
 248 {
 249   gdouble *double_p = collect_values[0].v_pointer;
 250
 251   if (!double_p)
 252     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 253
 254   *double_p = value->data[0].v_double;
 255
 256   return NULL;
 257 }
 258
 259 static void
 260 value_init_string (GValue *value)
 261 {
 262   value->data[0].v_pointer = NULL;
 263 }
 264
 265 static void
 266 value_free_string (GValue *value)
 267 {
 268   if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
 269     g_free (value->data[0].v_pointer);
 270 }
 271
 272 static void
 273 value_copy_string (const GValue *src_value,
 274                    GValue       *dest_value)
 275 {
 276   dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
 277 }
 278
 279 static gchar*
 280 value_collect_string (GValue      *value,
 281                       guint        n_collect_values,
 282                       GTypeCValue *collect_values,
 283                       guint        collect_flags)
 284 {
 285   if (!collect_values[0].v_pointer)
 286     value->data[0].v_pointer = NULL;
 287   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 288     {
 289       value->data[0].v_pointer = collect_values[0].v_pointer;
 290       value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 291     }
 292   else
 293     value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
 294
 295   return NULL;
 296 }
 297
 298 static gchar*
 299 value_lcopy_string (const GValue *value,
 300                     guint         n_collect_values,
 301                     GTypeCValue  *collect_values,
 302                     guint         collect_flags)
 303 {
 304   gchar **string_p = collect_values[0].v_pointer;
 305
 306   if (!string_p)
 307     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 308
 309   if (!value->data[0].v_pointer)
 310     *string_p = NULL;
 311   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 312     *string_p = value->data[0].v_pointer;
 313   else
 314     *string_p = g_strdup (value->data[0].v_pointer);
 315
 316   return NULL;
 317 }
 318
 319 static void
 320 value_init_pointer (GValue *value)
 321 {
 322   value->data[0].v_pointer = NULL;
 323 }
 324
 325 static void
 326 value_copy_pointer (const GValue *src_value,
 327                     GValue       *dest_value)
 328 {
 329   dest_value->data[0].v_pointer = src_value->data[0].v_pointer;
 330 }
 331
 332 static gpointer
 333 value_peek_pointer0 (const GValue *value)
 334 {
 335   return value->data[0].v_pointer;
 336 }
 337
 338 static gchar*
 339 value_collect_pointer (GValue      *value,
 340                        guint        n_collect_values,
 341                        GTypeCValue *collect_values,
 342                        guint        collect_flags)
 343 {
 344   value->data[0].v_pointer = collect_values[0].v_pointer;
 345
 346   return NULL;
 347 }
 348
 349 static gchar*
 350 value_lcopy_pointer (const GValue *value,
 351                      guint         n_collect_values,
 352                      GTypeCValue  *collect_values,
 353                      guint         collect_flags)
 354 {
 355   gpointer *pointer_p = collect_values[0].v_pointer;
 356
 357   if (!pointer_p)
 358     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 359
 360   *pointer_p = value->data[0].v_pointer;
 361
 362   return NULL;
 363 }
 364
 365 static void
 366 value_free_variant (GValue *value)
 367 {
 368   if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS) &&
 369       value->data[0].v_pointer)
 370     g_variant_unref (value->data[0].v_pointer);
 371 }
 372
 373 static void
 374 value_copy_variant (const GValue *src_value,
 375                    GValue       *dest_value)
 376 {
 377   if (src_value->data[0].v_pointer)
 378     dest_value->data[0].v_pointer = g_variant_ref_sink (src_value->data[0].v_pointer);
 379   else
 380     dest_value->data[0].v_pointer = NULL;
 381 }
 382
 383 static gchar*
 384 value_collect_variant (GValue     *value,
 385                       guint        n_collect_values,
 386                       GTypeCValue *collect_values,
 387                       guint        collect_flags)
 388 {
 389   if (!collect_values[0].v_pointer)
 390     value->data[0].v_pointer = NULL;
 391   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 392     {
 393       value->data[0].v_pointer = collect_values[0].v_pointer;
 394       value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 395     }
 396   else
 397     value->data[0].v_pointer = g_variant_ref_sink (collect_values[0].v_pointer);
 398
 399   return NULL;
 400 }
 401
 402 static gchar*
 403 value_lcopy_variant (const GValue *value,
 404                     guint         n_collect_values,
 405                     GTypeCValue  *collect_values,
 406                     guint         collect_flags)
 407 {
 408   GVariant **variant_p = collect_values[0].v_pointer;
 409
 410   if (!variant_p)
 411     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 412
 413   if (!value->data[0].v_pointer)
 414     *variant_p = NULL;
 415   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 416     *variant_p = value->data[0].v_pointer;
 417   else
 418     *variant_p = g_variant_ref_sink (value->data[0].v_pointer);
 419
 420   return NULL;
 421 }
 422
 423 /* --- type initialization --- */
 424 void
 425 _g_value_types_init (void)
 426 {
 427   GTypeInfo info = {
 428     0,                          /* class_size */
 429     NULL,                       /* base_init */
 430     NULL,                       /* base_destroy */
 431     NULL,                       /* class_init */
 432     NULL,                       /* class_destroy */
 433     NULL,                       /* class_data */
 434     0,                          /* instance_size */
 435     0,                          /* n_preallocs */
 436     NULL,                       /* instance_init */
 437     NULL,                       /* value_table */
 438   };
 439   const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
 440   GType type;
 441
 442   /* G_TYPE_CHAR / G_TYPE_UCHAR
 443    */
 444   {
 445     static const GTypeValueTable value_table = {
 446       value_init_long0,         /* value_init */
 447       NULL,                     /* value_free */
 448       value_copy_long0,         /* value_copy */
 449       NULL,                     /* value_peek_pointer */
 450       "i",                      /* collect_format */
 451       value_collect_int,        /* collect_value */
 452       "p",                      /* lcopy_format */
 453       value_lcopy_char,         /* lcopy_value */
 454     };
 455     info.value_table = &value_table;
 456     type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0);
 457     g_assert (type == G_TYPE_CHAR);
 458     type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0);
 459     g_assert (type == G_TYPE_UCHAR);
 460   }
 461
 462   /* G_TYPE_BOOLEAN
 463    */
 464   {
 465     static const GTypeValueTable value_table = {
 466       value_init_long0,          /* value_init */
 467       NULL,                      /* value_free */
 468       value_copy_long0,          /* value_copy */
 469       NULL,                      /* value_peek_pointer */
 470       "i",                       /* collect_format */
 471       value_collect_int,         /* collect_value */
 472       "p",                       /* lcopy_format */
 473       value_lcopy_boolean,       /* lcopy_value */
 474     };
 475     info.value_table = &value_table;
 476     type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0);
 477     g_assert (type == G_TYPE_BOOLEAN);
 478   }
 479
 480   /* G_TYPE_INT / G_TYPE_UINT
 481    */
 482   {
 483     static const GTypeValueTable value_table = {
 484       value_init_long0,         /* value_init */
 485       NULL,                     /* value_free */
 486       value_copy_long0,         /* value_copy */
 487       NULL,                     /* value_peek_pointer */
 488       "i",                      /* collect_format */
 489       value_collect_int,        /* collect_value */
 490       "p",                      /* lcopy_format */
 491       value_lcopy_int,          /* lcopy_value */
 492     };
 493     info.value_table = &value_table;
 494     type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0);
 495     g_assert (type == G_TYPE_INT);
 496     type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0);
 497     g_assert (type == G_TYPE_UINT);
 498   }
 499
 500   /* G_TYPE_LONG / G_TYPE_ULONG
 501    */
 502   {
 503     static const GTypeValueTable value_table = {
 504       value_init_long0,         /* value_init */
 505       NULL,                     /* value_free */
 506       value_copy_long0,         /* value_copy */
 507       NULL,                     /* value_peek_pointer */
 508       "l",                      /* collect_format */
 509       value_collect_long,       /* collect_value */
 510       "p",                      /* lcopy_format */
 511       value_lcopy_long,         /* lcopy_value */
 512     };
 513     info.value_table = &value_table;
 514     type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0);
 515     g_assert (type == G_TYPE_LONG);
 516     type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("gulong"), &info, &finfo, 0);
 517     g_assert (type == G_TYPE_ULONG);
 518   }
 519
 520   /* G_TYPE_INT64 / G_TYPE_UINT64
 521    */
 522   {
 523     static const GTypeValueTable value_table = {
 524       value_init_int64,         /* value_init */
 525       NULL,                     /* value_free */
 526       value_copy_int64,         /* value_copy */
 527       NULL,                     /* value_peek_pointer */
 528       "q",                      /* collect_format */
 529       value_collect_int64,      /* collect_value */
 530       "p",                      /* lcopy_format */
 531       value_lcopy_int64,        /* lcopy_value */
 532     };
 533     info.value_table = &value_table;
 534     type = g_type_register_fundamental (G_TYPE_INT64, g_intern_static_string ("gint64"), &info, &finfo, 0);
 535     g_assert (type == G_TYPE_INT64);
 536     type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0);
 537     g_assert (type == G_TYPE_UINT64);
 538   }
 539
 540   /* G_TYPE_FLOAT
 541    */
 542   {
 543     static const GTypeValueTable value_table = {
 544       value_init_float,          /* value_init */
 545       NULL,                      /* value_free */
 546       value_copy_float,          /* value_copy */
 547       NULL,                      /* value_peek_pointer */
 548       "d",                       /* collect_format */
 549       value_collect_float,       /* collect_value */
 550       "p",                       /* lcopy_format */
 551       value_lcopy_float,         /* lcopy_value */
 552     };
 553     info.value_table = &value_table;
 554     type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0);
 555     g_assert (type == G_TYPE_FLOAT);
 556   }
 557
 558   /* G_TYPE_DOUBLE
 559    */
 560   {
 561     static const GTypeValueTable value_table = {
 562       value_init_double,        /* value_init */
 563       NULL,                     /* value_free */
 564       value_copy_double,        /* value_copy */
 565       NULL,                     /* value_peek_pointer */
 566       "d",                      /* collect_format */
 567       value_collect_double,     /* collect_value */
 568       "p",                      /* lcopy_format */
 569       value_lcopy_double,       /* lcopy_value */
 570     };
 571     info.value_table = &value_table;
 572     type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0);
 573     g_assert (type == G_TYPE_DOUBLE);
 574   }
 575
 576   /* G_TYPE_STRING
 577    */
 578   {
 579     static const GTypeValueTable value_table = {
 580       value_init_string,        /* value_init */
 581       value_free_string,        /* value_free */
 582       value_copy_string,        /* value_copy */
 583       value_peek_pointer0,      /* value_peek_pointer */
 584       "p",                      /* collect_format */
 585       value_collect_string,     /* collect_value */
 586       "p",                      /* lcopy_format */
 587       value_lcopy_string,       /* lcopy_value */
 588     };
 589     info.value_table = &value_table;
 590     type = g_type_register_fundamental (G_TYPE_STRING, g_intern_static_string ("gchararray"), &info, &finfo, 0);
 591     g_assert (type == G_TYPE_STRING);
 592   }
 593
 594   /* G_TYPE_POINTER
 595    */
 596   {
 597     static const GTypeValueTable value_table = {
 598       value_init_pointer,       /* value_init */
 599       NULL,                     /* value_free */
 600       value_copy_pointer,       /* value_copy */
 601       value_peek_pointer0,      /* value_peek_pointer */
 602       "p",                      /* collect_format */
 603       value_collect_pointer,    /* collect_value */
 604       "p",                      /* lcopy_format */
 605       value_lcopy_pointer,      /* lcopy_value */
 606     };
 607     info.value_table = &value_table;
 608     type = g_type_register_fundamental (G_TYPE_POINTER, g_intern_static_string ("gpointer"), &info, &finfo, 0);
 609     g_assert (type == G_TYPE_POINTER);
 610   }
 611
 612   /* G_TYPE_VARIANT
 613    */
 614   {
 615     static const GTypeValueTable value_table = {
 616       value_init_pointer,       /* value_init */
 617       value_free_variant,       /* value_free */
 618       value_copy_variant,       /* value_copy */
 619       value_peek_pointer0,      /* value_peek_pointer */
 620       "p",                      /* collect_format */
 621       value_collect_variant,    /* collect_value */
 622       "p",                      /* lcopy_format */
 623       value_lcopy_variant,      /* lcopy_value */
 624     };
 625     info.value_table = &value_table;
 626     type = g_type_register_fundamental (G_TYPE_VARIANT, g_intern_static_string ("GVariant"), &info, &finfo, 0);
 627     g_assert (type == G_TYPE_VARIANT);
 628   }
 629 }
 630
 631
 632 /* --- GValue functions --- */
 633 /**
 634  * g_value_set_char:
 635  * @value: a valid #GValue of type %G_TYPE_CHAR
 636  * @v_char: character value to be set
 637  *
 638  * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
 639  * Deprecated: 2.32: This function's input type is broken, see g_value_set_schar()
 640  */
 641 void
 642 g_value_set_char (GValue *value,
 643                   gchar   v_char)
 644 {
 645   g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
 646
 647   value->data[0].v_int = v_char;
 648 }
 649
 650 /**
 651  * g_value_get_char:
 652  * @value: a valid #GValue of type %G_TYPE_CHAR
 653  *
 654  * Do not use this function; it is broken on platforms where the %char
 655  * type is unsigned, such as ARM and PowerPC.  See g_value_get_schar().
 656  *
 657  * Get the contents of a %G_TYPE_CHAR #GValue.
 658  *
 659  * Returns: character contents of @value
 660  * Deprecated: 2.32: This function's return type is broken, see g_value_get_schar()
 661  */
 662 gchar
 663 g_value_get_char (const GValue *value)
 664 {
 665   g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
 666
 667   return value->data[0].v_int;
 668 }
 669
 670 /**
 671  * g_value_set_schar:
 672  * @value: a valid #GValue of type %G_TYPE_CHAR
 673  * @v_char: signed 8 bit integer to be set
 674  *
 675  * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
 676  *
 677  * Since: 2.32
 678  */
 679 void
 680 g_value_set_schar (GValue *value,
 681                    gint8   v_char)
 682 {
 683   g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
 684
 685   value->data[0].v_int = v_char;
 686 }
 687
 688 /**
 689  * g_value_get_schar:
 690  * @value: a valid #GValue of type %G_TYPE_CHAR
 691  *
 692  * Get the contents of a %G_TYPE_CHAR #GValue.
 693  *
 694  * Returns: signed 8 bit integer contents of @value
 695  * Since: 2.32
 696  */
 697 gint8
 698 g_value_get_schar (const GValue *value)
 699 {
 700   g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
 701
 702   return value->data[0].v_int;
 703 }
 704
 705 /**
 706  * g_value_set_uchar:
 707  * @value: a valid #GValue of type %G_TYPE_UCHAR
 708  * @v_uchar: unsigned character value to be set
 709  *
 710  * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
 711  */
 712 void
 713 g_value_set_uchar (GValue *value,
 714                    guchar  v_uchar)
 715 {
 716   g_return_if_fail (G_VALUE_HOLDS_UCHAR (value));
 717
 718   value->data[0].v_uint = v_uchar;
 719 }
 720
 721 /**
 722  * g_value_get_uchar:
 723  * @value: a valid #GValue of type %G_TYPE_UCHAR
 724  *
 725  * Get the contents of a %G_TYPE_UCHAR #GValue.
 726  *
 727  * Returns: unsigned character contents of @value
 728  */
 729 guchar
 730 g_value_get_uchar (const GValue *value)
 731 {
 732   g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0);
 733
 734   return value->data[0].v_uint;
 735 }
 736
 737 /**
 738  * g_value_set_boolean:
 739  * @value: a valid #GValue of type %G_TYPE_BOOLEAN
 740  * @v_boolean: boolean value to be set
 741  *
 742  * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
 743  */
 744 void
 745 g_value_set_boolean (GValue  *value,
 746                      gboolean v_boolean)
 747 {
 748   g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value));
 749
 750   value->data[0].v_int = v_boolean != FALSE;
 751 }
 752
 753 /**
 754  * g_value_get_boolean:
 755  * @value: a valid #GValue of type %G_TYPE_BOOLEAN
 756  *
 757  * Get the contents of a %G_TYPE_BOOLEAN #GValue.
 758  *
 759  * Returns: boolean contents of @value
 760  */
 761 gboolean
 762 g_value_get_boolean (const GValue *value)
 763 {
 764   g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0);
 765
 766   return value->data[0].v_int;
 767 }
 768
 769 /**
 770  * g_value_set_int:
 771  * @value: a valid #GValue of type %G_TYPE_INT
 772  * @v_int: integer value to be set
 773  *
 774  * Set the contents of a %G_TYPE_INT #GValue to @v_int.
 775  */
 776 void
 777 g_value_set_int (GValue *value,
 778                  gint    v_int)
 779 {
 780   g_return_if_fail (G_VALUE_HOLDS_INT (value));
 781
 782   value->data[0].v_int = v_int;
 783 }
 784
 785 /**
 786  * g_value_get_int:
 787  * @value: a valid #GValue of type %G_TYPE_INT
 788  *
 789  * Get the contents of a %G_TYPE_INT #GValue.
 790  *
 791  * Returns: integer contents of @value
 792  */
 793 gint
 794 g_value_get_int (const GValue *value)
 795 {
 796   g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0);
 797
 798   return value->data[0].v_int;
 799 }
 800
 801 /**
 802  * g_value_set_uint:
 803  * @value: a valid #GValue of type %G_TYPE_UINT
 804  * @v_uint: unsigned integer value to be set
 805  *
 806  * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
 807  */
 808 void
 809 g_value_set_uint (GValue *value,
 810                   guint   v_uint)
 811 {
 812   g_return_if_fail (G_VALUE_HOLDS_UINT (value));
 813
 814   value->data[0].v_uint = v_uint;
 815 }
 816
 817 /**
 818  * g_value_get_uint:
 819  * @value: a valid #GValue of type %G_TYPE_UINT
 820  *
 821  * Get the contents of a %G_TYPE_UINT #GValue.
 822  *
 823  * Returns: unsigned integer contents of @value
 824  */
 825 guint
 826 g_value_get_uint (const GValue *value)
 827 {
 828   g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
 829
 830   return value->data[0].v_uint;
 831 }
 832
 833 /**
 834  * g_value_set_long:
 835  * @value: a valid #GValue of type %G_TYPE_LONG
 836  * @v_long: long integer value to be set
 837  *
 838  * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
 839  */
 840 void
 841 g_value_set_long (GValue *value,
 842                   glong   v_long)
 843 {
 844   g_return_if_fail (G_VALUE_HOLDS_LONG (value));
 845
 846   value->data[0].v_long = v_long;
 847 }
 848
 849 /**
 850  * g_value_get_long:
 851  * @value: a valid #GValue of type %G_TYPE_LONG
 852  *
 853  * Get the contents of a %G_TYPE_LONG #GValue.
 854  *
 855  * Returns: long integer contents of @value
 856  */
 857 glong
 858 g_value_get_long (const GValue *value)
 859 {
 860   g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0);
 861
 862   return value->data[0].v_long;
 863 }
 864
 865 /**
 866  * g_value_set_ulong:
 867  * @value: a valid #GValue of type %G_TYPE_ULONG
 868  * @v_ulong: unsigned long integer value to be set
 869  *
 870  * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
 871  */
 872 void
 873 g_value_set_ulong (GValue *value,
 874                    gulong  v_ulong)
 875 {
 876   g_return_if_fail (G_VALUE_HOLDS_ULONG (value));
 877
 878   value->data[0].v_ulong = v_ulong;
 879 }
 880
 881 /**
 882  * g_value_get_ulong:
 883  * @value: a valid #GValue of type %G_TYPE_ULONG
 884  *
 885  * Get the contents of a %G_TYPE_ULONG #GValue.
 886  *
 887  * Returns: unsigned long integer contents of @value
 888  */
 889 gulong
 890 g_value_get_ulong (const GValue *value)
 891 {
 892   g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0);
 893
 894   return value->data[0].v_ulong;
 895 }
 896
 897 /**
 898  * g_value_get_int64:
 899  * @value: a valid #GValue of type %G_TYPE_INT64
 900  *
 901  * Get the contents of a %G_TYPE_INT64 #GValue.
 902  *
 903  * Returns: 64bit integer contents of @value
 904  */
 905 void
 906 g_value_set_int64 (GValue *value,
 907                    gint64  v_int64)
 908 {
 909   g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
 910
 911   value->data[0].v_int64 = v_int64;
 912 }
 913
 914 /**
 915  * g_value_set_int64:
 916  * @value: a valid #GValue of type %G_TYPE_INT64
 917  * @v_int64: 64bit integer value to be set
 918  *
 919  * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
 920  */
 921 gint64
 922 g_value_get_int64 (const GValue *value)
 923 {
 924   g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
 925
 926   return value->data[0].v_int64;
 927 }
 928
 929 /**
 930  * g_value_set_uint64:
 931  * @value: a valid #GValue of type %G_TYPE_UINT64
 932  * @v_uint64: unsigned 64bit integer value to be set
 933  *
 934  * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
 935  */
 936 void
 937 g_value_set_uint64 (GValue *value,
 938                     guint64 v_uint64)
 939 {
 940   g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
 941
 942   value->data[0].v_uint64 = v_uint64;
 943 }
 944
 945 /**
 946  * g_value_get_uint64:
 947  * @value: a valid #GValue of type %G_TYPE_UINT64
 948  *
 949  * Get the contents of a %G_TYPE_UINT64 #GValue.
 950  *
 951  * Returns: unsigned 64bit integer contents of @value
 952  */
 953 guint64
 954 g_value_get_uint64 (const GValue *value)
 955 {
 956   g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
 957
 958   return value->data[0].v_uint64;
 959 }
 960
 961 /**
 962  * g_value_set_float:
 963  * @value: a valid #GValue of type %G_TYPE_FLOAT
 964  * @v_float: float value to be set
 965  *
 966  * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
 967  */
 968 void
 969 g_value_set_float (GValue *value,
 970                    gfloat  v_float)
 971 {
 972   g_return_if_fail (G_VALUE_HOLDS_FLOAT (value));
 973
 974   value->data[0].v_float = v_float;
 975 }
 976
 977 /**
 978  * g_value_get_float:
 979  * @value: a valid #GValue of type %G_TYPE_FLOAT
 980  *
 981  * Get the contents of a %G_TYPE_FLOAT #GValue.
 982  *
 983  * Returns: float contents of @value
 984  */
 985 gfloat
 986 g_value_get_float (const GValue *value)
 987 {
 988   g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0);
 989
 990   return value->data[0].v_float;
 991 }
 992
 993 /**
 994  * g_value_set_double:
 995  * @value: a valid #GValue of type %G_TYPE_DOUBLE
 996  * @v_double: double value to be set
 997  *
 998  * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
 999  */
1000 void
1001 g_value_set_double (GValue *value,
1002                     gdouble v_double)
1003 {
1004   g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value));
1005
1006   value->data[0].v_double = v_double;
1007 }
1008
1009 /**
1010  * g_value_get_double:
1011  * @value: a valid #GValue of type %G_TYPE_DOUBLE
1012  *
1013  * Get the contents of a %G_TYPE_DOUBLE #GValue.
1014  *
1015  * Returns: double contents of @value
1016  */
1017 gdouble
1018 g_value_get_double (const GValue *value)
1019 {
1020   g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0);
1021
1022   return value->data[0].v_double;
1023 }
1024
1025 /**
1026  * g_value_set_string:
1027  * @value: a valid #GValue of type %G_TYPE_STRING
1028  * @v_string: (allow-none): caller-owned string to be duplicated for the #GValue
1029  *
1030  * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
1031  */
1032 void
1033 g_value_set_string (GValue      *value,
1034                     const gchar *v_string)
1035 {
1036   gchar *new_val;
1037
1038   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1039
1040   new_val = g_strdup (v_string);
1041
1042   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1043     value->data[1].v_uint = 0;
1044   else
1045     g_free (value->data[0].v_pointer);
1046
1047   value->data[0].v_pointer = new_val;
1048 }
1049
1050 /**
1051  * g_value_set_static_string:
1052  * @value: a valid #GValue of type %G_TYPE_STRING
1053  * @v_string: (allow-none): static string to be set
1054  *
1055  * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
1056  * The string is assumed to be static, and is thus not duplicated
1057  * when setting the #GValue.
1058  */
1059 void
1060 g_value_set_static_string (GValue      *value,
1061                            const gchar *v_string)
1062 {
1063   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1064
1065   if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
1066     g_free (value->data[0].v_pointer);
1067   value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
1068   value->data[0].v_pointer = (gchar*) v_string;
1069 }
1070
1071 /**
1072  * g_value_set_string_take_ownership:
1073  * @value: a valid #GValue of type %G_TYPE_STRING
1074  * @v_string: (allow-none): duplicated unowned string to be set
1075  *
1076  * This is an internal function introduced mainly for C marshallers.
1077  *
1078  * Deprecated: 2.4: Use g_value_take_string() instead.
1079  */
1080 void
1081 g_value_set_string_take_ownership (GValue *value,
1082                                    gchar  *v_string)
1083 {
1084   g_value_take_string (value, v_string);
1085 }
1086
1087 /**
1088  * g_value_take_string:
1089  * @value: a valid #GValue of type %G_TYPE_STRING
1090  * @v_string: (allow-none): string to take ownership of
1091  *
1092  * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
1093  *
1094  * Since: 2.4
1095  */
1096 void
1097 g_value_take_string (GValue *value,
1098                      gchar  *v_string)
1099 {
1100   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
1101
1102   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
1103     value->data[1].v_uint = 0;
1104   else
1105     g_free (value->data[0].v_pointer);
1106   value->data[0].v_pointer = v_string;
1107 }
1108
1109 /**
1110  * g_value_get_string:
1111  * @value: a valid #GValue of type %G_TYPE_STRING
1112  *
1113  * Get the contents of a %G_TYPE_STRING #GValue.
1114  *
1115  * Returns: string content of @value
1116  */
1117 const gchar*
1118 g_value_get_string (const GValue *value)
1119 {
1120   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1121
1122   return value->data[0].v_pointer;
1123 }
1124
1125 /**
1126  * g_value_dup_string:
1127  * @value: a valid #GValue of type %G_TYPE_STRING
1128  *
1129  * Get a copy the contents of a %G_TYPE_STRING #GValue.
1130  *
1131  * Returns: a newly allocated copy of the string content of @value
1132  */
1133 gchar*
1134 g_value_dup_string (const GValue *value)
1135 {
1136   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1137
1138   return g_strdup (value->data[0].v_pointer);
1139 }
1140
1141 /**
1142  * g_value_set_pointer:
1143  * @value: a valid #GValue of %G_TYPE_POINTER
1144  * @v_pointer: pointer value to be set
1145  *
1146  * Set the contents of a pointer #GValue to @v_pointer.
1147  */
1148 void
1149 g_value_set_pointer (GValue  *value,
1150                      gpointer v_pointer)
1151 {
1152   g_return_if_fail (G_VALUE_HOLDS_POINTER (value));
1153
1154   value->data[0].v_pointer = v_pointer;
1155 }
1156
1157 /**
1158  * g_value_get_pointer:
1159  * @value: a valid #GValue of %G_TYPE_POINTER
1160  *
1161  * Get the contents of a pointer #GValue.
1162  *
1163  * Returns: (transfer none): pointer contents of @value
1164  */
1165 gpointer
1166 g_value_get_pointer (const GValue *value)
1167 {
1168   g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL);
1169
1170   return value->data[0].v_pointer;
1171 }
1172
1173 G_DEFINE_POINTER_TYPE (GType, g_gtype)
1174
1175 /**
1176  * g_value_set_gtype:
1177  * @value: a valid #GValue of type %G_TYPE_GTYPE
1178  * @v_gtype: #GType to be set
1179  *
1180  * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
1181  *
1182  * Since: 2.12
1183  */
1184 void
1185 g_value_set_gtype (GValue *value,
1186                    GType   v_gtype)
1187 {
1188   g_return_if_fail (G_VALUE_HOLDS_GTYPE (value));
1189
1190   value->data[0].v_pointer = GSIZE_TO_POINTER (v_gtype);
1191
1192 }
1193
1194 /**
1195  * g_value_get_gtype:
1196  * @value: a valid #GValue of type %G_TYPE_GTYPE
1197  *
1198  * Get the contents of a %G_TYPE_GTYPE #GValue.
1199  *
1200  * Since: 2.12
1201  *
1202  * Returns: the #GType stored in @value
1203  */
1204 GType
1205 g_value_get_gtype (const GValue *value)
1206 {
1207   g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value), 0);
1208
1209   return GPOINTER_TO_SIZE (value->data[0].v_pointer);
1210 }
1211
1212 /**
1213  * g_value_set_variant:
1214  * @value: a valid #GValue of type %G_TYPE_VARIANT
1215  * @variant: (allow-none): a #GVariant, or %NULL
1216  *
1217  * Set the contents of a variant #GValue to @variant.
1218  * If the variant is floating, it is consumed.
1219  *
1220  * Since: 2.26
1221  */
1222 void
1223 g_value_set_variant (GValue   *value,
1224                      GVariant *variant)
1225 {
1226   GVariant *old_variant;
1227
1228   g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
1229
1230   old_variant = value->data[0].v_pointer;
1231
1232   if (variant)
1233     value->data[0].v_pointer = g_variant_ref_sink (variant);
1234   else
1235     value->data[0].v_pointer = NULL;
1236
1237   if (old_variant)
1238     g_variant_unref (old_variant);
1239 }
1240
1241 /**
1242  * g_value_take_variant:
1243  * @value: a valid #GValue of type %G_TYPE_VARIANT
1244  * @variant: (allow-none): a #GVariant, or %NULL
1245  *
1246  * Set the contents of a variant #GValue to @variant, and takes over
1247  * the ownership of the caller's reference to @variant;
1248  * the caller doesn't have to unref it any more (i.e. the reference
1249  * count of the variant is not increased).
1250  *
1251  * If @variant was floating then its floating reference is converted to
1252  * a hard reference.
1253  *
1254  * If you want the #GValue to hold its own reference to @variant, use
1255  * g_value_set_variant() instead.
1256  *
1257  * This is an internal function introduced mainly for C marshallers.
1258  *
1259  * Since: 2.26
1260  */
1261 void
1262 g_value_take_variant (GValue   *value,
1263                       GVariant *variant)
1264 {
1265   GVariant *old_variant;
1266
1267   g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
1268
1269   old_variant = value->data[0].v_pointer;
1270
1271   if (variant)
1272     value->data[0].v_pointer = g_variant_take_ref (variant);
1273   else
1274     value->data[0].v_pointer = NULL;
1275
1276   if (old_variant)
1277     g_variant_unref (old_variant);
1278 }
1279
1280 /**
1281  * g_value_get_variant:
1282  * @value: a valid #GValue of type %G_TYPE_VARIANT
1283  *
1284  * Get the contents of a variant #GValue.
1285  *
1286  * Returns: variant contents of @value
1287  *
1288  * Since: 2.26
1289  */
1290 GVariant*
1291 g_value_get_variant (const GValue *value)
1292 {
1293   g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
1294
1295   return value->data[0].v_pointer;
1296 }
1297
1298 /**
1299  * g_value_dup_variant:
1300  * @value: a valid #GValue of type %G_TYPE_VARIANT
1301  *
1302  * Get the contents of a variant #GValue, increasing its refcount.
1303  *
1304  * Returns: variant contents of @value, should be unrefed using
1305  *   g_variant_unref() when no longer needed
1306  *
1307  * Since: 2.26
1308  */
1309 GVariant*
1310 g_value_dup_variant (const GValue *value)
1311 {
1312   GVariant *variant;
1313
1314   g_return_val_if_fail (G_VALUE_HOLDS_VARIANT (value), NULL);
1315
1316   variant = value->data[0].v_pointer;
1317   if (variant)
1318     g_variant_ref_sink (variant);
1319
1320   return variant;
1321 }
1322
1323 /**
1324  * g_strdup_value_contents:
1325  * @value: #GValue which contents are to be described.
1326  *
1327  * Return a newly allocated string, which describes the contents of a
1328  * #GValue.  The main purpose of this function is to describe #GValue
1329  * contents for debugging output, the way in which the contents are
1330  * described may change between different GLib versions.
1331  *
1332  * Returns: Newly allocated string.
1333  */
1334 gchar*
1335 g_strdup_value_contents (const GValue *value)
1336 {
1337   const gchar *src;
1338   gchar *contents;
1339
1340   g_return_val_if_fail (G_IS_VALUE (value), NULL);
1341
1342   if (G_VALUE_HOLDS_STRING (value))
1343     {
1344       src = g_value_get_string (value);
1345
1346       if (!src)
1347         contents = g_strdup ("NULL");
1348       else
1349         {
1350           gchar *s = g_strescape (src, NULL);
1351
1352           contents = g_strdup_printf ("\"%s\"", s);
1353           g_free (s);
1354         }
1355     }
1356   else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
1357     {
1358       GValue tmp_value = G_VALUE_INIT;
1359       gchar *s;
1360
1361       g_value_init (&tmp_value, G_TYPE_STRING);
1362       g_value_transform (value, &tmp_value);
1363       s = g_strescape (g_value_get_string (&tmp_value), NULL);
1364       g_value_unset (&tmp_value);
1365       if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
1366         contents = g_strdup_printf ("((%s) %s)",
1367                                     g_type_name (G_VALUE_TYPE (value)),
1368                                     s);
1369       else
1370         contents = g_strdup (s ? s : "NULL");
1371       g_free (s);
1372     }
1373   else if (g_value_fits_pointer (value))
1374     {
1375       gpointer p = g_value_peek_pointer (value);
1376
1377       if (!p)
1378         contents = g_strdup ("NULL");
1379       else if (G_VALUE_HOLDS_OBJECT (value))
1380         contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
1381       else if (G_VALUE_HOLDS_PARAM (value))
1382         contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
1383       else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
1384         {
1385           GStrv strv = g_value_get_boxed (value);
1386           GString *tmp = g_string_new ("[");
1387
1388           while (*strv != NULL)
1389             {
1390               gchar *escaped = g_strescape (*strv, NULL);
1391
1392               g_string_append_printf (tmp, "\"%s\"", escaped);
1393               g_free (escaped);
1394
1395               if (*++strv != NULL)
1396                 g_string_append (tmp, ", ");
1397             }
1398
1399           g_string_append (tmp, "]");
1400           contents = g_string_free (tmp, FALSE);
1401         }
1402       else if (G_VALUE_HOLDS_BOXED (value))
1403         contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
1404       else if (G_VALUE_HOLDS_POINTER (value))
1405         contents = g_strdup_printf ("((gpointer) %p)", p);
1406       else
1407         contents = g_strdup ("???");
1408     }
1409   else
1410     contents = g_strdup ("???");
1411
1412   return contents;
1413 }
1414
1415 /**
1416  * g_pointer_type_register_static:
1417  * @name: the name of the new pointer type.
1418  *
1419  * Creates a new %G_TYPE_POINTER derived type id for a new
1420  * pointer type with name @name.
1421  *
1422  * Returns: a new %G_TYPE_POINTER derived type id for @name.
1423  */
1424 GType
1425 g_pointer_type_register_static (const gchar *name)
1426 {
1427   const GTypeInfo type_info = {
1428     0,                  /* class_size */
1429     NULL,               /* base_init */
1430     NULL,               /* base_finalize */
1431     NULL,               /* class_init */
1432     NULL,               /* class_finalize */
1433     NULL,               /* class_data */
1434     0,                  /* instance_size */
1435     0,                  /* n_preallocs */
1436     NULL,               /* instance_init */
1437     NULL                /* value_table */
1438   };
1439   GType type;
1440
1441   g_return_val_if_fail (name != NULL, 0);
1442   g_return_val_if_fail (g_type_from_name (name) == 0, 0);
1443
1444   type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0);
1445
1446   return type;
1447 }