Class: RubyParser

Inherits:

Racc::Parser

Object
Racc::Parser
RubyParser

Defined in:: lib/ruby_parser.rb,
lib/ruby_parser_extras.rb

Constant Summary collapse

Racc_arg =

[
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]

Racc_token_to_s_table =

[
'$end',
'error',
'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',
'tNTH_REF',
'tBACK_REF',
'tSTRING_CONTENT',
'tINTEGER',
'tFLOAT',
'tREGEXP_END',
'tUPLUS',
'tUMINUS',
'tUMINUS_NUM',
'tPOW',
'tCMP',
'tEQ',
'tEQQ',
'tNEQ',
'tGEQ',
'tLEQ',
'tANDOP',
'tOROP',
'tMATCH',
'tNMATCH',
'tDOT',
'tDOT2',
'tDOT3',
'tAREF',
'tASET',
'tLSHFT',
'tRSHFT',
'tCOLON2',
'tCOLON3',
'tOP_ASGN',
'tASSOC',
'tLPAREN',
'tLPAREN2',
'tRPAREN',
'tLPAREN_ARG',
'tLBRACK',
'tRBRACK',
'tLBRACE',
'tLBRACE_ARG',
'tSTAR',
'tSTAR2',
'tAMPER',
'tAMPER2',
'tTILDE',
'tPERCENT',
'tDIVIDE',
'tPLUS',
'tMINUS',
'tLT',
'tGT',
'tPIPE',
'tBANG',
'tCARET',
'tLCURLY',
'tRCURLY',
'tBACK_REF2',
'tSYMBEG',
'tSTRING_BEG',
'tXSTRING_BEG',
'tREGEXP_BEG',
'tWORDS_BEG',
'tAWORDS_BEG',
'tSTRING_DBEG',
'tSTRING_DVAR',
'tSTRING_END',
'tLAST_TOKEN',
'"?"',
'":"',
'"="',
'tLOWEST',
'"["',
'","',
'" "',
'"\n"',
'";"',
'$start',
'program',
'compstmt',
'bodystmt',
'@1',
'opt_rescue',
'opt_else',
'opt_ensure',
'stmts',
'opt_terms',
'none',
'stmt',
'terms',
'fitem',
'undef_list',
'expr_value',
'lhs',
'command_call',
'mlhs',
'var_lhs',
'primary_value',
'aref_args',
'backref',
'mrhs',
'arg_value',
'expr',
'@2',
'@3',
'arg',
'command',
'block_command',
'call_args',
'block_call',
'operation2',
'command_args',
'cmd_brace_block',
'opt_block_var',
'@4',
'@5',
'operation',
'mlhs_basic',
'mlhs_entry',
'mlhs_head',
'mlhs_item',
'mlhs_node',
'variable',
'cname',
'cpath',
'fname',
'op',
'reswords',
'symbol',
'@6',
'opt_nl',
'primary',
'args',
'trailer',
'assocs',
'paren_args',
'opt_paren_args',
'opt_block_arg',
'block_arg',
'call_args2',
'open_args',
'@7',
'@8',
'@9',
'none_block_pass',
'literal',
'strings',
'xstring',
'regexp',
'words',
'awords',
'var_ref',
'assoc_list',
'brace_block',
'method_call',
'then',
'if_tail',
'do',
'case_body',
'block_var',
'superclass',
'term',
'f_arglist',
'singleton',
'dot_or_colon',
'@10',
'@11',
'@12',
'@13',
'@14',
'@15',
'@16',
'@17',
'@18',
'@19',
'@20',
'@21',
'@22',
'@23',
'do_block',
'@24',
'@25',
'operation3',
'@26',
'@27',
'@28',
'@29',
'when_args',
'cases',
'exc_list',
'exc_var',
'numeric',
'dsym',
'string',
'string1',
'string_contents',
'xstring_contents',
'word_list',
'word',
'string_content',
'qword_list',
'string_dvar',
'@30',
'@31',
'sym',
'@32',
'f_args',
'f_arg',
'f_optarg',
'f_rest_arg',
'opt_f_block_arg',
'f_block_arg',
'f_norm_arg',
'f_opt',
'restarg_mark',
'blkarg_mark',
'@33',
'assoc']

Racc_debug_parser =

false

VERSION =

'1.0.1'

Instance Attribute Summary collapse

#comments ⇒ Object readonly

Returns the value of attribute comments.
#env ⇒ Object readonly

Returns the value of attribute env.
#file ⇒ Object

Returns the value of attribute file.
#in_def ⇒ Object

Returns the value of attribute in_def.
#in_single ⇒ Object

Returns the value of attribute in_single.
#lexer ⇒ Object

Returns the value of attribute lexer.

Instance Method Summary collapse

Constructor Details

#initialize ⇒ `RubyParser`

Returns a new instance of RubyParser.

# File 'lib/ruby_parser_extras.rb', line 251

def initialize
  super
  self.lexer = RubyLexer.new
  self.in_def = false
  self.in_single = 0
  @env = Environment.new
  @comments = []
end

Instance Attribute Details

#comments ⇒ `Object` (readonly)

Returns the value of attribute comments.



58
59
60

# File 'lib/ruby_parser_extras.rb', line 58

def comments
  @comments
end

#env ⇒ `Object` (readonly)

Returns the value of attribute env.



58
59
60

# File 'lib/ruby_parser_extras.rb', line 58

def env
  @env
end

#file ⇒ `Object`

Returns the value of attribute file.



57
58
59

# File 'lib/ruby_parser_extras.rb', line 57

def file
  @file
end

#in_def ⇒ `Object`

Returns the value of attribute in_def.



57
58
59

# File 'lib/ruby_parser_extras.rb', line 57

def in_def
  @in_def
end

#in_single ⇒ `Object`

Returns the value of attribute in_single.



57
58
59

# File 'lib/ruby_parser_extras.rb', line 57

def in_single
  @in_single
end

#lexer ⇒ `Object`

Returns the value of attribute lexer.



57
58
59

# File 'lib/ruby_parser_extras.rb', line 57

def lexer
  @lexer
end

Instance Method Details

#_reduce_1(val, _values, result) ⇒ `Object`

reduce 0 omitted

# File 'lib/ruby_parser.rb', line 2861

def _reduce_1( val, _values, result )
                self.lexer.lex_state = :expr_beg
 result
end

#_reduce_10(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2912

def _reduce_10( val, _values, result )
                result = s(:alias, val[1], val[3])
 result
end

#_reduce_100(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3418

def _reduce_100( val, _values, result )
                lexer.lex_state = :expr_end
                result = val[0];
 result
end

#_reduce_101(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3424

def _reduce_101( val, _values, result )
 result = s(:lit, val[0].to_sym)
 result
end

#_reduce_102(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3429

def _reduce_102( val, _values, result )
 result = s(:lit, val[0])
 result
end

#_reduce_103(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3434

def _reduce_103( val, _values, result )
                result = s(:undef, val[0])
 result
end

#_reduce_104(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3439

def _reduce_104( val, _values, result )
                lexer.lex_state = :expr_fname
 result
end

#_reduce_105(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3444

def _reduce_105( val, _values, result )
                result = self.block_append(val[0], s(:undef, val[3]))
 result
end

#_reduce_11(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2917

def _reduce_11( val, _values, result )
                result = s(:valias, val[1].to_sym, val[2].to_sym)
 result
end

#_reduce_12(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2922

def _reduce_12( val, _values, result )
               result = s(:valias, val[1].to_sym, :"$#{val[2].last}")
 result
end

#_reduce_13(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2927

def _reduce_13( val, _values, result )
                yyerror("can't make alias for the number variables");
 result
end

#_reduce_14(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2932

def _reduce_14( val, _values, result )
                result = val[1]
 result
end

#_reduce_15(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2937

def _reduce_15( val, _values, result )
               val[2] = cond val[2]
               if val[2][0] == :not then
                 result = s(:if, val[2].last, nil, val[0])
               else
                 result = s(:if, val[2], val[0], nil)
               end
 result
end

#_reduce_16(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2947

def _reduce_16( val, _values, result )
               val[2] = cond val[2]
               if val[2][0] == :not then
                 result = s(:if, val[2].last, val[0], nil)
               else
                 result = s(:if, val[2], nil, val[0])
               end
 result
end

#_reduce_17(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2957

def _reduce_17( val, _values, result )
               block, pre = val[0], true
               block, pre = block.last, false if block[0] == :begin

               val[2] = cond val[2]
               if val[2][0] == :not then
                 result = s(:until, val[2].last, block, pre)
               else
                 result = s(:while, val[2], block, pre)
               end
 result
end

#_reduce_173(val, _values, result) ⇒ `Object`

reduce 172 omitted

# File 'lib/ruby_parser.rb', line 3583

def _reduce_173( val, _values, result )
               result = self.node_assign(val[0], val[2])
 result
end

#_reduce_174(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3588

def _reduce_174( val, _values, result )
               result = self.node_assign(val[0],
                          s(:rescue, val[2], s(:resbody, nil, val[4])))
 result
end

#_reduce_175(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3594

def _reduce_175( val, _values, result )
               name = val[0].value
               asgn_op = val[1].to_sym

               val[2] = remove_begin(val[2])

               case asgn_op
               when :"||" then
                 val[0] << val[2]
                 result = s(:op_asgn_or, self.gettable(name), val[0]);
               when :"&&" then
                 val[0] << val[2]
                 result = s(:op_asgn_and, self.gettable(name), val[0]);
               else
                 val[0][2] = s(:call, self.gettable(name), asgn_op, s(:array, val[2]))
                 result = val[0];
               end
 result
end

#_reduce_176(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3614

def _reduce_176( val, _values, result )
                result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5]);
 result
end

#_reduce_177(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3619

def _reduce_177( val, _values, result )
                result = s(:op_asgn2, val[0], :"#{val[2].value}=", val[3].to_sym, val[4]);
 result
end

#_reduce_178(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3624

def _reduce_178( val, _values, result )
                result = s(:op_asgn2, val[0], :"#{val[2].value}=", val[3].to_sym, val[4])
 result
end

#_reduce_179(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3629

def _reduce_179( val, _values, result )
                result = s(:op_asgn, val[0], val[4], val[2].value, val[3].value);
 result
end

#_reduce_18(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2970

def _reduce_18( val, _values, result )
 # REFACTOR
               block, pre = val[0], true 
               block, pre = block.last, false if block[0] == :begin

               val[2] = cond val[2]
               if val[2][0] == :not then
                 result = s(:while, val[2].last, block, pre)
               else
                 result = s(:until, val[2], block, pre)
               end
 result
end

#_reduce_180(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3634

def _reduce_180( val, _values, result )
               yyerror("constant re-assignment");
 result
end

#_reduce_181(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3639

def _reduce_181( val, _values, result )
               yyerror("constant re-assignment");
 result
end

#_reduce_182(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3644

def _reduce_182( val, _values, result )
                self.backref_assign_error(val[0]);
 result
end

#_reduce_183(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3649

def _reduce_183( val, _values, result )
               v1, v2 = val[0], val[2]
               if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
                 result = s(:lit, (v1.last)..(v2.last))
               else
                 result = s(:dot2, v1, v2)
               end
 result
end

#_reduce_184(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3659

def _reduce_184( val, _values, result )
               v1, v2 = val[0], val[2]
               if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
                 result = s(:lit, (v1.last)...(v2.last))
               else
                 result = s(:dot3, v1, v2)
               end
 result
end

#_reduce_185(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3669

def _reduce_185( val, _values, result )
                result = s(:call, val[0], :+, s(:array, val[2]))
 result
end

#_reduce_186(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3674

def _reduce_186( val, _values, result )
                result = s(:call, val[0], :-, s(:array, val[2]))
 result
end

#_reduce_187(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3679

def _reduce_187( val, _values, result )
                result = s(:call, val[0], :*, s(:array, val[2]))
 result
end

#_reduce_188(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3684

def _reduce_188( val, _values, result )
                result = s(:call, val[0], :"/", s(:array, val[2]))
 result
end

#_reduce_189(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3689

def _reduce_189( val, _values, result )
                result = s(:call, val[0], :%, s(:array, val[2]))
 result
end

#_reduce_19(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2984

def _reduce_19( val, _values, result )
                result = s(:rescue, val[0], s(:resbody, nil, val[2]))
 result
end

#_reduce_190(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3694

def _reduce_190( val, _values, result )
               result = s(:call, val[0], :**, s(:array, val[2]))
 result
end

#_reduce_191(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3699

def _reduce_191( val, _values, result )
                result = s(:call, s(:call, s(:lit, val[1]), :"**", s(:array, val[3])), :"-@");
 result
end

#_reduce_192(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3704

def _reduce_192( val, _values, result )
                result = s(:call, s(:call, s(:lit, val[1]), :"**", s(:array, val[3])), :"-@");
 result
end

#_reduce_193(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3709

def _reduce_193( val, _values, result )
                if val[1][0] == :lit then
                  result = val[1]
                else
                  result = s(:call, val[1], :"+@")
                end
 result
end

#_reduce_194(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3718

def _reduce_194( val, _values, result )
                result = s(:call, val[1], :"-@");
 result
end

#_reduce_195(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3723

def _reduce_195( val, _values, result )
                result = s(:call, val[0], :"|", s(:array, val[2]));
 result
end

#_reduce_196(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3728

def _reduce_196( val, _values, result )
                result = s(:call, val[0], :"^", s(:array, val[2]));
 result
end

#_reduce_197(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3733

def _reduce_197( val, _values, result )
                result = s(:call, val[0], :"&", s(:array, val[2]));
 result
end

#_reduce_198(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3738

def _reduce_198( val, _values, result )
                result = s(:call, val[0], :"<=>", s(:array, val[2]));
 result
end

#_reduce_199(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3743

def _reduce_199( val, _values, result )
                result = s(:call, val[0], :">", s(:array, val[2]));
 result
end

#_reduce_2(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2866

def _reduce_2( val, _values, result )
                result = val[1]
 result
end

#_reduce_20(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2989

def _reduce_20( val, _values, result )
               if (self.in_def || self.in_single > 0) then
                 # yyerror("BEGIN in method"); HACK
               end
               self.env.extend;
 result
end

#_reduce_200(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3748

def _reduce_200( val, _values, result )
                result = s(:call, val[0], :">=", s(:array, val[2]));
 result
end

#_reduce_201(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3753

def _reduce_201( val, _values, result )
                result = s(:call, val[0], :"<", s(:array, val[2]));
 result
end

#_reduce_202(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3758

def _reduce_202( val, _values, result )
                result = s(:call, val[0], :"<=", s(:array, val[2]));
 result
end

#_reduce_203(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3763

def _reduce_203( val, _values, result )
                result = s(:call, val[0], :"==", s(:array, val[2]));
 result
end

#_reduce_204(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3768

def _reduce_204( val, _values, result )
                result = s(:call, val[0], :"===", s(:array, val[2]));
 result
end

#_reduce_205(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3773

def _reduce_205( val, _values, result )
                val[0] = value_expr val[0] # TODO: port call_op and clean these
                val[2] = value_expr val[2]
                result = s(:not, s(:call, val[0], :"==", s(:array, val[2])));
 result
end

#_reduce_206(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3780

def _reduce_206( val, _values, result )
                result = self.get_match_node(val[0], val[2])
 result
end

#_reduce_207(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3785

def _reduce_207( val, _values, result )
                result = s(:not, self.get_match_node(val[0], val[2]))
 result
end

#_reduce_208(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3790

def _reduce_208( val, _values, result )
                result = s(:not, val[1])
 result
end

#_reduce_209(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3795

def _reduce_209( val, _values, result )
                val[2] = value_expr val[2]
                result = s(:call, val[1], :"~");
 result
end

#_reduce_21(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2997

def _reduce_21( val, _values, result )
               result = s(:iter, s(:preexe), nil)
               result << val[3] if val[3]
               result = nil # TODO: since it isn't supposed to go in the AST
 result
end

#_reduce_210(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3801

def _reduce_210( val, _values, result )
                val[0] = value_expr val[0]
                val[2] = value_expr val[2]
                result = s(:call, val[0], :"<<", s(:array, val[2])) # " stupid emacs
 result
end

#_reduce_211(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3808

def _reduce_211( val, _values, result )
                val[0] = value_expr val[0]
                val[2] = value_expr val[2]
                result = s(:call, val[0], :">>", s(:array, val[2]))
 result
end

#_reduce_212(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3815

def _reduce_212( val, _values, result )
                result = logop(:and, val[0], val[2])
 result
end

#_reduce_213(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3820

def _reduce_213( val, _values, result )
                result = logop(:or, val[0], val[2])
 result
end

#_reduce_214(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3825

def _reduce_214( val, _values, result )
                result = s(:defined, val[2]);
 result
end

#_reduce_215(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3830

def _reduce_215( val, _values, result )
               result = s(:if, val[0], val[2], val[4]);
 result
end

#_reduce_217(val, _values, result) ⇒ `Object`

reduce 216 omitted

# File 'lib/ruby_parser.rb', line 3837

def _reduce_217( val, _values, result )
                result = value_expr(val[0])
 result
end

#_reduce_219(val, _values, result) ⇒ `Object`

reduce 218 omitted

# File 'lib/ruby_parser.rb', line 3844

def _reduce_219( val, _values, result )
               warning("parenthesize argument(s) for future version");
               result = s(:array, val[0]);
 result
end

#_reduce_22(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3004

def _reduce_22( val, _values, result )
               if (self.in_def || self.in_single > 0) then
                 # yyerror("END in method; use at_exit"); HACK
               end
               result = s(:iter, s(:postexe), nil)
               result << val[2] if val[2]
 result
end

#_reduce_220(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3850

def _reduce_220( val, _values, result )
               result = val[0];
 result
end

#_reduce_221(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3855

def _reduce_221( val, _values, result )
               result = self.arg_concat(val[0], val[3])
 result
end

#_reduce_222(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3860

def _reduce_222( val, _values, result )
               result = s(:array, s(:hash, *val[0].values))
 result
end

#_reduce_223(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3865

def _reduce_223( val, _values, result )
               result = s(:splat, val[1])
               result.paren = true
 result
end

#_reduce_224(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3871

def _reduce_224( val, _values, result )
                result = val[1]
 result
end

#_reduce_225(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3876

def _reduce_225( val, _values, result )
                result = val[1];
 result
end

#_reduce_226(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3881

def _reduce_226( val, _values, result )
                warning("parenthesize argument(s) for future version");
                result = s(:array, val[1]);
 result
end

#_reduce_227(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3887

def _reduce_227( val, _values, result )
                warning("parenthesize argument(s) for future version");
                result = val[1].add(val[3]);
 result
end

#_reduce_23(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3013

def _reduce_23( val, _values, result )
                result = self.node_assign(val[0], val[2])
 result
end

#_reduce_230(val, _values, result) ⇒ `Object`

reduce 229 omitted

# File 'lib/ruby_parser.rb', line 3897

def _reduce_230( val, _values, result )
                warning("parenthesize argument(s) for future version");
                result = s(:array, val[0])
 result
end

#_reduce_231(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3903

def _reduce_231( val, _values, result )
               result = self.arg_blk_pass(val[0], val[1]);
 result
end

#_reduce_232(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3908

def _reduce_232( val, _values, result )
               result = self.arg_concat(val[0], val[3]);
               result = self.arg_blk_pass(result, val[4]);
 result
end

#_reduce_233(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3914

def _reduce_233( val, _values, result )
               result = s(:array, s(:hash, *val[0].values))
               result = self.arg_blk_pass(result, val[1]);
 result
end

#_reduce_234(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3920

def _reduce_234( val, _values, result )
               result = self.arg_concat(s(:array, s(:hash, *val[0].values)), val[3])
               result = self.arg_blk_pass(result, val[4]);
 result
end

#_reduce_235(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3926

def _reduce_235( val, _values, result )
               result = val[0] << s(:hash, *val[2].values)
               result = self.arg_blk_pass(result, val[3]);
 result
end

#_reduce_236(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3932

def _reduce_236( val, _values, result )
               val[0] << s(:hash, *val[2].values)
               result = self.arg_concat(val[0], val[5])
               result = self.arg_blk_pass(result, val[6]);
 result
end

#_reduce_237(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3939

def _reduce_237( val, _values, result )
                result = self.arg_blk_pass(s(:splat, val[1]), val[2])
 result
end

#_reduce_239(val, _values, result) ⇒ `Object`

reduce 238 omitted

# File 'lib/ruby_parser.rb', line 3946

def _reduce_239( val, _values, result )
                result = self.arg_blk_pass(s(:array, val[0], val[2]), val[3])
 result
end

#_reduce_24(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3018

def _reduce_24( val, _values, result )
                val[2] = value_expr(val[2])
                result = val[0] << if val[0][1] then
                                     s(:to_ary, val[2])
                                   else
                                     val[0].delete_at 1 # remove the nil
                                     s(:array, val[2])
                                   end
 result
end

#_reduce_240(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3951

def _reduce_240( val, _values, result )
                result = self.arg_blk_pass(val[0], val[2]);
 result
end

#_reduce_241(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3956

def _reduce_241( val, _values, result )
                result = self.arg_concat(s(:array, val[0]), val[3]);
                result = self.arg_blk_pass(result, val[4]);
 result
end

#_reduce_242(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3962

def _reduce_242( val, _values, result )
                result = self.arg_concat(s(:array, val[0], s(:hash, *val[2].values)), val[5])
                result = self.arg_blk_pass(result, val[6]);
 result
end

#_reduce_243(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3968

def _reduce_243( val, _values, result )
                result = s(:array, s(:hash, *val[0].values));
                result = self.arg_blk_pass(result, val[1]);
 result
end

#_reduce_244(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3974

def _reduce_244( val, _values, result )
                result = s(:array, s(:hash, *val[0].values), val[3])
                result = self.arg_blk_pass(result, val[4])
 result
end

#_reduce_245(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3980

def _reduce_245( val, _values, result )
                result = s(:array, val[0], s(:hash, *val[2].values))
                result = self.arg_blk_pass(result, val[3])
 result
end

#_reduce_246(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3986

def _reduce_246( val, _values, result )
                result = s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values));
                result = self.arg_blk_pass(result, val[5]);
 result
end

#_reduce_247(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3992

def _reduce_247( val, _values, result )
                result = self.arg_concat(s(:array, val[0]).add(s(:hash, *val[2].values)), val[5]);
                result = self.arg_blk_pass(result, val[6]);
 result
end

#_reduce_248(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3998

def _reduce_248( val, _values, result )
                result = self.arg_concat(s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)), val[7]);
                result = self.arg_blk_pass(result, val[8]);
 result
end

#_reduce_249(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4004

def _reduce_249( val, _values, result )
                result = self.arg_blk_pass(s(:splat, val[1]), val[2]);
 result
end

#_reduce_25(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3029

def _reduce_25( val, _values, result )
                name = val[0].last
                asgn_op = val[1].to_sym
                val[2] = value_expr(val[2])

                case asgn_op
                when :"||" then
                  val[0][2] = (val[2]);
                  result = s(:op_asgn_or,  self.gettable(name), val[0])
                when :"&&" then
                  val[0][2] = (val[2]);
                  result = s(:op_asgn_and, self.gettable(name), val[0])
                else
                  result = val[0]
                  result << s(:call, self.gettable(name), asgn_op, s(:array, val[2]))
              end
 result
end

#_reduce_251(val, _values, result) ⇒ `Object`

reduce 250 omitted

# File 'lib/ruby_parser.rb', line 4011

def _reduce_251( val, _values, result )
                result = lexer.cmdarg.stack.dup
                lexer.cmdarg.push true
 result
end

#_reduce_252(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4017

def _reduce_252( val, _values, result )
                lexer.cmdarg.stack.replace val[0]
                result = val[1]
 result
end

#_reduce_254(val, _values, result) ⇒ `Object`

reduce 253 omitted

# File 'lib/ruby_parser.rb', line 4025

def _reduce_254( val, _values, result )
               lexer.lex_state = :expr_endarg
 result
end

#_reduce_255(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4030

def _reduce_255( val, _values, result )
                warning("don't put space before argument parentheses");
                result = nil;
 result
end

#_reduce_256(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4036

def _reduce_256( val, _values, result )
               lexer.lex_state = :expr_endarg
 result
end

#_reduce_257(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4041

def _reduce_257( val, _values, result )
                warning("don't put space before argument parentheses");
                result = val[1];
 result
end

#_reduce_258(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4047

def _reduce_258( val, _values, result )
                result = s(:block_pass, val[1]);
 result
end

#_reduce_259(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4052

def _reduce_259( val, _values, result )
                result = val[1];
 result
end

#_reduce_26(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3048

def _reduce_26( val, _values, result )
                result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5]);
 result
end

#_reduce_261(val, _values, result) ⇒ `Object`

reduce 260 omitted

# File 'lib/ruby_parser.rb', line 4059

def _reduce_261( val, _values, result )
               result = s(:array, val[0])
 result
end

#_reduce_262(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4064

def _reduce_262( val, _values, result )
               result = val[0] << val[2]
               # result = self.list_append(val[0], val[2]) # TODO? breaks stuff
 result
end

#_reduce_263(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4070

def _reduce_263( val, _values, result )
               result = val[0] << val[2]
               # result = self.list_append(val[0], val[2]) # TODO? breaks stuff
 result
end

#_reduce_264(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4076

def _reduce_264( val, _values, result )
               result = self.arg_concat(val[0], val[3])
 result
end

#_reduce_265(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4081

def _reduce_265( val, _values, result )
               result = s(:splat, val[1])
 result
end

#_reduce_27(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3053

def _reduce_27( val, _values, result )
                result = s(:op_asgn, val[0], val[4], val[2].value, val[3].value);
 result
end

#_reduce_274(val, _values, result) ⇒ `Object`

reduce 273 omitted

# File 'lib/ruby_parser.rb', line 4102

def _reduce_274( val, _values, result )
               result = s(:fcall, val[0].to_sym)
 result
end

#_reduce_275(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4107

def _reduce_275( val, _values, result )
               unless val[1] then
                 result = s(:nil)
               else
                 result = s(:begin, val[1])
               end
 result
end

#_reduce_276(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4116

def _reduce_276( val, _values, result )
                lexer.lex_state = :expr_endarg
 result
end

#_reduce_277(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4121

def _reduce_277( val, _values, result )
                warning("(...) interpreted as grouped expression");
                result = val[1];
 result
end

#_reduce_278(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4127

def _reduce_278( val, _values, result )
               result = val[1];
               result.paren = true
 result
end

#_reduce_279(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4133

def _reduce_279( val, _values, result )
               result = s(:colon2, val[0], val[2].to_sym)
 result
end

#_reduce_28(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3058

def _reduce_28( val, _values, result )
                result = s(:op_asgn, val[0], val[4], val[2].value, val[3].value);
 result
end

#_reduce_280(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4138

def _reduce_280( val, _values, result )
               result = s(:colon3, val[1].to_sym)
 result
end

#_reduce_281(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4143

def _reduce_281( val, _values, result )
               if val[0].node_type == :self then
                 result = s(:fcall, :"[]")
               else
                 result = s(:call, val[0], :"[]")
               end
               result << val[2] if val[2]
 result
end

#_reduce_282(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4153

def _reduce_282( val, _values, result )
                result = val[1] || s(:zarray)
 result
end

#_reduce_283(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4158

def _reduce_283( val, _values, result )
               result = s(:hash, *val[1].values)
 result
end

#_reduce_284(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4163

def _reduce_284( val, _values, result )
               result = s(:return)
 result
end

#_reduce_285(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4168

def _reduce_285( val, _values, result )
               result = self.new_yield(val[2]);
 result
end

#_reduce_286(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4173

def _reduce_286( val, _values, result )
               result = s(:yield)
 result
end

#_reduce_287(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4178

def _reduce_287( val, _values, result )
               result = s(:yield)
 result
end

#_reduce_288(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4183

def _reduce_288( val, _values, result )
               result = s(:defined, val[3]);
 result
end

#_reduce_289(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4188

def _reduce_289( val, _values, result )
               name = val[0].to_sym
               iter = val[1]
#                 iter[2] = iter[2][1] if iter[2][0] == :block and iter[2].size == 2 # HACK
               iter.insert 1, s(:fcall, name)
               result = iter
 result
end

#_reduce_29(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3063

def _reduce_29( val, _values, result )
                result = s(:op_asgn, val[0], val[4], val[2].value, val[3].value);
 result
end

#_reduce_291(val, _values, result) ⇒ `Object`

reduce 290 omitted

# File 'lib/ruby_parser.rb', line 4199

def _reduce_291( val, _values, result )
               call = val[0]
               iter = val[1]
#                 iter[2] = iter[2][1] if iter[2][0] == :block and iter[2].size == 2 # HACK
               iter.insert 1, call
               result = iter
 result
end

#_reduce_292(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4208

def _reduce_292( val, _values, result )
               val[1] = cond val[1]
               if val[1][0] == :not then
                 result = s(:if, val[1].last, val[4], val[3])
               else
                 result = s(:if, val[1], val[3], val[4])
               end
 result
end

#_reduce_293(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4218

def _reduce_293( val, _values, result )
               val[1] = cond val[1]
               if val[1][0] == :not then
                 result = s(:if, val[1].last, val[3], val[4])
               else
                 result = s(:if, val[1], val[4], val[3])
               end
 result
end

#_reduce_294(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4228

def _reduce_294( val, _values, result )
               lexer.cond.push true
 result
end

#_reduce_295(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4233

def _reduce_295( val, _values, result )
               lexer.cond.pop
 result
end

#_reduce_296(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4238

def _reduce_296( val, _values, result )
               block = val[5]
               val[2] = cond val[2]
               if val[2][0] == :not then
                 result = s(:until, val[2].last, block, true);
               else
                 result = s(:while, val[2], block, true);
               end
 result
end

#_reduce_297(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4249

def _reduce_297( val, _values, result )
               lexer.cond.push true
 result
end

#_reduce_298(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4254

def _reduce_298( val, _values, result )
               lexer.cond.pop
 result
end

#_reduce_299(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4259

def _reduce_299( val, _values, result )
               block = val[5]
               val[2] = cond val[2]
               if val[2][0] == :not then
                 result = s(:while, val[2].last, block, true);
               else
                 result = s(:until, val[2], block, true);
               end
 result
end

#_reduce_3(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2871

def _reduce_3( val, _values, result )
                result = val[0]

                if val[1] then
                  result = s(:rescue)
                  result << val[0] if val[0]
                  result << val[1] if val[1]
                  result << val[2] if val[2]
                elsif not val[2].nil? then
                  warning("else without rescue is useless")
                  result = block_append(result, val[2])
                end

                result = s(:ensure, result, val[3]).compact if val[3]
 result
end

#_reduce_30(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3068

def _reduce_30( val, _values, result )
                self.backref_assign_error(val[0]);
 result
end

#_reduce_300(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4270

def _reduce_300( val, _values, result )
                result = s(:case, val[1]);

                body = val[3]
                while body and body.node_type == :when
                  result << body
                  body = body.delete_at 3
                end

                els = body

                if els and els != s(:block) then
                  result << els
                else
                  result << nil
                end
 result
end

#_reduce_301(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4289

def _reduce_301( val, _values, result )
                result = s(:case, nil); # REFACTOR

                body = val[2]
                while body and body.first == :when
                  result << body
                  body = body.delete_at 3
                end

                els = body

                if els and els != s(:block) then
                  result << els
                else
                  result << nil
                end
 result
end

#_reduce_302(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4308

def _reduce_302( val, _values, result )
 # TODO: need a test
               result = s(:case, nil, val[3])
 result
end

#_reduce_303(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4314

def _reduce_303( val, _values, result )
               lexer.cond.push true
 result
end

#_reduce_304(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4319

def _reduce_304( val, _values, result )
               lexer.cond.pop;
 result
end

#_reduce_305(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4324

def _reduce_305( val, _values, result )
               result = s(:for, val[4], val[1])
               result << val[7] if val[7]
 result
end

#_reduce_306(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4330

def _reduce_306( val, _values, result )
                self.comments.push self.lexer.comments
                if (self.in_def || self.in_single > 0) then
                  yyerror("class definition in method body");
                end
                self.env.extend
 result
end

#_reduce_307(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4339

def _reduce_307( val, _values, result )
                scope = s(:scope, val[4]).compact
                result = s(:class, val[1].last.to_sym, val[2], scope)
                result.comments = self.comments.pop
                self.env.unextend
 result
end

#_reduce_308(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4347

def _reduce_308( val, _values, result )
                result = self.in_def
                self.in_def = false
 result
end

#_reduce_309(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4353

def _reduce_309( val, _values, result )
                result = self.in_single
                self.in_single = 0
                self.env.extend;
 result
end

#_reduce_31(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3073

def _reduce_31( val, _values, result )
                result = self.node_assign(val[0], s(:svalue, val[2]))
 result
end

#_reduce_310(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4360

def _reduce_310( val, _values, result )
                scope = s(:scope, val[6]).compact
                result = s(:sclass, val[2], scope)
                self.env.unextend;
                self.in_def = val[3]
                self.in_single = val[5]
 result
end

#_reduce_311(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4369

def _reduce_311( val, _values, result )
               self.comments.push self.lexer.comments
               yyerror("module definition in method body") if
                 self.in_def or self.in_single > 0

               self.env.extend;
 result
end

#_reduce_312(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4378

def _reduce_312( val, _values, result )
               body = val[3] ? s(:scope, val[3]) : s(:scope)
               result = s(:module, val[1].last.to_sym, body)
               result.comments = self.comments.pop
               self.env.unextend;
 result
end

#_reduce_313(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4386

def _reduce_313( val, _values, result )
               self.comments.push self.lexer.comments
               self.in_def = true
               self.env.extend
 result
end

#_reduce_314(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4393

def _reduce_314( val, _values, result )
               name, args, body = val[1], val[3], val[4] # TODO: refactor
               name = name.to_sym
               body ||= s(:nil)

               block_arg = args.block_arg(:remove)
               body = self.block_append(args, body, body && body[0] == :block)
               body.insert 2, block_arg if block_arg
               result = s(:defn, name, s(:scope, body))
               result.comments = self.comments.pop

               self.env.unextend
               self.in_def = false
 result
end

#_reduce_315(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4409

def _reduce_315( val, _values, result )
 # 0-2, 3
               self.comments.push self.lexer.comments
               lexer.lex_state = :expr_fname
 result
end

#_reduce_316(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4416

def _reduce_316( val, _values, result )
                   # 4, 5
               self.in_single += 1
               self.env.extend;
               lexer.lex_state = :expr_end # force for args
 result
end

#_reduce_317(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4424

def _reduce_317( val, _values, result )
 # 6-8
               recv, name, args, body = val[1], val[4], val[6], val[7]

               block_arg = args.block_arg(:remove)
               body = self.block_append(args, body, body && body[0] == :block)
               body.insert 2, block_arg if block_arg

               result = s(:defs, recv, name.to_sym, s(:scope, body))
               result.comments = self.comments.pop

               self.env.unextend;
               self.in_single -= 1
 result
end

#_reduce_318(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4440

def _reduce_318( val, _values, result )
                result = s(:break)
 result
end

#_reduce_319(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4445

def _reduce_319( val, _values, result )
                result = s(:next)
 result
end

#_reduce_32(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3078

def _reduce_32( val, _values, result )
               result = val[0] << if val[0][1] then
                                    s(:to_ary, val[2])
                                  else
                                    val[0].delete_at 1 if val[0][1].nil?
                                    s(:array, val[2])
                                  end
 result
end

#_reduce_320(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4450

def _reduce_320( val, _values, result )
                result = s(:redo)
 result
end

#_reduce_321(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4455

def _reduce_321( val, _values, result )
                result = s(:retry)
 result
end

#_reduce_322(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4460

def _reduce_322( val, _values, result )
                result = value_expr(val[0])
 result
end

#_reduce_33(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3088

def _reduce_33( val, _values, result )
               val[0].delete_at 1 if val[0][1].nil?
               result = val[0] << val[2]
 result
end

#_reduce_331(val, _values, result) ⇒ `Object`

reduce 330 omitted

# File 'lib/ruby_parser.rb', line 4481

def _reduce_331( val, _values, result )
                result = s(:if, val[1], val[3], val[4]);
 result
end

#_reduce_333(val, _values, result) ⇒ `Object`

reduce 332 omitted

# File 'lib/ruby_parser.rb', line 4488

def _reduce_333( val, _values, result )
                result = val[1];
 result
end

#_reduce_335(val, _values, result) ⇒ `Object`

reduce 334 omitted

# File 'lib/ruby_parser.rb', line 4495

def _reduce_335( val, _values, result )
 val[0].delete_at 1 if val[0][1].nil?
 result
end

#_reduce_337(val, _values, result) ⇒ `Object`

reduce 336 omitted

# File 'lib/ruby_parser.rb', line 4502

def _reduce_337( val, _values, result )
                result = 0
 result
end

#_reduce_338(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4507

def _reduce_338( val, _values, result )
                result = 0
 result
end

#_reduce_339(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4512

def _reduce_339( val, _values, result )
                result = val[1];
 result
end

#_reduce_340(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4517

def _reduce_340( val, _values, result )
                self.env.extend :dynamic
 result
end

#_reduce_341(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4522

def _reduce_341( val, _values, result )
 result = self.env.dynamic.keys
 result
end

#_reduce_342(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4527

def _reduce_342( val, _values, result )
                vars = val[2]
                body = val[4]

                result = s(:iter)
                result << vars
                result << val[1] if val[1]
                result << body if body

                self.env.unextend;
 result
end

#_reduce_343(val, _values, result) ⇒ `Object`

Raises:

(SyntaxError)

# File 'lib/ruby_parser.rb', line 4540

def _reduce_343( val, _values, result )
              raise SyntaxError, "Both block arg and actual block given." if
                val[0] && val[0][0] == :blockpass

              result = val[1]
              result.insert 1, val[0]
 result
end

#_reduce_344(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4549

def _reduce_344( val, _values, result )
                result = s(:call, val[0], val[2]);
                result << val[3] if val[3]
 result
end

#_reduce_345(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4555

def _reduce_345( val, _values, result )
                result = s(:call, val[0], val[2]);
                result << val[3] if val[3]
 result
end

#_reduce_346(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4561

def _reduce_346( val, _values, result )
                result = new_fcall(val[0].to_sym, val[1])
 result
end

#_reduce_347(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4566

def _reduce_347( val, _values, result )
                result = new_call(val[0], val[2].to_sym, val[3])
 result
end

#_reduce_348(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4571

def _reduce_348( val, _values, result )
                result = new_call(val[0], val[2].to_sym, val[3])
 result
end

#_reduce_349(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4576

def _reduce_349( val, _values, result )
                result = new_call(val[0], val[2].to_sym)
 result
end

#_reduce_350(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4581

def _reduce_350( val, _values, result )
                result = self.new_super(val[1]);
 result
end

#_reduce_351(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4586

def _reduce_351( val, _values, result )
                result = s(:zsuper)
 result
end

#_reduce_352(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4591

def _reduce_352( val, _values, result )
                self.env.extend :dynamic
 result
end

#_reduce_353(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4596

def _reduce_353( val, _values, result )
 result = self.env.dynamic.keys
 result
end

#_reduce_354(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4601

def _reduce_354( val, _values, result )
 # REFACTOR
                args = val[2]
                body = val[4]
                result = s(:iter)
                result << args
                result << body if body
                self.env.unextend
 result
end

#_reduce_355(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4612

def _reduce_355( val, _values, result )
                self.env.extend :dynamic
 result
end

#_reduce_356(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4617

def _reduce_356( val, _values, result )
 result = self.env.dynamic.keys
 result
end

#_reduce_357(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4622

def _reduce_357( val, _values, result )
                args = val[2]
                body = val[4]
                result = s(:iter)
                result << args
                result << body if body
                self.env.unextend
 result
end

#_reduce_358(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4632

def _reduce_358( val, _values, result )
                result = s(:when, val[1], val[3])
                result << val[4] if val[4]
 result
end

#_reduce_36(val, _values, result) ⇒ `Object`

reduce 35 omitted

# File 'lib/ruby_parser.rb', line 3098

def _reduce_36( val, _values, result )
                result = logop(:and, val[0], val[2])
 result
end

#_reduce_360(val, _values, result) ⇒ `Object`

reduce 359 omitted

# File 'lib/ruby_parser.rb', line 4640

def _reduce_360( val, _values, result )
                result = self.list_append(val[0], s(:when, val[3], nil))
 result
end

#_reduce_361(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4645

def _reduce_361( val, _values, result )
                result = s(:array, s(:when, val[1], nil));
 result
end

#_reduce_364(val, _values, result) ⇒ `Object`

reduce 363 omitted

# File 'lib/ruby_parser.rb', line 4654

def _reduce_364( val, _values, result )
                result = s(:resbody, val[1])
                if val[2] then
                  val[2] = node_assign(val[2], s(:gvar, :"$!"))

                  strip = val[4] && val[4][0] == :block
                  val[4] = block_append(val[2], val[4])
                  val[4].push(*val[4].pop[1..-1]) if strip # HACK removes nested block from block_append
                end

                result << val[4] if val[4]
                result << val[5] if val[5]
 result
end

#_reduce_365(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4669

def _reduce_365( val, _values, result )
result = nil;
 result
end

#_reduce_366(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4674

def _reduce_366( val, _values, result )
                result = s(:array, val[0]);
 result
end

#_reduce_369(val, _values, result) ⇒ `Object`

reduce 368 omitted

# File 'lib/ruby_parser.rb', line 4683

def _reduce_369( val, _values, result )
                result = val[1];
 result
end

#_reduce_37(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3103

def _reduce_37( val, _values, result )
                result = logop(:or, val[0], val[2])
 result
end

#_reduce_371(val, _values, result) ⇒ `Object`

reduce 370 omitted

# File 'lib/ruby_parser.rb', line 4690

def _reduce_371( val, _values, result )
                if (val[1] != nil) then
                    result = val[1];
                else
                    result = s(:nil)
                end
 result
end

#_reduce_373(val, _values, result) ⇒ `Object`

reduce 372 omitted

# File 'lib/ruby_parser.rb', line 4701

def _reduce_373( val, _values, result )
 result = s(:lit, val[0])
 result
end

#_reduce_374(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4706

def _reduce_374( val, _values, result )
 result = s(:lit, val[0])
 result
end

#_reduce_376(val, _values, result) ⇒ `Object`

reduce 375 omitted

# File 'lib/ruby_parser.rb', line 4713

def _reduce_376( val, _values, result )
                val[0] = s(:dstr, val[0].value) if val[0][0] == :evstr
                result = val[0];
 result
end

#_reduce_378(val, _values, result) ⇒ `Object`

reduce 377 omitted

# File 'lib/ruby_parser.rb', line 4721

def _reduce_378( val, _values, result )
                result = self.literal_concat(val[0], val[1]);
 result
end

#_reduce_379(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4726

def _reduce_379( val, _values, result )
                result = val[1];
 result
end

#_reduce_38(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3108

def _reduce_38( val, _values, result )
                result = s(:not, val[1])
 result
end

#_reduce_380(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4731

def _reduce_380( val, _values, result )
                node = val[1]

                unless node then
                  node = s(:xstr, '')
                else
                  case node[0]
                  when :str
                    node[0] = :xstr
                  when :dstr
                    node[0] = :dxstr
                  else
                    node = s(:dxstr, '', node)
                  end
                end

                result = node
 result
end

#_reduce_381(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4751

def _reduce_381( val, _values, result )
                node = val[1] || s(:str, '')
                options = val[2]

                o, k = 0, nil
                options.split(//).each do |c| # FIX: this has a better home
                  v = {
                       'x' => Regexp::EXTENDED,
                       'i' => Regexp::IGNORECASE,
                       'm' => Regexp::MULTILINE,
                       'o' => Regexp::ONCE,
                       'n' => Regexp::ENC_NONE,
                       'e' => Regexp::ENC_EUC,
                       's' => Regexp::ENC_SJIS,
                       'u' => Regexp::ENC_UTF8,
                       }[c]
                  raise "unknown regexp option: #{c}" unless v
                  o += v
                  k = c if c =~ /[esu]/
                end

                case node[0]
                when :str then
                  node[0] = :lit
                  node[1] = if k then
                              Regexp.new(node[1], o, k)
                            else
                              Regexp.new(node[1], o)
                            end
                when :dstr then
                  if options =~ /o/ then
                    node[0] = :dregx_once
                  else
                    node[0] = :dregx
                  end
                  node << o if o and o != 0
                else
                  node = s(:dregx, '', node);
                  node[0] = :dregx_once if options =~ /o/
                  node << o if o and o != 0
                end

                result = node
 result
end

#_reduce_382(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4797

def _reduce_382( val, _values, result )
                 result = s(:zarray);
 result
end

#_reduce_383(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4802

def _reduce_383( val, _values, result )
               result = val[1];
 result
end

#_reduce_384(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4807

def _reduce_384( val, _values, result )
                 result = s(:array)
 result
end

#_reduce_385(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4812

def _reduce_385( val, _values, result )
                 word = val[1][0] == :evstr ? s(:dstr, '', val[1]) : val[1]
                 result = val[0] << word
 result
end

#_reduce_387(val, _values, result) ⇒ `Object`

reduce 386 omitted

# File 'lib/ruby_parser.rb', line 4820

def _reduce_387( val, _values, result )
                 result = self.literal_concat(val[0], val[1]);
 result
end

#_reduce_388(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4825

def _reduce_388( val, _values, result )
                 result = s(:zarray)
 result
end

#_reduce_389(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4830

def _reduce_389( val, _values, result )
                 result = val[1]
 result
end

#_reduce_39(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3113

def _reduce_39( val, _values, result )
                result = s(:not, val[1])
 result
end

#_reduce_390(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4835

def _reduce_390( val, _values, result )
                 result = s(:array)
 result
end

#_reduce_391(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4840

def _reduce_391( val, _values, result )
                 result = val[0] << val[1]
 result
end

#_reduce_392(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4845

def _reduce_392( val, _values, result )
 result = s(:str, "")
 result
end

#_reduce_393(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4850

def _reduce_393( val, _values, result )
                   result = literal_concat(val[0], val[1])
 result
end

#_reduce_394(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4855

def _reduce_394( val, _values, result )
 result = nil
 result
end

#_reduce_395(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4860

def _reduce_395( val, _values, result )
                  result = literal_concat(val[0], val[1])
 result
end

#_reduce_397(val, _values, result) ⇒ `Object`

reduce 396 omitted

# File 'lib/ruby_parser.rb', line 4867

def _reduce_397( val, _values, result )
                 result = lexer.lex_strterm;
                 lexer.lex_strterm = nil
                 lexer.lex_state = :expr_beg
 result
end

#_reduce_398(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4874

def _reduce_398( val, _values, result )
                 lexer.lex_strterm = val[1]
                 result = s(:evstr, val[2]);
 result
end

#_reduce_399(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4880

def _reduce_399( val, _values, result )
                 result = lexer.lex_strterm;
                 lexer.lex_strterm = nil
                 lexer.lex_state = :expr_beg
                 lexer.cond.push false
                 lexer.cmdarg.push false
 result
end

#_reduce_4(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2888

def _reduce_4( val, _values, result )
               result = void_stmts(val[0])
 result
end

#_reduce_400(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4889

def _reduce_400( val, _values, result )
                 lexer.lex_strterm = val[1]
                 lexer.cond.lexpop
                 lexer.cmdarg.lexpop
                 case val[2][0]
                 when :str, :dstr, :evstr then
                   result = val[2]
                 else
                   result = s(:evstr, val[2])
                 end
 result
end

#_reduce_401(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4902

def _reduce_401( val, _values, result )
                 result = s(:gvar, val[0].to_sym);
 result
end

#_reduce_402(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4907

def _reduce_402( val, _values, result )
                 result = s(:ivar, val[0].to_sym);
 result
end

#_reduce_403(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4912

def _reduce_403( val, _values, result )
                 result = s(:cvar, val[0].to_sym);
 result
end

#_reduce_405(val, _values, result) ⇒ `Object`

reduce 404 omitted

# File 'lib/ruby_parser.rb', line 4919

def _reduce_405( val, _values, result )
                 lexer.lex_state = :expr_end
                 result = val[1].to_sym
 result
end

#_reduce_41(val, _values, result) ⇒ `Object`

reduce 40 omitted

# File 'lib/ruby_parser.rb', line 3120

def _reduce_41( val, _values, result )
                result = value_expr(val[0])
 result
end

#_reduce_410(val, _values, result) ⇒ `Object`

reduce 409 omitted

# File 'lib/ruby_parser.rb', line 4933

def _reduce_410( val, _values, result )
                 lexer.lex_state = :expr_end
                 result = val[1]

                 yyerror("empty symbol literal") if result.nil? or result.empty?

                 case result[0]
                 when :dstr then
                   result[0] = :dsym
                 when :str then
                   result = s(:lit, result.last.intern)
                 else
                   result = s(:dsym, '', result)
                 end
 result
end

#_reduce_413(val, _values, result) ⇒ `Object`

reduce 412 omitted

# File 'lib/ruby_parser.rb', line 4954

def _reduce_413( val, _values, result )
               result = -val[1] # TODO: pt_testcase
 result
end

#_reduce_414(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4959

def _reduce_414( val, _values, result )
               result = -val[1] # TODO: pt_testcase
 result
end

#_reduce_420(val, _values, result) ⇒ `Object`

reduce 419 omitted

# File 'lib/ruby_parser.rb', line 4974

def _reduce_420( val, _values, result )
               result = s(:nil)
 result
end

#_reduce_421(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4979

def _reduce_421( val, _values, result )
               result = s(:self)
 result
end

#_reduce_422(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4984

def _reduce_422( val, _values, result )
               result = s(:true)
 result
end

#_reduce_423(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4989

def _reduce_423( val, _values, result )
               result = s(:false)
 result
end

#_reduce_424(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4994

def _reduce_424( val, _values, result )
               result = :"__FILE__"
 result
end

#_reduce_425(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 4999

def _reduce_425( val, _values, result )
               result = :"__LINE__"
 result
end

#_reduce_426(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5004

def _reduce_426( val, _values, result )
                 result = self.gettable(val[0])
 result
end

#_reduce_427(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5009

def _reduce_427( val, _values, result )
                 result = self.assignable(val[0]);
 result
end

#_reduce_430(val, _values, result) ⇒ `Object`

reduce 429 omitted

# File 'lib/ruby_parser.rb', line 5018

def _reduce_430( val, _values, result )
               result = nil;
 result
end

#_reduce_431(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5023

def _reduce_431( val, _values, result )
               lexer.lex_state = :expr_beg
 result
end

#_reduce_432(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5028

def _reduce_432( val, _values, result )
               result = val[2];
 result
end

#_reduce_433(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5033

def _reduce_433( val, _values, result )
               yyerrok;
               result = nil;
 result
end

#_reduce_434(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5039

def _reduce_434( val, _values, result )
                 result = val[1];
                 lexer.lex_state = :expr_beg
 result
end

#_reduce_435(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5045

def _reduce_435( val, _values, result )
                 result = val[0];
 result
end

#_reduce_436(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5050

def _reduce_436( val, _values, result )
               result = val[0]
               if val[2] then
                 val[2][1..-1].each do |lasgn| # FIX clean sexp iter
                   raise "wtf? #{lasgn.inspect}" unless lasgn[0] == :lasgn
                   result << lasgn[1]
                 end
               end
               result << val[4] if val[4]
               result << val[2] if val[2]
               result << val[5] if val[5]
 result
end

#_reduce_437(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5064

def _reduce_437( val, _values, result )
               result = val[0]
               if val[2] then
                 val[2][1..-1].each do |lasgn| # FIX clean sexp iter
                   raise "wtf? #{lasgn.inspect}" unless lasgn[0] == :lasgn
                   result << lasgn[1]
                 end
               end
               result << val[2] if val[2]
               result << val[3] if val[3]
 result
end

#_reduce_438(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5077

def _reduce_438( val, _values, result )
               result = val[0]
               result << val[2] if val[2]
               result << val[3] if val[3]
 result
end

#_reduce_439(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5084

def _reduce_439( val, _values, result )
               result = val[0]
               result << val[1] if val[1]
 result
end

#_reduce_44(val, _values, result) ⇒ `Object`

reduce 43 omitted

# File 'lib/ruby_parser.rb', line 3129

def _reduce_44( val, _values, result )
               result = s(:return, ret_args(val[1]))
 result
end

#_reduce_440(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5090

def _reduce_440( val, _values, result )
               result = s(:args)
               if val[0] then
                 val[0][1..-1].each do |lasgn| # FIX clean sexp iter
                   raise "wtf? #{lasgn.inspect}" unless lasgn[0] == :lasgn
                   result << lasgn[1]
                 end
               end

               result << val[2] if val[2]
               result << val[0] if val[0]
               result << val[3] if val[3]
 result
end

#_reduce_441(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5105

def _reduce_441( val, _values, result )
               result = s(:args)
               if val[0] then
                 val[0][1..-1].each do |lasgn| # FIX clean sexp iter
                   raise "wtf? #{lasgn.inspect}" unless lasgn[0] == :lasgn
                   result << lasgn[1]
                 end
               end

               result << val[0] if val[0]
               result << val[1] if val[1]
 result
end

#_reduce_442(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5119

def _reduce_442( val, _values, result )
                 result = s(:args, val[0], val[1]).compact
 result
end

#_reduce_443(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5124

def _reduce_443( val, _values, result )
                 result = s(:args, val[0]).compact
 result
end

#_reduce_444(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5129

def _reduce_444( val, _values, result )
                 result = s(:args)
 result
end

#_reduce_445(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5134

def _reduce_445( val, _values, result )
               yyerror("formal argument cannot be a constant");
 result
end

#_reduce_446(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5139

def _reduce_446( val, _values, result )
               yyerror("formal argument cannot be an instance variable");
 result
end

#_reduce_447(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5144

def _reduce_447( val, _values, result )
               yyerror("formal argument cannot be a class variable");
 result
end

#_reduce_448(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5149

def _reduce_448( val, _values, result )
               identifier = val[0].to_sym
               self.env[identifier] = :lvar

               result = val[0];
 result
end

#_reduce_449(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5157

def _reduce_449( val, _values, result )
                 result = s(:args)
                 result << val[0].to_sym
 result
end

#_reduce_45(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3134

def _reduce_45( val, _values, result )
               result = s(:break, ret_args(val[1]))
 result
end

#_reduce_450(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5163

def _reduce_450( val, _values, result )
                 val[0] << val[2].to_sym
                 result = val[0]
 result
end

#_reduce_451(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5169

def _reduce_451( val, _values, result )
                 result = self.assignable(val[0], val[2]);
                 # TODO: detect duplicate names
 result
end

#_reduce_452(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5175

def _reduce_452( val, _values, result )
               result = s(:block, val[0])
 result
end

#_reduce_453(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5180

def _reduce_453( val, _values, result )
               result = self.append_to_block(val[0], val[2]);
 result
end

#_reduce_456(val, _values, result) ⇒ `Object`

reduce 455 omitted

# File 'lib/ruby_parser.rb', line 5189

def _reduce_456( val, _values, result )
 # TODO: differs from parse.y - needs tests
                name = val[1].to_sym
                self.assignable(name)
                result = :"*#{name}"
 result
end

#_reduce_457(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5197

def _reduce_457( val, _values, result )
               name = :"*"
               self.env[name] = self.env.dynamic? ? :dvar : :lvar # FIX
               result = name
 result
end

#_reduce_46(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3139

def _reduce_46( val, _values, result )
               result = s(:next, ret_args(val[1]))
 result
end

#_reduce_460(val, _values, result) ⇒ `Object`

reduce 459 omitted

# File 'lib/ruby_parser.rb', line 5208

def _reduce_460( val, _values, result )
                identifier = val[1].to_sym

                self.env[identifier] = self.env.dynamic? ? :dvar : :lvar
                result = s(:block_arg, identifier.to_sym)
 result
end

#_reduce_461(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5216

def _reduce_461( val, _values, result )
                result = val[1];
 result
end

#_reduce_462(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5221

def _reduce_462( val, _values, result )
               result = nil;
 result
end

#_reduce_464(val, _values, result) ⇒ `Object`

reduce 463 omitted

# File 'lib/ruby_parser.rb', line 5228

def _reduce_464( val, _values, result )
               lexer.lex_state = :expr_beg
 result
end

#_reduce_465(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5233

def _reduce_465( val, _values, result )
               if (val[2].instanceof ILiteralNode) then
                  yyerror("Can't define single method for literals.");
               end
               result = val[2];
 result
end

#_reduce_466(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5241

def _reduce_466( val, _values, result )
 #  [!nil]
                result = s(:array)
 result
end

#_reduce_467(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5247

def _reduce_467( val, _values, result )
 #  [!nil]
                result = val[0];
 result
end

#_reduce_468(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5253

def _reduce_468( val, _values, result )
                size = val[0].size
                if (size % 2 != 1) then # != 1 because of leading :array
                  yyerror("Odd number (#{size}) list for Hash. #{val[0].inspect}");
                end
                result = val[0];
 result
end

#_reduce_470(val, _values, result) ⇒ `Object`

reduce 469 omitted

# File 'lib/ruby_parser.rb', line 5264

def _reduce_470( val, _values, result )
                list = val[0].dup
                more = val[2][1..-1]
                list.push(*more) unless more.empty?
                result = list
 result
end

#_reduce_471(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5272

def _reduce_471( val, _values, result )
                result = s(:array, val[0], val[2])
 result
end

#_reduce_48(val, _values, result) ⇒ `Object`

reduce 47 omitted

# File 'lib/ruby_parser.rb', line 3146

def _reduce_48( val, _values, result )
                result = s(:call, val[0], val[2], val[3]);
 result
end

#_reduce_49(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3151

def _reduce_49( val, _values, result )
                result = s(:call, val[0], val[2], val[3]);
 result
end

#_reduce_491(val, _values, result) ⇒ `Object`

reduce 490 omitted

# File 'lib/ruby_parser.rb', line 5315

def _reduce_491( val, _values, result )
 yyerrok
 result
end

#_reduce_494(val, _values, result) ⇒ `Object`

reduce 493 omitted

# File 'lib/ruby_parser.rb', line 5324

def _reduce_494( val, _values, result )
 yyerrok
 result
end

#_reduce_495(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5329

def _reduce_495( val, _values, result )
 result = nil
 result
end

#_reduce_496(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 5334

def _reduce_496( val, _values, result )
 result = nil
 result
end

#_reduce_50(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3156

def _reduce_50( val, _values, result )
                  self.env.extend :dynamic
 result
end

#_reduce_51(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3161

def _reduce_51( val, _values, result )
 result = self.env.dynamic.keys
 result
end

#_reduce_52(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3166

def _reduce_52( val, _values, result )
                  result = s(:iter, val[2], val[4])
                  self.env.unextend;
 result
end

#_reduce_53(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3172

def _reduce_53( val, _values, result )
               result = new_fcall(val[0].to_sym, val[1])
 result
end

#_reduce_54(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3177

def _reduce_54( val, _values, result )
               result = new_fcall(val[0].to_sym, val[1])
               if val[2] then
                 if result[0] == :block_pass then
                    raise "both block arg and actual block given"
                 end
                 val[2] << result
                 result = val[2]
               end
 result
end

#_reduce_55(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3189

def _reduce_55( val, _values, result )
               result = new_call(val[0], val[2].to_sym, val[3])
 result
end

#_reduce_56(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3194

def _reduce_56( val, _values, result )
               result = new_call(val[0], val[2].to_sym, val[3])
 result
end

#_reduce_57(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3199

def _reduce_57( val, _values, result )
               result = new_call(val[0], val[2].to_sym, val[3])
 result
end

#_reduce_58(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3204

def _reduce_58( val, _values, result )
               result = new_call(val[0], val[2].to_sym, val[3])
               if val[4] then
                 if result[0] == :block_pass then # REFACTOR
                   raise "both block arg and actual block given"
                 end
                 val[2] << result
                 result = val[2]
               end
 result
end

#_reduce_59(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3216

def _reduce_59( val, _values, result )
               result = self.new_super(val[1]);
 result
end

#_reduce_60(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3221

def _reduce_60( val, _values, result )
               result = self.new_yield(val[1]);
 result
end

#_reduce_62(val, _values, result) ⇒ `Object`

reduce 61 omitted

# File 'lib/ruby_parser.rb', line 3228

def _reduce_62( val, _values, result )
                result = val[1];
 result
end

#_reduce_64(val, _values, result) ⇒ `Object`

reduce 63 omitted

# File 'lib/ruby_parser.rb', line 3235

def _reduce_64( val, _values, result )
                result = s(:masgn, s(:array, val[1]));
 result
end

#_reduce_65(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3240

def _reduce_65( val, _values, result )
                result = s(:masgn, val[0]);
 result
end

#_reduce_66(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3245

def _reduce_66( val, _values, result )
                result = s(:masgn, val[0] << val[1].compact);
 result
end

#_reduce_67(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3250

def _reduce_67( val, _values, result )
                result = s(:masgn, val[0], val[2]);
 result
end

#_reduce_68(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3255

def _reduce_68( val, _values, result )
                result = s(:masgn, val[0], s(:splat))
 result
end

#_reduce_69(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3260

def _reduce_69( val, _values, result )
                result = s(:masgn, nil, val[1]);
 result
end

#_reduce_7(val, _values, result) ⇒ `Object`

reduce 6 omitted

# File 'lib/ruby_parser.rb', line 2897

def _reduce_7( val, _values, result )
               result = self.block_append(val[0], val[2])
 result
end

#_reduce_70(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3265

def _reduce_70( val, _values, result )
                result = s(:masgn, nil, s(:splat))
 result
end

#_reduce_72(val, _values, result) ⇒ `Object`

reduce 71 omitted

# File 'lib/ruby_parser.rb', line 3272

def _reduce_72( val, _values, result )
                result = val[1];
 result
end

#_reduce_73(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3277

def _reduce_73( val, _values, result )
                result = s(:array, val[0])
 result
end

#_reduce_74(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3282

def _reduce_74( val, _values, result )
                result = val[0] << val[1].compact
 result
end

#_reduce_75(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3287

def _reduce_75( val, _values, result )
               result = self.assignable(val[0])
 result
end

#_reduce_76(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3292

def _reduce_76( val, _values, result )
               result = self.aryset(val[0], val[2]);
 result
end

#_reduce_77(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3297

def _reduce_77( val, _values, result )
               result = s(:attrasgn, val[0], :"#{val[2].value}=");
 result
end

#_reduce_78(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3302

def _reduce_78( val, _values, result )
               result = s(:attrasgn, val[0], :"#{val[2].value}=");
 result
end

#_reduce_79(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3307

def _reduce_79( val, _values, result )
               result = s(:attrasgn, val[0], :"#{val[2].value}=");
 result
end

#_reduce_8(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2902

def _reduce_8( val, _values, result )
               result = val[1];
 result
end

#_reduce_80(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3312

def _reduce_80( val, _values, result )
               if (self.in_def || self.in_single > 0) then
                 yyerror("dynamic constant assignment");
               end

               result = s(:constdecl, nil,
                          s(:colon2, val[0], val[2].value), nil)
 result
end

#_reduce_81(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3322

def _reduce_81( val, _values, result )
               if (self.in_def || self.in_single > 0) then
                 yyerror("dynamic constant assignment");
               end

               result = s(:const, nil, s(:colon3, val[1].to_sym))
 result
end

#_reduce_82(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3331

def _reduce_82( val, _values, result )
                self.backref_assign_error(val[0]);
 result
end

#_reduce_83(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3336

def _reduce_83( val, _values, result )
               result = self.assignable(val[0])
 result
end

#_reduce_84(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3341

def _reduce_84( val, _values, result )
               result = self.aryset(val[0], val[2]);
 result
end

#_reduce_85(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3346

def _reduce_85( val, _values, result )
               result = s(:attrasgn, val[0], :"#{val[2].value}=");
 result
end

#_reduce_86(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3351

def _reduce_86( val, _values, result )
               result = s(:attrasgn, val[0], :"#{val[2].value}=");
 result
end

#_reduce_87(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3356

def _reduce_87( val, _values, result )
               result = s(:attrasgn, val[0], :"#{val[2].value}=");
 result
end

#_reduce_88(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3361

def _reduce_88( val, _values, result )
               if (self.in_def || self.in_single > 0) then
                 yyerror("dynamic constant assignment");
               end

               result = s(:constdecl, nil, s(:colon2, val[0], val[2].value), nil);
 result
end

#_reduce_89(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3370

def _reduce_89( val, _values, result )
                if (self.in_def || self.in_single > 0) then
                  yyerror("dynamic constant assignment");
                end

                result = s(:const, nil, s(:colon3, val[1].to_sym))
 result
end

#_reduce_9(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 2907

def _reduce_9( val, _values, result )
 lexer.lex_state = :expr_fname
 result
end

#_reduce_90(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3379

def _reduce_90( val, _values, result )
                 self.backref_assign_error(val[0]);
 result
end

#_reduce_91(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3384

def _reduce_91( val, _values, result )
                yyerror("class/module name must be CONSTANT");
 result
end

#_reduce_93(val, _values, result) ⇒ `Object`

reduce 92 omitted

# File 'lib/ruby_parser.rb', line 3391

def _reduce_93( val, _values, result )
                result = s(:colon3, val[1].to_sym)
 result
end

#_reduce_94(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3396

def _reduce_94( val, _values, result )
                result = s(:colon2, nil, val[0].value);
 result
end

#_reduce_95(val, _values, result) ⇒ `Object`

# File 'lib/ruby_parser.rb', line 3401

def _reduce_95( val, _values, result )
                result = s(:colon2, val[0], val[2].value);
 result
end

#_reduce_99(val, _values, result) ⇒ `Object`

reduce 98 omitted

# File 'lib/ruby_parser.rb', line 3412

def _reduce_99( val, _values, result )
                lexer.lex_state = :expr_end
                result = val[0];
 result
end

#_reduce_none(val, _values, result) ⇒ `Object`



5339
5340
5341

# File 'lib/ruby_parser.rb', line 5339

def _reduce_none( val, _values, result )
 result
end

#append_to_block(head, tail) ⇒ `Object`

FIX: wtf is this?!? switch to block_append

# File 'lib/ruby_parser_extras.rb', line 60

def append_to_block head, tail # FIX: wtf is this?!? switch to block_append
  return head if tail.nil?
  return tail if head.nil?

  head = s(:block, head) unless head.node_type == :block
  head << tail
end

#arg_add(node1, node2) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 68

def arg_add(node1, node2)
  return s(:array, node2) unless node1
  return node1 << node2 if node1[0] == :array
  return s(:argspush, node1, node2)
end

#arg_blk_pass(node1, node2) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 74

def arg_blk_pass node1, node2
  if node2 then
    node2.insert 1, node1
    return node2
  else
    node1
  end
end

#arg_concat(node1, node2) ⇒ `Object`



83
84
85

# File 'lib/ruby_parser_extras.rb', line 83

def arg_concat node1, node2
  return node2.nil? ? node1 : s(:argscat, node1, node2)
end

#aryset(receiver, index) ⇒ `Object`



87
88
89

# File 'lib/ruby_parser_extras.rb', line 87

def aryset receiver, index
  s(:attrasgn, receiver, :"[]=", index)
end

#assignable(lhs, value = nil) ⇒ `Object`

Raises:

(SyntaxError)

# File 'lib/ruby_parser_extras.rb', line 91

def assignable(lhs, value = nil)
  id = lhs.to_sym
  id = id.to_sym if Sexp === id

  raise SyntaxError, "Can't change the value of #{id}" if
    id.to_s =~ /^(?:self|nil|true|false|__LINE__|__FILE__)$/

  result = case id.to_s
           when /^@@/ then
             asgn = in_def || in_single > 0
             s((asgn ? :cvasgn : :cvdecl), id)
           when /^@/ then
             s(:iasgn, id)
           when /^\$/ then
             s(:gasgn, id)
           when /^[A-Z]/ then
             s(:cdecl, id)
           else
             case self.env[id]
             when :lvar then
               s(:lasgn, id)
             when :dvar, nil then
               if self.env.current[id] == :dvar then
                 s(:dasgn_curr, id)
               elsif self.env[id] == :dvar then
                 self.env.use(id)
                 s(:dasgn, id)
               elsif ! self.env.dynamic? then
                 s(:lasgn, id)
               else
                 s(:dasgn_curr, id)
               end
             else
               raise "wtf? unknown type: #{self.env[id]}"
             end
           end

  self.env[id] = (self.env.dynamic? ? :dvar : :lvar) unless self.env[id]

  result << value if value

  return result
end

#block_append(head, tail, strip_tail_block = false) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 135

def block_append(head, tail, strip_tail_block=false)
  return head unless tail
  return tail unless head

  case head[0]
  when :lit, :str then
    return tail
  end

  head = remove_begin(head)
  head = s(:block, head) unless head[0] == :block

  if strip_tail_block and Sexp === tail and tail[0] == :block then
    head.push(*tail.values)
  else
    head << tail
  end
end

#cond(node) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 154

def cond node
  return nil if node.nil?
  node = value_expr node

  case node.first
  when :dregex then
    return s(:match2, node, s(:gvar, "$_".to_sym))
  when :regex then
    return s(:match, node)
  when :lit then
    if Regexp === node.last then
      return s(:match, node)
    else
      return node
    end
  when :and then
    return s(:and, cond(node[1]), cond(node[2]))
  when :or then
    return s(:or,  cond(node[1]), cond(node[2]))
  when :dot2 then
    label = "flip#{node.hash}"
    env[label] = self.env.dynamic? ? :dvar : :lvar
    return s(:flip2, node[1], node[2])
  when :dot3 then
    label = "flip#{node.hash}"
    env[label] = self.env.dynamic? ? :dvar : :lvar
    return s(:flip3, node[1], node[2])
  else
    return node
  end
end

#do_parse ⇒ `Object`

for pure ruby systems only



189
190
191

# File 'lib/ruby_parser_extras.rb', line 189

def do_parse
  _racc_do_parse_rb(_racc_setup, false)
end

#get_match_node(lhs, rhs) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 193

def get_match_node lhs, rhs
  if lhs then
    case lhs[0]
    when :dregx, :dregx_once then
      return s(:match2, lhs, rhs)
    when :lit then
      return s(:match2, lhs, rhs) if Regexp === lhs.last
    end
  end

  if rhs then
    case rhs[0]
    when :dregx, :dregx_once then
      return s(:match3, rhs, lhs)
    when :lit then
      return s(:match3, rhs, lhs) if Regexp === rhs.last
    end
  end

  return s(:call, lhs, :"=~", s(:array, rhs))
end

#gettable(id) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 215

def gettable(id)
  id = id.to_sym if Sexp === id # HACK
  id = id.to_sym if String === id # HACK

  return s(:self)                  if id == :self
  return s(:nil)                   if id == :nil
  return s(:true)                  if id == :true
  return s(:false)                 if id == :false
  return s(:str, self.file)        if id == :"__FILE__"
  return s(:lit, lexer.src.current_line) if id == :"__LINE__"

  result = case id.to_s
           when /^@@/ then
             s(:cvar, id)
           when /^@/ then
             s(:ivar, id)
           when /^\$/ then
             s(:gvar, id)
           when /^[A-Z]/ then
             s(:const, id)
           else
             type = env[id]
             if type then
               s(type, id)
             elsif env.dynamic? and :dvar == env[id] then
               s(:dvar, id)
             else
               s(:vcall, id)
             end
           end

  return result if result

  raise "identifier #{id.inspect} is not valid"
end

#list_append(list, item) ⇒ `Object`

TODO: nuke me sigh

# File 'lib/ruby_parser_extras.rb', line 260

def list_append list, item # TODO: nuke me *sigh*
  return s(:array, item) unless list
  list << item
end

#literal_concat(head, tail) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 265

def literal_concat head, tail
  return tail unless head
  return head unless tail

  htype, ttype = head[0], tail[0]

  head = s(:dstr, '', head) if htype == :evstr

  case ttype
  when :str then
    if htype == :str
      head[-1] << tail[-1]
    elsif htype == :dstr and head.size == 2 then
      head[-1] << tail[-1]
    else
      head << tail
    end
  when :dstr then
    if htype == :str then
      tail[1] = head[-1] + tail[1]
      head = tail
    else
      tail[0] = :array
      tail[1] = s(:str, tail[1])
      tail.delete_at 1 if tail[1] == s(:str, '')

      head.push(*tail[1..-1])
    end
  when :evstr then
    head[0] = :dstr if htype == :str
    if head.size == 2 and tail[1][0] == :str then
      head[-1] << tail[1][-1]
      head[0] = :str if head.size == 2 # HACK ?
    else
      head.push(tail)
    end
  end

  return head
end

#logop(type, left, right) ⇒ `Object`

TODO: rename logical_op

# File 'lib/ruby_parser_extras.rb', line 306

def logop(type, left, right) # TODO: rename logical_op
  left = value_expr left

  if left and left[0] == type and not left.paren then
    node, second = left, nil

    while (second = node[2]) && second[0] == type and not second.paren do
      node = second
    end

    node[2] = s(type, second, right)

    return left
  end

  return s(type, left, right)
end

#new_call(recv, meth, args = nil) ⇒ `Object`

REFACTOR - merge with fcall

# File 'lib/ruby_parser_extras.rb', line 324

def new_call recv, meth, args = nil # REFACTOR - merge with fcall
  if args && args[0] == :block_pass then
    new_args = args.array(true) || args.argscat(true) || args.splat(true)
    call = s(:call, recv, meth)
    call << new_args if new_args
    args << call

    return args
  end
  result = s(:call, recv, meth)
  result << args if args
  result
end

#new_fcall(meth, args) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 338

def new_fcall meth, args
  if args and args[0] == :block_pass then
    new_args = args.array(true) || args.argscat(true) || args.splat(true)
    call = s(:fcall, meth)
    call << new_args if new_args
    args << call
    return args
  end

  r = s(:fcall, meth)
  r << args if args and args != s(:array)
  r
end

#new_super(args) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 352

def new_super args
  if args && args.node_type == :block_pass then
    t, body, bp = args
    result = s(t, bp, s(:super, body))
  else
    result = s(:super)
    result << args if args and args != s(:array)
  end
  result
end

#new_yield(node) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 363

def new_yield(node)
  if node then
    raise SyntaxError, "Block argument should not be given." if
      node.node_type == :block_pass

    node = node.last if node.node_type == :array and node.size == 2
  end

  return s(:yield, node)
end

#next_token ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 374

def next_token
  if self.lexer.advance then
    [self.lexer.token, self.lexer.yacc_value]
  else
    return [false, '$end']
  end
end

#node_assign(lhs, rhs) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 382

def node_assign(lhs, rhs)
  return nil unless lhs

  rhs = value_expr rhs

  case lhs[0]
  when :gasgn, :iasgn, :lasgn, :dasgn, :dasgn_curr,
    :masgn, :cdecl, :cvdecl, :cvasgn then
    lhs << rhs
  when :attrasgn, :call then
    args = lhs.array(true) || lhs.argscat(true) || lhs.splat(true) # FIX: fragile
    lhs << arg_add(args, rhs)
  end

  lhs
end

#parse(str, file = "(string)") ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 399

def parse(str, file = "(string)")
  raise "bad val: #{str.inspect}" unless String === str

  self.file = file
  self.lexer.src = str

  @yydebug = ENV.has_key? 'DEBUG'

  do_parse
end

#remove_begin(node) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 410

def remove_begin node
  node = node[-1] if node and node[0] == :begin and node.size == 2
  node
end

#ret_args(node) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 415

def ret_args node
  if node then
    raise SyntaxError, "block argument should not be given" if
      node[0] == :block_pass

    node = node.last if node[0] == :array && node.size == 2
    # HACK matz wraps ONE of the FOUR splats in a newline to
    # distinguish. I use paren for now. ugh
    node = s(:svalue, node) if node[0] == :splat and not node.paren
  end

  node
end

#value_expr(node) ⇒ `Object`

HACK

# File 'lib/ruby_parser_extras.rb', line 429

def value_expr node # HACK
  node = remove_begin node
  node[2] = value_expr(node[2]) if node and node[0] == :if
  node
end

#void_stmts(node) ⇒ `Object`

# File 'lib/ruby_parser_extras.rb', line 435

def void_stmts node
  return nil unless node
  return node unless node[0] == :block

  node[1..-2] = node[1..-2].map { |n| remove_begin(n) }
  node
end

#warning(s) ⇒ `Object`



443
444
445

# File 'lib/ruby_parser_extras.rb', line 443

def warning s
  # do nothing for now
end

Class: RubyParser

Constant Summary collapse

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ RubyParser

Instance Attribute Details

#comments ⇒ Object (readonly)

#env ⇒ Object (readonly)

#file ⇒ Object

#in_def ⇒ Object

#in_single ⇒ Object

#lexer ⇒ Object

Instance Method Details

#_reduce_1(val, _values, result) ⇒ Object

#_reduce_10(val, _values, result) ⇒ Object

#_reduce_100(val, _values, result) ⇒ Object

#_reduce_101(val, _values, result) ⇒ Object

#_reduce_102(val, _values, result) ⇒ Object

#_reduce_103(val, _values, result) ⇒ Object

#_reduce_104(val, _values, result) ⇒ Object

#_reduce_105(val, _values, result) ⇒ Object

#_reduce_11(val, _values, result) ⇒ Object

#_reduce_12(val, _values, result) ⇒ Object

#_reduce_13(val, _values, result) ⇒ Object

#_reduce_14(val, _values, result) ⇒ Object

#_reduce_15(val, _values, result) ⇒ Object

#_reduce_16(val, _values, result) ⇒ Object

#_reduce_17(val, _values, result) ⇒ Object

#_reduce_173(val, _values, result) ⇒ Object

#_reduce_174(val, _values, result) ⇒ Object

#_reduce_175(val, _values, result) ⇒ Object

#_reduce_176(val, _values, result) ⇒ Object

#_reduce_177(val, _values, result) ⇒ Object

#_reduce_178(val, _values, result) ⇒ Object

#_reduce_179(val, _values, result) ⇒ Object

#_reduce_18(val, _values, result) ⇒ Object

#_reduce_180(val, _values, result) ⇒ Object

#_reduce_181(val, _values, result) ⇒ Object

#_reduce_182(val, _values, result) ⇒ Object

#_reduce_183(val, _values, result) ⇒ Object

#_reduce_184(val, _values, result) ⇒ Object

#_reduce_185(val, _values, result) ⇒ Object

#_reduce_186(val, _values, result) ⇒ Object

#_reduce_187(val, _values, result) ⇒ Object

#_reduce_188(val, _values, result) ⇒ Object

#_reduce_189(val, _values, result) ⇒ Object

#_reduce_19(val, _values, result) ⇒ Object

#_reduce_190(val, _values, result) ⇒ Object

#_reduce_191(val, _values, result) ⇒ Object

#_reduce_192(val, _values, result) ⇒ Object

#_reduce_193(val, _values, result) ⇒ Object

#_reduce_194(val, _values, result) ⇒ Object

#_reduce_195(val, _values, result) ⇒ Object

#_reduce_196(val, _values, result) ⇒ Object

#_reduce_197(val, _values, result) ⇒ Object

#_reduce_198(val, _values, result) ⇒ Object

#_reduce_199(val, _values, result) ⇒ Object

#_reduce_2(val, _values, result) ⇒ Object

#_reduce_20(val, _values, result) ⇒ Object

#_reduce_200(val, _values, result) ⇒ Object

#_reduce_201(val, _values, result) ⇒ Object

#_reduce_202(val, _values, result) ⇒ Object

#_reduce_203(val, _values, result) ⇒ Object

#_reduce_204(val, _values, result) ⇒ Object

#_reduce_205(val, _values, result) ⇒ Object

#_reduce_206(val, _values, result) ⇒ Object

#_reduce_207(val, _values, result) ⇒ Object

#_reduce_208(val, _values, result) ⇒ Object

#_reduce_209(val, _values, result) ⇒ Object

#_reduce_21(val, _values, result) ⇒ Object

#_reduce_210(val, _values, result) ⇒ Object

#_reduce_211(val, _values, result) ⇒ Object

#_reduce_212(val, _values, result) ⇒ Object

#_reduce_213(val, _values, result) ⇒ Object

#_reduce_214(val, _values, result) ⇒ Object

#_reduce_215(val, _values, result) ⇒ Object

#_reduce_217(val, _values, result) ⇒ Object

#_reduce_219(val, _values, result) ⇒ Object

#_reduce_22(val, _values, result) ⇒ Object