visitor19.cpp

#include <sstream>

#include "melbourne.hpp"
#include "parser_state19.hpp"
#include "visitor19.hpp"
#include "symbols.hpp"

namespace melbourne {
  namespace grammar19 {

  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(ruby_sourceline),
               lex_lastline);

    parse_error = true;
  }

#define nd_3rd    u3.node

  VALUE process_parse_tree(rb_parser_state*, VALUE, NODE*, ID*);

  static VALUE process_dynamic(rb_parser_state *parser_state,
      VALUE ptp, NODE *node, ID *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, ID *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, ID *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);
    }

    // fprintf(stderr, "%s\n", get_node_type_string((enum node_type)nd_type(node)));

    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, ID2SYM(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_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 args = Qnil;

      if(node->nd_1st) {
        args = process_parse_tree(parser_state, ptp, node->nd_1st, locals);
      }

      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: {
      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;

      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, ID2SYM(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, ID2SYM(node->nd_mid), args);
      break;
    }
    case NODE_VCALL:
      tree = rb_funcall(ptp, rb_sVCall, 2, line, ID2SYM(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 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: {
      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(parser_intern("or"));
          break;
        case 1:
          op = ID2SYM(parser_intern("and"));
          break;
        default:
          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, value, op, args);
      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(parser_intern("or"));
          break;
        case 1:
          op = ID2SYM(parser_intern("and"));
          break;
        default:
          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, ID2SYM(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, 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, 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, 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, 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, ID2SYM(node->nd_vid), expr);
      break;
    }
    case NODE_CDECL: {
      VALUE expr;

      if(node->nd_vid) {
        expr = ID2SYM(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,
          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->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;
    }
    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, ID2SYM(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);
      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);
      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);
      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);
      if (node->nd_cflag) flags = INT2FIX(node->nd_cflag);
      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);
      if (node->nd_cflag) flags = INT2FIX(node->nd_cflag);
      tree = rb_funcall(ptp, rb_sDRegxOnce, 4, line, node->nd_lit, array, flags);
      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, ID2SYM(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, 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 = ID2SYM((ID)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 = ID2SYM((ID)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_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);

      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(node->nd_argc > 0) {
        total_args = (int)locals[0];
        args_ary = locals + 1;

        if(post_args && post_args->nd_next && nd_type(post_args->nd_next) == NODE_AND) {
          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;
          }
        }

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

      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 = ID2SYM(aux->nd_rest);
        }
      }
      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;
        }

        post = rb_ary_new();
        for(int i = 0; i < post_args->nd_argc && start + i < total_args; i++) {
          rb_ary_push(post, ID2SYM(args_ary[start + i]));
        }
      }

      tree = rb_funcall(ptp, rb_sArgs, 6, line, args, opts, splat, post, block);
      break;
    }
    case NODE_LVAR:
      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, ID2SYM(node->nd_vid));
      break;

    case NODE_CVAR:
      tree = rb_funcall(ptp, rb_sCVar, 2, line, ID2SYM(node->nd_vid));
      break;

    case NODE_GVAR:
      tree = rb_funcall(ptp, rb_sGVar, 2, line, ID2SYM(node->nd_vid));
      break;

    case NODE_CONST:
      tree = rb_funcall(ptp, rb_sConst, 2, line, ID2SYM(node->nd_vid));
      break;

    case NODE_XSTR:             /* u1    (%x{ls}) */
      tree = rb_funcall(ptp, rb_sXStr, 2, line, node->nd_lit);
      break;

    case NODE_STR:              /* u1 */
      tree = rb_funcall(ptp, rb_sStr, 2, line, node->nd_lit);
      break;

    case NODE_REGEX:
      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, node->nd_lit,
                        INT2FIX(node->nd_cnt));
      break;

    case NODE_LIT:
      tree = rb_funcall(ptp, rb_sLit, 2, line, node->nd_lit);
      break;

    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? */
      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(parser_intern(str)));
      break;
    }

    case NODE_BLOCK_ARG:        /* u1 u3 (def x(&b) */
      tree = rb_funcall(ptp, rb_sBlockArg, 2, line, ID2SYM(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_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);
      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_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, ID2SYM(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_PREEXE: {           /* BEGIN { ... } */
      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 { ... } */
      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));
      tree = rb_funcall(ptp, rb_intern("process_missing_node"), 3,
          line, node_name, node_type);
      break;
      }
    }

    return tree;
  }
  }; // namespace grammar19
};