Class: Ruby22Parser

Inherits:
RubyParser::Parser show all
Defined in:
lib/ruby22_parser.rb

Direct Known Subclasses

RubyParser::V22

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",
"kDO_LAMBDA",
"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__",
"k__ENCODING__",
"tIDENTIFIER",
"tFID",
"tGVAR",
"tIVAR",
"tCONSTANT",
"tLABEL",
"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",
"tLBRACK2",
"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",
"tQWORDS_BEG",
"tSTRING_DBEG",
"tSTRING_DVAR",
"tSTRING_END",
"tSTRING",
"tSYMBOL",
"tNL",
"tEH",
"tCOLON",
"tCOMMA",
"tSPACE",
"tSEMI",
"tLAMBDA",
"tLAMBEG",
"tDSTAR",
"tCHAR",
"tSYMBOLS_BEG",
"tQSYMBOLS_BEG",
"tSTRING_DEND",
"tUBANG",
"tRATIONAL",
"tIMAGINARY",
"tLABEL_END",
"tEQL",
"tLOWEST",
"$start",
"program",
"top_compstmt",
"@1",
"top_stmts",
"opt_terms",
"none",
"top_stmt",
"terms",
"stmt",
"bodystmt",
"@2",
"compstmt",
"opt_rescue",
"opt_else",
"opt_ensure",
"stmts",
"fitem",
"undef_list",
"expr_value",
"command_asgn",
"mlhs",
"command_call",
"var_lhs",
"primary_value",
"opt_call_args",
"rbracket",
"call_op",
"backref",
"lhs",
"mrhs",
"mrhs_arg",
"expr",
"@3",
"opt_nl",
"arg",
"command",
"block_command",
"block_call",
"dot_or_colon",
"operation2",
"command_args",
"cmd_brace_block",
"opt_block_param",
"fcall",
"@4",
"@5",
"operation",
"call_args",
"mlhs_basic",
"mlhs_inner",
"rparen",
"mlhs_head",
"mlhs_item",
"mlhs_node",
"mlhs_post",
"user_variable",
"keyword_variable",
"cname",
"cpath",
"fname",
"op",
"reswords",
"fsym",
"symbol",
"dsym",
"@6",
"simple_numeric",
"primary",
"arg_value",
"aref_args",
"args",
"trailer",
"assocs",
"paren_args",
"opt_paren_args",
"opt_block_arg",
"block_arg",
"@7",
"literal",
"strings",
"xstring",
"regexp",
"words",
"qwords",
"symbols",
"qsymbols",
"var_ref",
"assoc_list",
"brace_block",
"method_call",
"lambda",
"then",
"if_tail",
"do",
"case_body",
"for_var",
"superclass",
"term",
"f_arglist",
"singleton",
"@8",
"@9",
"@10",
"@11",
"@12",
"@13",
"@14",
"@15",
"@16",
"@17",
"@18",
"@19",
"@20",
"@21",
"@22",
"@23",
"@24",
"@25",
"@26",
"@27",
"k_begin",
"k_if",
"k_unless",
"k_while",
"k_until",
"k_case",
"k_for",
"k_class",
"k_module",
"k_def",
"k_end",
"f_marg",
"f_norm_arg",
"f_margs",
"f_marg_list",
"block_args_tail",
"f_block_kwarg",
"f_kwrest",
"opt_f_block_arg",
"f_block_arg",
"opt_block_args_tail",
"block_param",
"f_arg",
"f_block_optarg",
"f_rest_arg",
"block_param_def",
"opt_bv_decl",
"bv_decls",
"bvar",
"f_bad_arg",
"f_larglist",
"lambda_body",
"@28",
"f_args",
"do_block",
"@29",
"@30",
"operation3",
"@31",
"@32",
"@33",
"@34",
"@35",
"cases",
"@36",
"exc_list",
"exc_var",
"numeric",
"string",
"string1",
"string_contents",
"xstring_contents",
"regexp_contents",
"word_list",
"word",
"string_content",
"symbol_list",
"qword_list",
"qsym_list",
"string_dvar",
"@37",
"@38",
"sym",
"@39",
"args_tail",
"f_kwarg",
"opt_args_tail",
"f_optarg",
"f_arg_asgn",
"f_arg_item",
"f_label",
"f_kw",
"f_block_kw",
"kwrest_mark",
"f_opt",
"f_block_opt",
"restarg_mark",
"blkarg_mark",
"@40",
"assoc" ]
Racc_debug_parser = 
false

Constants included from RubyParserStuff

RubyParserStuff::ENCODING_ORDER, RubyParserStuff::VERSION

Instance Attribute Summary

Attributes included from RubyParserStuff

#canonicalize_conditions, #comments, #env, #file, #in_def, #in_single, #lexer

Instance Method Summary collapse

Methods inherited from RubyParser::Parser

inherited, version

Methods included from RubyParserStuff

#arg_blk_pass, #arg_concat, #argl, #args, #array_to_hash, #aryset, #assignable, #backref_assign_error, #block_append, #block_dup_check, #block_var, #block_var18, #call_args, #clean_mlhs, #cond, #debug20, deprecate, #do_parse, #gettable, #hack_encoding, #handle_encoding, #initialize, #invert_block_call, #inverted?, #list_append, #list_prepend, #literal_concat, #logical_op, #new_aref, #new_assign, #new_attrasgn, #new_body, #new_call, #new_case, #new_class, #new_compstmt, #new_defn, #new_defs, #new_for, #new_hash, #new_if, #new_iter, #new_masgn, #new_masgn_arg, #new_match, #new_module, #new_op_asgn, #new_op_asgn2, #new_qsym_list, #new_qsym_list_entry, #new_qword_list, #new_qword_list_entry, #new_regexp, #new_resbody, #new_sclass, #new_string, #new_super, #new_symbol_list, #new_symbol_list_entry, #new_undef, #new_until, #new_until_or_while, #new_when, #new_while, #new_word_list, #new_word_list_entry, #new_xstring, #new_yield, #next_token, #on_error, #process, #remove_begin, #reset, #ret_args, #s, #syntax_error, #value_expr, #void_stmts, #warning

Instance Method Details

#_reduce_1(val, _values, result) ⇒ Object

reduce 0 omitted



3470
3471
3472
3473
3474
 
# File 'lib/ruby22_parser.rb', line 3470

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

#_reduce_10(val, _values, result) ⇒ Object 



3521
3522
3523
3524
3525
 
# File 'lib/ruby22_parser.rb', line 3521

def _reduce_10(val, _values, result)
                      result = new_iter s(:preexe), nil, val[3]
                    
    result
end

#_reduce_100(val, _values, result) ⇒ Object 



4073
4074
4075
4076
4077
 
# File 'lib/ruby22_parser.rb', line 4073

def _reduce_100(val, _values, result)
                      result = self.aryset val[0], val[2]
                    
    result
end

#_reduce_101(val, _values, result) ⇒ Object 



4079
4080
4081
4082
4083
 
# File 'lib/ruby22_parser.rb', line 4079

def _reduce_101(val, _values, result)
                      result = new_attrasgn val[0], val[2], val[1]
                    
    result
end

#_reduce_102(val, _values, result) ⇒ Object 



4085
4086
4087
4088
4089
 
# File 'lib/ruby22_parser.rb', line 4085

def _reduce_102(val, _values, result)
                      result = s(:attrasgn, val[0], :"#{val[2]}=")
                    
    result
end

#_reduce_103(val, _values, result) ⇒ Object 



4091
4092
4093
4094
4095
 
# File 'lib/ruby22_parser.rb', line 4091

def _reduce_103(val, _values, result)
                      result = new_attrasgn val[0], val[2], val[1]
                    
    result
end

#_reduce_104(val, _values, result) ⇒ Object 



4097
4098
4099
4100
4101
4102
4103
4104
4105
4106
 
# File 'lib/ruby22_parser.rb', line 4097

def _reduce_104(val, _values, result)
                      if (self.in_def || self.in_single > 0) then
                        debug20 10
                        yyerror "dynamic constant assignment"
                      end

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

#_reduce_105(val, _values, result) ⇒ Object 



4108
4109
4110
4111
4112
4113
4114
4115
4116
4117
 
# File 'lib/ruby22_parser.rb', line 4108

def _reduce_105(val, _values, result)
                      if (self.in_def || self.in_single > 0) then
                        debug20 11
                        yyerror "dynamic constant assignment"
                      end

                      result = s(:const, s(:colon3, val[1].to_sym))
                    
    result
end

#_reduce_106(val, _values, result) ⇒ Object 



4119
4120
4121
4122
4123
 
# File 'lib/ruby22_parser.rb', line 4119

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

#_reduce_107(val, _values, result) ⇒ Object 



4125
4126
4127
4128
4129
 
# File 'lib/ruby22_parser.rb', line 4125

def _reduce_107(val, _values, result)
                      yyerror "class/module name must be CONSTANT"
                    
    result
end

#_reduce_109(val, _values, result) ⇒ Object

reduce 108 omitted



4133
4134
4135
4136
4137
 
# File 'lib/ruby22_parser.rb', line 4133

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

#_reduce_11(val, _values, result) ⇒ Object 



3527
3528
3529
3530
3531
 
# File 'lib/ruby22_parser.rb', line 3527

def _reduce_11(val, _values, result)
                      result = new_body val
                    
    result
end

#_reduce_110(val, _values, result) ⇒ Object 



4139
4140
4141
4142
4143
 
# File 'lib/ruby22_parser.rb', line 4139

def _reduce_110(val, _values, result)
                      result = val[0].to_sym
                    
    result
end

#_reduce_111(val, _values, result) ⇒ Object 



4145
4146
4147
4148
4149
 
# File 'lib/ruby22_parser.rb', line 4145

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

#_reduce_115(val, _values, result) ⇒ Object

reduce 114 omitted



4157
4158
4159
4160
4161
4162
 
# File 'lib/ruby22_parser.rb', line 4157

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

#_reduce_116(val, _values, result) ⇒ Object 



4164
4165
4166
4167
4168
4169
 
# File 'lib/ruby22_parser.rb', line 4164

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

#_reduce_119(val, _values, result) ⇒ Object

reduce 118 omitted



4175
4176
4177
4178
4179
 
# File 'lib/ruby22_parser.rb', line 4175

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

#_reduce_12(val, _values, result) ⇒ Object 



3533
3534
3535
3536
3537
 
# File 'lib/ruby22_parser.rb', line 3533

def _reduce_12(val, _values, result)
                      result = new_compstmt val
                    
    result
end

#_reduce_121(val, _values, result) ⇒ Object

reduce 120 omitted



4183
4184
4185
4186
4187
 
# File 'lib/ruby22_parser.rb', line 4183

def _reduce_121(val, _values, result)
                      result = new_undef val[0]
                    
    result
end

#_reduce_122(val, _values, result) ⇒ Object 



4189
4190
4191
4192
4193
 
# File 'lib/ruby22_parser.rb', line 4189

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

#_reduce_123(val, _values, result) ⇒ Object 



4195
4196
4197
4198
4199
 
# File 'lib/ruby22_parser.rb', line 4195

def _reduce_123(val, _values, result)
                      result = new_undef val[0], val[3]
                    
    result
end

#_reduce_15(val, _values, result) ⇒ Object

reduce 14 omitted



3543
3544
3545
3546
3547
 
# File 'lib/ruby22_parser.rb', line 3543

def _reduce_15(val, _values, result)
                      result = self.block_append val[0], val[2]
                    
    result
end

#_reduce_16(val, _values, result) ⇒ Object 



3549
3550
3551
3552
3553
3554
 
# File 'lib/ruby22_parser.rb', line 3549

def _reduce_16(val, _values, result)
                      result = val[1]
                      debug20 2, val, result
                    
    result
end

#_reduce_17(val, _values, result) ⇒ Object 



3556
3557
3558
3559
3560
3561
 
# File 'lib/ruby22_parser.rb', line 3556

def _reduce_17(val, _values, result)
                      lexer.lex_state = :expr_fname
                      result = self.lexer.lineno
                    
    result
end

#_reduce_18(val, _values, result) ⇒ Object 



3563
3564
3565
3566
3567
 
# File 'lib/ruby22_parser.rb', line 3563

def _reduce_18(val, _values, result)
                      result = s(:alias, val[1], val[3]).line(val[2])
                    
    result
end

#_reduce_19(val, _values, result) ⇒ Object 



3569
3570
3571
3572
3573
 
# File 'lib/ruby22_parser.rb', line 3569

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

#_reduce_195(val, _values, result) ⇒ Object

reduce 194 omitted



4343
4344
4345
4346
4347
 
# File 'lib/ruby22_parser.rb', line 4343

def _reduce_195(val, _values, result)
                      result = new_assign val[0], val[2]
                    
    result
end

#_reduce_196(val, _values, result) ⇒ Object 



4349
4350
4351
4352
4353
 
# File 'lib/ruby22_parser.rb', line 4349

def _reduce_196(val, _values, result)
                      result = new_assign val[0], s(:rescue, val[2], new_resbody(s(:array), val[4]))
                    
    result
end

#_reduce_197(val, _values, result) ⇒ Object 



4355
4356
4357
4358
4359
 
# File 'lib/ruby22_parser.rb', line 4355

def _reduce_197(val, _values, result)
                      result = new_op_asgn val
                    
    result
end

#_reduce_198(val, _values, result) ⇒ Object 



4361
4362
4363
4364
4365
4366
 
# File 'lib/ruby22_parser.rb', line 4361

def _reduce_198(val, _values, result)
                      result = new_op_asgn val
                      result = s(:rescue, result, new_resbody(s(:array), val[4]))
                    
    result
end

#_reduce_199(val, _values, result) ⇒ Object 



4368
4369
4370
4371
4372
4373
 
# File 'lib/ruby22_parser.rb', line 4368

def _reduce_199(val, _values, result)
                      val[2].sexp_type = :arglist if val[2]
                      result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
                    
    result
end

#_reduce_2(val, _values, result) ⇒ Object 



3476
3477
3478
3479
3480
 
# File 'lib/ruby22_parser.rb', line 3476

def _reduce_2(val, _values, result)
                      result = new_compstmt val
                    
    result
end

#_reduce_20(val, _values, result) ⇒ Object 



3575
3576
3577
3578
3579
 
# File 'lib/ruby22_parser.rb', line 3575

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

#_reduce_200(val, _values, result) ⇒ Object 



4375
4376
4377
4378
4379
 
# File 'lib/ruby22_parser.rb', line 4375

def _reduce_200(val, _values, result)
                      result = new_op_asgn2 val
                    
    result
end

#_reduce_201(val, _values, result) ⇒ Object 



4381
4382
4383
4384
4385
 
# File 'lib/ruby22_parser.rb', line 4381

def _reduce_201(val, _values, result)
                      result = new_op_asgn2 val
                    
    result
end

#_reduce_202(val, _values, result) ⇒ Object 



4387
4388
4389
4390
4391
 
# File 'lib/ruby22_parser.rb', line 4387

def _reduce_202(val, _values, result)
                      result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
                    
    result
end

#_reduce_203(val, _values, result) ⇒ Object 



4393
4394
4395
4396
4397
 
# File 'lib/ruby22_parser.rb', line 4393

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

#_reduce_204(val, _values, result) ⇒ Object 



4399
4400
4401
4402
4403
 
# File 'lib/ruby22_parser.rb', line 4399

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

#_reduce_205(val, _values, result) ⇒ Object 



4405
4406
4407
4408
4409
 
# File 'lib/ruby22_parser.rb', line 4405

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

#_reduce_206(val, _values, result) ⇒ Object 



4411
4412
4413
4414
4415
4416
4417
4418
4419
4420
 
# File 'lib/ruby22_parser.rb', line 4411

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

#_reduce_207(val, _values, result) ⇒ Object 



4422
4423
4424
4425
4426
4427
4428
4429
4430
4431
 
# File 'lib/ruby22_parser.rb', line 4422

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

#_reduce_208(val, _values, result) ⇒ Object 



4433
4434
4435
4436
4437
 
# File 'lib/ruby22_parser.rb', line 4433

def _reduce_208(val, _values, result)
                      result = new_call val[0], :+, argl(val[2])
                    
    result
end

#_reduce_209(val, _values, result) ⇒ Object 



4439
4440
4441
4442
4443
 
# File 'lib/ruby22_parser.rb', line 4439

def _reduce_209(val, _values, result)
                      result = new_call val[0], :-, argl(val[2])
                    
    result
end

#_reduce_21(val, _values, result) ⇒ Object 



3581
3582
3583
3584
3585
 
# File 'lib/ruby22_parser.rb', line 3581

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

#_reduce_210(val, _values, result) ⇒ Object 



4445
4446
4447
4448
4449
 
# File 'lib/ruby22_parser.rb', line 4445

def _reduce_210(val, _values, result)
                      result = new_call val[0], :*, argl(val[2])
                    
    result
end

#_reduce_211(val, _values, result) ⇒ Object 



4451
4452
4453
4454
4455
 
# File 'lib/ruby22_parser.rb', line 4451

def _reduce_211(val, _values, result)
                      result = new_call val[0], :"/", argl(val[2])
                    
    result
end

#_reduce_212(val, _values, result) ⇒ Object 



4457
4458
4459
4460
4461
 
# File 'lib/ruby22_parser.rb', line 4457

def _reduce_212(val, _values, result)
                      result = new_call val[0], :"%", argl(val[2])
                    
    result
end

#_reduce_213(val, _values, result) ⇒ Object 



4463
4464
4465
4466
4467
 
# File 'lib/ruby22_parser.rb', line 4463

def _reduce_213(val, _values, result)
                      result = new_call val[0], :**, argl(val[2])
                    
    result
end

#_reduce_214(val, _values, result) ⇒ Object 



4469
4470
4471
4472
4473
 
# File 'lib/ruby22_parser.rb', line 4469

def _reduce_214(val, _values, result)
                      result = new_call(new_call(s(:lit, val[1]), :"**", argl(val[3])), :"-@")
                    
    result
end

#_reduce_215(val, _values, result) ⇒ Object 



4475
4476
4477
4478
4479
 
# File 'lib/ruby22_parser.rb', line 4475

def _reduce_215(val, _values, result)
                      result = new_call val[1], :"+@"
                    
    result
end

#_reduce_216(val, _values, result) ⇒ Object 



4481
4482
4483
4484
4485
 
# File 'lib/ruby22_parser.rb', line 4481

def _reduce_216(val, _values, result)
                      result = new_call val[1], :"-@"
                    
    result
end

#_reduce_217(val, _values, result) ⇒ Object 



4487
4488
4489
4490
4491
 
# File 'lib/ruby22_parser.rb', line 4487

def _reduce_217(val, _values, result)
                      result = new_call val[0], :"|", argl(val[2])
                    
    result
end

#_reduce_218(val, _values, result) ⇒ Object 



4493
4494
4495
4496
4497
 
# File 'lib/ruby22_parser.rb', line 4493

def _reduce_218(val, _values, result)
                      result = new_call val[0], :"^", argl(val[2])
                    
    result
end

#_reduce_219(val, _values, result) ⇒ Object 



4499
4500
4501
4502
4503
 
# File 'lib/ruby22_parser.rb', line 4499

def _reduce_219(val, _values, result)
                      result = new_call val[0], :"&", argl(val[2])
                    
    result
end

#_reduce_22(val, _values, result) ⇒ Object 



3587
3588
3589
3590
3591
 
# File 'lib/ruby22_parser.rb', line 3587

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

#_reduce_220(val, _values, result) ⇒ Object 



4505
4506
4507
4508
4509
 
# File 'lib/ruby22_parser.rb', line 4505

def _reduce_220(val, _values, result)
                      result = new_call val[0], :"<=>", argl(val[2])
                    
    result
end

#_reduce_221(val, _values, result) ⇒ Object 



4511
4512
4513
4514
4515
 
# File 'lib/ruby22_parser.rb', line 4511

def _reduce_221(val, _values, result)
                      result = new_call val[0], :">", argl(val[2])
                    
    result
end

#_reduce_222(val, _values, result) ⇒ Object 



4517
4518
4519
4520
4521
 
# File 'lib/ruby22_parser.rb', line 4517

def _reduce_222(val, _values, result)
                      result = new_call val[0], :">=", argl(val[2])
                    
    result
end

#_reduce_223(val, _values, result) ⇒ Object 



4523
4524
4525
4526
4527
 
# File 'lib/ruby22_parser.rb', line 4523

def _reduce_223(val, _values, result)
                      result = new_call val[0], :"<", argl(val[2])
                    
    result
end

#_reduce_224(val, _values, result) ⇒ Object 



4529
4530
4531
4532
4533
 
# File 'lib/ruby22_parser.rb', line 4529

def _reduce_224(val, _values, result)
                      result = new_call val[0], :"<=", argl(val[2])
                    
    result
end

#_reduce_225(val, _values, result) ⇒ Object 



4535
4536
4537
4538
4539
 
# File 'lib/ruby22_parser.rb', line 4535

def _reduce_225(val, _values, result)
                      result = new_call val[0], :"==", argl(val[2])
                    
    result
end

#_reduce_226(val, _values, result) ⇒ Object 



4541
4542
4543
4544
4545
 
# File 'lib/ruby22_parser.rb', line 4541

def _reduce_226(val, _values, result)
                      result = new_call val[0], :"===", argl(val[2])
                    
    result
end

#_reduce_227(val, _values, result) ⇒ Object 



4547
4548
4549
4550
4551
 
# File 'lib/ruby22_parser.rb', line 4547

def _reduce_227(val, _values, result)
                      result = new_call val[0], :"!=", argl(val[2])
                    
    result
end

#_reduce_228(val, _values, result) ⇒ Object 



4553
4554
4555
4556
4557
 
# File 'lib/ruby22_parser.rb', line 4553

def _reduce_228(val, _values, result)
                      result = new_match val[0], val[2]
                    
    result
end

#_reduce_229(val, _values, result) ⇒ Object 



4559
4560
4561
4562
4563
 
# File 'lib/ruby22_parser.rb', line 4559

def _reduce_229(val, _values, result)
                      result = s(:not, new_match(val[0], val[2]))
                    
    result
end

#_reduce_23(val, _values, result) ⇒ Object 



3593
3594
3595
3596
3597
 
# File 'lib/ruby22_parser.rb', line 3593

def _reduce_23(val, _values, result)
                      result = new_if val[2], val[0], nil
                    
    result
end

#_reduce_230(val, _values, result) ⇒ Object 



4565
4566
4567
4568
4569
 
# File 'lib/ruby22_parser.rb', line 4565

def _reduce_230(val, _values, result)
                      result = new_call val[1], :"!"
                    
    result
end

#_reduce_231(val, _values, result) ⇒ Object 



4571
4572
4573
4574
4575
 
# File 'lib/ruby22_parser.rb', line 4571

def _reduce_231(val, _values, result)
                      result = new_call value_expr(val[1]), :"~"
                    
    result
end

#_reduce_232(val, _values, result) ⇒ Object 



4577
4578
4579
4580
4581
4582
4583
 
# File 'lib/ruby22_parser.rb', line 4577

def _reduce_232(val, _values, result)
                      val[0] = value_expr val[0]
                      val[2] = value_expr val[2]
                      result = new_call val[0], :"\<\<", argl(val[2])
                    
    result
end

#_reduce_233(val, _values, result) ⇒ Object 



4585
4586
4587
4588
4589
4590
4591
 
# File 'lib/ruby22_parser.rb', line 4585

def _reduce_233(val, _values, result)
                      val[0] = value_expr val[0]
                      val[2] = value_expr val[2]
                      result = new_call val[0], :">>", argl(val[2])
                    
    result
end

#_reduce_234(val, _values, result) ⇒ Object 



4593
4594
4595
4596
4597
 
# File 'lib/ruby22_parser.rb', line 4593

def _reduce_234(val, _values, result)
                      result = logical_op :and, val[0], val[2]
                    
    result
end

#_reduce_235(val, _values, result) ⇒ Object 



4599
4600
4601
4602
4603
 
# File 'lib/ruby22_parser.rb', line 4599

def _reduce_235(val, _values, result)
                      result = logical_op :or, val[0], val[2]
                    
    result
end

#_reduce_236(val, _values, result) ⇒ Object 



4605
4606
4607
4608
4609
 
# File 'lib/ruby22_parser.rb', line 4605

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

#_reduce_237(val, _values, result) ⇒ Object 



4611
4612
4613
4614
4615
 
# File 'lib/ruby22_parser.rb', line 4611

def _reduce_237(val, _values, result)
                      result = s(:if, val[0], val[2], val[5])
                    
    result
end

#_reduce_239(val, _values, result) ⇒ Object

reduce 238 omitted



4619
4620
4621
4622
4623
 
# File 'lib/ruby22_parser.rb', line 4619

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

#_reduce_24(val, _values, result) ⇒ Object 



3599
3600
3601
3602
3603
 
# File 'lib/ruby22_parser.rb', line 3599

def _reduce_24(val, _values, result)
                      result = new_if val[2], nil, val[0]
                    
    result
end

#_reduce_241(val, _values, result) ⇒ Object

reduce 240 omitted



4627
4628
4629
4630
4631
 
# File 'lib/ruby22_parser.rb', line 4627

def _reduce_241(val, _values, result)
                      result = args [val[0]]
                    
    result
end

#_reduce_242(val, _values, result) ⇒ Object 



4633
4634
4635
4636
4637
 
# File 'lib/ruby22_parser.rb', line 4633

def _reduce_242(val, _values, result)
                      result = args [val[0], array_to_hash(val[2])]
                    
    result
end

#_reduce_243(val, _values, result) ⇒ Object 



4639
4640
4641
4642
4643
 
# File 'lib/ruby22_parser.rb', line 4639

def _reduce_243(val, _values, result)
                      result = args [array_to_hash(val[0])]
                    
    result
end

#_reduce_244(val, _values, result) ⇒ Object 



4645
4646
4647
4648
4649
 
# File 'lib/ruby22_parser.rb', line 4645

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

#_reduce_247(val, _values, result) ⇒ Object

reduce 246 omitted



4655
4656
4657
4658
4659
 
# File 'lib/ruby22_parser.rb', line 4655

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

#_reduce_248(val, _values, result) ⇒ Object 



4661
4662
4663
4664
4665
 
# File 'lib/ruby22_parser.rb', line 4661

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

#_reduce_249(val, _values, result) ⇒ Object 



4667
4668
4669
4670
4671
 
# File 'lib/ruby22_parser.rb', line 4667

def _reduce_249(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_25(val, _values, result) ⇒ Object 



3605
3606
3607
3608
3609
 
# File 'lib/ruby22_parser.rb', line 3605

def _reduce_25(val, _values, result)
                      result = new_while val[0], val[2], true
                    
    result
end

#_reduce_250(val, _values, result) ⇒ Object 



4673
4674
4675
4676
4677
 
# File 'lib/ruby22_parser.rb', line 4673

def _reduce_250(val, _values, result)
                      result = args [val[0], array_to_hash(val[2])]
                    
    result
end

#_reduce_251(val, _values, result) ⇒ Object 



4679
4680
4681
4682
4683
 
# File 'lib/ruby22_parser.rb', line 4679

def _reduce_251(val, _values, result)
                      result = args [array_to_hash(val[0])]
                    
    result
end

#_reduce_252(val, _values, result) ⇒ Object 



4685
4686
4687
4688
4689
4690
 
# File 'lib/ruby22_parser.rb', line 4685

def _reduce_252(val, _values, result)
                      warning "parenthesize argument(s) for future version"
                      result = call_args val
                    
    result
end

#_reduce_253(val, _values, result) ⇒ Object 



4692
4693
4694
4695
4696
4697
 
# File 'lib/ruby22_parser.rb', line 4692

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

#_reduce_254(val, _values, result) ⇒ Object 



4699
4700
4701
4702
4703
4704
 
# File 'lib/ruby22_parser.rb', line 4699

def _reduce_254(val, _values, result)
                      result = call_args [array_to_hash(val[0])]
                      result = self.arg_blk_pass result, val[1]
                    
    result
end

#_reduce_255(val, _values, result) ⇒ Object 



4706
4707
4708
4709
4710
4711
 
# File 'lib/ruby22_parser.rb', line 4706

def _reduce_255(val, _values, result)
                      result = call_args [val[0], array_to_hash(val[2])]
                      result = self.arg_blk_pass result, val[3]
                    
    result
end

#_reduce_256(val, _values, result) ⇒ Object 



4713
4714
4715
4716
4717
 
# File 'lib/ruby22_parser.rb', line 4713

def _reduce_256(val, _values, result)
                      result = call_args val
                    
    result
end

#_reduce_257(val, _values, result) ⇒ Object 



4719
4720
4721
4722
4723
4724
 
# File 'lib/ruby22_parser.rb', line 4719

def _reduce_257(val, _values, result)
                      result = lexer.cmdarg.stack.dup # TODO: smell?
                      lexer.cmdarg.push true
                    
    result
end

#_reduce_258(val, _values, result) ⇒ Object 



4726
4727
4728
4729
4730
4731
 
# File 'lib/ruby22_parser.rb', line 4726

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

#_reduce_259(val, _values, result) ⇒ Object 



4733
4734
4735
4736
4737
 
# File 'lib/ruby22_parser.rb', line 4733

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

#_reduce_26(val, _values, result) ⇒ Object 



3611
3612
3613
3614
3615
 
# File 'lib/ruby22_parser.rb', line 3611

def _reduce_26(val, _values, result)
                      result = new_until val[0], val[2], true
                    
    result
end

#_reduce_260(val, _values, result) ⇒ Object 



4739
4740
4741
4742
4743
 
# File 'lib/ruby22_parser.rb', line 4739

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

#_reduce_262(val, _values, result) ⇒ Object

reduce 261 omitted



4747
4748
4749
4750
4751
 
# File 'lib/ruby22_parser.rb', line 4747

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

#_reduce_263(val, _values, result) ⇒ Object 



4753
4754
4755
4756
4757
 
# File 'lib/ruby22_parser.rb', line 4753

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

#_reduce_264(val, _values, result) ⇒ Object 



4759
4760
4761
4762
4763
 
# File 'lib/ruby22_parser.rb', line 4759

def _reduce_264(val, _values, result)
                      result = self.list_append val[0], val[2]
                    
    result
end

#_reduce_265(val, _values, result) ⇒ Object 



4765
4766
4767
4768
4769
 
# File 'lib/ruby22_parser.rb', line 4765

def _reduce_265(val, _values, result)
                      result = self.list_append val[0], s(:splat, val[3])
                    
    result
end

#_reduce_266(val, _values, result) ⇒ Object 



4771
4772
4773
4774
4775
 
# File 'lib/ruby22_parser.rb', line 4771

def _reduce_266(val, _values, result)
                      result = new_masgn_arg val[0]
                    
    result
end

#_reduce_267(val, _values, result) ⇒ Object 



4777
4778
4779
4780
4781
 
# File 'lib/ruby22_parser.rb', line 4777

def _reduce_267(val, _values, result)
                      result = new_masgn_arg val[0], :wrap
                    
    result
end

#_reduce_268(val, _values, result) ⇒ Object 



4783
4784
4785
4786
4787
 
# File 'lib/ruby22_parser.rb', line 4783

def _reduce_268(val, _values, result)
                      result = val[0] << val[2]
                    
    result
end

#_reduce_269(val, _values, result) ⇒ Object 



4789
4790
4791
4792
4793
 
# File 'lib/ruby22_parser.rb', line 4789

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

#_reduce_27(val, _values, result) ⇒ Object 



3617
3618
3619
3620
3621
 
# File 'lib/ruby22_parser.rb', line 3617

def _reduce_27(val, _values, result)
                      result = s(:rescue, val[0], new_resbody(s(:array), val[2]))
                    
    result
end

#_reduce_270(val, _values, result) ⇒ Object 



4795
4796
4797
4798
4799
 
# File 'lib/ruby22_parser.rb', line 4795

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

#_reduce_28(val, _values, result) ⇒ Object 



3623
3624
3625
3626
3627
3628
3629
3630
3631
 
# File 'lib/ruby22_parser.rb', line 3623

def _reduce_28(val, _values, result)
                      if (self.in_def || self.in_single > 0) then
                        debug20 3
                        yyerror "END in method; use at_exit"
                      end
                      result = new_iter s(:postexe), 0, val[2]
                    
    result
end

#_reduce_281(val, _values, result) ⇒ Object

reduce 280 omitted



4821
4822
4823
4824
4825
 
# File 'lib/ruby22_parser.rb', line 4821

def _reduce_281(val, _values, result)
                      result = new_call nil, val[0].to_sym
                    
    result
end

#_reduce_282(val, _values, result) ⇒ Object 



4827
4828
4829
4830
4831
 
# File 'lib/ruby22_parser.rb', line 4827

def _reduce_282(val, _values, result)
                      result = self.lexer.lineno
                    
    result
end

#_reduce_283(val, _values, result) ⇒ Object 



4833
4834
4835
4836
4837
4838
4839
4840
4841
4842
4843
 
# File 'lib/ruby22_parser.rb', line 4833

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

                      result.line = val[1]
                    
    result
end

#_reduce_284(val, _values, result) ⇒ Object 



4845
4846
4847
4848
4849
 
# File 'lib/ruby22_parser.rb', line 4845

def _reduce_284(val, _values, result)
                      debug20 13, val, result
                    
    result
end

#_reduce_285(val, _values, result) ⇒ Object 



4851
4852
4853
4854
4855
4856
 
# File 'lib/ruby22_parser.rb', line 4851

def _reduce_285(val, _values, result)
                      result = self.lexer.cmdarg.stack.dup
                      lexer.cmdarg.stack.replace [false] # TODO add api for these
                    
    result
end

#_reduce_286(val, _values, result) ⇒ Object 



4858
4859
4860
4861
4862
 
# File 'lib/ruby22_parser.rb', line 4858

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

#_reduce_287(val, _values, result) ⇒ Object 



4864
4865
4866
4867
4868
4869
4870
 
# File 'lib/ruby22_parser.rb', line 4864

def _reduce_287(val, _values, result)
                      warning "(...) interpreted as grouped expression"
                      lexer.cmdarg.stack.replace val[1]
                      result = val[2]
                    
    result
end

#_reduce_288(val, _values, result) ⇒ Object 



4872
4873
4874
4875
4876
4877
 
# File 'lib/ruby22_parser.rb', line 4872

def _reduce_288(val, _values, result)
                      result = val[1] || s(:nil)
                      result.paren = true
                    
    result
end

#_reduce_289(val, _values, result) ⇒ Object 



4879
4880
4881
4882
4883
 
# File 'lib/ruby22_parser.rb', line 4879

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

#_reduce_290(val, _values, result) ⇒ Object 



4885
4886
4887
4888
4889
 
# File 'lib/ruby22_parser.rb', line 4885

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

#_reduce_291(val, _values, result) ⇒ Object 



4891
4892
4893
4894
4895
4896
 
# File 'lib/ruby22_parser.rb', line 4891

def _reduce_291(val, _values, result)
                      result = val[1] || s(:array)
                      result.sexp_type = :array # aref_args is :args
                    
    result
end

#_reduce_292(val, _values, result) ⇒ Object 



4898
4899
4900
4901
4902
 
# File 'lib/ruby22_parser.rb', line 4898

def _reduce_292(val, _values, result)
                      result = self.lexer.lineno
                    
    result
end

#_reduce_293(val, _values, result) ⇒ Object 



4904
4905
4906
4907
4908
 
# File 'lib/ruby22_parser.rb', line 4904

def _reduce_293(val, _values, result)
                      result = new_hash val
                    
    result
end

#_reduce_294(val, _values, result) ⇒ Object 



4910
4911
4912
4913
4914
 
# File 'lib/ruby22_parser.rb', line 4910

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

#_reduce_295(val, _values, result) ⇒ Object 



4916
4917
4918
4919
4920
 
# File 'lib/ruby22_parser.rb', line 4916

def _reduce_295(val, _values, result)
                      result = new_yield val[2]
                    
    result
end

#_reduce_296(val, _values, result) ⇒ Object 



4922
4923
4924
4925
4926
 
# File 'lib/ruby22_parser.rb', line 4922

def _reduce_296(val, _values, result)
                      result = new_yield
                    
    result
end

#_reduce_297(val, _values, result) ⇒ Object 



4928
4929
4930
4931
4932
 
# File 'lib/ruby22_parser.rb', line 4928

def _reduce_297(val, _values, result)
                      result = new_yield
                    
    result
end

#_reduce_298(val, _values, result) ⇒ Object 



4934
4935
4936
4937
4938
 
# File 'lib/ruby22_parser.rb', line 4934

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

#_reduce_299(val, _values, result) ⇒ Object 



4940
4941
4942
4943
4944
 
# File 'lib/ruby22_parser.rb', line 4940

def _reduce_299(val, _values, result)
                      result = s(:call, val[2], :"!")
                    
    result
end

#_reduce_3(val, _values, result) ⇒ Object 



3482
3483
3484
3485
3486
 
# File 'lib/ruby22_parser.rb', line 3482

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

#_reduce_30(val, _values, result) ⇒ Object

reduce 29 omitted



3635
3636
3637
3638
3639
 
# File 'lib/ruby22_parser.rb', line 3635

def _reduce_30(val, _values, result)
                      result = new_masgn val[0], val[2], :wrap
                    
    result
end

#_reduce_300(val, _values, result) ⇒ Object 



4946
4947
4948
4949
4950
 
# File 'lib/ruby22_parser.rb', line 4946

def _reduce_300(val, _values, result)
                      debug20 14, val, result
                    
    result
end

#_reduce_301(val, _values, result) ⇒ Object 



4952
4953
4954
4955
4956
4957
4958
4959
4960
 
# File 'lib/ruby22_parser.rb', line 4952

def _reduce_301(val, _values, result)
                      oper, iter = val[0], val[1]
                      call = oper # FIX
                      iter.insert 1, call
                      result = iter
                      call.line = iter.line
                    
    result
end

#_reduce_303(val, _values, result) ⇒ Object

reduce 302 omitted



4964
4965
4966
4967
4968
4969
4970
4971
 
# File 'lib/ruby22_parser.rb', line 4964

def _reduce_303(val, _values, result)
                      call, iter = val[0], val[1]
                      block_dup_check call, iter
                      iter.insert 1, call # FIX
                      result = iter
                    
    result
end

#_reduce_304(val, _values, result) ⇒ Object 



4973
4974
4975
4976
4977
 
# File 'lib/ruby22_parser.rb', line 4973

def _reduce_304(val, _values, result)
                      result = val[1] # TODO: fix lineno
                    
    result
end

#_reduce_305(val, _values, result) ⇒ Object 



4979
4980
4981
4982
4983
 
# File 'lib/ruby22_parser.rb', line 4979

def _reduce_305(val, _values, result)
                      result = new_if val[1], val[3], val[4]
                    
    result
end

#_reduce_306(val, _values, result) ⇒ Object 



4985
4986
4987
4988
4989
 
# File 'lib/ruby22_parser.rb', line 4985

def _reduce_306(val, _values, result)
                      result = new_if val[1], val[4], val[3]
                    
    result
end

#_reduce_307(val, _values, result) ⇒ Object 



4991
4992
4993
4994
4995
 
# File 'lib/ruby22_parser.rb', line 4991

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

#_reduce_308(val, _values, result) ⇒ Object 



4997
4998
4999
5000
5001
 
# File 'lib/ruby22_parser.rb', line 4997

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

#_reduce_309(val, _values, result) ⇒ Object 



5003
5004
5005
5006
5007
 
# File 'lib/ruby22_parser.rb', line 5003

def _reduce_309(val, _values, result)
                      result = new_while val[5], val[2], true
                    
    result
end

#_reduce_31(val, _values, result) ⇒ Object 



3641
3642
3643
3644
3645
 
# File 'lib/ruby22_parser.rb', line 3641

def _reduce_31(val, _values, result)
                      result = new_op_asgn val
                    
    result
end

#_reduce_310(val, _values, result) ⇒ Object 



5009
5010
5011
5012
5013
 
# File 'lib/ruby22_parser.rb', line 5009

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

#_reduce_311(val, _values, result) ⇒ Object 



5015
5016
5017
5018
5019
 
# File 'lib/ruby22_parser.rb', line 5015

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

#_reduce_312(val, _values, result) ⇒ Object 



5021
5022
5023
5024
5025
 
# File 'lib/ruby22_parser.rb', line 5021

def _reduce_312(val, _values, result)
                      result = new_until val[5], val[2], true
                    
    result
end

#_reduce_313(val, _values, result) ⇒ Object 



5027
5028
5029
5030
5031
5032
 
# File 'lib/ruby22_parser.rb', line 5027

def _reduce_313(val, _values, result)
                      (_, line), expr, _, body, _ = val
                      result = new_case expr, body, line
                    
    result
end

#_reduce_314(val, _values, result) ⇒ Object 



5034
5035
5036
5037
5038
5039
 
# File 'lib/ruby22_parser.rb', line 5034

def _reduce_314(val, _values, result)
                      (_, line), _, body, _ = val
                      result = new_case nil, body, line
                    
    result
end

#_reduce_315(val, _values, result) ⇒ Object 



5041
5042
5043
5044
5045
 
# File 'lib/ruby22_parser.rb', line 5041

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

#_reduce_316(val, _values, result) ⇒ Object 



5047
5048
5049
5050
5051
 
# File 'lib/ruby22_parser.rb', line 5047

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

#_reduce_317(val, _values, result) ⇒ Object 



5053
5054
5055
5056
5057
 
# File 'lib/ruby22_parser.rb', line 5053

def _reduce_317(val, _values, result)
                      result = new_for val[4], val[1], val[7]
                    
    result
end

#_reduce_318(val, _values, result) ⇒ Object 



5059
5060
5061
5062
5063
 
# File 'lib/ruby22_parser.rb', line 5059

def _reduce_318(val, _values, result)
                      result = self.lexer.lineno
                    
    result
end

#_reduce_319(val, _values, result) ⇒ Object 



5065
5066
5067
5068
5069
5070
5071
5072
5073
 
# File 'lib/ruby22_parser.rb', line 5065

def _reduce_319(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_32(val, _values, result) ⇒ Object 



3647
3648
3649
3650
3651
 
# File 'lib/ruby22_parser.rb', line 3647

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

#_reduce_320(val, _values, result) ⇒ Object 



5075
5076
5077
5078
5079
5080
5081
 
# File 'lib/ruby22_parser.rb', line 5075

def _reduce_320(val, _values, result)
                      result = new_class val
                      self.env.unextend
                      self.lexer.comments # we don't care about comments in the body
                    
    result
end

#_reduce_321(val, _values, result) ⇒ Object 



5083
5084
5085
5086
5087
 
# File 'lib/ruby22_parser.rb', line 5083

def _reduce_321(val, _values, result)
                      result = self.lexer.lineno
                    
    result
end

#_reduce_322(val, _values, result) ⇒ Object 



5089
5090
5091
5092
5093
5094
 
# File 'lib/ruby22_parser.rb', line 5089

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

#_reduce_323(val, _values, result) ⇒ Object 



5096
5097
5098
5099
5100
5101
5102
 
# File 'lib/ruby22_parser.rb', line 5096

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

#_reduce_324(val, _values, result) ⇒ Object 



5104
5105
5106
5107
5108
5109
5110
 
# File 'lib/ruby22_parser.rb', line 5104

def _reduce_324(val, _values, result)
                      result = new_sclass val
                      self.env.unextend
                      self.lexer.comments # we don't care about comments in the body
                    
    result
end

#_reduce_325(val, _values, result) ⇒ Object 



5112
5113
5114
5115
5116
 
# File 'lib/ruby22_parser.rb', line 5112

def _reduce_325(val, _values, result)
                      result = self.lexer.lineno
                    
    result
end

#_reduce_326(val, _values, result) ⇒ Object 



5118
5119
5120
5121
5122
5123
5124
5125
5126
 
# File 'lib/ruby22_parser.rb', line 5118

def _reduce_326(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_327(val, _values, result) ⇒ Object 



5128
5129
5130
5131
5132
5133
5134
 
# File 'lib/ruby22_parser.rb', line 5128

def _reduce_327(val, _values, result)
                      result = new_module val
                      self.env.unextend
                      self.lexer.comments # we don't care about comments in the body
                    
    result
end

#_reduce_328(val, _values, result) ⇒ Object 



5136
5137
5138
5139
5140
5141
5142
5143
5144
5145
5146
5147
 
# File 'lib/ruby22_parser.rb', line 5136

def _reduce_328(val, _values, result)
                      result = [self.in_def, self.lexer.cmdarg.stack.dup]

                      self.comments.push self.lexer.comments
                      self.in_def = true
                      self.env.extend
                      # TODO: local->cmdargs = cmdarg_stack;
                      # TODO: port local_push_gen and local_pop_gen
                      lexer.cmdarg.stack.replace [false]
                    
    result
end

#_reduce_329(val, _values, result) ⇒ Object 



5149
5150
5151
5152
5153
5154
5155
5156
5157
5158
5159
5160
 
# File 'lib/ruby22_parser.rb', line 5149

def _reduce_329(val, _values, result)
                      in_def, cmdarg = val[2]

                      result = new_defn val

                      lexer.cmdarg.stack.replace cmdarg
                      self.env.unextend
                      self.in_def = in_def
                      self.lexer.comments # we don't care about comments in the body
                    
    result
end

#_reduce_33(val, _values, result) ⇒ Object 



3653
3654
3655
3656
3657
3658
3659
3660
3661
 
# File 'lib/ruby22_parser.rb', line 3653

def _reduce_33(val, _values, result)
                      result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
                      if val[1] == '&.'
                        result.sexp_type = :safe_op_asgn
                      end
                      result.line = val[0].line
                    
    result
end

#_reduce_330(val, _values, result) ⇒ Object 



5162
5163
5164
5165
5166
5167
 
# File 'lib/ruby22_parser.rb', line 5162

def _reduce_330(val, _values, result)
                      self.comments.push self.lexer.comments
                      lexer.lex_state = :expr_fname
                    
    result
end

#_reduce_331(val, _values, result) ⇒ Object 



5169
5170
5171
5172
5173
5174
5175
5176
5177
 
# File 'lib/ruby22_parser.rb', line 5169

def _reduce_331(val, _values, result)
                      self.in_single += 1
                      self.env.extend
                      lexer.lex_state = :expr_endfn # force for args
                      result = [lexer.lineno, self.lexer.cmdarg.stack.dup]
                      lexer.cmdarg.stack.replace [false]
                    
    result
end

#_reduce_332(val, _values, result) ⇒ Object 



5179
5180
5181
5182
5183
5184
5185
5186
5187
5188
5189
5190
5191
 
# File 'lib/ruby22_parser.rb', line 5179

def _reduce_332(val, _values, result)
                      line, cmdarg = val[5]
                      result = new_defs val
                      result[3].line line

                      lexer.cmdarg.stack.replace cmdarg

                      self.env.unextend
                      self.in_single -= 1
                      self.lexer.comments # we don't care about comments in the body
                    
    result
end

#_reduce_333(val, _values, result) ⇒ Object 



5193
5194
5195
5196
5197
 
# File 'lib/ruby22_parser.rb', line 5193

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

#_reduce_334(val, _values, result) ⇒ Object 



5199
5200
5201
5202
5203
 
# File 'lib/ruby22_parser.rb', line 5199

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

#_reduce_335(val, _values, result) ⇒ Object 



5205
5206
5207
5208
5209
 
# File 'lib/ruby22_parser.rb', line 5205

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

#_reduce_336(val, _values, result) ⇒ Object 



5211
5212
5213
5214
5215
 
# File 'lib/ruby22_parser.rb', line 5211

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

#_reduce_337(val, _values, result) ⇒ Object 



5217
5218
5219
5220
5221
 
# File 'lib/ruby22_parser.rb', line 5217

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

#_reduce_34(val, _values, result) ⇒ Object 



3663
3664
3665
3666
3667
3668
3669
3670
3671
 
# File 'lib/ruby22_parser.rb', line 3663

def _reduce_34(val, _values, result)
                      result = s(:op_asgn, val[0], val[4], val[2].to_sym, val[3].to_sym)
                      if val[1] == '&.'
                        result.sexp_type = :safe_op_asgn
                      end
                      result.line = val[0].line
                    
    result
end

#_reduce_35(val, _values, result) ⇒ Object 



3673
3674
3675
3676
3677
3678
 
# File 'lib/ruby22_parser.rb', line 3673

def _reduce_35(val, _values, result)
                      result = s(:op_asgn, val[0], val[4], val[2], val[3])
                      debug20 4, val, result
                    
    result
end

#_reduce_355(val, _values, result) ⇒ Object

reduce 354 omitted



5257
5258
5259
5260
5261
 
# File 'lib/ruby22_parser.rb', line 5257

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

#_reduce_357(val, _values, result) ⇒ Object

reduce 356 omitted



5265
5266
5267
5268
5269
 
# File 'lib/ruby22_parser.rb', line 5265

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

#_reduce_359(val, _values, result) ⇒ Object

reduce 358 omitted



5273
5274
5275
5276
5277
 
# File 'lib/ruby22_parser.rb', line 5273

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

#_reduce_36(val, _values, result) ⇒ Object 



3680
3681
3682
3683
3684
3685
 
# File 'lib/ruby22_parser.rb', line 3680

def _reduce_36(val, _values, result)
                      result = s(:op_asgn, val[0], val[4], val[2], val[3])
                      debug20 5, val, result
                    
    result
end

#_reduce_361(val, _values, result) ⇒ Object

reduce 360 omitted



5281
5282
5283
5284
5285
 
# File 'lib/ruby22_parser.rb', line 5281

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

#_reduce_362(val, _values, result) ⇒ Object 



5287
5288
5289
5290
5291
 
# File 'lib/ruby22_parser.rb', line 5287

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

#_reduce_363(val, _values, result) ⇒ Object 



5293
5294
5295
5296
5297
 
# File 'lib/ruby22_parser.rb', line 5293

def _reduce_363(val, _values, result)
                      result = list_append val[0], val[2]
                    
    result
end

#_reduce_364(val, _values, result) ⇒ Object 



5299
5300
5301
5302
5303
5304
5305
 
# File 'lib/ruby22_parser.rb', line 5299

def _reduce_364(val, _values, result)
                      args, = val

                      result = block_var args
                    
    result
end

#_reduce_365(val, _values, result) ⇒ Object 



5307
5308
5309
5310
5311
5312
5313
 
# File 'lib/ruby22_parser.rb', line 5307

def _reduce_365(val, _values, result)
                      args, _, _, splat = val

                      result = block_var args, "*#{splat}".to_sym
                    
    result
end

#_reduce_366(val, _values, result) ⇒ Object 



5315
5316
5317
5318
5319
5320
5321
 
# File 'lib/ruby22_parser.rb', line 5315

def _reduce_366(val, _values, result)
                      args, _, _, splat, _, args2 = val

                      result = block_var args, "*#{splat}".to_sym, args2
                    
    result
end

#_reduce_367(val, _values, result) ⇒ Object 



5323
5324
5325
5326
5327
5328
5329
 
# File 'lib/ruby22_parser.rb', line 5323

def _reduce_367(val, _values, result)
                      args, _, _ = val

                      result = block_var args, :*
                    
    result
end

#_reduce_368(val, _values, result) ⇒ Object 



5331
5332
5333
5334
5335
5336
5337
 
# File 'lib/ruby22_parser.rb', line 5331

def _reduce_368(val, _values, result)
                      args, _, _, _, args2 = val

                      result = block_var args, :*, args2
                    
    result
end

#_reduce_369(val, _values, result) ⇒ Object 



5339
5340
5341
5342
5343
5344
5345
 
# File 'lib/ruby22_parser.rb', line 5339

def _reduce_369(val, _values, result)
                      _, splat = val

                      result = block_var :"*#{splat}"
                    
    result
end

#_reduce_37(val, _values, result) ⇒ Object 



3687
3688
3689
3690
3691
 
# File 'lib/ruby22_parser.rb', line 3687

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

#_reduce_370(val, _values, result) ⇒ Object 



5347
5348
5349
5350
5351
5352
5353
 
# File 'lib/ruby22_parser.rb', line 5347

def _reduce_370(val, _values, result)
                      _, splat, _, args = val

                      result = block_var :"*#{splat}", args
                    
    result
end

#_reduce_371(val, _values, result) ⇒ Object 



5355
5356
5357
5358
5359
 
# File 'lib/ruby22_parser.rb', line 5355

def _reduce_371(val, _values, result)
                      result = block_var :*
                    
    result
end

#_reduce_372(val, _values, result) ⇒ Object 



5361
5362
5363
5364
5365
5366
5367
 
# File 'lib/ruby22_parser.rb', line 5361

def _reduce_372(val, _values, result)
                      _, _, args = val

                      result = block_var :*, args
                    
    result
end

#_reduce_373(val, _values, result) ⇒ Object 



5369
5370
5371
5372
5373
 
# File 'lib/ruby22_parser.rb', line 5369

def _reduce_373(val, _values, result)
                      result = call_args val
                    
    result
end

#_reduce_374(val, _values, result) ⇒ Object 



5375
5376
5377
5378
5379
 
# File 'lib/ruby22_parser.rb', line 5375

def _reduce_374(val, _values, result)
                      result = call_args val
                    
    result
end

#_reduce_375(val, _values, result) ⇒ Object 



5381
5382
5383
5384
5385
 
# File 'lib/ruby22_parser.rb', line 5381

def _reduce_375(val, _values, result)
                      result = call_args val
                    
    result
end

#_reduce_376(val, _values, result) ⇒ Object 



5387
5388
5389
5390
5391
 
# File 'lib/ruby22_parser.rb', line 5387

def _reduce_376(val, _values, result)
                      result = call_args val
                    
    result
end

#_reduce_377(val, _values, result) ⇒ Object 



5393
5394
5395
5396
5397
 
# File 'lib/ruby22_parser.rb', line 5393

def _reduce_377(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_379(val, _values, result) ⇒ Object

reduce 378 omitted



5401
5402
5403
5404
5405
 
# File 'lib/ruby22_parser.rb', line 5401

def _reduce_379(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_38(val, _values, result) ⇒ Object 



3693
3694
3695
3696
3697
 
# File 'lib/ruby22_parser.rb', line 3693

def _reduce_38(val, _values, result)
                      result = new_assign val[0], s(:svalue, val[2])
                    
    result
end

#_reduce_380(val, _values, result) ⇒ Object 



5407
5408
5409
5410
5411
 
# File 'lib/ruby22_parser.rb', line 5407

def _reduce_380(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_381(val, _values, result) ⇒ Object 



5413
5414
5415
5416
5417
 
# File 'lib/ruby22_parser.rb', line 5413

def _reduce_381(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_382(val, _values, result) ⇒ Object 



5419
5420
5421
5422
5423
 
# File 'lib/ruby22_parser.rb', line 5419

def _reduce_382(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_383(val, _values, result) ⇒ Object 



5425
5426
5427
5428
5429
 
# File 'lib/ruby22_parser.rb', line 5425

def _reduce_383(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_384(val, _values, result) ⇒ Object 



5431
5432
5433
5434
5435
 
# File 'lib/ruby22_parser.rb', line 5431

def _reduce_384(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_385(val, _values, result) ⇒ Object 



5437
5438
5439
5440
5441
 
# File 'lib/ruby22_parser.rb', line 5437

def _reduce_385(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_386(val, _values, result) ⇒ Object 



5443
5444
5445
5446
5447
 
# File 'lib/ruby22_parser.rb', line 5443

def _reduce_386(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_387(val, _values, result) ⇒ Object 



5449
5450
5451
5452
5453
 
# File 'lib/ruby22_parser.rb', line 5449

def _reduce_387(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_388(val, _values, result) ⇒ Object 



5455
5456
5457
5458
5459
 
# File 'lib/ruby22_parser.rb', line 5455

def _reduce_388(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_389(val, _values, result) ⇒ Object 



5461
5462
5463
5464
5465
 
# File 'lib/ruby22_parser.rb', line 5461

def _reduce_389(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_39(val, _values, result) ⇒ Object 



3699
3700
3701
3702
3703
 
# File 'lib/ruby22_parser.rb', line 3699

def _reduce_39(val, _values, result)
                      result = new_masgn val[0], val[2]
                    
    result
end

#_reduce_390(val, _values, result) ⇒ Object 



5467
5468
5469
5470
5471
 
# File 'lib/ruby22_parser.rb', line 5467

def _reduce_390(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_391(val, _values, result) ⇒ Object 



5473
5474
5475
5476
5477
 
# File 'lib/ruby22_parser.rb', line 5473

def _reduce_391(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_392(val, _values, result) ⇒ Object 



5479
5480
5481
5482
5483
 
# File 'lib/ruby22_parser.rb', line 5479

def _reduce_392(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_393(val, _values, result) ⇒ Object 



5485
5486
5487
5488
5489
 
# File 'lib/ruby22_parser.rb', line 5485

def _reduce_393(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_394(val, _values, result) ⇒ Object 



5491
5492
5493
5494
 
# File 'lib/ruby22_parser.rb', line 5491

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

#_reduce_396(val, _values, result) ⇒ Object

reduce 395 omitted



5498
5499
5500
5501
5502
 
# File 'lib/ruby22_parser.rb', line 5498

def _reduce_396(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_397(val, _values, result) ⇒ Object 



5504
5505
5506
5507
5508
5509
 
# File 'lib/ruby22_parser.rb', line 5504

def _reduce_397(val, _values, result)
                      self.lexer.command_start = true
                      result = s(:args)
                    
    result
end

#_reduce_398(val, _values, result) ⇒ Object 



5511
5512
5513
5514
5515
 
# File 'lib/ruby22_parser.rb', line 5511

def _reduce_398(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_400(val, _values, result) ⇒ Object

reduce 399 omitted



5519
5520
5521
5522
5523
 
# File 'lib/ruby22_parser.rb', line 5519

def _reduce_400(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_401(val, _values, result) ⇒ Object 



5525
5526
5527
5528
5529
 
# File 'lib/ruby22_parser.rb', line 5525

def _reduce_401(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_402(val, _values, result) ⇒ Object 



5531
5532
5533
5534
5535
 
# File 'lib/ruby22_parser.rb', line 5531

def _reduce_402(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_403(val, _values, result) ⇒ Object 



5537
5538
5539
5540
5541
 
# File 'lib/ruby22_parser.rb', line 5537

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

#_reduce_405(val, _values, result) ⇒ Object

reduce 404 omitted



5545
5546
5547
5548
5549
5550
5551
5552
5553
5554
 
# File 'lib/ruby22_parser.rb', line 5545

def _reduce_405(val, _values, result)
                      self.env.extend :dynamic
                      result = self.lexer.lineno

                      result = lexer.lpar_beg
                      lexer.paren_nest += 1
                      lexer.lpar_beg = lexer.paren_nest
                    
    result
end

#_reduce_406(val, _values, result) ⇒ Object 



5556
5557
5558
5559
5560
5561
5562
5563
5564
5565
 
# File 'lib/ruby22_parser.rb', line 5556

def _reduce_406(val, _values, result)
                      lpar, args, body = val
                      lexer.lpar_beg = lpar

                      call = new_call nil, :lambda
                      result = new_iter call, args, body
                      self.env.unextend
                    
    result
end

#_reduce_407(val, _values, result) ⇒ Object 



5567
5568
5569
5570
5571
 
# File 'lib/ruby22_parser.rb', line 5567

def _reduce_407(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_408(val, _values, result) ⇒ Object 



5573
5574
5575
5576
5577
5578
 
# File 'lib/ruby22_parser.rb', line 5573

def _reduce_408(val, _values, result)
                      result = val[0]
                      result = 0 if result == s(:args)
                    
    result
end

#_reduce_409(val, _values, result) ⇒ Object 



5580
5581
5582
5583
5584
 
# File 'lib/ruby22_parser.rb', line 5580

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

#_reduce_41(val, _values, result) ⇒ Object

reduce 40 omitted



3707
3708
3709
3710
3711
 
# File 'lib/ruby22_parser.rb', line 3707

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

#_reduce_410(val, _values, result) ⇒ Object 



5586
5587
5588
5589
5590
 
# File 'lib/ruby22_parser.rb', line 5586

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

#_reduce_411(val, _values, result) ⇒ Object 



5592
5593
5594
5595
5596
5597
 
# File 'lib/ruby22_parser.rb', line 5592

def _reduce_411(val, _values, result)
                      self.env.extend :dynamic
                      result = self.lexer.lineno
                    
    result
end

#_reduce_412(val, _values, result) ⇒ Object 



5599
5600
5601
5602
5603
 
# File 'lib/ruby22_parser.rb', line 5599

def _reduce_412(val, _values, result)
                      result = nil # self.env.dynamic.keys
                    
    result
end

#_reduce_413(val, _values, result) ⇒ Object 



5605
5606
5607
5608
5609
5610
5611
5612
5613
5614
 
# File 'lib/ruby22_parser.rb', line 5605

def _reduce_413(val, _values, result)
                      args   = val[2]
                      body   = val[4]
                      result = new_iter nil, args, body
                      result.line = val[1]

                      self.env.unextend
                    
    result
end

#_reduce_414(val, _values, result) ⇒ Object 



5616
5617
5618
5619
5620
5621
5622
5623
5624
5625
5626
5627
5628
5629
5630
 
# File 'lib/ruby22_parser.rb', line 5616

def _reduce_414(val, _values, result)
                      # TODO:
                      ## if (nd_type($1) == NODE_YIELD) {
                      ##     compile_error(PARSER_ARG "block given to yield");

                      syntax_error "Both block arg and actual block given." if
                        val[0].block_pass?

                      val = invert_block_call val if inverted? val

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

#_reduce_415(val, _values, result) ⇒ Object 



5632
5633
5634
5635
5636
 
# File 'lib/ruby22_parser.rb', line 5632

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

#_reduce_416(val, _values, result) ⇒ Object 



5638
5639
5640
5641
5642
5643
5644
5645
5646
5647
 
# File 'lib/ruby22_parser.rb', line 5638

def _reduce_416(val, _values, result)
                      iter1, _, name, args, iter2 = val

                      call = new_call iter1, name.to_sym, args
                      iter2.insert 1, call

                      result = iter2
                    
    result
end

#_reduce_417(val, _values, result) ⇒ Object 



5649
5650
5651
5652
5653
5654
5655
5656
5657
5658
 
# File 'lib/ruby22_parser.rb', line 5649

def _reduce_417(val, _values, result)
                      iter1, _, name, args, iter2 = val

                      call = new_call iter1, name.to_sym, args
                      iter2.insert 1, call

                      result = iter2
                    
    result
end

#_reduce_418(val, _values, result) ⇒ Object 



5660
5661
5662
5663
5664
 
# File 'lib/ruby22_parser.rb', line 5660

def _reduce_418(val, _values, result)
                      result = self.lexer.lineno
                    
    result
end

#_reduce_419(val, _values, result) ⇒ Object 



5666
5667
5668
5669
5670
5671
 
# File 'lib/ruby22_parser.rb', line 5666

def _reduce_419(val, _values, result)
                      args = self.call_args val[2..-1]
                      result = val[0].concat args.sexp_body
                    
    result
end

#_reduce_42(val, _values, result) ⇒ Object 



3713
3714
3715
3716
3717
 
# File 'lib/ruby22_parser.rb', line 3713

def _reduce_42(val, _values, result)
                      result = new_assign val[0], val[2]
                    
    result
end

#_reduce_420(val, _values, result) ⇒ Object 



5673
5674
5675
5676
5677
 
# File 'lib/ruby22_parser.rb', line 5673

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

#_reduce_421(val, _values, result) ⇒ Object 



5679
5680
5681
5682
5683
 
# File 'lib/ruby22_parser.rb', line 5679

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

#_reduce_422(val, _values, result) ⇒ Object 



5685
5686
5687
5688
5689
 
# File 'lib/ruby22_parser.rb', line 5685

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

#_reduce_423(val, _values, result) ⇒ Object 



5691
5692
5693
5694
5695
 
# File 'lib/ruby22_parser.rb', line 5691

def _reduce_423(val, _values, result)
                      result = new_call val[0], :call, val[2], val[1]
                    
    result
end

#_reduce_424(val, _values, result) ⇒ Object 



5697
5698
5699
5700
5701
 
# File 'lib/ruby22_parser.rb', line 5697

def _reduce_424(val, _values, result)
                      result = new_call val[0], :call, val[2]
                    
    result
end

#_reduce_425(val, _values, result) ⇒ Object 



5703
5704
5705
5706
5707
 
# File 'lib/ruby22_parser.rb', line 5703

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

#_reduce_426(val, _values, result) ⇒ Object 



5709
5710
5711
5712
5713
 
# File 'lib/ruby22_parser.rb', line 5709

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

#_reduce_427(val, _values, result) ⇒ Object 



5715
5716
5717
5718
5719
 
# File 'lib/ruby22_parser.rb', line 5715

def _reduce_427(val, _values, result)
                      result = new_aref val
                    
    result
end

#_reduce_428(val, _values, result) ⇒ Object 



5721
5722
5723
5724
5725
5726
 
# File 'lib/ruby22_parser.rb', line 5721

def _reduce_428(val, _values, result)
                      self.env.extend :dynamic
                      result = self.lexer.lineno
                    
    result
end

#_reduce_429(val, _values, result) ⇒ Object 



5728
5729
5730
5731
5732
 
# File 'lib/ruby22_parser.rb', line 5728

def _reduce_429(val, _values, result)
                      result = nil # self.env.dynamic.keys
                    
    result
end

#_reduce_430(val, _values, result) ⇒ Object 



5734
5735
5736
5737
5738
5739
5740
5741
5742
5743
 
# File 'lib/ruby22_parser.rb', line 5734

def _reduce_430(val, _values, result)
                      _, line, args, _, body, _ = val

                      result = new_iter nil, args, body
                      result.line = line

                      self.env.unextend
                    
    result
end

#_reduce_431(val, _values, result) ⇒ Object 



5745
5746
5747
5748
5749
5750
 
# File 'lib/ruby22_parser.rb', line 5745

def _reduce_431(val, _values, result)
                      self.env.extend :dynamic
                      result = self.lexer.lineno
                    
    result
end

#_reduce_432(val, _values, result) ⇒ Object 



5752
5753
5754
5755
5756
 
# File 'lib/ruby22_parser.rb', line 5752

def _reduce_432(val, _values, result)
                      result = nil # self.env.dynamic.keys
                    
    result
end

#_reduce_433(val, _values, result) ⇒ Object 



5758
5759
5760
5761
5762
5763
5764
5765
5766
5767
 
# File 'lib/ruby22_parser.rb', line 5758

def _reduce_433(val, _values, result)
                      _, line, args, _, body, _ = val

                      result = new_iter nil, args, body
                      result.line = line

                      self.env.unextend
                    
    result
end

#_reduce_434(val, _values, result) ⇒ Object 



5769
5770
5771
5772
5773
 
# File 'lib/ruby22_parser.rb', line 5769

def _reduce_434(val, _values, result)
                      result = self.lexer.lineno
                    
    result
end

#_reduce_435(val, _values, result) ⇒ Object 



5775
5776
5777
5778
5779
5780
5781
 
# File 'lib/ruby22_parser.rb', line 5775

def _reduce_435(val, _values, result)
                      result = new_when(val[2], val[4])
                      result.line = val[1]
                      result << val[5] if val[5]
                    
    result
end

#_reduce_438(val, _values, result) ⇒ Object

reduce 437 omitted



5787
5788
5789
5790
5791
5792
5793
5794
5795
5796
5797
5798
 
# File 'lib/ruby22_parser.rb', line 5787

def _reduce_438(val, _values, result)
                      (_, line), klasses, var, _, body, rest = val

                      klasses ||= s(:array)
                      klasses << new_assign(var, s(:gvar, :"$!")) if var
                      klasses.line line

                      result = new_resbody(klasses, body)
                      result << rest if rest # UGH, rewritten above
                    
    result
end

#_reduce_439(val, _values, result) ⇒ Object 



5800
5801
5802
5803
5804
 
# File 'lib/ruby22_parser.rb', line 5800

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

#_reduce_44(val, _values, result) ⇒ Object

reduce 43 omitted



3721
3722
3723
3724
3725
 
# File 'lib/ruby22_parser.rb', line 3721

def _reduce_44(val, _values, result)
                      result = logical_op :and, val[0], val[2]
                    
    result
end

#_reduce_440(val, _values, result) ⇒ Object 



5806
5807
5808
5809
5810
 
# File 'lib/ruby22_parser.rb', line 5806

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

#_reduce_443(val, _values, result) ⇒ Object

reduce 442 omitted



5816
5817
5818
5819
5820
 
# File 'lib/ruby22_parser.rb', line 5816

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

#_reduce_445(val, _values, result) ⇒ Object

reduce 444 omitted



5824
5825
5826
5827
5828
5829
5830
 
# File 'lib/ruby22_parser.rb', line 5824

def _reduce_445(val, _values, result)
                      _, body = val

                      result = body || s(:nil)
                    
    result
end

#_reduce_447(val, _values, result) ⇒ Object

reduce 446 omitted



5834
5835
5836
5837
5838
 
# File 'lib/ruby22_parser.rb', line 5834

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

#_reduce_448(val, _values, result) ⇒ Object 



5840
5841
5842
5843
5844
 
# File 'lib/ruby22_parser.rb', line 5840

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

#_reduce_45(val, _values, result) ⇒ Object 



3727
3728
3729
3730
3731
 
# File 'lib/ruby22_parser.rb', line 3727

def _reduce_45(val, _values, result)
                      result = logical_op :or, val[0], val[2]
                    
    result
end

#_reduce_450(val, _values, result) ⇒ Object

reduce 449 omitted



5848
5849
5850
5851
5852
5853
 
# File 'lib/ruby22_parser.rb', line 5848

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

#_reduce_451(val, _values, result) ⇒ Object 



5855
5856
5857
5858
5859
 
# File 'lib/ruby22_parser.rb', line 5855

def _reduce_451(val, _values, result)
                      debug20 23, val, result
                    
    result
end

#_reduce_453(val, _values, result) ⇒ Object

reduce 452 omitted



5863
5864
5865
5866
5867
 
# File 'lib/ruby22_parser.rb', line 5863

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

#_reduce_454(val, _values, result) ⇒ Object 



5869
5870
5871
5872
5873
 
# File 'lib/ruby22_parser.rb', line 5869

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

#_reduce_455(val, _values, result) ⇒ Object 



5875
5876
5877
5878
5879
 
# File 'lib/ruby22_parser.rb', line 5875

def _reduce_455(val, _values, result)
                      result = new_string val
                    
    result
end

#_reduce_456(val, _values, result) ⇒ Object 



5881
5882
5883
5884
5885
 
# File 'lib/ruby22_parser.rb', line 5881

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

#_reduce_457(val, _values, result) ⇒ Object 



5887
5888
5889
5890
5891
 
# File 'lib/ruby22_parser.rb', line 5887

def _reduce_457(val, _values, result)
                      result = new_regexp val
                    
    result
end

#_reduce_458(val, _values, result) ⇒ Object 



5893
5894
5895
5896
5897
 
# File 'lib/ruby22_parser.rb', line 5893

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

#_reduce_459(val, _values, result) ⇒ Object 



5899
5900
5901
5902
5903
 
# File 'lib/ruby22_parser.rb', line 5899

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

#_reduce_46(val, _values, result) ⇒ Object 



3733
3734
3735
3736
3737
 
# File 'lib/ruby22_parser.rb', line 3733

def _reduce_46(val, _values, result)
                      result = s(:call, val[2], :"!")
                    
    result
end

#_reduce_460(val, _values, result) ⇒ Object 



5905
5906
5907
5908
5909
 
# File 'lib/ruby22_parser.rb', line 5905

def _reduce_460(val, _values, result)
                      result = new_word_list
                    
    result
end

#_reduce_461(val, _values, result) ⇒ Object 



5911
5912
5913
5914
5915
 
# File 'lib/ruby22_parser.rb', line 5911

def _reduce_461(val, _values, result)
                      result = val[0].dup << new_word_list_entry(val)
                    
    result
end

#_reduce_463(val, _values, result) ⇒ Object

reduce 462 omitted



5919
5920
5921
5922
5923
 
# File 'lib/ruby22_parser.rb', line 5919

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

#_reduce_464(val, _values, result) ⇒ Object 



5925
5926
5927
5928
5929
 
# File 'lib/ruby22_parser.rb', line 5925

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

#_reduce_465(val, _values, result) ⇒ Object 



5931
5932
5933
5934
5935
 
# File 'lib/ruby22_parser.rb', line 5931

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

#_reduce_466(val, _values, result) ⇒ Object 



5937
5938
5939
5940
5941
 
# File 'lib/ruby22_parser.rb', line 5937

def _reduce_466(val, _values, result)
                      result = new_symbol_list
                    
    result
end

#_reduce_467(val, _values, result) ⇒ Object 



5943
5944
5945
5946
5947
 
# File 'lib/ruby22_parser.rb', line 5943

def _reduce_467(val, _values, result)
                      result = val[0].dup << new_symbol_list_entry(val)
                    
    result
end

#_reduce_468(val, _values, result) ⇒ Object 



5949
5950
5951
5952
5953
 
# File 'lib/ruby22_parser.rb', line 5949

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

#_reduce_469(val, _values, result) ⇒ Object 



5955
5956
5957
5958
5959
 
# File 'lib/ruby22_parser.rb', line 5955

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

#_reduce_47(val, _values, result) ⇒ Object 



3739
3740
3741
3742
3743
 
# File 'lib/ruby22_parser.rb', line 3739

def _reduce_47(val, _values, result)
                      result = s(:call, val[1], :"!")
                    
    result
end

#_reduce_470(val, _values, result) ⇒ Object 



5961
5962
5963
5964
5965
 
# File 'lib/ruby22_parser.rb', line 5961

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

#_reduce_471(val, _values, result) ⇒ Object 



5967
5968
5969
5970
5971
 
# File 'lib/ruby22_parser.rb', line 5967

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

#_reduce_472(val, _values, result) ⇒ Object 



5973
5974
5975
5976
5977
 
# File 'lib/ruby22_parser.rb', line 5973

def _reduce_472(val, _values, result)
                      result = new_qword_list
                    
    result
end

#_reduce_473(val, _values, result) ⇒ Object 



5979
5980
5981
5982
5983
 
# File 'lib/ruby22_parser.rb', line 5979

def _reduce_473(val, _values, result)
                      result = val[0].dup << new_qword_list_entry(val)
                    
    result
end

#_reduce_474(val, _values, result) ⇒ Object 



5985
5986
5987
5988
5989
 
# File 'lib/ruby22_parser.rb', line 5985

def _reduce_474(val, _values, result)
                      result = new_qsym_list
                    
    result
end

#_reduce_475(val, _values, result) ⇒ Object 



5991
5992
5993
5994
5995
 
# File 'lib/ruby22_parser.rb', line 5991

def _reduce_475(val, _values, result)
                      result = val[0].dup << new_qsym_list_entry(val)
                    
    result
end

#_reduce_476(val, _values, result) ⇒ Object 



5997
5998
5999
6000
6001
 
# File 'lib/ruby22_parser.rb', line 5997

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

#_reduce_477(val, _values, result) ⇒ Object 



6003
6004
6005
6006
6007
 
# File 'lib/ruby22_parser.rb', line 6003

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

#_reduce_478(val, _values, result) ⇒ Object 



6009
6010
6011
6012
6013
 
# File 'lib/ruby22_parser.rb', line 6009

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

#_reduce_479(val, _values, result) ⇒ Object 



6015
6016
6017
6018
6019
 
# File 'lib/ruby22_parser.rb', line 6015

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

#_reduce_480(val, _values, result) ⇒ Object 



6021
6022
6023
6024
6025
 
# File 'lib/ruby22_parser.rb', line 6021

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

#_reduce_481(val, _values, result) ⇒ Object 



6027
6028
6029
6030
6031
 
# File 'lib/ruby22_parser.rb', line 6027

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

#_reduce_482(val, _values, result) ⇒ Object 



6033
6034
6035
6036
6037
 
# File 'lib/ruby22_parser.rb', line 6033

def _reduce_482(val, _values, result)
                      result = new_string val
                    
    result
end

#_reduce_483(val, _values, result) ⇒ Object 



6039
6040
6041
6042
6043
6044
6045
6046
 
# File 'lib/ruby22_parser.rb', line 6039

def _reduce_483(val, _values, result)
                      result = lexer.lex_strterm

                      lexer.lex_strterm = nil
                      lexer.lex_state = :expr_beg # TODO: expr_value ?
                    
    result
end

#_reduce_484(val, _values, result) ⇒ Object 



6048
6049
6050
6051
6052
6053
 
# File 'lib/ruby22_parser.rb', line 6048

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

#_reduce_485(val, _values, result) ⇒ Object 



6055
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066
6067
6068
6069
6070
6071
 
# File 'lib/ruby22_parser.rb', line 6055

def _reduce_485(val, _values, result)
                      result = [lexer.lex_strterm,
                                lexer.brace_nest,
                                lexer.string_nest, # TODO: remove
                                lexer.cond.store,
                                lexer.cmdarg.store,
                                lexer.lex_state,
                               ]

                      lexer.lex_strterm = nil
                      lexer.brace_nest  = 0
                      lexer.string_nest = 0

                      lexer.lex_state   = :expr_value
                    
    result
end

#_reduce_486(val, _values, result) ⇒ Object 



6073
6074
6075
6076
6077
6078
6079
6080
6081
6082
6083
6084
6085
6086
6087
6088
6089
6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
 
# File 'lib/ruby22_parser.rb', line 6073

def _reduce_486(val, _values, result)
                      # TODO: tRCURLY -> tSTRING_END
                      _, memo, stmt, _ = val

                      lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg, oldlex_state = memo

                      lexer.lex_strterm = lex_strterm
                      lexer.brace_nest  = brace_nest
                      lexer.string_nest = string_nest

                      lexer.cond.restore oldcond
                      lexer.cmdarg.restore oldcmdarg

                      lexer.lex_state = oldlex_state

                      case stmt
                      when Sexp then
                        case stmt.sexp_type
                        when :str, :dstr, :evstr then
                          result = stmt
                        else
                          result = s(:evstr, stmt)
                        end
                      when nil then
                        result = s(:evstr)
                      else
                        debug20 25
                        raise "unknown string body: #{stmt.inspect}"
                      end
                    
    result
end

#_reduce_487(val, _values, result) ⇒ Object 



6106
6107
6108
6109
 
# File 'lib/ruby22_parser.rb', line 6106

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

#_reduce_488(val, _values, result) ⇒ Object 



6111
6112
6113
6114
 
# File 'lib/ruby22_parser.rb', line 6111

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

#_reduce_489(val, _values, result) ⇒ Object 



6116
6117
6118
6119
 
# File 'lib/ruby22_parser.rb', line 6116

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

#_reduce_49(val, _values, result) ⇒ Object

reduce 48 omitted



3747
3748
3749
3750
3751
 
# File 'lib/ruby22_parser.rb', line 3747

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

#_reduce_491(val, _values, result) ⇒ Object

reduce 490 omitted



6123
6124
6125
6126
6127
6128
 
# File 'lib/ruby22_parser.rb', line 6123

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

#_reduce_492(val, _values, result) ⇒ Object 



6130
6131
6132
6133
6134
 
# File 'lib/ruby22_parser.rb', line 6130

def _reduce_492(val, _values, result)
                      result = val[0].to_sym
                    
    result
end

#_reduce_497(val, _values, result) ⇒ Object

reduce 496 omitted



6144
6145
6146
6147
6148
6149
6150
6151
6152
6153
6154
6155
6156
6157
6158
6159
6160
6161
6162
 
# File 'lib/ruby22_parser.rb', line 6144

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

                      result ||= s(:str, "")

                      case result.sexp_type
                      when :dstr then
                        result.sexp_type = :dsym
                      when :str then
                        result = s(:lit, result.last.to_sym)
                      when :evstr then
                        result = s(:dsym, "", result)
                      else
                        debug20 26, val, result
                      end
                    
    result
end

#_reduce_499(val, _values, result) ⇒ Object

reduce 498 omitted



6166
6167
6168
6169
6170
 
# File 'lib/ruby22_parser.rb', line 6166

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

#_reduce_509(val, _values, result) ⇒ Object

reduce 508 omitted



6190
6191
6192
6193
 
# File 'lib/ruby22_parser.rb', line 6190

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

#_reduce_510(val, _values, result) ⇒ Object 



6195
6196
6197
6198
 
# File 'lib/ruby22_parser.rb', line 6195

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

#_reduce_511(val, _values, result) ⇒ Object 



6200
6201
6202
6203
 
# File 'lib/ruby22_parser.rb', line 6200

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

#_reduce_512(val, _values, result) ⇒ Object 



6205
6206
6207
6208
 
# File 'lib/ruby22_parser.rb', line 6205

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

#_reduce_513(val, _values, result) ⇒ Object 



6210
6211
6212
6213
 
# File 'lib/ruby22_parser.rb', line 6210

def _reduce_513(val, _values, result)
 result = s(:str, self.file) 
    result
end

#_reduce_514(val, _values, result) ⇒ Object 



6215
6216
6217
6218
 
# File 'lib/ruby22_parser.rb', line 6215

def _reduce_514(val, _values, result)
 result = s(:lit, lexer.lineno) 
    result
end

#_reduce_515(val, _values, result) ⇒ Object 



6220
6221
6222
6223
6224
6225
6226
6227
6228
6229
 
# File 'lib/ruby22_parser.rb', line 6220

def _reduce_515(val, _values, result)
                      result =
                        if defined? Encoding then
                          s(:colon2, s(:const, :Encoding), :UTF_8)
                        else
                          s(:str, "Unsupported!")
                        end
                    
    result
end

#_reduce_516(val, _values, result) ⇒ Object 



6231
6232
6233
6234
6235
6236
 
# File 'lib/ruby22_parser.rb', line 6231

def _reduce_516(val, _values, result)
                      var = val[0]
                      result = Sexp === var ? var : self.gettable(var)
                    
    result
end

#_reduce_517(val, _values, result) ⇒ Object 



6238
6239
6240
6241
6242
6243
 
# File 'lib/ruby22_parser.rb', line 6238

def _reduce_517(val, _values, result)
                      var = val[0]
                      result = Sexp === var ? var : self.gettable(var)
                    
    result
end

#_reduce_518(val, _values, result) ⇒ Object 



6245
6246
6247
6248
6249
 
# File 'lib/ruby22_parser.rb', line 6245

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

#_reduce_519(val, _values, result) ⇒ Object 



6251
6252
6253
6254
6255
6256
 
# File 'lib/ruby22_parser.rb', line 6251

def _reduce_519(val, _values, result)
                      result = self.assignable val[0]
                      debug20 29, val, result
                    
    result
end

#_reduce_520(val, _values, result) ⇒ Object 



6258
6259
6260
6261
 
# File 'lib/ruby22_parser.rb', line 6258

def _reduce_520(val, _values, result)
 result = s(:nth_ref,  val[0]) 
    result
end

#_reduce_521(val, _values, result) ⇒ Object 



6263
6264
6265
6266
 
# File 'lib/ruby22_parser.rb', line 6263

def _reduce_521(val, _values, result)
 result = s(:back_ref, val[0]) 
    result
end

#_reduce_522(val, _values, result) ⇒ Object 



6268
6269
6270
6271
6272
 
# File 'lib/ruby22_parser.rb', line 6268

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

#_reduce_523(val, _values, result) ⇒ Object 



6274
6275
6276
6277
6278
 
# File 'lib/ruby22_parser.rb', line 6274

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

#_reduce_524(val, _values, result) ⇒ Object 



6280
6281
6282
6283
6284
 
# File 'lib/ruby22_parser.rb', line 6280

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

#_reduce_525(val, _values, result) ⇒ Object 



6286
6287
6288
6289
6290
6291
6292
 
# File 'lib/ruby22_parser.rb', line 6286

def _reduce_525(val, _values, result)
                      yyerrok
                      result = nil
                      debug20 30, val, result
                    
    result
end

#_reduce_526(val, _values, result) ⇒ Object 



6294
6295
6296
6297
6298
6299
6300
6301
6302
6303
 
# File 'lib/ruby22_parser.rb', line 6294

def _reduce_526(val, _values, result)
                      result = val[1]
                      self.lexer.lex_state = :expr_beg
                      self.lexer.command_start = true
                      # TODO:
                      # $<num>$ = parser->parser_in_kwarg;
                      # parser->parser_in_kwarg = 1;
                    
    result
end

#_reduce_527(val, _values, result) ⇒ Object 



6305
6306
6307
6308
6309
6310
6311
6312
 
# File 'lib/ruby22_parser.rb', line 6305

def _reduce_527(val, _values, result)
                      # TODO: parser->parser_in_kwarg = $<num>1;
                      result = val[0]
                      self.lexer.lex_state = :expr_beg
                      self.lexer.command_start = true
                    
    result
end

#_reduce_528(val, _values, result) ⇒ Object 



6314
6315
6316
6317
6318
 
# File 'lib/ruby22_parser.rb', line 6314

def _reduce_528(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_529(val, _values, result) ⇒ Object 



6320
6321
6322
6323
6324
 
# File 'lib/ruby22_parser.rb', line 6320

def _reduce_529(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_53(val, _values, result) ⇒ Object

reduce 52 omitted



3759
3760
3761
3762
3763
 
# File 'lib/ruby22_parser.rb', line 3759

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

#_reduce_530(val, _values, result) ⇒ Object 



6326
6327
6328
6329
6330
 
# File 'lib/ruby22_parser.rb', line 6326

def _reduce_530(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_532(val, _values, result) ⇒ Object

reduce 531 omitted



6334
6335
6336
6337
6338
 
# File 'lib/ruby22_parser.rb', line 6334

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

#_reduce_533(val, _values, result) ⇒ Object 



6340
6341
6342
6343
6344
 
# File 'lib/ruby22_parser.rb', line 6340

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

#_reduce_534(val, _values, result) ⇒ Object 



6346
6347
6348
6349
6350
 
# File 'lib/ruby22_parser.rb', line 6346

def _reduce_534(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_535(val, _values, result) ⇒ Object 



6352
6353
6354
6355
6356
 
# File 'lib/ruby22_parser.rb', line 6352

def _reduce_535(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_536(val, _values, result) ⇒ Object 



6358
6359
6360
6361
6362
 
# File 'lib/ruby22_parser.rb', line 6358

def _reduce_536(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_537(val, _values, result) ⇒ Object 



6364
6365
6366
6367
6368
 
# File 'lib/ruby22_parser.rb', line 6364

def _reduce_537(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_538(val, _values, result) ⇒ Object 



6370
6371
6372
6373
6374
 
# File 'lib/ruby22_parser.rb', line 6370

def _reduce_538(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_539(val, _values, result) ⇒ Object 



6376
6377
6378
6379
6380
 
# File 'lib/ruby22_parser.rb', line 6376

def _reduce_539(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_54(val, _values, result) ⇒ Object 



3765
3766
3767
3768
3769
3770
 
# File 'lib/ruby22_parser.rb', line 3765

def _reduce_54(val, _values, result)
                      self.env.extend(:dynamic)
                      result = self.lexer.lineno
                    
    result
end

#_reduce_540(val, _values, result) ⇒ Object 



6382
6383
6384
6385
6386
 
# File 'lib/ruby22_parser.rb', line 6382

def _reduce_540(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_541(val, _values, result) ⇒ Object 



6388
6389
6390
6391
6392
 
# File 'lib/ruby22_parser.rb', line 6388

def _reduce_541(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_542(val, _values, result) ⇒ Object 



6394
6395
6396
6397
6398
 
# File 'lib/ruby22_parser.rb', line 6394

def _reduce_542(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_543(val, _values, result) ⇒ Object 



6400
6401
6402
6403
6404
 
# File 'lib/ruby22_parser.rb', line 6400

def _reduce_543(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_544(val, _values, result) ⇒ Object 



6406
6407
6408
6409
6410
 
# File 'lib/ruby22_parser.rb', line 6406

def _reduce_544(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_545(val, _values, result) ⇒ Object 



6412
6413
6414
6415
6416
 
# File 'lib/ruby22_parser.rb', line 6412

def _reduce_545(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_546(val, _values, result) ⇒ Object 



6418
6419
6420
6421
6422
 
# File 'lib/ruby22_parser.rb', line 6418

def _reduce_546(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_547(val, _values, result) ⇒ Object 



6424
6425
6426
6427
6428
 
# File 'lib/ruby22_parser.rb', line 6424

def _reduce_547(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_548(val, _values, result) ⇒ Object 



6430
6431
6432
6433
6434
 
# File 'lib/ruby22_parser.rb', line 6430

def _reduce_548(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_549(val, _values, result) ⇒ Object 



6436
6437
6438
6439
6440
 
# File 'lib/ruby22_parser.rb', line 6436

def _reduce_549(val, _values, result)
                      yyerror "formal argument cannot be a constant"
                    
    result
end

#_reduce_55(val, _values, result) ⇒ Object 



3772
3773
3774
3775
3776
 
# File 'lib/ruby22_parser.rb', line 3772

def _reduce_55(val, _values, result)
                      result = nil # self.env.dynamic.keys
                    
    result
end

#_reduce_550(val, _values, result) ⇒ Object 



6442
6443
6444
6445
6446
 
# File 'lib/ruby22_parser.rb', line 6442

def _reduce_550(val, _values, result)
                      yyerror "formal argument cannot be an instance variable"
                    
    result
end

#_reduce_551(val, _values, result) ⇒ Object 



6448
6449
6450
6451
6452
 
# File 'lib/ruby22_parser.rb', line 6448

def _reduce_551(val, _values, result)
                      yyerror "formal argument cannot be a global variable"
                    
    result
end

#_reduce_552(val, _values, result) ⇒ Object 



6454
6455
6456
6457
6458
 
# File 'lib/ruby22_parser.rb', line 6454

def _reduce_552(val, _values, result)
                      yyerror "formal argument cannot be a class variable"
                    
    result
end

#_reduce_554(val, _values, result) ⇒ Object

reduce 553 omitted



6462
6463
6464
6465
6466
6467
6468
6469
 
# File 'lib/ruby22_parser.rb', line 6462

def _reduce_554(val, _values, result)
                      identifier = val[0].to_sym
                      self.env[identifier] = :lvar

                      result = identifier
                    
    result
end

#_reduce_557(val, _values, result) ⇒ Object

reduce 556 omitted



6475
6476
6477
6478
6479
 
# File 'lib/ruby22_parser.rb', line 6475

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

#_reduce_558(val, _values, result) ⇒ Object 



6481
6482
6483
6484
6485
6486
6487
6488
6489
6490
6491
6492
6493
6494
 
# File 'lib/ruby22_parser.rb', line 6481

def _reduce_558(val, _values, result)
                      case val[0]
                      when Symbol then
                        result = s(:args)
                        result << val[0]
                      when Sexp then
                        result = val[0]
                      else
                        debug20 32
                        raise "Unknown f_arg type: #{val.inspect}"
                      end
                    
    result
end

#_reduce_559(val, _values, result) ⇒ Object 



6496
6497
6498
6499
6500
6501
6502
6503
6504
6505
6506
6507
6508
 
# File 'lib/ruby22_parser.rb', line 6496

def _reduce_559(val, _values, result)
                      list, _, item = val

                      if list.sexp_type == :args then
                        result = list
                      else
                        result = s(:args, list)
                      end

                      result << item
                    
    result
end

#_reduce_56(val, _values, result) ⇒ Object 



3778
3779
3780
3781
3782
3783
3784
3785
 
# File 'lib/ruby22_parser.rb', line 3778

def _reduce_56(val, _values, result)
                      result = new_iter nil, val[2], val[4]
                      result.line = val[1]

                      self.env.unextend
                    
    result
end

#_reduce_561(val, _values, result) ⇒ Object

reduce 560 omitted



6512
6513
6514
6515
6516
6517
6518
6519
6520
6521
 
# File 'lib/ruby22_parser.rb', line 6512

def _reduce_561(val, _values, result)
                      # TODO: call_args
                      label, _ = val[0] # TODO: fix lineno?
                      identifier = label.to_sym
                      self.env[identifier] = :lvar

                      result = s(:array, s(:kwarg, identifier, val[1]))
                    
    result
end

#_reduce_562(val, _values, result) ⇒ Object 



6523
6524
6525
6526
6527
6528
6529
6530
6531
 
# File 'lib/ruby22_parser.rb', line 6523

def _reduce_562(val, _values, result)
                      label, _ = val[0] # TODO: fix lineno?
                      identifier = label.to_sym
                      self.env[identifier] = :lvar

                      result = s(:array, s(:kwarg, identifier))
                    
    result
end

#_reduce_563(val, _values, result) ⇒ Object 



6533
6534
6535
6536
6537
6538
6539
6540
6541
6542
 
# File 'lib/ruby22_parser.rb', line 6533

def _reduce_563(val, _values, result)
                      # TODO: call_args
                      label, _ = val[0] # TODO: fix lineno?
                      identifier = label.to_sym
                      self.env[identifier] = :lvar

                      result = s(:array, s(:kwarg, identifier, val[1]))
                    
    result
end

#_reduce_564(val, _values, result) ⇒ Object 



6544
6545
6546
6547
6548
6549
6550
6551
6552
 
# File 'lib/ruby22_parser.rb', line 6544

def _reduce_564(val, _values, result)
                      label, _ = val[0] # TODO: fix lineno?
                      identifier = label.to_sym
                      self.env[identifier] = :lvar

                      result = s(:array, s(:kwarg, identifier))
                    
    result
end

#_reduce_566(val, _values, result) ⇒ Object

reduce 565 omitted



6556
6557
6558
6559
6560
6561
 
# File 'lib/ruby22_parser.rb', line 6556

def _reduce_566(val, _values, result)
                      list, _, item = val
                      result = list << item.last
                    
    result
end

#_reduce_568(val, _values, result) ⇒ Object

reduce 567 omitted



6565
6566
6567
6568
6569
 
# File 'lib/ruby22_parser.rb', line 6565

def _reduce_568(val, _values, result)
                      result = args val
                    
    result
end

#_reduce_57(val, _values, result) ⇒ Object 



3787
3788
3789
3790
3791
 
# File 'lib/ruby22_parser.rb', line 3787

def _reduce_57(val, _values, result)
                      result = new_call nil, val[0].to_sym
                    
    result
end

#_reduce_571(val, _values, result) ⇒ Object

reduce 570 omitted



6575
6576
6577
6578
6579
 
# File 'lib/ruby22_parser.rb', line 6575

def _reduce_571(val, _values, result)
                      result = :"**#{val[1]}"
                    
    result
end

#_reduce_572(val, _values, result) ⇒ Object 



6581
6582
6583
6584
6585
 
# File 'lib/ruby22_parser.rb', line 6581

def _reduce_572(val, _values, result)
                      result = :"**"
                    
    result
end

#_reduce_573(val, _values, result) ⇒ Object 



6587
6588
6589
6590
6591
6592
 
# File 'lib/ruby22_parser.rb', line 6587

def _reduce_573(val, _values, result)
                      result = self.assignable val[0], val[2]
                      # TODO: detect duplicate names
                    
    result
end

#_reduce_574(val, _values, result) ⇒ Object 



6594
6595
6596
6597
6598
 
# File 'lib/ruby22_parser.rb', line 6594

def _reduce_574(val, _values, result)
                      result = self.assignable val[0], val[2]
                    
    result
end

#_reduce_575(val, _values, result) ⇒ Object 



6600
6601
6602
6603
6604
 
# File 'lib/ruby22_parser.rb', line 6600

def _reduce_575(val, _values, result)
                      result = s(:block, val[0])
                    
    result
end

#_reduce_576(val, _values, result) ⇒ Object 



6606
6607
6608
6609
6610
6611
 
# File 'lib/ruby22_parser.rb', line 6606

def _reduce_576(val, _values, result)
                      result = val[0]
                      result << val[2]
                    
    result
end

#_reduce_577(val, _values, result) ⇒ Object 



6613
6614
6615
6616
6617
 
# File 'lib/ruby22_parser.rb', line 6613

def _reduce_577(val, _values, result)
                      result = s(:block, val[0])
                    
    result
end

#_reduce_578(val, _values, result) ⇒ Object 



6619
6620
6621
6622
6623
 
# File 'lib/ruby22_parser.rb', line 6619

def _reduce_578(val, _values, result)
                      result = self.block_append val[0], val[2]
                    
    result
end

#_reduce_58(val, _values, result) ⇒ Object 



3793
3794
3795
3796
3797
 
# File 'lib/ruby22_parser.rb', line 3793

def _reduce_58(val, _values, result)
                      result = val[0].concat val[1].sexp_body # REFACTOR pattern
                    
    result
end

#_reduce_581(val, _values, result) ⇒ Object

reduce 580 omitted



6629
6630
6631
6632
6633
6634
6635
6636
 
# File 'lib/ruby22_parser.rb', line 6629

def _reduce_581(val, _values, result)
                      # TODO: differs from parse.y - needs tests
                      name = val[1].to_sym
                      self.assignable name
                      result = :"*#{name}"
                    
    result
end

#_reduce_582(val, _values, result) ⇒ Object 



6638
6639
6640
6641
6642
6643
6644
 
# File 'lib/ruby22_parser.rb', line 6638

def _reduce_582(val, _values, result)
                      name = :"*"
                      self.env[name] = :lvar
                      result = name
                    
    result
end

#_reduce_585(val, _values, result) ⇒ Object

reduce 584 omitted



6650
6651
6652
6653
6654
6655
6656
6657
 
# File 'lib/ruby22_parser.rb', line 6650

def _reduce_585(val, _values, result)
                      identifier = val[1].to_sym

                      self.env[identifier] = :lvar
                      result = "&#{identifier}".to_sym
                    
    result
end

#_reduce_586(val, _values, result) ⇒ Object 



6659
6660
6661
6662
6663
 
# File 'lib/ruby22_parser.rb', line 6659

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

#_reduce_587(val, _values, result) ⇒ Object 



6665
6666
6667
6668
6669
 
# File 'lib/ruby22_parser.rb', line 6665

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

#_reduce_589(val, _values, result) ⇒ Object

reduce 588 omitted



6673
6674
6675
6676
6677
 
# File 'lib/ruby22_parser.rb', line 6673

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

#_reduce_59(val, _values, result) ⇒ Object 



3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
 
# File 'lib/ruby22_parser.rb', line 3799

def _reduce_59(val, _values, result)
                      result = val[0].concat val[1].sexp_body
                      if val[2] then
                        block_dup_check result, val[2]

                        result, operation = val[2], result
                        result.insert 1, operation
                      end
                    
    result
end

#_reduce_590(val, _values, result) ⇒ Object 



6679
6680
6681
6682
6683
6684
6685
 
# File 'lib/ruby22_parser.rb', line 6679

def _reduce_590(val, _values, result)
                      result = val[2]
                      yyerror "Can't define single method for literals." if
                        result.sexp_type == :lit
                    
    result
end

#_reduce_591(val, _values, result) ⇒ Object 



6687
6688
6689
6690
6691
 
# File 'lib/ruby22_parser.rb', line 6687

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

#_reduce_592(val, _values, result) ⇒ Object 



6693
6694
6695
6696
6697
 
# File 'lib/ruby22_parser.rb', line 6693

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

#_reduce_594(val, _values, result) ⇒ Object

reduce 593 omitted



6701
6702
6703
6704
6705
6706
6707
6708
6709
 
# File 'lib/ruby22_parser.rb', line 6701

def _reduce_594(val, _values, result)
                      list = val[0].dup
                      more = val[2].sexp_body
                      list.push(*more) unless more.empty?
                      result = list
                      result.sexp_type = :hash
                    
    result
end

#_reduce_595(val, _values, result) ⇒ Object 



6711
6712
6713
6714
6715
 
# File 'lib/ruby22_parser.rb', line 6711

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

#_reduce_596(val, _values, result) ⇒ Object 



6717
6718
6719
6720
6721
 
# File 'lib/ruby22_parser.rb', line 6717

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

#_reduce_597(val, _values, result) ⇒ Object 



6723
6724
6725
6726
6727
6728
6729
 
# File 'lib/ruby22_parser.rb', line 6723

def _reduce_597(val, _values, result)
                      _, sym, _, value = val
                      sym.sexp_type = :dsym
                      result = s(:array, sym, value)
                    
    result
end

#_reduce_598(val, _values, result) ⇒ Object 



6731
6732
6733
6734
6735
6736
 
# File 'lib/ruby22_parser.rb', line 6731

def _reduce_598(val, _values, result)
                      raise "not yet: #{val.inspect}"
                      # result = s(:array, s(:lit, val[1].to_sym), val[1])
                    
    result
end

#_reduce_599(val, _values, result) ⇒ Object 



6738
6739
6740
6741
6742
 
# File 'lib/ruby22_parser.rb', line 6738

def _reduce_599(val, _values, result)
                      result = s(:array, s(:kwsplat, val[1]))
                    
    result
end

#_reduce_6(val, _values, result) ⇒ Object

reduce 5 omitted



3492
3493
3494
3495
3496
 
# File 'lib/ruby22_parser.rb', line 3492

def _reduce_6(val, _values, result)
                      result = self.block_append val[0], val[2]
                    
    result
end

#_reduce_60(val, _values, result) ⇒ Object 



3811
3812
3813
3814
3815
 
# File 'lib/ruby22_parser.rb', line 3811

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

#_reduce_61(val, _values, result) ⇒ Object 



3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
 
# File 'lib/ruby22_parser.rb', line 3817

def _reduce_61(val, _values, result)
                      recv, _, msg, args, block = val
                      call = new_call recv, msg.to_sym, args, val[1]

                      block_dup_check call, block

                      block.insert 1, call
                      result = block
                    
    result
end

#_reduce_62(val, _values, result) ⇒ Object 



3829
3830
3831
3832
3833
 
# File 'lib/ruby22_parser.rb', line 3829

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

#_reduce_622(val, _values, result) ⇒ Object

reduce 621 omitted



6788
6789
6790
6791
 
# File 'lib/ruby22_parser.rb', line 6788

def _reduce_622(val, _values, result)
 yyerrok 
    result
end

#_reduce_625(val, _values, result) ⇒ Object

reduce 624 omitted



6797
6798
6799
6800
 
# File 'lib/ruby22_parser.rb', line 6797

def _reduce_625(val, _values, result)
 yyerrok 
    result
end

#_reduce_626(val, _values, result) ⇒ Object 



6802
6803
6804
6805
 
# File 'lib/ruby22_parser.rb', line 6802

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

#_reduce_63(val, _values, result) ⇒ Object 



3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
 
# File 'lib/ruby22_parser.rb', line 3835

def _reduce_63(val, _values, result)
                      recv, _, msg, args, block = val
                      call = new_call recv, msg.to_sym, args

                      block_dup_check call, block

                      block.insert 1, call
                      result = block
                    
    result
end

#_reduce_64(val, _values, result) ⇒ Object 



3847
3848
3849
3850
3851
 
# File 'lib/ruby22_parser.rb', line 3847

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

#_reduce_65(val, _values, result) ⇒ Object 



3853
3854
3855
3856
3857
 
# File 'lib/ruby22_parser.rb', line 3853

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

#_reduce_66(val, _values, result) ⇒ Object 



3859
3860
3861
3862
3863
3864
 
# File 'lib/ruby22_parser.rb', line 3859

def _reduce_66(val, _values, result)
                      line = val[0].last
                      result = s(:return, ret_args(val[1])).line(line)
                    
    result
end

#_reduce_67(val, _values, result) ⇒ Object 



3866
3867
3868
3869
3870
3871
 
# File 'lib/ruby22_parser.rb', line 3866

def _reduce_67(val, _values, result)
                      line = val[0].last
                      result = s(:break, ret_args(val[1])).line(line)
                    
    result
end

#_reduce_68(val, _values, result) ⇒ Object 



3873
3874
3875
3876
3877
3878
 
# File 'lib/ruby22_parser.rb', line 3873

def _reduce_68(val, _values, result)
                      line = val[0].last
                      result = s(:next, ret_args(val[1])).line(line)
                    
    result
end

#_reduce_70(val, _values, result) ⇒ Object

reduce 69 omitted



3882
3883
3884
3885
3886
 
# File 'lib/ruby22_parser.rb', line 3882

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

#_reduce_72(val, _values, result) ⇒ Object

reduce 71 omitted



3890
3891
3892
3893
3894
 
# File 'lib/ruby22_parser.rb', line 3890

def _reduce_72(val, _values, result)
                      result = s(:masgn, s(:array, val[1]))
                    
    result
end

#_reduce_73(val, _values, result) ⇒ Object 



3896
3897
3898
3899
3900
 
# File 'lib/ruby22_parser.rb', line 3896

def _reduce_73(val, _values, result)
                      result = s(:masgn, val[0])
                    
    result
end

#_reduce_74(val, _values, result) ⇒ Object 



3902
3903
3904
3905
3906
 
# File 'lib/ruby22_parser.rb', line 3902

def _reduce_74(val, _values, result)
                      result = s(:masgn, val[0] << val[1].compact)
                    
    result
end

#_reduce_75(val, _values, result) ⇒ Object 



3908
3909
3910
3911
3912
 
# File 'lib/ruby22_parser.rb', line 3908

def _reduce_75(val, _values, result)
                      result = s(:masgn, val[0] << s(:splat, val[2]))
                    
    result
end

#_reduce_76(val, _values, result) ⇒ Object 



3914
3915
3916
3917
3918
3919
3920
3921
3922
 
# File 'lib/ruby22_parser.rb', line 3914

def _reduce_76(val, _values, result)
                      ary1, _, splat, _, ary2 = val

                      result = list_append ary1, s(:splat, splat)
                      result.concat ary2.sexp_body
                      result = s(:masgn, result)
                    
    result
end

#_reduce_77(val, _values, result) ⇒ Object 



3924
3925
3926
3927
3928
 
# File 'lib/ruby22_parser.rb', line 3924

def _reduce_77(val, _values, result)
                      result = s(:masgn, val[0] << s(:splat))
                    
    result
end

#_reduce_78(val, _values, result) ⇒ Object 



3930
3931
3932
3933
3934
3935
3936
 
# File 'lib/ruby22_parser.rb', line 3930

def _reduce_78(val, _values, result)
                      ary = list_append val[0], s(:splat)
                      ary.concat val[3].sexp_body
                      result = s(:masgn, ary)
                    
    result
end

#_reduce_79(val, _values, result) ⇒ Object 



3938
3939
3940
3941
3942
 
# File 'lib/ruby22_parser.rb', line 3938

def _reduce_79(val, _values, result)
                      result = s(:masgn, s(:array, s(:splat, val[1])))
                    
    result
end

#_reduce_8(val, _values, result) ⇒ Object

reduce 7 omitted



3500
3501
3502
3503
3504
3505
3506
3507
3508
3509
 
# File 'lib/ruby22_parser.rb', line 3500

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

                      # TODO: remove once I have more confidence this is fixed
                      # result.each_of_type :call_args do |s|
                      #   debug20 666, s, result
                      # end
                    
    result
end

#_reduce_80(val, _values, result) ⇒ Object 



3944
3945
3946
3947
3948
3949
3950
 
# File 'lib/ruby22_parser.rb', line 3944

def _reduce_80(val, _values, result)
                      ary = s(:array, s(:splat, val[1]))
                      ary.concat val[3].sexp_body
                      result = s(:masgn, ary)
                    
    result
end

#_reduce_81(val, _values, result) ⇒ Object 



3952
3953
3954
3955
3956
 
# File 'lib/ruby22_parser.rb', line 3952

def _reduce_81(val, _values, result)
                      result = s(:masgn, s(:array, s(:splat)))
                    
    result
end

#_reduce_82(val, _values, result) ⇒ Object 



3958
3959
3960
3961
3962
 
# File 'lib/ruby22_parser.rb', line 3958

def _reduce_82(val, _values, result)
                      result = s(:masgn, s(:array, s(:splat), *val[2].sexp_body))
                    
    result
end

#_reduce_84(val, _values, result) ⇒ Object

reduce 83 omitted



3966
3967
3968
3969
3970
 
# File 'lib/ruby22_parser.rb', line 3966

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

#_reduce_85(val, _values, result) ⇒ Object 



3972
3973
3974
3975
3976
 
# File 'lib/ruby22_parser.rb', line 3972

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

#_reduce_86(val, _values, result) ⇒ Object 



3978
3979
3980
3981
3982
 
# File 'lib/ruby22_parser.rb', line 3978

def _reduce_86(val, _values, result)
                      result = val[0] << val[1].compact
                    
    result
end

#_reduce_87(val, _values, result) ⇒ Object 



3984
3985
3986
3987
3988
 
# File 'lib/ruby22_parser.rb', line 3984

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

#_reduce_88(val, _values, result) ⇒ Object 



3990
3991
3992
3993
3994
 
# File 'lib/ruby22_parser.rb', line 3990

def _reduce_88(val, _values, result)
                      result = list_append val[0], val[2]
                    
    result
end

#_reduce_89(val, _values, result) ⇒ Object 



3996
3997
3998
3999
4000
 
# File 'lib/ruby22_parser.rb', line 3996

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

#_reduce_9(val, _values, result) ⇒ Object 



3511
3512
3513
3514
3515
3516
3517
3518
3519
 
# File 'lib/ruby22_parser.rb', line 3511

def _reduce_9(val, _values, result)
                      if (self.in_def || self.in_single > 0) then
                        debug20 1
                        yyerror "BEGIN in method"
                      end
                      self.env.extend
                    
    result
end

#_reduce_90(val, _values, result) ⇒ Object 



4002
4003
4004
4005
4006
 
# File 'lib/ruby22_parser.rb', line 4002

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

#_reduce_91(val, _values, result) ⇒ Object 



4008
4009
4010
4011
4012
 
# File 'lib/ruby22_parser.rb', line 4008

def _reduce_91(val, _values, result)
                      result = self.aryset val[0], val[2]
                    
    result
end

#_reduce_92(val, _values, result) ⇒ Object 



4014
4015
4016
4017
4018
 
# File 'lib/ruby22_parser.rb', line 4014

def _reduce_92(val, _values, result)
                      result = new_attrasgn val[0], val[2], val[1]
                    
    result
end

#_reduce_93(val, _values, result) ⇒ Object 



4020
4021
4022
4023
4024
 
# File 'lib/ruby22_parser.rb', line 4020

def _reduce_93(val, _values, result)
                      result = s(:attrasgn, val[0], :"#{val[2]}=")
                    
    result
end

#_reduce_94(val, _values, result) ⇒ Object 



4026
4027
4028
4029
4030
 
# File 'lib/ruby22_parser.rb', line 4026

def _reduce_94(val, _values, result)
                      result = new_attrasgn val[0], val[2], val[1]
                    
    result
end

#_reduce_95(val, _values, result) ⇒ Object 



4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
 
# File 'lib/ruby22_parser.rb', line 4032

def _reduce_95(val, _values, result)
                      if (self.in_def || self.in_single > 0) then
                        debug20 7
                        yyerror "dynamic constant assignment"
                      end

                      result = s(:const, s(:colon2, val[0], val[2].to_sym), nil)
                    
    result
end

#_reduce_96(val, _values, result) ⇒ Object 



4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
 
# File 'lib/ruby22_parser.rb', line 4043

def _reduce_96(val, _values, result)
                      if (self.in_def || self.in_single > 0) then
                        debug20 8
                        yyerror "dynamic constant assignment"
                      end

                      result = s(:const, nil, s(:colon3, val[1].to_sym))
                    
    result
end

#_reduce_97(val, _values, result) ⇒ Object 



4054
4055
4056
4057
4058
 
# File 'lib/ruby22_parser.rb', line 4054

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

#_reduce_98(val, _values, result) ⇒ Object 



4060
4061
4062
4063
4064
 
# File 'lib/ruby22_parser.rb', line 4060

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

#_reduce_99(val, _values, result) ⇒ Object 



4066
4067
4068
4069
4070
4071
 
# File 'lib/ruby22_parser.rb', line 4066

def _reduce_99(val, _values, result)
                      result = self.assignable val[0]
                      debug20 9, val, result
                    
    result
end

#_reduce_none(val, _values, result) ⇒ Object 



6807
6808
6809
 
# File 'lib/ruby22_parser.rb', line 6807

def _reduce_none(val, _values, result)
  val[0]
end