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