1 """Python abstract syntax node definitions 2 3 This file is automatically generated by Tools/compiler/astgen.py 4 """ 5 from compiler.consts import CO_VARARGS, CO_VARKEYWORDS 6 7 def flatten(seq): 8 l = [] 9 for elt in seq: 10 t = type(elt) 11 if t is tuple or t is list: 12 for elt2 in flatten(elt): 13 l.append(elt2) 14 else: 15 l.append(elt) 16 return l 17 18 def flatten_nodes(seq): 19 return [n for n in flatten(seq) if isinstance(n, Node)] 20 21 def indent(s): 22 return s.replace("\n", "\n\t") 23 24 def decode_function(node): 25 star = (node.flags & 4 != 0) and 1 or 0 26 dstar = (node.flags & 8 != 0) and 1 or 0 27 argnames = node.argnames[:] 28 29 # Add stars to star and dstar parameters. 30 31 if star: 32 argnames[-dstar-star] = "*%s" % argnames[-dstar-star] 33 if dstar: 34 argnames[-dstar] = "**%s" % argnames[-dstar] 35 36 # Map defaults to parameters. 37 38 defaults = [None] * (len(node.argnames) - star - dstar - len(node.defaults)) + list(node.defaults) + [None] * (star + dstar) 39 return [(default and "%s=%s" % (argname, default) or argname) for (argname, default) in zip(argnames, defaults)] 40 41 nodes = {} 42 43 class AttributeUser: 44 45 "Annotation-related node." 46 47 def __init__(self): 48 49 # Name and usage observations. 50 51 self._attrnames = None 52 self._attrcombined = None 53 self._attrmerged = None 54 55 # Related nodes. 56 57 self._attrbranches = None 58 self._attrcontributors = None 59 self._attrdefs = None 60 61 # Deductions. 62 63 self._attrtypes = None 64 self._attrspecifictypes = None 65 66 class Node(AttributeUser): 67 68 "Abstract base class for ast nodes." 69 70 def getChildren(self): 71 pass # implemented by subclasses 72 73 def __iter__(self): 74 for n in self.getChildren(): 75 yield n 76 77 def asList(self): # for backwards compatibility 78 return self.getChildren() 79 80 def getChildNodes(self): 81 pass # implemented by subclasses 82 83 def visit(self, visitor, *args): 84 visitor.default(self, *args) 85 86 class EmptyNode(Node): 87 pass 88 89 class Expression(Node): 90 # Expression is an artificial node class to support "eval" 91 nodes["expression"] = "Expression" 92 def __init__(self, node): 93 Node.__init__(self) 94 self.node = node 95 96 def getChildren(self): 97 return self.node, 98 99 def getChildNodes(self): 100 return self.node, 101 102 def __repr__(self): 103 return "Expression(%r)" % (self.node,) 104 105 def __str__(self): 106 return str(self.node) 107 108 def visit(self, visitor, *args): 109 return visitor.visitExpression(self, *args) 110 111 class Add(Node): 112 def __init__(self, leftright, lineno=None): 113 Node.__init__(self) 114 self.left = leftright[0] 115 self.right = leftright[1] 116 self.lineno = lineno 117 118 def getChildren(self): 119 return self.left, self.right 120 121 def getChildNodes(self): 122 return self.left, self.right 123 124 def __repr__(self): 125 return "Add((%r, %r))" % (self.left, self.right) 126 127 def __str__(self): 128 return "%s + %s" % (self.left, self.right) 129 130 def visit(self, visitor, *args): 131 return visitor.visitAdd(self, *args) 132 133 class And(Node): 134 def __init__(self, nodes, lineno=None): 135 Node.__init__(self) 136 self.nodes = nodes 137 self.lineno = lineno 138 139 def getChildren(self): 140 return tuple(flatten(self.nodes)) 141 142 def getChildNodes(self): 143 nodelist = [] 144 nodelist.extend(flatten_nodes(self.nodes)) 145 return tuple(nodelist) 146 147 def __repr__(self): 148 return "And(%r)" % (self.nodes,) 149 150 def __str__(self): 151 return " and ".join(map(str, self.nodes)) 152 153 def visit(self, visitor, *args): 154 return visitor.visitAnd(self, *args) 155 156 class AssAttr(Node): 157 def __init__(self, expr, attrname, flags, lineno=None): 158 Node.__init__(self) 159 self.expr = expr 160 self.attrname = attrname 161 self.flags = flags 162 self.lineno = lineno 163 164 # Additional annotations. 165 166 self._attr = None 167 self._attrusers = None 168 169 def getChildren(self): 170 return self.expr, self.attrname, self.flags 171 172 def getChildNodes(self): 173 return self.expr, 174 175 def __repr__(self): 176 return "AssAttr(%r, %r, %r)" % (self.expr, self.attrname, self.flags) 177 178 def __str__(self): 179 if self.flags == "OP_DELETE": 180 return "del %s.%s" % (self.expr, self.attrname) 181 else: 182 return "%s.%s" % (self.expr, self.attrname) 183 184 def visit(self, visitor, *args): 185 return visitor.visitAssAttr(self, *args) 186 187 class AssList(Node): 188 def __init__(self, nodes, lineno=None): 189 Node.__init__(self) 190 self.nodes = nodes 191 self.lineno = lineno 192 193 def getChildren(self): 194 return tuple(flatten(self.nodes)) 195 196 def getChildNodes(self): 197 nodelist = [] 198 nodelist.extend(flatten_nodes(self.nodes)) 199 return tuple(nodelist) 200 201 def __repr__(self): 202 return "AssList(%r)" % (self.nodes,) 203 204 def __str__(self): 205 return "[%s]" % ", ".join(map(str, self.nodes)) 206 207 def visit(self, visitor, *args): 208 return visitor.visitAssList(self, *args) 209 210 class AssName(Node): 211 def __init__(self, name, flags, lineno=None): 212 Node.__init__(self) 213 self.name = name 214 self.flags = flags 215 self.lineno = lineno 216 217 def getChildren(self): 218 return self.name, self.flags 219 220 def getChildNodes(self): 221 return () 222 223 def __repr__(self): 224 return "AssName(%r, %r)" % (self.name, self.flags) 225 226 def __str__(self): 227 if self.flags == "OP_DELETE": 228 return "del %s" % self.name 229 else: 230 return str(self.name) 231 232 def visit(self, visitor, *args): 233 return visitor.visitAssName(self, *args) 234 235 class AssTuple(Node): 236 def __init__(self, nodes, lineno=None): 237 Node.__init__(self) 238 self.nodes = nodes 239 self.lineno = lineno 240 241 def getChildren(self): 242 return tuple(flatten(self.nodes)) 243 244 def getChildNodes(self): 245 nodelist = [] 246 nodelist.extend(flatten_nodes(self.nodes)) 247 return tuple(nodelist) 248 249 def __repr__(self): 250 return "AssTuple(%r)" % (self.nodes,) 251 252 def __str__(self): 253 return "(%s)" % ", ".join(map(str, self.nodes)) 254 255 def visit(self, visitor, *args): 256 return visitor.visitAssTuple(self, *args) 257 258 class Assert(Node): 259 def __init__(self, test, fail, lineno=None): 260 Node.__init__(self) 261 self.test = test 262 self.fail = fail 263 self.lineno = lineno 264 265 def getChildren(self): 266 children = [] 267 children.append(self.test) 268 children.append(self.fail) 269 return tuple(children) 270 271 def getChildNodes(self): 272 nodelist = [] 273 nodelist.append(self.test) 274 if self.fail is not None: 275 nodelist.append(self.fail) 276 return tuple(nodelist) 277 278 def __repr__(self): 279 return "Assert(%r, %r)" % (self.test, self.fail) 280 281 def __str__(self): 282 return "assert %s%s" % (self.test, self.fail and ", %s" % self.fail or "") 283 284 def visit(self, visitor, *args): 285 return visitor.visitAssert(self, *args) 286 287 class Assign(Node): 288 def __init__(self, nodes, expr, lineno=None): 289 Node.__init__(self) 290 self.nodes = nodes 291 self.expr = expr 292 self.lineno = lineno 293 294 def getChildren(self): 295 children = [] 296 children.extend(flatten(self.nodes)) 297 children.append(self.expr) 298 return tuple(children) 299 300 def getChildNodes(self): 301 nodelist = [] 302 nodelist.extend(flatten_nodes(self.nodes)) 303 nodelist.append(self.expr) 304 return tuple(nodelist) 305 306 def __repr__(self): 307 return "Assign(%r, %r)" % (self.nodes, self.expr) 308 309 def __str__(self): 310 return "%s = %s" % (", ".join(map(str, self.nodes)), self.expr) 311 312 def visit(self, visitor, *args): 313 return visitor.visitAssign(self, *args) 314 315 class AugAssign(Node): 316 def __init__(self, node, op, expr, lineno=None): 317 Node.__init__(self) 318 self.node = node 319 self.op = op 320 self.expr = expr 321 self.lineno = lineno 322 323 def getChildren(self): 324 return self.node, self.op, self.expr 325 326 def getChildNodes(self): 327 return self.node, self.expr 328 329 def __repr__(self): 330 return "AugAssign(%r, %r, %r)" % (self.node, self.op, self.expr) 331 332 def __str__(self): 333 return "%s %s %s" % (self.node, self.op, self.expr) 334 335 def visit(self, visitor, *args): 336 return visitor.visitAugAssign(self, *args) 337 338 class Backquote(Node): 339 def __init__(self, expr, lineno=None): 340 Node.__init__(self) 341 self.expr = expr 342 self.lineno = lineno 343 344 def getChildren(self): 345 return self.expr, 346 347 def getChildNodes(self): 348 return self.expr, 349 350 def __repr__(self): 351 return "Backquote(%r)" % (self.expr,) 352 353 def __str__(self): 354 return "`%s`" % self.expr 355 356 def visit(self, visitor, *args): 357 return visitor.visitBackquote(self, *args) 358 359 class Bitand(Node): 360 def __init__(self, nodes, lineno=None): 361 Node.__init__(self) 362 self.nodes = nodes 363 self.lineno = lineno 364 365 def getChildren(self): 366 return tuple(flatten(self.nodes)) 367 368 def getChildNodes(self): 369 nodelist = [] 370 nodelist.extend(flatten_nodes(self.nodes)) 371 return tuple(nodelist) 372 373 def __repr__(self): 374 return "Bitand(%r)" % (self.nodes,) 375 376 def __str__(self): 377 return " & ".join(map(str, self.nodes)) 378 379 def visit(self, visitor, *args): 380 return visitor.visitBitand(self, *args) 381 382 class Bitor(Node): 383 def __init__(self, nodes, lineno=None): 384 Node.__init__(self) 385 self.nodes = nodes 386 self.lineno = lineno 387 388 def getChildren(self): 389 return tuple(flatten(self.nodes)) 390 391 def getChildNodes(self): 392 nodelist = [] 393 nodelist.extend(flatten_nodes(self.nodes)) 394 return tuple(nodelist) 395 396 def __repr__(self): 397 return "Bitor(%r)" % (self.nodes,) 398 399 def __str__(self): 400 return " | ".join(map(str, self.nodes)) 401 402 def visit(self, visitor, *args): 403 return visitor.visitBitor(self, *args) 404 405 class Bitxor(Node): 406 def __init__(self, nodes, lineno=None): 407 Node.__init__(self) 408 self.nodes = nodes 409 self.lineno = lineno 410 411 def getChildren(self): 412 return tuple(flatten(self.nodes)) 413 414 def getChildNodes(self): 415 nodelist = [] 416 nodelist.extend(flatten_nodes(self.nodes)) 417 return tuple(nodelist) 418 419 def __repr__(self): 420 return "Bitxor(%r)" % (self.nodes,) 421 422 def __str__(self): 423 return " ^ ".join(map(str, self.nodes)) 424 425 def visit(self, visitor, *args): 426 return visitor.visitBitxor(self, *args) 427 428 class Break(Node): 429 def __init__(self, lineno=None): 430 Node.__init__(self) 431 self.lineno = lineno 432 433 def getChildren(self): 434 return () 435 436 def getChildNodes(self): 437 return () 438 439 def __repr__(self): 440 return "Break()" 441 442 def __str__(self): 443 return "break" 444 445 def visit(self, visitor, *args): 446 return visitor.visitBreak(self, *args) 447 448 class CallFunc(Node): 449 def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None): 450 Node.__init__(self) 451 self.node = node 452 self.args = args 453 self.star_args = star_args 454 self.dstar_args = dstar_args 455 self.lineno = lineno 456 457 def getChildren(self): 458 children = [] 459 children.append(self.node) 460 children.extend(flatten(self.args)) 461 children.append(self.star_args) 462 children.append(self.dstar_args) 463 return tuple(children) 464 465 def getChildNodes(self): 466 nodelist = [] 467 nodelist.append(self.node) 468 nodelist.extend(flatten_nodes(self.args)) 469 if self.star_args is not None: 470 nodelist.append(self.star_args) 471 if self.dstar_args is not None: 472 nodelist.append(self.dstar_args) 473 return tuple(nodelist) 474 475 def __repr__(self): 476 return "CallFunc(%r, %r, %r, %r)" % (self.node, self.args, self.star_args, self.dstar_args) 477 478 def __str__(self): 479 star_args = self.star_args and ["*%s" % self.star_args] or [] 480 dstar_args = self.dstar_args and ["**%s" % self.dstar_args] or [] 481 return "%s(%s)" % (self.node, ", ".join(map(str, self.args + star_args + dstar_args))) 482 483 def visit(self, visitor, *args): 484 return visitor.visitCallFunc(self, *args) 485 486 class Class(Node): 487 def __init__(self, name, bases, doc, code, decorators = None, lineno=None): 488 Node.__init__(self) 489 self.name = name 490 self.bases = bases 491 self.doc = doc 492 self.code = code 493 self.decorators = decorators 494 self.lineno = lineno 495 496 # Additional annotations. 497 498 self.unit = None 499 500 def getChildren(self): 501 children = [] 502 children.append(self.name) 503 children.extend(flatten(self.bases)) 504 children.append(self.doc) 505 children.append(self.code) 506 children.append(self.decorators) 507 return tuple(children) 508 509 def getChildNodes(self): 510 nodelist = [] 511 nodelist.extend(flatten_nodes(self.bases)) 512 nodelist.append(self.code) 513 if self.decorators is not None: 514 nodelist.append(self.decorators) 515 return tuple(nodelist) 516 517 def __repr__(self): 518 return "Class(%r, %r, %r, %r, %r)" % (self.name, self.bases, self.doc, self.code, self.decorators) 519 520 def __str__(self): 521 return "%sclass %s%s:%s%s" % ( 522 self.decorators and "%s\n" % "\n".join([("@%s" % decorator) for decorator in self.decorators]) or "", 523 self.name, 524 self.bases and "(%s)" % ", ".join(map(str, self.bases)) or "", 525 indent(self.doc and "\n%r" % self.doc or ""), 526 indent("\n%s" % self.code) 527 ) 528 529 def visit(self, visitor, *args): 530 return visitor.visitClass(self, *args) 531 532 class Compare(Node): 533 def __init__(self, expr, ops, lineno=None): 534 Node.__init__(self) 535 self.expr = expr 536 self.ops = ops 537 self.lineno = lineno 538 539 def getChildren(self): 540 children = [] 541 children.append(self.expr) 542 children.extend(flatten(self.ops)) 543 return tuple(children) 544 545 def getChildNodes(self): 546 nodelist = [] 547 nodelist.append(self.expr) 548 nodelist.extend(flatten_nodes(self.ops)) 549 return tuple(nodelist) 550 551 def __repr__(self): 552 return "Compare(%r, %r)" % (self.expr, self.ops) 553 554 def __str__(self): 555 return "%s %s" % (self.expr, " ".join([("%s %s" % op) for op in self.ops])) 556 557 def visit(self, visitor, *args): 558 return visitor.visitCompare(self, *args) 559 560 class Const(Node): 561 def __init__(self, value, lineno=None): 562 Node.__init__(self) 563 self.value = value 564 self.lineno = lineno 565 566 def getChildren(self): 567 return self.value, 568 569 def getChildNodes(self): 570 return () 571 572 def __repr__(self): 573 return "Const(%r)" % (self.value,) 574 575 def __str__(self): 576 return repr(self.value) 577 578 def visit(self, visitor, *args): 579 return visitor.visitConst(self, *args) 580 581 class Continue(Node): 582 def __init__(self, lineno=None): 583 Node.__init__(self) 584 self.lineno = lineno 585 586 def getChildren(self): 587 return () 588 589 def getChildNodes(self): 590 return () 591 592 def __repr__(self): 593 return "Continue()" 594 595 def __str__(self): 596 return "continue" 597 598 def visit(self, visitor, *args): 599 return visitor.visitContinue(self, *args) 600 601 class Decorators(Node): 602 def __init__(self, nodes, lineno=None): 603 Node.__init__(self) 604 self.nodes = nodes 605 self.lineno = lineno 606 607 def getChildren(self): 608 return tuple(flatten(self.nodes)) 609 610 def getChildNodes(self): 611 nodelist = [] 612 nodelist.extend(flatten_nodes(self.nodes)) 613 return tuple(nodelist) 614 615 def __repr__(self): 616 return "Decorators(%r)" % (self.nodes,) 617 618 def __str__(self): 619 return "\n".join([("@%s" % node) for node in self.nodes]) 620 621 def visit(self, visitor, *args): 622 return visitor.visitDecorators(self, *args) 623 624 class Dict(Node): 625 def __init__(self, items, lineno=None): 626 Node.__init__(self) 627 self.items = items 628 self.lineno = lineno 629 630 def getChildren(self): 631 return tuple(flatten(self.items)) 632 633 def getChildNodes(self): 634 nodelist = [] 635 nodelist.extend(flatten_nodes(self.items)) 636 return tuple(nodelist) 637 638 def __repr__(self): 639 return "Dict(%r)" % (self.items,) 640 641 def __str__(self): 642 return "{%s}" % ", ".join(map(str, self.items)) 643 644 def visit(self, visitor, *args): 645 return visitor.visitDict(self, *args) 646 647 class Discard(Node): 648 def __init__(self, expr, lineno=None): 649 Node.__init__(self) 650 self.expr = expr 651 self.lineno = lineno 652 653 def getChildren(self): 654 return self.expr, 655 656 def getChildNodes(self): 657 return self.expr, 658 659 def __repr__(self): 660 return "Discard(%r)" % (self.expr,) 661 662 def __str__(self): 663 return str(self.expr) 664 665 def visit(self, visitor, *args): 666 return visitor.visitDiscard(self, *args) 667 668 class Div(Node): 669 def __init__(self, leftright, lineno=None): 670 Node.__init__(self) 671 self.left = leftright[0] 672 self.right = leftright[1] 673 self.lineno = lineno 674 675 def getChildren(self): 676 return self.left, self.right 677 678 def getChildNodes(self): 679 return self.left, self.right 680 681 def __repr__(self): 682 return "Div((%r, %r))" % (self.left, self.right) 683 684 def __str__(self): 685 return "%s / %s" % (self.left, self.right) 686 687 def visit(self, visitor, *args): 688 return visitor.visitDiv(self, *args) 689 690 class Ellipsis(Node): 691 def __init__(self, lineno=None): 692 Node.__init__(self) 693 self.lineno = lineno 694 695 def getChildren(self): 696 return () 697 698 def getChildNodes(self): 699 return () 700 701 def __repr__(self): 702 return "Ellipsis()" 703 704 def __str__(self): 705 return "..." 706 707 def visit(self, visitor, *args): 708 return visitor.visitEllipsis(self, *args) 709 710 class Exec(Node): 711 def __init__(self, expr, locals, globals, lineno=None): 712 Node.__init__(self) 713 self.expr = expr 714 self.locals = locals 715 self.globals = globals 716 self.lineno = lineno 717 718 def getChildren(self): 719 children = [] 720 children.append(self.expr) 721 children.append(self.locals) 722 children.append(self.globals) 723 return tuple(children) 724 725 def getChildNodes(self): 726 nodelist = [] 727 nodelist.append(self.expr) 728 if self.locals is not None: 729 nodelist.append(self.locals) 730 if self.globals is not None: 731 nodelist.append(self.globals) 732 return tuple(nodelist) 733 734 def __repr__(self): 735 return "Exec(%r, %r, %r)" % (self.expr, self.locals, self.globals) 736 737 def __str__(self): 738 return "exec %s%s%s" % (self.expr, self.locals and ", %s" % self.locals or "", 739 self.globals and ", %s" % self.globals or "") 740 741 def visit(self, visitor, *args): 742 return visitor.visitExec(self, *args) 743 744 class FloorDiv(Node): 745 def __init__(self, leftright, lineno=None): 746 Node.__init__(self) 747 self.left = leftright[0] 748 self.right = leftright[1] 749 self.lineno = lineno 750 751 def getChildren(self): 752 return self.left, self.right 753 754 def getChildNodes(self): 755 return self.left, self.right 756 757 def __repr__(self): 758 return "FloorDiv((%r, %r))" % (self.left, self.right) 759 760 def __str__(self): 761 return "%s // %s" % (self.left, self.right) 762 763 def visit(self, visitor, *args): 764 return visitor.visitFloorDiv(self, *args) 765 766 class For(Node): 767 def __init__(self, assign, list, body, else_, lineno=None): 768 Node.__init__(self) 769 self.assign = assign 770 self.list = list 771 self.body = body 772 self.else_ = else_ 773 self.lineno = lineno 774 775 def getChildren(self): 776 children = [] 777 children.append(self.assign) 778 children.append(self.list) 779 children.append(self.body) 780 children.append(self.else_) 781 return tuple(children) 782 783 def getChildNodes(self): 784 nodelist = [] 785 nodelist.append(self.assign) 786 nodelist.append(self.list) 787 nodelist.append(self.body) 788 if self.else_ is not None: 789 nodelist.append(self.else_) 790 return tuple(nodelist) 791 792 def __repr__(self): 793 return "For(%r, %r, %r, %r)" % (self.assign, self.list, self.body, self.else_) 794 795 def __str__(self): 796 return "for %s in %s:%s%s" % ( 797 self.assign, self.list, 798 indent("\n%s" % self.body), 799 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 800 ) 801 802 def visit(self, visitor, *args): 803 return visitor.visitFor(self, *args) 804 805 class From(Node): 806 def __init__(self, modname, names, level, lineno=None): 807 Node.__init__(self) 808 self.modname = modname 809 self.names = names 810 self.level = level 811 self.lineno = lineno 812 813 def getChildren(self): 814 return self.modname, self.names, self.level 815 816 def getChildNodes(self): 817 return () 818 819 def __repr__(self): 820 return "From(%r, %r, %r)" % (self.modname, self.names, self.level) 821 822 def __str__(self): 823 return "from %s import %s" % (self.modname, 824 ", ".join([(alias and "%s as %s" % (name, alias) or name) for (name, alias) in self.names])) 825 826 def visit(self, visitor, *args): 827 return visitor.visitFrom(self, *args) 828 829 class Function(Node): 830 def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): 831 Node.__init__(self) 832 self.decorators = decorators 833 self.name = name 834 self.argnames = argnames 835 self.defaults = defaults 836 self.flags = flags 837 self.doc = doc 838 self.code = code 839 self.lineno = lineno 840 self.varargs = self.kwargs = None 841 if flags & CO_VARARGS: 842 self.varargs = 1 843 if flags & CO_VARKEYWORDS: 844 self.kwargs = 1 845 846 # Additional annotations. 847 848 self.unit = None 849 850 def getChildren(self): 851 children = [] 852 children.append(self.decorators) 853 children.append(self.name) 854 children.append(self.argnames) 855 children.extend(flatten(self.defaults)) 856 children.append(self.flags) 857 children.append(self.doc) 858 children.append(self.code) 859 return tuple(children) 860 861 def getChildNodes(self): 862 nodelist = [] 863 if self.decorators is not None: 864 nodelist.append(self.decorators) 865 nodelist.extend(flatten_nodes(self.defaults)) 866 nodelist.append(self.code) 867 return tuple(nodelist) 868 869 def __repr__(self): 870 return "Function(%r, %r, %r, %r, %r, %r, %r)" % (self.decorators, self.name, self.argnames, self.defaults, self.flags, self.doc, self.code) 871 872 def __str__(self): 873 parameters = decode_function(self) 874 875 return "%sdef %s(%s):%s%s" % ( 876 self.decorators and "%s\n" % "\n".join([("@%s" % decorator) for decorator in self.decorators]) or "", 877 self.name, 878 ", ".join(parameters), 879 indent(self.doc and "\n%r" % self.doc or ""), 880 indent("\n%s" % self.code) 881 ) 882 883 def visit(self, visitor, *args): 884 return visitor.visitFunction(self, *args) 885 886 class GenExpr(Node): 887 def __init__(self, code, lineno=None): 888 Node.__init__(self) 889 self.code = code 890 self.lineno = lineno 891 self.argnames = ['.0'] 892 self.varargs = self.kwargs = None 893 894 def getChildren(self): 895 return self.code, 896 897 def getChildNodes(self): 898 return self.code, 899 900 def __repr__(self): 901 return "GenExpr(%r)" % (self.code,) 902 903 def __str__(self): 904 return str(self.code) 905 906 def visit(self, visitor, *args): 907 return visitor.visitGenExpr(self, *args) 908 909 class GenExprFor(Node): 910 def __init__(self, assign, iter, ifs, lineno=None): 911 Node.__init__(self) 912 self.assign = assign 913 self.iter = iter 914 self.ifs = ifs 915 self.lineno = lineno 916 self.is_outmost = False 917 918 def getChildren(self): 919 children = [] 920 children.append(self.assign) 921 children.append(self.iter) 922 children.extend(flatten(self.ifs)) 923 return tuple(children) 924 925 def getChildNodes(self): 926 nodelist = [] 927 nodelist.append(self.assign) 928 nodelist.append(self.iter) 929 nodelist.extend(flatten_nodes(self.ifs)) 930 return tuple(nodelist) 931 932 def __repr__(self): 933 return "GenExprFor(%r, %r, %r)" % (self.assign, self.iter, self.ifs) 934 935 def __str__(self): 936 return "for %s in %s%s" % ( 937 self.assign, self.iter, 938 self.ifs and " ".join(map(str, self.ifs)) or "" 939 ) 940 941 def visit(self, visitor, *args): 942 return visitor.visitGenExprFor(self, *args) 943 944 class GenExprIf(Node): 945 def __init__(self, test, lineno=None): 946 Node.__init__(self) 947 self.test = test 948 self.lineno = lineno 949 950 def getChildren(self): 951 return self.test, 952 953 def getChildNodes(self): 954 return self.test, 955 956 def __repr__(self): 957 return "GenExprIf(%r)" % (self.test,) 958 959 def __str__(self): 960 return "if %s" % self.test 961 962 def visit(self, visitor, *args): 963 return visitor.visitGenExprIf(self, *args) 964 965 class GenExprInner(Node): 966 def __init__(self, expr, quals, lineno=None): 967 Node.__init__(self) 968 self.expr = expr 969 self.quals = quals 970 self.lineno = lineno 971 972 def getChildren(self): 973 children = [] 974 children.append(self.expr) 975 children.extend(flatten(self.quals)) 976 return tuple(children) 977 978 def getChildNodes(self): 979 nodelist = [] 980 nodelist.append(self.expr) 981 nodelist.extend(flatten_nodes(self.quals)) 982 return tuple(nodelist) 983 984 def __repr__(self): 985 return "GenExprInner(%r, %r)" % (self.expr, self.quals) 986 987 def __str__(self): 988 return "%s %s" % (self.expr, " ".join(map(str, self.quals))) 989 990 def visit(self, visitor, *args): 991 return visitor.visitGenExprInner(self, *args) 992 993 class Getattr(Node): 994 def __init__(self, expr, attrname, lineno=None): 995 Node.__init__(self) 996 self.expr = expr 997 self.attrname = attrname 998 self.lineno = lineno 999 1000 # Additional annotations. 1001 1002 self._attr = None 1003 self._attrusers = None 1004 1005 def getChildren(self): 1006 return self.expr, self.attrname 1007 1008 def getChildNodes(self): 1009 return self.expr, 1010 1011 def __repr__(self): 1012 return "Getattr(%r, %r)" % (self.expr, self.attrname) 1013 1014 def __str__(self): 1015 return "%s.%s" % (self.expr, self.attrname) 1016 1017 def visit(self, visitor, *args): 1018 return visitor.visitGetattr(self, *args) 1019 1020 class Global(Node): 1021 def __init__(self, names, lineno=None): 1022 Node.__init__(self) 1023 self.names = names 1024 self.lineno = lineno 1025 1026 def getChildren(self): 1027 return self.names, 1028 1029 def getChildNodes(self): 1030 return () 1031 1032 def __repr__(self): 1033 return "Global(%r)" % (self.names,) 1034 1035 def __str__(self): 1036 return "global %s" % ", ".join(map(str, self.names)) 1037 1038 def visit(self, visitor, *args): 1039 return visitor.visitGlobal(self, *args) 1040 1041 class If(Node): 1042 def __init__(self, tests, else_, lineno=None): 1043 Node.__init__(self) 1044 self.tests = tests 1045 self.else_ = else_ 1046 self.lineno = lineno 1047 1048 def getChildren(self): 1049 children = [] 1050 children.extend(flatten(self.tests)) 1051 children.append(self.else_) 1052 return tuple(children) 1053 1054 def getChildNodes(self): 1055 nodelist = [] 1056 nodelist.extend(flatten_nodes(self.tests)) 1057 if self.else_ is not None: 1058 nodelist.append(self.else_) 1059 return tuple(nodelist) 1060 1061 def __repr__(self): 1062 return "If(%r, %r)" % (self.tests, self.else_) 1063 1064 def __str__(self): 1065 tests = [("%sif %s:%s" % (i > 0 and "el" or "", test, indent("\n%s" % body))) for (i, (test, body)) in enumerate(self.tests)] 1066 return "%s%s" % ( 1067 "\n".join(tests), 1068 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1069 ) 1070 1071 def visit(self, visitor, *args): 1072 return visitor.visitIf(self, *args) 1073 1074 class IfExp(Node): 1075 def __init__(self, test, then, else_, lineno=None): 1076 Node.__init__(self) 1077 self.test = test 1078 self.then = then 1079 self.else_ = else_ 1080 self.lineno = lineno 1081 1082 def getChildren(self): 1083 return self.test, self.then, self.else_ 1084 1085 def getChildNodes(self): 1086 return self.test, self.then, self.else_ 1087 1088 def __repr__(self): 1089 return "IfExp(%r, %r, %r)" % (self.test, self.then, self.else_) 1090 1091 def __str__(self): 1092 return "%s if %s else %s" % (self.then, self.test, self.else_) 1093 1094 def visit(self, visitor, *args): 1095 return visitor.visitIfExp(self, *args) 1096 1097 class Import(Node): 1098 def __init__(self, names, lineno=None): 1099 Node.__init__(self) 1100 self.names = names 1101 self.lineno = lineno 1102 1103 def getChildren(self): 1104 return self.names, 1105 1106 def getChildNodes(self): 1107 return () 1108 1109 def __repr__(self): 1110 return "Import(%r)" % (self.names,) 1111 1112 def __str__(self): 1113 return "import %s" % ( 1114 ", ".join([(alias and "%s as %s" % (name, alias) or name) for (name, alias) in self.names])) 1115 1116 def visit(self, visitor, *args): 1117 return visitor.visitImport(self, *args) 1118 1119 class Invert(Node): 1120 def __init__(self, expr, lineno=None): 1121 Node.__init__(self) 1122 self.expr = expr 1123 self.lineno = lineno 1124 1125 def getChildren(self): 1126 return self.expr, 1127 1128 def getChildNodes(self): 1129 return self.expr, 1130 1131 def __repr__(self): 1132 return "Invert(%r)" % (self.expr,) 1133 1134 def __str__(self): 1135 return "~%s" % self.expr 1136 1137 def visit(self, visitor, *args): 1138 return visitor.visitInvert(self, *args) 1139 1140 class Keyword(Node): 1141 def __init__(self, name, expr, lineno=None): 1142 Node.__init__(self) 1143 self.name = name 1144 self.expr = expr 1145 self.lineno = lineno 1146 1147 def getChildren(self): 1148 return self.name, self.expr 1149 1150 def getChildNodes(self): 1151 return self.expr, 1152 1153 def __repr__(self): 1154 return "Keyword(%r, %r)" % (self.name, self.expr) 1155 1156 def __str__(self): 1157 return "%s=%s" % (self.name, self.expr) 1158 1159 def visit(self, visitor, *args): 1160 return visitor.visitKeyword(self, *args) 1161 1162 class Lambda(Node): 1163 def __init__(self, argnames, defaults, flags, code, lineno=None): 1164 Node.__init__(self) 1165 self.argnames = argnames 1166 self.defaults = defaults 1167 self.flags = flags 1168 self.code = code 1169 self.lineno = lineno 1170 self.varargs = self.kwargs = None 1171 if flags & CO_VARARGS: 1172 self.varargs = 1 1173 if flags & CO_VARKEYWORDS: 1174 self.kwargs = 1 1175 1176 def getChildren(self): 1177 children = [] 1178 children.append(self.argnames) 1179 children.extend(flatten(self.defaults)) 1180 children.append(self.flags) 1181 children.append(self.code) 1182 return tuple(children) 1183 1184 def getChildNodes(self): 1185 nodelist = [] 1186 nodelist.extend(flatten_nodes(self.defaults)) 1187 nodelist.append(self.code) 1188 return tuple(nodelist) 1189 1190 def __repr__(self): 1191 return "Lambda(%r, %r, %r, %r)" % (self.argnames, self.defaults, self.flags, self.code) 1192 1193 def __str__(self): 1194 parameters = decode_function(self) 1195 return "lambda %s: %s" % (", ".join(parameters), self.code) 1196 1197 def visit(self, visitor, *args): 1198 return visitor.visitLambda(self, *args) 1199 1200 class LeftShift(Node): 1201 def __init__(self, leftright, lineno=None): 1202 Node.__init__(self) 1203 self.left = leftright[0] 1204 self.right = leftright[1] 1205 self.lineno = lineno 1206 1207 def getChildren(self): 1208 return self.left, self.right 1209 1210 def getChildNodes(self): 1211 return self.left, self.right 1212 1213 def __repr__(self): 1214 return "LeftShift((%r, %r))" % (self.left, self.right) 1215 1216 def __str__(self): 1217 return "%s << %s" % (self.left, self.right) 1218 1219 def visit(self, visitor, *args): 1220 return visitor.visitLeftShift(self, *args) 1221 1222 class List(Node): 1223 def __init__(self, nodes, lineno=None): 1224 Node.__init__(self) 1225 self.nodes = nodes 1226 self.lineno = lineno 1227 1228 def getChildren(self): 1229 return tuple(flatten(self.nodes)) 1230 1231 def getChildNodes(self): 1232 nodelist = [] 1233 nodelist.extend(flatten_nodes(self.nodes)) 1234 return tuple(nodelist) 1235 1236 def __repr__(self): 1237 return "List(%r)" % (self.nodes,) 1238 1239 def __str__(self): 1240 return "[%s]" % ", ".join(map(str, self.nodes)) 1241 1242 def visit(self, visitor, *args): 1243 return visitor.visitList(self, *args) 1244 1245 class ListComp(Node): 1246 def __init__(self, expr, quals, lineno=None): 1247 Node.__init__(self) 1248 self.expr = expr 1249 self.quals = quals 1250 self.lineno = lineno 1251 1252 def getChildren(self): 1253 children = [] 1254 children.append(self.expr) 1255 children.extend(flatten(self.quals)) 1256 return tuple(children) 1257 1258 def getChildNodes(self): 1259 nodelist = [] 1260 nodelist.append(self.expr) 1261 nodelist.extend(flatten_nodes(self.quals)) 1262 return tuple(nodelist) 1263 1264 def __repr__(self): 1265 return "ListComp(%r, %r)" % (self.expr, self.quals) 1266 1267 def __str__(self): 1268 return "[%s %s]" % (self.expr, " ".join(map(str, self.quals))) 1269 1270 def visit(self, visitor, *args): 1271 return visitor.visitListComp(self, *args) 1272 1273 class ListCompFor(Node): 1274 def __init__(self, assign, list, ifs, lineno=None): 1275 Node.__init__(self) 1276 self.assign = assign 1277 self.list = list 1278 self.ifs = ifs 1279 self.lineno = lineno 1280 1281 def getChildren(self): 1282 children = [] 1283 children.append(self.assign) 1284 children.append(self.list) 1285 children.extend(flatten(self.ifs)) 1286 return tuple(children) 1287 1288 def getChildNodes(self): 1289 nodelist = [] 1290 nodelist.append(self.assign) 1291 nodelist.append(self.list) 1292 nodelist.extend(flatten_nodes(self.ifs)) 1293 return tuple(nodelist) 1294 1295 def __repr__(self): 1296 return "ListCompFor(%r, %r, %r)" % (self.assign, self.list, self.ifs) 1297 1298 def __str__(self): 1299 return "for %s in %s%s" % ( 1300 self.assign, self.list, 1301 self.ifs and " ".join(map(str, self.ifs)) or "" 1302 ) 1303 1304 def visit(self, visitor, *args): 1305 return visitor.visitListCompFor(self, *args) 1306 1307 class ListCompIf(Node): 1308 def __init__(self, test, lineno=None): 1309 Node.__init__(self) 1310 self.test = test 1311 self.lineno = lineno 1312 1313 def getChildren(self): 1314 return self.test, 1315 1316 def getChildNodes(self): 1317 return self.test, 1318 1319 def __repr__(self): 1320 return "ListCompIf(%r)" % (self.test,) 1321 1322 def __str__(self): 1323 return "if %s" % self.test 1324 1325 def visit(self, visitor, *args): 1326 return visitor.visitListCompIf(self, *args) 1327 1328 class Mod(Node): 1329 def __init__(self, leftright, lineno=None): 1330 Node.__init__(self) 1331 self.left = leftright[0] 1332 self.right = leftright[1] 1333 self.lineno = lineno 1334 1335 def getChildren(self): 1336 return self.left, self.right 1337 1338 def getChildNodes(self): 1339 return self.left, self.right 1340 1341 def __repr__(self): 1342 return "Mod((%r, %r))" % (self.left, self.right) 1343 1344 def __str__(self): 1345 return "%s %% %s" % (self.left, self.right) 1346 1347 def visit(self, visitor, *args): 1348 return visitor.visitMod(self, *args) 1349 1350 class Module(Node): 1351 def __init__(self, doc, node, lineno=None): 1352 Node.__init__(self) 1353 self.doc = doc 1354 self.node = node 1355 self.lineno = lineno 1356 1357 # Additional annotations. 1358 1359 self.unit = None 1360 1361 def getChildren(self): 1362 return self.doc, self.node 1363 1364 def getChildNodes(self): 1365 return self.node, 1366 1367 def __repr__(self): 1368 return "Module(%r, %r)" % (self.doc, self.node) 1369 1370 def __str__(self): 1371 return "%s%s" % (self.doc and "%r\n" % self.doc or "", self.node) 1372 1373 def visit(self, visitor, *args): 1374 return visitor.visitModule(self, *args) 1375 1376 class Mul(Node): 1377 def __init__(self, leftright, lineno=None): 1378 Node.__init__(self) 1379 self.left = leftright[0] 1380 self.right = leftright[1] 1381 self.lineno = lineno 1382 1383 def getChildren(self): 1384 return self.left, self.right 1385 1386 def getChildNodes(self): 1387 return self.left, self.right 1388 1389 def __repr__(self): 1390 return "Mul((%r, %r))" % (self.left, self.right) 1391 1392 def __str__(self): 1393 return "%s * %s" % (self.left, self.right) 1394 1395 def visit(self, visitor, *args): 1396 return visitor.visitMul(self, *args) 1397 1398 class Name(Node): 1399 def __init__(self, name, lineno=None): 1400 Node.__init__(self) 1401 self.name = name 1402 self.lineno = lineno 1403 1404 # Additional annotations. 1405 1406 self._scope = None 1407 self._attr = None 1408 self._attrusers = None 1409 1410 def getChildren(self): 1411 return self.name, 1412 1413 def getChildNodes(self): 1414 return () 1415 1416 def __repr__(self): 1417 return "Name(%r)" % (self.name,) 1418 1419 def __str__(self): 1420 return str(self.name) 1421 1422 def visit(self, visitor, *args): 1423 return visitor.visitName(self, *args) 1424 1425 class Not(Node): 1426 def __init__(self, expr, lineno=None): 1427 Node.__init__(self) 1428 self.expr = expr 1429 self.lineno = lineno 1430 1431 def getChildren(self): 1432 return self.expr, 1433 1434 def getChildNodes(self): 1435 return self.expr, 1436 1437 def __repr__(self): 1438 return "Not(%r)" % (self.expr,) 1439 1440 def __str__(self): 1441 return "not %s" % self.expr 1442 1443 def visit(self, visitor, *args): 1444 return visitor.visitNot(self, *args) 1445 1446 class Or(Node): 1447 def __init__(self, nodes, lineno=None): 1448 Node.__init__(self) 1449 self.nodes = nodes 1450 self.lineno = lineno 1451 1452 def getChildren(self): 1453 return tuple(flatten(self.nodes)) 1454 1455 def getChildNodes(self): 1456 nodelist = [] 1457 nodelist.extend(flatten_nodes(self.nodes)) 1458 return tuple(nodelist) 1459 1460 def __repr__(self): 1461 return "Or(%r)" % (self.nodes,) 1462 1463 def __str__(self): 1464 return " or ".join(map(str, self.nodes)) 1465 1466 def visit(self, visitor, *args): 1467 return visitor.visitOr(self, *args) 1468 1469 class Pass(Node): 1470 def __init__(self, lineno=None): 1471 Node.__init__(self) 1472 self.lineno = lineno 1473 1474 def getChildren(self): 1475 return () 1476 1477 def getChildNodes(self): 1478 return () 1479 1480 def __repr__(self): 1481 return "Pass()" 1482 1483 def __str__(self): 1484 return "pass" 1485 1486 def visit(self, visitor, *args): 1487 return visitor.visitPass(self, *args) 1488 1489 class Power(Node): 1490 def __init__(self, leftright, lineno=None): 1491 Node.__init__(self) 1492 self.left = leftright[0] 1493 self.right = leftright[1] 1494 self.lineno = lineno 1495 1496 def getChildren(self): 1497 return self.left, self.right 1498 1499 def getChildNodes(self): 1500 return self.left, self.right 1501 1502 def __repr__(self): 1503 return "Power((%r, %r))" % (self.left, self.right) 1504 1505 def __str__(self): 1506 return "%s ** %s" % (self.left, self.right) 1507 1508 def visit(self, visitor, *args): 1509 return visitor.visitPower(self, *args) 1510 1511 class Print(Node): 1512 def __init__(self, nodes, dest, lineno=None): 1513 Node.__init__(self) 1514 self.nodes = nodes 1515 self.dest = dest 1516 self.lineno = lineno 1517 1518 def getChildren(self): 1519 children = [] 1520 children.extend(flatten(self.nodes)) 1521 children.append(self.dest) 1522 return tuple(children) 1523 1524 def getChildNodes(self): 1525 nodelist = [] 1526 nodelist.extend(flatten_nodes(self.nodes)) 1527 if self.dest is not None: 1528 nodelist.append(self.dest) 1529 return tuple(nodelist) 1530 1531 def __repr__(self): 1532 return "Print(%r, %r)" % (self.nodes, self.dest) 1533 1534 def __str__(self): 1535 dest = self.dest and [">>%s" % self.dest] or [] 1536 return "print %s," % ", ".join(map(str, dest + self.nodes)) 1537 1538 def visit(self, visitor, *args): 1539 return visitor.visitPrint(self, *args) 1540 1541 class Printnl(Node): 1542 def __init__(self, nodes, dest, lineno=None): 1543 Node.__init__(self) 1544 self.nodes = nodes 1545 self.dest = dest 1546 self.lineno = lineno 1547 1548 def getChildren(self): 1549 children = [] 1550 children.extend(flatten(self.nodes)) 1551 children.append(self.dest) 1552 return tuple(children) 1553 1554 def getChildNodes(self): 1555 nodelist = [] 1556 nodelist.extend(flatten_nodes(self.nodes)) 1557 if self.dest is not None: 1558 nodelist.append(self.dest) 1559 return tuple(nodelist) 1560 1561 def __repr__(self): 1562 return "Printnl(%r, %r)" % (self.nodes, self.dest) 1563 1564 def __str__(self): 1565 dest = self.dest and [">>%s" % self.dest] or [] 1566 return "print %s" % ", ".join(map(str, dest + self.nodes)) 1567 1568 def visit(self, visitor, *args): 1569 return visitor.visitPrintnl(self, *args) 1570 1571 class Raise(Node): 1572 def __init__(self, expr1, expr2, expr3, lineno=None): 1573 Node.__init__(self) 1574 self.expr1 = expr1 1575 self.expr2 = expr2 1576 self.expr3 = expr3 1577 self.lineno = lineno 1578 1579 def getChildren(self): 1580 children = [] 1581 children.append(self.expr1) 1582 children.append(self.expr2) 1583 children.append(self.expr3) 1584 return tuple(children) 1585 1586 def getChildNodes(self): 1587 nodelist = [] 1588 if self.expr1 is not None: 1589 nodelist.append(self.expr1) 1590 if self.expr2 is not None: 1591 nodelist.append(self.expr2) 1592 if self.expr3 is not None: 1593 nodelist.append(self.expr3) 1594 return tuple(nodelist) 1595 1596 def __repr__(self): 1597 return "Raise(%r, %r, %r)" % (self.expr1, self.expr2, self.expr3) 1598 1599 def __str__(self): 1600 args = self.expr1 and [self.expr1] or [] 1601 args += self.expr2 and [self.expr2] or [] 1602 args += self.expr3 and [self.expr3] or [] 1603 return "raise %s" % ", ".join(map(str, args)) 1604 1605 def visit(self, visitor, *args): 1606 return visitor.visitRaise(self, *args) 1607 1608 class Return(Node): 1609 def __init__(self, value, lineno=None): 1610 Node.__init__(self) 1611 self.value = value 1612 self.lineno = lineno 1613 1614 def getChildren(self): 1615 return self.value, 1616 1617 def getChildNodes(self): 1618 return self.value, 1619 1620 def __repr__(self): 1621 return "Return(%r)" % (self.value,) 1622 1623 def __str__(self): 1624 return "return %s" % self.value 1625 1626 def visit(self, visitor, *args): 1627 return visitor.visitReturn(self, *args) 1628 1629 class RightShift(Node): 1630 def __init__(self, leftright, lineno=None): 1631 Node.__init__(self) 1632 self.left = leftright[0] 1633 self.right = leftright[1] 1634 self.lineno = lineno 1635 1636 def getChildren(self): 1637 return self.left, self.right 1638 1639 def getChildNodes(self): 1640 return self.left, self.right 1641 1642 def __repr__(self): 1643 return "RightShift((%r, %r))" % (self.left, self.right) 1644 1645 def __str__(self): 1646 return "%s >> %s" % (self.left, self.right) 1647 1648 def visit(self, visitor, *args): 1649 return visitor.visitRightShift(self, *args) 1650 1651 class Slice(Node): 1652 def __init__(self, expr, flags, lower, upper, lineno=None): 1653 Node.__init__(self) 1654 self.expr = expr 1655 self.flags = flags 1656 self.lower = lower 1657 self.upper = upper 1658 self.lineno = lineno 1659 1660 def getChildren(self): 1661 children = [] 1662 children.append(self.expr) 1663 children.append(self.flags) 1664 children.append(self.lower) 1665 children.append(self.upper) 1666 return tuple(children) 1667 1668 def getChildNodes(self): 1669 nodelist = [] 1670 nodelist.append(self.expr) 1671 if self.lower is not None: 1672 nodelist.append(self.lower) 1673 if self.upper is not None: 1674 nodelist.append(self.upper) 1675 return tuple(nodelist) 1676 1677 def __repr__(self): 1678 return "Slice(%r, %r, %r, %r)" % (self.expr, self.flags, self.lower, self.upper) 1679 1680 def __str__(self): 1681 args = [] 1682 args = self.lower is not None and [self.lower] or [] 1683 args = self.upper is not None and [self.upper] or [] 1684 return "%s[%s]" % (self.expr, ":".join(map(str, args))) 1685 1686 def visit(self, visitor, *args): 1687 return visitor.visitSlice(self, *args) 1688 1689 class Sliceobj(Node): 1690 def __init__(self, nodes, lineno=None): 1691 Node.__init__(self) 1692 self.nodes = nodes 1693 self.lineno = lineno 1694 1695 def getChildren(self): 1696 return tuple(flatten(self.nodes)) 1697 1698 def getChildNodes(self): 1699 nodelist = [] 1700 nodelist.extend(flatten_nodes(self.nodes)) 1701 return tuple(nodelist) 1702 1703 def __repr__(self): 1704 return "Sliceobj(%r)" % (self.nodes,) 1705 1706 def __str__(self): 1707 return ":".join(map(str, self.nodes)) 1708 1709 def visit(self, visitor, *args): 1710 return visitor.visitSliceobj(self, *args) 1711 1712 class Stmt(Node): 1713 def __init__(self, nodes, lineno=None): 1714 Node.__init__(self) 1715 self.nodes = nodes 1716 self.lineno = lineno 1717 1718 def getChildren(self): 1719 return tuple(flatten(self.nodes)) 1720 1721 def getChildNodes(self): 1722 nodelist = [] 1723 nodelist.extend(flatten_nodes(self.nodes)) 1724 return tuple(nodelist) 1725 1726 def __repr__(self): 1727 return "Stmt(%r)" % (self.nodes,) 1728 1729 def __str__(self): 1730 return "\n".join(map(str, self.nodes)) 1731 1732 def visit(self, visitor, *args): 1733 return visitor.visitStmt(self, *args) 1734 1735 class Sub(Node): 1736 def __init__(self, leftright, lineno=None): 1737 Node.__init__(self) 1738 self.left = leftright[0] 1739 self.right = leftright[1] 1740 self.lineno = lineno 1741 1742 def getChildren(self): 1743 return self.left, self.right 1744 1745 def getChildNodes(self): 1746 return self.left, self.right 1747 1748 def __repr__(self): 1749 return "Sub((%r, %r))" % (self.left, self.right) 1750 1751 def __str__(self): 1752 return "%s - %s" % (self.left, self.right) 1753 1754 def visit(self, visitor, *args): 1755 return visitor.visitSub(self, *args) 1756 1757 class Subscript(Node): 1758 def __init__(self, expr, flags, subs, lineno=None): 1759 Node.__init__(self) 1760 self.expr = expr 1761 self.flags = flags 1762 self.subs = subs 1763 self.lineno = lineno 1764 1765 def getChildren(self): 1766 children = [] 1767 children.append(self.expr) 1768 children.append(self.flags) 1769 children.extend(flatten(self.subs)) 1770 return tuple(children) 1771 1772 def getChildNodes(self): 1773 nodelist = [] 1774 nodelist.append(self.expr) 1775 nodelist.extend(flatten_nodes(self.subs)) 1776 return tuple(nodelist) 1777 1778 def __repr__(self): 1779 return "Subscript(%r, %r, %r)" % (self.expr, self.flags, self.subs) 1780 1781 def __str__(self): 1782 return "%s[%s]" % (self.expr, ",".join(map(str, self.subs))) 1783 1784 def visit(self, visitor, *args): 1785 return visitor.visitSubscript(self, *args) 1786 1787 class TryExcept(Node): 1788 def __init__(self, body, handlers, else_, lineno=None): 1789 Node.__init__(self) 1790 self.body = body 1791 self.handlers = handlers 1792 self.else_ = else_ 1793 self.lineno = lineno 1794 1795 def getChildren(self): 1796 children = [] 1797 children.append(self.body) 1798 children.extend(flatten(self.handlers)) 1799 children.append(self.else_) 1800 return tuple(children) 1801 1802 def getChildNodes(self): 1803 nodelist = [] 1804 nodelist.append(self.body) 1805 nodelist.extend(flatten_nodes(self.handlers)) 1806 if self.else_ is not None: 1807 nodelist.append(self.else_) 1808 return tuple(nodelist) 1809 1810 def __repr__(self): 1811 return "TryExcept(%r, %r, %r)" % (self.body, self.handlers, self.else_) 1812 1813 def __str__(self): 1814 handlers = [ 1815 ("\nexcept%s%s:%s" % (spec and " %s" % spec or "", assign and ", %s" % assign or "", indent("\n%s" % statement))) 1816 for (spec, assign, statement) in self.handlers 1817 ] 1818 1819 return "try:%s%s%s" % ( 1820 indent("\n%s" % self.body), 1821 "".join(handlers), 1822 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1823 ) 1824 1825 def visit(self, visitor, *args): 1826 return visitor.visitTryExcept(self, *args) 1827 1828 class TryFinally(Node): 1829 def __init__(self, body, final, lineno=None): 1830 Node.__init__(self) 1831 self.body = body 1832 self.final = final 1833 self.lineno = lineno 1834 1835 def getChildren(self): 1836 return self.body, self.final 1837 1838 def getChildNodes(self): 1839 return self.body, self.final 1840 1841 def __repr__(self): 1842 return "TryFinally(%r, %r)" % (self.body, self.final) 1843 1844 def __str__(self): 1845 return "try:%s\nfinally:%s" % ( 1846 indent("\n%s" % self.body), 1847 indent("\n%s" % self.final) 1848 ) 1849 1850 def visit(self, visitor, *args): 1851 return visitor.visitTryFinally(self, *args) 1852 1853 class Tuple(Node): 1854 def __init__(self, nodes, lineno=None): 1855 Node.__init__(self) 1856 self.nodes = nodes 1857 self.lineno = lineno 1858 1859 def getChildren(self): 1860 return tuple(flatten(self.nodes)) 1861 1862 def getChildNodes(self): 1863 nodelist = [] 1864 nodelist.extend(flatten_nodes(self.nodes)) 1865 return tuple(nodelist) 1866 1867 def __repr__(self): 1868 return "Tuple(%r)" % (self.nodes,) 1869 1870 def __str__(self): 1871 return "(%s)" % ", ".join(map(str, self.nodes)) 1872 1873 def visit(self, visitor, *args): 1874 return visitor.visitTuple(self, *args) 1875 1876 class UnaryAdd(Node): 1877 def __init__(self, expr, lineno=None): 1878 Node.__init__(self) 1879 self.expr = expr 1880 self.lineno = lineno 1881 1882 def getChildren(self): 1883 return self.expr, 1884 1885 def getChildNodes(self): 1886 return self.expr, 1887 1888 def __repr__(self): 1889 return "UnaryAdd(%r)" % (self.expr,) 1890 1891 def __str__(self): 1892 return "+%s" % self.expr 1893 1894 def visit(self, visitor, *args): 1895 return visitor.visitUnaryAdd(self, *args) 1896 1897 class UnarySub(Node): 1898 def __init__(self, expr, lineno=None): 1899 Node.__init__(self) 1900 self.expr = expr 1901 self.lineno = lineno 1902 1903 def getChildren(self): 1904 return self.expr, 1905 1906 def getChildNodes(self): 1907 return self.expr, 1908 1909 def __repr__(self): 1910 return "UnarySub(%r)" % (self.expr,) 1911 1912 def __str__(self): 1913 return "-%s" % self.expr 1914 1915 def visit(self, visitor, *args): 1916 return visitor.visitUnarySub(self, *args) 1917 1918 class While(Node): 1919 def __init__(self, test, body, else_, lineno=None): 1920 Node.__init__(self) 1921 self.test = test 1922 self.body = body 1923 self.else_ = else_ 1924 self.lineno = lineno 1925 1926 def getChildren(self): 1927 children = [] 1928 children.append(self.test) 1929 children.append(self.body) 1930 children.append(self.else_) 1931 return tuple(children) 1932 1933 def getChildNodes(self): 1934 nodelist = [] 1935 nodelist.append(self.test) 1936 nodelist.append(self.body) 1937 if self.else_ is not None: 1938 nodelist.append(self.else_) 1939 return tuple(nodelist) 1940 1941 def __repr__(self): 1942 return "While(%r, %r, %r)" % (self.test, self.body, self.else_) 1943 1944 def __str__(self): 1945 return "while %s:%s%s" % ( 1946 self.test, 1947 indent("\n%s" % self.body), 1948 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1949 ) 1950 1951 def visit(self, visitor, *args): 1952 return visitor.visitWhile(self, *args) 1953 1954 class With(Node): 1955 def __init__(self, expr, vars, body, lineno=None): 1956 Node.__init__(self) 1957 self.expr = expr 1958 self.vars = vars 1959 self.body = body 1960 self.lineno = lineno 1961 1962 def getChildren(self): 1963 children = [] 1964 children.append(self.expr) 1965 children.append(self.vars) 1966 children.append(self.body) 1967 return tuple(children) 1968 1969 def getChildNodes(self): 1970 nodelist = [] 1971 nodelist.append(self.expr) 1972 if self.vars is not None: 1973 nodelist.append(self.vars) 1974 nodelist.append(self.body) 1975 return tuple(nodelist) 1976 1977 def __repr__(self): 1978 return "With(%r, %r, %r)" % (self.expr, self.vars, self.body) 1979 1980 def __str__(self): 1981 return "with %s%s:%s" % ( 1982 self.expr, 1983 self.vars and " as %s" % ", ".join(map(str, self.vars)), 1984 indent("\n%s" % self.body), 1985 ) 1986 1987 def visit(self, visitor, *args): 1988 return visitor.visitWith(self, *args) 1989 1990 class Yield(Node): 1991 def __init__(self, value, lineno=None): 1992 Node.__init__(self) 1993 self.value = value 1994 self.lineno = lineno 1995 1996 def getChildren(self): 1997 return self.value, 1998 1999 def getChildNodes(self): 2000 return self.value, 2001 2002 def __repr__(self): 2003 return "Yield(%r)" % (self.value,) 2004 2005 def __str__(self): 2006 return "yield %s" % self.value 2007 2008 def visit(self, visitor, *args): 2009 return visitor.visitYield(self, *args) 2010 2011 for name, obj in globals().items(): 2012 if isinstance(obj, type) and issubclass(obj, Node): 2013 nodes[name.lower()] = obj