static mrb_value color_map_rgba_f(mrb_state *mrb, mrb_value self) { mrb_float r; mrb_float g; mrb_float b; mrb_float a; ALLEGRO_COLOR *c; mrb_get_args(mrb, "ffff", &r, &g, &b, &a); c = mrb_malloc(mrb, sizeof(*c)); *c = al_map_rgba_f(mrbal_clamp_f(r), mrbal_clamp_f(g), mrbal_clamp_f(b), mrbal_clamp_f(a)); return mrb_obj_value(Data_Wrap_Struct(mrb, mrb_class_ptr(self), &mrbal_color_data_type, c)); }
static mrb_value cfunc_env_get(mrb_state *mrb, mrb_value self) { mrb_sym n; mrb_value *argv; mrb_int argc; mrb_method_t m; struct RProc *p; mrb_get_args(mrb, "na", &n, &argv, &argc); p = mrb_proc_new_cfunc_with_env(mrb, return_env, argc, argv); MRB_METHOD_FROM_PROC(m, p); mrb_define_method_raw(mrb, mrb_class_ptr(self), n, m); return self; }
mrb_value mrb_class_new_class(mrb_state *mrb, mrb_value cv) { mrb_value super; struct RClass *new_class; if (mrb_get_args(mrb, "|o", &super) == 0) { super = mrb_obj_value(mrb->object_class); } new_class = mrb_class_new(mrb, mrb_class_ptr(super)); mrb_funcall(mrb, super, "inherited", 1, mrb_obj_value(new_class)); return mrb_obj_value(new_class); }
mrb_value mrb_class_superclass(mrb_state *mrb, mrb_value klass) { struct RClass *c; c = mrb_class_ptr(klass); c = c->super; while (c && c->tt == MRB_TT_ICLASS) { c = c->super; } if (!c) return mrb_nil_value(); return mrb_obj_value(c); }
/* * call-seq: * obj.is_a?(class) -> true or false * obj.kind_of?(class) -> true or false * * Returns <code>true</code> if <i>class</i> is the class of * <i>obj</i>, or if <i>class</i> is one of the superclasses of * <i>obj</i> or modules included in <i>obj</i>. * * module M; end * class A * include M * end * class B < A; end * class C < B; end * b = B.new * b.instance_of? A #=> false * b.instance_of? B #=> true * b.instance_of? C #=> false * b.instance_of? M #=> false * b.kind_of? A #=> true * b.kind_of? B #=> true * b.kind_of? C #=> false * b.kind_of? M #=> true */ mrb_value mrb_obj_is_kind_of_m(mrb_state *mrb, mrb_value self) { mrb_value arg; mrb_get_args(mrb, "o", &arg); if (mrb_obj_is_kind_of(mrb, self, mrb_class_ptr(arg))) { return mrb_true_value(); } else { return mrb_false_value(); } }
static mrb_value config_create(mrb_state *mrb, mrb_value self) { ALLEGRO_CONFIG *cfg; struct RData *data; cfg = al_create_config(); if (!cfg) { mrb_raise(mrb, E_ALLEGRO_ERROR, "could not create config"); } data = mrb_data_object_alloc(mrb, mrb_class_ptr(self), cfg, &mrbal_config_data_type); return mrb_obj_value(data); }
static mrb_value bitmap_create(mrb_state *mrb, mrb_value self) { mrb_int w; mrb_int h; ALLEGRO_BITMAP *b; mrb_get_args(mrb, "ii", &w, &h); b = al_create_bitmap(mrbal_clamp_int(w), mrbal_clamp_int(h)); if (!b) { mrb_raise(mrb, E_ALLEGRO_ERROR, "creating bitmap failed"); } return mrb_obj_value(Data_Wrap_Struct(mrb, mrb_class_ptr(self), &mrbal_bitmap_data_type, b)); }
struct RClass* mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id) { struct RClass *c, *s; if (mrb_const_defined(mrb, outer, id)) { mrb_value v = mrb_const_get(mrb, outer, id); mrb_check_type(mrb, v, MRB_TT_CLASS); c = mrb_class_ptr(v); if (!mrb_nil_p(super)) { if (mrb_type(super) != MRB_TT_CLASS) { mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super)); } if (!c->super || mrb_class_ptr(super) != mrb_class_real(c->super)) { mrb_raise(mrb, E_TYPE_ERROR, "superclass mismatch for class %s", mrb_sym2name(mrb, id)); } } return c; } if (!mrb_nil_p(super)) { if (mrb_type(super) != MRB_TT_CLASS) { mrb_raise(mrb, E_TYPE_ERROR, "superclass must be a Class (%s given)", mrb_obj_classname(mrb, super)); } s = mrb_class_ptr(super); } else { s = mrb->object_class; } c = mrb_class_new(mrb, s); setup_class(mrb, outer, c, id); mrb_funcall(mrb, mrb_obj_value(s), "inherited", 1, mrb_obj_value(c)); return c; }
/* * call-seq: * Struct.new( [aString] [, aSym]+> ) -> StructClass * StructClass.new(arg, ...) -> obj * StructClass[arg, ...] -> obj * * Creates a new class, named by <i>aString</i>, containing accessor * methods for the given symbols. If the name <i>aString</i> is * omitted, an anonymous structure class will be created. Otherwise, * the name of this struct will appear as a constant in class * <code>Struct</code>, so it must be unique for all * <code>Struct</code>s in the system and should start with a capital * letter. Assigning a structure class to a constant effectively gives * the class the name of the constant. * * <code>Struct::new</code> returns a new <code>Class</code> object, * which can then be used to create specific instances of the new * structure. The number of actual parameters must be * less than or equal to the number of attributes defined for this * class; unset parameters default to <code>nil</code>. Passing too many * parameters will raise an <code>ArgumentError</code>. * * The remaining methods listed in this section (class and instance) * are defined for this generated class. * * # Create a structure with a name in Struct * Struct.new("Customer", :name, :address) #=> Struct::Customer * Struct::Customer.new("Dave", "123 Main") #=> #<struct Struct::Customer name="Dave", address="123 Main"> * * # Create a structure named by its constant * Customer = Struct.new(:name, :address) #=> Customer * Customer.new("Dave", "123 Main") #=> #<struct Customer name="Dave", address="123 Main"> */ static mrb_value mrb_struct_s_def(mrb_state *mrb, mrb_value klass) { mrb_value name, rest; mrb_value *pargv; int argcnt; mrb_int i; mrb_value b, st; mrb_sym id; mrb_value *argv; int argc; name = mrb_nil_value(); rest = mrb_nil_value(); mrb_get_args(mrb, "*&", &argv, &argc, &b); if (argc == 0) { /* special case to avoid crash */ rest = mrb_ary_new(mrb); } else { if (argc > 0) name = argv[0]; if (argc > 1) rest = argv[1]; if (mrb_array_p(rest)) { if (!mrb_nil_p(name) && mrb_symbol_p(name)) { /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ mrb_ary_unshift(mrb, rest, name); name = mrb_nil_value(); } } else { pargv = &argv[1]; argcnt = argc-1; if (!mrb_nil_p(name) && mrb_symbol_p(name)) { /* 1stArgument:symbol -> name=nil rest=argv[0]-[n] */ name = mrb_nil_value(); pargv = &argv[0]; argcnt++; } rest = mrb_ary_new_from_values(mrb, argcnt, pargv); } for (i=0; i<RARRAY_LEN(rest); i++) { id = mrb_obj_to_sym(mrb, RARRAY_PTR(rest)[i]); RARRAY_PTR(rest)[i] = mrb_symbol_value(id); } } st = make_struct(mrb, name, rest, struct_class(mrb)); if (!mrb_nil_p(b)) { mrb_yield_with_class(mrb, b, 1, &st, st, mrb_class_ptr(klass)); } return st; }
// FLTK::Group#resizable static mrb_value mrb_fltk_group_resizable_get_method( mrb_state *mrb, mrb_value self ) { CONTEXT_SETUP( widget ); struct RClass *mrb_fltk_class = mrb_class_get( mrb, "FLTK" ); struct RClass *mrb_fltk_widget_class = mrb_class_ptr( mrb_const_get( mrb, mrb_obj_value( mrb_fltk_class ), mrb_intern_cstr( mrb, "Widget" ) ) ); mrb_value args[1]; args[0] = mrb_obj_value( Data_Wrap_Struct( mrb, mrb->object_class, &fltk_widget_type, (void *)( (Fl_Group *)context->fl_instance )->resizable() ) ); return mrb_class_new_instance( mrb, 1, args, mrb_fltk_widget_class ); }
mrb_value cfunc_pointer_class_malloc(mrb_state *mrb, mrb_value klass) { struct cfunc_type_data *data = malloc(sizeof(struct cfunc_type_data)); data->refer = false; data->autofree = false; mrb_int alloc_size; mrb_get_args(mrb, "i", &alloc_size); set_cfunc_pointer_data(data, malloc(alloc_size)); return mrb_obj_value(Data_Wrap_Struct(mrb, mrb_class_ptr(klass), &cfunc_pointer_data_type, data)); }
static mrb_value mrb_http_parser_parse_url(mrb_state *mrb, mrb_value self) { mrb_value c; mrb_value arg_data; struct http_parser_url handle = {0}; struct RClass* _class_http, *_class_http_url; mrb_get_args(mrb, "S", &arg_data); if (http_parser_parse_url(RSTRING_PTR(arg_data), RSTRING_LEN(arg_data), FALSE, &handle)) { mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid URL"); } _class_http = mrb_module_get(mrb, "HTTP"); _class_http_url = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_http), mrb_intern_cstr(mrb, "URL"))); c = mrb_obj_new(mrb, _class_http_url, 0, NULL); if (handle.field_set & (1<<UF_SCHEMA)) { OBJECT_SET(mrb, c, "schema", mrb_str_substr(mrb, arg_data, handle.field_data[UF_SCHEMA].off, handle.field_data[UF_SCHEMA].len)); } if (handle.field_set & (1<<UF_HOST)) { OBJECT_SET(mrb, c, "host", mrb_str_substr(mrb, arg_data, handle.field_data[UF_HOST].off, handle.field_data[UF_HOST].len)); } if (handle.field_set & (1<<UF_HOST)) { OBJECT_SET(mrb, c, "host", mrb_str_substr(mrb, arg_data, handle.field_data[UF_HOST].off, handle.field_data[UF_HOST].len)); } if (handle.field_set & (1<<UF_PORT)) { OBJECT_SET(mrb, c, "port", mrb_fixnum_value(handle.port)); } else { if (handle.field_set & (1<<UF_SCHEMA)) { mrb_value schema = mrb_str_substr(mrb, arg_data, handle.field_data[UF_SCHEMA].off, handle.field_data[UF_SCHEMA].len); if (!mrb_nil_p(schema) && !strcmp("https", (char*) RSTRING_PTR(schema))) { OBJECT_SET(mrb, c, "port", mrb_fixnum_value(443)); } } } if (handle.field_set & (1<<UF_PATH)) { OBJECT_SET(mrb, c, "path", mrb_str_substr(mrb, arg_data, handle.field_data[UF_PATH].off, handle.field_data[UF_PATH].len)); } if (handle.field_set & (1<<UF_QUERY)) { OBJECT_SET(mrb, c, "query", mrb_str_substr(mrb, arg_data, handle.field_data[UF_QUERY].off, handle.field_data[UF_QUERY].len)); } if (handle.field_set & (1<<UF_FRAGMENT)) { OBJECT_SET(mrb, c, "fragment", mrb_str_substr(mrb, arg_data, handle.field_data[UF_FRAGMENT].off, handle.field_data[UF_FRAGMENT].len)); } return c; }
mrb_value mrb_Curses_MEVENT_disown(mrb_state* mrb, mrb_value self) { mrb_value ruby_object = mrb_nil_value(); mrb_get_args(mrb, "o", &ruby_object); if (!mrb_obj_is_kind_of(mrb, ruby_object, mrb_class_ptr(self))) { mrb_raise(mrb, E_TYPE_ERROR, "Curses::MEVENT.disown only accepts objects of type Curses::MEVENT"); return mrb_nil_value(); } ((mruby_to_native_ref*)(DATA_PTR(ruby_object)))->belongs_to_ruby = FALSE; return mrb_nil_value(); }
/* * call-seq: * mod.class_variables -> array * * Returns an array of the names of class variables in <i>mod</i>. * * class One * @@var1 = 1 * end * class Two < One * @@var2 = 2 * end * One.class_variables #=> [:@@var1] * Two.class_variables #=> [:@@var2] */ mrb_value mrb_mod_class_variables(mrb_state *mrb, mrb_value mod) { mrb_value ary; struct RClass *c; ary = mrb_ary_new(mrb); c = mrb_class_ptr(mod); while (c) { iv_foreach(mrb, c->iv, cv_i, &ary); c = c->super; } return ary; }
mrb_value mrb_Pi_WiringPiNodeStruct_disown(mrb_state* mrb, mrb_value self) { mrb_value ruby_object; mrb_get_args(mrb, "o", &ruby_object); if (!mrb_obj_is_kind_of(mrb, ruby_object, mrb_class_ptr(self))) { mrb_raise(mrb, E_TYPE_ERROR, "Pi::WiringPiNodeStruct.disown only accepts objects of type Pi::WiringPiNodeStruct"); return mrb_nil_value(); } ((mruby_to_native_ref*)(DATA_PTR(ruby_object)))->belongs_to_ruby = FALSE; return mrb_nil_value(); }
struct RClass* mrb_vm_define_class(mrb_state *mrb, mrb_value outer, mrb_value super, mrb_sym id) { struct RClass *c = 0; if (mrb_const_defined(mrb, outer, id)) { mrb_value v = mrb_const_get(mrb, outer, id); c = mrb_class_ptr(v); if (!mrb_nil_p(super) && (c->tt != MRB_TT_CLASS || c->super != mrb_class_ptr(super))) { c = 0; } } if (!c) { struct RClass *s = 0; if (!mrb_nil_p(super)) s = mrb_class_ptr(super); c = mrb_class_new(mrb, s); setup_class(mrb, outer, c, id); } return c; }
static mrb_value h2o_mrb_get_class_obj(mrb_state *mrb, mrb_value self, char *obj_id, char *class_name) { mrb_value obj; struct RClass *obj_class, *h2o_class; obj = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, obj_id)); if (mrb_nil_p(obj)) { h2o_class = mrb_class_get(mrb, "H2O"); obj_class = (struct RClass *)mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(h2o_class), mrb_intern_cstr(mrb, class_name))); obj = mrb_obj_new(mrb, obj_class, 0, NULL); mrb_iv_set(mrb, self, mrb_intern_cstr(mrb, obj_id), obj); } return obj; }
mrb_value mrb_SDL_SDLTexture_disown(mrb_state* mrb, mrb_value self) { mrb_value ruby_object; mrb_get_args(mrb, "o", &ruby_object); if (!mrb_obj_is_kind_of(mrb, ruby_object, mrb_class_ptr(self))) { mrb_raise(mrb, E_TYPE_ERROR, "SDL::SDLTexture.disown only accepts objects of type SDL::SDLTexture"); return mrb_nil_value(); } ((mruby_to_native_ref*)(DATA_PTR(ruby_object)))->belongs_to_ruby = FALSE; return mrb_nil_value(); }
mrb_value mrb_mod_undef(mrb_state *mrb, mrb_value mod) { struct RClass *c = mrb_class_ptr(mod); int argc; mrb_value *argv; mrb_get_args(mrb, "*", &argv, &argc); while (argc--) { undef_method(mrb, c, mrb_symbol(*argv)); argv++; } return mrb_nil_value(); }
static mrb_value proc_new_cfunc_with_env(mrb_state *mrb, mrb_value self) { mrb_sym n; mrb_value n_val; mrb_method_t m; struct RProc *p; mrb_get_args(mrb, "n", &n); n_val = mrb_symbol_value(n); p = mrb_proc_new_cfunc_with_env(mrb, return_func_name, 1, &n_val); MRB_METHOD_FROM_PROC(m, p); mrb_define_method_raw(mrb, mrb_class_ptr(self), n, m); return self; }
mrb_value mrb_class_superclass(mrb_state *mrb, mrb_value klass) { struct RClass *c; mrb_value superclass; c = mrb_class_ptr(klass); if (c->super) superclass = mrb_obj_value(mrb_class_real(c->super)); else superclass = mrb_nil_value(); return superclass; }
static mrb_value mod_define_method(mrb_state *mrb, mrb_value self) { struct RClass *c = mrb_class_ptr(self); mrb_sym mid; mrb_value blk; mrb_get_args(mrb, "n&", &mid, &blk); if (mrb_nil_p(blk)) { /* raise */ } mrb_define_method_raw(mrb, c, mid, mrb_proc_ptr(blk)); return blk; }
static void copy_class(mrb_state *mrb, mrb_value dst, mrb_value src) { struct RClass *dc = mrb_class_ptr(dst); struct RClass *sc = mrb_class_ptr(src); /* if the origin is not the same as the class, then the origin and the current class need to be copied */ if (sc->flags & MRB_FLAG_IS_PREPENDED) { struct RClass *c0 = sc->super; struct RClass *c1 = dc; /* copy prepended iclasses */ while (!(c0->flags & MRB_FLAG_IS_ORIGIN)) { c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0))); c1 = c1->super; c0 = c0->super; } c1->super = mrb_class_ptr(mrb_obj_dup(mrb, mrb_obj_value(c0))); c1->super->flags |= MRB_FLAG_IS_ORIGIN; } dc->mt = kh_copy(mt, mrb, sc->mt); dc->super = sc->super; }
static mrb_value mrb_mod_to_s(mrb_state *mrb, mrb_value klass) { if (mrb_type(klass) == MRB_TT_SCLASS) { mrb_value s = mrb_str_new(mrb, "#<", 2); mrb_value v = mrb_iv_get(mrb, klass, mrb_intern(mrb, "__attached__")); mrb_str_cat2(mrb, s, "Class:"); switch (mrb_type(v)) { case MRB_TT_CLASS: case MRB_TT_MODULE: case MRB_TT_SCLASS: mrb_str_append(mrb, s, mrb_inspect(mrb, v)); break; default: mrb_str_append(mrb, s, mrb_any_to_s(mrb, v)); break; } mrb_str_cat2(mrb, s, ">"); return s; } else { struct RClass *c = mrb_class_ptr(klass); const char *cn = mrb_class_name(mrb, c); if (!cn) { char buf[256]; int n = 0; switch (mrb_type(klass)) { case MRB_TT_CLASS: n = snprintf(buf, sizeof(buf), "#<Class:%p>", c); break; case MRB_TT_MODULE: n = snprintf(buf, sizeof(buf), "#<Module:%p>", c); break; default: break; } return mrb_str_dup(mrb, mrb_str_new(mrb, buf, n)); } else { return mrb_str_dup(mrb, mrb_str_new_cstr(mrb, cn)); } } }
static mrb_value cfunc_call(mrb_state *mrb, mrb_value self) { int margc; mrb_value mresult_type, mname, *margs; mrb_get_args(mrb, "oo*", &mresult_type, &mname, &margs, &margc); void *dlh = dlopen(NULL, RTLD_LAZY); void *fp = dlsym(dlh, RSTRING_PTR(mname)); ffi_type **args = malloc(sizeof(ffi_type*) * margc); void **values = malloc(sizeof(void*) * margc); mrb_sym to_pointer = mrb_intern(mrb, "to_pointer"); for(int i = 0; i < margc; ++i) { if(!mrb_respond_to(mrb, margs[i], to_pointer)) { // Todo: should free some malloc-ed pointers mrb_raise(mrb, E_TYPE_ERROR, "ignore argument type"); } args[i] = mrb_value_to_mrb_ffi_type(mrb, margs[i])->ffi_type_value; values[i] = mobi_pointer_ptr(mrb_funcall(mrb, margs[i], "to_pointer", 0)); } ffi_type *result_type = rclass_to_mrb_ffi_type(mrb, mrb_class_ptr(mresult_type))->ffi_type_value; if (result_type == NULL) { mrb_raise(mrb, E_ARGUMENT_ERROR, "ignore return type"); } mrb_value mresult = mrb_nil_value(); ffi_cif cif; if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, margc, result_type, args) == FFI_OK) { void *result = result_type->size ? malloc(result_type->size) : NULL; ffi_call(&cif, fp, result, values); if(result) { mrb_value result_ptr = cfunc_pointer_new_with_pointer(mrb, result, 1); mresult = mrb_funcall(mrb, mresult_type, "refer", 1, result_ptr); } } else { // todo mrb_raise(mrb, E_NAME_ERROR, "can't find C function"); } cfunc_call_exit: free(values); free(args); return mresult; }
static mrb_value config_load_file(mrb_state *mrb, mrb_value self) { char *filename; ALLEGRO_CONFIG *cfg; struct RData *data; mrb_get_args(mrb, "z", &filename); cfg = al_load_config_file(filename); if (!cfg) { mrb_raise(mrb, E_ALLEGRO_ERROR, "could not load config"); } data = mrb_data_object_alloc(mrb, mrb_class_ptr(self), cfg, &mrbal_config_data_type); return mrb_obj_value(data); }
static mrb_value mrb_ary_s_create(mrb_state *mrb, mrb_value klass) { mrb_value ary; mrb_value *vals; mrb_int len; struct RArray *a; mrb_get_args(mrb, "*!", &vals, &len); ary = mrb_ary_new_from_values(mrb, len, vals); a = mrb_ary_ptr(ary); a->c = mrb_class_ptr(klass); return ary; }
static mrb_value mrb_cgroup_get_cpuacct_obj(mrb_state *mrb, mrb_value self) { mrb_value cpuacct_value; struct RClass *cpuacct_class, *cgroup_class; mrb_cgroup_context *mrb_cg_cxt = mrb_cgroup_get_context(mrb, self, "mrb_cgroup_context"); cpuacct_value = mrb_iv_get(mrb, self, mrb_intern_cstr(mrb, "cpuacct_obj")); if (mrb_nil_p(cpuacct_value)) { cgroup_class = mrb_class_get(mrb, "Cgroup"); cpuacct_class = (struct RClass*)mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(cgroup_class), mrb_intern_cstr(mrb, "CPUACCT"))); cpuacct_value = mrb_obj_new(mrb, cpuacct_class, 1, &mrb_cg_cxt->group_name); mrb_iv_set(mrb, self, mrb_intern_cstr(mrb, "cpuacct_obj"), cpuacct_value); } return cpuacct_value; }
mrb_value mrb_SDL_SDLTexture_belongs_to_ruby(mrb_state* mrb, mrb_value self) { mrb_value ruby_object; mrb_get_args(mrb, "o", &ruby_object); if (!mrb_obj_is_kind_of(mrb, ruby_object, mrb_class_ptr(self))) { mrb_raise(mrb, E_TYPE_ERROR, "SDL::SDLTexture.belongs_to_ruby only accepts objects of type SDL::SDLTexture"); return mrb_nil_value(); } if ( ((mruby_to_native_ref*)(DATA_PTR(ruby_object)))->belongs_to_ruby ) { return mrb_true_value(); } else { return mrb_false_value(); } }
/* * call-seq: * mod.constants -> array * * Returns an array of all names of contants defined in the receiver. */ mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod) { mrb_value ary; struct RClass *c = mrb_class_ptr(mod); ary = mrb_ary_new(mrb); while (c) { if (c->iv) { iv_foreach(mrb, c->iv, const_i, &ary); } c = c->super; if (c == mrb->object_class) break; } return ary; }