parsermodule.c revision 4469d0ca565d82af241926b5bde67b48fb4b844f
1/* parsermodule.c 2 * 3 * Copyright 1995-1996 by Fred L. Drake, Jr. and Virginia Polytechnic 4 * Institute and State University, Blacksburg, Virginia, USA. 5 * Portions copyright 1991-1995 by Stichting Mathematisch Centrum, 6 * Amsterdam, The Netherlands. Copying is permitted under the terms 7 * associated with the main Python distribution, with the additional 8 * restriction that this additional notice be included and maintained 9 * on all distributed copies. 10 * 11 * This module serves to replace the original parser module written 12 * by Guido. The functionality is not matched precisely, but the 13 * original may be implemented on top of this. This is desirable 14 * since the source of the text to be parsed is now divorced from 15 * this interface. 16 * 17 * Unlike the prior interface, the ability to give a parse tree 18 * produced by Python code as a tuple to the compiler is enabled by 19 * this module. See the documentation for more details. 20 * 21 * I've added some annotations that help with the lint code-checking 22 * program, but they're not complete by a long shot. The real errors 23 * that lint detects are gone, but there are still warnings with 24 * Py_[X]DECREF() and Py_[X]INCREF() macros. The lint annotations 25 * look like "NOTE(...)". 26 */ 27 28#include "Python.h" /* general Python API */ 29#include "Python-ast.h" /* mod_ty */ 30#include "graminit.h" /* symbols defined in the grammar */ 31#include "node.h" /* internal parser structure */ 32#include "errcode.h" /* error codes for PyNode_*() */ 33#include "token.h" /* token definitions */ 34#include "grammar.h" 35#include "parsetok.h" 36 /* ISTERMINAL() / ISNONTERMINAL() */ 37#include "compile.h" 38#undef Yield 39#include "ast.h" 40#include "pyarena.h" 41 42extern grammar _PyParser_Grammar; /* From graminit.c */ 43 44#ifdef lint 45#include <note.h> 46#else 47#define NOTE(x) 48#endif 49 50/* String constants used to initialize module attributes. 51 * 52 */ 53static char parser_copyright_string[] = 54"Copyright 1995-1996 by Virginia Polytechnic Institute & State\n\ 55University, Blacksburg, Virginia, USA, and Fred L. Drake, Jr., Reston,\n\ 56Virginia, USA. Portions copyright 1991-1995 by Stichting Mathematisch\n\ 57Centrum, Amsterdam, The Netherlands."; 58 59 60PyDoc_STRVAR(parser_doc_string, 61"This is an interface to Python's internal parser."); 62 63static char parser_version_string[] = "0.5"; 64 65 66typedef PyObject* (*SeqMaker) (Py_ssize_t length); 67typedef int (*SeqInserter) (PyObject* sequence, 68 Py_ssize_t index, 69 PyObject* element); 70 71/* The function below is copyrighted by Stichting Mathematisch Centrum. The 72 * original copyright statement is included below, and continues to apply 73 * in full to the function immediately following. All other material is 74 * original, copyrighted by Fred L. Drake, Jr. and Virginia Polytechnic 75 * Institute and State University. Changes were made to comply with the 76 * new naming conventions. Added arguments to provide support for creating 77 * lists as well as tuples, and optionally including the line numbers. 78 */ 79 80 81static PyObject* 82node2tuple(node *n, /* node to convert */ 83 SeqMaker mkseq, /* create sequence */ 84 SeqInserter addelem, /* func. to add elem. in seq. */ 85 int lineno, /* include line numbers? */ 86 int col_offset) /* include column offsets? */ 87{ 88 if (n == NULL) { 89 Py_INCREF(Py_None); 90 return (Py_None); 91 } 92 if (ISNONTERMINAL(TYPE(n))) { 93 int i; 94 PyObject *v; 95 PyObject *w; 96 97 v = mkseq(1 + NCH(n) + (TYPE(n) == encoding_decl)); 98 if (v == NULL) 99 return (v); 100 w = PyLong_FromLong(TYPE(n)); 101 if (w == NULL) { 102 Py_DECREF(v); 103 return ((PyObject*) NULL); 104 } 105 (void) addelem(v, 0, w); 106 for (i = 0; i < NCH(n); i++) { 107 w = node2tuple(CHILD(n, i), mkseq, addelem, lineno, col_offset); 108 if (w == NULL) { 109 Py_DECREF(v); 110 return ((PyObject*) NULL); 111 } 112 (void) addelem(v, i+1, w); 113 } 114 115 if (TYPE(n) == encoding_decl) 116 (void) addelem(v, i+1, PyUnicode_FromString(STR(n))); 117 return (v); 118 } 119 else if (ISTERMINAL(TYPE(n))) { 120 PyObject *result = mkseq(2 + lineno + col_offset); 121 if (result != NULL) { 122 (void) addelem(result, 0, PyLong_FromLong(TYPE(n))); 123 (void) addelem(result, 1, PyUnicode_FromString(STR(n))); 124 if (lineno == 1) 125 (void) addelem(result, 2, PyLong_FromLong(n->n_lineno)); 126 if (col_offset == 1) 127 (void) addelem(result, 3, PyLong_FromLong(n->n_col_offset)); 128 } 129 return (result); 130 } 131 else { 132 PyErr_SetString(PyExc_SystemError, 133 "unrecognized parse tree node type"); 134 return ((PyObject*) NULL); 135 } 136} 137/* 138 * End of material copyrighted by Stichting Mathematisch Centrum. 139 */ 140 141 142 143/* There are two types of intermediate objects we're interested in: 144 * 'eval' and 'exec' types. These constants can be used in the st_type 145 * field of the object type to identify which any given object represents. 146 * These should probably go in an external header to allow other extensions 147 * to use them, but then, we really should be using C++ too. ;-) 148 */ 149 150#define PyST_EXPR 1 151#define PyST_SUITE 2 152 153 154/* These are the internal objects and definitions required to implement the 155 * ST type. Most of the internal names are more reminiscent of the 'old' 156 * naming style, but the code uses the new naming convention. 157 */ 158 159static PyObject* 160parser_error = 0; 161 162 163typedef struct { 164 PyObject_HEAD /* standard object header */ 165 node* st_node; /* the node* returned by the parser */ 166 int st_type; /* EXPR or SUITE ? */ 167 PyCompilerFlags st_flags; /* Parser and compiler flags */ 168} PyST_Object; 169 170 171static void parser_free(PyST_Object *st); 172static int parser_compare(PyST_Object *left, PyST_Object *right); 173static PyObject* parser_compilest(PyST_Object *, PyObject *, PyObject *); 174static PyObject* parser_isexpr(PyST_Object *, PyObject *, PyObject *); 175static PyObject* parser_issuite(PyST_Object *, PyObject *, PyObject *); 176static PyObject* parser_st2list(PyST_Object *, PyObject *, PyObject *); 177static PyObject* parser_st2tuple(PyST_Object *, PyObject *, PyObject *); 178 179#define PUBLIC_METHOD_TYPE (METH_VARARGS|METH_KEYWORDS) 180 181static PyMethodDef parser_methods[] = { 182 {"compile", (PyCFunction)parser_compilest, PUBLIC_METHOD_TYPE, 183 PyDoc_STR("Compile this ST object into a code object.")}, 184 {"isexpr", (PyCFunction)parser_isexpr, PUBLIC_METHOD_TYPE, 185 PyDoc_STR("Determines if this ST object was created from an expression.")}, 186 {"issuite", (PyCFunction)parser_issuite, PUBLIC_METHOD_TYPE, 187 PyDoc_STR("Determines if this ST object was created from a suite.")}, 188 {"tolist", (PyCFunction)parser_st2list, PUBLIC_METHOD_TYPE, 189 PyDoc_STR("Creates a list-tree representation of this ST.")}, 190 {"totuple", (PyCFunction)parser_st2tuple, PUBLIC_METHOD_TYPE, 191 PyDoc_STR("Creates a tuple-tree representation of this ST.")}, 192 193 {NULL, NULL, 0, NULL} 194}; 195 196static 197PyTypeObject PyST_Type = { 198 PyVarObject_HEAD_INIT(NULL, 0) 199 "parser.st", /* tp_name */ 200 (int) sizeof(PyST_Object), /* tp_basicsize */ 201 0, /* tp_itemsize */ 202 (destructor)parser_free, /* tp_dealloc */ 203 0, /* tp_print */ 204 0, /* tp_getattr */ 205 0, /* tp_setattr */ 206 (cmpfunc)parser_compare, /* tp_compare */ 207 0, /* tp_repr */ 208 0, /* tp_as_number */ 209 0, /* tp_as_sequence */ 210 0, /* tp_as_mapping */ 211 0, /* tp_hash */ 212 0, /* tp_call */ 213 0, /* tp_str */ 214 0, /* tp_getattro */ 215 0, /* tp_setattro */ 216 217 /* Functions to access object as input/output buffer */ 218 0, /* tp_as_buffer */ 219 220 Py_TPFLAGS_DEFAULT, /* tp_flags */ 221 222 /* __doc__ */ 223 "Intermediate representation of a Python parse tree.", 224 0, /* tp_traverse */ 225 0, /* tp_clear */ 226 0, /* tp_richcompare */ 227 0, /* tp_weaklistoffset */ 228 0, /* tp_iter */ 229 0, /* tp_iternext */ 230 parser_methods, /* tp_methods */ 231}; /* PyST_Type */ 232 233 234static int 235parser_compare_nodes(node *left, node *right) 236{ 237 int j; 238 239 if (TYPE(left) < TYPE(right)) 240 return (-1); 241 242 if (TYPE(right) < TYPE(left)) 243 return (1); 244 245 if (ISTERMINAL(TYPE(left))) 246 return (strcmp(STR(left), STR(right))); 247 248 if (NCH(left) < NCH(right)) 249 return (-1); 250 251 if (NCH(right) < NCH(left)) 252 return (1); 253 254 for (j = 0; j < NCH(left); ++j) { 255 int v = parser_compare_nodes(CHILD(left, j), CHILD(right, j)); 256 257 if (v != 0) 258 return (v); 259 } 260 return (0); 261} 262 263 264/* int parser_compare(PyST_Object* left, PyST_Object* right) 265 * 266 * Comparison function used by the Python operators ==, !=, <, >, <=, >= 267 * This really just wraps a call to parser_compare_nodes() with some easy 268 * checks and protection code. 269 * 270 */ 271static int 272parser_compare(PyST_Object *left, PyST_Object *right) 273{ 274 if (left == right) 275 return (0); 276 277 if ((left == 0) || (right == 0)) 278 return (-1); 279 280 return (parser_compare_nodes(left->st_node, right->st_node)); 281} 282 283 284/* parser_newstobject(node* st) 285 * 286 * Allocates a new Python object representing an ST. This is simply the 287 * 'wrapper' object that holds a node* and allows it to be passed around in 288 * Python code. 289 * 290 */ 291static PyObject* 292parser_newstobject(node *st, int type) 293{ 294 PyST_Object* o = PyObject_New(PyST_Object, &PyST_Type); 295 296 if (o != 0) { 297 o->st_node = st; 298 o->st_type = type; 299 o->st_flags.cf_flags = 0; 300 } 301 else { 302 PyNode_Free(st); 303 } 304 return ((PyObject*)o); 305} 306 307 308/* void parser_free(PyST_Object* st) 309 * 310 * This is called by a del statement that reduces the reference count to 0. 311 * 312 */ 313static void 314parser_free(PyST_Object *st) 315{ 316 PyNode_Free(st->st_node); 317 PyObject_Del(st); 318} 319 320 321/* parser_st2tuple(PyObject* self, PyObject* args, PyObject* kw) 322 * 323 * This provides conversion from a node* to a tuple object that can be 324 * returned to the Python-level caller. The ST object is not modified. 325 * 326 */ 327static PyObject* 328parser_st2tuple(PyST_Object *self, PyObject *args, PyObject *kw) 329{ 330 PyObject *line_option = 0; 331 PyObject *col_option = 0; 332 PyObject *res = 0; 333 int ok; 334 335 static char *keywords[] = {"st", "line_info", "col_info", NULL}; 336 337 if (self == NULL || PyModule_Check(self)) { 338 ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|OO:st2tuple", keywords, 339 &PyST_Type, &self, &line_option, 340 &col_option); 341 } 342 else 343 ok = PyArg_ParseTupleAndKeywords(args, kw, "|OO:totuple", &keywords[1], 344 &line_option, &col_option); 345 if (ok != 0) { 346 int lineno = 0; 347 int col_offset = 0; 348 if (line_option != NULL) { 349 lineno = (PyObject_IsTrue(line_option) != 0) ? 1 : 0; 350 } 351 if (col_option != NULL) { 352 col_offset = (PyObject_IsTrue(col_option) != 0) ? 1 : 0; 353 } 354 /* 355 * Convert ST into a tuple representation. Use Guido's function, 356 * since it's known to work already. 357 */ 358 res = node2tuple(((PyST_Object*)self)->st_node, 359 PyTuple_New, PyTuple_SetItem, lineno, col_offset); 360 } 361 return (res); 362} 363 364 365/* parser_st2list(PyObject* self, PyObject* args, PyObject* kw) 366 * 367 * This provides conversion from a node* to a list object that can be 368 * returned to the Python-level caller. The ST object is not modified. 369 * 370 */ 371static PyObject* 372parser_st2list(PyST_Object *self, PyObject *args, PyObject *kw) 373{ 374 PyObject *line_option = 0; 375 PyObject *col_option = 0; 376 PyObject *res = 0; 377 int ok; 378 379 static char *keywords[] = {"st", "line_info", "col_info", NULL}; 380 381 if (self == NULL || PyModule_Check(self)) 382 ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|OO:st2list", keywords, 383 &PyST_Type, &self, &line_option, 384 &col_option); 385 else 386 ok = PyArg_ParseTupleAndKeywords(args, kw, "|OO:tolist", &keywords[1], 387 &line_option, &col_option); 388 if (ok) { 389 int lineno = 0; 390 int col_offset = 0; 391 if (line_option != 0) { 392 lineno = PyObject_IsTrue(line_option) ? 1 : 0; 393 } 394 if (col_option != NULL) { 395 col_offset = (PyObject_IsTrue(col_option) != 0) ? 1 : 0; 396 } 397 /* 398 * Convert ST into a tuple representation. Use Guido's function, 399 * since it's known to work already. 400 */ 401 res = node2tuple(self->st_node, 402 PyList_New, PyList_SetItem, lineno, col_offset); 403 } 404 return (res); 405} 406 407 408/* parser_compilest(PyObject* self, PyObject* args) 409 * 410 * This function creates code objects from the parse tree represented by 411 * the passed-in data object. An optional file name is passed in as well. 412 * 413 */ 414static PyObject* 415parser_compilest(PyST_Object *self, PyObject *args, PyObject *kw) 416{ 417 PyObject* res = 0; 418 PyArena* arena; 419 mod_ty mod; 420 char* str = "<syntax-tree>"; 421 int ok; 422 423 static char *keywords[] = {"st", "filename", NULL}; 424 425 if (self == NULL || PyModule_Check(self)) 426 ok = PyArg_ParseTupleAndKeywords(args, kw, "O!|s:compilest", keywords, 427 &PyST_Type, &self, &str); 428 else 429 ok = PyArg_ParseTupleAndKeywords(args, kw, "|s:compile", &keywords[1], 430 &str); 431 432 if (ok) { 433 arena = PyArena_New(); 434 if (arena) { 435 mod = PyAST_FromNode(self->st_node, &(self->st_flags), str, arena); 436 if (mod) { 437 res = (PyObject *)PyAST_Compile(mod, str, &(self->st_flags), arena); 438 } 439 PyArena_Free(arena); 440 } 441 } 442 443 return (res); 444} 445 446 447/* PyObject* parser_isexpr(PyObject* self, PyObject* args) 448 * PyObject* parser_issuite(PyObject* self, PyObject* args) 449 * 450 * Checks the passed-in ST object to determine if it is an expression or 451 * a statement suite, respectively. The return is a Python truth value. 452 * 453 */ 454static PyObject* 455parser_isexpr(PyST_Object *self, PyObject *args, PyObject *kw) 456{ 457 PyObject* res = 0; 458 int ok; 459 460 static char *keywords[] = {"st", NULL}; 461 462 if (self == NULL || PyModule_Check(self)) 463 ok = PyArg_ParseTupleAndKeywords(args, kw, "O!:isexpr", keywords, 464 &PyST_Type, &self); 465 else 466 ok = PyArg_ParseTupleAndKeywords(args, kw, ":isexpr", &keywords[1]); 467 468 if (ok) { 469 /* Check to see if the ST represents an expression or not. */ 470 res = (self->st_type == PyST_EXPR) ? Py_True : Py_False; 471 Py_INCREF(res); 472 } 473 return (res); 474} 475 476 477static PyObject* 478parser_issuite(PyST_Object *self, PyObject *args, PyObject *kw) 479{ 480 PyObject* res = 0; 481 int ok; 482 483 static char *keywords[] = {"st", NULL}; 484 485 if (self == NULL || PyModule_Check(self)) 486 ok = PyArg_ParseTupleAndKeywords(args, kw, "O!:issuite", keywords, 487 &PyST_Type, &self); 488 else 489 ok = PyArg_ParseTupleAndKeywords(args, kw, ":issuite", &keywords[1]); 490 491 if (ok) { 492 /* Check to see if the ST represents an expression or not. */ 493 res = (self->st_type == PyST_EXPR) ? Py_False : Py_True; 494 Py_INCREF(res); 495 } 496 return (res); 497} 498 499 500/* err_string(char* message) 501 * 502 * Sets the error string for an exception of type ParserError. 503 * 504 */ 505static void 506err_string(char *message) 507{ 508 PyErr_SetString(parser_error, message); 509} 510 511 512/* PyObject* parser_do_parse(PyObject* args, int type) 513 * 514 * Internal function to actually execute the parse and return the result if 515 * successful or set an exception if not. 516 * 517 */ 518static PyObject* 519parser_do_parse(PyObject *args, PyObject *kw, char *argspec, int type) 520{ 521 char* string = 0; 522 PyObject* res = 0; 523 int flags = 0; 524 perrdetail err; 525 526 static char *keywords[] = {"source", NULL}; 527 528 if (PyArg_ParseTupleAndKeywords(args, kw, argspec, keywords, &string)) { 529 node* n = PyParser_ParseStringFlagsFilenameEx(string, NULL, 530 &_PyParser_Grammar, 531 (type == PyST_EXPR) 532 ? eval_input : file_input, 533 &err, &flags); 534 535 if (n) { 536 res = parser_newstobject(n, type); 537 if (res) 538 ((PyST_Object *)res)->st_flags.cf_flags = flags & PyCF_MASK; 539 } 540 else 541 PyParser_SetError(&err); 542 } 543 return (res); 544} 545 546 547/* PyObject* parser_expr(PyObject* self, PyObject* args) 548 * PyObject* parser_suite(PyObject* self, PyObject* args) 549 * 550 * External interfaces to the parser itself. Which is called determines if 551 * the parser attempts to recognize an expression ('eval' form) or statement 552 * suite ('exec' form). The real work is done by parser_do_parse() above. 553 * 554 */ 555static PyObject* 556parser_expr(PyST_Object *self, PyObject *args, PyObject *kw) 557{ 558 NOTE(ARGUNUSED(self)) 559 return (parser_do_parse(args, kw, "s:expr", PyST_EXPR)); 560} 561 562 563static PyObject* 564parser_suite(PyST_Object *self, PyObject *args, PyObject *kw) 565{ 566 NOTE(ARGUNUSED(self)) 567 return (parser_do_parse(args, kw, "s:suite", PyST_SUITE)); 568} 569 570 571 572/* This is the messy part of the code. Conversion from a tuple to an ST 573 * object requires that the input tuple be valid without having to rely on 574 * catching an exception from the compiler. This is done to allow the 575 * compiler itself to remain fast, since most of its input will come from 576 * the parser directly, and therefore be known to be syntactically correct. 577 * This validation is done to ensure that we don't core dump the compile 578 * phase, returning an exception instead. 579 * 580 * Two aspects can be broken out in this code: creating a node tree from 581 * the tuple passed in, and verifying that it is indeed valid. It may be 582 * advantageous to expand the number of ST types to include funcdefs and 583 * lambdadefs to take advantage of the optimizer, recognizing those STs 584 * here. They are not necessary, and not quite as useful in a raw form. 585 * For now, let's get expressions and suites working reliably. 586 */ 587 588 589static node* build_node_tree(PyObject *tuple); 590static int validate_expr_tree(node *tree); 591static int validate_file_input(node *tree); 592static int validate_encoding_decl(node *tree); 593 594/* PyObject* parser_tuple2st(PyObject* self, PyObject* args) 595 * 596 * This is the public function, called from the Python code. It receives a 597 * single tuple object from the caller, and creates an ST object if the 598 * tuple can be validated. It does this by checking the first code of the 599 * tuple, and, if acceptable, builds the internal representation. If this 600 * step succeeds, the internal representation is validated as fully as 601 * possible with the various validate_*() routines defined below. 602 * 603 * This function must be changed if support is to be added for PyST_FRAGMENT 604 * ST objects. 605 * 606 */ 607static PyObject* 608parser_tuple2st(PyST_Object *self, PyObject *args, PyObject *kw) 609{ 610 NOTE(ARGUNUSED(self)) 611 PyObject *st = 0; 612 PyObject *tuple; 613 node *tree; 614 615 static char *keywords[] = {"sequence", NULL}; 616 617 if (!PyArg_ParseTupleAndKeywords(args, kw, "O:sequence2st", keywords, 618 &tuple)) 619 return (0); 620 if (!PySequence_Check(tuple)) { 621 PyErr_SetString(PyExc_ValueError, 622 "sequence2st() requires a single sequence argument"); 623 return (0); 624 } 625 /* 626 * Convert the tree to the internal form before checking it. 627 */ 628 tree = build_node_tree(tuple); 629 if (tree != 0) { 630 int start_sym = TYPE(tree); 631 if (start_sym == eval_input) { 632 /* Might be an eval form. */ 633 if (validate_expr_tree(tree)) 634 st = parser_newstobject(tree, PyST_EXPR); 635 else 636 PyNode_Free(tree); 637 } 638 else if (start_sym == file_input) { 639 /* This looks like an exec form so far. */ 640 if (validate_file_input(tree)) 641 st = parser_newstobject(tree, PyST_SUITE); 642 else 643 PyNode_Free(tree); 644 } 645 else if (start_sym == encoding_decl) { 646 /* This looks like an encoding_decl so far. */ 647 if (validate_encoding_decl(tree)) 648 st = parser_newstobject(tree, PyST_SUITE); 649 else 650 PyNode_Free(tree); 651 } 652 else { 653 /* This is a fragment, at best. */ 654 PyNode_Free(tree); 655 err_string("parse tree does not use a valid start symbol"); 656 } 657 } 658 /* Make sure we throw an exception on all errors. We should never 659 * get this, but we'd do well to be sure something is done. 660 */ 661 if (st == NULL && !PyErr_Occurred()) 662 err_string("unspecified ST error occurred"); 663 664 return st; 665} 666 667 668/* node* build_node_children() 669 * 670 * Iterate across the children of the current non-terminal node and build 671 * their structures. If successful, return the root of this portion of 672 * the tree, otherwise, 0. Any required exception will be specified already, 673 * and no memory will have been deallocated. 674 * 675 */ 676static node* 677build_node_children(PyObject *tuple, node *root, int *line_num) 678{ 679 Py_ssize_t len = PyObject_Size(tuple); 680 Py_ssize_t i; 681 int err; 682 683 for (i = 1; i < len; ++i) { 684 /* elem must always be a sequence, however simple */ 685 PyObject* elem = PySequence_GetItem(tuple, i); 686 int ok = elem != NULL; 687 long type = 0; 688 char *strn = 0; 689 690 if (ok) 691 ok = PySequence_Check(elem); 692 if (ok) { 693 PyObject *temp = PySequence_GetItem(elem, 0); 694 if (temp == NULL) 695 ok = 0; 696 else { 697 ok = PyLong_Check(temp); 698 if (ok) 699 type = PyLong_AS_LONG(temp); 700 Py_DECREF(temp); 701 } 702 } 703 if (!ok) { 704 PyObject *err = Py_BuildValue("os", elem, 705 "Illegal node construct."); 706 PyErr_SetObject(parser_error, err); 707 Py_XDECREF(err); 708 Py_XDECREF(elem); 709 return (0); 710 } 711 if (ISTERMINAL(type)) { 712 Py_ssize_t len = PyObject_Size(elem); 713 PyObject *temp; 714 const char *temp_str; 715 716 if ((len != 2) && (len != 3)) { 717 err_string("terminal nodes must have 2 or 3 entries"); 718 return 0; 719 } 720 temp = PySequence_GetItem(elem, 1); 721 if (temp == NULL) 722 return 0; 723 if (!PyUnicode_Check(temp)) { 724 PyErr_Format(parser_error, 725 "second item in terminal node must be a string," 726 " found %s", 727 Py_TYPE(temp)->tp_name); 728 Py_DECREF(temp); 729 Py_DECREF(elem); 730 return 0; 731 } 732 if (len == 3) { 733 PyObject *o = PySequence_GetItem(elem, 2); 734 if (o != NULL) { 735 if (PyLong_Check(o)) 736 *line_num = PyLong_AS_LONG(o); 737 else { 738 PyErr_Format(parser_error, 739 "third item in terminal node must be an" 740 " integer, found %s", 741 Py_TYPE(temp)->tp_name); 742 Py_DECREF(o); 743 Py_DECREF(temp); 744 Py_DECREF(elem); 745 return 0; 746 } 747 Py_DECREF(o); 748 } 749 } 750 temp_str = _PyUnicode_AsStringAndSize(temp, &len); 751 strn = (char *)PyObject_MALLOC(len + 1); 752 if (strn != NULL) 753 (void) memcpy(strn, temp_str, len + 1); 754 Py_DECREF(temp); 755 } 756 else if (!ISNONTERMINAL(type)) { 757 /* 758 * It has to be one or the other; this is an error. 759 * Throw an exception. 760 */ 761 PyObject *err = Py_BuildValue("os", elem, "unknown node type."); 762 PyErr_SetObject(parser_error, err); 763 Py_XDECREF(err); 764 Py_XDECREF(elem); 765 return (0); 766 } 767 err = PyNode_AddChild(root, type, strn, *line_num, 0); 768 if (err == E_NOMEM) { 769 Py_XDECREF(elem); 770 PyObject_FREE(strn); 771 return (node *) PyErr_NoMemory(); 772 } 773 if (err == E_OVERFLOW) { 774 Py_XDECREF(elem); 775 PyObject_FREE(strn); 776 PyErr_SetString(PyExc_ValueError, 777 "unsupported number of child nodes"); 778 return NULL; 779 } 780 781 if (ISNONTERMINAL(type)) { 782 node* new_child = CHILD(root, i - 1); 783 784 if (new_child != build_node_children(elem, new_child, line_num)) { 785 Py_XDECREF(elem); 786 return (0); 787 } 788 } 789 else if (type == NEWLINE) { /* It's true: we increment the */ 790 ++(*line_num); /* line number *after* the newline! */ 791 } 792 Py_XDECREF(elem); 793 } 794 return root; 795} 796 797 798static node* 799build_node_tree(PyObject *tuple) 800{ 801 node* res = 0; 802 PyObject *temp = PySequence_GetItem(tuple, 0); 803 long num = -1; 804 805 if (temp != NULL) 806 num = PyLong_AsLong(temp); 807 Py_XDECREF(temp); 808 if (ISTERMINAL(num)) { 809 /* 810 * The tuple is simple, but it doesn't start with a start symbol. 811 * Throw an exception now and be done with it. 812 */ 813 tuple = Py_BuildValue("os", tuple, 814 "Illegal syntax-tree; cannot start with terminal symbol."); 815 PyErr_SetObject(parser_error, tuple); 816 Py_XDECREF(tuple); 817 } 818 else if (ISNONTERMINAL(num)) { 819 /* 820 * Not efficient, but that can be handled later. 821 */ 822 int line_num = 0; 823 PyObject *encoding = NULL; 824 825 if (num == encoding_decl) { 826 encoding = PySequence_GetItem(tuple, 2); 827 /* tuple isn't borrowed anymore here, need to DECREF */ 828 tuple = PySequence_GetSlice(tuple, 0, 2); 829 } 830 res = PyNode_New(num); 831 if (res != NULL) { 832 if (res != build_node_children(tuple, res, &line_num)) { 833 PyNode_Free(res); 834 res = NULL; 835 } 836 if (res && encoding) { 837 Py_ssize_t len; 838 const char *temp; 839 temp = _PyUnicode_AsStringAndSize(encoding, &len); 840 res->n_str = (char *)PyObject_MALLOC(len + 1); 841 if (res->n_str != NULL && temp != NULL) 842 (void) memcpy(res->n_str, temp, len + 1); 843 Py_DECREF(encoding); 844 Py_DECREF(tuple); 845 } 846 } 847 } 848 else { 849 /* The tuple is illegal -- if the number is neither TERMINAL nor 850 * NONTERMINAL, we can't use it. Not sure the implementation 851 * allows this condition, but the API doesn't preclude it. 852 */ 853 PyObject *err = Py_BuildValue("os", tuple, 854 "Illegal component tuple."); 855 PyErr_SetObject(parser_error, err); 856 Py_XDECREF(err); 857 } 858 859 return (res); 860} 861 862 863/* 864 * Validation routines used within the validation section: 865 */ 866static int validate_terminal(node *terminal, int type, char *string); 867 868#define validate_ampersand(ch) validate_terminal(ch, AMPER, "&") 869#define validate_circumflex(ch) validate_terminal(ch, CIRCUMFLEX, "^") 870#define validate_colon(ch) validate_terminal(ch, COLON, ":") 871#define validate_comma(ch) validate_terminal(ch, COMMA, ",") 872#define validate_dedent(ch) validate_terminal(ch, DEDENT, "") 873#define validate_equal(ch) validate_terminal(ch, EQUAL, "=") 874#define validate_indent(ch) validate_terminal(ch, INDENT, (char*)NULL) 875#define validate_lparen(ch) validate_terminal(ch, LPAR, "(") 876#define validate_newline(ch) validate_terminal(ch, NEWLINE, (char*)NULL) 877#define validate_rparen(ch) validate_terminal(ch, RPAR, ")") 878#define validate_semi(ch) validate_terminal(ch, SEMI, ";") 879#define validate_star(ch) validate_terminal(ch, STAR, "*") 880#define validate_vbar(ch) validate_terminal(ch, VBAR, "|") 881#define validate_doublestar(ch) validate_terminal(ch, DOUBLESTAR, "**") 882#define validate_dot(ch) validate_terminal(ch, DOT, ".") 883#define validate_at(ch) validate_terminal(ch, AT, "@") 884#define validate_name(ch, str) validate_terminal(ch, NAME, str) 885 886#define VALIDATER(n) static int validate_##n(node *tree) 887 888VALIDATER(node); VALIDATER(small_stmt); 889VALIDATER(class); VALIDATER(node); 890VALIDATER(parameters); VALIDATER(suite); 891VALIDATER(testlist); VALIDATER(varargslist); 892VALIDATER(vfpdef); 893VALIDATER(stmt); VALIDATER(simple_stmt); 894VALIDATER(expr_stmt); VALIDATER(power); 895VALIDATER(del_stmt); 896VALIDATER(return_stmt); VALIDATER(raise_stmt); 897VALIDATER(import_stmt); VALIDATER(import_stmt); 898VALIDATER(import_name); VALIDATER(yield_stmt); 899VALIDATER(global_stmt); VALIDATER(assert_stmt); 900VALIDATER(compound_stmt); 901VALIDATER(while); VALIDATER(for); 902VALIDATER(try); VALIDATER(except_clause); 903VALIDATER(test); VALIDATER(and_test); 904VALIDATER(not_test); VALIDATER(comparison); 905VALIDATER(comp_op); 906VALIDATER(star_expr); VALIDATER(expr); 907VALIDATER(xor_expr); VALIDATER(and_expr); 908VALIDATER(shift_expr); VALIDATER(arith_expr); 909VALIDATER(term); VALIDATER(factor); 910VALIDATER(atom); VALIDATER(lambdef); 911VALIDATER(trailer); VALIDATER(subscript); 912VALIDATER(subscriptlist); VALIDATER(sliceop); 913VALIDATER(exprlist); VALIDATER(dictorsetmaker); 914VALIDATER(arglist); VALIDATER(argument); 915VALIDATER(testlist1); VALIDATER(comp_for); 916VALIDATER(comp_iter); VALIDATER(comp_if); 917VALIDATER(testlist_comp); VALIDATER(yield_expr); 918VALIDATER(yield_or_testlist); VALIDATER(or_test); 919VALIDATER(test_nocond); VALIDATER(lambdef_nocond); 920 921#undef VALIDATER 922 923#define is_even(n) (((n) & 1) == 0) 924#define is_odd(n) (((n) & 1) == 1) 925 926 927static int 928validate_ntype(node *n, int t) 929{ 930 if (TYPE(n) != t) { 931 PyErr_Format(parser_error, "Expected node type %d, got %d.", 932 t, TYPE(n)); 933 return 0; 934 } 935 return 1; 936} 937 938 939/* Verifies that the number of child nodes is exactly 'num', raising 940 * an exception if it isn't. The exception message does not indicate 941 * the exact number of nodes, allowing this to be used to raise the 942 * "right" exception when the wrong number of nodes is present in a 943 * specific variant of a statement's syntax. This is commonly used 944 * in that fashion. 945 */ 946static int 947validate_numnodes(node *n, int num, const char *const name) 948{ 949 if (NCH(n) != num) { 950 PyErr_Format(parser_error, 951 "Illegal number of children for %s node.", name); 952 return 0; 953 } 954 return 1; 955} 956 957 958static int 959validate_terminal(node *terminal, int type, char *string) 960{ 961 int res = (validate_ntype(terminal, type) 962 && ((string == 0) || (strcmp(string, STR(terminal)) == 0))); 963 964 if (!res && !PyErr_Occurred()) { 965 PyErr_Format(parser_error, 966 "Illegal terminal: expected \"%s\"", string); 967 } 968 return (res); 969} 970 971 972/* X (',' X) [','] 973 */ 974static int 975validate_repeating_list(node *tree, int ntype, int (*vfunc)(node *), 976 const char *const name) 977{ 978 int nch = NCH(tree); 979 int res = (nch && validate_ntype(tree, ntype) 980 && vfunc(CHILD(tree, 0))); 981 982 if (!res && !PyErr_Occurred()) 983 (void) validate_numnodes(tree, 1, name); 984 else { 985 if (is_even(nch)) 986 res = validate_comma(CHILD(tree, --nch)); 987 if (res && nch > 1) { 988 int pos = 1; 989 for ( ; res && pos < nch; pos += 2) 990 res = (validate_comma(CHILD(tree, pos)) 991 && vfunc(CHILD(tree, pos + 1))); 992 } 993 } 994 return (res); 995} 996 997 998/* validate_class() 999 * 1000 * classdef: 1001 * 'class' NAME ['(' testlist ')'] ':' suite 1002 */ 1003static int 1004validate_class(node *tree) 1005{ 1006 int nch = NCH(tree); 1007 int res = (validate_ntype(tree, classdef) && 1008 ((nch == 4) || (nch == 6) || (nch == 7))); 1009 1010 if (res) { 1011 res = (validate_name(CHILD(tree, 0), "class") 1012 && validate_ntype(CHILD(tree, 1), NAME) 1013 && validate_colon(CHILD(tree, nch - 2)) 1014 && validate_suite(CHILD(tree, nch - 1))); 1015 } 1016 else { 1017 (void) validate_numnodes(tree, 4, "class"); 1018 } 1019 1020 if (res) { 1021 if (nch == 7) { 1022 res = ((validate_lparen(CHILD(tree, 2)) && 1023 validate_arglist(CHILD(tree, 3)) && 1024 validate_rparen(CHILD(tree, 4)))); 1025 } 1026 else if (nch == 6) { 1027 res = (validate_lparen(CHILD(tree,2)) && 1028 validate_rparen(CHILD(tree,3))); 1029 } 1030 } 1031 return (res); 1032} 1033 1034 1035/* if_stmt: 1036 * 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] 1037 */ 1038static int 1039validate_if(node *tree) 1040{ 1041 int nch = NCH(tree); 1042 int res = (validate_ntype(tree, if_stmt) 1043 && (nch >= 4) 1044 && validate_name(CHILD(tree, 0), "if") 1045 && validate_test(CHILD(tree, 1)) 1046 && validate_colon(CHILD(tree, 2)) 1047 && validate_suite(CHILD(tree, 3))); 1048 1049 if (res && ((nch % 4) == 3)) { 1050 /* ... 'else' ':' suite */ 1051 res = (validate_name(CHILD(tree, nch - 3), "else") 1052 && validate_colon(CHILD(tree, nch - 2)) 1053 && validate_suite(CHILD(tree, nch - 1))); 1054 nch -= 3; 1055 } 1056 else if (!res && !PyErr_Occurred()) 1057 (void) validate_numnodes(tree, 4, "if"); 1058 if ((nch % 4) != 0) 1059 /* Will catch the case for nch < 4 */ 1060 res = validate_numnodes(tree, 0, "if"); 1061 else if (res && (nch > 4)) { 1062 /* ... ('elif' test ':' suite)+ ... */ 1063 int j = 4; 1064 while ((j < nch) && res) { 1065 res = (validate_name(CHILD(tree, j), "elif") 1066 && validate_colon(CHILD(tree, j + 2)) 1067 && validate_test(CHILD(tree, j + 1)) 1068 && validate_suite(CHILD(tree, j + 3))); 1069 j += 4; 1070 } 1071 } 1072 return (res); 1073} 1074 1075 1076/* parameters: 1077 * '(' [varargslist] ')' 1078 * 1079 */ 1080static int 1081validate_parameters(node *tree) 1082{ 1083 int nch = NCH(tree); 1084 int res = validate_ntype(tree, parameters) && ((nch == 2) || (nch == 3)); 1085 1086 if (res) { 1087 res = (validate_lparen(CHILD(tree, 0)) 1088 && validate_rparen(CHILD(tree, nch - 1))); 1089 if (res && (nch == 3)) 1090 res = validate_varargslist(CHILD(tree, 1)); 1091 } 1092 else { 1093 (void) validate_numnodes(tree, 2, "parameters"); 1094 } 1095 return (res); 1096} 1097 1098 1099/* validate_suite() 1100 * 1101 * suite: 1102 * simple_stmt 1103 * | NEWLINE INDENT stmt+ DEDENT 1104 */ 1105static int 1106validate_suite(node *tree) 1107{ 1108 int nch = NCH(tree); 1109 int res = (validate_ntype(tree, suite) && ((nch == 1) || (nch >= 4))); 1110 1111 if (res && (nch == 1)) 1112 res = validate_simple_stmt(CHILD(tree, 0)); 1113 else if (res) { 1114 /* NEWLINE INDENT stmt+ DEDENT */ 1115 res = (validate_newline(CHILD(tree, 0)) 1116 && validate_indent(CHILD(tree, 1)) 1117 && validate_stmt(CHILD(tree, 2)) 1118 && validate_dedent(CHILD(tree, nch - 1))); 1119 1120 if (res && (nch > 4)) { 1121 int i = 3; 1122 --nch; /* forget the DEDENT */ 1123 for ( ; res && (i < nch); ++i) 1124 res = validate_stmt(CHILD(tree, i)); 1125 } 1126 else if (nch < 4) 1127 res = validate_numnodes(tree, 4, "suite"); 1128 } 1129 return (res); 1130} 1131 1132 1133static int 1134validate_testlist(node *tree) 1135{ 1136 return (validate_repeating_list(tree, testlist, 1137 validate_test, "testlist")); 1138} 1139 1140 1141static int 1142validate_testlist1(node *tree) 1143{ 1144 return (validate_repeating_list(tree, testlist1, 1145 validate_test, "testlist1")); 1146} 1147 1148 1149/* validate either vfpdef or tfpdef. 1150 * vfpdef: NAME 1151 * tfpdef: NAME [':' test] 1152 */ 1153static int 1154validate_vfpdef(node *tree) 1155{ 1156 int nch = NCH(tree); 1157 if (TYPE(tree) == vfpdef) { 1158 return nch == 1 && validate_name(CHILD(tree, 0), NULL); 1159 } 1160 else if (TYPE(tree) == tfpdef) { 1161 if (nch == 1) { 1162 return validate_name(CHILD(tree, 0), NULL); 1163 } 1164 else if (nch == 3) { 1165 return validate_name(CHILD(tree, 0), NULL) && 1166 validate_colon(CHILD(tree, 1)) && 1167 validate_test(CHILD(tree, 2)); 1168 } 1169 } 1170 return 0; 1171} 1172 1173/* '*' vfpdef (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef 1174 * ..or tfpdef in place of vfpdef. vfpdef: NAME; tfpdef: NAME [':' test] 1175 */ 1176static int 1177validate_varargslist_trailer(node *tree, int start) 1178{ 1179 int nch = NCH(tree); 1180 int res = 0, i; 1181 int sym; 1182 1183 if (nch <= start) { 1184 err_string("expected variable argument trailer for varargslist"); 1185 return 0; 1186 } 1187 sym = TYPE(CHILD(tree, start)); 1188 if (sym == STAR) { 1189 /* 1190 * '*' vfpdef (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef 1191 */ 1192 if (nch-start == 2) 1193 res = validate_vfpdef(CHILD(tree, start+1)); 1194 else if (nch-start == 5 && TYPE(CHILD(tree, start+2)) == COMMA) 1195 res = (validate_vfpdef(CHILD(tree, start+1)) 1196 && validate_comma(CHILD(tree, start+2)) 1197 && validate_doublestar(CHILD(tree, start+3)) 1198 && validate_vfpdef(CHILD(tree, start+4))); 1199 else { 1200 /* skip over vfpdef (',' vfpdef ['=' test])* */ 1201 i = start + 1; 1202 if (TYPE(CHILD(tree, i)) == vfpdef || 1203 TYPE(CHILD(tree, i)) == tfpdef) { /* skip over vfpdef or tfpdef */ 1204 i += 1; 1205 } 1206 while (res && i+1 < nch) { /* validate (',' vfpdef ['=' test])* */ 1207 res = validate_comma(CHILD(tree, i)); 1208 if (TYPE(CHILD(tree, i+1)) == DOUBLESTAR) 1209 break; 1210 res = res && validate_vfpdef(CHILD(tree, i+1)); 1211 if (res && i+2 < nch && TYPE(CHILD(tree, i+2)) == EQUAL) { 1212 res = res && (i+3 < nch) 1213 && validate_test(CHILD(tree, i+3)); 1214 i += 4; 1215 } 1216 else { 1217 i += 2; 1218 } 1219 } 1220 /* [',' '**' vfpdef] */ 1221 if (res && i+1 < nch && TYPE(CHILD(tree, i+1)) == DOUBLESTAR) { 1222 res = validate_vfpdef(CHILD(tree, i+2)); 1223 } 1224 } 1225 } 1226 else if (sym == DOUBLESTAR) { 1227 /* 1228 * '**' NAME 1229 */ 1230 if (nch-start == 2) 1231 res = validate_vfpdef(CHILD(tree, start+1)); 1232 } 1233 if (!res) 1234 err_string("illegal variable argument trailer for varargslist"); 1235 return res; 1236} 1237 1238 1239/* validate_varargslist() 1240 * 1241 * Validate typedargslist or varargslist. 1242 * 1243 * typedargslist: ((tfpdef ['=' test] ',')* 1244 * ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | 1245 * '**' tfpdef) 1246 * | tfpdef ['=' test] (',' tfpdef ['=' test])* [',']) 1247 * tfpdef: NAME [':' test] 1248 * varargslist: ((vfpdef ['=' test] ',')* 1249 * ('*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | 1250 * '**' vfpdef) 1251 * | vfpdef ['=' test] (',' vfpdef ['=' test])* [',']) 1252 * vfpdef: NAME 1253 * 1254 */ 1255static int 1256validate_varargslist(node *tree) 1257{ 1258 int nch = NCH(tree); 1259 int res = (TYPE(tree) == varargslist || 1260 TYPE(tree) == typedargslist) && 1261 (nch != 0); 1262 int sym; 1263 node *ch; 1264 int i = 0; 1265 1266 if (!res) 1267 return 0; 1268 if (nch < 1) { 1269 err_string("varargslist missing child nodes"); 1270 return 0; 1271 } 1272 while (i < nch) { 1273 ch = CHILD(tree, i); 1274 sym = TYPE(ch); 1275 if (sym == vfpdef || sym == tfpdef) { 1276 /* validate (vfpdef ['=' test] ',')+ */ 1277 res = validate_vfpdef(ch); 1278 ++i; 1279 if (res && (i+2 <= nch) && TYPE(CHILD(tree, i)) == EQUAL) { 1280 res = (validate_equal(CHILD(tree, i)) 1281 && validate_test(CHILD(tree, i+1))); 1282 if (res) 1283 i += 2; 1284 } 1285 if (res && i < nch) { 1286 res = validate_comma(CHILD(tree, i)); 1287 ++i; 1288 } 1289 } else if (sym == DOUBLESTAR || sym == STAR) { 1290 res = validate_varargslist_trailer(tree, i); 1291 break; 1292 } else { 1293 res = 0; 1294 err_string("illegal formation for varargslist"); 1295 } 1296 } 1297 return res; 1298} 1299 1300 1301/* comp_iter: comp_for | comp_if 1302 */ 1303static int 1304validate_comp_iter(node *tree) 1305{ 1306 int res = (validate_ntype(tree, comp_iter) 1307 && validate_numnodes(tree, 1, "comp_iter")); 1308 if (res && TYPE(CHILD(tree, 0)) == comp_for) 1309 res = validate_comp_for(CHILD(tree, 0)); 1310 else 1311 res = validate_comp_if(CHILD(tree, 0)); 1312 1313 return res; 1314} 1315 1316/* comp_for: 'for' exprlist 'in' test [comp_iter] 1317 */ 1318static int 1319validate_comp_for(node *tree) 1320{ 1321 int nch = NCH(tree); 1322 int res; 1323 1324 if (nch == 5) 1325 res = validate_comp_iter(CHILD(tree, 4)); 1326 else 1327 res = validate_numnodes(tree, 4, "comp_for"); 1328 1329 if (res) 1330 res = (validate_name(CHILD(tree, 0), "for") 1331 && validate_exprlist(CHILD(tree, 1)) 1332 && validate_name(CHILD(tree, 2), "in") 1333 && validate_or_test(CHILD(tree, 3))); 1334 1335 return res; 1336} 1337 1338/* comp_if: 'if' test_nocond [comp_iter] 1339 */ 1340static int 1341validate_comp_if(node *tree) 1342{ 1343 int nch = NCH(tree); 1344 int res; 1345 1346 if (nch == 3) 1347 res = validate_comp_iter(CHILD(tree, 2)); 1348 else 1349 res = validate_numnodes(tree, 2, "comp_if"); 1350 1351 if (res) 1352 res = (validate_name(CHILD(tree, 0), "if") 1353 && validate_test_nocond(CHILD(tree, 1))); 1354 1355 return res; 1356} 1357 1358 1359/* simple_stmt | compound_stmt 1360 * 1361 */ 1362static int 1363validate_stmt(node *tree) 1364{ 1365 int res = (validate_ntype(tree, stmt) 1366 && validate_numnodes(tree, 1, "stmt")); 1367 1368 if (res) { 1369 tree = CHILD(tree, 0); 1370 1371 if (TYPE(tree) == simple_stmt) 1372 res = validate_simple_stmt(tree); 1373 else 1374 res = validate_compound_stmt(tree); 1375 } 1376 return (res); 1377} 1378 1379 1380/* small_stmt (';' small_stmt)* [';'] NEWLINE 1381 * 1382 */ 1383static int 1384validate_simple_stmt(node *tree) 1385{ 1386 int nch = NCH(tree); 1387 int res = (validate_ntype(tree, simple_stmt) 1388 && (nch >= 2) 1389 && validate_small_stmt(CHILD(tree, 0)) 1390 && validate_newline(CHILD(tree, nch - 1))); 1391 1392 if (nch < 2) 1393 res = validate_numnodes(tree, 2, "simple_stmt"); 1394 --nch; /* forget the NEWLINE */ 1395 if (res && is_even(nch)) 1396 res = validate_semi(CHILD(tree, --nch)); 1397 if (res && (nch > 2)) { 1398 int i; 1399 1400 for (i = 1; res && (i < nch); i += 2) 1401 res = (validate_semi(CHILD(tree, i)) 1402 && validate_small_stmt(CHILD(tree, i + 1))); 1403 } 1404 return (res); 1405} 1406 1407 1408static int 1409validate_small_stmt(node *tree) 1410{ 1411 int nch = NCH(tree); 1412 int res = validate_numnodes(tree, 1, "small_stmt"); 1413 1414 if (res) { 1415 int ntype = TYPE(CHILD(tree, 0)); 1416 1417 if ( (ntype == expr_stmt) 1418 || (ntype == del_stmt) 1419 || (ntype == pass_stmt) 1420 || (ntype == flow_stmt) 1421 || (ntype == import_stmt) 1422 || (ntype == global_stmt) 1423 || (ntype == assert_stmt)) 1424 res = validate_node(CHILD(tree, 0)); 1425 else { 1426 res = 0; 1427 err_string("illegal small_stmt child type"); 1428 } 1429 } 1430 else if (nch == 1) { 1431 res = 0; 1432 PyErr_Format(parser_error, 1433 "Unrecognized child node of small_stmt: %d.", 1434 TYPE(CHILD(tree, 0))); 1435 } 1436 return (res); 1437} 1438 1439 1440/* compound_stmt: 1441 * if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated 1442 */ 1443static int 1444validate_compound_stmt(node *tree) 1445{ 1446 int res = (validate_ntype(tree, compound_stmt) 1447 && validate_numnodes(tree, 1, "compound_stmt")); 1448 int ntype; 1449 1450 if (!res) 1451 return (0); 1452 1453 tree = CHILD(tree, 0); 1454 ntype = TYPE(tree); 1455 if ( (ntype == if_stmt) 1456 || (ntype == while_stmt) 1457 || (ntype == for_stmt) 1458 || (ntype == try_stmt) 1459 || (ntype == with_stmt) 1460 || (ntype == funcdef) 1461 || (ntype == classdef) 1462 || (ntype == decorated)) 1463 res = validate_node(tree); 1464 else { 1465 res = 0; 1466 PyErr_Format(parser_error, 1467 "Illegal compound statement type: %d.", TYPE(tree)); 1468 } 1469 return (res); 1470} 1471 1472static int 1473validate_yield_or_testlist(node *tree) 1474{ 1475 if (TYPE(tree) == yield_expr) 1476 return validate_yield_expr(tree); 1477 else 1478 return validate_testlist(tree); 1479} 1480 1481static int 1482validate_expr_stmt(node *tree) 1483{ 1484 int j; 1485 int nch = NCH(tree); 1486 int res = (validate_ntype(tree, expr_stmt) 1487 && is_odd(nch) 1488 && validate_testlist(CHILD(tree, 0))); 1489 1490 if (res && nch == 3 1491 && TYPE(CHILD(tree, 1)) == augassign) { 1492 res = validate_numnodes(CHILD(tree, 1), 1, "augassign") 1493 && validate_yield_or_testlist(CHILD(tree, 2)); 1494 1495 if (res) { 1496 char *s = STR(CHILD(CHILD(tree, 1), 0)); 1497 1498 res = (strcmp(s, "+=") == 0 1499 || strcmp(s, "-=") == 0 1500 || strcmp(s, "*=") == 0 1501 || strcmp(s, "/=") == 0 1502 || strcmp(s, "//=") == 0 1503 || strcmp(s, "%=") == 0 1504 || strcmp(s, "&=") == 0 1505 || strcmp(s, "|=") == 0 1506 || strcmp(s, "^=") == 0 1507 || strcmp(s, "<<=") == 0 1508 || strcmp(s, ">>=") == 0 1509 || strcmp(s, "**=") == 0); 1510 if (!res) 1511 err_string("illegal augmmented assignment operator"); 1512 } 1513 } 1514 else { 1515 for (j = 1; res && (j < nch); j += 2) 1516 res = validate_equal(CHILD(tree, j)) 1517 && validate_yield_or_testlist(CHILD(tree, j + 1)); 1518 } 1519 return (res); 1520} 1521 1522 1523static int 1524validate_del_stmt(node *tree) 1525{ 1526 return (validate_numnodes(tree, 2, "del_stmt") 1527 && validate_name(CHILD(tree, 0), "del") 1528 && validate_exprlist(CHILD(tree, 1))); 1529} 1530 1531 1532static int 1533validate_return_stmt(node *tree) 1534{ 1535 int nch = NCH(tree); 1536 int res = (validate_ntype(tree, return_stmt) 1537 && ((nch == 1) || (nch == 2)) 1538 && validate_name(CHILD(tree, 0), "return")); 1539 1540 if (res && (nch == 2)) 1541 res = validate_testlist(CHILD(tree, 1)); 1542 1543 return (res); 1544} 1545 1546 1547static int 1548validate_raise_stmt(node *tree) 1549{ 1550 int nch = NCH(tree); 1551 int res = (validate_ntype(tree, raise_stmt) 1552 && ((nch == 1) || (nch == 2) || (nch == 4) || (nch == 6))); 1553 1554 if (res) { 1555 res = validate_name(CHILD(tree, 0), "raise"); 1556 if (res && (nch >= 2)) 1557 res = validate_test(CHILD(tree, 1)); 1558 if (res && nch > 2) { 1559 res = (validate_comma(CHILD(tree, 2)) 1560 && validate_test(CHILD(tree, 3))); 1561 if (res && (nch > 4)) 1562 res = (validate_comma(CHILD(tree, 4)) 1563 && validate_test(CHILD(tree, 5))); 1564 } 1565 } 1566 else 1567 (void) validate_numnodes(tree, 2, "raise"); 1568 if (res && (nch == 4)) 1569 res = (validate_comma(CHILD(tree, 2)) 1570 && validate_test(CHILD(tree, 3))); 1571 1572 return (res); 1573} 1574 1575 1576/* yield_expr: 'yield' [testlist] 1577 */ 1578static int 1579validate_yield_expr(node *tree) 1580{ 1581 int nch = NCH(tree); 1582 int res = (validate_ntype(tree, yield_expr) 1583 && ((nch == 1) || (nch == 2)) 1584 && validate_name(CHILD(tree, 0), "yield")); 1585 1586 if (res && (nch == 2)) 1587 res = validate_testlist(CHILD(tree, 1)); 1588 1589 return (res); 1590} 1591 1592 1593/* yield_stmt: yield_expr 1594 */ 1595static int 1596validate_yield_stmt(node *tree) 1597{ 1598 return (validate_ntype(tree, yield_stmt) 1599 && validate_numnodes(tree, 1, "yield_stmt") 1600 && validate_yield_expr(CHILD(tree, 0))); 1601} 1602 1603 1604static int 1605validate_import_as_name(node *tree) 1606{ 1607 int nch = NCH(tree); 1608 int ok = validate_ntype(tree, import_as_name); 1609 1610 if (ok) { 1611 if (nch == 1) 1612 ok = validate_name(CHILD(tree, 0), NULL); 1613 else if (nch == 3) 1614 ok = (validate_name(CHILD(tree, 0), NULL) 1615 && validate_name(CHILD(tree, 1), "as") 1616 && validate_name(CHILD(tree, 2), NULL)); 1617 else 1618 ok = validate_numnodes(tree, 3, "import_as_name"); 1619 } 1620 return ok; 1621} 1622 1623 1624/* dotted_name: NAME ("." NAME)* 1625 */ 1626static int 1627validate_dotted_name(node *tree) 1628{ 1629 int nch = NCH(tree); 1630 int res = (validate_ntype(tree, dotted_name) 1631 && is_odd(nch) 1632 && validate_name(CHILD(tree, 0), NULL)); 1633 int i; 1634 1635 for (i = 1; res && (i < nch); i += 2) { 1636 res = (validate_dot(CHILD(tree, i)) 1637 && validate_name(CHILD(tree, i+1), NULL)); 1638 } 1639 return res; 1640} 1641 1642 1643/* dotted_as_name: dotted_name [NAME NAME] 1644 */ 1645static int 1646validate_dotted_as_name(node *tree) 1647{ 1648 int nch = NCH(tree); 1649 int res = validate_ntype(tree, dotted_as_name); 1650 1651 if (res) { 1652 if (nch == 1) 1653 res = validate_dotted_name(CHILD(tree, 0)); 1654 else if (nch == 3) 1655 res = (validate_dotted_name(CHILD(tree, 0)) 1656 && validate_name(CHILD(tree, 1), "as") 1657 && validate_name(CHILD(tree, 2), NULL)); 1658 else { 1659 res = 0; 1660 err_string("illegal number of children for dotted_as_name"); 1661 } 1662 } 1663 return res; 1664} 1665 1666 1667/* dotted_as_name (',' dotted_as_name)* */ 1668static int 1669validate_dotted_as_names(node *tree) 1670{ 1671 int nch = NCH(tree); 1672 int res = is_odd(nch) && validate_dotted_as_name(CHILD(tree, 0)); 1673 int i; 1674 1675 for (i = 1; res && (i < nch); i += 2) 1676 res = (validate_comma(CHILD(tree, i)) 1677 && validate_dotted_as_name(CHILD(tree, i + 1))); 1678 return (res); 1679} 1680 1681 1682/* import_as_name (',' import_as_name)* [','] */ 1683static int 1684validate_import_as_names(node *tree) 1685{ 1686 int nch = NCH(tree); 1687 int res = validate_import_as_name(CHILD(tree, 0)); 1688 int i; 1689 1690 for (i = 1; res && (i + 1 < nch); i += 2) 1691 res = (validate_comma(CHILD(tree, i)) 1692 && validate_import_as_name(CHILD(tree, i + 1))); 1693 return (res); 1694} 1695 1696 1697/* 'import' dotted_as_names */ 1698static int 1699validate_import_name(node *tree) 1700{ 1701 return (validate_ntype(tree, import_name) 1702 && validate_numnodes(tree, 2, "import_name") 1703 && validate_name(CHILD(tree, 0), "import") 1704 && validate_dotted_as_names(CHILD(tree, 1))); 1705} 1706 1707/* Helper function to count the number of leading dots in 1708 * 'from ...module import name' 1709 */ 1710static int 1711count_from_dots(node *tree) 1712{ 1713 int i; 1714 for (i = 1; i < NCH(tree); i++) 1715 if (TYPE(CHILD(tree, i)) != DOT) 1716 break; 1717 return i-1; 1718} 1719 1720/* 'from' ('.'* dotted_name | '.') 'import' ('*' | '(' import_as_names ')' | 1721 * import_as_names 1722 */ 1723static int 1724validate_import_from(node *tree) 1725{ 1726 int nch = NCH(tree); 1727 int ndots = count_from_dots(tree); 1728 int havename = (TYPE(CHILD(tree, ndots + 1)) == dotted_name); 1729 int offset = ndots + havename; 1730 int res = validate_ntype(tree, import_from) 1731 && (nch >= 4 + ndots) 1732 && validate_name(CHILD(tree, 0), "from") 1733 && (!havename || validate_dotted_name(CHILD(tree, ndots + 1))) 1734 && validate_name(CHILD(tree, offset + 1), "import"); 1735 1736 if (res && TYPE(CHILD(tree, offset + 2)) == LPAR) 1737 res = ((nch == offset + 5) 1738 && validate_lparen(CHILD(tree, offset + 2)) 1739 && validate_import_as_names(CHILD(tree, offset + 3)) 1740 && validate_rparen(CHILD(tree, offset + 4))); 1741 else if (res && TYPE(CHILD(tree, offset + 2)) != STAR) 1742 res = validate_import_as_names(CHILD(tree, offset + 2)); 1743 return (res); 1744} 1745 1746 1747/* import_stmt: import_name | import_from */ 1748static int 1749validate_import_stmt(node *tree) 1750{ 1751 int nch = NCH(tree); 1752 int res = validate_numnodes(tree, 1, "import_stmt"); 1753 1754 if (res) { 1755 int ntype = TYPE(CHILD(tree, 0)); 1756 1757 if (ntype == import_name || ntype == import_from) 1758 res = validate_node(CHILD(tree, 0)); 1759 else { 1760 res = 0; 1761 err_string("illegal import_stmt child type"); 1762 } 1763 } 1764 else if (nch == 1) { 1765 res = 0; 1766 PyErr_Format(parser_error, 1767 "Unrecognized child node of import_stmt: %d.", 1768 TYPE(CHILD(tree, 0))); 1769 } 1770 return (res); 1771} 1772 1773 1774 1775 1776static int 1777validate_global_stmt(node *tree) 1778{ 1779 int j; 1780 int nch = NCH(tree); 1781 int res = (validate_ntype(tree, global_stmt) 1782 && is_even(nch) && (nch >= 2)); 1783 1784 if (!res && !PyErr_Occurred()) 1785 err_string("illegal global statement"); 1786 1787 if (res) 1788 res = (validate_name(CHILD(tree, 0), "global") 1789 && validate_ntype(CHILD(tree, 1), NAME)); 1790 for (j = 2; res && (j < nch); j += 2) 1791 res = (validate_comma(CHILD(tree, j)) 1792 && validate_ntype(CHILD(tree, j + 1), NAME)); 1793 1794 return (res); 1795} 1796 1797 1798/* assert_stmt: 1799 * 1800 * 'assert' test [',' test] 1801 */ 1802static int 1803validate_assert_stmt(node *tree) 1804{ 1805 int nch = NCH(tree); 1806 int res = (validate_ntype(tree, assert_stmt) 1807 && ((nch == 2) || (nch == 4)) 1808 && (validate_name(CHILD(tree, 0), "assert")) 1809 && validate_test(CHILD(tree, 1))); 1810 1811 if (!res && !PyErr_Occurred()) 1812 err_string("illegal assert statement"); 1813 if (res && (nch > 2)) 1814 res = (validate_comma(CHILD(tree, 2)) 1815 && validate_test(CHILD(tree, 3))); 1816 1817 return (res); 1818} 1819 1820 1821static int 1822validate_while(node *tree) 1823{ 1824 int nch = NCH(tree); 1825 int res = (validate_ntype(tree, while_stmt) 1826 && ((nch == 4) || (nch == 7)) 1827 && validate_name(CHILD(tree, 0), "while") 1828 && validate_test(CHILD(tree, 1)) 1829 && validate_colon(CHILD(tree, 2)) 1830 && validate_suite(CHILD(tree, 3))); 1831 1832 if (res && (nch == 7)) 1833 res = (validate_name(CHILD(tree, 4), "else") 1834 && validate_colon(CHILD(tree, 5)) 1835 && validate_suite(CHILD(tree, 6))); 1836 1837 return (res); 1838} 1839 1840 1841static int 1842validate_for(node *tree) 1843{ 1844 int nch = NCH(tree); 1845 int res = (validate_ntype(tree, for_stmt) 1846 && ((nch == 6) || (nch == 9)) 1847 && validate_name(CHILD(tree, 0), "for") 1848 && validate_exprlist(CHILD(tree, 1)) 1849 && validate_name(CHILD(tree, 2), "in") 1850 && validate_testlist(CHILD(tree, 3)) 1851 && validate_colon(CHILD(tree, 4)) 1852 && validate_suite(CHILD(tree, 5))); 1853 1854 if (res && (nch == 9)) 1855 res = (validate_name(CHILD(tree, 6), "else") 1856 && validate_colon(CHILD(tree, 7)) 1857 && validate_suite(CHILD(tree, 8))); 1858 1859 return (res); 1860} 1861 1862 1863/* try_stmt: 1864 * 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite] 1865 * | 'try' ':' suite 'finally' ':' suite 1866 * 1867 */ 1868static int 1869validate_try(node *tree) 1870{ 1871 int nch = NCH(tree); 1872 int pos = 3; 1873 int res = (validate_ntype(tree, try_stmt) 1874 && (nch >= 6) && ((nch % 3) == 0)); 1875 1876 if (res) 1877 res = (validate_name(CHILD(tree, 0), "try") 1878 && validate_colon(CHILD(tree, 1)) 1879 && validate_suite(CHILD(tree, 2)) 1880 && validate_colon(CHILD(tree, nch - 2)) 1881 && validate_suite(CHILD(tree, nch - 1))); 1882 else if (!PyErr_Occurred()) { 1883 const char* name = "except"; 1884 if (TYPE(CHILD(tree, nch - 3)) != except_clause) 1885 name = STR(CHILD(tree, nch - 3)); 1886 1887 PyErr_Format(parser_error, 1888 "Illegal number of children for try/%s node.", name); 1889 } 1890 /* Skip past except_clause sections: */ 1891 while (res && (TYPE(CHILD(tree, pos)) == except_clause)) { 1892 res = (validate_except_clause(CHILD(tree, pos)) 1893 && validate_colon(CHILD(tree, pos + 1)) 1894 && validate_suite(CHILD(tree, pos + 2))); 1895 pos += 3; 1896 } 1897 if (res && (pos < nch)) { 1898 res = validate_ntype(CHILD(tree, pos), NAME); 1899 if (res && (strcmp(STR(CHILD(tree, pos)), "finally") == 0)) 1900 res = (validate_numnodes(tree, 6, "try/finally") 1901 && validate_colon(CHILD(tree, 4)) 1902 && validate_suite(CHILD(tree, 5))); 1903 else if (res) { 1904 if (nch == (pos + 3)) { 1905 res = ((strcmp(STR(CHILD(tree, pos)), "except") == 0) 1906 || (strcmp(STR(CHILD(tree, pos)), "else") == 0)); 1907 if (!res) 1908 err_string("illegal trailing triple in try statement"); 1909 } 1910 else if (nch == (pos + 6)) { 1911 res = (validate_name(CHILD(tree, pos), "except") 1912 && validate_colon(CHILD(tree, pos + 1)) 1913 && validate_suite(CHILD(tree, pos + 2)) 1914 && validate_name(CHILD(tree, pos + 3), "else")); 1915 } 1916 else 1917 res = validate_numnodes(tree, pos + 3, "try/except"); 1918 } 1919 } 1920 return (res); 1921} 1922 1923 1924static int 1925validate_except_clause(node *tree) 1926{ 1927 int nch = NCH(tree); 1928 int res = (validate_ntype(tree, except_clause) 1929 && ((nch == 1) || (nch == 2) || (nch == 4)) 1930 && validate_name(CHILD(tree, 0), "except")); 1931 1932 if (res && (nch > 1)) 1933 res = validate_test(CHILD(tree, 1)); 1934 if (res && (nch == 4)) 1935 res = (validate_name(CHILD(tree, 2), "as") 1936 && validate_ntype(CHILD(tree, 3), NAME)); 1937 1938 return (res); 1939} 1940 1941 1942static int 1943validate_test(node *tree) 1944{ 1945 int nch = NCH(tree); 1946 int res = validate_ntype(tree, test) && is_odd(nch); 1947 1948 if (res && (TYPE(CHILD(tree, 0)) == lambdef)) 1949 res = ((nch == 1) 1950 && validate_lambdef(CHILD(tree, 0))); 1951 else if (res) { 1952 res = validate_or_test(CHILD(tree, 0)); 1953 res = (res && (nch == 1 || (nch == 5 && 1954 validate_name(CHILD(tree, 1), "if") && 1955 validate_or_test(CHILD(tree, 2)) && 1956 validate_name(CHILD(tree, 3), "else") && 1957 validate_test(CHILD(tree, 4))))); 1958 } 1959 return (res); 1960} 1961 1962static int 1963validate_test_nocond(node *tree) 1964{ 1965 int nch = NCH(tree); 1966 int res = validate_ntype(tree, test_nocond) && (nch == 1); 1967 1968 if (res && (TYPE(CHILD(tree, 0)) == lambdef_nocond)) 1969 res = (validate_lambdef_nocond(CHILD(tree, 0))); 1970 else if (res) { 1971 res = (validate_or_test(CHILD(tree, 0))); 1972 } 1973 return (res); 1974} 1975 1976static int 1977validate_or_test(node *tree) 1978{ 1979 int nch = NCH(tree); 1980 int res = validate_ntype(tree, or_test) && is_odd(nch); 1981 1982 if (res) { 1983 int pos; 1984 res = validate_and_test(CHILD(tree, 0)); 1985 for (pos = 1; res && (pos < nch); pos += 2) 1986 res = (validate_name(CHILD(tree, pos), "or") 1987 && validate_and_test(CHILD(tree, pos + 1))); 1988 } 1989 return (res); 1990} 1991 1992 1993static int 1994validate_and_test(node *tree) 1995{ 1996 int pos; 1997 int nch = NCH(tree); 1998 int res = (validate_ntype(tree, and_test) 1999 && is_odd(nch) 2000 && validate_not_test(CHILD(tree, 0))); 2001 2002 for (pos = 1; res && (pos < nch); pos += 2) 2003 res = (validate_name(CHILD(tree, pos), "and") 2004 && validate_not_test(CHILD(tree, 0))); 2005 2006 return (res); 2007} 2008 2009 2010static int 2011validate_not_test(node *tree) 2012{ 2013 int nch = NCH(tree); 2014 int res = validate_ntype(tree, not_test) && ((nch == 1) || (nch == 2)); 2015 2016 if (res) { 2017 if (nch == 2) 2018 res = (validate_name(CHILD(tree, 0), "not") 2019 && validate_not_test(CHILD(tree, 1))); 2020 else if (nch == 1) 2021 res = validate_comparison(CHILD(tree, 0)); 2022 } 2023 return (res); 2024} 2025 2026 2027static int 2028validate_comparison(node *tree) 2029{ 2030 int pos; 2031 int nch = NCH(tree); 2032 int res = (validate_ntype(tree, comparison) 2033 && is_odd(nch) 2034 && validate_star_expr(CHILD(tree, 0))); 2035 2036 for (pos = 1; res && (pos < nch); pos += 2) 2037 res = (validate_comp_op(CHILD(tree, pos)) 2038 && validate_star_expr(CHILD(tree, pos + 1))); 2039 2040 return (res); 2041} 2042 2043 2044static int 2045validate_comp_op(node *tree) 2046{ 2047 int res = 0; 2048 int nch = NCH(tree); 2049 2050 if (!validate_ntype(tree, comp_op)) 2051 return (0); 2052 if (nch == 1) { 2053 /* 2054 * Only child will be a terminal with a well-defined symbolic name 2055 * or a NAME with a string of either 'is' or 'in' 2056 */ 2057 tree = CHILD(tree, 0); 2058 switch (TYPE(tree)) { 2059 case LESS: 2060 case GREATER: 2061 case EQEQUAL: 2062 case EQUAL: 2063 case LESSEQUAL: 2064 case GREATEREQUAL: 2065 case NOTEQUAL: 2066 res = 1; 2067 break; 2068 case NAME: 2069 res = ((strcmp(STR(tree), "in") == 0) 2070 || (strcmp(STR(tree), "is") == 0)); 2071 if (!res) { 2072 PyErr_Format(parser_error, 2073 "illegal operator '%s'", STR(tree)); 2074 } 2075 break; 2076 default: 2077 err_string("illegal comparison operator type"); 2078 break; 2079 } 2080 } 2081 else if ((res = validate_numnodes(tree, 2, "comp_op")) != 0) { 2082 res = (validate_ntype(CHILD(tree, 0), NAME) 2083 && validate_ntype(CHILD(tree, 1), NAME) 2084 && (((strcmp(STR(CHILD(tree, 0)), "is") == 0) 2085 && (strcmp(STR(CHILD(tree, 1)), "not") == 0)) 2086 || ((strcmp(STR(CHILD(tree, 0)), "not") == 0) 2087 && (strcmp(STR(CHILD(tree, 1)), "in") == 0)))); 2088 if (!res && !PyErr_Occurred()) 2089 err_string("unknown comparison operator"); 2090 } 2091 return (res); 2092} 2093 2094 2095static int 2096validate_star_expr(node *tree) 2097{ 2098 int res = validate_ntype(tree, star_expr); 2099 if (!res) return res; 2100 if (NCH(tree) == 2) { 2101 return validate_ntype(CHILD(tree, 0), STAR) && \ 2102 validate_expr(CHILD(tree, 1)); 2103 } else { 2104 return validate_expr(CHILD(tree, 0)); 2105 } 2106} 2107 2108 2109static int 2110validate_expr(node *tree) 2111{ 2112 int j; 2113 int nch = NCH(tree); 2114 int res = (validate_ntype(tree, expr) 2115 && is_odd(nch) 2116 && validate_xor_expr(CHILD(tree, 0))); 2117 2118 for (j = 2; res && (j < nch); j += 2) 2119 res = (validate_xor_expr(CHILD(tree, j)) 2120 && validate_vbar(CHILD(tree, j - 1))); 2121 2122 return (res); 2123} 2124 2125 2126static int 2127validate_xor_expr(node *tree) 2128{ 2129 int j; 2130 int nch = NCH(tree); 2131 int res = (validate_ntype(tree, xor_expr) 2132 && is_odd(nch) 2133 && validate_and_expr(CHILD(tree, 0))); 2134 2135 for (j = 2; res && (j < nch); j += 2) 2136 res = (validate_circumflex(CHILD(tree, j - 1)) 2137 && validate_and_expr(CHILD(tree, j))); 2138 2139 return (res); 2140} 2141 2142 2143static int 2144validate_and_expr(node *tree) 2145{ 2146 int pos; 2147 int nch = NCH(tree); 2148 int res = (validate_ntype(tree, and_expr) 2149 && is_odd(nch) 2150 && validate_shift_expr(CHILD(tree, 0))); 2151 2152 for (pos = 1; res && (pos < nch); pos += 2) 2153 res = (validate_ampersand(CHILD(tree, pos)) 2154 && validate_shift_expr(CHILD(tree, pos + 1))); 2155 2156 return (res); 2157} 2158 2159 2160static int 2161validate_chain_two_ops(node *tree, int (*termvalid)(node *), int op1, int op2) 2162 { 2163 int pos = 1; 2164 int nch = NCH(tree); 2165 int res = (is_odd(nch) 2166 && (*termvalid)(CHILD(tree, 0))); 2167 2168 for ( ; res && (pos < nch); pos += 2) { 2169 if (TYPE(CHILD(tree, pos)) != op1) 2170 res = validate_ntype(CHILD(tree, pos), op2); 2171 if (res) 2172 res = (*termvalid)(CHILD(tree, pos + 1)); 2173 } 2174 return (res); 2175} 2176 2177 2178static int 2179validate_shift_expr(node *tree) 2180{ 2181 return (validate_ntype(tree, shift_expr) 2182 && validate_chain_two_ops(tree, validate_arith_expr, 2183 LEFTSHIFT, RIGHTSHIFT)); 2184} 2185 2186 2187static int 2188validate_arith_expr(node *tree) 2189{ 2190 return (validate_ntype(tree, arith_expr) 2191 && validate_chain_two_ops(tree, validate_term, PLUS, MINUS)); 2192} 2193 2194 2195static int 2196validate_term(node *tree) 2197{ 2198 int pos = 1; 2199 int nch = NCH(tree); 2200 int res = (validate_ntype(tree, term) 2201 && is_odd(nch) 2202 && validate_factor(CHILD(tree, 0))); 2203 2204 for ( ; res && (pos < nch); pos += 2) 2205 res = (((TYPE(CHILD(tree, pos)) == STAR) 2206 || (TYPE(CHILD(tree, pos)) == SLASH) 2207 || (TYPE(CHILD(tree, pos)) == DOUBLESLASH) 2208 || (TYPE(CHILD(tree, pos)) == PERCENT)) 2209 && validate_factor(CHILD(tree, pos + 1))); 2210 2211 return (res); 2212} 2213 2214 2215/* factor: 2216 * 2217 * factor: ('+'|'-'|'~') factor | power 2218 */ 2219static int 2220validate_factor(node *tree) 2221{ 2222 int nch = NCH(tree); 2223 int res = (validate_ntype(tree, factor) 2224 && (((nch == 2) 2225 && ((TYPE(CHILD(tree, 0)) == PLUS) 2226 || (TYPE(CHILD(tree, 0)) == MINUS) 2227 || (TYPE(CHILD(tree, 0)) == TILDE)) 2228 && validate_factor(CHILD(tree, 1))) 2229 || ((nch == 1) 2230 && validate_power(CHILD(tree, 0))))); 2231 return (res); 2232} 2233 2234 2235/* power: 2236 * 2237 * power: atom trailer* ('**' factor)* 2238 */ 2239static int 2240validate_power(node *tree) 2241{ 2242 int pos = 1; 2243 int nch = NCH(tree); 2244 int res = (validate_ntype(tree, power) && (nch >= 1) 2245 && validate_atom(CHILD(tree, 0))); 2246 2247 while (res && (pos < nch) && (TYPE(CHILD(tree, pos)) == trailer)) 2248 res = validate_trailer(CHILD(tree, pos++)); 2249 if (res && (pos < nch)) { 2250 if (!is_even(nch - pos)) { 2251 err_string("illegal number of nodes for 'power'"); 2252 return (0); 2253 } 2254 for ( ; res && (pos < (nch - 1)); pos += 2) 2255 res = (validate_doublestar(CHILD(tree, pos)) 2256 && validate_factor(CHILD(tree, pos + 1))); 2257 } 2258 return (res); 2259} 2260 2261 2262static int 2263validate_atom(node *tree) 2264{ 2265 int pos; 2266 int nch = NCH(tree); 2267 int res = validate_ntype(tree, atom); 2268 2269 if (res && nch < 1) 2270 res = validate_numnodes(tree, nch+1, "atom"); 2271 if (res) { 2272 switch (TYPE(CHILD(tree, 0))) { 2273 case LPAR: 2274 res = ((nch <= 3) 2275 && (validate_rparen(CHILD(tree, nch - 1)))); 2276 2277 if (res && (nch == 3)) { 2278 if (TYPE(CHILD(tree, 1))==yield_expr) 2279 res = validate_yield_expr(CHILD(tree, 1)); 2280 else 2281 res = validate_testlist_comp(CHILD(tree, 1)); 2282 } 2283 break; 2284 case LSQB: 2285 if (nch == 2) 2286 res = validate_ntype(CHILD(tree, 1), RSQB); 2287 else if (nch == 3) 2288 res = (validate_testlist_comp(CHILD(tree, 1)) 2289 && validate_ntype(CHILD(tree, 2), RSQB)); 2290 else { 2291 res = 0; 2292 err_string("illegal list display atom"); 2293 } 2294 break; 2295 case LBRACE: 2296 res = ((nch <= 3) 2297 && validate_ntype(CHILD(tree, nch - 1), RBRACE)); 2298 2299 if (res && (nch == 3)) 2300 res = validate_dictorsetmaker(CHILD(tree, 1)); 2301 break; 2302 case NAME: 2303 case NUMBER: 2304 res = (nch == 1); 2305 break; 2306 case STRING: 2307 for (pos = 1; res && (pos < nch); ++pos) 2308 res = validate_ntype(CHILD(tree, pos), STRING); 2309 break; 2310 case DOT: 2311 res = (nch == 3 && 2312 validate_ntype(CHILD(tree, 1), DOT) && 2313 validate_ntype(CHILD(tree, 2), DOT)); 2314 break; 2315 default: 2316 res = 0; 2317 break; 2318 } 2319 } 2320 return (res); 2321} 2322 2323 2324/* testlist_comp: 2325 * test ( comp_for | (',' test)* [','] ) 2326 */ 2327static int 2328validate_testlist_comp(node *tree) 2329{ 2330 int nch = NCH(tree); 2331 int ok = nch; 2332 2333 if (nch == 0) 2334 err_string("missing child nodes of testlist_comp"); 2335 else { 2336 ok = validate_test(CHILD(tree, 0)); 2337 } 2338 2339 /* 2340 * comp_for | (',' test)* [','] 2341 */ 2342 if (nch == 2 && TYPE(CHILD(tree, 1)) == comp_for) 2343 ok = validate_comp_for(CHILD(tree, 1)); 2344 else { 2345 /* (',' test)* [','] */ 2346 int i = 1; 2347 while (ok && nch - i >= 2) { 2348 ok = (validate_comma(CHILD(tree, i)) 2349 && validate_test(CHILD(tree, i+1))); 2350 i += 2; 2351 } 2352 if (ok && i == nch-1) 2353 ok = validate_comma(CHILD(tree, i)); 2354 else if (i != nch) { 2355 ok = 0; 2356 err_string("illegal trailing nodes for testlist_comp"); 2357 } 2358 } 2359 return ok; 2360} 2361 2362/* decorator: 2363 * '@' dotted_name [ '(' [arglist] ')' ] NEWLINE 2364 */ 2365static int 2366validate_decorator(node *tree) 2367{ 2368 int ok; 2369 int nch = NCH(tree); 2370 ok = (validate_ntype(tree, decorator) && 2371 (nch == 3 || nch == 5 || nch == 6) && 2372 validate_at(CHILD(tree, 0)) && 2373 validate_dotted_name(CHILD(tree, 1)) && 2374 validate_newline(RCHILD(tree, -1))); 2375 2376 if (ok && nch != 3) { 2377 ok = (validate_lparen(CHILD(tree, 2)) && 2378 validate_rparen(RCHILD(tree, -2))); 2379 2380 if (ok && nch == 6) 2381 ok = validate_arglist(CHILD(tree, 3)); 2382 } 2383 2384 return ok; 2385} 2386 2387/* decorators: 2388 * decorator+ 2389 */ 2390static int 2391validate_decorators(node *tree) 2392{ 2393 int i, nch, ok; 2394 nch = NCH(tree); 2395 ok = validate_ntype(tree, decorators) && nch >= 1; 2396 2397 for (i = 0; ok && i < nch; ++i) 2398 ok = validate_decorator(CHILD(tree, i)); 2399 2400 return ok; 2401} 2402 2403/* with_var 2404with_var: 'as' expr 2405 */ 2406static int 2407validate_with_var(node *tree) 2408{ 2409 int nch = NCH(tree); 2410 int ok = (validate_ntype(tree, with_var) 2411 && (nch == 2) 2412 && validate_name(CHILD(tree, 0), "as") 2413 && validate_expr(CHILD(tree, 1))); 2414 return ok; 2415} 2416 2417/* with_stmt 2418 * 0 1 2 -2 -1 2419with_stmt: 'with' test [ with_var ] ':' suite 2420 */ 2421static int 2422validate_with_stmt(node *tree) 2423{ 2424 int nch = NCH(tree); 2425 int ok = (validate_ntype(tree, with_stmt) 2426 && ((nch == 4) || (nch == 5)) 2427 && validate_name(CHILD(tree, 0), "with") 2428 && validate_test(CHILD(tree, 1)) 2429 && (nch == 4 || validate_with_var(CHILD(tree, 2))) 2430 && validate_colon(RCHILD(tree, -2)) 2431 && validate_suite(RCHILD(tree, -1))); 2432 return ok; 2433} 2434 2435/* funcdef: 2436 * 2437 * -5 -4 -3 -2 -1 2438 * 'def' NAME parameters ':' suite 2439 */ 2440static int 2441validate_funcdef(node *tree) 2442{ 2443 int nch = NCH(tree); 2444 int ok = (validate_ntype(tree, funcdef) 2445 && (nch == 5) 2446 && validate_name(RCHILD(tree, -5), "def") 2447 && validate_ntype(RCHILD(tree, -4), NAME) 2448 && validate_colon(RCHILD(tree, -2)) 2449 && validate_parameters(RCHILD(tree, -3)) 2450 && validate_suite(RCHILD(tree, -1))); 2451 return ok; 2452} 2453 2454 2455/* decorated 2456 * decorators (classdef | funcdef) 2457 */ 2458static int 2459validate_decorated(node *tree) 2460{ 2461 int nch = NCH(tree); 2462 int ok = (validate_ntype(tree, decorated) 2463 && (nch == 2) 2464 && validate_decorators(RCHILD(tree, -2)) 2465 && (validate_funcdef(RCHILD(tree, -1)) 2466 || validate_class(RCHILD(tree, -1))) 2467 ); 2468 return ok; 2469} 2470 2471static int 2472validate_lambdef(node *tree) 2473{ 2474 int nch = NCH(tree); 2475 int res = (validate_ntype(tree, lambdef) 2476 && ((nch == 3) || (nch == 4)) 2477 && validate_name(CHILD(tree, 0), "lambda") 2478 && validate_colon(CHILD(tree, nch - 2)) 2479 && validate_test(CHILD(tree, nch - 1))); 2480 2481 if (res && (nch == 4)) 2482 res = validate_varargslist(CHILD(tree, 1)); 2483 else if (!res && !PyErr_Occurred()) 2484 (void) validate_numnodes(tree, 3, "lambdef"); 2485 2486 return (res); 2487} 2488 2489 2490static int 2491validate_lambdef_nocond(node *tree) 2492{ 2493 int nch = NCH(tree); 2494 int res = (validate_ntype(tree, lambdef_nocond) 2495 && ((nch == 3) || (nch == 4)) 2496 && validate_name(CHILD(tree, 0), "lambda") 2497 && validate_colon(CHILD(tree, nch - 2)) 2498 && validate_test(CHILD(tree, nch - 1))); 2499 2500 if (res && (nch == 4)) 2501 res = validate_varargslist(CHILD(tree, 1)); 2502 else if (!res && !PyErr_Occurred()) 2503 (void) validate_numnodes(tree, 3, "lambdef_nocond"); 2504 2505 return (res); 2506} 2507 2508 2509/* arglist: 2510 * 2511 * (argument ',')* (argument [','] | '*' test [',' '**' test] | '**' test) 2512 */ 2513static int 2514validate_arglist(node *tree) 2515{ 2516 int nch = NCH(tree); 2517 int i = 0; 2518 int ok = 1; 2519 2520 if (nch <= 0) 2521 /* raise the right error from having an invalid number of children */ 2522 return validate_numnodes(tree, nch + 1, "arglist"); 2523 2524 if (nch > 1) { 2525 for (i=0; i<nch; i++) { 2526 if (TYPE(CHILD(tree, i)) == argument) { 2527 node *ch = CHILD(tree, i); 2528 if (NCH(ch) == 2 && TYPE(CHILD(ch, 1)) == comp_for) { 2529 err_string("need '(', ')' for generator expression"); 2530 return 0; 2531 } 2532 } 2533 } 2534 } 2535 2536 while (ok && nch-i >= 2) { 2537 /* skip leading (argument ',') */ 2538 ok = (validate_argument(CHILD(tree, i)) 2539 && validate_comma(CHILD(tree, i+1))); 2540 if (ok) 2541 i += 2; 2542 else 2543 PyErr_Clear(); 2544 } 2545 ok = 1; 2546 if (nch-i > 0) { 2547 /* 2548 * argument | '*' test [',' '**' test] | '**' test 2549 */ 2550 int sym = TYPE(CHILD(tree, i)); 2551 2552 if (sym == argument) { 2553 ok = validate_argument(CHILD(tree, i)); 2554 if (ok && i+1 != nch) { 2555 err_string("illegal arglist specification" 2556 " (extra stuff on end)"); 2557 ok = 0; 2558 } 2559 } 2560 else if (sym == STAR) { 2561 ok = validate_star(CHILD(tree, i)); 2562 if (ok && (nch-i == 2)) 2563 ok = validate_test(CHILD(tree, i+1)); 2564 else if (ok && (nch-i == 5)) 2565 ok = (validate_test(CHILD(tree, i+1)) 2566 && validate_comma(CHILD(tree, i+2)) 2567 && validate_doublestar(CHILD(tree, i+3)) 2568 && validate_test(CHILD(tree, i+4))); 2569 else { 2570 err_string("illegal use of '*' in arglist"); 2571 ok = 0; 2572 } 2573 } 2574 else if (sym == DOUBLESTAR) { 2575 if (nch-i == 2) 2576 ok = (validate_doublestar(CHILD(tree, i)) 2577 && validate_test(CHILD(tree, i+1))); 2578 else { 2579 err_string("illegal use of '**' in arglist"); 2580 ok = 0; 2581 } 2582 } 2583 else { 2584 err_string("illegal arglist specification"); 2585 ok = 0; 2586 } 2587 } 2588 return (ok); 2589} 2590 2591 2592 2593/* argument: 2594 * 2595 * [test '='] test [comp_for] 2596 */ 2597static int 2598validate_argument(node *tree) 2599{ 2600 int nch = NCH(tree); 2601 int res = (validate_ntype(tree, argument) 2602 && ((nch == 1) || (nch == 2) || (nch == 3)) 2603 && validate_test(CHILD(tree, 0))); 2604 2605 if (res && (nch == 2)) 2606 res = validate_comp_for(CHILD(tree, 1)); 2607 else if (res && (nch == 3)) 2608 res = (validate_equal(CHILD(tree, 1)) 2609 && validate_test(CHILD(tree, 2))); 2610 2611 return (res); 2612} 2613 2614 2615 2616/* trailer: 2617 * 2618 * '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME 2619 */ 2620static int 2621validate_trailer(node *tree) 2622{ 2623 int nch = NCH(tree); 2624 int res = validate_ntype(tree, trailer) && ((nch == 2) || (nch == 3)); 2625 2626 if (res) { 2627 switch (TYPE(CHILD(tree, 0))) { 2628 case LPAR: 2629 res = validate_rparen(CHILD(tree, nch - 1)); 2630 if (res && (nch == 3)) 2631 res = validate_arglist(CHILD(tree, 1)); 2632 break; 2633 case LSQB: 2634 res = (validate_numnodes(tree, 3, "trailer") 2635 && validate_subscriptlist(CHILD(tree, 1)) 2636 && validate_ntype(CHILD(tree, 2), RSQB)); 2637 break; 2638 case DOT: 2639 res = (validate_numnodes(tree, 2, "trailer") 2640 && validate_ntype(CHILD(tree, 1), NAME)); 2641 break; 2642 default: 2643 res = 0; 2644 break; 2645 } 2646 } 2647 else { 2648 (void) validate_numnodes(tree, 2, "trailer"); 2649 } 2650 return (res); 2651} 2652 2653 2654/* subscriptlist: 2655 * 2656 * subscript (',' subscript)* [','] 2657 */ 2658static int 2659validate_subscriptlist(node *tree) 2660{ 2661 return (validate_repeating_list(tree, subscriptlist, 2662 validate_subscript, "subscriptlist")); 2663} 2664 2665 2666/* subscript: 2667 * 2668 * '.' '.' '.' | test | [test] ':' [test] [sliceop] 2669 */ 2670static int 2671validate_subscript(node *tree) 2672{ 2673 int offset = 0; 2674 int nch = NCH(tree); 2675 int res = validate_ntype(tree, subscript) && (nch >= 1) && (nch <= 4); 2676 2677 if (!res) { 2678 if (!PyErr_Occurred()) 2679 err_string("invalid number of arguments for subscript node"); 2680 return (0); 2681 } 2682 if (TYPE(CHILD(tree, 0)) == DOT) 2683 /* take care of ('.' '.' '.') possibility */ 2684 return (validate_numnodes(tree, 3, "subscript") 2685 && validate_dot(CHILD(tree, 0)) 2686 && validate_dot(CHILD(tree, 1)) 2687 && validate_dot(CHILD(tree, 2))); 2688 if (nch == 1) { 2689 if (TYPE(CHILD(tree, 0)) == test) 2690 res = validate_test(CHILD(tree, 0)); 2691 else 2692 res = validate_colon(CHILD(tree, 0)); 2693 return (res); 2694 } 2695 /* Must be [test] ':' [test] [sliceop], 2696 * but at least one of the optional components will 2697 * be present, but we don't know which yet. 2698 */ 2699 if ((TYPE(CHILD(tree, 0)) != COLON) || (nch == 4)) { 2700 res = validate_test(CHILD(tree, 0)); 2701 offset = 1; 2702 } 2703 if (res) 2704 res = validate_colon(CHILD(tree, offset)); 2705 if (res) { 2706 int rem = nch - ++offset; 2707 if (rem) { 2708 if (TYPE(CHILD(tree, offset)) == test) { 2709 res = validate_test(CHILD(tree, offset)); 2710 ++offset; 2711 --rem; 2712 } 2713 if (res && rem) 2714 res = validate_sliceop(CHILD(tree, offset)); 2715 } 2716 } 2717 return (res); 2718} 2719 2720 2721static int 2722validate_sliceop(node *tree) 2723{ 2724 int nch = NCH(tree); 2725 int res = ((nch == 1) || validate_numnodes(tree, 2, "sliceop")) 2726 && validate_ntype(tree, sliceop); 2727 if (!res && !PyErr_Occurred()) { 2728 res = validate_numnodes(tree, 1, "sliceop"); 2729 } 2730 if (res) 2731 res = validate_colon(CHILD(tree, 0)); 2732 if (res && (nch == 2)) 2733 res = validate_test(CHILD(tree, 1)); 2734 2735 return (res); 2736} 2737 2738 2739static int 2740validate_exprlist(node *tree) 2741{ 2742 return (validate_repeating_list(tree, exprlist, 2743 validate_star_expr, "exprlist")); 2744} 2745 2746 2747static int 2748validate_dictorsetmaker(node *tree) 2749{ 2750 int nch = NCH(tree); 2751 int res = (validate_ntype(tree, dictorsetmaker) 2752 && (nch >= 3) 2753 && validate_test(CHILD(tree, 0)) 2754 && validate_colon(CHILD(tree, 1)) 2755 && validate_test(CHILD(tree, 2))); 2756 2757 if (res && ((nch % 4) == 0)) 2758 res = validate_comma(CHILD(tree, --nch)); 2759 else if (res) 2760 res = ((nch % 4) == 3); 2761 2762 if (res && (nch > 3)) { 2763 int pos = 3; 2764 /* ( ',' test ':' test )* */ 2765 while (res && (pos < nch)) { 2766 res = (validate_comma(CHILD(tree, pos)) 2767 && validate_test(CHILD(tree, pos + 1)) 2768 && validate_colon(CHILD(tree, pos + 2)) 2769 && validate_test(CHILD(tree, pos + 3))); 2770 pos += 4; 2771 } 2772 } 2773 return (res); 2774} 2775 2776 2777static int 2778validate_eval_input(node *tree) 2779{ 2780 int pos; 2781 int nch = NCH(tree); 2782 int res = (validate_ntype(tree, eval_input) 2783 && (nch >= 2) 2784 && validate_testlist(CHILD(tree, 0)) 2785 && validate_ntype(CHILD(tree, nch - 1), ENDMARKER)); 2786 2787 for (pos = 1; res && (pos < (nch - 1)); ++pos) 2788 res = validate_ntype(CHILD(tree, pos), NEWLINE); 2789 2790 return (res); 2791} 2792 2793 2794static int 2795validate_node(node *tree) 2796{ 2797 int nch = 0; /* num. children on current node */ 2798 int res = 1; /* result value */ 2799 node* next = 0; /* node to process after this one */ 2800 2801 while (res && (tree != 0)) { 2802 nch = NCH(tree); 2803 next = 0; 2804 switch (TYPE(tree)) { 2805 /* 2806 * Definition nodes. 2807 */ 2808 case funcdef: 2809 res = validate_funcdef(tree); 2810 break; 2811 case with_stmt: 2812 res = validate_with_stmt(tree); 2813 break; 2814 case classdef: 2815 res = validate_class(tree); 2816 break; 2817 case decorated: 2818 res = validate_decorated(tree); 2819 break; 2820 /* 2821 * "Trivial" parse tree nodes. 2822 * (Why did I call these trivial?) 2823 */ 2824 case stmt: 2825 res = validate_stmt(tree); 2826 break; 2827 case small_stmt: 2828 /* 2829 * expr_stmt | del_stmt | pass_stmt | flow_stmt 2830 * | import_stmt | global_stmt | assert_stmt 2831 */ 2832 res = validate_small_stmt(tree); 2833 break; 2834 case flow_stmt: 2835 res = (validate_numnodes(tree, 1, "flow_stmt") 2836 && ((TYPE(CHILD(tree, 0)) == break_stmt) 2837 || (TYPE(CHILD(tree, 0)) == continue_stmt) 2838 || (TYPE(CHILD(tree, 0)) == yield_stmt) 2839 || (TYPE(CHILD(tree, 0)) == return_stmt) 2840 || (TYPE(CHILD(tree, 0)) == raise_stmt))); 2841 if (res) 2842 next = CHILD(tree, 0); 2843 else if (nch == 1) 2844 err_string("illegal flow_stmt type"); 2845 break; 2846 case yield_stmt: 2847 res = validate_yield_stmt(tree); 2848 break; 2849 /* 2850 * Compound statements. 2851 */ 2852 case simple_stmt: 2853 res = validate_simple_stmt(tree); 2854 break; 2855 case compound_stmt: 2856 res = validate_compound_stmt(tree); 2857 break; 2858 /* 2859 * Fundamental statements. 2860 */ 2861 case expr_stmt: 2862 res = validate_expr_stmt(tree); 2863 break; 2864 case del_stmt: 2865 res = validate_del_stmt(tree); 2866 break; 2867 case pass_stmt: 2868 res = (validate_numnodes(tree, 1, "pass") 2869 && validate_name(CHILD(tree, 0), "pass")); 2870 break; 2871 case break_stmt: 2872 res = (validate_numnodes(tree, 1, "break") 2873 && validate_name(CHILD(tree, 0), "break")); 2874 break; 2875 case continue_stmt: 2876 res = (validate_numnodes(tree, 1, "continue") 2877 && validate_name(CHILD(tree, 0), "continue")); 2878 break; 2879 case return_stmt: 2880 res = validate_return_stmt(tree); 2881 break; 2882 case raise_stmt: 2883 res = validate_raise_stmt(tree); 2884 break; 2885 case import_stmt: 2886 res = validate_import_stmt(tree); 2887 break; 2888 case import_name: 2889 res = validate_import_name(tree); 2890 break; 2891 case import_from: 2892 res = validate_import_from(tree); 2893 break; 2894 case global_stmt: 2895 res = validate_global_stmt(tree); 2896 break; 2897 case assert_stmt: 2898 res = validate_assert_stmt(tree); 2899 break; 2900 case if_stmt: 2901 res = validate_if(tree); 2902 break; 2903 case while_stmt: 2904 res = validate_while(tree); 2905 break; 2906 case for_stmt: 2907 res = validate_for(tree); 2908 break; 2909 case try_stmt: 2910 res = validate_try(tree); 2911 break; 2912 case suite: 2913 res = validate_suite(tree); 2914 break; 2915 /* 2916 * Expression nodes. 2917 */ 2918 case testlist: 2919 res = validate_testlist(tree); 2920 break; 2921 case yield_expr: 2922 res = validate_yield_expr(tree); 2923 break; 2924 case testlist1: 2925 res = validate_testlist1(tree); 2926 break; 2927 case test: 2928 res = validate_test(tree); 2929 break; 2930 case and_test: 2931 res = validate_and_test(tree); 2932 break; 2933 case not_test: 2934 res = validate_not_test(tree); 2935 break; 2936 case comparison: 2937 res = validate_comparison(tree); 2938 break; 2939 case exprlist: 2940 res = validate_exprlist(tree); 2941 break; 2942 case comp_op: 2943 res = validate_comp_op(tree); 2944 break; 2945 case expr: 2946 res = validate_expr(tree); 2947 break; 2948 case xor_expr: 2949 res = validate_xor_expr(tree); 2950 break; 2951 case and_expr: 2952 res = validate_and_expr(tree); 2953 break; 2954 case shift_expr: 2955 res = validate_shift_expr(tree); 2956 break; 2957 case arith_expr: 2958 res = validate_arith_expr(tree); 2959 break; 2960 case term: 2961 res = validate_term(tree); 2962 break; 2963 case factor: 2964 res = validate_factor(tree); 2965 break; 2966 case power: 2967 res = validate_power(tree); 2968 break; 2969 case atom: 2970 res = validate_atom(tree); 2971 break; 2972 2973 default: 2974 /* Hopefully never reached! */ 2975 err_string("unrecognized node type"); 2976 res = 0; 2977 break; 2978 } 2979 tree = next; 2980 } 2981 return (res); 2982} 2983 2984 2985static int 2986validate_expr_tree(node *tree) 2987{ 2988 int res = validate_eval_input(tree); 2989 2990 if (!res && !PyErr_Occurred()) 2991 err_string("could not validate expression tuple"); 2992 2993 return (res); 2994} 2995 2996 2997/* file_input: 2998 * (NEWLINE | stmt)* ENDMARKER 2999 */ 3000static int 3001validate_file_input(node *tree) 3002{ 3003 int j; 3004 int nch = NCH(tree) - 1; 3005 int res = ((nch >= 0) 3006 && validate_ntype(CHILD(tree, nch), ENDMARKER)); 3007 3008 for (j = 0; res && (j < nch); ++j) { 3009 if (TYPE(CHILD(tree, j)) == stmt) 3010 res = validate_stmt(CHILD(tree, j)); 3011 else 3012 res = validate_newline(CHILD(tree, j)); 3013 } 3014 /* This stays in to prevent any internal failures from getting to the 3015 * user. Hopefully, this won't be needed. If a user reports getting 3016 * this, we have some debugging to do. 3017 */ 3018 if (!res && !PyErr_Occurred()) 3019 err_string("VALIDATION FAILURE: report this to the maintainer!"); 3020 3021 return (res); 3022} 3023 3024static int 3025validate_encoding_decl(node *tree) 3026{ 3027 int nch = NCH(tree); 3028 int res = ((nch == 1) 3029 && validate_file_input(CHILD(tree, 0))); 3030 3031 if (!res && !PyErr_Occurred()) 3032 err_string("Error Parsing encoding_decl"); 3033 3034 return res; 3035} 3036 3037static PyObject* 3038pickle_constructor = NULL; 3039 3040 3041static PyObject* 3042parser__pickler(PyObject *self, PyObject *args) 3043{ 3044 NOTE(ARGUNUSED(self)) 3045 PyObject *result = NULL; 3046 PyObject *st = NULL; 3047 PyObject *empty_dict = NULL; 3048 3049 if (PyArg_ParseTuple(args, "O!:_pickler", &PyST_Type, &st)) { 3050 PyObject *newargs; 3051 PyObject *tuple; 3052 3053 if ((empty_dict = PyDict_New()) == NULL) 3054 goto finally; 3055 if ((newargs = Py_BuildValue("Oi", st, 1)) == NULL) 3056 goto finally; 3057 tuple = parser_st2tuple((PyST_Object*)NULL, newargs, empty_dict); 3058 if (tuple != NULL) { 3059 result = Py_BuildValue("O(O)", pickle_constructor, tuple); 3060 Py_DECREF(tuple); 3061 } 3062 Py_DECREF(empty_dict); 3063 Py_DECREF(newargs); 3064 } 3065 finally: 3066 Py_XDECREF(empty_dict); 3067 3068 return (result); 3069} 3070 3071 3072/* Functions exported by this module. Most of this should probably 3073 * be converted into an ST object with methods, but that is better 3074 * done directly in Python, allowing subclasses to be created directly. 3075 * We'd really have to write a wrapper around it all anyway to allow 3076 * inheritance. 3077 */ 3078static PyMethodDef parser_functions[] = { 3079 {"compilest", (PyCFunction)parser_compilest, PUBLIC_METHOD_TYPE, 3080 PyDoc_STR("Compiles an ST object into a code object.")}, 3081 {"expr", (PyCFunction)parser_expr, PUBLIC_METHOD_TYPE, 3082 PyDoc_STR("Creates an ST object from an expression.")}, 3083 {"isexpr", (PyCFunction)parser_isexpr, PUBLIC_METHOD_TYPE, 3084 PyDoc_STR("Determines if an ST object was created from an expression.")}, 3085 {"issuite", (PyCFunction)parser_issuite, PUBLIC_METHOD_TYPE, 3086 PyDoc_STR("Determines if an ST object was created from a suite.")}, 3087 {"suite", (PyCFunction)parser_suite, PUBLIC_METHOD_TYPE, 3088 PyDoc_STR("Creates an ST object from a suite.")}, 3089 {"sequence2st", (PyCFunction)parser_tuple2st, PUBLIC_METHOD_TYPE, 3090 PyDoc_STR("Creates an ST object from a tree representation.")}, 3091 {"st2tuple", (PyCFunction)parser_st2tuple, PUBLIC_METHOD_TYPE, 3092 PyDoc_STR("Creates a tuple-tree representation of an ST.")}, 3093 {"st2list", (PyCFunction)parser_st2list, PUBLIC_METHOD_TYPE, 3094 PyDoc_STR("Creates a list-tree representation of an ST.")}, 3095 {"tuple2st", (PyCFunction)parser_tuple2st, PUBLIC_METHOD_TYPE, 3096 PyDoc_STR("Creates an ST object from a tree representation.")}, 3097 3098 /* private stuff: support pickle module */ 3099 {"_pickler", (PyCFunction)parser__pickler, METH_VARARGS, 3100 PyDoc_STR("Returns the pickle magic to allow ST objects to be pickled.")}, 3101 3102 {NULL, NULL, 0, NULL} 3103 }; 3104 3105 3106 3107static struct PyModuleDef parsermodule = { 3108 PyModuleDef_HEAD_INIT, 3109 "parser", 3110 NULL, 3111 -1, 3112 parser_functions, 3113 NULL, 3114 NULL, 3115 NULL, 3116 NULL 3117}; 3118 3119PyMODINIT_FUNC PyInit_parser(void); /* supply a prototype */ 3120 3121PyMODINIT_FUNC 3122PyInit_parser(void) 3123{ 3124 PyObject *module, *copyreg; 3125 3126 if (PyType_Ready(&PyST_Type) < 0) 3127 return NULL; 3128 module = PyModule_Create(&parsermodule); 3129 if (module == NULL) 3130 return NULL; 3131 3132 if (parser_error == 0) 3133 parser_error = PyErr_NewException("parser.ParserError", NULL, NULL); 3134 3135 if (parser_error == 0) 3136 return NULL; 3137 /* CAUTION: The code next used to skip bumping the refcount on 3138 * parser_error. That's a disaster if PyInit_parser() gets called more 3139 * than once. By incref'ing, we ensure that each module dict that 3140 * gets created owns its reference to the shared parser_error object, 3141 * and the file static parser_error vrbl owns a reference too. 3142 */ 3143 Py_INCREF(parser_error); 3144 if (PyModule_AddObject(module, "ParserError", parser_error) != 0) 3145 return NULL; 3146 3147 Py_INCREF(&PyST_Type); 3148 PyModule_AddObject(module, "STType", (PyObject*)&PyST_Type); 3149 3150 PyModule_AddStringConstant(module, "__copyright__", 3151 parser_copyright_string); 3152 PyModule_AddStringConstant(module, "__doc__", 3153 parser_doc_string); 3154 PyModule_AddStringConstant(module, "__version__", 3155 parser_version_string); 3156 3157 /* Register to support pickling. 3158 * If this fails, the import of this module will fail because an 3159 * exception will be raised here; should we clear the exception? 3160 */ 3161 copyreg = PyImport_ImportModuleNoBlock("copyreg"); 3162 if (copyreg != NULL) { 3163 PyObject *func, *pickler; 3164 3165 func = PyObject_GetAttrString(copyreg, "pickle"); 3166 pickle_constructor = PyObject_GetAttrString(module, "sequence2st"); 3167 pickler = PyObject_GetAttrString(module, "_pickler"); 3168 Py_XINCREF(pickle_constructor); 3169 if ((func != NULL) && (pickle_constructor != NULL) 3170 && (pickler != NULL)) { 3171 PyObject *res; 3172 3173 res = PyObject_CallFunctionObjArgs(func, &PyST_Type, pickler, 3174 pickle_constructor, NULL); 3175 Py_XDECREF(res); 3176 } 3177 Py_XDECREF(func); 3178 Py_XDECREF(pickle_constructor); 3179 Py_XDECREF(pickler); 3180 Py_DECREF(copyreg); 3181 } 3182 return module; 3183} 3184