LEFT | RIGHT |
1 /* A Bison parser, made by GNU Bison 2.3. */ | 1 /* A Bison parser, made by GNU Bison 2.3. */ |
2 | 2 |
3 /* Skeleton implementation for Bison's Yacc-like parsers in C | 3 /* Skeleton implementation for Bison's Yacc-like parsers in C |
4 | 4 |
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 | 5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 |
6 Free Software Foundation, Inc. | 6 Free Software Foundation, Inc. |
7 | 7 |
8 This program is free software; you can redistribute it and/or modify | 8 This program is free software; you can redistribute it and/or modify |
9 it under the terms of the GNU General Public License as published by | 9 it under the terms of the GNU General Public License as published by |
10 the Free Software Foundation; either version 2, or (at your option) | 10 the Free Software Foundation; either version 2, or (at your option) |
(...skipping 657 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
668 780, 784, 788, 792, 796, 800, 804, 808, 812, 816, | 668 780, 784, 788, 792, 796, 800, 804, 808, 812, 816, |
669 820, 824, 828, 833, 839, 840, 844, 855, 859, 863, | 669 820, 824, 828, 833, 839, 840, 844, 855, 859, 863, |
670 867, 872, 876, 886, 890, 895, 903, 907, 908, 919, | 670 867, 872, 876, 886, 890, 895, 903, 907, 908, 919, |
671 923, 927, 931, 935, 936, 942, 949, 955, 962, 965, | 671 923, 927, 931, 935, 936, 942, 949, 955, 962, 965, |
672 972, 978, 979, 986, 987, 1005, 1006, 1009, 1012, 1016, | 672 972, 978, 979, 986, 987, 1005, 1006, 1009, 1012, 1016, |
673 1027, 1036, 1042, 1045, 1048, 1055, 1056, 1062, 1077, 1085, | 673 1027, 1036, 1042, 1045, 1048, 1055, 1056, 1062, 1077, 1085, |
674 1097, 1102, 1108, 1109, 1110, 1111, 1112, 1113, 1119, 1120, | 674 1097, 1102, 1108, 1109, 1110, 1111, 1112, 1113, 1119, 1120, |
675 1121, 1122, 1128, 1129, 1130, 1131, 1132, 1138, 1139, 1142, | 675 1121, 1122, 1128, 1129, 1130, 1131, 1132, 1138, 1139, 1142, |
676 1145, 1146, 1147, 1148, 1149, 1152, 1153, 1166, 1170, 1175, | 676 1145, 1146, 1147, 1148, 1149, 1152, 1153, 1166, 1170, 1175, |
677 1180, 1185, 1189, 1190, 1193, 1199, 1206, 1212, 1219, 1225, | 677 1180, 1185, 1189, 1190, 1193, 1199, 1206, 1212, 1219, 1225, |
678 1236, 1247, 1276, 1316, 1341, 1366, 1375, 1378, 1386, 1390, | 678 1236, 1247, 1276, 1316, 1341, 1367, 1376, 1379, 1387, 1391, |
679 1394, 1401, 1407, 1412, 1424, 1427, 1436, 1437, 1443, 1444, | 679 1395, 1402, 1408, 1413, 1425, 1428, 1437, 1438, 1444, 1445, |
680 1450, 1454, 1460, 1461, 1467, 1471, 1477, 1500, 1505, 1511, | 680 1451, 1455, 1461, 1462, 1468, 1472, 1478, 1501, 1506, 1512, |
681 1517, 1524, 1533, 1542, 1557, 1563, 1568, 1572, 1579, 1592, | 681 1518, 1525, 1534, 1543, 1558, 1564, 1569, 1573, 1580, 1593, |
682 1593, 1599, 1605, 1608, 1612, 1618, 1621, 1630, 1633, 1634, | 682 1594, 1600, 1606, 1609, 1613, 1619, 1622, 1631, 1634, 1635, |
683 1638, 1639, 1645, 1646, 1647, 1648, 1649, 1651, 1650, 1665, | 683 1639, 1640, 1646, 1647, 1648, 1649, 1650, 1652, 1651, 1666, |
684 1670, 1674, 1678, 1682, 1686, 1691, 1710, 1716, 1724, 1728, | 684 1671, 1675, 1679, 1683, 1687, 1692, 1711, 1717, 1725, 1729, |
685 1734, 1738, 1744, 1748, 1754, 1758, 1767, 1771, 1775, 1779, | 685 1735, 1739, 1745, 1749, 1755, 1759, 1768, 1772, 1776, 1780, |
686 1785, 1788, 1796, 1797, 1799, 1800, 1803, 1806, 1809, 1812, | 686 1786, 1789, 1797, 1798, 1800, 1801, 1804, 1807, 1810, 1813, |
687 1815, 1818, 1821, 1824, 1827, 1830, 1833, 1836, 1839, 1842, | 687 1816, 1819, 1822, 1825, 1828, 1831, 1834, 1837, 1840, 1843, |
688 1848, 1852, 1856, 1860, 1864, 1868, 1888, 1895, 1906, 1907, | 688 1849, 1853, 1857, 1861, 1865, 1869, 1889, 1896, 1907, 1908, |
689 1908, 1911, 1912, 1915, 1919, 1929, 1933, 1937, 1941, 1945, | 689 1909, 1912, 1913, 1916, 1920, 1930, 1934, 1938, 1942, 1946, |
690 1949, 1953, 1959, 1965, 1973, 1981, 1987, 1994, 2010, 2028, | 690 1950, 1954, 1960, 1966, 1974, 1982, 1988, 1995, 2011, 2029, |
691 2032, 2038, 2041, 2044, 2048, 2058, 2062, 2077, 2085, 2086, | 691 2033, 2039, 2042, 2045, 2049, 2059, 2063, 2078, 2086, 2087, |
692 2098, 2099, 2102, 2106, 2112, 2116, 2122, 2126 | 692 2099, 2100, 2103, 2107, 2113, 2117, 2123, 2127 |
693 }; | 693 }; |
694 #endif | 694 #endif |
695 | 695 |
696 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE | 696 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
697 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. | 697 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
698 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ | 698 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
699 const char *yytname[] = | 699 const char *yytname[] = |
700 { | 700 { |
701 "$end", "error", "$undefined", "LLITERAL", "LASOP", "LCOLAS", "LBREAK", | 701 "$end", "error", "$undefined", "LLITERAL", "LASOP", "LCOLAS", "LBREAK", |
702 "LCASE", "LCHAN", "LCONST", "LCONTINUE", "LDDD", "LDEFAULT", "LDEFER", | 702 "LCASE", "LCHAN", "LCONST", "LCONTINUE", "LDDD", "LDEFAULT", "LDEFER", |
(...skipping 3096 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3799 } | 3799 } |
3800 break; | 3800 break; |
3801 | 3801 |
3802 case 204: | 3802 case 204: |
3803 #line 1342 "go.y" | 3803 #line 1342 "go.y" |
3804 { | 3804 { |
3805 (yyval.node) = methodname1(newname((yyvsp[(4) - (8)].sym)), (yyv
sp[(2) - (8)].list)->n->right);· | 3805 (yyval.node) = methodname1(newname((yyvsp[(4) - (8)].sym)), (yyv
sp[(2) - (8)].list)->n->right);· |
3806 (yyval.node)->type = functype((yyvsp[(2) - (8)].list)->n, (yyvsp
[(6) - (8)].list), (yyvsp[(8) - (8)].list)); | 3806 (yyval.node)->type = functype((yyvsp[(2) - (8)].list)->n, (yyvsp
[(6) - (8)].list), (yyvsp[(8) - (8)].list)); |
3807 | 3807 |
3808 checkwidth((yyval.node)->type); | 3808 checkwidth((yyval.node)->type); |
| 3809 thingsused++; |
3809 if(addmethod((yyvsp[(4) - (8)].sym), (yyval.node)->type, 0, noin
terface)) { | 3810 if(addmethod((yyvsp[(4) - (8)].sym), (yyval.node)->type, 0, noin
terface)) { |
3810 // repeated add | 3811 // repeated add |
3811 dclcontext = PDISCARD; // since we skip funchdr below | 3812 dclcontext = PDISCARD; // since we skip funchdr below |
3812 » » » freenode((yyval.node)); | 3813 » » » freenode((yyval.node)); // TODO find more recyclable no
des from ->type |
3813 (yyval.node) = N; | 3814 (yyval.node) = N; |
3814 break; | 3815 break; |
3815 } | 3816 } |
3816 | 3817 » » thingsallocs++; |
3817 nointerface = 0; | 3818 nointerface = 0; |
3818 funchdr((yyval.node)); | 3819 funchdr((yyval.node)); |
3819 ················ | 3820 ················ |
3820 // inl.c's inlnode in on a dotmeth node expects to find the inli
neable body as | 3821 // inl.c's inlnode in on a dotmeth node expects to find the inli
neable body as |
3821 // (dotmeth's type)->nname->inl, and dotmeth's type has been pul
led | 3822 // (dotmeth's type)->nname->inl, and dotmeth's type has been pul
led |
3822 // out by typecheck's lookdot as this $$->ttype. So by providin
g | 3823 // out by typecheck's lookdot as this $$->ttype. So by providin
g |
3823 // this back link here we avoid special casing there. | 3824 // this back link here we avoid special casing there. |
3824 (yyval.node)->type->nname = (yyval.node); | 3825 (yyval.node)->type->nname = (yyval.node); |
3825 } | 3826 } |
3826 break; | 3827 break; |
3827 | 3828 |
3828 case 205: | 3829 case 205: |
3829 #line 1367 "go.y" | 3830 #line 1368 "go.y" |
3830 { | 3831 { |
3831 (yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list),
1); | 3832 (yyvsp[(3) - (5)].list) = checkarglist((yyvsp[(3) - (5)].list),
1); |
3832 (yyval.node) = nod(OTFUNC, N, N); | 3833 (yyval.node) = nod(OTFUNC, N, N); |
3833 (yyval.node)->list = (yyvsp[(3) - (5)].list); | 3834 (yyval.node)->list = (yyvsp[(3) - (5)].list); |
3834 (yyval.node)->rlist = (yyvsp[(5) - (5)].list); | 3835 (yyval.node)->rlist = (yyvsp[(5) - (5)].list); |
3835 } | 3836 } |
3836 break; | 3837 break; |
3837 | 3838 |
3838 case 206: | 3839 case 206: |
3839 #line 1375 "go.y" | 3840 #line 1376 "go.y" |
3840 { | 3841 { |
3841 (yyval.list) = nil; | 3842 (yyval.list) = nil; |
3842 } | 3843 } |
3843 break; | 3844 break; |
3844 | 3845 |
3845 case 207: | 3846 case 207: |
3846 #line 1379 "go.y" | 3847 #line 1380 "go.y" |
3847 { | 3848 { |
3848 (yyval.list) = (yyvsp[(2) - (3)].list); | 3849 (yyval.list) = (yyvsp[(2) - (3)].list); |
3849 if((yyval.list) == nil) | 3850 if((yyval.list) == nil) |
3850 (yyval.list) = list1(nod(OEMPTY, N, N)); | 3851 (yyval.list) = list1(nod(OEMPTY, N, N)); |
3851 } | 3852 } |
3852 break; | 3853 break; |
3853 | 3854 |
3854 case 208: | 3855 case 208: |
3855 #line 1387 "go.y" | 3856 #line 1388 "go.y" |
3856 { | 3857 { |
3857 (yyval.list) = nil; | 3858 (yyval.list) = nil; |
3858 } | 3859 } |
3859 break; | 3860 break; |
3860 | 3861 |
3861 case 209: | 3862 case 209: |
3862 #line 1391 "go.y" | 3863 #line 1392 "go.y" |
3863 { | 3864 { |
3864 (yyval.list) = list1(nod(ODCLFIELD, N, (yyvsp[(1) - (1)].node)))
; | 3865 (yyval.list) = list1(nod(ODCLFIELD, N, (yyvsp[(1) - (1)].node)))
; |
3865 } | 3866 } |
3866 break; | 3867 break; |
3867 | 3868 |
3868 case 210: | 3869 case 210: |
3869 #line 1395 "go.y" | 3870 #line 1396 "go.y" |
3870 { | 3871 { |
3871 (yyvsp[(2) - (3)].list) = checkarglist((yyvsp[(2) - (3)].list),
0); | 3872 (yyvsp[(2) - (3)].list) = checkarglist((yyvsp[(2) - (3)].list),
0); |
3872 (yyval.list) = (yyvsp[(2) - (3)].list); | 3873 (yyval.list) = (yyvsp[(2) - (3)].list); |
3873 } | 3874 } |
3874 break; | 3875 break; |
3875 | 3876 |
3876 case 211: | 3877 case 211: |
3877 #line 1402 "go.y" | 3878 #line 1403 "go.y" |
3878 { | 3879 { |
3879 closurehdr((yyvsp[(1) - (1)].node)); | 3880 closurehdr((yyvsp[(1) - (1)].node)); |
3880 } | 3881 } |
3881 break; | 3882 break; |
3882 | 3883 |
3883 case 212: | 3884 case 212: |
3884 #line 1408 "go.y" | 3885 #line 1409 "go.y" |
3885 { | 3886 { |
3886 (yyval.node) = closurebody((yyvsp[(3) - (4)].list)); | 3887 (yyval.node) = closurebody((yyvsp[(3) - (4)].list)); |
3887 fixlbrace((yyvsp[(2) - (4)].i)); | 3888 fixlbrace((yyvsp[(2) - (4)].i)); |
3888 } | 3889 } |
3889 break; | 3890 break; |
3890 | 3891 |
3891 case 213: | 3892 case 213: |
3892 #line 1413 "go.y" | 3893 #line 1414 "go.y" |
3893 { | 3894 { |
3894 (yyval.node) = closurebody(nil); | 3895 (yyval.node) = closurebody(nil); |
3895 } | 3896 } |
3896 break; | 3897 break; |
3897 | 3898 |
3898 case 214: | 3899 case 214: |
3899 #line 1424 "go.y" | 3900 #line 1425 "go.y" |
3900 { | 3901 { |
3901 (yyval.list) = nil; | 3902 (yyval.list) = nil; |
3902 } | 3903 } |
3903 break; | 3904 break; |
3904 | 3905 |
3905 case 215: | 3906 case 215: |
3906 #line 1428 "go.y" | 3907 #line 1429 "go.y" |
3907 { | 3908 { |
3908 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(2) - (3)]
.list)); | 3909 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(2) - (3)]
.list)); |
3909 if(nsyntaxerrors == 0) | 3910 if(nsyntaxerrors == 0) |
3910 testdclstack(); | 3911 testdclstack(); |
3911 nointerface = 0; | 3912 nointerface = 0; |
3912 } | 3913 } |
3913 break; | 3914 break; |
3914 | 3915 |
3915 case 217: | 3916 case 217: |
3916 #line 1438 "go.y" | 3917 #line 1439 "go.y" |
3917 { | 3918 { |
3918 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)]
.list)); | 3919 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)]
.list)); |
3919 } | 3920 } |
3920 break; | 3921 break; |
3921 | 3922 |
3922 case 219: | 3923 case 219: |
3923 #line 1445 "go.y" | 3924 #line 1446 "go.y" |
3924 { | 3925 { |
3925 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)]
.list)); | 3926 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)]
.list)); |
3926 } | 3927 } |
3927 break; | 3928 break; |
3928 | 3929 |
3929 case 220: | 3930 case 220: |
3930 #line 1451 "go.y" | 3931 #line 1452 "go.y" |
3931 { | 3932 { |
3932 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 3933 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
3933 } | 3934 } |
3934 break; | 3935 break; |
3935 | 3936 |
3936 case 221: | 3937 case 221: |
3937 #line 1455 "go.y" | 3938 #line 1456 "go.y" |
3938 { | 3939 { |
3939 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 3940 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
3940 } | 3941 } |
3941 break; | 3942 break; |
3942 | 3943 |
3943 case 223: | 3944 case 223: |
3944 #line 1462 "go.y" | 3945 #line 1463 "go.y" |
3945 { | 3946 { |
3946 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)]
.list)); | 3947 (yyval.list) = concat((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)]
.list)); |
3947 } | 3948 } |
3948 break; | 3949 break; |
3949 | 3950 |
3950 case 224: | 3951 case 224: |
3951 #line 1468 "go.y" | 3952 #line 1469 "go.y" |
3952 { | 3953 { |
3953 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 3954 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
3954 } | 3955 } |
3955 break; | 3956 break; |
3956 | 3957 |
3957 case 225: | 3958 case 225: |
3958 #line 1472 "go.y" | 3959 #line 1473 "go.y" |
3959 { | 3960 { |
3960 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 3961 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
3961 } | 3962 } |
3962 break; | 3963 break; |
3963 | 3964 |
3964 case 226: | 3965 case 226: |
3965 #line 1478 "go.y" | 3966 #line 1479 "go.y" |
3966 { | 3967 { |
3967 NodeList *l; | 3968 NodeList *l; |
3968 | 3969 |
3969 Node *n; | 3970 Node *n; |
3970 l = (yyvsp[(1) - (3)].list); | 3971 l = (yyvsp[(1) - (3)].list); |
3971 if(l != nil && l->next == nil && l->n == nil) { | 3972 if(l != nil && l->next == nil && l->n == nil) { |
3972 // ? symbol, during import | 3973 // ? symbol, during import |
3973 n = (yyvsp[(2) - (3)].node); | 3974 n = (yyvsp[(2) - (3)].node); |
3974 if(n->op == OIND) | 3975 if(n->op == OIND) |
3975 n = n->left; | 3976 n = n->left; |
3976 n = embedded(n->sym); | 3977 n = embedded(n->sym); |
3977 n->right = (yyvsp[(2) - (3)].node); | 3978 n->right = (yyvsp[(2) - (3)].node); |
3978 n->val = (yyvsp[(3) - (3)].val); | 3979 n->val = (yyvsp[(3) - (3)].val); |
3979 (yyval.list) = list1(n); | 3980 (yyval.list) = list1(n); |
3980 break; | 3981 break; |
3981 } | 3982 } |
3982 | 3983 |
3983 for(l=(yyvsp[(1) - (3)].list); l; l=l->next) { | 3984 for(l=(yyvsp[(1) - (3)].list); l; l=l->next) { |
3984 l->n = nod(ODCLFIELD, l->n, (yyvsp[(2) - (3)].node)); | 3985 l->n = nod(ODCLFIELD, l->n, (yyvsp[(2) - (3)].node)); |
3985 l->n->val = (yyvsp[(3) - (3)].val); | 3986 l->n->val = (yyvsp[(3) - (3)].val); |
3986 } | 3987 } |
3987 } | 3988 } |
3988 break; | 3989 break; |
3989 | 3990 |
3990 case 227: | 3991 case 227: |
3991 #line 1501 "go.y" | 3992 #line 1502 "go.y" |
3992 { | 3993 { |
3993 (yyvsp[(1) - (2)].node)->val = (yyvsp[(2) - (2)].val); | 3994 (yyvsp[(1) - (2)].node)->val = (yyvsp[(2) - (2)].val); |
3994 (yyval.list) = list1((yyvsp[(1) - (2)].node)); | 3995 (yyval.list) = list1((yyvsp[(1) - (2)].node)); |
3995 } | 3996 } |
3996 break; | 3997 break; |
3997 | 3998 |
3998 case 228: | 3999 case 228: |
3999 #line 1506 "go.y" | 4000 #line 1507 "go.y" |
4000 { | 4001 { |
4001 (yyvsp[(2) - (4)].node)->val = (yyvsp[(4) - (4)].val); | 4002 (yyvsp[(2) - (4)].node)->val = (yyvsp[(4) - (4)].val); |
4002 (yyval.list) = list1((yyvsp[(2) - (4)].node)); | 4003 (yyval.list) = list1((yyvsp[(2) - (4)].node)); |
4003 yyerror("cannot parenthesize embedded type"); | 4004 yyerror("cannot parenthesize embedded type"); |
4004 } | 4005 } |
4005 break; | 4006 break; |
4006 | 4007 |
4007 case 229: | 4008 case 229: |
4008 #line 1512 "go.y" | 4009 #line 1513 "go.y" |
4009 { | 4010 { |
4010 (yyvsp[(2) - (3)].node)->right = nod(OIND, (yyvsp[(2) - (3)].nod
e)->right, N); | 4011 (yyvsp[(2) - (3)].node)->right = nod(OIND, (yyvsp[(2) - (3)].nod
e)->right, N); |
4011 (yyvsp[(2) - (3)].node)->val = (yyvsp[(3) - (3)].val); | 4012 (yyvsp[(2) - (3)].node)->val = (yyvsp[(3) - (3)].val); |
4012 (yyval.list) = list1((yyvsp[(2) - (3)].node)); | 4013 (yyval.list) = list1((yyvsp[(2) - (3)].node)); |
4013 } | 4014 } |
4014 break; | 4015 break; |
4015 | 4016 |
4016 case 230: | 4017 case 230: |
4017 #line 1518 "go.y" | 4018 #line 1519 "go.y" |
4018 { | 4019 { |
4019 (yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].nod
e)->right, N); | 4020 (yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].nod
e)->right, N); |
4020 (yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val); | 4021 (yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val); |
4021 (yyval.list) = list1((yyvsp[(3) - (5)].node)); | 4022 (yyval.list) = list1((yyvsp[(3) - (5)].node)); |
4022 yyerror("cannot parenthesize embedded type"); | 4023 yyerror("cannot parenthesize embedded type"); |
4023 } | 4024 } |
4024 break; | 4025 break; |
4025 | 4026 |
4026 case 231: | 4027 case 231: |
4027 #line 1525 "go.y" | 4028 #line 1526 "go.y" |
4028 { | 4029 { |
4029 (yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].nod
e)->right, N); | 4030 (yyvsp[(3) - (5)].node)->right = nod(OIND, (yyvsp[(3) - (5)].nod
e)->right, N); |
4030 (yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val); | 4031 (yyvsp[(3) - (5)].node)->val = (yyvsp[(5) - (5)].val); |
4031 (yyval.list) = list1((yyvsp[(3) - (5)].node)); | 4032 (yyval.list) = list1((yyvsp[(3) - (5)].node)); |
4032 yyerror("cannot parenthesize embedded type"); | 4033 yyerror("cannot parenthesize embedded type"); |
4033 } | 4034 } |
4034 break; | 4035 break; |
4035 | 4036 |
4036 case 232: | 4037 case 232: |
4037 #line 1534 "go.y" | 4038 #line 1535 "go.y" |
4038 { | 4039 { |
4039 Node *n; | 4040 Node *n; |
4040 | 4041 |
4041 (yyval.sym) = (yyvsp[(1) - (1)].sym); | 4042 (yyval.sym) = (yyvsp[(1) - (1)].sym); |
4042 n = oldname((yyvsp[(1) - (1)].sym)); | 4043 n = oldname((yyvsp[(1) - (1)].sym)); |
4043 if(n->pack != N) | 4044 if(n->pack != N) |
4044 n->pack->used = 1; | 4045 n->pack->used = 1; |
4045 } | 4046 } |
4046 break; | 4047 break; |
4047 | 4048 |
4048 case 233: | 4049 case 233: |
4049 #line 1543 "go.y" | 4050 #line 1544 "go.y" |
4050 { | 4051 { |
4051 Pkg *pkg; | 4052 Pkg *pkg; |
4052 | 4053 |
4053 if((yyvsp[(1) - (3)].sym)->def == N || (yyvsp[(1) - (3)].sym)->d
ef->op != OPACK) { | 4054 if((yyvsp[(1) - (3)].sym)->def == N || (yyvsp[(1) - (3)].sym)->d
ef->op != OPACK) { |
4054 yyerror("%S is not a package", (yyvsp[(1) - (3)].sym)); | 4055 yyerror("%S is not a package", (yyvsp[(1) - (3)].sym)); |
4055 pkg = localpkg; | 4056 pkg = localpkg; |
4056 } else { | 4057 } else { |
4057 (yyvsp[(1) - (3)].sym)->def->used = 1; | 4058 (yyvsp[(1) - (3)].sym)->def->used = 1; |
4058 pkg = (yyvsp[(1) - (3)].sym)->def->pkg; | 4059 pkg = (yyvsp[(1) - (3)].sym)->def->pkg; |
4059 } | 4060 } |
4060 (yyval.sym) = restrictlookup((yyvsp[(3) - (3)].sym)->name, pkg); | 4061 (yyval.sym) = restrictlookup((yyvsp[(3) - (3)].sym)->name, pkg); |
4061 } | 4062 } |
4062 break; | 4063 break; |
4063 | 4064 |
4064 case 234: | 4065 case 234: |
4065 #line 1558 "go.y" | 4066 #line 1559 "go.y" |
4066 { | 4067 { |
4067 (yyval.node) = embedded((yyvsp[(1) - (1)].sym)); | 4068 (yyval.node) = embedded((yyvsp[(1) - (1)].sym)); |
4068 } | 4069 } |
4069 break; | 4070 break; |
4070 | 4071 |
4071 case 235: | 4072 case 235: |
4072 #line 1564 "go.y" | 4073 #line 1565 "go.y" |
4073 { | 4074 { |
4074 (yyval.node) = nod(ODCLFIELD, (yyvsp[(1) - (2)].node), (yyvsp[(2
) - (2)].node)); | 4075 (yyval.node) = nod(ODCLFIELD, (yyvsp[(1) - (2)].node), (yyvsp[(2
) - (2)].node)); |
4075 ifacedcl((yyval.node)); | 4076 ifacedcl((yyval.node)); |
4076 } | 4077 } |
4077 break; | 4078 break; |
4078 | 4079 |
4079 case 236: | 4080 case 236: |
4080 #line 1569 "go.y" | 4081 #line 1570 "go.y" |
4081 { | 4082 { |
4082 (yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(1) - (1)].sym))
); | 4083 (yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(1) - (1)].sym))
); |
4083 } | 4084 } |
4084 break; | 4085 break; |
4085 | 4086 |
4086 case 237: | 4087 case 237: |
4087 #line 1573 "go.y" | 4088 #line 1574 "go.y" |
4088 { | 4089 { |
4089 (yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(2) - (3)].sym))
); | 4090 (yyval.node) = nod(ODCLFIELD, N, oldname((yyvsp[(2) - (3)].sym))
); |
4090 yyerror("cannot parenthesize embedded type"); | 4091 yyerror("cannot parenthesize embedded type"); |
4091 } | 4092 } |
4092 break; | 4093 break; |
4093 | 4094 |
4094 case 238: | 4095 case 238: |
4095 #line 1580 "go.y" | 4096 #line 1581 "go.y" |
4096 { | 4097 { |
4097 // without func keyword | 4098 // without func keyword |
4098 (yyvsp[(2) - (4)].list) = checkarglist((yyvsp[(2) - (4)].list),
1); | 4099 (yyvsp[(2) - (4)].list) = checkarglist((yyvsp[(2) - (4)].list),
1); |
4099 (yyval.node) = nod(OTFUNC, fakethis(), N); | 4100 (yyval.node) = nod(OTFUNC, fakethis(), N); |
4100 (yyval.node)->list = (yyvsp[(2) - (4)].list); | 4101 (yyval.node)->list = (yyvsp[(2) - (4)].list); |
4101 (yyval.node)->rlist = (yyvsp[(4) - (4)].list); | 4102 (yyval.node)->rlist = (yyvsp[(4) - (4)].list); |
4102 } | 4103 } |
4103 break; | 4104 break; |
4104 | 4105 |
4105 case 240: | 4106 case 240: |
4106 #line 1594 "go.y" | 4107 #line 1595 "go.y" |
4107 { | 4108 { |
4108 (yyval.node) = nod(ONONAME, N, N); | 4109 (yyval.node) = nod(ONONAME, N, N); |
4109 (yyval.node)->sym = (yyvsp[(1) - (2)].sym); | 4110 (yyval.node)->sym = (yyvsp[(1) - (2)].sym); |
4110 (yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node)); | 4111 (yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node)); |
4111 } | 4112 } |
4112 break; | 4113 break; |
4113 | 4114 |
4114 case 241: | 4115 case 241: |
4115 #line 1600 "go.y" | 4116 #line 1601 "go.y" |
4116 { | 4117 { |
4117 (yyval.node) = nod(ONONAME, N, N); | 4118 (yyval.node) = nod(ONONAME, N, N); |
4118 (yyval.node)->sym = (yyvsp[(1) - (2)].sym); | 4119 (yyval.node)->sym = (yyvsp[(1) - (2)].sym); |
4119 (yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node)); | 4120 (yyval.node) = nod(OKEY, (yyval.node), (yyvsp[(2) - (2)].node)); |
4120 } | 4121 } |
4121 break; | 4122 break; |
4122 | 4123 |
4123 case 243: | 4124 case 243: |
4124 #line 1609 "go.y" | 4125 #line 1610 "go.y" |
4125 { | 4126 { |
4126 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4127 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4127 } | 4128 } |
4128 break; | 4129 break; |
4129 | 4130 |
4130 case 244: | 4131 case 244: |
4131 #line 1613 "go.y" | 4132 #line 1614 "go.y" |
4132 { | 4133 { |
4133 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4134 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4134 } | 4135 } |
4135 break; | 4136 break; |
4136 | 4137 |
4137 case 245: | 4138 case 245: |
4138 #line 1618 "go.y" | 4139 #line 1619 "go.y" |
4139 { | 4140 { |
4140 (yyval.list) = nil; | 4141 (yyval.list) = nil; |
4141 } | 4142 } |
4142 break; | 4143 break; |
4143 | 4144 |
4144 case 246: | 4145 case 246: |
4145 #line 1622 "go.y" | 4146 #line 1623 "go.y" |
4146 { | 4147 { |
4147 (yyval.list) = (yyvsp[(1) - (2)].list); | 4148 (yyval.list) = (yyvsp[(1) - (2)].list); |
4148 } | 4149 } |
4149 break; | 4150 break; |
4150 | 4151 |
4151 case 247: | 4152 case 247: |
4152 #line 1630 "go.y" | 4153 #line 1631 "go.y" |
4153 { | 4154 { |
4154 (yyval.node) = N; | 4155 (yyval.node) = N; |
4155 } | 4156 } |
4156 break; | 4157 break; |
4157 | 4158 |
4158 case 249: | 4159 case 249: |
4159 #line 1635 "go.y" | 4160 #line 1636 "go.y" |
4160 { | 4161 { |
4161 (yyval.node) = liststmt((yyvsp[(1) - (1)].list)); | 4162 (yyval.node) = liststmt((yyvsp[(1) - (1)].list)); |
4162 } | 4163 } |
4163 break; | 4164 break; |
4164 | 4165 |
4165 case 251: | 4166 case 251: |
4166 #line 1640 "go.y" | 4167 #line 1641 "go.y" |
4167 { | 4168 { |
4168 (yyval.node) = N; | 4169 (yyval.node) = N; |
4169 } | 4170 } |
4170 break; | 4171 break; |
4171 | 4172 |
4172 case 257: | 4173 case 257: |
4173 #line 1651 "go.y" | 4174 #line 1652 "go.y" |
4174 { | 4175 { |
4175 (yyvsp[(1) - (2)].node) = nod(OLABEL, (yyvsp[(1) - (2)].node), N
); | 4176 (yyvsp[(1) - (2)].node) = nod(OLABEL, (yyvsp[(1) - (2)].node), N
); |
4176 (yyvsp[(1) - (2)].node)->sym = dclstack; // context, for goto r
estrictions | 4177 (yyvsp[(1) - (2)].node)->sym = dclstack; // context, for goto r
estrictions |
4177 } | 4178 } |
4178 break; | 4179 break; |
4179 | 4180 |
4180 case 258: | 4181 case 258: |
4181 #line 1656 "go.y" | 4182 #line 1657 "go.y" |
4182 { | 4183 { |
4183 NodeList *l; | 4184 NodeList *l; |
4184 | 4185 |
4185 (yyvsp[(1) - (4)].node)->defn = (yyvsp[(4) - (4)].node); | 4186 (yyvsp[(1) - (4)].node)->defn = (yyvsp[(4) - (4)].node); |
4186 l = list1((yyvsp[(1) - (4)].node)); | 4187 l = list1((yyvsp[(1) - (4)].node)); |
4187 if((yyvsp[(4) - (4)].node)) | 4188 if((yyvsp[(4) - (4)].node)) |
4188 l = list(l, (yyvsp[(4) - (4)].node)); | 4189 l = list(l, (yyvsp[(4) - (4)].node)); |
4189 (yyval.node) = liststmt(l); | 4190 (yyval.node) = liststmt(l); |
4190 } | 4191 } |
4191 break; | 4192 break; |
4192 | 4193 |
4193 case 259: | 4194 case 259: |
4194 #line 1666 "go.y" | 4195 #line 1667 "go.y" |
4195 { | 4196 { |
4196 // will be converted to OFALL | 4197 // will be converted to OFALL |
4197 (yyval.node) = nod(OXFALL, N, N); | 4198 (yyval.node) = nod(OXFALL, N, N); |
4198 } | 4199 } |
4199 break; | 4200 break; |
4200 | 4201 |
4201 case 260: | 4202 case 260: |
4202 #line 1671 "go.y" | 4203 #line 1672 "go.y" |
4203 { | 4204 { |
4204 (yyval.node) = nod(OBREAK, (yyvsp[(2) - (2)].node), N); | 4205 (yyval.node) = nod(OBREAK, (yyvsp[(2) - (2)].node), N); |
4205 } | 4206 } |
4206 break; | 4207 break; |
4207 | 4208 |
4208 case 261: | 4209 case 261: |
4209 #line 1675 "go.y" | 4210 #line 1676 "go.y" |
4210 { | 4211 { |
4211 (yyval.node) = nod(OCONTINUE, (yyvsp[(2) - (2)].node), N); | 4212 (yyval.node) = nod(OCONTINUE, (yyvsp[(2) - (2)].node), N); |
4212 } | 4213 } |
4213 break; | 4214 break; |
4214 | 4215 |
4215 case 262: | 4216 case 262: |
4216 #line 1679 "go.y" | 4217 #line 1680 "go.y" |
4217 { | 4218 { |
4218 (yyval.node) = nod(OPROC, (yyvsp[(2) - (2)].node), N); | 4219 (yyval.node) = nod(OPROC, (yyvsp[(2) - (2)].node), N); |
4219 } | 4220 } |
4220 break; | 4221 break; |
4221 | 4222 |
4222 case 263: | 4223 case 263: |
4223 #line 1683 "go.y" | 4224 #line 1684 "go.y" |
4224 { | 4225 { |
4225 (yyval.node) = nod(ODEFER, (yyvsp[(2) - (2)].node), N); | 4226 (yyval.node) = nod(ODEFER, (yyvsp[(2) - (2)].node), N); |
4226 } | 4227 } |
4227 break; | 4228 break; |
4228 | 4229 |
4229 case 264: | 4230 case 264: |
4230 #line 1687 "go.y" | 4231 #line 1688 "go.y" |
4231 { | 4232 { |
4232 (yyval.node) = nod(OGOTO, (yyvsp[(2) - (2)].node), N); | 4233 (yyval.node) = nod(OGOTO, (yyvsp[(2) - (2)].node), N); |
4233 (yyval.node)->sym = dclstack; // context, for goto restrictions | 4234 (yyval.node)->sym = dclstack; // context, for goto restrictions |
4234 } | 4235 } |
4235 break; | 4236 break; |
4236 | 4237 |
4237 case 265: | 4238 case 265: |
4238 #line 1692 "go.y" | 4239 #line 1693 "go.y" |
4239 { | 4240 { |
4240 (yyval.node) = nod(ORETURN, N, N); | 4241 (yyval.node) = nod(ORETURN, N, N); |
4241 (yyval.node)->list = (yyvsp[(2) - (2)].list); | 4242 (yyval.node)->list = (yyvsp[(2) - (2)].list); |
4242 if((yyval.node)->list == nil && curfn != N) { | 4243 if((yyval.node)->list == nil && curfn != N) { |
4243 NodeList *l; | 4244 NodeList *l; |
4244 | 4245 |
4245 for(l=curfn->dcl; l; l=l->next) { | 4246 for(l=curfn->dcl; l; l=l->next) { |
4246 if(l->n->class == PPARAM) | 4247 if(l->n->class == PPARAM) |
4247 continue; | 4248 continue; |
4248 if(l->n->class != PPARAMOUT) | 4249 if(l->n->class != PPARAMOUT) |
4249 break; | 4250 break; |
4250 if(l->n->sym->def != l->n) | 4251 if(l->n->sym->def != l->n) |
4251 yyerror("%s is shadowed during return",
l->n->sym->name); | 4252 yyerror("%s is shadowed during return",
l->n->sym->name); |
4252 } | 4253 } |
4253 } | 4254 } |
4254 } | 4255 } |
4255 break; | 4256 break; |
4256 | 4257 |
4257 case 266: | 4258 case 266: |
4258 #line 1711 "go.y" | 4259 #line 1712 "go.y" |
4259 { | 4260 { |
4260 (yyval.list) = nil; | 4261 (yyval.list) = nil; |
4261 if((yyvsp[(1) - (1)].node) != N) | 4262 if((yyvsp[(1) - (1)].node) != N) |
4262 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4263 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4263 } | 4264 } |
4264 break; | 4265 break; |
4265 | 4266 |
4266 case 267: | 4267 case 267: |
4267 #line 1717 "go.y" | 4268 #line 1718 "go.y" |
4268 { | 4269 { |
4269 (yyval.list) = (yyvsp[(1) - (3)].list); | 4270 (yyval.list) = (yyvsp[(1) - (3)].list); |
4270 if((yyvsp[(3) - (3)].node) != N) | 4271 if((yyvsp[(3) - (3)].node) != N) |
4271 (yyval.list) = list((yyval.list), (yyvsp[(3) - (3)].node
)); | 4272 (yyval.list) = list((yyval.list), (yyvsp[(3) - (3)].node
)); |
4272 } | 4273 } |
4273 break; | 4274 break; |
4274 | 4275 |
4275 case 268: | 4276 case 268: |
4276 #line 1725 "go.y" | 4277 #line 1726 "go.y" |
4277 { | 4278 { |
4278 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4279 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4279 } | 4280 } |
4280 break; | 4281 break; |
4281 | 4282 |
4282 case 269: | 4283 case 269: |
4283 #line 1729 "go.y" | 4284 #line 1730 "go.y" |
4284 { | 4285 { |
4285 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4286 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4286 } | 4287 } |
4287 break; | 4288 break; |
4288 | 4289 |
4289 case 270: | 4290 case 270: |
4290 #line 1735 "go.y" | 4291 #line 1736 "go.y" |
4291 { | 4292 { |
4292 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4293 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4293 } | 4294 } |
4294 break; | 4295 break; |
4295 | 4296 |
4296 case 271: | 4297 case 271: |
4297 #line 1739 "go.y" | 4298 #line 1740 "go.y" |
4298 { | 4299 { |
4299 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4300 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4300 } | 4301 } |
4301 break; | 4302 break; |
4302 | 4303 |
4303 case 272: | 4304 case 272: |
4304 #line 1745 "go.y" | 4305 #line 1746 "go.y" |
4305 { | 4306 { |
4306 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4307 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4307 } | 4308 } |
4308 break; | 4309 break; |
4309 | 4310 |
4310 case 273: | 4311 case 273: |
4311 #line 1749 "go.y" | 4312 #line 1750 "go.y" |
4312 { | 4313 { |
4313 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4314 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4314 } | 4315 } |
4315 break; | 4316 break; |
4316 | 4317 |
4317 case 274: | 4318 case 274: |
4318 #line 1755 "go.y" | 4319 #line 1756 "go.y" |
4319 { | 4320 { |
4320 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4321 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4321 } | 4322 } |
4322 break; | 4323 break; |
4323 | 4324 |
4324 case 275: | 4325 case 275: |
4325 #line 1759 "go.y" | 4326 #line 1760 "go.y" |
4326 { | 4327 { |
4327 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4328 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4328 } | 4329 } |
4329 break; | 4330 break; |
4330 | 4331 |
4331 case 276: | 4332 case 276: |
4332 #line 1768 "go.y" | 4333 #line 1769 "go.y" |
4333 { | 4334 { |
4334 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4335 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4335 } | 4336 } |
4336 break; | 4337 break; |
4337 | 4338 |
4338 case 277: | 4339 case 277: |
4339 #line 1772 "go.y" | 4340 #line 1773 "go.y" |
4340 { | 4341 { |
4341 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4342 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4342 } | 4343 } |
4343 break; | 4344 break; |
4344 | 4345 |
4345 case 278: | 4346 case 278: |
4346 #line 1776 "go.y" | 4347 #line 1777 "go.y" |
4347 { | 4348 { |
4348 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4349 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4349 } | 4350 } |
4350 break; | 4351 break; |
4351 | 4352 |
4352 case 279: | 4353 case 279: |
4353 #line 1780 "go.y" | 4354 #line 1781 "go.y" |
4354 { | 4355 { |
4355 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4356 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4356 } | 4357 } |
4357 break; | 4358 break; |
4358 | 4359 |
4359 case 280: | 4360 case 280: |
4360 #line 1785 "go.y" | 4361 #line 1786 "go.y" |
4361 { | 4362 { |
4362 (yyval.list) = nil; | 4363 (yyval.list) = nil; |
4363 } | 4364 } |
4364 break; | 4365 break; |
4365 | 4366 |
4366 case 281: | 4367 case 281: |
4367 #line 1789 "go.y" | 4368 #line 1790 "go.y" |
4368 { | 4369 { |
4369 (yyval.list) = (yyvsp[(1) - (2)].list); | 4370 (yyval.list) = (yyvsp[(1) - (2)].list); |
4370 } | 4371 } |
4371 break; | 4372 break; |
4372 | 4373 |
4373 case 286: | 4374 case 286: |
4374 #line 1803 "go.y" | 4375 #line 1804 "go.y" |
4375 { | 4376 { |
4376 (yyval.node) = N; | 4377 (yyval.node) = N; |
4377 } | 4378 } |
4378 break; | 4379 break; |
4379 | 4380 |
4380 case 288: | 4381 case 288: |
4381 #line 1809 "go.y" | 4382 #line 1810 "go.y" |
4382 { | 4383 { |
4383 (yyval.list) = nil; | 4384 (yyval.list) = nil; |
4384 } | 4385 } |
4385 break; | 4386 break; |
4386 | 4387 |
4387 case 290: | 4388 case 290: |
4388 #line 1815 "go.y" | 4389 #line 1816 "go.y" |
4389 { | 4390 { |
4390 (yyval.node) = N; | 4391 (yyval.node) = N; |
4391 } | 4392 } |
4392 break; | 4393 break; |
4393 | 4394 |
4394 case 292: | 4395 case 292: |
4395 #line 1821 "go.y" | 4396 #line 1822 "go.y" |
4396 { | 4397 { |
4397 (yyval.list) = nil; | 4398 (yyval.list) = nil; |
4398 } | 4399 } |
4399 break; | 4400 break; |
4400 | 4401 |
4401 case 294: | 4402 case 294: |
4402 #line 1827 "go.y" | 4403 #line 1828 "go.y" |
4403 { | 4404 { |
4404 (yyval.list) = nil; | 4405 (yyval.list) = nil; |
4405 } | 4406 } |
4406 break; | 4407 break; |
4407 | 4408 |
4408 case 296: | 4409 case 296: |
4409 #line 1833 "go.y" | 4410 #line 1834 "go.y" |
4410 { | 4411 { |
4411 (yyval.list) = nil; | 4412 (yyval.list) = nil; |
4412 } | 4413 } |
4413 break; | 4414 break; |
4414 | 4415 |
4415 case 298: | 4416 case 298: |
4416 #line 1839 "go.y" | 4417 #line 1840 "go.y" |
4417 { | 4418 { |
4418 (yyval.val).ctype = CTxxx; | 4419 (yyval.val).ctype = CTxxx; |
4419 } | 4420 } |
4420 break; | 4421 break; |
4421 | 4422 |
4422 case 300: | 4423 case 300: |
4423 #line 1849 "go.y" | 4424 #line 1850 "go.y" |
4424 { | 4425 { |
4425 importimport((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].val).u.sv
al); | 4426 importimport((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].val).u.sv
al); |
4426 } | 4427 } |
4427 break; | 4428 break; |
4428 | 4429 |
4429 case 301: | 4430 case 301: |
4430 #line 1853 "go.y" | 4431 #line 1854 "go.y" |
4431 { | 4432 { |
4432 importvar((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].type)); | 4433 importvar((yyvsp[(2) - (4)].sym), (yyvsp[(3) - (4)].type)); |
4433 } | 4434 } |
4434 break; | 4435 break; |
4435 | 4436 |
4436 case 302: | 4437 case 302: |
4437 #line 1857 "go.y" | 4438 #line 1858 "go.y" |
4438 { | 4439 { |
4439 importconst((yyvsp[(2) - (5)].sym), types[TIDEAL], (yyvsp[(4) -
(5)].node)); | 4440 importconst((yyvsp[(2) - (5)].sym), types[TIDEAL], (yyvsp[(4) -
(5)].node)); |
4440 } | 4441 } |
4441 break; | 4442 break; |
4442 | 4443 |
4443 case 303: | 4444 case 303: |
4444 #line 1861 "go.y" | 4445 #line 1862 "go.y" |
4445 { | 4446 { |
4446 importconst((yyvsp[(2) - (6)].sym), (yyvsp[(3) - (6)].type), (yy
vsp[(5) - (6)].node)); | 4447 importconst((yyvsp[(2) - (6)].sym), (yyvsp[(3) - (6)].type), (yy
vsp[(5) - (6)].node)); |
4447 } | 4448 } |
4448 break; | 4449 break; |
4449 | 4450 |
4450 case 304: | 4451 case 304: |
4451 #line 1865 "go.y" | 4452 #line 1866 "go.y" |
4452 { | 4453 { |
4453 importtype((yyvsp[(2) - (4)].type), (yyvsp[(3) - (4)].type)); | 4454 importtype((yyvsp[(2) - (4)].type), (yyvsp[(3) - (4)].type)); |
4454 } | 4455 } |
4455 break; | 4456 break; |
4456 | 4457 |
4457 case 305: | 4458 case 305: |
4458 #line 1869 "go.y" | 4459 #line 1870 "go.y" |
4459 { | 4460 { |
4460 if((yyvsp[(2) - (4)].node) == N) { | 4461 if((yyvsp[(2) - (4)].node) == N) { |
4461 dclcontext = PEXTERN; // since we skip the funcbody bel
ow | 4462 dclcontext = PEXTERN; // since we skip the funcbody bel
ow |
4462 break; | 4463 break; |
4463 } | 4464 } |
4464 | 4465 |
4465 (yyvsp[(2) - (4)].node)->inl = (yyvsp[(3) - (4)].list); | 4466 (yyvsp[(2) - (4)].node)->inl = (yyvsp[(3) - (4)].list); |
4466 | 4467 |
4467 funcbody((yyvsp[(2) - (4)].node)); | 4468 funcbody((yyvsp[(2) - (4)].node)); |
4468 importlist = list(importlist, (yyvsp[(2) - (4)].node)); | 4469 importlist = list(importlist, (yyvsp[(2) - (4)].node)); |
4469 | 4470 |
4470 if(debug['E']) { | 4471 if(debug['E']) { |
4471 print("import [%Z] func %lN \n", importpkg->path, (yyvsp
[(2) - (4)].node)); | 4472 print("import [%Z] func %lN \n", importpkg->path, (yyvsp
[(2) - (4)].node)); |
4472 if(debug['m'] > 2 && (yyvsp[(2) - (4)].node)->inl) | 4473 if(debug['m'] > 2 && (yyvsp[(2) - (4)].node)->inl) |
4473 print("inl body:%+H\n", (yyvsp[(2) - (4)].node)-
>inl); | 4474 print("inl body:%+H\n", (yyvsp[(2) - (4)].node)-
>inl); |
4474 } | 4475 } |
4475 } | 4476 } |
4476 break; | 4477 break; |
4477 | 4478 |
4478 case 306: | 4479 case 306: |
4479 #line 1889 "go.y" | 4480 #line 1890 "go.y" |
4480 { | 4481 { |
4481 (yyval.sym) = (yyvsp[(1) - (1)].sym); | 4482 (yyval.sym) = (yyvsp[(1) - (1)].sym); |
4482 structpkg = (yyval.sym)->pkg; | 4483 structpkg = (yyval.sym)->pkg; |
4483 } | 4484 } |
4484 break; | 4485 break; |
4485 | 4486 |
4486 case 307: | 4487 case 307: |
4487 #line 1896 "go.y" | 4488 #line 1897 "go.y" |
4488 { | 4489 { |
4489 (yyval.type) = pkgtype((yyvsp[(1) - (1)].sym)); | 4490 (yyval.type) = pkgtype((yyvsp[(1) - (1)].sym)); |
4490 importsym((yyvsp[(1) - (1)].sym), OTYPE); | 4491 importsym((yyvsp[(1) - (1)].sym), OTYPE); |
4491 } | 4492 } |
4492 break; | 4493 break; |
4493 | 4494 |
4494 case 313: | 4495 case 313: |
4495 #line 1916 "go.y" | 4496 #line 1917 "go.y" |
4496 { | 4497 { |
4497 (yyval.type) = pkgtype((yyvsp[(1) - (1)].sym)); | 4498 (yyval.type) = pkgtype((yyvsp[(1) - (1)].sym)); |
4498 } | 4499 } |
4499 break; | 4500 break; |
4500 | 4501 |
4501 case 314: | 4502 case 314: |
4502 #line 1920 "go.y" | 4503 #line 1921 "go.y" |
4503 { | 4504 { |
4504 // predefined name like uint8 | 4505 // predefined name like uint8 |
4505 (yyvsp[(1) - (1)].sym) = pkglookup((yyvsp[(1) - (1)].sym)->name,
builtinpkg); | 4506 (yyvsp[(1) - (1)].sym) = pkglookup((yyvsp[(1) - (1)].sym)->name,
builtinpkg); |
4506 if((yyvsp[(1) - (1)].sym)->def == N || (yyvsp[(1) - (1)].sym)->d
ef->op != OTYPE) { | 4507 if((yyvsp[(1) - (1)].sym)->def == N || (yyvsp[(1) - (1)].sym)->d
ef->op != OTYPE) { |
4507 yyerror("%s is not a type", (yyvsp[(1) - (1)].sym)->name
); | 4508 yyerror("%s is not a type", (yyvsp[(1) - (1)].sym)->name
); |
4508 (yyval.type) = T; | 4509 (yyval.type) = T; |
4509 } else | 4510 } else |
4510 (yyval.type) = (yyvsp[(1) - (1)].sym)->def->type; | 4511 (yyval.type) = (yyvsp[(1) - (1)].sym)->def->type; |
4511 } | 4512 } |
4512 break; | 4513 break; |
4513 | 4514 |
4514 case 315: | 4515 case 315: |
4515 #line 1930 "go.y" | 4516 #line 1931 "go.y" |
4516 { | 4517 { |
4517 (yyval.type) = aindex(N, (yyvsp[(3) - (3)].type)); | 4518 (yyval.type) = aindex(N, (yyvsp[(3) - (3)].type)); |
4518 } | 4519 } |
4519 break; | 4520 break; |
4520 | 4521 |
4521 case 316: | 4522 case 316: |
4522 #line 1934 "go.y" | 4523 #line 1935 "go.y" |
4523 { | 4524 { |
4524 (yyval.type) = aindex(nodlit((yyvsp[(2) - (4)].val)), (yyvsp[(4)
- (4)].type)); | 4525 (yyval.type) = aindex(nodlit((yyvsp[(2) - (4)].val)), (yyvsp[(4)
- (4)].type)); |
4525 } | 4526 } |
4526 break; | 4527 break; |
4527 | 4528 |
4528 case 317: | 4529 case 317: |
4529 #line 1938 "go.y" | 4530 #line 1939 "go.y" |
4530 { | 4531 { |
4531 (yyval.type) = maptype((yyvsp[(3) - (5)].type), (yyvsp[(5) - (5)
].type)); | 4532 (yyval.type) = maptype((yyvsp[(3) - (5)].type), (yyvsp[(5) - (5)
].type)); |
4532 } | 4533 } |
4533 break; | 4534 break; |
4534 | 4535 |
4535 case 318: | 4536 case 318: |
4536 #line 1942 "go.y" | 4537 #line 1943 "go.y" |
4537 { | 4538 { |
4538 (yyval.type) = tostruct((yyvsp[(3) - (4)].list)); | 4539 (yyval.type) = tostruct((yyvsp[(3) - (4)].list)); |
4539 } | 4540 } |
4540 break; | 4541 break; |
4541 | 4542 |
4542 case 319: | 4543 case 319: |
4543 #line 1946 "go.y" | 4544 #line 1947 "go.y" |
4544 { | 4545 { |
4545 (yyval.type) = tointerface((yyvsp[(3) - (4)].list)); | 4546 (yyval.type) = tointerface((yyvsp[(3) - (4)].list)); |
4546 } | 4547 } |
4547 break; | 4548 break; |
4548 | 4549 |
4549 case 320: | 4550 case 320: |
4550 #line 1950 "go.y" | 4551 #line 1951 "go.y" |
4551 { | 4552 { |
4552 (yyval.type) = ptrto((yyvsp[(2) - (2)].type)); | 4553 (yyval.type) = ptrto((yyvsp[(2) - (2)].type)); |
4553 } | 4554 } |
4554 break; | 4555 break; |
4555 | 4556 |
4556 case 321: | 4557 case 321: |
4557 #line 1954 "go.y" | 4558 #line 1955 "go.y" |
4558 { | 4559 { |
4559 (yyval.type) = typ(TCHAN); | 4560 (yyval.type) = typ(TCHAN); |
4560 (yyval.type)->type = (yyvsp[(2) - (2)].type); | 4561 (yyval.type)->type = (yyvsp[(2) - (2)].type); |
4561 (yyval.type)->chan = Cboth; | 4562 (yyval.type)->chan = Cboth; |
4562 } | 4563 } |
4563 break; | 4564 break; |
4564 | 4565 |
4565 case 322: | 4566 case 322: |
4566 #line 1960 "go.y" | 4567 #line 1961 "go.y" |
4567 { | 4568 { |
4568 (yyval.type) = typ(TCHAN); | 4569 (yyval.type) = typ(TCHAN); |
4569 (yyval.type)->type = (yyvsp[(3) - (4)].type); | 4570 (yyval.type)->type = (yyvsp[(3) - (4)].type); |
4570 (yyval.type)->chan = Cboth; | 4571 (yyval.type)->chan = Cboth; |
4571 } | 4572 } |
4572 break; | 4573 break; |
4573 | 4574 |
4574 case 323: | 4575 case 323: |
4575 #line 1966 "go.y" | 4576 #line 1967 "go.y" |
4576 { | 4577 { |
4577 (yyval.type) = typ(TCHAN); | 4578 (yyval.type) = typ(TCHAN); |
4578 (yyval.type)->type = (yyvsp[(3) - (3)].type); | 4579 (yyval.type)->type = (yyvsp[(3) - (3)].type); |
4579 (yyval.type)->chan = Csend; | 4580 (yyval.type)->chan = Csend; |
4580 } | 4581 } |
4581 break; | 4582 break; |
4582 | 4583 |
4583 case 324: | 4584 case 324: |
4584 #line 1974 "go.y" | 4585 #line 1975 "go.y" |
4585 { | 4586 { |
4586 (yyval.type) = typ(TCHAN); | 4587 (yyval.type) = typ(TCHAN); |
4587 (yyval.type)->type = (yyvsp[(3) - (3)].type); | 4588 (yyval.type)->type = (yyvsp[(3) - (3)].type); |
4588 (yyval.type)->chan = Crecv; | 4589 (yyval.type)->chan = Crecv; |
4589 } | 4590 } |
4590 break; | 4591 break; |
4591 | 4592 |
4592 case 325: | 4593 case 325: |
4593 #line 1982 "go.y" | 4594 #line 1983 "go.y" |
4594 { | 4595 { |
4595 (yyval.type) = functype(nil, (yyvsp[(3) - (5)].list), (yyvsp[(5)
- (5)].list)); | 4596 (yyval.type) = functype(nil, (yyvsp[(3) - (5)].list), (yyvsp[(5)
- (5)].list)); |
4596 } | 4597 } |
4597 break; | 4598 break; |
4598 | 4599 |
4599 case 326: | 4600 case 326: |
4600 #line 1988 "go.y" | 4601 #line 1989 "go.y" |
4601 { | 4602 { |
4602 (yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(2) - (3)].type)
)); | 4603 (yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(2) - (3)].type)
)); |
4603 if((yyvsp[(1) - (3)].sym)) | 4604 if((yyvsp[(1) - (3)].sym)) |
4604 (yyval.node)->left = newname((yyvsp[(1) - (3)].sym)); | 4605 (yyval.node)->left = newname((yyvsp[(1) - (3)].sym)); |
4605 (yyval.node)->val = (yyvsp[(3) - (3)].val); | 4606 (yyval.node)->val = (yyvsp[(3) - (3)].val); |
4606 } | 4607 } |
4607 break; | 4608 break; |
4608 | 4609 |
4609 case 327: | 4610 case 327: |
4610 #line 1995 "go.y" | 4611 #line 1996 "go.y" |
4611 { | 4612 { |
4612 Type *t; | 4613 Type *t; |
4613 ········ | 4614 ········ |
4614 t = typ(TARRAY); | 4615 t = typ(TARRAY); |
4615 t->bound = -1; | 4616 t->bound = -1; |
4616 t->type = (yyvsp[(3) - (4)].type); | 4617 t->type = (yyvsp[(3) - (4)].type); |
4617 | 4618 |
4618 (yyval.node) = nod(ODCLFIELD, N, typenod(t)); | 4619 (yyval.node) = nod(ODCLFIELD, N, typenod(t)); |
4619 if((yyvsp[(1) - (4)].sym)) | 4620 if((yyvsp[(1) - (4)].sym)) |
4620 (yyval.node)->left = newname((yyvsp[(1) - (4)].sym)); | 4621 (yyval.node)->left = newname((yyvsp[(1) - (4)].sym)); |
4621 (yyval.node)->isddd = 1; | 4622 (yyval.node)->isddd = 1; |
4622 (yyval.node)->val = (yyvsp[(4) - (4)].val); | 4623 (yyval.node)->val = (yyvsp[(4) - (4)].val); |
4623 } | 4624 } |
4624 break; | 4625 break; |
4625 | 4626 |
4626 case 328: | 4627 case 328: |
4627 #line 2011 "go.y" | 4628 #line 2012 "go.y" |
4628 { | 4629 { |
4629 Sym *s; | 4630 Sym *s; |
4630 | 4631 |
4631 if((yyvsp[(1) - (3)].sym) != S) { | 4632 if((yyvsp[(1) - (3)].sym) != S) { |
4632 (yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (3)].
sym)), typenod((yyvsp[(2) - (3)].type))); | 4633 (yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (3)].
sym)), typenod((yyvsp[(2) - (3)].type))); |
4633 (yyval.node)->val = (yyvsp[(3) - (3)].val); | 4634 (yyval.node)->val = (yyvsp[(3) - (3)].val); |
4634 } else { | 4635 } else { |
4635 s = (yyvsp[(2) - (3)].type)->sym; | 4636 s = (yyvsp[(2) - (3)].type)->sym; |
4636 if(s == S && isptr[(yyvsp[(2) - (3)].type)->etype]) | 4637 if(s == S && isptr[(yyvsp[(2) - (3)].type)->etype]) |
4637 s = (yyvsp[(2) - (3)].type)->type->sym; | 4638 s = (yyvsp[(2) - (3)].type)->type->sym; |
4638 (yyval.node) = embedded(s); | 4639 (yyval.node) = embedded(s); |
4639 (yyval.node)->right = typenod((yyvsp[(2) - (3)].type)); | 4640 (yyval.node)->right = typenod((yyvsp[(2) - (3)].type)); |
4640 (yyval.node)->val = (yyvsp[(3) - (3)].val); | 4641 (yyval.node)->val = (yyvsp[(3) - (3)].val); |
4641 } | 4642 } |
4642 } | 4643 } |
4643 break; | 4644 break; |
4644 | 4645 |
4645 case 329: | 4646 case 329: |
4646 #line 2029 "go.y" | 4647 #line 2030 "go.y" |
4647 { | 4648 { |
4648 (yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (5)].sym)), t
ypenod(functype(fakethis(), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list)))); | 4649 (yyval.node) = nod(ODCLFIELD, newname((yyvsp[(1) - (5)].sym)), t
ypenod(functype(fakethis(), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list)))); |
4649 } | 4650 } |
4650 break; | 4651 break; |
4651 | 4652 |
4652 case 330: | 4653 case 330: |
4653 #line 2033 "go.y" | 4654 #line 2034 "go.y" |
4654 { | 4655 { |
4655 (yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type)
)); | 4656 (yyval.node) = nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)].type)
)); |
4656 } | 4657 } |
4657 break; | 4658 break; |
4658 | 4659 |
4659 case 331: | 4660 case 331: |
4660 #line 2038 "go.y" | 4661 #line 2039 "go.y" |
4661 { | 4662 { |
4662 (yyval.list) = nil; | 4663 (yyval.list) = nil; |
4663 } | 4664 } |
4664 break; | 4665 break; |
4665 | 4666 |
4666 case 333: | 4667 case 333: |
4667 #line 2045 "go.y" | 4668 #line 2046 "go.y" |
4668 { | 4669 { |
4669 (yyval.list) = (yyvsp[(2) - (3)].list); | 4670 (yyval.list) = (yyvsp[(2) - (3)].list); |
4670 } | 4671 } |
4671 break; | 4672 break; |
4672 | 4673 |
4673 case 334: | 4674 case 334: |
4674 #line 2049 "go.y" | 4675 #line 2050 "go.y" |
4675 { | 4676 { |
4676 (yyval.list) = list1(nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)]
.type)))); | 4677 (yyval.list) = list1(nod(ODCLFIELD, N, typenod((yyvsp[(1) - (1)]
.type)))); |
4677 } | 4678 } |
4678 break; | 4679 break; |
4679 | 4680 |
4680 case 335: | 4681 case 335: |
4681 #line 2059 "go.y" | 4682 #line 2060 "go.y" |
4682 { | 4683 { |
4683 (yyval.node) = nodlit((yyvsp[(1) - (1)].val)); | 4684 (yyval.node) = nodlit((yyvsp[(1) - (1)].val)); |
4684 } | 4685 } |
4685 break; | 4686 break; |
4686 | 4687 |
4687 case 336: | 4688 case 336: |
4688 #line 2063 "go.y" | 4689 #line 2064 "go.y" |
4689 { | 4690 { |
4690 (yyval.node) = nodlit((yyvsp[(2) - (2)].val)); | 4691 (yyval.node) = nodlit((yyvsp[(2) - (2)].val)); |
4691 switch((yyval.node)->val.ctype){ | 4692 switch((yyval.node)->val.ctype){ |
4692 case CTINT: | 4693 case CTINT: |
4693 case CTRUNE: | 4694 case CTRUNE: |
4694 mpnegfix((yyval.node)->val.u.xval); | 4695 mpnegfix((yyval.node)->val.u.xval); |
4695 break; | 4696 break; |
4696 case CTFLT: | 4697 case CTFLT: |
4697 mpnegflt((yyval.node)->val.u.fval); | 4698 mpnegflt((yyval.node)->val.u.fval); |
4698 break; | 4699 break; |
4699 default: | 4700 default: |
4700 yyerror("bad negated constant"); | 4701 yyerror("bad negated constant"); |
4701 } | 4702 } |
4702 } | 4703 } |
4703 break; | 4704 break; |
4704 | 4705 |
4705 case 337: | 4706 case 337: |
4706 #line 2078 "go.y" | 4707 #line 2079 "go.y" |
4707 { | 4708 { |
4708 (yyval.node) = oldname(pkglookup((yyvsp[(1) - (1)].sym)->name, b
uiltinpkg)); | 4709 (yyval.node) = oldname(pkglookup((yyvsp[(1) - (1)].sym)->name, b
uiltinpkg)); |
4709 if((yyval.node)->op != OLITERAL) | 4710 if((yyval.node)->op != OLITERAL) |
4710 yyerror("bad constant %S", (yyval.node)->sym); | 4711 yyerror("bad constant %S", (yyval.node)->sym); |
4711 } | 4712 } |
4712 break; | 4713 break; |
4713 | 4714 |
4714 case 339: | 4715 case 339: |
4715 #line 2087 "go.y" | 4716 #line 2088 "go.y" |
4716 { | 4717 { |
4717 if((yyvsp[(2) - (5)].node)->val.ctype == CTRUNE && (yyvsp[(4) -
(5)].node)->val.ctype == CTINT) { | 4718 if((yyvsp[(2) - (5)].node)->val.ctype == CTRUNE && (yyvsp[(4) -
(5)].node)->val.ctype == CTINT) { |
4718 (yyval.node) = (yyvsp[(2) - (5)].node); | 4719 (yyval.node) = (yyvsp[(2) - (5)].node); |
4719 mpaddfixfix((yyvsp[(2) - (5)].node)->val.u.xval, (yyvsp[
(4) - (5)].node)->val.u.xval, 0); | 4720 mpaddfixfix((yyvsp[(2) - (5)].node)->val.u.xval, (yyvsp[
(4) - (5)].node)->val.u.xval, 0); |
4720 break; | 4721 break; |
4721 } | 4722 } |
4722 (yyvsp[(4) - (5)].node)->val.u.cval->real = (yyvsp[(4) - (5)].no
de)->val.u.cval->imag; | 4723 (yyvsp[(4) - (5)].node)->val.u.cval->real = (yyvsp[(4) - (5)].no
de)->val.u.cval->imag; |
4723 mpmovecflt(&(yyvsp[(4) - (5)].node)->val.u.cval->imag, 0.0); | 4724 mpmovecflt(&(yyvsp[(4) - (5)].node)->val.u.cval->imag, 0.0); |
4724 (yyval.node) = nodcplxlit((yyvsp[(2) - (5)].node)->val, (yyvsp[(
4) - (5)].node)->val); | 4725 (yyval.node) = nodcplxlit((yyvsp[(2) - (5)].node)->val, (yyvsp[(
4) - (5)].node)->val); |
4725 } | 4726 } |
4726 break; | 4727 break; |
4727 | 4728 |
4728 case 342: | 4729 case 342: |
4729 #line 2103 "go.y" | 4730 #line 2104 "go.y" |
4730 { | 4731 { |
4731 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4732 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4732 } | 4733 } |
4733 break; | 4734 break; |
4734 | 4735 |
4735 case 343: | 4736 case 343: |
4736 #line 2107 "go.y" | 4737 #line 2108 "go.y" |
4737 { | 4738 { |
4738 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4739 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4739 } | 4740 } |
4740 break; | 4741 break; |
4741 | 4742 |
4742 case 344: | 4743 case 344: |
4743 #line 2113 "go.y" | 4744 #line 2114 "go.y" |
4744 { | 4745 { |
4745 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4746 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4746 } | 4747 } |
4747 break; | 4748 break; |
4748 | 4749 |
4749 case 345: | 4750 case 345: |
4750 #line 2117 "go.y" | 4751 #line 2118 "go.y" |
4751 { | 4752 { |
4752 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4753 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4753 } | 4754 } |
4754 break; | 4755 break; |
4755 | 4756 |
4756 case 346: | 4757 case 346: |
4757 #line 2123 "go.y" | 4758 #line 2124 "go.y" |
4758 { | 4759 { |
4759 (yyval.list) = list1((yyvsp[(1) - (1)].node)); | 4760 (yyval.list) = list1((yyvsp[(1) - (1)].node)); |
4760 } | 4761 } |
4761 break; | 4762 break; |
4762 | 4763 |
4763 case 347: | 4764 case 347: |
4764 #line 2127 "go.y" | 4765 #line 2128 "go.y" |
4765 { | 4766 { |
4766 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); | 4767 (yyval.list) = list((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].n
ode)); |
4767 } | 4768 } |
4768 break; | 4769 break; |
4769 | 4770 |
4770 | 4771 |
4771 /* Line 1267 of yacc.c. */ | 4772 /* Line 1267 of yacc.c. */ |
4772 #line 4771 "y.tab.c" | 4773 #line 4772 "y.tab.c" |
4773 default: break; | 4774 default: break; |
4774 } | 4775 } |
4775 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); | 4776 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); |
4776 | 4777 |
4777 YYPOPSTACK (yylen); | 4778 YYPOPSTACK (yylen); |
4778 yylen = 0; | 4779 yylen = 0; |
4779 YY_STACK_PRINT (yyss, yyssp); | 4780 YY_STACK_PRINT (yyss, yyssp); |
4780 | 4781 |
4781 *++yyvsp = yyval; | 4782 *++yyvsp = yyval; |
4782 | 4783 |
(...skipping 193 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4976 #endif | 4977 #endif |
4977 #if YYERROR_VERBOSE | 4978 #if YYERROR_VERBOSE |
4978 if (yymsg != yymsgbuf) | 4979 if (yymsg != yymsgbuf) |
4979 YYSTACK_FREE (yymsg); | 4980 YYSTACK_FREE (yymsg); |
4980 #endif | 4981 #endif |
4981 /* Make sure YYID is used. */ | 4982 /* Make sure YYID is used. */ |
4982 return YYID (yyresult); | 4983 return YYID (yyresult); |
4983 } | 4984 } |
4984 | 4985 |
4985 | 4986 |
4986 #line 2131 "go.y" | 4987 #line 2132 "go.y" |
4987 | 4988 |
4988 | 4989 |
4989 static void | 4990 static void |
4990 fixlbrace(int lbr) | 4991 fixlbrace(int lbr) |
4991 { | 4992 { |
4992 // If the opening brace was an LBODY, | 4993 // If the opening brace was an LBODY, |
4993 // set up for another one now that we're done. | 4994 // set up for another one now that we're done. |
4994 // See comment in lex.c about loophack. | 4995 // See comment in lex.c about loophack. |
4995 if(lbr == LBODY) | 4996 if(lbr == LBODY) |
4996 loophack = 1; | 4997 loophack = 1; |
4997 } | 4998 } |
4998 | 4999 |
4999 | 5000 |
LEFT | RIGHT |