static int move_refined_method(st_data_t key, st_data_t value, st_data_t data) { rb_method_entry_t *me = (rb_method_entry_t *) value; st_table *tbl = (st_table *) data; if (me->def->type == VM_METHOD_TYPE_REFINED) { if (me->def->body.orig_me) { rb_method_entry_t *orig_me = me->def->body.orig_me, *new_me; me->def->body.orig_me = NULL; new_me = ALLOC(rb_method_entry_t); *new_me = *me; st_add_direct(tbl, key, (st_data_t) new_me); *me = *orig_me; xfree(orig_me); return ST_CONTINUE; } else { st_add_direct(tbl, key, (st_data_t) me); return ST_DELETE; } } else { return ST_CONTINUE; } }
/**Function******************************************************************** Synopsis [Performs the recursive step of Cuddaux_NodesBelowLevelRecur.] Description [Performs the recursive step of Cuddaux_NodesBelowLevelRecur. F is supposed to be a regular node. Returns 1 if successful, NULL otherwise. The background node is not put in the list if take_background==0 ] SideEffects [None] SeeAlso [] ******************************************************************************/ static int cuddauxNodesBelowLevelRecur(DdManager* manager, DdNode* F, int level, cuddaux_list_t** plist, st_table* visited, size_t max, size_t* psize, bool take_background) { int topF,res; if ((!take_background && F==DD_BACKGROUND(manager)) || st_is_member(visited, (char *) F) == 1){ return 1; } topF = cuddI(manager,F->index); if (topF < level){ res = cuddauxNodesBelowLevelRecur(manager, Cudd_Regular(cuddT(F)), level, plist, visited, max, psize, take_background); if (res==0) return 0; if (max == 0 || *psize<max){ res = cuddauxNodesBelowLevelRecur(manager, Cudd_Regular(cuddE(F)), level, plist, visited, max, psize, take_background); if (res==0) return 0; } } else { res = cuddaux_list_add(plist,F); (*psize)++; if (res==0) return 0; } if (st_add_direct(visited, (char *) F, NULL) == ST_OUT_OF_MEM){ cuddaux_list_free(*plist); return 0; } return 1; }
static VALUE set_syserr(int n, const char *name) { st_data_t error; if (!st_lookup(syserr_tbl, n, &error)) { error = rb_define_class_under(rb_mErrno, name, rb_eSystemCallError); /* capture nonblock errnos for WaitReadable/WaitWritable subclasses */ switch (n) { case EAGAIN: rb_eEAGAIN = error; #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN break; case EWOULDBLOCK: #endif rb_eEWOULDBLOCK = error; break; case EINPROGRESS: rb_eEINPROGRESS = error; break; } rb_define_const(error, "Errno", INT2NUM(n)); st_add_direct(syserr_tbl, n, error); } else { rb_define_const(rb_mErrno, name, error); } return error; }
VALUE rb_define_class(const char *name, VALUE super) { VALUE klass; ID id; id = rb_intern(name); if (rb_const_defined(rb_cObject, id)) { klass = rb_const_get(rb_cObject, id); if (TYPE(klass) != T_CLASS) { rb_raise(rb_eTypeError, "%s is not a class", name); } if (rb_class_real(RCLASS_SUPER(klass)) != super) { rb_name_error(id, "%s is already defined", name); } return klass; } if (!super) { rb_warn("no super class for `%s', Object assumed", name); } klass = rb_define_class_id(id, super); st_add_direct(rb_class_tbl, id, klass); rb_name_class(klass, id); rb_const_set(rb_cObject, id, klass); rb_class_inherited(super, klass); return klass; }
int st_add(st_table *table, long key, long val) { long record; int ret = 0; if(!st_lookup(table, key, &record)) { ret = st_add_direct(table, key, val); } return ret; }
static int init_case_fold_table(void) { const CaseFold_11_Type *p; const CaseUnfold_11_Type *p1; const CaseUnfold_12_Type *p2; const CaseUnfold_13_Type *p3; int i; THREAD_ATOMIC_START; FoldTable = st_init_numtable_with_size(1400); if (ONIG_IS_NULL(FoldTable)) return ONIGERR_MEMORY; for (i = 0; i < numberof(CaseFold); i++) { p = &CaseFold[i]; st_add_direct(FoldTable, (st_data_t )p->from, (st_data_t )&(p->to)); } for (i = 0; i < numberof(CaseFold_Locale); i++) { p = &CaseFold_Locale[i]; st_add_direct(FoldTable, (st_data_t )p->from, (st_data_t )&(p->to)); } Unfold1Table = st_init_numtable_with_size(1200); if (ONIG_IS_NULL(Unfold1Table)) return ONIGERR_MEMORY; for (i = 0; i < numberof(CaseUnfold_11); i++) { p1 = &CaseUnfold_11[i]; st_add_direct(Unfold1Table, (st_data_t )p1->from, (st_data_t )&(p1->to)); } for (i = 0; i < numberof(CaseUnfold_11_Locale); i++) { p1 = &CaseUnfold_11_Locale[i]; st_add_direct(Unfold1Table, (st_data_t )p1->from, (st_data_t )&(p1->to)); } Unfold2Table = st_init_table_with_size(&type_code2_hash, 200); if (ONIG_IS_NULL(Unfold2Table)) return ONIGERR_MEMORY; for (i = 0; i < numberof(CaseUnfold_12); i++) { p2 = &CaseUnfold_12[i]; st_add_direct(Unfold2Table, (st_data_t )p2->from, (st_data_t )(&p2->to)); } for (i = 0; i < numberof(CaseUnfold_12_Locale); i++) { p2 = &CaseUnfold_12_Locale[i]; st_add_direct(Unfold2Table, (st_data_t )p2->from, (st_data_t )(&p2->to)); } Unfold3Table = st_init_table_with_size(&type_code3_hash, 30); if (ONIG_IS_NULL(Unfold3Table)) return ONIGERR_MEMORY; for (i = 0; i < numberof(CaseUnfold_13); i++) { p3 = &CaseUnfold_13[i]; st_add_direct(Unfold3Table, (st_data_t )p3->from, (st_data_t )(&p3->to)); } CaseFoldInited = 1; THREAD_ATOMIC_END; return 0; }
static VALUE boot_defclass(const char *name, VALUE super) { extern st_table *rb_class_tbl; VALUE obj = rb_class_boot(super); ID id = rb_intern(name); rb_name_class(obj, id); st_add_direct(rb_class_tbl, id, obj); rb_const_set((rb_cObject ? rb_cObject : obj), id, obj); return obj; }
static int method_entry(ID key, NODE *body, st_table *list) { long type; if (key == ID_ALLOCATOR) return ST_CONTINUE; if (!st_lookup(list, key, 0)) { if (!body->nd_body) type = -1; /* none */ else type = VISI(body->nd_noex); st_add_direct(list, key, type); } return ST_CONTINUE; }
/** * Add entry into TABLE. * if already entried tye KEY, rewrite record by VAL. */ int st_rewrite(st_table *table, long key, long val) { long record; int ret = 0; st_table_entry *entry; entry = st_lookup(table, key, &record); if(!entry) { ret = st_add_direct(table, key, val); } else if(record != val) { entry->record = val; } return ret; }
static VALUE set_syserr(int n, const char *name) { VALUE error; if (!st_lookup(syserr_tbl, n, &error)) { error = rb_define_class_under(rb_mErrno, name, rb_eSystemCallError); rb_define_const(error, "Errno", INT2NUM(n)); st_add_direct(syserr_tbl, n, error); } else { rb_define_const(rb_mErrno, name, error); } return error; }
static const char * make_unique_str(st_table *tbl, const char *str, long len) { if (!str) { return NULL; } else { char *result; if ((result = keep_unique_str(tbl, str)) == NULL) { result = (char *)ruby_xmalloc(len+1); strncpy(result, str, len); result[len] = 0; st_add_direct(tbl, (st_data_t)result, 1); } return result; } }
static int method_entry_i(st_data_t key, st_data_t value, st_data_t data) { const rb_method_entry_t *me = (const rb_method_entry_t *)value; st_table *list = (st_table *)data; long type; if (!st_lookup(list, key, 0)) { if (UNDEFINED_METHOD_ENTRY_P(me)) { type = -1; /* none */ } else { type = VISI(me->flag); } st_add_direct(list, key, type); } return ST_CONTINUE; }
VALUE rb_define_module(const char *name) { VALUE module; ID id; id = rb_intern(name); if (rb_const_defined(rb_cObject, id)) { module = rb_const_get(rb_cObject, id); if (TYPE(module) == T_MODULE) return module; rb_raise(rb_eTypeError, "%s is not a module", rb_obj_classname(module)); } module = rb_define_module_id(id); st_add_direct(rb_class_tbl, id, module); rb_const_set(rb_cObject, id, module); return module; }
static int method_entry(ID key, const rb_method_entry_t *me, st_table *list) { long type; if (key == ID_ALLOCATOR) { return ST_CONTINUE; } if (!st_lookup(list, key, 0)) { if (!me || me->type == VM_METHOD_TYPE_UNDEF) { type = -1; /* none */ } else { type = VISI(me->flag); } st_add_direct(list, key, type); } return ST_CONTINUE; }
static int method_entry_i(st_data_t key, st_data_t value, st_data_t data) { const rb_method_entry_t *me = (const rb_method_entry_t *)value; st_table *list = (st_table *)data; long type; if (me && me->def->type == VM_METHOD_TYPE_REFINED) { me = rb_resolve_refined_method(Qnil, me, NULL); if (!me) return ST_CONTINUE; } if (!st_lookup(list, key, 0)) { if (UNDEFINED_METHOD_ENTRY_P(me)) { type = -1; /* none */ } else { type = VISI(me->flag); } st_add_direct(list, key, type); } return ST_CONTINUE; }
static DdNode * cuddauxAddCamlTransferRecur( DdManager * ddS, DdManager * ddD, DdNode * f, st_table * table) { DdNode *ft, *fe, *t, *e, *var, *res; DdNode *one, *zero; int index; /* Trivial cases. */ if (cuddIsConstant(f)){ value value = f->type.value; return (Cuddaux_addCamlConst(ddD,value)); } /* Check the cache. */ if(st_lookup(table, f, &res)) return(res); /* Recursive step. */ index = f->index; ft = cuddT(f); fe = cuddE(f); t = cuddauxAddCamlTransferRecur(ddS, ddD, ft, table); if (t == NULL) { return(NULL); } cuddRef(t); e = cuddauxAddCamlTransferRecur(ddS, ddD, fe, table); if (e == NULL) { Cudd_RecursiveDeref(ddD, t); return(NULL); } cuddRef(e); one = DD_ONE(ddD); zero = Cudd_Not(one); var = cuddUniqueInter(ddD,index,one,zero); if (var == NULL) { Cudd_RecursiveDeref(ddD, t); Cudd_RecursiveDeref(ddD, e); return(NULL); } res = cuddauxAddIteRecur(ddD,var,t,e); if (res == NULL) { Cudd_RecursiveDeref(ddD, t); Cudd_RecursiveDeref(ddD, e); return(NULL); } cuddRef(res); Cudd_RecursiveDeref(ddD, t); Cudd_RecursiveDeref(ddD, e); if (st_add_direct(table, (char *) f, (char *) res) == ST_OUT_OF_MEM) { Cudd_RecursiveDeref(ddD, res); return(NULL); } return(res); }
/**Function******************************************************************** Synopsis [Performs the recursive step of Extra_TransferPermute.] Description [Performs the recursive step of Extra_TransferPermute. Returns a pointer to the result if successful; NULL otherwise.] SideEffects [None] SeeAlso [extraTransferPermuteTime] ******************************************************************************/ static DdNode * extraTransferPermuteRecurTime( DdManager * ddS, DdManager * ddD, DdNode * f, st_table * table, int * Permute, int TimeOut ) { DdNode *ft, *fe, *t, *e, *var, *res; DdNode *one, *zero; int index; int comple = 0; statLine( ddD ); one = DD_ONE( ddD ); comple = Cudd_IsComplement( f ); /* Trivial cases. */ if ( Cudd_IsConstant( f ) ) return ( Cudd_NotCond( one, comple ) ); /* Make canonical to increase the utilization of the cache. */ f = Cudd_NotCond( f, comple ); /* Now f is a regular pointer to a non-constant node. */ /* Check the cache. */ if ( st_lookup( table, ( char * ) f, ( char ** ) &res ) ) return ( Cudd_NotCond( res, comple ) ); if ( TimeOut && TimeOut < clock() ) return NULL; /* Recursive step. */ if ( Permute ) index = Permute[f->index]; else index = f->index; ft = cuddT( f ); fe = cuddE( f ); t = extraTransferPermuteRecurTime( ddS, ddD, ft, table, Permute, TimeOut ); if ( t == NULL ) { return ( NULL ); } cuddRef( t ); e = extraTransferPermuteRecurTime( ddS, ddD, fe, table, Permute, TimeOut ); if ( e == NULL ) { Cudd_RecursiveDeref( ddD, t ); return ( NULL ); } cuddRef( e ); zero = Cudd_Not(ddD->one); var = cuddUniqueInter( ddD, index, one, zero ); if ( var == NULL ) { Cudd_RecursiveDeref( ddD, t ); Cudd_RecursiveDeref( ddD, e ); return ( NULL ); } res = cuddBddIteRecur( ddD, var, t, e ); if ( res == NULL ) { Cudd_RecursiveDeref( ddD, t ); Cudd_RecursiveDeref( ddD, e ); return ( NULL ); } cuddRef( res ); Cudd_RecursiveDeref( ddD, t ); Cudd_RecursiveDeref( ddD, e ); if ( st_add_direct( table, ( char * ) f, ( char * ) res ) == ST_OUT_OF_MEM ) { Cudd_RecursiveDeref( ddD, res ); return ( NULL ); } return ( Cudd_NotCond( res, comple ) ); } /* end of extraTransferPermuteRecurTime */