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