void save_classes( void )
{
CLASS_TYPE *cclass;
for ( cclass = class_first; cclass; cclass = cclass->next )
save_class( cclass );
return;
}
tid_t add_class(tid_t tid_of_struc)
{
//classes are built on top of structures, make sure there is one before continuing
if(!get_struc(tid_of_struc))
return BADNODE;
if(get_class(tid_of_struc))
{
return tid_of_struc;
}
class_t clas;
clas.flags = 0;
clas.tid = tid_of_struc;
clas.functions_ea.clear();
clas.parents_tid.clear();
clas.virt_table_ea = BADADDR;
save_class(&clas);
//DONE: add to classes index
add_class_at_idx(tid_of_struc, BADNODE);
return tid_of_struc;
}
/*
* Lazy initialization of class descriptor.
*/
void pmix_class_initialize(pmix_class_t *cls)
{
pmix_class_t *c;
pmix_construct_t* cls_construct_array;
pmix_destruct_t* cls_destruct_array;
int cls_construct_array_count;
int cls_destruct_array_count;
int i;
assert(cls);
/* Check to see if anyone initialized
this class before we got a chance to */
if (1 == cls->cls_initialized) {
return;
}
/*
* First calculate depth of class hierarchy
* And the number of constructors and destructors
*/
cls->cls_depth = 0;
cls_construct_array_count = 0;
cls_destruct_array_count = 0;
for (c = cls; c; c = c->cls_parent) {
if( NULL != c->cls_construct ) {
cls_construct_array_count++;
}
if( NULL != c->cls_destruct ) {
cls_destruct_array_count++;
}
cls->cls_depth++;
}
/*
* Allocate arrays for hierarchy of constructors and destructors
* plus for each a NULL-sentinel
*/
cls->cls_construct_array =
(void (**)(pmix_object_t*))malloc((cls_construct_array_count +
cls_destruct_array_count + 2) *
sizeof(pmix_construct_t) );
if (NULL == cls->cls_construct_array) {
perror("Out of memory");
exit(-1);
}
cls->cls_destruct_array =
cls->cls_construct_array + cls_construct_array_count + 1;
/*
* The constructor array is reversed, so start at the end
*/
cls_construct_array = cls->cls_construct_array + cls_construct_array_count;
cls_destruct_array = cls->cls_destruct_array;
c = cls;
*cls_construct_array = NULL; /* end marker for the constructors */
for (i = 0; i < cls->cls_depth; i++) {
if( NULL != c->cls_construct ) {
--cls_construct_array;
*cls_construct_array = c->cls_construct;
}
if( NULL != c->cls_destruct ) {
*cls_destruct_array = c->cls_destruct;
cls_destruct_array++;
}
c = c->cls_parent;
}
*cls_destruct_array = NULL; /* end marker for the destructors */
cls->cls_initialized = 1;
save_class(cls);
/* All done */
}
/*
* Lazy initialization of class descriptor.
*/
void opal_class_initialize(opal_class_t *cls)
{
opal_class_t *c;
opal_construct_t* cls_construct_array;
opal_destruct_t* cls_destruct_array;
int cls_construct_array_count;
int cls_destruct_array_count;
int i;
assert(cls);
/* Check to see if any other thread got in here and initialized
this class before we got a chance to */
if (1 == cls->cls_initialized) {
return;
}
opal_atomic_lock(&class_lock);
/* If another thread initializing this same class came in at
roughly the same time, it may have gotten the lock and
initialized. So check again. */
if (1 == cls->cls_initialized) {
opal_atomic_unlock(&class_lock);
return;
}
/*
* First calculate depth of class hierarchy
* And the number of constructors and destructors
*/
cls->cls_depth = 0;
cls_construct_array_count = 0;
cls_destruct_array_count = 0;
for (c = cls; c; c = c->cls_parent) {
if( NULL != c->cls_construct ) {
cls_construct_array_count++;
}
if( NULL != c->cls_destruct ) {
cls_destruct_array_count++;
}
cls->cls_depth++;
}
/*
* Allocate arrays for hierarchy of constructors and destructors
* plus for each a NULL-sentinel
*/
cls->cls_construct_array =
(void (**)(opal_object_t*))malloc((cls_construct_array_count +
cls_destruct_array_count + 2) *
sizeof(opal_construct_t) );
if (NULL == cls->cls_construct_array) {
perror("Out of memory");
exit(-1);
}
cls->cls_destruct_array =
cls->cls_construct_array + cls_construct_array_count + 1;
/*
* The constructor array is reversed, so start at the end
*/
cls_construct_array = cls->cls_construct_array + cls_construct_array_count;
cls_destruct_array = cls->cls_destruct_array;
c = cls;
*cls_construct_array = NULL; /* end marker for the constructors */
for (i = 0; i < cls->cls_depth; i++) {
if( NULL != c->cls_construct ) {
--cls_construct_array;
*cls_construct_array = c->cls_construct;
}
if( NULL != c->cls_destruct ) {
*cls_destruct_array = c->cls_destruct;
cls_destruct_array++;
}
c = c->cls_parent;
}
*cls_destruct_array = NULL; /* end marker for the destructors */
cls->cls_initialized = 1;
save_class(cls);
/* All done */
opal_atomic_unlock(&class_lock);
}
