rubinius-melbourne 1.2.1.0 → 2.0.0.17

data/ext/rubinius/melbourne/parser_state.hpp

@@ -4,7 +4,8 @@
 #include "namespace.h"
 #include "node.hpp"
 #include "node_types.hpp"
-#include "local_state.hpp"
+#include "var_table.hpp"
+#include "encoding_compat.hpp"
 
 #include <vector>
 #include <list>
@@ -13,14 +14,17 @@ namespace MELBOURNE {
 
   enum lex_state_e {
     EXPR_BEG,       /* ignore newline, +/- is a sign. */
-    EXPR_END,       /* newline significant, +/- is a operator. */
-    EXPR_ARG,       /* newline significant, +/- is a operator. */
-    EXPR_CMDARG,    /* newline significant, +/- is a operator. */
-    EXPR_ENDARG,    /* newline significant, +/- is a operator. */
-    EXPR_MID,       /* newline significant, +/- is a operator. */
+    EXPR_END,       /* newline significant, +/- is an operator. */
+    EXPR_ENDARG,    /* ditto, and unbound braces. */
+    EXPR_ENDFN,     /* ditto, and unbound braces. */
+    EXPR_ARG,       /* newline significant, +/- is an operator. */
+    EXPR_CMDARG,    /* newline significant, +/- is an operator. */
+    EXPR_MID,       /* newline significant, +/- is an operator. */
     EXPR_FNAME,     /* ignore newline, no reserved words. */
     EXPR_DOT,       /* right after `.' or `::', no reserved words. */
     EXPR_CLASS,     /* immediate after `class', no here document. */
+    EXPR_VALUE,     /* like EXPR_BEG but label is disallowed. */
+    EXPR_MAX_STATE
   };
 
 typedef VALUE stack_type;
@@ -36,7 +40,7 @@ typedef VALUE stack_type;
   };
 
   typedef struct rb_parser_state {
-    int end_seen;
+    int ruby__end__seen;
     int debug_lines;
     int heredoc_end;
     int command_start;
@@ -58,15 +62,20 @@ typedef VALUE stack_type;
     /* this function reads a line from lex_io and stores it in
      * line_buffer.
      */
-    bool (*lex_gets)(rb_parser_state*);
-    bstring line_buffer;
+    VALUE (*lex_gets)(rb_parser_state*, VALUE);
 
     /* If this is set, we use the io method. */
-    FILE *lex_io;
+    int lex_io;
+    char* lex_io_buf;
+    ssize_t lex_io_index;
+    ssize_t lex_io_total;
+    long lex_io_count;
+
     /* Otherwise, we use this. */
-    bstring lex_string;
-    bstring lex_lastline;
-    bstring lex_nextline;
+    long lex_gets_ptr;
+    VALUE lex_input;
+    VALUE lex_lastline;
+    VALUE lex_nextline;
 
     char *lex_pbeg;
     char *lex_p;
@@ -81,11 +90,10 @@ typedef VALUE stack_type;
     void *lval; /* the parser's yylval */
     bool eofp;
 
-    std::vector<bstring>* magic_comments;
     int column;
     NODE *top_node;
 
-    LocalState* variables;
+    struct local_vars* locals_table;
 
     int ternary_colon;
 
@@ -98,20 +106,26 @@ typedef VALUE stack_type;
     bool verbose;
 
     bool parse_error;
-    VALUE processor;
 
-    char *sourcefile;
-    int sourceline;
+    // Reference to the object to call methods on to convert the
+    // C parse tree into a Ruby AST.
+    VALUE processor;
 
-    const unsigned char* re_mbctab;
+    // Keep track of any object literals created in the parser.
+    VALUE references;
 
     // Keeps track of lines that 'end' starters are on, to enable
     // better error reporting.
     std::list<StartPosition>* start_lines;
 
-    // Tracks quarks
-    quark_map* quark_indexes;
-    quark_vector* quarks;
+    int line_count;
+    bool has_shebang;
+
+    char *sourcefile;
+    int sourceline;
+
+    rb_encoding *enc;
+    rb_encoding *utf8;
   } rb_parser_state;
 
 
@@ -138,8 +152,12 @@ typedef VALUE stack_type;
 #define lex_gets            PARSER_VAR(lex_gets)
 #define line_buffer         PARSER_VAR(line_buffer)
 #define line_count          PARSER_VAR(line_count)
+#define has_shebang         PARSER_VAR(has_shebang)
 #define lex_io              PARSER_VAR(lex_io)
-#define lex_string          PARSER_VAR(lex_string)
+#define lex_io_buf          PARSER_VAR(lex_io_buf)
+#define lex_io_index        PARSER_VAR(lex_io_index)
+#define lex_io_total        PARSER_VAR(lex_io_total)
+#define lex_io_count        PARSER_VAR(lex_io_count)
 #define lex_gets_ptr        PARSER_VAR(lex_gets_ptr)
 #define lex_input           PARSER_VAR(lex_input)
 #define lex_lastline        PARSER_VAR(lex_lastline)
@@ -154,10 +172,9 @@ typedef VALUE stack_type;
 #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 locals_table        PARSER_VAR(locals_table)
 #define ternary_colon       PARSER_VAR(ternary_colon)
 #define memory_pools        PARSER_VAR(memory_pools)
 #define pool_size           PARSER_VAR(pool_size)
@@ -168,20 +185,63 @@ typedef VALUE stack_type;
 #define verbose             PARSER_VAR(verbose)
 #define parse_error         PARSER_VAR(parse_error)
 #define processor           PARSER_VAR(processor)
+#define references          PARSER_VAR(references)
 #define start_lines         PARSER_VAR(start_lines)
 #define sourcefile          PARSER_VAR(sourcefile)
 #define sourceline          PARSER_VAR(sourceline)
-#define re_mbctab           PARSER_VAR(re_mbctab)
-#define quark_indexes       PARSER_VAR(quark_indexes)
-#define quarks              PARSER_VAR(quarks)
 
-#undef ismbchar
-#define ismbchar(c)         re_mbctab[(unsigned char)(c)]
-#define mbclen(c)           (re_mbctab[(unsigned char)(c)]+1)
+#define node_newnode(t, a, b, c)  \
+  parser_node_newnode((rb_parser_state*)parser_state, t, a, b, c)
+#define node_add_reference(obj)   \
+  parser_add_reference((rb_parser_state*)parser_state, obj)
+
+  NODE *parser_node_newnode(rb_parser_state*, enum node_type, VALUE, VALUE, VALUE);
+  VALUE parser_add_reference(rb_parser_state* parser_state, VALUE obj);
+
+#undef ID_SCOPE_SHIFT
+#undef ID_SCOPE_MASK
+#undef ID_LOCAL
+#undef ID_INSTANCE
+#undef ID_GLOBAL
+#undef ID_ATTRSET
+#undef ID_CONST
+#undef ID_CLASS
+#undef ID_JUNK
+#undef ID_INTERNAL
+
+  ID parser_intern(const char*);
+  ID parser_intern2(const char*, long);
+  ID parser_intern3(const char*, long, rb_encoding*);
+  ID parser_intern_str(VALUE);
+  char* parser_id2name(ID);
+
+#undef ID2SYM
+
+/* ID_SCOPE_SHIFT must be at least 4 because at 3 the values will overlap
+* the values of the tokens, causing the parser to mistake the symbol for
+* '*' with the token tAREF. Hilarity ensues when Fixnum * Fixnum ends up
+* parsed as Fixnum[Fixnum].
+*/
+#define ID_SCOPE_SHIFT  7
+#define ID_SCOPE_MASK   0x0f
+#define ID_LOCAL        0x00
+#define ID_INSTANCE     0x01
+#define ID_GLOBAL       0x03
+#define ID_ATTRSET      0x04
+#define ID_CONST        0x05
+#define ID_CLASS        0x06
+#define ID_JUNK         0x07
+#define ID_INTERNAL     ID_JUNK
+
+#ifdef RUBINIUS
+#undef SYMBOL_FLAG
+#define ID2SYM(id)  (VALUE)((long)(id >> ID_SCOPE_SHIFT))
+#else
+#define ID2SYM(id)  ((VALUE)(((long)(id >> ID_SCOPE_SHIFT))<<8|SYMBOL_FLAG))
+#endif
 
-#define node_newnode(t, a, b, c)  parser_node_newnode((rb_parser_state*)parser_state, t, a, b, c)
+#define INTERNAL_ID_P(a)  ((a & ID_INTERNAL) == ID_INTERNAL)
 
-  quark id_to_quark(rb_parser_state* parser_state, QUID id);
 };
 
 #endif

data/ext/rubinius/melbourne/var_table.cpp

@@ -1,81 +1,76 @@
-#include <vector>
-#include <stdlib.h>
-#include <assert.h>
-
 #include "namespace.h"
 #include "melbourne.hpp"
 #include "var_table.hpp"
 
 namespace MELBOURNE {
-
-  struct var_table_t {
-    struct var_table_t *next;
-    std::vector<quark> *quarks;
-  };
-
-  var_table var_table_create() {
-    var_table vt = ALLOC(struct var_table_t);
-    vt->quarks = new std::vector<quark>();
-    vt->next = NULL;
-    return vt;
-  }
-
-  void var_table_destroy(var_table vt) {
-    while (vt) {
-      var_table cur = vt;
-      delete cur->quarks;
-      vt = vt->next;
-      free(cur);
+  int vtable_size(const struct vtable* tbl) {
+    if(tbl) {
+      return tbl->pos;
+    } else {
+      return 0;
     }
   }
 
-  var_table var_table_push(var_table cur) {
-    var_table vt = var_table_create();
-    vt->next = cur;
-    return vt;
+  struct vtable* vtable_alloc(struct vtable *prev) {
+    struct vtable *tbl = ALLOC(struct vtable);
+    tbl->pos = 0;
+    tbl->capa = 8;
+    tbl->tbl = ALLOC_N(ID, tbl->capa);
+    tbl->prev = prev;
+    return tbl;
   }
 
-  var_table var_table_pop(var_table cur) {
-    var_table nw = NULL;
-
-    if(cur) {
-      delete cur->quarks;
-      nw = cur->next;
-      free(cur);
+  void vtable_free(struct vtable* tbl) {
+    if(tbl) {
+      if(tbl->tbl) {
+        xfree(tbl->tbl);
+      }
+      xfree(tbl);
     }
-    return nw;
   }
 
-  int var_table_find(const var_table tbl, const quark needle) {
-    for(size_t i = 0; i < tbl->quarks->size(); i++) {
-      if(tbl->quarks->at(i) == needle) return (int)i;
+  void vtable_free_all(struct vtable* tbl) {
+    if(tbl) {
+      if(tbl->tbl) {
+        xfree(tbl->tbl);
+      }
+      if(tbl->prev) {
+        vtable_free_all(tbl->prev);
+      }
+      xfree(tbl);
     }
-    return -1;
   }
 
-  int var_table_find_chained(const var_table tbl, const quark needle) {
-    for(size_t i = 0; i < tbl->quarks->size(); i++) {
-      if(tbl->quarks->at(i) == needle) return (int)i;
+  void vtable_add(struct vtable* tbl, ID id) {
+    if(!tbl) {
+      rb_bug("vtable_add: vtable is not allocated (%p)", (void *)tbl);
     }
 
-    if(tbl->next) {
-      return var_table_find_chained(tbl->next, needle);
+    if(tbl->pos == tbl->capa) {
+      tbl->capa = tbl->capa * 2;
+      REALLOC_N(tbl->tbl, ID, tbl->capa);
     }
-    return -1;
-  }
-
-  int var_table_add(var_table tbl, const quark item) {
-    tbl->quarks->push_back(item);
-    return (int)tbl->quarks->size();
+    tbl->tbl[tbl->pos++] = id;
   }
 
-  int var_table_size(const var_table tbl)
-  {
-    return (int)tbl->quarks->size();
+  bool vtable_included(const struct vtable* tbl, ID id) {
+    if(tbl) {
+      for(int i = 0; i < tbl->pos; i++) {
+        if(tbl->tbl[i] == id) {
+          return true;
+        }
+      }
+    }
+    return false;
   }
 
-  quark var_table_get(const var_table tbl, const int index)
-  {
-    return tbl->quarks->at(index);
+  void local_vars_free(struct local_vars* vars) {
+    struct local_vars* prev;
+    for(struct local_vars* local = vars; local; local = prev) {
+      if(local->args) vtable_free_all(local->args);
+      if(local->vars) vtable_free_all(local->vars);
+      prev = local->prev;
+      xfree(local);
+    }
   }
 };

data/ext/rubinius/melbourne/var_table.hpp

@@ -1,31 +1,34 @@
 #ifndef MEL_VAR_TABLE_HPP
 #define MEL_VAR_TABLE_HPP
 
-#include "quark.hpp"
-
-#ifdef __cplusplus
-extern "C" {
+// We must use MRI's xfree for ALLOC'd memory.
+#ifdef RUBINIUS
+#undef xfree
+#define xfree free
 #endif
 
-
 namespace MELBOURNE {
-  struct var_table_t;
-  typedef struct var_table_t *var_table;
-
-  var_table var_table_create();
-  void var_table_destroy(var_table vt);
-  var_table var_table_push(var_table cur);
-  var_table var_table_pop(var_table cur);
-  int var_table_find(const var_table tbl, const quark needle);
-  int var_table_find_chained(const var_table tbl, const quark needle);
-
-  int var_table_add(var_table tbl, const quark item);
-  int var_table_size(const var_table tbl);
-  quark var_table_get(const var_table tbl, const int index);
+  struct vtable {
+    ID *tbl;
+    int pos;
+    int capa;
+    struct vtable *prev;
+  };
+
+  struct local_vars {
+    struct vtable *args;
+    struct vtable *vars;
+    struct local_vars *prev;
+  };
+
+  int vtable_size(const struct vtable* tbl);
+  struct vtable* vtable_alloc(struct vtable *prev);
+  void vtable_free(struct vtable* tbl);
+  void vtable_free_all(struct vtable* tbl);
+  void vtable_add(struct vtable* tbl, ID id);
+  bool vtable_included(const struct vtable* tbl, ID id);
+
+  void local_vars_free(struct local_vars* vars);
 };
 
-#ifdef __cplusplus
-}  /* extern "C" { */
-#endif
-
 #endif

data/ext/rubinius/melbourne/visitor.cpp

@@ -8,15 +8,6 @@
 
 namespace MELBOURNE {
 
-  static VALUE string_newfrombstr(bstring str)
-  {
-    if(str == NULL) {
-      return rb_str_new2("");
-    }
-
-    return rb_str_new((const char*)str->data, str->slen);
-  }
-
   void create_error(rb_parser_state *parser_state, char *msg) {
     VALUE err_msg;
 
@@ -62,34 +53,17 @@ namespace MELBOURNE {
                err_msg,
                INT2FIX(col),
                INT2FIX(sourceline),
-               string_newfrombstr(lex_lastline));
+               lex_lastline);
 
     parse_error = true;
   }
 
-  const char *op_to_name(rb_parser_state* parser_state, QUID id);
-
-
-  static VALUE quark_to_symbol(rb_parser_state* parser_state, quark quark) {
-    const char *op;
-    if((op = op_to_name(parser_state, quark)) ||
-       (op = quark_to_string(parser_state, id_to_quark(parser_state, quark)))) {
-      return ID2SYM(rb_intern(op));
-    } else {
-      fprintf(stderr,
-              "unable to retrieve string from parser symbol(quark: %#zx, id: %#zx)\n",
-              quark, id_to_quark(parser_state, quark));
-      abort();
-    }
-  }
-
 #define nd_3rd    u3.node
-#define Q2SYM(v)  quark_to_symbol(parser_state, v)
 
-  VALUE process_parse_tree(rb_parser_state*, VALUE, NODE*, QUID*);
+  VALUE process_parse_tree(rb_parser_state*, VALUE, NODE*, ID*);
 
   static VALUE process_dynamic(rb_parser_state *parser_state,
-                               VALUE ptp, NODE *node, QUID *locals)
+      VALUE ptp, NODE *node, ID *locals)
   {
     VALUE array = rb_ary_new();
 
@@ -103,8 +77,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, ID *locals, int *level, ID method, VALUE line)
   {
     VALUE iter, body, args;
 
@@ -132,7 +106,7 @@ namespace MELBOURNE {
    * Adapted from ParseTree by Ryan Davis and Eric Hodel.
    */
   VALUE process_parse_tree(rb_parser_state *parser_state,
-      VALUE ptp, NODE *n, QUID *locals)
+      VALUE ptp, NODE *n, ID *locals)
   {
     NODE * volatile node = n;
 
@@ -153,6 +127,8 @@ namespace MELBOURNE {
       return rb_funcall(ptp, rb_intern("process_dangling_node"), 0);
     }
 
+    // fprintf(stderr, "%s\n", get_node_type_string((enum node_type)nd_type(node)));
+
     switch(nd_type(node)) {
 
     case NODE_BLOCK: {
@@ -173,7 +149,7 @@ namespace MELBOURNE {
     case NODE_COLON2: {
       VALUE container = process_parse_tree(parser_state, ptp, node->nd_head, locals);
       tree = rb_funcall(ptp, rb_sColon2, 3, line,
-          container, Q2SYM(node->nd_mid));
+          container, ID2SYM(node->nd_mid));
       break;
     }
     case NODE_MATCH2: {
@@ -193,11 +169,6 @@ namespace MELBOURNE {
       tree = rb_funcall(ptp, rb_sBegin, 2, line, body);
       break;
     }
-    case NODE_NOT: {
-      VALUE expr = process_parse_tree(parser_state, ptp, node->nd_body, locals);
-      tree = rb_funcall(ptp, rb_sNot, 2, line, expr);
-      break;
-    }
     case NODE_IF: {
       VALUE cond, body = Qnil, else_body = Qnil;
 
@@ -289,23 +260,32 @@ namespace MELBOURNE {
       break;
     }
     case NODE_BLOCK_PASS: {
-      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
-      VALUE iter = Qnil;
-      if(node->nd_iter != (NODE*)1) {
-        iter = process_parse_tree(parser_state, ptp, node->nd_iter, locals);
+      VALUE args = Qnil;
+
+      if(node->nd_1st) {
+        args = process_parse_tree(parser_state, ptp, node->nd_1st, locals);
       }
 
-      tree = rb_funcall(ptp, rb_sBlockPass, 3, line, iter, body);
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+
+      tree = rb_funcall(ptp, rb_sBlockPass, 3, line, args, body);
       break;
     }
     case NODE_FOR:
       tree = process_iter(parser_state, ptp, node, locals, &masgn_level, rb_sFor, line);
       break;
 
-    case NODE_ITER:
-      tree = process_iter(parser_state, ptp, node, locals, &masgn_level, rb_sIter, line);
+    case NODE_ITER: {
+      VALUE iter = process_parse_tree(parser_state, ptp, node->nd_iter, locals);
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      tree = rb_funcall(ptp, rb_sIter, 3, line, iter, body);
       break;
-
+    }
+    case NODE_LAMBDA: {
+      VALUE scope = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      tree = rb_funcall(ptp, rb_sLambda, 2, line, scope);
+      break;
+    }
     case NODE_BREAK: {
       VALUE expr = Qnil;
 
@@ -431,8 +411,7 @@ namespace MELBOURNE {
       if (node->nd_args) {
         args = process_parse_tree(parser_state, ptp, node->nd_args, locals);
       }
-      tree = rb_funcall(ptp, rb_sCall, 4, line,
-          recv, Q2SYM(node->nd_mid), args);
+      tree = rb_funcall(ptp, rb_sCall, 4, line, recv, ID2SYM(node->nd_mid), args);
       break;
     }
     case NODE_FCALL: {
@@ -441,11 +420,11 @@ namespace MELBOURNE {
       if (node->nd_args) {
         args = process_parse_tree(parser_state, ptp, node->nd_args, locals);
       }
-      tree = rb_funcall(ptp, rb_sFCall, 3, line, Q2SYM(node->nd_mid), args);
+      tree = rb_funcall(ptp, rb_sFCall, 3, line, ID2SYM(node->nd_mid), args);
       break;
     }
     case NODE_VCALL:
-      tree = rb_funcall(ptp, rb_sVCall, 2, line, Q2SYM(node->nd_mid));
+      tree = rb_funcall(ptp, rb_sVCall, 2, line, ID2SYM(node->nd_mid));
       break;
 
     case NODE_SUPER: {
@@ -454,8 +433,19 @@ namespace MELBOURNE {
       break;
     }
     case NODE_SCOPE: {
-      VALUE body = process_parse_tree(parser_state, ptp, node->nd_next, node->nd_tbl);
-      tree = rb_funcall(ptp, rb_sScope, 2, line, body);
+      VALUE args = Qnil;
+      VALUE bv_locals = Qnil;
+
+      if(node->nd_args) {
+        if(nd_type(node->nd_args) == NODE_ARGS_AUX) {
+          args = process_parse_tree(parser_state, ptp, node->nd_args->nd_1st, node->nd_tbl);
+          bv_locals = process_parse_tree(parser_state, ptp, node->nd_args->nd_2nd, node->nd_tbl);
+        } else {
+          args = process_parse_tree(parser_state, ptp, node->nd_args, node->nd_tbl);
+        }
+      }
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, node->nd_tbl);
+      tree = rb_funcall(ptp, rb_sScope, 4, line, args, body, bv_locals);
       break;
     }
     case NODE_OP_ASGN1: {
@@ -465,16 +455,16 @@ namespace MELBOURNE {
       VALUE args = process_parse_tree(parser_state, ptp, node->nd_args->nd_2nd, locals);
       switch(node->nd_mid) {
         case 0:
-          op = ID2SYM(rb_intern("or"));
+          op = ID2SYM(parser_intern("or"));
           break;
         case 1:
-          op = ID2SYM(rb_intern("and"));
+          op = ID2SYM(parser_intern("and"));
           break;
         default:
-          op = Q2SYM(node->nd_mid);
+          op = ID2SYM(node->nd_mid);
       }
       VALUE value = process_parse_tree(parser_state, ptp, node->nd_args->nd_head, locals);
-      tree = rb_funcall(ptp, rb_sOpAsgn1, 5, line, recv, args, op, value);
+      tree = rb_funcall(ptp, rb_sOpAsgn1, 5, line, recv, value, op, args);
       break;
     }
     case NODE_OP_ASGN2: {
@@ -483,17 +473,17 @@ namespace MELBOURNE {
       VALUE recv = process_parse_tree(parser_state, ptp, node->nd_recv, locals);
       switch(node->nd_next->nd_mid) {
         case 0:
-          op = ID2SYM(rb_intern("or"));
+          op = ID2SYM(parser_intern("or"));
           break;
         case 1:
-          op = ID2SYM(rb_intern("and"));
+          op = ID2SYM(parser_intern("and"));
           break;
         default:
-          op = Q2SYM(node->nd_next->nd_mid);
+          op = ID2SYM(node->nd_next->nd_mid);
       }
       VALUE value = process_parse_tree(parser_state, ptp, node->nd_value, locals);
       tree = rb_funcall(ptp, rb_sOpAsgn2, 5, line,
-          recv, Q2SYM(node->nd_next->nd_aid), op, value);
+          recv, ID2SYM(node->nd_next->nd_aid), op, value);
       break;
     }
     case NODE_OP_ASGN_AND: {
@@ -527,34 +517,34 @@ namespace MELBOURNE {
     }
     case NODE_LASGN: {
       VALUE expr = process_parse_tree(parser_state, ptp, node->nd_value, locals);
-      tree = rb_funcall(ptp, rb_sLAsgn, 3, line, Q2SYM(node->nd_vid), expr);
+      tree = rb_funcall(ptp, rb_sLAsgn, 3, line, ID2SYM(node->nd_vid), expr);
       break;
     }
     case NODE_IASGN: {
       VALUE expr = process_parse_tree(parser_state, ptp, node->nd_value, locals);
-      tree = rb_funcall(ptp, rb_sIAsgn, 3, line, Q2SYM(node->nd_vid), expr);
+      tree = rb_funcall(ptp, rb_sIAsgn, 3, line, ID2SYM(node->nd_vid), expr);
       break;
     }
     case NODE_CVASGN: {
       VALUE expr = process_parse_tree(parser_state, ptp, node->nd_value, locals);
-      tree = rb_funcall(ptp, rb_sCVAsgn, 3, line, Q2SYM(node->nd_vid), expr);
+      tree = rb_funcall(ptp, rb_sCVAsgn, 3, line, ID2SYM(node->nd_vid), expr);
       break;
     }
     case NODE_CVDECL: {
       VALUE expr = process_parse_tree(parser_state, ptp, node->nd_value, locals);
-      tree = rb_funcall(ptp, rb_sCVDecl, 3, line, Q2SYM(node->nd_vid), expr);
+      tree = rb_funcall(ptp, rb_sCVDecl, 3, line, ID2SYM(node->nd_vid), expr);
       break;
     }
     case NODE_GASGN: {
       VALUE expr = process_parse_tree(parser_state, ptp, node->nd_value, locals);
-      tree = rb_funcall(ptp, rb_sGAsgn, 3, line, Q2SYM(node->nd_vid), expr);
+      tree = rb_funcall(ptp, rb_sGAsgn, 3, line, ID2SYM(node->nd_vid), expr);
       break;
     }
     case NODE_CDECL: {
       VALUE expr;
 
       if(node->nd_vid) {
-        expr = Q2SYM(node->nd_vid);
+        expr = ID2SYM(node->nd_vid);
       } else {
         expr = process_parse_tree(parser_state, ptp, node->nd_else, locals);
       }
@@ -564,12 +554,12 @@ namespace MELBOURNE {
     }
     case NODE_VALIAS:           /* u1 u2 (alias $global $global2) */
       tree = rb_funcall(ptp, rb_sVAlias, 3, line,
-          Q2SYM(node->u2.id), Q2SYM(node->u1.id));
+          ID2SYM(node->u1.id), ID2SYM(node->u2.id));
       break;
 
     case NODE_ALIAS: {          /* u1 u2 (alias :blah :blah2) */
-      VALUE to = process_parse_tree(parser_state, ptp, node->u2.node, locals);
-      VALUE from = process_parse_tree(parser_state, ptp, node->u1.node, locals);
+      VALUE to = process_parse_tree(parser_state, ptp, node->u1.node, locals);
+      VALUE from = process_parse_tree(parser_state, ptp, node->u2.node, locals);
       tree = rb_funcall(ptp, rb_sAlias, 3, line, to, from);
       break;
     }
@@ -579,7 +569,7 @@ namespace MELBOURNE {
       break;
     }
     case NODE_COLON3:           /* u2    (::OUTER_CONST) */
-      tree = rb_funcall(ptp, rb_sColon3, 2, line, Q2SYM(node->u2.id));
+      tree = rb_funcall(ptp, rb_sColon3, 2, line, ID2SYM(node->u2.id));
       break;
 
     case NODE_HASH: {
@@ -611,43 +601,33 @@ namespace MELBOURNE {
     }
     case NODE_DSTR: {
       VALUE array = process_dynamic(parser_state, ptp, node->nd_next, locals);
-      VALUE str = string_newfrombstr(node->nd_str);
-      tree = rb_funcall(ptp, rb_sDStr, 3, line, str, array);
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sDStr, 3, line, node->nd_lit, array);
       break;
     }
     case NODE_DSYM: {
       VALUE array = process_dynamic(parser_state, ptp, node->nd_next, locals);
-      VALUE str = string_newfrombstr(node->nd_str);
-      tree = rb_funcall(ptp, rb_sDSym, 3, line, str, array);
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sDSym, 3, line, node->nd_lit, array);
       break;
     }
     case NODE_DXSTR: {
       VALUE array = process_dynamic(parser_state, ptp, node->nd_next, locals);
-      VALUE str = string_newfrombstr(node->nd_str);
-      tree = rb_funcall(ptp, rb_sDXStr, 3, line, str, array);
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sDXStr, 3, line, node->nd_lit, array);
       break;
     }
     case NODE_DREGX: {
       VALUE flags = Qnil;
 
       VALUE array = process_dynamic(parser_state, ptp, node->nd_next, locals);
-      VALUE str = string_newfrombstr(node->nd_str);
       if (node->nd_cflag) flags = INT2FIX(node->nd_cflag);
-      tree = rb_funcall(ptp, rb_sDRegx, 4, line, str, array, flags);
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sDRegx, 4, line, node->nd_lit, array, flags);
       break;
     }
     case NODE_DREGX_ONCE: {
       VALUE flags = Qnil;
 
       VALUE array = process_dynamic(parser_state, ptp, node->nd_next, locals);
-      VALUE str = string_newfrombstr(node->nd_str);
       if (node->nd_cflag) flags = INT2FIX(node->nd_cflag);
-      tree = rb_funcall(ptp, rb_sDRegxOnce, 4, line, str, array, flags);
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sDRegxOnce, 4, line, node->nd_lit, array, flags);
       break;
     }
     case NODE_DEFN: {
@@ -656,7 +636,7 @@ namespace MELBOURNE {
       if (node->nd_defn) {
         body = process_parse_tree(parser_state, ptp, node->nd_defn, locals);
       }
-      tree = rb_funcall(ptp, rb_sDefn, 3, line, Q2SYM(node->nd_mid), body);
+      tree = rb_funcall(ptp, rb_sDefn, 3, line, ID2SYM(node->nd_mid), body);
       break;
     }
     case NODE_DEFS: {
@@ -666,14 +646,14 @@ namespace MELBOURNE {
         recv = process_parse_tree(parser_state, ptp, node->nd_recv, locals);
         body = process_parse_tree(parser_state, ptp, node->nd_defn, locals);
       }
-      tree = rb_funcall(ptp, rb_sDefs, 4, line, recv, Q2SYM(node->nd_mid), body);
+      tree = rb_funcall(ptp, rb_sDefs, 4, line, recv, ID2SYM(node->nd_mid), body);
       break;
     }
     case NODE_CLASS: {
       VALUE name, super = Qnil;
 
       if (nd_type(node->nd_cpath) == NODE_COLON2 && !node->nd_cpath->nd_vid) {
-        name = Q2SYM((QUID)node->nd_cpath->nd_mid);
+        name = ID2SYM((ID)node->nd_cpath->nd_mid);
       } else {
         name = process_parse_tree(parser_state, ptp, node->nd_cpath, locals);
       }
@@ -688,7 +668,7 @@ namespace MELBOURNE {
       VALUE name;
 
       if (nd_type(node->nd_cpath) == NODE_COLON2 && !node->nd_cpath->nd_vid) {
-        name = Q2SYM((QUID)node->nd_cpath->nd_mid);
+        name = ID2SYM((ID)node->nd_cpath->nd_mid);
       } else {
         name = process_parse_tree(parser_state, ptp, node->nd_cpath, locals);
       }
@@ -702,151 +682,185 @@ namespace MELBOURNE {
       tree = rb_funcall(ptp, rb_sSClass, 3, line, recv, body);
       break;
     }
-    case NODE_ARGS: {
-      VALUE splat = Qnil, args = rb_ary_new();
-      NODE *optnode;
-      int i = 0, max_args = (int)node->nd_cnt;
+    case NODE_OPT_ARG: {
+      VALUE args = rb_ary_new();
+
+      do {
+        rb_ary_push(args, process_parse_tree(parser_state, ptp, node->nd_body, locals));
+        node = node->nd_next;
+      } while(node);
 
-      /* push regular argument names */
-      for (; i < max_args; i++) {
-        rb_ary_push(args, Q2SYM(locals[i + 3]));
+      tree = rb_funcall(ptp, rb_sOptArg, 2, line, args);
+      break;
+    }
+    case NODE_ARGS: {
+      VALUE args = Qnil;
+      VALUE opts = Qnil;
+      VALUE splat = Qnil;
+      VALUE post = Qnil;
+      VALUE block = Qnil;
+
+      int total_args = 0;
+      ID* args_ary = 0;
+
+      NODE* aux = node->nd_args;
+      NODE* post_args = aux->nd_next;
+      NODE* masgn = 0;
+      NODE* next = 0;
+
+      if(post_args && post_args->nd_next && nd_type(post_args->nd_next) == NODE_AND) {
+        if(post_args->nd_next->nd_head) {
+          if (nd_type(post_args->nd_next->nd_head) == NODE_BLOCK) {
+            masgn = post_args->nd_next->nd_head->nd_head;
+            next = post_args->nd_next->nd_head->nd_next;
+          } else {
+            masgn = post_args->nd_next->nd_head;
+            next = masgn->nd_next;
+            // -1 comes from: mlhs_head tSTAR
+            if(masgn->nd_cnt == -1) next = 0;
+          }
+        } else {
+          masgn = post_args->nd_next->nd_2nd;
+          if(masgn) {
+            next = masgn->nd_next;
+            if (nd_type(masgn) == NODE_BLOCK) {
+              masgn = masgn->nd_head;
+            }
+          }
+        }
       }
 
-      /* look for optional arguments: we cannot assume these
-       * are left-to-right what the locals array contains
-       * (e.g. def(a=1, b=2, c=lambda {|n| n } will have 'n'
-       * at i (above) + 2 + 3); instead we walk the chain
-       * and look at the actual LASGN nodes
-       */
-      masgn_level++;
-      optnode = node->nd_opt;
-      while (optnode) {
-        if(nd_type(optnode) == NODE_LASGN) {
-          rb_ary_push(args, Q2SYM(optnode->nd_vid));
-        } else if(nd_type(optnode) == NODE_BLOCK
-                  && nd_type(optnode->nd_head) == NODE_LASGN) {
-          rb_ary_push(args, Q2SYM(optnode->nd_head->nd_vid));
+      if(node->nd_argc > 0) {
+        total_args = (int)locals[0];
+        args_ary = locals + 1;
+
+        args = rb_ary_new();
+        for(int i = 0; i < node->nd_argc && i < total_args; i++) {
+          VALUE arg = Qnil;
+
+          if(!INTERNAL_ID_P(args_ary[i])) {
+            arg = ID2SYM(args_ary[i]);
+          } else if(masgn) {
+            arg = process_parse_tree(parser_state, ptp, masgn, locals);
+            if(next && nd_type(next) == NODE_BLOCK) {
+              masgn = next->nd_head;
+              next = next->nd_next;
+            } else {
+              masgn = next;
+              if(masgn) next = masgn->nd_next;
+            }
+          }
+
+          rb_ary_push(args, arg);
         }
-        i++;  // do not use here but keep track for '*args' name below
-        optnode = optnode->nd_next;
       }
 
-      /* look for vargs */
-      long arg_count = (long)node->nd_rest;
-      if (arg_count > 0) {
-        /* *arg name */
-        if (locals[i + 3]) {
-          splat = quark_to_symbol(parser_state, locals[i + 3]);
+      if(node->nd_opt) {
+        opts = process_parse_tree(parser_state, ptp, node->nd_opt, locals);
+      }
+
+      if(INTERNAL_ID_P(aux->nd_rest)) {
+        splat = Qtrue;
+      } else if(aux->nd_rest) {
+        if(aux->nd_rest == 1) {
+          // m { |a,| ... }
+          splat = Qfalse;
         } else {
-          splat = Qtrue;
+          splat = ID2SYM(aux->nd_rest);
         }
-      } else if (arg_count == 0) {
-        /* nothing to do in this case, empty list */
-      } else if (arg_count == -1) {
-        /* nothing to do in this case, handled above */
-      } else if (arg_count == -2) {
-        /* nothing to do in this case, no name == no use */
-        splat = Qtrue;
-      } else {
-        // HACK: replace with Exception::argument_error()
-        printf("Unknown arg_count %ld encountered while processing args.\n", arg_count);
       }
+      if(aux->nd_mid) block = ID2SYM(aux->nd_mid);
+
+      if(post_args && post_args->nd_pid) {
+        total_args = (int)locals[0];
+        args_ary = locals + 1;
+
+        int start;
+        for(start = 0; start < total_args; start++) {
+          if(args_ary[start] == post_args->nd_pid)
+            break;
+        }
 
-      VALUE opt = Qnil;
-      optnode = node->nd_opt;
-      if (optnode) {
-        opt = process_parse_tree(parser_state, ptp, node->nd_opt, locals);
+        post = rb_ary_new();
+        for(int i = 0; i < post_args->nd_argc && start + i < total_args; i++) {
+          VALUE arg = Qnil;
+
+          if(!INTERNAL_ID_P(args_ary[start + i])) {
+            arg = ID2SYM(args_ary[start + i]);
+          } else if(masgn) {
+            arg = process_parse_tree(parser_state, ptp, masgn, locals);
+            if(next && nd_type(next) == NODE_BLOCK) {
+              masgn = next->nd_head;
+              next = next->nd_next;
+            } else {
+              masgn = next;
+              if(masgn) next = masgn->nd_next;
+            }
+          }
+          rb_ary_push(post, arg);
+        }
       }
-      masgn_level--;
 
-      tree = rb_funcall(ptp, rb_sArgs, 4, line, args, opt, splat);
+      tree = rb_funcall(ptp, rb_sArgs, 6, line, args, opts, splat, post, block);
       break;
     }
     case NODE_LVAR:
-      tree = rb_funcall(ptp, rb_sLVar, 2, line, Q2SYM(node->nd_vid));
+      if(!INTERNAL_ID_P(node->nd_vid)) {
+        tree = rb_funcall(ptp, rb_sLVar, 2, line, ID2SYM(node->nd_vid));
+      }
       break;
 
     case NODE_IVAR:
-      tree = rb_funcall(ptp, rb_sIVar, 2, line, Q2SYM(node->nd_vid));
+      tree = rb_funcall(ptp, rb_sIVar, 2, line, ID2SYM(node->nd_vid));
       break;
 
     case NODE_CVAR:
-      tree = rb_funcall(ptp, rb_sCVar, 2, line, Q2SYM(node->nd_vid));
+      tree = rb_funcall(ptp, rb_sCVar, 2, line, ID2SYM(node->nd_vid));
       break;
 
     case NODE_GVAR:
-      tree = rb_funcall(ptp, rb_sGVar, 2, line, Q2SYM(node->nd_vid));
+      tree = rb_funcall(ptp, rb_sGVar, 2, line, ID2SYM(node->nd_vid));
       break;
 
     case NODE_CONST:
-      tree = rb_funcall(ptp, rb_sConst, 2, line, Q2SYM(node->nd_vid));
-      break;
-
-    case NODE_FIXNUM:
-      tree = rb_funcall(ptp, rb_sFixnum, 2, line, INT2FIX(node->nd_cnt));
+      tree = rb_funcall(ptp, rb_sConst, 2, line, ID2SYM(node->nd_vid));
       break;
 
-    case NODE_NUMBER:
-      tree = rb_funcall(ptp, rb_sNumber, 3, line, INT2FIX(0),
-          string_newfrombstr(node->nd_str));
-      bdestroy(node->nd_str);
-      break;
-
-    case NODE_HEXNUM:
-      tree = rb_funcall(ptp, rb_sNumber, 3, line, INT2FIX(16),
-          string_newfrombstr(node->nd_str));
-      bdestroy(node->nd_str);
-      break;
-
-    case NODE_BINNUM:
-      tree = rb_funcall(ptp, rb_sNumber, 3, line, INT2FIX(2),
-          string_newfrombstr(node->nd_str));
-      bdestroy(node->nd_str);
-      break;
-
-    case NODE_OCTNUM:
-      tree = rb_funcall(ptp, rb_sNumber, 3, line, INT2FIX(8),
-          string_newfrombstr(node->nd_str));
-      bdestroy(node->nd_str);
-    break;
-
-    case NODE_FLOAT:
-      tree = rb_funcall(ptp, rb_sFloat, 2, line,
-          string_newfrombstr(node->nd_str));
-      bdestroy(node->nd_str);
-    break;
-
     case NODE_XSTR:             /* u1    (%x{ls}) */
-      tree = rb_funcall(ptp, rb_sXStr, 2, line,
-          string_newfrombstr(node->nd_str));
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sXStr, 2, line, node->nd_lit);
       break;
 
     case NODE_STR:              /* u1 */
-      tree = rb_funcall(ptp, rb_sStr, 2, line,
-          string_newfrombstr(node->nd_str));
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sStr, 2, line, node->nd_lit);
       break;
 
     case NODE_REGEX:
-      tree = rb_funcall(ptp, rb_sRegex, 3, line,
-          string_newfrombstr(node->nd_str), INT2FIX(node->nd_cnt));
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sRegex, 3, line, node->nd_lit,
+                        INT2FIX(node->nd_cnt));
       break;
 
     case NODE_MATCH:
-      tree = rb_funcall(ptp, rb_sMatch, 3, line,
-          string_newfrombstr(node->nd_str), INT2FIX(node->nd_cnt));
-      bdestroy(node->nd_str);
+      tree = rb_funcall(ptp, rb_sMatch, 3, line, node->nd_lit,
+                        INT2FIX(node->nd_cnt));
       break;
 
     case NODE_LIT:
-      tree = rb_funcall(ptp, rb_sLit, 2, line, Q2SYM((uintptr_t)node->nd_lit));
+      tree = rb_funcall(ptp, rb_sLit, 2, line, node->nd_lit);
       break;
 
-    case NODE_NEWLINE:
-      node = node->nd_next;
-      goto again;
+    case NODE_VALUES: {
+      VALUE first = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      VALUE rest = process_parse_tree(parser_state, ptp, node->nd_args, locals);
+      tree = rb_funcall(ptp, rb_sValues, 3, line, first, rest);
+      break;
+    }
+
+    case NODE_NUMBER:
+      tree = rb_funcall(ptp, rb_sNumber, 2, line, node->nd_lit);
+      break;
+
+    case NODE_FLOAT:
+      tree = rb_funcall(ptp, rb_sFloat, 2, line, node->nd_lit);
       break;
 
     case NODE_NTH_REF:          /* u2 u3 ($1) - u3 is local_cnt('~') ignorable? */
@@ -857,12 +871,12 @@ namespace MELBOURNE {
       char str[2];
       str[0] = node->nd_nth;
       str[1] = 0;
-      tree = rb_funcall(ptp, rb_sBackRef, 2, line, ID2SYM(rb_intern(str)));
+      tree = rb_funcall(ptp, rb_sBackRef, 2, line, ID2SYM(parser_intern(str)));
       break;
     }
 
     case NODE_BLOCK_ARG:        /* u1 u3 (def x(&b) */
-      tree = rb_funcall(ptp, rb_sBlockArg, 2, line, Q2SYM(node->u1.id));
+      tree = rb_funcall(ptp, rb_sBlockArg, 2, line, ID2SYM(node->u1.id));
       break;
 
     case NODE_RETRY:
@@ -901,6 +915,10 @@ namespace MELBOURNE {
       tree = rb_funcall(ptp, rb_sFile, 1, line);
       break;
 
+    case NODE_ENCODING:
+      tree = rb_funcall(ptp, rb_sEncoding, 2, line, node->nd_lit);
+      break;
+
     case NODE_SPLAT: {
       VALUE expr = process_parse_tree(parser_state, ptp, node->nd_head, locals);
       tree = rb_funcall(ptp, rb_sSplat, 2, line, expr);
@@ -911,11 +929,6 @@ namespace MELBOURNE {
       tree = rb_funcall(ptp, rb_sToAry, 2, line, expr);
       break;
     }
-    case NODE_SVALUE: {           /* a = b, c */
-      VALUE expr = process_parse_tree(parser_state, ptp, node->nd_head, locals);
-      tree = rb_funcall(ptp, rb_sSValue, 2, line, expr);
-      break;
-    }
     case NODE_ATTRASGN: {         /* literal.meth = y u1 u2 u3 */
       VALUE recv;
 
@@ -927,7 +940,7 @@ namespace MELBOURNE {
       }
       VALUE value = process_parse_tree(parser_state, ptp, node->nd_3rd, locals);
       tree = rb_funcall(ptp, rb_sAttrAsgn, 4, line,
-          recv, Q2SYM(node->u2.id), value);
+          recv, ID2SYM(node->u2.id), value);
       break;
     }
     case NODE_EVSTR: {
@@ -935,19 +948,27 @@ namespace MELBOURNE {
       tree = rb_funcall(ptp, rb_sEvStr, 2, line, value);
       break;
     }
-    case NODE_NEGATE: {
-      VALUE expr = process_parse_tree(parser_state, ptp, node->nd_head, locals);
-      tree = rb_funcall(ptp, rb_sNegate, 2, line, expr);
-      break;
-    }
     case NODE_PREEXE: {           /* BEGIN { ... } */
-      tree = rb_funcall(ptp, rb_sPreExe, 1, line);
+      VALUE scope = process_parse_tree(parser_state, ptp, node->nd_2nd, locals);
+      tree = rb_funcall(ptp, rb_sPreExe, 2, line, scope);
       break;
     }
-    case NODE_POSTEXE:            /* END { ... } */
-      tree = rb_funcall(ptp, rb_sPostExe, 1, line);
+    case NODE_POSTEXE: {          /* END { ... } */
+      VALUE scope = process_parse_tree(parser_state, ptp, node->nd_2nd, locals);
+      tree = rb_funcall(ptp, rb_sPostExe, 2, line, scope);
       break;
+    }
+    case NODE_POSTARG: {
+      VALUE into = Qnil;
+      if(node->nd_1st != RNODE(-1)) {
+        into = process_parse_tree(parser_state, ptp, node->nd_1st, locals);
+      }
+
+      VALUE rest = process_parse_tree(parser_state, ptp, node->nd_2nd, locals);
 
+      tree = rb_funcall(ptp, rb_sPostArg, 3, line, into, rest);
+      break;
+    }
     default: {
       VALUE node_name = rb_str_new2(get_node_type_string((enum node_type)nd_type(node)));
       VALUE node_type = INT2FIX(nd_type(node));