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  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General
  15  * Public License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * MT safe
  22  */
  23
  24 #include        "gvaluetypes.h"
  25
  26 #include        "gvaluecollector.h"
  27 #include        "gobjectalias.h"
  28 #include        <string.h>
  29 #include        <stdlib.h>      /* qsort() */
  30
  31
  32 /* --- value functions --- */
  33 static void
  34 value_init_long0 (GValue *value)
  35 {
  36   value->data[0].v_long = 0;
  37 }
  38
  39 static void
  40 value_copy_long0 (const GValue *src_value,
  41                   GValue       *dest_value)
  42 {
  43   dest_value->data[0].v_long = src_value->data[0].v_long;
  44 }
  45
  46 static gchar*
  47 value_lcopy_char (const GValue *value,
  48                   guint         n_collect_values,
  49                   GTypeCValue  *collect_values,
  50                   guint         collect_flags)
  51 {
  52   gint8 *int8_p = collect_values[0].v_pointer;
  53
  54   if (!int8_p)
  55     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  56
  57   *int8_p = value->data[0].v_int;
  58
  59   return NULL;
  60 }
  61
  62 static gchar*
  63 value_lcopy_boolean (const GValue *value,
  64                      guint         n_collect_values,
  65                      GTypeCValue  *collect_values,
  66                      guint         collect_flags)
  67 {
  68   gboolean *bool_p = collect_values[0].v_pointer;
  69
  70   if (!bool_p)
  71     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  72
  73   *bool_p = value->data[0].v_int;
  74
  75   return NULL;
  76 }
  77
  78 static gchar*
  79 value_collect_int (GValue      *value,
  80                    guint        n_collect_values,
  81                    GTypeCValue *collect_values,
  82                    guint        collect_flags)
  83 {
  84   value->data[0].v_int = collect_values[0].v_int;
  85
  86   return NULL;
  87 }
  88
  89 static gchar*
  90 value_lcopy_int (const GValue *value,
  91                  guint         n_collect_values,
  92                  GTypeCValue  *collect_values,
  93                  guint         collect_flags)
  94 {
  95   gint *int_p = collect_values[0].v_pointer;
  96
  97   if (!int_p)
  98     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  99
 100   *int_p = value->data[0].v_int;
 101
 102   return NULL;
 103 }
 104
 105 static gchar*
 106 value_collect_long (GValue      *value,
 107                     guint        n_collect_values,
 108                     GTypeCValue *collect_values,
 109                     guint        collect_flags)
 110 {
 111   value->data[0].v_long = collect_values[0].v_long;
 112
 113   return NULL;
 114 }
 115
 116 static gchar*
 117 value_lcopy_long (const GValue *value,
 118                   guint         n_collect_values,
 119                   GTypeCValue  *collect_values,
 120                   guint         collect_flags)
 121 {
 122   glong *long_p = collect_values[0].v_pointer;
 123
 124   if (!long_p)
 125     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 126
 127   *long_p = value->data[0].v_long;
 128
 129   return NULL;
 130 }
 131
 132 static void
 133 value_init_int64 (GValue *value)
 134 {
 135   value->data[0].v_int64 = 0;
 136 }
 137
 138 static void
 139 value_copy_int64 (const GValue *src_value,
 140                   GValue       *dest_value)
 141 {
 142   dest_value->data[0].v_int64 = src_value->data[0].v_int64;
 143 }
 144
 145 static gchar*
 146 value_collect_int64 (GValue      *value,
 147                      guint        n_collect_values,
 148                      GTypeCValue *collect_values,
 149                      guint        collect_flags)
 150 {
 151   value->data[0].v_int64 = collect_values[0].v_int64;
 152
 153   return NULL;
 154 }
 155
 156 static gchar*
 157 value_lcopy_int64 (const GValue *value,
 158                    guint         n_collect_values,
 159                    GTypeCValue  *collect_values,
 160                    guint         collect_flags)
 161 {
 162   gint64 *int64_p = collect_values[0].v_pointer;
 163
 164   if (!int64_p)
 165     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 166
 167   *int64_p = value->data[0].v_int64;
 168
 169   return NULL;
 170 }
 171
 172 static void
 173 value_init_float (GValue *value)
 174 {
 175   value->data[0].v_float = 0.0;
 176 }
 177
 178 static void
 179 value_copy_float (const GValue *src_value,
 180                   GValue       *dest_value)
 181 {
 182   dest_value->data[0].v_float = src_value->data[0].v_float;
 183 }
 184
 185 static gchar*
 186 value_collect_float (GValue      *value,
 187                      guint        n_collect_values,
 188                      GTypeCValue *collect_values,
 189                      guint        collect_flags)
 190 {
 191   value->data[0].v_float = collect_values[0].v_double;
 192
 193   return NULL;
 194 }
 195
 196 static gchar*
 197 value_lcopy_float (const GValue *value,
 198                    guint         n_collect_values,
 199                    GTypeCValue  *collect_values,
 200                    guint         collect_flags)
 201 {
 202   gfloat *float_p = collect_values[0].v_pointer;
 203
 204   if (!float_p)
 205     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 206
 207   *float_p = value->data[0].v_float;
 208
 209   return NULL;
 210 }
 211
 212 static void
 213 value_init_double (GValue *value)
 214 {
 215   value->data[0].v_double = 0.0;
 216 }
 217
 218 static void
 219 value_copy_double (const GValue *src_value,
 220                    GValue       *dest_value)
 221 {
 222   dest_value->data[0].v_double = src_value->data[0].v_double;
 223 }
 224
 225 static gchar*
 226 value_collect_double (GValue      *value,
 227                       guint        n_collect_values,
 228                       GTypeCValue *collect_values,
 229                       guint        collect_flags)
 230 {
 231   value->data[0].v_double = collect_values[0].v_double;
 232
 233   return NULL;
 234 }
 235
 236 static gchar*
 237 value_lcopy_double (const GValue *value,
 238                     guint         n_collect_values,
 239                     GTypeCValue  *collect_values,
 240                     guint         collect_flags)
 241 {
 242   gdouble *double_p = collect_values[0].v_pointer;
 243
 244   if (!double_p)
 245     return 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   dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
 270 }
 271
 272 static gchar*
 273 value_collect_string (GValue      *value,
 274                       guint        n_collect_values,
 275                       GTypeCValue *collect_values,
 276                       guint        collect_flags)
 277 {
 278   if (!collect_values[0].v_pointer)
 279     value->data[0].v_pointer = NULL;
 280   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 281     {
 282       value->data[0].v_pointer = collect_values[0].v_pointer;
 283       value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 284     }
 285   else
 286     value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
 287
 288   return NULL;
 289 }
 290
 291 static gchar*
 292 value_lcopy_string (const GValue *value,
 293                     guint         n_collect_values,
 294                     GTypeCValue  *collect_values,
 295                     guint         collect_flags)
 296 {
 297   gchar **string_p = collect_values[0].v_pointer;
 298
 299   if (!string_p)
 300     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 301
 302   if (!value->data[0].v_pointer)
 303     *string_p = NULL;
 304   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 305     *string_p = value->data[0].v_pointer;
 306   else
 307     *string_p = g_strdup (value->data[0].v_pointer);
 308
 309   return NULL;
 310 }
 311
 312 static void
 313 value_init_pointer (GValue *value)
 314 {
 315   value->data[0].v_pointer = NULL;
 316 }
 317
 318 static void
 319 value_copy_pointer (const GValue *src_value,
 320                     GValue       *dest_value)
 321 {
 322   dest_value->data[0].v_pointer = src_value->data[0].v_pointer;
 323 }
 324
 325 static gpointer
 326 value_peek_pointer0 (const GValue *value)
 327 {
 328   return value->data[0].v_pointer;
 329 }
 330
 331 static gchar*
 332 value_collect_pointer (GValue      *value,
 333                        guint        n_collect_values,
 334                        GTypeCValue *collect_values,
 335                        guint        collect_flags)
 336 {
 337   value->data[0].v_pointer = collect_values[0].v_pointer;
 338
 339   return NULL;
 340 }
 341
 342 static gchar*
 343 value_lcopy_pointer (const GValue *value,
 344                      guint         n_collect_values,
 345                      GTypeCValue  *collect_values,
 346                      guint         collect_flags)
 347 {
 348   gpointer *pointer_p = collect_values[0].v_pointer;
 349
 350   if (!pointer_p)
 351     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 352
 353   *pointer_p = value->data[0].v_pointer;
 354
 355   return NULL;
 356 }
 357
 358
 359 /* --- type initialization --- */
 360 void
 361 g_value_types_init (void)
 362 {
 363   GTypeInfo info = {
 364     0,                          /* class_size */
 365     NULL,                       /* base_init */
 366     NULL,                       /* base_destroy */
 367     NULL,                       /* class_init */
 368     NULL,                       /* class_destroy */
 369     NULL,                       /* class_data */
 370     0,                          /* instance_size */
 371     0,                          /* n_preallocs */
 372     NULL,                       /* instance_init */
 373     NULL,                       /* value_table */
 374   };
 375   const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
 376   GType type;
 377
 378   /* G_TYPE_CHAR / G_TYPE_UCHAR
 379    */
 380   {
 381     static const GTypeValueTable value_table = {
 382       value_init_long0,         /* value_init */
 383       NULL,                     /* value_free */
 384       value_copy_long0,         /* value_copy */
 385       NULL,                     /* value_peek_pointer */
 386       "i",                      /* collect_format */
 387       value_collect_int,        /* collect_value */
 388       "p",                      /* lcopy_format */
 389       value_lcopy_char,         /* lcopy_value */
 390     };
 391     info.value_table = &value_table;
 392     type = g_type_register_fundamental (G_TYPE_CHAR, "gchar", &info, &finfo, 0);
 393     g_assert (type == G_TYPE_CHAR);
 394     type = g_type_register_fundamental (G_TYPE_UCHAR, "guchar", &info, &finfo, 0);
 395     g_assert (type == G_TYPE_UCHAR);
 396   }
 397
 398   /* G_TYPE_BOOLEAN
 399    */
 400   {
 401     static const GTypeValueTable value_table = {
 402       value_init_long0,          /* value_init */
 403       NULL,                      /* value_free */
 404       value_copy_long0,          /* value_copy */
 405       NULL,                      /* value_peek_pointer */
 406       "i",                       /* collect_format */
 407       value_collect_int,         /* collect_value */
 408       "p",                       /* lcopy_format */
 409       value_lcopy_boolean,       /* lcopy_value */
 410     };
 411     info.value_table = &value_table;
 412     type = g_type_register_fundamental (G_TYPE_BOOLEAN, "gboolean", &info, &finfo, 0);
 413     g_assert (type == G_TYPE_BOOLEAN);
 414   }
 415
 416   /* G_TYPE_INT / G_TYPE_UINT
 417    */
 418   {
 419     static const GTypeValueTable value_table = {
 420       value_init_long0,         /* value_init */
 421       NULL,                     /* value_free */
 422       value_copy_long0,         /* value_copy */
 423       NULL,                     /* value_peek_pointer */
 424       "i",                      /* collect_format */
 425       value_collect_int,        /* collect_value */
 426       "p",                      /* lcopy_format */
 427       value_lcopy_int,          /* lcopy_value */
 428     };
 429     info.value_table = &value_table;
 430     type = g_type_register_fundamental (G_TYPE_INT, "gint", &info, &finfo, 0);
 431     g_assert (type == G_TYPE_INT);
 432     type = g_type_register_fundamental (G_TYPE_UINT, "guint", &info, &finfo, 0);
 433     g_assert (type == G_TYPE_UINT);
 434   }
 435
 436   /* G_TYPE_LONG / G_TYPE_ULONG
 437    */
 438   {
 439     static const GTypeValueTable value_table = {
 440       value_init_long0,         /* value_init */
 441       NULL,                     /* value_free */
 442       value_copy_long0,         /* value_copy */
 443       NULL,                     /* value_peek_pointer */
 444       "l",                      /* collect_format */
 445       value_collect_long,       /* collect_value */
 446       "p",                      /* lcopy_format */
 447       value_lcopy_long,         /* lcopy_value */
 448     };
 449     info.value_table = &value_table;
 450     type = g_type_register_fundamental (G_TYPE_LONG, "glong", &info, &finfo, 0);
 451     g_assert (type == G_TYPE_LONG);
 452     type = g_type_register_fundamental (G_TYPE_ULONG, "gulong", &info, &finfo, 0);
 453     g_assert (type == G_TYPE_ULONG);
 454   }
 455
 456   /* G_TYPE_INT64 / G_TYPE_UINT64
 457    */
 458   {
 459     static const GTypeValueTable value_table = {
 460       value_init_int64,         /* value_init */
 461       NULL,                     /* value_free */
 462       value_copy_int64,         /* value_copy */
 463       NULL,                     /* value_peek_pointer */
 464       "q",                      /* collect_format */
 465       value_collect_int64,      /* collect_value */
 466       "p",                      /* lcopy_format */
 467       value_lcopy_int64,        /* lcopy_value */
 468     };
 469     info.value_table = &value_table;
 470     type = g_type_register_fundamental (G_TYPE_INT64, "gint64", &info, &finfo, 0);
 471     g_assert (type == G_TYPE_INT64);
 472     type = g_type_register_fundamental (G_TYPE_UINT64, "guint64", &info, &finfo, 0);
 473     g_assert (type == G_TYPE_UINT64);
 474   }
 475
 476   /* G_TYPE_FLOAT
 477    */
 478   {
 479     static const GTypeValueTable value_table = {
 480       value_init_float,          /* value_init */
 481       NULL,                      /* value_free */
 482       value_copy_float,          /* value_copy */
 483       NULL,                      /* value_peek_pointer */
 484       "d",                       /* collect_format */
 485       value_collect_float,       /* collect_value */
 486       "p",                       /* lcopy_format */
 487       value_lcopy_float,         /* lcopy_value */
 488     };
 489     info.value_table = &value_table;
 490     type = g_type_register_fundamental (G_TYPE_FLOAT, "gfloat", &info, &finfo, 0);
 491     g_assert (type == G_TYPE_FLOAT);
 492   }
 493
 494   /* G_TYPE_DOUBLE
 495    */
 496   {
 497     static const GTypeValueTable value_table = {
 498       value_init_double,        /* value_init */
 499       NULL,                     /* value_free */
 500       value_copy_double,        /* value_copy */
 501       NULL,                     /* value_peek_pointer */
 502       "d",                      /* collect_format */
 503       value_collect_double,     /* collect_value */
 504       "p",                      /* lcopy_format */
 505       value_lcopy_double,       /* lcopy_value */
 506     };
 507     info.value_table = &value_table;
 508     type = g_type_register_fundamental (G_TYPE_DOUBLE, "gdouble", &info, &finfo, 0);
 509     g_assert (type == G_TYPE_DOUBLE);
 510   }
 511
 512   /* G_TYPE_STRING
 513    */
 514   {
 515     static const GTypeValueTable value_table = {
 516       value_init_string,        /* value_init */
 517       value_free_string,        /* value_free */
 518       value_copy_string,        /* value_copy */
 519       value_peek_pointer0,      /* value_peek_pointer */
 520       "p",                      /* collect_format */
 521       value_collect_string,     /* collect_value */
 522       "p",                      /* lcopy_format */
 523       value_lcopy_string,       /* lcopy_value */
 524     };
 525     info.value_table = &value_table;
 526     type = g_type_register_fundamental (G_TYPE_STRING, "gchararray", &info, &finfo, 0);
 527     g_assert (type == G_TYPE_STRING);
 528   }
 529
 530   /* G_TYPE_POINTER
 531    */
 532   {
 533     static const GTypeValueTable value_table = {
 534       value_init_pointer,       /* value_init */
 535       NULL,                     /* value_free */
 536       value_copy_pointer,       /* value_copy */
 537       value_peek_pointer0,      /* value_peek_pointer */
 538       "p",                      /* collect_format */
 539       value_collect_pointer,    /* collect_value */
 540       "p",                      /* lcopy_format */
 541       value_lcopy_pointer,      /* lcopy_value */
 542     };
 543     info.value_table = &value_table;
 544     type = g_type_register_fundamental (G_TYPE_POINTER, "gpointer", &info, &finfo, 0);
 545     g_assert (type == G_TYPE_POINTER);
 546   }
 547 }
 548
 549
 550 /* --- GValue functions --- */
 551 void
 552 g_value_set_char (GValue *value,
 553                   gchar   v_char)
 554 {
 555   g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
 556
 557   value->data[0].v_int = v_char;
 558 }
 559
 560 gchar
 561 g_value_get_char (const GValue *value)
 562 {
 563   g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
 564
 565   return value->data[0].v_int;
 566 }
 567
 568 void
 569 g_value_set_uchar (GValue *value,
 570                    guchar  v_uchar)
 571 {
 572   g_return_if_fail (G_VALUE_HOLDS_UCHAR (value));
 573
 574   value->data[0].v_uint = v_uchar;
 575 }
 576
 577 guchar
 578 g_value_get_uchar (const GValue *value)
 579 {
 580   g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0);
 581
 582   return value->data[0].v_uint;
 583 }
 584
 585 void
 586 g_value_set_boolean (GValue  *value,
 587                      gboolean v_boolean)
 588 {
 589   g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value));
 590
 591   value->data[0].v_int = v_boolean != FALSE;
 592 }
 593
 594 gboolean
 595 g_value_get_boolean (const GValue *value)
 596 {
 597   g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0);
 598
 599   return value->data[0].v_int;
 600 }
 601
 602 void
 603 g_value_set_int (GValue *value,
 604                  gint    v_int)
 605 {
 606   g_return_if_fail (G_VALUE_HOLDS_INT (value));
 607
 608   value->data[0].v_int = v_int;
 609 }
 610
 611 gint
 612 g_value_get_int (const GValue *value)
 613 {
 614   g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0);
 615
 616   return value->data[0].v_int;
 617 }
 618
 619 void
 620 g_value_set_uint (GValue *value,
 621                   guint   v_uint)
 622 {
 623   g_return_if_fail (G_VALUE_HOLDS_UINT (value));
 624
 625   value->data[0].v_uint = v_uint;
 626 }
 627
 628 guint
 629 g_value_get_uint (const GValue *value)
 630 {
 631   g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
 632
 633   return value->data[0].v_uint;
 634 }
 635
 636 void
 637 g_value_set_long (GValue *value,
 638                   glong   v_long)
 639 {
 640   g_return_if_fail (G_VALUE_HOLDS_LONG (value));
 641
 642   value->data[0].v_long = v_long;
 643 }
 644
 645 glong
 646 g_value_get_long (const GValue *value)
 647 {
 648   g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0);
 649
 650   return value->data[0].v_long;
 651 }
 652
 653 void
 654 g_value_set_ulong (GValue *value,
 655                    gulong  v_ulong)
 656 {
 657   g_return_if_fail (G_VALUE_HOLDS_ULONG (value));
 658
 659   value->data[0].v_ulong = v_ulong;
 660 }
 661
 662 gulong
 663 g_value_get_ulong (const GValue *value)
 664 {
 665   g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0);
 666
 667   return value->data[0].v_ulong;
 668 }
 669
 670 void
 671 g_value_set_int64 (GValue *value,
 672                    gint64  v_int64)
 673 {
 674   g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
 675
 676   value->data[0].v_int64 = v_int64;
 677 }
 678
 679 gint64
 680 g_value_get_int64 (const GValue *value)
 681 {
 682   g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
 683
 684   return value->data[0].v_int64;
 685 }
 686
 687 void
 688 g_value_set_uint64 (GValue *value,
 689                     guint64 v_uint64)
 690 {
 691   g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
 692
 693   value->data[0].v_uint64 = v_uint64;
 694 }
 695
 696 guint64
 697 g_value_get_uint64 (const GValue *value)
 698 {
 699   g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
 700
 701   return value->data[0].v_uint64;
 702 }
 703
 704 void
 705 g_value_set_float (GValue *value,
 706                    gfloat  v_float)
 707 {
 708   g_return_if_fail (G_VALUE_HOLDS_FLOAT (value));
 709
 710   value->data[0].v_float = v_float;
 711 }
 712
 713 gfloat
 714 g_value_get_float (const GValue *value)
 715 {
 716   g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0);
 717
 718   return value->data[0].v_float;
 719 }
 720
 721 void
 722 g_value_set_double (GValue *value,
 723                     gdouble v_double)
 724 {
 725   g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value));
 726
 727   value->data[0].v_double = v_double;
 728 }
 729
 730 gdouble
 731 g_value_get_double (const GValue *value)
 732 {
 733   g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0);
 734
 735   return value->data[0].v_double;
 736 }
 737
 738 void
 739 g_value_set_string (GValue      *value,
 740                     const gchar *v_string)
 741 {
 742   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 743
 744   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
 745     value->data[1].v_uint = 0;
 746   else
 747     g_free (value->data[0].v_pointer);
 748   value->data[0].v_pointer = g_strdup (v_string);
 749 }
 750
 751 void
 752 g_value_set_static_string (GValue      *value,
 753                            const gchar *v_string)
 754 {
 755   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 756
 757   if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
 758     g_free (value->data[0].v_pointer);
 759   value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 760   value->data[0].v_pointer = (gchar*) v_string;
 761 }
 762
 763 void
 764 g_value_set_string_take_ownership (GValue *value,
 765                                    gchar  *v_string)
 766 {
 767   g_value_take_string (value, v_string);
 768 }
 769
 770 void
 771 g_value_take_string (GValue *value,
 772                      gchar  *v_string)
 773 {
 774   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 775
 776   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
 777     value->data[1].v_uint = 0;
 778   else
 779     g_free (value->data[0].v_pointer);
 780   value->data[0].v_pointer = v_string;
 781 }
 782
 783 G_CONST_RETURN gchar*
 784 g_value_get_string (const GValue *value)
 785 {
 786   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
 787
 788   return value->data[0].v_pointer;
 789 }
 790
 791 gchar*
 792 g_value_dup_string (const GValue *value)
 793 {
 794   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
 795
 796   return g_strdup (value->data[0].v_pointer);
 797 }
 798
 799 void
 800 g_value_set_pointer (GValue  *value,
 801                      gpointer v_pointer)
 802 {
 803   g_return_if_fail (G_VALUE_HOLDS_POINTER (value));
 804
 805   value->data[0].v_pointer = v_pointer;
 806 }
 807
 808 gpointer
 809 g_value_get_pointer (const GValue *value)
 810 {
 811   g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL);
 812
 813   return value->data[0].v_pointer;
 814 }
 815
 816 /* need extra includes for g_strdup_value_contents() ;( */
 817 #include "gobject.h"
 818 #include "gparam.h"
 819 #include "gboxed.h"
 820 #include "genums.h"
 821
 822 gchar*
 823 g_strdup_value_contents (const GValue *value)
 824 {
 825   const gchar *src;
 826   gchar *contents;
 827
 828   g_return_val_if_fail (G_IS_VALUE (value), NULL);
 829
 830   if (G_VALUE_HOLDS_STRING (value))
 831     {
 832       src = g_value_get_string (value);
 833
 834       if (!src)
 835         contents = g_strdup ("NULL");
 836       else
 837         {
 838           gchar *s = g_strescape (src, NULL);
 839
 840           contents = g_strdup_printf ("\"%s\"", s);
 841           g_free (s);
 842         }
 843     }
 844   else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
 845     {
 846       GValue tmp_value = { 0, };
 847       gchar *s;
 848
 849       g_value_init (&tmp_value, G_TYPE_STRING);
 850       g_value_transform (value, &tmp_value);
 851       s = g_strescape (g_value_get_string (&tmp_value), NULL);
 852       g_value_unset (&tmp_value);
 853       if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
 854         contents = g_strdup_printf ("((%s) %s)",
 855                                     g_type_name (G_VALUE_TYPE (value)),
 856                                     s);
 857       else
 858         contents = g_strdup (s ? s : "NULL");
 859       g_free (s);
 860     }
 861   else if (g_value_fits_pointer (value))
 862     {
 863       gpointer p = g_value_peek_pointer (value);
 864
 865       if (!p)
 866         contents = g_strdup ("NULL");
 867       else if (G_VALUE_HOLDS_OBJECT (value))
 868         contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
 869       else if (G_VALUE_HOLDS_PARAM (value))
 870         contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
 871       else if (G_VALUE_HOLDS_BOXED (value))
 872         contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
 873       else if (G_VALUE_HOLDS_POINTER (value))
 874         contents = g_strdup_printf ("((gpointer) %p)", p);
 875       else
 876         contents = g_strdup ("???");
 877     }
 878   else
 879     contents = g_strdup ("???");
 880
 881   return contents;
 882 }
 883
 884 GType
 885 g_pointer_type_register_static (const gchar *name)
 886 {
 887   static const GTypeInfo type_info = {
 888     0,                  /* class_size */
 889     NULL,               /* base_init */
 890     NULL,               /* base_finalize */
 891     NULL,               /* class_init */
 892     NULL,               /* class_finalize */
 893     NULL,               /* class_data */
 894     0,                  /* instance_size */
 895     0,                  /* n_preallocs */
 896     NULL,               /* instance_init */
 897     NULL                /* value_table */
 898   };
 899   GType type;
 900
 901   g_return_val_if_fail (name != NULL, 0);
 902   g_return_val_if_fail (g_type_from_name (name) == 0, 0);
 903
 904   type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0);
 905
 906   return type;
 907 }
 908
 909 #define __G_VALUETYPES_C__
 910 #include "gobjectaliasdef.c"