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 class Add(Node): 54 def __init__(self, leftright, lineno=None): 55 self.left = leftright[0] 56 self.right = leftright[1] 57 self.lineno = lineno 58 59 def getChildren(self): 60 return self.left, self.right 61 62 def getChildNodes(self): 63 return self.left, self.right 64 65 def __repr__(self): 66 return "Add((%s, %s))" % (repr(self.left), repr(self.right)) 67 68 class And(Node): 69 def __init__(self, nodes, lineno=None): 70 self.nodes = nodes 71 self.lineno = lineno 72 73 def getChildren(self): 74 return tuple(flatten(self.nodes)) 75 76 def getChildNodes(self): 77 nodelist = [] 78 nodelist.extend(flatten_nodes(self.nodes)) 79 return tuple(nodelist) 80 81 def __repr__(self): 82 return "And(%s)" % (repr(self.nodes),) 83 84 class AssAttr(Node): 85 def __init__(self, expr, attrname, flags, lineno=None): 86 self.expr = expr 87 self.attrname = attrname 88 self.flags = flags 89 self.lineno = lineno 90 91 def getChildren(self): 92 return self.expr, self.attrname, self.flags 93 94 def getChildNodes(self): 95 return self.expr, 96 97 def __repr__(self): 98 return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags)) 99 100 class AssList(Node): 101 def __init__(self, nodes, lineno=None): 102 self.nodes = nodes 103 self.lineno = lineno 104 105 def getChildren(self): 106 return tuple(flatten(self.nodes)) 107 108 def getChildNodes(self): 109 nodelist = [] 110 nodelist.extend(flatten_nodes(self.nodes)) 111 return tuple(nodelist) 112 113 def __repr__(self): 114 return "AssList(%s)" % (repr(self.nodes),) 115 116 class AssName(Node): 117 def __init__(self, name, flags, lineno=None): 118 self.name = name 119 self.flags = flags 120 self.lineno = lineno 121 122 def getChildren(self): 123 return self.name, self.flags 124 125 def getChildNodes(self): 126 return () 127 128 def __repr__(self): 129 return "AssName(%s, %s)" % (repr(self.name), repr(self.flags)) 130 131 class AssTuple(Node): 132 def __init__(self, nodes, lineno=None): 133 self.nodes = nodes 134 self.lineno = lineno 135 136 def getChildren(self): 137 return tuple(flatten(self.nodes)) 138 139 def getChildNodes(self): 140 nodelist = [] 141 nodelist.extend(flatten_nodes(self.nodes)) 142 return tuple(nodelist) 143 144 def __repr__(self): 145 return "AssTuple(%s)" % (repr(self.nodes),) 146 147 class Assert(Node): 148 def __init__(self, test, fail, lineno=None): 149 self.test = test 150 self.fail = fail 151 self.lineno = lineno 152 153 def getChildren(self): 154 children = [] 155 children.append(self.test) 156 children.append(self.fail) 157 return tuple(children) 158 159 def getChildNodes(self): 160 nodelist = [] 161 nodelist.append(self.test) 162 if self.fail is not None: 163 nodelist.append(self.fail) 164 return tuple(nodelist) 165 166 def __repr__(self): 167 return "Assert(%s, %s)" % (repr(self.test), repr(self.fail)) 168 169 class Assign(Node): 170 def __init__(self, nodes, expr, lineno=None): 171 self.nodes = nodes 172 self.expr = expr 173 self.lineno = lineno 174 175 def getChildren(self): 176 children = [] 177 children.extend(flatten(self.nodes)) 178 children.append(self.expr) 179 return tuple(children) 180 181 def getChildNodes(self): 182 nodelist = [] 183 nodelist.extend(flatten_nodes(self.nodes)) 184 nodelist.append(self.expr) 185 return tuple(nodelist) 186 187 def __repr__(self): 188 return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr)) 189 190 class AugAssign(Node): 191 def __init__(self, node, op, expr, lineno=None): 192 self.node = node 193 self.op = op 194 self.expr = expr 195 self.lineno = lineno 196 197 def getChildren(self): 198 return self.node, self.op, self.expr 199 200 def getChildNodes(self): 201 return self.node, self.expr 202 203 def __repr__(self): 204 return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr)) 205 206 class Backquote(Node): 207 def __init__(self, expr, lineno=None): 208 self.expr = expr 209 self.lineno = lineno 210 211 def getChildren(self): 212 return self.expr, 213 214 def getChildNodes(self): 215 return self.expr, 216 217 def __repr__(self): 218 return "Backquote(%s)" % (repr(self.expr),) 219 220 class Bitand(Node): 221 def __init__(self, nodes, lineno=None): 222 self.nodes = nodes 223 self.lineno = lineno 224 225 def getChildren(self): 226 return tuple(flatten(self.nodes)) 227 228 def getChildNodes(self): 229 nodelist = [] 230 nodelist.extend(flatten_nodes(self.nodes)) 231 return tuple(nodelist) 232 233 def __repr__(self): 234 return "Bitand(%s)" % (repr(self.nodes),) 235 236 class Bitor(Node): 237 def __init__(self, nodes, lineno=None): 238 self.nodes = nodes 239 self.lineno = lineno 240 241 def getChildren(self): 242 return tuple(flatten(self.nodes)) 243 244 def getChildNodes(self): 245 nodelist = [] 246 nodelist.extend(flatten_nodes(self.nodes)) 247 return tuple(nodelist) 248 249 def __repr__(self): 250 return "Bitor(%s)" % (repr(self.nodes),) 251 252 class Bitxor(Node): 253 def __init__(self, nodes, lineno=None): 254 self.nodes = nodes 255 self.lineno = lineno 256 257 def getChildren(self): 258 return tuple(flatten(self.nodes)) 259 260 def getChildNodes(self): 261 nodelist = [] 262 nodelist.extend(flatten_nodes(self.nodes)) 263 return tuple(nodelist) 264 265 def __repr__(self): 266 return "Bitxor(%s)" % (repr(self.nodes),) 267 268 class Break(Node): 269 def __init__(self, lineno=None): 270 self.lineno = lineno 271 272 def getChildren(self): 273 return () 274 275 def getChildNodes(self): 276 return () 277 278 def __repr__(self): 279 return "Break()" 280 281 class CallFunc(Node): 282 def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None): 283 self.node = node 284 self.args = args 285 self.star_args = star_args 286 self.dstar_args = dstar_args 287 self.lineno = lineno 288 289 def getChildren(self): 290 children = [] 291 children.append(self.node) 292 children.extend(flatten(self.args)) 293 children.append(self.star_args) 294 children.append(self.dstar_args) 295 return tuple(children) 296 297 def getChildNodes(self): 298 nodelist = [] 299 nodelist.append(self.node) 300 nodelist.extend(flatten_nodes(self.args)) 301 if self.star_args is not None: 302 nodelist.append(self.star_args) 303 if self.dstar_args is not None: 304 nodelist.append(self.dstar_args) 305 return tuple(nodelist) 306 307 def __repr__(self): 308 return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args)) 309 310 class Class(Node): 311 def __init__(self, name, bases, doc, code, decorators = None, lineno=None): 312 self.name = name 313 self.bases = bases 314 self.doc = doc 315 self.code = code 316 self.decorators = decorators 317 self.lineno = lineno 318 319 def getChildren(self): 320 children = [] 321 children.append(self.name) 322 children.extend(flatten(self.bases)) 323 children.append(self.doc) 324 children.append(self.code) 325 children.append(self.decorators) 326 return tuple(children) 327 328 def getChildNodes(self): 329 nodelist = [] 330 nodelist.extend(flatten_nodes(self.bases)) 331 nodelist.append(self.code) 332 if self.decorators is not None: 333 nodelist.append(self.decorators) 334 return tuple(nodelist) 335 336 def __repr__(self): 337 return "Class(%s, %s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code), repr(self.decorators)) 338 339 class Compare(Node): 340 def __init__(self, expr, ops, lineno=None): 341 self.expr = expr 342 self.ops = ops 343 self.lineno = lineno 344 345 def getChildren(self): 346 children = [] 347 children.append(self.expr) 348 children.extend(flatten(self.ops)) 349 return tuple(children) 350 351 def getChildNodes(self): 352 nodelist = [] 353 nodelist.append(self.expr) 354 nodelist.extend(flatten_nodes(self.ops)) 355 return tuple(nodelist) 356 357 def __repr__(self): 358 return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops)) 359 360 class Const(Node): 361 def __init__(self, value, lineno=None): 362 self.value = value 363 self.lineno = lineno 364 365 def getChildren(self): 366 return self.value, 367 368 def getChildNodes(self): 369 return () 370 371 def __repr__(self): 372 return "Const(%s)" % (repr(self.value),) 373 374 class Continue(Node): 375 def __init__(self, lineno=None): 376 self.lineno = lineno 377 378 def getChildren(self): 379 return () 380 381 def getChildNodes(self): 382 return () 383 384 def __repr__(self): 385 return "Continue()" 386 387 class Decorators(Node): 388 def __init__(self, nodes, lineno=None): 389 self.nodes = nodes 390 self.lineno = lineno 391 392 def getChildren(self): 393 return tuple(flatten(self.nodes)) 394 395 def getChildNodes(self): 396 nodelist = [] 397 nodelist.extend(flatten_nodes(self.nodes)) 398 return tuple(nodelist) 399 400 def __repr__(self): 401 return "Decorators(%s)" % (repr(self.nodes),) 402 403 class Dict(Node): 404 def __init__(self, items, lineno=None): 405 self.items = items 406 self.lineno = lineno 407 408 def getChildren(self): 409 return tuple(flatten(self.items)) 410 411 def getChildNodes(self): 412 nodelist = [] 413 nodelist.extend(flatten_nodes(self.items)) 414 return tuple(nodelist) 415 416 def __repr__(self): 417 return "Dict(%s)" % (repr(self.items),) 418 419 class Discard(Node): 420 def __init__(self, expr, lineno=None): 421 self.expr = expr 422 self.lineno = lineno 423 424 def getChildren(self): 425 return self.expr, 426 427 def getChildNodes(self): 428 return self.expr, 429 430 def __repr__(self): 431 return "Discard(%s)" % (repr(self.expr),) 432 433 class Div(Node): 434 def __init__(self, leftright, lineno=None): 435 self.left = leftright[0] 436 self.right = leftright[1] 437 self.lineno = lineno 438 439 def getChildren(self): 440 return self.left, self.right 441 442 def getChildNodes(self): 443 return self.left, self.right 444 445 def __repr__(self): 446 return "Div((%s, %s))" % (repr(self.left), repr(self.right)) 447 448 class Ellipsis(Node): 449 def __init__(self, lineno=None): 450 self.lineno = lineno 451 452 def getChildren(self): 453 return () 454 455 def getChildNodes(self): 456 return () 457 458 def __repr__(self): 459 return "Ellipsis()" 460 461 class Exec(Node): 462 def __init__(self, expr, locals, globals, lineno=None): 463 self.expr = expr 464 self.locals = locals 465 self.globals = globals 466 self.lineno = lineno 467 468 def getChildren(self): 469 children = [] 470 children.append(self.expr) 471 children.append(self.locals) 472 children.append(self.globals) 473 return tuple(children) 474 475 def getChildNodes(self): 476 nodelist = [] 477 nodelist.append(self.expr) 478 if self.locals is not None: 479 nodelist.append(self.locals) 480 if self.globals is not None: 481 nodelist.append(self.globals) 482 return tuple(nodelist) 483 484 def __repr__(self): 485 return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals)) 486 487 class FloorDiv(Node): 488 def __init__(self, leftright, lineno=None): 489 self.left = leftright[0] 490 self.right = leftright[1] 491 self.lineno = lineno 492 493 def getChildren(self): 494 return self.left, self.right 495 496 def getChildNodes(self): 497 return self.left, self.right 498 499 def __repr__(self): 500 return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right)) 501 502 class For(Node): 503 def __init__(self, assign, list, body, else_, lineno=None): 504 self.assign = assign 505 self.list = list 506 self.body = body 507 self.else_ = else_ 508 self.lineno = lineno 509 510 def getChildren(self): 511 children = [] 512 children.append(self.assign) 513 children.append(self.list) 514 children.append(self.body) 515 children.append(self.else_) 516 return tuple(children) 517 518 def getChildNodes(self): 519 nodelist = [] 520 nodelist.append(self.assign) 521 nodelist.append(self.list) 522 nodelist.append(self.body) 523 if self.else_ is not None: 524 nodelist.append(self.else_) 525 return tuple(nodelist) 526 527 def __repr__(self): 528 return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_)) 529 530 class From(Node): 531 def __init__(self, modname, names, level, lineno=None): 532 self.modname = modname 533 self.names = names 534 self.level = level 535 self.lineno = lineno 536 537 def getChildren(self): 538 return self.modname, self.names, self.level 539 540 def getChildNodes(self): 541 return () 542 543 def __repr__(self): 544 return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level)) 545 546 class Function(Node): 547 def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): 548 self.decorators = decorators 549 self.name = name 550 self.argnames = argnames 551 self.defaults = defaults 552 self.flags = flags 553 self.doc = doc 554 self.code = code 555 self.lineno = lineno 556 self.varargs = self.kwargs = None 557 if flags & CO_VARARGS: 558 self.varargs = 1 559 if flags & CO_VARKEYWORDS: 560 self.kwargs = 1 561 562 563 def getChildren(self): 564 children = [] 565 children.append(self.decorators) 566 children.append(self.name) 567 children.append(self.argnames) 568 children.extend(flatten(self.defaults)) 569 children.append(self.flags) 570 children.append(self.doc) 571 children.append(self.code) 572 return tuple(children) 573 574 def getChildNodes(self): 575 nodelist = [] 576 if self.decorators is not None: 577 nodelist.append(self.decorators) 578 nodelist.extend(flatten_nodes(self.defaults)) 579 nodelist.append(self.code) 580 return tuple(nodelist) 581 582 def __repr__(self): 583 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)) 584 585 class GenExpr(Node): 586 def __init__(self, code, lineno=None): 587 self.code = code 588 self.lineno = lineno 589 self.argnames = ['.0'] 590 self.varargs = self.kwargs = None 591 592 593 def getChildren(self): 594 return self.code, 595 596 def getChildNodes(self): 597 return self.code, 598 599 def __repr__(self): 600 return "GenExpr(%s)" % (repr(self.code),) 601 602 class GenExprFor(Node): 603 def __init__(self, assign, iter, ifs, lineno=None): 604 self.assign = assign 605 self.iter = iter 606 self.ifs = ifs 607 self.lineno = lineno 608 self.is_outmost = False 609 610 def getChildren(self): 611 children = [] 612 children.append(self.assign) 613 children.append(self.iter) 614 children.extend(flatten(self.ifs)) 615 return tuple(children) 616 617 def getChildNodes(self): 618 nodelist = [] 619 nodelist.append(self.assign) 620 nodelist.append(self.iter) 621 nodelist.extend(flatten_nodes(self.ifs)) 622 return tuple(nodelist) 623 624 def __repr__(self): 625 return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs)) 626 627 class GenExprIf(Node): 628 def __init__(self, test, lineno=None): 629 self.test = test 630 self.lineno = lineno 631 632 def getChildren(self): 633 return self.test, 634 635 def getChildNodes(self): 636 return self.test, 637 638 def __repr__(self): 639 return "GenExprIf(%s)" % (repr(self.test),) 640 641 class GenExprInner(Node): 642 def __init__(self, expr, quals, lineno=None): 643 self.expr = expr 644 self.quals = quals 645 self.lineno = lineno 646 647 def getChildren(self): 648 children = [] 649 children.append(self.expr) 650 children.extend(flatten(self.quals)) 651 return tuple(children) 652 653 def getChildNodes(self): 654 nodelist = [] 655 nodelist.append(self.expr) 656 nodelist.extend(flatten_nodes(self.quals)) 657 return tuple(nodelist) 658 659 def __repr__(self): 660 return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals)) 661 662 class Getattr(Node): 663 def __init__(self, expr, attrname, lineno=None): 664 self.expr = expr 665 self.attrname = attrname 666 self.lineno = lineno 667 668 def getChildren(self): 669 return self.expr, self.attrname 670 671 def getChildNodes(self): 672 return self.expr, 673 674 def __repr__(self): 675 return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname)) 676 677 class Global(Node): 678 def __init__(self, names, lineno=None): 679 self.names = names 680 self.lineno = lineno 681 682 def getChildren(self): 683 return self.names, 684 685 def getChildNodes(self): 686 return () 687 688 def __repr__(self): 689 return "Global(%s)" % (repr(self.names),) 690 691 class If(Node): 692 def __init__(self, tests, else_, lineno=None): 693 self.tests = tests 694 self.else_ = else_ 695 self.lineno = lineno 696 697 def getChildren(self): 698 children = [] 699 children.extend(flatten(self.tests)) 700 children.append(self.else_) 701 return tuple(children) 702 703 def getChildNodes(self): 704 nodelist = [] 705 nodelist.extend(flatten_nodes(self.tests)) 706 if self.else_ is not None: 707 nodelist.append(self.else_) 708 return tuple(nodelist) 709 710 def __repr__(self): 711 return "If(%s, %s)" % (repr(self.tests), repr(self.else_)) 712 713 class IfExp(Node): 714 def __init__(self, test, then, else_, lineno=None): 715 self.test = test 716 self.then = then 717 self.else_ = else_ 718 self.lineno = lineno 719 720 def getChildren(self): 721 return self.test, self.then, self.else_ 722 723 def getChildNodes(self): 724 return self.test, self.then, self.else_ 725 726 def __repr__(self): 727 return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_)) 728 729 class Import(Node): 730 def __init__(self, names, lineno=None): 731 self.names = names 732 self.lineno = lineno 733 734 def getChildren(self): 735 return self.names, 736 737 def getChildNodes(self): 738 return () 739 740 def __repr__(self): 741 return "Import(%s)" % (repr(self.names),) 742 743 class Invert(Node): 744 def __init__(self, expr, lineno=None): 745 self.expr = expr 746 self.lineno = lineno 747 748 def getChildren(self): 749 return self.expr, 750 751 def getChildNodes(self): 752 return self.expr, 753 754 def __repr__(self): 755 return "Invert(%s)" % (repr(self.expr),) 756 757 class Keyword(Node): 758 def __init__(self, name, expr, lineno=None): 759 self.name = name 760 self.expr = expr 761 self.lineno = lineno 762 763 def getChildren(self): 764 return self.name, self.expr 765 766 def getChildNodes(self): 767 return self.expr, 768 769 def __repr__(self): 770 return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr)) 771 772 class Lambda(Node): 773 def __init__(self, argnames, defaults, flags, code, lineno=None): 774 self.argnames = argnames 775 self.defaults = defaults 776 self.flags = flags 777 self.code = code 778 self.lineno = lineno 779 self.varargs = self.kwargs = None 780 if flags & CO_VARARGS: 781 self.varargs = 1 782 if flags & CO_VARKEYWORDS: 783 self.kwargs = 1 784 785 786 def getChildren(self): 787 children = [] 788 children.append(self.argnames) 789 children.extend(flatten(self.defaults)) 790 children.append(self.flags) 791 children.append(self.code) 792 return tuple(children) 793 794 def getChildNodes(self): 795 nodelist = [] 796 nodelist.extend(flatten_nodes(self.defaults)) 797 nodelist.append(self.code) 798 return tuple(nodelist) 799 800 def __repr__(self): 801 return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code)) 802 803 class LeftShift(Node): 804 def __init__(self, leftright, lineno=None): 805 self.left = leftright[0] 806 self.right = leftright[1] 807 self.lineno = lineno 808 809 def getChildren(self): 810 return self.left, self.right 811 812 def getChildNodes(self): 813 return self.left, self.right 814 815 def __repr__(self): 816 return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right)) 817 818 class List(Node): 819 def __init__(self, nodes, lineno=None): 820 self.nodes = nodes 821 self.lineno = lineno 822 823 def getChildren(self): 824 return tuple(flatten(self.nodes)) 825 826 def getChildNodes(self): 827 nodelist = [] 828 nodelist.extend(flatten_nodes(self.nodes)) 829 return tuple(nodelist) 830 831 def __repr__(self): 832 return "List(%s)" % (repr(self.nodes),) 833 834 class ListComp(Node): 835 def __init__(self, expr, quals, lineno=None): 836 self.expr = expr 837 self.quals = quals 838 self.lineno = lineno 839 840 def getChildren(self): 841 children = [] 842 children.append(self.expr) 843 children.extend(flatten(self.quals)) 844 return tuple(children) 845 846 def getChildNodes(self): 847 nodelist = [] 848 nodelist.append(self.expr) 849 nodelist.extend(flatten_nodes(self.quals)) 850 return tuple(nodelist) 851 852 def __repr__(self): 853 return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals)) 854 855 class ListCompFor(Node): 856 def __init__(self, assign, list, ifs, lineno=None): 857 self.assign = assign 858 self.list = list 859 self.ifs = ifs 860 self.lineno = lineno 861 862 def getChildren(self): 863 children = [] 864 children.append(self.assign) 865 children.append(self.list) 866 children.extend(flatten(self.ifs)) 867 return tuple(children) 868 869 def getChildNodes(self): 870 nodelist = [] 871 nodelist.append(self.assign) 872 nodelist.append(self.list) 873 nodelist.extend(flatten_nodes(self.ifs)) 874 return tuple(nodelist) 875 876 def __repr__(self): 877 return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs)) 878 879 class ListCompIf(Node): 880 def __init__(self, test, lineno=None): 881 self.test = test 882 self.lineno = lineno 883 884 def getChildren(self): 885 return self.test, 886 887 def getChildNodes(self): 888 return self.test, 889 890 def __repr__(self): 891 return "ListCompIf(%s)" % (repr(self.test),) 892 893 class Mod(Node): 894 def __init__(self, leftright, lineno=None): 895 self.left = leftright[0] 896 self.right = leftright[1] 897 self.lineno = lineno 898 899 def getChildren(self): 900 return self.left, self.right 901 902 def getChildNodes(self): 903 return self.left, self.right 904 905 def __repr__(self): 906 return "Mod((%s, %s))" % (repr(self.left), repr(self.right)) 907 908 class Module(Node): 909 def __init__(self, doc, node, lineno=None): 910 self.doc = doc 911 self.node = node 912 self.lineno = lineno 913 914 def getChildren(self): 915 return self.doc, self.node 916 917 def getChildNodes(self): 918 return self.node, 919 920 def __repr__(self): 921 return "Module(%s, %s)" % (repr(self.doc), repr(self.node)) 922 923 class Mul(Node): 924 def __init__(self, leftright, lineno=None): 925 self.left = leftright[0] 926 self.right = leftright[1] 927 self.lineno = lineno 928 929 def getChildren(self): 930 return self.left, self.right 931 932 def getChildNodes(self): 933 return self.left, self.right 934 935 def __repr__(self): 936 return "Mul((%s, %s))" % (repr(self.left), repr(self.right)) 937 938 class Name(Node): 939 def __init__(self, name, lineno=None): 940 self.name = name 941 self.lineno = lineno 942 943 def getChildren(self): 944 return self.name, 945 946 def getChildNodes(self): 947 return () 948 949 def __repr__(self): 950 return "Name(%s)" % (repr(self.name),) 951 952 class Not(Node): 953 def __init__(self, expr, lineno=None): 954 self.expr = expr 955 self.lineno = lineno 956 957 def getChildren(self): 958 return self.expr, 959 960 def getChildNodes(self): 961 return self.expr, 962 963 def __repr__(self): 964 return "Not(%s)" % (repr(self.expr),) 965 966 class Or(Node): 967 def __init__(self, nodes, lineno=None): 968 self.nodes = nodes 969 self.lineno = lineno 970 971 def getChildren(self): 972 return tuple(flatten(self.nodes)) 973 974 def getChildNodes(self): 975 nodelist = [] 976 nodelist.extend(flatten_nodes(self.nodes)) 977 return tuple(nodelist) 978 979 def __repr__(self): 980 return "Or(%s)" % (repr(self.nodes),) 981 982 class Pass(Node): 983 def __init__(self, lineno=None): 984 self.lineno = lineno 985 986 def getChildren(self): 987 return () 988 989 def getChildNodes(self): 990 return () 991 992 def __repr__(self): 993 return "Pass()" 994 995 class Power(Node): 996 def __init__(self, leftright, lineno=None): 997 self.left = leftright[0] 998 self.right = leftright[1] 999 self.lineno = lineno 1000 1001 def getChildren(self): 1002 return self.left, self.right 1003 1004 def getChildNodes(self): 1005 return self.left, self.right 1006 1007 def __repr__(self): 1008 return "Power((%s, %s))" % (repr(self.left), repr(self.right)) 1009 1010 class Print(Node): 1011 def __init__(self, nodes, dest, lineno=None): 1012 self.nodes = nodes 1013 self.dest = dest 1014 self.lineno = lineno 1015 1016 def getChildren(self): 1017 children = [] 1018 children.extend(flatten(self.nodes)) 1019 children.append(self.dest) 1020 return tuple(children) 1021 1022 def getChildNodes(self): 1023 nodelist = [] 1024 nodelist.extend(flatten_nodes(self.nodes)) 1025 if self.dest is not None: 1026 nodelist.append(self.dest) 1027 return tuple(nodelist) 1028 1029 def __repr__(self): 1030 return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest)) 1031 1032 class Printnl(Node): 1033 def __init__(self, nodes, dest, lineno=None): 1034 self.nodes = nodes 1035 self.dest = dest 1036 self.lineno = lineno 1037 1038 def getChildren(self): 1039 children = [] 1040 children.extend(flatten(self.nodes)) 1041 children.append(self.dest) 1042 return tuple(children) 1043 1044 def getChildNodes(self): 1045 nodelist = [] 1046 nodelist.extend(flatten_nodes(self.nodes)) 1047 if self.dest is not None: 1048 nodelist.append(self.dest) 1049 return tuple(nodelist) 1050 1051 def __repr__(self): 1052 return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest)) 1053 1054 class Raise(Node): 1055 def __init__(self, expr1, expr2, expr3, lineno=None): 1056 self.expr1 = expr1 1057 self.expr2 = expr2 1058 self.expr3 = expr3 1059 self.lineno = lineno 1060 1061 def getChildren(self): 1062 children = [] 1063 children.append(self.expr1) 1064 children.append(self.expr2) 1065 children.append(self.expr3) 1066 return tuple(children) 1067 1068 def getChildNodes(self): 1069 nodelist = [] 1070 if self.expr1 is not None: 1071 nodelist.append(self.expr1) 1072 if self.expr2 is not None: 1073 nodelist.append(self.expr2) 1074 if self.expr3 is not None: 1075 nodelist.append(self.expr3) 1076 return tuple(nodelist) 1077 1078 def __repr__(self): 1079 return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3)) 1080 1081 class Return(Node): 1082 def __init__(self, value, lineno=None): 1083 self.value = value 1084 self.lineno = lineno 1085 1086 def getChildren(self): 1087 return self.value, 1088 1089 def getChildNodes(self): 1090 return self.value, 1091 1092 def __repr__(self): 1093 return "Return(%s)" % (repr(self.value),) 1094 1095 class RightShift(Node): 1096 def __init__(self, leftright, lineno=None): 1097 self.left = leftright[0] 1098 self.right = leftright[1] 1099 self.lineno = lineno 1100 1101 def getChildren(self): 1102 return self.left, self.right 1103 1104 def getChildNodes(self): 1105 return self.left, self.right 1106 1107 def __repr__(self): 1108 return "RightShift((%s, %s))" % (repr(self.left), repr(self.right)) 1109 1110 class Slice(Node): 1111 def __init__(self, expr, flags, lower, upper, lineno=None): 1112 self.expr = expr 1113 self.flags = flags 1114 self.lower = lower 1115 self.upper = upper 1116 self.lineno = lineno 1117 1118 def getChildren(self): 1119 children = [] 1120 children.append(self.expr) 1121 children.append(self.flags) 1122 children.append(self.lower) 1123 children.append(self.upper) 1124 return tuple(children) 1125 1126 def getChildNodes(self): 1127 nodelist = [] 1128 nodelist.append(self.expr) 1129 if self.lower is not None: 1130 nodelist.append(self.lower) 1131 if self.upper is not None: 1132 nodelist.append(self.upper) 1133 return tuple(nodelist) 1134 1135 def __repr__(self): 1136 return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper)) 1137 1138 class Sliceobj(Node): 1139 def __init__(self, nodes, lineno=None): 1140 self.nodes = nodes 1141 self.lineno = lineno 1142 1143 def getChildren(self): 1144 return tuple(flatten(self.nodes)) 1145 1146 def getChildNodes(self): 1147 nodelist = [] 1148 nodelist.extend(flatten_nodes(self.nodes)) 1149 return tuple(nodelist) 1150 1151 def __repr__(self): 1152 return "Sliceobj(%s)" % (repr(self.nodes),) 1153 1154 class Stmt(Node): 1155 def __init__(self, nodes, lineno=None): 1156 self.nodes = nodes 1157 self.lineno = lineno 1158 1159 def getChildren(self): 1160 return tuple(flatten(self.nodes)) 1161 1162 def getChildNodes(self): 1163 nodelist = [] 1164 nodelist.extend(flatten_nodes(self.nodes)) 1165 return tuple(nodelist) 1166 1167 def __repr__(self): 1168 return "Stmt(%s)" % (repr(self.nodes),) 1169 1170 class Sub(Node): 1171 def __init__(self, leftright, lineno=None): 1172 self.left = leftright[0] 1173 self.right = leftright[1] 1174 self.lineno = lineno 1175 1176 def getChildren(self): 1177 return self.left, self.right 1178 1179 def getChildNodes(self): 1180 return self.left, self.right 1181 1182 def __repr__(self): 1183 return "Sub((%s, %s))" % (repr(self.left), repr(self.right)) 1184 1185 class Subscript(Node): 1186 def __init__(self, expr, flags, subs, lineno=None): 1187 self.expr = expr 1188 self.flags = flags 1189 self.subs = subs 1190 self.lineno = lineno 1191 1192 def getChildren(self): 1193 children = [] 1194 children.append(self.expr) 1195 children.append(self.flags) 1196 children.extend(flatten(self.subs)) 1197 return tuple(children) 1198 1199 def getChildNodes(self): 1200 nodelist = [] 1201 nodelist.append(self.expr) 1202 nodelist.extend(flatten_nodes(self.subs)) 1203 return tuple(nodelist) 1204 1205 def __repr__(self): 1206 return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs)) 1207 1208 class TryExcept(Node): 1209 def __init__(self, body, handlers, else_, lineno=None): 1210 self.body = body 1211 self.handlers = handlers 1212 self.else_ = else_ 1213 self.lineno = lineno 1214 1215 def getChildren(self): 1216 children = [] 1217 children.append(self.body) 1218 children.extend(flatten(self.handlers)) 1219 children.append(self.else_) 1220 return tuple(children) 1221 1222 def getChildNodes(self): 1223 nodelist = [] 1224 nodelist.append(self.body) 1225 nodelist.extend(flatten_nodes(self.handlers)) 1226 if self.else_ is not None: 1227 nodelist.append(self.else_) 1228 return tuple(nodelist) 1229 1230 def __repr__(self): 1231 return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_)) 1232 1233 class TryFinally(Node): 1234 def __init__(self, body, final, lineno=None): 1235 self.body = body 1236 self.final = final 1237 self.lineno = lineno 1238 1239 def getChildren(self): 1240 return self.body, self.final 1241 1242 def getChildNodes(self): 1243 return self.body, self.final 1244 1245 def __repr__(self): 1246 return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final)) 1247 1248 class Tuple(Node): 1249 def __init__(self, nodes, lineno=None): 1250 self.nodes = nodes 1251 self.lineno = lineno 1252 1253 def getChildren(self): 1254 return tuple(flatten(self.nodes)) 1255 1256 def getChildNodes(self): 1257 nodelist = [] 1258 nodelist.extend(flatten_nodes(self.nodes)) 1259 return tuple(nodelist) 1260 1261 def __repr__(self): 1262 return "Tuple(%s)" % (repr(self.nodes),) 1263 1264 class UnaryAdd(Node): 1265 def __init__(self, expr, lineno=None): 1266 self.expr = expr 1267 self.lineno = lineno 1268 1269 def getChildren(self): 1270 return self.expr, 1271 1272 def getChildNodes(self): 1273 return self.expr, 1274 1275 def __repr__(self): 1276 return "UnaryAdd(%s)" % (repr(self.expr),) 1277 1278 class UnarySub(Node): 1279 def __init__(self, expr, lineno=None): 1280 self.expr = expr 1281 self.lineno = lineno 1282 1283 def getChildren(self): 1284 return self.expr, 1285 1286 def getChildNodes(self): 1287 return self.expr, 1288 1289 def __repr__(self): 1290 return "UnarySub(%s)" % (repr(self.expr),) 1291 1292 class While(Node): 1293 def __init__(self, test, body, else_, lineno=None): 1294 self.test = test 1295 self.body = body 1296 self.else_ = else_ 1297 self.lineno = lineno 1298 1299 def getChildren(self): 1300 children = [] 1301 children.append(self.test) 1302 children.append(self.body) 1303 children.append(self.else_) 1304 return tuple(children) 1305 1306 def getChildNodes(self): 1307 nodelist = [] 1308 nodelist.append(self.test) 1309 nodelist.append(self.body) 1310 if self.else_ is not None: 1311 nodelist.append(self.else_) 1312 return tuple(nodelist) 1313 1314 def __repr__(self): 1315 return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_)) 1316 1317 class With(Node): 1318 def __init__(self, expr, vars, body, lineno=None): 1319 self.expr = expr 1320 self.vars = vars 1321 self.body = body 1322 self.lineno = lineno 1323 1324 def getChildren(self): 1325 children = [] 1326 children.append(self.expr) 1327 children.append(self.vars) 1328 children.append(self.body) 1329 return tuple(children) 1330 1331 def getChildNodes(self): 1332 nodelist = [] 1333 nodelist.append(self.expr) 1334 if self.vars is not None: 1335 nodelist.append(self.vars) 1336 nodelist.append(self.body) 1337 return tuple(nodelist) 1338 1339 def __repr__(self): 1340 return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body)) 1341 1342 class Yield(Node): 1343 def __init__(self, value, lineno=None): 1344 self.value = value 1345 self.lineno = lineno 1346 1347 def getChildren(self): 1348 return self.value, 1349 1350 def getChildNodes(self): 1351 return self.value, 1352 1353 def __repr__(self): 1354 return "Yield(%s)" % (repr(self.value),) 1355 1356 for name, obj in globals().items(): 1357 if isinstance(obj, type) and issubclass(obj, Node): 1358 nodes[name.lower()] = obj