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 nodes = {} 22 23 class Node: 24 """Abstract base class for ast nodes.""" 25 def getChildren(self): 26 pass # implemented by subclasses 27 def __iter__(self): 28 for n in self.getChildren(): 29 yield n 30 def asList(self): # for backwards compatibility 31 return self.getChildren() 32 def getChildNodes(self): 33 pass # implemented by subclasses 34 35 class EmptyNode(Node): 36 pass 37 38 class Expression(Node): 39 # Expression is an artificial node class to support "eval" 40 nodes["expression"] = "Expression" 41 def __init__(self, node): 42 self.node = node 43 44 def getChildren(self): 45 return self.node, 46 47 def getChildNodes(self): 48 return self.node, 49 50 def __repr__(self): 51 return "Expression(%s)" % (repr(self.node)) 52 53 def visit(self, visitor): 54 return visitor.visitExpression(self) 55 56 class Add(Node): 57 def __init__(self, (left, right), lineno=None): 58 self.left = left 59 self.right = right 60 self.lineno = lineno 61 62 def getChildren(self): 63 return self.left, self.right 64 65 def getChildNodes(self): 66 return self.left, self.right 67 68 def __repr__(self): 69 return "Add((%s, %s))" % (repr(self.left), repr(self.right)) 70 71 def visit(self, visitor): 72 return visitor.visitAdd(self) 73 74 class And(Node): 75 def __init__(self, nodes, lineno=None): 76 self.nodes = nodes 77 self.lineno = lineno 78 79 def getChildren(self): 80 return tuple(flatten(self.nodes)) 81 82 def getChildNodes(self): 83 nodelist = [] 84 nodelist.extend(flatten_nodes(self.nodes)) 85 return tuple(nodelist) 86 87 def __repr__(self): 88 return "And(%s)" % (repr(self.nodes),) 89 90 def visit(self, visitor): 91 return visitor.visitAnd(self) 92 93 class AssAttr(Node): 94 def __init__(self, expr, attrname, flags, lineno=None): 95 self.expr = expr 96 self.attrname = attrname 97 self.flags = flags 98 self.lineno = lineno 99 100 def getChildren(self): 101 return self.expr, self.attrname, self.flags 102 103 def getChildNodes(self): 104 return self.expr, 105 106 def __repr__(self): 107 return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags)) 108 109 def visit(self, visitor): 110 return visitor.visitAssAttr(self) 111 112 class AssList(Node): 113 def __init__(self, nodes, lineno=None): 114 self.nodes = nodes 115 self.lineno = lineno 116 117 def getChildren(self): 118 return tuple(flatten(self.nodes)) 119 120 def getChildNodes(self): 121 nodelist = [] 122 nodelist.extend(flatten_nodes(self.nodes)) 123 return tuple(nodelist) 124 125 def __repr__(self): 126 return "AssList(%s)" % (repr(self.nodes),) 127 128 def visit(self, visitor): 129 return visitor.visitAssList(self) 130 131 class AssName(Node): 132 def __init__(self, name, flags, lineno=None): 133 self.name = name 134 self.flags = flags 135 self.lineno = lineno 136 137 def getChildren(self): 138 return self.name, self.flags 139 140 def getChildNodes(self): 141 return () 142 143 def __repr__(self): 144 return "AssName(%s, %s)" % (repr(self.name), repr(self.flags)) 145 146 def visit(self, visitor): 147 return visitor.visitAssName(self) 148 149 class AssTuple(Node): 150 def __init__(self, nodes, lineno=None): 151 self.nodes = nodes 152 self.lineno = lineno 153 154 def getChildren(self): 155 return tuple(flatten(self.nodes)) 156 157 def getChildNodes(self): 158 nodelist = [] 159 nodelist.extend(flatten_nodes(self.nodes)) 160 return tuple(nodelist) 161 162 def __repr__(self): 163 return "AssTuple(%s)" % (repr(self.nodes),) 164 165 def visit(self, visitor): 166 return visitor.visitAssTuple(self) 167 168 class Assert(Node): 169 def __init__(self, test, fail, lineno=None): 170 self.test = test 171 self.fail = fail 172 self.lineno = lineno 173 174 def getChildren(self): 175 children = [] 176 children.append(self.test) 177 children.append(self.fail) 178 return tuple(children) 179 180 def getChildNodes(self): 181 nodelist = [] 182 nodelist.append(self.test) 183 if self.fail is not None: 184 nodelist.append(self.fail) 185 return tuple(nodelist) 186 187 def __repr__(self): 188 return "Assert(%s, %s)" % (repr(self.test), repr(self.fail)) 189 190 def visit(self, visitor): 191 return visitor.visitAssert(self) 192 193 class Assign(Node): 194 def __init__(self, nodes, expr, lineno=None): 195 self.nodes = nodes 196 self.expr = expr 197 self.lineno = lineno 198 199 def getChildren(self): 200 children = [] 201 children.extend(flatten(self.nodes)) 202 children.append(self.expr) 203 return tuple(children) 204 205 def getChildNodes(self): 206 nodelist = [] 207 nodelist.extend(flatten_nodes(self.nodes)) 208 nodelist.append(self.expr) 209 return tuple(nodelist) 210 211 def __repr__(self): 212 return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr)) 213 214 def visit(self, visitor): 215 return visitor.visitAssign(self) 216 217 class AugAssign(Node): 218 def __init__(self, node, op, expr, lineno=None): 219 self.node = node 220 self.op = op 221 self.expr = expr 222 self.lineno = lineno 223 224 def getChildren(self): 225 return self.node, self.op, self.expr 226 227 def getChildNodes(self): 228 return self.node, self.expr 229 230 def __repr__(self): 231 return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr)) 232 233 def visit(self, visitor): 234 return visitor.visitAugAssign(self) 235 236 class Backquote(Node): 237 def __init__(self, expr, lineno=None): 238 self.expr = expr 239 self.lineno = lineno 240 241 def getChildren(self): 242 return self.expr, 243 244 def getChildNodes(self): 245 return self.expr, 246 247 def __repr__(self): 248 return "Backquote(%s)" % (repr(self.expr),) 249 250 def visit(self, visitor): 251 return visitor.visitBackquote(self) 252 253 class Bitand(Node): 254 def __init__(self, nodes, lineno=None): 255 self.nodes = nodes 256 self.lineno = lineno 257 258 def getChildren(self): 259 return tuple(flatten(self.nodes)) 260 261 def getChildNodes(self): 262 nodelist = [] 263 nodelist.extend(flatten_nodes(self.nodes)) 264 return tuple(nodelist) 265 266 def __repr__(self): 267 return "Bitand(%s)" % (repr(self.nodes),) 268 269 def visit(self, visitor): 270 return visitor.visitBitand(self) 271 272 class Bitor(Node): 273 def __init__(self, nodes, lineno=None): 274 self.nodes = nodes 275 self.lineno = lineno 276 277 def getChildren(self): 278 return tuple(flatten(self.nodes)) 279 280 def getChildNodes(self): 281 nodelist = [] 282 nodelist.extend(flatten_nodes(self.nodes)) 283 return tuple(nodelist) 284 285 def __repr__(self): 286 return "Bitor(%s)" % (repr(self.nodes),) 287 288 def visit(self, visitor): 289 return visitor.visitBitor(self) 290 291 class Bitxor(Node): 292 def __init__(self, nodes, lineno=None): 293 self.nodes = nodes 294 self.lineno = lineno 295 296 def getChildren(self): 297 return tuple(flatten(self.nodes)) 298 299 def getChildNodes(self): 300 nodelist = [] 301 nodelist.extend(flatten_nodes(self.nodes)) 302 return tuple(nodelist) 303 304 def __repr__(self): 305 return "Bitxor(%s)" % (repr(self.nodes),) 306 307 def visit(self, visitor): 308 return visitor.visitBitxor(self) 309 310 class Break(Node): 311 def __init__(self, lineno=None): 312 self.lineno = lineno 313 314 def getChildren(self): 315 return () 316 317 def getChildNodes(self): 318 return () 319 320 def __repr__(self): 321 return "Break()" 322 323 def visit(self, visitor): 324 return visitor.visitBreak(self) 325 326 class CallFunc(Node): 327 def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None): 328 self.node = node 329 self.args = args 330 self.star_args = star_args 331 self.dstar_args = dstar_args 332 self.lineno = lineno 333 334 def getChildren(self): 335 children = [] 336 children.append(self.node) 337 children.extend(flatten(self.args)) 338 children.append(self.star_args) 339 children.append(self.dstar_args) 340 return tuple(children) 341 342 def getChildNodes(self): 343 nodelist = [] 344 nodelist.append(self.node) 345 nodelist.extend(flatten_nodes(self.args)) 346 if self.star_args is not None: 347 nodelist.append(self.star_args) 348 if self.dstar_args is not None: 349 nodelist.append(self.dstar_args) 350 return tuple(nodelist) 351 352 def __repr__(self): 353 return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args)) 354 355 def visit(self, visitor): 356 return visitor.visitCallFunc(self) 357 358 class Class(Node): 359 def __init__(self, name, bases, doc, code, lineno=None): 360 self.name = name 361 self.bases = bases 362 self.doc = doc 363 self.code = code 364 self.lineno = lineno 365 366 def getChildren(self): 367 children = [] 368 children.append(self.name) 369 children.extend(flatten(self.bases)) 370 children.append(self.doc) 371 children.append(self.code) 372 return tuple(children) 373 374 def getChildNodes(self): 375 nodelist = [] 376 nodelist.extend(flatten_nodes(self.bases)) 377 nodelist.append(self.code) 378 return tuple(nodelist) 379 380 def __repr__(self): 381 return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code)) 382 383 def visit(self, visitor): 384 return visitor.visitClass(self) 385 386 class Compare(Node): 387 def __init__(self, expr, ops, lineno=None): 388 self.expr = expr 389 self.ops = ops 390 self.lineno = lineno 391 392 def getChildren(self): 393 children = [] 394 children.append(self.expr) 395 children.extend(flatten(self.ops)) 396 return tuple(children) 397 398 def getChildNodes(self): 399 nodelist = [] 400 nodelist.append(self.expr) 401 nodelist.extend(flatten_nodes(self.ops)) 402 return tuple(nodelist) 403 404 def __repr__(self): 405 return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops)) 406 407 def visit(self, visitor): 408 return visitor.visitCompare(self) 409 410 class Const(Node): 411 def __init__(self, value, lineno=None): 412 self.value = value 413 self.lineno = lineno 414 415 def getChildren(self): 416 return self.value, 417 418 def getChildNodes(self): 419 return () 420 421 def __repr__(self): 422 return "Const(%s)" % (repr(self.value),) 423 424 def visit(self, visitor): 425 return visitor.visitConst(self) 426 427 class Continue(Node): 428 def __init__(self, lineno=None): 429 self.lineno = lineno 430 431 def getChildren(self): 432 return () 433 434 def getChildNodes(self): 435 return () 436 437 def __repr__(self): 438 return "Continue()" 439 440 def visit(self, visitor): 441 return visitor.visitContinue(self) 442 443 class Decorators(Node): 444 def __init__(self, nodes, lineno=None): 445 self.nodes = nodes 446 self.lineno = lineno 447 448 def getChildren(self): 449 return tuple(flatten(self.nodes)) 450 451 def getChildNodes(self): 452 nodelist = [] 453 nodelist.extend(flatten_nodes(self.nodes)) 454 return tuple(nodelist) 455 456 def __repr__(self): 457 return "Decorators(%s)" % (repr(self.nodes),) 458 459 def visit(self, visitor): 460 return visitor.visitDecorators(self) 461 462 class Dict(Node): 463 def __init__(self, items, lineno=None): 464 self.items = items 465 self.lineno = lineno 466 467 def getChildren(self): 468 return tuple(flatten(self.items)) 469 470 def getChildNodes(self): 471 nodelist = [] 472 nodelist.extend(flatten_nodes(self.items)) 473 return tuple(nodelist) 474 475 def __repr__(self): 476 return "Dict(%s)" % (repr(self.items),) 477 478 def visit(self, visitor): 479 return visitor.visitDict(self) 480 481 class Discard(Node): 482 def __init__(self, expr, lineno=None): 483 self.expr = expr 484 self.lineno = lineno 485 486 def getChildren(self): 487 return self.expr, 488 489 def getChildNodes(self): 490 return self.expr, 491 492 def __repr__(self): 493 return "Discard(%s)" % (repr(self.expr),) 494 495 def visit(self, visitor): 496 return visitor.visitDiscard(self) 497 498 class Div(Node): 499 def __init__(self, (left, right), lineno=None): 500 self.left = left 501 self.right = right 502 self.lineno = lineno 503 504 def getChildren(self): 505 return self.left, self.right 506 507 def getChildNodes(self): 508 return self.left, self.right 509 510 def __repr__(self): 511 return "Div((%s, %s))" % (repr(self.left), repr(self.right)) 512 513 def visit(self, visitor): 514 return visitor.visitDiv(self) 515 516 class Ellipsis(Node): 517 def __init__(self, lineno=None): 518 self.lineno = lineno 519 520 def getChildren(self): 521 return () 522 523 def getChildNodes(self): 524 return () 525 526 def __repr__(self): 527 return "Ellipsis()" 528 529 def visit(self, visitor): 530 return visitor.visitEllipsis(self) 531 532 class Exec(Node): 533 def __init__(self, expr, locals, globals, lineno=None): 534 self.expr = expr 535 self.locals = locals 536 self.globals = globals 537 self.lineno = lineno 538 539 def getChildren(self): 540 children = [] 541 children.append(self.expr) 542 children.append(self.locals) 543 children.append(self.globals) 544 return tuple(children) 545 546 def getChildNodes(self): 547 nodelist = [] 548 nodelist.append(self.expr) 549 if self.locals is not None: 550 nodelist.append(self.locals) 551 if self.globals is not None: 552 nodelist.append(self.globals) 553 return tuple(nodelist) 554 555 def __repr__(self): 556 return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals)) 557 558 def visit(self, visitor): 559 return visitor.visitExec(self) 560 561 class FloorDiv(Node): 562 def __init__(self, (left, right), lineno=None): 563 self.left = left 564 self.right = right 565 self.lineno = lineno 566 567 def getChildren(self): 568 return self.left, self.right 569 570 def getChildNodes(self): 571 return self.left, self.right 572 573 def __repr__(self): 574 return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right)) 575 576 def visit(self, visitor): 577 return visitor.visitFloorDiv(self) 578 579 class For(Node): 580 def __init__(self, assign, list, body, else_, lineno=None): 581 self.assign = assign 582 self.list = list 583 self.body = body 584 self.else_ = else_ 585 self.lineno = lineno 586 587 def getChildren(self): 588 children = [] 589 children.append(self.assign) 590 children.append(self.list) 591 children.append(self.body) 592 children.append(self.else_) 593 return tuple(children) 594 595 def getChildNodes(self): 596 nodelist = [] 597 nodelist.append(self.assign) 598 nodelist.append(self.list) 599 nodelist.append(self.body) 600 if self.else_ is not None: 601 nodelist.append(self.else_) 602 return tuple(nodelist) 603 604 def __repr__(self): 605 return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_)) 606 607 def visit(self, visitor): 608 return visitor.visitFor(self) 609 610 class From(Node): 611 def __init__(self, modname, names, level, lineno=None): 612 self.modname = modname 613 self.names = names 614 self.level = level 615 self.lineno = lineno 616 617 def getChildren(self): 618 return self.modname, self.names, self.level 619 620 def getChildNodes(self): 621 return () 622 623 def __repr__(self): 624 return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level)) 625 626 def visit(self, visitor): 627 return visitor.visitFrom(self) 628 629 class Function(Node): 630 def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): 631 self.decorators = decorators 632 self.name = name 633 self.argnames = argnames 634 self.defaults = defaults 635 self.flags = flags 636 self.doc = doc 637 self.code = code 638 self.lineno = lineno 639 self.varargs = self.kwargs = None 640 if flags & CO_VARARGS: 641 self.varargs = 1 642 if flags & CO_VARKEYWORDS: 643 self.kwargs = 1 644 645 646 647 def getChildren(self): 648 children = [] 649 children.append(self.decorators) 650 children.append(self.name) 651 children.append(self.argnames) 652 children.extend(flatten(self.defaults)) 653 children.append(self.flags) 654 children.append(self.doc) 655 children.append(self.code) 656 return tuple(children) 657 658 def getChildNodes(self): 659 nodelist = [] 660 if self.decorators is not None: 661 nodelist.append(self.decorators) 662 nodelist.extend(flatten_nodes(self.defaults)) 663 nodelist.append(self.code) 664 return tuple(nodelist) 665 666 def __repr__(self): 667 return "Function(%s, %s, %s, %s, %s, %s, %s)" % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code)) 668 669 def visit(self, visitor): 670 return visitor.visitFunction(self) 671 672 class GenExpr(Node): 673 def __init__(self, code, lineno=None): 674 self.code = code 675 self.lineno = lineno 676 self.argnames = ['.0'] 677 self.varargs = self.kwargs = None 678 679 def getChildren(self): 680 return self.code, 681 682 def getChildNodes(self): 683 return self.code, 684 685 def __repr__(self): 686 return "GenExpr(%s)" % (repr(self.code),) 687 688 def visit(self, visitor): 689 return visitor.visitGenExpr(self) 690 691 class GenExprFor(Node): 692 def __init__(self, assign, iter, ifs, lineno=None): 693 self.assign = assign 694 self.iter = iter 695 self.ifs = ifs 696 self.lineno = lineno 697 self.is_outmost = False 698 699 700 def getChildren(self): 701 children = [] 702 children.append(self.assign) 703 children.append(self.iter) 704 children.extend(flatten(self.ifs)) 705 return tuple(children) 706 707 def getChildNodes(self): 708 nodelist = [] 709 nodelist.append(self.assign) 710 nodelist.append(self.iter) 711 nodelist.extend(flatten_nodes(self.ifs)) 712 return tuple(nodelist) 713 714 def __repr__(self): 715 return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs)) 716 717 def visit(self, visitor): 718 return visitor.visitGenExprFor(self) 719 720 class GenExprIf(Node): 721 def __init__(self, test, lineno=None): 722 self.test = test 723 self.lineno = lineno 724 725 def getChildren(self): 726 return self.test, 727 728 def getChildNodes(self): 729 return self.test, 730 731 def __repr__(self): 732 return "GenExprIf(%s)" % (repr(self.test),) 733 734 def visit(self, visitor): 735 return visitor.visitGenExprIf(self) 736 737 class GenExprInner(Node): 738 def __init__(self, expr, quals, lineno=None): 739 self.expr = expr 740 self.quals = quals 741 self.lineno = lineno 742 743 def getChildren(self): 744 children = [] 745 children.append(self.expr) 746 children.extend(flatten(self.quals)) 747 return tuple(children) 748 749 def getChildNodes(self): 750 nodelist = [] 751 nodelist.append(self.expr) 752 nodelist.extend(flatten_nodes(self.quals)) 753 return tuple(nodelist) 754 755 def __repr__(self): 756 return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals)) 757 758 def visit(self, visitor): 759 return visitor.visitGenExprInner(self) 760 761 class Getattr(Node): 762 def __init__(self, expr, attrname, lineno=None): 763 self.expr = expr 764 self.attrname = attrname 765 self.lineno = lineno 766 767 def getChildren(self): 768 return self.expr, self.attrname 769 770 def getChildNodes(self): 771 return self.expr, 772 773 def __repr__(self): 774 return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname)) 775 776 def visit(self, visitor): 777 return visitor.visitGetattr(self) 778 779 class Global(Node): 780 def __init__(self, names, lineno=None): 781 self.names = names 782 self.lineno = lineno 783 784 def getChildren(self): 785 return self.names, 786 787 def getChildNodes(self): 788 return () 789 790 def __repr__(self): 791 return "Global(%s)" % (repr(self.names),) 792 793 def visit(self, visitor): 794 return visitor.visitGlobal(self) 795 796 class If(Node): 797 def __init__(self, tests, else_, lineno=None): 798 self.tests = tests 799 self.else_ = else_ 800 self.lineno = lineno 801 802 def getChildren(self): 803 children = [] 804 children.extend(flatten(self.tests)) 805 children.append(self.else_) 806 return tuple(children) 807 808 def getChildNodes(self): 809 nodelist = [] 810 nodelist.extend(flatten_nodes(self.tests)) 811 if self.else_ is not None: 812 nodelist.append(self.else_) 813 return tuple(nodelist) 814 815 def __repr__(self): 816 return "If(%s, %s)" % (repr(self.tests), repr(self.else_)) 817 818 def visit(self, visitor): 819 return visitor.visitIf(self) 820 821 class IfExp(Node): 822 def __init__(self, test, then, else_, lineno=None): 823 self.test = test 824 self.then = then 825 self.else_ = else_ 826 self.lineno = lineno 827 828 def getChildren(self): 829 return self.test, self.then, self.else_ 830 831 def getChildNodes(self): 832 return self.test, self.then, self.else_ 833 834 def __repr__(self): 835 return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_)) 836 837 def visit(self, visitor): 838 return visitor.visitIfExp(self) 839 840 class Import(Node): 841 def __init__(self, names, lineno=None): 842 self.names = names 843 self.lineno = lineno 844 845 def getChildren(self): 846 return self.names, 847 848 def getChildNodes(self): 849 return () 850 851 def __repr__(self): 852 return "Import(%s)" % (repr(self.names),) 853 854 def visit(self, visitor): 855 return visitor.visitImport(self) 856 857 class Invert(Node): 858 def __init__(self, expr, lineno=None): 859 self.expr = expr 860 self.lineno = lineno 861 862 def getChildren(self): 863 return self.expr, 864 865 def getChildNodes(self): 866 return self.expr, 867 868 def __repr__(self): 869 return "Invert(%s)" % (repr(self.expr),) 870 871 def visit(self, visitor): 872 return visitor.visitInvert(self) 873 874 class Keyword(Node): 875 def __init__(self, name, expr, lineno=None): 876 self.name = name 877 self.expr = expr 878 self.lineno = lineno 879 880 def getChildren(self): 881 return self.name, self.expr 882 883 def getChildNodes(self): 884 return self.expr, 885 886 def __repr__(self): 887 return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr)) 888 889 def visit(self, visitor): 890 return visitor.visitKeyword(self) 891 892 class Lambda(Node): 893 def __init__(self, argnames, defaults, flags, code, lineno=None): 894 self.argnames = argnames 895 self.defaults = defaults 896 self.flags = flags 897 self.code = code 898 self.lineno = lineno 899 self.varargs = self.kwargs = None 900 if flags & CO_VARARGS: 901 self.varargs = 1 902 if flags & CO_VARKEYWORDS: 903 self.kwargs = 1 904 905 906 907 def getChildren(self): 908 children = [] 909 children.append(self.argnames) 910 children.extend(flatten(self.defaults)) 911 children.append(self.flags) 912 children.append(self.code) 913 return tuple(children) 914 915 def getChildNodes(self): 916 nodelist = [] 917 nodelist.extend(flatten_nodes(self.defaults)) 918 nodelist.append(self.code) 919 return tuple(nodelist) 920 921 def __repr__(self): 922 return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code)) 923 924 def visit(self, visitor): 925 return visitor.visitLambda(self) 926 927 class LeftShift(Node): 928 def __init__(self, (left, right), lineno=None): 929 self.left = left 930 self.right = right 931 self.lineno = lineno 932 933 def getChildren(self): 934 return self.left, self.right 935 936 def getChildNodes(self): 937 return self.left, self.right 938 939 def __repr__(self): 940 return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right)) 941 942 def visit(self, visitor): 943 return visitor.visitLeftShift(self) 944 945 class List(Node): 946 def __init__(self, nodes, lineno=None): 947 self.nodes = nodes 948 self.lineno = lineno 949 950 def getChildren(self): 951 return tuple(flatten(self.nodes)) 952 953 def getChildNodes(self): 954 nodelist = [] 955 nodelist.extend(flatten_nodes(self.nodes)) 956 return tuple(nodelist) 957 958 def __repr__(self): 959 return "List(%s)" % (repr(self.nodes),) 960 961 def visit(self, visitor): 962 return visitor.visitList(self) 963 964 class ListComp(Node): 965 def __init__(self, expr, quals, lineno=None): 966 self.expr = expr 967 self.quals = quals 968 self.lineno = lineno 969 970 def getChildren(self): 971 children = [] 972 children.append(self.expr) 973 children.extend(flatten(self.quals)) 974 return tuple(children) 975 976 def getChildNodes(self): 977 nodelist = [] 978 nodelist.append(self.expr) 979 nodelist.extend(flatten_nodes(self.quals)) 980 return tuple(nodelist) 981 982 def __repr__(self): 983 return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals)) 984 985 def visit(self, visitor): 986 return visitor.visitListComp(self) 987 988 class ListCompFor(Node): 989 def __init__(self, assign, list, ifs, lineno=None): 990 self.assign = assign 991 self.list = list 992 self.ifs = ifs 993 self.lineno = lineno 994 995 def getChildren(self): 996 children = [] 997 children.append(self.assign) 998 children.append(self.list) 999 children.extend(flatten(self.ifs)) 1000 return tuple(children) 1001 1002 def getChildNodes(self): 1003 nodelist = [] 1004 nodelist.append(self.assign) 1005 nodelist.append(self.list) 1006 nodelist.extend(flatten_nodes(self.ifs)) 1007 return tuple(nodelist) 1008 1009 def __repr__(self): 1010 return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs)) 1011 1012 def visit(self, visitor): 1013 return visitor.visitListCompFor(self) 1014 1015 class ListCompIf(Node): 1016 def __init__(self, test, lineno=None): 1017 self.test = test 1018 self.lineno = lineno 1019 1020 def getChildren(self): 1021 return self.test, 1022 1023 def getChildNodes(self): 1024 return self.test, 1025 1026 def __repr__(self): 1027 return "ListCompIf(%s)" % (repr(self.test),) 1028 1029 def visit(self, visitor): 1030 return visitor.visitListCompIf(self) 1031 1032 class Mod(Node): 1033 def __init__(self, (left, right), lineno=None): 1034 self.left = left 1035 self.right = right 1036 self.lineno = lineno 1037 1038 def getChildren(self): 1039 return self.left, self.right 1040 1041 def getChildNodes(self): 1042 return self.left, self.right 1043 1044 def __repr__(self): 1045 return "Mod((%s, %s))" % (repr(self.left), repr(self.right)) 1046 1047 def visit(self, visitor): 1048 return visitor.visitMod(self) 1049 1050 class Module(Node): 1051 def __init__(self, doc, node, lineno=None): 1052 self.doc = doc 1053 self.node = node 1054 self.lineno = lineno 1055 1056 def getChildren(self): 1057 return self.doc, self.node 1058 1059 def getChildNodes(self): 1060 return self.node, 1061 1062 def __repr__(self): 1063 return "Module(%s, %s)" % (repr(self.doc), repr(self.node)) 1064 1065 def visit(self, visitor): 1066 return visitor.visitModule(self) 1067 1068 class Mul(Node): 1069 def __init__(self, (left, right), lineno=None): 1070 self.left = left 1071 self.right = right 1072 self.lineno = lineno 1073 1074 def getChildren(self): 1075 return self.left, self.right 1076 1077 def getChildNodes(self): 1078 return self.left, self.right 1079 1080 def __repr__(self): 1081 return "Mul((%s, %s))" % (repr(self.left), repr(self.right)) 1082 1083 def visit(self, visitor): 1084 return visitor.visitMul(self) 1085 1086 class Name(Node): 1087 def __init__(self, name, lineno=None): 1088 self.name = name 1089 self.lineno = lineno 1090 1091 def getChildren(self): 1092 return self.name, 1093 1094 def getChildNodes(self): 1095 return () 1096 1097 def __repr__(self): 1098 return "Name(%s)" % (repr(self.name),) 1099 1100 def visit(self, visitor): 1101 return visitor.visitName(self) 1102 1103 class Not(Node): 1104 def __init__(self, expr, lineno=None): 1105 self.expr = expr 1106 self.lineno = lineno 1107 1108 def getChildren(self): 1109 return self.expr, 1110 1111 def getChildNodes(self): 1112 return self.expr, 1113 1114 def __repr__(self): 1115 return "Not(%s)" % (repr(self.expr),) 1116 1117 def visit(self, visitor): 1118 return visitor.visitNot(self) 1119 1120 class Or(Node): 1121 def __init__(self, nodes, lineno=None): 1122 self.nodes = nodes 1123 self.lineno = lineno 1124 1125 def getChildren(self): 1126 return tuple(flatten(self.nodes)) 1127 1128 def getChildNodes(self): 1129 nodelist = [] 1130 nodelist.extend(flatten_nodes(self.nodes)) 1131 return tuple(nodelist) 1132 1133 def __repr__(self): 1134 return "Or(%s)" % (repr(self.nodes),) 1135 1136 def visit(self, visitor): 1137 return visitor.visitOr(self) 1138 1139 class Pass(Node): 1140 def __init__(self, lineno=None): 1141 self.lineno = lineno 1142 1143 def getChildren(self): 1144 return () 1145 1146 def getChildNodes(self): 1147 return () 1148 1149 def __repr__(self): 1150 return "Pass()" 1151 1152 def visit(self, visitor): 1153 return visitor.visitPass(self) 1154 1155 class Power(Node): 1156 def __init__(self, (left, right), lineno=None): 1157 self.left = left 1158 self.right = right 1159 self.lineno = lineno 1160 1161 def getChildren(self): 1162 return self.left, self.right 1163 1164 def getChildNodes(self): 1165 return self.left, self.right 1166 1167 def __repr__(self): 1168 return "Power((%s, %s))" % (repr(self.left), repr(self.right)) 1169 1170 def visit(self, visitor): 1171 return visitor.visitPower(self) 1172 1173 class Print(Node): 1174 def __init__(self, nodes, dest, lineno=None): 1175 self.nodes = nodes 1176 self.dest = dest 1177 self.lineno = lineno 1178 1179 def getChildren(self): 1180 children = [] 1181 children.extend(flatten(self.nodes)) 1182 children.append(self.dest) 1183 return tuple(children) 1184 1185 def getChildNodes(self): 1186 nodelist = [] 1187 nodelist.extend(flatten_nodes(self.nodes)) 1188 if self.dest is not None: 1189 nodelist.append(self.dest) 1190 return tuple(nodelist) 1191 1192 def __repr__(self): 1193 return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest)) 1194 1195 def visit(self, visitor): 1196 return visitor.visitPrint(self) 1197 1198 class Printnl(Node): 1199 def __init__(self, nodes, dest, lineno=None): 1200 self.nodes = nodes 1201 self.dest = dest 1202 self.lineno = lineno 1203 1204 def getChildren(self): 1205 children = [] 1206 children.extend(flatten(self.nodes)) 1207 children.append(self.dest) 1208 return tuple(children) 1209 1210 def getChildNodes(self): 1211 nodelist = [] 1212 nodelist.extend(flatten_nodes(self.nodes)) 1213 if self.dest is not None: 1214 nodelist.append(self.dest) 1215 return tuple(nodelist) 1216 1217 def __repr__(self): 1218 return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest)) 1219 1220 def visit(self, visitor): 1221 return visitor.visitPrintnl(self) 1222 1223 class Raise(Node): 1224 def __init__(self, expr1, expr2, expr3, lineno=None): 1225 self.expr1 = expr1 1226 self.expr2 = expr2 1227 self.expr3 = expr3 1228 self.lineno = lineno 1229 1230 def getChildren(self): 1231 children = [] 1232 children.append(self.expr1) 1233 children.append(self.expr2) 1234 children.append(self.expr3) 1235 return tuple(children) 1236 1237 def getChildNodes(self): 1238 nodelist = [] 1239 if self.expr1 is not None: 1240 nodelist.append(self.expr1) 1241 if self.expr2 is not None: 1242 nodelist.append(self.expr2) 1243 if self.expr3 is not None: 1244 nodelist.append(self.expr3) 1245 return tuple(nodelist) 1246 1247 def __repr__(self): 1248 return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3)) 1249 1250 def visit(self, visitor): 1251 return visitor.visitRaise(self) 1252 1253 class Return(Node): 1254 def __init__(self, value, lineno=None): 1255 self.value = value 1256 self.lineno = lineno 1257 1258 def getChildren(self): 1259 return self.value, 1260 1261 def getChildNodes(self): 1262 return self.value, 1263 1264 def __repr__(self): 1265 return "Return(%s)" % (repr(self.value),) 1266 1267 def visit(self, visitor): 1268 return visitor.visitReturn(self) 1269 1270 class RightShift(Node): 1271 def __init__(self, (left, right), lineno=None): 1272 self.left = left 1273 self.right = right 1274 self.lineno = lineno 1275 1276 def getChildren(self): 1277 return self.left, self.right 1278 1279 def getChildNodes(self): 1280 return self.left, self.right 1281 1282 def __repr__(self): 1283 return "RightShift((%s, %s))" % (repr(self.left), repr(self.right)) 1284 1285 def visit(self, visitor): 1286 return visitor.visitRightShift(self) 1287 1288 class Slice(Node): 1289 def __init__(self, expr, flags, lower, upper, lineno=None): 1290 self.expr = expr 1291 self.flags = flags 1292 self.lower = lower 1293 self.upper = upper 1294 self.lineno = lineno 1295 1296 def getChildren(self): 1297 children = [] 1298 children.append(self.expr) 1299 children.append(self.flags) 1300 children.append(self.lower) 1301 children.append(self.upper) 1302 return tuple(children) 1303 1304 def getChildNodes(self): 1305 nodelist = [] 1306 nodelist.append(self.expr) 1307 if self.lower is not None: 1308 nodelist.append(self.lower) 1309 if self.upper is not None: 1310 nodelist.append(self.upper) 1311 return tuple(nodelist) 1312 1313 def __repr__(self): 1314 return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper)) 1315 1316 def visit(self, visitor): 1317 return visitor.visitSlice(self) 1318 1319 class Sliceobj(Node): 1320 def __init__(self, nodes, lineno=None): 1321 self.nodes = nodes 1322 self.lineno = lineno 1323 1324 def getChildren(self): 1325 return tuple(flatten(self.nodes)) 1326 1327 def getChildNodes(self): 1328 nodelist = [] 1329 nodelist.extend(flatten_nodes(self.nodes)) 1330 return tuple(nodelist) 1331 1332 def __repr__(self): 1333 return "Sliceobj(%s)" % (repr(self.nodes),) 1334 1335 def visit(self, visitor): 1336 return visitor.visitSliceobj(self) 1337 1338 class Stmt(Node): 1339 def __init__(self, nodes, lineno=None): 1340 self.nodes = nodes 1341 self.lineno = lineno 1342 1343 def getChildren(self): 1344 return tuple(flatten(self.nodes)) 1345 1346 def getChildNodes(self): 1347 nodelist = [] 1348 nodelist.extend(flatten_nodes(self.nodes)) 1349 return tuple(nodelist) 1350 1351 def __repr__(self): 1352 return "Stmt(%s)" % (repr(self.nodes),) 1353 1354 def visit(self, visitor): 1355 return visitor.visitStmt(self) 1356 1357 class Sub(Node): 1358 def __init__(self, (left, right), lineno=None): 1359 self.left = left 1360 self.right = right 1361 self.lineno = lineno 1362 1363 def getChildren(self): 1364 return self.left, self.right 1365 1366 def getChildNodes(self): 1367 return self.left, self.right 1368 1369 def __repr__(self): 1370 return "Sub((%s, %s))" % (repr(self.left), repr(self.right)) 1371 1372 def visit(self, visitor): 1373 return visitor.visitSub(self) 1374 1375 class Subscript(Node): 1376 def __init__(self, expr, flags, subs, lineno=None): 1377 self.expr = expr 1378 self.flags = flags 1379 self.subs = subs 1380 self.lineno = lineno 1381 1382 def getChildren(self): 1383 children = [] 1384 children.append(self.expr) 1385 children.append(self.flags) 1386 children.extend(flatten(self.subs)) 1387 return tuple(children) 1388 1389 def getChildNodes(self): 1390 nodelist = [] 1391 nodelist.append(self.expr) 1392 nodelist.extend(flatten_nodes(self.subs)) 1393 return tuple(nodelist) 1394 1395 def __repr__(self): 1396 return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs)) 1397 1398 def visit(self, visitor): 1399 return visitor.visitSubscript(self) 1400 1401 class TryExcept(Node): 1402 def __init__(self, body, handlers, else_, lineno=None): 1403 self.body = body 1404 self.handlers = handlers 1405 self.else_ = else_ 1406 self.lineno = lineno 1407 1408 def getChildren(self): 1409 children = [] 1410 children.append(self.body) 1411 children.extend(flatten(self.handlers)) 1412 children.append(self.else_) 1413 return tuple(children) 1414 1415 def getChildNodes(self): 1416 nodelist = [] 1417 nodelist.append(self.body) 1418 nodelist.extend(flatten_nodes(self.handlers)) 1419 if self.else_ is not None: 1420 nodelist.append(self.else_) 1421 return tuple(nodelist) 1422 1423 def __repr__(self): 1424 return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_)) 1425 1426 def visit(self, visitor): 1427 return visitor.visitTryExcept(self) 1428 1429 class TryFinally(Node): 1430 def __init__(self, body, final, lineno=None): 1431 self.body = body 1432 self.final = final 1433 self.lineno = lineno 1434 1435 def getChildren(self): 1436 return self.body, self.final 1437 1438 def getChildNodes(self): 1439 return self.body, self.final 1440 1441 def __repr__(self): 1442 return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final)) 1443 1444 def visit(self, visitor): 1445 return visitor.visitTryFinally(self) 1446 1447 class Tuple(Node): 1448 def __init__(self, nodes, lineno=None): 1449 self.nodes = nodes 1450 self.lineno = lineno 1451 1452 def getChildren(self): 1453 return tuple(flatten(self.nodes)) 1454 1455 def getChildNodes(self): 1456 nodelist = [] 1457 nodelist.extend(flatten_nodes(self.nodes)) 1458 return tuple(nodelist) 1459 1460 def __repr__(self): 1461 return "Tuple(%s)" % (repr(self.nodes),) 1462 1463 def visit(self, visitor): 1464 return visitor.visitTuple(self) 1465 1466 class UnaryAdd(Node): 1467 def __init__(self, expr, lineno=None): 1468 self.expr = expr 1469 self.lineno = lineno 1470 1471 def getChildren(self): 1472 return self.expr, 1473 1474 def getChildNodes(self): 1475 return self.expr, 1476 1477 def __repr__(self): 1478 return "UnaryAdd(%s)" % (repr(self.expr),) 1479 1480 def visit(self, visitor): 1481 return visitor.visitUnaryAdd(self) 1482 1483 class UnarySub(Node): 1484 def __init__(self, expr, lineno=None): 1485 self.expr = expr 1486 self.lineno = lineno 1487 1488 def getChildren(self): 1489 return self.expr, 1490 1491 def getChildNodes(self): 1492 return self.expr, 1493 1494 def __repr__(self): 1495 return "UnarySub(%s)" % (repr(self.expr),) 1496 1497 def visit(self, visitor): 1498 return visitor.visitUnarySub(self) 1499 1500 class While(Node): 1501 def __init__(self, test, body, else_, lineno=None): 1502 self.test = test 1503 self.body = body 1504 self.else_ = else_ 1505 self.lineno = lineno 1506 1507 def getChildren(self): 1508 children = [] 1509 children.append(self.test) 1510 children.append(self.body) 1511 children.append(self.else_) 1512 return tuple(children) 1513 1514 def getChildNodes(self): 1515 nodelist = [] 1516 nodelist.append(self.test) 1517 nodelist.append(self.body) 1518 if self.else_ is not None: 1519 nodelist.append(self.else_) 1520 return tuple(nodelist) 1521 1522 def __repr__(self): 1523 return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_)) 1524 1525 def visit(self, visitor): 1526 return visitor.visitWhile(self) 1527 1528 class With(Node): 1529 def __init__(self, expr, vars, body, lineno=None): 1530 self.expr = expr 1531 self.vars = vars 1532 self.body = body 1533 self.lineno = lineno 1534 1535 def getChildren(self): 1536 children = [] 1537 children.append(self.expr) 1538 children.append(self.vars) 1539 children.append(self.body) 1540 return tuple(children) 1541 1542 def getChildNodes(self): 1543 nodelist = [] 1544 nodelist.append(self.expr) 1545 if self.vars is not None: 1546 nodelist.append(self.vars) 1547 nodelist.append(self.body) 1548 return tuple(nodelist) 1549 1550 def __repr__(self): 1551 return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body)) 1552 1553 def visit(self, visitor): 1554 return visitor.visitWith(self) 1555 1556 class Yield(Node): 1557 def __init__(self, value, lineno=None): 1558 self.value = value 1559 self.lineno = lineno 1560 1561 def getChildren(self): 1562 return self.value, 1563 1564 def getChildNodes(self): 1565 return self.value, 1566 1567 def __repr__(self): 1568 return "Yield(%s)" % (repr(self.value),) 1569 1570 def visit(self, visitor): 1571 return visitor.visitYield(self) 1572 1573 for name, obj in globals().items(): 1574 if isinstance(obj, type) and issubclass(obj, Node): 1575 nodes[name.lower()] = obj