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 SetComp(Node): 1235 def __init__(self, expr, quals, lineno=None): 1236 self.expr = expr 1237 self.quals = quals 1238 self.lineno = lineno 1239 1240 def getChildren(self): 1241 children = [] 1242 children.append(self.expr) 1243 children.extend(flatten(self.quals)) 1244 return tuple(children) 1245 1246 def getChildNodes(self): 1247 nodelist = [] 1248 nodelist.append(self.expr) 1249 nodelist.extend(flatten_nodes(self.quals)) 1250 return tuple(nodelist) 1251 1252 def __repr__(self): 1253 return "SetComp(%r, %r)" % (self.expr, self.quals) 1254 1255 def __str__(self): 1256 return "{%s %s}" % (self.expr, " ".join(map(str, self.quals))) 1257 1258 def visit(self, visitor, *args): 1259 return visitor.visitSetComp(self, *args) 1260 1261 class DictComp(Node): 1262 def __init__(self, key, value, quals, lineno=None): 1263 self.key = key 1264 self.value = value 1265 self.quals = quals 1266 self.lineno = lineno 1267 1268 def getChildren(self): 1269 children = [] 1270 children.append(self.key) 1271 children.append(self.value) 1272 children.extend(flatten(self.quals)) 1273 return tuple(children) 1274 1275 def getChildNodes(self): 1276 nodelist = [] 1277 nodelist.append(self.key) 1278 nodelist.append(self.value) 1279 nodelist.extend(flatten_nodes(self.quals)) 1280 return tuple(nodelist) 1281 1282 def __repr__(self): 1283 return "DictComp(%r, %r, %r)" % (self.key, self.value, self.quals) 1284 1285 def __str__(self): 1286 return "{%s : %s %s}" % (self.key, self.value, " ".join(map(str, self.quals))) 1287 1288 def visit(self, visitor, *args): 1289 return visitor.visitDictComp(self, *args) 1290 1291 class Mod(Node): 1292 def __init__(self, leftright, lineno=None): 1293 self.left = leftright[0] 1294 self.right = leftright[1] 1295 self.lineno = lineno 1296 1297 def getChildren(self): 1298 return self.left, self.right 1299 1300 def getChildNodes(self): 1301 return self.left, self.right 1302 1303 def __repr__(self): 1304 return "Mod((%r, %r))" % (self.left, self.right) 1305 1306 def __str__(self): 1307 return "%s %% %s" % (self.left, self.right) 1308 1309 def visit(self, visitor, *args): 1310 return visitor.visitMod(self, *args) 1311 1312 class Module(Node): 1313 def __init__(self, doc, node, lineno=None): 1314 self.doc = doc 1315 self.node = node 1316 self.lineno = lineno 1317 1318 def getChildren(self): 1319 return self.doc, self.node 1320 1321 def getChildNodes(self): 1322 return self.node, 1323 1324 def __repr__(self): 1325 return "Module(%r, %r)" % (self.doc, self.node) 1326 1327 def __str__(self): 1328 return "%s%s" % (self.doc and "%r\n" % self.doc or "", self.node) 1329 1330 def visit(self, visitor, *args): 1331 return visitor.visitModule(self, *args) 1332 1333 class Mul(Node): 1334 def __init__(self, leftright, lineno=None): 1335 self.left = leftright[0] 1336 self.right = leftright[1] 1337 self.lineno = lineno 1338 1339 def getChildren(self): 1340 return self.left, self.right 1341 1342 def getChildNodes(self): 1343 return self.left, self.right 1344 1345 def __repr__(self): 1346 return "Mul((%r, %r))" % (self.left, self.right) 1347 1348 def __str__(self): 1349 return "%s * %s" % (self.left, self.right) 1350 1351 def visit(self, visitor, *args): 1352 return visitor.visitMul(self, *args) 1353 1354 class Name(Node): 1355 def __init__(self, name, lineno=None): 1356 self.name = name 1357 self.lineno = lineno 1358 1359 def getChildren(self): 1360 return self.name, 1361 1362 def getChildNodes(self): 1363 return () 1364 1365 def __repr__(self): 1366 return "Name(%r)" % (self.name,) 1367 1368 def __str__(self): 1369 return str(self.name) 1370 1371 def visit(self, visitor, *args): 1372 return visitor.visitName(self, *args) 1373 1374 class Not(Node): 1375 def __init__(self, expr, lineno=None): 1376 self.expr = expr 1377 self.lineno = lineno 1378 1379 def getChildren(self): 1380 return self.expr, 1381 1382 def getChildNodes(self): 1383 return self.expr, 1384 1385 def __repr__(self): 1386 return "Not(%r)" % (self.expr,) 1387 1388 def __str__(self): 1389 return "not %s" % self.expr 1390 1391 def visit(self, visitor, *args): 1392 return visitor.visitNot(self, *args) 1393 1394 class Or(Node): 1395 def __init__(self, nodes, lineno=None): 1396 self.nodes = nodes 1397 self.lineno = lineno 1398 1399 def getChildren(self): 1400 return tuple(flatten(self.nodes)) 1401 1402 def getChildNodes(self): 1403 nodelist = [] 1404 nodelist.extend(flatten_nodes(self.nodes)) 1405 return tuple(nodelist) 1406 1407 def __repr__(self): 1408 return "Or(%r)" % (self.nodes,) 1409 1410 def __str__(self): 1411 return " or ".join(map(str, self.nodes)) 1412 1413 def visit(self, visitor, *args): 1414 return visitor.visitOr(self, *args) 1415 1416 class Pass(Node): 1417 def __init__(self, lineno=None): 1418 self.lineno = lineno 1419 1420 def getChildren(self): 1421 return () 1422 1423 def getChildNodes(self): 1424 return () 1425 1426 def __repr__(self): 1427 return "Pass()" 1428 1429 def __str__(self): 1430 return "pass" 1431 1432 def visit(self, visitor, *args): 1433 return visitor.visitPass(self, *args) 1434 1435 class Power(Node): 1436 def __init__(self, leftright, lineno=None): 1437 self.left = leftright[0] 1438 self.right = leftright[1] 1439 self.lineno = lineno 1440 1441 def getChildren(self): 1442 return self.left, self.right 1443 1444 def getChildNodes(self): 1445 return self.left, self.right 1446 1447 def __repr__(self): 1448 return "Power((%r, %r))" % (self.left, self.right) 1449 1450 def __str__(self): 1451 return "%s ** %s" % (self.left, self.right) 1452 1453 def visit(self, visitor, *args): 1454 return visitor.visitPower(self, *args) 1455 1456 class Print(Node): 1457 def __init__(self, nodes, dest, lineno=None): 1458 self.nodes = nodes 1459 self.dest = dest 1460 self.lineno = lineno 1461 1462 def getChildren(self): 1463 children = [] 1464 children.extend(flatten(self.nodes)) 1465 children.append(self.dest) 1466 return tuple(children) 1467 1468 def getChildNodes(self): 1469 nodelist = [] 1470 nodelist.extend(flatten_nodes(self.nodes)) 1471 if self.dest is not None: 1472 nodelist.append(self.dest) 1473 return tuple(nodelist) 1474 1475 def __repr__(self): 1476 return "Print(%r, %r)" % (self.nodes, self.dest) 1477 1478 def __str__(self): 1479 dest = self.dest and [">>%s" % self.dest] or [] 1480 return "print %s," % ", ".join(map(str, dest + self.nodes)) 1481 1482 def visit(self, visitor, *args): 1483 return visitor.visitPrint(self, *args) 1484 1485 class Printnl(Node): 1486 def __init__(self, nodes, dest, lineno=None): 1487 self.nodes = nodes 1488 self.dest = dest 1489 self.lineno = lineno 1490 1491 def getChildren(self): 1492 children = [] 1493 children.extend(flatten(self.nodes)) 1494 children.append(self.dest) 1495 return tuple(children) 1496 1497 def getChildNodes(self): 1498 nodelist = [] 1499 nodelist.extend(flatten_nodes(self.nodes)) 1500 if self.dest is not None: 1501 nodelist.append(self.dest) 1502 return tuple(nodelist) 1503 1504 def __repr__(self): 1505 return "Printnl(%r, %r)" % (self.nodes, self.dest) 1506 1507 def __str__(self): 1508 dest = self.dest and [">>%s" % self.dest] or [] 1509 return "print %s" % ", ".join(map(str, dest + self.nodes)) 1510 1511 def visit(self, visitor, *args): 1512 return visitor.visitPrintnl(self, *args) 1513 1514 class Raise(Node): 1515 def __init__(self, expr1, expr2, expr3, lineno=None): 1516 self.expr1 = expr1 1517 self.expr2 = expr2 1518 self.expr3 = expr3 1519 self.lineno = lineno 1520 1521 def getChildren(self): 1522 children = [] 1523 children.append(self.expr1) 1524 children.append(self.expr2) 1525 children.append(self.expr3) 1526 return tuple(children) 1527 1528 def getChildNodes(self): 1529 nodelist = [] 1530 if self.expr1 is not None: 1531 nodelist.append(self.expr1) 1532 if self.expr2 is not None: 1533 nodelist.append(self.expr2) 1534 if self.expr3 is not None: 1535 nodelist.append(self.expr3) 1536 return tuple(nodelist) 1537 1538 def __repr__(self): 1539 return "Raise(%r, %r, %r)" % (self.expr1, self.expr2, self.expr3) 1540 1541 def __str__(self): 1542 args = self.expr1 and [self.expr1] or [] 1543 args += self.expr2 and [self.expr2] or [] 1544 args += self.expr3 and [self.expr3] or [] 1545 return "raise %s" % ", ".join(map(str, args)) 1546 1547 def visit(self, visitor, *args): 1548 return visitor.visitRaise(self, *args) 1549 1550 class Return(Node): 1551 def __init__(self, value, lineno=None): 1552 self.value = value 1553 self.lineno = lineno 1554 1555 def getChildren(self): 1556 return self.value, 1557 1558 def getChildNodes(self): 1559 return self.value, 1560 1561 def __repr__(self): 1562 return "Return(%r)" % (self.value,) 1563 1564 def __str__(self): 1565 return "return %s" % self.value 1566 1567 def visit(self, visitor, *args): 1568 return visitor.visitReturn(self, *args) 1569 1570 class RightShift(Node): 1571 def __init__(self, leftright, lineno=None): 1572 self.left = leftright[0] 1573 self.right = leftright[1] 1574 self.lineno = lineno 1575 1576 def getChildren(self): 1577 return self.left, self.right 1578 1579 def getChildNodes(self): 1580 return self.left, self.right 1581 1582 def __repr__(self): 1583 return "RightShift((%r, %r))" % (self.left, self.right) 1584 1585 def __str__(self): 1586 return "%s >> %s" % (self.left, self.right) 1587 1588 def visit(self, visitor, *args): 1589 return visitor.visitRightShift(self, *args) 1590 1591 class Set(Node): 1592 def __init__(self, nodes, lineno=None): 1593 self.nodes = nodes 1594 self.lineno = lineno 1595 1596 def getChildren(self): 1597 return tuple(flatten(self.nodes)) 1598 1599 def getChildNodes(self): 1600 nodelist = [] 1601 nodelist.extend(flatten_nodes(self.nodes)) 1602 return tuple(nodelist) 1603 1604 def __repr__(self): 1605 return "Set(%r)" % (self.nodes,) 1606 1607 def __str__(self): 1608 return "{%s}" % ", ".join(map(str, self.nodes)) 1609 1610 def visit(self, visitor, *args): 1611 return visitor.visitSet(self, *args) 1612 1613 class Slice(Node): 1614 def __init__(self, expr, flags, lower, upper, lineno=None): 1615 self.expr = expr 1616 self.flags = flags 1617 self.lower = lower 1618 self.upper = upper 1619 self.lineno = lineno 1620 1621 def getChildren(self): 1622 children = [] 1623 children.append(self.expr) 1624 children.append(self.flags) 1625 children.append(self.lower) 1626 children.append(self.upper) 1627 return tuple(children) 1628 1629 def getChildNodes(self): 1630 nodelist = [] 1631 nodelist.append(self.expr) 1632 if self.lower is not None: 1633 nodelist.append(self.lower) 1634 if self.upper is not None: 1635 nodelist.append(self.upper) 1636 return tuple(nodelist) 1637 1638 def __repr__(self): 1639 return "Slice(%r, %r, %r, %r)" % (self.expr, self.flags, self.lower, self.upper) 1640 1641 def __str__(self): 1642 args = [] 1643 args = self.lower is not None and [self.lower] or [] 1644 args = self.upper is not None and [self.upper] or [] 1645 return "%s[%s]" % (self.expr, ":".join(map(str, args))) 1646 1647 def visit(self, visitor, *args): 1648 return visitor.visitSlice(self, *args) 1649 1650 class Sliceobj(Node): 1651 def __init__(self, nodes, lineno=None): 1652 self.nodes = nodes 1653 self.lineno = lineno 1654 1655 def getChildren(self): 1656 return tuple(flatten(self.nodes)) 1657 1658 def getChildNodes(self): 1659 nodelist = [] 1660 nodelist.extend(flatten_nodes(self.nodes)) 1661 return tuple(nodelist) 1662 1663 def __repr__(self): 1664 return "Sliceobj(%r)" % (self.nodes,) 1665 1666 def __str__(self): 1667 return ":".join(map(str, self.nodes)) 1668 1669 def visit(self, visitor, *args): 1670 return visitor.visitSliceobj(self, *args) 1671 1672 class Stmt(Node): 1673 def __init__(self, nodes, lineno=None): 1674 self.nodes = nodes 1675 self.lineno = lineno 1676 1677 def getChildren(self): 1678 return tuple(flatten(self.nodes)) 1679 1680 def getChildNodes(self): 1681 nodelist = [] 1682 nodelist.extend(flatten_nodes(self.nodes)) 1683 return tuple(nodelist) 1684 1685 def __repr__(self): 1686 return "Stmt(%r)" % (self.nodes,) 1687 1688 def __str__(self): 1689 return "\n".join(map(str, self.nodes)) 1690 1691 def visit(self, visitor, *args): 1692 return visitor.visitStmt(self, *args) 1693 1694 class Sub(Node): 1695 def __init__(self, leftright, lineno=None): 1696 self.left = leftright[0] 1697 self.right = leftright[1] 1698 self.lineno = lineno 1699 1700 def getChildren(self): 1701 return self.left, self.right 1702 1703 def getChildNodes(self): 1704 return self.left, self.right 1705 1706 def __repr__(self): 1707 return "Sub((%r, %r))" % (self.left, self.right) 1708 1709 def __str__(self): 1710 return "%s - %s" % (self.left, self.right) 1711 1712 def visit(self, visitor, *args): 1713 return visitor.visitSub(self, *args) 1714 1715 class Subscript(Node): 1716 def __init__(self, expr, flags, subs, lineno=None): 1717 self.expr = expr 1718 self.flags = flags 1719 self.subs = subs 1720 self.lineno = lineno 1721 1722 def getChildren(self): 1723 children = [] 1724 children.append(self.expr) 1725 children.append(self.flags) 1726 children.extend(flatten(self.subs)) 1727 return tuple(children) 1728 1729 def getChildNodes(self): 1730 nodelist = [] 1731 nodelist.append(self.expr) 1732 nodelist.extend(flatten_nodes(self.subs)) 1733 return tuple(nodelist) 1734 1735 def __repr__(self): 1736 return "Subscript(%r, %r, %r)" % (self.expr, self.flags, self.subs) 1737 1738 def __str__(self): 1739 return "%s[%s]" % (self.expr, ",".join(map(str, self.subs))) 1740 1741 def visit(self, visitor, *args): 1742 return visitor.visitSubscript(self, *args) 1743 1744 class TryExcept(Node): 1745 def __init__(self, body, handlers, else_, lineno=None): 1746 self.body = body 1747 self.handlers = handlers 1748 self.else_ = else_ 1749 self.lineno = lineno 1750 1751 def getChildren(self): 1752 children = [] 1753 children.append(self.body) 1754 children.extend(flatten(self.handlers)) 1755 children.append(self.else_) 1756 return tuple(children) 1757 1758 def getChildNodes(self): 1759 nodelist = [] 1760 nodelist.append(self.body) 1761 nodelist.extend(flatten_nodes(self.handlers)) 1762 if self.else_ is not None: 1763 nodelist.append(self.else_) 1764 return tuple(nodelist) 1765 1766 def __repr__(self): 1767 return "TryExcept(%r, %r, %r)" % (self.body, self.handlers, self.else_) 1768 1769 def __str__(self): 1770 handlers = [ 1771 ("\nexcept%s%s:%s" % (spec and " %s" % spec or "", assign and ", %s" % assign or "", indent("\n%s" % statement))) 1772 for (spec, assign, statement) in self.handlers 1773 ] 1774 1775 return "try:%s%s%s" % ( 1776 indent("\n%s" % self.body), 1777 "".join(handlers), 1778 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1779 ) 1780 1781 def visit(self, visitor, *args): 1782 return visitor.visitTryExcept(self, *args) 1783 1784 class TryFinally(Node): 1785 def __init__(self, body, final, lineno=None): 1786 self.body = body 1787 self.final = final 1788 self.lineno = lineno 1789 1790 def getChildren(self): 1791 return self.body, self.final 1792 1793 def getChildNodes(self): 1794 return self.body, self.final 1795 1796 def __repr__(self): 1797 return "TryFinally(%r, %r)" % (self.body, self.final) 1798 1799 def __str__(self): 1800 return "try:%s\nfinally:%s" % ( 1801 indent("\n%s" % self.body), 1802 indent("\n%s" % self.final) 1803 ) 1804 1805 def visit(self, visitor, *args): 1806 return visitor.visitTryFinally(self, *args) 1807 1808 class Tuple(Node): 1809 def __init__(self, nodes, lineno=None): 1810 self.nodes = nodes 1811 self.lineno = lineno 1812 1813 def getChildren(self): 1814 return tuple(flatten(self.nodes)) 1815 1816 def getChildNodes(self): 1817 nodelist = [] 1818 nodelist.extend(flatten_nodes(self.nodes)) 1819 return tuple(nodelist) 1820 1821 def __repr__(self): 1822 return "Tuple(%r)" % (self.nodes,) 1823 1824 def __str__(self): 1825 return "(%s)" % ", ".join(map(str, self.nodes)) 1826 1827 def visit(self, visitor, *args): 1828 return visitor.visitTuple(self, *args) 1829 1830 class UnaryAdd(Node): 1831 def __init__(self, expr, lineno=None): 1832 self.expr = expr 1833 self.lineno = lineno 1834 1835 def getChildren(self): 1836 return self.expr, 1837 1838 def getChildNodes(self): 1839 return self.expr, 1840 1841 def __repr__(self): 1842 return "UnaryAdd(%r)" % (self.expr,) 1843 1844 def __str__(self): 1845 return "+%s" % self.expr 1846 1847 def visit(self, visitor, *args): 1848 return visitor.visitUnaryAdd(self, *args) 1849 1850 class UnarySub(Node): 1851 def __init__(self, expr, lineno=None): 1852 self.expr = expr 1853 self.lineno = lineno 1854 1855 def getChildren(self): 1856 return self.expr, 1857 1858 def getChildNodes(self): 1859 return self.expr, 1860 1861 def __repr__(self): 1862 return "UnarySub(%r)" % (self.expr,) 1863 1864 def __str__(self): 1865 return "-%s" % self.expr 1866 1867 def visit(self, visitor, *args): 1868 return visitor.visitUnarySub(self, *args) 1869 1870 class While(Node): 1871 def __init__(self, test, body, else_, lineno=None): 1872 self.test = test 1873 self.body = body 1874 self.else_ = else_ 1875 self.lineno = lineno 1876 1877 def getChildren(self): 1878 children = [] 1879 children.append(self.test) 1880 children.append(self.body) 1881 children.append(self.else_) 1882 return tuple(children) 1883 1884 def getChildNodes(self): 1885 nodelist = [] 1886 nodelist.append(self.test) 1887 nodelist.append(self.body) 1888 if self.else_ is not None: 1889 nodelist.append(self.else_) 1890 return tuple(nodelist) 1891 1892 def __repr__(self): 1893 return "While(%r, %r, %r)" % (self.test, self.body, self.else_) 1894 1895 def __str__(self): 1896 return "while %s:%s%s" % ( 1897 self.test, 1898 indent("\n%s" % self.body), 1899 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1900 ) 1901 1902 def visit(self, visitor, *args): 1903 return visitor.visitWhile(self, *args) 1904 1905 class With(Node): 1906 def __init__(self, expr, vars, body, lineno=None): 1907 self.expr = expr 1908 self.vars = vars 1909 self.body = body 1910 self.lineno = lineno 1911 1912 def getChildren(self): 1913 children = [] 1914 children.append(self.expr) 1915 children.append(self.vars) 1916 children.append(self.body) 1917 return tuple(children) 1918 1919 def getChildNodes(self): 1920 nodelist = [] 1921 nodelist.append(self.expr) 1922 if self.vars is not None: 1923 nodelist.append(self.vars) 1924 nodelist.append(self.body) 1925 return tuple(nodelist) 1926 1927 def __repr__(self): 1928 return "With(%r, %r, %r)" % (self.expr, self.vars, self.body) 1929 1930 def __str__(self): 1931 return "with %s%s:%s" % ( 1932 self.expr, 1933 self.vars and " as %s" % ", ".join(map(str, self.vars)), 1934 indent("\n%s" % self.body), 1935 ) 1936 1937 def visit(self, visitor, *args): 1938 return visitor.visitWith(self, *args) 1939 1940 class Yield(Node): 1941 def __init__(self, value, lineno=None): 1942 self.value = value 1943 self.lineno = lineno 1944 1945 def getChildren(self): 1946 return self.value, 1947 1948 def getChildNodes(self): 1949 return self.value, 1950 1951 def __repr__(self): 1952 return "Yield(%r)" % (self.value,) 1953 1954 def __str__(self): 1955 return "yield %s" % self.value 1956 1957 def visit(self, visitor, *args): 1958 return visitor.visitYield(self, *args) 1959 1960 for name, obj in globals().items(): 1961 if isinstance(obj, type) and issubclass(obj, Node): 1962 nodes[name.lower()] = obj