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