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