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

/* :nodoc: */static VALUEenumerator_init_copy(VALUE obj, SEL sel, VALUE orig){    struct enumerator *ptr0, *ptr1;    ptr0 = enumerator_ptr(orig);    if (ptr0->fib) {	/* Fibers cannot be copied */	rb_raise(rb_eTypeError, "can't copy execution context");    }    Data_Get_Struct(obj, struct enumerator, ptr1);    if (!ptr1) {	rb_raise(rb_eArgError, "unallocated enumerator");    }    GC_WB(&ptr1->obj, ptr0->obj);    ptr1->sel = ptr0->sel;    if (ptr0->args != 0) {	GC_WB(&ptr1->args, ptr0->args);    }    ptr1->fib  = 0;    return obj;}

static VALUErb_source_init(VALUE self, SEL sel,    VALUE type, VALUE handle, VALUE mask, VALUE queue){    Check_Queue(queue);    rb_source_t *src = RSource(self);    src->source_enum = (source_enum_t) NUM2LONG(type);    dispatch_source_type_t c_type = rb_source_enum2type(src->source_enum);    assert(c_type != NULL);    uintptr_t c_handle = NUM2UINT(rb_Integer(handle));    unsigned long c_mask = NUM2LONG(mask);    dispatch_queue_t c_queue = RQueue(queue)->queue;    src->source = dispatch_source_create(c_type, c_handle, c_mask, c_queue);    assert(src->source != NULL);    rb_vm_block_t *block = get_prepared_block();    GC_WB(&src->event_handler, block);    GC_RETAIN(self); // apparently needed to ensure consistent counting    dispatch_set_context(src->source, (void *)self);    dispatch_source_set_event_handler_f(src->source, rb_source_event_handler);    GC_WB(&src->handle, handle);    if (rb_source_is_file(src) && rb_obj_is_kind_of(handle, rb_cIO)) {        dispatch_source_set_cancel_handler_f(src->source,          rb_source_close_handler);    }    rb_dispatch_resume(self, 0);    return self;}

static rb_vm_block_t *dup_block(rb_vm_block_t *src_b){    const size_t block_size = sizeof(rb_vm_block_t)	    + (sizeof(VALUE *) * src_b->dvars_size);    rb_vm_block_t *new_b = (rb_vm_block_t *)xmalloc(block_size);    memcpy(new_b, src_b, block_size);    new_b->proc = src_b->proc; // weak    GC_WB(&new_b->parent_block, src_b->parent_block);    GC_WB(&new_b->self, src_b->self);    new_b->flags = src_b->flags & ~VM_BLOCK_ACTIVE;    rb_vm_local_t *src_l = src_b->locals;    rb_vm_local_t **new_l = &new_b->locals;    while (src_l != NULL) {	GC_WB(new_l, xmalloc(sizeof(rb_vm_local_t)));	(*new_l)->name = src_l->name;	(*new_l)->value = src_l->value;	new_l = &(*new_l)->next;	src_l = src_l->next;    }    *new_l = NULL;    return new_b;}

rb_vm_method_t *rb_vm_get_method(VALUE klass, VALUE obj, ID mid, int scope){    SEL sel = 0;    IMP imp = NULL;    rb_vm_method_node_t *node = NULL;    // TODO honor scope    if (!rb_vm_lookup_method2((Class)klass, mid, &sel, &imp, &node)) {	rb_print_undef(klass, mid, 0);    }    Class k, oklass = (Class)klass;    while ((k = class_getSuperclass(oklass)) != NULL) {	if (!rb_vm_lookup_method(k, sel, NULL, NULL)) {	    break;	}	oklass = k;    }    Method method = class_getInstanceMethod((Class)klass, sel);    assert(method != NULL);    int arity;    rb_vm_method_node_t *new_node;    if (node == NULL) {	arity = rb_method_getNumberOfArguments(method) - 2;	new_node = NULL;    }    else {	arity = rb_vm_arity_n(node->arity);	new_node = (rb_vm_method_node_t *)xmalloc(sizeof(rb_vm_method_node_t));	memcpy(new_node, node, sizeof(rb_vm_method_node_t));    }    rb_vm_method_t *m = (rb_vm_method_t *)xmalloc(sizeof(rb_vm_method_t));    m->oclass = (VALUE)oklass;    m->rclass = klass;    GC_WB(&m->recv, obj);    m->sel = sel;    m->arity = arity;    GC_WB(&m->node, new_node);    // Let's allocate a static cache here, since a rb_vm_method_t must always    // point to the method it was created from.    struct mcache *c = (struct mcache *)xmalloc(sizeof(struct mcache));    if (new_node == NULL) {	fill_ocache(c, obj, oklass, imp, sel, method, arity);    }    else {	fill_rcache(c, oklass, sel, new_node);    }    GC_WB(&m->cache, c);    return m;}

/* :nodoc: */static VALUEname_err_mesg_new(VALUE obj, SEL sel, VALUE mesg, VALUE recv, VALUE method){    VALUE *ptr = ALLOC_N(VALUE, 3);    GC_WB(&ptr[0], mesg);    GC_WB(&ptr[1], recv);    GC_WB(&ptr[2], method);    return Data_Wrap_Struct(rb_cNameErrorMesg, NULL, NULL, ptr);}

static void *imp_rhash_keyEnumerator(void *rcv, SEL sel){    NEWOBJ(keyenum, rb_hash_keyenum_t);    keyenum->klass = rb_cRubyHashKeyEnumerator;    GC_WB(&keyenum->hash, rcv);    VALUE ary = rb_ary_new();    st_foreach_safe(RHASH(rcv)->tbl, keys_i, (st_data_t)ary);    GC_WB(&keyenum->keys, ary);     keyenum->pos = 0;    return keyenum;}

static VALUEbinding_dup(VALUE self, SEL sel){    VALUE bindval = binding_alloc(rb_cBinding);    rb_vm_binding_t *src, *dst;    GetBindingPtr(self, src);    GetBindingPtr(bindval, dst);    GC_WB(&dst->self, src->self);    GC_WB(&dst->next, src->next);    GC_WB(&dst->locals, src->locals);    GC_WB(&dst->outer_stack, src->outer_stack);    GC_WB(&dst->block, src->block);    return bindval;}

static VALUEthgroup_s_alloc(VALUE self, SEL sel){    rb_thread_group_t *t = (rb_thread_group_t *)xmalloc(	    sizeof(rb_thread_group_t));    t->enclosed = false;    GC_WB(&t->threads, rb_ary_new());    OBJ_UNTRUST(t->threads);    VALUE mutex = mutex_s_alloc(rb_cMutex, 0);    mutex_initialize(mutex, 0);    GC_WB(&t->mutex, mutex);    return Data_Wrap_Struct(self, NULL, NULL, t);}

static VALUEdefine_final(VALUE os, SEL sel, int argc, VALUE *argv){    VALUE obj, block;    rb_scan_args(argc, argv, "11", &obj, &block);    if (argc == 1) {	block = rb_block_proc();    }    else if (!rb_respond_to(block, rb_intern("call"))) {	rb_raise(rb_eArgError, "wrong type argument %s (should be callable)",		rb_obj_classname(block));    }    if (SPECIAL_CONST_P(obj)) {	rb_raise(rb_eArgError, "immediate types are not finalizable");    }    rb_vm_finalizer_t *finalizer = rb_objc_get_associative_ref((void *)obj,	    &finalizer_key);    if (finalizer == NULL) {	finalizer = (rb_vm_finalizer_t *)	    rb_objc_newobj(sizeof(rb_vm_finalizer_t *));	finalizer->klass = rb_cFinalizer;	finalizer->objid = rb_obj_id(obj, 0);	GC_WB(&finalizer->finalizers, rb_ary_new());	rb_objc_set_associative_ref((void *)obj, &finalizer_key, finalizer);	rb_vm_register_finalizer(finalizer);     }    rb_ary_push(finalizer->finalizers, block);        // For RubySpec conformance.    return rb_ary_new3(2, INT2FIX(rb_safe_level()), block);}

static VALUErb_mutex_lock(VALUE self, SEL sel){    rb_vm_thread_t *current = GetThreadPtr(rb_vm_current_thread());    rb_vm_mutex_t *m = GetMutexPtr(self);    rb_vm_thread_status_t prev_status;    if (m->thread == current) {	rb_raise(rb_eThreadError, "deadlock; recursive locking");    }    prev_status = current->status;    if (current->status == THREAD_ALIVE) {	current->status = THREAD_SLEEP;    }    current->wait_for_mutex_lock = true;    pthread_assert(pthread_mutex_lock(&m->mutex));    current->wait_for_mutex_lock = false;    current->status = prev_status;    m->thread = current;    if (current->mutexes == Qnil) {	GC_WB(&current->mutexes, rb_ary_new());	OBJ_UNTRUST(current->mutexes);    }    rb_ary_push(current->mutexes, self);    return self;}

static VALUEproc_dup(VALUE self){    VALUE procval = rb_proc_alloc(rb_cProc);    rb_proc_t *src, *dst;    GetProcPtr(self, src);    GetProcPtr(procval, dst);    dst->block = src->block;    GC_WB(&dst->block.proc, procval);    GC_WB(&dst->envval, src->envval);    dst->safe_level = src->safe_level;    dst->is_lambda = src->is_lambda;    return procval;}

static VALUErb_yaml_parser_set_input(VALUE self, SEL sel, VALUE input){    rb_yaml_parser_t *rbparser = RYAMLParser(self);    yaml_parser_t *parser = &rbparser->parser;    if (!NIL_P(input)) {	assert(parser != NULL);	if (TYPE(input) == T_STRING) {	    const char * instring = RSTRING_PTR(input);	    yaml_parser_set_input_string(parser,		    (const unsigned char *)(instring),		    strlen(instring));				}	else if (TYPE(input) == T_FILE) {	    yaml_parser_set_input(parser, rb_yaml_io_read_handler,		    (void *)input);	}	else {	    rb_raise(rb_eArgError, "invalid input for YAML parser: %s",		    rb_obj_classname(input));	}    }    GC_WB(&rbparser->input, input);    return input;}

static VALUErb_yaml_emitter_set_output(VALUE self, SEL sel, VALUE output){    rb_yaml_emitter_t *remitter = RYAMLEmitter(self);    GC_WB(&remitter->output, output);    yaml_emitter_t *emitter = &remitter->emitter;    if (!NIL_P(output)) {	switch (TYPE(output)) {	    case T_FILE:		yaml_emitter_set_output(emitter, rb_yaml_io_output_handler,			(void *)output);		break;	    case T_STRING:		yaml_emitter_set_output(emitter, rb_yaml_str_output_handler,			(void *)output);		break;	    default:		rb_raise(rb_eArgError, "unsupported YAML output type %s",			rb_obj_classname(output));	}	    }    return output;}

/* *  call-seq: *     prc.binding    => binding *   *  Returns the binding associated with <i>prc</i>. Note that *  <code>Kernel#eval</code> accepts either a <code>Proc</code> or a *  <code>Binding</code> object as its second parameter. *      *     def fred(param) *       proc {} *     end *      *     b = fred(99) *     eval("param", b.binding)   #=> 99 */static VALUEproc_binding(VALUE self, SEL sel){    rb_vm_block_t *block;    GetProcPtr(self, block);    rb_vm_binding_t *binding = (rb_vm_binding_t *)xmalloc(	    sizeof(rb_vm_binding_t));    binding->block = NULL;    GC_WB(&binding->self, block->self);    GC_WB(&binding->locals, block->locals);    binding->outer_stack = NULL;    return Data_Wrap_Struct(rb_cBinding, NULL, NULL, binding);}

voidrb_fd_init(volatile rb_fdset_t *fds){    fds->maxfd = 0;    GC_WB(&fds->fdset, ALLOC(fd_set));    FD_ZERO(fds->fdset);}

NODE*rb_node_newnode(enum node_type type, VALUE a0, VALUE a1, VALUE a2){    NODE *n = xmalloc(sizeof(struct RNode));    n->flags |= T_NODE;    nd_set_type(n, type);    GC_WB(&n->u1.value, a0);    GC_WB(&n->u2.value, a1);    GC_WB(&n->u3.value, a2);    // FIXME this retain is added because the parser is NOT GC-safe at this point    GC_RETAIN(n);    return n;}

VALUErhash_set_default(VALUE hash, SEL sel, VALUE ifnone){    rhash_modify(hash);    GC_WB(&RHASH(hash)->ifnone, ifnone);    RHASH(hash)->has_proc_default = false;    return ifnone;}

static VALUEthgroup_s_alloc(VALUE self, SEL sel){    rb_thread_group_t *t = (rb_thread_group_t *)xmalloc(	    sizeof(rb_thread_group_t));    t->enclosed = false;    GC_WB(&t->threads, rb_ary_new());    return Data_Wrap_Struct(rb_cThGroup, NULL, NULL, t);}

rb_vm_block_t *rb_vm_create_block(IMP imp, VALUE self, VALUE userdata){    rb_vm_block_t *b = rb_vm_prepare_block((void *)imp, VM_BLOCK_IFUNC, self,	    rb_vm_arity(0), // not used	    NULL, NULL, 0, 0);    GC_WB(&b->userdata, userdata);    return b;}

static VALUErb_yaml_resolver_initialize(VALUE self, SEL sel){    rb_yaml_resolver_t *resolver = RYAMLResolver(self);    CFMutableDictionaryRef d = CFDictionaryCreateMutable(NULL, 0, NULL,	    &kCFTypeDictionaryValueCallBacks);    GC_WB(&resolver->tags, d);    CFMakeCollectable(d);    return self;}

voidrb_fd_copy(rb_fdset_t *dst, const fd_set *src, int max){    int size = howmany(max, NFDBITS) * sizeof(fd_mask);    if (size < sizeof(fd_set)) size = sizeof(fd_set);    dst->maxfd = max;    GC_WB(&dst->fdset, xrealloc(dst->fdset, size));    memcpy(dst->fdset, src, size);}

PRIMITIVE voidvm_init_c_block(struct ruby_block_literal *b, void *imp, VALUE proc){    b->isa = &_NSConcreteAutoBlock;    b->flags = __MR_BLOCK_IS_GC | __MR_BLOCK_HAS_DESCRIPTOR;    b->reserved = 0;    b->imp = imp;    b->descriptor = &ruby_block_descriptor_value;    GC_WB(&b->ruby_proc, proc);}

static rb_sym_t *sym_alloc(VALUE str, ID id){    rb_sym_t *sym = (rb_sym_t *)xmalloc(sizeof(rb_sym_t));    assert(rb_cSymbol != 0);    sym->klass = rb_cSymbol;    GC_WB(&sym->str, str);    sym->id = id;    return sym;}

static VALUErhash_initialize(VALUE hash, SEL sel, int argc, const VALUE *argv){    rhash_modify(hash);    if (rb_block_given_p()) {	if (argc > 0) {	    rb_raise(rb_eArgError, "wrong number of arguments");	}	GC_WB(&RHASH(hash)->ifnone, rb_block_proc());	RHASH(hash)->has_proc_default = true;    }    else {	VALUE ifnone;	rb_scan_args(argc, argv, "01", &ifnone);	if (ifnone != Qnil) {	    GC_WB(&RHASH(hash)->ifnone, ifnone);	}    }    return hash;}

static VALUErhash_rehash(VALUE hash, SEL sel){    rhash_modify(hash);    st_table *tbl = st_init_table_with_size(RHASH(hash)->tbl->type,	    RHASH(hash)->tbl->num_entries);    rb_hash_foreach(hash, rhash_rehash_i, (VALUE)tbl);    //st_free_table(RHASH(hash)->tbl);    GC_WB(&RHASH(hash)->tbl, tbl);    return hash;}

static voidrange_init(VALUE range, VALUE beg, VALUE end, int exclude_end){    VALUE args[2];    args[0] = beg;    args[1] = end;    if (!FIXNUM_P(beg) || !FIXNUM_P(end)) {	VALUE v;	v = rb_rescue(range_check, (VALUE)args, range_failed, 0);	if (NIL_P(v))	    range_failed();    }    SET_EXCL(range, exclude_end);    GC_WB(&RANGE_BEG(range), beg);    GC_WB(&RANGE_END(range), end);}

static rb_vm_block_t *get_prepared_block(){    rb_vm_block_t *block = rb_vm_current_block();    if (block == NULL) {        rb_raise(rb_eArgError, "block not given");    }#if GCD_BLOCKS_COPY_DVARS    block = rb_vm_dup_block(block);    for (int i = 0; i < block->dvars_size; i++) {    	VALUE *slot = block->dvars[i];    	VALUE *new_slot = xmalloc(sizeof(VALUE));    	GC_WB(new_slot, *slot);    	GC_WB(&block->dvars[i], new_slot);    }#else    rb_vm_block_make_detachable_proc(block);#endif    GC_RETAIN(block);    return block;}

static VALUEmake_struct(VALUE name, VALUE members, VALUE klass){    VALUE nstr;    ID id;    long i, len;    OBJ_FREEZE(members);    if (NIL_P(name)) {	nstr = rb_class_new(klass);#if !WITH_OBJC	rb_make_metaclass(nstr, RBASIC(klass)->klass);#endif	rb_class_inherited(klass, nstr);    }    else {	/* old style: should we warn? */	name = rb_str_to_str(name);	id = rb_to_id(name);	if (!rb_is_const_id(id)) {	    rb_name_error(id, "identifier %s needs to be constant",		    StringValuePtr(name));	}	if (rb_const_defined_at(klass, id)) {	    rb_warn("redefining constant Struct::%s", StringValuePtr(name));	    rb_mod_remove_const(klass, ID2SYM(id));	}	nstr = rb_define_class_under(klass, rb_id2name(id), klass);    }    rb_ivar_set(nstr, id_members, members);    rb_objc_define_method(*(VALUE *)nstr, "alloc", struct_alloc, 0);    rb_objc_define_method(*(VALUE *)nstr, "new", rb_class_new_instance_imp, -1);    rb_objc_define_method(*(VALUE *)nstr, "[]", rb_class_new_instance_imp, -1);    rb_objc_define_method(*(VALUE *)nstr, "members", rb_struct_s_members_m, 0);    len = RARRAY_LEN(members);    for (i=0; i< len; i++) {	ID id = SYM2ID(RARRAY_AT(members, i));	if (rb_is_local_id(id) || rb_is_const_id(id)) {	    long j = i; /* Needed for block data reference. */	/* Struct attribute reader */	rb_objc_define_method(nstr, rb_id2name(id),		pl_imp_implementationWithBlock(^(VALUE obj) {		    return RSTRUCT_PTR(obj)[j];		}), 0);	/* Struct attribute writer */	rb_objc_define_method(nstr, rb_id2name(rb_id_attrset(id)),		pl_imp_implementationWithBlock(^(VALUE obj, VALUE val) {		    VALUE *ptr = RSTRUCT_PTR(obj);		    rb_struct_modify(obj);		    GC_WB(&ptr[i], val);		    return val;		}), 1);