rubinius-melbourne 1.0.0.8

data/ext/rubinius/melbourne/symbols.hpp

@@ -0,0 +1,119 @@
+#ifndef MEL_SYMBOLS_HPP
+#define MEL_SYMBOLS_HPP
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+namespace MELBOURNE {
+  extern ID rb_sAlias;
+  extern ID rb_sAnd;
+  extern ID rb_sArgs;
+  extern ID rb_sArgsCat;
+  extern ID rb_sArgsPush;
+  extern ID rb_sArray;
+  extern ID rb_sAttrAsgn;
+  extern ID rb_sBackRef;
+  extern ID rb_sBegin;
+  extern ID rb_sBlock;
+  extern ID rb_sBlockArg;
+  extern ID rb_sBlockPass;
+  extern ID rb_sBreak;
+  extern ID rb_sCall;
+  extern ID rb_sCase;
+  extern ID rb_sCDecl;
+  extern ID rb_sClass;
+  extern ID rb_sColon2;
+  extern ID rb_sColon3;
+  extern ID rb_sConst;
+  extern ID rb_sCVar;
+  extern ID rb_sCVAsgn;
+  extern ID rb_sCVDecl;
+  extern ID rb_sData;
+  extern ID rb_sDefined;
+  extern ID rb_sDefn;
+  extern ID rb_sDefs;
+  extern ID rb_sDot2;
+  extern ID rb_sDot3;
+  extern ID rb_sDRegx;
+  extern ID rb_sDRegxOnce;
+  extern ID rb_sDStr;
+  extern ID rb_sDSym;
+  extern ID rb_sDXStr;
+  extern ID rb_sEncoding;
+  extern ID rb_sEnsure;
+  extern ID rb_sEvStr;
+  extern ID rb_sFalse;
+  extern ID rb_sFCall;
+  extern ID rb_sFile;
+  extern ID rb_sFixnum;
+  extern ID rb_sFlip2;
+  extern ID rb_sFlip3;
+  extern ID rb_sFloat;
+  extern ID rb_sFor;
+  extern ID rb_sGAsgn;
+  extern ID rb_sGVar;
+  extern ID rb_sHash;
+  extern ID rb_sIAsgn;
+  extern ID rb_sIf;
+  extern ID rb_sIter;
+  extern ID rb_sIVar;
+  extern ID rb_sLAsgn;
+  extern ID rb_sLambda;
+  extern ID rb_sLit;
+  extern ID rb_sLVar;
+  extern ID rb_sMAsgn;
+  extern ID rb_sMatch;
+  extern ID rb_sMatch2;
+  extern ID rb_sMatch3;
+  extern ID rb_sModule;
+  extern ID rb_sNegate;
+  extern ID rb_sNext;
+  extern ID rb_sNil;
+  extern ID rb_sNot;
+  extern ID rb_sNthRef;
+  extern ID rb_sNumber;
+  extern ID rb_sOpAsgn1;
+  extern ID rb_sOpAsgn2;
+  extern ID rb_sOpAsgnAnd;
+  extern ID rb_sOpAsgnOr;
+  extern ID rb_sOptArg;
+  extern ID rb_sOr;
+  extern ID rb_sPostExe;
+  extern ID rb_sPostArg;
+  extern ID rb_sPreExe;
+  extern ID rb_sRedo;
+  extern ID rb_sRegex;
+  extern ID rb_sResbody;
+  extern ID rb_sRescue;
+  extern ID rb_sRetry;
+  extern ID rb_sReturn;
+  extern ID rb_sSClass;
+  extern ID rb_sScope;
+  extern ID rb_sSelf;
+  extern ID rb_sSplat;
+  extern ID rb_sStr;
+  extern ID rb_sSuper;
+  extern ID rb_sSValue;
+  extern ID rb_sToAry;
+  extern ID rb_sTrue;
+  extern ID rb_sUndef;
+  extern ID rb_sUntil;
+  extern ID rb_sVAlias;
+  extern ID rb_sValues;
+  extern ID rb_sVCall;
+  extern ID rb_sWhen;
+  extern ID rb_sWhile;
+  extern ID rb_sXStr;
+  extern ID rb_sYield;
+  extern ID rb_sZArray;
+  extern ID rb_sZSuper;
+
+  void init_symbols();
+};
+
+#ifdef __cplusplus
+}  /* extern "C" { */
+#endif
+
+#endif

data/ext/rubinius/melbourne/var_table.cpp

@@ -0,0 +1,81 @@
+#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);
+    }
+  }
+
+  var_table var_table_push(var_table cur) {
+    var_table vt = var_table_create();
+    vt->next = cur;
+    return vt;
+  }
+
+  var_table var_table_pop(var_table cur) {
+    var_table nw = NULL;
+
+    if(cur) {
+      delete cur->quarks;
+      nw = cur->next;
+      free(cur);
+    }
+    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;
+    }
+    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;
+    }
+
+    if(tbl->next) {
+      return var_table_find_chained(tbl->next, needle);
+    }
+    return -1;
+  }
+
+  int var_table_add(var_table tbl, const quark item) {
+    tbl->quarks->push_back(item);
+    return (int)tbl->quarks->size();
+  }
+
+  int var_table_size(const var_table tbl)
+  {
+    return (int)tbl->quarks->size();
+  }
+
+  quark var_table_get(const var_table tbl, const int index)
+  {
+    return tbl->quarks->at(index);
+  }
+};

data/ext/rubinius/melbourne/var_table.hpp

@@ -0,0 +1,31 @@
+#ifndef MEL_VAR_TABLE_HPP
+#define MEL_VAR_TABLE_HPP
+
+#include "quark.hpp"
+
+#ifdef __cplusplus
+extern "C" {
+#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);
+};
+
+#ifdef __cplusplus
+}  /* extern "C" { */
+#endif
+
+#endif

data/ext/rubinius/melbourne/visitor.cpp

@@ -0,0 +1,962 @@
+#include <sstream>
+
+#include "namespace.h"
+#include "melbourne.hpp"
+#include "parser_state.hpp"
+#include "visitor.hpp"
+#include "symbols.hpp"
+
+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;
+
+    // Cleanup one of the common and ugly syntax errors.
+    if(std::string("syntax error, unexpected $end, expecting kEND") ==
+        std::string(msg)) {
+      if(start_lines->size() > 0) {
+        StartPosition& pos = start_lines->back();
+
+        std::ostringstream ss;
+        ss << "missing 'end' for '"
+           << pos.kind
+           << "' started on line "
+           << pos.line;
+        err_msg = rb_str_new2(ss.str().c_str());
+
+      } else {
+        err_msg = rb_str_new2("missing 'end' for unknown start");
+      }
+    } else {
+      err_msg = 0;
+
+      std::string pmsg(msg);
+      std::string comma(", ");
+
+      size_t one = pmsg.find(comma);
+      if(one != std::string::npos) {
+        size_t two = pmsg.find(comma, one+1);
+        if(two != std::string::npos) {
+          std::string sub = pmsg.substr(two+2);
+
+          err_msg = rb_str_new2(sub.c_str());
+        }
+      }
+
+      if(!err_msg) err_msg = rb_str_new2(msg);
+    }
+
+    int col = (int)(lex_p - lex_pbeg);
+
+    rb_funcall(processor,
+               rb_intern("process_parse_error"),4,
+               err_msg,
+               INT2FIX(col),
+               INT2FIX(sourceline),
+               string_newfrombstr(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*);
+
+  static VALUE process_dynamic(rb_parser_state *parser_state,
+                               VALUE ptp, NODE *node, QUID *locals)
+  {
+    VALUE array = rb_ary_new();
+
+    while(node) {
+      if (node->nd_head) {
+        rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
+      }
+      node = node->nd_next;
+    }
+
+    return array;
+  }
+
+  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;
+
+    iter = process_parse_tree(parser_state, ptp, node->nd_iter, locals);
+    (*level)++;
+    if (node->nd_var != (NODE *)1
+        && node->nd_var != (NODE *)2
+        && node->nd_var != NULL) {
+      args = process_parse_tree(parser_state, ptp, node->nd_var, locals);
+    } else {
+      if (node->nd_var == NULL) {
+        // e.g. proc {}
+        args = Qnil;
+      } else {
+        // e.g. proc {||}
+        args = INT2FIX(0);
+      }
+    }
+    (*level)--;
+    body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+    return rb_funcall(ptp, method, 4, line, iter, args, body);
+  }
+
+  /* Visits all the nodes in the parse tree.
+   * Adapted from ParseTree by Ryan Davis and Eric Hodel.
+   */
+  VALUE process_parse_tree(rb_parser_state *parser_state,
+      VALUE ptp, NODE *n, QUID *locals)
+  {
+    NODE * volatile node = n;
+
+    static int masgn_level = 0;
+    static unsigned case_level = 0;
+    static unsigned when_level = 0;
+    static unsigned inside_case_args = 0;
+
+    VALUE line, tree = Qnil;
+
+    if(!node) return tree;
+
+    again:
+
+    if(node) {
+      line = INT2FIX(nd_line(node));
+    } else {
+      return rb_funcall(ptp, rb_intern("process_dangling_node"), 0);
+    }
+
+    switch(nd_type(node)) {
+
+    case NODE_BLOCK: {
+      VALUE array = rb_ary_new();
+
+      while (node) {
+        rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
+        node = node->nd_next;
+      }
+      tree = rb_funcall(ptp, rb_sBlock, 2, line, array);
+      break;
+    }
+    case NODE_DEFINED: {
+      VALUE expr = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      tree = rb_funcall(ptp, rb_sDefined, 2, line, expr);
+      break;
+    }
+    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));
+      break;
+    }
+    case NODE_MATCH2: {
+      VALUE pattern = process_parse_tree(parser_state, ptp, node->nd_recv, locals);
+      VALUE value = process_parse_tree(parser_state, ptp, node->nd_value, locals);
+      tree = rb_funcall(ptp, rb_sMatch2, 3, line, pattern, value);
+      break;
+    }
+    case NODE_MATCH3: {
+      VALUE pattern = process_parse_tree(parser_state, ptp, node->nd_recv, locals);
+      VALUE value = process_parse_tree(parser_state, ptp, node->nd_value, locals);
+      tree = rb_funcall(ptp, rb_sMatch3, 3, line, pattern, value);
+      break;
+    }
+    case NODE_BEGIN: {
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      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;
+
+      cond = process_parse_tree(parser_state, ptp, node->nd_cond, locals);
+      if (node->nd_body) {
+        body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      }
+      if (node->nd_else) {
+        else_body = process_parse_tree(parser_state, ptp, node->nd_else, locals);
+      }
+      tree = rb_funcall(ptp, rb_sIf, 4, line, cond, body, else_body);
+      break;
+    }
+    case NODE_CASE: {
+      VALUE expr = Qnil, els = Qnil;
+      NODE* else_node = 0;
+
+      case_level++;
+      if(node->nd_head) {
+        expr = process_parse_tree(parser_state, ptp, node->nd_head, locals); /* expr */
+      }
+
+      VALUE whens = rb_ary_new();
+      node = node->nd_body;
+      while(node) {
+        if (nd_type(node) == NODE_WHEN) {                 /* when */
+          rb_ary_push(whens, process_parse_tree(parser_state, ptp, node, locals));
+          node = node->nd_next;
+        } else {
+          else_node = node;
+          break;                                          /* else */
+        }
+      }
+
+      case_level--;
+
+      // Be sure to decrease the case_level before processing the else.
+      // See http://github.com/rubinius/rubinius/issues#issue/240 for an example of
+      // why.
+      if(else_node) {
+        els = process_parse_tree(parser_state, ptp, else_node, locals);
+      }
+
+      tree = rb_funcall(ptp, rb_sCase, 4, line, expr, whens, els);
+      break;
+    }
+    case NODE_WHEN: {
+      VALUE body = Qnil;
+
+      when_level++;
+      /* when without case, ie, no expr in case */
+      if(!inside_case_args && case_level < when_level) {
+        if(when_level > 0) when_level--;
+        node = NEW_CASE(0, node);
+        goto again;
+      }
+      inside_case_args++;
+      VALUE args = process_parse_tree(parser_state, ptp, node->nd_head, locals); /* args */
+      inside_case_args--;
+
+      if(node->nd_body) {
+        body = process_parse_tree(parser_state, ptp, node->nd_body, locals); /* body */
+      }
+      if(when_level > 0) when_level--;
+
+      tree = rb_funcall(ptp, rb_sWhen, 3, line, args, body);
+      break;
+    }
+    case NODE_WHILE: {
+      VALUE cond, body = Qnil, post_cond;
+
+      cond = process_parse_tree(parser_state, ptp,  node->nd_cond, locals);
+      if(node->nd_body) {
+        body = process_parse_tree(parser_state, ptp,  node->nd_body, locals);
+      }
+      post_cond = node->nd_3rd == 0 ? Qfalse : Qtrue;
+      tree = rb_funcall(ptp, rb_sWhile, 4, line, cond, body, post_cond);
+      break;
+    }
+    case NODE_UNTIL: {
+      VALUE cond, body = Qnil, post_cond;
+
+      cond = process_parse_tree(parser_state, ptp,  node->nd_cond, locals);
+      if(node->nd_body) {
+        body = process_parse_tree(parser_state, ptp,  node->nd_body, locals);
+      }
+      post_cond = node->nd_3rd == 0 ? Qfalse : Qtrue;
+      tree = rb_funcall(ptp, rb_sUntil, 4, line, cond, body, post_cond);
+      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);
+      }
+
+      tree = rb_funcall(ptp, rb_sBlockPass, 3, line, iter, 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);
+      break;
+
+    case NODE_BREAK: {
+      VALUE expr = Qnil;
+
+      if (node->nd_stts) {
+        expr = process_parse_tree(parser_state, ptp, node->nd_stts, locals);
+      }
+      tree = rb_funcall(ptp, rb_sBreak, 2, line, expr);
+      break;
+    }
+    case NODE_NEXT: {
+      VALUE expr = Qnil;
+
+      if (node->nd_stts) {
+        expr = process_parse_tree(parser_state, ptp, node->nd_stts, locals);
+      }
+      tree = rb_funcall(ptp, rb_sNext, 2, line, expr);
+      break;
+    }
+    case NODE_YIELD: {
+      VALUE expr = Qnil;
+
+      if (node->nd_stts) {
+        expr = process_parse_tree(parser_state, ptp, node->nd_stts, locals);
+      }
+      tree = rb_funcall(ptp, rb_sYield, 3, line, expr, node->u3.value);
+      break;
+    }
+    case NODE_RESCUE: {
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_1st, locals);
+      VALUE resc = process_parse_tree(parser_state, ptp, node->nd_2nd, locals);
+      VALUE els = process_parse_tree(parser_state, ptp, node->nd_3rd, locals);
+      tree = rb_funcall(ptp, rb_sRescue, 4, line, body, resc, els);
+      break;
+    }
+    case NODE_RESBODY: {
+      /* rescue body:
+       * begin stmt rescue exception => var; stmt; [rescue e2 => v2; s2;]* end
+       * stmt rescue stmt
+       * a = b rescue c
+       */
+
+      VALUE conditions = Qnil;
+
+      if(node->nd_3rd) {
+        conditions = process_parse_tree(parser_state, ptp, node->nd_3rd, locals);
+      }
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_2nd, locals);
+      VALUE next = process_parse_tree(parser_state, ptp, node->nd_1st, locals);
+      tree = rb_funcall(ptp, rb_sResbody, 4, line, conditions, body, next);
+      break;
+    }
+    case NODE_ENSURE: {
+      VALUE head, ensr = Qnil;
+
+      head = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      if (node->nd_ensr) {
+        ensr = process_parse_tree(parser_state, ptp, node->nd_ensr, locals);
+      }
+      tree = rb_funcall(ptp, rb_sEnsure, 3, line, head, ensr);
+      break;
+    }
+    case NODE_AND: {
+      VALUE left = process_parse_tree(parser_state, ptp, node->nd_1st, locals);
+      VALUE right = process_parse_tree(parser_state, ptp, node->nd_2nd, locals);
+      tree = rb_funcall(ptp, rb_sAnd, 3, line, left, right);
+      break;
+    }
+    case NODE_OR: {
+      VALUE left = process_parse_tree(parser_state, ptp, node->nd_1st, locals);
+      VALUE right = process_parse_tree(parser_state, ptp, node->nd_2nd, locals);
+      tree = rb_funcall(ptp, rb_sOr, 3, line, left, right);
+      break;
+    }
+    case NODE_DOT2: {
+      VALUE start = process_parse_tree(parser_state, ptp, node->nd_beg, locals);
+      VALUE finish = process_parse_tree(parser_state, ptp, node->nd_end, locals);
+      tree = rb_funcall(ptp, rb_sDot2, 3, line, start, finish);
+      break;
+    }
+    case NODE_DOT3: {
+      VALUE start = process_parse_tree(parser_state, ptp, node->nd_beg, locals);
+      VALUE finish = process_parse_tree(parser_state, ptp, node->nd_end, locals);
+      tree = rb_funcall(ptp, rb_sDot3, 3, line, start, finish);
+      break;
+    }
+    case NODE_FLIP2: {
+      VALUE start = process_parse_tree(parser_state, ptp, node->nd_beg, locals);
+      VALUE finish = process_parse_tree(parser_state, ptp, node->nd_end, locals);
+      tree = rb_funcall(ptp, rb_sFlip2, 3, line, start, finish);
+      break;
+    }
+    case NODE_FLIP3: {
+      VALUE start = process_parse_tree(parser_state, ptp, node->nd_beg, locals);
+      VALUE finish = process_parse_tree(parser_state, ptp, node->nd_end, locals);
+      tree = rb_funcall(ptp, rb_sFlip3, 3, line, start, finish);
+      break;
+    }
+    case NODE_RETURN: {
+      VALUE expr = Qnil;
+
+      if (node->nd_stts) {
+        expr = process_parse_tree(parser_state, ptp, node->nd_stts, locals);
+      }
+      tree = rb_funcall(ptp, rb_sReturn, 2, line, expr);
+      break;
+    }
+    case NODE_ARGSCAT: {
+      VALUE array = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      VALUE rest = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      tree = rb_funcall(ptp, rb_sArgsCat, 3, line, array, rest);
+      break;
+    }
+    case NODE_ARGSPUSH: {
+      VALUE head = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      tree = rb_funcall(ptp, rb_sArgsPush, 3, line, head, body);
+      break;
+    }
+    case NODE_CALL: {
+      VALUE args = Qnil;
+
+      VALUE recv = process_parse_tree(parser_state, ptp, node->nd_recv, locals);
+      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);
+      break;
+    }
+    case NODE_FCALL: {
+      VALUE args = Qnil;
+
+      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);
+      break;
+    }
+    case NODE_VCALL:
+      tree = rb_funcall(ptp, rb_sVCall, 2, line, Q2SYM(node->nd_mid));
+      break;
+
+    case NODE_SUPER: {
+      VALUE args = process_parse_tree(parser_state, ptp, node->nd_args, locals);
+      tree = rb_funcall(ptp, rb_sSuper, 2, line, args);
+      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);
+      break;
+    }
+    case NODE_OP_ASGN1: {
+      VALUE op;
+
+      VALUE recv = process_parse_tree(parser_state, ptp, node->nd_recv, locals);
+      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"));
+          break;
+        case 1:
+          op = ID2SYM(rb_intern("and"));
+          break;
+        default:
+          op = Q2SYM(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);
+      break;
+    }
+    case NODE_OP_ASGN2: {
+      VALUE op;
+
+      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"));
+          break;
+        case 1:
+          op = ID2SYM(rb_intern("and"));
+          break;
+        default:
+          op = Q2SYM(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);
+      break;
+    }
+    case NODE_OP_ASGN_AND: {
+      VALUE var = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      VALUE value = process_parse_tree(parser_state, ptp, node->nd_value, locals);
+      tree = rb_funcall(ptp, rb_sOpAsgnAnd, 3, line, var, value);
+      break;
+    }
+    case NODE_OP_ASGN_OR: {
+      VALUE var = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      VALUE value = process_parse_tree(parser_state, ptp, node->nd_value, locals);
+      tree = rb_funcall(ptp, rb_sOpAsgnOr, 3, line, var, value);
+      break;
+    }
+    case NODE_MASGN: {
+      VALUE args = Qnil;
+
+      masgn_level++;
+      VALUE head = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      if (node->nd_args) {
+        if(node->nd_args != (NODE *)-1) {
+          args = process_parse_tree(parser_state, ptp, node->nd_args, locals);
+        } else {
+          args = Qtrue;
+        }
+      }
+      VALUE value = process_parse_tree(parser_state, ptp, node->nd_value, locals);
+      tree = rb_funcall(ptp, rb_sMAsgn, 4, line, head, value, args);
+      masgn_level--;
+      break;
+    }
+    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);
+      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);
+      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);
+      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);
+      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);
+      break;
+    }
+    case NODE_CDECL: {
+      VALUE expr;
+
+      if(node->nd_vid) {
+        expr = Q2SYM(node->nd_vid);
+      } else {
+        expr = process_parse_tree(parser_state, ptp, node->nd_else, locals);
+      }
+      VALUE value = process_parse_tree(parser_state, ptp, node->nd_value, locals);
+      tree = rb_funcall(ptp, rb_sCDecl, 3, line, expr, value);
+      break;
+    }
+    case NODE_VALIAS:           /* u1 u2 (alias $global $global2) */
+      tree = rb_funcall(ptp, rb_sVAlias, 3, line,
+          Q2SYM(node->u2.id), Q2SYM(node->u1.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);
+      tree = rb_funcall(ptp, rb_sAlias, 3, line, to, from);
+      break;
+    }
+    case NODE_UNDEF: {          /* u2    (undef instvar) */
+      VALUE name = process_parse_tree(parser_state, ptp, node->u2.node, locals);
+      tree = rb_funcall(ptp, rb_sUndef, 2, line, name);
+      break;
+    }
+    case NODE_COLON3:           /* u2    (::OUTER_CONST) */
+      tree = rb_funcall(ptp, rb_sColon3, 2, line, Q2SYM(node->u2.id));
+      break;
+
+    case NODE_HASH: {
+      VALUE array = rb_ary_new();
+
+      node = node->nd_head;
+      while (node) {
+        rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
+        if (!(node = node->nd_next)) {
+          // @todo: properly process the parse error
+          printf("odd number list for Hash");
+          abort();
+        }
+        rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
+        node = node->nd_next;
+      }
+      tree = rb_funcall(ptp, rb_sHash, 2, line, array);
+      break;
+    }
+    case NODE_ARRAY: {
+      VALUE array = rb_ary_new();
+
+      while (node) {
+        rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
+        node = node->nd_next;
+      }
+      tree = rb_funcall(ptp, rb_sArray, 2, line, array);
+      break;
+    }
+    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);
+      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);
+      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);
+      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);
+      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);
+      break;
+    }
+    case NODE_DEFN: {
+      VALUE body = Qnil;
+
+      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);
+      break;
+    }
+    case NODE_DEFS: {
+      VALUE recv = Qnil, body = Qnil;
+
+      if (node->nd_defn) {
+        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);
+      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);
+      } else {
+        name = process_parse_tree(parser_state, ptp, node->nd_cpath, locals);
+      }
+      if(node->nd_super) {
+        super = process_parse_tree(parser_state, ptp, node->nd_super, locals);
+      }
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      tree = rb_funcall(ptp, rb_sClass, 4, line, name, super, body);
+      break;
+    }
+    case NODE_MODULE: {
+      VALUE name;
+
+      if (nd_type(node->nd_cpath) == NODE_COLON2 && !node->nd_cpath->nd_vid) {
+        name = Q2SYM((QUID)node->nd_cpath->nd_mid);
+      } else {
+        name = process_parse_tree(parser_state, ptp, node->nd_cpath, locals);
+      }
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      tree = rb_funcall(ptp, rb_sModule, 3, line, name, body);
+      break;
+    }
+    case NODE_SCLASS: {
+      VALUE recv = process_parse_tree(parser_state, ptp, node->nd_recv, locals);
+      VALUE body = process_parse_tree(parser_state, ptp, node->nd_body, locals);
+      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;
+
+      /* push regular argument names */
+      for (; i < max_args; i++) {
+        rb_ary_push(args, Q2SYM(locals[i + 3]));
+      }
+
+      /* 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));
+        }
+        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]);
+        } else {
+          splat = Qtrue;
+        }
+      } 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);
+      }
+
+      VALUE opt = Qnil;
+      optnode = node->nd_opt;
+      if (optnode) {
+        opt = process_parse_tree(parser_state, ptp, node->nd_opt, locals);
+      }
+      masgn_level--;
+
+      tree = rb_funcall(ptp, rb_sArgs, 4, line, args, opt, splat);
+      break;
+    }
+    case NODE_LVAR:
+      tree = rb_funcall(ptp, rb_sLVar, 2, line, Q2SYM(node->nd_vid));
+      break;
+
+    case NODE_IVAR:
+      tree = rb_funcall(ptp, rb_sIVar, 2, line, Q2SYM(node->nd_vid));
+      break;
+
+    case NODE_CVAR:
+      tree = rb_funcall(ptp, rb_sCVar, 2, line, Q2SYM(node->nd_vid));
+      break;
+
+    case NODE_GVAR:
+      tree = rb_funcall(ptp, rb_sGVar, 2, line, Q2SYM(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));
+      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);
+      break;
+
+    case NODE_STR:              /* u1 */
+      tree = rb_funcall(ptp, rb_sStr, 2, line,
+          string_newfrombstr(node->nd_str));
+      bdestroy(node->nd_str);
+      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);
+      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);
+      break;
+
+    case NODE_LIT:
+      tree = rb_funcall(ptp, rb_sLit, 2, line, Q2SYM((uintptr_t)node->nd_lit));
+      break;
+
+    case NODE_NEWLINE:
+      node = node->nd_next;
+      goto again;
+      break;
+
+    case NODE_NTH_REF:          /* u2 u3 ($1) - u3 is local_cnt('~') ignorable? */
+      tree = rb_funcall(ptp, rb_sNthRef, 2, line, INT2FIX(node->nd_nth));
+      break;
+
+    case NODE_BACK_REF: {        /* u2 u3 ($& etc) */
+      char str[2];
+      str[0] = node->nd_nth;
+      str[1] = 0;
+      tree = rb_funcall(ptp, rb_sBackRef, 2, line, ID2SYM(rb_intern(str)));
+      break;
+    }
+
+    case NODE_BLOCK_ARG:        /* u1 u3 (def x(&b) */
+      tree = rb_funcall(ptp, rb_sBlockArg, 2, line, Q2SYM(node->u1.id));
+      break;
+
+    case NODE_RETRY:
+      tree = rb_funcall(ptp, rb_sRetry, 1, line);
+      break;
+
+    case NODE_FALSE:
+      tree = rb_funcall(ptp, rb_sFalse, 1, line);
+      break;
+
+    case NODE_NIL:
+      tree = rb_funcall(ptp, rb_sNil, 1, line);
+      break;
+
+    case NODE_SELF:
+      tree = rb_funcall(ptp, rb_sSelf, 1, line);
+      break;
+
+    case NODE_TRUE:
+      tree = rb_funcall(ptp, rb_sTrue, 1, line);
+      break;
+
+    case NODE_ZARRAY:
+      tree = rb_funcall(ptp, rb_sZArray, 1, line);
+      break;
+
+    case NODE_ZSUPER:
+      tree = rb_funcall(ptp, rb_sZSuper, 1, line);
+      break;
+
+    case NODE_REDO:
+      tree = rb_funcall(ptp, rb_sRedo, 1, line);
+      break;
+
+    case NODE_FILE:
+      tree = rb_funcall(ptp, rb_sFile, 1, line);
+      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);
+      break;
+    }
+    case NODE_TO_ARY: {
+      VALUE expr = process_parse_tree(parser_state, ptp, node->nd_head, locals);
+      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;
+
+      /* node id node */
+      if (node->nd_1st == RNODE(1)) {
+        recv = process_parse_tree(parser_state, ptp, NEW_SELF(), locals);
+      } else {
+        recv = process_parse_tree(parser_state, ptp, node->nd_1st, locals);
+      }
+      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);
+      break;
+    }
+    case NODE_EVSTR: {
+      VALUE value = process_parse_tree(parser_state, ptp, node->nd_2nd, locals);
+      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);
+      break;
+    }
+    case NODE_POSTEXE:            /* END { ... } */
+      tree = rb_funcall(ptp, rb_sPostExe, 1, line);
+      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));
+      tree = rb_funcall(ptp, rb_intern("process_missing_node"), 3,
+          line, node_name, node_type);
+      break;
+      }
+    }
+
+    return tree;
+  }
+};