mruby.sh

mirb – Embeddable Interactive Ruby Shell

written by Daniel Bovensiepen on 2012-05-23 18:44 UTC

My first patch which was non-trivial to mruby was a reimplementation of the IRB. The Interactive Ruby Shell is a quite useful tool all over the Ruby community. It is available for all other implementations and there is even a web-version available. Enough reason to also create an embeddable version.

The first attempt was actually not done by me but by Frank Celler. He was in need for a playground to experiment with mruby in his no-sql database AvocadoDB. The downside of his solution was that he didn’t yet evaluated the return value of each evaluation and the complete thing was implemented in C++ (mruby is written in C99).

As time went by matz implemented this missing return value and I took another look at the API of mruby. The result was a quite naive implementation of an IRB based on mruby:

/*
** 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 <string.h>

#include <mruby.h>
#include <mruby/proc.h>
#include <mruby/data.h>
#include <mruby/compile.h>

/* Guess if the user might want to enter more
 * or if he wants an evaluation of his code now */
int
is_code_block_open(struct mrb_parser_state *parser)
{
  int code_block_open = FALSE;

  /* check for unterminated string */
  if (parser->sterm) return TRUE;

  /* 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 = TRUE;
    }
    else if (strcmp(message, "syntax error, unexpected tREGEXP_BEG") == 0) {
      code_block_open = TRUE;
    }
    return code_block_open;
  }

  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;
}

/* Print a short remark for the user */
void print_hint(void)
{
  printf("mirb - Embeddable Interactive Ruby Shelln");
  printf("nThis is a very early version, please test and report errors.n");
  printf("Thanks :)nn");
}

/* Print the command line prompt of the REPL */
void
print_cmdline(int code_block_open)
{
  if (code_block_open) {
    printf("* ");
  }
  else {
    printf("> ");
  }
}

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] = '�';

    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: %sn", 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;
}

But for some reason matz accepted it and since two weeks (2012-05-12) mruby has now a Read Eval Print Loop which provides an easy way to explore mruby:

boviAir:mruby daniel$ ./bin/mirb
mirb - Embeddable Interactive Ruby Shell

This is a very early version, please test and report errors.
Thanks :)

> class Testii
*   def testoo
*     puts 1
*   end
*
*   def testuu arg
*     puts arg
*   end
* end
=> nil
> Testii.testoo
#<NoMethodError: no method named testoo>
> Testii.new.testoo
1
=> false
> Testii.new.testuu 'hui'
hui
=> false
> 1+1
=> 2

But having such a tool doesn’t only makes it easy to play with Ruby. It also makes it possible to learn how to interact with mruby.

We start by getting a mruby instance:

mrb_interpreter = mrb_open();

With this instance we are getting a parser instance which we will use to parse our input code:

parser = mrb_parser_new(mrb_interpreter);

We now tell the parser where our ruby code is ->s, then we have to give him the same again with the length ->send. For our special use case of a REPL we tell the parser to capture all errors instead of screaming them out to stdio. This is done by ->capture_errors. With ->lineno we set the starting point and then we start the parsing with mrb_parser_parse:

/* parse code */
parser->s = ruby_code;
parser->send = ruby_code + strlen(ruby_code);
parser->capture_errors = 1;
parser->lineno = 1;
mrb_parser_parse(parser);

Next up, we want to compile down to byte code for the VM:

/* generate bytecode */
byte_code = mrb_generate_code(mrb_interpreter, parser->tree);

Last but not least we run the byte code inside of the VM and capturing the return value:

/* 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))

And that’s it. In this way you can use mruby in any of your application too.


available also via rss