void
mrb_mruby_method_gem_init(mrb_state* mrb)
{
struct RClass *unbound_method = mrb_define_class(mrb, "UnboundMethod", mrb->object_class);
struct RClass *method = mrb_define_class(mrb, "Method", mrb->object_class);
mrb_undef_class_method(mrb, unbound_method, "new");
mrb_define_method(mrb, unbound_method, "bind", unbound_method_bind, MRB_ARGS_REQ(1));
mrb_define_method(mrb, unbound_method, "super_method", method_super_method, MRB_ARGS_NONE());
mrb_define_method(mrb, unbound_method, "==", method_eql, MRB_ARGS_REQ(1));
mrb_alias_method(mrb, unbound_method, mrb_intern_lit(mrb, "eql?"), mrb_intern_lit(mrb, "=="));
mrb_define_method(mrb, unbound_method, "to_s", method_to_s, MRB_ARGS_NONE());
mrb_define_method(mrb, unbound_method, "inspect", method_to_s, MRB_ARGS_NONE());
mrb_define_method(mrb, unbound_method, "arity", method_arity, MRB_ARGS_NONE());
mrb_define_method(mrb, unbound_method, "source_location", method_source_location, MRB_ARGS_NONE());
mrb_define_method(mrb, unbound_method, "parameters", method_parameters, MRB_ARGS_NONE());
mrb_undef_class_method(mrb, method, "new");
mrb_define_method(mrb, method, "==", method_eql, MRB_ARGS_REQ(1));
mrb_alias_method(mrb, method, mrb_intern_lit(mrb, "eql?"), mrb_intern_lit(mrb, "=="));
mrb_define_method(mrb, method, "to_s", method_to_s, MRB_ARGS_NONE());
mrb_define_method(mrb, method, "inspect", method_to_s, MRB_ARGS_NONE());
mrb_define_method(mrb, method, "call", method_call, MRB_ARGS_ANY());
mrb_alias_method(mrb, method, mrb_intern_lit(mrb, "[]"), mrb_intern_lit(mrb, "call"));
mrb_define_method(mrb, method, "unbind", method_unbind, MRB_ARGS_NONE());
mrb_define_method(mrb, method, "super_method", method_super_method, MRB_ARGS_NONE());
mrb_define_method(mrb, method, "arity", method_arity, MRB_ARGS_NONE());
mrb_define_method(mrb, method, "source_location", method_source_location, MRB_ARGS_NONE());
mrb_define_method(mrb, method, "parameters", method_parameters, MRB_ARGS_NONE());
mrb_define_method(mrb, mrb->kernel_module, "method", mrb_kernel_method, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->module_class, "instance_method", mrb_module_instance_method, MRB_ARGS_REQ(1));
}
void TRI_InitMRUtils (MR_state_t* mrs) {
struct RClass *rcl;
rcl = mrs->_mrb.kernel_module;
// .............................................................................
// timing function
// .............................................................................
mrb_define_method(&mrs->_mrb, rcl, "time", MR_Time, ARGS_NONE());
// .............................................................................
// arango exception
// .............................................................................
mrs->_arangoError = mrb_define_class(&mrs->_mrb, "ArangoError", mrs->_mrb.eStandardError_class);
// .............................................................................
// json parser and generator
// .............................................................................
rcl = mrb_define_class(&mrs->_mrb, "ArangoJson", mrs->_mrb.object_class);
mrb_define_class_method(&mrs->_mrb, rcl, "parse", MR_JsonParse, ARGS_REQ(1));
}
/* ------------------------------------------------------------------------*/
void
mrb_init_numeric(mrb_state *mrb)
{
struct RClass *numeric, *integer, *fixnum, *fl;
/* Numeric Class */
numeric = mrb_define_class(mrb, "Numeric", mrb->object_class);
mrb_define_method(mrb, numeric, "**", num_pow, MRB_ARGS_REQ(1));
mrb_define_method(mrb, numeric, "/", num_div, MRB_ARGS_REQ(1)); /* 15.2.8.3.4 */
mrb_define_method(mrb, numeric, "quo", num_div, MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
mrb_define_method(mrb, numeric, "<=>", num_cmp, MRB_ARGS_REQ(1)); /* 15.2.9.3.6 */
/* Integer Class */
integer = mrb_define_class(mrb, "Integer", numeric);
mrb_undef_class_method(mrb, integer, "new");
mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE()); /* 15.2.8.3.24 */
mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE());
fixnum = mrb->fixnum_class = mrb_define_class(mrb, "Fixnum", integer);
mrb_define_method(mrb, fixnum, "+", fix_plus, MRB_ARGS_REQ(1)); /* 15.2.8.3.1 */
mrb_define_method(mrb, fixnum, "-", fix_minus, MRB_ARGS_REQ(1)); /* 15.2.8.3.2 */
mrb_define_method(mrb, fixnum, "*", fix_mul, MRB_ARGS_REQ(1)); /* 15.2.8.3.3 */
mrb_define_method(mrb, fixnum, "%", fix_mod, MRB_ARGS_REQ(1)); /* 15.2.8.3.5 */
mrb_define_method(mrb, fixnum, "==", fix_equal, MRB_ARGS_REQ(1)); /* 15.2.8.3.7 */
mrb_define_method(mrb, fixnum, "~", fix_rev, MRB_ARGS_NONE()); /* 15.2.8.3.8 */
mrb_define_method(mrb, fixnum, "&", fix_and, MRB_ARGS_REQ(1)); /* 15.2.8.3.9 */
mrb_define_method(mrb, fixnum, "|", fix_or, MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
mrb_define_method(mrb, fixnum, "^", fix_xor, MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
mrb_define_method(mrb, fixnum, "<<", fix_lshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
mrb_define_method(mrb, fixnum, ">>", fix_rshift, MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
mrb_define_method(mrb, fixnum, "eql?", num_eql, MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
mrb_define_method(mrb, fixnum, "hash", flo_hash, MRB_ARGS_NONE()); /* 15.2.8.3.18 */
mrb_define_method(mrb, fixnum, "to_f", fix_to_f, MRB_ARGS_NONE()); /* 15.2.8.3.23 */
mrb_define_method(mrb, fixnum, "to_s", fix_to_s, MRB_ARGS_NONE()); /* 15.2.8.3.25 */
mrb_define_method(mrb, fixnum, "inspect", fix_to_s, MRB_ARGS_NONE());
mrb_define_method(mrb, fixnum, "divmod", fix_divmod, MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
/* Float Class */
fl = mrb->float_class = mrb_define_class(mrb, "Float", numeric);
mrb_undef_class_method(mrb, fl, "new");
mrb_define_method(mrb, fl, "+", flo_plus, MRB_ARGS_REQ(1)); /* 15.2.9.3.1 */
mrb_define_method(mrb, fl, "-", flo_minus, MRB_ARGS_REQ(1)); /* 15.2.9.3.2 */
mrb_define_method(mrb, fl, "*", flo_mul, MRB_ARGS_REQ(1)); /* 15.2.9.3.3 */
mrb_define_method(mrb, fl, "%", flo_mod, MRB_ARGS_REQ(1)); /* 15.2.9.3.5 */
mrb_define_method(mrb, fl, "==", flo_eq, MRB_ARGS_REQ(1)); /* 15.2.9.3.7 */
mrb_define_method(mrb, fl, "ceil", flo_ceil, MRB_ARGS_NONE()); /* 15.2.9.3.8 */
mrb_define_method(mrb, fl, "finite?", flo_finite_p, MRB_ARGS_NONE()); /* 15.2.9.3.9 */
mrb_define_method(mrb, fl, "floor", flo_floor, MRB_ARGS_NONE()); /* 15.2.9.3.10 */
mrb_define_method(mrb, fl, "infinite?", flo_infinite_p, MRB_ARGS_NONE()); /* 15.2.9.3.11 */
mrb_define_method(mrb, fl, "round", flo_round, MRB_ARGS_NONE()); /* 15.2.9.3.12 */
mrb_define_method(mrb, fl, "to_f", flo_to_f, MRB_ARGS_NONE()); /* 15.2.9.3.13 */
mrb_define_method(mrb, fl, "to_i", flo_truncate, MRB_ARGS_NONE()); /* 15.2.9.3.14 */
mrb_define_method(mrb, fl, "to_int", flo_truncate, MRB_ARGS_NONE());
mrb_define_method(mrb, fl, "truncate", flo_truncate, MRB_ARGS_NONE()); /* 15.2.9.3.15 */
mrb_define_method(mrb, fl, "divmod", flo_divmod, MRB_ARGS_REQ(1));
mrb_define_method(mrb, fl, "to_s", flo_to_s, MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
mrb_define_method(mrb, fl, "inspect", flo_to_s, MRB_ARGS_NONE());
}
void
mrb_mruby_regexp_pcre_gem_init(mrb_state *mrb)
{
struct RClass *re, *md;
re = mrb_define_class(mrb, "Regexp", mrb->object_class);
MRB_SET_INSTANCE_TT(re, MRB_TT_DATA);
mrb_define_method(mrb, re, "initialize", regexp_pcre_initialize, MRB_ARGS_REQ(1) | MRB_ARGS_OPT(2));
mrb_define_method(mrb, re, "match", regexp_pcre_match, MRB_ARGS_REQ(1));
mrb_define_method(mrb, re, "==", regexp_equal, MRB_ARGS_REQ(1));
mrb_define_const(mrb, re, "IGNORECASE", mrb_fixnum_value(MRUBY_REGEXP_IGNORECASE));
mrb_define_const(mrb, re, "EXTENDED", mrb_fixnum_value(MRUBY_REGEXP_EXTENDED));
mrb_define_const(mrb, re, "MULTILINE", mrb_fixnum_value(MRUBY_REGEXP_MULTILINE));
md = mrb_define_class(mrb, "MatchData", mrb->object_class);
MRB_SET_INSTANCE_TT(md, MRB_TT_DATA);
mrb_define_method(mrb, md, "initialize", mrb_matchdata_init, MRB_ARGS_REQ(1));
mrb_define_method(mrb, md, "initialize_copy", mrb_matchdata_init_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, md, "begin", mrb_matchdata_begin, MRB_ARGS_REQ(1));
mrb_define_method(mrb, md, "end", mrb_matchdata_end, MRB_ARGS_REQ(1));
mrb_define_method(mrb, md, "length", mrb_matchdata_length, MRB_ARGS_NONE());
}
void
mrb_init_object(mrb_state *mrb)
{
struct RClass *n;
struct RClass *t;
struct RClass *f;
n = mrb->nil_class = mrb_define_class(mrb, "NilClass", mrb->object_class);
mrb_undef_class_method(mrb, n, "new");
mrb_define_method(mrb, n, "&", false_and, MRB_ARGS_REQ(1)); /* 15.2.4.3.1 */
mrb_define_method(mrb, n, "^", false_xor, MRB_ARGS_REQ(1)); /* 15.2.4.3.2 */
mrb_define_method(mrb, n, "|", false_or, MRB_ARGS_REQ(1)); /* 15.2.4.3.3 */
mrb_define_method(mrb, n, "nil?", mrb_true, MRB_ARGS_NONE()); /* 15.2.4.3.4 */
mrb_define_method(mrb, n, "to_s", nil_to_s, MRB_ARGS_NONE()); /* 15.2.4.3.5 */
mrb_define_method(mrb, n, "inspect", nil_inspect, MRB_ARGS_NONE());
t = mrb->true_class = mrb_define_class(mrb, "TrueClass", mrb->object_class);
mrb_undef_class_method(mrb, t, "new");
mrb_define_method(mrb, t, "&", true_and, MRB_ARGS_REQ(1)); /* 15.2.5.3.1 */
mrb_define_method(mrb, t, "^", true_xor, MRB_ARGS_REQ(1)); /* 15.2.5.3.2 */
mrb_define_method(mrb, t, "to_s", true_to_s, MRB_ARGS_NONE()); /* 15.2.5.3.3 */
mrb_define_method(mrb, t, "|", true_or, MRB_ARGS_REQ(1)); /* 15.2.5.3.4 */
mrb_define_method(mrb, t, "inspect", true_to_s, MRB_ARGS_NONE());
f = mrb->false_class = mrb_define_class(mrb, "FalseClass", mrb->object_class);
mrb_undef_class_method(mrb, f, "new");
mrb_define_method(mrb, f, "&", false_and, MRB_ARGS_REQ(1)); /* 15.2.6.3.1 */
mrb_define_method(mrb, f, "^", false_xor, MRB_ARGS_REQ(1)); /* 15.2.6.3.2 */
mrb_define_method(mrb, f, "to_s", false_to_s, MRB_ARGS_NONE()); /* 15.2.6.3.3 */
mrb_define_method(mrb, f, "|", false_or, MRB_ARGS_REQ(1)); /* 15.2.6.3.4 */
mrb_define_method(mrb, f, "inspect", false_to_s, MRB_ARGS_NONE());
}
void
mrb_mruby_method_gem_init(mrb_state* mrb)
{
struct RClass *unbound_method = mrb_define_class(mrb, "UnboundMethod", mrb->object_class);
struct RClass *method = mrb_define_class(mrb, "Method", mrb->object_class);
struct RClass *module = mrb->module_class;
struct RClass *kernel = mrb->kernel_module;
mrb_define_method(mrb, kernel, "method", mrb_kernel_method, MRB_ARGS_REQ(1));
mrb_define_method(mrb, module, "instance_method", mrb_module_instance_method, MRB_ARGS_REQ(1));
}
void
mrb_init_range(mrb_state *mrb)
{
struct RClass *r;
r = mrb_define_class(mrb, "Range", mrb->object_class);
mrb_include_module(mrb, r, mrb_class_get(mrb, "Enumerable"));
mrb_define_method(mrb, r, "begin", mrb_range_beg, ARGS_NONE()); /* 15.2.14.4.3 */
mrb_define_method(mrb, r, "end", mrb_range_end, ARGS_NONE()); /* 15.2.14.4.5 */
mrb_define_method(mrb, r, "==", mrb_range_eq, ARGS_REQ(1)); /* 15.2.14.4.1 */
mrb_define_method(mrb, r, "===", mrb_range_include, ARGS_REQ(1)); /* 15.2.14.4.2 */
mrb_define_method(mrb, r, "each", mrb_range_each, ARGS_NONE()); /* 15.2.14.4.4 */
mrb_define_method(mrb, r, "exclude_end?", mrb_range_excl, ARGS_NONE()); /* 15.2.14.4.6 */
mrb_define_method(mrb, r, "first", mrb_range_beg, ARGS_NONE()); /* 15.2.14.4.7 */
mrb_define_method(mrb, r, "include?", mrb_range_include, ARGS_REQ(1)); /* 15.2.14.4.8 */
mrb_define_method(mrb, r, "initialize", mrb_range_initialize, ARGS_REQ(4)); /* 15.2.14.4.9 */
mrb_define_method(mrb, r, "last", mrb_range_end, ARGS_NONE()); /* 15.2.14.4.10 */
mrb_define_method(mrb, r, "member?", mrb_range_include, ARGS_REQ(1)); /* 15.2.14.4.11 */
mrb_define_method(mrb, r, "to_s", range_to_s, ARGS_NONE()); /* 15.2.14.4.12(x) */
mrb_define_method(mrb, r, "inspect", range_inspect, ARGS_NONE()); /* 15.2.14.4.13(x) */
mrb_define_method(mrb, r, "eql?", range_eql, ARGS_REQ(1)); /* 15.2.14.4.14(x) */
mrb_define_method(mrb, r, "initialize_copy", range_initialize_copy, ARGS_REQ(1)); /* 15.2.14.4.15(x) */
}
/*
* Document-class: Cache
*
* <code>Cache</code> provides for a Hashtable of strings in shared
* memory (via a memory mapped file), which thus can be shared between
* processes on a computer. Here is an example of its usage:
*
* $lm = Cache.new :namespace => "viewcounters"
* $lm[:foo] = 1
* $lm[:foo] # -> "1"
* $lm.delete(:foo)
*
* <code>Cache</code> can also be used as a persistent key value
* database, just use the :filename instead of the :namespace parameter.
*
* $lm = Cache.new :filename => "my-database.lmc"
* $lm[:foo] = 1
* $lm[:foo] # -> "1"
* $lm.delete(:foo)
*
* == Default sizes of memory pools
*
* The default size for memory pools is 1024 (MB). It cannot be changed later,
* so choose a size that will provide enough space for all your data. You
* might consider setting this size to the maximum filesize of your
* filesystem. Also note that while these memory pools may look large on your
* disk, they really aren't, because with sparse files only those parts of the
* file which contain non-null data actually use disk space.
*
* == Automatic recovery from crashes
*
* In case a process is terminated while accessing a memory pool, other
* processes will wait for the lock up to 2 seconds, and will then try to
* resume the aborted operation. This can also be done explicitly by using
* Cache.check(options).
*
* == Clearing memory pools
*
* Removing memory pools can be done with Cache.drop(options).
*
* == Environment
*
* If you use the :namespace parameter, the .lmc file for your namespace will
* reside in /var/tmp/Cache. This can be overriden by setting the
* LMC_NAMESPACES_ROOT_PATH variable in the environment.
*
* == Storing Ruby Objects
*
* If you want to store Ruby objects instead of just strings, consider
* using Cache::SharedObjectStorage.
*
*/
void mrb_mruby_cache_gem_init(mrb_state *mrb)
{
struct RClass *Cache;
lmc_init();
Cache = mrb_define_class(mrb, "Cache", mrb->object_class);
MRB_SET_INSTANCE_TT(Cache, MRB_TT_DATA);
mrb_define_method(mrb, Cache, "initialize", Cache_init, MRB_ARGS_REQ(1));
mrb_define_singleton_method(mrb, (struct RObject *)Cache, "drop", Cache__drop, MRB_ARGS_REQ(1));
mrb_define_singleton_method(mrb, (struct RObject *)Cache, "disable_test_crash", Cache__disable_test_crash,
MRB_ARGS_NONE());
mrb_define_singleton_method(mrb, (struct RObject *)Cache, "enable_test_crash", Cache__enable_test_crash,
MRB_ARGS_NONE());
mrb_define_method(mrb, Cache, "get", Cache__get, MRB_ARGS_REQ(1));
mrb_define_method(mrb, Cache, "[]", Cache__get, MRB_ARGS_REQ(1));
mrb_define_method(mrb, Cache, "delete", Cache__delete, MRB_ARGS_REQ(1));
mrb_define_method(mrb, Cache, "set", Cache__set, MRB_ARGS_REQ(2));
mrb_define_method(mrb, Cache, "clear", Cache__clear, MRB_ARGS_NONE());
mrb_define_method(mrb, Cache, "[]=", Cache__set, MRB_ARGS_REQ(2));
mrb_define_method(mrb, Cache, "close", Cache__close, MRB_ARGS_NONE());
mrb_define_method(mrb, Cache, "size", Cache__size, MRB_ARGS_NONE());
mrb_define_method(mrb, Cache, "shm_status", Cache__shm_status, MRB_ARGS_NONE());
mrb_define_method(mrb, Cache, "check_consistency", Cache__check_consistency, MRB_ARGS_NONE());
// mrb_define_method(mrb, Cache, "keys", Cache__keys, MRB_ARGS_NONE());
DONE;
}
void
fontBindingInit(mrb_state *mrb)
{
RClass *klass = mrb_define_class(mrb, "Font", 0);
Font::setDefaultColor(new Color(*Font::getDefaultColor()));
wrapProperty(mrb, mrb_obj_value(klass), Font::getDefaultColor(), CSdefault_color, ColorType);
mrb_define_class_method(mrb, klass, "exist?", fontDoesExist, MRB_ARGS_REQ(1));
INIT_KLASS_PROP_BIND(Font, DefaultName, "default_name");
INIT_KLASS_PROP_BIND(Font, DefaultSize, "default_size");
INIT_KLASS_PROP_BIND(Font, DefaultBold, "default_bold");
INIT_KLASS_PROP_BIND(Font, DefaultItalic, "default_italic");
INIT_KLASS_PROP_BIND(Font, DefaultColor, "default_color");
mrb_define_method(mrb, klass, "initialize", fontInitialize, MRB_ARGS_OPT(2));
INIT_PROP_BIND(Font, Name, "name");
INIT_PROP_BIND(Font, Size, "size");
INIT_PROP_BIND(Font, Bold, "bold");
INIT_PROP_BIND(Font, Italic, "italic");
INIT_PROP_BIND(Font, Color, "color");
mrb_define_method(mrb, klass, "inspect", inspectObject, MRB_ARGS_NONE());
}
int main(int argc, char *argv[])
{
mrb_state *mrb = mrb_open();
mrb_value ARGV = mrb_ary_new_capa(mrb, argc);
int i;
int return_value;
struct RClass *c = mrb_define_class(mrb, "Timeout", mrb->object_class);
mrb_define_method(mrb, c, "alarm", mrb_alarm, MRB_ARGS_REQ(1));
for (i = 0; i < argc; i++) {
mrb_ary_push(mrb, ARGV, mrb_str_new_cstr(mrb, argv[i]));
}
mrb_define_global_const(mrb, "ARGV", ARGV);
// call __main__(ARGV)
mrb_funcall(mrb, mrb_top_self(mrb), "__main__", 1, ARGV);
return_value = EXIT_SUCCESS;
if (mrb->exc) {
mrb_print_error(mrb);
return_value = EXIT_FAILURE;
}
mrb_close(mrb);
return return_value;
}
void
mrb_mruby_mindstorms_ev3_gem_init(mrb_state* mrb) {
struct RClass *ev3_class = mrb_define_class(mrb, "EV3", mrb->object_class);
mrb_define_method(mrb, ev3_class, "initialize", mrb_ev3_initialize, ARGS_NONE());
mrb_define_method(mrb, ev3_class, "keypad?", mrb_ev3_keypad, MRB_ARGS_REQ(1));
mrb_define_method(mrb, ev3_class, "led=", mrb_ev3_set_led, MRB_ARGS_REQ(1));
}
//**************************************************
// ライブラリを定義します
//**************************************************
void serial_Init(mrb_state* mrb) {
RbSerial[0] = &Serial; //0:Serial(USB)
RbSerial[1] = &Serial1; //1:Serial1
RbSerial[2] = &Serial2; //2:Serial3
RbSerial[3] = &Serial3; //3:Serial2
RbSerial[4] = &Serial4; //4:Serial6
RbSerial[5] = &Serial5; //5:Serial7
struct RClass *serialModule = mrb_define_class(mrb, "Serial", mrb->object_class);
MRB_SET_INSTANCE_TT(serialModule, MRB_TT_DATA);
mrb_define_method(mrb, serialModule, "initialize", mrb_serial_initialize, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
mrb_define_method(mrb, serialModule, "bps", mrb_serial_bps, MRB_ARGS_REQ(1));
mrb_define_method(mrb, serialModule, "print", mrb_serial_print, MRB_ARGS_OPT(1));
mrb_define_method(mrb, serialModule, "println", mrb_serial_println, MRB_ARGS_OPT(1));
mrb_define_method(mrb, serialModule, "read", mrb_serial_read, MRB_ARGS_NONE());
mrb_define_method(mrb, serialModule, "write", mrb_serial_write, MRB_ARGS_REQ(2));
mrb_define_method(mrb, serialModule, "flash", mrb_serial_flash, MRB_ARGS_NONE());
mrb_define_method(mrb, serialModule, "available", mrb_serial_available, MRB_ARGS_NONE());
//struct RClass *wifiModule = mrb_define_module(mrb, "WiFi");
//mrb_define_module_function(mrb, wifiModule, "bypass", mrb_wifi_bypass, MRB_ARGS_NONE());
}
void mrb_vmod_fetch_define(mrb_state *mrb)
{
struct RClass *varnish, *fetch;
varnish = mrb_class_get(mrb, "Varnish");
fetch = mrb_define_class(mrb, "Fetch", varnish);
mrb_define_method(mrb, fetch, "initialize", mrb_vmod_fetch_init, MRB_ARGS_NONE() );
}
void mrb_vmod_hit_define(mrb_state *mrb)
{
struct RClass *varnish, *hit;
varnish = mrb_class_get(mrb, "Varnish");
hit = mrb_define_class(mrb, "Hit", varnish);
mrb_define_method(mrb, hit, "initialize", mrb_vmod_hit_init, MRB_ARGS_NONE() );
}
void mrb_vmod_deliver_define(mrb_state *mrb)
{
struct RClass *action, *deliver;
action = mrb_class_get(mrb, "Action");
deliver = mrb_define_class(mrb, "Deliver", action);
mrb_define_method(mrb, deliver, "initialize", mrb_vmod_deliver_init, MRB_ARGS_NONE() );
}
void
mrb_mruby_fake_gem_gem_init(mrb_state* mrb) {
struct RClass *fakeClass = mrb_define_class(mrb, "Fake", mrb->object_class);
mrb_define_method(mrb, fakeClass, "c_method1", fake_c_method1, ARGS_NONE());
mrb_define_method(mrb, fakeClass, "c_method2", fake_c_method2, ARGS_NONE());
}
/*
* A <code>Struct</code> is a convenient way to bundle a number of
* attributes together, using accessor methods, without having to write
* an explicit class.
*
* The <code>Struct</code> class is a generator of specific classes,
* each one of which is defined to hold a set of variables and their
* accessors. In these examples, we'll call the generated class
* ``<i>Customer</i>Class,'' and we'll show an example instance of that
* class as ``<i>Customer</i>Inst.''
*
* In the descriptions that follow, the parameter <i>symbol</i> refers
* to a symbol, which is either a quoted string or a
* <code>Symbol</code> (such as <code>:name</code>).
*/
void
mrb_mruby_struct_gem_init(mrb_state* mrb)
{
struct RClass *st;
st = mrb_define_class(mrb, "Struct", mrb->object_class);
mrb_define_class_method(mrb, st, "new", mrb_struct_s_def, MRB_ARGS_ANY()); /* 15.2.18.3.1 */
mrb_define_method(mrb, st, "==", mrb_struct_equal, MRB_ARGS_REQ(1)); /* 15.2.18.4.1 */
mrb_define_method(mrb, st, "[]", mrb_struct_aref, MRB_ARGS_REQ(1)); /* 15.2.18.4.2 */
mrb_define_method(mrb, st, "[]=", mrb_struct_aset, MRB_ARGS_REQ(2)); /* 15.2.18.4.3 */
mrb_define_method(mrb, st, "members", mrb_struct_members_m, MRB_ARGS_NONE()); /* 15.2.18.4.6 */
mrb_define_method(mrb, st, "initialize", mrb_struct_initialize_m,MRB_ARGS_ANY()); /* 15.2.18.4.8 */
mrb_define_method(mrb, st, "initialize_copy", mrb_struct_init_copy, MRB_ARGS_REQ(1)); /* 15.2.18.4.9 */
mrb_define_method(mrb, st, "inspect", mrb_struct_inspect, MRB_ARGS_NONE()); /* 15.2.18.4.10(x) */
mrb_define_alias(mrb, st, "to_s", "inspect"); /* 15.2.18.4.11(x) */
mrb_define_method(mrb, st, "eql?", mrb_struct_eql, MRB_ARGS_REQ(1)); /* 15.2.18.4.12(x) */
mrb_define_method(mrb, st, "size", mrb_struct_len, MRB_ARGS_NONE());
mrb_define_method(mrb, st, "length", mrb_struct_len, MRB_ARGS_NONE());
mrb_define_method(mrb, st, "to_a", mrb_struct_to_a, MRB_ARGS_NONE());
mrb_define_method(mrb, st, "values", mrb_struct_to_a, MRB_ARGS_NONE());
mrb_define_method(mrb, st, "to_h", mrb_struct_to_h, MRB_ARGS_NONE());
mrb_define_method(mrb, st, "values_at", mrb_struct_values_at, MRB_ARGS_NONE());
}
void
mrb_init_hash(mrb_state *mrb)
{
struct RClass *h;
mrb->hash_class = h = mrb_define_class(mrb, "Hash", mrb->object_class); /* 15.2.13 */
MRB_SET_INSTANCE_TT(h, MRB_TT_HASH);
mrb_define_method(mrb, h, "[]", mrb_hash_aget, MRB_ARGS_REQ(1)); /* 15.2.13.4.2 */
mrb_define_method(mrb, h, "[]=", mrb_hash_aset, MRB_ARGS_REQ(2)); /* 15.2.13.4.3 */
mrb_define_method(mrb, h, "clear", mrb_hash_clear, MRB_ARGS_NONE()); /* 15.2.13.4.4 */
mrb_define_method(mrb, h, "default", mrb_hash_default, MRB_ARGS_ANY()); /* 15.2.13.4.5 */
mrb_define_method(mrb, h, "default=", mrb_hash_set_default, MRB_ARGS_REQ(1)); /* 15.2.13.4.6 */
mrb_define_method(mrb, h, "default_proc", mrb_hash_default_proc,MRB_ARGS_NONE()); /* 15.2.13.4.7 */
mrb_define_method(mrb, h, "default_proc=", mrb_hash_set_default_proc,MRB_ARGS_REQ(1)); /* 15.2.13.4.7 */
mrb_define_method(mrb, h, "__delete", mrb_hash_delete, MRB_ARGS_REQ(1)); /* core of 15.2.13.4.8 */
mrb_define_method(mrb, h, "empty?", mrb_hash_empty_p, MRB_ARGS_NONE()); /* 15.2.13.4.12 */
mrb_define_method(mrb, h, "has_key?", mrb_hash_has_key, MRB_ARGS_REQ(1)); /* 15.2.13.4.13 */
mrb_define_method(mrb, h, "has_value?", mrb_hash_has_value, MRB_ARGS_REQ(1)); /* 15.2.13.4.14 */
mrb_define_method(mrb, h, "include?", mrb_hash_has_key, MRB_ARGS_REQ(1)); /* 15.2.13.4.15 */
mrb_define_method(mrb, h, "initialize", mrb_hash_init, MRB_ARGS_OPT(1)); /* 15.2.13.4.16 */
mrb_define_method(mrb, h, "key?", mrb_hash_has_key, MRB_ARGS_REQ(1)); /* 15.2.13.4.18 */
mrb_define_method(mrb, h, "keys", mrb_hash_keys, MRB_ARGS_NONE()); /* 15.2.13.4.19 */
mrb_define_method(mrb, h, "length", mrb_hash_size_m, MRB_ARGS_NONE()); /* 15.2.13.4.20 */
mrb_define_method(mrb, h, "member?", mrb_hash_has_key, MRB_ARGS_REQ(1)); /* 15.2.13.4.21 */
mrb_define_method(mrb, h, "shift", mrb_hash_shift, MRB_ARGS_NONE()); /* 15.2.13.4.24 */
mrb_define_method(mrb, h, "dup", mrb_hash_dup, MRB_ARGS_NONE());
mrb_define_method(mrb, h, "size", mrb_hash_size_m, MRB_ARGS_NONE()); /* 15.2.13.4.25 */
mrb_define_method(mrb, h, "store", mrb_hash_aset, MRB_ARGS_REQ(2)); /* 15.2.13.4.26 */
mrb_define_method(mrb, h, "value?", mrb_hash_has_value, MRB_ARGS_REQ(1)); /* 15.2.13.4.27 */
mrb_define_method(mrb, h, "values", mrb_hash_values, MRB_ARGS_NONE()); /* 15.2.13.4.28 */
mrb_define_method(mrb, h, "to_hash", mrb_hash_to_hash, MRB_ARGS_NONE()); /* 15.2.13.4.29 (x)*/
}
void
mrb_init_file(mrb_state *mrb)
{
struct RClass *io, *file, *cnst;
io = mrb_class_get(mrb, "IO");
file = mrb_define_class(mrb, "File", io);
MRB_SET_INSTANCE_TT(file, MRB_TT_DATA);
mrb_define_class_method(mrb, file, "umask", mrb_file_s_umask, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "delete", mrb_file_s_unlink, MRB_ARGS_ANY());
mrb_define_class_method(mrb, file, "unlink", mrb_file_s_unlink, MRB_ARGS_ANY());
mrb_define_class_method(mrb, file, "rename", mrb_file_s_rename, MRB_ARGS_REQ(2));
mrb_define_class_method(mrb, file, "dirname", mrb_file_dirname, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "basename", mrb_file_basename, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb, file, "realpath", mrb_file_realpath, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
mrb_define_class_method(mrb, file, "_getwd", mrb_file__getwd, MRB_ARGS_NONE());
mrb_define_class_method(mrb, file, "_gethome", mrb_file__gethome, MRB_ARGS_OPT(1));
#ifndef _WIN32
mrb_define_method(mrb, file, "flock", mrb_file_flock, MRB_ARGS_REQ(1));
#endif
cnst = mrb_define_module_under(mrb, file, "Constants");
mrb_define_const(mrb, cnst, "LOCK_SH", mrb_fixnum_value(LOCK_SH));
mrb_define_const(mrb, cnst, "LOCK_EX", mrb_fixnum_value(LOCK_EX));
mrb_define_const(mrb, cnst, "LOCK_UN", mrb_fixnum_value(LOCK_UN));
mrb_define_const(mrb, cnst, "LOCK_NB", mrb_fixnum_value(LOCK_NB));
mrb_define_const(mrb, cnst, "SEPARATOR", mrb_str_new_cstr(mrb, FILE_SEPARATOR));
mrb_define_const(mrb, cnst, "NULL", mrb_str_new_cstr(mrb, NULL_FILE));
}
int main(void)
{
/* new interpreter instance */
mrb_state *mrb;
mrb = mrb_open();
/* modify interpreter state */
// FakeLED class
struct RClass *fake_led_class = mrb_define_class(mrb, "FakeLED", mrb->object_class);
// Instance methods in FakeLED
mrb_define_method(mrb, fake_led_class, "initialize", fake_led_init, MRB_ARGS_REQ(1));
mrb_define_method(mrb, fake_led_class, "illuminate!", fake_led_illuminate, MRB_ARGS_REQ(1));
// Constants nested in FakeLED, eg FakeLED::RED
// They define the available colors of LED (maybe these would be pin numbers IRL)
mrb_define_const(mrb, fake_led_class, "RED", mrb_str_new(mrb, KRED, 4));
mrb_define_const(mrb, fake_led_class, "BLUE", mrb_str_new(mrb, KBLU, 4));
mrb_define_const(mrb, fake_led_class, "GREEN", mrb_str_new(mrb, KGRN, 4));
/* read and execute compiled symbols */
mrb_load_irep(mrb, hello_embedded_ruby);
mrb_close(mrb);
return 0;
}
//----------------------------------------------------------
void BindImage::Bind(mrb_state* mrb)
{
struct RClass *cc = mrb_define_class(mrb, "Image", mrb->object_class);
mrb_define_class_method(mrb , cc, "load", load, MRB_ARGS_REQ(1));
mrb_define_class_method(mrb , cc, "grab_screen", grab_screen, MRB_ARGS_OPT(4));
mrb_define_method(mrb, cc, "clone", clone, MRB_ARGS_NONE());
mrb_define_method(mrb, cc, "save", save, MRB_ARGS_ARG(2, 1));
mrb_define_method(mrb, cc, "color", color, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "set_color", set_color, MRB_ARGS_REQ(3));
mrb_define_method(mrb, cc, "resize", resize, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "set_image_type", set_image_type, MRB_ARGS_REQ(1));
mrb_define_method(mrb, cc, "crop", crop, MRB_ARGS_REQ(4));
mrb_define_method(mrb, cc, "crop!", crop_bang, MRB_ARGS_REQ(4));
mrb_define_method(mrb, cc, "rotate90", rotate90, MRB_ARGS_OPT(1));
mrb_define_method(mrb, cc, "mirror", mirror, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "update", update, MRB_ARGS_NONE());
mrb_define_method(mrb, cc, "set_anchor_percent", set_anchor_percent, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "set_anchor_point", set_anchor_point, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "reset_anchor", reset_anchor, MRB_ARGS_REQ(2));
mrb_define_method(mrb, cc, "draw", draw, MRB_ARGS_ARG(2, 2));
mrb_define_method(mrb, cc, "draw_sub", draw_sub, MRB_ARGS_ARG(6, 2));
mrb_define_method(mrb, cc, "height", height, MRB_ARGS_NONE());
mrb_define_method(mrb, cc, "width", width, MRB_ARGS_NONE());
mrb_define_method(mrb, cc, "each_pixels", each_pixels, MRB_ARGS_OPT(2));
mrb_define_method(mrb, cc, "map_pixels", map_pixels, MRB_ARGS_OPT(2));
}
void
mrb_mruby_require_gem_init(mrb_state* mrb)
{
char *env;
struct RClass *krn;
krn = mrb->kernel_module;
struct RClass *load_error;
mrb_define_method(mrb, krn, "load", mrb_f_load, MRB_ARGS_REQ(1));
mrb_define_method(mrb, krn, "require", mrb_f_require, MRB_ARGS_REQ(1));
load_error = mrb_define_class(mrb, "LoadError", E_SCRIPT_ERROR);
mrb_define_method(mrb, load_error, "path", mrb_load_error_path, MRB_ARGS_NONE());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$:"), mrb_init_load_path(mrb));
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$\""), mrb_ary_new(mrb));
env = getenv("MRUBY_REQUIRE");
if (env != NULL) {
int i, envlen;
envlen = strlen(env);
for (i = 0; i < envlen; i++) {
char *ptr = env + i;
char *end = strchr(ptr, ',');
int len;
if (end == NULL) {
end = env + envlen;
}
len = end - ptr;
mrb_require(mrb, mrb_str_new(mrb, ptr, len));
i += len;
}
}
}
void
mrb_system_init(mrb_state* mrb)
{
struct RClass *platform;
struct RClass *audio;
struct RClass *system;
platform = mrb_define_class(mrb, "Platform", mrb->object_class);
audio = mrb_define_class_under(mrb, platform, "Audio", mrb->object_class);
system = mrb_define_class_under(mrb, platform, "System", mrb->object_class);
mrb_define_class_method(mrb , system , "serial" , mrb_system_s_serial , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "backlight=" , mrb_system_s__set_backlight , MRB_ARGS_REQ(1));
mrb_define_class_method(mrb , system , "battery" , mrb_system_s_battery , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "_power_supply" , mrb_s__power_supply , MRB_ARGS_NONE());
mrb_define_class_method(mrb , audio , "beep" , mrb_audio_s__beep , MRB_ARGS_REQ(2));
mrb_define_class_method(mrb , system , "reboot" , mrb_system_s_reboot , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "hwclock" , mrb_system_s_hwclock , MRB_ARGS_REQ(7));
mrb_define_class_method(mrb , system , "model" , mrb_system_s_model , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "brand" , mrb_system_s_brand , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "os_version" , mrb_system_s_os_version , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "sdk_version" , mrb_system_s_sdk_version , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "pinpad_version" , mrb_system_s_pinpad_version , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "install" , mrb_system_s_install , MRB_ARGS_REQ(3));
mrb_define_class_method(mrb , system , "get_time" , mrb_system_s_get_time , MRB_ARGS_NONE());
mrb_define_class_method(mrb , system , "status_bar" , mrb_system_s_status_bar , MRB_ARGS_REQ(4));
}
void
mrb_init_io(mrb_state *mrb)
{
struct RClass *io;
io = mrb_define_class(mrb, "IO", mrb->object_class);
MRB_SET_INSTANCE_TT(io, MRB_TT_DATA);
mrb_include_module(mrb, io, mrb_module_get(mrb, "Enumerable")); /* 15.2.20.3 */
#ifndef _WIN32
mrb_define_class_method(mrb, io, "_popen", mrb_io_s_popen, MRB_ARGS_ANY());
mrb_define_class_method(mrb, io, "_sysclose", mrb_io_s_sysclose, MRB_ARGS_REQ(1));
#endif
mrb_define_class_method(mrb, io, "select", mrb_io_s_select, MRB_ARGS_ANY());
mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, MRB_ARGS_ANY());
mrb_define_method(mrb, io, "initialize", mrb_io_initialize, MRB_ARGS_ANY()); /* 15.2.20.5.21 (x)*/
mrb_define_method(mrb, io, "sync", mrb_io_sync, MRB_ARGS_NONE());
mrb_define_method(mrb, io, "sync=", mrb_io_set_sync, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "sysread", mrb_io_sysread, MRB_ARGS_ANY());
mrb_define_method(mrb, io, "sysseek", mrb_io_sysseek, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "syswrite", mrb_io_syswrite, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "close", mrb_io_close, MRB_ARGS_NONE()); /* 15.2.20.5.1 */
mrb_define_method(mrb, io, "close_on_exec=", mrb_io_set_close_on_exec, MRB_ARGS_REQ(1));
mrb_define_method(mrb, io, "close_on_exec?", mrb_io_close_on_exec_p, MRB_ARGS_NONE());
mrb_define_method(mrb, io, "closed?", mrb_io_closed, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
mrb_define_method(mrb, io, "pid", mrb_io_pid, MRB_ARGS_NONE()); /* 15.2.20.5.2 */
mrb_define_method(mrb, io, "fileno", mrb_io_fileno, MRB_ARGS_NONE());
mrb_gv_set(mrb, mrb_intern_cstr(mrb, "$/"), mrb_str_new_cstr(mrb, "\n"));
}
void
mrb_init_io(mrb_state *mrb)
{
struct RClass *io;
io = mrb_define_class(mrb, "IO", mrb->object_class);
MRB_SET_INSTANCE_TT(io, MRB_TT_DATA);
mrb_include_module(mrb, io, mrb_class_get(mrb, "Enumerable")); /* 15.2.20.3 */
mrb_define_class_method(mrb, io, "_popen", mrb_io_s_popen, ARGS_ANY());
mrb_define_class_method(mrb, io, "for_fd", mrb_io_s_for_fd, ARGS_REQ(1)|ARGS_OPT(2));
mrb_define_class_method(mrb, io, "sysopen", mrb_io_s_sysopen, ARGS_ANY());
mrb_define_method(mrb, io, "_bless", mrb_io_bless, ARGS_NONE());
mrb_define_method(mrb, io, "initialize", mrb_io_initialize, ARGS_ANY()); /* 15.2.20.5.21 (x)*/
mrb_define_method(mrb, io, "sysread", mrb_io_sysread, ARGS_ANY());
mrb_define_method(mrb, io, "sysseek", mrb_io_sysseek, ARGS_REQ(1));
mrb_define_method(mrb, io, "syswrite", mrb_io_syswrite, ARGS_REQ(1));
mrb_define_method(mrb, io, "close", mrb_io_close, ARGS_NONE()); /* 15.2.20.5.1 */
mrb_define_method(mrb, io, "closed?", mrb_io_closed, ARGS_NONE()); /* 15.2.20.5.2 */
mrb_define_method(mrb, io, "pid", mrb_io_pid, ARGS_NONE()); /* 15.2.20.5.2 */
mrb_define_method(mrb, io, "fileno", mrb_io_fileno, ARGS_NONE());
mrb_gv_set(mrb, mrb_intern(mrb, "$/"), mrb_str_new_cstr(mrb, "\n"));
}
void
mrb_init_proc(mrb_state *mrb)
{
struct RProc *m;
mrb_irep *call_irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep));
static const mrb_irep mrb_irep_zero = { 0 };
if (call_irep == NULL)
return;
*call_irep = mrb_irep_zero;
call_irep->flags = MRB_ISEQ_NO_FREE;
call_irep->iseq = call_iseq;
call_irep->ilen = 1;
mrb->proc_class = mrb_define_class(mrb, "Proc", mrb->object_class);
MRB_SET_INSTANCE_TT(mrb->proc_class, MRB_TT_PROC);
mrb_define_method(mrb, mrb->proc_class, "initialize", mrb_proc_initialize, MRB_ARGS_NONE());
mrb_define_method(mrb, mrb->proc_class, "initialize_copy", mrb_proc_init_copy, MRB_ARGS_REQ(1));
mrb_define_method(mrb, mrb->proc_class, "arity", mrb_proc_arity, MRB_ARGS_NONE());
m = mrb_proc_new(mrb, call_irep);
mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m);
mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m);
mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.2.6 */
mrb_define_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.3.27 */
}
void
mrb_mruby_time_gem_init(mrb_state* mrb)
{
struct RClass *tc;
/* ISO 15.2.19.2 */
tc = mrb_define_class(mrb, "Time", mrb->object_class);
MRB_SET_INSTANCE_TT(tc, MRB_TT_DATA);
mrb_include_module(mrb, tc, mrb_module_get(mrb, "Comparable"));
mrb_define_class_method(mrb, tc, "at", mrb_time_at, MRB_ARGS_ARG(1, 1)); /* 15.2.19.6.1 */
mrb_define_class_method(mrb, tc, "gm", mrb_time_gm, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.2 */
mrb_define_class_method(mrb, tc, "local", mrb_time_local, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.3 */
mrb_define_class_method(mrb, tc, "mktime", mrb_time_local, MRB_ARGS_ARG(1,6));/* 15.2.19.6.4 */
mrb_define_class_method(mrb, tc, "now", mrb_time_now, MRB_ARGS_NONE()); /* 15.2.19.6.5 */
mrb_define_class_method(mrb, tc, "utc", mrb_time_gm, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.6 */
mrb_define_method(mrb, tc, "==" , mrb_time_eq , MRB_ARGS_REQ(1));
mrb_define_method(mrb, tc, "<=>" , mrb_time_cmp , MRB_ARGS_REQ(1)); /* 15.2.19.7.1 */
mrb_define_method(mrb, tc, "+" , mrb_time_plus , MRB_ARGS_REQ(1)); /* 15.2.19.7.2 */
mrb_define_method(mrb, tc, "-" , mrb_time_minus , MRB_ARGS_REQ(1)); /* 15.2.19.7.3 */
mrb_define_method(mrb, tc, "to_s" , mrb_time_asctime, MRB_ARGS_NONE());
mrb_define_method(mrb, tc, "inspect", mrb_time_asctime, MRB_ARGS_NONE());
mrb_define_method(mrb, tc, "asctime", mrb_time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.4 */
mrb_define_method(mrb, tc, "ctime" , mrb_time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.5 */
mrb_define_method(mrb, tc, "day" , mrb_time_day , MRB_ARGS_NONE()); /* 15.2.19.7.6 */
mrb_define_method(mrb, tc, "dst?" , mrb_time_dst_p , MRB_ARGS_NONE()); /* 15.2.19.7.7 */
mrb_define_method(mrb, tc, "getgm" , mrb_time_getutc , MRB_ARGS_NONE()); /* 15.2.19.7.8 */
mrb_define_method(mrb, tc, "getlocal",mrb_time_getlocal,MRB_ARGS_NONE()); /* 15.2.19.7.9 */
mrb_define_method(mrb, tc, "getutc" , mrb_time_getutc , MRB_ARGS_NONE()); /* 15.2.19.7.10 */
mrb_define_method(mrb, tc, "gmt?" , mrb_time_utc_p , MRB_ARGS_NONE()); /* 15.2.19.7.11 */
mrb_define_method(mrb, tc, "gmtime" , mrb_time_utc , MRB_ARGS_NONE()); /* 15.2.19.7.13 */
mrb_define_method(mrb, tc, "hour" , mrb_time_hour, MRB_ARGS_NONE()); /* 15.2.19.7.15 */
mrb_define_method(mrb, tc, "localtime", mrb_time_localtime, MRB_ARGS_NONE()); /* 15.2.19.7.18 */
mrb_define_method(mrb, tc, "mday" , mrb_time_mday, MRB_ARGS_NONE()); /* 15.2.19.7.19 */
mrb_define_method(mrb, tc, "min" , mrb_time_min, MRB_ARGS_NONE()); /* 15.2.19.7.20 */
mrb_define_method(mrb, tc, "mon" , mrb_time_mon, MRB_ARGS_NONE()); /* 15.2.19.7.21 */
mrb_define_method(mrb, tc, "month", mrb_time_mon, MRB_ARGS_NONE()); /* 15.2.19.7.22 */
mrb_define_method(mrb, tc, "sec" , mrb_time_sec, MRB_ARGS_NONE()); /* 15.2.19.7.23 */
mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, MRB_ARGS_NONE()); /* 15.2.19.7.25 */
mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, MRB_ARGS_NONE()); /* 15.2.19.7.24 */
mrb_define_method(mrb, tc, "usec", mrb_time_usec, MRB_ARGS_NONE()); /* 15.2.19.7.26 */
mrb_define_method(mrb, tc, "utc" , mrb_time_utc, MRB_ARGS_NONE()); /* 15.2.19.7.27 */
mrb_define_method(mrb, tc, "utc?", mrb_time_utc_p,MRB_ARGS_NONE()); /* 15.2.19.7.28 */
mrb_define_method(mrb, tc, "wday", mrb_time_wday, MRB_ARGS_NONE()); /* 15.2.19.7.30 */
mrb_define_method(mrb, tc, "yday", mrb_time_yday, MRB_ARGS_NONE()); /* 15.2.19.7.31 */
mrb_define_method(mrb, tc, "year", mrb_time_year, MRB_ARGS_NONE()); /* 15.2.19.7.32 */
mrb_define_method(mrb, tc, "zone", mrb_time_zone, MRB_ARGS_NONE()); /* 15.2.19.7.33 */
mrb_define_method(mrb, tc, "initialize", mrb_time_initialize, MRB_ARGS_REQ(1)); /* 15.2.19.7.16 */
mrb_define_method(mrb, tc, "initialize_copy", mrb_time_initialize_copy, MRB_ARGS_REQ(1)); /* 15.2.19.7.17 */
/*
methods not available:
gmt_offset(15.2.19.7.12)
gmtoff(15.2.19.7.14)
utc_offset(15.2.19.7.29)
*/
}
void
mrb_mruby_skkdic_gem_init(mrb_state* mrb) {
struct RClass *skkdic = mrb_define_class(mrb, "SKKDic", mrb->object_class);
mrb_define_method(mrb, skkdic, "make_table",
mrb_skkdic_make_table, MRB_ARGS_REQ(1));
mrb_define_method(mrb, skkdic, "dict_data",
mrb_skkdic_dict_data, MRB_ARGS_REQ(2));
}
void
mrb_init_exception(mrb_state *mrb)
{
struct RClass *e;
mrb->eException_class = e = mrb_define_class(mrb, "Exception", mrb->object_class); /* 15.2.22 */
mrb_define_class_method(mrb, e, "exception", mrb_instance_new, ARGS_ANY());
mrb_define_method(mrb, e, "exception", exc_exception, ARGS_ANY());
mrb_define_method(mrb, e, "initialize", exc_initialize, ARGS_ANY());
mrb_define_method(mrb, e, "==", exc_equal, ARGS_REQ(1));
mrb_define_method(mrb, e, "to_s", exc_to_s, ARGS_NONE());
mrb_define_method(mrb, e, "message", exc_message, ARGS_NONE());
mrb_define_method(mrb, e, "inspect", exc_inspect, ARGS_NONE());
mrb->eStandardError_class = mrb_define_class(mrb, "StandardError", mrb->eException_class); /* 15.2.23 */
mrb_define_class(mrb, "RuntimeError", mrb->eStandardError_class); /* 15.2.28 */
}
static void mrb_init_js_func(mrb_state *mrb)
{
struct RClass *js;
js = MRB_UD_JS_FUNC_CLASS(mrb) = mrb_define_class(mrb, "JsFunc", mrb->object_class);
MRB_SET_INSTANCE_TT(js, MRB_TT_DATA);
mrb_define_method(mrb, js, "call", mrb_js_func_call, ARGS_ANY());
}
