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 "config.h"
  25
  26 #include <string.h>
  27 #include <stdlib.h> /* qsort() */
  28
  29 #include "gvaluetypes.h"
  30 #include "gvaluecollector.h"
  31 #include "gobject.h"
  32 #include "gparam.h"
  33 #include "gboxed.h"
  34 #include "genums.h"
  35
  36 #include "gobjectalias.h"
  37
  38
  39 /* --- value functions --- */
  40 static void
  41 value_init_long0 (GValue *value)
  42 {
  43   value->data[0].v_long = 0;
  44 }
  45
  46 static void
  47 value_copy_long0 (const GValue *src_value,
  48                   GValue       *dest_value)
  49 {
  50   dest_value->data[0].v_long = src_value->data[0].v_long;
  51 }
  52
  53 static gchar*
  54 value_lcopy_char (const GValue *value,
  55                   guint         n_collect_values,
  56                   GTypeCValue  *collect_values,
  57                   guint         collect_flags)
  58 {
  59   gint8 *int8_p = collect_values[0].v_pointer;
  60
  61   if (!int8_p)
  62     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  63
  64   *int8_p = value->data[0].v_int;
  65
  66   return NULL;
  67 }
  68
  69 static gchar*
  70 value_lcopy_boolean (const GValue *value,
  71                      guint         n_collect_values,
  72                      GTypeCValue  *collect_values,
  73                      guint         collect_flags)
  74 {
  75   gboolean *bool_p = collect_values[0].v_pointer;
  76
  77   if (!bool_p)
  78     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
  79
  80   *bool_p = value->data[0].v_int;
  81
  82   return NULL;
  83 }
  84
  85 static gchar*
  86 value_collect_int (GValue      *value,
  87                    guint        n_collect_values,
  88                    GTypeCValue *collect_values,
  89                    guint        collect_flags)
  90 {
  91   value->data[0].v_int = collect_values[0].v_int;
  92
  93   return NULL;
  94 }
  95
  96 static gchar*
  97 value_lcopy_int (const GValue *value,
  98                  guint         n_collect_values,
  99                  GTypeCValue  *collect_values,
 100                  guint         collect_flags)
 101 {
 102   gint *int_p = collect_values[0].v_pointer;
 103
 104   if (!int_p)
 105     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 106
 107   *int_p = value->data[0].v_int;
 108
 109   return NULL;
 110 }
 111
 112 static gchar*
 113 value_collect_long (GValue      *value,
 114                     guint        n_collect_values,
 115                     GTypeCValue *collect_values,
 116                     guint        collect_flags)
 117 {
 118   value->data[0].v_long = collect_values[0].v_long;
 119
 120   return NULL;
 121 }
 122
 123 static gchar*
 124 value_lcopy_long (const GValue *value,
 125                   guint         n_collect_values,
 126                   GTypeCValue  *collect_values,
 127                   guint         collect_flags)
 128 {
 129   glong *long_p = collect_values[0].v_pointer;
 130
 131   if (!long_p)
 132     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 133
 134   *long_p = value->data[0].v_long;
 135
 136   return NULL;
 137 }
 138
 139 static void
 140 value_init_int64 (GValue *value)
 141 {
 142   value->data[0].v_int64 = 0;
 143 }
 144
 145 static void
 146 value_copy_int64 (const GValue *src_value,
 147                   GValue       *dest_value)
 148 {
 149   dest_value->data[0].v_int64 = src_value->data[0].v_int64;
 150 }
 151
 152 static gchar*
 153 value_collect_int64 (GValue      *value,
 154                      guint        n_collect_values,
 155                      GTypeCValue *collect_values,
 156                      guint        collect_flags)
 157 {
 158   value->data[0].v_int64 = collect_values[0].v_int64;
 159
 160   return NULL;
 161 }
 162
 163 static gchar*
 164 value_lcopy_int64 (const GValue *value,
 165                    guint         n_collect_values,
 166                    GTypeCValue  *collect_values,
 167                    guint         collect_flags)
 168 {
 169   gint64 *int64_p = collect_values[0].v_pointer;
 170
 171   if (!int64_p)
 172     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 173
 174   *int64_p = value->data[0].v_int64;
 175
 176   return NULL;
 177 }
 178
 179 static void
 180 value_init_float (GValue *value)
 181 {
 182   value->data[0].v_float = 0.0;
 183 }
 184
 185 static void
 186 value_copy_float (const GValue *src_value,
 187                   GValue       *dest_value)
 188 {
 189   dest_value->data[0].v_float = src_value->data[0].v_float;
 190 }
 191
 192 static gchar*
 193 value_collect_float (GValue      *value,
 194                      guint        n_collect_values,
 195                      GTypeCValue *collect_values,
 196                      guint        collect_flags)
 197 {
 198   value->data[0].v_float = collect_values[0].v_double;
 199
 200   return NULL;
 201 }
 202
 203 static gchar*
 204 value_lcopy_float (const GValue *value,
 205                    guint         n_collect_values,
 206                    GTypeCValue  *collect_values,
 207                    guint         collect_flags)
 208 {
 209   gfloat *float_p = collect_values[0].v_pointer;
 210
 211   if (!float_p)
 212     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 213
 214   *float_p = value->data[0].v_float;
 215
 216   return NULL;
 217 }
 218
 219 static void
 220 value_init_double (GValue *value)
 221 {
 222   value->data[0].v_double = 0.0;
 223 }
 224
 225 static void
 226 value_copy_double (const GValue *src_value,
 227                    GValue       *dest_value)
 228 {
 229   dest_value->data[0].v_double = src_value->data[0].v_double;
 230 }
 231
 232 static gchar*
 233 value_collect_double (GValue      *value,
 234                       guint        n_collect_values,
 235                       GTypeCValue *collect_values,
 236                       guint        collect_flags)
 237 {
 238   value->data[0].v_double = collect_values[0].v_double;
 239
 240   return NULL;
 241 }
 242
 243 static gchar*
 244 value_lcopy_double (const GValue *value,
 245                     guint         n_collect_values,
 246                     GTypeCValue  *collect_values,
 247                     guint         collect_flags)
 248 {
 249   gdouble *double_p = collect_values[0].v_pointer;
 250
 251   if (!double_p)
 252     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 253
 254   *double_p = value->data[0].v_double;
 255
 256   return NULL;
 257 }
 258
 259 static void
 260 value_init_string (GValue *value)
 261 {
 262   value->data[0].v_pointer = NULL;
 263 }
 264
 265 static void
 266 value_free_string (GValue *value)
 267 {
 268   if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
 269     g_free (value->data[0].v_pointer);
 270 }
 271
 272 static void
 273 value_copy_string (const GValue *src_value,
 274                    GValue       *dest_value)
 275 {
 276   dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
 277 }
 278
 279 static gchar*
 280 value_collect_string (GValue      *value,
 281                       guint        n_collect_values,
 282                       GTypeCValue *collect_values,
 283                       guint        collect_flags)
 284 {
 285   if (!collect_values[0].v_pointer)
 286     value->data[0].v_pointer = NULL;
 287   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 288     {
 289       value->data[0].v_pointer = collect_values[0].v_pointer;
 290       value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 291     }
 292   else
 293     value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
 294
 295   return NULL;
 296 }
 297
 298 static gchar*
 299 value_lcopy_string (const GValue *value,
 300                     guint         n_collect_values,
 301                     GTypeCValue  *collect_values,
 302                     guint         collect_flags)
 303 {
 304   gchar **string_p = collect_values[0].v_pointer;
 305
 306   if (!string_p)
 307     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 308
 309   if (!value->data[0].v_pointer)
 310     *string_p = NULL;
 311   else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
 312     *string_p = value->data[0].v_pointer;
 313   else
 314     *string_p = g_strdup (value->data[0].v_pointer);
 315
 316   return NULL;
 317 }
 318
 319 static void
 320 value_init_pointer (GValue *value)
 321 {
 322   value->data[0].v_pointer = NULL;
 323 }
 324
 325 static void
 326 value_copy_pointer (const GValue *src_value,
 327                     GValue       *dest_value)
 328 {
 329   dest_value->data[0].v_pointer = src_value->data[0].v_pointer;
 330 }
 331
 332 static gpointer
 333 value_peek_pointer0 (const GValue *value)
 334 {
 335   return value->data[0].v_pointer;
 336 }
 337
 338 static gchar*
 339 value_collect_pointer (GValue      *value,
 340                        guint        n_collect_values,
 341                        GTypeCValue *collect_values,
 342                        guint        collect_flags)
 343 {
 344   value->data[0].v_pointer = collect_values[0].v_pointer;
 345
 346   return NULL;
 347 }
 348
 349 static gchar*
 350 value_lcopy_pointer (const GValue *value,
 351                      guint         n_collect_values,
 352                      GTypeCValue  *collect_values,
 353                      guint         collect_flags)
 354 {
 355   gpointer *pointer_p = collect_values[0].v_pointer;
 356
 357   if (!pointer_p)
 358     return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 359
 360   *pointer_p = value->data[0].v_pointer;
 361
 362   return NULL;
 363 }
 364
 365
 366 /* --- type initialization --- */
 367 void
 368 g_value_types_init (void)
 369 {
 370   GTypeInfo info = {
 371     0,                          /* class_size */
 372     NULL,                       /* base_init */
 373     NULL,                       /* base_destroy */
 374     NULL,                       /* class_init */
 375     NULL,                       /* class_destroy */
 376     NULL,                       /* class_data */
 377     0,                          /* instance_size */
 378     0,                          /* n_preallocs */
 379     NULL,                       /* instance_init */
 380     NULL,                       /* value_table */
 381   };
 382   const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };
 383   GType type;
 384
 385   /* G_TYPE_CHAR / G_TYPE_UCHAR
 386    */
 387   {
 388     static const GTypeValueTable value_table = {
 389       value_init_long0,         /* value_init */
 390       NULL,                     /* value_free */
 391       value_copy_long0,         /* value_copy */
 392       NULL,                     /* value_peek_pointer */
 393       "i",                      /* collect_format */
 394       value_collect_int,        /* collect_value */
 395       "p",                      /* lcopy_format */
 396       value_lcopy_char,         /* lcopy_value */
 397     };
 398     info.value_table = &value_table;
 399     type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0);
 400     g_assert (type == G_TYPE_CHAR);
 401     type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0);
 402     g_assert (type == G_TYPE_UCHAR);
 403   }
 404
 405   /* G_TYPE_BOOLEAN
 406    */
 407   {
 408     static const GTypeValueTable value_table = {
 409       value_init_long0,          /* value_init */
 410       NULL,                      /* value_free */
 411       value_copy_long0,          /* value_copy */
 412       NULL,                      /* value_peek_pointer */
 413       "i",                       /* collect_format */
 414       value_collect_int,         /* collect_value */
 415       "p",                       /* lcopy_format */
 416       value_lcopy_boolean,       /* lcopy_value */
 417     };
 418     info.value_table = &value_table;
 419     type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0);
 420     g_assert (type == G_TYPE_BOOLEAN);
 421   }
 422
 423   /* G_TYPE_INT / G_TYPE_UINT
 424    */
 425   {
 426     static const GTypeValueTable value_table = {
 427       value_init_long0,         /* value_init */
 428       NULL,                     /* value_free */
 429       value_copy_long0,         /* value_copy */
 430       NULL,                     /* value_peek_pointer */
 431       "i",                      /* collect_format */
 432       value_collect_int,        /* collect_value */
 433       "p",                      /* lcopy_format */
 434       value_lcopy_int,          /* lcopy_value */
 435     };
 436     info.value_table = &value_table;
 437     type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0);
 438     g_assert (type == G_TYPE_INT);
 439     type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0);
 440     g_assert (type == G_TYPE_UINT);
 441   }
 442
 443   /* G_TYPE_LONG / G_TYPE_ULONG
 444    */
 445   {
 446     static const GTypeValueTable value_table = {
 447       value_init_long0,         /* value_init */
 448       NULL,                     /* value_free */
 449       value_copy_long0,         /* value_copy */
 450       NULL,                     /* value_peek_pointer */
 451       "l",                      /* collect_format */
 452       value_collect_long,       /* collect_value */
 453       "p",                      /* lcopy_format */
 454       value_lcopy_long,         /* lcopy_value */
 455     };
 456     info.value_table = &value_table;
 457     type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0);
 458     g_assert (type == G_TYPE_LONG);
 459     type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("gulong"), &info, &finfo, 0);
 460     g_assert (type == G_TYPE_ULONG);
 461   }
 462
 463   /* G_TYPE_INT64 / G_TYPE_UINT64
 464    */
 465   {
 466     static const GTypeValueTable value_table = {
 467       value_init_int64,         /* value_init */
 468       NULL,                     /* value_free */
 469       value_copy_int64,         /* value_copy */
 470       NULL,                     /* value_peek_pointer */
 471       "q",                      /* collect_format */
 472       value_collect_int64,      /* collect_value */
 473       "p",                      /* lcopy_format */
 474       value_lcopy_int64,        /* lcopy_value */
 475     };
 476     info.value_table = &value_table;
 477     type = g_type_register_fundamental (G_TYPE_INT64, g_intern_static_string ("gint64"), &info, &finfo, 0);
 478     g_assert (type == G_TYPE_INT64);
 479     type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0);
 480     g_assert (type == G_TYPE_UINT64);
 481   }
 482
 483   /* G_TYPE_FLOAT
 484    */
 485   {
 486     static const GTypeValueTable value_table = {
 487       value_init_float,          /* value_init */
 488       NULL,                      /* value_free */
 489       value_copy_float,          /* value_copy */
 490       NULL,                      /* value_peek_pointer */
 491       "d",                       /* collect_format */
 492       value_collect_float,       /* collect_value */
 493       "p",                       /* lcopy_format */
 494       value_lcopy_float,         /* lcopy_value */
 495     };
 496     info.value_table = &value_table;
 497     type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0);
 498     g_assert (type == G_TYPE_FLOAT);
 499   }
 500
 501   /* G_TYPE_DOUBLE
 502    */
 503   {
 504     static const GTypeValueTable value_table = {
 505       value_init_double,        /* value_init */
 506       NULL,                     /* value_free */
 507       value_copy_double,        /* value_copy */
 508       NULL,                     /* value_peek_pointer */
 509       "d",                      /* collect_format */
 510       value_collect_double,     /* collect_value */
 511       "p",                      /* lcopy_format */
 512       value_lcopy_double,       /* lcopy_value */
 513     };
 514     info.value_table = &value_table;
 515     type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0);
 516     g_assert (type == G_TYPE_DOUBLE);
 517   }
 518
 519   /* G_TYPE_STRING
 520    */
 521   {
 522     static const GTypeValueTable value_table = {
 523       value_init_string,        /* value_init */
 524       value_free_string,        /* value_free */
 525       value_copy_string,        /* value_copy */
 526       value_peek_pointer0,      /* value_peek_pointer */
 527       "p",                      /* collect_format */
 528       value_collect_string,     /* collect_value */
 529       "p",                      /* lcopy_format */
 530       value_lcopy_string,       /* lcopy_value */
 531     };
 532     info.value_table = &value_table;
 533     type = g_type_register_fundamental (G_TYPE_STRING, g_intern_static_string ("gchararray"), &info, &finfo, 0);
 534     g_assert (type == G_TYPE_STRING);
 535   }
 536
 537   /* G_TYPE_POINTER
 538    */
 539   {
 540     static const GTypeValueTable value_table = {
 541       value_init_pointer,       /* value_init */
 542       NULL,                     /* value_free */
 543       value_copy_pointer,       /* value_copy */
 544       value_peek_pointer0,      /* value_peek_pointer */
 545       "p",                      /* collect_format */
 546       value_collect_pointer,    /* collect_value */
 547       "p",                      /* lcopy_format */
 548       value_lcopy_pointer,      /* lcopy_value */
 549     };
 550     info.value_table = &value_table;
 551     type = g_type_register_fundamental (G_TYPE_POINTER, g_intern_static_string ("gpointer"), &info, &finfo, 0);
 552     g_assert (type == G_TYPE_POINTER);
 553   }
 554 }
 555
 556
 557 /* --- GValue functions --- */
 558 /**
 559  * g_value_set_char:
 560  * @value: a valid #GValue of type %G_TYPE_CHAR
 561  * @v_char: character value to be set
 562  *
 563  * Set the contents of a %G_TYPE_CHAR #GValue to @v_char.
 564  */
 565 void
 566 g_value_set_char (GValue *value,
 567                   gchar   v_char)
 568 {
 569   g_return_if_fail (G_VALUE_HOLDS_CHAR (value));
 570
 571   value->data[0].v_int = v_char;
 572 }
 573
 574 /**
 575  * g_value_get_char:
 576  * @value: a valid #GValue of type %G_TYPE_CHAR
 577  *
 578  * Get the contents of a %G_TYPE_CHAR #GValue.
 579  *
 580  * Returns: character contents of @value
 581  */
 582 gchar
 583 g_value_get_char (const GValue *value)
 584 {
 585   g_return_val_if_fail (G_VALUE_HOLDS_CHAR (value), 0);
 586
 587   return value->data[0].v_int;
 588 }
 589
 590 /**
 591  * g_value_set_uchar:
 592  * @value: a valid #GValue of type %G_TYPE_UCHAR
 593  * @v_uchar: unsigned character value to be set
 594  *
 595  * Set the contents of a %G_TYPE_UCHAR #GValue to @v_uchar.
 596  */
 597 void
 598 g_value_set_uchar (GValue *value,
 599                    guchar  v_uchar)
 600 {
 601   g_return_if_fail (G_VALUE_HOLDS_UCHAR (value));
 602
 603   value->data[0].v_uint = v_uchar;
 604 }
 605
 606 /**
 607  * g_value_get_uchar:
 608  * @value: a valid #GValue of type %G_TYPE_UCHAR
 609  *
 610  * Get the contents of a %G_TYPE_UCHAR #GValue.
 611  *
 612  * Returns: unsigned character contents of @value
 613  */
 614 guchar
 615 g_value_get_uchar (const GValue *value)
 616 {
 617   g_return_val_if_fail (G_VALUE_HOLDS_UCHAR (value), 0);
 618
 619   return value->data[0].v_uint;
 620 }
 621
 622 /**
 623  * g_value_set_boolean:
 624  * @value: a valid #GValue of type %G_TYPE_BOOLEAN
 625  * @v_boolean: boolean value to be set
 626  *
 627  * Set the contents of a %G_TYPE_BOOLEAN #GValue to @v_boolean.
 628  */
 629 void
 630 g_value_set_boolean (GValue  *value,
 631                      gboolean v_boolean)
 632 {
 633   g_return_if_fail (G_VALUE_HOLDS_BOOLEAN (value));
 634
 635   value->data[0].v_int = v_boolean != FALSE;
 636 }
 637
 638 /**
 639  * g_value_get_boolean:
 640  * @value: a valid #GValue of type %G_TYPE_BOOLEAN
 641  *
 642  * Get the contents of a %G_TYPE_BOOLEAN #GValue.
 643  *
 644  * Returns: boolean contents of @value
 645  */
 646 gboolean
 647 g_value_get_boolean (const GValue *value)
 648 {
 649   g_return_val_if_fail (G_VALUE_HOLDS_BOOLEAN (value), 0);
 650
 651   return value->data[0].v_int;
 652 }
 653
 654 /**
 655  * g_value_set_int:
 656  * @value: a valid #GValue of type %G_TYPE_INT
 657  * @v_int: integer value to be set
 658  *
 659  * Set the contents of a %G_TYPE_INT #GValue to @v_int.
 660  */
 661 void
 662 g_value_set_int (GValue *value,
 663                  gint    v_int)
 664 {
 665   g_return_if_fail (G_VALUE_HOLDS_INT (value));
 666
 667   value->data[0].v_int = v_int;
 668 }
 669
 670 /**
 671  * g_value_get_int:
 672  * @value: a valid #GValue of type %G_TYPE_INT
 673  *
 674  * Get the contents of a %G_TYPE_INT #GValue.
 675  *
 676  * Returns: integer contents of @value
 677  */
 678 gint
 679 g_value_get_int (const GValue *value)
 680 {
 681   g_return_val_if_fail (G_VALUE_HOLDS_INT (value), 0);
 682
 683   return value->data[0].v_int;
 684 }
 685
 686 /**
 687  * g_value_set_uint:
 688  * @value: a valid #GValue of type %G_TYPE_UINT
 689  * @v_uint: unsigned integer value to be set
 690  *
 691  * Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
 692  */
 693 void
 694 g_value_set_uint (GValue *value,
 695                   guint   v_uint)
 696 {
 697   g_return_if_fail (G_VALUE_HOLDS_UINT (value));
 698
 699   value->data[0].v_uint = v_uint;
 700 }
 701
 702 /**
 703  * g_value_get_uint:
 704  * @value: a valid #GValue of type %G_TYPE_UINT
 705  *
 706  * Get the contents of a %G_TYPE_UINT #GValue.
 707  *
 708  * Returns: unsigned integer contents of @value
 709  */
 710 guint
 711 g_value_get_uint (const GValue *value)
 712 {
 713   g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
 714
 715   return value->data[0].v_uint;
 716 }
 717
 718 /**
 719  * g_value_set_long:
 720  * @value: a valid #GValue of type %G_TYPE_LONG
 721  * @v_long: long integer value to be set
 722  *
 723  * Set the contents of a %G_TYPE_LONG #GValue to @v_long.
 724  */
 725 void
 726 g_value_set_long (GValue *value,
 727                   glong   v_long)
 728 {
 729   g_return_if_fail (G_VALUE_HOLDS_LONG (value));
 730
 731   value->data[0].v_long = v_long;
 732 }
 733
 734 /**
 735  * g_value_get_long:
 736  * @value: a valid #GValue of type %G_TYPE_LONG
 737  *
 738  * Get the contents of a %G_TYPE_LONG #GValue.
 739  *
 740  * Returns: long integer contents of @value
 741  */
 742 glong
 743 g_value_get_long (const GValue *value)
 744 {
 745   g_return_val_if_fail (G_VALUE_HOLDS_LONG (value), 0);
 746
 747   return value->data[0].v_long;
 748 }
 749
 750 /**
 751  * g_value_set_ulong:
 752  * @value: a valid #GValue of type %G_TYPE_ULONG
 753  * @v_ulong: unsigned long integer value to be set
 754  *
 755  * Set the contents of a %G_TYPE_ULONG #GValue to @v_ulong.
 756  */
 757 void
 758 g_value_set_ulong (GValue *value,
 759                    gulong  v_ulong)
 760 {
 761   g_return_if_fail (G_VALUE_HOLDS_ULONG (value));
 762
 763   value->data[0].v_ulong = v_ulong;
 764 }
 765
 766 /**
 767  * g_value_get_ulong:
 768  * @value: a valid #GValue of type %G_TYPE_ULONG
 769  *
 770  * Get the contents of a %G_TYPE_ULONG #GValue.
 771  *
 772  * Returns: unsigned long integer contents of @value
 773  */
 774 gulong
 775 g_value_get_ulong (const GValue *value)
 776 {
 777   g_return_val_if_fail (G_VALUE_HOLDS_ULONG (value), 0);
 778
 779   return value->data[0].v_ulong;
 780 }
 781
 782 /**
 783  * g_value_get_int64:
 784  * @value: a valid #GValue of type %G_TYPE_INT64
 785  *
 786  * Get the contents of a %G_TYPE_INT64 #GValue.
 787  *
 788  * Returns: 64bit integer contents of @value
 789  */
 790 void
 791 g_value_set_int64 (GValue *value,
 792                    gint64  v_int64)
 793 {
 794   g_return_if_fail (G_VALUE_HOLDS_INT64 (value));
 795
 796   value->data[0].v_int64 = v_int64;
 797 }
 798
 799 /**
 800  * g_value_set_int64:
 801  * @value: a valid #GValue of type %G_TYPE_INT64
 802  * @v_int64: 64bit integer value to be set
 803  *
 804  * Set the contents of a %G_TYPE_INT64 #GValue to @v_int64.
 805  */
 806 gint64
 807 g_value_get_int64 (const GValue *value)
 808 {
 809   g_return_val_if_fail (G_VALUE_HOLDS_INT64 (value), 0);
 810
 811   return value->data[0].v_int64;
 812 }
 813
 814 /**
 815  * g_value_set_uint64:
 816  * @value: a valid #GValue of type %G_TYPE_UINT64
 817  * @v_uint64: unsigned 64bit integer value to be set
 818  *
 819  * Set the contents of a %G_TYPE_UINT64 #GValue to @v_uint64.
 820  */
 821 void
 822 g_value_set_uint64 (GValue *value,
 823                     guint64 v_uint64)
 824 {
 825   g_return_if_fail (G_VALUE_HOLDS_UINT64 (value));
 826
 827   value->data[0].v_uint64 = v_uint64;
 828 }
 829
 830 /**
 831  * g_value_get_uint64:
 832  * @value: a valid #GValue of type %G_TYPE_UINT64
 833  *
 834  * Get the contents of a %G_TYPE_UINT64 #GValue.
 835  *
 836  * Returns: unsigned 64bit integer contents of @value
 837  */
 838 guint64
 839 g_value_get_uint64 (const GValue *value)
 840 {
 841   g_return_val_if_fail (G_VALUE_HOLDS_UINT64 (value), 0);
 842
 843   return value->data[0].v_uint64;
 844 }
 845
 846 /**
 847  * g_value_set_float:
 848  * @value: a valid #GValue of type %G_TYPE_FLOAT
 849  * @v_float: float value to be set
 850  *
 851  * Set the contents of a %G_TYPE_FLOAT #GValue to @v_float.
 852  */
 853 void
 854 g_value_set_float (GValue *value,
 855                    gfloat  v_float)
 856 {
 857   g_return_if_fail (G_VALUE_HOLDS_FLOAT (value));
 858
 859   value->data[0].v_float = v_float;
 860 }
 861
 862 /**
 863  * g_value_get_float:
 864  * @value: a valid #GValue of type %G_TYPE_FLOAT
 865  *
 866  * Get the contents of a %G_TYPE_FLOAT #GValue.
 867  *
 868  * Returns: float contents of @value
 869  */
 870 gfloat
 871 g_value_get_float (const GValue *value)
 872 {
 873   g_return_val_if_fail (G_VALUE_HOLDS_FLOAT (value), 0);
 874
 875   return value->data[0].v_float;
 876 }
 877
 878 /**
 879  * g_value_set_double:
 880  * @value: a valid #GValue of type %G_TYPE_DOUBLE
 881  * @v_double: double value to be set
 882  *
 883  * Set the contents of a %G_TYPE_DOUBLE #GValue to @v_double.
 884  */
 885 void
 886 g_value_set_double (GValue *value,
 887                     gdouble v_double)
 888 {
 889   g_return_if_fail (G_VALUE_HOLDS_DOUBLE (value));
 890
 891   value->data[0].v_double = v_double;
 892 }
 893
 894 /**
 895  * g_value_get_double:
 896  * @value: a valid #GValue of type %G_TYPE_DOUBLE
 897  *
 898  * Get the contents of a %G_TYPE_DOUBLE #GValue.
 899  *
 900  * Returns: double contents of @value
 901  */
 902 gdouble
 903 g_value_get_double (const GValue *value)
 904 {
 905   g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (value), 0);
 906
 907   return value->data[0].v_double;
 908 }
 909
 910 /**
 911  * g_value_set_string:
 912  * @value: a valid #GValue of type %G_TYPE_STRING
 913  * @v_string: string to be set
 914  *
 915  * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
 916  */
 917 void
 918 g_value_set_string (GValue      *value,
 919                     const gchar *v_string)
 920 {
 921   gchar *new_val;
 922
 923   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 924
 925   new_val = g_strdup (v_string);
 926
 927   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
 928     value->data[1].v_uint = 0;
 929   else
 930     g_free (value->data[0].v_pointer);
 931
 932   value->data[0].v_pointer = new_val;
 933 }
 934
 935 /**
 936  * g_value_set_static_string:
 937  * @value: a valid #GValue of type %G_TYPE_STRING
 938  * @v_string: static string to be set
 939  *
 940  * Set the contents of a %G_TYPE_STRING #GValue to @v_string.
 941  * The string is assumed to be static, and is thus not duplicated
 942  * when setting the #GValue.
 943  */
 944 void
 945 g_value_set_static_string (GValue      *value,
 946                            const gchar *v_string)
 947 {
 948   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 949
 950   if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
 951     g_free (value->data[0].v_pointer);
 952   value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
 953   value->data[0].v_pointer = (gchar*) v_string;
 954 }
 955
 956 /**
 957  * g_value_set_string_take_ownership:
 958  * @value: a valid #GValue of type %G_TYPE_STRING
 959  * @v_string: duplicated unowned string to be set
 960  *
 961  * This is an internal function introduced mainly for C marshallers.
 962  *
 963  * Deprecated: 2.4: Use g_value_take_string() instead.
 964  */
 965 void
 966 g_value_set_string_take_ownership (GValue *value,
 967                                    gchar  *v_string)
 968 {
 969   g_value_take_string (value, v_string);
 970 }
 971
 972 /**
 973  * g_value_take_string:
 974  * @value: a valid #GValue of type %G_TYPE_STRING
 975  * @v_string: duplicated unowned string to be set
 976  *
 977  * Sets the contents of a %G_TYPE_STRING #GValue to @v_string.
 978  *
 979  * Since: 2.4
 980  */
 981 void
 982 g_value_take_string (GValue *value,
 983                      gchar  *v_string)
 984 {
 985   g_return_if_fail (G_VALUE_HOLDS_STRING (value));
 986
 987   if (value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)
 988     value->data[1].v_uint = 0;
 989   else
 990     g_free (value->data[0].v_pointer);
 991   value->data[0].v_pointer = v_string;
 992 }
 993
 994 /**
 995  * g_value_get_string:
 996  * @value: a valid #GValue of type %G_TYPE_STRING
 997  *
 998  * Get the contents of a %G_TYPE_STRING #GValue.
 999  *
1000  * Returns: string content of @value
1001  */
1002 G_CONST_RETURN gchar*
1003 g_value_get_string (const GValue *value)
1004 {
1005   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1006
1007   return value->data[0].v_pointer;
1008 }
1009
1010 /**
1011  * g_value_dup_string:
1012  * @value: a valid #GValue of type %G_TYPE_STRING
1013  *
1014  * Get a copy the contents of a %G_TYPE_STRING #GValue.
1015  *
1016  * Returns: a newly allocated copy of the string content of @value
1017  */
1018 gchar*
1019 g_value_dup_string (const GValue *value)
1020 {
1021   g_return_val_if_fail (G_VALUE_HOLDS_STRING (value), NULL);
1022
1023   return g_strdup (value->data[0].v_pointer);
1024 }
1025
1026 /**
1027  * g_value_set_pointer:
1028  * @value: a valid #GValue of %G_TYPE_POINTER
1029  * @v_pointer: pointer value to be set
1030  *
1031  * Set the contents of a pointer #GValue to @v_pointer.
1032  */
1033 void
1034 g_value_set_pointer (GValue  *value,
1035                      gpointer v_pointer)
1036 {
1037   g_return_if_fail (G_VALUE_HOLDS_POINTER (value));
1038
1039   value->data[0].v_pointer = v_pointer;
1040 }
1041
1042 /**
1043  * g_value_get_pointer:
1044  * @value: a valid #GValue of %G_TYPE_POINTER
1045  *
1046  * Get the contents of a pointer #GValue.
1047  *
1048  * Returns: pointer contents of @value
1049  */
1050 gpointer
1051 g_value_get_pointer (const GValue *value)
1052 {
1053   g_return_val_if_fail (G_VALUE_HOLDS_POINTER (value), NULL);
1054
1055   return value->data[0].v_pointer;
1056 }
1057
1058 GType
1059 g_gtype_get_type (void)
1060 {
1061   static const GTypeInfo type_info = { 0, };
1062   static GType type;
1063   if (!type)
1064     type = g_type_register_static (G_TYPE_POINTER, g_intern_static_string ("GType"), &type_info, 0);
1065   return type;
1066 }
1067
1068 /**
1069  * g_value_set_gtype:
1070  * @value: a valid #GValue of type %G_TYPE_GTYPE
1071  * @v_gtype: #GType to be set
1072  *
1073  * Set the contents of a %G_TYPE_GTYPE #GValue to @v_gtype.
1074  *
1075  * Since: 2.12
1076  */
1077 void
1078 g_value_set_gtype (GValue *value,
1079                    GType   v_gtype)
1080 {
1081   g_return_if_fail (G_VALUE_HOLDS_GTYPE (value));
1082
1083   value->data[0].v_long = v_gtype;
1084
1085 }
1086
1087 /**
1088  * g_value_get_gtype:
1089  * @value: a valid #GValue of type %G_TYPE_GTYPE
1090  *
1091  * Get the contents of a %G_TYPE_GTYPE #GValue.
1092  *
1093  * Since: 2.12
1094  * Returns: the #GType stored in @value
1095  */
1096 GType
1097 g_value_get_gtype (const GValue *value)
1098 {
1099   g_return_val_if_fail (G_VALUE_HOLDS_GTYPE (value), 0);
1100
1101   return value->data[0].v_long;
1102 }
1103
1104 /**
1105  * g_strdup_value_contents:
1106  * @value: #GValue which contents are to be described.
1107  *
1108  * Return a newly allocated string, which describes the contents of a #GValue.
1109  * The main purpose of this function is to describe #GValue contents for
1110  * debugging output, the way in which the contents are described may change
1111  * between different GLib versions.
1112  *
1113  * Returns: Newly allocated string.
1114  */
1115 gchar*
1116 g_strdup_value_contents (const GValue *value)
1117 {
1118   const gchar *src;
1119   gchar *contents;
1120
1121   g_return_val_if_fail (G_IS_VALUE (value), NULL);
1122
1123   if (G_VALUE_HOLDS_STRING (value))
1124     {
1125       src = g_value_get_string (value);
1126
1127       if (!src)
1128         contents = g_strdup ("NULL");
1129       else
1130         {
1131           gchar *s = g_strescape (src, NULL);
1132
1133           contents = g_strdup_printf ("\"%s\"", s);
1134           g_free (s);
1135         }
1136     }
1137   else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING))
1138     {
1139       GValue tmp_value = { 0, };
1140       gchar *s;
1141
1142       g_value_init (&tmp_value, G_TYPE_STRING);
1143       g_value_transform (value, &tmp_value);
1144       s = g_strescape (g_value_get_string (&tmp_value), NULL);
1145       g_value_unset (&tmp_value);
1146       if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value))
1147         contents = g_strdup_printf ("((%s) %s)",
1148                                     g_type_name (G_VALUE_TYPE (value)),
1149                                     s);
1150       else
1151         contents = g_strdup (s ? s : "NULL");
1152       g_free (s);
1153     }
1154   else if (g_value_fits_pointer (value))
1155     {
1156       gpointer p = g_value_peek_pointer (value);
1157
1158       if (!p)
1159         contents = g_strdup ("NULL");
1160       else if (G_VALUE_HOLDS_OBJECT (value))
1161         contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p);
1162       else if (G_VALUE_HOLDS_PARAM (value))
1163         contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p);
1164       else if (G_VALUE_HOLDS_BOXED (value))
1165         contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p);
1166       else if (G_VALUE_HOLDS_POINTER (value))
1167         contents = g_strdup_printf ("((gpointer) %p)", p);
1168       else
1169         contents = g_strdup ("???");
1170     }
1171   else
1172     contents = g_strdup ("???");
1173
1174   return contents;
1175 }
1176
1177 /**
1178  * g_pointer_type_register_static:
1179  * @name: the name of the new pointer type.
1180  *
1181  * Creates a new %G_TYPE_POINTER derived type id for a new
1182  * pointer type with name @name.
1183  *
1184  * Returns: a new %G_TYPE_POINTER derived type id for @name.
1185  */
1186 GType
1187 g_pointer_type_register_static (const gchar *name)
1188 {
1189   static const GTypeInfo type_info = {
1190     0,                  /* class_size */
1191     NULL,               /* base_init */
1192     NULL,               /* base_finalize */
1193     NULL,               /* class_init */
1194     NULL,               /* class_finalize */
1195     NULL,               /* class_data */
1196     0,                  /* instance_size */
1197     0,                  /* n_preallocs */
1198     NULL,               /* instance_init */
1199     NULL                /* value_table */
1200   };
1201   GType type;
1202
1203   g_return_val_if_fail (name != NULL, 0);
1204   g_return_val_if_fail (g_type_from_name (name) == 0, 0);
1205
1206   type = g_type_register_static (G_TYPE_POINTER, name, &type_info, 0);
1207
1208   return type;
1209 }
1210
1211 #define __G_VALUETYPES_C__
1212 #include "gobjectaliasdef.c"