int
main(void)
{
char last_char, ruby_code[1024], last_code_line[1024];
int char_index;
struct mrb_parser_state *parser;
mrb_state *mrb_interpreter;
mrb_value mrb_return_value;
int byte_code;
int code_block_open = FALSE;
print_hint();
/* new interpreter instance */
mrb_interpreter = mrb_open();
/* new parser instance */
parser = mrb_parser_new(mrb_interpreter);
memset(ruby_code, 0, sizeof(*ruby_code));
memset(last_code_line, 0, sizeof(*last_code_line));
while (TRUE) {
print_cmdline(code_block_open);
char_index = 0;
while ((last_char = getchar()) != '\n') {
if (last_char == EOF) break;
last_code_line[char_index++] = last_char;
}
if (last_char == EOF) {
printf("\n");
break;
}
last_code_line[char_index] = '\0';
if ((strcmp(last_code_line, "quit") == 0) ||
(strcmp(last_code_line, "exit") == 0)) {
if (code_block_open) {
/* cancel the current block and reset */
code_block_open = FALSE;
memset(ruby_code, 0, sizeof(*ruby_code));
memset(last_code_line, 0, sizeof(*last_code_line));
continue;
}
else {
/* quit the program */
break;
}
}
else {
if (code_block_open) {
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
}
else {
memset(ruby_code, 0, sizeof(*ruby_code));
strcat(ruby_code, last_code_line);
}
/* parse code */
parser->s = ruby_code;
parser->send = ruby_code + strlen(ruby_code);
parser->capture_errors = 1;
parser->lineno = 1;
mrb_parser_parse(parser);
code_block_open = is_code_block_open(parser);
if (code_block_open) {
/* no evaluation of code */
}
else {
if (0 < parser->nerr) {
/* syntax error */
printf("line %d: %s\n", parser->error_buffer[0].lineno, parser->error_buffer[0].message);
}
else {
/* generate bytecode */
byte_code = mrb_generate_code(mrb_interpreter, parser->tree);
/* evaluate the bytecode */
mrb_return_value = mrb_run(mrb_interpreter,
/* pass a proc for evaulation */
mrb_proc_new(mrb_interpreter, mrb_interpreter->irep[byte_code]),
mrb_top_self(mrb_interpreter));
/* did an exception occur? */
if (mrb_interpreter->exc) {
mrb_p(mrb_interpreter, mrb_obj_value(mrb_interpreter->exc));
mrb_interpreter->exc = 0;
}
else {
/* no */
printf(" => ");
mrb_p(mrb_interpreter, mrb_return_value);
}
}
memset(ruby_code, 0, sizeof(*ruby_code));
memset(ruby_code, 0, sizeof(*last_code_line));
}
}
}
mrb_close(mrb_interpreter);
return 0;
}
void
test_incremental_gc(void)
{
mrb_state *mrb = mrb_open();
size_t max = ~0, live = 0, total = 0, freed = 0;
RVALUE *free;
struct heap_page *page;
puts("test_incremental_gc");
change_gen_gc_mode(mrb, FALSE);
puts(" in mrb_full_gc");
mrb_full_gc(mrb);
mrb_assert(mrb->gc_state == GC_STATE_NONE);
puts(" in GC_STATE_NONE");
incremental_gc(mrb, max);
mrb_assert(mrb->gc_state == GC_STATE_MARK);
puts(" in GC_STATE_MARK");
incremental_gc_until(mrb, GC_STATE_SWEEP);
mrb_assert(mrb->gc_state == GC_STATE_SWEEP);
puts(" in GC_STATE_SWEEP");
page = mrb->heaps;
while (page) {
RVALUE *p = page->objects;
RVALUE *e = p + MRB_HEAP_PAGE_SIZE;
while (p<e) {
if (is_black(&p->as.basic)) {
live++;
}
if (is_gray(&p->as.basic) && !is_dead(mrb, &p->as.basic)) {
printf("%p\n", &p->as.basic);
}
p++;
}
page = page->next;
total += MRB_HEAP_PAGE_SIZE;
}
mrb_assert(mrb->gray_list == NULL);
incremental_gc(mrb, max);
mrb_assert(mrb->gc_state == GC_STATE_SWEEP);
incremental_gc(mrb, max);
mrb_assert(mrb->gc_state == GC_STATE_NONE);
free = (RVALUE*)mrb->heaps->freelist;
while (free) {
freed++;
free = (RVALUE*)free->as.free.next;
}
mrb_assert(mrb->live == live);
mrb_assert(mrb->live == total-freed);
puts("test_incremental_gc(gen)");
incremental_gc_until(mrb, GC_STATE_SWEEP);
change_gen_gc_mode(mrb, TRUE);
mrb_assert(mrb->gc_full == FALSE);
mrb_assert(mrb->gc_state == GC_STATE_NONE);
puts(" in minor");
mrb_assert(is_minor_gc(mrb));
mrb_assert(mrb->majorgc_old_threshold > 0);
mrb->majorgc_old_threshold = 0;
mrb_incremental_gc(mrb);
mrb_assert(mrb->gc_full == TRUE);
mrb_assert(mrb->gc_state == GC_STATE_NONE);
puts(" in major");
mrb_assert(is_major_gc(mrb));
do {
mrb_incremental_gc(mrb);
} while (mrb->gc_state != GC_STATE_NONE);
mrb_assert(mrb->gc_full == FALSE);
mrb_close(mrb);
}
int
main(int argc, char **argv)
{
char ruby_code[1024] = { 0 };
char last_code_line[1024] = { 0 };
#ifndef ENABLE_READLINE
int last_char;
int char_index;
#else
char *home = NULL;
#endif
mrbc_context *cxt;
struct mrb_parser_state *parser;
mrb_state *mrb;
mrb_value result;
struct _args args;
int n;
mrb_bool code_block_open = FALSE;
int ai;
mrb_bool first_command = TRUE;
unsigned int nregs;
/* new interpreter instance */
mrb = mrb_open();
if (mrb == NULL) {
fputs("Invalid mrb interpreter, exiting mirb\n", stderr);
return EXIT_FAILURE;
}
mrb_define_global_const(mrb, "ARGV", mrb_ary_new_capa(mrb, 0));
n = parse_args(mrb, argc, argv, &args);
if (n == EXIT_FAILURE) {
cleanup(mrb, &args);
usage(argv[0]);
return n;
}
print_hint();
cxt = mrbc_context_new(mrb);
cxt->capture_errors = 1;
cxt->lineno = 1;
mrbc_filename(mrb, cxt, "(mirb)");
if (args.verbose) cxt->dump_result = 1;
ai = mrb_gc_arena_save(mrb);
#ifdef ENABLE_READLINE
using_history();
home = getenv("HOME");
#ifdef _WIN32
if (!home)
home = getenv("USERPROFILE");
#endif
if (home) {
strcpy(history_path, home);
strcat(history_path, "/");
strcat(history_path, history_file_name);
read_history(history_path);
}
#endif
while (TRUE) {
#ifndef ENABLE_READLINE
print_cmdline(code_block_open);
char_index = 0;
while ((last_char = getchar()) != '\n') {
if (last_char == EOF) break;
last_code_line[char_index++] = last_char;
}
if (last_char == EOF) {
fputs("\n", stdout);
break;
}
last_code_line[char_index] = '\0';
#else
char* line = readline(code_block_open ? "* " : "> ");
if (line == NULL) {
printf("\n");
break;
}
strncpy(last_code_line, line, sizeof(last_code_line)-1);
add_history(line);
free(line);
#endif
if ((strcmp(last_code_line, "quit") == 0) || (strcmp(last_code_line, "exit") == 0)) {
if (!code_block_open) {
break;
}
else{
/* count the quit/exit commands as strings if in a quote block */
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
}
}
else {
if (code_block_open) {
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
}
else {
strcpy(ruby_code, last_code_line);
}
}
/* parse code */
parser = mrb_parser_new(mrb);
parser->s = ruby_code;
parser->send = ruby_code + strlen(ruby_code);
parser->lineno = cxt->lineno;
mrb_parser_parse(parser, cxt);
code_block_open = is_code_block_open(parser);
if (code_block_open) {
/* no evaluation of code */
}
else {
if (0 < parser->nerr) {
/* syntax error */
printf("line %d: %s\n", parser->error_buffer[0].lineno, parser->error_buffer[0].message);
}
else {
/* generate bytecode */
struct RProc *proc = mrb_generate_code(mrb, parser);
if (args.verbose) {
mrb_codedump_all(mrb, proc);
}
/* pass a proc for evaulation */
nregs = first_command ? 0: proc->body.irep->nregs;
/* evaluate the bytecode */
result = mrb_context_run(mrb,
proc,
mrb_top_self(mrb),
nregs);
/* did an exception occur? */
if (mrb->exc) {
p(mrb, mrb_obj_value(mrb->exc), 0);
mrb->exc = 0;
}
else {
/* no */
if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect"))){
result = mrb_any_to_s(mrb,result);
}
p(mrb, result, 1);
}
}
ruby_code[0] = '\0';
last_code_line[0] = '\0';
mrb_gc_arena_restore(mrb, ai);
}
mrb_parser_free(parser);
cxt->lineno++;
first_command = FALSE;
}
mrbc_context_free(mrb, cxt);
mrb_close(mrb);
#ifdef ENABLE_READLINE
write_history(history_path);
#endif
return 0;
}
ScriptEngine::ScriptEngine(): mrb(mrb_open(), [=](mrb_state *state){
mrb_close(state);
}) {
}
void
test_mrb_field_write_barrier(void)
{
mrb_state *mrb = mrb_open();
struct RBasic *obj, *value;
puts("test_mrb_field_write_barrier");
mrb->is_generational_gc_mode = FALSE;
obj = mrb_basic_ptr(mrb_ary_new(mrb));
value = mrb_basic_ptr(mrb_str_new_lit(mrb, "value"));
paint_black(obj);
paint_partial_white(mrb,value);
puts(" in GC_STATE_MARK");
mrb->gc_state = GC_STATE_MARK;
mrb_field_write_barrier(mrb, obj, value);
mrb_assert(is_gray(value));
puts(" in GC_STATE_SWEEP");
paint_partial_white(mrb,value);
mrb->gc_state = GC_STATE_SWEEP;
mrb_field_write_barrier(mrb, obj, value);
mrb_assert(obj->color & mrb->current_white_part);
mrb_assert(value->color & mrb->current_white_part);
puts(" fail with black");
mrb->gc_state = GC_STATE_MARK;
paint_white(obj);
paint_partial_white(mrb,value);
mrb_field_write_barrier(mrb, obj, value);
mrb_assert(obj->color & mrb->current_white_part);
puts(" fail with gray");
mrb->gc_state = GC_STATE_MARK;
paint_black(obj);
paint_gray(value);
mrb_field_write_barrier(mrb, obj, value);
mrb_assert(is_gray(value));
{
puts("test_mrb_field_write_barrier_value");
obj = mrb_basic_ptr(mrb_ary_new(mrb));
mrb_value value = mrb_str_new_lit(mrb, "value");
paint_black(obj);
paint_partial_white(mrb, mrb_basic_ptr(value));
mrb->gc_state = GC_STATE_MARK;
mrb_field_write_barrier_value(mrb, obj, value);
mrb_assert(is_gray(mrb_basic_ptr(value)));
}
mrb_close(mrb);
}
//----------------------------------------------------------
void ScriptEngine::open()
{
close(); // close if still open.
mMrb = mrb_open();
}
int
main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
int n = -1;
int i;
struct _args args;
mrb_value ARGV;
if (mrb == NULL) {
fputs("Invalid mrb_state, exiting mruby\n", stderr);
return EXIT_FAILURE;
}
n = parse_args(mrb, argc, argv, &args);
if (n == EXIT_FAILURE || (args.cmdline == NULL && args.rfp == NULL)) {
cleanup(mrb, &args);
usage(argv[0]);
return n;
}
ARGV = mrb_ary_new_capa(mrb, args.argc);
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.mrbfile) {
n = mrb_read_irep_file(mrb, args.rfp);
if (n < 0) {
fprintf(stderr, "failed to load mrb file: %s\n", args.cmdline);
}
else if (!args.check_syntax) {
mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
n = 0;
if (mrb->exc) {
showcallinfo(mrb);
p(mrb, mrb_obj_value(mrb->exc));
n = -1;
}
}
}
else {
mrbc_context *c = mrbc_context_new(mrb);
mrb_sym zero_sym = mrb_intern2(mrb, "$0", 2);
mrb_value v;
if (args.verbose)
c->dump_result = 1;
if (args.check_syntax)
c->no_exec = 1;
if (args.rfp) {
char *cmdline;
cmdline = args.cmdline ? args.cmdline : "-";
mrbc_filename(mrb, c, cmdline);
mrb_gv_set(mrb, zero_sym, mrb_str_new_cstr(mrb, cmdline));
v = mrb_load_file_cxt(mrb, args.rfp, c);
}
else {
mrbc_filename(mrb, c, "-e");
mrb_gv_set(mrb, zero_sym, mrb_str_new(mrb, "-e", 2));
v = mrb_load_string_cxt(mrb, args.cmdline, c);
}
mrbc_context_free(mrb, c);
if (mrb->exc) {
if (!mrb_undef_p(v)) {
showcallinfo(mrb);
p(mrb, mrb_obj_value(mrb->exc));
}
n = -1;
}
else if (args.check_syntax) {
printf("Syntax OK\n");
}
}
cleanup(mrb, &args);
return n == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
int
main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
int n = -1;
int i;
struct _args args;
mrb_value ARGV;
mrbc_context *c;
mrb_value v;
mrb_sym zero_sym;
struct mrb_jmpbuf c_jmp;
int ai;
if (mrb == NULL) {
fputs("Invalid mrb_state, exiting mruby\n", stderr);
return EXIT_FAILURE;
}
n = parse_args(mrb, argc, argv, &args);
if (n == EXIT_FAILURE || (args.cmdline == NULL && args.rfp == NULL)) {
cleanup(mrb, &args);
usage(argv[0]);
return n;
}
ai = mrb_gc_arena_save(mrb);
MRB_TRY(&c_jmp) {
mrb->jmp = &c_jmp;
ARGV = mrb_ary_new_capa(mrb, args.argc);
for (i = 0; i < args.argc; i++) {
char* utf8 = mrb_utf8_from_locale(args.argv[i], -1);
if (utf8) {
mrb_ary_push(mrb, ARGV, mrb_str_new_cstr(mrb, utf8));
mrb_utf8_free(utf8);
}
}
mrb_define_global_const(mrb, "ARGV", ARGV);
c = mrbc_context_new(mrb);
if (args.verbose)
c->dump_result = TRUE;
if (args.check_syntax)
c->no_exec = TRUE;
/* Set $0 */
zero_sym = mrb_intern_lit(mrb, "$0");
if (args.rfp) {
const char *cmdline;
cmdline = args.cmdline ? args.cmdline : "-";
mrbc_filename(mrb, c, cmdline);
mrb_gv_set(mrb, zero_sym, mrb_str_new_cstr(mrb, cmdline));
}
else {
mrbc_filename(mrb, c, "-e");
mrb_gv_set(mrb, zero_sym, mrb_str_new_lit(mrb, "-e"));
}
/* Load program */
if (args.mrbfile) {
v = mrb_load_irep_file_cxt(mrb, args.rfp, c);
}
else if (args.rfp) {
v = mrb_load_file_cxt(mrb, args.rfp, c);
}
else {
char* utf8 = mrb_utf8_from_locale(args.cmdline, -1);
if (!utf8) abort();
v = mrb_load_string_cxt(mrb, utf8, c);
mrb_utf8_free(utf8);
}
mrb_gc_arena_restore(mrb, ai);
mrbc_context_free(mrb, c);
if (mrb->exc) {
if (!mrb_undef_p(v)) {
mrb_print_error(mrb);
}
n = -1;
}
else if (args.check_syntax) {
printf("Syntax OK\n");
}
}
MRB_CATCH(&c_jmp) { /* error */
}
MRB_END_EXC(&c_jmp);
cleanup(mrb, &args);
return n == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
int
main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
int n, result;
struct mrbc_args args;
FILE *wfp;
mrb_value load;
if (mrb == NULL) {
fputs("Invalid mrb_state, exiting mrbc\n", stderr);
return EXIT_FAILURE;
}
n = parse_args(mrb, argc, argv, &args);
if (n < 0) {
cleanup(mrb, &args);
usage(argv[0]);
return EXIT_FAILURE;
}
if (n == argc) {
fprintf(stderr, "%s: no program file given\n", args.prog);
return EXIT_FAILURE;
}
if (args.outfile == NULL) {
if (n + 1 == argc) {
args.outfile = get_outfilename(mrb, argv[n], args.initname ? C_EXT : RITEBIN_EXT);
}
else {
fprintf(stderr, "%s: output file should be specified to compile multiple files\n", args.prog);
return EXIT_FAILURE;
}
}
args.idx = n;
load = load_file(mrb, &args);
if (mrb_nil_p(load)) {
cleanup(mrb, &args);
return EXIT_FAILURE;
}
if (args.check_syntax) {
printf("%s:%s:Syntax OK\n", args.prog, argv[n]);
}
if (args.check_syntax) {
cleanup(mrb, &args);
return EXIT_SUCCESS;
}
if (args.outfile) {
if (strcmp("-", args.outfile) == 0) {
wfp = stdout;
}
else if ((wfp = fopen(args.outfile, "wb")) == NULL) {
fprintf(stderr, "%s: cannot open output file:(%s)\n", args.prog, args.outfile);
return EXIT_FAILURE;
}
}
else {
fprintf(stderr, "Output file is required\n");
return EXIT_FAILURE;
}
result = dump_file(mrb, wfp, args.outfile, mrb_proc_ptr(load), &args);
fclose(wfp);
cleanup(mrb, &args);
if (result != MRB_DUMP_OK) {
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
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 VALUE
mruby_alloc(VALUE class)
{
mrb_state *mrb = mrb_open();
return Data_Wrap_Struct(mruby_cMRuby, NULL, NULL, mrb);
}
VALUE
mruby_gen_code(VALUE self, VALUE prog)
{
int n = -1;
mrb_state *mrb = (mrb_state *)DATA_PTR(self);
struct mrb_parser_state *p;
mrbc_context *c = mrbc_context_new(mrb);
p = mrb_parse_string(mrb, StringValueCStr(prog), c);
n = mrb_generate_code(mrb, p);
mrbc_context_free(mrb, c);
int main(int argc, char *argv[])
{
mrb_value s;
FILE *fp;
DIR *dp;
struct dirent *dirst;
mrb_state *mrb = mrb_open();
glmrb_sprite_init(mrb);
glmrb_input_init(mrb);
dp = opendir("./lib");
while((dirst = readdir(dp)) != NULL)
{
char buf[256];
if (dirst->d_name[0] == '.') continue;
strcpy(buf, "./lib/");
strcat(buf, dirst->d_name);
fp = fopen(buf, "r");
mrb_load_file(mrb, fp);
fclose(fp);
}
closedir(dp);
fp = fopen("main.rb", "r");
s = mrb_load_file(mrb, fp);
fclose(fp);
/* SDL初期化 */
if (SDL_Init(SDL_INIT_VIDEO) < 0 ) {
exit(-1);
}
/* フレームバッファ作成 */
mWIN = SDL_SetVideoMode(640, 480, 0, 0);
if (!mWIN) {
SDL_Quit();
exit(-1);
}
/* キャプション設定 */
SDL_WM_SetCaption("glmruby application",NULL);
/* メインループ */
while(quits() != 0) {
mrb_funcall(mrb, s, "update", 0);
/* 画面消去 */
SDL_FillRect(mWIN, NULL, SDL_MapRGB(mWIN->format, 0, 0, 0));
mrb_funcall(mrb, s, "draw", 0);
/* ウェイト処理 */
timer.now = SDL_GetTicks();
timer.wit = timer.now - timer.lev;
if (timer.wit < 16) SDL_Delay(16 - timer.wit);
timer.lev = SDL_GetTicks();
/* 画面更新 */
SDL_UpdateRect(mWIN, 0, 0, 0, 0);
}
/* 終了処理 */
SDL_Quit();
return 0;
}
Epoch::Script::Script()
:main_state(mrb_open())
{
std::cout << "Init script sub system: Ruby \n";
this->current_context = mrbc_context_new(this->main_state);
}
int
main(void)
{
char ruby_code[1024] = { 0 };
char last_code_line[1024] = { 0 };
#ifndef ENABLE_READLINE
int last_char;
int char_index;
#endif
mrbc_context *cxt;
struct mrb_parser_state *parser;
mrb_state *mrb;
mrb_value result;
int n;
int code_block_open = FALSE;
int ai;
print_hint();
/* new interpreter instance */
mrb = mrb_open();
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb interpreter, exiting mirb");
return EXIT_FAILURE;
}
cxt = mrbc_context_new(mrb);
cxt->capture_errors = 1;
ai = mrb_gc_arena_save(mrb);
while (TRUE) {
#ifndef ENABLE_READLINE
print_cmdline(code_block_open);
char_index = 0;
while ((last_char = getchar()) != '\n') {
if (last_char == EOF) break;
last_code_line[char_index++] = last_char;
}
if (last_char == EOF) {
printf("\n");
break;
}
last_code_line[char_index] = '\0';
#else
char* line = readline(code_block_open ? "* " : "> ");
strncat(last_code_line, line, sizeof(last_code_line)-1);
add_history(line);
free(line);
#endif
if ((strcmp(last_code_line, "quit") == 0) || (strcmp(last_code_line, "exit") == 0)) {
if (!code_block_open) {
break;
}
else{
/* count the quit/exit commands as strings if in a quote block */
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
}
}
else {
if (code_block_open) {
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
}
else {
strcpy(ruby_code, last_code_line);
}
}
/* parse code */
parser = mrb_parser_new(mrb);
parser->s = ruby_code;
parser->send = ruby_code + strlen(ruby_code);
parser->lineno = 1;
mrb_parser_parse(parser, cxt);
code_block_open = is_code_block_open(parser);
if (code_block_open) {
/* no evaluation of code */
}
else {
if (0 < parser->nerr) {
/* syntax error */
printf("line %d: %s\n", parser->error_buffer[0].lineno, parser->error_buffer[0].message);
}
else {
/* generate bytecode */
n = mrb_generate_code(mrb, parser);
/* evaluate the bytecode */
result = mrb_run(mrb,
/* pass a proc for evaulation */
mrb_proc_new(mrb, mrb->irep[n]),
mrb_top_self(mrb));
/* did an exception occur? */
if (mrb->exc) {
p(mrb, mrb_obj_value(mrb->exc));
mrb->exc = 0;
}
else {
/* no */
printf(" => ");
p(mrb, result);
}
}
ruby_code[0] = '\0';
last_code_line[0] = '\0';
mrb_parser_free(parser);
mrb_gc_arena_restore(mrb, ai);
}
}
mrbc_context_free(mrb, cxt);
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;
}
int main()
{
char *str;
mrb_state* mrb;
int n;
FILE* f;
mrb_value ret;
int key='q';
mrb = mrb_open();
f = fopen("test.rb", "r");
mrb_load_file(mrb, f);
fclose(f);
initscr();
key = getch();
ret = mrb_funcall(mrb, mrb_top_self(mrb), "evaluate", 1, mrb_fixnum_value(key) );
str = mrb_string_value_ptr(mrb, ret);
printf("%s\n", str);
//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;
initscr();
keypad(stdscr, TRUE);
setlocale(LC_ALL, "");
/*
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);
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);
}
static mrb_value
mrb_future_init(mrb_state *oldmrb, mrb_value self)
{
static const struct mrb_context mrb_context_zero = { 0 };
mrb_state *mrb = mrb_open();
mrb_future_context *context = (mrb_future_context *) malloc(sizeof(mrb_future_context));
struct mrb_context *c;
struct RProc *p;
mrb_callinfo *ci;
mrb_value blk;
size_t slen;
int argc;
mrb_value* argv;
*mrb = *oldmrb;
mrb_get_args(mrb, "*&", &argv, &argc, &blk);
p = mrb_proc_ptr(blk);
c = (struct mrb_context*)mrb_malloc(mrb, sizeof(struct mrb_context));
*c = mrb_context_zero;
mrb->c = c;
context->mrb = mrb;
context->oldmrb = oldmrb;
context->proc = mrb_proc_ptr(blk);
context->argc = argc;
context->argv = argv;
context->self = self;
/* initialize VM stack */
slen = FIBER_STACK_INIT_SIZE;
if (!MRB_PROC_CFUNC_P(p) && p->body.irep->nregs > slen) {
slen += p->body.irep->nregs;
}
c->stbase = (mrb_value *)mrb_malloc(mrb, slen*sizeof(mrb_value));
c->stend = c->stbase + slen;
c->stack = c->stbase;
#ifdef MRB_NAN_BOXING
{
mrb_value *p = c->stbase;
mrb_value *pend = c->stend;
while (p < pend) {
SET_NIL_VALUE(*p);
p++;
}
}
#else
memset(c->stbase, 0, slen * sizeof(mrb_value));
#endif
/* copy future object(self) from a block */
c->stack[0] = self;
/* initialize callinfo stack */
c->cibase = (mrb_callinfo *)mrb_calloc(mrb, FIBER_CI_INIT_SIZE, sizeof(mrb_callinfo));
c->ciend = c->cibase + FIBER_CI_INIT_SIZE;
c->ci = c->cibase;
c->ci->stackent = c->stack;
/* adjust return callinfo */
ci = c->ci;
ci->target_class = p->target_class;
ci->proc = p;
if (!MRB_PROC_CFUNC_P(p)) {
ci->pc = p->body.irep->iseq;
ci->nregs = p->body.irep->nregs;
}
ci[1] = ci[0];
c->ci++; /* push dummy callinfo */
mrb_iv_set(oldmrb, self, mrb_intern_cstr(oldmrb, "_context"), mrb_cptr_value(oldmrb, context));
mrb_iv_set(oldmrb, self, mrb_intern_cstr(oldmrb, "_state"), mrb_fixnum_value(FUTURE_RUNNING));
pthread_create(&context->thread, NULL, &mrb_future_func, (void *)context);
return self;
}
