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;
}
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;
}
int main()
{
mrb_state* mrb;
int n;
FILE* f;
mrb_value ret;
mrb = mrb_open();
f = fopen("test.rb", "r");
mrb_load_file(mrb, f);
fclose(f);
ret = mrb_funcall(mrb, mrb_top_self(mrb), "test", 1, mrb_fixnum_value(20) );
//mrb_define_method(mrb, mrb->kernel_module, "cursor_move", cursor_move, MRB_ARGS_REQ(2));
//------------------------------------------
int x, y;
int key=' ';
char *str;
initscr();
keypad(stdscr, TRUE);
setlocale(LC_ALL, "");
x = 0;
y = 0;
while (1) {
key = getch();
ret = mrb_funcall(mrb, mrb_top_self(mrb), "evaluate", 1, mrb_fixnum_value(key) );
str = mrb_string_value_ptr(mrb, ret);
addstr(str);
if (key == 'q') break;
switch (key) {
case KEY_UP: y--; break;
case KEY_DOWN: y++; break;
case KEY_LEFT: x--; break;
case KEY_RIGHT: x++; break;
default : mvprintw(y, x++, "%c", key); break;
}
move(y, x);
//mrb_load_string(mrb,"cursor_move(x, y);");
}
endwin();
mrb_close(mrb);
return (0);
}
// 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;
}
// ssp_thread で登録されるtask本体
void
mrb_ssp_alarm_call(intptr_t exf)
{
mrb_int alarm_id = (mrb_int)exf; // alarmID
mrb_value self = alarm_self_tbl[alarm_id-1];
char name_cstr[20];
#if MRB_DEBUG1
printf("alarm_call &self = %08x self = %08x %08x\n",
(int)&self,*((int*)&self),*(((int*)&self)+1));
#endif
mrb_value name = mrb_iv_get(mrb_global, self, mrb_intern_lit(mrb_global, "@alarm_name"));
mrb_value id = mrb_iv_get(mrb_global, self, mrb_intern_lit(mrb_global, "@alarm_id"));
// char *name_cstr = mrb_str_to_cstr(mrb_global, name);
strncpy(name_cstr, RSTRING_PTR(name), RSTRING_LEN(name));
name_cstr[RSTRING_LEN(name)]='\0';
#if MRB_DEBUG1
printf("mrb_alarm_call exf = %d cstr=%s id = %d\n",
exf,name_cstr,mrb_fixnum(id));
#endif
t_lock_cpu();
#if 0
mrb_funcall(mrb_global, mrb_top_self(mrb_global), name_cstr,1, id);
#else
mrb_funcall(mrb_global, self, name_cstr,1, id);
#endif
t_unlock_cpu();
}
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;
}
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));
}
// ssp_thread で登録されるtask本体
void
mrb_ssp_cyclic_call(intptr_t exf)
{
mrb_int cyclic_id = (mrb_int)exf; // cyclicID
mrb_value self = cyclic_self_tbl[cyclic_id-1];
char name_cstr[20];
#if MRB_DEBUG1
printf("cyclic_call &self = %08x self = %08x %08x\n",
(int)&self,*((int*)&self),*(((int*)&self)+1));
#endif
mrb_value name = mrb_iv_get(mrb_global, self, mrb_intern_lit(mrb_global, "@cyclic_name"));
mrb_value id = mrb_iv_get(mrb_global, self, mrb_intern_lit(mrb_global, "@cyclic_id"));
// char *name_cstr = mrb_str_to_cstr(mrb_global, name); //メモリリーク？ 開放しないため４回目で落ちる
strncpy(name_cstr, RSTRING_PTR(name), RSTRING_LEN(name));
name_cstr[RSTRING_LEN(name)]='\0';
#if MRB_DEBUG1
printf("mrb_cyclic_call exf = %d cstr=%s id = %d\n",
exf,name_cstr,mrb_fixnum(id));
#endif
#if 0
mrb_funcall(mrb_global, mrb_top_self(mrb_global), "cyclic",1, id);
#else
mrb_funcall(mrb_global, self, (const char*)name_cstr,1, id);
#endif
}
int main(void)
{
mrb_value response;
mrb_state *mrb = mrb_open();
mrbc_context *ctx = mrbc_context_new(mrb);
// URL into instance variable "@url" of main on same ctx
mrb_iv_set(mrb, mrb_top_self(mrb), mrb_intern_lit(mrb, "@url"),
mrb_str_new_lit(mrb, "https://127.0.0.1:8080/index.html"));
response = mrb_load_string_cxt(mrb, request, ctx);
mrb_funcall(mrb, mrb_top_self(mrb), "pp", 1, response);
mrbc_context_free(mrb, ctx);
mrb_close(mrb);
return 0;
}
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() {
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 MRuby::init() {
const char *code =
"def echo(x); x; end;"
"def invert(x)\n"
" r = {}\n"
" x.each do |k, v|\n"
" r[v] = k\n"
" end\n"
" r\n"
"end\n"
;
struct mrb_parser_state *p = mrb_parse_string(mMrb, code, mContext);
if (p->nerr > 0) {
std::cerr << "parse error" << std::endl;
mrb_parser_free(p);
return 1;
}
struct RProc *proc = mrb_generate_code(mMrb, p);
mrb_parser_free(p);
if (proc == NULL) {
std::cerr << "compile error" << std::endl;
return 1;
}
mrb_run(mMrb, proc, mrb_top_self(mMrb));
return 0;
}
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(int argc, char **argv)
{
mrb_state *mrb;
mrb = mrb_open();
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb_state, exiting driver");
return EXIT_FAILURE;
}
#if 0
mrb_iv_set(mrb, mrb_obj_value(mrb->kernel_module),
mrb_intern(mrb, "@loaded_compiled_mrb_handles"),
mrb_ary_new(mrb));
#endif
mrbb_exec_entry_point_for_mrblib(mrb, mrb_top_self(mrb));
MRBB_EXEC_ENTRY_POINT(mrb, mrb_top_self(mrb));
mrb_close(mrb);
return EXIT_SUCCESS;
}
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);
}
}
ngx_int_t ngx_http_mruby_run(ngx_http_request_t *r, ngx_http_mruby_state_t *state, ngx_http_mruby_code_t *code, ngx_flag_t cached)
{
ngx_http_mruby_ctx_t *ctx;
ngx_http_mruby_rputs_chain_list_t *chain;
ctx = ngx_http_get_module_ctx(r, ngx_http_mruby_module);
ngx_http_mruby_push_request(r);
state->ai = mrb_gc_arena_save(state->mrb);
mrb_run(state->mrb, code->proc, mrb_top_self(state->mrb));
if (state->mrb->exc) {
ngx_http_mruby_raise_error(state, code, r);
}
mrb_gc_arena_restore(state->mrb, state->ai);
//mrb_gc_protect(state->mrb, ctx->table);
if (!cached) {
ngx_http_mruby_irep_clean(state, code);
}
if (ctx->exited) {
return ctx->exit_code;
}
chain = ctx->rputs_chain;
if (chain == NULL) {
if (state->mrb->exc) {
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (r->headers_out.status >= NGX_HTTP_OK) {
if (ctx->phase < NGX_HTTP_MRUBY_PHASE_LOG) {
return r->headers_out.status;
}
}
return NGX_DECLINED;
}
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);
return NGX_OK;
}
return r->headers_out.status;
}
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));
}
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(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);
}
s.run \n\
";
int main(void)
{
mrb_state *mrb = mrb_open();
mrbc_context *ctx = mrbc_context_new(mrb);
// 8080 into instance variable "@port" of main on same ctx
mrb_iv_set(mrb, mrb_top_self(mrb), mrb_intern_lit(mrb, "@port"),
mrb_fixnum_value(8080));
mrb_iv_set(mrb, mrb_top_self(mrb), mrb_intern_lit(mrb, "@echo_content"),
mrb_str_new_lit(mrb, "world from cb."));
mrb_load_string_cxt(mrb, config, ctx);
mrb_load_string_cxt(mrb, response, ctx);
mrb_load_string_cxt(mrb, run, ctx);
mrbc_context_free(mrb, ctx);
mrb_close(mrb);
return 0;
}
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;
}
static ngx_int_t ngx_stream_mrb_run_cycle(ngx_cycle_t *cycle, mrb_state *mrb, ngx_mrb_code_t *code)
{
mrb_int ai = mrb_gc_arena_save(mrb);
mrb_run(mrb, code->proc, mrb_top_self(mrb));
if (mrb->exc) {
ngx_stream_mrb_raise_cycle_error(mrb, mrb_obj_value(mrb->exc), cycle);
mrb_gc_arena_restore(mrb, ai);
return NGX_ERROR;
}
mrb_gc_arena_restore(mrb, ai);
return NGX_OK;
}
void h2o_mruby_send_chunked_init_context(h2o_mruby_shared_context_t *shared_ctx)
{
mrb_state *mrb = shared_ctx->mrb;
h2o_mruby_eval_expr_location(mrb, H2O_MRUBY_CODE_CHUNKED, "(h2o)lib/handler/mruby/embedded/chunked.rb", 1);
h2o_mruby_assert(mrb);
mrb_define_method(mrb, mrb->kernel_module, "_h2o_send_chunk", send_chunked_method, MRB_ARGS_ARG(1, 0));
h2o_mruby_define_callback(mrb, "_h2o_send_chunk_eos", send_chunked_eos_callback);
mrb_ary_set(mrb, shared_ctx->constants, H2O_MRUBY_CHUNKED_PROC_EACH_TO_FIBER,
mrb_funcall(mrb, mrb_top_self(mrb), "_h2o_chunked_proc_each_to_fiber", 0));
h2o_mruby_assert(mrb);
}
static mrb_value
load_exec(mrb_state *mrb, mrb_parser_state *p, mrbc_context *c)
{
RClass *target = mrb->object_class;
RProc *proc;
mrb_value v;
if (!p) {
return mrb_value::undef();
}
if (!p->m_tree || p->nerr) {
if (p->m_capture_errors) {
char buf[256];
int n = snprintf(buf, sizeof(buf), "line %d: %s\n",
p->error_buffer[0].lineno, p->error_buffer[0].message);
mrb->m_exc = mrb_exc_new(E_SYNTAX_ERROR, buf, n).object_ptr();
mrb_parser_free(p);
return mrb_value::undef();
}
else {
static const char msg[] = "syntax error";
mrb->m_exc = mrb_exc_new(E_SYNTAX_ERROR, msg, sizeof(msg) - 1).object_ptr();
mrb_parser_free(p);
return mrb_value::undef();
}
}
proc = mrb_generate_code(mrb, p);
mrb_parser_free(p);
if (nullptr == proc) {
static const char msg[] = "codegen error";
mrb->m_exc = mrb_exc_new(E_SCRIPT_ERROR, msg, sizeof(msg) - 1).object_ptr();
return mrb_value::undef();
}
if (c) {
if (c->dump_result) mrb->codedump_all(proc);
if (c->no_exec) return mrb_value::wrap(proc);
if (c->target_class) {
target = c->target_class;
}
}
proc->m_target_class = target;
if (mrb->m_ctx->m_ci) {
mrb->m_ctx->m_ci->target_class = target;
}
v = mrb->mrb_context_run(proc, mrb_top_self(mrb),0);
if (mrb->m_exc) return mrb_value::nil();
return v;
}
ngx_int_t ngx_http_mruby_run_conf(ngx_conf_t *cf, ngx_http_mruby_state_t *state, ngx_http_mruby_code_t *code)
{
state->ai = mrb_gc_arena_save(state->mrb);
mrb_run(state->mrb, code->proc, mrb_top_self(state->mrb));
mrb_gc_arena_restore(state->mrb, state->ai);
if (state->mrb->exc) {
ngx_http_mruby_raise_conf_error(state, code, cf);
return NGX_ERROR;
}
return NGX_OK;
}
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;
}
