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