/*
* Print levels:
* 0 - Do not print anything
* 1 - Print errors only
* 2 - Print errors and results
*/
static int check_and_print_errors(mrb_state* mrb, mrb_value result,
int print_level)
{
if (mrb->exc && (print_level > 0)) {
mrb_p(mrb, mrb_obj_value(mrb->exc));
mrb->exc = 0;
return 1;
}
if (print_level > 1) {
mrb_p(mrb, result);
}
return 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;
}
int main() {
FILE *fp;
if ((fp = fopen("./member.conf", "r")) == NULL)
return 1;
mrb_state* mrb = mrb_open();
mrb_load_file(mrb, fp);
mrb_value member;
mrb_get_config_value(mrb, "member", "o", &member);
mrb_value mnum = mrb_funcall(mrb, member, "size", 0);
int i;
int seki_num = mrb_fixnum(mnum);
for (i = 0; i < seki_num; i++) {
mnum = mrb_funcall(mrb, member, "size", 0);
mrb_value seki = mrb_funcall(mrb, mrb_top_self(mrb), "rand", 1, mnum);
mrb_p(mrb, mrb_funcall(mrb, member, "[]", 1, seki));
mrb_funcall(mrb, member, "delete_at", 1, seki);
}
mrb_close(mrb);
return 0;
}
virtual void PerformIteration()
{
mrb_run(mrb, script, mrb_nil_value());
if (mrb->exc) {
mrb_p(mrb, mrb_obj_value(mrb->exc));
}
}
int main(int argc, char *argv[])
{
mrb_state *mrb;
int ret = EXIT_SUCCESS;
/* create new interpreter instance */
mrb = mrb_open();
if (mrb == NULL) {
fprintf(stderr, "Invalid mrb_state, exiting test driver.\n");
return EXIT_FAILURE;
}
/* load bytecode */
webruby_internal_run(mrb);
if (mrb->exc) {
/* an exception occurs */
fprintf(stderr, "An exception occurs when running mruby bytecodes!\n");
mrb_p(mrb, mrb_obj_value(mrb->exc));
mrb->exc = 0;
ret = EXIT_FAILURE;
}
mrb_close(mrb);
return ret;
}
void GENERATED_TMP_mrb_mruby_enum_ext_gem_init(mrb_state *mrb) {
int ai = mrb_gc_arena_save(mrb);
mrb_load_irep(mrb, gem_mrblib_irep_mruby_enum_ext);
if (mrb->exc) {
mrb_p(mrb, mrb_obj_value(mrb->exc));
exit(EXIT_FAILURE);
}
mrb_gc_arena_restore(mrb, ai);
}
void mrb_exc_raise(mrb_state *mrb, mrb_value exc)
{
mrb->m_exc = exc.object_ptr();
exc_debug_info(mrb, mrb->m_exc);
if (!mrb->jmp) {
mrb_p(mrb, exc);
abort();
}
MRB_THROW(mrb->jmp);
}
bool TRI_ExecuteRubyString (mrb_state* mrb,
char const* script,
char const* name,
bool printResult,
mrb_value* result) {
struct mrb_parser_state* p;
mrb_value r;
int n;
p = mrb_parse_nstring(mrb, script, strlen(script));
if (p == 0 || p->tree == 0 || 0 < p->nerr) {
printf("failed to parse script\n");
return false;
}
n = mrb_generate_code(mrb, p->tree);
if (n < 0) {
printf("failed to generate code: %d\n", 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;
}
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);
}
}
void
mrb_exc_raise(mrb_state *mrb, mrb_value exc)
{
mrb->exc = mrb_obj_ptr(exc);
exc_debug_info(mrb, mrb->exc);
if (!mrb->jmp) {
mrb_p(mrb, exc);
abort();
}
longjmp(*(jmp_buf*)mrb->jmp, 1);
}
void
mrb_init_mrbtest(mrb_state *mrb)
{
mrb_load_irep(mrb, mrbtest_irep);
#ifndef DISABLE_GEMS
mrbgemtest_init(mrb);
#endif
if (mrb->exc) {
mrb_p(mrb, mrb_obj_value(mrb->exc));
exit(EXIT_FAILURE);
}
}
/* 15.3.1.3.34 */
static mrb_value
p_m(mrb_state *mrb, mrb_value self)
{
int argc, i;
mrb_value *argv;
mrb_get_args(mrb, "*", &argv, &argc);
for (i=0; i<argc; i++) {
mrb_p(mrb, argv[i]);
}
return argv[0];
}
MRB_API mrb_noreturn void
mrb_exc_raise(mrb_state *mrb, mrb_value exc)
{
mrb->exc = mrb_obj_ptr(exc);
if (!mrb->out_of_memory) {
exc_debug_info(mrb, mrb->exc);
}
if (!mrb->jmp) {
mrb_p(mrb, exc);
abort();
}
MRB_THROW(mrb->jmp);
}
void
mrb_exc_raise(mrb_state *mrb, mrb_value exc)
{
mrb->exc = (struct RObject*)mrb_object(exc);
exc_debug_info(mrb, mrb->exc);
if (!mrb->jmp) {
#ifdef ENABLE_STDIO
mrb_p(mrb, exc);
#endif
abort();
}
longjmp(*(jmp_buf*)mrb->jmp, 1);
}
MRB_API mrb_noreturn void
mrb_exc_raise(mrb_state *mrb, mrb_value exc)
{
mrb_exc_set(mrb, exc);
if (!mrb->gc.out_of_memory) {
exc_debug_info(mrb, mrb->exc);
mrb_save_backtrace(mrb);
}
if (!mrb->jmp) {
mrb_p(mrb, exc);
abort();
}
MRB_THROW(mrb->jmp);
}
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() {
mrb_state* mrb = mrb_open();
mrb_define_method(mrb, mrb->kernel_module, "plus", plus, MRB_ARGS_REQ(2));
mrb_define_method(mrb, mrb->kernel_module, "myabs", myabs, MRB_ARGS_REQ(1));
mrb_load_string(mrb,
"puts plus(1, 2);"
"puts plus('foo', 'bar');"
"puts myabs(-11);"
"puts myabs(332311);"
);
if (mrb->exc) { // エラー処理
mrb_p(mrb, mrb_obj_value(mrb->exc));
}
mrb_close(mrb);
return 0;
}
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;
}
static int
eval_test(mrb_state *mrb)
{
mrb_value return_value;
const char *prog = "report()";
/* evaluate the test */
return_value = mrb_load_string(mrb, prog);
/* did an exception occur? */
if (mrb->exc) {
mrb_p(mrb, return_value);
mrb->exc = 0;
return EXIT_FAILURE;
}
else if (!check_error(mrb)) {
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
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 */
}
// FLTK::NativeFileChooser#filename(index=nil)
// Return the filename the user choose. If index is given, return one of the filenames the user selected.
mrb_value mrb_fltk_native_file_chooser_filename_instance_method( mrb_state *mrb, mrb_value self ) {
// TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO
// Segfaults! Wowza
// TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO TODO
GET_DATA( fl_native_file_chooser, Fl_Native_File_Chooser, self );
mrb_value mrb_index;
mrb_get_args( mrb, "|i", &mrb_index );
mrb_value mrb_filename;
if( mrb_nil_p( mrb_index ) ) {
mrb_filename = mrb_str_new_cstr( mrb, fl_native_file_chooser->filename() );
} else {
mrb_filename = mrb_str_new_cstr( mrb, fl_native_file_chooser->filename( mrb_fixnum( mrb_index ) ) );
}
printf( "-==--==--==-=-=-=-=-=-=-=-=--=-=-=----------\n" );
mrb_p( mrb, mrb_filename );
printf( "-==--==--==-=-=-=-=-=-=-=-=--=-=-=----------\n" );
return mrb_filename;
}
ngx_int_t ngx_eval_mruby(mrb_state *mrb_interpreter, mrb_parser_state *parser, mrb_value *mrb_return_value, const ngx_log_t *log) {
*mrb_return_value =
mrb_run(
mrb_interpreter,
mrb_proc_new(
mrb_interpreter,
mrb_interpreter->irep[
mrb_generate_code(mrb_interpreter, parser->tree)
]
),
mrb_top_self(mrb_interpreter)
);
/* exception handling */
if (mrb_interpreter->exc) {
mrb_p(mrb_interpreter, mrb_obj_value(mrb_interpreter->exc));
mrb_interpreter->exc = NULL;
return 1;
}
return 0;
}
int exec(int argc, char* argv[])
{
mrb_state* mrb = mrb_open();
if(mrb == 0)
{
printf("cannot open mruby\n");
return -2;
}
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;
}
//----------------------------------------------------------
void ScriptEngine::closeOnException()
{
if (mMrb->exc) {
// Kernel.p
mrb_p(mMrb, mrb_obj_value(mMrb->exc));
// Save error message & Draw to display
mrb_value str = mrb_funcall(mMrb, mrb_obj_value(mMrb->exc), "inspect", 0);
mErrorMsg = mrb_string_value_cstr(mMrb, &str);
// Insert a line break at the 40 digits each
static const int COLUMN = 40;
int insertPos = COLUMN;
while (mErrorMsg.length() > insertPos) {
mErrorMsg.insert(insertPos, "\n");
insertPos += COLUMN + 1;
}
// Close mrb
mErroredMrb = mMrb;
mMrb = NULL;
}
}
int
main(int argc, char *argv[])
{
mrb_state *mrb;
int i;
mrb_value ARGV;
mrb = mrb_open();
ARGV = mrb_ary_new_capa(mrb, argc - 1);
for (i = 1; i < argc; i++) {
mrb_ary_push(mrb, ARGV, mrb_str_new_cstr(mrb, argv[i]));
}
mrb_define_global_const(mrb, "ARGV", ARGV);
mrb_load_string(mrb, "Fastyet.start");
if(mrb->exc) {
mrb_p(mrb, mrb_obj_value(mrb->exc));
}
mrb_close(mrb);
return EXIT_SUCCESS;
}
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;
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(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;
}
