/* It works like: * 1 - boot smop, * 2 - init a new object, and set the methods * 3 - get a stack * 4 - call method 1 * 5 - lower the refcount (should init destruction) * 6 - call method 2 * 7 - call stack loop */ int main(int argc, char** argv) { printf("1..6\n"); smop_init(); SMOP__Object* obj = smop_lowlevel_alloc(sizeof(SMOP__ResponderInterface)); if (!obj) { printf("not "); } printf("ok 1 - object allocated successfully.\n"); SMOP__ResponderInterface* ri = (SMOP__ResponderInterface*)obj; ri->MESSAGE = custom_MESSAGE; ri->REFERENCE = smop_lowlevel_refcnt_inc; ri->RELEASE = smop_lowlevel_refcnt_dec; SMOP__Object* intrp = SMOP_DISPATCH(SMOP__INTPTR__InterpreterInstance, SMOP_RI(SMOP__INTPTR__InterpreterInstance), SMOP__ID__new, SMOP__NATIVE__capture_create(SMOP__INTPTR__InterpreterInstance, SMOP__INTPTR__InterpreterInstance, NULL, NULL)); if (!intrp) { printf("not "); } printf("ok 2 - got new interp successfully %p.\n",intrp); SMOP_DISPATCH(intrp, ri, SMOP__ID__new, NULL); /* At this point, the destruction code for the object will be put in * the stack. That's why we still can call the second method just * below that. The object will only be invalidated when the stack * loop is called. */ SMOP_RELEASE(intrp, obj); SMOP_DISPATCH(intrp, ri, SMOP__ID__invocant, NULL); SMOP_DISPATCH(intrp, SMOP_RI(intrp), SMOP__ID__loop, SMOP__NATIVE__capture_create(intrp, SMOP_REFERENCE(intrp,intrp), NULL, NULL)); SMOP_RELEASE(SMOP__INTPTR__InterpreterInstance, intrp); printf("ok 6 - finished succesfully.\n"); smop_destr(); return 0; }
smop_util_hash* smop_util_hash_copy(SMOP__Object* interpreter,smop_util_hash* hash) { smop_util_hash* ret = malloc(sizeof(smop_util_hash)); ret->size = hash->size; ret->content = calloc(ret->size,sizeof(smop_util_hash_bucket*)); int i; for (i=0;i < hash->size;i++) { smop_util_hash_bucket* bucket = hash->content[i]; smop_util_hash_bucket* new_bucket = bucket ? (smop_util_hash_bucket*) malloc(sizeof(smop_util_hash_bucket)) : NULL; ret->content[i] = new_bucket; while (bucket) { new_bucket->value = SMOP_REFERENCE(interpreter,bucket->value); new_bucket->key = SMOP_REFERENCE(interpreter,bucket->key); smop_util_hash_bucket* next = bucket->next; if (next) { smop_util_hash_bucket* new_next = (smop_util_hash_bucket*) malloc(sizeof(smop_util_hash_bucket)); new_bucket->next = new_next; new_bucket = new_next; } bucket = next; } if (new_bucket) new_bucket->next = NULL; } return ret; }