static void
load_rb_file(mrb_state *mrb, mrb_value filepath)
{
FILE *file;
char *fpath = RSTRING_PTR(filepath);
mrbc_context *mrbc_ctx;
{
FILE *fp = fopen(fpath, "r");
if (fp == NULL) {
mrb_load_fail(mrb, filepath, "cannot load such file");
return;
}
fclose(fp);
}
mrbc_ctx = mrbc_context_new(mrb);
file = fopen((const char*)fpath, "r");
mrbc_filename(mrb, mrbc_ctx, fpath);
mrb_load_file_cxt(mrb, file, mrbc_ctx);
fclose(file);
mrbc_context_free(mrb, mrbc_ctx);
}
static int
load_file(mrb_state *mrb, struct mrbc_args *args)
{
mrbc_context *c;
mrb_value result;
char *input = args->argv[args->idx];
FILE *infile;
c = mrbc_context_new(mrb);
if (args->verbose)
c->dump_result = 1;
c->no_exec = 1;
if (input[0] == '-' && input[1] == '\0') {
infile = stdin;
}
else if ((infile = fopen(input, "r")) == NULL) {
fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, input);
return EXIT_FAILURE;
}
mrbc_filename(mrb, c, input);
args->idx++;
if (args->idx < args->argc) {
mrbc_partial_hook(mrb, c, partial_hook, (void*)args);
}
result = mrb_load_file_cxt(mrb, infile, c);
if (mrb_undef_p(result) || mrb_fixnum(result) < 0) {
mrbc_context_free(mrb, c);
return EXIT_FAILURE;
}
mrbc_context_free(mrb, c);
return EXIT_SUCCESS;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
app_handle = hInstance;
#ifndef WINDOWS
global_argc = argc;
global_argv = argv;
#endif
mrb_state* mrb = mrb_open();
set_mrb_for_thread(mrb);
mrbc_context* context = mrbc_context_new(mrb);
context->filename = "lamina_main.rb";
FILE* startup_script = fopen("lamina_main.rb", "r");
if (startup_script != NULL) {
mrb_load_file_cxt(mrb, startup_script, context);
if (mrb->exc) {
LAMINA_LOG("!!! Error !!! " << mrb_str_to_cstr(mrb, mrb_funcall(mrb, mrb_obj_value(mrb->exc), "to_s", 0)));
}
return 0;
}
else {
return 1;
}
}
int
main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
int n = -1;
struct _args args;
mrbc_context *c;
mrb_value result;
if (mrb == NULL) {
fputs("Invalid mrb_state, exiting mrbc\n", stderr);
return EXIT_FAILURE;
}
n = parse_args(mrb, argc, argv, &args);
if (n == EXIT_FAILURE || args.rfp == NULL) {
cleanup(mrb, &args);
usage(argv[0]);
return n;
}
c = mrbc_context_new(mrb);
if (args.verbose)
c->dump_result = 1;
c->no_exec = 1;
c->filename = args.filename;
result = mrb_load_file_cxt(mrb, args.rfp, c);
if (mrb_undef_p(result) || mrb_fixnum(result) < 0) {
cleanup(mrb, &args);
return EXIT_FAILURE;
}
if (args.check_syntax) {
puts("Syntax OK");
cleanup(mrb, &args);
return EXIT_SUCCESS;
}
if (args.initname) {
n = mrb_dump_irep_cfunc(mrb, n, args.debug_info, args.wfp, args.initname);
if (n == MRB_DUMP_INVALID_ARGUMENT) {
printf("%s: Invalid C language symbol name\n", args.initname);
return EXIT_FAILURE;
}
}
else {
n = mrb_dump_irep_binary(mrb, n, args.debug_info, args.wfp);
}
cleanup(mrb, &args);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
int n = -1;
struct _args args;
mrbc_context *c;
mrb_value result;
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb_state, exiting mrbc");
return EXIT_FAILURE;
}
n = parse_args(mrb, argc, argv, &args);
if (n < 0 || args.rfp == NULL) {
cleanup(mrb, &args);
usage(argv[0]);
return n;
}
c = mrbc_context_new(mrb);
if (args.verbose)
c->dump_result = 1;
c->no_exec = 1;
c->filename = args.filename;
result = mrb_load_file_cxt(mrb, args.rfp, c);
if (mrb_undef_p(result) || mrb_fixnum(result) < 0) {
cleanup(mrb, &args);
return EXIT_FAILURE;
}
if (args.check_syntax) {
printf("Syntax OK\n");
cleanup(mrb, &args);
return EXIT_SUCCESS;
}
if (args.initname) {
if (args.dump_type == DUMP_TYPE_BIN)
n = mrb_bdump_irep(mrb, n, args.wfp, args.initname);
else
n = mrb_cdump_irep(mrb, n, args.wfp, args.initname);
}
else {
n = mrb_dump_irep(mrb, n, args.wfp);
}
cleanup(mrb, &args);
return EXIT_SUCCESS;
}
static mrb_value
load_file(mrb_state *mrb, struct mrbc_args *args)
{
mrbc_context *c;
mrb_value result;
char *input = args->argv[args->idx];
FILE *infile;
mrb_bool need_close = FALSE;
c = mrbc_context_new(mrb);
if (args->verbose)
c->dump_result = TRUE;
c->no_exec = TRUE;
if (input[0] == '-' && input[1] == '\0') {
infile = stdin;
}
else {
need_close = TRUE;
if ((infile = fopen(input, "r")) == NULL) {
fprintf(stderr, "%s: cannot open program file. (%s)\n", args->prog, input);
return mrb_nil_value();
}
}
mrbc_filename(mrb, c, input);
args->idx++;
if (args->idx < args->argc) {
need_close = FALSE;
mrbc_partial_hook(mrb, c, partial_hook, (void*)args);
}
result = mrb_load_file_cxt(mrb, infile, c);
if (need_close) fclose(infile);
mrbc_context_free(mrb, c);
if (mrb_undef_p(result)) {
return mrb_nil_value();
}
return result;
}
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) {
fprintf(stderr, "Invalid mrb_state, exiting mruby");
return EXIT_FAILURE;
}
n = parse_args(mrb, argc, argv, &args);
if (n < 0 || (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_load_irep(mrb, args.rfp);
if (n >= 0) {
if (!args.check_syntax) {
mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
if (mrb->exc) {
p(mrb, mrb_obj_value(mrb->exc));
}
}
}
}
else {
mrbc_context *c = mrbc_context_new(mrb);
mrb_value v;
if (args.verbose)
c->dump_result = 1;
if (args.check_syntax)
c->no_exec = 1;
if (args.rfp) {
mrbc_filename(mrb, c, args.cmdline ? args.cmdline : "-");
v = mrb_load_file_cxt(mrb, args.rfp, c);
}
else {
mrbc_filename(mrb, c, "-e");
v = mrb_load_string_cxt(mrb, args.cmdline, c);
}
mrbc_context_free(mrb, c);
if (mrb->exc) {
if (!mrb_undef_p(v)) {
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;
struct _args args;
mrb_value v;
mrdb_state *mrdb;
mrdb_state *mrdb_backup;
mrb_debug_context* dbg_backup;
debug_command *cmd;
l_restart:
if (mrb == NULL) {
fputs("Invalid mrb_state, exiting mruby\n", stderr);
return EXIT_FAILURE;
}
/* parse command parameters */
n = parse_args(mrb, argc, argv, &args);
if (n == EXIT_FAILURE || args.rfp == NULL) {
cleanup(mrb, &args);
usage(argv[0]);
return n;
}
/* initialize debugger information */
mrdb = mrdb_state_get(mrb);
mrb_assert(mrdb && mrdb->dbg);
mrdb->srcpath = args.srcpath;
if(mrdb->dbg->xm == DBG_QUIT) {
mrdb->dbg->xphase = DBG_PHASE_RESTART;
}
else {
mrdb->dbg->xphase = DBG_PHASE_BEFORE_RUN;
}
mrdb->dbg->xm = DBG_INIT;
mrdb->dbg->ccnt = 1;
/* setup hook functions */
mrb->code_fetch_hook = mrb_code_fetch_hook;
mrdb->dbg->break_hook = mrb_debug_break_hook;
if (args.mrbfile) { /* .mrb */
v = mrb_load_irep_file(mrb, args.rfp);
}
else { /* .rb */
mrbc_context *cc = mrbc_context_new(mrb);
mrbc_filename(mrb, cc, args.fname);
v = mrb_load_file_cxt(mrb, args.rfp, cc);
mrbc_context_free(mrb, cc);
}
if (mrdb->dbg->xm == DBG_QUIT && !mrb_undef_p(v) && mrb->exc) {
const char *classname = mrb_obj_classname(mrb, mrb_obj_value(mrb->exc));
if (!strcmp(classname, "DebuggerExit")) {
cleanup(mrb, &args);
return 0;
}
if (!strcmp(classname, "DebuggerRestart")) {
mrdb_backup = mrdb_state_get(mrb);
dbg_backup = mrb_debug_context_get(mrb);
mrdb_state_set(NULL);
mrb_debug_context_set(NULL);
cleanup(mrb, &args);
mrb = mrb_open();
mrdb_state_set(mrdb_backup);
mrb_debug_context_set(dbg_backup);
goto l_restart;
}
}
puts("mruby application exited.");
mrdb->dbg->xphase = DBG_PHASE_AFTER_RUN;
if (!mrb_undef_p(v)) {
if (mrb->exc) {
mrb_print_error(mrb);
}
else {
printf(" => ");
mrb_p(mrb, v);
}
}
mrdb->dbg->prvfile = "-";
mrdb->dbg->prvline = 0;
while (1) {
cmd = get_and_parse_command(mrb, mrdb);
mrb_assert(cmd);
if (cmd->id == DBGCMD_QUIT) {
break;
}
if( cmd->func(mrb, mrdb) == DBGST_RESTART ) goto l_restart;
}
cleanup(mrb, &args);
return 0;
}
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;
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);
c = mrbc_context_new(mrb);
if (args.verbose)
c->dump_result = TRUE;
if (args.check_syntax)
c->no_exec = FALSE;
if (args.mrbfile) {
v = mrb_load_irep_file_cxt(mrb, args.rfp, c);
}
else {
mrb_sym zero_sym = mrb_intern_lit(mrb, "$0");
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_lit(mrb, "-e"));
v = mrb_load_string_cxt(mrb, args.cmdline, c);
}
}
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");
}
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;
}
mrb_value
mrb_load_file(mrb_state *mrb, FILE *f)
{
return mrb_load_file_cxt(mrb, f, NULL);
}
