mirror of https://gitee.com/bigwinds/arangodb
400 lines
8.8 KiB
C
400 lines
8.8 KiB
C
/*
|
|
** mirb - Embeddable Interactive Ruby Shell
|
|
**
|
|
** This program takes code from the user in
|
|
** an interactive way and executes it
|
|
** immediately. It's a REPL...
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include <mruby.h>
|
|
#include "mruby/array.h"
|
|
#include <mruby/proc.h>
|
|
#include <mruby/data.h>
|
|
#include <mruby/compile.h>
|
|
#ifdef ENABLE_READLINE
|
|
#include <limits.h>
|
|
#include <readline/readline.h>
|
|
#include <readline/history.h>
|
|
#endif
|
|
#include <mruby/string.h>
|
|
|
|
|
|
#ifdef ENABLE_READLINE
|
|
static const char *history_file_name = ".mirb_history";
|
|
char history_path[PATH_MAX];
|
|
#endif
|
|
|
|
|
|
static void
|
|
p(mrb_state *mrb, mrb_value obj, int prompt)
|
|
{
|
|
obj = mrb_funcall(mrb, obj, "inspect", 0);
|
|
if (prompt) {
|
|
if (!mrb->exc) {
|
|
fputs(" => ", stdout);
|
|
}
|
|
else {
|
|
obj = mrb_funcall(mrb, mrb_obj_value(mrb->exc), "inspect", 0);
|
|
}
|
|
}
|
|
fwrite(RSTRING_PTR(obj), RSTRING_LEN(obj), 1, stdout);
|
|
putc('\n', stdout);
|
|
}
|
|
|
|
/* Guess if the user might want to enter more
|
|
* or if he wants an evaluation of his code now */
|
|
mrb_bool
|
|
is_code_block_open(struct mrb_parser_state *parser)
|
|
{
|
|
int code_block_open = FALSE;
|
|
|
|
/* check for heredoc */
|
|
if (parser->parsing_heredoc != NULL) return TRUE;
|
|
if (parser->heredoc_end_now) {
|
|
parser->heredoc_end_now = FALSE;
|
|
return FALSE;
|
|
}
|
|
|
|
/* check if parser error are available */
|
|
if (0 < parser->nerr) {
|
|
const char *unexpected_end = "syntax error, unexpected $end";
|
|
const char *message = parser->error_buffer[0].message;
|
|
|
|
/* a parser error occur, we have to check if */
|
|
/* we need to read one more line or if there is */
|
|
/* a different issue which we have to show to */
|
|
/* the user */
|
|
|
|
if (strncmp(message, unexpected_end, strlen(unexpected_end)) == 0) {
|
|
code_block_open = TRUE;
|
|
}
|
|
else if (strcmp(message, "syntax error, unexpected keyword_end") == 0) {
|
|
code_block_open = FALSE;
|
|
}
|
|
else if (strcmp(message, "syntax error, unexpected tREGEXP_BEG") == 0) {
|
|
code_block_open = FALSE;
|
|
}
|
|
return code_block_open;
|
|
}
|
|
|
|
/* check for unterminated string */
|
|
if (parser->lex_strterm) return TRUE;
|
|
|
|
switch (parser->lstate) {
|
|
|
|
/* all states which need more code */
|
|
|
|
case EXPR_BEG:
|
|
/* an expression was just started, */
|
|
/* we can't end it like this */
|
|
code_block_open = TRUE;
|
|
break;
|
|
case EXPR_DOT:
|
|
/* a message dot was the last token, */
|
|
/* there has to come more */
|
|
code_block_open = TRUE;
|
|
break;
|
|
case EXPR_CLASS:
|
|
/* a class keyword is not enough! */
|
|
/* we need also a name of the class */
|
|
code_block_open = TRUE;
|
|
break;
|
|
case EXPR_FNAME:
|
|
/* a method name is necessary */
|
|
code_block_open = TRUE;
|
|
break;
|
|
case EXPR_VALUE:
|
|
/* if, elsif, etc. without condition */
|
|
code_block_open = TRUE;
|
|
break;
|
|
|
|
/* now all the states which are closed */
|
|
|
|
case EXPR_ARG:
|
|
/* an argument is the last token */
|
|
code_block_open = FALSE;
|
|
break;
|
|
|
|
/* all states which are unsure */
|
|
|
|
case EXPR_CMDARG:
|
|
break;
|
|
case EXPR_END:
|
|
/* an expression was ended */
|
|
break;
|
|
case EXPR_ENDARG:
|
|
/* closing parenthese */
|
|
break;
|
|
case EXPR_ENDFN:
|
|
/* definition end */
|
|
break;
|
|
case EXPR_MID:
|
|
/* jump keyword like break, return, ... */
|
|
break;
|
|
case EXPR_MAX_STATE:
|
|
/* don't know what to do with this token */
|
|
break;
|
|
default:
|
|
/* this state is unexpected! */
|
|
break;
|
|
}
|
|
|
|
return code_block_open;
|
|
}
|
|
|
|
void mrb_show_version(mrb_state *);
|
|
void mrb_show_copyright(mrb_state *);
|
|
|
|
struct _args {
|
|
mrb_bool verbose : 1;
|
|
int argc;
|
|
char** argv;
|
|
};
|
|
|
|
static void
|
|
usage(const char *name)
|
|
{
|
|
static const char *const usage_msg[] = {
|
|
"switches:",
|
|
"-v print version number, then run in verbose mode",
|
|
"--verbose run in verbose mode",
|
|
"--version print the version",
|
|
"--copyright print the copyright",
|
|
NULL
|
|
};
|
|
const char *const *p = usage_msg;
|
|
|
|
printf("Usage: %s [switches]\n", name);
|
|
while (*p)
|
|
printf(" %s\n", *p++);
|
|
}
|
|
|
|
static int
|
|
parse_args(mrb_state *mrb, int argc, char **argv, struct _args *args)
|
|
{
|
|
static const struct _args args_zero = { 0 };
|
|
|
|
*args = args_zero;
|
|
|
|
for (argc--,argv++; argc > 0; argc--,argv++) {
|
|
char *item;
|
|
if (argv[0][0] != '-') break;
|
|
|
|
item = argv[0] + 1;
|
|
switch (*item++) {
|
|
case 'v':
|
|
if (!args->verbose) mrb_show_version(mrb);
|
|
args->verbose = 1;
|
|
break;
|
|
case '-':
|
|
if (strcmp((*argv) + 2, "version") == 0) {
|
|
mrb_show_version(mrb);
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
else if (strcmp((*argv) + 2, "verbose") == 0) {
|
|
args->verbose = 1;
|
|
break;
|
|
}
|
|
else if (strcmp((*argv) + 2, "copyright") == 0) {
|
|
mrb_show_copyright(mrb);
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
default:
|
|
return EXIT_FAILURE;
|
|
}
|
|
}
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
static void
|
|
cleanup(mrb_state *mrb, struct _args *args)
|
|
{
|
|
mrb_close(mrb);
|
|
}
|
|
|
|
/* Print a short remark for the user */
|
|
static void
|
|
print_hint(void)
|
|
{
|
|
printf("mirb - Embeddable Interactive Ruby Shell\n");
|
|
printf("\nThis is a very early version, please test and report errors.\n");
|
|
printf("Thanks :)\n\n");
|
|
}
|
|
|
|
/* Print the command line prompt of the REPL */
|
|
void
|
|
print_cmdline(int code_block_open)
|
|
{
|
|
if (code_block_open) {
|
|
printf("* ");
|
|
}
|
|
else {
|
|
printf("> ");
|
|
}
|
|
}
|
|
|
|
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;
|
|
int code_block_open = FALSE;
|
|
int ai;
|
|
|
|
/* 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 */
|
|
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), 0);
|
|
mrb->exc = 0;
|
|
}
|
|
else {
|
|
/* no */
|
|
if (!mrb_respond_to(mrb, result, mrb_intern2(mrb, "inspect", 7))){
|
|
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
|
|
write_history(history_path);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|