mrb_value
grn_mrb_load(grn_ctx *ctx, const char *path)
{
grn_mrb_data *data = &(ctx->impl->mrb);
mrb_state *mrb = data->state;
char expanded_path[PATH_MAX];
FILE *file;
mrb_value result;
struct mrb_parser_state *parser;
if (!mrb) {
return mrb_nil_value();
}
if (!grn_mrb_expand_script_path(ctx, path, expanded_path, PATH_MAX)) {
return mrb_nil_value();
}
file = grn_fopen(expanded_path, "r");
if (!file) {
mrb_value exception;
SERR("fopen: failed to open mruby script file: <%s>",
expanded_path);
exception = mrb_exc_new(mrb, E_LOAD_ERROR,
ctx->errbuf, strlen(ctx->errbuf));
mrb->exc = mrb_obj_ptr(exception);
return mrb_nil_value();
}
{
char current_base_directory[PATH_MAX];
char *last_directory;
grn_strcpy(current_base_directory, PATH_MAX, data->base_directory);
grn_strcpy(data->base_directory, PATH_MAX, expanded_path);
last_directory = strrchr(data->base_directory, '/');
if (last_directory) {
last_directory[0] = '\0';
}
parser = mrb_parser_new(mrb);
mrb_parser_set_filename(parser, expanded_path);
parser->s = parser->send = NULL;
parser->f = file;
mrb_parser_parse(parser, NULL);
fclose(file);
{
struct RProc *proc;
proc = mrb_generate_code(mrb, parser);
result = mrb_toplevel_run(mrb, proc);
}
mrb_parser_free(parser);
grn_strcpy(data->base_directory, PATH_MAX, current_base_directory);
}
return result;
}
mrb_parser_state* mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
{
mrb_parser_state *p;
p = mrb_parser_new(mrb);
if (!p)
return 0;
p->s = p->send = nullptr;
p->f = f;
mrb_parser_parse(p, c);
return p;
}
mrb_parser_state* mrb_parse_nstring(mrb_state *mrb, const std::string &str, mrbc_context *c)
{
mrb_parser_state *p;
p = mrb_parser_new(mrb);
if (!p)
return 0;
p->source = str;
p->s = p->source.c_str();
p->send = p->s + p->source.size();
mrb_parser_parse(p, c);
return p;
}
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;
mrb_value MIRB_BIN;
int ai;
unsigned int stack_keep = 0;
/* 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;
MIRB_BIN= mrb_str_new(mrb, argv[0], strlen(argv[0]));
mrb_define_global_const(mrb, "MIRB_BIN", MIRB_BIN);
#ifdef ENABLE_REQUIRE
mrb_value LOAD_PATH = mrb_gv_get(mrb, mrb_intern(mrb, "$:"));
if (mrb_str_cmp(mrb, MIRB_BIN, mrb_str_new2(mrb, "mirb")) != 0) {
int len = strrchr(RSTRING_PTR(MIRB_BIN), '/') - RSTRING_PTR(MIRB_BIN);
mrb_value extdir = mrb_str_substr(mrb, mrb_str_dup(mrb, MIRB_BIN), 0, len);
mrb_str_cat2(mrb, extdir, "/../ext");
if (mrb_obj_eq(mrb, mrb_file_exist(mrb, extdir), mrb_true_value())) {
mrb_ary_push(mrb, LOAD_PATH, extdir);
}
}
#endif /* ENABLE_REQUIRE */
ai = mrb_gc_arena_save(mrb);
#ifdef ENABLE_READLINE
MIRB_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);
MIRB_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 = MIRB_READLINE(code_block_open ? "* " : "> ");
if (line == NULL) {
printf("\n");
break;
}
strncpy(last_code_line, line, sizeof(last_code_line)-1);
MIRB_ADD_HISTORY(line);
free(line);
#endif
if (code_block_open) {
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
}
else {
if ((strcmp(last_code_line, "quit") == 0) || (strcmp(last_code_line, "exit") == 0)) {
break;
}
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 */
/* evaluate the bytecode */
result = mrb_context_run(mrb,
proc,
mrb_top_self(mrb),
stack_keep);
stack_keep = proc->body.irep->nlocals;
/* 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++;
}
mrbc_context_free(mrb, cxt);
mrb_close(mrb);
#ifdef ENABLE_READLINE
MIRB_WRITE_HISTORY(history_path);
#endif
return 0;
}
mrb_parser_state ngx_init_mruby_parser(ngx_str_t *source_filename, const ngx_log_t *log) {
FILE *source_file;
char *source;
struct stat source_file_stat;
unsigned int source_size;
struct mrb_parser_state *parser;
if (source_filename == NULL) {
ngx_log_error(NGX_LOG_CRIT, log, "mruby source filename is invalid");
return NULL;
}
mrb_interpreter = mrb_open();
if (mrb_interpreter == NULL) {
ngx_log_error(NGX_LOG_CRIT, "could not allocate mruby interpreter");
return NULL;
}
parser = mrb_parser_new(mrb_interpreter);
stat(source_filename, &source_file_stat);
if (source_file_stat == NULL) {
ngx_log_error(NGX_LOG_CRIT, log, "mruby file '%s' does not exist.", source_filename);
return NULL;
}
source_size = (source_file_stat.st_size * sizeof(char)) + 1;
source = calloc(source_size);
if (source == NULL) {
ngx_log_error(NGX_LOG_CRIT, log, "could not allocate memory for mruby source");
return NULL;
}
source_file = fopen(source_filename, "r");
fread(source, sizeof(char), source_file_stat.st_size, source_file);
if (ferror(source_file)) {
ngx_log_error(
NGX_LOG_CRIT,
log,
"could not read mruby file '%s': %s",
source_filename,
ngx_strerror(ferror(source_file))
);
free(source);
return NULL;
} else {
fclose(source_file);
}
parser->filename = (char *)source_filename;
parser->s = source;
parser->send = source + strlen(source);
parser->capture_errors = 1;
parser->lineno = 1;
return parser;
}
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;
}
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;
}
void loop() {
if (Serial.available() > 0) {
char_index = 0;
while (true) {
if (Serial.available() > 0) {
incommingByte = Serial.read();
if (incommingByte == 13) {
// New Line
last_code_line[char_index] = '\0';
break;
} else {
last_code_line[char_index++] = incommingByte;
Serial.write(incommingByte);
}
}
}
Serial.println("");
Serial.flush();
is_exit = false;
if ((strcmp(last_code_line, "quit") == 0) || (strcmp(last_code_line, "exit") == 0)) {
// Exit Interactive Mode
if (!code_block_open) {
is_exit = true;
} else {
/* count the quit/exit commands as strings if in a quote block */
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
is_exit = false;
}
} else {
if (code_block_open) {
strcat(ruby_code, "\n");
strcat(ruby_code, last_code_line);
is_exit = false;
} else {
strcpy(ruby_code, last_code_line);
is_exit = false;
}
}
if (!is_exit) {
// Not Exit or Quit!
/* 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 */
Serial.write("Syntax Error: ");
Serial.println(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) {
/* yes */
p(mrb, mrb_obj_value(mrb->exc), 0);
mrb->exc = 0;
}
else {
/* no */
if (!mrb_respond_to(mrb,result,mrb_intern(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);
} else {
// User Enter 'exit' or 'quit'
Serial.println("quit IAS");
ruby_code[0] = '\0';
last_code_line[0] = '\0';
mrb_parser_free(parser);
mrbc_context_free(mrb, cxt);
mrb_close(mrb);
mrb_setup_arduino();
}
print_cmdline(code_block_open);
}
}
mrb_parser_state * Epoch::Script::get_parser()
{
return mrb_parser_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;
}
