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