add context to parser, that would hold local variable info, filename, and line number. mrbc_context argument has been added to mrb_parse_xxx() functions. Normally, you just to need to add NULL (or 0) to the last argument of the above functions.

include/mruby/compile.h

@@ -14,13 +14,26 @@ extern "C" {
 #include "mruby.h"
 #include <stdio.h>
 #include <setjmp.h>
+#include <stdio.h>
 
+/* load context */
+typedef struct mrbc_context {
+  mrb_sym *syms;
+  int slen;
+  char *filename;
+  int lineno;
+} mrbc_context;
+
+mrbc_context* mrbc_context_new(mrb_state *mrb);
+void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
+const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
+
+/* AST node structure */
 typedef struct mrb_ast_node {
   struct mrb_ast_node *car, *cdr;
 } mrb_ast_node;
 
-#include <stdio.h>
-
+/* lexer states */
 enum mrb_lex_state_enum {
     EXPR_BEG,                   /* ignore newline, +/- is a sign. */
     EXPR_END,                   /* newline significant, +/- is an operator. */
@@ -36,21 +49,23 @@ enum mrb_lex_state_enum {
     EXPR_MAX_STATE
 };
 
+/* saved error message */
 struct mrb_parser_message {
   int lineno;
   int column;
   char* message;
 };
 
+/* parser structure */
 struct mrb_parser_state {
   mrb_state *mrb;
   struct mrb_pool *pool;
   mrb_ast_node *cells;
   const char *s, *send;
   FILE *f;
+  char *filename;
   int lineno;
   int column;
-  const char *filename;
 
   enum mrb_lex_state_enum lstate;
   int sterm;
@@ -59,6 +74,8 @@ struct mrb_parser_state {
   unsigned int cmdarg_stack;
   int paren_nest;
   int lpar_beg;
+  int in_def, in_single, cmd_start;
+  mrb_ast_node *locals;
 
   mrb_ast_node *pb;
   char buf[1024];
@@ -66,9 +83,6 @@ struct mrb_parser_state {
 
   mrb_ast_node *heredoc;
 
-  int in_def, in_single, cmd_start;
-  mrb_ast_node *locals;
-
   void *ylval;
 
   int nerr;
@@ -82,22 +96,23 @@ struct mrb_parser_state {
   jmp_buf jmp;
 };
 
-/* parser structure */
 struct mrb_parser_state* mrb_parser_new(mrb_state*);
 const char *mrb_parser_filename(struct mrb_parser_state*, const char*);
-int mrb_parser_lineno(struct mrb_parser_state*, int);
 void mrb_parser_parse(struct mrb_parser_state*);
 
 /* utility functions */
-struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*);
-struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*);
-struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int);
+struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
+struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
+struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int,mrbc_context*);
 int mrb_generate_code(mrb_state*, mrb_ast_node*);
 
 /* program load functions */
 mrb_value mrb_load_file(mrb_state*,FILE*);
 mrb_value mrb_load_string(mrb_state *mrb, const char *path);
 mrb_value mrb_load_nstring(mrb_state *mrb, const char *path, int len);
+mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
+mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *path, mrbc_context *cxt);
+mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *path, int len, mrbc_context *cxt);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */

src/parse.y

@@ -4730,7 +4730,6 @@ mrb_parser_new(mrb_state *mrb)
   p->in_def = p->in_single = FALSE;
 
   p->capture_errors = 0;
-
   p->lineno = 1;
   p->column = 0;
 #if defined(PARSER_TEST) || defined(PARSER_DEBUG)
@@ -4740,33 +4739,56 @@ mrb_parser_new(mrb_state *mrb)
   return p;
 }
 
-const char*
-mrb_parser_filename(parser_state *p, const char *s)
+mrbc_context*
+mrbc_context_new(mrb_state *mrb)
 {
-  if (s) {
-    p->filename = strdup(s);
-  }
-  return p->filename;
+  mrbc_context *c;
+
+  c = mrb_malloc(mrb, sizeof(mrbc_context));
+  memset(c, 0, sizeof(mrbc_context));
+  return c;
 }
 
-int
-mrb_parser_lineno(struct mrb_parser_state *p, int n)
+void
+mrbc_context_free(mrb_state *mrb, mrbc_context *cxt)
 {
-  if (n <= 0) {
-    return p->lineno;
+  mrb_free(mrb, cxt->syms);
+  mrb_free(mrb, cxt->filename);
+  mrb_free(mrb, cxt);
+}
+
+const char*
+mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s)
+{
+  if (s) {
+    int len = strlen(s);
+    char *p = mrb_malloc(mrb, len);
+
+    memcpy(p, s, len);
+    if (c->filename) mrb_free(mrb, c->filename);
+    c->filename = p;
+    c->lineno = 1;
+  }
+  return c->filename;
+}
+
+static void
+parser_init_cxt(parser_state *p, mrbc_context *cxt)
+{
+  if (cxt) {
+    if (cxt->lineno) p->lineno = cxt->lineno;
+    if (cxt->filename) p->filename = cxt->filename;
   }
-  p->column = 0;
-  p->lineno = n;
-  return n;
 }
 
 parser_state*
-mrb_parse_file(mrb_state *mrb, FILE *f)
+mrb_parse_file(mrb_state *mrb, FILE *f, mrbc_context *c)
 {
   parser_state *p;
  
   p = mrb_parser_new(mrb);
   if (!p) return 0;
+  parser_init_cxt(p, c);
   p->s = p->send = NULL;
   p->f = f;
 
@@ -4775,12 +4797,13 @@ mrb_parse_file(mrb_state *mrb, FILE *f)
 }
 
 parser_state*
-mrb_parse_nstring(mrb_state *mrb, const char *s, int len)
+mrb_parse_nstring(mrb_state *mrb, const char *s, int len, mrbc_context *c)
 {
   parser_state *p;
 
   p = mrb_parser_new(mrb);
   if (!p) return 0;
+  parser_init_cxt(p, c);
   p->s = s;
   p->send = s + len;
 
@@ -4789,9 +4812,9 @@ mrb_parse_nstring(mrb_state *mrb, const char *s, int len)
 }
 
 parser_state*
-mrb_parse_string(mrb_state *mrb, const char *s)
+mrb_parse_string(mrb_state *mrb, const char *s, mrbc_context *c)
 {
-  return mrb_parse_nstring(mrb, s, strlen(s));
+  return mrb_parse_nstring(mrb, s, strlen(s), c);
 }
 
 static mrb_value
@@ -4817,22 +4840,40 @@ load_exec(mrb_state *mrb, parser_state *p)
   return mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
 }
 
+mrb_value
+mrb_load_file_cxt(mrb_state *mrb, FILE *f, mrbc_context *c)
+{
+  return load_exec(mrb, mrb_parse_file(mrb, f, c));
+}
+
 mrb_value
 mrb_load_file(mrb_state *mrb, FILE *f)
 {
-  return load_exec(mrb, mrb_parse_file(mrb, f));
+  return mrb_load_file_cxt(mrb, f, NULL);
+}
+
+mrb_value
+mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *c)
+{
+  return load_exec(mrb, mrb_parse_nstring(mrb, s, len, c));
 }
 
 mrb_value
 mrb_load_nstring(mrb_state *mrb, const char *s, int len)
 {
-  return load_exec(mrb, mrb_parse_nstring(mrb, s, len));
+  return mrb_load_nstring_cxt(mrb, s, len, NULL);
+}
+
+mrb_value
+mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *c)
+{
+  return load_exec(mrb, mrb_parse_nstring(mrb, s, strlen(s), c));
 }
 
 mrb_value
 mrb_load_string(mrb_state *mrb, const char *s)
 {
-  return load_exec(mrb, mrb_parse_nstring(mrb, s, strlen(s)));
+  return mrb_load_string_cxt(mrb, s, NULL);
 }
 
 void parser_dump(mrb_state *mrb, node *tree, int offset);

test/driver.c

@@ -42,16 +42,8 @@ main(void)
   }
 
   mrb_init_mrbtest(mrb);
-  parser = mrb_parse_nstring(mrb, prog, strlen(prog));
-
-  /* generate bytecode */
-  byte_code = mrb_generate_code(mrb, parser->tree);
-
-  /* evaluate the bytecode */
-  return_value = mrb_run(mrb,
-    /* pass a proc for evaulation */
-    mrb_proc_new(mrb, mrb->irep[byte_code]),
-    mrb_top_self(mrb));
+  /* evaluate the test */
+  return_value = mrb_load_string(mrb, prog);
   /* did an exception occur? */
   if (mrb->exc) {
     mrb_p(mrb, return_value);

tools/mrbc/mrbc.c

@@ -172,7 +172,7 @@ main(int argc, char **argv)
     return n;
   }
 
-  p = mrb_parse_file(mrb, args.rfp);
+  p = mrb_parse_file(mrb, args.rfp, NULL);
   if (!p || !p->tree || p->nerr) {
     cleanup(&args);
     mrb_close(mrb);

tools/mruby/mruby.c

@@ -165,17 +165,16 @@ main(int argc, char **argv)
     n = mrb_load_irep(mrb, args.rfp);
   }
   else {
+    mrbc_context *c = mrbc_context_new(mrb);
     if (args.cmdline) {
-      p = mrb_parse_string(mrb, (char*)args.cmdline);
-    }
+      mrbc_filename(mrb, c, "-e");
+      p = mrb_parse_string(mrb, (char*)args.cmdline, c); 
+   }
     else {
-      p = mrb_parser_new(mrb);
-      if (p) {
-	mrb_parser_filename(p, argv[1]);
-	p->f = args.rfp;
-	mrb_parser_parse(p);
-      }
+      mrbc_filename(mrb, c, argv[1]);
+      p = mrb_parse_file(mrb, args.rfp, c);
     }
+    mrbc_context_free(mrb, c);
     if (!p || !p->tree || p->nerr) {
       cleanup(mrb, &args);
       return -1;