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