void
mrb_mruby_opencv_highgui_init(mrb_state* mrb, struct RClass *class_cv) {
mrb_define_class_method(mrb, class_cv, "imshow", mrb_mruby_opencv_imshow, ARGS_OPT(2));
mrb_define_class_method(mrb, class_cv, "namedWindow", mrb_mruby_opencv_namedWindow, ARGS_ANY());
mrb_define_class_method(mrb, class_cv, "waitKey", mrb_mruby_opencv_waitKey, ARGS_ANY());
mrb_define_class_method(mrb, class_cv, "imread", mrb_mruby_opencv_imread, ARGS_OPT(1));
}
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_class_get(mrb, "Comparable"));
mrb_define_class_method(mrb, tc, "at", mrb_time_at, ARGS_ANY()); /* 15.2.19.6.1 */
mrb_define_class_method(mrb, tc, "gm", mrb_time_gm, ARGS_REQ(1)|ARGS_OPT(6)); /* 15.2.19.6.2 */
mrb_define_class_method(mrb, tc, "local", mrb_time_local, ARGS_REQ(1)|ARGS_OPT(6)); /* 15.2.19.6.3 */
mrb_define_class_method(mrb, tc, "mktime", mrb_time_local, ARGS_REQ(1)|ARGS_OPT(6));/* 15.2.19.6.4 */
mrb_define_class_method(mrb, tc, "now", mrb_time_now, ARGS_NONE()); /* 15.2.19.6.5 */
mrb_define_class_method(mrb, tc, "utc", mrb_time_gm, ARGS_REQ(1)|ARGS_OPT(6)); /* 15.2.19.6.6 */
mrb_define_method(mrb, tc, "==" , mrb_time_eq , ARGS_REQ(1));
mrb_define_method(mrb, tc, "<=>" , mrb_time_cmp , ARGS_REQ(1)); /* 15.2.19.7.1 */
mrb_define_method(mrb, tc, "+" , mrb_time_plus , ARGS_REQ(1)); /* 15.2.19.7.2 */
mrb_define_method(mrb, tc, "-" , mrb_time_minus , ARGS_REQ(1)); /* 15.2.19.7.3 */
mrb_define_method(mrb, tc, "to_s" , mrb_time_asctime, ARGS_NONE());
mrb_define_method(mrb, tc, "inspect", mrb_time_asctime, ARGS_NONE());
mrb_define_method(mrb, tc, "asctime", mrb_time_asctime, ARGS_NONE()); /* 15.2.19.7.4 */
mrb_define_method(mrb, tc, "ctime" , mrb_time_asctime, ARGS_NONE()); /* 15.2.19.7.5 */
mrb_define_method(mrb, tc, "day" , mrb_time_day , ARGS_NONE()); /* 15.2.19.7.6 */
mrb_define_method(mrb, tc, "dst?" , mrb_time_dstp , ARGS_NONE()); /* 15.2.19.7.7 */
mrb_define_method(mrb, tc, "getgm" , mrb_time_getutc , ARGS_NONE()); /* 15.2.19.7.8 */
mrb_define_method(mrb, tc, "getlocal",mrb_time_getlocal,ARGS_NONE()); /* 15.2.19.7.9 */
mrb_define_method(mrb, tc, "getutc" , mrb_time_getutc , ARGS_NONE()); /* 15.2.19.7.10 */
mrb_define_method(mrb, tc, "gmt?" , mrb_time_utcp , ARGS_NONE()); /* 15.2.19.7.11 */
mrb_define_method(mrb, tc, "gmtime" , mrb_time_utc , ARGS_NONE()); /* 15.2.19.7.13 */
mrb_define_method(mrb, tc, "hour" , mrb_time_hour, ARGS_NONE()); /* 15.2.19.7.15 */
mrb_define_method(mrb, tc, "localtime", mrb_time_localtime, ARGS_NONE()); /* 15.2.19.7.18 */
mrb_define_method(mrb, tc, "mday" , mrb_time_mday, ARGS_NONE()); /* 15.2.19.7.19 */
mrb_define_method(mrb, tc, "min" , mrb_time_min, ARGS_NONE()); /* 15.2.19.7.20 */
mrb_define_method(mrb, tc, "mon" , mrb_time_mon, ARGS_NONE()); /* 15.2.19.7.21 */
mrb_define_method(mrb, tc, "month", mrb_time_mon, ARGS_NONE()); /* 15.2.19.7.22 */
mrb_define_method(mrb, tc, "sec" , mrb_time_sec, ARGS_NONE()); /* 15.2.19.7.23 */
mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, ARGS_NONE()); /* 15.2.19.7.25 */
mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, ARGS_NONE()); /* 15.2.19.7.24 */
mrb_define_method(mrb, tc, "usec", mrb_time_usec, ARGS_NONE()); /* 15.2.19.7.26 */
mrb_define_method(mrb, tc, "utc" , mrb_time_utc, ARGS_NONE()); /* 15.2.19.7.27 */
mrb_define_method(mrb, tc, "utc?", mrb_time_utcp, ARGS_NONE()); /* 15.2.19.7.28 */
mrb_define_method(mrb, tc, "wday", mrb_time_wday, ARGS_NONE()); /* 15.2.19.7.30 */
mrb_define_method(mrb, tc, "yday", mrb_time_yday, ARGS_NONE()); /* 15.2.19.7.31 */
mrb_define_method(mrb, tc, "year", mrb_time_year, ARGS_NONE()); /* 15.2.19.7.32 */
mrb_define_method(mrb, tc, "zone", mrb_time_zone, ARGS_NONE()); /* 15.2.19.7.33 */
mrb_define_method(mrb, tc, "initialize", mrb_time_initialize, ARGS_REQ(1)); /* 15.2.19.7.16 */
mrb_define_method(mrb, tc, "initialize_copy", mrb_time_initialize_copy, 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_curl_gem_init(mrb_state* mrb)
{
struct RClass* _class_curl;
int ai = mrb_gc_arena_save(mrb); \
_class_curl = mrb_define_module(mrb, "Curl");
mrb_define_class_method(mrb, _class_curl, "get", mrb_curl_get, ARGS_REQ(1) | ARGS_OPT(1));
mrb_define_class_method(mrb, _class_curl, "post", mrb_curl_post, ARGS_REQ(2) | ARGS_OPT(1));
mrb_define_class_method(mrb, _class_curl, "send", mrb_curl_send, ARGS_REQ(2));
mrb_define_const(mrb, _class_curl, "SSL_VERIFYPEER", mrb_fixnum_value(1));
mrb_gc_arena_restore(mrb, ai);
}
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_math(mrb_state *mrb)
{
struct RClass *mrb_math;
mrb_math = mrb_define_module(mrb, "Math");
#ifdef M_PI
mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(M_PI));
#else
mrb_define_const(mrb, mrb_math, "PI", mrb_float_value(atan(1.0)*4.0));
#endif
#ifdef M_E
mrb_define_const(mrb, mrb_math, "E", mrb_float_value(M_E));
#else
mrb_define_const(mrb, mrb_math, "E", mrb_float_value(exp(1.0)));
#endif
#ifdef MRB_USE_FLOAT
mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(1e-5));
#else
mrb_define_const(mrb, mrb_math, "TOLERANCE", mrb_float_value(1e-12));
#endif
mrb_define_module_function(mrb, mrb_math, "sin", math_sin, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cos", math_cos, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "tan", math_tan, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "asin", math_asin, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "acos", math_acos, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atan", math_atan, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atan2", math_atan2, ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "sinh", math_sinh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cosh", math_cosh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "tanh", math_tanh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "asinh", math_asinh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "acosh", math_acosh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "atanh", math_atanh, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "exp", math_exp, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "log", math_log, ARGS_REQ(1)|ARGS_OPT(1));
mrb_define_module_function(mrb, mrb_math, "log2", math_log2, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "log10", math_log10, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "sqrt", math_sqrt, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "cbrt", math_cbrt, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "frexp", math_frexp, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "ldexp", math_ldexp, ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "hypot", math_hypot, ARGS_REQ(2));
mrb_define_module_function(mrb, mrb_math, "erf", math_erf, ARGS_REQ(1));
mrb_define_module_function(mrb, mrb_math, "erfc", math_erfc, ARGS_REQ(1));
}
void
mrb_http_init(mrb_state* mrb) {
_class_http = mrb_define_module(mrb, "HTTP");
_class_http_parser = mrb_define_class_under(mrb, _class_http, "Parser", mrb->object_class);
mrb_define_method(mrb, _class_http_parser, "initialize", mrb_http_parser_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_http_parser, "parse", mrb_http_parser_parse, ARGS_OPT(2));
mrb_define_method(mrb, _class_http_parser, "execute", mrb_http_parser_execute, ARGS_REQ(1));
_class_http_request = mrb_define_class_under(mrb, _class_http, "Request", mrb->object_class);
mrb_define_method(mrb, _class_http_request, "schema", mrb_http_request_schema, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "host", mrb_http_request_host, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "port", mrb_http_request_port, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "path", mrb_http_request_path, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "query", mrb_http_request_query, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "fragment", mrb_http_request_fragment, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "headers", mrb_http_request_headers, ARGS_NONE());
_class_http_response = mrb_define_class_under(mrb, _class_http, "Response", mrb->object_class);
}
void mrb_mruby_redis_gem_init(mrb_state *mrb)
{
struct RClass *redis;
redis = mrb_define_class(mrb, "Redis", mrb->object_class);
mrb_define_method(mrb, redis, "initialize", mrb_redis_connect, ARGS_ANY());
mrb_define_method(mrb, redis, "set", mrb_redis_set, ARGS_ANY());
mrb_define_method(mrb, redis, "get", mrb_redis_get, ARGS_ANY());
mrb_define_method(mrb, redis, "[]=", mrb_redis_set, ARGS_ANY());
mrb_define_method(mrb, redis, "[]", mrb_redis_get, ARGS_ANY());
mrb_define_method(mrb, redis, "del", mrb_redis_del, ARGS_ANY());
mrb_define_method(mrb, redis, "incr", mrb_redis_incr, ARGS_OPT(1));
mrb_define_method(mrb, redis, "decr", mrb_redis_decr, ARGS_OPT(1));
mrb_define_method(mrb, redis, "rpush", mrb_redis_rpush, ARGS_OPT(2));
mrb_define_method(mrb, redis, "lpush", mrb_redis_lpush, ARGS_OPT(2));
mrb_define_method(mrb, redis, "lrange", mrb_redis_lrange, ARGS_ANY());
mrb_define_method(mrb, redis, "ltrim", mrb_redis_ltrim, ARGS_ANY());
mrb_define_method(mrb, redis, "publish", mrb_redis_pub, ARGS_ANY());
mrb_define_method(mrb, redis, "close", mrb_redis_close, ARGS_NONE());
DONE;
}
void mrb_mruby_random_gem_init(mrb_state *mrb)
{
struct RClass *random;
mrb_define_method(mrb, mrb->kernel_module, "rand", mrb_random_g_rand, ARGS_OPT(1));
mrb_define_method(mrb, mrb->kernel_module, "srand", mrb_random_g_srand, ARGS_OPT(1));
random = mrb_define_class(mrb, "Random", mrb->object_class);
mrb_define_class_method(mrb, random, "rand", mrb_random_g_rand, ARGS_OPT(1));
mrb_define_class_method(mrb, random, "srand", mrb_random_g_srand, ARGS_OPT(1));
mrb_define_method(mrb, random, "initialize", mrb_random_init, ARGS_OPT(1));
mrb_define_method(mrb, random, "rand", mrb_random_rand, ARGS_OPT(1));
mrb_define_method(mrb, random, "srand", mrb_random_srand, ARGS_OPT(1));
}
void
mrb_mruby_process_gem_init(mrb_state *mrb)
{
struct RClass *p;
mrb_define_method(mrb, mrb->kernel_module, "exit", mrb_f_exit, ARGS_OPT(1));
mrb_define_method(mrb, mrb->kernel_module, "sleep", mrb_f_sleep, ARGS_ANY());
mrb_define_method(mrb, mrb->kernel_module, "system", mrb_f_system, ARGS_ANY());
p = mrb_define_module(mrb, "Process");
mrb_define_class_method(mrb, p, "kill", mrb_f_kill, ARGS_ANY());
mrb_define_class_method(mrb, p, "fork", mrb_f_fork, ARGS_NONE());
mrb_define_class_method(mrb, p, "waitpid", mrb_f_waitpid, ARGS_ANY());
mrb_define_class_method(mrb, p, "pid", mrb_f_pid, ARGS_NONE());
mrb_define_class_method(mrb, p, "ppid", mrb_f_ppid, ARGS_NONE());
mrb_gv_set(mrb, mrb_intern(mrb, "$$"), mrb_fixnum_value((mrb_int)getpid()));
}
void
mrb_init_array(mrb_state *mrb)
{
struct RClass *a;
a = mrb->array_class = mrb_define_class(mrb, "Array", mrb->object_class);
MRB_SET_INSTANCE_TT(a, MRB_TT_ARRAY);
mrb_include_module(mrb, a, mrb_class_get(mrb, "Enumerable"));
mrb_define_class_method(mrb, a, "[]", mrb_ary_s_create, ARGS_ANY()); /* 15.2.12.4.1 */
mrb_define_method(mrb, a, "*", mrb_ary_times, ARGS_REQ(1)); /* 15.2.12.5.1 */
mrb_define_method(mrb, a, "+", mrb_ary_plus, ARGS_REQ(1)); /* 15.2.12.5.2 */
mrb_define_method(mrb, a, "<<", mrb_ary_push_m, ARGS_REQ(1)); /* 15.2.12.5.3 */
mrb_define_method(mrb, a, "[]", mrb_ary_aget, ARGS_ANY()); /* 15.2.12.5.4 */
mrb_define_method(mrb, a, "[]=", mrb_ary_aset, ARGS_ANY()); /* 15.2.12.5.5 */
mrb_define_method(mrb, a, "clear", mrb_ary_clear, ARGS_NONE()); /* 15.2.12.5.6 */
mrb_define_method(mrb, a, "concat", mrb_ary_concat_m, ARGS_REQ(1)); /* 15.2.12.5.8 */
mrb_define_method(mrb, a, "delete_at", mrb_ary_delete_at, ARGS_REQ(1)); /* 15.2.12.5.9 */
mrb_define_method(mrb, a, "empty?", mrb_ary_empty_p, ARGS_NONE()); /* 15.2.12.5.12 */
mrb_define_method(mrb, a, "first", mrb_ary_first, ARGS_OPT(1)); /* 15.2.12.5.13 */
mrb_define_method(mrb, a, "index", mrb_ary_index_m, ARGS_REQ(1)); /* 15.2.12.5.14 */
mrb_define_method(mrb, a, "initialize_copy", mrb_ary_replace_m, ARGS_REQ(1)); /* 15.2.12.5.16 */
mrb_define_method(mrb, a, "join", mrb_ary_join_m, ARGS_ANY()); /* 15.2.12.5.17 */
mrb_define_method(mrb, a, "last", mrb_ary_last, ARGS_ANY()); /* 15.2.12.5.18 */
mrb_define_method(mrb, a, "length", mrb_ary_size, ARGS_NONE()); /* 15.2.12.5.19 */
mrb_define_method(mrb, a, "pop", mrb_ary_pop, ARGS_NONE()); /* 15.2.12.5.21 */
mrb_define_method(mrb, a, "push", mrb_ary_push_m, ARGS_ANY()); /* 15.2.12.5.22 */
mrb_define_method(mrb, a, "replace", mrb_ary_replace_m, ARGS_REQ(1)); /* 15.2.12.5.23 */
mrb_define_method(mrb, a, "reverse", mrb_ary_reverse, ARGS_NONE()); /* 15.2.12.5.24 */
mrb_define_method(mrb, a, "reverse!", mrb_ary_reverse_bang, ARGS_NONE()); /* 15.2.12.5.25 */
mrb_define_method(mrb, a, "rindex", mrb_ary_rindex_m, ARGS_REQ(1)); /* 15.2.12.5.26 */
mrb_define_method(mrb, a, "shift", mrb_ary_shift, ARGS_NONE()); /* 15.2.12.5.27 */
mrb_define_method(mrb, a, "size", mrb_ary_size, ARGS_NONE()); /* 15.2.12.5.28 */
mrb_define_method(mrb, a, "slice", mrb_ary_aget, ARGS_ANY()); /* 15.2.12.5.29 */
mrb_define_method(mrb, a, "unshift", mrb_ary_unshift_m, ARGS_ANY()); /* 15.2.12.5.30 */
mrb_define_method(mrb, a, "inspect", mrb_ary_inspect, ARGS_NONE()); /* 15.2.12.5.31 (x) */
mrb_define_alias(mrb, a, "to_s", "inspect"); /* 15.2.12.5.32 (x) */
mrb_define_method(mrb, a, "==", mrb_ary_equal, ARGS_REQ(1)); /* 15.2.12.5.33 (x) */
mrb_define_method(mrb, a, "eql?", mrb_ary_eql, ARGS_REQ(1)); /* 15.2.12.5.34 (x) */
mrb_define_method(mrb, a, "<=>", mrb_ary_cmp, ARGS_REQ(1)); /* 15.2.12.5.36 (x) */
}
void
mrb_mruby_thread_gem_init(mrb_state* mrb) {
struct RClass *_class_thread, *_class_mutex;
_class_thread = mrb_define_class(mrb, "Thread", mrb->object_class);
mrb_define_method(mrb, _class_thread, "initialize", mrb_thread_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_thread, "join", mrb_thread_join, ARGS_NONE());
mrb_define_method(mrb, _class_thread, "kill", mrb_thread_kill, ARGS_NONE());
mrb_define_method(mrb, _class_thread, "terminate", mrb_thread_kill, ARGS_NONE());
mrb_define_method(mrb, _class_thread, "alive?", mrb_thread_alive, ARGS_NONE());
mrb_define_module_function(mrb, _class_thread, "sleep", mrb_thread_sleep, ARGS_REQ(1));
_class_mutex = mrb_define_class(mrb, "Mutex", mrb->object_class);
mrb_define_method(mrb, _class_mutex, "initialize", mrb_mutex_init, ARGS_NONE());
mrb_define_method(mrb, _class_mutex, "lock", mrb_mutex_lock, ARGS_NONE());
mrb_define_method(mrb, _class_mutex, "try_lock", mrb_mutex_try_lock, ARGS_NONE());
mrb_define_method(mrb, _class_mutex, "locked?", mrb_mutex_locked, ARGS_NONE());
mrb_define_method(mrb, _class_mutex, "sleep", mrb_mutex_sleep, ARGS_REQ(1));
mrb_define_method(mrb, _class_mutex, "synchronize", mrb_mutex_synchronize, ARGS_REQ(1));
mrb_define_method(mrb, _class_mutex, "unlock", mrb_mutex_unlock, ARGS_NONE());
}
void mrb_mruby_vedis_gem_init(mrb_state *mrb)
{
struct RClass *vedis;
vedis = mrb_define_class(mrb, "Vedis", mrb->object_class);
mrb_define_method(mrb, vedis, "initialize", mrb_vedis_open, ARGS_OPT(1));
mrb_define_method(mrb, vedis, "set", mrb_vedis_set, ARGS_REQ(2));
mrb_define_method(mrb, vedis, "get", mrb_vedis_get, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "[]=", mrb_vedis_set, ARGS_REQ(2));
mrb_define_method(mrb, vedis, "[]", mrb_vedis_get, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "exec", mrb_vedis_exec, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "del", mrb_vedis_del, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "append", mrb_vedis_append, ARGS_REQ(2));
mrb_define_method(mrb, vedis, "<<", mrb_vedis_append_hash, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "exists?", mrb_vedis_exists, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "strlen", mrb_vedis_strlen, ARGS_REQ(1));
mrb_define_method(mrb, vedis, "close", mrb_vedis_close, ARGS_NONE());
DONE;
}
void
mrb_mruby_http_gem_init(mrb_state* mrb) {
_class_http = mrb_define_module(mrb, "HTTP");
_class_http_parser = mrb_define_class_under(mrb, _class_http, "Parser", mrb->object_class);
mrb_define_method(mrb, _class_http_parser, "initialize", mrb_http_parser_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_http_parser, "parse_request", mrb_http_parser_parse_request, ARGS_OPT(2));
mrb_define_method(mrb, _class_http_parser, "parse_url", mrb_http_parser_parse_url, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_parser, "execute", mrb_http_parser_execute, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_parser, "data=", mrb_http_data_set, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_parser, "data", mrb_http_data_get, ARGS_NONE());
_class_http_request = mrb_define_class_under(mrb, _class_http, "Request", mrb->object_class);
mrb_define_method(mrb, _class_http_request, "schema", mrb_http_request_schema, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "host", mrb_http_request_host, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "port", mrb_http_request_port, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "path", mrb_http_request_path, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "query", mrb_http_request_query, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "headers", mrb_http_request_headers, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "method", mrb_http_request_method, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "data=", mrb_http_data_set, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_request, "data", mrb_http_data_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "body=", mrb_http_request_body_set, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_request, "body", mrb_http_request_body_get, ARGS_NONE());
_class_http_url = mrb_define_class_under(mrb, _class_http, "URL", mrb->object_class);
mrb_define_method(mrb, _class_http_url, "schema", mrb_http_url_schema, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "host", mrb_http_url_host, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "port", mrb_http_url_port, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "path", mrb_http_url_path, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "query", mrb_http_url_query, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "fragment", mrb_http_url_fragment, ARGS_NONE());
mrb_define_class_method(mrb, _class_http_url, "encode", mrb_http_url_encode, ARGS_REQ(1));
mrb_define_class_method(mrb, _class_http_url, "decode", mrb_http_url_decode, ARGS_REQ(1));
_class_http_response = mrb_define_class_under(mrb, _class_http, "Response", mrb->object_class);
}
void define_digital_out(mrb_state* mrb, struct RClass* mbed_mod) {
// creating class DigitalOut
struct RClass *digital_out_class = mrb_define_class_under(mrb, mbed_mod, "DigitalOut", NULL);
MRB_SET_INSTANCE_TT(digital_out_class, MRB_TT_DATA);
mrb_define_method(mrb, digital_out_class, "initialize", mrb_digital_out_initialize, ARGS_REQ(1) | ARGS_OPT(1));
mrb_define_method(mrb, digital_out_class, "write", mrb_digital_out_write, ARGS_REQ(1));
mrb_define_method(mrb, digital_out_class, "read", mrb_digital_out_read, ARGS_NONE());
}
void
mrb_mruby_sqlite3_gem_init(mrb_state* mrb) {
struct RClass *_class_sqlite3;
struct RClass *_class_sqlite3_database;
struct RClass* _class_sqlite3_resultset;
ARENA_SAVE;
_class_sqlite3 = mrb_define_module(mrb, "SQLite3");
_class_sqlite3_database = mrb_define_class_under(mrb, _class_sqlite3, "Database", mrb->object_class);
mrb_define_method(mrb, _class_sqlite3_database, "initialize", mrb_sqlite3_database_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_sqlite3_database, "execute", mrb_sqlite3_database_execute, ARGS_ANY());
mrb_define_method(mrb, _class_sqlite3_database, "execute_batch", mrb_sqlite3_database_execute_batch, ARGS_ANY());
mrb_define_method(mrb, _class_sqlite3_database, "close", mrb_sqlite3_database_close, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "last_insert_rowid", mrb_sqlite3_database_last_insert_rowid, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "changes", mrb_sqlite3_database_changes, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "transaction", mrb_sqlite3_database_transaction, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "commit", mrb_sqlite3_database_commit, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_database, "rollback", mrb_sqlite3_database_rollback, ARGS_NONE());
ARENA_RESTORE;
_class_sqlite3_resultset = mrb_define_class_under(mrb, _class_sqlite3, "ResultSet", mrb->object_class);
mrb_define_method(mrb, _class_sqlite3_resultset, "next", mrb_sqlite3_resultset_next, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_resultset, "close", mrb_sqlite3_resultset_close, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_resultset, "fields", mrb_sqlite3_resultset_fields, ARGS_NONE());
mrb_define_method(mrb, _class_sqlite3_resultset, "eof?", mrb_sqlite3_resultset_eof, ARGS_NONE());
ARENA_RESTORE;
}
void
mrb_mruby_arduino_gem_init(mrb_state* mrb) {
RClass *serialClass = mrb_define_class(mrb, "Serial", mrb->object_class);
mrb_define_class_method(mrb, serialClass, "available", mrb_serial_available, ARGS_NONE());
mrb_define_class_method(mrb, serialClass, "begin",mrb_serial_begin, ARGS_REQ(1));
mrb_define_class_method(mrb, serialClass, "println", mrb_serial_println, ARGS_REQ(1));
RClass *servoClass = mrb_define_class(mrb, "Servo", mrb->object_class);
MRB_SET_INSTANCE_TT(servoClass, MRB_TT_DATA);
mrb_define_method(mrb, servoClass, "initialize", mrb_servo_initialize, ARGS_NONE());
mrb_define_method(mrb, servoClass, "attach", mrb_servo_attach, ARGS_REQ(1));
mrb_define_method(mrb, servoClass, "write", mrb_servo_write, ARGS_REQ(1));
mrb_define_method(mrb, servoClass, "detach", mrb_servo_detach, ARGS_NONE());
RClass *arduinoModule = mrb_define_module(mrb, "Arduino");
mrb_define_module_function(mrb, arduinoModule, "pinMode", mrb_arduino_pinMode, ARGS_REQ(2));
mrb_define_module_function(mrb, arduinoModule, "digitalWrite", mrb_arduino_digitalWrite, ARGS_REQ(2));
mrb_define_module_function(mrb, arduinoModule, "digitalRead", mrb_arduino_digitalRead, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "analogReference", mrb_arduino_analogReference, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "analogWrite", mrb_arduino_analogWrite, ARGS_REQ(2));
mrb_define_module_function(mrb, arduinoModule, "analogRead", mrb_arduino_analogRead, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "tone", mrb_arduino_tone, ARGS_REQ(2) | ARGS_OPT(1));
mrb_define_module_function(mrb, arduinoModule, "noTone", mrb_arduino_noTone, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "shiftOut", mrb_arduino_shiftOut, ARGS_REQ(4));
mrb_define_module_function(mrb, arduinoModule, "shiftIn", mrb_arduino_shiftOut, ARGS_REQ(3));
mrb_define_module_function(mrb, arduinoModule, "pulseIn", mrb_arduino_pulseIn, ARGS_REQ(2) | ARGS_OPT(1));
mrb_define_module_function(mrb, arduinoModule, "millis", mrb_arduino_millis, ARGS_NONE());
mrb_define_module_function(mrb, arduinoModule, "micros", mrb_arduino_micros, ARGS_NONE());
mrb_define_module_function(mrb, arduinoModule, "delay", mrb_arduino_delay, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "delayMicroseconds", mrb_arduino_delayMicroseconds, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "map", mrb_arduino_map, ARGS_REQ(5));
mrb_define_module_function(mrb, arduinoModule, "randomSeed", mrb_arduino_randomSeed, ARGS_REQ(1));
mrb_define_module_function(mrb, arduinoModule, "random", mrb_arduino_random, ARGS_REQ(1) | ARGS_OPT(1));
mrb_define_module_function(mrb, arduinoModule, "interrupts", mrb_arduino_interrupts, ARGS_NONE());
mrb_define_module_function(mrb, arduinoModule, "noInterrupts", mrb_arduino_noInterrupts, ARGS_NONE());
mrb_define_const(mrb, arduinoModule, "HIGH", mrb_fixnum_value(HIGH));
mrb_define_const(mrb, arduinoModule, "LOW", mrb_fixnum_value(LOW));
mrb_define_const(mrb, arduinoModule, "INPUT", mrb_fixnum_value(INPUT));
mrb_define_const(mrb, arduinoModule, "OUTPUT", mrb_fixnum_value(OUTPUT));
#ifdef INPUT_PULLUP
mrb_define_const(mrb, arduinoModule, "INPUT_PULLUP", mrb_fixnum_value(INPUT_PULLUP));
#endif
mrb_define_const(mrb, arduinoModule, "DEFAULT", mrb_fixnum_value(DEFAULT));
mrb_define_const(mrb, arduinoModule, "INTERNAL", mrb_fixnum_value(INTERNAL));
mrb_define_const(mrb, arduinoModule, "EXTERNAL", mrb_fixnum_value(EXTERNAL));
//for chipKit, below are not defined.
#ifdef INTERNAL1V1
mrb_define_const(mrb, arduinoModule, "INTERNAL1V1", mrb_fixnum_value(INTERNAL1V1));
#endif
#ifdef INTERNAL2V56
mrb_define_const(mrb, arduinoModule, "INTERNAL2V56", mrb_fixnum_value(INTERNAL2V56));
#endif
mrb_define_const(mrb, arduinoModule, "MSBFIRST", mrb_fixnum_value(MSBFIRST));
mrb_define_const(mrb, arduinoModule, "LSBFIRST", mrb_fixnum_value(LSBFIRST));
}
void
mrb_mruby_http_gem_init(mrb_state* mrb) {
struct RClass* _class_http;
struct RClass* _class_http_parser;
struct RClass* _class_http_request;
struct RClass* _class_http_response;
struct RClass *_class_http_url;
int ai = mrb_gc_arena_save(mrb);
_class_http = mrb_define_module(mrb, "HTTP");
_class_http_parser = mrb_define_class_under(mrb, _class_http, "Parser", mrb->object_class);
mrb_define_method(mrb, _class_http_parser, "initialize", mrb_http_parser_init, ARGS_OPT(1));
mrb_define_method(mrb, _class_http_parser, "parse_request", mrb_http_parser_parse_request, ARGS_OPT(2));
mrb_define_method(mrb, _class_http_parser, "parse_response", mrb_http_parser_parse_response, ARGS_OPT(2));
mrb_define_method(mrb, _class_http_parser, "parse_url", mrb_http_parser_parse_url, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_parser, "execute", mrb_http_parser_execute, ARGS_REQ(1));
mrb_gc_arena_restore(mrb, ai);
_class_http_request = mrb_define_class_under(mrb, _class_http, "Request", mrb->object_class);
mrb_define_method(mrb, _class_http_request, "initialize", mrb_http_object_initialize, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "schema", mrb_http_object_schema_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "host", mrb_http_object_host_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "port", mrb_http_object_port_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "path", mrb_http_object_path_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "query", mrb_http_object_query_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "headers", mrb_http_object_headers_get, ARGS_NONE());
//mrb_define_method(mrb, _class_http_request, "headers[]=", mrb_http_object_headers_set_item, ARGS_REQ(2));
mrb_define_method(mrb, _class_http_request, "method", mrb_http_object_method_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "method=", mrb_http_object_method_set, ARGS_REQ(1));
mrb_define_method(mrb, _class_http_request, "body", mrb_http_object_body_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_request, "body=", mrb_http_object_body_set, ARGS_REQ(1));
mrb_gc_arena_restore(mrb, ai);
_class_http_response = mrb_define_class_under(mrb, _class_http, "Response", mrb->object_class);
mrb_define_method(mrb, _class_http_response, "initialize", mrb_http_object_initialize, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "status_code", mrb_http_object_status_code_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "message", mrb_http_object_message_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "content_length", mrb_http_object_content_length_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "schema", mrb_http_object_schema_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "host", mrb_http_object_host_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "port", mrb_http_object_port_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "path", mrb_http_object_path_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "query", mrb_http_object_query_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "headers", mrb_http_object_headers_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "method", mrb_http_object_method_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "body", mrb_http_object_body_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_response, "body=", mrb_http_object_body_set, ARGS_REQ(1));
mrb_gc_arena_restore(mrb, ai);
_class_http_url = mrb_define_class_under(mrb, _class_http, "URL", mrb->object_class);
mrb_define_method(mrb, _class_http_url, "schema", mrb_http_object_schema_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "host", mrb_http_object_host_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "port", mrb_http_object_port_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "path", mrb_http_object_path_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "query", mrb_http_object_query_get, ARGS_NONE());
mrb_define_method(mrb, _class_http_url, "fragment", mrb_http_object_fragment_get, ARGS_NONE());
//mrb_define_method(mrb, _class_http_url, "to_url", mrb_http_url_to_url, ARGS_NONE());
mrb_define_class_method(mrb, _class_http_url, "encode", mrb_http_url_encode, ARGS_REQ(1));
mrb_define_class_method(mrb, _class_http_url, "decode", mrb_http_url_decode, ARGS_REQ(1));
mrb_gc_arena_restore(mrb, ai);
}
void mrb_mruby_ipvs_gem_init(mrb_state *mrb) {
/* Initialize IPVS module */
if (ipvs_init()) {
if (_modprobe_ipvs() || ipvs_init()) {
mrb_raise(mrb, E_RUNTIME_ERROR,
"Can't initialize ipvs.\n"
"Are you sure that IP Virtual Server is \n"
"built in the kernel or as module?\n");
}
}
struct RClass* _class_ipvs;
struct RClass* _class_ipvs_service;
struct RClass* _class_ipvs_dest;
_class_ipvs = mrb_define_class(mrb, "IPVS", mrb->object_class);
_class_ipvs_service = mrb_define_class_under(mrb, _class_ipvs, "Service", mrb->object_class);
mrb_define_method(mrb, _class_ipvs_service, "initialize", mrb_ipvs_service_init, ARGS_REQ(1));
mrb_define_method(mrb, _class_ipvs_service, "initialize_copy", mrb_ipvs_service_init_copy, ARGS_REQ(1) | ARGS_OPT(6));
mrb_define_method(mrb, _class_ipvs_service, "add_service", mrb_ipvs_service_add, ARGS_NONE());
mrb_define_method(mrb, _class_ipvs_service, "del_service", mrb_ipvs_service_del, ARGS_NONE());
mrb_define_method(mrb, _class_ipvs_service, "add_dest", mrb_ipvs_service_add_dest, ARGS_REQ(1));
mrb_define_method(mrb, _class_ipvs_service, "del_dest", mrb_ipvs_service_del_dest, ARGS_REQ(1));
mrb_define_method(mrb, _class_ipvs_service, "addr", mrb_ipvs_service_get_addr, ARGS_NONE());
mrb_define_method(mrb, _class_ipvs_service, "port", mrb_ipvs_service_get_port, ARGS_NONE());
mrb_define_method(mrb, _class_ipvs_service, "proto", mrb_ipvs_service_get_proto, ARGS_NONE());
mrb_define_method(mrb, _class_ipvs_service, "sched_name", mrb_ipvs_service_get_sched_name, ARGS_NONE());
// mrb_define_method(mrb, _class_ipvs_service, "timeout", mrb_ipvs_service_get_timeout, ARGS_NONE());
// mrb_define_method(mrb, _class_ipvs_service, "netmask", mrb_ipvs_service_get_netmask, ARGS_NONE());
// mrb_define_method(mrb, _class_ipvs_service, "ops", mrb_ipvs_service_get_ops, ARGS_NONE());
_class_ipvs_dest = mrb_define_class_under(mrb, _class_ipvs, "Dest", mrb->object_class);
mrb_define_method(mrb, _class_ipvs_dest, "initialize", mrb_ipvs_dest_init, ARGS_REQ(1));
mrb_define_method(mrb, _class_ipvs_dest, "addr", mrb_ipvs_service_get_addr, ARGS_NONE());
mrb_define_method(mrb, _class_ipvs_dest, "port", mrb_ipvs_service_get_port, ARGS_NONE());
mrb_define_method(mrb, _class_ipvs_dest, "weight", mrb_ipvs_dest_get_weight, ARGS_NONE());
mrb_define_method(mrb, _class_ipvs_dest, "weight=", mrb_ipvs_dest_set_weight, ARGS_NONE());
/* TODO:
- fwmark
- ipv6
- get_dests
- get_services
* */
}
