/*
* call-seq:
* lcd.clear(col) # => nil
*
* Clear window.
*
* Parameters:
* +col+ LCD foreground color.
* :black black (default)
* :white while
*
* Returns nil.
*/
static mrb_value
mrb_lcd_clear(mrb_state *mrb, mrb_value self)
{
mrb_lcd_t *plcd = (mrb_lcd_t*)DATA_PTR(self);
struct RClass *lcd = mrb_obj_class(mrb, self);
mrb_value cmap = mrb_const_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "COLOR"));
mrb_sym col = mrb_intern_lit(mrb, "black");
mrb_value colv;
mrb_get_args(mrb, "|n", &col);
colv = mrb_hash_get(mrb, cmap, mrb_symbol_value(col));
if (mrb_nil_p(colv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid foreground color :%S", mrb_sym2str(mrb, col));
}
ev3_lcd_fill_rect(
plcd->left,
plcd->top,
plcd->width,
plcd->height,
mrb_fixnum(colv) ? 0 : 1
);
plcd->cx = plcd->cy = 0;
return mrb_nil_value();
}
mrb_value
mrb_mod_const_get(mrb_state *mrb, mrb_value mod)
{
mrb_value sym;
mrb_get_args(mrb, "o", &sym);
return mrb_const_get(mrb, mod, mrb_sym_value(mrb, sym));
}
/*
* call-seq:
* SerialPort.new(port) # => SerialPort
*
* Open serial port.
*
* Parameters:
* +port+ font size.
* :default Default serial port
* :uart UART
* :bt Bluetooth
*
* Returns SerialPort object.
*/
static mrb_value
mrb_serial_init(mrb_state *mrb, mrb_value self)
{
struct RClass *ser = mrb_obj_class(mrb, self);
mrb_value pmap = mrb_const_get(mrb, mrb_obj_value(ser), mrb_intern_lit(mrb, "PORT"));
mrb_sym port;
mrb_value portv;
FILE *fp;
mrb_get_args(mrb, "n", &port);
portv = mrb_hash_get(mrb, pmap, mrb_symbol_value(port));
if (mrb_nil_p(portv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid port :%S", mrb_sym2str(mrb, port));
}
fp = ev3_serial_open_file((serial_port_t)mrb_fixnum(portv));
if (fp == NULL) {
mrb_raisef(mrb, E_IO_ERROR, "Serial port cannot open :%S", mrb_sym2str(mrb, port));
}
mrb_file_attach(self, fp);
return self;
}
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)) {
mrb_check_type(mrb, super, MRB_TT_CLASS);
s = mrb_class_ptr(super);
}
if (!s) {
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;
}
static mrb_value
mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
{
mrb_int i;
mt_state *random = NULL;
if (RARRAY_LEN(ary) > 1) {
mrb_get_args(mrb, "|d", &random, &mt_state_type);
if (random == NULL) {
mrb_value random_val = mrb_const_get(mrb,
mrb_obj_value(mrb_class_get(mrb, "Random")),
mrb_intern_lit(mrb, "DEFAULT"));
random = (mt_state *)DATA_PTR(random_val);
}
mrb_random_rand_seed(mrb, random);
mrb_ary_modify(mrb, mrb_ary_ptr(ary));
for (i = RARRAY_LEN(ary) - 1; i > 0; i--) {
mrb_int j;
mrb_value tmp;
j = mrb_fixnum(mrb_random_mt_rand(mrb, random, mrb_fixnum_value(RARRAY_LEN(ary))));
tmp = RARRAY_PTR(ary)[i];
RARRAY_PTR(ary)[i] = RARRAY_PTR(ary)[j];
RARRAY_PTR(ary)[j] = tmp;
}
}
return ary;
}
static mrb_value
hs_regexp_get_match_data(mrb_state *mrb, mrb_value self, const char *str)
{
mrb_value hs_match_data_cls, match_data;
struct mrb_hs_regexp *reg;
reg = (struct mrb_hs_regexp *)DATA_PTR(self);
hs_match_data_cls = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), INTERN("HsMatchData"));
match_data = mrb_funcall_argv(mrb, hs_match_data_cls, INTERN("new"), 0, NULL);
mrb_iv_set(mrb, match_data, INTERN("@string"), mrb_str_new_cstr(mrb, str));
{
mrb_value args[2];
mrb_sym sym_push;
size_t i;
sym_push = INTERN("push");
for (i = 0; i < sizeof(reg->reg->startp)/sizeof(reg->reg->startp[0]); i++){
if (reg->reg->startp[i] && reg->reg->endp[i]){
args[0] = mrb_fixnum_value(reg->reg->startp[i] - str);
args[1] = mrb_fixnum_value(reg->reg->endp[i] - reg->reg->startp[i]);
mrb_funcall_argv(mrb, match_data, sym_push, sizeof(args)/sizeof(args[0]), &args[0]);
}else{
mrb_funcall_argv(mrb, match_data, sym_push, 0, NULL);
}
}
}
return match_data;
}
static mrb_value
mrb_hmac_init(mrb_state *mrb, mrb_value self)
{
struct mrb_hmac *hmac;
mrb_value digest, t;
mrb_int keylen;
char *key;
hmac = (struct mrb_hmac *)DATA_PTR(self);
if (hmac) {
lib_hmac_free(mrb, hmac);
}
DATA_TYPE(self) = &mrb_hmac_type;
DATA_PTR(self) = NULL;
mrb_get_args(mrb, "so", &key, &keylen, &digest);
t = mrb_const_get(mrb, digest, mrb_intern_lit(mrb, TYPESYM));
if (mrb_nil_p(t)) {
mrb_raise(mrb, E_RUNTIME_ERROR, "not a digester");
}
hmac = (struct mrb_hmac *)mrb_malloc(mrb, sizeof(*hmac));
DATA_PTR(self) = hmac;
lib_hmac_init(mrb, hmac, mrb_fixnum(t), (unsigned char *)key, keylen);
return self;
}
static mrb_value
mrb_digest_init(mrb_state *mrb, mrb_value self)
{
struct RClass *c;
struct mrb_md *md;
mrb_value t;
md = (struct mrb_md *)DATA_PTR(self);
if (md) {
lib_md_free(mrb, md);
}
DATA_TYPE(self) = &mrb_md_type;
DATA_PTR(self) = NULL;
c = mrb_obj_class(mrb, self);
if (!mrb_const_defined(mrb, mrb_obj_value(c), mrb_intern_lit(mrb, TYPESYM))) {
mrb_raise(mrb, E_NOTIMP_ERROR, "Digest::Base is an abstract class");
}
t = mrb_const_get(mrb, mrb_obj_value(c), mrb_intern_lit(mrb, TYPESYM));
#if 0
if (lib_md_supported(t)) {
mrb_raise(mrb, E_NOTIMP_ERROR, "unknown algorithm");
}
#endif
md = (struct mrb_md *)mrb_malloc(mrb, sizeof(*md));
DATA_PTR(self) = md;
lib_md_init(mrb, md, mrb_fixnum(t));
return self;
}
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)) {
mrb_check_type(mrb, super, MRB_TT_CLASS);
s = mrb_class_ptr(super);
}
c = mrb_class_new(mrb, s);
setup_class(mrb, outer, c, id);
}
return c;
}
mrb_value
uefi_const_get_under_uefi(mrb_state *mrb, const char *name)
{
mrb_value uefi_ns;
uefi_ns = mrb_vm_const_get(mrb, mrb_intern(mrb, "UEFI"));
return mrb_const_get(mrb, uefi_ns, mrb_intern(mrb, name));
}
static mrb_value
mrb_random_g_rand(mrb_state *mrb, mrb_value self)
{
mrb_value random = mrb_const_get(mrb,
mrb_obj_value(mrb_class_get(mrb, "Random")),
mrb_intern_lit(mrb, "DEFAULT"));
return mrb_random_rand(mrb, random);
}
struct RClass *
mrb_class_obj_get(mrb_state *mrb, const char *name)
{
mrb_value mod = mrb_obj_value(mrb->object_class);
mrb_sym sym = mrb_intern(mrb, name);
return mrb_class_ptr(mrb_const_get(mrb, mod, sym));
}
void
mrb_show_version(mrb_state *mrb)
{
mrb_value msg;
msg = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_DESCRIPTION"));
printstr(mrb, msg);
printstr(mrb, mrb_str_new_lit(mrb, "\n"));
}
void
mrb_show_copyright(mrb_state *mrb)
{
mrb_value msg;
msg = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), mrb_intern_lit(mrb, "MRUBY_COPYRIGHT"));
printstr(mrb, msg);
printstr(mrb, mrb_str_new_lit(mrb, "\n"));
}
mrb_value
mrb_mod_const_get(mrb_state *mrb, mrb_value mod)
{
mrb_sym id;
mrb_get_args(mrb, "n", &id);
check_const_name_sym(mrb, id);
return mrb_const_get(mrb, mod, id);
}
static struct RClass *
class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym id)
{
mrb_value c = mrb_const_get(mrb, mrb_obj_value(klass), id);
if (mrb_type(c) != MRB_TT_MODULE && mrb_type(c) != MRB_TT_CLASS) {
mrb_raisef(mrb, E_TYPE_ERROR, "%s is not a class/module", mrb_sym2name(mrb, id));
}
return mrb_class_ptr(c);
}
/*
* call-seq:
* LCD.new(font, x, y, width, height, color) # => LCD
*
* Creates LCD object.
*
* Parameters:
* +font+ font size.
* :small small font (6x8, default)
* :medium medium font (8x16)
* +x+ Window origin (left) X coordinate. (default: 0)
* +y+ Window origin (top) Y coordinate. (default: 0)
* +width+ Width of window. (default: LCD::WIDTH)
* +height+ Height of window. (default: LCD::HEIGHT)
* +color+ LCD foreground color.
* :black black (default)
* :white while
*
* Returns LCD object.
*/
static mrb_value
mrb_lcd_init(mrb_state *mrb, mrb_value self)
{
struct RClass *lcd = mrb_obj_class(mrb, self);
mrb_value fmap = mrb_const_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "FONT"));
mrb_value cmap = mrb_const_get(mrb, mrb_obj_value(lcd), mrb_intern_lit(mrb, "COLOR"));
mrb_sym font = mrb_intern_lit(mrb, "small");
mrb_sym col = mrb_intern_lit(mrb, "black");
mrb_value fontv;
mrb_value colv;
mrb_lcd_t *plcd;
DATA_TYPE(self) = &mrb_lcd_type;
plcd = (mrb_lcd_t*)mrb_malloc(mrb, sizeof(mrb_lcd_t));
DATA_PTR(self) = plcd;
memset(plcd, 0, sizeof(mrb_lcd_t));
plcd->width = EV3_LCD_WIDTH;
plcd->height = EV3_LCD_HEIGHT;
mrb_get_args(mrb, "|niiiin", &font, &plcd->left, &plcd->top, &plcd->width, &plcd->height, &col);
fontv = mrb_hash_get(mrb, fmap, mrb_symbol_value(font));
if (mrb_nil_p(fontv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid font size :%S", mrb_sym2str(mrb, font));
}
plcd->font = mrb_fixnum(fontv);
if (_font_size[plcd->font].w == 0) {
/* initialize font size at 1st time */
ev3_font_get_size(plcd->font, &_font_size[plcd->font].w, &_font_size[plcd->font].h);
}
colv = mrb_hash_get(mrb, cmap, mrb_symbol_value(col));
if (mrb_nil_p(colv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid foreground color :%S", mrb_sym2str(mrb, col));
}
plcd->color = mrb_fixnum(colv);
return self;
}
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;
}
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;
}
// 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 );
}
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;
}
/*
* call-seq:
* Button.new(key) # => Button
*
* Creates Button object.
*
* Parameters:
* +key+ Button name
* :left Left button
* :right Right button
* :up Up button
* :down Down button
* :enter Enter button
* :back Back button
*
* Returns Butotn object.
*/
static mrb_value
mrb_btn_init(mrb_state *mrb, mrb_value self)
{
struct RClass *btn = mrb_obj_class(mrb, self);
mrb_value map = mrb_const_get(mrb, mrb_obj_value(btn), mrb_intern_lit(mrb, "KEY"));
mrb_sym key;
mrb_value keyv;
mrb_get_args(mrb, "n", &key);
keyv = mrb_hash_get(mrb, map, mrb_symbol_value(key));
mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "@key"), keyv);
return self;
}
struct RClass*
mrb_vm_define_module(mrb_state *mrb, mrb_value outer, mrb_sym id)
{
struct RClass *c;
mrb_value v;
if (mrb_const_defined(mrb, outer, id)) {
v = mrb_const_get(mrb, outer, id);
c = mrb_class_ptr(v);
}
else {
c = mrb_module_new(mrb);
setup_class(mrb, outer, c, id);
}
return c;
}
/*
* call-seq:
* LED.color = col # => nil
*
* Light LED.
*
* Parameters:
* +col+ LED color
* LED::OFF
* LED::RED
* LED::GREEN
* LED::ORANGE
*
* Returns nil.
*/
static mrb_value
mrb_led_color(mrb_state *mrb, mrb_value self)
{
mrb_value cmap = mrb_const_get(mrb, self, mrb_intern_lit(mrb, "COLOR"));
mrb_sym col;
mrb_value colv;
mrb_get_args(mrb, "n", &col);
colv = mrb_hash_get(mrb, cmap, mrb_symbol_value(col));
if (mrb_nil_p(colv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid color :%S", mrb_sym2str(mrb, col));
}
ev3_led_set_color(mrb_fixnum(colv));
return mrb_nil_value();
}
static struct RClass *
mrb_class_from_path(mrb_state *mrb, mrb_value path)
{
char *path_s;
switch (path.tt)
{
case MRB_TT_SYMBOL :
path_s = (char*) mrb_sym2name(mrb, mrb_symbol(path));
break;
case MRB_TT_STRING :
path_s = (char*) RSTRING_PTR(path);
break;
default:
throw Exception(Exception::ArgumentError, "dump format error for symbol");
}
/* If a symbol contains any colons, mrb_sym2name
* will return the string with "s around it
* (e.g. :Mod::Class => :"Mod::Class"),
* so we need to skip those. */
if (path_s[0] == '\"')
path_s++;
char *p, *pbgn;
mrb_value klass = mrb_obj_value(mrb->object_class);
p = pbgn = path_s;
while (*p && *p != '\"')
{
while (*p && *p != ':' && *p != '\"') p++;
mrb_sym sym = mrb_intern(mrb, pbgn, p-pbgn);
klass = mrb_const_get(mrb, klass, sym);
if (p[0] == ':')
{
if (p[1] != ':')
return 0;
p += 2;
pbgn = p;
}
}
return (struct RClass*) mrb_obj_ptr(klass);
}
static void
basecheck(mrb_state *mrb, mrb_value self, struct mrb_md **mdp)
{
struct RClass *c;
struct mrb_md *md;
mrb_value t;
c = mrb_obj_class(mrb, self);
t = mrb_const_get(mrb, mrb_obj_value(c), mrb_intern_lit(mrb, TYPESYM));
if (mrb_nil_p(t)) {
mrb_raise(mrb, E_NOTIMP_ERROR, "Digest::Base is an abstract class");
}
md = (struct mrb_md *)DATA_PTR(self);
if (!md) {
mrb_raise(mrb, E_RUNTIME_ERROR, "no md found (BUG?)");
}
if (mdp) *mdp = md;
}
/*
* call-seq:
* LCD.font = font # => nil
*
* Set the current font.
*
* Parameters:
* +font+ font size.
* :small small font
* :medium medium font (8x16)
*
* Returns nil.
*/
static mrb_value
mrb_lcd_set_font(mrb_state *mrb, mrb_value self)
{
mrb_value fmap = mrb_const_get(mrb, self, mrb_intern_lit(mrb, "FONT"));
mrb_sym font;
mrb_value fontv;
mrb_get_args(mrb, "n", &font);
fontv = mrb_hash_get(mrb, fmap, mrb_symbol_value(font));
if (mrb_nil_p(fontv)) {
mrb_raisef(mrb, E_ARGUMENT_ERROR, "invalid font size :%S", mrb_sym2str(mrb, font));
}
ev3_lcd_set_font(mrb_fixnum(fontv));
mrb_cv_set(mrb, self, mrb_intern_lit(mrb, "@@font"), fontv);
return mrb_nil_value();
}
// using from ngx_http_mruby_connection.c and ngx_http_mruby_server.c
mrb_value ngx_mrb_get_request_var(mrb_state *mrb, mrb_value self)
{
const char *iv_var_str = "@iv_var";
mrb_value iv_var;
struct RClass *class_var, *ngx_class;
iv_var = mrb_iv_get(mrb, self, mrb_intern(mrb, iv_var_str));
if (mrb_nil_p(iv_var)) {
// get class from Nginx::Var
ngx_class = mrb_class_get(mrb, "Nginx");
class_var = (struct RClass*)mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(ngx_class), mrb_intern_cstr(mrb, "Var")));
// initialize a Var instance
iv_var = mrb_class_new_instance(mrb, 0, 0, class_var);
// save Var, avoid multi initialize
mrb_iv_set(mrb, self, mrb_intern(mrb, iv_var_str), iv_var);
}
return iv_var;
}
mrb_value mrb_mongo_collection_query(mrb_state *mrb, mrb_value self) {
mrb_value hash_query, query;
mrb_value query_params[2];
mrb_get_args(mrb, "|H", &hash_query);
if (!mrb_hash_p(hash_query)) {
hash_query = mrb_hash_new(mrb);
}
struct RClass *_class_mongo = mrb_module_get(mrb, "Mongo");
struct RClass *_class_mongo_query = mrb_class_ptr(mrb_const_get(mrb, mrb_obj_value(_class_mongo), mrb_intern_lit(mrb, "Query")));
query_params[0] = self;
query_params[1] = hash_query;
query = mrb_obj_new(mrb, _class_mongo_query, 2, query_params);
return query;
}
static mrb_int getButtonArg(mrb_state *mrb, mrb_value self)
{
mrb_int num;
#ifdef RGSS3
mrb_sym sym;
mrb_get_args(mrb, "n", &sym);
if (mrb_const_defined(mrb, self, sym))
num = mrb_fixnum(mrb_const_get(mrb, self, sym));
else
num = 0;
#else
(void) self;
mrb_get_args(mrb, "i", &num);
#endif
return num;
}
