?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Put the g_return_val_if_fail() in the right place.
[glib.git] / gobject / gtype.c
blob26d6765a74588ce3d0c07d50e21d1ec27b235587
1 /* GObject - GLib Type, Object, Parameter and Signal Library
2 * Copyright (C) 1998-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 #include <config.h>
20 #include "gtype.h"
21
22 /*
23 * MT safe
24 */
25
26 #include "gtypeplugin.h"
27 #include "gvaluecollector.h"
28 #include <string.h>
29
30
31 /* NOTE: some functions (some internal variants and exported ones)
32 * invalidate data portions of the TypeNodes. if external functions/callbacks
33 * are called, pointers to memory maintained by TypeNodes have to be looked up
34 * again. this affects most of the struct TypeNode fields, e.g. ->children or
35 * CLASSED_NODE_IFACES_ENTRIES() respectively IFACE_NODE_PREREQUISITES() (but
36 * not ->supers[]), as all those memory portions can get realloc()ed during
37 * callback invocation.
38 *
39 * TODO:
40 * - g_type_from_name() should do an ordered array lookup after fetching the
41 * the quark, instead of a second hashtable lookup.
42 *
43 * LOCKING:
44 * lock handling issues when calling static functions are indicated by
45 * uppercase letter postfixes, all static functions have to have
46 * one of the below postfixes:
47 * - _I: [Indifferent about locking]
48 * function doesn't care about locks at all
49 * - _U: [Unlocked invocation]
50 * no read or write lock has to be held across function invocation
51 * (locks may be acquired and released during invocation though)
52 * - _L: [Locked invocation]
53 * a write lock or more than 0 read locks have to be held across
54 * function invocation
55 * - _W: [Write-locked invocation]
56 * a write lock has to be held across function invokation
57 * - _Wm: [Write-locked invocation, mutatable]
58 * like _W, but the write lock might be released and reacquired
59 * during invocation, watch your pointers
60 */
61
62 static GStaticRWLock type_rw_lock = G_STATIC_RW_LOCK_INIT;
63 #ifdef LOCK_DEBUG
64 #define G_READ_LOCK(rw_lock) do { g_printerr (G_STRLOC ": readL++\n"); g_static_rw_lock_reader_lock (rw_lock); } while (0)
65 #define G_READ_UNLOCK(rw_lock) do { g_printerr (G_STRLOC ": readL--\n"); g_static_rw_lock_reader_unlock (rw_lock); } while (0)
66 #define G_WRITE_LOCK(rw_lock) do { g_printerr (G_STRLOC ": writeL++\n"); g_static_rw_lock_writer_lock (rw_lock); } while (0)
67 #define G_WRITE_UNLOCK(rw_lock) do { g_printerr (G_STRLOC ": writeL--\n"); g_static_rw_lock_writer_unlock (rw_lock); } while (0)
68 #else
69 #define G_READ_LOCK(rw_lock) g_static_rw_lock_reader_lock (rw_lock)
70 #define G_READ_UNLOCK(rw_lock) g_static_rw_lock_reader_unlock (rw_lock)
71 #define G_WRITE_LOCK(rw_lock) g_static_rw_lock_writer_lock (rw_lock)
72 #define G_WRITE_UNLOCK(rw_lock) g_static_rw_lock_writer_unlock (rw_lock)
73 #endif
74 #define INVALID_RECURSION(func, arg, type_name) G_STMT_START{ \
75 static const gchar *_action = " invalidly modified type "; \
76 gpointer _arg = (gpointer) (arg); const gchar *_tname = (type_name), *_fname = (func); \
77 if (_arg) \
78 g_error ("%s(%p)%s`%s'", _fname, _arg, _action, _tname); \
79 else \
80 g_error ("%s()%s`%s'", _fname, _action, _tname); \
81 }G_STMT_END
82 #define g_return_val_if_uninitialized(condition, init_function, return_value) G_STMT_START{ \
83 if (!(condition)) \
84 { \
85 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, \
86 "%s: initialization assertion failed, use %s() prior to this function", \
87 G_STRLOC, G_STRINGIFY (init_function)); \
88 return (return_value); \
89 } \
90 }G_STMT_END
91
92 #ifdef G_ENABLE_DEBUG
93 #define DEBUG_CODE(debug_type, code_block) G_STMT_START { \
94 if (_g_type_debug_flags & G_TYPE_DEBUG_ ## debug_type) \
95 { code_block; } \
96 } G_STMT_END
97 #else /* !G_ENABLE_DEBUG */
98 #define DEBUG_CODE(debug_type, code_block) /* code_block */
99 #endif /* G_ENABLE_DEBUG */
100
101 #define TYPE_FUNDAMENTAL_FLAG_MASK (G_TYPE_FLAG_CLASSED | \
102 G_TYPE_FLAG_INSTANTIATABLE | \
103 G_TYPE_FLAG_DERIVABLE | \
104 G_TYPE_FLAG_DEEP_DERIVABLE)
105 #define TYPE_FLAG_MASK (G_TYPE_FLAG_ABSTRACT | G_TYPE_FLAG_VALUE_ABSTRACT)
106 #define SIZEOF_FUNDAMENTAL_INFO ((gssize) MAX (MAX (sizeof (GTypeFundamentalInfo), \
107 sizeof (gpointer)), \
108 sizeof (glong)))
109
110
111 /* --- typedefs --- */
112 typedef struct _TypeNode TypeNode;
113 typedef struct _CommonData CommonData;
114 typedef struct _IFaceData IFaceData;
115 typedef struct _ClassData ClassData;
116 typedef struct _InstanceData InstanceData;
117 typedef union _TypeData TypeData;
118 typedef struct _IFaceEntry IFaceEntry;
119 typedef struct _IFaceHolder IFaceHolder;
120
121
122 /* --- prototypes --- */
123 static inline GTypeFundamentalInfo* type_node_fundamental_info_I (TypeNode *node);
124 static void type_add_flags_W (TypeNode *node,
125 GTypeFlags flags);
126 static void type_data_make_W (TypeNode *node,
127 const GTypeInfo *info,
128 const GTypeValueTable *value_table);
129 static inline void type_data_ref_Wm (TypeNode *node);
130 static inline void type_data_unref_Wm (TypeNode *node,
131 gboolean uncached);
132 static void type_data_last_unref_Wm (GType type,
133 gboolean uncached);
134 static inline gpointer type_get_qdata_L (TypeNode *node,
135 GQuark quark);
136 static inline void type_set_qdata_W (TypeNode *node,
137 GQuark quark,
138 gpointer data);
139 static IFaceHolder* type_iface_peek_holder_L (TypeNode *iface,
140 GType instance_type);
141 static gboolean type_node_is_a_L (TypeNode *node,
142 TypeNode *iface_node);
143
144
145 /* --- structures --- */
146 struct _TypeNode
147 {
148 GTypePlugin *plugin;
149 guint n_children : 12;
150 guint n_supers : 8;
151 guint _prot_n_ifaces_prerequisites : 9;
152 guint is_classed : 1;
153 guint is_instantiatable : 1;
154 guint mutatable_check_cache : 1; /* combines some common path checks */
155 GType *children;
156 TypeData * volatile data;
157 GQuark qname;
158 GData *global_gdata;
159 union {
160 IFaceEntry *iface_entries; /* for !iface types */
161 GType *prerequisistes;
162 } _prot;
163 GType supers[1]; /* flexible array */
164 };
165 #define SIZEOF_BASE_TYPE_NODE() (G_STRUCT_OFFSET (TypeNode, supers))
166 #define MAX_N_SUPERS (255)
167 #define MAX_N_CHILDREN (4095)
168 #define MAX_N_IFACES (511)
169 #define MAX_N_PREREQUISITES (MAX_N_IFACES)
170 #define NODE_TYPE(node) (node->supers[0])
171 #define NODE_PARENT_TYPE(node) (node->supers[1])
172 #define NODE_FUNDAMENTAL_TYPE(node) (node->supers[node->n_supers])
173 #define NODE_NAME(node) (g_quark_to_string (node->qname))
174 #define NODE_IS_IFACE(node) (NODE_FUNDAMENTAL_TYPE (node) == G_TYPE_INTERFACE)
175 #define CLASSED_NODE_N_IFACES(node) ((node)->_prot_n_ifaces_prerequisites)
176 #define CLASSED_NODE_IFACES_ENTRIES(node) ((node)->_prot.iface_entries)
177 #define IFACE_NODE_N_PREREQUISITES(node) ((node)->_prot_n_ifaces_prerequisites)
178 #define IFACE_NODE_PREREQUISITES(node) ((node)->_prot.prerequisistes)
179 #define iface_node_get_holders_L(node) ((IFaceHolder*) type_get_qdata_L ((node), static_quark_iface_holder))
180 #define iface_node_set_holders_W(node, holders) (type_set_qdata_W ((node), static_quark_iface_holder, (holders)))
181 #define iface_node_get_dependants_array_L(n) ((GType*) type_get_qdata_L ((n), static_quark_dependants_array))
182 #define iface_node_set_dependants_array_W(n,d) (type_set_qdata_W ((n), static_quark_dependants_array, (d)))
183 #define TYPE_ID_MASK ((GType) ((1 << G_TYPE_FUNDAMENTAL_SHIFT) - 1))
184
185
186 struct _IFaceHolder
187 {
188 GType instance_type;
189 GInterfaceInfo *info;
190 GTypePlugin *plugin;
191 IFaceHolder *next;
192 };
193 struct _IFaceEntry
194 {
195 GType iface_type;
196 GTypeInterface *vtable;
197 };
198 struct _CommonData
199 {
200 guint ref_count;
201 GTypeValueTable *value_table;
202 };
203 struct _IFaceData
204 {
205 CommonData common;
206 guint16 vtable_size;
207 GBaseInitFunc vtable_init_base;
208 GBaseFinalizeFunc vtable_finalize_base;
209 };
210 struct _ClassData
211 {
212 CommonData common;
213 guint16 class_size;
214 GBaseInitFunc class_init_base;
215 GBaseFinalizeFunc class_finalize_base;
216 GClassInitFunc class_init;
217 GClassFinalizeFunc class_finalize;
218 gconstpointer class_data;
219 gpointer class;
220 };
221 struct _InstanceData
222 {
223 CommonData common;
224 guint16 class_size;
225 GBaseInitFunc class_init_base;
226 GBaseFinalizeFunc class_finalize_base;
227 GClassInitFunc class_init;
228 GClassFinalizeFunc class_finalize;
229 gconstpointer class_data;
230 gpointer class;
231 guint16 instance_size;
232 guint16 n_preallocs;
233 GInstanceInitFunc instance_init;
234 GMemChunk *mem_chunk;
235 };
236 union _TypeData
237 {
238 CommonData common;
239 IFaceData iface;
240 ClassData class;
241 InstanceData instance;
242 };
243 typedef struct {
244 gpointer cache_data;
245 GTypeClassCacheFunc cache_func;
246 } ClassCacheFunc;
247
248
249 /* --- variables --- */
250 static guint static_n_class_cache_funcs = 0;
251 static ClassCacheFunc *static_class_cache_funcs = NULL;
252 static GQuark static_quark_type_flags = 0;
253 static GQuark static_quark_iface_holder = 0;
254 static GQuark static_quark_dependants_array = 0;
255 GTypeDebugFlags _g_type_debug_flags = 0;
256
257
258 /* --- type nodes --- */
259 static GHashTable *static_type_nodes_ht = NULL;
260 static TypeNode *static_fundamental_type_nodes[(G_TYPE_FUNDAMENTAL_MAX >> G_TYPE_FUNDAMENTAL_SHIFT) + 1] = { 0, };
261 static GType static_fundamental_next = G_TYPE_RESERVED_USER_FIRST;
262
263 static inline TypeNode*
264 lookup_type_node_I (register GType utype)
265 {
266 if (utype > G_TYPE_FUNDAMENTAL_MAX)
267 return (TypeNode*) (utype & ~TYPE_ID_MASK);
268 else
269 return static_fundamental_type_nodes[utype >> G_TYPE_FUNDAMENTAL_SHIFT];
270 }
271
272 static TypeNode*
273 type_node_any_new_W (TypeNode *pnode,
274 GType ftype,
275 const gchar *name,
276 GTypePlugin *plugin,
277 GTypeFundamentalFlags type_flags)
278 {
279 guint n_supers;
280 GType type;
281 TypeNode *node;
282 guint i, node_size = 0;
283
284 n_supers = pnode ? pnode->n_supers + 1 : 0;
285
286 if (!pnode)
287 node_size += SIZEOF_FUNDAMENTAL_INFO; /* fundamental type info */
288 node_size += SIZEOF_BASE_TYPE_NODE (); /* TypeNode structure */
289 node_size += (sizeof (GType) * (1 + n_supers + 1)); /* self + ancestors + (0) for ->supers[] */
290 node = g_malloc0 (node_size);
291 if (!pnode) /* offset fundamental types */
292 {
293 node = G_STRUCT_MEMBER_P (node, SIZEOF_FUNDAMENTAL_INFO);
294 static_fundamental_type_nodes[ftype >> G_TYPE_FUNDAMENTAL_SHIFT] = node;
295 type = ftype;
296 }
297 else
298 type = (GType) node;
299
300 g_assert ((type & TYPE_ID_MASK) == 0);
301
302 node->n_supers = n_supers;
303 if (!pnode)
304 {
305 node->supers[0] = type;
306 node->supers[1] = 0;
307
308 node->is_classed = (type_flags & G_TYPE_FLAG_CLASSED) != 0;
309 node->is_instantiatable = (type_flags & G_TYPE_FLAG_INSTANTIATABLE) != 0;
310
311 if (NODE_IS_IFACE (node))
312 {
313 IFACE_NODE_N_PREREQUISITES (node) = 0;
314 IFACE_NODE_PREREQUISITES (node) = NULL;
315 }
316 else
317 {
318 CLASSED_NODE_N_IFACES (node) = 0;
319 CLASSED_NODE_IFACES_ENTRIES (node) = NULL;
320 }
321 }
322 else
323 {
324 node->supers[0] = type;
325 memcpy (node->supers + 1, pnode->supers, sizeof (GType) * (1 + pnode->n_supers + 1));
326
327 node->is_classed = pnode->is_classed;
328 node->is_instantiatable = pnode->is_instantiatable;
329
330 if (NODE_IS_IFACE (node))
331 {
332 IFACE_NODE_N_PREREQUISITES (node) = 0;
333 IFACE_NODE_PREREQUISITES (node) = NULL;
334 }
335 else
336 {
337 guint j;
338
339 CLASSED_NODE_N_IFACES (node) = CLASSED_NODE_N_IFACES (pnode);
340 CLASSED_NODE_IFACES_ENTRIES (node) = g_memdup (CLASSED_NODE_IFACES_ENTRIES (pnode),
341 sizeof (CLASSED_NODE_IFACES_ENTRIES (pnode)[0]) *
342 CLASSED_NODE_N_IFACES (node));
343 for (j = 0; j < CLASSED_NODE_N_IFACES (node); j++)
344 CLASSED_NODE_IFACES_ENTRIES (node)[j].vtable = NULL;
345 }
346
347 i = pnode->n_children++;
348 pnode->children = g_renew (GType, pnode->children, pnode->n_children);
349 pnode->children[i] = type;
350 }
351
352 node->plugin = plugin;
353 node->n_children = 0;
354 node->children = NULL;
355 node->data = NULL;
356 node->qname = g_quark_from_string (name);
357 node->global_gdata = NULL;
358
359 g_hash_table_insert (static_type_nodes_ht,
360 GUINT_TO_POINTER (node->qname),
361 (gpointer) type);
362 return node;
363 }
364
365 static inline GTypeFundamentalInfo*
366 type_node_fundamental_info_I (TypeNode *node)
367 {
368 GType ftype = NODE_FUNDAMENTAL_TYPE (node);
369
370 if (ftype != NODE_TYPE (node))
371 node = lookup_type_node_I (ftype);
372
373 return node ? G_STRUCT_MEMBER_P (node, -SIZEOF_FUNDAMENTAL_INFO) : NULL;
374 }
375
376 static TypeNode*
377 type_node_fundamental_new_W (GType ftype,
378 const gchar *name,
379 GTypeFundamentalFlags type_flags)
380 {
381 GTypeFundamentalInfo *finfo;
382 TypeNode *node;
383
384 g_assert ((ftype & TYPE_ID_MASK) == 0);
385 g_assert (ftype <= G_TYPE_FUNDAMENTAL_MAX);
386
387 if (ftype >> G_TYPE_FUNDAMENTAL_SHIFT == static_fundamental_next)
388 static_fundamental_next++;
389
390 type_flags &= TYPE_FUNDAMENTAL_FLAG_MASK;
391
392 node = type_node_any_new_W (NULL, ftype, name, NULL, type_flags);
393
394 finfo = type_node_fundamental_info_I (node);
395 finfo->type_flags = type_flags;
396
397 return node;
398 }
399
400 static TypeNode*
401 type_node_new_W (TypeNode *pnode,
402 const gchar *name,
403 GTypePlugin *plugin)
404
405 {
406 g_assert (pnode);
407 g_assert (pnode->n_supers < MAX_N_SUPERS);
408 g_assert (pnode->n_children < MAX_N_CHILDREN);
409
410 return type_node_any_new_W (pnode, NODE_FUNDAMENTAL_TYPE (pnode), name, plugin, 0);
411 }
412
413 static inline IFaceEntry*
414 type_lookup_iface_entry_L (TypeNode *node,
415 TypeNode *iface_node)
416 {
417 if (NODE_IS_IFACE (iface_node) && CLASSED_NODE_N_IFACES (node))
418 {
419 IFaceEntry *ifaces = CLASSED_NODE_IFACES_ENTRIES (node) - 1;
420 guint n_ifaces = CLASSED_NODE_N_IFACES (node);
421 GType iface_type = NODE_TYPE (iface_node);
422
423 do
424 {
425 guint i;
426 IFaceEntry *check;
427
428 i = (n_ifaces + 1) >> 1;
429 check = ifaces + i;
430 if (iface_type == check->iface_type)
431 return check;
432 else if (iface_type > check->iface_type)
433 {
434 n_ifaces -= i;
435 ifaces = check;
436 }
437 else /* if (iface_type < check->iface_type) */
438 n_ifaces = i - 1;
439 }
440 while (n_ifaces);
441 }
442
443 return NULL;
444 }
445
446 static inline gboolean
447 type_lookup_prerequisite_L (TypeNode *iface,
448 GType prerequisite_type)
449 {
450 if (NODE_IS_IFACE (iface) && IFACE_NODE_N_PREREQUISITES (iface))
451 {
452 GType *prerequisites = IFACE_NODE_PREREQUISITES (iface) - 1;
453 guint n_prerequisites = IFACE_NODE_N_PREREQUISITES (iface);
454
455 do
456 {
457 guint i;
458 GType *check;
459
460 i = (n_prerequisites + 1) >> 1;
461 check = prerequisites + i;
462 if (prerequisite_type == *check)
463 return TRUE;
464 else if (prerequisite_type > *check)
465 {
466 n_prerequisites -= i;
467 prerequisites = check;
468 }
469 else /* if (prerequisite_type < *check) */
470 n_prerequisites = i - 1;
471 }
472 while (n_prerequisites);
473 }
474 return FALSE;
475 }
476
477 static gchar*
478 type_descriptive_name_I (GType type)
479 {
480 if (type)
481 {
482 TypeNode *node = lookup_type_node_I (type);
483
484 return node ? NODE_NAME (node) : "<unknown>";
485 }
486 else
487 return "<invalid>";
488 }
489
490
491 /* --- type consistency checks --- */
492 static gboolean
493 check_plugin_U (GTypePlugin *plugin,
494 gboolean need_complete_type_info,
495 gboolean need_complete_interface_info,
496 const gchar *type_name)
497 {
498 /* G_IS_TYPE_PLUGIN() and G_TYPE_PLUGIN_GET_CLASS() are external calls: _U
499 */
500 if (!plugin)
501 {
502 g_warning ("plugin handle for type `%s' is NULL",
503 type_name);
504 return FALSE;
505 }
506 if (!G_IS_TYPE_PLUGIN (plugin))
507 {
508 g_warning ("plugin pointer (%p) for type `%s' is invalid",
509 plugin, type_name);
510 return FALSE;
511 }
512 if (need_complete_type_info && !G_TYPE_PLUGIN_GET_CLASS (plugin)->complete_type_info)
513 {
514 g_warning ("plugin for type `%s' has no complete_type_info() implementation",
515 type_name);
516 return FALSE;
517 }
518 if (need_complete_interface_info && !G_TYPE_PLUGIN_GET_CLASS (plugin)->complete_interface_info)
519 {
520 g_warning ("plugin for type `%s' has no complete_interface_info() implementation",
521 type_name);
522 return FALSE;
523 }
524 return TRUE;
525 }
526
527 static gboolean
528 check_type_name_I (const gchar *type_name)
529 {
530 static const gchar *extra_chars = "-_+";
531 const gchar *p = type_name;
532 gboolean name_valid;
533
534 if (!type_name[0] || !type_name[1] || !type_name[2])
535 {
536 g_warning ("type name `%s' is too short", type_name);
537 return FALSE;
538 }
539 /* check the first letter */
540 name_valid = (p[0] >= 'A' && p[0] <= 'Z') || (p[0] >= 'a' && p[0] <= 'z') || p[0] == '_';
541 for (p = type_name + 1; *p; p++)
542 name_valid &= ((p[0] >= 'A' && p[0] <= 'Z') ||
543 (p[0] >= 'a' && p[0] <= 'z') ||
544 (p[0] >= '0' && p[0] <= '9') ||
545 strchr (extra_chars, p[0]));
546 if (!name_valid)
547 {
548 g_warning ("type name `%s' contains invalid characters", type_name);
549 return FALSE;
550 }
551 if (g_type_from_name (type_name))
552 {
553 g_warning ("cannot register existing type `%s'", type_name);
554 return FALSE;
555 }
556
557 return TRUE;
558 }
559
560 static gboolean
561 check_derivation_I (GType parent_type,
562 const gchar *type_name)
563 {
564 TypeNode *pnode;
565 GTypeFundamentalInfo* finfo;
566
567 pnode = lookup_type_node_I (parent_type);
568 if (!pnode)
569 {
570 g_warning ("cannot derive type `%s' from invalid parent type `%s'",
571 type_name,
572 type_descriptive_name_I (parent_type));
573 return FALSE;
574 }
575 finfo = type_node_fundamental_info_I (pnode);
576 /* ensure flat derivability */
577 if (!(finfo->type_flags & G_TYPE_FLAG_DERIVABLE))
578 {
579 g_warning ("cannot derive `%s' from non-derivable parent type `%s'",
580 type_name,
581 NODE_NAME (pnode));
582 return FALSE;
583 }
584 /* ensure deep derivability */
585 if (parent_type != NODE_FUNDAMENTAL_TYPE (pnode) &&
586 !(finfo->type_flags & G_TYPE_FLAG_DEEP_DERIVABLE))
587 {
588 g_warning ("cannot derive `%s' from non-fundamental parent type `%s'",
589 type_name,
590 NODE_NAME (pnode));
591 return FALSE;
592 }
593
594 return TRUE;
595 }
596
597 static gboolean
598 check_collect_format_I (const gchar *collect_format)
599 {
600 const gchar *p = collect_format;
601 gchar valid_format[] = { G_VALUE_COLLECT_INT, G_VALUE_COLLECT_LONG,
602 G_VALUE_COLLECT_INT64, G_VALUE_COLLECT_DOUBLE,
603 G_VALUE_COLLECT_POINTER, 0 };
604
605 while (*p)
606 if (!strchr (valid_format, *p++))
607 return FALSE;
608 return p - collect_format <= G_VALUE_COLLECT_FORMAT_MAX_LENGTH;
609 }
610
611 static gboolean
612 check_value_table_I (const gchar *type_name,
613 const GTypeValueTable *value_table)
614 {
615 if (!value_table)
616 return FALSE;
617 else if (value_table->value_init == NULL)
618 {
619 if (value_table->value_free || value_table->value_copy ||
620 value_table->value_peek_pointer ||
621 value_table->collect_format || value_table->collect_value ||
622 value_table->lcopy_format || value_table->lcopy_value)
623 g_warning ("cannot handle uninitializable values of type `%s'",
624 type_name);
625 return FALSE;
626 }
627 else /* value_table->value_init != NULL */
628 {
629 if (!value_table->value_free)
630 {
631 /* +++ optional +++
632 * g_warning ("missing `value_free()' for type `%s'", type_name);
633 * return FALSE;
634 */
635 }
636 if (!value_table->value_copy)
637 {
638 g_warning ("missing `value_copy()' for type `%s'", type_name);
639 return FALSE;
640 }
641 if ((value_table->collect_format || value_table->collect_value) &&
642 (!value_table->collect_format || !value_table->collect_value))
643 {
644 g_warning ("one of `collect_format' and `collect_value()' is unspecified for type `%s'",
645 type_name);
646 return FALSE;
647 }
648 if (value_table->collect_format && !check_collect_format_I (value_table->collect_format))
649 {
650 g_warning ("the `%s' specification for type `%s' is too long or invalid",
651 "collect_format",
652 type_name);
653 return FALSE;
654 }
655 if ((value_table->lcopy_format || value_table->lcopy_value) &&
656 (!value_table->lcopy_format || !value_table->lcopy_value))
657 {
658 g_warning ("one of `lcopy_format' and `lcopy_value()' is unspecified for type `%s'",
659 type_name);
660 return FALSE;
661 }
662 if (value_table->lcopy_format && !check_collect_format_I (value_table->lcopy_format))
663 {
664 g_warning ("the `%s' specification for type `%s' is too long or invalid",
665 "lcopy_format",
666 type_name);
667 return FALSE;
668 }
669 }
670 return TRUE;
671 }
672
673 static gboolean
674 check_type_info_I (TypeNode *pnode,
675 GType ftype,
676 const gchar *type_name,
677 const GTypeInfo *info)
678 {
679 GTypeFundamentalInfo *finfo = type_node_fundamental_info_I (lookup_type_node_I (ftype));
680 gboolean is_interface = ftype == G_TYPE_INTERFACE;
681
682 g_assert (ftype <= G_TYPE_FUNDAMENTAL_MAX && !(ftype & TYPE_ID_MASK));
683
684 /* check instance members */
685 if (!(finfo->type_flags & G_TYPE_FLAG_INSTANTIATABLE) &&
686 (info->instance_size || info->n_preallocs || info->instance_init))
687 {
688 if (pnode)
689 g_warning ("cannot instantiate `%s', derived from non-instantiatable parent type `%s'",
690 type_name,
691 NODE_NAME (pnode));
692 else
693 g_warning ("cannot instantiate `%s' as non-instantiatable fundamental",
694 type_name);
695 return FALSE;
696 }
697 /* check class & interface members */
698 if (!(finfo->type_flags & G_TYPE_FLAG_CLASSED) &&
699 (info->class_init || info->class_finalize || info->class_data ||
700 (!is_interface && (info->class_size || info->base_init || info->base_finalize))))
701 {
702 if (pnode)
703 g_warning ("cannot create class for `%s', derived from non-classed parent type `%s'",
704 type_name,
705 NODE_NAME (pnode));
706 else
707 g_warning ("cannot create class for `%s' as non-classed fundamental",
708 type_name);
709 return FALSE;
710 }
711 /* check interface size */
712 if (is_interface && info->class_size < sizeof (GTypeInterface))
713 {
714 g_warning ("specified interface size for type `%s' is smaller than `GTypeInterface' size",
715 type_name);
716 return FALSE;
717 }
718 /* check class size */
719 if (finfo->type_flags & G_TYPE_FLAG_CLASSED)
720 {
721 if (info->class_size < sizeof (GTypeClass))
722 {
723 g_warning ("specified class size for type `%s' is smaller than `GTypeClass' size",
724 type_name);
725 return FALSE;
726 }
727 if (pnode && info->class_size < pnode->data->class.class_size)
728 {
729 g_warning ("specified class size for type `%s' is smaller "
730 "than the parent type's `%s' class size",
731 type_name,
732 NODE_NAME (pnode));
733 return FALSE;
734 }
735 }
736 /* check instance size */
737 if (finfo->type_flags & G_TYPE_FLAG_INSTANTIATABLE)
738 {
739 if (info->instance_size < sizeof (GTypeInstance))
740 {
741 g_warning ("specified instance size for type `%s' is smaller than `GTypeInstance' size",
742 type_name);
743 return FALSE;
744 }
745 if (pnode && info->instance_size < pnode->data->instance.instance_size)
746 {
747 g_warning ("specified instance size for type `%s' is smaller "
748 "than the parent type's `%s' instance size",
749 type_name,
750 NODE_NAME (pnode));
751 return FALSE;
752 }
753 }
754
755 return TRUE;
756 }
757
758 static TypeNode*
759 find_conforming_child_type_L (TypeNode *pnode,
760 TypeNode *iface)
761 {
762 TypeNode *node = NULL;
763 guint i;
764
765 if (type_lookup_iface_entry_L (pnode, iface))
766 return pnode;
767
768 for (i = 0; i < pnode->n_children && !node; i++)
769 node = find_conforming_child_type_L (lookup_type_node_I (pnode->children[i]), iface);
770
771 return node;
772 }
773
774 static gboolean
775 check_add_interface_L (GType instance_type,
776 GType iface_type)
777 {
778 TypeNode *node = lookup_type_node_I (instance_type);
779 TypeNode *iface = lookup_type_node_I (iface_type);
780 IFaceEntry *entry;
781 TypeNode *tnode;
782 GType *prerequisites;
783 guint i;
784
785
786 if (!node || !node->is_instantiatable)
787 {
788 g_warning ("cannot add interfaces to invalid (non-instantiatable) type `%s'",
789 type_descriptive_name_I (instance_type));
790 return FALSE;
791 }
792 if (!iface || !NODE_IS_IFACE (iface))
793 {
794 g_warning ("cannot add invalid (non-interface) type `%s' to type `%s'",
795 type_descriptive_name_I (iface_type),
796 NODE_NAME (node));
797 return FALSE;
798 }
799 tnode = lookup_type_node_I (NODE_PARENT_TYPE (iface));
800 if (NODE_PARENT_TYPE (tnode) && !type_lookup_iface_entry_L (node, tnode))
801 {
802 /* 2001/7/31:timj: erk, i guess this warning is junk as interface derivation is flat */
803 g_warning ("cannot add sub-interface `%s' to type `%s' which does not conform to super-interface `%s'",
804 NODE_NAME (iface),
805 NODE_NAME (node),
806 NODE_NAME (tnode));
807 return FALSE;
808 }
809 /* allow overriding of interface type introduced for parent type */
810 entry = type_lookup_iface_entry_L (node, iface);
811 if (entry && entry->vtable == NULL && !type_iface_peek_holder_L (iface, NODE_TYPE (node)))
812 {
813 /* ok, we do conform to this interface already, but the interface vtable was not
814 * yet intialized, and we just conform to the interface because it got added to
815 * one of our parents. so we allow overriding of holder info here.
816 */
817 return TRUE;
818 }
819 /* check whether one of our children already conforms (or whether the interface
820 * got added to this node already)
821 */
822 tnode = find_conforming_child_type_L (node, iface); /* tnode is_a node */
823 if (tnode)
824 {
825 g_warning ("cannot add interface type `%s' to type `%s', since type `%s' already conforms to interface",
826 NODE_NAME (iface),
827 NODE_NAME (node),
828 NODE_NAME (tnode));
829 return FALSE;
830 }
831 prerequisites = IFACE_NODE_PREREQUISITES (iface);
832 for (i = 0; i < IFACE_NODE_N_PREREQUISITES (iface); i++)
833 {
834 tnode = lookup_type_node_I (prerequisites[i]);
835 if (!type_node_is_a_L (node, tnode))
836 {
837 g_warning ("cannot add interface type `%s' to type `%s' which does not conform to prerequisite `%s'",
838 NODE_NAME (iface),
839 NODE_NAME (node),
840 NODE_NAME (tnode));
841 return FALSE;
842 }
843 }
844 return TRUE;
845 }
846
847 static gboolean
848 check_interface_info_I (TypeNode *iface,
849 GType instance_type,
850 const GInterfaceInfo *info)
851 {
852 if ((info->interface_finalize || info->interface_data) && !info->interface_init)
853 {
854 g_warning ("interface type `%s' for type `%s' comes without initializer",
855 NODE_NAME (iface),
856 type_descriptive_name_I (instance_type));
857 return FALSE;
858 }
859
860 return TRUE;
861 }
862
863 /* --- type info (type node data) --- */
864 static void
865 type_data_make_W (TypeNode *node,
866 const GTypeInfo *info,
867 const GTypeValueTable *value_table)
868 {
869 TypeData *data;
870 GTypeValueTable *vtable = NULL;
871 guint vtable_size = 0;
872
873 g_assert (node->data == NULL && info != NULL);
874
875 if (!value_table)
876 {
877 TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node));
878
879 if (pnode)
880 vtable = pnode->data->common.value_table;
881 else
882 {
883 static const GTypeValueTable zero_vtable = { NULL, };
884
885 value_table = &zero_vtable;
886 }
887 }
888 if (value_table)
889 {
890 /* need to setup vtable_size since we have to allocate it with data in one chunk */
891 vtable_size = sizeof (GTypeValueTable);
892 if (value_table->collect_format)
893 vtable_size += strlen (value_table->collect_format);
894 if (value_table->lcopy_format)
895 vtable_size += strlen (value_table->lcopy_format);
896 vtable_size += 2;
897 }
898
899 if (node->is_instantiatable) /* carefull, is_instantiatable is also is_classed */
900 {
901 data = g_malloc0 (sizeof (InstanceData) + vtable_size);
902 if (vtable_size)
903 vtable = G_STRUCT_MEMBER_P (data, sizeof (InstanceData));
904 data->instance.class_size = info->class_size;
905 data->instance.class_init_base = info->base_init;
906 data->instance.class_finalize_base = info->base_finalize;
907 data->instance.class_init = info->class_init;
908 data->instance.class_finalize = info->class_finalize;
909 data->instance.class_data = info->class_data;
910 data->instance.class = NULL;
911 data->instance.instance_size = info->instance_size;
912 #ifdef DISABLE_MEM_POOLS
913 data->instance.n_preallocs = 0;
914 #else /* !DISABLE_MEM_POOLS */
915 data->instance.n_preallocs = MIN (info->n_preallocs, 1024);
916 #endif /* !DISABLE_MEM_POOLS */
917 data->instance.instance_init = info->instance_init;
918 data->instance.mem_chunk = NULL;
919 }
920 else if (node->is_classed) /* only classed */
921 {
922 data = g_malloc0 (sizeof (ClassData) + vtable_size);
923 if (vtable_size)
924 vtable = G_STRUCT_MEMBER_P (data, sizeof (ClassData));
925 data->class.class_size = info->class_size;
926 data->class.class_init_base = info->base_init;
927 data->class.class_finalize_base = info->base_finalize;
928 data->class.class_init = info->class_init;
929 data->class.class_finalize = info->class_finalize;
930 data->class.class_data = info->class_data;
931 data->class.class = NULL;
932 }
933 else if (NODE_IS_IFACE (node))
934 {
935 data = g_malloc0 (sizeof (IFaceData) + vtable_size);
936 if (vtable_size)
937 vtable = G_STRUCT_MEMBER_P (data, sizeof (IFaceData));
938 data->iface.vtable_size = info->class_size;
939 data->iface.vtable_init_base = info->base_init;
940 data->iface.vtable_finalize_base = info->base_finalize;
941 }
942 else
943 {
944 data = g_malloc0 (sizeof (CommonData) + vtable_size);
945 if (vtable_size)
946 vtable = G_STRUCT_MEMBER_P (data, sizeof (CommonData));
947 }
948
949 node->data = data;
950 node->data->common.ref_count = 1;
951
952 if (vtable_size)
953 {
954 gchar *p;
955
956 /* we allocate the vtable and its strings together with the type data, so
957 * children can take over their parent's vtable pointer, and we don't
958 * need to worry freeing it or not when the child data is destroyed
959 */
960 *vtable = *value_table;
961 p = G_STRUCT_MEMBER_P (vtable, sizeof (*vtable));
962 p[0] = 0;
963 vtable->collect_format = p;
964 if (value_table->collect_format)
965 {
966 strcat (p, value_table->collect_format);
967 p += strlen (value_table->collect_format);
968 }
969 p++;
970 p[0] = 0;
971 vtable->lcopy_format = p;
972 if (value_table->lcopy_format)
973 strcat (p, value_table->lcopy_format);
974 }
975 node->data->common.value_table = vtable;
976 node->mutatable_check_cache = (node->data->common.value_table->value_init != NULL &&
977 !((G_TYPE_FLAG_VALUE_ABSTRACT | G_TYPE_FLAG_ABSTRACT) &
978 GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags))));
979
980 g_assert (node->data->common.value_table != NULL); /* paranoid */
981 }
982
983 static inline void
984 type_data_ref_Wm (TypeNode *node)
985 {
986 if (!node->data)
987 {
988 TypeNode *pnode = lookup_type_node_I (NODE_PARENT_TYPE (node));
989 GTypeInfo tmp_info;
990 GTypeValueTable tmp_value_table;
991
992 g_assert (node->plugin != NULL);
993
994 if (pnode)
995 {
996 type_data_ref_Wm (pnode);
997 if (node->data)
998 INVALID_RECURSION ("g_type_plugin_*", node->plugin, NODE_NAME (node));
999 }
1000
1001 memset (&tmp_info, 0, sizeof (tmp_info));
1002 memset (&tmp_value_table, 0, sizeof (tmp_value_table));
1003
1004 G_WRITE_UNLOCK (&type_rw_lock);
1005 g_type_plugin_use (node->plugin);
1006 g_type_plugin_complete_type_info (node->plugin, NODE_TYPE (node), &tmp_info, &tmp_value_table);
1007 G_WRITE_LOCK (&type_rw_lock);
1008 if (node->data)
1009 INVALID_RECURSION ("g_type_plugin_*", node->plugin, NODE_NAME (node));
1010
1011 check_type_info_I (pnode, NODE_FUNDAMENTAL_TYPE (node), NODE_NAME (node), &tmp_info);
1012 type_data_make_W (node, &tmp_info,
1013 check_value_table_I (NODE_NAME (node),
1014 &tmp_value_table) ? &tmp_value_table : NULL);
1015 }
1016 else
1017 {
1018 g_assert (node->data->common.ref_count > 0);
1019
1020 node->data->common.ref_count += 1;
1021 }
1022 }
1023
1024 static inline void
1025 type_data_unref_Wm (TypeNode *node,
1026 gboolean uncached)
1027 {
1028 g_assert (node->data && node->data->common.ref_count);
1029
1030 if (node->data->common.ref_count > 1)
1031 node->data->common.ref_count -= 1;
1032 else
1033 {
1034 if (!node->plugin)
1035 {
1036 g_warning ("static type `%s' unreferenced too often",
1037 NODE_NAME (node));
1038 return;
1039 }
1040
1041 type_data_last_unref_Wm (NODE_TYPE (node), uncached);
1042 }
1043 }
1044
1045 static void
1046 type_node_add_iface_entry_W (TypeNode *node,
1047 GType iface_type)
1048 {
1049 IFaceEntry *entries;
1050 guint i;
1051
1052 g_assert (node->is_instantiatable && CLASSED_NODE_N_IFACES (node) < MAX_N_IFACES);
1053
1054 entries = CLASSED_NODE_IFACES_ENTRIES (node);
1055 for (i = 0; i < CLASSED_NODE_N_IFACES (node); i++)
1056 if (entries[i].iface_type == iface_type)
1057 {
1058 /* this can (should) only happen if our parent type already conformed
1059 * to iface_type and node got it's own holder info. here, our
1060 * children should already have entries with NULL vtables, so
1061 * we're actually done.
1062 */
1063 g_assert (entries[i].vtable == NULL);
1064 return;
1065 }
1066 else if (entries[i].iface_type > iface_type)
1067 break;
1068 CLASSED_NODE_N_IFACES (node) += 1;
1069 CLASSED_NODE_IFACES_ENTRIES (node) = g_renew (IFaceEntry,
1070 CLASSED_NODE_IFACES_ENTRIES (node),
1071 CLASSED_NODE_N_IFACES (node));
1072 entries = CLASSED_NODE_IFACES_ENTRIES (node);
1073 g_memmove (entries + i + 1, entries + i, sizeof (entries[0]) * (CLASSED_NODE_N_IFACES (node) - i - 1));
1074 entries[i].iface_type = iface_type;
1075 entries[i].vtable = NULL;
1076
1077 for (i = 0; i < node->n_children; i++)
1078 type_node_add_iface_entry_W (lookup_type_node_I (node->children[i]), iface_type);
1079 }
1080
1081 static void
1082 type_add_interface_W (TypeNode *node,
1083 TypeNode *iface,
1084 const GInterfaceInfo *info,
1085 GTypePlugin *plugin)
1086 {
1087 IFaceHolder *iholder = g_new0 (IFaceHolder, 1);
1088
1089 /* we must not call any functions of GInterfaceInfo from within here, since
1090 * we got most probably called from _within_ a type registration function
1091 */
1092 g_assert (node->is_instantiatable && NODE_IS_IFACE (iface) && ((info && !plugin) || (!info && plugin)));
1093
1094 iholder->next = iface_node_get_holders_L (iface);
1095 iface_node_set_holders_W (iface, iholder);
1096 iholder->instance_type = NODE_TYPE (node);
1097 iholder->info = info ? g_memdup (info, sizeof (*info)) : NULL;
1098 iholder->plugin = plugin;
1099
1100 type_node_add_iface_entry_W (node, NODE_TYPE (iface));
1101 }
1102
1103 static void
1104 type_iface_add_prerequisite_W (TypeNode *iface,
1105 TypeNode *prerequisite_node)
1106 {
1107 GType prerequisite_type = NODE_TYPE (prerequisite_node);
1108 GType *prerequisites, *dependants;
1109 guint n_dependants, i;
1110
1111 g_assert (NODE_IS_IFACE (iface) &&
1112 IFACE_NODE_N_PREREQUISITES (iface) < MAX_N_PREREQUISITES &&
1113 (prerequisite_node->is_instantiatable || NODE_IS_IFACE (prerequisite_node)));
1114
1115 prerequisites = IFACE_NODE_PREREQUISITES (iface);
1116 for (i = 0; i < IFACE_NODE_N_PREREQUISITES (iface); i++)
1117 if (prerequisites[i] == prerequisite_type)
1118 return; /* we already have that prerequisiste */
1119 else if (prerequisites[i] > prerequisite_type)
1120 break;
1121 IFACE_NODE_N_PREREQUISITES (iface) += 1;
1122 IFACE_NODE_PREREQUISITES (iface) = g_renew (GType,
1123 IFACE_NODE_PREREQUISITES (iface),
1124 IFACE_NODE_N_PREREQUISITES (iface));
1125 prerequisites = IFACE_NODE_PREREQUISITES (iface);
1126 g_memmove (prerequisites + i + 1, prerequisites + i,
1127 sizeof (prerequisites[0]) * (IFACE_NODE_N_PREREQUISITES (iface) - i - 1));
1128 prerequisites[i] = prerequisite_type;
1129
1130 /* we want to get notified when prerequisites get added to prerequisite_node */
1131 if (NODE_IS_IFACE (prerequisite_node))
1132 {
1133 dependants = iface_node_get_dependants_array_L (prerequisite_node);
1134 n_dependants = dependants ? dependants[0] : 0;
1135 n_dependants += 1;
1136 dependants = g_renew (GType, dependants, n_dependants + 1);
1137 dependants[n_dependants] = NODE_TYPE (iface);
1138 dependants[0] = n_dependants;
1139 iface_node_set_dependants_array_W (prerequisite_node, dependants);
1140 }
1141
1142 /* we need to notify all dependants */
1143 dependants = iface_node_get_dependants_array_L (iface);
1144 n_dependants = dependants ? dependants[0] : 0;
1145 for (i = 1; i <= n_dependants; i++)
1146 type_iface_add_prerequisite_W (lookup_type_node_I (dependants[i]), prerequisite_node);
1147 }
1148
1149 /**
1150 * g_type_interface_add_prerequisite:
1151 * @interface_type: #GType value of an interface type.
1152 * @prerequisite_type: #GType value of an interface or instantiatable type.
1153 *
1154 * Adds @prerequisite_type to the list of prerequisites of @interface_type.
1155 * This means that any type implementing @interface_type must also implement
1156 * @prerequisite_type. Prerequisites can be thought of as an alternative to
1157 * interface derivation (which GType doesn't support). An interface can have
1158 * at most one instantiatable prerequisite type.
1159 **/
1160 void
1161 g_type_interface_add_prerequisite (GType interface_type,
1162 GType prerequisite_type)
1163 {
1164 TypeNode *iface, *prerequisite_node;
1165 IFaceHolder *holders;
1166
1167 g_return_if_fail (G_TYPE_IS_INTERFACE (interface_type)); /* G_TYPE_IS_INTERFACE() is an external call: _U */
1168 g_return_if_fail (!g_type_is_a (interface_type, prerequisite_type));
1169 g_return_if_fail (!g_type_is_a (prerequisite_type, interface_type));
1170
1171 iface = lookup_type_node_I (interface_type);
1172 prerequisite_node = lookup_type_node_I (prerequisite_type);
1173 if (!iface || !prerequisite_node || !NODE_IS_IFACE (iface))
1174 {
1175 g_warning ("interface type `%s' or prerequisite type `%s' invalid",
1176 type_descriptive_name_I (interface_type),
1177 type_descriptive_name_I (prerequisite_type));
1178 return;
1179 }
1180 G_WRITE_LOCK (&type_rw_lock);
1181 holders = iface_node_get_holders_L (iface);
1182 if (holders)
1183 {
1184 G_WRITE_UNLOCK (&type_rw_lock);
1185 g_warning ("unable to add prerequisite `%s' to interface `%s' which is already in use for `%s'",
1186 type_descriptive_name_I (prerequisite_type),
1187 type_descriptive_name_I (interface_type),
1188 type_descriptive_name_I (holders->instance_type));
1189 return;
1190 }
1191 if (prerequisite_node->is_instantiatable)
1192 {
1193 guint i;
1194
1195 /* can have at most one publically installable instantiatable prerequisite */
1196 for (i = 0; i < IFACE_NODE_N_PREREQUISITES (iface); i++)
1197 {
1198 TypeNode *prnode = lookup_type_node_I (IFACE_NODE_PREREQUISITES (iface)[i]);
1199
1200 if (prnode->is_instantiatable)
1201 {
1202 G_WRITE_UNLOCK (&type_rw_lock);
1203 g_warning ("adding prerequisite `%s' to interface `%s' conflicts with existing prerequisite `%s'",
1204 type_descriptive_name_I (prerequisite_type),
1205 type_descriptive_name_I (interface_type),
1206 type_descriptive_name_I (NODE_TYPE (prnode)));
1207 return;
1208 }
1209 }
1210
1211 for (i = 0; i < prerequisite_node->n_supers + 1; i++)
1212 type_iface_add_prerequisite_W (iface, lookup_type_node_I (prerequisite_node->supers[i]));
1213 G_WRITE_UNLOCK (&type_rw_lock);
1214 }
1215 else if (NODE_IS_IFACE (prerequisite_node))
1216 {
1217 GType *prerequisites;
1218 guint i;
1219
1220 prerequisites = IFACE_NODE_PREREQUISITES (prerequisite_node);
1221 for (i = 0; i < IFACE_NODE_N_PREREQUISITES (prerequisite_node); i++)
1222 type_iface_add_prerequisite_W (iface, lookup_type_node_I (prerequisites[i]));
1223 type_iface_add_prerequisite_W (iface, prerequisite_node);
1224 G_WRITE_UNLOCK (&type_rw_lock);
1225 }
1226 else
1227 {
1228 G_WRITE_UNLOCK (&type_rw_lock);
1229 g_warning ("prerequisite `%s' for interface `%s' is neither instantiatable nor interface",
1230 type_descriptive_name_I (prerequisite_type),
1231 type_descriptive_name_I (interface_type));
1232 }
1233 }
1234
1235 /**
1236 * g_type_interface_prerequisites:
1237 * @interface_type: an interface type
1238 * @n_prerequisites: location to return the number of prerequisites, or %NULL
1239 *
1240 * Returns the prerequisites of an interfaces type.
1241 *
1242 * Return value: a newly-allocated zero-terminated array of #GType containing
1243 * the prerequisites of @interface_type
1244 *
1245 * Since: 2.2
1246 **/
1247 GType* /* free result */
1248 g_type_interface_prerequisites (GType interface_type,
1249 guint *n_prerequisites)
1250 {
1251 TypeNode *iface;
1252
1253 g_return_val_if_fail (G_TYPE_IS_INTERFACE (interface_type), NULL);
1254
1255 iface = lookup_type_node_I (interface_type);
1256 if (iface)
1257 {
1258 GType *types;
1259 TypeNode *inode = NULL;
1260 guint i, n = 0;
1261
1262 G_READ_LOCK (&type_rw_lock);
1263 types = g_new0 (GType, IFACE_NODE_N_PREREQUISITES (iface) + 1);
1264 for (i = 0; i < IFACE_NODE_N_PREREQUISITES (iface); i++)
1265 {
1266 GType prerequisite = IFACE_NODE_PREREQUISITES (iface)[i];
1267 TypeNode *node = lookup_type_node_I (prerequisite);
1268 if (node->is_instantiatable &&
1269 (!inode || type_node_is_a_L (node, inode)))
1270 inode = node;
1271 else
1272 types[n++] = NODE_TYPE (node);
1273 }
1274 if (inode)
1275 types[n++] = NODE_TYPE (inode);
1276
1277 if (n_prerequisites)
1278 *n_prerequisites = n;
1279 G_READ_UNLOCK (&type_rw_lock);
1280
1281 return types;
1282 }
1283 else
1284 {
1285 if (n_prerequisites)
1286 *n_prerequisites = 0;
1287
1288 return NULL;
1289 }
1290 }
1291
1292
1293 static IFaceHolder*
1294 type_iface_peek_holder_L (TypeNode *iface,
1295 GType instance_type)
1296 {
1297 IFaceHolder *iholder;
1298
1299 g_assert (NODE_IS_IFACE (iface));
1300
1301 iholder = iface_node_get_holders_L (iface);
1302 while (iholder && iholder->instance_type != instance_type)
1303 iholder = iholder->next;
1304 return iholder;
1305 }
1306
1307 static IFaceHolder*
1308 type_iface_retrieve_holder_info_Wm (TypeNode *iface,
1309 GType instance_type,
1310 gboolean need_info)
1311 {
1312 IFaceHolder *iholder = type_iface_peek_holder_L (iface, instance_type);
1313
1314 if (iholder && !iholder->info && need_info)
1315 {
1316 GInterfaceInfo tmp_info;
1317
1318 g_assert (iholder->plugin != NULL);
1319
1320 type_data_ref_Wm (iface);
1321 if (iholder->info)
1322 INVALID_RECURSION ("g_type_plugin_*", iface->plugin, NODE_NAME (iface));
1323
1324 memset (&tmp_info, 0, sizeof (tmp_info));
1325
1326 G_WRITE_UNLOCK (&type_rw_lock);
1327 g_type_plugin_use (iholder->plugin);
1328 g_type_plugin_complete_interface_info (iholder->plugin, instance_type, NODE_TYPE (iface), &tmp_info);
1329 G_WRITE_LOCK (&type_rw_lock);
1330 if (iholder->info)
1331 INVALID_RECURSION ("g_type_plugin_*", iholder->plugin, NODE_NAME (iface));
1332
1333 check_interface_info_I (iface, instance_type, &tmp_info);
1334 iholder->info = g_memdup (&tmp_info, sizeof (tmp_info));
1335 }
1336
1337 return iholder; /* we don't modify write lock upon returning NULL */
1338 }
1339
1340 static void
1341 type_iface_blow_holder_info_Wm (TypeNode *iface,
1342 GType instance_type)
1343 {
1344 IFaceHolder *iholder = iface_node_get_holders_L (iface);
1345
1346 g_assert (NODE_IS_IFACE (iface));
1347
1348 while (iholder->instance_type != instance_type)
1349 iholder = iholder->next;
1350
1351 if (iholder->info && iholder->plugin)
1352 {
1353 g_free (iholder->info);
1354 iholder->info = NULL;
1355
1356 G_WRITE_UNLOCK (&type_rw_lock);
1357 g_type_plugin_unuse (iholder->plugin);
1358 G_WRITE_LOCK (&type_rw_lock);
1359
1360 type_data_unref_Wm (iface, FALSE);
1361 }
1362 }
1363
1364
1365 /* --- type structure creation/destruction --- */
1366 GTypeInstance*
1367 g_type_create_instance (GType type)
1368 {
1369 TypeNode *node;
1370 GTypeInstance *instance;
1371 GTypeClass *class;
1372 guint i;
1373
1374 node = lookup_type_node_I (type);
1375 if (!node || !node->is_instantiatable)
1376 {
1377 g_warning ("cannot create new instance of invalid (non-instantiatable) type `%s'",
1378 type_descriptive_name_I (type));
1379 return NULL;
1380 }
1381 /* G_TYPE_IS_ABSTRACT() is an external call: _U */
1382 if (!node->mutatable_check_cache && G_TYPE_IS_ABSTRACT (type))
1383 {
1384 g_warning ("cannot create instance of abstract (non-instantiatable) type `%s'",
1385 type_descriptive_name_I (type));
1386 return NULL;
1387 }
1388
1389 class = g_type_class_ref (type);
1390
1391 if (node->data->instance.n_preallocs)
1392 {
1393 G_WRITE_LOCK (&type_rw_lock);
1394 if (!node->data->instance.mem_chunk)
1395 node->data->instance.mem_chunk = g_mem_chunk_new (NODE_NAME (node),
1396 node->data->instance.instance_size,
1397 (node->data->instance.instance_size *
1398 node->data->instance.n_preallocs),
1399 G_ALLOC_AND_FREE);
1400 instance = g_chunk_new0 (GTypeInstance, node->data->instance.mem_chunk);
1401 G_WRITE_UNLOCK (&type_rw_lock);
1402 }
1403 else
1404 instance = g_malloc0 (node->data->instance.instance_size); /* fine without read lock */
1405 for (i = node->n_supers; i > 0; i--)
1406 {
1407 TypeNode *pnode;
1408
1409 pnode = lookup_type_node_I (node->supers[i]);
1410 if (pnode->data->instance.instance_init)
1411 {
1412 instance->g_class = pnode->data->instance.class;
1413 pnode->data->instance.instance_init (instance, class);
1414 }
1415 }
1416 instance->g_class = class;
1417
1418 if (node->data->instance.instance_init)
1419 node->data->instance.instance_init (instance, class);
1420
1421 return instance;
1422 }
1423
1424 void
1425 g_type_free_instance (GTypeInstance *instance)
1426 {
1427 TypeNode *node;
1428 GTypeClass *class;
1429
1430 g_return_if_fail (instance != NULL && instance->g_class != NULL);
1431
1432 class = instance->g_class;
1433 node = lookup_type_node_I (class->g_type);
1434 if (!node || !node->is_instantiatable || !node->data || node->data->class.class != (gpointer) class)
1435 {
1436 g_warning ("cannot free instance of invalid (non-instantiatable) type `%s'",
1437 type_descriptive_name_I (class->g_type));
1438 return;
1439 }
1440 /* G_TYPE_IS_ABSTRACT() is an external call: _U */
1441 if (!node->mutatable_check_cache && G_TYPE_IS_ABSTRACT (NODE_TYPE (node)))
1442 {
1443 g_warning ("cannot free instance of abstract (non-instantiatable) type `%s'",
1444 NODE_NAME (node));
1445 return;
1446 }
1447
1448 instance->g_class = NULL;
1449 #ifdef G_ENABLE_DEBUG
1450 memset (instance, 0xaa, node->data->instance.instance_size); /* debugging hack */
1451 #endif
1452 if (node->data->instance.n_preallocs)
1453 {
1454 G_WRITE_LOCK (&type_rw_lock);
1455 g_chunk_free (instance, node->data->instance.mem_chunk);
1456 G_WRITE_UNLOCK (&type_rw_lock);
1457 }
1458 else
1459 g_free (instance);
1460
1461 g_type_class_unref (class);
1462 }
1463
1464 static gboolean
1465 type_iface_vtable_init_Wm (TypeNode *iface,
1466 TypeNode *node)
1467 {
1468 IFaceEntry *entry = type_lookup_iface_entry_L (node, iface);
1469 IFaceHolder *iholder;
1470 GTypeInterface *vtable = NULL;
1471 TypeNode *pnode;
1472
1473 /* type_iface_retrieve_holder_info_Wm() doesn't modify write lock for returning NULL */
1474 iholder = type_iface_retrieve_holder_info_Wm (iface, NODE_TYPE (node), TRUE);
1475 if (!iholder)
1476 return FALSE; /* we don't modify write lock upon FALSE */
1477
1478 g_assert (iface->data && entry && entry->vtable == NULL && iholder && iholder->info);
1479
1480 pnode = lookup_type_node_I (NODE_PARENT_TYPE (node));
1481 if (pnode) /* want to copy over parent iface contents */
1482 {
1483 IFaceEntry *pentry = type_lookup_iface_entry_L (pnode, iface);
1484
1485 if (pentry)
1486 vtable = g_memdup (pentry->vtable, iface->data->iface.vtable_size);
1487 }
1488 if (!vtable)
1489 vtable = g_malloc0 (iface->data->iface.vtable_size);
1490 entry->vtable = vtable;
1491 vtable->g_type = NODE_TYPE (iface);
1492 vtable->g_instance_type = NODE_TYPE (node);
1493
1494 if (iface->data->iface.vtable_init_base || iholder->info->interface_init)
1495 {
1496 G_WRITE_UNLOCK (&type_rw_lock);
1497 if (iface->data->iface.vtable_init_base)
1498 iface->data->iface.vtable_init_base (vtable);
1499 if (iholder->info->interface_init)
1500 iholder->info->interface_init (vtable, iholder->info->interface_data);
1501 G_WRITE_LOCK (&type_rw_lock);
1502 }
1503 return TRUE; /* write lock modified */
1504 }
1505
1506 static gboolean
1507 type_iface_vtable_finalize_Wm (TypeNode *iface,
1508 TypeNode *node,
1509 GTypeInterface *vtable)
1510 {
1511 IFaceEntry *entry = type_lookup_iface_entry_L (node, iface);
1512 IFaceHolder *iholder;
1513
1514 /* type_iface_retrieve_holder_info_Wm() doesn't modify write lock for returning NULL */
1515 iholder = type_iface_retrieve_holder_info_Wm (iface, NODE_TYPE (node), FALSE);
1516 if (!iholder)
1517 return FALSE; /* we don't modify write lock upon FALSE */
1518
1519 g_assert (entry && entry->vtable == vtable && iholder->info);
1520
1521 entry->vtable = NULL;
1522 if (iholder->info->interface_finalize || iface->data->iface.vtable_finalize_base)
1523 {
1524 G_WRITE_UNLOCK (&type_rw_lock);
1525 if (iholder->info->interface_finalize)
1526 iholder->info->interface_finalize (vtable, iholder->info->interface_data);
1527 if (iface->data->iface.vtable_finalize_base)
1528 iface->data->iface.vtable_finalize_base (vtable);
1529 G_WRITE_LOCK (&type_rw_lock);
1530 }
1531 vtable->g_type = 0;
1532 vtable->g_instance_type = 0;
1533 g_free (vtable);
1534
1535 type_iface_blow_holder_info_Wm (iface, NODE_TYPE (node));
1536
1537 return TRUE; /* write lock modified */
1538 }
1539
1540 static void
1541 type_class_init_Wm (TypeNode *node,
1542 GTypeClass *pclass)
1543 {
1544 GSList *slist, *init_slist = NULL;
1545 GTypeClass *class;
1546 IFaceEntry *entry;
1547 TypeNode *bnode, *pnode;
1548 guint i;
1549
1550 g_assert (node->is_classed && node->data &&
1551 node->data->class.class_size &&
1552 !node->data->class.class);
1553
1554 class = g_malloc0 (node->data->class.class_size);
1555 node->data->class.class = class;
1556
1557 if (pclass)
1558 {
1559 TypeNode *pnode = lookup_type_node_I (pclass->g_type);
1560
1561 memcpy (class, pclass, pnode->data->class.class_size);
1562 }
1563 class->g_type = NODE_TYPE (node);
1564
1565 G_WRITE_UNLOCK (&type_rw_lock);
1566
1567 /* stack all base class initialization functions, so we
1568 * call them in ascending order.
1569 */
1570 for (bnode = node; bnode; bnode = lookup_type_node_I (NODE_PARENT_TYPE (bnode)))
1571 if (bnode->data->class.class_init_base)
1572 init_slist = g_slist_prepend (init_slist, (gpointer) bnode->data->class.class_init_base);
1573 for (slist = init_slist; slist; slist = slist->next)
1574 {
1575 GBaseInitFunc class_init_base = (GBaseInitFunc) slist->data;
1576
1577 class_init_base (class);
1578 }
1579 g_slist_free (init_slist);
1580
1581 if (node->data->class.class_init)
1582 node->data->class.class_init (class, (gpointer) node->data->class.class_data);
1583
1584 G_WRITE_LOCK (&type_rw_lock);
1585
1586 /* ok, we got the class done, now initialize all interfaces, either
1587 * from parent, or through our holder info
1588 */
1589 pnode = lookup_type_node_I (NODE_PARENT_TYPE (node));
1590 entry = CLASSED_NODE_IFACES_ENTRIES (node) + 0;
1591 while (entry)
1592 {
1593 g_assert (entry->vtable == NULL);
1594
1595 if (!type_iface_vtable_init_Wm (lookup_type_node_I (entry->iface_type), node))
1596 {
1597 guint j;
1598
1599 /* type_iface_vtable_init_Wm() doesn't modify write lock upon FALSE,
1600 * need to get this interface from parent
1601 */
1602 g_assert (pnode != NULL);
1603
1604 for (j = 0; j < CLASSED_NODE_N_IFACES (pnode); j++)
1605 {
1606 IFaceEntry *pentry = CLASSED_NODE_IFACES_ENTRIES (pnode) + j;
1607
1608 if (pentry->iface_type == entry->iface_type)
1609 {
1610 entry->vtable = pentry->vtable;
1611 break;
1612 }
1613 }
1614 g_assert (entry->vtable != NULL);
1615 }
1616
1617 /* refetch entry, IFACES_ENTRIES might be modified */
1618 for (entry = NULL, i = 0; i < CLASSED_NODE_N_IFACES (node); i++)
1619 if (!CLASSED_NODE_IFACES_ENTRIES (node)[i].vtable)
1620 entry = CLASSED_NODE_IFACES_ENTRIES (node) + i;
1621 }
1622 }
1623
1624 static void
1625 type_data_finalize_class_ifaces_Wm (TypeNode *node)
1626 {
1627 guint i;
1628
1629 g_assert (node->is_instantiatable && node->data && node->data->class.class && node->data->common.ref_count == 0);
1630
1631 reiterate:
1632 for (i = 0; i < CLASSED_NODE_N_IFACES (node); i++)
1633 {
1634 IFaceEntry *entry = CLASSED_NODE_IFACES_ENTRIES (node) + i;
1635 if (entry->vtable)
1636 {
1637 if (type_iface_vtable_finalize_Wm (lookup_type_node_I (entry->iface_type), node, entry->vtable))
1638 {
1639 /* refetch entries, IFACES_ENTRIES might be modified */
1640 goto reiterate;
1641 }
1642 else
1643 {
1644 /* type_iface_vtable_finalize_Wm() doesn't modify write lock upon FALSE,
1645 * iface vtable came from parent
1646 */
1647 entry->vtable = NULL;
1648 }
1649 }
1650 }
1651 }
1652
1653 static void
1654 type_data_finalize_class_U (TypeNode *node,
1655 ClassData *cdata)
1656 {
1657 GTypeClass *class = cdata->class;
1658 TypeNode *bnode;
1659
1660 g_assert (cdata->class && cdata->common.ref_count == 0);
1661
1662 if (cdata->class_finalize)
1663 cdata->class_finalize (class, (gpointer) cdata->class_data);
1664
1665 /* call all base class destruction functions in descending order
1666 */
1667 if (cdata->class_finalize_base)
1668 cdata->class_finalize_base (class);
1669 for (bnode = lookup_type_node_I (NODE_PARENT_TYPE (node)); bnode; bnode = lookup_type_node_I (NODE_PARENT_TYPE (bnode)))
1670 if (bnode->data->class.class_finalize_base)
1671 bnode->data->class.class_finalize_base (class);
1672
1673 class->g_type = 0;
1674 g_free (cdata->class);
1675 }
1676
1677 static void
1678 type_data_last_unref_Wm (GType type,
1679 gboolean uncached)
1680 {
1681 TypeNode *node = lookup_type_node_I (type);
1682
1683 g_return_if_fail (node != NULL && node->plugin != NULL);
1684
1685 if (!node->data || node->data->common.ref_count == 0)
1686 {
1687 g_warning ("cannot drop last reference to unreferenced type `%s'",
1688 type_descriptive_name_I (type));
1689 return;
1690 }
1691
1692 if (node->is_classed && node->data && node->data->class.class && static_n_class_cache_funcs)
1693 {
1694 guint i;
1695
1696 G_WRITE_UNLOCK (&type_rw_lock);
1697 G_READ_LOCK (&type_rw_lock);
1698 for (i = 0; i < static_n_class_cache_funcs; i++)
1699 {
1700 GTypeClassCacheFunc cache_func = static_class_cache_funcs[i].cache_func;
1701 gpointer cache_data = static_class_cache_funcs[i].cache_data;
1702 gboolean need_break;
1703
1704 G_READ_UNLOCK (&type_rw_lock);
1705 need_break = cache_func (cache_data, node->data->class.class);
1706 G_READ_LOCK (&type_rw_lock);
1707 if (!node->data || node->data->common.ref_count == 0)
1708 INVALID_RECURSION ("GType class cache function ", cache_func, NODE_NAME (node));
1709 if (need_break)
1710 break;
1711 }
1712 G_READ_UNLOCK (&type_rw_lock);
1713 G_WRITE_LOCK (&type_rw_lock);
1714 }
1715
1716 if (node->data->common.ref_count > 1) /* may have been re-referenced meanwhile */
1717 node->data->common.ref_count -= 1;
1718 else
1719 {
1720 GType ptype = NODE_PARENT_TYPE (node);
1721 TypeData *tdata;
1722
1723 node->data->common.ref_count = 0;
1724
1725 if (node->is_instantiatable && node->data->instance.mem_chunk)
1726 {
1727 g_mem_chunk_destroy (node->data->instance.mem_chunk);
1728 node->data->instance.mem_chunk = NULL;
1729 }
1730
1731 tdata = node->data;
1732 if (node->is_classed && tdata->class.class)
1733 {
1734 if (CLASSED_NODE_N_IFACES (node))
1735 type_data_finalize_class_ifaces_Wm (node);
1736 node->mutatable_check_cache = FALSE;
1737 node->data = NULL;
1738 G_WRITE_UNLOCK (&type_rw_lock);
1739 type_data_finalize_class_U (node, &tdata->class);
1740 G_WRITE_LOCK (&type_rw_lock);
1741 }
1742 else
1743 {
1744 node->mutatable_check_cache = FALSE;
1745 node->data = NULL;
1746 }
1747
1748 /* freeing tdata->common.value_table and its contents is taking care of
1749 * by allocating it in one chunk with tdata
1750 */
1751 g_free (tdata);
1752
1753 if (ptype)
1754 type_data_unref_Wm (lookup_type_node_I (ptype), FALSE);
1755 G_WRITE_UNLOCK (&type_rw_lock);
1756 g_type_plugin_unuse (node->plugin);
1757 G_WRITE_LOCK (&type_rw_lock);
1758 }
1759 }
1760
1761 void
1762 g_type_add_class_cache_func (gpointer cache_data,
1763 GTypeClassCacheFunc cache_func)
1764 {
1765 guint i;
1766
1767 g_return_if_fail (cache_func != NULL);
1768
1769 G_WRITE_LOCK (&type_rw_lock);
1770 i = static_n_class_cache_funcs++;
1771 static_class_cache_funcs = g_renew (ClassCacheFunc, static_class_cache_funcs, static_n_class_cache_funcs);
1772 static_class_cache_funcs[i].cache_data = cache_data;
1773 static_class_cache_funcs[i].cache_func = cache_func;
1774 G_WRITE_UNLOCK (&type_rw_lock);
1775 }
1776
1777 void
1778 g_type_remove_class_cache_func (gpointer cache_data,
1779 GTypeClassCacheFunc cache_func)
1780 {
1781 gboolean found_it = FALSE;
1782 guint i;
1783
1784 g_return_if_fail (cache_func != NULL);
1785
1786 G_WRITE_LOCK (&type_rw_lock);
1787 for (i = 0; i < static_n_class_cache_funcs; i++)
1788 if (static_class_cache_funcs[i].cache_data == cache_data &&
1789 static_class_cache_funcs[i].cache_func == cache_func)
1790 {
1791 static_n_class_cache_funcs--;
1792 g_memmove (static_class_cache_funcs + i,
1793 static_class_cache_funcs + i + 1,
1794 sizeof (static_class_cache_funcs[0]) * (static_n_class_cache_funcs - i));
1795 static_class_cache_funcs = g_renew (ClassCacheFunc, static_class_cache_funcs, static_n_class_cache_funcs);
1796 found_it = TRUE;
1797 break;
1798 }
1799 G_WRITE_UNLOCK (&type_rw_lock);
1800
1801 if (!found_it)
1802 g_warning (G_STRLOC ": cannot remove unregistered class cache func %p with data %p",
1803 cache_func, cache_data);
1804 }
1805
1806
1807 /* --- type registration --- */
1808 GType
1809 g_type_register_fundamental (GType type_id,
1810 const gchar *type_name,
1811 const GTypeInfo *info,
1812 const GTypeFundamentalInfo *finfo,
1813 GTypeFlags flags)
1814 {
1815 GTypeFundamentalInfo *node_finfo;
1816 TypeNode *node;
1817
1818 g_return_val_if_uninitialized (static_quark_type_flags, g_type_init, 0);
1819 g_return_val_if_fail (type_id > 0, 0);
1820 g_return_val_if_fail (type_name != NULL, 0);
1821 g_return_val_if_fail (info != NULL, 0);
1822 g_return_val_if_fail (finfo != NULL, 0);
1823
1824 if (!check_type_name_I (type_name))
1825 return 0;
1826 if ((type_id & TYPE_ID_MASK) ||
1827 type_id > G_TYPE_FUNDAMENTAL_MAX)
1828 {
1829 g_warning ("attempt to register fundamental type `%s' with invalid type id (%lu)",
1830 type_name,
1831 type_id);
1832 return 0;
1833 }
1834 if ((finfo->type_flags & G_TYPE_FLAG_INSTANTIATABLE) &&
1835 !(finfo->type_flags & G_TYPE_FLAG_CLASSED))
1836 {
1837 g_warning ("cannot register instantiatable fundamental type `%s' as non-classed",
1838 type_name);
1839 return 0;
1840 }
1841 if (lookup_type_node_I (type_id))
1842 {
1843 g_warning ("cannot register existing fundamental type `%s' (as `%s')",
1844 type_descriptive_name_I (type_id),
1845 type_name);
1846 return 0;
1847 }
1848
1849 G_WRITE_LOCK (&type_rw_lock);
1850 node = type_node_fundamental_new_W (type_id, type_name, finfo->type_flags);
1851 node_finfo = type_node_fundamental_info_I (node);
1852 type_add_flags_W (node, flags);
1853
1854 if (check_type_info_I (NULL, NODE_FUNDAMENTAL_TYPE (node), type_name, info))
1855 type_data_make_W (node, info,
1856 check_value_table_I (type_name, info->value_table) ? info->value_table : NULL);
1857 G_WRITE_UNLOCK (&type_rw_lock);
1858
1859 return NODE_TYPE (node);
1860 }
1861
1862 GType
1863 g_type_register_static (GType parent_type,
1864 const gchar *type_name,
1865 const GTypeInfo *info,
1866 GTypeFlags flags)
1867 {
1868 TypeNode *pnode, *node;
1869 GType type = 0;
1870
1871 g_return_val_if_uninitialized (static_quark_type_flags, g_type_init, 0);
1872 g_return_val_if_fail (parent_type > 0, 0);
1873 g_return_val_if_fail (type_name != NULL, 0);
1874 g_return_val_if_fail (info != NULL, 0);
1875
1876 if (!check_type_name_I (type_name) ||
1877 !check_derivation_I (parent_type, type_name))
1878 return 0;
1879 if (info->class_finalize)
1880 {
1881 g_warning ("class finalizer specified for static type `%s'",
1882 type_name);
1883 return 0;
1884 }
1885
1886 pnode = lookup_type_node_I (parent_type);
1887 G_WRITE_LOCK (&type_rw_lock);
1888 type_data_ref_Wm (pnode);
1889 if (check_type_info_I (pnode, NODE_FUNDAMENTAL_TYPE (pnode), type_name, info))
1890 {
1891 node = type_node_new_W (pnode, type_name, NULL);
1892 type_add_flags_W (node, flags);
1893 type = NODE_TYPE (node);
1894 type_data_make_W (node, info,
1895 check_value_table_I (type_name, info->value_table) ? info->value_table : NULL);
1896 }
1897 G_WRITE_UNLOCK (&type_rw_lock);
1898
1899 return type;
1900 }
1901
1902 GType
1903 g_type_register_dynamic (GType parent_type,
1904 const gchar *type_name,
1905 GTypePlugin *plugin,
1906 GTypeFlags flags)
1907 {
1908 TypeNode *pnode, *node;
1909 GType type;
1910
1911 g_return_val_if_uninitialized (static_quark_type_flags, g_type_init, 0);
1912 g_return_val_if_fail (parent_type > 0, 0);
1913 g_return_val_if_fail (type_name != NULL, 0);
1914 g_return_val_if_fail (plugin != NULL, 0);
1915
1916 if (!check_type_name_I (type_name) ||
1917 !check_derivation_I (parent_type, type_name) ||
1918 !check_plugin_U (plugin, TRUE, FALSE, type_name))
1919 return 0;
1920
1921 G_WRITE_LOCK (&type_rw_lock);
1922 pnode = lookup_type_node_I (parent_type);
1923 node = type_node_new_W (pnode, type_name, plugin);
1924 type_add_flags_W (node, flags);
1925 type = NODE_TYPE (node);
1926 G_WRITE_UNLOCK (&type_rw_lock);
1927
1928 return type;
1929 }
1930
1931 void
1932 g_type_add_interface_static (GType instance_type,
1933 GType interface_type,
1934 const GInterfaceInfo *info)
1935 {
1936 /* G_TYPE_IS_INSTANTIATABLE() is an external call: _U */
1937 g_return_if_fail (G_TYPE_IS_INSTANTIATABLE (instance_type));
1938 g_return_if_fail (g_type_parent (interface_type) == G_TYPE_INTERFACE);
1939
1940 G_WRITE_LOCK (&type_rw_lock);
1941 if (check_add_interface_L (instance_type, interface_type))
1942 {
1943 TypeNode *node = lookup_type_node_I (instance_type);
1944 TypeNode *iface = lookup_type_node_I (interface_type);
1945
1946 if (check_interface_info_I (iface, NODE_TYPE (node), info))
1947 {
1948 type_add_interface_W (node, iface, info, NULL);
1949 /* if we have a class already, the interface vtable needs to
1950 * be initialized as well
1951 */
1952 if (node->data && node->data->class.class)
1953 type_iface_vtable_init_Wm (iface, node);
1954 }
1955 }
1956 G_WRITE_UNLOCK (&type_rw_lock);
1957 }
1958
1959 /**
1960 * g_type_add_interface_dynamic:
1961 * @instance_type: the #GType value of an instantiable type.
1962 * @interface_type: the #GType value of an interface type.
1963 * @plugin: the #GTypePlugin structure to retrieve the #GInterfaceInfo from.
1964 *
1965 * Adds the dynamic @interface_type to @instantiable_type. The information
1966 * contained in the #GTypePlugin structure pointed to by @plugin
1967 * is used to manage the relationship.
1968 **/
1969 void
1970 g_type_add_interface_dynamic (GType instance_type,
1971 GType interface_type,
1972 GTypePlugin *plugin)
1973 {
1974 TypeNode *node;
1975
1976 /* G_TYPE_IS_INSTANTIATABLE() is an external call: _U */
1977 g_return_if_fail (G_TYPE_IS_INSTANTIATABLE (instance_type));
1978 g_return_if_fail (g_type_parent (interface_type) == G_TYPE_INTERFACE);
1979
1980 node = lookup_type_node_I (instance_type);
1981 if (!check_plugin_U (plugin, FALSE, TRUE, NODE_NAME (node)))
1982 return;
1983
1984 G_WRITE_LOCK (&type_rw_lock);
1985 if (check_add_interface_L (instance_type, interface_type))
1986 {
1987 TypeNode *iface = lookup_type_node_I (interface_type);
1988
1989 type_add_interface_W (node, iface, NULL, plugin);
1990 /* if we have a class already, the interface vtable needs to
1991 * be initialized as well
1992 */
1993 if (node->data && node->data->class.class)
1994 type_iface_vtable_init_Wm (iface, node);
1995 }
1996 G_WRITE_UNLOCK (&type_rw_lock);
1997 }
1998
1999
2000 /* --- public API functions --- */
2001 gpointer
2002 g_type_class_ref (GType type)
2003 {
2004 TypeNode *node;
2005
2006 /* optimize for common code path
2007 */
2008 G_WRITE_LOCK (&type_rw_lock);
2009 node = lookup_type_node_I (type);
2010 if (node && node->is_classed && node->data &&
2011 node->data->class.class && node->data->common.ref_count > 0)
2012 {
2013 type_data_ref_Wm (node);
2014 G_WRITE_UNLOCK (&type_rw_lock);
2015
2016 return node->data->class.class;
2017 }
2018
2019 if (!node || !node->is_classed ||
2020 (node->data && node->data->common.ref_count < 1))
2021 {
2022 G_WRITE_UNLOCK (&type_rw_lock);
2023 g_warning ("cannot retrieve class for invalid (unclassed) type `%s'",
2024 type_descriptive_name_I (type));
2025 return NULL;
2026 }
2027
2028 type_data_ref_Wm (node);
2029
2030 if (!node->data->class.class)
2031 {
2032 GType ptype = NODE_PARENT_TYPE (node);
2033 GTypeClass *pclass = NULL;
2034
2035 if (ptype)
2036 {
2037 G_WRITE_UNLOCK (&type_rw_lock);
2038 pclass = g_type_class_ref (ptype);
2039 if (node->data->class.class)
2040 INVALID_RECURSION ("g_type_plugin_*", node->plugin, NODE_NAME (node));
2041 G_WRITE_LOCK (&type_rw_lock);
2042 }
2043
2044 type_class_init_Wm (node, pclass);
2045 }
2046 G_WRITE_UNLOCK (&type_rw_lock);
2047
2048 return node->data->class.class;
2049 }
2050
2051 void
2052 g_type_class_unref (gpointer g_class)
2053 {
2054 TypeNode *node;
2055 GTypeClass *class = g_class;
2056
2057 g_return_if_fail (g_class != NULL);
2058
2059 node = lookup_type_node_I (class->g_type);
2060 G_WRITE_LOCK (&type_rw_lock);
2061 if (node && node->is_classed && node->data &&
2062 node->data->class.class == class && node->data->common.ref_count > 0)
2063 type_data_unref_Wm (node, FALSE);
2064 else
2065 g_warning ("cannot unreference class of invalid (unclassed) type `%s'",
2066 type_descriptive_name_I (class->g_type));
2067 G_WRITE_UNLOCK (&type_rw_lock);
2068 }
2069
2070 void
2071 g_type_class_unref_uncached (gpointer g_class)
2072 {
2073 TypeNode *node;
2074 GTypeClass *class = g_class;
2075
2076 g_return_if_fail (g_class != NULL);
2077
2078 G_WRITE_LOCK (&type_rw_lock);
2079 node = lookup_type_node_I (class->g_type);
2080 if (node && node->is_classed && node->data &&
2081 node->data->class.class == class && node->data->common.ref_count > 0)
2082 type_data_unref_Wm (node, TRUE);
2083 else
2084 g_warning ("cannot unreference class of invalid (unclassed) type `%s'",
2085 type_descriptive_name_I (class->g_type));
2086 G_WRITE_UNLOCK (&type_rw_lock);
2087 }
2088
2089 gpointer
2090 g_type_class_peek (GType type)
2091 {
2092 TypeNode *node;
2093 gpointer class;
2094
2095 node = lookup_type_node_I (type);
2096 G_READ_LOCK (&type_rw_lock);
2097 if (node && node->is_classed && node->data && node->data->class.class) /* common.ref_count _may_ be 0 */
2098 class = node->data->class.class;
2099 else
2100 class = NULL;
2101 G_READ_UNLOCK (&type_rw_lock);
2102
2103 return class;
2104 }
2105
2106 gpointer
2107 g_type_class_peek_parent (gpointer g_class)
2108 {
2109 TypeNode *node;
2110 gpointer class = NULL;
2111
2112 g_return_val_if_fail (g_class != NULL, NULL);
2113
2114 node = lookup_type_node_I (G_TYPE_FROM_CLASS (g_class));
2115 G_READ_LOCK (&type_rw_lock);
2116 if (node && node->is_classed && node->data && NODE_PARENT_TYPE (node))
2117 {
2118 node = lookup_type_node_I (NODE_PARENT_TYPE (node));
2119 class = node->data->class.class;
2120 }
2121 else if (NODE_PARENT_TYPE (node))
2122 g_warning (G_STRLOC ": invalid class pointer `%p'", g_class);
2123 G_READ_UNLOCK (&type_rw_lock);
2124
2125 return class;
2126 }
2127
2128 gpointer
2129 g_type_interface_peek (gpointer instance_class,
2130 GType iface_type)
2131 {
2132 TypeNode *node;
2133 TypeNode *iface;
2134 gpointer vtable = NULL;
2135 GTypeClass *class = instance_class;
2136
2137 g_return_val_if_fail (instance_class != NULL, NULL);
2138
2139 node = lookup_type_node_I (class->g_type);
2140 iface = lookup_type_node_I (iface_type);
2141 if (node && node->is_instantiatable && iface)
2142 {
2143 IFaceEntry *entry;
2144
2145 G_READ_LOCK (&type_rw_lock);
2146
2147 entry = type_lookup_iface_entry_L (node, iface);
2148 if (entry && entry->vtable) /* entry is relocatable */
2149 vtable = entry->vtable;
2150
2151 G_READ_UNLOCK (&type_rw_lock);
2152 }
2153 else
2154 g_warning (G_STRLOC ": invalid class pointer `%p'", class);
2155
2156 return vtable;
2157 }
2158
2159 /**
2160 * g_type_interface_peek_parent:
2161 * @g_iface: A #GTypeInterface structure.
2162 *
2163 * Returns the corresponding #GTypeInterface structure of the parent type
2164 * of the instance type to which @g_iface belongs. This is useful when
2165 * deriving the implementation of an interface from the parent type and
2166 * then possibly overriding some methods.
2167 *
2168 * Return value: The corresponding #GTypeInterface structure of the parent type
2169 * of the instance type to which @g_iface belongs, or %NULL if the parent type
2170 * doesn't conform to the interface.
2171 **/
2172 gpointer
2173 g_type_interface_peek_parent (gpointer g_iface)
2174 {
2175 TypeNode *node;
2176 TypeNode *iface;
2177 gpointer vtable = NULL;
2178 GTypeInterface *iface_class = g_iface;
2179
2180 g_return_val_if_fail (g_iface != NULL, NULL);
2181
2182 iface = lookup_type_node_I (iface_class->g_type);
2183 node = lookup_type_node_I (iface_class->g_instance_type);
2184 if (node)
2185 node = lookup_type_node_I (NODE_PARENT_TYPE (node));
2186 if (node && node->is_instantiatable && iface)
2187 {
2188 IFaceEntry *entry;
2189
2190 G_READ_LOCK (&type_rw_lock);
2191
2192 entry = type_lookup_iface_entry_L (node, iface);
2193 if (entry && entry->vtable) /* entry is relocatable */
2194 vtable = entry->vtable;
2195
2196 G_READ_UNLOCK (&type_rw_lock);
2197 }
2198 else if (node)
2199 g_warning (G_STRLOC ": invalid interface pointer `%p'", g_iface);
2200
2201 return vtable;
2202 }
2203
2204 G_CONST_RETURN gchar*
2205 g_type_name (GType type)
2206 {
2207 TypeNode *node;
2208
2209 g_return_val_if_uninitialized (static_quark_type_flags, g_type_init, NULL);
2210
2211 node = lookup_type_node_I (type);
2212
2213 return node ? NODE_NAME (node) : NULL;
2214 }
2215
2216 GQuark
2217 g_type_qname (GType type)
2218 {
2219 TypeNode *node;
2220
2221 node = lookup_type_node_I (type);
2222
2223 return node ? node->qname : 0;
2224 }
2225
2226 GType
2227 g_type_from_name (const gchar *name)
2228 {
2229 GType type = 0;
2230 GQuark quark;
2231
2232 g_return_val_if_fail (name != NULL, 0);
2233
2234 quark = g_quark_try_string (name);
2235 if (quark)
2236 {
2237 G_READ_LOCK (&type_rw_lock);
2238 type = (GType) g_hash_table_lookup (static_type_nodes_ht, GUINT_TO_POINTER (quark));
2239 G_READ_UNLOCK (&type_rw_lock);
2240 }
2241
2242 return type;
2243 }
2244
2245 GType
2246 g_type_parent (GType type)
2247 {
2248 TypeNode *node;
2249
2250 node = lookup_type_node_I (type);
2251
2252 return node ? NODE_PARENT_TYPE (node) : 0;
2253 }
2254
2255 guint
2256 g_type_depth (GType type)
2257 {
2258 TypeNode *node;
2259
2260 node = lookup_type_node_I (type);
2261
2262 return node ? node->n_supers + 1 : 0;
2263 }
2264
2265 GType
2266 g_type_next_base (GType type,
2267 GType base_type)
2268 {
2269 GType atype = 0;
2270 TypeNode *node;
2271
2272 node = lookup_type_node_I (type);
2273 if (node)
2274 {
2275 TypeNode *base_node = lookup_type_node_I (base_type);
2276
2277 if (base_node && base_node->n_supers < node->n_supers)
2278 {
2279 guint n = node->n_supers - base_node->n_supers;
2280
2281 if (node->supers[n] == base_type)
2282 atype = node->supers[n - 1];
2283 }
2284 }
2285
2286 return atype;
2287 }
2288
2289 static inline gboolean
2290 type_node_check_conformities_UorL (TypeNode *node,
2291 TypeNode *iface_node,
2292 /* support_inheritance */
2293 gboolean support_interfaces,
2294 gboolean support_prerequisites,
2295 gboolean have_lock)
2296 {
2297 gboolean match;
2298
2299 if (/* support_inheritance && */
2300 iface_node->n_supers <= node->n_supers &&
2301 node->supers[node->n_supers - iface_node->n_supers] == NODE_TYPE (iface_node))
2302 return TRUE;
2303
2304 support_interfaces = support_interfaces && node->is_instantiatable && NODE_IS_IFACE (iface_node);
2305 support_prerequisites = support_prerequisites && NODE_IS_IFACE (node);
2306 match = FALSE;
2307 if (support_interfaces || support_prerequisites)
2308 {
2309 if (!have_lock)
2310 G_READ_LOCK (&type_rw_lock);
2311 if (support_interfaces && type_lookup_iface_entry_L (node, iface_node))
2312 match = TRUE;
2313 else if (support_prerequisites && type_lookup_prerequisite_L (node, NODE_TYPE (iface_node)))
2314 match = TRUE;
2315 if (!have_lock)
2316 G_READ_UNLOCK (&type_rw_lock);
2317 }
2318 return match;
2319 }
2320
2321 static gboolean
2322 type_node_is_a_L (TypeNode *node,
2323 TypeNode *iface_node)
2324 {
2325 return type_node_check_conformities_UorL (node, iface_node, TRUE, TRUE, TRUE);
2326 }
2327
2328 static inline gboolean
2329 type_node_conforms_to_U (TypeNode *node,
2330 TypeNode *iface_node,
2331 gboolean support_interfaces,
2332 gboolean support_prerequisites)
2333 {
2334 return type_node_check_conformities_UorL (node, iface_node, support_interfaces, support_prerequisites, FALSE);
2335 }
2336
2337 gboolean
2338 g_type_is_a (GType type,
2339 GType iface_type)
2340 {
2341 TypeNode *node, *iface_node;
2342 gboolean is_a;
2343
2344 node = lookup_type_node_I (type);
2345 iface_node = lookup_type_node_I (iface_type);
2346 is_a = node && iface_node && type_node_conforms_to_U (node, iface_node, TRUE, TRUE);
2347
2348 return is_a;
2349 }
2350
2351 GType* /* free result */
2352 g_type_children (GType type,
2353 guint *n_children)
2354 {
2355 TypeNode *node;
2356
2357 node = lookup_type_node_I (type);
2358 if (node)
2359 {
2360 GType *children;
2361
2362 G_READ_LOCK (&type_rw_lock); /* ->children is relocatable */
2363 children = g_new (GType, node->n_children + 1);
2364 memcpy (children, node->children, sizeof (GType) * node->n_children);
2365 children[node->n_children] = 0;
2366
2367 if (n_children)
2368 *n_children = node->n_children;
2369 G_READ_UNLOCK (&type_rw_lock);
2370
2371 return children;
2372 }
2373 else
2374 {
2375 if (n_children)
2376 *n_children = 0;
2377
2378 return NULL;
2379 }
2380 }
2381
2382 GType* /* free result */
2383 g_type_interfaces (GType type,
2384 guint *n_interfaces)
2385 {
2386 TypeNode *node;
2387
2388 node = lookup_type_node_I (type);
2389 if (node && node->is_instantiatable)
2390 {
2391 GType *ifaces;
2392 guint i;
2393
2394 G_READ_LOCK (&type_rw_lock);
2395 ifaces = g_new (GType, CLASSED_NODE_N_IFACES (node) + 1);
2396 for (i = 0; i < CLASSED_NODE_N_IFACES (node); i++)
2397 ifaces[i] = CLASSED_NODE_IFACES_ENTRIES (node)[i].iface_type;
2398 ifaces[i] = 0;
2399
2400 if (n_interfaces)
2401 *n_interfaces = CLASSED_NODE_N_IFACES (node);
2402 G_READ_UNLOCK (&type_rw_lock);
2403
2404 return ifaces;
2405 }
2406 else
2407 {
2408 if (n_interfaces)
2409 *n_interfaces = 0;
2410
2411 return NULL;
2412 }
2413 }
2414
2415 typedef struct _QData QData;
2416 struct _GData
2417 {
2418 guint n_qdatas;
2419 QData *qdatas;
2420 };
2421 struct _QData
2422 {
2423 GQuark quark;
2424 gpointer data;
2425 };
2426
2427 static inline gpointer
2428 type_get_qdata_L (TypeNode *node,
2429 GQuark quark)
2430 {
2431 GData *gdata = node->global_gdata;
2432
2433 if (quark && gdata && gdata->n_qdatas)
2434 {
2435 QData *qdatas = gdata->qdatas - 1;
2436 guint n_qdatas = gdata->n_qdatas;
2437
2438 do
2439 {
2440 guint i;
2441 QData *check;
2442
2443 i = (n_qdatas + 1) / 2;
2444 check = qdatas + i;
2445 if (quark == check->quark)
2446 return check->data;
2447 else if (quark > check->quark)
2448 {
2449 n_qdatas -= i;
2450 qdatas = check;
2451 }
2452 else /* if (quark < check->quark) */
2453 n_qdatas = i - 1;
2454 }
2455 while (n_qdatas);
2456 }
2457 return NULL;
2458 }
2459
2460 /**
2461 * g_type_get_qdata:
2462 * @type: a #GType
2463 * @quark: a #GQuark id to identify the data
2464 *
2465 * Obtains data which has previously been attached to @type
2466 * with g_type_set_qdata().
2467 *
2468 * Return value: the data, or %NULL if no data was found
2469 **/
2470 gpointer
2471 g_type_get_qdata (GType type,
2472 GQuark quark)
2473 {
2474 TypeNode *node;
2475 gpointer data;
2476
2477 node = lookup_type_node_I (type);
2478 if (node)
2479 {
2480 G_READ_LOCK (&type_rw_lock);
2481 data = type_get_qdata_L (node, quark);
2482 G_READ_UNLOCK (&type_rw_lock);
2483 }
2484 else
2485 {
2486 g_return_val_if_fail (node != NULL, NULL);
2487 data = NULL;
2488 }
2489 return data;
2490 }
2491
2492 static inline void
2493 type_set_qdata_W (TypeNode *node,
2494 GQuark quark,
2495 gpointer data)
2496 {
2497 GData *gdata;
2498 QData *qdata;
2499 guint i;
2500
2501 /* setup qdata list if necessary */
2502 if (!node->global_gdata)
2503 node->global_gdata = g_new0 (GData, 1);
2504 gdata = node->global_gdata;
2505
2506 /* try resetting old data */
2507 qdata = gdata->qdatas;
2508 for (i = 0; i < gdata->n_qdatas; i++)
2509 if (qdata[i].quark == quark)
2510 {
2511 qdata[i].data = data;
2512 return;
2513 }
2514
2515 /* add new entry */
2516 gdata->n_qdatas++;
2517 gdata->qdatas = g_renew (QData, gdata->qdatas, gdata->n_qdatas);
2518 qdata = gdata->qdatas;
2519 for (i = 0; i < gdata->n_qdatas - 1; i++)
2520 if (qdata[i].quark > quark)
2521 break;
2522 g_memmove (qdata + i + 1, qdata + i, sizeof (qdata[0]) * (gdata->n_qdatas - i - 1));
2523 qdata[i].quark = quark;
2524 qdata[i].data = data;
2525 }
2526
2527 /**
2528 * g_type_set_qdata:
2529 * @type: a #GType
2530 * @quark: a #GQuark id to identify the data
2531 * @data: the data
2532 *
2533 * Attaches arbitrary data to a type.
2534 **/
2535 void
2536 g_type_set_qdata (GType type,
2537 GQuark quark,
2538 gpointer data)
2539 {
2540 TypeNode *node;
2541
2542 g_return_if_fail (quark != 0);
2543
2544 node = lookup_type_node_I (type);
2545 if (node)
2546 {
2547 G_WRITE_LOCK (&type_rw_lock);
2548 type_set_qdata_W (node, quark, data);
2549 G_WRITE_UNLOCK (&type_rw_lock);
2550 }
2551 else
2552 g_return_if_fail (node != NULL);
2553 }
2554
2555 static void
2556 type_add_flags_W (TypeNode *node,
2557 GTypeFlags flags)
2558 {
2559 guint dflags;
2560
2561 g_return_if_fail ((flags & ~TYPE_FLAG_MASK) == 0);
2562 g_return_if_fail (node != NULL);
2563
2564 if ((flags & TYPE_FLAG_MASK) && node->is_classed && node->data && node->data->class.class)
2565 g_warning ("tagging type `%s' as abstract after class initialization", NODE_NAME (node));
2566 dflags = GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags));
2567 dflags |= flags;
2568 type_set_qdata_W (node, static_quark_type_flags, GUINT_TO_POINTER (dflags));
2569 }
2570
2571 /**
2572 * g_type_query:
2573 * @type: the #GType value of a static, classed type.
2574 * @query: A user provided structure that is filled in with constant values
2575 * upon success.
2576 *
2577 * Queries the type system for information about a specific type.
2578 * This function will fill in a user-provided structure to hold type-specific
2579 * information. If an invalid #GType is passed in, the @type member of the
2580 * #GTypeQuery is 0. All members filled into the #GTypeQuery structure should
2581 * be considered constant and have to be left untouched.
2582 **/
2583 void
2584 g_type_query (GType type,
2585 GTypeQuery *query)
2586 {
2587 TypeNode *node;
2588
2589 g_return_if_fail (query != NULL);
2590
2591 /* if node is not static and classed, we won't allow query */
2592 query->type = 0;
2593 node = lookup_type_node_I (type);
2594 if (node && node->is_classed && !node->plugin)
2595 {
2596 /* type is classed and probably even instantiatable */
2597 G_READ_LOCK (&type_rw_lock);
2598 if (node->data) /* type is static or referenced */
2599 {
2600 query->type = NODE_TYPE (node);
2601 query->type_name = NODE_NAME (node);
2602 query->class_size = node->data->class.class_size;
2603 query->instance_size = node->is_instantiatable ? node->data->instance.instance_size : 0;
2604 }
2605 G_READ_UNLOCK (&type_rw_lock);
2606 }
2607 }
2608
2609
2610 /* --- implementation details --- */
2611 gboolean
2612 g_type_test_flags (GType type,
2613 guint flags)
2614 {
2615 TypeNode *node;
2616 gboolean result = FALSE;
2617
2618 node = lookup_type_node_I (type);
2619 if (node)
2620 {
2621 guint fflags = flags & TYPE_FUNDAMENTAL_FLAG_MASK;
2622 guint tflags = flags & TYPE_FLAG_MASK;
2623
2624 if (fflags)
2625 {
2626 GTypeFundamentalInfo *finfo = type_node_fundamental_info_I (node);
2627
2628 fflags = (finfo->type_flags & fflags) == fflags;
2629 }
2630 else
2631 fflags = TRUE;
2632
2633 if (tflags)
2634 {
2635 G_READ_LOCK (&type_rw_lock);
2636 tflags = (tflags & GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags))) == tflags;
2637 G_READ_UNLOCK (&type_rw_lock);
2638 }
2639 else
2640 tflags = TRUE;
2641
2642 result = tflags && fflags;
2643 }
2644
2645 return result;
2646 }
2647
2648 GTypePlugin*
2649 g_type_get_plugin (GType type)
2650 {
2651 TypeNode *node;
2652
2653 node = lookup_type_node_I (type);
2654
2655 return node ? node->plugin : NULL;
2656 }
2657
2658 /**
2659 * g_type_interface_get_plugin:
2660 * @instance_type: the #GType value of an instantiatable type.
2661 * @interface_type: the #GType value of an interface type.
2662 *
2663 * Returns the #GTypePlugin structure for the dynamic interface
2664 * @interface_type which has been added to @instance_type, or
2665 * %NULL if @interface_type has not been added to @instance_type or does
2666 * not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
2667 *
2668 * Return value: the #GTypePlugin for the dynamic interface @interface_type
2669 * of @instance_type.
2670 **/
2671 GTypePlugin*
2672 g_type_interface_get_plugin (GType instance_type,
2673 GType interface_type)
2674 {
2675 TypeNode *node;
2676 TypeNode *iface;
2677
2678 g_return_val_if_fail (G_TYPE_IS_INTERFACE (interface_type), NULL); /* G_TYPE_IS_INTERFACE() is an external call: _U */
2679
2680 node = lookup_type_node_I (instance_type);
2681 iface = lookup_type_node_I (interface_type);
2682 if (node && iface)
2683 {
2684 IFaceHolder *iholder;
2685 GTypePlugin *plugin;
2686
2687 G_READ_LOCK (&type_rw_lock);
2688
2689 iholder = iface_node_get_holders_L (iface);
2690 while (iholder && iholder->instance_type != instance_type)
2691 iholder = iholder->next;
2692 plugin = iholder ? iholder->plugin : NULL;
2693
2694 G_READ_UNLOCK (&type_rw_lock);
2695
2696 return plugin;
2697 }
2698
2699 g_return_val_if_fail (node == NULL, NULL);
2700 g_return_val_if_fail (iface == NULL, NULL);
2701
2702 g_warning (G_STRLOC ": attempt to look up plugin for invalid instance/interface type pair.");
2703
2704 return NULL;
2705 }
2706
2707 GType
2708 g_type_fundamental_next (void)
2709 {
2710 GType type;
2711
2712 G_READ_LOCK (&type_rw_lock);
2713 type = static_fundamental_next;
2714 G_READ_UNLOCK (&type_rw_lock);
2715 type = G_TYPE_MAKE_FUNDAMENTAL (type);
2716 return type <= G_TYPE_FUNDAMENTAL_MAX ? type : 0;
2717 }
2718
2719 GType
2720 g_type_fundamental (GType type_id)
2721 {
2722 TypeNode *node = lookup_type_node_I (type_id);
2723
2724 return node ? NODE_FUNDAMENTAL_TYPE (node) : 0;
2725 }
2726
2727 gboolean
2728 g_type_check_instance_is_a (GTypeInstance *type_instance,
2729 GType iface_type)
2730 {
2731 TypeNode *node, *iface;
2732 gboolean check;
2733
2734 if (!type_instance || !type_instance->g_class)
2735 return FALSE;
2736
2737 node = lookup_type_node_I (type_instance->g_class->g_type);
2738 iface = lookup_type_node_I (iface_type);
2739 check = node && node->is_instantiatable && iface && type_node_conforms_to_U (node, iface, TRUE, FALSE);
2740
2741 return check;
2742 }
2743
2744 gboolean
2745 g_type_check_class_is_a (GTypeClass *type_class,
2746 GType is_a_type)
2747 {
2748 TypeNode *node, *iface;
2749 gboolean check;
2750
2751 if (!type_class)
2752 return FALSE;
2753
2754 node = lookup_type_node_I (type_class->g_type);
2755 iface = lookup_type_node_I (is_a_type);
2756 check = node && node->is_classed && iface && type_node_conforms_to_U (node, iface, FALSE, FALSE);
2757
2758 return check;
2759 }
2760
2761 GTypeInstance*
2762 g_type_check_instance_cast (GTypeInstance *type_instance,
2763 GType iface_type)
2764 {
2765 if (type_instance)
2766 {
2767 if (type_instance->g_class)
2768 {
2769 TypeNode *node, *iface;
2770 gboolean is_instantiatable, check;
2771
2772 node = lookup_type_node_I (type_instance->g_class->g_type);
2773 is_instantiatable = node && node->is_instantiatable;
2774 iface = lookup_type_node_I (iface_type);
2775 check = is_instantiatable && iface && type_node_conforms_to_U (node, iface, TRUE, FALSE);
2776 if (check)
2777 return type_instance;
2778
2779 if (is_instantiatable)
2780 g_warning ("invalid cast from `%s' to `%s'",
2781 type_descriptive_name_I (type_instance->g_class->g_type),
2782 type_descriptive_name_I (iface_type));
2783 else
2784 g_warning ("invalid uninstantiatable type `%s' in cast to `%s'",
2785 type_descriptive_name_I (type_instance->g_class->g_type),
2786 type_descriptive_name_I (iface_type));
2787 }
2788 else
2789 g_warning ("invalid unclassed pointer in cast to `%s'",
2790 type_descriptive_name_I (iface_type));
2791 }
2792
2793 return type_instance;
2794 }
2795
2796 GTypeClass*
2797 g_type_check_class_cast (GTypeClass *type_class,
2798 GType is_a_type)
2799 {
2800 if (type_class)
2801 {
2802 TypeNode *node, *iface;
2803 gboolean is_classed, check;
2804
2805 node = lookup_type_node_I (type_class->g_type);
2806 is_classed = node && node->is_classed;
2807 iface = lookup_type_node_I (is_a_type);
2808 check = is_classed && iface && type_node_conforms_to_U (node, iface, FALSE, FALSE);
2809 if (check)
2810 return type_class;
2811
2812 if (is_classed)
2813 g_warning ("invalid class cast from `%s' to `%s'",
2814 type_descriptive_name_I (type_class->g_type),
2815 type_descriptive_name_I (is_a_type));
2816 else
2817 g_warning ("invalid unclassed type `%s' in class cast to `%s'",
2818 type_descriptive_name_I (type_class->g_type),
2819 type_descriptive_name_I (is_a_type));
2820 }
2821 else
2822 g_warning ("invalid class cast from (NULL) pointer to `%s'",
2823 type_descriptive_name_I (is_a_type));
2824 return type_class;
2825 }
2826
2827 gboolean
2828 g_type_check_instance (GTypeInstance *type_instance)
2829 {
2830 /* this function is just here to make the signal system
2831 * conveniently elaborated on instance checks
2832 */
2833 if (type_instance)
2834 {
2835 if (type_instance->g_class)
2836 {
2837 TypeNode *node = lookup_type_node_I (type_instance->g_class->g_type);
2838
2839 if (node && node->is_instantiatable)
2840 return TRUE;
2841
2842 g_warning ("instance of invalid non-instantiatable type `%s'",
2843 type_descriptive_name_I (type_instance->g_class->g_type));
2844 }
2845 else
2846 g_warning ("instance with invalid (NULL) class pointer");
2847 }
2848 else
2849 g_warning ("invalid (NULL) pointer instance");
2850
2851 return FALSE;
2852 }
2853
2854 static inline gboolean
2855 type_check_is_value_type_U (GType type)
2856 {
2857 GTypeFlags tflags = G_TYPE_FLAG_VALUE_ABSTRACT;
2858 TypeNode *node;
2859
2860 /* common path speed up */
2861 node = lookup_type_node_I (type);
2862 if (node && node->mutatable_check_cache)
2863 return TRUE;
2864
2865 G_READ_LOCK (&type_rw_lock);
2866 restart_check:
2867 if (node)
2868 {
2869 if (node->data && node->data->common.ref_count > 0 &&
2870 node->data->common.value_table->value_init)
2871 tflags = GPOINTER_TO_UINT (type_get_qdata_L (node, static_quark_type_flags));
2872 else if (NODE_IS_IFACE (node))
2873 {
2874 guint i;
2875
2876 for (i = 0; i < IFACE_NODE_N_PREREQUISITES (node); i++)
2877 {
2878 GType prtype = IFACE_NODE_PREREQUISITES (node)[i];
2879 TypeNode *prnode = lookup_type_node_I (prtype);
2880
2881 if (prnode->is_instantiatable)
2882 {
2883 type = prtype;
2884 node = lookup_type_node_I (type);
2885 goto restart_check;
2886 }
2887 }
2888 }
2889 }
2890 G_READ_UNLOCK (&type_rw_lock);
2891
2892 return !(tflags & G_TYPE_FLAG_VALUE_ABSTRACT);
2893 }
2894
2895 gboolean
2896 g_type_check_is_value_type (GType type)
2897 {
2898 return type_check_is_value_type_U (type);
2899 }
2900
2901 gboolean
2902 g_type_check_value (GValue *value)
2903 {
2904 return value && type_check_is_value_type_U (value->g_type);
2905 }
2906
2907 gboolean
2908 g_type_check_value_holds (GValue *value,
2909 GType type)
2910 {
2911 return value && type_check_is_value_type_U (value->g_type) && g_type_is_a (value->g_type, type);
2912 }
2913
2914 GTypeValueTable*
2915 g_type_value_table_peek (GType type)
2916 {
2917 GTypeValueTable *vtable = NULL;
2918 TypeNode *node = lookup_type_node_I (type);
2919 gboolean has_refed_data, has_table;
2920 TypeData *data;
2921
2922 /* speed up common code path, we're not 100% safe here,
2923 * but we should only get called with referenced types anyway
2924 */
2925 data = node ? node->data : NULL;
2926 if (node && node->mutatable_check_cache)
2927 return data->common.value_table;
2928
2929 G_READ_LOCK (&type_rw_lock);
2930
2931 restart_table_peek:
2932 has_refed_data = node && node->data && node->data->common.ref_count;
2933 has_table = has_refed_data && node->data->common.value_table->value_init;
2934 if (has_refed_data)
2935 {
2936 if (has_table)
2937 vtable = node->data->common.value_table;
2938 else if (NODE_IS_IFACE (node))
2939 {
2940 guint i;
2941
2942 for (i = 0; i < IFACE_NODE_N_PREREQUISITES (node); i++)
2943 {
2944 GType prtype = IFACE_NODE_PREREQUISITES (node)[i];
2945 TypeNode *prnode = lookup_type_node_I (prtype);
2946
2947 if (prnode->is_instantiatable)
2948 {
2949 type = prtype;
2950 node = lookup_type_node_I (type);
2951 goto restart_table_peek;
2952 }
2953 }
2954 }
2955 }
2956
2957 G_READ_UNLOCK (&type_rw_lock);
2958
2959 if (vtable)
2960 return vtable;
2961
2962 if (!node)
2963 g_warning (G_STRLOC ": type id `%lu' is invalid", type);
2964 if (!has_refed_data)
2965 g_warning ("can't peek value table for type `%s' which is not currently referenced",
2966 type_descriptive_name_I (type));
2967
2968 return NULL;
2969 }
2970
2971 G_CONST_RETURN gchar*
2972 g_type_name_from_instance (GTypeInstance *instance)
2973 {
2974 if (!instance)
2975 return "<NULL-instance>";
2976 else
2977 return g_type_name_from_class (instance->g_class);
2978 }
2979
2980 G_CONST_RETURN gchar*
2981 g_type_name_from_class (GTypeClass *g_class)
2982 {
2983 if (!g_class)
2984 return "<NULL-class>";
2985 else
2986 return g_type_name (g_class->g_type);
2987 }
2988
2989
2990 /* --- foreign prototypes --- */
2991 extern void g_value_c_init (void); /* sync with gvalue.c */
2992 extern void g_value_types_init (void); /* sync with gvaluetypes.c */
2993 extern void g_enum_types_init (void); /* sync with genums.c */
2994 extern void g_param_type_init (void); /* sync with gparam.c */
2995 extern void g_boxed_type_init (void); /* sync with gboxed.c */
2996 extern void g_object_type_init (void); /* sync with gobject.c */
2997 extern void g_param_spec_types_init (void); /* sync with gparamspecs.c */
2998 extern void g_value_transforms_init (void); /* sync with gvaluetransform.c */
2999 extern void g_signal_init (void); /* sync with gsignal.c */
3000
3001
3002 /* --- initialization --- */
3003 void
3004 g_type_init_with_debug_flags (GTypeDebugFlags debug_flags)
3005 {
3006 G_LOCK_DEFINE_STATIC (type_init_lock);
3007 const gchar *env_string;
3008 GTypeInfo info;
3009 TypeNode *node;
3010 GType type;
3011
3012 G_LOCK (type_init_lock);
3013
3014 G_WRITE_LOCK (&type_rw_lock);
3015
3016 if (static_quark_type_flags)
3017 {
3018 G_WRITE_UNLOCK (&type_rw_lock);
3019 G_UNLOCK (type_init_lock);
3020 return;
3021 }
3022
3023 /* setup GObject library wide debugging flags */
3024 _g_type_debug_flags = debug_flags & G_TYPE_DEBUG_MASK;
3025 env_string = g_getenv ("GOBJECT_DEBUG");
3026 if (env_string != NULL)
3027 {
3028 static GDebugKey debug_keys[] = {
3029 { "objects", G_TYPE_DEBUG_OBJECTS },
3030 { "signals", G_TYPE_DEBUG_SIGNALS },
3031 };
3032
3033 _g_type_debug_flags |= g_parse_debug_string (env_string,
3034 debug_keys,
3035 sizeof (debug_keys) / sizeof (debug_keys[0]));
3036 env_string = NULL;
3037 }
3038
3039 /* quarks */
3040 static_quark_type_flags = g_quark_from_static_string ("-g-type-private--GTypeFlags");
3041 static_quark_iface_holder = g_quark_from_static_string ("-g-type-private--IFaceHolder");
3042 static_quark_dependants_array = g_quark_from_static_string ("-g-type-private--dependants-array");
3043
3044 /* type qname hash table */
3045 static_type_nodes_ht = g_hash_table_new (g_direct_hash, g_direct_equal);
3046
3047 /* invalid type G_TYPE_INVALID (0)
3048 */
3049 static_fundamental_type_nodes[0] = NULL;
3050
3051 /* void type G_TYPE_NONE
3052 */
3053 node = type_node_fundamental_new_W (G_TYPE_NONE, "void", 0);
3054 type = NODE_TYPE (node);
3055 g_assert (type == G_TYPE_NONE);
3056
3057 /* interface fundamental type G_TYPE_INTERFACE (!classed)
3058 */
3059 memset (&info, 0, sizeof (info));
3060 node = type_node_fundamental_new_W (G_TYPE_INTERFACE, "GInterface", G_TYPE_FLAG_DERIVABLE);
3061 type = NODE_TYPE (node);
3062 type_data_make_W (node, &info, NULL);
3063 g_assert (type == G_TYPE_INTERFACE);
3064
3065 G_WRITE_UNLOCK (&type_rw_lock);
3066
3067 g_value_c_init ();
3068
3069 /* G_TYPE_TYPE_PLUGIN
3070 */
3071 g_type_plugin_get_type ();
3072
3073 /* G_TYPE_* value types
3074 */
3075 g_value_types_init ();
3076
3077 /* G_TYPE_ENUM & G_TYPE_FLAGS
3078 */
3079 g_enum_types_init ();
3080
3081 /* G_TYPE_BOXED
3082 */
3083 g_boxed_type_init ();
3084
3085 /* G_TYPE_PARAM
3086 */
3087 g_param_type_init ();
3088
3089 /* G_TYPE_OBJECT
3090 */
3091 g_object_type_init ();
3092
3093 /* G_TYPE_PARAM_* pspec types
3094 */
3095 g_param_spec_types_init ();
3096
3097 /* Value Transformations
3098 */
3099 g_value_transforms_init ();
3100
3101 /* Signal system
3102 */
3103 g_signal_init ();
3104
3105 G_UNLOCK (type_init_lock);
3106 }
3107
3108 void
3109 g_type_init (void)
3110 {
3111 g_type_init_with_debug_flags (0);
3112 }
glib mirror