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