From 628caae61b0197b26c57682e2ebd4bcf85c4525b Mon Sep 17 00:00:00 2001 From: benfry Date: Wed, 22 Nov 2006 22:47:52 +0000 Subject: [PATCH] trying new preproc and new antlr --- app/preproc/CommonTokenTypes.txt.java15 | 4 + app/preproc/JavaLexer.smap | 1211 ++++++++ app/preproc/JavaRecognizer.smap | 3442 +++++++++++++++++++++++ app/preproc/PdeLexer.smap | 1236 ++++++++ app/preproc/PdeRecognizer.smap | 3252 +++++++++++++++++++++ app/preproc/java.g.java15 | 2002 +++++++++++++ 6 files changed, 11147 insertions(+) create mode 100644 app/preproc/CommonTokenTypes.txt.java15 create mode 100644 app/preproc/JavaLexer.smap create mode 100644 app/preproc/JavaRecognizer.smap create mode 100644 app/preproc/PdeLexer.smap create mode 100644 app/preproc/PdeRecognizer.smap create mode 100644 app/preproc/java.g.java15 diff --git a/app/preproc/CommonTokenTypes.txt.java15 b/app/preproc/CommonTokenTypes.txt.java15 new file mode 100644 index 000000000..51379633d --- /dev/null +++ b/app/preproc/CommonTokenTypes.txt.java15 @@ -0,0 +1,4 @@ +Common +JAVADOC_COMMENT=6 +LCURLY=7 +RCURLY=8 diff --git a/app/preproc/JavaLexer.smap b/app/preproc/JavaLexer.smap new file mode 100644 index 000000000..9d0011055 --- /dev/null +++ b/app/preproc/JavaLexer.smap @@ -0,0 +1,1211 @@ +SMAP +JavaLexer.java +G +*S G +*F ++ 0 java.g +java.g +*L +0:110 +0:116 +0:122 +0:128 +0:134 +0:140 +0:146 +0:152 +0:158 +0:164 +0:170 +0:177 +0:183 +0:189 +0:208 +0:216 +0:222 +0:226 +0:230 +0:234 +0:238 +0:242 +0:246 +0:250 +0:254 +0:258 +0:262 +0:266 +0:270 +0:274 +0:278 +0:282 +0:286 +0:290 +0:294 +0:298 +0:302 +0:306 +0:310 +0:314 +0:318 +0:322 +0:326 +0:330 +0:334 +0:338 +0:342 +0:346 +0:350 +0:354 +0:358 +0:362 +1:3 +1040:390 +1040:391 +1040:392 +1040:393 +1040:395 +1040:396 +1040:397 +1040:398 +1040:399 +1040:400 +1040:401 +1041:403 +1041:404 +1041:405 +1041:406 +1041:408 +1041:409 +1041:410 +1041:411 +1041:412 +1041:413 +1041:414 +1042:416 +1042:417 +1042:418 +1042:419 +1042:421 +1042:422 +1042:423 +1042:424 +1042:425 +1042:426 +1042:427 +1043:429 +1043:430 +1043:431 +1043:432 +1043:434 +1043:435 +1043:436 +1043:437 +1043:438 +1043:439 +1043:440 +1044:442 +1044:443 +1044:444 +1044:445 +1044:447 +1044:448 +1044:449 +1044:450 +1044:451 +1044:452 +1044:453 +1045:455 +1045:456 +1045:457 +1045:458 +1045:460 +1045:461 +1045:462 +1045:463 +1045:464 +1045:465 +1045:466 +1046:468 +1046:469 +1046:470 +1046:471 +1046:473 +1046:474 +1046:475 +1046:476 +1046:477 +1046:478 +1046:479 +1047:481 +1047:482 +1047:483 +1047:484 +1047:486 +1047:487 +1047:488 +1047:489 +1047:490 +1047:491 +1047:492 +1048:494 +1048:495 +1048:496 +1048:497 +1048:499 +1048:500 +1048:501 +1048:502 +1048:503 +1048:504 +1048:505 +1050:507 +1050:508 +1050:509 +1050:510 +1050:512 +1050:513 +1050:514 +1050:515 +1050:516 +1050:517 +1050:518 +1051:520 +1051:521 +1051:522 +1051:523 +1051:525 +1051:526 +1051:527 +1051:528 +1051:529 +1051:530 +1051:531 +1052:533 +1052:534 +1052:535 +1052:536 +1052:538 +1052:539 +1052:540 +1052:541 +1052:542 +1052:543 +1052:544 +1053:546 +1053:547 +1053:548 +1053:549 +1053:551 +1053:552 +1053:553 +1053:554 +1053:555 +1053:556 +1053:557 +1054:559 +1054:560 +1054:561 +1054:562 +1054:564 +1054:565 +1054:566 +1054:567 +1054:568 +1054:569 +1054:570 +1055:572 +1055:573 +1055:574 +1055:575 +1055:577 +1055:578 +1055:579 +1055:580 +1055:581 +1055:582 +1055:583 +1056:585 +1056:586 +1056:587 +1056:588 +1056:590 +1056:591 +1056:592 +1056:593 +1056:594 +1056:595 +1056:596 +1057:598 +1057:599 +1057:600 +1057:601 +1057:603 +1057:604 +1057:605 +1057:606 +1057:607 +1057:608 +1057:609 +1058:611 +1058:612 +1058:613 +1058:614 +1058:616 +1058:617 +1058:618 +1058:619 +1058:620 +1058:621 +1058:622 +1059:624 +1059:625 +1059:626 +1059:627 +1059:629 +1059:630 +1059:631 +1059:632 +1059:633 +1059:634 +1059:635 +1060:637 +1060:638 +1060:639 +1060:640 +1060:642 +1060:643 +1060:644 +1060:645 +1060:646 +1060:647 +1060:648 +1061:650 +1061:651 +1061:652 +1061:653 +1061:655 +1061:656 +1061:657 +1061:658 +1061:659 +1061:660 +1061:661 +1062:663 +1062:664 +1062:665 +1062:666 +1062:668 +1062:669 +1062:670 +1062:671 +1062:672 +1062:673 +1062:674 +1063:676 +1063:677 +1063:678 +1063:679 +1063:681 +1063:682 +1063:683 +1063:684 +1063:685 +1063:686 +1063:687 +1064:689 +1064:690 +1064:691 +1064:692 +1064:694 +1064:695 +1064:696 +1064:697 +1064:698 +1064:699 +1064:700 +1065:702 +1065:703 +1065:704 +1065:705 +1065:707 +1065:708 +1065:709 +1065:710 +1065:711 +1065:712 +1065:713 +1066:715 +1066:716 +1066:717 +1066:718 +1066:720 +1066:721 +1066:722 +1066:723 +1066:724 +1066:725 +1066:726 +1067:728 +1067:729 +1067:730 +1067:731 +1067:733 +1067:734 +1067:735 +1067:736 +1067:737 +1067:738 +1067:739 +1068:741 +1068:742 +1068:743 +1068:744 +1068:746 +1068:747 +1068:748 +1068:749 +1068:750 +1068:751 +1068:752 +1069:754 +1069:755 +1069:756 +1069:757 +1069:759 +1069:760 +1069:761 +1069:762 +1069:763 +1069:764 +1069:765 +1070:767 +1070:768 +1070:769 +1070:770 +1070:772 +1070:773 +1070:774 +1070:775 +1070:776 +1070:777 +1070:778 +1071:780 +1071:781 +1071:782 +1071:783 +1071:785 +1071:786 +1071:787 +1071:788 +1071:789 +1071:790 +1071:791 +1072:793 +1072:794 +1072:795 +1072:796 +1072:798 +1072:799 +1072:800 +1072:801 +1072:802 +1072:803 +1072:804 +1073:806 +1073:807 +1073:808 +1073:809 +1073:811 +1073:812 +1073:813 +1073:814 +1073:815 +1073:816 +1073:817 +1074:819 +1074:820 +1074:821 +1074:822 +1074:824 +1074:825 +1074:826 +1074:827 +1074:828 +1074:829 +1074:830 +1075:832 +1075:833 +1075:834 +1075:835 +1075:837 +1075:838 +1075:839 +1075:840 +1075:841 +1075:842 +1075:843 +1076:845 +1076:846 +1076:847 +1076:848 +1076:850 +1076:851 +1076:852 +1076:853 +1076:854 +1076:855 +1076:856 +1077:858 +1077:859 +1077:860 +1077:861 +1077:863 +1077:864 +1077:865 +1077:866 +1077:867 +1077:868 +1077:869 +1078:871 +1078:872 +1078:873 +1078:874 +1078:876 +1078:877 +1078:878 +1078:879 +1078:880 +1078:881 +1078:882 +1079:884 +1079:885 +1079:886 +1079:887 +1079:889 +1079:890 +1079:891 +1079:892 +1079:893 +1079:894 +1079:895 +1080:897 +1080:898 +1080:899 +1080:900 +1080:902 +1080:903 +1080:904 +1080:905 +1080:906 +1080:907 +1080:908 +1081:910 +1081:911 +1081:912 +1081:913 +1081:915 +1081:916 +1081:917 +1081:918 +1081:919 +1081:920 +1081:921 +1082:923 +1082:924 +1082:925 +1082:926 +1082:928 +1082:929 +1082:930 +1082:931 +1082:932 +1082:933 +1082:934 +1083:936 +1083:937 +1083:938 +1083:939 +1083:941 +1083:942 +1083:943 +1083:944 +1083:945 +1083:946 +1083:947 +1084:949 +1084:950 +1084:951 +1084:952 +1084:954 +1084:955 +1084:956 +1084:957 +1084:958 +1084:959 +1084:960 +1085:962 +1085:963 +1085:964 +1085:965 +1085:967 +1085:968 +1085:969 +1085:970 +1085:971 +1085:972 +1085:973 +1089:975 +1089:976 +1089:977 +1089:978 +1089:981 +1089:982 +1089:983 +1089:984 +1089:985 +1089:986 +1089:987 +1089:1020 +1089:1021 +1089:1022 +1089:1023 +1089:1024 +1089:1025 +1089:1026 +1089:1027 +1089:1029 +1089:1030 +1089:1031 +1089:1032 +1089:1033 +1089:1034 +1090:990 +1090:991 +1090:992 +1091:995 +1091:996 +1091:997 +1093:1000 +1093:1001 +1093:1005 +1093:1008 +1093:1011 +1093:1012 +1093:1013 +1093:1014 +1094:1003 +1094:1004 +1095:1006 +1095:1007 +1096:1009 +1096:1010 +1098:1017 +1100:1028 +1104:1036 +1104:1037 +1104:1038 +1104:1039 +1104:1083 +1104:1084 +1104:1085 +1104:1086 +1104:1087 +1104:1088 +1105:1041 +1106:1042 +1106:1043 +1106:1044 +1106:1045 +1106:1047 +1106:1049 +1106:1050 +1106:1051 +1106:1052 +1106:1054 +1106:1055 +1106:1057 +1106:1058 +1106:1059 +1106:1060 +1106:1063 +1106:1064 +1106:1065 +1106:1067 +1106:1068 +1106:1069 +1106:1071 +1106:1076 +1106:1077 +1106:1078 +1106:1079 +1106:1080 +1107:1082 +1111:1090 +1111:1091 +1111:1092 +1111:1093 +1111:1128 +1111:1129 +1111:1130 +1111:1131 +1111:1132 +1111:1133 +1112:1095 +1113:1096 +1113:1097 +1113:1098 +1113:1103 +1113:1106 +1113:1110 +1113:1114 +1113:1119 +1113:1120 +1113:1121 +1113:1122 +1113:1124 +1113:1125 +1124:1104 +1124:1105 +1125:1099 +1125:1100 +1125:1101 +1125:1102 +1126:1107 +1126:1108 +1126:1109 +1127:1111 +1127:1112 +1127:1113 +1128:1115 +1128:1117 +1130:1126 +1131:1127 +1136:1135 +1136:1136 +1136:1137 +1136:1138 +1136:1154 +1136:1155 +1136:1156 +1136:1157 +1136:1158 +1136:1159 +1137:1140 +1137:1142 +1137:1143 +1137:1144 +1137:1145 +1137:1146 +1137:1147 +1137:1148 +1137:1149 +1137:1150 +1137:1153 +1141:1287 +1141:1288 +1141:1289 +1141:1290 +1141:1311 +1141:1312 +1141:1313 +1141:1314 +1141:1315 +1141:1316 +1142:1292 +1142:1293 +1142:1294 +1142:1295 +1142:1296 +1142:1297 +1142:1298 +1142:1299 +1142:1301 +1142:1303 +1142:1304 +1142:1305 +1142:1306 +1142:1308 +1142:1309 +1142:1310 +1155:1161 +1155:1162 +1155:1163 +1155:1164 +1155:1280 +1155:1281 +1155:1282 +1155:1283 +1155:1284 +1155:1285 +1156:1166 +1157:1168 +1157:1169 +1157:1170 +1157:1171 +1157:1274 +1157:1275 +1157:1276 +1157:1277 +1157:1278 +1158:1174 +1158:1175 +1158:1176 +1159:1179 +1159:1180 +1159:1181 +1160:1184 +1160:1185 +1160:1186 +1161:1189 +1161:1190 +1161:1191 +1162:1194 +1162:1195 +1162:1196 +1163:1199 +1163:1200 +1163:1201 +1164:1204 +1164:1205 +1164:1206 +1165:1209 +1165:1210 +1165:1212 +1165:1213 +1165:1214 +1165:1215 +1165:1216 +1165:1217 +1165:1218 +1165:1219 +1165:1220 +1165:1222 +1165:1223 +1165:1224 +1165:1225 +1165:1226 +1165:1227 +1165:1228 +1166:1231 +1166:1232 +1166:1233 +1167:1248 +1167:1250 +1167:1251 +1167:1252 +1167:1253 +1171:1235 +1171:1236 +1172:1240 +1172:1242 +1172:1243 +1172:1244 +1172:1245 +1176:1238 +1176:1239 +1179:1258 +1179:1259 +1179:1260 +1180:1264 +1180:1266 +1180:1267 +1180:1268 +1180:1269 +1184:1262 +1184:1263 +1192:1318 +1192:1319 +1192:1320 +1192:1321 +1192:1350 +1192:1351 +1192:1352 +1192:1353 +1192:1354 +1192:1355 +1193:1324 +1193:1325 +1193:1326 +1193:1327 +1193:1328 +1193:1329 +1193:1332 +1193:1333 +1193:1334 +1193:1335 +1193:1338 +1193:1339 +1193:1340 +1193:1341 +1193:1344 +1193:1345 +1193:1346 +1193:1347 +1193:1348 +1200:1357 +1200:1358 +1200:1359 +1200:1360 +1200:1363 +1200:1364 +1200:1365 +1200:1366 +1200:1367 +1200:1368 +1201:1362 +1208:1370 +1208:1371 +1208:1372 +1208:1373 +1208:1465 +1208:1466 +1208:1467 +1208:1468 +1208:1469 +1208:1470 +1208:1471 +1210:1376 +1210:1377 +1210:1378 +1210:1379 +1210:1380 +1210:1381 +1210:1382 +1210:1383 +1210:1384 +1210:1385 +1210:1388 +1210:1389 +1210:1390 +1210:1391 +1210:1392 +1210:1393 +1210:1394 +1210:1395 +1210:1396 +1210:1399 +1210:1400 +1210:1401 +1210:1404 +1210:1405 +1210:1406 +1210:1409 +1210:1410 +1210:1411 +1210:1412 +1210:1413 +1210:1415 +1210:1416 +1210:1417 +1210:1418 +1210:1419 +1210:1420 +1210:1421 +1210:1422 +1210:1423 +1210:1424 +1210:1425 +1210:1426 +1210:1427 +1210:1430 +1210:1431 +1210:1432 +1210:1433 +1210:1434 +1210:1435 +1210:1436 +1210:1437 +1210:1438 +1210:1441 +1210:1442 +1210:1443 +1210:1446 +1210:1447 +1210:1448 +1210:1449 +1210:1450 +1210:1453 +1210:1454 +1210:1455 +1210:1458 +1210:1459 +1210:1460 +1210:1461 +1210:1462 +1210:1463 +1210:1464 +1215:1473 +1215:1474 +1215:1475 +1215:1476 +1215:1481 +1215:1483 +1215:1742 +1215:1743 +1215:1744 +1215:1745 +1215:1746 +1215:1747 +1215:1748 +1215:1749 +1215:1750 +1215:1751 +1215:1752 +1217:1484 +1217:1485 +1217:1486 +1217:1487 +1218:1477 +1218:1489 +1218:1491 +1218:1492 +1218:1493 +1218:1494 +1218:1495 +1218:1496 +1218:1497 +1218:1498 +1218:1499 +1218:1501 +1218:1502 +1218:1503 +1218:1505 +1218:1506 +1218:1507 +1218:1509 +1218:1513 +1218:1514 +1218:1515 +1218:1516 +1218:1517 +1218:1519 +1218:1530 +1218:1532 +1220:1523 +1221:1524 +1222:1525 +1223:1526 +1224:1527 +1225:1528 +1229:1537 +1229:1538 +1229:1539 +1229:1540 +1229:1542 +1229:1543 +1229:1544 +1229:1545 +1229:1546 +1229:1633 +1229:1634 +1229:1635 +1229:1636 +1229:1637 +1230:1548 +1230:1549 +1230:1550 +1230:1552 +1230:1553 +1230:1554 +1230:1555 +1230:1558 +1230:1559 +1230:1560 +1230:1563 +1230:1564 +1230:1565 +1230:1566 +1230:1567 +1230:1604 +1230:1606 +1230:1607 +1231:1570 +1231:1571 +1231:1572 +1231:1575 +1231:1576 +1231:1577 +1231:1578 +1231:1580 +1231:1581 +1231:1582 +1240:1573 +1240:1574 +1242:1585 +1242:1586 +1242:1587 +1242:1589 +1242:1590 +1242:1591 +1242:1592 +1242:1593 +1242:1594 +1242:1595 +1242:1596 +1242:1597 +1242:1599 +1242:1600 +1242:1601 +1244:1611 +1244:1612 +1244:1613 +1244:1614 +1244:1616 +1244:1618 +1244:1619 +1244:1620 +1244:1621 +1244:1622 +1244:1623 +1244:1624 +1244:1625 +1244:1626 +1244:1628 +1244:1629 +1244:1630 +1246:1640 +1246:1642 +1246:1643 +1246:1644 +1246:1645 +1246:1648 +1246:1649 +1246:1650 +1246:1653 +1246:1654 +1246:1655 +1246:1656 +1246:1657 +1246:1659 +1246:1660 +1246:1735 +1246:1737 +1250:1478 +1250:1661 +1250:1663 +1250:1664 +1250:1665 +1250:1666 +1250:1667 +1250:1668 +1250:1669 +1250:1670 +1250:1671 +1250:1672 +1250:1673 +1250:1674 +1250:1675 +1250:1677 +1250:1678 +1250:1680 +1250:1681 +1250:1682 +1250:1684 +1250:1688 +1250:1689 +1250:1690 +1250:1691 +1250:1692 +1250:1694 +1250:1721 +1250:1722 +1250:1723 +1250:1724 +1250:1725 +1251:1479 +1251:1699 +1251:1700 +1251:1701 +1251:1703 +1251:1704 +1251:1705 +1251:1706 +1251:1707 +1251:1709 +1252:1480 +1252:1714 +1252:1715 +1252:1716 +1252:1717 +1252:1718 +1255:1728 +1256:1729 +1257:1730 +1258:1731 +1259:1732 +1260:1733 +1268:1754 +1268:1755 +1268:1756 +1268:1757 +1268:1815 +1268:1816 +1268:1817 +1268:1818 +1268:1819 +1268:1820 +1269:1760 +1269:1761 +1269:1762 +1269:1763 +1269:1766 +1269:1767 +1269:1768 +1269:1771 +1269:1772 +1269:1773 +1269:1774 +1269:1775 +1269:1778 +1269:1779 +1269:1780 +1269:1781 +1269:1784 +1269:1785 +1269:1786 +1269:1795 +1269:1796 +1269:1797 +1269:1798 +1269:1799 +1269:1802 +1269:1803 +1269:1804 +1269:1805 +1269:1806 +1269:1807 +1269:1808 +1269:1809 +1269:1810 +1269:1812 +1269:1813 +1269:1814 +1274:1822 +1274:1823 +1274:1824 +1274:1825 +1274:1827 +1274:1848 +1274:1849 +1274:1850 +1274:1851 +1274:1852 +1274:1853 +1274:1854 +1274:1855 +1274:1856 +1274:1857 +1274:1858 +1275:1828 +1275:1829 +1275:1830 +1275:1833 +1275:1834 +1275:1835 +1275:1838 +1275:1839 +1275:1840 +1275:1843 +1275:1844 +1275:1845 +*E diff --git a/app/preproc/JavaRecognizer.smap b/app/preproc/JavaRecognizer.smap new file mode 100644 index 000000000..47b0beb18 --- /dev/null +++ b/app/preproc/JavaRecognizer.smap @@ -0,0 +1,3442 @@ +SMAP +JavaRecognizer.java +G +*S G +*F ++ 0 java.g +java.g +*L +1:3 +137:165 +137:167 +137:168 +137:169 +137:233 +137:234 +139:172 +139:173 +139:174 +139:175 +139:176 +139:199 +139:200 +139:201 +139:202 +139:203 +144:205 +144:206 +144:207 +144:208 +144:209 +144:210 +144:211 +144:212 +144:213 +144:214 +144:216 +144:217 +148:218 +148:219 +148:220 +148:221 +148:222 +148:223 +148:224 +148:225 +148:226 +148:227 +148:229 +148:230 +150:231 +152:232 +155:236 +155:238 +155:239 +155:240 +155:244 +155:256 +155:257 +155:258 +155:259 +155:260 +155:261 +155:262 +155:263 +155:264 +155:265 +155:266 +157:241 +157:242 +157:245 +157:246 +157:247 +157:248 +157:249 +157:250 +157:252 +157:253 +157:254 +159:255 +162:268 +162:270 +162:271 +162:272 +162:276 +162:288 +162:289 +162:290 +162:291 +162:292 +162:293 +162:294 +162:295 +162:296 +162:297 +162:298 +164:273 +164:274 +164:277 +164:278 +164:279 +164:280 +164:281 +164:282 +164:284 +164:285 +164:286 +166:287 +168:300 +168:302 +168:303 +168:304 +168:307 +168:308 +168:355 +168:356 +168:357 +168:358 +168:359 +168:360 +168:361 +168:362 +168:363 +168:364 +168:365 +168:366 +168:367 +168:368 +168:369 +168:370 +170:305 +170:309 +170:310 +170:311 +170:312 +170:313 +170:314 +170:315 +170:316 +170:317 +170:318 +170:319 +170:320 +170:321 +170:322 +170:323 +170:324 +170:325 +171:327 +171:328 +171:329 +171:330 +171:331 +171:340 +171:341 +171:342 +171:343 +171:344 +172:334 +172:335 +172:336 +172:337 +172:346 +174:349 +174:350 +174:351 +176:352 +180:554 +180:557 +180:559 +180:560 +180:561 +180:580 +180:581 +181:555 +181:562 +181:563 +181:564 +181:566 +181:567 +181:568 +181:569 +181:570 +181:571 +182:556 +182:572 +182:573 +182:574 +182:575 +182:577 +182:578 +187:583 +187:584 +187:585 +187:587 +187:588 +187:589 +187:591 +187:614 +187:615 +187:616 +187:617 +187:618 +187:619 +187:620 +188:592 +188:593 +188:594 +188:595 +188:596 +189:599 +189:600 +189:601 +189:602 +189:603 +189:604 +189:605 +189:606 +189:607 +189:608 +189:609 +189:610 +189:611 +194:652 +194:653 +194:654 +194:656 +194:657 +194:658 +194:696 +194:697 +195:659 +195:660 +195:662 +195:663 +195:664 +195:665 +195:666 +195:667 +195:668 +195:669 +195:670 +195:671 +195:672 +195:673 +195:675 +195:676 +195:677 +195:678 +195:679 +195:681 +195:682 +196:683 +196:684 +196:690 +196:692 +196:693 +197:686 +197:695 +198:687 +199:688 +205:699 +205:700 +205:701 +205:703 +205:704 +205:705 +205:743 +205:744 +206:706 +206:707 +206:709 +206:710 +206:711 +206:712 +206:713 +206:714 +206:715 +206:716 +206:717 +206:718 +206:719 +206:720 +206:722 +206:723 +206:724 +206:725 +206:726 +206:728 +206:729 +207:730 +207:731 +207:737 +207:739 +207:740 +208:733 +208:742 +209:734 +210:735 +216:842 +216:844 +216:845 +216:846 +216:848 +216:871 +216:872 +216:873 +216:874 +216:875 +216:876 +216:877 +217:849 +217:850 +217:851 +217:852 +217:853 +218:856 +218:857 +218:858 +218:859 +218:860 +218:861 +218:862 +218:863 +218:864 +218:865 +218:866 +218:867 +218:868 +222:746 +222:748 +222:749 +222:750 +222:752 +222:834 +222:835 +222:836 +222:837 +222:838 +222:839 +222:840 +223:753 +223:754 +223:755 +223:756 +223:757 +223:758 +223:759 +224:762 +224:763 +224:764 +224:765 +224:766 +224:767 +224:768 +225:771 +225:772 +225:773 +225:774 +225:775 +225:776 +225:777 +226:780 +226:781 +226:782 +226:783 +226:784 +226:785 +226:786 +227:789 +227:790 +227:791 +227:792 +227:793 +227:794 +227:795 +228:798 +228:799 +228:800 +228:801 +228:802 +228:803 +228:804 +229:807 +229:808 +229:809 +229:810 +229:811 +229:812 +229:813 +230:816 +230:817 +230:818 +230:819 +230:820 +230:821 +230:822 +231:825 +231:826 +231:827 +231:828 +231:829 +231:830 +231:831 +236:372 +236:374 +236:375 +236:376 +236:402 +236:403 +237:378 +237:379 +237:380 +237:381 +237:382 +237:383 +237:384 +237:385 +237:386 +237:387 +237:388 +237:389 +237:390 +237:391 +237:392 +237:393 +237:394 +237:395 +237:396 +237:397 +237:399 +237:400 +237:401 +240:405 +240:407 +240:408 +240:409 +240:459 +240:460 +241:411 +241:412 +241:413 +241:414 +242:415 +242:416 +242:417 +242:418 +242:419 +242:420 +242:421 +242:422 +242:423 +242:424 +242:425 +242:426 +242:427 +242:428 +242:429 +242:430 +242:432 +242:433 +243:435 +243:436 +243:437 +243:438 +243:439 +243:440 +243:441 +243:442 +243:443 +243:444 +243:445 +243:452 +243:453 +243:454 +243:455 +243:456 +244:458 +250:462 +250:464 +250:465 +250:466 +250:490 +250:491 +251:468 +251:469 +251:470 +251:471 +251:472 +251:473 +251:474 +251:475 +251:476 +251:477 +251:479 +251:480 +252:481 +252:482 +252:483 +252:484 +252:486 +252:487 +253:489 +256:879 +256:881 +256:882 +256:883 +256:885 +256:994 +256:995 +256:996 +256:997 +256:998 +256:999 +256:1000 +257:886 +257:887 +257:888 +257:889 +257:890 +257:891 +257:892 +258:895 +258:896 +258:897 +258:898 +258:899 +258:900 +258:901 +259:904 +259:905 +259:906 +259:907 +259:908 +259:909 +259:910 +260:913 +260:914 +260:915 +260:916 +260:917 +260:918 +260:919 +261:922 +261:923 +261:924 +261:925 +261:926 +261:927 +261:928 +262:931 +262:932 +262:933 +262:934 +262:935 +262:936 +262:937 +263:940 +263:941 +263:942 +263:943 +263:944 +263:945 +263:946 +264:949 +264:950 +264:951 +264:952 +264:953 +264:954 +264:955 +265:958 +265:959 +265:960 +265:961 +265:962 +265:963 +265:964 +266:967 +266:968 +266:969 +266:970 +266:971 +266:972 +266:973 +268:976 +268:977 +268:978 +268:979 +268:980 +268:981 +268:982 +269:985 +269:986 +269:987 +269:988 +269:989 +269:990 +269:991 +273:493 +273:494 +273:495 +273:497 +273:498 +273:499 +273:522 +273:523 +274:504 +274:505 +274:506 +274:507 +276:500 +276:508 +276:509 +278:501 +278:510 +278:511 +280:502 +280:512 +280:513 +281:514 +281:515 +281:516 +281:517 +281:519 +281:520 +285:1002 +285:1004 +285:1005 +285:1006 +285:1037 +285:1038 +286:1007 +286:1010 +286:1011 +286:1012 +286:1013 +286:1014 +286:1015 +286:1023 +286:1024 +286:1025 +286:1026 +286:1027 +287:1029 +287:1030 +287:1031 +287:1032 +287:1034 +287:1035 +291:525 +291:526 +291:527 +291:529 +291:530 +291:531 +291:551 +291:552 +292:535 +292:536 +292:537 +292:538 +294:532 +294:539 +294:540 +296:533 +296:541 +296:542 +297:543 +297:544 +297:545 +297:546 +297:548 +297:549 +304:1095 +304:1097 +304:1098 +304:1099 +304:1158 +304:1159 +305:1101 +306:1102 +306:1103 +306:1104 +306:1105 +306:1106 +306:1107 +306:1108 +306:1109 +306:1110 +306:1111 +306:1112 +306:1113 +306:1114 +306:1115 +306:1116 +306:1117 +306:1118 +306:1119 +306:1120 +306:1121 +306:1122 +306:1123 +306:1124 +306:1125 +306:1126 +306:1127 +306:1128 +306:1129 +306:1130 +306:1131 +306:1132 +306:1133 +306:1136 +306:1137 +306:1138 +306:1141 +306:1142 +306:1143 +306:1144 +306:1145 +306:1146 +306:1147 +307:1148 +308:1149 +308:1150 +308:1151 +308:1152 +308:1154 +308:1155 +309:1157 +312:1161 +312:1163 +312:1164 +312:1165 +312:1213 +312:1214 +313:1170 +313:1198 +313:1199 +313:1200 +313:1201 +313:1202 +314:1166 +314:1167 +314:1171 +314:1172 +314:1173 +314:1174 +314:1175 +315:1176 +315:1177 +315:1178 +315:1179 +315:1180 +315:1181 +315:1182 +315:1183 +315:1184 +315:1185 +315:1186 +315:1187 +315:1188 +315:1190 +315:1191 +317:1204 +317:1205 +317:1206 +317:1207 +317:1209 +317:1210 +318:1212 +322:1040 +322:1042 +322:1043 +322:1044 +322:1092 +322:1093 +323:1049 +323:1077 +323:1078 +323:1079 +323:1080 +323:1081 +324:1045 +324:1046 +324:1050 +324:1051 +324:1052 +324:1053 +324:1054 +324:1055 +324:1056 +324:1057 +324:1058 +324:1059 +324:1060 +324:1061 +324:1062 +324:1063 +324:1064 +324:1065 +324:1066 +324:1067 +324:1069 +324:1070 +326:1083 +326:1084 +326:1085 +326:1086 +326:1088 +326:1089 +327:1091 +334:1216 +334:1218 +334:1219 +334:1220 +334:1372 +334:1385 +334:1397 +334:1398 +334:1399 +334:1400 +334:1402 +334:1403 +336:1221 +336:1235 +336:1236 +336:1237 +337:1222 +337:1223 +337:1239 +337:1268 +337:1269 +337:1270 +337:1271 +337:1272 +337:1273 +337:1282 +337:1366 +337:1367 +337:1368 +337:1369 +337:1370 +338:1274 +338:1275 +338:1276 +338:1277 +338:1279 +338:1280 +340:1224 +340:1240 +340:1241 +340:1242 +340:1243 +341:1244 +341:1245 +341:1246 +341:1247 +341:1249 +341:1250 +343:1225 +343:1254 +343:1255 +343:1256 +343:1257 +344:1258 +344:1259 +344:1260 +344:1261 +344:1263 +344:1264 +346:1226 +346:1283 +346:1284 +346:1285 +347:1287 +347:1288 +347:1289 +347:1290 +347:1345 +347:1360 +347:1361 +347:1362 +347:1363 +350:1227 +350:1291 +350:1292 +350:1293 +350:1294 +352:1228 +352:1295 +352:1296 +356:1229 +356:1298 +356:1299 +356:1300 +356:1301 +356:1302 +356:1310 +356:1311 +356:1312 +356:1313 +356:1314 +358:1230 +358:1317 +358:1318 +358:1319 +358:1320 +358:1321 +358:1324 +358:1325 +358:1326 +358:1327 +358:1328 +358:1331 +358:1332 +358:1333 +358:1334 +358:1335 +359:1337 +359:1338 +359:1339 +359:1340 +359:1342 +359:1343 +366:1231 +366:1346 +366:1347 +366:1348 +366:1349 +366:1350 +366:1351 +368:1352 +368:1353 +368:1354 +368:1355 +368:1357 +368:1358 +373:1232 +373:1373 +373:1374 +373:1375 +373:1376 +374:1377 +374:1378 +374:1379 +374:1380 +374:1382 +374:1383 +377:1233 +377:1386 +377:1387 +377:1388 +378:1389 +378:1390 +378:1391 +378:1392 +378:1394 +378:1395 +381:1441 +381:1443 +381:1444 +381:1445 +381:1483 +381:1484 +382:1446 +382:1447 +382:1449 +382:1450 +382:1451 +382:1452 +382:1453 +382:1454 +383:1457 +383:1458 +383:1459 +383:1460 +383:1462 +383:1463 +383:1464 +383:1465 +384:1468 +384:1469 +384:1470 +384:1471 +384:1472 +384:1473 +384:1474 +384:1475 +384:1476 +384:1477 +384:1479 +384:1480 +385:1481 +387:1482 +389:1650 +389:1651 +389:1653 +389:1654 +389:1655 +389:1661 +389:1696 +389:1697 +389:1698 +389:1699 +389:1700 +389:1701 +389:1702 +390:1656 +390:1657 +390:1662 +390:1663 +390:1664 +390:1665 +390:1666 +390:1667 +390:1668 +390:1669 +390:1670 +390:1671 +390:1672 +391:1673 +391:1674 +392:1658 +392:1659 +392:1679 +392:1680 +392:1681 +392:1682 +392:1683 +392:1684 +392:1685 +392:1686 +392:1687 +392:1688 +392:1689 +393:1690 +393:1691 +394:1676 +396:622 +396:623 +396:624 +396:626 +396:627 +396:628 +396:649 +396:650 +396:1693 +397:630 +397:631 +397:632 +398:631 +399:633 +399:634 +399:635 +399:636 +399:637 +399:641 +399:642 +399:643 +399:644 +399:646 +399:647 +399:648 +400:638 +400:639 +400:640 +401:639 +409:2146 +409:2150 +409:2151 +409:2152 +409:2154 +409:2155 +409:2156 +409:2177 +409:2178 +410:2147 +410:2157 +410:2158 +410:2159 +410:2160 +410:2162 +410:2163 +410:2164 +410:2165 +410:2166 +410:2167 +410:2168 +411:2148 +411:2169 +411:2170 +411:2171 +411:2172 +411:2174 +411:2175 +412:2149 +414:1546 +414:1547 +414:1548 +414:1550 +414:1551 +414:1552 +414:1584 +414:1585 +415:1556 +415:1557 +415:1558 +415:1559 +415:1561 +415:1562 +416:1553 +416:1554 +416:1564 +416:1565 +416:1566 +416:1567 +416:1568 +416:1569 +416:1570 +416:1571 +416:1572 +416:1573 +416:1575 +416:1576 +416:1577 +416:1578 +416:1579 +416:1581 +416:1582 +416:1583 +419:2180 +419:2182 +419:2183 +419:2184 +419:2210 +419:2211 +420:2187 +420:2188 +420:2189 +420:2190 +420:2191 +420:2192 +420:2193 +420:2194 +420:2195 +420:2203 +420:2204 +420:2205 +420:2206 +420:2207 +421:2209 +424:2270 +424:2272 +424:2273 +424:2274 +424:2365 +424:2366 +425:2275 +425:2276 +425:2278 +425:2279 +425:2280 +425:2281 +425:2282 +425:2283 +426:2286 +426:2287 +426:2288 +426:2289 +426:2290 +426:2291 +426:2292 +426:2293 +426:2294 +426:2295 +426:2296 +426:2297 +426:2298 +426:2299 +426:2300 +426:2301 +426:2302 +426:2303 +426:2304 +426:2305 +426:2306 +426:2307 +426:2308 +426:2309 +426:2310 +426:2311 +426:2312 +426:2313 +426:2314 +426:2315 +426:2316 +426:2317 +426:2318 +426:2319 +426:2357 +426:2358 +426:2359 +426:2360 +426:2361 +427:2320 +427:2321 +427:2322 +427:2327 +427:2328 +427:2329 +427:2330 +427:2332 +427:2333 +436:2323 +436:2324 +436:2325 +436:2326 +438:2335 +438:2336 +438:2337 +438:2338 +438:2345 +438:2346 +438:2347 +438:2348 +438:2349 +440:2363 +442:2364 +446:2213 +446:2215 +446:2216 +446:2217 +446:2219 +446:2262 +446:2263 +446:2264 +446:2265 +446:2266 +446:2267 +446:2268 +447:2220 +447:2221 +447:2222 +447:2223 +447:2224 +447:2225 +447:2226 +447:2227 +447:2228 +447:2229 +447:2230 +447:2231 +447:2232 +447:2233 +447:2234 +447:2235 +447:2236 +447:2237 +447:2238 +447:2239 +447:2240 +447:2241 +447:2242 +447:2243 +447:2244 +447:2245 +447:2246 +447:2247 +447:2248 +447:2249 +447:2250 +447:2251 +447:2252 +448:2255 +448:2256 +448:2257 +448:2258 +448:2259 +454:1405 +454:1407 +454:1408 +454:1409 +454:1438 +454:1439 +455:1411 +455:1412 +455:1413 +455:1414 +458:1415 +458:1416 +458:1417 +458:1418 +461:1420 +461:1421 +461:1422 +461:1423 +461:1424 +461:1431 +461:1432 +461:1433 +461:1434 +461:1435 +462:1437 +465:1587 +465:1589 +465:1590 +465:1591 +465:1614 +465:1615 +466:1593 +466:1594 +466:1595 +466:1596 +466:1597 +466:1598 +466:1599 +466:1600 +466:1601 +466:1602 +466:1603 +466:1604 +466:1605 +466:1606 +466:1607 +466:1608 +466:1609 +466:1611 +466:1612 +466:1613 +471:1486 +471:1488 +471:1489 +471:1490 +471:1543 +471:1544 +472:1493 +472:1494 +472:1495 +472:1496 +472:1497 +472:1498 +472:1499 +472:1500 +472:1501 +472:1502 +472:1503 +472:1504 +472:1505 +472:1506 +472:1507 +472:1508 +472:1509 +472:1510 +472:1511 +472:1512 +472:1513 +472:1514 +472:1515 +472:1516 +472:1517 +472:1518 +472:1520 +472:1521 +472:1528 +472:1529 +472:1530 +472:1531 +472:1532 +473:1534 +473:1535 +473:1536 +473:1537 +473:1539 +473:1540 +474:1542 +478:2388 +478:2390 +478:2391 +478:2392 +478:2416 +478:2417 +479:2393 +479:2394 +479:2395 +479:2396 +479:2399 +479:2400 +479:2401 +479:2402 +479:2403 +479:2404 +479:2405 +480:2397 +480:2406 +480:2407 +481:2408 +481:2409 +481:2410 +481:2411 +481:2413 +481:2414 +485:2419 +485:2421 +485:2422 +485:2423 +485:2465 +485:2466 +486:2424 +486:2425 +486:2428 +486:2429 +486:2430 +486:2431 +486:2432 +486:2433 +486:2434 +486:2450 +486:2451 +486:2452 +486:2453 +486:2454 +487:2456 +487:2457 +487:2458 +487:2459 +487:2461 +487:2462 +488:2464 +499:1617 +499:1619 +499:1620 +499:1621 +499:1647 +499:1648 +500:1622 +500:1623 +500:1625 +500:1626 +500:1627 +500:1628 +500:1629 +500:1630 +502:1632 +502:1633 +502:1634 +502:1635 +502:1636 +502:1637 +502:1638 +502:1639 +502:1640 +502:1641 +502:1643 +502:1644 +503:1645 +505:1646 +507:1704 +507:1706 +507:1707 +507:1708 +507:1715 +507:2010 +507:2032 +507:2038 +507:2045 +507:2061 +507:2074 +507:2075 +507:2076 +507:2077 +507:2078 +507:2079 +507:2080 +509:1716 +509:1717 +509:1718 +509:1719 +509:1720 +515:2011 +515:2012 +515:2013 +515:2014 +515:2015 +515:2016 +515:2018 +515:2020 +515:2021 +515:2022 +515:2023 +515:2024 +515:2025 +515:2026 +515:2027 +515:2028 +515:2029 +515:2030 +517:2031 +520:2033 +520:2034 +520:2035 +520:2036 +522:2037 +523:1709 +523:2039 +523:2040 +523:2041 +523:2042 +523:2043 +523:2044 +526:1710 +526:1711 +526:2046 +526:2047 +526:2048 +526:2049 +526:2050 +526:2051 +526:2052 +526:2053 +526:2054 +526:2055 +526:2056 +526:2058 +526:2059 +526:2060 +529:1723 +529:1724 +529:1725 +529:1726 +529:1727 +529:1728 +529:1729 +529:1730 +529:1731 +529:1732 +529:1733 +529:1734 +530:1740 +530:1742 +530:1743 +530:1744 +530:1745 +531:1748 +538:1736 +538:1737 +538:1738 +538:1739 +542:1751 +542:1752 +542:1753 +542:1754 +542:1755 +542:1756 +543:1757 +544:1758 +544:1759 +544:1760 +545:1761 +545:1762 +545:1763 +546:1764 +546:1765 +547:1766 +548:1767 +548:1768 +548:1769 +551:1772 +551:1773 +551:1774 +551:1775 +551:1776 +551:1777 +551:1778 +551:1779 +551:1780 +551:1781 +551:1782 +551:1783 +551:1784 +554:1787 +554:1788 +554:1789 +554:1790 +554:1791 +554:1792 +554:1793 +554:1794 +554:1795 +554:1796 +554:1797 +554:1798 +554:1799 +554:1800 +556:1801 +557:1804 +557:1805 +557:1806 +557:1807 +557:1808 +557:1809 +557:1811 +557:1812 +557:1813 +557:1814 +557:1815 +557:1816 +557:1817 +557:1824 +557:1825 +557:1826 +557:1827 +557:1828 +557:1830 +559:1831 +560:1834 +560:1835 +560:1836 +560:1837 +560:1838 +560:1839 +560:1841 +560:1842 +560:1843 +560:1844 +560:1845 +560:1846 +560:1847 +560:1854 +560:1855 +560:1856 +560:1857 +560:1858 +560:1860 +562:1861 +563:1864 +563:1865 +563:1866 +563:1867 +563:1868 +563:1869 +563:1871 +563:1872 +563:1873 +563:1874 +563:1875 +563:1876 +563:1877 +563:1878 +563:1879 +563:1880 +563:1881 +563:1882 +563:1883 +563:1884 +563:1885 +563:1886 +563:1887 +563:1888 +563:1889 +563:1890 +563:1891 +563:1892 +563:1893 +563:1894 +563:1895 +563:1896 +563:1897 +563:1898 +563:1899 +563:1900 +563:1901 +563:1902 +563:1903 +563:1910 +563:1911 +563:1912 +563:1913 +563:1914 +563:1916 +565:1917 +566:1920 +566:1921 +566:1922 +566:1923 +566:1924 +566:1925 +566:1926 +566:1927 +566:1928 +566:1929 +566:1930 +567:1931 +567:1932 +567:1933 +567:1934 +567:1935 +567:1936 +567:1937 +567:1938 +567:1939 +567:1940 +567:1942 +567:1943 +568:1944 +570:1945 +571:1948 +571:1949 +571:1950 +571:1951 +571:1952 +574:1955 +574:1956 +574:1957 +574:1958 +574:1959 +574:1960 +574:1961 +574:1962 +574:1963 +576:1964 +577:2062 +577:2063 +577:2064 +577:2065 +577:2066 +577:2067 +577:2068 +577:2069 +577:2070 +577:2071 +577:2072 +577:2073 +580:1967 +580:1968 +580:1969 +580:1970 +580:1971 +580:1972 +580:1973 +580:1974 +580:1976 +580:1977 +580:1978 +580:1979 +580:1980 +580:1981 +580:1988 +580:1989 +580:1990 +580:1991 +580:1992 +580:1994 +582:1995 +583:1712 +583:1713 +583:1998 +583:1999 +583:2000 +583:2001 +583:2002 +583:2003 +583:2004 +583:2005 +586:2007 +586:2646 +586:2648 +586:2649 +586:2650 +586:2678 +586:2679 +587:2653 +587:2654 +587:2655 +587:2659 +587:2660 +587:2661 +587:2662 +587:2664 +587:2665 +587:2666 +595:2656 +595:2657 +595:2658 +597:2667 +597:2668 +598:2669 +598:2670 +598:2671 +598:2672 +598:2674 +598:2675 +599:2677 +601:2786 +601:2788 +601:2789 +601:2790 +601:2820 +601:2821 +602:2793 +602:2794 +602:2795 +602:2796 +602:2797 +602:2798 +602:2799 +602:2800 +602:2801 +602:2804 +602:2805 +602:2806 +602:2807 +602:2808 +602:2809 +602:2812 +602:2813 +602:2814 +602:2815 +602:2816 +602:2818 +604:2819 +605:2823 +605:2825 +605:2826 +605:2827 +605:2851 +605:2852 +606:2829 +606:2830 +606:2831 +606:2832 +606:2833 +606:2834 +606:2835 +606:2836 +606:2837 +606:2838 +606:2840 +606:2841 +607:2842 +607:2843 +607:2844 +607:2845 +607:2847 +607:2848 +608:2850 +611:2468 +611:2470 +611:2471 +611:2472 +611:2515 +611:2516 +613:2475 +613:2476 +613:2477 +613:2478 +613:2479 +613:2480 +613:2482 +613:2484 +613:2485 +613:2486 +613:2487 +613:2488 +613:2489 +613:2490 +613:2491 +613:2492 +613:2493 +613:2494 +613:2498 +613:2500 +613:2501 +613:2502 +613:2503 +615:2495 +615:2496 +615:2497 +617:2506 +617:2507 +617:2508 +617:2509 +617:2511 +617:2512 +618:2514 +620:2518 +620:2520 +620:2521 +620:2522 +620:2579 +620:2580 +621:2525 +621:2526 +621:2527 +621:2528 +621:2529 +621:2530 +621:2531 +621:2532 +621:2533 +621:2534 +621:2535 +621:2536 +621:2537 +621:2538 +621:2539 +621:2540 +621:2541 +621:2542 +621:2543 +621:2544 +621:2545 +621:2546 +621:2547 +621:2548 +621:2549 +621:2550 +621:2551 +621:2552 +621:2553 +621:2554 +621:2555 +621:2556 +621:2557 +621:2564 +621:2565 +621:2566 +621:2567 +621:2568 +622:2570 +622:2571 +622:2572 +622:2573 +622:2575 +622:2576 +623:2578 +625:2582 +625:2584 +625:2585 +625:2586 +625:2643 +625:2644 +626:2589 +626:2590 +626:2591 +626:2592 +626:2593 +626:2594 +626:2595 +626:2596 +626:2597 +626:2598 +626:2599 +626:2600 +626:2601 +626:2602 +626:2603 +626:2604 +626:2605 +626:2606 +626:2607 +626:2608 +626:2609 +626:2610 +626:2611 +626:2612 +626:2613 +626:2614 +626:2615 +626:2616 +626:2617 +626:2618 +626:2619 +626:2620 +626:2621 +626:2628 +626:2629 +626:2630 +626:2631 +626:2632 +627:2634 +627:2635 +627:2636 +627:2637 +627:2639 +627:2640 +628:2642 +631:2681 +631:2683 +631:2684 +631:2685 +631:2783 +631:2784 +632:2687 +632:2688 +632:2689 +632:2690 +632:2691 +632:2692 +633:2693 +633:2694 +633:2695 +633:2696 +633:2697 +633:2698 +633:2699 +633:2700 +633:2701 +633:2702 +633:2704 +633:2705 +634:2707 +634:2708 +634:2709 +634:2710 +634:2711 +634:2776 +634:2777 +634:2778 +634:2779 +634:2780 +635:2782 +637:2908 +637:2910 +637:2911 +637:2912 +637:2921 +637:2922 +638:2914 +638:2915 +638:2916 +638:2917 +638:2918 +638:2919 +638:2920 +642:2888 +642:2890 +642:2891 +642:2892 +642:2905 +642:2906 +643:2894 +643:2895 +643:2896 +643:2897 +643:2898 +643:2899 +643:2900 +643:2901 +643:2902 +643:2903 +643:2904 +682:2368 +682:2370 +682:2371 +682:2372 +682:2385 +682:2386 +683:2374 +683:2375 +684:2376 +684:2377 +684:2378 +684:2379 +684:2381 +684:2382 +685:2384 +689:2854 +689:2856 +689:2857 +689:2858 +689:2885 +689:2886 +690:2860 +690:2861 +690:2862 +690:2863 +690:2864 +690:2865 +690:2866 +690:2867 +690:2868 +690:2869 +690:2870 +690:2871 +690:2872 +690:2874 +690:2875 +691:2876 +691:2877 +691:2878 +691:2879 +691:2881 +691:2882 +692:2884 +696:2924 +696:2926 +696:2927 +696:2928 +696:3071 +696:3072 +697:2930 +697:2931 +698:2933 +698:2934 +698:2935 +698:2936 +698:2937 +698:2938 +698:2939 +698:2940 +698:2941 +698:2942 +698:2943 +698:2944 +698:2945 +698:2946 +698:2948 +698:2949 +698:2950 +698:2951 +698:2952 +698:2953 +698:2954 +698:3045 +698:3046 +698:3047 +698:3048 +698:3049 +698:3064 +698:3065 +698:3066 +698:3067 +698:3068 +699:2957 +699:2958 +699:2959 +699:2960 +699:2961 +699:2962 +699:3070 +700:2965 +700:2966 +700:2967 +700:2968 +700:2969 +700:2970 +701:2973 +701:2974 +701:2975 +701:2976 +701:2977 +701:2978 +702:2981 +702:2982 +702:2983 +702:2984 +702:2985 +702:2986 +703:2989 +703:2990 +703:2991 +703:2992 +703:2993 +703:2994 +704:2997 +704:2998 +704:2999 +704:3000 +704:3001 +704:3002 +705:3005 +705:3006 +705:3007 +705:3008 +705:3009 +705:3010 +706:3013 +706:3014 +706:3015 +706:3016 +706:3017 +706:3018 +707:3021 +707:3022 +707:3023 +707:3024 +707:3025 +707:3026 +708:3029 +708:3030 +708:3031 +708:3032 +708:3033 +708:3034 +709:3037 +709:3038 +709:3039 +709:3040 +709:3041 +709:3042 +711:3051 +711:3052 +717:3074 +717:3076 +717:3077 +717:3078 +717:3125 +717:3126 +718:3080 +718:3081 +719:3083 +719:3084 +719:3085 +719:3086 +719:3087 +719:3088 +719:3089 +719:3090 +719:3091 +719:3092 +719:3093 +719:3094 +719:3118 +719:3119 +719:3120 +719:3121 +719:3122 +720:3124 +724:3128 +724:3130 +724:3131 +724:3132 +724:3154 +724:3155 +725:3134 +725:3135 +725:3136 +725:3137 +725:3138 +725:3139 +725:3140 +725:3141 +725:3142 +725:3143 +725:3144 +725:3145 +725:3146 +725:3147 +725:3148 +725:3149 +725:3151 +725:3152 +725:3153 +730:3157 +730:3159 +730:3160 +730:3161 +730:3183 +730:3184 +731:3163 +731:3164 +731:3165 +731:3166 +731:3167 +731:3168 +731:3169 +731:3170 +731:3171 +731:3172 +731:3173 +731:3174 +731:3175 +731:3176 +731:3177 +731:3178 +731:3180 +731:3181 +731:3182 +736:3186 +736:3188 +736:3189 +736:3190 +736:3212 +736:3213 +737:3192 +737:3193 +737:3194 +737:3195 +737:3196 +737:3197 +737:3198 +737:3199 +737:3200 +737:3201 +737:3202 +737:3203 +737:3204 +737:3205 +737:3206 +737:3207 +737:3209 +737:3210 +737:3211 +742:3215 +742:3217 +742:3218 +742:3219 +742:3241 +742:3242 +743:3221 +743:3222 +743:3223 +743:3224 +743:3225 +743:3226 +743:3227 +743:3228 +743:3229 +743:3230 +743:3231 +743:3232 +743:3233 +743:3234 +743:3235 +743:3236 +743:3238 +743:3239 +743:3240 +748:3244 +748:3246 +748:3247 +748:3248 +748:3270 +748:3271 +749:3250 +749:3251 +749:3252 +749:3253 +749:3254 +749:3255 +749:3256 +749:3257 +749:3258 +749:3259 +749:3260 +749:3261 +749:3262 +749:3263 +749:3264 +749:3265 +749:3267 +749:3268 +749:3269 +754:3273 +754:3275 +754:3276 +754:3277 +754:3319 +754:3320 +755:3279 +755:3280 +755:3281 +755:3282 +755:3283 +755:3284 +755:3286 +755:3287 +755:3288 +755:3289 +755:3290 +755:3291 +755:3292 +755:3295 +755:3296 +755:3297 +755:3298 +755:3299 +755:3300 +755:3303 +755:3304 +755:3305 +755:3306 +755:3307 +755:3309 +755:3310 +755:3311 +755:3312 +755:3313 +755:3314 +755:3316 +755:3317 +755:3318 +760:3322 +760:3324 +760:3325 +760:3326 +760:3435 +760:3436 +761:3328 +761:3329 +762:3331 +762:3332 +762:3333 +762:3334 +762:3335 +762:3336 +762:3337 +762:3338 +762:3339 +762:3340 +762:3341 +762:3342 +762:3343 +762:3344 +762:3345 +762:3346 +762:3347 +762:3348 +762:3349 +762:3350 +762:3351 +762:3352 +762:3353 +762:3354 +762:3355 +762:3356 +762:3357 +762:3358 +762:3359 +762:3360 +762:3361 +762:3362 +762:3363 +762:3364 +762:3365 +762:3366 +762:3368 +762:3369 +762:3370 +762:3371 +762:3372 +762:3373 +762:3374 +762:3401 +762:3402 +762:3403 +762:3404 +762:3405 +762:3409 +762:3410 +762:3411 +762:3412 +762:3414 +762:3415 +762:3428 +762:3429 +762:3430 +762:3431 +762:3432 +763:3377 +763:3378 +763:3379 +763:3380 +763:3381 +763:3382 +763:3434 +764:3385 +764:3386 +764:3387 +764:3388 +764:3389 +764:3390 +765:3393 +765:3394 +765:3395 +765:3396 +765:3397 +765:3398 +767:3407 +767:3408 +769:3418 +769:3419 +769:3420 +769:3421 +769:3422 +769:3423 +769:3424 +769:3425 +775:3438 +775:3440 +775:3441 +775:3442 +775:3492 +775:3493 +776:3444 +776:3445 +776:3446 +776:3447 +776:3448 +776:3449 +776:3451 +776:3452 +776:3453 +776:3454 +776:3455 +776:3456 +776:3457 +776:3460 +776:3461 +776:3462 +776:3463 +776:3464 +776:3465 +776:3468 +776:3469 +776:3470 +776:3471 +776:3472 +776:3473 +776:3476 +776:3477 +776:3478 +776:3479 +776:3480 +776:3482 +776:3483 +776:3484 +776:3485 +776:3486 +776:3487 +776:3489 +776:3490 +776:3491 +781:3495 +781:3497 +781:3498 +781:3499 +781:3541 +781:3542 +782:3501 +782:3502 +782:3503 +782:3504 +782:3505 +782:3506 +782:3508 +782:3509 +782:3510 +782:3511 +782:3512 +782:3513 +782:3514 +782:3517 +782:3518 +782:3519 +782:3520 +782:3521 +782:3522 +782:3525 +782:3526 +782:3527 +782:3528 +782:3529 +782:3531 +782:3532 +782:3533 +782:3534 +782:3535 +782:3536 +782:3538 +782:3539 +782:3540 +787:3544 +787:3546 +787:3547 +787:3548 +787:3598 +787:3599 +788:3550 +788:3551 +788:3552 +788:3553 +788:3554 +788:3555 +788:3557 +788:3558 +788:3559 +788:3560 +788:3561 +788:3562 +788:3563 +788:3566 +788:3567 +788:3568 +788:3569 +788:3570 +788:3571 +788:3574 +788:3575 +788:3576 +788:3577 +788:3578 +788:3579 +788:3582 +788:3583 +788:3584 +788:3585 +788:3586 +788:3588 +788:3589 +788:3590 +788:3591 +788:3592 +788:3593 +788:3595 +788:3596 +788:3597 +791:3601 +791:3603 +791:3604 +791:3605 +791:3607 +791:3689 +791:3690 +791:3691 +791:3692 +791:3693 +791:3694 +791:3695 +792:3608 +792:3609 +792:3610 +792:3611 +792:3612 +792:3613 +792:3614 +792:3615 +792:3616 +793:3619 +793:3620 +793:3621 +793:3622 +793:3623 +793:3624 +793:3625 +793:3626 +793:3627 +794:3630 +794:3631 +794:3632 +794:3633 +794:3634 +794:3635 +794:3636 +794:3637 +794:3639 +794:3640 +794:3641 +795:3644 +795:3645 +795:3646 +795:3647 +795:3648 +795:3649 +795:3650 +795:3651 +795:3653 +795:3654 +795:3655 +796:3658 +796:3659 +796:3660 +796:3661 +796:3662 +796:3663 +796:3664 +796:3665 +796:3666 +796:3667 +796:3668 +796:3669 +796:3670 +796:3671 +796:3672 +796:3673 +796:3674 +796:3675 +796:3676 +796:3677 +796:3678 +796:3679 +796:3680 +796:3681 +796:3682 +796:3683 +796:3684 +796:3685 +796:3686 +799:3697 +799:3699 +799:3700 +799:3701 +799:3707 +799:3815 +799:3816 +799:3817 +799:3818 +799:3819 +799:3820 +799:3821 +800:3708 +800:3709 +800:3710 +800:3711 +800:3712 +800:3713 +800:3714 +800:3715 +800:3716 +801:3719 +801:3720 +801:3721 +801:3722 +801:3723 +801:3724 +801:3725 +801:3726 +801:3727 +803:3730 +803:3731 +803:3732 +803:3733 +803:3734 +803:3735 +803:3736 +803:3737 +803:3738 +803:3739 +803:3740 +803:3741 +803:3742 +803:3743 +803:3744 +803:3745 +803:3746 +803:3747 +803:3748 +803:3749 +803:3750 +803:3751 +803:3752 +803:3753 +803:3768 +803:3802 +803:3806 +803:3807 +803:3808 +803:3809 +803:3810 +804:3812 +811:3702 +811:3703 +811:3755 +811:3756 +811:3757 +811:3758 +811:3759 +811:3760 +811:3761 +811:3763 +811:3764 +811:3765 +812:3766 +812:3767 +817:3769 +817:3770 +817:3771 +817:3772 +817:3773 +817:3774 +817:3775 +817:3777 +817:3778 +817:3779 +817:3780 +817:3782 +817:3783 +817:3784 +817:3785 +817:3786 +817:3787 +817:3788 +817:3789 +818:3704 +818:3705 +818:3790 +818:3791 +818:3792 +818:3793 +818:3794 +818:3795 +818:3797 +818:3798 +818:3799 +819:3800 +819:3801 +821:3803 +821:3804 +821:3805 +826:3823 +826:3825 +826:3826 +826:3827 +826:4145 +826:4146 +836:3841 +836:3842 +838:3843 +838:3844 +838:3845 +838:3923 +838:3933 +838:4045 +838:4053 +838:4065 +838:4066 +838:4067 +838:4068 +838:4070 +838:4071 +848:3846 +848:3847 +848:3848 +848:3849 +848:3850 +848:3851 +848:3852 +848:3853 +848:3854 +849:3828 +849:3829 +849:3856 +849:3857 +849:3858 +849:3859 +849:3860 +849:3861 +849:3862 +849:3863 +849:3864 +849:3917 +849:3918 +849:3919 +849:3920 +849:3921 +850:3866 +850:3867 +851:3868 +853:3924 +853:3925 +853:3926 +853:3927 +853:3928 +853:3929 +853:3930 +853:3931 +853:3932 +855:3934 +855:3935 +855:3936 +855:3937 +855:3938 +855:3939 +855:3940 +855:3941 +855:3942 +856:3944 +856:4039 +856:4040 +856:4041 +856:4042 +856:4043 +857:3830 +857:3831 +857:3945 +857:3946 +857:3947 +857:3948 +857:3949 +857:3950 +857:3951 +857:3952 +857:3953 +858:3954 +858:3955 +859:3959 +859:3960 +859:3961 +859:3962 +859:3963 +859:3964 +859:3965 +859:3966 +859:3967 +859:3968 +860:3832 +860:3833 +860:3970 +860:3971 +860:3972 +860:3973 +860:3974 +860:3975 +860:3976 +860:3977 +860:3978 +860:4031 +860:4032 +860:4033 +860:4034 +860:4035 +861:3980 +861:3981 +862:3982 +865:4046 +865:4047 +865:4048 +865:4049 +865:4050 +865:4051 +865:4052 +866:3834 +866:3835 +866:4054 +866:4055 +866:4056 +866:4057 +866:4058 +866:4059 +866:4060 +866:4062 +866:4063 +866:4064 +869:4073 +869:4138 +869:4139 +869:4140 +869:4141 +869:4142 +870:4144 +871:3836 +871:3837 +871:4074 +871:4075 +871:4076 +871:4077 +871:4078 +871:4079 +871:4080 +871:4081 +872:3838 +872:3839 +872:4085 +872:4086 +872:4087 +872:4088 +872:4089 +872:4090 +872:4091 +872:4092 +877:4148 +877:4150 +877:4151 +877:4152 +877:4156 +877:4297 +877:4298 +877:4299 +877:4300 +877:4301 +877:4302 +877:4303 +878:4157 +878:4158 +878:4159 +878:4160 +878:4162 +878:4163 +878:4164 +878:4165 +878:4166 +878:4167 +878:4168 +878:4169 +878:4170 +878:4171 +878:4173 +878:4174 +878:4175 +878:4176 +879:4179 +879:4182 +879:4183 +879:4184 +879:4185 +879:4186 +879:4187 +879:4188 +879:4189 +879:4190 +879:4191 +880:4194 +880:4195 +880:4196 +880:4197 +880:4198 +880:4199 +880:4200 +881:4203 +881:4204 +881:4205 +881:4206 +881:4207 +881:4208 +881:4209 +882:4212 +882:4213 +882:4214 +882:4215 +882:4216 +882:4217 +882:4218 +883:4221 +883:4222 +883:4223 +883:4224 +883:4225 +884:4228 +884:4229 +884:4230 +884:4231 +884:4232 +884:4233 +884:4234 +885:4237 +885:4238 +885:4239 +885:4240 +885:4241 +885:4242 +885:4243 +886:4246 +886:4247 +886:4248 +886:4249 +886:4250 +886:4251 +888:4252 +888:4255 +888:4256 +888:4257 +888:4258 +888:4259 +888:4260 +888:4261 +888:4262 +888:4263 +888:4264 +888:4265 +888:4266 +889:4153 +889:4154 +889:4267 +889:4268 +889:4269 +889:4270 +889:4271 +889:4272 +889:4273 +889:4274 +889:4275 +889:4276 +889:4278 +889:4279 +889:4280 +889:4281 +889:4282 +889:4284 +889:4285 +890:4286 +890:4287 +890:4288 +890:4289 +890:4290 +890:4291 +890:4292 +890:4293 +890:4294 +897:4512 +897:4516 +897:4518 +897:4519 +897:4520 +897:4595 +897:4596 +898:4513 +898:4526 +898:4527 +898:4528 +898:4529 +899:4514 +899:4530 +899:4531 +899:4532 +899:4542 +899:4543 +899:4544 +899:4545 +899:4547 +899:4548 +900:4515 +905:4533 +905:4534 +905:4535 +905:4536 +905:4537 +905:4538 +905:4539 +905:4540 +905:4541 +907:4563 +907:4586 +907:4588 +907:4589 +907:4590 +907:4591 +908:4594 +915:4521 +915:4522 +915:4550 +915:4552 +915:4553 +915:4554 +915:4555 +915:4556 +915:4557 +915:4559 +915:4560 +915:4561 +916:4564 +916:4566 +916:4567 +916:4568 +916:4578 +916:4579 +916:4580 +916:4581 +916:4583 +916:4584 +916:4585 +917:4523 +917:4524 +917:4569 +917:4570 +917:4571 +917:4572 +917:4573 +917:4574 +917:4575 +917:4577 +971:4305 +971:4354 +971:4356 +971:4357 +971:4358 +971:4509 +971:4510 +972:4306 +972:4360 +972:4361 +972:4362 +972:4363 +972:4364 +972:4365 +973:4307 +973:4367 +973:4368 +973:4369 +973:4370 +973:4371 +973:4372 +973:4373 +973:4375 +973:4376 +973:4377 +973:4378 +973:4379 +973:4428 +973:4429 +973:4430 +973:4431 +973:4432 +973:4502 +973:4503 +973:4504 +973:4505 +973:4506 +974:4308 +974:4508 +975:4309 +976:4310 +977:4311 +978:4312 +979:4313 +980:4314 +981:4315 +982:4316 +983:4317 +983:4436 +983:4437 +983:4438 +983:4439 +983:4441 +983:4442 +983:4443 +983:4444 +983:4445 +983:4494 +983:4495 +983:4496 +983:4497 +983:4498 +984:4318 +985:4319 +986:4320 +987:2082 +987:2084 +987:2085 +987:2086 +987:2143 +987:2144 +987:4321 +988:2089 +988:2090 +988:2091 +988:2092 +988:2093 +988:2094 +988:2095 +988:2096 +988:2097 +988:2098 +988:2099 +988:2100 +988:2101 +988:2102 +988:2103 +988:2104 +988:2105 +988:2106 +988:2107 +988:2108 +988:2109 +988:2110 +988:2111 +988:2112 +988:2113 +988:2114 +988:2115 +988:2116 +988:2117 +988:2118 +988:2119 +988:2120 +988:2121 +988:2136 +988:2137 +988:2138 +988:2139 +988:2140 +988:4322 +989:2142 +989:4323 +990:2124 +990:2125 +990:2126 +990:2127 +990:2128 +990:2129 +990:2131 +990:2132 +990:4324 +991:4325 +992:4326 +993:4327 +994:4328 +994:4667 +994:4669 +994:4670 +994:4671 +994:4743 +994:4744 +995:4329 +995:4676 +995:4677 +995:4678 +995:4734 +995:4735 +995:4736 +995:4737 +995:4739 +995:4740 +995:4741 +995:4742 +996:4330 +997:4331 +998:4332 +999:4333 +1000:4334 +1001:4335 +1002:4336 +1003:4337 +1004:4338 +1005:4339 +1005:4672 +1005:4673 +1005:4679 +1005:4680 +1005:4681 +1005:4682 +1005:4683 +1005:4684 +1005:4685 +1006:4340 +1006:4688 +1006:4689 +1006:4690 +1006:4691 +1006:4692 +1006:4693 +1006:4694 +1006:4695 +1006:4696 +1006:4697 +1006:4698 +1006:4699 +1006:4700 +1006:4701 +1006:4702 +1006:4703 +1006:4704 +1006:4705 +1006:4706 +1006:4707 +1006:4708 +1006:4709 +1006:4710 +1006:4711 +1006:4712 +1006:4713 +1006:4714 +1006:4715 +1006:4716 +1006:4717 +1006:4718 +1006:4719 +1006:4720 +1006:4727 +1006:4728 +1006:4729 +1006:4730 +1006:4731 +1007:4341 +1007:4733 +1008:4342 +1009:4343 +1010:4344 +1011:4345 +1011:4598 +1011:4600 +1011:4601 +1011:4602 +1011:4604 +1011:4659 +1011:4660 +1011:4661 +1011:4662 +1011:4663 +1011:4664 +1011:4665 +1012:4346 +1012:4605 +1012:4606 +1012:4607 +1012:4608 +1012:4609 +1012:4610 +1013:4347 +1013:4614 +1013:4615 +1013:4616 +1013:4617 +1013:4618 +1013:4619 +1014:4348 +1014:4611 +1014:4623 +1014:4624 +1014:4625 +1014:4626 +1014:4627 +1014:4628 +1015:4349 +1015:4620 +1015:4632 +1015:4633 +1015:4634 +1015:4635 +1015:4636 +1015:4637 +1016:4350 +1016:4629 +1016:4641 +1016:4642 +1016:4643 +1016:4644 +1016:4645 +1016:4646 +1017:4351 +1017:4638 +1017:4650 +1017:4651 +1017:4652 +1017:4653 +1017:4654 +1017:4655 +1018:4352 +1018:4647 +1019:4353 +1019:4656 +*E diff --git a/app/preproc/PdeLexer.smap b/app/preproc/PdeLexer.smap new file mode 100644 index 000000000..f3ff35ac1 --- /dev/null +++ b/app/preproc/PdeLexer.smap @@ -0,0 +1,1236 @@ +SMAP +PdeLexer.java +G +*S G +*F ++ 0 expandedpde.g +expandedpde.g +*L +0:114 +0:120 +0:126 +0:132 +0:138 +0:144 +0:150 +0:156 +0:162 +0:168 +0:174 +0:180 +0:186 +0:192 +0:198 +0:217 +0:225 +0:231 +0:235 +0:239 +0:243 +0:247 +0:251 +0:255 +0:259 +0:263 +0:267 +0:271 +0:275 +0:279 +0:283 +0:287 +0:291 +0:295 +0:299 +0:303 +0:307 +0:311 +0:315 +0:319 +0:323 +0:327 +0:331 +0:335 +0:339 +0:343 +0:347 +0:351 +0:355 +0:359 +0:363 +0:367 +0:371 +1:3 +1:5 +819:399 +819:400 +819:401 +819:402 +819:405 +819:406 +819:407 +819:408 +819:409 +819:410 +819:411 +819:444 +819:445 +819:446 +819:447 +819:448 +819:449 +819:450 +819:451 +819:452 +819:453 +819:454 +819:455 +819:456 +819:457 +820:414 +820:415 +820:416 +821:419 +821:420 +821:421 +823:424 +823:425 +823:429 +823:432 +823:435 +823:436 +823:437 +823:438 +824:427 +824:428 +825:430 +825:431 +826:433 +826:434 +828:441 +832:459 +832:460 +832:461 +832:462 +832:464 +832:506 +832:507 +832:508 +832:509 +832:510 +832:511 +833:465 +833:466 +833:467 +833:468 +833:470 +833:472 +833:473 +833:474 +833:475 +833:477 +833:478 +833:480 +833:481 +833:482 +833:483 +833:486 +833:487 +833:488 +833:490 +833:491 +833:492 +833:494 +833:499 +833:500 +833:501 +833:502 +833:503 +834:505 +837:513 +837:514 +837:515 +837:516 +837:518 +837:550 +837:551 +837:552 +837:553 +837:554 +837:555 +838:519 +838:520 +838:521 +838:526 +838:529 +838:533 +838:537 +838:542 +838:543 +838:544 +838:545 +838:547 +838:548 +849:527 +849:528 +850:522 +850:523 +850:524 +850:525 +851:530 +851:531 +851:532 +852:534 +852:535 +852:536 +853:538 +853:540 +855:549 +858:557 +858:558 +858:559 +858:560 +858:562 +858:563 +858:564 +858:566 +858:567 +858:568 +858:569 +858:570 +858:571 +858:572 +858:573 +858:574 +858:576 +858:577 +858:578 +858:579 +858:580 +858:581 +858:582 +858:583 +858:584 +862:625 +862:626 +862:627 +862:628 +862:630 +862:631 +862:632 +862:633 +862:634 +862:635 +862:636 +865:638 +865:639 +865:640 +865:641 +865:643 +865:644 +865:645 +865:646 +865:647 +865:648 +865:649 +868:651 +868:652 +868:653 +868:654 +868:656 +868:657 +868:658 +868:659 +868:660 +868:661 +868:662 +871:664 +871:665 +871:666 +871:667 +871:669 +871:670 +871:671 +871:672 +871:673 +871:674 +871:675 +874:677 +874:678 +874:679 +874:680 +874:682 +874:683 +874:684 +874:685 +874:686 +874:687 +874:688 +877:690 +877:691 +877:692 +877:693 +877:695 +877:696 +877:697 +877:698 +877:699 +877:700 +877:701 +880:703 +880:704 +880:705 +880:706 +880:708 +880:709 +880:710 +880:711 +880:712 +880:713 +880:714 +883:716 +883:717 +883:718 +883:719 +883:721 +883:722 +883:723 +883:724 +883:725 +883:726 +883:727 +886:729 +886:730 +886:731 +886:732 +886:734 +886:735 +886:736 +886:737 +886:738 +886:739 +886:740 +889:742 +889:743 +889:744 +889:745 +889:747 +889:748 +889:749 +889:750 +889:751 +889:752 +889:753 +892:755 +892:756 +892:757 +892:758 +892:760 +892:761 +892:762 +892:763 +892:764 +892:765 +892:766 +895:768 +895:769 +895:770 +895:771 +895:773 +895:774 +895:775 +895:776 +895:777 +895:778 +895:779 +898:781 +898:782 +898:783 +898:784 +898:786 +898:787 +898:788 +898:789 +898:790 +898:791 +898:792 +901:794 +901:795 +901:796 +901:797 +901:799 +901:800 +901:801 +901:802 +901:803 +901:804 +901:805 +904:807 +904:808 +904:809 +904:810 +904:812 +904:813 +904:814 +904:815 +904:816 +904:817 +904:818 +907:820 +907:821 +907:822 +907:823 +907:825 +907:826 +907:827 +907:828 +907:829 +907:830 +907:831 +910:833 +910:834 +910:835 +910:836 +910:838 +910:839 +910:840 +910:841 +910:842 +910:843 +910:844 +913:846 +913:847 +913:848 +913:849 +913:851 +913:852 +913:853 +913:854 +913:855 +913:856 +913:857 +916:859 +916:860 +916:861 +916:862 +916:864 +916:865 +916:866 +916:867 +916:868 +916:869 +916:870 +919:872 +919:873 +919:874 +919:875 +919:877 +919:878 +919:879 +919:880 +919:881 +919:882 +919:883 +922:885 +922:886 +922:887 +922:888 +922:890 +922:891 +922:892 +922:893 +922:894 +922:895 +922:896 +925:898 +925:899 +925:900 +925:901 +925:903 +925:904 +925:905 +925:906 +925:907 +925:908 +925:909 +928:911 +928:912 +928:913 +928:914 +928:916 +928:917 +928:918 +928:919 +928:920 +928:921 +928:922 +931:924 +931:925 +931:926 +931:927 +931:929 +931:930 +931:931 +931:932 +931:933 +931:934 +931:935 +934:937 +934:938 +934:939 +934:940 +934:942 +934:943 +934:944 +934:945 +934:946 +934:947 +934:948 +937:950 +937:951 +937:952 +937:953 +937:955 +937:956 +937:957 +937:958 +937:959 +937:960 +937:961 +940:963 +940:964 +940:965 +940:966 +940:968 +940:969 +940:970 +940:971 +940:972 +940:973 +940:974 +943:976 +943:977 +943:978 +943:979 +943:981 +943:982 +943:983 +943:984 +943:985 +943:986 +943:987 +946:989 +946:990 +946:991 +946:992 +946:994 +946:995 +946:996 +946:997 +946:998 +946:999 +946:1000 +949:1002 +949:1003 +949:1004 +949:1005 +949:1007 +949:1008 +949:1009 +949:1010 +949:1011 +949:1012 +949:1013 +952:1015 +952:1016 +952:1017 +952:1018 +952:1020 +952:1021 +952:1022 +952:1023 +952:1024 +952:1025 +952:1026 +955:1028 +955:1029 +955:1030 +955:1031 +955:1033 +955:1034 +955:1035 +955:1036 +955:1037 +955:1038 +955:1039 +958:1041 +958:1042 +958:1043 +958:1044 +958:1046 +958:1047 +958:1048 +958:1049 +958:1050 +958:1051 +958:1052 +961:1054 +961:1055 +961:1056 +961:1057 +961:1059 +961:1060 +961:1061 +961:1062 +961:1063 +961:1064 +961:1065 +964:1067 +964:1068 +964:1069 +964:1070 +964:1072 +964:1073 +964:1074 +964:1075 +964:1076 +964:1077 +964:1078 +967:1080 +967:1081 +967:1082 +967:1083 +967:1085 +967:1086 +967:1087 +967:1088 +967:1089 +967:1090 +967:1091 +970:1093 +970:1094 +970:1095 +970:1096 +970:1098 +970:1099 +970:1100 +970:1101 +970:1102 +970:1103 +970:1104 +973:1106 +973:1107 +973:1108 +973:1109 +973:1111 +973:1112 +973:1113 +973:1114 +973:1115 +973:1116 +973:1117 +976:1119 +976:1120 +976:1121 +976:1122 +976:1124 +976:1125 +976:1126 +976:1127 +976:1128 +976:1129 +976:1130 +979:1132 +979:1133 +979:1134 +979:1135 +979:1137 +979:1138 +979:1139 +979:1140 +979:1141 +979:1142 +979:1143 +982:1145 +982:1146 +982:1147 +982:1148 +982:1150 +982:1151 +982:1152 +982:1153 +982:1154 +982:1155 +982:1156 +985:1158 +985:1159 +985:1160 +985:1161 +985:1163 +985:1164 +985:1165 +985:1166 +985:1167 +985:1168 +985:1169 +988:1171 +988:1172 +988:1173 +988:1174 +988:1176 +988:1177 +988:1178 +988:1179 +988:1180 +988:1181 +988:1182 +991:1184 +991:1185 +991:1186 +991:1187 +991:1189 +991:1190 +991:1191 +991:1192 +991:1193 +991:1194 +991:1195 +994:1197 +994:1198 +994:1199 +994:1200 +994:1202 +994:1203 +994:1204 +994:1205 +994:1206 +994:1207 +994:1208 +997:1210 +997:1211 +997:1212 +997:1213 +997:1215 +997:1217 +997:1218 +997:1219 +997:1220 +997:1221 +997:1222 +997:1223 +997:1224 +997:1225 +997:1228 +997:1229 +997:1230 +997:1231 +997:1232 +997:1233 +997:1234 +1001:1362 +1001:1363 +1001:1364 +1001:1365 +1001:1367 +1001:1368 +1001:1369 +1001:1370 +1001:1371 +1001:1372 +1001:1373 +1001:1374 +1001:1376 +1001:1378 +1001:1379 +1001:1380 +1001:1381 +1001:1383 +1001:1384 +1001:1385 +1001:1386 +1001:1387 +1001:1388 +1001:1389 +1001:1390 +1001:1391 +1005:1236 +1005:1237 +1005:1238 +1005:1239 +1005:1241 +1005:1355 +1005:1356 +1005:1357 +1005:1358 +1005:1359 +1005:1360 +1006:1243 +1006:1244 +1006:1245 +1006:1246 +1006:1349 +1006:1350 +1006:1351 +1006:1352 +1006:1353 +1007:1249 +1007:1250 +1007:1251 +1008:1254 +1008:1255 +1008:1256 +1009:1259 +1009:1260 +1009:1261 +1010:1264 +1010:1265 +1010:1266 +1011:1269 +1011:1270 +1011:1271 +1012:1274 +1012:1275 +1012:1276 +1013:1279 +1013:1280 +1013:1281 +1014:1284 +1014:1285 +1014:1287 +1014:1288 +1014:1289 +1014:1290 +1014:1291 +1014:1292 +1014:1293 +1014:1294 +1014:1295 +1014:1297 +1014:1298 +1014:1299 +1014:1300 +1014:1301 +1014:1302 +1014:1303 +1015:1306 +1015:1307 +1015:1308 +1016:1323 +1016:1325 +1016:1326 +1016:1327 +1016:1328 +1020:1310 +1020:1311 +1021:1315 +1021:1317 +1021:1318 +1021:1319 +1021:1320 +1025:1313 +1025:1314 +1028:1333 +1028:1334 +1028:1335 +1029:1339 +1029:1341 +1029:1342 +1029:1343 +1029:1344 +1033:1337 +1033:1338 +1039:586 +1039:587 +1039:588 +1039:589 +1039:592 +1039:593 +1039:594 +1039:595 +1039:596 +1039:597 +1039:600 +1039:601 +1039:602 +1039:603 +1039:606 +1039:607 +1039:608 +1039:609 +1039:612 +1039:613 +1039:614 +1039:615 +1039:616 +1039:618 +1039:619 +1039:620 +1039:621 +1039:622 +1039:623 +1043:1393 +1043:1394 +1043:1395 +1043:1396 +1043:1398 +1043:1399 +1043:1400 +1043:1401 +1043:1402 +1043:1403 +1043:1404 +1047:1406 +1047:1407 +1047:1408 +1047:1409 +1047:1501 +1047:1502 +1047:1503 +1047:1504 +1047:1505 +1047:1506 +1047:1507 +1051:1412 +1051:1413 +1051:1414 +1051:1415 +1051:1416 +1051:1417 +1051:1418 +1051:1419 +1051:1420 +1051:1421 +1051:1424 +1051:1425 +1051:1426 +1051:1427 +1051:1428 +1051:1429 +1051:1430 +1051:1431 +1051:1432 +1051:1435 +1051:1436 +1051:1437 +1051:1440 +1051:1441 +1051:1442 +1051:1445 +1051:1446 +1051:1447 +1051:1448 +1051:1449 +1051:1451 +1051:1452 +1051:1453 +1051:1454 +1051:1455 +1051:1456 +1051:1457 +1051:1458 +1051:1459 +1051:1460 +1051:1461 +1051:1462 +1051:1463 +1051:1466 +1051:1467 +1051:1468 +1051:1469 +1051:1470 +1051:1471 +1051:1472 +1051:1473 +1051:1474 +1051:1477 +1051:1478 +1051:1479 +1051:1482 +1051:1483 +1051:1484 +1051:1485 +1051:1486 +1051:1489 +1051:1490 +1051:1491 +1051:1494 +1051:1495 +1051:1496 +1051:1497 +1051:1498 +1051:1499 +1051:1500 +1055:1509 +1055:1510 +1055:1511 +1055:1512 +1055:1517 +1055:1519 +1055:1778 +1055:1779 +1055:1780 +1055:1781 +1055:1782 +1055:1783 +1055:1784 +1055:1785 +1055:1786 +1055:1787 +1055:1788 +1056:1520 +1056:1521 +1056:1522 +1056:1523 +1057:1513 +1057:1525 +1057:1527 +1057:1528 +1057:1529 +1057:1530 +1057:1531 +1057:1532 +1057:1533 +1057:1534 +1057:1535 +1057:1537 +1057:1538 +1057:1539 +1057:1541 +1057:1542 +1057:1543 +1057:1545 +1057:1549 +1057:1550 +1057:1551 +1057:1552 +1057:1553 +1057:1555 +1057:1566 +1057:1568 +1059:1559 +1060:1560 +1061:1561 +1062:1562 +1063:1563 +1064:1564 +1068:1573 +1068:1574 +1068:1575 +1068:1576 +1068:1578 +1068:1579 +1068:1580 +1068:1581 +1068:1582 +1068:1669 +1068:1670 +1068:1671 +1068:1672 +1068:1673 +1069:1584 +1069:1585 +1069:1586 +1069:1588 +1069:1589 +1069:1590 +1069:1591 +1069:1594 +1069:1595 +1069:1596 +1069:1599 +1069:1600 +1069:1601 +1069:1602 +1069:1603 +1069:1640 +1069:1642 +1069:1643 +1070:1606 +1070:1607 +1070:1608 +1070:1611 +1070:1612 +1070:1613 +1070:1614 +1070:1616 +1070:1617 +1070:1618 +1079:1609 +1079:1610 +1081:1621 +1081:1622 +1081:1623 +1081:1625 +1081:1626 +1081:1627 +1081:1628 +1081:1629 +1081:1630 +1081:1631 +1081:1632 +1081:1633 +1081:1635 +1081:1636 +1081:1637 +1083:1647 +1083:1648 +1083:1649 +1083:1650 +1083:1652 +1083:1654 +1083:1655 +1083:1656 +1083:1657 +1083:1658 +1083:1659 +1083:1660 +1083:1661 +1083:1662 +1083:1664 +1083:1665 +1083:1666 +1085:1676 +1085:1678 +1085:1679 +1085:1680 +1085:1681 +1085:1684 +1085:1685 +1085:1686 +1085:1689 +1085:1690 +1085:1691 +1085:1692 +1085:1693 +1085:1695 +1085:1696 +1085:1771 +1085:1773 +1089:1514 +1089:1697 +1089:1699 +1089:1700 +1089:1701 +1089:1702 +1089:1703 +1089:1704 +1089:1705 +1089:1706 +1089:1707 +1089:1708 +1089:1709 +1089:1710 +1089:1711 +1089:1713 +1089:1714 +1089:1716 +1089:1717 +1089:1718 +1089:1720 +1089:1724 +1089:1725 +1089:1726 +1089:1727 +1089:1728 +1089:1730 +1089:1757 +1089:1758 +1089:1759 +1089:1760 +1089:1761 +1090:1515 +1090:1735 +1090:1736 +1090:1737 +1090:1739 +1090:1740 +1090:1741 +1090:1742 +1090:1743 +1090:1745 +1091:1516 +1091:1750 +1091:1751 +1091:1752 +1091:1753 +1091:1754 +1094:1764 +1095:1765 +1096:1766 +1097:1767 +1098:1768 +1099:1769 +1105:1790 +1105:1791 +1105:1792 +1105:1793 +1105:1796 +1105:1797 +1105:1798 +1105:1799 +1105:1802 +1105:1803 +1105:1804 +1105:1807 +1105:1808 +1105:1809 +1105:1810 +1105:1811 +1105:1814 +1105:1815 +1105:1816 +1105:1817 +1105:1820 +1105:1821 +1105:1822 +1105:1831 +1105:1832 +1105:1833 +1105:1834 +1105:1835 +1105:1838 +1105:1839 +1105:1840 +1105:1841 +1105:1842 +1105:1843 +1105:1844 +1105:1845 +1105:1846 +1105:1848 +1105:1849 +1105:1850 +1105:1851 +1105:1852 +1105:1853 +1105:1854 +1105:1855 +1105:1856 +1109:1858 +1109:1859 +1109:1860 +1109:1861 +1109:1863 +1109:1864 +1109:1865 +1109:1866 +1109:1869 +1109:1870 +1109:1871 +1109:1874 +1109:1875 +1109:1876 +1109:1879 +1109:1880 +1109:1881 +1109:1884 +1109:1885 +1109:1886 +1109:1887 +1109:1888 +1109:1889 +1109:1890 +1109:1891 +1109:1892 +1109:1893 +1109:1894 +*E diff --git a/app/preproc/PdeRecognizer.smap b/app/preproc/PdeRecognizer.smap new file mode 100644 index 000000000..f2cddd935 --- /dev/null +++ b/app/preproc/PdeRecognizer.smap @@ -0,0 +1,3252 @@ +SMAP +PdeRecognizer.java +G +*S G +*F ++ 0 expandedpde.g +expandedpde.g +*L +1:3 +1:5 +21:58 +21:60 +21:61 +21:62 +21:64 +21:65 +21:66 +21:67 +21:68 +21:69 +21:71 +21:72 +21:73 +21:74 +21:75 +21:76 +21:77 +21:78 +21:79 +21:80 +21:83 +21:84 +21:85 +21:86 +21:87 +21:88 +21:89 +21:90 +21:91 +21:92 +21:97 +21:138 +21:146 +21:147 +21:148 +21:149 +21:150 +21:151 +21:152 +22:93 +22:94 +25:96 +32:98 +32:99 +32:100 +32:101 +32:102 +32:103 +32:104 +32:106 +32:107 +32:108 +32:109 +32:110 +32:111 +32:112 +32:113 +32:114 +32:115 +32:116 +32:118 +32:119 +32:120 +32:121 +32:122 +32:124 +32:125 +32:126 +32:127 +32:128 +32:129 +32:130 +32:131 +33:132 +33:133 +34:134 +34:135 +36:139 +36:140 +36:141 +37:137 +37:142 +37:143 +40:145 +40:154 +40:156 +40:157 +40:158 +40:160 +40:161 +40:162 +40:163 +40:164 +43:196 +43:198 +43:199 +43:200 +43:203 +43:204 +43:205 +43:206 +43:207 +43:208 +43:209 +43:210 +43:211 +43:212 +43:214 +43:215 +43:216 +43:217 +43:218 +43:219 +46:221 +46:223 +46:224 +46:225 +46:227 +46:228 +46:229 +46:230 +46:231 +46:232 +46:233 +46:234 +46:235 +46:236 +46:238 +46:239 +46:240 +46:241 +46:242 +49:619 +49:621 +49:622 +49:623 +49:625 +49:626 +49:627 +49:628 +49:629 +49:631 +49:638 +49:645 +49:652 +49:659 +49:666 +49:671 +49:672 +49:673 +49:674 +49:676 +49:677 +50:632 +50:633 +50:634 +50:635 +50:636 +51:630 +51:639 +51:640 +51:641 +51:642 +51:643 +52:637 +52:646 +52:647 +52:648 +52:649 +52:650 +53:644 +53:653 +53:654 +53:655 +53:656 +53:657 +54:651 +54:660 +54:661 +54:662 +54:663 +54:664 +55:658 +55:667 +55:668 +55:669 +55:670 +56:665 +58:679 +58:681 +58:682 +58:683 +58:684 +58:685 +58:687 +58:688 +58:689 +58:690 +58:695 +58:696 +59:691 +59:692 +59:693 +59:694 +63:698 +63:700 +63:701 +63:702 +63:704 +63:705 +63:706 +63:707 +63:708 +63:709 +63:710 +63:717 +63:724 +63:731 +63:738 +63:745 +63:752 +63:759 +63:766 +63:767 +63:768 +63:769 +63:771 +63:772 +64:711 +64:712 +64:713 +64:714 +64:715 +64:716 +65:718 +65:719 +65:720 +65:721 +65:722 +65:723 +66:725 +66:726 +66:727 +66:728 +66:729 +66:730 +67:732 +67:733 +67:734 +67:735 +67:736 +67:737 +68:739 +68:740 +68:741 +68:742 +68:743 +68:744 +69:746 +69:747 +69:748 +69:749 +69:750 +69:751 +70:753 +70:754 +70:755 +70:756 +70:757 +70:758 +71:760 +71:761 +71:762 +71:763 +71:764 +71:765 +74:774 +74:776 +74:777 +74:778 +74:780 +74:781 +74:782 +74:783 +74:784 +74:793 +74:794 +74:795 +74:796 +74:798 +74:799 +75:785 +75:786 +75:787 +75:788 +75:789 +76:790 +76:791 +76:792 +79:801 +79:803 +79:804 +79:805 +79:806 +79:809 +79:810 +79:831 +79:832 +80:811 +81:807 +81:812 +81:813 +82:814 +86:815 +86:816 +86:817 +86:818 +86:819 +86:820 +86:821 +86:822 +95:823 +95:824 +95:825 +95:826 +95:828 +95:829 +98:834 +98:835 +98:836 +98:838 +98:839 +98:840 +98:842 +98:843 +98:844 +98:845 +98:846 +102:868 +102:869 +102:870 +102:872 +102:873 +102:874 +102:876 +102:877 +102:891 +102:892 +103:878 +103:879 +103:885 +103:887 +103:888 +104:881 +104:890 +105:882 +106:883 +111:894 +111:896 +111:897 +111:898 +111:899 +111:900 +111:904 +111:905 +111:906 +111:907 +111:908 +111:909 +111:922 +111:923 +112:901 +112:902 +112:911 +112:912 +112:913 +112:914 +112:915 +112:916 +113:918 +113:919 +114:920 +116:921 +117:955 +117:957 +117:958 +117:959 +117:963 +117:964 +117:965 +117:966 +117:967 +117:968 +117:970 +117:971 +117:973 +117:974 +117:975 +117:976 +117:977 +117:978 +117:979 +117:980 +117:981 +117:982 +117:986 +117:1009 +117:1014 +117:1021 +117:1028 +117:1035 +117:1040 +117:1047 +117:1054 +117:1061 +117:1066 +117:1098 +117:1099 +117:1100 +117:1101 +117:1103 +117:1104 +118:983 +118:984 +118:985 +119:987 +119:988 +119:989 +119:991 +119:992 +119:993 +119:994 +119:995 +119:996 +119:997 +119:998 +119:999 +119:1000 +119:1002 +119:1003 +119:1004 +119:1005 +120:1008 +120:1010 +120:1011 +120:1012 +120:1013 +121:1015 +121:1016 +121:1017 +121:1018 +121:1019 +121:1020 +122:1022 +122:1023 +122:1024 +122:1025 +122:1026 +122:1027 +123:1029 +123:1030 +123:1031 +123:1032 +123:1033 +123:1034 +124:1036 +124:1037 +124:1038 +124:1039 +125:1041 +125:1042 +125:1043 +125:1044 +125:1045 +125:1046 +126:1048 +126:1049 +126:1050 +126:1051 +126:1052 +126:1053 +127:1055 +127:1056 +127:1057 +127:1058 +127:1059 +128:1062 +128:1063 +128:1064 +128:1065 +129:1060 +130:1067 +130:1068 +130:1069 +131:960 +131:961 +131:1070 +131:1071 +131:1072 +131:1073 +131:1074 +131:1075 +131:1076 +131:1077 +131:1078 +131:1079 +131:1081 +131:1082 +131:1083 +131:1084 +131:1085 +131:1087 +131:1088 +132:1089 +132:1090 +132:1091 +132:1092 +132:1093 +132:1094 +132:1095 +132:1096 +132:1097 +135:1372 +135:1373 +135:1374 +135:1376 +135:1377 +135:1378 +135:1379 +135:1381 +135:1382 +135:1383 +135:1392 +135:1393 +136:1382 +137:1384 +137:1385 +137:1386 +137:1387 +137:1389 +137:1390 +141:1395 +141:1396 +141:1397 +141:1399 +141:1400 +141:1401 +141:1402 +141:1403 +141:1404 +141:1405 +141:1409 +141:1410 +141:1411 +141:1412 +141:1413 +141:1414 +141:1415 +141:1416 +141:1417 +141:1418 +141:1419 +141:1420 +141:1421 +141:1422 +141:1423 +141:1424 +141:1425 +141:1426 +141:1428 +141:1429 +141:1430 +141:1431 +141:1432 +141:1434 +141:1435 +141:1450 +141:1451 +141:1452 +141:1453 +141:1455 +141:1456 +141:1457 +141:1458 +141:1459 +141:1460 +142:1406 +142:1436 +142:1437 +142:1438 +142:1440 +142:1441 +142:1442 +142:1444 +142:1445 +142:1446 +142:1447 +145:1488 +145:1490 +145:1491 +145:1492 +145:1493 +145:1494 +145:1495 +145:1500 +145:1501 +145:1502 +145:1503 +145:1504 +145:1505 +145:1506 +145:1507 +145:1508 +145:1509 +145:1510 +145:1511 +145:1512 +145:1513 +145:1514 +145:1523 +145:1547 +145:1548 +145:1549 +145:1550 +145:1552 +145:1553 +146:1515 +146:1516 +146:1517 +146:1518 +146:1520 +146:1521 +148:1496 +148:1497 +148:1498 +148:1524 +148:1525 +148:1526 +148:1527 +148:1528 +148:1529 +148:1530 +148:1531 +148:1532 +148:1533 +148:1534 +148:1535 +148:1536 +148:1537 +148:1538 +149:1539 +149:1540 +149:1541 +149:1542 +149:1544 +149:1545 +154:1555 +154:1556 +154:1557 +154:1559 +154:1560 +154:1561 +154:1562 +154:1563 +154:1568 +154:1569 +154:1570 +154:1571 +154:1587 +154:1588 +156:1564 +156:1572 +156:1573 +158:1565 +158:1574 +158:1575 +160:1566 +160:1576 +160:1577 +161:1578 +161:1579 +161:1580 +161:1582 +161:1584 +161:1585 +162:1581 +166:166 +166:168 +166:169 +166:170 +166:174 +166:175 +166:176 +166:177 +166:178 +166:188 +166:189 +166:190 +166:191 +166:193 +166:194 +167:171 +167:172 +167:179 +167:180 +167:181 +167:182 +167:183 +167:184 +167:185 +170:187 +171:244 +171:246 +171:247 +171:248 +171:290 +171:291 +172:251 +172:252 +172:253 +172:254 +172:256 +172:257 +172:258 +172:259 +177:262 +177:263 +177:264 +177:265 +177:266 +177:267 +177:268 +177:269 +177:270 +177:271 +177:273 +177:274 +181:275 +181:276 +181:277 +181:278 +181:279 +181:280 +181:281 +181:282 +181:283 +181:284 +181:286 +181:287 +183:288 +185:289 +187:1876 +187:1878 +187:1879 +187:1880 +187:1884 +187:1896 +187:1897 +187:1898 +187:1899 +187:1900 +187:1901 +187:1902 +187:1903 +187:1904 +187:1905 +187:1906 +191:1881 +191:1882 +191:1885 +191:1886 +191:1887 +191:1888 +191:1889 +191:1890 +191:1892 +191:1893 +191:1894 +193:1895 +195:1908 +195:1910 +195:1911 +195:1912 +195:1916 +195:1928 +195:1929 +195:1930 +195:1931 +195:1932 +195:1933 +195:1934 +195:1935 +195:1936 +195:1937 +195:1938 +199:1913 +199:1914 +199:1917 +199:1918 +199:1919 +199:1920 +199:1921 +199:1922 +199:1924 +199:1925 +199:1926 +201:1927 +203:1940 +203:1942 +203:1943 +203:1944 +203:1947 +203:1966 +203:1970 +203:1971 +203:1972 +203:1973 +203:1975 +203:1976 +203:1977 +203:1978 +203:1979 +203:1980 +203:1981 +203:1982 +203:1983 +203:1984 +203:1985 +207:1945 +207:1948 +207:1949 +207:1950 +208:1952 +208:1953 +208:1954 +208:1955 +208:1959 +208:1960 +208:1961 +208:1962 +209:1956 +209:1957 +209:1958 +209:1965 +211:1967 +211:1968 +213:1969 +215:2131 +215:2133 +215:2134 +215:2135 +215:2136 +215:2137 +215:2138 +215:2140 +215:2141 +215:2142 +215:2143 +215:2144 +215:2145 +215:2154 +215:2155 +216:2146 +216:2147 +216:2148 +216:2149 +216:2151 +216:2152 +220:2157 +220:2158 +220:2159 +220:2161 +220:2162 +220:2163 +220:2165 +220:2166 +220:2167 +220:2168 +220:2169 +220:2174 +220:2175 +220:2176 +220:2177 +220:2179 +220:2180 +221:2170 +221:2171 +221:2172 +221:2173 +225:2182 +225:2183 +225:2184 +225:2186 +225:2187 +225:2188 +225:2189 +225:2190 +225:2192 +225:2193 +225:2194 +225:2195 +225:2196 +225:2197 +225:2198 +225:2199 +225:2200 +225:2201 +225:2202 +225:2203 +225:2205 +225:2206 +225:2207 +225:2208 +225:2209 +225:2211 +225:2212 +225:2226 +225:2227 +226:2213 +226:2214 +226:2220 +226:2222 +226:2223 +227:2216 +227:2225 +228:2217 +229:2218 +234:2229 +234:2230 +234:2231 +234:2233 +234:2234 +234:2235 +234:2236 +234:2237 +234:2239 +234:2240 +234:2241 +234:2242 +234:2243 +234:2244 +234:2245 +234:2246 +234:2247 +234:2248 +234:2249 +234:2250 +234:2252 +234:2253 +234:2254 +234:2255 +234:2256 +234:2258 +234:2259 +234:2273 +234:2274 +235:2260 +235:2261 +235:2267 +235:2269 +235:2270 +236:2263 +236:2272 +237:2264 +238:2265 +243:2276 +243:2278 +243:2279 +243:2280 +243:2282 +243:2283 +243:2284 +243:2285 +243:2286 +243:2291 +243:2292 +243:2293 +243:2294 +243:2296 +243:2297 +244:2287 +244:2288 +244:2289 +244:2290 +248:1987 +248:1989 +248:1990 +248:1991 +248:1993 +248:1994 +248:1995 +248:1996 +248:1997 +248:1998 +248:1999 +248:2000 +248:2001 +248:2002 +248:2003 +248:2004 +248:2005 +248:2006 +248:2007 +248:2008 +248:2009 +248:2010 +248:2011 +248:2012 +248:2014 +248:2015 +248:2016 +248:2017 +248:2018 +252:2020 +252:2022 +252:2023 +252:2024 +252:2026 +252:2027 +252:2028 +252:2029 +252:2068 +252:2069 +253:2030 +253:2031 +253:2032 +253:2033 +253:2034 +253:2035 +253:2036 +253:2037 +253:2038 +253:2039 +253:2040 +253:2041 +253:2042 +253:2043 +253:2044 +253:2045 +253:2047 +253:2048 +254:2050 +254:2051 +254:2052 +254:2053 +254:2054 +254:2055 +254:2056 +254:2057 +254:2058 +254:2059 +254:2061 +254:2062 +254:2063 +254:2064 +255:2067 +258:2071 +258:2073 +258:2074 +258:2075 +258:2077 +258:2078 +258:2079 +258:2080 +258:2081 +258:2082 +258:2083 +258:2084 +258:2085 +258:2086 +258:2088 +258:2089 +258:2099 +258:2100 +259:2090 +259:2091 +259:2092 +259:2093 +259:2095 +259:2096 +260:2098 +263:2299 +263:2301 +263:2302 +263:2303 +263:2305 +263:2306 +263:2307 +263:2308 +263:2309 +263:2310 +263:2311 +263:2312 +263:2414 +263:2415 +263:2416 +263:2417 +263:2418 +263:2419 +263:2420 +264:2315 +264:2316 +264:2317 +264:2318 +264:2319 +264:2320 +264:2321 +265:2324 +265:2325 +265:2326 +265:2327 +265:2328 +265:2329 +265:2330 +266:2333 +266:2334 +266:2335 +266:2336 +266:2337 +266:2338 +266:2339 +267:2342 +267:2343 +267:2344 +267:2345 +267:2346 +267:2347 +267:2348 +268:2351 +268:2352 +268:2353 +268:2354 +268:2355 +268:2356 +268:2357 +269:2360 +269:2361 +269:2362 +269:2363 +269:2364 +269:2365 +269:2366 +270:2369 +270:2370 +270:2371 +270:2372 +270:2373 +270:2374 +270:2375 +271:2378 +271:2379 +271:2380 +271:2381 +271:2382 +271:2383 +271:2384 +272:2387 +272:2388 +272:2389 +272:2390 +272:2391 +272:2392 +272:2393 +274:2396 +274:2397 +274:2398 +274:2399 +274:2400 +274:2401 +274:2402 +275:2405 +275:2406 +275:2407 +275:2408 +275:2409 +275:2410 +275:2411 +279:1590 +279:1592 +279:1593 +279:1594 +279:1595 +279:1598 +279:1599 +279:1600 +279:1601 +279:1602 +279:1604 +279:1605 +279:1606 +279:1607 +279:1618 +279:1619 +280:1610 +280:1611 +280:1612 +280:1613 +280:1615 +280:1616 +284:2102 +284:2103 +284:2104 +284:2106 +284:2107 +284:2108 +284:2112 +284:2113 +284:2114 +284:2115 +284:2128 +284:2129 +286:2109 +286:2116 +286:2117 +288:2110 +288:2118 +288:2119 +289:2120 +289:2121 +289:2122 +289:2123 +289:2125 +289:2126 +294:1670 +294:1672 +294:1673 +294:1674 +294:1676 +294:1703 +294:1704 +295:1677 +295:1678 +295:1679 +295:1680 +295:1681 +295:1682 +295:1683 +295:1684 +295:1685 +295:1686 +295:1687 +295:1688 +295:1689 +295:1691 +295:1692 +296:1693 +297:1694 +297:1695 +297:1696 +297:1697 +297:1699 +297:1700 +298:1702 +301:2422 +301:2424 +301:2425 +301:2426 +301:2451 +301:2453 +301:2454 +301:2455 +301:2456 +301:2468 +301:2469 +302:2427 +302:2428 +302:2431 +302:2432 +302:2433 +302:2434 +303:2435 +303:2436 +303:2437 +303:2438 +303:2439 +303:2440 +303:2441 +303:2442 +303:2443 +303:2444 +303:2445 +303:2446 +303:2447 +303:2449 +303:2450 +305:2459 +305:2460 +305:2461 +305:2462 +305:2464 +305:2465 +306:2467 +310:1621 +310:1623 +310:1624 +310:1625 +310:1650 +310:1652 +310:1653 +310:1654 +310:1655 +310:1667 +310:1668 +311:1626 +311:1627 +311:1630 +311:1631 +311:1632 +311:1633 +311:1634 +311:1635 +311:1636 +311:1637 +311:1638 +311:1639 +311:1640 +311:1641 +311:1642 +311:1643 +311:1644 +311:1645 +311:1646 +311:1648 +311:1649 +313:1658 +313:1659 +313:1660 +313:1661 +313:1663 +313:1664 +314:1666 +318:1706 +318:1708 +318:1709 +318:1710 +318:1843 +318:1856 +318:1868 +318:1869 +318:1870 +318:1871 +318:1873 +318:1874 +319:1711 +319:1725 +319:1726 +319:1727 +320:1712 +320:1713 +320:1729 +320:1730 +320:1731 +320:1732 +320:1733 +320:1742 +320:1754 +320:1766 +320:1837 +320:1838 +320:1839 +320:1840 +321:1734 +321:1735 +321:1736 +321:1737 +321:1739 +321:1740 +323:1714 +323:1743 +323:1744 +323:1745 +324:1746 +324:1747 +324:1748 +324:1749 +324:1751 +324:1752 +326:1715 +326:1755 +326:1756 +326:1757 +327:1758 +327:1759 +327:1760 +327:1761 +327:1763 +327:1764 +329:1716 +329:1767 +329:1768 +329:1769 +330:1771 +330:1772 +330:1773 +330:1774 +330:1816 +330:1831 +330:1832 +330:1833 +330:1834 +333:1717 +333:1775 +333:1776 +333:1777 +333:1778 +335:1718 +335:1779 +335:1780 +339:1719 +339:1782 +339:1783 +339:1784 +339:1785 +339:1787 +339:1788 +339:1789 +339:1790 +341:1720 +341:1794 +341:1795 +341:1796 +341:1797 +341:1798 +341:1799 +341:1800 +341:1801 +341:1802 +341:1803 +341:1804 +341:1805 +342:1808 +342:1809 +342:1810 +342:1811 +342:1813 +342:1814 +349:1721 +349:1817 +349:1818 +349:1819 +349:1820 +349:1821 +349:1822 +351:1823 +351:1824 +351:1825 +351:1826 +351:1828 +351:1829 +356:1722 +356:1844 +356:1845 +356:1846 +356:1847 +357:1848 +357:1849 +357:1850 +357:1851 +357:1853 +357:1854 +360:1723 +360:1857 +360:1858 +360:1859 +361:1860 +361:1861 +361:1862 +361:1863 +361:1865 +361:1866 +365:2501 +365:2503 +365:2504 +365:2505 +365:2506 +365:2507 +365:2509 +365:2510 +365:2511 +365:2512 +365:2513 +365:2514 +365:2543 +365:2544 +366:2517 +366:2518 +366:2519 +366:2520 +366:2522 +366:2523 +366:2524 +366:2525 +367:2528 +367:2529 +367:2530 +367:2531 +367:2532 +367:2533 +367:2534 +367:2535 +367:2536 +367:2537 +367:2539 +367:2540 +368:2541 +370:2542 +372:2590 +372:2591 +372:2592 +372:2594 +372:2595 +372:2596 +372:2600 +372:2601 +372:2602 +372:2603 +372:2605 +372:2606 +372:2628 +372:2629 +373:2597 +373:2598 +373:2608 +373:2609 +373:2610 +373:2611 +373:2612 +373:2613 +373:2614 +373:2615 +373:2616 +373:2617 +373:2619 +373:2620 +373:2621 +373:2622 +373:2623 +373:2625 +373:2626 +373:2627 +377:1462 +377:1464 +377:1465 +377:1466 +377:1469 +377:1470 +377:1471 +377:1472 +377:1473 +377:1474 +377:1475 +377:1476 +377:1478 +377:1479 +377:1480 +377:1481 +377:1485 +377:1486 +378:1484 +381:2717 +381:2719 +381:2720 +381:2721 +381:2722 +381:2723 +381:2725 +381:2726 +381:2727 +381:2728 +381:2729 +381:2730 +381:2771 +381:2772 +382:2733 +382:2734 +382:2735 +382:2761 +382:2763 +382:2764 +382:2765 +382:2766 +383:2736 +383:2737 +383:2738 +383:2743 +383:2744 +383:2745 +383:2746 +383:2748 +383:2749 +392:2739 +392:2740 +392:2741 +392:2742 +394:2751 +394:2752 +394:2753 +394:2755 +394:2756 +394:2757 +394:2758 +396:2769 +398:2770 +400:2694 +400:2696 +400:2697 +400:2698 +400:2700 +400:2701 +400:2702 +400:2703 +400:2704 +400:2709 +400:2710 +400:2711 +400:2712 +400:2714 +400:2715 +401:2705 +401:2706 +401:2707 +401:2708 +405:2471 +405:2473 +405:2474 +405:2475 +405:2477 +405:2478 +405:2479 +405:2480 +405:2498 +405:2499 +408:2481 +408:2482 +408:2483 +408:2484 +411:2486 +411:2487 +411:2488 +411:2489 +411:2491 +411:2492 +411:2493 +411:2494 +412:2497 +415:2631 +415:2633 +415:2634 +415:2635 +415:2637 +415:2638 +415:2639 +415:2640 +415:2641 +415:2642 +415:2643 +415:2644 +415:2645 +415:2646 +415:2647 +415:2648 +415:2649 +415:2650 +415:2651 +415:2652 +415:2653 +415:2655 +415:2656 +415:2657 +415:2658 +415:2659 +419:2546 +419:2548 +419:2549 +419:2550 +419:2553 +419:2554 +419:2555 +419:2556 +419:2557 +419:2558 +419:2559 +419:2560 +419:2561 +419:2562 +419:2563 +419:2564 +419:2565 +419:2566 +419:2568 +419:2569 +419:2570 +419:2572 +419:2573 +419:2574 +419:2575 +419:2587 +419:2588 +420:2578 +420:2579 +420:2580 +420:2581 +420:2583 +420:2584 +421:2586 +425:2774 +425:2776 +425:2777 +425:2778 +425:2779 +425:2780 +425:2781 +425:2782 +425:2785 +425:2786 +425:2787 +425:2788 +425:2789 +425:2790 +425:2791 +425:2802 +425:2803 +426:2783 +426:2792 +426:2793 +427:2794 +427:2795 +427:2796 +427:2797 +427:2799 +427:2800 +432:2805 +432:2807 +432:2808 +432:2809 +432:2810 +432:2811 +432:2814 +432:2815 +432:2816 +432:2817 +432:2818 +432:2819 +432:2821 +432:2822 +432:2823 +432:2824 +432:2836 +432:2837 +433:2827 +433:2828 +433:2829 +433:2830 +433:2832 +433:2833 +434:2835 +437:2661 +437:2663 +437:2664 +437:2665 +437:2666 +437:2667 +437:2669 +437:2670 +437:2671 +437:2672 +437:2673 +437:2674 +437:2691 +437:2692 +439:2676 +439:2677 +439:2678 +439:2679 +439:2680 +439:2681 +439:2682 +439:2683 +439:2684 +439:2685 +439:2687 +439:2688 +440:2689 +442:2690 +444:293 +444:295 +444:296 +444:297 +444:304 +444:305 +444:306 +444:307 +444:308 +444:309 +444:547 +444:569 +444:575 +444:582 +444:598 +444:611 +444:612 +444:613 +444:614 +444:615 +444:616 +444:617 +450:548 +450:549 +450:550 +450:551 +450:552 +450:553 +450:555 +450:557 +450:558 +450:559 +450:560 +450:561 +450:562 +450:563 +450:564 +450:565 +450:566 +450:567 +452:568 +455:570 +455:571 +455:572 +455:573 +457:574 +458:298 +458:576 +458:577 +458:578 +458:579 +458:580 +458:581 +461:299 +461:300 +461:583 +461:584 +461:585 +461:586 +461:587 +461:588 +461:589 +461:590 +461:591 +461:592 +461:593 +461:595 +461:596 +461:597 +464:312 +464:313 +464:314 +464:315 +464:316 +464:317 +464:318 +464:319 +464:320 +464:321 +464:322 +464:323 +465:329 +465:331 +465:332 +465:333 +465:334 +466:337 +473:325 +473:326 +473:327 +473:328 +477:340 +477:341 +477:342 +477:343 +477:344 +477:345 +478:346 +479:347 +479:348 +479:349 +480:350 +480:351 +480:352 +481:353 +481:354 +482:355 +483:356 +483:357 +483:358 +486:361 +486:362 +486:363 +486:364 +486:365 +486:366 +486:367 +486:368 +486:369 +486:370 +486:371 +486:372 +486:373 +489:376 +489:377 +489:378 +489:379 +489:380 +489:381 +489:382 +489:383 +489:384 +489:385 +489:386 +489:387 +489:388 +489:389 +491:390 +492:393 +492:394 +492:395 +492:396 +492:397 +492:398 +492:400 +492:401 +492:402 +492:403 +492:404 +492:405 +492:407 +492:408 +492:409 +492:410 +492:413 +494:414 +495:417 +495:418 +495:419 +495:420 +495:421 +495:422 +495:424 +495:425 +495:426 +495:427 +495:428 +495:429 +495:431 +495:432 +495:433 +495:434 +495:437 +497:438 +498:441 +498:442 +498:443 +498:444 +498:445 +498:446 +498:448 +498:449 +498:450 +498:451 +498:453 +498:454 +498:455 +498:456 +498:459 +500:460 +501:463 +501:464 +501:465 +501:466 +501:467 +501:468 +501:469 +501:470 +501:471 +501:472 +501:473 +502:474 +502:475 +502:476 +502:477 +502:478 +502:479 +502:480 +502:481 +502:482 +502:483 +502:485 +502:486 +503:487 +505:488 +506:491 +506:492 +506:493 +506:494 +506:495 +509:498 +509:499 +509:500 +509:501 +509:502 +509:503 +509:504 +509:505 +509:506 +511:507 +512:599 +512:600 +512:601 +512:602 +512:603 +512:604 +512:605 +512:606 +512:607 +512:608 +512:609 +512:610 +515:510 +515:511 +515:512 +515:513 +515:514 +515:515 +515:516 +515:517 +515:519 +515:520 +515:521 +515:522 +515:523 +515:525 +515:526 +515:527 +515:528 +515:531 +517:532 +518:301 +518:302 +518:535 +518:536 +518:537 +518:538 +518:539 +518:540 +518:541 +518:542 +521:544 +522:2949 +522:2951 +522:2952 +522:2953 +522:2956 +522:2957 +522:2958 +522:2962 +522:2963 +522:2964 +522:2965 +522:2967 +522:2968 +522:2969 +522:2981 +522:2982 +530:2959 +530:2960 +530:2961 +532:2970 +532:2971 +533:2972 +533:2973 +533:2974 +533:2975 +533:2977 +533:2978 +534:2980 +537:3025 +537:3027 +537:3028 +537:3029 +537:3032 +537:3033 +537:3034 +537:3035 +537:3036 +537:3037 +537:3038 +537:3039 +537:3040 +537:3041 +537:3042 +537:3043 +537:3044 +537:3045 +537:3046 +537:3047 +537:3048 +537:3051 +537:3053 +537:3054 +539:3052 +541:3056 +541:3058 +541:3059 +541:3060 +541:3062 +541:3063 +541:3064 +541:3065 +541:3066 +541:3067 +541:3068 +541:3069 +541:3070 +541:3071 +541:3073 +541:3074 +541:3084 +541:3085 +542:3075 +542:3076 +542:3077 +542:3078 +542:3080 +542:3081 +543:3083 +546:2839 +546:2841 +546:2842 +546:2843 +546:2846 +546:2847 +546:2848 +546:2849 +546:2850 +546:2851 +546:2853 +546:2855 +546:2856 +546:2857 +546:2858 +546:2859 +546:2860 +546:2861 +546:2862 +546:2863 +546:2864 +546:2865 +546:2869 +546:2871 +546:2872 +546:2873 +546:2874 +546:2886 +546:2887 +548:2866 +548:2867 +548:2868 +550:2877 +550:2878 +550:2879 +550:2880 +550:2882 +550:2883 +551:2885 +554:2889 +554:2891 +554:2892 +554:2893 +554:2896 +554:2897 +554:2898 +554:2899 +554:2901 +554:2902 +554:2903 +554:2904 +554:2916 +554:2917 +555:2907 +555:2908 +555:2909 +555:2910 +555:2912 +555:2913 +556:2915 +559:2919 +559:2921 +559:2922 +559:2923 +559:2926 +559:2927 +559:2928 +559:2929 +559:2931 +559:2932 +559:2933 +559:2934 +559:2946 +559:2947 +560:2937 +560:2938 +560:2939 +560:2940 +560:2942 +560:2943 +561:2945 +564:2984 +564:2986 +564:2987 +564:2988 +564:2990 +564:2991 +564:2992 +564:2993 +564:2994 +564:2995 +564:3022 +564:3023 +565:2996 +565:2997 +565:2998 +565:2999 +565:3000 +565:3001 +565:3002 +565:3003 +565:3004 +565:3005 +565:3007 +565:3008 +566:3010 +566:3011 +566:3012 +566:3013 +566:3015 +566:3016 +566:3017 +566:3018 +567:3021 +570:3141 +570:3143 +570:3144 +570:3145 +570:3147 +570:3148 +570:3149 +570:3150 +570:3151 +570:3152 +570:3153 +570:3154 +570:3155 +574:3121 +574:3123 +574:3124 +574:3125 +574:3127 +574:3128 +574:3129 +574:3130 +574:3131 +574:3132 +574:3133 +574:3134 +574:3135 +574:3136 +574:3137 +574:3138 +574:3139 +578:848 +578:850 +578:851 +578:852 +578:854 +578:855 +578:865 +578:866 +579:856 +579:857 +579:858 +579:859 +579:861 +579:862 +580:864 +583:3087 +583:3089 +583:3090 +583:3091 +583:3093 +583:3094 +583:3095 +583:3096 +583:3097 +583:3098 +583:3099 +583:3100 +583:3101 +583:3102 +583:3103 +583:3104 +583:3105 +583:3107 +583:3108 +583:3118 +583:3119 +584:3109 +584:3110 +584:3111 +584:3112 +584:3114 +584:3115 +585:3117 +588:1244 +588:1246 +588:1247 +588:1248 +588:1250 +588:1251 +588:1369 +588:1370 +589:1253 +589:1255 +589:1256 +589:1257 +589:1258 +589:1259 +589:1260 +589:1261 +589:1352 +589:1353 +589:1354 +589:1355 +589:1356 +589:1360 +589:1362 +589:1363 +589:1364 +589:1365 +590:1264 +590:1265 +590:1266 +590:1267 +590:1268 +590:1269 +590:1368 +591:1272 +591:1273 +591:1274 +591:1275 +591:1276 +591:1277 +592:1280 +592:1281 +592:1282 +592:1283 +592:1284 +592:1285 +593:1288 +593:1289 +593:1290 +593:1291 +593:1292 +593:1293 +594:1296 +594:1297 +594:1298 +594:1299 +594:1300 +594:1301 +595:1304 +595:1305 +595:1306 +595:1307 +595:1308 +595:1309 +596:1312 +596:1313 +596:1314 +596:1315 +596:1316 +596:1317 +597:1320 +597:1321 +597:1322 +597:1323 +597:1324 +597:1325 +598:1328 +598:1329 +598:1330 +598:1331 +598:1332 +598:1333 +599:1336 +599:1337 +599:1338 +599:1339 +599:1340 +599:1341 +600:1344 +600:1345 +600:1346 +600:1347 +600:1348 +600:1349 +602:1358 +602:1359 +607:3157 +607:3159 +607:3160 +607:3161 +607:3163 +607:3164 +607:3185 +607:3186 +608:3166 +608:3167 +608:3168 +608:3169 +608:3170 +608:3171 +608:3172 +608:3173 +608:3174 +608:3175 +608:3176 +608:3178 +608:3179 +608:3180 +608:3181 +609:3184 +612:3188 +612:3190 +612:3191 +612:3192 +612:3194 +612:3195 +612:3196 +612:3197 +612:3198 +612:3199 +612:3200 +612:3201 +612:3202 +612:3203 +612:3204 +612:3205 +612:3206 +612:3207 +612:3208 +612:3209 +612:3211 +612:3212 +612:3213 +612:3214 +612:3215 +616:3217 +616:3219 +616:3220 +616:3221 +616:3223 +616:3224 +616:3225 +616:3226 +616:3227 +616:3228 +616:3229 +616:3230 +616:3231 +616:3232 +616:3233 +616:3234 +616:3235 +616:3236 +616:3237 +616:3238 +616:3240 +616:3241 +616:3242 +616:3243 +616:3244 +620:3246 +620:3248 +620:3249 +620:3250 +620:3252 +620:3253 +620:3254 +620:3255 +620:3256 +620:3257 +620:3258 +620:3259 +620:3260 +620:3261 +620:3262 +620:3263 +620:3264 +620:3265 +620:3266 +620:3267 +620:3269 +620:3270 +620:3271 +620:3272 +620:3273 +624:3275 +624:3277 +624:3278 +624:3279 +624:3281 +624:3282 +624:3283 +624:3284 +624:3285 +624:3286 +624:3287 +624:3288 +624:3289 +624:3290 +624:3291 +624:3292 +624:3293 +624:3294 +624:3295 +624:3296 +624:3298 +624:3299 +624:3300 +624:3301 +624:3302 +628:3304 +628:3306 +628:3307 +628:3308 +628:3310 +628:3311 +628:3312 +628:3313 +628:3314 +628:3315 +628:3316 +628:3317 +628:3318 +628:3319 +628:3320 +628:3321 +628:3322 +628:3323 +628:3324 +628:3325 +628:3327 +628:3328 +628:3329 +628:3330 +628:3331 +632:3333 +632:3335 +632:3336 +632:3337 +632:3339 +632:3340 +632:3341 +632:3342 +632:3343 +632:3344 +632:3346 +632:3347 +632:3348 +632:3349 +632:3350 +632:3351 +632:3352 +632:3353 +632:3354 +632:3355 +632:3356 +632:3357 +632:3358 +632:3359 +632:3360 +632:3363 +632:3364 +632:3365 +632:3366 +632:3367 +632:3368 +632:3370 +632:3371 +632:3372 +632:3373 +632:3374 +636:3376 +636:3378 +636:3379 +636:3380 +636:3382 +636:3383 +636:3444 +636:3445 +637:3385 +637:3386 +637:3387 +637:3388 +637:3389 +637:3391 +637:3392 +637:3393 +637:3394 +637:3395 +637:3396 +637:3402 +637:3408 +637:3414 +637:3415 +637:3416 +637:3417 +637:3422 +637:3423 +637:3424 +637:3425 +637:3427 +637:3428 +637:3429 +637:3437 +637:3438 +637:3439 +637:3440 +638:3397 +638:3398 +638:3399 +638:3400 +638:3401 +638:3443 +639:3403 +639:3404 +639:3405 +639:3406 +639:3407 +640:3409 +640:3410 +640:3411 +640:3412 +640:3413 +642:3420 +642:3421 +644:3430 +644:3431 +644:3432 +644:3433 +644:3434 +644:3435 +644:3436 +649:3447 +649:3449 +649:3450 +649:3451 +649:3453 +649:3454 +649:3455 +649:3456 +649:3457 +649:3458 +649:3460 +649:3461 +649:3462 +649:3463 +649:3464 +649:3465 +649:3466 +649:3467 +649:3468 +649:3469 +649:3470 +649:3471 +649:3472 +649:3473 +649:3474 +649:3475 +649:3476 +649:3477 +649:3478 +649:3479 +649:3480 +649:3483 +649:3484 +649:3485 +649:3486 +649:3487 +649:3488 +649:3490 +649:3491 +649:3492 +649:3493 +649:3494 +653:3496 +653:3498 +653:3499 +653:3500 +653:3502 +653:3503 +653:3504 +653:3505 +653:3506 +653:3507 +653:3509 +653:3510 +653:3511 +653:3512 +653:3513 +653:3514 +653:3515 +653:3516 +653:3517 +653:3518 +653:3519 +653:3520 +653:3521 +653:3522 +653:3523 +653:3526 +653:3527 +653:3528 +653:3529 +653:3530 +653:3531 +653:3533 +653:3534 +653:3535 +653:3536 +653:3537 +657:3539 +657:3541 +657:3542 +657:3543 +657:3545 +657:3546 +657:3547 +657:3548 +657:3549 +657:3550 +657:3552 +657:3553 +657:3554 +657:3555 +657:3556 +657:3557 +657:3558 +657:3559 +657:3560 +657:3561 +657:3562 +657:3563 +657:3564 +657:3565 +657:3566 +657:3567 +657:3568 +657:3569 +657:3570 +657:3571 +657:3572 +657:3575 +657:3576 +657:3577 +657:3578 +657:3579 +657:3580 +657:3582 +657:3583 +657:3584 +657:3585 +657:3586 +661:3588 +661:3590 +661:3591 +661:3592 +661:3594 +661:3595 +661:3596 +661:3597 +661:3598 +661:3599 +661:3600 +661:3601 +661:3602 +661:3611 +661:3623 +661:3635 +661:3640 +661:3641 +661:3642 +661:3643 +661:3645 +661:3646 +662:3603 +662:3604 +662:3605 +662:3606 +662:3607 +662:3608 +662:3609 +662:3610 +663:3612 +663:3613 +663:3614 +663:3615 +663:3616 +663:3617 +663:3618 +663:3620 +663:3621 +663:3622 +664:3624 +664:3625 +664:3626 +664:3627 +664:3628 +664:3629 +664:3630 +664:3632 +664:3633 +664:3634 +665:3636 +665:3637 +665:3638 +665:3639 +669:3648 +669:3650 +669:3651 +669:3652 +669:3658 +669:3659 +669:3660 +669:3661 +669:3662 +669:3663 +669:3664 +669:3665 +669:3666 +669:3675 +669:3736 +669:3737 +669:3738 +669:3739 +669:3741 +669:3742 +670:3667 +670:3668 +670:3669 +670:3670 +670:3671 +670:3672 +670:3673 +670:3674 +672:3676 +672:3691 +672:3725 +672:3729 +672:3730 +672:3731 +672:3732 +672:3733 +673:3735 +680:3653 +680:3654 +680:3678 +680:3679 +680:3680 +680:3681 +680:3682 +680:3683 +680:3684 +680:3686 +680:3687 +680:3688 +681:3689 +681:3690 +686:3692 +686:3693 +686:3694 +686:3695 +686:3696 +686:3697 +686:3698 +686:3700 +686:3701 +686:3702 +686:3703 +686:3705 +686:3706 +686:3707 +686:3708 +686:3709 +686:3710 +686:3711 +686:3712 +687:3655 +687:3656 +687:3713 +687:3714 +687:3715 +687:3716 +687:3717 +687:3718 +687:3720 +687:3721 +687:3722 +688:3723 +688:3724 +690:3726 +690:3727 +690:3728 +695:3744 +695:3746 +695:3747 +695:3748 +695:3918 +695:3919 +703:3762 +703:3763 +705:3764 +705:3765 +705:3766 +705:3796 +705:3806 +705:3864 +705:3872 +705:3884 +705:3885 +705:3886 +705:3887 +705:3889 +705:3890 +715:3767 +715:3768 +715:3769 +715:3770 +715:3771 +715:3772 +715:3773 +715:3774 +715:3775 +716:3749 +716:3750 +716:3777 +716:3778 +716:3779 +716:3780 +716:3781 +716:3782 +716:3783 +716:3788 +716:3790 +716:3791 +716:3792 +716:3793 +717:3785 +717:3786 +718:3787 +720:3797 +720:3798 +720:3799 +720:3800 +720:3801 +720:3802 +720:3803 +720:3804 +720:3805 +722:3807 +722:3808 +722:3809 +722:3810 +722:3811 +722:3812 +722:3813 +722:3814 +722:3815 +723:3828 +723:3858 +723:3859 +723:3860 +723:3861 +724:3751 +724:3752 +724:3817 +724:3818 +724:3819 +724:3820 +724:3821 +724:3822 +724:3823 +724:3824 +725:3825 +725:3826 +726:3829 +726:3830 +726:3831 +726:3832 +726:3833 +726:3834 +726:3835 +726:3836 +726:3837 +727:3753 +727:3754 +727:3839 +727:3840 +727:3841 +727:3842 +727:3843 +727:3844 +727:3845 +727:3850 +727:3852 +727:3853 +727:3854 +727:3855 +728:3847 +728:3848 +729:3849 +732:3865 +732:3866 +732:3867 +732:3868 +732:3869 +732:3870 +732:3871 +733:3755 +733:3756 +733:3873 +733:3874 +733:3875 +733:3876 +733:3877 +733:3878 +733:3879 +733:3881 +733:3882 +733:3883 +736:3900 +736:3909 +736:3911 +736:3912 +736:3913 +736:3914 +737:3917 +738:3757 +738:3758 +738:3892 +738:3893 +738:3894 +738:3895 +738:3896 +738:3897 +738:3898 +739:3759 +739:3760 +739:3901 +739:3902 +739:3903 +739:3904 +739:3905 +739:3906 +739:3907 +744:1106 +744:1108 +744:1109 +744:1110 +744:1116 +744:1117 +744:1118 +744:1119 +744:1185 +744:1186 +745:1120 +745:1121 +745:1122 +745:1132 +745:1133 +745:1134 +745:1135 +745:1137 +745:1138 +751:1123 +751:1124 +751:1125 +751:1126 +751:1127 +751:1128 +751:1129 +751:1130 +751:1131 +753:1153 +753:1176 +753:1178 +753:1179 +753:1180 +753:1181 +754:1184 +761:1111 +761:1112 +761:1140 +761:1142 +761:1143 +761:1144 +761:1145 +761:1146 +761:1147 +761:1149 +761:1150 +761:1151 +762:1154 +762:1156 +762:1157 +762:1158 +762:1168 +762:1169 +762:1170 +762:1171 +762:1173 +762:1174 +762:1175 +763:1113 +763:1114 +763:1159 +763:1160 +763:1161 +763:1162 +763:1163 +763:1164 +763:1165 +763:1167 +769:1188 +769:1190 +769:1191 +769:1192 +769:1194 +769:1195 +769:1196 +769:1197 +769:1198 +769:1199 +769:1241 +769:1242 +770:1201 +770:1202 +770:1203 +770:1204 +770:1205 +770:1207 +770:1208 +770:1209 +770:1210 +770:1212 +770:1213 +770:1214 +770:1215 +770:1218 +770:1234 +770:1235 +770:1236 +770:1237 +771:1240 +780:1219 +780:1220 +780:1221 +780:1223 +780:1224 +780:1225 +780:1226 +780:1228 +780:1229 +780:1230 +780:1231 +785:925 +785:927 +785:928 +785:929 +785:932 +785:933 +785:934 +785:935 +785:945 +785:946 +785:947 +785:948 +785:952 +785:953 +786:951 +787:936 +787:937 +787:938 +787:939 +787:940 +787:942 +787:943 +792:3921 +792:3923 +792:3924 +792:3925 +792:3930 +792:3931 +792:3932 +792:3954 +792:3955 +792:3956 +792:3957 +792:3959 +792:3960 +792:3961 +792:3962 +792:3963 +792:3964 +802:3926 +802:3927 +802:3933 +802:3934 +802:3935 +802:3936 +802:3937 +802:3938 +802:3939 +803:3942 +803:3943 +803:3944 +803:3945 +803:3947 +803:3948 +803:3949 +803:3950 +804:3953 +*E diff --git a/app/preproc/java.g.java15 b/app/preproc/java.g.java15 new file mode 100644 index 000000000..b119cd35f --- /dev/null +++ b/app/preproc/java.g.java15 @@ -0,0 +1,2002 @@ +header +{ +package de.hunsicker.jalopy.language.antlr; + +import de.hunsicker.jalopy.language.antlr.JavaNode; +import de.hunsicker.jalopy.language.JavaNodeHelper; +} + +/** Java 1.5 Recognizer + * + * Run 'java Main [-showtree] directory-full-of-java-files' + * + * [The -showtree option pops up a Swing frame that shows + * the JavaNode constructed from the parser.] + * + * Run 'java Main ' + * + * Contributing authors: + * John Mitchell johnm@non.net + * Terence Parr parrt@magelang.com + * John Lilley jlilley@empathy.com + * Scott Stanchfield thetick@magelang.com + * Markus Mohnen mohnen@informatik.rwth-aachen.de + * Peter Williams pete.williams@sun.com + * Allan Jacobs Allan.Jacobs@eng.sun.com + * Steve Messick messick@redhills.com + * John Pybus john@pybus.org + * + * Version 1.00 December 9, 1997 -- initial release + * Version 1.01 December 10, 1997 + * fixed bug in octal def (0..7 not 0..8) + * Version 1.10 August 1998 (parrt) + * added tree construction + * fixed definition of WS,comments for mac,pc,unix newlines + * added unary plus + * Version 1.11 (Nov 20, 1998) + * Added "shutup" option to turn off last ambig warning. + * Fixed inner class def to allow named class defs as statements + * synchronized requires compound not simple statement + * add [] after builtInType DOT class in primaryExpression + * "const" is reserved but not valid..removed from modifiers + * Version 1.12 (Feb 2, 1999) + * Changed LITERAL_xxx to xxx in tree grammar. + * Updated java.g to use tokens {...} now for 2.6.0 (new feature). + * + * Version 1.13 (Apr 23, 1999) + * Didn't have (stat)? for else clause in tree parser. + * Didn't gen ASTs for interface extends. Updated tree parser too. + * Updated to 2.6.0. + * Version 1.14 (Jun 20, 1999) + * Allowed final/abstract on local classes. + * Removed local interfaces from methods + * Put instanceof precedence where it belongs...in relationalExpr + * It also had expr not type as arg; fixed it. + * Missing ! on SEMI in classBlock + * fixed: (expr) + "string" was parsed incorrectly (+ as unary plus). + * fixed: didn't like Object[].class in parser or tree parser + * Version 1.15 (Jun 26, 1999) + * Screwed up rule with instanceof in it. :( Fixed. + * Tree parser didn't like (expr).something; fixed. + * Allowed multiple inheritance in tree grammar. oops. + * Version 1.16 (August 22, 1999) + * Extending an interface built a wacky tree: had extra EXTENDS. + * Tree grammar didn't allow multiple superinterfaces. + * Tree grammar didn't allow empty var initializer: {} + * Version 1.17 (October 12, 1999) + * ESC lexer rule allowed 399 max not 377 max. + * java.tree.g didn't handle the expression of synchronized + * statements. + * Version 1.18 (August 12, 2001) + * Terence updated to Java 2 Version 1.3 by + * observing/combining work of Allan Jacobs and Steve + * Messick. Handles 1.3 src. Summary: + * o primary didn't include boolean.class kind of thing + * o constructor calls parsed explicitly now: + * see explicitConstructorInvocation + * o add strictfp modifier + * o missing objBlock after new expression in tree grammar + * o merged local class definition alternatives, moved after declaration + * o fixed problem with ClassName.super.field + * o reordered some alternatives to make things more efficient + * o long and double constants were not differentiated from int/float + * o whitespace rule was inefficient: matched only one char + * o add an examples directory with some nasty 1.3 cases + * o made Main.java use buffered IO and a Reader for Unicode support + * o supports UNICODE? + * Using Unicode charVocabulay makes code file big, but only + * in the bitsets at the end. I need to make ANTLR generate + * unicode bitsets more efficiently. + * Version 1.19 (April 25, 2002) + * Terence added in nice fixes by John Pybus concerning floating + * constants and problems with super() calls. John did a nice + * reorg of the primary/postfix expression stuff to read better + * and makes f.g.super() parse properly (it was METHOD_CALL not + * a SUPER_CTOR_CALL). Also: + * + * o "finally" clause was a root...made it a child of "try" + * o Added stuff for asserts too for Java 1.4, but *commented out* + * as it is not backward compatible. + * + * Version 1.20 (October 27, 2002) + * + * Terence ended up reorging John Pybus' stuff to + * remove some nondeterminisms and some syntactic predicates. + * Note that the grammar is stricter now; e.g., this(...) must + * be the first statement. + * + * Trinary ?: operator wasn't working as array name: + * (isBig ? bigDigits : digits)[i]; + * + * Checked parser/tree parser on source for + * Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4, + * and the 110k-line jGuru server source. + * + * Version 1.21 (October 17, 2003) + * Fixed lots of problems including: + * Ray Waldin: add typeDefinition to interfaceBlock in java.tree.g + * He found a problem/fix with floating point that start with 0 + * Ray also fixed problem that (int.class) was not recognized. + * Thorsten van Ellen noticed that \n are allowed incorrectly in strings. + * TJP fixed CHAR_LITERAL analogously. + * + * Version 1.21.2 (March, 2003) + * Changes by Matt Quail to support generics (as per JDK1.5/JSR14) + * Notes: + * o We only allow the "extends" keyword and not the "implements" + * keyword, since thats what JSR14 seems to imply. + * o Thanks to Monty Zukowski for his help on the antlr-interest + * mail list. + * o Thanks to Alan Eliasen for testing the grammar over his + * Fink source base + * + * Version 1.22 (July, 2004) + * Changes by Michael Studman to support Java 1.5 language extensions + * Notes: + * o Added support for annotations types + * o Finished off Matt Quail's generics enhancements to support bound type arguments + * o Added support for new for statement syntax + * o Added support for static import syntax + * o Added support for enum types + * o Tested against JDK 1.5 source base and source base of jdigraph project + * o Thanks to Matt Quail for doing the hard part by doing most of the generics work + * + * Version 1.22.1 (July 28, 2004) + * Bug/omission fixes for Java 1.5 language support + * o Fixed tree structure bug with classOrInterface - thanks to Pieter Vangorpto for + * spotting this + * o Fixed bug where incorrect handling of SR and BSR tokens would cause type + * parameters to be recognised as type arguments. + * o Enabled type parameters on constructors, annotations on enum constants + * and package definitions + * o Fixed problems when parsing if ((char.class.equals(c))) {} - solution by Matt Quail at Cenqua + * + * Version 1.22.2 (July 28, 2004) + * Slight refactoring of Java 1.5 language support + * o Refactored for/"foreach" productions so that original literal "for" literal + * is still used but the for sub-clauses vary by token type + * o Fixed bug where type parameter was not included in generic constructor's branch of AST + * + * Version 1.22.3 (August 26, 2004) + * Bug fixes as identified by Michael Stahl; clean up of tabs/spaces + * and other refactorings + * o Fixed typeParameters omission in identPrimary and newStatement + * o Replaced GT reconcilliation code with simple semantic predicate + * o Adapted enum/assert keyword checking support from Michael Stahl's java15 grammar + * o Refactored typeDefinition production and field productions to reduce duplication + * + * Version 1.22.4 (October 21, 2004) + * Small bux fixes + * o Added typeArguments to explicitConstructorInvocation, e.g. new MyParameterised() + * o Added typeArguments to postfixExpression productions for anonymous inner class super + * constructor invocation, e.g. new Outer().super() + * o Fixed bug in array declarations identified by Geoff Roy + * + * This grammar is in the PUBLIC DOMAIN + */ + +class InternalJavaParser extends Parser; +options { + k = 2; // two token lookahead + exportVocab=Java; // Call its vocabulary "Java" + codeGenMakeSwitchThreshold = 2; // Some optimizations + codeGenBitsetTestThreshold = 3; + defaultErrorHandler = false; // Don't generate parser error handlers + buildAST = true; +// classHeaderSuffix = "Parser"; + importVocab = Common; + ASTLabelType = JavaNode; +// useTokenPrefix = true; + // This class is abstract + classHeaderPrefix = "public abstract"; + +} +tokens { + BLOCK; MODIFIERS; OBJBLOCK; SLIST; CTOR_DEF; METHOD_DEF; VARIABLE_DEF; + INSTANCE_INIT; STATIC_INIT; TYPE; CLASS_DEF; INTERFACE_DEF; + PACKAGE_DEF; ARRAY_DECLARATOR; EXTENDS_CLAUSE; IMPLEMENTS_CLAUSE; + PARAMETERS; PARAMETER_DEF; LABELED_STAT; TYPECAST; INDEX_OP; + POST_INC; POST_DEC; METHOD_CALL; EXPR; ARRAY_INIT; + IMPORT; UNARY_MINUS; UNARY_PLUS; CASE_GROUP; ELIST; FOR_INIT; FOR_CONDITION; + FOR_ITERATOR; EMPTY_STAT; FINAL="final"; ABSTRACT="abstract"; + STRICTFP="strictfp"; SUPER_CTOR_CALL; CTOR_CALL; VARIABLE_PARAMETER_DEF; + STATIC_IMPORT; ENUM_DEF; ENUM_CONSTANT_DEF; FOR_EACH_CLAUSE; ANNOTATION_DEF; ANNOTATIONS; + ANNOTATION; ANNOTATION_MEMBER_VALUE_PAIR; ANNOTATION_FIELD_DEF; ANNOTATION_ARRAY_INIT; + TYPE_ARGUMENTS; TYPE_ARGUMENT; TYPE_PARAMETERS; TYPE_PARAMETER; WILDCARD_TYPE; + TYPE_UPPER_BOUNDS; TYPE_LOWER_BOUNDS; + + ROOT;CASESLIST;SEPARATOR_COMMENT;BOF;SYNBLOCK;SPECIAL_COMMENT; + +} + +{ + /** + * Counts the number of LT seen in the typeArguments production. + * It is used in semantic predicates to ensure we have seen + * enough closing '>' characters; which actually may have been + * either GT, SR or BSR tokens. + */ + private int ltCounter = 0; + + protected abstract void attachStuff(JavaNode[] nodes) throws TokenStreamIOException; + +} + +// Compilation Unit: In Java, this is a single file. This is the start +// rule for this parser compilationUnit +parse + { + JavaNode root = (JavaNode) getASTFactory().create(); + root.setType(JavaTokenTypes.ROOT); + root.setText(getFilename()); + currentAST.root = root; + } + + : // A compilation unit starts with an optional package definition + ( (annotations "package")=> packageDefinition + | /* nothing */ + ) + + // Next we have a series of zero or more import statements + ( importDefinition )* + + // Wrapping things up with any number of class or interface + // definitions + ( typeDefinition )* + + EOF + ; + + +// Package statement: optional annotations followed by "package" then the package identifier. +packageDefinition + options {defaultErrorHandler = true;} // let ANTLR handle errors + : annotations p:"package"^ {#p.setType(PACKAGE_DEF);} identifier SEMI + ; + + +// Import statement: import followed by a package or class name +importDefinition + options {defaultErrorHandler = true;} + { boolean isStatic = false; } + : i:"import"^ {#i.setType(IMPORT);} ( "static"! {#i.setType(STATIC_IMPORT);} )? identifierStar SEMI + ; + +// A type definition is either a class, interface, enum or annotation with possible additional semis. +typeDefinition + options {defaultErrorHandler = true;} + : m:modifiers! + typeDefinitionInternal[#m] + | SEMI + ; + +// Protected type definitions production for reuse in other productions +protected typeDefinitionInternal[JavaNode mods] + : classDefinition[#mods] // inner class + | interfaceDefinition[#mods] // inner interface + | enumDefinition[#mods] // inner enum + | annotationDefinition[#mods] // inner annotation + ; + +// A declaration is the creation of a reference or primitive-type variable +// Create a separate Type/Var tree for each var in the var list. +declaration! + : m:modifiers t:typeSpec[false] v:variableDefinitions[#m,#t] + {#declaration = #v;} + ; + +// A type specification is a type name with possible brackets afterwards +// (which would make it an array type). +typeSpec[boolean addImagNode] + : classTypeSpec[addImagNode] + | builtInTypeSpec[addImagNode] + ; + +// A class type specification is a class type with either: +// - possible brackets afterwards +// (which would make it an array type). +// - generic type arguments after +classTypeSpec[boolean addImagNode] + : classOrInterfaceType[false] + (options{greedy=true;}: // match as many as possible + lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK! + )* + { + if ( addImagNode ) { + #classTypeSpec = #(#[TYPE,"TYPE"], #classTypeSpec); + } + } + ; + +// A non-built in type name, with possible type parameters +classOrInterfaceType[boolean addImagNode] + : IDENT^ (typeArguments)? + (options{greedy=true;}: // match as many as possible + DOT^ + IDENT (typeArguments)? + )* + { + if ( addImagNode ) { + #classOrInterfaceType = #(#[TYPE,"TYPE"], #classOrInterfaceType); + } + } + ; + +// A specialised form of typeSpec where built in types must be arrays +typeArgumentSpec + : classTypeSpec[true] + | builtInTypeArraySpec[true] + ; + +// A generic type argument is a class type, a possibly bounded wildcard type or a built-in type array +typeArgument + : ( typeArgumentSpec + | wildcardType + ) + {#typeArgument = #(#[TYPE_ARGUMENT,"TYPE_ARGUMENT"], #typeArgument);} + ; + +// Wildcard type indicating all types (with possible constraint) +wildcardType + : q:QUESTION^ {#q.setType(WILDCARD_TYPE);} + (("extends" | "super")=> typeArgumentBounds)? + ; + +// Type arguments to a class or interface type +typeArguments +{int currentLtLevel = 0;} + : + {currentLtLevel = ltCounter;} + LT! {ltCounter++;} + typeArgument + (options{greedy=true;}: // match as many as possible + {inputState.guessing !=0 || ltCounter == currentLtLevel + 1}? + COMMA typeArgument + )* + + ( // turn warning off since Antlr generates the right code, + // plus we have our semantic predicate below + options{generateAmbigWarnings=false;}: + typeArgumentsOrParametersEnd + )? + + // make sure we have gobbled up enough '>' characters + // if we are at the "top level" of nested typeArgument productions + {(currentLtLevel != 0) || ltCounter == currentLtLevel}? + + {#typeArguments = #(#[TYPE_ARGUMENTS, "TYPE_ARGUMENTS"], #typeArguments);} + ; + +// this gobbles up *some* amount of '>' characters, and counts how many +// it gobbled. +protected typeArgumentsOrParametersEnd + : GT! {ltCounter-=1;} + | SR! {ltCounter-=2;} + | BSR! {ltCounter-=3;} + ; + +// Restriction on wildcard types based on super class or derrived class +typeArgumentBounds + {boolean isUpperBounds = false;} + : + ( "extends"! {isUpperBounds=true;} | "super"! ) classOrInterfaceType[false] + { + if (isUpperBounds) + { + #typeArgumentBounds = #(#[TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS"], #typeArgumentBounds); + } + else + { + #typeArgumentBounds = #(#[TYPE_LOWER_BOUNDS,"TYPE_LOWER_BOUNDS"], #typeArgumentBounds); + } + } + ; + +// A builtin type array specification is a builtin type with brackets afterwards +builtInTypeArraySpec[boolean addImagNode] + : builtInType + (options{greedy=true;}: // match as many as possible + lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK! + )+ + + { + if ( addImagNode ) { + #builtInTypeArraySpec = #(#[TYPE,"TYPE"], #builtInTypeArraySpec); + } + } + ; + +// A builtin type specification is a builtin type with possible brackets +// afterwards (which would make it an array type). +builtInTypeSpec[boolean addImagNode] + : builtInType + (options{greedy=true;}: // match as many as possible + lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK! + )* + { + if ( addImagNode ) { + #builtInTypeSpec = #(#[TYPE,"TYPE"], #builtInTypeSpec); + } + } + ; + +// A type name. which is either a (possibly qualified and parameterized) +// class name or a primitive (builtin) type +type + : classOrInterfaceType[false] + | builtInType + ; + +// The primitive types. +builtInType + : "void" + | "boolean" + | "byte" + | "char" + | "short" + | "int" + | "float" + | "long" + | "double" + ; + +// A (possibly-qualified) java identifier. We start with the first IDENT +// and expand its name by adding dots and following IDENTS +identifier + : IDENT ( DOT^ IDENT )* + ; + +identifierStar + : IDENT + ( DOT^ IDENT )* + ( DOT^ STAR )? + ; + +// A list of zero or more modifiers. We could have used (modifier)* in +// place of a call to modifiers, but I thought it was a good idea to keep +// this rule separate so they can easily be collected in a Vector if +// someone so desires +modifiers + : + ( + //hush warnings since the semantic check for "@interface" solves the non-determinism + options{generateAmbigWarnings=false;}: + + modifier + | + //Semantic check that we aren't matching @interface as this is not an annotation + //A nicer way to do this would be nice + {LA(1)==AT && !LT(2).getText().equals("interface")}? annotation + )* + + {#modifiers = #([MODIFIERS, "MODIFIERS"], #modifiers);} + ; + +// modifiers for Java classes, interfaces, class/instance vars and methods +modifier + : "private" + | "public" + | "protected" + | "static" + | "transient" + | "final" + | "abstract" + | "native" + | "threadsafe" + | "synchronized" + | "volatile" + | "strictfp" + ; + +annotation! + : a:AT i:identifier ( lp:LPAREN ( args:annotationArguments )? rp:RPAREN )? + {#annotation = #(#[ANNOTATION,"ANNOTATION"],a, i, lp, args, rp);} + ; + +annotations + : (annotation)* + {#annotations = #([ANNOTATIONS, "ANNOTATIONS"], #annotations);} + ; + +annotationArguments + : annotationMemberValueInitializer | anntotationMemberValuePairs + ; + +anntotationMemberValuePairs + : annotationMemberValuePair ( COMMA annotationMemberValuePair )* + ; + +annotationMemberValuePair! + : i:IDENT ASSIGN! v:annotationMemberValueInitializer + {#annotationMemberValuePair = #(#[ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR"], i, v);} + ; + +annotationMemberValueInitializer + : + conditionalExpression | annotation | annotationMemberArrayInitializer + ; + +// This is an initializer used to set up an annotation member array. +annotationMemberArrayInitializer + : lc:LCURLY^ {#lc.setType(ANNOTATION_ARRAY_INIT);} + ( annotationMemberArrayValueInitializer + ( + // CONFLICT: does a COMMA after an initializer start a new + // initializer or start the option ',' at end? + // ANTLR generates proper code by matching + // the comma as soon as possible. + options { + warnWhenFollowAmbig = false; + } + : + COMMA annotationMemberArrayValueInitializer + )* + (COMMA)? + )? + RCURLY + ; + +// The two things that can initialize an annotation array element are a conditional expression +// and an annotation (nested annotation array initialisers are not valid) +annotationMemberArrayValueInitializer + : conditionalExpression + | annotation + ; + +superClassClause! + : ( "extends" c:classOrInterfaceType[false] )? + {#superClassClause = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],c);} + ; + +// Definition of a Java class +classDefinition![JavaNode modifiers] + : c:"class" IDENT + // it _might_ have type paramaters + (tp:typeParameters)? + // it _might_ have a superclass... + sc:superClassClause + // it might implement some interfaces... + ic:implementsClause + // now parse the body of the class + cb:classBlock + {#classDefinition = #(#[CLASS_DEF,"CLASS_DEF"], + modifiers,IDENT,tp,sc,ic,cb); + attachStuff(new JavaNode[] {#classDefinition, modifiers, #c}); + } + ; + +// Definition of a Java Interface +interfaceDefinition![JavaNode modifiers] + : i:"interface" IDENT + // it _might_ have type paramaters + (tp:typeParameters)? + // it might extend some other interfaces + ie:interfaceExtends + // now parse the body of the interface (looks like a class...) + ib:interfaceBlock + {#interfaceDefinition = #(#[INTERFACE_DEF,"INTERFACE_DEF"], + modifiers,IDENT,tp,ie,ib); + attachStuff(new JavaNode[] {#interfaceDefinition, modifiers, #i}); + } + ; + +enumDefinition![JavaNode modifiers] + : e:"enum" IDENT + // it might implement some interfaces... + ic:implementsClause + // now parse the body of the enum + eb:enumBlock + {#enumDefinition = #(#[ENUM_DEF,"ENUM_DEF"], + modifiers,IDENT,ic,eb); + attachStuff(new JavaNode[] {#enumDefinition, modifiers, #e}); + } + ; + +annotationDefinition![JavaNode modifiers] + : a:AT "interface" IDENT + // now parse the body of the annotation + ab:annotationBlock + {#annotationDefinition = #(#[ANNOTATION_DEF,"ANNOTATION_DEF"], + modifiers,IDENT,ab); + attachStuff(new JavaNode[] {#annotationDefinition, modifiers, #a}); + } + ; + +typeParameters +{int currentLtLevel = 0;} + : + {currentLtLevel = ltCounter;} + LT {ltCounter++;} + typeParameter (COMMA typeParameter)* + (typeArgumentsOrParametersEnd)? + + // make sure we have gobbled up enough '>' characters + // if we are at the "top level" of nested typeArgument productions + {(currentLtLevel != 0) || ltCounter == currentLtLevel}? + + {#typeParameters = #(#[TYPE_PARAMETERS, "TYPE_PARAMETERS"], #typeParameters);} + ; + +typeParameter + : + // I'm pretty sure Antlr generates the right thing here: + (id:IDENT) ( options{generateAmbigWarnings=false;}: typeParameterBounds )? + {#typeParameter = #(#[TYPE_PARAMETER,"TYPE_PARAMETER"], #typeParameter);} + ; + +typeParameterBounds + : + "extends"! classOrInterfaceType[false] + (BAND classOrInterfaceType[false])* + {#typeParameterBounds = #(#[TYPE_UPPER_BOUNDS,"TYPE_UPPER_BOUNDS"], #typeParameterBounds);} + ; + +// This is the body of a class. You can have classFields and extra semicolons. +classBlock + : lc:LCURLY^ + ( classField | SEMI )* + RCURLY + { #lc.setType(OBJBLOCK);} + //{#classBlock = #([OBJBLOCK, "OBJBLOCK"], #classBlock);} + ; + +// This is the body of an interface. You can have interfaceField and extra semicolons. +interfaceBlock + : lc:LCURLY^ + ( interfaceField | SEMI )* + RCURLY + { #lc.setType(OBJBLOCK);} + //{#interfaceBlock = #([OBJBLOCK, "OBJBLOCK"], #interfaceBlock);} + ; + +// This is the body of an annotation. You can have annotation fields and extra semicolons, +// That's about it (until you see what an annoation field is...) +annotationBlock + : lc:LCURLY^ + ( annotationField | SEMI )* + RCURLY + { #lc.setType(OBJBLOCK);} +// {#annotationBlock = #([OBJBLOCK, "OBJBLOCK"], #annotationBlock);} + ; + +// This is the body of an enum. You can have zero or more enum constants +// followed by any number of fields like a regular class +enumBlock + : lc:LCURLY^ + ( enumConstant ( options{greedy=true;}: COMMA! enumConstant )* ( COMMA! )? )? + ( SEMI! ( classField | SEMI! )* )? + RCURLY + { #lc.setType(OBJBLOCK);} +// {#enumBlock = #([OBJBLOCK, "OBJBLOCK"], #enumBlock);} + ; + +// An annotation field +annotationField! + : mods:modifiers + ( td:typeDefinitionInternal[#mods] + {#annotationField = #td;} + | t:typeSpec[false] // annotation field + ( i:IDENT // the name of the field + + LPAREN RPAREN + + rt:declaratorBrackets[#t] + + ( "default" amvi:annotationMemberValueInitializer ) ? +// { if (#d!=null) #d = #(d,#(amvi)); } + + SEMI + + {#annotationField = + #(#[ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF"], + mods, + #(#[TYPE,"TYPE"],rt), + i,LPAREN,RPAREN,amvi,SEMI + ); + attachStuff(new JavaNode[] {#annotationField, #mods, #t}); + } + | v:variableDefinitions[#mods,#t] // typeVariableDefinitions + { + #annotationField = #v; + } + ) + ) + ; + +//An enum constant may have optional parameters and may have a +//a class body +enumConstant! + : an:annotations + i:IDENT + ( lp:LPAREN + a:argList + rp:RPAREN + )? + ( b:enumConstantBlock )? + {#enumConstant = #([ENUM_CONSTANT_DEF, "ENUM_CONSTANT_DEF"], an, i, lp,a,rp, b);} + ; + +//The class-like body of an enum constant +enumConstantBlock + : LCURLY + ( enumConstantField | SEMI )* + RCURLY + {#enumConstantBlock = #([OBJBLOCK, "OBJBLOCK"], #enumConstantBlock);} + ; + +//An enum constant field is just like a class field but without +//the posibility of a constructor definition or a static initializer +enumConstantField! + : mods:modifiers + ( td:typeDefinitionInternal[#mods] + {#enumConstantField = #td;} + + | // A generic method has the typeParameters before the return type. + // This is not allowed for variable definitions, but this production + // allows it, a semantic check could be used if you wanted. + (tp:typeParameters)? t:typeSpec[false] // method or variable declaration(s) + ( IDENT // the name of the method + + // parse the formal parameter declarations. + LPAREN param:parameterDeclarationList RPAREN + + rt:declaratorBrackets[#t] + + // get the list of exceptions that this method is + // declared to throw + (tc:throwsClause)? + + ( s2:compoundStatement | semim:SEMI ) + {#enumConstantField = #(#[METHOD_DEF,"METHOD_DEF"], + mods, + tp, + #(#[TYPE,"TYPE"],rt), + IDENT, + param, + tc, + s2, + semim); + attachStuff(new JavaNode[] {#enumConstantField, #mods, #t}); + } + | v:variableDefinitions[#mods,#t] // typeVariableDefinitions + {#enumConstantField = #v; + } + ) + ) + + // "{ ... }" instance initializer + | s4:compoundStatement + {#enumConstantField = #(#[INSTANCE_INIT,"INSTANCE_INIT"], s4); + attachStuff(new JavaNode[] {#enumConstantField, #s4}); + } + ; + +// An interface can extend several other interfaces... +interfaceExtends + : ( + e:"extends"! + classOrInterfaceType[false] ( COMMA! classOrInterfaceType[false] )* + )? + {#interfaceExtends = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"], + #interfaceExtends);} + ; + +// A class can implement several interfaces... +implementsClause + : ( + i:"implements"! classOrInterfaceType[false] ( COMMA! classOrInterfaceType[false] )* + )? + {#implementsClause = #(#[IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE"], + #implementsClause);} + ; + +// Now the various things that can be defined inside a class +classField! + : // method, constructor, or variable declaration + mods:modifiers + ( td:typeDefinitionInternal[#mods] + {#classField = #td;} + + | (tp:typeParameters)? + ( + h:ctorHead s:constructorBody // constructor + {#classField = #(#[CTOR_DEF,"CTOR_DEF"], mods, tp, h, s); + attachStuff(new JavaNode[] {#classField, #mods, #h}); + } + + | // A generic method/ctor has the typeParameters before the return type. + // This is not allowed for variable definitions, but this production + // allows it, a semantic check could be used if you wanted. + t:typeSpec[false] // method or variable declaration(s) + ( IDENT // the name of the method + + // parse the formal parameter declarations. + LPAREN param:parameterDeclarationList RPAREN + + rt:declaratorBrackets[#t] + + // get the list of exceptions that this method is + // declared to throw + (tc:throwsClause)? + + ( s2:compoundStatement | semim:SEMI ) + {#classField = #(#[METHOD_DEF,"METHOD_DEF"], + mods, + tp, + #(#[TYPE,"TYPE"],rt), + IDENT, + LPAREN, + param, + RPAREN, + tc, + s2, + semim); + attachStuff(new JavaNode[] {#classField, #mods, #t}); + } + | v:variableDefinitions[#mods,#t] semi:SEMI!// typeVariableDefinitions + { + #classField = #v; + + #classField.addChild(#semi); + + AST next = #classField.getNextSibling(); + // HACK for multiple variable declaration in one statement + // e.g float x, y, z; + // the semicolon will only be added to the first statement so + // we have to add it manually to all others + if (next != null) + { + AST ssemi = JavaNodeHelper.getFirstChild(#classField, JavaTokenTypes.SEMI); + + for (AST var = next; var != null; var = var.getNextSibling()) + { + var.addChild(astFactory.create(ssemi)); + } + } + + + } + ) + ) + ) + + // "static { ... }" class initializer + | "static" s3:compoundStatement + {#classField = #(#[STATIC_INIT,"STATIC_INIT"], s3); + attachStuff(new JavaNode[] {#classField, #s3}); + } + + // "{ ... }" instance initializer + | s4:compoundStatement + {#classField = #(#[INSTANCE_INIT,"INSTANCE_INIT"], s4); + attachStuff(new JavaNode[] {#classField, #s4}); + } + ; + +// Now the various things that can be defined inside a interface +interfaceField! + : // method, constructor, or variable declaration + mods:modifiers + ( td:typeDefinitionInternal[#mods] + {#interfaceField = #td;} + + | (tp:typeParameters)? + // A generic method has the typeParameters before the return type. + // This is not allowed for variable definitions, but this production + // allows it, a semantic check could be used if you want a more strict + // grammar. + t:typeSpec[false] // method or variable declaration(s) + ( IDENT // the name of the method + + // parse the formal parameter declarations. + LPAREN param:parameterDeclarationList RPAREN + + rt:declaratorBrackets[#t] + + // get the list of exceptions that this method is + // declared to throw + (tc:throwsClause)? + + SEMI + + {#interfaceField = #(#[METHOD_DEF,"METHOD_DEF"], + mods, + tp, + #(#[TYPE,"TYPE"],rt), + IDENT, + LPAREN, + param, + RPAREN, + tc, + SEMI); + attachStuff(new JavaNode[] {#interfaceField, #mods, #t}); + } + | v:variableDefinitions[#mods,#t] semi:SEMI! + { + #interfaceField = #v; + + #interfaceField.addChild(#semi); + + AST next = #interfaceField.getNextSibling(); + // HACK for multiple variable declaration in one statement + // e.g float x, y, z; + // the semicolon will only be added to the first statement so + // we have to add it manually to all others + if (next != null) + { + AST ssemi = JavaNodeHelper.getFirstChild(#interfaceField, JavaTokenTypes.SEMI); + + for (AST var = next; var != null; var = var.getNextSibling()) + { + var.addChild(astFactory.create(ssemi)); + } + } + + + } + ) + ) + ; + +constructorBody + : lc:LCURLY^ {#lc.setType(SLIST);} + ( options { greedy=true; } : explicitConstructorInvocation)? + (statement)* + RCURLY + ; + +/** Catch obvious constructor calls, but not the expr.super(...) calls */ +explicitConstructorInvocation + : (typeArguments)? + ( "this" lp1:LPAREN^ argList RPAREN SEMI + {#lp1.setType(CTOR_CALL);} + | "super" lp2:LPAREN^ argList RPAREN SEMI + {#lp2.setType(SUPER_CTOR_CALL);} + ) + ; + +/** Catch variable definitions but add the semicolon ???*/ +typeVariableDefinitions[JavaNode mods, JavaNode t] + : v:variableDefinitions[mods,t] + (semi:SEMI + { + #v.addChild(#semi); + } + ) + ; + +variableDefinitions[JavaNode mods, JavaNode t] + : variableDeclarator[(JavaNode)getASTFactory().dupTree(mods), + (JavaNode)getASTFactory().dupTree(t)] + ( COMMA! + variableDeclarator[(JavaNode)getASTFactory().dupTree(mods), + (JavaNode)getASTFactory().dupTree(t)] + )* + + ; + +/** Declaration of a variable. This can be a class/instance variable, + * or a local variable in a method + * It can also include possible initialization. + */ +variableDeclarator![JavaNode mods, JavaNode t] + : id:IDENT d:declaratorBrackets[t] v:varInitializer + {#variableDeclarator = #(#[VARIABLE_DEF,"VARIABLE_DEF"], mods, #(#[TYPE,"TYPE"],d), id, v); + attachStuff(new JavaNode[] {#variableDeclarator,mods, t}); + } + ; + +declaratorBrackets[JavaNode typ] + : {#declaratorBrackets=typ;} + (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)* + ; + +varInitializer + : ( ASSIGN^ initializer )? + ; + +// This is an initializer used to set up an array. +arrayInitializer + : lc:LCURLY^ {#lc.setType(ARRAY_INIT);} + ( initializer + ( + // CONFLICT: does a COMMA after an initializer start a new + // initializer or start the option ',' at end? + // ANTLR generates proper code by matching + // the comma as soon as possible. + options { + warnWhenFollowAmbig = false; + } + : + COMMA initializer + )* + (COMMA)? + )? + RCURLY + ; + + +// The two "things" that can initialize an array element are an expression +// and another (nested) array initializer. +initializer + : expression + | arrayInitializer + ; + +// This is the header of a method. It includes the name and parameters +// for the method. +// This also watches for a list of exception classes in a "throws" clause. +ctorHead + : IDENT // the name of the method + + // parse the formal parameter declarations. + LPAREN parameterDeclarationList RPAREN + + // get the list of exceptions that this method is declared to throw + (throwsClause)? + ; + +// This is a list of exception classes that the method is declared to throw +throwsClause + : "throws"^ identifier ( COMMA identifier )* + ; + +// A list of formal parameters +// Zero or more parameters +// If a parameter is variable length (e.g. String... myArg) it is the right-most parameter +parameterDeclarationList + // The semantic check in ( .... )* block is flagged as superfluous, and seems superfluous but + // is the only way I could make this work. If my understanding is correct this is a known bug + : ( ( parameterDeclaration )=> parameterDeclaration + ( options {warnWhenFollowAmbig=false;} : ( COMMA parameterDeclaration ) => COMMA parameterDeclaration )* + ( COMMA variableLengthParameterDeclaration )? + | + variableLengthParameterDeclaration + )? + {#parameterDeclarationList = #(#[PARAMETERS,"PARAMETERS"], + #parameterDeclarationList);} + ; + +// A formal parameter. +parameterDeclaration! + : pm:parameterModifier t:typeSpec[false] id:IDENT + pd:declaratorBrackets[#t] + {#parameterDeclaration = #(#[PARAMETER_DEF,"PARAMETER_DEF"], + pm, #([TYPE,"TYPE"],pd), id);} + ; + +variableLengthParameterDeclaration! + : pm:parameterModifier t:typeSpec[false] TRIPLE_DOT id:IDENT + pd:declaratorBrackets[#t] + {#variableLengthParameterDeclaration = #(#[VARIABLE_PARAMETER_DEF,"VARIABLE_PARAMETER_DEF"], + pm, #([TYPE,"TYPE"],pd), id);} + ; + +parameterModifier + //final can appear amongst annotations in any order - greedily consume any preceding + //annotations to shut nond-eterminism warnings off + : (options{greedy=true;} : annotation)* (f:"final")? (annotation)* + {#parameterModifier = #(#[MODIFIERS,"MODIFIERS"], #parameterModifier);} + ; + +// Compound statement. This is used in many contexts: +// Inside a class definition prefixed with "static": +// it is a class initializer +// Inside a class definition without "static": +// it is an instance initializer +// As the body of a method +// As a completely indepdent braced block of code inside a method +// it starts a new scope for variable definitions + +compoundStatement + : lc:LCURLY^ {#lc.setType(SLIST);} + // include the (possibly-empty) list of statements + (statement)* + RCURLY + ; + + +statement + // A list of statements in curly braces -- start a new scope! + : compoundStatement + + // declarations are ambiguous with "ID DOT" relative to expression + // statements. Must backtrack to be sure. Could use a semantic + // predicate to test symbol table to see what the type was coming + // up, but that's pretty hard without a symbol table ;) + // (declaration)=> declaration SEMI + | (declaration)=> decl:declaration semi1:SEMI! + { + // add semicolon to the AST + #decl.addChild(#semi1); + + AST next = currentAST.root.getNextSibling(); + + // HACK for multiple variable declaration in one statement + // e.g float x, y, z; + // the semicolon will only be added to the first statement so + // we have to add it manually to all others + if (next != null) + { + AST semi = JavaNodeHelper.getFirstChild(currentAST.root, JavaTokenTypes.SEMI); + + for (AST var = next; var != null; var = var.getNextSibling()) + { + var.addChild(astFactory.create(semi)); + } + } + } + + // An expression statement. This could be a method call, + // assignment statement, or any other expression evaluated for + // side-effects. + | e:expression semi2:SEMI! + {#e.addChild(#semi2); + } + + //TODO: what abour interfaces, enums and annotations + // class definition + | m:modifiers! classDefinition[#m] + + // Attach a label to the front of a statement + | IDENT c:COLON^ {#c.setType(LABELED_STAT);} statement + + // If-else statement + | "if"^ LPAREN expression RPAREN statement + ( + // CONFLICT: the old "dangling-else" problem... + // ANTLR generates proper code matching + // as soon as possible. Hush warning. + options { + warnWhenFollowAmbig = false; + } + : + "else" statement + )? + + // For statement + | forStatement + + // While statement + | "while"^ LPAREN expression RPAREN statement + + // do-while statement + | "do"^ statement "while" LPAREN expression RPAREN SEMI + + // get out of a loop (or switch) + | "break"^ (IDENT)? SEMI + + // do next iteration of a loop + | "continue"^ (IDENT)? SEMI + + // Return an expression + | "return"^ (expression)? SEMI + + // switch/case statement + | "switch"^ LPAREN expression RPAREN LCURLY + ( casesGroup )* + RCURLY + + // exception try-catch block + | tryBlock + + // throw an exception + | "throw"^ expression SEMI + + // synchronize a statement + | synBlock:"synchronized"^ LPAREN expression RPAREN compoundStatement + { #synBlock.setType(SYNBLOCK);} + + // asserts (uncomment if you want 1.4 compatibility) + | "assert"^ expression ( COLON! expression )? SEMI + + // empty statement possibly ????? + | s:SEMI {#s.setType(EMPTY_STAT);} + ; + +forStatement + : f:"for"^ + LPAREN + ( (forInit SEMI)=>traditionalForClause + | forEachClause + ) + RPAREN + statement // statement to loop over + ; + +traditionalForClause + : + forInit SEMI // initializer + forCond SEMI // condition test + forIter // updater + ; + +forEachClause + : + p:parameterDeclaration COLON! expression + {#forEachClause = #(#[FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE"], #forEachClause);} + ; + +casesGroup + : ( // CONFLICT: to which case group do the statements bind? + // ANTLR generates proper code: it groups the + // many "case"/"default" labels together then + // follows them with the statements + options { + greedy = true; + } + : + aCase + )+ + caseSList + {#casesGroup = #([CASE_GROUP, "CASE_GROUP"], #casesGroup);} + ; + +aCase + : ("case"^ expression | "default") COLON + ; + +caseSList + : (statement)* + {#caseSList = #(#[CASESLIST,"CASESLIST"],#caseSList);} + ; + +// The initializer for a for loop +forInit + // if it looks like a declaration, it is + : ((declaration)=> declaration + // otherwise it could be an expression list... + | expressionList + )? + {#forInit = #(#[FOR_INIT,"FOR_INIT"],#forInit);} + ; + +forCond + : (expression)? + {#forCond = #(#[FOR_CONDITION,"FOR_CONDITION"],#forCond);} + ; + +forIter + : (expressionList)? + {#forIter = #(#[FOR_ITERATOR,"FOR_ITERATOR"],#forIter);} + ; + +// an exception handler try/catch block +tryBlock + : "try"^ compoundStatement + (handler)* + ( finallyClause )? + ; + +finallyClause + : "finally"^ compoundStatement + ; + +// an exception handler +handler + : "catch"^ LPAREN parameterDeclaration RPAREN compoundStatement + ; + + +// expressions +// Note that most of these expressions follow the pattern +// thisLevelExpression : +// nextHigherPrecedenceExpression +// (OPERATOR nextHigherPrecedenceExpression)* +// which is a standard recursive definition for a parsing an expression. +// The operators in java have the following precedences: +// lowest (13) = *= /= %= += -= <<= >>= >>>= &= ^= |= +// (12) ?: +// (11) || +// (10) && +// ( 9) | +// ( 8) ^ +// ( 7) & +// ( 6) == != +// ( 5) < <= > >= +// ( 4) << >> +// ( 3) +(binary) -(binary) +// ( 2) * / % +// ( 1) ++ -- +(unary) -(unary) ~ ! (type) +// [] () (method call) . (dot -- identifier qualification) +// new () (explicit parenthesis) +// +// the last two are not usually on a precedence chart; I put them in +// to point out that new has a higher precedence than '.', so you +// can validy use +// new Frame().show() +// +// Note that the above precedence levels map to the rules below... +// Once you have a precedence chart, writing the appropriate rules as below +// is usually very straightfoward + + + +// the mother of all expressions +expression + : assignmentExpression + {#expression = #(#[EXPR,"EXPR"],#expression);} + ; + + +// This is a list of expressions. +expressionList + : expression (COMMA expression)* + {#expressionList = #(#[ELIST,"ELIST"], expressionList);} + ; + + +// assignment expression (level 13) +assignmentExpression + : conditionalExpression + ( ( ASSIGN^ + | PLUS_ASSIGN^ + | MINUS_ASSIGN^ + | STAR_ASSIGN^ + | DIV_ASSIGN^ + | MOD_ASSIGN^ + | SR_ASSIGN^ + | BSR_ASSIGN^ + | SL_ASSIGN^ + | BAND_ASSIGN^ + | BXOR_ASSIGN^ + | BOR_ASSIGN^ + ) + assignmentExpression + )? + ; + + +// conditional test (level 12) +conditionalExpression + : logicalOrExpression + ( QUESTION^ assignmentExpression COLON conditionalExpression )? + ; + + +// logical or (||) (level 11) +logicalOrExpression + : logicalAndExpression (LOR^ logicalAndExpression)* + ; + + +// logical and (&&) (level 10) +logicalAndExpression + : inclusiveOrExpression (LAND^ inclusiveOrExpression)* + ; + + +// bitwise or non-short-circuiting or (|) (level 9) +inclusiveOrExpression + : exclusiveOrExpression (BOR^ exclusiveOrExpression)* + ; + + +// exclusive or (^) (level 8) +exclusiveOrExpression + : andExpression (BXOR^ andExpression)* + ; + + +// bitwise or non-short-circuiting and (&) (level 7) +andExpression + : equalityExpression (BAND^ equalityExpression)* + ; + + +// equality/inequality (==/!=) (level 6) +equalityExpression + : relationalExpression ((NOT_EQUAL^ | EQUAL^) relationalExpression)* + ; + + +// boolean relational expressions (level 5) +relationalExpression + : shiftExpression + ( ( ( LT^ + | GT^ + | LE^ + | GE^ + ) + shiftExpression + )* + | "instanceof"^ typeSpec[true] + ) + ; + + +// bit shift expressions (level 4) +shiftExpression + : additiveExpression ((SL^ | SR^ | BSR^) additiveExpression)* + ; + + +// binary addition/subtraction (level 3) +additiveExpression + : multiplicativeExpression ((PLUS^ | MINUS^) multiplicativeExpression)* + ; + + +// multiplication/division/modulo (level 2) +multiplicativeExpression + : unaryExpression ((STAR^ | DIV^ | MOD^ ) unaryExpression)* + ; + +unaryExpression + : INC^ unaryExpression + | DEC^ unaryExpression + | MINUS^ {#MINUS.setType(UNARY_MINUS);} unaryExpression + | PLUS^ {#PLUS.setType(UNARY_PLUS);} unaryExpression + | unaryExpressionNotPlusMinus + ; + +unaryExpressionNotPlusMinus + : BNOT^ unaryExpression + | LNOT^ unaryExpression + | ( // subrule allows option to shut off warnings + options { + // "(int" ambig with postfixExpr due to lack of sequence + // info in linear approximate LL(k). It's ok. Shut up. + generateAmbigWarnings=false; + } + : // If typecast is built in type, must be numeric operand + // Have to backtrack to see if operator follows + (LPAREN builtInTypeSpec[true] RPAREN unaryExpression)=> + lpb:LPAREN^ {#lpb.setType(TYPECAST);} builtInTypeSpec[true] RPAREN! + unaryExpression + + // Have to backtrack to see if operator follows. If no operator + // follows, it's a typecast. No semantic checking needed to parse. + // if it _looks_ like a cast, it _is_ a cast; else it's a "(expr)" + | (LPAREN classTypeSpec[true] RPAREN unaryExpressionNotPlusMinus)=> + lp:LPAREN^ {#lp.setType(TYPECAST);} classTypeSpec[true] RPAREN! + unaryExpressionNotPlusMinus + + | postfixExpression + ) + ; + +// qualified names, array expressions, method invocation, post inc/dec +postfixExpression + : + primaryExpression + + ( + /* + options { + // the use of postfixExpression in SUPER_CTOR_CALL adds DOT + // to the lookahead set, and gives loads of false non-det + // warnings. + // shut them off. + generateAmbigWarnings=false; + } + : */ + //type arguments are only appropriate for a parameterized method/ctor invocations + //semantic check may be needed here to ensure that this is the case + DOT^ (typeArguments)? + ( IDENT + ( lp:LPAREN^ {#lp.setType(METHOD_CALL);} + argList + RPAREN + )? + | "super" + ( // (new Outer()).super() (create enclosing instance) + lp3:LPAREN^ argList RPAREN + {#lp3.setType(SUPER_CTOR_CALL);} + | DOT^ (typeArguments)? IDENT + ( lps:LPAREN^ {#lps.setType(METHOD_CALL);} + argList + RPAREN + )? + ) + ) + | DOT^ "this" + | DOT^ newExpression + | lb:LBRACK^ {#lb.setType(INDEX_OP);} expression RBRACK + )* + + ( // possibly add on a post-increment or post-decrement. + // allows INC/DEC on too much, but semantics can check + in:INC^ {#in.setType(POST_INC);} + | de:DEC^ {#de.setType(POST_DEC);} + )? + ; + +// the basic element of an expression +primaryExpression + : identPrimary ( options {greedy=true;} : DOT^ "class" )? + | constant + | "true" + | "false" + | "null" + | newExpression + | "this" + | "super" + | LPAREN assignmentExpression RPAREN + // look for int.class and int[].class + | builtInType + ( lbt:LBRACK^ {#lbt.setType(ARRAY_DECLARATOR);} RBRACK! )* + DOT^ "class" + ; + +/** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class, + * and a.b.c.class refs. Also this(...) and super(...). Match + * this or super. + */ +identPrimary + : (ta1:typeArguments!)? + IDENT + // Syntax for method invocation with type arguments is + // foo("blah") + ( + options { + // .ident could match here or in postfixExpression. + // We do want to match here. Turn off warning. + greedy=true; + // This turns the ambiguity warning of the second alternative + // off. See below. (The "false" predicate makes it non-issue) + warnWhenFollowAmbig=false; + } + // we have a new nondeterminism because of + // typeArguments... only a syntactic predicate will help... + // The problem is that this loop here conflicts with + // DOT typeArguments "super" in postfixExpression (k=2) + // A proper solution would require a lot of refactoring... +// Original way. +// : (DOT (typeArguments)? IDENT) => +// DOT^ (ta2:typeArguments!)? IDENT + : (DOT^ (typeArguments)? IDENT) + | {false}? // FIXME: this is very ugly but it seems to work... + // this will also produce an ANTLR warning! + // Unfortunately a syntactic predicate can only select one of + // multiple alternatives on the same level, not break out of + // an enclosing loop, which is why this ugly hack (a fake + // empty alternative with always-false semantic predicate) + // is necessary. + )* + ( + options { + // ARRAY_DECLARATOR here conflicts with INDEX_OP in + // postfixExpression on LBRACK RBRACK. + // We want to match [] here, so greedy. This overcomes + // limitation of linear approximate lookahead. + greedy=true; + } + : ( lp:LPAREN^ {#lp.setType(METHOD_CALL);} + // if the input is valid, only the last IDENT may + // have preceding typeArguments... rather hacky, this is... +// Not required because see above +// {if (#ta2 != null) astFactory.addASTChild(currentAST, #ta2);} +// {if (#ta2 == null) astFactory.addASTChild(currentAST, #ta1);} + argList RPAREN + ) + | ( options {greedy=true;} : + lbc:LBRACK^ {#lbc.setType(ARRAY_DECLARATOR);} RBRACK! + )+ + )? + ; + +/** object instantiation. + * Trees are built as illustrated by the following input/tree pairs: + * + * new T() + * + * new + * | + * T -- ELIST + * | + * arg1 -- arg2 -- .. -- argn + * + * new int[] + * + * new + * | + * int -- ARRAY_DECLARATOR + * + * new int[] {1,2} + * + * new + * | + * int -- ARRAY_DECLARATOR -- ARRAY_INIT + * | + * EXPR -- EXPR + * | | + * 1 2 + * + * new int[3] + * new + * | + * int -- ARRAY_DECLARATOR + * | + * EXPR + * | + * 3 + * + * new int[1][2] + * + * new + * | + * int -- ARRAY_DECLARATOR + * | + * ARRAY_DECLARATOR -- EXPR + * | | + * EXPR 1 + * | + * 2 + * + */ +newExpression + : "new"^ (typeArguments)? type + ( LPAREN argList RPAREN (classBlock)? + + //java 1.1 + // Note: This will allow bad constructs like + // new int[4][][3] {exp,exp}. + // There needs to be a semantic check here... + // to make sure: + // a) [ expr ] and [ ] are not mixed + // b) [ expr ] and an init are not used together + + | newArrayDeclarator (arrayInitializer)? + ) + ; + +argList + : ( expressionList + | /*nothing*/ + {#argList = #[ELIST,"ELIST"];} + ) + ; + +newArrayDeclarator + : ( + // CONFLICT: + // newExpression is a primaryExpression which can be + // followed by an array index reference. This is ok, + // as the generated code will stay in this loop as + // long as it sees an LBRACK (proper behavior) + options { + warnWhenFollowAmbig = false; + } + : + lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} + (expression)? + RBRACK! + )+ + ; + +constant + : NUM_INT + | CHAR_LITERAL + | STRING_LITERAL + | NUM_FLOAT + | NUM_LONG + | NUM_DOUBLE + ; + + +//---------------------------------------------------------------------------- +// The Java scanner +//---------------------------------------------------------------------------- +class InternalJavaLexer extends Lexer; + +options { + exportVocab=Java; // call the vocabulary "Java" + testLiterals=false; // don't automatically test for literals + k=4; // four characters of lookahead + charVocabulary='\u0003'..'\uFFFF'; + // without inlining some bitset tests, couldn't do unicode; + // I need to make ANTLR generate smaller bitsets; see + // bottom of JavaLexer.java + codeGenBitsetTestThreshold=20; + // This class is abstract + classHeaderPrefix = "public abstract"; +} + +{ + /** flag for enabling the "assert" keyword */ + private boolean assertEnabled = true; + /** flag for enabling the "enum" keyword */ + private boolean enumEnabled = true; + + /** Enable the "assert" keyword */ + public void enableAssert(boolean shouldEnable) { assertEnabled = shouldEnable; } + /** Query the "assert" keyword state */ + public boolean isAssertEnabled() { return assertEnabled; } + /** Enable the "enum" keyword */ + public void enableEnum(boolean shouldEnable) { enumEnabled = shouldEnable; } + /** Query the "enum" keyword state */ + public boolean isEnumEnabled() { return enumEnabled; } + + protected abstract Token makeJavaDoc(Token node, String text) throws TokenStreamIOException; + +} + +// OPERATORS +QUESTION : '?' ; +LPAREN : '(' ; +RPAREN : ')' ; +LBRACK : '[' ; +RBRACK : ']' ; +LCURLY : '{' ; +RCURLY : '}' ; +COLON : ':' ; +COMMA : ',' ; +//DOT : '.' ; +ASSIGN : '=' ; +EQUAL : "==" ; +LNOT : '!' ; +BNOT : '~' ; +NOT_EQUAL : "!=" ; +DIV : '/' ; +DIV_ASSIGN : "/=" ; +PLUS : '+' ; +PLUS_ASSIGN : "+=" ; +INC : "++" ; +MINUS : '-' ; +MINUS_ASSIGN : "-=" ; +DEC : "--" ; +STAR : '*' ; +STAR_ASSIGN : "*=" ; +MOD : '%' ; +MOD_ASSIGN : "%=" ; +SR : ">>" ; +SR_ASSIGN : ">>=" ; +BSR : ">>>" ; +BSR_ASSIGN : ">>>=" ; +GE : ">=" ; +GT : ">" ; +SL : "<<" ; +SL_ASSIGN : "<<=" ; +LE : "<=" ; +LT : '<' ; +BXOR : '^' ; +BXOR_ASSIGN : "^=" ; +BOR : '|' ; +BOR_ASSIGN : "|=" ; +LOR : "||" ; +BAND : '&' ; +BAND_ASSIGN : "&=" ; +LAND : "&&" ; +SEMI : ';' ; + + +// Whitespace -- ignored +WS : ( ' ' + | '\t' + | '\f' + // handle newlines + | ( options {generateAmbigWarnings=false;} + : "\r\n" // Evil DOS + | '\r' // Macintosh + | '\n' // Unix (the right way) + ) + { newline(); } + )+ + { // _ttype = Token.SKIP; + } + ; + +protected SEPARATOR_COMMENT +: "//~" (~('\n'|'\r') {if (LA(1) == EOF_CHAR) break;} )* + ( '\n'! | '\r'!('\n'!)? )? + {newline();} +; + +// Single-line comments +protected SL_COMMENT +: "//" (~('\n'|'\r') {if (LA(1) == EOF_CHAR) break;} )* + ( '\n'! | '\r'!('\n'!)? )? + {newline(); + + } +; +COMMENT +: + ( + options { + // ANTLR does it right by consuming input as soon as possible + generateAmbigWarnings=false; + // TODO spec:SPECIAL_COMMENT {$setToken(spec);} | + }: + + sep:SEPARATOR_COMMENT {$setToken(sep); } | + sl:SL_COMMENT {$setToken(sl); } + ) +; + +// multiple-line comments +ML_COMMENT + : "/*" + ( /* '\r' '\n' can be matched in one alternative or by matching + '\r' in one iteration and '\n' in another. I am trying to + handle any flavor of newline that comes in, but the language + that allows both "\r\n" and "\r" and "\n" to all be valid + newline is ambiguous. Consequently, the resulting grammar + must be ambiguous. I'm shutting this warning off. + */ + options { + generateAmbigWarnings=false; + } + : + { LA(2)!='/' }? '*' + | '\r' '\n' {newline();} + | '\r' {newline();} + | '\n' {newline();} + | ~('*'|'\n'|'\r') + )* + "*/" + { + // $setType(Token.SKIP); + Token n = makeJavaDoc(makeToken(_ttype), $getText); + $setToken(n); + $setType(n.getType()); + } + ; + + +// character literals +CHAR_LITERAL + : '\'' ( ESC | ~('\''|'\n'|'\r'|'\\') ) '\'' + ; + +// string literals +STRING_LITERAL + : '"' (ESC|~('"'|'\\'|'\n'|'\r'))* '"' + ; + + +// escape sequence -- note that this is protected; it can only be called +// from another lexer rule -- it will not ever directly return a token to +// the parser +// There are various ambiguities hushed in this rule. The optional +// '0'...'9' digit matches should be matched here rather than letting +// them go back to STRING_LITERAL to be matched. ANTLR does the +// right thing by matching immediately; hence, it's ok to shut off +// the FOLLOW ambig warnings. +protected +ESC + : '\\' + ( 'n' + | 'r' + | 't' + | 'b' + | 'f' + | '"' + | '\'' + | '\\' + | ('u')+ HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT + | '0'..'3' + ( + options { + warnWhenFollowAmbig = false; + } + : '0'..'7' + ( + options { + warnWhenFollowAmbig = false; + } + : '0'..'7' + )? + )? + | '4'..'7' + ( + options { + warnWhenFollowAmbig = false; + } + : '0'..'7' + )? + ) + ; + + +// hexadecimal digit (again, note it's protected!) +protected +HEX_DIGIT + : ('0'..'9'|'A'..'F'|'a'..'f') + ; + + +// a dummy rule to force vocabulary to be all characters (except special +// ones that ANTLR uses internally (0 to 2) +protected +VOCAB + : '\3'..'\377' + ; + + +// an identifier. Note that testLiterals is set to true! This means +// that after we match the rule, we look in the literals table to see +// if it's a literal or really an identifer +IDENT + options {testLiterals=true;} + : ('a'..'z'|'A'..'Z'|'_'|'$') ('a'..'z'|'A'..'Z'|'_'|'0'..'9'|'$')* + { + // check if "assert" keyword is enabled + if (assertEnabled && "assert".equals($getText)) { + $setType(LITERAL_assert); // set token type for the rule in the parser + } + // check if "enum" keyword is enabled + if (enumEnabled && "enum".equals($getText)) { + $setType(LITERAL_enum); // set token type for the rule in the parser + } + } + ; + + +// a numeric literal +NUM_INT + {boolean isDecimal=false; Token t=null;} + : '.' {_ttype = DOT;} + ( + (('0'..'9')+ (EXPONENT)? (f1:FLOAT_SUFFIX {t=f1;})? + { + if (t != null && t.getText().toUpperCase().indexOf('F')>=0) { + _ttype = NUM_FLOAT; + } + else { + _ttype = NUM_DOUBLE; // assume double + } + }) + | + // JDK 1.5 token for variable length arguments + (".." {_ttype = TRIPLE_DOT;}) + )? + + | ( '0' {isDecimal = true;} // special case for just '0' + ( ('x'|'X') + ( // hex + // the 'e'|'E' and float suffix stuff look + // like hex digits, hence the (...)+ doesn't + // know when to stop: ambig. ANTLR resolves + // it correctly by matching immediately. It + // is therefor ok to hush warning. + options { + warnWhenFollowAmbig=false; + } + : HEX_DIGIT + )+ + + | //float or double with leading zero + (('0'..'9')+ ('.'|EXPONENT|FLOAT_SUFFIX)) => ('0'..'9')+ + + | ('0'..'7')+ // octal + )? + | ('1'..'9') ('0'..'9')* {isDecimal=true;} // non-zero decimal + ) + ( ('l'|'L') { _ttype = NUM_LONG; } + + // only check to see if it's a float if looks like decimal so far + | {isDecimal}? + ( '.' ('0'..'9')* (EXPONENT)? (f2:FLOAT_SUFFIX {t=f2;})? + | EXPONENT (f3:FLOAT_SUFFIX {t=f3;})? + | f4:FLOAT_SUFFIX {t=f4;} + ) + { + if (t != null && t.getText().toUpperCase() .indexOf('F') >= 0) { + _ttype = NUM_FLOAT; + } + else { + _ttype = NUM_DOUBLE; // assume double + } + } + )? + ; + +// JDK 1.5 token for annotations and their declarations +AT + : '@' + ; + +// a couple protected methods to assist in matching floating point numbers +protected +EXPONENT + : ('e'|'E') ('+'|'-')? ('0'..'9')+ + ; + + +protected +FLOAT_SUFFIX + : 'f'|'F'|'d'|'D' + ; +