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));
}
// 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;
}
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;
}
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;
}
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 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;
}
virtual void PerformIteration()
{
mrb_run(mrb, script, mrb_nil_value());
if (mrb->exc) {
mrb_p(mrb, mrb_obj_value(mrb->exc));
}
}
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(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_funcall_with_block(mrb_state *mrb, mrb_value self, const char *name, int argc, mrb_value *argv, struct RProc *blk)
{
struct RProc *p;
struct RClass *c;
mrb_sym mid = mrb_intern(mrb, name);
mrb_sym undef = 0;
mrb_callinfo *ci;
int n = mrb->ci->nregs;
mrb_value val;
c = mrb_class(mrb, self);
p = mrb_method_search_vm(mrb, &c, mid);
if (!p) {
undef = mid;
mid = mrb_intern(mrb, "method_missing");
p = mrb_method_search_vm(mrb, &c, mid);
n++; argc++;
}
ci = cipush(mrb);
ci->mid = mid;
ci->proc = p;
ci->stackidx = mrb->stack - mrb->stbase;
ci->argc = argc;
ci->target_class = p->target_class;
ci->nregs = argc + 2;
ci->acc = -1;
mrb->stack = mrb->stack + n;
stack_extend(mrb, ci->nregs, 0);
mrb->stack[0] = self;
if (undef) {
mrb->stack[1] = mrb_symbol_value(undef);
memcpy(mrb->stack+2, argv, sizeof(mrb_value)*(argc-1));
}
else if (argc > 0) {
memcpy(mrb->stack+1, argv, sizeof(mrb_value)*argc);
}
if (!blk) {
mrb->stack[argc+1] = mrb_nil_value();
}
else {
mrb->stack[argc+1] = mrb_obj_value(blk);
}
if (MRB_PROC_CFUNC_P(p)) {
val = p->body.func(mrb, self);
mrb->stack = mrb->stbase + ci->stackidx;
cipop(mrb);
}
else {
val = mrb_run(mrb, p, self);
}
return val;
}
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;
}
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_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 mrbb_proc_call(mrb_state *mrb, mrb_value self)
{
mrb_callinfo *ci;
mrb_value recv = mrb->stack[0];
struct RProc *m = mrb_proc_ptr(recv);
int ai = mrb->arena_idx;
/* replace callinfo */
ci = mrb->ci;
ci->target_class = m->target_class;
ci->proc = m;
if (m->env) {
if (m->env->mid) {
ci->mid = m->env->mid;
}
if (!m->env->stack) {
m->env->stack = mrb->stack;
}
}
/* prepare stack */
if (MRB_PROC_CFUNC_P(m)) {
recv = m->body.func(mrb, m->env->stack[0]);
mrb->arena_idx = ai;
if (mrb->exc) mrbb_raise(mrb, 0);
/* pop stackpos */
// already done by funcall
//ci = mrb->ci;
//mrb->stack = mrb->stbase + ci->stackidx;
//regs[ci->acc] = recv;
//pc = ci->pc;
//cipop(mrb);
} else {
mrb_irep *irep = m->body.irep;
if (!irep) {
mrb->stack[0] = mrb_nil_value();
return mrb_nil_value();
}
ci->nregs = irep->nregs;
if (ci->argc < 0) {
stack_extend(mrb, (irep->nregs < 3) ? 3 : irep->nregs, 3);
}
else {
stack_extend(mrb, irep->nregs, ci->argc+2);
}
mrb->stack[0] = m->env->stack[0];
recv = mrb_run(mrb, m, recv);
}
// TODO: only overwrite this method for Cfunc procs
// so we let OP_CALL handle interpreted funcs
return recv;
}
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;
}
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;
}
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*
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;
}
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;
}
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;
}
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;
}
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);
}
ngx_int_t ngx_http_mruby_run_body_filter(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;
mrb_value ARGV, mrb_result;
size_t body_length;
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);
ARGV = mrb_ary_new_capa(state->mrb, 1);
mrb_ary_push(state->mrb, ARGV, mrb_str_new(state->mrb, (char *)ctx->filter_ctx.body, ctx->filter_ctx.body_length));
mrb_define_global_const(state->mrb, "ARGV", ARGV);
mrb_result = 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);
}
return NGX_ERROR;
}
mrb_result = mrb_obj_as_string(state->mrb, mrb_result);
body_length = RSTRING_LEN(mrb_result);
if (body_length != 0) {
ctx->filter_ctx.body = (u_char *)RSTRING_PTR(mrb_result);
ctx->filter_ctx.body_length = body_length;
}
mrb_gc_arena_restore(state->mrb, state->ai);
//mrb_gc_protect(state->mrb, ctx->table);
if (!cached) {
ngx_http_mruby_irep_clean(state, code);
}
return NGX_OK;
}
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;
}
std::string Epoch::Script::run_line(char* source){
struct mrb_parser_state *parser = this->get_parser();
parser->s = source;
parser->send = source + strlen(source);
mrb_parser_parse(parser, this->current_context);
int compilation_result = mrb_generate_code(this->main_state, parser);
if (0 < parser->nerr) {
printf("line %d: %s\n", parser->error_buffer[0].lineno, parser->error_buffer[0].message);
}
mrb_value result = mrb_run(this->main_state,
mrb_proc_new(this->main_state, this->main_state->irep[compilation_result]),
mrb_top_self(this->main_state));
return return_inspect(this->main_state, result);
}
int main()
{
mrb_state *mrb;
int n;
FILE* f;
struct RClass* cObject;
mrb = mrb_open();
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."); }
n = mrb_load_file(mrb, f);
fclose(f);
mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value());
mrb_close(mrb);
}
int exec(int argc, char* argv[])
{
mrb_state* mrb = mrb_open();
if(mrb == 0)
{
printf("cannot open mruby\n");
return -2;
}
// クラスを定義する
RClass* my_class = mrb_define_class(mrb, "MyClass", mrb->object_class);
// メソッドを定義する
mrb_define_method(mrb, my_class, "print_name", my_class_print_name, ARGS_NONE());
for(int i = 0; i < argc; ++i)
{
FILE* fp = std::fopen(argv[i], "r");
if(fp == 0)
{
printf("cannot open file \"%s\"\n", argv[i]);
continue;
}
mrb_parser_state* parser = mrb_parse_file(mrb, fp);
int byte_code = mrb_generate_code(mrb, parser->tree);
mrb_value return_value = mrb_run( mrb,
mrb_proc_new(mrb, mrb->irep[byte_code]),
mrb_top_self(mrb)
);
if(mrb->exc) // if exception occurred ...
{
mrb_p(mrb, return_value);
mrb->exc = 0;
}
std::fclose(fp);
}
mrb_close(mrb);
return 0;
}
