← Back to branch summary

~ubuntu-branches/ubuntu/quantal/ruby1.9.1/quantal

« back to all changes in this revision

Viewing changes to ext/ripper/ripper.c

  • Committer: Bazaar Package Importer
  • Author(s): Lucas Nussbaum, Daigo Moriwaki, Lucas Nussbaum
  • Date: 2011-07-25 20:27:20 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20110725202720-9qfs7iam0ml7e1kc
Tags: 1.9.2.290-1
http://bugs.debian.org/628450
[ Daigo Moriwaki ]
* New upstream release.
* Removed debian/patches/110411_disable_osslv2.patch, which has been applied
  by the upstream.
* Added a patch: debian/patches/debian/patches/110716-bigdecimal,
  which was backported from the upstream (r30993)
  (CVE-2011-0188; Closes: 628450)

[ Lucas Nussbaum ]
* Build-depend on tcl-dev and tk-dev instead of {tcl,tk}8.4-dev.
* Update Lucas' email address.
* Add 110825-ossl-config.diff: backport changes to the OpenSSL
  extension to fix test failure.
* Add patch 110720_tcltk_disable_rpath.diff: disable rpath in tcltk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/ripper/ripper.c
1382
1382
    1219,  1228,  1237,  1240,  1241,  1249,  1257,  1265,  1273,  1276,
1383
1383
    1288,  1289,  1292,  1293,  1302,  1314,  1313,  1335,  1344,  1356,
1384
1384
    1365,  1377,  1386,  1398,  1407,  1416,  1424,  1432,  1442,  1443,
1385
 
    1453,  1454,  1464,  1472,  1480,  1488,  1497,  1505,  1513,  1521,
1386
 
    1529,  1537,  1547,  1548,  1558,  1566,  1576,  1584,  1594,  1598,
1387
 
    1606,  1614,  1622,  1630,  1642,  1652,  1664,  1673,  1681,  1689,
1388
 
    1697,  1705,  1718,  1731,  1742,  1750,  1753,  1761,  1769,  1779,
1389
 
    1780,  1781,  1782,  1787,  1798,  1799,  1802,  1810,  1813,  1821,
1390
 
    1821,  1831,  1832,  1833,  1834,  1835,  1836,  1837,  1838,  1839,
1391
 
    1840,  1841,  1842,  1843,  1844,  1845,  1846,  1847,  1848,  1849,
1392
 
    1850,  1851,  1852,  1853,  1854,  1855,  1856,  1857,  1858,  1859,
1393
 
    1862,  1862,  1862,  1863,  1863,  1864,  1864,  1864,  1865,  1865,
1394
 
    1865,  1865,  1866,  1866,  1866,  1866,  1867,  1867,  1867,  1868,
1395
 
    1868,  1868,  1868,  1869,  1869,  1869,  1869,  1870,  1870,  1870,
1396
 
    1870,  1871,  1871,  1871,  1871,  1872,  1872,  1872,  1872,  1873,
1397
 
    1873,  1876,  1885,  1895,  1924,  1955,  1981,  1998,  2015,  2032,
1398
 
    2043,  2054,  2065,  2079,  2093,  2101,  2109,  2117,  2125,  2133,
1399
 
    2141,  2150,  2159,  2167,  2175,  2183,  2191,  2199,  2207,  2215,
1400
 
    2223,  2231,  2239,  2247,  2255,  2263,  2274,  2282,  2290,  2298,
1401
 
    2306,  2314,  2322,  2330,  2330,  2340,  2350,  2356,  2368,  2369,
1402
 
    2373,  2381,  2391,  2401,  2402,  2405,  2406,  2409,  2418,  2426,
1403
 
    2436,  2445,  2454,  2454,  2466,  2476,  2480,  2484,  2490,  2498,
1404
 
    2506,  2520,  2536,  2550,  2565,  2575,  2576,  2577,  2578,  2579,
1405
 
    2580,  2581,  2582,  2583,  2592,  2591,  2616,  2616,  2625,  2633,
1406
 
    2641,  2649,  2662,  2670,  2678,  2686,  2694,  2702,  2702,  2712,
1407
 
    2720,  2728,  2739,  2740,  2751,  2755,  2767,  2779,  2779,  2779,
1408
 
    2790,  2790,  2790,  2801,  2812,  2821,  2823,  2820,  2887,  2886,
1409
 
    2908,  2913,  2907,  2932,  2931,  2953,  2952,  2975,  2976,  2975,
1410
 
    2996,  3004,  3012,  3020,  3030,  3042,  3048,  3054,  3060,  3066,
1411
 
    3072,  3078,  3084,  3090,  3096,  3106,  3112,  3117,  3118,  3125,
1412
 
    3130,  3133,  3134,  3147,  3148,  3158,  3159,  3162,  3170,  3180,
1413
 
    3188,  3198,  3206,  3215,  3224,  3232,  3240,  3249,  3261,  3269,
1414
 
    3279,  3287,  3295,  3303,  3311,  3319,  3328,  3336,  3344,  3352,
1415
 
    3360,  3368,  3376,  3384,  3392,  3402,  3403,  3409,  3418,  3427,
1416
 
    3438,  3439,  3449,  3456,  3465,  3473,  3479,  3482,  3479,  3500,
1417
 
    3508,  3518,  3522,  3529,  3528,  3549,  3565,  3574,  3585,  3594,
1418
 
    3604,  3614,  3622,  3633,  3644,  3652,  3660,  3675,  3674,  3694,
1419
 
    3693,  3714,  3726,  3727,  3730,  3749,  3752,  3760,  3768,  3771,
1420
 
    3775,  3778,  3786,  3789,  3790,  3798,  3801,  3818,  3819,  3820,
1421
 
    3830,  3840,  3867,  3932,  3940,  3947,  3954,  3964,  3972,  3982,
1422
 
    3990,  3997,  4004,  4015,  4022,  4033,  4040,  4051,  4058,  4087,
1423
 
    4089,  4088,  4105,  4111,  4104,  4130,  4138,  4146,  4154,  4157,
1424
 
    4168,  4169,  4170,  4171,  4174,  4204,  4205,  4206,  4214,  4224,
1425
 
    4225,  4226,  4227,  4228,  4229,  4230,  4231,  4232,  4233,  4234,
1426
 
    4235,  4238,  4248,  4258,  4259,  4262,  4271,  4270,  4278,  4290,
1427
 
    4300,  4306,  4314,  4322,  4330,  4338,  4346,  4354,  4362,  4370,
1428
 
    4378,  4386,  4394,  4402,  4410,  4419,  4428,  4437,  4446,  4455,
1429
 
    4466,  4467,  4474,  4483,  4502,  4509,  4522,  4534,  4546,  4554,
1430
 
    4570,  4578,  4594,  4595,  4598,  4611,  4622,  4623,  4626,  4643,
1431
 
    4647,  4657,  4667,  4667,  4696,  4697,  4707,  4714,  4724,  4732,
1432
 
    4742,  4743,  4744,  4747,  4748,  4749,  4750,  4753,  4754,  4755,
1433
 
    4758,  4763,  4770,  4771,  4774,  4775,  4778,  4781,  4784,  4785,
1434
 
    4786,  4789,  4790,  4793,  4794,  4798
 
1385
    1453,  1454,  1464,  1472,  1480,  1488,  1497,  1505,  1514,  1522,
 
1386
    1531,  1539,  1550,  1551,  1561,  1569,  1579,  1587,  1597,  1601,
 
1387
    1609,  1617,  1625,  1633,  1645,  1655,  1667,  1676,  1684,  1692,
 
1388
    1700,  1708,  1721,  1734,  1745,  1753,  1756,  1764,  1772,  1782,
 
1389
    1783,  1784,  1785,  1790,  1801,  1802,  1805,  1813,  1816,  1824,
 
1390
    1824,  1834,  1835,  1836,  1837,  1838,  1839,  1840,  1841,  1842,
 
1391
    1843,  1844,  1845,  1846,  1847,  1848,  1849,  1850,  1851,  1852,
 
1392
    1853,  1854,  1855,  1856,  1857,  1858,  1859,  1860,  1861,  1862,
 
1393
    1865,  1865,  1865,  1866,  1866,  1867,  1867,  1867,  1868,  1868,
 
1394
    1868,  1868,  1869,  1869,  1869,  1869,  1870,  1870,  1870,  1871,
 
1395
    1871,  1871,  1871,  1872,  1872,  1872,  1872,  1873,  1873,  1873,
 
1396
    1873,  1874,  1874,  1874,  1874,  1875,  1875,  1875,  1875,  1876,
 
1397
    1876,  1879,  1888,  1898,  1927,  1958,  1984,  2001,  2018,  2035,
 
1398
    2046,  2057,  2068,  2082,  2096,  2104,  2112,  2120,  2128,  2136,
 
1399
    2144,  2153,  2162,  2170,  2178,  2186,  2194,  2202,  2210,  2218,
 
1400
    2226,  2234,  2242,  2250,  2258,  2266,  2277,  2285,  2293,  2301,
 
1401
    2309,  2317,  2325,  2333,  2333,  2343,  2353,  2359,  2371,  2372,
 
1402
    2376,  2384,  2394,  2404,  2405,  2408,  2409,  2412,  2421,  2429,
 
1403
    2439,  2448,  2457,  2457,  2469,  2479,  2483,  2487,  2493,  2501,
 
1404
    2509,  2523,  2539,  2553,  2568,  2578,  2579,  2580,  2581,  2582,
 
1405
    2583,  2584,  2585,  2586,  2595,  2594,  2619,  2619,  2628,  2636,
 
1406
    2644,  2652,  2665,  2673,  2681,  2689,  2697,  2705,  2705,  2715,
 
1407
    2723,  2731,  2742,  2743,  2754,  2758,  2770,  2782,  2782,  2782,
 
1408
    2793,  2793,  2793,  2804,  2815,  2824,  2826,  2823,  2890,  2889,
 
1409
    2911,  2916,  2910,  2935,  2934,  2956,  2955,  2978,  2979,  2978,
 
1410
    2999,  3007,  3015,  3023,  3033,  3045,  3051,  3057,  3063,  3069,
 
1411
    3075,  3081,  3087,  3093,  3099,  3109,  3115,  3120,  3121,  3128,
 
1412
    3133,  3136,  3137,  3150,  3151,  3161,  3162,  3165,  3173,  3183,
 
1413
    3191,  3201,  3209,  3218,  3227,  3235,  3243,  3252,  3264,  3272,
 
1414
    3282,  3290,  3298,  3306,  3314,  3322,  3331,  3339,  3347,  3355,
 
1415
    3363,  3371,  3379,  3387,  3395,  3405,  3406,  3412,  3421,  3430,
 
1416
    3441,  3442,  3452,  3459,  3468,  3476,  3482,  3485,  3482,  3503,
 
1417
    3511,  3521,  3525,  3532,  3531,  3552,  3568,  3577,  3588,  3597,
 
1418
    3607,  3617,  3625,  3636,  3647,  3655,  3663,  3678,  3677,  3697,
 
1419
    3696,  3717,  3729,  3730,  3733,  3752,  3755,  3763,  3771,  3774,
 
1420
    3778,  3781,  3789,  3792,  3793,  3801,  3804,  3821,  3822,  3823,
 
1421
    3833,  3843,  3870,  3935,  3944,  3955,  3962,  3972,  3980,  3990,
 
1422
    3999,  4010,  4017,  4028,  4035,  4046,  4053,  4064,  4071,  4100,
 
1423
    4102,  4101,  4118,  4124,  4117,  4143,  4151,  4159,  4167,  4170,
 
1424
    4181,  4182,  4183,  4184,  4187,  4217,  4218,  4219,  4227,  4237,
 
1425
    4238,  4239,  4240,  4241,  4242,  4243,  4244,  4245,  4246,  4247,
 
1426
    4248,  4251,  4261,  4271,  4272,  4275,  4284,  4283,  4291,  4303,
 
1427
    4313,  4319,  4327,  4335,  4343,  4351,  4359,  4367,  4375,  4383,
 
1428
    4391,  4399,  4407,  4415,  4423,  4432,  4441,  4450,  4459,  4468,
 
1429
    4479,  4480,  4487,  4496,  4515,  4522,  4535,  4547,  4559,  4567,
 
1430
    4583,  4591,  4607,  4608,  4611,  4624,  4635,  4636,  4639,  4656,
 
1431
    4660,  4670,  4680,  4680,  4709,  4710,  4720,  4727,  4737,  4745,
 
1432
    4755,  4756,  4757,  4760,  4761,  4762,  4763,  4766,  4767,  4768,
 
1433
    4771,  4776,  4783,  4784,  4787,  4788,  4791,  4794,  4797,  4798,
 
1434
    4799,  4802,  4803,  4806,  4807,  4811
1435
1435
};
1436
1436
#endif
1437
1437
 
5942
5942
#if 0
5943
5943
                        (yyval.val) = NEW_MASGN((yyvsp[(1) - (4)].val), NEW_POSTARG(-1, (yyvsp[(4) - (4)].val)));
5944
5944
#endif
5945
 
                        (yyval.val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
 
5945
                        (yyvsp[(1) - (4)].val) = mlhs_add_star((yyvsp[(1) - (4)].val), Qnil);
 
5946
                        (yyval.val) = mlhs_add((yyvsp[(1) - (4)].val), (yyvsp[(4) - (4)].val));
5946
5947
 
5947
5948
                    ;}
5948
5949
    break;
5950
5951
  case 78:
5951
5952
 
5952
5953
/* Line 1464 of yacc.c  */
5953
 
#line 1514 "ripper.y"
 
5954
#line 1515 "ripper.y"
5954
5955
    {
5955
5956
#if 0
5956
5957
                        (yyval.val) = NEW_MASGN(0, (yyvsp[(2) - (2)].val));
5963
5964
  case 79:
5964
5965
 
5965
5966
/* Line 1464 of yacc.c  */
5966
 
#line 1522 "ripper.y"
 
5967
#line 1523 "ripper.y"
5967
5968
    {
5968
5969
#if 0
5969
5970
                        (yyval.val) = NEW_MASGN(0, NEW_POSTARG((yyvsp[(2) - (4)].val),(yyvsp[(4) - (4)].val)));
5970
5971
#endif
5971
 
                        (yyval.val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
 
5972
                        (yyvsp[(2) - (4)].val) = mlhs_add_star(mlhs_new(), (yyvsp[(2) - (4)].val));
 
5973
                        (yyval.val) = mlhs_add((yyvsp[(2) - (4)].val), (yyvsp[(4) - (4)].val));
5972
5974
 
5973
5975
                    ;}
5974
5976
    break;
5976
5978
  case 80:
5977
5979
 
5978
5980
/* Line 1464 of yacc.c  */
5979
 
#line 1530 "ripper.y"
 
5981
#line 1532 "ripper.y"
5980
5982
    {
5981
5983
#if 0
5982
5984
                        (yyval.val) = NEW_MASGN(0, -1);
5989
5991
  case 81:
5990
5992
 
5991
5993
/* Line 1464 of yacc.c  */
5992
 
#line 1538 "ripper.y"
 
5994
#line 1540 "ripper.y"
5993
5995
    {
5994
5996
#if 0
5995
5997
                        (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
5996
5998
#endif
5997
5999
                        (yyval.val) = mlhs_add_star(mlhs_new(), Qnil);
 
6000
                        (yyval.val) = mlhs_add((yyval.val), (yyvsp[(3) - (3)].val));
5998
6001
 
5999
6002
                    ;}
6000
6003
    break;
6002
6005
  case 83:
6003
6006
 
6004
6007
/* Line 1464 of yacc.c  */
6005
 
#line 1549 "ripper.y"
 
6008
#line 1552 "ripper.y"
6006
6009
    {
6007
6010
#if 0
6008
6011
                        (yyval.val) = (yyvsp[(2) - (3)].val);
6015
6018
  case 84:
6016
6019
 
6017
6020
/* Line 1464 of yacc.c  */
6018
 
#line 1559 "ripper.y"
 
6021
#line 1562 "ripper.y"
6019
6022
    {
6020
6023
#if 0
6021
6024
                        (yyval.val) = NEW_LIST((yyvsp[(1) - (2)].val));
6028
6031
  case 85:
6029
6032
 
6030
6033
/* Line 1464 of yacc.c  */
6031
 
#line 1567 "ripper.y"
 
6034
#line 1570 "ripper.y"
6032
6035
    {
6033
6036
#if 0
6034
6037
                        (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
6041
6044
  case 86:
6042
6045
 
6043
6046
/* Line 1464 of yacc.c  */
6044
 
#line 1577 "ripper.y"
 
6047
#line 1580 "ripper.y"
6045
6048
    {
6046
6049
#if 0
6047
6050
                        (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
6054
6057
  case 87:
6055
6058
 
6056
6059
/* Line 1464 of yacc.c  */
6057
 
#line 1585 "ripper.y"
 
6060
#line 1588 "ripper.y"
6058
6061
    {
6059
6062
#if 0
6060
6063
                        (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6067
6070
  case 88:
6068
6071
 
6069
6072
/* Line 1464 of yacc.c  */
6070
 
#line 1595 "ripper.y"
 
6073
#line 1598 "ripper.y"
6071
6074
    {
6072
6075
                        (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6073
6076
                    ;}
6076
6079
  case 89:
6077
6080
 
6078
6081
/* Line 1464 of yacc.c  */
6079
 
#line 1599 "ripper.y"
 
6082
#line 1602 "ripper.y"
6080
6083
    {
6081
6084
#if 0
6082
6085
                        (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6089
6092
  case 90:
6090
6093
 
6091
6094
/* Line 1464 of yacc.c  */
6092
 
#line 1607 "ripper.y"
 
6095
#line 1610 "ripper.y"
6093
6096
    {
6094
6097
#if 0
6095
6098
                        (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6102
6105
  case 91:
6103
6106
 
6104
6107
/* Line 1464 of yacc.c  */
6105
 
#line 1615 "ripper.y"
 
6108
#line 1618 "ripper.y"
6106
6109
    {
6107
6110
#if 0
6108
6111
                        (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6115
6118
  case 92:
6116
6119
 
6117
6120
/* Line 1464 of yacc.c  */
6118
 
#line 1623 "ripper.y"
 
6121
#line 1626 "ripper.y"
6119
6122
    {
6120
6123
#if 0
6121
6124
                        (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6128
6131
  case 93:
6129
6132
 
6130
6133
/* Line 1464 of yacc.c  */
6131
 
#line 1631 "ripper.y"
 
6134
#line 1634 "ripper.y"
6132
6135
    {
6133
6136
#if 0
6134
6137
                        if (in_def || in_single)
6145
6148
  case 94:
6146
6149
 
6147
6150
/* Line 1464 of yacc.c  */
6148
 
#line 1643 "ripper.y"
 
6151
#line 1646 "ripper.y"
6149
6152
    {
6150
6153
#if 0
6151
6154
                        if (in_def || in_single)
6160
6163
  case 95:
6161
6164
 
6162
6165
/* Line 1464 of yacc.c  */
6163
 
#line 1653 "ripper.y"
 
6166
#line 1656 "ripper.y"
6164
6167
    {
6165
6168
#if 0
6166
6169
                        rb_backref_error((yyvsp[(1) - (1)].val));
6175
6178
  case 96:
6176
6179
 
6177
6180
/* Line 1464 of yacc.c  */
6178
 
#line 1665 "ripper.y"
 
6181
#line 1668 "ripper.y"
6179
6182
    {
6180
6183
                        (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
6181
6184
#if 0
6189
6192
  case 97:
6190
6193
 
6191
6194
/* Line 1464 of yacc.c  */
6192
 
#line 1674 "ripper.y"
 
6195
#line 1677 "ripper.y"
6193
6196
    {
6194
6197
#if 0
6195
6198
                        (yyval.val) = aryset((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val));
6202
6205
  case 98:
6203
6206
 
6204
6207
/* Line 1464 of yacc.c  */
6205
 
#line 1682 "ripper.y"
 
6208
#line 1685 "ripper.y"
6206
6209
    {
6207
6210
#if 0
6208
6211
                        (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6215
6218
  case 99:
6216
6219
 
6217
6220
/* Line 1464 of yacc.c  */
6218
 
#line 1690 "ripper.y"
 
6221
#line 1693 "ripper.y"
6219
6222
    {
6220
6223
#if 0
6221
6224
                        (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6228
6231
  case 100:
6229
6232
 
6230
6233
/* Line 1464 of yacc.c  */
6231
 
#line 1698 "ripper.y"
 
6234
#line 1701 "ripper.y"
6232
6235
    {
6233
6236
#if 0
6234
6237
                        (yyval.val) = attrset((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6241
6244
  case 101:
6242
6245
 
6243
6246
/* Line 1464 of yacc.c  */
6244
 
#line 1706 "ripper.y"
 
6247
#line 1709 "ripper.y"
6245
6248
    {
6246
6249
#if 0
6247
6250
                        if (in_def || in_single)
6259
6262
  case 102:
6260
6263
 
6261
6264
/* Line 1464 of yacc.c  */
6262
 
#line 1719 "ripper.y"
 
6265
#line 1722 "ripper.y"
6263
6266
    {
6264
6267
#if 0
6265
6268
                        if (in_def || in_single)
6277
6280
  case 103:
6278
6281
 
6279
6282
/* Line 1464 of yacc.c  */
6280
 
#line 1732 "ripper.y"
 
6283
#line 1735 "ripper.y"
6281
6284
    {
6282
6285
#if 0
6283
6286
                        rb_backref_error((yyvsp[(1) - (1)].val));
6291
6294
  case 104:
6292
6295
 
6293
6296
/* Line 1464 of yacc.c  */
6294
 
#line 1743 "ripper.y"
 
6297
#line 1746 "ripper.y"
6295
6298
    {
6296
6299
#if 0
6297
6300
                        yyerror("class/module name must be CONSTANT");
6304
6307
  case 106:
6305
6308
 
6306
6309
/* Line 1464 of yacc.c  */
6307
 
#line 1754 "ripper.y"
 
6310
#line 1757 "ripper.y"
6308
6311
    {
6309
6312
#if 0
6310
6313
                        (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
6317
6320
  case 107:
6318
6321
 
6319
6322
/* Line 1464 of yacc.c  */
6320
 
#line 1762 "ripper.y"
 
6323
#line 1765 "ripper.y"
6321
6324
    {
6322
6325
#if 0
6323
6326
                        (yyval.val) = NEW_COLON2(0, (yyval.val));
6330
6333
  case 108:
6331
6334
 
6332
6335
/* Line 1464 of yacc.c  */
6333
 
#line 1770 "ripper.y"
 
6336
#line 1773 "ripper.y"
6334
6337
    {
6335
6338
#if 0
6336
6339
                        (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
6343
6346
  case 112:
6344
6347
 
6345
6348
/* Line 1464 of yacc.c  */
6346
 
#line 1783 "ripper.y"
 
6349
#line 1786 "ripper.y"
6347
6350
    {
6348
6351
                        lex_state = EXPR_ENDFN;
6349
6352
                        (yyval.val) = (yyvsp[(1) - (1)].val);
6353
6356
  case 113:
6354
6357
 
6355
6358
/* Line 1464 of yacc.c  */
6356
 
#line 1788 "ripper.y"
 
6359
#line 1791 "ripper.y"
6357
6360
    {
6358
6361
                        lex_state = EXPR_ENDFN;
6359
6362
#if 0
6367
6370
  case 116:
6368
6371
 
6369
6372
/* Line 1464 of yacc.c  */
6370
 
#line 1803 "ripper.y"
 
6373
#line 1806 "ripper.y"
6371
6374
    {
6372
6375
#if 0
6373
6376
                        (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
6380
6383
  case 118:
6381
6384
 
6382
6385
/* Line 1464 of yacc.c  */
6383
 
#line 1814 "ripper.y"
 
6386
#line 1817 "ripper.y"
6384
6387
    {
6385
6388
#if 0
6386
6389
                        (yyval.val) = NEW_UNDEF((yyvsp[(1) - (1)].val));
6393
6396
  case 119:
6394
6397
 
6395
6398
/* Line 1464 of yacc.c  */
6396
 
#line 1821 "ripper.y"
 
6399
#line 1824 "ripper.y"
6397
6400
    {lex_state = EXPR_FNAME;;}
6398
6401
    break;
6399
6402
 
6400
6403
  case 120:
6401
6404
 
6402
6405
/* Line 1464 of yacc.c  */
6403
 
#line 1822 "ripper.y"
 
6406
#line 1825 "ripper.y"
6404
6407
    {
6405
6408
#if 0
6406
6409
                        (yyval.val) = block_append((yyvsp[(1) - (4)].val), NEW_UNDEF((yyvsp[(4) - (4)].val)));
6413
6416
  case 121:
6414
6417
 
6415
6418
/* Line 1464 of yacc.c  */
6416
 
#line 1831 "ripper.y"
 
6419
#line 1834 "ripper.y"
6417
6420
    { ifndef_ripper((yyval.val) = '|'); ;}
6418
6421
    break;
6419
6422
 
6420
6423
  case 122:
6421
6424
 
6422
6425
/* Line 1464 of yacc.c  */
6423
 
#line 1832 "ripper.y"
 
6426
#line 1835 "ripper.y"
6424
6427
    { ifndef_ripper((yyval.val) = '^'); ;}
6425
6428
    break;
6426
6429
 
6427
6430
  case 123:
6428
6431
 
6429
6432
/* Line 1464 of yacc.c  */
6430
 
#line 1833 "ripper.y"
 
6433
#line 1836 "ripper.y"
6431
6434
    { ifndef_ripper((yyval.val) = '&'); ;}
6432
6435
    break;
6433
6436
 
6434
6437
  case 124:
6435
6438
 
6436
6439
/* Line 1464 of yacc.c  */
6437
 
#line 1834 "ripper.y"
 
6440
#line 1837 "ripper.y"
6438
6441
    { ifndef_ripper((yyval.val) = tCMP); ;}
6439
6442
    break;
6440
6443
 
6441
6444
  case 125:
6442
6445
 
6443
6446
/* Line 1464 of yacc.c  */
6444
 
#line 1835 "ripper.y"
 
6447
#line 1838 "ripper.y"
6445
6448
    { ifndef_ripper((yyval.val) = tEQ); ;}
6446
6449
    break;
6447
6450
 
6448
6451
  case 126:
6449
6452
 
6450
6453
/* Line 1464 of yacc.c  */
6451
 
#line 1836 "ripper.y"
 
6454
#line 1839 "ripper.y"
6452
6455
    { ifndef_ripper((yyval.val) = tEQQ); ;}
6453
6456
    break;
6454
6457
 
6455
6458
  case 127:
6456
6459
 
6457
6460
/* Line 1464 of yacc.c  */
6458
 
#line 1837 "ripper.y"
 
6461
#line 1840 "ripper.y"
6459
6462
    { ifndef_ripper((yyval.val) = tMATCH); ;}
6460
6463
    break;
6461
6464
 
6462
6465
  case 128:
6463
6466
 
6464
6467
/* Line 1464 of yacc.c  */
6465
 
#line 1838 "ripper.y"
 
6468
#line 1841 "ripper.y"
6466
6469
    { ifndef_ripper((yyval.val) = tNMATCH); ;}
6467
6470
    break;
6468
6471
 
6469
6472
  case 129:
6470
6473
 
6471
6474
/* Line 1464 of yacc.c  */
6472
 
#line 1839 "ripper.y"
 
6475
#line 1842 "ripper.y"
6473
6476
    { ifndef_ripper((yyval.val) = '>'); ;}
6474
6477
    break;
6475
6478
 
6476
6479
  case 130:
6477
6480
 
6478
6481
/* Line 1464 of yacc.c  */
6479
 
#line 1840 "ripper.y"
 
6482
#line 1843 "ripper.y"
6480
6483
    { ifndef_ripper((yyval.val) = tGEQ); ;}
6481
6484
    break;
6482
6485
 
6483
6486
  case 131:
6484
6487
 
6485
6488
/* Line 1464 of yacc.c  */
6486
 
#line 1841 "ripper.y"
 
6489
#line 1844 "ripper.y"
6487
6490
    { ifndef_ripper((yyval.val) = '<'); ;}
6488
6491
    break;
6489
6492
 
6490
6493
  case 132:
6491
6494
 
6492
6495
/* Line 1464 of yacc.c  */
6493
 
#line 1842 "ripper.y"
 
6496
#line 1845 "ripper.y"
6494
6497
    { ifndef_ripper((yyval.val) = tLEQ); ;}
6495
6498
    break;
6496
6499
 
6497
6500
  case 133:
6498
6501
 
6499
6502
/* Line 1464 of yacc.c  */
6500
 
#line 1843 "ripper.y"
 
6503
#line 1846 "ripper.y"
6501
6504
    { ifndef_ripper((yyval.val) = tNEQ); ;}
6502
6505
    break;
6503
6506
 
6504
6507
  case 134:
6505
6508
 
6506
6509
/* Line 1464 of yacc.c  */
6507
 
#line 1844 "ripper.y"
 
6510
#line 1847 "ripper.y"
6508
6511
    { ifndef_ripper((yyval.val) = tLSHFT); ;}
6509
6512
    break;
6510
6513
 
6511
6514
  case 135:
6512
6515
 
6513
6516
/* Line 1464 of yacc.c  */
6514
 
#line 1845 "ripper.y"
 
6517
#line 1848 "ripper.y"
6515
6518
    { ifndef_ripper((yyval.val) = tRSHFT); ;}
6516
6519
    break;
6517
6520
 
6518
6521
  case 136:
6519
6522
 
6520
6523
/* Line 1464 of yacc.c  */
6521
 
#line 1846 "ripper.y"
 
6524
#line 1849 "ripper.y"
6522
6525
    { ifndef_ripper((yyval.val) = '+'); ;}
6523
6526
    break;
6524
6527
 
6525
6528
  case 137:
6526
6529
 
6527
6530
/* Line 1464 of yacc.c  */
6528
 
#line 1847 "ripper.y"
 
6531
#line 1850 "ripper.y"
6529
6532
    { ifndef_ripper((yyval.val) = '-'); ;}
6530
6533
    break;
6531
6534
 
6532
6535
  case 138:
6533
6536
 
6534
6537
/* Line 1464 of yacc.c  */
6535
 
#line 1848 "ripper.y"
 
6538
#line 1851 "ripper.y"
6536
6539
    { ifndef_ripper((yyval.val) = '*'); ;}
6537
6540
    break;
6538
6541
 
6539
6542
  case 139:
6540
6543
 
6541
6544
/* Line 1464 of yacc.c  */
6542
 
#line 1849 "ripper.y"
 
6545
#line 1852 "ripper.y"
6543
6546
    { ifndef_ripper((yyval.val) = '*'); ;}
6544
6547
    break;
6545
6548
 
6546
6549
  case 140:
6547
6550
 
6548
6551
/* Line 1464 of yacc.c  */
6549
 
#line 1850 "ripper.y"
 
6552
#line 1853 "ripper.y"
6550
6553
    { ifndef_ripper((yyval.val) = '/'); ;}
6551
6554
    break;
6552
6555
 
6553
6556
  case 141:
6554
6557
 
6555
6558
/* Line 1464 of yacc.c  */
6556
 
#line 1851 "ripper.y"
 
6559
#line 1854 "ripper.y"
6557
6560
    { ifndef_ripper((yyval.val) = '%'); ;}
6558
6561
    break;
6559
6562
 
6560
6563
  case 142:
6561
6564
 
6562
6565
/* Line 1464 of yacc.c  */
6563
 
#line 1852 "ripper.y"
 
6566
#line 1855 "ripper.y"
6564
6567
    { ifndef_ripper((yyval.val) = tPOW); ;}
6565
6568
    break;
6566
6569
 
6567
6570
  case 143:
6568
6571
 
6569
6572
/* Line 1464 of yacc.c  */
6570
 
#line 1853 "ripper.y"
 
6573
#line 1856 "ripper.y"
6571
6574
    { ifndef_ripper((yyval.val) = '!'); ;}
6572
6575
    break;
6573
6576
 
6574
6577
  case 144:
6575
6578
 
6576
6579
/* Line 1464 of yacc.c  */
6577
 
#line 1854 "ripper.y"
 
6580
#line 1857 "ripper.y"
6578
6581
    { ifndef_ripper((yyval.val) = '~'); ;}
6579
6582
    break;
6580
6583
 
6581
6584
  case 145:
6582
6585
 
6583
6586
/* Line 1464 of yacc.c  */
6584
 
#line 1855 "ripper.y"
 
6587
#line 1858 "ripper.y"
6585
6588
    { ifndef_ripper((yyval.val) = tUPLUS); ;}
6586
6589
    break;
6587
6590
 
6588
6591
  case 146:
6589
6592
 
6590
6593
/* Line 1464 of yacc.c  */
6591
 
#line 1856 "ripper.y"
 
6594
#line 1859 "ripper.y"
6592
6595
    { ifndef_ripper((yyval.val) = tUMINUS); ;}
6593
6596
    break;
6594
6597
 
6595
6598
  case 147:
6596
6599
 
6597
6600
/* Line 1464 of yacc.c  */
6598
 
#line 1857 "ripper.y"
 
6601
#line 1860 "ripper.y"
6599
6602
    { ifndef_ripper((yyval.val) = tAREF); ;}
6600
6603
    break;
6601
6604
 
6602
6605
  case 148:
6603
6606
 
6604
6607
/* Line 1464 of yacc.c  */
6605
 
#line 1858 "ripper.y"
 
6608
#line 1861 "ripper.y"
6606
6609
    { ifndef_ripper((yyval.val) = tASET); ;}
6607
6610
    break;
6608
6611
 
6609
6612
  case 149:
6610
6613
 
6611
6614
/* Line 1464 of yacc.c  */
6612
 
#line 1859 "ripper.y"
 
6615
#line 1862 "ripper.y"
6613
6616
    { ifndef_ripper((yyval.val) = '`'); ;}
6614
6617
    break;
6615
6618
 
6616
6619
  case 191:
6617
6620
 
6618
6621
/* Line 1464 of yacc.c  */
6619
 
#line 1877 "ripper.y"
 
6622
#line 1880 "ripper.y"
6620
6623
    {
6621
6624
#if 0
6622
6625
                        value_expr((yyvsp[(3) - (3)].val));
6630
6633
  case 192:
6631
6634
 
6632
6635
/* Line 1464 of yacc.c  */
6633
 
#line 1886 "ripper.y"
 
6636
#line 1889 "ripper.y"
6634
6637
    {
6635
6638
#if 0
6636
6639
                        value_expr((yyvsp[(3) - (5)].val));
6645
6648
  case 193:
6646
6649
 
6647
6650
/* Line 1464 of yacc.c  */
6648
 
#line 1896 "ripper.y"
 
6651
#line 1899 "ripper.y"
6649
6652
    {
6650
6653
#if 0
6651
6654
                        value_expr((yyvsp[(3) - (3)].val));
6679
6682
  case 194:
6680
6683
 
6681
6684
/* Line 1464 of yacc.c  */
6682
 
#line 1925 "ripper.y"
 
6685
#line 1928 "ripper.y"
6683
6686
    {
6684
6687
#if 0
6685
6688
                        value_expr((yyvsp[(3) - (5)].val));
6715
6718
  case 195:
6716
6719
 
6717
6720
/* Line 1464 of yacc.c  */
6718
 
#line 1956 "ripper.y"
 
6721
#line 1959 "ripper.y"
6719
6722
    {
6720
6723
#if 0
6721
6724
                        NODE *args;
6746
6749
  case 196:
6747
6750
 
6748
6751
/* Line 1464 of yacc.c  */
6749
 
#line 1982 "ripper.y"
 
6752
#line 1985 "ripper.y"
6750
6753
    {
6751
6754
#if 0
6752
6755
                        value_expr((yyvsp[(5) - (5)].val));
6768
6771
  case 197:
6769
6772
 
6770
6773
/* Line 1464 of yacc.c  */
6771
 
#line 1999 "ripper.y"
 
6774
#line 2002 "ripper.y"
6772
6775
    {
6773
6776
#if 0
6774
6777
                        value_expr((yyvsp[(5) - (5)].val));
6790
6793
  case 198:
6791
6794
 
6792
6795
/* Line 1464 of yacc.c  */
6793
 
#line 2016 "ripper.y"
 
6796
#line 2019 "ripper.y"
6794
6797
    {
6795
6798
#if 0
6796
6799
                        value_expr((yyvsp[(5) - (5)].val));
6812
6815
  case 199:
6813
6816
 
6814
6817
/* Line 1464 of yacc.c  */
6815
 
#line 2033 "ripper.y"
 
6818
#line 2036 "ripper.y"
6816
6819
    {
6817
6820
#if 0
6818
6821
                        yyerror("constant re-assignment");
6828
6831
  case 200:
6829
6832
 
6830
6833
/* Line 1464 of yacc.c  */
6831
 
#line 2044 "ripper.y"
 
6834
#line 2047 "ripper.y"
6832
6835
    {
6833
6836
#if 0
6834
6837
                        yyerror("constant re-assignment");
6844
6847
  case 201:
6845
6848
 
6846
6849
/* Line 1464 of yacc.c  */
6847
 
#line 2055 "ripper.y"
 
6850
#line 2058 "ripper.y"
6848
6851
    {
6849
6852
#if 0
6850
6853
                        rb_backref_error((yyvsp[(1) - (3)].val));
6860
6863
  case 202:
6861
6864
 
6862
6865
/* Line 1464 of yacc.c  */
6863
 
#line 2066 "ripper.y"
 
6866
#line 2069 "ripper.y"
6864
6867
    {
6865
6868
#if 0
6866
6869
                        value_expr((yyvsp[(1) - (3)].val));
6879
6882
  case 203:
6880
6883
 
6881
6884
/* Line 1464 of yacc.c  */
6882
 
#line 2080 "ripper.y"
 
6885
#line 2083 "ripper.y"
6883
6886
    {
6884
6887
#if 0
6885
6888
                        value_expr((yyvsp[(1) - (3)].val));
6898
6901
  case 204:
6899
6902
 
6900
6903
/* Line 1464 of yacc.c  */
6901
 
#line 2094 "ripper.y"
 
6904
#line 2097 "ripper.y"
6902
6905
    {
6903
6906
#if 0
6904
6907
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '+', (yyvsp[(3) - (3)].val));
6911
6914
  case 205:
6912
6915
 
6913
6916
/* Line 1464 of yacc.c  */
6914
 
#line 2102 "ripper.y"
 
6917
#line 2105 "ripper.y"
6915
6918
    {
6916
6919
#if 0
6917
6920
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '-', (yyvsp[(3) - (3)].val));
6924
6927
  case 206:
6925
6928
 
6926
6929
/* Line 1464 of yacc.c  */
6927
 
#line 2110 "ripper.y"
 
6930
#line 2113 "ripper.y"
6928
6931
    {
6929
6932
#if 0
6930
6933
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '*', (yyvsp[(3) - (3)].val));
6937
6940
  case 207:
6938
6941
 
6939
6942
/* Line 1464 of yacc.c  */
6940
 
#line 2118 "ripper.y"
 
6943
#line 2121 "ripper.y"
6941
6944
    {
6942
6945
#if 0
6943
6946
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '/', (yyvsp[(3) - (3)].val));
6950
6953
  case 208:
6951
6954
 
6952
6955
/* Line 1464 of yacc.c  */
6953
 
#line 2126 "ripper.y"
 
6956
#line 2129 "ripper.y"
6954
6957
    {
6955
6958
#if 0
6956
6959
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '%', (yyvsp[(3) - (3)].val));
6963
6966
  case 209:
6964
6967
 
6965
6968
/* Line 1464 of yacc.c  */
6966
 
#line 2134 "ripper.y"
 
6969
#line 2137 "ripper.y"
6967
6970
    {
6968
6971
#if 0
6969
6972
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tPOW, (yyvsp[(3) - (3)].val));
6976
6979
  case 210:
6977
6980
 
6978
6981
/* Line 1464 of yacc.c  */
6979
 
#line 2142 "ripper.y"
 
6982
#line 2145 "ripper.y"
6980
6983
    {
6981
6984
#if 0
6982
6985
                        (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
6990
6993
  case 211:
6991
6994
 
6992
6995
/* Line 1464 of yacc.c  */
6993
 
#line 2151 "ripper.y"
 
6996
#line 2154 "ripper.y"
6994
6997
    {
6995
6998
#if 0
6996
6999
                        (yyval.val) = NEW_CALL(call_bin_op((yyvsp[(2) - (4)].val), tPOW, (yyvsp[(4) - (4)].val)), tUMINUS, 0);
7004
7007
  case 212:
7005
7008
 
7006
7009
/* Line 1464 of yacc.c  */
7007
 
#line 2160 "ripper.y"
 
7010
#line 2163 "ripper.y"
7008
7011
    {
7009
7012
#if 0
7010
7013
                        (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUPLUS);
7017
7020
  case 213:
7018
7021
 
7019
7022
/* Line 1464 of yacc.c  */
7020
 
#line 2168 "ripper.y"
 
7023
#line 2171 "ripper.y"
7021
7024
    {
7022
7025
#if 0
7023
7026
                        (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), tUMINUS);
7030
7033
  case 214:
7031
7034
 
7032
7035
/* Line 1464 of yacc.c  */
7033
 
#line 2176 "ripper.y"
 
7036
#line 2179 "ripper.y"
7034
7037
    {
7035
7038
#if 0
7036
7039
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '|', (yyvsp[(3) - (3)].val));
7043
7046
  case 215:
7044
7047
 
7045
7048
/* Line 1464 of yacc.c  */
7046
 
#line 2184 "ripper.y"
 
7049
#line 2187 "ripper.y"
7047
7050
    {
7048
7051
#if 0
7049
7052
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '^', (yyvsp[(3) - (3)].val));
7056
7059
  case 216:
7057
7060
 
7058
7061
/* Line 1464 of yacc.c  */
7059
 
#line 2192 "ripper.y"
 
7062
#line 2195 "ripper.y"
7060
7063
    {
7061
7064
#if 0
7062
7065
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '&', (yyvsp[(3) - (3)].val));
7069
7072
  case 217:
7070
7073
 
7071
7074
/* Line 1464 of yacc.c  */
7072
 
#line 2200 "ripper.y"
 
7075
#line 2203 "ripper.y"
7073
7076
    {
7074
7077
#if 0
7075
7078
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tCMP, (yyvsp[(3) - (3)].val));
7082
7085
  case 218:
7083
7086
 
7084
7087
/* Line 1464 of yacc.c  */
7085
 
#line 2208 "ripper.y"
 
7088
#line 2211 "ripper.y"
7086
7089
    {
7087
7090
#if 0
7088
7091
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '>', (yyvsp[(3) - (3)].val));
7095
7098
  case 219:
7096
7099
 
7097
7100
/* Line 1464 of yacc.c  */
7098
 
#line 2216 "ripper.y"
 
7101
#line 2219 "ripper.y"
7099
7102
    {
7100
7103
#if 0
7101
7104
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tGEQ, (yyvsp[(3) - (3)].val));
7108
7111
  case 220:
7109
7112
 
7110
7113
/* Line 1464 of yacc.c  */
7111
 
#line 2224 "ripper.y"
 
7114
#line 2227 "ripper.y"
7112
7115
    {
7113
7116
#if 0
7114
7117
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), '<', (yyvsp[(3) - (3)].val));
7121
7124
  case 221:
7122
7125
 
7123
7126
/* Line 1464 of yacc.c  */
7124
 
#line 2232 "ripper.y"
 
7127
#line 2235 "ripper.y"
7125
7128
    {
7126
7129
#if 0
7127
7130
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLEQ, (yyvsp[(3) - (3)].val));
7134
7137
  case 222:
7135
7138
 
7136
7139
/* Line 1464 of yacc.c  */
7137
 
#line 2240 "ripper.y"
 
7140
#line 2243 "ripper.y"
7138
7141
    {
7139
7142
#if 0
7140
7143
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQ, (yyvsp[(3) - (3)].val));
7147
7150
  case 223:
7148
7151
 
7149
7152
/* Line 1464 of yacc.c  */
7150
 
#line 2248 "ripper.y"
 
7153
#line 2251 "ripper.y"
7151
7154
    {
7152
7155
#if 0
7153
7156
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tEQQ, (yyvsp[(3) - (3)].val));
7160
7163
  case 224:
7161
7164
 
7162
7165
/* Line 1464 of yacc.c  */
7163
 
#line 2256 "ripper.y"
 
7166
#line 2259 "ripper.y"
7164
7167
    {
7165
7168
#if 0
7166
7169
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNEQ, (yyvsp[(3) - (3)].val));
7173
7176
  case 225:
7174
7177
 
7175
7178
/* Line 1464 of yacc.c  */
7176
 
#line 2264 "ripper.y"
 
7179
#line 2267 "ripper.y"
7177
7180
    {
7178
7181
#if 0
7179
7182
                        (yyval.val) = match_op((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7189
7192
  case 226:
7190
7193
 
7191
7194
/* Line 1464 of yacc.c  */
7192
 
#line 2275 "ripper.y"
 
7195
#line 2278 "ripper.y"
7193
7196
    {
7194
7197
#if 0
7195
7198
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tNMATCH, (yyvsp[(3) - (3)].val));
7202
7205
  case 227:
7203
7206
 
7204
7207
/* Line 1464 of yacc.c  */
7205
 
#line 2283 "ripper.y"
 
7208
#line 2286 "ripper.y"
7206
7209
    {
7207
7210
#if 0
7208
7211
                        (yyval.val) = call_uni_op(cond((yyvsp[(2) - (2)].val)), '!');
7215
7218
  case 228:
7216
7219
 
7217
7220
/* Line 1464 of yacc.c  */
7218
 
#line 2291 "ripper.y"
 
7221
#line 2294 "ripper.y"
7219
7222
    {
7220
7223
#if 0
7221
7224
                        (yyval.val) = call_uni_op((yyvsp[(2) - (2)].val), '~');
7228
7231
  case 229:
7229
7232
 
7230
7233
/* Line 1464 of yacc.c  */
7231
 
#line 2299 "ripper.y"
 
7234
#line 2302 "ripper.y"
7232
7235
    {
7233
7236
#if 0
7234
7237
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tLSHFT, (yyvsp[(3) - (3)].val));
7241
7244
  case 230:
7242
7245
 
7243
7246
/* Line 1464 of yacc.c  */
7244
 
#line 2307 "ripper.y"
 
7247
#line 2310 "ripper.y"
7245
7248
    {
7246
7249
#if 0
7247
7250
                        (yyval.val) = call_bin_op((yyvsp[(1) - (3)].val), tRSHFT, (yyvsp[(3) - (3)].val));
7254
7257
  case 231:
7255
7258
 
7256
7259
/* Line 1464 of yacc.c  */
7257
 
#line 2315 "ripper.y"
 
7260
#line 2318 "ripper.y"
7258
7261
    {
7259
7262
#if 0
7260
7263
                        (yyval.val) = logop(NODE_AND, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7267
7270
  case 232:
7268
7271
 
7269
7272
/* Line 1464 of yacc.c  */
7270
 
#line 2323 "ripper.y"
 
7273
#line 2326 "ripper.y"
7271
7274
    {
7272
7275
#if 0
7273
7276
                        (yyval.val) = logop(NODE_OR, (yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7280
7283
  case 233:
7281
7284
 
7282
7285
/* Line 1464 of yacc.c  */
7283
 
#line 2330 "ripper.y"
 
7286
#line 2333 "ripper.y"
7284
7287
    {in_defined = 1;;}
7285
7288
    break;
7286
7289
 
7287
7290
  case 234:
7288
7291
 
7289
7292
/* Line 1464 of yacc.c  */
7290
 
#line 2331 "ripper.y"
 
7293
#line 2334 "ripper.y"
7291
7294
    {
7292
7295
#if 0
7293
7296
                        in_defined = 0;
7302
7305
  case 235:
7303
7306
 
7304
7307
/* Line 1464 of yacc.c  */
7305
 
#line 2341 "ripper.y"
 
7308
#line 2344 "ripper.y"
7306
7309
    {
7307
7310
#if 0
7308
7311
                        value_expr((yyvsp[(1) - (6)].val));
7317
7320
  case 236:
7318
7321
 
7319
7322
/* Line 1464 of yacc.c  */
7320
 
#line 2351 "ripper.y"
 
7323
#line 2354 "ripper.y"
7321
7324
    {
7322
7325
                        (yyval.val) = (yyvsp[(1) - (1)].val);
7323
7326
                    ;}
7326
7329
  case 237:
7327
7330
 
7328
7331
/* Line 1464 of yacc.c  */
7329
 
#line 2357 "ripper.y"
 
7332
#line 2360 "ripper.y"
7330
7333
    {
7331
7334
#if 0
7332
7335
                        value_expr((yyvsp[(1) - (1)].val));
7341
7344
  case 239:
7342
7345
 
7343
7346
/* Line 1464 of yacc.c  */
7344
 
#line 2370 "ripper.y"
 
7347
#line 2373 "ripper.y"
7345
7348
    {
7346
7349
                        (yyval.val) = (yyvsp[(1) - (2)].val);
7347
7350
                    ;}
7350
7353
  case 240:
7351
7354
 
7352
7355
/* Line 1464 of yacc.c  */
7353
 
#line 2374 "ripper.y"
 
7356
#line 2377 "ripper.y"
7354
7357
    {
7355
7358
#if 0
7356
7359
                        (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7363
7366
  case 241:
7364
7367
 
7365
7368
/* Line 1464 of yacc.c  */
7366
 
#line 2382 "ripper.y"
 
7369
#line 2385 "ripper.y"
7367
7370
    {
7368
7371
#if 0
7369
7372
                        (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7376
7379
  case 242:
7377
7380
 
7378
7381
/* Line 1464 of yacc.c  */
7379
 
#line 2392 "ripper.y"
 
7382
#line 2395 "ripper.y"
7380
7383
    {
7381
7384
#if 0
7382
7385
                        (yyval.val) = (yyvsp[(2) - (3)].val);
7389
7392
  case 247:
7390
7393
 
7391
7394
/* Line 1464 of yacc.c  */
7392
 
#line 2410 "ripper.y"
 
7395
#line 2413 "ripper.y"
7393
7396
    {
7394
7397
#if 0
7395
7398
                        value_expr((yyvsp[(1) - (1)].val));
7403
7406
  case 248:
7404
7407
 
7405
7408
/* Line 1464 of yacc.c  */
7406
 
#line 2419 "ripper.y"
 
7409
#line 2422 "ripper.y"
7407
7410
    {
7408
7411
#if 0
7409
7412
                        (yyval.val) = arg_blk_pass((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
7416
7419
  case 249:
7417
7420
 
7418
7421
/* Line 1464 of yacc.c  */
7419
 
#line 2427 "ripper.y"
 
7422
#line 2430 "ripper.y"
7420
7423
    {
7421
7424
#if 0
7422
7425
                        (yyval.val) = NEW_LIST(NEW_HASH((yyvsp[(1) - (2)].val)));
7431
7434
  case 250:
7432
7435
 
7433
7436
/* Line 1464 of yacc.c  */
7434
 
#line 2437 "ripper.y"
 
7437
#line 2440 "ripper.y"
7435
7438
    {
7436
7439
#if 0
7437
7440
                        (yyval.val) = arg_append((yyvsp[(1) - (4)].val), NEW_HASH((yyvsp[(3) - (4)].val)));
7445
7448
  case 251:
7446
7449
 
7447
7450
/* Line 1464 of yacc.c  */
7448
 
#line 2448 "ripper.y"
 
7451
#line 2451 "ripper.y"
7449
7452
    {
7450
7453
                        (yyval.val) = arg_add_block(arg_new(), (yyvsp[(1) - (1)].val));
7451
7454
                    ;}
7454
7457
  case 252:
7455
7458
 
7456
7459
/* Line 1464 of yacc.c  */
7457
 
#line 2454 "ripper.y"
 
7460
#line 2457 "ripper.y"
7458
7461
    {
7459
7462
                        (yyval.val) = cmdarg_stack;
7460
7463
                        CMDARG_PUSH(1);
7464
7467
  case 253:
7465
7468
 
7466
7469
/* Line 1464 of yacc.c  */
7467
 
#line 2459 "ripper.y"
 
7470
#line 2462 "ripper.y"
7468
7471
    {
7469
7472
                        /* CMDARG_POP() */
7470
7473
                        cmdarg_stack = (yyvsp[(1) - (2)].val);
7475
7478
  case 254:
7476
7479
 
7477
7480
/* Line 1464 of yacc.c  */
7478
 
#line 2467 "ripper.y"
 
7481
#line 2470 "ripper.y"
7479
7482
    {
7480
7483
#if 0
7481
7484
                        (yyval.val) = NEW_BLOCK_PASS((yyvsp[(2) - (2)].val));
7488
7491
  case 255:
7489
7492
 
7490
7493
/* Line 1464 of yacc.c  */
7491
 
#line 2477 "ripper.y"
 
7494
#line 2480 "ripper.y"
7492
7495
    {
7493
7496
                        (yyval.val) = (yyvsp[(2) - (2)].val);
7494
7497
                    ;}
7497
7500
  case 256:
7498
7501
 
7499
7502
/* Line 1464 of yacc.c  */
7500
 
#line 2481 "ripper.y"
 
7503
#line 2484 "ripper.y"
7501
7504
    {
7502
7505
                        (yyval.val) = 0;
7503
7506
                    ;}
7506
7509
  case 257:
7507
7510
 
7508
7511
/* Line 1464 of yacc.c  */
7509
 
#line 2485 "ripper.y"
 
7512
#line 2488 "ripper.y"
7510
7513
    {
7511
7514
                        (yyval.val) = 0;
7512
7515
                    ;}
7515
7518
  case 258:
7516
7519
 
7517
7520
/* Line 1464 of yacc.c  */
7518
 
#line 2491 "ripper.y"
 
7521
#line 2494 "ripper.y"
7519
7522
    {
7520
7523
#if 0
7521
7524
                        (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
7528
7531
  case 259:
7529
7532
 
7530
7533
/* Line 1464 of yacc.c  */
7531
 
#line 2499 "ripper.y"
 
7534
#line 2502 "ripper.y"
7532
7535
    {
7533
7536
#if 0
7534
7537
                        (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7541
7544
  case 260:
7542
7545
 
7543
7546
/* Line 1464 of yacc.c  */
7544
 
#line 2507 "ripper.y"
 
7547
#line 2510 "ripper.y"
7545
7548
    {
7546
7549
#if 0
7547
7550
                        NODE *n1;
7560
7563
  case 261:
7561
7564
 
7562
7565
/* Line 1464 of yacc.c  */
7563
 
#line 2521 "ripper.y"
 
7566
#line 2524 "ripper.y"
7564
7567
    {
7565
7568
#if 0
7566
7569
                        NODE *n1;
7579
7582
  case 262:
7580
7583
 
7581
7584
/* Line 1464 of yacc.c  */
7582
 
#line 2537 "ripper.y"
 
7585
#line 2540 "ripper.y"
7583
7586
    {
7584
7587
#if 0
7585
7588
                        NODE *n1;
7598
7601
  case 263:
7599
7602
 
7600
7603
/* Line 1464 of yacc.c  */
7601
 
#line 2551 "ripper.y"
 
7604
#line 2554 "ripper.y"
7602
7605
    {
7603
7606
#if 0
7604
7607
                        NODE *n1;
7618
7621
  case 264:
7619
7622
 
7620
7623
/* Line 1464 of yacc.c  */
7621
 
#line 2566 "ripper.y"
 
7624
#line 2569 "ripper.y"
7622
7625
    {
7623
7626
#if 0
7624
7627
                        (yyval.val) = NEW_SPLAT((yyvsp[(2) - (2)].val));
7631
7634
  case 273:
7632
7635
 
7633
7636
/* Line 1464 of yacc.c  */
7634
 
#line 2584 "ripper.y"
 
7637
#line 2587 "ripper.y"
7635
7638
    {
7636
7639
#if 0
7637
7640
                        (yyval.val) = NEW_FCALL((yyvsp[(1) - (1)].val), 0);
7644
7647
  case 274:
7645
7648
 
7646
7649
/* Line 1464 of yacc.c  */
7647
 
#line 2592 "ripper.y"
 
7650
#line 2595 "ripper.y"
7648
7651
    {
7649
7652
#if 0
7650
7653
                        (yyval.num) = ruby_sourceline;
7656
7659
  case 275:
7657
7660
 
7658
7661
/* Line 1464 of yacc.c  */
7659
 
#line 2600 "ripper.y"
 
7662
#line 2603 "ripper.y"
7660
7663
    {
7661
7664
#if 0
7662
7665
                        if ((yyvsp[(3) - (4)].val) == NULL) {
7678
7681
  case 276:
7679
7682
 
7680
7683
/* Line 1464 of yacc.c  */
7681
 
#line 2616 "ripper.y"
 
7684
#line 2619 "ripper.y"
7682
7685
    {lex_state = EXPR_ENDARG;;}
7683
7686
    break;
7684
7687
 
7685
7688
  case 277:
7686
7689
 
7687
7690
/* Line 1464 of yacc.c  */
7688
 
#line 2617 "ripper.y"
 
7691
#line 2620 "ripper.y"
7689
7692
    {
7690
7693
                        rb_warning0("(...) interpreted as grouped expression");
7691
7694
#if 0
7699
7702
  case 278:
7700
7703
 
7701
7704
/* Line 1464 of yacc.c  */
7702
 
#line 2626 "ripper.y"
 
7705
#line 2629 "ripper.y"
7703
7706
    {
7704
7707
#if 0
7705
7708
                        (yyval.val) = (yyvsp[(2) - (3)].val);
7712
7715
  case 279:
7713
7716
 
7714
7717
/* Line 1464 of yacc.c  */
7715
 
#line 2634 "ripper.y"
 
7718
#line 2637 "ripper.y"
7716
7719
    {
7717
7720
#if 0
7718
7721
                        (yyval.val) = NEW_COLON2((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
7725
7728
  case 280:
7726
7729
 
7727
7730
/* Line 1464 of yacc.c  */
7728
 
#line 2642 "ripper.y"
 
7731
#line 2645 "ripper.y"
7729
7732
    {
7730
7733
#if 0
7731
7734
                        (yyval.val) = NEW_COLON3((yyvsp[(2) - (2)].val));
7738
7741
  case 281:
7739
7742
 
7740
7743
/* Line 1464 of yacc.c  */
7741
 
#line 2650 "ripper.y"
 
7744
#line 2653 "ripper.y"
7742
7745
    {
7743
7746
#if 0
7744
7747
                        if ((yyvsp[(2) - (3)].val) == 0) {
7756
7759
  case 282:
7757
7760
 
7758
7761
/* Line 1464 of yacc.c  */
7759
 
#line 2663 "ripper.y"
 
7762
#line 2666 "ripper.y"
7760
7763
    {
7761
7764
#if 0
7762
7765
                        (yyval.val) = NEW_HASH((yyvsp[(2) - (3)].val));
7769
7772
  case 283:
7770
7773
 
7771
7774
/* Line 1464 of yacc.c  */
7772
 
#line 2671 "ripper.y"
 
7775
#line 2674 "ripper.y"
7773
7776
    {
7774
7777
#if 0
7775
7778
                        (yyval.val) = NEW_RETURN(0);
7782
7785
  case 284:
7783
7786
 
7784
7787
/* Line 1464 of yacc.c  */
7785
 
#line 2679 "ripper.y"
 
7788
#line 2682 "ripper.y"
7786
7789
    {
7787
7790
#if 0
7788
7791
                        (yyval.val) = new_yield((yyvsp[(3) - (4)].val));
7795
7798
  case 285:
7796
7799
 
7797
7800
/* Line 1464 of yacc.c  */
7798
 
#line 2687 "ripper.y"
 
7801
#line 2690 "ripper.y"
7799
7802
    {
7800
7803
#if 0
7801
7804
                        (yyval.val) = NEW_YIELD(0, Qfalse);
7808
7811
  case 286:
7809
7812
 
7810
7813
/* Line 1464 of yacc.c  */
7811
 
#line 2695 "ripper.y"
 
7814
#line 2698 "ripper.y"
7812
7815
    {
7813
7816
#if 0
7814
7817
                        (yyval.val) = NEW_YIELD(0, Qfalse);
7821
7824
  case 287:
7822
7825
 
7823
7826
/* Line 1464 of yacc.c  */
7824
 
#line 2702 "ripper.y"
 
7827
#line 2705 "ripper.y"
7825
7828
    {in_defined = 1;;}
7826
7829
    break;
7827
7830
 
7828
7831
  case 288:
7829
7832
 
7830
7833
/* Line 1464 of yacc.c  */
7831
 
#line 2703 "ripper.y"
 
7834
#line 2706 "ripper.y"
7832
7835
    {
7833
7836
#if 0
7834
7837
                        in_defined = 0;
7843
7846
  case 289:
7844
7847
 
7845
7848
/* Line 1464 of yacc.c  */
7846
 
#line 2713 "ripper.y"
 
7849
#line 2716 "ripper.y"
7847
7850
    {
7848
7851
#if 0
7849
7852
                        (yyval.val) = call_uni_op(cond((yyvsp[(3) - (4)].val)), '!');
7856
7859
  case 290:
7857
7860
 
7858
7861
/* Line 1464 of yacc.c  */
7859
 
#line 2721 "ripper.y"
 
7862
#line 2724 "ripper.y"
7860
7863
    {
7861
7864
#if 0
7862
7865
                        (yyval.val) = call_uni_op(cond(NEW_NIL()), '!');
7869
7872
  case 291:
7870
7873
 
7871
7874
/* Line 1464 of yacc.c  */
7872
 
#line 2729 "ripper.y"
 
7875
#line 2732 "ripper.y"
7873
7876
    {
7874
7877
#if 0
7875
7878
                        (yyvsp[(2) - (2)].val)->nd_iter = NEW_FCALL((yyvsp[(1) - (2)].val), 0);
7885
7888
  case 293:
7886
7889
 
7887
7890
/* Line 1464 of yacc.c  */
7888
 
#line 2741 "ripper.y"
 
7891
#line 2744 "ripper.y"
7889
7892
    {
7890
7893
#if 0
7891
7894
                        block_dup_check((yyvsp[(1) - (2)].val)->nd_args, (yyvsp[(2) - (2)].val));
7901
7904
  case 294:
7902
7905
 
7903
7906
/* Line 1464 of yacc.c  */
7904
 
#line 2752 "ripper.y"
 
7907
#line 2755 "ripper.y"
7905
7908
    {
7906
7909
                        (yyval.val) = (yyvsp[(2) - (2)].val);
7907
7910
                    ;}
7910
7913
  case 295:
7911
7914
 
7912
7915
/* Line 1464 of yacc.c  */
7913
 
#line 2759 "ripper.y"
 
7916
#line 2762 "ripper.y"
7914
7917
    {
7915
7918
#if 0
7916
7919
                        (yyval.val) = NEW_IF(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
7924
7927
  case 296:
7925
7928
 
7926
7929
/* Line 1464 of yacc.c  */
7927
 
#line 2771 "ripper.y"
 
7930
#line 2774 "ripper.y"
7928
7931
    {
7929
7932
#if 0
7930
7933
                        (yyval.val) = NEW_UNLESS(cond((yyvsp[(2) - (6)].val)), (yyvsp[(4) - (6)].val), (yyvsp[(5) - (6)].val));
7938
7941
  case 297:
7939
7942
 
7940
7943
/* Line 1464 of yacc.c  */
7941
 
#line 2779 "ripper.y"
 
7944
#line 2782 "ripper.y"
7942
7945
    {COND_PUSH(1);;}
7943
7946
    break;
7944
7947
 
7945
7948
  case 298:
7946
7949
 
7947
7950
/* Line 1464 of yacc.c  */
7948
 
#line 2779 "ripper.y"
 
7951
#line 2782 "ripper.y"
7949
7952
    {COND_POP();;}
7950
7953
    break;
7951
7954
 
7952
7955
  case 299:
7953
7956
 
7954
7957
/* Line 1464 of yacc.c  */
7955
 
#line 2782 "ripper.y"
 
7958
#line 2785 "ripper.y"
7956
7959
    {
7957
7960
#if 0
7958
7961
                        (yyval.val) = NEW_WHILE(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
7966
7969
  case 300:
7967
7970
 
7968
7971
/* Line 1464 of yacc.c  */
7969
 
#line 2790 "ripper.y"
 
7972
#line 2793 "ripper.y"
7970
7973
    {COND_PUSH(1);;}
7971
7974
    break;
7972
7975
 
7973
7976
  case 301:
7974
7977
 
7975
7978
/* Line 1464 of yacc.c  */
7976
 
#line 2790 "ripper.y"
 
7979
#line 2793 "ripper.y"
7977
7980
    {COND_POP();;}
7978
7981
    break;
7979
7982
 
7980
7983
  case 302:
7981
7984
 
7982
7985
/* Line 1464 of yacc.c  */
7983
 
#line 2793 "ripper.y"
 
7986
#line 2796 "ripper.y"
7984
7987
    {
7985
7988
#if 0
7986
7989
                        (yyval.val) = NEW_UNTIL(cond((yyvsp[(3) - (7)].val)), (yyvsp[(6) - (7)].val), 1);
7994
7997
  case 303:
7995
7998
 
7996
7999
/* Line 1464 of yacc.c  */
7997
 
#line 2804 "ripper.y"
 
8000
#line 2807 "ripper.y"
7998
8001
    {
7999
8002
#if 0
8000
8003
                        (yyval.val) = NEW_CASE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8008
8011
  case 304:
8009
8012
 
8010
8013
/* Line 1464 of yacc.c  */
8011
 
#line 2813 "ripper.y"
 
8014
#line 2816 "ripper.y"
8012
8015
    {
8013
8016
#if 0
8014
8017
                        (yyval.val) = NEW_CASE(0, (yyvsp[(3) - (4)].val));
8021
8024
  case 305:
8022
8025
 
8023
8026
/* Line 1464 of yacc.c  */
8024
 
#line 2821 "ripper.y"
 
8027
#line 2824 "ripper.y"
8025
8028
    {COND_PUSH(1);;}
8026
8029
    break;
8027
8030
 
8028
8031
  case 306:
8029
8032
 
8030
8033
/* Line 1464 of yacc.c  */
8031
 
#line 2823 "ripper.y"
 
8034
#line 2826 "ripper.y"
8032
8035
    {COND_POP();;}
8033
8036
    break;
8034
8037
 
8035
8038
  case 307:
8036
8039
 
8037
8040
/* Line 1464 of yacc.c  */
8038
 
#line 2826 "ripper.y"
 
8041
#line 2829 "ripper.y"
8039
8042
    {
8040
8043
#if 0
8041
8044
                        /*
8101
8104
  case 308:
8102
8105
 
8103
8106
/* Line 1464 of yacc.c  */
8104
 
#line 2887 "ripper.y"
 
8107
#line 2890 "ripper.y"
8105
8108
    {
8106
8109
                        if (in_def || in_single)
8107
8110
                            yyerror("class definition in method body");
8116
8119
  case 309:
8117
8120
 
8118
8121
/* Line 1464 of yacc.c  */
8119
 
#line 2898 "ripper.y"
 
8122
#line 2901 "ripper.y"
8120
8123
    {
8121
8124
#if 0
8122
8125
                        (yyval.val) = NEW_CLASS((yyvsp[(2) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(3) - (6)].val));
8131
8134
  case 310:
8132
8135
 
8133
8136
/* Line 1464 of yacc.c  */
8134
 
#line 2908 "ripper.y"
 
8137
#line 2911 "ripper.y"
8135
8138
    {
8136
8139
                        (yyval.num) = in_def;
8137
8140
                        in_def = 0;
8141
8144
  case 311:
8142
8145
 
8143
8146
/* Line 1464 of yacc.c  */
8144
 
#line 2913 "ripper.y"
 
8147
#line 2916 "ripper.y"
8145
8148
    {
8146
8149
                        (yyval.num) = in_single;
8147
8150
                        in_single = 0;
8152
8155
  case 312:
8153
8156
 
8154
8157
/* Line 1464 of yacc.c  */
8155
 
#line 2920 "ripper.y"
 
8158
#line 2923 "ripper.y"
8156
8159
    {
8157
8160
#if 0
8158
8161
                        (yyval.val) = NEW_SCLASS((yyvsp[(3) - (8)].val), (yyvsp[(7) - (8)].val));
8169
8172
  case 313:
8170
8173
 
8171
8174
/* Line 1464 of yacc.c  */
8172
 
#line 2932 "ripper.y"
 
8175
#line 2935 "ripper.y"
8173
8176
    {
8174
8177
                        if (in_def || in_single)
8175
8178
                            yyerror("module definition in method body");
8184
8187
  case 314:
8185
8188
 
8186
8189
/* Line 1464 of yacc.c  */
8187
 
#line 2943 "ripper.y"
 
8190
#line 2946 "ripper.y"
8188
8191
    {
8189
8192
#if 0
8190
8193
                        (yyval.val) = NEW_MODULE((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val));
8199
8202
  case 315:
8200
8203
 
8201
8204
/* Line 1464 of yacc.c  */
8202
 
#line 2953 "ripper.y"
 
8205
#line 2956 "ripper.y"
8203
8206
    {
8204
8207
                        (yyval.id) = cur_mid;
8205
8208
                        cur_mid = (yyvsp[(2) - (2)].val);
8211
8214
  case 316:
8212
8215
 
8213
8216
/* Line 1464 of yacc.c  */
8214
 
#line 2962 "ripper.y"
 
8217
#line 2965 "ripper.y"
8215
8218
    {
8216
8219
#if 0
8217
8220
                        NODE *body = remove_begin((yyvsp[(5) - (6)].val));
8230
8233
  case 317:
8231
8234
 
8232
8235
/* Line 1464 of yacc.c  */
8233
 
#line 2975 "ripper.y"
 
8236
#line 2978 "ripper.y"
8234
8237
    {lex_state = EXPR_FNAME;;}
8235
8238
    break;
8236
8239
 
8237
8240
  case 318:
8238
8241
 
8239
8242
/* Line 1464 of yacc.c  */
8240
 
#line 2976 "ripper.y"
 
8243
#line 2979 "ripper.y"
8241
8244
    {
8242
8245
                        in_single++;
8243
8246
                        lex_state = EXPR_ENDFN; /* force for args */
8248
8251
  case 319:
8249
8252
 
8250
8253
/* Line 1464 of yacc.c  */
8251
 
#line 2984 "ripper.y"
 
8254
#line 2987 "ripper.y"
8252
8255
    {
8253
8256
#if 0
8254
8257
                        NODE *body = remove_begin((yyvsp[(8) - (9)].val));
8266
8269
  case 320:
8267
8270
 
8268
8271
/* Line 1464 of yacc.c  */
8269
 
#line 2997 "ripper.y"
 
8272
#line 3000 "ripper.y"
8270
8273
    {
8271
8274
#if 0
8272
8275
                        (yyval.val) = NEW_BREAK(0);
8279
8282
  case 321:
8280
8283
 
8281
8284
/* Line 1464 of yacc.c  */
8282
 
#line 3005 "ripper.y"
 
8285
#line 3008 "ripper.y"
8283
8286
    {
8284
8287
#if 0
8285
8288
                        (yyval.val) = NEW_NEXT(0);
8292
8295
  case 322:
8293
8296
 
8294
8297
/* Line 1464 of yacc.c  */
8295
 
#line 3013 "ripper.y"
 
8298
#line 3016 "ripper.y"
8296
8299
    {
8297
8300
#if 0
8298
8301
                        (yyval.val) = NEW_REDO();
8305
8308
  case 323:
8306
8309
 
8307
8310
/* Line 1464 of yacc.c  */
8308
 
#line 3021 "ripper.y"
 
8311
#line 3024 "ripper.y"
8309
8312
    {
8310
8313
#if 0
8311
8314
                        (yyval.val) = NEW_RETRY();
8318
8321
  case 324:
8319
8322
 
8320
8323
/* Line 1464 of yacc.c  */
8321
 
#line 3031 "ripper.y"
 
8324
#line 3034 "ripper.y"
8322
8325
    {
8323
8326
#if 0
8324
8327
                        value_expr((yyvsp[(1) - (1)].val));
8333
8336
  case 325:
8334
8337
 
8335
8338
/* Line 1464 of yacc.c  */
8336
 
#line 3043 "ripper.y"
 
8339
#line 3046 "ripper.y"
8337
8340
    {
8338
8341
                        token_info_push("begin");
8339
8342
                    ;}
8342
8345
  case 326:
8343
8346
 
8344
8347
/* Line 1464 of yacc.c  */
8345
 
#line 3049 "ripper.y"
 
8348
#line 3052 "ripper.y"
8346
8349
    {
8347
8350
                        token_info_push("if");
8348
8351
                    ;}
8351
8354
  case 327:
8352
8355
 
8353
8356
/* Line 1464 of yacc.c  */
8354
 
#line 3055 "ripper.y"
 
8357
#line 3058 "ripper.y"
8355
8358
    {
8356
8359
                        token_info_push("unless");
8357
8360
                    ;}
8360
8363
  case 328:
8361
8364
 
8362
8365
/* Line 1464 of yacc.c  */
8363
 
#line 3061 "ripper.y"
 
8366
#line 3064 "ripper.y"
8364
8367
    {
8365
8368
                        token_info_push("while");
8366
8369
                    ;}
8369
8372
  case 329:
8370
8373
 
8371
8374
/* Line 1464 of yacc.c  */
8372
 
#line 3067 "ripper.y"
 
8375
#line 3070 "ripper.y"
8373
8376
    {
8374
8377
                        token_info_push("until");
8375
8378
                    ;}
8378
8381
  case 330:
8379
8382
 
8380
8383
/* Line 1464 of yacc.c  */
8381
 
#line 3073 "ripper.y"
 
8384
#line 3076 "ripper.y"
8382
8385
    {
8383
8386
                        token_info_push("case");
8384
8387
                    ;}
8387
8390
  case 331:
8388
8391
 
8389
8392
/* Line 1464 of yacc.c  */
8390
 
#line 3079 "ripper.y"
 
8393
#line 3082 "ripper.y"
8391
8394
    {
8392
8395
                        token_info_push("for");
8393
8396
                    ;}
8396
8399
  case 332:
8397
8400
 
8398
8401
/* Line 1464 of yacc.c  */
8399
 
#line 3085 "ripper.y"
 
8402
#line 3088 "ripper.y"
8400
8403
    {
8401
8404
                        token_info_push("class");
8402
8405
                    ;}
8405
8408
  case 333:
8406
8409
 
8407
8410
/* Line 1464 of yacc.c  */
8408
 
#line 3091 "ripper.y"
 
8411
#line 3094 "ripper.y"
8409
8412
    {
8410
8413
                        token_info_push("module");
8411
8414
                    ;}
8414
8417
  case 334:
8415
8418
 
8416
8419
/* Line 1464 of yacc.c  */
8417
 
#line 3097 "ripper.y"
 
8420
#line 3100 "ripper.y"
8418
8421
    {
8419
8422
                        token_info_push("def");
8420
8423
#if 0
8427
8430
  case 335:
8428
8431
 
8429
8432
/* Line 1464 of yacc.c  */
8430
 
#line 3107 "ripper.y"
 
8433
#line 3110 "ripper.y"
8431
8434
    {
8432
8435
                        token_info_pop("end");
8433
8436
                    ;}
8436
8439
  case 336:
8437
8440
 
8438
8441
/* Line 1464 of yacc.c  */
8439
 
#line 3115 "ripper.y"
 
8442
#line 3118 "ripper.y"
8440
8443
    { (yyval.val) = Qnil; ;}
8441
8444
    break;
8442
8445
 
8443
8446
  case 338:
8444
8447
 
8445
8448
/* Line 1464 of yacc.c  */
8446
 
#line 3121 "ripper.y"
 
8449
#line 3124 "ripper.y"
8447
8450
    { (yyval.val) = (yyvsp[(2) - (2)].val); ;}
8448
8451
    break;
8449
8452
 
8450
8453
  case 339:
8451
8454
 
8452
8455
/* Line 1464 of yacc.c  */
8453
 
#line 3128 "ripper.y"
 
8456
#line 3131 "ripper.y"
8454
8457
    { (yyval.val) = Qnil; ;}
8455
8458
    break;
8456
8459
 
8457
8460
  case 342:
8458
8461
 
8459
8462
/* Line 1464 of yacc.c  */
8460
 
#line 3137 "ripper.y"
 
8463
#line 3140 "ripper.y"
8461
8464
    {
8462
8465
#if 0
8463
8466
                        (yyval.val) = NEW_IF(cond((yyvsp[(2) - (5)].val)), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
8471
8474
  case 344:
8472
8475
 
8473
8476
/* Line 1464 of yacc.c  */
8474
 
#line 3149 "ripper.y"
 
8477
#line 3152 "ripper.y"
8475
8478
    {
8476
8479
#if 0
8477
8480
                        (yyval.val) = (yyvsp[(2) - (2)].val);
8484
8487
  case 347:
8485
8488
 
8486
8489
/* Line 1464 of yacc.c  */
8487
 
#line 3163 "ripper.y"
 
8490
#line 3166 "ripper.y"
8488
8491
    {
8489
8492
                        (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
8490
8493
#if 0
8497
8500
  case 348:
8498
8501
 
8499
8502
/* Line 1464 of yacc.c  */
8500
 
#line 3171 "ripper.y"
 
8503
#line 3174 "ripper.y"
8501
8504
    {
8502
8505
#if 0
8503
8506
                        (yyval.val) = (yyvsp[(2) - (3)].val);
8510
8513
  case 349:
8511
8514
 
8512
8515
/* Line 1464 of yacc.c  */
8513
 
#line 3181 "ripper.y"
 
8516
#line 3184 "ripper.y"
8514
8517
    {
8515
8518
#if 0
8516
8519
                        (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
8523
8526
  case 350:
8524
8527
 
8525
8528
/* Line 1464 of yacc.c  */
8526
 
#line 3189 "ripper.y"
 
8529
#line 3192 "ripper.y"
8527
8530
    {
8528
8531
#if 0
8529
8532
                        (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
8536
8539
  case 351:
8537
8540
 
8538
8541
/* Line 1464 of yacc.c  */
8539
 
#line 3199 "ripper.y"
 
8542
#line 3202 "ripper.y"
8540
8543
    {
8541
8544
#if 0
8542
8545
                        (yyval.val) = NEW_MASGN((yyvsp[(1) - (1)].val), 0);
8549
8552
  case 352:
8550
8553
 
8551
8554
/* Line 1464 of yacc.c  */
8552
 
#line 3207 "ripper.y"
 
8555
#line 3210 "ripper.y"
8553
8556
    {
8554
8557
                        (yyval.val) = assignable((yyvsp[(4) - (4)].val), 0);
8555
8558
#if 0
8563
8566
  case 353:
8564
8567
 
8565
8568
/* Line 1464 of yacc.c  */
8566
 
#line 3216 "ripper.y"
 
8569
#line 3219 "ripper.y"
8567
8570
    {
8568
8571
                        (yyval.val) = assignable((yyvsp[(4) - (6)].val), 0);
8569
8572
#if 0
8577
8580
  case 354:
8578
8581
 
8579
8582
/* Line 1464 of yacc.c  */
8580
 
#line 3225 "ripper.y"
 
8583
#line 3228 "ripper.y"
8581
8584
    {
8582
8585
#if 0
8583
8586
                        (yyval.val) = NEW_MASGN((yyvsp[(1) - (3)].val), -1);
8590
8593
  case 355:
8591
8594
 
8592
8595
/* Line 1464 of yacc.c  */
8593
 
#line 3233 "ripper.y"
 
8596
#line 3236 "ripper.y"
8594
8597
    {
8595
8598
#if 0
8596
8599
                        (yyval.val) = NEW_MASGN((yyvsp[(1) - (5)].val), NEW_POSTARG(-1, (yyvsp[(5) - (5)].val)));
8603
8606
  case 356:
8604
8607
 
8605
8608
/* Line 1464 of yacc.c  */
8606
 
#line 3241 "ripper.y"
 
8609
#line 3244 "ripper.y"
8607
8610
    {
8608
8611
                        (yyval.val) = assignable((yyvsp[(2) - (2)].val), 0);
8609
8612
#if 0
8617
8620
  case 357:
8618
8621
 
8619
8622
/* Line 1464 of yacc.c  */
8620
 
#line 3250 "ripper.y"
 
8623
#line 3253 "ripper.y"
8621
8624
    {
8622
8625
                        (yyval.val) = assignable((yyvsp[(2) - (4)].val), 0);
8623
8626
#if 0
8634
8637
  case 358:
8635
8638
 
8636
8639
/* Line 1464 of yacc.c  */
8637
 
#line 3262 "ripper.y"
 
8640
#line 3265 "ripper.y"
8638
8641
    {
8639
8642
#if 0
8640
8643
                        (yyval.val) = NEW_MASGN(0, -1);
8647
8650
  case 359:
8648
8651
 
8649
8652
/* Line 1464 of yacc.c  */
8650
 
#line 3270 "ripper.y"
 
8653
#line 3273 "ripper.y"
8651
8654
    {
8652
8655
#if 0
8653
8656
                        (yyval.val) = NEW_MASGN(0, NEW_POSTARG(-1, (yyvsp[(3) - (3)].val)));
8660
8663
  case 360:
8661
8664
 
8662
8665
/* Line 1464 of yacc.c  */
8663
 
#line 3280 "ripper.y"
 
8666
#line 3283 "ripper.y"
8664
8667
    {
8665
8668
#if 0
8666
8669
                        (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
8673
8676
  case 361:
8674
8677
 
8675
8678
/* Line 1464 of yacc.c  */
8676
 
#line 3288 "ripper.y"
 
8679
#line 3291 "ripper.y"
8677
8680
    {
8678
8681
#if 0
8679
8682
                        (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
8686
8689
  case 362:
8687
8690
 
8688
8691
/* Line 1464 of yacc.c  */
8689
 
#line 3296 "ripper.y"
 
8692
#line 3299 "ripper.y"
8690
8693
    {
8691
8694
#if 0
8692
8695
                        (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
8699
8702
  case 363:
8700
8703
 
8701
8704
/* Line 1464 of yacc.c  */
8702
 
#line 3304 "ripper.y"
 
8705
#line 3307 "ripper.y"
8703
8706
    {
8704
8707
#if 0
8705
8708
                        (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8712
8715
  case 364:
8713
8716
 
8714
8717
/* Line 1464 of yacc.c  */
8715
 
#line 3312 "ripper.y"
 
8718
#line 3315 "ripper.y"
8716
8719
    {
8717
8720
#if 0
8718
8721
                        (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
8725
8728
  case 365:
8726
8729
 
8727
8730
/* Line 1464 of yacc.c  */
8728
 
#line 3320 "ripper.y"
 
8731
#line 3323 "ripper.y"
8729
8732
    {
8730
8733
#if 0
8731
8734
                        (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 1, 0, 0);
8739
8742
  case 366:
8740
8743
 
8741
8744
/* Line 1464 of yacc.c  */
8742
 
#line 3329 "ripper.y"
 
8745
#line 3332 "ripper.y"
8743
8746
    {
8744
8747
#if 0
8745
8748
                        (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8752
8755
  case 367:
8753
8756
 
8754
8757
/* Line 1464 of yacc.c  */
8755
 
#line 3337 "ripper.y"
 
8758
#line 3340 "ripper.y"
8756
8759
    {
8757
8760
#if 0
8758
8761
                        (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
8765
8768
  case 368:
8766
8769
 
8767
8770
/* Line 1464 of yacc.c  */
8768
 
#line 3345 "ripper.y"
 
8771
#line 3348 "ripper.y"
8769
8772
    {
8770
8773
#if 0
8771
8774
                        (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
8778
8781
  case 369:
8779
8782
 
8780
8783
/* Line 1464 of yacc.c  */
8781
 
#line 3353 "ripper.y"
 
8784
#line 3356 "ripper.y"
8782
8785
    {
8783
8786
#if 0
8784
8787
                        (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
8791
8794
  case 370:
8792
8795
 
8793
8796
/* Line 1464 of yacc.c  */
8794
 
#line 3361 "ripper.y"
 
8797
#line 3364 "ripper.y"
8795
8798
    {
8796
8799
#if 0
8797
8800
                        (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
8804
8807
  case 371:
8805
8808
 
8806
8809
/* Line 1464 of yacc.c  */
8807
 
#line 3369 "ripper.y"
 
8810
#line 3372 "ripper.y"
8808
8811
    {
8809
8812
#if 0
8810
8813
                        (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8817
8820
  case 372:
8818
8821
 
8819
8822
/* Line 1464 of yacc.c  */
8820
 
#line 3377 "ripper.y"
 
8823
#line 3380 "ripper.y"
8821
8824
    {
8822
8825
#if 0
8823
8826
                        (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
8830
8833
  case 373:
8831
8834
 
8832
8835
/* Line 1464 of yacc.c  */
8833
 
#line 3385 "ripper.y"
 
8836
#line 3388 "ripper.y"
8834
8837
    {
8835
8838
#if 0
8836
8839
                        (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
8843
8846
  case 374:
8844
8847
 
8845
8848
/* Line 1464 of yacc.c  */
8846
 
#line 3393 "ripper.y"
 
8849
#line 3396 "ripper.y"
8847
8850
    {
8848
8851
#if 0
8849
8852
                        (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
8856
8859
  case 376:
8857
8860
 
8858
8861
/* Line 1464 of yacc.c  */
8859
 
#line 3404 "ripper.y"
 
8862
#line 3407 "ripper.y"
8860
8863
    {
8861
8864
                        command_start = TRUE;
8862
8865
                    ;}
8865
8868
  case 377:
8866
8869
 
8867
8870
/* Line 1464 of yacc.c  */
8868
 
#line 3410 "ripper.y"
 
8871
#line 3413 "ripper.y"
8869
8872
    {
8870
8873
#if 0
8871
8874
                        (yyval.val) = 0;
8879
8882
  case 378:
8880
8883
 
8881
8884
/* Line 1464 of yacc.c  */
8882
 
#line 3419 "ripper.y"
 
8885
#line 3422 "ripper.y"
8883
8886
    {
8884
8887
#if 0
8885
8888
                        (yyval.val) = 0;
8893
8896
  case 379:
8894
8897
 
8895
8898
/* Line 1464 of yacc.c  */
8896
 
#line 3428 "ripper.y"
 
8899
#line 3431 "ripper.y"
8897
8900
    {
8898
8901
#if 0
8899
8902
                        (yyval.val) = (yyvsp[(2) - (4)].val);
8906
8909
  case 381:
8907
8910
 
8908
8911
/* Line 1464 of yacc.c  */
8909
 
#line 3440 "ripper.y"
 
8912
#line 3443 "ripper.y"
8910
8913
    {
8911
8914
#if 0
8912
8915
                        (yyval.val) = 0;
8919
8922
  case 382:
8920
8923
 
8921
8924
/* Line 1464 of yacc.c  */
8922
 
#line 3452 "ripper.y"
 
8925
#line 3455 "ripper.y"
8923
8926
    {
8924
8927
                        (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
8925
8928
                    ;}
8928
8931
  case 383:
8929
8932
 
8930
8933
/* Line 1464 of yacc.c  */
8931
 
#line 3459 "ripper.y"
 
8934
#line 3462 "ripper.y"
8932
8935
    {
8933
8936
                        rb_ary_push((yyval.val), (yyvsp[(3) - (3)].val));
8934
8937
                    ;}
8937
8940
  case 384:
8938
8941
 
8939
8942
/* Line 1464 of yacc.c  */
8940
 
#line 3466 "ripper.y"
 
8943
#line 3469 "ripper.y"
8941
8944
    {
8942
8945
                        new_bv(get_id((yyvsp[(1) - (1)].val)));
8943
8946
#if 0
8950
8953
  case 385:
8951
8954
 
8952
8955
/* Line 1464 of yacc.c  */
8953
 
#line 3474 "ripper.y"
 
8956
#line 3477 "ripper.y"
8954
8957
    {
8955
8958
                        (yyval.val) = 0;
8956
8959
                    ;}
8959
8962
  case 386:
8960
8963
 
8961
8964
/* Line 1464 of yacc.c  */
8962
 
#line 3479 "ripper.y"
 
8965
#line 3482 "ripper.y"
8963
8966
    {
8964
8967
                        (yyval.vars) = dyna_push();
8965
8968
                    ;}
8968
8971
  case 387:
8969
8972
 
8970
8973
/* Line 1464 of yacc.c  */
8971
 
#line 3482 "ripper.y"
 
8974
#line 3485 "ripper.y"
8972
8975
    {
8973
8976
                        (yyval.num) = lpar_beg;
8974
8977
                        lpar_beg = ++paren_nest;
8978
8981
  case 388:
8979
8982
 
8980
8983
/* Line 1464 of yacc.c  */
8981
 
#line 3488 "ripper.y"
 
8984
#line 3491 "ripper.y"
8982
8985
    {
8983
8986
                        lpar_beg = (yyvsp[(2) - (4)].num);
8984
8987
#if 0
8994
8997
  case 389:
8995
8998
 
8996
8999
/* Line 1464 of yacc.c  */
8997
 
#line 3501 "ripper.y"
 
9000
#line 3504 "ripper.y"
8998
9001
    {
8999
9002
#if 0
9000
9003
                        (yyval.val) = NEW_LAMBDA((yyvsp[(2) - (4)].val));
9007
9010
  case 390:
9008
9011
 
9009
9012
/* Line 1464 of yacc.c  */
9010
 
#line 3509 "ripper.y"
 
9013
#line 3512 "ripper.y"
9011
9014
    {
9012
9015
#if 0
9013
9016
                        (yyval.val) = NEW_LAMBDA((yyvsp[(1) - (1)].val));
9020
9023
  case 391:
9021
9024
 
9022
9025
/* Line 1464 of yacc.c  */
9023
 
#line 3519 "ripper.y"
 
9026
#line 3522 "ripper.y"
9024
9027
    {
9025
9028
                        (yyval.val) = (yyvsp[(2) - (3)].val);
9026
9029
                    ;}
9029
9032
  case 392:
9030
9033
 
9031
9034
/* Line 1464 of yacc.c  */
9032
 
#line 3523 "ripper.y"
 
9035
#line 3526 "ripper.y"
9033
9036
    {
9034
9037
                        (yyval.val) = (yyvsp[(2) - (3)].val);
9035
9038
                    ;}
9038
9041
  case 393:
9039
9042
 
9040
9043
/* Line 1464 of yacc.c  */
9041
 
#line 3529 "ripper.y"
 
9044
#line 3532 "ripper.y"
9042
9045
    {
9043
9046
                        (yyvsp[(1) - (1)].vars) = dyna_push();
9044
9047
#if 0
9050
9053
  case 394:
9051
9054
 
9052
9055
/* Line 1464 of yacc.c  */
9053
 
#line 3538 "ripper.y"
 
9056
#line 3541 "ripper.y"
9054
9057
    {
9055
9058
#if 0
9056
9059
                        (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9065
9068
  case 395:
9066
9069
 
9067
9070
/* Line 1464 of yacc.c  */
9068
 
#line 3550 "ripper.y"
 
9071
#line 3553 "ripper.y"
9069
9072
    {
9070
9073
#if 0
9071
9074
                        if (nd_type((yyvsp[(1) - (2)].val)) == NODE_YIELD) {
9086
9089
  case 396:
9087
9090
 
9088
9091
/* Line 1464 of yacc.c  */
9089
 
#line 3566 "ripper.y"
 
9092
#line 3569 "ripper.y"
9090
9093
    {
9091
9094
#if 0
9092
9095
                        (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9100
9103
  case 397:
9101
9104
 
9102
9105
/* Line 1464 of yacc.c  */
9103
 
#line 3575 "ripper.y"
 
9106
#line 3578 "ripper.y"
9104
9107
    {
9105
9108
#if 0
9106
9109
                        (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9114
9117
  case 398:
9115
9118
 
9116
9119
/* Line 1464 of yacc.c  */
9117
 
#line 3586 "ripper.y"
 
9120
#line 3589 "ripper.y"
9118
9121
    {
9119
9122
#if 0
9120
9123
                        (yyval.val) = NEW_FCALL((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9128
9131
  case 399:
9129
9132
 
9130
9133
/* Line 1464 of yacc.c  */
9131
 
#line 3595 "ripper.y"
 
9134
#line 3598 "ripper.y"
9132
9135
    {
9133
9136
#if 0
9134
9137
                        (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9143
9146
  case 400:
9144
9147
 
9145
9148
/* Line 1464 of yacc.c  */
9146
 
#line 3605 "ripper.y"
 
9149
#line 3608 "ripper.y"
9147
9150
    {
9148
9151
#if 0
9149
9152
                        (yyval.val) = NEW_CALL((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
9158
9161
  case 401:
9159
9162
 
9160
9163
/* Line 1464 of yacc.c  */
9161
 
#line 3615 "ripper.y"
 
9164
#line 3618 "ripper.y"
9162
9165
    {
9163
9166
#if 0
9164
9167
                        (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val), 0);
9171
9174
  case 402:
9172
9175
 
9173
9176
/* Line 1464 of yacc.c  */
9174
 
#line 3623 "ripper.y"
 
9177
#line 3626 "ripper.y"
9175
9178
    {
9176
9179
#if 0
9177
9180
                        (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
9187
9190
  case 403:
9188
9191
 
9189
9192
/* Line 1464 of yacc.c  */
9190
 
#line 3634 "ripper.y"
 
9193
#line 3637 "ripper.y"
9191
9194
    {
9192
9195
#if 0
9193
9196
                        (yyval.val) = NEW_CALL((yyvsp[(1) - (3)].val), rb_intern("call"), (yyvsp[(3) - (3)].val));
9203
9206
  case 404:
9204
9207
 
9205
9208
/* Line 1464 of yacc.c  */
9206
 
#line 3645 "ripper.y"
 
9209
#line 3648 "ripper.y"
9207
9210
    {
9208
9211
#if 0
9209
9212
                        (yyval.val) = NEW_SUPER((yyvsp[(2) - (2)].val));
9216
9219
  case 405:
9217
9220
 
9218
9221
/* Line 1464 of yacc.c  */
9219
 
#line 3653 "ripper.y"
 
9222
#line 3656 "ripper.y"
9220
9223
    {
9221
9224
#if 0
9222
9225
                        (yyval.val) = NEW_ZSUPER();
9229
9232
  case 406:
9230
9233
 
9231
9234
/* Line 1464 of yacc.c  */
9232
 
#line 3661 "ripper.y"
 
9235
#line 3664 "ripper.y"
9233
9236
    {
9234
9237
#if 0
9235
9238
                        if ((yyvsp[(1) - (4)].val) && nd_type((yyvsp[(1) - (4)].val)) == NODE_SELF)
9246
9249
  case 407:
9247
9250
 
9248
9251
/* Line 1464 of yacc.c  */
9249
 
#line 3675 "ripper.y"
 
9252
#line 3678 "ripper.y"
9250
9253
    {
9251
9254
                        (yyvsp[(1) - (1)].vars) = dyna_push();
9252
9255
#if 0
9259
9262
  case 408:
9260
9263
 
9261
9264
/* Line 1464 of yacc.c  */
9262
 
#line 3684 "ripper.y"
 
9265
#line 3687 "ripper.y"
9263
9266
    {
9264
9267
#if 0
9265
9268
                        (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9274
9277
  case 409:
9275
9278
 
9276
9279
/* Line 1464 of yacc.c  */
9277
 
#line 3694 "ripper.y"
 
9280
#line 3697 "ripper.y"
9278
9281
    {
9279
9282
                        (yyvsp[(1) - (1)].vars) = dyna_push();
9280
9283
#if 0
9287
9290
  case 410:
9288
9291
 
9289
9292
/* Line 1464 of yacc.c  */
9290
 
#line 3703 "ripper.y"
 
9293
#line 3706 "ripper.y"
9291
9294
    {
9292
9295
#if 0
9293
9296
                        (yyval.val) = NEW_ITER((yyvsp[(3) - (5)].val),(yyvsp[(4) - (5)].val));
9302
9305
  case 411:
9303
9306
 
9304
9307
/* Line 1464 of yacc.c  */
9305
 
#line 3717 "ripper.y"
 
9308
#line 3720 "ripper.y"
9306
9309
    {
9307
9310
#if 0
9308
9311
                        (yyval.val) = NEW_WHEN((yyvsp[(2) - (5)].val), (yyvsp[(4) - (5)].val), (yyvsp[(5) - (5)].val));
9315
9318
  case 414:
9316
9319
 
9317
9320
/* Line 1464 of yacc.c  */
9318
 
#line 3733 "ripper.y"
 
9321
#line 3736 "ripper.y"
9319
9322
    {
9320
9323
#if 0
9321
9324
                        if ((yyvsp[(3) - (6)].val)) {
9337
9340
  case 416:
9338
9341
 
9339
9342
/* Line 1464 of yacc.c  */
9340
 
#line 3753 "ripper.y"
 
9343
#line 3756 "ripper.y"
9341
9344
    {
9342
9345
#if 0
9343
9346
                        (yyval.val) = NEW_LIST((yyvsp[(1) - (1)].val));
9350
9353
  case 417:
9351
9354
 
9352
9355
/* Line 1464 of yacc.c  */
9353
 
#line 3761 "ripper.y"
 
9356
#line 3764 "ripper.y"
9354
9357
    {
9355
9358
#if 0
9356
9359
                        if (!((yyval.val) = splat_array((yyvsp[(1) - (1)].val)))) (yyval.val) = (yyvsp[(1) - (1)].val);
9363
9366
  case 419:
9364
9367
 
9365
9368
/* Line 1464 of yacc.c  */
9366
 
#line 3772 "ripper.y"
 
9369
#line 3775 "ripper.y"
9367
9370
    {
9368
9371
                        (yyval.val) = (yyvsp[(2) - (2)].val);
9369
9372
                    ;}
9372
9375
  case 421:
9373
9376
 
9374
9377
/* Line 1464 of yacc.c  */
9375
 
#line 3779 "ripper.y"
 
9378
#line 3782 "ripper.y"
9376
9379
    {
9377
9380
#if 0
9378
9381
                        (yyval.val) = (yyvsp[(2) - (2)].val);
9385
9388
  case 424:
9386
9389
 
9387
9390
/* Line 1464 of yacc.c  */
9388
 
#line 3791 "ripper.y"
 
9391
#line 3794 "ripper.y"
9389
9392
    {
9390
9393
#if 0
9391
9394
                        (yyval.val) = NEW_LIT(ID2SYM((yyvsp[(1) - (1)].val)));
9398
9401
  case 426:
9399
9402
 
9400
9403
/* Line 1464 of yacc.c  */
9401
 
#line 3802 "ripper.y"
 
9404
#line 3805 "ripper.y"
9402
9405
    {
9403
9406
#if 0
9404
9407
                        NODE *node = (yyvsp[(1) - (1)].val);
9418
9421
  case 429:
9419
9422
 
9420
9423
/* Line 1464 of yacc.c  */
9421
 
#line 3821 "ripper.y"
 
9424
#line 3824 "ripper.y"
9422
9425
    {
9423
9426
#if 0
9424
9427
                        (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9431
9434
  case 430:
9432
9435
 
9433
9436
/* Line 1464 of yacc.c  */
9434
 
#line 3831 "ripper.y"
 
9437
#line 3834 "ripper.y"
9435
9438
    {
9436
9439
#if 0
9437
9440
                        (yyval.val) = (yyvsp[(2) - (3)].val);
9444
9447
  case 431:
9445
9448
 
9446
9449
/* Line 1464 of yacc.c  */
9447
 
#line 3841 "ripper.y"
 
9450
#line 3844 "ripper.y"
9448
9451
    {
9449
9452
#if 0
9450
9453
                        NODE *node = (yyvsp[(2) - (3)].val);
9474
9477
  case 432:
9475
9478
 
9476
9479
/* Line 1464 of yacc.c  */
9477
 
#line 3868 "ripper.y"
 
9480
#line 3871 "ripper.y"
9478
9481
    {
9479
9482
#if 0
9480
9483
                        int options = (yyvsp[(3) - (3)].val);
9542
9545
  case 433:
9543
9546
 
9544
9547
/* Line 1464 of yacc.c  */
9545
 
#line 3933 "ripper.y"
 
9548
#line 3936 "ripper.y"
9546
9549
    {
9547
9550
#if 0
9548
9551
                        (yyval.val) = NEW_ZARRAY();
9549
9552
#endif
9550
9553
                        (yyval.val) = dispatch0(words_new);
 
9554
                        (yyval.val) = dispatch1(array, (yyval.val));
9551
9555
 
9552
9556
                    ;}
9553
9557
    break;
9555
9559
  case 434:
9556
9560
 
9557
9561
/* Line 1464 of yacc.c  */
9558
 
#line 3941 "ripper.y"
 
9562
#line 3945 "ripper.y"
9559
9563
    {
 
9564
#if 0
9560
9565
                        (yyval.val) = (yyvsp[(2) - (3)].val);
 
9566
#endif
 
9567
                        (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
 
9568
 
9561
9569
                    ;}
9562
9570
    break;
9563
9571
 
9564
9572
  case 435:
9565
9573
 
9566
9574
/* Line 1464 of yacc.c  */
9567
 
#line 3947 "ripper.y"
 
9575
#line 3955 "ripper.y"
9568
9576
    {
9569
9577
#if 0
9570
9578
                        (yyval.val) = 0;
9577
9585
  case 436:
9578
9586
 
9579
9587
/* Line 1464 of yacc.c  */
9580
 
#line 3955 "ripper.y"
 
9588
#line 3963 "ripper.y"
9581
9589
    {
9582
9590
#if 0
9583
9591
                        (yyval.val) = list_append((yyvsp[(1) - (3)].val), evstr2dstr((yyvsp[(2) - (3)].val)));
9590
9598
  case 437:
9591
9599
 
9592
9600
/* Line 1464 of yacc.c  */
9593
 
#line 3967 "ripper.y"
 
9601
#line 3975 "ripper.y"
9594
9602
    {
9595
9603
                        (yyval.val) = dispatch0(word_new);
9596
9604
                        (yyval.val) = dispatch2(word_add, (yyval.val), (yyvsp[(1) - (1)].val));
9600
9608
  case 438:
9601
9609
 
9602
9610
/* Line 1464 of yacc.c  */
9603
 
#line 3973 "ripper.y"
 
9611
#line 3981 "ripper.y"
9604
9612
    {
9605
9613
#if 0
9606
9614
                        (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9613
9621
  case 439:
9614
9622
 
9615
9623
/* Line 1464 of yacc.c  */
9616
 
#line 3983 "ripper.y"
 
9624
#line 3991 "ripper.y"
9617
9625
    {
9618
9626
#if 0
9619
9627
                        (yyval.val) = NEW_ZARRAY();
9620
9628
#endif
9621
9629
                        (yyval.val) = dispatch0(qwords_new);
 
9630
                        (yyval.val) = dispatch1(array, (yyval.val));
9622
9631
 
9623
9632
                    ;}
9624
9633
    break;
9626
9635
  case 440:
9627
9636
 
9628
9637
/* Line 1464 of yacc.c  */
9629
 
#line 3991 "ripper.y"
 
9638
#line 4000 "ripper.y"
9630
9639
    {
 
9640
#if 0
9631
9641
                        (yyval.val) = (yyvsp[(2) - (3)].val);
 
9642
#endif
 
9643
                        (yyval.val) = dispatch1(array, (yyvsp[(2) - (3)].val));
 
9644
 
9632
9645
                    ;}
9633
9646
    break;
9634
9647
 
9635
9648
  case 441:
9636
9649
 
9637
9650
/* Line 1464 of yacc.c  */
9638
 
#line 3997 "ripper.y"
 
9651
#line 4010 "ripper.y"
9639
9652
    {
9640
9653
#if 0
9641
9654
                        (yyval.val) = 0;
9648
9661
  case 442:
9649
9662
 
9650
9663
/* Line 1464 of yacc.c  */
9651
 
#line 4005 "ripper.y"
 
9664
#line 4018 "ripper.y"
9652
9665
    {
9653
9666
#if 0
9654
9667
                        (yyval.val) = list_append((yyvsp[(1) - (3)].val), (yyvsp[(2) - (3)].val));
9661
9674
  case 443:
9662
9675
 
9663
9676
/* Line 1464 of yacc.c  */
9664
 
#line 4015 "ripper.y"
 
9677
#line 4028 "ripper.y"
9665
9678
    {
9666
9679
#if 0
9667
9680
                        (yyval.val) = 0;
9674
9687
  case 444:
9675
9688
 
9676
9689
/* Line 1464 of yacc.c  */
9677
 
#line 4023 "ripper.y"
 
9690
#line 4036 "ripper.y"
9678
9691
    {
9679
9692
#if 0
9680
9693
                        (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9687
9700
  case 445:
9688
9701
 
9689
9702
/* Line 1464 of yacc.c  */
9690
 
#line 4033 "ripper.y"
 
9703
#line 4046 "ripper.y"
9691
9704
    {
9692
9705
#if 0
9693
9706
                        (yyval.val) = 0;
9700
9713
  case 446:
9701
9714
 
9702
9715
/* Line 1464 of yacc.c  */
9703
 
#line 4041 "ripper.y"
 
9716
#line 4054 "ripper.y"
9704
9717
    {
9705
9718
#if 0
9706
9719
                        (yyval.val) = literal_concat((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].val));
9713
9726
  case 447:
9714
9727
 
9715
9728
/* Line 1464 of yacc.c  */
9716
 
#line 4051 "ripper.y"
 
9729
#line 4064 "ripper.y"
9717
9730
    {
9718
9731
#if 0
9719
9732
                        (yyval.val) = 0;
9726
9739
  case 448:
9727
9740
 
9728
9741
/* Line 1464 of yacc.c  */
9729
 
#line 4059 "ripper.y"
 
9742
#line 4072 "ripper.y"
9730
9743
    {
9731
9744
#if 0
9732
9745
                        NODE *head = (yyvsp[(1) - (2)].val), *tail = (yyvsp[(2) - (2)].val);
9758
9771
  case 450:
9759
9772
 
9760
9773
/* Line 1464 of yacc.c  */
9761
 
#line 4089 "ripper.y"
 
9774
#line 4102 "ripper.y"
9762
9775
    {
9763
9776
                        (yyval.node) = lex_strterm;
9764
9777
                        lex_strterm = 0;
9769
9782
  case 451:
9770
9783
 
9771
9784
/* Line 1464 of yacc.c  */
9772
 
#line 4095 "ripper.y"
 
9785
#line 4108 "ripper.y"
9773
9786
    {
9774
9787
#if 0
9775
9788
                        lex_strterm = (yyvsp[(2) - (3)].node);
9784
9797
  case 452:
9785
9798
 
9786
9799
/* Line 1464 of yacc.c  */
9787
 
#line 4105 "ripper.y"
 
9800
#line 4118 "ripper.y"
9788
9801
    {
9789
9802
                        (yyvsp[(1) - (1)].val) = cond_stack;
9790
9803
                        (yyval.val) = cmdarg_stack;
9796
9809
  case 453:
9797
9810
 
9798
9811
/* Line 1464 of yacc.c  */
9799
 
#line 4111 "ripper.y"
 
9812
#line 4124 "ripper.y"
9800
9813
    {
9801
9814
                        (yyval.node) = lex_strterm;
9802
9815
                        lex_strterm = 0;
9807
9820
  case 454:
9808
9821
 
9809
9822
/* Line 1464 of yacc.c  */
9810
 
#line 4117 "ripper.y"
 
9823
#line 4130 "ripper.y"
9811
9824
    {
9812
9825
                        cond_stack = (yyvsp[(1) - (5)].val);
9813
9826
                        cmdarg_stack = (yyvsp[(2) - (5)].val);
9824
9837
  case 455:
9825
9838
 
9826
9839
/* Line 1464 of yacc.c  */
9827
 
#line 4131 "ripper.y"
 
9840
#line 4144 "ripper.y"
9828
9841
    {
9829
9842
#if 0
9830
9843
                        (yyval.val) = NEW_GVAR((yyvsp[(1) - (1)].val));
9837
9850
  case 456:
9838
9851
 
9839
9852
/* Line 1464 of yacc.c  */
9840
 
#line 4139 "ripper.y"
 
9853
#line 4152 "ripper.y"
9841
9854
    {
9842
9855
#if 0
9843
9856
                        (yyval.val) = NEW_IVAR((yyvsp[(1) - (1)].val));
9850
9863
  case 457:
9851
9864
 
9852
9865
/* Line 1464 of yacc.c  */
9853
 
#line 4147 "ripper.y"
 
9866
#line 4160 "ripper.y"
9854
9867
    {
9855
9868
#if 0
9856
9869
                        (yyval.val) = NEW_CVAR((yyvsp[(1) - (1)].val));
9863
9876
  case 459:
9864
9877
 
9865
9878
/* Line 1464 of yacc.c  */
9866
 
#line 4158 "ripper.y"
 
9879
#line 4171 "ripper.y"
9867
9880
    {
9868
9881
                        lex_state = EXPR_END;
9869
9882
#if 0
9877
9890
  case 464:
9878
9891
 
9879
9892
/* Line 1464 of yacc.c  */
9880
 
#line 4175 "ripper.y"
 
9893
#line 4188 "ripper.y"
9881
9894
    {
9882
9895
                        lex_state = EXPR_END;
9883
9896
#if 0
9910
9923
  case 467:
9911
9924
 
9912
9925
/* Line 1464 of yacc.c  */
9913
 
#line 4207 "ripper.y"
 
9926
#line 4220 "ripper.y"
9914
9927
    {
9915
9928
#if 0
9916
9929
                        (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
9923
9936
  case 468:
9924
9937
 
9925
9938
/* Line 1464 of yacc.c  */
9926
 
#line 4215 "ripper.y"
 
9939
#line 4228 "ripper.y"
9927
9940
    {
9928
9941
#if 0
9929
9942
                        (yyval.val) = negate_lit((yyvsp[(2) - (2)].val));
9936
9949
  case 474:
9937
9950
 
9938
9951
/* Line 1464 of yacc.c  */
9939
 
#line 4229 "ripper.y"
 
9952
#line 4242 "ripper.y"
9940
9953
    {ifndef_ripper((yyval.val) = keyword_nil);;}
9941
9954
    break;
9942
9955
 
9943
9956
  case 475:
9944
9957
 
9945
9958
/* Line 1464 of yacc.c  */
9946
 
#line 4230 "ripper.y"
 
9959
#line 4243 "ripper.y"
9947
9960
    {ifndef_ripper((yyval.val) = keyword_self);;}
9948
9961
    break;
9949
9962
 
9950
9963
  case 476:
9951
9964
 
9952
9965
/* Line 1464 of yacc.c  */
9953
 
#line 4231 "ripper.y"
 
9966
#line 4244 "ripper.y"
9954
9967
    {ifndef_ripper((yyval.val) = keyword_true);;}
9955
9968
    break;
9956
9969
 
9957
9970
  case 477:
9958
9971
 
9959
9972
/* Line 1464 of yacc.c  */
9960
 
#line 4232 "ripper.y"
 
9973
#line 4245 "ripper.y"
9961
9974
    {ifndef_ripper((yyval.val) = keyword_false);;}
9962
9975
    break;
9963
9976
 
9964
9977
  case 478:
9965
9978
 
9966
9979
/* Line 1464 of yacc.c  */
9967
 
#line 4233 "ripper.y"
 
9980
#line 4246 "ripper.y"
9968
9981
    {ifndef_ripper((yyval.val) = keyword__FILE__);;}
9969
9982
    break;
9970
9983
 
9971
9984
  case 479:
9972
9985
 
9973
9986
/* Line 1464 of yacc.c  */
9974
 
#line 4234 "ripper.y"
 
9987
#line 4247 "ripper.y"
9975
9988
    {ifndef_ripper((yyval.val) = keyword__LINE__);;}
9976
9989
    break;
9977
9990
 
9978
9991
  case 480:
9979
9992
 
9980
9993
/* Line 1464 of yacc.c  */
9981
 
#line 4235 "ripper.y"
 
9994
#line 4248 "ripper.y"
9982
9995
    {ifndef_ripper((yyval.val) = keyword__ENCODING__);;}
9983
9996
    break;
9984
9997
 
9985
9998
  case 481:
9986
9999
 
9987
10000
/* Line 1464 of yacc.c  */
9988
 
#line 4239 "ripper.y"
 
10001
#line 4252 "ripper.y"
9989
10002
    {
9990
10003
#if 0
9991
10004
                        if (!((yyval.val) = gettable((yyvsp[(1) - (1)].val)))) (yyval.val) = NEW_BEGIN(0);
9998
10011
  case 482:
9999
10012
 
10000
10013
/* Line 1464 of yacc.c  */
10001
 
#line 4249 "ripper.y"
 
10014
#line 4262 "ripper.y"
10002
10015
    {
10003
10016
                        (yyval.val) = assignable((yyvsp[(1) - (1)].val), 0);
10004
10017
#if 0
10011
10024
  case 485:
10012
10025
 
10013
10026
/* Line 1464 of yacc.c  */
10014
 
#line 4263 "ripper.y"
 
10027
#line 4276 "ripper.y"
10015
10028
    {
10016
10029
#if 0
10017
10030
                        (yyval.val) = 0;
10024
10037
  case 486:
10025
10038
 
10026
10039
/* Line 1464 of yacc.c  */
10027
 
#line 4271 "ripper.y"
 
10040
#line 4284 "ripper.y"
10028
10041
    {
10029
10042
                        lex_state = EXPR_BEG;
10030
10043
                    ;}
10033
10046
  case 487:
10034
10047
 
10035
10048
/* Line 1464 of yacc.c  */
10036
 
#line 4275 "ripper.y"
 
10049
#line 4288 "ripper.y"
10037
10050
    {
10038
10051
                        (yyval.val) = (yyvsp[(3) - (4)].val);
10039
10052
                    ;}
10042
10055
  case 488:
10043
10056
 
10044
10057
/* Line 1464 of yacc.c  */
10045
 
#line 4279 "ripper.y"
 
10058
#line 4292 "ripper.y"
10046
10059
    {
10047
10060
#if 0
10048
10061
                        yyerrok;
10057
10070
  case 489:
10058
10071
 
10059
10072
/* Line 1464 of yacc.c  */
10060
 
#line 4291 "ripper.y"
 
10073
#line 4304 "ripper.y"
10061
10074
    {
10062
10075
#if 0
10063
10076
                        (yyval.val) = (yyvsp[(2) - (3)].val);
10072
10085
  case 490:
10073
10086
 
10074
10087
/* Line 1464 of yacc.c  */
10075
 
#line 4301 "ripper.y"
 
10088
#line 4314 "ripper.y"
10076
10089
    {
10077
10090
                        (yyval.val) = (yyvsp[(1) - (2)].val);
10078
10091
                    ;}
10081
10094
  case 491:
10082
10095
 
10083
10096
/* Line 1464 of yacc.c  */
10084
 
#line 4307 "ripper.y"
 
10097
#line 4320 "ripper.y"
10085
10098
    {
10086
10099
#if 0
10087
10100
                        (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), 0, (yyvsp[(6) - (6)].val));
10094
10107
  case 492:
10095
10108
 
10096
10109
/* Line 1464 of yacc.c  */
10097
 
#line 4315 "ripper.y"
 
10110
#line 4328 "ripper.y"
10098
10111
    {
10099
10112
#if 0
10100
10113
                        (yyval.val) = new_args((yyvsp[(1) - (8)].val), (yyvsp[(3) - (8)].val), (yyvsp[(5) - (8)].val), (yyvsp[(7) - (8)].val), (yyvsp[(8) - (8)].val));
10107
10120
  case 493:
10108
10121
 
10109
10122
/* Line 1464 of yacc.c  */
10110
 
#line 4323 "ripper.y"
 
10123
#line 4336 "ripper.y"
10111
10124
    {
10112
10125
#if 0
10113
10126
                        (yyval.val) = new_args((yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, 0, (yyvsp[(4) - (4)].val));
10120
10133
  case 494:
10121
10134
 
10122
10135
/* Line 1464 of yacc.c  */
10123
 
#line 4331 "ripper.y"
 
10136
#line 4344 "ripper.y"
10124
10137
    {
10125
10138
#if 0
10126
10139
                        (yyval.val) = new_args((yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), 0, (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10133
10146
  case 495:
10134
10147
 
10135
10148
/* Line 1464 of yacc.c  */
10136
 
#line 4339 "ripper.y"
 
10149
#line 4352 "ripper.y"
10137
10150
    {
10138
10151
#if 0
10139
10152
                        (yyval.val) = new_args((yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10146
10159
  case 496:
10147
10160
 
10148
10161
/* Line 1464 of yacc.c  */
10149
 
#line 4347 "ripper.y"
 
10162
#line 4360 "ripper.y"
10150
10163
    {
10151
10164
#if 0
10152
10165
                        (yyval.val) = new_args((yyvsp[(1) - (6)].val), 0, (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10159
10172
  case 497:
10160
10173
 
10161
10174
/* Line 1464 of yacc.c  */
10162
 
#line 4355 "ripper.y"
 
10175
#line 4368 "ripper.y"
10163
10176
    {
10164
10177
#if 0
10165
10178
                        (yyval.val) = new_args((yyvsp[(1) - (2)].val), 0, 0, 0, (yyvsp[(2) - (2)].val));
10172
10185
  case 498:
10173
10186
 
10174
10187
/* Line 1464 of yacc.c  */
10175
 
#line 4363 "ripper.y"
 
10188
#line 4376 "ripper.y"
10176
10189
    {
10177
10190
#if 0
10178
10191
                        (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), 0, (yyvsp[(4) - (4)].val));
10185
10198
  case 499:
10186
10199
 
10187
10200
/* Line 1464 of yacc.c  */
10188
 
#line 4371 "ripper.y"
 
10201
#line 4384 "ripper.y"
10189
10202
    {
10190
10203
#if 0
10191
10204
                        (yyval.val) = new_args(0, (yyvsp[(1) - (6)].val), (yyvsp[(3) - (6)].val), (yyvsp[(5) - (6)].val), (yyvsp[(6) - (6)].val));
10198
10211
  case 500:
10199
10212
 
10200
10213
/* Line 1464 of yacc.c  */
10201
 
#line 4379 "ripper.y"
 
10214
#line 4392 "ripper.y"
10202
10215
    {
10203
10216
#if 0
10204
10217
                        (yyval.val) = new_args(0, (yyvsp[(1) - (2)].val), 0, 0, (yyvsp[(2) - (2)].val));
10211
10224
  case 501:
10212
10225
 
10213
10226
/* Line 1464 of yacc.c  */
10214
 
#line 4387 "ripper.y"
 
10227
#line 4400 "ripper.y"
10215
10228
    {
10216
10229
#if 0
10217
10230
                        (yyval.val) = new_args(0, (yyvsp[(1) - (4)].val), 0, (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10224
10237
  case 502:
10225
10238
 
10226
10239
/* Line 1464 of yacc.c  */
10227
 
#line 4395 "ripper.y"
 
10240
#line 4408 "ripper.y"
10228
10241
    {
10229
10242
#if 0
10230
10243
                        (yyval.val) = new_args(0, 0, (yyvsp[(1) - (2)].val), 0, (yyvsp[(2) - (2)].val));
10237
10250
  case 503:
10238
10251
 
10239
10252
/* Line 1464 of yacc.c  */
10240
 
#line 4403 "ripper.y"
 
10253
#line 4416 "ripper.y"
10241
10254
    {
10242
10255
#if 0
10243
10256
                        (yyval.val) = new_args(0, 0, (yyvsp[(1) - (4)].val), (yyvsp[(3) - (4)].val), (yyvsp[(4) - (4)].val));
10250
10263
  case 504:
10251
10264
 
10252
10265
/* Line 1464 of yacc.c  */
10253
 
#line 4411 "ripper.y"
 
10266
#line 4424 "ripper.y"
10254
10267
    {
10255
10268
#if 0
10256
10269
                        (yyval.val) = new_args(0, 0, 0, 0, (yyvsp[(1) - (1)].val));
10263
10276
  case 505:
10264
10277
 
10265
10278
/* Line 1464 of yacc.c  */
10266
 
#line 4419 "ripper.y"
 
10279
#line 4432 "ripper.y"
10267
10280
    {
10268
10281
#if 0
10269
10282
                        (yyval.val) = new_args(0, 0, 0, 0, 0);
10276
10289
  case 506:
10277
10290
 
10278
10291
/* Line 1464 of yacc.c  */
10279
 
#line 4429 "ripper.y"
 
10292
#line 4442 "ripper.y"
10280
10293
    {
10281
10294
#if 0
10282
10295
                        yyerror("formal argument cannot be a constant");
10290
10303
  case 507:
10291
10304
 
10292
10305
/* Line 1464 of yacc.c  */
10293
 
#line 4438 "ripper.y"
 
10306
#line 4451 "ripper.y"
10294
10307
    {
10295
10308
#if 0
10296
10309
                        yyerror("formal argument cannot be an instance variable");
10304
10317
  case 508:
10305
10318
 
10306
10319
/* Line 1464 of yacc.c  */
10307
 
#line 4447 "ripper.y"
 
10320
#line 4460 "ripper.y"
10308
10321
    {
10309
10322
#if 0
10310
10323
                        yyerror("formal argument cannot be a global variable");
10318
10331
  case 509:
10319
10332
 
10320
10333
/* Line 1464 of yacc.c  */
10321
 
#line 4456 "ripper.y"
 
10334
#line 4469 "ripper.y"
10322
10335
    {
10323
10336
#if 0
10324
10337
                        yyerror("formal argument cannot be a class variable");
10332
10345
  case 511:
10333
10346
 
10334
10347
/* Line 1464 of yacc.c  */
10335
 
#line 4468 "ripper.y"
 
10348
#line 4481 "ripper.y"
10336
10349
    {
10337
10350
                        formal_argument(get_id((yyvsp[(1) - (1)].val)));
10338
10351
                        (yyval.val) = (yyvsp[(1) - (1)].val);
10342
10355
  case 512:
10343
10356
 
10344
10357
/* Line 1464 of yacc.c  */
10345
 
#line 4475 "ripper.y"
 
10358
#line 4488 "ripper.y"
10346
10359
    {
10347
10360
                        arg_var(get_id((yyvsp[(1) - (1)].val)));
10348
10361
#if 0
10356
10369
  case 513:
10357
10370
 
10358
10371
/* Line 1464 of yacc.c  */
10359
 
#line 4484 "ripper.y"
 
10372
#line 4497 "ripper.y"
10360
10373
    {
10361
10374
                        ID tid = internal_id();
10362
10375
                        arg_var(tid);
10378
10391
  case 514:
10379
10392
 
10380
10393
/* Line 1464 of yacc.c  */
10381
 
#line 4505 "ripper.y"
 
10394
#line 4518 "ripper.y"
10382
10395
    {
10383
10396
                        (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10384
10397
                    ;}
10387
10400
  case 515:
10388
10401
 
10389
10402
/* Line 1464 of yacc.c  */
10390
 
#line 4510 "ripper.y"
 
10403
#line 4523 "ripper.y"
10391
10404
    {
10392
10405
#if 0
10393
10406
                        (yyval.val) = (yyvsp[(1) - (3)].val);
10403
10416
  case 516:
10404
10417
 
10405
10418
/* Line 1464 of yacc.c  */
10406
 
#line 4523 "ripper.y"
 
10419
#line 4536 "ripper.y"
10407
10420
    {
10408
10421
                        arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10409
10422
                        (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10418
10431
  case 517:
10419
10432
 
10420
10433
/* Line 1464 of yacc.c  */
10421
 
#line 4535 "ripper.y"
 
10434
#line 4548 "ripper.y"
10422
10435
    {
10423
10436
                        arg_var(formal_argument(get_id((yyvsp[(1) - (3)].val))));
10424
10437
                        (yyval.val) = assignable((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10433
10446
  case 518:
10434
10447
 
10435
10448
/* Line 1464 of yacc.c  */
10436
 
#line 4547 "ripper.y"
 
10449
#line 4560 "ripper.y"
10437
10450
    {
10438
10451
#if 0
10439
10452
                        (yyval.val) = (yyvsp[(1) - (1)].val);
10446
10459
  case 519:
10447
10460
 
10448
10461
/* Line 1464 of yacc.c  */
10449
 
#line 4555 "ripper.y"
 
10462
#line 4568 "ripper.y"
10450
10463
    {
10451
10464
#if 0
10452
10465
                        NODE *opts = (yyvsp[(1) - (3)].val);
10465
10478
  case 520:
10466
10479
 
10467
10480
/* Line 1464 of yacc.c  */
10468
 
#line 4571 "ripper.y"
 
10481
#line 4584 "ripper.y"
10469
10482
    {
10470
10483
#if 0
10471
10484
                        (yyval.val) = (yyvsp[(1) - (1)].val);
10478
10491
  case 521:
10479
10492
 
10480
10493
/* Line 1464 of yacc.c  */
10481
 
#line 4579 "ripper.y"
 
10494
#line 4592 "ripper.y"
10482
10495
    {
10483
10496
#if 0
10484
10497
                        NODE *opts = (yyvsp[(1) - (3)].val);
10497
10510
  case 524:
10498
10511
 
10499
10512
/* Line 1464 of yacc.c  */
10500
 
#line 4599 "ripper.y"
 
10513
#line 4612 "ripper.y"
10501
10514
    {
10502
10515
#if 0
10503
10516
                        if (!is_local_id((yyvsp[(2) - (2)].val)))
10515
10528
  case 525:
10516
10529
 
10517
10530
/* Line 1464 of yacc.c  */
10518
 
#line 4612 "ripper.y"
 
10531
#line 4625 "ripper.y"
10519
10532
    {
10520
10533
#if 0
10521
10534
                        (yyval.val) = internal_id();
10529
10542
  case 528:
10530
10543
 
10531
10544
/* Line 1464 of yacc.c  */
10532
 
#line 4627 "ripper.y"
 
10545
#line 4640 "ripper.y"
10533
10546
    {
10534
10547
#if 0
10535
10548
                        if (!is_local_id((yyvsp[(2) - (2)].val)))
10549
10562
  case 529:
10550
10563
 
10551
10564
/* Line 1464 of yacc.c  */
10552
 
#line 4644 "ripper.y"
 
10565
#line 4657 "ripper.y"
10553
10566
    {
10554
10567
                        (yyval.val) = (yyvsp[(2) - (2)].val);
10555
10568
                    ;}
10558
10571
  case 530:
10559
10572
 
10560
10573
/* Line 1464 of yacc.c  */
10561
 
#line 4648 "ripper.y"
 
10574
#line 4661 "ripper.y"
10562
10575
    {
10563
10576
#if 0
10564
10577
                        (yyval.val) = 0;
10571
10584
  case 531:
10572
10585
 
10573
10586
/* Line 1464 of yacc.c  */
10574
 
#line 4658 "ripper.y"
 
10587
#line 4671 "ripper.y"
10575
10588
    {
10576
10589
#if 0
10577
10590
                        value_expr((yyvsp[(1) - (1)].val));
10586
10599
  case 532:
10587
10600
 
10588
10601
/* Line 1464 of yacc.c  */
10589
 
#line 4667 "ripper.y"
 
10602
#line 4680 "ripper.y"
10590
10603
    {lex_state = EXPR_BEG;;}
10591
10604
    break;
10592
10605
 
10593
10606
  case 533:
10594
10607
 
10595
10608
/* Line 1464 of yacc.c  */
10596
 
#line 4668 "ripper.y"
 
10609
#line 4681 "ripper.y"
10597
10610
    {
10598
10611
#if 0
10599
10612
                        if ((yyvsp[(3) - (4)].val) == 0) {
10625
10638
  case 535:
10626
10639
 
10627
10640
/* Line 1464 of yacc.c  */
10628
 
#line 4698 "ripper.y"
 
10641
#line 4711 "ripper.y"
10629
10642
    {
10630
10643
#if 0
10631
10644
                        (yyval.val) = (yyvsp[(1) - (2)].val);
10638
10651
  case 536:
10639
10652
 
10640
10653
/* Line 1464 of yacc.c  */
10641
 
#line 4710 "ripper.y"
 
10654
#line 4723 "ripper.y"
10642
10655
    {
10643
10656
                        (yyval.val) = rb_ary_new3(1, (yyvsp[(1) - (1)].val));
10644
10657
                    ;}
10647
10660
  case 537:
10648
10661
 
10649
10662
/* Line 1464 of yacc.c  */
10650
 
#line 4715 "ripper.y"
 
10663
#line 4728 "ripper.y"
10651
10664
    {
10652
10665
#if 0
10653
10666
                        (yyval.val) = list_concat((yyvsp[(1) - (3)].val), (yyvsp[(3) - (3)].val));
10660
10673
  case 538:
10661
10674
 
10662
10675
/* Line 1464 of yacc.c  */
10663
 
#line 4725 "ripper.y"
 
10676
#line 4738 "ripper.y"
10664
10677
    {
10665
10678
#if 0
10666
10679
                        (yyval.val) = list_append(NEW_LIST((yyvsp[(1) - (3)].val)), (yyvsp[(3) - (3)].val));
10673
10686
  case 539:
10674
10687
 
10675
10688
/* Line 1464 of yacc.c  */
10676
 
#line 4733 "ripper.y"
 
10689
#line 4746 "ripper.y"
10677
10690
    {
10678
10691
#if 0
10679
10692
                        (yyval.val) = list_append(NEW_LIST(NEW_LIT(ID2SYM((yyvsp[(1) - (2)].val)))), (yyvsp[(2) - (2)].val));
10686
10699
  case 550:
10687
10700
 
10688
10701
/* Line 1464 of yacc.c  */
10689
 
#line 4761 "ripper.y"
 
10702
#line 4774 "ripper.y"
10690
10703
    { (yyval.val) = (yyvsp[(1) - (1)].val); ;}
10691
10704
    break;
10692
10705
 
10693
10706
  case 551:
10694
10707
 
10695
10708
/* Line 1464 of yacc.c  */
10696
 
#line 4766 "ripper.y"
 
10709
#line 4779 "ripper.y"
10697
10710
    { (yyval.val) = (yyvsp[(1) - (1)].val); ;}
10698
10711
    break;
10699
10712
 
10700
10713
  case 561:
10701
10714
 
10702
10715
/* Line 1464 of yacc.c  */
10703
 
#line 4789 "ripper.y"
 
10716
#line 4802 "ripper.y"
10704
10717
    {yyerrok;;}
10705
10718
    break;
10706
10719
 
10707
10720
  case 564:
10708
10721
 
10709
10722
/* Line 1464 of yacc.c  */
10710
 
#line 4794 "ripper.y"
 
10723
#line 4807 "ripper.y"
10711
10724
    {yyerrok;;}
10712
10725
    break;
10713
10726
 
10714
10727
  case 565:
10715
10728
 
10716
10729
/* Line 1464 of yacc.c  */
10717
 
#line 4798 "ripper.y"
 
10730
#line 4811 "ripper.y"
10718
10731
    {
10719
10732
#if 0
10720
10733
                        (yyval.val) = 0;
10727
10740
 
10728
10741
 
10729
10742
/* Line 1464 of yacc.c  */
10730
 
#line 10729 "parse.c"
 
10743
#line 10742 "parse.c"
10731
10744
      default: break;
10732
10745
    }
10733
10746
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
10939
10952
 
10940
10953
 
10941
10954
/* Line 1684 of yacc.c  */
10942
 
#line 4806 "ripper.y"
 
10955
#line 4819 "ripper.y"
10943
10956
 
10944
10957
# undef parser
10945
10958
# undef yylex
11341
11354
    must_be_ascii_compatible(line);
11342
11355
#ifndef RIPPER
11343
11356
    if (ruby_debug_lines) {
 
11357
        rb_enc_associate(line, parser->enc);
11344
11358
        rb_ary_push(ruby_debug_lines, line);
11345
11359
    }
11346
11360
    if (ruby_coverage) {
12096
12110
 
12097
12111
    tokfix();
12098
12112
    set_yylval_str(STR_NEW3(tok(), toklen(), enc, func));
 
12113
 
 
12114
#ifdef RIPPER
 
12115
    if (!NIL_P(parser->delayed)){
 
12116
        ptrdiff_t len = lex_p - parser->tokp;
 
12117
        if (len > 0) {
 
12118
            rb_enc_str_buf_cat(parser->delayed, parser->tokp, len, enc);
 
12119
        }
 
12120
        ripper_dispatch_delayed_token(parser, tSTRING_CONTENT);
 
12121
        parser->tokp = lex_p;
 
12122
    }
 
12123
#endif
 
12124
 
12099
12125
    return tSTRING_CONTENT;
12100
12126
}
12101
12127
 
12343
12369
        if (rb_memcicmp(name + nlen + 1, "unix", 4) == 0)
12344
12370
            return nlen;
12345
12371
    }
12346
 
    if (len > 4 && name[nlen = len - 5] == '-') {
 
12372
    if (len > 4 && name[nlen = len - 4] == '-') {
12347
12373
        if (rb_memcicmp(name + nlen + 1, "dos", 3) == 0)
12348
12374
            return nlen;
12349
 
        if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0)
 
12375
        if (rb_memcicmp(name + nlen + 1, "mac", 3) == 0 &&
 
12376
            !(len == 8 && rb_memcicmp(name, "utf8-mac", len) == 0))
 
12377
            /* exclude UTF8-MAC because the encoding named "UTF8" doesn't exist in Ruby */
12350
12378
            return nlen;
12351
12379
    }
12352
12380
    return len;
12376
12404
        goto error;
12377
12405
    }
12378
12406
    parser->enc = enc;
 
12407
#ifndef RIPPER
 
12408
    if (ruby_debug_lines) {
 
12409
        long i, n = RARRAY_LEN(ruby_debug_lines);
 
12410
        const VALUE *p = RARRAY_PTR(ruby_debug_lines);
 
12411
        for (i = 0; i < n; ++i) {
 
12412
            rb_enc_associate_index(*p, idx);
 
12413
        }
 
12414
    }
 
12415
#endif
12379
12416
}
12380
12417
 
12381
12418
static int
13933
13970
#ifdef RIPPER
13934
13971
    if (!NIL_P(parser->delayed)) {
13935
13972
        ripper_dispatch_delayed_token(parser, t);
 
13973
        return t;
13936
13974
    }
13937
13975
    if (t != 0)
13938
13976
        ripper_dispatch_scan_event(parser, t);