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