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