Racc::Parser
# 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
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
# 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
# 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 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 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 3009 3009: def _reduce_14(val, _values, result) 3010: result = val[1] 3011: 3012: result 3013: end
# 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
# 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
# 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 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 3730 3730: def _reduce_182(val, _values, result) 3731: yyerror "constant re-assignment" 3732: 3733: result 3734: end
# File lib/ruby_parser.rb, line 3736 3736: def _reduce_183(val, _values, result) 3737: yyerror "constant re-assignment" 3738: 3739: result 3740: end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 2944 2944: def _reduce_2(val, _values, result) 2945: result = val[1] 2946: 2947: result 2948: end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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 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
# 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 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
# File lib/ruby_parser.rb, line 3984 3984: def _reduce_222(val, _values, result) 3985: result = val[0] 3986: 3987: result 3988: end
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4008 4008: def _reduce_226(val, _values, result) 4009: result = val[1] 4010: 4011: result 4012: end
# File lib/ruby_parser.rb, line 4014 4014: def _reduce_227(val, _values, result) 4015: result = val[1] 4016: 4017: result 4018: end
# 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
# 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
# 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 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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 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
# 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 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4220 4220: def _reduce_261(val, _values, result) 4221: result = val[1] 4222: 4223: result 4224: end
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
# 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
# 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
# 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
# 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
# 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 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
# File lib/ruby_parser.rb, line 4280 4280: def _reduce_277(val, _values, result) 4281: result = self.lexer.lineno 4282: 4283: result 4284: end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4330 4330: def _reduce_284(val, _values, result) 4331: result = new_aref val 4332: 4333: result 4334: end
# 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
# 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
# File lib/ruby_parser.rb, line 4348 4348: def _reduce_287(val, _values, result) 4349: result = s(:return) 4350: 4351: result 4352: end
# 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
# File lib/ruby_parser.rb, line 4360 4360: def _reduce_289(val, _values, result) 4361: result = new_yield 4362: 4363: result 4364: end
# 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
# File lib/ruby_parser.rb, line 4366 4366: def _reduce_290(val, _values, result) 4367: result = new_yield 4368: 4369: result 4370: end
# 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
# 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 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
# 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
# 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
# File lib/ruby_parser.rb, line 4410 4410: def _reduce_297(val, _values, result) 4411: lexer.cond.push true 4412: 4413: result 4414: end
# File lib/ruby_parser.rb, line 4416 4416: def _reduce_298(val, _values, result) 4417: lexer.cond.pop 4418: 4419: result 4420: end
# 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
# File lib/ruby_parser.rb, line 2950 2950: def _reduce_3(val, _values, result) 2951: result = new_body val 2952: 2953: result 2954: end
# 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
# File lib/ruby_parser.rb, line 4428 4428: def _reduce_300(val, _values, result) 4429: lexer.cond.push true 4430: 4431: result 4432: end
# File lib/ruby_parser.rb, line 4434 4434: def _reduce_301(val, _values, result) 4435: lexer.cond.pop 4436: 4437: result 4438: end
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4464 4464: def _reduce_306(val, _values, result) 4465: lexer.cond.push true 4466: 4467: result 4468: end
# File lib/ruby_parser.rb, line 4470 4470: def _reduce_307(val, _values, result) 4471: lexer.cond.pop 4472: 4473: result 4474: end
# 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
# File lib/ruby_parser.rb, line 4482 4482: def _reduce_309(val, _values, result) 4483: result = self.lexer.lineno 4484: 4485: result 4486: end
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4505 4505: def _reduce_312(val, _values, result) 4506: result = self.lexer.lineno 4507: 4508: result 4509: end
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4533 4533: def _reduce_316(val, _values, result) 4534: result = self.lexer.lineno 4535: 4536: result 4537: end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4597 4597: def _reduce_324(val, _values, result) 4598: result = s(:break) 4599: 4600: result 4601: end
# File lib/ruby_parser.rb, line 4603 4603: def _reduce_325(val, _values, result) 4604: result = s(:next) 4605: 4606: result 4607: end
# File lib/ruby_parser.rb, line 4609 4609: def _reduce_326(val, _values, result) 4610: result = s(:redo) 4611: 4612: result 4613: end
# File lib/ruby_parser.rb, line 4615 4615: def _reduce_327(val, _values, result) 4616: result = s(:retry) 4617: 4618: result 4619: end
# 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
# 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 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 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 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 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4734 4734: def _reduce_352(val, _values, result) 4735: result = self.lexer.lineno 4736: 4737: result 4738: end
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4770 4770: def _reduce_358(val, _values, result) 4771: result = s(:zsuper) 4772: 4773: result 4774: end
# 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 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4823 4823: def _reduce_365(val, _values, result) 4824: result = self.lexer.lineno 4825: 4826: result 4827: end
# 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 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
# 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
# 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 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
# File lib/ruby_parser.rb, line 4867 4867: def _reduce_373(val, _values, result) 4868: result = nil 4869: 4870: result 4871: end
# 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 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 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
# 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 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
# 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 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 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
# File lib/ruby_parser.rb, line 4930 4930: def _reduce_387(val, _values, result) 4931: result = val[1] 4932: 4933: result 4934: end
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 4948 4948: def _reduce_390(val, _values, result) 4949: result = new_regexp val 4950: 4951: result 4952: end
# File lib/ruby_parser.rb, line 4954 4954: def _reduce_391(val, _values, result) 4955: result = s(:array) 4956: 4957: result 4958: end
# File lib/ruby_parser.rb, line 4960 4960: def _reduce_392(val, _values, result) 4961: result = val[1] 4962: 4963: result 4964: end
# File lib/ruby_parser.rb, line 4966 4966: def _reduce_393(val, _values, result) 4967: result = s(:array) 4968: 4969: result 4970: end
# 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 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
# File lib/ruby_parser.rb, line 4987 4987: def _reduce_397(val, _values, result) 4988: result = s(:array) 4989: 4990: result 4991: end
# File lib/ruby_parser.rb, line 4993 4993: def _reduce_398(val, _values, result) 4994: result = val[1] 4995: 4996: result 4997: end
# File lib/ruby_parser.rb, line 4999 4999: def _reduce_399(val, _values, result) 5000: result = s(:array) 5001: 5002: result 5003: end
# File lib/ruby_parser.rb, line 2956 2956: def _reduce_4(val, _values, result) 2957: result = new_compstmt val 2958: 2959: result 2960: end
# 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
# File lib/ruby_parser.rb, line 5011 5011: def _reduce_401(val, _values, result) 5012: result = s(:str, "") 5013: 5014: result 5015: end
# 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
# File lib/ruby_parser.rb, line 5023 5023: def _reduce_403(val, _values, result) 5024: result = nil 5025: 5026: result 5027: end
# 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
# 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
# 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
# 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
# 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
# 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 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
# 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
# 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
# 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 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
# 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 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 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
# 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 429 omitted
# File lib/ruby_parser.rb, line 5171 5171: def _reduce_430(val, _values, result) 5172: result = s(:nil) 5173: result 5174: end
# File lib/ruby_parser.rb, line 5176 5176: def _reduce_431(val, _values, result) 5177: result = s(:self) 5178: result 5179: end
# File lib/ruby_parser.rb, line 5181 5181: def _reduce_432(val, _values, result) 5182: result = s(:true) 5183: result 5184: end
# File lib/ruby_parser.rb, line 5186 5186: def _reduce_433(val, _values, result) 5187: result = s(:false) 5188: result 5189: end
# File lib/ruby_parser.rb, line 5191 5191: def _reduce_434(val, _values, result) 5192: result = s(:str, self.file) 5193: result 5194: end
# 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
# 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
# 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
# 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
# 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 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
# File lib/ruby_parser.rb, line 5224 5224: def _reduce_440(val, _values, result) 5225: result = nil 5226: 5227: result 5228: end
# 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
# File lib/ruby_parser.rb, line 5236 5236: def _reduce_442(val, _values, result) 5237: result = val[2] 5238: 5239: result 5240: end
# File lib/ruby_parser.rb, line 5242 5242: def _reduce_443(val, _values, result) 5243: yyerrok 5244: result = nil 5245: 5246: result 5247: end
# 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
# File lib/ruby_parser.rb, line 5257 5257: def _reduce_445(val, _values, result) 5258: result = val[0] 5259: 5260: result 5261: end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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 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
# 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 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
# File lib/ruby_parser.rb, line 5411 5411: def _reduce_471(val, _values, result) 5412: result = val[1] 5413: 5414: result 5415: end
# File lib/ruby_parser.rb, line 5417 5417: def _reduce_472(val, _values, result) 5418: result = nil 5419: 5420: result 5421: end
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
# 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
# File lib/ruby_parser.rb, line 5439 5439: def _reduce_476(val, _values, result) 5440: result = s(:array) 5441: 5442: result 5443: end
# File lib/ruby_parser.rb, line 5445 5445: def _reduce_477(val, _values, result) 5446: result = val[0] 5447: 5448: result 5449: end
# 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 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 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
# 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
# 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
# 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 500 omitted
# File lib/ruby_parser.rb, line 5516 5516: def _reduce_501(val, _values, result) 5517: yyerrok 5518: result 5519: end
reduce 503 omitted
# File lib/ruby_parser.rb, line 5525 5525: def _reduce_504(val, _values, result) 5526: yyerrok 5527: result 5528: end
# File lib/ruby_parser.rb, line 5530 5530: def _reduce_505(val, _values, result) 5531: result = nil 5532: result 5533: end
# File lib/ruby_parser.rb, line 5535 5535: def _reduce_506(val, _values, result) 5536: result = nil 5537: result 5538: end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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 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 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
# 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
# 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
# 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
# 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
# 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 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
# 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 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# File lib/ruby_parser.rb, line 2972 2972: def _reduce_8(val, _values, result) 2973: result = val[1] 2974: 2975: result 2976: end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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 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
# 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
# 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 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
# File lib/ruby_parser.rb, line 5540 5540: def _reduce_none(val, _values, result) 5541: val[0] 5542: end
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
# 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
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.