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