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 def visit(self, visitor, *args): 35 visitor.default(self, *args) 36 37 class EmptyNode(Node): 38 pass 39 40 class Expression(Node): 41 # Expression is an artificial node class to support "eval" 42 nodes["expression"] = "Expression" 43 def __init__(self, node): 44 self.node = node 45 46 def getChildren(self): 47 return self.node, 48 49 def getChildNodes(self): 50 return self.node, 51 52 def __repr__(self): 53 return "Expression(%s)" % (repr(self.node)) 54 55 def visit(self, visitor, *args): 56 return visitor.visitExpression(self, *args) 57 58 class Add(Node): 59 def __init__(self, (left, right), lineno=None): 60 self.left = left 61 self.right = right 62 self.lineno = lineno 63 64 def getChildren(self): 65 return self.left, self.right 66 67 def getChildNodes(self): 68 return self.left, self.right 69 70 def __repr__(self): 71 return "Add((%s, %s))" % (repr(self.left), repr(self.right)) 72 73 def visit(self, visitor, *args): 74 return visitor.visitAdd(self, *args) 75 76 class And(Node): 77 def __init__(self, nodes, lineno=None): 78 self.nodes = nodes 79 self.lineno = lineno 80 81 def getChildren(self): 82 return tuple(flatten(self.nodes)) 83 84 def getChildNodes(self): 85 nodelist = [] 86 nodelist.extend(flatten_nodes(self.nodes)) 87 return tuple(nodelist) 88 89 def __repr__(self): 90 return "And(%s)" % (repr(self.nodes),) 91 92 def visit(self, visitor, *args): 93 return visitor.visitAnd(self, *args) 94 95 class AssAttr(Node): 96 def __init__(self, expr, attrname, flags, lineno=None): 97 self.expr = expr 98 self.attrname = attrname 99 self.flags = flags 100 self.lineno = lineno 101 102 def getChildren(self): 103 return self.expr, self.attrname, self.flags 104 105 def getChildNodes(self): 106 return self.expr, 107 108 def __repr__(self): 109 return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags)) 110 111 def visit(self, visitor, *args): 112 return visitor.visitAssAttr(self, *args) 113 114 class AssList(Node): 115 def __init__(self, nodes, lineno=None): 116 self.nodes = nodes 117 self.lineno = lineno 118 119 def getChildren(self): 120 return tuple(flatten(self.nodes)) 121 122 def getChildNodes(self): 123 nodelist = [] 124 nodelist.extend(flatten_nodes(self.nodes)) 125 return tuple(nodelist) 126 127 def __repr__(self): 128 return "AssList(%s)" % (repr(self.nodes),) 129 130 def visit(self, visitor, *args): 131 return visitor.visitAssList(self, *args) 132 133 class AssName(Node): 134 def __init__(self, name, flags, lineno=None): 135 self.name = name 136 self.flags = flags 137 self.lineno = lineno 138 139 def getChildren(self): 140 return self.name, self.flags 141 142 def getChildNodes(self): 143 return () 144 145 def __repr__(self): 146 return "AssName(%s, %s)" % (repr(self.name), repr(self.flags)) 147 148 def visit(self, visitor, *args): 149 return visitor.visitAssName(self, *args) 150 151 class AssTuple(Node): 152 def __init__(self, nodes, lineno=None): 153 self.nodes = nodes 154 self.lineno = lineno 155 156 def getChildren(self): 157 return tuple(flatten(self.nodes)) 158 159 def getChildNodes(self): 160 nodelist = [] 161 nodelist.extend(flatten_nodes(self.nodes)) 162 return tuple(nodelist) 163 164 def __repr__(self): 165 return "AssTuple(%s)" % (repr(self.nodes),) 166 167 def visit(self, visitor, *args): 168 return visitor.visitAssTuple(self, *args) 169 170 class Assert(Node): 171 def __init__(self, test, fail, lineno=None): 172 self.test = test 173 self.fail = fail 174 self.lineno = lineno 175 176 def getChildren(self): 177 children = [] 178 children.append(self.test) 179 children.append(self.fail) 180 return tuple(children) 181 182 def getChildNodes(self): 183 nodelist = [] 184 nodelist.append(self.test) 185 if self.fail is not None: 186 nodelist.append(self.fail) 187 return tuple(nodelist) 188 189 def __repr__(self): 190 return "Assert(%s, %s)" % (repr(self.test), repr(self.fail)) 191 192 def visit(self, visitor, *args): 193 return visitor.visitAssert(self, *args) 194 195 class Assign(Node): 196 def __init__(self, nodes, expr, lineno=None): 197 self.nodes = nodes 198 self.expr = expr 199 self.lineno = lineno 200 201 def getChildren(self): 202 children = [] 203 children.extend(flatten(self.nodes)) 204 children.append(self.expr) 205 return tuple(children) 206 207 def getChildNodes(self): 208 nodelist = [] 209 nodelist.extend(flatten_nodes(self.nodes)) 210 nodelist.append(self.expr) 211 return tuple(nodelist) 212 213 def __repr__(self): 214 return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr)) 215 216 def visit(self, visitor, *args): 217 return visitor.visitAssign(self, *args) 218 219 class AugAssign(Node): 220 def __init__(self, node, op, expr, lineno=None): 221 self.node = node 222 self.op = op 223 self.expr = expr 224 self.lineno = lineno 225 226 def getChildren(self): 227 return self.node, self.op, self.expr 228 229 def getChildNodes(self): 230 return self.node, self.expr 231 232 def __repr__(self): 233 return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr)) 234 235 def visit(self, visitor, *args): 236 return visitor.visitAugAssign(self, *args) 237 238 class Backquote(Node): 239 def __init__(self, expr, lineno=None): 240 self.expr = expr 241 self.lineno = lineno 242 243 def getChildren(self): 244 return self.expr, 245 246 def getChildNodes(self): 247 return self.expr, 248 249 def __repr__(self): 250 return "Backquote(%s)" % (repr(self.expr),) 251 252 def visit(self, visitor, *args): 253 return visitor.visitBackquote(self, *args) 254 255 class Bitand(Node): 256 def __init__(self, nodes, lineno=None): 257 self.nodes = nodes 258 self.lineno = lineno 259 260 def getChildren(self): 261 return tuple(flatten(self.nodes)) 262 263 def getChildNodes(self): 264 nodelist = [] 265 nodelist.extend(flatten_nodes(self.nodes)) 266 return tuple(nodelist) 267 268 def __repr__(self): 269 return "Bitand(%s)" % (repr(self.nodes),) 270 271 def visit(self, visitor, *args): 272 return visitor.visitBitand(self, *args) 273 274 class Bitor(Node): 275 def __init__(self, nodes, lineno=None): 276 self.nodes = nodes 277 self.lineno = lineno 278 279 def getChildren(self): 280 return tuple(flatten(self.nodes)) 281 282 def getChildNodes(self): 283 nodelist = [] 284 nodelist.extend(flatten_nodes(self.nodes)) 285 return tuple(nodelist) 286 287 def __repr__(self): 288 return "Bitor(%s)" % (repr(self.nodes),) 289 290 def visit(self, visitor, *args): 291 return visitor.visitBitor(self, *args) 292 293 class Bitxor(Node): 294 def __init__(self, nodes, lineno=None): 295 self.nodes = nodes 296 self.lineno = lineno 297 298 def getChildren(self): 299 return tuple(flatten(self.nodes)) 300 301 def getChildNodes(self): 302 nodelist = [] 303 nodelist.extend(flatten_nodes(self.nodes)) 304 return tuple(nodelist) 305 306 def __repr__(self): 307 return "Bitxor(%s)" % (repr(self.nodes),) 308 309 def visit(self, visitor, *args): 310 return visitor.visitBitxor(self, *args) 311 312 class Break(Node): 313 def __init__(self, lineno=None): 314 self.lineno = lineno 315 316 def getChildren(self): 317 return () 318 319 def getChildNodes(self): 320 return () 321 322 def __repr__(self): 323 return "Break()" 324 325 def visit(self, visitor, *args): 326 return visitor.visitBreak(self, *args) 327 328 class CallFunc(Node): 329 def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None): 330 self.node = node 331 self.args = args 332 self.star_args = star_args 333 self.dstar_args = dstar_args 334 self.lineno = lineno 335 336 def getChildren(self): 337 children = [] 338 children.append(self.node) 339 children.extend(flatten(self.args)) 340 children.append(self.star_args) 341 children.append(self.dstar_args) 342 return tuple(children) 343 344 def getChildNodes(self): 345 nodelist = [] 346 nodelist.append(self.node) 347 nodelist.extend(flatten_nodes(self.args)) 348 if self.star_args is not None: 349 nodelist.append(self.star_args) 350 if self.dstar_args is not None: 351 nodelist.append(self.dstar_args) 352 return tuple(nodelist) 353 354 def __repr__(self): 355 return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args)) 356 357 def visit(self, visitor, *args): 358 return visitor.visitCallFunc(self, *args) 359 360 class Class(Node): 361 def __init__(self, name, bases, doc, code, lineno=None): 362 self.name = name 363 self.bases = bases 364 self.doc = doc 365 self.code = code 366 self.lineno = lineno 367 368 def getChildren(self): 369 children = [] 370 children.append(self.name) 371 children.extend(flatten(self.bases)) 372 children.append(self.doc) 373 children.append(self.code) 374 return tuple(children) 375 376 def getChildNodes(self): 377 nodelist = [] 378 nodelist.extend(flatten_nodes(self.bases)) 379 nodelist.append(self.code) 380 return tuple(nodelist) 381 382 def __repr__(self): 383 return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code)) 384 385 def visit(self, visitor, *args): 386 return visitor.visitClass(self, *args) 387 388 class Compare(Node): 389 def __init__(self, expr, ops, lineno=None): 390 self.expr = expr 391 self.ops = ops 392 self.lineno = lineno 393 394 def getChildren(self): 395 children = [] 396 children.append(self.expr) 397 children.extend(flatten(self.ops)) 398 return tuple(children) 399 400 def getChildNodes(self): 401 nodelist = [] 402 nodelist.append(self.expr) 403 nodelist.extend(flatten_nodes(self.ops)) 404 return tuple(nodelist) 405 406 def __repr__(self): 407 return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops)) 408 409 def visit(self, visitor, *args): 410 return visitor.visitCompare(self, *args) 411 412 class Const(Node): 413 def __init__(self, value, lineno=None): 414 self.value = value 415 self.lineno = lineno 416 417 def getChildren(self): 418 return self.value, 419 420 def getChildNodes(self): 421 return () 422 423 def __repr__(self): 424 return "Const(%s)" % (repr(self.value),) 425 426 def visit(self, visitor, *args): 427 return visitor.visitConst(self, *args) 428 429 class Continue(Node): 430 def __init__(self, lineno=None): 431 self.lineno = lineno 432 433 def getChildren(self): 434 return () 435 436 def getChildNodes(self): 437 return () 438 439 def __repr__(self): 440 return "Continue()" 441 442 def visit(self, visitor, *args): 443 return visitor.visitContinue(self, *args) 444 445 class Decorators(Node): 446 def __init__(self, nodes, lineno=None): 447 self.nodes = nodes 448 self.lineno = lineno 449 450 def getChildren(self): 451 return tuple(flatten(self.nodes)) 452 453 def getChildNodes(self): 454 nodelist = [] 455 nodelist.extend(flatten_nodes(self.nodes)) 456 return tuple(nodelist) 457 458 def __repr__(self): 459 return "Decorators(%s)" % (repr(self.nodes),) 460 461 def visit(self, visitor, *args): 462 return visitor.visitDecorators(self, *args) 463 464 class Dict(Node): 465 def __init__(self, items, lineno=None): 466 self.items = items 467 self.lineno = lineno 468 469 def getChildren(self): 470 return tuple(flatten(self.items)) 471 472 def getChildNodes(self): 473 nodelist = [] 474 nodelist.extend(flatten_nodes(self.items)) 475 return tuple(nodelist) 476 477 def __repr__(self): 478 return "Dict(%s)" % (repr(self.items),) 479 480 def visit(self, visitor, *args): 481 return visitor.visitDict(self, *args) 482 483 class Discard(Node): 484 def __init__(self, expr, lineno=None): 485 self.expr = expr 486 self.lineno = lineno 487 488 def getChildren(self): 489 return self.expr, 490 491 def getChildNodes(self): 492 return self.expr, 493 494 def __repr__(self): 495 return "Discard(%s)" % (repr(self.expr),) 496 497 def visit(self, visitor, *args): 498 return visitor.visitDiscard(self, *args) 499 500 class Div(Node): 501 def __init__(self, (left, right), lineno=None): 502 self.left = left 503 self.right = right 504 self.lineno = lineno 505 506 def getChildren(self): 507 return self.left, self.right 508 509 def getChildNodes(self): 510 return self.left, self.right 511 512 def __repr__(self): 513 return "Div((%s, %s))" % (repr(self.left), repr(self.right)) 514 515 def visit(self, visitor, *args): 516 return visitor.visitDiv(self, *args) 517 518 class Ellipsis(Node): 519 def __init__(self, lineno=None): 520 self.lineno = lineno 521 522 def getChildren(self): 523 return () 524 525 def getChildNodes(self): 526 return () 527 528 def __repr__(self): 529 return "Ellipsis()" 530 531 def visit(self, visitor, *args): 532 return visitor.visitEllipsis(self, *args) 533 534 class Exec(Node): 535 def __init__(self, expr, locals, globals, lineno=None): 536 self.expr = expr 537 self.locals = locals 538 self.globals = globals 539 self.lineno = lineno 540 541 def getChildren(self): 542 children = [] 543 children.append(self.expr) 544 children.append(self.locals) 545 children.append(self.globals) 546 return tuple(children) 547 548 def getChildNodes(self): 549 nodelist = [] 550 nodelist.append(self.expr) 551 if self.locals is not None: 552 nodelist.append(self.locals) 553 if self.globals is not None: 554 nodelist.append(self.globals) 555 return tuple(nodelist) 556 557 def __repr__(self): 558 return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals)) 559 560 def visit(self, visitor, *args): 561 return visitor.visitExec(self, *args) 562 563 class FloorDiv(Node): 564 def __init__(self, (left, right), lineno=None): 565 self.left = left 566 self.right = right 567 self.lineno = lineno 568 569 def getChildren(self): 570 return self.left, self.right 571 572 def getChildNodes(self): 573 return self.left, self.right 574 575 def __repr__(self): 576 return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right)) 577 578 def visit(self, visitor, *args): 579 return visitor.visitFloorDiv(self, *args) 580 581 class For(Node): 582 def __init__(self, assign, list, body, else_, lineno=None): 583 self.assign = assign 584 self.list = list 585 self.body = body 586 self.else_ = else_ 587 self.lineno = lineno 588 589 def getChildren(self): 590 children = [] 591 children.append(self.assign) 592 children.append(self.list) 593 children.append(self.body) 594 children.append(self.else_) 595 return tuple(children) 596 597 def getChildNodes(self): 598 nodelist = [] 599 nodelist.append(self.assign) 600 nodelist.append(self.list) 601 nodelist.append(self.body) 602 if self.else_ is not None: 603 nodelist.append(self.else_) 604 return tuple(nodelist) 605 606 def __repr__(self): 607 return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_)) 608 609 def visit(self, visitor, *args): 610 return visitor.visitFor(self, *args) 611 612 class From(Node): 613 def __init__(self, modname, names, level, lineno=None): 614 self.modname = modname 615 self.names = names 616 self.level = level 617 self.lineno = lineno 618 619 def getChildren(self): 620 return self.modname, self.names, self.level 621 622 def getChildNodes(self): 623 return () 624 625 def __repr__(self): 626 return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level)) 627 628 def visit(self, visitor, *args): 629 return visitor.visitFrom(self, *args) 630 631 class Function(Node): 632 def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): 633 self.decorators = decorators 634 self.name = name 635 self.argnames = argnames 636 self.defaults = defaults 637 self.flags = flags 638 self.doc = doc 639 self.code = code 640 self.lineno = lineno 641 self.varargs = self.kwargs = None 642 if flags & CO_VARARGS: 643 self.varargs = 1 644 if flags & CO_VARKEYWORDS: 645 self.kwargs = 1 646 647 648 649 def getChildren(self): 650 children = [] 651 children.append(self.decorators) 652 children.append(self.name) 653 children.append(self.argnames) 654 children.extend(flatten(self.defaults)) 655 children.append(self.flags) 656 children.append(self.doc) 657 children.append(self.code) 658 return tuple(children) 659 660 def getChildNodes(self): 661 nodelist = [] 662 if self.decorators is not None: 663 nodelist.append(self.decorators) 664 nodelist.extend(flatten_nodes(self.defaults)) 665 nodelist.append(self.code) 666 return tuple(nodelist) 667 668 def __repr__(self): 669 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)) 670 671 def visit(self, visitor, *args): 672 return visitor.visitFunction(self, *args) 673 674 class GenExpr(Node): 675 def __init__(self, code, lineno=None): 676 self.code = code 677 self.lineno = lineno 678 self.argnames = ['.0'] 679 self.varargs = self.kwargs = None 680 681 def getChildren(self): 682 return self.code, 683 684 def getChildNodes(self): 685 return self.code, 686 687 def __repr__(self): 688 return "GenExpr(%s)" % (repr(self.code),) 689 690 def visit(self, visitor, *args): 691 return visitor.visitGenExpr(self, *args) 692 693 class GenExprFor(Node): 694 def __init__(self, assign, iter, ifs, lineno=None): 695 self.assign = assign 696 self.iter = iter 697 self.ifs = ifs 698 self.lineno = lineno 699 self.is_outmost = False 700 701 702 def getChildren(self): 703 children = [] 704 children.append(self.assign) 705 children.append(self.iter) 706 children.extend(flatten(self.ifs)) 707 return tuple(children) 708 709 def getChildNodes(self): 710 nodelist = [] 711 nodelist.append(self.assign) 712 nodelist.append(self.iter) 713 nodelist.extend(flatten_nodes(self.ifs)) 714 return tuple(nodelist) 715 716 def __repr__(self): 717 return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs)) 718 719 def visit(self, visitor, *args): 720 return visitor.visitGenExprFor(self, *args) 721 722 class GenExprIf(Node): 723 def __init__(self, test, lineno=None): 724 self.test = test 725 self.lineno = lineno 726 727 def getChildren(self): 728 return self.test, 729 730 def getChildNodes(self): 731 return self.test, 732 733 def __repr__(self): 734 return "GenExprIf(%s)" % (repr(self.test),) 735 736 def visit(self, visitor, *args): 737 return visitor.visitGenExprIf(self, *args) 738 739 class GenExprInner(Node): 740 def __init__(self, expr, quals, lineno=None): 741 self.expr = expr 742 self.quals = quals 743 self.lineno = lineno 744 745 def getChildren(self): 746 children = [] 747 children.append(self.expr) 748 children.extend(flatten(self.quals)) 749 return tuple(children) 750 751 def getChildNodes(self): 752 nodelist = [] 753 nodelist.append(self.expr) 754 nodelist.extend(flatten_nodes(self.quals)) 755 return tuple(nodelist) 756 757 def __repr__(self): 758 return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals)) 759 760 def visit(self, visitor, *args): 761 return visitor.visitGenExprInner(self, *args) 762 763 class Getattr(Node): 764 def __init__(self, expr, attrname, lineno=None): 765 self.expr = expr 766 self.attrname = attrname 767 self.lineno = lineno 768 769 def getChildren(self): 770 return self.expr, self.attrname 771 772 def getChildNodes(self): 773 return self.expr, 774 775 def __repr__(self): 776 return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname)) 777 778 def visit(self, visitor, *args): 779 return visitor.visitGetattr(self, *args) 780 781 class Global(Node): 782 def __init__(self, names, lineno=None): 783 self.names = names 784 self.lineno = lineno 785 786 def getChildren(self): 787 return self.names, 788 789 def getChildNodes(self): 790 return () 791 792 def __repr__(self): 793 return "Global(%s)" % (repr(self.names),) 794 795 def visit(self, visitor, *args): 796 return visitor.visitGlobal(self, *args) 797 798 class If(Node): 799 def __init__(self, tests, else_, lineno=None): 800 self.tests = tests 801 self.else_ = else_ 802 self.lineno = lineno 803 804 def getChildren(self): 805 children = [] 806 children.extend(flatten(self.tests)) 807 children.append(self.else_) 808 return tuple(children) 809 810 def getChildNodes(self): 811 nodelist = [] 812 nodelist.extend(flatten_nodes(self.tests)) 813 if self.else_ is not None: 814 nodelist.append(self.else_) 815 return tuple(nodelist) 816 817 def __repr__(self): 818 return "If(%s, %s)" % (repr(self.tests), repr(self.else_)) 819 820 def visit(self, visitor, *args): 821 return visitor.visitIf(self, *args) 822 823 class IfExp(Node): 824 def __init__(self, test, then, else_, lineno=None): 825 self.test = test 826 self.then = then 827 self.else_ = else_ 828 self.lineno = lineno 829 830 def getChildren(self): 831 return self.test, self.then, self.else_ 832 833 def getChildNodes(self): 834 return self.test, self.then, self.else_ 835 836 def __repr__(self): 837 return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_)) 838 839 def visit(self, visitor, *args): 840 return visitor.visitIfExp(self, *args) 841 842 class Import(Node): 843 def __init__(self, names, lineno=None): 844 self.names = names 845 self.lineno = lineno 846 847 def getChildren(self): 848 return self.names, 849 850 def getChildNodes(self): 851 return () 852 853 def __repr__(self): 854 return "Import(%s)" % (repr(self.names),) 855 856 def visit(self, visitor, *args): 857 return visitor.visitImport(self, *args) 858 859 class Invert(Node): 860 def __init__(self, expr, lineno=None): 861 self.expr = expr 862 self.lineno = lineno 863 864 def getChildren(self): 865 return self.expr, 866 867 def getChildNodes(self): 868 return self.expr, 869 870 def __repr__(self): 871 return "Invert(%s)" % (repr(self.expr),) 872 873 def visit(self, visitor, *args): 874 return visitor.visitInvert(self, *args) 875 876 class Keyword(Node): 877 def __init__(self, name, expr, lineno=None): 878 self.name = name 879 self.expr = expr 880 self.lineno = lineno 881 882 def getChildren(self): 883 return self.name, self.expr 884 885 def getChildNodes(self): 886 return self.expr, 887 888 def __repr__(self): 889 return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr)) 890 891 def visit(self, visitor, *args): 892 return visitor.visitKeyword(self, *args) 893 894 class Lambda(Node): 895 def __init__(self, argnames, defaults, flags, code, lineno=None): 896 self.argnames = argnames 897 self.defaults = defaults 898 self.flags = flags 899 self.code = code 900 self.lineno = lineno 901 self.varargs = self.kwargs = None 902 if flags & CO_VARARGS: 903 self.varargs = 1 904 if flags & CO_VARKEYWORDS: 905 self.kwargs = 1 906 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, *args): 927 return visitor.visitLambda(self, *args) 928 929 class LeftShift(Node): 930 def __init__(self, (left, right), lineno=None): 931 self.left = left 932 self.right = right 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, *args): 945 return visitor.visitLeftShift(self, *args) 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, *args): 964 return visitor.visitList(self, *args) 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, *args): 988 return visitor.visitListComp(self, *args) 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, *args): 1015 return visitor.visitListCompFor(self, *args) 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, *args): 1032 return visitor.visitListCompIf(self, *args) 1033 1034 class Mod(Node): 1035 def __init__(self, (left, right), lineno=None): 1036 self.left = left 1037 self.right = right 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, *args): 1050 return visitor.visitMod(self, *args) 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, *args): 1068 return visitor.visitModule(self, *args) 1069 1070 class Mul(Node): 1071 def __init__(self, (left, right), lineno=None): 1072 self.left = left 1073 self.right = right 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, *args): 1086 return visitor.visitMul(self, *args) 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, *args): 1103 return visitor.visitName(self, *args) 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, *args): 1120 return visitor.visitNot(self, *args) 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, *args): 1139 return visitor.visitOr(self, *args) 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, *args): 1155 return visitor.visitPass(self, *args) 1156 1157 class Power(Node): 1158 def __init__(self, (left, right), lineno=None): 1159 self.left = left 1160 self.right = right 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, *args): 1173 return visitor.visitPower(self, *args) 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, *args): 1198 return visitor.visitPrint(self, *args) 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, *args): 1223 return visitor.visitPrintnl(self, *args) 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, *args): 1253 return visitor.visitRaise(self, *args) 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, *args): 1270 return visitor.visitReturn(self, *args) 1271 1272 class RightShift(Node): 1273 def __init__(self, (left, right), lineno=None): 1274 self.left = left 1275 self.right = right 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, *args): 1288 return visitor.visitRightShift(self, *args) 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, *args): 1319 return visitor.visitSlice(self, *args) 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, *args): 1338 return visitor.visitSliceobj(self, *args) 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, *args): 1357 return visitor.visitStmt(self, *args) 1358 1359 class Sub(Node): 1360 def __init__(self, (left, right), lineno=None): 1361 self.left = left 1362 self.right = right 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, *args): 1375 return visitor.visitSub(self, *args) 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, *args): 1401 return visitor.visitSubscript(self, *args) 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, *args): 1429 return visitor.visitTryExcept(self, *args) 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, *args): 1447 return visitor.visitTryFinally(self, *args) 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, *args): 1466 return visitor.visitTuple(self, *args) 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, *args): 1483 return visitor.visitUnaryAdd(self, *args) 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, *args): 1500 return visitor.visitUnarySub(self, *args) 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, *args): 1528 return visitor.visitWhile(self, *args) 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, *args): 1556 return visitor.visitWith(self, *args) 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, *args): 1573 return visitor.visitYield(self, *args) 1574 1575 for name, obj in globals().items(): 1576 if isinstance(obj, type) and issubclass(obj, Node): 1577 nodes[name.lower()] = obj