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