/* GObject - GLib Type, Object, Parameter and Signal Library

 * Copyright (C) 1997-1999, 2000-2001 Tim Janik and Red Hat, Inc.

 * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General

 * Public License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * MT safe

 */

#include "config.h"

#include <string.h>

#include <stdlib.h> /* qsort() */

#include "gvaluetypes.h"

#include "gvaluecollector.h"

#include "gobject.h"

#include "gparam.h"

#include "gboxed.h"

#include "genums.h"

#include "gobjectalias.h"

#if __SYMBIAN32__

#include "gobject_wsd.h"

#endif /* __SYMBIAN32__ */

/* --- value functions --- */

static void

value_init_long0 (GValue *value)

{

  value->data[0].v_long = 0;

}

static void

value_copy_long0 (const GValue *src_value,

		  GValue       *dest_value)

{

  dest_value->data[0].v_long = src_value->data[0].v_long;

}

static gchar*

value_lcopy_char (const GValue *value,

		  guint         n_collect_values,

		  GTypeCValue  *collect_values,

		  guint         collect_flags)

{

  gint8 *int8_p = collect_values[0].v_pointer;

  if (!int8_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  *int8_p = value->data[0].v_int;

  return NULL;

}

static gchar*

value_lcopy_boolean (const GValue *value,

		     guint         n_collect_values,

		     GTypeCValue  *collect_values,

		     guint         collect_flags)

{

  gboolean *bool_p = collect_values[0].v_pointer;

  if (!bool_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  *bool_p = value->data[0].v_int;

  return NULL;

}

static gchar*

value_collect_int (GValue      *value,

		   guint        n_collect_values,

		   GTypeCValue *collect_values,

		   guint        collect_flags)

{

  value->data[0].v_int = collect_values[0].v_int;

  return NULL;

}

static gchar*

value_lcopy_int (const GValue *value,

		 guint         n_collect_values,

		 GTypeCValue  *collect_values,

		 guint         collect_flags)

{

  gint *int_p = collect_values[0].v_pointer;

  if (!int_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  *int_p = value->data[0].v_int;

  return NULL;

}

static gchar*

value_collect_long (GValue      *value,

		    guint        n_collect_values,

		    GTypeCValue *collect_values,

		    guint        collect_flags)

{

  value->data[0].v_long = collect_values[0].v_long;

  return NULL;

}

static gchar*

value_lcopy_long (const GValue *value,

		  guint         n_collect_values,

		  GTypeCValue  *collect_values,

		  guint         collect_flags)

{

  glong *long_p = collect_values[0].v_pointer;

  if (!long_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  *long_p = value->data[0].v_long;

  return NULL;

}

static void

value_init_int64 (GValue *value)

{

  value->data[0].v_int64 = 0;

}

static void

value_copy_int64 (const GValue *src_value,

		  GValue       *dest_value)

{

  dest_value->data[0].v_int64 = src_value->data[0].v_int64;

}

static gchar*

value_collect_int64 (GValue      *value,

		     guint        n_collect_values,

		     GTypeCValue *collect_values,

		     guint        collect_flags)

{

  value->data[0].v_int64 = collect_values[0].v_int64;

  return NULL;

}

static gchar*

value_lcopy_int64 (const GValue *value,

		   guint         n_collect_values,

		   GTypeCValue  *collect_values,

		   guint         collect_flags)

{

  gint64 *int64_p = collect_values[0].v_pointer;

  if (!int64_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  *int64_p = value->data[0].v_int64;

  return NULL;

}

static void

value_init_float (GValue *value)

{

  value->data[0].v_float = 0.0;

}

static void

value_copy_float (const GValue *src_value,

		  GValue       *dest_value)

{

  dest_value->data[0].v_float = src_value->data[0].v_float;

}

static gchar*

value_collect_float (GValue      *value,

		     guint        n_collect_values,

		     GTypeCValue *collect_values,

		     guint        collect_flags)

{

  value->data[0].v_float = collect_values[0].v_double;

  return NULL;

}

static gchar*

value_lcopy_float (const GValue *value,

		   guint         n_collect_values,

		   GTypeCValue  *collect_values,

		   guint         collect_flags)

{

  gfloat *float_p = collect_values[0].v_pointer;

  if (!float_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  *float_p = value->data[0].v_float;

  return NULL;

}

static void

value_init_double (GValue *value)

{

  value->data[0].v_double = 0.0;

}

static void

value_copy_double (const GValue *src_value,

		   GValue	*dest_value)

{

  dest_value->data[0].v_double = src_value->data[0].v_double;

}

static gchar*

value_collect_double (GValue	  *value,

		      guint        n_collect_values,

		      GTypeCValue *collect_values,

		      guint        collect_flags)

{

  value->data[0].v_double = collect_values[0].v_double;

  return NULL;

}

static gchar*

value_lcopy_double (const GValue *value,

		    guint         n_collect_values,

		    GTypeCValue  *collect_values,

		    guint         collect_flags)

{

  gdouble *double_p = collect_values[0].v_pointer;

  if (!double_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  *double_p = value->data[0].v_double;

  return NULL;

}

static void

value_init_string (GValue *value)

{

  value->data[0].v_pointer = NULL;

}

static void

value_free_string (GValue *value)

{

  if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))

    g_free (value->data[0].v_pointer);

}

static void

value_copy_string (const GValue *src_value,

		   GValue	*dest_value)

{

  dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);

}

static gchar*

value_collect_string (GValue	  *value,

		      guint        n_collect_values,

		      GTypeCValue *collect_values,

		      guint        collect_flags)

{

  if (!collect_values[0].v_pointer)

    value->data[0].v_pointer = NULL;

  else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)

    {

      value->data[0].v_pointer = collect_values[0].v_pointer;

      value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;

    }

  else

    value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);

  return NULL;

}

static gchar*

value_lcopy_string (const GValue *value,

		    guint         n_collect_values,

		    GTypeCValue  *collect_values,

		    guint         collect_flags)

{

  gchar **string_p = collect_values[0].v_pointer;

  if (!string_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  if (!value->data[0].v_pointer)

    *string_p = NULL;

  else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)

    *string_p = value->data[0].v_pointer;

  else

    *string_p = g_strdup (value->data[0].v_pointer);

  return NULL;

}

static void

value_init_pointer (GValue *value)

{

  value->data[0].v_pointer = NULL;

}

static void

value_copy_pointer (const GValue *src_value,

		    GValue       *dest_value)

{

  dest_value->data[0].v_pointer = src_value->data[0].v_pointer;

}

static gpointer

value_peek_pointer0 (const GValue *value)

{

  return value->data[0].v_pointer;

}

static gchar*

value_collect_pointer (GValue      *value,

		       guint        n_collect_values,

		       GTypeCValue *collect_values,

		       guint        collect_flags)

{

  value->data[0].v_pointer = collect_values[0].v_pointer;

  return NULL;

}

static gchar*

value_lcopy_pointer (const GValue *value,

		     guint         n_collect_values,

		     GTypeCValue  *collect_values,

		     guint         collect_flags)

{

  gpointer *pointer_p = collect_values[0].v_pointer;

  if (!pointer_p)

    return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

  *pointer_p = value->data[0].v_pointer;

  return NULL;

}

/* --- type initialization --- */

void

g_value_types_init (void)

{

  GTypeInfo info = {

    0,				/* class_size */

    NULL,			/* base_init */

    NULL,			/* base_destroy */

    NULL,			/* class_init */

    NULL,			/* class_destroy */

    NULL,			/* class_data */

    0,				/* instance_size */

    0,				/* n_preallocs */

    NULL,			/* instance_init */

    NULL,			/* value_table */

  };

  const GTypeFundamentalInfo finfo = { G_TYPE_FLAG_DERIVABLE, };

  GType type;

  /* G_TYPE_CHAR / G_TYPE_UCHAR

   */

  {

    static const GTypeValueTable value_table = {

      value_init_long0,		/* value_init */

      NULL,			/* value_free */

      value_copy_long0,		/* value_copy */

      NULL,			/* value_peek_pointer */

      "i",			/* collect_format */

      value_collect_int,	/* collect_value */

      "p",			/* lcopy_format */

      value_lcopy_char,		/* lcopy_value */

    };

    info.value_table = &value_table;

    type = g_type_register_fundamental (G_TYPE_CHAR, g_intern_static_string ("gchar"), &info, &finfo, 0);

    g_assert (type == G_TYPE_CHAR);

    type = g_type_register_fundamental (G_TYPE_UCHAR, g_intern_static_string ("guchar"), &info, &finfo, 0);

    g_assert (type == G_TYPE_UCHAR);

  }

  /* G_TYPE_BOOLEAN

   */

  {

    static const GTypeValueTable value_table = {

      value_init_long0,		 /* value_init */

      NULL,			 /* value_free */

      value_copy_long0,		 /* value_copy */

      NULL,                      /* value_peek_pointer */

      "i",			 /* collect_format */

      value_collect_int,	 /* collect_value */

      "p",			 /* lcopy_format */

      value_lcopy_boolean,	 /* lcopy_value */

    };

    info.value_table = &value_table;

    type = g_type_register_fundamental (G_TYPE_BOOLEAN, g_intern_static_string ("gboolean"), &info, &finfo, 0);

    g_assert (type == G_TYPE_BOOLEAN);

  }

  /* G_TYPE_INT / G_TYPE_UINT

   */

  {

    static const GTypeValueTable value_table = {

      value_init_long0,		/* value_init */

      NULL,			/* value_free */

      value_copy_long0,		/* value_copy */

      NULL,                     /* value_peek_pointer */

      "i",			/* collect_format */

      value_collect_int,	/* collect_value */

      "p",			/* lcopy_format */

      value_lcopy_int,		/* lcopy_value */

    };

    info.value_table = &value_table;

    type = g_type_register_fundamental (G_TYPE_INT, g_intern_static_string ("gint"), &info, &finfo, 0);

    g_assert (type == G_TYPE_INT);

    type = g_type_register_fundamental (G_TYPE_UINT, g_intern_static_string ("guint"), &info, &finfo, 0);

    g_assert (type == G_TYPE_UINT);

  }

  /* G_TYPE_LONG / G_TYPE_ULONG

   */

  {

    static const GTypeValueTable value_table = {

      value_init_long0,		/* value_init */

      NULL,			/* value_free */

      value_copy_long0,		/* value_copy */

      NULL,                     /* value_peek_pointer */

      "l",			/* collect_format */

      value_collect_long,	/* collect_value */

      "p",			/* lcopy_format */

      value_lcopy_long,		/* lcopy_value */

    };

    info.value_table = &value_table;

    type = g_type_register_fundamental (G_TYPE_LONG, g_intern_static_string ("glong"), &info, &finfo, 0);

    g_assert (type == G_TYPE_LONG);

    type = g_type_register_fundamental (G_TYPE_ULONG, g_intern_static_string ("gulong"), &info, &finfo, 0);

    g_assert (type == G_TYPE_ULONG);

  }

  /* G_TYPE_INT64 / G_TYPE_UINT64

   */

  {

    static const GTypeValueTable value_table = {

      value_init_int64,		/* value_init */

      NULL,			/* value_free */

      value_copy_int64,		/* value_copy */

      NULL,                     /* value_peek_pointer */

      "q",			/* collect_format */

      value_collect_int64,	/* collect_value */

      "p",			/* lcopy_format */

      value_lcopy_int64,	/* lcopy_value */

    };

    info.value_table = &value_table;

    type = g_type_register_fundamental (G_TYPE_INT64, g_intern_static_string ("gint64"), &info, &finfo, 0);

    g_assert (type == G_TYPE_INT64);

    type = g_type_register_fundamental (G_TYPE_UINT64, g_intern_static_string ("guint64"), &info, &finfo, 0);

    g_assert (type == G_TYPE_UINT64);

  }

  /* G_TYPE_FLOAT

   */

  {

    static const GTypeValueTable value_table = {

      value_init_float,		 /* value_init */

      NULL,			 /* value_free */

      value_copy_float,		 /* value_copy */

      NULL,                      /* value_peek_pointer */

      "d",			 /* collect_format */

      value_collect_float,	 /* collect_value */

      "p",			 /* lcopy_format */

      value_lcopy_float,	 /* lcopy_value */

    };

    info.value_table = &value_table;

    type = g_type_register_fundamental (G_TYPE_FLOAT, g_intern_static_string ("gfloat"), &info, &finfo, 0);

    g_assert (type == G_TYPE_FLOAT);

  }

  /* G_TYPE_DOUBLE

   */

  {

    static const GTypeValueTable value_table = {

      value_init_double,	/* value_init */

      NULL,			/* value_free */

      value_copy_double,	/* value_copy */

      NULL,                     /* value_peek_pointer */

      "d",			/* collect_format */

      value_collect_double,	/* collect_value */

      "p",			/* lcopy_format */

      value_lcopy_double,	/* lcopy_value */

    };

    info.value_table = &value_table;

    type = g_type_register_fundamental (G_TYPE_DOUBLE, g_intern_static_string ("gdouble"), &info, &finfo, 0);

    g_assert (type == G_TYPE_DOUBLE);

  }

  /* G_TYPE_STRING

   */

  {

    static const GTypeValueTable value_table = {

      value_init_string,	/* value_init */

      value_free_string,	/* value_free */

      value_copy_string,	/* value_copy */