ruby_parser 3.14.1 → 3.14.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 80b91fff73fd2b78aa0e9218f7f975247d0f281c04820b28c99f3b2b378d85c7
4
- data.tar.gz: 85fee306db91c8f29cfe45728dea537ef068bf1dee3055c5f88395adc335eb71
3
+ metadata.gz: 397471879b6b8dc9138464e3c08e585fbbf6c314c664573c660d9f9853e8b503
4
+ data.tar.gz: e90bc3750fac22cefb540a1d847cd8f07af611096b8095feaa17885fe040dff7
5
5
  SHA512:
6
- metadata.gz: ac46d9e8261e7ad6e182e4fd81551ce357b5b4d39ba3a361f19d8a86f67e40d5645b3fe4fffe47ecf544eb2c8b66fa92aba032ff8663def56490e337a192ffa6
7
- data.tar.gz: 1070b7d4b64dc73e551ea1d0a0de17f75e21f313e549ac6e735bdf235777e17ec67373c67fec2f31413224c1182eb5ca797fecdd2c1d36219b9586b9c960d838
6
+ metadata.gz: 54edcdda388c8ad13123ae58484e2ab9c0f3eb49893de14f947751cd65133d6dbb5805eb9baa22f6c91f18e20c759053d98265415128b13a107f6a652b1459a7
7
+ data.tar.gz: c59425b19b4017e420963aaf37a27bfa7ae31e15d2824efd3bbc0dcf3590f6f3a76cbeee22c62204e1d45fc1fa4759d478dde8cd5f1984007071217659450f42
Binary file
data.tar.gz.sig CHANGED
Binary file
@@ -1,3 +1,9 @@
1
+ === 3.14.2 / 2020-02-06
2
+
3
+ * 1 minor enhancement:
4
+
5
+ * Cleaned up call_args and removed arg_blk_pass from ruby_parser_extras.rb! Yay!
6
+
1
7
  === 3.14.1 / 2019-10-29
2
8
 
3
9
  * 1 minor enhancement:
@@ -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'
@@ -3473,20 +3473,20 @@ Racc_debug_parser = false
3473
3473
 
3474
3474
  def _reduce_1(val, _values, result)
3475
3475
  self.lexer.lex_state = EXPR_BEG
3476
-
3476
+
3477
3477
  result
3478
3478
  end
3479
3479
 
3480
3480
  def _reduce_2(val, _values, result)
3481
3481
  result = new_compstmt val
3482
-
3482
+
3483
3483
  result
3484
3484
  end
3485
3485
 
3486
3486
  def _reduce_3(val, _values, result)
3487
3487
  stmt, _ = val
3488
3488
  result = stmt
3489
-
3489
+
3490
3490
  result
3491
3491
  end
3492
3492
 
@@ -3496,7 +3496,7 @@ end
3496
3496
 
3497
3497
  def _reduce_6(val, _values, result)
3498
3498
  result = self.block_append val[0], val[2]
3499
-
3499
+
3500
3500
  result
3501
3501
  end
3502
3502
 
@@ -3510,7 +3510,7 @@ def _reduce_9(val, _values, result)
3510
3510
  yyerror "BEGIN in method"
3511
3511
  end
3512
3512
  self.env.extend
3513
-
3513
+
3514
3514
  result
3515
3515
  end
3516
3516
 
@@ -3522,26 +3522,26 @@ def _reduce_10(val, _values, result)
3522
3522
  preexe.line lineno
3523
3523
 
3524
3524
  result = iter
3525
-
3525
+
3526
3526
  result
3527
3527
  end
3528
3528
 
3529
3529
  def _reduce_11(val, _values, result)
3530
- result = lexer.lineno
3530
+ result = lexer.lineno
3531
3531
  result
3532
3532
  end
3533
3533
 
3534
3534
  def _reduce_12(val, _values, result)
3535
3535
  _, line, stmt, _ = val
3536
3536
  result = new_iter s(:preexe).line(line), 0, stmt
3537
-
3537
+
3538
3538
  result
3539
3539
  end
3540
3540
 
3541
3541
  def _reduce_13(val, _values, result)
3542
3542
  res = _values[-2]
3543
3543
  yyerror "else without rescue is useless" unless res
3544
-
3544
+
3545
3545
  result
3546
3546
  end
3547
3547
 
@@ -3549,7 +3549,7 @@ def _reduce_14(val, _values, result)
3549
3549
  body, resc, _, _, els, ens = val
3550
3550
 
3551
3551
  result = new_body [body, resc, els, ens]
3552
-
3552
+
3553
3553
  result
3554
3554
  end
3555
3555
 
@@ -3557,13 +3557,13 @@ def _reduce_15(val, _values, result)
3557
3557
  body, resc, ens = val
3558
3558
 
3559
3559
  result = new_body [body, resc, nil, ens]
3560
-
3560
+
3561
3561
  result
3562
3562
  end
3563
3563
 
3564
3564
  def _reduce_16(val, _values, result)
3565
3565
  result = new_compstmt val
3566
-
3566
+
3567
3567
  result
3568
3568
  end
3569
3569
 
@@ -3573,14 +3573,14 @@ end
3573
3573
 
3574
3574
  def _reduce_19(val, _values, result)
3575
3575
  result = self.block_append val[0], val[2]
3576
-
3576
+
3577
3577
  result
3578
3578
  end
3579
3579
 
3580
3580
  def _reduce_20(val, _values, result)
3581
3581
  result = val[1]
3582
3582
  debug20 2, val, result
3583
-
3583
+
3584
3584
  result
3585
3585
  end
3586
3586
 
@@ -3588,74 +3588,74 @@ end
3588
3588
 
3589
3589
  def _reduce_22(val, _values, result)
3590
3590
  yyerror "BEGIN is permitted only at toplevel"
3591
-
3591
+
3592
3592
  result
3593
3593
  end
3594
3594
 
3595
3595
  def _reduce_23(val, _values, result)
3596
3596
  lexer.lex_state = EXPR_FNAME
3597
-
3597
+
3598
3598
  result
3599
3599
  end
3600
3600
 
3601
3601
  def _reduce_24(val, _values, result)
3602
3602
  (_, line), lhs, _, rhs = val
3603
3603
  result = s(:alias, lhs, rhs).line(line).line line
3604
-
3604
+
3605
3605
  result
3606
3606
  end
3607
3607
 
3608
3608
  def _reduce_25(val, _values, result)
3609
3609
  (_, line), lhs, rhs = val
3610
3610
  result = s(:valias, lhs.to_sym, rhs.to_sym).line line
3611
-
3611
+
3612
3612
  result
3613
3613
  end
3614
3614
 
3615
3615
  def _reduce_26(val, _values, result)
3616
3616
  (_, line), lhs, rhs = val
3617
3617
  result = s(:valias, lhs.to_sym, :"$#{rhs}").line line
3618
-
3618
+
3619
3619
  result
3620
3620
  end
3621
3621
 
3622
3622
  def _reduce_27(val, _values, result)
3623
3623
  yyerror "can't make alias for the number variables"
3624
-
3624
+
3625
3625
  result
3626
3626
  end
3627
3627
 
3628
3628
  def _reduce_28(val, _values, result)
3629
3629
  result = val[1]
3630
-
3630
+
3631
3631
  result
3632
3632
  end
3633
3633
 
3634
3634
  def _reduce_29(val, _values, result)
3635
3635
  t, _, c = val
3636
3636
  result = new_if c, t, nil
3637
-
3637
+
3638
3638
  result
3639
3639
  end
3640
3640
 
3641
3641
  def _reduce_30(val, _values, result)
3642
3642
  f, _, c = val
3643
3643
  result = new_if c, nil, f
3644
-
3644
+
3645
3645
  result
3646
3646
  end
3647
3647
 
3648
3648
  def _reduce_31(val, _values, result)
3649
3649
  e, _, c = val
3650
3650
  result = new_while e, c, true
3651
-
3651
+
3652
3652
  result
3653
3653
  end
3654
3654
 
3655
3655
  def _reduce_32(val, _values, result)
3656
3656
  e, _, c = val
3657
3657
  result = new_until e, c, true
3658
-
3658
+
3659
3659
  result
3660
3660
  end
3661
3661
 
@@ -3664,7 +3664,7 @@ def _reduce_33(val, _values, result)
3664
3664
 
3665
3665
  resbody = new_resbody s(:array).line(resbody.line), resbody
3666
3666
  result = new_rescue body, resbody
3667
-
3667
+
3668
3668
  result
3669
3669
  end
3670
3670
 
@@ -3677,7 +3677,7 @@ def _reduce_34(val, _values, result)
3677
3677
  end
3678
3678
 
3679
3679
  result = new_iter s(:postexe).line(line), 0, stmt
3680
-
3680
+
3681
3681
  result
3682
3682
  end
3683
3683
 
@@ -3685,26 +3685,26 @@ end
3685
3685
 
3686
3686
  def _reduce_36(val, _values, result)
3687
3687
  result = new_masgn val[0], val[2], :wrap
3688
-
3688
+
3689
3689
  result
3690
3690
  end
3691
3691
 
3692
3692
  def _reduce_37(val, _values, result)
3693
3693
  lhs, _, rhs = val
3694
3694
  result = new_assign lhs, s(:svalue, rhs).line(rhs.line)
3695
-
3695
+
3696
3696
  result
3697
3697
  end
3698
3698
 
3699
3699
  def _reduce_38(val, _values, result)
3700
3700
  result = new_masgn val[0], val[2], :wrap
3701
-
3701
+
3702
3702
  result
3703
3703
  end
3704
3704
 
3705
3705
  def _reduce_39(val, _values, result)
3706
3706
  result = new_masgn val[0], val[2]
3707
-
3707
+
3708
3708
  result
3709
3709
  end
3710
3710
 
@@ -3712,19 +3712,19 @@ end
3712
3712
 
3713
3713
  def _reduce_41(val, _values, result)
3714
3714
  result = new_assign val[0], val[2]
3715
-
3715
+
3716
3716
  result
3717
3717
  end
3718
3718
 
3719
3719
  def _reduce_42(val, _values, result)
3720
3720
  result = new_op_asgn val
3721
-
3721
+
3722
3722
  result
3723
3723
  end
3724
3724
 
3725
3725
  def _reduce_43(val, _values, result)
3726
3726
  result = new_op_asgn1 val
3727
-
3727
+
3728
3728
  result
3729
3729
  end
3730
3730
 
@@ -3735,7 +3735,7 @@ def _reduce_44(val, _values, result)
3735
3735
  result.sexp_type = :safe_op_asgn
3736
3736
  end
3737
3737
  result.line = val[0].line
3738
-
3738
+
3739
3739
  result
3740
3740
  end
3741
3741
 
@@ -3745,34 +3745,34 @@ def _reduce_45(val, _values, result)
3745
3745
  result.sexp_type = :safe_op_asgn
3746
3746
  end
3747
3747
  result.line = val[0].line
3748
-
3748
+
3749
3749
  result
3750
3750
  end
3751
3751
 
3752
3752
  def _reduce_46(val, _values, result)
3753
3753
  result = s(:op_asgn, val[0], val[4], val[2], val[3])
3754
3754
  debug20 4, val, result
3755
-
3755
+
3756
3756
  result
3757
3757
  end
3758
3758
 
3759
3759
  def _reduce_47(val, _values, result)
3760
3760
  result = s(:op_asgn, val[0], val[4], val[2], val[3])
3761
3761
  debug20 5, val, result
3762
-
3762
+
3763
3763
  result
3764
3764
  end
3765
3765
 
3766
3766
  def _reduce_48(val, _values, result)
3767
3767
  self.backref_assign_error val[0]
3768
-
3768
+
3769
3769
  result
3770
3770
  end
3771
3771
 
3772
3772
  def _reduce_49(val, _values, result)
3773
3773
  expr, = val
3774
3774
  result = value_expr expr
3775
-
3775
+
3776
3776
  result
3777
3777
  end
3778
3778
 
@@ -3783,14 +3783,14 @@ end
3783
3783
  def _reduce_52(val, _values, result)
3784
3784
  lhs, _, rhs = val
3785
3785
  result = logical_op :and, lhs, rhs
3786
-
3786
+
3787
3787
  result
3788
3788
  end
3789
3789
 
3790
3790
  def _reduce_53(val, _values, result)
3791
3791
  lhs, _, rhs = val
3792
3792
  result = logical_op :or, lhs, rhs
3793
-
3793
+
3794
3794
  result
3795
3795
  end
3796
3796
 
@@ -3798,7 +3798,7 @@ def _reduce_54(val, _values, result)
3798
3798
  (_, line), _, expr = val
3799
3799
  result = new_call(expr, :"!").line line
3800
3800
  # REFACTOR: call_uni_op
3801
-
3801
+
3802
3802
  result
3803
3803
  end
3804
3804
 
@@ -3807,7 +3807,7 @@ def _reduce_55(val, _values, result)
3807
3807
  result = new_call(cmd, :"!").line cmd.line
3808
3808
  # TODO: fix line number to tBANG... but causes BAD shift/reduce conflict
3809
3809
  # REFACTOR: call_uni_op -- see parse26.y
3810
-
3810
+
3811
3811
  result
3812
3812
  end
3813
3813
 
@@ -3815,26 +3815,26 @@ end
3815
3815
 
3816
3816
  def _reduce_57(val, _values, result)
3817
3817
  result = value_expr(val[0])
3818
-
3818
+
3819
3819
  result
3820
3820
  end
3821
3821
 
3822
3822
  def _reduce_58(val, _values, result)
3823
3823
  lexer.cond.push true
3824
-
3824
+
3825
3825
  result
3826
3826
  end
3827
3827
 
3828
3828
  def _reduce_59(val, _values, result)
3829
3829
  lexer.cond.pop
3830
-
3830
+
3831
3831
  result
3832
3832
  end
3833
3833
 
3834
3834
  def _reduce_60(val, _values, result)
3835
3835
  _, expr, _, _ = val
3836
3836
  result = expr
3837
-
3837
+
3838
3838
  result
3839
3839
  end
3840
3840
 
@@ -3847,14 +3847,14 @@ end
3847
3847
  def _reduce_64(val, _values, result)
3848
3848
  blk, _, msg, args = val
3849
3849
  result = new_call(blk, msg.to_sym, args).line blk.line
3850
-
3850
+
3851
3851
  result
3852
3852
  end
3853
3853
 
3854
3854
  def _reduce_65(val, _values, result)
3855
3855
  # self.env.extend(:dynamic)
3856
3856
  result = self.lexer.lineno
3857
-
3857
+
3858
3858
  result
3859
3859
  end
3860
3860
 
@@ -3865,21 +3865,21 @@ def _reduce_66(val, _values, result)
3865
3865
  result.line = line
3866
3866
 
3867
3867
  # self.env.unextend
3868
-
3868
+
3869
3869
  result
3870
3870
  end
3871
3871
 
3872
3872
  def _reduce_67(val, _values, result)
3873
3873
  msg, = val
3874
3874
  result = new_call(nil, msg.to_sym).line lexer.lineno
3875
-
3875
+
3876
3876
  result
3877
3877
  end
3878
3878
 
3879
3879
  def _reduce_68(val, _values, result)
3880
3880
  call, args = val
3881
3881
  result = call.concat args.sexp_body
3882
-
3882
+
3883
3883
  result
3884
3884
  end
3885
3885
 
@@ -3894,14 +3894,14 @@ def _reduce_69(val, _values, result)
3894
3894
  result, operation = block, result
3895
3895
  result.insert 1, operation
3896
3896
  end
3897
-
3897
+
3898
3898
  result
3899
3899
  end
3900
3900
 
3901
3901
  def _reduce_70(val, _values, result)
3902
3902
  lhs, callop, op, args = val
3903
3903
  result = new_call lhs, op.to_sym, args, callop
3904
-
3904
+
3905
3905
  result
3906
3906
  end
3907
3907
 
@@ -3913,13 +3913,13 @@ def _reduce_71(val, _values, result)
3913
3913
 
3914
3914
  block.insert 1, call
3915
3915
  result = block
3916
-
3916
+
3917
3917
  result
3918
3918
  end
3919
3919
 
3920
3920
  def _reduce_72(val, _values, result)
3921
3921
  result = new_call val[0], val[2].to_sym, val[3]
3922
-
3922
+
3923
3923
  result
3924
3924
  end
3925
3925
 
@@ -3931,13 +3931,13 @@ def _reduce_73(val, _values, result)
3931
3931
 
3932
3932
  block.insert 1, call
3933
3933
  result = block
3934
-
3934
+
3935
3935
  result
3936
3936
  end
3937
3937
 
3938
3938
  def _reduce_74(val, _values, result)
3939
3939
  result = new_super val[1]
3940
-
3940
+
3941
3941
  result
3942
3942
  end
3943
3943
 
@@ -3945,28 +3945,28 @@ def _reduce_75(val, _values, result)
3945
3945
  (_, line), args = val
3946
3946
  result = new_yield args
3947
3947
  result.line line # TODO: push to new_yield
3948
-
3948
+
3949
3949
  result
3950
3950
  end
3951
3951
 
3952
3952
  def _reduce_76(val, _values, result)
3953
3953
  line = val[0].last
3954
3954
  result = s(:return, ret_args(val[1])).line(line)
3955
-
3955
+
3956
3956
  result
3957
3957
  end
3958
3958
 
3959
3959
  def _reduce_77(val, _values, result)
3960
3960
  (_, line), args = val
3961
3961
  result = s(:break, ret_args(args)).line line
3962
-
3962
+
3963
3963
  result
3964
3964
  end
3965
3965
 
3966
3966
  def _reduce_78(val, _values, result)
3967
3967
  line = val[0].last
3968
3968
  result = s(:next, ret_args(val[1])).line(line)
3969
-
3969
+
3970
3970
  result
3971
3971
  end
3972
3972
 
@@ -3974,7 +3974,7 @@ end
3974
3974
 
3975
3975
  def _reduce_80(val, _values, result)
3976
3976
  result = val[1]
3977
-
3977
+
3978
3978
  result
3979
3979
  end
3980
3980
 
@@ -3985,21 +3985,21 @@ def _reduce_82(val, _values, result)
3985
3985
  l = arg.line
3986
3986
 
3987
3987
  result = s(:masgn, s(:array, arg).line(l)).line l
3988
-
3988
+
3989
3989
  result
3990
3990
  end
3991
3991
 
3992
3992
  def _reduce_83(val, _values, result)
3993
3993
  head, = val
3994
3994
  result = s(:masgn, head).line head.line
3995
-
3995
+
3996
3996
  result
3997
3997
  end
3998
3998
 
3999
3999
  def _reduce_84(val, _values, result)
4000
4000
  lhs, rhs = val
4001
4001
  result = s(:masgn, lhs << rhs.compact).line lhs.line
4002
-
4002
+
4003
4003
  result
4004
4004
  end
4005
4005
 
@@ -4007,7 +4007,7 @@ def _reduce_85(val, _values, result)
4007
4007
  head, _, tail = val
4008
4008
  head << s(:splat, tail).line(tail.line)
4009
4009
  result = s(:masgn, head).line head.line
4010
-
4010
+
4011
4011
  result
4012
4012
  end
4013
4013
 
@@ -4017,7 +4017,7 @@ def _reduce_86(val, _values, result)
4017
4017
  result = list_append ary1, s(:splat, splat).line(splat.line)
4018
4018
  result.concat ary2.sexp_body
4019
4019
  result = s(:masgn, result).line result.line
4020
-
4020
+
4021
4021
  result
4022
4022
  end
4023
4023
 
@@ -4025,7 +4025,7 @@ def _reduce_87(val, _values, result)
4025
4025
  head, _ = val
4026
4026
  l = head.line
4027
4027
  result = s(:masgn, head << s(:splat).line(l)).line l
4028
-
4028
+
4029
4029
  result
4030
4030
  end
4031
4031
 
@@ -4034,7 +4034,7 @@ def _reduce_88(val, _values, result)
4034
4034
  ary = list_append head, s(:splat).line(head.line)
4035
4035
  ary.concat post.sexp_body
4036
4036
  result = s(:masgn, ary).line ary.line
4037
-
4037
+
4038
4038
  result
4039
4039
  end
4040
4040
 
@@ -4044,7 +4044,7 @@ def _reduce_89(val, _values, result)
4044
4044
  splat = s(:splat, node).line l
4045
4045
  ary = s(:array, splat).line l
4046
4046
  result = s(:masgn, ary).line l
4047
-
4047
+
4048
4048
  result
4049
4049
  end
4050
4050
 
@@ -4055,14 +4055,14 @@ def _reduce_90(val, _values, result)
4055
4055
  ary = s(:array, splat).line splat.line
4056
4056
  ary.concat post.sexp_body
4057
4057
  result = s(:masgn, ary).line ary.line
4058
-
4058
+
4059
4059
  result
4060
4060
  end
4061
4061
 
4062
4062
  def _reduce_91(val, _values, result)
4063
4063
  l = lexer.lineno
4064
4064
  result = s(:masgn, s(:array, s(:splat).line(l)).line(l)).line l
4065
-
4065
+
4066
4066
  result
4067
4067
  end
4068
4068
 
@@ -4073,7 +4073,7 @@ def _reduce_92(val, _values, result)
4073
4073
  splat = s(:splat).line l
4074
4074
  ary = s(:array, splat, *post.sexp_body).line l
4075
4075
  result = s(:masgn, ary).line l
4076
-
4076
+
4077
4077
  result
4078
4078
  end
4079
4079
 
@@ -4081,70 +4081,70 @@ end
4081
4081
 
4082
4082
  def _reduce_94(val, _values, result)
4083
4083
  result = val[1]
4084
-
4084
+
4085
4085
  result
4086
4086
  end
4087
4087
 
4088
4088
  def _reduce_95(val, _values, result)
4089
4089
  lhs, _ = val
4090
4090
  result = s(:array, lhs).line lhs.line
4091
-
4091
+
4092
4092
  result
4093
4093
  end
4094
4094
 
4095
4095
  def _reduce_96(val, _values, result)
4096
4096
  result = val[0] << val[1].compact
4097
-
4097
+
4098
4098
  result
4099
4099
  end
4100
4100
 
4101
4101
  def _reduce_97(val, _values, result)
4102
4102
  item, = val
4103
4103
  result = s(:array, item).line item.line
4104
-
4104
+
4105
4105
  result
4106
4106
  end
4107
4107
 
4108
4108
  def _reduce_98(val, _values, result)
4109
4109
  result = list_append val[0], val[2]
4110
-
4110
+
4111
4111
  result
4112
4112
  end
4113
4113
 
4114
4114
  def _reduce_99(val, _values, result)
4115
4115
  result = self.assignable val[0]
4116
-
4116
+
4117
4117
  result
4118
4118
  end
4119
4119
 
4120
4120
  def _reduce_100(val, _values, result)
4121
4121
  result = self.assignable val[0]
4122
-
4122
+
4123
4123
  result
4124
4124
  end
4125
4125
 
4126
4126
  def _reduce_101(val, _values, result)
4127
4127
  result = self.aryset val[0], val[2]
4128
-
4128
+
4129
4129
  result
4130
4130
  end
4131
4131
 
4132
4132
  def _reduce_102(val, _values, result)
4133
4133
  result = new_attrasgn val[0], val[2], val[1]
4134
-
4134
+
4135
4135
  result
4136
4136
  end
4137
4137
 
4138
4138
  def _reduce_103(val, _values, result)
4139
4139
  recv, _, id = val
4140
4140
  result = new_attrasgn recv, id
4141
-
4141
+
4142
4142
  result
4143
4143
  end
4144
4144
 
4145
4145
  def _reduce_104(val, _values, result)
4146
4146
  result = new_attrasgn val[0], val[2], val[1]
4147
-
4147
+
4148
4148
  result
4149
4149
  end
4150
4150
 
@@ -4158,7 +4158,7 @@ def _reduce_105(val, _values, result)
4158
4158
  l = expr.line
4159
4159
 
4160
4160
  result = s(:const, s(:colon2, expr, id.to_sym).line(l), nil).line l
4161
-
4161
+
4162
4162
  result
4163
4163
  end
4164
4164
 
@@ -4172,13 +4172,13 @@ def _reduce_106(val, _values, result)
4172
4172
  l = lexer.lineno
4173
4173
 
4174
4174
  result = s(:const, nil, s(:colon3, id.to_sym).line(l)).line l
4175
-
4175
+
4176
4176
  result
4177
4177
  end
4178
4178
 
4179
4179
  def _reduce_107(val, _values, result)
4180
4180
  self.backref_assign_error val[0]
4181
-
4181
+
4182
4182
  result
4183
4183
  end
4184
4184
 
@@ -4186,7 +4186,7 @@ def _reduce_108(val, _values, result)
4186
4186
  line = lexer.lineno
4187
4187
  result = self.assignable val[0]
4188
4188
  result.line = line
4189
-
4189
+
4190
4190
  result
4191
4191
  end
4192
4192
 
@@ -4195,34 +4195,34 @@ def _reduce_109(val, _values, result)
4195
4195
  result = self.assignable val[0]
4196
4196
  result.line = line
4197
4197
  debug20 9, val, result
4198
-
4198
+
4199
4199
  result
4200
4200
  end
4201
4201
 
4202
4202
  def _reduce_110(val, _values, result)
4203
4203
  lhs, _, args, _ = val
4204
4204
  result = self.aryset lhs, args
4205
-
4205
+
4206
4206
  result
4207
4207
  end
4208
4208
 
4209
4209
  def _reduce_111(val, _values, result)
4210
4210
  lhs, op, id = val
4211
4211
  result = new_attrasgn lhs, id, op
4212
-
4212
+
4213
4213
  result
4214
4214
  end
4215
4215
 
4216
4216
  def _reduce_112(val, _values, result)
4217
4217
  lhs, _, id = val
4218
4218
  result = new_attrasgn lhs, id
4219
-
4219
+
4220
4220
  result
4221
4221
  end
4222
4222
 
4223
4223
  def _reduce_113(val, _values, result)
4224
4224
  result = new_attrasgn val[0], val[2], val[1]
4225
-
4225
+
4226
4226
  result
4227
4227
  end
4228
4228
 
@@ -4236,7 +4236,7 @@ def _reduce_114(val, _values, result)
4236
4236
 
4237
4237
  l = expr.line
4238
4238
  result = s(:const, s(:colon2, expr, id.to_sym).line(l)).line l
4239
-
4239
+
4240
4240
  result
4241
4241
  end
4242
4242
 
@@ -4250,19 +4250,19 @@ def _reduce_115(val, _values, result)
4250
4250
 
4251
4251
  l = lexer.lineno
4252
4252
  result = s(:const, s(:colon3, id.to_sym).line(l)).line l
4253
-
4253
+
4254
4254
  result
4255
4255
  end
4256
4256
 
4257
4257
  def _reduce_116(val, _values, result)
4258
4258
  self.backref_assign_error val[0]
4259
-
4259
+
4260
4260
  result
4261
4261
  end
4262
4262
 
4263
4263
  def _reduce_117(val, _values, result)
4264
4264
  yyerror "class/module name must be CONSTANT"
4265
-
4265
+
4266
4266
  result
4267
4267
  end
4268
4268
 
@@ -4271,13 +4271,13 @@ end
4271
4271
  def _reduce_119(val, _values, result)
4272
4272
  _, name = val
4273
4273
  result = s(:colon3, name.to_sym).line lexer.lineno
4274
-
4274
+
4275
4275
  result
4276
4276
  end
4277
4277
 
4278
4278
  def _reduce_120(val, _values, result)
4279
4279
  result = val[0].to_sym
4280
-
4280
+
4281
4281
  result
4282
4282
  end
4283
4283
 
@@ -4286,7 +4286,7 @@ def _reduce_121(val, _values, result)
4286
4286
 
4287
4287
  result = s(:colon2, pval, name.to_sym)
4288
4288
  result.line pval.line
4289
-
4289
+
4290
4290
  result
4291
4291
  end
4292
4292
 
@@ -4299,7 +4299,7 @@ end
4299
4299
  def _reduce_125(val, _values, result)
4300
4300
  lexer.lex_state = EXPR_END
4301
4301
  result = val[0]
4302
-
4302
+
4303
4303
  result
4304
4304
  end
4305
4305
 
@@ -4307,7 +4307,7 @@ def _reduce_126(val, _values, result)
4307
4307
  (sym, _line), = val
4308
4308
  lexer.lex_state = EXPR_END
4309
4309
  result = sym
4310
-
4310
+
4311
4311
  result
4312
4312
  end
4313
4313
 
@@ -4318,7 +4318,7 @@ end
4318
4318
  def _reduce_129(val, _values, result)
4319
4319
  id, = val
4320
4320
  result = s(:lit, id.to_sym).line lexer.lineno
4321
-
4321
+
4322
4322
  result
4323
4323
  end
4324
4324
 
@@ -4326,19 +4326,19 @@ end
4326
4326
 
4327
4327
  def _reduce_131(val, _values, result)
4328
4328
  result = new_undef val[0]
4329
-
4329
+
4330
4330
  result
4331
4331
  end
4332
4332
 
4333
4333
  def _reduce_132(val, _values, result)
4334
4334
  lexer.lex_state = EXPR_FNAME
4335
-
4335
+
4336
4336
  result
4337
4337
  end
4338
4338
 
4339
4339
  def _reduce_133(val, _values, result)
4340
4340
  result = new_undef val[0], val[3]
4341
-
4341
+
4342
4342
  result
4343
4343
  end
4344
4344
 
@@ -4488,31 +4488,31 @@ end
4488
4488
 
4489
4489
  def _reduce_206(val, _values, result)
4490
4490
  result = new_assign val[0], val[2]
4491
-
4491
+
4492
4492
  result
4493
4493
  end
4494
4494
 
4495
4495
  def _reduce_207(val, _values, result)
4496
4496
  result = new_op_asgn val
4497
-
4497
+
4498
4498
  result
4499
4499
  end
4500
4500
 
4501
4501
  def _reduce_208(val, _values, result)
4502
4502
  result = new_op_asgn1 val
4503
-
4503
+
4504
4504
  result
4505
4505
  end
4506
4506
 
4507
4507
  def _reduce_209(val, _values, result)
4508
4508
  result = new_op_asgn2 val
4509
-
4509
+
4510
4510
  result
4511
4511
  end
4512
4512
 
4513
4513
  def _reduce_210(val, _values, result)
4514
4514
  result = new_op_asgn2 val
4515
-
4515
+
4516
4516
  result
4517
4517
  end
4518
4518
 
@@ -4520,7 +4520,7 @@ def _reduce_211(val, _values, result)
4520
4520
  lhs, _, id, op, rhs = val
4521
4521
 
4522
4522
  result = s(:op_asgn, lhs, rhs, id.to_sym, op.to_sym).line lhs.line
4523
-
4523
+
4524
4524
  result
4525
4525
  end
4526
4526
 
@@ -4529,13 +4529,13 @@ def _reduce_212(val, _values, result)
4529
4529
 
4530
4530
  lhs = s(:colon2, lhs1, lhs2.to_sym).line lhs1.line
4531
4531
  result = new_const_op_asgn [lhs, op, rhs]
4532
-
4532
+
4533
4533
  result
4534
4534
  end
4535
4535
 
4536
4536
  def _reduce_213(val, _values, result)
4537
4537
  result = self.lexer.lineno
4538
-
4538
+
4539
4539
  result
4540
4540
  end
4541
4541
 
@@ -4544,7 +4544,7 @@ def _reduce_214(val, _values, result)
4544
4544
 
4545
4545
  lhs = s(:colon3, lhs.to_sym).line line
4546
4546
  result = new_const_op_asgn [lhs, op, rhs]
4547
-
4547
+
4548
4548
  result
4549
4549
  end
4550
4550
 
@@ -4552,7 +4552,7 @@ def _reduce_215(val, _values, result)
4552
4552
  # TODO: lhs = var_field val[0]
4553
4553
  asgn = new_op_asgn val
4554
4554
  result = self.backref_assign_error asgn
4555
-
4555
+
4556
4556
  result
4557
4557
  end
4558
4558
 
@@ -4563,7 +4563,7 @@ def _reduce_216(val, _values, result)
4563
4563
  else
4564
4564
  result = s(:dot2, v1, v2).line v1.line
4565
4565
  end
4566
-
4566
+
4567
4567
  result
4568
4568
  end
4569
4569
 
@@ -4574,50 +4574,50 @@ def _reduce_217(val, _values, result)
4574
4574
  else
4575
4575
  result = s(:dot3, v1, v2).line v1.line
4576
4576
  end
4577
-
4577
+
4578
4578
  result
4579
4579
  end
4580
4580
 
4581
4581
  def _reduce_218(val, _values, result)
4582
4582
  result = new_call val[0], :+, argl(val[2])
4583
-
4583
+
4584
4584
  result
4585
4585
  end
4586
4586
 
4587
4587
  def _reduce_219(val, _values, result)
4588
4588
  result = new_call val[0], :-, argl(val[2])
4589
-
4589
+
4590
4590
  result
4591
4591
  end
4592
4592
 
4593
4593
  def _reduce_220(val, _values, result)
4594
4594
  result = new_call val[0], :*, argl(val[2])
4595
-
4595
+
4596
4596
  result
4597
4597
  end
4598
4598
 
4599
4599
  def _reduce_221(val, _values, result)
4600
4600
  result = new_call val[0], :"/", argl(val[2])
4601
-
4601
+
4602
4602
  result
4603
4603
  end
4604
4604
 
4605
4605
  def _reduce_222(val, _values, result)
4606
4606
  result = new_call val[0], :"%", argl(val[2])
4607
-
4607
+
4608
4608
  result
4609
4609
  end
4610
4610
 
4611
4611
  def _reduce_223(val, _values, result)
4612
4612
  result = new_call val[0], :**, argl(val[2])
4613
-
4613
+
4614
4614
  result
4615
4615
  end
4616
4616
 
4617
4617
  def _reduce_224(val, _values, result)
4618
4618
  lit = s(:lit, val[1]).line lexer.lineno
4619
4619
  result = new_call(new_call(lit, :"**", argl(val[3])), :"-@")
4620
-
4620
+
4621
4621
  result
4622
4622
  end
4623
4623
 
@@ -4627,43 +4627,43 @@ def _reduce_225(val, _values, result)
4627
4627
 
4628
4628
  ## TODO: why is this 2.0 only?
4629
4629
  debug20 12, val, result
4630
-
4630
+
4631
4631
  result
4632
4632
  end
4633
4633
 
4634
4634
  def _reduce_226(val, _values, result)
4635
4635
  result = new_call val[1], :"+@"
4636
-
4636
+
4637
4637
  result
4638
4638
  end
4639
4639
 
4640
4640
  def _reduce_227(val, _values, result)
4641
4641
  result = new_call val[1], :"-@"
4642
-
4642
+
4643
4643
  result
4644
4644
  end
4645
4645
 
4646
4646
  def _reduce_228(val, _values, result)
4647
4647
  result = new_call val[0], :"|", argl(val[2])
4648
-
4648
+
4649
4649
  result
4650
4650
  end
4651
4651
 
4652
4652
  def _reduce_229(val, _values, result)
4653
4653
  result = new_call val[0], :"^", argl(val[2])
4654
-
4654
+
4655
4655
  result
4656
4656
  end
4657
4657
 
4658
4658
  def _reduce_230(val, _values, result)
4659
4659
  result = new_call val[0], :"&", argl(val[2])
4660
-
4660
+
4661
4661
  result
4662
4662
  end
4663
4663
 
4664
4664
  def _reduce_231(val, _values, result)
4665
4665
  result = new_call val[0], :"<=>", argl(val[2])
4666
-
4666
+
4667
4667
  result
4668
4668
  end
4669
4669
 
@@ -4671,33 +4671,33 @@ end
4671
4671
 
4672
4672
  def _reduce_233(val, _values, result)
4673
4673
  result = new_call val[0], :"==", argl(val[2])
4674
-
4674
+
4675
4675
  result
4676
4676
  end
4677
4677
 
4678
4678
  def _reduce_234(val, _values, result)
4679
4679
  result = new_call val[0], :"===", argl(val[2])
4680
-
4680
+
4681
4681
  result
4682
4682
  end
4683
4683
 
4684
4684
  def _reduce_235(val, _values, result)
4685
4685
  result = new_call val[0], :"!=", argl(val[2])
4686
-
4686
+
4687
4687
  result
4688
4688
  end
4689
4689
 
4690
4690
  def _reduce_236(val, _values, result)
4691
4691
  lhs, _, rhs = val
4692
4692
  result = new_match lhs, rhs
4693
-
4693
+
4694
4694
  result
4695
4695
  end
4696
4696
 
4697
4697
  def _reduce_237(val, _values, result)
4698
4698
  lhs, _, rhs = val
4699
4699
  result = s(:not, new_match(lhs, rhs)).line lhs.line
4700
-
4700
+
4701
4701
  result
4702
4702
  end
4703
4703
 
@@ -4705,13 +4705,13 @@ def _reduce_238(val, _values, result)
4705
4705
  _, arg = val
4706
4706
  result = new_call arg, :"!"
4707
4707
  result.line arg.line
4708
-
4708
+
4709
4709
  result
4710
4710
  end
4711
4711
 
4712
4712
  def _reduce_239(val, _values, result)
4713
4713
  result = new_call value_expr(val[1]), :"~"
4714
-
4714
+
4715
4715
  result
4716
4716
  end
4717
4717
 
@@ -4719,7 +4719,7 @@ def _reduce_240(val, _values, result)
4719
4719
  val[0] = value_expr val[0]
4720
4720
  val[2] = value_expr val[2]
4721
4721
  result = new_call val[0], :"\<\<", argl(val[2])
4722
-
4722
+
4723
4723
  result
4724
4724
  end
4725
4725
 
@@ -4727,33 +4727,33 @@ def _reduce_241(val, _values, result)
4727
4727
  val[0] = value_expr val[0]
4728
4728
  val[2] = value_expr val[2]
4729
4729
  result = new_call val[0], :">>", argl(val[2])
4730
-
4730
+
4731
4731
  result
4732
4732
  end
4733
4733
 
4734
4734
  def _reduce_242(val, _values, result)
4735
4735
  result = logical_op :and, val[0], val[2]
4736
-
4736
+
4737
4737
  result
4738
4738
  end
4739
4739
 
4740
4740
  def _reduce_243(val, _values, result)
4741
4741
  result = logical_op :or, val[0], val[2]
4742
-
4742
+
4743
4743
  result
4744
4744
  end
4745
4745
 
4746
4746
  def _reduce_244(val, _values, result)
4747
4747
  (_, line), _, arg = val
4748
4748
  result = s(:defined, arg).line line
4749
-
4749
+
4750
4750
  result
4751
4751
  end
4752
4752
 
4753
4753
  def _reduce_245(val, _values, result)
4754
4754
  c, _, t, _, _, f = val
4755
4755
  result = s(:if, c, t, f).line c.line
4756
-
4756
+
4757
4757
  result
4758
4758
  end
4759
4759
 
@@ -4770,7 +4770,7 @@ end
4770
4770
  def _reduce_251(val, _values, result)
4771
4771
  lhs, op, rhs = val
4772
4772
  result = new_call lhs, op.to_sym, argl(rhs)
4773
-
4773
+
4774
4774
  result
4775
4775
  end
4776
4776
 
@@ -4778,13 +4778,13 @@ def _reduce_252(val, _values, result)
4778
4778
  lhs, op, rhs = val
4779
4779
  warn "comparison '%s' after comparison", op
4780
4780
  result = new_call lhs, op.to_sym, argl(rhs)
4781
-
4781
+
4782
4782
  result
4783
4783
  end
4784
4784
 
4785
4785
  def _reduce_253(val, _values, result)
4786
4786
  result = value_expr(val[0])
4787
-
4787
+
4788
4788
  result
4789
4789
  end
4790
4790
 
@@ -4792,19 +4792,19 @@ end
4792
4792
 
4793
4793
  def _reduce_255(val, _values, result)
4794
4794
  result = args [val[0]]
4795
-
4795
+
4796
4796
  result
4797
4797
  end
4798
4798
 
4799
4799
  def _reduce_256(val, _values, result)
4800
4800
  result = args [val[0], array_to_hash(val[2])]
4801
-
4801
+
4802
4802
  result
4803
4803
  end
4804
4804
 
4805
4805
  def _reduce_257(val, _values, result)
4806
4806
  result = args [array_to_hash(val[0])]
4807
-
4807
+
4808
4808
  result
4809
4809
  end
4810
4810
 
@@ -4817,14 +4817,14 @@ def _reduce_259(val, _values, result)
4817
4817
 
4818
4818
  ary = s(:array).line line
4819
4819
  result = new_rescue(body, new_resbody(ary, resbody))
4820
-
4820
+
4821
4821
  result
4822
4822
  end
4823
4823
 
4824
4824
  def _reduce_260(val, _values, result)
4825
4825
  _, args, _ = val
4826
4826
  result = args
4827
-
4827
+
4828
4828
  result
4829
4829
  end
4830
4830
 
@@ -4838,79 +4838,76 @@ end
4838
4838
 
4839
4839
  def _reduce_265(val, _values, result)
4840
4840
  result = args val
4841
-
4841
+
4842
4842
  result
4843
4843
  end
4844
4844
 
4845
4845
  def _reduce_266(val, _values, result)
4846
4846
  result = args [val[0], array_to_hash(val[2])]
4847
-
4847
+
4848
4848
  result
4849
4849
  end
4850
4850
 
4851
4851
  def _reduce_267(val, _values, result)
4852
4852
  result = args [array_to_hash(val[0])]
4853
-
4853
+
4854
4854
  result
4855
4855
  end
4856
4856
 
4857
4857
  def _reduce_268(val, _values, result)
4858
4858
  warning "parenthesize argument(s) for future version"
4859
4859
  result = call_args val
4860
-
4860
+
4861
4861
  result
4862
4862
  end
4863
4863
 
4864
4864
  def _reduce_269(val, _values, result)
4865
4865
  result = call_args val
4866
- result = self.arg_blk_pass val[0], val[1]
4867
-
4866
+
4868
4867
  result
4869
4868
  end
4870
4869
 
4871
4870
  def _reduce_270(val, _values, result)
4872
- result = call_args [array_to_hash(val[0])]
4873
- result = self.arg_blk_pass result, val[1]
4874
-
4871
+ result = call_args [array_to_hash(val[0]), val[1]]
4872
+
4875
4873
  result
4876
4874
  end
4877
4875
 
4878
4876
  def _reduce_271(val, _values, result)
4879
- result = call_args [val[0], array_to_hash(val[2])]
4880
- result = self.arg_blk_pass result, val[3]
4881
-
4877
+ result = call_args [val[0], array_to_hash(val[2]), val[3]]
4878
+
4882
4879
  result
4883
4880
  end
4884
4881
 
4885
4882
  def _reduce_272(val, _values, result)
4886
4883
  result = call_args val
4887
-
4884
+
4888
4885
  result
4889
4886
  end
4890
4887
 
4891
4888
  def _reduce_273(val, _values, result)
4892
4889
  result = lexer.cmdarg.store true
4893
-
4890
+
4894
4891
  result
4895
4892
  end
4896
4893
 
4897
4894
  def _reduce_274(val, _values, result)
4898
4895
  lexer.cmdarg.restore val[0]
4899
4896
  result = val[1]
4900
-
4897
+
4901
4898
  result
4902
4899
  end
4903
4900
 
4904
4901
  def _reduce_275(val, _values, result)
4905
4902
  _, arg = val
4906
4903
  result = s(:block_pass, arg).line arg.line
4907
-
4904
+
4908
4905
  result
4909
4906
  end
4910
4907
 
4911
4908
  def _reduce_276(val, _values, result)
4912
4909
  result = val[1]
4913
-
4910
+
4914
4911
  result
4915
4912
  end
4916
4913
 
@@ -4920,39 +4917,39 @@ def _reduce_278(val, _values, result)
4920
4917
  arg, = val
4921
4918
 
4922
4919
  result = s(:array, arg).line arg.line
4923
-
4920
+
4924
4921
  result
4925
4922
  end
4926
4923
 
4927
4924
  def _reduce_279(val, _values, result)
4928
4925
  _, arg = val
4929
4926
  result = s(:array, s(:splat, arg).line(arg.line)).line arg.line
4930
-
4927
+
4931
4928
  result
4932
4929
  end
4933
4930
 
4934
4931
  def _reduce_280(val, _values, result)
4935
4932
  args, _, id = val
4936
4933
  result = self.list_append args, id
4937
-
4934
+
4938
4935
  result
4939
4936
  end
4940
4937
 
4941
4938
  def _reduce_281(val, _values, result)
4942
- result = lexer.lineno
4939
+ result = lexer.lineno
4943
4940
  result
4944
4941
  end
4945
4942
 
4946
4943
  def _reduce_282(val, _values, result)
4947
4944
  args, _, _, line, id = val
4948
4945
  result = self.list_append args, s(:splat, id).line(line)
4949
-
4946
+
4950
4947
  result
4951
4948
  end
4952
4949
 
4953
4950
  def _reduce_283(val, _values, result)
4954
4951
  result = val[0] << val[2]
4955
-
4952
+
4956
4953
  result
4957
4954
  end
4958
4955
 
@@ -4961,14 +4958,14 @@ def _reduce_284(val, _values, result)
4961
4958
  # TODO: make all tXXXX terminals include lexer.lineno
4962
4959
  arg, _, _, splat = val
4963
4960
  result = self.arg_concat arg, splat
4964
-
4961
+
4965
4962
  result
4966
4963
  end
4967
4964
 
4968
4965
  def _reduce_285(val, _values, result)
4969
4966
  _, arg = val
4970
4967
  result = s(:splat, arg).line arg.line
4971
-
4968
+
4972
4969
  result
4973
4970
  end
4974
4971
 
@@ -4995,7 +4992,7 @@ end
4995
4992
  def _reduce_296(val, _values, result)
4996
4993
  msg, = val
4997
4994
  result = new_call nil, msg.to_sym
4998
-
4995
+
4999
4996
  result
5000
4997
  end
5001
4998
 
@@ -5004,7 +5001,7 @@ def _reduce_297(val, _values, result)
5004
5001
  # TODO:
5005
5002
  # $<val>1 = cmdarg_stack;
5006
5003
  # CMDARG_SET(0);
5007
-
5004
+
5008
5005
  result
5009
5006
  end
5010
5007
 
@@ -5017,33 +5014,33 @@ def _reduce_298(val, _values, result)
5017
5014
  end
5018
5015
 
5019
5016
  result.line = val[1]
5020
-
5017
+
5021
5018
  result
5022
5019
  end
5023
5020
 
5024
5021
  def _reduce_299(val, _values, result)
5025
5022
  lexer.lex_state = EXPR_ENDARG
5026
5023
  result = lexer.lineno
5027
-
5024
+
5028
5025
  result
5029
5026
  end
5030
5027
 
5031
5028
  def _reduce_300(val, _values, result)
5032
5029
  _, line, _ = val
5033
5030
  result = s(:begin).line line
5034
-
5031
+
5035
5032
  result
5036
5033
  end
5037
5034
 
5038
5035
  def _reduce_301(val, _values, result)
5039
5036
  result = lexer.cmdarg.store false
5040
-
5037
+
5041
5038
  result
5042
5039
  end
5043
5040
 
5044
5041
  def _reduce_302(val, _values, result)
5045
5042
  lexer.lex_state = EXPR_ENDARG
5046
-
5043
+
5047
5044
  result
5048
5045
  end
5049
5046
 
@@ -5052,7 +5049,7 @@ def _reduce_303(val, _values, result)
5052
5049
  warning "(...) interpreted as grouped expression"
5053
5050
  lexer.cmdarg.restore cmdarg
5054
5051
  result = stmt
5055
-
5052
+
5056
5053
  result
5057
5054
  end
5058
5055
 
@@ -5061,7 +5058,7 @@ def _reduce_304(val, _values, result)
5061
5058
  result = stmt
5062
5059
  result ||= s(:nil).line lexer.lineno
5063
5060
  result.paren = true
5064
-
5061
+
5065
5062
  result
5066
5063
  end
5067
5064
 
@@ -5069,7 +5066,7 @@ def _reduce_305(val, _values, result)
5069
5066
  expr, _, id = val
5070
5067
 
5071
5068
  result = s(:colon2, expr, id.to_sym).line expr.line
5072
-
5069
+
5073
5070
  result
5074
5071
  end
5075
5072
 
@@ -5077,12 +5074,12 @@ def _reduce_306(val, _values, result)
5077
5074
  _, id = val
5078
5075
 
5079
5076
  result = s(:colon3, id.to_sym).line lexer.lineno
5080
-
5077
+
5081
5078
  result
5082
5079
  end
5083
5080
 
5084
5081
  def _reduce_307(val, _values, result)
5085
- result = lexer.lineno
5082
+ result = lexer.lineno
5086
5083
  result
5087
5084
  end
5088
5085
 
@@ -5091,44 +5088,44 @@ def _reduce_308(val, _values, result)
5091
5088
  result = args || s(:array)
5092
5089
  result.sexp_type = :array # aref_args is :args
5093
5090
  result.line line
5094
-
5091
+
5095
5092
  result
5096
5093
  end
5097
5094
 
5098
5095
  def _reduce_309(val, _values, result)
5099
5096
  result = self.lexer.lineno
5100
-
5097
+
5101
5098
  result
5102
5099
  end
5103
5100
 
5104
5101
  def _reduce_310(val, _values, result)
5105
5102
  result = new_hash val
5106
-
5103
+
5107
5104
  result
5108
5105
  end
5109
5106
 
5110
5107
  def _reduce_311(val, _values, result)
5111
5108
  (_, line), = val
5112
5109
  result = s(:return).line line
5113
-
5110
+
5114
5111
  result
5115
5112
  end
5116
5113
 
5117
5114
  def _reduce_312(val, _values, result)
5118
5115
  result = new_yield val[2]
5119
-
5116
+
5120
5117
  result
5121
5118
  end
5122
5119
 
5123
5120
  def _reduce_313(val, _values, result)
5124
5121
  result = new_yield
5125
-
5122
+
5126
5123
  result
5127
5124
  end
5128
5125
 
5129
5126
  def _reduce_314(val, _values, result)
5130
5127
  result = new_yield
5131
-
5128
+
5132
5129
  result
5133
5130
  end
5134
5131
 
@@ -5136,20 +5133,20 @@ def _reduce_315(val, _values, result)
5136
5133
  (_, line), _, _, arg, _ = val
5137
5134
 
5138
5135
  result = s(:defined, arg).line line
5139
-
5136
+
5140
5137
  result
5141
5138
  end
5142
5139
 
5143
5140
  def _reduce_316(val, _values, result)
5144
5141
  _, _, lhs, _ = val
5145
5142
  result = new_call lhs, :"!"
5146
-
5143
+
5147
5144
  result
5148
5145
  end
5149
5146
 
5150
5147
  def _reduce_317(val, _values, result)
5151
5148
  debug20 14, val, result
5152
-
5149
+
5153
5150
  result
5154
5151
  end
5155
5152
 
@@ -5159,7 +5156,7 @@ def _reduce_318(val, _values, result)
5159
5156
  iter.insert 1, call
5160
5157
  result = iter
5161
5158
  # FIX: probably not: call.line = iter.line
5162
-
5159
+
5163
5160
  result
5164
5161
  end
5165
5162
 
@@ -5170,68 +5167,68 @@ def _reduce_320(val, _values, result)
5170
5167
  block_dup_check call, iter
5171
5168
  iter.insert 1, call # FIX
5172
5169
  result = iter
5173
-
5170
+
5174
5171
  result
5175
5172
  end
5176
5173
 
5177
5174
  def _reduce_321(val, _values, result)
5178
5175
  result = val[1] # TODO: fix lineno
5179
-
5176
+
5180
5177
  result
5181
5178
  end
5182
5179
 
5183
5180
  def _reduce_322(val, _values, result)
5184
5181
  _, c, _, t, f, _ = val
5185
5182
  result = new_if c, t, f
5186
-
5183
+
5187
5184
  result
5188
5185
  end
5189
5186
 
5190
5187
  def _reduce_323(val, _values, result)
5191
5188
  _, c, _, t, f, _ = val
5192
5189
  result = new_if c, f, t
5193
-
5190
+
5194
5191
  result
5195
5192
  end
5196
5193
 
5197
5194
  def _reduce_324(val, _values, result)
5198
5195
  _, cond, body, _ = val
5199
5196
  result = new_while body, cond, true
5200
-
5197
+
5201
5198
  result
5202
5199
  end
5203
5200
 
5204
5201
  def _reduce_325(val, _values, result)
5205
5202
  _, cond, body, _ = val
5206
5203
  result = new_until body, cond, true
5207
-
5204
+
5208
5205
  result
5209
5206
  end
5210
5207
 
5211
5208
  def _reduce_326(val, _values, result)
5212
5209
  (_, line), expr, _, body, _ = val
5213
5210
  result = new_case expr, body, line
5214
-
5211
+
5215
5212
  result
5216
5213
  end
5217
5214
 
5218
5215
  def _reduce_327(val, _values, result)
5219
5216
  (_, line), _, body, _ = val
5220
5217
  result = new_case nil, body, line
5221
-
5218
+
5222
5219
  result
5223
5220
  end
5224
5221
 
5225
5222
  def _reduce_328(val, _values, result)
5226
5223
  _, var, _, iter, body, _ = val
5227
5224
  result = new_for iter, var, body
5228
-
5225
+
5229
5226
  result
5230
5227
  end
5231
5228
 
5232
5229
  def _reduce_329(val, _values, result)
5233
5230
  result = self.lexer.lineno
5234
-
5231
+
5235
5232
  result
5236
5233
  end
5237
5234
 
@@ -5241,7 +5238,7 @@ def _reduce_330(val, _values, result)
5241
5238
  yyerror "class definition in method body"
5242
5239
  end
5243
5240
  self.env.extend
5244
-
5241
+
5245
5242
  result
5246
5243
  end
5247
5244
 
@@ -5249,20 +5246,20 @@ def _reduce_331(val, _values, result)
5249
5246
  result = new_class val
5250
5247
  self.env.unextend
5251
5248
  self.lexer.comments # we don't care about comments in the body
5252
-
5249
+
5253
5250
  result
5254
5251
  end
5255
5252
 
5256
5253
  def _reduce_332(val, _values, result)
5257
5254
  result = self.lexer.lineno
5258
-
5255
+
5259
5256
  result
5260
5257
  end
5261
5258
 
5262
5259
  def _reduce_333(val, _values, result)
5263
5260
  result = self.in_def
5264
5261
  self.in_def = false
5265
-
5262
+
5266
5263
  result
5267
5264
  end
5268
5265
 
@@ -5270,7 +5267,7 @@ def _reduce_334(val, _values, result)
5270
5267
  result = self.in_single
5271
5268
  self.in_single = 0
5272
5269
  self.env.extend
5273
-
5270
+
5274
5271
  result
5275
5272
  end
5276
5273
 
@@ -5278,13 +5275,13 @@ def _reduce_335(val, _values, result)
5278
5275
  result = new_sclass val
5279
5276
  self.env.unextend
5280
5277
  self.lexer.comments # we don't care about comments in the body
5281
-
5278
+
5282
5279
  result
5283
5280
  end
5284
5281
 
5285
5282
  def _reduce_336(val, _values, result)
5286
5283
  result = self.lexer.lineno
5287
-
5284
+
5288
5285
  result
5289
5286
  end
5290
5287
 
@@ -5294,7 +5291,7 @@ def _reduce_337(val, _values, result)
5294
5291
  self.in_def or self.in_single > 0
5295
5292
 
5296
5293
  self.env.extend
5297
-
5294
+
5298
5295
  result
5299
5296
  end
5300
5297
 
@@ -5302,7 +5299,7 @@ def _reduce_338(val, _values, result)
5302
5299
  result = new_module val
5303
5300
  self.env.unextend
5304
5301
  self.lexer.comments # we don't care about comments in the body
5305
-
5302
+
5306
5303
  result
5307
5304
  end
5308
5305
 
@@ -5315,12 +5312,12 @@ def _reduce_339(val, _values, result)
5315
5312
  # TODO: local->cmdargs = cmdarg_stack;
5316
5313
  # TODO: port local_push_gen and local_pop_gen
5317
5314
  lexer.cmdarg.stack.replace [false]
5318
-
5315
+
5319
5316
  result
5320
5317
  end
5321
5318
 
5322
5319
  def _reduce_340(val, _values, result)
5323
- result = lexer.lineno
5320
+ result = lexer.lineno
5324
5321
  result
5325
5322
  end
5326
5323
 
@@ -5333,14 +5330,14 @@ def _reduce_341(val, _values, result)
5333
5330
  self.env.unextend
5334
5331
  self.in_def = in_def
5335
5332
  self.lexer.comments # we don't care about comments in the body
5336
-
5333
+
5337
5334
  result
5338
5335
  end
5339
5336
 
5340
5337
  def _reduce_342(val, _values, result)
5341
5338
  self.comments.push self.lexer.comments
5342
5339
  lexer.lex_state = EXPR_FNAME
5343
-
5340
+
5344
5341
  result
5345
5342
  end
5346
5343
 
@@ -5350,7 +5347,7 @@ def _reduce_343(val, _values, result)
5350
5347
  lexer.lex_state = EXPR_ENDFN # force for args
5351
5348
  result = [lexer.lineno, self.lexer.cmdarg.stack.dup]
5352
5349
  lexer.cmdarg.stack.replace [false]
5353
-
5350
+
5354
5351
  result
5355
5352
  end
5356
5353
 
@@ -5363,41 +5360,41 @@ def _reduce_344(val, _values, result)
5363
5360
  self.env.unextend
5364
5361
  self.in_single -= 1
5365
5362
  self.lexer.comments # we don't care about comments in the body
5366
-
5363
+
5367
5364
  result
5368
5365
  end
5369
5366
 
5370
5367
  def _reduce_345(val, _values, result)
5371
5368
  (_, line), = val
5372
5369
  result = s(:break).line line
5373
-
5370
+
5374
5371
  result
5375
5372
  end
5376
5373
 
5377
5374
  def _reduce_346(val, _values, result)
5378
5375
  (_, line), = val
5379
5376
  result = s(:next).line line
5380
-
5377
+
5381
5378
  result
5382
5379
  end
5383
5380
 
5384
5381
  def _reduce_347(val, _values, result)
5385
5382
  (_, line), = val
5386
5383
  result = s(:redo).line line
5387
-
5384
+
5388
5385
  result
5389
5386
  end
5390
5387
 
5391
5388
  def _reduce_348(val, _values, result)
5392
5389
  (_, line), = val
5393
5390
  result = s(:retry).line line
5394
-
5391
+
5395
5392
  result
5396
5393
  end
5397
5394
 
5398
5395
  def _reduce_349(val, _values, result)
5399
5396
  result = value_expr(val[0])
5400
-
5397
+
5401
5398
  result
5402
5399
  end
5403
5400
 
@@ -5455,7 +5452,7 @@ def _reduce_375(val, _values, result)
5455
5452
  (_, line), c, _, t, rest = val
5456
5453
 
5457
5454
  result = s(:if, c, t, rest).line line
5458
-
5455
+
5459
5456
  result
5460
5457
  end
5461
5458
 
@@ -5463,7 +5460,7 @@ end
5463
5460
 
5464
5461
  def _reduce_377(val, _values, result)
5465
5462
  result = val[1]
5466
-
5463
+
5467
5464
  result
5468
5465
  end
5469
5466
 
@@ -5471,7 +5468,7 @@ end
5471
5468
 
5472
5469
  def _reduce_379(val, _values, result)
5473
5470
  val[0].delete_at 1 if val[0][1].nil? # HACK
5474
-
5471
+
5475
5472
  result
5476
5473
  end
5477
5474
 
@@ -5479,7 +5476,7 @@ end
5479
5476
 
5480
5477
  def _reduce_381(val, _values, result)
5481
5478
  result = val[1]
5482
-
5479
+
5483
5480
  result
5484
5481
  end
5485
5482
 
@@ -5487,13 +5484,13 @@ def _reduce_382(val, _values, result)
5487
5484
  sym, = val
5488
5485
 
5489
5486
  result = s(:array, sym).line lexer.lineno
5490
-
5487
+
5491
5488
  result
5492
5489
  end
5493
5490
 
5494
5491
  def _reduce_383(val, _values, result)
5495
5492
  result = list_append val[0], val[2]
5496
-
5493
+
5497
5494
  result
5498
5495
  end
5499
5496
 
@@ -5501,7 +5498,7 @@ def _reduce_384(val, _values, result)
5501
5498
  args, = val
5502
5499
 
5503
5500
  result = block_var args
5504
-
5501
+
5505
5502
  result
5506
5503
  end
5507
5504
 
@@ -5509,7 +5506,7 @@ def _reduce_385(val, _values, result)
5509
5506
  args, _, _, splat = val
5510
5507
 
5511
5508
  result = block_var args, "*#{splat}".to_sym
5512
-
5509
+
5513
5510
  result
5514
5511
  end
5515
5512
 
@@ -5517,7 +5514,7 @@ def _reduce_386(val, _values, result)
5517
5514
  args, _, _, splat, _, args2 = val
5518
5515
 
5519
5516
  result = block_var args, "*#{splat}".to_sym, args2
5520
-
5517
+
5521
5518
  result
5522
5519
  end
5523
5520
 
@@ -5525,7 +5522,7 @@ def _reduce_387(val, _values, result)
5525
5522
  args, _, _ = val
5526
5523
 
5527
5524
  result = block_var args, :*
5528
-
5525
+
5529
5526
  result
5530
5527
  end
5531
5528
 
@@ -5533,7 +5530,7 @@ def _reduce_388(val, _values, result)
5533
5530
  args, _, _, _, args2 = val
5534
5531
 
5535
5532
  result = block_var args, :*, args2
5536
-
5533
+
5537
5534
  result
5538
5535
  end
5539
5536
 
@@ -5541,7 +5538,7 @@ def _reduce_389(val, _values, result)
5541
5538
  _, splat = val
5542
5539
 
5543
5540
  result = block_var :"*#{splat}"
5544
-
5541
+
5545
5542
  result
5546
5543
  end
5547
5544
 
@@ -5549,13 +5546,13 @@ def _reduce_390(val, _values, result)
5549
5546
  _, splat, _, args = val
5550
5547
 
5551
5548
  result = block_var :"*#{splat}", args
5552
-
5549
+
5553
5550
  result
5554
5551
  end
5555
5552
 
5556
5553
  def _reduce_391(val, _values, result)
5557
5554
  result = block_var :*
5558
-
5555
+
5559
5556
  result
5560
5557
  end
5561
5558
 
@@ -5563,25 +5560,25 @@ def _reduce_392(val, _values, result)
5563
5560
  _, _, args = val
5564
5561
 
5565
5562
  result = block_var :*, args
5566
-
5563
+
5567
5564
  result
5568
5565
  end
5569
5566
 
5570
5567
  def _reduce_393(val, _values, result)
5571
5568
  result = call_args val
5572
-
5569
+
5573
5570
  result
5574
5571
  end
5575
5572
 
5576
5573
  def _reduce_394(val, _values, result)
5577
5574
  result = call_args val
5578
-
5575
+
5579
5576
  result
5580
5577
  end
5581
5578
 
5582
5579
  def _reduce_395(val, _values, result)
5583
5580
  result = call_args val
5584
-
5581
+
5585
5582
  result
5586
5583
  end
5587
5584
 
@@ -5589,13 +5586,13 @@ def _reduce_396(val, _values, result)
5589
5586
  line = lexer.lineno
5590
5587
  result = call_args val # TODO: push line down
5591
5588
  result.line line
5592
-
5589
+
5593
5590
  result
5594
5591
  end
5595
5592
 
5596
5593
  def _reduce_397(val, _values, result)
5597
5594
  result = args val
5598
-
5595
+
5599
5596
  result
5600
5597
  end
5601
5598
 
@@ -5603,122 +5600,122 @@ end
5603
5600
 
5604
5601
  def _reduce_399(val, _values, result)
5605
5602
  result = args val
5606
-
5603
+
5607
5604
  result
5608
5605
  end
5609
5606
 
5610
5607
  def _reduce_400(val, _values, result)
5611
5608
  result = args val
5612
-
5609
+
5613
5610
  result
5614
5611
  end
5615
5612
 
5616
5613
  def _reduce_401(val, _values, result)
5617
5614
  result = args val
5618
-
5615
+
5619
5616
  result
5620
5617
  end
5621
5618
 
5622
5619
  def _reduce_402(val, _values, result)
5623
5620
  result = args val
5624
-
5621
+
5625
5622
  result
5626
5623
  end
5627
5624
 
5628
5625
  def _reduce_403(val, _values, result)
5629
5626
  result = args val
5630
-
5627
+
5631
5628
  result
5632
5629
  end
5633
5630
 
5634
5631
  def _reduce_404(val, _values, result)
5635
5632
  result = args(val) << nil
5636
-
5633
+
5637
5634
  result
5638
5635
  end
5639
5636
 
5640
5637
  def _reduce_405(val, _values, result)
5641
5638
  result = args val
5642
-
5639
+
5643
5640
  result
5644
5641
  end
5645
5642
 
5646
5643
  def _reduce_406(val, _values, result)
5647
5644
  result = args val
5648
-
5645
+
5649
5646
  result
5650
5647
  end
5651
5648
 
5652
5649
  def _reduce_407(val, _values, result)
5653
5650
  result = args val
5654
-
5651
+
5655
5652
  result
5656
5653
  end
5657
5654
 
5658
5655
  def _reduce_408(val, _values, result)
5659
5656
  result = args val
5660
-
5657
+
5661
5658
  result
5662
5659
  end
5663
5660
 
5664
5661
  def _reduce_409(val, _values, result)
5665
5662
  result = args val
5666
-
5663
+
5667
5664
  result
5668
5665
  end
5669
5666
 
5670
5667
  def _reduce_410(val, _values, result)
5671
5668
  result = args val
5672
-
5669
+
5673
5670
  result
5674
5671
  end
5675
5672
 
5676
5673
  def _reduce_411(val, _values, result)
5677
5674
  result = args val
5678
-
5675
+
5679
5676
  result
5680
5677
  end
5681
5678
 
5682
5679
  def _reduce_412(val, _values, result)
5683
5680
  result = args val
5684
-
5681
+
5685
5682
  result
5686
5683
  end
5687
5684
 
5688
5685
  def _reduce_413(val, _values, result)
5689
5686
  result = args val
5690
-
5687
+
5691
5688
  result
5692
5689
  end
5693
5690
 
5694
5691
  def _reduce_414(val, _values, result)
5695
- result = 0
5692
+ result = 0
5696
5693
  result
5697
5694
  end
5698
5695
 
5699
5696
  def _reduce_415(val, _values, result)
5700
5697
  self.lexer.command_start = true
5701
-
5698
+
5702
5699
  result
5703
5700
  end
5704
5701
 
5705
5702
  def _reduce_416(val, _values, result)
5706
5703
  # TODO: current_arg = 0
5707
5704
  result = args val
5708
-
5705
+
5709
5706
  result
5710
5707
  end
5711
5708
 
5712
5709
  def _reduce_417(val, _values, result)
5713
5710
  result = s(:args).line lexer.lineno
5714
-
5711
+
5715
5712
  result
5716
5713
  end
5717
5714
 
5718
5715
  def _reduce_418(val, _values, result)
5719
5716
  # TODO: current_arg = 0
5720
5717
  result = args val
5721
-
5718
+
5722
5719
  result
5723
5720
  end
5724
5721
 
@@ -5726,19 +5723,19 @@ end
5726
5723
 
5727
5724
  def _reduce_420(val, _values, result)
5728
5725
  result = args val
5729
-
5726
+
5730
5727
  result
5731
5728
  end
5732
5729
 
5733
5730
  def _reduce_421(val, _values, result)
5734
5731
  result = args val
5735
-
5732
+
5736
5733
  result
5737
5734
  end
5738
5735
 
5739
5736
  def _reduce_422(val, _values, result)
5740
5737
  result = args val
5741
-
5738
+
5742
5739
  result
5743
5740
  end
5744
5741
 
@@ -5746,7 +5743,7 @@ def _reduce_423(val, _values, result)
5746
5743
  id, = val
5747
5744
  line = lexer.lineno
5748
5745
  result = s(:shadow, id.to_sym).line line
5749
-
5746
+
5750
5747
  result
5751
5748
  end
5752
5749
 
@@ -5757,13 +5754,13 @@ def _reduce_425(val, _values, result)
5757
5754
  result = [lexer.lineno, lexer.lpar_beg]
5758
5755
  lexer.paren_nest += 1
5759
5756
  lexer.lpar_beg = lexer.paren_nest
5760
-
5757
+
5761
5758
  result
5762
5759
  end
5763
5760
 
5764
5761
  def _reduce_426(val, _values, result)
5765
5762
  result = lexer.cmdarg.store(false)
5766
-
5763
+
5767
5764
  result
5768
5765
  end
5769
5766
 
@@ -5778,39 +5775,39 @@ def _reduce_427(val, _values, result)
5778
5775
  result = new_iter call, args, body
5779
5776
  result.line = line
5780
5777
  self.env.unextend
5781
-
5778
+
5782
5779
  result
5783
5780
  end
5784
5781
 
5785
5782
  def _reduce_428(val, _values, result)
5786
5783
  result = args val
5787
-
5784
+
5788
5785
  result
5789
5786
  end
5790
5787
 
5791
5788
  def _reduce_429(val, _values, result)
5792
5789
  result = val[0]
5793
5790
  result = 0 if result == s(:args)
5794
-
5791
+
5795
5792
  result
5796
5793
  end
5797
5794
 
5798
5795
  def _reduce_430(val, _values, result)
5799
5796
  result = val[1]
5800
-
5797
+
5801
5798
  result
5802
5799
  end
5803
5800
 
5804
5801
  def _reduce_431(val, _values, result)
5805
5802
  result = val[1]
5806
-
5803
+
5807
5804
  result
5808
5805
  end
5809
5806
 
5810
5807
  def _reduce_432(val, _values, result)
5811
5808
  (_, line), iter, _ = val
5812
5809
  result = iter.line line
5813
-
5810
+
5814
5811
  result
5815
5812
  end
5816
5813
 
@@ -5828,13 +5825,13 @@ def _reduce_433(val, _values, result)
5828
5825
 
5829
5826
  result = blk
5830
5827
  result.insert 1, cmd
5831
-
5828
+
5832
5829
  result
5833
5830
  end
5834
5831
 
5835
5832
  def _reduce_434(val, _values, result)
5836
5833
  result = new_call val[0], val[2].to_sym, val[3]
5837
-
5834
+
5838
5835
  result
5839
5836
  end
5840
5837
 
@@ -5845,7 +5842,7 @@ def _reduce_435(val, _values, result)
5845
5842
  iter2.insert 1, call
5846
5843
 
5847
5844
  result = iter2
5848
-
5845
+
5849
5846
  result
5850
5847
  end
5851
5848
 
@@ -5856,13 +5853,13 @@ def _reduce_436(val, _values, result)
5856
5853
  iter2.insert 1, call
5857
5854
 
5858
5855
  result = iter2
5859
-
5856
+
5860
5857
  result
5861
5858
  end
5862
5859
 
5863
5860
  def _reduce_437(val, _values, result)
5864
5861
  result = self.lexer.lineno
5865
-
5862
+
5866
5863
  result
5867
5864
  end
5868
5865
 
@@ -5871,62 +5868,62 @@ def _reduce_438(val, _values, result)
5871
5868
 
5872
5869
  result = call.concat args.sexp_body if args
5873
5870
  result.line lineno
5874
-
5871
+
5875
5872
  result
5876
5873
  end
5877
5874
 
5878
5875
  def _reduce_439(val, _values, result)
5879
5876
  result = new_call val[0], val[2].to_sym, val[3], val[1]
5880
-
5877
+
5881
5878
  result
5882
5879
  end
5883
5880
 
5884
5881
  def _reduce_440(val, _values, result)
5885
5882
  result = new_call val[0], val[2].to_sym, val[3]
5886
-
5883
+
5887
5884
  result
5888
5885
  end
5889
5886
 
5890
5887
  def _reduce_441(val, _values, result)
5891
5888
  result = new_call val[0], val[2].to_sym
5892
-
5889
+
5893
5890
  result
5894
5891
  end
5895
5892
 
5896
5893
  def _reduce_442(val, _values, result)
5897
5894
  result = new_call val[0], :call, val[2], val[1]
5898
-
5895
+
5899
5896
  result
5900
5897
  end
5901
5898
 
5902
5899
  def _reduce_443(val, _values, result)
5903
5900
  result = new_call val[0], :call, val[2]
5904
-
5901
+
5905
5902
  result
5906
5903
  end
5907
5904
 
5908
5905
  def _reduce_444(val, _values, result)
5909
5906
  result = new_super val[1]
5910
-
5907
+
5911
5908
  result
5912
5909
  end
5913
5910
 
5914
5911
  def _reduce_445(val, _values, result)
5915
5912
  result = s(:zsuper).line lexer.lineno
5916
-
5913
+
5917
5914
  result
5918
5915
  end
5919
5916
 
5920
5917
  def _reduce_446(val, _values, result)
5921
5918
  result = new_aref val
5922
-
5919
+
5923
5920
  result
5924
5921
  end
5925
5922
 
5926
5923
  def _reduce_447(val, _values, result)
5927
5924
  self.env.extend :dynamic
5928
5925
  result = self.lexer.lineno
5929
-
5926
+
5930
5927
  result
5931
5928
  end
5932
5929
 
@@ -5937,14 +5934,14 @@ def _reduce_448(val, _values, result)
5937
5934
  result.line = line
5938
5935
 
5939
5936
  self.env.unextend
5940
-
5937
+
5941
5938
  result
5942
5939
  end
5943
5940
 
5944
5941
  def _reduce_449(val, _values, result)
5945
5942
  self.env.extend :dynamic
5946
5943
  result = self.lexer.lineno
5947
-
5944
+
5948
5945
  result
5949
5946
  end
5950
5947
 
@@ -5955,17 +5952,17 @@ def _reduce_450(val, _values, result)
5955
5952
  result.line = line
5956
5953
 
5957
5954
  self.env.unextend
5958
-
5955
+
5959
5956
  result
5960
5957
  end
5961
5958
 
5962
5959
  def _reduce_451(val, _values, result)
5963
- self.env.extend :dynamic; result = self.lexer.lineno
5960
+ self.env.extend :dynamic; result = self.lexer.lineno
5964
5961
  result
5965
5962
  end
5966
5963
 
5967
5964
  def _reduce_452(val, _values, result)
5968
- result = lexer.cmdarg.store(false)
5965
+ result = lexer.cmdarg.store(false)
5969
5966
  result
5970
5967
  end
5971
5968
 
@@ -5976,17 +5973,17 @@ def _reduce_453(val, _values, result)
5976
5973
  self.env.unextend
5977
5974
  lexer.cmdarg.restore cmdarg
5978
5975
  lexer.cmdarg.pop # because of: cmdarg_stack >> 1 ?
5979
-
5976
+
5980
5977
  result
5981
5978
  end
5982
5979
 
5983
5980
  def _reduce_454(val, _values, result)
5984
- self.env.extend :dynamic; result = self.lexer.lineno
5981
+ self.env.extend :dynamic; result = self.lexer.lineno
5985
5982
  result
5986
5983
  end
5987
5984
 
5988
5985
  def _reduce_455(val, _values, result)
5989
- result = lexer.cmdarg.store(false)
5986
+ result = lexer.cmdarg.store(false)
5990
5987
  result
5991
5988
  end
5992
5989
 
@@ -5996,13 +5993,13 @@ def _reduce_456(val, _values, result)
5996
5993
  result = new_do_body param, cmpstmt, line
5997
5994
  self.env.unextend
5998
5995
  lexer.cmdarg.restore cmdarg
5999
-
5996
+
6000
5997
  result
6001
5998
  end
6002
5999
 
6003
6000
  def _reduce_457(val, _values, result)
6004
6001
  result = self.lexer.lineno
6005
-
6002
+
6006
6003
  result
6007
6004
  end
6008
6005
 
@@ -6010,7 +6007,7 @@ def _reduce_458(val, _values, result)
6010
6007
  result = new_when(val[2], val[4])
6011
6008
  result.line = val[1]
6012
6009
  result << val[5] if val[5]
6013
-
6010
+
6014
6011
  result
6015
6012
  end
6016
6013
 
@@ -6027,20 +6024,20 @@ def _reduce_461(val, _values, result)
6027
6024
 
6028
6025
  result = new_resbody(klasses, body)
6029
6026
  result << rest if rest # UGH, rewritten above
6030
-
6027
+
6031
6028
  result
6032
6029
  end
6033
6030
 
6034
6031
  def _reduce_462(val, _values, result)
6035
6032
  result = nil
6036
-
6033
+
6037
6034
  result
6038
6035
  end
6039
6036
 
6040
6037
  def _reduce_463(val, _values, result)
6041
6038
  arg, = val
6042
6039
  result = s(:array, arg).line arg.line
6043
-
6040
+
6044
6041
  result
6045
6042
  end
6046
6043
 
@@ -6050,7 +6047,7 @@ end
6050
6047
 
6051
6048
  def _reduce_466(val, _values, result)
6052
6049
  result = val[1]
6053
-
6050
+
6054
6051
  result
6055
6052
  end
6056
6053
 
@@ -6060,7 +6057,7 @@ def _reduce_468(val, _values, result)
6060
6057
  (_, line), body = val
6061
6058
 
6062
6059
  result = body || s(:nil).line(line)
6063
-
6060
+
6064
6061
  result
6065
6062
  end
6066
6063
 
@@ -6070,7 +6067,7 @@ def _reduce_470(val, _values, result)
6070
6067
  line = lexer.lineno
6071
6068
  result = s(:lit, val[0])
6072
6069
  result.line = line
6073
-
6070
+
6074
6071
  result
6075
6072
  end
6076
6073
 
@@ -6078,7 +6075,7 @@ def _reduce_471(val, _values, result)
6078
6075
  line = lexer.lineno
6079
6076
  result = s(:lit, val[0])
6080
6077
  result.line = line
6081
-
6078
+
6082
6079
  result
6083
6080
  end
6084
6081
 
@@ -6088,13 +6085,13 @@ def _reduce_473(val, _values, result)
6088
6085
  str, = val
6089
6086
  str = s(:dstr, str.value) if str.sexp_type == :evstr
6090
6087
  result = str
6091
-
6088
+
6092
6089
  result
6093
6090
  end
6094
6091
 
6095
6092
  def _reduce_474(val, _values, result)
6096
6093
  debug20 23, val, result
6097
-
6094
+
6098
6095
  result
6099
6096
  end
6100
6097
 
@@ -6102,7 +6099,7 @@ end
6102
6099
 
6103
6100
  def _reduce_476(val, _values, result)
6104
6101
  result = self.literal_concat val[0], val[1]
6105
-
6102
+
6106
6103
  result
6107
6104
  end
6108
6105
 
@@ -6112,50 +6109,50 @@ def _reduce_477(val, _values, result)
6112
6109
  str = dedent str if func =~ RubyLexer::STR_FUNC_ICNTNT
6113
6110
 
6114
6111
  result = str
6115
-
6112
+
6116
6113
  result
6117
6114
  end
6118
6115
 
6119
6116
  def _reduce_478(val, _values, result)
6120
6117
  result = new_string val
6121
-
6118
+
6122
6119
  result
6123
6120
  end
6124
6121
 
6125
6122
  def _reduce_479(val, _values, result)
6126
6123
  result = new_xstring val[1]
6127
6124
  # TODO: dedent?!?! SERIOUSLY?!?
6128
-
6125
+
6129
6126
  result
6130
6127
  end
6131
6128
 
6132
6129
  def _reduce_480(val, _values, result)
6133
6130
  result = new_regexp val
6134
-
6131
+
6135
6132
  result
6136
6133
  end
6137
6134
 
6138
6135
  def _reduce_481(val, _values, result)
6139
6136
  result = s(:array).line lexer.lineno
6140
-
6137
+
6141
6138
  result
6142
6139
  end
6143
6140
 
6144
6141
  def _reduce_482(val, _values, result)
6145
6142
  result = val[1]
6146
-
6143
+
6147
6144
  result
6148
6145
  end
6149
6146
 
6150
6147
  def _reduce_483(val, _values, result)
6151
6148
  result = new_word_list
6152
-
6149
+
6153
6150
  result
6154
6151
  end
6155
6152
 
6156
6153
  def _reduce_484(val, _values, result)
6157
6154
  result = val[0].dup << new_word_list_entry(val)
6158
-
6155
+
6159
6156
  result
6160
6157
  end
6161
6158
 
@@ -6163,18 +6160,18 @@ end
6163
6160
 
6164
6161
  def _reduce_486(val, _values, result)
6165
6162
  result = self.literal_concat val[0], val[1]
6166
-
6163
+
6167
6164
  result
6168
6165
  end
6169
6166
 
6170
6167
  def _reduce_487(val, _values, result)
6171
6168
  result = s(:array).line lexer.lineno
6172
-
6169
+
6173
6170
  result
6174
6171
  end
6175
6172
 
6176
6173
  def _reduce_488(val, _values, result)
6177
- result = lexer.lineno
6174
+ result = lexer.lineno
6178
6175
  result
6179
6176
  end
6180
6177
 
@@ -6182,113 +6179,113 @@ def _reduce_489(val, _values, result)
6182
6179
  _, line, list, _, = val
6183
6180
  list.line = line
6184
6181
  result = list
6185
-
6182
+
6186
6183
  result
6187
6184
  end
6188
6185
 
6189
6186
  def _reduce_490(val, _values, result)
6190
6187
  result = new_symbol_list.line lexer.lineno
6191
-
6188
+
6192
6189
  result
6193
6190
  end
6194
6191
 
6195
6192
  def _reduce_491(val, _values, result)
6196
6193
  list, * = val
6197
6194
  result = list.dup << new_symbol_list_entry(val)
6198
-
6195
+
6199
6196
  result
6200
6197
  end
6201
6198
 
6202
6199
  def _reduce_492(val, _values, result)
6203
6200
  result = s(:array).line lexer.lineno
6204
-
6201
+
6205
6202
  result
6206
6203
  end
6207
6204
 
6208
6205
  def _reduce_493(val, _values, result)
6209
6206
  result = val[1]
6210
-
6207
+
6211
6208
  result
6212
6209
  end
6213
6210
 
6214
6211
  def _reduce_494(val, _values, result)
6215
6212
  result = s(:array).line lexer.lineno # FIX
6216
-
6213
+
6217
6214
  result
6218
6215
  end
6219
6216
 
6220
6217
  def _reduce_495(val, _values, result)
6221
6218
  result = val[1]
6222
-
6219
+
6223
6220
  result
6224
6221
  end
6225
6222
 
6226
6223
  def _reduce_496(val, _values, result)
6227
6224
  result = new_qword_list
6228
-
6225
+
6229
6226
  result
6230
6227
  end
6231
6228
 
6232
6229
  def _reduce_497(val, _values, result)
6233
6230
  result = val[0].dup << new_qword_list_entry(val)
6234
-
6231
+
6235
6232
  result
6236
6233
  end
6237
6234
 
6238
6235
  def _reduce_498(val, _values, result)
6239
6236
  result = new_qsym_list
6240
-
6237
+
6241
6238
  result
6242
6239
  end
6243
6240
 
6244
6241
  def _reduce_499(val, _values, result)
6245
6242
  result = val[0].dup << new_qsym_list_entry(val)
6246
-
6243
+
6247
6244
  result
6248
6245
  end
6249
6246
 
6250
6247
  def _reduce_500(val, _values, result)
6251
6248
  result = s(:str, "").line lexer.lineno
6252
-
6249
+
6253
6250
  result
6254
6251
  end
6255
6252
 
6256
6253
  def _reduce_501(val, _values, result)
6257
6254
  v1, v2 = val
6258
6255
  result = literal_concat v1, v2
6259
-
6256
+
6260
6257
  result
6261
6258
  end
6262
6259
 
6263
6260
  def _reduce_502(val, _values, result)
6264
6261
  result = nil
6265
-
6262
+
6266
6263
  result
6267
6264
  end
6268
6265
 
6269
6266
  def _reduce_503(val, _values, result)
6270
6267
  v1, v2 = val
6271
6268
  result = literal_concat v1, v2
6272
-
6269
+
6273
6270
  result
6274
6271
  end
6275
6272
 
6276
6273
  def _reduce_504(val, _values, result)
6277
6274
  result = nil
6278
-
6275
+
6279
6276
  result
6280
6277
  end
6281
6278
 
6282
6279
  def _reduce_505(val, _values, result)
6283
6280
  v1, v2 = val
6284
6281
  result = literal_concat v1, v2
6285
-
6282
+
6286
6283
  result
6287
6284
  end
6288
6285
 
6289
6286
  def _reduce_506(val, _values, result)
6290
6287
  result = new_string val
6291
-
6288
+
6292
6289
  result
6293
6290
  end
6294
6291
 
@@ -6297,7 +6294,7 @@ def _reduce_507(val, _values, result)
6297
6294
 
6298
6295
  lexer.lex_strterm = nil
6299
6296
  lexer.lex_state = EXPR_BEG
6300
-
6297
+
6301
6298
  result
6302
6299
  end
6303
6300
 
@@ -6305,7 +6302,7 @@ def _reduce_508(val, _values, result)
6305
6302
  _, strterm, str = val
6306
6303
  lexer.lex_strterm = strterm
6307
6304
  result = s(:evstr, str).line str.line
6308
-
6305
+
6309
6306
  result
6310
6307
  end
6311
6308
 
@@ -6324,7 +6321,7 @@ def _reduce_509(val, _values, result)
6324
6321
  lexer.string_nest = 0
6325
6322
 
6326
6323
  lexer.lex_state = EXPR_BEG
6327
-
6324
+
6328
6325
  result
6329
6326
  end
6330
6327
 
@@ -6356,22 +6353,22 @@ def _reduce_510(val, _values, result)
6356
6353
  debug20 25
6357
6354
  raise "unknown string body: #{stmt.inspect}"
6358
6355
  end
6359
-
6356
+
6360
6357
  result
6361
6358
  end
6362
6359
 
6363
6360
  def _reduce_511(val, _values, result)
6364
- result = s(:gvar, val[0].to_sym).line lexer.lineno
6361
+ result = s(:gvar, val[0].to_sym).line lexer.lineno
6365
6362
  result
6366
6363
  end
6367
6364
 
6368
6365
  def _reduce_512(val, _values, result)
6369
- result = s(:ivar, val[0].to_sym).line lexer.lineno
6366
+ result = s(:ivar, val[0].to_sym).line lexer.lineno
6370
6367
  result
6371
6368
  end
6372
6369
 
6373
6370
  def _reduce_513(val, _values, result)
6374
- result = s(:cvar, val[0].to_sym).line lexer.lineno
6371
+ result = s(:cvar, val[0].to_sym).line lexer.lineno
6375
6372
  result
6376
6373
  end
6377
6374
 
@@ -6380,13 +6377,13 @@ end
6380
6377
  def _reduce_515(val, _values, result)
6381
6378
  lexer.lex_state = EXPR_END
6382
6379
  result = val[1].to_sym
6383
-
6380
+
6384
6381
  result
6385
6382
  end
6386
6383
 
6387
6384
  def _reduce_516(val, _values, result)
6388
6385
  result = val[0].to_sym
6389
-
6386
+
6390
6387
  result
6391
6388
  end
6392
6389
 
@@ -6415,7 +6412,7 @@ def _reduce_521(val, _values, result)
6415
6412
  else
6416
6413
  debug20 26, val, result
6417
6414
  end
6418
-
6415
+
6419
6416
  result
6420
6417
  end
6421
6418
 
@@ -6425,13 +6422,13 @@ end
6425
6422
 
6426
6423
  def _reduce_524(val, _values, result)
6427
6424
  result = -val[1] # TODO: pt_testcase
6428
-
6425
+
6429
6426
  result
6430
6427
  end
6431
6428
 
6432
6429
  def _reduce_525(val, _values, result)
6433
6430
  result = -val[1] # TODO: pt_testcase
6434
-
6431
+
6435
6432
  result
6436
6433
  end
6437
6434
 
@@ -6446,32 +6443,32 @@ end
6446
6443
  # reduce 530 omitted
6447
6444
 
6448
6445
  def _reduce_531(val, _values, result)
6449
- result = s(:nil).line lexer.lineno
6446
+ result = s(:nil).line lexer.lineno
6450
6447
  result
6451
6448
  end
6452
6449
 
6453
6450
  def _reduce_532(val, _values, result)
6454
- result = s(:self).line lexer.lineno
6451
+ result = s(:self).line lexer.lineno
6455
6452
  result
6456
6453
  end
6457
6454
 
6458
6455
  def _reduce_533(val, _values, result)
6459
- result = s(:true).line lexer.lineno
6456
+ result = s(:true).line lexer.lineno
6460
6457
  result
6461
6458
  end
6462
6459
 
6463
6460
  def _reduce_534(val, _values, result)
6464
- result = s(:false).line lexer.lineno
6461
+ result = s(:false).line lexer.lineno
6465
6462
  result
6466
6463
  end
6467
6464
 
6468
6465
  def _reduce_535(val, _values, result)
6469
- result = s(:str, self.file).line lexer.lineno
6466
+ result = s(:str, self.file).line lexer.lineno
6470
6467
  result
6471
6468
  end
6472
6469
 
6473
6470
  def _reduce_536(val, _values, result)
6474
- result = s(:lit, lexer.lineno).line lexer.lineno
6471
+ result = s(:lit, lexer.lineno).line lexer.lineno
6475
6472
  result
6476
6473
  end
6477
6474
 
@@ -6483,63 +6480,63 @@ def _reduce_537(val, _values, result)
6483
6480
  else
6484
6481
  s(:str, "Unsupported!").line l
6485
6482
  end
6486
-
6483
+
6487
6484
  result
6488
6485
  end
6489
6486
 
6490
6487
  def _reduce_538(val, _values, result)
6491
6488
  var = val[0]
6492
6489
  result = Sexp === var ? var : self.gettable(var)
6493
-
6490
+
6494
6491
  result
6495
6492
  end
6496
6493
 
6497
6494
  def _reduce_539(val, _values, result)
6498
6495
  var = val[0]
6499
6496
  result = Sexp === var ? var : self.gettable(var)
6500
-
6497
+
6501
6498
  result
6502
6499
  end
6503
6500
 
6504
6501
  def _reduce_540(val, _values, result)
6505
6502
  result = self.assignable val[0]
6506
-
6503
+
6507
6504
  result
6508
6505
  end
6509
6506
 
6510
6507
  def _reduce_541(val, _values, result)
6511
6508
  result = self.assignable val[0]
6512
6509
  debug20 29, val, result
6513
-
6510
+
6514
6511
  result
6515
6512
  end
6516
6513
 
6517
6514
  def _reduce_542(val, _values, result)
6518
- result = s(:nth_ref, val[0]).line lexer.lineno
6515
+ result = s(:nth_ref, val[0]).line lexer.lineno
6519
6516
  result
6520
6517
  end
6521
6518
 
6522
6519
  def _reduce_543(val, _values, result)
6523
- result = s(:back_ref, val[0]).line lexer.lineno
6520
+ result = s(:back_ref, val[0]).line lexer.lineno
6524
6521
  result
6525
6522
  end
6526
6523
 
6527
6524
  def _reduce_544(val, _values, result)
6528
6525
  lexer.lex_state = EXPR_BEG
6529
6526
  lexer.command_start = true
6530
-
6527
+
6531
6528
  result
6532
6529
  end
6533
6530
 
6534
6531
  def _reduce_545(val, _values, result)
6535
6532
  result = val[2]
6536
-
6533
+
6537
6534
  result
6538
6535
  end
6539
6536
 
6540
6537
  def _reduce_546(val, _values, result)
6541
6538
  result = nil
6542
-
6539
+
6543
6540
  result
6544
6541
  end
6545
6542
 
@@ -6547,7 +6544,7 @@ def _reduce_547(val, _values, result)
6547
6544
  result = val[1]
6548
6545
  self.lexer.lex_state = EXPR_BEG
6549
6546
  self.lexer.command_start = true
6550
-
6547
+
6551
6548
  result
6552
6549
  end
6553
6550
 
@@ -6555,7 +6552,7 @@ def _reduce_548(val, _values, result)
6555
6552
  result = self.in_kwarg
6556
6553
  self.in_kwarg = true
6557
6554
  self.lexer.lex_state |= EXPR_LABEL
6558
-
6555
+
6559
6556
  result
6560
6557
  end
6561
6558
 
@@ -6566,25 +6563,25 @@ def _reduce_549(val, _values, result)
6566
6563
  result = args
6567
6564
  lexer.lex_state = EXPR_BEG
6568
6565
  lexer.command_start = true
6569
-
6566
+
6570
6567
  result
6571
6568
  end
6572
6569
 
6573
6570
  def _reduce_550(val, _values, result)
6574
6571
  result = args val
6575
-
6572
+
6576
6573
  result
6577
6574
  end
6578
6575
 
6579
6576
  def _reduce_551(val, _values, result)
6580
6577
  result = args val
6581
-
6578
+
6582
6579
  result
6583
6580
  end
6584
6581
 
6585
6582
  def _reduce_552(val, _values, result)
6586
6583
  result = args val
6587
-
6584
+
6588
6585
  result
6589
6586
  end
6590
6587
 
@@ -6592,127 +6589,127 @@ end
6592
6589
 
6593
6590
  def _reduce_554(val, _values, result)
6594
6591
  result = val[1]
6595
-
6592
+
6596
6593
  result
6597
6594
  end
6598
6595
 
6599
6596
  def _reduce_555(val, _values, result)
6600
6597
  result = nil
6601
-
6598
+
6602
6599
  result
6603
6600
  end
6604
6601
 
6605
6602
  def _reduce_556(val, _values, result)
6606
6603
  result = args val
6607
-
6604
+
6608
6605
  result
6609
6606
  end
6610
6607
 
6611
6608
  def _reduce_557(val, _values, result)
6612
6609
  result = args val
6613
-
6610
+
6614
6611
  result
6615
6612
  end
6616
6613
 
6617
6614
  def _reduce_558(val, _values, result)
6618
6615
  result = args val
6619
-
6616
+
6620
6617
  result
6621
6618
  end
6622
6619
 
6623
6620
  def _reduce_559(val, _values, result)
6624
6621
  result = args val
6625
-
6622
+
6626
6623
  result
6627
6624
  end
6628
6625
 
6629
6626
  def _reduce_560(val, _values, result)
6630
6627
  result = args val
6631
-
6628
+
6632
6629
  result
6633
6630
  end
6634
6631
 
6635
6632
  def _reduce_561(val, _values, result)
6636
6633
  result = args val
6637
-
6634
+
6638
6635
  result
6639
6636
  end
6640
6637
 
6641
6638
  def _reduce_562(val, _values, result)
6642
6639
  result = args val
6643
-
6640
+
6644
6641
  result
6645
6642
  end
6646
6643
 
6647
6644
  def _reduce_563(val, _values, result)
6648
6645
  result = args val
6649
-
6646
+
6650
6647
  result
6651
6648
  end
6652
6649
 
6653
6650
  def _reduce_564(val, _values, result)
6654
6651
  result = args val
6655
-
6652
+
6656
6653
  result
6657
6654
  end
6658
6655
 
6659
6656
  def _reduce_565(val, _values, result)
6660
6657
  result = args val
6661
-
6658
+
6662
6659
  result
6663
6660
  end
6664
6661
 
6665
6662
  def _reduce_566(val, _values, result)
6666
6663
  result = args val
6667
-
6664
+
6668
6665
  result
6669
6666
  end
6670
6667
 
6671
6668
  def _reduce_567(val, _values, result)
6672
6669
  result = args val
6673
-
6670
+
6674
6671
  result
6675
6672
  end
6676
6673
 
6677
6674
  def _reduce_568(val, _values, result)
6678
6675
  result = args val
6679
-
6676
+
6680
6677
  result
6681
6678
  end
6682
6679
 
6683
6680
  def _reduce_569(val, _values, result)
6684
6681
  result = args val
6685
-
6682
+
6686
6683
  result
6687
6684
  end
6688
6685
 
6689
6686
  def _reduce_570(val, _values, result)
6690
6687
  result = args val
6691
-
6688
+
6692
6689
  result
6693
6690
  end
6694
6691
 
6695
6692
  def _reduce_571(val, _values, result)
6696
6693
  yyerror "formal argument cannot be a constant"
6697
-
6694
+
6698
6695
  result
6699
6696
  end
6700
6697
 
6701
6698
  def _reduce_572(val, _values, result)
6702
6699
  yyerror "formal argument cannot be an instance variable"
6703
-
6700
+
6704
6701
  result
6705
6702
  end
6706
6703
 
6707
6704
  def _reduce_573(val, _values, result)
6708
6705
  yyerror "formal argument cannot be a global variable"
6709
-
6706
+
6710
6707
  result
6711
6708
  end
6712
6709
 
6713
6710
  def _reduce_574(val, _values, result)
6714
6711
  yyerror "formal argument cannot be a class variable"
6715
-
6712
+
6716
6713
  result
6717
6714
  end
6718
6715
 
@@ -6723,7 +6720,7 @@ def _reduce_576(val, _values, result)
6723
6720
  self.env[identifier] = :lvar
6724
6721
 
6725
6722
  result = identifier
6726
-
6723
+
6727
6724
  result
6728
6725
  end
6729
6726
 
@@ -6731,7 +6728,7 @@ end
6731
6728
 
6732
6729
  def _reduce_578(val, _values, result)
6733
6730
  result = val[1]
6734
-
6731
+
6735
6732
  result
6736
6733
  end
6737
6734
 
@@ -6747,7 +6744,7 @@ def _reduce_579(val, _values, result)
6747
6744
  debug20 32
6748
6745
  raise "Unknown f_arg type: #{val.inspect}"
6749
6746
  end
6750
-
6747
+
6751
6748
  result
6752
6749
  end
6753
6750
 
@@ -6761,7 +6758,7 @@ def _reduce_580(val, _values, result)
6761
6758
  end
6762
6759
 
6763
6760
  result << item
6764
-
6761
+
6765
6762
  result
6766
6763
  end
6767
6764
 
@@ -6774,7 +6771,7 @@ def _reduce_581(val, _values, result)
6774
6771
 
6775
6772
  kwarg = s(:kwarg, identifier, arg).line line
6776
6773
  result = s(:array, kwarg).line line
6777
-
6774
+
6778
6775
  result
6779
6776
  end
6780
6777
 
@@ -6785,7 +6782,7 @@ def _reduce_582(val, _values, result)
6785
6782
  self.env[id] = :lvar
6786
6783
 
6787
6784
  result = s(:array, s(:kwarg, id, expr).line(line)).line line
6788
-
6785
+
6789
6786
  result
6790
6787
  end
6791
6788
 
@@ -6794,7 +6791,7 @@ end
6794
6791
  def _reduce_584(val, _values, result)
6795
6792
  list, _, item = val
6796
6793
  result = list << item.last
6797
-
6794
+
6798
6795
  result
6799
6796
  end
6800
6797
 
@@ -6802,7 +6799,7 @@ end
6802
6799
 
6803
6800
  def _reduce_586(val, _values, result)
6804
6801
  result = args val
6805
-
6802
+
6806
6803
  result
6807
6804
  end
6808
6805
 
@@ -6814,33 +6811,33 @@ def _reduce_589(val, _values, result)
6814
6811
  name = val[1].to_sym
6815
6812
  self.assignable name
6816
6813
  result = :"**#{name}"
6817
-
6814
+
6818
6815
  result
6819
6816
  end
6820
6817
 
6821
6818
  def _reduce_590(val, _values, result)
6822
6819
  result = :"**"
6823
-
6820
+
6824
6821
  result
6825
6822
  end
6826
6823
 
6827
6824
  def _reduce_591(val, _values, result)
6828
6825
  result = self.assignable val[0], val[2]
6829
6826
  # TODO: detect duplicate names
6830
-
6827
+
6831
6828
  result
6832
6829
  end
6833
6830
 
6834
6831
  def _reduce_592(val, _values, result)
6835
6832
  result = self.assignable val[0], val[2]
6836
-
6833
+
6837
6834
  result
6838
6835
  end
6839
6836
 
6840
6837
  def _reduce_593(val, _values, result)
6841
6838
  optblk, = val
6842
6839
  result = s(:block, optblk).line optblk.line
6843
-
6840
+
6844
6841
  result
6845
6842
  end
6846
6843
 
@@ -6848,20 +6845,20 @@ def _reduce_594(val, _values, result)
6848
6845
  optarg, _, optblk = val
6849
6846
  result = optarg
6850
6847
  result << optblk
6851
-
6848
+
6852
6849
  result
6853
6850
  end
6854
6851
 
6855
6852
  def _reduce_595(val, _values, result)
6856
6853
  opt, = val
6857
6854
  result = s(:block, opt).line opt.line
6858
-
6855
+
6859
6856
  result
6860
6857
  end
6861
6858
 
6862
6859
  def _reduce_596(val, _values, result)
6863
6860
  result = self.block_append val[0], val[2]
6864
-
6861
+
6865
6862
  result
6866
6863
  end
6867
6864
 
@@ -6874,7 +6871,7 @@ def _reduce_599(val, _values, result)
6874
6871
  name = val[1].to_sym
6875
6872
  self.assignable name
6876
6873
  result = :"*#{name}"
6877
-
6874
+
6878
6875
  result
6879
6876
  end
6880
6877
 
@@ -6882,7 +6879,7 @@ def _reduce_600(val, _values, result)
6882
6879
  name = :"*"
6883
6880
  self.env[name] = :lvar
6884
6881
  result = name
6885
-
6882
+
6886
6883
  result
6887
6884
  end
6888
6885
 
@@ -6895,19 +6892,19 @@ def _reduce_603(val, _values, result)
6895
6892
 
6896
6893
  self.env[identifier] = :lvar
6897
6894
  result = "&#{identifier}".to_sym
6898
-
6895
+
6899
6896
  result
6900
6897
  end
6901
6898
 
6902
6899
  def _reduce_604(val, _values, result)
6903
6900
  result = val[1]
6904
-
6901
+
6905
6902
  result
6906
6903
  end
6907
6904
 
6908
6905
  def _reduce_605(val, _values, result)
6909
6906
  result = nil
6910
-
6907
+
6911
6908
  result
6912
6909
  end
6913
6910
 
@@ -6915,7 +6912,7 @@ end
6915
6912
 
6916
6913
  def _reduce_607(val, _values, result)
6917
6914
  lexer.lex_state = EXPR_BEG
6918
-
6915
+
6919
6916
  result
6920
6917
  end
6921
6918
 
@@ -6923,13 +6920,13 @@ def _reduce_608(val, _values, result)
6923
6920
  result = val[2]
6924
6921
  yyerror "Can't define single method for literals." if
6925
6922
  result.sexp_type == :lit
6926
-
6923
+
6927
6924
  result
6928
6925
  end
6929
6926
 
6930
6927
  def _reduce_609(val, _values, result)
6931
6928
  result = s(:array).line lexer.lineno
6932
-
6929
+
6933
6930
  result
6934
6931
  end
6935
6932
 
@@ -6943,14 +6940,14 @@ def _reduce_612(val, _values, result)
6943
6940
  list.push(*more) unless more.empty?
6944
6941
  result = list
6945
6942
  result.sexp_type = :hash
6946
-
6943
+
6947
6944
  result
6948
6945
  end
6949
6946
 
6950
6947
  def _reduce_613(val, _values, result)
6951
6948
  v1, _, v2 = val
6952
6949
  result = s(:array, v1, v2).line v1.line
6953
-
6950
+
6954
6951
  result
6955
6952
  end
6956
6953
 
@@ -6959,7 +6956,7 @@ def _reduce_614(val, _values, result)
6959
6956
 
6960
6957
  lit = s(:lit, label.to_sym).line line
6961
6958
  result = s(:array, lit, arg).line line
6962
-
6959
+
6963
6960
  result
6964
6961
  end
6965
6962
 
@@ -6967,7 +6964,7 @@ def _reduce_615(val, _values, result)
6967
6964
  _, arg = val
6968
6965
  line = arg.line
6969
6966
  result = s(:array, s(:kwsplat, arg).line(line)).line line
6970
-
6967
+
6971
6968
  result
6972
6969
  end
6973
6970
 
@@ -7020,7 +7017,7 @@ end
7020
7017
  # reduce 639 omitted
7021
7018
 
7022
7019
  def _reduce_640(val, _values, result)
7023
- yyerrok
7020
+ yyerrok
7024
7021
  result
7025
7022
  end
7026
7023
 
@@ -7029,12 +7026,12 @@ end
7029
7026
  # reduce 642 omitted
7030
7027
 
7031
7028
  def _reduce_643(val, _values, result)
7032
- yyerrok
7029
+ yyerrok
7033
7030
  result
7034
7031
  end
7035
7032
 
7036
7033
  def _reduce_644(val, _values, result)
7037
- result = nil;
7034
+ result = nil;
7038
7035
  result
7039
7036
  end
7040
7037