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