Lines Matching refs:tree
17 * Unlike the prior interface, the ability to give a parse tree
133 "unrecognized parse tree node type");
192 PyDoc_STR("Creates a list-tree representation of this ST.")},
194 PyDoc_STR("Creates a tuple-tree representation of this ST.")},
227 "Intermediate representation of a Python parse tree.",
438 * This function creates code objects from the parse tree represented by
448 char* str = "<syntax-tree>";
623 * Two aspects can be broken out in this code: creating a node tree from
633 static int validate_expr_tree(node *tree);
634 static int validate_file_input(node *tree);
635 static int validate_encoding_decl(node *tree);
656 node *tree;
669 * Convert the tree to the internal form before checking it.
671 tree = build_node_tree(tuple);
672 if (tree != 0) {
673 int start_sym = TYPE(tree);
676 if (validate_expr_tree(tree))
677 st = parser_newstobject(tree, PyST_EXPR);
679 PyNode_Free(tree);
683 if (validate_file_input(tree))
684 st = parser_newstobject(tree, PyST_SUITE);
686 PyNode_Free(tree);
690 if (validate_encoding_decl(tree))
691 st = parser_newstobject(tree, PyST_SUITE);
693 PyNode_Free(tree);
697 PyNode_Free(tree);
698 err_string("parse tree does not use a valid start symbol");
732 * the tree, otherwise, 0. Any required exception will be specified already,
869 "Illegal syntax-tree; cannot start with terminal symbol.");
940 tree)
1030 validate_repeating_list(node *tree, int ntype, int (*vfunc)(node *),
1033 int nch = NCH(tree);
1034 int res = (nch && validate_ntype(tree, ntype)
1035 && vfunc(CHILD(tree, 0)));
1038 (void) validate_numnodes(tree, 1, name);
1041 res = validate_comma(CHILD(tree, --nch));
1045 res = (validate_comma(CHILD(tree, pos))
1046 && vfunc(CHILD(tree, pos + 1)));
1059 validate_class(node *tree)
1061 int nch = NCH(tree);
1062 int res = (validate_ntype(tree, classdef) &&
1066 res = (validate_name(CHILD(tree, 0), "class")
1067 && validate_ntype(CHILD(tree, 1), NAME)
1068 && validate_colon(CHILD(tree, nch - 2))
1069 && validate_suite(CHILD(tree, nch - 1)));
1072 (void) validate_numnodes(tree, 4, "class");
1077 res = ((validate_lparen(CHILD(tree, 2)) &&
1078 validate_testlist(CHILD(tree, 3)) &&
1079 validate_rparen(CHILD(tree, 4))));
1082 res = (validate_lparen(CHILD(tree,2)) &&
1083 validate_rparen(CHILD(tree,3)));
1094 validate_if(node *tree)
1096 int nch = NCH(tree);
1097 int res = (validate_ntype(tree, if_stmt)
1099 && validate_name(CHILD(tree, 0), "if")
1100 && validate_test(CHILD(tree, 1))
1101 && validate_colon(CHILD(tree, 2))
1102 && validate_suite(CHILD(tree, 3)));
1106 res = (validate_name(CHILD(tree, nch - 3), "else")
1107 && validate_colon(CHILD(tree, nch - 2))
1108 && validate_suite(CHILD(tree, nch - 1)));
1112 (void) validate_numnodes(tree, 4, "if");
1115 res = validate_numnodes(tree, 0, "if");
1120 res = (validate_name(CHILD(tree, j), "elif")
1121 && validate_colon(CHILD(tree, j + 2))
1122 && validate_test(CHILD(tree, j + 1))
1123 && validate_suite(CHILD(tree, j + 3)));
1136 validate_parameters(node *tree)
1138 int nch = NCH(tree);
1139 int res = validate_ntype(tree, parameters) && ((nch == 2) || (nch == 3));
1142 res = (validate_lparen(CHILD(tree, 0))
1143 && validate_rparen(CHILD(tree, nch - 1)));
1145 res = validate_varargslist(CHILD(tree, 1));
1148 (void) validate_numnodes(tree, 2, "parameters");
1161 validate_suite(node *tree)
1163 int nch = NCH(tree);
1164 int res = (validate_ntype(tree, suite) && ((nch == 1) || (nch >= 4)));
1167 res = validate_simple_stmt(CHILD(tree, 0));
1170 res = (validate_newline(CHILD(tree, 0))
1171 && validate_indent(CHILD(tree, 1))
1172 && validate_stmt(CHILD(tree, 2))
1173 && validate_dedent(CHILD(tree, nch - 1)));
1179 res = validate_stmt(CHILD(tree, i));
1182 res = validate_numnodes(tree, 4, "suite");
1189 validate_testlist(node *tree)
1191 return (validate_repeating_list(tree, testlist,
1197 validate_testlist1(node *tree)
1199 return (validate_repeating_list(tree, testlist1,
1205 validate_testlist_safe(node *tree)
1207 return (validate_repeating_list(tree, testlist_safe,
1215 validate_varargslist_trailer(node *tree, int start)
1217 int nch = NCH(tree);
1225 sym = TYPE(CHILD(tree, start));
1231 res = validate_name(CHILD(tree, start+1), NULL);
1233 res = (validate_name(CHILD(tree, start+1), NULL)
1234 && validate_comma(CHILD(tree, start+2))
1235 && validate_doublestar(CHILD(tree, start+3))
1236 && validate_name(CHILD(tree, start+4), NULL));
1243 res = validate_name(CHILD(tree, start+1), NULL);
1261 validate_varargslist(node *tree)
1263 int nch = NCH(tree);
1264 int res = validate_ntype(tree, varargslist) && (nch != 0);
1273 sym = TYPE(CHILD(tree, 0));
1278 res = validate_varargslist_trailer(tree, 0);
1282 sym = TYPE(CHILD(tree, nch-1));
1291 res = validate_fpdef(CHILD(tree, i));
1293 if (res && TYPE(CHILD(tree, i)) == EQUAL && (i+2 <= nch)) {
1294 res = (validate_equal(CHILD(tree, i))
1295 && validate_test(CHILD(tree, i+1)));
1300 res = validate_comma(CHILD(tree, i));
1303 && (TYPE(CHILD(tree, i)) == DOUBLESTAR
1304 || TYPE(CHILD(tree, i)) == STAR))
1312 res = validate_varargslist_trailer(tree, i);
1320 res = validate_comma(CHILD(tree, nch-1));
1328 res = validate_fpdef(CHILD(tree, 0));
1330 if (res && (i+2 <= nch) && TYPE(CHILD(tree, i)) == EQUAL) {
1331 res = (validate_equal(CHILD(tree, i))
1332 && validate_test(CHILD(tree, i+1)));
1340 res = (validate_comma(CHILD(tree, i))
1341 && validate_fpdef(CHILD(tree, i+1)));
1343 if (res && (nch - i) >= 2 && TYPE(CHILD(tree, i)) == EQUAL) {
1344 res = (validate_equal(CHILD(tree, i))
1345 && validate_test(CHILD(tree, i+1)));
1362 validate_list_iter(node *tree)
1364 int res = (validate_ntype(tree, list_iter)
1365 && validate_numnodes(tree, 1, "list_iter"));
1366 if (res && TYPE(CHILD(tree, 0)) == list_for)
1367 res = validate_list_for(CHILD(tree, 0));
1369 res = validate_list_if(CHILD(tree, 0));
1377 validate_comp_iter(node *tree)
1379 int res = (validate_ntype(tree, comp_iter)
1380 && validate_numnodes(tree, 1, "comp_iter"));
1381 if (res && TYPE(CHILD(tree, 0)) == comp_for)
1382 res = validate_comp_for(CHILD(tree, 0));
1384 res = validate_comp_if(CHILD(tree, 0));
1392 validate_list_for(node *tree)
1394 int nch = NCH(tree);
1398 res = validate_list_iter(CHILD(tree, 4));
1400 res = validate_numnodes(tree, 4, "list_for");
1403 res = (validate_name(CHILD(tree, 0), "for")
1404 && validate_exprlist(CHILD(tree, 1))
1405 && validate_name(CHILD(tree, 2), "in")
1406 && validate_testlist_safe(CHILD(tree, 3)));
1414 validate_comp_for(node *tree)
1416 int nch = NCH(tree);
1420 res = validate_comp_iter(CHILD(tree, 4));
1422 res = validate_numnodes(tree, 4, "comp_for");
1425 res = (validate_name(CHILD(tree, 0), "for")
1426 && validate_exprlist(CHILD(tree, 1))
1427 && validate_name(CHILD(tree, 2), "in")
1428 && validate_or_test(CHILD(tree, 3)));
1436 validate_list_if(node *tree)
1438 int nch = NCH(tree);
1442 res = validate_list_iter(CHILD(tree, 2));
1444 res = validate_numnodes(tree, 2, "list_if");
1447 res = (validate_name(CHILD(tree, 0), "if")
1448 && validate_old_test(CHILD(tree, 1)));
1456 validate_comp_if(node *tree)
1458 int nch = NCH(tree);
1462 res = validate_comp_iter(CHILD(tree, 2));
1464 res = validate_numnodes(tree, 2, "comp_if");
1467 res = (validate_name(CHILD(tree, 0), "if")
1468 && validate_old_test(CHILD(tree, 1)));
1480 validate_fpdef(node *tree)
1482 int nch = NCH(tree);
1483 int res = validate_ntype(tree, fpdef);
1487 res = validate_ntype(CHILD(tree, 0), NAME);
1489 res = (validate_lparen(CHILD(tree, 0))
1490 && validate_fplist(CHILD(tree, 1))
1491 && validate_rparen(CHILD(tree, 2)));
1493 res = validate_numnodes(tree, 1, "fpdef");
1500 validate_fplist(node *tree)
1502 return (validate_repeating_list(tree, fplist,
1511 validate_stmt(node *tree)
1513 int res = (validate_ntype(tree, stmt)
1514 && validate_numnodes(tree, 1, "stmt"));
1517 tree = CHILD(tree, 0);
1519 if (TYPE(tree) == simple_stmt)
1520 res = validate_simple_stmt(tree);
1522 res = validate_compound_stmt(tree);
1532 validate_simple_stmt(node *tree)
1534 int nch = NCH(tree);
1535 int res = (validate_ntype(tree, simple_stmt)
1537 && validate_small_stmt(CHILD(tree, 0))
1538 && validate_newline(CHILD(tree, nch - 1)));
1541 res = validate_numnodes(tree, 2, "simple_stmt");
1544 res = validate_semi(CHILD(tree, --nch));
1549 res = (validate_semi(CHILD(tree, i))
1550 && validate_small_stmt(CHILD(tree, i + 1)));
1557 validate_small_stmt(node *tree)
1559 int nch = NCH(tree);
1560 int res = validate_numnodes(tree, 1, "small_stmt");
1563 int ntype = TYPE(CHILD(tree, 0));
1574 res = validate_node(CHILD(tree, 0));
1584 TYPE(CHILD(tree, 0)));
1594 validate_compound_stmt(node *tree)
1596 int res = (validate_ntype(tree, compound_stmt)
1597 && validate_numnodes(tree, 1, "compound_stmt"));
1603 tree = CHILD(tree, 0);
1604 ntype = TYPE(tree);
1613 res = validate_node(tree);
1617 "Illegal compound statement type: %d.", TYPE(tree));
1623 validate_yield_or_testlist(node *tree)
1625 if (TYPE(tree) == yield_expr)
1626 return validate_yield_expr(tree);
1628 return validate_testlist(tree);
1632 validate_expr_stmt(node *tree)
1635 int nch = NCH(tree);
1636 int res = (validate_ntype(tree, expr_stmt)
1638 && validate_testlist(CHILD(tree, 0)));
1641 && TYPE(CHILD(tree, 1)) == augassign) {
1642 res = validate_numnodes(CHILD(tree, 1), 1, "augassign")
1643 && validate_yield_or_testlist(CHILD(tree, 2));
1646 char *s = STR(CHILD(CHILD(tree, 1), 0));
1666 res = validate_equal(CHILD(tree, j))
1667 && validate_yield_or_testlist(CHILD(tree, j + 1));
1679 validate_print_stmt(node *tree)
1681 int nch = NCH(tree);
1682 int res = (validate_ntype(tree, print_stmt)
1684 && validate_name(CHILD(tree, 0), "print"));
1687 int sym = TYPE(CHILD(tree, 1));
1692 res = validate_test(CHILD(tree, i++));
1695 res = validate_numnodes(tree, 3, "print_stmt");
1697 res = (validate_ntype(CHILD(tree, i), RIGHTSHIFT)
1698 && validate_test(CHILD(tree, i+1)));
1706 res = (validate_comma(CHILD(tree, i))
1707 && validate_test(CHILD(tree, i+1)));
1712 res = validate_numnodes(tree, i, "print_stmt");
1714 res = validate_comma(CHILD(tree, i));
1722 validate_del_stmt(node *tree)
1724 return (validate_numnodes(tree, 2, "del_stmt")
1725 && validate_name(CHILD(tree, 0), "del")
1726 && validate_exprlist(CHILD(tree, 1)));
1731 validate_return_stmt(node *tree)
1733 int nch = NCH(tree);
1734 int res = (validate_ntype(tree, return_stmt)
1736 && validate_name(CHILD(tree, 0), "return"));
1739 res = validate_testlist(CHILD(tree, 1));
1746 validate_raise_stmt(node *tree)
1748 int nch = NCH(tree);
1749 int res = (validate_ntype(tree, raise_stmt)
1753 res = validate_name(CHILD(tree, 0), "raise");
1755 res = validate_test(CHILD(tree, 1));
1757 res = (validate_comma(CHILD(tree, 2))
1758 && validate_test(CHILD(tree, 3)));
1760 res = (validate_comma(CHILD(tree, 4))
1761 && validate_test(CHILD(tree, 5)));
1765 (void) validate_numnodes(tree, 2, "raise");
1767 res = (validate_comma(CHILD(tree, 2))
1768 && validate_test(CHILD(tree, 3)));
1777 validate_yield_expr(node *tree)
1779 int nch = NCH(tree);
1780 int res = (validate_ntype(tree, yield_expr)
1782 && validate_name(CHILD(tree, 0), "yield"));
1785 res = validate_testlist(CHILD(tree, 1));
1794 validate_yield_stmt(node *tree)
1796 return (validate_ntype(tree, yield_stmt)
1797 && validate_numnodes(tree, 1, "yield_stmt")
1798 && validate_yield_expr(CHILD(tree, 0)));
1803 validate_import_as_name(node *tree)
1805 int nch = NCH(tree);
1806 int ok = validate_ntype(tree, import_as_name);
1810 ok = validate_name(CHILD(tree, 0), NULL);
1812 ok = (validate_name(CHILD(tree, 0), NULL)
1813 && validate_name(CHILD(tree, 1), "as")
1814 && validate_name(CHILD(tree, 2), NULL));
1816 ok = validate_numnodes(tree, 3, "import_as_name");
1825 validate_dotted_name(node *tree)
1827 int nch = NCH(tree);
1828 int res = (validate_ntype(tree, dotted_name)
1830 && validate_name(CHILD(tree, 0), NULL));
1834 res = (validate_dot(CHILD(tree, i))
1835 && validate_name(CHILD(tree, i+1), NULL));
1844 validate_dotted_as_name(node *tree)
1846 int nch = NCH(tree);
1847 int res = validate_ntype(tree, dotted_as_name);
1851 res = validate_dotted_name(CHILD(tree, 0));
1853 res = (validate_dotted_name(CHILD(tree, 0))
1854 && validate_name(CHILD(tree, 1), "as")
1855 && validate_name(CHILD(tree, 2), NULL));
1867 validate_dotted_as_names(node *tree)
1869 int nch = NCH(tree);
1870 int res = is_odd(nch) && validate_dotted_as_name(CHILD(tree, 0));
1874 res = (validate_comma(CHILD(tree, i))
1875 && validate_dotted_as_name(CHILD(tree, i + 1)));
1882 validate_import_as_names(node *tree)
1884 int nch = NCH(tree);
1885 int res = validate_import_as_name(CHILD(tree, 0));
1889 res = (validate_comma(CHILD(tree, i))
1890 && validate_import_as_name(CHILD(tree, i + 1)));
1897 validate_import_name(node *tree)
1899 return (validate_ntype(tree, import_name)
1900 && validate_numnodes(tree, 2, "import_name")
1901 && validate_name(CHILD(tree, 0), "import")
1902 && validate_dotted_as_names(CHILD(tree, 1)));
1909 count_from_dots(node *tree)
1912 for (i = 1; i < NCH(tree); i++)
1913 if (TYPE(CHILD(tree, i)) != DOT)
1922 validate_import_from(node *tree)
1924 int nch = NCH(tree);
1925 int ndots = count_from_dots(tree);
1926 int havename = (TYPE(CHILD(tree, ndots + 1)) == dotted_name);
1928 int res = validate_ntype(tree, import_from)
1931 && validate_name(CHILD(tree, 0), "from")
1932 && (!havename || validate_dotted_name(CHILD(tree, ndots + 1)))
1933 && validate_name(CHILD(tree, offset + 1), "import");
1935 if (res && TYPE(CHILD(tree, offset + 2)) == LPAR)
1937 && validate_lparen(CHILD(tree, offset + 2))
1938 && validate_import_as_names(CHILD(tree, offset + 3))
1939 && validate_rparen(CHILD(tree, offset + 4)));
1940 else if (res && TYPE(CHILD(tree, offset + 2)) != STAR)
1941 res = validate_import_as_names(CHILD(tree, offset + 2));
1948 validate_import_stmt(node *tree)
1950 int nch = NCH(tree);
1951 int res = validate_numnodes(tree, 1, "import_stmt");
1954 int ntype = TYPE(CHILD(tree, 0));
1957 res = validate_node(CHILD(tree, 0));
1967 TYPE(CHILD(tree, 0)));
1976 validate_global_stmt(node *tree)
1979 int nch = NCH(tree);
1980 int res = (validate_ntype(tree, global_stmt)
1987 res = (validate_name(CHILD(tree, 0), "global")
1988 && validate_ntype(CHILD(tree, 1), NAME));
1990 res = (validate_comma(CHILD(tree, j))
1991 && validate_ntype(CHILD(tree, j + 1), NAME));
2002 validate_exec_stmt(node *tree)
2004 int nch = NCH(tree);
2005 int res = (validate_ntype(tree, exec_stmt)
2007 && validate_name(CHILD(tree, 0), "exec")
2008 && validate_expr(CHILD(tree, 1)));
2013 res = (validate_name(CHILD(tree, 2), "in")
2014 && validate_test(CHILD(tree, 3)));
2016 res = (validate_comma(CHILD(tree, 4))
2017 && validate_test(CHILD(tree, 5)));
2028 validate_assert_stmt(node *tree)
2030 int nch = NCH(tree);
2031 int res = (validate_ntype(tree, assert_stmt)
2033 && (validate_name(CHILD(tree, 0), "assert"))
2034 && validate_test(CHILD(tree, 1)));
2039 res = (validate_comma(CHILD(tree, 2))
2040 && validate_test(CHILD(tree, 3)));
2047 validate_while(node *tree)
2049 int nch = NCH(tree);
2050 int res = (validate_ntype(tree, while_stmt)
2052 && validate_name(CHILD(tree, 0), "while")
2053 && validate_test(CHILD(tree, 1))
2054 && validate_colon(CHILD(tree, 2))
2055 && validate_suite(CHILD(tree, 3)));
2058 res = (validate_name(CHILD(tree, 4), "else")
2059 && validate_colon(CHILD(tree, 5))
2060 && validate_suite(CHILD(tree, 6)));
2067 validate_for(node *tree)
2069 int nch = NCH(tree);
2070 int res = (validate_ntype(tree, for_stmt)
2072 && validate_name(CHILD(tree, 0), "for")
2073 && validate_exprlist(CHILD(tree, 1))
2074 && validate_name(CHILD(tree, 2), "in")
2075 && validate_testlist(CHILD(tree, 3))
2076 && validate_colon(CHILD(tree, 4))
2077 && validate_suite(CHILD(tree, 5)));
2080 res = (validate_name(CHILD(tree, 6), "else")
2081 && validate_colon(CHILD(tree, 7))
2082 && validate_suite(CHILD(tree, 8)));
2095 tree)
2097 int nch = NCH(tree);
2099 int res = (validate_ntype(tree, try_stmt)
2103 res = (validate_name(CHILD(tree, 0), "try")
2104 && validate_colon(CHILD(tree, 1))
2105 && validate_suite(CHILD(tree, 2))
2106 && validate_colon(CHILD(tree, nch - 2))
2107 && validate_suite(CHILD(tree, nch - 1)));
2110 if (TYPE(CHILD(tree, nch - 3)) != except_clause)
2111 name = STR(CHILD(tree, nch - 3));
2117 if (res && (TYPE(CHILD(tree, pos)) == NAME) &&
2118 (strcmp(STR(CHILD(tree, pos)), "finally") == 0)) {
2119 res = (validate_numnodes(tree, 6, "try/finally")
2120 && validate_colon(CHILD(tree, 4))
2121 && validate_suite(CHILD(tree, 5)));
2125 while (res && pos < nch && (TYPE(CHILD(tree, pos)) == except_clause)) {
2126 res = (validate_except_clause(CHILD(tree, pos))
2127 && validate_colon(CHILD(tree, pos + 1))
2128 && validate_suite(CHILD(tree, pos + 2)));
2132 if (res && pos < nch && (TYPE(CHILD(tree, pos)) == NAME) &&
2133 (strcmp(STR(CHILD(tree, pos)), "else") == 0)) {
2134 res = (validate_colon(CHILD(tree, pos + 1))
2135 && validate_suite(CHILD(tree, pos + 2)));
2140 res = (validate_name(CHILD(tree, pos), "finally")
2141 && validate_numnodes(tree, pos + 3, "try/except/finally")
2142 && validate_colon(CHILD(tree, pos + 1))
2143 && validate_suite(CHILD(tree, pos + 2)));
2150 validate_except_clause(node *tree)
2152 int nch = NCH(tree);
2153 int res = (validate_ntype(tree, except_clause)
2155 && validate_name(CHILD(tree, 0), "except"));
2158 res = validate_test(CHILD(tree, 1));
2160 if (TYPE(CHILD(tree, 2)) == NAME)
2161 res = validate_name(CHILD(tree, 2), "as");
2163 res = validate_comma(CHILD(tree, 2));
2164 res = res && validate_test(CHILD(tree, 3));
2171 validate_test(node *tree)
2173 int nch = NCH(tree);
2174 int res = validate_ntype(tree, test) && is_odd(nch);
2176 if (res && (TYPE(CHILD(tree, 0)) == lambdef))
2178 && validate_lambdef(CHILD(tree, 0)));
2180 res = validate_or_test(CHILD(tree, 0));
2182 validate_name(CHILD(tree, 1), "if") &&
2183 validate_or_test(CHILD(tree, 2)) &&
2184 validate_name(CHILD(tree, 3), "else") &&
2185 validate_test(CHILD(tree, 4)))));
2191 validate_old_test(node *tree)
2193 int nch = NCH(tree);
2194 int res = validate_ntype(tree, old_test) && (nch == 1);
2196 if (res && (TYPE(CHILD(tree, 0)) == old_lambdef))
2197 res = (validate_old_lambdef(CHILD(tree, 0)));
2199 res = (validate_or_test(CHILD(tree, 0)));
2205 validate_or_test(node *tree)
2207 int nch = NCH(tree);
2208 int res = validate_ntype(tree, or_test) && is_odd(nch);
2212 res = validate_and_test(CHILD(tree, 0));
2214 res = (validate_name(CHILD(tree, pos), "or")
2215 && validate_and_test(CHILD(tree, pos + 1)));
2222 validate_and_test(node *tree)
2225 int nch = NCH(tree);
2226 int res = (validate_ntype(tree, and_test)
2228 && validate_not_test(CHILD(tree, 0)));
2231 res = (validate_name(CHILD(tree, pos), "and")
2232 && validate_not_test(CHILD(tree, 0)));
2239 validate_not_test(node *tree)
2241 int nch = NCH(tree);
2242 int res = validate_ntype(tree, not_test) && ((nch == 1) || (nch == 2));
2246 res = (validate_name(CHILD(tree, 0), "not")
2247 && validate_not_test(CHILD(tree, 1)));
2249 res = validate_comparison(CHILD(tree, 0));
2256 validate_comparison(node *tree)
2259 int nch = NCH(tree);
2260 int res = (validate_ntype(tree, comparison)
2262 && validate_expr(CHILD(tree, 0)));
2265 res = (validate_comp_op(CHILD(tree, pos))
2266 && validate_expr(CHILD(tree, pos + 1)));
2273 validate_comp_op(node *tree)
2276 int nch = NCH(tree);
2278 if (!validate_ntype(tree, comp_op))
2285 tree = CHILD(tree, 0);
2286 switch (TYPE(tree)) {
2297 res = ((strcmp(STR(tree), "in") == 0)
2298 || (strcmp(STR(tree), "is") == 0));
2301 "illegal operator '%s'", STR(tree));
2309 else if ((res = validate_numnodes(tree, 2, "comp_op")) != 0) {
2310 res = (validate_ntype(CHILD(tree, 0), NAME)
2311 && validate_ntype(CHILD(tree, 1), NAME)
2312 && (((strcmp(STR(CHILD(tree, 0)), "is") == 0)
2313 && (strcmp(STR(CHILD(tree, 1)), "not") == 0))
2314 || ((strcmp(STR(CHILD(tree, 0)), "not") == 0)
2315 && (strcmp(STR(CHILD(tree, 1)), "in") == 0))));
2324 validate_expr(node *tree)
2327 int nch = NCH(tree);
2328 int res = (validate_ntype(tree, expr)
2330 && validate_xor_expr(CHILD(tree, 0)));
2333 res = (validate_xor_expr(CHILD(tree, j))
2334 && validate_vbar(CHILD(tree, j - 1)));
2341 validate_xor_expr(node *tree)
2344 int nch = NCH(tree);
2345 int res = (validate_ntype(tree, xor_expr)
2347 && validate_and_expr(CHILD(tree, 0)));
2350 res = (validate_circumflex(CHILD(tree, j - 1))
2351 && validate_and_expr(CHILD(tree, j)));
2358 validate_and_expr(node *tree)
2361 int nch = NCH(tree);
2362 int res = (validate_ntype(tree, and_expr)
2364 && validate_shift_expr(CHILD(tree, 0)));
2367 res = (validate_ampersand(CHILD(tree, pos))
2368 && validate_shift_expr(CHILD(tree, pos + 1)));
2375 validate_chain_two_ops(node *tree, int (*termvalid)(node *), int op1, int op2)
2378 int nch = NCH(tree);
2380 && (*termvalid)(CHILD(tree, 0)));
2383 if (TYPE(CHILD(tree, pos)) != op1)
2384 res = validate_ntype(CHILD(tree, pos), op2);
2386 res = (*termvalid)(CHILD(tree, pos + 1));
2393 validate_shift_expr(node *tree)
2395 return (validate_ntype(tree, shift_expr)
2396 && validate_chain_two_ops(tree, validate_arith_expr,
2402 validate_arith_expr(node *tree)
2404 return (validate_ntype(tree, arith_expr)
2405 && validate_chain_two_ops(tree, validate_term, PLUS, MINUS));
2410 validate_term(node *tree)
2413 int nch = NCH(tree);
2414 int res = (validate_ntype(tree, term)
2416 && validate_factor(CHILD(tree, 0)));
2419 res = (((TYPE(CHILD(tree, pos)) == STAR)
2420 || (TYPE(CHILD(tree, pos)) == SLASH)
2421 || (TYPE(CHILD(tree, pos)) == DOUBLESLASH)
2422 || (TYPE(CHILD(tree, pos)) == PERCENT))
2423 && validate_factor(CHILD(tree, pos + 1)));
2434 validate_factor(node *tree)
2436 int nch = NCH(tree);
2437 int res = (validate_ntype(tree, factor)
2439 && ((TYPE(CHILD(tree, 0)) == PLUS)
2440 || (TYPE(CHILD(tree, 0)) == MINUS)
2441 || (TYPE(CHILD(tree, 0)) == TILDE))
2442 && validate_factor(CHILD(tree, 1)))
2444 && validate_power(CHILD(tree, 0)))));
2454 validate_power(node *tree)
2457 int nch = NCH(tree);
2458 int res = (validate_ntype(tree, power) && (nch >= 1)
2459 && validate_atom(CHILD(tree, 0)));
2461 while (res && (pos < nch) && (TYPE(CHILD(tree, pos)) == trailer))
2462 res = validate_trailer(CHILD(tree, pos++));
2469 res = (validate_doublestar(CHILD(tree, pos))
2470 && validate_factor(CHILD(tree, pos + 1)));
2477 validate_atom(node *tree)
2480 int nch = NCH(tree);
2481 int res = validate_ntype(tree, atom);
2484 res = validate_numnodes(tree, nch+1, "atom");
2486 switch (TYPE(CHILD(tree, 0))) {
2489 && (validate_rparen(CHILD(tree, nch - 1))));
2492 if (TYPE(CHILD(tree, 1))==yield_expr)
2493 res = validate_yield_expr(CHILD(tree, 1));
2495 res = validate_testlist_comp(CHILD(tree, 1));
2500 res = validate_ntype(CHILD(tree, 1), RSQB);
2502 res = (validate_listmaker(CHILD(tree, 1))
2503 && validate_ntype(CHILD(tree, 2), RSQB));
2511 && validate_ntype(CHILD(tree, nch - 1), RBRACE));
2514 res = validate_dictorsetmaker(CHILD(tree, 1));
2518 && validate_testlist1(CHILD(tree, 1))
2519 && validate_ntype(CHILD(tree, 2), BACKQUOTE));
2527 res = validate_ntype(CHILD(tree, pos), STRING);
2542 validate_listmaker(node *tree)
2544 int nch = NCH(tree);
2550 ok = validate_test(CHILD(tree, 0));
2555 if (nch == 2 && TYPE(CHILD(tree, 1)) == list_for)
2556 ok = validate_list_for(CHILD(tree, 1));
2561 ok = (validate_comma(CHILD(tree, i))
2562 && validate_test(CHILD(tree, i+1)));
2566 ok = validate_comma(CHILD(tree, i));
2579 validate_testlist_comp(node *tree)
2581 int nch = NCH(tree);
2587 ok = validate_test(CHILD(tree, 0));
2593 if (nch == 2 && TYPE(CHILD(tree, 1)) == comp_for)
2594 ok = validate_comp_for(CHILD(tree, 1));
2599 ok = (validate_comma(CHILD(tree, i))
2600 && validate_test(CHILD(tree, i+1)));
2604 ok = validate_comma(CHILD(tree, i));
2617 validate_decorator(node *tree)
2620 int nch = NCH(tree);
2621 ok = (validate_ntype(tree, decorator) &&
2623 validate_at(CHILD(tree, 0)) &&
2624 validate_dotted_name(CHILD(tree, 1)) &&
2625 validate_newline(RCHILD(tree, -1)));
2628 ok = (validate_lparen(CHILD(tree, 2)) &&
2629 validate_rparen(RCHILD(tree, -2)));
2632 ok = validate_arglist(CHILD(tree, 3));
2642 validate_decorators(node *tree)
2645 nch = NCH(tree);
2646 ok = validate_ntype(tree, decorators) && nch >= 1;
2649 ok = validate_decorator(CHILD(tree, i));
2658 validate_with_item(node *tree)
2660 int nch = NCH(tree);
2661 int ok = (validate_ntype(tree, with_item)
2663 && validate_test(CHILD(tree, 0)));
2665 ok = (validate_name(CHILD(tree, 1), "as")
2666 && validate_expr(CHILD(tree, 2)));
2675 validate_with_stmt(node *tree)
2678 int nch = NCH(tree);
2679 int ok = (validate_ntype(tree, with_stmt)
2681 && validate_name(CHILD(tree, 0), "with")
2682 tree, -2))
2683 && validate_suite(RCHILD(tree, -1)));
2685 ok = validate_with_item(CHILD(tree, i));
2695 validate_funcdef(node *tree)
2697 int nch = NCH(tree);
2698 int ok = (validate_ntype(tree, funcdef)
2700 && validate_name(RCHILD(tree, -5), "def")
2701 && validate_ntype(RCHILD(tree, -4), NAME)
2702 && validate_colon(RCHILD(tree, -2))
2703 && validate_parameters(RCHILD(tree, -3))
2704 && validate_suite(RCHILD(tree, -1)));
2713 validate_decorated(node *tree)
2715 int nch = NCH(tree);
2716 int ok = (validate_ntype(tree, decorated)
2718 && validate_decorators(RCHILD(tree, -2)));
2719 if (TYPE(RCHILD(tree, -1)) == funcdef)
2720 ok = ok && validate_funcdef(RCHILD(tree, -1));
2722 ok = ok && validate_class(RCHILD(tree, -1));
2727 validate_lambdef(node *tree)
2729 int nch = NCH(tree);
2730 int res = (validate_ntype(tree, lambdef)
2732 && validate_name(CHILD(tree, 0), "lambda")
2733 && validate_colon(CHILD(tree, nch - 2))
2734 && validate_test(CHILD(tree, nch - 1)));
2737 res = validate_varargslist(CHILD(tree, 1));
2739 (void) validate_numnodes(tree, 3, "lambdef");
2746 validate_old_lambdef(node *tree)
2748 int nch = NCH(tree);
2749 int res = (validate_ntype(tree, old_lambdef)
2751 && validate_name(CHILD(tree, 0), "lambda")
2752 && validate_colon(CHILD(tree, nch - 2))
2753 && validate_test(CHILD(tree, nch - 1)));
2756 res = validate_varargslist(CHILD(tree, 1));
2758 (void) validate_numnodes(tree, 3, "old_lambdef");
2769 validate_arglist(node *tree)
2771 int nch = NCH(tree);
2777 return validate_numnodes(tree, nch + 1, "arglist");
2781 if (TYPE(CHILD(tree, i)) == argument) {
2782 node *ch = CHILD(tree, i);
2793 ok = (validate_argument(CHILD(tree, i))
2794 && validate_comma(CHILD(tree, i+1)));
2805 int sym = TYPE(CHILD(tree, i));
2808 ok = validate_argument(CHILD(tree, i));
2816 ok = validate_star(CHILD(tree, i));
2818 ok = validate_test(CHILD(tree, i+1));
2820 ok = (validate_test(CHILD(tree, i+1))
2821 && validate_comma(CHILD(tree, i+2))
2822 && validate_doublestar(CHILD(tree, i+3))
2823 && validate_test(CHILD(tree, i+4)));
2831 ok = (validate_doublestar(CHILD(tree, i))
2832 && validate_test(CHILD(tree, i+1)));
2853 validate_argument(node *tree)
2855 int nch = NCH(tree);
2856 int res = (validate_ntype(tree, argument)
2858 && validate_test(CHILD(tree, 0)));
2861 res = validate_comp_for(CHILD(tree, 1));
2863 res = (validate_equal(CHILD(tree, 1))
2864 && validate_test(CHILD(tree, 2)));
2876 validate_trailer(node *tree)
2878 int nch = NCH(tree);
2879 int res = validate_ntype(tree, trailer) && ((nch == 2) || (nch == 3));
2882 switch (TYPE(CHILD(tree, 0))) {
2884 res = validate_rparen(CHILD(tree, nch - 1));
2886 res = validate_arglist(CHILD(tree, 1));
2889 res = (validate_numnodes(tree, 3, "trailer")
2890 && validate_subscriptlist(CHILD(tree, 1))
2891 && validate_ntype(CHILD(tree, 2), RSQB));
2894 res = (validate_numnodes(tree, 2, "trailer")
2895 && validate_ntype(CHILD(tree, 1), NAME));
2903 (void) validate_numnodes(tree, 2, "trailer");
2914 validate_subscriptlist(node *tree)
2916 return (validate_repeating_list(tree, subscriptlist,
2926 validate_subscript(node *tree)
2929 int nch = NCH(tree);
2930 int res = validate_ntype(tree, subscript) && (nch >= 1) && (nch <= 4);
2937 if (TYPE(CHILD(tree, 0)) == DOT)
2939 return (validate_numnodes(tree, 3, "subscript")
2940 && validate_dot(CHILD(tree, 0))
2941 && validate_dot(CHILD(tree, 1))
2942 && validate_dot(CHILD(tree, 2)));
2944 if (TYPE(CHILD(tree, 0)) == test)
2945 res = validate_test(CHILD(tree, 0));
2947 res = validate_colon(CHILD(tree, 0));
2954 if ((TYPE(CHILD(tree, 0)) != COLON) || (nch == 4)) {
2955 res = validate_test(CHILD(tree, 0));
2959 res = validate_colon(CHILD(tree, offset));
2963 if (TYPE(CHILD(tree, offset)) == test) {
2964 res = validate_test(CHILD(tree, offset));
2969 res = validate_sliceop(CHILD(tree, offset));
2977 validate_sliceop(node *tree)
2979 int nch = NCH(tree);
2980 int res = ((nch == 1) || validate_numnodes(tree, 2, "sliceop"))
2981 && validate_ntype(tree, sliceop);
2983 res = validate_numnodes(tree, 1, "sliceop");
2986 res = validate_colon(CHILD(tree, 0));
2988 res = validate_test(CHILD(tree, 1));
2995 validate_exprlist(node *tree)
2997 return (validate_repeating_list(tree, exprlist,
3009 validate_dictorsetmaker(node *tree)
3011 int nch = NCH(tree);
3012 int ok = validate_ntype(tree, dictorsetmaker);
3018 if (ok && (nch == 1 || TYPE(CHILD(tree, 1)) == COMMA)) {
3022 ok = validate_test(CHILD(tree, i++));
3024 ok = (validate_comma(CHILD(tree, i))
3025 && validate_test(CHILD(tree, i+1)));
3030 else if (ok && TYPE(CHILD(tree, 1)) == comp_for) {
3034 ok = (validate_test(CHILD(tree, 0))
3035 && validate_comp_for(CHILD(tree, 1)));
3037 else if (ok && NCH(tree) > 3 && TYPE(CHILD(tree, 3)) == comp_for) {
3041 ok = (validate_test(CHILD(tree, 0))
3042 && validate_colon(CHILD(tree, 1))
3043 && validate_test(CHILD(tree, 2))
3044 && validate_comp_for(CHILD(tree, 3)));
3051 ok = (validate_test(CHILD(tree, i))
3052 && validate_colon(CHILD(tree, i+1))
3053 && validate_test(CHILD(tree, i+2)));
3062 ok = (validate_comma(CHILD(tree, i))
3063 && validate_test(CHILD(tree, i+1))
3064 && validate_colon(CHILD(tree, i+2))
3065 && validate_test(CHILD(tree, i+3)));
3072 ok = validate_comma(CHILD(tree, i));
3084 validate_eval_input(node *tree)
3087 int nch = NCH(tree);
3088 int res = (validate_ntype(tree, eval_input)
3090 && validate_testlist(CHILD(tree, 0))
3091 && validate_ntype(CHILD(tree, nch - 1), ENDMARKER));
3094 res = validate_ntype(CHILD(tree, pos), NEWLINE);
3101 validate_node(node *tree)
3107 while (res && (tree != 0)) {
3108 nch = NCH(tree);
3110 switch (TYPE(tree)) {
3115 res = validate_funcdef(tree);
3118 res = validate_with_stmt(tree);
3121 res = validate_class(tree);
3124 res = validate_decorated(tree);
3127 * "Trivial" parse tree nodes.
3131 res = validate_stmt(tree);
3138 res = validate_small_stmt(tree);
3141 res = (validate_numnodes(tree, 1, "flow_stmt")
3142 && ((TYPE(CHILD(tree, 0)) == break_stmt)
3143 || (TYPE(CHILD(tree, 0)) == continue_stmt)
3144 || (TYPE(CHILD(tree, 0)) == yield_stmt)
3145 || (TYPE(CHILD(tree, 0)) == return_stmt)
3146 || (TYPE(CHILD(tree, 0)) == raise_stmt)));
3148 next = CHILD(tree, 0);
3153 res = validate_yield_stmt(tree);
3159 res = validate_simple_stmt(tree);
3162 res = validate_compound_stmt(tree);
3168 res = validate_expr_stmt(tree);
3171 res = validate_print_stmt(tree);
3174 res = validate_del_stmt(tree);
3177 res = (validate_numnodes(tree, 1, "pass")
3178 && validate_name(CHILD(tree, 0), "pass"));
3181 res = (validate_numnodes(tree, 1, "break")
3182 && validate_name(CHILD(tree, 0), "break"));
3185 res = (validate_numnodes(tree, 1, "continue")
3186 && validate_name(CHILD(tree, 0), "continue"));
3189 res = validate_return_stmt(tree);
3192 res = validate_raise_stmt(tree);
3195 res = validate_import_stmt(tree);
3198 res = validate_import_name(tree);
3201 res = validate_import_from(tree);
3204 res = validate_global_stmt(tree);
3207 res = validate_exec_stmt(tree);
3210 res = validate_assert_stmt(tree);
3213 res = validate_if(tree);
3216 res = validate_while(tree);
3219 res = validate_for(tree);
3222 res = validate_try(tree);
3225 res = validate_suite(tree);
3231 res = validate_testlist(tree);
3234 res = validate_yield_expr(tree);
3237 res = validate_testlist1(tree);
3240 res = validate_test(tree);
3243 res = validate_and_test(tree);
3246 res = validate_not_test(tree);
3249 res = validate_comparison(tree);
3252 res = validate_exprlist(tree);
3255 res = validate_comp_op(tree);
3258 res = validate_expr(tree);
3261 res = validate_xor_expr(tree);
3264 res = validate_and_expr(tree);
3267 res = validate_shift_expr(tree);
3270 res = validate_arith_expr(tree);
3273 res = validate_term(tree);
3276 res = validate_factor(tree);
3279 res = validate_power(tree);
3282 res = validate_atom(tree);
3291 tree = next;
3298 validate_expr_tree(node *tree)
3300 int res = validate_eval_input(tree);
3313 validate_file_input(node *tree)
3316 int nch = NCH(tree) - 1;
3318 && validate_ntype(CHILD(tree, nch), ENDMARKER));
3321 if (TYPE(CHILD(tree, j)) == stmt)
3322 res = validate_stmt(CHILD(tree, j));
3324 res = validate_newline(CHILD(tree, j));
3337 validate_encoding_decl(node *tree)
3339 int nch = NCH(tree);
3341 && validate_file_input(CHILD(tree, 0)));
3392 PyDoc_STR("Creates a tuple-tree representation of an ST.")},
3394 PyDoc_STR("Creates a list-tree representation of an ST.")},
3408 PyDoc_STR("Creates an ST object from a tree representation.")},
3410 PyDoc_STR("Creates an ST object from a tree representation.")},
3412 PyDoc_STR("Creates a tuple-tree representation of an ST.")},
3414 PyDoc_STR("Creates a list-tree representation of an ST.")},
3416 PyDoc_STR("Creates an ST object from a tree representation.")},
3418 PyDoc_STR("Creates an ST object from a tree representation.")},
