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