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

 * Copyright (C) 1998-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 "gtype.h"

#include "gtypeplugin.h"

#include "gvaluecollector.h"

#include "gbsearcharray.h"

#include "gobjectalias.h"

#ifdef __SYMBIAN32__

#include <glib_global.h>

#include "gobject_wsd.h"

#endif /* __SYMBIAN32__ */

/**

 * SECTION:gtype

 * @short_description: The GLib Runtime type identification and

 *     management system

 * @title:Type Information

 *

 * The GType API is the foundation of the GObject system.  It provides the

 * facilities for registering and managing all fundamental data types,

 * user-defined object and interface types.  Before using any GType

 * or GObject functions, g_type_init() must be called to initialize the

 * type system.

 *

 * For type creation and registration purposes, all types fall into one of

 * two categories: static or dynamic.  Static types are never loaded or

 * unloaded at run-time as dynamic types may be.  Static types are created

 * with g_type_register_static() that gets type specific information passed

 * in via a #GTypeInfo structure.

 * Dynamic types are created with g_type_register_dynamic() which takes a

 * #GTypePlugin structure instead. The remaining type information (the

 * #GTypeInfo structure) is retrieved during runtime through #GTypePlugin

 * and the g_type_plugin_*() API.

 * These registration functions are usually called only once from a

 * function whose only purpose is to return the type identifier for a

 * specific class.  Once the type (or class or interface) is registered,

 * it may be instantiated, inherited, or implemented depending on exactly

 * what sort of type it is.

 * There is also a third registration function for registering fundamental

 * types called g_type_register_fundamental() which requires both a #GTypeInfo

 * structure and a #GTypeFundamentalInfo structure but it is seldom used

 * since most fundamental types are predefined rather than user-defined.

 *

 * A final word about type names.

 * Such an identifier needs to be at least three characters long. There is no

 * upper length limit. The first character needs to be a letter (a-z or A-Z)

 * or an underscore '_'. Subsequent characters can be letters, numbers or

 * any of '-_+'.

 */

/* NOTE: some functions (some internal variants and exported ones)

 * invalidate data portions of the TypeNodes. if external functions/callbacks

 * are called, pointers to memory maintained by TypeNodes have to be looked up

 * again. this affects most of the struct TypeNode fields, e.g. ->children or

 * CLASSED_NODE_IFACES_ENTRIES() respectively IFACE_NODE_PREREQUISITES() (but

 * not ->supers[]), as all those memory portions can get realloc()ed during

 * callback invocation.

 *

 * TODO:

 * - g_type_from_name() should do an ordered array lookup after fetching the

 *   the quark, instead of a second hashtable lookup.

 *

 * LOCKING:

 * lock handling issues when calling static functions are indicated by

 * uppercase letter postfixes, all static functions have to have

 * one of the below postfixes:

 * - _I:	[Indifferent about locking]

 *   function doesn't care about locks at all

 * - _U:	[Unlocked invocation]

 *   no read or write lock has to be held across function invocation

 *   (locks may be acquired and released during invocation though)

 * - _L:	[Locked invocation]

 *   a write lock or more than 0 read locks have to be held across

 *   function invocation

 * - _W:	[Write-locked invocation]

 *   a write lock has to be held across function invocation

 * - _Wm:	[Write-locked invocation, mutatable]

 *   like _W, but the write lock might be released and reacquired

 *   during invocation, watch your pointers

 * - _WmREC:    [Write-locked invocation, mutatable, recursive]

 *   like _Wm, but also acquires recursive mutex class_init_rec_mutex

 */

#ifdef LOCK_DEBUG

#define G_READ_LOCK(rw_lock)    do { g_printerr (G_STRLOC ": readL++\n"); g_static_rw_lock_reader_lock (rw_lock); } while (0)

#define G_READ_UNLOCK(rw_lock)  do { g_printerr (G_STRLOC ": readL--\n"); g_static_rw_lock_reader_unlock (rw_lock); } while (0)

#define G_WRITE_LOCK(rw_lock)   do { g_printerr (G_STRLOC ": writeL++\n"); g_static_rw_lock_writer_lock (rw_lock); } while (0)

#define G_WRITE_UNLOCK(rw_lock) do { g_printerr (G_STRLOC ": writeL--\n"); g_static_rw_lock_writer_unlock (rw_lock); } while (0)

#else

#define G_READ_LOCK(rw_lock)    g_static_rw_lock_reader_lock (rw_lock)

#define G_READ_UNLOCK(rw_lock)  g_static_rw_lock_reader_unlock (rw_lock)

#define G_WRITE_LOCK(rw_lock)   g_static_rw_lock_writer_lock (rw_lock)

#define G_WRITE_UNLOCK(rw_lock) g_static_rw_lock_writer_unlock (rw_lock)

#endif

#define	INVALID_RECURSION(func, arg, type_name) G_STMT_START{ \

    static const gchar _action[] = " invalidly modified type ";  \

    gpointer _arg = (gpointer) (arg); const gchar *_tname = (type_name), *_fname = (func); \

    if (_arg) \

      g_error ("%s(%p)%s`%s'", _fname, _arg, _action, _tname); \

    else \

      g_error ("%s()%s`%s'", _fname, _action, _tname); \

}G_STMT_END

#define	g_return_val_if_uninitialized(condition, init_function, return_value) G_STMT_START{	\

  if (!(condition))										\

    {												\

      g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,						\

	     "%s: initialization assertion failed, use %s() prior to this function",		\

	     G_STRLOC, G_STRINGIFY (init_function));						\

      return (return_value);									\

    }												\

}G_STMT_END

#ifdef  G_ENABLE_DEBUG

#define DEBUG_CODE(debug_type, code_block)  G_STMT_START {    \

    if (_g_type_debug_flags & G_TYPE_DEBUG_ ## debug_type) \

      { code_block; }                                     \

} G_STMT_END

#else /* !G_ENABLE_DEBUG */

#define DEBUG_CODE(debug_type, code_block)  /* code_block */

#endif  /* G_ENABLE_DEBUG */

#define TYPE_FUNDAMENTAL_FLAG_MASK (G_TYPE_FLAG_CLASSED | \

				    G_TYPE_FLAG_INSTANTIATABLE | \

				    G_TYPE_FLAG_DERIVABLE | \

				    G_TYPE_FLAG_DEEP_DERIVABLE)

#define	TYPE_FLAG_MASK		   (G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT)

#define	SIZEOF_FUNDAMENTAL_INFO	   ((gssize) MAX (MAX (sizeof (GTypeFundamentalInfo), \

						       sizeof (gpointer)), \

                                                  sizeof (glong)))

/* The 2*sizeof(size_t) alignment here is borrowed from

 * GNU libc, so it should be good most everywhere.

 * It is more conservative than is needed on some 64-bit

 * platforms, but ia64 does require a 16-byte alignment.

 * The SIMD extensions for x86 and ppc32 would want a

 * larger alignment than this, but we don't need to

 * do better than malloc.

 */

#define STRUCT_ALIGNMENT (2 * sizeof (gsize))

#define ALIGN_STRUCT(offset) \

      ((offset + (STRUCT_ALIGNMENT - 1)) & -STRUCT_ALIGNMENT)

/* --- typedefs --- */

typedef struct _TypeNode        TypeNode;

typedef struct _CommonData      CommonData;

typedef struct _IFaceData       IFaceData;

typedef struct _ClassData       ClassData;

typedef struct _InstanceData    InstanceData;

typedef union  _TypeData        TypeData;

typedef struct _IFaceEntry      IFaceEntry;

typedef struct _IFaceHolder	IFaceHolder;

/* --- prototypes --- */

static inline GTypeFundamentalInfo*	type_node_fundamental_info_I	(TypeNode		*node);

static	      void			type_add_flags_W		(TypeNode		*node,

									 GTypeFlags		 flags);

static	      void			type_data_make_W		(TypeNode		*node,

									 const GTypeInfo	*info,

									 const GTypeValueTable	*value_table);

static inline void			type_data_ref_Wm		(TypeNode		*node);

static inline void			type_data_unref_WmREC		(TypeNode		*node,

									 gboolean		 uncached);

static void				type_data_last_unref_Wm		(GType			 type,

									 gboolean		 uncached);

static inline gpointer			type_get_qdata_L		(TypeNode		*node,

									 GQuark			 quark);

static inline void			type_set_qdata_W		(TypeNode		*node,

									 GQuark			 quark,

									 gpointer		 data);

static IFaceHolder*			type_iface_peek_holder_L	(TypeNode		*iface,

									 GType			 instance_type);

static gboolean                         type_iface_vtable_base_init_Wm  (TypeNode               *iface,

                                                                         TypeNode               *node);

static void                             type_iface_vtable_iface_init_Wm (TypeNode               *iface,

                                                                         TypeNode               *node);

static gboolean				type_node_is_a_L		(TypeNode		*node,

									 TypeNode		*iface_node);

/* --- enumeration --- */

/* The InitState enumeration is used to track the progress of initializing

 * both classes and interface vtables. Keeping the state of initialization

 * is necessary to handle new interfaces being added while we are initializing

 * the class or other interfaces.

 */

typedef enum

{

  UNINITIALIZED,

  BASE_CLASS_INIT,

  BASE_IFACE_INIT,

  CLASS_INIT,

  IFACE_INIT,

  INITIALIZED

} InitState;

/* --- structures --- */

struct _TypeNode

{

  GTypePlugin *plugin;

  guint        n_children : 12;

  guint        n_supers : 8;

  guint        _prot_n_ifaces_prerequisites : 9;

  guint        is_classed : 1;

  guint        is_instantiatable : 1;

  guint        mutatable_check_cache : 1;	/* combines some common path checks */

  GType       *children;

  TypeData * volatile data;

  GQuark       qname;

  GData       *global_gdata;

  union {

    IFaceEntry  *iface_entries;		/* for !iface types */

    GType       *prerequisistes;

  } _prot;

  GType        supers[1]; /* flexible array */

};

#define SIZEOF_BASE_TYPE_NODE()			(G_STRUCT_OFFSET (TypeNode, supers))

#define MAX_N_SUPERS				(255)

#define MAX_N_CHILDREN				(4095)

#define MAX_N_IFACES				(511)

#define	MAX_N_PREREQUISITES			(MAX_N_IFACES)

#define NODE_TYPE(node)				(node->supers[0])

#define NODE_PARENT_TYPE(node)			(node->supers[1])

#define NODE_FUNDAMENTAL_TYPE(node)		(node->supers[node->n_supers])

#define NODE_NAME(node)				(g_quark_to_string (node->qname))

#define	NODE_IS_IFACE(node)			(NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE)

#define	CLASSED_NODE_N_IFACES(node)		((node)->_prot_n_ifaces_prerequisites)

#define	CLASSED_NODE_IFACES_ENTRIES(node)	((node)->_prot.iface_entries)

#define	IFACE_NODE_N_PREREQUISITES(node)	((node)->_prot_n_ifaces_prerequisites)

#define	IFACE_NODE_PREREQUISITES(node)		((node)->_prot.prerequisistes)

#define	iface_node_get_holders_L(node)		((IFaceHolder*) type_get_qdata_L ((node), static_quark_iface_holder))

#define	iface_node_set_holders_W(node, holders)	(type_set_qdata_W ((node), static_quark_iface_holder, (holders)))

#define	iface_node_get_dependants_array_L(n)	((GType*) type_get_qdata_L ((n), static_quark_dependants_array))

#define	iface_node_set_dependants_array_W(n,d)	(type_set_qdata_W ((n), static_quark_dependants_array, (d)))

#define	TYPE_ID_MASK				((GType) ((1 << G_TYPE_FUNDAMENTAL_SHIFT) - 1))

#define NODE_IS_ANCESTOR(ancestor, node)                                                    \

        ((ancestor)->n_supers <= (node)->n_supers &&                                        \

	 (node)->supers[(node)->n_supers - (ancestor)->n_supers] == NODE_TYPE (ancestor))

struct _IFaceHolder

{

  GType           instance_type;

  GInterfaceInfo *info;

  GTypePlugin    *plugin;

  IFaceHolder    *next;

};

struct _IFaceEntry

{

  GType           iface_type;

  GTypeInterface *vtable;

  InitState       init_state;

};

struct _CommonData

{

  guint             ref_count;

  GTypeValueTable  *value_table;

};

struct _IFaceData

{

  CommonData         common;

  guint16            vtable_size;

  GBaseInitFunc      vtable_init_base;

  GBaseFinalizeFunc  vtable_finalize_base;

  GClassInitFunc     dflt_init;

  GClassFinalizeFunc dflt_finalize;

  gconstpointer      dflt_data;

  gpointer           dflt_vtable;

};

struct _ClassData

{

  CommonData         common;

  guint16            class_size;

  guint              init_state : 4;

  GBaseInitFunc      class_init_base;

  GBaseFinalizeFunc  class_finalize_base;

  GClassInitFunc     class_init;

  GClassFinalizeFunc class_finalize;

  gconstpointer      class_data;

  gpointer           class;

};

struct _InstanceData

{

  CommonData         common;

  guint16            class_size;

  guint              init_state : 4;

  GBaseInitFunc      class_init_base;

  GBaseFinalizeFunc  class_finalize_base;

  GClassInitFunc     class_init;

  GClassFinalizeFunc class_finalize;

  gconstpointer      class_data;

  gpointer           class;

  guint16            instance_size;

  guint16            private_size;

  guint16            n_preallocs;

  GInstanceInitFunc  instance_init;

};

union _TypeData

{

  CommonData         common;

  IFaceData          iface;

  ClassData          class;

  InstanceData       instance;

};

#if (!EMULATOR)

typedef struct {

  gpointer            cache_data;

  GTypeClassCacheFunc cache_func;

} ClassCacheFunc;

typedef struct {

  gpointer                check_data;

  GTypeInterfaceCheckFunc check_func;

} IFaceCheckFunc;

#endif /* EMULATOR */

/* --- variables --- */

#if EMULATOR

PLS(type_rw_lock,gtype,GStaticRWLock)

PLS(class_init_rec_mutex,gtype,GStaticRecMutex)

PLS(static_n_class_cache_funcs,gtype,guint)

PLS(static_class_cache_funcs ,gtype,ClassCacheFunc *)

PLS(static_n_iface_check_funcs,gtype,guint)

PLS(static_iface_check_funcs,gtype,IFaceCheckFunc *)

PLS(static_quark_type_flags,gtype,GQuark)

PLS(static_quark_iface_holder,gtype,GQuark)

PLS(static_quark_dependants_array,gtype,GQuark)

PLS(_g_type_debug_flags,gtype,GTypeDebugFlags)

PLS(static_type_nodes_ht,gtype,GHashTable *)

PLS_ARRAY(static_fundamental_type_nodes,gtype,TypeNode	*)

PLS(static_fundamental_next,gtype,GType)

#define type_rw_lock (*FUNCTION_NAME(type_rw_lock,gtype)())

#define class_init_rec_mutex (*FUNCTION_NAME(class_init_rec_mutex,gtype)())

#define static_n_class_cache_funcs (*FUNCTION_NAME(static_n_class_cache_funcs,gtype)())

#define static_class_cache_funcs  (*FUNCTION_NAME(static_class_cache_funcs ,gtype)())

#define static_n_iface_check_funcs (*FUNCTION_NAME(static_n_iface_check_funcs,gtype)())

#define static_iface_check_funcs (*FUNCTION_NAME(static_iface_check_funcs,gtype)())

#define static_quark_type_flags (*FUNCTION_NAME(static_quark_type_flags,gtype)())

#define static_quark_iface_holder (*FUNCTION_NAME(static_quark_iface_holder,gtype)())

#define static_quark_dependants_array (*FUNCTION_NAME(static_quark_dependants_array,gtype)())

#define _g_type_debug_flags (*FUNCTION_NAME(_g_type_debug_flags,gtype)())

#define static_type_nodes_ht (*FUNCTION_NAME(static_type_nodes_ht,gtype)())

#define static_fundamental_type_nodes (FUNCTION_NAME(static_fundamental_type_nodes,gtype)())

#define static_fundamental_next (*FUNCTION_NAME(static_fundamental_next,gtype)())

#else

static GStaticRWLock   type_rw_lock = G_STATIC_RW_LOCK_INIT;

static GStaticRecMutex class_init_rec_mutex = G_STATIC_REC_MUTEX_INIT;

static guint           static_n_class_cache_funcs = 0;

static ClassCacheFunc *static_class_cache_funcs = NULL;

static guint           static_n_iface_check_funcs = 0;

static IFaceCheckFunc *static_iface_check_funcs = NULL;

static GQuark          static_quark_type_flags = 0;

static GQuark          static_quark_iface_holder = 0;

static GQuark          static_quark_dependants_array = 0;

GTypeDebugFlags	       _g_type_debug_flags = 0;

/* --- type nodes --- */

static GHashTable       *static_type_nodes_ht = NULL;

static TypeNode		*static_fundamental_type_nodes[(G_TYPE_FUNDAMENTAL_MAX >> G_TYPE_FUNDAMENTAL_SHIFT) + 1] = { NULL, };

static GType		 static_fundamental_next = G_TYPE_RESERVED_USER_FIRST;

#endif /* EMULATOR */

static inline TypeNode*

lookup_type_node_I (register GType utype)

{

  if (utype > G_TYPE_FUNDAMENTAL_MAX)

    return (TypeNode*) (utype & ~TYPE_ID_MASK);

  else

    return static_fundamental_type_nodes[utype >> G_TYPE_FUNDAMENTAL_SHIFT];

}

static TypeNode*

type_node_any_new_W (TypeNode             *pnode,

		     GType                 ftype,

		     const gchar          *name,

		     GTypePlugin          *plugin,

		     GTypeFundamentalFlags type_flags)

{

  guint n_supers;

  GType type;

  TypeNode *node;

  guint i, node_size = 0;

  n_supers = pnode ? pnode->n_supers + 1 : 0;

  if (!pnode)

    node_size += SIZEOF_FUNDAMENTAL_INFO;	      /* fundamental type info */

  node_size += SIZEOF_BASE_TYPE_NODE ();	      /* TypeNode structure */

  node_size += (sizeof (GType) * (1 + n_supers + 1)); /* self + ancestors + (0) for ->supers[] */

  node = g_malloc0 (node_size);

  if (!pnode)					      /* offset fundamental types */

    {

      node = G_STRUCT_MEMBER_P (node, SIZEOF_FUNDAMENTAL_INFO);

      static_fundamental_type_nodes[ftype >> G_TYPE_FUNDAMENTAL_SHIFT] = node;

      type = ftype;

    }

  else

    type = (GType) node;

  g_assert ((type & TYPE_ID_MASK) == 0);

  node->n_supers = n_supers;

  if (!pnode)

    {

      node->supers[0] = type;

      node->supers[1] = 0;

      node->is_classed = (type_flags & G_TYPE_FLAG_CLASSED) != 0;

      node->is_instantiatable = (type_flags & G_TYPE_FLAG_INSTANTIATABLE) != 0;

      if (NODE_IS_IFACE (node))

	{

          IFACE_NODE_N_PREREQUISITES (node) = 0;

	  IFACE_NODE_PREREQUISITES (node) = NULL;

	}

      else

	{

	  CLASSED_NODE_N_IFACES (node) = 0;

	  CLASSED_NODE_IFACES_ENTRIES (node) = NULL;

	}

    }

  else

    {

      node->supers[0] = type;

      memcpy (node->supers + 1, pnode->supers, sizeof (GType) * (1 + pnode->n_supers + 1));

      node->is_classed = pnode->is_classed;

      node->is_instantiatable = pnode->is_instantiatable;

      if (NODE_IS_IFACE (node))

	{

	  IFACE_NODE_N_PREREQUISITES (node) = 0;

	  IFACE_NODE_PREREQUISITES (node) = NULL;

	}

      else

	{

	  guint j;

	  CLASSED_NODE_N_IFACES (node) = CLASSED_NODE_N_IFACES (pnode);

	  CLASSED_NODE_IFACES_ENTRIES (node) = g_memdup (CLASSED_NODE_IFACES_ENTRIES (pnode),

							 sizeof (CLASSED_NODE_IFACES_ENTRIES (pnode)[0]) *

							 CLASSED_NODE_N_IFACES (node));

	  for (j = 0; j < CLASSED_NODE_N_IFACES (node); j++)

	    {

	      CLASSED_NODE_IFACES_ENTRIES (node)[j].vtable = NULL;

	      CLASSED_NODE_IFACES_ENTRIES (node)[j].init_state = UNINITIALIZED;

	    }

	}

      i = pnode->n_children++;

      pnode->children = g_renew (GType, pnode->children, pnode->n_children);

      pnode->children[i] = type;

    }

  node->plugin = plugin;

  node->n_children = 0;

  node->children = NULL;

  node->data = NULL;

  node->qname = g_quark_from_string (name);

  node->global_gdata = NULL;

  g_hash_table_insert (static_type_nodes_ht,

		       GUINT_TO_POINTER (node->qname),

		       (gpointer) type);

  return node;

}

static inline GTypeFundamentalInfo*

type_node_fundamental_info_I (TypeNode *node)

{

  GType ftype = NODE_FUNDAMENTAL_TYPE (node);

  if (ftype != NODE_TYPE (node))

    node = lookup_type_node_I (ftype);

  return node ? G_STRUCT_MEMBER_P (node, -SIZEOF_FUNDAMENTAL_INFO) : NULL;

}

static TypeNode*

type_node_fundamental_new_W (GType                 ftype,

			     const gchar          *name,

			     GTypeFundamentalFlags type_flags)

{

  GTypeFundamentalInfo *finfo;

  TypeNode *node;

  g_assert ((ftype & TYPE_ID_MASK) == 0);

  g_assert (ftype <= G_TYPE_FUNDAMENTAL_MAX);