Lines Matching refs:tree
17 * Unlike the prior interface, the ability to give a parse tree
133 "unrecognized parse tree node type");
203 "Intermediate representation of a Python parse tree."
399 * This function creates code objects from the parse tree represented by
409 char* str = "<syntax-tree>";
508 PyDoc_STR("Creates a list-tree representation of this ST.")},
510 PyDoc_STR("Creates a tuple-tree representation of this ST.")},
603 * Two aspects can be broken out in this code: creating a node tree from
613 static int validate_expr_tree(node *tree);
614 static int validate_file_input(node *tree);
615 static int validate_encoding_decl(node *tree);
636 node *tree;
649 * Convert the tree to the internal form before checking it.
651 tree = build_node_tree(tuple);
652 if (tree != 0) {
653 int start_sym = TYPE(tree);
656 if (validate_expr_tree(tree))
657 st = parser_newstobject(tree, PyST_EXPR);
659 PyNode_Free(tree);
663 if (validate_file_input(tree))
664 st = parser_newstobject(tree, PyST_SUITE);
666 PyNode_Free(tree);
670 if (validate_encoding_decl(tree))
671 st = parser_newstobject(tree, PyST_SUITE);
673 PyNode_Free(tree);
677 PyNode_Free(tree);
678 err_string("parse tree does not use a valid start symbol");
703 * the tree, otherwise, 0. Any required exception will be specified already,
840 "Illegal syntax-tree; cannot start with terminal symbol.");
911 #define VALIDATER(n) static int validate_##n(node *tree)
1001 validate_repeating_list(node *tree, int ntype, int (*vfunc)(node *),
1004 int nch = NCH(tree);
1005 int res = (nch && validate_ntype(tree, ntype)
1006 && vfunc(CHILD(tree, 0)));
1009 (void) validate_numnodes(tree, 1, name);
1012 res = validate_comma(CHILD(tree, --nch));
1016 res = (validate_comma(CHILD(tree, pos))
1017 && vfunc(CHILD(tree, pos + 1)));
1030 validate_class(node *tree)
1032 int nch = NCH(tree);
1033 int res = (validate_ntype(tree, classdef) &&
1037 res = (validate_name(CHILD(tree, 0), "class")
1038 && validate_ntype(CHILD(tree, 1), NAME)
1039 && validate_colon(CHILD(tree, nch - 2))
1040 && validate_suite(CHILD(tree, nch - 1)));
1043 (void) validate_numnodes(tree, 4, "class");
1048 res = ((validate_lparen(CHILD(tree, 2)) &&
1049 validate_testlist(CHILD(tree, 3)) &&
1050 validate_rparen(CHILD(tree, 4))));
1053 res = (validate_lparen(CHILD(tree,2)) &&
1054 validate_rparen(CHILD(tree,3)));
1065 validate_if(node *tree)
1067 int nch = NCH(tree);
1068 int res = (validate_ntype(tree, if_stmt)
1070 && validate_name(CHILD(tree, 0), "if")
1071 && validate_test(CHILD(tree, 1))
1072 && validate_colon(CHILD(tree, 2))
1073 && validate_suite(CHILD(tree, 3)));
1077 res = (validate_name(CHILD(tree, nch - 3), "else")
1078 && validate_colon(CHILD(tree, nch - 2))
1079 && validate_suite(CHILD(tree, nch - 1)));
1083 (void) validate_numnodes(tree, 4, "if");
1086 res = validate_numnodes(tree, 0, "if");
1091 res = (validate_name(CHILD(tree, j), "elif")
1092 && validate_colon(CHILD(tree, j + 2))
1093 && validate_test(CHILD(tree, j + 1))
1094 && validate_suite(CHILD(tree, j + 3)));
1107 validate_parameters(node *tree)
1109 int nch = NCH(tree);
1110 int res = validate_ntype(tree, parameters) && ((nch == 2) || (nch == 3));
1113 res = (validate_lparen(CHILD(tree, 0))
1114 && validate_rparen(CHILD(tree, nch - 1)));
1116 res = validate_varargslist(CHILD(tree, 1));
1119 (void) validate_numnodes(tree, 2, "parameters");
1132 validate_suite(node *tree)
1134 int nch = NCH(tree);
1135 int res = (validate_ntype(tree, suite) && ((nch == 1) || (nch >= 4)));
1138 res = validate_simple_stmt(CHILD(tree, 0));
1141 res = (validate_newline(CHILD(tree, 0))
1142 && validate_indent(CHILD(tree, 1))
1143 && validate_stmt(CHILD(tree, 2))
1144 && validate_dedent(CHILD(tree, nch - 1)));
1150 res = validate_stmt(CHILD(tree, i));
1153 res = validate_numnodes(tree, 4, "suite");
1160 validate_testlist(node *tree)
1162 return (validate_repeating_list(tree, testlist,
1168 validate_testlist1(node *tree)
1170 return (validate_repeating_list(tree, testlist1,
1176 validate_testlist_safe(node *tree)
1178 return (validate_repeating_list(tree, testlist_safe,
1186 validate_varargslist_trailer(node *tree, int start)
1188 int nch = NCH(tree);
1196 sym = TYPE(CHILD(tree, start));
1202 res = validate_name(CHILD(tree, start+1), NULL);
1204 res = (validate_name(CHILD(tree, start+1), NULL)
1205 && validate_comma(CHILD(tree, start+2))
1206 && validate_doublestar(CHILD(tree, start+3))
1207 && validate_name(CHILD(tree, start+4), NULL));
1214 res = validate_name(CHILD(tree, start+1), NULL);
1232 validate_varargslist(node *tree)
1234 int nch = NCH(tree);
1235 int res = validate_ntype(tree, varargslist) && (nch != 0);
1244 sym = TYPE(CHILD(tree, 0));
1249 res = validate_varargslist_trailer(tree, 0);
1253 sym = TYPE(CHILD(tree, nch-1));
1262 res = validate_fpdef(CHILD(tree, i));
1264 if (res && TYPE(CHILD(tree, i)) == EQUAL && (i+2 <= nch)) {
1265 res = (validate_equal(CHILD(tree, i))
1266 && validate_test(CHILD(tree, i+1)));
1271 res = validate_comma(CHILD(tree, i));
1274 && (TYPE(CHILD(tree, i)) == DOUBLESTAR
1275 || TYPE(CHILD(tree, i)) == STAR))
1283 res = validate_varargslist_trailer(tree, i);
1291 res = validate_comma(CHILD(tree, nch-1));
1299 res = validate_fpdef(CHILD(tree, 0));
1301 if (res && (i+2 <= nch) && TYPE(CHILD(tree, i)) == EQUAL) {
1302 res = (validate_equal(CHILD(tree, i))
1303 && validate_test(CHILD(tree, i+1)));
1311 res = (validate_comma(CHILD(tree, i))
1312 && validate_fpdef(CHILD(tree, i+1)));
1314 if (res && (nch - i) >= 2 && TYPE(CHILD(tree, i)) == EQUAL) {
1315 res = (validate_equal(CHILD(tree, i))
1316 && validate_test(CHILD(tree, i+1)));
1333 validate_list_iter(node *tree)
1335 int res = (validate_ntype(tree, list_iter)
1336 && validate_numnodes(tree, 1, "list_iter"));
1337 if (res && TYPE(CHILD(tree, 0)) == list_for)
1338 res = validate_list_for(CHILD(tree, 0));
1340 res = validate_list_if(CHILD(tree, 0));
1348 validate_comp_iter(node *tree)
1350 int res = (validate_ntype(tree, comp_iter)
1351 && validate_numnodes(tree, 1, "comp_iter"));
1352 if (res && TYPE(CHILD(tree, 0)) == comp_for)
1353 res = validate_comp_for(CHILD(tree, 0));
1355 res = validate_comp_if(CHILD(tree, 0));
1363 validate_list_for(node *tree)
1365 int nch = NCH(tree);
1369 res = validate_list_iter(CHILD(tree, 4));
1371 res = validate_numnodes(tree, 4, "list_for");
1374 res = (validate_name(CHILD(tree, 0), "for")
1375 && validate_exprlist(CHILD(tree, 1))
1376 && validate_name(CHILD(tree, 2), "in")
1377 && validate_testlist_safe(CHILD(tree, 3)));
1385 validate_comp_for(node *tree)
1387 int nch = NCH(tree);
1391 res = validate_comp_iter(CHILD(tree, 4));
1393 res = validate_numnodes(tree, 4, "comp_for");
1396 res = (validate_name(CHILD(tree, 0), "for")
1397 && validate_exprlist(CHILD(tree, 1))
1398 && validate_name(CHILD(tree, 2), "in")
1399 && validate_or_test(CHILD(tree, 3)));
1407 validate_list_if(node *tree)
1409 int nch = NCH(tree);
1413 res = validate_list_iter(CHILD(tree, 2));
1415 res = validate_numnodes(tree, 2, "list_if");
1418 res = (validate_name(CHILD(tree, 0), "if")
1419 && validate_old_test(CHILD(tree, 1)));
1427 validate_comp_if(node *tree)
1429 int nch = NCH(tree);
1433 res = validate_comp_iter(CHILD(tree, 2));
1435 res = validate_numnodes(tree, 2, "comp_if");
1438 res = (validate_name(CHILD(tree, 0), "if")
1439 && validate_old_test(CHILD(tree, 1)));
1451 validate_fpdef(node *tree)
1453 int nch = NCH(tree);
1454 int res = validate_ntype(tree, fpdef);
1458 res = validate_ntype(CHILD(tree, 0), NAME);
1460 res = (validate_lparen(CHILD(tree, 0))
1461 && validate_fplist(CHILD(tree, 1))
1462 && validate_rparen(CHILD(tree, 2)));
1464 res = validate_numnodes(tree, 1, "fpdef");
1471 validate_fplist(node *tree)
1473 return (validate_repeating_list(tree, fplist,
1482 validate_stmt(node *tree)
1484 int res = (validate_ntype(tree, stmt)
1485 && validate_numnodes(tree, 1, "stmt"));
1488 tree = CHILD(tree, 0);
1490 if (TYPE(tree) == simple_stmt)
1491 res = validate_simple_stmt(tree);
1493 res = validate_compound_stmt(tree);
1503 validate_simple_stmt(node *tree)
1505 int nch = NCH(tree);
1506 int res = (validate_ntype(tree, simple_stmt)
1508 && validate_small_stmt(CHILD(tree, 0))
1509 && validate_newline(CHILD(tree, nch - 1)));
1512 res = validate_numnodes(tree, 2, "simple_stmt");
1515 res = validate_semi(CHILD(tree, --nch));
1520 res = (validate_semi(CHILD(tree, i))
1521 && validate_small_stmt(CHILD(tree, i + 1)));
1528 validate_small_stmt(node *tree)
1530 int nch = NCH(tree);
1531 int res = validate_numnodes(tree, 1, "small_stmt");
1534 tree, 0));
1545 res = validate_node(CHILD(tree, 0));
1555 TYPE(CHILD(tree, 0)));
1565 validate_compound_stmt(node *tree)
1567 int res = (validate_ntype(tree, compound_stmt)
1568 && validate_numnodes(tree, 1, "compound_stmt"));
1574 tree = CHILD(tree, 0);
1575 ntype = TYPE(tree);
1584 res = validate_node(tree);
1588 "Illegal compound statement type: %d.", TYPE(tree));
1594 validate_yield_or_testlist(node *tree)
1596 if (TYPE(tree) == yield_expr)
1597 return validate_yield_expr(tree);
1599 return validate_testlist(tree);
1603 validate_expr_stmt(node *tree)
1606 int nch = NCH(tree);
1607 int res = (validate_ntype(tree, expr_stmt)
1609 && validate_testlist(CHILD(tree, 0)));
1612 && TYPE(CHILD(tree, 1)) == augassign) {
1613 res = validate_numnodes(CHILD(tree, 1), 1, "augassign")
1614 && validate_yield_or_testlist(CHILD(tree, 2));
1617 char *s = STR(CHILD(CHILD(tree, 1), 0));
1637 res = validate_equal(CHILD(tree, j))
1638 && validate_yield_or_testlist(CHILD(tree, j + 1));
1650 validate_print_stmt(node *tree)
1652 int nch = NCH(tree);
1653 int res = (validate_ntype(tree, print_stmt)
1655 && validate_name(CHILD(tree, 0), "print"));
1658 int sym = TYPE(CHILD(tree, 1));
1663 res = validate_test(CHILD(tree, i++));
1666 res = validate_numnodes(tree, 3, "print_stmt");
1668 res = (validate_ntype(CHILD(tree, i), RIGHTSHIFT)
1669 && validate_test(CHILD(tree, i+1)));
1677 res = (validate_comma(CHILD(tree, i))
1678 && validate_test(CHILD(tree, i+1)));
1683 res = validate_numnodes(tree, i, "print_stmt");
1685 res = validate_comma(CHILD(tree, i));
1693 validate_del_stmt(node *tree)
1695 return (validate_numnodes(tree, 2, "del_stmt")
1696 && validate_name(CHILD(tree, 0), "del")
1697 && validate_exprlist(CHILD(tree, 1)));
1702 validate_return_stmt(node *tree)
1704 int nch = NCH(tree);
1705 int res = (validate_ntype(tree, return_stmt)
1707 && validate_name(CHILD(tree, 0), "return"));
1710 res = validate_testlist(CHILD(tree, 1));
1717 validate_raise_stmt(node *tree)
1719 int nch = NCH(tree);
1720 int res = (validate_ntype(tree, raise_stmt)
1724 res = validate_name(CHILD(tree, 0), "raise");
1726 res = validate_test(CHILD(tree, 1));
1728 res = (validate_comma(CHILD(tree, 2))
1729 && validate_test(CHILD(tree, 3)));
1731 res = (validate_comma(CHILD(tree, 4))
1732 && validate_test(CHILD(tree, 5)));
1736 (void) validate_numnodes(tree, 2, "raise");
1738 res = (validate_comma(CHILD(tree, 2))
1739 && validate_test(CHILD(tree, 3)));
1748 validate_yield_expr(node *tree)
1750 int nch = NCH(tree);
1751 int res = (validate_ntype(tree, yield_expr)
1753 && validate_name(CHILD(tree, 0), "yield"));
1756 res = validate_testlist(CHILD(tree, 1));
1765 validate_yield_stmt(node *tree)
1767 return (validate_ntype(tree, yield_stmt)
1768 && validate_numnodes(tree, 1, "yield_stmt")
1769 && validate_yield_expr(CHILD(tree, 0)));
1774 validate_import_as_name(node *tree)
1776 int nch = NCH(tree);
1777 int ok = validate_ntype(tree, import_as_name);
1781 ok = validate_name(CHILD(tree, 0), NULL);
1783 ok = (validate_name(CHILD(tree, 0), NULL)
1784 && validate_name(CHILD(tree, 1), "as")
1785 && validate_name(CHILD(tree, 2), NULL));
1787 ok = validate_numnodes(tree, 3, "import_as_name");
1796 validate_dotted_name(node *tree)
1798 int nch = NCH(tree);
1799 int res = (validate_ntype(tree, dotted_name)
1801 && validate_name(CHILD(tree, 0), NULL));
1805 res = (validate_dot(CHILD(tree, i))
1806 && validate_name(CHILD(tree, i+1), NULL));
1815 validate_dotted_as_name(node *tree)
1817 int nch = NCH(tree);
1818 int res = validate_ntype(tree, dotted_as_name);
1822 res = validate_dotted_name(CHILD(tree, 0));
1824 res = (validate_dotted_name(CHILD(tree, 0))
1825 && validate_name(CHILD(tree, 1), "as")
1826 && validate_name(CHILD(tree, 2), NULL));
1838 validate_dotted_as_names(node *tree)
1840 int nch = NCH(tree);
1841 int res = is_odd(nch) && validate_dotted_as_name(CHILD(tree, 0));
1845 res = (validate_comma(CHILD(tree, i))
1846 && validate_dotted_as_name(CHILD(tree, i + 1)));
1853 validate_import_as_names(node *tree)
1855 int nch = NCH(tree);
1856 int res = validate_import_as_name(CHILD(tree, 0));
1860 res = (validate_comma(CHILD(tree, i))
1861 && validate_import_as_name(CHILD(tree, i + 1)));
1868 validate_import_name(node *tree)
1870 return (validate_ntype(tree, import_name)
1871 && validate_numnodes(tree, 2, "import_name")
1872 && validate_name(CHILD(tree, 0), "import")
1873 && validate_dotted_as_names(CHILD(tree, 1)));
1880 count_from_dots(node *tree)
1883 for (i = 1; i < NCH(tree); i++)
1884 if (TYPE(CHILD(tree, i)) != DOT)
1893 validate_import_from(node *tree)
1895 int nch = NCH(tree);
1896 int ndots = count_from_dots(tree);
1897 int havename = (TYPE(CHILD(tree, ndots + 1)) == dotted_name);
1899 int res = validate_ntype(tree, import_from)
1902 && validate_name(CHILD(tree, 0), "from")
1903 && (!havename || validate_dotted_name(CHILD(tree, ndots + 1)))
1904 && validate_name(CHILD(tree, offset + 1), "import");
1906 if (res && TYPE(CHILD(tree, offset + 2)) == LPAR)
1908 && validate_lparen(CHILD(tree, offset + 2))
1909 && validate_import_as_names(CHILD(tree, offset + 3))
1910 && validate_rparen(CHILD(tree, offset + 4)));
1911 else if (res && TYPE(CHILD(tree, offset + 2)) != STAR)
1912 res = validate_import_as_names(CHILD(tree, offset + 2));
1919 validate_import_stmt(node *tree)
1921 int nch = NCH(tree);
1922 int res = validate_numnodes(tree, 1, "import_stmt");
1925 int ntype = TYPE(CHILD(tree, 0));
1928 res = validate_node(CHILD(tree, 0));
1938 TYPE(CHILD(tree, 0)));
1947 validate_global_stmt(node *tree)
1950 int nch = NCH(tree);
1951 int res = (validate_ntype(tree, global_stmt)
1958 res = (validate_name(CHILD(tree, 0), "global")
1959 && validate_ntype(CHILD(tree, 1), NAME));
1961 res = (validate_comma(CHILD(tree, j))
1962 && validate_ntype(CHILD(tree, j + 1), NAME));
1973 validate_exec_stmt(node *tree)
1975 int nch = NCH(tree);
1976 int res = (validate_ntype(tree, exec_stmt)
1978 && validate_name(CHILD(tree, 0), "exec")
1979 && validate_expr(CHILD(tree, 1)));
1984 res = (validate_name(CHILD(tree, 2), "in")
1985 && validate_test(CHILD(tree, 3)));
1987 res = (validate_comma(CHILD(tree, 4))
1988 && validate_test(CHILD(tree, 5)));
1999 validate_assert_stmt(node *tree)
2001 int nch = NCH(tree);
2002 int res = (validate_ntype(tree, assert_stmt)
2004 && (validate_name(CHILD(tree, 0), "assert"))
2005 && validate_test(CHILD(tree, 1)));
2010 res = (validate_comma(CHILD(tree, 2))
2011 && validate_test(CHILD(tree, 3)));
2018 validate_while(node *tree)
2020 int nch = NCH(tree);
2021 int res = (validate_ntype(tree, while_stmt)
2023 && validate_name(CHILD(tree, 0), "while")
2024 && validate_test(CHILD(tree, 1))
2025 && validate_colon(CHILD(tree, 2))
2026 && validate_suite(CHILD(tree, 3)));
2029 res = (validate_name(CHILD(tree, 4), "else")
2030 && validate_colon(CHILD(tree, 5))
2031 && validate_suite(CHILD(tree, 6)));
2038 validate_for(node *tree)
2040 int nch = NCH(tree);
2041 int res = (validate_ntype(tree, for_stmt)
2043 && validate_name(CHILD(tree, 0), "for")
2044 && validate_exprlist(CHILD(tree, 1))
2045 && validate_name(CHILD(tree, 2), "in")
2046 && validate_testlist(CHILD(tree, 3))
2047 && validate_colon(CHILD(tree, 4))
2048 && validate_suite(CHILD(tree, 5)));
2051 res = (validate_name(CHILD(tree, 6), "else")
2052 && validate_colon(CHILD(tree, 7))
2053 && validate_suite(CHILD(tree, 8)));
2066 validate_try(node *tree)
2068 int nch = NCH(tree);
2070 int res = (validate_ntype(tree, try_stmt)
2074 res = (validate_name(CHILD(tree, 0), "try")
2075 && validate_colon(CHILD(tree, 1))
2076 && validate_suite(CHILD(tree, 2))
2077 && validate_colon(CHILD(tree, nch - 2))
2078 && validate_suite(CHILD(tree, nch - 1)));
2081 if (TYPE(CHILD(tree, nch - 3)) != except_clause)
2082 name = STR(CHILD(tree, nch - 3));
2088 if (res && (TYPE(CHILD(tree, pos)) == NAME) &&
2089 (strcmp(STR(CHILD(tree, pos)), "finally") == 0)) {
2090 res = (validate_numnodes(tree, 6, "try/finally")
2091 && validate_colon(CHILD(tree, 4))
2092 && validate_suite(CHILD(tree, 5)));
2096 while (res && pos < nch && (TYPE(CHILD(tree, pos)) == except_clause)) {
2097 res = (validate_except_clause(CHILD(tree, pos))
2098 && validate_colon(CHILD(tree
2099 && validate_suite(CHILD(tree, pos + 2)));
2103 if (res && pos < nch && (TYPE(CHILD(tree, pos)) == NAME) &&
2104 (strcmp(STR(CHILD(tree, pos)), "else") == 0)) {
2105 res = (validate_colon(CHILD(tree, pos + 1))
2106 && validate_suite(CHILD(tree, pos + 2)));
2111 res = (validate_name(CHILD(tree, pos), "finally")
2112 && validate_numnodes(tree, pos + 3, "try/except/finally")
2113 && validate_colon(CHILD(tree, pos + 1))
2114 && validate_suite(CHILD(tree, pos + 2)));
2121 validate_except_clause(node *tree)
2123 int nch = NCH(tree);
2124 int res = (validate_ntype(tree, except_clause)
2126 && validate_name(CHILD(tree, 0), "except"));
2129 res = validate_test(CHILD(tree, 1));
2131 if (TYPE(CHILD(tree, 2)) == NAME)
2132 res = validate_name(CHILD(tree, 2), "as");
2134 res = validate_comma(CHILD(tree, 2));
2135 res = res && validate_test(CHILD(tree, 3));
2142 validate_test(node *tree)
2144 int nch = NCH(tree);
2145 int res = validate_ntype(tree, test) && is_odd(nch);
2147 if (res && (TYPE(CHILD(tree, 0)) == lambdef))
2149 && validate_lambdef(CHILD(tree, 0)));
2151 res = validate_or_test(CHILD(tree, 0));
2153 validate_name(CHILD(tree, 1), "if") &&
2154 validate_or_test(CHILD(tree, 2)) &&
2155 validate_name(CHILD(tree, 3), "else") &&
2156 validate_test(CHILD(tree, 4)))));
2162 validate_old_test(node *tree)
2164 int nch = NCH(tree);
2165 int res = validate_ntype(tree, old_test) && (nch == 1);
2167 if (res && (TYPE(CHILD(tree, 0)) == old_lambdef))
2168 res = (validate_old_lambdef(CHILD(tree, 0)));
2170 res = (validate_or_test(CHILD(tree, 0)));
2176 validate_or_test(node *tree)
2178 int nch = NCH(tree);
2179 int res = validate_ntype(tree, or_test) && is_odd(nch);
2183 res = validate_and_test(CHILD(tree, 0));
2185 res = (validate_name(CHILD(tree, pos), "or")
2186 && validate_and_test(CHILD(tree, pos + 1)));
2193 validate_and_test(node *tree)
2196 int nch = NCH(tree);
2197 int res = (validate_ntype(tree, and_test)
2199 && validate_not_test(CHILD(tree, 0)));
2202 res = (validate_name(CHILD(tree, pos), "and")
2203 && validate_not_test(CHILD(tree, 0)));
2210 validate_not_test(node *tree)
2212 int nch = NCH(tree);
2213 int res = validate_ntype(tree, not_test) && ((nch == 1) || (nch == 2));
2217 res = (validate_name(CHILD(tree, 0), "not")
2218 && validate_not_test(CHILD(tree, 1)));
2220 res = validate_comparison(CHILD(tree, 0));
2227 validate_comparison(node *tree)
2230 int nch = NCH(tree);
2231 int res = (validate_ntype(tree, comparison)
2233 && validate_expr(CHILD(tree, 0)));
2236 res = (validate_comp_op(CHILD(tree, pos))
2237 && validate_expr(CHILD(tree, pos + 1)));
2244 validate_comp_op(node *tree)
2247 int nch = NCH(tree);
2249 if (!validate_ntype(tree, comp_op))
2256 tree = CHILD(tree, 0);
2257 switch (TYPE(tree)) {
2268 res = ((strcmp(STR(tree), "in") == 0)
2269 || (strcmp(STR(tree), "is") == 0));
2272 "illegal operator '%s'", STR(tree));
2280 else if ((res = validate_numnodes(tree, 2, "comp_op")) != 0) {
2281 res = (validate_ntype(CHILD(tree, 0), NAME)
2282 && validate_ntype(CHILD(tree, 1), NAME)
2283 && (((strcmp(STR(CHILD(tree, 0)), "is") == 0)
2284 && (strcmp(STR(CHILD(tree, 1)), "not") == 0))
2285 || ((strcmp(STR(CHILD(tree, 0)), "not") == 0)
2286 && (strcmp(STR(CHILD(tree, 1)), "in") == 0))));
2295 validate_expr(node *tree)
2298 int nch = NCH(tree);
2299 int res = (validate_ntype(tree, expr)
2301 && validate_xor_expr(CHILD(tree, 0)));
2304 res = (validate_xor_expr(CHILD(tree, j))
2305 && validate_vbar(CHILD(tree, j - 1)));
2312 validate_xor_expr(node *tree)
2315 int nch = NCH(tree);
2316 int res = (validate_ntype(tree, xor_expr)
2318 && validate_and_expr(CHILD(tree, 0)));
2321 res = (validate_circumflex(CHILD(tree, j - 1))
2322 && validate_and_expr(CHILD(tree, j)));
2329 validate_and_expr(node *tree)
2332 int nch = NCH(tree);
2333 int res = (validate_ntype(tree, and_expr)
2335 && validate_shift_expr(CHILD(tree, 0)));
2338 res = (validate_ampersand(CHILD(tree, pos))
2339 && validate_shift_expr(CHILD(tree, pos + 1)));
2346 validate_chain_two_ops(node *tree, int (*termvalid)(node *), int op1, int op2)
2349 int nch = NCH(tree);
2351 && (*termvalid)(CHILD(tree, 0)));
2354 if (TYPE(CHILD(tree, pos)) != op1)
2355 res = validate_ntype(CHILD(tree, pos), op2);
2357 res = (*termvalid)(CHILD(tree, pos + 1));
2364 validate_shift_expr(node *tree)
2366 return (validate_ntype(tree, shift_expr)
2367 && validate_chain_two_ops(tree, validate_arith_expr,
2373 validate_arith_expr(node *tree)
2375 return (validate_ntype(tree, arith_expr)
2376 && validate_chain_two_ops(tree, validate_term, PLUS, MINUS));
2381 validate_term(node *tree)
2384 int nch = NCH(tree);
2385 int res = (validate_ntype(tree, term)
2387 && validate_factor(CHILD(tree, 0)));
2390 res = (((TYPE(CHILD(tree, pos)) == STAR)
2391 || (TYPE(CHILD(tree, pos)) == SLASH)
2392 || (TYPE(CHILD(tree, pos)) == DOUBLESLASH)
2393 || (TYPE(CHILD(tree, pos)) == PERCENT))
2394 && validate_factor(CHILD(tree, pos + 1)));
2405 validate_factor(node *tree)
2407 int nch = NCH(tree);
2408 int res = (validate_ntype(tree, factor)
2410 && ((TYPE(CHILD(tree, 0)) == PLUS)
2411 || (TYPE(CHILD(tree, 0)) == MINUS)
2412 || (TYPE(CHILD(tree, 0)) == TILDE))
2413 && validate_factor(CHILD(tree, 1)))
2415 && validate_power(CHILD(tree, 0)))));
2425 validate_power(node *tree)
2428 int nch = NCH(tree);
2429 int res = (validate_ntype(tree, power) && (nch >= 1)
2430 && validate_atom(CHILD(tree, 0)));
2432 while (res && (pos < nch) && (TYPE(CHILD(tree, pos)) == trailer))
2433 res = validate_trailer(CHILD(tree, pos++));
2440 res = (validate_doublestar(CHILD(tree, pos))
2441 && validate_factor(CHILD(tree, pos + 1)));
2448 validate_atom(node *tree)
2451 int nch = NCH(tree);
2452 int res = validate_ntype(tree, atom);
2455 res = validate_numnodes(tree, nch+1, "atom");
2457 switch (TYPE(CHILD(tree, 0))) {
2460 && (validate_rparen(CHILD(tree, nch - 1))));
2463 if (TYPE(CHILD(tree, 1))==yield_expr)
2464 res = validate_yield_expr(CHILD(tree, 1));
2466 res = validate_testlist_comp(CHILD(tree, 1));
2471 res = validate_ntype(CHILD(tree, 1), RSQB);
2473 res = (validate_listmaker(CHILD(tree, 1))
2474 && validate_ntype(CHILD(tree, 2), RSQB));
2482 && validate_ntype(CHILD(tree, nch - 1), RBRACE));
2485 res = validate_dictorsetmaker(CHILD(tree, 1));
2489 && validate_testlist1(CHILD(tree, 1))
2490 && validate_ntype(CHILD(tree, 2), BACKQUOTE));
2498 res = validate_ntype(CHILD(tree, pos), STRING);
2513 validate_listmaker(node *tree)
2515 int nch = NCH(tree);
2521 ok = validate_test(CHILD(tree, 0));
2526 if (nch == 2 && TYPE(CHILD(tree, 1)) == list_for)
2527 ok = validate_list_for(CHILD(tree, 1));
2532 ok = (validate_comma(CHILD(tree, i))
2533 && validate_test(CHILD(tree, i+1)));
2537 ok = validate_comma(CHILD(tree, i));
2550 validate_testlist_comp(node *tree)
2552 int nch = NCH(tree);
2558 ok = validate_test(CHILD(tree, 0));
2564 if (nch == 2 && TYPE(CHILD(tree, 1)) == comp_for)
2565 ok = validate_comp_for(CHILD(tree, 1));
2570 ok = (validate_comma(CHILD(tree, i))
2571 && validate_test(CHILD(tree, i+1)));
2575 ok = validate_comma(CHILD(tree, i));
2588 validate_decorator(node *tree)
2591 int nch = NCH(tree);
2592 ok = (validate_ntype(tree, decorator) &&
2594 validate_at(CHILD(tree, 0)) &&
2595 validate_dotted_name(CHILD(tree, 1)) &&
2596 validate_newline(RCHILD(tree, -1)));
2599 ok = (validate_lparen(CHILD(tree, 2)) &&
2600 validate_rparen(RCHILD(tree, -2)));
2603 ok = validate_arglist(CHILD(tree, 3));
2613 validate_decorators(node *tree)
2616 nch = NCH(tree);
2617 ok = validate_ntype(tree, decorators) && nch >= 1;
2620 ok = validate_decorator(CHILD(tree, i));
2629 validate_with_item(node *tree)
2631 int nch = NCH(tree);
2632 int ok = (validate_ntype(tree, with_item)
2634 && validate_test(CHILD(tree, 0)));
2636 ok = (validate_name(CHILD(tree, 1), "as")
2637 && validate_expr(CHILD(tree, 2)));
2646 validate_with_stmt(node *tree)
2649 int nch = NCH(tree);
2650 int ok = (validate_ntype(tree, with_stmt)
2652 && validate_name(CHILD(tree, 0), "with")
2653 && validate_colon(RCHILD(tree, -2))
2654 && validate_suite(RCHILD(tree, -1)));
2656 ok = validate_with_item(CHILD(tree, i));
2666 validate_funcdef(node *tree)
2668 int nch = NCH(tree);
2669 int ok = (validate_ntype(tree, funcdef)
2671 && validate_name(RCHILD(tree, -5), "def")
2672 && validate_ntype(RCHILD(tree, -4), NAME)
2673 && validate_colon(RCHILD(tree, -2))
2674 && validate_parameters(RCHILD(tree, -3))
2675 && validate_suite(RCHILD(tree, -1)));
2684 validate_decorated(node *tree)
2686 int nch = NCH(tree);
2687 int ok = (validate_ntype(tree, decorated)
2689 && validate_decorators(RCHILD(tree, -2)));
2690 if (TYPE(RCHILD(tree, -1)) == funcdef)
2691 ok = ok && validate_funcdef(RCHILD(tree, -1));
2693 ok = ok && validate_class(RCHILD(tree, -1));
2698 validate_lambdef(node *tree)
2700 int nch = NCH(tree);
2701 int res = (validate_ntype(tree, lambdef)
2703 && validate_name(CHILD(tree, 0), "lambda")
2704 && validate_colon(CHILD(tree, nch - 2))
2705 && validate_test(CHILD(tree, nch - 1)));
2708 res = validate_varargslist(CHILD(tree, 1));
2710 (void) validate_numnodes(tree, 3, "lambdef");
2717 validate_old_lambdef(node *tree)
2719 int nch = NCH(tree);
2720 int res = (validate_ntype(tree, old_lambdef)
2722 && validate_name(CHILD(tree, 0), "lambda")
2723 && validate_colon(CHILD(tree, nch - 2))
2724 && validate_test(CHILD(tree, nch - 1)));
2727 res = validate_varargslist(CHILD(tree, 1));
2729 (void) validate_numnodes(tree, 3, "old_lambdef");
2740 validate_arglist(node *tree)
2742 int nch = NCH(tree);
2748 return validate_numnodes(tree, nch + 1, "arglist");
2752 if (TYPE(CHILD(tree, i)) == argument) {
2753 node *ch = CHILD(tree, i);
2764 ok = (validate_argument(CHILD(tree, i))
2765 && validate_comma(CHILD(tree, i+1)));
2776 int sym = TYPE(CHILD(tree, i));
2779 ok = validate_argument(CHILD(tree, i));
2787 ok = validate_star(CHILD(tree, i));
2789 ok = validate_test(CHILD(tree, i+1));
2791 ok = (validate_test(CHILD(tree, i+1))
2792 && validate_comma(CHILD(tree, i+2))
2793 && validate_doublestar(CHILD(tree, i+3))
2794 && validate_test(CHILD(tree, i+4)));
2802 ok = (validate_doublestar(CHILD(tree, i))
2803 && validate_test(CHILD(tree, i+1)));
2824 validate_argument(node *tree)
2826 int nch = NCH(tree);
2827 int res = (validate_ntype(tree, argument)
2829 && validate_test(CHILD(tree, 0)));
2832 res = validate_comp_for(CHILD(tree, 1));
2834 res = (validate_equal(CHILD(tree, 1))
2835 && validate_test(CHILD(tree, 2)));
2847 validate_trailer(node *tree)
2849 int nch = NCH(tree);
2850 int res = validate_ntype(tree, trailer) && ((nch == 2) || (nch == 3));
2853 switch (TYPE(CHILD(tree, 0))) {
2855 res = validate_rparen(CHILD(tree, nch - 1));
2857 res = validate_arglist(CHILD(tree, 1));
2860 res = (validate_numnodes(tree, 3, "trailer")
2861 && validate_subscriptlist(CHILD(tree, 1))
2862 && validate_ntype(CHILD(tree, 2), RSQB));
2865 res = (validate_numnodes(tree, 2, "trailer")
2866 && validate_ntype(CHILD(tree, 1), NAME));
2874 (void) validate_numnodes(tree, 2, "trailer");
2885 validate_subscriptlist(node *tree)
2887 return (validate_repeating_list(tree, subscriptlist,
2897 validate_subscript(node *tree)
2900 int nch = NCH(tree);
2901 int res = validate_ntype(tree, subscript) && (nch >= 1) && (nch <= 4);
2908 if (TYPE(CHILD(tree, 0)) == DOT)
2910 return (validate_numnodes(tree, 3, "subscript")
2911 && validate_dot(CHILD(tree, 0))
2912 && validate_dot(CHILD(tree, 1))
2913 && validate_dot(CHILD(tree, 2)));
2915 if (TYPE(CHILD(tree, 0)) == test)
2916 res = validate_test(CHILD(tree, 0));
2918 res = validate_colon(CHILD(tree, 0));
2925 if ((TYPE(CHILD(tree, 0)) != COLON) || (nch == 4)) {
2926 res = validate_test(CHILD(tree, 0));
2930 res = validate_colon(CHILD(tree, offset));
2934 if (TYPE(CHILD(tree, offset)) == test) {
2935 res = validate_test(CHILD(tree, offset));
2940 res = validate_sliceop(CHILD(tree, offset));
2948 validate_sliceop(node *tree)
2950 int nch = NCH(tree);
2951 int res = ((nch == 1) || validate_numnodes(tree, 2, "sliceop"))
2952 && validate_ntype(tree, sliceop);
2954 res = validate_numnodes(tree, 1, "sliceop");
2957 res = validate_colon(CHILD(tree, 0));
2959 res = validate_test(CHILD(tree, 1));
2966 validate_exprlist(node *tree)
2968 return (validate_repeating_list(tree, exprlist,
2980 validate_dictorsetmaker(node *tree)
2982 int nch = NCH(tree);
2983 int ok = validate_ntype(tree, dictorsetmaker);
2989 if (ok && (nch == 1 || TYPE(CHILD(tree, 1)) == COMMA)) {
2993 ok = validate_test(CHILD(tree, i++));
2995 ok = (validate_comma(CHILD(tree, i))
2996 && validate_test(CHILD(tree, i+1)));
3001 else if (ok && TYPE(CHILD(tree, 1)) == comp_for) {
3005 ok = (validate_test(CHILD(tree, 0))
3006 && validate_comp_for(CHILD(tree, 1)));
3008 else if (ok && NCH(tree) > 3 && TYPE(CHILD(tree, 3)) == comp_for) {
3012 ok = (validate_test(CHILD(tree, 0))
3013 && validate_colon(CHILD(tree, 1))
3014 && validate_test(CHILD(tree, 2))
3015 && validate_comp_for(CHILD(tree, 3)));
3022 ok = (validate_test(CHILD(tree, i))
3023 && validate_colon(CHILD(tree, i+1))
3024 && validate_test(CHILD(tree, i+2)));
3033 ok = (validate_comma(CHILD(tree, i))
3034 && validate_test(CHILD(tree, i+1))
3035 && validate_colon(CHILD(tree, i+2))
3036 && validate_test(CHILD(tree, i+3)));
3043 ok = validate_comma(CHILD(tree, i));
3055 validate_eval_input(node *tree)
3058 int nch = NCH(tree);
3059 int res = (validate_ntype(tree, eval_input)
3061 && validate_testlist(CHILD(tree, 0))
3062 && validate_ntype(CHILD(tree, nch - 1), ENDMARKER));
3065 res = validate_ntype(CHILD(tree, pos), NEWLINE);
3072 validate_node(node *tree)
3078 while (res && (tree != 0)) {
3079 nch = NCH(tree);
3081 switch (TYPE(tree)) {
3086 res = validate_funcdef(tree);
3089 res = validate_with_stmt(tree);
3092 res = validate_class(tree);
3095 res = validate_decorated(tree);
3098 * "Trivial" parse tree nodes.
3102 res = validate_stmt(tree);
3109 res = validate_small_stmt(tree);
3112 res = (validate_numnodes(tree, 1, "flow_stmt")
3113 && ((TYPE(CHILD(tree, 0)) == break_stmt)
3114 || (TYPE(CHILD(tree, 0)) == continue_stmt)
3115 || (TYPE(CHILD(tree, 0)) == yield_stmt)
3116 || (TYPE(CHILD(tree, 0)) == return_stmt)
3117 || (TYPE(CHILD(tree, 0)) == raise_stmt)));
3119 next = CHILD(tree, 0);
3124 res = validate_yield_stmt(tree);
3130 res = validate_simple_stmt(tree);
3133 res = validate_compound_stmt(tree);
3139 res = validate_expr_stmt(tree);
3142 res = validate_print_stmt(tree);
3145 res = validate_del_stmt(tree);
3148 res = (validate_numnodes(tree, 1, "pass")
3149 && validate_name(CHILD(tree, 0), "pass"));
3152 res = (validate_numnodes(tree, 1, "break")
3153 && validate_name(CHILD(tree, 0), "break"));
3156 res = (validate_numnodes(tree, 1, "continue")
3157 && validate_name(CHILD(tree, 0), "continue"));
3160 res = validate_return_stmt(tree);
3163 res = validate_raise_stmt(tree);
3166 res = validate_import_stmt(tree);
3169 res = validate_import_name(tree);
3172 res = validate_import_from(tree);
3175 res = validate_global_stmt(tree);
3178 res = validate_exec_stmt(tree);
3181 res = validate_assert_stmt(tree);
3184 res = validate_if(tree);
3187 res = validate_while(tree);
3190 res = validate_for(tree);
3193 res = validate_try(tree);
3196 res = validate_suite(tree);
3202 res = validate_testlist(tree);
3205 res = validate_yield_expr(tree);
3208 res = validate_testlist1(tree);
3211 res = validate_test(tree);
3214 res = validate_and_test(tree);
3217 res = validate_not_test(tree);
3220 res = validate_comparison(tree);
3223 res = validate_exprlist(tree);
3226 res = validate_comp_op(tree);
3229 res = validate_expr(tree);
3232 res = validate_xor_expr(tree);
3235 res = validate_and_expr(tree);
3238 res = validate_shift_expr(tree);
3241 res = validate_arith_expr(tree);
3244 res = validate_term(tree);
3247 res = validate_factor(tree);
3250 res = validate_power(tree);
3253 res = validate_atom(tree);
3262 tree = next;
3269 validate_expr_tree(node *tree)
3271 int res = validate_eval_input(tree);
3284 validate_file_input(node *tree)
3287 int nch = NCH(tree) - 1;
3289 && validate_ntype(CHILD(tree, nch), ENDMARKER));
3292 if (TYPE(CHILD(tree, j)) == stmt)
3293 res = validate_stmt(CHILD(tree, j));
3295 res = validate_newline(CHILD(tree, j));
3308 validate_encoding_decl(node *tree)
3310 int nch = NCH(tree);
3312 && validate_file_input(CHILD(tree, 0)));
3363 PyDoc_STR("Creates a tuple-tree representation of an ST.")},
3365 PyDoc_STR("Creates a list-tree representation of an ST.")},
3379 PyDoc_STR("Creates an ST object from a tree representation.")},
3381 PyDoc_STR("Creates an ST object from a tree representation.")},
3383 PyDoc_STR("Creates a tuple-tree representation of an ST.")},
3385 PyDoc_STR("Creates a list-tree representation of an ST.")},
3387 PyDoc_STR("Creates an ST object from a tree representation.")},
3389 PyDoc_STR("Creates an ST object from a tree representation.")},
