Parent

Methods

RubyParser

Constants

Racc_arg
Racc_token_to_s_table
Racc_debug_parser
VERSION

Attributes

lexer[RW]
in_def[RW]
in_single[RW]
file[RW]
env[R]
comments[R]

Public Class Methods

new() click to toggle source
     # File lib/ruby_parser_extras.rb, line 338
338:   def initialize
339:     super
340:     self.lexer = RubyLexer.new
341:     self.lexer.parser = self
342:     @env = Environment.new
343:     @comments = []
344: 
345:     self.reset
346:   end

Public Instance Methods

_reduce_1(val, _values, result) click to toggle source

reduce 0 omitted

      # File lib/ruby_parser.rb, line 2950
2950: def _reduce_1(val, _values, result)
2951:                       self.lexer.lex_state = :expr_beg
2952:                     
2953:     result
2954: end
_reduce_10(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2997
2997: def _reduce_10(val, _values, result)
2998:                       result = s(:alias, val[1], val[3]).line(val[2])
2999:                     
3000:     result
3001: end
_reduce_100(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3525
3525: def _reduce_100(val, _values, result)
3526:                       lexer.lex_state = :expr_end
3527:                       result = val[0]
3528:                     
3529:     result
3530: end
_reduce_101(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3532
3532: def _reduce_101(val, _values, result)
3533:  result = s(:lit, val[0].to_sym) 
3534:     result
3535: end
_reduce_102(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3537
3537: def _reduce_102(val, _values, result)
3538:  result = s(:lit, val[0]) 
3539:     result
3540: end
_reduce_103(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3542
3542: def _reduce_103(val, _values, result)
3543:                       result = new_undef val[0]
3544:                     
3545:     result
3546: end
_reduce_104(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3548
3548: def _reduce_104(val, _values, result)
3549:                       lexer.lex_state = :expr_fname
3550:                     
3551:     result
3552: end
_reduce_105(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3554
3554: def _reduce_105(val, _values, result)
3555:                       result = new_undef val[0], val[3]
3556:                     
3557:     result
3558: end
_reduce_11(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3003
3003: def _reduce_11(val, _values, result)
3004:                       result = s(:valias, val[1].to_sym, val[2].to_sym)
3005:                     
3006:     result
3007: end
_reduce_12(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3009
3009: def _reduce_12(val, _values, result)
3010:                       result = s(:valias, val[1].to_sym, :"$#{val[2]}")
3011:                     
3012:     result
3013: end
_reduce_13(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3015
3015: def _reduce_13(val, _values, result)
3016:                       yyerror "can't make alias for the number variables"
3017:                     
3018:     result
3019: end
_reduce_14(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3021
3021: def _reduce_14(val, _values, result)
3022:                       result = val[1]
3023:                     
3024:     result
3025: end
_reduce_15(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3027
3027: def _reduce_15(val, _values, result)
3028:                       result = new_if val[2], val[0], nil
3029:                     
3030:     result
3031: end
_reduce_16(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3033
3033: def _reduce_16(val, _values, result)
3034:                       result = new_if val[2], nil, val[0]
3035:                     
3036:     result
3037: end
_reduce_17(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3039
3039: def _reduce_17(val, _values, result)
3040:                       result = new_while val[0], val[2], true
3041:                     
3042:     result
3043: end
_reduce_173(val, _values, result) click to toggle source

reduce 172 omitted

      # File lib/ruby_parser.rb, line 3694
3694: def _reduce_173(val, _values, result)
3695:                       result = self.node_assign val[0], val[2]
3696:                     
3697:     result
3698: end
_reduce_174(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3700
3700: def _reduce_174(val, _values, result)
3701:                       result = self.node_assign val[0], s(:rescue, val[2], s(:resbody, s(:array), val[4]))
3702:                       # result.line = val[0].line
3703:                     
3704:     result
3705: end
_reduce_175(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3707
3707: def _reduce_175(val, _values, result)
3708:                       result = new_op_asgn val
3709:                     
3710:     result
3711: end
_reduce_176(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3713
3713: def _reduce_176(val, _values, result)
3714:                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
3715:                       val[2][0] = :arglist
3716:                     
3717:     result
3718: end
_reduce_177(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3720
3720: def _reduce_177(val, _values, result)
3721:                       result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
3722:                     
3723:     result
3724: end
_reduce_178(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3726
3726: def _reduce_178(val, _values, result)
3727:                       result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
3728:                     
3729:     result
3730: end
_reduce_179(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3732
3732: def _reduce_179(val, _values, result)
3733:                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
3734:                     
3735:     result
3736: end
_reduce_18(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3045
3045: def _reduce_18(val, _values, result)
3046:                       result = new_until val[0], val[2], true
3047:                     
3048:     result
3049: end
_reduce_180(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3738
3738: def _reduce_180(val, _values, result)
3739:                       yyerror "constant re-assignment"
3740:                     
3741:     result
3742: end
_reduce_181(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3744
3744: def _reduce_181(val, _values, result)
3745:                       yyerror "constant re-assignment"
3746:                     
3747:     result
3748: end
_reduce_182(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3750
3750: def _reduce_182(val, _values, result)
3751:                       self.backref_assign_error val[0]
3752:                     
3753:     result
3754: end
_reduce_183(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3756
3756: def _reduce_183(val, _values, result)
3757:                       v1, v2 = val[0], val[2]
3758:                       if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
3759:                         result = s(:lit, (v1.last)..(v2.last))
3760:                       else
3761:                         result = s(:dot2, v1, v2)
3762:                       end
3763:                     
3764:     result
3765: end
_reduce_184(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3767
3767: def _reduce_184(val, _values, result)
3768:                       v1, v2 = val[0], val[2]
3769:                       if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
3770:                         result = s(:lit, (v1.last)...(v2.last))
3771:                       else
3772:                         result = s(:dot3, v1, v2)
3773:                       end
3774:                     
3775:     result
3776: end
_reduce_185(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3778
3778: def _reduce_185(val, _values, result)
3779:                       result = new_call val[0], :+, s(:arglist, val[2])
3780:                     
3781:     result
3782: end
_reduce_186(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3784
3784: def _reduce_186(val, _values, result)
3785:                       result = new_call val[0], :-, s(:arglist, val[2])
3786:                     
3787:     result
3788: end
_reduce_187(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3790
3790: def _reduce_187(val, _values, result)
3791:                       result = new_call val[0], :*, s(:arglist, val[2])
3792:                     
3793:     result
3794: end
_reduce_188(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3796
3796: def _reduce_188(val, _values, result)
3797:                       result = new_call val[0], :"/", s(:arglist, val[2])
3798:                     
3799:     result
3800: end
_reduce_189(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3802
3802: def _reduce_189(val, _values, result)
3803:                       result = new_call val[0], :%, s(:arglist, val[2])
3804:                     
3805:     result
3806: end
_reduce_19(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3051
3051: def _reduce_19(val, _values, result)
3052:                       result = s(:rescue, val[0], s(:resbody, s(:array), val[2]))
3053:                     
3054:     result
3055: end
_reduce_190(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3808
3808: def _reduce_190(val, _values, result)
3809:                       result = new_call val[0], :**, s(:arglist, val[2])
3810:                     
3811:     result
3812: end
_reduce_191(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3814
3814: def _reduce_191(val, _values, result)
3815:                       result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
3816:                     
3817:     result
3818: end
_reduce_192(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3820
3820: def _reduce_192(val, _values, result)
3821:                       result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
3822:                     
3823:     result
3824: end
_reduce_193(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3826
3826: def _reduce_193(val, _values, result)
3827:                       if val[1][0] == :lit then
3828:                         result = val[1]
3829:                       else
3830:                         result = new_call val[1], :"+@", s(:arglist)
3831:                       end
3832:                     
3833:     result
3834: end
_reduce_194(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3836
3836: def _reduce_194(val, _values, result)
3837:                       result = new_call val[1], :"-@", s(:arglist)
3838:                     
3839:     result
3840: end
_reduce_195(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3842
3842: def _reduce_195(val, _values, result)
3843:                       result = new_call val[0], :"|", s(:arglist, val[2])
3844:                     
3845:     result
3846: end
_reduce_196(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3848
3848: def _reduce_196(val, _values, result)
3849:                       result = new_call val[0], :"^", s(:arglist, val[2])
3850:                     
3851:     result
3852: end
_reduce_197(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3854
3854: def _reduce_197(val, _values, result)
3855:                       result = new_call val[0], :"&", s(:arglist, val[2])
3856:                     
3857:     result
3858: end
_reduce_198(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3860
3860: def _reduce_198(val, _values, result)
3861:                       result = new_call val[0], :"<=>", s(:arglist, val[2])
3862:                     
3863:     result
3864: end
_reduce_199(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3866
3866: def _reduce_199(val, _values, result)
3867:                       result = new_call val[0], :">", s(:arglist, val[2])
3868:                     
3869:     result
3870: end
_reduce_2(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2956
2956: def _reduce_2(val, _values, result)
2957:                       result = val[1]
2958:                     
2959:     result
2960: end
_reduce_20(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3057
3057: def _reduce_20(val, _values, result)
3058:                       if (self.in_def || self.in_single > 0) then
3059:                         yyerror "BEGIN in method"
3060:                       end
3061:                       self.env.extend
3062:                     
3063:     result
3064: end
_reduce_200(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3872
3872: def _reduce_200(val, _values, result)
3873:                       result = new_call val[0], :">=", s(:arglist, val[2])
3874:                     
3875:     result
3876: end
_reduce_201(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3878
3878: def _reduce_201(val, _values, result)
3879:                       result = new_call val[0], :"<", s(:arglist, val[2])
3880:                     
3881:     result
3882: end
_reduce_202(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3884
3884: def _reduce_202(val, _values, result)
3885:                       result = new_call val[0], :"<=", s(:arglist, val[2])
3886:                     
3887:     result
3888: end
_reduce_203(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3890
3890: def _reduce_203(val, _values, result)
3891:                       result = new_call val[0], :"==", s(:arglist, val[2])
3892:                     
3893:     result
3894: end
_reduce_204(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3896
3896: def _reduce_204(val, _values, result)
3897:                       result = new_call val[0], :"===", s(:arglist, val[2])
3898:                     
3899:     result
3900: end
_reduce_205(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3902
3902: def _reduce_205(val, _values, result)
3903:                       val[0] = value_expr val[0] # TODO: port call_op and clean these
3904:                       val[2] = value_expr val[2]
3905:                       result = s(:not, new_call(val[0], :"==", s(:arglist, val[2])))
3906:                     
3907:     result
3908: end
_reduce_206(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3910
3910: def _reduce_206(val, _values, result)
3911:                       result = self.get_match_node val[0], val[2]
3912:                     
3913:     result
3914: end
_reduce_207(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3916
3916: def _reduce_207(val, _values, result)
3917:                       result = s(:not, self.get_match_node(val[0], val[2]))
3918:                     
3919:     result
3920: end
_reduce_208(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3922
3922: def _reduce_208(val, _values, result)
3923:                       result = s(:not, val[1])
3924:                     
3925:     result
3926: end
_reduce_209(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3928
3928: def _reduce_209(val, _values, result)
3929:                       val[2] = value_expr val[2]
3930:                       result = new_call val[1], :"~", s(:arglist)
3931:                     
3932:     result
3933: end
_reduce_21(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3066
3066: def _reduce_21(val, _values, result)
3067:                       result = new_iter s(:preexe), nil, val[3] # TODO: add test?
3068:                       result = nil # TODO: since it isn't supposed to go in the AST
3069:                     
3070:     result
3071: end
_reduce_210(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3935
3935: def _reduce_210(val, _values, result)
3936:                       val[0] = value_expr val[0]
3937:                       val[2] = value_expr val[2]
3938:                       result = new_call val[0], :"\<\<", s(:arglist, val[2])
3939:                     
3940:     result
3941: end
_reduce_211(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3943
3943: def _reduce_211(val, _values, result)
3944:                       val[0] = value_expr val[0]
3945:                       val[2] = value_expr val[2]
3946:                       result = new_call val[0], :">>", s(:arglist, val[2])
3947:                     
3948:     result
3949: end
_reduce_212(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3951
3951: def _reduce_212(val, _values, result)
3952:                       result = logop(:and, val[0], val[2])
3953:                     
3954:     result
3955: end
_reduce_213(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3957
3957: def _reduce_213(val, _values, result)
3958:                       result = logop(:or, val[0], val[2])
3959:                     
3960:     result
3961: end
_reduce_214(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3963
3963: def _reduce_214(val, _values, result)
3964:                       result = s(:defined, val[2])
3965:                     
3966:     result
3967: end
_reduce_215(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3969
3969: def _reduce_215(val, _values, result)
3970:                       result = s(:if, val[0], val[2], val[4])
3971:                     
3972:     result
3973: end
_reduce_217(val, _values, result) click to toggle source

reduce 216 omitted

      # File lib/ruby_parser.rb, line 3977
3977: def _reduce_217(val, _values, result)
3978:                       result = value_expr(val[0])
3979:                     
3980:     result
3981: end
_reduce_219(val, _values, result) click to toggle source

reduce 218 omitted

      # File lib/ruby_parser.rb, line 3985
3985: def _reduce_219(val, _values, result)
3986:                       warning 'parenthesize argument(s) for future version'
3987:                       result = s(:array, val[0])
3988:                     
3989:     result
3990: end
_reduce_22(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3073
3073: def _reduce_22(val, _values, result)
3074:                       if (self.in_def || self.in_single > 0) then
3075:                         yyerror "END in method; use at_exit"
3076:                       end
3077:                       result = new_iter s(:postexe), nil, val[2]
3078:                     
3079:     result
3080: end
_reduce_220(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3992
3992: def _reduce_220(val, _values, result)
3993:                       result = val[0]
3994:                     
3995:     result
3996: end
_reduce_221(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3998
3998: def _reduce_221(val, _values, result)
3999:                       result = self.arg_concat val[0], val[3]
4000:                     
4001:     result
4002: end
_reduce_222(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4004
4004: def _reduce_222(val, _values, result)
4005:                       result = s(:array, s(:hash, *val[0].values))
4006:                     
4007:     result
4008: end
_reduce_223(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4010
4010: def _reduce_223(val, _values, result)
4011:                       result = s(:array, s(:splat, val[1]))
4012:                     
4013:     result
4014: end
_reduce_224(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4016
4016: def _reduce_224(val, _values, result)
4017:                       result = val[1]
4018:                     
4019:     result
4020: end
_reduce_225(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4022
4022: def _reduce_225(val, _values, result)
4023:                       result = val[1]
4024:                     
4025:     result
4026: end
_reduce_226(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4028
4028: def _reduce_226(val, _values, result)
4029:                       warning "parenthesize argument(s) for future version"
4030:                       result = s(:array, val[1])
4031:                     
4032:     result
4033: end
_reduce_227(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4035
4035: def _reduce_227(val, _values, result)
4036:                       warning "parenthesize argument(s) for future version"
4037:                       result = val[1].add val[3]
4038:                     
4039:     result
4040: end
_reduce_23(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3082
3082: def _reduce_23(val, _values, result)
3083:                       result = self.node_assign val[0], val[2]
3084:                     
3085:     result
3086: end
_reduce_230(val, _values, result) click to toggle source

reduce 229 omitted

      # File lib/ruby_parser.rb, line 4046
4046: def _reduce_230(val, _values, result)
4047:                       warning "parenthesize argument(s) for future version"
4048:                       result = s(:array, val[0])
4049:                     
4050:     result
4051: end
_reduce_231(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4053
4053: def _reduce_231(val, _values, result)
4054:                       result = self.arg_blk_pass val[0], val[1]
4055:                     
4056:     result
4057: end
_reduce_232(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4059
4059: def _reduce_232(val, _values, result)
4060:                       result = self.arg_concat val[0], val[3]
4061:                       result = self.arg_blk_pass result, val[4]
4062:                     
4063:     result
4064: end
_reduce_233(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4066
4066: def _reduce_233(val, _values, result)
4067:                       result = s(:array, s(:hash, *val[0].values))
4068:                       result = self.arg_blk_pass result, val[1]
4069:                     
4070:     result
4071: end
_reduce_234(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4073
4073: def _reduce_234(val, _values, result)
4074:                       result = self.arg_concat s(:array, s(:hash, *val[0].values)), val[3]
4075:                       result = self.arg_blk_pass result, val[4]
4076:                     
4077:     result
4078: end
_reduce_235(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4080
4080: def _reduce_235(val, _values, result)
4081:                       result = val[0] << s(:hash, *val[2].values)
4082:                       result = self.arg_blk_pass result, val[3]
4083:                     
4084:     result
4085: end
_reduce_236(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4087
4087: def _reduce_236(val, _values, result)
4088:                       val[0] << s(:hash, *val[2].values)
4089:                       result = self.arg_concat val[0], val[5]
4090:                       result = self.arg_blk_pass result, val[6]
4091:                     
4092:     result
4093: end
_reduce_237(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4095
4095: def _reduce_237(val, _values, result)
4096:                       result = self.arg_blk_pass s(:splat, val[1]), val[2]
4097:                     
4098:     result
4099: end
_reduce_239(val, _values, result) click to toggle source

reduce 238 omitted

      # File lib/ruby_parser.rb, line 4103
4103: def _reduce_239(val, _values, result)
4104:                       args = self.list_prepend val[0], val[2]
4105:                       result = self.arg_blk_pass args, val[3]
4106:                     
4107:     result
4108: end
_reduce_24(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3088
3088: def _reduce_24(val, _values, result)
3089:                       result = new_masgn val[0], val[2], :wrap
3090:                     
3091:     result
3092: end
_reduce_240(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4110
4110: def _reduce_240(val, _values, result)
4111:                       result = self.arg_blk_pass val[0], val[2]
4112:                     
4113:     result
4114: end
_reduce_241(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4116
4116: def _reduce_241(val, _values, result)
4117:                       result = self.arg_concat s(:array, val[0]), val[3]
4118:                       result = self.arg_blk_pass result, val[4]
4119:                     
4120:     result
4121: end
_reduce_242(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4123
4123: def _reduce_242(val, _values, result)
4124:                       result = self.arg_concat s(:array, val[0], s(:hash, *val[2].values)), val[5]
4125:                       result = self.arg_blk_pass result, val[6]
4126:                     
4127:     result
4128: end
_reduce_243(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4130
4130: def _reduce_243(val, _values, result)
4131:                       result = s(:array, s(:hash, *val[0].values))
4132:                       result = self.arg_blk_pass result, val[1]
4133:                     
4134:     result
4135: end
_reduce_244(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4137
4137: def _reduce_244(val, _values, result)
4138:                       result = s(:array, s(:hash, *val[0].values), val[3])
4139:                       result = self.arg_blk_pass result, val[4]
4140:                     
4141:     result
4142: end
_reduce_245(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4144
4144: def _reduce_245(val, _values, result)
4145:                       result = s(:array, val[0], s(:hash, *val[2].values))
4146:                       result = self.arg_blk_pass result, val[3]
4147:                     
4148:     result
4149: end
_reduce_246(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4151
4151: def _reduce_246(val, _values, result)
4152:                       result = s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values))
4153:                       result = self.arg_blk_pass result, val[5]
4154:                     
4155:     result
4156: end
_reduce_247(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4158
4158: def _reduce_247(val, _values, result)
4159:                       result = self.arg_concat s(:array, val[0]).add(s(:hash, *val[2].values)), val[5]
4160:                       result = self.arg_blk_pass result, val[6]
4161:                     
4162:     result
4163: end
_reduce_248(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4165
4165: def _reduce_248(val, _values, result)
4166:                       result = self.arg_concat s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)), val[7]
4167:                       result = self.arg_blk_pass result, val[8]
4168:                     
4169:     result
4170: end
_reduce_249(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4172
4172: def _reduce_249(val, _values, result)
4173:                       result = self.arg_blk_pass s(:splat, val[1]), val[2]
4174:                     
4175:     result
4176: end
_reduce_25(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3094
3094: def _reduce_25(val, _values, result)
3095:                       result = new_op_asgn val
3096:                     
3097:     result
3098: end
_reduce_251(val, _values, result) click to toggle source

reduce 250 omitted

      # File lib/ruby_parser.rb, line 4180
4180: def _reduce_251(val, _values, result)
4181:                       result = lexer.cmdarg.stack.dup
4182:                       lexer.cmdarg.push true
4183:                     
4184:     result
4185: end
_reduce_252(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4187
4187: def _reduce_252(val, _values, result)
4188:                       lexer.cmdarg.stack.replace val[0]
4189:                       result = val[1]
4190:                     
4191:     result
4192: end
_reduce_254(val, _values, result) click to toggle source

reduce 253 omitted

      # File lib/ruby_parser.rb, line 4196
4196: def _reduce_254(val, _values, result)
4197:                       lexer.lex_state = :expr_endarg
4198:                     
4199:     result
4200: end
_reduce_255(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4202
4202: def _reduce_255(val, _values, result)
4203:                       warning "don't put space before argument parentheses"
4204:                       result = nil
4205:                     
4206:     result
4207: end
_reduce_256(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4209
4209: def _reduce_256(val, _values, result)
4210:                       lexer.lex_state = :expr_endarg
4211:                     
4212:     result
4213: end
_reduce_257(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4215
4215: def _reduce_257(val, _values, result)
4216:                       warning "don't put space before argument parentheses"
4217:                       result = val[1]
4218:                     
4219:     result
4220: end
_reduce_258(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4222
4222: def _reduce_258(val, _values, result)
4223:                       result = s(:block_pass, val[1])
4224:                     
4225:     result
4226: end
_reduce_259(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4228
4228: def _reduce_259(val, _values, result)
4229:                       result = val[1]
4230:                     
4231:     result
4232: end
_reduce_26(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3100
3100: def _reduce_26(val, _values, result)
3101:                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
3102:                     
3103:     result
3104: end
_reduce_261(val, _values, result) click to toggle source

reduce 260 omitted

      # File lib/ruby_parser.rb, line 4236
4236: def _reduce_261(val, _values, result)
4237:                       result = s(:array, val[0])
4238:                     
4239:     result
4240: end
_reduce_262(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4242
4242: def _reduce_262(val, _values, result)
4243:                       result = self.list_append val[0], val[2]
4244:                     
4245:     result
4246: end
_reduce_263(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4248
4248: def _reduce_263(val, _values, result)
4249:                       result = val[0] << val[2]
4250:                     
4251:     result
4252: end
_reduce_264(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4254
4254: def _reduce_264(val, _values, result)
4255:                       result = self.arg_concat val[0], val[3]
4256:                     
4257:     result
4258: end
_reduce_265(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4260
4260: def _reduce_265(val, _values, result)
4261:                       result = s(:splat, val[1])
4262:                     
4263:     result
4264: end
_reduce_27(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3106
3106: def _reduce_27(val, _values, result)
3107:                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
3108:                     
3109:     result
3110: end
_reduce_274(val, _values, result) click to toggle source

reduce 273 omitted

      # File lib/ruby_parser.rb, line 4282
4282: def _reduce_274(val, _values, result)
4283:                       result = new_call nil, val[0].to_sym
4284:                     
4285:     result
4286: end
_reduce_275(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4288
4288: def _reduce_275(val, _values, result)
4289:                       result = self.lexer.lineno
4290:                     
4291:     result
4292: end
_reduce_276(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4294
4294: def _reduce_276(val, _values, result)
4295:                       unless val[2] then
4296:                         result = s(:nil)
4297:                       else
4298:                         result = s(:begin, val[2])
4299:                       end
4300: 
4301:                       result.line = val[1]
4302:                     
4303:     result
4304: end
_reduce_277(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4306
4306: def _reduce_277(val, _values, result)
4307:                       lexer.lex_state = :expr_endarg
4308:                     
4309:     result
4310: end
_reduce_278(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4312
4312: def _reduce_278(val, _values, result)
4313:                       warning "(...) interpreted as grouped expression"
4314:                       result = val[1]
4315:                     
4316:     result
4317: end
_reduce_279(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4319
4319: def _reduce_279(val, _values, result)
4320:                       result = val[1] || s(:nil)
4321:                       result.paren = true
4322:                     
4323:     result
4324: end
_reduce_28(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3112
3112: def _reduce_28(val, _values, result)
3113:                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
3114:                     
3115:     result
3116: end
_reduce_280(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4326
4326: def _reduce_280(val, _values, result)
4327:                       result = s(:colon2, val[0], val[2].to_sym)
4328:                     
4329:     result
4330: end
_reduce_281(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4332
4332: def _reduce_281(val, _values, result)
4333:                       result = s(:colon3, val[1].to_sym)
4334:                     
4335:     result
4336: end
_reduce_282(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4338
4338: def _reduce_282(val, _values, result)
4339:                       result = new_aref val
4340:                     
4341:     result
4342: end
_reduce_283(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4344
4344: def _reduce_283(val, _values, result)
4345:                       result = val[1] || s(:array)
4346:                     
4347:     result
4348: end
_reduce_284(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4350
4350: def _reduce_284(val, _values, result)
4351:                       result = s(:hash, *val[1].values)
4352:                     
4353:     result
4354: end
_reduce_285(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4356
4356: def _reduce_285(val, _values, result)
4357:                       result = s(:return)
4358:                     
4359:     result
4360: end
_reduce_286(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4362
4362: def _reduce_286(val, _values, result)
4363:                       result = new_yield val[2]
4364:                     
4365:     result
4366: end
_reduce_287(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4368
4368: def _reduce_287(val, _values, result)
4369:                       result = new_yield
4370:                     
4371:     result
4372: end
_reduce_288(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4374
4374: def _reduce_288(val, _values, result)
4375:                       result = new_yield
4376:                     
4377:     result
4378: end
_reduce_289(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4380
4380: def _reduce_289(val, _values, result)
4381:                       result = s(:defined, val[3])
4382:                     
4383:     result
4384: end
_reduce_29(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3118
3118: def _reduce_29(val, _values, result)
3119:                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
3120:                     
3121:     result
3122: end
_reduce_290(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4386
4386: def _reduce_290(val, _values, result)
4387:                       oper, iter = val[0], val[1]
4388:                       call = new_call(nil, oper.to_sym)
4389:                       iter.insert 1, call
4390:                       result = iter
4391:                       call.line ||= iter.line
4392:                     
4393:     result
4394: end
_reduce_292(val, _values, result) click to toggle source

reduce 291 omitted

      # File lib/ruby_parser.rb, line 4398
4398: def _reduce_292(val, _values, result)
4399:                       call, iter = val[0], val[1]
4400:                       iter.insert 1, call
4401:                       result = iter
4402:                     
4403:     result
4404: end
_reduce_293(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4406
4406: def _reduce_293(val, _values, result)
4407:                       result = new_if val[1], val[3], val[4]
4408:                     
4409:     result
4410: end
_reduce_294(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4412
4412: def _reduce_294(val, _values, result)
4413:                       result = new_if val[1], val[4], val[3]
4414:                     
4415:     result
4416: end
_reduce_295(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4418
4418: def _reduce_295(val, _values, result)
4419:                       lexer.cond.push true
4420:                     
4421:     result
4422: end
_reduce_296(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4424
4424: def _reduce_296(val, _values, result)
4425:                       lexer.cond.pop
4426:                     
4427:     result
4428: end
_reduce_297(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4430
4430: def _reduce_297(val, _values, result)
4431:                       result = new_while val[5], val[2], true
4432:                     
4433:     result
4434: end
_reduce_298(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4436
4436: def _reduce_298(val, _values, result)
4437:                       lexer.cond.push true
4438:                     
4439:     result
4440: end
_reduce_299(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4442
4442: def _reduce_299(val, _values, result)
4443:                       lexer.cond.pop
4444:                     
4445:     result
4446: end
_reduce_3(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2962
2962: def _reduce_3(val, _values, result)
2963:                       result = new_body val
2964:                     
2965:     result
2966: end
_reduce_30(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3124
3124: def _reduce_30(val, _values, result)
3125:                       self.backref_assign_error val[0]
3126:                     
3127:     result
3128: end
_reduce_300(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4448
4448: def _reduce_300(val, _values, result)
4449:                       result = new_until val[5], val[2], true
4450:                     
4451:     result
4452: end
_reduce_301(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4454
4454: def _reduce_301(val, _values, result)
4455:                       result = new_case val[1], val[3]
4456:                     
4457:     result
4458: end
_reduce_302(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4460
4460: def _reduce_302(val, _values, result)
4461:                       result = new_case nil, val[2]
4462:                     
4463:     result
4464: end
_reduce_303(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4466
4466: def _reduce_303(val, _values, result)
4467:                       result = new_case nil, val[3]
4468:                     
4469:     result
4470: end
_reduce_304(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4472
4472: def _reduce_304(val, _values, result)
4473:                       lexer.cond.push true
4474:                     
4475:     result
4476: end
_reduce_305(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4478
4478: def _reduce_305(val, _values, result)
4479:                       lexer.cond.pop
4480:                     
4481:     result
4482: end
_reduce_306(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4484
4484: def _reduce_306(val, _values, result)
4485:                       result = new_for val[4], val[1], val[7]
4486:                     
4487:     result
4488: end
_reduce_307(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4490
4490: def _reduce_307(val, _values, result)
4491:                       result = self.lexer.lineno
4492:                     
4493:     result
4494: end
_reduce_308(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4496
4496: def _reduce_308(val, _values, result)
4497:                       self.comments.push self.lexer.comments
4498:                       if (self.in_def || self.in_single > 0) then
4499:                         yyerror "class definition in method body"
4500:                       end
4501:                       self.env.extend
4502:                     
4503:     result
4504: end
_reduce_309(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4506
4506: def _reduce_309(val, _values, result)
4507:                       result = new_class val
4508:                       self.env.unextend
4509:                     
4510:     result
4511: end
_reduce_31(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3130
3130: def _reduce_31(val, _values, result)
3131:                       result = self.node_assign val[0], s(:svalue, val[2])
3132:                     
3133:     result
3134: end
_reduce_310(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4513
4513: def _reduce_310(val, _values, result)
4514:                       result = self.lexer.lineno
4515:                     
4516:     result
4517: end
_reduce_311(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4519
4519: def _reduce_311(val, _values, result)
4520:                       result = self.in_def
4521:                       self.in_def = false
4522:                     
4523:     result
4524: end
_reduce_312(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4526
4526: def _reduce_312(val, _values, result)
4527:                       result = self.in_single
4528:                       self.in_single = 0
4529:                       self.env.extend
4530:                     
4531:     result
4532: end
_reduce_313(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4534
4534: def _reduce_313(val, _values, result)
4535:                       result = new_sclass val
4536:                       self.env.unextend
4537:                     
4538:     result
4539: end
_reduce_314(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4541
4541: def _reduce_314(val, _values, result)
4542:                       result = self.lexer.lineno
4543:                     
4544:     result
4545: end
_reduce_315(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4547
4547: def _reduce_315(val, _values, result)
4548:                       self.comments.push self.lexer.comments
4549:                       yyerror "module definition in method body" if
4550:                         self.in_def or self.in_single > 0
4551: 
4552:                       self.env.extend
4553:                     
4554:     result
4555: end
_reduce_316(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4557
4557: def _reduce_316(val, _values, result)
4558:                       result = new_module val
4559:                       self.env.unextend
4560:                     
4561:     result
4562: end
_reduce_317(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4564
4564: def _reduce_317(val, _values, result)
4565:                       self.comments.push self.lexer.comments
4566:                       self.in_def = true
4567:                       self.env.extend
4568:                       result = lexer.lineno, lexer.src.beginning_of_line?
4569:                     
4570:     result
4571: end
_reduce_318(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4573
4573: def _reduce_318(val, _values, result)
4574:                       result = new_defn val
4575:                       self.env.unextend
4576:                       self.in_def = false
4577:                     
4578:     result
4579: end
_reduce_319(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4581
4581: def _reduce_319(val, _values, result)
4582:                       self.comments.push self.lexer.comments
4583:                       lexer.lex_state = :expr_fname
4584:                     
4585:     result
4586: end
_reduce_32(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3136
3136: def _reduce_32(val, _values, result)
3137:                       result = new_masgn val[0], val[2], :wrap
3138:                     
3139:     result
3140: end
_reduce_320(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4588
4588: def _reduce_320(val, _values, result)
4589:                       self.in_single += 1
4590:                       self.env.extend
4591:                       lexer.lex_state = :expr_end # force for args
4592:                     
4593:     result
4594: end
_reduce_321(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4596
4596: def _reduce_321(val, _values, result)
4597:                       result = new_defs val
4598: 
4599:                       self.env.unextend
4600:                       self.in_single -= 1
4601:                     
4602:     result
4603: end
_reduce_322(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4605
4605: def _reduce_322(val, _values, result)
4606:                       result = s(:break)
4607:                     
4608:     result
4609: end
_reduce_323(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4611
4611: def _reduce_323(val, _values, result)
4612:                       result = s(:next)
4613:                     
4614:     result
4615: end
_reduce_324(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4617
4617: def _reduce_324(val, _values, result)
4618:                       result = s(:redo)
4619:                     
4620:     result
4621: end
_reduce_325(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4623
4623: def _reduce_325(val, _values, result)
4624:                       result = s(:retry)
4625:                     
4626:     result
4627: end
_reduce_326(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4629
4629: def _reduce_326(val, _values, result)
4630:                       result = value_expr(val[0])
4631:                     
4632:     result
4633: end
_reduce_33(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3142
3142: def _reduce_33(val, _values, result)
3143:                       result = new_masgn val[0], val[2]
3144:                     
3145:     result
3146: end
_reduce_335(val, _values, result) click to toggle source

reduce 334 omitted

      # File lib/ruby_parser.rb, line 4651
4651: def _reduce_335(val, _values, result)
4652:                       result = s(:if, val[1], val[3], val[4])
4653:                     
4654:     result
4655: end
_reduce_337(val, _values, result) click to toggle source

reduce 336 omitted

      # File lib/ruby_parser.rb, line 4659
4659: def _reduce_337(val, _values, result)
4660:                       result = val[1]
4661:                     
4662:     result
4663: end
_reduce_339(val, _values, result) click to toggle source

reduce 338 omitted

      # File lib/ruby_parser.rb, line 4667
4667: def _reduce_339(val, _values, result)
4668:                       val[0].delete_at 1 if val[0][1].nil? # HACK
4669:                     
4670:     result
4671: end
_reduce_341(val, _values, result) click to toggle source

reduce 340 omitted

      # File lib/ruby_parser.rb, line 4675
4675: def _reduce_341(val, _values, result)
4676:                       result = 0
4677:                     
4678:     result
4679: end
_reduce_342(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4681
4681: def _reduce_342(val, _values, result)
4682:                       result = 0
4683:                     
4684:     result
4685: end
_reduce_343(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4687
4687: def _reduce_343(val, _values, result)
4688:                       result = val[1]
4689:                     
4690:     result
4691: end
_reduce_344(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4693
4693: def _reduce_344(val, _values, result)
4694:                       self.env.extend :dynamic
4695:                     
4696:     result
4697: end
_reduce_345(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4699
4699: def _reduce_345(val, _values, result)
4700:                       result = self.env.dynamic.keys
4701:                     
4702:     result
4703: end
_reduce_346(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4705
4705: def _reduce_346(val, _values, result)
4706:                       vars   = val[2]
4707:                       body   = val[4]
4708:                       result = new_iter nil, vars, body
4709: 
4710:                       self.env.unextend
4711:                     
4712:     result
4713: end
_reduce_347(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4715
4715: def _reduce_347(val, _values, result)
4716:                       raise SyntaxError, "Both block arg and actual block given." if
4717:                         val[0] && val[0][0] == :blockpass
4718: 
4719:                       result = val[1]
4720:                       result.insert 1, val[0]
4721:                     
4722:     result
4723: end
_reduce_348(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4725
4725: def _reduce_348(val, _values, result)
4726:                       result = new_call val[0], val[2], val[3]
4727:                     
4728:     result
4729: end
_reduce_349(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4731
4731: def _reduce_349(val, _values, result)
4732:                       result = new_call val[0], val[2], val[3]
4733:                     
4734:     result
4735: end
_reduce_350(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4737
4737: def _reduce_350(val, _values, result)
4738:                       result = self.lexer.lineno
4739:                     
4740:     result
4741: end
_reduce_351(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4743
4743: def _reduce_351(val, _values, result)
4744:                       result = new_call nil, val[0].to_sym, val[2]
4745:                     
4746:     result
4747: end
_reduce_352(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4749
4749: def _reduce_352(val, _values, result)
4750:                       result = new_call val[0], val[2].to_sym, val[3]
4751:                     
4752:     result
4753: end
_reduce_353(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4755
4755: def _reduce_353(val, _values, result)
4756:                       result = new_call val[0], val[2].to_sym, val[3]
4757:                     
4758:     result
4759: end
_reduce_354(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4761
4761: def _reduce_354(val, _values, result)
4762:                       result = new_call val[0], val[2].to_sym
4763:                     
4764:     result
4765: end
_reduce_355(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4767
4767: def _reduce_355(val, _values, result)
4768:                       result = new_super val[1]
4769:                     
4770:     result
4771: end
_reduce_356(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4773
4773: def _reduce_356(val, _values, result)
4774:                       result = s(:zsuper)
4775:                     
4776:     result
4777: end
_reduce_357(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4779
4779: def _reduce_357(val, _values, result)
4780:                       self.env.extend :dynamic
4781:                       result = self.lexer.lineno
4782:                     
4783:     result
4784: end
_reduce_358(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4786
4786: def _reduce_358(val, _values, result)
4787:                       result = self.env.dynamic.keys
4788:                     
4789:     result
4790: end
_reduce_359(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4792
4792: def _reduce_359(val, _values, result)
4793:                       # REFACTOR
4794:                       args   = val[2]
4795:                       body   = val[4]
4796:                       result = new_iter nil, args, body
4797:                       self.env.unextend
4798:                       result.line = val[1]
4799:                     
4800:     result
4801: end
_reduce_36(val, _values, result) click to toggle source

reduce 35 omitted

      # File lib/ruby_parser.rb, line 3152
3152: def _reduce_36(val, _values, result)
3153:                       result = logop(:and, val[0], val[2])
3154:                     
3155:     result
3156: end
_reduce_360(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4803
4803: def _reduce_360(val, _values, result)
4804:                       self.env.extend :dynamic
4805:                       result = self.lexer.lineno
4806:                     
4807:     result
4808: end
_reduce_361(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4810
4810: def _reduce_361(val, _values, result)
4811:                       result = self.env.dynamic.keys
4812:                     
4813:     result
4814: end
_reduce_362(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4816
4816: def _reduce_362(val, _values, result)
4817:                       args = val[2]
4818:                       body = val[4]
4819:                       result = new_iter nil, args, body
4820:                       self.env.unextend
4821:                       result.line = val[1]
4822:                     
4823:     result
4824: end
_reduce_363(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4826
4826: def _reduce_363(val, _values, result)
4827:                       result = self.lexer.lineno
4828:                     
4829:     result
4830: end
_reduce_364(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4832
4832: def _reduce_364(val, _values, result)
4833:                       result = s(:when, val[2], val[4])
4834:                       result.line = val[1]
4835:                       result << val[5] if val[5]
4836:                     
4837:     result
4838: end
_reduce_366(val, _values, result) click to toggle source

reduce 365 omitted

      # File lib/ruby_parser.rb, line 4842
4842: def _reduce_366(val, _values, result)
4843:                       result = self.list_append val[0], s(:when, val[3], nil)
4844:                     
4845:     result
4846: end
_reduce_367(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4848
4848: def _reduce_367(val, _values, result)
4849:                       result = s(:array, s(:when, val[1], nil))
4850:                     
4851:     result
4852: end
_reduce_37(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3158
3158: def _reduce_37(val, _values, result)
3159:                       result = logop(:or, val[0], val[2])
3160:                     
3161:     result
3162: end
_reduce_370(val, _values, result) click to toggle source

reduce 369 omitted

      # File lib/ruby_parser.rb, line 4858
4858: def _reduce_370(val, _values, result)
4859:                       klasses, var, body, rest = val[1], val[2], val[4], val[5]
4860: 
4861:                       klasses ||= s(:array)
4862:                       klasses << node_assign(var, s(:gvar, :"$!")) if var
4863: 
4864:                       result = s(:resbody, klasses, body)
4865:                       result << rest if rest # UGH, rewritten above
4866:                     
4867:     result
4868: end
_reduce_371(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4870
4870: def _reduce_371(val, _values, result)
4871:                       result = nil
4872:                     
4873:     result
4874: end
_reduce_372(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4876
4876: def _reduce_372(val, _values, result)
4877:                       result = s(:array, val[0])
4878:                     
4879:     result
4880: end
_reduce_375(val, _values, result) click to toggle source

reduce 374 omitted

      # File lib/ruby_parser.rb, line 4886
4886: def _reduce_375(val, _values, result)
4887:                       result = val[1]
4888:                     
4889:     result
4890: end
_reduce_377(val, _values, result) click to toggle source

reduce 376 omitted

      # File lib/ruby_parser.rb, line 4894
4894: def _reduce_377(val, _values, result)
4895:                       if (val[1] != nil) then
4896:                         result = val[1]
4897:                       else
4898:                         result = s(:nil)
4899:                       end
4900:                     
4901:     result
4902: end
_reduce_379(val, _values, result) click to toggle source

reduce 378 omitted

      # File lib/ruby_parser.rb, line 4906
4906: def _reduce_379(val, _values, result)
4907:  result = s(:lit, val[0]) 
4908:     result
4909: end
_reduce_38(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3164
3164: def _reduce_38(val, _values, result)
3165:                       result = s(:not, val[1])
3166:                     
3167:     result
3168: end
_reduce_380(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4911
4911: def _reduce_380(val, _values, result)
4912:  result = s(:lit, val[0]) 
4913:     result
4914: end
_reduce_382(val, _values, result) click to toggle source

reduce 381 omitted

      # File lib/ruby_parser.rb, line 4918
4918: def _reduce_382(val, _values, result)
4919:                       val[0] = s(:dstr, val[0].value) if val[0][0] == :evstr
4920:                       result = val[0]
4921:                     
4922:     result
4923: end
_reduce_384(val, _values, result) click to toggle source

reduce 383 omitted

      # File lib/ruby_parser.rb, line 4927
4927: def _reduce_384(val, _values, result)
4928:                       result = self.literal_concat val[0], val[1]
4929:                     
4930:     result
4931: end
_reduce_385(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4933
4933: def _reduce_385(val, _values, result)
4934:                       result = val[1]
4935:                     
4936:     result
4937: end
_reduce_386(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4939
4939: def _reduce_386(val, _values, result)
4940:                       result = s(:str, val[0])
4941:                     
4942:     result
4943: end
_reduce_387(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4945
4945: def _reduce_387(val, _values, result)
4946:                       result = new_xstring val[1]
4947:                     
4948:     result
4949: end
_reduce_388(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4951
4951: def _reduce_388(val, _values, result)
4952:                       result = new_regexp val
4953:                     
4954:     result
4955: end
_reduce_389(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4957
4957: def _reduce_389(val, _values, result)
4958:                       result = s(:array)
4959:                     
4960:     result
4961: end
_reduce_39(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3170
3170: def _reduce_39(val, _values, result)
3171:                       result = s(:not, val[1])
3172:                     
3173:     result
3174: end
_reduce_390(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4963
4963: def _reduce_390(val, _values, result)
4964:                       result = val[1]
4965:                     
4966:     result
4967: end
_reduce_391(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4969
4969: def _reduce_391(val, _values, result)
4970:                       result = s(:array)
4971:                     
4972:     result
4973: end
_reduce_392(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4975
4975: def _reduce_392(val, _values, result)
4976:                       word = val[1][0] == :evstr ? s(:dstr, "", val[1]) : val[1]
4977:                       result = val[0] << word
4978:                     
4979:     result
4980: end
_reduce_394(val, _values, result) click to toggle source

reduce 393 omitted

      # File lib/ruby_parser.rb, line 4984
4984: def _reduce_394(val, _values, result)
4985:                       result = self.literal_concat val[0], val[1]
4986:                     
4987:     result
4988: end
_reduce_395(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4990
4990: def _reduce_395(val, _values, result)
4991:                       result = s(:array)
4992:                     
4993:     result
4994: end
_reduce_396(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4996
4996: def _reduce_396(val, _values, result)
4997:                       result = val[1]
4998:                     
4999:     result
5000: end
_reduce_397(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5002
5002: def _reduce_397(val, _values, result)
5003:                       result = s(:array)
5004:                     
5005:     result
5006: end
_reduce_398(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5008
5008: def _reduce_398(val, _values, result)
5009:                       result = val[0] << s(:str, val[1])
5010:                     
5011:     result
5012: end
_reduce_399(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5014
5014: def _reduce_399(val, _values, result)
5015:                       result = s(:str, "")
5016:                     
5017:     result
5018: end
_reduce_4(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2968
2968: def _reduce_4(val, _values, result)
2969:                       result = new_compstmt val
2970:                     
2971:     result
2972: end
_reduce_400(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5020
5020: def _reduce_400(val, _values, result)
5021:                       result = literal_concat(val[0], val[1])
5022:                     
5023:     result
5024: end
_reduce_401(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5026
5026: def _reduce_401(val, _values, result)
5027:                       result = nil
5028:                     
5029:     result
5030: end
_reduce_402(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5032
5032: def _reduce_402(val, _values, result)
5033:                       result = literal_concat(val[0], val[1])
5034:                     
5035:     result
5036: end
_reduce_403(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5038
5038: def _reduce_403(val, _values, result)
5039:                       result = s(:str, val[0])
5040:                     
5041:     result
5042: end
_reduce_404(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5044
5044: def _reduce_404(val, _values, result)
5045:                       result = lexer.lex_strterm
5046:                       lexer.lex_strterm = nil
5047:                       lexer.lex_state = :expr_beg
5048:                     
5049:     result
5050: end
_reduce_405(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5052
5052: def _reduce_405(val, _values, result)
5053:                       lexer.lex_strterm = val[1]
5054:                       result = s(:evstr, val[2])
5055:                     
5056:     result
5057: end
_reduce_406(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5059
5059: def _reduce_406(val, _values, result)
5060:                       result = lexer.lex_strterm
5061:                       lexer.lex_strterm = nil
5062:                       lexer.lex_state = :expr_beg
5063:                       lexer.cond.push false
5064:                       lexer.cmdarg.push false
5065:                     
5066:     result
5067: end
_reduce_407(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5069
5069: def _reduce_407(val, _values, result)
5070:                       lexer.lex_strterm = val[1]
5071:                       lexer.cond.lexpop
5072:                       lexer.cmdarg.lexpop
5073: 
5074:                       case val[2]
5075:                       when Sexp then
5076:                         case val[2][0]
5077:                         when :str, :dstr, :evstr then
5078:                           result = val[2]
5079:                         else
5080:                           result = s(:evstr, val[2])
5081:                         end
5082:                       when nil then
5083:                         result = s(:evstr)
5084:                       else
5085:                         raise "unknown rescue body: #{val[2].inspect}"
5086:                       end
5087:                     
5088:     result
5089: end
_reduce_408(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5091
5091: def _reduce_408(val, _values, result)
5092:  result = s(:gvar, val[0].to_sym) 
5093:     result
5094: end
_reduce_409(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5096
5096: def _reduce_409(val, _values, result)
5097:  result = s(:ivar, val[0].to_sym) 
5098:     result
5099: end
_reduce_41(val, _values, result) click to toggle source

reduce 40 omitted

      # File lib/ruby_parser.rb, line 3178
3178: def _reduce_41(val, _values, result)
3179:                       result = value_expr(val[0])
3180:                     
3181:     result
3182: end
_reduce_410(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5101
5101: def _reduce_410(val, _values, result)
5102:  result = s(:cvar, val[0].to_sym) 
5103:     result
5104: end
_reduce_412(val, _values, result) click to toggle source

reduce 411 omitted

      # File lib/ruby_parser.rb, line 5108
5108: def _reduce_412(val, _values, result)
5109:                       lexer.lex_state = :expr_end
5110:                       result = val[1].to_sym
5111:                     
5112:     result
5113: end
_reduce_413(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5115
5115: def _reduce_413(val, _values, result)
5116:                       result = val[0].to_sym
5117:                     
5118:     result
5119: end
_reduce_418(val, _values, result) click to toggle source

reduce 417 omitted

      # File lib/ruby_parser.rb, line 5129
5129: def _reduce_418(val, _values, result)
5130:                       lexer.lex_state = :expr_end
5131:                       result = val[1]
5132: 
5133:                       yyerror "empty symbol literal" if
5134:                         result.nil? or result.empty?
5135: 
5136:                       case result[0]
5137:                       when :dstr then
5138:                         result[0] = :dsym
5139:                       when :str then
5140:                         result = s(:lit, result.last.intern)
5141:                       else
5142:                         result = s(:dsym, "", result)
5143:                       end
5144:                     
5145:     result
5146: end
_reduce_421(val, _values, result) click to toggle source

reduce 420 omitted

      # File lib/ruby_parser.rb, line 5152
5152: def _reduce_421(val, _values, result)
5153:                       result = -val[1] # TODO: pt_testcase
5154:                     
5155:     result
5156: end
_reduce_422(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5158
5158: def _reduce_422(val, _values, result)
5159:                       result = -val[1] # TODO: pt_testcase
5160:                     
5161:     result
5162: end
_reduce_428(val, _values, result) click to toggle source

reduce 427 omitted

      # File lib/ruby_parser.rb, line 5174
5174: def _reduce_428(val, _values, result)
5175:  result = :nil      
5176:     result
5177: end
_reduce_429(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5179
5179: def _reduce_429(val, _values, result)
5180:  result = :self     
5181:     result
5182: end
_reduce_430(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5184
5184: def _reduce_430(val, _values, result)
5185:  result = :true     
5186:     result
5187: end
_reduce_431(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5189
5189: def _reduce_431(val, _values, result)
5190:  result = :false    
5191:     result
5192: end
_reduce_432(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5194
5194: def _reduce_432(val, _values, result)
5195:  result = :__FILE__ 
5196:     result
5197: end
_reduce_433(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5199
5199: def _reduce_433(val, _values, result)
5200:  result = :__LINE__ 
5201:     result
5202: end
_reduce_434(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5204
5204: def _reduce_434(val, _values, result)
5205:                       result = self.gettable val[0]
5206:                     
5207:     result
5208: end
_reduce_435(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5210
5210: def _reduce_435(val, _values, result)
5211:                       result = self.assignable val[0]
5212:                     
5213:     result
5214: end
_reduce_436(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5216
5216: def _reduce_436(val, _values, result)
5217:  result = s(:nth_ref,  val[0]) 
5218:     result
5219: end
_reduce_437(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5221
5221: def _reduce_437(val, _values, result)
5222:  result = s(:back_ref, val[0]) 
5223:     result
5224: end
_reduce_438(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5226
5226: def _reduce_438(val, _values, result)
5227:                       result = nil
5228:                     
5229:     result
5230: end
_reduce_439(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5232
5232: def _reduce_439(val, _values, result)
5233:                       lexer.lex_state = :expr_beg
5234:                     
5235:     result
5236: end
_reduce_44(val, _values, result) click to toggle source

reduce 43 omitted

      # File lib/ruby_parser.rb, line 3188
3188: def _reduce_44(val, _values, result)
3189:                       result = s(:return, ret_args(val[1]))
3190:                     
3191:     result
3192: end
_reduce_440(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5238
5238: def _reduce_440(val, _values, result)
5239:                       result = val[2]
5240:                     
5241:     result
5242: end
_reduce_441(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5244
5244: def _reduce_441(val, _values, result)
5245:                       yyerrok
5246:                       result = nil
5247:                     
5248:     result
5249: end
_reduce_442(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5251
5251: def _reduce_442(val, _values, result)
5252:                       result = val[1]
5253:                       lexer.lex_state = :expr_beg
5254:                     
5255:     result
5256: end
_reduce_443(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5258
5258: def _reduce_443(val, _values, result)
5259:                       result = val[0]
5260:                     
5261:     result
5262: end
_reduce_444(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5264
5264: def _reduce_444(val, _values, result)
5265:                       result = args val[0], val[2], val[4], val[5]
5266:                     
5267:     result
5268: end
_reduce_445(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5270
5270: def _reduce_445(val, _values, result)
5271:                       result = args val[0], val[2],    nil, val[3]
5272:                     
5273:     result
5274: end
_reduce_446(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5276
5276: def _reduce_446(val, _values, result)
5277:                       result = args val[0],    nil, val[2], val[3]
5278:                     
5279:     result
5280: end
_reduce_447(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5282
5282: def _reduce_447(val, _values, result)
5283:                       result = args val[0],    nil,    nil, val[1]
5284:                     
5285:     result
5286: end
_reduce_448(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5288
5288: def _reduce_448(val, _values, result)
5289:                       result = args    nil, val[0], val[2], val[3]
5290:                     
5291:     result
5292: end
_reduce_449(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5294
5294: def _reduce_449(val, _values, result)
5295:                       result = args    nil, val[0],    nil, val[1]
5296:                     
5297:     result
5298: end
_reduce_45(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3194
3194: def _reduce_45(val, _values, result)
3195:                       result = s(:break, ret_args(val[1]))
3196:                     
3197:     result
3198: end
_reduce_450(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5300
5300: def _reduce_450(val, _values, result)
5301:                       result = args    nil,    nil, val[0], val[1]
5302:                     
5303:     result
5304: end
_reduce_451(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5306
5306: def _reduce_451(val, _values, result)
5307:                       result = args    nil,    nil,    nil, val[0]
5308:                     
5309:     result
5310: end
_reduce_452(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5312
5312: def _reduce_452(val, _values, result)
5313:                       result = args    nil,    nil,    nil,    nil
5314:                     
5315:     result
5316: end
_reduce_453(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5318
5318: def _reduce_453(val, _values, result)
5319:                       yyerror "formal argument cannot be a constant: #{val[0]}"
5320:                     
5321:     result
5322: end
_reduce_454(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5324
5324: def _reduce_454(val, _values, result)
5325:                       yyerror "formal argument cannot be an instance variable"
5326:                     
5327:     result
5328: end
_reduce_455(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5330
5330: def _reduce_455(val, _values, result)
5331:                       yyerror "formal argument cannot be a class variable"
5332:                     
5333:     result
5334: end
_reduce_456(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5336
5336: def _reduce_456(val, _values, result)
5337:                       identifier = val[0].to_sym
5338:                       self.env[identifier] = :lvar
5339: 
5340:                       result = val[0]
5341:                     
5342:     result
5343: end
_reduce_457(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5345
5345: def _reduce_457(val, _values, result)
5346:                       result = s(:args)
5347:                       result << val[0].to_sym
5348:                     
5349:     result
5350: end
_reduce_458(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5352
5352: def _reduce_458(val, _values, result)
5353:                       val[0] << val[2].to_sym
5354:                       result = val[0]
5355:                     
5356:     result
5357: end
_reduce_459(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5359
5359: def _reduce_459(val, _values, result)
5360:                       result = self.assignable val[0], val[2]
5361:                       # TODO: detect duplicate names
5362:                     
5363:     result
5364: end
_reduce_46(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3200
3200: def _reduce_46(val, _values, result)
3201:                       result = s(:next, ret_args(val[1]))
3202:                     
3203:     result
3204: end
_reduce_460(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5366
5366: def _reduce_460(val, _values, result)
5367:                       result = s(:block, val[0])
5368:                     
5369:     result
5370: end
_reduce_461(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5372
5372: def _reduce_461(val, _values, result)
5373:                       result = self.append_to_block val[0], val[2]
5374:                     
5375:     result
5376: end
_reduce_464(val, _values, result) click to toggle source

reduce 463 omitted

      # File lib/ruby_parser.rb, line 5382
5382: def _reduce_464(val, _values, result)
5383:                       # TODO: differs from parse.y - needs tests
5384:                       name = val[1].to_sym
5385:                       self.assignable name
5386:                       result = :"*#{name}"
5387:                     
5388:     result
5389: end
_reduce_465(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5391
5391: def _reduce_465(val, _values, result)
5392:                       name = :"*"
5393:                       self.env[name] = :lvar
5394:                       result = name
5395:                     
5396:     result
5397: end
_reduce_468(val, _values, result) click to toggle source

reduce 467 omitted

      # File lib/ruby_parser.rb, line 5403
5403: def _reduce_468(val, _values, result)
5404:                       identifier = val[1].to_sym
5405: 
5406:                       self.env[identifier] = :lvar
5407:                       result = s(:block_arg, identifier.to_sym)
5408:                     
5409:     result
5410: end
_reduce_469(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5412
5412: def _reduce_469(val, _values, result)
5413:                       result = val[1]
5414:                     
5415:     result
5416: end
_reduce_470(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5418
5418: def _reduce_470(val, _values, result)
5419:                       result = nil
5420:                     
5421:     result
5422: end
_reduce_472(val, _values, result) click to toggle source

reduce 471 omitted

      # File lib/ruby_parser.rb, line 5426
5426: def _reduce_472(val, _values, result)
5427:                       lexer.lex_state = :expr_beg
5428:                     
5429:     result
5430: end
_reduce_473(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5432
5432: def _reduce_473(val, _values, result)
5433:                       result = val[2]
5434:                       yyerror "Can't define single method for literals." if
5435:                         result[0] == :lit
5436:                     
5437:     result
5438: end
_reduce_474(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5440
5440: def _reduce_474(val, _values, result)
5441:                       result = s(:array)
5442:                     
5443:     result
5444: end
_reduce_475(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5446
5446: def _reduce_475(val, _values, result)
5447:                       result = val[0]
5448:                     
5449:     result
5450: end
_reduce_476(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5452
5452: def _reduce_476(val, _values, result)
5453:                       size = val[0].size
5454:                       if (size % 2 != 1) then # != 1 because of leading :array
5455:                         yyerror "Odd number (#{size}) list for Hash. #{val[0].inspect}"
5456:                       end
5457:                       result = val[0]
5458:                     
5459:     result
5460: end
_reduce_478(val, _values, result) click to toggle source

reduce 477 omitted

      # File lib/ruby_parser.rb, line 5464
5464: def _reduce_478(val, _values, result)
5465:                       list = val[0].dup
5466:                       more = val[2][1..1]
5467:                       list.push(*more) unless more.empty?
5468:                       result = list
5469:                     
5470:     result
5471: end
_reduce_479(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5473
5473: def _reduce_479(val, _values, result)
5474:                       result = s(:array, val[0], val[2])
5475:                     
5476:     result
5477: end
_reduce_48(val, _values, result) click to toggle source

reduce 47 omitted

      # File lib/ruby_parser.rb, line 3208
3208: def _reduce_48(val, _values, result)
3209:                       result = new_call val[0], val[2], val[3]
3210:                     
3211:     result
3212: end
_reduce_49(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3214
3214: def _reduce_49(val, _values, result)
3215:                       result = new_call val[0], val[2], val[3]
3216:                     
3217:     result
3218: end
_reduce_499(val, _values, result) click to toggle source

reduce 498 omitted

      # File lib/ruby_parser.rb, line 5517
5517: def _reduce_499(val, _values, result)
5518:  yyerrok 
5519:     result
5520: end
_reduce_50(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3220
3220: def _reduce_50(val, _values, result)
3221:                       self.env.extend(:dynamic)
3222:                       result = self.lexer.lineno
3223:                     
3224:     result
3225: end
_reduce_502(val, _values, result) click to toggle source

reduce 501 omitted

      # File lib/ruby_parser.rb, line 5526
5526: def _reduce_502(val, _values, result)
5527:  yyerrok 
5528:     result
5529: end
_reduce_503(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5531
5531: def _reduce_503(val, _values, result)
5532:  result = nil 
5533:     result
5534: end
_reduce_504(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5536
5536: def _reduce_504(val, _values, result)
5537:  result = nil 
5538:     result
5539: end
_reduce_51(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3227
3227: def _reduce_51(val, _values, result)
3228:                       result = self.env.dynamic.keys
3229:                     
3230:     result
3231: end
_reduce_52(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3233
3233: def _reduce_52(val, _values, result)
3234:                       result = new_iter nil, val[2], val[4]
3235:                       self.env.unextend
3236:                     
3237:     result
3238: end
_reduce_53(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3240
3240: def _reduce_53(val, _values, result)
3241:                       result = new_call nil, val[0].to_sym, val[1]
3242:                     
3243:     result
3244: end
_reduce_54(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3246
3246: def _reduce_54(val, _values, result)
3247:                       result = new_call nil, val[0].to_sym, val[1]
3248:                       if val[2] then
3249:                         if result[0] == :block_pass then
3250:                           raise "both block arg and actual block given"
3251:                         end
3252:                         result, operation = val[2], result
3253:                         result.insert 1, operation
3254:                       end
3255:                     
3256:     result
3257: end
_reduce_55(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3259
3259: def _reduce_55(val, _values, result)
3260:                       result = new_call val[0], val[2].to_sym, val[3]
3261:                     
3262:     result
3263: end
_reduce_56(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3265
3265: def _reduce_56(val, _values, result)
3266:                       result = new_call val[0], val[2].to_sym, val[3]
3267:                     
3268:     result
3269: end
_reduce_57(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3271
3271: def _reduce_57(val, _values, result)
3272:                       result = new_call val[0], val[2].to_sym, val[3]
3273:                     
3274:     result
3275: end
_reduce_58(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3277
3277: def _reduce_58(val, _values, result)
3278:                       result = new_call val[0], val[2].to_sym, val[3]
3279:                       if val[4] then
3280:                         if result[0] == :block_pass then # REFACTOR
3281:                           raise "both block arg and actual block given"
3282:                         end
3283:                         val[2] << result
3284:                         result = val[2]
3285:                       end
3286:                     
3287:     result
3288: end
_reduce_59(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3290
3290: def _reduce_59(val, _values, result)
3291:                       result = new_super val[1]
3292:                     
3293:     result
3294: end
_reduce_60(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3296
3296: def _reduce_60(val, _values, result)
3297:                       result = new_yield val[1]
3298:                     
3299:     result
3300: end
_reduce_62(val, _values, result) click to toggle source

reduce 61 omitted

      # File lib/ruby_parser.rb, line 3304
3304: def _reduce_62(val, _values, result)
3305:                       result = val[1]
3306:                     
3307:     result
3308: end
_reduce_64(val, _values, result) click to toggle source

reduce 63 omitted

      # File lib/ruby_parser.rb, line 3312
3312: def _reduce_64(val, _values, result)
3313:                       result = s(:masgn, s(:array, val[1]))
3314:                     
3315:     result
3316: end
_reduce_65(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3318
3318: def _reduce_65(val, _values, result)
3319:                       result = s(:masgn, val[0])
3320:                     
3321:     result
3322: end
_reduce_66(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3324
3324: def _reduce_66(val, _values, result)
3325:                       result = s(:masgn, val[0] << val[1].compact)
3326:                     
3327:     result
3328: end
_reduce_67(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3330
3330: def _reduce_67(val, _values, result)
3331:                       result = s(:masgn, val[0] << s(:splat, val[2]))
3332:                     
3333:     result
3334: end
_reduce_68(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3336
3336: def _reduce_68(val, _values, result)
3337:                       result = s(:masgn, val[0] << s(:splat))
3338:                     
3339:     result
3340: end
_reduce_69(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3342
3342: def _reduce_69(val, _values, result)
3343:                       result = s(:masgn, s(:array, s(:splat, val[1])))
3344:                     
3345:     result
3346: end
_reduce_7(val, _values, result) click to toggle source

reduce 6 omitted

      # File lib/ruby_parser.rb, line 2978
2978: def _reduce_7(val, _values, result)
2979:                       result = self.block_append val[0], val[2]
2980:                     
2981:     result
2982: end
_reduce_70(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3348
3348: def _reduce_70(val, _values, result)
3349:                       result = s(:masgn, s(:array, s(:splat)))
3350:                     
3351:     result
3352: end
_reduce_72(val, _values, result) click to toggle source

reduce 71 omitted

      # File lib/ruby_parser.rb, line 3356
3356: def _reduce_72(val, _values, result)
3357:                       result = val[1]
3358:                     
3359:     result
3360: end
_reduce_73(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3362
3362: def _reduce_73(val, _values, result)
3363:                       result = s(:array, val[0])
3364:                     
3365:     result
3366: end
_reduce_74(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3368
3368: def _reduce_74(val, _values, result)
3369:                       result = val[0] << val[1].compact
3370:                     
3371:     result
3372: end
_reduce_75(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3374
3374: def _reduce_75(val, _values, result)
3375:                       result = self.assignable val[0]
3376:                     
3377:     result
3378: end
_reduce_76(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3380
3380: def _reduce_76(val, _values, result)
3381:                       result = self.aryset val[0], val[2]
3382:                     
3383:     result
3384: end
_reduce_77(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3386
3386: def _reduce_77(val, _values, result)
3387:                       result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
3388:                     
3389:     result
3390: end
_reduce_78(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3392
3392: def _reduce_78(val, _values, result)
3393:                       result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
3394:                     
3395:     result
3396: end
_reduce_79(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3398
3398: def _reduce_79(val, _values, result)
3399:                       result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
3400:                     
3401:     result
3402: end
_reduce_8(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2984
2984: def _reduce_8(val, _values, result)
2985:                       result = val[1]
2986:                     
2987:     result
2988: end
_reduce_80(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3404
3404: def _reduce_80(val, _values, result)
3405:                       if (self.in_def || self.in_single > 0) then
3406:                         yyerror "dynamic constant assignment"
3407:                       end
3408: 
3409:                       result = s(:const, s(:colon2, val[0], val[2].to_sym), nil)
3410:                     
3411:     result
3412: end
_reduce_81(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3414
3414: def _reduce_81(val, _values, result)
3415:                       if (self.in_def || self.in_single > 0) then
3416:                         yyerror "dynamic constant assignment"
3417:                       end
3418: 
3419:                       result = s(:const, nil, s(:colon3, val[1].to_sym))
3420:                     
3421:     result
3422: end
_reduce_82(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3424
3424: def _reduce_82(val, _values, result)
3425:                       self.backref_assign_error val[0]
3426:                     
3427:     result
3428: end
_reduce_83(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3430
3430: def _reduce_83(val, _values, result)
3431:                       result = self.assignable val[0]
3432:                     
3433:     result
3434: end
_reduce_84(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3436
3436: def _reduce_84(val, _values, result)
3437:                       result = self.aryset val[0], val[2]
3438:                     
3439:     result
3440: end
_reduce_85(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3442
3442: def _reduce_85(val, _values, result)
3443:                       result = s(:attrasgn, val[0], :"#{val[2]}=")
3444:                     
3445:     result
3446: end
_reduce_86(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3448
3448: def _reduce_86(val, _values, result)
3449:                       result = s(:attrasgn, val[0], :"#{val[2]}=")
3450:                     
3451:     result
3452: end
_reduce_87(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3454
3454: def _reduce_87(val, _values, result)
3455:                       result = s(:attrasgn, val[0], :"#{val[2]}=")
3456:                     
3457:     result
3458: end
_reduce_88(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3460
3460: def _reduce_88(val, _values, result)
3461:                       if (self.in_def || self.in_single > 0) then
3462:                         yyerror "dynamic constant assignment"
3463:                       end
3464: 
3465:                       result = s(:const, s(:colon2, val[0], val[2].to_sym))
3466:                     
3467:     result
3468: end
_reduce_89(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3470
3470: def _reduce_89(val, _values, result)
3471:                       if (self.in_def || self.in_single > 0) then
3472:                         yyerror "dynamic constant assignment"
3473:                       end
3474: 
3475:                       result = s(:const, s(:colon3, val[1].to_sym))
3476:                     
3477:     result
3478: end
_reduce_9(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2990
2990: def _reduce_9(val, _values, result)
2991:                       lexer.lex_state = :expr_fname
2992:                       result = self.lexer.lineno
2993:                     
2994:     result
2995: end
_reduce_90(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3480
3480: def _reduce_90(val, _values, result)
3481:                       self.backref_assign_error val[0]
3482:                     
3483:     result
3484: end
_reduce_91(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3486
3486: def _reduce_91(val, _values, result)
3487:                       yyerror "class/module name must be CONSTANT"
3488:                     
3489:     result
3490: end
_reduce_93(val, _values, result) click to toggle source

reduce 92 omitted

      # File lib/ruby_parser.rb, line 3494
3494: def _reduce_93(val, _values, result)
3495:                       result = s(:colon3, val[1].to_sym)
3496:                     
3497:     result
3498: end
_reduce_94(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3500
3500: def _reduce_94(val, _values, result)
3501:                       result = val[0].to_sym
3502:                     
3503:     result
3504: end
_reduce_95(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3506
3506: def _reduce_95(val, _values, result)
3507:                       result = s(:colon2, val[0], val[2].to_sym)
3508:                     
3509:     result
3510: end
_reduce_99(val, _values, result) click to toggle source

reduce 98 omitted

      # File lib/ruby_parser.rb, line 3518
3518: def _reduce_99(val, _values, result)
3519:                       lexer.lex_state = :expr_end
3520:                       result = val[0]
3521:                     
3522:     result
3523: end
_reduce_none(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5541
5541: def _reduce_none(val, _values, result)
5542:   val[0]
5543: end
append_to_block(head, tail) click to toggle source
     # File lib/ruby_parser_extras.rb, line 123
123:   def append_to_block head, tail # FIX: wtf is this?!? switch to block_append
124:     return head if tail.nil?
125:     return tail if head.nil?
126: 
127:     head = s(:block, head) unless head.node_type == :block
128:     head << tail
129:     head
130:   end
arg_add(node1, node2) click to toggle source
     # File lib/ruby_parser_extras.rb, line 132
132:   def arg_add(node1, node2) # TODO: nuke
133:     return s(:arglist, node2) unless node1
134: 
135:     node1[0] = :arglist if node1[0] == :array
136:     return node1 << node2 if node1[0] == :arglist
137: 
138:     return s(:arglist, node1, node2)
139:   end
arg_blk_pass(node1, node2) click to toggle source
     # File lib/ruby_parser_extras.rb, line 141
141:   def arg_blk_pass node1, node2 # TODO: nuke
142:     node1 = s(:arglist, node1) unless [:arglist, :array].include? node1.first
143:     node1 << node2 if node2
144:     node1
145:   end
arg_concat(node1, node2) click to toggle source
     # File lib/ruby_parser_extras.rb, line 147
147:   def arg_concat node1, node2 # TODO: nuke
148:     raise "huh" unless node2
149:     node1 << s(:splat, node2).compact
150:     node1
151:   end
args(arg, optarg, rest_arg, block_arg) click to toggle source
     # File lib/ruby_parser_extras.rb, line 153
153:   def args arg, optarg, rest_arg, block_arg
154:     arg ||= s(:args)
155: 
156:     result = arg
157:     if optarg then
158:       optarg[1..1].each do |lasgn| # FIX clean sexp iter
159:         raise "wtf? #{lasgn.inspect}" unless lasgn[0] == :lasgn
160:         result << lasgn[1]
161:       end
162:     end
163: 
164:     result << rest_arg  if rest_arg
165:     result << :"&#{block_arg.last}" if block_arg
166:     result << optarg    if optarg # TODO? huh - processed above as well
167: 
168:     result
169:   end
aryset(receiver, index) click to toggle source
     # File lib/ruby_parser_extras.rb, line 171
171:   def aryset receiver, index
172:     index[0] = :arglist if index[0] == :array
173:     s(:attrasgn, receiver, :"[]=", index)
174:   end
assignable(lhs, value = nil) click to toggle source
     # File lib/ruby_parser_extras.rb, line 176
176:   def assignable(lhs, value = nil)
177:     id = lhs.to_sym
178:     id = id.to_sym if Sexp === id
179: 
180:     raise SyntaxError, "Can't change the value of #{id}" if
181:       id.to_s =~ /^(?:self|nil|true|false|__LINE__|__FILE__)$/
182: 
183:     result = case id.to_s
184:              when /^@@/ then
185:                asgn = in_def || in_single > 0
186:                s((asgn ? :cvasgn : :cvdecl), id)
187:              when /^@/ then
188:                s(:iasgn, id)
189:              when /^\$/ then
190:                s(:gasgn, id)
191:              when /^[A-Z]/ then
192:                s(:cdecl, id)
193:              else
194:                case self.env[id]
195:                when :lvar then
196:                  s(:lasgn, id)
197:                when :dvar, nil then
198:                  if self.env.current[id] == :dvar then
199:                    s(:lasgn, id)
200:                  elsif self.env[id] == :dvar then
201:                    self.env.use(id)
202:                    s(:lasgn, id)
203:                  elsif ! self.env.dynamic? then
204:                    s(:lasgn, id)
205:                  else
206:                    s(:lasgn, id)
207:                  end
208:                else
209:                  raise "wtf? unknown type: #{self.env[id]}"
210:                end
211:              end
212: 
213:     self.env[id] ||= :lvar
214: 
215:     result << value if value
216: 
217:     return result
218:   end
block_append(head, tail, strip_tail_block=false) click to toggle source
     # File lib/ruby_parser_extras.rb, line 220
220:   def block_append(head, tail, strip_tail_block=false)
221:     return head unless tail
222:     return tail unless head
223: 
224:     case head[0]
225:     when :lit, :str then
226:       return tail
227:     end
228: 
229:     line = [head.line, tail.line].compact.min
230: 
231:     head = remove_begin(head)
232:     head = s(:block, head) unless head[0] == :block
233: 
234:     if strip_tail_block and Sexp === tail and tail[0] == :block then
235:       head.push(*tail.values)
236:     else
237:       head << tail
238:     end
239: 
240:     head.line = line
241:     head
242:   end
cond(node) click to toggle source
     # File lib/ruby_parser_extras.rb, line 244
244:   def cond node
245:     return nil if node.nil?
246:     node = value_expr node
247: 
248:     case node.first
249:     when :lit then
250:       if Regexp === node.last then
251:         return s(:match, node)
252:       else
253:         return node
254:       end
255:     when :and then
256:       return s(:and, cond(node[1]), cond(node[2]))
257:     when :or then
258:       return s(:or,  cond(node[1]), cond(node[2]))
259:     when :dot2 then
260:       label = "flip#{node.hash}"
261:       env[label] = :lvar
262:       return s(:flip2, node[1], node[2])
263:     when :dot3 then
264:       label = "flip#{node.hash}"
265:       env[label] = :lvar
266:       return s(:flip3, node[1], node[2])
267:     else
268:       return node
269:     end
270:   end
do_parse() click to toggle source

for pure ruby systems only

     # File lib/ruby_parser_extras.rb, line 275
275:   def do_parse
276:     _racc_do_parse_rb(_racc_setup, false)
277:   end
get_match_node(lhs, rhs) click to toggle source
     # File lib/ruby_parser_extras.rb, line 279
279:   def get_match_node lhs, rhs # TODO: rename to new_match
280:     if lhs then
281:       case lhs[0]
282:       when :dregx, :dregx_once then
283:         return s(:match2, lhs, rhs).line(lhs.line)
284:       when :lit then
285:         return s(:match2, lhs, rhs).line(lhs.line) if Regexp === lhs.last
286:       end
287:     end
288: 
289:     if rhs then
290:       case rhs[0]
291:       when :dregx, :dregx_once then
292:         return s(:match3, rhs, lhs).line(lhs.line)
293:       when :lit then
294:         return s(:match3, rhs, lhs).line(lhs.line) if Regexp === rhs.last
295:       end
296:     end
297: 
298:     return s(:call, lhs, :"=~", s(:arglist, rhs)).line(lhs.line)
299:   end
gettable(id) click to toggle source
     # File lib/ruby_parser_extras.rb, line 301
301:   def gettable(id)
302:     raise "no: #{id.inspect}" if Sexp === id
303:     id = id.to_sym if Sexp   === id # HACK
304:     id = id.to_sym if String === id # HACK
305: 
306:     return s(:self)                  if id == :self
307:     return s(:nil)                   if id == :nil
308:     return s(:true)                  if id == :true
309:     return s(:false)                 if id == :false
310:     return s(:str, self.file)        if id == :"__FILE__"
311:     return s(:lit, lexer.src.current_line) if id == :"__LINE__"
312: 
313:     result = case id.to_s
314:              when /^@@/ then
315:                s(:cvar, id)
316:              when /^@/ then
317:                s(:ivar, id)
318:              when /^\$/ then
319:                s(:gvar, id)
320:              when /^[A-Z]/ then
321:                s(:const, id)
322:              else
323:                type = env[id]
324:                if type then
325:                  s(type, id)
326:                elsif env.dynamic? and :dvar == env[id] then
327:                  s(:lvar, id)
328:                else
329:                  s(:call, nil, id, s(:arglist))
330:                end
331:              end
332: 
333:     return result if result
334: 
335:     raise "identifier #{id.inspect} is not valid"
336:   end
list_append(list, item) click to toggle source
     # File lib/ruby_parser_extras.rb, line 348
348:   def list_append list, item # TODO: nuke me *sigh*
349:     return s(:array, item) unless list
350:     list = s(:array, list) unless Sexp === list && list.first == :array
351:     list << item
352:   end
list_prepend(item, list) click to toggle source
     # File lib/ruby_parser_extras.rb, line 354
354:   def list_prepend item, list # TODO: nuke me *sigh*
355:     list = s(:array, list) unless Sexp === list && list[0] == :array
356:     list.insert 1, item
357:     list
358:   end
literal_concat(head, tail) click to toggle source
     # File lib/ruby_parser_extras.rb, line 360
360:   def literal_concat head, tail
361:     return tail unless head
362:     return head unless tail
363: 
364:     htype, ttype = head[0], tail[0]
365: 
366:     head = s(:dstr, '', head) if htype == :evstr
367: 
368:     case ttype
369:     when :str then
370:       if htype == :str
371:         head[1] << tail[1]
372:       elsif htype == :dstr and head.size == 2 then
373:         head[1] << tail[1]
374:       else
375:         head << tail
376:       end
377:     when :dstr then
378:       if htype == :str then
379:         tail[1] = head[1] + tail[1]
380:         head = tail
381:       else
382:         tail[0] = :array
383:         tail[1] = s(:str, tail[1])
384:         tail.delete_at 1 if tail[1] == s(:str, '')
385: 
386:         head.push(*tail[1..1])
387:       end
388:     when :evstr then
389:       head[0] = :dstr if htype == :str
390:       if head.size == 2 and tail.size > 1 and tail[1][0] == :str then
391:         head[1] << tail[1][1]
392:         head[0] = :str if head.size == 2 # HACK ?
393:       else
394:         head.push(tail)
395:       end
396:     else
397:       x = [head, tail]
398:       raise "unknown type: #{x.inspect}"
399:     end
400: 
401:     return head
402:   end
logop(type, left, right) click to toggle source
     # File lib/ruby_parser_extras.rb, line 404
404:   def logop(type, left, right) # TODO: rename logical_op
405:     left = value_expr left
406: 
407:     if left and left[0] == type and not left.paren then
408:       node, second = left, nil
409: 
410:       while (second = node[2]) && second[0] == type and not second.paren do
411:         node = second
412:       end
413: 
414:       node[2] = s(type, second, right)
415: 
416:       return left
417:     end
418: 
419:     return s(type, left, right)
420:   end
421: 
422:   def new_aref val
423:     val[2] ||= s(:arglist)
424:     val[2][0] = :arglist if val[2][0] == :array # REFACTOR
425:     if val[0].node_type == :self then
426:       result = new_call nil, :"[]", val[2]
427:     else
428:       result = new_call val[0], :"[]", val[2]
429:     end
430:     result
431:   end
432: 
433:   def new_body val
434:     result = val[0]
435: 
436:     if val[1] then
437:       result = s(:rescue)
438:       result << val[0] if val[0]
439: 
440:       resbody = val[1]
441: 
442:       while resbody do
443:         result << resbody
444:         resbody = resbody.resbody(true)
445:       end
446: 
447:       result << val[2] if val[2]
448: 
449:       result.line = (val[0] || val[1]).line
450:     elsif not val[2].nil? then
451:       warning("else without rescue is useless")
452:       result = block_append(result, val[2])
453:     end
454: 
455:     result = s(:ensure, result, val[3]).compact if val[3]
456:     return result
457:   end
458: 
459:   def new_call recv, meth, args = nil
460:     result = s(:call, recv, meth)
461:     result.line = recv.line if recv
462: 
463:     args ||= s(:arglist)
464:     args[0] = :arglist if args.first == :array
465:     args = s(:arglist, args) unless args.first == :arglist
466:     result << args
467:     result
468:   end
469: 
470:   def new_case expr, body
471:     result = s(:case, expr)
472:     line = (expr || body).line
473: 
474:     while body and body.node_type == :when
475:       result << body
476:       body = body.delete_at 3
477:     end
478: 
479:     # else
480:     body = nil if body == s(:block)
481:     result << body
482: 
483:     result.line = line
484:     result
485:   end
486: 
487:   def new_class val
488:     line, path, superclass, body = val[1], val[2], val[3], val[5]
489:     scope = s(:scope, body).compact
490:     result = s(:class, path, superclass, scope)
491:     result.line = line
492:     result.comments = self.comments.pop
493:     result
494:   end
495: 
496:   def new_compstmt val
497:     result = void_stmts(val[0])
498:     result = remove_begin(result) if result
499:     result
500:   end
501: 
502:   def new_defn val
503:     (line, bol), name, args, body = val[2], val[1], val[3], val[4]
504:     body ||= s(:nil)
505: 
506:     body ||= s(:block)
507:     body = s(:block, body) unless body.first == :block
508: 
509:     result = s(:defn, name.to_sym, args, s(:scope, body))
510:     result.line = line
511:     result.line -= 1 if bol
512:     result.comments = self.comments.pop
513:     result
514:   end
515: 
516:   def new_defs val
517:     recv, name, args, body = val[1], val[4], val[6], val[7]
518: 
519:     body ||= s(:block)
520:     body = s(:block, body) unless body.first == :block
521: 
522:     result = s(:defs, recv, name.to_sym, args, s(:scope, body))
523:     result.line = recv.line
524:     result.comments = self.comments.pop
525:     result
526:   end
527: 
528:   def new_for expr, var, body
529:     result = s(:for, expr, var).line(var.line)
530:     result << body if body
531:     result
532:   end
533: 
534:   def new_if c, t, f
535:     l = [c.line, t && t.line, f && f.line].compact.min
536:     c = cond c
537:     c, t, f = c.last, f, t if c[0] == :not
538:     s(:if, c, t, f).line(l)
539:   end
540: 
541:   def new_iter call, args, body
542:     result = s(:iter)
543:     result << call if call
544:     result << args
545:     result << body if body
546:     result
547:   end
548: 
549:   def new_masgn lhs, rhs, wrap = false
550:     rhs = value_expr(rhs)
551:     rhs = lhs[1] ? s(:to_ary, rhs) : s(:array, rhs) if wrap
552: 
553:     lhs.delete_at 1 if lhs[1].nil?
554:     lhs << rhs
555: 
556:     lhs
557:   end
558: 
559:   def new_module val
560:     line, path, body = val[1], val[2], val[4]
561:     body = s(:scope, body).compact
562:     result = s(:module, path, body)
563:     result.line = line
564:     result.comments = self.comments.pop
565:     result
566:   end
567: 
568:   def new_op_asgn val
569:     lhs, asgn_op, arg = val[0], val[1].to_sym, val[2]
570:     name = lhs.value
571:     arg = remove_begin(arg)
572:     result = case asgn_op # REFACTOR
573:              when :"||" then
574:                lhs << arg
575:                s(:op_asgn_or, self.gettable(name), lhs)
576:              when :"&&" then
577:                lhs << arg
578:                s(:op_asgn_and, self.gettable(name), lhs)
579:              else
580:                # TODO: why [2] ?
581:                lhs[2] = new_call(self.gettable(name), asgn_op,
582:                                  s(:arglist, arg))
583:                lhs
584:              end
585:     result.line = lhs.line
586:     result
587:   end
588: 
589:   def new_regexp val
590:     node = val[1] || s(:str, '')
591:     options = val[2]
592: 
593:     o, k = 0, nil
594:     options.split(//).uniq.each do |c| # FIX: this has a better home
595:       v = {
596:         'x' => Regexp::EXTENDED,
597:         'i' => Regexp::IGNORECASE,
598:         'm' => Regexp::MULTILINE,
599:         'o' => Regexp::ONCE,
600:         'n' => Regexp::ENC_NONE,
601:         'e' => Regexp::ENC_EUC,
602:         's' => Regexp::ENC_SJIS,
603:         'u' => Regexp::ENC_UTF8,
604:       }[c]
605:       raise "unknown regexp option: #{c}" unless v
606:       o += v
607:       k = c if c =~ /[esu]/
608:     end
609: 
610:     case node[0]
611:     when :str then
612:       node[0] = :lit
613:       node[1] = if k then
614:                   Regexp.new(node[1], o, k)
615:                 else
616:                   Regexp.new(node[1], o)
617:                 end
618:     when :dstr then
619:       if options =~ /o/ then
620:         node[0] = :dregx_once
621:       else
622:         node[0] = :dregx
623:       end
624:       node << o if o and o != 0
625:     else
626:       node = s(:dregx, '', node);
627:       node[0] = :dregx_once if options =~ /o/
628:       node << o if o and o != 0
629:     end
630: 
631:     node
632:   end
633: 
634:   def new_sclass val
635:     recv, in_def, in_single, body = val[3], val[4], val[6], val[7]
636:     scope = s(:scope, body).compact
637:     result = s(:sclass, recv, scope)
638:     result.line = val[2]
639:     self.in_def = in_def
640:     self.in_single = in_single
641:     result
642:   end
643: 
644:   def new_super args
645:     if args && args.node_type == :block_pass then
646:       s(:super, args)
647:     else
648:       args ||= s(:arglist)
649:       s(:super, *args[1..1])
650:     end
651:   end
652: 
653:   def new_undef n, m = nil
654:     if m then
655:       block_append(n, s(:undef, m))
656:     else
657:       s(:undef, n)
658:     end
659:   end
660: 
661:   def new_until block, expr, pre
662:     expr = (expr.first == :not ? expr.last : s(:not, expr)).line(expr.line)
663:     new_while block, expr, pre
664:   end
665: 
666:   def new_while block, expr, pre
667:     line = [block && block.line, expr.line].compact.min
668:     block, pre = block.last, false if block && block[0] == :begin
669: 
670:     expr = cond expr
671:     result = if expr.first == :not then
672:                s(:until, expr.last, block, pre)
673:              else
674:                s(:while, expr, block, pre)
675:              end
676: 
677:     result.line = line
678:     result
679:   end
680: 
681:   def new_xstring str
682:     if str then
683:       case str[0]
684:       when :str
685:         str[0] = :xstr
686:       when :dstr
687:         str[0] = :dxstr
688:       else
689:         str = s(:dxstr, '', str)
690:       end
691:       str
692:     else
693:       s(:xstr, '')
694:     end
695:   end
696: 
697:   def new_yield args = nil
698:     # TODO: raise args.inspect unless [:arglist].include? args.first # HACK
699:     raise SyntaxError, "Block argument should not be given." if
700:       args && args.node_type == :block_pass
701: 
702:     args ||= s(:arglist)
703: 
704:     # TODO: I can prolly clean this up
705:     args[0] = :arglist       if args.first == :array
706:     args = s(:arglist, args) unless args.first == :arglist
707: 
708:     return s(:yield, *args[1..1])
709:   end
710: 
711:   def next_token
712:     if self.lexer.advance then
713:       return self.lexer.token, self.lexer.yacc_value
714:     else
715:       return [false, '$end']
716:     end
717:   end
718: 
719:   def node_assign(lhs, rhs) # TODO: rename new_assign
720:     return nil unless lhs
721: 
722:     rhs = value_expr rhs
723: 
724:     case lhs[0]
725:     when :gasgn, :iasgn, :lasgn, :dasgn, :dasgn_curr,
726:       :masgn, :cdecl, :cvdecl, :cvasgn then
727:       lhs << rhs
728:     when :attrasgn, :call then
729:       args = lhs.pop unless Symbol === lhs.last
730:       lhs << arg_add(args, rhs)
731:     when :const then
732:       lhs[0] = :cdecl
733:       lhs << rhs
734:     else
735:       raise "unknown lhs #{lhs.inspect}"
736:     end
737: 
738:     lhs
739:   end
740: 
741:   def process(str, file = "(string)")
742:     raise "bad val: #{str.inspect}" unless String === str
743: 
744:     self.file = file
745:     self.lexer.src = str
746: 
747:     @yydebug = ENV.has_key? 'DEBUG'
748: 
749:     do_parse
750:   end
751:   alias :parse :process
752: 
753:   def remove_begin node
754:     oldnode = node
755:     if node and :begin == node[0] and node.size == 2 then
756:       node = node[1]
757:       node.line = oldnode.line
758:     end
759:     node
760:   end
761: 
762:   def reset
763:     lexer.reset
764:     self.in_def = false
765:     self.in_single = 0
766:     self.env.reset
767:     self.comments.clear
768:   end
769: 
770:   def ret_args node
771:     if node then
772:       raise SyntaxError, "block argument should not be given" if
773:         node[0] == :block_pass
774: 
775:       node = node.last if node[0] == :array && node.size == 2
776:       # HACK matz wraps ONE of the FOUR splats in a newline to
777:       # distinguish. I use paren for now. ugh
778:       node = s(:svalue, node) if node[0] == :splat and not node.paren
779:       node[0] = :svalue if node[0] == :arglist && node[1][0] == :splat
780:     end
781: 
782:     node
783:   end
784: 
785:   def s(*args)
786:     result = Sexp.new(*args)
787:     result.line ||= lexer.lineno if lexer.src          # otherwise...
788:     result.file = self.file
789:     result
790:   end
791: 
792:   def value_expr oldnode # HACK
793:     node = remove_begin oldnode
794:     node.line = oldnode.line if oldnode
795:     node[2] = value_expr(node[2]) if node and node[0] == :if
796:     node
797:   end
798: 
799:   def void_stmts node
800:     return nil unless node
801:     return node unless node[0] == :block
802: 
803:     node[1..1] = node[1..1].map { |n| remove_begin(n) }
804:     node
805:   end
806: 
807:   def warning s
808:     # do nothing for now
809:   end
810: 
811:   alias :old_yyerror :yyerror
812:   def yyerror msg
813:     # for now do nothing with the msg
814:     old_yyerror
815:   end
816: end
new_aref(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 422
422:   def new_aref val
423:     val[2] ||= s(:arglist)
424:     val[2][0] = :arglist if val[2][0] == :array # REFACTOR
425:     if val[0].node_type == :self then
426:       result = new_call nil, :"[]", val[2]
427:     else
428:       result = new_call val[0], :"[]", val[2]
429:     end
430:     result
431:   end
new_body(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 433
433:   def new_body val
434:     result = val[0]
435: 
436:     if val[1] then
437:       result = s(:rescue)
438:       result << val[0] if val[0]
439: 
440:       resbody = val[1]
441: 
442:       while resbody do
443:         result << resbody
444:         resbody = resbody.resbody(true)
445:       end
446: 
447:       result << val[2] if val[2]
448: 
449:       result.line = (val[0] || val[1]).line
450:     elsif not val[2].nil? then
451:       warning("else without rescue is useless")
452:       result = block_append(result, val[2])
453:     end
454: 
455:     result = s(:ensure, result, val[3]).compact if val[3]
456:     return result
457:   end
new_call(recv, meth, args = nil) click to toggle source
     # File lib/ruby_parser_extras.rb, line 459
459:   def new_call recv, meth, args = nil
460:     result = s(:call, recv, meth)
461:     result.line = recv.line if recv
462: 
463:     args ||= s(:arglist)
464:     args[0] = :arglist if args.first == :array
465:     args = s(:arglist, args) unless args.first == :arglist
466:     result << args
467:     result
468:   end
new_case(expr, body) click to toggle source
     # File lib/ruby_parser_extras.rb, line 470
470:   def new_case expr, body
471:     result = s(:case, expr)
472:     line = (expr || body).line
473: 
474:     while body and body.node_type == :when
475:       result << body
476:       body = body.delete_at 3
477:     end
478: 
479:     # else
480:     body = nil if body == s(:block)
481:     result << body
482: 
483:     result.line = line
484:     result
485:   end
new_class(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 487
487:   def new_class val
488:     line, path, superclass, body = val[1], val[2], val[3], val[5]
489:     scope = s(:scope, body).compact
490:     result = s(:class, path, superclass, scope)
491:     result.line = line
492:     result.comments = self.comments.pop
493:     result
494:   end
new_compstmt(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 496
496:   def new_compstmt val
497:     result = void_stmts(val[0])
498:     result = remove_begin(result) if result
499:     result
500:   end
new_defn(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 502
502:   def new_defn val
503:     (line, bol), name, args, body = val[2], val[1], val[3], val[4]
504:     body ||= s(:nil)
505: 
506:     body ||= s(:block)
507:     body = s(:block, body) unless body.first == :block
508: 
509:     result = s(:defn, name.to_sym, args, s(:scope, body))
510:     result.line = line
511:     result.line -= 1 if bol
512:     result.comments = self.comments.pop
513:     result
514:   end
new_defs(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 516
516:   def new_defs val
517:     recv, name, args, body = val[1], val[4], val[6], val[7]
518: 
519:     body ||= s(:block)
520:     body = s(:block, body) unless body.first == :block
521: 
522:     result = s(:defs, recv, name.to_sym, args, s(:scope, body))
523:     result.line = recv.line
524:     result.comments = self.comments.pop
525:     result
526:   end
new_for(expr, var, body) click to toggle source
     # File lib/ruby_parser_extras.rb, line 528
528:   def new_for expr, var, body
529:     result = s(:for, expr, var).line(var.line)
530:     result << body if body
531:     result
532:   end
new_if(c, t, f) click to toggle source
     # File lib/ruby_parser_extras.rb, line 534
534:   def new_if c, t, f
535:     l = [c.line, t && t.line, f && f.line].compact.min
536:     c = cond c
537:     c, t, f = c.last, f, t if c[0] == :not
538:     s(:if, c, t, f).line(l)
539:   end
new_iter(call, args, body) click to toggle source
     # File lib/ruby_parser_extras.rb, line 541
541:   def new_iter call, args, body
542:     result = s(:iter)
543:     result << call if call
544:     result << args
545:     result << body if body
546:     result
547:   end
new_masgn(lhs, rhs, wrap = false) click to toggle source
     # File lib/ruby_parser_extras.rb, line 549
549:   def new_masgn lhs, rhs, wrap = false
550:     rhs = value_expr(rhs)
551:     rhs = lhs[1] ? s(:to_ary, rhs) : s(:array, rhs) if wrap
552: 
553:     lhs.delete_at 1 if lhs[1].nil?
554:     lhs << rhs
555: 
556:     lhs
557:   end
new_module(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 559
559:   def new_module val
560:     line, path, body = val[1], val[2], val[4]
561:     body = s(:scope, body).compact
562:     result = s(:module, path, body)
563:     result.line = line
564:     result.comments = self.comments.pop
565:     result
566:   end
new_op_asgn(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 568
568:   def new_op_asgn val
569:     lhs, asgn_op, arg = val[0], val[1].to_sym, val[2]
570:     name = lhs.value
571:     arg = remove_begin(arg)
572:     result = case asgn_op # REFACTOR
573:              when :"||" then
574:                lhs << arg
575:                s(:op_asgn_or, self.gettable(name), lhs)
576:              when :"&&" then
577:                lhs << arg
578:                s(:op_asgn_and, self.gettable(name), lhs)
579:              else
580:                # TODO: why [2] ?
581:                lhs[2] = new_call(self.gettable(name), asgn_op,
582:                                  s(:arglist, arg))
583:                lhs
584:              end
585:     result.line = lhs.line
586:     result
587:   end
new_regexp(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 589
589:   def new_regexp val
590:     node = val[1] || s(:str, '')
591:     options = val[2]
592: 
593:     o, k = 0, nil
594:     options.split(//).uniq.each do |c| # FIX: this has a better home
595:       v = {
596:         'x' => Regexp::EXTENDED,
597:         'i' => Regexp::IGNORECASE,
598:         'm' => Regexp::MULTILINE,
599:         'o' => Regexp::ONCE,
600:         'n' => Regexp::ENC_NONE,
601:         'e' => Regexp::ENC_EUC,
602:         's' => Regexp::ENC_SJIS,
603:         'u' => Regexp::ENC_UTF8,
604:       }[c]
605:       raise "unknown regexp option: #{c}" unless v
606:       o += v
607:       k = c if c =~ /[esu]/
608:     end
609: 
610:     case node[0]
611:     when :str then
612:       node[0] = :lit
613:       node[1] = if k then
614:                   Regexp.new(node[1], o, k)
615:                 else
616:                   Regexp.new(node[1], o)
617:                 end
618:     when :dstr then
619:       if options =~ /o/ then
620:         node[0] = :dregx_once
621:       else
622:         node[0] = :dregx
623:       end
624:       node << o if o and o != 0
625:     else
626:       node = s(:dregx, '', node);
627:       node[0] = :dregx_once if options =~ /o/
628:       node << o if o and o != 0
629:     end
630: 
631:     node
632:   end
new_sclass(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 634
634:   def new_sclass val
635:     recv, in_def, in_single, body = val[3], val[4], val[6], val[7]
636:     scope = s(:scope, body).compact
637:     result = s(:sclass, recv, scope)
638:     result.line = val[2]
639:     self.in_def = in_def
640:     self.in_single = in_single
641:     result
642:   end
new_super(args) click to toggle source
     # File lib/ruby_parser_extras.rb, line 644
644:   def new_super args
645:     if args && args.node_type == :block_pass then
646:       s(:super, args)
647:     else
648:       args ||= s(:arglist)
649:       s(:super, *args[1..1])
650:     end
651:   end
new_undef(n, m = nil) click to toggle source
     # File lib/ruby_parser_extras.rb, line 653
653:   def new_undef n, m = nil
654:     if m then
655:       block_append(n, s(:undef, m))
656:     else
657:       s(:undef, n)
658:     end
659:   end
new_until(block, expr, pre) click to toggle source
     # File lib/ruby_parser_extras.rb, line 661
661:   def new_until block, expr, pre
662:     expr = (expr.first == :not ? expr.last : s(:not, expr)).line(expr.line)
663:     new_while block, expr, pre
664:   end
new_while(block, expr, pre) click to toggle source
     # File lib/ruby_parser_extras.rb, line 666
666:   def new_while block, expr, pre
667:     line = [block && block.line, expr.line].compact.min
668:     block, pre = block.last, false if block && block[0] == :begin
669: 
670:     expr = cond expr
671:     result = if expr.first == :not then
672:                s(:until, expr.last, block, pre)
673:              else
674:                s(:while, expr, block, pre)
675:              end
676: 
677:     result.line = line
678:     result
679:   end
new_xstring(str) click to toggle source
     # File lib/ruby_parser_extras.rb, line 681
681:   def new_xstring str
682:     if str then
683:       case str[0]
684:       when :str
685:         str[0] = :xstr
686:       when :dstr
687:         str[0] = :dxstr
688:       else
689:         str = s(:dxstr, '', str)
690:       end
691:       str
692:     else
693:       s(:xstr, '')
694:     end
695:   end
new_yield(args = nil) click to toggle source
     # File lib/ruby_parser_extras.rb, line 697
697:   def new_yield args = nil
698:     # TODO: raise args.inspect unless [:arglist].include? args.first # HACK
699:     raise SyntaxError, "Block argument should not be given." if
700:       args && args.node_type == :block_pass
701: 
702:     args ||= s(:arglist)
703: 
704:     # TODO: I can prolly clean this up
705:     args[0] = :arglist       if args.first == :array
706:     args = s(:arglist, args) unless args.first == :arglist
707: 
708:     return s(:yield, *args[1..1])
709:   end
next_token() click to toggle source
     # File lib/ruby_parser_extras.rb, line 711
711:   def next_token
712:     if self.lexer.advance then
713:       return self.lexer.token, self.lexer.yacc_value
714:     else
715:       return [false, '$end']
716:     end
717:   end
node_assign(lhs, rhs) click to toggle source
     # File lib/ruby_parser_extras.rb, line 719
719:   def node_assign(lhs, rhs) # TODO: rename new_assign
720:     return nil unless lhs
721: 
722:     rhs = value_expr rhs
723: 
724:     case lhs[0]
725:     when :gasgn, :iasgn, :lasgn, :dasgn, :dasgn_curr,
726:       :masgn, :cdecl, :cvdecl, :cvasgn then
727:       lhs << rhs
728:     when :attrasgn, :call then
729:       args = lhs.pop unless Symbol === lhs.last
730:       lhs << arg_add(args, rhs)
731:     when :const then
732:       lhs[0] = :cdecl
733:       lhs << rhs
734:     else
735:       raise "unknown lhs #{lhs.inspect}"
736:     end
737: 
738:     lhs
739:   end
process(str, file = "(string)") click to toggle source
     # File lib/ruby_parser_extras.rb, line 741
741:   def process(str, file = "(string)")
742:     raise "bad val: #{str.inspect}" unless String === str
743: 
744:     self.file = file
745:     self.lexer.src = str
746: 
747:     @yydebug = ENV.has_key? 'DEBUG'
748: 
749:     do_parse
750:   end
remove_begin(node) click to toggle source
     # File lib/ruby_parser_extras.rb, line 753
753:   def remove_begin node
754:     oldnode = node
755:     if node and :begin == node[0] and node.size == 2 then
756:       node = node[1]
757:       node.line = oldnode.line
758:     end
759:     node
760:   end
reset() click to toggle source
     # File lib/ruby_parser_extras.rb, line 762
762:   def reset
763:     lexer.reset
764:     self.in_def = false
765:     self.in_single = 0
766:     self.env.reset
767:     self.comments.clear
768:   end
ret_args(node) click to toggle source
     # File lib/ruby_parser_extras.rb, line 770
770:   def ret_args node
771:     if node then
772:       raise SyntaxError, "block argument should not be given" if
773:         node[0] == :block_pass
774: 
775:       node = node.last if node[0] == :array && node.size == 2
776:       # HACK matz wraps ONE of the FOUR splats in a newline to
777:       # distinguish. I use paren for now. ugh
778:       node = s(:svalue, node) if node[0] == :splat and not node.paren
779:       node[0] = :svalue if node[0] == :arglist && node[1][0] == :splat
780:     end
781: 
782:     node
783:   end
s(*args) click to toggle source
     # File lib/ruby_parser_extras.rb, line 785
785:   def s(*args)
786:     result = Sexp.new(*args)
787:     result.line ||= lexer.lineno if lexer.src          # otherwise...
788:     result.file = self.file
789:     result
790:   end
value_expr(oldnode) click to toggle source
     # File lib/ruby_parser_extras.rb, line 792
792:   def value_expr oldnode # HACK
793:     node = remove_begin oldnode
794:     node.line = oldnode.line if oldnode
795:     node[2] = value_expr(node[2]) if node and node[0] == :if
796:     node
797:   end
void_stmts(node) click to toggle source
     # File lib/ruby_parser_extras.rb, line 799
799:   def void_stmts node
800:     return nil unless node
801:     return node unless node[0] == :block
802: 
803:     node[1..1] = node[1..1].map { |n| remove_begin(n) }
804:     node
805:   end
warning(s) click to toggle source
     # File lib/ruby_parser_extras.rb, line 807
807:   def warning s
808:     # do nothing for now
809:   end
yyerror(msg) click to toggle source
     # File lib/ruby_parser_extras.rb, line 812
812:   def yyerror msg
813:     # for now do nothing with the msg
814:     old_yyerror
815:   end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.