/* :nodoc: */ VALUE rb_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(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_i, (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; }
static VALUE rb_ool_conmin_gencan_parameters_default(VALUE klass) { ool_conmin_gencan_parameters P; VALUE ary; ool_conmin_parameters_default(ool_conmin_minimizer_gencan, (void*) &P); ary = create_parameters_ary_gencan(&P); RBASIC(ary)->klass = cool_conmin_gencan_parameters; return ary; }
static const char * ruby__sfvextra(rb_printf_buffer *fp, size_t valsize, void *valp, long *sz, int sign) { VALUE value, result = (VALUE)fp->_bf._base; rb_encoding *enc; char *cp; if (valsize != sizeof(VALUE)) return 0; value = *(VALUE *)valp; if (RBASIC(result)->klass) { rb_raise(rb_eRuntimeError, "rb_vsprintf reentered"); } if (sign == '+') { if (RB_TYPE_P(value, T_CLASS)) { # define LITERAL(str) (*sz = rb_strlen_lit(str), str) if (value == rb_cNilClass) { return LITERAL("nil"); } else if (value == rb_cFixnum) { return LITERAL("Fixnum"); } else if (value == rb_cSymbol) { return LITERAL("Symbol"); } else if (value == rb_cTrueClass) { return LITERAL("true"); } else if (value == rb_cFalseClass) { return LITERAL("false"); } # undef LITERAL } value = rb_inspect(value); } else { value = rb_obj_as_string(value); if (sign == ' ') value = QUOTE(value); } enc = rb_enc_compatible(result, value); if (enc) { rb_enc_associate(result, enc); } else { enc = rb_enc_get(result); value = rb_str_conv_enc_opts(value, rb_enc_get(value), enc, ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE, Qnil); *(volatile VALUE *)valp = value; } StringValueCStr(value); RSTRING_GETMEM(value, cp, *sz); ((rb_printf_buffer_extra *)fp)->value = value; OBJ_INFECT(result, value); return cp; }
static VALUE anonymous_struct(VALUE klass) { VALUE nstr; nstr = rb_class_new(klass); rb_make_metaclass(nstr, RBASIC(klass)->klass); rb_class_inherited(klass, nstr); return nstr; }
VALUE make_gdkevent(GdkEvent *ev) { VALUE obj; if (ev == NULL) return Qnil; obj = BOXED2RVAL(ev, GDK_TYPE_EVENT); RBASIC(obj)->klass = gdkevents[ev->type]; /* hack */ return obj; }
static VALUE gdkevent_initialize(VALUE self, VALUE type) { GdkEventType gtype = RVAL2GENUM(type, GDK_TYPE_EVENT_TYPE); if (RBASIC(self)->klass != gdkevents[gtype]) rb_raise(rb_eArgError, "Wrong event type for this class."); G_INITIALIZE(self, gdk_event_new(gtype)); return Qnil; }
static VALUE proc_new(VALUE klass, int is_lambda) { VALUE procval = Qnil; rb_thread_t *th = GET_THREAD(); rb_control_frame_t *cfp = th->cfp; rb_block_t *block; if ((GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0 && !RUBY_VM_CLASS_SPECIAL_P(cfp->lfp[0])) { block = GC_GUARDED_PTR_REF(cfp->lfp[0]); cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); } else { cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); if ((GC_GUARDED_PTR_REF(cfp->lfp[0])) != 0 && !RUBY_VM_CLASS_SPECIAL_P(cfp->lfp[0])) { block = GC_GUARDED_PTR_REF(cfp->lfp[0]); if (block->proc) { return block->proc; } /* TODO: check more (cfp limit, called via cfunc, etc) */ while (cfp->dfp != block->dfp) { cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); } if (is_lambda) { rb_warn("tried to create Proc object without a block"); } } else { rb_raise(rb_eArgError, "tried to create Proc object without a block"); } } procval = block->proc; if (procval && RBASIC(procval)->klass == klass) { return procval; } procval = vm_make_proc(th, cfp, block, klass); if (is_lambda) { rb_proc_t *proc; GetProcPtr(procval, proc); proc->is_lambda = Qtrue; } return procval; }
void * rb_objc_newobj(size_t size) { void *obj; obj = auto_zone_allocate_object(__auto_zone, size, AUTO_OBJECT_SCANNED, 0, 0); assert(obj != NULL); RBASIC(obj)->klass = (VALUE)__nsobject; return obj; }
VALUE rb_define_class_id(ID id, VALUE super) { VALUE klass; if (!super) super = rb_cObject; klass = rb_class_new(super); rb_make_metaclass(klass, RBASIC(super)->klass); return klass; }
static VALUE syserr_initialize(int argc, VALUE *argv, VALUE self) { #if !defined(_WIN32) char *strerror(); #endif const char *err; VALUE mesg, error; VALUE klass = rb_obj_class(self); if (klass == rb_eSystemCallError) { st_data_t data = (st_data_t)klass; rb_scan_args(argc, argv, "11", &mesg, &error); if (argc == 1 && FIXNUM_P(mesg)) { error = mesg; mesg = Qnil; } if (!NIL_P(error) && st_lookup(syserr_tbl, NUM2LONG(error), &data)) { klass = (VALUE)data; /* change class */ if (TYPE(self) != T_OBJECT) { /* insurance to avoid type crash */ rb_raise(rb_eTypeError, "invalid instance type"); } RBASIC(self)->klass = klass; } } else { rb_scan_args(argc, argv, "01", &mesg); error = rb_const_get(klass, rb_intern("Errno")); } if (!NIL_P(error)) err = strerror(NUM2INT(error)); else err = "unknown error"; if (!NIL_P(mesg)) { rb_encoding *le = rb_locale_encoding(); VALUE str = mesg; StringValue(str); mesg = rb_sprintf("%s - %.*s", err, (int)RSTRING_LEN(str), RSTRING_PTR(str)); if (le == rb_usascii_encoding()) { rb_encoding *me = rb_enc_get(mesg); if (le != me && rb_enc_asciicompat(me)) le = me; }/* else assume err is non ASCII string. */ OBJ_INFECT(mesg, str); rb_enc_associate(mesg, le); } else { mesg = rb_str_new2(err); rb_enc_associate(mesg, rb_locale_encoding()); } rb_call_super(1, &mesg); rb_iv_set(self, "errno", error); return self; }
static void w_nbyte(const char *s, long n, struct dump_arg *arg) { VALUE buf = arg->str; rb_str_buf_cat(buf, s, n); RBASIC(buf)->flags |= arg->infection; if (arg->dest && RSTRING_LEN(buf) >= BUFSIZ) { rb_io_write(arg->dest, buf); rb_str_resize(buf, 0); } }
/*! * Ensures a class can be derived from super. * * \param super a reference to an object. * \exception TypeError if \a super is not a Class or \a super is a singleton class. */ void rb_check_inheritable(VALUE super) { if (TYPE(super) != T_CLASS) { rb_raise(rb_eTypeError, "superclass must be a Class (%s given)", rb_obj_classname(super)); } if (RBASIC(super)->flags & FL_SINGLETON) { rb_raise(rb_eTypeError, "can't make subclass of singleton class"); } }
/* * Return the class or module that the given internal class * represents. * * If a class is given, this is the class. If an iclass is given, * this is the module it represents in the lookup chain. */ VALUE Looksee_internal_class_to_module(VALUE self, VALUE internal_class) { if (!SPECIAL_CONST_P(internal_class)) { switch (BUILTIN_TYPE(internal_class)) { case T_ICLASS: return RBASIC(internal_class)->klass; case T_CLASS: return internal_class; } } rb_raise(rb_eArgError, "not an internal class: %s", RSTRING_PTR(rb_inspect(internal_class))); }
static void add_modules(VALUE *req_list, const char *mod) { VALUE list = *req_list; if (!list) { *req_list = list = rb_ary_new(); RBASIC(list)->klass = 0; } rb_ary_push(list, rb_obj_freeze(rb_str_new2(mod))); }
static int fragment_byteno(VALUE fragment) { VALUE val; Check_Type(fragment, T_STRUCT); if (RBASIC(fragment)->klass != Fragment) { rb_raise(rb_eTypeError, "not fragment"); } val = RSTRUCT(fragment)->ptr[3]; return NUM2INT(val); }
static void add_modules(struct cmdline_options *opt, const char *mod) { VALUE list = opt->req_list; if (!list) { opt->req_list = list = rb_ary_new(); RBASIC(list)->klass = 0; } rb_ary_push(list, rb_obj_freeze(rb_str_new2(mod))); }
VALUE rb_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_INIT(clone); 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; } }
VALUE rb_enc_vsprintf(rb_encoding *enc, const char *fmt, va_list ap) { rb_printf_buffer f; VALUE result; f._flags = __SWR | __SSTR; f._bf._size = 0; f._w = 120; result = rb_str_buf_new(f._w); if (enc) rb_enc_associate(result, enc); f._bf._base = (unsigned char *)result; f._p = (unsigned char *)RSTRING_PTR(result); RBASIC(result)->klass = 0; f.vwrite = ruby__sfvwrite; BSD_vfprintf(&f, fmt, ap); RBASIC(result)->klass = rb_cString; rb_str_resize(result, (char *)f._p - RSTRING_PTR(result)); return result; }
static VALUE make_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);
void test_add_gray_list(void) { mrb_state *mrb = mrb_open(); struct RBasic *obj1, *obj2; puts("test_add_gray_list"); gc_assert(mrb->gray_list == NULL); obj1 = RBASIC(mrb_str_new_cstr(mrb, "test")); add_gray_list(mrb, obj1); gc_assert(mrb->gray_list == obj1); gc_assert(is_gray(obj1)); obj2 = RBASIC(mrb_str_new_cstr(mrb, "test")); add_gray_list(mrb, obj2); gc_assert(mrb->gray_list == obj2); gc_assert(mrb->gray_list->gcnext == obj1); gc_assert(is_gray(obj2)); mrb_close(mrb); }
static VALUE range_loader(VALUE range, VALUE obj) { if (TYPE(obj) != T_OBJECT || RBASIC(obj)->klass != rb_cObject) { rb_raise(rb_eTypeError, "not a dumped range object"); } RSTRUCT(range)->as.ary[0] = rb_ivar_get(obj, id_beg); RSTRUCT(range)->as.ary[1] = rb_ivar_get(obj, id_end); RSTRUCT(range)->as.ary[2] = rb_ivar_get(obj, id_excl); return range; }
static VALUE create_proc(VALUE klass, VALUE binding, NODE * body, NODE * var) { /* Calling eval will do a security check */ VALUE new_proc = rb_funcall( rb_cObject, rb_intern("eval"), 2, rb_str_new2("proc { }"), binding); struct BLOCK * b; Data_Get_Struct(new_proc, struct BLOCK, b); b->body = body; b->var = var; RBASIC(new_proc)->klass = klass; return new_proc; }
static VALUE fragment_type(VALUE fragment) { VALUE val; Check_Type(fragment, T_STRUCT); if (RBASIC(fragment)->klass != Fragment) { rb_raise(rb_eTypeError, "not fragment"); } val = RSTRUCT(fragment)->ptr[0]; Check_Type(val, T_SYMBOL); return val; }
static VALUE struct_alloc(VALUE klass) { long n; NEWOBJ_OF(st, struct RStruct, klass, T_STRUCT); n = num_members(klass); 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 { st->as.heap.ptr = ALLOC_N(VALUE, n); rb_mem_clear(st->as.heap.ptr, n); st->as.heap.len = n; } return (VALUE)st; }
static int cto_i(void *vstart, void *vend, size_t stride, void *data) { VALUE hash = (VALUE)data; VALUE v = (VALUE)vstart; for (; v != (VALUE)vend; v += stride) { if (RBASIC(v)->flags && BUILTIN_TYPE(v) == T_DATA) { VALUE counter = rb_hash_aref(hash, RBASIC(v)->klass); if (NIL_P(counter)) { counter = INT2FIX(1); } else { counter = INT2FIX(FIX2INT(counter) + 1); } rb_hash_aset(hash, RBASIC(v)->klass, counter); } } return 0; }
VALUE rb_poppler_ruby_object_from_action(PopplerAction *action) { VALUE obj; if (!action) return Qnil; obj = BOXED2RVAL(action, POPPLER_TYPE_ACTION); RBASIC(obj)->klass = actions[action->type]; return obj; }
/* * call-seq: * Coverage.start => nil * * Enables coverage measurement. */ static VALUE rb_coverage_start(VALUE klass) { if (!RTEST(rb_get_coverages())) { if (rb_coverages == Qundef) { rb_coverages = rb_hash_new(); RBASIC(rb_coverages)->klass = 0; } rb_set_coverages(rb_coverages); } return Qnil; }
static VALUE fragment_text(VALUE fragment) { VALUE val; Check_Type(fragment, T_STRUCT); if (RBASIC(fragment)->klass != Fragment) { rb_raise(rb_eTypeError, "not fragment"); } val = RSTRUCT(fragment)->ptr[1]; StringValue(val); return val; }
static VALUE make_struct(VALUE name, VALUE members, VALUE klass) { VALUE nstr; ID id; long i, count; 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_iv_set(nstr, "__size__", LONG2NUM(RARRAY_LEN(members))); rb_iv_set(nstr, "__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); for (i = 0, count = RARRAY_LEN(members); i < count; i++) { ID id = SYM2ID(RARRAY_AT(members, i)); if (rb_is_local_id(id) || rb_is_const_id(id)) { if (i < N_REF_FUNC) { rb_objc_define_method(nstr, rb_id2name(id), ref_func[i], 0); } else { rb_objc_define_method(nstr, rb_id2name(id), rb_struct_ref, 0); } rb_objc_define_method(nstr, rb_id2name(rb_id_attrset(id)), rb_struct_set, 1); } } return nstr; }
VALUE rb_mod_include_p(VALUE mod, VALUE mod2) { VALUE p; Check_Type(mod2, T_MODULE); for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) { if (BUILTIN_TYPE(p) == T_ICLASS) { if (RBASIC(p)->klass == mod2) return Qtrue; } } return Qfalse; }