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 */