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