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, leftright, lineno=None): 58 self.left = leftright[0] 59 self.right = leftright[1] 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, decorators = None, lineno=None): 360 self.name = name 361 self.bases = bases 362 self.doc = doc 363 self.code = code 364 self.decorators = decorators 365 self.lineno = lineno 366 367 def getChildren(self): 368 children = [] 369 children.append(self.name) 370 children.extend(flatten(self.bases)) 371 children.append(self.doc) 372 children.append(self.code) 373 children.append(self.decorators) 374 return tuple(children) 375 376 def getChildNodes(self): 377 nodelist = [] 378 nodelist.extend(flatten_nodes(self.bases)) 379 nodelist.append(self.code) 380 if self.decorators is not None: 381 nodelist.append(self.decorators) 382 return tuple(nodelist) 383 384 def __repr__(self): 385 return "Class(%s, %s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code), repr(self.decorators)) 386 387 def visit(self, visitor): 388 return visitor.visitClass(self) 389 390 class Compare(Node): 391 def __init__(self, expr, ops, lineno=None): 392 self.expr = expr 393 self.ops = ops 394 self.lineno = lineno 395 396 def getChildren(self): 397 children = [] 398 children.append(self.expr) 399 children.extend(flatten(self.ops)) 400 return tuple(children) 401 402 def getChildNodes(self): 403 nodelist = [] 404 nodelist.append(self.expr) 405 nodelist.extend(flatten_nodes(self.ops)) 406 return tuple(nodelist) 407 408 def __repr__(self): 409 return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops)) 410 411 def visit(self, visitor): 412 return visitor.visitCompare(self) 413 414 class Const(Node): 415 def __init__(self, value, lineno=None): 416 self.value = value 417 self.lineno = lineno 418 419 def getChildren(self): 420 return self.value, 421 422 def getChildNodes(self): 423 return () 424 425 def __repr__(self): 426 return "Const(%s)" % (repr(self.value),) 427 428 def visit(self, visitor): 429 return visitor.visitConst(self) 430 431 class Continue(Node): 432 def __init__(self, lineno=None): 433 self.lineno = lineno 434 435 def getChildren(self): 436 return () 437 438 def getChildNodes(self): 439 return () 440 441 def __repr__(self): 442 return "Continue()" 443 444 def visit(self, visitor): 445 return visitor.visitContinue(self) 446 447 class Decorators(Node): 448 def __init__(self, nodes, lineno=None): 449 self.nodes = nodes 450 self.lineno = lineno 451 452 def getChildren(self): 453 return tuple(flatten(self.nodes)) 454 455 def getChildNodes(self): 456 nodelist = [] 457 nodelist.extend(flatten_nodes(self.nodes)) 458 return tuple(nodelist) 459 460 def __repr__(self): 461 return "Decorators(%s)" % (repr(self.nodes),) 462 463 def visit(self, visitor): 464 return visitor.visitDecorators(self) 465 466 class Dict(Node): 467 def __init__(self, items, lineno=None): 468 self.items = items 469 self.lineno = lineno 470 471 def getChildren(self): 472 return tuple(flatten(self.items)) 473 474 def getChildNodes(self): 475 nodelist = [] 476 nodelist.extend(flatten_nodes(self.items)) 477 return tuple(nodelist) 478 479 def __repr__(self): 480 return "Dict(%s)" % (repr(self.items),) 481 482 def visit(self, visitor): 483 return visitor.visitDict(self) 484 485 class Discard(Node): 486 def __init__(self, expr, lineno=None): 487 self.expr = expr 488 self.lineno = lineno 489 490 def getChildren(self): 491 return self.expr, 492 493 def getChildNodes(self): 494 return self.expr, 495 496 def __repr__(self): 497 return "Discard(%s)" % (repr(self.expr),) 498 499 def visit(self, visitor): 500 return visitor.visitDiscard(self) 501 502 class Div(Node): 503 def __init__(self, leftright, lineno=None): 504 self.left = leftright[0] 505 self.right = leftright[1] 506 self.lineno = lineno 507 508 def getChildren(self): 509 return self.left, self.right 510 511 def getChildNodes(self): 512 return self.left, self.right 513 514 def __repr__(self): 515 return "Div((%s, %s))" % (repr(self.left), repr(self.right)) 516 517 def visit(self, visitor): 518 return visitor.visitDiv(self) 519 520 class Ellipsis(Node): 521 def __init__(self, lineno=None): 522 self.lineno = lineno 523 524 def getChildren(self): 525 return () 526 527 def getChildNodes(self): 528 return () 529 530 def __repr__(self): 531 return "Ellipsis()" 532 533 def visit(self, visitor): 534 return visitor.visitEllipsis(self) 535 536 class Exec(Node): 537 def __init__(self, expr, locals, globals, lineno=None): 538 self.expr = expr 539 self.locals = locals 540 self.globals = globals 541 self.lineno = lineno 542 543 def getChildren(self): 544 children = [] 545 children.append(self.expr) 546 children.append(self.locals) 547 children.append(self.globals) 548 return tuple(children) 549 550 def getChildNodes(self): 551 nodelist = [] 552 nodelist.append(self.expr) 553 if self.locals is not None: 554 nodelist.append(self.locals) 555 if self.globals is not None: 556 nodelist.append(self.globals) 557 return tuple(nodelist) 558 559 def __repr__(self): 560 return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals)) 561 562 def visit(self, visitor): 563 return visitor.visitExec(self) 564 565 class FloorDiv(Node): 566 def __init__(self, leftright, lineno=None): 567 self.left = leftright[0] 568 self.right = leftright[1] 569 self.lineno = lineno 570 571 def getChildren(self): 572 return self.left, self.right 573 574 def getChildNodes(self): 575 return self.left, self.right 576 577 def __repr__(self): 578 return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right)) 579 580 def visit(self, visitor): 581 return visitor.visitFloorDiv(self) 582 583 class For(Node): 584 def __init__(self, assign, list, body, else_, lineno=None): 585 self.assign = assign 586 self.list = list 587 self.body = body 588 self.else_ = else_ 589 self.lineno = lineno 590 591 def getChildren(self): 592 children = [] 593 children.append(self.assign) 594 children.append(self.list) 595 children.append(self.body) 596 children.append(self.else_) 597 return tuple(children) 598 599 def getChildNodes(self): 600 nodelist = [] 601 nodelist.append(self.assign) 602 nodelist.append(self.list) 603 nodelist.append(self.body) 604 if self.else_ is not None: 605 nodelist.append(self.else_) 606 return tuple(nodelist) 607 608 def __repr__(self): 609 return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_)) 610 611 def visit(self, visitor): 612 return visitor.visitFor(self) 613 614 class From(Node): 615 def __init__(self, modname, names, level, lineno=None): 616 self.modname = modname 617 self.names = names 618 self.level = level 619 self.lineno = lineno 620 621 def getChildren(self): 622 return self.modname, self.names, self.level 623 624 def getChildNodes(self): 625 return () 626 627 def __repr__(self): 628 return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level)) 629 630 def visit(self, visitor): 631 return visitor.visitFrom(self) 632 633 class Function(Node): 634 def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): 635 self.decorators = decorators 636 self.name = name 637 self.argnames = argnames 638 self.defaults = defaults 639 self.flags = flags 640 self.doc = doc 641 self.code = code 642 self.lineno = lineno 643 self.varargs = self.kwargs = None 644 if flags & CO_VARARGS: 645 self.varargs = 1 646 if flags & CO_VARKEYWORDS: 647 self.kwargs = 1 648 649 650 def getChildren(self): 651 children = [] 652 children.append(self.decorators) 653 children.append(self.name) 654 children.append(self.argnames) 655 children.extend(flatten(self.defaults)) 656 children.append(self.flags) 657 children.append(self.doc) 658 children.append(self.code) 659 return tuple(children) 660 661 def getChildNodes(self): 662 nodelist = [] 663 if self.decorators is not None: 664 nodelist.append(self.decorators) 665 nodelist.extend(flatten_nodes(self.defaults)) 666 nodelist.append(self.code) 667 return tuple(nodelist) 668 669 def __repr__(self): 670 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)) 671 672 def visit(self, visitor): 673 return visitor.visitFunction(self) 674 675 class GenExpr(Node): 676 def __init__(self, code, lineno=None): 677 self.code = code 678 self.lineno = lineno 679 self.argnames = ['.0'] 680 self.varargs = self.kwargs = None 681 682 683 def getChildren(self): 684 return self.code, 685 686 def getChildNodes(self): 687 return self.code, 688 689 def __repr__(self): 690 return "GenExpr(%s)" % (repr(self.code),) 691 692 def visit(self, visitor): 693 return visitor.visitGenExpr(self) 694 695 class GenExprFor(Node): 696 def __init__(self, assign, iter, ifs, lineno=None): 697 self.assign = assign 698 self.iter = iter 699 self.ifs = ifs 700 self.lineno = lineno 701 self.is_outmost = False 702 703 def getChildren(self): 704 children = [] 705 children.append(self.assign) 706 children.append(self.iter) 707 children.extend(flatten(self.ifs)) 708 return tuple(children) 709 710 def getChildNodes(self): 711 nodelist = [] 712 nodelist.append(self.assign) 713 nodelist.append(self.iter) 714 nodelist.extend(flatten_nodes(self.ifs)) 715 return tuple(nodelist) 716 717 def __repr__(self): 718 return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs)) 719 720 def visit(self, visitor): 721 return visitor.visitGenExprFor(self) 722 723 class GenExprIf(Node): 724 def __init__(self, test, lineno=None): 725 self.test = test 726 self.lineno = lineno 727 728 def getChildren(self): 729 return self.test, 730 731 def getChildNodes(self): 732 return self.test, 733 734 def __repr__(self): 735 return "GenExprIf(%s)" % (repr(self.test),) 736 737 def visit(self, visitor): 738 return visitor.visitGenExprIf(self) 739 740 class GenExprInner(Node): 741 def __init__(self, expr, quals, lineno=None): 742 self.expr = expr 743 self.quals = quals 744 self.lineno = lineno 745 746 def getChildren(self): 747 children = [] 748 children.append(self.expr) 749 children.extend(flatten(self.quals)) 750 return tuple(children) 751 752 def getChildNodes(self): 753 nodelist = [] 754 nodelist.append(self.expr) 755 nodelist.extend(flatten_nodes(self.quals)) 756 return tuple(nodelist) 757 758 def __repr__(self): 759 return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals)) 760 761 def visit(self, visitor): 762 return visitor.visitGenExprInner(self) 763 764 class Getattr(Node): 765 def __init__(self, expr, attrname, lineno=None): 766 self.expr = expr 767 self.attrname = attrname 768 self.lineno = lineno 769 770 def getChildren(self): 771 return self.expr, self.attrname 772 773 def getChildNodes(self): 774 return self.expr, 775 776 def __repr__(self): 777 return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname)) 778 779 def visit(self, visitor): 780 return visitor.visitGetattr(self) 781 782 class Global(Node): 783 def __init__(self, names, lineno=None): 784 self.names = names 785 self.lineno = lineno 786 787 def getChildren(self): 788 return self.names, 789 790 def getChildNodes(self): 791 return () 792 793 def __repr__(self): 794 return "Global(%s)" % (repr(self.names),) 795 796 def visit(self, visitor): 797 return visitor.visitGlobal(self) 798 799 class If(Node): 800 def __init__(self, tests, else_, lineno=None): 801 self.tests = tests 802 self.else_ = else_ 803 self.lineno = lineno 804 805 def getChildren(self): 806 children = [] 807 children.extend(flatten(self.tests)) 808 children.append(self.else_) 809 return tuple(children) 810 811 def getChildNodes(self): 812 nodelist = [] 813 nodelist.extend(flatten_nodes(self.tests)) 814 if self.else_ is not None: 815 nodelist.append(self.else_) 816 return tuple(nodelist) 817 818 def __repr__(self): 819 return "If(%s, %s)" % (repr(self.tests), repr(self.else_)) 820 821 def visit(self, visitor): 822 return visitor.visitIf(self) 823 824 class IfExp(Node): 825 def __init__(self, test, then, else_, lineno=None): 826 self.test = test 827 self.then = then 828 self.else_ = else_ 829 self.lineno = lineno 830 831 def getChildren(self): 832 return self.test, self.then, self.else_ 833 834 def getChildNodes(self): 835 return self.test, self.then, self.else_ 836 837 def __repr__(self): 838 return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_)) 839 840 def visit(self, visitor): 841 return visitor.visitIfExp(self) 842 843 class Import(Node): 844 def __init__(self, names, lineno=None): 845 self.names = names 846 self.lineno = lineno 847 848 def getChildren(self): 849 return self.names, 850 851 def getChildNodes(self): 852 return () 853 854 def __repr__(self): 855 return "Import(%s)" % (repr(self.names),) 856 857 def visit(self, visitor): 858 return visitor.visitImport(self) 859 860 class Invert(Node): 861 def __init__(self, expr, lineno=None): 862 self.expr = expr 863 self.lineno = lineno 864 865 def getChildren(self): 866 return self.expr, 867 868 def getChildNodes(self): 869 return self.expr, 870 871 def __repr__(self): 872 return "Invert(%s)" % (repr(self.expr),) 873 874 def visit(self, visitor): 875 return visitor.visitInvert(self) 876 877 class Keyword(Node): 878 def __init__(self, name, expr, lineno=None): 879 self.name = name 880 self.expr = expr 881 self.lineno = lineno 882 883 def getChildren(self): 884 return self.name, self.expr 885 886 def getChildNodes(self): 887 return self.expr, 888 889 def __repr__(self): 890 return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr)) 891 892 def visit(self, visitor): 893 return visitor.visitKeyword(self) 894 895 class Lambda(Node): 896 def __init__(self, argnames, defaults, flags, code, lineno=None): 897 self.argnames = argnames 898 self.defaults = defaults 899 self.flags = flags 900 self.code = code 901 self.lineno = lineno 902 self.varargs = self.kwargs = None 903 if flags & CO_VARARGS: 904 self.varargs = 1 905 if flags & CO_VARKEYWORDS: 906 self.kwargs = 1 907 908 909 def getChildren(self): 910 children = [] 911 children.append(self.argnames) 912 children.extend(flatten(self.defaults)) 913 children.append(self.flags) 914 children.append(self.code) 915 return tuple(children) 916 917 def getChildNodes(self): 918 nodelist = [] 919 nodelist.extend(flatten_nodes(self.defaults)) 920 nodelist.append(self.code) 921 return tuple(nodelist) 922 923 def __repr__(self): 924 return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code)) 925 926 def visit(self, visitor): 927 return visitor.visitLambda(self) 928 929 class LeftShift(Node): 930 def __init__(self, leftright, lineno=None): 931 self.left = leftright[0] 932 self.right = leftright[1] 933 self.lineno = lineno 934 935 def getChildren(self): 936 return self.left, self.right 937 938 def getChildNodes(self): 939 return self.left, self.right 940 941 def __repr__(self): 942 return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right)) 943 944 def visit(self, visitor): 945 return visitor.visitLeftShift(self) 946 947 class List(Node): 948 def __init__(self, nodes, lineno=None): 949 self.nodes = nodes 950 self.lineno = lineno 951 952 def getChildren(self): 953 return tuple(flatten(self.nodes)) 954 955 def getChildNodes(self): 956 nodelist = [] 957 nodelist.extend(flatten_nodes(self.nodes)) 958 return tuple(nodelist) 959 960 def __repr__(self): 961 return "List(%s)" % (repr(self.nodes),) 962 963 def visit(self, visitor): 964 return visitor.visitList(self) 965 966 class ListComp(Node): 967 def __init__(self, expr, quals, lineno=None): 968 self.expr = expr 969 self.quals = quals 970 self.lineno = lineno 971 972 def getChildren(self): 973 children = [] 974 children.append(self.expr) 975 children.extend(flatten(self.quals)) 976 return tuple(children) 977 978 def getChildNodes(self): 979 nodelist = [] 980 nodelist.append(self.expr) 981 nodelist.extend(flatten_nodes(self.quals)) 982 return tuple(nodelist) 983 984 def __repr__(self): 985 return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals)) 986 987 def visit(self, visitor): 988 return visitor.visitListComp(self) 989 990 class ListCompFor(Node): 991 def __init__(self, assign, list, ifs, lineno=None): 992 self.assign = assign 993 self.list = list 994 self.ifs = ifs 995 self.lineno = lineno 996 997 def getChildren(self): 998 children = [] 999 children.append(self.assign) 1000 children.append(self.list) 1001 children.extend(flatten(self.ifs)) 1002 return tuple(children) 1003 1004 def getChildNodes(self): 1005 nodelist = [] 1006 nodelist.append(self.assign) 1007 nodelist.append(self.list) 1008 nodelist.extend(flatten_nodes(self.ifs)) 1009 return tuple(nodelist) 1010 1011 def __repr__(self): 1012 return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs)) 1013 1014 def visit(self, visitor): 1015 return visitor.visitListCompFor(self) 1016 1017 class ListCompIf(Node): 1018 def __init__(self, test, lineno=None): 1019 self.test = test 1020 self.lineno = lineno 1021 1022 def getChildren(self): 1023 return self.test, 1024 1025 def getChildNodes(self): 1026 return self.test, 1027 1028 def __repr__(self): 1029 return "ListCompIf(%s)" % (repr(self.test),) 1030 1031 def visit(self, visitor): 1032 return visitor.visitListCompIf(self) 1033 1034 class SetComp(Node): 1035 def __init__(self, expr, quals, lineno=None): 1036 self.expr = expr 1037 self.quals = quals 1038 self.lineno = lineno 1039 1040 def getChildren(self): 1041 children = [] 1042 children.append(self.expr) 1043 children.extend(flatten(self.quals)) 1044 return tuple(children) 1045 1046 def getChildNodes(self): 1047 nodelist = [] 1048 nodelist.append(self.expr) 1049 nodelist.extend(flatten_nodes(self.quals)) 1050 return tuple(nodelist) 1051 1052 def __repr__(self): 1053 return "SetComp(%s, %s)" % (repr(self.expr), repr(self.quals)) 1054 1055 class DictComp(Node): 1056 def __init__(self, key, value, quals, lineno=None): 1057 self.key = key 1058 self.value = value 1059 self.quals = quals 1060 self.lineno = lineno 1061 1062 def getChildren(self): 1063 children = [] 1064 children.append(self.key) 1065 children.append(self.value) 1066 children.extend(flatten(self.quals)) 1067 return tuple(children) 1068 1069 def getChildNodes(self): 1070 nodelist = [] 1071 nodelist.append(self.key) 1072 nodelist.append(self.value) 1073 nodelist.extend(flatten_nodes(self.quals)) 1074 return tuple(nodelist) 1075 1076 def __repr__(self): 1077 return "DictComp(%s, %s, %s)" % (repr(self.key), repr(self.value), repr(self.quals)) 1078 1079 class Mod(Node): 1080 def __init__(self, leftright, lineno=None): 1081 self.left = leftright[0] 1082 self.right = leftright[1] 1083 self.lineno = lineno 1084 1085 def getChildren(self): 1086 return self.left, self.right 1087 1088 def getChildNodes(self): 1089 return self.left, self.right 1090 1091 def __repr__(self): 1092 return "Mod((%s, %s))" % (repr(self.left), repr(self.right)) 1093 1094 def visit(self, visitor): 1095 return visitor.visitMod(self) 1096 1097 class Module(Node): 1098 def __init__(self, doc, node, lineno=None): 1099 self.doc = doc 1100 self.node = node 1101 self.lineno = lineno 1102 1103 def getChildren(self): 1104 return self.doc, self.node 1105 1106 def getChildNodes(self): 1107 return self.node, 1108 1109 def __repr__(self): 1110 return "Module(%s, %s)" % (repr(self.doc), repr(self.node)) 1111 1112 def visit(self, visitor): 1113 return visitor.visitModule(self) 1114 1115 class Mul(Node): 1116 def __init__(self, leftright, lineno=None): 1117 self.left = leftright[0] 1118 self.right = leftright[1] 1119 self.lineno = lineno 1120 1121 def getChildren(self): 1122 return self.left, self.right 1123 1124 def getChildNodes(self): 1125 return self.left, self.right 1126 1127 def __repr__(self): 1128 return "Mul((%s, %s))" % (repr(self.left), repr(self.right)) 1129 1130 def visit(self, visitor): 1131 return visitor.visitMul(self) 1132 1133 class Name(Node): 1134 def __init__(self, name, lineno=None): 1135 self.name = name 1136 self.lineno = lineno 1137 1138 def getChildren(self): 1139 return self.name, 1140 1141 def getChildNodes(self): 1142 return () 1143 1144 def __repr__(self): 1145 return "Name(%s)" % (repr(self.name),) 1146 1147 def visit(self, visitor): 1148 return visitor.visitName(self) 1149 1150 class Not(Node): 1151 def __init__(self, expr, lineno=None): 1152 self.expr = expr 1153 self.lineno = lineno 1154 1155 def getChildren(self): 1156 return self.expr, 1157 1158 def getChildNodes(self): 1159 return self.expr, 1160 1161 def __repr__(self): 1162 return "Not(%s)" % (repr(self.expr),) 1163 1164 def visit(self, visitor): 1165 return visitor.visitNot(self) 1166 1167 class Or(Node): 1168 def __init__(self, nodes, lineno=None): 1169 self.nodes = nodes 1170 self.lineno = lineno 1171 1172 def getChildren(self): 1173 return tuple(flatten(self.nodes)) 1174 1175 def getChildNodes(self): 1176 nodelist = [] 1177 nodelist.extend(flatten_nodes(self.nodes)) 1178 return tuple(nodelist) 1179 1180 def __repr__(self): 1181 return "Or(%s)" % (repr(self.nodes),) 1182 1183 def visit(self, visitor): 1184 return visitor.visitOr(self) 1185 1186 class Pass(Node): 1187 def __init__(self, lineno=None): 1188 self.lineno = lineno 1189 1190 def getChildren(self): 1191 return () 1192 1193 def getChildNodes(self): 1194 return () 1195 1196 def __repr__(self): 1197 return "Pass()" 1198 1199 def visit(self, visitor): 1200 return visitor.visitPass(self) 1201 1202 class Power(Node): 1203 def __init__(self, leftright, lineno=None): 1204 self.left = leftright[0] 1205 self.right = leftright[1] 1206 self.lineno = lineno 1207 1208 def getChildren(self): 1209 return self.left, self.right 1210 1211 def getChildNodes(self): 1212 return self.left, self.right 1213 1214 def __repr__(self): 1215 return "Power((%s, %s))" % (repr(self.left), repr(self.right)) 1216 1217 def visit(self, visitor): 1218 return visitor.visitPower(self) 1219 1220 class Print(Node): 1221 def __init__(self, nodes, dest, lineno=None): 1222 self.nodes = nodes 1223 self.dest = dest 1224 self.lineno = lineno 1225 1226 def getChildren(self): 1227 children = [] 1228 children.extend(flatten(self.nodes)) 1229 children.append(self.dest) 1230 return tuple(children) 1231 1232 def getChildNodes(self): 1233 nodelist = [] 1234 nodelist.extend(flatten_nodes(self.nodes)) 1235 if self.dest is not None: 1236 nodelist.append(self.dest) 1237 return tuple(nodelist) 1238 1239 def __repr__(self): 1240 return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest)) 1241 1242 def visit(self, visitor): 1243 return visitor.visitPrint(self) 1244 1245 class Printnl(Node): 1246 def __init__(self, nodes, dest, lineno=None): 1247 self.nodes = nodes 1248 self.dest = dest 1249 self.lineno = lineno 1250 1251 def getChildren(self): 1252 children = [] 1253 children.extend(flatten(self.nodes)) 1254 children.append(self.dest) 1255 return tuple(children) 1256 1257 def getChildNodes(self): 1258 nodelist = [] 1259 nodelist.extend(flatten_nodes(self.nodes)) 1260 if self.dest is not None: 1261 nodelist.append(self.dest) 1262 return tuple(nodelist) 1263 1264 def __repr__(self): 1265 return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest)) 1266 1267 def visit(self, visitor): 1268 return visitor.visitPrintnl(self) 1269 1270 class Raise(Node): 1271 def __init__(self, expr1, expr2, expr3, lineno=None): 1272 self.expr1 = expr1 1273 self.expr2 = expr2 1274 self.expr3 = expr3 1275 self.lineno = lineno 1276 1277 def getChildren(self): 1278 children = [] 1279 children.append(self.expr1) 1280 children.append(self.expr2) 1281 children.append(self.expr3) 1282 return tuple(children) 1283 1284 def getChildNodes(self): 1285 nodelist = [] 1286 if self.expr1 is not None: 1287 nodelist.append(self.expr1) 1288 if self.expr2 is not None: 1289 nodelist.append(self.expr2) 1290 if self.expr3 is not None: 1291 nodelist.append(self.expr3) 1292 return tuple(nodelist) 1293 1294 def __repr__(self): 1295 return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3)) 1296 1297 def visit(self, visitor): 1298 return visitor.visitRaise(self) 1299 1300 class Return(Node): 1301 def __init__(self, value, lineno=None): 1302 self.value = value 1303 self.lineno = lineno 1304 1305 def getChildren(self): 1306 return self.value, 1307 1308 def getChildNodes(self): 1309 return self.value, 1310 1311 def __repr__(self): 1312 return "Return(%s)" % (repr(self.value),) 1313 1314 def visit(self, visitor): 1315 return visitor.visitReturn(self) 1316 1317 class RightShift(Node): 1318 def __init__(self, leftright, lineno=None): 1319 self.left = leftright[0] 1320 self.right = leftright[1] 1321 self.lineno = lineno 1322 1323 def getChildren(self): 1324 return self.left, self.right 1325 1326 def getChildNodes(self): 1327 return self.left, self.right 1328 1329 def __repr__(self): 1330 return "RightShift((%s, %s))" % (repr(self.left), repr(self.right)) 1331 1332 def visit(self, visitor): 1333 return visitor.visitRightShift(self) 1334 1335 class Set(Node): 1336 def __init__(self, nodes, lineno=None): 1337 self.nodes = nodes 1338 self.lineno = lineno 1339 1340 def getChildren(self): 1341 return tuple(flatten(self.nodes)) 1342 1343 def getChildNodes(self): 1344 nodelist = [] 1345 nodelist.extend(flatten_nodes(self.nodes)) 1346 return tuple(nodelist) 1347 1348 def __repr__(self): 1349 return "Set(%s)" % (repr(self.nodes),) 1350 1351 class Slice(Node): 1352 def __init__(self, expr, flags, lower, upper, lineno=None): 1353 self.expr = expr 1354 self.flags = flags 1355 self.lower = lower 1356 self.upper = upper 1357 self.lineno = lineno 1358 1359 def getChildren(self): 1360 children = [] 1361 children.append(self.expr) 1362 children.append(self.flags) 1363 children.append(self.lower) 1364 children.append(self.upper) 1365 return tuple(children) 1366 1367 def getChildNodes(self): 1368 nodelist = [] 1369 nodelist.append(self.expr) 1370 if self.lower is not None: 1371 nodelist.append(self.lower) 1372 if self.upper is not None: 1373 nodelist.append(self.upper) 1374 return tuple(nodelist) 1375 1376 def __repr__(self): 1377 return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper)) 1378 1379 def visit(self, visitor): 1380 return visitor.visitSlice(self) 1381 1382 class Sliceobj(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 "Sliceobj(%s)" % (repr(self.nodes),) 1397 1398 def visit(self, visitor): 1399 return visitor.visitSliceobj(self) 1400 1401 class Stmt(Node): 1402 def __init__(self, nodes, lineno=None): 1403 self.nodes = nodes 1404 self.lineno = lineno 1405 1406 def getChildren(self): 1407 return tuple(flatten(self.nodes)) 1408 1409 def getChildNodes(self): 1410 nodelist = [] 1411 nodelist.extend(flatten_nodes(self.nodes)) 1412 return tuple(nodelist) 1413 1414 def __repr__(self): 1415 return "Stmt(%s)" % (repr(self.nodes),) 1416 1417 def visit(self, visitor): 1418 return visitor.visitStmt(self) 1419 1420 class Sub(Node): 1421 def __init__(self, leftright, lineno=None): 1422 self.left = leftright[0] 1423 self.right = leftright[1] 1424 self.lineno = lineno 1425 1426 def getChildren(self): 1427 return self.left, self.right 1428 1429 def getChildNodes(self): 1430 return self.left, self.right 1431 1432 def __repr__(self): 1433 return "Sub((%s, %s))" % (repr(self.left), repr(self.right)) 1434 1435 def visit(self, visitor): 1436 return visitor.visitSub(self) 1437 1438 class Subscript(Node): 1439 def __init__(self, expr, flags, subs, lineno=None): 1440 self.expr = expr 1441 self.flags = flags 1442 self.subs = subs 1443 self.lineno = lineno 1444 1445 def getChildren(self): 1446 children = [] 1447 children.append(self.expr) 1448 children.append(self.flags) 1449 children.extend(flatten(self.subs)) 1450 return tuple(children) 1451 1452 def getChildNodes(self): 1453 nodelist = [] 1454 nodelist.append(self.expr) 1455 nodelist.extend(flatten_nodes(self.subs)) 1456 return tuple(nodelist) 1457 1458 def __repr__(self): 1459 return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs)) 1460 1461 def visit(self, visitor): 1462 return visitor.visitSubscript(self) 1463 1464 class TryExcept(Node): 1465 def __init__(self, body, handlers, else_, lineno=None): 1466 self.body = body 1467 self.handlers = handlers 1468 self.else_ = else_ 1469 self.lineno = lineno 1470 1471 def getChildren(self): 1472 children = [] 1473 children.append(self.body) 1474 children.extend(flatten(self.handlers)) 1475 children.append(self.else_) 1476 return tuple(children) 1477 1478 def getChildNodes(self): 1479 nodelist = [] 1480 nodelist.append(self.body) 1481 nodelist.extend(flatten_nodes(self.handlers)) 1482 if self.else_ is not None: 1483 nodelist.append(self.else_) 1484 return tuple(nodelist) 1485 1486 def __repr__(self): 1487 return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_)) 1488 1489 def visit(self, visitor): 1490 return visitor.visitTryExcept(self) 1491 1492 class TryFinally(Node): 1493 def __init__(self, body, final, lineno=None): 1494 self.body = body 1495 self.final = final 1496 self.lineno = lineno 1497 1498 def getChildren(self): 1499 return self.body, self.final 1500 1501 def getChildNodes(self): 1502 return self.body, self.final 1503 1504 def __repr__(self): 1505 return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final)) 1506 1507 def visit(self, visitor): 1508 return visitor.visitTryFinally(self) 1509 1510 class Tuple(Node): 1511 def __init__(self, nodes, lineno=None): 1512 self.nodes = nodes 1513 self.lineno = lineno 1514 1515 def getChildren(self): 1516 return tuple(flatten(self.nodes)) 1517 1518 def getChildNodes(self): 1519 nodelist = [] 1520 nodelist.extend(flatten_nodes(self.nodes)) 1521 return tuple(nodelist) 1522 1523 def __repr__(self): 1524 return "Tuple(%s)" % (repr(self.nodes),) 1525 1526 def visit(self, visitor): 1527 return visitor.visitTuple(self) 1528 1529 class UnaryAdd(Node): 1530 def __init__(self, expr, lineno=None): 1531 self.expr = expr 1532 self.lineno = lineno 1533 1534 def getChildren(self): 1535 return self.expr, 1536 1537 def getChildNodes(self): 1538 return self.expr, 1539 1540 def __repr__(self): 1541 return "UnaryAdd(%s)" % (repr(self.expr),) 1542 1543 def visit(self, visitor): 1544 return visitor.visitUnaryAdd(self) 1545 1546 class UnarySub(Node): 1547 def __init__(self, expr, lineno=None): 1548 self.expr = expr 1549 self.lineno = lineno 1550 1551 def getChildren(self): 1552 return self.expr, 1553 1554 def getChildNodes(self): 1555 return self.expr, 1556 1557 def __repr__(self): 1558 return "UnarySub(%s)" % (repr(self.expr),) 1559 1560 def visit(self, visitor): 1561 return visitor.visitUnarySub(self) 1562 1563 class While(Node): 1564 def __init__(self, test, body, else_, lineno=None): 1565 self.test = test 1566 self.body = body 1567 self.else_ = else_ 1568 self.lineno = lineno 1569 1570 def getChildren(self): 1571 children = [] 1572 children.append(self.test) 1573 children.append(self.body) 1574 children.append(self.else_) 1575 return tuple(children) 1576 1577 def getChildNodes(self): 1578 nodelist = [] 1579 nodelist.append(self.test) 1580 nodelist.append(self.body) 1581 if self.else_ is not None: 1582 nodelist.append(self.else_) 1583 return tuple(nodelist) 1584 1585 def __repr__(self): 1586 return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_)) 1587 1588 def visit(self, visitor): 1589 return visitor.visitWhile(self) 1590 1591 class With(Node): 1592 def __init__(self, expr, vars, body, lineno=None): 1593 self.expr = expr 1594 self.vars = vars 1595 self.body = body 1596 self.lineno = lineno 1597 1598 def getChildren(self): 1599 children = [] 1600 children.append(self.expr) 1601 children.append(self.vars) 1602 children.append(self.body) 1603 return tuple(children) 1604 1605 def getChildNodes(self): 1606 nodelist = [] 1607 nodelist.append(self.expr) 1608 if self.vars is not None: 1609 nodelist.append(self.vars) 1610 nodelist.append(self.body) 1611 return tuple(nodelist) 1612 1613 def __repr__(self): 1614 return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body)) 1615 1616 def visit(self, visitor): 1617 return visitor.visitWith(self) 1618 1619 class Yield(Node): 1620 def __init__(self, value, lineno=None): 1621 self.value = value 1622 self.lineno = lineno 1623 1624 def getChildren(self): 1625 return self.value, 1626 1627 def getChildNodes(self): 1628 return self.value, 1629 1630 def __repr__(self): 1631 return "Yield(%s)" % (repr(self.value),) 1632 1633 def visit(self, visitor): 1634 return visitor.visitYield(self) 1635 1636 for name, obj in globals().items(): 1637 if isinstance(obj, type) and issubclass(obj, Node): 1638 nodes[name.lower()] = obj