ruby_parser 3.14.1 → 3.14.2

Sign up to get free protection for your applications and to get access to all the features.
@@ -992,17 +992,14 @@ rule
992
992
  | args opt_block_arg
993
993
  {
994
994
  result = call_args val
995
- result = self.arg_blk_pass val[0], val[1]
996
995
  }
997
996
  | assocs opt_block_arg
998
997
  {
999
- result = call_args [array_to_hash(val[0])]
1000
- result = self.arg_blk_pass result, val[1]
998
+ result = call_args [array_to_hash(val[0]), val[1]]
1001
999
  }
1002
1000
  | args tCOMMA assocs opt_block_arg
1003
1001
  {
1004
- result = call_args [val[0], array_to_hash(val[2])]
1005
- result = self.arg_blk_pass result, val[3]
1002
+ result = call_args [val[0], array_to_hash(val[2]), val[3]]
1006
1003
  }
1007
1004
  | block_arg
1008
1005
  {
@@ -1,7 +1,7 @@
1
1
  #
2
2
  # DO NOT MODIFY!!!!
3
- # This file is automatically generated by Racc 1.4.15
4
- # from Racc grammer file "".
3
+ # This file is automatically generated by Racc 1.4.16
4
+ # from Racc grammar file "".
5
5
  #
6
6
 
7
7
  require 'racc/parser.rb'
@@ -3563,20 +3563,20 @@ Racc_debug_parser = false
3563
3563
 
3564
3564
  def _reduce_1(val, _values, result)
3565
3565
  self.lexer.lex_state = EXPR_BEG
3566
-
3566
+
3567
3567
  result
3568
3568
  end
3569
3569
 
3570
3570
  def _reduce_2(val, _values, result)
3571
3571
  result = new_compstmt val
3572
-
3572
+
3573
3573
  result
3574
3574
  end
3575
3575
 
3576
3576
  def _reduce_3(val, _values, result)
3577
3577
  stmt, _ = val
3578
3578
  result = stmt
3579
-
3579
+
3580
3580
  result
3581
3581
  end
3582
3582
 
@@ -3586,7 +3586,7 @@ end
3586
3586
 
3587
3587
  def _reduce_6(val, _values, result)
3588
3588
  result = self.block_append val[0], val[2]
3589
-
3589
+
3590
3590
  result
3591
3591
  end
3592
3592
 
@@ -3600,7 +3600,7 @@ def _reduce_9(val, _values, result)
3600
3600
  yyerror "BEGIN in method"
3601
3601
  end
3602
3602
  self.env.extend
3603
-
3603
+
3604
3604
  result
3605
3605
  end
3606
3606
 
@@ -3612,26 +3612,26 @@ def _reduce_10(val, _values, result)
3612
3612
  preexe.line lineno
3613
3613
 
3614
3614
  result = iter
3615
-
3615
+
3616
3616
  result
3617
3617
  end
3618
3618
 
3619
3619
  def _reduce_11(val, _values, result)
3620
- result = lexer.lineno
3620
+ result = lexer.lineno
3621
3621
  result
3622
3622
  end
3623
3623
 
3624
3624
  def _reduce_12(val, _values, result)
3625
3625
  _, line, stmt, _ = val
3626
3626
  result = new_iter s(:preexe).line(line), 0, stmt
3627
-
3627
+
3628
3628
  result
3629
3629
  end
3630
3630
 
3631
3631
  def _reduce_13(val, _values, result)
3632
3632
  res = _values[-2]
3633
3633
  yyerror "else without rescue is useless" unless res
3634
-
3634
+
3635
3635
  result
3636
3636
  end
3637
3637
 
@@ -3639,7 +3639,7 @@ def _reduce_14(val, _values, result)
3639
3639
  body, resc, _, _, els, ens = val
3640
3640
 
3641
3641
  result = new_body [body, resc, els, ens]
3642
-
3642
+
3643
3643
  result
3644
3644
  end
3645
3645
 
@@ -3647,13 +3647,13 @@ def _reduce_15(val, _values, result)
3647
3647
  body, resc, ens = val
3648
3648
 
3649
3649
  result = new_body [body, resc, nil, ens]
3650
-
3650
+
3651
3651
  result
3652
3652
  end
3653
3653
 
3654
3654
  def _reduce_16(val, _values, result)
3655
3655
  result = new_compstmt val
3656
-
3656
+
3657
3657
  result
3658
3658
  end
3659
3659
 
@@ -3663,14 +3663,14 @@ end
3663
3663
 
3664
3664
  def _reduce_19(val, _values, result)
3665
3665
  result = self.block_append val[0], val[2]
3666
-
3666
+
3667
3667
  result
3668
3668
  end
3669
3669
 
3670
3670
  def _reduce_20(val, _values, result)
3671
3671
  result = val[1]
3672
3672
  debug20 2, val, result
3673
-
3673
+
3674
3674
  result
3675
3675
  end
3676
3676
 
@@ -3678,74 +3678,74 @@ end
3678
3678
 
3679
3679
  def _reduce_22(val, _values, result)
3680
3680
  yyerror "BEGIN is permitted only at toplevel"
3681
-
3681
+
3682
3682
  result
3683
3683
  end
3684
3684
 
3685
3685
  def _reduce_23(val, _values, result)
3686
3686
  lexer.lex_state = EXPR_FNAME
3687
-
3687
+
3688
3688
  result
3689
3689
  end
3690
3690
 
3691
3691
  def _reduce_24(val, _values, result)
3692
3692
  (_, line), lhs, _, rhs = val
3693
3693
  result = s(:alias, lhs, rhs).line(line).line line
3694
-
3694
+
3695
3695
  result
3696
3696
  end
3697
3697
 
3698
3698
  def _reduce_25(val, _values, result)
3699
3699
  (_, line), lhs, rhs = val
3700
3700
  result = s(:valias, lhs.to_sym, rhs.to_sym).line line
3701
-
3701
+
3702
3702
  result
3703
3703
  end
3704
3704
 
3705
3705
  def _reduce_26(val, _values, result)
3706
3706
  (_, line), lhs, rhs = val
3707
3707
  result = s(:valias, lhs.to_sym, :"$#{rhs}").line line
3708
-
3708
+
3709
3709
  result
3710
3710
  end
3711
3711
 
3712
3712
  def _reduce_27(val, _values, result)
3713
3713
  yyerror "can't make alias for the number variables"
3714
-
3714
+
3715
3715
  result
3716
3716
  end
3717
3717
 
3718
3718
  def _reduce_28(val, _values, result)
3719
3719
  result = val[1]
3720
-
3720
+
3721
3721
  result
3722
3722
  end
3723
3723
 
3724
3724
  def _reduce_29(val, _values, result)
3725
3725
  t, _, c = val
3726
3726
  result = new_if c, t, nil
3727
-
3727
+
3728
3728
  result
3729
3729
  end
3730
3730
 
3731
3731
  def _reduce_30(val, _values, result)
3732
3732
  f, _, c = val
3733
3733
  result = new_if c, nil, f
3734
-
3734
+
3735
3735
  result
3736
3736
  end
3737
3737
 
3738
3738
  def _reduce_31(val, _values, result)
3739
3739
  e, _, c = val
3740
3740
  result = new_while e, c, true
3741
-
3741
+
3742
3742
  result
3743
3743
  end
3744
3744
 
3745
3745
  def _reduce_32(val, _values, result)
3746
3746
  e, _, c = val
3747
3747
  result = new_until e, c, true
3748
-
3748
+
3749
3749
  result
3750
3750
  end
3751
3751
 
@@ -3754,7 +3754,7 @@ def _reduce_33(val, _values, result)
3754
3754
 
3755
3755
  resbody = new_resbody s(:array).line(resbody.line), resbody
3756
3756
  result = new_rescue body, resbody
3757
-
3757
+
3758
3758
  result
3759
3759
  end
3760
3760
 
@@ -3767,7 +3767,7 @@ def _reduce_34(val, _values, result)
3767
3767
  end
3768
3768
 
3769
3769
  result = new_iter s(:postexe).line(line), 0, stmt
3770
-
3770
+
3771
3771
  result
3772
3772
  end
3773
3773
 
@@ -3775,20 +3775,20 @@ end
3775
3775
 
3776
3776
  def _reduce_36(val, _values, result)
3777
3777
  result = new_masgn val[0], val[2], :wrap
3778
-
3778
+
3779
3779
  result
3780
3780
  end
3781
3781
 
3782
3782
  def _reduce_37(val, _values, result)
3783
3783
  lhs, _, rhs = val
3784
3784
  result = new_assign lhs, s(:svalue, rhs).line(rhs.line)
3785
-
3785
+
3786
3786
  result
3787
3787
  end
3788
3788
 
3789
3789
  def _reduce_38(val, _values, result)
3790
3790
  result = new_masgn val[0], val[2]
3791
-
3791
+
3792
3792
  result
3793
3793
  end
3794
3794
 
@@ -3796,19 +3796,19 @@ end
3796
3796
 
3797
3797
  def _reduce_40(val, _values, result)
3798
3798
  result = new_assign val[0], val[2]
3799
-
3799
+
3800
3800
  result
3801
3801
  end
3802
3802
 
3803
3803
  def _reduce_41(val, _values, result)
3804
3804
  result = new_op_asgn val
3805
-
3805
+
3806
3806
  result
3807
3807
  end
3808
3808
 
3809
3809
  def _reduce_42(val, _values, result)
3810
3810
  result = new_op_asgn1 val
3811
-
3811
+
3812
3812
  result
3813
3813
  end
3814
3814
 
@@ -3819,7 +3819,7 @@ def _reduce_43(val, _values, result)
3819
3819
  result.sexp_type = :safe_op_asgn
3820
3820
  end
3821
3821
  result.line = val[0].line
3822
-
3822
+
3823
3823
  result
3824
3824
  end
3825
3825
 
@@ -3829,34 +3829,34 @@ def _reduce_44(val, _values, result)
3829
3829
  result.sexp_type = :safe_op_asgn
3830
3830
  end
3831
3831
  result.line = val[0].line
3832
-
3832
+
3833
3833
  result
3834
3834
  end
3835
3835
 
3836
3836
  def _reduce_45(val, _values, result)
3837
3837
  result = s(:op_asgn, val[0], val[4], val[2], val[3])
3838
3838
  debug20 4, val, result
3839
-
3839
+
3840
3840
  result
3841
3841
  end
3842
3842
 
3843
3843
  def _reduce_46(val, _values, result)
3844
3844
  result = s(:op_asgn, val[0], val[4], val[2], val[3])
3845
3845
  debug20 5, val, result
3846
-
3846
+
3847
3847
  result
3848
3848
  end
3849
3849
 
3850
3850
  def _reduce_47(val, _values, result)
3851
3851
  self.backref_assign_error val[0]
3852
-
3852
+
3853
3853
  result
3854
3854
  end
3855
3855
 
3856
3856
  def _reduce_48(val, _values, result)
3857
3857
  expr, = val
3858
3858
  result = value_expr expr
3859
-
3859
+
3860
3860
  result
3861
3861
  end
3862
3862
 
@@ -3866,7 +3866,7 @@ def _reduce_49(val, _values, result)
3866
3866
  expr = value_expr expr
3867
3867
  ary = s(:array).line line
3868
3868
  result = new_rescue(expr, new_resbody(ary, resbody))
3869
-
3869
+
3870
3870
  result
3871
3871
  end
3872
3872
 
@@ -3877,14 +3877,14 @@ end
3877
3877
  def _reduce_52(val, _values, result)
3878
3878
  lhs, _, rhs = val
3879
3879
  result = logical_op :and, lhs, rhs
3880
-
3880
+
3881
3881
  result
3882
3882
  end
3883
3883
 
3884
3884
  def _reduce_53(val, _values, result)
3885
3885
  lhs, _, rhs = val
3886
3886
  result = logical_op :or, lhs, rhs
3887
-
3887
+
3888
3888
  result
3889
3889
  end
3890
3890
 
@@ -3892,7 +3892,7 @@ def _reduce_54(val, _values, result)
3892
3892
  (_, line), _, expr = val
3893
3893
  result = new_call(expr, :"!").line line
3894
3894
  # REFACTOR: call_uni_op
3895
-
3895
+
3896
3896
  result
3897
3897
  end
3898
3898
 
@@ -3901,7 +3901,7 @@ def _reduce_55(val, _values, result)
3901
3901
  result = new_call(cmd, :"!").line cmd.line
3902
3902
  # TODO: fix line number to tBANG... but causes BAD shift/reduce conflict
3903
3903
  # REFACTOR: call_uni_op -- see parse26.y
3904
-
3904
+
3905
3905
  result
3906
3906
  end
3907
3907
 
@@ -3909,26 +3909,26 @@ end
3909
3909
 
3910
3910
  def _reduce_57(val, _values, result)
3911
3911
  result = value_expr(val[0])
3912
-
3912
+
3913
3913
  result
3914
3914
  end
3915
3915
 
3916
3916
  def _reduce_58(val, _values, result)
3917
3917
  lexer.cond.push true
3918
-
3918
+
3919
3919
  result
3920
3920
  end
3921
3921
 
3922
3922
  def _reduce_59(val, _values, result)
3923
3923
  lexer.cond.pop
3924
-
3924
+
3925
3925
  result
3926
3926
  end
3927
3927
 
3928
3928
  def _reduce_60(val, _values, result)
3929
3929
  _, expr, _, _ = val
3930
3930
  result = expr
3931
-
3931
+
3932
3932
  result
3933
3933
  end
3934
3934
 
@@ -3941,14 +3941,14 @@ end
3941
3941
  def _reduce_64(val, _values, result)
3942
3942
  blk, _, msg, args = val
3943
3943
  result = new_call(blk, msg.to_sym, args).line blk.line
3944
-
3944
+
3945
3945
  result
3946
3946
  end
3947
3947
 
3948
3948
  def _reduce_65(val, _values, result)
3949
3949
  # self.env.extend(:dynamic)
3950
3950
  result = self.lexer.lineno
3951
-
3951
+
3952
3952
  result
3953
3953
  end
3954
3954
 
@@ -3959,21 +3959,21 @@ def _reduce_66(val, _values, result)
3959
3959
  result.line = line
3960
3960
 
3961
3961
  # self.env.unextend
3962
-
3962
+
3963
3963
  result
3964
3964
  end
3965
3965
 
3966
3966
  def _reduce_67(val, _values, result)
3967
3967
  msg, = val
3968
3968
  result = new_call(nil, msg.to_sym).line lexer.lineno
3969
-
3969
+
3970
3970
  result
3971
3971
  end
3972
3972
 
3973
3973
  def _reduce_68(val, _values, result)
3974
3974
  call, args = val
3975
3975
  result = call.concat args.sexp_body
3976
-
3976
+
3977
3977
  result
3978
3978
  end
3979
3979
 
@@ -3988,14 +3988,14 @@ def _reduce_69(val, _values, result)
3988
3988
  result, operation = block, result
3989
3989
  result.insert 1, operation
3990
3990
  end
3991
-
3991
+
3992
3992
  result
3993
3993
  end
3994
3994
 
3995
3995
  def _reduce_70(val, _values, result)
3996
3996
  lhs, callop, op, args = val
3997
3997
  result = new_call lhs, op.to_sym, args, callop
3998
-
3998
+
3999
3999
  result
4000
4000
  end
4001
4001
 
@@ -4007,13 +4007,13 @@ def _reduce_71(val, _values, result)
4007
4007
 
4008
4008
  block.insert 1, call
4009
4009
  result = block
4010
-
4010
+
4011
4011
  result
4012
4012
  end
4013
4013
 
4014
4014
  def _reduce_72(val, _values, result)
4015
4015
  result = new_call val[0], val[2].to_sym, val[3]
4016
-
4016
+
4017
4017
  result
4018
4018
  end
4019
4019
 
@@ -4025,13 +4025,13 @@ def _reduce_73(val, _values, result)
4025
4025
 
4026
4026
  block.insert 1, call
4027
4027
  result = block
4028
-
4028
+
4029
4029
  result
4030
4030
  end
4031
4031
 
4032
4032
  def _reduce_74(val, _values, result)
4033
4033
  result = new_super val[1]
4034
-
4034
+
4035
4035
  result
4036
4036
  end
4037
4037
 
@@ -4039,28 +4039,28 @@ def _reduce_75(val, _values, result)
4039
4039
  (_, line), args = val
4040
4040
  result = new_yield args
4041
4041
  result.line line # TODO: push to new_yield
4042
-
4042
+
4043
4043
  result
4044
4044
  end
4045
4045
 
4046
4046
  def _reduce_76(val, _values, result)
4047
4047
  line = val[0].last
4048
4048
  result = s(:return, ret_args(val[1])).line(line)
4049
-
4049
+
4050
4050
  result
4051
4051
  end
4052
4052
 
4053
4053
  def _reduce_77(val, _values, result)
4054
4054
  (_, line), args = val
4055
4055
  result = s(:break, ret_args(args)).line line
4056
-
4056
+
4057
4057
  result
4058
4058
  end
4059
4059
 
4060
4060
  def _reduce_78(val, _values, result)
4061
4061
  line = val[0].last
4062
4062
  result = s(:next, ret_args(val[1])).line(line)
4063
-
4063
+
4064
4064
  result
4065
4065
  end
4066
4066
 
@@ -4068,7 +4068,7 @@ end
4068
4068
 
4069
4069
  def _reduce_80(val, _values, result)
4070
4070
  result = val[1]
4071
-
4071
+
4072
4072
  result
4073
4073
  end
4074
4074
 
@@ -4079,21 +4079,21 @@ def _reduce_82(val, _values, result)
4079
4079
  l = arg.line
4080
4080
 
4081
4081
  result = s(:masgn, s(:array, arg).line(l)).line l
4082
-
4082
+
4083
4083
  result
4084
4084
  end
4085
4085
 
4086
4086
  def _reduce_83(val, _values, result)
4087
4087
  head, = val
4088
4088
  result = s(:masgn, head).line head.line
4089
-
4089
+
4090
4090
  result
4091
4091
  end
4092
4092
 
4093
4093
  def _reduce_84(val, _values, result)
4094
4094
  lhs, rhs = val
4095
4095
  result = s(:masgn, lhs << rhs.compact).line lhs.line
4096
-
4096
+
4097
4097
  result
4098
4098
  end
4099
4099
 
@@ -4101,7 +4101,7 @@ def _reduce_85(val, _values, result)
4101
4101
  head, _, tail = val
4102
4102
  head << s(:splat, tail).line(tail.line)
4103
4103
  result = s(:masgn, head).line head.line
4104
-
4104
+
4105
4105
  result
4106
4106
  end
4107
4107
 
@@ -4111,7 +4111,7 @@ def _reduce_86(val, _values, result)
4111
4111
  result = list_append ary1, s(:splat, splat).line(splat.line)
4112
4112
  result.concat ary2.sexp_body
4113
4113
  result = s(:masgn, result).line result.line
4114
-
4114
+
4115
4115
  result
4116
4116
  end
4117
4117
 
@@ -4119,7 +4119,7 @@ def _reduce_87(val, _values, result)
4119
4119
  head, _ = val
4120
4120
  l = head.line
4121
4121
  result = s(:masgn, head << s(:splat).line(l)).line l
4122
-
4122
+
4123
4123
  result
4124
4124
  end
4125
4125
 
@@ -4128,7 +4128,7 @@ def _reduce_88(val, _values, result)
4128
4128
  ary = list_append head, s(:splat).line(head.line)
4129
4129
  ary.concat post.sexp_body
4130
4130
  result = s(:masgn, ary).line ary.line
4131
-
4131
+
4132
4132
  result
4133
4133
  end
4134
4134
 
@@ -4138,7 +4138,7 @@ def _reduce_89(val, _values, result)
4138
4138
  splat = s(:splat, node).line l
4139
4139
  ary = s(:array, splat).line l
4140
4140
  result = s(:masgn, ary).line l
4141
-
4141
+
4142
4142
  result
4143
4143
  end
4144
4144
 
@@ -4149,14 +4149,14 @@ def _reduce_90(val, _values, result)
4149
4149
  ary = s(:array, splat).line splat.line
4150
4150
  ary.concat post.sexp_body
4151
4151
  result = s(:masgn, ary).line ary.line
4152
-
4152
+
4153
4153
  result
4154
4154
  end
4155
4155
 
4156
4156
  def _reduce_91(val, _values, result)
4157
4157
  l = lexer.lineno
4158
4158
  result = s(:masgn, s(:array, s(:splat).line(l)).line(l)).line l
4159
-
4159
+
4160
4160
  result
4161
4161
  end
4162
4162
 
@@ -4167,7 +4167,7 @@ def _reduce_92(val, _values, result)
4167
4167
  splat = s(:splat).line l
4168
4168
  ary = s(:array, splat, *post.sexp_body).line l
4169
4169
  result = s(:masgn, ary).line l
4170
-
4170
+
4171
4171
  result
4172
4172
  end
4173
4173
 
@@ -4175,70 +4175,70 @@ end
4175
4175
 
4176
4176
  def _reduce_94(val, _values, result)
4177
4177
  result = val[1]
4178
-
4178
+
4179
4179
  result
4180
4180
  end
4181
4181
 
4182
4182
  def _reduce_95(val, _values, result)
4183
4183
  lhs, _ = val
4184
4184
  result = s(:array, lhs).line lhs.line
4185
-
4185
+
4186
4186
  result
4187
4187
  end
4188
4188
 
4189
4189
  def _reduce_96(val, _values, result)
4190
4190
  result = val[0] << val[1].compact
4191
-
4191
+
4192
4192
  result
4193
4193
  end
4194
4194
 
4195
4195
  def _reduce_97(val, _values, result)
4196
4196
  item, = val
4197
4197
  result = s(:array, item).line item.line
4198
-
4198
+
4199
4199
  result
4200
4200
  end
4201
4201
 
4202
4202
  def _reduce_98(val, _values, result)
4203
4203
  result = list_append val[0], val[2]
4204
-
4204
+
4205
4205
  result
4206
4206
  end
4207
4207
 
4208
4208
  def _reduce_99(val, _values, result)
4209
4209
  result = self.assignable val[0]
4210
-
4210
+
4211
4211
  result
4212
4212
  end
4213
4213
 
4214
4214
  def _reduce_100(val, _values, result)
4215
4215
  result = self.assignable val[0]
4216
-
4216
+
4217
4217
  result
4218
4218
  end
4219
4219
 
4220
4220
  def _reduce_101(val, _values, result)
4221
4221
  result = self.aryset val[0], val[2]
4222
-
4222
+
4223
4223
  result
4224
4224
  end
4225
4225
 
4226
4226
  def _reduce_102(val, _values, result)
4227
4227
  result = new_attrasgn val[0], val[2], val[1]
4228
-
4228
+
4229
4229
  result
4230
4230
  end
4231
4231
 
4232
4232
  def _reduce_103(val, _values, result)
4233
4233
  recv, _, id = val
4234
4234
  result = new_attrasgn recv, id
4235
-
4235
+
4236
4236
  result
4237
4237
  end
4238
4238
 
4239
4239
  def _reduce_104(val, _values, result)
4240
4240
  result = new_attrasgn val[0], val[2], val[1]
4241
-
4241
+
4242
4242
  result
4243
4243
  end
4244
4244
 
@@ -4252,7 +4252,7 @@ def _reduce_105(val, _values, result)
4252
4252
  l = expr.line
4253
4253
 
4254
4254
  result = s(:const, s(:colon2, expr, id.to_sym).line(l), nil).line l
4255
-
4255
+
4256
4256
  result
4257
4257
  end
4258
4258
 
@@ -4266,13 +4266,13 @@ def _reduce_106(val, _values, result)
4266
4266
  l = lexer.lineno
4267
4267
 
4268
4268
  result = s(:const, nil, s(:colon3, id.to_sym).line(l)).line l
4269
-
4269
+
4270
4270
  result
4271
4271
  end
4272
4272
 
4273
4273
  def _reduce_107(val, _values, result)
4274
4274
  self.backref_assign_error val[0]
4275
-
4275
+
4276
4276
  result
4277
4277
  end
4278
4278
 
@@ -4280,7 +4280,7 @@ def _reduce_108(val, _values, result)
4280
4280
  line = lexer.lineno
4281
4281
  result = self.assignable val[0]
4282
4282
  result.line = line
4283
-
4283
+
4284
4284
  result
4285
4285
  end
4286
4286
 
@@ -4289,34 +4289,34 @@ def _reduce_109(val, _values, result)
4289
4289
  result = self.assignable val[0]
4290
4290
  result.line = line
4291
4291
  debug20 9, val, result
4292
-
4292
+
4293
4293
  result
4294
4294
  end
4295
4295
 
4296
4296
  def _reduce_110(val, _values, result)
4297
4297
  lhs, _, args, _ = val
4298
4298
  result = self.aryset lhs, args
4299
-
4299
+
4300
4300
  result
4301
4301
  end
4302
4302
 
4303
4303
  def _reduce_111(val, _values, result)
4304
4304
  lhs, op, id = val
4305
4305
  result = new_attrasgn lhs, id, op
4306
-
4306
+
4307
4307
  result
4308
4308
  end
4309
4309
 
4310
4310
  def _reduce_112(val, _values, result)
4311
4311
  lhs, _, id = val
4312
4312
  result = new_attrasgn lhs, id
4313
-
4313
+
4314
4314
  result
4315
4315
  end
4316
4316
 
4317
4317
  def _reduce_113(val, _values, result)
4318
4318
  result = new_attrasgn val[0], val[2], val[1]
4319
-
4319
+
4320
4320
  result
4321
4321
  end
4322
4322
 
@@ -4330,7 +4330,7 @@ def _reduce_114(val, _values, result)
4330
4330
 
4331
4331
  l = expr.line
4332
4332
  result = s(:const, s(:colon2, expr, id.to_sym).line(l)).line l
4333
-
4333
+
4334
4334
  result
4335
4335
  end
4336
4336
 
@@ -4344,19 +4344,19 @@ def _reduce_115(val, _values, result)
4344
4344
 
4345
4345
  l = lexer.lineno
4346
4346
  result = s(:const, s(:colon3, id.to_sym).line(l)).line l
4347
-
4347
+
4348
4348
  result
4349
4349
  end
4350
4350
 
4351
4351
  def _reduce_116(val, _values, result)
4352
4352
  self.backref_assign_error val[0]
4353
-
4353
+
4354
4354
  result
4355
4355
  end
4356
4356
 
4357
4357
  def _reduce_117(val, _values, result)
4358
4358
  yyerror "class/module name must be CONSTANT"
4359
-
4359
+
4360
4360
  result
4361
4361
  end
4362
4362
 
@@ -4365,13 +4365,13 @@ end
4365
4365
  def _reduce_119(val, _values, result)
4366
4366
  _, name = val
4367
4367
  result = s(:colon3, name.to_sym).line lexer.lineno
4368
-
4368
+
4369
4369
  result
4370
4370
  end
4371
4371
 
4372
4372
  def _reduce_120(val, _values, result)
4373
4373
  result = val[0].to_sym
4374
-
4374
+
4375
4375
  result
4376
4376
  end
4377
4377
 
@@ -4380,7 +4380,7 @@ def _reduce_121(val, _values, result)
4380
4380
 
4381
4381
  result = s(:colon2, pval, name.to_sym)
4382
4382
  result.line pval.line
4383
-
4383
+
4384
4384
  result
4385
4385
  end
4386
4386
 
@@ -4393,7 +4393,7 @@ end
4393
4393
  def _reduce_125(val, _values, result)
4394
4394
  lexer.lex_state = EXPR_END
4395
4395
  result = val[0]
4396
-
4396
+
4397
4397
  result
4398
4398
  end
4399
4399
 
@@ -4401,7 +4401,7 @@ def _reduce_126(val, _values, result)
4401
4401
  (sym, _line), = val
4402
4402
  lexer.lex_state = EXPR_END
4403
4403
  result = sym
4404
-
4404
+
4405
4405
  result
4406
4406
  end
4407
4407
 
@@ -4412,7 +4412,7 @@ end
4412
4412
  def _reduce_129(val, _values, result)
4413
4413
  id, = val
4414
4414
  result = s(:lit, id.to_sym).line lexer.lineno
4415
-
4415
+
4416
4416
  result
4417
4417
  end
4418
4418
 
@@ -4420,19 +4420,19 @@ end
4420
4420
 
4421
4421
  def _reduce_131(val, _values, result)
4422
4422
  result = new_undef val[0]
4423
-
4423
+
4424
4424
  result
4425
4425
  end
4426
4426
 
4427
4427
  def _reduce_132(val, _values, result)
4428
4428
  lexer.lex_state = EXPR_FNAME
4429
-
4429
+
4430
4430
  result
4431
4431
  end
4432
4432
 
4433
4433
  def _reduce_133(val, _values, result)
4434
4434
  result = new_undef val[0], val[3]
4435
-
4435
+
4436
4436
  result
4437
4437
  end
4438
4438
 
@@ -4582,31 +4582,31 @@ end
4582
4582
 
4583
4583
  def _reduce_206(val, _values, result)
4584
4584
  result = new_assign val[0], val[2]
4585
-
4585
+
4586
4586
  result
4587
4587
  end
4588
4588
 
4589
4589
  def _reduce_207(val, _values, result)
4590
4590
  result = new_op_asgn val
4591
-
4591
+
4592
4592
  result
4593
4593
  end
4594
4594
 
4595
4595
  def _reduce_208(val, _values, result)
4596
4596
  result = new_op_asgn1 val
4597
-
4597
+
4598
4598
  result
4599
4599
  end
4600
4600
 
4601
4601
  def _reduce_209(val, _values, result)
4602
4602
  result = new_op_asgn2 val
4603
-
4603
+
4604
4604
  result
4605
4605
  end
4606
4606
 
4607
4607
  def _reduce_210(val, _values, result)
4608
4608
  result = new_op_asgn2 val
4609
-
4609
+
4610
4610
  result
4611
4611
  end
4612
4612
 
@@ -4614,7 +4614,7 @@ def _reduce_211(val, _values, result)
4614
4614
  lhs, _, id, op, rhs = val
4615
4615
 
4616
4616
  result = s(:op_asgn, lhs, rhs, id.to_sym, op.to_sym).line lhs.line
4617
-
4617
+
4618
4618
  result
4619
4619
  end
4620
4620
 
@@ -4623,13 +4623,13 @@ def _reduce_212(val, _values, result)
4623
4623
 
4624
4624
  lhs = s(:colon2, lhs1, lhs2.to_sym).line lhs1.line
4625
4625
  result = new_const_op_asgn [lhs, op, rhs]
4626
-
4626
+
4627
4627
  result
4628
4628
  end
4629
4629
 
4630
4630
  def _reduce_213(val, _values, result)
4631
4631
  result = self.lexer.lineno
4632
-
4632
+
4633
4633
  result
4634
4634
  end
4635
4635
 
@@ -4638,7 +4638,7 @@ def _reduce_214(val, _values, result)
4638
4638
 
4639
4639
  lhs = s(:colon3, lhs.to_sym).line line
4640
4640
  result = new_const_op_asgn [lhs, op, rhs]
4641
-
4641
+
4642
4642
  result
4643
4643
  end
4644
4644
 
@@ -4646,7 +4646,7 @@ def _reduce_215(val, _values, result)
4646
4646
  # TODO: lhs = var_field val[0]
4647
4647
  asgn = new_op_asgn val
4648
4648
  result = self.backref_assign_error asgn
4649
-
4649
+
4650
4650
  result
4651
4651
  end
4652
4652
 
@@ -4657,7 +4657,7 @@ def _reduce_216(val, _values, result)
4657
4657
  else
4658
4658
  result = s(:dot2, v1, v2).line v1.line
4659
4659
  end
4660
-
4660
+
4661
4661
  result
4662
4662
  end
4663
4663
 
@@ -4668,43 +4668,43 @@ def _reduce_217(val, _values, result)
4668
4668
  else
4669
4669
  result = s(:dot3, v1, v2).line v1.line
4670
4670
  end
4671
-
4671
+
4672
4672
  result
4673
4673
  end
4674
4674
 
4675
4675
  def _reduce_218(val, _values, result)
4676
4676
  result = new_call val[0], :+, argl(val[2])
4677
-
4677
+
4678
4678
  result
4679
4679
  end
4680
4680
 
4681
4681
  def _reduce_219(val, _values, result)
4682
4682
  result = new_call val[0], :-, argl(val[2])
4683
-
4683
+
4684
4684
  result
4685
4685
  end
4686
4686
 
4687
4687
  def _reduce_220(val, _values, result)
4688
4688
  result = new_call val[0], :*, argl(val[2])
4689
-
4689
+
4690
4690
  result
4691
4691
  end
4692
4692
 
4693
4693
  def _reduce_221(val, _values, result)
4694
4694
  result = new_call val[0], :"/", argl(val[2])
4695
-
4695
+
4696
4696
  result
4697
4697
  end
4698
4698
 
4699
4699
  def _reduce_222(val, _values, result)
4700
4700
  result = new_call val[0], :"%", argl(val[2])
4701
-
4701
+
4702
4702
  result
4703
4703
  end
4704
4704
 
4705
4705
  def _reduce_223(val, _values, result)
4706
4706
  result = new_call val[0], :**, argl(val[2])
4707
-
4707
+
4708
4708
  result
4709
4709
  end
4710
4710
 
@@ -4712,43 +4712,43 @@ def _reduce_224(val, _values, result)
4712
4712
  lit = s(:lit, val[1]).line lexer.lineno
4713
4713
  result = new_call(new_call(lit, :"**", argl(val[3])), :"-@")
4714
4714
 
4715
-
4715
+
4716
4716
  result
4717
4717
  end
4718
4718
 
4719
4719
  def _reduce_225(val, _values, result)
4720
4720
  result = new_call val[1], :"+@"
4721
-
4721
+
4722
4722
  result
4723
4723
  end
4724
4724
 
4725
4725
  def _reduce_226(val, _values, result)
4726
4726
  result = new_call val[1], :"-@"
4727
-
4727
+
4728
4728
  result
4729
4729
  end
4730
4730
 
4731
4731
  def _reduce_227(val, _values, result)
4732
4732
  result = new_call val[0], :"|", argl(val[2])
4733
-
4733
+
4734
4734
  result
4735
4735
  end
4736
4736
 
4737
4737
  def _reduce_228(val, _values, result)
4738
4738
  result = new_call val[0], :"^", argl(val[2])
4739
-
4739
+
4740
4740
  result
4741
4741
  end
4742
4742
 
4743
4743
  def _reduce_229(val, _values, result)
4744
4744
  result = new_call val[0], :"&", argl(val[2])
4745
-
4745
+
4746
4746
  result
4747
4747
  end
4748
4748
 
4749
4749
  def _reduce_230(val, _values, result)
4750
4750
  result = new_call val[0], :"<=>", argl(val[2])
4751
-
4751
+
4752
4752
  result
4753
4753
  end
4754
4754
 
@@ -4756,33 +4756,33 @@ end
4756
4756
 
4757
4757
  def _reduce_232(val, _values, result)
4758
4758
  result = new_call val[0], :"==", argl(val[2])
4759
-
4759
+
4760
4760
  result
4761
4761
  end
4762
4762
 
4763
4763
  def _reduce_233(val, _values, result)
4764
4764
  result = new_call val[0], :"===", argl(val[2])
4765
-
4765
+
4766
4766
  result
4767
4767
  end
4768
4768
 
4769
4769
  def _reduce_234(val, _values, result)
4770
4770
  result = new_call val[0], :"!=", argl(val[2])
4771
-
4771
+
4772
4772
  result
4773
4773
  end
4774
4774
 
4775
4775
  def _reduce_235(val, _values, result)
4776
4776
  lhs, _, rhs = val
4777
4777
  result = new_match lhs, rhs
4778
-
4778
+
4779
4779
  result
4780
4780
  end
4781
4781
 
4782
4782
  def _reduce_236(val, _values, result)
4783
4783
  lhs, _, rhs = val
4784
4784
  result = s(:not, new_match(lhs, rhs)).line lhs.line
4785
-
4785
+
4786
4786
  result
4787
4787
  end
4788
4788
 
@@ -4790,13 +4790,13 @@ def _reduce_237(val, _values, result)
4790
4790
  _, arg = val
4791
4791
  result = new_call arg, :"!"
4792
4792
  result.line arg.line
4793
-
4793
+
4794
4794
  result
4795
4795
  end
4796
4796
 
4797
4797
  def _reduce_238(val, _values, result)
4798
4798
  result = new_call value_expr(val[1]), :"~"
4799
-
4799
+
4800
4800
  result
4801
4801
  end
4802
4802
 
@@ -4804,7 +4804,7 @@ def _reduce_239(val, _values, result)
4804
4804
  val[0] = value_expr val[0]
4805
4805
  val[2] = value_expr val[2]
4806
4806
  result = new_call val[0], :"\<\<", argl(val[2])
4807
-
4807
+
4808
4808
  result
4809
4809
  end
4810
4810
 
@@ -4812,33 +4812,33 @@ def _reduce_240(val, _values, result)
4812
4812
  val[0] = value_expr val[0]
4813
4813
  val[2] = value_expr val[2]
4814
4814
  result = new_call val[0], :">>", argl(val[2])
4815
-
4815
+
4816
4816
  result
4817
4817
  end
4818
4818
 
4819
4819
  def _reduce_241(val, _values, result)
4820
4820
  result = logical_op :and, val[0], val[2]
4821
-
4821
+
4822
4822
  result
4823
4823
  end
4824
4824
 
4825
4825
  def _reduce_242(val, _values, result)
4826
4826
  result = logical_op :or, val[0], val[2]
4827
-
4827
+
4828
4828
  result
4829
4829
  end
4830
4830
 
4831
4831
  def _reduce_243(val, _values, result)
4832
4832
  (_, line), _, arg = val
4833
4833
  result = s(:defined, arg).line line
4834
-
4834
+
4835
4835
  result
4836
4836
  end
4837
4837
 
4838
4838
  def _reduce_244(val, _values, result)
4839
4839
  c, _, t, _, _, f = val
4840
4840
  result = s(:if, c, t, f).line c.line
4841
-
4841
+
4842
4842
  result
4843
4843
  end
4844
4844
 
@@ -4855,7 +4855,7 @@ end
4855
4855
  def _reduce_250(val, _values, result)
4856
4856
  lhs, op, rhs = val
4857
4857
  result = new_call lhs, op.to_sym, argl(rhs)
4858
-
4858
+
4859
4859
  result
4860
4860
  end
4861
4861
 
@@ -4863,13 +4863,13 @@ def _reduce_251(val, _values, result)
4863
4863
  lhs, op, rhs = val
4864
4864
  warn "comparison '%s' after comparison", op
4865
4865
  result = new_call lhs, op.to_sym, argl(rhs)
4866
-
4866
+
4867
4867
  result
4868
4868
  end
4869
4869
 
4870
4870
  def _reduce_252(val, _values, result)
4871
4871
  result = value_expr(val[0])
4872
-
4872
+
4873
4873
  result
4874
4874
  end
4875
4875
 
@@ -4877,19 +4877,19 @@ end
4877
4877
 
4878
4878
  def _reduce_254(val, _values, result)
4879
4879
  result = args [val[0]]
4880
-
4880
+
4881
4881
  result
4882
4882
  end
4883
4883
 
4884
4884
  def _reduce_255(val, _values, result)
4885
4885
  result = args [val[0], array_to_hash(val[2])]
4886
-
4886
+
4887
4887
  result
4888
4888
  end
4889
4889
 
4890
4890
  def _reduce_256(val, _values, result)
4891
4891
  result = args [array_to_hash(val[0])]
4892
-
4892
+
4893
4893
  result
4894
4894
  end
4895
4895
 
@@ -4902,14 +4902,14 @@ def _reduce_258(val, _values, result)
4902
4902
 
4903
4903
  ary = s(:array).line line
4904
4904
  result = new_rescue(body, new_resbody(ary, resbody))
4905
-
4905
+
4906
4906
  result
4907
4907
  end
4908
4908
 
4909
4909
  def _reduce_259(val, _values, result)
4910
4910
  _, args, _ = val
4911
4911
  result = args
4912
-
4912
+
4913
4913
  result
4914
4914
  end
4915
4915
 
@@ -4923,79 +4923,76 @@ end
4923
4923
 
4924
4924
  def _reduce_264(val, _values, result)
4925
4925
  result = args val
4926
-
4926
+
4927
4927
  result
4928
4928
  end
4929
4929
 
4930
4930
  def _reduce_265(val, _values, result)
4931
4931
  result = args [val[0], array_to_hash(val[2])]
4932
-
4932
+
4933
4933
  result
4934
4934
  end
4935
4935
 
4936
4936
  def _reduce_266(val, _values, result)
4937
4937
  result = args [array_to_hash(val[0])]
4938
-
4938
+
4939
4939
  result
4940
4940
  end
4941
4941
 
4942
4942
  def _reduce_267(val, _values, result)
4943
4943
  warning "parenthesize argument(s) for future version"
4944
4944
  result = call_args val
4945
-
4945
+
4946
4946
  result
4947
4947
  end
4948
4948
 
4949
4949
  def _reduce_268(val, _values, result)
4950
4950
  result = call_args val
4951
- result = self.arg_blk_pass val[0], val[1]
4952
-
4951
+
4953
4952
  result
4954
4953
  end
4955
4954
 
4956
4955
  def _reduce_269(val, _values, result)
4957
- result = call_args [array_to_hash(val[0])]
4958
- result = self.arg_blk_pass result, val[1]
4959
-
4956
+ result = call_args [array_to_hash(val[0]), val[1]]
4957
+
4960
4958
  result
4961
4959
  end
4962
4960
 
4963
4961
  def _reduce_270(val, _values, result)
4964
- result = call_args [val[0], array_to_hash(val[2])]
4965
- result = self.arg_blk_pass result, val[3]
4966
-
4962
+ result = call_args [val[0], array_to_hash(val[2]), val[3]]
4963
+
4967
4964
  result
4968
4965
  end
4969
4966
 
4970
4967
  def _reduce_271(val, _values, result)
4971
4968
  result = call_args val
4972
-
4969
+
4973
4970
  result
4974
4971
  end
4975
4972
 
4976
4973
  def _reduce_272(val, _values, result)
4977
4974
  result = lexer.cmdarg.store true
4978
-
4975
+
4979
4976
  result
4980
4977
  end
4981
4978
 
4982
4979
  def _reduce_273(val, _values, result)
4983
4980
  lexer.cmdarg.restore val[0]
4984
4981
  result = val[1]
4985
-
4982
+
4986
4983
  result
4987
4984
  end
4988
4985
 
4989
4986
  def _reduce_274(val, _values, result)
4990
4987
  _, arg = val
4991
4988
  result = s(:block_pass, arg).line arg.line
4992
-
4989
+
4993
4990
  result
4994
4991
  end
4995
4992
 
4996
4993
  def _reduce_275(val, _values, result)
4997
4994
  result = val[1]
4998
-
4995
+
4999
4996
  result
5000
4997
  end
5001
4998
 
@@ -5005,51 +5002,51 @@ def _reduce_277(val, _values, result)
5005
5002
  arg, = val
5006
5003
 
5007
5004
  result = s(:array, arg).line arg.line
5008
-
5005
+
5009
5006
  result
5010
5007
  end
5011
5008
 
5012
5009
  def _reduce_278(val, _values, result)
5013
5010
  _, arg = val
5014
5011
  result = s(:array, s(:splat, arg).line(arg.line)).line arg.line
5015
-
5012
+
5016
5013
  result
5017
5014
  end
5018
5015
 
5019
5016
  def _reduce_279(val, _values, result)
5020
5017
  args, _, id = val
5021
5018
  result = self.list_append args, id
5022
-
5019
+
5023
5020
  result
5024
5021
  end
5025
5022
 
5026
5023
  def _reduce_280(val, _values, result)
5027
- result = lexer.lineno
5024
+ result = lexer.lineno
5028
5025
  result
5029
5026
  end
5030
5027
 
5031
5028
  def _reduce_281(val, _values, result)
5032
5029
  args, _, _, line, id = val
5033
5030
  result = self.list_append args, s(:splat, id).line(line)
5034
-
5031
+
5035
5032
  result
5036
5033
  end
5037
5034
 
5038
5035
  def _reduce_282(val, _values, result)
5039
5036
  result = new_masgn_arg val[0]
5040
-
5037
+
5041
5038
  result
5042
5039
  end
5043
5040
 
5044
5041
  def _reduce_283(val, _values, result)
5045
5042
  result = new_masgn_arg val[0], :wrap
5046
-
5043
+
5047
5044
  result
5048
5045
  end
5049
5046
 
5050
5047
  def _reduce_284(val, _values, result)
5051
5048
  result = val[0] << val[2]
5052
-
5049
+
5053
5050
  result
5054
5051
  end
5055
5052
 
@@ -5058,14 +5055,14 @@ def _reduce_285(val, _values, result)
5058
5055
  # TODO: make all tXXXX terminals include lexer.lineno
5059
5056
  arg, _, _, splat = val
5060
5057
  result = self.arg_concat arg, splat
5061
-
5058
+
5062
5059
  result
5063
5060
  end
5064
5061
 
5065
5062
  def _reduce_286(val, _values, result)
5066
5063
  _, arg = val
5067
5064
  result = s(:splat, arg).line arg.line
5068
-
5065
+
5069
5066
  result
5070
5067
  end
5071
5068
 
@@ -5092,7 +5089,7 @@ end
5092
5089
  def _reduce_297(val, _values, result)
5093
5090
  msg, = val
5094
5091
  result = new_call nil, msg.to_sym
5095
-
5092
+
5096
5093
  result
5097
5094
  end
5098
5095
 
@@ -5101,7 +5098,7 @@ def _reduce_298(val, _values, result)
5101
5098
  # TODO:
5102
5099
  # $<val>1 = cmdarg_stack;
5103
5100
  # CMDARG_SET(0);
5104
-
5101
+
5105
5102
  result
5106
5103
  end
5107
5104
 
@@ -5114,33 +5111,33 @@ def _reduce_299(val, _values, result)
5114
5111
  end
5115
5112
 
5116
5113
  result.line = val[1]
5117
-
5114
+
5118
5115
  result
5119
5116
  end
5120
5117
 
5121
5118
  def _reduce_300(val, _values, result)
5122
5119
  lexer.lex_state = EXPR_ENDARG
5123
5120
  result = lexer.lineno
5124
-
5121
+
5125
5122
  result
5126
5123
  end
5127
5124
 
5128
5125
  def _reduce_301(val, _values, result)
5129
5126
  _, line, _ = val
5130
5127
  result = s(:begin).line line
5131
-
5128
+
5132
5129
  result
5133
5130
  end
5134
5131
 
5135
5132
  def _reduce_302(val, _values, result)
5136
5133
  result = lexer.cmdarg.store false
5137
-
5134
+
5138
5135
  result
5139
5136
  end
5140
5137
 
5141
5138
  def _reduce_303(val, _values, result)
5142
5139
  lexer.lex_state = EXPR_ENDARG
5143
-
5140
+
5144
5141
  result
5145
5142
  end
5146
5143
 
@@ -5149,7 +5146,7 @@ def _reduce_304(val, _values, result)
5149
5146
  warning "(...) interpreted as grouped expression"
5150
5147
  lexer.cmdarg.restore cmdarg
5151
5148
  result = stmt
5152
-
5149
+
5153
5150
  result
5154
5151
  end
5155
5152
 
@@ -5158,7 +5155,7 @@ def _reduce_305(val, _values, result)
5158
5155
  result = stmt
5159
5156
  result ||= s(:nil).line lexer.lineno
5160
5157
  result.paren = true
5161
-
5158
+
5162
5159
  result
5163
5160
  end
5164
5161
 
@@ -5166,7 +5163,7 @@ def _reduce_306(val, _values, result)
5166
5163
  expr, _, id = val
5167
5164
 
5168
5165
  result = s(:colon2, expr, id.to_sym).line expr.line
5169
-
5166
+
5170
5167
  result
5171
5168
  end
5172
5169
 
@@ -5174,12 +5171,12 @@ def _reduce_307(val, _values, result)
5174
5171
  _, id = val
5175
5172
 
5176
5173
  result = s(:colon3, id.to_sym).line lexer.lineno
5177
-
5174
+
5178
5175
  result
5179
5176
  end
5180
5177
 
5181
5178
  def _reduce_308(val, _values, result)
5182
- result = lexer.lineno
5179
+ result = lexer.lineno
5183
5180
  result
5184
5181
  end
5185
5182
 
@@ -5188,44 +5185,44 @@ def _reduce_309(val, _values, result)
5188
5185
  result = args || s(:array)
5189
5186
  result.sexp_type = :array # aref_args is :args
5190
5187
  result.line line
5191
-
5188
+
5192
5189
  result
5193
5190
  end
5194
5191
 
5195
5192
  def _reduce_310(val, _values, result)
5196
5193
  result = self.lexer.lineno
5197
-
5194
+
5198
5195
  result
5199
5196
  end
5200
5197
 
5201
5198
  def _reduce_311(val, _values, result)
5202
5199
  result = new_hash val
5203
-
5200
+
5204
5201
  result
5205
5202
  end
5206
5203
 
5207
5204
  def _reduce_312(val, _values, result)
5208
5205
  (_, line), = val
5209
5206
  result = s(:return).line line
5210
-
5207
+
5211
5208
  result
5212
5209
  end
5213
5210
 
5214
5211
  def _reduce_313(val, _values, result)
5215
5212
  result = new_yield val[2]
5216
-
5213
+
5217
5214
  result
5218
5215
  end
5219
5216
 
5220
5217
  def _reduce_314(val, _values, result)
5221
5218
  result = new_yield
5222
-
5219
+
5223
5220
  result
5224
5221
  end
5225
5222
 
5226
5223
  def _reduce_315(val, _values, result)
5227
5224
  result = new_yield
5228
-
5225
+
5229
5226
  result
5230
5227
  end
5231
5228
 
@@ -5233,20 +5230,20 @@ def _reduce_316(val, _values, result)
5233
5230
  (_, line), _, _, arg, _ = val
5234
5231
 
5235
5232
  result = s(:defined, arg).line line
5236
-
5233
+
5237
5234
  result
5238
5235
  end
5239
5236
 
5240
5237
  def _reduce_317(val, _values, result)
5241
5238
  _, _, lhs, _ = val
5242
5239
  result = new_call lhs, :"!"
5243
-
5240
+
5244
5241
  result
5245
5242
  end
5246
5243
 
5247
5244
  def _reduce_318(val, _values, result)
5248
5245
  debug20 14, val, result
5249
-
5246
+
5250
5247
  result
5251
5248
  end
5252
5249
 
@@ -5256,7 +5253,7 @@ def _reduce_319(val, _values, result)
5256
5253
  iter.insert 1, call
5257
5254
  result = iter
5258
5255
  # FIX: probably not: call.line = iter.line
5259
-
5256
+
5260
5257
  result
5261
5258
  end
5262
5259
 
@@ -5267,68 +5264,68 @@ def _reduce_321(val, _values, result)
5267
5264
  block_dup_check call, iter
5268
5265
  iter.insert 1, call # FIX
5269
5266
  result = iter
5270
-
5267
+
5271
5268
  result
5272
5269
  end
5273
5270
 
5274
5271
  def _reduce_322(val, _values, result)
5275
5272
  result = val[1] # TODO: fix lineno
5276
-
5273
+
5277
5274
  result
5278
5275
  end
5279
5276
 
5280
5277
  def _reduce_323(val, _values, result)
5281
5278
  _, c, _, t, f, _ = val
5282
5279
  result = new_if c, t, f
5283
-
5280
+
5284
5281
  result
5285
5282
  end
5286
5283
 
5287
5284
  def _reduce_324(val, _values, result)
5288
5285
  _, c, _, t, f, _ = val
5289
5286
  result = new_if c, f, t
5290
-
5287
+
5291
5288
  result
5292
5289
  end
5293
5290
 
5294
5291
  def _reduce_325(val, _values, result)
5295
5292
  _, cond, body, _ = val
5296
5293
  result = new_while body, cond, true
5297
-
5294
+
5298
5295
  result
5299
5296
  end
5300
5297
 
5301
5298
  def _reduce_326(val, _values, result)
5302
5299
  _, cond, body, _ = val
5303
5300
  result = new_until body, cond, true
5304
-
5301
+
5305
5302
  result
5306
5303
  end
5307
5304
 
5308
5305
  def _reduce_327(val, _values, result)
5309
5306
  (_, line), expr, _, body, _ = val
5310
5307
  result = new_case expr, body, line
5311
-
5308
+
5312
5309
  result
5313
5310
  end
5314
5311
 
5315
5312
  def _reduce_328(val, _values, result)
5316
5313
  (_, line), _, body, _ = val
5317
5314
  result = new_case nil, body, line
5318
-
5315
+
5319
5316
  result
5320
5317
  end
5321
5318
 
5322
5319
  def _reduce_329(val, _values, result)
5323
5320
  _, var, _, iter, body, _ = val
5324
5321
  result = new_for iter, var, body
5325
-
5322
+
5326
5323
  result
5327
5324
  end
5328
5325
 
5329
5326
  def _reduce_330(val, _values, result)
5330
5327
  result = self.lexer.lineno
5331
-
5328
+
5332
5329
  result
5333
5330
  end
5334
5331
 
@@ -5338,7 +5335,7 @@ def _reduce_331(val, _values, result)
5338
5335
  yyerror "class definition in method body"
5339
5336
  end
5340
5337
  self.env.extend
5341
-
5338
+
5342
5339
  result
5343
5340
  end
5344
5341
 
@@ -5346,20 +5343,20 @@ def _reduce_332(val, _values, result)
5346
5343
  result = new_class val
5347
5344
  self.env.unextend
5348
5345
  self.lexer.comments # we don't care about comments in the body
5349
-
5346
+
5350
5347
  result
5351
5348
  end
5352
5349
 
5353
5350
  def _reduce_333(val, _values, result)
5354
5351
  result = self.lexer.lineno
5355
-
5352
+
5356
5353
  result
5357
5354
  end
5358
5355
 
5359
5356
  def _reduce_334(val, _values, result)
5360
5357
  result = self.in_def
5361
5358
  self.in_def = false
5362
-
5359
+
5363
5360
  result
5364
5361
  end
5365
5362
 
@@ -5367,7 +5364,7 @@ def _reduce_335(val, _values, result)
5367
5364
  result = self.in_single
5368
5365
  self.in_single = 0
5369
5366
  self.env.extend
5370
-
5367
+
5371
5368
  result
5372
5369
  end
5373
5370
 
@@ -5375,13 +5372,13 @@ def _reduce_336(val, _values, result)
5375
5372
  result = new_sclass val
5376
5373
  self.env.unextend
5377
5374
  self.lexer.comments # we don't care about comments in the body
5378
-
5375
+
5379
5376
  result
5380
5377
  end
5381
5378
 
5382
5379
  def _reduce_337(val, _values, result)
5383
5380
  result = self.lexer.lineno
5384
-
5381
+
5385
5382
  result
5386
5383
  end
5387
5384
 
@@ -5391,7 +5388,7 @@ def _reduce_338(val, _values, result)
5391
5388
  self.in_def or self.in_single > 0
5392
5389
 
5393
5390
  self.env.extend
5394
-
5391
+
5395
5392
  result
5396
5393
  end
5397
5394
 
@@ -5399,7 +5396,7 @@ def _reduce_339(val, _values, result)
5399
5396
  result = new_module val
5400
5397
  self.env.unextend
5401
5398
  self.lexer.comments # we don't care about comments in the body
5402
-
5399
+
5403
5400
  result
5404
5401
  end
5405
5402
 
@@ -5412,12 +5409,12 @@ def _reduce_340(val, _values, result)
5412
5409
  # TODO: local->cmdargs = cmdarg_stack;
5413
5410
  # TODO: port local_push_gen and local_pop_gen
5414
5411
  lexer.cmdarg.stack.replace [false]
5415
-
5412
+
5416
5413
  result
5417
5414
  end
5418
5415
 
5419
5416
  def _reduce_341(val, _values, result)
5420
- result = lexer.lineno
5417
+ result = lexer.lineno
5421
5418
  result
5422
5419
  end
5423
5420
 
@@ -5430,14 +5427,14 @@ def _reduce_342(val, _values, result)
5430
5427
  self.env.unextend
5431
5428
  self.in_def = in_def
5432
5429
  self.lexer.comments # we don't care about comments in the body
5433
-
5430
+
5434
5431
  result
5435
5432
  end
5436
5433
 
5437
5434
  def _reduce_343(val, _values, result)
5438
5435
  self.comments.push self.lexer.comments
5439
5436
  lexer.lex_state = EXPR_FNAME
5440
-
5437
+
5441
5438
  result
5442
5439
  end
5443
5440
 
@@ -5447,7 +5444,7 @@ def _reduce_344(val, _values, result)
5447
5444
  lexer.lex_state = EXPR_ENDFN # force for args
5448
5445
  result = [lexer.lineno, self.lexer.cmdarg.stack.dup]
5449
5446
  lexer.cmdarg.stack.replace [false]
5450
-
5447
+
5451
5448
  result
5452
5449
  end
5453
5450
 
@@ -5460,41 +5457,41 @@ def _reduce_345(val, _values, result)
5460
5457
  self.env.unextend
5461
5458
  self.in_single -= 1
5462
5459
  self.lexer.comments # we don't care about comments in the body
5463
-
5460
+
5464
5461
  result
5465
5462
  end
5466
5463
 
5467
5464
  def _reduce_346(val, _values, result)
5468
5465
  (_, line), = val
5469
5466
  result = s(:break).line line
5470
-
5467
+
5471
5468
  result
5472
5469
  end
5473
5470
 
5474
5471
  def _reduce_347(val, _values, result)
5475
5472
  (_, line), = val
5476
5473
  result = s(:next).line line
5477
-
5474
+
5478
5475
  result
5479
5476
  end
5480
5477
 
5481
5478
  def _reduce_348(val, _values, result)
5482
5479
  (_, line), = val
5483
5480
  result = s(:redo).line line
5484
-
5481
+
5485
5482
  result
5486
5483
  end
5487
5484
 
5488
5485
  def _reduce_349(val, _values, result)
5489
5486
  (_, line), = val
5490
5487
  result = s(:retry).line line
5491
-
5488
+
5492
5489
  result
5493
5490
  end
5494
5491
 
5495
5492
  def _reduce_350(val, _values, result)
5496
5493
  result = value_expr(val[0])
5497
-
5494
+
5498
5495
  result
5499
5496
  end
5500
5497
 
@@ -5552,7 +5549,7 @@ def _reduce_376(val, _values, result)
5552
5549
  (_, line), c, _, t, rest = val
5553
5550
 
5554
5551
  result = s(:if, c, t, rest).line line
5555
-
5552
+
5556
5553
  result
5557
5554
  end
5558
5555
 
@@ -5560,7 +5557,7 @@ end
5560
5557
 
5561
5558
  def _reduce_378(val, _values, result)
5562
5559
  result = val[1]
5563
-
5560
+
5564
5561
  result
5565
5562
  end
5566
5563
 
@@ -5568,7 +5565,7 @@ end
5568
5565
 
5569
5566
  def _reduce_380(val, _values, result)
5570
5567
  val[0].delete_at 1 if val[0][1].nil? # HACK
5571
-
5568
+
5572
5569
  result
5573
5570
  end
5574
5571
 
@@ -5576,7 +5573,7 @@ end
5576
5573
 
5577
5574
  def _reduce_382(val, _values, result)
5578
5575
  result = val[1]
5579
-
5576
+
5580
5577
  result
5581
5578
  end
5582
5579
 
@@ -5584,13 +5581,13 @@ def _reduce_383(val, _values, result)
5584
5581
  sym, = val
5585
5582
 
5586
5583
  result = s(:array, sym).line lexer.lineno
5587
-
5584
+
5588
5585
  result
5589
5586
  end
5590
5587
 
5591
5588
  def _reduce_384(val, _values, result)
5592
5589
  result = list_append val[0], val[2]
5593
-
5590
+
5594
5591
  result
5595
5592
  end
5596
5593
 
@@ -5598,7 +5595,7 @@ def _reduce_385(val, _values, result)
5598
5595
  args, = val
5599
5596
 
5600
5597
  result = block_var args
5601
-
5598
+
5602
5599
  result
5603
5600
  end
5604
5601
 
@@ -5606,7 +5603,7 @@ def _reduce_386(val, _values, result)
5606
5603
  args, _, _, splat = val
5607
5604
 
5608
5605
  result = block_var args, "*#{splat}".to_sym
5609
-
5606
+
5610
5607
  result
5611
5608
  end
5612
5609
 
@@ -5614,7 +5611,7 @@ def _reduce_387(val, _values, result)
5614
5611
  args, _, _, splat, _, args2 = val
5615
5612
 
5616
5613
  result = block_var args, "*#{splat}".to_sym, args2
5617
-
5614
+
5618
5615
  result
5619
5616
  end
5620
5617
 
@@ -5622,7 +5619,7 @@ def _reduce_388(val, _values, result)
5622
5619
  args, _, _ = val
5623
5620
 
5624
5621
  result = block_var args, :*
5625
-
5622
+
5626
5623
  result
5627
5624
  end
5628
5625
 
@@ -5630,7 +5627,7 @@ def _reduce_389(val, _values, result)
5630
5627
  args, _, _, _, args2 = val
5631
5628
 
5632
5629
  result = block_var args, :*, args2
5633
-
5630
+
5634
5631
  result
5635
5632
  end
5636
5633
 
@@ -5638,7 +5635,7 @@ def _reduce_390(val, _values, result)
5638
5635
  _, splat = val
5639
5636
 
5640
5637
  result = block_var :"*#{splat}"
5641
-
5638
+
5642
5639
  result
5643
5640
  end
5644
5641
 
@@ -5646,13 +5643,13 @@ def _reduce_391(val, _values, result)
5646
5643
  _, splat, _, args = val
5647
5644
 
5648
5645
  result = block_var :"*#{splat}", args
5649
-
5646
+
5650
5647
  result
5651
5648
  end
5652
5649
 
5653
5650
  def _reduce_392(val, _values, result)
5654
5651
  result = block_var :*
5655
-
5652
+
5656
5653
  result
5657
5654
  end
5658
5655
 
@@ -5660,25 +5657,25 @@ def _reduce_393(val, _values, result)
5660
5657
  _, _, args = val
5661
5658
 
5662
5659
  result = block_var :*, args
5663
-
5660
+
5664
5661
  result
5665
5662
  end
5666
5663
 
5667
5664
  def _reduce_394(val, _values, result)
5668
5665
  result = call_args val
5669
-
5666
+
5670
5667
  result
5671
5668
  end
5672
5669
 
5673
5670
  def _reduce_395(val, _values, result)
5674
5671
  result = call_args val
5675
-
5672
+
5676
5673
  result
5677
5674
  end
5678
5675
 
5679
5676
  def _reduce_396(val, _values, result)
5680
5677
  result = call_args val
5681
-
5678
+
5682
5679
  result
5683
5680
  end
5684
5681
 
@@ -5686,13 +5683,13 @@ def _reduce_397(val, _values, result)
5686
5683
  line = lexer.lineno
5687
5684
  result = call_args val # TODO: push line down
5688
5685
  result.line line
5689
-
5686
+
5690
5687
  result
5691
5688
  end
5692
5689
 
5693
5690
  def _reduce_398(val, _values, result)
5694
5691
  result = args val
5695
-
5692
+
5696
5693
  result
5697
5694
  end
5698
5695
 
@@ -5700,122 +5697,122 @@ end
5700
5697
 
5701
5698
  def _reduce_400(val, _values, result)
5702
5699
  result = args val
5703
-
5700
+
5704
5701
  result
5705
5702
  end
5706
5703
 
5707
5704
  def _reduce_401(val, _values, result)
5708
5705
  result = args val
5709
-
5706
+
5710
5707
  result
5711
5708
  end
5712
5709
 
5713
5710
  def _reduce_402(val, _values, result)
5714
5711
  result = args val
5715
-
5712
+
5716
5713
  result
5717
5714
  end
5718
5715
 
5719
5716
  def _reduce_403(val, _values, result)
5720
5717
  result = args val
5721
-
5718
+
5722
5719
  result
5723
5720
  end
5724
5721
 
5725
5722
  def _reduce_404(val, _values, result)
5726
5723
  result = args val
5727
-
5724
+
5728
5725
  result
5729
5726
  end
5730
5727
 
5731
5728
  def _reduce_405(val, _values, result)
5732
5729
  result = args(val) << nil
5733
-
5730
+
5734
5731
  result
5735
5732
  end
5736
5733
 
5737
5734
  def _reduce_406(val, _values, result)
5738
5735
  result = args val
5739
-
5736
+
5740
5737
  result
5741
5738
  end
5742
5739
 
5743
5740
  def _reduce_407(val, _values, result)
5744
5741
  result = args val
5745
-
5742
+
5746
5743
  result
5747
5744
  end
5748
5745
 
5749
5746
  def _reduce_408(val, _values, result)
5750
5747
  result = args val
5751
-
5748
+
5752
5749
  result
5753
5750
  end
5754
5751
 
5755
5752
  def _reduce_409(val, _values, result)
5756
5753
  result = args val
5757
-
5754
+
5758
5755
  result
5759
5756
  end
5760
5757
 
5761
5758
  def _reduce_410(val, _values, result)
5762
5759
  result = args val
5763
-
5760
+
5764
5761
  result
5765
5762
  end
5766
5763
 
5767
5764
  def _reduce_411(val, _values, result)
5768
5765
  result = args val
5769
-
5766
+
5770
5767
  result
5771
5768
  end
5772
5769
 
5773
5770
  def _reduce_412(val, _values, result)
5774
5771
  result = args val
5775
-
5772
+
5776
5773
  result
5777
5774
  end
5778
5775
 
5779
5776
  def _reduce_413(val, _values, result)
5780
5777
  result = args val
5781
-
5778
+
5782
5779
  result
5783
5780
  end
5784
5781
 
5785
5782
  def _reduce_414(val, _values, result)
5786
5783
  result = args val
5787
-
5784
+
5788
5785
  result
5789
5786
  end
5790
5787
 
5791
5788
  def _reduce_415(val, _values, result)
5792
- result = 0
5789
+ result = 0
5793
5790
  result
5794
5791
  end
5795
5792
 
5796
5793
  def _reduce_416(val, _values, result)
5797
5794
  self.lexer.command_start = true
5798
-
5795
+
5799
5796
  result
5800
5797
  end
5801
5798
 
5802
5799
  def _reduce_417(val, _values, result)
5803
5800
  # TODO: current_arg = 0
5804
5801
  result = args val
5805
-
5802
+
5806
5803
  result
5807
5804
  end
5808
5805
 
5809
5806
  def _reduce_418(val, _values, result)
5810
5807
  result = s(:args).line lexer.lineno
5811
-
5808
+
5812
5809
  result
5813
5810
  end
5814
5811
 
5815
5812
  def _reduce_419(val, _values, result)
5816
5813
  # TODO: current_arg = 0
5817
5814
  result = args val
5818
-
5815
+
5819
5816
  result
5820
5817
  end
5821
5818
 
@@ -5823,19 +5820,19 @@ end
5823
5820
 
5824
5821
  def _reduce_421(val, _values, result)
5825
5822
  result = args val
5826
-
5823
+
5827
5824
  result
5828
5825
  end
5829
5826
 
5830
5827
  def _reduce_422(val, _values, result)
5831
5828
  result = args val
5832
-
5829
+
5833
5830
  result
5834
5831
  end
5835
5832
 
5836
5833
  def _reduce_423(val, _values, result)
5837
5834
  result = args val
5838
-
5835
+
5839
5836
  result
5840
5837
  end
5841
5838
 
@@ -5843,7 +5840,7 @@ def _reduce_424(val, _values, result)
5843
5840
  id, = val
5844
5841
  line = lexer.lineno
5845
5842
  result = s(:shadow, id.to_sym).line line
5846
-
5843
+
5847
5844
  result
5848
5845
  end
5849
5846
 
@@ -5854,13 +5851,13 @@ def _reduce_426(val, _values, result)
5854
5851
  result = [lexer.lineno, lexer.lpar_beg]
5855
5852
  lexer.paren_nest += 1
5856
5853
  lexer.lpar_beg = lexer.paren_nest
5857
-
5854
+
5858
5855
  result
5859
5856
  end
5860
5857
 
5861
5858
  def _reduce_427(val, _values, result)
5862
5859
  result = lexer.cmdarg.store(false)
5863
-
5860
+
5864
5861
  result
5865
5862
  end
5866
5863
 
@@ -5875,39 +5872,39 @@ def _reduce_428(val, _values, result)
5875
5872
  result = new_iter call, args, body
5876
5873
  result.line = line
5877
5874
  self.env.unextend
5878
-
5875
+
5879
5876
  result
5880
5877
  end
5881
5878
 
5882
5879
  def _reduce_429(val, _values, result)
5883
5880
  result = args val
5884
-
5881
+
5885
5882
  result
5886
5883
  end
5887
5884
 
5888
5885
  def _reduce_430(val, _values, result)
5889
5886
  result = val[0]
5890
5887
  result = 0 if result == s(:args)
5891
-
5888
+
5892
5889
  result
5893
5890
  end
5894
5891
 
5895
5892
  def _reduce_431(val, _values, result)
5896
5893
  result = val[1]
5897
-
5894
+
5898
5895
  result
5899
5896
  end
5900
5897
 
5901
5898
  def _reduce_432(val, _values, result)
5902
5899
  result = val[1]
5903
-
5900
+
5904
5901
  result
5905
5902
  end
5906
5903
 
5907
5904
  def _reduce_433(val, _values, result)
5908
5905
  (_, line), iter, _ = val
5909
5906
  result = iter.line line
5910
-
5907
+
5911
5908
  result
5912
5909
  end
5913
5910
 
@@ -5925,13 +5922,13 @@ def _reduce_434(val, _values, result)
5925
5922
 
5926
5923
  result = blk
5927
5924
  result.insert 1, cmd
5928
-
5925
+
5929
5926
  result
5930
5927
  end
5931
5928
 
5932
5929
  def _reduce_435(val, _values, result)
5933
5930
  result = new_call val[0], val[2].to_sym, val[3]
5934
-
5931
+
5935
5932
  result
5936
5933
  end
5937
5934
 
@@ -5942,7 +5939,7 @@ def _reduce_436(val, _values, result)
5942
5939
  iter2.insert 1, call
5943
5940
 
5944
5941
  result = iter2
5945
-
5942
+
5946
5943
  result
5947
5944
  end
5948
5945
 
@@ -5953,13 +5950,13 @@ def _reduce_437(val, _values, result)
5953
5950
  iter2.insert 1, call
5954
5951
 
5955
5952
  result = iter2
5956
-
5953
+
5957
5954
  result
5958
5955
  end
5959
5956
 
5960
5957
  def _reduce_438(val, _values, result)
5961
5958
  result = self.lexer.lineno
5962
-
5959
+
5963
5960
  result
5964
5961
  end
5965
5962
 
@@ -5968,62 +5965,62 @@ def _reduce_439(val, _values, result)
5968
5965
 
5969
5966
  result = call.concat args.sexp_body if args
5970
5967
  result.line lineno
5971
-
5968
+
5972
5969
  result
5973
5970
  end
5974
5971
 
5975
5972
  def _reduce_440(val, _values, result)
5976
5973
  result = new_call val[0], val[2].to_sym, val[3], val[1]
5977
-
5974
+
5978
5975
  result
5979
5976
  end
5980
5977
 
5981
5978
  def _reduce_441(val, _values, result)
5982
5979
  result = new_call val[0], val[2].to_sym, val[3]
5983
-
5980
+
5984
5981
  result
5985
5982
  end
5986
5983
 
5987
5984
  def _reduce_442(val, _values, result)
5988
5985
  result = new_call val[0], val[2].to_sym
5989
-
5986
+
5990
5987
  result
5991
5988
  end
5992
5989
 
5993
5990
  def _reduce_443(val, _values, result)
5994
5991
  result = new_call val[0], :call, val[2], val[1]
5995
-
5992
+
5996
5993
  result
5997
5994
  end
5998
5995
 
5999
5996
  def _reduce_444(val, _values, result)
6000
5997
  result = new_call val[0], :call, val[2]
6001
-
5998
+
6002
5999
  result
6003
6000
  end
6004
6001
 
6005
6002
  def _reduce_445(val, _values, result)
6006
6003
  result = new_super val[1]
6007
-
6004
+
6008
6005
  result
6009
6006
  end
6010
6007
 
6011
6008
  def _reduce_446(val, _values, result)
6012
6009
  result = s(:zsuper).line lexer.lineno
6013
-
6010
+
6014
6011
  result
6015
6012
  end
6016
6013
 
6017
6014
  def _reduce_447(val, _values, result)
6018
6015
  result = new_aref val
6019
-
6016
+
6020
6017
  result
6021
6018
  end
6022
6019
 
6023
6020
  def _reduce_448(val, _values, result)
6024
6021
  self.env.extend :dynamic
6025
6022
  result = self.lexer.lineno
6026
-
6023
+
6027
6024
  result
6028
6025
  end
6029
6026
 
@@ -6034,14 +6031,14 @@ def _reduce_449(val, _values, result)
6034
6031
  result.line = line
6035
6032
 
6036
6033
  self.env.unextend
6037
-
6034
+
6038
6035
  result
6039
6036
  end
6040
6037
 
6041
6038
  def _reduce_450(val, _values, result)
6042
6039
  self.env.extend :dynamic
6043
6040
  result = self.lexer.lineno
6044
-
6041
+
6045
6042
  result
6046
6043
  end
6047
6044
 
@@ -6052,17 +6049,17 @@ def _reduce_451(val, _values, result)
6052
6049
  result.line = line
6053
6050
 
6054
6051
  self.env.unextend
6055
-
6052
+
6056
6053
  result
6057
6054
  end
6058
6055
 
6059
6056
  def _reduce_452(val, _values, result)
6060
- self.env.extend :dynamic; result = self.lexer.lineno
6057
+ self.env.extend :dynamic; result = self.lexer.lineno
6061
6058
  result
6062
6059
  end
6063
6060
 
6064
6061
  def _reduce_453(val, _values, result)
6065
- result = lexer.cmdarg.store(false)
6062
+ result = lexer.cmdarg.store(false)
6066
6063
  result
6067
6064
  end
6068
6065
 
@@ -6073,17 +6070,17 @@ def _reduce_454(val, _values, result)
6073
6070
  self.env.unextend
6074
6071
  lexer.cmdarg.restore cmdarg
6075
6072
  lexer.cmdarg.pop # because of: cmdarg_stack >> 1 ?
6076
-
6073
+
6077
6074
  result
6078
6075
  end
6079
6076
 
6080
6077
  def _reduce_455(val, _values, result)
6081
- self.env.extend :dynamic; result = self.lexer.lineno
6078
+ self.env.extend :dynamic; result = self.lexer.lineno
6082
6079
  result
6083
6080
  end
6084
6081
 
6085
6082
  def _reduce_456(val, _values, result)
6086
- result = lexer.cmdarg.store(false)
6083
+ result = lexer.cmdarg.store(false)
6087
6084
  result
6088
6085
  end
6089
6086
 
@@ -6093,13 +6090,13 @@ def _reduce_457(val, _values, result)
6093
6090
  result = new_do_body param, cmpstmt, line
6094
6091
  self.env.unextend
6095
6092
  lexer.cmdarg.restore cmdarg
6096
-
6093
+
6097
6094
  result
6098
6095
  end
6099
6096
 
6100
6097
  def _reduce_458(val, _values, result)
6101
6098
  result = self.lexer.lineno
6102
-
6099
+
6103
6100
  result
6104
6101
  end
6105
6102
 
@@ -6107,7 +6104,7 @@ def _reduce_459(val, _values, result)
6107
6104
  result = new_when(val[2], val[4])
6108
6105
  result.line = val[1]
6109
6106
  result << val[5] if val[5]
6110
-
6107
+
6111
6108
  result
6112
6109
  end
6113
6110
 
@@ -6124,20 +6121,20 @@ def _reduce_462(val, _values, result)
6124
6121
 
6125
6122
  result = new_resbody(klasses, body)
6126
6123
  result << rest if rest # UGH, rewritten above
6127
-
6124
+
6128
6125
  result
6129
6126
  end
6130
6127
 
6131
6128
  def _reduce_463(val, _values, result)
6132
6129
  result = nil
6133
-
6130
+
6134
6131
  result
6135
6132
  end
6136
6133
 
6137
6134
  def _reduce_464(val, _values, result)
6138
6135
  arg, = val
6139
6136
  result = s(:array, arg).line arg.line
6140
-
6137
+
6141
6138
  result
6142
6139
  end
6143
6140
 
@@ -6147,7 +6144,7 @@ end
6147
6144
 
6148
6145
  def _reduce_467(val, _values, result)
6149
6146
  result = val[1]
6150
-
6147
+
6151
6148
  result
6152
6149
  end
6153
6150
 
@@ -6157,7 +6154,7 @@ def _reduce_469(val, _values, result)
6157
6154
  (_, line), body = val
6158
6155
 
6159
6156
  result = body || s(:nil).line(line)
6160
-
6157
+
6161
6158
  result
6162
6159
  end
6163
6160
 
@@ -6167,7 +6164,7 @@ def _reduce_471(val, _values, result)
6167
6164
  line = lexer.lineno
6168
6165
  result = s(:lit, val[0])
6169
6166
  result.line = line
6170
-
6167
+
6171
6168
  result
6172
6169
  end
6173
6170
 
@@ -6175,7 +6172,7 @@ def _reduce_472(val, _values, result)
6175
6172
  line = lexer.lineno
6176
6173
  result = s(:lit, val[0])
6177
6174
  result.line = line
6178
-
6175
+
6179
6176
  result
6180
6177
  end
6181
6178
 
@@ -6185,13 +6182,13 @@ def _reduce_474(val, _values, result)
6185
6182
  str, = val
6186
6183
  str = s(:dstr, str.value) if str.sexp_type == :evstr
6187
6184
  result = str
6188
-
6185
+
6189
6186
  result
6190
6187
  end
6191
6188
 
6192
6189
  def _reduce_475(val, _values, result)
6193
6190
  debug20 23, val, result
6194
-
6191
+
6195
6192
  result
6196
6193
  end
6197
6194
 
@@ -6199,7 +6196,7 @@ end
6199
6196
 
6200
6197
  def _reduce_477(val, _values, result)
6201
6198
  result = self.literal_concat val[0], val[1]
6202
-
6199
+
6203
6200
  result
6204
6201
  end
6205
6202
 
@@ -6209,50 +6206,50 @@ def _reduce_478(val, _values, result)
6209
6206
  str = dedent str if func =~ RubyLexer::STR_FUNC_ICNTNT
6210
6207
 
6211
6208
  result = str
6212
-
6209
+
6213
6210
  result
6214
6211
  end
6215
6212
 
6216
6213
  def _reduce_479(val, _values, result)
6217
6214
  result = new_string val
6218
-
6215
+
6219
6216
  result
6220
6217
  end
6221
6218
 
6222
6219
  def _reduce_480(val, _values, result)
6223
6220
  result = new_xstring val[1]
6224
6221
  # TODO: dedent?!?! SERIOUSLY?!?
6225
-
6222
+
6226
6223
  result
6227
6224
  end
6228
6225
 
6229
6226
  def _reduce_481(val, _values, result)
6230
6227
  result = new_regexp val
6231
-
6228
+
6232
6229
  result
6233
6230
  end
6234
6231
 
6235
6232
  def _reduce_482(val, _values, result)
6236
6233
  result = s(:array).line lexer.lineno
6237
-
6234
+
6238
6235
  result
6239
6236
  end
6240
6237
 
6241
6238
  def _reduce_483(val, _values, result)
6242
6239
  result = val[1]
6243
-
6240
+
6244
6241
  result
6245
6242
  end
6246
6243
 
6247
6244
  def _reduce_484(val, _values, result)
6248
6245
  result = new_word_list
6249
-
6246
+
6250
6247
  result
6251
6248
  end
6252
6249
 
6253
6250
  def _reduce_485(val, _values, result)
6254
6251
  result = val[0].dup << new_word_list_entry(val)
6255
-
6252
+
6256
6253
  result
6257
6254
  end
6258
6255
 
@@ -6260,18 +6257,18 @@ end
6260
6257
 
6261
6258
  def _reduce_487(val, _values, result)
6262
6259
  result = self.literal_concat val[0], val[1]
6263
-
6260
+
6264
6261
  result
6265
6262
  end
6266
6263
 
6267
6264
  def _reduce_488(val, _values, result)
6268
6265
  result = s(:array).line lexer.lineno
6269
-
6266
+
6270
6267
  result
6271
6268
  end
6272
6269
 
6273
6270
  def _reduce_489(val, _values, result)
6274
- result = lexer.lineno
6271
+ result = lexer.lineno
6275
6272
  result
6276
6273
  end
6277
6274
 
@@ -6279,113 +6276,113 @@ def _reduce_490(val, _values, result)
6279
6276
  _, line, list, _, = val
6280
6277
  list.line = line
6281
6278
  result = list
6282
-
6279
+
6283
6280
  result
6284
6281
  end
6285
6282
 
6286
6283
  def _reduce_491(val, _values, result)
6287
6284
  result = new_symbol_list.line lexer.lineno
6288
-
6285
+
6289
6286
  result
6290
6287
  end
6291
6288
 
6292
6289
  def _reduce_492(val, _values, result)
6293
6290
  list, * = val
6294
6291
  result = list.dup << new_symbol_list_entry(val)
6295
-
6292
+
6296
6293
  result
6297
6294
  end
6298
6295
 
6299
6296
  def _reduce_493(val, _values, result)
6300
6297
  result = s(:array).line lexer.lineno
6301
-
6298
+
6302
6299
  result
6303
6300
  end
6304
6301
 
6305
6302
  def _reduce_494(val, _values, result)
6306
6303
  result = val[1]
6307
-
6304
+
6308
6305
  result
6309
6306
  end
6310
6307
 
6311
6308
  def _reduce_495(val, _values, result)
6312
6309
  result = s(:array).line lexer.lineno # FIX
6313
-
6310
+
6314
6311
  result
6315
6312
  end
6316
6313
 
6317
6314
  def _reduce_496(val, _values, result)
6318
6315
  result = val[1]
6319
-
6316
+
6320
6317
  result
6321
6318
  end
6322
6319
 
6323
6320
  def _reduce_497(val, _values, result)
6324
6321
  result = new_qword_list
6325
-
6322
+
6326
6323
  result
6327
6324
  end
6328
6325
 
6329
6326
  def _reduce_498(val, _values, result)
6330
6327
  result = val[0].dup << new_qword_list_entry(val)
6331
-
6328
+
6332
6329
  result
6333
6330
  end
6334
6331
 
6335
6332
  def _reduce_499(val, _values, result)
6336
6333
  result = new_qsym_list
6337
-
6334
+
6338
6335
  result
6339
6336
  end
6340
6337
 
6341
6338
  def _reduce_500(val, _values, result)
6342
6339
  result = val[0].dup << new_qsym_list_entry(val)
6343
-
6340
+
6344
6341
  result
6345
6342
  end
6346
6343
 
6347
6344
  def _reduce_501(val, _values, result)
6348
6345
  result = s(:str, "").line lexer.lineno
6349
-
6346
+
6350
6347
  result
6351
6348
  end
6352
6349
 
6353
6350
  def _reduce_502(val, _values, result)
6354
6351
  v1, v2 = val
6355
6352
  result = literal_concat v1, v2
6356
-
6353
+
6357
6354
  result
6358
6355
  end
6359
6356
 
6360
6357
  def _reduce_503(val, _values, result)
6361
6358
  result = nil
6362
-
6359
+
6363
6360
  result
6364
6361
  end
6365
6362
 
6366
6363
  def _reduce_504(val, _values, result)
6367
6364
  v1, v2 = val
6368
6365
  result = literal_concat v1, v2
6369
-
6366
+
6370
6367
  result
6371
6368
  end
6372
6369
 
6373
6370
  def _reduce_505(val, _values, result)
6374
6371
  result = nil
6375
-
6372
+
6376
6373
  result
6377
6374
  end
6378
6375
 
6379
6376
  def _reduce_506(val, _values, result)
6380
6377
  v1, v2 = val
6381
6378
  result = literal_concat v1, v2
6382
-
6379
+
6383
6380
  result
6384
6381
  end
6385
6382
 
6386
6383
  def _reduce_507(val, _values, result)
6387
6384
  result = new_string val
6388
-
6385
+
6389
6386
  result
6390
6387
  end
6391
6388
 
@@ -6394,7 +6391,7 @@ def _reduce_508(val, _values, result)
6394
6391
 
6395
6392
  lexer.lex_strterm = nil
6396
6393
  lexer.lex_state = EXPR_BEG
6397
-
6394
+
6398
6395
  result
6399
6396
  end
6400
6397
 
@@ -6402,7 +6399,7 @@ def _reduce_509(val, _values, result)
6402
6399
  _, strterm, str = val
6403
6400
  lexer.lex_strterm = strterm
6404
6401
  result = s(:evstr, str).line str.line
6405
-
6402
+
6406
6403
  result
6407
6404
  end
6408
6405
 
@@ -6421,7 +6418,7 @@ def _reduce_510(val, _values, result)
6421
6418
  lexer.string_nest = 0
6422
6419
 
6423
6420
  lexer.lex_state = EXPR_BEG
6424
-
6421
+
6425
6422
  result
6426
6423
  end
6427
6424
 
@@ -6453,22 +6450,22 @@ def _reduce_511(val, _values, result)
6453
6450
  debug20 25
6454
6451
  raise "unknown string body: #{stmt.inspect}"
6455
6452
  end
6456
-
6453
+
6457
6454
  result
6458
6455
  end
6459
6456
 
6460
6457
  def _reduce_512(val, _values, result)
6461
- result = s(:gvar, val[0].to_sym).line lexer.lineno
6458
+ result = s(:gvar, val[0].to_sym).line lexer.lineno
6462
6459
  result
6463
6460
  end
6464
6461
 
6465
6462
  def _reduce_513(val, _values, result)
6466
- result = s(:ivar, val[0].to_sym).line lexer.lineno
6463
+ result = s(:ivar, val[0].to_sym).line lexer.lineno
6467
6464
  result
6468
6465
  end
6469
6466
 
6470
6467
  def _reduce_514(val, _values, result)
6471
- result = s(:cvar, val[0].to_sym).line lexer.lineno
6468
+ result = s(:cvar, val[0].to_sym).line lexer.lineno
6472
6469
  result
6473
6470
  end
6474
6471
 
@@ -6477,13 +6474,13 @@ end
6477
6474
  def _reduce_516(val, _values, result)
6478
6475
  lexer.lex_state = EXPR_END
6479
6476
  result = val[1].to_sym
6480
-
6477
+
6481
6478
  result
6482
6479
  end
6483
6480
 
6484
6481
  def _reduce_517(val, _values, result)
6485
6482
  result = val[0].to_sym
6486
-
6483
+
6487
6484
  result
6488
6485
  end
6489
6486
 
@@ -6512,7 +6509,7 @@ def _reduce_522(val, _values, result)
6512
6509
  else
6513
6510
  debug20 26, val, result
6514
6511
  end
6515
-
6512
+
6516
6513
  result
6517
6514
  end
6518
6515
 
@@ -6520,7 +6517,7 @@ end
6520
6517
 
6521
6518
  def _reduce_524(val, _values, result)
6522
6519
  result = -val[1] # TODO: pt_testcase
6523
-
6520
+
6524
6521
  result
6525
6522
  end
6526
6523
 
@@ -6543,32 +6540,32 @@ end
6543
6540
  # reduce 533 omitted
6544
6541
 
6545
6542
  def _reduce_534(val, _values, result)
6546
- result = s(:nil).line lexer.lineno
6543
+ result = s(:nil).line lexer.lineno
6547
6544
  result
6548
6545
  end
6549
6546
 
6550
6547
  def _reduce_535(val, _values, result)
6551
- result = s(:self).line lexer.lineno
6548
+ result = s(:self).line lexer.lineno
6552
6549
  result
6553
6550
  end
6554
6551
 
6555
6552
  def _reduce_536(val, _values, result)
6556
- result = s(:true).line lexer.lineno
6553
+ result = s(:true).line lexer.lineno
6557
6554
  result
6558
6555
  end
6559
6556
 
6560
6557
  def _reduce_537(val, _values, result)
6561
- result = s(:false).line lexer.lineno
6558
+ result = s(:false).line lexer.lineno
6562
6559
  result
6563
6560
  end
6564
6561
 
6565
6562
  def _reduce_538(val, _values, result)
6566
- result = s(:str, self.file).line lexer.lineno
6563
+ result = s(:str, self.file).line lexer.lineno
6567
6564
  result
6568
6565
  end
6569
6566
 
6570
6567
  def _reduce_539(val, _values, result)
6571
- result = s(:lit, lexer.lineno).line lexer.lineno
6568
+ result = s(:lit, lexer.lineno).line lexer.lineno
6572
6569
  result
6573
6570
  end
6574
6571
 
@@ -6580,63 +6577,63 @@ def _reduce_540(val, _values, result)
6580
6577
  else
6581
6578
  s(:str, "Unsupported!").line l
6582
6579
  end
6583
-
6580
+
6584
6581
  result
6585
6582
  end
6586
6583
 
6587
6584
  def _reduce_541(val, _values, result)
6588
6585
  var = val[0]
6589
6586
  result = Sexp === var ? var : self.gettable(var)
6590
-
6587
+
6591
6588
  result
6592
6589
  end
6593
6590
 
6594
6591
  def _reduce_542(val, _values, result)
6595
6592
  var = val[0]
6596
6593
  result = Sexp === var ? var : self.gettable(var)
6597
-
6594
+
6598
6595
  result
6599
6596
  end
6600
6597
 
6601
6598
  def _reduce_543(val, _values, result)
6602
6599
  result = self.assignable val[0]
6603
-
6600
+
6604
6601
  result
6605
6602
  end
6606
6603
 
6607
6604
  def _reduce_544(val, _values, result)
6608
6605
  result = self.assignable val[0]
6609
6606
  debug20 29, val, result
6610
-
6607
+
6611
6608
  result
6612
6609
  end
6613
6610
 
6614
6611
  def _reduce_545(val, _values, result)
6615
- result = s(:nth_ref, val[0]).line lexer.lineno
6612
+ result = s(:nth_ref, val[0]).line lexer.lineno
6616
6613
  result
6617
6614
  end
6618
6615
 
6619
6616
  def _reduce_546(val, _values, result)
6620
- result = s(:back_ref, val[0]).line lexer.lineno
6617
+ result = s(:back_ref, val[0]).line lexer.lineno
6621
6618
  result
6622
6619
  end
6623
6620
 
6624
6621
  def _reduce_547(val, _values, result)
6625
6622
  lexer.lex_state = EXPR_BEG
6626
6623
  lexer.command_start = true
6627
-
6624
+
6628
6625
  result
6629
6626
  end
6630
6627
 
6631
6628
  def _reduce_548(val, _values, result)
6632
6629
  result = val[2]
6633
-
6630
+
6634
6631
  result
6635
6632
  end
6636
6633
 
6637
6634
  def _reduce_549(val, _values, result)
6638
6635
  result = nil
6639
-
6636
+
6640
6637
  result
6641
6638
  end
6642
6639
 
@@ -6644,7 +6641,7 @@ def _reduce_550(val, _values, result)
6644
6641
  result = val[1]
6645
6642
  self.lexer.lex_state = EXPR_BEG
6646
6643
  self.lexer.command_start = true
6647
-
6644
+
6648
6645
  result
6649
6646
  end
6650
6647
 
@@ -6652,7 +6649,7 @@ def _reduce_551(val, _values, result)
6652
6649
  result = self.in_kwarg
6653
6650
  self.in_kwarg = true
6654
6651
  self.lexer.lex_state |= EXPR_LABEL
6655
-
6652
+
6656
6653
  result
6657
6654
  end
6658
6655
 
@@ -6663,25 +6660,25 @@ def _reduce_552(val, _values, result)
6663
6660
  result = args
6664
6661
  lexer.lex_state = EXPR_BEG
6665
6662
  lexer.command_start = true
6666
-
6663
+
6667
6664
  result
6668
6665
  end
6669
6666
 
6670
6667
  def _reduce_553(val, _values, result)
6671
6668
  result = args val
6672
-
6669
+
6673
6670
  result
6674
6671
  end
6675
6672
 
6676
6673
  def _reduce_554(val, _values, result)
6677
6674
  result = args val
6678
-
6675
+
6679
6676
  result
6680
6677
  end
6681
6678
 
6682
6679
  def _reduce_555(val, _values, result)
6683
6680
  result = args val
6684
-
6681
+
6685
6682
  result
6686
6683
  end
6687
6684
 
@@ -6689,127 +6686,127 @@ end
6689
6686
 
6690
6687
  def _reduce_557(val, _values, result)
6691
6688
  result = val[1]
6692
-
6689
+
6693
6690
  result
6694
6691
  end
6695
6692
 
6696
6693
  def _reduce_558(val, _values, result)
6697
6694
  result = nil
6698
-
6695
+
6699
6696
  result
6700
6697
  end
6701
6698
 
6702
6699
  def _reduce_559(val, _values, result)
6703
6700
  result = args val
6704
-
6701
+
6705
6702
  result
6706
6703
  end
6707
6704
 
6708
6705
  def _reduce_560(val, _values, result)
6709
6706
  result = args val
6710
-
6707
+
6711
6708
  result
6712
6709
  end
6713
6710
 
6714
6711
  def _reduce_561(val, _values, result)
6715
6712
  result = args val
6716
-
6713
+
6717
6714
  result
6718
6715
  end
6719
6716
 
6720
6717
  def _reduce_562(val, _values, result)
6721
6718
  result = args val
6722
-
6719
+
6723
6720
  result
6724
6721
  end
6725
6722
 
6726
6723
  def _reduce_563(val, _values, result)
6727
6724
  result = args val
6728
-
6725
+
6729
6726
  result
6730
6727
  end
6731
6728
 
6732
6729
  def _reduce_564(val, _values, result)
6733
6730
  result = args val
6734
-
6731
+
6735
6732
  result
6736
6733
  end
6737
6734
 
6738
6735
  def _reduce_565(val, _values, result)
6739
6736
  result = args val
6740
-
6737
+
6741
6738
  result
6742
6739
  end
6743
6740
 
6744
6741
  def _reduce_566(val, _values, result)
6745
6742
  result = args val
6746
-
6743
+
6747
6744
  result
6748
6745
  end
6749
6746
 
6750
6747
  def _reduce_567(val, _values, result)
6751
6748
  result = args val
6752
-
6749
+
6753
6750
  result
6754
6751
  end
6755
6752
 
6756
6753
  def _reduce_568(val, _values, result)
6757
6754
  result = args val
6758
-
6755
+
6759
6756
  result
6760
6757
  end
6761
6758
 
6762
6759
  def _reduce_569(val, _values, result)
6763
6760
  result = args val
6764
-
6761
+
6765
6762
  result
6766
6763
  end
6767
6764
 
6768
6765
  def _reduce_570(val, _values, result)
6769
6766
  result = args val
6770
-
6767
+
6771
6768
  result
6772
6769
  end
6773
6770
 
6774
6771
  def _reduce_571(val, _values, result)
6775
6772
  result = args val
6776
-
6773
+
6777
6774
  result
6778
6775
  end
6779
6776
 
6780
6777
  def _reduce_572(val, _values, result)
6781
6778
  result = args val
6782
-
6779
+
6783
6780
  result
6784
6781
  end
6785
6782
 
6786
6783
  def _reduce_573(val, _values, result)
6787
6784
  result = args val
6788
-
6785
+
6789
6786
  result
6790
6787
  end
6791
6788
 
6792
6789
  def _reduce_574(val, _values, result)
6793
6790
  yyerror "formal argument cannot be a constant"
6794
-
6791
+
6795
6792
  result
6796
6793
  end
6797
6794
 
6798
6795
  def _reduce_575(val, _values, result)
6799
6796
  yyerror "formal argument cannot be an instance variable"
6800
-
6797
+
6801
6798
  result
6802
6799
  end
6803
6800
 
6804
6801
  def _reduce_576(val, _values, result)
6805
6802
  yyerror "formal argument cannot be a global variable"
6806
-
6803
+
6807
6804
  result
6808
6805
  end
6809
6806
 
6810
6807
  def _reduce_577(val, _values, result)
6811
6808
  yyerror "formal argument cannot be a class variable"
6812
-
6809
+
6813
6810
  result
6814
6811
  end
6815
6812
 
@@ -6820,7 +6817,7 @@ def _reduce_579(val, _values, result)
6820
6817
  self.env[identifier] = :lvar
6821
6818
 
6822
6819
  result = identifier
6823
-
6820
+
6824
6821
  result
6825
6822
  end
6826
6823
 
@@ -6830,7 +6827,7 @@ end
6830
6827
 
6831
6828
  def _reduce_582(val, _values, result)
6832
6829
  result = val[1]
6833
-
6830
+
6834
6831
  result
6835
6832
  end
6836
6833
 
@@ -6846,7 +6843,7 @@ def _reduce_583(val, _values, result)
6846
6843
  debug20 32
6847
6844
  raise "Unknown f_arg type: #{val.inspect}"
6848
6845
  end
6849
-
6846
+
6850
6847
  result
6851
6848
  end
6852
6849
 
@@ -6860,7 +6857,7 @@ def _reduce_584(val, _values, result)
6860
6857
  end
6861
6858
 
6862
6859
  result << item
6863
-
6860
+
6864
6861
  result
6865
6862
  end
6866
6863
 
@@ -6875,7 +6872,7 @@ def _reduce_586(val, _values, result)
6875
6872
 
6876
6873
  kwarg = s(:kwarg, identifier, arg).line line
6877
6874
  result = s(:array, kwarg).line line
6878
-
6875
+
6879
6876
  result
6880
6877
  end
6881
6878
 
@@ -6886,7 +6883,7 @@ def _reduce_587(val, _values, result)
6886
6883
  self.env[id] = :lvar
6887
6884
 
6888
6885
  result = s(:array, s(:kwarg, id).line(line)).line line
6889
-
6886
+
6890
6887
  result
6891
6888
  end
6892
6889
 
@@ -6897,7 +6894,7 @@ def _reduce_588(val, _values, result)
6897
6894
  self.env[id] = :lvar
6898
6895
 
6899
6896
  result = s(:array, s(:kwarg, id, expr).line(line)).line line
6900
-
6897
+
6901
6898
  result
6902
6899
  end
6903
6900
 
@@ -6908,7 +6905,7 @@ def _reduce_589(val, _values, result)
6908
6905
  self.env[id] = :lvar
6909
6906
 
6910
6907
  result = s(:array, s(:kwarg, id).line(line)).line line
6911
-
6908
+
6912
6909
  result
6913
6910
  end
6914
6911
 
@@ -6917,7 +6914,7 @@ end
6917
6914
  def _reduce_591(val, _values, result)
6918
6915
  list, _, item = val
6919
6916
  result = list << item.last
6920
-
6917
+
6921
6918
  result
6922
6919
  end
6923
6920
 
@@ -6925,7 +6922,7 @@ end
6925
6922
 
6926
6923
  def _reduce_593(val, _values, result)
6927
6924
  result = args val
6928
-
6925
+
6929
6926
  result
6930
6927
  end
6931
6928
 
@@ -6937,33 +6934,33 @@ def _reduce_596(val, _values, result)
6937
6934
  name = val[1].to_sym
6938
6935
  self.assignable name
6939
6936
  result = :"**#{name}"
6940
-
6937
+
6941
6938
  result
6942
6939
  end
6943
6940
 
6944
6941
  def _reduce_597(val, _values, result)
6945
6942
  result = :"**"
6946
-
6943
+
6947
6944
  result
6948
6945
  end
6949
6946
 
6950
6947
  def _reduce_598(val, _values, result)
6951
6948
  result = self.assignable val[0], val[2]
6952
6949
  # TODO: detect duplicate names
6953
-
6950
+
6954
6951
  result
6955
6952
  end
6956
6953
 
6957
6954
  def _reduce_599(val, _values, result)
6958
6955
  result = self.assignable val[0], val[2]
6959
-
6956
+
6960
6957
  result
6961
6958
  end
6962
6959
 
6963
6960
  def _reduce_600(val, _values, result)
6964
6961
  optblk, = val
6965
6962
  result = s(:block, optblk).line optblk.line
6966
-
6963
+
6967
6964
  result
6968
6965
  end
6969
6966
 
@@ -6971,20 +6968,20 @@ def _reduce_601(val, _values, result)
6971
6968
  optarg, _, optblk = val
6972
6969
  result = optarg
6973
6970
  result << optblk
6974
-
6971
+
6975
6972
  result
6976
6973
  end
6977
6974
 
6978
6975
  def _reduce_602(val, _values, result)
6979
6976
  opt, = val
6980
6977
  result = s(:block, opt).line opt.line
6981
-
6978
+
6982
6979
  result
6983
6980
  end
6984
6981
 
6985
6982
  def _reduce_603(val, _values, result)
6986
6983
  result = self.block_append val[0], val[2]
6987
-
6984
+
6988
6985
  result
6989
6986
  end
6990
6987
 
@@ -6997,7 +6994,7 @@ def _reduce_606(val, _values, result)
6997
6994
  name = val[1].to_sym
6998
6995
  self.assignable name
6999
6996
  result = :"*#{name}"
7000
-
6997
+
7001
6998
  result
7002
6999
  end
7003
7000
 
@@ -7005,7 +7002,7 @@ def _reduce_607(val, _values, result)
7005
7002
  name = :"*"
7006
7003
  self.env[name] = :lvar
7007
7004
  result = name
7008
-
7005
+
7009
7006
  result
7010
7007
  end
7011
7008
 
@@ -7018,19 +7015,19 @@ def _reduce_610(val, _values, result)
7018
7015
 
7019
7016
  self.env[identifier] = :lvar
7020
7017
  result = "&#{identifier}".to_sym
7021
-
7018
+
7022
7019
  result
7023
7020
  end
7024
7021
 
7025
7022
  def _reduce_611(val, _values, result)
7026
7023
  result = val[1]
7027
-
7024
+
7028
7025
  result
7029
7026
  end
7030
7027
 
7031
7028
  def _reduce_612(val, _values, result)
7032
7029
  result = nil
7033
-
7030
+
7034
7031
  result
7035
7032
  end
7036
7033
 
@@ -7038,7 +7035,7 @@ end
7038
7035
 
7039
7036
  def _reduce_614(val, _values, result)
7040
7037
  lexer.lex_state = EXPR_BEG
7041
-
7038
+
7042
7039
  result
7043
7040
  end
7044
7041
 
@@ -7046,13 +7043,13 @@ def _reduce_615(val, _values, result)
7046
7043
  result = val[2]
7047
7044
  yyerror "Can't define single method for literals." if
7048
7045
  result.sexp_type == :lit
7049
-
7046
+
7050
7047
  result
7051
7048
  end
7052
7049
 
7053
7050
  def _reduce_616(val, _values, result)
7054
7051
  result = s(:array).line lexer.lineno
7055
-
7052
+
7056
7053
  result
7057
7054
  end
7058
7055
 
@@ -7066,14 +7063,14 @@ def _reduce_619(val, _values, result)
7066
7063
  list.push(*more) unless more.empty?
7067
7064
  result = list
7068
7065
  result.sexp_type = :hash
7069
-
7066
+
7070
7067
  result
7071
7068
  end
7072
7069
 
7073
7070
  def _reduce_620(val, _values, result)
7074
7071
  v1, _, v2 = val
7075
7072
  result = s(:array, v1, v2).line v1.line
7076
-
7073
+
7077
7074
  result
7078
7075
  end
7079
7076
 
@@ -7082,7 +7079,7 @@ def _reduce_621(val, _values, result)
7082
7079
 
7083
7080
  lit = s(:lit, label.to_sym).line line
7084
7081
  result = s(:array, lit, arg).line line
7085
-
7082
+
7086
7083
  result
7087
7084
  end
7088
7085
 
@@ -7090,7 +7087,7 @@ def _reduce_622(val, _values, result)
7090
7087
  _, sym, _, value = val
7091
7088
  sym.sexp_type = :dsym
7092
7089
  result = s(:array, sym, value).line sym.line
7093
-
7090
+
7094
7091
  result
7095
7092
  end
7096
7093
 
@@ -7098,7 +7095,7 @@ def _reduce_623(val, _values, result)
7098
7095
  _, arg = val
7099
7096
  line = arg.line
7100
7097
  result = s(:array, s(:kwsplat, arg).line(line)).line line
7101
-
7098
+
7102
7099
  result
7103
7100
  end
7104
7101
 
@@ -7153,7 +7150,7 @@ end
7153
7150
  # reduce 648 omitted
7154
7151
 
7155
7152
  def _reduce_649(val, _values, result)
7156
- yyerrok
7153
+ yyerrok
7157
7154
  result
7158
7155
  end
7159
7156
 
@@ -7162,12 +7159,12 @@ end
7162
7159
  # reduce 651 omitted
7163
7160
 
7164
7161
  def _reduce_652(val, _values, result)
7165
- yyerrok
7162
+ yyerrok
7166
7163
  result
7167
7164
  end
7168
7165
 
7169
7166
  def _reduce_653(val, _values, result)
7170
- result = nil;
7167
+ result = nil;
7171
7168
  result
7172
7169
  end
7173
7170