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