Eo: Clean up previous commit a bit.
[profile/ivi/eobj.git] / lib / eo.c
1 #include <Eina.h>
2
3 #include "Eo.h"
4 #include "eo_private.h"
5
6 #include "config.h"
7
8 /* The last id that should be reserved for statically allocated classes. */
9 #define EO_STATIC_IDS_LAST 10
10
11 /* Used inside the class_get functions of classes, see #EO_DEFINE_CLASS */
12 EAPI Eina_Lock _eo_class_creation_lock;
13 int _eo_log_dom = -1;
14
15 static Eo_Class **_eo_classes;
16 static Eo_Class_Id _eo_classes_last_id;
17 static Eina_Bool _eo_init_count = 0;
18
19 static void _eo_constructor(Eo *obj, const Eo_Class *klass);
20 static void _eo_destructor(Eo *obj, const Eo_Class *klass);
21 static inline Eina_Bool _eo_error_get(const Eo *obj);
22 static inline void _eo_error_unset(Eo *obj);
23 static inline void *_eo_data_get(const Eo *obj, const Eo_Class *klass);
24 static inline Eo *_eo_ref(Eo *obj);
25 static inline void _eo_unref(Eo *obj);
26
27 typedef struct
28 {
29    Eo_Op op;
30    const Eo_Class **kls_itr;
31 } Eo_Kls_Itr;
32
33 struct _Eo {
34      EINA_MAGIC
35      EINA_INLIST;
36      Eo *parent;
37      Eina_Inlist *children;
38      const Eo_Class *klass;
39      int refcount;
40 #ifndef NDEBUG
41      Eina_Inlist *xrefs;
42 #endif
43
44      Eina_List *composite_objects;
45
46      Eo_Kls_Itr mro_itr;
47
48      Eina_Bool composite:1;
49      Eina_Bool del:1;
50      Eina_Bool construct_error:1;
51      Eina_Bool manual_free:1;
52 };
53
54 /* Start of Dich */
55 /* Dich search, split to 0xff 0xff 0xffff */
56
57 #define DICH_CHAIN1_MASK (0xffff)
58 #define DICH_CHAIN_LAST_MASK (0xffff)
59 #define DICH_CHAIN1(x) (((x) >> 16) & DICH_CHAIN1_MASK)
60 #define DICH_CHAIN_LAST(x) ((x) & DICH_CHAIN_LAST_MASK)
61
62 #define OP_CLASS_OFFSET_GET(x) (((x) >> EO_OP_CLASS_OFFSET) & 0xffff)
63 #define OP_CLASS_GET(op) ({ \
64       Eo_Class_Id tmp = OP_CLASS_OFFSET_GET(op); \
65       ID_CLASS_GET(tmp); \
66       })
67 #define OP_SUB_ID_GET(op) ((op) & 0xffff)
68
69 #define ID_CLASS_GET(id) ({ \
70       (Eo_Class *) ((id <= _eo_classes_last_id) && (id > 0)) ? \
71       (_eo_classes[id - 1]) : NULL; \
72       })
73
74 #define EO_ALIGN_SIZE(size) \
75         ((size) + (sizeof(void *) - ((size) % sizeof(void *))))
76
77 /* Structure of Eo_Op is:
78  * 16bit: class
79  * 16bit: op.
80  */
81
82 typedef struct _Dich_Chain1 Dich_Chain1;
83
84 typedef struct
85 {
86    eo_op_func_type func;
87    const Eo_Class *src;
88 } op_type_funcs;
89
90 struct _Dich_Chain1
91 {
92    op_type_funcs *funcs;
93 };
94
95 typedef struct
96 {
97      EINA_INLIST;
98      const Eo_Class *klass;
99 } Eo_Extension_Node;
100
101 typedef struct
102 {
103      const Eo_Class *klass;
104      size_t offset;
105 } Eo_Extension_Data_Offset;
106
107 struct _Eo_Class
108 {
109    EINA_MAGIC
110    Eo_Class_Id class_id;
111    const Eo_Class *parent;
112    const Eo_Class_Description *desc;
113    Dich_Chain1 *chain; /**< The size is class_id */
114    Eina_Inlist *extensions;
115
116    Eo_Extension_Data_Offset *extn_data_off;
117    size_t extn_data_size;
118
119    const Eo_Class **mro;
120    Eo_Kls_Itr mro_itr;
121
122    size_t data_offset; /* < Offset of the data within object data. */
123
124    Eina_Bool constructed : 1;
125 };
126
127 static inline void
128 _dich_chain_alloc(Dich_Chain1 *chain1, size_t num_ops)
129 {
130    if (!chain1->funcs)
131      {
132         chain1->funcs = calloc(num_ops, sizeof(*(chain1->funcs)));
133      }
134 }
135
136 static inline void
137 _dich_copy_all(Eo_Class *dst, const Eo_Class *src)
138 {
139    if (!src->chain) return;
140
141    if (!dst->chain)
142      {
143         dst->chain = calloc(dst->class_id, sizeof(*dst->chain));
144      }
145
146    Eo_Class_Id i;
147    const Dich_Chain1 *sc1 = src->chain;
148    Dich_Chain1 *dc1 = dst->chain;
149    for (i = 0 ; i < src->class_id ; i++, sc1++, dc1++)
150      {
151         if (sc1->funcs)
152           {
153              size_t j;
154              const Eo_Class *op_klass = ID_CLASS_GET(i + 1);
155              /* Can be NULL because of future static classes. */
156              if (!op_klass)
157                 continue;
158
159              size_t num_ops = op_klass->desc->ops.count;
160              _dich_chain_alloc(dc1, num_ops);
161
162              const op_type_funcs *sf = sc1->funcs;
163              op_type_funcs *df = dc1->funcs;
164              for (j = 0 ; j < num_ops ; j++, df++, sf++)
165                {
166                   if (sf->func)
167                     {
168                        memcpy(df, sf, sizeof(*df));
169                     }
170                }
171           }
172      }
173 }
174
175 static inline const op_type_funcs *
176 _dich_func_get(const Eo_Class *klass, Eo_Op op)
177 {
178    if (!klass->chain) return NULL;
179
180    size_t idx1 = DICH_CHAIN1(op) - 1;
181    if (idx1 >= klass->class_id) return NULL;
182    const Dich_Chain1 *chain1 = &klass->chain[idx1];
183    if (!chain1->funcs) return NULL;
184
185    size_t idxl = DICH_CHAIN_LAST(op);
186    /* num_ops is calculated from the class. */
187    const Eo_Class *op_klass = ID_CLASS_GET(idx1 + 1);
188    if (!op_klass || (idxl >= op_klass->desc->ops.count))
189       return NULL;
190
191    return &chain1->funcs[idxl];
192 }
193
194 static inline void
195 _dich_func_set(Eo_Class *klass, Eo_Op op, eo_op_func_type func)
196 {
197    const Eo_Class *op_klass = OP_CLASS_GET(op);
198    size_t num_ops;
199
200    /* Verify op is valid. */
201    if (op_klass)
202      {
203         /* num_ops is calculated from the class. */
204         num_ops = op_klass->desc->ops.count;
205         if (DICH_CHAIN_LAST(op) >= num_ops)
206           {
207              ERR("OP %x is too big for the domain '%s', expected value < %x.",
208                    op, op_klass->desc->name, op_klass->desc->ops.count);
209              return;
210           }
211      }
212    else
213      {
214         ERR("OP %x is from an illegal class.", op);
215         return;
216      }
217
218    if (!klass->chain)
219      {
220         klass->chain = calloc(klass->class_id, sizeof(*klass->chain));
221      }
222
223    size_t idx1 = DICH_CHAIN1(op) - 1;
224    Dich_Chain1 *chain1 = &klass->chain[idx1];
225    _dich_chain_alloc(chain1, num_ops);
226    chain1->funcs[DICH_CHAIN_LAST(op)].func = func;
227    chain1->funcs[DICH_CHAIN_LAST(op)].src = klass;
228 }
229
230 static inline void
231 _dich_func_clean_all(Eo_Class *klass)
232 {
233    size_t i;
234    Dich_Chain1 *chain1 = klass->chain;
235
236    if (!chain1)
237       return;
238
239    for (i = 0 ; i < klass->class_id ; i++, chain1++)
240      {
241         if (chain1->funcs)
242            free(chain1->funcs);
243      }
244    free(klass->chain);
245    klass->chain = NULL;
246 }
247
248 /* END OF DICH */
249
250 static const Eo_Op_Description noop_desc =
251         EO_OP_DESCRIPTION(EO_NOOP, "", "No operation.");
252
253 static const Eo_Op_Description *
254 _eo_op_id_desc_get(Eo_Op op)
255 {
256    const Eo_Class *klass = OP_CLASS_GET(op);
257    Eo_Op sub_id = OP_SUB_ID_GET(op);
258
259    if (op == EO_NOOP)
260       return &noop_desc;
261
262    if (klass && (sub_id < klass->desc->ops.count))
263       return klass->desc->ops.descs + sub_id;
264
265    return NULL;
266 }
267
268 static const char *
269 _eo_op_id_name_get(Eo_Op op)
270 {
271    const Eo_Op_Description *desc = _eo_op_id_desc_get(op);
272    return (desc) ? desc->name : NULL;
273 }
274
275 static inline void
276 _eo_kls_itr_init(const Eo_Class *obj_klass, Eo_Kls_Itr *cur, Eo_Op op, Eo_Kls_Itr *prev_state)
277 {
278    prev_state->op = cur->op;
279    prev_state->kls_itr = cur->kls_itr;
280
281    /* If we are in a constructor/destructor or we changed an op - init. */
282    if ((op == EO_NOOP) || (cur->op != op))
283      {
284         cur->op = op;
285         cur->kls_itr = obj_klass->mro;
286      }
287 }
288
289 static inline void
290 _eo_kls_itr_end(Eo_Kls_Itr *cur, Eo_Kls_Itr *prev_state)
291 {
292    if (cur->op != prev_state->op)
293      {
294         cur->op = prev_state->op;
295         cur->kls_itr = prev_state->kls_itr;
296      }
297 }
298
299 static inline const Eo_Class *
300 _eo_kls_itr_get(Eo_Kls_Itr *cur)
301 {
302    return (cur->kls_itr) ? *(cur->kls_itr) : NULL;
303 }
304
305 static inline const Eo_Class *
306 _eo_kls_itr_next(Eo_Kls_Itr *cur, Eo_Op op)
307 {
308    if (cur->op != op)
309      {
310         Eo_Op node_op = cur->op;
311         ERR("Called with op %d ('%s') while expecting: %d ('%s'). This probaly means you called eo_*_super functions from a wrong place.",
312               op, _eo_op_id_name_get(op),
313               node_op, _eo_op_id_name_get(node_op));
314         return NULL;
315      }
316
317    const Eo_Class **kls_itr = cur->kls_itr;
318    if (*kls_itr)
319      {
320         if (op != EO_NOOP)
321           {
322              const op_type_funcs *fsrc = _dich_func_get(*kls_itr, op);
323
324              while (*kls_itr && (*(kls_itr++) != fsrc->src))
325                 ;
326           }
327         else
328           {
329              kls_itr++;
330           }
331
332         cur->kls_itr = kls_itr;
333         return *kls_itr;
334      }
335    else
336      {
337         return NULL;
338      }
339 }
340
341 static inline Eina_Bool
342 _eo_kls_itr_reached_end(const Eo_Kls_Itr *cur)
343 {
344    const Eo_Class **kls_itr = cur->kls_itr;
345    return !(*kls_itr && *(kls_itr + 1));
346 }
347
348 static inline const op_type_funcs *
349 _eo_kls_itr_func_get(const Eo_Class *klass, Eo_Kls_Itr *mro_itr, Eo_Op op, Eo_Kls_Itr *prev_state)
350 {
351    _eo_kls_itr_init(klass, mro_itr, op, prev_state);
352    klass = _eo_kls_itr_get(mro_itr);
353    if (klass)
354      {
355         const op_type_funcs *func = _dich_func_get(klass, op);
356
357         if (func && func->func)
358           {
359              return func;
360           }
361      }
362
363    return NULL;
364 }
365
366 #define _EO_OP_ERR_NO_OP_PRINT(op, klass) \
367    do \
368       { \
369          const Eo_Class *op_klass = OP_CLASS_GET(op); \
370          const char *_dom_name = (op_klass) ? op_klass->desc->name : NULL; \
371          ERR("Can't find func for op %x ('%s' of domain '%s') for class '%s'. Aborting.", \
372                op, _eo_op_id_name_get(op), _dom_name, \
373                (klass) ? klass->desc->name : NULL); \
374       } \
375    while (0)
376
377 static Eina_Bool
378 _eo_op_internal(Eo *obj, Eo_Op_Type op_type, Eo_Op op, va_list *p_list)
379 {
380    Eina_Bool ret = EINA_FALSE;
381
382 #ifndef NDEBUG
383    const Eo_Op_Description *op_desc = _eo_op_id_desc_get(op);
384
385    if (op_desc)
386      {
387         if (op_desc->op_type == EO_OP_TYPE_CLASS)
388           {
389              ERR("Tried calling a class op '%s' (%d) from a non-class context.", (op_desc) ? op_desc->name : NULL, op);
390              return EINA_FALSE;
391           }
392         else if ((op_type == EO_OP_TYPE_CONST) &&
393               (op_desc->op_type != EO_OP_TYPE_CONST))
394           {
395              ERR("Tried calling non-const or non-existant op '%s' (%d) from a const (query) function.", (op_desc) ? op_desc->name : NULL, op);
396              return EINA_FALSE;
397           }
398      }
399 #endif
400
401    Eo_Kls_Itr prev_state;
402
403      {
404         const op_type_funcs *func =
405            _eo_kls_itr_func_get(obj->klass, &obj->mro_itr, op, &prev_state);
406         if (func)
407           {
408              func->func(obj, _eo_data_get(obj, func->src), p_list);
409              ret = EINA_TRUE;
410              goto end;
411           }
412      }
413
414    /* Try composite objects */
415      {
416         Eina_List *itr;
417         Eo *emb_obj;
418         EINA_LIST_FOREACH(obj->composite_objects, itr, emb_obj)
419           {
420              if (_eo_op_internal(emb_obj, op_type, op, p_list))
421                {
422                   ret = EINA_TRUE;
423                   goto end;
424                }
425           }
426      }
427
428 end:
429    _eo_kls_itr_end(&obj->mro_itr, &prev_state);
430    return ret;
431 }
432
433 EAPI Eina_Bool
434 eo_do_internal(Eo *obj, Eo_Op_Type op_type, ...)
435 {
436    Eina_Bool ret = EINA_TRUE;
437    Eo_Op op = EO_NOOP;
438    va_list p_list;
439
440    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE);
441
442    _eo_ref(obj);
443
444    va_start(p_list, op_type);
445
446    op = va_arg(p_list, Eo_Op);
447    while (op)
448      {
449         if (!_eo_op_internal(obj, op_type, op, &p_list))
450           {
451              _EO_OP_ERR_NO_OP_PRINT(op, obj->klass);
452              ret = EINA_FALSE;
453              break;
454           }
455         op = va_arg(p_list, Eo_Op);
456      }
457
458    va_end(p_list);
459
460    _eo_unref(obj);
461    return ret;
462 }
463
464 EAPI Eina_Bool
465 eo_do_super_internal(Eo *obj, Eo_Op_Type op_type, Eo_Op op, ...)
466 {
467    const Eo_Class *nklass;
468    Eina_Bool ret = EINA_TRUE;
469    va_list p_list;
470    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE);
471
472    /* Advance the kls itr. */
473    nklass = _eo_kls_itr_next(&obj->mro_itr, op);
474
475    if (obj->mro_itr.op != op)
476       return EINA_FALSE;
477
478    va_start(p_list, op);
479    if (!_eo_op_internal(obj, op_type, op, &p_list))
480      {
481         _EO_OP_ERR_NO_OP_PRINT(op, nklass);
482         ret = EINA_FALSE;
483      }
484    va_end(p_list);
485
486    return ret;
487 }
488
489 static Eina_Bool
490 _eo_class_op_internal(Eo_Class *klass, Eo_Op op, va_list *p_list)
491 {
492    Eina_Bool ret = EINA_FALSE;
493
494 #ifndef NDEBUG
495    const Eo_Op_Description *op_desc = _eo_op_id_desc_get(op);
496
497    if (op_desc)
498      {
499         if (op_desc->op_type != EO_OP_TYPE_CLASS)
500           {
501              ERR("Tried calling an instant op '%s' (%d) from a class context.", (op_desc) ? op_desc->name : NULL, op);
502              return EINA_FALSE;
503           }
504      }
505 #endif
506
507    Eo_Kls_Itr prev_state;
508
509      {
510         const op_type_funcs *func =
511            _eo_kls_itr_func_get(klass, &klass->mro_itr, op, &prev_state);
512         if (func)
513           {
514              ((eo_op_func_type_class) func->func)(klass, p_list);
515              ret = EINA_TRUE;
516              goto end;
517           }
518      }
519
520 end:
521    _eo_kls_itr_end(&klass->mro_itr, &prev_state);
522    return ret;
523 }
524
525 EAPI Eina_Bool
526 eo_class_do_internal(const Eo_Class *klass, ...)
527 {
528    Eina_Bool ret = EINA_TRUE;
529    Eo_Op op = EO_NOOP;
530    va_list p_list;
531
532    EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, EINA_FALSE);
533
534    va_start(p_list, klass);
535
536    op = va_arg(p_list, Eo_Op);
537    while (op)
538      {
539         if (!_eo_class_op_internal((Eo_Class *) klass, op, &p_list))
540           {
541              _EO_OP_ERR_NO_OP_PRINT(op, klass);
542              ret = EINA_FALSE;
543              break;
544           }
545         op = va_arg(p_list, Eo_Op);
546      }
547
548    va_end(p_list);
549
550    return ret;
551 }
552
553 EAPI Eina_Bool
554 eo_class_do_super_internal(const Eo_Class *klass, Eo_Op op, ...)
555 {
556    const Eo_Class *nklass;
557    Eina_Bool ret = EINA_TRUE;
558    va_list p_list;
559    EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, EINA_FALSE);
560
561    /* Advance the kls itr. */
562    nklass = _eo_kls_itr_next(&((Eo_Class *) klass)->mro_itr, op);
563
564    if (klass->mro_itr.op != op)
565       return EINA_FALSE;
566
567    va_start(p_list, op);
568    if (!_eo_class_op_internal((Eo_Class *) klass, op, &p_list))
569      {
570         _EO_OP_ERR_NO_OP_PRINT(op, nklass);
571         ret = EINA_FALSE;
572      }
573    va_end(p_list);
574
575    return ret;
576 }
577
578 EAPI const Eo_Class *
579 eo_class_get(const Eo *obj)
580 {
581    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE);
582
583    return obj->klass;
584 }
585
586 EAPI const char *
587 eo_class_name_get(const Eo_Class *klass)
588 {
589    EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, NULL);
590
591    return klass->desc->name;
592 }
593
594 static void
595 _eo_class_base_op_init(Eo_Class *klass)
596 {
597    const Eo_Class_Description *desc = klass->desc;
598    if (!desc || !desc->ops.base_op_id)
599       return;
600
601    *(desc->ops.base_op_id) = EO_CLASS_ID_TO_BASE_ID(klass->class_id);
602 }
603
604 #ifndef NDEBUG
605 static Eina_Bool
606 _eo_class_mro_has(const Eo_Class *klass, const Eo_Class *find)
607 {
608    const Eo_Class **itr;
609    for (itr = klass->mro ; *itr ; itr++)
610      {
611         if (*itr == find)
612           {
613              return EINA_TRUE;
614           }
615      }
616
617    return EINA_FALSE;
618 }
619 #endif
620
621 static Eina_List *
622 _eo_class_mro_add(Eina_List *mro, const Eo_Class *klass)
623 {
624    Eina_List *extn_pos = NULL;
625    Eina_Bool check_consistency = !mro;
626    if (!klass)
627       return mro;
628
629    mro = eina_list_append(mro, klass);
630
631    /* Recursively add extenions. */
632      {
633         Eo_Extension_Node *extn;
634         EINA_INLIST_FOREACH(klass->extensions, extn)
635           {
636              mro = _eo_class_mro_add(mro, extn->klass);
637              /* Not possible: if (!mro) return NULL; */
638
639              if (check_consistency)
640                {
641                   extn_pos = eina_list_append(extn_pos, eina_list_last(mro));
642                }
643           }
644      }
645
646    /* Check if we can create a consistent mro. We only do it for the class
647     * we are working on (i.e no parents). */
648    if (check_consistency)
649      {
650         Eo_Extension_Node *extn;
651
652         Eina_List *itr = extn_pos;
653         EINA_INLIST_FOREACH(klass->extensions, extn)
654           {
655              /* Get the first one after the extension. */
656              Eina_List *extn_list = eina_list_next(eina_list_data_get(itr));
657
658              /* If we found the extension again. */
659              if (eina_list_data_find_list(extn_list, extn->klass))
660                {
661                   eina_list_free(mro);
662                   ERR("Cannot create a consistent method resolution order for class '%s' because of '%s'.", klass->desc->name, extn->klass->desc->name);
663                   return NULL;
664                }
665
666              itr = eina_list_next(itr);
667           }
668      }
669
670
671    mro = _eo_class_mro_add(mro, klass->parent);
672
673    return mro;
674 }
675
676 static Eina_Bool
677 _eo_class_mro_init(Eo_Class *klass)
678 {
679    Eina_List *mro = NULL;
680
681    DBG("Started creating MRO for class '%s'", klass->desc->name);
682    mro = _eo_class_mro_add(mro, klass);
683
684    if (!mro)
685       return EINA_FALSE;
686
687    /* Remove duplicates and make them the right order. */
688      {
689         Eina_List *itr1, *itr2, *itr2n;
690
691         itr1 = eina_list_last(mro);
692         while (itr1)
693           {
694              itr2 = eina_list_prev(itr1);
695
696              while (itr2)
697                {
698                   itr2n = eina_list_prev(itr2);
699
700                   if (eina_list_data_get(itr1) == eina_list_data_get(itr2))
701                     {
702                        mro = eina_list_remove_list(mro, itr2);
703                     }
704
705                   itr2 = itr2n;
706                }
707
708              itr1 = eina_list_prev(itr1);
709           }
710      }
711
712    /* Copy the mro and free the list. */
713      {
714         const Eo_Class *kls_itr;
715         const Eo_Class **mro_itr;
716         klass->mro = calloc(sizeof(*klass->mro), eina_list_count(mro) + 1);
717
718         mro_itr = klass->mro;
719
720         EINA_LIST_FREE(mro, kls_itr)
721           {
722              *(mro_itr++) = kls_itr;
723
724              DBG("Added '%s' to MRO", kls_itr->desc->name);
725           }
726         *(mro_itr) = NULL;
727      }
728
729    DBG("Finished creating MRO for class '%s'", klass->desc->name);
730
731    return EINA_TRUE;
732 }
733
734 static void
735 _eo_class_constructor(Eo_Class *klass)
736 {
737    if (klass->constructed)
738       return;
739
740    klass->constructed = EINA_TRUE;
741
742    if (klass->desc->class_constructor)
743       klass->desc->class_constructor(klass);
744 }
745
746 EAPI void
747 eo_class_funcs_set(Eo_Class *klass, const Eo_Op_Func_Description *func_descs)
748 {
749    EO_MAGIC_RETURN(klass, EO_CLASS_EINA_MAGIC);
750
751    const Eo_Op_Func_Description *itr;
752    itr = func_descs;
753    if (itr)
754      {
755         for ( ; itr->op != 0 ; itr++)
756           {
757              const Eo_Op_Description *op_desc = _eo_op_id_desc_get(itr->op);
758
759              if (EINA_LIKELY(op_desc && (itr->op_type == op_desc->op_type)))
760                {
761                   _dich_func_set(klass, itr->op, itr->func);
762                }
763              else
764                {
765                   ERR("Set function's op type (%d) is different than the one in the op description (%d) for op '%s' in class '%s'.", itr->op_type,
766                         (op_desc) ? op_desc->op_type : EO_OP_TYPE_REGULAR,
767                         (op_desc) ? op_desc->name : NULL,
768                         klass->desc->name);
769                }
770           }
771      }
772 }
773
774 static void
775 eo_class_free(Eo_Class *klass)
776 {
777    if (klass->constructed)
778      {
779         if (klass->desc->class_destructor)
780            klass->desc->class_destructor(klass);
781
782         _dich_func_clean_all(klass);
783      }
784
785      {
786         Eina_Inlist *itrn;
787         Eo_Extension_Node *extn = NULL;
788         EINA_INLIST_FOREACH_SAFE(klass->extensions, itrn, extn)
789           {
790              free(extn);
791           }
792      }
793
794    if (klass->mro)
795       free(klass->mro);
796
797    if (klass->extn_data_off)
798       free(klass->extn_data_off);
799
800    free(klass);
801 }
802
803 /* DEVCHECK */
804 static Eina_Bool
805 _eo_class_check_op_descs(const Eo_Class *klass, Eo_Class_Id id)
806 {
807    const Eo_Class_Description *desc = klass->desc;
808    const Eo_Op_Description *itr;
809    size_t i;
810
811    if (desc->ops.count > 0)
812      {
813         if (((id == 0) || (id > EO_STATIC_IDS_LAST)) && !desc->ops.base_op_id)
814           {
815              ERR("Class '%s' has a non-zero ops count, but base_id is NULL.",
816                    desc->name);
817              return EINA_FALSE;
818           }
819
820         if (!desc->ops.descs)
821           {
822              ERR("Class '%s' has a non-zero ops count, but there are no descs.",
823                    desc->name);
824              return EINA_FALSE;
825           }
826      }
827
828    itr = desc->ops.descs;
829    for (i = 0 ; i < desc->ops.count ; i++, itr++)
830      {
831         if (itr->sub_op != i)
832           {
833              if (itr->name)
834                {
835                   ERR("Wrong order in Ops description for class '%s'. Expected %d and got %d", desc->name, i, itr->sub_op);
836                }
837              else
838                {
839                   ERR("Found too few Ops description for class '%s'. Expected %d descriptions, but found %d.", desc->name, desc->ops.count, i);
840                }
841              return EINA_FALSE;
842           }
843      }
844
845    if (itr && itr->name)
846      {
847         ERR("Found extra Ops description for class '%s'. Expected %d descriptions, but found more.", desc->name, desc->ops.count);
848         return EINA_FALSE;
849      }
850
851    return EINA_TRUE;
852 }
853
854 EAPI const Eo_Class *
855 eo_class_new(const Eo_Class_Description *desc, Eo_Class_Id id, const Eo_Class *parent, ...)
856 {
857    Eo_Class *klass;
858    va_list p_list;
859
860    if (parent && !EINA_MAGIC_CHECK(parent, EO_CLASS_EINA_MAGIC))
861      {
862         EINA_MAGIC_FAIL(parent, EO_CLASS_EINA_MAGIC);
863         return NULL;
864      }
865
866    if (id > EO_STATIC_IDS_LAST)
867      {
868         ERR("Tried creating a class with the static id %d while the maximum static id is %d. Aborting.", id, EO_STATIC_IDS_LAST);
869         return NULL;
870      }
871
872    va_start(p_list, parent);
873
874    EINA_SAFETY_ON_NULL_RETURN_VAL(desc, NULL);
875    EINA_SAFETY_ON_NULL_RETURN_VAL(desc->name, NULL);
876
877    /* Check restrictions on Interface types. */
878    if (desc->type == EO_CLASS_TYPE_INTERFACE)
879      {
880         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->constructor, NULL);
881         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->destructor, NULL);
882         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->class_constructor, NULL);
883         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->class_destructor, NULL);
884         EINA_SAFETY_ON_FALSE_RETURN_VAL(!desc->data_size, NULL);
885      }
886
887    klass = calloc(1, sizeof(Eo_Class));
888    klass->parent = parent;
889
890    /* Handle class extensions */
891      {
892         Eo_Class *extn = NULL;
893
894         extn = va_arg(p_list, Eo_Class *);
895         while (extn)
896           {
897              switch (extn->desc->type)
898                {
899                 case EO_CLASS_TYPE_REGULAR:
900                 case EO_CLASS_TYPE_REGULAR_NO_INSTANT:
901                    /* Use it like an interface. */
902                 case EO_CLASS_TYPE_INTERFACE:
903                    break;
904                 case EO_CLASS_TYPE_MIXIN:
905                      {
906                         Eo_Extension_Node *node = calloc(1, sizeof(*node));
907                         node->klass = extn;
908                         klass->extensions =
909                            eina_inlist_append(klass->extensions,
910                                  EINA_INLIST_GET(node));
911                      }
912                    break;
913                }
914
915              extn = va_arg(p_list, Eo_Class *);
916           }
917      }
918
919    klass->desc = desc;
920
921    /* Handle the inheritance */
922    if (klass->parent)
923      {
924         /* Verify the inheritance is allowed. */
925         switch (klass->desc->type)
926           {
927            case EO_CLASS_TYPE_REGULAR:
928            case EO_CLASS_TYPE_REGULAR_NO_INSTANT:
929               if ((klass->parent->desc->type != EO_CLASS_TYPE_REGULAR) &&
930                     (klass->parent->desc->type != EO_CLASS_TYPE_REGULAR_NO_INSTANT))
931                 {
932                    ERR("Regular classes ('%s') aren't allowed to inherit from non-regular classes ('%s').", klass->desc->name, klass->parent->desc->name);
933                    goto cleanup;
934                 }
935               break;
936            case EO_CLASS_TYPE_INTERFACE:
937            case EO_CLASS_TYPE_MIXIN:
938               if ((klass->parent->desc->type != EO_CLASS_TYPE_INTERFACE) &&
939                     (klass->parent->desc->type != EO_CLASS_TYPE_MIXIN))
940                 {
941                    ERR("Non-regular classes ('%s') aren't allowed to inherit from regular classes ('%s').", klass->desc->name, klass->parent->desc->name);
942                    goto cleanup;
943                 }
944               break;
945           }
946
947
948         /* Update the current offset. */
949         /* FIXME: Make sure this alignment is enough. */
950         klass->data_offset = klass->parent->data_offset +
951            EO_ALIGN_SIZE(klass->parent->desc->data_size);
952      }
953
954    if (!_eo_class_check_op_descs(klass, id))
955      {
956         goto cleanup;
957      }
958
959    if (!_eo_class_mro_init(klass))
960      {
961         goto cleanup;
962      }
963
964    /* create MIXIN offset table. */
965      {
966         const Eo_Class **mro_itr = klass->mro;
967         Eo_Extension_Data_Offset *extn_data_itr;
968         size_t extn_num = 0;
969         size_t extn_data_off = klass->data_offset +
970            EO_ALIGN_SIZE(klass->desc->data_size);
971
972         /* FIXME: Make faster... */
973         while (*mro_itr)
974           {
975              if (((*mro_itr)->desc->type == EO_CLASS_TYPE_MIXIN) &&
976                    ((*mro_itr)->desc->data_size > 0))
977                {
978                   extn_num++;
979                }
980              mro_itr++;
981           }
982
983         klass->extn_data_off = calloc(extn_num + 1,
984               sizeof(*klass->extn_data_off));
985
986         extn_data_itr = klass->extn_data_off;
987         mro_itr = klass->mro;
988         while (*mro_itr)
989           {
990              if (((*mro_itr)->desc->type == EO_CLASS_TYPE_MIXIN) &&
991                    ((*mro_itr)->desc->data_size > 0))
992                {
993                   extn_data_itr->klass = *mro_itr;
994                   extn_data_itr->offset = extn_data_off;
995
996                   extn_data_off += EO_ALIGN_SIZE(extn_data_itr->klass->desc->data_size);
997                   extn_data_itr++;
998                }
999              mro_itr++;
1000           }
1001
1002         klass->extn_data_size = extn_data_off;
1003      }
1004
1005    eina_lock_take(&_eo_class_creation_lock);
1006
1007    if (id == 0)
1008      {
1009         klass->class_id = ++_eo_classes_last_id;
1010      }
1011    else
1012      {
1013 #ifndef NDEBUG
1014         if (_eo_classes && _eo_classes[id - 1])
1015           {
1016              ERR("A class with id %d was already defined (%s). Aborting.", id,
1017                    _eo_classes[id - 1]->desc->name);
1018              eina_lock_release(&_eo_class_creation_lock);
1019              goto cleanup;
1020           }
1021 #endif
1022         klass->class_id = id;
1023      }
1024
1025
1026      {
1027         /* FIXME: Handle errors. */
1028         size_t arrsize = _eo_classes_last_id * sizeof(*_eo_classes);
1029         Eo_Class **tmp;
1030         tmp = realloc(_eo_classes, arrsize);
1031
1032         /* If it's the first allocation, memset. */
1033         if (!_eo_classes)
1034            memset(tmp, 0, arrsize);
1035
1036         _eo_classes = tmp;
1037         _eo_classes[klass->class_id - 1] = klass;
1038      }
1039    eina_lock_release(&_eo_class_creation_lock);
1040
1041    EINA_MAGIC_SET(klass, EO_CLASS_EINA_MAGIC);
1042
1043    /* Flatten the function array */
1044      {
1045         const Eo_Class **mro_itr = klass->mro;
1046         for (  ; *mro_itr ; mro_itr++)
1047            ;
1048
1049         /* Skip ourselves. */
1050         for ( mro_itr-- ; mro_itr > klass->mro ; mro_itr--)
1051           {
1052              _dich_copy_all(klass, *mro_itr);
1053           }
1054      }
1055
1056    _eo_class_base_op_init(klass);
1057
1058    _eo_class_constructor(klass);
1059
1060    va_end(p_list);
1061
1062    return klass;
1063
1064 cleanup:
1065    eo_class_free(klass);
1066    return NULL;
1067 }
1068
1069 EAPI Eina_Bool
1070 eo_parent_set(Eo *obj, const Eo *parent)
1071 {
1072    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, EINA_FALSE);
1073    if (parent)
1074       EO_MAGIC_RETURN_VAL(parent, EO_EINA_MAGIC, EINA_FALSE);
1075
1076    if (obj->parent == parent)
1077       return EINA_TRUE;
1078
1079    _eo_ref(obj);
1080
1081    if (eo_composite_is(obj))
1082      {
1083         eo_composite_object_detach(obj->parent, obj);
1084      }
1085
1086    if (obj->parent)
1087      {
1088         obj->parent->children =
1089            eina_inlist_remove(obj->parent->children, EINA_INLIST_GET(obj));
1090         eo_xunref(obj, obj->parent);
1091      }
1092
1093    obj->parent = (Eo *) parent;
1094    if (obj->parent)
1095      {
1096         obj->parent->children =
1097            eina_inlist_append(obj->parent->children, EINA_INLIST_GET(obj));
1098         eo_xref(obj, obj->parent);
1099      }
1100
1101    _eo_unref(obj);
1102
1103    return EINA_TRUE;
1104 }
1105
1106 EAPI Eo *
1107 eo_add(const Eo_Class *klass, Eo *parent)
1108 {
1109    EO_MAGIC_RETURN_VAL(klass, EO_CLASS_EINA_MAGIC, NULL);
1110
1111    if (parent) EO_MAGIC_RETURN_VAL(parent, EO_EINA_MAGIC, NULL);
1112
1113    if (EINA_UNLIKELY(klass->desc->type != EO_CLASS_TYPE_REGULAR))
1114      {
1115         ERR("Class '%s' is not instantiate-able. Aborting.", klass->desc->name);
1116         return NULL;
1117      }
1118
1119    Eo *obj = calloc(1, EO_ALIGN_SIZE(sizeof(*obj)) +
1120          (klass->data_offset + EO_ALIGN_SIZE(klass->desc->data_size)) +
1121          klass->extn_data_size);
1122    EINA_MAGIC_SET(obj, EO_EINA_MAGIC);
1123    obj->refcount++;
1124    obj->klass = klass;
1125
1126    eo_parent_set(obj, parent);
1127
1128    Eo_Kls_Itr prev_state;
1129
1130    _eo_kls_itr_init(klass, &obj->mro_itr, EO_NOOP, &prev_state);
1131    _eo_error_unset(obj);
1132
1133    _eo_ref(obj);
1134    _eo_constructor(obj, klass);
1135
1136    if (EINA_UNLIKELY(_eo_error_get(obj)))
1137      {
1138         ERR("Type '%s' - One of the object constructors have failed.", klass->desc->name);
1139         goto fail;
1140      }
1141
1142    if (EINA_UNLIKELY(!_eo_kls_itr_reached_end(&obj->mro_itr)))
1143      {
1144         ERR("Type '%s' - Not all of the object constructors have been executed.", klass->desc->name);
1145         goto fail;
1146      }
1147    _eo_kls_itr_end(&obj->mro_itr, &prev_state);
1148    _eo_unref(obj);
1149
1150    return obj;
1151
1152 fail:
1153    _eo_kls_itr_end(&obj->mro_itr, &prev_state);
1154    /* Unref twice, once for the ref above, and once for the basic object ref. */
1155    _eo_unref(obj);
1156    _eo_unref(obj);
1157    return NULL;
1158 }
1159
1160 typedef struct
1161 {
1162    EINA_INLIST;
1163    const Eo *ref_obj;
1164    const char *file;
1165    int line;
1166 } Eo_Xref_Node;
1167
1168 EAPI Eo *
1169 eo_xref_internal(Eo *obj, const Eo *ref_obj, const char *file, int line)
1170 {
1171    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, obj);
1172
1173    _eo_ref(obj);
1174
1175 #ifndef NDEBUG
1176    Eo_Xref_Node *xref = calloc(1, sizeof(*xref));
1177    xref->ref_obj = ref_obj;
1178    xref->file = file;
1179    xref->line = line;
1180
1181    obj->xrefs = eina_inlist_prepend(obj->xrefs, EINA_INLIST_GET(xref));
1182 #else
1183    (void) ref_obj;
1184    (void) file;
1185    (void) line;
1186 #endif
1187
1188    return obj;
1189 }
1190
1191 EAPI void
1192 eo_xunref(Eo *obj, const Eo *ref_obj)
1193 {
1194    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1195 #ifndef NDEBUG
1196    Eo_Xref_Node *xref = NULL;
1197    EINA_INLIST_FOREACH(obj->xrefs, xref)
1198      {
1199         if (xref->ref_obj == ref_obj)
1200            break;
1201      }
1202
1203    if (xref)
1204      {
1205         obj->xrefs = eina_inlist_remove(obj->xrefs, EINA_INLIST_GET(xref));
1206         free(xref);
1207      }
1208    else
1209      {
1210         ERR("ref_obj (%p) does not reference obj (%p). Aborting unref.", ref_obj, obj);
1211         return;
1212      }
1213 #else
1214    (void) ref_obj;
1215 #endif
1216    _eo_unref(obj);
1217 }
1218
1219 static inline Eo *
1220 _eo_ref(Eo *obj)
1221 {
1222    obj->refcount++;
1223    return obj;
1224 }
1225
1226 EAPI Eo *
1227 eo_ref(const Eo *_obj)
1228 {
1229    Eo *obj = (Eo *) _obj;
1230    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, obj);
1231
1232    return _eo_ref(obj);
1233 }
1234
1235 static inline void
1236 _eo_del_internal(Eo *obj)
1237 {
1238    /* We need that for the event callbacks that may ref/unref. */
1239    obj->refcount++;
1240
1241    eo_do(obj, eo_event_callback_call(EO_EV_DEL, NULL, NULL));
1242
1243    const Eo_Class *klass = eo_class_get(obj);
1244    Eo_Kls_Itr prev_state;
1245
1246    _eo_kls_itr_init(klass, &obj->mro_itr, EO_NOOP, &prev_state);
1247    _eo_error_unset(obj);
1248    _eo_destructor(obj, klass);
1249    if (_eo_error_get(obj))
1250      {
1251         ERR("Type '%s' - One of the object destructors have failed.", klass->desc->name);
1252      }
1253
1254    if (!_eo_kls_itr_reached_end(&obj->mro_itr))
1255      {
1256         ERR("Type '%s' - Not all of the object destructors have been executed.", klass->desc->name);
1257      }
1258    _eo_kls_itr_end(&obj->mro_itr, &prev_state);
1259    /*FIXME: add eo_class_unref(klass) ? - just to clear the caches. */
1260
1261      {
1262         Eina_List *itr, *itr_n;
1263         Eo *emb_obj;
1264         EINA_LIST_FOREACH_SAFE(obj->composite_objects, itr, itr_n, emb_obj)
1265           {
1266              eo_composite_object_detach(obj, emb_obj);
1267           }
1268      }
1269
1270    while (obj->children)
1271      {
1272         eo_parent_set(EINA_INLIST_CONTAINER_GET(obj->children, Eo), NULL);
1273      }
1274
1275    obj->del = EINA_TRUE;
1276    obj->refcount--;
1277 }
1278
1279 static inline void
1280 _eo_free(Eo *obj)
1281 {
1282    EINA_MAGIC_SET(obj, EO_FREED_EINA_MAGIC);
1283    free(obj);
1284 }
1285
1286 static inline void
1287 _eo_unref(Eo *obj)
1288 {
1289    if (--(obj->refcount) == 0)
1290      {
1291         _eo_del_internal(obj);
1292
1293 #ifndef NDEBUG
1294         /* If for some reason it's not empty, clear it. */
1295         while (obj->xrefs)
1296           {
1297              WRN("obj->xrefs is not empty, possibly a bug, please report. - An error will be reported for each xref in the stack.");
1298              Eina_Inlist *nitr = obj->xrefs->next;
1299              free(EINA_INLIST_CONTAINER_GET(obj->xrefs, Eo_Xref_Node));
1300              obj->xrefs = nitr;
1301           }
1302 #endif
1303
1304         if (!obj->manual_free)
1305            _eo_free(obj);
1306         else
1307            _eo_ref(obj); /* If we manual free, we keep a phantom ref. */
1308      }
1309 }
1310
1311 EAPI void
1312 eo_unref(const Eo *_obj)
1313 {
1314    Eo *obj = (Eo *) _obj;
1315    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1316
1317    _eo_unref(obj);
1318 }
1319
1320 EAPI void
1321 eo_del(const Eo *obj)
1322 {
1323    eo_parent_set((Eo *) obj, NULL);
1324    eo_unref(obj);
1325 }
1326
1327 EAPI int
1328 eo_ref_get(const Eo *obj)
1329 {
1330    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, 0);
1331
1332    return obj->refcount;
1333 }
1334
1335 EAPI Eo *
1336 eo_parent_get(const Eo *obj)
1337 {
1338    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, NULL);
1339
1340    return obj->parent;
1341 }
1342
1343 EAPI void
1344 eo_error_set_internal(const Eo *obj, const char *file, int line)
1345 {
1346    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1347
1348    ERR("Error with obj '%p' at %s:%d", obj, file, line);
1349
1350    ((Eo *) obj)->construct_error = EINA_TRUE;
1351 }
1352
1353 static inline void
1354 _eo_error_unset(Eo *obj)
1355 {
1356    obj->construct_error = EINA_FALSE;
1357 }
1358
1359 /**
1360  * @internal
1361  * @brief Check if there was an error when constructing, destructing or calling a function of the object.
1362  * @param obj the object to work on.
1363  * @return @c EINA_TRUE if there was an error.
1364  */
1365 static inline Eina_Bool
1366 _eo_error_get(const Eo *obj)
1367 {
1368    return obj->construct_error;
1369 }
1370
1371 static inline void
1372 _eo_constructor_default(Eo *obj)
1373 {
1374    eo_constructor_super(obj);
1375 }
1376
1377 static inline void
1378 _eo_destructor_default(Eo *obj)
1379 {
1380    eo_destructor_super(obj);
1381 }
1382
1383 static void
1384 _eo_constructor(Eo *obj, const Eo_Class *klass)
1385 {
1386    if (!klass)
1387       return;
1388
1389    if (klass->desc->constructor)
1390       klass->desc->constructor(obj, _eo_data_get(obj, klass));
1391    else
1392       _eo_constructor_default(obj);
1393 }
1394
1395 static void
1396 _eo_destructor(Eo *obj, const Eo_Class *klass)
1397 {
1398    if (!klass)
1399       return;
1400
1401    if (klass->desc->destructor)
1402       klass->desc->destructor(obj, _eo_data_get(obj, klass));
1403    else
1404       _eo_destructor_default(obj);
1405 }
1406
1407 EAPI void
1408 eo_constructor_super(Eo *obj)
1409 {
1410    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1411
1412    _eo_constructor(obj, _eo_kls_itr_next(&obj->mro_itr, EO_NOOP));
1413 }
1414
1415 EAPI void
1416 eo_destructor_super(Eo *obj)
1417 {
1418    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1419
1420    _eo_destructor(obj, _eo_kls_itr_next(&obj->mro_itr, EO_NOOP));
1421 }
1422
1423 static inline void *
1424 _eo_data_get(const Eo *obj, const Eo_Class *klass)
1425 {
1426    if (EINA_LIKELY(klass->desc->data_size > 0))
1427      {
1428         if (EINA_UNLIKELY(klass->desc->type == EO_CLASS_TYPE_MIXIN))
1429           {
1430              Eo_Extension_Data_Offset *doff_itr =
1431                 eo_class_get(obj)->extn_data_off;
1432
1433              if (!doff_itr)
1434                 return NULL;
1435
1436              while (doff_itr->klass)
1437                {
1438                   if (doff_itr->klass == klass)
1439                      return ((char *) obj) + EO_ALIGN_SIZE(sizeof(*obj)) +
1440                            doff_itr->offset;
1441                   doff_itr++;
1442                }
1443           }
1444         else
1445           {
1446           return ((char *) obj) + EO_ALIGN_SIZE(sizeof(*obj)) +
1447              klass->data_offset;
1448           }
1449      }
1450
1451    return NULL;
1452 }
1453
1454 EAPI void *
1455 eo_data_get(const Eo *obj, const Eo_Class *klass)
1456 {
1457    void *ret;
1458    EO_MAGIC_RETURN_VAL(obj, EO_EINA_MAGIC, NULL);
1459
1460 #ifndef NDEBUG
1461    if (!_eo_class_mro_has(obj->klass, klass))
1462      {
1463         ERR("Tried getting data of class '%s' from object of class '%s', but the former is not a direct inheritance of the latter.", klass->desc->name, obj->klass->desc->name);
1464         return NULL;
1465      }
1466 #endif
1467
1468    ret = _eo_data_get(obj, klass);
1469
1470 #ifndef NDEBUG
1471    if (!ret && (klass->desc->data_size == 0))
1472      {
1473         ERR("Tried getting data of class '%s', but it has none..", klass->desc->name);
1474      }
1475 #endif
1476
1477    return ret;
1478 }
1479
1480 EAPI Eina_Bool
1481 eo_init(void)
1482 {
1483    const char *log_dom = "eo";
1484    if (_eo_init_count++ > 0)
1485       return EINA_TRUE;
1486
1487    eina_init();
1488
1489    _eo_classes = NULL;
1490    _eo_classes_last_id = EO_STATIC_IDS_LAST;
1491    _eo_log_dom = eina_log_domain_register(log_dom, EINA_COLOR_LIGHTBLUE);
1492    if (_eo_log_dom < 0)
1493      {
1494         EINA_LOG_ERR("Could not register log domain: %s", log_dom);
1495         return EINA_FALSE;
1496      }
1497
1498    if (!eina_lock_new(&_eo_class_creation_lock))
1499      {
1500         EINA_LOG_ERR("Could not init lock.");
1501         return EINA_FALSE;
1502      }
1503
1504    eina_magic_string_static_set(EO_EINA_MAGIC, EO_EINA_MAGIC_STR);
1505    eina_magic_string_static_set(EO_FREED_EINA_MAGIC,
1506          EO_FREED_EINA_MAGIC_STR);
1507    eina_magic_string_static_set(EO_CLASS_EINA_MAGIC,
1508          EO_CLASS_EINA_MAGIC_STR);
1509
1510    return EINA_TRUE;
1511 }
1512
1513 EAPI Eina_Bool
1514 eo_shutdown(void)
1515 {
1516    size_t i;
1517    Eo_Class **cls_itr = _eo_classes;
1518
1519    if (--_eo_init_count > 0)
1520       return EINA_TRUE;
1521
1522    for (i = 0 ; i < _eo_classes_last_id ; i++, cls_itr++)
1523      {
1524         if (*cls_itr)
1525            eo_class_free(*cls_itr);
1526      }
1527
1528    if (_eo_classes)
1529       free(_eo_classes);
1530
1531    eina_lock_free(&_eo_class_creation_lock);
1532
1533    eina_log_domain_unregister(_eo_log_dom);
1534    _eo_log_dom = -1;
1535
1536    eina_shutdown();
1537    return EINA_TRUE;
1538 }
1539
1540 EAPI void
1541 eo_composite_object_attach(Eo *obj, Eo *emb_obj)
1542 {
1543    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1544    EO_MAGIC_RETURN(emb_obj, EO_EINA_MAGIC);
1545
1546    emb_obj->composite = EINA_TRUE;
1547    eo_parent_set(emb_obj, obj);
1548    obj->composite_objects = eina_list_prepend(obj->composite_objects, emb_obj);
1549 }
1550
1551 EAPI void
1552 eo_composite_object_detach(Eo *obj, Eo *emb_obj)
1553 {
1554    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1555    EO_MAGIC_RETURN(emb_obj, EO_EINA_MAGIC);
1556
1557    emb_obj->composite = EINA_FALSE;
1558    obj->composite_objects = eina_list_remove(obj->composite_objects, emb_obj);
1559    eo_parent_set(emb_obj, NULL);
1560 }
1561
1562 EAPI Eina_Bool
1563 eo_composite_is(const Eo *emb_obj)
1564 {
1565    if (!EINA_MAGIC_CHECK(emb_obj, EO_EINA_MAGIC))
1566      {
1567         EINA_MAGIC_FAIL(emb_obj, EO_EINA_MAGIC);
1568         return EINA_FALSE;
1569      }
1570
1571    return emb_obj->composite;
1572 }
1573
1574 EAPI void
1575 eo_manual_free_set(Eo *obj, Eina_Bool manual_free)
1576 {
1577    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1578    obj->manual_free = manual_free;
1579 }
1580
1581 EAPI void
1582 eo_manual_free(Eo *obj)
1583 {
1584    EO_MAGIC_RETURN(obj, EO_EINA_MAGIC);
1585
1586    if (EINA_FALSE == obj->manual_free)
1587      {
1588         ERR("Tried to manually free the object %p while the option has not been set; see eo_manual_free_set for more information.", obj);
1589         return;
1590      }
1591
1592    if (!obj->del)
1593      {
1594         ERR("Tried deleting the object %p while still referenced(%d).", obj, eo_ref_get(obj));
1595         return;
1596      }
1597
1598    _eo_free(obj);
1599 }
1600