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;
}
