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