﻿/*
 *  TOPPERS/ECNL Prototyping tool
 *
 *  Copyright (C) 2017 Cores Co., Ltd. Japan
 *
 *  上記著作権者は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
 *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
 *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
 *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
 *      と．
 *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
 *        報告すること．
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
 *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
 *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
 *      免責すること．
 *
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
 *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
 *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
 *  の責任を負わない．
 *
 *  @(#) $Id$
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Bridge;
using Bridge.Html5;

namespace WebMrbc
{
	public interface IMrbParser
	{
		int lineno { get; set; }
		int column { get; set; }
		string filename { get; }
		string sym2name(mrb_sym sym);
		mrb_sym[] locals_node();
		void yyError(string message, params object[] expected);
	}

	public enum node_type
	{
		NODE_METHOD = 1,
		NODE_FBODY,
		NODE_CFUNC,
		NODE_SCOPE,
		NODE_BLOCK,
		NODE_IF,
		NODE_CASE,
		NODE_WHEN,
		NODE_OPT_N,
		NODE_WHILE,
		NODE_UNTIL,
		NODE_ITER,
		NODE_FOR,
		NODE_BREAK,
		NODE_NEXT,
		NODE_REDO,
		NODE_RETRY,
		NODE_BEGIN,
		NODE_RESCUE,
		NODE_ENSURE,
		NODE_AND,
		NODE_OR,
		NODE_NOT,
		NODE_MASGN,
		NODE_ASGN,
		NODE_CDECL,
		NODE_CVASGN,
		NODE_CVDECL,
		NODE_OP_ASGN,
		NODE_CALL,
		NODE_SCALL,
		NODE_FCALL,
		NODE_VCALL,
		NODE_SUPER,
		NODE_ZSUPER,
		NODE_ARRAY,
		NODE_ZARRAY,
		NODE_HASH,
		NODE_RETURN,
		NODE_YIELD,
		NODE_LVAR,
		NODE_DVAR,
		NODE_GVAR,
		NODE_IVAR,
		NODE_CONST,
		NODE_CVAR,
		NODE_NTH_REF,
		NODE_BACK_REF,
		NODE_MATCH,
		NODE_MATCH2,
		NODE_MATCH3,
		NODE_INT,
		NODE_FLOAT,
		NODE_NEGATE,
		NODE_LAMBDA,
		NODE_SYM,
		NODE_STR,
		NODE_DSTR,
		NODE_XSTR,
		NODE_DXSTR,
		NODE_REGX,
		NODE_DREGX,
		NODE_DREGX_ONCE,
		NODE_LIST,
		NODE_ARG,
		NODE_ARGSCAT,
		NODE_ARGSPUSH,
		NODE_SPLAT,
		NODE_TO_ARY,
		NODE_SVALUE,
		NODE_BLOCK_ARG,
		NODE_DEF,
		NODE_SDEF,
		NODE_ALIAS,
		NODE_UNDEF,
		NODE_CLASS,
		NODE_MODULE,
		NODE_SCLASS,
		NODE_COLON2,
		NODE_COLON3,
		NODE_CREF,
		NODE_DOT2,
		NODE_DOT3,
		NODE_FLIP2,
		NODE_FLIP3,
		NODE_ATTRSET,
		NODE_SELF,
		NODE_NIL,
		NODE_TRUE,
		NODE_FALSE,
		NODE_DEFINED,
		NODE_NEWLINE,
		NODE_POSTEXE,
		NODE_ALLOCA,
		NODE_DMETHOD,
		NODE_BMETHOD,
		NODE_MEMO,
		NODE_IFUNC,
		NODE_DSYM,
		NODE_ATTRASGN,
		NODE_HEREDOC,
		NODE_LITERAL_DELIM,
		NODE_WORDS,
		NODE_SYMBOLS,
		NODE_LAST
	}

	/* lexer states */
	public enum mrb_lex_state_enum
	{
		EXPR_BEG,                   /* ignore newline, +/- is a sign. */
		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,                 /* alike EXPR_BEG but label is disallowed. */
		EXPR_MAX_STATE
	}

	public enum mrb_sym { }

	public enum stack_type { }

	[Flags]
	enum mrb_string_type
	{
		STR_FUNC_PARSING = 0x01,
		STR_FUNC_EXPAND = 0x02,
		STR_FUNC_REGEXP = 0x04,
		STR_FUNC_WORD = 0x08,
		STR_FUNC_SYMBOL = 0x10,
		STR_FUNC_ARRAY = 0x20,
		STR_FUNC_HEREDOC = 0x40,
		STR_FUNC_XQUOTE = 0x80,

		str_not_parsing = (0),
		str_squote = (STR_FUNC_PARSING),
		str_dquote = (STR_FUNC_PARSING | STR_FUNC_EXPAND),
		str_regexp = (STR_FUNC_PARSING | STR_FUNC_REGEXP | STR_FUNC_EXPAND),
		str_sword = (STR_FUNC_PARSING | STR_FUNC_WORD | STR_FUNC_ARRAY),
		str_dword = (STR_FUNC_PARSING | STR_FUNC_WORD | STR_FUNC_ARRAY | STR_FUNC_EXPAND),
		str_ssym = (STR_FUNC_PARSING | STR_FUNC_SYMBOL),
		str_ssymbols = (STR_FUNC_PARSING | STR_FUNC_SYMBOL | STR_FUNC_ARRAY),
		str_dsymbols = (STR_FUNC_PARSING | STR_FUNC_SYMBOL | STR_FUNC_ARRAY | STR_FUNC_EXPAND),
		str_heredoc = (STR_FUNC_PARSING | STR_FUNC_HEREDOC),
		str_xquote = (STR_FUNC_PARSING | STR_FUNC_XQUOTE | STR_FUNC_EXPAND),
	}

	class parser_heredoc_info
	{
		public bool allow_indent;
		public bool line_head;
		public mrb_string_type type;
		public Uint8Array term;
		public int term_len;
		public node[] doc = new node[0];

		public string GetString()
		{
			var sb = new StringBuilder();

			foreach (var str in doc) {
				if (str is str_node) {
					sb.Append(MrbParser.UTF8ArrayToString(((str_node)str).str, 0));
				}
				else if (str is begin_node) {
					foreach (var p in ((begin_node)str).progs) {
						if (p is str_node) {
							sb.Append(MrbParser.UTF8ArrayToString(((str_node)p).str, 0));
						}
						else if (p is heredoc_node) {
							sb.Append(((heredoc_node)p).info.GetString());
						}
						else if (p is call_node) {

						}
						else {
							throw new NotImplementedException();
						}
					}
				}
				else {
					throw new NotImplementedException();
				}
			}

			return sb.ToString();
		}

		public override string ToString()
		{
			return $"{term} {GetString()}";
		}

		internal void push_doc(node str)
		{
			doc.Push(str);
		}

		internal void claer_doc()
		{
			doc.Splice(0, doc.Length);
		}

		internal void to_ruby(ruby_code_cond cond)
		{
			cond.write_line("<<" + MrbParser.UTF8ArrayToString(term, 0));
			foreach (var d in doc) {
				if (d is begin_node) {
					cond.write("#{");
					d.to_ruby(cond);
					cond.write("}");
				}
				else {
					d.to_ruby(cond);
				}
			}
			cond.write_line();
			cond.write_line(MrbParser.UTF8ArrayToString(term, 0));
		}
	}

	public class xml_code_cond
	{
		public xml_code_cond()
		{
		}

		internal Element CreateElement(string tagname)
		{
			return Document.CreateElement(tagname);
		}

		internal Node CreateTextNode(string text)
		{
			return Document.CreateTextNode(text);
		}
	}

	public class ruby_code_cond
	{
		public string newline_str { get; private set; }
		public string indent_str { get; set; }
		public string indent { get; private set; }
		public int nest { get; private set; }

		bool first;
		bool space;
		StringBuilder _code = new StringBuilder();
		public string filename { get; private set; }
		public int lineno { get; private set; }
		public int column { get; private set; }

		public ruby_code_cond(string filename, string indent_str = "  ")
		{
			this.filename = filename;
			lineno = 1;
			column = 0;
			this.indent_str = indent_str;
			indent = "";
			newline_str = "\r\n";
			first = true;
			space = false;
		}

		public void increment_indent()
		{
			indent += indent_str;
			if (!first) {
				new_line();
				first = true;
				space = false;
			}
		}

		private void new_line()
		{
			_code.Append(newline_str);
			lineno++;
			column = 0;
		}

		private void write_code(string code)
		{
			_code.Append(code);
			column += code.Length;
		}

		public void decrement_indent()
		{
			indent = indent.Substring(0, indent.Length - indent_str.Length);
			if (!first) {
				new_line();
				first = true;
				space = false;
			}
		}

		public void increment_nest()
		{
			nest++;
		}

		public void decrement_nest()
		{
			nest--;
			System.Diagnostics.Debug.Assert(nest >= 0);
		}

		public void write(string code)
		{
			if (first) {
				first = false;
				write_code(indent);
			}
			write_code(code);
			space = code.EndsWith(" ");
		}

		public void write_line(string code = null)
		{
			if (nest != 0 && !first && !space) {
				write_code(" ");
				space = true;
			}
			if (code != null) {
				if (first) {
					first = false;
					write_code(indent);
				}
				write_code(code);
				space = code.EndsWith(" ");
			}
			if (nest == 0) {
				new_line();
				space = false;
				first = true;
			}
		}

		internal void separate_line()
		{
			if (!first) {
				new_line();
				first = true;
			}
		}

		public node[] nodes = new node[0];

		public void add_node(node node)
		{
			nodes.Push(node);
		}

		public override string ToString()
		{
			return _code.ToString();
		}
	}

	public class node
	{
		object _car;
		object _cdr;

		public IMrbParser p { get; private set; }
		public object car {
			get { return _car; }
			set {
				System.Diagnostics.Debug.Assert(GetType() == typeof(node));
				_car = value;
			}
		}
		public object cdr {
			get { return _cdr; }
			set {
				System.Diagnostics.Debug.Assert(GetType() == typeof(node));
				_cdr = value;
			}
		}
		public int lineno { get; private set; }
		public int column { get; private set; }
		public string filename { get; private set; }
		public string block_id;

		protected node(IMrbParser p, node_type car)
		{
			this.p = p;
			_car = car;
			lineno = p.lineno;
			column = p.column;
			filename = p.filename;
		}

		public override string ToString()
		{
			if (cdr == null)
				return $"({car})";
			return $"({car}, {cdr})";
		}

		public void SET_LINENO(int n) { lineno = n; }

		public void NODE_LINENO(node n)
		{
			if (n != null) {
				filename = n.filename;
				lineno = n.lineno;
				column = n.column;
			}
		}

		public static node cons(IMrbParser p, object car, object cdr)
		{
			var result = new node(p, 0);
			result.car = car;
			result.cdr = cdr;
			return result;
		}

		public virtual void append(node b)
		{
			node c = this;
			while (c.cdr != null) {
				c = (node)c.cdr;
			}
			if (b != null) {
				c.cdr = b;
			}
		}

		public static void dump_recur<T>(T[] list, node tree)
		{
			while (tree != null) {
				list.Push((T)tree.car);
				tree = (node)tree.cdr;
			}
		}

		public virtual Element to_xml(xml_code_cond cond)
		{
			var a = car as node;
			if (a != null && cdr == null) {
				return a.to_xml(cond);
			}

			throw new NotImplementedException();
		}

		public int start_lineno { get; private set; }
		public int start_column { get; private set; }

		public void to_ruby(ruby_code_cond cond)
		{
			filename = cond.filename;
			start_lineno = cond.lineno;
			start_column = cond.column;

			to_rb(cond);

			lineno = cond.lineno;
			column = cond.column;

			cond.add_node(this);
		}

		protected virtual void to_rb(ruby_code_cond cond)
		{
			var a = car as node;
			while (a != null) {
				a.to_ruby(cond);
				a = a.cdr as node;
			}
		}
	}

	public class locals_node
	{
		public mrb_sym[] symList = new mrb_sym[0];
		public locals_node cdr;

		public locals_node(locals_node cdr)
		{
			this.cdr = cdr;
		}

		internal void push(mrb_sym sym)
		{
			symList.Push(sym);
		}
	}

	/* (:scope (vars..) (prog...)) */
	class scope_node : node
	{
		private mrb_sym[] _local_variables = new mrb_sym[0];
		private node _body;

		public scope_node(IMrbParser p, node body)
			: base(p, node_type.NODE_SCOPE)
		{
			_local_variables = _local_variables.Concat(p.locals_node()).ToArray();
			_body = body;
		}

		public mrb_sym[] local_variables { get { return _local_variables; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			// TODO:？？？
			var s = cond.CreateElement("scope");
			var b = _body.to_xml(cond);
			if (b != null) {
				s.AppendChild(b);
			}
			return s;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			_body.to_ruby(cond);
		}

		public override string ToString()
		{
			var str = "(:scope (";
			foreach (var v in local_variables) {
				str += $"{v}, ";
			}
			return str + $") {body})";
		}
	}

	/* (:begin prog...) */
	public class begin_node : node
	{
		private node[] _progs = new node[0];
		bool _parentheses;

		public begin_node(IMrbParser p, node body, bool parentheses = false)
			: base(p, node_type.NODE_BEGIN)
		{
			while (body != null) {
				_progs.Push(body);
				body = (node)body.cdr;
			}
			_parentheses = parentheses;
		}

		public begin_node(IMrbParser p, node[] progs)
			: base(p, node_type.NODE_BEGIN)
		{
			_progs = _progs.Concat(progs).ToArray();
		}

		public node[] progs { get { return _progs; } }

		public override void append(node b)
		{
			_progs.Push((node)b.car);
		}

		public override Element to_xml(xml_code_cond cond)
		{
			switch (_progs.Length) {
			case 0:
				return null;
			case 1:
				return _progs[0].to_xml(cond);
			}
			var b = _progs[0].to_xml(cond);
			var p = b;
			for (int i = 1; i < _progs.Length; i++) {
				var n = cond.CreateElement("next");
				var q = _progs[i].to_xml(cond);
				n.AppendChild(q);
				p.AppendChild(n);
				p = q;
			}

			return b;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			var i = progs.Length;
			foreach (var v in progs) {
				var prn = _parentheses || (v is dot2_node);
				if (prn) {
					cond.increment_nest();
					cond.write("(");
				}
				v.to_ruby(cond);
				if (prn) {
					cond.write(")");
					cond.decrement_nest();
				}
				i--; if (i > 0) cond.separate_line();
			}
		}

		public override string ToString()
		{
			var str = "(:begin ";
			foreach (var v in progs) {
				str += $"{v}, ";
			}
			return str + ")";
		}
	}

	/* (:rescue body rescue else) */
	class rescue_node : node
	{
		public class rescue_t
		{
			public node[] handle_classes = new node[0];
			public node exc_var;
			public node body;

			public override string ToString()
			{
				var str = "(";
				foreach (var c in handle_classes) {
					str += $"{c}, ";
				}
				return $"{exc_var} {body})";
			}

			internal void to_ruby(ruby_code_cond cond)
			{
				cond.increment_nest();
				cond.write("rescue");
				int i = handle_classes.Length;
				if (i > 0)
					cond.write(" ");
				foreach (var c in handle_classes) {
					c.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (exc_var != null) {
					cond.write(" => ");
					exc_var.to_ruby(cond);
				}
				cond.decrement_nest();
				cond.write_line();
				cond.increment_indent();
				body.to_ruby(cond);
				cond.decrement_indent();
			}
		}

		private node _body;
		private rescue_t[] _rescue = new rescue_t[0];
		private node _else;
		public bool ensure;

		public rescue_node(IMrbParser p, node body, node resq, node els)
			: base(p, node_type.NODE_RESCUE)
		{
			_body = body;
			if (resq != null) {
				var n2 = (node)resq;

				while (n2 != null) {
					rescue_t r = new rescue_t();
					var n3 = (node)n2.car;
					if (n3.car != null) {
						dump_recur(r.handle_classes, (node)n3.car);
					}
					r.exc_var = (node)((node)n3.cdr).car;
					r.body = (node)((node)((node)n3.cdr).cdr).car;
					_rescue.Push(r);
					n2 = (node)n2.cdr;
				}
			}
			_else = els;
		}

		public node body { get { return _body; } }
		public rescue_t[] rescue { get { return _rescue; } }
		public node @else { get { return _else; } }

		public override Element to_xml(xml_code_cond cond)
		{
			// TODO:？？？
			return body.to_xml(cond);
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			if (!ensure) {
				cond.write_line("begin");
				cond.increment_indent();
			}
			_body.to_ruby(cond);
			cond.decrement_indent();
			foreach (var r in _rescue) {
				r.to_ruby(cond);
			}
			if (_else != null) {
				cond.write_line("else");
				cond.increment_indent();
				_else.to_ruby(cond);
				cond.decrement_indent();
			}
			if (!ensure) {
				cond.write_line("end");
			}
			else {
				cond.increment_indent();
			}
		}

		public override string ToString()
		{
			var str = $"(:rescue {body} ";
			foreach (var r in rescue) {
				str += $"{r}, ";
			}
			return str + $" {@else})";
		}
	}

	/* (:ensure body ensure) */
	class ensure_node : node
	{
		private node _body;
		private node _ensure;
		public bool def;

		public ensure_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_ENSURE)
		{
			_body = a;
			_ensure = b;
			if (_body is rescue_node) {
				((rescue_node)_body).ensure = true;
			}
		}

		public node body { get { return _body; } }
		public node ensure { get { return _ensure; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			if (!def) {
				cond.write_line("begin");
				cond.increment_indent();
			}
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("ensure");
			cond.increment_indent();
			_ensure.to_ruby(cond);
			if (!def) {
				cond.decrement_indent();
				cond.write_line("end");
			}
		}

		public override string ToString()
		{
			return $"(:ensure {body} {ensure})";
		}
	}

	/* (:nil) */
	class nil_node : node, IEvaluatable
	{
		public nil_node(IMrbParser p)
			: base(p, node_type.NODE_NIL)
		{
		}

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "logic_null");
			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("nil");
		}

		public override string ToString()
		{
			return $"(:nil)";
		}

		public node evaluate(string method, node[] args)
		{
			switch (method) {
			case "!":
				if (args.Length != 0)
					break;
				return new true_node(p);
			}
			return null;
		}
	}

	/* (:true) */
	class true_node : node, IEvaluatable
	{
		public true_node(IMrbParser p)
			: base(p, node_type.NODE_TRUE)
		{
		}

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "logic_boolean");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "BOOL");
			field.AppendChild(cond.CreateTextNode("TRUE"));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("true");
		}

		public override string ToString()
		{
			return $"(:true)";
		}

		public node evaluate(string method, node[] args)
		{
			switch (method) {
			case "!":
				if (args.Length != 0)
					break;
				return new false_node(p);
			}
			return null;
		}
	}

	/* (:false) */
	class false_node : node, IEvaluatable
	{
		public false_node(IMrbParser p)
			: base(p, node_type.NODE_FALSE)
		{
		}

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "logic_boolean");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "BOOL");
			field.AppendChild(cond.CreateTextNode("FALSE"));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("false");
		}

		public override string ToString()
		{
			return $"(:false)";
		}

		public node evaluate(string method, node[] args)
		{
			switch (method) {
			case "!":
				if (args.Length != 0)
					break;
				return new true_node(p);
			}
			return null;
		}
	}

	/* (:alias new old) */
	class alias_node : node
	{
		private mrb_sym _new;
		private mrb_sym _old;

		public alias_node(IMrbParser p, mrb_sym a, mrb_sym b)
			: base(p, node_type.NODE_ALIAS)
		{
			_new = a;
			_old = b;
		}

		public mrb_sym @new { get { return _new; } }
		public mrb_sym old { get { return _old; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write_line($"alias {p.sym2name(_new)} {p.sym2name(_old)}");
		}

		public override string ToString()
		{
			return $"(:alias {p.sym2name(@new)} {p.sym2name(old)})";
		}
	}

	/* (:if cond then else) */
	class if_node : node
	{
		private node _cond;
		private node _then;
		private node _else;
		bool _inline;

		public if_node(IMrbParser p, node cond, node then, node @else, bool inline)
			: base(p, node_type.NODE_IF)
		{
			_cond = cond;
			_then = then;
			_else = @else;
			_inline = inline;
		}

		public node cond { get { return _cond; } }
		public node then { get { return _then; } }
		public node @else { get { return _else; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var _elsif = new Tuple<node, node>[0];
			node _else = this._else;

			_elsif.Push(new Tuple<node, node>(_cond, _then));
			for (var c = _else as if_node; c != null; _else = c._else, c = _else as if_node) {
				_elsif.Push(new Tuple<node, node>(c._cond, c._then));
			}

			var block = cond.CreateElement("block");
			block.SetAttribute("type", "controls_if");

			var mutation = cond.CreateElement("mutation");
			mutation.SetAttribute("elseif", _elsif.Length.ToString());
			mutation.SetAttribute("else", _else != null ? "1" : "0");
			block.AppendChild(mutation);

			int i = 0;
			foreach (var e in _elsif) {
				var value = cond.CreateElement("value");
				value.SetAttribute("name", $"IF{i}");
				value.AppendChild(e.Item1.to_xml(cond));
				block.AppendChild(value);

				var statement = cond.CreateElement("statement");
				statement.SetAttribute("name", $"DO{i}");
				statement.AppendChild(e.Item2.to_xml(cond));
				block.AppendChild(statement);
				i++;
			}

			if (_else != null) {
				var statement = cond.CreateElement("statement");
				statement.SetAttribute("name", "ELSE");
				statement.AppendChild(_else.to_xml(cond));
				block.AppendChild(statement);
			}

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			if (_inline) {
				cond.increment_nest();
				cond.write("(");
				_cond.to_ruby(cond);
				cond.write(" ? ");
				_then.to_ruby(cond);
				cond.write(" : ");
				_else.to_ruby(cond);
				cond.decrement_nest();
			}
			else {
				var _elsif = new Tuple<node, node>[0];
				node _else = this._else;

				for (var c = _else as if_node; c != null; _else = c._else, c = _else as if_node) {
					_elsif.Push(new Tuple<node, node>(c._cond, c._then));
				}

				cond.increment_nest();
				cond.write("if ");
				_cond.to_ruby(cond);
				cond.decrement_nest();
				cond.increment_indent();
				_then.to_ruby(cond);
				cond.decrement_indent();
				foreach (var e in _elsif) {
					cond.increment_nest();
					cond.write("elsif ");
					e.Item1.to_ruby(cond);
					cond.decrement_nest();
					cond.write_line();
					cond.increment_indent();
					e.Item2.to_ruby(cond);
					cond.decrement_indent();
				}

				if (_else != null) {
					cond.write_line("else");
					cond.increment_indent();
					_else.to_ruby(cond);
					cond.decrement_indent();
				}
				cond.write_line("end");
			}
		}

		public override string ToString()
		{
			return $"(:if {cond} {then} {@else})";
		}
	}

	/* (:unless cond then else) */
	class unless_node : node
	{
		private node _cond;
		private node _then;
		private node _else;

		public unless_node(IMrbParser p, node a, node b, node c)
			: base(p, node_type.NODE_IF)
		{
			_cond = a;
			_then = c;
			_else = b;
		}

		public node cond { get { return _cond; } }
		public node then { get { return _then; } }
		public node @else { get { return _else; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "controls_if");

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "IF0");
			value.AppendChild(_cond.to_xml(cond));
			block.AppendChild(value);

			if (_then != null) {
				var statement = cond.CreateElement("statement");
				statement.SetAttribute("name", "DO0");
				block.AppendChild(statement);

				statement.AppendChild(_then.to_xml(cond));
			}

			if (_else != null) {
				var statement = cond.CreateElement("statement");
				statement.SetAttribute("name", "ELSE");
				block.AppendChild(statement);

				statement.AppendChild(_else.to_xml(cond));
			}

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("unless ");
			_cond.to_ruby(cond);
			cond.decrement_nest();
			cond.increment_indent();
			_else.to_ruby(cond);
			cond.decrement_indent();

			if (_then != null) {
				cond.write_line("else");
				cond.increment_indent();
				_then.to_ruby(cond);
				cond.decrement_indent();
			}
			cond.write_line("end");
		}

		public override string ToString()
		{
			return $"(:unless {cond} {then} {@else})";
		}
	}

	/* (:while cond body) */
	class while_node : node
	{
		private node _cond;
		private node _body;

		public while_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_WHILE)
		{
			_cond = a;
			_body = b;
		}

		public node cond { get { return _cond; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "controls_whileUntil");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "MODE");
			field.AppendChild(cond.CreateTextNode("WHILE"));
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "BOOL");
			value.AppendChild(_cond.to_xml(cond));
			block.AppendChild(value);

			var statement = cond.CreateElement("statement");
			statement.SetAttribute("name", "DO");
			statement.AppendChild(_body.to_xml(cond));
			block.AppendChild(statement);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("while ");
			_cond.to_ruby(cond);
			cond.decrement_nest();
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("end");
		}

		public override string ToString()
		{
			return $"(:while {cond} {body})";
		}
	}

	/* (:until cond body) */
	class until_node : node
	{
		private node _cond;
		private node _body;

		public until_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_UNTIL)
		{
			_cond = a;
			_body = b;
		}

		public node cond { get { return _cond; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "controls_whileUntil");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "MODE");
			field.AppendChild(cond.CreateTextNode("UNTIL"));
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "BOOL");
			value.AppendChild(_cond.to_xml(cond));
			block.AppendChild(value);

			var statement = cond.CreateElement("statement");
			statement.SetAttribute("name", "DO");
			statement.AppendChild(_body.to_xml(cond));
			block.AppendChild(statement);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("until ");
			_cond.to_ruby(cond);
			cond.decrement_nest();
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("end");
		}

		public override string ToString()
		{
			return $"(:until {cond} {body})";
		}
	}

	/* (:for var obj body) */
	class for_node : node
	{
		public class var_t
		{
			public node[] pre = new node[0];
			public node rest;
			public node[] post = new node[0];

			public override string ToString()
			{
				var str = "(";
				foreach (var p in pre) {
					str += $"{p} ";
				}
				str += $"{rest} ";
				foreach (var p in post) {
					str += $"{p} ";
				}
				return str + ")";
			}

			internal void to_ruby(ruby_code_cond cond)
			{
				int i = pre.Length + (rest != null ? 1 : 0) + post.Length;
				foreach (var p in pre) {
					p.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (rest != null) {
					rest.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				foreach (var p in post) {
					p.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
			}
		}
		private var_t _var;
		private node _in;
		private node _do;

		public for_node(IMrbParser p, node v, node o, node b)
			: base(p, node_type.NODE_FOR)
		{
			_var = new var_t();
			node n2 = v;

			if (n2.car != null) {
				dump_recur(_var.pre, (node)n2.car);
			}
			n2 = (node)n2.cdr;
			if (n2 != null) {
				if (n2.car != null) {
					_var.rest = (node)n2.car;
				}
				n2 = (node)n2.cdr;
				if (n2 != null) {
					if (n2.car != null) {
						dump_recur(_var.post, (node)n2.car);
					}
				}
			}
			_in = o;
			_do = b;
		}

		public var_t var { get { return _var; } }
		public node @in { get { return _in; } }
		public node @do { get { return _do; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "controls_forEach");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "VAR");
			// TODO:var？
			var pre = var.pre[0];
			switch ((node_type)pre.car) {
			case node_type.NODE_GVAR:
				field.AppendChild(cond.CreateTextNode(p.sym2name(((gvar_node)pre).name)));
				break;
			case node_type.NODE_CVAR:
				field.AppendChild(cond.CreateTextNode(p.sym2name(((cvar_node)pre).name)));
				break;
			case node_type.NODE_IVAR:
				field.AppendChild(cond.CreateTextNode(p.sym2name(((ivar_node)pre).name)));
				break;
			case node_type.NODE_LVAR:
				field.AppendChild(cond.CreateTextNode(p.sym2name(((lvar_node)pre).name)));
				break;
			default:
				// TODO: ？
				throw new NotImplementedException();
			}
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "LIST");
			value.AppendChild(_in.to_xml(cond));
			block.AppendChild(value);

			var statement = cond.CreateElement("statement");
			statement.SetAttribute("name", "DO");
			statement.AppendChild(_do.to_xml(cond));
			block.AppendChild(statement);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("for ");
			_var.to_ruby(cond);
			cond.write(" in ");
			_in.to_ruby(cond);
			cond.write(" do");
			cond.decrement_nest();
			cond.increment_indent();
			_do.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("end");
		}

		public override string ToString()
		{
			return $"(:for {var} {@in} {@do})";
		}
	}

	/* (:case a ((when ...) body) ((when...) body)) */
	class case_node : node
	{
		public class when_t
		{
			public node[] value = new node[0];
			public node body;

			public override string ToString()
			{
				var str = $"(when ";
				foreach (var c in value) {
					str += $"{c} ";
				}
				return str + $"{body})";
			}
		}
		private node _arg;
		private when_t[] _when = new when_t[0];

		public case_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_CASE)
		{
			_arg = a;
			while (b != null) {
				var w = new when_t();
				dump_recur(w.value, (node)((node)b.car).car);
				w.body = (node)((node)b.car).cdr;
				_when.Push(w);
				b = (node)b.cdr;
			}
		}

		public case_node(IMrbParser p, node a, when_t[] b)
			: base(p, node_type.NODE_CASE)
		{
			_arg = a;
			_when = _when.Concat(b).ToArray();
		}

		public node arg { get { return _arg; } }
		public when_t[] when { get { return _when; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "switch_case_number");

			int c = 0, d = 0;
			when_t default_node = null;
			foreach (var w in _when) {
				if (w.value.Length == 0) {
					default_node = w;
					d = 1;
				}
				else
					c++;
			}

			var mutation = cond.CreateElement("mutation");
			mutation.SetAttribute("case", c.ToString());
			mutation.SetAttribute("default", d.ToString());
			block.AppendChild(mutation);

			int i = 0;
			foreach (var w in _when) {
				if (w.value.Length == 0)
					continue;

				var field = cond.CreateElement("field");
				field.SetAttribute("name", "CONST" + i);
				// TODO:whenの値が複数の場合
				field.AppendChild(cond.CreateTextNode(MrbParser.UTF8ArrayToString(((int_node)w.value[0]).num, 0)));
				block.AppendChild(field);
				i++;
			}

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "SWITCH");
			block.AppendChild(value);

			value.AppendChild(_arg.to_xml(cond));

			foreach (var w in _when) {
				if (w.value.Length == 0)
					continue;

				var statement = cond.CreateElement("statement");
				statement.SetAttribute("name", "DO" + i);
				statement.AppendChild(w.body.to_xml(cond));
				block.AppendChild(statement);
			}

			if (default_node != null) {
				var statement = cond.CreateElement("statement");
				statement.SetAttribute("name", "DEFAULT");
				statement.AppendChild(default_node.body.to_xml(cond));
				block.AppendChild(statement);
			}

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("case ");
			if (_arg != null)
				_arg.to_ruby(cond);
			cond.decrement_nest();
			cond.separate_line();
			foreach (var w in _when) {
				cond.increment_nest();
				var count = w.value.Length;
				if (count != 0) {
					cond.write("when ");
					foreach (var v in w.value) {
						v.to_ruby(cond);
						count--;
						if (count > 0)
							cond.write(", ");
					}
				}
				else
					cond.write("else");
				cond.decrement_nest();

				cond.increment_indent();
				w.body.to_ruby(cond);
				cond.decrement_indent();
			}
			cond.write_line("end");
		}

		public override string ToString()
		{
			var str = $"(:case {arg} ";
			foreach (var w in when) {
				str += $"{w} ";
			}
			return str + ")";
		}
	}

	/* (:postexe a) */
	class postexe_node : node
	{
		private node _postexe;

		public postexe_node(IMrbParser p, node a)
			: base(p, node_type.NODE_POSTEXE)
		{
			_postexe = a;
		}

		public node postexe { get { return _postexe; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write_line("END {");
			_postexe.to_ruby(cond);
			cond.write_line("}");
		}

		public override string ToString()
		{
			return $"(:postexe {postexe})";
		}
	}

	/* (:self) */
	class self_node : node
	{
		public self_node(IMrbParser p)
			: base(p, node_type.NODE_SELF)
		{
		}

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("self");
		}

		public override string ToString()
		{
			return $"(:self)";
		}
	}

	/* (:call a b c) */
	class call_node : node
	{
		private node _obj;
		private mrb_sym _method;
		private node[] _args = new node[0];
		private node _block;
		private MrbTokens _pass;

		public call_node(IMrbParser p, node a, mrb_sym b, node c, MrbTokens pass)
			: base(p, pass != 0 ? node_type.NODE_CALL : node_type.NODE_SCALL)
		{
			_pass = pass;
			NODE_LINENO(a);

			_obj = a;
			_method = b;
			if (c != null) {
				dump_recur(_args, (node)c.car);
				if (c.cdr != null) {
					_block = (node)c.cdr;
				}
			}
		}

		public call_node(IMrbParser p, node a, mrb_sym b, node[] args = null, node block = null)
			: base(p, node_type.NODE_CALL)
		{
			_obj = a;
			_method = b;
			if (args != null)
				_args = _args.Concat(args).ToArray();
			_block = block;
		}

		public call_node(IMrbParser p, node a, mrb_sym b, node arg)
			: base(p, node_type.NODE_CALL)
		{
			_obj = a;
			_method = b;
			if (arg != null)
				_args.Push(arg);
			_pass = (MrbTokens)1;
		}

		public node obj { get { return _obj; } }
		public mrb_sym method { get { return _method; } }
		public node[] args { get { return _args; } }
		public node block { get { return _block; } }

		internal void add_block(node b)
		{
			if (b != null) {
				if (_block != null) {
					p.yyError("both block arg and actual block given");
				}
				_block = b;
			}
		}

		public override Element to_xml(xml_code_cond cond)
		{
			var method = p.sym2name(_method);
			switch (method) {
			case "==": return logic_compare(cond, "EQ");
			case "!=": return logic_compare(cond, "NEQ");
			case "<": return logic_compare(cond, "LT");
			case "<=": return logic_compare(cond, "LTE");
			case ">": return logic_compare(cond, "GT");
			case ">=": return logic_compare(cond, "GTE");
			}

			return procedures_callreturn(cond, method);
		}

		private Element procedures_callreturn(xml_code_cond cond, string method)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "procedures_callreturn");

			var mutation = cond.CreateElement("mutation");
			mutation.SetAttribute("name", method);
			block.AppendChild(mutation);

			int i = 0;
			foreach (var a in args) {
				var arg = cond.CreateElement("arg");
				// TODO: 引数名を持ってくkる
				arg.SetAttribute("name", i.ToString());
				arg.AppendChild(a.to_xml(cond));
				block.AppendChild(arg);
				i++;
			}

			return block;
		}

		private Element logic_compare(xml_code_cond cond, string op)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "logic_compare");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "OP");
			field.AppendChild(cond.CreateTextNode(op));
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "A");
			value.AppendChild(_obj.to_xml(cond));
			block.AppendChild(value);

			// argsは１つ
			value = cond.CreateElement("value");
			value.SetAttribute("name", "B");
			value.AppendChild(args[0].to_xml(cond));
			block.AppendChild(value);

			return block;
		}

		public bool isArray(node _obj)
		{
			var cnst = _obj as const_node;
			return (cnst != null) && (p.sym2name(cnst.name) == "Array");
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			var blk_arg = _block as block_arg_node;
			var blk = _block;
			if (blk_arg != null)
				blk = null;
			var m = p.sym2name(_method);
			int i = _args.Length + (blk_arg != null ? 1 : 0);
			if (_pass == (MrbTokens)1) {
				cond.increment_nest();
				switch (m) {
				case "!":
				case "~":
					cond.write(m);
					_obj.to_ruby(cond);
					foreach (var a in _args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
					if (blk_arg != null) {
						blk_arg.to_ruby(cond);
					}
					break;
				case "+@":
				case "-@":
					cond.write(m.Substring(0, 1));
					_obj.to_ruby(cond);
					foreach (var a in _args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
					if (blk_arg != null) {
						blk_arg.to_ruby(cond);
					}
					break;
				default:
					_obj.to_ruby(cond);
					cond.write(" " + m + " ");
					foreach (var a in _args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
					if (blk_arg != null) {
						blk_arg.to_ruby(cond);
					}
					break;
				}
				cond.decrement_nest();
			}
			else {
				string call_op = _pass == MrbTokens.tCOLON2 ? "::" : ".";
				switch (m) {
				case "[]":
					cond.increment_nest();
					_obj.to_ruby(cond);
					if (isArray(_obj)) {
						cond.write(call_op + "[]");
						cond.write("(");
						foreach (var a in _args) {
							a.to_ruby(cond);
							i--; if (i > 0) cond.write(", ");
						}
						cond.write(")");
					}
					else if (i == 0)
						cond.write("[]");
					else {
						cond.write("[");
						foreach (var a in _args) {
							a.to_ruby(cond);
							i--; if (i > 0) cond.write(", ");
						}
						cond.write("]");
					}
					cond.decrement_nest();
					break;
				case "[]=":
					cond.increment_nest();
					_obj.to_ruby(cond);
					cond.write(".[]=");
					cond.write("(");
					foreach (var a in _args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
					if (blk_arg != null) {
						blk_arg.to_ruby(cond);
					}
					cond.write(")");
					cond.decrement_nest();
					break;
				default:
					cond.increment_nest();
					_obj.to_ruby(cond);
					if (i == 0)
						cond.write(call_op + m);
					else {
						cond.write(call_op + m + "(");
						foreach (var a in _args) {
							a.to_ruby(cond);
							i--; if (i > 0) cond.write(", ");
						}
						if (blk_arg != null) {
							blk_arg.to_ruby(cond);
						}
						cond.write(")");
					}
					cond.decrement_nest();
					break;
				}
			}
			if (blk != null) {
				blk.to_ruby(cond);
			}
			else if (cond.nest == 0)
				cond.write_line();
		}

		public override string ToString()
		{
			var str = $"(:call {obj} {p.sym2name(method)} ";
			foreach (var v in args) {
				str += v.ToString() + " ";
			}
			return str + $"{block})";
		}
	}

	/* (:fcall self mid args) */
	class fcall_node : node
	{
		private node _self;
		private mrb_sym _method;
		private node[] _args = new node[0];
		private node _block;

		public fcall_node(IMrbParser p, mrb_sym b, node c)
			: base(p, node_type.NODE_FCALL)
		{
			node n = new self_node(p);
			n.NODE_LINENO(c);
			NODE_LINENO(c);

			_self = n;
			_method = b;
			if (c != null) {
				dump_recur(_args, (node)c.car);
				if (c.cdr != null) {
					_block = (node)c.cdr;
				}
			}
		}

		public fcall_node(IMrbParser p, mrb_sym b, node[] args = null, node block = null)
			: base(p, node_type.NODE_FCALL)
		{
			_self = new self_node(p);
			_method = b;
			if (args != null)
				_args = _args.Concat(args).ToArray();
			_block = block;
		}

		public node self { get { return _self; } }
		public mrb_sym method { get { return _method; } }
		public node[] args { get { return _args; } }
		public node block { get { return _block; } }

		internal void add_block(node b)
		{
			if (b != null) {
				if (_block != null) {
					p.yyError("both block arg and actual block given");
				}
				_block = b;
			}
		}

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "procedures_callreturn");

			var mutation = cond.CreateElement("mutation");
			mutation.SetAttribute("name", p.sym2name(_method));
			block.AppendChild(mutation);

			int i = 0;
			foreach (var a in args) {
				var arg = cond.CreateElement("arg");
				// TODO: 引数名を持ってくkる
				arg.SetAttribute("name", i.ToString());
				arg.AppendChild(a.to_xml(cond));
				block.AppendChild(arg);
				i++;
			}

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			var blk_arg = _block as block_arg_node;
			var blk = _block;
			if (blk_arg != null)
				blk = null;
			var m = p.sym2name(_method);
			int i = _args.Length + (blk_arg != null ? 1 : 0);
			switch (m) {
			case "include":
			case "raise":
				cond.write(m + " ");
				foreach (var a in _args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (blk_arg != null) {
					blk_arg.to_ruby(cond);
				}
				break;
			default:
				if (i == 0)
					cond.write(m);
				else {
					cond.write(m + "(");
					foreach (var a in _args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
					if (blk_arg != null) {
						blk_arg.to_ruby(cond);
					}
					cond.write(")");
				}
				break;
			}
			cond.decrement_nest();
			if (blk != null) {
				blk.to_ruby(cond);
			}
			else if (cond.nest == 0)
				cond.write_line();
		}

		public override string ToString()
		{
			var str = $"(:fcall {self} {p.sym2name(method)} ";
			foreach (var v in args) {
				str += v.ToString() + " ";
			}
			return str + $"{block})";
		}
	}

	/* (:super . c) */
	class super_node : node
	{
		private node[] _args = new node[0];
		private node _block;

		public super_node(IMrbParser p, node c)
			: base(p, node_type.NODE_SUPER)
		{
			if (c != null) {
				dump_recur(_args, (node)c.car);
				if (c.cdr != null) {
					_block = (node)c.cdr;
				}
			}
		}

		public super_node(IMrbParser p, node[] args)
			: base(p, node_type.NODE_SUPER)
		{
			_args = _args.Concat(args).ToArray();
		}

		public node[] args { get { return _args; } }
		public node block { get { return _block; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "procedures_callreturn");

			var mutation = cond.CreateElement("mutation");
			mutation.SetAttribute("name", "super");
			block.AppendChild(mutation);

			int i = 0;
			foreach (var a in args) {
				var arg = cond.CreateElement("arg");
				// TODO: 引数名を持ってくkる
				arg.SetAttribute("name", i.ToString());
				arg.AppendChild(a.to_xml(cond));
				block.AppendChild(arg);
				i++;
			}

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			var blk_arg = _block as block_arg_node;
			var blk = _block;
			if (blk_arg != null)
				blk = null;
			int i = _args.Length + (blk_arg != null ? 1 : 0);
			if (i == 0)
				cond.write("super");
			else {
				cond.write("super(");
				foreach (var a in _args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (blk_arg != null) {
					blk_arg.to_ruby(cond);
				}
				cond.write(")");
			}
			cond.decrement_nest();
			if (blk != null) {
				blk.to_ruby(cond);
			}
			else if (cond.nest == 0)
				cond.write_line();
		}

		public override string ToString()
		{
			var str = "(:super ";
			foreach (var v in args) {
				str += v.ToString() + " ";
			}
			return str + block + ")";
		}

		internal void add_block(node b)
		{
			if (b != null) {
				if (_block != null) {
					p.yyError("both block arg and actual block given");
				}
				_block = b;
			}
		}
	}

	/* (:zsuper) */
	class zsuper_node : node
	{
		private node _block; // 必要?

		public zsuper_node(IMrbParser p)
			: base(p, node_type.NODE_ZSUPER)
		{
		}

		internal void add_block(node b)
		{
			if (b != null) {
				if (_block != null) {
					p.yyError("both block arg and actual block given");
				}
				_block = b;
			}
		}

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			var blk_arg = _block as block_arg_node;
			var blk = _block;
			if (blk_arg != null)
				blk = null;
			if (blk_arg == null)
				cond.write("super");
			else {
				cond.write("super(");
				if (blk_arg != null) {
					blk_arg.to_ruby(cond);
				}
				cond.write(")");
			}
			cond.decrement_nest();
			if (blk != null) {
				blk.to_ruby(cond);
			}
			else if (cond.nest == 0)
				cond.write_line();
		}

		public override string ToString()
		{
			return $"(:zsuper)";
		}
	}

	/* (:yield . c) */
	class yield_node : node
	{
		private node[] _args = new node[0];

		public yield_node(IMrbParser p, node c)
			: base(p, node_type.NODE_YIELD)
		{
			if (c != null) {
				if (c.cdr != null) {
					p.yyError("both block arg and actual block given");
				}
				c = (node)c.car;
			}

			dump_recur(_args, (node)c);
		}

		public node[] args { get { return _args; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			int i = _args.Length;
			if (i == 0)
				cond.write("yield");
			else {
				cond.write("yield ");
				foreach (var a in _args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
			}
			cond.decrement_nest();
			if (cond.nest == 0)
				cond.write_line();
		}

		public override string ToString()
		{
			var str = "(:yield ";
			foreach (var v in args) {
				str += v.ToString() + " ";
			}
			return str + ")";
		}
	}

	/* (:return . c) */
	class return_node : node
	{
		private node _retval;

		public return_node(IMrbParser p, node c)
			: base(p, node_type.NODE_RETURN)
		{
			_retval = c;
		}

		public node retval { get { return _retval; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "procedures_return");

			var mutation = cond.CreateElement("mutation");
			mutation.SetAttribute("value", (_retval != null) ? "0" : "1");
			block.AppendChild(mutation);

			if (_retval != null) {
				var value = cond.CreateElement("value");
				value.SetAttribute("name", "VALUE");
				value.AppendChild(_retval.to_xml(cond));
				block.AppendChild(value);
			}

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			if (_retval != null) {
				cond.write("return ");
				_retval.to_ruby(cond);
				cond.write_line();
			}
			else {
				cond.write_line("return");
			}
			cond.decrement_nest();
		}

		public override string ToString()
		{
			return $"(:return . {retval})";
		}
	}

	/* (:break . c) */
	class break_node : node
	{
		private node _retval;

		public break_node(IMrbParser p, node c)
			: base(p, node_type.NODE_BREAK)
		{
			_retval = c;
		}

		public node retval { get { return _retval; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "controls_flow_statements");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "FLOW");
			field.AppendChild(cond.CreateTextNode("BREAK"));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			if (_retval != null) {
				cond.write("break ");
				_retval.to_ruby(cond);
				cond.write_line();
			}
			else {
				cond.write_line("break");
			}
			cond.decrement_nest();
		}

		public override string ToString()
		{
			return $"(:break . {retval})";
		}
	}

	/* (:next . c) */
	class next_node : node
	{
		private node _retval;

		public next_node(IMrbParser p, node c)
			: base(p, node_type.NODE_NEXT)
		{
			_retval = c;
		}

		public node retval { get { return _retval; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "controls_flow_statements");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "FLOW");
			field.AppendChild(cond.CreateTextNode("CONTINUE"));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			if (_retval != null) {
				cond.write("next ");
				_retval.to_ruby(cond);
				cond.write_line();
			}
			else {
				cond.write_line("next");
			}
			cond.decrement_nest();
		}

		public override string ToString()
		{
			return $"(:next . {retval})";
		}
	}

	/* (:redo) */
	class redo_node : node
	{
		public redo_node(IMrbParser p)
			: base(p, node_type.NODE_REDO)
		{
		}

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write_line("redo");
		}

		public override string ToString()
		{
			return $"(:redo)";
		}
	}

	/* (:retry) */
	class retry_node : node
	{
		public retry_node(IMrbParser p)
			: base(p, node_type.NODE_RETRY)
		{
		}

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write_line("retry");
		}

		public override string ToString()
		{
			return $"(:retry)";
		}
	}

	/* (:dot2 a b) */
	class dot2_node : node
	{
		private node _a;
		private node _b;

		public dot2_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_DOT2)
		{
			_a = a;
			_b = b;
		}

		public node a { get { return _a; } }

		public node b { get { return _b; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			_a.to_ruby(cond);
			cond.write("..");
			_b.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:dot2 {a} {b})";
		}
	}

	/* (:dot3 a b) */
	class dot3_node : node
	{
		private node _a;
		private node _b;

		public dot3_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_DOT3)
		{
			_a = a;
			_b = b;
		}

		public node a { get { return _a; } }

		public node b { get { return _b; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			_a.to_ruby(cond);
			cond.write("...");
			_b.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:dot3 {a} {b})";
		}
	}

	/* (:colon2 b c) */
	class colon2_node : node
	{
		private node _b;
		private mrb_sym _c;

		public colon2_node(IMrbParser p, node b, mrb_sym c)
			: base(p, node_type.NODE_COLON2)
		{
			_b = b;
			_c = c;
		}

		public node b { get { return _b; } }
		public mrb_sym c { get { return _c; } }

		public override Element to_xml(xml_code_cond cond)
		{
			// TODO:？？？
			var block = cond.CreateElement("class");
			block.SetAttribute("const", p.sym2name(((const_node)_b).name));
			block.SetAttribute("name", p.sym2name(_c));

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			_b.to_ruby(cond);
			cond.write("::" + p.sym2name(_c));
		}

		public override string ToString()
		{
			return $"(:colon2 {b} {p.sym2name(c)})";
		}
	}

	/* (:colon3 . c) */
	class colon3_node : node
	{
		private mrb_sym _c;

		public colon3_node(IMrbParser p, mrb_sym c)
			: base(p, node_type.NODE_COLON3)
		{
			_c = c;
		}

		public mrb_sym c { get { return _c; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("::" + p.sym2name(_c));
		}

		public override string ToString()
		{
			return $"(:colon3 . {p.sym2name(c)})";
		}
	}

	/* (:and a b) */
	class and_node : node
	{
		private node _a;
		private node _b;

		public and_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_AND)
		{
			_a = a;
			_b = b;
		}

		public node a { get { return _a; } }

		public node b { get { return _b; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "logic_operation");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "OP");
			field.AppendChild(cond.CreateTextNode("AND"));
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "A");
			value.AppendChild(_a.to_xml(cond));
			block.AppendChild(value);

			value = cond.CreateElement("value");
			value.SetAttribute("name", "B");
			value.AppendChild(_b.to_xml(cond));
			block.AppendChild(value);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			_a.to_ruby(cond);
			cond.write(" && ");
			_b.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:and {a} {b})";
		}
	}

	/* (:or a b) */
	class or_node : node
	{
		private node _a;
		private node _b;

		public or_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_OR)
		{
			_a = a;
			_b = b;
		}

		public node a { get { return _a; } }
		public node b { get { return _b; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "logic_operation");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "OP");
			field.AppendChild(cond.CreateTextNode("OR"));
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "A");
			value.AppendChild(_a.to_xml(cond));
			block.AppendChild(value);

			value = cond.CreateElement("value");
			value.SetAttribute("name", "B");
			value.AppendChild(_b.to_xml(cond));
			block.AppendChild(value);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			_a.to_ruby(cond);
			cond.write(" || ");
			_b.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:or {a} {b})";
		}
	}

	/* (:array a...) */
	class array_node : node
	{
		private node[] _array = new node[0];
		private bool _item_per_line;

		public array_node(IMrbParser p, node a)
			: base(p, node_type.NODE_ARRAY)
		{
			dump_recur(_array, a);
		}

		public array_node(IMrbParser p, node[] a, bool item_per_line = false)
			: base(p, node_type.NODE_ARRAY)
		{
			_array = _array.Concat(a).ToArray();
			_item_per_line = item_per_line;
		}


		public node[] array { get { return _array; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "lists_create_with");

			var mutation = cond.CreateElement("mutation");
			mutation.SetAttribute("items", _array.Length.ToString());
			block.AppendChild(mutation);

			int i = 0;
			foreach (var item in _array) {
				var value = cond.CreateElement("value");
				value.SetAttribute("name", $"ADD{i}");
				value.AppendChild(_array[i].to_xml(cond));
				block.AppendChild(value);
				i++;
			}

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("[");
			if (_item_per_line) {
				cond.separate_line();
				cond.increment_indent();
			}
			int i = _array.Length;
			foreach (var item in _array) {
				item.to_ruby(cond);
				i--;
				if (i > 0) {
					if (_item_per_line) {
						cond.write(",");
						cond.separate_line();
					}
					else
						cond.write(", ");
				}
				else if (_item_per_line) {
					cond.decrement_indent();
					cond.separate_line();
				}
			}
			cond.write("]");
			cond.decrement_nest();
		}

		public override string ToString()
		{
			var str = $"(:array ";
			foreach (var n in array) {
				str += $"{n} ";
			}
			return str + ")";
		}
	}

	/* (:splat . a) */
	class splat_node : node
	{
		private node _a;

		public splat_node(IMrbParser p, node a)
			: base(p, node_type.NODE_SPLAT)
		{
			_a = a;
		}

		public node a { get { return _a; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("*");
			_a.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:splat . {a})";
		}
	}

	/* (:hash (k . v) (k . v)...) */
	class hash_node : node
	{
		public class kv_t
		{
			public node key;
			public node value;

			public kv_t(node key, node value)
			{
				this.key = key;
				this.value = value;
			}

			public override string ToString()
			{
				return $"({key} . {value})";
			}
		}
		kv_t[] _kvs = new kv_t[0];

		public hash_node(IMrbParser p, node a)
			: base(p, node_type.NODE_HASH)
		{
			while (a != null) {
				var kv = new kv_t((node)((node)a.car).car, (node)((node)a.car).cdr);
				_kvs.Push(kv);
				a = (node)a.cdr;
			}
		}

		public hash_node(IMrbParser p, kv_t[] items)
			: base(p, node_type.NODE_HASH)
		{
			_kvs = _kvs.Concat(items).ToArray();
		}

		public kv_t[] kvs { get { return _kvs; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			if (cond.nest != 0)
				cond.write("{");
			else
				cond.write_line("{");
			int i = _kvs.Length;
			foreach (var kv in _kvs) {
				kv.key.to_ruby(cond);
				cond.write(" => ");
				kv.value.to_ruby(cond);
				i--; if (i > 0) cond.write(", ");
			}
			if (cond.nest != 0)
				cond.write("}");
			else
				cond.write_line("}");
		}

		public override string ToString()
		{
			var str = $"(:hash ";
			foreach (var n in kvs) {
				str += $"{n} ";
			}
			return str + ")";
		}
	}

	/* (:sym . a) */
	class sym_node : node
	{
		private mrb_sym _name;

		public sym_node(IMrbParser p, mrb_sym sym)
			: base(p, node_type.NODE_SYM)
		{
			_name = sym;
		}

		public mrb_sym name { get { return _name; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "variables_get");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "VAR");
			field.AppendChild(cond.CreateTextNode(":" + p.sym2name(_name)));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(":" + p.sym2name(_name));
		}

		public override string ToString()
		{
			return $"(:sym . {p.sym2name(name)})";
		}
	}

	/* (:lvar . a) */
	class lvar_node : node
	{
		private mrb_sym _name;

		public lvar_node(IMrbParser p, mrb_sym sym)
			: base(p, node_type.NODE_LVAR)
		{
			_name = sym;
		}

		public mrb_sym name { get { return _name; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "variables_get");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "VAR");
			field.AppendChild(cond.CreateTextNode(p.sym2name(_name)));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(p.sym2name(_name));
		}

		public override string ToString()
		{
			return $"(:lvar . {p.sym2name(name)})";
		}
	}

	/* (:gvar . a) */
	class gvar_node : node
	{
		private mrb_sym _name;

		public gvar_node(IMrbParser p, mrb_sym sym)
			: base(p, node_type.NODE_GVAR)
		{
			_name = sym;
		}

		public mrb_sym name { get { return _name; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "variables_get");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "VAR");
			field.AppendChild(cond.CreateTextNode(p.sym2name(_name)));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(p.sym2name(_name));
		}

		public override string ToString()
		{
			return $"(:gvar . {p.sym2name(name)})";
		}
	}

	/* (:ivar . a) */
	class ivar_node : node
	{
		private mrb_sym _name;

		public ivar_node(IMrbParser p, mrb_sym sym)
			: base(p, node_type.NODE_IVAR)
		{
			_name = sym;
		}

		public mrb_sym name { get { return _name; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "variables_get");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "VAR");
			field.AppendChild(cond.CreateTextNode(p.sym2name(_name)));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(p.sym2name(_name));
		}

		public override string ToString()
		{
			return $"(:ivar . {p.sym2name(name)})";
		}
	}

	/* (:cvar . a) */
	class cvar_node : node
	{
		private mrb_sym _name;

		public cvar_node(IMrbParser p, mrb_sym sym)
			: base(p, node_type.NODE_CVAR)
		{
			_name = sym;
		}

		public mrb_sym name { get { return _name; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "variables_get");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "VAR");
			field.AppendChild(cond.CreateTextNode(p.sym2name(_name)));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(p.sym2name(_name));
		}

		public override string ToString()
		{
			return $"(:cvar . {p.sym2name(name)})";
		}
	}

	/* (:const . a) */
	class const_node : node
	{
		private mrb_sym _name;

		public const_node(IMrbParser p, mrb_sym sym)
			: base(p, node_type.NODE_CONST)
		{
			_name = sym;
		}

		public mrb_sym name { get { return _name; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "variables_get");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "VAR");
			field.AppendChild(cond.CreateTextNode(p.sym2name(_name)));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(p.sym2name(_name));
		}

		public override string ToString()
		{
			return $"(:const . {p.sym2name(name)})";
		}
	}

	/* (:undef a...) */
	class undef_node : node
	{
		private mrb_sym[] _syms = new mrb_sym[0];

		public undef_node(IMrbParser p, mrb_sym sym)
			: base(p, node_type.NODE_UNDEF)
		{
			_syms.Push(sym);
		}

		public mrb_sym[] syms { get { return _syms; } }

		public override void append(node b)
		{
			_syms.Push((mrb_sym)b.car);
		}

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("undef");
			int i = _syms.Length;
			if (i > 0)
				cond.write(" ");
			foreach (var sym in _syms) {
				cond.write(p.sym2name(sym));
				i--;
				if (i > 0)
					cond.write(", ");
			}
		}

		public override string ToString()
		{
			var str = "(:undef ";
			foreach (var n in syms) {
				str += $"{p.sym2name(n)}, ";
			}
			return str + ")";
		}
	}

	/* (:class class super body) */
	class class_node : node
	{
		private string _prefix;
		private node _type;
		private mrb_sym _name;
		private node _super;
		private mrb_sym _arg;
		private node _body;

		public class_node(IMrbParser p, node c, node s, node b)
			: base(p, node_type.NODE_CLASS)
		{
			if (c.car is int) {
				var type = (int)c.car;
				if (type == 0) {
					_prefix = ""/*":"*/;
					_name = (mrb_sym)c.cdr;
				}
				else if (type == 1) {
					_prefix = "::";
					_name = (mrb_sym)c.cdr;
				}
			}
			else {
				_prefix = "::";
				_type = (node)c.car;
				_name = (mrb_sym)c.cdr;
			}
			_super = s;
			var a = p.locals_node();
			_arg = (a.Length == 0) ? 0 : a[0];
			_body = b;
		}

		public class_node(IMrbParser p, mrb_sym name, node s, node b)
			: base(p, node_type.NODE_CLASS)
		{
			_prefix = "";
			_name = name;
			_super = s;
			_body = b;
		}

		public string prefix { get { return _prefix; } }
		public mrb_sym name { get { return _name; } }
		public node super { get { return _super; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			// TODO:クラス？
			var block = cond.CreateElement("class");
			block.SetAttribute("name", p.sym2name(_name));

			if (_super != null) {
				var field = cond.CreateElement("field");
				field.SetAttribute("name", "SUPER");
				field.AppendChild(_super.to_xml(cond));
				block.AppendChild(field);
			}

			var statement = cond.CreateElement("statement");
			statement.SetAttribute("name", "BODY");
			statement.AppendChild(_body.to_xml(cond));
			block.AppendChild(statement);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("class ");
			if (_type != null)
				_type.to_ruby(cond);
			if (_prefix != null)
				cond.write(_prefix);
			cond.write(p.sym2name(_name) + " ");
			if (_super != null) {
				cond.write("< ");
				if (_super != null)
					_super.to_ruby(cond);
			}
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("end");
		}

		public override string ToString()
		{
			return $"(:class {prefix}{p.sym2name(name)} {super} {body})";
		}
	}

	/* (:sclass obj body) */
	class sclass_node : node
	{
		private node _obj;
		private mrb_sym[] _super;
		private node _body;

		public sclass_node(IMrbParser p, node o, node b)
			: base(p, node_type.NODE_SCLASS)
		{
			_obj = o;
			_super = p.locals_node();
			_body = b;
		}

		public node obj { get { return _obj; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("class << ");
			_obj.to_ruby(cond);
			/*if (_super != null) {
				cond.write(">");
				_super.to_ruby(cond);
			}*/
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("end");
		}

		public override string ToString()
		{
			return $"(:sclass {obj} {body})";
		}
	}

	/* (:module module body) */
	class module_node : node
	{
		private string _prefix;
		private mrb_sym _name;
		private node _type;
		private mrb_sym[] _super;
		private node _body;

		public module_node(IMrbParser p, node m, node b)
			: base(p, node_type.NODE_MODULE)
		{
			if (m.car is int) {
				if ((int)m.car == 0) {
					_prefix = ""/*":"*/;
					_name = (mrb_sym)m.cdr;
				}
				else if ((int)m.car == 1) {
					_prefix = "::";
					_name = (mrb_sym)m.cdr;
				}
			}
			else {
				_prefix = "::";
				_type = (node)m.car;
				_name = (mrb_sym)m.cdr;
			}
			_super = p.locals_node();
			_body = b;
		}

		public string prefix { get { return _prefix; } }
		public mrb_sym name { get { return _name; } }
		public object type { get { return _type; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("module " + p.sym2name(_name) + " ");
			if (_super != null) {
				if (_type != null)
					_type.to_ruby(cond);
				foreach (var s in _super) {
					if (_prefix != null)
						cond.write(_prefix + "::");
					cond.write(p.sym2name(s));
				}
			}
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("end");
		}

		public override string ToString()
		{
			return $"(:module {prefix}{p.sym2name(name)} {body})";
		}
	}

	public class args_t
	{
		IMrbParser p;
		public mrb_sym name;
		public node arg;

		public args_t(IMrbParser p)
		{
			this.p = p;
		}

		public override string ToString()
		{
			return $"({p.sym2name(name)} {arg})";
		}

		internal void to_ruby(ruby_code_cond cond)
		{
			cond.write(p.sym2name(name));
			if (arg != null) {
				cond.write(" = ");
				arg.to_ruby(cond);
			}
		}
	}

	/* (:def m lv (arg . body)) */
	class def_node : node
	{
		private mrb_sym _name;
		private mrb_sym[] _local_variables = new mrb_sym[0];
		private arg_node[] _mandatory_args = new arg_node[0];
		private args_t[] _optional_args = new args_t[0];
		private mrb_sym _rest;
		private arg_node[] _post_mandatory_args = new arg_node[0];
		private mrb_sym _blk;
		private node _body;

		public def_node(IMrbParser p, mrb_sym m, node a, node b)
			: base(p, node_type.NODE_DEF)
		{
			_name = m;
			_local_variables = _local_variables.Concat(p.locals_node()).ToArray();
			if (a != null) {
				node n = a;

				if (n.car != null) {
					dump_recur(_mandatory_args, (node)n.car);
				}
				n = (node)n.cdr;
				if (n.car != null) {
					var n2 = (node)n.car;

					while (n2 != null) {
						var arg = new args_t(p);
						arg.name = (mrb_sym)((node)n2.car).car;
						arg.arg = (node)((node)n2.car).cdr;
						_optional_args.Push(arg);
						n2 = (node)n2.cdr;
					}
				}
				n = (node)n.cdr;
				if (n.car != null) {
					_rest = (mrb_sym)n.car;
				}
				n = (node)n.cdr;
				if (n.car != null) {
					dump_recur(_post_mandatory_args, (node)n.car);
				}
				if (n.cdr != null) {
					_blk = (mrb_sym)n.cdr;
				}
			}
			_body = b;
			if (_body is ensure_node) {
				((ensure_node)_body).def = true;
			}
		}

		public def_node(IMrbParser p, mrb_sym m, arg_node[] a, node b)
			: base(p, node_type.NODE_DEF)
		{
			_name = m;
			_mandatory_args = _mandatory_args.Concat(a).ToArray();
			_body = b;
		}

		public mrb_sym name { get { return _name; } }
		public mrb_sym[] local_variables { get { return _local_variables; } }
		public arg_node[] mandatory_args { get { return _mandatory_args; } }
		internal args_t[] optional_args { get { return _optional_args; } }
		public mrb_sym rest { get { return _rest; } }
		public arg_node[] post_mandatory_args { get { return _post_mandatory_args; } }
		public mrb_sym blk { get { return _blk; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "procedures_defreturn");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "NAME");
			field.AppendChild(cond.CreateTextNode(p.sym2name(_name)));
			block.AppendChild(field);

			Element bxml;
			if (_body != null && (bxml = _body.to_xml(cond)) != null) {
				var statement = cond.CreateElement("statement");
				statement.SetAttribute("name", "STACK");
				statement.AppendChild(bxml);
				block.AppendChild(statement);
			}

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("def " + p.sym2name(_name) + "(");
			int i = _mandatory_args.Length + _optional_args.Length
				+ (_rest != 0 ? 1 : 0) + _post_mandatory_args.Length
				+ (_blk != 0 ? 1 : 0);
			if (i > 0) {
				foreach (var a in _mandatory_args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				foreach (var a in _optional_args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (_rest != 0) {
					cond.write("*");
					if (_rest != (mrb_sym)(-1))
						cond.write(p.sym2name(_rest));
					i--; if (i > 0) cond.write(", ");
					foreach (var a in _post_mandatory_args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
				}
				if (_blk != 0) {
					cond.write("&" + p.sym2name(_blk));
				}
			}
			cond.write(")");
			cond.decrement_nest();
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("end");
		}

		public override string ToString()
		{
			var str = $"(:def {p.sym2name(name)} ";
			foreach (var n in local_variables) {
				str += $"{p.sym2name(n)}, ";
			}
			str += $" (";
			foreach (var n in mandatory_args) {
				str += $"{n}, ";
			}
			foreach (var n in optional_args) {
				str += $"{n}, ";
			}
			str += $"{p.sym2name(rest)}, ";
			foreach (var n in post_mandatory_args) {
				str += $"{n}, ";
			}
			str += $"{p.sym2name(blk)}, ";
			return str + $" . {body}))";
		}
	}

	/* (:sdef obj m lv (arg . body)) */
	class sdef_node : node
	{
		private node _obj;
		private mrb_sym _name;
		private mrb_sym[] _lv;
		private arg_node[] _mandatory_args = new arg_node[0];
		private args_t[] _optional_args = new args_t[0];
		private mrb_sym _rest;
		private arg_node[] _post_mandatory_args = new arg_node[0];
		private mrb_sym _blk;
		private node _body;

		public sdef_node(IMrbParser p, node o, mrb_sym m, node a, node b)
			: base(p, node_type.NODE_SDEF)
		{
			_obj = o;
			_name = m;
			_lv = p.locals_node();
			if (a != null) {
				node n = a;

				if (n.car != null) {
					dump_recur(_mandatory_args, (node)n.car);
				}
				n = (node)n.cdr;
				if (n.car != null) {
					var n2 = (node)n.car;

					while (n2 != null) {
						var arg = new args_t(p);
						arg.name = (mrb_sym)((node)n2.car).car;
						arg.arg = (node)((node)n2.car).cdr;
						_optional_args.Push(arg);
						n2 = (node)n2.cdr;
					}
				}
				n = (node)n.cdr;
				if (n.car != null) {
					_rest = (mrb_sym)n.car;
				}
				n = (node)n.cdr;
				if (n.car != null) {
					dump_recur(_post_mandatory_args, (node)n.car);
				}
				_blk = (mrb_sym)n.cdr;
			}
			_body = b;
		}

		public node obj { get { return _obj; } }
		public mrb_sym name { get { return _name; } }
		public arg_node[] mandatory_args { get { return _mandatory_args; } }
		internal args_t[] optional_args { get { return _optional_args; } }
		public mrb_sym rest { get { return _rest; } }
		public arg_node[] post_mandatory_args { get { return _post_mandatory_args; } }
		public mrb_sym blk { get { return _blk; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("def self." + p.sym2name(_name) + "(");
			int i = _mandatory_args.Length + _optional_args.Length
				+ (_rest != 0 ? 1 : 0) + _post_mandatory_args.Length
				+ (_blk != 0 ? 1 : 0);
			if (i > 0) {
				foreach (var a in _mandatory_args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				foreach (var a in _optional_args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (_rest != 0) {
					if (_rest == (mrb_sym)(-1))
						cond.write("*");
					else
						cond.write(p.sym2name(_rest));
					i--; if (i > 0) cond.write(", ");
					foreach (var a in _post_mandatory_args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
				}
				if (_blk != 0) {
					cond.write("&" + p.sym2name(_blk));
				}
			}
			cond.write(")");
			cond.decrement_nest();
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("end");
		}

		public override string ToString()
		{
			var str = $"(:sdef {obj} {p.sym2name(name)} (";
			foreach (var n in mandatory_args) {
				str += $"{n}, ";
			}
			foreach (var n in optional_args) {
				str += $"{n}, ";
			}
			str += $"{p.sym2name(rest)}, ";
			foreach (var n in post_mandatory_args) {
				str += $"{n}, ";
			}
			str += $"{p.sym2name(blk)}, ";
			return str + $" . {body}))";
		}
	}

	/* (:arg . sym) */
	class arg_node : node
	{
		private mrb_sym _name;

		public arg_node(IMrbParser p, mrb_sym sym)
			: base(p, node_type.NODE_ARG)
		{
			_name = sym;
		}

		public mrb_sym name { get { return _name; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(p.sym2name(_name));
		}

		public override string ToString()
		{
			return $"(:arg . {p.sym2name(name)})";
		}
	}

	/* (:block_arg . a) */
	class block_arg_node : node
	{
		private node _a;

		public block_arg_node(IMrbParser p, node a)
			: base(p, node_type.NODE_BLOCK_ARG)
		{
			_a = a;
		}

		public node a { get { return _a; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("&");
			_a.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:block_arg . {a})";
		}
	}

	/* (:block arg body) */
	class block_node : node
	{
		private mrb_sym[] _local_variables = new mrb_sym[0];
		private node[] _mandatory_args = new node[0];
		private args_t[] _optional_args = new args_t[0];
		private mrb_sym _rest;
		private node[] _post_mandatory_args = new node[0];
		private mrb_sym _blk;
		private node _body;
		private bool _brace;

		public block_node(IMrbParser p, node args, node body, bool brace)
			: base(p, node_type.NODE_BLOCK)
		{
			_local_variables = _local_variables.Concat(p.locals_node()).ToArray();
			if (args != null) {
				node n = args;

				if (n.car != null) {
					dump_recur(_mandatory_args, (node)n.car);
				}
				n = (node)n.cdr;
				if (n.car != null) {
					var n2 = (node)n.car;

					while (n2 != null) {
						var arg = new args_t(p);
						arg.name = (mrb_sym)((node)n2.car).car;
						arg.arg = (node)((node)n2.car).cdr;
						_optional_args.Push(arg);
						n2 = (node)n2.cdr;
					}
				}
				n = (node)n.cdr;
				if (n.car != null) {
					_rest = (mrb_sym)n.car;
				}
				n = (node)n.cdr;
				if (n.car != null) {
					dump_recur(_post_mandatory_args, (node)n.car);
				}
				if (n.cdr != null) {
					_blk = (mrb_sym)n.cdr;
				}
			}
			_body = body;
			if (_body is ensure_node) {
				((ensure_node)_body).def = true;
			}
			_brace = brace;
		}

		public block_node(IMrbParser p, node[] args, node body, bool brace)
			: base(p, node_type.NODE_BLOCK)
		{
			_mandatory_args = _mandatory_args.Concat(args).ToArray();
			_body = body;
			if (_body is ensure_node) {
				((ensure_node)_body).def = true;
			}
			_brace = brace;
		}

		public mrb_sym[] local_variables { get { return _local_variables; } }
		public node[] mandatory_args { get { return _mandatory_args; } }
		internal args_t[] optional_args { get { return _optional_args; } }
		public mrb_sym rest { get { return _rest; } }
		public node[] post_mandatory_args { get { return _post_mandatory_args; } }
		public mrb_sym blk { get { return _blk; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			string beg, end;
			if (_brace) {
				beg = " {";
				end = "}";
			}
			else {
				beg = " do";
				end = "end";
			}

			cond.increment_nest();
			cond.write(beg);
			int i = _mandatory_args.Length + _optional_args.Length
				+ (_rest != 0 ? 1 : 0) + _post_mandatory_args.Length
				+ (_blk != 0 ? 1 : 0);
			if (i > 0) {
				cond.write(" |");
				foreach (var a in _mandatory_args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				foreach (var a in _optional_args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (_rest != 0) {
					cond.write("*");
					if (_rest != (mrb_sym)(-1))
						cond.write(p.sym2name(_rest));
					i--; if (i > 0) cond.write(", ");
					foreach (var a in _post_mandatory_args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
				}
				if (_blk != 0) {
					cond.write("&" + p.sym2name(_blk));
				}
				cond.write("|");
			}
			cond.decrement_nest();
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line(end);
		}

		public override string ToString()
		{
			var str = $"(:block ";
			foreach (var n in mandatory_args) {
				str += $"{n}, ";
			}
			foreach (var n in optional_args) {
				str += $"{n}, ";
			}
			return str + $" . {body}))";
		}
	}

	/* (:lambda arg body) */
	class lambda_node : node
	{
		private mrb_sym[] _local_variables = new mrb_sym[0];
		private node[] _mandatory_args = new node[0];
		private args_t[] _optional_args = new args_t[0];
		private mrb_sym _rest;
		private node[] _post_mandatory_args = new node[0];
		private mrb_sym _blk;
		private node _body;

		public lambda_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_LAMBDA)
		{
			_local_variables = _local_variables.Concat(p.locals_node()).ToArray();
			if (a != null) {
				node n = a;

				if (n.car != null) {
					dump_recur(_mandatory_args, (node)n.car);
				}
				n = (node)n.cdr;
				if (n.car != null) {
					var n2 = (node)n.car;

					while (n2 != null) {
						var arg = new args_t(p);
						arg.name = (mrb_sym)((node)n2.car).car;
						arg.arg = (node)((node)n2.car).cdr;
						_optional_args.Push(arg);
						n2 = (node)n2.cdr;
					}
				}
				n = (node)n.cdr;
				if (n.car != null) {
					_rest = (mrb_sym)n.car;
				}
				n = (node)n.cdr;
				if (n.car != null) {
					dump_recur(_post_mandatory_args, (node)n.car);
				}
				if (n.cdr != null) {
					_blk = (mrb_sym)n.cdr;
				}
			}
			_body = b;
			if (_body is ensure_node) {
				((ensure_node)_body).def = true;
			}
		}

		public mrb_sym[] local_variables { get { return _local_variables; } }
		public node[] mandatory_args { get { return _mandatory_args; } }
		internal args_t[] optional_args { get { return _optional_args; } }
		public mrb_sym rest { get { return _rest; } }
		public node[] post_mandatory_args { get { return _post_mandatory_args; } }
		public mrb_sym blk { get { return _blk; } }
		public node body { get { return _body; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("{");
			int i = _mandatory_args.Length + _optional_args.Length
				+ (_rest != 0 ? 1 : 0) + _post_mandatory_args.Length
				+ (_blk != 0 ? 1 : 0);
			if (i > 0) {
				cond.write(" |");
				foreach (var a in _mandatory_args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				foreach (var a in _optional_args) {
					a.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (_rest != 0) {
					cond.write("*");
					if (_rest != (mrb_sym)(-1))
						cond.write(p.sym2name(_rest));
					i--; if (i > 0) cond.write(", ");
					foreach (var a in _post_mandatory_args) {
						a.to_ruby(cond);
						i--; if (i > 0) cond.write(", ");
					}
				}
				if (_blk != 0) {
					cond.write("&" + p.sym2name(_blk));
				}
				cond.write("|");
			}
			cond.decrement_nest();
			cond.increment_indent();
			_body.to_ruby(cond);
			cond.decrement_indent();
			cond.write_line("}");
		}

		public override string ToString()
		{
			var str = $"(:lambda ";
			foreach (var n in mandatory_args) {
				str += $"{n}, ";
			}
			foreach (var n in optional_args) {
				str += $"{n}, ";
			}
			return str + $" . {body}))";
		}
	}

	/* (:asgn lhs rhs) */
	class asgn_node : node
	{
		private node _lhs;
		private node _rhs;

		public asgn_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_ASGN)
		{
			_lhs = a;
			_rhs = b;
		}

		public node lhs { get { return _lhs; } }
		public node rhs { get { return _rhs; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "variables_set");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "VAR");
			switch ((node_type)_lhs.car) {
			case node_type.NODE_GVAR:
				field.AppendChild(cond.CreateTextNode(p.sym2name(((gvar_node)_lhs).name)));
				break;
			case node_type.NODE_CVAR:
				field.AppendChild(cond.CreateTextNode(p.sym2name(((cvar_node)_lhs).name)));
				break;
			case node_type.NODE_IVAR:
				field.AppendChild(cond.CreateTextNode(p.sym2name(((ivar_node)_lhs).name)));
				break;
			case node_type.NODE_LVAR:
				field.AppendChild(cond.CreateTextNode(p.sym2name(((lvar_node)_lhs).name)));
				break;
			default:
				// TODO: list[0] = ...？
				field.AppendChild(_lhs.to_xml(cond));
				break;
			}
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "VALUE");
			block.AppendChild(value);

			value.AppendChild(_rhs.to_xml(cond));

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			_lhs.to_ruby(cond);
			cond.write(" = ");
			_rhs.to_ruby(cond);
			cond.decrement_nest();
			cond.write_line();
		}

		public override string ToString()
		{
			return $"(:asgn {lhs} {rhs})";
		}
	}

	/* (:masgn mlhs=(pre rest post)  mrhs) */
	class masgn_node : node
	{
		public class mlhs_t
		{
			public node[] pre = new node[0];
			public node rest;
			public bool rest_empty;
			public node[] post = new node[0];

			public override string ToString()
			{
				var str = "(";
				foreach (var p in pre) {
					str += $"{p} ";
				}
				str += $"{rest} ";
				foreach (var p in post) {
					str += $"{p} ";
				}
				return str + ")";
			}

			internal void to_ruby(ruby_code_cond cond)
			{
				int i = pre.Length + (rest != null ? 1 : 0) + post.Length;
				foreach (var p in pre) {
					p.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				if (rest != null) {
					rest.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
				foreach (var p in post) {
					p.to_ruby(cond);
					i--; if (i > 0) cond.write(", ");
				}
			}
		}
		private mlhs_t _mlhs;
		private node _mrhs;

		public masgn_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_MASGN)
		{
			_mlhs = new mlhs_t();
			{
				node n2 = a;

				if (n2.car != null) {
					dump_recur(_mlhs.pre, (node)n2.car);
				}
				n2 = (node)n2.cdr;
				if (n2 != null) {
					if (n2.car != null) {
						if (n2.car is int && (int)n2.car == -1) {
							_mlhs.rest = null; //(empty)?
							_mlhs.rest_empty = true;
						}
						else {
							_mlhs.rest = (node)n2.car;
						}
					}
					n2 = (node)n2.cdr;
					if (n2 != null) {
						if (n2.car != null) {
							dump_recur(_mlhs.post, (node)n2.car);
						}
					}
				}
			}
			_mrhs = b;
		}

		public mlhs_t mlhs { get { return _mlhs; } }
		public node mrhs { get { return _mrhs; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			_mlhs.to_ruby(cond);
			cond.write(" = ");
			if (_mrhs != null)
				_mrhs.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:masgn {mlhs} {mrhs})";
		}

		internal bool remove(mrb_sym[] args)
		{
			bool m = false;
			foreach (var a in _mlhs.pre) {
				var arg = a as arg_node;
				if (arg != null) {
					var i = Array.IndexOf(args, arg.name);
					m = i >= 0;
					if (m)
						args.Splice(i, 1);
				}
				else {
					var masgn = a as masgn_node;
					m = masgn.remove(args);
				}
				if (m)
					return true;
			}
			if (_mlhs.rest != null) {
				var rest = _mlhs.rest as arg_node;
				if (rest != null) {
					var i = Array.IndexOf(args, rest.name);
					m = i >= 0;
					if (m) {
						args.Splice(i, 1);
						return true;
					}
				}
			}
			foreach (var a in _mlhs.post) {
				var arg = a as arg_node;
				if (arg != null) {
					var i = Array.IndexOf(args, arg.name);
					m = i >= 0;
					if (m)
						args.Splice(i, 1);
				}
				else {
					var masgn = a as masgn_node;
					m = masgn.remove(args);
				}
				if (m)
					return true;
			}
			return m;
		}
	}

	/* (:asgn lhs rhs) */
	class op_asgn_node : node
	{
		private node _lhs;
		private mrb_sym _op;
		private node _rhs;

		public op_asgn_node(IMrbParser p, node lhs, mrb_sym op, node rhs)
			: base(p, node_type.NODE_OP_ASGN)
		{
			_lhs = lhs;
			_op = op;
			_rhs = rhs;
		}

		public node lhs { get { return _lhs; } }
		public mrb_sym op { get { return _op; } }
		public node rhs { get { return _rhs; } }

		public override Element to_xml(xml_code_cond cond)
		{
			// TODO:Rubyの演算は数値だけとは限らない
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "math_arithmetic");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "OP");
			switch (p.sym2name(op)) {
			case "+": field.AppendChild(cond.CreateTextNode("ADD")); break;
			case "-": field.AppendChild(cond.CreateTextNode("MINUS")); break;
			case "*": field.AppendChild(cond.CreateTextNode("MULTIPLY")); break;
			case "/": field.AppendChild(cond.CreateTextNode("DIVIDE")); break;
			case "**": field.AppendChild(cond.CreateTextNode("POWER")); break;
			}
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "A");
			value.AppendChild(lhs.to_xml(cond));
			block.AppendChild(value);

			value = cond.CreateElement("value");
			value.SetAttribute("name", "B");
			value.AppendChild(rhs.to_xml(cond));
			block.AppendChild(value);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			_lhs.to_ruby(cond);
			cond.write(" " + p.sym2name(_op) + "= ");
			_rhs.to_ruby(cond);
			cond.decrement_nest();
			cond.write_line();
		}

		public override string ToString()
		{
			return $"(:asgn {lhs} {p.sym2name(op)} {rhs})";
		}
	}

	class negate_node : node
	{
		node _n;

		public negate_node(IMrbParser p, node n)
			: base(p, node_type.NODE_NEGATE)
		{
			this._n = n;
		}

		public node n { get { return _n; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "math_single");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "OP");
			field.AppendChild(cond.CreateTextNode("NEG"));
			block.AppendChild(field);

			var value = cond.CreateElement("value");
			value.SetAttribute("name", "NUM");
			value.AppendChild(_n.to_xml(cond));
			block.AppendChild(value);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("-");
			_n.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:nagete {n})";
		}
	}

	/* (:int . i) */
	class int_node : node, IEvaluatable
	{
		private Uint8Array _s;
		private int _base;

		public int_node(IMrbParser p, Uint8Array s, int @base)
			: base(p, node_type.NODE_INT)
		{
			_s = MrbParser.strdup(s, 0);
			_base = @base;
		}

		public int_node(IMrbParser p, int i, int @base = 10)
			: base(p, node_type.NODE_INT)
		{
			string str = "";
			switch (@base) {
			case 2:
				for (uint b = 0x80000000u; b != 0; b >>= 1) {
					str += (b & i) != 0 ? "1" : "0";
				}
				break;
			case 8:
				for (int s = 30; s > 0; s -= 3) {
					str = ((i << s) & 0xE).ToString() + str;
				}
				break;
			case 16:
				str = i.ToString("X");
				break;
			default:
				@base = 10;
				str = i.ToString();
				break;
			}
			_s = MrbParser.UTF8StringToArray(str);
			_base = @base;
		}

		public Uint8Array num { get { return _s; } }
		public int @base { get { return _base; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "math_number");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "NUM");
			field.AppendChild(cond.CreateTextNode(GetString()));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			switch (_base) {
			case 2:
				cond.write("0b" + MrbParser.UTF8ArrayToString(_s, 0));
				break;
			case 8:
				cond.write("0o" + MrbParser.UTF8ArrayToString(_s, 0));
				break;
			case 16:
				cond.write("0x" + MrbParser.UTF8ArrayToString(_s, 0));
				break;
			default:
				cond.write(MrbParser.UTF8ArrayToString(_s, 0));
				break;
			}
		}

		public override string ToString()
		{
			string num = GetString();
			return $"(:int . {num})";
		}

		private string GetString()
		{
			string num;

			switch (_base) {
			case 2:
				num = "0b" + MrbParser.UTF8ArrayToString(_s, 0);
				break;
			case 8:
				num = "0o" + MrbParser.UTF8ArrayToString(_s, 0);
				break;
			case 16:
				num = "0x" + MrbParser.UTF8ArrayToString(_s, 0);
				break;
			default:
				num = MrbParser.UTF8ArrayToString(_s, 0);
				break;
			}

			return num;
		}

		internal long to_i()
		{
			var str = MrbParser.UTF8ArrayToString(_s, 0);
			return Convert.ToInt64(str, _base);
		}

		public node evaluate(string method, node[] args)
		{
			if (args.Length != 1)
				return null;

			var arg = args[0];
			var a = to_i();

			if (arg is int_node) {
				var b = ((int_node)arg).to_i();

				switch (method) {
				case "+": {
						var c = MrbParser.UTF8StringToArray((a + b).ToString());
						return new int_node(p, c, 10);
					}
				case "-": {
						var c = MrbParser.UTF8StringToArray((a - b).ToString());
						return new int_node(p, c, 10);
					}
				case "*": {
						var c = MrbParser.UTF8StringToArray((a * b).ToString());
						return new int_node(p, c, 10);
					}
				case "/": {
						var c = MrbParser.UTF8StringToArray((a / b).ToString());
						return new int_node(p, c, 10);
					}
				case "%": {
						var c = MrbParser.UTF8StringToArray((a % b).ToString());
						return new int_node(p, c, 10);
					}
				case "==": {
						if (a == b)
							return new true_node(p);
						else
							return new false_node(p);
					}
				case "&": {
						var c = MrbParser.UTF8StringToArray((a & b).ToString());
						return new int_node(p, c, 10);
					}
				case "|": {
						var c = MrbParser.UTF8StringToArray((a | b).ToString());
						return new int_node(p, c, 10);
					}
				case "^": {
						var c = MrbParser.UTF8StringToArray((a ^ b).ToString());
						return new int_node(p, c, 10);
					}
				case "<<": {
						var c = MrbParser.UTF8StringToArray((a << (int)b).ToString());
						return new int_node(p, c, 10);
					}
				case ">>": {
						var c = MrbParser.UTF8StringToArray((a >> (int)b).ToString());
						return new int_node(p, c, 10);
					}
				}
			}
			else if (arg is float_node) {
				var b = ((float_node)arg).to_f();

				switch (method) {
				case "+": {
						var c = MrbParser.UTF8StringToArray((a + b).ToString());
						return new float_node(p, c);
					}
				case "-": {
						var c = MrbParser.UTF8StringToArray((a - b).ToString());
						return new float_node(p, c);
					}
				case "*": {
						var c = MrbParser.UTF8StringToArray((a * b).ToString());
						return new float_node(p, c);
					}
				case "/": {
						var c = MrbParser.UTF8StringToArray((a / b).ToString());
						return new float_node(p, c);
					}
				case "%": {
						var c = MrbParser.UTF8StringToArray((a % b).ToString());
						return new float_node(p, c);
					}
				case "==": {
						if (a == b)
							return new true_node(p);
						else
							return new false_node(p);
					}
				}
			}

			return null;
		}
	}

	/* (:float . i) */
	class float_node : node, IEvaluatable
	{
		private Uint8Array _s;

		public float_node(IMrbParser p, Uint8Array s)
			: base(p, node_type.NODE_FLOAT)
		{
			_s = MrbParser.strdup(s, 0);
		}

		public float_node(IMrbParser p, double f)
			: base(p, node_type.NODE_FLOAT)
		{
			_s = MrbParser.UTF8StringToArray(f.ToString());
		}

		public Uint8Array num { get { return _s; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "math_number");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "NUM");
			field.AppendChild(cond.CreateTextNode(MrbParser.UTF8ArrayToString(_s, 0)));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(MrbParser.UTF8ArrayToString(_s, 0));
		}

		public override string ToString()
		{
			return $"(:float . {num})";
		}

		internal double to_f()
		{
			var str = MrbParser.UTF8ArrayToString(_s, 0);
			return Convert.ToDouble(str);
		}

		public node evaluate(string method, node[] args)
		{
			if (args.Length != 1)
				return null;

			var arg = args[0];
			var a = to_f();

			if (arg is int_node) {
				var b = ((int_node)arg).to_i();

				switch (method) {
				case "+": {
						var c = MrbParser.UTF8StringToArray((a + b).ToString());
						return new float_node(p, c);
					}
				case "-": {
						var c = MrbParser.UTF8StringToArray((a - b).ToString());
						return new float_node(p, c);
					}
				case "*": {
						var c = MrbParser.UTF8StringToArray((a * b).ToString());
						return new float_node(p, c);
					}
				case "/": {
						var c = MrbParser.UTF8StringToArray((a / b).ToString());
						return new float_node(p, c);
					}
				case "%": {
						var c = MrbParser.UTF8StringToArray((a % b).ToString());
						return new float_node(p, c);
					}
				case "==": {
						if (a == b)
							return new true_node(p);
						else
							return new false_node(p);
					}
				}
			}
			else if (arg is float_node) {
				var b = ((float_node)arg).to_f();

				switch (method) {
				case "+": {
						var c = MrbParser.UTF8StringToArray((a + b).ToString());
						return new float_node(p, c);
					}
				case "-": {
						var c = MrbParser.UTF8StringToArray((a - b).ToString());
						return new float_node(p, c);
					}
				case "*": {
						var c = MrbParser.UTF8StringToArray((a * b).ToString());
						return new float_node(p, c);
					}
				case "/": {
						var c = MrbParser.UTF8StringToArray((a / b).ToString());
						return new float_node(p, c);
					}
				case "%": {
						var c = MrbParser.UTF8StringToArray((a % b).ToString());
						return new float_node(p, c);
					}
				case "==": {
						if (a == b)
							return new true_node(p);
						else
							return new false_node(p);
					}
				}
			}

			return null;
		}
	}

	/* (:str . (s . len)) */
	class str_node : node, IEvaluatable
	{
		private Uint8Array _str;
		private int _len;

		public str_node(IMrbParser p, Uint8Array s, int len)
			: base(p, node_type.NODE_STR)
		{
			_str = MrbParser.strndup(s, 0, len);
			_len = len;
		}

		public str_node(IMrbParser p, string s)
			: base(p, node_type.NODE_STR)
		{
			_str = MrbParser.UTF8StringToArray(s);
			_len = _str.Length;
		}

		public Uint8Array str { get { return _str; } }
		public int len { get { return _len; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "text");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "TEXT");
			field.AppendChild(cond.CreateTextNode(MrbParser.UTF8ArrayToString(_str, 0)));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			bool esc;
			var str = MrbParser.UTF8ArrayToStringEsc(_str, 0, out esc);
			if (esc)
				cond.write("\"" + str.Replace("\"", "\\\"") + "\"");
			else
				cond.write("'" + str.Replace("'", "\\'") + "'");
		}

		public override string ToString()
		{
			return $"(:str . ('{str}' . {len}))";
		}

		public string to_s()
		{
			return MrbParser.UTF8ArrayToString(_str, 0);
		}

		public node evaluate(string method, node[] args)
		{
			var s = to_s();

			switch (method) {
			case "<=>": {
					if ((args.Length != 1) || !(args[0] is str_node))
						break;
					var c = MrbParser.UTF8StringToArray(String.Compare(s, ((str_node)args[0]).to_s()).ToString());
					return new int_node(p, c, 10);
				}
			case "==": {
					if ((args.Length != 1) || !(args[0] is str_node))
						break;
					if (String.Compare(s, ((str_node)args[0]).to_s()) == 0)
						return new true_node(p);
					else
						return new true_node(p);
				}
			case "+": {
					if ((args.Length != 1) || !(args[0] is str_node))
						break;
					var t = MrbParser.UTF8StringToArray(s + ((str_node)args[0]).to_s());
					return new str_node(p, t, t.Length - 1);
				}
			case "*": {
					int a;
					if (args.Length != 1)
						break;
					if (args[0] is int_node)
						a = (int)((int_node)args[0]).to_i();
					else if (args[0] is float_node)
						a = (int)((float_node)args[0]).to_f();
					else
						break;
					var sb = new StringBuilder();
					for (var i = 0; i < a; i++) {
						sb.Append(a);
					}
					var t = MrbParser.UTF8StringToArray(sb.ToString());
					return new str_node(p, t, t.Length - 1);
				}
			}

			return null;
		}
	}

	/* (:dstr . a) */
	class dstr_node : node
	{
		private node[] _a = new node[0];

		public dstr_node(IMrbParser p, node a)
			: base(p, node_type.NODE_DSTR)
		{
			dump_recur(_a, a);
		}

		public node[] a { get { return _a; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.increment_nest();
			cond.write("\"");
			foreach (var i in _a) {
				var s = i as str_node;
				if (s != null) {
					var str = MrbParser.UTF8ArrayToString(s.str, 0);
					cond.write(str.Replace("\"", "\\\""));
				}
				else {
					cond.write("#{");
					i.to_ruby(cond);
					cond.write("}");
				}
			}
			cond.write("\"");
			cond.decrement_nest();
		}

		public override string ToString()
		{
			var str = $"(:dstr . ";
			foreach (var n in a) {
				str += $"{n} ";
			}
			return str + ")";
		}
	}

	/* (:str . (s . len)) */
	class xstr_node : node
	{
		private Uint8Array _str;
		private int _len;

		public xstr_node(IMrbParser p, Uint8Array s, int len)
			: base(p, node_type.NODE_XSTR)
		{
			_str = MrbParser.strndup(s, 0, len);
			_len = len;
		}

		public Uint8Array str { get { return _str; } }
		public int len { get { return _len; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("%x(");
			cond.write(MrbParser.UTF8ArrayToString(_str, 0));
			cond.write(")");
		}

		public override string ToString()
		{
			return $"(:str . ({str} . {len}))";
		}
	}

	/* (:xstr . a) */
	class dxstr_node : node
	{
		private node[] _a = new node[0];

		public dxstr_node(IMrbParser p, node a)
			: base(p, node_type.NODE_DXSTR)
		{
			dump_recur(_a, a);
		}

		public node[] a { get { return _a; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			foreach (var i in _a) {
				i.to_ruby(cond);
			}
		}

		public override string ToString()
		{
			var str = $"(:xstr . ";
			foreach (var n in a) {
				str += $"{n} ";
			}
			return str + ")";
		}
	}

	/* (:dsym . a) */
	class dsym_node : node
	{
		private dstr_node _a;

		public dsym_node(IMrbParser p, node a)
			: base(p, node_type.NODE_DSYM)
		{
			_a = new dstr_node(p, a);
		}

		public node[] a { get { return _a.a; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(":");
			_a.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:dsym . {a})";
		}
	}

	/* (:regx . (a . a)) */
	class regx_node : node
	{
		Uint8Array _pattern;
		Uint8Array _flags;
		Uint8Array _encp;

		public regx_node(IMrbParser p, Uint8Array pattern, Uint8Array flags, Uint8Array encp)
			: base(p, node_type.NODE_REGX)
		{
			_pattern = pattern;
			_flags = flags;
			_encp = encp;
		}

		public Uint8Array pattern { get { return _pattern; } }
		public Uint8Array flags { get { return _flags; } }
		public Uint8Array encp { get { return _encp; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("/" + MrbParser.UTF8ArrayToString(_pattern, 0));
			cond.write("/" + MrbParser.UTF8ArrayToString(_flags, 0));
			cond.write("/" + MrbParser.UTF8ArrayToString(_encp, 0));
			cond.write("/");
		}

		public override string ToString()
		{
			return $"(:regx . ({pattern} . {flags} . {encp}))";
		}
	}

	/* (:dregx . a) */
	class dregx_node : node
	{
		private node[] _a = new node[0];
		private Uint8Array _opt;
		private Uint8Array _tail;

		public dregx_node(IMrbParser p, node a, node b)
			: base(p, node_type.NODE_DREGX)
		{
			dump_recur(_a, a);
			_tail = (Uint8Array)((node)b.cdr).car;
			_opt = (Uint8Array)((node)b.cdr).cdr;
		}

		public node[] a { get { return _a; } }
		public Uint8Array opt { get { return _opt; } }
		public Uint8Array tail { get { return _tail; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			foreach (var i in _a) {
				i.to_ruby(cond);
			}
			cond.write(MrbParser.UTF8ArrayToString(_opt, 0));
			cond.write(MrbParser.UTF8ArrayToString(_tail, 0));
		}

		public override string ToString()
		{
			var str = $"(:dregx . ";
			foreach (var n in a) {
				str += $"{n} ";
			}
			return str + $"{opt} {tail})";
		}
	}

	/* (:backref . n) */
	class back_ref_node : node
	{
		private int _n;

		public back_ref_node(IMrbParser p, int n)
			: base(p, node_type.NODE_BACK_REF)
		{
			_n = n;
		}

		public int n { get { return _n; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(n.ToString());
		}

		public override string ToString()
		{
			return $"(:backref . {n})";
		}
	}

	/* (:nthref . n) */
	class nth_ref_node : node
	{
		private int _n;

		public nth_ref_node(IMrbParser p, int n)
			: base(p, node_type.NODE_NTH_REF)
		{
			_n = n;
		}

		public int n { get { return _n; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write(n.ToString());
		}

		public override string ToString()
		{
			return $"(:nthref . {n})";
		}
	}

	/* (:heredoc . a) */
	class heredoc_node : node
	{
		private parser_heredoc_info _info;

		public heredoc_node(IMrbParser p)
			: base(p, node_type.NODE_HEREDOC)
		{
			_info = new parser_heredoc_info();
		}

		public parser_heredoc_info info { get { return _info; } }

		public override Element to_xml(xml_code_cond cond)
		{
			var block = cond.CreateElement("block");
			block.SetAttribute("type", "text");

			var field = cond.CreateElement("field");
			field.SetAttribute("name", "TEXT");
			field.AppendChild(cond.CreateTextNode(info.GetString()));
			block.AppendChild(field);

			return block;
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			_info.to_ruby(cond);
		}

		public override string ToString()
		{
			return $"(:heredoc . {info})";
		}
	}

	class literal_delim_node : node
	{
		public literal_delim_node(IMrbParser p)
			: base(p, node_type.NODE_LITERAL_DELIM)
		{
		}

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
		}

		public override string ToString()
		{
			return $"(:literal_delim)";
		}
	}

	/* (:words . a) */
	class words_node : node
	{
		private node[] _a = new node[0];

		public words_node(IMrbParser p, node a)
			: base(p, node_type.NODE_WORDS)
		{
			dump_recur(_a, a);
		}

		public node[] a { get { return _a; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("%w(");
			foreach (var i in _a) {
				i.to_ruby(cond);
			}
			cond.write(")");
		}

		public override string ToString()
		{
			return $"(:words . {a})";
		}
	}

	/* (:symbols . a) */
	class symbols_node : node
	{
		private node[] _a = new node[0];

		public symbols_node(IMrbParser p, node a)
			: base(p, node_type.NODE_SYMBOLS)
		{
			dump_recur(_a, a);
		}

		public node[] a { get { return _a; } }

		public override Element to_xml(xml_code_cond cond)
		{
			throw new NotImplementedException();
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("%i{");
			foreach (var i in _a) {
				i.to_ruby(cond);
			}
			cond.write("}");
		}

		public override string ToString()
		{
			return $"(:symbols . {a})";
		}
	}

	class filename_node : str_node
	{
		public filename_node(IMrbParser p, Uint8Array s, int len)
			: base(p, s, len)
		{
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("__FILE__");
		}
	}

	class lineno_node : int_node
	{
		public lineno_node(IMrbParser p, int lineno)
			: base(p, MrbParser.UTF8StringToArray(lineno.ToString()), 10)
		{
		}

		protected override void to_rb(ruby_code_cond cond)
		{
			cond.write("__LINE__");
		}
	}
}
