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