自学教程：C++ st_init_numtable函数代码示例

static VALUEfind_class_path(VALUE klass){    struct fc_result arg;    arg.name = 0;    arg.path = 0;    arg.klass = klass;    arg.track = rb_cObject;    arg.prev = 0;    if (RCLASS_CONST_TBL(rb_cObject)) {	st_foreach_safe(RCLASS_CONST_TBL(rb_cObject), fc_i, (st_data_t)&arg);    }    if (arg.path == 0) {	st_foreach_safe(rb_class_tbl, fc_i, (st_data_t)&arg);    }    if (arg.path) {	st_data_t tmp = tmp_classpath;	if (!RCLASS_IV_TBL(klass)) {	    RCLASS_IV_TBL(klass) = st_init_numtable();	}	st_insert(RCLASS_IV_TBL(klass), (st_data_t)classpath, arg.path);	st_delete(RCLASS_IV_TBL(klass), &tmp, 0);	return arg.path;    }    return Qnil;}

static voidlink_undef(const char *name, long base, struct relocation_info *reloc){    static int u_no = 0;    struct undef *obj;    char *addr = (char*)(reloc->r_address + base);    obj = (struct undef*)xmalloc(sizeof(struct undef));    obj->name = strdup(name);    obj->reloc = *reloc;    obj->base = base;    switch (R_LENGTH(reloc)) {      case 0:		/* byte */	obj->u.c = *addr;	break;      case 1:		/* word */	obj->u.s = *(short*)addr;	break;      case 2:		/* long */	obj->u.l = *(long*)addr;	break;    }    if (reloc_tbl == NULL) {	reloc_tbl = st_init_numtable();    }    st_insert(reloc_tbl, u_no++, obj);}

VALUErb_obj_singleton_methods(int argc, VALUE *argv, VALUE obj){    VALUE recur, ary, klass, origin;    st_table *list, *mtbl;    if (argc == 0) {	recur = Qtrue;    }    else {	rb_scan_args(argc, argv, "01", &recur);    }    klass = CLASS_OF(obj);    origin = RCLASS_ORIGIN(klass);    list = st_init_numtable();    if (klass && FL_TEST(klass, FL_SINGLETON)) {	if ((mtbl = RCLASS_M_TBL(origin)) != 0)	    st_foreach(mtbl, method_entry_i, (st_data_t)list);	klass = RCLASS_SUPER(klass);    }    if (RTEST(recur)) {	while (klass && (FL_TEST(klass, FL_SINGLETON) || RB_TYPE_P(klass, T_ICLASS))) {	    if (klass != origin && (mtbl = RCLASS_M_TBL(klass)) != 0)		st_foreach(mtbl, method_entry_i, (st_data_t)list);	    klass = RCLASS_SUPER(klass);	}    }    ary = rb_ary_new();    st_foreach(list, ins_methods_i, ary);    st_free_table(list);    return ary;}

voidrb_prepend_module(VALUE klass, VALUE module){    void rb_vm_check_redefinition_by_prepend(VALUE klass);    VALUE origin;    int changed = 0;    rb_frozen_class_p(klass);    Check_Type(module, T_MODULE);    OBJ_INFECT(klass, module);    origin = RCLASS_ORIGIN(klass);    if (origin == klass) {	origin = class_alloc(T_ICLASS, klass);	RCLASS_SET_SUPER(origin, RCLASS_SUPER(klass));	RCLASS_SET_SUPER(klass, origin);	RCLASS_ORIGIN(klass) = origin;	RCLASS_M_TBL(origin) = RCLASS_M_TBL(klass);	RCLASS_M_TBL(klass) = st_init_numtable();	st_foreach(RCLASS_M_TBL(origin), move_refined_method,		   (st_data_t) RCLASS_M_TBL(klass));    }    changed = include_modules_at(klass, klass, module);    if (changed < 0)	rb_raise(rb_eArgError, "cyclic prepend detected");    if (changed) {	rb_clear_cache();	rb_vm_check_redefinition_by_prepend(klass);    }}

static VALUEclass_instance_method_list(int argc, VALUE *argv, VALUE mod, int obj, int (*func) (st_data_t, st_data_t, st_data_t)){    VALUE ary;    int recur, prepended = 0;    st_table *list;    if (argc == 0) {	recur = TRUE;    }    else {	VALUE r;	rb_scan_args(argc, argv, "01", &r);	recur = RTEST(r);    }    if (!recur && RCLASS_ORIGIN(mod) != mod) {	mod = RCLASS_ORIGIN(mod);	prepended = 1;    }    list = st_init_numtable();    for (; mod; mod = RCLASS_SUPER(mod)) {	if (RCLASS_M_TBL(mod)) st_foreach(RCLASS_M_TBL(mod), method_entry_i, (st_data_t)list);	if (BUILTIN_TYPE(mod) == T_ICLASS && !prepended) continue;	if (obj && FL_TEST(mod, FL_SINGLETON)) continue;	if (!recur) break;    }    ary = rb_ary_new();    st_foreach(list, func, ary);    st_free_table(list);    return ary;}

VALUErb_obj_singleton_methods(int argc, VALUE *argv, VALUE obj){    VALUE recur, ary, klass;    st_table *list;    if (argc == 0) {	recur = Qtrue;    }    else {	rb_scan_args(argc, argv, "01", &recur);    }    klass = CLASS_OF(obj);    list = st_init_numtable();    if (klass && FL_TEST(klass, FL_SINGLETON)) {	st_foreach(RCLASS_M_TBL(klass), method_entry_i, (st_data_t)list);	klass = RCLASS_SUPER(klass);    }    if (RTEST(recur)) {	while (klass && (FL_TEST(klass, FL_SINGLETON) || TYPE(klass) == T_ICLASS)) {	    st_foreach(RCLASS_M_TBL(klass), method_entry_i, (st_data_t)list);	    klass = RCLASS_SUPER(klass);	}    }    ary = rb_ary_new();    st_foreach(list, ins_methods_i, ary);    st_free_table(list);    return ary;}

/* :nodoc: */VALUErb_mod_init_copy(VALUE clone, VALUE orig){    if (RB_TYPE_P(clone, T_CLASS)) {	class_init_copy_check(clone, orig);    }    rb_obj_init_copy(clone, orig);    if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) {	RBASIC_SET_CLASS(clone, rb_singleton_class_clone(orig));	rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);    }    RCLASS_SET_SUPER(clone, RCLASS_SUPER(orig));    RCLASS_EXT(clone)->allocator = RCLASS_EXT(orig)->allocator;    if (RCLASS_IV_TBL(orig)) {	st_data_t id;	if (RCLASS_IV_TBL(clone)) {	    st_free_table(RCLASS_IV_TBL(clone));	}	RCLASS_IV_TBL(clone) = rb_st_copy(clone, RCLASS_IV_TBL(orig));	CONST_ID(id, "__tmp_classpath__");	st_delete(RCLASS_IV_TBL(clone), &id, 0);	CONST_ID(id, "__classpath__");	st_delete(RCLASS_IV_TBL(clone), &id, 0);	CONST_ID(id, "__classid__");	st_delete(RCLASS_IV_TBL(clone), &id, 0);    }    if (RCLASS_CONST_TBL(orig)) {	struct clone_const_arg arg;	if (RCLASS_CONST_TBL(clone)) {	    rb_free_const_table(RCLASS_CONST_TBL(clone));	}	RCLASS_CONST_TBL(clone) = st_init_numtable();	arg.klass = clone;	arg.tbl = RCLASS_CONST_TBL(clone);	st_foreach(RCLASS_CONST_TBL(orig), clone_const_i, (st_data_t)&arg);    }    if (RCLASS_M_TBL(orig)) {	if (RCLASS_M_TBL(clone)) {	    rb_free_m_table(RCLASS_M_TBL(clone));	}	RCLASS_M_TBL(clone) = st_init_numtable();	st_foreach(RCLASS_M_TBL(orig), clone_method_i, (st_data_t)clone);    }    return clone;}

void init_kgio_tryopen(void){	VALUE mKgio = rb_define_module("Kgio");	VALUE mPipeMethods = rb_const_get(mKgio, rb_intern("PipeMethods"));	VALUE cFile;	VALUE tmp;	VALUE *ptr;	long len;	id_path = rb_intern("path");	id_for_fd = rb_intern("for_fd");	id_to_path = rb_intern("to_path");	/*	 * Document-class: Kgio::File	 *	 * This subclass of the core File class adds the "tryopen" singleton	 * method for opening files.  A single "tryopen" and check for the	 * return value may be used to avoid unnecessary stat(2) syscalls	 * or File.open exceptions when checking for the existence of a file	 * and opening it.	 */	cFile = rb_define_class_under(mKgio, "File", rb_cFile);	rb_define_singleton_method(cFile, "tryopen", s_tryopen, -1);	rb_include_module(cFile, mPipeMethods);	if (!rb_funcall(cFile, rb_intern("method_defined?"), 1,	                ID2SYM(id_to_path)))		rb_define_alias(cFile, "to_path", "path");	errno2sym = st_init_numtable();	tmp = rb_funcall(rb_mErrno, rb_intern("constants"), 0);	ptr = RARRAY_PTR(tmp);	len = RARRAY_LEN(tmp);	for (; --len >= 0; ptr++) {		VALUE error;		ID const_id;		switch (TYPE(*ptr)) {		case T_SYMBOL: const_id = SYM2ID(*ptr); break;		case T_STRING: const_id = rb_intern(RSTRING_PTR(*ptr)); break;		default: rb_bug("constant not a symbol or string");		}		error = rb_const_get(rb_mErrno, const_id);		if ((TYPE(error) != T_CLASS) ||		    !rb_const_defined(error, rb_intern("Errno")))			continue;		error = rb_const_get(error, rb_intern("Errno"));		switch (TYPE(error)) {		case T_FIXNUM:		case T_BIGNUM:			st_insert(errno2sym, (st_data_t)NUM2INT(error),			          ID2SYM(const_id));		}	}}

VALUErb_module_new(void){    VALUE mdl = class_alloc(T_MODULE, rb_cModule);    RCLASS_M_TBL(mdl) = st_init_numtable();    return (VALUE)mdl;}

/* *  Creates a numeric hash whose keys are the currently active threads and *  whose values are their associated contexts. */VALUEcreate_threads_table(void){  threads_table_t *t_tbl;  t_tbl = ALLOC(threads_table_t);  t_tbl->tbl = st_init_numtable();  return Data_Wrap_Struct(cThreadsTable, t_tbl_mark, t_tbl_free, t_tbl);}

voidrb_singleton_class_attached(VALUE klass, VALUE obj){    if (FL_TEST(klass, FL_SINGLETON)) {	if (!RCLASS(klass)->iv_tbl) {	    RCLASS(klass)->iv_tbl = st_init_numtable();	}	st_insert(RCLASS(klass)->iv_tbl, rb_intern("__attached__"), obj);    }}

/*! * Attach a object to a singleton class. * @pre /a klass is the singleton class of /a obj. */voidrb_singleton_class_attached(VALUE klass, VALUE obj){    if (FL_TEST(klass, FL_SINGLETON)) {	if (!RCLASS_IV_TBL(klass)) {	    RCLASS_IV_TBL(klass) = st_init_numtable();	}	st_insert(RCLASS_IV_TBL(klass), id_attached, obj);    }}

static VALUEstackprof_start(int argc, VALUE *argv, VALUE self){    struct sigaction sa;    struct itimerval timer;    VALUE opts = Qnil, mode = Qnil, interval = Qnil;    if (_stackprof.running)	return Qfalse;    rb_scan_args(argc, argv, "0:", &opts);    if (RTEST(opts)) {	mode = rb_hash_aref(opts, sym_mode);	interval = rb_hash_aref(opts, sym_interval);    }    if (!RTEST(mode)) mode = sym_wall;    if (!_stackprof.frames) {	_stackprof.frames = st_init_numtable();	_stackprof.overall_signals = 0;	_stackprof.overall_samples = 0;	_stackprof.during_gc = 0;    }    if (mode == sym_object) {	if (!RTEST(interval)) interval = INT2FIX(1);	objtracer = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, stackprof_newobj_handler, 0);	rb_tracepoint_enable(objtracer);    } else if (mode == sym_wall || mode == sym_cpu) {	if (!RTEST(interval)) interval = INT2FIX(1000);	sa.sa_sigaction = stackprof_signal_handler;	sa.sa_flags = SA_RESTART | SA_SIGINFO;	sigemptyset(&sa.sa_mask);	sigaction(mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL);	timer.it_interval.tv_sec = 0;	timer.it_interval.tv_usec = NUM2LONG(interval);	timer.it_value = timer.it_interval;	setitimer(mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);    } else if (mode == sym_custom) {	/* sampled manually */	interval = Qnil;    } else {	rb_raise(rb_eArgError, "unknown profiler mode");    }    _stackprof.running = 1;    _stackprof.mode = mode;    _stackprof.interval = interval;    return Qtrue;}

/* :nodoc: */VALUErb_mod_init_copy(VALUE clone, VALUE orig){    rb_obj_init_copy(clone, orig);    if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) {	RBASIC(clone)->klass = rb_singleton_class_clone(orig);	rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);    }    RCLASS_SUPER(clone) = RCLASS_SUPER(orig);    if (RCLASS_IV_TBL(orig)) {	st_data_t id;	if (RCLASS_IV_TBL(clone)) {	    st_free_table(RCLASS_IV_TBL(clone));	}	RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(orig));	CONST_ID(id, "__classpath__");	st_delete(RCLASS_IV_TBL(clone), &id, 0);	CONST_ID(id, "__classid__");	st_delete(RCLASS_IV_TBL(clone), &id, 0);    }    if (RCLASS_CONST_TBL(orig)) {	if (RCLASS_CONST_TBL(clone)) {	    rb_free_const_table(RCLASS_CONST_TBL(clone));	}	RCLASS_CONST_TBL(clone) = st_init_numtable();	st_foreach(RCLASS_CONST_TBL(orig), clone_const, (st_data_t)RCLASS_CONST_TBL(clone));    }    if (RCLASS_M_TBL(orig)) {	struct clone_method_data data;	if (RCLASS_M_TBL(clone)) {	    rb_free_m_table(RCLASS_M_TBL(clone));	}	data.tbl = RCLASS_M_TBL(clone) = st_init_numtable();	data.klass = clone;	st_foreach(RCLASS_M_TBL(orig), clone_method,		   (st_data_t)&data);    }    return clone;}

/*! * A utility function that wraps class_alloc. * * allocates a class and initializes safely. * /param super     a class from which the new class derives. * /return          a class object. * /pre  /a super must be a class. * /post the metaclass of the new class is Class. */VALUErb_class_boot(VALUE super){    VALUE klass = class_alloc(T_CLASS, rb_cClass);    RCLASS_SUPER(klass) = super;    RCLASS_M_TBL(klass) = st_init_numtable();    OBJ_INFECT(klass, super);    return (VALUE)klass;}

VALUErb_singleton_class_clone_and_attach(VALUE obj, VALUE attach){    VALUE klass = RBASIC(obj)->klass;    if (!FL_TEST(klass, FL_SINGLETON))	return klass;    else {	/* copy singleton(unnamed) class */	VALUE clone = class_alloc(RBASIC(klass)->flags, 0);	if (BUILTIN_TYPE(obj) == T_CLASS) {	    RBASIC_SET_CLASS(clone, clone);	}	else {	    RBASIC_SET_CLASS(clone, rb_singleton_class_clone(klass));	}	RCLASS_SET_SUPER(clone, RCLASS_SUPER(klass));	RCLASS_EXT(clone)->allocator = RCLASS_EXT(klass)->allocator;	if (RCLASS_IV_TBL(klass)) {	    RCLASS_IV_TBL(clone) = rb_st_copy(clone, RCLASS_IV_TBL(klass));	}	if (RCLASS_CONST_TBL(klass)) {	    struct clone_const_arg arg;	    RCLASS_CONST_TBL(clone) = st_init_numtable();	    arg.klass = clone;	    arg.tbl = RCLASS_CONST_TBL(clone);	    st_foreach(RCLASS_CONST_TBL(klass), clone_const_i, (st_data_t)&arg);	}	if (attach != Qundef) {	    rb_singleton_class_attached(clone, attach);	}	RCLASS_M_TBL(clone) = st_init_numtable();	st_foreach(RCLASS_M_TBL(klass), clone_method_i, (st_data_t)clone);	rb_singleton_class_attached(RBASIC(clone)->klass, clone);	FL_SET(clone, FL_SINGLETON);	return clone;    }}

voidrb_singleton_class_attached(VALUE klass, VALUE obj){    if (FL_TEST(klass, FL_SINGLETON)) {	ID attached;	if (!RCLASS_IV_TBL(klass)) {	    RCLASS_IV_TBL(klass) = st_init_numtable();	}	CONST_ID(attached, "__attached__");	st_insert(RCLASS_IV_TBL(klass), attached, obj);    }}

VALUErb_module_new(){    NEWOBJ(mdl, struct RClass);    OBJSETUP(mdl, rb_cModule, T_MODULE);    mdl->super = 0;    mdl->iv_tbl = 0;    mdl->m_tbl = 0;    mdl->m_tbl = st_init_numtable();    return (VALUE)mdl;}

VALUEhash_new(){	VALUE hash;	hash = NEW_OBJ(Hash);	OBJ_SETUP(hash, T_HASH);	BASIC(hash).klass = cHash;	BASIC(hash).reap = hash_reap;	HASH(hash)->ptr = st_init_numtable();	return (VALUE)hash;}

VALUErb_class_boot(VALUE super){    NEWOBJ(klass, struct RClass);    OBJSETUP(klass, rb_cClass, T_CLASS);    klass->super = super;    klass->iv_tbl = 0;    klass->m_tbl = 0;		/* safe GC */    klass->m_tbl = st_init_numtable();    OBJ_INFECT(klass, super);    return (VALUE)klass;}

VALUErb_singleton_class_clone(VALUE obj){    VALUE klass = RBASIC(obj)->klass;    if (!FL_TEST(klass, FL_SINGLETON))	return klass;    else {	struct clone_method_data data;	/* copy singleton(unnamed) class */	VALUE clone = class_alloc((RBASIC(klass)->flags & ~(FL_MARK)), 0);	if (BUILTIN_TYPE(obj) == T_CLASS) {	    RBASIC(clone)->klass = (VALUE)clone;	}	else {	    RBASIC(clone)->klass = rb_singleton_class_clone(klass);	}	RCLASS_SUPER(clone) = RCLASS_SUPER(klass);	if (RCLASS_IV_TBL(klass)) {	    RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(klass));	}	if (RCLASS_CONST_TBL(klass)) {	    RCLASS_CONST_TBL(clone) = st_init_numtable();	    st_foreach(RCLASS_CONST_TBL(klass), clone_const, (st_data_t)RCLASS_CONST_TBL(clone));	}	RCLASS_M_TBL(clone) = st_init_numtable();	data.tbl = RCLASS_M_TBL(clone);	data.klass = (VALUE)clone;	st_foreach(RCLASS_M_TBL(klass), clone_method,		   (st_data_t)&data);	rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);	FL_SET(clone, FL_SINGLETON);	return (VALUE)clone;    }}

static struct traceobj_arg *get_traceobj_arg(void){    if (tmp_trace_arg == 0) {	tmp_trace_arg = ALLOC_N(struct traceobj_arg, 1);	MEMZERO(tmp_trace_arg, struct traceobj_arg, 1);	tmp_trace_arg->running = 0;	tmp_trace_arg->keys = 0;	tmp_trace_arg->vals = VAL_COUNT | VAL_OLDCOUNT | VAL_TOTAL_AGE | VAL_MAX_AGE | VAL_MIN_AGE | VAL_MEMSIZE;	tmp_trace_arg->aggregate_table = st_init_table(&memcmp_hash_type);	tmp_trace_arg->object_table = st_init_numtable();	tmp_trace_arg->str_table = st_init_strtable();	tmp_trace_arg->freed_allocation_info = NULL;	tmp_trace_arg->lifetime_table = NULL;    }

static rbkit_logger * get_trace_logger() {  if (logger == 0) {    logger = ALLOC_N(rbkit_logger, 1);    logger->enabled = Qfalse;    logger->sampling_profiler_enabled = Qfalse;    logger->newobj_trace = 0;    logger->freeobj_trace = 0;    logger->object_table = st_init_numtable();    logger->str_table = st_init_strtable();    logger->sbuf = msgpack_sbuffer_new();    logger->msgpacker = msgpack_packer_new(logger->sbuf, msgpack_sbuffer_write);    logger->data = 0;  }  return logger;}

/* a modified version of include_class_new from class.c */static VALUEj_class_new(VALUE module, VALUE sup){#ifdef RUBY_19    VALUE klass = class_alloc(T_ICLASS, rb_cClass);#else    NEWOBJ(klass, struct RClass);    OBJSETUP(klass, rb_cClass, T_ICLASS);#endif    if (BUILTIN_TYPE(module) == T_ICLASS) {        module = KLASS_OF(module);    }    if (!RCLASS_IV_TBL(module)) {        RCLASS_IV_TBL(module) = (struct st_table *)st_init_numtable();    }    /* assign iv_tbl, m_tbl and super */    RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);    RCLASS_SUPER(klass) = sup;    if(TYPE(module) != T_OBJECT) {        RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);    }    else {        RCLASS_M_TBL(klass) = RCLASS_M_TBL(CLASS_OF(module));    }    /* */    if (TYPE(module) == T_ICLASS) {        KLASS_OF(klass) = KLASS_OF(module);    }    else {        KLASS_OF(klass) = module;    }    if(TYPE(module) != T_OBJECT) {        OBJ_INFECT(klass, module);        OBJ_INFECT(klass, sup);    }    return (VALUE)klass;}

static VALUEstruct_layout_allocate(VALUE klass){    StructLayout* layout;    VALUE obj;    obj = Data_Make_Struct(klass, StructLayout, struct_layout_mark, struct_layout_free, layout);    layout->rbFieldMap = Qnil;    layout->rbFieldNames = Qnil;    layout->rbFields = Qnil;    layout->fieldSymbolTable = st_init_numtable();    layout->base.ffiType = xcalloc(1, sizeof(*layout->base.ffiType));    layout->base.ffiType->size = 0;    layout->base.ffiType->alignment = 0;    layout->base.ffiType->type = FFI_TYPE_STRUCT;    return obj;}

static VALUEfiber_init(VALUE fibval, VALUE proc){    rb_fiber_t *fib = fiber_t_alloc(fibval);    rb_context_t *cont = &fib->cont;    rb_thread_t *th = &cont->saved_thread;    fiber_link_join(fib);    /* initialize cont */    cont->vm_stack = 0;    th->stack = 0;    th->stack_size = FIBER_VM_STACK_SIZE;    th->stack = ALLOC_N(VALUE, th->stack_size);    th->cfp = (void *)(th->stack + th->stack_size);    th->cfp--;    th->cfp->pc = 0;    th->cfp->sp = th->stack + 1;    th->cfp->bp = 0;    th->cfp->lfp = th->stack;    *th->cfp->lfp = 0;    th->cfp->dfp = th->stack;    th->cfp->self = Qnil;    th->cfp->flag = 0;    th->cfp->iseq = 0;    th->cfp->proc = 0;    th->cfp->block_iseq = 0;    th->tag = 0;    th->local_storage = st_init_numtable();    th->first_proc = proc;    MEMCPY(&cont->jmpbuf, &th->root_jmpbuf, rb_jmpbuf_t, 1);    return fibval;}

static VALUEreachable_objects_from(VALUE self, VALUE obj){    if (rb_objspace_markable_object_p(obj)) {	VALUE ret = rb_ary_new();	struct rof_data data;	if (rb_typeddata_is_kind_of(obj, &iow_data_type)) {	    obj = (VALUE)DATA_PTR(obj);	}	data.refs = st_init_numtable();	data.internals = rb_ary_new();	rb_objspace_reachable_objects_from(obj, reachable_object_from_i, &data);	st_foreach(data.refs, collect_values, (st_data_t)ret);	return ret;    }    else {	return Qnil;    }}

static VALUEfiber_new(VALUE klass, VALUE proc){    rb_context_t *cont = fiber_alloc(klass);    VALUE contval = cont->self;    rb_thread_t *th = &cont->saved_thread;    /* initialize */    cont->vm_stack = 0;    th->stack = 0;    th->stack_size = FIBER_VM_STACK_SIZE;    th->stack = ALLOC_N(VALUE, th->stack_size);    th->cfp = (void *)(th->stack + th->stack_size);    th->cfp--;    th->cfp->pc = 0;    th->cfp->sp = th->stack + 1;    th->cfp->bp = 0;    th->cfp->lfp = th->stack;    *th->cfp->lfp = 0;    th->cfp->dfp = th->stack;    th->cfp->self = Qnil;    th->cfp->flag = 0;    th->cfp->iseq = 0;    th->cfp->proc = 0;    th->cfp->block_iseq = 0;    th->tag = 0;    th->local_storage = st_init_numtable();    th->first_proc = proc;    MEMCPY(&cont->jmpbuf, &th->root_jmpbuf, rb_jmpbuf_t, 1);    return contval;}

/* :nodoc: */VALUErb_mod_init_copy(VALUE clone, VALUE orig){    rb_obj_init_copy(clone, orig);    if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) {	RBASIC(clone)->klass = singleton_class_clone_int(orig, clone);    }    RCLASS(clone)->super = RCLASS(orig)->super;    if (RCLASS(orig)->iv_tbl) {	ID id;	RCLASS(clone)->iv_tbl = st_copy(RCLASS(orig)->iv_tbl);	id = rb_intern("__classpath__");	st_delete(RCLASS(clone)->iv_tbl, (st_data_t*)&id, 0);	id = rb_intern("__classid__");	st_delete(RCLASS(clone)->iv_tbl, (st_data_t*)&id, 0);    }    if (RCLASS(orig)->m_tbl) { 	RCLASS(clone)->m_tbl = st_init_numtable();	st_foreach(RCLASS(orig)->m_tbl, (int (*)(...))clone_method, clone);    }    return clone;}