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;
}
static void mod_mruby_compile_code(mrb_state *mrb, mod_mruby_code_t *c, server_rec *s)
{
struct mrb_parser_state* p;
FILE *mrb_file;
TRACER;
if (c != NULL) {
if (c->type == MOD_MRUBY_STRING) {
p = mrb_parse_string(mrb, c->code, NULL);
c->irep_idx_start = mrb_generate_code(mrb, p);
c->irep_idx_end = mrb->irep_len - 1;
ap_log_error(APLOG_MARK
, APLOG_DEBUG
, 0
, s
, "%s DEBUG %s: mruby code string compiled: string=[%s] from irep_idx_start=[%d] to irep_idx_end=[%d]"
, MODULE_NAME
, __func__
, c->code
, c->irep_idx_start
, c->irep_idx_end
);
} else if (c->type == MOD_MRUBY_FILE) {
if ((mrb_file = fopen(c->path, "r")) == NULL) {
ap_log_error(APLOG_MARK
, APLOG_ERR
, 0
, s
, "%s ERROR %s: mrb file oepn failed: %s"
, MODULE_NAME
, __func__
, c->path
);
return;
}
p = mrb_parse_file(mrb, mrb_file, NULL);
fclose(mrb_file);
c->irep_idx_start = mrb_generate_code(mrb, p);
c->irep_idx_end = mrb->irep_len - 1;
ap_log_error(APLOG_MARK
, APLOG_DEBUG
, 0
, s
, "%s DEBUG %s: mruby code file compiled: path=[%s]from irep_idx_start=[%d] to irep_idx_end=[%d]"
, MODULE_NAME
, __func__
, c->path
, c->irep_idx_start
, c->irep_idx_end
);
} else {
return;
}
mrb_pool_close(p->pool);
}
}
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;
}
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);
}
static ngx_int_t ngx_mrb_init_string(char *code, ngx_mrb_state_t *state)
{
mrb_state *mrb;
struct mrb_parser_state *p;
mrb = mrb_open();
ngx_mrb_class_init(mrb);
state->ai = mrb_gc_arena_save(mrb);
p = mrb_parse_string(mrb, code, NULL);
state->mrb = mrb;
state->n = mrb_generate_code(mrb, p);
state->code_type = NGX_MRB_CODE_TYPE_STRING;
mrb_pool_close(p->pool);
return NGX_OK;
}
ngx_int_t ngx_http_mruby_shared_state_compile(ngx_http_mruby_state_t *state, ngx_http_mruby_code_t *code)
{
FILE *mrb_file;
struct mrb_parser_state *p;
if (code->code_type == NGX_HTTP_MRUBY_CODE_TYPE_FILE) {
if ((mrb_file = fopen((char *)code->code.file, "r")) == NULL) {
return NGX_ERROR;
}
p = mrb_parse_file(state->mrb, mrb_file, NULL);
fclose(mrb_file);
} else {
p = mrb_parse_string(state->mrb, (char *)code->code.string, NULL);
}
code->n = mrb_generate_code(state->mrb, p);
mrb_pool_close(p->pool);
return NGX_OK;
}
int main()
{
mrb_state *mrb;
int n;
struct mrb_parser_state *p;
mrbc_context *mrbc_ctx;
mrb = mrb_open();
mrbc_ctx = mrbc_context_new(mrb);
p = mrb_parse_string(mrb, "puts 'hello'; puts 1+2; p({:a=>[1,2,3], :b=>{'c'=>{'d'=>['e', {'f'=>nil}]}}})",mrbc_ctx);
n = mrb_generate_code(mrb, p);
mrb_parser_free(p);
mrbc_context_free(mrb,mrbc_ctx);
mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value());
if (mrb->exc) {
mrb_p(mrb, mrb_obj_value(mrb->exc));
}
mrb_close(mrb);
return 0; /* returns 255 otherwise */
}
static ngx_int_t ngx_stream_mruby_shared_state_compile(ngx_conf_t *cf, mrb_state *mrb, ngx_mrb_code_t *code)
{
FILE *mrb_file;
struct mrb_parser_state *p;
if (code->code_type == NGX_MRB_CODE_TYPE_FILE) {
if ((mrb_file = fopen((char *)code->code.file, "r")) == NULL) {
return NGX_ERROR;
}
code->ctx = mrbc_context_new(mrb);
mrbc_filename(mrb, code->ctx, (char *)code->code.file);
p = mrb_parse_file(mrb, mrb_file, code->ctx);
fclose(mrb_file);
} else {
code->ctx = mrbc_context_new(mrb);
mrbc_filename(mrb, code->ctx, "INLINE CODE");
p = mrb_parse_string(mrb, (char *)code->code.string, code->ctx);
}
if (p == NULL) {
return NGX_ERROR;
}
code->proc = mrb_generate_code(mrb, p);
mrb_pool_close(p->pool);
if (code->proc == NULL) {
return NGX_ERROR;
}
if (code->code_type == NGX_MRB_CODE_TYPE_FILE) {
ngx_conf_log_error(NGX_LOG_NOTICE, cf, 0, "%s NOTICE %s:%d: compile info: code->code.file=(%s)", MODULE_NAME,
__func__, __LINE__, code->code.file);
} else {
ngx_conf_log_error(NGX_LOG_NOTICE, cf, 0, "%s NOTICE %s:%d: compile info: "
"code->code.string=(%s)",
MODULE_NAME, __func__, __LINE__, code->code.string);
}
return NGX_OK;
}
int main()
{
mrb_state *mrb = mrb_open();
init_TestClass(mrb);
char code[] = "$t = Test.new; res = $t.run; p res";
printf("Executing Ruby code from C!\n");
auto c = mrbc_context_new(mrb);
auto p = mrb_parse_string(mrb, code, c);
auto n = mrb_generate_code(mrb, p);
// mrb_run(mrb, n, mrb_top_self(mrb));
unsigned stack_keep = 0;
auto result = mrb_vm_run(mrb,
n,
mrb_top_self(mrb),
stack_keep);
if (mrb->exc) // have exception
{
mrb_p(mrb, mrb_obj_value(mrb->exc));
mrb->exc = 0;
}
else
{
if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect")))
result = mrb_any_to_s(mrb, result);
mrb_p(mrb, result);
}
mrbc_context_free(mrb, c);
mrb_close(mrb);
return 0;
}
int
main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
int n = -1;
int i;
struct _args args;
struct mrb_parser_state *p;
n = parse_args(mrb, argc, argv, &args);
if (n < 0 || (args.cmdline == NULL && args.rfp == NULL)) {
cleanup(mrb, &args);
usage(argv[0]);
return n;
}
if (args.mrbfile) {
n = mrb_load_irep(mrb, args.rfp);
}
else {
if (args.cmdline) {
p = mrb_parse_string(mrb, (char*)args.cmdline);
}
else {
p = mrb_parser_new(mrb);
if (p) {
mrb_parser_filename(p, argv[1]);
p->f = args.rfp;
mrb_parser_parse(p);
}
}
if (!p || !p->tree || p->nerr) {
cleanup(mrb, &args);
return -1;
}
if (args.verbose)
parser_dump(mrb, p->tree, 0);
n = mrb_generate_code(mrb, p->tree);
mrb_pool_close(p->pool);
}
if (n >= 0) {
mrb_value ARGV = mrb_ary_new(mrb);
for (i = 0; i < args.argc; i++) {
mrb_ary_push(mrb, ARGV, mrb_str_new(mrb, args.argv[i], strlen(args.argv[i])));
}
mrb_define_global_const(mrb, "ARGV", ARGV);
if (args.verbose)
codedump_all(mrb, n);
if (!args.check_syntax) {
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));
}
}
}
cleanup(mrb, &args);
return n > 0 ? 0 : 1;
}
