diff --git a/lib/ext/melbourne/grammar18.y b/lib/ext/melbourne/grammar18.y
index 770936be2b..b7fe8ae047 100644
--- a/lib/ext/melbourne/grammar18.y
+++ b/lib/ext/melbourne/grammar18.y
@@ -31,8 +31,6 @@
 
 namespace melbourne {
 
-rb_parser_state *alloc_parser_state();
-
 namespace grammar18 {
 
 #ifndef isnumber
@@ -235,14 +233,14 @@ static int _debug_print(const char *fmt, ...) {
 #define rb_warn _debug_print
 #define rb_warning _debug_print
 
-void push_start_line(rb_parser_state* st, int line, const char* which) {
-  st->start_lines->push_back(StartPosition(line, which));
+void push_start_line(rb_parser_state* parser_state, int line, const char* which) {
+  start_lines->push_back(StartPosition(line, which));
 }
 
 #define PUSH_LINE(which) push_start_line((rb_parser_state*)parser_state, ruby_sourceline, which)
 
-void pop_start_line(rb_parser_state* st) {
-  st->start_lines->pop_back();
+void pop_start_line(rb_parser_state* parser_state) {
+  start_lines->pop_back();
 }
 
 #define POP_LINE() pop_start_line((rb_parser_state*)parser_state)
@@ -1306,11 +1304,11 @@ arg             : lhs '=' arg
                         in_defined = 0;
                         $$ = NEW_DEFINED($4);
                     }
-                | arg '?' {vps->ternary_colon++;} arg ':' arg
+                | arg '?' {ternary_colon++;} arg ':' arg
                     {
                         $$ = NEW_IF(cond($1, vps), $4, $6);
                         fixpos($$, $1);
-                        vps->ternary_colon--;
+                        ternary_colon--;
                     }
                 | primary
                     {
@@ -2700,7 +2698,7 @@ yycompile(rb_parser_state *parser_state, char *f, int line)
     /* Setup an initial empty scope. */
     heredoc_end = 0;
     lex_strterm = 0;
-    parser_state->end_seen = 0;
+    end_seen = 0;
     ruby_sourcefile = f;
     command_start = TRUE;
     n = yyparse(parser_state);
@@ -2726,18 +2724,18 @@ lex_get_str(rb_parser_state *parser_state)
     const char *beg, *end, *pend;
     int sz;
 
-    str = bdata(parser_state->lex_string);
+    str = bdata(lex_string);
     beg = str;
 
-    if (parser_state->lex_str_used) {
-      if (blength(parser_state->lex_string) == parser_state->lex_str_used) {
+    if (lex_str_used) {
+      if (blength(lex_string) == lex_str_used) {
         return false;
       }
 
-      beg += parser_state->lex_str_used;
+      beg += lex_str_used;
     }
 
-    pend = str + blength(parser_state->lex_string);
+    pend = str + blength(lex_string);
     end = beg;
 
     while(end < pend) {
@@ -2745,8 +2743,8 @@ lex_get_str(rb_parser_state *parser_state)
     }
 
     sz = end - beg;
-    bcatblk(parser_state->line_buffer, beg, sz);
-    parser_state->lex_str_used += sz;
+    bcatblk(line_buffer, beg, sz);
+    lex_str_used += sz;
 
     return TRUE;
 }
@@ -2754,13 +2752,13 @@ lex_get_str(rb_parser_state *parser_state)
 static bool
 lex_getline(rb_parser_state *parser_state)
 {
-  if(!parser_state->line_buffer) {
-    parser_state->line_buffer = cstr2bstr("");
+  if(!line_buffer) {
+    line_buffer = cstr2bstr("");
   } else {
-    btrunc(parser_state->line_buffer, 0);
+    btrunc(line_buffer, 0);
   }
 
-  return parser_state->lex_gets(parser_state);
+  return lex_gets(parser_state);
 }
 
 VALUE process_parse_tree(rb_parser_state*, VALUE, NODE*, QUID*);
@@ -2769,24 +2767,20 @@ VALUE
 string_to_ast(VALUE ptp, const char *f, bstring s, int line)
 {
     int n;
-    rb_parser_state *parser_state;
     VALUE ret;
-    parser_state = alloc_parser_state();
-    parser_state->lex_string = s;
-    parser_state->lex_gets = lex_get_str;
-    lex_pbeg = 0;
-    lex_p = 0;
-    lex_pend = 0;
-    parser_state->error = Qfalse;
-    parser_state->processor = ptp;
+    rb_parser_state *parser_state = parser_alloc_state();
+
+    lex_string = s;
+    lex_gets = lex_get_str;
+    processor = ptp;
     ruby_sourceline = line - 1;
     compile_for_eval = 1;
 
     n = yycompile(parser_state, (char*)f, line);
 
-    if(parser_state->error == Qfalse) {
-      for(std::vector<bstring>::iterator i = parser_state->magic_comments->begin();
-          i != parser_state->magic_comments->end();
+    if(!parse_error) {
+      for(std::vector<bstring>::iterator i = magic_comments->begin();
+          i != magic_comments->end();
           i++) {
         rb_funcall(ptp, rb_intern("add_magic_comment"), 1,
           rb_str_new((const char*)(*i)->data, (*i)->slen));
@@ -2801,7 +2795,7 @@ string_to_ast(VALUE ptp, const char *f, bstring s, int line)
 }
 
 static bool parse_io_gets(rb_parser_state *parser_state) {
-  if(feof(parser_state->lex_io)) {
+  if(feof(lex_io)) {
     return false;
   }
 
@@ -2809,13 +2803,13 @@ static bool parse_io_gets(rb_parser_state *parser_state) {
     char *ptr, buf[1024];
     int read;
 
-    ptr = fgets(buf, sizeof(buf), parser_state->lex_io);
+    ptr = fgets(buf, sizeof(buf), lex_io);
     if(!ptr) {
       return false;
     }
 
     read = strlen(ptr);
-    bcatblk(parser_state->line_buffer, ptr, read);
+    bcatblk(line_buffer, ptr, read);
 
     /* check whether we read a full line */
     if(!(read == (sizeof(buf) - 1) && ptr[read] != '\n')) {
@@ -2831,30 +2825,26 @@ file_to_ast(VALUE ptp, const char *f, FILE *file, int start)
 {
     int n;
     VALUE ret;
-    rb_parser_state *parser_state;
-    parser_state = alloc_parser_state();
-    parser_state->lex_io = file;
-    parser_state->lex_gets = parse_io_gets;
-    lex_pbeg = 0;
-    lex_p = 0;
-    lex_pend = 0;
-    parser_state->error = Qfalse;
-    parser_state->processor = ptp;
+    rb_parser_state *parser_state = parser_alloc_state();
+
+    lex_io = file;
+    lex_gets = parse_io_gets;
+    processor = ptp;
     ruby_sourceline = start - 1;
 
     n = yycompile(parser_state, (char*)f, start);
 
-    if(parser_state->error == Qfalse) {
-      for(std::vector<bstring>::iterator i = parser_state->magic_comments->begin();
-          i != parser_state->magic_comments->end();
+    if(!parse_error) {
+      for(std::vector<bstring>::iterator i = magic_comments->begin();
+          i != magic_comments->end();
           i++) {
         rb_funcall(ptp, rb_intern("add_magic_comment"), 1,
           rb_str_new((const char*)(*i)->data, (*i)->slen));
       }
         ret = process_parse_tree(parser_state, ptp, top_node, NULL);
 
-        if (parser_state->end_seen && parser_state->lex_io) {
-          rb_funcall(ptp, rb_sData, 1, ULONG2NUM(ftell(parser_state->lex_io)));
+        if (end_seen && lex_io) {
+          rb_funcall(ptp, rb_sData, 1, ULONG2NUM(ftell(lex_io)));
         }
     } else {
         ret = Qnil;
@@ -2876,7 +2866,7 @@ ps_nextc(rb_parser_state *parser_state)
         bstring v;
 
         if (!lex_getline(parser_state)) return -1;
-        v = parser_state->line_buffer;
+        v = line_buffer;
 
         if (heredoc_end > 0) {
             ruby_sourceline = heredoc_end;
@@ -2902,11 +2892,11 @@ ps_nextc(rb_parser_state *parser_state)
     if (c == '\r' && lex_p < lex_pend && *(lex_p) == '\n') {
         lex_p++;
         c = '\n';
-        parser_state->column = 0;
+        column = 0;
     } else if(c == '\n') {
-        parser_state->column = 0;
+        column = 0;
     } else {
-        parser_state->column++;
+        column++;
     }
 
     return c;
@@ -3297,7 +3287,7 @@ static int tokadd_string(int func, int term, int paren, quark *nest, rb_parser_s
 #define NEW_STRTERM(func, term, paren) \
   node_newnode(NODE_STRTERM, (VALUE)(func), \
                (VALUE)((term) | ((paren) << (CHAR_BIT * 2))), NULL)
-#define pslval ((YYSTYPE *)parser_state->lval)
+#define pslval ((YYSTYPE *)lval)
 static int
 parse_string(NODE *quote, rb_parser_state *parser_state)
 {
@@ -3614,7 +3604,7 @@ yylex(void *yylval_v, void *vstate)
     YYSTYPE *yylval = (YYSTYPE*)yylval_v;
     parser_state = (struct rb_parser_state*)vstate;
 
-    parser_state->lval = (void *)yylval;
+    lval = (void *)yylval;
 
     /*
     c = nextc();
@@ -3661,7 +3651,7 @@ yylex(void *yylval_v, void *vstate)
         if(char* str = parse_comment(parser_state)) {
             int len = lex_pend - str - 1; // - 1 for the \n
             cur_line = blk2bstr(str, len);
-            parser_state->magic_comments->push_back(cur_line);
+            magic_comments->push_back(cur_line);
         }
         lex_p = lex_pend;
         /* fall through */
@@ -3893,7 +3883,7 @@ yylex(void *yylval_v, void *vstate)
           ternary:
             pushback(c, parser_state);
             lex_state = EXPR_BEG;
-            parser_state->ternary_colon = 1;
+            ternary_colon = 1;
             return '?';
         }
         else if (ismbchar(c)) {
@@ -4644,7 +4634,7 @@ yylex(void *yylval_v, void *vstate)
 
       case '_':
         if (was_bol() && whole_match_p("__END__", 7, 0, parser_state)) {
-            parser_state->end_seen = 1;
+            end_seen = 1;
             return -1;
         }
         newtok(parser_state);
@@ -4831,7 +4821,7 @@ static void
 parser_warning(rb_parser_state *parser_state, NODE *node, const char *mesg)
 {
     int line = ruby_sourceline;
-    if(parser_state->emit_warnings) {
+    if(emit_warnings) {
       ruby_sourceline = nd_line(node);
       printf("%s:%li: warning: %s\n", ruby_sourcefile, ruby_sourceline, mesg);
       ruby_sourceline = line;
@@ -4866,7 +4856,7 @@ block_append(rb_parser_state *parser_state, NODE *head, NODE *tail)
         break;
     }
 
-    if (parser_state->verbose) {
+    if (verbose) {
         NODE *nd = end->nd_head;
       newline:
         switch (nd_type(nd)) {
@@ -5412,7 +5402,7 @@ void_expr0(NODE *node, rb_parser_state *parser_state)
 {
   const char *useless = NULL;
 
-    if (!parser_state->verbose) return;
+    if (!verbose) return;
 
   again:
     if (!node) return;
@@ -5505,7 +5495,7 @@ void_expr0(NODE *node, rb_parser_state *parser_state)
 static void
 void_stmts(NODE *node, rb_parser_state *parser_state)
 {
-    if (!parser_state->verbose) return;
+    if (!verbose) return;
     if (!node) return;
     if (nd_type(node) != NODE_BLOCK) return;
 
@@ -5664,7 +5654,7 @@ cond0(NODE *node, rb_parser_state *parser_state)
         if (!e_option_supplied()) {
             int b = literal_node(node->nd_beg);
             int e = literal_node(node->nd_end);
-            if ((b == 1 && e == 1) || (b + e >= 2 && parser_state->verbose)) {
+            if ((b == 1 && e == 1) || (b + e >= 2 && verbose)) {
             }
         }
         break;
diff --git a/lib/ext/melbourne/grammar19.y b/lib/ext/melbourne/grammar19.y
index 0780528eff..30d15bc2d7 100644
--- a/lib/ext/melbourne/grammar19.y
+++ b/lib/ext/melbourne/grammar19.y
@@ -33,8 +33,6 @@
 
 namespace melbourne {
 
-rb_parser_state* alloc_parser_state();
-
 namespace grammar19 {
 
 #ifndef isnumber
@@ -218,14 +216,14 @@ static int _debug_print(const char *fmt, ...) {
 #define rb_warn _debug_print
 #define rb_warning _debug_print
 
-void push_start_line(rb_parser_state* st, int line, const char* which) {
-  st->start_lines->push_back(StartPosition(line, which));
+void push_start_line(rb_parser_state* parser_state, int line, const char* which) {
+  start_lines->push_back(StartPosition(line, which));
 }
 
 #define PUSH_LINE(which) push_start_line((rb_parser_state*)parser_state, ruby_sourceline, which)
 
-void pop_start_line(rb_parser_state* st) {
-  st->start_lines->pop_back();
+void pop_start_line(rb_parser_state* parser_state) {
+  start_lines->pop_back();
 }
 
 #define POP_LINE() pop_start_line((rb_parser_state*)parser_state)
@@ -2975,7 +2973,7 @@ none            : /* none */ {$$ = 0;}
 #undef parser
 #undef yylex
 #undef yylval
-#define yylval  (*((YYSTYPE*)(parser_state->lval)))
+#define yylval  (*((YYSTYPE*)(lval)))
 
 static int parser_regx_options(rb_parser_state*);
 static int parser_tokadd_string(rb_parser_state*, int, int, int, long*, rb_encoding**);
@@ -3025,7 +3023,7 @@ static int parser_here_document(rb_parser_state*, NODE*);
 #define parser_mbclen()           mbclen((lex_p-1),lex_pend,parser->enc)
 #define parser_precise_mbclen()   rb_enc_precise_mbclen((lex_p-1),lex_pend,parser_state->enc)
 #define is_identchar(p,e,enc)     (rb_enc_isalnum(*p,enc) || (*p) == '_' || !ISASCII(*p))
-#define parser_is_identchar()     (!parser_state->eofp && \
+#define parser_is_identchar()     (!eofp && \
                                    is_identchar((lex_p-1),lex_pend,parser_state->enc))
 
 #define parser_isascii() ISASCII(*(lex_p-1))
@@ -3053,7 +3051,7 @@ yycompile(rb_parser_state* parser_state, char *f, int line)
   /* Setup an initial empty scope. */
   heredoc_end = 0;
   lex_strterm = 0;
-  parser_state->end_seen = 0;
+  end_seen = 0;
   ruby_sourcefile = f;
   command_start = TRUE;
   n = yyparse(parser_state);
@@ -3079,18 +3077,18 @@ lex_get_str(rb_parser_state* parser_state)
   const char *beg, *end, *pend;
   int sz;
 
-  str = bdata(parser_state->lex_string);
+  str = bdata(lex_string);
   beg = str;
 
-  if(parser_state->lex_str_used) {
-    if(blength(parser_state->lex_string) == parser_state->lex_str_used) {
+  if(lex_str_used) {
+    if(blength(lex_string) == lex_str_used) {
       return false;
     }
 
-    beg += parser_state->lex_str_used;
+    beg += lex_str_used;
   }
 
-  pend = str + blength(parser_state->lex_string);
+  pend = str + blength(lex_string);
   end = beg;
 
   while(end < pend) {
@@ -3098,8 +3096,8 @@ lex_get_str(rb_parser_state* parser_state)
   }
 
   sz = end - beg;
-  bcatblk(parser_state->line_buffer, beg, sz);
-  parser_state->lex_str_used += sz;
+  bcatblk(line_buffer, beg, sz);
+  lex_str_used += sz;
 
   return TRUE;
 }
@@ -3107,13 +3105,13 @@ lex_get_str(rb_parser_state* parser_state)
 static bool
 lex_getline(rb_parser_state* parser_state)
 {
-  if(!parser_state->line_buffer) {
-    parser_state->line_buffer = cstr2bstr("");
+  if(!line_buffer) {
+    line_buffer = cstr2bstr("");
   } else {
-    btrunc(parser_state->line_buffer, 0);
+    btrunc(line_buffer, 0);
   }
 
-  return parser_state->lex_gets(parser_state);
+  return lex_gets(parser_state);
 }
 
 VALUE process_parse_tree(rb_parser_state*, VALUE, NODE*, QUID*);
@@ -3122,24 +3120,20 @@ VALUE
 string_to_ast(VALUE ptp, const char *f, bstring s, int line)
 {
   int n;
-  rb_parser_state* parser_state;
   VALUE ret;
-  parser_state = alloc_parser_state();
-  parser_state->lex_string = s;
-  parser_state->lex_gets = lex_get_str;
-  lex_pbeg = 0;
-  lex_p = 0;
-  lex_pend = 0;
-  parser_state->error = Qfalse;
-  parser_state->processor = ptp;
+  rb_parser_state* parser_state = parser_alloc_state();
+
+  lex_string = s;
+  lex_gets = lex_get_str;
+  processor = ptp;
   ruby_sourceline = line - 1;
   compile_for_eval = 1;
 
   n = yycompile(parser_state, (char*)f, line);
 
-  if(parser_state->error == Qfalse) {
-    for(std::vector<bstring>::iterator i = parser_state->magic_comments->begin();
-        i != parser_state->magic_comments->end();
+  if(!parse_error) {
+    for(std::vector<bstring>::iterator i = magic_comments->begin();
+        i != magic_comments->end();
         i++) {
       rb_funcall(ptp, rb_intern("add_magic_comment"), 1,
         rb_str_new((const char*)(*i)->data, (*i)->slen));
@@ -3154,7 +3148,7 @@ string_to_ast(VALUE ptp, const char *f, bstring s, int line)
 }
 
 static bool parse_io_gets(rb_parser_state* parser_state) {
-  if(feof(parser_state->lex_io)) {
+  if(feof(lex_io)) {
     return false;
   }
 
@@ -3162,13 +3156,13 @@ static bool parse_io_gets(rb_parser_state* parser_state) {
     char *ptr, buf[1024];
     int read;
 
-    ptr = fgets(buf, sizeof(buf), parser_state->lex_io);
+    ptr = fgets(buf, sizeof(buf), lex_io);
     if(!ptr) {
       return false;
     }
 
     read = strlen(ptr);
-    bcatblk(parser_state->line_buffer, ptr, read);
+    bcatblk(line_buffer, ptr, read);
 
     /* check whether we read a full line */
     if(!(read == (sizeof(buf) - 1) && ptr[read] != '\n')) {
@@ -3184,30 +3178,26 @@ file_to_ast(VALUE ptp, const char *f, FILE *file, int start)
 {
   int n;
   VALUE ret;
-  rb_parser_state* parser_state;
-  parser_state = alloc_parser_state();
-  parser_state->lex_io = file;
-  parser_state->lex_gets = parse_io_gets;
-  lex_pbeg = 0;
-  lex_p = 0;
-  lex_pend = 0;
-  parser_state->error = Qfalse;
-  parser_state->processor = ptp;
+  rb_parser_state* parser_state = parser_alloc_state();
+
+  lex_io = file;
+  lex_gets = parse_io_gets;
+  processor = ptp;
   ruby_sourceline = start - 1;
 
   n = yycompile(parser_state, (char*)f, start);
 
-  if(parser_state->error == Qfalse) {
-    for(std::vector<bstring>::iterator i = parser_state->magic_comments->begin();
-        i != parser_state->magic_comments->end();
+  if(!parse_error) {
+    for(std::vector<bstring>::iterator i = magic_comments->begin();
+        i != magic_comments->end();
         i++) {
       rb_funcall(ptp, rb_intern("add_magic_comment"), 1,
         rb_str_new((const char*)(*i)->data, (*i)->slen));
     }
       ret = process_parse_tree(parser_state, ptp, top_node, NULL);
 
-      if(parser_state->end_seen && parser_state->lex_io) {
-        rb_funcall(ptp, rb_sData, 1, ULONG2NUM(ftell(parser_state->lex_io)));
+      if(end_seen && lex_io) {
+        rb_funcall(ptp, rb_sData, 1, ULONG2NUM(ftell(lex_io)));
       }
   } else {
     ret = Qnil;
@@ -3246,7 +3236,7 @@ parser_nextc(rb_parser_state* parser_state)
       bstring v;
 
       if(!lex_getline(parser_state)) return -1;
-      v = parser_state->line_buffer;
+      v = line_buffer;
 
       if(heredoc_end > 0) {
         ruby_sourceline = heredoc_end;
@@ -3272,11 +3262,11 @@ parser_nextc(rb_parser_state* parser_state)
   if(c == '\r' && lex_p < lex_pend && *(lex_p) == '\n') {
     lex_p++;
     c = '\n';
-    parser_state->column = 0;
+    column = 0;
   } else if(c == '\n') {
-    parser_state->column = 0;
+    column = 0;
   } else {
-    parser_state->column++;
+    column++;
   }
 
   return c;
@@ -3814,7 +3804,7 @@ parser_tokadd_string(rb_parser_state *parser_state,
 #define NEW_STRTERM(func, term, paren) \
   node_newnode(NODE_STRTERM, (VALUE)(func), \
                (VALUE)((term) | ((paren) << (CHAR_BIT * 2))), NULL)
-#define pslval ((YYSTYPE *)parser_state->lval)
+#define pslval ((YYSTYPE *)lval)
 static int
 parser_parse_string(rb_parser_state* parser_state, NODE *quote)
 {
@@ -4214,7 +4204,7 @@ retry:
     if(char* str = parse_comment(parser_state)) {
         int len = lex_pend - str - 1; // - 1 for the \n
         cur_line = blk2bstr(str, len);
-        parser_state->magic_comments->push_back(cur_line);
+        magic_comments->push_back(cur_line);
     }
     lex_p = lex_pend;
     /* fall through */
@@ -5233,7 +5223,7 @@ retry:
 
   case '_':
     if(was_bol() && whole_match_p("__END__", 7, 0)) {
-      parser_state->end_seen = 1;
+      end_seen = 1;
       return -1;
     }
     newtok();
@@ -5381,15 +5371,15 @@ retry:
 
 #if YYPURE
 static int
-yylex(void *lval, void *p)
+yylex(void *l, void *p)
 #else
 yylex(void *p)
 #endif
 {
   rb_parser_state* parser_state = (rb_parser_state*)p;
 
-  parser_state->lval = lval;
-  ((YYSTYPE*)parser_state->lval)->val = Qundef;
+  lval = l;
+  ((YYSTYPE*)lval)->val = Qundef;
 
   return parser_yylex(parser_state);
 }
@@ -5441,7 +5431,7 @@ static void
 parser_warning(rb_parser_state* parser_state, NODE *node, const char *mesg)
 {
   int line = ruby_sourceline;
-  if(parser_state->emit_warnings) {
+  if(emit_warnings) {
     ruby_sourceline = nd_line(node);
     printf("%s:%li: warning: %s\n", ruby_sourcefile, ruby_sourceline, mesg);
     ruby_sourceline = line;
@@ -5476,7 +5466,7 @@ again:
     break;
   }
 
-  if(parser_state->verbose) {
+  if(verbose) {
     NODE *nd = end->nd_head;
   newline:
     switch(nd_type(nd)) {
@@ -6194,7 +6184,7 @@ parser_void_expr0(rb_parser_state* parser_state, NODE *node)
 {
   const char *useless = NULL;
 
-  if(!parser_state->verbose) return;
+  if(!verbose) return;
 
 again:
   if(!node) return;
@@ -6287,7 +6277,7 @@ again:
 static void
 parser_void_stmts(NODE *node, rb_parser_state* parser_state)
 {
-  if(!parser_state->verbose) return;
+  if(!verbose) return;
   if(!node) return;
   if(nd_type(node) != NODE_BLOCK) return;
 
@@ -6446,7 +6436,7 @@ cond0(NODE *node, rb_parser_state* parser_state)
     if(!e_option_supplied()) {
       int b = literal_node(node->nd_beg);
       int e = literal_node(node->nd_end);
-      if((b == 1 && e == 1) || (b + e >= 2 && parser_state->verbose)) {
+      if((b == 1 && e == 1) || (b + e >= 2 && verbose)) {
       }
     }
     break;
diff --git a/lib/ext/melbourne/internal.hpp b/lib/ext/melbourne/internal.hpp
index 934b46dae5..583fc98978 100644
--- a/lib/ext/melbourne/internal.hpp
+++ b/lib/ext/melbourne/internal.hpp
@@ -111,12 +111,11 @@ namespace melbourne {
     stack_type cmdarg_stack;
 
     void *lval; /* the parser's yylval */
-    VALUE eofp;
+    bool eofp;
 
     std::vector<bstring>* magic_comments;
     int column;
     NODE *top_node;
-    ID *locals;
 
     LocalState* variables;
 
@@ -130,7 +129,7 @@ namespace melbourne {
 
     bool verbose;
 
-    VALUE error;
+    bool parse_error;
     VALUE processor;
 
     // Keeps track of lines that 'end' starters are on, to enable
@@ -148,32 +147,53 @@ namespace melbourne {
 #define PARSER_STATE        ((rb_parser_state*)parser_state)
 #define PARSER_VAR(var)     (PARSER_STATE->var)
 
-#define lex_state           PARSER_VAR(lex_state)
-#define lex_pbeg            PARSER_VAR(lex_pbeg)
-#define lex_p               PARSER_VAR(lex_p)
-#define lex_pend            PARSER_VAR(lex_pend)
-#define lex_lastline        PARSER_VAR(lex_lastline)
-#define lex_nextline        PARSER_VAR(lex_nextline)
+#define end_seen            PARSER_VAR(end_seen)
 #define ruby_debug_lines    PARSER_VAR(debug_lines)
 #define heredoc_end         PARSER_VAR(heredoc_end)
 #define command_start       PARSER_VAR(command_start)
 #define lex_strterm         PARSER_VAR(lex_strterm)
+#define paren_nest          PARSER_VAR(paren_nest)
+#define lpar_beg            PARSER_VAR(lpar_beg)
 #define class_nest          PARSER_VAR(class_nest)
 #define in_single           PARSER_VAR(in_single)
 #define in_def              PARSER_VAR(in_def)
 #define compile_for_eval    PARSER_VAR(compile_for_eval)
 #define cur_mid             PARSER_VAR(cur_mid)
-#define variables           PARSER_VAR(variables)
-#define top_node            PARSER_VAR(top_node)
-#define cmdarg_stack        PARSER_VAR(cmdarg_stack)
-#define cond_stack          PARSER_VAR(cond_stack)
-#define in_defined          PARSER_VAR(in_defined)
-#define paren_nest          PARSER_VAR(paren_nest)
-#define lpar_beg            PARSER_VAR(lpar_beg)
-
 #define tokenbuf            PARSER_VAR(token_buffer)
 #define tokidx              PARSER_VAR(tokidx)
 #define toksiz              PARSER_VAR(toksiz)
+#define emit_warnings       PARSER_VAR(emit_warnings)
+#define lex_gets            PARSER_VAR(lex_gets)
+#define line_buffer         PARSER_VAR(line_buffer)
+#define lex_io              PARSER_VAR(lex_io)
+#define lex_string          PARSER_VAR(lex_string)
+#define lex_lastline        PARSER_VAR(lex_lastline)
+#define lex_nextline        PARSER_VAR(lex_nextline)
+#define lex_pbeg            PARSER_VAR(lex_pbeg)
+#define lex_p               PARSER_VAR(lex_p)
+#define lex_pend            PARSER_VAR(lex_pend)
+#define lex_str_used        PARSER_VAR(lex_str_used)
+#define lex_state           PARSER_VAR(lex_state)
+#define in_defined          PARSER_VAR(in_defined)
+#define cond_stack          PARSER_VAR(cond_stack)
+#define cmdarg_stack        PARSER_VAR(cmdarg_stack)
+#define lval                PARSER_VAR(lval)
+#define eofp                PARSER_VAR(eofp)
+#define magic_comments      PARSER_VAR(magic_comments)
+#define column              PARSER_VAR(column)
+#define top_node            PARSER_VAR(top_node)
+#define variables           PARSER_VAR(variables)
+#define ternary_colon       PARSER_VAR(ternary_colon)
+#define memory_pools        PARSER_VAR(memory_pools)
+#define pool_size           PARSER_VAR(pool_size)
+#define current_pool        PARSER_VAR(current_pool)
+#define memory_cur          PARSER_VAR(memory_cur)
+#define memory_last_addr    PARSER_VAR(memory_last_addr)
+#define memory_size         PARSER_VAR(memory_size)
+#define verbose             PARSER_VAR(verbose)
+#define parse_error         PARSER_VAR(parse_error)
+#define processor           PARSER_VAR(processor)
+#define start_lines         PARSER_VAR(start_lines)
 
 }; // namespace melbourne
 
diff --git a/lib/ext/melbourne/visitor.cpp b/lib/ext/melbourne/visitor.cpp
index d156bcedd2..1ed03a6d9f 100644
--- a/lib/ext/melbourne/visitor.cpp
+++ b/lib/ext/melbourne/visitor.cpp
@@ -22,63 +22,61 @@ namespace melbourne {
     return rb_str_new((const char*)str->data, str->slen);
   }
 
-  rb_parser_state *alloc_parser_state() {
+  rb_parser_state *parser_alloc_state() {
       rb_parser_state *parser_state = (rb_parser_state*)calloc(1, sizeof(rb_parser_state));
 
-      #undef command_start
-      #undef class_nest
-      #undef in_single
-      #undef in_def
-      #undef compile_for_eval
-      #undef cur_mid
-      #undef tokidx
-      #undef toksiz
-      parser_state->command_start = true;
-      parser_state->class_nest = 0;
-      parser_state->in_single = 0;
-      parser_state->in_def = 0;
-      parser_state->compile_for_eval = 0;
-      parser_state->cur_mid = 0;
-      parser_state->token_buffer = NULL;
-      parser_state->tokidx = 0;
-      parser_state->toksiz = 0;
-      parser_state->memory_cur = NULL;
-      parser_state->memory_last_addr = NULL;
-      parser_state->current_pool = 0;
-      parser_state->pool_size = 0;
-      parser_state->memory_size = 204800;
-      parser_state->memory_pools = NULL;
-      parser_state->emit_warnings = 0;
-      parser_state->verbose = RTEST(ruby_verbose);
-      parser_state->magic_comments = new std::vector<bstring>;
-      parser_state->start_lines = new std::list<StartPosition>;
+      lex_pbeg = 0;
+      lex_p = 0;
+      lex_pend = 0;
+      parse_error = false;
+
+      eofp = false;
+      command_start = true;
+      class_nest = 0;
+      in_single = 0;
+      in_def = 0;
+      compile_for_eval = 0;
+      cur_mid = 0;
+      tokenbuf = NULL;
+      tokidx = 0;
+      toksiz = 0;
+      memory_cur = NULL;
+      memory_last_addr = NULL;
+      current_pool = 0;
+      pool_size = 0;
+      memory_size = 204800;
+      memory_pools = NULL;
+      emit_warnings = 0;
+      verbose = RTEST(ruby_verbose);
+      magic_comments = new std::vector<bstring>;
+      start_lines = new std::list<StartPosition>;
 
       return parser_state;
   }
 
   void compile_error(const char *);
 
-  void *pt_allocate(rb_parser_state *st, int size) {
+  void *pt_allocate(rb_parser_state *parser_state, int size) {
     void *cur;
 
-    if(!st->memory_cur || ((st->memory_cur + size) >= st->memory_last_addr)) {
-      if(st->memory_cur) st->current_pool++;
+    if(!memory_cur || ((memory_cur + size) >= memory_last_addr)) {
+      if(memory_cur) current_pool++;
 
-      if(st->current_pool == st->pool_size) {
-        st->pool_size += 10;
-        if(st->memory_pools) {
-          st->memory_pools = (void**)realloc(st->memory_pools, sizeof(void*) * st->pool_size);
+      if(current_pool == pool_size) {
+        pool_size += 10;
+        if(memory_pools) {
+          memory_pools = (void**)realloc(memory_pools, sizeof(void*) * pool_size);
         } else {
-          st->memory_pools = (void**)malloc(sizeof(void*) * st->pool_size);
+          memory_pools = (void**)malloc(sizeof(void*) * pool_size);
         }
       }
-      st->memory_pools[st->current_pool] = malloc(st->memory_size);
-      st->memory_cur = (char*)st->memory_pools[st->current_pool];
-      st->memory_last_addr = st->memory_cur + st->memory_size - 1;
+      memory_pools[current_pool] = malloc(memory_size);
+      memory_cur = (char*)memory_pools[current_pool];
+      memory_last_addr = memory_cur + memory_size - 1;
     }
 
-    cur = (void*)st->memory_cur;
-    st->memory_cur = st->memory_cur + size;
+    cur = (void*)memory_cur;
+    memory_cur = memory_cur + size;
 
     return cur;
   }
@@ -86,32 +84,32 @@ namespace melbourne {
   void pt_free(rb_parser_state *parser_state) {
     int i;
 
-    if(parser_state->line_buffer) {
-      bdestroy(parser_state->line_buffer);
+    if(line_buffer) {
+      bdestroy(line_buffer);
     }
 
     if(lex_lastline) {
       bdestroy(lex_lastline);
     }
 
-    free(parser_state->token_buffer);
+    free(tokenbuf);
     delete variables;
 
-    for(std::vector<bstring>::iterator i = parser_state->magic_comments->begin();
-        i != parser_state->magic_comments->end();
+    for(std::vector<bstring>::iterator i = magic_comments->begin();
+        i != magic_comments->end();
         i++) {
       bdestroy(*i);
     }
 
-    delete parser_state->magic_comments;
-    delete parser_state->start_lines;
+    delete magic_comments;
+    delete start_lines;
 
-    if(!parser_state->memory_pools) return;
+    if(!memory_pools) return;
 
-    for(i = 0; i <= parser_state->current_pool; i++) {
-      free(parser_state->memory_pools[i]);
+    for(i = 0; i <= current_pool; i++) {
+      free(memory_pools[i]);
     }
-    free(parser_state->memory_pools);
+    free(memory_pools);
 
   }
 
@@ -124,8 +122,8 @@ namespace melbourne {
     // Cleanup one of the common and ugly syntax errors.
     if(std::string("syntax error, unexpected $end, expecting kEND") ==
         std::string(msg)) {
-      if(parser_state->start_lines->size() > 0) {
-        StartPosition& pos = parser_state->start_lines->back();
+      if(start_lines->size() > 0) {
+        StartPosition& pos = start_lines->back();
 
         std::stringstream ss;
         ss << "missing 'end' for '"
@@ -158,14 +156,14 @@ namespace melbourne {
 
     int col = lex_p - lex_pbeg;
 
-    rb_funcall(parser_state->processor,
+    rb_funcall(processor,
                rb_intern("process_parse_error"),4,
                err_msg,
                INT2FIX(col),
                INT2FIX(mel_sourceline),
                string_newfrombstr(lex_lastline));
 
-    parser_state->error = Qtrue;
+    parse_error = true;
   }
 
   const char *op_to_name(QUID id);
@@ -190,7 +188,7 @@ namespace melbourne {
   VALUE process_parse_tree(rb_parser_state*, VALUE, NODE*, QUID*);
 
   static VALUE process_dynamic(rb_parser_state *parser_state,
-      VALUE ptp, NODE *node, QUID *locals)
+                               VALUE ptp, NODE *node, QUID *locals)
   {
     VALUE array = rb_ary_new();
 
@@ -204,8 +202,8 @@ namespace melbourne {
     return array;
   }
 
-  static VALUE process_iter(rb_parser_state *parser_state,
-      VALUE ptp, NODE *node, QUID *locals, int *level, ID method, VALUE line)
+  static VALUE process_iter(rb_parser_state *parser_state, VALUE ptp, NODE *node,
+                            QUID *locals, int *level, ID method, VALUE line)
   {
     VALUE iter, body, args;
 
@@ -1067,8 +1065,8 @@ namespace melbourne {
     // Cleanup one of the common and ugly syntax errors.
     if(std::string("syntax error, unexpected $end, expecting kEND") ==
         std::string(msg)) {
-      if(parser_state->start_lines->size() > 0) {
-        StartPosition& pos = parser_state->start_lines->back();
+      if(start_lines->size() > 0) {
+        StartPosition& pos = start_lines->back();
 
         std::stringstream ss;
         ss << "missing 'end' for '"
@@ -1101,14 +1099,14 @@ namespace melbourne {
 
     int col = lex_p - lex_pbeg;
 
-    rb_funcall(parser_state->processor,
+    rb_funcall(processor,
                rb_intern("process_parse_error"),4,
                err_msg,
                INT2FIX(col),
                INT2FIX(mel_sourceline),
                string_newfrombstr(lex_lastline));
 
-    parser_state->error = Qtrue;
+    parse_error = true;
   }
 
   const char *op_to_name(QUID id);
diff --git a/lib/ext/melbourne/visitor.hpp b/lib/ext/melbourne/visitor.hpp
index 7bd3b5a9b9..5d8563fe72 100644
--- a/lib/ext/melbourne/visitor.hpp
+++ b/lib/ext/melbourne/visitor.hpp
@@ -2,7 +2,7 @@
 #define MEL_VISITOR_HPP
 
 namespace melbourne {
-  rb_parser_state *alloc_parser_state();
+  rb_parser_state *parser_alloc_state();
   void *pt_allocate(rb_parser_state *st, int size);
   void pt_free(rb_parser_state *st);