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; }
static int cpurate_from_mruby(request_rec *r) { FILE *mrb_file; mrm_config_t *conf = ap_get_module_config(r->server->module_config, &resource_manager_module); mrb_state *mrb = mrb_open(); ap_mruby_class_init(mrb); if ((mrb_file = fopen(conf->mruby_code, "r")) == NULL) { ap_log_error(APLOG_MARK , APLOG_ERR , 0 , NULL , "%s ERROR %s: mrb file oepn failed: %s" , MODULE_NAME , __func__ , conf->mruby_code ); } struct mrb_parser_state* p = mrb_parse_file(mrb, mrb_file, NULL); int n = mrb_generate_code(mrb, p->tree); mrb_pool_close(p->pool); ap_mrb_push_request(r); mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value()); return OK; }
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 }; mrbjit_code_info *cinfo; int i; *call_irep = mrb_irep_zero; call_irep->flags = MRB_ISEQ_NO_FREE; call_irep->iseq = call_iseq; call_irep->ilen = 1; call_irep->jit_entry_tab = (mrbjit_codetab *)mrb_calloc(mrb, 2, sizeof(mrbjit_codetab)); for (i = 0; i < 2; i++) { call_irep->jit_entry_tab[i].size = 16; cinfo = (mrbjit_code_info *)mrb_calloc(mrb, 16, sizeof(mrbjit_code_info)); call_irep->jit_entry_tab[i].body = cinfo; } call_irep->prof_info = (int *)mrb_calloc(mrb, 2, sizeof(int)); call_irep->method_kind = NORMAL; call_irep->simple_lambda = 1; call_irep->proc_obj = NULL; 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_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 */ }
// 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; }
void mrb_init_mrblib(mrb_state *mrb) { int n = mrb_read_irep(mrb, mrblib_irep); mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); }
ngx_int_t ngx_mrb_run_conf(ngx_conf_t *cf, ngx_mrb_state_t *state, ngx_mrb_code_t *code) { ngx_log_error(NGX_LOG_INFO , cf->log , 0 , "%s INFO %s:%d: mrb_run info: irep_n=%d" , MODULE_NAME , __func__ , __LINE__ , code->n ); mrb_run(state->mrb, mrb_proc_new(state->mrb, state->mrb->irep[code->n]), mrb_top_self(state->mrb)); if (state->mrb->exc) { if (code->code_type == NGX_MRB_CODE_TYPE_FILE) { ngx_mrb_raise_file_conf_error(state->mrb, mrb_obj_value(state->mrb->exc), cf, code->code.file); } else { ngx_mrb_raise_conf_error(state->mrb, mrb_obj_value(state->mrb->exc), cf); } mrb_gc_arena_restore(state->mrb, state->ai); return NGX_ERROR; } mrb_gc_arena_restore(state->mrb, state->ai); return NGX_OK; }
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; }
struct RProc * mrb_closure_new(mrb_state *mrb, mrb_irep *irep) { struct RProc *p = mrb_proc_new(mrb, irep); closure_setup(mrb, p, mrb->c->ci->proc->body.irep->nlocals); return p; }
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; }
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; }
int main() { mrb_state *mrb; int n; mrb = mrb_open(); n = mrb_load_string(mrb, "puts 'hello'; puts 1+2; p({:a=>[1,2,3], :b=>{'c'=>{'d'=>['e', {'f'=>nil}]}}})"); mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value()); mrb_close(mrb); }
mrb_value mrb_load_irep(mrb_state *mrb, const char *bin) { int n = mrb_read_irep(mrb, bin); if (n < 0) { irep_error(mrb, n); return mrb_nil_value(); } return mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); }
mrb_value mrb_load_irep_file(mrb_state *mrb, FILE* fp) { int n = mrb_read_irep_file(mrb, fp); if (n < 0) { irep_error(mrb, n); return mrb_nil_value(); } return mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); }
void mrb_init_mrubybin(mrb_state *mrb) { int n = mrb_read_irep(mrb, mrubybin); mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); if (mrb->exc) { mrb_p(mrb, mrb_obj_value(mrb->exc)); exit(0); } }
mrb_value mrb_load_irep(mrb_state *mrb, const uint8_t *bin) { int32_t n; n = mrb_read_irep(mrb, bin); if (n < 0) { irep_error(mrb, n); return mrb_nil_value(); } return mrb_context_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb), 0); }
static ERL_NIF_TERM eval2(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); } if (!enif_is_list(env, argv[1])) { enif_release_binary(&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"); } unsigned int mrb_argv_len; enif_get_list_length(env, argv[1], &mrb_argv_len); mrb_value mrb_argv = mrb_ary_new(mrb); ERL_NIF_TERM cur; for(cur = argv[1]; !enif_is_empty_list(env, cur); ) { ERL_NIF_TERM head, tail; enif_get_list_cell(env, cur, &head, &tail); mrb_ary_push(mrb, mrb_argv, erl2mruby(env, mrb, head)); cur = tail; } mrb_define_global_const(mrb, "ARGV", mrb_argv); char *script = malloc(script_binary.size+1); strncpy(script, (const char *)script_binary.data, (int)script_binary.size); script[script_binary.size] = '\0'; 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_NIF_TERM erl_result = mruby2erl(env, mrb, result); free(script); mrbc_context_free(mrb, cxt); mrb_close(mrb); enif_release_binary(&script_binary); return erl_result; }
static mrb_value mrb_thread_init(mrb_state* mrb, mrb_value self) { mrb_value proc = mrb_nil_value(); mrb_int argc; mrb_value* argv; mrb_get_args(mrb, "&*", &proc, &argv, &argc); if (!mrb_nil_p(proc) && MRB_PROC_CFUNC_P(mrb_proc_ptr(proc))) { mrb_raise(mrb, E_RUNTIME_ERROR, "forking C defined block"); } if (!mrb_nil_p(proc)) { int i, l; mrb_thread_context* context = (mrb_thread_context*) malloc(sizeof(mrb_thread_context)); context->mrb_caller = mrb; context->mrb = mrb_open_allocf(mrb->allocf, mrb->allocf_ud); migrate_all_symbols(mrb, context->mrb); context->proc = mrb_proc_new(mrb, mrb_proc_ptr(proc)->body.irep); context->proc->target_class = context->mrb->object_class; context->argc = argc; context->argv = calloc(sizeof (mrb_value), context->argc); context->result = mrb_nil_value(); context->alive = TRUE; for (i = 0; i < context->argc; i++) { context->argv[i] = migrate_simple_value(mrb, argv[i], context->mrb); } { mrb_value gv = mrb_funcall(mrb, self, "global_variables", 0, NULL); l = RARRAY_LEN(gv); for (i = 0; i < l; i++) { mrb_int len; int ai = mrb_gc_arena_save(mrb); mrb_value k = mrb_ary_entry(gv, i); mrb_value o = mrb_gv_get(mrb, mrb_symbol(k)); if (is_safe_migratable_simple_value(mrb, o, context->mrb)) { const char *p = mrb_sym2name_len(mrb, mrb_symbol(k), &len); mrb_gv_set(context->mrb, mrb_intern_static(context->mrb, p, len), migrate_simple_value(mrb, o, context->mrb)); } mrb_gc_arena_restore(mrb, ai); } } mrb_iv_set(mrb, self, mrb_intern_lit(mrb, "context"), mrb_obj_value( Data_Wrap_Struct(mrb, mrb->object_class, &mrb_thread_context_type, (void*) context))); pthread_create(&context->thread, NULL, &mrb_thread_func, (void*) context); } return self; }
static void load_mrb_file(mrb_state *mrb, mrb_value filepath) { char *fpath = RSTRING_PTR(filepath); int arena_idx; FILE *fp; mrb_irep *irep; { FILE *fp = fopen(fpath, "rb"); if (fp == NULL) { mrb_load_fail( mrb, mrb_str_new_cstr(mrb, fpath), "cannot load such file" ); return; } fclose(fp); } arena_idx = mrb_gc_arena_save(mrb); fp = fopen(fpath, "rb"); irep = mrb_read_irep_file(mrb, fp); fclose(fp); mrb_gc_arena_restore(mrb, arena_idx); if (irep) { struct RProc *proc; /* size_t i; for (i = sirep; i < mrb->irep_len; i++) { mrb->irep[i]->filename = mrb_string_value_ptr(mrb, filepath); } */ replace_stop_with_return(mrb, irep); proc = mrb_proc_new(mrb, irep); proc->target_class = mrb->object_class; arena_idx = mrb_gc_arena_save(mrb); mrb_yield_with_class(mrb, mrb_obj_value(proc), 0, NULL, mrb_top_self(mrb), mrb->object_class); mrb_gc_arena_restore(mrb, arena_idx); } else if (mrb->exc) { // fail to load longjmp(*(jmp_buf*)mrb->jmp, 1); } }
static void eval_load_irep(mrb_state *mrb, mrb_irep *irep) { int ai; struct RProc *proc; replace_stop_with_return(mrb, irep); proc = mrb_proc_new(mrb, irep); proc->target_class = mrb->object_class; ai = mrb_gc_arena_save(mrb); mrb_yield_internal(mrb, mrb_obj_value(proc), 0, NULL, mrb_top_self(mrb), mrb->object_class); mrb_gc_arena_restore(mrb, ai); }
static int ap_mruby_run_inline(mrb_state *mrb, request_rec *r, mod_mruby_code_t *c) { int ai; mrb_value ret; // mutex lock if (apr_thread_mutex_lock(mod_mruby_mutex) != APR_SUCCESS) { ap_log_rerror(APLOG_MARK , APLOG_ERR , 0 , r , "%s ERROR %s: mod_mruby_mutex lock failed" , MODULE_NAME , __func__ ); return OK; } ap_mrb_push_request(r); ai = mrb_gc_arena_save(mrb); ap_log_rerror(APLOG_MARK , APLOG_DEBUG , 0 , r , "%s DEBUG %s: irep[%d] inline core run: inline code = %s" , MODULE_NAME , __func__ , c->irep_idx_start , c->code ); ret = mrb_run(mrb , mrb_proc_new(mrb, mrb->irep[c->irep_idx_start]) , mrb_top_self(mrb) ); mrb_gc_arena_restore(mrb, ai); ap_mruby_state_clean(mrb); // mutex unlock if (apr_thread_mutex_unlock(mod_mruby_mutex) != APR_SUCCESS){ ap_log_rerror(APLOG_MARK , APLOG_ERR , 0 , r , "%s ERROR %s: mod_mruby_mutex unlock failed" , MODULE_NAME , __func__ ); return OK; } return OK; }
int main(int argc, char **argv) { if(argc != 2) { print_usage(); exit(1); } char *input_file = argv[1]; FILE *fp = fopen(input_file, "r"); if(fp == NULL) { fprintf(stderr, "Error opening file: '%s' - %s\n", input_file, strerror(errno)); exit(2); } char *code = NULL; char buffer[1024]; int code_size = 0; do { int read_bytes = fread(buffer, sizeof(char), 1024, fp); code = realloc(code, code_size + read_bytes); memcpy(code+code_size, buffer, read_bytes); code_size += read_bytes; } while(!feof(fp)); code = realloc(code, code_size + 1); code[code_size] = 0; if(fclose(fp) != 0) { fprintf(stderr, "Error closing file: '%s' - %s\n", input_file, strerror(errno)); exit(3); } mrb_state* mrb = mrb_open(); mrb_uv_init(mrb); struct mrb_parser_state* st = mrb_parse_string(mrb, code); free(code); int n = mrb_generate_code(mrb, st->tree); mrb_pool_close(st->pool); mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value()); return 0; }
void* cfunc_rubyvm_open(void *args) { struct cfunc_rubyvm_data *data = args; mrb_state *mrb = mrb_open(); data->state = mrb; #ifdef DISABLE_GEMS init_cfunc_module(mrb); #endif int n = mrb_read_irep(mrb, data->mrb_data); mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); if (mrb->exc) { return NULL; } while(true) { pthread_mutex_lock(&data->queue_mutex); while(data->queue->length == 0) { pthread_cond_wait(&data->queue_cond, &data->queue_mutex); } struct queue_task *task = vector_dequeue(data->queue); task->status = queue_task_running; mrb_sym taskname = mrb_intern(mrb, task->name); int args_len = task->args_len; mrb_value *args = mrb_malloc(mrb, sizeof(struct task_arg) * task->args_len); int i; for(i=0; i<task->args_len; ++i) { args[i] = task_arg_to_mrb_value(data->state, task->args[i]); } pthread_mutex_unlock(&data->queue_mutex); mrb_value result = mrb_funcall_argv(mrb, mrb_top_self(data->state), taskname, args_len, args); task->result = mrb_value_to_task_arg(mrb, result); task->status = queue_task_finished; pthread_cond_signal(&task->sync_cond); mrb_free(mrb, args); free_queue_task(mrb, task); } return NULL; }
MRB_API mrb_value mrb_load_irep_cxt(mrb_state *mrb, const uint8_t *bin, mrbc_context *c) { mrb_irep *irep = mrb_read_irep(mrb, bin); struct RProc *proc; if (!irep) { irep_error(mrb); return mrb_nil_value(); } proc = mrb_proc_new(mrb, irep); mrb_irep_decref(mrb, irep); if (c && c->no_exec) return mrb_obj_value(proc); return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0); }
bool TRI_ExecuteRubyString (mrb_state* mrb, char const* script, char const* name, bool printResult, mrb_value* result) { struct mrb_parser_state* parser; mrb_value r; int n; parser = mrb_parse_nstring(mrb, script, strlen(script), NULL); if (parser == 0 || parser->tree == 0 || 0 < parser->nerr) { LOG_DEBUG("failed to parse ruby script"); if (parser != 0 && parser->pool != 0) { mrb_pool_close(parser->pool); } return false; } n = mrb_generate_code(mrb, parser); mrb_pool_close(parser->pool); if (n < 0) { LOG_DEBUG("failed to generate ruby code: %d", n); return false; } r = mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb)); if (mrb->exc) { if (printResult) { mrb_p(mrb, mrb_obj_value(mrb->exc)); } mrb->exc = 0; } else if (printResult && ! mrb_nil_p(r)) { mrb_p(mrb, r); } if (result != NULL) { *result = r; } return true; }
static void load_mrb_file(mrb_state *mrb, mrb_value filepath) { char *fpath = RSTRING_PTR(filepath); int ai; FILE *fp; mrb_irep *irep; fp = fopen(fpath, "rb"); if (fp == NULL) { mrb_load_fail( mrb, mrb_str_new_cstr(mrb, fpath), "cannot load such file" ); return; } ai = mrb_gc_arena_save(mrb); irep = mrb_read_irep_file(mrb, fp); fclose(fp); mrb_gc_arena_restore(mrb, ai); if (irep) { struct RProc *proc; /* size_t i; for (i = sirep; i < mrb->irep_len; i++) { mrb->irep[i]->filename = mrb_string_value_ptr(mrb, filepath); } */ #ifdef USE_MRUBY_OLD_BYTE_CODE replace_stop_with_return(mrb, irep); #endif proc = mrb_proc_new(mrb, irep); MRB_PROC_SET_TARGET_CLASS(proc, mrb->object_class); ai = mrb_gc_arena_save(mrb); mrb_yield_with_class(mrb, mrb_obj_value(proc), 0, NULL, mrb_top_self(mrb), mrb->object_class); mrb_gc_arena_restore(mrb, ai); } else if (mrb->exc) { // fail to load longjmp(*(jmp_buf*)mrb->jmp, 1); } }
static mrb_value load_irep(mrb_state *mrb, mrb_irep *irep, mrbc_context *c) { struct RProc *proc; if (!irep) { irep_error(mrb); return mrb_nil_value(); } proc = mrb_proc_new(mrb, irep); proc->c = NULL; mrb_irep_decref(mrb, irep); if (c && c->dump_result) mrb_codedump_all(mrb, proc); if (c && c->no_exec) return mrb_obj_value(proc); return mrb_top_run(mrb, proc, mrb_top_self(mrb), 0); }
ngx_int_t ngx_mrb_run(ngx_http_request_t *r, ngx_mrb_state_t *state, ngx_flag_t cached) { ngx_mruby_ctx_t *ctx; rputs_chain_list_t *chain; if (state == NGX_CONF_UNSET_PTR) { return NGX_DECLINED; } if ((ctx = ngx_pcalloc(r->pool, sizeof(*ctx))) == NULL) { ngx_log_error(NGX_LOG_ERR , r->connection->log , 0 , "failed to allocate memory from r->pool %s:%d" , __FUNCTION__ , __LINE__ ); return NGX_ERROR; } ngx_http_set_ctx(r, ctx, ngx_http_mruby_module); ngx_mrb_push_request(r); mrb_run(state->mrb, mrb_proc_new(state->mrb, state->mrb->irep[state->n]), mrb_nil_value()); if (state->mrb->exc) { if (state->code_type == NGX_MRB_CODE_TYPE_FILE) { ngx_mrb_raise_file_error(state->mrb, mrb_obj_value(state->mrb->exc), r, state->code.file); } else { ngx_mrb_raise_error(state->mrb, mrb_obj_value(state->mrb->exc), r); } } mrb_gc_arena_restore(state->mrb, state->ai); if (!cached) { ngx_mrb_irep_clean(state); } if (ngx_http_get_module_ctx(r, ngx_http_mruby_module) != NULL) { chain = ctx->rputs_chain; if (r->headers_out.status == NGX_HTTP_OK || !(*chain->last)->buf->last_buf) { r->headers_out.status = NGX_HTTP_OK; (*chain->last)->buf->last_buf = 1; ngx_http_send_header(r); ngx_http_output_filter(r, chain->out); ngx_http_set_ctx(r, NULL, ngx_http_mruby_module); return NGX_OK; } else { return r->headers_out.status; } } return NGX_OK; }
VALUE mruby_eval(VALUE self, VALUE prog) { int n = -1; mrb_state *mrb = mrb_open(); struct mrb_parser_state *p; mrbc_context *c = mrbc_context_new(mrb); mrb_value rc; p = mrb_parse_string(mrb, StringValueCStr(prog), c); n = mrb_generate_code(mrb, p); mrbc_context_free(mrb, c); mrb_pool_close(p->pool); if (n >= 0) { rc = mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value()); } return mruby_cvt_mr2cr(rc); }
mrb_value mrb_load_irep_file_cxt(mrb_state *mrb, FILE* fp, mrbc_context *c) { mrb_irep *irep = mrb_read_irep_file(mrb, fp); mrb_value val; struct RProc *proc; if (!irep) { irep_error(mrb); return mrb_nil_value(); } proc = mrb_proc_new(mrb, irep); mrb_irep_decref(mrb, irep); if (c && c->no_exec) return mrb_obj_value(proc); val = mrb_toplevel_run(mrb, proc); return val; }