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]
canonicalize_conditions[RW]

Canonicalize conditionals. Eg:

  not x ? a : b

becomes:

  x ? b : a

Public Class Methods

new(options = {}) click to toggle source
     # File lib/ruby_parser_extras.rb, line 333
333:   def initialize(options = {})
334:     super()
335:     self.lexer = RubyLexer.new
336:     self.lexer.parser = self
337:     @env = Environment.new
338:     @comments = []
339: 
340:     @canonicalize_conditions = true
341: 
342:     self.reset
343:   end

Public Instance Methods

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

reduce 0 omitted

      # File lib/ruby_parser.rb, line 2938
2938: def _reduce_1(val, _values, result)
2939:                       self.lexer.lex_state = :expr_beg
2940:                     
2941:     result
2942: end
_reduce_10(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2985
2985: def _reduce_10(val, _values, result)
2986:                       result = s(:alias, val[1], val[3]).line(val[2])
2987:                     
2988:     result
2989: end
_reduce_100(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3516
3516: def _reduce_100(val, _values, result)
3517:                       lexer.lex_state = :expr_end
3518:                       result = val[0]
3519:                     
3520:     result
3521: end
_reduce_103(val, _values, result) click to toggle source

reduce 102 omitted

      # File lib/ruby_parser.rb, line 3527
3527: def _reduce_103(val, _values, result)
3528:  result = s(:lit, val[0].to_sym) 
3529:     result
3530: end
_reduce_105(val, _values, result) click to toggle source

reduce 104 omitted

      # File lib/ruby_parser.rb, line 3534
3534: def _reduce_105(val, _values, result)
3535:                       result = new_undef val[0]
3536:                     
3537:     result
3538: end
_reduce_106(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3540
3540: def _reduce_106(val, _values, result)
3541:                       lexer.lex_state = :expr_fname
3542:                     
3543:     result
3544: end
_reduce_107(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3546
3546: def _reduce_107(val, _values, result)
3547:                       result = new_undef val[0], val[3]
3548:                     
3549:     result
3550: end
_reduce_11(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2991
2991: def _reduce_11(val, _values, result)
2992:                       result = s(:valias, val[1].to_sym, val[2].to_sym)
2993:                     
2994:     result
2995: end
_reduce_12(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2997
2997: def _reduce_12(val, _values, result)
2998:                       result = s(:valias, val[1].to_sym, :"$#{val[2]}")
2999:                     
3000:     result
3001: end
_reduce_13(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3003
3003: def _reduce_13(val, _values, result)
3004:                       yyerror "can't make alias for the number variables"
3005:                     
3006:     result
3007: end
_reduce_14(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3009
3009: def _reduce_14(val, _values, result)
3010:                       result = val[1]
3011:                     
3012:     result
3013: end
_reduce_15(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3015
3015: def _reduce_15(val, _values, result)
3016:                       result = new_if val[2], val[0], nil
3017:                     
3018:     result
3019: end
_reduce_16(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3021
3021: def _reduce_16(val, _values, result)
3022:                       result = new_if val[2], nil, val[0]
3023:                     
3024:     result
3025: end
_reduce_17(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3027
3027: def _reduce_17(val, _values, result)
3028:                       result = new_while val[0], val[2], true
3029:                     
3030:     result
3031: end
_reduce_175(val, _values, result) click to toggle source

reduce 174 omitted

      # File lib/ruby_parser.rb, line 3686
3686: def _reduce_175(val, _values, result)
3687:                       result = self.node_assign val[0], val[2]
3688:                     
3689:     result
3690: end
_reduce_176(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3692
3692: def _reduce_176(val, _values, result)
3693:                       result = self.node_assign val[0], s(:rescue, val[2], s(:resbody, s(:array), val[4]))
3694:                       # result.line = val[0].line
3695:                     
3696:     result
3697: end
_reduce_177(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3699
3699: def _reduce_177(val, _values, result)
3700:                       result = new_op_asgn val
3701:                     
3702:     result
3703: end
_reduce_178(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3705
3705: def _reduce_178(val, _values, result)
3706:                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
3707:                       val[2][0] = :arglist
3708:                     
3709:     result
3710: end
_reduce_179(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3712
3712: def _reduce_179(val, _values, result)
3713:                       result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
3714:                     
3715:     result
3716: end
_reduce_18(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3033
3033: def _reduce_18(val, _values, result)
3034:                       result = new_until val[0], val[2], true
3035:                     
3036:     result
3037: end
_reduce_180(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3718
3718: def _reduce_180(val, _values, result)
3719:                       result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4])
3720:                     
3721:     result
3722: end
_reduce_181(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3724
3724: def _reduce_181(val, _values, result)
3725:                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
3726:                     
3727:     result
3728: end
_reduce_182(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3730
3730: def _reduce_182(val, _values, result)
3731:                       yyerror "constant re-assignment"
3732:                     
3733:     result
3734: end
_reduce_183(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3736
3736: def _reduce_183(val, _values, result)
3737:                       yyerror "constant re-assignment"
3738:                     
3739:     result
3740: end
_reduce_184(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3742
3742: def _reduce_184(val, _values, result)
3743:                       self.backref_assign_error val[0]
3744:                     
3745:     result
3746: end
_reduce_185(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3748
3748: def _reduce_185(val, _values, result)
3749:                       v1, v2 = val[0], val[2]
3750:                       if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
3751:                         result = s(:lit, (v1.last)..(v2.last))
3752:                       else
3753:                         result = s(:dot2, v1, v2)
3754:                       end
3755:                     
3756:     result
3757: end
_reduce_186(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3759
3759: def _reduce_186(val, _values, result)
3760:                       v1, v2 = val[0], val[2]
3761:                       if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then
3762:                         result = s(:lit, (v1.last)...(v2.last))
3763:                       else
3764:                         result = s(:dot3, v1, v2)
3765:                       end
3766:                     
3767:     result
3768: end
_reduce_187(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3770
3770: def _reduce_187(val, _values, result)
3771:                       result = new_call val[0], :+, s(:arglist, val[2])
3772:                     
3773:     result
3774: end
_reduce_188(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3776
3776: def _reduce_188(val, _values, result)
3777:                       result = new_call val[0], :-, s(:arglist, val[2])
3778:                     
3779:     result
3780: end
_reduce_189(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3782
3782: def _reduce_189(val, _values, result)
3783:                       result = new_call val[0], :*, s(:arglist, val[2])
3784:                     
3785:     result
3786: end
_reduce_19(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3039
3039: def _reduce_19(val, _values, result)
3040:                       result = s(:rescue, val[0], s(:resbody, s(:array), val[2]))
3041:                     
3042:     result
3043: end
_reduce_190(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3788
3788: def _reduce_190(val, _values, result)
3789:                       result = new_call val[0], :"/", s(:arglist, val[2])
3790:                     
3791:     result
3792: end
_reduce_191(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3794
3794: def _reduce_191(val, _values, result)
3795:                       result = new_call val[0], :%, s(:arglist, val[2])
3796:                     
3797:     result
3798: end
_reduce_192(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3800
3800: def _reduce_192(val, _values, result)
3801:                       result = new_call val[0], :**, s(:arglist, val[2])
3802:                     
3803:     result
3804: end
_reduce_193(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3806
3806: def _reduce_193(val, _values, result)
3807:                       result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
3808:                     
3809:     result
3810: end
_reduce_194(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3812
3812: def _reduce_194(val, _values, result)
3813:                       result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist))
3814:                     
3815:     result
3816: end
_reduce_195(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3818
3818: def _reduce_195(val, _values, result)
3819:                       if val[1][0] == :lit then
3820:                         result = val[1]
3821:                       else
3822:                         result = new_call val[1], :"+@", s(:arglist)
3823:                       end
3824:                     
3825:     result
3826: end
_reduce_196(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3828
3828: def _reduce_196(val, _values, result)
3829:                       result = new_call val[1], :"-@", s(:arglist)
3830:                     
3831:     result
3832: end
_reduce_197(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3834
3834: def _reduce_197(val, _values, result)
3835:                       result = new_call val[0], :"|", s(:arglist, val[2])
3836:                     
3837:     result
3838: end
_reduce_198(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3840
3840: def _reduce_198(val, _values, result)
3841:                       result = new_call val[0], :"^", s(:arglist, val[2])
3842:                     
3843:     result
3844: end
_reduce_199(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3846
3846: def _reduce_199(val, _values, result)
3847:                       result = new_call val[0], :"&", s(:arglist, val[2])
3848:                     
3849:     result
3850: end
_reduce_2(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2944
2944: def _reduce_2(val, _values, result)
2945:                       result = val[1]
2946:                     
2947:     result
2948: end
_reduce_20(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3045
3045: def _reduce_20(val, _values, result)
3046:                       if (self.in_def || self.in_single > 0) then
3047:                         yyerror "BEGIN in method"
3048:                       end
3049:                       self.env.extend
3050:                     
3051:     result
3052: end
_reduce_200(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3852
3852: def _reduce_200(val, _values, result)
3853:                       result = new_call val[0], :"<=>", s(:arglist, val[2])
3854:                     
3855:     result
3856: end
_reduce_201(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3858
3858: def _reduce_201(val, _values, result)
3859:                       result = new_call val[0], :">", s(:arglist, val[2])
3860:                     
3861:     result
3862: end
_reduce_202(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3864
3864: def _reduce_202(val, _values, result)
3865:                       result = new_call val[0], :">=", s(:arglist, val[2])
3866:                     
3867:     result
3868: end
_reduce_203(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3870
3870: def _reduce_203(val, _values, result)
3871:                       result = new_call val[0], :"<", s(:arglist, val[2])
3872:                     
3873:     result
3874: end
_reduce_204(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3876
3876: def _reduce_204(val, _values, result)
3877:                       result = new_call val[0], :"<=", s(:arglist, val[2])
3878:                     
3879:     result
3880: end
_reduce_205(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3882
3882: def _reduce_205(val, _values, result)
3883:                       result = new_call val[0], :"==", s(:arglist, val[2])
3884:                     
3885:     result
3886: end
_reduce_206(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3888
3888: def _reduce_206(val, _values, result)
3889:                       result = new_call val[0], :"===", s(:arglist, val[2])
3890:                     
3891:     result
3892: end
_reduce_207(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3894
3894: def _reduce_207(val, _values, result)
3895:                       val[0] = value_expr val[0] # TODO: port call_op and clean these
3896:                       val[2] = value_expr val[2]
3897:                       result = s(:not, new_call(val[0], :"==", s(:arglist, val[2])))
3898:                     
3899:     result
3900: end
_reduce_208(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3902
3902: def _reduce_208(val, _values, result)
3903:                       result = self.get_match_node val[0], val[2]
3904:                     
3905:     result
3906: end
_reduce_209(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3908
3908: def _reduce_209(val, _values, result)
3909:                       result = s(:not, self.get_match_node(val[0], val[2]))
3910:                     
3911:     result
3912: end
_reduce_21(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3054
3054: def _reduce_21(val, _values, result)
3055:                       result = new_iter s(:preexe), nil, val[3] # TODO: add test?
3056:                       result = nil # TODO: since it isn't supposed to go in the AST
3057:                     
3058:     result
3059: end
_reduce_210(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3914
3914: def _reduce_210(val, _values, result)
3915:                       result = s(:not, val[1])
3916:                     
3917:     result
3918: end
_reduce_211(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3920
3920: def _reduce_211(val, _values, result)
3921:                       val[2] = value_expr val[2]
3922:                       result = new_call val[1], :"~", s(:arglist)
3923:                     
3924:     result
3925: end
_reduce_212(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3927
3927: def _reduce_212(val, _values, result)
3928:                       val[0] = value_expr val[0]
3929:                       val[2] = value_expr val[2]
3930:                       result = new_call val[0], :"\<\<", s(:arglist, val[2])
3931:                     
3932:     result
3933: end
_reduce_213(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3935
3935: def _reduce_213(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_214(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3943
3943: def _reduce_214(val, _values, result)
3944:                       result = logop(:and, val[0], val[2])
3945:                     
3946:     result
3947: end
_reduce_215(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3949
3949: def _reduce_215(val, _values, result)
3950:                       result = logop(:or, val[0], val[2])
3951:                     
3952:     result
3953: end
_reduce_216(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3955
3955: def _reduce_216(val, _values, result)
3956:                       result = s(:defined, val[2])
3957:                     
3958:     result
3959: end
_reduce_217(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3961
3961: def _reduce_217(val, _values, result)
3962:                       result = s(:if, val[0], val[2], val[4])
3963:                     
3964:     result
3965: end
_reduce_219(val, _values, result) click to toggle source

reduce 218 omitted

      # File lib/ruby_parser.rb, line 3969
3969: def _reduce_219(val, _values, result)
3970:                       result = value_expr(val[0])
3971:                     
3972:     result
3973: end
_reduce_22(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3061
3061: def _reduce_22(val, _values, result)
3062:                       if (self.in_def || self.in_single > 0) then
3063:                         yyerror "END in method; use at_exit"
3064:                       end
3065:                       result = new_iter s(:postexe), nil, val[2]
3066:                     
3067:     result
3068: end
_reduce_221(val, _values, result) click to toggle source

reduce 220 omitted

      # File lib/ruby_parser.rb, line 3977
3977: def _reduce_221(val, _values, result)
3978:                       warning 'parenthesize argument(s) for future version'
3979:                       result = s(:array, val[0])
3980:                     
3981:     result
3982: end
_reduce_222(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3984
3984: def _reduce_222(val, _values, result)
3985:                       result = val[0]
3986:                     
3987:     result
3988: end
_reduce_223(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3990
3990: def _reduce_223(val, _values, result)
3991:                       result = self.arg_concat val[0], val[3]
3992:                     
3993:     result
3994: end
_reduce_224(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3996
3996: def _reduce_224(val, _values, result)
3997:                       result = s(:array, s(:hash, *val[0].values))
3998:                     
3999:     result
4000: end
_reduce_225(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4002
4002: def _reduce_225(val, _values, result)
4003:                       result = s(:array, s(:splat, val[1]))
4004:                     
4005:     result
4006: end
_reduce_226(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4008
4008: def _reduce_226(val, _values, result)
4009:                       result = val[1]
4010:                     
4011:     result
4012: end
_reduce_227(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4014
4014: def _reduce_227(val, _values, result)
4015:                       result = val[1]
4016:                     
4017:     result
4018: end
_reduce_228(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4020
4020: def _reduce_228(val, _values, result)
4021:                       warning "parenthesize argument(s) for future version"
4022:                       result = s(:array, val[1])
4023:                     
4024:     result
4025: end
_reduce_229(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4027
4027: def _reduce_229(val, _values, result)
4028:                       warning "parenthesize argument(s) for future version"
4029:                       result = val[1].add val[3]
4030:                     
4031:     result
4032: end
_reduce_23(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3070
3070: def _reduce_23(val, _values, result)
3071:                       result = self.node_assign val[0], val[2]
3072:                     
3073:     result
3074: end
_reduce_232(val, _values, result) click to toggle source

reduce 231 omitted

      # File lib/ruby_parser.rb, line 4038
4038: def _reduce_232(val, _values, result)
4039:                       warning "parenthesize argument(s) for future version"
4040:                       result = s(:array, val[0])
4041:                     
4042:     result
4043: end
_reduce_233(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4045
4045: def _reduce_233(val, _values, result)
4046:                       result = self.arg_blk_pass val[0], val[1]
4047:                     
4048:     result
4049: end
_reduce_234(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4051
4051: def _reduce_234(val, _values, result)
4052:                       result = self.arg_concat val[0], val[3]
4053:                       result = self.arg_blk_pass result, val[4]
4054:                     
4055:     result
4056: end
_reduce_235(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4058
4058: def _reduce_235(val, _values, result)
4059:                       result = s(:array, s(:hash, *val[0].values))
4060:                       result = self.arg_blk_pass result, val[1]
4061:                     
4062:     result
4063: end
_reduce_236(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4065
4065: def _reduce_236(val, _values, result)
4066:                       result = self.arg_concat s(:array, s(:hash, *val[0].values)), val[3]
4067:                       result = self.arg_blk_pass result, val[4]
4068:                     
4069:     result
4070: end
_reduce_237(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4072
4072: def _reduce_237(val, _values, result)
4073:                       result = val[0] << s(:hash, *val[2].values)
4074:                       result = self.arg_blk_pass result, val[3]
4075:                     
4076:     result
4077: end
_reduce_238(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4079
4079: def _reduce_238(val, _values, result)
4080:                       val[0] << s(:hash, *val[2].values)
4081:                       result = self.arg_concat val[0], val[5]
4082:                       result = self.arg_blk_pass result, val[6]
4083:                     
4084:     result
4085: end
_reduce_239(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4087
4087: def _reduce_239(val, _values, result)
4088:                       result = self.arg_blk_pass s(:splat, val[1]), val[2]
4089:                     
4090:     result
4091: end
_reduce_24(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3076
3076: def _reduce_24(val, _values, result)
3077:                       result = new_masgn val[0], val[2], :wrap
3078:                     
3079:     result
3080: end
_reduce_241(val, _values, result) click to toggle source

reduce 240 omitted

      # File lib/ruby_parser.rb, line 4095
4095: def _reduce_241(val, _values, result)
4096:                       args = self.list_prepend val[0], val[2]
4097:                       result = self.arg_blk_pass args, val[3]
4098:                     
4099:     result
4100: end
_reduce_242(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4102
4102: def _reduce_242(val, _values, result)
4103:                       result = self.arg_blk_pass val[0], val[2]
4104:                     
4105:     result
4106: end
_reduce_243(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4108
4108: def _reduce_243(val, _values, result)
4109:                       result = self.arg_concat s(:array, val[0]), val[3]
4110:                       result = self.arg_blk_pass result, val[4]
4111:                     
4112:     result
4113: end
_reduce_244(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4115
4115: def _reduce_244(val, _values, result)
4116:                       result = self.arg_concat s(:array, val[0], s(:hash, *val[2].values)), val[5]
4117:                       result = self.arg_blk_pass result, val[6]
4118:                     
4119:     result
4120: end
_reduce_245(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4122
4122: def _reduce_245(val, _values, result)
4123:                       result = s(:array, s(:hash, *val[0].values))
4124:                       result = self.arg_blk_pass result, val[1]
4125:                     
4126:     result
4127: end
_reduce_246(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4129
4129: def _reduce_246(val, _values, result)
4130:                       result = s(:array, s(:hash, *val[0].values), val[3])
4131:                       result = self.arg_blk_pass result, val[4]
4132:                     
4133:     result
4134: end
_reduce_247(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4136
4136: def _reduce_247(val, _values, result)
4137:                       result = s(:array, val[0], s(:hash, *val[2].values))
4138:                       result = self.arg_blk_pass result, val[3]
4139:                     
4140:     result
4141: end
_reduce_248(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4143
4143: def _reduce_248(val, _values, result)
4144:                       result = s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values))
4145:                       result = self.arg_blk_pass result, val[5]
4146:                     
4147:     result
4148: end
_reduce_249(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4150
4150: def _reduce_249(val, _values, result)
4151:                       result = self.arg_concat s(:array, val[0]).add(s(:hash, *val[2].values)), val[5]
4152:                       result = self.arg_blk_pass result, val[6]
4153:                     
4154:     result
4155: end
_reduce_25(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3082
3082: def _reduce_25(val, _values, result)
3083:                       result = new_op_asgn val
3084:                     
3085:     result
3086: end
_reduce_250(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4157
4157: def _reduce_250(val, _values, result)
4158:                       result = self.arg_concat s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)), val[7]
4159:                       result = self.arg_blk_pass result, val[8]
4160:                     
4161:     result
4162: end
_reduce_251(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4164
4164: def _reduce_251(val, _values, result)
4165:                       result = self.arg_blk_pass s(:splat, val[1]), val[2]
4166:                     
4167:     result
4168: end
_reduce_253(val, _values, result) click to toggle source

reduce 252 omitted

      # File lib/ruby_parser.rb, line 4172
4172: def _reduce_253(val, _values, result)
4173:                       result = lexer.cmdarg.stack.dup
4174:                       lexer.cmdarg.push true
4175:                     
4176:     result
4177: end
_reduce_254(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4179
4179: def _reduce_254(val, _values, result)
4180:                       lexer.cmdarg.stack.replace val[0]
4181:                       result = val[1]
4182:                     
4183:     result
4184: end
_reduce_256(val, _values, result) click to toggle source

reduce 255 omitted

      # File lib/ruby_parser.rb, line 4188
4188: def _reduce_256(val, _values, result)
4189:                       lexer.lex_state = :expr_endarg
4190:                     
4191:     result
4192: end
_reduce_257(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4194
4194: def _reduce_257(val, _values, result)
4195:                       warning "don't put space before argument parentheses"
4196:                       result = nil
4197:                     
4198:     result
4199: end
_reduce_258(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4201
4201: def _reduce_258(val, _values, result)
4202:                       lexer.lex_state = :expr_endarg
4203:                     
4204:     result
4205: end
_reduce_259(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4207
4207: def _reduce_259(val, _values, result)
4208:                       warning "don't put space before argument parentheses"
4209:                       result = val[1]
4210:                     
4211:     result
4212: end
_reduce_26(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3088
3088: def _reduce_26(val, _values, result)
3089:                       result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5])
3090:                     
3091:     result
3092: end
_reduce_260(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4214
4214: def _reduce_260(val, _values, result)
4215:                       result = s(:block_pass, val[1])
4216:                     
4217:     result
4218: end
_reduce_261(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4220
4220: def _reduce_261(val, _values, result)
4221:                       result = val[1]
4222:                     
4223:     result
4224: end
_reduce_263(val, _values, result) click to toggle source

reduce 262 omitted

      # File lib/ruby_parser.rb, line 4228
4228: def _reduce_263(val, _values, result)
4229:                       result = s(:array, val[0])
4230:                     
4231:     result
4232: end
_reduce_264(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4234
4234: def _reduce_264(val, _values, result)
4235:                       result = self.list_append val[0], val[2]
4236:                     
4237:     result
4238: end
_reduce_265(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4240
4240: def _reduce_265(val, _values, result)
4241:                       result = val[0] << val[2]
4242:                     
4243:     result
4244: end
_reduce_266(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4246
4246: def _reduce_266(val, _values, result)
4247:                       result = self.arg_concat val[0], val[3]
4248:                     
4249:     result
4250: end
_reduce_267(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4252
4252: def _reduce_267(val, _values, result)
4253:                       result = s(:splat, val[1])
4254:                     
4255:     result
4256: end
_reduce_27(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3094
3094: def _reduce_27(val, _values, result)
3095:                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
3096:                     
3097:     result
3098: end
_reduce_276(val, _values, result) click to toggle source

reduce 275 omitted

      # File lib/ruby_parser.rb, line 4274
4274: def _reduce_276(val, _values, result)
4275:                       result = new_call nil, val[0].to_sym
4276:                     
4277:     result
4278: end
_reduce_277(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4280
4280: def _reduce_277(val, _values, result)
4281:                       result = self.lexer.lineno
4282:                     
4283:     result
4284: end
_reduce_278(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4286
4286: def _reduce_278(val, _values, result)
4287:                       unless val[2] then
4288:                         result = s(:nil)
4289:                       else
4290:                         result = s(:begin, val[2])
4291:                       end
4292: 
4293:                       result.line = val[1]
4294:                     
4295:     result
4296: end
_reduce_279(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4298
4298: def _reduce_279(val, _values, result)
4299:                       lexer.lex_state = :expr_endarg
4300:                     
4301:     result
4302: end
_reduce_28(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3100
3100: def _reduce_28(val, _values, result)
3101:                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
3102:                     
3103:     result
3104: end
_reduce_280(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4304
4304: def _reduce_280(val, _values, result)
4305:                       warning "(...) interpreted as grouped expression"
4306:                       result = val[1]
4307:                     
4308:     result
4309: end
_reduce_281(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4311
4311: def _reduce_281(val, _values, result)
4312:                       result = val[1] || s(:nil)
4313:                       result.paren = true
4314:                     
4315:     result
4316: end
_reduce_282(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4318
4318: def _reduce_282(val, _values, result)
4319:                       result = s(:colon2, val[0], val[2].to_sym)
4320:                     
4321:     result
4322: end
_reduce_283(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4324
4324: def _reduce_283(val, _values, result)
4325:                       result = s(:colon3, val[1].to_sym)
4326:                     
4327:     result
4328: end
_reduce_284(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4330
4330: def _reduce_284(val, _values, result)
4331:                       result = new_aref val
4332:                     
4333:     result
4334: end
_reduce_285(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4336
4336: def _reduce_285(val, _values, result)
4337:                       result = val[1] || s(:array)
4338:                     
4339:     result
4340: end
_reduce_286(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4342
4342: def _reduce_286(val, _values, result)
4343:                       result = s(:hash, *val[1].values)
4344:                     
4345:     result
4346: end
_reduce_287(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4348
4348: def _reduce_287(val, _values, result)
4349:                       result = s(:return)
4350:                     
4351:     result
4352: end
_reduce_288(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4354
4354: def _reduce_288(val, _values, result)
4355:                       result = new_yield val[2]
4356:                     
4357:     result
4358: end
_reduce_289(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4360
4360: def _reduce_289(val, _values, result)
4361:                       result = new_yield
4362:                     
4363:     result
4364: end
_reduce_29(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3106
3106: def _reduce_29(val, _values, result)
3107:                       result = s(:op_asgn, val[0], val[4], val[2], val[3])
3108:                     
3109:     result
3110: end
_reduce_290(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4366
4366: def _reduce_290(val, _values, result)
4367:                       result = new_yield
4368:                     
4369:     result
4370: end
_reduce_291(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4372
4372: def _reduce_291(val, _values, result)
4373:                       result = s(:defined, val[3])
4374:                     
4375:     result
4376: end
_reduce_292(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4378
4378: def _reduce_292(val, _values, result)
4379:                       oper, iter = val[0], val[1]
4380:                       call = new_call(nil, oper.to_sym)
4381:                       iter.insert 1, call
4382:                       result = iter
4383:                       call.line = iter.line
4384:                     
4385:     result
4386: end
_reduce_294(val, _values, result) click to toggle source

reduce 293 omitted

      # File lib/ruby_parser.rb, line 4390
4390: def _reduce_294(val, _values, result)
4391:                       call, iter = val[0], val[1]
4392:                       iter.insert 1, call
4393:                       result = iter
4394:                     
4395:     result
4396: end
_reduce_295(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4398
4398: def _reduce_295(val, _values, result)
4399:                       result = new_if val[1], val[3], val[4]
4400:                     
4401:     result
4402: end
_reduce_296(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4404
4404: def _reduce_296(val, _values, result)
4405:                       result = new_if val[1], val[4], val[3]
4406:                     
4407:     result
4408: end
_reduce_297(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4410
4410: def _reduce_297(val, _values, result)
4411:                       lexer.cond.push true
4412:                     
4413:     result
4414: end
_reduce_298(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4416
4416: def _reduce_298(val, _values, result)
4417:                       lexer.cond.pop
4418:                     
4419:     result
4420: end
_reduce_299(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4422
4422: def _reduce_299(val, _values, result)
4423:                       result = new_while val[5], val[2], true
4424:                     
4425:     result
4426: end
_reduce_3(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2950
2950: def _reduce_3(val, _values, result)
2951:                       result = new_body val
2952:                     
2953:     result
2954: end
_reduce_30(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3112
3112: def _reduce_30(val, _values, result)
3113:                       self.backref_assign_error val[0]
3114:                     
3115:     result
3116: end
_reduce_300(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4428
4428: def _reduce_300(val, _values, result)
4429:                       lexer.cond.push true
4430:                     
4431:     result
4432: end
_reduce_301(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4434
4434: def _reduce_301(val, _values, result)
4435:                       lexer.cond.pop
4436:                     
4437:     result
4438: end
_reduce_302(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4440
4440: def _reduce_302(val, _values, result)
4441:                       result = new_until val[5], val[2], true
4442:                     
4443:     result
4444: end
_reduce_303(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4446
4446: def _reduce_303(val, _values, result)
4447:                       result = new_case val[1], val[3]
4448:                     
4449:     result
4450: end
_reduce_304(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4452
4452: def _reduce_304(val, _values, result)
4453:                       result = new_case nil, val[2]
4454:                     
4455:     result
4456: end
_reduce_305(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4458
4458: def _reduce_305(val, _values, result)
4459:                       result = new_case nil, val[3]
4460:                     
4461:     result
4462: end
_reduce_306(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4464
4464: def _reduce_306(val, _values, result)
4465:                       lexer.cond.push true
4466:                     
4467:     result
4468: end
_reduce_307(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4470
4470: def _reduce_307(val, _values, result)
4471:                       lexer.cond.pop
4472:                     
4473:     result
4474: end
_reduce_308(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4476
4476: def _reduce_308(val, _values, result)
4477:                       result = new_for val[4], val[1], val[7]
4478:                     
4479:     result
4480: end
_reduce_309(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4482
4482: def _reduce_309(val, _values, result)
4483:                       result = self.lexer.lineno
4484:                     
4485:     result
4486: end
_reduce_31(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3118
3118: def _reduce_31(val, _values, result)
3119:                       result = self.node_assign val[0], s(:svalue, val[2])
3120:                     
3121:     result
3122: end
_reduce_310(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4488
4488: def _reduce_310(val, _values, result)
4489:                       self.comments.push self.lexer.comments
4490:                       if (self.in_def || self.in_single > 0) then
4491:                         yyerror "class definition in method body"
4492:                       end
4493:                       self.env.extend
4494:                     
4495:     result
4496: end
_reduce_311(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4498
4498: def _reduce_311(val, _values, result)
4499:                       result = new_class val
4500:                       self.env.unextend
4501:                     
4502:     result
4503: end
_reduce_312(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4505
4505: def _reduce_312(val, _values, result)
4506:                       result = self.lexer.lineno
4507:                     
4508:     result
4509: end
_reduce_313(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4511
4511: def _reduce_313(val, _values, result)
4512:                       result = self.in_def
4513:                       self.in_def = false
4514:                     
4515:     result
4516: end
_reduce_314(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4518
4518: def _reduce_314(val, _values, result)
4519:                       result = self.in_single
4520:                       self.in_single = 0
4521:                       self.env.extend
4522:                     
4523:     result
4524: end
_reduce_315(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4526
4526: def _reduce_315(val, _values, result)
4527:                       result = new_sclass val
4528:                       self.env.unextend
4529:                     
4530:     result
4531: end
_reduce_316(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4533
4533: def _reduce_316(val, _values, result)
4534:                       result = self.lexer.lineno
4535:                     
4536:     result
4537: end
_reduce_317(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4539
4539: def _reduce_317(val, _values, result)
4540:                       self.comments.push self.lexer.comments
4541:                       yyerror "module definition in method body" if
4542:                         self.in_def or self.in_single > 0
4543: 
4544:                       self.env.extend
4545:                     
4546:     result
4547: end
_reduce_318(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4549
4549: def _reduce_318(val, _values, result)
4550:                       result = new_module val
4551:                       self.env.unextend
4552:                     
4553:     result
4554: end
_reduce_319(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4556
4556: def _reduce_319(val, _values, result)
4557:                       self.comments.push self.lexer.comments
4558:                       self.in_def = true
4559:                       self.env.extend
4560:                       result = lexer.lineno, lexer.src.beginning_of_line?
4561:                     
4562:     result
4563: end
_reduce_32(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3124
3124: def _reduce_32(val, _values, result)
3125:                       result = new_masgn val[0], val[2], :wrap
3126:                     
3127:     result
3128: end
_reduce_320(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4565
4565: def _reduce_320(val, _values, result)
4566:                       result = new_defn val
4567:                       self.env.unextend
4568:                       self.in_def = false
4569:                     
4570:     result
4571: end
_reduce_321(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4573
4573: def _reduce_321(val, _values, result)
4574:                       self.comments.push self.lexer.comments
4575:                       lexer.lex_state = :expr_fname
4576:                     
4577:     result
4578: end
_reduce_322(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4580
4580: def _reduce_322(val, _values, result)
4581:                       self.in_single += 1
4582:                       self.env.extend
4583:                       lexer.lex_state = :expr_end # force for args
4584:                     
4585:     result
4586: end
_reduce_323(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4588
4588: def _reduce_323(val, _values, result)
4589:                       result = new_defs val
4590: 
4591:                       self.env.unextend
4592:                       self.in_single -= 1
4593:                     
4594:     result
4595: end
_reduce_324(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4597
4597: def _reduce_324(val, _values, result)
4598:                       result = s(:break)
4599:                     
4600:     result
4601: end
_reduce_325(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4603
4603: def _reduce_325(val, _values, result)
4604:                       result = s(:next)
4605:                     
4606:     result
4607: end
_reduce_326(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4609
4609: def _reduce_326(val, _values, result)
4610:                       result = s(:redo)
4611:                     
4612:     result
4613: end
_reduce_327(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4615
4615: def _reduce_327(val, _values, result)
4616:                       result = s(:retry)
4617:                     
4618:     result
4619: end
_reduce_328(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4621
4621: def _reduce_328(val, _values, result)
4622:                       result = value_expr(val[0])
4623:                     
4624:     result
4625: end
_reduce_33(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3130
3130: def _reduce_33(val, _values, result)
3131:                       result = new_masgn val[0], val[2]
3132:                     
3133:     result
3134: end
_reduce_337(val, _values, result) click to toggle source

reduce 336 omitted

      # File lib/ruby_parser.rb, line 4643
4643: def _reduce_337(val, _values, result)
4644:                       result = s(:if, val[1], val[3], val[4])
4645:                     
4646:     result
4647: end
_reduce_339(val, _values, result) click to toggle source

reduce 338 omitted

      # File lib/ruby_parser.rb, line 4651
4651: def _reduce_339(val, _values, result)
4652:                       result = val[1]
4653:                     
4654:     result
4655: end
_reduce_341(val, _values, result) click to toggle source

reduce 340 omitted

      # File lib/ruby_parser.rb, line 4659
4659: def _reduce_341(val, _values, result)
4660:                       val[0].delete_at 1 if val[0][1].nil? # HACK
4661:                     
4662:     result
4663: end
_reduce_343(val, _values, result) click to toggle source

reduce 342 omitted

      # File lib/ruby_parser.rb, line 4667
4667: def _reduce_343(val, _values, result)
4668:                       result = 0
4669:                       self.lexer.command_start = true
4670:                     
4671:     result
4672: end
_reduce_344(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4674
4674: def _reduce_344(val, _values, result)
4675:                       result = 0
4676:                       self.lexer.command_start = true
4677:                     
4678:     result
4679: end
_reduce_345(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4681
4681: def _reduce_345(val, _values, result)
4682:                       result = val[1]
4683:                       self.lexer.command_start = true
4684:                     
4685:     result
4686: end
_reduce_346(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4688
4688: def _reduce_346(val, _values, result)
4689:                       self.env.extend :dynamic
4690:                       result = self.lexer.lineno
4691:                     
4692:     result
4693: end
_reduce_347(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4695
4695: def _reduce_347(val, _values, result)
4696:                       result = self.env.dynamic.keys
4697:                     
4698:     result
4699: end
_reduce_348(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4701
4701: def _reduce_348(val, _values, result)
4702:                       vars   = val[2]
4703:                       body   = val[4]
4704:                       result = new_iter nil, vars, body
4705:                       result.line = val[1]
4706: 
4707:                       self.env.unextend
4708:                     
4709:     result
4710: end
_reduce_349(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4712
4712: def _reduce_349(val, _values, result)
4713:                       raise SyntaxError, "Both block arg and actual block given." if
4714:                         val[0] && val[0][0] == :blockpass
4715: 
4716:                       result = val[1]
4717:                       result.insert 1, val[0]
4718:                     
4719:     result
4720: end
_reduce_350(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4722
4722: def _reduce_350(val, _values, result)
4723:                       result = new_call val[0], val[2], val[3]
4724:                     
4725:     result
4726: end
_reduce_351(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4728
4728: def _reduce_351(val, _values, result)
4729:                       result = new_call val[0], val[2], val[3]
4730:                     
4731:     result
4732: end
_reduce_352(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4734
4734: def _reduce_352(val, _values, result)
4735:                       result = self.lexer.lineno
4736:                     
4737:     result
4738: end
_reduce_353(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4740
4740: def _reduce_353(val, _values, result)
4741:                       result = new_call nil, val[0].to_sym, val[2]
4742:                     
4743:     result
4744: end
_reduce_354(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4746
4746: def _reduce_354(val, _values, result)
4747:                       result = new_call val[0], val[2].to_sym, val[3]
4748:                     
4749:     result
4750: end
_reduce_355(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4752
4752: def _reduce_355(val, _values, result)
4753:                       result = new_call val[0], val[2].to_sym, val[3]
4754:                     
4755:     result
4756: end
_reduce_356(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4758
4758: def _reduce_356(val, _values, result)
4759:                       result = new_call val[0], val[2].to_sym
4760:                     
4761:     result
4762: end
_reduce_357(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4764
4764: def _reduce_357(val, _values, result)
4765:                       result = new_super val[1]
4766:                     
4767:     result
4768: end
_reduce_358(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4770
4770: def _reduce_358(val, _values, result)
4771:                       result = s(:zsuper)
4772:                     
4773:     result
4774: end
_reduce_359(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4776
4776: def _reduce_359(val, _values, result)
4777:                       self.env.extend :dynamic
4778:                       result = self.lexer.lineno
4779:                     
4780:     result
4781: end
_reduce_36(val, _values, result) click to toggle source

reduce 35 omitted

      # File lib/ruby_parser.rb, line 3140
3140: def _reduce_36(val, _values, result)
3141:                       result = logop(:and, val[0], val[2])
3142:                     
3143:     result
3144: end
_reduce_360(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4783
4783: def _reduce_360(val, _values, result)
4784:                       result = self.env.dynamic.keys
4785:                     
4786:     result
4787: end
_reduce_361(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4789
4789: def _reduce_361(val, _values, result)
4790:                       # REFACTOR
4791:                       args   = val[2]
4792:                       body   = val[4]
4793:                       result = new_iter nil, args, body
4794:                       self.env.unextend
4795:                       result.line = val[1]
4796:                     
4797:     result
4798: end
_reduce_362(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4800
4800: def _reduce_362(val, _values, result)
4801:                       self.env.extend :dynamic
4802:                       result = self.lexer.lineno
4803:                     
4804:     result
4805: end
_reduce_363(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4807
4807: def _reduce_363(val, _values, result)
4808:                       result = self.env.dynamic.keys
4809:                     
4810:     result
4811: end
_reduce_364(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4813
4813: def _reduce_364(val, _values, result)
4814:                       args = val[2]
4815:                       body = val[4]
4816:                       result = new_iter nil, args, body
4817:                       self.env.unextend
4818:                       result.line = val[1]
4819:                     
4820:     result
4821: end
_reduce_365(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4823
4823: def _reduce_365(val, _values, result)
4824:                       result = self.lexer.lineno
4825:                     
4826:     result
4827: end
_reduce_366(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4829
4829: def _reduce_366(val, _values, result)
4830:                       result = s(:when, val[2], val[4])
4831:                       result.line = val[1]
4832:                       result << val[5] if val[5]
4833:                     
4834:     result
4835: end
_reduce_368(val, _values, result) click to toggle source

reduce 367 omitted

      # File lib/ruby_parser.rb, line 4839
4839: def _reduce_368(val, _values, result)
4840:                       result = self.list_append val[0], s(:when, val[3], nil)
4841:                     
4842:     result
4843: end
_reduce_369(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4845
4845: def _reduce_369(val, _values, result)
4846:                       result = s(:array, s(:when, val[1], nil))
4847:                     
4848:     result
4849: end
_reduce_37(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3146
3146: def _reduce_37(val, _values, result)
3147:                       result = logop(:or, val[0], val[2])
3148:                     
3149:     result
3150: end
_reduce_372(val, _values, result) click to toggle source

reduce 371 omitted

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

reduce 376 omitted

      # File lib/ruby_parser.rb, line 4883
4883: def _reduce_377(val, _values, result)
4884:                       result = val[1]
4885:                     
4886:     result
4887: end
_reduce_379(val, _values, result) click to toggle source

reduce 378 omitted

      # File lib/ruby_parser.rb, line 4891
4891: def _reduce_379(val, _values, result)
4892:                       if (val[1] != nil) then
4893:                         result = val[1]
4894:                       else
4895:                         result = s(:nil)
4896:                       end
4897:                     
4898:     result
4899: end
_reduce_38(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3152
3152: def _reduce_38(val, _values, result)
3153:                       result = s(:not, val[1])
3154:                     
3155:     result
3156: end
_reduce_381(val, _values, result) click to toggle source

reduce 380 omitted

      # File lib/ruby_parser.rb, line 4903
4903: def _reduce_381(val, _values, result)
4904:  result = s(:lit, val[0]) 
4905:     result
4906: end
_reduce_382(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4908
4908: def _reduce_382(val, _values, result)
4909:  result = s(:lit, val[0]) 
4910:     result
4911: end
_reduce_384(val, _values, result) click to toggle source

reduce 383 omitted

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

reduce 385 omitted

      # File lib/ruby_parser.rb, line 4924
4924: def _reduce_386(val, _values, result)
4925:                       result = self.literal_concat val[0], val[1]
4926:                     
4927:     result
4928: end
_reduce_387(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4930
4930: def _reduce_387(val, _values, result)
4931:                       result = val[1]
4932:                     
4933:     result
4934: end
_reduce_388(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4936
4936: def _reduce_388(val, _values, result)
4937:                       result = s(:str, val[0])
4938:                     
4939:     result
4940: end
_reduce_389(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4942
4942: def _reduce_389(val, _values, result)
4943:                       result = new_xstring val[1]
4944:                     
4945:     result
4946: end
_reduce_39(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3158
3158: def _reduce_39(val, _values, result)
3159:                       result = s(:not, val[1])
3160:                     
3161:     result
3162: end
_reduce_390(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4948
4948: def _reduce_390(val, _values, result)
4949:                       result = new_regexp val
4950:                     
4951:     result
4952: end
_reduce_391(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4954
4954: def _reduce_391(val, _values, result)
4955:                       result = s(:array)
4956:                     
4957:     result
4958: end
_reduce_392(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4960
4960: def _reduce_392(val, _values, result)
4961:                       result = val[1]
4962:                     
4963:     result
4964: end
_reduce_393(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4966
4966: def _reduce_393(val, _values, result)
4967:                       result = s(:array)
4968:                     
4969:     result
4970: end
_reduce_394(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4972
4972: def _reduce_394(val, _values, result)
4973:                       word = val[1][0] == :evstr ? s(:dstr, "", val[1]) : val[1]
4974:                       result = val[0] << word
4975:                     
4976:     result
4977: end
_reduce_396(val, _values, result) click to toggle source

reduce 395 omitted

      # File lib/ruby_parser.rb, line 4981
4981: def _reduce_396(val, _values, result)
4982:                       result = self.literal_concat val[0], val[1]
4983:                     
4984:     result
4985: end
_reduce_397(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4987
4987: def _reduce_397(val, _values, result)
4988:                       result = s(:array)
4989:                     
4990:     result
4991: end
_reduce_398(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4993
4993: def _reduce_398(val, _values, result)
4994:                       result = val[1]
4995:                     
4996:     result
4997: end
_reduce_399(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 4999
4999: def _reduce_399(val, _values, result)
5000:                       result = s(:array)
5001:                     
5002:     result
5003: end
_reduce_4(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2956
2956: def _reduce_4(val, _values, result)
2957:                       result = new_compstmt val
2958:                     
2959:     result
2960: end
_reduce_400(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5005
5005: def _reduce_400(val, _values, result)
5006:                       result = val[0] << s(:str, val[1])
5007:                     
5008:     result
5009: end
_reduce_401(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5011
5011: def _reduce_401(val, _values, result)
5012:                       result = s(:str, "")
5013:                     
5014:     result
5015: end
_reduce_402(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5017
5017: def _reduce_402(val, _values, result)
5018:                       result = literal_concat(val[0], val[1])
5019:                     
5020:     result
5021: end
_reduce_403(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5023
5023: def _reduce_403(val, _values, result)
5024:                       result = nil
5025:                     
5026:     result
5027: end
_reduce_404(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5029
5029: def _reduce_404(val, _values, result)
5030:                       result = literal_concat(val[0], val[1])
5031:                     
5032:     result
5033: end
_reduce_405(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5035
5035: def _reduce_405(val, _values, result)
5036:                       result = s(:str, val[0])
5037:                     
5038:     result
5039: end
_reduce_406(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5041
5041: def _reduce_406(val, _values, result)
5042:                       result = lexer.lex_strterm
5043:                       lexer.lex_strterm = nil
5044:                       lexer.lex_state = :expr_beg
5045:                     
5046:     result
5047: end
_reduce_407(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5049
5049: def _reduce_407(val, _values, result)
5050:                       lexer.lex_strterm = val[1]
5051:                       result = s(:evstr, val[2])
5052:                     
5053:     result
5054: end
_reduce_408(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5056
5056: def _reduce_408(val, _values, result)
5057:                       result = lexer.lex_strterm
5058:                       lexer.lex_strterm = nil
5059:                       lexer.lex_state = :expr_beg
5060:                       lexer.cond.push false
5061:                       lexer.cmdarg.push false
5062:                     
5063:     result
5064: end
_reduce_409(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5066
5066: def _reduce_409(val, _values, result)
5067:                       lexer.lex_strterm = val[1]
5068:                       lexer.cond.lexpop
5069:                       lexer.cmdarg.lexpop
5070: 
5071:                       case val[2]
5072:                       when Sexp then
5073:                         case val[2][0]
5074:                         when :str, :dstr, :evstr then
5075:                           result = val[2]
5076:                         else
5077:                           result = s(:evstr, val[2])
5078:                         end
5079:                       when nil then
5080:                         result = s(:evstr)
5081:                       else
5082:                         raise "unknown rescue body: #{val[2].inspect}"
5083:                       end
5084:                     
5085:     result
5086: end
_reduce_41(val, _values, result) click to toggle source

reduce 40 omitted

      # File lib/ruby_parser.rb, line 3166
3166: def _reduce_41(val, _values, result)
3167:                       result = value_expr(val[0])
3168:                     
3169:     result
3170: end
_reduce_410(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5088
5088: def _reduce_410(val, _values, result)
5089:  result = s(:gvar, val[0].to_sym) 
5090:     result
5091: end
_reduce_411(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5093
5093: def _reduce_411(val, _values, result)
5094:  result = s(:ivar, val[0].to_sym) 
5095:     result
5096: end
_reduce_412(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5098
5098: def _reduce_412(val, _values, result)
5099:  result = s(:cvar, val[0].to_sym) 
5100:     result
5101: end
_reduce_414(val, _values, result) click to toggle source

reduce 413 omitted

      # File lib/ruby_parser.rb, line 5105
5105: def _reduce_414(val, _values, result)
5106:                       lexer.lex_state = :expr_end
5107:                       result = val[1].to_sym
5108:                     
5109:     result
5110: end
_reduce_415(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5112
5112: def _reduce_415(val, _values, result)
5113:                       result = val[0].to_sym
5114:                     
5115:     result
5116: end
_reduce_420(val, _values, result) click to toggle source

reduce 419 omitted

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

reduce 422 omitted

      # File lib/ruby_parser.rb, line 5149
5149: def _reduce_423(val, _values, result)
5150:                       result = -val[1] # TODO: pt_testcase
5151:                     
5152:     result
5153: end
_reduce_424(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5155
5155: def _reduce_424(val, _values, result)
5156:                       result = -val[1] # TODO: pt_testcase
5157:                     
5158:     result
5159: end
_reduce_430(val, _values, result) click to toggle source

reduce 429 omitted

      # File lib/ruby_parser.rb, line 5171
5171: def _reduce_430(val, _values, result)
5172:  result = s(:nil)   
5173:     result
5174: end
_reduce_431(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5176
5176: def _reduce_431(val, _values, result)
5177:  result = s(:self)  
5178:     result
5179: end
_reduce_432(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5181
5181: def _reduce_432(val, _values, result)
5182:  result = s(:true)  
5183:     result
5184: end
_reduce_433(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5186
5186: def _reduce_433(val, _values, result)
5187:  result = s(:false) 
5188:     result
5189: end
_reduce_434(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5191
5191: def _reduce_434(val, _values, result)
5192:  result = s(:str, self.file) 
5193:     result
5194: end
_reduce_435(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5196
5196: def _reduce_435(val, _values, result)
5197:  result = s(:lit, lexer.src.current_line) 
5198:     result
5199: end
_reduce_436(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5201
5201: def _reduce_436(val, _values, result)
5202:                       var = val[0]
5203:                       result = Sexp === var ? var : self.gettable(var)
5204:                     
5205:     result
5206: end
_reduce_437(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5208
5208: def _reduce_437(val, _values, result)
5209:                       result = self.assignable val[0]
5210:                     
5211:     result
5212: end
_reduce_438(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5214
5214: def _reduce_438(val, _values, result)
5215:  result = s(:nth_ref,  val[0]) 
5216:     result
5217: end
_reduce_439(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5219
5219: def _reduce_439(val, _values, result)
5220:  result = s(:back_ref, val[0]) 
5221:     result
5222: end
_reduce_44(val, _values, result) click to toggle source

reduce 43 omitted

      # File lib/ruby_parser.rb, line 3176
3176: def _reduce_44(val, _values, result)
3177:                       line = val[0].last
3178:                       result = s(:return, ret_args(val[1])).line(line)
3179:                     
3180:     result
3181: end
_reduce_440(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5224
5224: def _reduce_440(val, _values, result)
5225:                       result = nil
5226:                     
5227:     result
5228: end
_reduce_441(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5230
5230: def _reduce_441(val, _values, result)
5231:                       lexer.lex_state = :expr_beg
5232:                     
5233:     result
5234: end
_reduce_442(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5236
5236: def _reduce_442(val, _values, result)
5237:                       result = val[2]
5238:                     
5239:     result
5240: end
_reduce_443(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5242
5242: def _reduce_443(val, _values, result)
5243:                       yyerrok
5244:                       result = nil
5245:                     
5246:     result
5247: end
_reduce_444(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5249
5249: def _reduce_444(val, _values, result)
5250:                       result = val[1]
5251:                       lexer.lex_state = :expr_beg
5252:                       self.lexer.command_start = true
5253:                     
5254:     result
5255: end
_reduce_445(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5257
5257: def _reduce_445(val, _values, result)
5258:                       result = val[0]
5259:                     
5260:     result
5261: end
_reduce_446(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5263
5263: def _reduce_446(val, _values, result)
5264:                       result = args val[0], val[2], val[4], val[5]
5265:                     
5266:     result
5267: end
_reduce_447(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5269
5269: def _reduce_447(val, _values, result)
5270:                       result = args val[0], val[2],    nil, val[3]
5271:                     
5272:     result
5273: end
_reduce_448(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5275
5275: def _reduce_448(val, _values, result)
5276:                       result = args val[0],    nil, val[2], val[3]
5277:                     
5278:     result
5279: end
_reduce_449(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5281
5281: def _reduce_449(val, _values, result)
5282:                       result = args val[0],    nil,    nil, val[1]
5283:                     
5284:     result
5285: end
_reduce_45(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3183
3183: def _reduce_45(val, _values, result)
3184:                       line = val[0].last
3185:                       result = s(:break, ret_args(val[1])).line(line)
3186:                     
3187:     result
3188: end
_reduce_450(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5287
5287: def _reduce_450(val, _values, result)
5288:                       result = args    nil, val[0], val[2], val[3]
5289:                     
5290:     result
5291: end
_reduce_451(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5293
5293: def _reduce_451(val, _values, result)
5294:                       result = args    nil, val[0],    nil, val[1]
5295:                     
5296:     result
5297: end
_reduce_452(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5299
5299: def _reduce_452(val, _values, result)
5300:                       result = args    nil,    nil, val[0], val[1]
5301:                     
5302:     result
5303: end
_reduce_453(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5305
5305: def _reduce_453(val, _values, result)
5306:                       result = args    nil,    nil,    nil, val[0]
5307:                     
5308:     result
5309: end
_reduce_454(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5311
5311: def _reduce_454(val, _values, result)
5312:                       result = args    nil,    nil,    nil,    nil
5313:                     
5314:     result
5315: end
_reduce_455(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5317
5317: def _reduce_455(val, _values, result)
5318:                       yyerror "formal argument cannot be a constant: #{val[0]}"
5319:                     
5320:     result
5321: end
_reduce_456(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5323
5323: def _reduce_456(val, _values, result)
5324:                       yyerror "formal argument cannot be an instance variable"
5325:                     
5326:     result
5327: end
_reduce_457(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5329
5329: def _reduce_457(val, _values, result)
5330:                       yyerror "formal argument cannot be a class variable"
5331:                     
5332:     result
5333: end
_reduce_458(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5335
5335: def _reduce_458(val, _values, result)
5336:                       identifier = val[0].to_sym
5337:                       self.env[identifier] = :lvar
5338: 
5339:                       result = val[0]
5340:                     
5341:     result
5342: end
_reduce_459(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5344
5344: def _reduce_459(val, _values, result)
5345:                       result = s(:args)
5346:                       result << val[0].to_sym
5347:                     
5348:     result
5349: end
_reduce_46(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3190
3190: def _reduce_46(val, _values, result)
3191:                       line = val[0].last
3192:                       result = s(:next, ret_args(val[1])).line(line)
3193:                     
3194:     result
3195: end
_reduce_460(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5351
5351: def _reduce_460(val, _values, result)
5352:                       val[0] << val[2].to_sym
5353:                       result = val[0]
5354:                     
5355:     result
5356: end
_reduce_461(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5358
5358: def _reduce_461(val, _values, result)
5359:                       result = self.assignable val[0], val[2]
5360:                       # TODO: detect duplicate names
5361:                     
5362:     result
5363: end
_reduce_462(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5365
5365: def _reduce_462(val, _values, result)
5366:                       result = s(:block, val[0])
5367:                     
5368:     result
5369: end
_reduce_463(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5371
5371: def _reduce_463(val, _values, result)
5372:                       result = self.block_append val[0], val[2]
5373:                     
5374:     result
5375: end
_reduce_466(val, _values, result) click to toggle source

reduce 465 omitted

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

reduce 469 omitted

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

reduce 473 omitted

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

reduce 47 omitted

      # File lib/ruby_parser.rb, line 3199
3199: def _reduce_48(val, _values, result)
3200:                       result = new_call val[0], val[2], val[3]
3201:                     
3202:     result
3203: end
_reduce_480(val, _values, result) click to toggle source

reduce 479 omitted

      # File lib/ruby_parser.rb, line 5463
5463: def _reduce_480(val, _values, result)
5464:                       list = val[0].dup
5465:                       more = val[2][1..1]
5466:                       list.push(*more) unless more.empty?
5467:                       result = list
5468:                     
5469:     result
5470: end
_reduce_481(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5472
5472: def _reduce_481(val, _values, result)
5473:                       result = s(:array, val[0], val[2])
5474:                     
5475:     result
5476: end
_reduce_49(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3205
3205: def _reduce_49(val, _values, result)
3206:                       result = new_call val[0], val[2], val[3]
3207:                     
3208:     result
3209: end
_reduce_50(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3211
3211: def _reduce_50(val, _values, result)
3212:                       self.env.extend(:dynamic)
3213:                       result = self.lexer.lineno
3214:                     
3215:     result
3216: end
_reduce_501(val, _values, result) click to toggle source

reduce 500 omitted

      # File lib/ruby_parser.rb, line 5516
5516: def _reduce_501(val, _values, result)
5517:  yyerrok 
5518:     result
5519: end
_reduce_504(val, _values, result) click to toggle source

reduce 503 omitted

      # File lib/ruby_parser.rb, line 5525
5525: def _reduce_504(val, _values, result)
5526:  yyerrok 
5527:     result
5528: end
_reduce_505(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5530
5530: def _reduce_505(val, _values, result)
5531:  result = nil 
5532:     result
5533: end
_reduce_506(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 5535
5535: def _reduce_506(val, _values, result)
5536:  result = nil 
5537:     result
5538: end
_reduce_51(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3218
3218: def _reduce_51(val, _values, result)
3219:                       result = self.env.dynamic.keys
3220:                     
3221:     result
3222: end
_reduce_52(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3224
3224: def _reduce_52(val, _values, result)
3225:                       result = new_iter nil, val[2], val[4]
3226:                       self.env.unextend
3227:                     
3228:     result
3229: end
_reduce_53(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3231
3231: def _reduce_53(val, _values, result)
3232:                       result = new_call nil, val[0].to_sym, val[1]
3233:                     
3234:     result
3235: end
_reduce_54(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3237
3237: def _reduce_54(val, _values, result)
3238:                       result = new_call nil, val[0].to_sym, val[1]
3239:                       if val[2] then
3240:                         if result[0] == :block_pass then
3241:                           raise "both block arg and actual block given"
3242:                         end
3243:                         result, operation = val[2], result
3244:                         result.insert 1, operation
3245:                       end
3246:                     
3247:     result
3248: end
_reduce_55(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3250
3250: def _reduce_55(val, _values, result)
3251:                       result = new_call val[0], val[2].to_sym, val[3]
3252:                     
3253:     result
3254: end
_reduce_56(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3256
3256: def _reduce_56(val, _values, result)
3257:                       result = new_call val[0], val[2].to_sym, val[3]
3258:                     
3259:     result
3260: end
_reduce_57(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3262
3262: def _reduce_57(val, _values, result)
3263:                       result = new_call val[0], val[2].to_sym, val[3]
3264:                     
3265:     result
3266: end
_reduce_58(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3268
3268: def _reduce_58(val, _values, result)
3269:                       result = new_call val[0], val[2].to_sym, val[3]
3270:                       if val[4] then
3271:                         if result[0] == :block_pass then # REFACTOR
3272:                           raise "both block arg and actual block given"
3273:                         end
3274:                         val[2] << result
3275:                         result = val[2]
3276:                       end
3277:                     
3278:     result
3279: end
_reduce_59(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3281
3281: def _reduce_59(val, _values, result)
3282:                       result = new_super val[1]
3283:                     
3284:     result
3285: end
_reduce_60(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3287
3287: def _reduce_60(val, _values, result)
3288:                       result = new_yield val[1]
3289:                     
3290:     result
3291: end
_reduce_62(val, _values, result) click to toggle source

reduce 61 omitted

      # File lib/ruby_parser.rb, line 3295
3295: def _reduce_62(val, _values, result)
3296:                       result = val[1]
3297:                     
3298:     result
3299: end
_reduce_64(val, _values, result) click to toggle source

reduce 63 omitted

      # File lib/ruby_parser.rb, line 3303
3303: def _reduce_64(val, _values, result)
3304:                       result = s(:masgn, s(:array, val[1]))
3305:                     
3306:     result
3307: end
_reduce_65(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3309
3309: def _reduce_65(val, _values, result)
3310:                       result = s(:masgn, val[0])
3311:                     
3312:     result
3313: end
_reduce_66(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3315
3315: def _reduce_66(val, _values, result)
3316:                       result = s(:masgn, val[0] << val[1].compact)
3317:                     
3318:     result
3319: end
_reduce_67(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3321
3321: def _reduce_67(val, _values, result)
3322:                       result = s(:masgn, val[0] << s(:splat, val[2]))
3323:                     
3324:     result
3325: end
_reduce_68(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3327
3327: def _reduce_68(val, _values, result)
3328:                       result = s(:masgn, val[0] << s(:splat))
3329:                     
3330:     result
3331: end
_reduce_69(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3333
3333: def _reduce_69(val, _values, result)
3334:                       result = s(:masgn, s(:array, s(:splat, val[1])))
3335:                     
3336:     result
3337: end
_reduce_7(val, _values, result) click to toggle source

reduce 6 omitted

      # File lib/ruby_parser.rb, line 2966
2966: def _reduce_7(val, _values, result)
2967:                       result = self.block_append val[0], val[2]
2968:                     
2969:     result
2970: end
_reduce_70(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3339
3339: def _reduce_70(val, _values, result)
3340:                       result = s(:masgn, s(:array, s(:splat)))
3341:                     
3342:     result
3343: end
_reduce_72(val, _values, result) click to toggle source

reduce 71 omitted

      # File lib/ruby_parser.rb, line 3347
3347: def _reduce_72(val, _values, result)
3348:                       result = val[1]
3349:                     
3350:     result
3351: end
_reduce_73(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3353
3353: def _reduce_73(val, _values, result)
3354:                       result = s(:array, val[0])
3355:                     
3356:     result
3357: end
_reduce_74(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3359
3359: def _reduce_74(val, _values, result)
3360:                       result = val[0] << val[1].compact
3361:                     
3362:     result
3363: end
_reduce_75(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3365
3365: def _reduce_75(val, _values, result)
3366:                       result = self.assignable val[0]
3367:                     
3368:     result
3369: end
_reduce_76(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3371
3371: def _reduce_76(val, _values, result)
3372:                       result = self.aryset val[0], val[2]
3373:                     
3374:     result
3375: end
_reduce_77(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3377
3377: def _reduce_77(val, _values, result)
3378:                       result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
3379:                     
3380:     result
3381: end
_reduce_78(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3383
3383: def _reduce_78(val, _values, result)
3384:                       result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
3385:                     
3386:     result
3387: end
_reduce_79(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3389
3389: def _reduce_79(val, _values, result)
3390:                       result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist))
3391:                     
3392:     result
3393: end
_reduce_8(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2972
2972: def _reduce_8(val, _values, result)
2973:                       result = val[1]
2974:                     
2975:     result
2976: end
_reduce_80(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3395
3395: def _reduce_80(val, _values, result)
3396:                       if (self.in_def || self.in_single > 0) then
3397:                         yyerror "dynamic constant assignment"
3398:                       end
3399: 
3400:                       result = s(:const, s(:colon2, val[0], val[2].to_sym), nil)
3401:                     
3402:     result
3403: end
_reduce_81(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3405
3405: def _reduce_81(val, _values, result)
3406:                       if (self.in_def || self.in_single > 0) then
3407:                         yyerror "dynamic constant assignment"
3408:                       end
3409: 
3410:                       result = s(:const, nil, s(:colon3, val[1].to_sym))
3411:                     
3412:     result
3413: end
_reduce_82(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3415
3415: def _reduce_82(val, _values, result)
3416:                       self.backref_assign_error val[0]
3417:                     
3418:     result
3419: end
_reduce_83(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3421
3421: def _reduce_83(val, _values, result)
3422:                       result = self.assignable val[0]
3423:                     
3424:     result
3425: end
_reduce_84(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3427
3427: def _reduce_84(val, _values, result)
3428:                       result = self.aryset val[0], val[2]
3429:                     
3430:     result
3431: end
_reduce_85(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3433
3433: def _reduce_85(val, _values, result)
3434:                       result = s(:attrasgn, val[0], :"#{val[2]}=")
3435:                     
3436:     result
3437: end
_reduce_86(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3439
3439: def _reduce_86(val, _values, result)
3440:                       result = s(:attrasgn, val[0], :"#{val[2]}=")
3441:                     
3442:     result
3443: end
_reduce_87(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3445
3445: def _reduce_87(val, _values, result)
3446:                       result = s(:attrasgn, val[0], :"#{val[2]}=")
3447:                     
3448:     result
3449: end
_reduce_88(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3451
3451: def _reduce_88(val, _values, result)
3452:                       if (self.in_def || self.in_single > 0) then
3453:                         yyerror "dynamic constant assignment"
3454:                       end
3455: 
3456:                       result = s(:const, s(:colon2, val[0], val[2].to_sym))
3457:                     
3458:     result
3459: end
_reduce_89(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3461
3461: def _reduce_89(val, _values, result)
3462:                       if (self.in_def || self.in_single > 0) then
3463:                         yyerror "dynamic constant assignment"
3464:                       end
3465: 
3466:                       result = s(:const, s(:colon3, val[1].to_sym))
3467:                     
3468:     result
3469: end
_reduce_9(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 2978
2978: def _reduce_9(val, _values, result)
2979:                       lexer.lex_state = :expr_fname
2980:                       result = self.lexer.lineno
2981:                     
2982:     result
2983: end
_reduce_90(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3471
3471: def _reduce_90(val, _values, result)
3472:                       self.backref_assign_error val[0]
3473:                     
3474:     result
3475: end
_reduce_91(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3477
3477: def _reduce_91(val, _values, result)
3478:                       yyerror "class/module name must be CONSTANT"
3479:                     
3480:     result
3481: end
_reduce_93(val, _values, result) click to toggle source

reduce 92 omitted

      # File lib/ruby_parser.rb, line 3485
3485: def _reduce_93(val, _values, result)
3486:                       result = s(:colon3, val[1].to_sym)
3487:                     
3488:     result
3489: end
_reduce_94(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3491
3491: def _reduce_94(val, _values, result)
3492:                       result = val[0].to_sym
3493:                     
3494:     result
3495: end
_reduce_95(val, _values, result) click to toggle source
      # File lib/ruby_parser.rb, line 3497
3497: def _reduce_95(val, _values, result)
3498:                       result = s(:colon2, val[0], val[2].to_sym)
3499:                     
3500:     result
3501: end
_reduce_99(val, _values, result) click to toggle source

reduce 98 omitted

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

for pure ruby systems only

     # File lib/ruby_parser_extras.rb, line 268
268:   def do_parse
269:     _racc_do_parse_rb(_racc_setup, false)
270:   end
get_match_node(lhs, rhs) click to toggle source
     # File lib/ruby_parser_extras.rb, line 272
272:   def get_match_node lhs, rhs # TODO: rename to new_match
273:     if lhs then
274:       case lhs[0]
275:       when :dregx, :dregx_once then
276:         return s(:match2, lhs, rhs).line(lhs.line)
277:       when :lit then
278:         return s(:match2, lhs, rhs).line(lhs.line) if Regexp === lhs.last
279:       end
280:     end
281: 
282:     if rhs then
283:       case rhs[0]
284:       when :dregx, :dregx_once then
285:         return s(:match3, rhs, lhs).line(lhs.line)
286:       when :lit then
287:         return s(:match3, rhs, lhs).line(lhs.line) if Regexp === rhs.last
288:       end
289:     end
290: 
291:     return s(:call, lhs, :"=~", s(:arglist, rhs)).line(lhs.line)
292:   end
gettable(id) click to toggle source
     # File lib/ruby_parser_extras.rb, line 294
294:   def gettable(id)
295:     id = id.to_sym if String === id
296: 
297:     result = case id.to_s
298:              when /^@@/ then
299:                s(:cvar, id)
300:              when /^@/ then
301:                s(:ivar, id)
302:              when /^\$/ then
303:                s(:gvar, id)
304:              when /^[A-Z]/ then
305:                s(:const, id)
306:              else
307:                type = env[id]
308:                if type then
309:                  s(type, id)
310:                elsif env.dynamic? and :dvar == env[id] then
311:                  s(:lvar, id)
312:                else
313:                  s(:call, nil, id, s(:arglist))
314:                end
315:              end
316: 
317:     raise "identifier #{id.inspect} is not valid" unless result
318: 
319:     result
320:   end
list_append(list, item) click to toggle source
     # File lib/ruby_parser_extras.rb, line 345
345:   def list_append list, item # TODO: nuke me *sigh*
346:     return s(:array, item) unless list
347:     list = s(:array, list) unless Sexp === list && list.first == :array
348:     list << item
349:   end
list_prepend(item, list) click to toggle source
     # File lib/ruby_parser_extras.rb, line 351
351:   def list_prepend item, list # TODO: nuke me *sigh*
352:     list = s(:array, list) unless Sexp === list && list[0] == :array
353:     list.insert 1, item
354:     list
355:   end
literal_concat(head, tail) click to toggle source
     # File lib/ruby_parser_extras.rb, line 357
357:   def literal_concat head, tail
358:     return tail unless head
359:     return head unless tail
360: 
361:     htype, ttype = head[0], tail[0]
362: 
363:     head = s(:dstr, '', head) if htype == :evstr
364: 
365:     case ttype
366:     when :str then
367:       if htype == :str
368:         head[1] << tail[1]
369:       elsif htype == :dstr and head.size == 2 then
370:         head[1] << tail[1]
371:       else
372:         head << tail
373:       end
374:     when :dstr then
375:       if htype == :str then
376:         tail[1] = head[1] + tail[1]
377:         head = tail
378:       else
379:         tail[0] = :array
380:         tail[1] = s(:str, tail[1])
381:         tail.delete_at 1 if tail[1] == s(:str, '')
382: 
383:         head.push(*tail[1..1])
384:       end
385:     when :evstr then
386:       head[0] = :dstr if htype == :str
387:       if head.size == 2 and tail.size > 1 and tail[1][0] == :str then
388:         head[1] << tail[1][1]
389:         head[0] = :str if head.size == 2 # HACK ?
390:       else
391:         head.push(tail)
392:       end
393:     else
394:       x = [head, tail]
395:       raise "unknown type: #{x.inspect}"
396:     end
397: 
398:     return head
399:   end
logop(type, left, right) click to toggle source
     # File lib/ruby_parser_extras.rb, line 401
401:   def logop(type, left, right) # TODO: rename logical_op
402:     left = value_expr left
403: 
404:     if left and left[0] == type and not left.paren then
405:       node, second = left, nil
406: 
407:       while (second = node[2]) && second[0] == type and not second.paren do
408:         node = second
409:       end
410: 
411:       node[2] = s(type, second, right)
412: 
413:       return left
414:     end
415: 
416:     return s(type, left, right)
417:   end
418: 
419:   def new_aref val
420:     val[2] ||= s(:arglist)
421:     val[2][0] = :arglist if val[2][0] == :array # REFACTOR
422:     if val[0].node_type == :self then
423:       result = new_call nil, :"[]", val[2]
424:     else
425:       result = new_call val[0], :"[]", val[2]
426:     end
427:     result
428:   end
429: 
430:   def new_body val
431:     result = val[0]
432: 
433:     if val[1] then
434:       result = s(:rescue)
435:       result << val[0] if val[0]
436: 
437:       resbody = val[1]
438: 
439:       while resbody do
440:         result << resbody
441:         resbody = resbody.resbody(true)
442:       end
443: 
444:       result << val[2] if val[2]
445: 
446:       result.line = (val[0] || val[1]).line
447:     elsif not val[2].nil? then
448:       warning("else without rescue is useless")
449:       result = block_append(result, val[2])
450:     end
451: 
452:     result = s(:ensure, result, val[3]).compact if val[3]
453:     return result
454:   end
455: 
456:   def new_call recv, meth, args = nil
457:     result = s(:call, recv, meth)
458:     result.line = recv.line if recv
459: 
460:     args ||= s(:arglist)
461:     args[0] = :arglist if args.first == :array
462:     args = s(:arglist, args) unless args.first == :arglist
463:     result << args
464:     result
465:   end
466: 
467:   def new_case expr, body
468:     result = s(:case, expr)
469:     line = (expr || body).line
470: 
471:     while body and body.node_type == :when
472:       result << body
473:       body = body.delete_at 3
474:     end
475: 
476:     # else
477:     body = nil if body == s(:block)
478:     result << body
479: 
480:     result.line = line
481:     result
482:   end
483: 
484:   def new_class val
485:     line, path, superclass, body = val[1], val[2], val[3], val[5]
486:     scope = s(:scope, body).compact
487:     result = s(:class, path, superclass, scope)
488:     result.line = line
489:     result.comments = self.comments.pop
490:     result
491:   end
492: 
493:   def new_compstmt val
494:     result = void_stmts(val[0])
495:     result = remove_begin(result) if result
496:     result
497:   end
498: 
499:   def new_defn val
500:     (_, line), name, args, body = val[0], val[1], val[3], val[4]
501:     body ||= s(:nil)
502: 
503:     body ||= s(:block)
504:     body = s(:block, body) unless body.first == :block
505: 
506:     result = s(:defn, name.to_sym, args, s(:scope, body))
507:     result.line = line
508:     result.comments = self.comments.pop
509:     result
510:   end
511: 
512:   def new_defs val
513:     recv, name, args, body = val[1], val[4], val[6], val[7]
514: 
515:     body ||= s(:block)
516:     body = s(:block, body) unless body.first == :block
517: 
518:     result = s(:defs, recv, name.to_sym, args, s(:scope, body))
519:     result.line = recv.line
520:     result.comments = self.comments.pop
521:     result
522:   end
523: 
524:   def new_for expr, var, body
525:     result = s(:for, expr, var).line(var.line)
526:     result << body if body
527:     result
528:   end
529: 
530:   def new_if c, t, f
531:     l = [c.line, t && t.line, f && f.line].compact.min
532:     c = cond c
533:     c, t, f = c.last, f, t if c[0] == :not and canonicalize_conditions
534:     s(:if, c, t, f).line(l)
535:   end
536: 
537:   def new_iter call, args, body
538:     result = s(:iter)
539:     result << call if call
540:     result << args
541:     result << body if body
542:     result
543:   end
544: 
545:   def new_masgn lhs, rhs, wrap = false
546:     rhs = value_expr(rhs)
547:     rhs = lhs[1] ? s(:to_ary, rhs) : s(:array, rhs) if wrap
548: 
549:     lhs.delete_at 1 if lhs[1].nil?
550:     lhs << rhs
551: 
552:     lhs
553:   end
554: 
555:   def new_module val
556:     line, path, body = val[1], val[2], val[4]
557:     body = s(:scope, body).compact
558:     result = s(:module, path, body)
559:     result.line = line
560:     result.comments = self.comments.pop
561:     result
562:   end
563: 
564:   def new_op_asgn val
565:     lhs, asgn_op, arg = val[0], val[1].to_sym, val[2]
566:     name = lhs.value
567:     arg = remove_begin(arg)
568:     result = case asgn_op # REFACTOR
569:              when :"||" then
570:                lhs << arg
571:                s(:op_asgn_or, self.gettable(name), lhs)
572:              when :"&&" then
573:                lhs << arg
574:                s(:op_asgn_and, self.gettable(name), lhs)
575:              else
576:                # TODO: why [2] ?
577:                lhs[2] = new_call(self.gettable(name), asgn_op,
578:                                  s(:arglist, arg))
579:                lhs
580:              end
581:     result.line = lhs.line
582:     result
583:   end
584: 
585:   def new_regexp val
586:     node = val[1] || s(:str, '')
587:     options = val[2]
588: 
589:     o, k = 0, nil
590:     options.split(//).uniq.each do |c| # FIX: this has a better home
591:       v = {
592:         'x' => Regexp::EXTENDED,
593:         'i' => Regexp::IGNORECASE,
594:         'm' => Regexp::MULTILINE,
595:         'o' => Regexp::ONCE,
596:         'n' => Regexp::ENC_NONE,
597:         'e' => Regexp::ENC_EUC,
598:         's' => Regexp::ENC_SJIS,
599:         'u' => Regexp::ENC_UTF8,
600:       }[c]
601:       raise "unknown regexp option: #{c}" unless v
602:       o += v
603:       k = c if c =~ /[esu]/
604:     end
605: 
606:     case node[0]
607:     when :str then
608:       node[0] = :lit
609:       node[1] = if k then
610:                   Regexp.new(node[1], o, k)
611:                 else
612:                   Regexp.new(node[1], o)
613:                 end
614:     when :dstr then
615:       if options =~ /o/ then
616:         node[0] = :dregx_once
617:       else
618:         node[0] = :dregx
619:       end
620:       node << o if o and o != 0
621:     else
622:       node = s(:dregx, '', node);
623:       node[0] = :dregx_once if options =~ /o/
624:       node << o if o and o != 0
625:     end
626: 
627:     node
628:   end
629: 
630:   def new_sclass val
631:     recv, in_def, in_single, body = val[3], val[4], val[6], val[7]
632:     scope = s(:scope, body).compact
633:     result = s(:sclass, recv, scope)
634:     result.line = val[2]
635:     self.in_def = in_def
636:     self.in_single = in_single
637:     result
638:   end
639: 
640:   def new_super args
641:     if args && args.node_type == :block_pass then
642:       s(:super, args)
643:     else
644:       args ||= s(:arglist)
645:       s(:super, *args[1..1])
646:     end
647:   end
648: 
649:   def new_undef n, m = nil
650:     if m then
651:       block_append(n, s(:undef, m))
652:     else
653:       s(:undef, n)
654:     end
655:   end
656: 
657:   def new_until_or_while type, block, expr, pre
658:     other = type == :until ? :while : :until
659:     line = [block && block.line, expr.line].compact.min
660:     block, pre = block.last, false if block && block[0] == :begin
661: 
662:     expr = cond expr
663: 
664:     result = unless expr.first == :not and canonicalize_conditions then
665:                s(type,  expr,      block, pre)
666:              else
667:                s(other, expr.last, block, pre)
668:              end
669: 
670:     result.line = line
671:     result
672:   end
673: 
674:   def new_until block, expr, pre
675:     new_until_or_while :until, block, expr, pre
676:   end
677: 
678:   def new_while block, expr, pre
679:     new_until_or_while :while, block, expr, pre
680:   end
681: 
682:   def new_xstring str
683:     if str then
684:       case str[0]
685:       when :str
686:         str[0] = :xstr
687:       when :dstr
688:         str[0] = :dxstr
689:       else
690:         str = s(:dxstr, '', str)
691:       end
692:       str
693:     else
694:       s(:xstr, '')
695:     end
696:   end
697: 
698:   def new_yield args = nil
699:     # TODO: raise args.inspect unless [:arglist].include? args.first # HACK
700:     raise SyntaxError, "Block argument should not be given." if
701:       args && args.node_type == :block_pass
702: 
703:     args ||= s(:arglist)
704: 
705:     # TODO: I can prolly clean this up
706:     args[0] = :arglist       if args.first == :array
707:     args = s(:arglist, args) unless args.first == :arglist
708: 
709:     return s(:yield, *args[1..1])
710:   end
711: 
712:   def next_token
713:     if self.lexer.advance then
714:       return self.lexer.token, self.lexer.yacc_value
715:     else
716:       return [false, '$end']
717:     end
718:   end
719: 
720:   def node_assign(lhs, rhs) # TODO: rename new_assign
721:     return nil unless lhs
722: 
723:     rhs = value_expr rhs
724: 
725:     case lhs[0]
726:     when :gasgn, :iasgn, :lasgn, :dasgn, :dasgn_curr,
727:       :masgn, :cdecl, :cvdecl, :cvasgn then
728:       lhs << rhs
729:     when :attrasgn, :call then
730:       args = lhs.pop unless Symbol === lhs.last
731:       lhs << arg_add(args, rhs)
732:     when :const then
733:       lhs[0] = :cdecl
734:       lhs << rhs
735:     else
736:       raise "unknown lhs #{lhs.inspect}"
737:     end
738: 
739:     lhs
740:   end
741: 
742:   def process(str, file = "(string)")
743:     raise "bad val: #{str.inspect}" unless String === str
744: 
745:     self.file = file
746:     self.lexer.src = str
747: 
748:     @yydebug = ENV.has_key? 'DEBUG'
749: 
750:     do_parse
751:   end
752:   alias :parse :process
753: 
754:   def remove_begin node
755:     oldnode = node
756:     if node and :begin == node[0] and node.size == 2 then
757:       node = node[1]
758:       node.line = oldnode.line
759:     end
760:     node
761:   end
762: 
763:   def reset
764:     lexer.reset
765:     self.in_def = false
766:     self.in_single = 0
767:     self.env.reset
768:     self.comments.clear
769:   end
770: 
771:   def ret_args node
772:     if node then
773:       raise SyntaxError, "block argument should not be given" if
774:         node[0] == :block_pass
775: 
776:       node = node.last if node[0] == :array && node.size == 2
777:       # HACK matz wraps ONE of the FOUR splats in a newline to
778:       # distinguish. I use paren for now. ugh
779:       node = s(:svalue, node) if node[0] == :splat and not node.paren
780:       node[0] = :svalue if node[0] == :arglist && node[1][0] == :splat
781:     end
782: 
783:     node
784:   end
785: 
786:   def s(*args)
787:     result = Sexp.new(*args)
788:     result.line ||= lexer.lineno if lexer.src          # otherwise...
789:     result.file = self.file
790:     result
791:   end
792: 
793:   def value_expr oldnode # HACK
794:     node = remove_begin oldnode
795:     node.line = oldnode.line if oldnode
796:     node[2] = value_expr(node[2]) if node and node[0] == :if
797:     node
798:   end
799: 
800:   def void_stmts node
801:     return nil unless node
802:     return node unless node[0] == :block
803: 
804:     node[1..1] = node[1..1].map { |n| remove_begin(n) }
805:     node
806:   end
807: 
808:   def warning s
809:     # do nothing for now
810:   end
811: 
812:   alias :old_yyerror :yyerror
813:   def yyerror msg
814:     # for now do nothing with the msg
815:     old_yyerror
816:   end
817: 
818:   class Keyword
819:     class KWtable
820:       attr_accessor :name, :state, :id0, :id1
821:       def initialize(name, id=[], state=nil)
822:         @name  = name
823:         @id0, @id1 = id
824:         @state = state
825:       end
826:     end
827: 
828:     ##
829:     # :stopdoc:
830:     #
831:     # :expr_beg    = ignore newline, +/- is a sign.
832:     # :expr_end    = newline significant, +/- is a operator.
833:     # :expr_arg    = newline significant, +/- is a operator.
834:     # :expr_cmdarg = newline significant, +/- is a operator.
835:     # :expr_endarg = newline significant, +/- is a operator.
836:     # :expr_mid    = newline significant, +/- is a operator.
837:     # :expr_fname  = ignore newline, no reserved words.
838:     # :expr_dot    = right after . or ::, no reserved words.
839:     # :expr_class  = immediate after class, no here document.
840: 
841:     wordlist = [
842:                 ["end",      [:kEND,      :kEND        ], :expr_end   ],
843:                 ["else",     [:kELSE,     :kELSE       ], :expr_beg   ],
844:                 ["case",     [:kCASE,     :kCASE       ], :expr_beg   ],
845:                 ["ensure",   [:kENSURE,   :kENSURE     ], :expr_beg   ],
846:                 ["module",   [:kMODULE,   :kMODULE     ], :expr_beg   ],
847:                 ["elsif",    [:kELSIF,    :kELSIF      ], :expr_beg   ],
848:                 ["def",      [:kDEF,      :kDEF        ], :expr_fname ],
849:                 ["rescue",   [:kRESCUE,   :kRESCUE_MOD ], :expr_mid   ],
850:                 ["not",      [:kNOT,      :kNOT        ], :expr_beg   ],
851:                 ["then",     [:kTHEN,     :kTHEN       ], :expr_beg   ],
852:                 ["yield",    [:kYIELD,    :kYIELD      ], :expr_arg   ],
853:                 ["for",      [:kFOR,      :kFOR        ], :expr_beg   ],
854:                 ["self",     [:kSELF,     :kSELF       ], :expr_end   ],
855:                 ["false",    [:kFALSE,    :kFALSE      ], :expr_end   ],
856:                 ["retry",    [:kRETRY,    :kRETRY      ], :expr_end   ],
857:                 ["return",   [:kRETURN,   :kRETURN     ], :expr_mid   ],
858:                 ["true",     [:kTRUE,     :kTRUE       ], :expr_end   ],
859:                 ["if",       [:kIF,       :kIF_MOD     ], :expr_beg   ],
860:                 ["defined?", [:kDEFINED,  :kDEFINED    ], :expr_arg   ],
861:                 ["super",    [:kSUPER,    :kSUPER      ], :expr_arg   ],
862:                 ["undef",    [:kUNDEF,    :kUNDEF      ], :expr_fname ],
863:                 ["break",    [:kBREAK,    :kBREAK      ], :expr_mid   ],
864:                 ["in",       [:kIN,       :kIN         ], :expr_beg   ],
865:                 ["do",       [:kDO,       :kDO         ], :expr_beg   ],
866:                 ["nil",      [:kNIL,      :kNIL        ], :expr_end   ],
867:                 ["until",    [:kUNTIL,    :kUNTIL_MOD  ], :expr_beg   ],
868:                 ["unless",   [:kUNLESS,   :kUNLESS_MOD ], :expr_beg   ],
869:                 ["or",       [:kOR,       :kOR         ], :expr_beg   ],
870:                 ["next",     [:kNEXT,     :kNEXT       ], :expr_mid   ],
871:                 ["when",     [:kWHEN,     :kWHEN       ], :expr_beg   ],
872:                 ["redo",     [:kREDO,     :kREDO       ], :expr_end   ],
873:                 ["and",      [:kAND,      :kAND        ], :expr_beg   ],
874:                 ["begin",    [:kBEGIN,    :kBEGIN      ], :expr_beg   ],
875:                 ["__LINE__", [:k__LINE__, :k__LINE__   ], :expr_end   ],
876:                 ["class",    [:kCLASS,    :kCLASS      ], :expr_class ],
877:                 ["__FILE__", [:k__FILE__, :k__FILE__   ], :expr_end   ],
878:                 ["END",      [:klEND,     :klEND       ], :expr_end   ],
879:                 ["BEGIN",    [:klBEGIN,   :klBEGIN     ], :expr_end   ],
880:                 ["while",    [:kWHILE,    :kWHILE_MOD  ], :expr_beg   ],
881:                 ["alias",    [:kALIAS,    :kALIAS      ], :expr_fname ],
882:                ].map { |args| KWtable.new(*args) }
883: 
884:     # :startdoc:
885: 
886:     WORDLIST = Hash[*wordlist.map { |o| [o.name, o] }.flatten] unless
887:       defined? WORDLIST
888: 
889:     def self.keyword str
890:       WORDLIST[str]
891:     end
892:   end
893: 
894:   class Environment
895:     attr_reader :env, :dyn
896: 
897:     def [] k
898:       self.all[k]
899:     end
900: 
901:     def []= k, v
902:       raise "no" if v == true
903:       self.current[k] = v
904:     end
905: 
906:     def all
907:       idx = @dyn.index(false) || 0
908:       @env[0..idx].reverse.inject { |env, scope| env.merge scope }
909:     end
910: 
911:     def current
912:       @env.first
913:     end
914: 
915:     def dynamic
916:       idx = @dyn.index false
917:       @env[0...idx].reverse.inject { |env, scope| env.merge scope } || {}
918:     end
919: 
920:     def dynamic?
921:       @dyn[0] != false
922:     end
923: 
924:     def extend dyn = false
925:       @dyn.unshift dyn
926:       @env.unshift({})
927:       @use.unshift({})
928:     end
929: 
930:     def initialize dyn = false
931:       @dyn = []
932:       @env = []
933:       @use = []
934:       self.reset
935:     end
936: 
937:     def reset
938:       @dyn.clear
939:       @env.clear
940:       @use.clear
941:       self.extend
942:     end
943: 
944:     def unextend
945:       @dyn.shift
946:       @env.shift
947:       @use.shift
948:       raise "You went too far unextending env" if @env.empty?
949:     end
950: 
951:     def use id
952:       @env.each_with_index do |env, i|
953:         if env[id] then
954:           @use[i][id] = true
955:         end
956:       end
957:     end
958: 
959:     def used? id
960:       idx = @dyn.index false # REFACTOR
961:       u = @use[0...idx].reverse.inject { |env, scope| env.merge scope } || {}
962:       u[id]
963:     end
964:   end
965: 
966:   class StackState
967:     attr_reader :stack
968: 
969:     def initialize(name)
970:       @name = name
971:       @stack = [false]
972:     end
973: 
974:     def inspect
975:       "StackState(#{@name}, #{@stack.inspect})"
976:     end
977: 
978:     def is_in_state
979:       @stack.last
980:     end
981: 
982:     def lexpop
983:       raise if @stack.size == 0
984:       a = @stack.pop
985:       b = @stack.pop
986:       @stack.push(a || b)
987:     end
988: 
989:     def pop
990:       r = @stack.pop
991:       @stack.push false if @stack.size == 0
992:       r
993:     end
994: 
995:     def push val
996:       @stack.push val
997:     end
998:   end
999: end
new_aref(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 419
419:   def new_aref val
420:     val[2] ||= s(:arglist)
421:     val[2][0] = :arglist if val[2][0] == :array # REFACTOR
422:     if val[0].node_type == :self then
423:       result = new_call nil, :"[]", val[2]
424:     else
425:       result = new_call val[0], :"[]", val[2]
426:     end
427:     result
428:   end
new_body(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 430
430:   def new_body val
431:     result = val[0]
432: 
433:     if val[1] then
434:       result = s(:rescue)
435:       result << val[0] if val[0]
436: 
437:       resbody = val[1]
438: 
439:       while resbody do
440:         result << resbody
441:         resbody = resbody.resbody(true)
442:       end
443: 
444:       result << val[2] if val[2]
445: 
446:       result.line = (val[0] || val[1]).line
447:     elsif not val[2].nil? then
448:       warning("else without rescue is useless")
449:       result = block_append(result, val[2])
450:     end
451: 
452:     result = s(:ensure, result, val[3]).compact if val[3]
453:     return result
454:   end
new_call(recv, meth, args = nil) click to toggle source
     # File lib/ruby_parser_extras.rb, line 456
456:   def new_call recv, meth, args = nil
457:     result = s(:call, recv, meth)
458:     result.line = recv.line if recv
459: 
460:     args ||= s(:arglist)
461:     args[0] = :arglist if args.first == :array
462:     args = s(:arglist, args) unless args.first == :arglist
463:     result << args
464:     result
465:   end
new_case(expr, body) click to toggle source
     # File lib/ruby_parser_extras.rb, line 467
467:   def new_case expr, body
468:     result = s(:case, expr)
469:     line = (expr || body).line
470: 
471:     while body and body.node_type == :when
472:       result << body
473:       body = body.delete_at 3
474:     end
475: 
476:     # else
477:     body = nil if body == s(:block)
478:     result << body
479: 
480:     result.line = line
481:     result
482:   end
new_class(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 484
484:   def new_class val
485:     line, path, superclass, body = val[1], val[2], val[3], val[5]
486:     scope = s(:scope, body).compact
487:     result = s(:class, path, superclass, scope)
488:     result.line = line
489:     result.comments = self.comments.pop
490:     result
491:   end
new_compstmt(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 493
493:   def new_compstmt val
494:     result = void_stmts(val[0])
495:     result = remove_begin(result) if result
496:     result
497:   end
new_defn(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 499
499:   def new_defn val
500:     (_, line), name, args, body = val[0], val[1], val[3], val[4]
501:     body ||= s(:nil)
502: 
503:     body ||= s(:block)
504:     body = s(:block, body) unless body.first == :block
505: 
506:     result = s(:defn, name.to_sym, args, s(:scope, body))
507:     result.line = line
508:     result.comments = self.comments.pop
509:     result
510:   end
new_defs(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 512
512:   def new_defs val
513:     recv, name, args, body = val[1], val[4], val[6], val[7]
514: 
515:     body ||= s(:block)
516:     body = s(:block, body) unless body.first == :block
517: 
518:     result = s(:defs, recv, name.to_sym, args, s(:scope, body))
519:     result.line = recv.line
520:     result.comments = self.comments.pop
521:     result
522:   end
new_for(expr, var, body) click to toggle source
     # File lib/ruby_parser_extras.rb, line 524
524:   def new_for expr, var, body
525:     result = s(:for, expr, var).line(var.line)
526:     result << body if body
527:     result
528:   end
new_if(c, t, f) click to toggle source
     # File lib/ruby_parser_extras.rb, line 530
530:   def new_if c, t, f
531:     l = [c.line, t && t.line, f && f.line].compact.min
532:     c = cond c
533:     c, t, f = c.last, f, t if c[0] == :not and canonicalize_conditions
534:     s(:if, c, t, f).line(l)
535:   end
new_iter(call, args, body) click to toggle source
     # File lib/ruby_parser_extras.rb, line 537
537:   def new_iter call, args, body
538:     result = s(:iter)
539:     result << call if call
540:     result << args
541:     result << body if body
542:     result
543:   end
new_masgn(lhs, rhs, wrap = false) click to toggle source
     # File lib/ruby_parser_extras.rb, line 545
545:   def new_masgn lhs, rhs, wrap = false
546:     rhs = value_expr(rhs)
547:     rhs = lhs[1] ? s(:to_ary, rhs) : s(:array, rhs) if wrap
548: 
549:     lhs.delete_at 1 if lhs[1].nil?
550:     lhs << rhs
551: 
552:     lhs
553:   end
new_module(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 555
555:   def new_module val
556:     line, path, body = val[1], val[2], val[4]
557:     body = s(:scope, body).compact
558:     result = s(:module, path, body)
559:     result.line = line
560:     result.comments = self.comments.pop
561:     result
562:   end
new_op_asgn(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 564
564:   def new_op_asgn val
565:     lhs, asgn_op, arg = val[0], val[1].to_sym, val[2]
566:     name = lhs.value
567:     arg = remove_begin(arg)
568:     result = case asgn_op # REFACTOR
569:              when :"||" then
570:                lhs << arg
571:                s(:op_asgn_or, self.gettable(name), lhs)
572:              when :"&&" then
573:                lhs << arg
574:                s(:op_asgn_and, self.gettable(name), lhs)
575:              else
576:                # TODO: why [2] ?
577:                lhs[2] = new_call(self.gettable(name), asgn_op,
578:                                  s(:arglist, arg))
579:                lhs
580:              end
581:     result.line = lhs.line
582:     result
583:   end
new_regexp(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 585
585:   def new_regexp val
586:     node = val[1] || s(:str, '')
587:     options = val[2]
588: 
589:     o, k = 0, nil
590:     options.split(//).uniq.each do |c| # FIX: this has a better home
591:       v = {
592:         'x' => Regexp::EXTENDED,
593:         'i' => Regexp::IGNORECASE,
594:         'm' => Regexp::MULTILINE,
595:         'o' => Regexp::ONCE,
596:         'n' => Regexp::ENC_NONE,
597:         'e' => Regexp::ENC_EUC,
598:         's' => Regexp::ENC_SJIS,
599:         'u' => Regexp::ENC_UTF8,
600:       }[c]
601:       raise "unknown regexp option: #{c}" unless v
602:       o += v
603:       k = c if c =~ /[esu]/
604:     end
605: 
606:     case node[0]
607:     when :str then
608:       node[0] = :lit
609:       node[1] = if k then
610:                   Regexp.new(node[1], o, k)
611:                 else
612:                   Regexp.new(node[1], o)
613:                 end
614:     when :dstr then
615:       if options =~ /o/ then
616:         node[0] = :dregx_once
617:       else
618:         node[0] = :dregx
619:       end
620:       node << o if o and o != 0
621:     else
622:       node = s(:dregx, '', node);
623:       node[0] = :dregx_once if options =~ /o/
624:       node << o if o and o != 0
625:     end
626: 
627:     node
628:   end
new_sclass(val) click to toggle source
     # File lib/ruby_parser_extras.rb, line 630
630:   def new_sclass val
631:     recv, in_def, in_single, body = val[3], val[4], val[6], val[7]
632:     scope = s(:scope, body).compact
633:     result = s(:sclass, recv, scope)
634:     result.line = val[2]
635:     self.in_def = in_def
636:     self.in_single = in_single
637:     result
638:   end
new_super(args) click to toggle source
     # File lib/ruby_parser_extras.rb, line 640
640:   def new_super args
641:     if args && args.node_type == :block_pass then
642:       s(:super, args)
643:     else
644:       args ||= s(:arglist)
645:       s(:super, *args[1..1])
646:     end
647:   end
new_undef(n, m = nil) click to toggle source
     # File lib/ruby_parser_extras.rb, line 649
649:   def new_undef n, m = nil
650:     if m then
651:       block_append(n, s(:undef, m))
652:     else
653:       s(:undef, n)
654:     end
655:   end
new_until(block, expr, pre) click to toggle source
     # File lib/ruby_parser_extras.rb, line 674
674:   def new_until block, expr, pre
675:     new_until_or_while :until, block, expr, pre
676:   end
new_until_or_while(type, block, expr, pre) click to toggle source
     # File lib/ruby_parser_extras.rb, line 657
657:   def new_until_or_while type, block, expr, pre
658:     other = type == :until ? :while : :until
659:     line = [block && block.line, expr.line].compact.min
660:     block, pre = block.last, false if block && block[0] == :begin
661: 
662:     expr = cond expr
663: 
664:     result = unless expr.first == :not and canonicalize_conditions then
665:                s(type,  expr,      block, pre)
666:              else
667:                s(other, expr.last, block, pre)
668:              end
669: 
670:     result.line = line
671:     result
672:   end
new_while(block, expr, pre) click to toggle source
     # File lib/ruby_parser_extras.rb, line 678
678:   def new_while block, expr, pre
679:     new_until_or_while :while, block, expr, pre
680:   end
new_xstring(str) click to toggle source
     # File lib/ruby_parser_extras.rb, line 682
682:   def new_xstring str
683:     if str then
684:       case str[0]
685:       when :str
686:         str[0] = :xstr
687:       when :dstr
688:         str[0] = :dxstr
689:       else
690:         str = s(:dxstr, '', str)
691:       end
692:       str
693:     else
694:       s(:xstr, '')
695:     end
696:   end
new_yield(args = nil) click to toggle source
     # File lib/ruby_parser_extras.rb, line 698
698:   def new_yield args = nil
699:     # TODO: raise args.inspect unless [:arglist].include? args.first # HACK
700:     raise SyntaxError, "Block argument should not be given." if
701:       args && args.node_type == :block_pass
702: 
703:     args ||= s(:arglist)
704: 
705:     # TODO: I can prolly clean this up
706:     args[0] = :arglist       if args.first == :array
707:     args = s(:arglist, args) unless args.first == :arglist
708: 
709:     return s(:yield, *args[1..1])
710:   end
next_token() click to toggle source
     # File lib/ruby_parser_extras.rb, line 712
712:   def next_token
713:     if self.lexer.advance then
714:       return self.lexer.token, self.lexer.yacc_value
715:     else
716:       return [false, '$end']
717:     end
718:   end
node_assign(lhs, rhs) click to toggle source
     # File lib/ruby_parser_extras.rb, line 720
720:   def node_assign(lhs, rhs) # TODO: rename new_assign
721:     return nil unless lhs
722: 
723:     rhs = value_expr rhs
724: 
725:     case lhs[0]
726:     when :gasgn, :iasgn, :lasgn, :dasgn, :dasgn_curr,
727:       :masgn, :cdecl, :cvdecl, :cvasgn then
728:       lhs << rhs
729:     when :attrasgn, :call then
730:       args = lhs.pop unless Symbol === lhs.last
731:       lhs << arg_add(args, rhs)
732:     when :const then
733:       lhs[0] = :cdecl
734:       lhs << rhs
735:     else
736:       raise "unknown lhs #{lhs.inspect}"
737:     end
738: 
739:     lhs
740:   end
process(str, file = "(string)") click to toggle source
     # File lib/ruby_parser_extras.rb, line 742
742:   def process(str, file = "(string)")
743:     raise "bad val: #{str.inspect}" unless String === str
744: 
745:     self.file = file
746:     self.lexer.src = str
747: 
748:     @yydebug = ENV.has_key? 'DEBUG'
749: 
750:     do_parse
751:   end
remove_begin(node) click to toggle source
     # File lib/ruby_parser_extras.rb, line 754
754:   def remove_begin node
755:     oldnode = node
756:     if node and :begin == node[0] and node.size == 2 then
757:       node = node[1]
758:       node.line = oldnode.line
759:     end
760:     node
761:   end
reset() click to toggle source
     # File lib/ruby_parser_extras.rb, line 763
763:   def reset
764:     lexer.reset
765:     self.in_def = false
766:     self.in_single = 0
767:     self.env.reset
768:     self.comments.clear
769:   end
ret_args(node) click to toggle source
     # File lib/ruby_parser_extras.rb, line 771
771:   def ret_args node
772:     if node then
773:       raise SyntaxError, "block argument should not be given" if
774:         node[0] == :block_pass
775: 
776:       node = node.last if node[0] == :array && node.size == 2
777:       # HACK matz wraps ONE of the FOUR splats in a newline to
778:       # distinguish. I use paren for now. ugh
779:       node = s(:svalue, node) if node[0] == :splat and not node.paren
780:       node[0] = :svalue if node[0] == :arglist && node[1][0] == :splat
781:     end
782: 
783:     node
784:   end
s(*args) click to toggle source
     # File lib/ruby_parser_extras.rb, line 786
786:   def s(*args)
787:     result = Sexp.new(*args)
788:     result.line ||= lexer.lineno if lexer.src          # otherwise...
789:     result.file = self.file
790:     result
791:   end
value_expr(oldnode) click to toggle source
     # File lib/ruby_parser_extras.rb, line 793
793:   def value_expr oldnode # HACK
794:     node = remove_begin oldnode
795:     node.line = oldnode.line if oldnode
796:     node[2] = value_expr(node[2]) if node and node[0] == :if
797:     node
798:   end
void_stmts(node) click to toggle source
     # File lib/ruby_parser_extras.rb, line 800
800:   def void_stmts node
801:     return nil unless node
802:     return node unless node[0] == :block
803: 
804:     node[1..1] = node[1..1].map { |n| remove_begin(n) }
805:     node
806:   end
warning(s) click to toggle source
     # File lib/ruby_parser_extras.rb, line 808
808:   def warning s
809:     # do nothing for now
810:   end
yyerror(msg) click to toggle source
     # File lib/ruby_parser_extras.rb, line 813
813:   def yyerror msg
814:     # for now do nothing with the msg
815:     old_yyerror
816:   end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.