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