lib/eo.c

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