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