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