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