netruby/netruby/parser.cs

// created by jay 0.7 (c) 1998 Axel.Schreiner@informatik.uni-osnabrueck.de

#line 21 "parse.y"
    
using System;
using System.Collections;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Reflection;

namespace arton.NETRuby
{
    public class Parser
    {
        public interface Lexer
        {
            EXPR State
            {
                get;
                set;
            }
            void COND_PUSH();
            void COND_POP();
            void CMDARG_PUSH();
            void CMDARG_POP();
        }

        public Parser(NetRuby rb, RThread th, bool in_eval)
        {
            evalTree = null;
            ruby = rb;
            thread = th;
            compile_for_eval = in_eval;
        }

        public Parser(NetRuby rb)
        {
            evalTree = null;
            ruby = rb;
            thread = rb.GetCurrentContext();
            compile_for_eval = false;
        }

        public object Parse(Lexer lexer)
        {
            evalTree = null;
            lex = lexer;
            object n = yyparse((yyParser.yyInput)lex, new yydebug.yyDebugSimple());
            if (n == null)
                return evalTree;
            return null;
        }
        
        private Lexer lex;
        internal RNode evalTree;

        internal enum ID
        {
            SCOPE_SHIFT = 3,
            SCOPE_MASK = 7,
            LOCAL = 1,
            INSTANCE = 2,
            GLOBAL = 3,
            ATTRSET = 4,
            CONST = 5,
            CLASS = 6,
        }

        internal string sourcefile
        {
            get { return thread.file; }
        }
        internal int sourceline
        {
            get { return thread.line; }
            set { thread.line = value; }
        }

        public NetRuby ruby;
        internal RThread thread;
        internal bool verbose
        {
            get { return ruby.verbose; }
        }
        internal void warn(string s)
        {
            ruby.warn(s);
        }

        internal uint[] Locals
        {
            get { return thread.Locals; }
        }
        
        private int class_nest = 0;
        private int in_single = 0;
        private int in_def = 0;
        private bool compile_for_eval = false;
        private uint cur_mid = 0;
        private bool in_defined = false;

#line 104 "-"

  /** simplified error message.
      @see <a href="#yyerror(java.lang.String, java.lang.String[])">yyerror</a>
    */
  public void yyerror (string message) {
    yyerror(message, null);
  }

  /** (syntax) error message.
      Can be overwritten to control message format.
      @param message text to be displayed.
      @param expected vector of acceptable tokens, if available.
    */
  public void yyerror (string message, string[] expected) {
    if ((expected != null) && (expected.Length  > 0)) {
      StringBuilder sb = new StringBuilder();    
      sb.AppendFormat("{0}, expecting", message);
      for (int n = 0; n < expected.Length; ++ n)
        sb.AppendFormat(" {0}", expected[n]);
        thread.CompileError(sb.ToString());
    } else
      thread.CompileError (message);
  }

  /** debugging support, requires the package jay.yydebug.
      Set to null to suppress debugging messages.
    */
//t  protected yydebug.yyDebug yydebug;

  protected static  int yyFinal = 1;
//t  public static  string [] yyRule = {
//t    "$accept : program",
//t    "$$1 :",
//t    "program : $$1 compstmt",
//t    "compstmt : stmts opt_terms",
//t    "stmts : none",
//t    "stmts : stmt",
//t    "stmts : stmts terms stmt",
//t    "stmts : error stmt",
//t    "$$2 :",
//t    "stmt : kALIAS fitem $$2 fitem",
//t    "stmt : kALIAS tGVAR tGVAR",
//t    "stmt : kALIAS tGVAR tBACK_REF",
//t    "stmt : kALIAS tGVAR tNTH_REF",
//t    "stmt : kUNDEF undef_list",
//t    "stmt : stmt kIF_MOD expr",
//t    "stmt : stmt kUNLESS_MOD expr",
//t    "stmt : stmt kWHILE_MOD expr",
//t    "stmt : stmt kUNTIL_MOD expr",
//t    "stmt : stmt kRESCUE_MOD stmt",
//t    "$$3 :",
//t    "stmt : klBEGIN $$3 '{' compstmt '}'",
//t    "stmt : klEND '{' compstmt '}'",
//t    "stmt : lhs '=' command_call",
//t    "stmt : mlhs '=' command_call",
//t    "stmt : lhs '=' mrhs_basic",
//t    "stmt : expr",
//t    "expr : mlhs '=' mrhs",
//t    "expr : kRETURN ret_args",
//t    "expr : command_call",
//t    "expr : expr kAND expr",
//t    "expr : expr kOR expr",
//t    "expr : kNOT expr",
//t    "expr : '!' command_call",
//t    "expr : arg",
//t    "command_call : command",
//t    "command_call : block_command",
//t    "block_command : block_call",
//t    "block_command : block_call '.' operation2 command_args",
//t    "block_command : block_call tCOLON2 operation2 command_args",
//t    "command : operation command_args",
//t    "command : primary '.' operation2 command_args",
//t    "command : primary tCOLON2 operation2 command_args",
//t    "command : kSUPER command_args",
//t    "command : kYIELD ret_args",
//t    "mlhs : mlhs_basic",
//t    "mlhs : tLPAREN mlhs_entry ')'",
//t    "mlhs_entry : mlhs_basic",
//t    "mlhs_entry : tLPAREN mlhs_entry ')'",
//t    "mlhs_basic : mlhs_head",
//t    "mlhs_basic : mlhs_head mlhs_item",
//t    "mlhs_basic : mlhs_head tSTAR mlhs_node",
//t    "mlhs_basic : mlhs_head tSTAR",
//t    "mlhs_basic : tSTAR mlhs_node",
//t    "mlhs_basic : tSTAR",
//t    "mlhs_item : mlhs_node",
//t    "mlhs_item : tLPAREN mlhs_entry ')'",
//t    "mlhs_head : mlhs_item ','",
//t    "mlhs_head : mlhs_head mlhs_item ','",
//t    "mlhs_node : variable",
//t    "mlhs_node : primary '[' aref_args ']'",
//t    "mlhs_node : primary '.' tIDENTIFIER",
//t    "mlhs_node : primary tCOLON2 tIDENTIFIER",
//t    "mlhs_node : primary '.' tCONSTANT",
//t    "mlhs_node : backref",
//t    "lhs : variable",
//t    "lhs : primary '[' aref_args ']'",
//t    "lhs : primary '.' tIDENTIFIER",
//t    "lhs : primary tCOLON2 tIDENTIFIER",
//t    "lhs : primary '.' tCONSTANT",
//t    "lhs : backref",
//t    "cname : tIDENTIFIER",
//t    "cname : tCONSTANT",
//t    "fname : tIDENTIFIER",
//t    "fname : tCONSTANT",
//t    "fname : tFID",
//t    "fname : op",
//t    "fname : reswords",
//t    "fitem : fname",
//t    "fitem : symbol",
//t    "undef_list : fitem",
//t    "$$4 :",
//t    "undef_list : undef_list ',' $$4 fitem",
//t    "op : '|'",
//t    "op : '^'",
//t    "op : '&'",
//t    "op : tCMP",
//t    "op : tEQ",
//t    "op : tEQQ",
//t    "op : tMATCH",
//t    "op : '>'",
//t    "op : tGEQ",
//t    "op : '<'",
//t    "op : tLEQ",
//t    "op : tLSHFT",
//t    "op : tRSHFT",
//t    "op : '+'",
//t    "op : '-'",
//t    "op : '*'",
//t    "op : tSTAR",
//t    "op : '/'",
//t    "op : '%'",
//t    "op : tPOW",
//t    "op : '~'",
//t    "op : tUPLUS",
//t    "op : tUMINUS",
//t    "op : tAREF",
//t    "op : tASET",
//t    "op : '`'",
//t    "reswords : k__LINE__",
//t    "reswords : k__FILE__",
//t    "reswords : klBEGIN",
//t    "reswords : klEND",
//t    "reswords : kALIAS",
//t    "reswords : kAND",
//t    "reswords : kBEGIN",
//t    "reswords : kBREAK",
//t    "reswords : kCASE",
//t    "reswords : kCLASS",
//t    "reswords : kDEF",
//t    "reswords : kDEFINED",
//t    "reswords : kDO",
//t    "reswords : kELSE",
//t    "reswords : kELSIF",
//t    "reswords : kEND",
//t    "reswords : kENSURE",
//t    "reswords : kFALSE",
//t    "reswords : kFOR",
//t    "reswords : kIF_MOD",
//t    "reswords : kIN",
//t    "reswords : kMODULE",
//t    "reswords : kNEXT",
//t    "reswords : kNIL",
//t    "reswords : kNOT",
//t    "reswords : kOR",
//t    "reswords : kREDO",
//t    "reswords : kRESCUE",
//t    "reswords : kRETRY",
//t    "reswords : kRETURN",
//t    "reswords : kSELF",
//t    "reswords : kSUPER",
//t    "reswords : kTHEN",
//t    "reswords : kTRUE",
//t    "reswords : kUNDEF",
//t    "reswords : kUNLESS_MOD",
//t    "reswords : kUNTIL_MOD",
//t    "reswords : kWHEN",
//t    "reswords : kWHILE_MOD",
//t    "reswords : kYIELD",
//t    "reswords : kRESCUE_MOD",
//t    "arg : lhs '=' arg",
//t    "$$5 :",
//t    "arg : variable tOP_ASGN $$5 arg",
//t    "arg : primary '[' aref_args ']' tOP_ASGN arg",
//t    "arg : primary '.' tIDENTIFIER tOP_ASGN arg",
//t    "arg : primary '.' tCONSTANT tOP_ASGN arg",
//t    "arg : primary tCOLON2 tIDENTIFIER tOP_ASGN arg",
//t    "arg : backref tOP_ASGN arg",
//t    "arg : arg tDOT2 arg",
//t    "arg : arg tDOT3 arg",
//t    "arg : arg '+' arg",
//t    "arg : arg '-' arg",
//t    "arg : arg '*' arg",
//t    "arg : arg '/' arg",
//t    "arg : arg '%' arg",
//t    "arg : arg tPOW arg",
//t    "arg : tUPLUS arg",
//t    "arg : tUMINUS arg",
//t    "arg : arg '|' arg",
//t    "arg : arg '^' arg",
//t    "arg : arg '&' arg",
//t    "arg : arg tCMP arg",
//t    "arg : arg '>' arg",
//t    "arg : arg tGEQ arg",
//t    "arg : arg '<' arg",
//t    "arg : arg tLEQ arg",
//t    "arg : arg tEQ arg",
//t    "arg : arg tEQQ arg",
//t    "arg : arg tNEQ arg",
//t    "arg : arg tMATCH arg",
//t    "arg : arg tNMATCH arg",
//t    "arg : '!' arg",
//t    "arg : '~' arg",
//t    "arg : arg tLSHFT arg",
//t    "arg : arg tRSHFT arg",
//t    "arg : arg tANDOP arg",
//t    "arg : arg tOROP arg",
//t    "$$6 :",
//t    "arg : kDEFINED opt_nl $$6 arg",
//t    "arg : arg '?' arg ':' arg",
//t    "arg : primary",
//t    "aref_args : none",
//t    "aref_args : command_call opt_nl",
//t    "aref_args : args ',' command_call opt_nl",
//t    "aref_args : args trailer",
//t    "aref_args : args ',' tSTAR arg opt_nl",
//t    "aref_args : assocs trailer",
//t    "aref_args : tSTAR arg opt_nl",
//t    "paren_args : '(' none ')'",
//t    "paren_args : '(' call_args opt_nl ')'",
//t    "paren_args : '(' block_call opt_nl ')'",
//t    "paren_args : '(' args ',' block_call opt_nl ')'",
//t    "opt_paren_args : none",
//t    "opt_paren_args : paren_args",
//t    "call_args : command",
//t    "call_args : args ',' command",
//t    "call_args : args opt_block_arg",
//t    "call_args : args ',' tSTAR arg opt_block_arg",
//t    "call_args : assocs opt_block_arg",
//t    "call_args : assocs ',' tSTAR arg opt_block_arg",
//t    "call_args : args ',' assocs opt_block_arg",
//t    "call_args : args ',' assocs ',' tSTAR arg opt_block_arg",
//t    "call_args : tSTAR arg opt_block_arg",
//t    "call_args : block_arg",
//t    "$$7 :",
//t    "command_args : $$7 call_args",
//t    "block_arg : tAMPER arg",
//t    "opt_block_arg : ',' block_arg",
//t    "opt_block_arg : none",
//t    "args : arg",
//t    "args : args ',' arg",
//t    "mrhs : arg",
//t    "mrhs : mrhs_basic",
//t    "mrhs_basic : args ',' arg",
//t    "mrhs_basic : args ',' tSTAR arg",
//t    "mrhs_basic : tSTAR arg",
//t    "ret_args : call_args",
//t    "primary : literal",
//t    "primary : string",
//t    "primary : tXSTRING",
//t    "primary : tQWORDS",
//t    "primary : tDXSTRING",
//t    "primary : tDREGEXP",
//t    "primary : var_ref",
//t    "primary : backref",
//t    "primary : tFID",
//t    "primary : kBEGIN compstmt rescue opt_else ensure kEND",
//t    "primary : tLPAREN compstmt ')'",
//t    "primary : primary tCOLON2 tCONSTANT",
//t    "primary : tCOLON3 cname",
//t    "primary : primary '[' aref_args ']'",
//t    "primary : tLBRACK aref_args ']'",
//t    "primary : tLBRACE assoc_list '}'",
//t    "primary : kRETURN '(' ret_args ')'",
//t    "primary : kRETURN '(' ')'",
//t    "primary : kRETURN",
//t    "primary : kYIELD '(' ret_args ')'",
//t    "primary : kYIELD '(' ')'",
//t    "primary : kYIELD",
//t    "$$8 :",
//t    "primary : kDEFINED opt_nl '(' $$8 expr ')'",
//t    "primary : operation brace_block",
//t    "primary : method_call",
//t    "primary : method_call brace_block",
//t    "primary : kIF expr then compstmt if_tail kEND",
//t    "primary : kUNLESS expr then compstmt opt_else kEND",
//t    "$$9 :",
//t    "$$10 :",
//t    "primary : kWHILE $$9 expr do $$10 compstmt kEND",
//t    "$$11 :",
//t    "$$12 :",
//t    "primary : kUNTIL $$11 expr do $$12 compstmt kEND",
//t    "primary : kCASE expr opt_terms case_body kEND",
//t    "primary : kCASE opt_terms case_body kEND",
//t    "$$13 :",
//t    "$$14 :",
//t    "primary : kFOR block_var kIN $$13 expr do $$14 compstmt kEND",
//t    "$$15 :",
//t    "primary : kCLASS cname superclass $$15 compstmt kEND",
//t    "$$16 :",
//t    "$$17 :",
//t    "primary : kCLASS tLSHFT expr $$16 term $$17 compstmt kEND",
//t    "$$18 :",
//t    "primary : kMODULE cname $$18 compstmt kEND",
//t    "$$19 :",
//t    "primary : kDEF fname $$19 f_arglist compstmt rescue opt_else ensure kEND",
//t    "$$20 :",
//t    "$$21 :",
//t    "primary : kDEF singleton dot_or_colon $$20 fname $$21 f_arglist compstmt rescue opt_else ensure kEND",
//t    "primary : kBREAK",
//t    "primary : kNEXT",
//t    "primary : kREDO",
//t    "primary : kRETRY",
//t    "then : term",
//t    "then : kTHEN",
//t    "then : term kTHEN",
//t    "do : term",
//t    "do : kDO_COND",
//t    "if_tail : opt_else",
//t    "if_tail : kELSIF expr then compstmt if_tail",
//t    "opt_else : none",
//t    "opt_else : kELSE compstmt",
//t    "block_var : lhs",
//t    "block_var : mlhs",
//t    "opt_block_var : none",
//t    "opt_block_var : '|' '|'",
//t    "opt_block_var : tOROP",
//t    "opt_block_var : '|' block_var '|'",
//t    "$$22 :",
//t    "do_block : kDO_BLOCK $$22 opt_block_var compstmt kEND",
//t    "block_call : command do_block",
//t    "block_call : block_call '.' operation2 opt_paren_args",
//t    "block_call : block_call tCOLON2 operation2 opt_paren_args",
//t    "method_call : operation paren_args",
//t    "method_call : primary '.' operation2 opt_paren_args",
//t    "method_call : primary tCOLON2 operation2 paren_args",
//t    "method_call : primary tCOLON2 operation3",
//t    "method_call : kSUPER paren_args",
//t    "method_call : kSUPER",
//t    "$$23 :",
//t    "brace_block : '{' $$23 opt_block_var compstmt '}'",
//t    "$$24 :",
//t    "brace_block : kDO $$24 opt_block_var compstmt kEND",
//t    "case_body : kWHEN when_args then compstmt cases",
//t    "when_args : args",
//t    "when_args : args ',' tSTAR arg",
//t    "when_args : tSTAR arg",
//t    "cases : opt_else",
//t    "cases : case_body",
//t    "exc_list : none",
//t    "exc_list : args",
//t    "exc_var : tASSOC lhs",
//t    "exc_var : none",
//t    "rescue : kRESCUE exc_list exc_var then compstmt rescue",
//t    "rescue : none",
//t    "ensure : none",
//t    "ensure : kENSURE compstmt",
//t    "literal : numeric",
//t    "literal : symbol",
//t    "literal : tREGEXP",
//t    "string : tSTRING",
//t    "string : tDSTRING",
//t    "string : string tSTRING",
//t    "string : string tDSTRING",
//t    "symbol : tSYMBEG sym",
//t    "sym : fname",
//t    "sym : tIVAR",
//t    "sym : tGVAR",
//t    "sym : tCVAR",
//t    "numeric : tINTEGER",
//t    "numeric : tFLOAT",
//t    "variable : tIDENTIFIER",
//t    "variable : tIVAR",
//t    "variable : tGVAR",
//t    "variable : tCONSTANT",
//t    "variable : tCVAR",
//t    "variable : kNIL",
//t    "variable : kSELF",
//t    "variable : kTRUE",
//t    "variable : kFALSE",
//t    "variable : k__FILE__",
//t    "variable : k__LINE__",
//t    "var_ref : variable",
//t    "backref : tNTH_REF",
//t    "backref : tBACK_REF",
//t    "superclass : term",
//t    "$$25 :",
//t    "superclass : '<' $$25 expr term",
//t    "superclass : error term",
//t    "f_arglist : '(' f_args opt_nl ')'",
//t    "f_arglist : f_args term",
//t    "f_args : f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg",
//t    "f_args : f_arg ',' f_optarg opt_f_block_arg",
//t    "f_args : f_arg ',' f_rest_arg opt_f_block_arg",
//t    "f_args : f_arg opt_f_block_arg",
//t    "f_args : f_optarg ',' f_rest_arg opt_f_block_arg",
//t    "f_args : f_optarg opt_f_block_arg",
//t    "f_args : f_rest_arg opt_f_block_arg",
//t    "f_args : f_block_arg",
//t    "f_args :",
//t    "f_norm_arg : tCONSTANT",
//t    "f_norm_arg : tIVAR",
//t    "f_norm_arg : tGVAR",
//t    "f_norm_arg : tCVAR",
//t    "f_norm_arg : tIDENTIFIER",
//t    "f_arg : f_norm_arg",
//t    "f_arg : f_arg ',' f_norm_arg",
//t    "f_opt : tIDENTIFIER '=' arg",
//t    "f_optarg : f_opt",
//t    "f_optarg : f_optarg ',' f_opt",
//t    "f_rest_arg : tSTAR tIDENTIFIER",
//t    "f_rest_arg : tSTAR",
//t    "f_block_arg : tAMPER tIDENTIFIER",
//t    "opt_f_block_arg : ',' f_block_arg",
//t    "opt_f_block_arg : none",
//t    "singleton : var_ref",
//t    "$$26 :",
//t    "singleton : '(' $$26 expr opt_nl ')'",
//t    "assoc_list : none",
//t    "assoc_list : assocs trailer",
//t    "assoc_list : args trailer",
//t    "assocs : assoc",
//t    "assocs : assocs ',' assoc",
//t    "assoc : arg tASSOC arg",
//t    "operation : tIDENTIFIER",
//t    "operation : tCONSTANT",
//t    "operation : tFID",
//t    "operation2 : tIDENTIFIER",
//t    "operation2 : tCONSTANT",
//t    "operation2 : tFID",
//t    "operation2 : op",
//t    "operation3 : tIDENTIFIER",
//t    "operation3 : tFID",
//t    "operation3 : op",
//t    "dot_or_colon : '.'",
//t    "dot_or_colon : tCOLON2",
//t    "opt_terms :",
//t    "opt_terms : terms",
//t    "opt_nl :",
//t    "opt_nl : '\\n'",
//t    "trailer :",
//t    "trailer : '\\n'",
//t    "trailer : ','",
//t    "term : ';'",
//t    "term : '\\n'",
//t    "terms : term",
//t    "terms : terms ';'",
//t    "none :",
//t  };
  protected static  string [] yyName = {    
    "end-of-file",null,null,null,null,null,null,null,null,null,"'\\n'",
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,"'!'",null,null,null,"'%'",
    "'&'",null,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",null,null,
    null,null,null,null,null,null,null,null,"':'","';'","'<'","'='","'>'",
    "'?'",null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,"'['",null,"']'","'^'",null,"'`'",null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,"'{'","'|'","'}'","'~'",null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,null,null,null,null,null,null,null,null,null,null,null,null,null,
    null,"kCLASS","kMODULE","kDEF","kUNDEF","kBEGIN","kRESCUE","kENSURE",
    "kEND","kIF","kUNLESS","kTHEN","kELSIF","kELSE","kCASE","kWHEN",
    "kWHILE","kUNTIL","kFOR","kBREAK","kNEXT","kREDO","kRETRY","kIN",
    "kDO","kDO_COND","kDO_BLOCK","kRETURN","kYIELD","kSUPER","kSELF",
    "kNIL","kTRUE","kFALSE","kAND","kOR","kNOT","kIF_MOD","kUNLESS_MOD",
    "kWHILE_MOD","kUNTIL_MOD","kRESCUE_MOD","kALIAS","kDEFINED","klBEGIN",
    "klEND","k__LINE__","k__FILE__","tIDENTIFIER","tFID","tGVAR","tIVAR",
    "tCONSTANT","tCVAR","tINTEGER","tFLOAT","tSTRING","tXSTRING",
    "tREGEXP","tDSTRING","tDXSTRING","tDREGEXP","tNTH_REF","tBACK_REF",
    "tQWORDS","tUPLUS","tUMINUS","tPOW","tCMP","tEQ","tEQQ","tNEQ","tGEQ",
    "tLEQ","tANDOP","tOROP","tMATCH","tNMATCH","tDOT2","tDOT3","tAREF",
    "tASET","tLSHFT","tRSHFT","tCOLON2","tCOLON3","tOP_ASGN","tASSOC",
    "tLPAREN","tLBRACK","tLBRACE","tSTAR","tAMPER","tSYMBEG","LAST_TOKEN",
  };

  /** index-checked interface to yyName[].
      @param token single character or %token value.
      @return token name or [illegal] or [unknown].
    */
//t  public static string yyname (int token) {
//t    if ((token < 0) || (token > yyName.Length)) return "[illegal]";
//t    string name;
//t    if ((name = yyName[token]) != null) return name;
//t    return "[unknown]";
//t  }

  /** computes list of expected tokens on error by tracing the tables.
      @param state for which to compute the list.
      @return list of token names.
    */
  protected string[] yyExpecting (int state) {
    int token, n, len = 0;
    bool[] ok = new bool[yyName.Length];

    if ((n = yySindex[state]) != 0)
      for (token = n < 0 ? -n : 0;
           (token < yyName.Length) && (n+token < yyTable.Length); ++ token)
        if (yyCheck[n+token] == token && !ok[token] && yyName[token] != null) {
          ++ len;
          ok[token] = true;
        }
    if ((n = yyRindex[state]) != 0)
      for (token = n < 0 ? -n : 0;
           (token < yyName.Length) && (n+token < yyTable.Length); ++ token)
        if (yyCheck[n+token] == token && !ok[token] && yyName[token] != null) {
          ++ len;
          ok[token] = true;
        }

    string [] result = new string[len];
    for (n = token = 0; n < len;  ++ token)
      if (ok[token]) result[n++] = yyName[token];
    return result;
  }

  /** the generated parser, with debugging messages.
      Maintains a state and a value stack, currently with fixed maximum size.
      @param yyLex scanner.
      @param yydebug debug message writer implementing yyDebug, or null.
      @return result of the last reduction, if any.
      @throws yyException on irrecoverable parse error.
    */
  public Object yyparse (yyParser.yyInput yyLex, Object yydebug)
                                 {
//t    this.yydebug = (yydebug.yyDebug)yydebug;
    return yyparse(yyLex);
  }

  /** initial size and increment of the state/value stack [default 256].
      This is not final so that it can be overwritten outside of invocations
      of yyparse().
    */
  protected int yyMax;

  /** executed at the beginning of a reduce action.
      Used as $$ = yyDefault($1), prior to the user-specified action, if any.
      Can be overwritten to provide deep copy, etc.
      @param first value for $1, or null.
      @return first.
    */
  protected Object yyDefault (Object first) {
    return first;
  }

  /** the generated parser.
      Maintains a state and a value stack, currently with fixed maximum size.
      @param yyLex scanner.
      @return result of the last reduction, if any.
      @throws yyException on irrecoverable parse error.
    */
  public Object yyparse (yyParser.yyInput yyLex)
                                {
    if (yyMax <= 0) yyMax = 256;                        // initial size
    int yyState = 0;                                   // state stack ptr
    int [] yyStates = new int[yyMax];                   // state stack 
    Object yyVal = null;                               // value stack ptr
    Object [] yyVals = new Object[yyMax];               // value stack
    int yyToken = -1;                                   // current input
    int yyErrorFlag = 0;                                // #tks to shift

    int yyTop = 0;
    goto skip;
    yyLoop:
    yyTop++;
    skip:
    for (;; ++ yyTop) {
      if (yyTop >= yyStates.Length) {                   // dynamically increase
        int[] i = new int[yyStates.Length+yyMax];
        System.Array.Copy(yyStates, i, 0);
        yyStates = i;
        Object[] o = new Object[yyVals.Length+yyMax];
        System.Array.Copy(yyVals, o, 0);
        yyVals = o;
      }
      yyStates[yyTop] = yyState;
      yyVals[yyTop] = yyVal;
//t      if (yydebug != null) yydebug.push(yyState, yyVal);

      yyDiscarded: for (;;) {   // discarding a token does not change stack
        int yyN;
        if ((yyN = yyDefRed[yyState]) == 0) {   // else [default] reduce (yyN)
          if (yyToken < 0) {
            yyToken = yyLex.advance() ? yyLex.token() : 0;
//t            if (yydebug != null)
//t              yydebug.lex(yyState, yyToken, yyname(yyToken), yyLex.value());
          }
          if ((yyN = yySindex[yyState]) != 0 && ((yyN += yyToken) >= 0)
              && (yyN < yyTable.Length) && (yyCheck[yyN] == yyToken)) {
//t            if (yydebug != null)
//t              yydebug.shift(yyState, yyTable[yyN], yyErrorFlag-1);
            yyState = yyTable[yyN];             // shift to yyN
            yyVal = yyLex.value();
            yyToken = -1;
            if (yyErrorFlag > 0) -- yyErrorFlag;
            goto yyLoop;
          }
          if ((yyN = yyRindex[yyState]) != 0 && (yyN += yyToken) >= 0
              && yyN < yyTable.Length && yyCheck[yyN] == yyToken)
            yyN = yyTable[yyN];                 // reduce (yyN)
          else
            switch (yyErrorFlag) {
  
            case 0:
              yyerror("syntax error", yyExpecting(yyState));
//t              if (yydebug != null) yydebug.error("syntax error");
              goto case 1;
            case 1: case 2:
              yyErrorFlag = 3;
              do {
                if ((yyN = yySindex[yyStates[yyTop]]) != 0
                    && (yyN += Token.yyErrorCode) >= 0 && yyN < yyTable.Length
                    && yyCheck[yyN] == Token.yyErrorCode) {
//t                  if (yydebug != null)
//t                    yydebug.shift(yyStates[yyTop], yyTable[yyN], 3);
                  yyState = yyTable[yyN];
                  yyVal = yyLex.value();
                  goto yyLoop;
                }
//t                if (yydebug != null) yydebug.pop(yyStates[yyTop]);
              } while (-- yyTop >= 0);
//t              if (yydebug != null) yydebug.reject();
              throw new yyParser.yyException("irrecoverable syntax error");
  
            case 3:
              if (yyToken == 0) {
//t                if (yydebug != null) yydebug.reject();
                throw new yyParser.yyException("irrecoverable syntax error at end-of-file");
              }
//t              if (yydebug != null)
//t                yydebug.discard(yyState, yyToken, yyname(yyToken),
//t                                                     yyLex.value());
              yyToken = -1;
              goto yyDiscarded;         // leave stack alone
            }
        }
        int yyV = yyTop + 1-yyLen[yyN];
//t        if (yydebug != null)
//t          yydebug.reduce(yyState, yyStates[yyV-1], yyN, yyRule[yyN], yyLen[yyN]);
        yyVal = yyDefault(yyV > yyTop ? null : yyVals[yyV]);
        switch (yyN) {
case 1:
#line 239 "parse.y"
  {
                        yyVal = thread.dyna_vars;
                        lex.State = EXPR.BEG;
                        thread.TopLocalInit();
                        /*
                        if ((VALUE)ruby_class == rb_cObject) class_nest = 0;
                        else class_nest = 1;
                        */
                    }
  break;
case 2:
#line 249 "parse.y"
  {
                        if (((RNode)yyVals[0+yyTop]) != null && !compile_for_eval) {
                            /* last expression should not be void */
                            if (((RNode)yyVals[0+yyTop]) is RNBlock)
                            {
                                RNode node = ((RNode)yyVals[0+yyTop]);
                                while (node.next != null) {
                                    node = node.next;
                                }
                                void_expr(node.head);
                            }
                            else
                            {
                                void_expr(((RNode)yyVals[0+yyTop]));
                            }
                        }
                        evalTree = block_append(evalTree, ((RNode)yyVals[0+yyTop]));
                        thread.TopLocalSetup();
                        class_nest = 0;
                        thread.dyna_vars = ((RVarmap)yyVals[-1+yyTop]);
                    }
  break;
case 3:
#line 272 "parse.y"
  {
                        void_stmts(((RNode)yyVals[-1+yyTop]));
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 5:
#line 279 "parse.y"
  {
                        yyVal = new RNNewLine(thread, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 6:
#line 283 "parse.y"
  {
                        yyVal = block_append(((RNode)yyVals[-2+yyTop]), new RNNewLine(thread, ((RNode)yyVals[0+yyTop])));
                    }
  break;
case 7:
#line 287 "parse.y"
  {
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 8:
#line 291 "parse.y"
  {lex.State = EXPR.FNAME;}
  break;
case 9:
#line 292 "parse.y"
  {
                        if (in_def != 0 || in_single != 0)
                            yyerror("alias within method");
                        yyVal = new RNAlias(thread, ((uint)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 10:
#line 298 "parse.y"
  {
                        if (in_def != 0 || in_single != 0)
                            yyerror("alias within method");
                        yyVal = new RNVAlias(thread, ((uint)yyVals[-1+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 11:
#line 304 "parse.y"
  {
                        if (in_def != 0 || in_single != 0)
                            yyerror("alias within method");
                        string buf = "$" + Convert.ToChar(((RNode)yyVals[0+yyTop]).nth);
                        yyVal = new RNVAlias(thread, ((uint)yyVals[-1+yyTop]), intern(buf));
                    }
  break;
case 12:
#line 311 "parse.y"
  {
                        yyerror("can't make alias for the number variables");
                        yyVal = null;
                    }
  break;
case 13:
#line 316 "parse.y"
  {
                        if (in_def != 0 || in_single != 0)
                            yyerror("undef within method");
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 14:
#line 322 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = new RNIf(thread, cond(((RNode)yyVals[0+yyTop])), ((RNode)yyVals[-2+yyTop]));
                    }
  break;
case 15:
#line 327 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = new RNUnless(thread, cond(((RNode)yyVals[0+yyTop])), ((RNode)yyVals[-2+yyTop]));
                    }
  break;
case 16:
#line 332 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        if (((RNode)yyVals[-2+yyTop]) != null && ((RNode)yyVals[-2+yyTop]) is RNBegin) {
                            yyVal = new RNWhile(thread, cond(((RNode)yyVals[0+yyTop])), ((RNode)yyVals[-2+yyTop]).body, false);
                        }
                        else {
                            yyVal = new RNWhile(thread, cond(((RNode)yyVals[0+yyTop])), ((RNode)yyVals[-2+yyTop]), true);
                        }
                    }
  break;
case 17:
#line 342 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        if (((RNode)yyVals[-2+yyTop]) != null && ((RNode)yyVals[-2+yyTop]) is RNBegin) {
                            yyVal = new RNUntil(thread, cond(((RNode)yyVals[0+yyTop])), ((RNode)yyVals[-2+yyTop]).body, false);
                        }
                        else {
                            yyVal = new RNUntil(thread, cond(((RNode)yyVals[0+yyTop])), ((RNode)yyVals[-2+yyTop]), true);
                        }
                    }
  break;
case 18:
#line 352 "parse.y"
  {
                        yyVal = new RNRescue(thread, ((RNode)yyVals[-2+yyTop]), new RNResBody(thread, null, ((RNode)yyVals[0+yyTop]), null), null);
                    }
  break;
case 19:
#line 356 "parse.y"
  {
                        if (in_def != 0 || in_single != 0) {
                            yyerror("BEGIN in method");
                        }
                        thread.LocalPush();
                    }
  break;
case 20:
#line 363 "parse.y"
  {
                        thread.evalTreeBegin = block_append(thread.evalTreeBegin,
                                                     new RNPreExe(thread, ((RNode)yyVals[-1+yyTop])));
                        thread.LocalPop();
                        yyVal = null;
                    }
  break;
case 21:
#line 370 "parse.y"
  {
                        if (compile_for_eval && (in_def != 0|| in_single != 0)) {
                            yyerror("END in method; use at_exit");
                        }

                        yyVal = new RNIter(thread, null, new RNPostExe(thread), ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 22:
#line 378 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = node_assign(((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 23:
#line 383 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVals[-2+yyTop]).val = ((RNode)yyVals[0+yyTop]);
                        yyVal = ((RNode)yyVals[-2+yyTop]);
                    }
  break;
case 24:
#line 389 "parse.y"
  {
                        yyVal = node_assign(((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 26:
#line 395 "parse.y"
  {
                        /* value_expr($3); // nakada ruby-dev:15905*/
                        ((RNode)yyVals[-2+yyTop]).val = ((RNode)yyVals[0+yyTop]);
                        yyVal = ((RNode)yyVals[-2+yyTop]);
                    }
  break;
case 27:
#line 401 "parse.y"
  {
                        if (!compile_for_eval && in_def != 0 && in_single != 0)
                            yyerror("return appeared outside of method");
                        yyVal = new RNReturn(thread, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 29:
#line 408 "parse.y"
  {
                        yyVal = logop(typeof(RNAnd), ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 30:
#line 412 "parse.y"
  {
                        yyVal = logop(typeof(RNOr), ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 31:
#line 416 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = new RNNot(thread, cond(((RNode)yyVals[0+yyTop])));
                    }
  break;
case 32:
#line 421 "parse.y"
  {
                        yyVal = new RNNot(thread, cond(((RNode)yyVals[0+yyTop])));
                    }
  break;
case 37:
#line 431 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 38:
#line 436 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 39:
#line 442 "parse.y"
  {
                        yyVal = new_fcall(((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[0+yyTop]));
                   }
  break;
case 40:
#line 447 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-3+yyTop]));
                    }
  break;
case 41:
#line 453 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-3+yyTop]));
                    }
  break;
case 42:
#line 459 "parse.y"
  {
                        if (!compile_for_eval && in_def == 0 && in_single == 0)
                            yyerror("super called outside of method");
                        yyVal = new_super(((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[0+yyTop]));
                    }
  break;
case 43:
#line 466 "parse.y"
  {
                        yyVal = new RNYield(thread, ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[0+yyTop]));
                    }
  break;
case 45:
#line 473 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 47:
#line 479 "parse.y"
  {
                        yyVal = new RNMAsgn(thread, new RNArray(thread, ((RNode)yyVals[-1+yyTop])));
                    }
  break;
case 48:
#line 484 "parse.y"
  {
                        yyVal = new RNMAsgn(thread, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 49:
#line 488 "parse.y"
  {
                        yyVal = new RNMAsgn(thread, RNode.list_append(thread,((RNode)yyVals[-1+yyTop]),((RNode)yyVals[0+yyTop])));
                    }
  break;
case 50:
#line 492 "parse.y"
  {
                        yyVal = new RNMAsgn(thread, ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 51:
#line 496 "parse.y"
  {
                        yyVal = new RNMAsgn(thread, ((RNode)yyVals[-1+yyTop]), -1);
                    }
  break;
case 52:
#line 500 "parse.y"
  {
                        yyVal = new RNMAsgn(thread, null, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 53:
#line 504 "parse.y"
  {
                        yyVal = new RNMAsgn(thread, null, -1);
                    }
  break;
case 55:
#line 510 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 56:
#line 515 "parse.y"
  {
                        yyVal = new RNArray(thread, ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 57:
#line 519 "parse.y"
  {
                        yyVal = RNode.list_append(thread, ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 58:
#line 524 "parse.y"
  {
                        yyVal = assignable(((uint)yyVals[0+yyTop]), null);
                    }
  break;
case 59:
#line 528 "parse.y"
  {
                        yyVal = aryset(((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 60:
#line 532 "parse.y"
  {
                        yyVal = attrset(((RNode)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 61:
#line 536 "parse.y"
  {
                        yyVal = attrset(((RNode)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 62:
#line 540 "parse.y"
  {
                        yyVal = attrset(((RNode)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 63:
#line 544 "parse.y"
  {
                        backref_error(((RNode)yyVals[0+yyTop]));
                        yyVal = null;
                    }
  break;
case 64:
#line 550 "parse.y"
  {
                        yyVal = assignable(((uint)yyVals[0+yyTop]), null);
                    }
  break;
case 65:
#line 554 "parse.y"
  {
                        yyVal = aryset(((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 66:
#line 558 "parse.y"
  {
                        yyVal = attrset(((RNode)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 67:
#line 562 "parse.y"
  {
                        yyVal = attrset(((RNode)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 68:
#line 566 "parse.y"
  {
                        yyVal = attrset(((RNode)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 69:
#line 570 "parse.y"
  {
                        backref_error(((RNode)yyVals[0+yyTop]));
                        yyVal = null;
                    }
  break;
case 70:
#line 576 "parse.y"
  {
                        yyerror("class/module name must be CONSTANT");
                    }
  break;
case 75:
#line 585 "parse.y"
  {
                        lex.State = EXPR.END;
                        if (((object)yyVals[0+yyTop]) is int)
                            yyVal = ((int)yyVals[0+yyTop]);
                        else
                            yyVal = ((char)yyVals[0+yyTop]);
                    }
  break;
case 76:
#line 593 "parse.y"
  {
                        lex.State = EXPR.END;
                        yyVal = ((uint)yyVals[0+yyTop]);
                    }
  break;
case 79:
#line 602 "parse.y"
  {
                        yyVal = new RNUndef(thread, ((uint)yyVals[0+yyTop]));
                    }
  break;
case 80:
#line 605 "parse.y"
  {lex.State = EXPR.FNAME;}
  break;
case 81:
#line 606 "parse.y"
  {
                        yyVal = block_append(((RNode)yyVals[-3+yyTop]), new RNUndef(thread, ((uint)yyVals[0+yyTop])));
                    }
  break;
case 82:
#line 610 "parse.y"
  { yyVal = '|'; }
  break;
case 83:
#line 611 "parse.y"
  { yyVal = '^'; }
  break;
case 84:
#line 612 "parse.y"
  { yyVal = '&'; }
  break;
case 85:
#line 613 "parse.y"
  { yyVal = Token.tCMP; }
  break;
case 86:
#line 614 "parse.y"
  { yyVal = Token.tEQ; }
  break;
case 87:
#line 615 "parse.y"
  { yyVal = Token.tEQQ; }
  break;
case 88:
#line 616 "parse.y"
  { yyVal = Token.tMATCH; }
  break;
case 89:
#line 617 "parse.y"
  { yyVal = '>'; }
  break;
case 90:
#line 618 "parse.y"
  { yyVal = Token.tGEQ; }
  break;
case 91:
#line 619 "parse.y"
  { yyVal = '<'; }
  break;
case 92:
#line 620 "parse.y"
  { yyVal = Token.tLEQ; }
  break;
case 93:
#line 621 "parse.y"
  { yyVal = Token.tLSHFT; }
  break;
case 94:
#line 622 "parse.y"
  { yyVal = Token.tRSHFT; }
  break;
case 95:
#line 623 "parse.y"
  { yyVal = '+'; }
  break;
case 96:
#line 624 "parse.y"
  { yyVal = '-'; }
  break;
case 97:
#line 625 "parse.y"
  { yyVal = '*'; }
  break;
case 98:
#line 626 "parse.y"
  { yyVal = '*'; }
  break;
case 99:
#line 627 "parse.y"
  { yyVal = '/'; }
  break;
case 100:
#line 628 "parse.y"
  { yyVal = '%'; }
  break;
case 101:
#line 629 "parse.y"
  { yyVal = Token.tPOW; }
  break;
case 102:
#line 630 "parse.y"
  { yyVal = '~'; }
  break;
case 103:
#line 631 "parse.y"
  { yyVal = Token.tUPLUS; }
  break;
case 104:
#line 632 "parse.y"
  { yyVal = Token.tUMINUS; }
  break;
case 105:
#line 633 "parse.y"
  { yyVal = Token.tAREF; }
  break;
case 106:
#line 634 "parse.y"
  { yyVal = Token.tASET; }
  break;
case 107:
#line 635 "parse.y"
  { yyVal = '`'; }
  break;
case 149:
#line 646 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = node_assign(((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 150:
#line 650 "parse.y"
  {yyVal = assignable(((uint)yyVals[-1+yyTop]), null);}
  break;
case 151:
#line 651 "parse.y"
  {
                        if (((RNode)yyVals[-1+yyTop]) != null) {
                            if (((char)yyVals[-2+yyTop]) == Token.tOROP) {
                                ((RNode)yyVals[-1+yyTop]).val = ((RNode)yyVals[0+yyTop]);
                                yyVal = new RNOpAsgnOr(thread, gettable(((uint)yyVals[-3+yyTop])), ((RNode)yyVals[-1+yyTop]));
                                if (is_instance_id(((uint)yyVals[-3+yyTop]))) {
                                    ((RNode)yyVal).aid = ((uint)yyVals[-3+yyTop]);
                                }
                            }
                            else if (((char)yyVals[-2+yyTop]) == Token.tANDOP) {
                                ((RNode)yyVals[-1+yyTop]).val = ((RNode)yyVals[0+yyTop]);
                                yyVal = new RNOpAsgnAnd(thread, gettable(((uint)yyVals[-3+yyTop])), ((RNode)yyVals[-1+yyTop]));
                            }
                            else {
                                yyVal = ((RNode)yyVals[-1+yyTop]);
                                ((RNode)yyVal).val = call_op(gettable(((uint)yyVals[-3+yyTop])),((char)yyVals[-2+yyTop]),1,((RNode)yyVals[0+yyTop]));
                            }
                            ((RNode)yyVal).FixPos(((RNode)yyVals[0+yyTop]));
                        }
                        else {
                            yyVal = null;
                        }
                    }
  break;
case 152:
#line 675 "parse.y"
  {
                        RNode args = new RNArray(thread, ((RNode)yyVals[0+yyTop]));

                        RNode tail = RNode.list_append(thread, ((RNode)yyVals[-3+yyTop]), new RNNil(thread));
                        RNode.list_concat(args, tail);
                        uint id = ((char)yyVals[-1+yyTop]);
                        if (id == Token.tOROP) {
                            id = 0;
                        }
                        else if (id == Token.tANDOP) {
                            id = 1;
                        }
                        yyVal = new RNOpAsgn1(thread, ((RNode)yyVals[-5+yyTop]), id, args);
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-5+yyTop]));
                    }
  break;
case 153:
#line 691 "parse.y"
  {
                        uint id = ((uint)yyVals[-1+yyTop]);
                        if (id == Token.tOROP) {
                            id = 0;
                        }
                        else if (id == Token.tANDOP) {
                            id = 1;
                        }
                        yyVal = new RNOpAsgn2(thread, ((RNode)yyVals[-4+yyTop]), ((uint)yyVals[-2+yyTop]), id, ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-4+yyTop]));
                    }
  break;
case 154:
#line 703 "parse.y"
  {
                        uint id = ((uint)yyVals[-1+yyTop]);
                        if (id == Token.tOROP) {
                            id = 0;
                        }
                        else if (id == Token.tANDOP) {
                            id = 1;
                        }
                        yyVal = new RNOpAsgn2(thread, ((RNode)yyVals[-4+yyTop]), ((uint)yyVals[-2+yyTop]), id, ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-4+yyTop]));
                    }
  break;
case 155:
#line 715 "parse.y"
  {
                        uint id = ((uint)yyVals[-1+yyTop]);
                        if (id == Token.tOROP) {
                            id = 0;
                        }
                        else if (id == Token.tANDOP) {
                            id = 1;
                        }
                        yyVal = new RNOpAsgn2(thread, ((RNode)yyVals[-4+yyTop]), ((uint)yyVals[-2+yyTop]), id, ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-4+yyTop]));
                    }
  break;
case 156:
#line 727 "parse.y"
  {
                        backref_error(((RNode)yyVals[-2+yyTop]));
                        yyVal = null;
                    }
  break;
case 157:
#line 732 "parse.y"
  {
                        yyVal = new RNDot2(thread, ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 158:
#line 736 "parse.y"
  {
                        yyVal = new RNDot3(thread, ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 159:
#line 740 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '+', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 160:
#line 744 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '-', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 161:
#line 748 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '*', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 162:
#line 752 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '/', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 163:
#line 756 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '%', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 164:
#line 760 "parse.y"
  {
                        bool need_negate = false;
#if UMINUS
                        if (((RNode)yyVals[-2+yyTop]) is RNLit) {
                            if (((RNode)yyVals[-2+yyTop]).lit is long ||
                                ((RNode)yyVals[-2+yyTop]).lit is double ||
                                ((RNode)yyVals[-2+yyTop]).lit is int /* ||
                                $1.lit is BIGNUM */
                                )
                            {
                                if (RTEST(rb_funcall(((RNode)yyVals[-2+yyTop]).lit,'<',1,0))) {
                                    ((RNode)yyVals[-2+yyTop]).lit = rb_funcall(((RNode)yyVals[-2+yyTop]).lit,intern("-@"),0,0);
                                    need_negate = true;
                                }
                            }
                        }
#endif
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), Token.tPOW, 1, ((RNode)yyVals[0+yyTop]));
                        if (need_negate) {
                            yyVal = call_op(((RNode)yyVal), Token.tUMINUS, 0, null);
                        }
                    }
  break;
case 165:
#line 783 "parse.y"
  {
                        if (((RNode)yyVals[0+yyTop]) != null && ((RNode)yyVals[0+yyTop]) is RNLit) {
                            yyVal = ((RNode)yyVals[0+yyTop]);
                        }
                        else {
                            yyVal = call_op(((RNode)yyVals[0+yyTop]), Token.tUPLUS, 0, null);
                        }
                    }
  break;
case 166:
#line 792 "parse.y"
  {
                        if (((RNode)yyVals[0+yyTop]) != null && ((RNode)yyVals[0+yyTop]) is RNLit && (((RNode)yyVals[0+yyTop]).lit is int ||
                                                          ((RNode)yyVals[0+yyTop]).lit is long)) {
                            if (((RNode)yyVals[0+yyTop]).lit is int)
                            {
                                int i = (int)((RNode)yyVals[0+yyTop]).lit;
                                ((RNode)yyVals[0+yyTop]).lit = -i;
                            }
                            else
                            {
                                long i = (long)((RNode)yyVals[0+yyTop]).lit;
                                ((RNode)yyVals[0+yyTop]).lit = -i;
                            }
                            yyVal = ((RNode)yyVals[0+yyTop]);
                        }
                        else {
                            yyVal = call_op(((RNode)yyVals[0+yyTop]), Token.tUMINUS, 0, null);
                        }
                    }
  break;
case 167:
#line 812 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '|', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 168:
#line 816 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '^', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 169:
#line 820 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '&', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 170:
#line 824 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), Token.tCMP, 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 171:
#line 828 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '>', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 172:
#line 832 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), Token.tGEQ, 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 173:
#line 836 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), '<', 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 174:
#line 840 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), Token.tLEQ, 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 175:
#line 844 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), Token.tEQ, 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 176:
#line 848 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), Token.tEQQ, 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 177:
#line 852 "parse.y"
  {
                        yyVal = new RNNot(thread, call_op(((RNode)yyVals[-2+yyTop]), Token.tEQ, 1, ((RNode)yyVals[0+yyTop])));
                    }
  break;
case 178:
#line 856 "parse.y"
  {
                        yyVal = match_gen(((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 179:
#line 860 "parse.y"
  {
                        yyVal = new RNNot(thread, match_gen(((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop])));
                    }
  break;
case 180:
#line 864 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = new RNNot(thread, cond(((RNode)yyVals[0+yyTop])));
                    }
  break;
case 181:
#line 869 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[0+yyTop]), '~', 0, null);
                    }
  break;
case 182:
#line 873 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), Token.tLSHFT, 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 183:
#line 877 "parse.y"
  {
                        yyVal = call_op(((RNode)yyVals[-2+yyTop]), Token.tRSHFT, 1, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 184:
#line 881 "parse.y"
  {
                        yyVal = logop(typeof(RNAnd), ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 185:
#line 885 "parse.y"
  {
                        yyVal = logop(typeof(RNOr), ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 186:
#line 888 "parse.y"
  {in_defined = true;}
  break;
case 187:
#line 889 "parse.y"
  {
                        in_defined = false;
                        yyVal = new RNDefined(thread, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 188:
#line 894 "parse.y"
  {
                        value_expr(((RNode)yyVals[-4+yyTop]));
                        yyVal = new RNIf(thread, cond(((RNode)yyVals[-4+yyTop])), ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 189:
#line 899 "parse.y"
  {
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 191:
#line 905 "parse.y"
  {
                        yyVal = new RNArray(thread, ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 192:
#line 909 "parse.y"
  {
                        yyVal = RNode.list_append(thread, ((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 193:
#line 913 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 194:
#line 917 "parse.y"
  {
                        value_expr(((RNode)yyVals[-1+yyTop]));
                        yyVal = arg_concat(((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 195:
#line 922 "parse.y"
  {
                        yyVal = new RNArray(thread, new RNHash(thread, ((RNode)yyVals[-1+yyTop])));
                    }
  break;
case 196:
#line 926 "parse.y"
  {
                        value_expr(((RNode)yyVals[-1+yyTop]));
                        yyVal = new RNRestArgs(thread, ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 197:
#line 932 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 198:
#line 936 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-2+yyTop]);
                    }
  break;
case 199:
#line 940 "parse.y"
  {
                        yyVal = new RNArray(thread, ((RNode)yyVals[-2+yyTop]));
                    }
  break;
case 200:
#line 944 "parse.y"
  {
                        yyVal = RNode.list_append(thread, ((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-2+yyTop]));
                    }
  break;
case 203:
#line 952 "parse.y"
  {
                        yyVal = new RNArray(thread, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 204:
#line 956 "parse.y"
  {
                        yyVal = RNode.list_append(thread, ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 205:
#line 960 "parse.y"
  {
                        yyVal = arg_blk_pass(((RNode)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 206:
#line 964 "parse.y"
  {
                        value_expr(((RNode)yyVals[-1+yyTop]));
                        yyVal = arg_concat(((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-1+yyTop]));
                        yyVal = arg_blk_pass(((RNode)yyVal), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 207:
#line 970 "parse.y"
  {
                        yyVal = new RNArray(thread, new RNHash(thread, ((RNode)yyVals[-1+yyTop])));
                        yyVal = arg_blk_pass(((RNode)yyVal), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 208:
#line 975 "parse.y"
  {
                        value_expr(((RNode)yyVals[-1+yyTop]));
                        yyVal = arg_concat(new RNArray(thread, new RNHash(thread, ((RNode)yyVals[-4+yyTop]))), ((RNode)yyVals[-1+yyTop]));
                        yyVal = arg_blk_pass(((RNode)yyVal), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 209:
#line 981 "parse.y"
  {
                        yyVal = RNode.list_append(thread, ((RNode)yyVals[-3+yyTop]), new RNHash(thread, ((RNode)yyVals[-1+yyTop])));
                        yyVal = arg_blk_pass(((RNode)yyVal), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 210:
#line 986 "parse.y"
  {
                        value_expr(((RNode)yyVals[-1+yyTop]));
                        yyVal = arg_concat(RNode.list_append(thread, ((RNode)yyVals[-6+yyTop]), new RNHash(thread, ((RNode)yyVals[-4+yyTop]))), ((RNode)yyVals[-1+yyTop]));
                        yyVal = arg_blk_pass(((RNode)yyVal), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 211:
#line 992 "parse.y"
  {
                        value_expr(((RNode)yyVals[-1+yyTop]));
                        yyVal = arg_blk_pass(new RNRestArgs(thread, ((RNode)yyVals[-1+yyTop])), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 213:
#line 998 "parse.y"
  {lex.CMDARG_PUSH();}
  break;
case 214:
#line 999 "parse.y"
  {
                        lex.CMDARG_POP();
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 215:
#line 1005 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = new RNBlockPass(thread, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 216:
#line 1011 "parse.y"
  {
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 218:
#line 1017 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = new RNArray(thread, ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 219:
#line 1022 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = RNode.list_append(thread, ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 220:
#line 1028 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 222:
#line 1035 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = RNode.list_append(thread, ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 223:
#line 1040 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = arg_concat(((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 224:
#line 1045 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 225:
#line 1051 "parse.y"
  {
                        yyVal = ((RNode)yyVals[0+yyTop]);
                        if (((RNode)yyVals[0+yyTop]) != null) {
                            if (((RNode)yyVals[0+yyTop]) is RNArray && ((RNode)yyVals[0+yyTop]).next == null) {
                                yyVal = ((RNode)yyVals[0+yyTop]).head;
                            }
                            else if (((RNode)yyVals[0+yyTop]) is RNBlockPass) {
                                thread.CompileError("block argument should not be given");
                            }
                        }
                    }
  break;
case 226:
#line 1064 "parse.y"
  {
                        yyVal = new RNLit(thread, ((object)yyVals[0+yyTop]));
                    }
  break;
case 228:
#line 1069 "parse.y"
  {
                        yyVal = new RNXStr(thread, ruby, ((object)yyVals[0+yyTop]));
                    }
  break;
case 234:
#line 1078 "parse.y"
  {
                        yyVal = new RNVCall(thread, ((uint)yyVals[0+yyTop]));
                    }
  break;
case 235:
#line 1087 "parse.y"
  {
                        RNode nd = ((RNode)yyVals[-4+yyTop]);
                        if (((RNode)yyVals[-3+yyTop]) == null && ((RNode)yyVals[-2+yyTop]) == null && ((RNode)yyVals[-1+yyTop]) == null)
                            yyVal = new RNBegin(thread, ((RNode)yyVals[-4+yyTop]));
                        else {
                            if (((RNode)yyVals[-3+yyTop]) != null) nd = new RNRescue(thread, ((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[-2+yyTop]));
                            else if (((RNode)yyVals[-2+yyTop]) != null) {
                                ruby.warn("else without rescue is useless");
                                nd = block_append(((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-2+yyTop]));
                            }
                            if (((RNode)yyVals[-1+yyTop]) != null) nd = new RNEnsure(thread, ((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-1+yyTop]));
                            yyVal = nd;
                        }
                        ((RNode)yyVal).FixPos(nd);
                    }
  break;
case 236:
#line 1103 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 237:
#line 1107 "parse.y"
  {
                        value_expr(((RNode)yyVals[-2+yyTop]));
                        yyVal = new RNColon2(thread, ((RNode)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]));
                    }
  break;
case 238:
#line 1112 "parse.y"
  {
                        yyVal = new RNColon3(thread, ((uint)yyVals[0+yyTop]));
                    }
  break;
case 239:
#line 1116 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new RNCall(thread, ((RNode)yyVals[-3+yyTop]), Token.tAREF, ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 240:
#line 1121 "parse.y"
  {
                        if (((RNode)yyVals[-1+yyTop]) == null)
                            yyVal = new RNZArray(thread); /* zero length array*/
                        else {
                            yyVal = ((RNode)yyVals[-1+yyTop]);
                        }
                    }
  break;
case 241:
#line 1129 "parse.y"
  {
                        yyVal = new RNHash(thread, ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 242:
#line 1133 "parse.y"
  {
                        if (!compile_for_eval && in_def == 0 && in_single == 0)
                            yyerror("return appeared outside of method");
                        value_expr(((RNode)yyVals[-1+yyTop]));
                        yyVal = new RNReturn(thread, ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 243:
#line 1140 "parse.y"
  {
                        if (!compile_for_eval && in_def == 0 && in_single == 0)
                            yyerror("return appeared outside of method");
                        yyVal = new RNReturn(thread);
                    }
  break;
case 244:
#line 1146 "parse.y"
  {
                        if (!compile_for_eval && in_def == 0 && in_single == 0)
                            yyerror("return appeared outside of method");
                        yyVal = new RNReturn(thread);
                    }
  break;
case 245:
#line 1152 "parse.y"
  {
                        value_expr(((RNode)yyVals[-1+yyTop]));
                        yyVal = new RNYield(thread, ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 246:
#line 1157 "parse.y"
  {
                        yyVal = new RNYield(thread);
                    }
  break;
case 247:
#line 1161 "parse.y"
  {
                        yyVal = new RNYield(thread);
                    }
  break;
case 248:
#line 1164 "parse.y"
  {in_defined = true;}
  break;
case 249:
#line 1165 "parse.y"
  {
                        in_defined = false;
                        yyVal = new RNDefined(thread, ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 250:
#line 1170 "parse.y"
  {
                        ((RNode)yyVals[0+yyTop]).iter = new RNFCall(thread, ((uint)yyVals[-1+yyTop]));
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 252:
#line 1176 "parse.y"
  {
                        if (((RNode)yyVals[-1+yyTop]) != null && ((RNode)yyVals[-1+yyTop]) is RNBlockPass) {
                            thread.CompileError("both block arg and actual block given");
                        }
                        ((RNode)yyVals[0+yyTop]).iter = ((RNode)yyVals[-1+yyTop]);
                        yyVal = ((RNode)yyVals[0+yyTop]);
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 253:
#line 1188 "parse.y"
  {
                        value_expr(((RNode)yyVals[-4+yyTop]));
                        yyVal = new RNIf(thread, cond(((RNode)yyVals[-4+yyTop])), ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[-1+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-4+yyTop]));
                    }
  break;
case 254:
#line 1197 "parse.y"
  {
                        value_expr(((RNode)yyVals[-4+yyTop]));
                        yyVal = new RNUnless(thread, cond(((RNode)yyVals[-4+yyTop])), ((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[-1+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-4+yyTop]));
                    }
  break;
case 255:
#line 1202 "parse.y"
  {lex.COND_PUSH();}
  break;
case 256:
#line 1202 "parse.y"
  {lex.COND_POP();}
  break;
case 257:
#line 1205 "parse.y"
  {
                        value_expr(((RNode)yyVals[-4+yyTop]));
                        yyVal = new RNWhile(thread, cond(((RNode)yyVals[-4+yyTop])), ((RNode)yyVals[-1+yyTop]), true);
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-4+yyTop]));
                    }
  break;
case 258:
#line 1210 "parse.y"
  {lex.COND_PUSH();}
  break;
case 259:
#line 1210 "parse.y"
  {lex.COND_POP();}
  break;
case 260:
#line 1213 "parse.y"
  {
                        value_expr(((RNode)yyVals[-4+yyTop]));                  
                        yyVal = new RNUntil(thread, cond(((RNode)yyVals[-4+yyTop])), ((RNode)yyVals[-1+yyTop]), true);
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-4+yyTop]));
                    }
  break;
case 261:
#line 1221 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new RNCase(thread, ((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[-1+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-3+yyTop]));
                    }
  break;
case 262:
#line 1227 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 263:
#line 1230 "parse.y"
  {lex.COND_PUSH();}
  break;
case 264:
#line 1230 "parse.y"
  {lex.COND_POP();}
  break;
case 265:
#line 1233 "parse.y"
  {
                        value_expr(((RNode)yyVals[-4+yyTop]));
                        yyVal = new RNFor(thread, ((RNode)yyVals[-7+yyTop]), ((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-1+yyTop]));
                    }
  break;
case 266:
#line 1238 "parse.y"
  {
                        if (in_def != 0|| in_single != 0)
                            yyerror("class definition in method body");
                        class_nest++;
                        thread.LocalPush();
                        yyVal = sourceline;
                    }
  break;
case 267:
#line 1247 "parse.y"
  {
                        yyVal = new RNClass(thread, ((uint)yyVals[-4+yyTop]), ((RNode)yyVals[-1+yyTop]), ((RNode)yyVals[-3+yyTop]));
                        ((RNode)yyVal).SetLine(((int)yyVals[-2+yyTop]));
                        thread.LocalPop();
                        class_nest--;
                    }
  break;
case 268:
#line 1254 "parse.y"
  {
                        yyVal = in_def;
                        in_def = 0;
                    }
  break;
case 269:
#line 1259 "parse.y"
  {
                        yyVal = in_single;
                        in_single = 0;
                        class_nest++;
                        thread.LocalPush();
                    }
  break;
case 270:
#line 1267 "parse.y"
  {
                        yyVal = new RNSClass(thread, ((RNode)yyVals[-5+yyTop]), ((RNode)yyVals[-1+yyTop]));
                        thread.LocalPop();
                        class_nest--;
                        in_def = ((int)yyVals[-4+yyTop]);
                        in_single = ((int)yyVals[-2+yyTop]);
                    }
  break;
case 271:
#line 1275 "parse.y"
  {
                        if (in_def != 0|| in_single != 0)
                            yyerror("module definition in method body");
                        class_nest++;
                        thread.LocalPush();
                        yyVal = sourceline;
                    }
  break;
case 272:
#line 1284 "parse.y"
  {
                        yyVal = new RNModule(thread, ((uint)yyVals[-3+yyTop]), ((RNode)yyVals[-1+yyTop]));
                        ((RNode)yyVal).SetLine(((int)yyVals[-2+yyTop]));
                        thread.LocalPop();
                        class_nest--;
                    }
  break;
case 273:
#line 1291 "parse.y"
  {
                        if (in_def != 0|| in_single != 0)
                            yyerror("nested method definition");
                        yyVal = cur_mid;
                        if (((object)yyVals[0+yyTop]) is uint)
                            cur_mid = ((uint)yyVals[0+yyTop]);
                        else
                            cur_mid = (uint)((int)yyVals[0+yyTop]);
                        in_def++;
                        thread.LocalPush();
                    }
  break;
case 274:
#line 1308 "parse.y"
  {
                        RNode nd = ((RNode)yyVals[-4+yyTop]);
                        if (((RNode)yyVals[-3+yyTop]) != null) nd = new RNRescue(thread, ((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[-2+yyTop]));
                        else if (((RNode)yyVals[-2+yyTop]) != null) {
                            ruby.warn("else without rescue is useless");
                            nd = block_append(((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-2+yyTop]));
                        }
                        if (((RNode)yyVals[-1+yyTop]) != null) nd = new RNEnsure(thread, ((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-1+yyTop]));

                        /* NOEX_PRIVATE for toplevel */
                        uint id;
                        if (((object)yyVals[-7+yyTop]) is uint)
                        {
                            id = ((uint)yyVals[-7+yyTop]);
                        }
                        else
                        {
                            id = (uint)((int)yyVals[-7+yyTop]);
                        }
                        yyVal = new RNDefn(thread, id, ((RNode)yyVals[-5+yyTop]), nd, (class_nest > 0) ? NOEX.PUBLIC : NOEX.PRIVATE);
                        if (is_attrset_id(id)) ((RNode)yyVal).noex = NOEX.PUBLIC;
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-5+yyTop]));
                        thread.LocalPop();
                        in_def--;
                        cur_mid = ((uint)yyVals[-6+yyTop]);
                    }
  break;
case 275:
#line 1334 "parse.y"
  {lex.State = EXPR.FNAME;}
  break;
case 276:
#line 1335 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        in_single++;
                        thread.LocalPush();
                        lex.State = EXPR.END; /* force for args */
                    }
  break;
case 277:
#line 1347 "parse.y"
  {
                        RNode nd = ((RNode)yyVals[-4+yyTop]);
                        if (((RNode)yyVals[-3+yyTop]) != null) nd = new RNRescue(thread, ((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[-2+yyTop]));
                        else if (((RNode)yyVals[-2+yyTop]) != null) {
                            ruby.warn("else without rescue is useless");
                            nd = block_append(((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-2+yyTop]));
                        }
                        if (((RNode)yyVals[-1+yyTop]) != null) nd = new RNEnsure(thread, ((RNode)yyVals[-4+yyTop]), ((RNode)yyVals[-1+yyTop]));

                        yyVal = new RNDefs(thread, ((RNode)yyVals[-10+yyTop]), ((uint)yyVals[-7+yyTop]), ((RNode)yyVals[-5+yyTop]), nd);
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-10+yyTop]));
                        thread.LocalPop();
                        in_single--;
                    }
  break;
case 278:
#line 1362 "parse.y"
  {
                        yyVal = new RNBreak(thread);
                    }
  break;
case 279:
#line 1366 "parse.y"
  {
                        yyVal = new RNNext(thread);
                    }
  break;
case 280:
#line 1370 "parse.y"
  {
                        yyVal = new RNRedo(thread);
                    }
  break;
case 281:
#line 1374 "parse.y"
  {
                        yyVal = new RNRetry(thread);
                    }
  break;
case 288:
#line 1389 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new RNIf(thread, cond(((RNode)yyVals[-3+yyTop])), ((RNode)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 290:
#line 1396 "parse.y"
  {
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 294:
#line 1405 "parse.y"
  {
                        yyVal = new RNBlockNoArg(thread);
                    }
  break;
case 295:
#line 1409 "parse.y"
  {
                        yyVal = new RNBlockNoArg(thread);
                    }
  break;
case 296:
#line 1413 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 297:
#line 1419 "parse.y"
  {
                        yyVal = thread.DynaPush();
                    }
  break;
case 298:
#line 1425 "parse.y"
  {
                        yyVal = new RNIter(thread, ((RNode)yyVals[-2+yyTop]), null, ((RNode)yyVals[-1+yyTop]));
                        ((RNode)yyVal).FixPos((((RNode)yyVals[-2+yyTop]) != null) ? ((RNode)yyVals[-2+yyTop]) : ((RNode)yyVals[-1+yyTop]));
                        thread.DynaPop(((RVarmap)yyVals[-3+yyTop]));
                    }
  break;
case 299:
#line 1432 "parse.y"
  {
                        if (((RNode)yyVals[-1+yyTop]) != null && ((RNode)yyVals[-1+yyTop]) is RNBlockPass) {
                            thread.CompileError("both block arg and actual block given");
                        }
                        ((RNode)yyVals[0+yyTop]).iter = ((RNode)yyVals[-1+yyTop]);
                        yyVal = ((RNode)yyVals[0+yyTop]);
                        ((RNode)yyVal).FixPos(((RNode)yyVals[0+yyTop]));
                    }
  break;
case 300:
#line 1441 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 301:
#line 1446 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 302:
#line 1452 "parse.y"
  {
                        yyVal = new_fcall(((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[0+yyTop]));
                    }
  break;
case 303:
#line 1457 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-3+yyTop]));
                    }
  break;
case 304:
#line 1463 "parse.y"
  {
                        value_expr(((RNode)yyVals[-3+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-3+yyTop]));
                    }
  break;
case 305:
#line 1469 "parse.y"
  {
                        value_expr(((RNode)yyVals[-2+yyTop]));
                        yyVal = new_call(((RNode)yyVals[-2+yyTop]), ((uint)yyVals[0+yyTop]), null);
                    }
  break;
case 306:
#line 1474 "parse.y"
  {
                        if (!compile_for_eval && in_def == 0 &&
                            in_single == 0 && !in_defined)
                            yyerror("super called outside of method");
                        yyVal = new_super(((RNode)yyVals[0+yyTop]));
                    }
  break;
case 307:
#line 1481 "parse.y"
  {
                        if (!compile_for_eval && in_def == 0 &&
                            in_single == 0 && !in_defined)
                            yyerror("super called outside of method");
                        yyVal = new RNZSuper(thread, ruby);
                    }
  break;
case 308:
#line 1489 "parse.y"
  {
                        yyVal = thread.DynaPush();
                    }
  break;
case 309:
#line 1494 "parse.y"
  {
                        yyVal = new RNIter(thread, ((RNode)yyVals[-2+yyTop]), null, ((RNode)yyVals[-1+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-1+yyTop]));
                        thread.DynaPop(((RVarmap)yyVals[-3+yyTop]));
                    }
  break;
case 310:
#line 1500 "parse.y"
  {
                        yyVal = thread.DynaPush();
                    }
  break;
case 311:
#line 1505 "parse.y"
  {
                        yyVal = new RNIter(thread, ((RNode)yyVals[-2+yyTop]), null, ((RNode)yyVals[-1+yyTop]));
                        ((RNode)yyVal).FixPos(((RNode)yyVals[-1+yyTop]));
                        thread.DynaPop(((RVarmap)yyVals[-3+yyTop]));
                    }
  break;
case 312:
#line 1514 "parse.y"
  {
                        yyVal = new RNWhen(thread, ((RNode)yyVals[-3+yyTop]), ((RNode)yyVals[-1+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 314:
#line 1520 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = RNode.list_append(thread, ((RNode)yyVals[-3+yyTop]), new RNWhen(thread, ((RNode)yyVals[0+yyTop])));
                    }
  break;
case 315:
#line 1525 "parse.y"
  {
                        value_expr(((RNode)yyVals[0+yyTop]));
                        yyVal = new RNArray(thread, new RNWhen(thread, ((RNode)yyVals[0+yyTop])));
                    }
  break;
case 320:
#line 1537 "parse.y"
  {
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 322:
#line 1545 "parse.y"
  {
                        RNode nd = ((RNode)yyVals[-3+yyTop]);
                        RNode nd2 = ((RNode)yyVals[-1+yyTop]);
                        if (nd != null) {
                            nd = node_assign(((RNode)yyVals[-3+yyTop]), new RNGVar(thread, ruby, intern("$!")));
                            nd2 = block_append(nd, ((RNode)yyVals[-1+yyTop]));
                        }
                        yyVal = new RNResBody(thread, ((RNode)yyVals[-4+yyTop]), nd2, ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).FixPos((((RNode)yyVals[-4+yyTop]) != null) ? ((RNode)yyVals[-4+yyTop]) : nd2);
                    }
  break;
case 325:
#line 1559 "parse.y"
  {
                        if (((RNode)yyVals[0+yyTop]) != null)
                            yyVal = ((RNode)yyVals[0+yyTop]);
                        else
                            /* place holder */
                            yyVal = new RNNil(thread);
                    }
  break;
case 327:
#line 1569 "parse.y"
  {
                        if (((object)yyVals[0+yyTop]) is uint)
                            yyVal = Symbol.ID2SYM(((uint)yyVals[0+yyTop]));
                        else
                            yyVal = Symbol.ID2SYM(((char)yyVals[0+yyTop]));
                    }
  break;
case 329:
#line 1578 "parse.y"
  {
                        yyVal = new RNStr(thread, ruby, ((object)yyVals[0+yyTop]));
                    }
  break;
case 331:
#line 1583 "parse.y"
  {
                        if (((RNode)yyVals[-1+yyTop]) is RNDStr) {
                            RNode.list_append(thread, ((RNode)yyVals[-1+yyTop]), new RNStr(thread, ruby, ((string)yyVals[0+yyTop])));
                        }
                        else {
#if STRCONCAT
                            rb_str_concat(((RNode)yyVals[-1+yyTop]).lit, ((object)yyVals[0+yyTop]));
#else
                            ((RNode)yyVals[-1+yyTop]).lit = (string)(((RNode)yyVals[-1+yyTop]).lit) + ((string)yyVals[0+yyTop]);
#endif                      
                        }
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 332:
#line 1597 "parse.y"
  {
                        if (((RNode)yyVals[-1+yyTop]) is RNStr) {
                            yyVal = new RNDStr(thread, ruby, ((RNode)yyVals[-1+yyTop]).lit);
                        }
                        else {
                            yyVal = ((RNode)yyVals[-1+yyTop]);
                        }
                        ((RNode)yyVals[0+yyTop]).head = new RNStr(thread, ruby, ((RNode)yyVals[0+yyTop]).lit);
                        RNode.list_concat(((RNode)yyVal), new RNArray(thread, ((RNode)yyVals[0+yyTop])));
                    }
  break;
case 333:
#line 1609 "parse.y"
  {
                        lex.State = EXPR.END;
                        if (((object)yyVals[0+yyTop]) is uint)
                            yyVal = ((uint)yyVals[0+yyTop]);
                        else
                            yyVal = ((char)yyVals[0+yyTop]);
                    }
  break;
case 345:
#line 1630 "parse.y"
  {yyVal = (uint)Token.kNIL;}
  break;
case 346:
#line 1631 "parse.y"
  {yyVal = (uint)Token.kSELF;}
  break;
case 347:
#line 1632 "parse.y"
  {yyVal = (uint)Token.kTRUE;}
  break;
case 348:
#line 1633 "parse.y"
  {yyVal = (uint)Token.kFALSE;}
  break;
case 349:
#line 1634 "parse.y"
  {yyVal = (uint)Token.k__FILE__;}
  break;
case 350:
#line 1635 "parse.y"
  {yyVal = (uint)Token.k__LINE__;}
  break;
case 351:
#line 1638 "parse.y"
  {
                        yyVal = gettable(((uint)yyVals[0+yyTop]));
                    }
  break;
case 354:
#line 1646 "parse.y"
  {
                        yyVal = null;
                    }
  break;
case 355:
#line 1650 "parse.y"
  {
                        lex.State = EXPR.BEG;
                    }
  break;
case 356:
#line 1654 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 357:
#line 1657 "parse.y"
  {yyErrorFlag = 0; yyVal = null;}
  break;
case 358:
#line 1660 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-2+yyTop]);
                        lex.State = EXPR.BEG;
                    }
  break;
case 359:
#line 1665 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 360:
#line 1670 "parse.y"
  {
                        yyVal = block_append(new RNArgs(thread, ((int)yyVals[-5+yyTop]), ((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop])), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 361:
#line 1674 "parse.y"
  {
                        yyVal = block_append(new RNArgs(thread, ((int)yyVals[-3+yyTop]), ((RNode)yyVals[-1+yyTop]), -1), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 362:
#line 1678 "parse.y"
  {
                        yyVal = block_append(new RNArgs(thread, ((int)yyVals[-3+yyTop]), null, ((int)yyVals[-1+yyTop])), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 363:
#line 1682 "parse.y"
  {
                        yyVal = block_append(new RNArgs(thread, ((int)yyVals[-1+yyTop]), null, -1), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 364:
#line 1686 "parse.y"
  {
                        yyVal = block_append(new RNArgs(thread, 0, ((RNode)yyVals[-3+yyTop]), ((uint)yyVals[-1+yyTop])), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 365:
#line 1690 "parse.y"
  {
                        yyVal = block_append(new RNArgs(thread, 0, ((RNode)yyVals[-1+yyTop]), -1), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 366:
#line 1694 "parse.y"
  {
                        yyVal = block_append(new RNArgs(thread, 0, null, ((int)yyVals[-1+yyTop])), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 367:
#line 1698 "parse.y"
  {
                        yyVal = block_append(new RNArgs(thread, 0, null, -1), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 368:
#line 1702 "parse.y"
  {
                        yyVal = new RNArgs(thread, 0, null, -1);
                    }
  break;
case 369:
#line 1707 "parse.y"
  {
                        yyerror("formal argument cannot be a constant");
                    }
  break;
case 370:
#line 1711 "parse.y"
  {
                        yyerror("formal argument cannot be an instance variable");
                    }
  break;
case 371:
#line 1715 "parse.y"
  {
                        yyerror("formal argument cannot be a global variable");
                    }
  break;
case 372:
#line 1719 "parse.y"
  {
                        yyerror("formal argument cannot be a class variable");
                    }
  break;
case 373:
#line 1723 "parse.y"
  {
                        if (!is_local_id(((uint)yyVals[0+yyTop])))
                            yyerror("formal argument must be local variable");
                        else if (thread.LocalID(((uint)yyVals[0+yyTop])))
                            yyerror("duplicate argument name");
                        thread.LocalCnt(((uint)yyVals[0+yyTop]));
                        yyVal = 1;
                    }
  break;
case 375:
#line 1734 "parse.y"
  {
                        yyVal = ((int)yyVal) + 1;
                    }
  break;
case 376:
#line 1739 "parse.y"
  {
                        if (!is_local_id(((uint)yyVals[-2+yyTop])))
                            yyerror("formal argument must be local variable");
                        else if (thread.LocalID(((uint)yyVals[-2+yyTop])))
                            yyerror("duplicate optional argument name");
                        yyVal = assignable(((uint)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 377:
#line 1748 "parse.y"
  {
                        yyVal = new RNBlock(thread, ((RNode)yyVals[0+yyTop]));
                        ((RNode)yyVal).end = ((RNode)yyVal);
                    }
  break;
case 378:
#line 1753 "parse.y"
  {
                        yyVal = block_append(((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 379:
#line 1758 "parse.y"
  {
                        if (!is_local_id(((uint)yyVals[0+yyTop])))
                            yyerror("rest argument must be local variable");
                        else if (thread.LocalID(((uint)yyVals[0+yyTop])))
                            yyerror("duplicate rest argument name");
                        yyVal = thread.LocalCnt(((uint)yyVals[0+yyTop]));
                    }
  break;
case 380:
#line 1766 "parse.y"
  {
                        yyVal = -2;
                    }
  break;
case 381:
#line 1771 "parse.y"
  {
                        if (!is_local_id(((uint)yyVals[0+yyTop])))
                            yyerror("block argument must be local variable");
                        else if (thread.LocalID(((uint)yyVals[0+yyTop])))
                            yyerror("duplicate block argument name");
                        yyVal = new RNBlockArg(thread, ((uint)yyVals[0+yyTop]), thread.LocalCnt(((uint)yyVals[0+yyTop])));
                    }
  break;
case 382:
#line 1780 "parse.y"
  {
                        yyVal = ((RNode)yyVals[0+yyTop]);
                    }
  break;
case 384:
#line 1786 "parse.y"
  {
                        if (((RNode)yyVals[0+yyTop]) is RNSelf) {
                            yyVal = new RNSelf(thread);
                        }
                        else {
                            yyVal = ((RNode)yyVals[0+yyTop]);
                        }
                    }
  break;
case 385:
#line 1794 "parse.y"
  {lex.State = EXPR.BEG;}
  break;
case 386:
#line 1795 "parse.y"
  {
                        if (((RNode)yyVals[-2+yyTop]) is RNStr ||
                            ((RNode)yyVals[-2+yyTop]) is RNDStr ||
                            ((RNode)yyVals[-2+yyTop]) is RNXStr ||
                            ((RNode)yyVals[-2+yyTop]) is RNDXStr ||
                            ((RNode)yyVals[-2+yyTop]) is RNDRegx ||
                            ((RNode)yyVals[-2+yyTop]) is RNLit ||
                            ((RNode)yyVals[-2+yyTop]) is RNArray ||
                            ((RNode)yyVals[-2+yyTop]) is RNZArray)
                        {
                            yyerror("can't define single method for literals.");
                        }
                        yyVal = ((RNode)yyVals[-2+yyTop]);
                    }
  break;
case 388:
#line 1812 "parse.y"
  {
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 389:
#line 1816 "parse.y"
  {
                        if (((RNode)yyVals[-1+yyTop]).alen % 2 != 0) {
                            yyerror("odd number list for Hash");
                        }
                        yyVal = ((RNode)yyVals[-1+yyTop]);
                    }
  break;
case 391:
#line 1825 "parse.y"
  {
                        yyVal = RNode.list_concat(((RNode)yyVals[-2+yyTop]), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 392:
#line 1830 "parse.y"
  {
                        yyVal = RNode.list_append(thread, new RNArray(thread, ((RNode)yyVals[-2+yyTop])), ((RNode)yyVals[0+yyTop]));
                    }
  break;
case 412:
#line 1860 "parse.y"
  {yyErrorFlag = 0;}
  break;
case 415:
#line 1864 "parse.y"
  {yyErrorFlag = 0;}
  break;
case 416:
#line 1867 "parse.y"
  {
                        yyVal = null;
                    }
  break;
#line 2803 "-"
        }
        yyTop -= yyLen[yyN];
        yyState = yyStates[yyTop];
        int yyM = yyLhs[yyN];
        if (yyState == 0 && yyM == 0) {
//t          if (yydebug != null) yydebug.shift(0, yyFinal);
          yyState = yyFinal;
          if (yyToken < 0) {
            yyToken = yyLex.advance() ? yyLex.token() : 0;
//t            if (yydebug != null)
//t               yydebug.lex(yyState, yyToken,yyname(yyToken), yyLex.value());
          }
          if (yyToken == 0) {
//t            if (yydebug != null) yydebug.accept(yyVal);
            return yyVal;
          }
          goto yyLoop;
        }
        if (((yyN = yyGindex[yyM]) != 0) && ((yyN += yyState) >= 0)
            && (yyN < yyTable.Length) && (yyCheck[yyN] == yyState))
          yyState = yyTable[yyN];
        else
          yyState = yyDgoto[yyM];
//t        if (yydebug != null) yydebug.shift(yyStates[yyTop], yyState);
         goto yyLoop;
      }
    }
  }

   static  short [] yyLhs  = {              -1,
   74,    0,    5,    6,    6,    6,    6,   77,    7,    7,
    7,    7,    7,    7,    7,    7,    7,    7,   78,    7,
    7,    7,    7,    7,    7,    8,    8,    8,    8,    8,
    8,    8,    8,   12,   12,   37,   37,   37,   11,   11,
   11,   11,   11,   55,   55,   58,   58,   57,   57,   57,
   57,   57,   57,   59,   59,   56,   56,   60,   60,   60,
   60,   60,   60,   53,   53,   53,   53,   53,   53,   68,
   68,   69,   69,   69,   69,   69,   61,   61,   47,   80,
   47,   70,   70,   70,   70,   70,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,   79,   79,   79,
   79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
   79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
   79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
   79,   79,   79,   79,   79,   79,   79,   79,    9,   81,
    9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
    9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
    9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
    9,    9,    9,    9,    9,   83,    9,    9,    9,   29,
   29,   29,   29,   29,   29,   29,   26,   26,   26,   26,
   27,   27,   25,   25,   25,   25,   25,   25,   25,   25,
   25,   25,   85,   28,   31,   30,   30,   22,   22,   33,
   33,   34,   34,   34,   23,   10,   10,   10,   10,   10,
   10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
   10,   10,   10,   10,   10,   10,   10,   86,   10,   10,
   10,   10,   10,   10,   88,   90,   10,   91,   92,   10,
   10,   10,   93,   94,   10,   95,   10,   97,   98,   10,
   99,   10,  100,   10,  102,  103,   10,   10,   10,   10,
   10,   87,   87,   87,   89,   89,   14,   14,   15,   15,
   49,   49,   50,   50,   50,   50,  104,   52,   36,   36,
   36,   13,   13,   13,   13,   13,   13,  105,   51,  106,
   51,   16,   24,   24,   24,   17,   17,   19,   19,   20,
   20,   18,   18,   21,   21,    3,    3,    3,    2,    2,
    2,    2,   64,   63,   63,   63,   63,    4,    4,   62,
   62,   62,   62,   62,   62,   62,   62,   62,   62,   62,
   32,   48,   48,   35,  107,   35,   35,   38,   38,   39,
   39,   39,   39,   39,   39,   39,   39,   39,   72,   72,
   72,   72,   72,   73,   73,   41,   40,   40,   71,   71,
   42,   43,   43,    1,  108,    1,   44,   44,   44,   45,
   45,   46,   65,   65,   65,   66,   66,   66,   66,   67,
   67,   67,  101,  101,   75,   75,   82,   82,   84,   84,
   84,   96,   96,   76,   76,   54,
  };
   static  short [] yyLen = {           2,
    0,    2,    2,    1,    1,    3,    2,    0,    4,    3,
    3,    3,    2,    3,    3,    3,    3,    3,    0,    5,
    4,    3,    3,    3,    1,    3,    2,    1,    3,    3,
    2,    2,    1,    1,    1,    1,    4,    4,    2,    4,
    4,    2,    2,    1,    3,    1,    3,    1,    2,    3,
    2,    2,    1,    1,    3,    2,    3,    1,    4,    3,
    3,    3,    1,    1,    4,    3,    3,    3,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    0,
    4,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    3,    0,
    4,    6,    5,    5,    5,    3,    3,    3,    3,    3,
    3,    3,    3,    3,    2,    2,    3,    3,    3,    3,
    3,    3,    3,    3,    3,    3,    3,    3,    3,    2,
    2,    3,    3,    3,    3,    0,    4,    5,    1,    1,
    2,    4,    2,    5,    2,    3,    3,    4,    4,    6,
    1,    1,    1,    3,    2,    5,    2,    5,    4,    7,
    3,    1,    0,    2,    2,    2,    1,    1,    3,    1,
    1,    3,    4,    2,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    6,    3,    3,    2,    4,    3,
    3,    4,    3,    1,    4,    3,    1,    0,    6,    2,
    1,    2,    6,    6,    0,    0,    7,    0,    0,    7,
    5,    4,    0,    0,    9,    0,    6,    0,    0,    8,
    0,    5,    0,    9,    0,    0,   12,    1,    1,    1,
    1,    1,    1,    2,    1,    1,    1,    5,    1,    2,
    1,    1,    1,    2,    1,    3,    0,    5,    2,    4,
    4,    2,    4,    4,    3,    2,    1,    0,    5,    0,
    5,    5,    1,    4,    2,    1,    1,    1,    1,    2,
    1,    6,    1,    1,    2,    1,    1,    1,    1,    1,
    2,    2,    2,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    0,    4,    2,    4,    2,    6,
    4,    4,    2,    4,    2,    2,    1,    0,    1,    1,
    1,    1,    1,    1,    3,    3,    1,    3,    2,    1,
    2,    2,    1,    1,    0,    5,    1,    2,    2,    1,
    3,    3,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    0,    1,    0,    1,    0,    1,
    1,    1,    1,    1,    2,    0,
  };
   static  short [] yyDefRed = {            1,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  255,  258,    0,  278,  279,  280,  281,    0,    0,
    0,  346,  345,  347,  348,    0,    0,    0,   19,    0,
  350,  349,    0,    0,  342,  341,    0,  344,  338,  339,
  329,  228,  328,  330,  230,  231,  352,  353,  229,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  226,  326,    2,    0,    0,    0,    0,    0,    0,   28,
    0,  232,    0,   35,    0,    0,    4,    0,    0,   44,
    0,   54,    0,  327,    0,    0,   70,   71,    0,    0,
  271,  117,  129,  118,  142,  114,  135,  124,  123,  140,
  122,  121,  116,  145,  126,  115,  130,  134,  136,  128,
  120,  137,  147,  139,    0,    0,    0,    0,  113,  133,
  132,  127,  143,  146,  144,  148,  112,  119,  110,  111,
    0,    0,    0,   74,    0,  103,  104,  101,   85,   86,
   87,   90,   92,   88,  105,  106,   93,   94,   98,   89,
   91,   82,   83,   84,   95,   96,   97,   99,  100,  102,
  107,  385,    0,  384,  351,  273,   75,   76,  138,  131,
  141,  125,  108,  109,   72,   73,    0,   79,   78,   77,
    0,    0,    0,    0,    0,  413,  412,    0,    0,    0,
  414,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  291,  292,    0,    0,    0,    0,    0,    0,    0,    0,
    0,  203,    0,   27,  225,  212,    0,  390,    0,    0,
    0,   43,    0,  306,   42,    0,   31,    0,    8,  408,
    0,    0,    0,    0,    0,    0,  238,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  190,    0,    0,    0,
  387,    0,    0,   52,    0,  336,  335,  337,  333,  334,
    0,   32,    0,  331,  332,    3,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,  297,  299,  310,  308,  252,    0,    0,
    0,    0,    0,    0,    0,    0,   56,  150,  302,   39,
  250,    0,    0,  355,  266,  354,    0,    0,  404,  403,
  275,    0,   80,    0,    0,  323,  283,    0