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;
}
