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 Mod(Node, OperatorUser): 1417 def __init__(self, leftright, lineno=None): 1418 Node.__init__(self) 1419 OperatorUser.__init__(self) 1420 self.left = leftright[0] 1421 self.right = leftright[1] 1422 self.lineno = lineno 1423 1424 def getChildren(self): 1425 return self.left, self.right 1426 1427 def getChildNodes(self): 1428 return self.left, self.right 1429 1430 def __repr__(self): 1431 return "Mod((%r, %r))" % (self.left, self.right) 1432 1433 def __str__(self): 1434 return "(%s %% %s)" % (self.left, self.right) 1435 1436 def visit(self, visitor, *args): 1437 return visitor.visitMod(self, *args) 1438 1439 class Module(Node): 1440 def __init__(self, doc, node, lineno=None): 1441 Node.__init__(self) 1442 self.doc = doc 1443 self.node = node 1444 self.lineno = lineno 1445 1446 def getChildren(self): 1447 return self.doc, self.node 1448 1449 def getChildNodes(self): 1450 return self.node, 1451 1452 def __repr__(self): 1453 return "Module(%r, %r)" % (self.doc, self.node) 1454 1455 def __str__(self): 1456 return "%s%s" % (self.doc and "%s\n\n" % docstring(self.doc) or "", self.node) 1457 1458 def visit(self, visitor, *args): 1459 return visitor.visitModule(self, *args) 1460 1461 class Mul(Node, OperatorUser): 1462 def __init__(self, leftright, lineno=None): 1463 Node.__init__(self) 1464 OperatorUser.__init__(self) 1465 self.left = leftright[0] 1466 self.right = leftright[1] 1467 self.lineno = lineno 1468 1469 def getChildren(self): 1470 return self.left, self.right 1471 1472 def getChildNodes(self): 1473 return self.left, self.right 1474 1475 def __repr__(self): 1476 return "Mul((%r, %r))" % (self.left, self.right) 1477 1478 def __str__(self): 1479 return "(%s * %s)" % (self.left, self.right) 1480 1481 def visit(self, visitor, *args): 1482 return visitor.visitMul(self, *args) 1483 1484 class Name(Node, AttributeAccessor): 1485 def __init__(self, name, lineno=None): 1486 Node.__init__(self) 1487 AttributeAccessor.__init__(self) 1488 self.name = name 1489 self.lineno = lineno 1490 1491 # Additional annotations. 1492 1493 self._scope = None 1494 1495 def getChildren(self): 1496 return self.name, 1497 1498 def getChildNodes(self): 1499 return () 1500 1501 def __repr__(self): 1502 return "Name(%r)" % (self.name,) 1503 1504 def __str__(self): 1505 return str(self.name) 1506 1507 def visit(self, visitor, *args): 1508 return visitor.visitName(self, *args) 1509 1510 class Not(Node): 1511 def __init__(self, expr, lineno=None): 1512 Node.__init__(self) 1513 self.expr = expr 1514 self.lineno = lineno 1515 1516 def getChildren(self): 1517 return self.expr, 1518 1519 def getChildNodes(self): 1520 return self.expr, 1521 1522 def __repr__(self): 1523 return "Not(%r)" % (self.expr,) 1524 1525 def __str__(self): 1526 return "not %s" % self.expr 1527 1528 def visit(self, visitor, *args): 1529 return visitor.visitNot(self, *args) 1530 1531 class Or(Node): 1532 def __init__(self, nodes, lineno=None): 1533 Node.__init__(self) 1534 self.nodes = nodes 1535 self.lineno = lineno 1536 1537 def getChildren(self): 1538 return tuple(flatten(self.nodes)) 1539 1540 def getChildNodes(self): 1541 nodelist = [] 1542 nodelist.extend(flatten_nodes(self.nodes)) 1543 return tuple(nodelist) 1544 1545 def __repr__(self): 1546 return "Or(%r)" % (self.nodes,) 1547 1548 def __str__(self): 1549 return "(%s)" % " or ".join(map(str, self.nodes)) 1550 1551 def visit(self, visitor, *args): 1552 return visitor.visitOr(self, *args) 1553 1554 class Pass(Node): 1555 def __init__(self, lineno=None): 1556 Node.__init__(self) 1557 self.lineno = lineno 1558 1559 def getChildren(self): 1560 return () 1561 1562 def getChildNodes(self): 1563 return () 1564 1565 def __repr__(self): 1566 return "Pass()" 1567 1568 def __str__(self): 1569 return "pass" 1570 1571 def visit(self, visitor, *args): 1572 return visitor.visitPass(self, *args) 1573 1574 class Power(Node, OperatorUser): 1575 def __init__(self, leftright, lineno=None): 1576 Node.__init__(self) 1577 OperatorUser.__init__(self) 1578 self.left = leftright[0] 1579 self.right = leftright[1] 1580 self.lineno = lineno 1581 1582 def getChildren(self): 1583 return self.left, self.right 1584 1585 def getChildNodes(self): 1586 return self.left, self.right 1587 1588 def __repr__(self): 1589 return "Power((%r, %r))" % (self.left, self.right) 1590 1591 def __str__(self): 1592 return "(%s ** %s)" % (self.left, self.right) 1593 1594 def visit(self, visitor, *args): 1595 return visitor.visitPower(self, *args) 1596 1597 class Print(Node): 1598 def __init__(self, nodes, dest, lineno=None): 1599 Node.__init__(self) 1600 self.nodes = nodes 1601 self.dest = dest 1602 self.lineno = lineno 1603 1604 def getChildren(self): 1605 children = [] 1606 children.extend(flatten(self.nodes)) 1607 children.append(self.dest) 1608 return tuple(children) 1609 1610 def getChildNodes(self): 1611 nodelist = [] 1612 nodelist.extend(flatten_nodes(self.nodes)) 1613 if self.dest is not None: 1614 nodelist.append(self.dest) 1615 return tuple(nodelist) 1616 1617 def __repr__(self): 1618 return "Print(%r, %r)" % (self.nodes, self.dest) 1619 1620 def __str__(self): 1621 dest = self.dest and [">>%s" % self.dest] or [] 1622 return "print %s," % ", ".join(map(str, dest + self.nodes)) 1623 1624 def visit(self, visitor, *args): 1625 return visitor.visitPrint(self, *args) 1626 1627 class Printnl(Node): 1628 def __init__(self, nodes, dest, lineno=None): 1629 Node.__init__(self) 1630 self.nodes = nodes 1631 self.dest = dest 1632 self.lineno = lineno 1633 1634 def getChildren(self): 1635 children = [] 1636 children.extend(flatten(self.nodes)) 1637 children.append(self.dest) 1638 return tuple(children) 1639 1640 def getChildNodes(self): 1641 nodelist = [] 1642 nodelist.extend(flatten_nodes(self.nodes)) 1643 if self.dest is not None: 1644 nodelist.append(self.dest) 1645 return tuple(nodelist) 1646 1647 def __repr__(self): 1648 return "Printnl(%r, %r)" % (self.nodes, self.dest) 1649 1650 def __str__(self): 1651 dest = self.dest and [">>%s" % self.dest] or [] 1652 return "print %s" % ", ".join(map(str, dest + self.nodes)) 1653 1654 def visit(self, visitor, *args): 1655 return visitor.visitPrintnl(self, *args) 1656 1657 class Raise(Node): 1658 def __init__(self, expr1, expr2, expr3, lineno=None): 1659 Node.__init__(self) 1660 self.expr1 = expr1 1661 self.expr2 = expr2 1662 self.expr3 = expr3 1663 self.lineno = lineno 1664 1665 def getChildren(self): 1666 children = [] 1667 children.append(self.expr1) 1668 children.append(self.expr2) 1669 children.append(self.expr3) 1670 return tuple(children) 1671 1672 def getChildNodes(self): 1673 nodelist = [] 1674 if self.expr1 is not None: 1675 nodelist.append(self.expr1) 1676 if self.expr2 is not None: 1677 nodelist.append(self.expr2) 1678 if self.expr3 is not None: 1679 nodelist.append(self.expr3) 1680 return tuple(nodelist) 1681 1682 def __repr__(self): 1683 return "Raise(%r, %r, %r)" % (self.expr1, self.expr2, self.expr3) 1684 1685 def __str__(self): 1686 args = self.expr1 and [self.expr1] or [] 1687 args += self.expr2 and [self.expr2] or [] 1688 args += self.expr3 and [self.expr3] or [] 1689 return "raise %s" % ", ".join(map(str, args)) 1690 1691 def visit(self, visitor, *args): 1692 return visitor.visitRaise(self, *args) 1693 1694 class Return(Node): 1695 def __init__(self, value, lineno=None): 1696 Node.__init__(self) 1697 self.value = value 1698 self.lineno = lineno 1699 1700 def getChildren(self): 1701 return self.value, 1702 1703 def getChildNodes(self): 1704 return self.value, 1705 1706 def __repr__(self): 1707 return "Return(%r)" % (self.value,) 1708 1709 def __str__(self): 1710 return "return %s" % self.value 1711 1712 def visit(self, visitor, *args): 1713 return visitor.visitReturn(self, *args) 1714 1715 class RightShift(Node, OperatorUser): 1716 def __init__(self, leftright, lineno=None): 1717 Node.__init__(self) 1718 OperatorUser.__init__(self) 1719 self.left = leftright[0] 1720 self.right = leftright[1] 1721 self.lineno = lineno 1722 1723 def getChildren(self): 1724 return self.left, self.right 1725 1726 def getChildNodes(self): 1727 return self.left, self.right 1728 1729 def __repr__(self): 1730 return "RightShift((%r, %r))" % (self.left, self.right) 1731 1732 def __str__(self): 1733 return "(%s >> %s)" % (self.left, self.right) 1734 1735 def visit(self, visitor, *args): 1736 return visitor.visitRightShift(self, *args) 1737 1738 class Slice(Node, OperatorUser): 1739 def __init__(self, expr, flags, lower, upper, lineno=None): 1740 Node.__init__(self) 1741 OperatorUser.__init__(self) 1742 self.expr = expr 1743 self.flags = flags 1744 self.lower = lower 1745 self.upper = upper 1746 self.lineno = lineno 1747 1748 def getChildren(self): 1749 children = [] 1750 children.append(self.expr) 1751 children.append(self.flags) 1752 children.append(self.lower) 1753 children.append(self.upper) 1754 return tuple(children) 1755 1756 def getChildNodes(self): 1757 nodelist = [] 1758 nodelist.append(self.expr) 1759 if self.lower is not None: 1760 nodelist.append(self.lower) 1761 if self.upper is not None: 1762 nodelist.append(self.upper) 1763 return tuple(nodelist) 1764 1765 def __repr__(self): 1766 return "Slice(%r, %r, %r, %r)" % (self.expr, self.flags, self.lower, self.upper) 1767 1768 def __str__(self): 1769 args = [] 1770 args = self.lower is not None and [self.lower] or [] 1771 args = self.upper is not None and [self.upper] or [] 1772 return "%s[%s]" % (self.expr, ":".join(map(str, args))) 1773 1774 def visit(self, visitor, *args): 1775 return visitor.visitSlice(self, *args) 1776 1777 class Sliceobj(Node): 1778 def __init__(self, nodes, lineno=None): 1779 Node.__init__(self) 1780 self.nodes = nodes 1781 self.lineno = lineno 1782 1783 def getChildren(self): 1784 return tuple(flatten(self.nodes)) 1785 1786 def getChildNodes(self): 1787 nodelist = [] 1788 nodelist.extend(flatten_nodes(self.nodes)) 1789 return tuple(nodelist) 1790 1791 def __repr__(self): 1792 return "Sliceobj(%r)" % (self.nodes,) 1793 1794 def __str__(self): 1795 return ":".join(map(str, self.nodes)) 1796 1797 def visit(self, visitor, *args): 1798 return visitor.visitSliceobj(self, *args) 1799 1800 class Stmt(Node): 1801 def __init__(self, nodes, lineno=None): 1802 Node.__init__(self) 1803 self.nodes = nodes 1804 self.lineno = lineno 1805 1806 def getChildren(self): 1807 return tuple(flatten(self.nodes)) 1808 1809 def getChildNodes(self): 1810 nodelist = [] 1811 nodelist.extend(flatten_nodes(self.nodes)) 1812 return tuple(nodelist) 1813 1814 def __repr__(self): 1815 return "Stmt(%r)" % (self.nodes,) 1816 1817 def __str__(self): 1818 nodes = flatten_statement(self.nodes) 1819 return "\n".join(map(str, nodes or [Pass()])) 1820 1821 def visit(self, visitor, *args): 1822 return visitor.visitStmt(self, *args) 1823 1824 class Sub(Node, OperatorUser): 1825 def __init__(self, leftright, lineno=None): 1826 Node.__init__(self) 1827 OperatorUser.__init__(self) 1828 self.left = leftright[0] 1829 self.right = leftright[1] 1830 self.lineno = lineno 1831 1832 def getChildren(self): 1833 return self.left, self.right 1834 1835 def getChildNodes(self): 1836 return self.left, self.right 1837 1838 def __repr__(self): 1839 return "Sub((%r, %r))" % (self.left, self.right) 1840 1841 def __str__(self): 1842 return "(%s - %s)" % (self.left, self.right) 1843 1844 def visit(self, visitor, *args): 1845 return visitor.visitSub(self, *args) 1846 1847 class Subscript(Node, OperatorUser): 1848 def __init__(self, expr, flags, subs, lineno=None): 1849 Node.__init__(self) 1850 OperatorUser.__init__(self) 1851 self.expr = expr 1852 self.flags = flags 1853 self.subs = subs 1854 self.lineno = lineno 1855 1856 # Additional annotations. 1857 1858 self._expr = None 1859 1860 def getChildren(self): 1861 children = [] 1862 children.append(self.expr) 1863 children.append(self.flags) 1864 children.extend(flatten(self.subs)) 1865 return tuple(children) 1866 1867 def getChildNodes(self): 1868 nodelist = [] 1869 nodelist.append(self.expr) 1870 nodelist.extend(flatten_nodes(self.subs)) 1871 return tuple(nodelist) 1872 1873 def __repr__(self): 1874 return "Subscript(%r, %r, %r)" % (self.expr, self.flags, self.subs) 1875 1876 def __str__(self): 1877 return "%s[%s]" % (self.expr, ",".join(map(str, self.subs))) 1878 1879 def visit(self, visitor, *args): 1880 return visitor.visitSubscript(self, *args) 1881 1882 class TryExcept(Node): 1883 def __init__(self, body, handlers, else_, lineno=None): 1884 Node.__init__(self) 1885 self.body = body 1886 self.handlers = handlers 1887 self.else_ = else_ 1888 self.lineno = lineno 1889 1890 def getChildren(self): 1891 children = [] 1892 children.append(self.body) 1893 children.extend(flatten(self.handlers)) 1894 children.append(self.else_) 1895 return tuple(children) 1896 1897 def getChildNodes(self): 1898 nodelist = [] 1899 nodelist.append(self.body) 1900 nodelist.extend(flatten_nodes(self.handlers)) 1901 if self.else_ is not None: 1902 nodelist.append(self.else_) 1903 return tuple(nodelist) 1904 1905 def __repr__(self): 1906 return "TryExcept(%r, %r, %r)" % (self.body, self.handlers, self.else_) 1907 1908 def __str__(self): 1909 handlers = [ 1910 ("\nexcept%s%s:%s" % (spec and " %s" % spec or "", assign and ", %s" % assign or "", indent("\n%s" % statement))) 1911 for (spec, assign, statement) in self.handlers 1912 ] 1913 1914 return "try:%s%s%s" % ( 1915 indent("\n%s" % self.body), 1916 "".join(handlers), 1917 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1918 ) 1919 1920 def visit(self, visitor, *args): 1921 return visitor.visitTryExcept(self, *args) 1922 1923 class TryFinally(Node): 1924 def __init__(self, body, final, lineno=None): 1925 Node.__init__(self) 1926 self.body = body 1927 self.final = final 1928 self.lineno = lineno 1929 1930 def getChildren(self): 1931 return self.body, self.final 1932 1933 def getChildNodes(self): 1934 return self.body, self.final 1935 1936 def __repr__(self): 1937 return "TryFinally(%r, %r)" % (self.body, self.final) 1938 1939 def __str__(self): 1940 return "try:%s\nfinally:%s" % ( 1941 indent("\n%s" % self.body), 1942 indent("\n%s" % self.final) 1943 ) 1944 1945 def visit(self, visitor, *args): 1946 return visitor.visitTryFinally(self, *args) 1947 1948 class Tuple(Node): 1949 def __init__(self, nodes, lineno=None): 1950 Node.__init__(self) 1951 self.nodes = nodes 1952 self.lineno = lineno 1953 1954 def getChildren(self): 1955 return tuple(flatten(self.nodes)) 1956 1957 def getChildNodes(self): 1958 nodelist = [] 1959 nodelist.extend(flatten_nodes(self.nodes)) 1960 return tuple(nodelist) 1961 1962 def __repr__(self): 1963 return "Tuple(%r)" % (self.nodes,) 1964 1965 def __str__(self): 1966 return "(%s)" % ", ".join(map(str, self.nodes)) 1967 1968 def visit(self, visitor, *args): 1969 return visitor.visitTuple(self, *args) 1970 1971 class UnaryAdd(Node, OperatorUser): 1972 def __init__(self, expr, lineno=None): 1973 Node.__init__(self) 1974 OperatorUser.__init__(self) 1975 self.expr = expr 1976 self.lineno = lineno 1977 1978 def getChildren(self): 1979 return self.expr, 1980 1981 def getChildNodes(self): 1982 return self.expr, 1983 1984 def __repr__(self): 1985 return "UnaryAdd(%r)" % (self.expr,) 1986 1987 def __str__(self): 1988 return "+%s" % self.expr 1989 1990 def visit(self, visitor, *args): 1991 return visitor.visitUnaryAdd(self, *args) 1992 1993 class UnarySub(Node, OperatorUser): 1994 def __init__(self, expr, lineno=None): 1995 Node.__init__(self) 1996 OperatorUser.__init__(self) 1997 self.expr = expr 1998 self.lineno = lineno 1999 2000 def getChildren(self): 2001 return self.expr, 2002 2003 def getChildNodes(self): 2004 return self.expr, 2005 2006 def __repr__(self): 2007 return "UnarySub(%r)" % (self.expr,) 2008 2009 def __str__(self): 2010 return "-%s" % self.expr 2011 2012 def visit(self, visitor, *args): 2013 return visitor.visitUnarySub(self, *args) 2014 2015 class While(Node): 2016 def __init__(self, test, body, else_, lineno=None): 2017 Node.__init__(self) 2018 self.test = test 2019 self.body = body 2020 self.else_ = else_ 2021 self.lineno = lineno 2022 2023 def getChildren(self): 2024 children = [] 2025 children.append(self.test) 2026 children.append(self.body) 2027 children.append(self.else_) 2028 return tuple(children) 2029 2030 def getChildNodes(self): 2031 nodelist = [] 2032 nodelist.append(self.test) 2033 nodelist.append(self.body) 2034 if self.else_ is not None: 2035 nodelist.append(self.else_) 2036 return tuple(nodelist) 2037 2038 def __repr__(self): 2039 return "While(%r, %r, %r)" % (self.test, self.body, self.else_) 2040 2041 def __str__(self): 2042 return "while %s:%s%s" % ( 2043 self.test, 2044 indent("\n%s" % self.body), 2045 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 2046 ) 2047 2048 def visit(self, visitor, *args): 2049 return visitor.visitWhile(self, *args) 2050 2051 class With(Node): 2052 def __init__(self, expr, vars, body, lineno=None): 2053 Node.__init__(self) 2054 self.expr = expr 2055 self.vars = vars 2056 self.body = body 2057 self.lineno = lineno 2058 2059 def getChildren(self): 2060 children = [] 2061 children.append(self.expr) 2062 children.append(self.vars) 2063 children.append(self.body) 2064 return tuple(children) 2065 2066 def getChildNodes(self): 2067 nodelist = [] 2068 nodelist.append(self.expr) 2069 if self.vars is not None: 2070 nodelist.append(self.vars) 2071 nodelist.append(self.body) 2072 return tuple(nodelist) 2073 2074 def __repr__(self): 2075 return "With(%r, %r, %r)" % (self.expr, self.vars, self.body) 2076 2077 def __str__(self): 2078 return "with %s%s:%s" % ( 2079 self.expr, 2080 self.vars and (" as %s" % self.vars) or "", 2081 indent("\n%s" % self.body), 2082 ) 2083 2084 def visit(self, visitor, *args): 2085 return visitor.visitWith(self, *args) 2086 2087 class Yield(Node): 2088 def __init__(self, value, lineno=None): 2089 Node.__init__(self) 2090 self.value = value 2091 self.lineno = lineno 2092 2093 def getChildren(self): 2094 return self.value, 2095 2096 def getChildNodes(self): 2097 return self.value, 2098 2099 def __repr__(self): 2100 return "Yield(%r)" % (self.value,) 2101 2102 def __str__(self): 2103 return "yield %s" % self.value 2104 2105 def visit(self, visitor, *args): 2106 return visitor.visitYield(self, *args) 2107 2108 for name, obj in globals().items(): 2109 if isinstance(obj, type) and issubclass(obj, Node): 2110 nodes[name.lower()] = obj