Class: Ruby19Parser

Inherits:
Racc::Parser
  • Object
show all
Includes:
RubyParserStuff
Defined in:
lib/ruby_parser/ruby19_parser.rb,
lib/ruby_parser/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__",
"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",
"tRBRACK",
"tLBRACE",
"tLBRACE_ARG",
"tSTAR",
"tSTAR2",
"tAMPER",
"tAMPER2",
"tTILDE",
"tPERCENT",
"tDIVIDE",
"tPLUS",
"tMINUS",
"tLT",
"tGT",
"tPIPE",
"tBANG",
"tCARET",
"tLCURLY",
"tRCURLY",
"tBACK_REF2",
"tSYMBEG",
"tSTRING_BEG",
"tXSTRING_BEG",
"tREGEXP_BEG",
"tWORDS_BEG",
"tAWORDS_BEG",
"tSTRING_DBEG",
"tSTRING_DVAR",
"tSTRING_END",
"tSTRING",
"tSYMBOL",
"tNL",
"tEH",
"tCOLON",
"tCOMMA",
"tSPACE",
"tSEMI",
"tLAST_TOKEN",
"tLAMBDA",
"tLAMBEG",
"tEQL",
"tLOWEST",
"\"[\"",
"$start",
"program",
"compstmt",
"bodystmt",
"@1",
"opt_rescue",
"opt_else",
"opt_ensure",
"stmts",
"opt_terms",
"none",
"stmt",
"terms",
"fitem",
"undef_list",
"expr_value",
"lhs",
"command_call",
"mlhs",
"var_lhs",
"primary_value",
"aref_args",
"backref",
"mrhs",
"arg_value",
"expr",
"@2",
"@3",
"arg",
"command",
"block_command",
"call_args",
"block_call",
"operation2",
"command_args",
"cmd_brace_block",
"opt_block_var",
"@4",
"@5",
"operation",
"mlhs_basic",
"mlhs_entry",
"mlhs_head",
"mlhs_item",
"mlhs_node",
"variable",
"cname",
"cpath",
"fname",
"op",
"reswords",
"fsym",
"symbol",
"dsym",
"@6",
"opt_nl",
"primary",
"args",
"trailer",
"assocs",
"paren_args",
"opt_paren_args",
"opt_block_arg",
"block_arg",
"call_args2",
"open_args",
"@7",
"@8",
"@9",
"none_block_pass",
"literal",
"strings",
"xstring",
"regexp",
"words",
"awords",
"var_ref",
"assoc_list",
"brace_block",
"method_call",
"lambda",
"then",
"if_tail",
"do",
"case_body",
"block_var",
"superclass",
"term",
"f_arglist",
"singleton",
"dot_or_colon",
"@10",
"@11",
"@12",
"@13",
"@14",
"@15",
"@16",
"@17",
"@18",
"@19",
"@20",
"@21",
"@22",
"@23",
"@24",
"@25",
"@26",
"@27",
"do_block",
"@28",
"@29",
"operation3",
"@30",
"lambda_body",
"f_larglist",
"f_args",
"@31",
"@32",
"@33",
"@34",
"when_args",
"cases",
"@35",
"exc_list",
"exc_var",
"numeric",
"string",
"string1",
"string_contents",
"xstring_contents",
"word_list",
"word",
"string_content",
"qword_list",
"string_dvar",
"@36",
"@37",
"sym",
"@38",
"f_arg",
"f_optarg",
"f_rest_arg",
"opt_f_block_arg",
"f_block_arg",
"f_norm_arg",
"f_opt",
"restarg_mark",
"blkarg_mark",
"@39",
"assoc" ]
Racc_debug_parser = 
false

Constants included from RubyParserStuff

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_add, #arg_blk_pass, #arg_concat, #args, #args19, #aryset, #assignable, #block_append, #cond, #do_parse, #get_match_node, #gettable, #initialize, #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_module, #new_op_asgn, #new_regexp, #new_sclass, #new_super, #new_undef, #new_until, #new_until_or_while, #new_while, #new_xstring, #new_yield, #next_token, #node_assign, #process, #remove_begin, #reset, #ret_args, #s, #value_expr, #void_stmts, #warning, #yyerror

Instance Method Details

#_reduce_1(val, _values, result) ⇒ Object

reduce 0 omitted



3042
3043
3044
3045
3046
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3042

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

#_reduce_10(val, _values, result) ⇒ Object 



3089
3090
3091
3092
3093
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3089

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

#_reduce_100(val, _values, result) ⇒ Object 



3620
3621
3622
3623
3624
3625
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3620

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

#_reduce_103(val, _values, result) ⇒ Object

reduce 102 omitted



3631
3632
3633
3634
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3631

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

#_reduce_105(val, _values, result) ⇒ Object

reduce 104 omitted



3638
3639
3640
3641
3642
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3638

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

#_reduce_106(val, _values, result) ⇒ Object 



3644
3645
3646
3647
3648
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3644

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

#_reduce_107(val, _values, result) ⇒ Object 



3650
3651
3652
3653
3654
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3650

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

#_reduce_11(val, _values, result) ⇒ Object 



3095
3096
3097
3098
3099
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3095

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

#_reduce_12(val, _values, result) ⇒ Object 



3101
3102
3103
3104
3105
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3101

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

#_reduce_13(val, _values, result) ⇒ Object 



3107
3108
3109
3110
3111
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3107

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

#_reduce_14(val, _values, result) ⇒ Object 



3113
3114
3115
3116
3117
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3113

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

#_reduce_15(val, _values, result) ⇒ Object 



3119
3120
3121
3122
3123
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3119

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

#_reduce_16(val, _values, result) ⇒ Object 



3125
3126
3127
3128
3129
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3125

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

#_reduce_17(val, _values, result) ⇒ Object 



3131
3132
3133
3134
3135
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3131

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

#_reduce_175(val, _values, result) ⇒ Object

reduce 174 omitted



3790
3791
3792
3793
3794
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3790

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

#_reduce_176(val, _values, result) ⇒ Object 



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

def _reduce_176(val, _values, result)
                      result = self.node_assign val[0], s(:rescue, val[2], s(:resbody, s(:array), val[4]))
                      # result.line = val[0].line
                    
    result
end

#_reduce_177(val, _values, result) ⇒ Object 



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

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

#_reduce_178(val, _values, result) ⇒ Object 



3809
3810
3811
3812
3813
3814
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3809

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

#_reduce_179(val, _values, result) ⇒ Object 



3816
3817
3818
3819
3820
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3816

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

#_reduce_18(val, _values, result) ⇒ Object 



3137
3138
3139
3140
3141
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3137

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

#_reduce_180(val, _values, result) ⇒ Object 



3822
3823
3824
3825
3826
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3822

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

#_reduce_181(val, _values, result) ⇒ Object 



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

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

#_reduce_182(val, _values, result) ⇒ Object 



3834
3835
3836
3837
3838
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3834

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

#_reduce_183(val, _values, result) ⇒ Object 



3840
3841
3842
3843
3844
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3840

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

#_reduce_184(val, _values, result) ⇒ Object 



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

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

#_reduce_185(val, _values, result) ⇒ Object 



3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3852

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



3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3863

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



3874
3875
3876
3877
3878
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3874

def _reduce_187(val, _values, result)
                      result = new_call val[0], :+, s(:arglist, val[2])
                    
    result
end

#_reduce_188(val, _values, result) ⇒ Object 



3880
3881
3882
3883
3884
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3880

def _reduce_188(val, _values, result)
                      result = new_call val[0], :-, s(:arglist, val[2])
                    
    result
end

#_reduce_189(val, _values, result) ⇒ Object 



3886
3887
3888
3889
3890
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3886

def _reduce_189(val, _values, result)
                      result = new_call val[0], :*, s(:arglist, val[2])
                    
    result
end

#_reduce_19(val, _values, result) ⇒ Object 



3143
3144
3145
3146
3147
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3143

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

#_reduce_190(val, _values, result) ⇒ Object 



3892
3893
3894
3895
3896
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3892

def _reduce_190(val, _values, result)
                      result = new_call val[0], :"/", s(:arglist, val[2])
                    
    result
end

#_reduce_191(val, _values, result) ⇒ Object 



3898
3899
3900
3901
3902
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3898

def _reduce_191(val, _values, result)
                      result = new_call val[0], :%, s(:arglist, val[2])
                    
    result
end

#_reduce_192(val, _values, result) ⇒ Object 



3904
3905
3906
3907
3908
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3904

def _reduce_192(val, _values, result)
                      result = new_call val[0], :**, s(:arglist, val[2])
                    
    result
end

#_reduce_193(val, _values, result) ⇒ Object 



3910
3911
3912
3913
3914
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3910

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

#_reduce_194(val, _values, result) ⇒ Object 



3916
3917
3918
3919
3920
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3916

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

#_reduce_195(val, _values, result) ⇒ Object 



3922
3923
3924
3925
3926
3927
3928
3929
3930
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3922

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

#_reduce_196(val, _values, result) ⇒ Object 



3932
3933
3934
3935
3936
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3932

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

#_reduce_197(val, _values, result) ⇒ Object 



3938
3939
3940
3941
3942
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3938

def _reduce_197(val, _values, result)
                      result = new_call val[0], :"|", s(:arglist, val[2])
                    
    result
end

#_reduce_198(val, _values, result) ⇒ Object 



3944
3945
3946
3947
3948
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3944

def _reduce_198(val, _values, result)
                      result = new_call val[0], :"^", s(:arglist, val[2])
                    
    result
end

#_reduce_199(val, _values, result) ⇒ Object 



3950
3951
3952
3953
3954
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3950

def _reduce_199(val, _values, result)
                      result = new_call val[0], :"&", s(:arglist, val[2])
                    
    result
end

#_reduce_2(val, _values, result) ⇒ Object 



3048
3049
3050
3051
3052
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3048

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

#_reduce_20(val, _values, result) ⇒ Object 



3149
3150
3151
3152
3153
3154
3155
3156
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3149

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

#_reduce_200(val, _values, result) ⇒ Object 



3956
3957
3958
3959
3960
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3956

def _reduce_200(val, _values, result)
                      result = new_call val[0], :"<=>", s(:arglist, val[2])
                    
    result
end

#_reduce_201(val, _values, result) ⇒ Object 



3962
3963
3964
3965
3966
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3962

def _reduce_201(val, _values, result)
                      result = new_call val[0], :">", s(:arglist, val[2])
                    
    result
end

#_reduce_202(val, _values, result) ⇒ Object 



3968
3969
3970
3971
3972
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3968

def _reduce_202(val, _values, result)
                      result = new_call val[0], :">=", s(:arglist, val[2])
                    
    result
end

#_reduce_203(val, _values, result) ⇒ Object 



3974
3975
3976
3977
3978
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3974

def _reduce_203(val, _values, result)
                      result = new_call val[0], :"<", s(:arglist, val[2])
                    
    result
end

#_reduce_204(val, _values, result) ⇒ Object 



3980
3981
3982
3983
3984
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3980

def _reduce_204(val, _values, result)
                      result = new_call val[0], :"<=", s(:arglist, val[2])
                    
    result
end

#_reduce_205(val, _values, result) ⇒ Object 



3986
3987
3988
3989
3990
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3986

def _reduce_205(val, _values, result)
                      result = new_call val[0], :"==", s(:arglist, val[2])
                    
    result
end

#_reduce_206(val, _values, result) ⇒ Object 



3992
3993
3994
3995
3996
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3992

def _reduce_206(val, _values, result)
                      result = new_call val[0], :"===", s(:arglist, val[2])
                    
    result
end

#_reduce_207(val, _values, result) ⇒ Object 



3998
3999
4000
4001
4002
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3998

def _reduce_207(val, _values, result)
                      result = new_call val[0], :"!=", s(:arglist, val[2])
                    
    result
end

#_reduce_208(val, _values, result) ⇒ Object 



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

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

#_reduce_209(val, _values, result) ⇒ Object 



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

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

#_reduce_21(val, _values, result) ⇒ Object 



3158
3159
3160
3161
3162
3163
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3158

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

#_reduce_210(val, _values, result) ⇒ Object 



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

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

#_reduce_211(val, _values, result) ⇒ Object 



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

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

#_reduce_212(val, _values, result) ⇒ Object 



4029
4030
4031
4032
4033
4034
4035
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4029

def _reduce_212(val, _values, result)
                      val[0] = value_expr val[0]
                      val[2] = value_expr val[2]
                      result = new_call val[0], :"\<\<", s(:arglist, val[2])
                    
    result
end

#_reduce_213(val, _values, result) ⇒ Object 



4037
4038
4039
4040
4041
4042
4043
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4037

def _reduce_213(val, _values, result)
                      val[0] = value_expr val[0]
                      val[2] = value_expr val[2]
                      result = new_call val[0], :">>", s(:arglist, val[2])
                    
    result
end

#_reduce_214(val, _values, result) ⇒ Object 



4045
4046
4047
4048
4049
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4045

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

#_reduce_215(val, _values, result) ⇒ Object 



4051
4052
4053
4054
4055
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4051

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

#_reduce_216(val, _values, result) ⇒ Object 



4057
4058
4059
4060
4061
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4057

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

#_reduce_217(val, _values, result) ⇒ Object 



4063
4064
4065
4066
4067
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4063

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

#_reduce_219(val, _values, result) ⇒ Object

reduce 218 omitted



4071
4072
4073
4074
4075
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4071

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

#_reduce_22(val, _values, result) ⇒ Object 



3165
3166
3167
3168
3169
3170
3171
3172
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3165

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

reduce 220 omitted



4079
4080
4081
4082
4083
4084
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4079

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

#_reduce_222(val, _values, result) ⇒ Object 



4086
4087
4088
4089
4090
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4086

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

#_reduce_223(val, _values, result) ⇒ Object 



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

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

#_reduce_224(val, _values, result) ⇒ Object 



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

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

#_reduce_225(val, _values, result) ⇒ Object 



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

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

#_reduce_226(val, _values, result) ⇒ Object 



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

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

#_reduce_227(val, _values, result) ⇒ Object 



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

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

#_reduce_228(val, _values, result) ⇒ Object 



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

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

#_reduce_229(val, _values, result) ⇒ Object 



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

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

#_reduce_23(val, _values, result) ⇒ Object 



3174
3175
3176
3177
3178
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3174

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

#_reduce_232(val, _values, result) ⇒ Object

reduce 231 omitted



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

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

#_reduce_233(val, _values, result) ⇒ Object 



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

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

#_reduce_234(val, _values, result) ⇒ Object 



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

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

#_reduce_235(val, _values, result) ⇒ Object 



4160
4161
4162
4163
4164
4165
4166
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4160

def _reduce_235(val, _values, result)
                      result = self.arg_concat val[0], val[3]
                      val[5][1..-1].each {|a| result << a }
                      result = self.arg_blk_pass result, val[6]
                    
    result
end

#_reduce_236(val, _values, result) ⇒ Object 



4168
4169
4170
4171
4172
4173
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4168

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

#_reduce_237(val, _values, result) ⇒ Object 



4175
4176
4177
4178
4179
4180
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4175

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

#_reduce_238(val, _values, result) ⇒ Object 



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

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

#_reduce_239(val, _values, result) ⇒ Object 



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

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

#_reduce_24(val, _values, result) ⇒ Object 



3180
3181
3182
3183
3184
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3180

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

#_reduce_240(val, _values, result) ⇒ Object 



4197
4198
4199
4200
4201
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4197

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

#_reduce_242(val, _values, result) ⇒ Object

reduce 241 omitted



4205
4206
4207
4208
4209
4210
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4205

def _reduce_242(val, _values, result)
                      args = self.list_prepend val[0], val[2]
                      result = self.arg_blk_pass args, val[3]
                    
    result
end

#_reduce_243(val, _values, result) ⇒ Object 



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

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

#_reduce_244(val, _values, result) ⇒ Object 



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

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

#_reduce_245(val, _values, result) ⇒ Object 



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

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

#_reduce_246(val, _values, result) ⇒ Object 



4232
4233
4234
4235
4236
4237
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4232

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

#_reduce_247(val, _values, result) ⇒ Object 



4239
4240
4241
4242
4243
4244
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4239

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

#_reduce_248(val, _values, result) ⇒ Object 



4246
4247
4248
4249
4250
4251
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4246

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

#_reduce_249(val, _values, result) ⇒ Object 



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

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

#_reduce_25(val, _values, result) ⇒ Object 



3186
3187
3188
3189
3190
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3186

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

#_reduce_250(val, _values, result) ⇒ Object 



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

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

#_reduce_251(val, _values, result) ⇒ Object 



4267
4268
4269
4270
4271
4272
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4267

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

#_reduce_252(val, _values, result) ⇒ Object 



4274
4275
4276
4277
4278
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4274

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

#_reduce_254(val, _values, result) ⇒ Object

reduce 253 omitted



4282
4283
4284
4285
4286
4287
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4282

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

#_reduce_255(val, _values, result) ⇒ Object 



4289
4290
4291
4292
4293
4294
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4289

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

#_reduce_257(val, _values, result) ⇒ Object

reduce 256 omitted



4298
4299
4300
4301
4302
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4298

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

#_reduce_258(val, _values, result) ⇒ Object 



4304
4305
4306
4307
4308
4309
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4304

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

#_reduce_259(val, _values, result) ⇒ Object 



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

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

#_reduce_26(val, _values, result) ⇒ Object 



3192
3193
3194
3195
3196
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3192

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

#_reduce_260(val, _values, result) ⇒ Object 



4317
4318
4319
4320
4321
4322
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4317

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

#_reduce_261(val, _values, result) ⇒ Object 



4324
4325
4326
4327
4328
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4324

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

#_reduce_262(val, _values, result) ⇒ Object 



4330
4331
4332
4333
4334
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4330

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

#_reduce_264(val, _values, result) ⇒ Object

reduce 263 omitted



4338
4339
4340
4341
4342
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4338

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

#_reduce_265(val, _values, result) ⇒ Object 



4344
4345
4346
4347
4348
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4344

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

#_reduce_266(val, _values, result) ⇒ Object 



4350
4351
4352
4353
4354
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4350

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

#_reduce_267(val, _values, result) ⇒ Object 



4356
4357
4358
4359
4360
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4356

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

#_reduce_268(val, _values, result) ⇒ Object 



4362
4363
4364
4365
4366
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4362

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

#_reduce_27(val, _values, result) ⇒ Object 



3198
3199
3200
3201
3202
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3198

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

#_reduce_277(val, _values, result) ⇒ Object

reduce 276 omitted



4384
4385
4386
4387
4388
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4384

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

#_reduce_278(val, _values, result) ⇒ Object 



4390
4391
4392
4393
4394
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4390

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

#_reduce_279(val, _values, result) ⇒ Object 



4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4396

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

                      result.line = val[1]
                    
    result
end

#_reduce_28(val, _values, result) ⇒ Object 



3204
3205
3206
3207
3208
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3204

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

#_reduce_280(val, _values, result) ⇒ Object 



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

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

#_reduce_281(val, _values, result) ⇒ Object 



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

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

#_reduce_282(val, _values, result) ⇒ Object 



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

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

#_reduce_283(val, _values, result) ⇒ Object 



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

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

#_reduce_284(val, _values, result) ⇒ Object 



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

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

#_reduce_285(val, _values, result) ⇒ Object 



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

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

#_reduce_286(val, _values, result) ⇒ Object 



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

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

#_reduce_287(val, _values, result) ⇒ Object 



4452
4453
4454
4455
4456
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4452

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

#_reduce_288(val, _values, result) ⇒ Object 



4458
4459
4460
4461
4462
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4458

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

#_reduce_289(val, _values, result) ⇒ Object 



4464
4465
4466
4467
4468
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4464

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

#_reduce_29(val, _values, result) ⇒ Object 



3210
3211
3212
3213
3214
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3210

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

#_reduce_290(val, _values, result) ⇒ Object 



4470
4471
4472
4473
4474
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4470

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

#_reduce_291(val, _values, result) ⇒ Object 



4476
4477
4478
4479
4480
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4476

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

#_reduce_292(val, _values, result) ⇒ Object 



4482
4483
4484
4485
4486
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4482

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

#_reduce_293(val, _values, result) ⇒ Object 



4488
4489
4490
4491
4492
4493
4494
4495
4496
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4488

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

reduce 294 omitted



4500
4501
4502
4503
4504
4505
4506
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4500

def _reduce_295(val, _values, result)
                      call, iter = val[0], val[1]
                      iter.insert 1, call
                      result = iter
                    
    result
end

#_reduce_296(val, _values, result) ⇒ Object 



4508
4509
4510
4511
4512
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4508

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

#_reduce_297(val, _values, result) ⇒ Object 



4514
4515
4516
4517
4518
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4514

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

#_reduce_298(val, _values, result) ⇒ Object 



4520
4521
4522
4523
4524
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4520

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

#_reduce_299(val, _values, result) ⇒ Object 



4526
4527
4528
4529
4530
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4526

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

#_reduce_3(val, _values, result) ⇒ Object 



3054
3055
3056
3057
3058
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3054

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

#_reduce_30(val, _values, result) ⇒ Object 



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

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

#_reduce_300(val, _values, result) ⇒ Object 



4532
4533
4534
4535
4536
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4532

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

#_reduce_301(val, _values, result) ⇒ Object 



4538
4539
4540
4541
4542
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4538

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

#_reduce_302(val, _values, result) ⇒ Object 



4544
4545
4546
4547
4548
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4544

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

#_reduce_303(val, _values, result) ⇒ Object 



4550
4551
4552
4553
4554
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4550

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

#_reduce_304(val, _values, result) ⇒ Object 



4556
4557
4558
4559
4560
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4556

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

#_reduce_305(val, _values, result) ⇒ Object 



4562
4563
4564
4565
4566
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4562

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

#_reduce_306(val, _values, result) ⇒ Object 



4568
4569
4570
4571
4572
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4568

def _reduce_306(val, _values, result)
                      result = new_case nil, val[2]
                    
    result
end

#_reduce_307(val, _values, result) ⇒ Object 



4574
4575
4576
4577
4578
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4574

def _reduce_307(val, _values, result)
                      result = new_case nil, val[3]
                    
    result
end

#_reduce_308(val, _values, result) ⇒ Object 



4580
4581
4582
4583
4584
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4580

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

#_reduce_309(val, _values, result) ⇒ Object 



4586
4587
4588
4589
4590
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4586

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

#_reduce_31(val, _values, result) ⇒ Object 



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

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

#_reduce_310(val, _values, result) ⇒ Object 



4592
4593
4594
4595
4596
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4592

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

#_reduce_311(val, _values, result) ⇒ Object 



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

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

#_reduce_312(val, _values, result) ⇒ Object 



4604
4605
4606
4607
4608
4609
4610
4611
4612
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4604

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



4614
4615
4616
4617
4618
4619
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4614

def _reduce_313(val, _values, result)
                      result = new_class val
                      self.env.unextend
                    
    result
end

#_reduce_314(val, _values, result) ⇒ Object 



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

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

#_reduce_315(val, _values, result) ⇒ Object 



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

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

#_reduce_316(val, _values, result) ⇒ Object 



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

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

#_reduce_317(val, _values, result) ⇒ Object 



4642
4643
4644
4645
4646
4647
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4642

def _reduce_317(val, _values, result)
                      result = new_sclass val
                      self.env.unextend
                    
    result
end

#_reduce_318(val, _values, result) ⇒ Object 



4649
4650
4651
4652
4653
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4649

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

#_reduce_319(val, _values, result) ⇒ Object 



4655
4656
4657
4658
4659
4660
4661
4662
4663
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4655

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



3228
3229
3230
3231
3232
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3228

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

#_reduce_320(val, _values, result) ⇒ Object 



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

def _reduce_320(val, _values, result)
                      result = new_module val
                      self.env.unextend
                    
    result
end

#_reduce_321(val, _values, result) ⇒ Object 



4672
4673
4674
4675
4676
4677
4678
4679
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4672

def _reduce_321(val, _values, result)
                      self.comments.push self.lexer.comments
                      self.in_def = true
                      self.env.extend
                      result = lexer.lineno, lexer.src.beginning_of_line?
                    
    result
end

#_reduce_322(val, _values, result) ⇒ Object 



4681
4682
4683
4684
4685
4686
4687
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4681

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

#_reduce_323(val, _values, result) ⇒ Object 



4689
4690
4691
4692
4693
4694
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4689

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

#_reduce_324(val, _values, result) ⇒ Object 



4696
4697
4698
4699
4700
4701
4702
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4696

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

#_reduce_325(val, _values, result) ⇒ Object 



4704
4705
4706
4707
4708
4709
4710
4711
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4704

def _reduce_325(val, _values, result)
                      result = new_defs val

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

#_reduce_326(val, _values, result) ⇒ Object 



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

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

#_reduce_327(val, _values, result) ⇒ Object 



4719
4720
4721
4722
4723
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4719

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

#_reduce_328(val, _values, result) ⇒ Object 



4725
4726
4727
4728
4729
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4725

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

#_reduce_329(val, _values, result) ⇒ Object 



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

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

#_reduce_33(val, _values, result) ⇒ Object 



3234
3235
3236
3237
3238
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3234

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

#_reduce_330(val, _values, result) ⇒ Object 



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

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

#_reduce_339(val, _values, result) ⇒ Object

reduce 338 omitted



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

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

#_reduce_341(val, _values, result) ⇒ Object

reduce 340 omitted



4767
4768
4769
4770
4771
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4767

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

#_reduce_343(val, _values, result) ⇒ Object

reduce 342 omitted



4775
4776
4777
4778
4779
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4775

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

#_reduce_345(val, _values, result) ⇒ Object

reduce 344 omitted



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

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

#_reduce_346(val, _values, result) ⇒ Object 



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

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

#_reduce_347(val, _values, result) ⇒ Object 



4797
4798
4799
4800
4801
4802
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4797

def _reduce_347(val, _values, result)
                      result = val[1]
                      self.lexer.command_start = true
                    
    result
end

#_reduce_348(val, _values, result) ⇒ Object 



4804
4805
4806
4807
4808
4809
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4804

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

#_reduce_349(val, _values, result) ⇒ Object 



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

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

#_reduce_350(val, _values, result) ⇒ Object 



4817
4818
4819
4820
4821
4822
4823
4824
4825
4826
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4817

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

                      self.env.unextend
                    
    result
end

#_reduce_351(val, _values, result) ⇒ Object

Raises:

  • (SyntaxError) 


4828
4829
4830
4831
4832
4833
4834
4835
4836
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4828

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

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

#_reduce_352(val, _values, result) ⇒ Object 



4838
4839
4840
4841
4842
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4838

def _reduce_352(val, _values, result)
                      result = new_call val[0], val[2], val[3]
                    
    result
end

#_reduce_353(val, _values, result) ⇒ Object 



4844
4845
4846
4847
4848
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4844

def _reduce_353(val, _values, result)
                      result = new_call val[0], val[2], val[3]
                    
    result
end

#_reduce_354(val, _values, result) ⇒ Object 



4850
4851
4852
4853
4854
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4850

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

#_reduce_355(val, _values, result) ⇒ Object 



4856
4857
4858
4859
4860
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4856

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

#_reduce_356(val, _values, result) ⇒ Object 



4862
4863
4864
4865
4866
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4862

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

#_reduce_357(val, _values, result) ⇒ Object 



4868
4869
4870
4871
4872
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4868

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

#_reduce_358(val, _values, result) ⇒ Object 



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

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

#_reduce_359(val, _values, result) ⇒ Object 



4880
4881
4882
4883
4884
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4880

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

#_reduce_36(val, _values, result) ⇒ Object

reduce 35 omitted



3244
3245
3246
3247
3248
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3244

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

#_reduce_360(val, _values, result) ⇒ Object 



4886
4887
4888
4889
4890
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4886

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

#_reduce_361(val, _values, result) ⇒ Object 



4892
4893
4894
4895
4896
4897
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4892

def _reduce_361(val, _values, result)
                      call = s(:call, nil, :lambda, s(:arglist))
                      result = s(:iter, call, nil, val[0])
                    
    result
end

#_reduce_362(val, _values, result) ⇒ Object 



4899
4900
4901
4902
4903
4904
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4899

def _reduce_362(val, _values, result)
                      case val[0].size
                      when 1
                        args = 0
                      when 2
                        args = s(:lasgn, val[0][1])
                      else
                        vars = val[0][1..-1].map{|name| s(:lasgn, name)}
                        args = s(:masgn, s(:array, *vars))
                      end

                      call = s(:call, nil, :lambda, s(:arglist))
                      result = s(:iter, call, args, val[1])
                    
    result
end

#_reduce_363(val, _values, result) ⇒ Object 



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

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

#_reduce_364(val, _values, result) ⇒ Object 



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

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

#_reduce_365(val, _values, result) ⇒ Object 



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

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

#_reduce_366(val, _values, result) ⇒ Object 



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

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

#_reduce_367(val, _values, result) ⇒ Object 



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

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

#_reduce_368(val, _values, result) ⇒ Object 



4947
4948
4949
4950
4951
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4947

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

#_reduce_369(val, _values, result) ⇒ Object 



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

def _reduce_369(val, _values, result)
                      # REFACTOR
                      args   = val[2]
                      body   = val[4]
                      result = new_iter nil, args, body
                      self.env.unextend
                      result.line = val[1]
                    
    result
end

#_reduce_37(val, _values, result) ⇒ Object 



3250
3251
3252
3253
3254
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3250

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

#_reduce_370(val, _values, result) ⇒ Object 



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

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

#_reduce_371(val, _values, result) ⇒ Object 



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

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

#_reduce_372(val, _values, result) ⇒ Object 



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

def _reduce_372(val, _values, result)
                      args = val[2]
                      body = val[4]
                      result = new_iter nil, args, body
                      self.env.unextend
                      result.line = val[1]
                    
    result
end

#_reduce_373(val, _values, result) ⇒ Object 



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

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

#_reduce_374(val, _values, result) ⇒ Object 



4993
4994
4995
4996
4997
4998
4999
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 4993

def _reduce_374(val, _values, result)
                      result = s(:when, val[2], val[4])
                      result.line = val[1]
                      result << val[5] if val[5]
                    
    result
end

#_reduce_376(val, _values, result) ⇒ Object

reduce 375 omitted



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

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

#_reduce_377(val, _values, result) ⇒ Object 



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

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

#_reduce_38(val, _values, result) ⇒ Object 



3256
3257
3258
3259
3260
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3256

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

#_reduce_380(val, _values, result) ⇒ Object

reduce 379 omitted



5019
5020
5021
5022
5023
5024
5025
5026
5027
5028
5029
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5019

def _reduce_380(val, _values, result)
                      klasses, var, body, rest = val[1], val[2], val[4], val[5]

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

                      result = s(:resbody, klasses, body)
                      result << rest if rest # UGH, rewritten above
                    
    result
end

#_reduce_381(val, _values, result) ⇒ Object 



5031
5032
5033
5034
5035
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5031

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

#_reduce_382(val, _values, result) ⇒ Object 



5037
5038
5039
5040
5041
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5037

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

#_reduce_385(val, _values, result) ⇒ Object

reduce 384 omitted



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

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

#_reduce_387(val, _values, result) ⇒ Object

reduce 386 omitted



5055
5056
5057
5058
5059
5060
5061
5062
5063
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5055

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

#_reduce_389(val, _values, result) ⇒ Object

reduce 388 omitted



5067
5068
5069
5070
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5067

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

#_reduce_39(val, _values, result) ⇒ Object 



3262
3263
3264
3265
3266
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3262

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

#_reduce_390(val, _values, result) ⇒ Object 



5072
5073
5074
5075
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5072

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

#_reduce_392(val, _values, result) ⇒ Object

reduce 391 omitted



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

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

#_reduce_394(val, _values, result) ⇒ Object

reduce 393 omitted



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

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

#_reduce_395(val, _values, result) ⇒ Object 



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

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

#_reduce_396(val, _values, result) ⇒ Object 



5100
5101
5102
5103
5104
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5100

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

#_reduce_397(val, _values, result) ⇒ Object 



5106
5107
5108
5109
5110
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5106

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

#_reduce_398(val, _values, result) ⇒ Object 



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

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

#_reduce_399(val, _values, result) ⇒ Object 



5118
5119
5120
5121
5122
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5118

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

#_reduce_4(val, _values, result) ⇒ Object 



3060
3061
3062
3063
3064
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3060

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

#_reduce_400(val, _values, result) ⇒ Object 



5124
5125
5126
5127
5128
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5124

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

#_reduce_401(val, _values, result) ⇒ Object 



5130
5131
5132
5133
5134
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5130

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

#_reduce_402(val, _values, result) ⇒ Object 



5136
5137
5138
5139
5140
5141
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5136

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

#_reduce_404(val, _values, result) ⇒ Object

reduce 403 omitted



5145
5146
5147
5148
5149
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5145

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

#_reduce_405(val, _values, result) ⇒ Object 



5151
5152
5153
5154
5155
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5151

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

#_reduce_406(val, _values, result) ⇒ Object 



5157
5158
5159
5160
5161
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5157

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

#_reduce_407(val, _values, result) ⇒ Object 



5163
5164
5165
5166
5167
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5163

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

#_reduce_408(val, _values, result) ⇒ Object 



5169
5170
5171
5172
5173
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5169

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

#_reduce_409(val, _values, result) ⇒ Object 



5175
5176
5177
5178
5179
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5175

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

#_reduce_41(val, _values, result) ⇒ Object

reduce 40 omitted



3270
3271
3272
3273
3274
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3270

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

#_reduce_410(val, _values, result) ⇒ Object 



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

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

#_reduce_411(val, _values, result) ⇒ Object 



5187
5188
5189
5190
5191
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5187

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

#_reduce_412(val, _values, result) ⇒ Object 



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

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

#_reduce_413(val, _values, result) ⇒ Object 



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

def _reduce_413(val, _values, result)
                      result = s(:str, val[0])
                    
    result
end

#_reduce_414(val, _values, result) ⇒ Object 



5205
5206
5207
5208
5209
5210
5211
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5205

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

#_reduce_415(val, _values, result) ⇒ Object 



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

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

#_reduce_416(val, _values, result) ⇒ Object 



5220
5221
5222
5223
5224
5225
5226
5227
5228
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5220

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

#_reduce_417(val, _values, result) ⇒ Object 



5230
5231
5232
5233
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243
5244
5245
5246
5247
5248
5249
5250
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5230

def _reduce_417(val, _values, result)
                      lexer.lex_strterm = val[1]
                      lexer.cond.lexpop
                      lexer.cmdarg.lexpop

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

#_reduce_418(val, _values, result) ⇒ Object 



5252
5253
5254
5255
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5252

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

#_reduce_419(val, _values, result) ⇒ Object 



5257
5258
5259
5260
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5257

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

#_reduce_420(val, _values, result) ⇒ Object 



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

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

#_reduce_422(val, _values, result) ⇒ Object

reduce 421 omitted



5269
5270
5271
5272
5273
5274
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5269

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

#_reduce_423(val, _values, result) ⇒ Object 



5276
5277
5278
5279
5280
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5276

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

#_reduce_428(val, _values, result) ⇒ Object

reduce 427 omitted



5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305
5306
5307
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5290

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

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

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

#_reduce_431(val, _values, result) ⇒ Object

reduce 430 omitted



5313
5314
5315
5316
5317
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5313

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

#_reduce_432(val, _values, result) ⇒ Object 



5319
5320
5321
5322
5323
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5319

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

#_reduce_438(val, _values, result) ⇒ Object

reduce 437 omitted



5335
5336
5337
5338
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5335

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

#_reduce_439(val, _values, result) ⇒ Object 



5340
5341
5342
5343
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5340

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

#_reduce_44(val, _values, result) ⇒ Object

reduce 43 omitted



3280
3281
3282
3283
3284
3285
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3280

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

#_reduce_440(val, _values, result) ⇒ Object 



5345
5346
5347
5348
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5345

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

#_reduce_441(val, _values, result) ⇒ Object 



5350
5351
5352
5353
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5350

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

#_reduce_442(val, _values, result) ⇒ Object 



5355
5356
5357
5358
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5355

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

#_reduce_443(val, _values, result) ⇒ Object 



5360
5361
5362
5363
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5360

def _reduce_443(val, _values, result)
 result = s(:lit, lexer.src.current_line) 
    result
end

#_reduce_444(val, _values, result) ⇒ Object 



5365
5366
5367
5368
5369
5370
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5365

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

#_reduce_445(val, _values, result) ⇒ Object 



5372
5373
5374
5375
5376
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5372

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

#_reduce_446(val, _values, result) ⇒ Object 



5378
5379
5380
5381
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5378

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

#_reduce_447(val, _values, result) ⇒ Object 



5383
5384
5385
5386
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5383

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

#_reduce_448(val, _values, result) ⇒ Object 



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

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

#_reduce_449(val, _values, result) ⇒ Object 



5394
5395
5396
5397
5398
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5394

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

#_reduce_45(val, _values, result) ⇒ Object 



3287
3288
3289
3290
3291
3292
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3287

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

#_reduce_450(val, _values, result) ⇒ Object 



5400
5401
5402
5403
5404
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5400

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

#_reduce_451(val, _values, result) ⇒ Object 



5406
5407
5408
5409
5410
5411
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5406

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

#_reduce_452(val, _values, result) ⇒ Object 



5413
5414
5415
5416
5417
5418
5419
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5413

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

#_reduce_453(val, _values, result) ⇒ Object 



5421
5422
5423
5424
5425
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5421

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

#_reduce_454(val, _values, result) ⇒ Object 



5427
5428
5429
5430
5431
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5427

def _reduce_454(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_455(val, _values, result) ⇒ Object 



5433
5434
5435
5436
5437
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5433

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

#_reduce_456(val, _values, result) ⇒ Object 



5439
5440
5441
5442
5443
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5439

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

#_reduce_457(val, _values, result) ⇒ Object 



5445
5446
5447
5448
5449
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5445

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

#_reduce_458(val, _values, result) ⇒ Object 



5451
5452
5453
5454
5455
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5451

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

#_reduce_459(val, _values, result) ⇒ Object 



5457
5458
5459
5460
5461
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5457

def _reduce_459(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_46(val, _values, result) ⇒ Object 



3294
3295
3296
3297
3298
3299
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3294

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

#_reduce_460(val, _values, result) ⇒ Object 



5463
5464
5465
5466
5467
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5463

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

#_reduce_461(val, _values, result) ⇒ Object 



5469
5470
5471
5472
5473
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5469

def _reduce_461(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_462(val, _values, result) ⇒ Object 



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

def _reduce_462(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_463(val, _values, result) ⇒ Object 



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

def _reduce_463(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_464(val, _values, result) ⇒ Object 



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

def _reduce_464(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_465(val, _values, result) ⇒ Object 



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

def _reduce_465(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_466(val, _values, result) ⇒ Object 



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

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

#_reduce_467(val, _values, result) ⇒ Object 



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

def _reduce_467(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_468(val, _values, result) ⇒ Object 



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

def _reduce_468(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_469(val, _values, result) ⇒ Object 



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

def _reduce_469(val, _values, result)
                      result = args19 val
                    
    result
end

#_reduce_470(val, _values, result) ⇒ Object 



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

def _reduce_470(val, _values, result)
                      yyerror "formal argument cannot be a constant: #{val[0]}"
                    
    result
end

#_reduce_471(val, _values, result) ⇒ Object 



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

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

#_reduce_472(val, _values, result) ⇒ Object 



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

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

#_reduce_473(val, _values, result) ⇒ Object 



5541
5542
5543
5544
5545
5546
5547
5548
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5541

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

                      result = val[0]
                    
    result
end

#_reduce_474(val, _values, result) ⇒ Object 



5550
5551
5552
5553
5554
5555
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5550

def _reduce_474(val, _values, result)
                      result = s(:args)
                      result << val[0].to_sym
                    
    result
end

#_reduce_475(val, _values, result) ⇒ Object 



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

def _reduce_475(val, _values, result)
                      val[0] << val[2].to_sym
                      result = val[0]
                    
    result
end

#_reduce_476(val, _values, result) ⇒ Object 



5564
5565
5566
5567
5568
5569
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5564

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

#_reduce_477(val, _values, result) ⇒ Object 



5571
5572
5573
5574
5575
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5571

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

#_reduce_478(val, _values, result) ⇒ Object 



5577
5578
5579
5580
5581
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5577

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

#_reduce_48(val, _values, result) ⇒ Object

reduce 47 omitted



3303
3304
3305
3306
3307
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3303

def _reduce_48(val, _values, result)
                      result = new_call val[0], val[2], val[3]
                    
    result
end

#_reduce_481(val, _values, result) ⇒ Object

reduce 480 omitted



5587
5588
5589
5590
5591
5592
5593
5594
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5587

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

#_reduce_482(val, _values, result) ⇒ Object 



5596
5597
5598
5599
5600
5601
5602
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5596

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

#_reduce_485(val, _values, result) ⇒ Object

reduce 484 omitted



5608
5609
5610
5611
5612
5613
5614
5615
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5608

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

                      self.env[identifier] = :lvar
                      result = s(:block_arg, identifier.to_sym)
                    
    result
end

#_reduce_486(val, _values, result) ⇒ Object 



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

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

#_reduce_487(val, _values, result) ⇒ Object 



5623
5624
5625
5626
5627
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5623

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

#_reduce_489(val, _values, result) ⇒ Object

reduce 488 omitted



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

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

#_reduce_49(val, _values, result) ⇒ Object 



3309
3310
3311
3312
3313
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3309

def _reduce_49(val, _values, result)
                      result = new_call val[0], val[2], val[3]
                    
    result
end

#_reduce_490(val, _values, result) ⇒ Object 



5637
5638
5639
5640
5641
5642
5643
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5637

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

#_reduce_491(val, _values, result) ⇒ Object 



5645
5646
5647
5648
5649
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5645

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

#_reduce_492(val, _values, result) ⇒ Object 



5651
5652
5653
5654
5655
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5651

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

#_reduce_493(val, _values, result) ⇒ Object 



5657
5658
5659
5660
5661
5662
5663
5664
5665
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5657

def _reduce_493(val, _values, result)
                      size = val[0].size
                      if (size % 2 != 1) then # != 1 because of leading :array
                        yyerror "Odd number (#{size}) list for Hash. #{val[0].inspect}"
                      end
                      result = val[0]
                    
    result
end

#_reduce_495(val, _values, result) ⇒ Object

reduce 494 omitted



5669
5670
5671
5672
5673
5674
5675
5676
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5669

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

#_reduce_496(val, _values, result) ⇒ Object 



5678
5679
5680
5681
5682
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5678

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

#_reduce_497(val, _values, result) ⇒ Object 



5684
5685
5686
5687
5688
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5684

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

#_reduce_50(val, _values, result) ⇒ Object 



3315
3316
3317
3318
3319
3320
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3315

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

#_reduce_51(val, _values, result) ⇒ Object 



3322
3323
3324
3325
3326
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3322

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

#_reduce_517(val, _values, result) ⇒ Object

reduce 516 omitted



5728
5729
5730
5731
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5728

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

#_reduce_52(val, _values, result) ⇒ Object 



3328
3329
3330
3331
3332
3333
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3328

def _reduce_52(val, _values, result)
                      result = new_iter nil, val[2], val[4]
                      self.env.unextend
                    
    result
end

#_reduce_520(val, _values, result) ⇒ Object

reduce 519 omitted



5737
5738
5739
5740
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5737

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

#_reduce_521(val, _values, result) ⇒ Object 



5742
5743
5744
5745
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5742

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

#_reduce_522(val, _values, result) ⇒ Object 



5747
5748
5749
5750
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 5747

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

#_reduce_53(val, _values, result) ⇒ Object 



3335
3336
3337
3338
3339
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3335

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

#_reduce_54(val, _values, result) ⇒ Object 



3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3341

def _reduce_54(val, _values, result)
                      result = new_call nil, val[0].to_sym, val[1]
                      if val[2] then
                        if result[0] == :block_pass then
                          raise "both block arg and actual block given"
                        end
                        result, operation = val[2], result
                        result.insert 1, operation
                      end
                    
    result
end

#_reduce_55(val, _values, result) ⇒ Object 



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

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

#_reduce_56(val, _values, result) ⇒ Object 



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

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

#_reduce_57(val, _values, result) ⇒ Object 



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

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

#_reduce_58(val, _values, result) ⇒ Object 



3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3372

def _reduce_58(val, _values, result)
                      result = new_call val[0], val[2].to_sym, val[3]
                      if val[4] then
                        if result[0] == :block_pass then # REFACTOR
                          raise "both block arg and actual block given"
                        end
                        val[2] << result
                        result = val[2]
                      end
                    
    result
end

#_reduce_59(val, _values, result) ⇒ Object 



3385
3386
3387
3388
3389
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3385

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

#_reduce_60(val, _values, result) ⇒ Object 



3391
3392
3393
3394
3395
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3391

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

#_reduce_62(val, _values, result) ⇒ Object

reduce 61 omitted



3399
3400
3401
3402
3403
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3399

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

#_reduce_64(val, _values, result) ⇒ Object

reduce 63 omitted



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

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

#_reduce_65(val, _values, result) ⇒ Object 



3413
3414
3415
3416
3417
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3413

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

#_reduce_66(val, _values, result) ⇒ Object 



3419
3420
3421
3422
3423
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3419

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

#_reduce_67(val, _values, result) ⇒ Object 



3425
3426
3427
3428
3429
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3425

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

#_reduce_68(val, _values, result) ⇒ Object 



3431
3432
3433
3434
3435
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3431

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

#_reduce_69(val, _values, result) ⇒ Object 



3437
3438
3439
3440
3441
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3437

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

#_reduce_7(val, _values, result) ⇒ Object

reduce 6 omitted



3070
3071
3072
3073
3074
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3070

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

#_reduce_70(val, _values, result) ⇒ Object 



3443
3444
3445
3446
3447
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3443

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

#_reduce_72(val, _values, result) ⇒ Object

reduce 71 omitted



3451
3452
3453
3454
3455
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3451

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

#_reduce_73(val, _values, result) ⇒ Object 



3457
3458
3459
3460
3461
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3457

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

#_reduce_74(val, _values, result) ⇒ Object 



3463
3464
3465
3466
3467
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3463

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

#_reduce_75(val, _values, result) ⇒ Object 



3469
3470
3471
3472
3473
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3469

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

#_reduce_76(val, _values, result) ⇒ Object 



3475
3476
3477
3478
3479
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3475

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

#_reduce_77(val, _values, result) ⇒ Object 



3481
3482
3483
3484
3485
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3481

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

#_reduce_78(val, _values, result) ⇒ Object 



3487
3488
3489
3490
3491
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3487

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

#_reduce_79(val, _values, result) ⇒ Object 



3493
3494
3495
3496
3497
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3493

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

#_reduce_8(val, _values, result) ⇒ Object 



3076
3077
3078
3079
3080
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3076

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

#_reduce_80(val, _values, result) ⇒ Object 



3499
3500
3501
3502
3503
3504
3505
3506
3507
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3499

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



3509
3510
3511
3512
3513
3514
3515
3516
3517
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3509

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

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

#_reduce_82(val, _values, result) ⇒ Object 



3519
3520
3521
3522
3523
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3519

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

#_reduce_83(val, _values, result) ⇒ Object 



3525
3526
3527
3528
3529
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3525

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

#_reduce_84(val, _values, result) ⇒ Object 



3531
3532
3533
3534
3535
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3531

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

#_reduce_85(val, _values, result) ⇒ Object 



3537
3538
3539
3540
3541
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3537

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

#_reduce_86(val, _values, result) ⇒ Object 



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

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

#_reduce_87(val, _values, result) ⇒ Object 



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

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

#_reduce_88(val, _values, result) ⇒ Object 



3555
3556
3557
3558
3559
3560
3561
3562
3563
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3555

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



3565
3566
3567
3568
3569
3570
3571
3572
3573
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3565

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



3082
3083
3084
3085
3086
3087
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3082

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

#_reduce_90(val, _values, result) ⇒ Object 



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

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

#_reduce_91(val, _values, result) ⇒ Object 



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

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

#_reduce_93(val, _values, result) ⇒ Object

reduce 92 omitted



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

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

#_reduce_94(val, _values, result) ⇒ Object 



3595
3596
3597
3598
3599
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3595

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

#_reduce_95(val, _values, result) ⇒ Object 



3601
3602
3603
3604
3605
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3601

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

#_reduce_99(val, _values, result) ⇒ Object

reduce 98 omitted



3613
3614
3615
3616
3617
3618
 
# File 'lib/ruby_parser/ruby19_parser.rb', line 3613

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

#_reduce_none(val, _values, result) ⇒ Object 



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

def _reduce_none(val, _values, result)
  val[0]
end