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 def visit(self, visitor): 1056 return visitor.visitSetComp(self) 1057 1058 class DictComp(Node): 1059 def __init__(self, key, value, quals, lineno=None): 1060 self.key = key 1061 self.value = value 1062 self.quals = quals 1063 self.lineno = lineno 1064 1065 def getChildren(self): 1066 children = [] 1067 children.append(self.key) 1068 children.append(self.value) 1069 children.extend(flatten(self.quals)) 1070 return tuple(children) 1071 1072 def getChildNodes(self): 1073 nodelist = [] 1074 nodelist.append(self.key) 1075 nodelist.append(self.value) 1076 nodelist.extend(flatten_nodes(self.quals)) 1077 return tuple(nodelist) 1078 1079 def __repr__(self): 1080 return "DictComp(%s, %s, %s)" % (repr(self.key), repr(self.value), repr(self.quals)) 1081 1082 def visit(self, visitor): 1083 return visitor.visitDictComp(self) 1084 1085 class Mod(Node): 1086 def __init__(self, leftright, lineno=None): 1087 self.left = leftright[0] 1088 self.right = leftright[1] 1089 self.lineno = lineno 1090 1091 def getChildren(self): 1092 return self.left, self.right 1093 1094 def getChildNodes(self): 1095 return self.left, self.right 1096 1097 def __repr__(self): 1098 return "Mod((%s, %s))" % (repr(self.left), repr(self.right)) 1099 1100 def visit(self, visitor): 1101 return visitor.visitMod(self) 1102 1103 class Module(Node): 1104 def __init__(self, doc, node, lineno=None): 1105 self.doc = doc 1106 self.node = node 1107 self.lineno = lineno 1108 1109 def getChildren(self): 1110 return self.doc, self.node 1111 1112 def getChildNodes(self): 1113 return self.node, 1114 1115 def __repr__(self): 1116 return "Module(%s, %s)" % (repr(self.doc), repr(self.node)) 1117 1118 def visit(self, visitor): 1119 return visitor.visitModule(self) 1120 1121 class Mul(Node): 1122 def __init__(self, leftright, lineno=None): 1123 self.left = leftright[0] 1124 self.right = leftright[1] 1125 self.lineno = lineno 1126 1127 def getChildren(self): 1128 return self.left, self.right 1129 1130 def getChildNodes(self): 1131 return self.left, self.right 1132 1133 def __repr__(self): 1134 return "Mul((%s, %s))" % (repr(self.left), repr(self.right)) 1135 1136 def visit(self, visitor): 1137 return visitor.visitMul(self) 1138 1139 class Name(Node): 1140 def __init__(self, name, lineno=None): 1141 self.name = name 1142 self.lineno = lineno 1143 1144 def getChildren(self): 1145 return self.name, 1146 1147 def getChildNodes(self): 1148 return () 1149 1150 def __repr__(self): 1151 return "Name(%s)" % (repr(self.name),) 1152 1153 def visit(self, visitor): 1154 return visitor.visitName(self) 1155 1156 class Not(Node): 1157 def __init__(self, expr, lineno=None): 1158 self.expr = expr 1159 self.lineno = lineno 1160 1161 def getChildren(self): 1162 return self.expr, 1163 1164 def getChildNodes(self): 1165 return self.expr, 1166 1167 def __repr__(self): 1168 return "Not(%s)" % (repr(self.expr),) 1169 1170 def visit(self, visitor): 1171 return visitor.visitNot(self) 1172 1173 class Or(Node): 1174 def __init__(self, nodes, lineno=None): 1175 self.nodes = nodes 1176 self.lineno = lineno 1177 1178 def getChildren(self): 1179 return tuple(flatten(self.nodes)) 1180 1181 def getChildNodes(self): 1182 nodelist = [] 1183 nodelist.extend(flatten_nodes(self.nodes)) 1184 return tuple(nodelist) 1185 1186 def __repr__(self): 1187 return "Or(%s)" % (repr(self.nodes),) 1188 1189 def visit(self, visitor): 1190 return visitor.visitOr(self) 1191 1192 class Pass(Node): 1193 def __init__(self, lineno=None): 1194 self.lineno = lineno 1195 1196 def getChildren(self): 1197 return () 1198 1199 def getChildNodes(self): 1200 return () 1201 1202 def __repr__(self): 1203 return "Pass()" 1204 1205 def visit(self, visitor): 1206 return visitor.visitPass(self) 1207 1208 class Power(Node): 1209 def __init__(self, leftright, lineno=None): 1210 self.left = leftright[0] 1211 self.right = leftright[1] 1212 self.lineno = lineno 1213 1214 def getChildren(self): 1215 return self.left, self.right 1216 1217 def getChildNodes(self): 1218 return self.left, self.right 1219 1220 def __repr__(self): 1221 return "Power((%s, %s))" % (repr(self.left), repr(self.right)) 1222 1223 def visit(self, visitor): 1224 return visitor.visitPower(self) 1225 1226 class Print(Node): 1227 def __init__(self, nodes, dest, lineno=None): 1228 self.nodes = nodes 1229 self.dest = dest 1230 self.lineno = lineno 1231 1232 def getChildren(self): 1233 children = [] 1234 children.extend(flatten(self.nodes)) 1235 children.append(self.dest) 1236 return tuple(children) 1237 1238 def getChildNodes(self): 1239 nodelist = [] 1240 nodelist.extend(flatten_nodes(self.nodes)) 1241 if self.dest is not None: 1242 nodelist.append(self.dest) 1243 return tuple(nodelist) 1244 1245 def __repr__(self): 1246 return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest)) 1247 1248 def visit(self, visitor): 1249 return visitor.visitPrint(self) 1250 1251 class Printnl(Node): 1252 def __init__(self, nodes, dest, lineno=None): 1253 self.nodes = nodes 1254 self.dest = dest 1255 self.lineno = lineno 1256 1257 def getChildren(self): 1258 children = [] 1259 children.extend(flatten(self.nodes)) 1260 children.append(self.dest) 1261 return tuple(children) 1262 1263 def getChildNodes(self): 1264 nodelist = [] 1265 nodelist.extend(flatten_nodes(self.nodes)) 1266 if self.dest is not None: 1267 nodelist.append(self.dest) 1268 return tuple(nodelist) 1269 1270 def __repr__(self): 1271 return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest)) 1272 1273 def visit(self, visitor): 1274 return visitor.visitPrintnl(self) 1275 1276 class Raise(Node): 1277 def __init__(self, expr1, expr2, expr3, lineno=None): 1278 self.expr1 = expr1 1279 self.expr2 = expr2 1280 self.expr3 = expr3 1281 self.lineno = lineno 1282 1283 def getChildren(self): 1284 children = [] 1285 children.append(self.expr1) 1286 children.append(self.expr2) 1287 children.append(self.expr3) 1288 return tuple(children) 1289 1290 def getChildNodes(self): 1291 nodelist = [] 1292 if self.expr1 is not None: 1293 nodelist.append(self.expr1) 1294 if self.expr2 is not None: 1295 nodelist.append(self.expr2) 1296 if self.expr3 is not None: 1297 nodelist.append(self.expr3) 1298 return tuple(nodelist) 1299 1300 def __repr__(self): 1301 return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3)) 1302 1303 def visit(self, visitor): 1304 return visitor.visitRaise(self) 1305 1306 class Return(Node): 1307 def __init__(self, value, lineno=None): 1308 self.value = value 1309 self.lineno = lineno 1310 1311 def getChildren(self): 1312 return self.value, 1313 1314 def getChildNodes(self): 1315 return self.value, 1316 1317 def __repr__(self): 1318 return "Return(%s)" % (repr(self.value),) 1319 1320 def visit(self, visitor): 1321 return visitor.visitReturn(self) 1322 1323 class RightShift(Node): 1324 def __init__(self, leftright, lineno=None): 1325 self.left = leftright[0] 1326 self.right = leftright[1] 1327 self.lineno = lineno 1328 1329 def getChildren(self): 1330 return self.left, self.right 1331 1332 def getChildNodes(self): 1333 return self.left, self.right 1334 1335 def __repr__(self): 1336 return "RightShift((%s, %s))" % (repr(self.left), repr(self.right)) 1337 1338 def visit(self, visitor): 1339 return visitor.visitRightShift(self) 1340 1341 class Set(Node): 1342 def __init__(self, nodes, lineno=None): 1343 self.nodes = nodes 1344 self.lineno = lineno 1345 1346 def getChildren(self): 1347 return tuple(flatten(self.nodes)) 1348 1349 def getChildNodes(self): 1350 nodelist = [] 1351 nodelist.extend(flatten_nodes(self.nodes)) 1352 return tuple(nodelist) 1353 1354 def __repr__(self): 1355 return "Set(%s)" % (repr(self.nodes),) 1356 1357 def visit(self, visitor): 1358 return visitor.visitSet(self) 1359 1360 class Slice(Node): 1361 def __init__(self, expr, flags, lower, upper, lineno=None): 1362 self.expr = expr 1363 self.flags = flags 1364 self.lower = lower 1365 self.upper = upper 1366 self.lineno = lineno 1367 1368 def getChildren(self): 1369 children = [] 1370 children.append(self.expr) 1371 children.append(self.flags) 1372 children.append(self.lower) 1373 children.append(self.upper) 1374 return tuple(children) 1375 1376 def getChildNodes(self): 1377 nodelist = [] 1378 nodelist.append(self.expr) 1379 if self.lower is not None: 1380 nodelist.append(self.lower) 1381 if self.upper is not None: 1382 nodelist.append(self.upper) 1383 return tuple(nodelist) 1384 1385 def __repr__(self): 1386 return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper)) 1387 1388 def visit(self, visitor): 1389 return visitor.visitSlice(self) 1390 1391 class Sliceobj(Node): 1392 def __init__(self, nodes, lineno=None): 1393 self.nodes = nodes 1394 self.lineno = lineno 1395 1396 def getChildren(self): 1397 return tuple(flatten(self.nodes)) 1398 1399 def getChildNodes(self): 1400 nodelist = [] 1401 nodelist.extend(flatten_nodes(self.nodes)) 1402 return tuple(nodelist) 1403 1404 def __repr__(self): 1405 return "Sliceobj(%s)" % (repr(self.nodes),) 1406 1407 def visit(self, visitor): 1408 return visitor.visitSliceobj(self) 1409 1410 class Stmt(Node): 1411 def __init__(self, nodes, lineno=None): 1412 self.nodes = nodes 1413 self.lineno = lineno 1414 1415 def getChildren(self): 1416 return tuple(flatten(self.nodes)) 1417 1418 def getChildNodes(self): 1419 nodelist = [] 1420 nodelist.extend(flatten_nodes(self.nodes)) 1421 return tuple(nodelist) 1422 1423 def __repr__(self): 1424 return "Stmt(%s)" % (repr(self.nodes),) 1425 1426 def visit(self, visitor): 1427 return visitor.visitStmt(self) 1428 1429 class Sub(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 "Sub((%s, %s))" % (repr(self.left), repr(self.right)) 1443 1444 def visit(self, visitor): 1445 return visitor.visitSub(self) 1446 1447 class Subscript(Node): 1448 def __init__(self, expr, flags, subs, lineno=None): 1449 self.expr = expr 1450 self.flags = flags 1451 self.subs = subs 1452 self.lineno = lineno 1453 1454 def getChildren(self): 1455 children = [] 1456 children.append(self.expr) 1457 children.append(self.flags) 1458 children.extend(flatten(self.subs)) 1459 return tuple(children) 1460 1461 def getChildNodes(self): 1462 nodelist = [] 1463 nodelist.append(self.expr) 1464 nodelist.extend(flatten_nodes(self.subs)) 1465 return tuple(nodelist) 1466 1467 def __repr__(self): 1468 return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs)) 1469 1470 def visit(self, visitor): 1471 return visitor.visitSubscript(self) 1472 1473 class TryExcept(Node): 1474 def __init__(self, body, handlers, else_, lineno=None): 1475 self.body = body 1476 self.handlers = handlers 1477 self.else_ = else_ 1478 self.lineno = lineno 1479 1480 def getChildren(self): 1481 children = [] 1482 children.append(self.body) 1483 children.extend(flatten(self.handlers)) 1484 children.append(self.else_) 1485 return tuple(children) 1486 1487 def getChildNodes(self): 1488 nodelist = [] 1489 nodelist.append(self.body) 1490 nodelist.extend(flatten_nodes(self.handlers)) 1491 if self.else_ is not None: 1492 nodelist.append(self.else_) 1493 return tuple(nodelist) 1494 1495 def __repr__(self): 1496 return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_)) 1497 1498 def visit(self, visitor): 1499 return visitor.visitTryExcept(self) 1500 1501 class TryFinally(Node): 1502 def __init__(self, body, final, lineno=None): 1503 self.body = body 1504 self.final = final 1505 self.lineno = lineno 1506 1507 def getChildren(self): 1508 return self.body, self.final 1509 1510 def getChildNodes(self): 1511 return self.body, self.final 1512 1513 def __repr__(self): 1514 return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final)) 1515 1516 def visit(self, visitor): 1517 return visitor.visitTryFinally(self) 1518 1519 class Tuple(Node): 1520 def __init__(self, nodes, lineno=None): 1521 self.nodes = nodes 1522 self.lineno = lineno 1523 1524 def getChildren(self): 1525 return tuple(flatten(self.nodes)) 1526 1527 def getChildNodes(self): 1528 nodelist = [] 1529 nodelist.extend(flatten_nodes(self.nodes)) 1530 return tuple(nodelist) 1531 1532 def __repr__(self): 1533 return "Tuple(%s)" % (repr(self.nodes),) 1534 1535 def visit(self, visitor): 1536 return visitor.visitTuple(self) 1537 1538 class UnaryAdd(Node): 1539 def __init__(self, expr, lineno=None): 1540 self.expr = expr 1541 self.lineno = lineno 1542 1543 def getChildren(self): 1544 return self.expr, 1545 1546 def getChildNodes(self): 1547 return self.expr, 1548 1549 def __repr__(self): 1550 return "UnaryAdd(%s)" % (repr(self.expr),) 1551 1552 def visit(self, visitor): 1553 return visitor.visitUnaryAdd(self) 1554 1555 class UnarySub(Node): 1556 def __init__(self, expr, lineno=None): 1557 self.expr = expr 1558 self.lineno = lineno 1559 1560 def getChildren(self): 1561 return self.expr, 1562 1563 def getChildNodes(self): 1564 return self.expr, 1565 1566 def __repr__(self): 1567 return "UnarySub(%s)" % (repr(self.expr),) 1568 1569 def visit(self, visitor): 1570 return visitor.visitUnarySub(self) 1571 1572 class While(Node): 1573 def __init__(self, test, body, else_, lineno=None): 1574 self.test = test 1575 self.body = body 1576 self.else_ = else_ 1577 self.lineno = lineno 1578 1579 def getChildren(self): 1580 children = [] 1581 children.append(self.test) 1582 children.append(self.body) 1583 children.append(self.else_) 1584 return tuple(children) 1585 1586 def getChildNodes(self): 1587 nodelist = [] 1588 nodelist.append(self.test) 1589 nodelist.append(self.body) 1590 if self.else_ is not None: 1591 nodelist.append(self.else_) 1592 return tuple(nodelist) 1593 1594 def __repr__(self): 1595 return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_)) 1596 1597 def visit(self, visitor): 1598 return visitor.visitWhile(self) 1599 1600 class With(Node): 1601 def __init__(self, expr, vars, body, lineno=None): 1602 self.expr = expr 1603 self.vars = vars 1604 self.body = body 1605 self.lineno = lineno 1606 1607 def getChildren(self): 1608 children = [] 1609 children.append(self.expr) 1610 children.append(self.vars) 1611 children.append(self.body) 1612 return tuple(children) 1613 1614 def getChildNodes(self): 1615 nodelist = [] 1616 nodelist.append(self.expr) 1617 if self.vars is not None: 1618 nodelist.append(self.vars) 1619 nodelist.append(self.body) 1620 return tuple(nodelist) 1621 1622 def __repr__(self): 1623 return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body)) 1624 1625 def visit(self, visitor): 1626 return visitor.visitWith(self) 1627 1628 class Yield(Node): 1629 def __init__(self, value, lineno=None): 1630 self.value = value 1631 self.lineno = lineno 1632 1633 def getChildren(self): 1634 return self.value, 1635 1636 def getChildNodes(self): 1637 return self.value, 1638 1639 def __repr__(self): 1640 return "Yield(%s)" % (repr(self.value),) 1641 1642 def visit(self, visitor): 1643 return visitor.visitYield(self) 1644 1645 for name, obj in globals().items(): 1646 if isinstance(obj, type) and issubclass(obj, Node): 1647 nodes[name.lower()] = obj