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