// mruby_run for not request phase.
static int ap_mruby_run_nr(const char *mruby_code_file)
{
int n;
struct mrb_parser_state* p;
FILE *mrb_file;
mrb_state *mrb = mrb_open();
ap_mruby_class_init(mrb);
if ((mrb_file = fopen(mruby_code_file, "r")) == NULL) {
ap_log_error(APLOG_MARK
, APLOG_ERR
, 0
, ap_server_conf
, "%s ERROR %s: mrb file oepn failed: %s"
, MODULE_NAME
, __func__
, mruby_code_file
);
mrb_close(mrb);
return -1;
}
ap_log_error(APLOG_MARK
, APLOG_DEBUG
, 0
, ap_server_conf
, "%s DEBUG %s: cache nothing on pid %d, compile code: %s"
, MODULE_NAME
, __func__
, getpid()
, mruby_code_file
);
p = mrb_parse_file(mrb, mrb_file, NULL);
fclose(mrb_file);
n = mrb_generate_code(mrb, p);
mrb_pool_close(p->pool);
ap_log_error(APLOG_MARK
, APLOG_DEBUG
, 0
, ap_server_conf
, "%s DEBUG %s: run mruby code: %s"
, MODULE_NAME
, __func__
, mruby_code_file
);
ap_mrb_set_status_code(OK);
mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
if (mrb->exc)
ap_mrb_raise_file_error_nr(mrb, mrb_obj_value(mrb->exc), mruby_code_file);
mrb_close(mrb);
return APR_SUCCESS;
}
static int
compile_rb2mrb(mrb_state *mrb0, const char *code, int code_len, const char *path, FILE* tmpfp)
{
mrb_state *mrb = mrb_open();
mrb_value result;
mrbc_context *c;
int ret = -1;
int debuginfo = 1;
mrb_irep *irep;
c = mrbc_context_new(mrb);
c->no_exec = 1;
if (path != NULL) {
mrbc_filename(mrb, c, path);
}
result = mrb_load_nstring_cxt(mrb, code, code_len, c);
if (mrb_undef_p(result)) {
mrbc_context_free(mrb, c);
mrb_close(mrb);
return MRB_DUMP_GENERAL_FAILURE;
}
irep = mrb_proc_ptr(result)->body.irep;
ret = mrb_dump_irep_binary(mrb, irep, debuginfo, tmpfp);
mrbc_context_free(mrb, c);
mrb_close(mrb);
return ret;
}
//----------------------------------------------------------
void ScriptEngine::close()
{
if (mErroredMrb) {
mrb_close(mErroredMrb);
mErroredMrb = NULL;
}
if (mMrb) {
mrb_close(mMrb);
mMrb = NULL;
}
}
int
main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
int n = -1;
struct _args args;
struct mrb_parser_state *p;
n = parse_args(mrb, argc, argv, &args);
if (n < 0 || args.rfp == NULL) {
cleanup(&args);
usage(argv[0]);
mrb_close(mrb);
return n;
}
p = mrb_parse_file(mrb, args.rfp);
if (!p || !p->tree || p->nerr) {
cleanup(&args);
mrb_close(mrb);
return -1;
}
if (args.verbose)
parser_dump(mrb, p->tree, 0);
n = mrb_generate_code(mrb, p->tree);
mrb_pool_close(p->pool);
if (args.verbose)
codedump_all(mrb, n);
if (n < 0 || args.check_syntax) {
cleanup(&args);
mrb_close(mrb);
return n;
}
if (args.initname) {
if (args.dump_type == DUMP_TYPE_BIN)
n = mrb_bdump_irep(mrb, n, args.wfp, args.initname);
else
n = mrb_cdump_irep(mrb, n, args.wfp, args.initname);
}
else {
n = mrb_dump_irep(mrb, n, args.wfp);
}
cleanup(&args);
mrb_close(mrb);
return n;
}
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;
}
int
main(int argc, char **argv)
{
mrb_state *mrb;
int ret;
print_hint();
/* new interpreter instance */
mrb = mrb_open();
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb_state, exiting test driver");
return EXIT_FAILURE;
}
if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'v') {
printf("verbose mode: enable\n\n");
mrb_gv_set(mrb, mrb->intern_cstr("$mrbtest_verbose"), mrb_true_value());
}
mrb_init_mrbtest(mrb);
ret = eval_test(mrb);
mrb_close(mrb);
return ret;
}
int main()
{
mrb_state* mrb = mrb_open();
// mrubyファイルをロードする
FILE *fd = fopen("person.mrb", "r");
mrb_load_irep_file(mrb, fd);
// *.rbを直接ロードする
// FILE *fd = fopen("person.rb", "r");
// mrb_load_file(mrb, fd);
// クラスオブジェクトを取得する
struct RClass *person = mrb_class_get(mrb, "Person");
// 引数をmrb_valueに変換する
mrb_value person_value = mrb_obj_value(person);
mrb_value name_value = mrb_str_new(mrb, "naoty", 5);
mrb_value age_value = mrb_fixnum_value(25);
// Person#newを呼び出す
mrb_value naoty = mrb_funcall(mrb, person_value, "new", 2, name_value, age_value);
// Person#greetingを呼び出す
mrb_value greeting_value = mrb_funcall(mrb, naoty, "greeting", 0);
// 返り値をchar*に変換して出力する
char *greeting = mrb_string_value_ptr(mrb, greeting_value);
printf("%s\n", greeting);
mrb_close(mrb);
return 0;
}
static void
cleanup(mrb_state *mrb, struct mrbc_args *args)
{
if (args->outfile)
mrb_free(mrb, (void*)args->outfile);
mrb_close(mrb);
}
int
main(int argc, char **argv)
{
struct strip_args args;
int args_result;
mrb_state *mrb;
int ret;
if (argc <= 1) {
printf("no files to strip\n");
print_usage(argv[0]);
return EXIT_FAILURE;
}
args_result = parse_args(argc, argv, &args);
if (args_result < 0) {
print_usage(argv[0]);
return EXIT_FAILURE;
}
mrb = mrb_open_core(mrb_default_allocf, NULL);
if (mrb == NULL) {
fputs("Invalid mrb_state, exiting mruby-strip\n", stderr);
return EXIT_FAILURE;
}
ret = strip(mrb, &args);
mrb_close(mrb);
return ret;
}
int main() {
FILE *fp;
if ((fp = fopen("./member.conf", "r")) == NULL)
return 1;
mrb_state* mrb = mrb_open();
mrb_load_file(mrb, fp);
mrb_value member;
mrb_get_config_value(mrb, "member", "o", &member);
mrb_value mnum = mrb_funcall(mrb, member, "size", 0);
int i;
int seki_num = mrb_fixnum(mnum);
for (i = 0; i < seki_num; i++) {
mnum = mrb_funcall(mrb, member, "size", 0);
mrb_value seki = mrb_funcall(mrb, mrb_top_self(mrb), "rand", 1, mnum);
mrb_p(mrb, mrb_funcall(mrb, member, "[]", 1, seki));
mrb_funcall(mrb, member, "delete_at", 1, seki);
}
mrb_close(mrb);
return 0;
}
int main(int argc, char *argv[])
{
mrb_state *mrb;
int ret = EXIT_SUCCESS;
/* create new interpreter instance */
mrb = mrb_open();
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb_state, exiting test driver.\n");
return EXIT_FAILURE;
}
/* load bytecode */
webruby_internal_run(mrb);
if (mrb->exc) {
/* an exception occurs */
fprintf(stderr, "An exception occurs when running mruby bytecodes!\n");
mrb_p(mrb, mrb_obj_value(mrb->exc));
mrb->exc = 0;
ret = EXIT_FAILURE;
}
mrb_close(mrb);
return ret;
}
void
test_gc_api(void)
{
mrb_state *mrb = mrb_open();
mrb_value res;
mrb_value argv[1];
puts("test_gc_api");
gc_start(mrb, mrb_nil_value());
res = gc_interval_ratio_get(mrb, mrb_nil_value());
gc_assert(mrb_fixnum(res) == 200);
argv[0] = mrb_fixnum_value(300);
mrb->argv = &argv;
mrb->argc = 1;
gc_interval_ratio_set(mrb, mrb_nil_value());
res = gc_interval_ratio_get(mrb, mrb_nil_value());
gc_assert(mrb_fixnum(res) == 300);
res = gc_step_ratio_get(mrb, mrb_nil_value());
gc_assert(mrb_fixnum(res) == 200);
gc_step_ratio_set(mrb, mrb_nil_value());
res = gc_step_ratio_get(mrb, mrb_nil_value());
gc_assert(mrb_fixnum(res) == 300);
mrb_close(mrb);
}
static ERL_NIF_TERM eval1(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
ErlNifBinary script_binary;
if (!enif_inspect_binary(env, argv[0], &script_binary)){
return enif_make_badarg(env);
}
mrb_state *mrb;
mrbc_context *cxt;
mrb = mrb_open();
if (mrb == NULL) {
return enif_make_atom(env, "error");
}
char *script = malloc(script_binary.size+1);
script[script_binary.size] = '\0';
strncpy(script, (const char *)script_binary.data, (int)script_binary.size);
ERL_NIF_TERM erl_result;
cxt = mrbc_context_new(mrb);
struct mrb_parser_state* st = mrb_parse_string(mrb, (const char *)script, cxt);
int n = mrb_generate_code(mrb, st);
mrb_pool_close(st->pool);
mrb_value result = mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value());
erl_result = mruby2erl(env, mrb, result);
free(script);
mrbc_context_free(mrb, cxt);
mrb_close(mrb);
enif_release_binary(&script_binary);
return erl_result;
}
int main ( int argc, char const *argv[] )
{
mrb_state *mrb = mrb_open();
// Load Ruby code defined in C (SimpleC)
init_simple_c( mrb );
// Load Ruby code compiled into C (SimpleRuby)
mrb_load_irep( mrb, &simple_ruby );
// Print with C
printf( "Hello from C!\n" );
// Print by evaluating Ruby from C
mrb_load_string( mrb, "puts 'Hello from MRuby!'" );
// Print by evaluating Ruby from C, using Class defined in compiled Ruby
mrb_load_string( mrb, "SimpleRuby.say_hi" );
// Print by evaluating Ruby from C, using Class defined in C
mrb_load_string( mrb, "SimpleC.say_hi" );
// Print by calling function directly from Class defined in compiled Ruby
struct RClass *simple_ruby_class = mrb_class_get(mrb, "SimpleRuby");
mrb_funcall(mrb, mrb_obj_value(simple_ruby_class), "say_hi", 0 );
// Print by calling function directly from Class defined in C
struct RClass *simple_c_class = mrb_class_get(mrb, "SimpleC");
mrb_funcall(mrb, mrb_obj_value(simple_c_class), "say_hi", 0 );
mrb_close( mrb ); // Not sure if this is really needed as we are exiting anyways but I'm afraid not to.
return 0;
}
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
test_gc_gray_mark(void)
{
mrb_state *mrb = mrb_open();
mrb_value obj_v, value_v;
struct RBasic *obj;
size_t gray_num = 0;
puts("test_gc_gray_mark");
puts(" in MRB_TT_CLASS");
obj = (struct RBasic*)mrb->object_class;
paint_gray(obj);
gray_num = gc_gray_mark(mrb, obj);
mrb_assert(is_black(obj));
mrb_assert(gray_num > 1);
puts(" in MRB_TT_ARRAY");
obj_v = mrb_ary_new(mrb);
value_v = mrb_str_new_lit(mrb, "test");
paint_gray(mrb_basic_ptr(obj_v));
paint_partial_white(mrb, mrb_basic_ptr(value_v));
mrb_ary_push(mrb, obj_v, value_v);
gray_num = gc_gray_mark(mrb, mrb_basic_ptr(obj_v));
mrb_assert(is_black(mrb_basic_ptr(obj_v)));
mrb_assert(is_gray(mrb_basic_ptr(value_v)));
mrb_assert(gray_num == 1);
mrb_close(mrb);
}
int main()
{
mrb_state *mrb;
int n;
FILE* f;
struct RClass* cObject;
mrbc_context *mrbc_ctx;
struct mrb_parser_state *p;
mrb = mrb_open();
mrbc_ctx = mrbc_context_new(mrb);
cObject = mrb_class_obj_get(mrb, "Object");
mrb_define_method(mrb, cObject, "plus", plus, ARGS_ANY());
//mrb_define_singleton_method(mrb, mrb_top_self(mrb), "plus", plus, ARGS_REQ(2));
f = fopen("step4.rb", "r");
if(f==NULL){ _error("file not found."); }
p = mrb_parse_file(mrb,f,mrbc_ctx);
fclose(f);
n = mrb_generate_code(mrb, p);
mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value());
mrb_parser_free(p);
mrbc_context_free(mrb,mrbc_ctx);
mrb_close(mrb);
return 0;
}
int
main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb_state, exiting driver");
return EXIT_FAILURE;
}
mrb_iv_set(mrb, mrb_obj_value(mrb->kernel_module),
mrb_intern(mrb, "@loaded_compiled_mrb_handles"),
mrb_ary_new(mrb));
// define load method on kernel
mrb_define_method(mrb, mrb->kernel_module, "load_compiled_mrb",
rb_load_compiled_mrb, ARGS_REQ(1));
mrbcc_load_so(mrb, mrb_top_self(mrb), "mrblib.so");
if (argc <= 1) {
printf("Usage: %s compiled.so\n", argv[0]);
} else {
mrbcc_load_so(mrb, mrb_top_self(mrb), argv[1]);
}
mrb_close(mrb);
// TODO: unload .so
//dlclose(handle); // gotta keep a global array of loaded sos and not close
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
mrb_state *mrb;
struct RClass *krn;
int ret;
print_hint();
/* new interpreter instance */
mrb = mrb_open();
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb_state, exiting test driver");
return EXIT_FAILURE;
}
if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'v') {
printf("verbose mode: enable\n\n");
mrb_gv_set(mrb, mrb_intern_lit(mrb, "$mrbtest_verbose"), mrb_true_value());
}
krn = mrb->kernel_module;
mrb_define_method(mrb, krn, "__t_printstr__", mrb_t_printstr, MRB_ARGS_REQ(1));
mrb_init_mrbtest(mrb);
ret = eval_test(mrb);
mrb_close(mrb);
return ret;
}
void
test_mrb_write_barrier(void)
{
mrb_state *mrb = mrb_open();
struct RBasic *obj;
puts("test_mrb_write_barrier");
obj = mrb_basic_ptr(mrb_ary_new(mrb));
paint_black(obj);
puts(" in GC_STATE_MARK");
mrb->gc_state = GC_STATE_MARK;
mrb_write_barrier(mrb, obj);
mrb_assert(is_gray(obj));
mrb_assert(mrb->atomic_gray_list == obj);
puts(" fail with gray");
paint_gray(obj);
mrb_write_barrier(mrb, obj);
mrb_assert(is_gray(obj));
mrb_close(mrb);
}
void
grn_ctx_impl_mrb_fin(grn_ctx *ctx)
{
if (ctx->impl->mrb.state) {
mrb_close(ctx->impl->mrb.state);
ctx->impl->mrb.state = NULL;
}
}
void
grn_ctx_impl_mrb_fin(grn_ctx *ctx)
{
if (ctx->impl->mrb) {
mrb_close(ctx->impl->mrb);
ctx->impl->mrb = NULL;
}
}
void mrb4R_finalize(void)
{
if(mrb != NULL) {
mrbc_context_free(mrb,mrb_cxt);
mrb_close(mrb);
printf("mruby finalize!!!\n");
}
}
void
test_incremental_gc(void)
{
mrb_state *mrb = mrb_open();
size_t max = ~0, live = 0, total = 0, freed = 0;
RVALUE *free;
struct heap_page *page;
puts("test_incremental_gc");
mrb_garbage_collect(mrb);
gc_assert(mrb->gc_state == GC_STATE_NONE);
incremental_gc(mrb, max);
gc_assert(mrb->gc_state == GC_STATE_MARK);
incremental_gc(mrb, max);
gc_assert(mrb->gc_state == GC_STATE_MARK);
incremental_gc(mrb, max);
gc_assert(mrb->gc_state == GC_STATE_SWEEP);
page = mrb->heaps;
while (page) {
RVALUE *p = page->objects;
RVALUE *e = p + MRB_HEAP_PAGE_SIZE;
while (p<e) {
if (is_black(&p->as.basic)) {
live++;
}
if (is_gray(&p->as.basic) && !is_dead(mrb, &p->as.basic)) {
printf("%p\n", &p->as.basic);
}
p++;
}
page = page->next;
total += MRB_HEAP_PAGE_SIZE;
}
gc_assert(mrb->gray_list == NULL);
incremental_gc(mrb, max);
gc_assert(mrb->gc_state == GC_STATE_SWEEP);
incremental_gc(mrb, max);
gc_assert(mrb->gc_state == GC_STATE_NONE);
free = (RVALUE*)mrb->heaps->freelist;
while (free) {
freed++;
free = (RVALUE*)free->as.free.next;
}
gc_assert(mrb->live == live);
gc_assert(mrb->live == total-freed);
mrb_close(mrb);
}
int main(int argc, char** argv)
{
const char rite[] = "app.mrb";
mrb_state* mrb = mrb_open();
FILE* fp = fopen(rite, "r");
if (fp == NULL) {
fprintf(stderr, "%s not found.\n", rite);
fprintf(stderr, "`mruby/bin/mrbc app.rb` to create app.mrb file.\n");
exit(EXIT_FAILURE);
}
int n = mrb_read_irep_file(mrb, fp);
fclose(fp);
if (n < 0) {
fprintf(stderr, "%s - irep load error.\n", rite);
exit(EXIT_FAILURE);
}
mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
if (argc < 2) {
printf("Usage %s <environment>\n", argv[0]);
return 0;
}
// AppSetting
struct RClass* clz = mrb_class_get(mrb, "AppSetting");
mrb_value setting = mrb_obj_value(clz);
// AppSetting.load(*targets) -> AppConfig
mrb_value target = mrb_str_new(mrb, argv[1], strlen(argv[1]));
mrb_value conf = mrb_funcall(mrb, setting, "load", 1, target);
// AppConfig.#debug -> bool
mrb_value debug = mrb_funcall(mrb, conf, "debug", 0);
printf("debug: %d\n", mrb_type(debug) == MRB_TT_TRUE);
// AppConfig.#timeout -> Integer
mrb_value timeout = mrb_funcall(mrb, conf, "timeout", 0);
printf("timeout: %d\n", timeout.value.i);
// AppConfig.#title -> String
mrb_value title = mrb_funcall(mrb, conf, "title", 0);
printf("title: %s\n", mrb_string_value_ptr(mrb, title));
// AppConfig.#messages -> Array
mrb_value messages = mrb_funcall(mrb, conf, "messages", 0);
{
// Array.#size -> Integer
mrb_value len = mrb_funcall(mrb, messages, "size", 0);
int i;
for (i = 0; i < len.value.i; i++) {
// Array.#at(nth) -> object
mrb_value message = mrb_funcall(mrb, messages, "at", 1, mrb_fixnum_value(i));
printf("%s\n", mrb_string_value_ptr(mrb, message));
}
}
mrb_close(mrb);
return 0;
}
static void
cleanup(mrb_state *mrb, struct _args *args)
{
if (args->rfp)
fclose(args->rfp);
if (args->wfp)
fclose(args->wfp);
mrb_close(mrb);
}
static void
mrb_thread_context_free(mrb_state *mrb, void *p) {
if (p) {
mrb_thread_context* context = (mrb_thread_context*) p;
if (context->mrb) mrb_close(context->mrb);
if (context->argv) free(context->argv);
free(p);
}
}
static void
cleanup(mrb_state *mrb, struct _args *args)
{
if (args->rfp && args->rfp != stdin)
fclose(args->rfp);
if (!args->fname)
mrb_free(mrb, args->cmdline);
mrb_free(mrb, args->argv);
mrb_close(mrb);
}
int
main(void)
{
mrb_state* mrb = mrb_open();
FILE *fp = fopen("mruby.rb", "r");
mrb_load_file(mrb, fp);
mrb_close(mrb);
return 0;
}
int
main(void)
{
mrb_state *mrb;
mrb = mrb_open();
int n = mrb_read_irep(mrb, fizzbuzz);
mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
mrb_close(mrb);
return 0;
}
