static VALUE singleton_class_clone_int(VALUE obj, VALUE nklass) { VALUE klass = RBASIC(obj)->klass; if (!FL_TEST(klass, FL_SINGLETON)) return klass; else { /* copy singleton(unnamed) class */ NEWOBJ(clone, struct RClass); OBJSETUP(clone, 0, RBASIC(klass)->flags); if (BUILTIN_TYPE(obj) == T_CLASS) { RBASIC(clone)->klass = (VALUE)clone; } else { RBASIC(clone)->klass = rb_singleton_class_clone(klass); } clone->super = RCLASS(klass)->super; clone->iv_tbl = 0; clone->m_tbl = 0; if (RCLASS(klass)->iv_tbl) { clone->iv_tbl = st_copy(RCLASS(klass)->iv_tbl); } clone->m_tbl = st_init_numtable(); st_foreach(RCLASS(klass)->m_tbl, (int (*)(...))clone_method, NIL_P(nklass) ? (VALUE)clone : nklass); rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone); FL_SET(clone, FL_SINGLETON); return (VALUE)clone; } }
// Buffer methods static VALUE rb_buffer_alloc(VALUE klass, SEL sel) { NEWOBJ(s, rb_opencl_buffer_t); OBJSETUP(s, klass, RUBY_T_NATIVE); return (VALUE)s; }
static VALUE struct_alloc(VALUE klass) { VALUE size; long n; NEWOBJ(st, struct RStruct); OBJSETUP(st, klass, T_STRUCT); size = rb_struct_iv_get(klass, "__size__"); n = FIX2LONG(size); if (0 < n && n <= RSTRUCT_EMBED_LEN_MAX) { RBASIC(st)->flags &= ~RSTRUCT_EMBED_LEN_MASK; RBASIC(st)->flags |= n << RSTRUCT_EMBED_LEN_SHIFT; rb_mem_clear(st->as.ary, n); } else { if (n > 0) { GC_WB(&st->as.heap.ptr, xmalloc_ptrs(sizeof(VALUE) * n)); rb_mem_clear(st->as.heap.ptr, n); } else { st->as.heap.ptr = NULL; } st->as.heap.len = n; } return (VALUE)st; }
// Command queue methods static VALUE rb_command_queue_alloc(VALUE klass, SEL sel) { NEWOBJ(s, rb_opencl_command_queue_t); OBJSETUP(s, klass, RUBY_T_NATIVE); return (VALUE)s; }
static void add_module(VALUE self, VALUE module) { VALUE super = RCLASS_SUPER(rb_singleton_class(self)); #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) = (void*)st_init_numtable(); } RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module); RCLASS_M_TBL(klass) = RCLASS_M_TBL(module); RCLASS_SUPER(klass) = super; if (TYPE(module) == T_ICLASS) { KLASS_OF(klass) = KLASS_OF(module); } else { KLASS_OF(klass) = module; } OBJ_INFECT(klass, module); OBJ_INFECT(klass, super); RCLASS_SUPER(rb_singleton_class(self)) = (VALUE)klass; }
static VALUE include_class_new(VALUE module, VALUE super) { NEWOBJ(klass, struct RClass); OBJSETUP(klass, rb_cClass, T_ICLASS); if (BUILTIN_TYPE(module) == T_ICLASS) { module = RBASIC(module)->klass; } if (!RCLASS(module)->iv_tbl) { RCLASS(module)->iv_tbl = st_init_numtable(); } klass->iv_tbl = RCLASS(module)->iv_tbl; klass->m_tbl = RCLASS(module)->m_tbl; klass->super = super; if (TYPE(module) == T_ICLASS) { RBASIC(klass)->klass = RBASIC(module)->klass; } else { RBASIC(klass)->klass = module; } OBJ_INFECT(klass, module); OBJ_INFECT(klass, super); return (VALUE)klass; }
static VALUE rb_yaml_resolver_alloc(VALUE klass, SEL sel) { NEWOBJ(resolver, struct rb_yaml_resolver_s); OBJSETUP(resolver, klass, T_OBJECT); resolver->tags = NULL; return (VALUE)resolver; }
static VALUE rb_source_alloc(VALUE klass, SEL sel) { NEWOBJ(source, rb_source_t); OBJSETUP(source, klass, RUBY_T_NATIVE); source->suspension_count = 1; return (VALUE)source; }
VALUE mtserver_alloc(void) { NEWOBJ(mts,struct MTServer); OBJSETUP(mts,radical_mtServer,T_OBJECT); mts->workers=0; mts->avail=0; return (VALUE)mts; }
static VALUE rb_group_alloc(VALUE klass, SEL sel) { NEWOBJ(group, rb_group_t); OBJSETUP(group, klass, RUBY_T_NATIVE); group->suspension_count = 0; return (VALUE)group; }
static VALUE rb_queue_alloc(VALUE klass, SEL sel) { NEWOBJ(queue, rb_queue_t); OBJSETUP(queue, klass, RUBY_T_NATIVE); queue->suspension_count = 0; queue->should_release_queue = 0; return (VALUE)queue; }
static VALUE ludicrous_splat_iterate_proc_(VALUE val) { struct Ludicrous_Splat_Iterate_Proc_Data * data = (struct Ludicrous_Splat_Iterate_Proc_Data *)val; ID varname = rb_intern("ludicrous_splat_iterate_var"); /* Create a new scope */ NEWOBJ(scope, struct SCOPE); OBJSETUP(scope, 0, T_SCOPE); scope->super = ruby_scope->super; scope->local_tbl = ALLOC_N(ID, 4); scope->local_vars = ALLOC_N(VALUE, 4); scope->flags = SCOPE_MALLOC; /* Set the names of the scope's local variables */ scope->local_tbl[0] = 3; scope->local_tbl[1] = '_'; scope->local_tbl[2] = '~'; scope->local_tbl[3] = varname; /* And and their values */ scope->local_vars[0] = 3; scope->local_vars[1] = Qnil; scope->local_vars[2] = Qnil; scope->local_vars[3] = Qnil; ++scope->local_vars; scope->local_vars[0] = ruby_scope->local_vars[0]; /* $_ */ scope->local_vars[1] = ruby_scope->local_vars[1]; /* $~ */ /* Temporarily set ruby_scope to the new scope, so the proc being * created below will pick it up (it will be set back when this * function returns) */ ruby_scope = scope; /* Create a new proc */ VALUE proc = rb_proc_new( data->body, data->val); NODE * * var; Data_Get_Struct(proc, NODE *, var); /* Set the iterator's assignment node to set a local variable that the * iterator's body can retrieve */ *var = NEW_MASGN( 0, NEW_NODE( NODE_LASGN, varname, 0, 2)); /* And return the proc */ return proc; }
static VALUE rb_semaphore_alloc(VALUE klass, SEL sel) { NEWOBJ(s, rb_semaphore_t); OBJSETUP(s, klass, RUBY_T_NATIVE); s->sem = NULL; s->count = 0; return (VALUE)s; }
static VALUE rb_yaml_emitter_alloc(VALUE klass, SEL sel) { NEWOBJ(emitter, struct rb_yaml_emitter_s); OBJSETUP(emitter, klass, T_OBJECT); yaml_emitter_initialize(&emitter->emitter); emitter->output = Qnil; return (VALUE)emitter; }
/* * Allocates memory for a new array * Note: Implementation almost exactly the same * as Ruby 1.9.2 p0 (have to copy because static) */ static VALUE my_ary_alloc (VALUE klass) { NEWOBJ(ary, struct RArray); OBJSETUP((VALUE)ary, klass, T_ARRAY); FL_SET_EMBED((VALUE)ary); ARY_SET_EMBED_LEN((VALUE)ary, 0); return (VALUE)ary; }
inline static VALUE nucomp_s_new_internal(VALUE klass, VALUE real, VALUE imag) { NEWOBJ(obj, struct RComplex); OBJSETUP(obj, klass, T_COMPLEX); obj->real = real; obj->imag = imag; return (VALUE)obj; }
inline static VALUE nurat_s_new_internal(VALUE klass, VALUE num, VALUE den) { NEWOBJ(obj, struct RRational); OBJSETUP(obj, klass, T_RATIONAL); obj->num = num; obj->den = den; return (VALUE)obj; }
static VALUE ary_alloc(void) { NEWOBJ(ary, struct RArray); OBJSETUP(ary, rb_cArray, T_ARRAY); ary->len = 0; ary->ptr = 0; ary->aux.capa = 0; return (VALUE)ary; }
VALUE rb_data_object_alloc(VALUE klass, void *datap, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree) { NEWOBJ(data, struct RData); if (klass) Check_Type(klass, T_CLASS); OBJSETUP(data, klass, T_DATA); GC_WB(&data->data, datap); data->dfree = dfree; data->dmark = dmark; return (VALUE)data; }
static VALUE rb_yaml_parser_alloc(VALUE klass, SEL sel) { NEWOBJ(parser, struct rb_yaml_parser_s); OBJSETUP(parser, klass, T_OBJECT); GC_WB(&parser->resolver, rb_oDefaultResolver); parser->event_valid = false; yaml_parser_initialize(&parser->parser); return (VALUE)parser; }
VALUE rb_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; }
/** * Allocates a struct RClass for a new class. * * \param flags initial value for basic.flags of the returned class. * \param klass the class of the returned class. * \return an uninitialized Class object. * \pre \p klass must refer \c Class class or an ancestor of Class. * \pre \code (flags | T_CLASS) != 0 \endcode * \post the returned class can safely be \c #initialize 'd. * * \note this function is not Class#allocate. */ static VALUE class_alloc(VALUE flags, VALUE klass) { rb_classext_t *ext = ALLOC(rb_classext_t); NEWOBJ(obj, struct RClass); OBJSETUP(obj, klass, flags); obj->ptr = ext; RCLASS_IV_TBL(obj) = 0; RCLASS_M_TBL(obj) = 0; RCLASS_SUPER(obj) = 0; RCLASS_IV_INDEX_TBL(obj) = 0; return (VALUE)obj; }
VALUE rb_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; }
static VALUE range_dumper(VALUE range) { VALUE v; NEWOBJ(m, struct RObject); OBJSETUP(m, rb_cObject, T_OBJECT); v = (VALUE)m; rb_ivar_set(v, id_excl, RANGE_EXCL(range)); rb_ivar_set(v, id_beg, RANGE_BEG(range)); rb_ivar_set(v, id_end, RANGE_END(range)); return v; }
static VALUE callwith_cleanup(VALUE self) { /* We don't want to keep the ivar table pointer around indefinitely, * because if we do, the GC will free the ivar table, which is * undesirable, since the original object still references it. So we * set the ivar table back to something that won't get freed, instead. */ NEWOBJ(dummy, struct RObject); OBJSETUP(dummy, rb_cCallWith, T_OBJECT); struct RBasic basic = *(RBASIC(self)); *(ROBJECT(self)) = *(ROBJECT(dummy)); *(RBASIC(self)) = basic; }
/* a modified version of include_class_new from class.c */ static VALUE j_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 VALUE struct_alloc(VALUE klass) { VALUE size; long n; NEWOBJ(st, struct RStruct); OBJSETUP(st, klass, T_STRUCT); size = rb_struct_iv_get(klass, "__size__"); n = FIX2LONG(size); st->ptr = ALLOC_N(VALUE, n); rb_mem_clear(st->ptr, n); st->len = n; return (VALUE)st; }
static VALUE class_alloc(VALUE flags, VALUE klass) { #ifdef RUBY_193 rb_deprecated_classext_t *ext = ALLOC(rb_deprecated_classext_t); #else rb_classext_t *ext = ALLOC(rb_classext_t); #endif NEWOBJ(obj, struct RClass); OBJSETUP(obj, klass, flags); obj->ptr = ext; RCLASS_IV_TBL(obj) = 0; RCLASS_M_TBL(obj) = 0; RCLASS_SUPER(obj) = 0; #ifndef RUBY_193 RCLASS_IV_INDEX_TBL(obj) = 0; #endif return (VALUE)obj; }
/* note: this code is magical: */ static VALUE rb_str_new_move(char* data, size_t length) { NEWOBJ(str, struct RString); OBJSETUP(str, rb_cString, T_STRING); str->as.heap.ptr = data; str->as.heap.len = length; str->as.heap.aux.capa = length; FL_SET(str, FL_USER1); /* set STR_NOEMBED */ RBASIC(str)->flags &= ~RSTRING_EMBED_LEN_MASK; /* this is safe. see msgpack_postmem_alloc() */ data[length] = '\0'; /* ???: unknown whether this is needed or not */ OBJ_FREEZE(str); return (VALUE) str; }
VALUE rb_data_object_alloc(VALUE klass, void *datap, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree) { if (klass) { Check_Type(klass, T_CLASS); } NEWOBJ(data, struct RData); OBJSETUP(data, klass, T_DATA); GC_WB(&data->data, datap); data->dfree = dfree; data->dmark = dmark; if (dfree != NULL) { rb_objc_install_method2((Class)klass, "finalize", (IMP)rdata_finalize); } return (VALUE)data; }