Racc::Parser
reduce 0 omitted
# File lib/ruby_parser.rb, line 2950 2950: def _reduce_1(val, _values, result) 2951: self.lexer.lex_state = :expr_beg 2952: 2953: result 2954: end
# File lib/ruby_parser.rb, line 2997 2997: def _reduce_10(val, _values, result) 2998: result = s(:alias, val[1], val[3]).line(val[2]) 2999: 3000: result 3001: end
# File lib/ruby_parser.rb, line 3525 3525: def _reduce_100(val, _values, result) 3526: lexer.lex_state = :expr_end 3527: result = val[0] 3528: 3529: result 3530: end
# File lib/ruby_parser.rb, line 3532 3532: def _reduce_101(val, _values, result) 3533: result = s(:lit, val[0].to_sym) 3534: result 3535: end
# File lib/ruby_parser.rb, line 3537 3537: def _reduce_102(val, _values, result) 3538: result = s(:lit, val[0]) 3539: result 3540: end
# File lib/ruby_parser.rb, line 3542 3542: def _reduce_103(val, _values, result) 3543: result = new_undef val[0] 3544: 3545: result 3546: end
# File lib/ruby_parser.rb, line 3548 3548: def _reduce_104(val, _values, result) 3549: lexer.lex_state = :expr_fname 3550: 3551: result 3552: end
# File lib/ruby_parser.rb, line 3554 3554: def _reduce_105(val, _values, result) 3555: result = new_undef val[0], val[3] 3556: 3557: result 3558: end
# File lib/ruby_parser.rb, line 3003 3003: def _reduce_11(val, _values, result) 3004: result = s(:valias, val[1].to_sym, val[2].to_sym) 3005: 3006: result 3007: end
# File lib/ruby_parser.rb, line 3009 3009: def _reduce_12(val, _values, result) 3010: result = s(:valias, val[1].to_sym, :"$#{val[2]}") 3011: 3012: result 3013: end
# File lib/ruby_parser.rb, line 3015 3015: def _reduce_13(val, _values, result) 3016: yyerror "can't make alias for the number variables" 3017: 3018: result 3019: end
# File lib/ruby_parser.rb, line 3021 3021: def _reduce_14(val, _values, result) 3022: result = val[1] 3023: 3024: result 3025: end
# File lib/ruby_parser.rb, line 3027 3027: def _reduce_15(val, _values, result) 3028: result = new_if val[2], val[0], nil 3029: 3030: result 3031: end
# File lib/ruby_parser.rb, line 3033 3033: def _reduce_16(val, _values, result) 3034: result = new_if val[2], nil, val[0] 3035: 3036: result 3037: end
# File lib/ruby_parser.rb, line 3039 3039: def _reduce_17(val, _values, result) 3040: result = new_while val[0], val[2], true 3041: 3042: result 3043: end
reduce 172 omitted
# File lib/ruby_parser.rb, line 3694 3694: def _reduce_173(val, _values, result) 3695: result = self.node_assign val[0], val[2] 3696: 3697: result 3698: end
# File lib/ruby_parser.rb, line 3700 3700: def _reduce_174(val, _values, result) 3701: result = self.node_assign val[0], s(:rescue, val[2], s(:resbody, s(:array), val[4])) 3702: # result.line = val[0].line 3703: 3704: result 3705: end
# File lib/ruby_parser.rb, line 3707 3707: def _reduce_175(val, _values, result) 3708: result = new_op_asgn val 3709: 3710: result 3711: end
# File lib/ruby_parser.rb, line 3713 3713: def _reduce_176(val, _values, result) 3714: result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5]) 3715: val[2][0] = :arglist 3716: 3717: result 3718: end
# File lib/ruby_parser.rb, line 3720 3720: def _reduce_177(val, _values, result) 3721: result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4]) 3722: 3723: result 3724: end
# File lib/ruby_parser.rb, line 3726 3726: def _reduce_178(val, _values, result) 3727: result = s(:op_asgn2, val[0], :"#{val[2]}=", val[3].to_sym, val[4]) 3728: 3729: result 3730: end
# File lib/ruby_parser.rb, line 3732 3732: def _reduce_179(val, _values, result) 3733: result = s(:op_asgn, val[0], val[4], val[2], val[3]) 3734: 3735: result 3736: end
# File lib/ruby_parser.rb, line 3045 3045: def _reduce_18(val, _values, result) 3046: result = new_until val[0], val[2], true 3047: 3048: result 3049: end
# File lib/ruby_parser.rb, line 3738 3738: def _reduce_180(val, _values, result) 3739: yyerror "constant re-assignment" 3740: 3741: result 3742: end
# File lib/ruby_parser.rb, line 3744 3744: def _reduce_181(val, _values, result) 3745: yyerror "constant re-assignment" 3746: 3747: result 3748: end
# File lib/ruby_parser.rb, line 3750 3750: def _reduce_182(val, _values, result) 3751: self.backref_assign_error val[0] 3752: 3753: result 3754: end
# File lib/ruby_parser.rb, line 3756 3756: def _reduce_183(val, _values, result) 3757: v1, v2 = val[0], val[2] 3758: if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then 3759: result = s(:lit, (v1.last)..(v2.last)) 3760: else 3761: result = s(:dot2, v1, v2) 3762: end 3763: 3764: result 3765: end
# File lib/ruby_parser.rb, line 3767 3767: def _reduce_184(val, _values, result) 3768: v1, v2 = val[0], val[2] 3769: if v1.node_type == :lit and v2.node_type == :lit and Fixnum === v1.last and Fixnum === v2.last then 3770: result = s(:lit, (v1.last)...(v2.last)) 3771: else 3772: result = s(:dot3, v1, v2) 3773: end 3774: 3775: result 3776: end
# File lib/ruby_parser.rb, line 3778 3778: def _reduce_185(val, _values, result) 3779: result = new_call val[0], :+, s(:arglist, val[2]) 3780: 3781: result 3782: end
# File lib/ruby_parser.rb, line 3784 3784: def _reduce_186(val, _values, result) 3785: result = new_call val[0], :-, s(:arglist, val[2]) 3786: 3787: result 3788: end
# File lib/ruby_parser.rb, line 3790 3790: def _reduce_187(val, _values, result) 3791: result = new_call val[0], :*, s(:arglist, val[2]) 3792: 3793: result 3794: end
# File lib/ruby_parser.rb, line 3796 3796: def _reduce_188(val, _values, result) 3797: result = new_call val[0], :"/", s(:arglist, val[2]) 3798: 3799: result 3800: end
# File lib/ruby_parser.rb, line 3802 3802: def _reduce_189(val, _values, result) 3803: result = new_call val[0], :%, s(:arglist, val[2]) 3804: 3805: result 3806: end
# File lib/ruby_parser.rb, line 3051 3051: def _reduce_19(val, _values, result) 3052: result = s(:rescue, val[0], s(:resbody, s(:array), val[2])) 3053: 3054: result 3055: end
# File lib/ruby_parser.rb, line 3808 3808: def _reduce_190(val, _values, result) 3809: result = new_call val[0], :**, s(:arglist, val[2]) 3810: 3811: result 3812: end
# File lib/ruby_parser.rb, line 3814 3814: def _reduce_191(val, _values, result) 3815: result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist)) 3816: 3817: result 3818: end
# File lib/ruby_parser.rb, line 3820 3820: def _reduce_192(val, _values, result) 3821: result = new_call(new_call(s(:lit, val[1]), :"**", s(:arglist, val[3])), :"-@", s(:arglist)) 3822: 3823: result 3824: end
# File lib/ruby_parser.rb, line 3826 3826: def _reduce_193(val, _values, result) 3827: if val[1][0] == :lit then 3828: result = val[1] 3829: else 3830: result = new_call val[1], :"+@", s(:arglist) 3831: end 3832: 3833: result 3834: end
# File lib/ruby_parser.rb, line 3836 3836: def _reduce_194(val, _values, result) 3837: result = new_call val[1], :"-@", s(:arglist) 3838: 3839: result 3840: end
# File lib/ruby_parser.rb, line 3842 3842: def _reduce_195(val, _values, result) 3843: result = new_call val[0], :"|", s(:arglist, val[2]) 3844: 3845: result 3846: end
# File lib/ruby_parser.rb, line 3848 3848: def _reduce_196(val, _values, result) 3849: result = new_call val[0], :"^", s(:arglist, val[2]) 3850: 3851: result 3852: end
# File lib/ruby_parser.rb, line 3854 3854: def _reduce_197(val, _values, result) 3855: result = new_call val[0], :"&", s(:arglist, val[2]) 3856: 3857: result 3858: end
# File lib/ruby_parser.rb, line 3860 3860: def _reduce_198(val, _values, result) 3861: result = new_call val[0], :"<=>", s(:arglist, val[2]) 3862: 3863: result 3864: end
# File lib/ruby_parser.rb, line 3866 3866: def _reduce_199(val, _values, result) 3867: result = new_call val[0], :">", s(:arglist, val[2]) 3868: 3869: result 3870: end
# File lib/ruby_parser.rb, line 2956 2956: def _reduce_2(val, _values, result) 2957: result = val[1] 2958: 2959: result 2960: end
# File lib/ruby_parser.rb, line 3057 3057: def _reduce_20(val, _values, result) 3058: if (self.in_def || self.in_single > 0) then 3059: yyerror "BEGIN in method" 3060: end 3061: self.env.extend 3062: 3063: result 3064: end
# File lib/ruby_parser.rb, line 3872 3872: def _reduce_200(val, _values, result) 3873: result = new_call val[0], :">=", s(:arglist, val[2]) 3874: 3875: result 3876: end
# File lib/ruby_parser.rb, line 3878 3878: def _reduce_201(val, _values, result) 3879: result = new_call val[0], :"<", s(:arglist, val[2]) 3880: 3881: result 3882: end
# File lib/ruby_parser.rb, line 3884 3884: def _reduce_202(val, _values, result) 3885: result = new_call val[0], :"<=", s(:arglist, val[2]) 3886: 3887: result 3888: end
# File lib/ruby_parser.rb, line 3890 3890: def _reduce_203(val, _values, result) 3891: result = new_call val[0], :"==", s(:arglist, val[2]) 3892: 3893: result 3894: end
# File lib/ruby_parser.rb, line 3896 3896: def _reduce_204(val, _values, result) 3897: result = new_call val[0], :"===", s(:arglist, val[2]) 3898: 3899: result 3900: end
# File lib/ruby_parser.rb, line 3902 3902: def _reduce_205(val, _values, result) 3903: val[0] = value_expr val[0] # TODO: port call_op and clean these 3904: val[2] = value_expr val[2] 3905: result = s(:not, new_call(val[0], :"==", s(:arglist, val[2]))) 3906: 3907: result 3908: end
# File lib/ruby_parser.rb, line 3910 3910: def _reduce_206(val, _values, result) 3911: result = self.get_match_node val[0], val[2] 3912: 3913: result 3914: end
# File lib/ruby_parser.rb, line 3916 3916: def _reduce_207(val, _values, result) 3917: result = s(:not, self.get_match_node(val[0], val[2])) 3918: 3919: result 3920: end
# File lib/ruby_parser.rb, line 3922 3922: def _reduce_208(val, _values, result) 3923: result = s(:not, val[1]) 3924: 3925: result 3926: end
# File lib/ruby_parser.rb, line 3928 3928: def _reduce_209(val, _values, result) 3929: val[2] = value_expr val[2] 3930: result = new_call val[1], :"~", s(:arglist) 3931: 3932: result 3933: end
# File lib/ruby_parser.rb, line 3066 3066: def _reduce_21(val, _values, result) 3067: result = new_iter s(:preexe), nil, val[3] # TODO: add test? 3068: result = nil # TODO: since it isn't supposed to go in the AST 3069: 3070: result 3071: end
# File lib/ruby_parser.rb, line 3935 3935: def _reduce_210(val, _values, result) 3936: val[0] = value_expr val[0] 3937: val[2] = value_expr val[2] 3938: result = new_call val[0], :"\<\<", s(:arglist, val[2]) 3939: 3940: result 3941: end
# File lib/ruby_parser.rb, line 3943 3943: def _reduce_211(val, _values, result) 3944: val[0] = value_expr val[0] 3945: val[2] = value_expr val[2] 3946: result = new_call val[0], :">>", s(:arglist, val[2]) 3947: 3948: result 3949: end
# File lib/ruby_parser.rb, line 3951 3951: def _reduce_212(val, _values, result) 3952: result = logop(:and, val[0], val[2]) 3953: 3954: result 3955: end
# File lib/ruby_parser.rb, line 3957 3957: def _reduce_213(val, _values, result) 3958: result = logop(:or, val[0], val[2]) 3959: 3960: result 3961: end
# File lib/ruby_parser.rb, line 3963 3963: def _reduce_214(val, _values, result) 3964: result = s(:defined, val[2]) 3965: 3966: result 3967: end
# File lib/ruby_parser.rb, line 3969 3969: def _reduce_215(val, _values, result) 3970: result = s(:if, val[0], val[2], val[4]) 3971: 3972: result 3973: end
reduce 216 omitted
# File lib/ruby_parser.rb, line 3977 3977: def _reduce_217(val, _values, result) 3978: result = value_expr(val[0]) 3979: 3980: result 3981: end
reduce 218 omitted
# File lib/ruby_parser.rb, line 3985 3985: def _reduce_219(val, _values, result) 3986: warning 'parenthesize argument(s) for future version' 3987: result = s(:array, val[0]) 3988: 3989: result 3990: end
# File lib/ruby_parser.rb, line 3073 3073: def _reduce_22(val, _values, result) 3074: if (self.in_def || self.in_single > 0) then 3075: yyerror "END in method; use at_exit" 3076: end 3077: result = new_iter s(:postexe), nil, val[2] 3078: 3079: result 3080: end
# File lib/ruby_parser.rb, line 3992 3992: def _reduce_220(val, _values, result) 3993: result = val[0] 3994: 3995: result 3996: end
# File lib/ruby_parser.rb, line 3998 3998: def _reduce_221(val, _values, result) 3999: result = self.arg_concat val[0], val[3] 4000: 4001: result 4002: end
# File lib/ruby_parser.rb, line 4004 4004: def _reduce_222(val, _values, result) 4005: result = s(:array, s(:hash, *val[0].values)) 4006: 4007: result 4008: end
# File lib/ruby_parser.rb, line 4010 4010: def _reduce_223(val, _values, result) 4011: result = s(:array, s(:splat, val[1])) 4012: 4013: result 4014: end
# File lib/ruby_parser.rb, line 4016 4016: def _reduce_224(val, _values, result) 4017: result = val[1] 4018: 4019: result 4020: end
# File lib/ruby_parser.rb, line 4022 4022: def _reduce_225(val, _values, result) 4023: result = val[1] 4024: 4025: result 4026: end
# File lib/ruby_parser.rb, line 4028 4028: def _reduce_226(val, _values, result) 4029: warning "parenthesize argument(s) for future version" 4030: result = s(:array, val[1]) 4031: 4032: result 4033: end
# File lib/ruby_parser.rb, line 4035 4035: def _reduce_227(val, _values, result) 4036: warning "parenthesize argument(s) for future version" 4037: result = val[1].add val[3] 4038: 4039: result 4040: end
# File lib/ruby_parser.rb, line 3082 3082: def _reduce_23(val, _values, result) 3083: result = self.node_assign val[0], val[2] 3084: 3085: result 3086: end
reduce 229 omitted
# File lib/ruby_parser.rb, line 4046 4046: def _reduce_230(val, _values, result) 4047: warning "parenthesize argument(s) for future version" 4048: result = s(:array, val[0]) 4049: 4050: result 4051: end
# File lib/ruby_parser.rb, line 4053 4053: def _reduce_231(val, _values, result) 4054: result = self.arg_blk_pass val[0], val[1] 4055: 4056: result 4057: end
# File lib/ruby_parser.rb, line 4059 4059: def _reduce_232(val, _values, result) 4060: result = self.arg_concat val[0], val[3] 4061: result = self.arg_blk_pass result, val[4] 4062: 4063: result 4064: end
# File lib/ruby_parser.rb, line 4066 4066: def _reduce_233(val, _values, result) 4067: result = s(:array, s(:hash, *val[0].values)) 4068: result = self.arg_blk_pass result, val[1] 4069: 4070: result 4071: end
# File lib/ruby_parser.rb, line 4073 4073: def _reduce_234(val, _values, result) 4074: result = self.arg_concat s(:array, s(:hash, *val[0].values)), val[3] 4075: result = self.arg_blk_pass result, val[4] 4076: 4077: result 4078: end
# File lib/ruby_parser.rb, line 4080 4080: def _reduce_235(val, _values, result) 4081: result = val[0] << s(:hash, *val[2].values) 4082: result = self.arg_blk_pass result, val[3] 4083: 4084: result 4085: end
# File lib/ruby_parser.rb, line 4087 4087: def _reduce_236(val, _values, result) 4088: val[0] << s(:hash, *val[2].values) 4089: result = self.arg_concat val[0], val[5] 4090: result = self.arg_blk_pass result, val[6] 4091: 4092: result 4093: end
# File lib/ruby_parser.rb, line 4095 4095: def _reduce_237(val, _values, result) 4096: result = self.arg_blk_pass s(:splat, val[1]), val[2] 4097: 4098: result 4099: end
reduce 238 omitted
# File lib/ruby_parser.rb, line 4103 4103: def _reduce_239(val, _values, result) 4104: args = self.list_prepend val[0], val[2] 4105: result = self.arg_blk_pass args, val[3] 4106: 4107: result 4108: end
# File lib/ruby_parser.rb, line 3088 3088: def _reduce_24(val, _values, result) 3089: result = new_masgn val[0], val[2], :wrap 3090: 3091: result 3092: end
# File lib/ruby_parser.rb, line 4110 4110: def _reduce_240(val, _values, result) 4111: result = self.arg_blk_pass val[0], val[2] 4112: 4113: result 4114: end
# File lib/ruby_parser.rb, line 4116 4116: def _reduce_241(val, _values, result) 4117: result = self.arg_concat s(:array, val[0]), val[3] 4118: result = self.arg_blk_pass result, val[4] 4119: 4120: result 4121: end
# File lib/ruby_parser.rb, line 4123 4123: def _reduce_242(val, _values, result) 4124: result = self.arg_concat s(:array, val[0], s(:hash, *val[2].values)), val[5] 4125: result = self.arg_blk_pass result, val[6] 4126: 4127: result 4128: end
# File lib/ruby_parser.rb, line 4130 4130: def _reduce_243(val, _values, result) 4131: result = s(:array, s(:hash, *val[0].values)) 4132: result = self.arg_blk_pass result, val[1] 4133: 4134: result 4135: end
# File lib/ruby_parser.rb, line 4137 4137: def _reduce_244(val, _values, result) 4138: result = s(:array, s(:hash, *val[0].values), val[3]) 4139: result = self.arg_blk_pass result, val[4] 4140: 4141: result 4142: end
# File lib/ruby_parser.rb, line 4144 4144: def _reduce_245(val, _values, result) 4145: result = s(:array, val[0], s(:hash, *val[2].values)) 4146: result = self.arg_blk_pass result, val[3] 4147: 4148: result 4149: end
# File lib/ruby_parser.rb, line 4151 4151: def _reduce_246(val, _values, result) 4152: result = s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)) 4153: result = self.arg_blk_pass result, val[5] 4154: 4155: result 4156: end
# File lib/ruby_parser.rb, line 4158 4158: def _reduce_247(val, _values, result) 4159: result = self.arg_concat s(:array, val[0]).add(s(:hash, *val[2].values)), val[5] 4160: result = self.arg_blk_pass result, val[6] 4161: 4162: result 4163: end
# File lib/ruby_parser.rb, line 4165 4165: def _reduce_248(val, _values, result) 4166: result = self.arg_concat s(:array, val[0]).add_all(val[2]).add(s(:hash, *val[4].values)), val[7] 4167: result = self.arg_blk_pass result, val[8] 4168: 4169: result 4170: end
# File lib/ruby_parser.rb, line 4172 4172: def _reduce_249(val, _values, result) 4173: result = self.arg_blk_pass s(:splat, val[1]), val[2] 4174: 4175: result 4176: end
# File lib/ruby_parser.rb, line 3094 3094: def _reduce_25(val, _values, result) 3095: result = new_op_asgn val 3096: 3097: result 3098: end
reduce 250 omitted
# File lib/ruby_parser.rb, line 4180 4180: def _reduce_251(val, _values, result) 4181: result = lexer.cmdarg.stack.dup 4182: lexer.cmdarg.push true 4183: 4184: result 4185: end
# File lib/ruby_parser.rb, line 4187 4187: def _reduce_252(val, _values, result) 4188: lexer.cmdarg.stack.replace val[0] 4189: result = val[1] 4190: 4191: result 4192: end
reduce 253 omitted
# File lib/ruby_parser.rb, line 4196 4196: def _reduce_254(val, _values, result) 4197: lexer.lex_state = :expr_endarg 4198: 4199: result 4200: end
# File lib/ruby_parser.rb, line 4202 4202: def _reduce_255(val, _values, result) 4203: warning "don't put space before argument parentheses" 4204: result = nil 4205: 4206: result 4207: end
# File lib/ruby_parser.rb, line 4209 4209: def _reduce_256(val, _values, result) 4210: lexer.lex_state = :expr_endarg 4211: 4212: result 4213: end
# File lib/ruby_parser.rb, line 4215 4215: def _reduce_257(val, _values, result) 4216: warning "don't put space before argument parentheses" 4217: result = val[1] 4218: 4219: result 4220: end
# File lib/ruby_parser.rb, line 4222 4222: def _reduce_258(val, _values, result) 4223: result = s(:block_pass, val[1]) 4224: 4225: result 4226: end
# File lib/ruby_parser.rb, line 4228 4228: def _reduce_259(val, _values, result) 4229: result = val[1] 4230: 4231: result 4232: end
# File lib/ruby_parser.rb, line 3100 3100: def _reduce_26(val, _values, result) 3101: result = s(:op_asgn1, val[0], val[2], val[4].to_sym, val[5]) 3102: 3103: result 3104: end
reduce 260 omitted
# File lib/ruby_parser.rb, line 4236 4236: def _reduce_261(val, _values, result) 4237: result = s(:array, val[0]) 4238: 4239: result 4240: end
# File lib/ruby_parser.rb, line 4242 4242: def _reduce_262(val, _values, result) 4243: result = self.list_append val[0], val[2] 4244: 4245: result 4246: end
# File lib/ruby_parser.rb, line 4248 4248: def _reduce_263(val, _values, result) 4249: result = val[0] << val[2] 4250: 4251: result 4252: end
# File lib/ruby_parser.rb, line 4254 4254: def _reduce_264(val, _values, result) 4255: result = self.arg_concat val[0], val[3] 4256: 4257: result 4258: end
# File lib/ruby_parser.rb, line 4260 4260: def _reduce_265(val, _values, result) 4261: result = s(:splat, val[1]) 4262: 4263: result 4264: end
# File lib/ruby_parser.rb, line 3106 3106: def _reduce_27(val, _values, result) 3107: result = s(:op_asgn, val[0], val[4], val[2], val[3]) 3108: 3109: result 3110: end
reduce 273 omitted
# File lib/ruby_parser.rb, line 4282 4282: def _reduce_274(val, _values, result) 4283: result = new_call nil, val[0].to_sym 4284: 4285: result 4286: end
# File lib/ruby_parser.rb, line 4288 4288: def _reduce_275(val, _values, result) 4289: result = self.lexer.lineno 4290: 4291: result 4292: end
# File lib/ruby_parser.rb, line 4294 4294: def _reduce_276(val, _values, result) 4295: unless val[2] then 4296: result = s(:nil) 4297: else 4298: result = s(:begin, val[2]) 4299: end 4300: 4301: result.line = val[1] 4302: 4303: result 4304: end
# File lib/ruby_parser.rb, line 4306 4306: def _reduce_277(val, _values, result) 4307: lexer.lex_state = :expr_endarg 4308: 4309: result 4310: end
# File lib/ruby_parser.rb, line 4312 4312: def _reduce_278(val, _values, result) 4313: warning "(...) interpreted as grouped expression" 4314: result = val[1] 4315: 4316: result 4317: end
# File lib/ruby_parser.rb, line 4319 4319: def _reduce_279(val, _values, result) 4320: result = val[1] || s(:nil) 4321: result.paren = true 4322: 4323: result 4324: end
# File lib/ruby_parser.rb, line 3112 3112: def _reduce_28(val, _values, result) 3113: result = s(:op_asgn, val[0], val[4], val[2], val[3]) 3114: 3115: result 3116: end
# File lib/ruby_parser.rb, line 4326 4326: def _reduce_280(val, _values, result) 4327: result = s(:colon2, val[0], val[2].to_sym) 4328: 4329: result 4330: end
# File lib/ruby_parser.rb, line 4332 4332: def _reduce_281(val, _values, result) 4333: result = s(:colon3, val[1].to_sym) 4334: 4335: result 4336: end
# File lib/ruby_parser.rb, line 4338 4338: def _reduce_282(val, _values, result) 4339: result = new_aref val 4340: 4341: result 4342: end
# File lib/ruby_parser.rb, line 4344 4344: def _reduce_283(val, _values, result) 4345: result = val[1] || s(:array) 4346: 4347: result 4348: end
# File lib/ruby_parser.rb, line 4350 4350: def _reduce_284(val, _values, result) 4351: result = s(:hash, *val[1].values) 4352: 4353: result 4354: end
# File lib/ruby_parser.rb, line 4356 4356: def _reduce_285(val, _values, result) 4357: result = s(:return) 4358: 4359: result 4360: end
# File lib/ruby_parser.rb, line 4362 4362: def _reduce_286(val, _values, result) 4363: result = new_yield val[2] 4364: 4365: result 4366: end
# File lib/ruby_parser.rb, line 4368 4368: def _reduce_287(val, _values, result) 4369: result = new_yield 4370: 4371: result 4372: end
# File lib/ruby_parser.rb, line 4374 4374: def _reduce_288(val, _values, result) 4375: result = new_yield 4376: 4377: result 4378: end
# File lib/ruby_parser.rb, line 4380 4380: def _reduce_289(val, _values, result) 4381: result = s(:defined, val[3]) 4382: 4383: result 4384: end
# File lib/ruby_parser.rb, line 3118 3118: def _reduce_29(val, _values, result) 3119: result = s(:op_asgn, val[0], val[4], val[2], val[3]) 3120: 3121: result 3122: end
# File lib/ruby_parser.rb, line 4386 4386: def _reduce_290(val, _values, result) 4387: oper, iter = val[0], val[1] 4388: call = new_call(nil, oper.to_sym) 4389: iter.insert 1, call 4390: result = iter 4391: call.line ||= iter.line 4392: 4393: result 4394: end
reduce 291 omitted
# File lib/ruby_parser.rb, line 4398 4398: def _reduce_292(val, _values, result) 4399: call, iter = val[0], val[1] 4400: iter.insert 1, call 4401: result = iter 4402: 4403: result 4404: end
# File lib/ruby_parser.rb, line 4406 4406: def _reduce_293(val, _values, result) 4407: result = new_if val[1], val[3], val[4] 4408: 4409: result 4410: end
# File lib/ruby_parser.rb, line 4412 4412: def _reduce_294(val, _values, result) 4413: result = new_if val[1], val[4], val[3] 4414: 4415: result 4416: end
# File lib/ruby_parser.rb, line 4418 4418: def _reduce_295(val, _values, result) 4419: lexer.cond.push true 4420: 4421: result 4422: end
# File lib/ruby_parser.rb, line 4424 4424: def _reduce_296(val, _values, result) 4425: lexer.cond.pop 4426: 4427: result 4428: end
# File lib/ruby_parser.rb, line 4430 4430: def _reduce_297(val, _values, result) 4431: result = new_while val[5], val[2], true 4432: 4433: result 4434: end
# File lib/ruby_parser.rb, line 4436 4436: def _reduce_298(val, _values, result) 4437: lexer.cond.push true 4438: 4439: result 4440: end
# File lib/ruby_parser.rb, line 4442 4442: def _reduce_299(val, _values, result) 4443: lexer.cond.pop 4444: 4445: result 4446: end
# File lib/ruby_parser.rb, line 2962 2962: def _reduce_3(val, _values, result) 2963: result = new_body val 2964: 2965: result 2966: end
# File lib/ruby_parser.rb, line 3124 3124: def _reduce_30(val, _values, result) 3125: self.backref_assign_error val[0] 3126: 3127: result 3128: end
# File lib/ruby_parser.rb, line 4448 4448: def _reduce_300(val, _values, result) 4449: result = new_until val[5], val[2], true 4450: 4451: result 4452: end
# File lib/ruby_parser.rb, line 4454 4454: def _reduce_301(val, _values, result) 4455: result = new_case val[1], val[3] 4456: 4457: result 4458: end
# File lib/ruby_parser.rb, line 4460 4460: def _reduce_302(val, _values, result) 4461: result = new_case nil, val[2] 4462: 4463: result 4464: end
# File lib/ruby_parser.rb, line 4466 4466: def _reduce_303(val, _values, result) 4467: result = new_case nil, val[3] 4468: 4469: result 4470: end
# File lib/ruby_parser.rb, line 4472 4472: def _reduce_304(val, _values, result) 4473: lexer.cond.push true 4474: 4475: result 4476: end
# File lib/ruby_parser.rb, line 4478 4478: def _reduce_305(val, _values, result) 4479: lexer.cond.pop 4480: 4481: result 4482: end
# File lib/ruby_parser.rb, line 4484 4484: def _reduce_306(val, _values, result) 4485: result = new_for val[4], val[1], val[7] 4486: 4487: result 4488: end
# File lib/ruby_parser.rb, line 4490 4490: def _reduce_307(val, _values, result) 4491: result = self.lexer.lineno 4492: 4493: result 4494: end
# File lib/ruby_parser.rb, line 4496 4496: def _reduce_308(val, _values, result) 4497: self.comments.push self.lexer.comments 4498: if (self.in_def || self.in_single > 0) then 4499: yyerror "class definition in method body" 4500: end 4501: self.env.extend 4502: 4503: result 4504: end
# File lib/ruby_parser.rb, line 4506 4506: def _reduce_309(val, _values, result) 4507: result = new_class val 4508: self.env.unextend 4509: 4510: result 4511: end
# File lib/ruby_parser.rb, line 3130 3130: def _reduce_31(val, _values, result) 3131: result = self.node_assign val[0], s(:svalue, val[2]) 3132: 3133: result 3134: end
# File lib/ruby_parser.rb, line 4513 4513: def _reduce_310(val, _values, result) 4514: result = self.lexer.lineno 4515: 4516: result 4517: end
# File lib/ruby_parser.rb, line 4519 4519: def _reduce_311(val, _values, result) 4520: result = self.in_def 4521: self.in_def = false 4522: 4523: result 4524: end
# File lib/ruby_parser.rb, line 4526 4526: def _reduce_312(val, _values, result) 4527: result = self.in_single 4528: self.in_single = 0 4529: self.env.extend 4530: 4531: result 4532: end
# File lib/ruby_parser.rb, line 4534 4534: def _reduce_313(val, _values, result) 4535: result = new_sclass val 4536: self.env.unextend 4537: 4538: result 4539: end
# File lib/ruby_parser.rb, line 4541 4541: def _reduce_314(val, _values, result) 4542: result = self.lexer.lineno 4543: 4544: result 4545: end
# File lib/ruby_parser.rb, line 4547 4547: def _reduce_315(val, _values, result) 4548: self.comments.push self.lexer.comments 4549: yyerror "module definition in method body" if 4550: self.in_def or self.in_single > 0 4551: 4552: self.env.extend 4553: 4554: result 4555: end
# File lib/ruby_parser.rb, line 4557 4557: def _reduce_316(val, _values, result) 4558: result = new_module val 4559: self.env.unextend 4560: 4561: result 4562: end
# File lib/ruby_parser.rb, line 4564 4564: def _reduce_317(val, _values, result) 4565: self.comments.push self.lexer.comments 4566: self.in_def = true 4567: self.env.extend 4568: result = lexer.lineno, lexer.src.beginning_of_line? 4569: 4570: result 4571: end
# File lib/ruby_parser.rb, line 4573 4573: def _reduce_318(val, _values, result) 4574: result = new_defn val 4575: self.env.unextend 4576: self.in_def = false 4577: 4578: result 4579: end
# File lib/ruby_parser.rb, line 4581 4581: def _reduce_319(val, _values, result) 4582: self.comments.push self.lexer.comments 4583: lexer.lex_state = :expr_fname 4584: 4585: result 4586: end
# File lib/ruby_parser.rb, line 3136 3136: def _reduce_32(val, _values, result) 3137: result = new_masgn val[0], val[2], :wrap 3138: 3139: result 3140: end
# File lib/ruby_parser.rb, line 4588 4588: def _reduce_320(val, _values, result) 4589: self.in_single += 1 4590: self.env.extend 4591: lexer.lex_state = :expr_end # force for args 4592: 4593: result 4594: end
# File lib/ruby_parser.rb, line 4596 4596: def _reduce_321(val, _values, result) 4597: result = new_defs val 4598: 4599: self.env.unextend 4600: self.in_single -= 1 4601: 4602: result 4603: end
# File lib/ruby_parser.rb, line 4605 4605: def _reduce_322(val, _values, result) 4606: result = s(:break) 4607: 4608: result 4609: end
# File lib/ruby_parser.rb, line 4611 4611: def _reduce_323(val, _values, result) 4612: result = s(:next) 4613: 4614: result 4615: end
# File lib/ruby_parser.rb, line 4617 4617: def _reduce_324(val, _values, result) 4618: result = s(:redo) 4619: 4620: result 4621: end
# File lib/ruby_parser.rb, line 4623 4623: def _reduce_325(val, _values, result) 4624: result = s(:retry) 4625: 4626: result 4627: end
# File lib/ruby_parser.rb, line 4629 4629: def _reduce_326(val, _values, result) 4630: result = value_expr(val[0]) 4631: 4632: result 4633: end
# File lib/ruby_parser.rb, line 3142 3142: def _reduce_33(val, _values, result) 3143: result = new_masgn val[0], val[2] 3144: 3145: result 3146: end
reduce 334 omitted
# File lib/ruby_parser.rb, line 4651 4651: def _reduce_335(val, _values, result) 4652: result = s(:if, val[1], val[3], val[4]) 4653: 4654: result 4655: end
reduce 336 omitted
# File lib/ruby_parser.rb, line 4659 4659: def _reduce_337(val, _values, result) 4660: result = val[1] 4661: 4662: result 4663: end
reduce 338 omitted
# File lib/ruby_parser.rb, line 4667 4667: def _reduce_339(val, _values, result) 4668: val[0].delete_at 1 if val[0][1].nil? # HACK 4669: 4670: result 4671: end
reduce 340 omitted
# File lib/ruby_parser.rb, line 4675 4675: def _reduce_341(val, _values, result) 4676: result = 0 4677: 4678: result 4679: end
# File lib/ruby_parser.rb, line 4681 4681: def _reduce_342(val, _values, result) 4682: result = 0 4683: 4684: result 4685: end
# File lib/ruby_parser.rb, line 4687 4687: def _reduce_343(val, _values, result) 4688: result = val[1] 4689: 4690: result 4691: end
# File lib/ruby_parser.rb, line 4693 4693: def _reduce_344(val, _values, result) 4694: self.env.extend :dynamic 4695: 4696: result 4697: end
# File lib/ruby_parser.rb, line 4699 4699: def _reduce_345(val, _values, result) 4700: result = self.env.dynamic.keys 4701: 4702: result 4703: end
# File lib/ruby_parser.rb, line 4705 4705: def _reduce_346(val, _values, result) 4706: vars = val[2] 4707: body = val[4] 4708: result = new_iter nil, vars, body 4709: 4710: self.env.unextend 4711: 4712: result 4713: end
# File lib/ruby_parser.rb, line 4715 4715: def _reduce_347(val, _values, result) 4716: raise SyntaxError, "Both block arg and actual block given." if 4717: val[0] && val[0][0] == :blockpass 4718: 4719: result = val[1] 4720: result.insert 1, val[0] 4721: 4722: result 4723: end
# File lib/ruby_parser.rb, line 4725 4725: def _reduce_348(val, _values, result) 4726: result = new_call val[0], val[2], val[3] 4727: 4728: result 4729: end
# File lib/ruby_parser.rb, line 4731 4731: def _reduce_349(val, _values, result) 4732: result = new_call val[0], val[2], val[3] 4733: 4734: result 4735: end
# File lib/ruby_parser.rb, line 4737 4737: def _reduce_350(val, _values, result) 4738: result = self.lexer.lineno 4739: 4740: result 4741: end
# File lib/ruby_parser.rb, line 4743 4743: def _reduce_351(val, _values, result) 4744: result = new_call nil, val[0].to_sym, val[2] 4745: 4746: result 4747: end
# File lib/ruby_parser.rb, line 4749 4749: def _reduce_352(val, _values, result) 4750: result = new_call val[0], val[2].to_sym, val[3] 4751: 4752: result 4753: end
# File lib/ruby_parser.rb, line 4755 4755: def _reduce_353(val, _values, result) 4756: result = new_call val[0], val[2].to_sym, val[3] 4757: 4758: result 4759: end
# File lib/ruby_parser.rb, line 4761 4761: def _reduce_354(val, _values, result) 4762: result = new_call val[0], val[2].to_sym 4763: 4764: result 4765: end
# File lib/ruby_parser.rb, line 4767 4767: def _reduce_355(val, _values, result) 4768: result = new_super val[1] 4769: 4770: result 4771: end
# File lib/ruby_parser.rb, line 4773 4773: def _reduce_356(val, _values, result) 4774: result = s(:zsuper) 4775: 4776: result 4777: end
# File lib/ruby_parser.rb, line 4779 4779: def _reduce_357(val, _values, result) 4780: self.env.extend :dynamic 4781: result = self.lexer.lineno 4782: 4783: result 4784: end
# File lib/ruby_parser.rb, line 4786 4786: def _reduce_358(val, _values, result) 4787: result = self.env.dynamic.keys 4788: 4789: result 4790: end
# File lib/ruby_parser.rb, line 4792 4792: def _reduce_359(val, _values, result) 4793: # REFACTOR 4794: args = val[2] 4795: body = val[4] 4796: result = new_iter nil, args, body 4797: self.env.unextend 4798: result.line = val[1] 4799: 4800: result 4801: end
reduce 35 omitted
# File lib/ruby_parser.rb, line 3152 3152: def _reduce_36(val, _values, result) 3153: result = logop(:and, val[0], val[2]) 3154: 3155: result 3156: end
# File lib/ruby_parser.rb, line 4803 4803: def _reduce_360(val, _values, result) 4804: self.env.extend :dynamic 4805: result = self.lexer.lineno 4806: 4807: result 4808: end
# File lib/ruby_parser.rb, line 4810 4810: def _reduce_361(val, _values, result) 4811: result = self.env.dynamic.keys 4812: 4813: result 4814: end
# File lib/ruby_parser.rb, line 4816 4816: def _reduce_362(val, _values, result) 4817: args = val[2] 4818: body = val[4] 4819: result = new_iter nil, args, body 4820: self.env.unextend 4821: result.line = val[1] 4822: 4823: result 4824: end
# File lib/ruby_parser.rb, line 4826 4826: def _reduce_363(val, _values, result) 4827: result = self.lexer.lineno 4828: 4829: result 4830: end
# File lib/ruby_parser.rb, line 4832 4832: def _reduce_364(val, _values, result) 4833: result = s(:when, val[2], val[4]) 4834: result.line = val[1] 4835: result << val[5] if val[5] 4836: 4837: result 4838: end
reduce 365 omitted
# File lib/ruby_parser.rb, line 4842 4842: def _reduce_366(val, _values, result) 4843: result = self.list_append val[0], s(:when, val[3], nil) 4844: 4845: result 4846: end
# File lib/ruby_parser.rb, line 4848 4848: def _reduce_367(val, _values, result) 4849: result = s(:array, s(:when, val[1], nil)) 4850: 4851: result 4852: end
# File lib/ruby_parser.rb, line 3158 3158: def _reduce_37(val, _values, result) 3159: result = logop(:or, val[0], val[2]) 3160: 3161: result 3162: end
reduce 369 omitted
# File lib/ruby_parser.rb, line 4858 4858: def _reduce_370(val, _values, result) 4859: klasses, var, body, rest = val[1], val[2], val[4], val[5] 4860: 4861: klasses ||= s(:array) 4862: klasses << node_assign(var, s(:gvar, :"$!")) if var 4863: 4864: result = s(:resbody, klasses, body) 4865: result << rest if rest # UGH, rewritten above 4866: 4867: result 4868: end
# File lib/ruby_parser.rb, line 4870 4870: def _reduce_371(val, _values, result) 4871: result = nil 4872: 4873: result 4874: end
# File lib/ruby_parser.rb, line 4876 4876: def _reduce_372(val, _values, result) 4877: result = s(:array, val[0]) 4878: 4879: result 4880: end
reduce 374 omitted
# File lib/ruby_parser.rb, line 4886 4886: def _reduce_375(val, _values, result) 4887: result = val[1] 4888: 4889: result 4890: end
reduce 376 omitted
# File lib/ruby_parser.rb, line 4894 4894: def _reduce_377(val, _values, result) 4895: if (val[1] != nil) then 4896: result = val[1] 4897: else 4898: result = s(:nil) 4899: end 4900: 4901: result 4902: end
reduce 378 omitted
# File lib/ruby_parser.rb, line 4906 4906: def _reduce_379(val, _values, result) 4907: result = s(:lit, val[0]) 4908: result 4909: end
# File lib/ruby_parser.rb, line 3164 3164: def _reduce_38(val, _values, result) 3165: result = s(:not, val[1]) 3166: 3167: result 3168: end
# File lib/ruby_parser.rb, line 4911 4911: def _reduce_380(val, _values, result) 4912: result = s(:lit, val[0]) 4913: result 4914: end
reduce 381 omitted
# File lib/ruby_parser.rb, line 4918 4918: def _reduce_382(val, _values, result) 4919: val[0] = s(:dstr, val[0].value) if val[0][0] == :evstr 4920: result = val[0] 4921: 4922: result 4923: end
reduce 383 omitted
# File lib/ruby_parser.rb, line 4927 4927: def _reduce_384(val, _values, result) 4928: result = self.literal_concat val[0], val[1] 4929: 4930: result 4931: end
# File lib/ruby_parser.rb, line 4933 4933: def _reduce_385(val, _values, result) 4934: result = val[1] 4935: 4936: result 4937: end
# File lib/ruby_parser.rb, line 4939 4939: def _reduce_386(val, _values, result) 4940: result = s(:str, val[0]) 4941: 4942: result 4943: end
# File lib/ruby_parser.rb, line 4945 4945: def _reduce_387(val, _values, result) 4946: result = new_xstring val[1] 4947: 4948: result 4949: end
# File lib/ruby_parser.rb, line 4951 4951: def _reduce_388(val, _values, result) 4952: result = new_regexp val 4953: 4954: result 4955: end
# File lib/ruby_parser.rb, line 4957 4957: def _reduce_389(val, _values, result) 4958: result = s(:array) 4959: 4960: result 4961: end
# File lib/ruby_parser.rb, line 3170 3170: def _reduce_39(val, _values, result) 3171: result = s(:not, val[1]) 3172: 3173: result 3174: end
# File lib/ruby_parser.rb, line 4963 4963: def _reduce_390(val, _values, result) 4964: result = val[1] 4965: 4966: result 4967: end
# File lib/ruby_parser.rb, line 4969 4969: def _reduce_391(val, _values, result) 4970: result = s(:array) 4971: 4972: result 4973: end
# File lib/ruby_parser.rb, line 4975 4975: def _reduce_392(val, _values, result) 4976: word = val[1][0] == :evstr ? s(:dstr, "", val[1]) : val[1] 4977: result = val[0] << word 4978: 4979: result 4980: end
reduce 393 omitted
# File lib/ruby_parser.rb, line 4984 4984: def _reduce_394(val, _values, result) 4985: result = self.literal_concat val[0], val[1] 4986: 4987: result 4988: end
# File lib/ruby_parser.rb, line 4990 4990: def _reduce_395(val, _values, result) 4991: result = s(:array) 4992: 4993: result 4994: end
# File lib/ruby_parser.rb, line 4996 4996: def _reduce_396(val, _values, result) 4997: result = val[1] 4998: 4999: result 5000: end
# File lib/ruby_parser.rb, line 5002 5002: def _reduce_397(val, _values, result) 5003: result = s(:array) 5004: 5005: result 5006: end
# File lib/ruby_parser.rb, line 5008 5008: def _reduce_398(val, _values, result) 5009: result = val[0] << s(:str, val[1]) 5010: 5011: result 5012: end
# File lib/ruby_parser.rb, line 5014 5014: def _reduce_399(val, _values, result) 5015: result = s(:str, "") 5016: 5017: result 5018: end
# File lib/ruby_parser.rb, line 2968 2968: def _reduce_4(val, _values, result) 2969: result = new_compstmt val 2970: 2971: result 2972: end
# File lib/ruby_parser.rb, line 5020 5020: def _reduce_400(val, _values, result) 5021: result = literal_concat(val[0], val[1]) 5022: 5023: result 5024: end
# File lib/ruby_parser.rb, line 5026 5026: def _reduce_401(val, _values, result) 5027: result = nil 5028: 5029: result 5030: end
# File lib/ruby_parser.rb, line 5032 5032: def _reduce_402(val, _values, result) 5033: result = literal_concat(val[0], val[1]) 5034: 5035: result 5036: end
# File lib/ruby_parser.rb, line 5038 5038: def _reduce_403(val, _values, result) 5039: result = s(:str, val[0]) 5040: 5041: result 5042: end
# File lib/ruby_parser.rb, line 5044 5044: def _reduce_404(val, _values, result) 5045: result = lexer.lex_strterm 5046: lexer.lex_strterm = nil 5047: lexer.lex_state = :expr_beg 5048: 5049: result 5050: end
# File lib/ruby_parser.rb, line 5052 5052: def _reduce_405(val, _values, result) 5053: lexer.lex_strterm = val[1] 5054: result = s(:evstr, val[2]) 5055: 5056: result 5057: end
# File lib/ruby_parser.rb, line 5059 5059: def _reduce_406(val, _values, result) 5060: result = lexer.lex_strterm 5061: lexer.lex_strterm = nil 5062: lexer.lex_state = :expr_beg 5063: lexer.cond.push false 5064: lexer.cmdarg.push false 5065: 5066: result 5067: end
# File lib/ruby_parser.rb, line 5069 5069: def _reduce_407(val, _values, result) 5070: lexer.lex_strterm = val[1] 5071: lexer.cond.lexpop 5072: lexer.cmdarg.lexpop 5073: 5074: case val[2] 5075: when Sexp then 5076: case val[2][0] 5077: when :str, :dstr, :evstr then 5078: result = val[2] 5079: else 5080: result = s(:evstr, val[2]) 5081: end 5082: when nil then 5083: result = s(:evstr) 5084: else 5085: raise "unknown rescue body: #{val[2].inspect}" 5086: end 5087: 5088: result 5089: end
# File lib/ruby_parser.rb, line 5091 5091: def _reduce_408(val, _values, result) 5092: result = s(:gvar, val[0].to_sym) 5093: result 5094: end
# File lib/ruby_parser.rb, line 5096 5096: def _reduce_409(val, _values, result) 5097: result = s(:ivar, val[0].to_sym) 5098: result 5099: end
reduce 40 omitted
# File lib/ruby_parser.rb, line 3178 3178: def _reduce_41(val, _values, result) 3179: result = value_expr(val[0]) 3180: 3181: result 3182: end
# File lib/ruby_parser.rb, line 5101 5101: def _reduce_410(val, _values, result) 5102: result = s(:cvar, val[0].to_sym) 5103: result 5104: end
reduce 411 omitted
# File lib/ruby_parser.rb, line 5108 5108: def _reduce_412(val, _values, result) 5109: lexer.lex_state = :expr_end 5110: result = val[1].to_sym 5111: 5112: result 5113: end
# File lib/ruby_parser.rb, line 5115 5115: def _reduce_413(val, _values, result) 5116: result = val[0].to_sym 5117: 5118: result 5119: end
reduce 417 omitted
# File lib/ruby_parser.rb, line 5129 5129: def _reduce_418(val, _values, result) 5130: lexer.lex_state = :expr_end 5131: result = val[1] 5132: 5133: yyerror "empty symbol literal" if 5134: result.nil? or result.empty? 5135: 5136: case result[0] 5137: when :dstr then 5138: result[0] = :dsym 5139: when :str then 5140: result = s(:lit, result.last.intern) 5141: else 5142: result = s(:dsym, "", result) 5143: end 5144: 5145: result 5146: end
reduce 420 omitted
# File lib/ruby_parser.rb, line 5152 5152: def _reduce_421(val, _values, result) 5153: result = -val[1] # TODO: pt_testcase 5154: 5155: result 5156: end
# File lib/ruby_parser.rb, line 5158 5158: def _reduce_422(val, _values, result) 5159: result = -val[1] # TODO: pt_testcase 5160: 5161: result 5162: end
reduce 427 omitted
# File lib/ruby_parser.rb, line 5174 5174: def _reduce_428(val, _values, result) 5175: result = :nil 5176: result 5177: end
# File lib/ruby_parser.rb, line 5179 5179: def _reduce_429(val, _values, result) 5180: result = :self 5181: result 5182: end
# File lib/ruby_parser.rb, line 5184 5184: def _reduce_430(val, _values, result) 5185: result = :true 5186: result 5187: end
# File lib/ruby_parser.rb, line 5189 5189: def _reduce_431(val, _values, result) 5190: result = :false 5191: result 5192: end
# File lib/ruby_parser.rb, line 5194 5194: def _reduce_432(val, _values, result) 5195: result = :__FILE__ 5196: result 5197: end
# File lib/ruby_parser.rb, line 5199 5199: def _reduce_433(val, _values, result) 5200: result = :__LINE__ 5201: result 5202: end
# File lib/ruby_parser.rb, line 5204 5204: def _reduce_434(val, _values, result) 5205: result = self.gettable val[0] 5206: 5207: result 5208: end
# File lib/ruby_parser.rb, line 5210 5210: def _reduce_435(val, _values, result) 5211: result = self.assignable val[0] 5212: 5213: result 5214: end
# File lib/ruby_parser.rb, line 5216 5216: def _reduce_436(val, _values, result) 5217: result = s(:nth_ref, val[0]) 5218: result 5219: end
# File lib/ruby_parser.rb, line 5221 5221: def _reduce_437(val, _values, result) 5222: result = s(:back_ref, val[0]) 5223: result 5224: end
# File lib/ruby_parser.rb, line 5226 5226: def _reduce_438(val, _values, result) 5227: result = nil 5228: 5229: result 5230: end
# File lib/ruby_parser.rb, line 5232 5232: def _reduce_439(val, _values, result) 5233: lexer.lex_state = :expr_beg 5234: 5235: result 5236: end
reduce 43 omitted
# File lib/ruby_parser.rb, line 3188 3188: def _reduce_44(val, _values, result) 3189: result = s(:return, ret_args(val[1])) 3190: 3191: result 3192: end
# File lib/ruby_parser.rb, line 5238 5238: def _reduce_440(val, _values, result) 5239: result = val[2] 5240: 5241: result 5242: end
# File lib/ruby_parser.rb, line 5244 5244: def _reduce_441(val, _values, result) 5245: yyerrok 5246: result = nil 5247: 5248: result 5249: end
# File lib/ruby_parser.rb, line 5251 5251: def _reduce_442(val, _values, result) 5252: result = val[1] 5253: lexer.lex_state = :expr_beg 5254: 5255: result 5256: end
# File lib/ruby_parser.rb, line 5258 5258: def _reduce_443(val, _values, result) 5259: result = val[0] 5260: 5261: result 5262: end
# File lib/ruby_parser.rb, line 5264 5264: def _reduce_444(val, _values, result) 5265: result = args val[0], val[2], val[4], val[5] 5266: 5267: result 5268: end
# File lib/ruby_parser.rb, line 5270 5270: def _reduce_445(val, _values, result) 5271: result = args val[0], val[2], nil, val[3] 5272: 5273: result 5274: end
# File lib/ruby_parser.rb, line 5276 5276: def _reduce_446(val, _values, result) 5277: result = args val[0], nil, val[2], val[3] 5278: 5279: result 5280: end
# File lib/ruby_parser.rb, line 5282 5282: def _reduce_447(val, _values, result) 5283: result = args val[0], nil, nil, val[1] 5284: 5285: result 5286: end
# File lib/ruby_parser.rb, line 5288 5288: def _reduce_448(val, _values, result) 5289: result = args nil, val[0], val[2], val[3] 5290: 5291: result 5292: end
# File lib/ruby_parser.rb, line 5294 5294: def _reduce_449(val, _values, result) 5295: result = args nil, val[0], nil, val[1] 5296: 5297: result 5298: end
# File lib/ruby_parser.rb, line 3194 3194: def _reduce_45(val, _values, result) 3195: result = s(:break, ret_args(val[1])) 3196: 3197: result 3198: end
# File lib/ruby_parser.rb, line 5300 5300: def _reduce_450(val, _values, result) 5301: result = args nil, nil, val[0], val[1] 5302: 5303: result 5304: end
# File lib/ruby_parser.rb, line 5306 5306: def _reduce_451(val, _values, result) 5307: result = args nil, nil, nil, val[0] 5308: 5309: result 5310: end
# File lib/ruby_parser.rb, line 5312 5312: def _reduce_452(val, _values, result) 5313: result = args nil, nil, nil, nil 5314: 5315: result 5316: end
# File lib/ruby_parser.rb, line 5318 5318: def _reduce_453(val, _values, result) 5319: yyerror "formal argument cannot be a constant: #{val[0]}" 5320: 5321: result 5322: end
# File lib/ruby_parser.rb, line 5324 5324: def _reduce_454(val, _values, result) 5325: yyerror "formal argument cannot be an instance variable" 5326: 5327: result 5328: end
# File lib/ruby_parser.rb, line 5330 5330: def _reduce_455(val, _values, result) 5331: yyerror "formal argument cannot be a class variable" 5332: 5333: result 5334: end
# File lib/ruby_parser.rb, line 5336 5336: def _reduce_456(val, _values, result) 5337: identifier = val[0].to_sym 5338: self.env[identifier] = :lvar 5339: 5340: result = val[0] 5341: 5342: result 5343: end
# File lib/ruby_parser.rb, line 5345 5345: def _reduce_457(val, _values, result) 5346: result = s(:args) 5347: result << val[0].to_sym 5348: 5349: result 5350: end
# File lib/ruby_parser.rb, line 5352 5352: def _reduce_458(val, _values, result) 5353: val[0] << val[2].to_sym 5354: result = val[0] 5355: 5356: result 5357: end
# File lib/ruby_parser.rb, line 5359 5359: def _reduce_459(val, _values, result) 5360: result = self.assignable val[0], val[2] 5361: # TODO: detect duplicate names 5362: 5363: result 5364: end
# File lib/ruby_parser.rb, line 3200 3200: def _reduce_46(val, _values, result) 3201: result = s(:next, ret_args(val[1])) 3202: 3203: result 3204: end
# File lib/ruby_parser.rb, line 5366 5366: def _reduce_460(val, _values, result) 5367: result = s(:block, val[0]) 5368: 5369: result 5370: end
# File lib/ruby_parser.rb, line 5372 5372: def _reduce_461(val, _values, result) 5373: result = self.append_to_block val[0], val[2] 5374: 5375: result 5376: end
reduce 463 omitted
# File lib/ruby_parser.rb, line 5382 5382: def _reduce_464(val, _values, result) 5383: # TODO: differs from parse.y - needs tests 5384: name = val[1].to_sym 5385: self.assignable name 5386: result = :"*#{name}" 5387: 5388: result 5389: end
# File lib/ruby_parser.rb, line 5391 5391: def _reduce_465(val, _values, result) 5392: name = :"*" 5393: self.env[name] = :lvar 5394: result = name 5395: 5396: result 5397: end
reduce 467 omitted
# File lib/ruby_parser.rb, line 5403 5403: def _reduce_468(val, _values, result) 5404: identifier = val[1].to_sym 5405: 5406: self.env[identifier] = :lvar 5407: result = s(:block_arg, identifier.to_sym) 5408: 5409: result 5410: end
# File lib/ruby_parser.rb, line 5412 5412: def _reduce_469(val, _values, result) 5413: result = val[1] 5414: 5415: result 5416: end
# File lib/ruby_parser.rb, line 5418 5418: def _reduce_470(val, _values, result) 5419: result = nil 5420: 5421: result 5422: end
reduce 471 omitted
# File lib/ruby_parser.rb, line 5426 5426: def _reduce_472(val, _values, result) 5427: lexer.lex_state = :expr_beg 5428: 5429: result 5430: end
# File lib/ruby_parser.rb, line 5432 5432: def _reduce_473(val, _values, result) 5433: result = val[2] 5434: yyerror "Can't define single method for literals." if 5435: result[0] == :lit 5436: 5437: result 5438: end
# File lib/ruby_parser.rb, line 5440 5440: def _reduce_474(val, _values, result) 5441: result = s(:array) 5442: 5443: result 5444: end
# File lib/ruby_parser.rb, line 5446 5446: def _reduce_475(val, _values, result) 5447: result = val[0] 5448: 5449: result 5450: end
# File lib/ruby_parser.rb, line 5452 5452: def _reduce_476(val, _values, result) 5453: size = val[0].size 5454: if (size % 2 != 1) then # != 1 because of leading :array 5455: yyerror "Odd number (#{size}) list for Hash. #{val[0].inspect}" 5456: end 5457: result = val[0] 5458: 5459: result 5460: end
reduce 477 omitted
# File lib/ruby_parser.rb, line 5464 5464: def _reduce_478(val, _values, result) 5465: list = val[0].dup 5466: more = val[2][1..1] 5467: list.push(*more) unless more.empty? 5468: result = list 5469: 5470: result 5471: end
# File lib/ruby_parser.rb, line 5473 5473: def _reduce_479(val, _values, result) 5474: result = s(:array, val[0], val[2]) 5475: 5476: result 5477: end
reduce 47 omitted
# File lib/ruby_parser.rb, line 3208 3208: def _reduce_48(val, _values, result) 3209: result = new_call val[0], val[2], val[3] 3210: 3211: result 3212: end
# File lib/ruby_parser.rb, line 3214 3214: def _reduce_49(val, _values, result) 3215: result = new_call val[0], val[2], val[3] 3216: 3217: result 3218: end
reduce 498 omitted
# File lib/ruby_parser.rb, line 5517 5517: def _reduce_499(val, _values, result) 5518: yyerrok 5519: result 5520: end
# File lib/ruby_parser.rb, line 3220 3220: def _reduce_50(val, _values, result) 3221: self.env.extend(:dynamic) 3222: result = self.lexer.lineno 3223: 3224: result 3225: end
reduce 501 omitted
# File lib/ruby_parser.rb, line 5526 5526: def _reduce_502(val, _values, result) 5527: yyerrok 5528: result 5529: end
# File lib/ruby_parser.rb, line 5531 5531: def _reduce_503(val, _values, result) 5532: result = nil 5533: result 5534: end
# File lib/ruby_parser.rb, line 5536 5536: def _reduce_504(val, _values, result) 5537: result = nil 5538: result 5539: end
# File lib/ruby_parser.rb, line 3227 3227: def _reduce_51(val, _values, result) 3228: result = self.env.dynamic.keys 3229: 3230: result 3231: end
# File lib/ruby_parser.rb, line 3233 3233: def _reduce_52(val, _values, result) 3234: result = new_iter nil, val[2], val[4] 3235: self.env.unextend 3236: 3237: result 3238: end
# File lib/ruby_parser.rb, line 3240 3240: def _reduce_53(val, _values, result) 3241: result = new_call nil, val[0].to_sym, val[1] 3242: 3243: result 3244: end
# File lib/ruby_parser.rb, line 3246 3246: def _reduce_54(val, _values, result) 3247: result = new_call nil, val[0].to_sym, val[1] 3248: if val[2] then 3249: if result[0] == :block_pass then 3250: raise "both block arg and actual block given" 3251: end 3252: result, operation = val[2], result 3253: result.insert 1, operation 3254: end 3255: 3256: result 3257: end
# File lib/ruby_parser.rb, line 3259 3259: def _reduce_55(val, _values, result) 3260: result = new_call val[0], val[2].to_sym, val[3] 3261: 3262: result 3263: end
# File lib/ruby_parser.rb, line 3265 3265: def _reduce_56(val, _values, result) 3266: result = new_call val[0], val[2].to_sym, val[3] 3267: 3268: result 3269: end
# File lib/ruby_parser.rb, line 3271 3271: def _reduce_57(val, _values, result) 3272: result = new_call val[0], val[2].to_sym, val[3] 3273: 3274: result 3275: end
# File lib/ruby_parser.rb, line 3277 3277: def _reduce_58(val, _values, result) 3278: result = new_call val[0], val[2].to_sym, val[3] 3279: if val[4] then 3280: if result[0] == :block_pass then # REFACTOR 3281: raise "both block arg and actual block given" 3282: end 3283: val[2] << result 3284: result = val[2] 3285: end 3286: 3287: result 3288: end
# File lib/ruby_parser.rb, line 3290 3290: def _reduce_59(val, _values, result) 3291: result = new_super val[1] 3292: 3293: result 3294: end
# File lib/ruby_parser.rb, line 3296 3296: def _reduce_60(val, _values, result) 3297: result = new_yield val[1] 3298: 3299: result 3300: end
reduce 61 omitted
# File lib/ruby_parser.rb, line 3304 3304: def _reduce_62(val, _values, result) 3305: result = val[1] 3306: 3307: result 3308: end
reduce 63 omitted
# File lib/ruby_parser.rb, line 3312 3312: def _reduce_64(val, _values, result) 3313: result = s(:masgn, s(:array, val[1])) 3314: 3315: result 3316: end
# File lib/ruby_parser.rb, line 3318 3318: def _reduce_65(val, _values, result) 3319: result = s(:masgn, val[0]) 3320: 3321: result 3322: end
# File lib/ruby_parser.rb, line 3324 3324: def _reduce_66(val, _values, result) 3325: result = s(:masgn, val[0] << val[1].compact) 3326: 3327: result 3328: end
# File lib/ruby_parser.rb, line 3330 3330: def _reduce_67(val, _values, result) 3331: result = s(:masgn, val[0] << s(:splat, val[2])) 3332: 3333: result 3334: end
# File lib/ruby_parser.rb, line 3336 3336: def _reduce_68(val, _values, result) 3337: result = s(:masgn, val[0] << s(:splat)) 3338: 3339: result 3340: end
# File lib/ruby_parser.rb, line 3342 3342: def _reduce_69(val, _values, result) 3343: result = s(:masgn, s(:array, s(:splat, val[1]))) 3344: 3345: result 3346: end
reduce 6 omitted
# File lib/ruby_parser.rb, line 2978 2978: def _reduce_7(val, _values, result) 2979: result = self.block_append val[0], val[2] 2980: 2981: result 2982: end
# File lib/ruby_parser.rb, line 3348 3348: def _reduce_70(val, _values, result) 3349: result = s(:masgn, s(:array, s(:splat))) 3350: 3351: result 3352: end
reduce 71 omitted
# File lib/ruby_parser.rb, line 3356 3356: def _reduce_72(val, _values, result) 3357: result = val[1] 3358: 3359: result 3360: end
# File lib/ruby_parser.rb, line 3362 3362: def _reduce_73(val, _values, result) 3363: result = s(:array, val[0]) 3364: 3365: result 3366: end
# File lib/ruby_parser.rb, line 3368 3368: def _reduce_74(val, _values, result) 3369: result = val[0] << val[1].compact 3370: 3371: result 3372: end
# File lib/ruby_parser.rb, line 3374 3374: def _reduce_75(val, _values, result) 3375: result = self.assignable val[0] 3376: 3377: result 3378: end
# File lib/ruby_parser.rb, line 3380 3380: def _reduce_76(val, _values, result) 3381: result = self.aryset val[0], val[2] 3382: 3383: result 3384: end
# File lib/ruby_parser.rb, line 3386 3386: def _reduce_77(val, _values, result) 3387: result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist)) 3388: 3389: result 3390: end
# File lib/ruby_parser.rb, line 3392 3392: def _reduce_78(val, _values, result) 3393: result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist)) 3394: 3395: result 3396: end
# File lib/ruby_parser.rb, line 3398 3398: def _reduce_79(val, _values, result) 3399: result = s(:attrasgn, val[0], :"#{val[2]}=", s(:arglist)) 3400: 3401: result 3402: end
# File lib/ruby_parser.rb, line 2984 2984: def _reduce_8(val, _values, result) 2985: result = val[1] 2986: 2987: result 2988: end
# File lib/ruby_parser.rb, line 3404 3404: def _reduce_80(val, _values, result) 3405: if (self.in_def || self.in_single > 0) then 3406: yyerror "dynamic constant assignment" 3407: end 3408: 3409: result = s(:const, s(:colon2, val[0], val[2].to_sym), nil) 3410: 3411: result 3412: end
# File lib/ruby_parser.rb, line 3414 3414: def _reduce_81(val, _values, result) 3415: if (self.in_def || self.in_single > 0) then 3416: yyerror "dynamic constant assignment" 3417: end 3418: 3419: result = s(:const, nil, s(:colon3, val[1].to_sym)) 3420: 3421: result 3422: end
# File lib/ruby_parser.rb, line 3424 3424: def _reduce_82(val, _values, result) 3425: self.backref_assign_error val[0] 3426: 3427: result 3428: end
# File lib/ruby_parser.rb, line 3430 3430: def _reduce_83(val, _values, result) 3431: result = self.assignable val[0] 3432: 3433: result 3434: end
# File lib/ruby_parser.rb, line 3436 3436: def _reduce_84(val, _values, result) 3437: result = self.aryset val[0], val[2] 3438: 3439: result 3440: end
# File lib/ruby_parser.rb, line 3442 3442: def _reduce_85(val, _values, result) 3443: result = s(:attrasgn, val[0], :"#{val[2]}=") 3444: 3445: result 3446: end
# File lib/ruby_parser.rb, line 3448 3448: def _reduce_86(val, _values, result) 3449: result = s(:attrasgn, val[0], :"#{val[2]}=") 3450: 3451: result 3452: end
# File lib/ruby_parser.rb, line 3454 3454: def _reduce_87(val, _values, result) 3455: result = s(:attrasgn, val[0], :"#{val[2]}=") 3456: 3457: result 3458: end
# File lib/ruby_parser.rb, line 3460 3460: def _reduce_88(val, _values, result) 3461: if (self.in_def || self.in_single > 0) then 3462: yyerror "dynamic constant assignment" 3463: end 3464: 3465: result = s(:const, s(:colon2, val[0], val[2].to_sym)) 3466: 3467: result 3468: end
# File lib/ruby_parser.rb, line 3470 3470: def _reduce_89(val, _values, result) 3471: if (self.in_def || self.in_single > 0) then 3472: yyerror "dynamic constant assignment" 3473: end 3474: 3475: result = s(:const, s(:colon3, val[1].to_sym)) 3476: 3477: result 3478: end
# File lib/ruby_parser.rb, line 2990 2990: def _reduce_9(val, _values, result) 2991: lexer.lex_state = :expr_fname 2992: result = self.lexer.lineno 2993: 2994: result 2995: end
# File lib/ruby_parser.rb, line 3480 3480: def _reduce_90(val, _values, result) 3481: self.backref_assign_error val[0] 3482: 3483: result 3484: end
# File lib/ruby_parser.rb, line 3486 3486: def _reduce_91(val, _values, result) 3487: yyerror "class/module name must be CONSTANT" 3488: 3489: result 3490: end
reduce 92 omitted
# File lib/ruby_parser.rb, line 3494 3494: def _reduce_93(val, _values, result) 3495: result = s(:colon3, val[1].to_sym) 3496: 3497: result 3498: end
# File lib/ruby_parser.rb, line 3500 3500: def _reduce_94(val, _values, result) 3501: result = val[0].to_sym 3502: 3503: result 3504: end
# File lib/ruby_parser.rb, line 3506 3506: def _reduce_95(val, _values, result) 3507: result = s(:colon2, val[0], val[2].to_sym) 3508: 3509: result 3510: end
reduce 98 omitted
# File lib/ruby_parser.rb, line 3518 3518: def _reduce_99(val, _values, result) 3519: lexer.lex_state = :expr_end 3520: result = val[0] 3521: 3522: result 3523: end
# File lib/ruby_parser.rb, line 5541 5541: def _reduce_none(val, _values, result) 5542: val[0] 5543: end
# File lib/ruby_parser_extras.rb, line 123 123: def append_to_block head, tail # FIX: wtf is this?!? switch to block_append 124: return head if tail.nil? 125: return tail if head.nil? 126: 127: head = s(:block, head) unless head.node_type == :block 128: head << tail 129: head 130: end
# File lib/ruby_parser_extras.rb, line 132 132: def arg_add(node1, node2) # TODO: nuke 133: return s(:arglist, node2) unless node1 134: 135: node1[0] = :arglist if node1[0] == :array 136: return node1 << node2 if node1[0] == :arglist 137: 138: return s(:arglist, node1, node2) 139: end
# File lib/ruby_parser_extras.rb, line 141 141: def arg_blk_pass node1, node2 # TODO: nuke 142: node1 = s(:arglist, node1) unless [:arglist, :array].include? node1.first 143: node1 << node2 if node2 144: node1 145: end
# File lib/ruby_parser_extras.rb, line 147 147: def arg_concat node1, node2 # TODO: nuke 148: raise "huh" unless node2 149: node1 << s(:splat, node2).compact 150: node1 151: end
# File lib/ruby_parser_extras.rb, line 153 153: def args arg, optarg, rest_arg, block_arg 154: arg ||= s(:args) 155: 156: result = arg 157: if optarg then 158: optarg[1..1].each do |lasgn| # FIX clean sexp iter 159: raise "wtf? #{lasgn.inspect}" unless lasgn[0] == :lasgn 160: result << lasgn[1] 161: end 162: end 163: 164: result << rest_arg if rest_arg 165: result << :"&#{block_arg.last}" if block_arg 166: result << optarg if optarg # TODO? huh - processed above as well 167: 168: result 169: end
# File lib/ruby_parser_extras.rb, line 171 171: def aryset receiver, index 172: index[0] = :arglist if index[0] == :array 173: s(:attrasgn, receiver, :"[]=", index) 174: end
# File lib/ruby_parser_extras.rb, line 176 176: def assignable(lhs, value = nil) 177: id = lhs.to_sym 178: id = id.to_sym if Sexp === id 179: 180: raise SyntaxError, "Can't change the value of #{id}" if 181: id.to_s =~ /^(?:self|nil|true|false|__LINE__|__FILE__)$/ 182: 183: result = case id.to_s 184: when /^@@/ then 185: asgn = in_def || in_single > 0 186: s((asgn ? :cvasgn : :cvdecl), id) 187: when /^@/ then 188: s(:iasgn, id) 189: when /^\$/ then 190: s(:gasgn, id) 191: when /^[A-Z]/ then 192: s(:cdecl, id) 193: else 194: case self.env[id] 195: when :lvar then 196: s(:lasgn, id) 197: when :dvar, nil then 198: if self.env.current[id] == :dvar then 199: s(:lasgn, id) 200: elsif self.env[id] == :dvar then 201: self.env.use(id) 202: s(:lasgn, id) 203: elsif ! self.env.dynamic? then 204: s(:lasgn, id) 205: else 206: s(:lasgn, id) 207: end 208: else 209: raise "wtf? unknown type: #{self.env[id]}" 210: end 211: end 212: 213: self.env[id] ||= :lvar 214: 215: result << value if value 216: 217: return result 218: end
# File lib/ruby_parser_extras.rb, line 220 220: def block_append(head, tail, strip_tail_block=false) 221: return head unless tail 222: return tail unless head 223: 224: case head[0] 225: when :lit, :str then 226: return tail 227: end 228: 229: line = [head.line, tail.line].compact.min 230: 231: head = remove_begin(head) 232: head = s(:block, head) unless head[0] == :block 233: 234: if strip_tail_block and Sexp === tail and tail[0] == :block then 235: head.push(*tail.values) 236: else 237: head << tail 238: end 239: 240: head.line = line 241: head 242: end
# File lib/ruby_parser_extras.rb, line 244 244: def cond node 245: return nil if node.nil? 246: node = value_expr node 247: 248: case node.first 249: when :lit then 250: if Regexp === node.last then 251: return s(:match, node) 252: else 253: return node 254: end 255: when :and then 256: return s(:and, cond(node[1]), cond(node[2])) 257: when :or then 258: return s(:or, cond(node[1]), cond(node[2])) 259: when :dot2 then 260: label = "flip#{node.hash}" 261: env[label] = :lvar 262: return s(:flip2, node[1], node[2]) 263: when :dot3 then 264: label = "flip#{node.hash}" 265: env[label] = :lvar 266: return s(:flip3, node[1], node[2]) 267: else 268: return node 269: end 270: end
for pure ruby systems only
# File lib/ruby_parser_extras.rb, line 275 275: def do_parse 276: _racc_do_parse_rb(_racc_setup, false) 277: end
# File lib/ruby_parser_extras.rb, line 279 279: def get_match_node lhs, rhs # TODO: rename to new_match 280: if lhs then 281: case lhs[0] 282: when :dregx, :dregx_once then 283: return s(:match2, lhs, rhs).line(lhs.line) 284: when :lit then 285: return s(:match2, lhs, rhs).line(lhs.line) if Regexp === lhs.last 286: end 287: end 288: 289: if rhs then 290: case rhs[0] 291: when :dregx, :dregx_once then 292: return s(:match3, rhs, lhs).line(lhs.line) 293: when :lit then 294: return s(:match3, rhs, lhs).line(lhs.line) if Regexp === rhs.last 295: end 296: end 297: 298: return s(:call, lhs, :"=~", s(:arglist, rhs)).line(lhs.line) 299: end
# File lib/ruby_parser_extras.rb, line 301 301: def gettable(id) 302: raise "no: #{id.inspect}" if Sexp === id 303: id = id.to_sym if Sexp === id # HACK 304: id = id.to_sym if String === id # HACK 305: 306: return s(:self) if id == :self 307: return s(:nil) if id == :nil 308: return s(:true) if id == :true 309: return s(:false) if id == :false 310: return s(:str, self.file) if id == :"__FILE__" 311: return s(:lit, lexer.src.current_line) if id == :"__LINE__" 312: 313: result = case id.to_s 314: when /^@@/ then 315: s(:cvar, id) 316: when /^@/ then 317: s(:ivar, id) 318: when /^\$/ then 319: s(:gvar, id) 320: when /^[A-Z]/ then 321: s(:const, id) 322: else 323: type = env[id] 324: if type then 325: s(type, id) 326: elsif env.dynamic? and :dvar == env[id] then 327: s(:lvar, id) 328: else 329: s(:call, nil, id, s(:arglist)) 330: end 331: end 332: 333: return result if result 334: 335: raise "identifier #{id.inspect} is not valid" 336: end
# File lib/ruby_parser_extras.rb, line 348 348: def list_append list, item # TODO: nuke me *sigh* 349: return s(:array, item) unless list 350: list = s(:array, list) unless Sexp === list && list.first == :array 351: list << item 352: end
# File lib/ruby_parser_extras.rb, line 354 354: def list_prepend item, list # TODO: nuke me *sigh* 355: list = s(:array, list) unless Sexp === list && list[0] == :array 356: list.insert 1, item 357: list 358: end
# File lib/ruby_parser_extras.rb, line 360 360: def literal_concat head, tail 361: return tail unless head 362: return head unless tail 363: 364: htype, ttype = head[0], tail[0] 365: 366: head = s(:dstr, '', head) if htype == :evstr 367: 368: case ttype 369: when :str then 370: if htype == :str 371: head[1] << tail[1] 372: elsif htype == :dstr and head.size == 2 then 373: head[1] << tail[1] 374: else 375: head << tail 376: end 377: when :dstr then 378: if htype == :str then 379: tail[1] = head[1] + tail[1] 380: head = tail 381: else 382: tail[0] = :array 383: tail[1] = s(:str, tail[1]) 384: tail.delete_at 1 if tail[1] == s(:str, '') 385: 386: head.push(*tail[1..1]) 387: end 388: when :evstr then 389: head[0] = :dstr if htype == :str 390: if head.size == 2 and tail.size > 1 and tail[1][0] == :str then 391: head[1] << tail[1][1] 392: head[0] = :str if head.size == 2 # HACK ? 393: else 394: head.push(tail) 395: end 396: else 397: x = [head, tail] 398: raise "unknown type: #{x.inspect}" 399: end 400: 401: return head 402: end
# File lib/ruby_parser_extras.rb, line 404 404: def logop(type, left, right) # TODO: rename logical_op 405: left = value_expr left 406: 407: if left and left[0] == type and not left.paren then 408: node, second = left, nil 409: 410: while (second = node[2]) && second[0] == type and not second.paren do 411: node = second 412: end 413: 414: node[2] = s(type, second, right) 415: 416: return left 417: end 418: 419: return s(type, left, right) 420: end 421: 422: def new_aref val 423: val[2] ||= s(:arglist) 424: val[2][0] = :arglist if val[2][0] == :array # REFACTOR 425: if val[0].node_type == :self then 426: result = new_call nil, :"[]", val[2] 427: else 428: result = new_call val[0], :"[]", val[2] 429: end 430: result 431: end 432: 433: def new_body val 434: result = val[0] 435: 436: if val[1] then 437: result = s(:rescue) 438: result << val[0] if val[0] 439: 440: resbody = val[1] 441: 442: while resbody do 443: result << resbody 444: resbody = resbody.resbody(true) 445: end 446: 447: result << val[2] if val[2] 448: 449: result.line = (val[0] || val[1]).line 450: elsif not val[2].nil? then 451: warning("else without rescue is useless") 452: result = block_append(result, val[2]) 453: end 454: 455: result = s(:ensure, result, val[3]).compact if val[3] 456: return result 457: end 458: 459: def new_call recv, meth, args = nil 460: result = s(:call, recv, meth) 461: result.line = recv.line if recv 462: 463: args ||= s(:arglist) 464: args[0] = :arglist if args.first == :array 465: args = s(:arglist, args) unless args.first == :arglist 466: result << args 467: result 468: end 469: 470: def new_case expr, body 471: result = s(:case, expr) 472: line = (expr || body).line 473: 474: while body and body.node_type == :when 475: result << body 476: body = body.delete_at 3 477: end 478: 479: # else 480: body = nil if body == s(:block) 481: result << body 482: 483: result.line = line 484: result 485: end 486: 487: def new_class val 488: line, path, superclass, body = val[1], val[2], val[3], val[5] 489: scope = s(:scope, body).compact 490: result = s(:class, path, superclass, scope) 491: result.line = line 492: result.comments = self.comments.pop 493: result 494: end 495: 496: def new_compstmt val 497: result = void_stmts(val[0]) 498: result = remove_begin(result) if result 499: result 500: end 501: 502: def new_defn val 503: (line, bol), name, args, body = val[2], val[1], val[3], val[4] 504: body ||= s(:nil) 505: 506: body ||= s(:block) 507: body = s(:block, body) unless body.first == :block 508: 509: result = s(:defn, name.to_sym, args, s(:scope, body)) 510: result.line = line 511: result.line -= 1 if bol 512: result.comments = self.comments.pop 513: result 514: end 515: 516: def new_defs val 517: recv, name, args, body = val[1], val[4], val[6], val[7] 518: 519: body ||= s(:block) 520: body = s(:block, body) unless body.first == :block 521: 522: result = s(:defs, recv, name.to_sym, args, s(:scope, body)) 523: result.line = recv.line 524: result.comments = self.comments.pop 525: result 526: end 527: 528: def new_for expr, var, body 529: result = s(:for, expr, var).line(var.line) 530: result << body if body 531: result 532: end 533: 534: def new_if c, t, f 535: l = [c.line, t && t.line, f && f.line].compact.min 536: c = cond c 537: c, t, f = c.last, f, t if c[0] == :not 538: s(:if, c, t, f).line(l) 539: end 540: 541: def new_iter call, args, body 542: result = s(:iter) 543: result << call if call 544: result << args 545: result << body if body 546: result 547: end 548: 549: def new_masgn lhs, rhs, wrap = false 550: rhs = value_expr(rhs) 551: rhs = lhs[1] ? s(:to_ary, rhs) : s(:array, rhs) if wrap 552: 553: lhs.delete_at 1 if lhs[1].nil? 554: lhs << rhs 555: 556: lhs 557: end 558: 559: def new_module val 560: line, path, body = val[1], val[2], val[4] 561: body = s(:scope, body).compact 562: result = s(:module, path, body) 563: result.line = line 564: result.comments = self.comments.pop 565: result 566: end 567: 568: def new_op_asgn val 569: lhs, asgn_op, arg = val[0], val[1].to_sym, val[2] 570: name = lhs.value 571: arg = remove_begin(arg) 572: result = case asgn_op # REFACTOR 573: when :"||" then 574: lhs << arg 575: s(:op_asgn_or, self.gettable(name), lhs) 576: when :"&&" then 577: lhs << arg 578: s(:op_asgn_and, self.gettable(name), lhs) 579: else 580: # TODO: why [2] ? 581: lhs[2] = new_call(self.gettable(name), asgn_op, 582: s(:arglist, arg)) 583: lhs 584: end 585: result.line = lhs.line 586: result 587: end 588: 589: def new_regexp val 590: node = val[1] || s(:str, '') 591: options = val[2] 592: 593: o, k = 0, nil 594: options.split(//).uniq.each do |c| # FIX: this has a better home 595: v = { 596: 'x' => Regexp::EXTENDED, 597: 'i' => Regexp::IGNORECASE, 598: 'm' => Regexp::MULTILINE, 599: 'o' => Regexp::ONCE, 600: 'n' => Regexp::ENC_NONE, 601: 'e' => Regexp::ENC_EUC, 602: 's' => Regexp::ENC_SJIS, 603: 'u' => Regexp::ENC_UTF8, 604: }[c] 605: raise "unknown regexp option: #{c}" unless v 606: o += v 607: k = c if c =~ /[esu]/ 608: end 609: 610: case node[0] 611: when :str then 612: node[0] = :lit 613: node[1] = if k then 614: Regexp.new(node[1], o, k) 615: else 616: Regexp.new(node[1], o) 617: end 618: when :dstr then 619: if options =~ /o/ then 620: node[0] = :dregx_once 621: else 622: node[0] = :dregx 623: end 624: node << o if o and o != 0 625: else 626: node = s(:dregx, '', node); 627: node[0] = :dregx_once if options =~ /o/ 628: node << o if o and o != 0 629: end 630: 631: node 632: end 633: 634: def new_sclass val 635: recv, in_def, in_single, body = val[3], val[4], val[6], val[7] 636: scope = s(:scope, body).compact 637: result = s(:sclass, recv, scope) 638: result.line = val[2] 639: self.in_def = in_def 640: self.in_single = in_single 641: result 642: end 643: 644: def new_super args 645: if args && args.node_type == :block_pass then 646: s(:super, args) 647: else 648: args ||= s(:arglist) 649: s(:super, *args[1..1]) 650: end 651: end 652: 653: def new_undef n, m = nil 654: if m then 655: block_append(n, s(:undef, m)) 656: else 657: s(:undef, n) 658: end 659: end 660: 661: def new_until block, expr, pre 662: expr = (expr.first == :not ? expr.last : s(:not, expr)).line(expr.line) 663: new_while block, expr, pre 664: end 665: 666: def new_while block, expr, pre 667: line = [block && block.line, expr.line].compact.min 668: block, pre = block.last, false if block && block[0] == :begin 669: 670: expr = cond expr 671: result = if expr.first == :not then 672: s(:until, expr.last, block, pre) 673: else 674: s(:while, expr, block, pre) 675: end 676: 677: result.line = line 678: result 679: end 680: 681: def new_xstring str 682: if str then 683: case str[0] 684: when :str 685: str[0] = :xstr 686: when :dstr 687: str[0] = :dxstr 688: else 689: str = s(:dxstr, '', str) 690: end 691: str 692: else 693: s(:xstr, '') 694: end 695: end 696: 697: def new_yield args = nil 698: # TODO: raise args.inspect unless [:arglist].include? args.first # HACK 699: raise SyntaxError, "Block argument should not be given." if 700: args && args.node_type == :block_pass 701: 702: args ||= s(:arglist) 703: 704: # TODO: I can prolly clean this up 705: args[0] = :arglist if args.first == :array 706: args = s(:arglist, args) unless args.first == :arglist 707: 708: return s(:yield, *args[1..1]) 709: end 710: 711: def next_token 712: if self.lexer.advance then 713: return self.lexer.token, self.lexer.yacc_value 714: else 715: return [false, '$end'] 716: end 717: end 718: 719: def node_assign(lhs, rhs) # TODO: rename new_assign 720: return nil unless lhs 721: 722: rhs = value_expr rhs 723: 724: case lhs[0] 725: when :gasgn, :iasgn, :lasgn, :dasgn, :dasgn_curr, 726: :masgn, :cdecl, :cvdecl, :cvasgn then 727: lhs << rhs 728: when :attrasgn, :call then 729: args = lhs.pop unless Symbol === lhs.last 730: lhs << arg_add(args, rhs) 731: when :const then 732: lhs[0] = :cdecl 733: lhs << rhs 734: else 735: raise "unknown lhs #{lhs.inspect}" 736: end 737: 738: lhs 739: end 740: 741: def process(str, file = "(string)") 742: raise "bad val: #{str.inspect}" unless String === str 743: 744: self.file = file 745: self.lexer.src = str 746: 747: @yydebug = ENV.has_key? 'DEBUG' 748: 749: do_parse 750: end 751: alias :parse :process 752: 753: def remove_begin node 754: oldnode = node 755: if node and :begin == node[0] and node.size == 2 then 756: node = node[1] 757: node.line = oldnode.line 758: end 759: node 760: end 761: 762: def reset 763: lexer.reset 764: self.in_def = false 765: self.in_single = 0 766: self.env.reset 767: self.comments.clear 768: end 769: 770: def ret_args node 771: if node then 772: raise SyntaxError, "block argument should not be given" if 773: node[0] == :block_pass 774: 775: node = node.last if node[0] == :array && node.size == 2 776: # HACK matz wraps ONE of the FOUR splats in a newline to 777: # distinguish. I use paren for now. ugh 778: node = s(:svalue, node) if node[0] == :splat and not node.paren 779: node[0] = :svalue if node[0] == :arglist && node[1][0] == :splat 780: end 781: 782: node 783: end 784: 785: def s(*args) 786: result = Sexp.new(*args) 787: result.line ||= lexer.lineno if lexer.src # otherwise... 788: result.file = self.file 789: result 790: end 791: 792: def value_expr oldnode # HACK 793: node = remove_begin oldnode 794: node.line = oldnode.line if oldnode 795: node[2] = value_expr(node[2]) if node and node[0] == :if 796: node 797: end 798: 799: def void_stmts node 800: return nil unless node 801: return node unless node[0] == :block 802: 803: node[1..1] = node[1..1].map { |n| remove_begin(n) } 804: node 805: end 806: 807: def warning s 808: # do nothing for now 809: end 810: 811: alias :old_yyerror :yyerror 812: def yyerror msg 813: # for now do nothing with the msg 814: old_yyerror 815: end 816: end
# File lib/ruby_parser_extras.rb, line 422 422: def new_aref val 423: val[2] ||= s(:arglist) 424: val[2][0] = :arglist if val[2][0] == :array # REFACTOR 425: if val[0].node_type == :self then 426: result = new_call nil, :"[]", val[2] 427: else 428: result = new_call val[0], :"[]", val[2] 429: end 430: result 431: end
# File lib/ruby_parser_extras.rb, line 433 433: def new_body val 434: result = val[0] 435: 436: if val[1] then 437: result = s(:rescue) 438: result << val[0] if val[0] 439: 440: resbody = val[1] 441: 442: while resbody do 443: result << resbody 444: resbody = resbody.resbody(true) 445: end 446: 447: result << val[2] if val[2] 448: 449: result.line = (val[0] || val[1]).line 450: elsif not val[2].nil? then 451: warning("else without rescue is useless") 452: result = block_append(result, val[2]) 453: end 454: 455: result = s(:ensure, result, val[3]).compact if val[3] 456: return result 457: end
# File lib/ruby_parser_extras.rb, line 459 459: def new_call recv, meth, args = nil 460: result = s(:call, recv, meth) 461: result.line = recv.line if recv 462: 463: args ||= s(:arglist) 464: args[0] = :arglist if args.first == :array 465: args = s(:arglist, args) unless args.first == :arglist 466: result << args 467: result 468: end
# File lib/ruby_parser_extras.rb, line 470 470: def new_case expr, body 471: result = s(:case, expr) 472: line = (expr || body).line 473: 474: while body and body.node_type == :when 475: result << body 476: body = body.delete_at 3 477: end 478: 479: # else 480: body = nil if body == s(:block) 481: result << body 482: 483: result.line = line 484: result 485: end
# File lib/ruby_parser_extras.rb, line 487 487: def new_class val 488: line, path, superclass, body = val[1], val[2], val[3], val[5] 489: scope = s(:scope, body).compact 490: result = s(:class, path, superclass, scope) 491: result.line = line 492: result.comments = self.comments.pop 493: result 494: end
# File lib/ruby_parser_extras.rb, line 496 496: def new_compstmt val 497: result = void_stmts(val[0]) 498: result = remove_begin(result) if result 499: result 500: end
# File lib/ruby_parser_extras.rb, line 502 502: def new_defn val 503: (line, bol), name, args, body = val[2], val[1], val[3], val[4] 504: body ||= s(:nil) 505: 506: body ||= s(:block) 507: body = s(:block, body) unless body.first == :block 508: 509: result = s(:defn, name.to_sym, args, s(:scope, body)) 510: result.line = line 511: result.line -= 1 if bol 512: result.comments = self.comments.pop 513: result 514: end
# File lib/ruby_parser_extras.rb, line 516 516: def new_defs val 517: recv, name, args, body = val[1], val[4], val[6], val[7] 518: 519: body ||= s(:block) 520: body = s(:block, body) unless body.first == :block 521: 522: result = s(:defs, recv, name.to_sym, args, s(:scope, body)) 523: result.line = recv.line 524: result.comments = self.comments.pop 525: result 526: end
# File lib/ruby_parser_extras.rb, line 528 528: def new_for expr, var, body 529: result = s(:for, expr, var).line(var.line) 530: result << body if body 531: result 532: end
# File lib/ruby_parser_extras.rb, line 534 534: def new_if c, t, f 535: l = [c.line, t && t.line, f && f.line].compact.min 536: c = cond c 537: c, t, f = c.last, f, t if c[0] == :not 538: s(:if, c, t, f).line(l) 539: end
# File lib/ruby_parser_extras.rb, line 541 541: def new_iter call, args, body 542: result = s(:iter) 543: result << call if call 544: result << args 545: result << body if body 546: result 547: end
# File lib/ruby_parser_extras.rb, line 549 549: def new_masgn lhs, rhs, wrap = false 550: rhs = value_expr(rhs) 551: rhs = lhs[1] ? s(:to_ary, rhs) : s(:array, rhs) if wrap 552: 553: lhs.delete_at 1 if lhs[1].nil? 554: lhs << rhs 555: 556: lhs 557: end
# File lib/ruby_parser_extras.rb, line 559 559: def new_module val 560: line, path, body = val[1], val[2], val[4] 561: body = s(:scope, body).compact 562: result = s(:module, path, body) 563: result.line = line 564: result.comments = self.comments.pop 565: result 566: end
# File lib/ruby_parser_extras.rb, line 568 568: def new_op_asgn val 569: lhs, asgn_op, arg = val[0], val[1].to_sym, val[2] 570: name = lhs.value 571: arg = remove_begin(arg) 572: result = case asgn_op # REFACTOR 573: when :"||" then 574: lhs << arg 575: s(:op_asgn_or, self.gettable(name), lhs) 576: when :"&&" then 577: lhs << arg 578: s(:op_asgn_and, self.gettable(name), lhs) 579: else 580: # TODO: why [2] ? 581: lhs[2] = new_call(self.gettable(name), asgn_op, 582: s(:arglist, arg)) 583: lhs 584: end 585: result.line = lhs.line 586: result 587: end
# File lib/ruby_parser_extras.rb, line 589 589: def new_regexp val 590: node = val[1] || s(:str, '') 591: options = val[2] 592: 593: o, k = 0, nil 594: options.split(//).uniq.each do |c| # FIX: this has a better home 595: v = { 596: 'x' => Regexp::EXTENDED, 597: 'i' => Regexp::IGNORECASE, 598: 'm' => Regexp::MULTILINE, 599: 'o' => Regexp::ONCE, 600: 'n' => Regexp::ENC_NONE, 601: 'e' => Regexp::ENC_EUC, 602: 's' => Regexp::ENC_SJIS, 603: 'u' => Regexp::ENC_UTF8, 604: }[c] 605: raise "unknown regexp option: #{c}" unless v 606: o += v 607: k = c if c =~ /[esu]/ 608: end 609: 610: case node[0] 611: when :str then 612: node[0] = :lit 613: node[1] = if k then 614: Regexp.new(node[1], o, k) 615: else 616: Regexp.new(node[1], o) 617: end 618: when :dstr then 619: if options =~ /o/ then 620: node[0] = :dregx_once 621: else 622: node[0] = :dregx 623: end 624: node << o if o and o != 0 625: else 626: node = s(:dregx, '', node); 627: node[0] = :dregx_once if options =~ /o/ 628: node << o if o and o != 0 629: end 630: 631: node 632: end
# File lib/ruby_parser_extras.rb, line 634 634: def new_sclass val 635: recv, in_def, in_single, body = val[3], val[4], val[6], val[7] 636: scope = s(:scope, body).compact 637: result = s(:sclass, recv, scope) 638: result.line = val[2] 639: self.in_def = in_def 640: self.in_single = in_single 641: result 642: end
# File lib/ruby_parser_extras.rb, line 644 644: def new_super args 645: if args && args.node_type == :block_pass then 646: s(:super, args) 647: else 648: args ||= s(:arglist) 649: s(:super, *args[1..1]) 650: end 651: end
# File lib/ruby_parser_extras.rb, line 653 653: def new_undef n, m = nil 654: if m then 655: block_append(n, s(:undef, m)) 656: else 657: s(:undef, n) 658: end 659: end
# File lib/ruby_parser_extras.rb, line 661 661: def new_until block, expr, pre 662: expr = (expr.first == :not ? expr.last : s(:not, expr)).line(expr.line) 663: new_while block, expr, pre 664: end
# File lib/ruby_parser_extras.rb, line 666 666: def new_while block, expr, pre 667: line = [block && block.line, expr.line].compact.min 668: block, pre = block.last, false if block && block[0] == :begin 669: 670: expr = cond expr 671: result = if expr.first == :not then 672: s(:until, expr.last, block, pre) 673: else 674: s(:while, expr, block, pre) 675: end 676: 677: result.line = line 678: result 679: end
# File lib/ruby_parser_extras.rb, line 681 681: def new_xstring str 682: if str then 683: case str[0] 684: when :str 685: str[0] = :xstr 686: when :dstr 687: str[0] = :dxstr 688: else 689: str = s(:dxstr, '', str) 690: end 691: str 692: else 693: s(:xstr, '') 694: end 695: end
# File lib/ruby_parser_extras.rb, line 697 697: def new_yield args = nil 698: # TODO: raise args.inspect unless [:arglist].include? args.first # HACK 699: raise SyntaxError, "Block argument should not be given." if 700: args && args.node_type == :block_pass 701: 702: args ||= s(:arglist) 703: 704: # TODO: I can prolly clean this up 705: args[0] = :arglist if args.first == :array 706: args = s(:arglist, args) unless args.first == :arglist 707: 708: return s(:yield, *args[1..1]) 709: end
# File lib/ruby_parser_extras.rb, line 711 711: def next_token 712: if self.lexer.advance then 713: return self.lexer.token, self.lexer.yacc_value 714: else 715: return [false, '$end'] 716: end 717: end
# File lib/ruby_parser_extras.rb, line 719 719: def node_assign(lhs, rhs) # TODO: rename new_assign 720: return nil unless lhs 721: 722: rhs = value_expr rhs 723: 724: case lhs[0] 725: when :gasgn, :iasgn, :lasgn, :dasgn, :dasgn_curr, 726: :masgn, :cdecl, :cvdecl, :cvasgn then 727: lhs << rhs 728: when :attrasgn, :call then 729: args = lhs.pop unless Symbol === lhs.last 730: lhs << arg_add(args, rhs) 731: when :const then 732: lhs[0] = :cdecl 733: lhs << rhs 734: else 735: raise "unknown lhs #{lhs.inspect}" 736: end 737: 738: lhs 739: end
# File lib/ruby_parser_extras.rb, line 741 741: def process(str, file = "(string)") 742: raise "bad val: #{str.inspect}" unless String === str 743: 744: self.file = file 745: self.lexer.src = str 746: 747: @yydebug = ENV.has_key? 'DEBUG' 748: 749: do_parse 750: end
# File lib/ruby_parser_extras.rb, line 753 753: def remove_begin node 754: oldnode = node 755: if node and :begin == node[0] and node.size == 2 then 756: node = node[1] 757: node.line = oldnode.line 758: end 759: node 760: end
# File lib/ruby_parser_extras.rb, line 762 762: def reset 763: lexer.reset 764: self.in_def = false 765: self.in_single = 0 766: self.env.reset 767: self.comments.clear 768: end
# File lib/ruby_parser_extras.rb, line 770 770: def ret_args node 771: if node then 772: raise SyntaxError, "block argument should not be given" if 773: node[0] == :block_pass 774: 775: node = node.last if node[0] == :array && node.size == 2 776: # HACK matz wraps ONE of the FOUR splats in a newline to 777: # distinguish. I use paren for now. ugh 778: node = s(:svalue, node) if node[0] == :splat and not node.paren 779: node[0] = :svalue if node[0] == :arglist && node[1][0] == :splat 780: end 781: 782: node 783: end
# File lib/ruby_parser_extras.rb, line 785 785: def s(*args) 786: result = Sexp.new(*args) 787: result.line ||= lexer.lineno if lexer.src # otherwise... 788: result.file = self.file 789: result 790: end
# File lib/ruby_parser_extras.rb, line 792 792: def value_expr oldnode # HACK 793: node = remove_begin oldnode 794: node.line = oldnode.line if oldnode 795: node[2] = value_expr(node[2]) if node and node[0] == :if 796: node 797: end
# File lib/ruby_parser_extras.rb, line 799 799: def void_stmts node 800: return nil unless node 801: return node unless node[0] == :block 802: 803: node[1..1] = node[1..1].map { |n| remove_begin(n) } 804: node 805: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.