Class: Ruby19Parser

Inherits:
Racc::Parser
  • Object
show all
Includes:
RubyParserStuff
Defined in:
lib/ruby19_parser.rb,
lib/ruby_parser_extras.rb

Constant Summary collapse

Racc_arg =
[
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table =
[
"$end",
"error",
"kCLASS",
"kMODULE",
"kDEF",
"kUNDEF",
"kBEGIN",
"kRESCUE",
"kENSURE",
"kEND",
"kIF",
"kUNLESS",
"kTHEN",
"kELSIF",
"kELSE",
"kCASE",
"kWHEN",
"kWHILE",
"kUNTIL",
"kFOR",
"kBREAK",
"kNEXT",
"kREDO",
"kRETRY",
"kIN",
"kDO",
"kDO_COND",
"kDO_BLOCK",
"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",
"tLAST_TOKEN",
"tLAMBDA",
"tLAMBEG",
"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",
"backref",
"lhs",
"mrhs",
"arg_value",
"expr",
"@3",
"opt_nl",
"arg",
"command",
"block_command",
"block_call",
"operation2",
"command_args",
"cmd_brace_block",
"opt_block_param",
"@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",
"primary",
"aref_args",
"args",
"trailer",
"assocs",
"paren_args",
"opt_paren_args",
"opt_block_arg",
"block_arg",
"@7",
"literal",
"strings",
"xstring",
"regexp",
"words",
"qwords",
"var_ref",
"assoc_list",
"brace_block",
"method_call",
"lambda",
"then",
"if_tail",
"do",
"case_body",
"for_var",
"superclass",
"term",
"f_arglist",
"singleton",
"dot_or_colon",
"@8",
"@9",
"@10",
"@11",
"@12",
"@13",
"@14",
"@15",
"@16",
"@17",
"@18",
"@19",
"@20",
"@21",
"@22",
"@23",
"@24",
"@25",
"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_param",
"f_arg",
"f_block_optarg",
"f_rest_arg",
"opt_f_block_arg",
"f_block_arg",
"block_param_def",
"opt_bv_decl",
"bv_decls",
"bvar",
"f_bad_arg",
"f_larglist",
"lambda_body",
"@26",
"f_args",
"do_block",
"@27",
"@28",
"operation3",
"@29",
"@30",
"@31",
"@32",
"@33",
"cases",
"@34",
"exc_list",
"exc_var",
"numeric",
"string",
"string1",
"string_contents",
"xstring_contents",
"regexp_contents",
"word_list",
"word",
"string_content",
"qword_list",
"string_dvar",
"@35",
"@36",
"sym",
"@37",
"f_optarg",
"f_arg_item",
"f_opt",
"f_block_opt",
"restarg_mark",
"blkarg_mark",
"@38",
"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 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, #do_parse, #get_match_node, #gettable, #hack_encoding, #handle_encoding, #initialize, #invert_block_call, #inverted?, #list_append, #list_prepend, #literal_concat, #logop, #new_aref, #new_body, #new_call, #new_case, #new_class, #new_compstmt, #new_defn, #new_defs, #new_for, #new_if, #new_iter, #new_masgn, #new_masgn_arg, #new_module, #new_op_asgn, #new_regexp, #new_resbody, #new_sclass, #new_string, #new_super, #new_undef, #new_until, #new_until_or_while, #new_when, #new_while, #new_xstring, #new_yield, #next_token, #node_assign, #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



3154
3155
3156
3157
3158
# File 'lib/ruby19_parser.rb', line 3154

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

#_reduce_10(val, _values, result) ⇒ Object



3195
3196
3197
3198
3199
# File 'lib/ruby19_parser.rb', line 3195

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

#_reduce_100(val, _values, result) ⇒ Object



3732
3733
3734
3735
3736
# File 'lib/ruby19_parser.rb', line 3732

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

#_reduce_101(val, _values, result) ⇒ Object



3738
3739
3740
3741
3742
# File 'lib/ruby19_parser.rb', line 3738

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

#_reduce_102(val, _values, result) ⇒ Object



3744
3745
3746
3747
3748
# File 'lib/ruby19_parser.rb', line 3744

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

#_reduce_103(val, _values, result) ⇒ Object



3750
3751
3752
3753
3754
# File 'lib/ruby19_parser.rb', line 3750

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

#_reduce_104(val, _values, result) ⇒ Object



3756
3757
3758
3759
3760
# File 'lib/ruby19_parser.rb', line 3756

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

#_reduce_105(val, _values, result) ⇒ Object



3762
3763
3764
3765
3766
3767
3768
3769
3770
# File 'lib/ruby19_parser.rb', line 3762

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

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

#_reduce_106(val, _values, result) ⇒ Object



3772
3773
3774
3775
3776
3777
3778
3779
3780
# File 'lib/ruby19_parser.rb', line 3772

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

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

#_reduce_107(val, _values, result) ⇒ Object



3782
3783
3784
3785
3786
# File 'lib/ruby19_parser.rb', line 3782

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

#_reduce_108(val, _values, result) ⇒ Object



3788
3789
3790
3791
3792
# File 'lib/ruby19_parser.rb', line 3788

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

#_reduce_11(val, _values, result) ⇒ Object



3201
3202
3203
3204
3205
# File 'lib/ruby19_parser.rb', line 3201

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

#_reduce_110(val, _values, result) ⇒ Object

reduce 109 omitted



3796
3797
3798
3799
3800
# File 'lib/ruby19_parser.rb', line 3796

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

#_reduce_111(val, _values, result) ⇒ Object



3802
3803
3804
3805
3806
# File 'lib/ruby19_parser.rb', line 3802

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

#_reduce_112(val, _values, result) ⇒ Object



3808
3809
3810
3811
3812
# File 'lib/ruby19_parser.rb', line 3808

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

#_reduce_116(val, _values, result) ⇒ Object

reduce 115 omitted



3820
3821
3822
3823
3824
3825
# File 'lib/ruby19_parser.rb', line 3820

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

#_reduce_117(val, _values, result) ⇒ Object



3827
3828
3829
3830
3831
3832
# File 'lib/ruby19_parser.rb', line 3827

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

#_reduce_12(val, _values, result) ⇒ Object



3207
3208
3209
3210
3211
# File 'lib/ruby19_parser.rb', line 3207

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

#_reduce_120(val, _values, result) ⇒ Object

reduce 119 omitted



3838
3839
3840
3841
# File 'lib/ruby19_parser.rb', line 3838

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

#_reduce_122(val, _values, result) ⇒ Object

reduce 121 omitted



3845
3846
3847
3848
3849
# File 'lib/ruby19_parser.rb', line 3845

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

#_reduce_123(val, _values, result) ⇒ Object



3851
3852
3853
3854
3855
# File 'lib/ruby19_parser.rb', line 3851

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

#_reduce_124(val, _values, result) ⇒ Object



3857
3858
3859
3860
3861
# File 'lib/ruby19_parser.rb', line 3857

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

#_reduce_15(val, _values, result) ⇒ Object

reduce 14 omitted



3217
3218
3219
3220
3221
# File 'lib/ruby19_parser.rb', line 3217

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

#_reduce_16(val, _values, result) ⇒ Object



3223
3224
3225
3226
3227
# File 'lib/ruby19_parser.rb', line 3223

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

#_reduce_17(val, _values, result) ⇒ Object



3229
3230
3231
3232
3233
3234
# File 'lib/ruby19_parser.rb', line 3229

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

#_reduce_18(val, _values, result) ⇒ Object



3236
3237
3238
3239
3240
# File 'lib/ruby19_parser.rb', line 3236

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

#_reduce_19(val, _values, result) ⇒ Object



3242
3243
3244
3245
3246
# File 'lib/ruby19_parser.rb', line 3242

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



4003
4004
4005
4006
4007
# File 'lib/ruby19_parser.rb', line 4003

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

#_reduce_196(val, _values, result) ⇒ Object



4009
4010
4011
4012
4013
# File 'lib/ruby19_parser.rb', line 4009

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

#_reduce_197(val, _values, result) ⇒ Object



4015
4016
4017
4018
4019
# File 'lib/ruby19_parser.rb', line 4015

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

#_reduce_198(val, _values, result) ⇒ Object



4021
4022
4023
4024
4025
4026
# File 'lib/ruby19_parser.rb', line 4021

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



4028
4029
4030
4031
4032
4033
# File 'lib/ruby19_parser.rb', line 4028

def _reduce_199(val, _values, result)
                      val[2][0] = :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



3160
3161
3162
3163
3164
# File 'lib/ruby19_parser.rb', line 3160

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

#_reduce_20(val, _values, result) ⇒ Object



3248
3249
3250
3251
3252
# File 'lib/ruby19_parser.rb', line 3248

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

#_reduce_200(val, _values, result) ⇒ Object



4035
4036
4037
4038
4039
# File 'lib/ruby19_parser.rb', line 4035

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

#_reduce_201(val, _values, result) ⇒ Object



4041
4042
4043
4044
4045
# File 'lib/ruby19_parser.rb', line 4041

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

#_reduce_202(val, _values, result) ⇒ Object



4047
4048
4049
4050
4051
# File 'lib/ruby19_parser.rb', line 4047

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



4053
4054
4055
4056
4057
# File 'lib/ruby19_parser.rb', line 4053

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

#_reduce_204(val, _values, result) ⇒ Object



4059
4060
4061
4062
4063
# File 'lib/ruby19_parser.rb', line 4059

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

#_reduce_205(val, _values, result) ⇒ Object



4065
4066
4067
4068
4069
# File 'lib/ruby19_parser.rb', line 4065

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

#_reduce_206(val, _values, result) ⇒ Object



4071
4072
4073
4074
4075
4076
4077
4078
4079
4080
# File 'lib/ruby19_parser.rb', line 4071

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

#_reduce_207(val, _values, result) ⇒ Object



4082
4083
4084
4085
4086
4087
4088
4089
4090
4091
# File 'lib/ruby19_parser.rb', line 4082

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

#_reduce_208(val, _values, result) ⇒ Object



4093
4094
4095
4096
4097
# File 'lib/ruby19_parser.rb', line 4093

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

#_reduce_209(val, _values, result) ⇒ Object



4099
4100
4101
4102
4103
# File 'lib/ruby19_parser.rb', line 4099

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

#_reduce_21(val, _values, result) ⇒ Object



3254
3255
3256
3257
3258
# File 'lib/ruby19_parser.rb', line 3254

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

#_reduce_210(val, _values, result) ⇒ Object



4105
4106
4107
4108
4109
# File 'lib/ruby19_parser.rb', line 4105

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

#_reduce_211(val, _values, result) ⇒ Object



4111
4112
4113
4114
4115
# File 'lib/ruby19_parser.rb', line 4111

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

#_reduce_212(val, _values, result) ⇒ Object



4117
4118
4119
4120
4121
# File 'lib/ruby19_parser.rb', line 4117

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

#_reduce_213(val, _values, result) ⇒ Object



4123
4124
4125
4126
4127
# File 'lib/ruby19_parser.rb', line 4123

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

#_reduce_214(val, _values, result) ⇒ Object



4129
4130
4131
4132
4133
# File 'lib/ruby19_parser.rb', line 4129

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



4135
4136
4137
4138
4139
# File 'lib/ruby19_parser.rb', line 4135

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

#_reduce_216(val, _values, result) ⇒ Object



4141
4142
4143
4144
4145
# File 'lib/ruby19_parser.rb', line 4141

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

#_reduce_217(val, _values, result) ⇒ Object



4147
4148
4149
4150
4151
# File 'lib/ruby19_parser.rb', line 4147

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

#_reduce_218(val, _values, result) ⇒ Object



4153
4154
4155
4156
4157
# File 'lib/ruby19_parser.rb', line 4153

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

#_reduce_219(val, _values, result) ⇒ Object



4159
4160
4161
4162
4163
# File 'lib/ruby19_parser.rb', line 4159

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

#_reduce_22(val, _values, result) ⇒ Object



3260
3261
3262
3263
3264
# File 'lib/ruby19_parser.rb', line 3260

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

#_reduce_220(val, _values, result) ⇒ Object



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

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

#_reduce_221(val, _values, result) ⇒ Object



4171
4172
4173
4174
4175
# File 'lib/ruby19_parser.rb', line 4171

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

#_reduce_222(val, _values, result) ⇒ Object



4177
4178
4179
4180
4181
# File 'lib/ruby19_parser.rb', line 4177

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

#_reduce_223(val, _values, result) ⇒ Object



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

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

#_reduce_224(val, _values, result) ⇒ Object



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

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

#_reduce_225(val, _values, result) ⇒ Object



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

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

#_reduce_226(val, _values, result) ⇒ Object



4201
4202
4203
4204
4205
# File 'lib/ruby19_parser.rb', line 4201

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

#_reduce_227(val, _values, result) ⇒ Object



4207
4208
4209
4210
4211
# File 'lib/ruby19_parser.rb', line 4207

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

#_reduce_228(val, _values, result) ⇒ Object



4213
4214
4215
4216
4217
# File 'lib/ruby19_parser.rb', line 4213

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

#_reduce_229(val, _values, result) ⇒ Object



4219
4220
4221
4222
4223
# File 'lib/ruby19_parser.rb', line 4219

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

#_reduce_23(val, _values, result) ⇒ Object



3266
3267
3268
3269
3270
# File 'lib/ruby19_parser.rb', line 3266

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

#_reduce_230(val, _values, result) ⇒ Object



4225
4226
4227
4228
4229
# File 'lib/ruby19_parser.rb', line 4225

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

#_reduce_231(val, _values, result) ⇒ Object



4231
4232
4233
4234
4235
# File 'lib/ruby19_parser.rb', line 4231

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

#_reduce_232(val, _values, result) ⇒ Object



4237
4238
4239
4240
4241
4242
# File 'lib/ruby19_parser.rb', line 4237

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

#_reduce_233(val, _values, result) ⇒ Object



4244
4245
4246
4247
4248
4249
4250
# File 'lib/ruby19_parser.rb', line 4244

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



4252
4253
4254
4255
4256
4257
4258
# File 'lib/ruby19_parser.rb', line 4252

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



4260
4261
4262
4263
4264
# File 'lib/ruby19_parser.rb', line 4260

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

#_reduce_236(val, _values, result) ⇒ Object



4266
4267
4268
4269
4270
# File 'lib/ruby19_parser.rb', line 4266

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

#_reduce_237(val, _values, result) ⇒ Object



4272
4273
4274
4275
4276
# File 'lib/ruby19_parser.rb', line 4272

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

#_reduce_238(val, _values, result) ⇒ Object



4278
4279
4280
4281
4282
# File 'lib/ruby19_parser.rb', line 4278

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

#_reduce_24(val, _values, result) ⇒ Object



3272
3273
3274
3275
3276
# File 'lib/ruby19_parser.rb', line 3272

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

#_reduce_240(val, _values, result) ⇒ Object

reduce 239 omitted



4286
4287
4288
4289
4290
# File 'lib/ruby19_parser.rb', line 4286

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

#_reduce_242(val, _values, result) ⇒ Object

reduce 241 omitted



4294
4295
4296
4297
4298
# File 'lib/ruby19_parser.rb', line 4294

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

#_reduce_243(val, _values, result) ⇒ Object



4300
4301
4302
4303
4304
# File 'lib/ruby19_parser.rb', line 4300

def _reduce_243(val, _values, result)
                      result = val[0] << s(:hash, *val[2].values)
                    
    result
end

#_reduce_244(val, _values, result) ⇒ Object



4306
4307
4308
4309
4310
# File 'lib/ruby19_parser.rb', line 4306

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

#_reduce_245(val, _values, result) ⇒ Object



4312
4313
4314
4315
4316
# File 'lib/ruby19_parser.rb', line 4312

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

#_reduce_248(val, _values, result) ⇒ Object

reduce 247 omitted



4322
4323
4324
4325
4326
# File 'lib/ruby19_parser.rb', line 4322

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

#_reduce_249(val, _values, result) ⇒ Object



4328
4329
4330
4331
4332
# File 'lib/ruby19_parser.rb', line 4328

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

#_reduce_25(val, _values, result) ⇒ Object



3278
3279
3280
3281
3282
# File 'lib/ruby19_parser.rb', line 3278

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

#_reduce_250(val, _values, result) ⇒ Object



4334
4335
4336
4337
4338
# File 'lib/ruby19_parser.rb', line 4334

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

#_reduce_251(val, _values, result) ⇒ Object



4340
4341
4342
4343
4344
# File 'lib/ruby19_parser.rb', line 4340

def _reduce_251(val, _values, result)
                      result = val[0] << s(:hash, *val[2][1..-1]) # TODO: self.args
                    
    result
end

#_reduce_252(val, _values, result) ⇒ Object



4346
4347
4348
4349
4350
# File 'lib/ruby19_parser.rb', line 4346

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

#_reduce_253(val, _values, result) ⇒ Object



4352
4353
4354
4355
4356
4357
# File 'lib/ruby19_parser.rb', line 4352

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

#_reduce_254(val, _values, result) ⇒ Object



4359
4360
4361
4362
4363
# File 'lib/ruby19_parser.rb', line 4359

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

#_reduce_255(val, _values, result) ⇒ Object



4365
4366
4367
4368
4369
4370
# File 'lib/ruby19_parser.rb', line 4365

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

#_reduce_256(val, _values, result) ⇒ Object



4372
4373
4374
4375
4376
4377
# File 'lib/ruby19_parser.rb', line 4372

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

#_reduce_258(val, _values, result) ⇒ Object

reduce 257 omitted



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

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

#_reduce_259(val, _values, result) ⇒ Object



4388
4389
4390
4391
4392
4393
# File 'lib/ruby19_parser.rb', line 4388

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

#_reduce_26(val, _values, result) ⇒ Object



3284
3285
3286
3287
3288
# File 'lib/ruby19_parser.rb', line 3284

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

#_reduce_260(val, _values, result) ⇒ Object



4395
4396
4397
4398
4399
# File 'lib/ruby19_parser.rb', line 4395

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

#_reduce_261(val, _values, result) ⇒ Object



4401
4402
4403
4404
4405
# File 'lib/ruby19_parser.rb', line 4401

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

#_reduce_263(val, _values, result) ⇒ Object

reduce 262 omitted



4409
4410
4411
4412
4413
# File 'lib/ruby19_parser.rb', line 4409

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

#_reduce_264(val, _values, result) ⇒ Object



4415
4416
4417
4418
4419
# File 'lib/ruby19_parser.rb', line 4415

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

#_reduce_265(val, _values, result) ⇒ Object



4421
4422
4423
4424
4425
# File 'lib/ruby19_parser.rb', line 4421

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

#_reduce_266(val, _values, result) ⇒ Object



4427
4428
4429
4430
4431
# File 'lib/ruby19_parser.rb', line 4427

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

#_reduce_267(val, _values, result) ⇒ Object



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

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

#_reduce_268(val, _values, result) ⇒ Object



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

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

#_reduce_269(val, _values, result) ⇒ Object



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

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

#_reduce_27(val, _values, result) ⇒ Object



3290
3291
3292
3293
3294
# File 'lib/ruby19_parser.rb', line 3290

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

#_reduce_278(val, _values, result) ⇒ Object

reduce 277 omitted



4467
4468
4469
4470
4471
# File 'lib/ruby19_parser.rb', line 4467

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

#_reduce_279(val, _values, result) ⇒ Object



4473
4474
4475
4476
4477
# File 'lib/ruby19_parser.rb', line 4473

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

#_reduce_28(val, _values, result) ⇒ Object



3296
3297
3298
3299
3300
3301
3302
3303
# File 'lib/ruby19_parser.rb', line 3296

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

#_reduce_280(val, _values, result) ⇒ Object



4479
4480
4481
4482
4483
4484
4485
4486
4487
4488
4489
# File 'lib/ruby19_parser.rb', line 4479

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

                      result.line = val[1]
                    
    result
end

#_reduce_281(val, _values, result) ⇒ Object



4491
4492
4493
4494
4495
# File 'lib/ruby19_parser.rb', line 4491

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

#_reduce_282(val, _values, result) ⇒ Object



4497
4498
4499
4500
4501
4502
# File 'lib/ruby19_parser.rb', line 4497

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

#_reduce_283(val, _values, result) ⇒ Object



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

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

#_reduce_284(val, _values, result) ⇒ Object



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

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

#_reduce_285(val, _values, result) ⇒ Object



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

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

#_reduce_286(val, _values, result) ⇒ Object



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

def _reduce_286(val, _values, result)
                      result = val[1] || s(:array)
                    
    result
end

#_reduce_287(val, _values, result) ⇒ Object



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

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

#_reduce_288(val, _values, result) ⇒ Object



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

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

#_reduce_289(val, _values, result) ⇒ Object



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

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

#_reduce_290(val, _values, result) ⇒ Object



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

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

#_reduce_291(val, _values, result) ⇒ Object



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

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

#_reduce_292(val, _values, result) ⇒ Object



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

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

#_reduce_293(val, _values, result) ⇒ Object



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

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

#_reduce_294(val, _values, result) ⇒ Object



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

def _reduce_294(val, _values, result)
                      raise "no3\non#{val.inspect}"
                    
    result
end

#_reduce_295(val, _values, result) ⇒ Object



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

def _reduce_295(val, _values, result)
                      oper, iter = val[0], val[1]
                      call = new_call nil, oper.to_sym
                      iter.insert 1, call
                      result = iter
                      call.line = iter.line
                    
    result
end

#_reduce_297(val, _values, result) ⇒ Object

reduce 296 omitted



4589
4590
4591
4592
4593
4594
4595
4596
# File 'lib/ruby19_parser.rb', line 4589

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

#_reduce_298(val, _values, result) ⇒ Object



4598
4599
4600
4601
4602
# File 'lib/ruby19_parser.rb', line 4598

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

#_reduce_299(val, _values, result) ⇒ Object



4604
4605
4606
4607
4608
# File 'lib/ruby19_parser.rb', line 4604

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

#_reduce_3(val, _values, result) ⇒ Object



3166
3167
3168
3169
3170
# File 'lib/ruby19_parser.rb', line 3166

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

#_reduce_30(val, _values, result) ⇒ Object

reduce 29 omitted



3307
3308
3309
3310
3311
# File 'lib/ruby19_parser.rb', line 3307

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

#_reduce_300(val, _values, result) ⇒ Object



4610
4611
4612
4613
4614
# File 'lib/ruby19_parser.rb', line 4610

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

#_reduce_301(val, _values, result) ⇒ Object



4616
4617
4618
4619
4620
# File 'lib/ruby19_parser.rb', line 4616

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

#_reduce_302(val, _values, result) ⇒ Object



4622
4623
4624
4625
4626
# File 'lib/ruby19_parser.rb', line 4622

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

#_reduce_303(val, _values, result) ⇒ Object



4628
4629
4630
4631
4632
# File 'lib/ruby19_parser.rb', line 4628

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

#_reduce_304(val, _values, result) ⇒ Object



4634
4635
4636
4637
4638
# File 'lib/ruby19_parser.rb', line 4634

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

#_reduce_305(val, _values, result) ⇒ Object



4640
4641
4642
4643
4644
# File 'lib/ruby19_parser.rb', line 4640

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

#_reduce_306(val, _values, result) ⇒ Object



4646
4647
4648
4649
4650
# File 'lib/ruby19_parser.rb', line 4646

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

#_reduce_307(val, _values, result) ⇒ Object



4652
4653
4654
4655
4656
4657
# File 'lib/ruby19_parser.rb', line 4652

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

#_reduce_308(val, _values, result) ⇒ Object



4659
4660
4661
4662
4663
4664
# File 'lib/ruby19_parser.rb', line 4659

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

#_reduce_309(val, _values, result) ⇒ Object



4666
4667
4668
4669
4670
# File 'lib/ruby19_parser.rb', line 4666

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

#_reduce_31(val, _values, result) ⇒ Object



3313
3314
3315
3316
3317
# File 'lib/ruby19_parser.rb', line 3313

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

#_reduce_310(val, _values, result) ⇒ Object



4672
4673
4674
4675
4676
# File 'lib/ruby19_parser.rb', line 4672

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

#_reduce_311(val, _values, result) ⇒ Object



4678
4679
4680
4681
4682
# File 'lib/ruby19_parser.rb', line 4678

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

#_reduce_312(val, _values, result) ⇒ Object



4684
4685
4686
4687
4688
# File 'lib/ruby19_parser.rb', line 4684

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

#_reduce_313(val, _values, result) ⇒ Object



4690
4691
4692
4693
4694
4695
4696
4697
4698
# File 'lib/ruby19_parser.rb', line 4690

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



4700
4701
4702
4703
4704
4705
4706
# File 'lib/ruby19_parser.rb', line 4700

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



4708
4709
4710
4711
4712
# File 'lib/ruby19_parser.rb', line 4708

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

#_reduce_316(val, _values, result) ⇒ Object



4714
4715
4716
4717
4718
4719
# File 'lib/ruby19_parser.rb', line 4714

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

#_reduce_317(val, _values, result) ⇒ Object



4721
4722
4723
4724
4725
4726
4727
# File 'lib/ruby19_parser.rb', line 4721

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

#_reduce_318(val, _values, result) ⇒ Object



4729
4730
4731
4732
4733
4734
4735
# File 'lib/ruby19_parser.rb', line 4729

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



4737
4738
4739
4740
4741
# File 'lib/ruby19_parser.rb', line 4737

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

#_reduce_32(val, _values, result) ⇒ Object



3319
3320
3321
3322
3323
# File 'lib/ruby19_parser.rb', line 3319

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



4743
4744
4745
4746
4747
4748
4749
4750
4751
# File 'lib/ruby19_parser.rb', line 4743

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



4753
4754
4755
4756
4757
4758
4759
# File 'lib/ruby19_parser.rb', line 4753

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



4761
4762
4763
4764
4765
4766
4767
4768
4769
# File 'lib/ruby19_parser.rb', line 4761

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

                      self.comments.push self.lexer.comments
                      self.in_def = true
                      self.env.extend
                    
    result
end

#_reduce_323(val, _values, result) ⇒ Object



4771
4772
4773
4774
4775
4776
4777
4778
4779
4780
4781
# File 'lib/ruby19_parser.rb', line 4771

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

                      result = new_defn val

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

#_reduce_324(val, _values, result) ⇒ Object



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

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

#_reduce_325(val, _values, result) ⇒ Object



4790
4791
4792
4793
4794
4795
4796
4797
# File 'lib/ruby19_parser.rb', line 4790

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

#_reduce_326(val, _values, result) ⇒ Object



4799
4800
4801
4802
4803
4804
4805
4806
4807
4808
# File 'lib/ruby19_parser.rb', line 4799

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

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

#_reduce_327(val, _values, result) ⇒ Object



4810
4811
4812
4813
4814
# File 'lib/ruby19_parser.rb', line 4810

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

#_reduce_328(val, _values, result) ⇒ Object



4816
4817
4818
4819
4820
# File 'lib/ruby19_parser.rb', line 4816

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

#_reduce_329(val, _values, result) ⇒ Object



4822
4823
4824
4825
4826
# File 'lib/ruby19_parser.rb', line 4822

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

#_reduce_33(val, _values, result) ⇒ Object



3325
3326
3327
3328
3329
# File 'lib/ruby19_parser.rb', line 3325

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

#_reduce_330(val, _values, result) ⇒ Object



4828
4829
4830
4831
4832
# File 'lib/ruby19_parser.rb', line 4828

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

#_reduce_331(val, _values, result) ⇒ Object



4834
4835
4836
4837
4838
# File 'lib/ruby19_parser.rb', line 4834

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

#_reduce_34(val, _values, result) ⇒ Object



3331
3332
3333
3334
3335
# File 'lib/ruby19_parser.rb', line 3331

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

#_reduce_349(val, _values, result) ⇒ Object

reduce 348 omitted



4874
4875
4876
4877
4878
# File 'lib/ruby19_parser.rb', line 4874

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

#_reduce_35(val, _values, result) ⇒ Object



3337
3338
3339
3340
3341
# File 'lib/ruby19_parser.rb', line 3337

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

#_reduce_351(val, _values, result) ⇒ Object

reduce 350 omitted



4882
4883
4884
4885
4886
# File 'lib/ruby19_parser.rb', line 4882

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

#_reduce_353(val, _values, result) ⇒ Object

reduce 352 omitted



4890
4891
4892
4893
4894
# File 'lib/ruby19_parser.rb', line 4890

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

#_reduce_355(val, _values, result) ⇒ Object

reduce 354 omitted



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

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

#_reduce_356(val, _values, result) ⇒ Object



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

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

#_reduce_357(val, _values, result) ⇒ Object



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

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

#_reduce_358(val, _values, result) ⇒ Object



4916
4917
4918
4919
4920
4921
4922
# File 'lib/ruby19_parser.rb', line 4916

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

                      result = block_var args
                    
    result
end

#_reduce_359(val, _values, result) ⇒ Object



4924
4925
4926
4927
4928
4929
4930
# File 'lib/ruby19_parser.rb', line 4924

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

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

#_reduce_36(val, _values, result) ⇒ Object



3343
3344
3345
3346
3347
# File 'lib/ruby19_parser.rb', line 3343

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

#_reduce_360(val, _values, result) ⇒ Object



4932
4933
4934
4935
4936
4937
4938
# File 'lib/ruby19_parser.rb', line 4932

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

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

#_reduce_361(val, _values, result) ⇒ Object



4940
4941
4942
4943
4944
4945
4946
# File 'lib/ruby19_parser.rb', line 4940

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

                      result = block_var args, :*
                    
    result
end

#_reduce_362(val, _values, result) ⇒ Object



4948
4949
4950
4951
4952
4953
4954
# File 'lib/ruby19_parser.rb', line 4948

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

                      result = block_var args, :*, args2
                    
    result
end

#_reduce_363(val, _values, result) ⇒ Object



4956
4957
4958
4959
4960
4961
4962
# File 'lib/ruby19_parser.rb', line 4956

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

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

#_reduce_364(val, _values, result) ⇒ Object



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

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

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

#_reduce_365(val, _values, result) ⇒ Object



4972
4973
4974
4975
4976
# File 'lib/ruby19_parser.rb', line 4972

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

#_reduce_366(val, _values, result) ⇒ Object



4978
4979
4980
4981
4982
4983
4984
# File 'lib/ruby19_parser.rb', line 4978

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

                      result = block_var :*, args
                    
    result
end

#_reduce_367(val, _values, result) ⇒ Object



4986
4987
4988
4989
4990
# File 'lib/ruby19_parser.rb', line 4986

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

#_reduce_368(val, _values, result) ⇒ Object



4992
4993
4994
4995
4996
# File 'lib/ruby19_parser.rb', line 4992

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

#_reduce_369(val, _values, result) ⇒ Object



4998
4999
5000
5001
5002
# File 'lib/ruby19_parser.rb', line 4998

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

#_reduce_37(val, _values, result) ⇒ Object



3349
3350
3351
3352
3353
# File 'lib/ruby19_parser.rb', line 3349

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

#_reduce_370(val, _values, result) ⇒ Object



5004
5005
5006
5007
5008
# File 'lib/ruby19_parser.rb', line 5004

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

#_reduce_371(val, _values, result) ⇒ Object



5010
5011
5012
5013
5014
# File 'lib/ruby19_parser.rb', line 5010

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

#_reduce_372(val, _values, result) ⇒ Object



5016
5017
5018
5019
5020
# File 'lib/ruby19_parser.rb', line 5016

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

#_reduce_373(val, _values, result) ⇒ Object



5022
5023
5024
5025
5026
# File 'lib/ruby19_parser.rb', line 5022

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

#_reduce_374(val, _values, result) ⇒ Object



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

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

#_reduce_375(val, _values, result) ⇒ Object



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

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

#_reduce_376(val, _values, result) ⇒ Object



5040
5041
5042
5043
5044
# File 'lib/ruby19_parser.rb', line 5040

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

#_reduce_377(val, _values, result) ⇒ Object



5046
5047
5048
5049
5050
# File 'lib/ruby19_parser.rb', line 5046

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

#_reduce_378(val, _values, result) ⇒ Object



5052
5053
5054
5055
5056
# File 'lib/ruby19_parser.rb', line 5052

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

#_reduce_379(val, _values, result) ⇒ Object



5058
5059
5060
5061
5062
# File 'lib/ruby19_parser.rb', line 5058

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

#_reduce_38(val, _values, result) ⇒ Object



3355
3356
3357
3358
3359
# File 'lib/ruby19_parser.rb', line 3355

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

#_reduce_380(val, _values, result) ⇒ Object



5064
5065
5066
5067
5068
# File 'lib/ruby19_parser.rb', line 5064

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

#_reduce_381(val, _values, result) ⇒ Object



5070
5071
5072
5073
5074
# File 'lib/ruby19_parser.rb', line 5070

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

#_reduce_384(val, _values, result) ⇒ Object

reduce 383 omitted



5080
5081
5082
5083
5084
5085
# File 'lib/ruby19_parser.rb', line 5080

def _reduce_384(val, _values, result)
                      result = args val
                      result = 0 if result == s(:args)
                    
    result
end

#_reduce_385(val, _values, result) ⇒ Object



5087
5088
5089
5090
5091
5092
# File 'lib/ruby19_parser.rb', line 5087

def _reduce_385(val, _values, result)
                      result = 0
                      self.lexer.command_start = true
                    
    result
end

#_reduce_386(val, _values, result) ⇒ Object



5094
5095
5096
5097
5098
# File 'lib/ruby19_parser.rb', line 5094

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

#_reduce_388(val, _values, result) ⇒ Object

reduce 387 omitted



5102
5103
5104
5105
5106
# File 'lib/ruby19_parser.rb', line 5102

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

#_reduce_389(val, _values, result) ⇒ Object



5108
5109
5110
5111
5112
# File 'lib/ruby19_parser.rb', line 5108

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

#_reduce_39(val, _values, result) ⇒ Object



3361
3362
3363
3364
3365
# File 'lib/ruby19_parser.rb', line 3361

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

#_reduce_390(val, _values, result) ⇒ Object



5114
5115
5116
5117
5118
# File 'lib/ruby19_parser.rb', line 5114

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

#_reduce_391(val, _values, result) ⇒ Object



5120
5121
5122
5123
5124
# File 'lib/ruby19_parser.rb', line 5120

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

#_reduce_393(val, _values, result) ⇒ Object

reduce 392 omitted



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

def _reduce_393(val, _values, result)
                      # TODO: dyna_push ? hrm
                      result = lexer.lpar_beg
                      lexer.paren_nest += 1
                      lexer.lpar_beg = lexer.paren_nest
                    
    result
end

#_reduce_394(val, _values, result) ⇒ Object



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

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

                      args = 0 if args == s(:args)

                      call = new_call nil, :lambda
                      result = new_iter call, args, body
                    
    result
end

#_reduce_395(val, _values, result) ⇒ Object



5149
5150
5151
5152
5153
# File 'lib/ruby19_parser.rb', line 5149

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

#_reduce_396(val, _values, result) ⇒ Object



5155
5156
5157
5158
5159
# File 'lib/ruby19_parser.rb', line 5155

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

#_reduce_397(val, _values, result) ⇒ Object



5161
5162
5163
5164
5165
# File 'lib/ruby19_parser.rb', line 5161

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

#_reduce_398(val, _values, result) ⇒ Object



5167
5168
5169
5170
5171
# File 'lib/ruby19_parser.rb', line 5167

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

#_reduce_399(val, _values, result) ⇒ Object



5173
5174
5175
5176
5177
5178
# File 'lib/ruby19_parser.rb', line 5173

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

#_reduce_40(val, _values, result) ⇒ Object



3367
3368
3369
3370
3371
# File 'lib/ruby19_parser.rb', line 3367

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

#_reduce_400(val, _values, result) ⇒ Object



5180
5181
5182
5183
5184
# File 'lib/ruby19_parser.rb', line 5180

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

#_reduce_401(val, _values, result) ⇒ Object



5186
5187
5188
5189
5190
5191
5192
5193
5194
5195
# File 'lib/ruby19_parser.rb', line 5186

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



5197
5198
5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
# File 'lib/ruby19_parser.rb', line 5197

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



5213
5214
5215
5216
5217
# File 'lib/ruby19_parser.rb', line 5213

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

#_reduce_404(val, _values, result) ⇒ Object



5219
5220
5221
5222
5223
# File 'lib/ruby19_parser.rb', line 5219

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

#_reduce_405(val, _values, result) ⇒ Object



5225
5226
5227
5228
5229
# File 'lib/ruby19_parser.rb', line 5225

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

#_reduce_406(val, _values, result) ⇒ Object



5231
5232
5233
5234
5235
# File 'lib/ruby19_parser.rb', line 5231

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

#_reduce_407(val, _values, result) ⇒ Object



5237
5238
5239
5240
5241
# File 'lib/ruby19_parser.rb', line 5237

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

#_reduce_408(val, _values, result) ⇒ Object



5243
5244
5245
5246
5247
# File 'lib/ruby19_parser.rb', line 5243

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

#_reduce_409(val, _values, result) ⇒ Object



5249
5250
5251
5252
5253
# File 'lib/ruby19_parser.rb', line 5249

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

#_reduce_410(val, _values, result) ⇒ Object



5255
5256
5257
5258
5259
# File 'lib/ruby19_parser.rb', line 5255

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

#_reduce_411(val, _values, result) ⇒ Object



5261
5262
5263
5264
5265
# File 'lib/ruby19_parser.rb', line 5261

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

#_reduce_412(val, _values, result) ⇒ Object



5267
5268
5269
5270
5271
# File 'lib/ruby19_parser.rb', line 5267

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

#_reduce_413(val, _values, result) ⇒ Object



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

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

#_reduce_414(val, _values, result) ⇒ Object



5279
5280
5281
5282
5283
# File 'lib/ruby19_parser.rb', line 5279

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

#_reduce_415(val, _values, result) ⇒ Object



5285
5286
5287
5288
5289
5290
# File 'lib/ruby19_parser.rb', line 5285

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

#_reduce_416(val, _values, result) ⇒ Object



5292
5293
5294
5295
5296
# File 'lib/ruby19_parser.rb', line 5292

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

#_reduce_417(val, _values, result) ⇒ Object



5298
5299
5300
5301
5302
5303
5304
5305
5306
5307
# File 'lib/ruby19_parser.rb', line 5298

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

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

                      self.env.unextend
                    
    result
end

#_reduce_418(val, _values, result) ⇒ Object



5309
5310
5311
5312
5313
5314
# File 'lib/ruby19_parser.rb', line 5309

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

#_reduce_419(val, _values, result) ⇒ Object



5316
5317
5318
5319
5320
# File 'lib/ruby19_parser.rb', line 5316

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

#_reduce_42(val, _values, result) ⇒ Object

reduce 41 omitted



3375
3376
3377
3378
3379
# File 'lib/ruby19_parser.rb', line 3375

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

#_reduce_420(val, _values, result) ⇒ Object



5322
5323
5324
5325
5326
5327
5328
5329
5330
5331
# File 'lib/ruby19_parser.rb', line 5322

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

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

                      self.env.unextend
                    
    result
end

#_reduce_421(val, _values, result) ⇒ Object



5333
5334
5335
5336
5337
# File 'lib/ruby19_parser.rb', line 5333

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

#_reduce_422(val, _values, result) ⇒ Object



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

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

#_reduce_425(val, _values, result) ⇒ Object

reduce 424 omitted



5351
5352
5353
5354
5355
5356
5357
5358
5359
5360
5361
# File 'lib/ruby19_parser.rb', line 5351

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

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

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

#_reduce_426(val, _values, result) ⇒ Object



5363
5364
5365
5366
5367
# File 'lib/ruby19_parser.rb', line 5363

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

#_reduce_427(val, _values, result) ⇒ Object



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

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

#_reduce_43(val, _values, result) ⇒ Object



3381
3382
3383
3384
3385
# File 'lib/ruby19_parser.rb', line 3381

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

#_reduce_430(val, _values, result) ⇒ Object

reduce 429 omitted



5379
5380
5381
5382
5383
# File 'lib/ruby19_parser.rb', line 5379

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

#_reduce_432(val, _values, result) ⇒ Object

reduce 431 omitted



5387
5388
5389
5390
5391
5392
5393
# File 'lib/ruby19_parser.rb', line 5387

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

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

#_reduce_434(val, _values, result) ⇒ Object

reduce 433 omitted



5397
5398
5399
5400
# File 'lib/ruby19_parser.rb', line 5397

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

#_reduce_435(val, _values, result) ⇒ Object



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

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

#_reduce_437(val, _values, result) ⇒ Object

reduce 436 omitted



5409
5410
5411
5412
5413
5414
# File 'lib/ruby19_parser.rb', line 5409

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

#_reduce_439(val, _values, result) ⇒ Object

reduce 438 omitted



5418
5419
5420
5421
5422
# File 'lib/ruby19_parser.rb', line 5418

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

#_reduce_440(val, _values, result) ⇒ Object



5424
5425
5426
5427
5428
# File 'lib/ruby19_parser.rb', line 5424

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

#_reduce_441(val, _values, result) ⇒ Object



5430
5431
5432
5433
5434
# File 'lib/ruby19_parser.rb', line 5430

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

#_reduce_442(val, _values, result) ⇒ Object



5436
5437
5438
5439
5440
# File 'lib/ruby19_parser.rb', line 5436

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

#_reduce_443(val, _values, result) ⇒ Object



5442
5443
5444
5445
5446
# File 'lib/ruby19_parser.rb', line 5442

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

#_reduce_444(val, _values, result) ⇒ Object



5448
5449
5450
5451
5452
# File 'lib/ruby19_parser.rb', line 5448

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

#_reduce_445(val, _values, result) ⇒ Object



5454
5455
5456
5457
5458
# File 'lib/ruby19_parser.rb', line 5454

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

#_reduce_446(val, _values, result) ⇒ Object



5460
5461
5462
5463
5464
# File 'lib/ruby19_parser.rb', line 5460

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

#_reduce_447(val, _values, result) ⇒ Object



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

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

#_reduce_449(val, _values, result) ⇒ Object

reduce 448 omitted



5475
5476
5477
5478
5479
# File 'lib/ruby19_parser.rb', line 5475

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

#_reduce_45(val, _values, result) ⇒ Object

reduce 44 omitted



3389
3390
3391
3392
3393
# File 'lib/ruby19_parser.rb', line 3389

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

#_reduce_450(val, _values, result) ⇒ Object



5481
5482
5483
5484
5485
# File 'lib/ruby19_parser.rb', line 5481

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

#_reduce_451(val, _values, result) ⇒ Object



5487
5488
5489
5490
5491
# File 'lib/ruby19_parser.rb', line 5487

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

#_reduce_452(val, _values, result) ⇒ Object



5493
5494
5495
5496
5497
# File 'lib/ruby19_parser.rb', line 5493

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

#_reduce_453(val, _values, result) ⇒ Object



5499
5500
5501
5502
5503
# File 'lib/ruby19_parser.rb', line 5499

def _reduce_453(val, _values, result)
                      result = val[0] << s(:str, val[1])
                    
    result
end

#_reduce_454(val, _values, result) ⇒ Object



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

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

#_reduce_455(val, _values, result) ⇒ Object



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

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

#_reduce_456(val, _values, result) ⇒ Object



5517
5518
5519
5520
5521
# File 'lib/ruby19_parser.rb', line 5517

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

#_reduce_457(val, _values, result) ⇒ Object



5523
5524
5525
5526
5527
# File 'lib/ruby19_parser.rb', line 5523

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

#_reduce_458(val, _values, result) ⇒ Object



5529
5530
5531
5532
5533
# File 'lib/ruby19_parser.rb', line 5529

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

#_reduce_459(val, _values, result) ⇒ Object



5535
5536
5537
5538
5539
# File 'lib/ruby19_parser.rb', line 5535

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

#_reduce_46(val, _values, result) ⇒ Object



3395
3396
3397
3398
3399
# File 'lib/ruby19_parser.rb', line 3395

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

#_reduce_460(val, _values, result) ⇒ Object



5541
5542
5543
5544
5545
# File 'lib/ruby19_parser.rb', line 5541

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

#_reduce_461(val, _values, result) ⇒ Object



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

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

                      lexer.lex_strterm = nil
                      lexer.lex_state = :expr_beg
                    
    result
end

#_reduce_462(val, _values, result) ⇒ Object



5556
5557
5558
5559
5560
5561
# File 'lib/ruby19_parser.rb', line 5556

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

#_reduce_463(val, _values, result) ⇒ Object



5563
5564
5565
5566
5567
5568
5569
5570
5571
5572
5573
5574
5575
5576
5577
# File 'lib/ruby19_parser.rb', line 5563

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

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

                      lexer.lex_state   = :expr_beg
                    
    result
end

#_reduce_464(val, _values, result) ⇒ Object



5579
5580
5581
5582
5583
5584
5585
5586
5587
5588
5589
5590
5591
5592
5593
5594
5595
5596
5597
5598
5599
5600
5601
5602
5603
5604
5605
5606
# File 'lib/ruby19_parser.rb', line 5579

def _reduce_464(val, _values, result)
                      _, memo, stmt, _ = val

                      lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg = memo

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

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

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

#_reduce_465(val, _values, result) ⇒ Object



5608
5609
5610
5611
# File 'lib/ruby19_parser.rb', line 5608

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

#_reduce_466(val, _values, result) ⇒ Object



5613
5614
5615
5616
# File 'lib/ruby19_parser.rb', line 5613

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

#_reduce_467(val, _values, result) ⇒ Object



5618
5619
5620
5621
# File 'lib/ruby19_parser.rb', line 5618

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

#_reduce_469(val, _values, result) ⇒ Object

reduce 468 omitted



5625
5626
5627
5628
5629
5630
# File 'lib/ruby19_parser.rb', line 5625

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

#_reduce_47(val, _values, result) ⇒ Object



3401
3402
3403
3404
3405
# File 'lib/ruby19_parser.rb', line 3401

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

#_reduce_470(val, _values, result) ⇒ Object



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

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

#_reduce_475(val, _values, result) ⇒ Object

reduce 474 omitted



5646
5647
5648
5649
5650
5651
5652
5653
5654
5655
5656
5657
5658
5659
5660
5661
5662
# File 'lib/ruby19_parser.rb', line 5646

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

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

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

#_reduce_478(val, _values, result) ⇒ Object

reduce 477 omitted



5668
5669
5670
5671
5672
# File 'lib/ruby19_parser.rb', line 5668

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

#_reduce_479(val, _values, result) ⇒ Object



5674
5675
5676
5677
5678
# File 'lib/ruby19_parser.rb', line 5674

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

#_reduce_48(val, _values, result) ⇒ Object



3407
3408
3409
3410
3411
# File 'lib/ruby19_parser.rb', line 3407

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

#_reduce_485(val, _values, result) ⇒ Object

reduce 484 omitted



5690
5691
5692
5693
# File 'lib/ruby19_parser.rb', line 5690

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

#_reduce_486(val, _values, result) ⇒ Object



5695
5696
5697
5698
# File 'lib/ruby19_parser.rb', line 5695

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

#_reduce_487(val, _values, result) ⇒ Object



5700
5701
5702
5703
# File 'lib/ruby19_parser.rb', line 5700

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

#_reduce_488(val, _values, result) ⇒ Object



5705
5706
5707
5708
# File 'lib/ruby19_parser.rb', line 5705

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

#_reduce_489(val, _values, result) ⇒ Object



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

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

#_reduce_490(val, _values, result) ⇒ Object



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

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

#_reduce_491(val, _values, result) ⇒ Object



5720
5721
5722
5723
5724
5725
5726
5727
5728
5729
# File 'lib/ruby19_parser.rb', line 5720

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

#_reduce_492(val, _values, result) ⇒ Object



5731
5732
5733
5734
5735
5736
# File 'lib/ruby19_parser.rb', line 5731

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

#_reduce_493(val, _values, result) ⇒ Object



5738
5739
5740
5741
5742
5743
# File 'lib/ruby19_parser.rb', line 5738

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

#_reduce_494(val, _values, result) ⇒ Object



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

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

#_reduce_495(val, _values, result) ⇒ Object



5751
5752
5753
5754
5755
# File 'lib/ruby19_parser.rb', line 5751

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

#_reduce_496(val, _values, result) ⇒ Object



5757
5758
5759
5760
# File 'lib/ruby19_parser.rb', line 5757

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

#_reduce_497(val, _values, result) ⇒ Object



5762
5763
5764
5765
# File 'lib/ruby19_parser.rb', line 5762

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

#_reduce_498(val, _values, result) ⇒ Object



5767
5768
5769
5770
5771
# File 'lib/ruby19_parser.rb', line 5767

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

#_reduce_499(val, _values, result) ⇒ Object



5773
5774
5775
5776
5777
# File 'lib/ruby19_parser.rb', line 5773

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

#_reduce_50(val, _values, result) ⇒ Object

reduce 49 omitted



3415
3416
3417
3418
3419
# File 'lib/ruby19_parser.rb', line 3415

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

#_reduce_500(val, _values, result) ⇒ Object



5779
5780
5781
5782
5783
# File 'lib/ruby19_parser.rb', line 5779

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

#_reduce_501(val, _values, result) ⇒ Object



5785
5786
5787
5788
5789
5790
# File 'lib/ruby19_parser.rb', line 5785

def _reduce_501(val, _values, result)
                      yyerrok
                      result = nil
                    
    result
end

#_reduce_502(val, _values, result) ⇒ Object



5792
5793
5794
5795
5796
5797
5798
# File 'lib/ruby19_parser.rb', line 5792

def _reduce_502(val, _values, result)
                      result = val[1]
                      lexer.lex_state = :expr_beg
                      self.lexer.command_start = true
                    
    result
end

#_reduce_503(val, _values, result) ⇒ Object



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

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

#_reduce_504(val, _values, result) ⇒ Object



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

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

#_reduce_505(val, _values, result) ⇒ Object



5812
5813
5814
5815
5816
# File 'lib/ruby19_parser.rb', line 5812

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

#_reduce_506(val, _values, result) ⇒ Object



5818
5819
5820
5821
5822
# File 'lib/ruby19_parser.rb', line 5818

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

#_reduce_507(val, _values, result) ⇒ Object



5824
5825
5826
5827
5828
# File 'lib/ruby19_parser.rb', line 5824

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

#_reduce_508(val, _values, result) ⇒ Object



5830
5831
5832
5833
5834
# File 'lib/ruby19_parser.rb', line 5830

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

#_reduce_509(val, _values, result) ⇒ Object



5836
5837
5838
5839
5840
# File 'lib/ruby19_parser.rb', line 5836

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

#_reduce_510(val, _values, result) ⇒ Object



5842
5843
5844
5845
5846
# File 'lib/ruby19_parser.rb', line 5842

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

#_reduce_511(val, _values, result) ⇒ Object



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

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

#_reduce_512(val, _values, result) ⇒ Object



5854
5855
5856
5857
5858
# File 'lib/ruby19_parser.rb', line 5854

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

#_reduce_513(val, _values, result) ⇒ Object



5860
5861
5862
5863
5864
# File 'lib/ruby19_parser.rb', line 5860

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

#_reduce_514(val, _values, result) ⇒ Object



5866
5867
5868
5869
5870
# File 'lib/ruby19_parser.rb', line 5866

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

#_reduce_515(val, _values, result) ⇒ Object



5872
5873
5874
5875
5876
# File 'lib/ruby19_parser.rb', line 5872

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

#_reduce_516(val, _values, result) ⇒ Object



5878
5879
5880
5881
5882
# File 'lib/ruby19_parser.rb', line 5878

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

#_reduce_517(val, _values, result) ⇒ Object



5884
5885
5886
5887
5888
# File 'lib/ruby19_parser.rb', line 5884

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

#_reduce_518(val, _values, result) ⇒ Object



5890
5891
5892
5893
5894
# File 'lib/ruby19_parser.rb', line 5890

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

#_reduce_519(val, _values, result) ⇒ Object



5896
5897
5898
5899
5900
# File 'lib/ruby19_parser.rb', line 5896

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

#_reduce_520(val, _values, result) ⇒ Object



5902
5903
5904
5905
5906
# File 'lib/ruby19_parser.rb', line 5902

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

#_reduce_521(val, _values, result) ⇒ Object



5908
5909
5910
5911
5912
# File 'lib/ruby19_parser.rb', line 5908

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

#_reduce_522(val, _values, result) ⇒ Object



5914
5915
5916
5917
5918
# File 'lib/ruby19_parser.rb', line 5914

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

#_reduce_524(val, _values, result) ⇒ Object

reduce 523 omitted



5922
5923
5924
5925
5926
5927
5928
5929
# File 'lib/ruby19_parser.rb', line 5922

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

                      result = identifier
                    
    result
end

#_reduce_526(val, _values, result) ⇒ Object

reduce 525 omitted



5933
5934
5935
5936
5937
# File 'lib/ruby19_parser.rb', line 5933

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

#_reduce_527(val, _values, result) ⇒ Object



5939
5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
5950
5951
# File 'lib/ruby19_parser.rb', line 5939

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

#_reduce_528(val, _values, result) ⇒ Object



5953
5954
5955
5956
5957
5958
5959
5960
5961
5962
5963
5964
5965
# File 'lib/ruby19_parser.rb', line 5953

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



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

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

#_reduce_530(val, _values, result) ⇒ Object



5974
5975
5976
5977
5978
# File 'lib/ruby19_parser.rb', line 5974

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

#_reduce_531(val, _values, result) ⇒ Object



5980
5981
5982
5983
5984
# File 'lib/ruby19_parser.rb', line 5980

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

#_reduce_532(val, _values, result) ⇒ Object



5986
5987
5988
5989
5990
5991
# File 'lib/ruby19_parser.rb', line 5986

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

#_reduce_533(val, _values, result) ⇒ Object



5993
5994
5995
5996
5997
# File 'lib/ruby19_parser.rb', line 5993

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

#_reduce_534(val, _values, result) ⇒ Object



5999
6000
6001
6002
6003
# File 'lib/ruby19_parser.rb', line 5999

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

#_reduce_537(val, _values, result) ⇒ Object

reduce 536 omitted



6009
6010
6011
6012
6013
6014
6015
6016
# File 'lib/ruby19_parser.rb', line 6009

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

#_reduce_538(val, _values, result) ⇒ Object



6018
6019
6020
6021
6022
6023
6024
# File 'lib/ruby19_parser.rb', line 6018

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

#_reduce_54(val, _values, result) ⇒ Object

reduce 53 omitted



3427
3428
3429
3430
3431
# File 'lib/ruby19_parser.rb', line 3427

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

#_reduce_541(val, _values, result) ⇒ Object

reduce 540 omitted



6030
6031
6032
6033
6034
6035
6036
6037
# File 'lib/ruby19_parser.rb', line 6030

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

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

#_reduce_542(val, _values, result) ⇒ Object



6039
6040
6041
6042
6043
# File 'lib/ruby19_parser.rb', line 6039

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

#_reduce_543(val, _values, result) ⇒ Object



6045
6046
6047
6048
6049
# File 'lib/ruby19_parser.rb', line 6045

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

#_reduce_545(val, _values, result) ⇒ Object

reduce 544 omitted



6053
6054
6055
6056
6057
# File 'lib/ruby19_parser.rb', line 6053

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

#_reduce_546(val, _values, result) ⇒ Object



6059
6060
6061
6062
6063
6064
6065
# File 'lib/ruby19_parser.rb', line 6059

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

#_reduce_547(val, _values, result) ⇒ Object



6067
6068
6069
6070
6071
# File 'lib/ruby19_parser.rb', line 6067

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

#_reduce_548(val, _values, result) ⇒ Object



6073
6074
6075
6076
6077
# File 'lib/ruby19_parser.rb', line 6073

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

#_reduce_55(val, _values, result) ⇒ Object



3433
3434
3435
3436
3437
# File 'lib/ruby19_parser.rb', line 3433

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

#_reduce_550(val, _values, result) ⇒ Object

reduce 549 omitted



6081
6082
6083
6084
6085
6086
6087
6088
# File 'lib/ruby19_parser.rb', line 6081

def _reduce_550(val, _values, result)
                      list = val[0].dup
                      more = val[2][1..-1]
                      list.push(*more) unless more.empty?
                      result = list
                    
    result
end

#_reduce_551(val, _values, result) ⇒ Object



6090
6091
6092
6093
6094
# File 'lib/ruby19_parser.rb', line 6090

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

#_reduce_552(val, _values, result) ⇒ Object



6096
6097
6098
6099
6100
6101
# File 'lib/ruby19_parser.rb', line 6096

def _reduce_552(val, _values, result)
                      label, _ = val[0] # TODO: fix lineno?
                      result = s(:array, s(:lit, label.to_sym), val[1])
                    
    result
end

#_reduce_56(val, _values, result) ⇒ Object



3439
3440
3441
3442
3443
3444
# File 'lib/ruby19_parser.rb', line 3439

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

#_reduce_57(val, _values, result) ⇒ Object



3446
3447
3448
3449
3450
# File 'lib/ruby19_parser.rb', line 3446

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

#_reduce_574(val, _values, result) ⇒ Object

reduce 573 omitted



6145
6146
6147
6148
# File 'lib/ruby19_parser.rb', line 6145

def _reduce_574(val, _values, result)
 yyerrok 
    result
end

#_reduce_577(val, _values, result) ⇒ Object

reduce 576 omitted



6154
6155
6156
6157
# File 'lib/ruby19_parser.rb', line 6154

def _reduce_577(val, _values, result)
 yyerrok 
    result
end

#_reduce_578(val, _values, result) ⇒ Object



6159
6160
6161
6162
# File 'lib/ruby19_parser.rb', line 6159

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

#_reduce_58(val, _values, result) ⇒ Object



3452
3453
3454
3455
3456
3457
3458
3459
# File 'lib/ruby19_parser.rb', line 3452

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

                      self.env.unextend
                    
    result
end

#_reduce_59(val, _values, result) ⇒ Object



3461
3462
3463
3464
3465
# File 'lib/ruby19_parser.rb', line 3461

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

#_reduce_6(val, _values, result) ⇒ Object

reduce 5 omitted



3176
3177
3178
3179
3180
# File 'lib/ruby19_parser.rb', line 3176

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

#_reduce_60(val, _values, result) ⇒ Object



3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
# File 'lib/ruby19_parser.rb', line 3467

def _reduce_60(val, _values, result)
                      result = new_call nil, val[0].to_sym, val[1]
                      if val[2] then
                        block_dup_check result, val[2]

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

#_reduce_61(val, _values, result) ⇒ Object



3479
3480
3481
3482
3483
# File 'lib/ruby19_parser.rb', line 3479

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

#_reduce_62(val, _values, result) ⇒ Object



3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
# File 'lib/ruby19_parser.rb', line 3485

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



3497
3498
3499
3500
3501
# File 'lib/ruby19_parser.rb', line 3497

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

#_reduce_64(val, _values, result) ⇒ Object



3503
3504
3505
3506
3507
3508
3509
3510
3511
3512
3513
# File 'lib/ruby19_parser.rb', line 3503

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



3515
3516
3517
3518
3519
# File 'lib/ruby19_parser.rb', line 3515

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

#_reduce_66(val, _values, result) ⇒ Object



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

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

#_reduce_67(val, _values, result) ⇒ Object



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

def _reduce_67(val, _values, result)
                      line = val[0].last
                      result = s(:return, ret_args(val[1])).line(line)
                    
    result
end

#_reduce_68(val, _values, result) ⇒ Object



3534
3535
3536
3537
3538
3539
# File 'lib/ruby19_parser.rb', line 3534

def _reduce_68(val, _values, result)
                      line = val[0].last
                      result = s(:break, ret_args(val[1])).line(line)
                    
    result
end

#_reduce_69(val, _values, result) ⇒ Object



3541
3542
3543
3544
3545
3546
# File 'lib/ruby19_parser.rb', line 3541

def _reduce_69(val, _values, result)
                      line = val[0].last
                      result = s(:next, ret_args(val[1])).line(line)
                    
    result
end

#_reduce_71(val, _values, result) ⇒ Object

reduce 70 omitted



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

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

#_reduce_73(val, _values, result) ⇒ Object

reduce 72 omitted



3558
3559
3560
3561
3562
# File 'lib/ruby19_parser.rb', line 3558

def _reduce_73(val, _values, result)
                      result = s(:masgn, s(:array, val[1]))
                    
    result
end

#_reduce_74(val, _values, result) ⇒ Object



3564
3565
3566
3567
3568
# File 'lib/ruby19_parser.rb', line 3564

def _reduce_74(val, _values, result)
                      result = s(:masgn, val[0])
                    
    result
end

#_reduce_75(val, _values, result) ⇒ Object



3570
3571
3572
3573
3574
# File 'lib/ruby19_parser.rb', line 3570

def _reduce_75(val, _values, result)
                      result = s(:masgn, val[0] << val[1].compact)
                    
    result
end

#_reduce_76(val, _values, result) ⇒ Object



3576
3577
3578
3579
3580
# File 'lib/ruby19_parser.rb', line 3576

def _reduce_76(val, _values, result)
                      result = s(:masgn, val[0] << s(:splat, val[2]))
                    
    result
end

#_reduce_77(val, _values, result) ⇒ Object



3582
3583
3584
3585
3586
3587
3588
# File 'lib/ruby19_parser.rb', line 3582

def _reduce_77(val, _values, result)
                      ary = list_append val[0], s(:splat, val[2])
                      ary.concat val[4][1..-1]
                      result = s(:masgn, ary)
                    
    result
end

#_reduce_78(val, _values, result) ⇒ Object



3590
3591
3592
3593
3594
# File 'lib/ruby19_parser.rb', line 3590

def _reduce_78(val, _values, result)
                      result = s(:masgn, val[0] << s(:splat))
                    
    result
end

#_reduce_79(val, _values, result) ⇒ Object



3596
3597
3598
3599
3600
3601
3602
# File 'lib/ruby19_parser.rb', line 3596

def _reduce_79(val, _values, result)
                      ary = list_append val[0], s(:splat)
                      ary.concat val[3][1..-1]
                      result = s(:masgn, ary)
                    
    result
end

#_reduce_80(val, _values, result) ⇒ Object



3604
3605
3606
3607
3608
# File 'lib/ruby19_parser.rb', line 3604

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

#_reduce_81(val, _values, result) ⇒ Object



3610
3611
3612
3613
3614
3615
3616
# File 'lib/ruby19_parser.rb', line 3610

def _reduce_81(val, _values, result)
                      ary = s(:array, s(:splat, val[1]))
                      ary.concat val[3][1..-1]
                      result = s(:masgn, ary)
                    
    result
end

#_reduce_82(val, _values, result) ⇒ Object



3618
3619
3620
3621
3622
# File 'lib/ruby19_parser.rb', line 3618

def _reduce_82(val, _values, result)
                      result = s(:masgn, s(:array, s(:splat)))
                    
    result
end

#_reduce_83(val, _values, result) ⇒ Object



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

def _reduce_83(val, _values, result)
                      ary = s(:array, s(:splat))
                      ary.concat val[2][1..-1]
                      result = s(:masgn, ary)
                    
    result
end

#_reduce_85(val, _values, result) ⇒ Object

reduce 84 omitted



3634
3635
3636
3637
3638
# File 'lib/ruby19_parser.rb', line 3634

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

#_reduce_86(val, _values, result) ⇒ Object



3640
3641
3642
3643
3644
# File 'lib/ruby19_parser.rb', line 3640

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

#_reduce_87(val, _values, result) ⇒ Object



3646
3647
3648
3649
3650
# File 'lib/ruby19_parser.rb', line 3646

def _reduce_87(val, _values, result)
                      result = val[0] << val[1].compact
                    
    result
end

#_reduce_88(val, _values, result) ⇒ Object



3652
3653
3654
3655
3656
# File 'lib/ruby19_parser.rb', line 3652

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

#_reduce_89(val, _values, result) ⇒ Object



3658
3659
3660
3661
3662
# File 'lib/ruby19_parser.rb', line 3658

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

#_reduce_9(val, _values, result) ⇒ Object

reduce 8 omitted



3186
3187
3188
3189
3190
3191
3192
3193
# File 'lib/ruby19_parser.rb', line 3186

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

#_reduce_90(val, _values, result) ⇒ Object



3664
3665
3666
3667
3668
# File 'lib/ruby19_parser.rb', line 3664

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

#_reduce_91(val, _values, result) ⇒ Object



3670
3671
3672
3673
3674
# File 'lib/ruby19_parser.rb', line 3670

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

#_reduce_92(val, _values, result) ⇒ Object



3676
3677
3678
3679
3680
# File 'lib/ruby19_parser.rb', line 3676

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

#_reduce_93(val, _values, result) ⇒ Object



3682
3683
3684
3685
3686
# File 'lib/ruby19_parser.rb', line 3682

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

#_reduce_94(val, _values, result) ⇒ Object



3688
3689
3690
3691
3692
# File 'lib/ruby19_parser.rb', line 3688

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

#_reduce_95(val, _values, result) ⇒ Object



3694
3695
3696
3697
3698
# File 'lib/ruby19_parser.rb', line 3694

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

#_reduce_96(val, _values, result) ⇒ Object



3700
3701
3702
3703
3704
3705
3706
3707
3708
# File 'lib/ruby19_parser.rb', line 3700

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

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

#_reduce_97(val, _values, result) ⇒ Object



3710
3711
3712
3713
3714
3715
3716
3717
3718
# File 'lib/ruby19_parser.rb', line 3710

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

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

#_reduce_98(val, _values, result) ⇒ Object



3720
3721
3722
3723
3724
# File 'lib/ruby19_parser.rb', line 3720

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

#_reduce_99(val, _values, result) ⇒ Object



3726
3727
3728
3729
3730
# File 'lib/ruby19_parser.rb', line 3726

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

#_reduce_none(val, _values, result) ⇒ Object



6164
6165
6166
# File 'lib/ruby19_parser.rb', line 6164

def _reduce_none(val, _values, result)
  val[0]
end